wxPython/src/gtk/filesys.cpp

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