wxPython/src/gtk/image.cpp

   1 /*
   2  * FILE : src/gtk/image.cpp
   3  *
   4  * This file was automatically generated by :
   5  * Simplified Wrapper and Interface Generator (SWIG)
   6  * Version 1.1 (Build 883)
   7  *
   8  * Portions Copyright (c) 1995-1998
   9  * The University of Utah and The Regents of the University of California.
  10  * Permission is granted to distribute this file in any manner provided
  11  * this notice remains intact.
  12  *
  13  * Do not make changes to this file--changes will be lost!
  14  *
  15  */
  16
  17
  18 #define SWIGCODE
  19 /* Implementation : PYTHON */
  20
  21 #define SWIGPYTHON
  22 #include <string.h>
  23 #include <stdlib.h>
  24 /* Definitions for Windows/Unix exporting */
  25 #if defined(__WIN32__)
  26 #   if defined(_MSC_VER)
  27 #       define SWIGEXPORT(a) __declspec(dllexport) a
  28 #   else
  29 #       if defined(__BORLANDC__)
  30 #           define SWIGEXPORT(a) a _export
  31 #       else
  32 #           define SWIGEXPORT(a) a
  33 #       endif
  34 #   endif
  35 #else
  36 #   define SWIGEXPORT(a) a
  37 #endif
  38
  39 #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_ConvertToMonoBitmap(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->ConvertToMonoBitmap(_swigarg0,_swigarg1,_swigarg2))
 975 static PyObject *_wrap_wxImage_ConvertToMonoBitmap(PyObject *self, PyObject *args, PyObject *kwargs) {
 976     PyObject * _resultobj;
 977     wxBitmap * _result;
 978     wxImage * _arg0;
 979     unsigned char  _arg1;
 980     unsigned char  _arg2;
 981     unsigned char  _arg3;
 982     PyObject * _argo0 = 0;
 983     char *_kwnames[] = { "self","red","green","blue", NULL };
 984     char _ptemp[128];
 985
 986     self = self;
 987     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Obbb:wxImage_ConvertToMonoBitmap",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3))
 988         return NULL;
 989     if (_argo0) {
 990         if (_argo0 == Py_None) { _arg0 = NULL; }
 991         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
 992             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_ConvertToMonoBitmap. Expected _wxImage_p.");
 993         return NULL;
 994         }
 995     }
 996 {
 997     wxPy_BEGIN_ALLOW_THREADS;
 998         _result = new wxBitmap (wxImage_ConvertToMonoBitmap(_arg0,_arg1,_arg2,_arg3));
 999
1000     wxPy_END_ALLOW_THREADS;
1001 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxBitmap_p");
1002     _resultobj = Py_BuildValue("s",_ptemp);
1003     return _resultobj;
1004 }
1005
1006 #define wxImage_Create(_swigobj,_swigarg0,_swigarg1)  (_swigobj->Create(_swigarg0,_swigarg1))
1007 static PyObject *_wrap_wxImage_Create(PyObject *self, PyObject *args, PyObject *kwargs) {
1008     PyObject * _resultobj;
1009     wxImage * _arg0;
1010     int  _arg1;
1011     int  _arg2;
1012     PyObject * _argo0 = 0;
1013     char *_kwnames[] = { "self","width","height", NULL };
1014
1015     self = self;
1016     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxImage_Create",_kwnames,&_argo0,&_arg1,&_arg2))
1017         return NULL;
1018     if (_argo0) {
1019         if (_argo0 == Py_None) { _arg0 = NULL; }
1020         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1021             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_Create. Expected _wxImage_p.");
1022         return NULL;
1023         }
1024     }
1025 {
1026     wxPy_BEGIN_ALLOW_THREADS;
1027         wxImage_Create(_arg0,_arg1,_arg2);
1028
1029     wxPy_END_ALLOW_THREADS;
1030 }    Py_INCREF(Py_None);
1031     _resultobj = Py_None;
1032     return _resultobj;
1033 }
1034
1035 #define wxImage_Destroy(_swigobj)  (_swigobj->Destroy())
1036 static PyObject *_wrap_wxImage_Destroy(PyObject *self, PyObject *args, PyObject *kwargs) {
1037     PyObject * _resultobj;
1038     wxImage * _arg0;
1039     PyObject * _argo0 = 0;
1040     char *_kwnames[] = { "self", NULL };
1041
1042     self = self;
1043     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_Destroy",_kwnames,&_argo0))
1044         return NULL;
1045     if (_argo0) {
1046         if (_argo0 == Py_None) { _arg0 = NULL; }
1047         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1048             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_Destroy. Expected _wxImage_p.");
1049         return NULL;
1050         }
1051     }
1052 {
1053     wxPy_BEGIN_ALLOW_THREADS;
1054         wxImage_Destroy(_arg0);
1055
1056     wxPy_END_ALLOW_THREADS;
1057 }    Py_INCREF(Py_None);
1058     _resultobj = Py_None;
1059     return _resultobj;
1060 }
1061
1062 #define wxImage_Scale(_swigobj,_swigarg0,_swigarg1)  (_swigobj->Scale(_swigarg0,_swigarg1))
1063 static PyObject *_wrap_wxImage_Scale(PyObject *self, PyObject *args, PyObject *kwargs) {
1064     PyObject * _resultobj;
1065     wxImage * _result;
1066     wxImage * _arg0;
1067     int  _arg1;
1068     int  _arg2;
1069     PyObject * _argo0 = 0;
1070     char *_kwnames[] = { "self","width","height", NULL };
1071     char _ptemp[128];
1072
1073     self = self;
1074     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxImage_Scale",_kwnames,&_argo0,&_arg1,&_arg2))
1075         return NULL;
1076     if (_argo0) {
1077         if (_argo0 == Py_None) { _arg0 = NULL; }
1078         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1079             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_Scale. Expected _wxImage_p.");
1080         return NULL;
1081         }
1082     }
1083 {
1084     wxPy_BEGIN_ALLOW_THREADS;
1085         _result = new wxImage (wxImage_Scale(_arg0,_arg1,_arg2));
1086
1087     wxPy_END_ALLOW_THREADS;
1088 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxImage_p");
1089     _resultobj = Py_BuildValue("s",_ptemp);
1090     return _resultobj;
1091 }
1092
1093 #define wxImage_Rescale(_swigobj,_swigarg0,_swigarg1)  (_swigobj->Rescale(_swigarg0,_swigarg1))
1094 static PyObject *_wrap_wxImage_Rescale(PyObject *self, PyObject *args, PyObject *kwargs) {
1095     PyObject * _resultobj;
1096     wxImage * _result;
1097     wxImage * _arg0;
1098     int  _arg1;
1099     int  _arg2;
1100     PyObject * _argo0 = 0;
1101     char *_kwnames[] = { "self","width","height", NULL };
1102     char _ptemp[128];
1103
1104     self = self;
1105     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxImage_Rescale",_kwnames,&_argo0,&_arg1,&_arg2))
1106         return NULL;
1107     if (_argo0) {
1108         if (_argo0 == Py_None) { _arg0 = NULL; }
1109         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1110             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_Rescale. Expected _wxImage_p.");
1111         return NULL;
1112         }
1113     }
1114 {
1115     wxPy_BEGIN_ALLOW_THREADS;
1116         wxImage & _result_ref = wxImage_Rescale(_arg0,_arg1,_arg2);
1117     _result = (wxImage *) &_result_ref;
1118
1119     wxPy_END_ALLOW_THREADS;
1120 }    if (_result) {
1121         SWIG_MakePtr(_ptemp, (char *) _result,"_wxImage_p");
1122         _resultobj = Py_BuildValue("s",_ptemp);
1123     } else {
1124         Py_INCREF(Py_None);
1125         _resultobj = Py_None;
1126     }
1127     return _resultobj;
1128 }
1129
1130 #define wxImage_SetRGB(_swigobj,_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4)  (_swigobj->SetRGB(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4))
1131 static PyObject *_wrap_wxImage_SetRGB(PyObject *self, PyObject *args, PyObject *kwargs) {
1132     PyObject * _resultobj;
1133     wxImage * _arg0;
1134     int  _arg1;
1135     int  _arg2;
1136     unsigned char  _arg3;
1137     unsigned char  _arg4;
1138     unsigned char  _arg5;
1139     PyObject * _argo0 = 0;
1140     char *_kwnames[] = { "self","x","y","r","g","b", NULL };
1141
1142     self = self;
1143     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oiibbb:wxImage_SetRGB",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3,&_arg4,&_arg5))
1144         return NULL;
1145     if (_argo0) {
1146         if (_argo0 == Py_None) { _arg0 = NULL; }
1147         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1148             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_SetRGB. Expected _wxImage_p.");
1149         return NULL;
1150         }
1151     }
1152 {
1153     wxPy_BEGIN_ALLOW_THREADS;
1154         wxImage_SetRGB(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5);
1155
1156     wxPy_END_ALLOW_THREADS;
1157 }    Py_INCREF(Py_None);
1158     _resultobj = Py_None;
1159     return _resultobj;
1160 }
1161
1162 #define wxImage_GetRed(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetRed(_swigarg0,_swigarg1))
1163 static PyObject *_wrap_wxImage_GetRed(PyObject *self, PyObject *args, PyObject *kwargs) {
1164     PyObject * _resultobj;
1165     unsigned char  _result;
1166     wxImage * _arg0;
1167     int  _arg1;
1168     int  _arg2;
1169     PyObject * _argo0 = 0;
1170     char *_kwnames[] = { "self","x","y", NULL };
1171
1172     self = self;
1173     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxImage_GetRed",_kwnames,&_argo0,&_arg1,&_arg2))
1174         return NULL;
1175     if (_argo0) {
1176         if (_argo0 == Py_None) { _arg0 = NULL; }
1177         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1178             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetRed. Expected _wxImage_p.");
1179         return NULL;
1180         }
1181     }
1182 {
1183     wxPy_BEGIN_ALLOW_THREADS;
1184         _result = (unsigned char )wxImage_GetRed(_arg0,_arg1,_arg2);
1185
1186     wxPy_END_ALLOW_THREADS;
1187 }    _resultobj = Py_BuildValue("b",_result);
1188     return _resultobj;
1189 }
1190
1191 #define wxImage_GetGreen(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetGreen(_swigarg0,_swigarg1))
1192 static PyObject *_wrap_wxImage_GetGreen(PyObject *self, PyObject *args, PyObject *kwargs) {
1193     PyObject * _resultobj;
1194     unsigned char  _result;
1195     wxImage * _arg0;
1196     int  _arg1;
1197     int  _arg2;
1198     PyObject * _argo0 = 0;
1199     char *_kwnames[] = { "self","x","y", NULL };
1200
1201     self = self;
1202     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxImage_GetGreen",_kwnames,&_argo0,&_arg1,&_arg2))
1203         return NULL;
1204     if (_argo0) {
1205         if (_argo0 == Py_None) { _arg0 = NULL; }
1206         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1207             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetGreen. Expected _wxImage_p.");
1208         return NULL;
1209         }
1210     }
1211 {
1212     wxPy_BEGIN_ALLOW_THREADS;
1213         _result = (unsigned char )wxImage_GetGreen(_arg0,_arg1,_arg2);
1214
1215     wxPy_END_ALLOW_THREADS;
1216 }    _resultobj = Py_BuildValue("b",_result);
1217     return _resultobj;
1218 }
1219
1220 #define wxImage_GetBlue(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetBlue(_swigarg0,_swigarg1))
1221 static PyObject *_wrap_wxImage_GetBlue(PyObject *self, PyObject *args, PyObject *kwargs) {
1222     PyObject * _resultobj;
1223     unsigned char  _result;
1224     wxImage * _arg0;
1225     int  _arg1;
1226     int  _arg2;
1227     PyObject * _argo0 = 0;
1228     char *_kwnames[] = { "self","x","y", NULL };
1229
1230     self = self;
1231     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxImage_GetBlue",_kwnames,&_argo0,&_arg1,&_arg2))
1232         return NULL;
1233     if (_argo0) {
1234         if (_argo0 == Py_None) { _arg0 = NULL; }
1235         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1236             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetBlue. Expected _wxImage_p.");
1237         return NULL;
1238         }
1239     }
1240 {
1241     wxPy_BEGIN_ALLOW_THREADS;
1242         _result = (unsigned char )wxImage_GetBlue(_arg0,_arg1,_arg2);
1243
1244     wxPy_END_ALLOW_THREADS;
1245 }    _resultobj = Py_BuildValue("b",_result);
1246     return _resultobj;
1247 }
1248
1249 static PyObject *_wrap_wxImage_CanRead(PyObject *self, PyObject *args, PyObject *kwargs) {
1250     PyObject * _resultobj;
1251     bool  _result;
1252     wxString * _arg0;
1253     PyObject * _obj0 = 0;
1254     char *_kwnames[] = { "name", NULL };
1255
1256     self = self;
1257     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_CanRead",_kwnames,&_obj0))
1258         return NULL;
1259 {
1260 #if PYTHON_API_VERSION >= 1009
1261     char* tmpPtr; int tmpSize;
1262     if (!PyString_Check(_obj0) && !PyUnicode_Check(_obj0)) {
1263         PyErr_SetString(PyExc_TypeError, "String or Unicode type required");
1264         return NULL;
1265     }
1266     if (PyString_AsStringAndSize(_obj0, &tmpPtr, &tmpSize) == -1)
1267         return NULL;
1268     _arg0 = new wxString(tmpPtr, tmpSize);
1269 #else
1270     if (!PyString_Check(_obj0)) {
1271         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1272         return NULL;
1273     }
1274     _arg0 = new wxString(PyString_AS_STRING(_obj0), PyString_GET_SIZE(_obj0));
1275 #endif
1276 }
1277 {
1278     wxPy_BEGIN_ALLOW_THREADS;
1279         _result = (bool )wxImage::CanRead(*_arg0);
1280
1281     wxPy_END_ALLOW_THREADS;
1282 }    _resultobj = Py_BuildValue("i",_result);
1283 {
1284     if (_obj0)
1285         delete _arg0;
1286 }
1287     return _resultobj;
1288 }
1289
1290 #define wxImage_LoadFile(_swigobj,_swigarg0,_swigarg1)  (_swigobj->LoadFile(_swigarg0,_swigarg1))
1291 static PyObject *_wrap_wxImage_LoadFile(PyObject *self, PyObject *args, PyObject *kwargs) {
1292     PyObject * _resultobj;
1293     bool  _result;
1294     wxImage * _arg0;
1295     wxString * _arg1;
1296     long  _arg2 = (long ) wxBITMAP_TYPE_ANY;
1297     PyObject * _argo0 = 0;
1298     PyObject * _obj1 = 0;
1299     char *_kwnames[] = { "self","name","type", NULL };
1300
1301     self = self;
1302     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO|l:wxImage_LoadFile",_kwnames,&_argo0,&_obj1,&_arg2))
1303         return NULL;
1304     if (_argo0) {
1305         if (_argo0 == Py_None) { _arg0 = NULL; }
1306         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1307             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_LoadFile. Expected _wxImage_p.");
1308         return NULL;
1309         }
1310     }
1311 {
1312 #if PYTHON_API_VERSION >= 1009
1313     char* tmpPtr; int tmpSize;
1314     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
1315         PyErr_SetString(PyExc_TypeError, "String or Unicode type required");
1316         return NULL;
1317     }
1318     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
1319         return NULL;
1320     _arg1 = new wxString(tmpPtr, tmpSize);
1321 #else
1322     if (!PyString_Check(_obj1)) {
1323         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1324         return NULL;
1325     }
1326     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
1327 #endif
1328 }
1329 {
1330     wxPy_BEGIN_ALLOW_THREADS;
1331         _result = (bool )wxImage_LoadFile(_arg0,*_arg1,_arg2);
1332
1333     wxPy_END_ALLOW_THREADS;
1334 }    _resultobj = Py_BuildValue("i",_result);
1335 {
1336     if (_obj1)
1337         delete _arg1;
1338 }
1339     return _resultobj;
1340 }
1341
1342 #define wxImage_LoadMimeFile(_swigobj,_swigarg0,_swigarg1)  (_swigobj->LoadFile(_swigarg0,_swigarg1))
1343 static PyObject *_wrap_wxImage_LoadMimeFile(PyObject *self, PyObject *args, PyObject *kwargs) {
1344     PyObject * _resultobj;
1345     bool  _result;
1346     wxImage * _arg0;
1347     wxString * _arg1;
1348     wxString * _arg2;
1349     PyObject * _argo0 = 0;
1350     PyObject * _obj1 = 0;
1351     PyObject * _obj2 = 0;
1352     char *_kwnames[] = { "self","name","mimetype", NULL };
1353
1354     self = self;
1355     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO:wxImage_LoadMimeFile",_kwnames,&_argo0,&_obj1,&_obj2))
1356         return NULL;
1357     if (_argo0) {
1358         if (_argo0 == Py_None) { _arg0 = NULL; }
1359         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1360             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_LoadMimeFile. Expected _wxImage_p.");
1361         return NULL;
1362         }
1363     }
1364 {
1365 #if PYTHON_API_VERSION >= 1009
1366     char* tmpPtr; int tmpSize;
1367     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
1368         PyErr_SetString(PyExc_TypeError, "String or Unicode type required");
1369         return NULL;
1370     }
1371     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
1372         return NULL;
1373     _arg1 = new wxString(tmpPtr, tmpSize);
1374 #else
1375     if (!PyString_Check(_obj1)) {
1376         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1377         return NULL;
1378     }
1379     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
1380 #endif
1381 }
1382 {
1383 #if PYTHON_API_VERSION >= 1009
1384     char* tmpPtr; int tmpSize;
1385     if (!PyString_Check(_obj2) && !PyUnicode_Check(_obj2)) {
1386         PyErr_SetString(PyExc_TypeError, "String or Unicode type required");
1387         return NULL;
1388     }
1389     if (PyString_AsStringAndSize(_obj2, &tmpPtr, &tmpSize) == -1)
1390         return NULL;
1391     _arg2 = new wxString(tmpPtr, tmpSize);
1392 #else
1393     if (!PyString_Check(_obj2)) {
1394         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1395         return NULL;
1396     }
1397     _arg2 = new wxString(PyString_AS_STRING(_obj2), PyString_GET_SIZE(_obj2));
1398 #endif
1399 }
1400 {
1401     wxPy_BEGIN_ALLOW_THREADS;
1402         _result = (bool )wxImage_LoadMimeFile(_arg0,*_arg1,*_arg2);
1403
1404     wxPy_END_ALLOW_THREADS;
1405 }    _resultobj = Py_BuildValue("i",_result);
1406 {
1407     if (_obj1)
1408         delete _arg1;
1409 }
1410 {
1411     if (_obj2)
1412         delete _arg2;
1413 }
1414     return _resultobj;
1415 }
1416
1417 #define wxImage_SaveFile(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SaveFile(_swigarg0,_swigarg1))
1418 static PyObject *_wrap_wxImage_SaveFile(PyObject *self, PyObject *args, PyObject *kwargs) {
1419     PyObject * _resultobj;
1420     bool  _result;
1421     wxImage * _arg0;
1422     wxString * _arg1;
1423     int  _arg2;
1424     PyObject * _argo0 = 0;
1425     PyObject * _obj1 = 0;
1426     char *_kwnames[] = { "self","name","type", NULL };
1427
1428     self = self;
1429     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOi:wxImage_SaveFile",_kwnames,&_argo0,&_obj1,&_arg2))
1430         return NULL;
1431     if (_argo0) {
1432         if (_argo0 == Py_None) { _arg0 = NULL; }
1433         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1434             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_SaveFile. Expected _wxImage_p.");
1435         return NULL;
1436         }
1437     }
1438 {
1439 #if PYTHON_API_VERSION >= 1009
1440     char* tmpPtr; int tmpSize;
1441     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
1442         PyErr_SetString(PyExc_TypeError, "String or Unicode type required");
1443         return NULL;
1444     }
1445     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
1446         return NULL;
1447     _arg1 = new wxString(tmpPtr, tmpSize);
1448 #else
1449     if (!PyString_Check(_obj1)) {
1450         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1451         return NULL;
1452     }
1453     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
1454 #endif
1455 }
1456 {
1457     wxPy_BEGIN_ALLOW_THREADS;
1458         _result = (bool )wxImage_SaveFile(_arg0,*_arg1,_arg2);
1459
1460     wxPy_END_ALLOW_THREADS;
1461 }    _resultobj = Py_BuildValue("i",_result);
1462 {
1463     if (_obj1)
1464         delete _arg1;
1465 }
1466     return _resultobj;
1467 }
1468
1469 #define wxImage_SaveMimeFile(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SaveFile(_swigarg0,_swigarg1))
1470 static PyObject *_wrap_wxImage_SaveMimeFile(PyObject *self, PyObject *args, PyObject *kwargs) {
1471     PyObject * _resultobj;
1472     bool  _result;
1473     wxImage * _arg0;
1474     wxString * _arg1;
1475     wxString * _arg2;
1476     PyObject * _argo0 = 0;
1477     PyObject * _obj1 = 0;
1478     PyObject * _obj2 = 0;
1479     char *_kwnames[] = { "self","name","mimetype", NULL };
1480
1481     self = self;
1482     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO:wxImage_SaveMimeFile",_kwnames,&_argo0,&_obj1,&_obj2))
1483         return NULL;
1484     if (_argo0) {
1485         if (_argo0 == Py_None) { _arg0 = NULL; }
1486         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1487             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_SaveMimeFile. Expected _wxImage_p.");
1488         return NULL;
1489         }
1490     }
1491 {
1492 #if PYTHON_API_VERSION >= 1009
1493     char* tmpPtr; int tmpSize;
1494     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
1495         PyErr_SetString(PyExc_TypeError, "String or Unicode type required");
1496         return NULL;
1497     }
1498     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
1499         return NULL;
1500     _arg1 = new wxString(tmpPtr, tmpSize);
1501 #else
1502     if (!PyString_Check(_obj1)) {
1503         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1504         return NULL;
1505     }
1506     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
1507 #endif
1508 }
1509 {
1510 #if PYTHON_API_VERSION >= 1009
1511     char* tmpPtr; int tmpSize;
1512     if (!PyString_Check(_obj2) && !PyUnicode_Check(_obj2)) {
1513         PyErr_SetString(PyExc_TypeError, "String or Unicode type required");
1514         return NULL;
1515     }
1516     if (PyString_AsStringAndSize(_obj2, &tmpPtr, &tmpSize) == -1)
1517         return NULL;
1518     _arg2 = new wxString(tmpPtr, tmpSize);
1519 #else
1520     if (!PyString_Check(_obj2)) {
1521         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1522         return NULL;
1523     }
1524     _arg2 = new wxString(PyString_AS_STRING(_obj2), PyString_GET_SIZE(_obj2));
1525 #endif
1526 }
1527 {
1528     wxPy_BEGIN_ALLOW_THREADS;
1529         _result = (bool )wxImage_SaveMimeFile(_arg0,*_arg1,*_arg2);
1530
1531     wxPy_END_ALLOW_THREADS;
1532 }    _resultobj = Py_BuildValue("i",_result);
1533 {
1534     if (_obj1)
1535         delete _arg1;
1536 }
1537 {
1538     if (_obj2)
1539         delete _arg2;
1540 }
1541     return _resultobj;
1542 }
1543
1544 #define wxImage_Ok(_swigobj)  (_swigobj->Ok())
1545 static PyObject *_wrap_wxImage_Ok(PyObject *self, PyObject *args, PyObject *kwargs) {
1546     PyObject * _resultobj;
1547     bool  _result;
1548     wxImage * _arg0;
1549     PyObject * _argo0 = 0;
1550     char *_kwnames[] = { "self", NULL };
1551
1552     self = self;
1553     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_Ok",_kwnames,&_argo0))
1554         return NULL;
1555     if (_argo0) {
1556         if (_argo0 == Py_None) { _arg0 = NULL; }
1557         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1558             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_Ok. Expected _wxImage_p.");
1559         return NULL;
1560         }
1561     }
1562 {
1563     wxPy_BEGIN_ALLOW_THREADS;
1564         _result = (bool )wxImage_Ok(_arg0);
1565
1566     wxPy_END_ALLOW_THREADS;
1567 }    _resultobj = Py_BuildValue("i",_result);
1568     return _resultobj;
1569 }
1570
1571 #define wxImage_GetWidth(_swigobj)  (_swigobj->GetWidth())
1572 static PyObject *_wrap_wxImage_GetWidth(PyObject *self, PyObject *args, PyObject *kwargs) {
1573     PyObject * _resultobj;
1574     int  _result;
1575     wxImage * _arg0;
1576     PyObject * _argo0 = 0;
1577     char *_kwnames[] = { "self", NULL };
1578
1579     self = self;
1580     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_GetWidth",_kwnames,&_argo0))
1581         return NULL;
1582     if (_argo0) {
1583         if (_argo0 == Py_None) { _arg0 = NULL; }
1584         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1585             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetWidth. Expected _wxImage_p.");
1586         return NULL;
1587         }
1588     }
1589 {
1590     wxPy_BEGIN_ALLOW_THREADS;
1591         _result = (int )wxImage_GetWidth(_arg0);
1592
1593     wxPy_END_ALLOW_THREADS;
1594 }    _resultobj = Py_BuildValue("i",_result);
1595     return _resultobj;
1596 }
1597
1598 #define wxImage_GetHeight(_swigobj)  (_swigobj->GetHeight())
1599 static PyObject *_wrap_wxImage_GetHeight(PyObject *self, PyObject *args, PyObject *kwargs) {
1600     PyObject * _resultobj;
1601     int  _result;
1602     wxImage * _arg0;
1603     PyObject * _argo0 = 0;
1604     char *_kwnames[] = { "self", NULL };
1605
1606     self = self;
1607     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_GetHeight",_kwnames,&_argo0))
1608         return NULL;
1609     if (_argo0) {
1610         if (_argo0 == Py_None) { _arg0 = NULL; }
1611         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1612             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetHeight. Expected _wxImage_p.");
1613         return NULL;
1614         }
1615     }
1616 {
1617     wxPy_BEGIN_ALLOW_THREADS;
1618         _result = (int )wxImage_GetHeight(_arg0);
1619
1620     wxPy_END_ALLOW_THREADS;
1621 }    _resultobj = Py_BuildValue("i",_result);
1622     return _resultobj;
1623 }
1624
1625 #define wxImage_GetSubImage(_swigobj,_swigarg0)  (_swigobj->GetSubImage(_swigarg0))
1626 static PyObject *_wrap_wxImage_GetSubImage(PyObject *self, PyObject *args, PyObject *kwargs) {
1627     PyObject * _resultobj;
1628     wxImage * _result;
1629     wxImage * _arg0;
1630     wxRect * _arg1;
1631     PyObject * _argo0 = 0;
1632     wxRect  temp;
1633     PyObject * _obj1 = 0;
1634     char *_kwnames[] = { "self","rect", NULL };
1635     char _ptemp[128];
1636
1637     self = self;
1638     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxImage_GetSubImage",_kwnames,&_argo0,&_obj1))
1639         return NULL;
1640     if (_argo0) {
1641         if (_argo0 == Py_None) { _arg0 = NULL; }
1642         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1643             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetSubImage. Expected _wxImage_p.");
1644         return NULL;
1645         }
1646     }
1647 {
1648     _arg1 = &temp;
1649     if (! wxRect_helper(_obj1, &_arg1))
1650         return NULL;
1651 }
1652 {
1653     wxPy_BEGIN_ALLOW_THREADS;
1654         _result = new wxImage (wxImage_GetSubImage(_arg0,*_arg1));
1655
1656     wxPy_END_ALLOW_THREADS;
1657 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxImage_p");
1658     _resultobj = Py_BuildValue("s",_ptemp);
1659     return _resultobj;
1660 }
1661
1662 #define wxImage_Copy(_swigobj)  (_swigobj->Copy())
1663 static PyObject *_wrap_wxImage_Copy(PyObject *self, PyObject *args, PyObject *kwargs) {
1664     PyObject * _resultobj;
1665     wxImage * _result;
1666     wxImage * _arg0;
1667     PyObject * _argo0 = 0;
1668     char *_kwnames[] = { "self", NULL };
1669     char _ptemp[128];
1670
1671     self = self;
1672     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_Copy",_kwnames,&_argo0))
1673         return NULL;
1674     if (_argo0) {
1675         if (_argo0 == Py_None) { _arg0 = NULL; }
1676         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1677             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_Copy. Expected _wxImage_p.");
1678         return NULL;
1679         }
1680     }
1681 {
1682     wxPy_BEGIN_ALLOW_THREADS;
1683         _result = new wxImage (wxImage_Copy(_arg0));
1684
1685     wxPy_END_ALLOW_THREADS;
1686 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxImage_p");
1687     _resultobj = Py_BuildValue("s",_ptemp);
1688     return _resultobj;
1689 }
1690
1691 #define wxImage_Paste(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->Paste(_swigarg0,_swigarg1,_swigarg2))
1692 static PyObject *_wrap_wxImage_Paste(PyObject *self, PyObject *args, PyObject *kwargs) {
1693     PyObject * _resultobj;
1694     wxImage * _arg0;
1695     wxImage * _arg1;
1696     int  _arg2;
1697     int  _arg3;
1698     PyObject * _argo0 = 0;
1699     PyObject * _argo1 = 0;
1700     char *_kwnames[] = { "self","image","x","y", NULL };
1701
1702     self = self;
1703     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOii:wxImage_Paste",_kwnames,&_argo0,&_argo1,&_arg2,&_arg3))
1704         return NULL;
1705     if (_argo0) {
1706         if (_argo0 == Py_None) { _arg0 = NULL; }
1707         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1708             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_Paste. Expected _wxImage_p.");
1709         return NULL;
1710         }
1711     }
1712     if (_argo1) {
1713         if (_argo1 == Py_None) { _arg1 = NULL; }
1714         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxImage_p")) {
1715             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxImage_Paste. Expected _wxImage_p.");
1716         return NULL;
1717         }
1718     }
1719 {
1720     wxPy_BEGIN_ALLOW_THREADS;
1721         wxImage_Paste(_arg0,*_arg1,_arg2,_arg3);
1722
1723     wxPy_END_ALLOW_THREADS;
1724 }    Py_INCREF(Py_None);
1725     _resultobj = Py_None;
1726     return _resultobj;
1727 }
1728
1729 static PyObject * wxImage_GetData(wxImage *self) {
1730             unsigned char* data = self->GetData();
1731             int len = self->GetWidth() * self->GetHeight() * 3;
1732             return PyString_FromStringAndSize((char*)data, len);
1733         }
1734 static PyObject *_wrap_wxImage_GetData(PyObject *self, PyObject *args, PyObject *kwargs) {
1735     PyObject * _resultobj;
1736     PyObject * _result;
1737     wxImage * _arg0;
1738     PyObject * _argo0 = 0;
1739     char *_kwnames[] = { "self", NULL };
1740
1741     self = self;
1742     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_GetData",_kwnames,&_argo0))
1743         return NULL;
1744     if (_argo0) {
1745         if (_argo0 == Py_None) { _arg0 = NULL; }
1746         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1747             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetData. Expected _wxImage_p.");
1748         return NULL;
1749         }
1750     }
1751 {
1752     wxPy_BEGIN_ALLOW_THREADS;
1753         _result = (PyObject *)wxImage_GetData(_arg0);
1754
1755     wxPy_END_ALLOW_THREADS;
1756 }{
1757   _resultobj = _result;
1758 }
1759     return _resultobj;
1760 }
1761
1762 static void  wxImage_SetData(wxImage *self,PyObject * data) {
1763             unsigned char* dataPtr;
1764
1765             if (! PyString_Check(data)) {
1766                 PyErr_SetString(PyExc_TypeError, "Expected string object");
1767                 return /* NULL */ ;
1768             }
1769
1770             size_t len = self->GetWidth() * self->GetHeight() * 3;
1771             dataPtr = (unsigned char*) malloc(len);
1772             memcpy(dataPtr, PyString_AsString(data), len);
1773             self->SetData(dataPtr);
1774         }
1775 static PyObject *_wrap_wxImage_SetData(PyObject *self, PyObject *args, PyObject *kwargs) {
1776     PyObject * _resultobj;
1777     wxImage * _arg0;
1778     PyObject * _arg1;
1779     PyObject * _argo0 = 0;
1780     PyObject * _obj1 = 0;
1781     char *_kwnames[] = { "self","data", NULL };
1782
1783     self = self;
1784     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxImage_SetData",_kwnames,&_argo0,&_obj1))
1785         return NULL;
1786     if (_argo0) {
1787         if (_argo0 == Py_None) { _arg0 = NULL; }
1788         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1789             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_SetData. Expected _wxImage_p.");
1790         return NULL;
1791         }
1792     }
1793 {
1794   _arg1 = _obj1;
1795 }
1796 {
1797     wxPy_BEGIN_ALLOW_THREADS;
1798         wxImage_SetData(_arg0,_arg1);
1799
1800     wxPy_END_ALLOW_THREADS;
1801 }    Py_INCREF(Py_None);
1802     _resultobj = Py_None;
1803     return _resultobj;
1804 }
1805
1806 #define wxImage_SetMaskColour(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->SetMaskColour(_swigarg0,_swigarg1,_swigarg2))
1807 static PyObject *_wrap_wxImage_SetMaskColour(PyObject *self, PyObject *args, PyObject *kwargs) {
1808     PyObject * _resultobj;
1809     wxImage * _arg0;
1810     unsigned char  _arg1;
1811     unsigned char  _arg2;
1812     unsigned char  _arg3;
1813     PyObject * _argo0 = 0;
1814     char *_kwnames[] = { "self","r","g","b", NULL };
1815
1816     self = self;
1817     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Obbb:wxImage_SetMaskColour",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3))
1818         return NULL;
1819     if (_argo0) {
1820         if (_argo0 == Py_None) { _arg0 = NULL; }
1821         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1822             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_SetMaskColour. Expected _wxImage_p.");
1823         return NULL;
1824         }
1825     }
1826 {
1827     wxPy_BEGIN_ALLOW_THREADS;
1828         wxImage_SetMaskColour(_arg0,_arg1,_arg2,_arg3);
1829
1830     wxPy_END_ALLOW_THREADS;
1831 }    Py_INCREF(Py_None);
1832     _resultobj = Py_None;
1833     return _resultobj;
1834 }
1835
1836 #define wxImage_GetMaskRed(_swigobj)  (_swigobj->GetMaskRed())
1837 static PyObject *_wrap_wxImage_GetMaskRed(PyObject *self, PyObject *args, PyObject *kwargs) {
1838     PyObject * _resultobj;
1839     unsigned char  _result;
1840     wxImage * _arg0;
1841     PyObject * _argo0 = 0;
1842     char *_kwnames[] = { "self", NULL };
1843
1844     self = self;
1845     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_GetMaskRed",_kwnames,&_argo0))
1846         return NULL;
1847     if (_argo0) {
1848         if (_argo0 == Py_None) { _arg0 = NULL; }
1849         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1850             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetMaskRed. Expected _wxImage_p.");
1851         return NULL;
1852         }
1853     }
1854 {
1855     wxPy_BEGIN_ALLOW_THREADS;
1856         _result = (unsigned char )wxImage_GetMaskRed(_arg0);
1857
1858     wxPy_END_ALLOW_THREADS;
1859 }    _resultobj = Py_BuildValue("b",_result);
1860     return _resultobj;
1861 }
1862
1863 #define wxImage_GetMaskGreen(_swigobj)  (_swigobj->GetMaskGreen())
1864 static PyObject *_wrap_wxImage_GetMaskGreen(PyObject *self, PyObject *args, PyObject *kwargs) {
1865     PyObject * _resultobj;
1866     unsigned char  _result;
1867     wxImage * _arg0;
1868     PyObject * _argo0 = 0;
1869     char *_kwnames[] = { "self", NULL };
1870
1871     self = self;
1872     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_GetMaskGreen",_kwnames,&_argo0))
1873         return NULL;
1874     if (_argo0) {
1875         if (_argo0 == Py_None) { _arg0 = NULL; }
1876         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1877             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetMaskGreen. Expected _wxImage_p.");
1878         return NULL;
1879         }
1880     }
1881 {
1882     wxPy_BEGIN_ALLOW_THREADS;
1883         _result = (unsigned char )wxImage_GetMaskGreen(_arg0);
1884
1885     wxPy_END_ALLOW_THREADS;
1886 }    _resultobj = Py_BuildValue("b",_result);
1887     return _resultobj;
1888 }
1889
1890 #define wxImage_GetMaskBlue(_swigobj)  (_swigobj->GetMaskBlue())
1891 static PyObject *_wrap_wxImage_GetMaskBlue(PyObject *self, PyObject *args, PyObject *kwargs) {
1892     PyObject * _resultobj;
1893     unsigned char  _result;
1894     wxImage * _arg0;
1895     PyObject * _argo0 = 0;
1896     char *_kwnames[] = { "self", NULL };
1897
1898     self = self;
1899     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_GetMaskBlue",_kwnames,&_argo0))
1900         return NULL;
1901     if (_argo0) {
1902         if (_argo0 == Py_None) { _arg0 = NULL; }
1903         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1904             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_GetMaskBlue. Expected _wxImage_p.");
1905         return NULL;
1906         }
1907     }
1908 {
1909     wxPy_BEGIN_ALLOW_THREADS;
1910         _result = (unsigned char )wxImage_GetMaskBlue(_arg0);
1911
1912     wxPy_END_ALLOW_THREADS;
1913 }    _resultobj = Py_BuildValue("b",_result);
1914     return _resultobj;
1915 }
1916
1917 #define wxImage_SetMask(_swigobj,_swigarg0)  (_swigobj->SetMask(_swigarg0))
1918 static PyObject *_wrap_wxImage_SetMask(PyObject *self, PyObject *args, PyObject *kwargs) {
1919     PyObject * _resultobj;
1920     wxImage * _arg0;
1921     bool  _arg1 = (bool ) TRUE;
1922     PyObject * _argo0 = 0;
1923     int tempbool1 = (int) TRUE;
1924     char *_kwnames[] = { "self","mask", NULL };
1925
1926     self = self;
1927     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|i:wxImage_SetMask",_kwnames,&_argo0,&tempbool1))
1928         return NULL;
1929     if (_argo0) {
1930         if (_argo0 == Py_None) { _arg0 = NULL; }
1931         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1932             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_SetMask. Expected _wxImage_p.");
1933         return NULL;
1934         }
1935     }
1936     _arg1 = (bool ) tempbool1;
1937 {
1938     wxPy_BEGIN_ALLOW_THREADS;
1939         wxImage_SetMask(_arg0,_arg1);
1940
1941     wxPy_END_ALLOW_THREADS;
1942 }    Py_INCREF(Py_None);
1943     _resultobj = Py_None;
1944     return _resultobj;
1945 }
1946
1947 #define wxImage_HasMask(_swigobj)  (_swigobj->HasMask())
1948 static PyObject *_wrap_wxImage_HasMask(PyObject *self, PyObject *args, PyObject *kwargs) {
1949     PyObject * _resultobj;
1950     bool  _result;
1951     wxImage * _arg0;
1952     PyObject * _argo0 = 0;
1953     char *_kwnames[] = { "self", NULL };
1954
1955     self = self;
1956     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_HasMask",_kwnames,&_argo0))
1957         return NULL;
1958     if (_argo0) {
1959         if (_argo0 == Py_None) { _arg0 = NULL; }
1960         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1961             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_HasMask. Expected _wxImage_p.");
1962         return NULL;
1963         }
1964     }
1965 {
1966     wxPy_BEGIN_ALLOW_THREADS;
1967         _result = (bool )wxImage_HasMask(_arg0);
1968
1969     wxPy_END_ALLOW_THREADS;
1970 }    _resultobj = Py_BuildValue("i",_result);
1971     return _resultobj;
1972 }
1973
1974 #define wxImage_Rotate(_swigobj,_swigarg0,_swigarg1,_swigarg2,_swigarg3)  (_swigobj->Rotate(_swigarg0,_swigarg1,_swigarg2,_swigarg3))
1975 static PyObject *_wrap_wxImage_Rotate(PyObject *self, PyObject *args, PyObject *kwargs) {
1976     PyObject * _resultobj;
1977     wxImage * _result;
1978     wxImage * _arg0;
1979     double  _arg1;
1980     wxPoint * _arg2;
1981     bool  _arg3 = (bool ) TRUE;
1982     wxPoint * _arg4 = (wxPoint *) NULL;
1983     PyObject * _argo0 = 0;
1984     wxPoint  temp;
1985     PyObject * _obj2 = 0;
1986     int tempbool3 = (int) TRUE;
1987     wxPoint  temp0;
1988     PyObject * _obj4 = 0;
1989     char *_kwnames[] = { "self","angle","centre_of_rotation","interpolating","offset_after_rotation", NULL };
1990     char _ptemp[128];
1991
1992     self = self;
1993     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OdO|iO:wxImage_Rotate",_kwnames,&_argo0,&_arg1,&_obj2,&tempbool3,&_obj4))
1994         return NULL;
1995     if (_argo0) {
1996         if (_argo0 == Py_None) { _arg0 = NULL; }
1997         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
1998             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_Rotate. Expected _wxImage_p.");
1999         return NULL;
2000         }
2001     }
2002 {
2003     _arg2 = &temp;
2004     if (! wxPoint_helper(_obj2, &_arg2))
2005         return NULL;
2006 }
2007     _arg3 = (bool ) tempbool3;
2008     if (_obj4)
2009 {
2010     _arg4 = &temp0;
2011     if (! wxPoint_helper(_obj4, &_arg4))
2012         return NULL;
2013 }
2014 {
2015     wxPy_BEGIN_ALLOW_THREADS;
2016         _result = new wxImage (wxImage_Rotate(_arg0,_arg1,*_arg2,_arg3,_arg4));
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_Rotate90(_swigobj,_swigarg0)  (_swigobj->Rotate90(_swigarg0))
2025 static PyObject *_wrap_wxImage_Rotate90(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","clockwise", NULL };
2033     char _ptemp[128];
2034
2035     self = self;
2036     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|i:wxImage_Rotate90",_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_Rotate90. Expected _wxImage_p.");
2042         return NULL;
2043         }
2044     }
2045     _arg1 = (bool ) tempbool1;
2046 {
2047     wxPy_BEGIN_ALLOW_THREADS;
2048         _result = new wxImage (wxImage_Rotate90(_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_Mirror(_swigobj,_swigarg0)  (_swigobj->Mirror(_swigarg0))
2057 static PyObject *_wrap_wxImage_Mirror(PyObject *self, PyObject *args, PyObject *kwargs) {
2058     PyObject * _resultobj;
2059     wxImage * _result;
2060     wxImage * _arg0;
2061     bool  _arg1 = (bool ) TRUE;
2062     PyObject * _argo0 = 0;
2063     int tempbool1 = (int) TRUE;
2064     char *_kwnames[] = { "self","horizontally", NULL };
2065     char _ptemp[128];
2066
2067     self = self;
2068     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|i:wxImage_Mirror",_kwnames,&_argo0,&tempbool1))
2069         return NULL;
2070     if (_argo0) {
2071         if (_argo0 == Py_None) { _arg0 = NULL; }
2072         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
2073             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_Mirror. Expected _wxImage_p.");
2074         return NULL;
2075         }
2076     }
2077     _arg1 = (bool ) tempbool1;
2078 {
2079     wxPy_BEGIN_ALLOW_THREADS;
2080         _result = new wxImage (wxImage_Mirror(_arg0,_arg1));
2081
2082     wxPy_END_ALLOW_THREADS;
2083 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxImage_p");
2084     _resultobj = Py_BuildValue("s",_ptemp);
2085     return _resultobj;
2086 }
2087
2088 #define wxImage_Replace(_swigobj,_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5)  (_swigobj->Replace(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5))
2089 static PyObject *_wrap_wxImage_Replace(PyObject *self, PyObject *args, PyObject *kwargs) {
2090     PyObject * _resultobj;
2091     wxImage * _arg0;
2092     unsigned char  _arg1;
2093     unsigned char  _arg2;
2094     unsigned char  _arg3;
2095     unsigned char  _arg4;
2096     unsigned char  _arg5;
2097     unsigned char  _arg6;
2098     PyObject * _argo0 = 0;
2099     char *_kwnames[] = { "self","r1","g1","b1","r2","g2","b2", NULL };
2100
2101     self = self;
2102     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Obbbbbb:wxImage_Replace",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3,&_arg4,&_arg5,&_arg6))
2103         return NULL;
2104     if (_argo0) {
2105         if (_argo0 == Py_None) { _arg0 = NULL; }
2106         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
2107             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_Replace. Expected _wxImage_p.");
2108         return NULL;
2109         }
2110     }
2111 {
2112     wxPy_BEGIN_ALLOW_THREADS;
2113         wxImage_Replace(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5,_arg6);
2114
2115     wxPy_END_ALLOW_THREADS;
2116 }    Py_INCREF(Py_None);
2117     _resultobj = Py_None;
2118     return _resultobj;
2119 }
2120
2121 #define wxImage_CountColours(_swigobj,_swigarg0)  (_swigobj->CountColours(_swigarg0))
2122 static PyObject *_wrap_wxImage_CountColours(PyObject *self, PyObject *args, PyObject *kwargs) {
2123     PyObject * _resultobj;
2124     unsigned long  _result;
2125     wxImage * _arg0;
2126     unsigned long  _arg1 = (unsigned long ) (unsigned long)-1;
2127     PyObject * _argo0 = 0;
2128     char *_kwnames[] = { "self","stopafter", NULL };
2129
2130     self = self;
2131     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|l:wxImage_CountColours",_kwnames,&_argo0,&_arg1))
2132         return NULL;
2133     if (_argo0) {
2134         if (_argo0 == Py_None) { _arg0 = NULL; }
2135         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImage_p")) {
2136             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_CountColours. Expected _wxImage_p.");
2137         return NULL;
2138         }
2139     }
2140 {
2141     wxPy_BEGIN_ALLOW_THREADS;
2142         _result = (unsigned long )wxImage_CountColours(_arg0,_arg1);
2143
2144     wxPy_END_ALLOW_THREADS;
2145 }    _resultobj = Py_BuildValue("l",_result);
2146     return _resultobj;
2147 }
2148
2149 static PyObject *_wrap_wxImage_AddHandler(PyObject *self, PyObject *args, PyObject *kwargs) {
2150     PyObject * _resultobj;
2151     wxImageHandler * _arg0;
2152     PyObject * _argo0 = 0;
2153     char *_kwnames[] = { "handler", NULL };
2154
2155     self = self;
2156     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_AddHandler",_kwnames,&_argo0))
2157         return NULL;
2158     if (_argo0) {
2159         if (_argo0 == Py_None) { _arg0 = NULL; }
2160         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImageHandler_p")) {
2161             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_AddHandler. Expected _wxImageHandler_p.");
2162         return NULL;
2163         }
2164     }
2165 {
2166     wxPy_BEGIN_ALLOW_THREADS;
2167         wxImage::AddHandler(_arg0);
2168
2169     wxPy_END_ALLOW_THREADS;
2170 }    Py_INCREF(Py_None);
2171     _resultobj = Py_None;
2172     return _resultobj;
2173 }
2174
2175 static PyObject *_wrap_wxImage_InsertHandler(PyObject *self, PyObject *args, PyObject *kwargs) {
2176     PyObject * _resultobj;
2177     wxImageHandler * _arg0;
2178     PyObject * _argo0 = 0;
2179     char *_kwnames[] = { "handler", NULL };
2180
2181     self = self;
2182     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_InsertHandler",_kwnames,&_argo0))
2183         return NULL;
2184     if (_argo0) {
2185         if (_argo0 == Py_None) { _arg0 = NULL; }
2186         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxImageHandler_p")) {
2187             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxImage_InsertHandler. Expected _wxImageHandler_p.");
2188         return NULL;
2189         }
2190     }
2191 {
2192     wxPy_BEGIN_ALLOW_THREADS;
2193         wxImage::InsertHandler(_arg0);
2194
2195     wxPy_END_ALLOW_THREADS;
2196 }    Py_INCREF(Py_None);
2197     _resultobj = Py_None;
2198     return _resultobj;
2199 }
2200
2201 static PyObject *_wrap_wxImage_RemoveHandler(PyObject *self, PyObject *args, PyObject *kwargs) {
2202     PyObject * _resultobj;
2203     bool  _result;
2204     wxString * _arg0;
2205     PyObject * _obj0 = 0;
2206     char *_kwnames[] = { "name", NULL };
2207
2208     self = self;
2209     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxImage_RemoveHandler",_kwnames,&_obj0))
2210         return NULL;
2211 {
2212 #if PYTHON_API_VERSION >= 1009
2213     char* tmpPtr; int tmpSize;
2214     if (!PyString_Check(_obj0) && !PyUnicode_Check(_obj0)) {
2215         PyErr_SetString(PyExc_TypeError, "String or Unicode type required");
2216         return NULL;
2217     }
2218     if (PyString_AsStringAndSize(_obj0, &tmpPtr, &tmpSize) == -1)
2219         return NULL;
2220     _arg0 = new wxString(tmpPtr, tmpSize);
2221 #else
2222     if (!PyString_Check(_obj0)) {
2223         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
2224         return NULL;
2225     }
2226     _arg0 = new wxString(PyString_AS_STRING(_obj0), PyString_GET_SIZE(_obj0));
2227 #endif
2228 }
2229 {
2230     wxPy_BEGIN_ALLOW_THREADS;
2231         _result = (bool )wxImage::RemoveHandler(*_arg0);
2232
2233     wxPy_END_ALLOW_THREADS;
2234 }    _resultobj = Py_BuildValue("i",_result);
2235 {
2236     if (_obj0)
2237         delete _arg0;
2238 }
2239     return _resultobj;
2240 }
2241
2242 static PyMethodDef imagecMethods[] = {
2243          { "wxImage_RemoveHandler", (PyCFunction) _wrap_wxImage_RemoveHandler, METH_VARARGS | METH_KEYWORDS },
2244          { "wxImage_InsertHandler", (PyCFunction) _wrap_wxImage_InsertHandler, METH_VARARGS | METH_KEYWORDS },
2245          { "wxImage_AddHandler", (PyCFunction) _wrap_wxImage_AddHandler, METH_VARARGS | METH_KEYWORDS },
2246          { "wxImage_CountColours", (PyCFunction) _wrap_wxImage_CountColours, METH_VARARGS | METH_KEYWORDS },
2247          { "wxImage_Replace", (PyCFunction) _wrap_wxImage_Replace, METH_VARARGS | METH_KEYWORDS },
2248          { "wxImage_Mirror", (PyCFunction) _wrap_wxImage_Mirror, METH_VARARGS | METH_KEYWORDS },
2249          { "wxImage_Rotate90", (PyCFunction) _wrap_wxImage_Rotate90, METH_VARARGS | METH_KEYWORDS },
2250          { "wxImage_Rotate", (PyCFunction) _wrap_wxImage_Rotate, METH_VARARGS | METH_KEYWORDS },
2251          { "wxImage_HasMask", (PyCFunction) _wrap_wxImage_HasMask, METH_VARARGS | METH_KEYWORDS },
2252          { "wxImage_SetMask", (PyCFunction) _wrap_wxImage_SetMask, METH_VARARGS | METH_KEYWORDS },
2253          { "wxImage_GetMaskBlue", (PyCFunction) _wrap_wxImage_GetMaskBlue, METH_VARARGS | METH_KEYWORDS },
2254          { "wxImage_GetMaskGreen", (PyCFunction) _wrap_wxImage_GetMaskGreen, METH_VARARGS | METH_KEYWORDS },
2255          { "wxImage_GetMaskRed", (PyCFunction) _wrap_wxImage_GetMaskRed, METH_VARARGS | METH_KEYWORDS },
2256          { "wxImage_SetMaskColour", (PyCFunction) _wrap_wxImage_SetMaskColour, METH_VARARGS | METH_KEYWORDS },
2257          { "wxImage_SetData", (PyCFunction) _wrap_wxImage_SetData, METH_VARARGS | METH_KEYWORDS },
2258          { "wxImage_GetData", (PyCFunction) _wrap_wxImage_GetData, METH_VARARGS | METH_KEYWORDS },
2259          { "wxImage_Paste", (PyCFunction) _wrap_wxImage_Paste, METH_VARARGS | METH_KEYWORDS },
2260          { "wxImage_Copy", (PyCFunction) _wrap_wxImage_Copy, METH_VARARGS | METH_KEYWORDS },
2261          { "wxImage_GetSubImage", (PyCFunction) _wrap_wxImage_GetSubImage, METH_VARARGS | METH_KEYWORDS },
2262          { "wxImage_GetHeight", (PyCFunction) _wrap_wxImage_GetHeight, METH_VARARGS | METH_KEYWORDS },
2263          { "wxImage_GetWidth", (PyCFunction) _wrap_wxImage_GetWidth, METH_VARARGS | METH_KEYWORDS },
2264          { "wxImage_Ok", (PyCFunction) _wrap_wxImage_Ok, METH_VARARGS | METH_KEYWORDS },
2265          { "wxImage_SaveMimeFile", (PyCFunction) _wrap_wxImage_SaveMimeFile, METH_VARARGS | METH_KEYWORDS },
2266          { "wxImage_SaveFile", (PyCFunction) _wrap_wxImage_SaveFile, METH_VARARGS | METH_KEYWORDS },
2267          { "wxImage_LoadMimeFile", (PyCFunction) _wrap_wxImage_LoadMimeFile, METH_VARARGS | METH_KEYWORDS },
2268          { "wxImage_LoadFile", (PyCFunction) _wrap_wxImage_LoadFile, METH_VARARGS | METH_KEYWORDS },
2269          { "wxImage_CanRead", (PyCFunction) _wrap_wxImage_CanRead, METH_VARARGS | METH_KEYWORDS },
2270          { "wxImage_GetBlue", (PyCFunction) _wrap_wxImage_GetBlue, METH_VARARGS | METH_KEYWORDS },
2271          { "wxImage_GetGreen", (PyCFunction) _wrap_wxImage_GetGreen, METH_VARARGS | METH_KEYWORDS },
2272          { "wxImage_GetRed", (PyCFunction) _wrap_wxImage_GetRed, METH_VARARGS | METH_KEYWORDS },
2273          { "wxImage_SetRGB", (PyCFunction) _wrap_wxImage_SetRGB, METH_VARARGS | METH_KEYWORDS },
2274          { "wxImage_Rescale", (PyCFunction) _wrap_wxImage_Rescale, METH_VARARGS | METH_KEYWORDS },
2275          { "wxImage_Scale", (PyCFunction) _wrap_wxImage_Scale, METH_VARARGS | METH_KEYWORDS },
2276          { "wxImage_Destroy", (PyCFunction) _wrap_wxImage_Destroy, METH_VARARGS | METH_KEYWORDS },
2277          { "wxImage_Create", (PyCFunction) _wrap_wxImage_Create, METH_VARARGS | METH_KEYWORDS },
2278          { "wxImage_ConvertToMonoBitmap", (PyCFunction) _wrap_wxImage_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS },
2279          { "wxImage_ConvertToBitmap", (PyCFunction) _wrap_wxImage_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS },
2280          { "delete_wxImage", (PyCFunction) _wrap_delete_wxImage, METH_VARARGS | METH_KEYWORDS },
2281          { "new_wxImage", (PyCFunction) _wrap_new_wxImage, METH_VARARGS | METH_KEYWORDS },
2282          { "new_wxTIFFHandler", (PyCFunction) _wrap_new_wxTIFFHandler, METH_VARARGS | METH_KEYWORDS },
2283          { "new_wxPCXHandler", (PyCFunction) _wrap_new_wxPCXHandler, METH_VARARGS | METH_KEYWORDS },
2284          { "new_wxPNMHandler", (PyCFunction) _wrap_new_wxPNMHandler, METH_VARARGS | METH_KEYWORDS },
2285          { "new_wxGIFHandler", (PyCFunction) _wrap_new_wxGIFHandler, METH_VARARGS | METH_KEYWORDS },
2286          { "new_wxBMPHandler", (PyCFunction) _wrap_new_wxBMPHandler, METH_VARARGS | METH_KEYWORDS },
2287          { "new_wxJPEGHandler", (PyCFunction) _wrap_new_wxJPEGHandler, METH_VARARGS | METH_KEYWORDS },
2288          { "new_wxPNGHandler", (PyCFunction) _wrap_new_wxPNGHandler, METH_VARARGS | METH_KEYWORDS },
2289          { "wxImageHandler_SetMimeType", (PyCFunction) _wrap_wxImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS },
2290          { "wxImageHandler_SetType", (PyCFunction) _wrap_wxImageHandler_SetType, METH_VARARGS | METH_KEYWORDS },
2291          { "wxImageHandler_SetExtension", (PyCFunction) _wrap_wxImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS },
2292          { "wxImageHandler_SetName", (PyCFunction) _wrap_wxImageHandler_SetName, METH_VARARGS | METH_KEYWORDS },
2293          { "wxImageHandler_GetMimeType", (PyCFunction) _wrap_wxImageHandler_GetMimeType, METH_VARARGS | METH_KEYWORDS },
2294          { "wxImageHandler_GetType", (PyCFunction) _wrap_wxImageHandler_GetType, METH_VARARGS | METH_KEYWORDS },
2295          { "wxImageHandler_GetExtension", (PyCFunction) _wrap_wxImageHandler_GetExtension, METH_VARARGS | METH_KEYWORDS },
2296          { "wxImageHandler_GetName", (PyCFunction) _wrap_wxImageHandler_GetName, METH_VARARGS | METH_KEYWORDS },
2297          { "wxBitmapFromImage", (PyCFunction) _wrap_wxBitmapFromImage, METH_VARARGS | METH_KEYWORDS },
2298          { "wxInitAllImageHandlers", (PyCFunction) _wrap_wxInitAllImageHandlers, METH_VARARGS | METH_KEYWORDS },
2299          { "wxImageFromBitmap", (PyCFunction) _wrap_wxImageFromBitmap, METH_VARARGS | METH_KEYWORDS },
2300          { "wxImageFromMime", (PyCFunction) _wrap_wxImageFromMime, METH_VARARGS | METH_KEYWORDS },
2301          { "wxEmptyImage", (PyCFunction) _wrap_wxEmptyImage, METH_VARARGS | METH_KEYWORDS },
2302          { NULL, NULL }
2303 };
2304 #ifdef __cplusplus
2305 }
2306 #endif
2307 /*
2308  * This table is used by the pointer type-checker
2309  */
2310 static struct { char *n1; char *n2; void *(*pcnv)(void *); } _swig_mapping[] = {
2311     { "_wxAcceleratorTable","_class_wxAcceleratorTable",0},
2312     { "_signed_long","_long",0},
2313     { "_class_wxJPEGHandler","_wxJPEGHandler",0},
2314     { "_wxBMPHandler","_class_wxBMPHandler",0},
2315     { "_wxImage","_class_wxImage",0},
2316     { "_wxPrintQuality","_wxCoord",0},
2317     { "_wxPrintQuality","_int",0},
2318     { "_wxPrintQuality","_signed_int",0},
2319     { "_wxPrintQuality","_unsigned_int",0},
2320     { "_wxPrintQuality","_wxWindowID",0},
2321     { "_wxPrintQuality","_uint",0},
2322     { "_wxPrintQuality","_EBool",0},
2323     { "_wxPrintQuality","_size_t",0},
2324     { "_wxPrintQuality","_time_t",0},
2325     { "_class_wxRegionIterator","_wxRegionIterator",0},
2326     { "_wxGIFHandler","_class_wxGIFHandler",0},
2327     { "_wxIndividualLayoutConstraint","_class_wxIndividualLayoutConstraint",0},
2328     { "_wxCursor","_class_wxCursor",0},
2329     { "_wxImageHandler","_class_wxTIFFHandler",SwigwxTIFFHandlerTowxImageHandler},
2330     { "_wxImageHandler","_wxTIFFHandler",SwigwxTIFFHandlerTowxImageHandler},
2331     { "_wxImageHandler","_class_wxPCXHandler",SwigwxPCXHandlerTowxImageHandler},
2332     { "_wxImageHandler","_wxPCXHandler",SwigwxPCXHandlerTowxImageHandler},
2333     { "_wxImageHandler","_class_wxPNMHandler",SwigwxPNMHandlerTowxImageHandler},
2334     { "_wxImageHandler","_wxPNMHandler",SwigwxPNMHandlerTowxImageHandler},
2335     { "_wxImageHandler","_class_wxGIFHandler",SwigwxGIFHandlerTowxImageHandler},
2336     { "_wxImageHandler","_wxGIFHandler",SwigwxGIFHandlerTowxImageHandler},
2337     { "_wxImageHandler","_class_wxBMPHandler",SwigwxBMPHandlerTowxImageHandler},
2338     { "_wxImageHandler","_wxBMPHandler",SwigwxBMPHandlerTowxImageHandler},
2339     { "_wxImageHandler","_class_wxJPEGHandler",SwigwxJPEGHandlerTowxImageHandler},
2340     { "_wxImageHandler","_wxJPEGHandler",SwigwxJPEGHandlerTowxImageHandler},
2341     { "_wxImageHandler","_class_wxPNGHandler",SwigwxPNGHandlerTowxImageHandler},
2342     { "_wxImageHandler","_wxPNGHandler",SwigwxPNGHandlerTowxImageHandler},
2343     { "_wxImageHandler","_class_wxImageHandler",0},
2344     { "_wxMask","_class_wxMask",0},
2345     { "_wxPNGHandler","_class_wxPNGHandler",0},
2346     { "_wxPen","_class_wxPen",0},
2347     { "_byte","_unsigned_char",0},
2348     { "_wxColourDatabase","_class_wxColourDatabase",0},
2349     { "_long","_unsigned_long",0},
2350     { "_long","_signed_long",0},
2351     { "_wxImageList","_class_wxImageList",0},
2352     { "_class_wxTIFFHandler","_wxTIFFHandler",0},
2353     { "_class_wxAcceleratorTable","_wxAcceleratorTable",0},
2354     { "_wxDC","_class_wxDC",0},
2355     { "_class_wxBMPHandler","_wxBMPHandler",0},
2356     { "_size_t","_wxCoord",0},
2357     { "_size_t","_wxPrintQuality",0},
2358     { "_size_t","_time_t",0},
2359     { "_size_t","_unsigned_int",0},
2360     { "_size_t","_int",0},
2361     { "_size_t","_wxWindowID",0},
2362     { "_size_t","_uint",0},
2363     { "_class_wxRealPoint","_wxRealPoint",0},
2364     { "_wxPNMHandler","_class_wxPNMHandler",0},
2365     { "_class_wxGIFHandler","_wxGIFHandler",0},
2366     { "_class_wxPostScriptDC","_wxPostScriptDC",0},
2367     { "_class_wxMask","_wxMask",0},
2368     { "_class_wxPNGHandler","_wxPNGHandler",0},
2369     { "_wxColour","_class_wxColour",0},
2370     { "_wxBrush","_class_wxBrush",0},
2371     { "_uint","_wxCoord",0},
2372     { "_uint","_wxPrintQuality",0},
2373     { "_uint","_time_t",0},
2374     { "_uint","_size_t",0},
2375     { "_uint","_unsigned_int",0},
2376     { "_uint","_int",0},
2377     { "_uint","_wxWindowID",0},
2378     { "_wxChar","_char",0},
2379     { "_wxRect","_class_wxRect",0},
2380     { "_class_wxImage","_wxImage",0},
2381     { "_wxPoint","_class_wxPoint",0},
2382     { "_class_wxPNMHandler","_wxPNMHandler",0},
2383     { "_char","_wxChar",0},
2384     { "_wxBitmap","_class_wxBitmap",0},
2385     { "_wxPenList","_class_wxPenList",0},
2386     { "_wxWindowDC","_class_wxWindowDC",0},
2387     { "_class_wxIndividualLayoutConstraint","_wxIndividualLayoutConstraint",0},
2388     { "_class_wxColourDatabase","_wxColourDatabase",0},
2389     { "_EBool","_wxCoord",0},
2390     { "_EBool","_wxPrintQuality",0},
2391     { "_EBool","_signed_int",0},
2392     { "_EBool","_int",0},
2393     { "_EBool","_wxWindowID",0},
2394     { "_class_wxRegion","_wxRegion",0},
2395     { "_wxFont","_class_wxFont",0},
2396     { "_unsigned_long","_long",0},
2397     { "_class_wxRect","_wxRect",0},
2398     { "_class_wxDC","_wxDC",0},
2399     { "_class_wxBrushList","_wxBrushList",0},
2400     { "_class_wxPenList","_wxPenList",0},
2401     { "_wxAcceleratorEntry","_class_wxAcceleratorEntry",0},
2402     { "_signed_int","_wxCoord",0},
2403     { "_signed_int","_wxPrintQuality",0},
2404     { "_signed_int","_EBool",0},
2405     { "_signed_int","_wxWindowID",0},
2406     { "_signed_int","_int",0},
2407     { "_wxLayoutConstraints","_class_wxLayoutConstraints",0},
2408     { "_wxScreenDC","_class_wxScreenDC",0},
2409     { "_WXTYPE","_short",0},
2410     { "_WXTYPE","_signed_short",0},
2411     { "_WXTYPE","_unsigned_short",0},
2412     { "_class_wxBrush","_wxBrush",0},
2413     { "_unsigned_short","_WXTYPE",0},
2414     { "_unsigned_short","_short",0},
2415     { "_class_wxFont","_wxFont",0},
2416     { "_wxBusyInfo","_class_wxBusyInfo",0},
2417     { "_wxFontList","_class_wxFontList",0},
2418     { "_wxClientDC","_class_wxClientDC",0},
2419     { "_class_wxPoint","_wxPoint",0},
2420     { "_wxRealPoint","_class_wxRealPoint",0},
2421     { "_signed_short","_WXTYPE",0},
2422     { "_signed_short","_short",0},
2423     { "_wxMemoryDC","_class_wxMemoryDC",0},
2424     { "_wxPaintDC","_class_wxPaintDC",0},
2425     { "_class_wxWindowDC","_wxWindowDC",0},
2426     { "_class_wxAcceleratorEntry","_wxAcceleratorEntry",0},
2427     { "_class_wxCursor","_wxCursor",0},
2428     { "_wxPostScriptDC","_class_wxPostScriptDC",0},
2429     { "_class_wxImageHandler","_class_wxTIFFHandler",SwigwxTIFFHandlerTowxImageHandler},
2430     { "_class_wxImageHandler","_wxTIFFHandler",SwigwxTIFFHandlerTowxImageHandler},
2431     { "_class_wxImageHandler","_class_wxPCXHandler",SwigwxPCXHandlerTowxImageHandler},
2432     { "_class_wxImageHandler","_wxPCXHandler",SwigwxPCXHandlerTowxImageHandler},
2433     { "_class_wxImageHandler","_class_wxPNMHandler",SwigwxPNMHandlerTowxImageHandler},
2434     { "_class_wxImageHandler","_wxPNMHandler",SwigwxPNMHandlerTowxImageHandler},
2435     { "_class_wxImageHandler","_class_wxGIFHandler",SwigwxGIFHandlerTowxImageHandler},
2436     { "_class_wxImageHandler","_wxGIFHandler",SwigwxGIFHandlerTowxImageHandler},
2437     { "_class_wxImageHandler","_class_wxBMPHandler",SwigwxBMPHandlerTowxImageHandler},
2438     { "_class_wxImageHandler","_wxBMPHandler",SwigwxBMPHandlerTowxImageHandler},
2439     { "_class_wxImageHandler","_class_wxJPEGHandler",SwigwxJPEGHandlerTowxImageHandler},
2440     { "_class_wxImageHandler","_wxJPEGHandler",SwigwxJPEGHandlerTowxImageHandler},
2441     { "_class_wxImageHandler","_class_wxPNGHandler",SwigwxPNGHandlerTowxImageHandler},
2442     { "_class_wxImageHandler","_wxPNGHandler",SwigwxPNGHandlerTowxImageHandler},
2443     { "_class_wxImageHandler","_wxImageHandler",0},
2444     { "_unsigned_char","_byte",0},
2445     { "_unsigned_int","_wxCoord",0},
2446     { "_unsigned_int","_wxPrintQuality",0},
2447     { "_unsigned_int","_time_t",0},
2448     { "_unsigned_int","_size_t",0},
2449     { "_unsigned_int","_uint",0},
2450     { "_unsigned_int","_wxWindowID",0},
2451     { "_unsigned_int","_int",0},
2452     { "_wxIcon","_class_wxIcon",0},
2453     { "_class_wxPen","_wxPen",0},
2454     { "_short","_WXTYPE",0},
2455     { "_short","_unsigned_short",0},
2456     { "_short","_signed_short",0},
2457     { "_class_wxImageList","_wxImageList",0},
2458     { "_wxPCXHandler","_class_wxPCXHandler",0},
2459     { "_wxJPEGHandler","_class_wxJPEGHandler",0},
2460     { "_wxWindowID","_wxCoord",0},
2461     { "_wxWindowID","_wxPrintQuality",0},
2462     { "_wxWindowID","_time_t",0},
2463     { "_wxWindowID","_size_t",0},
2464     { "_wxWindowID","_EBool",0},
2465     { "_wxWindowID","_uint",0},
2466     { "_wxWindowID","_int",0},
2467     { "_wxWindowID","_signed_int",0},
2468     { "_wxWindowID","_unsigned_int",0},
2469     { "_int","_wxCoord",0},
2470     { "_int","_wxPrintQuality",0},
2471     { "_int","_time_t",0},
2472     { "_int","_size_t",0},
2473     { "_int","_EBool",0},
2474     { "_int","_uint",0},
2475     { "_int","_wxWindowID",0},
2476     { "_int","_unsigned_int",0},
2477     { "_int","_signed_int",0},
2478     { "_time_t","_wxCoord",0},
2479     { "_time_t","_wxPrintQuality",0},
2480     { "_time_t","_unsigned_int",0},
2481     { "_time_t","_int",0},
2482     { "_time_t","_wxWindowID",0},
2483     { "_time_t","_uint",0},
2484     { "_time_t","_size_t",0},
2485     { "_wxSize","_class_wxSize",0},
2486     { "_wxRegionIterator","_class_wxRegionIterator",0},
2487     { "_class_wxPaintDC","_wxPaintDC",0},
2488     { "_class_wxLayoutConstraints","_wxLayoutConstraints",0},
2489     { "_class_wxIcon","_wxIcon",0},
2490     { "_class_wxColour","_wxColour",0},
2491     { "_class_wxScreenDC","_wxScreenDC",0},
2492     { "_wxPalette","_class_wxPalette",0},
2493     { "_wxCoord","_int",0},
2494     { "_wxCoord","_signed_int",0},
2495     { "_wxCoord","_unsigned_int",0},
2496     { "_wxCoord","_wxWindowID",0},
2497     { "_wxCoord","_uint",0},
2498     { "_wxCoord","_EBool",0},
2499     { "_wxCoord","_size_t",0},
2500     { "_wxCoord","_time_t",0},
2501     { "_wxCoord","_wxPrintQuality",0},
2502     { "_wxRegion","_class_wxRegion",0},
2503     { "_class_wxPCXHandler","_wxPCXHandler",0},
2504     { "_wxTIFFHandler","_class_wxTIFFHandler",0},
2505     { "_class_wxBusyInfo","_wxBusyInfo",0},
2506     { "_class_wxFontList","_wxFontList",0},
2507     { "_class_wxClientDC","_wxClientDC",0},
2508     { "_wxBrushList","_class_wxBrushList",0},
2509     { "_class_wxSize","_wxSize",0},
2510     { "_class_wxBitmap","_wxBitmap",0},
2511     { "_class_wxMemoryDC","_wxMemoryDC",0},
2512     { "_class_wxPalette","_wxPalette",0},
2513 {0,0,0}};
2514
2515 static PyObject *SWIG_globals;
2516 #ifdef __cplusplus
2517 extern "C"
2518 #endif
2519 SWIGEXPORT(void) initimagec() {
2520          PyObject *m, *d;
2521          SWIG_globals = SWIG_newvarlink();
2522          m = Py_InitModule("imagec", imagecMethods);
2523          d = PyModule_GetDict(m);
2524          PyDict_SetItemString(d,"cvar", SWIG_globals);
2525          SWIG_addvarlink(SWIG_globals,"wxNullImage",_wrap_wxNullImage_get, _wrap_wxNullImage_set);
2526 {
2527    int i;
2528    for (i = 0; _swig_mapping[i].n1; i++)
2529         SWIG_RegisterMapping(_swig_mapping[i].n1,_swig_mapping[i].n2,_swig_mapping[i].pcnv);
2530 }
2531 }