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