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