wxPython/src/msw/filesys.cpp

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