wxPython/src/msw/image.cpp

   1 /*
   2  * FILE : src/msw/image.cpp
   3  *
   4  * This file was automatically generated by :
   5  * Simplified Wrapper and Interface Generator (SWIG)
   6  * Version 1.1 (Build 883)
   7  *
   8  * Portions Copyright (c) 1995-1998
   9  * The University of Utah and The Regents of the University of California.
  10  * Permission is granted to distribute this file in any manner provided
  11  * this notice remains intact.
  12  *
  13  * Do not make changes to this file--changes will be lost!
  14  *
  15  */
  16
  17
  18 #define SWIGCODE
  19 /* Implementation : PYTHON */
  20
  21 #define SWIGPYTHON
  22 #include <string.h>
  23 #include <stdlib.h>
  24 /* Definitions for Windows/Unix exporting */
  25 #if defined(__WIN32__)
  26 #   if defined(_MSC_VER)
  27 #       define SWIGEXPORT(a) __declspec(dllexport) a
  28 #   else
  29 #       if defined(__BORLANDC__)
  30 #           define SWIGEXPORT(a) a _export
  31 #       else
  32 #           define SWIGEXPORT(a) a
  33 #       endif
  34 #   endif
  35 #else
  36 #   define SWIGEXPORT(a) a
  37 #endif
  38
  39 #include "Python.h"
  40
  41 #ifdef __cplusplus
  42 extern "C" {
  43 #endif
  44
  45 extern void SWIG_MakePtr(char *, void *, char *);
  46 extern void SWIG_RegisterMapping(char *, char *, void *(*)(void *));
  47 extern char *SWIG_GetPtr(char *, void **, char *);
  48 extern char *SWIG_GetPtrObj(PyObject *, void **, char *);
  49 extern void SWIG_addvarlink(PyObject *, char *, PyObject *(*)(void), int (*)(PyObject *));
  50 extern PyObject *SWIG_newvarlink(void);
  51 #ifdef __cplusplus
  52 }
  53 #endif
  54 #define SWIG_init    initimagec
  55
  56 #define SWIG_name    "imagec"
  57
  58 #include "helpers.h"
  59 #include <wx/image.h>
  60
  61 static PyObject* l_output_helper(PyObject* target, PyObject* o) {
  62     PyObject*   o2;
  63     if (!target) {
  64         target = o;
  65     } else if (target == Py_None) {
  66         Py_DECREF(Py_None);
  67         target = o;
  68     } else {
  69         if (!PyList_Check(target)) {
  70             o2 = target;
  71             target = PyList_New(0);
  72             PyList_Append(target, o2);
  73             Py_XDECREF(o2);
  74         }
  75         PyList_Append(target,o);
  76         Py_XDECREF(o);
  77     }
  78     return target;
  79 }
  80
  81 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
  82     PyObject*   o2;
  83     PyObject*   o3;
  84
  85     if (!target) {
  86         target = o;
  87     } else if (target == Py_None) {
  88         Py_DECREF(Py_None);
  89         target = o;
  90     } else {
  91         if (!PyTuple_Check(target)) {
  92             o2 = target;
  93             target = PyTuple_New(1);
  94             PyTuple_SetItem(target, 0, o2);
  95         }
  96         o3 = PyTuple_New(1);
  97         PyTuple_SetItem(o3, 0, o);
  98
  99         o2 = target;
 100         target = PySequence_Concat(o2, o3);
 101         Py_DECREF(o2);
 102         Py_DECREF(o3);
 103     }
 104     return target;
 105 }
 106
 107 #if PYTHON_API_VERSION >= 1009
 108     static char* wxStringErrorMsg = "String or Unicode type required";
 109 #else
 110     static char* wxStringErrorMsg = "string type is required for parameter";
 111 #endif
 112
 113     wxImage* wxEmptyImage(int width=0, int height=0) {
 114         if (width == 0 && height == 0)
 115             return new wxImage;
 116         else
 117             return new wxImage(width, height);
 118     }
 119
 120     wxImage* wxImageFromMime(const wxString& name, const wxString& mimetype) {
 121         return new wxImage(name, mimetype);
 122     }
 123
 124     wxImage* wxImageFromBitmap(const wxBitmap &bitmap) {
 125         return new wxImage(bitmap);
 126     }
 127
 128 #if 0
 129 extern wxImage  wxNullImage;
 130
 131 #endif
 132
 133     wxBitmap* wxBitmapFromImage(const wxImage& img, int depth=-1) {
 134         return new wxBitmap(img, depth);
 135     }
 136
 137 #ifdef __cplusplus
 138 extern "C" {
 139 #endif
 140 static PyObject *_wrap_wxEmptyImage(PyObject *self, PyObject *args, PyObject *kwargs) {
 141     PyObject * _resultobj;
 142     wxImage * _result;
 143     int  _arg0 = (int ) 0;
 144     int  _arg1 = (int ) 0;
 145     char *_kwnames[] = { "width","height", NULL };
 146     char _ptemp[128];
 147
 148     self = self;
 149     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"|ii:wxEmptyImage",_kwnames,&_arg0,&_arg1))
 150         return NULL;
 151 {
 152     wxPy_BEGIN_ALLOW_THREADS;
 153         _result = (wxImage *)wxEmptyImage(_arg0,_arg1);
 154
 155     wxPy_END_ALLOW_THREADS;
 156 }    if (_result) {
 157         SWIG_MakePtr(_ptemp, (char *) _result,"_wxImage_p");
 158         _resultobj = Py_BuildValue("s",_ptemp);
 159     } else {
 160         Py_INCREF(Py_None);
 161         _resultobj = Py_None;
 162     }
 163     return _resultobj;
 164 }
 165
 166 static PyObject *_wrap_wxImageFromMime(PyObject *self, PyObject *args, PyObject *kwargs) {
 167     PyObject * _resultobj;
 168     wxImage * _result;
 169     wxString * _arg0;
 170     wxString * _arg1;
 171     PyObject * _obj0 = 0;
 172     PyObject * _obj1 = 0;
 173     char *_kwnames[] = { "name","mimetype", NULL };
 174     char _ptemp[128];
 175
 176     self = self;
 177     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxImageFromMime",_kwnames,&_obj0,&_obj1))
 178         return NULL;
 179 {
 180 #if PYTHON_API_VERSION >= 1009
 181     char* tmpPtr; int tmpSize;
 182     if (!PyString_Check(_obj0) && !PyUnicode_Check(_obj0)) {
 183         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
 184         return NULL;
 185     }
 186     if (PyString_AsStringAndSize(_obj0, &tmpPtr, &tmpSize) == -1)
 187         return NULL;
 188     _arg0 = new wxString(tmpPtr, tmpSize);
 189 #else
 190     if (!PyString_Check(_obj0)) {
 191         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
 192         return NULL;
 193     }
 194     _arg0 = new wxString(PyString_AS_STRING(_obj0), PyString_GET_SIZE(_obj0));
 195 #endif
 196 }
 197 {
 198 #if PYTHON_API_VERSION >= 1009
 199     char* tmpPtr; int tmpSize;
 200     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
 201         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
 202         return NULL;
 203     }
 204     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
 205         return NULL;
 206     _arg1 = new wxString(tmpPtr, tmpSize);
 207 #else
 208     if (!PyString_Check(_obj1)) {
 209         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
 210         return NULL;
 211     }
 212     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
 213 #endif
 214 }
 215 {
 216     wxPy_BEGIN_ALLOW_THREADS;
 217         _result = (wxImage *)wxImageFromMime(*_arg0,*_arg1);
 218
 219     wxPy_END_ALLOW_THREADS;
 220 }    if (_result) {
 221         SWIG_MakePtr(_ptemp, (char *) _result,"_wxImage_p");
 222         _resultobj = Py_BuildValue("s",_ptemp);
 223     } else {
 224         Py_INCREF(Py_None);
 225         _resultobj = Py_None;
 226     }
 227 {
 228     if (_obj0)
 229         delete _arg0;
 230 }
 231 {
 232     if (_obj1)
 233         delete _arg1;
 234 }
 235     return _resultobj;
 236 }
 237
 238 static PyObject *_wrap_wxImageFromBitmap(PyObject *self, PyObject *args, PyObject *kwargs) {
 239     PyObject * _resultobj;
 240     wxImage * _result;
 241     wxBitmap * _arg0;
 242     PyObject * _argo0 = 0;
 243     char *_kwnames[] = { "bitmap", NULL };
 244     char _ptemp[128];
 245
 246     self = self;
 247     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImageFromBitmap",_kwnames,&_argo0))
 248         return NULL;
 249     if (_argo0) {
 250         if (_argo0 == Py_None) { _arg0 = NULL; }
 251         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxBitmap_p")) {
 252             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImageFromBitmap. Expected _wxBitmap_p.");
 253         return NULL;
 254         }
 255     }
 256 {
 257     wxPy_BEGIN_ALLOW_THREADS;
 258         _result = (wxImage *)wxImageFromBitmap(*_arg0);
 259
 260     wxPy_END_ALLOW_THREADS;
 261 }    if (_result) {
 262         SWIG_MakePtr(_ptemp, (char *) _result,"_wxImage_p");
 263         _resultobj = Py_BuildValue("s",_ptemp);
 264     } else {
 265         Py_INCREF(Py_None);
 266         _resultobj = Py_None;
 267     }
 268     return _resultobj;
 269 }
 270
 271 static PyObject *_wrap_wxInitAllImageHandlers(PyObject *self, PyObject *args, PyObject *kwargs) {
 272     PyObject * _resultobj;
 273     char *_kwnames[] = {  NULL };
 274
 275     self = self;
 276     if(!PyArg_ParseTupleAndKeywords(args,kwargs,":wxInitAllImageHandlers",_kwnames))
 277         return NULL;
 278 {
 279     wxPy_BEGIN_ALLOW_THREADS;
 280         wxInitAllImageHandlers();
 281
 282     wxPy_END_ALLOW_THREADS;
 283 }    Py_INCREF(Py_None);
 284     _resultobj = Py_None;
 285     return _resultobj;
 286 }
 287
 288 static int _wrap_wxNullImage_set(PyObject *val) {
 289
 290     PyErr_SetString(PyExc_TypeError,"Variable wxNullImage is read-only.");
 291     return 1;
 292 }
 293
 294 static PyObject *_wrap_wxNullImage_get() {
 295     PyObject * pyobj;
 296     char ptemp[128];
 297
 298     SWIG_MakePtr(ptemp,(char *) &wxNullImage,"_wxImage_p");
 299     pyobj = PyString_FromString(ptemp);
 300     return pyobj;
 301 }
 302
 303 static PyObject *_wrap_wxBitmapFromImage(PyObject *self, PyObject *args, PyObject *kwargs) {
 304     PyObject * _resultobj;
 305     wxBitmap * _result;
 306     wxImage * _arg0;
 307     int  _arg1 = (int ) -1;
 308     PyObject * _argo0 = 0;
 309     char *_kwnames[] = { "img","depth", NULL };
 310     char _ptemp[128];
 311
 312     self = self;
 313     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|i:wxBitmapFromImage",_kwnames,&_argo0,&_arg1))
 314         return NULL;
 315     if (_argo0) {
 316         if (_argo0 == Py_None) { _arg0 = NULL; }
 317         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
 318             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxBitmapFromImage. Expected _wxImage_p.");
 319         return NULL;
 320         }
 321     }
 322 {
 323     wxPy_BEGIN_ALLOW_THREADS;
 324         _result = (wxBitmap *)wxBitmapFromImage(*_arg0,_arg1);
 325
 326     wxPy_END_ALLOW_THREADS;
 327 }    if (_result) {
 328         SWIG_MakePtr(_ptemp, (char *) _result,"_wxBitmap_p");
 329         _resultobj = Py_BuildValue("s",_ptemp);
 330     } else {
 331         Py_INCREF(Py_None);
 332         _resultobj = Py_None;
 333     }
 334     return _resultobj;
 335 }
 336
 337 static void *SwigwxImageHandlerTowxObject(void *ptr) {
 338     wxImageHandler *src;
 339     wxObject *dest;
 340     src = (wxImageHandler *) ptr;
 341     dest = (wxObject *) src;
 342     return (void *) dest;
 343 }
 344
 345 #define wxImageHandler_GetName(_swigobj)  (_swigobj->GetName())
 346 static PyObject *_wrap_wxImageHandler_GetName(PyObject *self, PyObject *args, PyObject *kwargs) {
 347     PyObject * _resultobj;
 348     wxString * _result;
 349     wxImageHandler * _arg0;
 350     PyObject * _argo0 = 0;
 351     char *_kwnames[] = { "self", NULL };
 352
 353     self = self;
 354     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImageHandler_GetName",_kwnames,&_argo0))
 355         return NULL;
 356     if (_argo0) {
 357         if (_argo0 == Py_None) { _arg0 = NULL; }
 358         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImageHandler_p")) {
 359             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImageHandler_GetName. Expected _wxImageHandler_p.");
 360         return NULL;
 361         }
 362     }
 363 {
 364     wxPy_BEGIN_ALLOW_THREADS;
 365         _result = new wxString (wxImageHandler_GetName(_arg0));
 366
 367     wxPy_END_ALLOW_THREADS;
 368 }{
 369     _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
 370 }
 371 {
 372     delete _result;
 373 }
 374     return _resultobj;
 375 }
 376
 377 #define wxImageHandler_GetExtension(_swigobj)  (_swigobj->GetExtension())
 378 static PyObject *_wrap_wxImageHandler_GetExtension(PyObject *self, PyObject *args, PyObject *kwargs) {
 379     PyObject * _resultobj;
 380     wxString * _result;
 381     wxImageHandler * _arg0;
 382     PyObject * _argo0 = 0;
 383     char *_kwnames[] = { "self", NULL };
 384
 385     self = self;
 386     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImageHandler_GetExtension",_kwnames,&_argo0))
 387         return NULL;
 388     if (_argo0) {
 389         if (_argo0 == Py_None) { _arg0 = NULL; }
 390         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImageHandler_p")) {
 391             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImageHandler_GetExtension. Expected _wxImageHandler_p.");
 392         return NULL;
 393         }
 394     }
 395 {
 396     wxPy_BEGIN_ALLOW_THREADS;
 397         _result = new wxString (wxImageHandler_GetExtension(_arg0));
 398
 399     wxPy_END_ALLOW_THREADS;
 400 }{
 401     _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
 402 }
 403 {
 404     delete _result;
 405 }
 406     return _resultobj;
 407 }
 408
 409 #define wxImageHandler_GetType(_swigobj)  (_swigobj->GetType())
 410 static PyObject *_wrap_wxImageHandler_GetType(PyObject *self, PyObject *args, PyObject *kwargs) {
 411     PyObject * _resultobj;
 412     long  _result;
 413     wxImageHandler * _arg0;
 414     PyObject * _argo0 = 0;
 415     char *_kwnames[] = { "self", NULL };
 416
 417     self = self;
 418     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImageHandler_GetType",_kwnames,&_argo0))
 419         return NULL;
 420     if (_argo0) {
 421         if (_argo0 == Py_None) { _arg0 = NULL; }
 422         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImageHandler_p")) {
 423             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImageHandler_GetType. Expected _wxImageHandler_p.");
 424         return NULL;
 425         }
 426     }
 427 {
 428     wxPy_BEGIN_ALLOW_THREADS;
 429         _result = (long )wxImageHandler_GetType(_arg0);
 430
 431     wxPy_END_ALLOW_THREADS;
 432 }    _resultobj = Py_BuildValue("l",_result);
 433     return _resultobj;
 434 }
 435
 436 #define wxImageHandler_GetMimeType(_swigobj)  (_swigobj->GetMimeType())
 437 static PyObject *_wrap_wxImageHandler_GetMimeType(PyObject *self, PyObject *args, PyObject *kwargs) {
 438     PyObject * _resultobj;
 439     wxString * _result;
 440     wxImageHandler * _arg0;
 441     PyObject * _argo0 = 0;
 442     char *_kwnames[] = { "self", NULL };
 443
 444     self = self;
 445     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImageHandler_GetMimeType",_kwnames,&_argo0))
 446         return NULL;
 447     if (_argo0) {
 448         if (_argo0 == Py_None) { _arg0 = NULL; }
 449         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImageHandler_p")) {
 450             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImageHandler_GetMimeType. Expected _wxImageHandler_p.");
 451         return NULL;
 452         }
 453     }
 454 {
 455     wxPy_BEGIN_ALLOW_THREADS;
 456         _result = new wxString (wxImageHandler_GetMimeType(_arg0));
 457
 458     wxPy_END_ALLOW_THREADS;
 459 }{
 460     _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
 461 }
 462 {
 463     delete _result;
 464 }
 465     return _resultobj;
 466 }
 467
 468 #define wxImageHandler_SetName(_swigobj,_swigarg0)  (_swigobj->SetName(_swigarg0))
 469 static PyObject *_wrap_wxImageHandler_SetName(PyObject *self, PyObject *args, PyObject *kwargs) {
 470     PyObject * _resultobj;
 471     wxImageHandler * _arg0;
 472     wxString * _arg1;
 473     PyObject * _argo0 = 0;
 474     PyObject * _obj1 = 0;
 475     char *_kwnames[] = { "self","name", NULL };
 476
 477     self = self;
 478     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxImageHandler_SetName",_kwnames,&_argo0,&_obj1))
 479         return NULL;
 480     if (_argo0) {
 481         if (_argo0 == Py_None) { _arg0 = NULL; }
 482         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImageHandler_p")) {
 483             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImageHandler_SetName. Expected _wxImageHandler_p.");
 484         return NULL;
 485         }
 486     }
 487 {
 488 #if PYTHON_API_VERSION >= 1009
 489     char* tmpPtr; int tmpSize;
 490     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
 491         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
 492         return NULL;
 493     }
 494     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
 495         return NULL;
 496     _arg1 = new wxString(tmpPtr, tmpSize);
 497 #else
 498     if (!PyString_Check(_obj1)) {
 499         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
 500         return NULL;
 501     }
 502     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
 503 #endif
 504 }
 505 {
 506     wxPy_BEGIN_ALLOW_THREADS;
 507         wxImageHandler_SetName(_arg0,*_arg1);
 508
 509     wxPy_END_ALLOW_THREADS;
 510 }    Py_INCREF(Py_None);
 511     _resultobj = Py_None;
 512 {
 513     if (_obj1)
 514         delete _arg1;
 515 }
 516     return _resultobj;
 517 }
 518
 519 #define wxImageHandler_SetExtension(_swigobj,_swigarg0)  (_swigobj->SetExtension(_swigarg0))
 520 static PyObject *_wrap_wxImageHandler_SetExtension(PyObject *self, PyObject *args, PyObject *kwargs) {
 521     PyObject * _resultobj;
 522     wxImageHandler * _arg0;
 523     wxString * _arg1;
 524     PyObject * _argo0 = 0;
 525     PyObject * _obj1 = 0;
 526     char *_kwnames[] = { "self","extension", NULL };
 527
 528     self = self;
 529     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxImageHandler_SetExtension",_kwnames,&_argo0,&_obj1))
 530         return NULL;
 531     if (_argo0) {
 532         if (_argo0 == Py_None) { _arg0 = NULL; }
 533         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImageHandler_p")) {
 534             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImageHandler_SetExtension. Expected _wxImageHandler_p.");
 535         return NULL;
 536         }
 537     }
 538 {
 539 #if PYTHON_API_VERSION >= 1009
 540     char* tmpPtr; int tmpSize;
 541     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
 542         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
 543         return NULL;
 544     }
 545     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
 546         return NULL;
 547     _arg1 = new wxString(tmpPtr, tmpSize);
 548 #else
 549     if (!PyString_Check(_obj1)) {
 550         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
 551         return NULL;
 552     }
 553     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
 554 #endif
 555 }
 556 {
 557     wxPy_BEGIN_ALLOW_THREADS;
 558         wxImageHandler_SetExtension(_arg0,*_arg1);
 559
 560     wxPy_END_ALLOW_THREADS;
 561 }    Py_INCREF(Py_None);
 562     _resultobj = Py_None;
 563 {
 564     if (_obj1)
 565         delete _arg1;
 566 }
 567     return _resultobj;
 568 }
 569
 570 #define wxImageHandler_SetType(_swigobj,_swigarg0)  (_swigobj->SetType(_swigarg0))
 571 static PyObject *_wrap_wxImageHandler_SetType(PyObject *self, PyObject *args, PyObject *kwargs) {
 572     PyObject * _resultobj;
 573     wxImageHandler * _arg0;
 574     long  _arg1;
 575     PyObject * _argo0 = 0;
 576     char *_kwnames[] = { "self","type", NULL };
 577
 578     self = self;
 579     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Ol:wxImageHandler_SetType",_kwnames,&_argo0,&_arg1))
 580         return NULL;
 581     if (_argo0) {
 582         if (_argo0 == Py_None) { _arg0 = NULL; }
 583         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImageHandler_p")) {
 584             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImageHandler_SetType. Expected _wxImageHandler_p.");
 585         return NULL;
 586         }
 587     }
 588 {
 589     wxPy_BEGIN_ALLOW_THREADS;
 590         wxImageHandler_SetType(_arg0,_arg1);
 591
 592     wxPy_END_ALLOW_THREADS;
 593 }    Py_INCREF(Py_None);
 594     _resultobj = Py_None;
 595     return _resultobj;
 596 }
 597
 598 #define wxImageHandler_SetMimeType(_swigobj,_swigarg0)  (_swigobj->SetMimeType(_swigarg0))
 599 static PyObject *_wrap_wxImageHandler_SetMimeType(PyObject *self, PyObject *args, PyObject *kwargs) {
 600     PyObject * _resultobj;
 601     wxImageHandler * _arg0;
 602     wxString * _arg1;
 603     PyObject * _argo0 = 0;
 604     PyObject * _obj1 = 0;
 605     char *_kwnames[] = { "self","mimetype", NULL };
 606
 607     self = self;
 608     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxImageHandler_SetMimeType",_kwnames,&_argo0,&_obj1))
 609         return NULL;
 610     if (_argo0) {
 611         if (_argo0 == Py_None) { _arg0 = NULL; }
 612         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImageHandler_p")) {
 613             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImageHandler_SetMimeType. Expected _wxImageHandler_p.");
 614         return NULL;
 615         }
 616     }
 617 {
 618 #if PYTHON_API_VERSION >= 1009
 619     char* tmpPtr; int tmpSize;
 620     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
 621         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
 622         return NULL;
 623     }
 624     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
 625         return NULL;
 626     _arg1 = new wxString(tmpPtr, tmpSize);
 627 #else
 628     if (!PyString_Check(_obj1)) {
 629         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
 630         return NULL;
 631     }
 632     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
 633 #endif
 634 }
 635 {
 636     wxPy_BEGIN_ALLOW_THREADS;
 637         wxImageHandler_SetMimeType(_arg0,*_arg1);
 638
 639     wxPy_END_ALLOW_THREADS;
 640 }    Py_INCREF(Py_None);
 641     _resultobj = Py_None;
 642 {
 643     if (_obj1)
 644         delete _arg1;
 645 }
 646     return _resultobj;
 647 }
 648
 649 static void *SwigwxPNGHandlerTowxImageHandler(void *ptr) {
 650     wxPNGHandler *src;
 651     wxImageHandler *dest;
 652     src = (wxPNGHandler *) ptr;
 653     dest = (wxImageHandler *) src;
 654     return (void *) dest;
 655 }
 656
 657 static void *SwigwxPNGHandlerTowxObject(void *ptr) {
 658     wxPNGHandler *src;
 659     wxObject *dest;
 660     src = (wxPNGHandler *) ptr;
 661     dest = (wxObject *) src;
 662     return (void *) dest;
 663 }
 664
 665 #define new_wxPNGHandler() (new wxPNGHandler())
 666 static PyObject *_wrap_new_wxPNGHandler(PyObject *self, PyObject *args, PyObject *kwargs) {
 667     PyObject * _resultobj;
 668     wxPNGHandler * _result;
 669     char *_kwnames[] = {  NULL };
 670     char _ptemp[128];
 671
 672     self = self;
 673     if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxPNGHandler",_kwnames))
 674         return NULL;
 675 {
 676     wxPy_BEGIN_ALLOW_THREADS;
 677         _result = (wxPNGHandler *)new_wxPNGHandler();
 678
 679     wxPy_END_ALLOW_THREADS;
 680 }    if (_result) {
 681         SWIG_MakePtr(_ptemp, (char *) _result,"_wxPNGHandler_p");
 682         _resultobj = Py_BuildValue("s",_ptemp);
 683     } else {
 684         Py_INCREF(Py_None);
 685         _resultobj = Py_None;
 686     }
 687     return _resultobj;
 688 }
 689
 690 static void *SwigwxJPEGHandlerTowxImageHandler(void *ptr) {
 691     wxJPEGHandler *src;
 692     wxImageHandler *dest;
 693     src = (wxJPEGHandler *) ptr;
 694     dest = (wxImageHandler *) src;
 695     return (void *) dest;
 696 }
 697
 698 static void *SwigwxJPEGHandlerTowxObject(void *ptr) {
 699     wxJPEGHandler *src;
 700     wxObject *dest;
 701     src = (wxJPEGHandler *) ptr;
 702     dest = (wxObject *) src;
 703     return (void *) dest;
 704 }
 705
 706 #define new_wxJPEGHandler() (new wxJPEGHandler())
 707 static PyObject *_wrap_new_wxJPEGHandler(PyObject *self, PyObject *args, PyObject *kwargs) {
 708     PyObject * _resultobj;
 709     wxJPEGHandler * _result;
 710     char *_kwnames[] = {  NULL };
 711     char _ptemp[128];
 712
 713     self = self;
 714     if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxJPEGHandler",_kwnames))
 715         return NULL;
 716 {
 717     wxPy_BEGIN_ALLOW_THREADS;
 718         _result = (wxJPEGHandler *)new_wxJPEGHandler();
 719
 720     wxPy_END_ALLOW_THREADS;
 721 }    if (_result) {
 722         SWIG_MakePtr(_ptemp, (char *) _result,"_wxJPEGHandler_p");
 723         _resultobj = Py_BuildValue("s",_ptemp);
 724     } else {
 725         Py_INCREF(Py_None);
 726         _resultobj = Py_None;
 727     }
 728     return _resultobj;
 729 }
 730
 731 static void *SwigwxBMPHandlerTowxImageHandler(void *ptr) {
 732     wxBMPHandler *src;
 733     wxImageHandler *dest;
 734     src = (wxBMPHandler *) ptr;
 735     dest = (wxImageHandler *) src;
 736     return (void *) dest;
 737 }
 738
 739 static void *SwigwxBMPHandlerTowxObject(void *ptr) {
 740     wxBMPHandler *src;
 741     wxObject *dest;
 742     src = (wxBMPHandler *) ptr;
 743     dest = (wxObject *) src;
 744     return (void *) dest;
 745 }
 746
 747 #define new_wxBMPHandler() (new wxBMPHandler())
 748 static PyObject *_wrap_new_wxBMPHandler(PyObject *self, PyObject *args, PyObject *kwargs) {
 749     PyObject * _resultobj;
 750     wxBMPHandler * _result;
 751     char *_kwnames[] = {  NULL };
 752     char _ptemp[128];
 753
 754     self = self;
 755     if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxBMPHandler",_kwnames))
 756         return NULL;
 757 {
 758     wxPy_BEGIN_ALLOW_THREADS;
 759         _result = (wxBMPHandler *)new_wxBMPHandler();
 760
 761     wxPy_END_ALLOW_THREADS;
 762 }    if (_result) {
 763         SWIG_MakePtr(_ptemp, (char *) _result,"_wxBMPHandler_p");
 764         _resultobj = Py_BuildValue("s",_ptemp);
 765     } else {
 766         Py_INCREF(Py_None);
 767         _resultobj = Py_None;
 768     }
 769     return _resultobj;
 770 }
 771
 772 static void *SwigwxGIFHandlerTowxImageHandler(void *ptr) {
 773     wxGIFHandler *src;
 774     wxImageHandler *dest;
 775     src = (wxGIFHandler *) ptr;
 776     dest = (wxImageHandler *) src;
 777     return (void *) dest;
 778 }
 779
 780 static void *SwigwxGIFHandlerTowxObject(void *ptr) {
 781     wxGIFHandler *src;
 782     wxObject *dest;
 783     src = (wxGIFHandler *) ptr;
 784     dest = (wxObject *) src;
 785     return (void *) dest;
 786 }
 787
 788 #define new_wxGIFHandler() (new wxGIFHandler())
 789 static PyObject *_wrap_new_wxGIFHandler(PyObject *self, PyObject *args, PyObject *kwargs) {
 790     PyObject * _resultobj;
 791     wxGIFHandler * _result;
 792     char *_kwnames[] = {  NULL };
 793     char _ptemp[128];
 794
 795     self = self;
 796     if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxGIFHandler",_kwnames))
 797         return NULL;
 798 {
 799     wxPy_BEGIN_ALLOW_THREADS;
 800         _result = (wxGIFHandler *)new_wxGIFHandler();
 801
 802     wxPy_END_ALLOW_THREADS;
 803 }    if (_result) {
 804         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGIFHandler_p");
 805         _resultobj = Py_BuildValue("s",_ptemp);
 806     } else {
 807         Py_INCREF(Py_None);
 808         _resultobj = Py_None;
 809     }
 810     return _resultobj;
 811 }
 812
 813 static void *SwigwxPNMHandlerTowxImageHandler(void *ptr) {
 814     wxPNMHandler *src;
 815     wxImageHandler *dest;
 816     src = (wxPNMHandler *) ptr;
 817     dest = (wxImageHandler *) src;
 818     return (void *) dest;
 819 }
 820
 821 static void *SwigwxPNMHandlerTowxObject(void *ptr) {
 822     wxPNMHandler *src;
 823     wxObject *dest;
 824     src = (wxPNMHandler *) ptr;
 825     dest = (wxObject *) src;
 826     return (void *) dest;
 827 }
 828
 829 #define new_wxPNMHandler() (new wxPNMHandler())
 830 static PyObject *_wrap_new_wxPNMHandler(PyObject *self, PyObject *args, PyObject *kwargs) {
 831     PyObject * _resultobj;
 832     wxPNMHandler * _result;
 833     char *_kwnames[] = {  NULL };
 834     char _ptemp[128];
 835
 836     self = self;
 837     if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxPNMHandler",_kwnames))
 838         return NULL;
 839 {
 840     wxPy_BEGIN_ALLOW_THREADS;
 841         _result = (wxPNMHandler *)new_wxPNMHandler();
 842
 843     wxPy_END_ALLOW_THREADS;
 844 }    if (_result) {
 845         SWIG_MakePtr(_ptemp, (char *) _result,"_wxPNMHandler_p");
 846         _resultobj = Py_BuildValue("s",_ptemp);
 847     } else {
 848         Py_INCREF(Py_None);
 849         _resultobj = Py_None;
 850     }
 851     return _resultobj;
 852 }
 853
 854 static void *SwigwxPCXHandlerTowxImageHandler(void *ptr) {
 855     wxPCXHandler *src;
 856     wxImageHandler *dest;
 857     src = (wxPCXHandler *) ptr;
 858     dest = (wxImageHandler *) src;
 859     return (void *) dest;
 860 }
 861
 862 static void *SwigwxPCXHandlerTowxObject(void *ptr) {
 863     wxPCXHandler *src;
 864     wxObject *dest;
 865     src = (wxPCXHandler *) ptr;
 866     dest = (wxObject *) src;
 867     return (void *) dest;
 868 }
 869
 870 #define new_wxPCXHandler() (new wxPCXHandler())
 871 static PyObject *_wrap_new_wxPCXHandler(PyObject *self, PyObject *args, PyObject *kwargs) {
 872     PyObject * _resultobj;
 873     wxPCXHandler * _result;
 874     char *_kwnames[] = {  NULL };
 875     char _ptemp[128];
 876
 877     self = self;
 878     if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxPCXHandler",_kwnames))
 879         return NULL;
 880 {
 881     wxPy_BEGIN_ALLOW_THREADS;
 882         _result = (wxPCXHandler *)new_wxPCXHandler();
 883
 884     wxPy_END_ALLOW_THREADS;
 885 }    if (_result) {
 886         SWIG_MakePtr(_ptemp, (char *) _result,"_wxPCXHandler_p");
 887         _resultobj = Py_BuildValue("s",_ptemp);
 888     } else {
 889         Py_INCREF(Py_None);
 890         _resultobj = Py_None;
 891     }
 892     return _resultobj;
 893 }
 894
 895 static void *SwigwxTIFFHandlerTowxImageHandler(void *ptr) {
 896     wxTIFFHandler *src;
 897     wxImageHandler *dest;
 898     src = (wxTIFFHandler *) ptr;
 899     dest = (wxImageHandler *) src;
 900     return (void *) dest;
 901 }
 902
 903 static void *SwigwxTIFFHandlerTowxObject(void *ptr) {
 904     wxTIFFHandler *src;
 905     wxObject *dest;
 906     src = (wxTIFFHandler *) ptr;
 907     dest = (wxObject *) src;
 908     return (void *) dest;
 909 }
 910
 911 #define new_wxTIFFHandler() (new wxTIFFHandler())
 912 static PyObject *_wrap_new_wxTIFFHandler(PyObject *self, PyObject *args, PyObject *kwargs) {
 913     PyObject * _resultobj;
 914     wxTIFFHandler * _result;
 915     char *_kwnames[] = {  NULL };
 916     char _ptemp[128];
 917
 918     self = self;
 919     if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxTIFFHandler",_kwnames))
 920         return NULL;
 921 {
 922     wxPy_BEGIN_ALLOW_THREADS;
 923         _result = (wxTIFFHandler *)new_wxTIFFHandler();
 924
 925     wxPy_END_ALLOW_THREADS;
 926 }    if (_result) {
 927         SWIG_MakePtr(_ptemp, (char *) _result,"_wxTIFFHandler_p");
 928         _resultobj = Py_BuildValue("s",_ptemp);
 929     } else {
 930         Py_INCREF(Py_None);
 931         _resultobj = Py_None;
 932     }
 933     return _resultobj;
 934 }
 935
 936 static void *SwigwxImageTowxObject(void *ptr) {
 937     wxImage *src;
 938     wxObject *dest;
 939     src = (wxImage *) ptr;
 940     dest = (wxObject *) src;
 941     return (void *) dest;
 942 }
 943
 944 #define new_wxImage(_swigarg0,_swigarg1) (new wxImage(_swigarg0,_swigarg1))
 945 static PyObject *_wrap_new_wxImage(PyObject *self, PyObject *args, PyObject *kwargs) {
 946     PyObject * _resultobj;
 947     wxImage * _result;
 948     wxString * _arg0;
 949     long  _arg1 = (long ) wxBITMAP_TYPE_ANY;
 950     PyObject * _obj0 = 0;
 951     char *_kwnames[] = { "name","type", NULL };
 952     char _ptemp[128];
 953
 954     self = self;
 955     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|l:new_wxImage",_kwnames,&_obj0,&_arg1))
 956         return NULL;
 957 {
 958 #if PYTHON_API_VERSION >= 1009
 959     char* tmpPtr; int tmpSize;
 960     if (!PyString_Check(_obj0) && !PyUnicode_Check(_obj0)) {
 961         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
 962         return NULL;
 963     }
 964     if (PyString_AsStringAndSize(_obj0, &tmpPtr, &tmpSize) == -1)
 965         return NULL;
 966     _arg0 = new wxString(tmpPtr, tmpSize);
 967 #else
 968     if (!PyString_Check(_obj0)) {
 969         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
 970         return NULL;
 971     }
 972     _arg0 = new wxString(PyString_AS_STRING(_obj0), PyString_GET_SIZE(_obj0));
 973 #endif
 974 }
 975 {
 976     wxPy_BEGIN_ALLOW_THREADS;
 977         _result = (wxImage *)new_wxImage(*_arg0,_arg1);
 978
 979     wxPy_END_ALLOW_THREADS;
 980 }    if (_result) {
 981         SWIG_MakePtr(_ptemp, (char *) _result,"_wxImage_p");
 982         _resultobj = Py_BuildValue("s",_ptemp);
 983     } else {
 984         Py_INCREF(Py_None);
 985         _resultobj = Py_None;
 986     }
 987 {
 988     if (_obj0)
 989         delete _arg0;
 990 }
 991     return _resultobj;
 992 }
 993
 994 #define delete_wxImage(_swigobj) (delete _swigobj)
 995 static PyObject *_wrap_delete_wxImage(PyObject *self, PyObject *args, PyObject *kwargs) {
 996     PyObject * _resultobj;
 997     wxImage * _arg0;
 998     PyObject * _argo0 = 0;
 999     char *_kwnames[] = { "self", NULL };
1000
1001     self = self;
1002     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:delete_wxImage",_kwnames,&_argo0))
1003         return NULL;
1004     if (_argo0) {
1005         if (_argo0 == Py_None) { _arg0 = NULL; }
1006         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1007             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of delete_wxImage. Expected _wxImage_p.");
1008         return NULL;
1009         }
1010     }
1011 {
1012     wxPy_BEGIN_ALLOW_THREADS;
1013         delete_wxImage(_arg0);
1014
1015     wxPy_END_ALLOW_THREADS;
1016 }    Py_INCREF(Py_None);
1017     _resultobj = Py_None;
1018     return _resultobj;
1019 }
1020
1021 #define wxImage_ConvertToBitmap(_swigobj)  (_swigobj->ConvertToBitmap())
1022 static PyObject *_wrap_wxImage_ConvertToBitmap(PyObject *self, PyObject *args, PyObject *kwargs) {
1023     PyObject * _resultobj;
1024     wxBitmap * _result;
1025     wxImage * _arg0;
1026     PyObject * _argo0 = 0;
1027     char *_kwnames[] = { "self", NULL };
1028     char _ptemp[128];
1029
1030     self = self;
1031     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_ConvertToBitmap",_kwnames,&_argo0))
1032         return NULL;
1033     if (_argo0) {
1034         if (_argo0 == Py_None) { _arg0 = NULL; }
1035         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1036             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_ConvertToBitmap. Expected _wxImage_p.");
1037         return NULL;
1038         }
1039     }
1040 {
1041     wxPy_BEGIN_ALLOW_THREADS;
1042         _result = new wxBitmap (wxImage_ConvertToBitmap(_arg0));
1043
1044     wxPy_END_ALLOW_THREADS;
1045 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxBitmap_p");
1046     _resultobj = Py_BuildValue("s",_ptemp);
1047     return _resultobj;
1048 }
1049
1050 #define wxImage_Create(_swigobj,_swigarg0,_swigarg1)  (_swigobj->Create(_swigarg0,_swigarg1))
1051 static PyObject *_wrap_wxImage_Create(PyObject *self, PyObject *args, PyObject *kwargs) {
1052     PyObject * _resultobj;
1053     wxImage * _arg0;
1054     int  _arg1;
1055     int  _arg2;
1056     PyObject * _argo0 = 0;
1057     char *_kwnames[] = { "self","width","height", NULL };
1058
1059     self = self;
1060     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxImage_Create",_kwnames,&_argo0,&_arg1,&_arg2))
1061         return NULL;
1062     if (_argo0) {
1063         if (_argo0 == Py_None) { _arg0 = NULL; }
1064         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1065             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_Create. Expected _wxImage_p.");
1066         return NULL;
1067         }
1068     }
1069 {
1070     wxPy_BEGIN_ALLOW_THREADS;
1071         wxImage_Create(_arg0,_arg1,_arg2);
1072
1073     wxPy_END_ALLOW_THREADS;
1074 }    Py_INCREF(Py_None);
1075     _resultobj = Py_None;
1076     return _resultobj;
1077 }
1078
1079 #define wxImage_Destroy(_swigobj)  (_swigobj->Destroy())
1080 static PyObject *_wrap_wxImage_Destroy(PyObject *self, PyObject *args, PyObject *kwargs) {
1081     PyObject * _resultobj;
1082     wxImage * _arg0;
1083     PyObject * _argo0 = 0;
1084     char *_kwnames[] = { "self", NULL };
1085
1086     self = self;
1087     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_Destroy",_kwnames,&_argo0))
1088         return NULL;
1089     if (_argo0) {
1090         if (_argo0 == Py_None) { _arg0 = NULL; }
1091         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1092             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_Destroy. Expected _wxImage_p.");
1093         return NULL;
1094         }
1095     }
1096 {
1097     wxPy_BEGIN_ALLOW_THREADS;
1098         wxImage_Destroy(_arg0);
1099
1100     wxPy_END_ALLOW_THREADS;
1101 }    Py_INCREF(Py_None);
1102     _resultobj = Py_None;
1103     return _resultobj;
1104 }
1105
1106 #define wxImage_Scale(_swigobj,_swigarg0,_swigarg1)  (_swigobj->Scale(_swigarg0,_swigarg1))
1107 static PyObject *_wrap_wxImage_Scale(PyObject *self, PyObject *args, PyObject *kwargs) {
1108     PyObject * _resultobj;
1109     wxImage * _result;
1110     wxImage * _arg0;
1111     int  _arg1;
1112     int  _arg2;
1113     PyObject * _argo0 = 0;
1114     char *_kwnames[] = { "self","width","height", NULL };
1115     char _ptemp[128];
1116
1117     self = self;
1118     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxImage_Scale",_kwnames,&_argo0,&_arg1,&_arg2))
1119         return NULL;
1120     if (_argo0) {
1121         if (_argo0 == Py_None) { _arg0 = NULL; }
1122         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1123             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_Scale. Expected _wxImage_p.");
1124         return NULL;
1125         }
1126     }
1127 {
1128     wxPy_BEGIN_ALLOW_THREADS;
1129         _result = new wxImage (wxImage_Scale(_arg0,_arg1,_arg2));
1130
1131     wxPy_END_ALLOW_THREADS;
1132 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxImage_p");
1133     _resultobj = Py_BuildValue("s",_ptemp);
1134     return _resultobj;
1135 }
1136
1137 #define wxImage_Rescale(_swigobj,_swigarg0,_swigarg1)  (_swigobj->Rescale(_swigarg0,_swigarg1))
1138 static PyObject *_wrap_wxImage_Rescale(PyObject *self, PyObject *args, PyObject *kwargs) {
1139     PyObject * _resultobj;
1140     wxImage * _result;
1141     wxImage * _arg0;
1142     int  _arg1;
1143     int  _arg2;
1144     PyObject * _argo0 = 0;
1145     char *_kwnames[] = { "self","width","height", NULL };
1146     char _ptemp[128];
1147
1148     self = self;
1149     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxImage_Rescale",_kwnames,&_argo0,&_arg1,&_arg2))
1150         return NULL;
1151     if (_argo0) {
1152         if (_argo0 == Py_None) { _arg0 = NULL; }
1153         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1154             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_Rescale. Expected _wxImage_p.");
1155         return NULL;
1156         }
1157     }
1158 {
1159     wxPy_BEGIN_ALLOW_THREADS;
1160         wxImage & _result_ref = wxImage_Rescale(_arg0,_arg1,_arg2);
1161     _result = (wxImage *) &_result_ref;
1162
1163     wxPy_END_ALLOW_THREADS;
1164 }    if (_result) {
1165         SWIG_MakePtr(_ptemp, (char *) _result,"_wxImage_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 #define wxImage_SetRGB(_swigobj,_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4)  (_swigobj->SetRGB(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4))
1175 static PyObject *_wrap_wxImage_SetRGB(PyObject *self, PyObject *args, PyObject *kwargs) {
1176     PyObject * _resultobj;
1177     wxImage * _arg0;
1178     int  _arg1;
1179     int  _arg2;
1180     unsigned char  _arg3;
1181     unsigned char  _arg4;
1182     unsigned char  _arg5;
1183     PyObject * _argo0 = 0;
1184     char *_kwnames[] = { "self","x","y","r","g","b", NULL };
1185
1186     self = self;
1187     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oiibbb:wxImage_SetRGB",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3,&_arg4,&_arg5))
1188         return NULL;
1189     if (_argo0) {
1190         if (_argo0 == Py_None) { _arg0 = NULL; }
1191         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1192             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_SetRGB. Expected _wxImage_p.");
1193         return NULL;
1194         }
1195     }
1196 {
1197     wxPy_BEGIN_ALLOW_THREADS;
1198         wxImage_SetRGB(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5);
1199
1200     wxPy_END_ALLOW_THREADS;
1201 }    Py_INCREF(Py_None);
1202     _resultobj = Py_None;
1203     return _resultobj;
1204 }
1205
1206 #define wxImage_GetRed(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetRed(_swigarg0,_swigarg1))
1207 static PyObject *_wrap_wxImage_GetRed(PyObject *self, PyObject *args, PyObject *kwargs) {
1208     PyObject * _resultobj;
1209     unsigned char  _result;
1210     wxImage * _arg0;
1211     int  _arg1;
1212     int  _arg2;
1213     PyObject * _argo0 = 0;
1214     char *_kwnames[] = { "self","x","y", NULL };
1215
1216     self = self;
1217     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxImage_GetRed",_kwnames,&_argo0,&_arg1,&_arg2))
1218         return NULL;
1219     if (_argo0) {
1220         if (_argo0 == Py_None) { _arg0 = NULL; }
1221         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1222             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetRed. Expected _wxImage_p.");
1223         return NULL;
1224         }
1225     }
1226 {
1227     wxPy_BEGIN_ALLOW_THREADS;
1228         _result = (unsigned char )wxImage_GetRed(_arg0,_arg1,_arg2);
1229
1230     wxPy_END_ALLOW_THREADS;
1231 }    _resultobj = Py_BuildValue("b",_result);
1232     return _resultobj;
1233 }
1234
1235 #define wxImage_GetGreen(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetGreen(_swigarg0,_swigarg1))
1236 static PyObject *_wrap_wxImage_GetGreen(PyObject *self, PyObject *args, PyObject *kwargs) {
1237     PyObject * _resultobj;
1238     unsigned char  _result;
1239     wxImage * _arg0;
1240     int  _arg1;
1241     int  _arg2;
1242     PyObject * _argo0 = 0;
1243     char *_kwnames[] = { "self","x","y", NULL };
1244
1245     self = self;
1246     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxImage_GetGreen",_kwnames,&_argo0,&_arg1,&_arg2))
1247         return NULL;
1248     if (_argo0) {
1249         if (_argo0 == Py_None) { _arg0 = NULL; }
1250         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1251             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetGreen. Expected _wxImage_p.");
1252         return NULL;
1253         }
1254     }
1255 {
1256     wxPy_BEGIN_ALLOW_THREADS;
1257         _result = (unsigned char )wxImage_GetGreen(_arg0,_arg1,_arg2);
1258
1259     wxPy_END_ALLOW_THREADS;
1260 }    _resultobj = Py_BuildValue("b",_result);
1261     return _resultobj;
1262 }
1263
1264 #define wxImage_GetBlue(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetBlue(_swigarg0,_swigarg1))
1265 static PyObject *_wrap_wxImage_GetBlue(PyObject *self, PyObject *args, PyObject *kwargs) {
1266     PyObject * _resultobj;
1267     unsigned char  _result;
1268     wxImage * _arg0;
1269     int  _arg1;
1270     int  _arg2;
1271     PyObject * _argo0 = 0;
1272     char *_kwnames[] = { "self","x","y", NULL };
1273
1274     self = self;
1275     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxImage_GetBlue",_kwnames,&_argo0,&_arg1,&_arg2))
1276         return NULL;
1277     if (_argo0) {
1278         if (_argo0 == Py_None) { _arg0 = NULL; }
1279         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1280             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetBlue. Expected _wxImage_p.");
1281         return NULL;
1282         }
1283     }
1284 {
1285     wxPy_BEGIN_ALLOW_THREADS;
1286         _result = (unsigned char )wxImage_GetBlue(_arg0,_arg1,_arg2);
1287
1288     wxPy_END_ALLOW_THREADS;
1289 }    _resultobj = Py_BuildValue("b",_result);
1290     return _resultobj;
1291 }
1292
1293 static PyObject *_wrap_wxImage_CanRead(PyObject *self, PyObject *args, PyObject *kwargs) {
1294     PyObject * _resultobj;
1295     bool  _result;
1296     wxString * _arg0;
1297     PyObject * _obj0 = 0;
1298     char *_kwnames[] = { "name", NULL };
1299
1300     self = self;
1301     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_CanRead",_kwnames,&_obj0))
1302         return NULL;
1303 {
1304 #if PYTHON_API_VERSION >= 1009
1305     char* tmpPtr; int tmpSize;
1306     if (!PyString_Check(_obj0) && !PyUnicode_Check(_obj0)) {
1307         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1308         return NULL;
1309     }
1310     if (PyString_AsStringAndSize(_obj0, &tmpPtr, &tmpSize) == -1)
1311         return NULL;
1312     _arg0 = new wxString(tmpPtr, tmpSize);
1313 #else
1314     if (!PyString_Check(_obj0)) {
1315         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1316         return NULL;
1317     }
1318     _arg0 = new wxString(PyString_AS_STRING(_obj0), PyString_GET_SIZE(_obj0));
1319 #endif
1320 }
1321 {
1322     wxPy_BEGIN_ALLOW_THREADS;
1323         _result = (bool )wxImage::CanRead(*_arg0);
1324
1325     wxPy_END_ALLOW_THREADS;
1326 }    _resultobj = Py_BuildValue("i",_result);
1327 {
1328     if (_obj0)
1329         delete _arg0;
1330 }
1331     return _resultobj;
1332 }
1333
1334 #define wxImage_LoadFile(_swigobj,_swigarg0,_swigarg1)  (_swigobj->LoadFile(_swigarg0,_swigarg1))
1335 static PyObject *_wrap_wxImage_LoadFile(PyObject *self, PyObject *args, PyObject *kwargs) {
1336     PyObject * _resultobj;
1337     bool  _result;
1338     wxImage * _arg0;
1339     wxString * _arg1;
1340     long  _arg2 = (long ) wxBITMAP_TYPE_ANY;
1341     PyObject * _argo0 = 0;
1342     PyObject * _obj1 = 0;
1343     char *_kwnames[] = { "self","name","type", NULL };
1344
1345     self = self;
1346     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO|l:wxImage_LoadFile",_kwnames,&_argo0,&_obj1,&_arg2))
1347         return NULL;
1348     if (_argo0) {
1349         if (_argo0 == Py_None) { _arg0 = NULL; }
1350         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1351             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_LoadFile. Expected _wxImage_p.");
1352         return NULL;
1353         }
1354     }
1355 {
1356 #if PYTHON_API_VERSION >= 1009
1357     char* tmpPtr; int tmpSize;
1358     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
1359         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1360         return NULL;
1361     }
1362     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
1363         return NULL;
1364     _arg1 = new wxString(tmpPtr, tmpSize);
1365 #else
1366     if (!PyString_Check(_obj1)) {
1367         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1368         return NULL;
1369     }
1370     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
1371 #endif
1372 }
1373 {
1374     wxPy_BEGIN_ALLOW_THREADS;
1375         _result = (bool )wxImage_LoadFile(_arg0,*_arg1,_arg2);
1376
1377     wxPy_END_ALLOW_THREADS;
1378 }    _resultobj = Py_BuildValue("i",_result);
1379 {
1380     if (_obj1)
1381         delete _arg1;
1382 }
1383     return _resultobj;
1384 }
1385
1386 #define wxImage_LoadMimeFile(_swigobj,_swigarg0,_swigarg1)  (_swigobj->LoadFile(_swigarg0,_swigarg1))
1387 static PyObject *_wrap_wxImage_LoadMimeFile(PyObject *self, PyObject *args, PyObject *kwargs) {
1388     PyObject * _resultobj;
1389     bool  _result;
1390     wxImage * _arg0;
1391     wxString * _arg1;
1392     wxString * _arg2;
1393     PyObject * _argo0 = 0;
1394     PyObject * _obj1 = 0;
1395     PyObject * _obj2 = 0;
1396     char *_kwnames[] = { "self","name","mimetype", NULL };
1397
1398     self = self;
1399     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO:wxImage_LoadMimeFile",_kwnames,&_argo0,&_obj1,&_obj2))
1400         return NULL;
1401     if (_argo0) {
1402         if (_argo0 == Py_None) { _arg0 = NULL; }
1403         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1404             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_LoadMimeFile. Expected _wxImage_p.");
1405         return NULL;
1406         }
1407     }
1408 {
1409 #if PYTHON_API_VERSION >= 1009
1410     char* tmpPtr; int tmpSize;
1411     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
1412         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1413         return NULL;
1414     }
1415     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
1416         return NULL;
1417     _arg1 = new wxString(tmpPtr, tmpSize);
1418 #else
1419     if (!PyString_Check(_obj1)) {
1420         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1421         return NULL;
1422     }
1423     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
1424 #endif
1425 }
1426 {
1427 #if PYTHON_API_VERSION >= 1009
1428     char* tmpPtr; int tmpSize;
1429     if (!PyString_Check(_obj2) && !PyUnicode_Check(_obj2)) {
1430         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1431         return NULL;
1432     }
1433     if (PyString_AsStringAndSize(_obj2, &tmpPtr, &tmpSize) == -1)
1434         return NULL;
1435     _arg2 = new wxString(tmpPtr, tmpSize);
1436 #else
1437     if (!PyString_Check(_obj2)) {
1438         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1439         return NULL;
1440     }
1441     _arg2 = new wxString(PyString_AS_STRING(_obj2), PyString_GET_SIZE(_obj2));
1442 #endif
1443 }
1444 {
1445     wxPy_BEGIN_ALLOW_THREADS;
1446         _result = (bool )wxImage_LoadMimeFile(_arg0,*_arg1,*_arg2);
1447
1448     wxPy_END_ALLOW_THREADS;
1449 }    _resultobj = Py_BuildValue("i",_result);
1450 {
1451     if (_obj1)
1452         delete _arg1;
1453 }
1454 {
1455     if (_obj2)
1456         delete _arg2;
1457 }
1458     return _resultobj;
1459 }
1460
1461 #define wxImage_SaveFile(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SaveFile(_swigarg0,_swigarg1))
1462 static PyObject *_wrap_wxImage_SaveFile(PyObject *self, PyObject *args, PyObject *kwargs) {
1463     PyObject * _resultobj;
1464     bool  _result;
1465     wxImage * _arg0;
1466     wxString * _arg1;
1467     int  _arg2;
1468     PyObject * _argo0 = 0;
1469     PyObject * _obj1 = 0;
1470     char *_kwnames[] = { "self","name","type", NULL };
1471
1472     self = self;
1473     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOi:wxImage_SaveFile",_kwnames,&_argo0,&_obj1,&_arg2))
1474         return NULL;
1475     if (_argo0) {
1476         if (_argo0 == Py_None) { _arg0 = NULL; }
1477         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1478             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_SaveFile. Expected _wxImage_p.");
1479         return NULL;
1480         }
1481     }
1482 {
1483 #if PYTHON_API_VERSION >= 1009
1484     char* tmpPtr; int tmpSize;
1485     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
1486         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1487         return NULL;
1488     }
1489     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
1490         return NULL;
1491     _arg1 = new wxString(tmpPtr, tmpSize);
1492 #else
1493     if (!PyString_Check(_obj1)) {
1494         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1495         return NULL;
1496     }
1497     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
1498 #endif
1499 }
1500 {
1501     wxPy_BEGIN_ALLOW_THREADS;
1502         _result = (bool )wxImage_SaveFile(_arg0,*_arg1,_arg2);
1503
1504     wxPy_END_ALLOW_THREADS;
1505 }    _resultobj = Py_BuildValue("i",_result);
1506 {
1507     if (_obj1)
1508         delete _arg1;
1509 }
1510     return _resultobj;
1511 }
1512
1513 #define wxImage_SaveMimeFile(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SaveFile(_swigarg0,_swigarg1))
1514 static PyObject *_wrap_wxImage_SaveMimeFile(PyObject *self, PyObject *args, PyObject *kwargs) {
1515     PyObject * _resultobj;
1516     bool  _result;
1517     wxImage * _arg0;
1518     wxString * _arg1;
1519     wxString * _arg2;
1520     PyObject * _argo0 = 0;
1521     PyObject * _obj1 = 0;
1522     PyObject * _obj2 = 0;
1523     char *_kwnames[] = { "self","name","mimetype", NULL };
1524
1525     self = self;
1526     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO:wxImage_SaveMimeFile",_kwnames,&_argo0,&_obj1,&_obj2))
1527         return NULL;
1528     if (_argo0) {
1529         if (_argo0 == Py_None) { _arg0 = NULL; }
1530         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1531             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_SaveMimeFile. Expected _wxImage_p.");
1532         return NULL;
1533         }
1534     }
1535 {
1536 #if PYTHON_API_VERSION >= 1009
1537     char* tmpPtr; int tmpSize;
1538     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
1539         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1540         return NULL;
1541     }
1542     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
1543         return NULL;
1544     _arg1 = new wxString(tmpPtr, tmpSize);
1545 #else
1546     if (!PyString_Check(_obj1)) {
1547         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1548         return NULL;
1549     }
1550     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
1551 #endif
1552 }
1553 {
1554 #if PYTHON_API_VERSION >= 1009
1555     char* tmpPtr; int tmpSize;
1556     if (!PyString_Check(_obj2) && !PyUnicode_Check(_obj2)) {
1557         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1558         return NULL;
1559     }
1560     if (PyString_AsStringAndSize(_obj2, &tmpPtr, &tmpSize) == -1)
1561         return NULL;
1562     _arg2 = new wxString(tmpPtr, tmpSize);
1563 #else
1564     if (!PyString_Check(_obj2)) {
1565         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1566         return NULL;
1567     }
1568     _arg2 = new wxString(PyString_AS_STRING(_obj2), PyString_GET_SIZE(_obj2));
1569 #endif
1570 }
1571 {
1572     wxPy_BEGIN_ALLOW_THREADS;
1573         _result = (bool )wxImage_SaveMimeFile(_arg0,*_arg1,*_arg2);
1574
1575     wxPy_END_ALLOW_THREADS;
1576 }    _resultobj = Py_BuildValue("i",_result);
1577 {
1578     if (_obj1)
1579         delete _arg1;
1580 }
1581 {
1582     if (_obj2)
1583         delete _arg2;
1584 }
1585     return _resultobj;
1586 }
1587
1588 #define wxImage_Ok(_swigobj)  (_swigobj->Ok())
1589 static PyObject *_wrap_wxImage_Ok(PyObject *self, PyObject *args, PyObject *kwargs) {
1590     PyObject * _resultobj;
1591     bool  _result;
1592     wxImage * _arg0;
1593     PyObject * _argo0 = 0;
1594     char *_kwnames[] = { "self", NULL };
1595
1596     self = self;
1597     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_Ok",_kwnames,&_argo0))
1598         return NULL;
1599     if (_argo0) {
1600         if (_argo0 == Py_None) { _arg0 = NULL; }
1601         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1602             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_Ok. Expected _wxImage_p.");
1603         return NULL;
1604         }
1605     }
1606 {
1607     wxPy_BEGIN_ALLOW_THREADS;
1608         _result = (bool )wxImage_Ok(_arg0);
1609
1610     wxPy_END_ALLOW_THREADS;
1611 }    _resultobj = Py_BuildValue("i",_result);
1612     return _resultobj;
1613 }
1614
1615 #define wxImage_GetWidth(_swigobj)  (_swigobj->GetWidth())
1616 static PyObject *_wrap_wxImage_GetWidth(PyObject *self, PyObject *args, PyObject *kwargs) {
1617     PyObject * _resultobj;
1618     int  _result;
1619     wxImage * _arg0;
1620     PyObject * _argo0 = 0;
1621     char *_kwnames[] = { "self", NULL };
1622
1623     self = self;
1624     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_GetWidth",_kwnames,&_argo0))
1625         return NULL;
1626     if (_argo0) {
1627         if (_argo0 == Py_None) { _arg0 = NULL; }
1628         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1629             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetWidth. Expected _wxImage_p.");
1630         return NULL;
1631         }
1632     }
1633 {
1634     wxPy_BEGIN_ALLOW_THREADS;
1635         _result = (int )wxImage_GetWidth(_arg0);
1636
1637     wxPy_END_ALLOW_THREADS;
1638 }    _resultobj = Py_BuildValue("i",_result);
1639     return _resultobj;
1640 }
1641
1642 #define wxImage_GetHeight(_swigobj)  (_swigobj->GetHeight())
1643 static PyObject *_wrap_wxImage_GetHeight(PyObject *self, PyObject *args, PyObject *kwargs) {
1644     PyObject * _resultobj;
1645     int  _result;
1646     wxImage * _arg0;
1647     PyObject * _argo0 = 0;
1648     char *_kwnames[] = { "self", NULL };
1649
1650     self = self;
1651     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_GetHeight",_kwnames,&_argo0))
1652         return NULL;
1653     if (_argo0) {
1654         if (_argo0 == Py_None) { _arg0 = NULL; }
1655         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1656             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetHeight. Expected _wxImage_p.");
1657         return NULL;
1658         }
1659     }
1660 {
1661     wxPy_BEGIN_ALLOW_THREADS;
1662         _result = (int )wxImage_GetHeight(_arg0);
1663
1664     wxPy_END_ALLOW_THREADS;
1665 }    _resultobj = Py_BuildValue("i",_result);
1666     return _resultobj;
1667 }
1668
1669 #define wxImage_GetSubImage(_swigobj,_swigarg0)  (_swigobj->GetSubImage(_swigarg0))
1670 static PyObject *_wrap_wxImage_GetSubImage(PyObject *self, PyObject *args, PyObject *kwargs) {
1671     PyObject * _resultobj;
1672     wxImage * _result;
1673     wxImage * _arg0;
1674     wxRect * _arg1;
1675     PyObject * _argo0 = 0;
1676     wxRect  temp;
1677     PyObject * _obj1 = 0;
1678     char *_kwnames[] = { "self","rect", NULL };
1679     char _ptemp[128];
1680
1681     self = self;
1682     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxImage_GetSubImage",_kwnames,&_argo0,&_obj1))
1683         return NULL;
1684     if (_argo0) {
1685         if (_argo0 == Py_None) { _arg0 = NULL; }
1686         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1687             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetSubImage. Expected _wxImage_p.");
1688         return NULL;
1689         }
1690     }
1691 {
1692     _arg1 = &temp;
1693     if (! wxRect_helper(_obj1, &_arg1))
1694         return NULL;
1695 }
1696 {
1697     wxPy_BEGIN_ALLOW_THREADS;
1698         _result = new wxImage (wxImage_GetSubImage(_arg0,*_arg1));
1699
1700     wxPy_END_ALLOW_THREADS;
1701 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxImage_p");
1702     _resultobj = Py_BuildValue("s",_ptemp);
1703     return _resultobj;
1704 }
1705
1706 #define wxImage_Copy(_swigobj)  (_swigobj->Copy())
1707 static PyObject *_wrap_wxImage_Copy(PyObject *self, PyObject *args, PyObject *kwargs) {
1708     PyObject * _resultobj;
1709     wxImage * _result;
1710     wxImage * _arg0;
1711     PyObject * _argo0 = 0;
1712     char *_kwnames[] = { "self", NULL };
1713     char _ptemp[128];
1714
1715     self = self;
1716     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_Copy",_kwnames,&_argo0))
1717         return NULL;
1718     if (_argo0) {
1719         if (_argo0 == Py_None) { _arg0 = NULL; }
1720         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1721             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_Copy. Expected _wxImage_p.");
1722         return NULL;
1723         }
1724     }
1725 {
1726     wxPy_BEGIN_ALLOW_THREADS;
1727         _result = new wxImage (wxImage_Copy(_arg0));
1728
1729     wxPy_END_ALLOW_THREADS;
1730 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxImage_p");
1731     _resultobj = Py_BuildValue("s",_ptemp);
1732     return _resultobj;
1733 }
1734
1735 #define wxImage_Paste(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->Paste(_swigarg0,_swigarg1,_swigarg2))
1736 static PyObject *_wrap_wxImage_Paste(PyObject *self, PyObject *args, PyObject *kwargs) {
1737     PyObject * _resultobj;
1738     wxImage * _arg0;
1739     wxImage * _arg1;
1740     int  _arg2;
1741     int  _arg3;
1742     PyObject * _argo0 = 0;
1743     PyObject * _argo1 = 0;
1744     char *_kwnames[] = { "self","image","x","y", NULL };
1745
1746     self = self;
1747     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOii:wxImage_Paste",_kwnames,&_argo0,&_argo1,&_arg2,&_arg3))
1748         return NULL;
1749     if (_argo0) {
1750         if (_argo0 == Py_None) { _arg0 = NULL; }
1751         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1752             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_Paste. Expected _wxImage_p.");
1753         return NULL;
1754         }
1755     }
1756     if (_argo1) {
1757         if (_argo1 == Py_None) { _arg1 = NULL; }
1758         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxImage_p")) {
1759             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxImage_Paste. Expected _wxImage_p.");
1760         return NULL;
1761         }
1762     }
1763 {
1764     wxPy_BEGIN_ALLOW_THREADS;
1765         wxImage_Paste(_arg0,*_arg1,_arg2,_arg3);
1766
1767     wxPy_END_ALLOW_THREADS;
1768 }    Py_INCREF(Py_None);
1769     _resultobj = Py_None;
1770     return _resultobj;
1771 }
1772
1773 static PyObject * wxImage_GetData(wxImage *self) {
1774             unsigned char* data = self->GetData();
1775             int len = self->GetWidth() * self->GetHeight() * 3;
1776             return PyString_FromStringAndSize((char*)data, len);
1777         }
1778 static PyObject *_wrap_wxImage_GetData(PyObject *self, PyObject *args, PyObject *kwargs) {
1779     PyObject * _resultobj;
1780     PyObject * _result;
1781     wxImage * _arg0;
1782     PyObject * _argo0 = 0;
1783     char *_kwnames[] = { "self", NULL };
1784
1785     self = self;
1786     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_GetData",_kwnames,&_argo0))
1787         return NULL;
1788     if (_argo0) {
1789         if (_argo0 == Py_None) { _arg0 = NULL; }
1790         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1791             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetData. Expected _wxImage_p.");
1792         return NULL;
1793         }
1794     }
1795 {
1796     wxPy_BEGIN_ALLOW_THREADS;
1797         _result = (PyObject *)wxImage_GetData(_arg0);
1798
1799     wxPy_END_ALLOW_THREADS;
1800 }{
1801   _resultobj = _result;
1802 }
1803     return _resultobj;
1804 }
1805
1806 static void  wxImage_SetData(wxImage *self,PyObject * data) {
1807             unsigned char* dataPtr;
1808
1809             if (! PyString_Check(data)) {
1810                 PyErr_SetString(PyExc_TypeError, "Expected string object");
1811                 return /* NULL */ ;
1812             }
1813
1814             size_t len = self->GetWidth() * self->GetHeight() * 3;
1815             dataPtr = (unsigned char*) malloc(len);
1816             memcpy(dataPtr, PyString_AsString(data), len);
1817             self->SetData(dataPtr);
1818         }
1819 static PyObject *_wrap_wxImage_SetData(PyObject *self, PyObject *args, PyObject *kwargs) {
1820     PyObject * _resultobj;
1821     wxImage * _arg0;
1822     PyObject * _arg1;
1823     PyObject * _argo0 = 0;
1824     PyObject * _obj1 = 0;
1825     char *_kwnames[] = { "self","data", NULL };
1826
1827     self = self;
1828     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxImage_SetData",_kwnames,&_argo0,&_obj1))
1829         return NULL;
1830     if (_argo0) {
1831         if (_argo0 == Py_None) { _arg0 = NULL; }
1832         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1833             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_SetData. Expected _wxImage_p.");
1834         return NULL;
1835         }
1836     }
1837 {
1838   _arg1 = _obj1;
1839 }
1840 {
1841     wxPy_BEGIN_ALLOW_THREADS;
1842         wxImage_SetData(_arg0,_arg1);
1843
1844     wxPy_END_ALLOW_THREADS;
1845 }    Py_INCREF(Py_None);
1846     _resultobj = Py_None;
1847     return _resultobj;
1848 }
1849
1850 #define wxImage_SetMaskColour(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->SetMaskColour(_swigarg0,_swigarg1,_swigarg2))
1851 static PyObject *_wrap_wxImage_SetMaskColour(PyObject *self, PyObject *args, PyObject *kwargs) {
1852     PyObject * _resultobj;
1853     wxImage * _arg0;
1854     unsigned char  _arg1;
1855     unsigned char  _arg2;
1856     unsigned char  _arg3;
1857     PyObject * _argo0 = 0;
1858     char *_kwnames[] = { "self","r","g","b", NULL };
1859
1860     self = self;
1861     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Obbb:wxImage_SetMaskColour",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3))
1862         return NULL;
1863     if (_argo0) {
1864         if (_argo0 == Py_None) { _arg0 = NULL; }
1865         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1866             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_SetMaskColour. Expected _wxImage_p.");
1867         return NULL;
1868         }
1869     }
1870 {
1871     wxPy_BEGIN_ALLOW_THREADS;
1872         wxImage_SetMaskColour(_arg0,_arg1,_arg2,_arg3);
1873
1874     wxPy_END_ALLOW_THREADS;
1875 }    Py_INCREF(Py_None);
1876     _resultobj = Py_None;
1877     return _resultobj;
1878 }
1879
1880 #define wxImage_GetMaskRed(_swigobj)  (_swigobj->GetMaskRed())
1881 static PyObject *_wrap_wxImage_GetMaskRed(PyObject *self, PyObject *args, PyObject *kwargs) {
1882     PyObject * _resultobj;
1883     unsigned char  _result;
1884     wxImage * _arg0;
1885     PyObject * _argo0 = 0;
1886     char *_kwnames[] = { "self", NULL };
1887
1888     self = self;
1889     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_GetMaskRed",_kwnames,&_argo0))
1890         return NULL;
1891     if (_argo0) {
1892         if (_argo0 == Py_None) { _arg0 = NULL; }
1893         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1894             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetMaskRed. Expected _wxImage_p.");
1895         return NULL;
1896         }
1897     }
1898 {
1899     wxPy_BEGIN_ALLOW_THREADS;
1900         _result = (unsigned char )wxImage_GetMaskRed(_arg0);
1901
1902     wxPy_END_ALLOW_THREADS;
1903 }    _resultobj = Py_BuildValue("b",_result);
1904     return _resultobj;
1905 }
1906
1907 #define wxImage_GetMaskGreen(_swigobj)  (_swigobj->GetMaskGreen())
1908 static PyObject *_wrap_wxImage_GetMaskGreen(PyObject *self, PyObject *args, PyObject *kwargs) {
1909     PyObject * _resultobj;
1910     unsigned char  _result;
1911     wxImage * _arg0;
1912     PyObject * _argo0 = 0;
1913     char *_kwnames[] = { "self", NULL };
1914
1915     self = self;
1916     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_GetMaskGreen",_kwnames,&_argo0))
1917         return NULL;
1918     if (_argo0) {
1919         if (_argo0 == Py_None) { _arg0 = NULL; }
1920         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1921             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetMaskGreen. Expected _wxImage_p.");
1922         return NULL;
1923         }
1924     }
1925 {
1926     wxPy_BEGIN_ALLOW_THREADS;
1927         _result = (unsigned char )wxImage_GetMaskGreen(_arg0);
1928
1929     wxPy_END_ALLOW_THREADS;
1930 }    _resultobj = Py_BuildValue("b",_result);
1931     return _resultobj;
1932 }
1933
1934 #define wxImage_GetMaskBlue(_swigobj)  (_swigobj->GetMaskBlue())
1935 static PyObject *_wrap_wxImage_GetMaskBlue(PyObject *self, PyObject *args, PyObject *kwargs) {
1936     PyObject * _resultobj;
1937     unsigned char  _result;
1938     wxImage * _arg0;
1939     PyObject * _argo0 = 0;
1940     char *_kwnames[] = { "self", NULL };
1941
1942     self = self;
1943     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_GetMaskBlue",_kwnames,&_argo0))
1944         return NULL;
1945     if (_argo0) {
1946         if (_argo0 == Py_None) { _arg0 = NULL; }
1947         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1948             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetMaskBlue. Expected _wxImage_p.");
1949         return NULL;
1950         }
1951     }
1952 {
1953     wxPy_BEGIN_ALLOW_THREADS;
1954         _result = (unsigned char )wxImage_GetMaskBlue(_arg0);
1955
1956     wxPy_END_ALLOW_THREADS;
1957 }    _resultobj = Py_BuildValue("b",_result);
1958     return _resultobj;
1959 }
1960
1961 #define wxImage_SetMask(_swigobj,_swigarg0)  (_swigobj->SetMask(_swigarg0))
1962 static PyObject *_wrap_wxImage_SetMask(PyObject *self, PyObject *args, PyObject *kwargs) {
1963     PyObject * _resultobj;
1964     wxImage * _arg0;
1965     bool  _arg1 = (bool ) TRUE;
1966     PyObject * _argo0 = 0;
1967     int tempbool1 = (int) TRUE;
1968     char *_kwnames[] = { "self","mask", NULL };
1969
1970     self = self;
1971     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|i:wxImage_SetMask",_kwnames,&_argo0,&tempbool1))
1972         return NULL;
1973     if (_argo0) {
1974         if (_argo0 == Py_None) { _arg0 = NULL; }
1975         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1976             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_SetMask. Expected _wxImage_p.");
1977         return NULL;
1978         }
1979     }
1980     _arg1 = (bool ) tempbool1;
1981 {
1982     wxPy_BEGIN_ALLOW_THREADS;
1983         wxImage_SetMask(_arg0,_arg1);
1984
1985     wxPy_END_ALLOW_THREADS;
1986 }    Py_INCREF(Py_None);
1987     _resultobj = Py_None;
1988     return _resultobj;
1989 }
1990
1991 #define wxImage_HasMask(_swigobj)  (_swigobj->HasMask())
1992 static PyObject *_wrap_wxImage_HasMask(PyObject *self, PyObject *args, PyObject *kwargs) {
1993     PyObject * _resultobj;
1994     bool  _result;
1995     wxImage * _arg0;
1996     PyObject * _argo0 = 0;
1997     char *_kwnames[] = { "self", NULL };
1998
1999     self = self;
2000     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_HasMask",_kwnames,&_argo0))
2001         return NULL;
2002     if (_argo0) {
2003         if (_argo0 == Py_None) { _arg0 = NULL; }
2004         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
2005             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_HasMask. Expected _wxImage_p.");
2006         return NULL;
2007         }
2008     }
2009 {
2010     wxPy_BEGIN_ALLOW_THREADS;
2011         _result = (bool )wxImage_HasMask(_arg0);
2012
2013     wxPy_END_ALLOW_THREADS;
2014 }    _resultobj = Py_BuildValue("i",_result);
2015     return _resultobj;
2016 }
2017
2018 #define wxImage_Rotate(_swigobj,_swigarg0,_swigarg1,_swigarg2,_swigarg3)  (_swigobj->Rotate(_swigarg0,_swigarg1,_swigarg2,_swigarg3))
2019 static PyObject *_wrap_wxImage_Rotate(PyObject *self, PyObject *args, PyObject *kwargs) {
2020     PyObject * _resultobj;
2021     wxImage * _result;
2022     wxImage * _arg0;
2023     double  _arg1;
2024     wxPoint * _arg2;
2025     bool  _arg3 = (bool ) TRUE;
2026     wxPoint * _arg4 = (wxPoint *) NULL;
2027     PyObject * _argo0 = 0;
2028     wxPoint  temp;
2029     PyObject * _obj2 = 0;
2030     int tempbool3 = (int) TRUE;
2031     wxPoint  temp0;
2032     PyObject * _obj4 = 0;
2033     char *_kwnames[] = { "self","angle","centre_of_rotation","interpolating","offset_after_rotation", NULL };
2034     char _ptemp[128];
2035
2036     self = self;
2037     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OdO|iO:wxImage_Rotate",_kwnames,&_argo0,&_arg1,&_obj2,&tempbool3,&_obj4))
2038         return NULL;
2039     if (_argo0) {
2040         if (_argo0 == Py_None) { _arg0 = NULL; }
2041         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
2042             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_Rotate. Expected _wxImage_p.");
2043         return NULL;
2044         }
2045     }
2046 {
2047     _arg2 = &temp;
2048     if (! wxPoint_helper(_obj2, &_arg2))
2049         return NULL;
2050 }
2051     _arg3 = (bool ) tempbool3;
2052     if (_obj4)
2053 {
2054     _arg4 = &temp0;
2055     if (! wxPoint_helper(_obj4, &_arg4))
2056         return NULL;
2057 }
2058 {
2059     wxPy_BEGIN_ALLOW_THREADS;
2060         _result = new wxImage (wxImage_Rotate(_arg0,_arg1,*_arg2,_arg3,_arg4));
2061
2062     wxPy_END_ALLOW_THREADS;
2063 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxImage_p");
2064     _resultobj = Py_BuildValue("s",_ptemp);
2065     return _resultobj;
2066 }
2067
2068 #define wxImage_Rotate90(_swigobj,_swigarg0)  (_swigobj->Rotate90(_swigarg0))
2069 static PyObject *_wrap_wxImage_Rotate90(PyObject *self, PyObject *args, PyObject *kwargs) {
2070     PyObject * _resultobj;
2071     wxImage * _result;
2072     wxImage * _arg0;
2073     bool  _arg1 = (bool ) TRUE;
2074     PyObject * _argo0 = 0;
2075     int tempbool1 = (int) TRUE;
2076     char *_kwnames[] = { "self","clockwise", NULL };
2077     char _ptemp[128];
2078
2079     self = self;
2080     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|i:wxImage_Rotate90",_kwnames,&_argo0,&tempbool1))
2081         return NULL;
2082     if (_argo0) {
2083         if (_argo0 == Py_None) { _arg0 = NULL; }
2084         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
2085             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_Rotate90. Expected _wxImage_p.");
2086         return NULL;
2087         }
2088     }
2089     _arg1 = (bool ) tempbool1;
2090 {
2091     wxPy_BEGIN_ALLOW_THREADS;
2092         _result = new wxImage (wxImage_Rotate90(_arg0,_arg1));
2093
2094     wxPy_END_ALLOW_THREADS;
2095 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxImage_p");
2096     _resultobj = Py_BuildValue("s",_ptemp);
2097     return _resultobj;
2098 }
2099
2100 #define wxImage_Mirror(_swigobj,_swigarg0)  (_swigobj->Mirror(_swigarg0))
2101 static PyObject *_wrap_wxImage_Mirror(PyObject *self, PyObject *args, PyObject *kwargs) {
2102     PyObject * _resultobj;
2103     wxImage * _result;
2104     wxImage * _arg0;
2105     bool  _arg1 = (bool ) TRUE;
2106     PyObject * _argo0 = 0;
2107     int tempbool1 = (int) TRUE;
2108     char *_kwnames[] = { "self","horizontally", NULL };
2109     char _ptemp[128];
2110
2111     self = self;
2112     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|i:wxImage_Mirror",_kwnames,&_argo0,&tempbool1))
2113         return NULL;
2114     if (_argo0) {
2115         if (_argo0 == Py_None) { _arg0 = NULL; }
2116         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
2117             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_Mirror. Expected _wxImage_p.");
2118         return NULL;
2119         }
2120     }
2121     _arg1 = (bool ) tempbool1;
2122 {
2123     wxPy_BEGIN_ALLOW_THREADS;
2124         _result = new wxImage (wxImage_Mirror(_arg0,_arg1));
2125
2126     wxPy_END_ALLOW_THREADS;
2127 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxImage_p");
2128     _resultobj = Py_BuildValue("s",_ptemp);
2129     return _resultobj;
2130 }
2131
2132 #define wxImage_Replace(_swigobj,_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5)  (_swigobj->Replace(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5))
2133 static PyObject *_wrap_wxImage_Replace(PyObject *self, PyObject *args, PyObject *kwargs) {
2134     PyObject * _resultobj;
2135     wxImage * _arg0;
2136     unsigned char  _arg1;
2137     unsigned char  _arg2;
2138     unsigned char  _arg3;
2139     unsigned char  _arg4;
2140     unsigned char  _arg5;
2141     unsigned char  _arg6;
2142     PyObject * _argo0 = 0;
2143     char *_kwnames[] = { "self","r1","g1","b1","r2","g2","b2", NULL };
2144
2145     self = self;
2146     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Obbbbbb:wxImage_Replace",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3,&_arg4,&_arg5,&_arg6))
2147         return NULL;
2148     if (_argo0) {
2149         if (_argo0 == Py_None) { _arg0 = NULL; }
2150         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
2151             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_Replace. Expected _wxImage_p.");
2152         return NULL;
2153         }
2154     }
2155 {
2156     wxPy_BEGIN_ALLOW_THREADS;
2157         wxImage_Replace(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5,_arg6);
2158
2159     wxPy_END_ALLOW_THREADS;
2160 }    Py_INCREF(Py_None);
2161     _resultobj = Py_None;
2162     return _resultobj;
2163 }
2164
2165 #define wxImage_CountColours(_swigobj,_swigarg0)  (_swigobj->CountColours(_swigarg0))
2166 static PyObject *_wrap_wxImage_CountColours(PyObject *self, PyObject *args, PyObject *kwargs) {
2167     PyObject * _resultobj;
2168     unsigned long  _result;
2169     wxImage * _arg0;
2170     unsigned long  _arg1 = (unsigned long ) (unsigned long)-1;
2171     PyObject * _argo0 = 0;
2172     char *_kwnames[] = { "self","stopafter", NULL };
2173
2174     self = self;
2175     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|l:wxImage_CountColours",_kwnames,&_argo0,&_arg1))
2176         return NULL;
2177     if (_argo0) {
2178         if (_argo0 == Py_None) { _arg0 = NULL; }
2179         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
2180             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_CountColours. Expected _wxImage_p.");
2181         return NULL;
2182         }
2183     }
2184 {
2185     wxPy_BEGIN_ALLOW_THREADS;
2186         _result = (unsigned long )wxImage_CountColours(_arg0,_arg1);
2187
2188     wxPy_END_ALLOW_THREADS;
2189 }    _resultobj = Py_BuildValue("l",_result);
2190     return _resultobj;
2191 }
2192
2193 static PyObject *_wrap_wxImage_AddHandler(PyObject *self, PyObject *args, PyObject *kwargs) {
2194     PyObject * _resultobj;
2195     wxImageHandler * _arg0;
2196     PyObject * _argo0 = 0;
2197     char *_kwnames[] = { "handler", NULL };
2198
2199     self = self;
2200     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_AddHandler",_kwnames,&_argo0))
2201         return NULL;
2202     if (_argo0) {
2203         if (_argo0 == Py_None) { _arg0 = NULL; }
2204         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImageHandler_p")) {
2205             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_AddHandler. Expected _wxImageHandler_p.");
2206         return NULL;
2207         }
2208     }
2209 {
2210     wxPy_BEGIN_ALLOW_THREADS;
2211         wxImage::AddHandler(_arg0);
2212
2213     wxPy_END_ALLOW_THREADS;
2214 }    Py_INCREF(Py_None);
2215     _resultobj = Py_None;
2216     return _resultobj;
2217 }
2218
2219 static PyObject *_wrap_wxImage_InsertHandler(PyObject *self, PyObject *args, PyObject *kwargs) {
2220     PyObject * _resultobj;
2221     wxImageHandler * _arg0;
2222     PyObject * _argo0 = 0;
2223     char *_kwnames[] = { "handler", NULL };
2224
2225     self = self;
2226     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_InsertHandler",_kwnames,&_argo0))
2227         return NULL;
2228     if (_argo0) {
2229         if (_argo0 == Py_None) { _arg0 = NULL; }
2230         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImageHandler_p")) {
2231             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_InsertHandler. Expected _wxImageHandler_p.");
2232         return NULL;
2233         }
2234     }
2235 {
2236     wxPy_BEGIN_ALLOW_THREADS;
2237         wxImage::InsertHandler(_arg0);
2238
2239     wxPy_END_ALLOW_THREADS;
2240 }    Py_INCREF(Py_None);
2241     _resultobj = Py_None;
2242     return _resultobj;
2243 }
2244
2245 static PyObject *_wrap_wxImage_RemoveHandler(PyObject *self, PyObject *args, PyObject *kwargs) {
2246     PyObject * _resultobj;
2247     bool  _result;
2248     wxString * _arg0;
2249     PyObject * _obj0 = 0;
2250     char *_kwnames[] = { "name", NULL };
2251
2252     self = self;
2253     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_RemoveHandler",_kwnames,&_obj0))
2254         return NULL;
2255 {
2256 #if PYTHON_API_VERSION >= 1009
2257     char* tmpPtr; int tmpSize;
2258     if (!PyString_Check(_obj0) && !PyUnicode_Check(_obj0)) {
2259         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
2260         return NULL;
2261     }
2262     if (PyString_AsStringAndSize(_obj0, &tmpPtr, &tmpSize) == -1)
2263         return NULL;
2264     _arg0 = new wxString(tmpPtr, tmpSize);
2265 #else
2266     if (!PyString_Check(_obj0)) {
2267         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
2268         return NULL;
2269     }
2270     _arg0 = new wxString(PyString_AS_STRING(_obj0), PyString_GET_SIZE(_obj0));
2271 #endif
2272 }
2273 {
2274     wxPy_BEGIN_ALLOW_THREADS;
2275         _result = (bool )wxImage::RemoveHandler(*_arg0);
2276
2277     wxPy_END_ALLOW_THREADS;
2278 }    _resultobj = Py_BuildValue("i",_result);
2279 {
2280     if (_obj0)
2281         delete _arg0;
2282 }
2283     return _resultobj;
2284 }
2285
2286 static PyMethodDef imagecMethods[] = {
2287          { "wxImage_RemoveHandler", (PyCFunction) _wrap_wxImage_RemoveHandler, METH_VARARGS | METH_KEYWORDS },
2288          { "wxImage_InsertHandler", (PyCFunction) _wrap_wxImage_InsertHandler, METH_VARARGS | METH_KEYWORDS },
2289          { "wxImage_AddHandler", (PyCFunction) _wrap_wxImage_AddHandler, METH_VARARGS | METH_KEYWORDS },
2290          { "wxImage_CountColours", (PyCFunction) _wrap_wxImage_CountColours, METH_VARARGS | METH_KEYWORDS },
2291          { "wxImage_Replace", (PyCFunction) _wrap_wxImage_Replace, METH_VARARGS | METH_KEYWORDS },
2292          { "wxImage_Mirror", (PyCFunction) _wrap_wxImage_Mirror, METH_VARARGS | METH_KEYWORDS },
2293          { "wxImage_Rotate90", (PyCFunction) _wrap_wxImage_Rotate90, METH_VARARGS | METH_KEYWORDS },
2294          { "wxImage_Rotate", (PyCFunction) _wrap_wxImage_Rotate, METH_VARARGS | METH_KEYWORDS },
2295          { "wxImage_HasMask", (PyCFunction) _wrap_wxImage_HasMask, METH_VARARGS | METH_KEYWORDS },
2296          { "wxImage_SetMask", (PyCFunction) _wrap_wxImage_SetMask, METH_VARARGS | METH_KEYWORDS },
2297          { "wxImage_GetMaskBlue", (PyCFunction) _wrap_wxImage_GetMaskBlue, METH_VARARGS | METH_KEYWORDS },
2298          { "wxImage_GetMaskGreen", (PyCFunction) _wrap_wxImage_GetMaskGreen, METH_VARARGS | METH_KEYWORDS },
2299          { "wxImage_GetMaskRed", (PyCFunction) _wrap_wxImage_GetMaskRed, METH_VARARGS | METH_KEYWORDS },
2300          { "wxImage_SetMaskColour", (PyCFunction) _wrap_wxImage_SetMaskColour, METH_VARARGS | METH_KEYWORDS },
2301          { "wxImage_SetData", (PyCFunction) _wrap_wxImage_SetData, METH_VARARGS | METH_KEYWORDS },
2302          { "wxImage_GetData", (PyCFunction) _wrap_wxImage_GetData, METH_VARARGS | METH_KEYWORDS },
2303          { "wxImage_Paste", (PyCFunction) _wrap_wxImage_Paste, METH_VARARGS | METH_KEYWORDS },
2304          { "wxImage_Copy", (PyCFunction) _wrap_wxImage_Copy, METH_VARARGS | METH_KEYWORDS },
2305          { "wxImage_GetSubImage", (PyCFunction) _wrap_wxImage_GetSubImage, METH_VARARGS | METH_KEYWORDS },
2306          { "wxImage_GetHeight", (PyCFunction) _wrap_wxImage_GetHeight, METH_VARARGS | METH_KEYWORDS },
2307          { "wxImage_GetWidth", (PyCFunction) _wrap_wxImage_GetWidth, METH_VARARGS | METH_KEYWORDS },
2308          { "wxImage_Ok", (PyCFunction) _wrap_wxImage_Ok, METH_VARARGS | METH_KEYWORDS },
2309          { "wxImage_SaveMimeFile", (PyCFunction) _wrap_wxImage_SaveMimeFile, METH_VARARGS | METH_KEYWORDS },
2310          { "wxImage_SaveFile", (PyCFunction) _wrap_wxImage_SaveFile, METH_VARARGS | METH_KEYWORDS },
2311          { "wxImage_LoadMimeFile", (PyCFunction) _wrap_wxImage_LoadMimeFile, METH_VARARGS | METH_KEYWORDS },
2312          { "wxImage_LoadFile", (PyCFunction) _wrap_wxImage_LoadFile, METH_VARARGS | METH_KEYWORDS },
2313          { "wxImage_CanRead", (PyCFunction) _wrap_wxImage_CanRead, METH_VARARGS | METH_KEYWORDS },
2314          { "wxImage_GetBlue", (PyCFunction) _wrap_wxImage_GetBlue, METH_VARARGS | METH_KEYWORDS },
2315          { "wxImage_GetGreen", (PyCFunction) _wrap_wxImage_GetGreen, METH_VARARGS | METH_KEYWORDS },
2316          { "wxImage_GetRed", (PyCFunction) _wrap_wxImage_GetRed, METH_VARARGS | METH_KEYWORDS },
2317          { "wxImage_SetRGB", (PyCFunction) _wrap_wxImage_SetRGB, METH_VARARGS | METH_KEYWORDS },
2318          { "wxImage_Rescale", (PyCFunction) _wrap_wxImage_Rescale, METH_VARARGS | METH_KEYWORDS },
2319          { "wxImage_Scale", (PyCFunction) _wrap_wxImage_Scale, METH_VARARGS | METH_KEYWORDS },
2320          { "wxImage_Destroy", (PyCFunction) _wrap_wxImage_Destroy, METH_VARARGS | METH_KEYWORDS },
2321          { "wxImage_Create", (PyCFunction) _wrap_wxImage_Create, METH_VARARGS | METH_KEYWORDS },
2322          { "wxImage_ConvertToBitmap", (PyCFunction) _wrap_wxImage_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS },
2323          { "delete_wxImage", (PyCFunction) _wrap_delete_wxImage, METH_VARARGS | METH_KEYWORDS },
2324          { "new_wxImage", (PyCFunction) _wrap_new_wxImage, METH_VARARGS | METH_KEYWORDS },
2325          { "new_wxTIFFHandler", (PyCFunction) _wrap_new_wxTIFFHandler, METH_VARARGS | METH_KEYWORDS },
2326          { "new_wxPCXHandler", (PyCFunction) _wrap_new_wxPCXHandler, METH_VARARGS | METH_KEYWORDS },
2327          { "new_wxPNMHandler", (PyCFunction) _wrap_new_wxPNMHandler, METH_VARARGS | METH_KEYWORDS },
2328          { "new_wxGIFHandler", (PyCFunction) _wrap_new_wxGIFHandler, METH_VARARGS | METH_KEYWORDS },
2329          { "new_wxBMPHandler", (PyCFunction) _wrap_new_wxBMPHandler, METH_VARARGS | METH_KEYWORDS },
2330          { "new_wxJPEGHandler", (PyCFunction) _wrap_new_wxJPEGHandler, METH_VARARGS | METH_KEYWORDS },
2331          { "new_wxPNGHandler", (PyCFunction) _wrap_new_wxPNGHandler, METH_VARARGS | METH_KEYWORDS },
2332          { "wxImageHandler_SetMimeType", (PyCFunction) _wrap_wxImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS },
2333          { "wxImageHandler_SetType", (PyCFunction) _wrap_wxImageHandler_SetType, METH_VARARGS | METH_KEYWORDS },
2334          { "wxImageHandler_SetExtension", (PyCFunction) _wrap_wxImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS },
2335          { "wxImageHandler_SetName", (PyCFunction) _wrap_wxImageHandler_SetName, METH_VARARGS | METH_KEYWORDS },
2336          { "wxImageHandler_GetMimeType", (PyCFunction) _wrap_wxImageHandler_GetMimeType, METH_VARARGS | METH_KEYWORDS },
2337          { "wxImageHandler_GetType", (PyCFunction) _wrap_wxImageHandler_GetType, METH_VARARGS | METH_KEYWORDS },
2338          { "wxImageHandler_GetExtension", (PyCFunction) _wrap_wxImageHandler_GetExtension, METH_VARARGS | METH_KEYWORDS },
2339          { "wxImageHandler_GetName", (PyCFunction) _wrap_wxImageHandler_GetName, METH_VARARGS | METH_KEYWORDS },
2340          { "wxBitmapFromImage", (PyCFunction) _wrap_wxBitmapFromImage, METH_VARARGS | METH_KEYWORDS },
2341          { "wxInitAllImageHandlers", (PyCFunction) _wrap_wxInitAllImageHandlers, METH_VARARGS | METH_KEYWORDS },
2342          { "wxImageFromBitmap", (PyCFunction) _wrap_wxImageFromBitmap, METH_VARARGS | METH_KEYWORDS },
2343          { "wxImageFromMime", (PyCFunction) _wrap_wxImageFromMime, METH_VARARGS | METH_KEYWORDS },
2344          { "wxEmptyImage", (PyCFunction) _wrap_wxEmptyImage, METH_VARARGS | METH_KEYWORDS },
2345          { NULL, NULL }
2346 };
2347 #ifdef __cplusplus
2348 }
2349 #endif
2350 /*
2351  * This table is used by the pointer type-checker
2352  */
2353 static struct { char *n1; char *n2; void *(*pcnv)(void *); } _swig_mapping[] = {
2354     { "_wxAcceleratorTable","_class_wxAcceleratorTable",0},
2355     { "_signed_long","_long",0},
2356     { "_class_wxJPEGHandler","_wxJPEGHandler",0},
2357     { "_wxBMPHandler","_class_wxBMPHandler",0},
2358     { "_wxImage","_class_wxImage",0},
2359     { "_wxPrintQuality","_wxCoord",0},
2360     { "_wxPrintQuality","_int",0},
2361     { "_wxPrintQuality","_signed_int",0},
2362     { "_wxPrintQuality","_unsigned_int",0},
2363     { "_wxPrintQuality","_wxWindowID",0},
2364     { "_wxPrintQuality","_uint",0},
2365     { "_wxPrintQuality","_EBool",0},
2366     { "_wxPrintQuality","_size_t",0},
2367     { "_wxPrintQuality","_time_t",0},
2368     { "_class_wxRegionIterator","_wxRegionIterator",0},
2369     { "_wxGIFHandler","_class_wxGIFHandler",0},
2370     { "_wxIndividualLayoutConstraint","_class_wxIndividualLayoutConstraint",0},
2371     { "_wxCursor","_class_wxCursor",0},
2372     { "_wxImageHandler","_class_wxTIFFHandler",SwigwxTIFFHandlerTowxImageHandler},
2373     { "_wxImageHandler","_wxTIFFHandler",SwigwxTIFFHandlerTowxImageHandler},
2374     { "_wxImageHandler","_class_wxPCXHandler",SwigwxPCXHandlerTowxImageHandler},
2375     { "_wxImageHandler","_wxPCXHandler",SwigwxPCXHandlerTowxImageHandler},
2376     { "_wxImageHandler","_class_wxPNMHandler",SwigwxPNMHandlerTowxImageHandler},
2377     { "_wxImageHandler","_wxPNMHandler",SwigwxPNMHandlerTowxImageHandler},
2378     { "_wxImageHandler","_class_wxGIFHandler",SwigwxGIFHandlerTowxImageHandler},
2379     { "_wxImageHandler","_wxGIFHandler",SwigwxGIFHandlerTowxImageHandler},
2380     { "_wxImageHandler","_class_wxBMPHandler",SwigwxBMPHandlerTowxImageHandler},
2381     { "_wxImageHandler","_wxBMPHandler",SwigwxBMPHandlerTowxImageHandler},
2382     { "_wxImageHandler","_class_wxJPEGHandler",SwigwxJPEGHandlerTowxImageHandler},
2383     { "_wxImageHandler","_wxJPEGHandler",SwigwxJPEGHandlerTowxImageHandler},
2384     { "_wxImageHandler","_class_wxPNGHandler",SwigwxPNGHandlerTowxImageHandler},
2385     { "_wxImageHandler","_wxPNGHandler",SwigwxPNGHandlerTowxImageHandler},
2386     { "_wxImageHandler","_class_wxImageHandler",0},
2387     { "_wxMask","_class_wxMask",0},
2388     { "_wxPNGHandler","_class_wxPNGHandler",0},
2389     { "_wxPen","_class_wxPen",0},
2390     { "_byte","_unsigned_char",0},
2391     { "_wxColourDatabase","_class_wxColourDatabase",0},
2392     { "_long","_unsigned_long",0},
2393     { "_long","_signed_long",0},
2394     { "_wxImageList","_class_wxImageList",0},
2395     { "_class_wxTIFFHandler","_wxTIFFHandler",0},
2396     { "_class_wxAcceleratorTable","_wxAcceleratorTable",0},
2397     { "_wxGDIObject","_class_wxGDIObject",0},
2398     { "_wxDC","_class_wxDC",0},
2399     { "_class_wxBMPHandler","_wxBMPHandler",0},
2400     { "_class_wxObject","_class_wxImage",SwigwxImageTowxObject},
2401     { "_class_wxObject","_wxImage",SwigwxImageTowxObject},
2402     { "_class_wxObject","_class_wxTIFFHandler",SwigwxTIFFHandlerTowxObject},
2403     { "_class_wxObject","_wxTIFFHandler",SwigwxTIFFHandlerTowxObject},
2404     { "_class_wxObject","_class_wxPCXHandler",SwigwxPCXHandlerTowxObject},
2405     { "_class_wxObject","_wxPCXHandler",SwigwxPCXHandlerTowxObject},
2406     { "_class_wxObject","_class_wxPNMHandler",SwigwxPNMHandlerTowxObject},
2407     { "_class_wxObject","_wxPNMHandler",SwigwxPNMHandlerTowxObject},
2408     { "_class_wxObject","_class_wxGIFHandler",SwigwxGIFHandlerTowxObject},
2409     { "_class_wxObject","_wxGIFHandler",SwigwxGIFHandlerTowxObject},
2410     { "_class_wxObject","_class_wxBMPHandler",SwigwxBMPHandlerTowxObject},
2411     { "_class_wxObject","_wxBMPHandler",SwigwxBMPHandlerTowxObject},
2412     { "_class_wxObject","_class_wxJPEGHandler",SwigwxJPEGHandlerTowxObject},
2413     { "_class_wxObject","_wxJPEGHandler",SwigwxJPEGHandlerTowxObject},
2414     { "_class_wxObject","_class_wxPNGHandler",SwigwxPNGHandlerTowxObject},
2415     { "_class_wxObject","_wxPNGHandler",SwigwxPNGHandlerTowxObject},
2416     { "_class_wxObject","_class_wxImageHandler",SwigwxImageHandlerTowxObject},
2417     { "_class_wxObject","_wxImageHandler",SwigwxImageHandlerTowxObject},
2418     { "_class_wxObject","_wxObject",0},
2419     { "_size_t","_wxCoord",0},
2420     { "_size_t","_wxPrintQuality",0},
2421     { "_size_t","_time_t",0},
2422     { "_size_t","_unsigned_int",0},
2423     { "_size_t","_int",0},
2424     { "_size_t","_wxWindowID",0},
2425     { "_size_t","_uint",0},
2426     { "_class_wxRealPoint","_wxRealPoint",0},
2427     { "_wxPNMHandler","_class_wxPNMHandler",0},
2428     { "_class_wxGIFHandler","_wxGIFHandler",0},
2429     { "_class_wxMask","_wxMask",0},
2430     { "_class_wxPNGHandler","_wxPNGHandler",0},
2431     { "_wxColour","_class_wxColour",0},
2432     { "_wxBrush","_class_wxBrush",0},
2433     { "_uint","_wxCoord",0},
2434     { "_uint","_wxPrintQuality",0},
2435     { "_uint","_time_t",0},
2436     { "_uint","_size_t",0},
2437     { "_uint","_unsigned_int",0},
2438     { "_uint","_int",0},
2439     { "_uint","_wxWindowID",0},
2440     { "_wxChar","_char",0},
2441     { "_wxRect","_class_wxRect",0},
2442     { "_class_wxImage","_wxImage",0},
2443     { "_wxPoint","_class_wxPoint",0},
2444     { "_class_wxPNMHandler","_wxPNMHandler",0},
2445     { "_char","_wxChar",0},
2446     { "_wxBitmap","_class_wxBitmap",0},
2447     { "_wxPenList","_class_wxPenList",0},
2448     { "_wxWindowDC","_class_wxWindowDC",0},
2449     { "_class_wxIndividualLayoutConstraint","_wxIndividualLayoutConstraint",0},
2450     { "_class_wxColourDatabase","_wxColourDatabase",0},
2451     { "_EBool","_wxCoord",0},
2452     { "_EBool","_wxPrintQuality",0},
2453     { "_EBool","_signed_int",0},
2454     { "_EBool","_int",0},
2455     { "_EBool","_wxWindowID",0},
2456     { "_class_wxRegion","_wxRegion",0},
2457     { "_wxFont","_class_wxFont",0},
2458     { "_unsigned_long","_long",0},
2459     { "_class_wxRect","_wxRect",0},
2460     { "_class_wxDC","_wxDC",0},
2461     { "_class_wxBrushList","_wxBrushList",0},
2462     { "_class_wxPenList","_wxPenList",0},
2463     { "_wxAcceleratorEntry","_class_wxAcceleratorEntry",0},
2464     { "_signed_int","_wxCoord",0},
2465     { "_signed_int","_wxPrintQuality",0},
2466     { "_signed_int","_EBool",0},
2467     { "_signed_int","_wxWindowID",0},
2468     { "_signed_int","_int",0},
2469     { "_wxLayoutConstraints","_class_wxLayoutConstraints",0},
2470     { "_wxMetaFileDC","_class_wxMetaFileDC",0},
2471     { "_wxScreenDC","_class_wxScreenDC",0},
2472     { "_WXTYPE","_short",0},
2473     { "_WXTYPE","_signed_short",0},
2474     { "_WXTYPE","_unsigned_short",0},
2475     { "_class_wxBrush","_wxBrush",0},
2476     { "_unsigned_short","_WXTYPE",0},
2477     { "_unsigned_short","_short",0},
2478     { "_class_wxFont","_wxFont",0},
2479     { "_wxBusyInfo","_class_wxBusyInfo",0},
2480     { "_wxFontList","_class_wxFontList",0},
2481     { "_wxClientDC","_class_wxClientDC",0},
2482     { "_wxObject","_class_wxImage",SwigwxImageTowxObject},
2483     { "_wxObject","_wxImage",SwigwxImageTowxObject},
2484     { "_wxObject","_class_wxTIFFHandler",SwigwxTIFFHandlerTowxObject},
2485     { "_wxObject","_wxTIFFHandler",SwigwxTIFFHandlerTowxObject},
2486     { "_wxObject","_class_wxPCXHandler",SwigwxPCXHandlerTowxObject},
2487     { "_wxObject","_wxPCXHandler",SwigwxPCXHandlerTowxObject},
2488     { "_wxObject","_class_wxPNMHandler",SwigwxPNMHandlerTowxObject},
2489     { "_wxObject","_wxPNMHandler",SwigwxPNMHandlerTowxObject},
2490     { "_wxObject","_class_wxGIFHandler",SwigwxGIFHandlerTowxObject},
2491     { "_wxObject","_wxGIFHandler",SwigwxGIFHandlerTowxObject},
2492     { "_wxObject","_class_wxBMPHandler",SwigwxBMPHandlerTowxObject},
2493     { "_wxObject","_wxBMPHandler",SwigwxBMPHandlerTowxObject},
2494     { "_wxObject","_class_wxJPEGHandler",SwigwxJPEGHandlerTowxObject},
2495     { "_wxObject","_wxJPEGHandler",SwigwxJPEGHandlerTowxObject},
2496     { "_wxObject","_class_wxPNGHandler",SwigwxPNGHandlerTowxObject},
2497     { "_wxObject","_wxPNGHandler",SwigwxPNGHandlerTowxObject},
2498     { "_wxObject","_class_wxImageHandler",SwigwxImageHandlerTowxObject},
2499     { "_wxObject","_wxImageHandler",SwigwxImageHandlerTowxObject},
2500     { "_wxObject","_class_wxObject",0},
2501     { "_class_wxPoint","_wxPoint",0},
2502     { "_wxRealPoint","_class_wxRealPoint",0},
2503     { "_signed_short","_WXTYPE",0},
2504     { "_signed_short","_short",0},
2505     { "_wxMemoryDC","_class_wxMemoryDC",0},
2506     { "_wxPaintDC","_class_wxPaintDC",0},
2507     { "_class_wxWindowDC","_wxWindowDC",0},
2508     { "_class_wxAcceleratorEntry","_wxAcceleratorEntry",0},
2509     { "_class_wxCursor","_wxCursor",0},
2510     { "_class_wxImageHandler","_class_wxTIFFHandler",SwigwxTIFFHandlerTowxImageHandler},
2511     { "_class_wxImageHandler","_wxTIFFHandler",SwigwxTIFFHandlerTowxImageHandler},
2512     { "_class_wxImageHandler","_class_wxPCXHandler",SwigwxPCXHandlerTowxImageHandler},
2513     { "_class_wxImageHandler","_wxPCXHandler",SwigwxPCXHandlerTowxImageHandler},
2514     { "_class_wxImageHandler","_class_wxPNMHandler",SwigwxPNMHandlerTowxImageHandler},
2515     { "_class_wxImageHandler","_wxPNMHandler",SwigwxPNMHandlerTowxImageHandler},
2516     { "_class_wxImageHandler","_class_wxGIFHandler",SwigwxGIFHandlerTowxImageHandler},
2517     { "_class_wxImageHandler","_wxGIFHandler",SwigwxGIFHandlerTowxImageHandler},
2518     { "_class_wxImageHandler","_class_wxBMPHandler",SwigwxBMPHandlerTowxImageHandler},
2519     { "_class_wxImageHandler","_wxBMPHandler",SwigwxBMPHandlerTowxImageHandler},
2520     { "_class_wxImageHandler","_class_wxJPEGHandler",SwigwxJPEGHandlerTowxImageHandler},
2521     { "_class_wxImageHandler","_wxJPEGHandler",SwigwxJPEGHandlerTowxImageHandler},
2522     { "_class_wxImageHandler","_class_wxPNGHandler",SwigwxPNGHandlerTowxImageHandler},
2523     { "_class_wxImageHandler","_wxPNGHandler",SwigwxPNGHandlerTowxImageHandler},
2524     { "_class_wxImageHandler","_wxImageHandler",0},
2525     { "_unsigned_char","_byte",0},
2526     { "_class_wxMetaFileDC","_wxMetaFileDC",0},
2527     { "_unsigned_int","_wxCoord",0},
2528     { "_unsigned_int","_wxPrintQuality",0},
2529     { "_unsigned_int","_time_t",0},
2530     { "_unsigned_int","_size_t",0},
2531     { "_unsigned_int","_uint",0},
2532     { "_unsigned_int","_wxWindowID",0},
2533     { "_unsigned_int","_int",0},
2534     { "_wxIcon","_class_wxIcon",0},
2535     { "_class_wxPen","_wxPen",0},
2536     { "_short","_WXTYPE",0},
2537     { "_short","_unsigned_short",0},
2538     { "_short","_signed_short",0},
2539     { "_class_wxImageList","_wxImageList",0},
2540     { "_wxPCXHandler","_class_wxPCXHandler",0},
2541     { "_wxJPEGHandler","_class_wxJPEGHandler",0},
2542     { "_wxWindowID","_wxCoord",0},
2543     { "_wxWindowID","_wxPrintQuality",0},
2544     { "_wxWindowID","_time_t",0},
2545     { "_wxWindowID","_size_t",0},
2546     { "_wxWindowID","_EBool",0},
2547     { "_wxWindowID","_uint",0},
2548     { "_wxWindowID","_int",0},
2549     { "_wxWindowID","_signed_int",0},
2550     { "_wxWindowID","_unsigned_int",0},
2551     { "_class_wxGDIObject","_wxGDIObject",0},
2552     { "_int","_wxCoord",0},
2553     { "_int","_wxPrintQuality",0},
2554     { "_int","_time_t",0},
2555     { "_int","_size_t",0},
2556     { "_int","_EBool",0},
2557     { "_int","_uint",0},
2558     { "_int","_wxWindowID",0},
2559     { "_int","_unsigned_int",0},
2560     { "_int","_signed_int",0},
2561     { "_time_t","_wxCoord",0},
2562     { "_time_t","_wxPrintQuality",0},
2563     { "_time_t","_unsigned_int",0},
2564     { "_time_t","_int",0},
2565     { "_time_t","_wxWindowID",0},
2566     { "_time_t","_uint",0},
2567     { "_time_t","_size_t",0},
2568     { "_wxSize","_class_wxSize",0},
2569     { "_wxRegionIterator","_class_wxRegionIterator",0},
2570     { "_class_wxPaintDC","_wxPaintDC",0},
2571     { "_class_wxLayoutConstraints","_wxLayoutConstraints",0},
2572     { "_class_wxIcon","_wxIcon",0},
2573     { "_class_wxColour","_wxColour",0},
2574     { "_class_wxScreenDC","_wxScreenDC",0},
2575     { "_wxPalette","_class_wxPalette",0},
2576     { "_wxCoord","_int",0},
2577     { "_wxCoord","_signed_int",0},
2578     { "_wxCoord","_unsigned_int",0},
2579     { "_wxCoord","_wxWindowID",0},
2580     { "_wxCoord","_uint",0},
2581     { "_wxCoord","_EBool",0},
2582     { "_wxCoord","_size_t",0},
2583     { "_wxCoord","_time_t",0},
2584     { "_wxCoord","_wxPrintQuality",0},
2585     { "_wxRegion","_class_wxRegion",0},
2586     { "_class_wxPCXHandler","_wxPCXHandler",0},
2587     { "_wxTIFFHandler","_class_wxTIFFHandler",0},
2588     { "_class_wxBusyInfo","_wxBusyInfo",0},
2589     { "_class_wxFontList","_wxFontList",0},
2590     { "_class_wxClientDC","_wxClientDC",0},
2591     { "_wxBrushList","_class_wxBrushList",0},
2592     { "_class_wxSize","_wxSize",0},
2593     { "_class_wxBitmap","_wxBitmap",0},
2594     { "_class_wxMemoryDC","_wxMemoryDC",0},
2595     { "_class_wxPalette","_wxPalette",0},
2596 {0,0,0}};
2597
2598 static PyObject *SWIG_globals;
2599 #ifdef __cplusplus
2600 extern "C"
2601 #endif
2602 SWIGEXPORT(void) initimagec() {
2603          PyObject *m, *d;
2604          SWIG_globals = SWIG_newvarlink();
2605          m = Py_InitModule("imagec", imagecMethods);
2606          d = PyModule_GetDict(m);
2607          PyDict_SetItemString(d,"cvar", SWIG_globals);
2608          SWIG_addvarlink(SWIG_globals,"wxNullImage",_wrap_wxNullImage_get, _wrap_wxNullImage_set);
2609 {
2610    int i;
2611    for (i = 0; _swig_mapping[i].n1; i++)
2612         SWIG_RegisterMapping(_swig_mapping[i].n1,_swig_mapping[i].n2,_swig_mapping[i].pcnv);
2613 }
2614 }