wxPython/src/msw/image.cpp

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