wxPython/src/gtk/image.cpp

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