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 #define new_wxFSFile(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4) (new wxFSFile(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4))
 332 static PyObject *_wrap_new_wxFSFile(PyObject *self, PyObject *args, PyObject *kwargs) {
 333     PyObject * _resultobj;
 334     wxFSFile * _result;
 335     wxInputStream * _arg0;
 336     wxString * _arg1;
 337     wxString * _arg2;
 338     wxString * _arg3;
 339     wxDateTime * _arg4;
 340     PyObject * _obj0 = 0;
 341     PyObject * _obj1 = 0;
 342     PyObject * _obj2 = 0;
 343     PyObject * _obj3 = 0;
 344     PyObject * _argo4 = 0;
 345     char *_kwnames[] = { "stream","loc","mimetype","anchor","modif", NULL };
 346     char _ptemp[128];
 347
 348     self = self;
 349     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOOOO:new_wxFSFile",_kwnames,&_obj0,&_obj1,&_obj2,&_obj3,&_argo4))
 350         return NULL;
 351 {
 352     if (PyInstance_Check(_obj0)) {
 353         wxPyInputStream* ptr;
 354         if (SWIG_GetPtrObj(_obj0, (void **) &ptr,"_wxPyInputStream_p")) {
 355             PyErr_SetString(PyExc_TypeError,"Expected _wxInputStream_p.");
 356             return NULL;
 357         }
 358         _arg0 = ptr->wxi;
 359     } else {
 360         PyErr_SetString(PyExc_TypeError,"Expected _wxInputStream_p.");
 361         return NULL;
 362     }
 363 }
 364 {
 365 #if PYTHON_API_VERSION >= 1009
 366     char* tmpPtr; int tmpSize;
 367     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
 368         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
 369         return NULL;
 370     }
 371     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
 372         return NULL;
 373     _arg1 = new wxString(tmpPtr, tmpSize);
 374 #else
 375     if (!PyString_Check(_obj1)) {
 376         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
 377         return NULL;
 378     }
 379     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
 380 #endif
 381 }
 382 {
 383 #if PYTHON_API_VERSION >= 1009
 384     char* tmpPtr; int tmpSize;
 385     if (!PyString_Check(_obj2) && !PyUnicode_Check(_obj2)) {
 386         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
 387         return NULL;
 388     }
 389     if (PyString_AsStringAndSize(_obj2, &tmpPtr, &tmpSize) == -1)
 390         return NULL;
 391     _arg2 = new wxString(tmpPtr, tmpSize);
 392 #else
 393     if (!PyString_Check(_obj2)) {
 394         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
 395         return NULL;
 396     }
 397     _arg2 = new wxString(PyString_AS_STRING(_obj2), PyString_GET_SIZE(_obj2));
 398 #endif
 399 }
 400 {
 401 #if PYTHON_API_VERSION >= 1009
 402     char* tmpPtr; int tmpSize;
 403     if (!PyString_Check(_obj3) && !PyUnicode_Check(_obj3)) {
 404         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
 405         return NULL;
 406     }
 407     if (PyString_AsStringAndSize(_obj3, &tmpPtr, &tmpSize) == -1)
 408         return NULL;
 409     _arg3 = new wxString(tmpPtr, tmpSize);
 410 #else
 411     if (!PyString_Check(_obj3)) {
 412         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
 413         return NULL;
 414     }
 415     _arg3 = new wxString(PyString_AS_STRING(_obj3), PyString_GET_SIZE(_obj3));
 416 #endif
 417 }
 418     if (_argo4) {
 419         if (_argo4 == Py_None) { _arg4 = NULL; }
 420         else if (SWIG_GetPtrObj(_argo4,(void **) &_arg4,"_wxDateTime_p")) {
 421             PyErr_SetString(PyExc_TypeError,"Type error in argument 5 of new_wxFSFile. Expected _wxDateTime_p.");
 422         return NULL;
 423         }
 424     }
 425 {
 426     wxPy_BEGIN_ALLOW_THREADS;
 427         _result = (wxFSFile *)new_wxFSFile(_arg0,*_arg1,*_arg2,*_arg3,*_arg4);
 428
 429     wxPy_END_ALLOW_THREADS;
 430 }    if (_result) {
 431         SWIG_MakePtr(_ptemp, (char *) _result,"_wxFSFile_p");
 432         _resultobj = Py_BuildValue("s",_ptemp);
 433     } else {
 434         Py_INCREF(Py_None);
 435         _resultobj = Py_None;
 436     }
 437 {
 438     if (_obj1)
 439         delete _arg1;
 440 }
 441 {
 442     if (_obj2)
 443         delete _arg2;
 444 }
 445 {
 446     if (_obj3)
 447         delete _arg3;
 448 }
 449     return _resultobj;
 450 }
 451
 452 #define wxFSFile_GetStream(_swigobj)  (_swigobj->GetStream())
 453 static PyObject *_wrap_wxFSFile_GetStream(PyObject *self, PyObject *args, PyObject *kwargs) {
 454     PyObject * _resultobj;
 455     wxInputStream * _result;
 456     wxFSFile * _arg0;
 457     PyObject * _argo0 = 0;
 458     char *_kwnames[] = { "self", NULL };
 459
 460     self = self;
 461     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxFSFile_GetStream",_kwnames,&_argo0))
 462         return NULL;
 463     if (_argo0) {
 464         if (_argo0 == Py_None) { _arg0 = NULL; }
 465         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxFSFile_p")) {
 466             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxFSFile_GetStream. Expected _wxFSFile_p.");
 467         return NULL;
 468         }
 469     }
 470 {
 471     wxPy_BEGIN_ALLOW_THREADS;
 472         _result = (wxInputStream *)wxFSFile_GetStream(_arg0);
 473
 474     wxPy_END_ALLOW_THREADS;
 475 }{
 476     wxPyInputStream * _ptr = NULL;
 477
 478     if (_result) {
 479         _ptr = new wxPyInputStream(_result);
 480     }
 481     if (_ptr) {
 482         char    swigptr[64];
 483         SWIG_MakePtr(swigptr, _ptr, "_wxPyInputStream_p");
 484
 485         PyObject* classobj = PyDict_GetItemString(wxPython_dict, "wxInputStreamPtr");
 486         if (! classobj) {
 487             Py_INCREF(Py_None);
 488             _resultobj = Py_None;
 489         } else {
 490             PyObject* arg = Py_BuildValue("(s)", swigptr);
 491             _resultobj = PyInstance_New(classobj, arg, NULL);
 492             Py_DECREF(arg);
 493
 494             // set ThisOwn
 495             PyObject* one = PyInt_FromLong(1);
 496             PyObject_SetAttrString(_resultobj, "thisown", one);
 497             Py_DECREF(one);
 498         }
 499     } else {
 500         Py_INCREF(Py_None);
 501         _resultobj = Py_None;
 502     }
 503 }
 504     return _resultobj;
 505 }
 506
 507 #define wxFSFile_GetMimeType(_swigobj)  (_swigobj->GetMimeType())
 508 static PyObject *_wrap_wxFSFile_GetMimeType(PyObject *self, PyObject *args, PyObject *kwargs) {
 509     PyObject * _resultobj;
 510     wxString * _result;
 511     wxFSFile * _arg0;
 512     PyObject * _argo0 = 0;
 513     char *_kwnames[] = { "self", NULL };
 514
 515     self = self;
 516     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxFSFile_GetMimeType",_kwnames,&_argo0))
 517         return NULL;
 518     if (_argo0) {
 519         if (_argo0 == Py_None) { _arg0 = NULL; }
 520         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxFSFile_p")) {
 521             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxFSFile_GetMimeType. Expected _wxFSFile_p.");
 522         return NULL;
 523         }
 524     }
 525 {
 526     wxPy_BEGIN_ALLOW_THREADS;
 527         const wxString & _result_ref = wxFSFile_GetMimeType(_arg0);
 528     _result = (wxString *) &_result_ref;
 529
 530     wxPy_END_ALLOW_THREADS;
 531 }{
 532     _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
 533 }
 534     return _resultobj;
 535 }
 536
 537 #define wxFSFile_GetLocation(_swigobj)  (_swigobj->GetLocation())
 538 static PyObject *_wrap_wxFSFile_GetLocation(PyObject *self, PyObject *args, PyObject *kwargs) {
 539     PyObject * _resultobj;
 540     wxString * _result;
 541     wxFSFile * _arg0;
 542     PyObject * _argo0 = 0;
 543     char *_kwnames[] = { "self", NULL };
 544
 545     self = self;
 546     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxFSFile_GetLocation",_kwnames,&_argo0))
 547         return NULL;
 548     if (_argo0) {
 549         if (_argo0 == Py_None) { _arg0 = NULL; }
 550         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxFSFile_p")) {
 551             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxFSFile_GetLocation. Expected _wxFSFile_p.");
 552         return NULL;
 553         }
 554     }
 555 {
 556     wxPy_BEGIN_ALLOW_THREADS;
 557         const wxString & _result_ref = wxFSFile_GetLocation(_arg0);
 558     _result = (wxString *) &_result_ref;
 559
 560     wxPy_END_ALLOW_THREADS;
 561 }{
 562     _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
 563 }
 564     return _resultobj;
 565 }
 566
 567 #define wxFSFile_GetAnchor(_swigobj)  (_swigobj->GetAnchor())
 568 static PyObject *_wrap_wxFSFile_GetAnchor(PyObject *self, PyObject *args, PyObject *kwargs) {
 569     PyObject * _resultobj;
 570     wxString * _result;
 571     wxFSFile * _arg0;
 572     PyObject * _argo0 = 0;
 573     char *_kwnames[] = { "self", NULL };
 574
 575     self = self;
 576     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxFSFile_GetAnchor",_kwnames,&_argo0))
 577         return NULL;
 578     if (_argo0) {
 579         if (_argo0 == Py_None) { _arg0 = NULL; }
 580         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxFSFile_p")) {
 581             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxFSFile_GetAnchor. Expected _wxFSFile_p.");
 582         return NULL;
 583         }
 584     }
 585 {
 586     wxPy_BEGIN_ALLOW_THREADS;
 587         const wxString & _result_ref = wxFSFile_GetAnchor(_arg0);
 588     _result = (wxString *) &_result_ref;
 589
 590     wxPy_END_ALLOW_THREADS;
 591 }{
 592     _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
 593 }
 594     return _resultobj;
 595 }
 596
 597 #define wxFSFile_GetModificationTime(_swigobj)  (_swigobj->GetModificationTime())
 598 static PyObject *_wrap_wxFSFile_GetModificationTime(PyObject *self, PyObject *args, PyObject *kwargs) {
 599     PyObject * _resultobj;
 600     wxDateTime * _result;
 601     wxFSFile * _arg0;
 602     PyObject * _argo0 = 0;
 603     char *_kwnames[] = { "self", NULL };
 604     char _ptemp[128];
 605
 606     self = self;
 607     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxFSFile_GetModificationTime",_kwnames,&_argo0))
 608         return NULL;
 609     if (_argo0) {
 610         if (_argo0 == Py_None) { _arg0 = NULL; }
 611         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxFSFile_p")) {
 612             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxFSFile_GetModificationTime. Expected _wxFSFile_p.");
 613         return NULL;
 614         }
 615     }
 616 {
 617     wxPy_BEGIN_ALLOW_THREADS;
 618         _result = new wxDateTime (wxFSFile_GetModificationTime(_arg0));
 619
 620     wxPy_END_ALLOW_THREADS;
 621 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxDateTime_p");
 622     _resultobj = Py_BuildValue("s",_ptemp);
 623     return _resultobj;
 624 }
 625
 626 static void *SwigwxPyFileSystemHandlerTowxFileSystemHandler(void *ptr) {
 627     wxPyFileSystemHandler *src;
 628     wxFileSystemHandler *dest;
 629     src = (wxPyFileSystemHandler *) ptr;
 630     dest = (wxFileSystemHandler *) src;
 631     return (void *) dest;
 632 }
 633
 634 #define new_wxFileSystemHandler() (new wxPyFileSystemHandler())
 635 static PyObject *_wrap_new_wxFileSystemHandler(PyObject *self, PyObject *args, PyObject *kwargs) {
 636     PyObject * _resultobj;
 637     wxPyFileSystemHandler * _result;
 638     char *_kwnames[] = {  NULL };
 639     char _ptemp[128];
 640
 641     self = self;
 642     if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxFileSystemHandler",_kwnames))
 643         return NULL;
 644 {
 645     wxPy_BEGIN_ALLOW_THREADS;
 646         _result = (wxPyFileSystemHandler *)new_wxFileSystemHandler();
 647
 648     wxPy_END_ALLOW_THREADS;
 649 }    if (_result) {
 650         SWIG_MakePtr(_ptemp, (char *) _result,"_wxPyFileSystemHandler_p");
 651         _resultobj = Py_BuildValue("s",_ptemp);
 652     } else {
 653         Py_INCREF(Py_None);
 654         _resultobj = Py_None;
 655     }
 656     return _resultobj;
 657 }
 658
 659 #define wxFileSystemHandler__setSelf(_swigobj,_swigarg0,_swigarg1)  (_swigobj->_setSelf(_swigarg0,_swigarg1))
 660 static PyObject *_wrap_wxFileSystemHandler__setSelf(PyObject *self, PyObject *args, PyObject *kwargs) {
 661     PyObject * _resultobj;
 662     wxPyFileSystemHandler * _arg0;
 663     PyObject * _arg1;
 664     PyObject * _arg2;
 665     PyObject * _argo0 = 0;
 666     PyObject * _obj1 = 0;
 667     PyObject * _obj2 = 0;
 668     char *_kwnames[] = { "self","self","_class", NULL };
 669
 670     self = self;
 671     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO:wxFileSystemHandler__setSelf",_kwnames,&_argo0,&_obj1,&_obj2))
 672         return NULL;
 673     if (_argo0) {
 674         if (_argo0 == Py_None) { _arg0 = NULL; }
 675         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyFileSystemHandler_p")) {
 676             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxFileSystemHandler__setSelf. Expected _wxPyFileSystemHandler_p.");
 677         return NULL;
 678         }
 679     }
 680 {
 681   _arg1 = _obj1;
 682 }
 683 {
 684   _arg2 = _obj2;
 685 }
 686 {
 687     wxPy_BEGIN_ALLOW_THREADS;
 688         wxFileSystemHandler__setSelf(_arg0,_arg1,_arg2);
 689
 690     wxPy_END_ALLOW_THREADS;
 691 }    Py_INCREF(Py_None);
 692     _resultobj = Py_None;
 693     return _resultobj;
 694 }
 695
 696 #define wxFileSystemHandler_CanOpen(_swigobj,_swigarg0)  (_swigobj->CanOpen(_swigarg0))
 697 static PyObject *_wrap_wxFileSystemHandler_CanOpen(PyObject *self, PyObject *args, PyObject *kwargs) {
 698     PyObject * _resultobj;
 699     bool  _result;
 700     wxPyFileSystemHandler * _arg0;
 701     wxString * _arg1;
 702     PyObject * _argo0 = 0;
 703     PyObject * _obj1 = 0;
 704     char *_kwnames[] = { "self","location", NULL };
 705
 706     self = self;
 707     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxFileSystemHandler_CanOpen",_kwnames,&_argo0,&_obj1))
 708         return NULL;
 709     if (_argo0) {
 710         if (_argo0 == Py_None) { _arg0 = NULL; }
 711         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyFileSystemHandler_p")) {
 712             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxFileSystemHandler_CanOpen. Expected _wxPyFileSystemHandler_p.");
 713         return NULL;
 714         }
 715     }
 716 {
 717 #if PYTHON_API_VERSION >= 1009
 718     char* tmpPtr; int tmpSize;
 719     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
 720         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
 721         return NULL;
 722     }
 723     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
 724         return NULL;
 725     _arg1 = new wxString(tmpPtr, tmpSize);
 726 #else
 727     if (!PyString_Check(_obj1)) {
 728         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
 729         return NULL;
 730     }
 731     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
 732 #endif
 733 }
 734 {
 735     wxPy_BEGIN_ALLOW_THREADS;
 736         _result = (bool )wxFileSystemHandler_CanOpen(_arg0,*_arg1);
 737
 738     wxPy_END_ALLOW_THREADS;
 739 }    _resultobj = Py_BuildValue("i",_result);
 740 {
 741     if (_obj1)
 742         delete _arg1;
 743 }
 744     return _resultobj;
 745 }
 746
 747 #define wxFileSystemHandler_OpenFile(_swigobj,_swigarg0,_swigarg1)  (_swigobj->OpenFile(_swigarg0,_swigarg1))
 748 static PyObject *_wrap_wxFileSystemHandler_OpenFile(PyObject *self, PyObject *args, PyObject *kwargs) {
 749     PyObject * _resultobj;
 750     wxFSFile * _result;
 751     wxPyFileSystemHandler * _arg0;
 752     wxFileSystem * _arg1;
 753     wxString * _arg2;
 754     PyObject * _argo0 = 0;
 755     PyObject * _argo1 = 0;
 756     PyObject * _obj2 = 0;
 757     char *_kwnames[] = { "self","fs","location", NULL };
 758     char _ptemp[128];
 759
 760     self = self;
 761     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO:wxFileSystemHandler_OpenFile",_kwnames,&_argo0,&_argo1,&_obj2))
 762         return NULL;
 763     if (_argo0) {
 764         if (_argo0 == Py_None) { _arg0 = NULL; }
 765         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyFileSystemHandler_p")) {
 766             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxFileSystemHandler_OpenFile. Expected _wxPyFileSystemHandler_p.");
 767         return NULL;
 768         }
 769     }
 770     if (_argo1) {
 771         if (_argo1 == Py_None) { _arg1 = NULL; }
 772         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxFileSystem_p")) {
 773             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxFileSystemHandler_OpenFile. Expected _wxFileSystem_p.");
 774         return NULL;
 775         }
 776     }
 777 {
 778 #if PYTHON_API_VERSION >= 1009
 779     char* tmpPtr; int tmpSize;
 780     if (!PyString_Check(_obj2) && !PyUnicode_Check(_obj2)) {
 781         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
 782         return NULL;
 783     }
 784     if (PyString_AsStringAndSize(_obj2, &tmpPtr, &tmpSize) == -1)
 785         return NULL;
 786     _arg2 = new wxString(tmpPtr, tmpSize);
 787 #else
 788     if (!PyString_Check(_obj2)) {
 789         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
 790         return NULL;
 791     }
 792     _arg2 = new wxString(PyString_AS_STRING(_obj2), PyString_GET_SIZE(_obj2));
 793 #endif
 794 }
 795 {
 796     wxPy_BEGIN_ALLOW_THREADS;
 797         _result = (wxFSFile *)wxFileSystemHandler_OpenFile(_arg0,*_arg1,*_arg2);
 798
 799     wxPy_END_ALLOW_THREADS;
 800 }    if (_result) {
 801         SWIG_MakePtr(_ptemp, (char *) _result,"_wxFSFile_p");
 802         _resultobj = Py_BuildValue("s",_ptemp);
 803     } else {
 804         Py_INCREF(Py_None);
 805         _resultobj = Py_None;
 806     }
 807 {
 808     if (_obj2)
 809         delete _arg2;
 810 }
 811     return _resultobj;
 812 }
 813
 814 #define wxFileSystemHandler_FindFirst(_swigobj,_swigarg0,_swigarg1)  (_swigobj->FindFirst(_swigarg0,_swigarg1))
 815 static PyObject *_wrap_wxFileSystemHandler_FindFirst(PyObject *self, PyObject *args, PyObject *kwargs) {
 816     PyObject * _resultobj;
 817     wxString * _result;
 818     wxPyFileSystemHandler * _arg0;
 819     wxString * _arg1;
 820     int  _arg2 = (int ) 0;
 821     PyObject * _argo0 = 0;
 822     PyObject * _obj1 = 0;
 823     char *_kwnames[] = { "self","spec","flags", NULL };
 824
 825     self = self;
 826     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO|i:wxFileSystemHandler_FindFirst",_kwnames,&_argo0,&_obj1,&_arg2))
 827         return NULL;
 828     if (_argo0) {
 829         if (_argo0 == Py_None) { _arg0 = NULL; }
 830         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyFileSystemHandler_p")) {
 831             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxFileSystemHandler_FindFirst. Expected _wxPyFileSystemHandler_p.");
 832         return NULL;
 833         }
 834     }
 835 {
 836 #if PYTHON_API_VERSION >= 1009
 837     char* tmpPtr; int tmpSize;
 838     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
 839         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
 840         return NULL;
 841     }
 842     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
 843         return NULL;
 844     _arg1 = new wxString(tmpPtr, tmpSize);
 845 #else
 846     if (!PyString_Check(_obj1)) {
 847         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
 848         return NULL;
 849     }
 850     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
 851 #endif
 852 }
 853 {
 854     wxPy_BEGIN_ALLOW_THREADS;
 855         _result = new wxString (wxFileSystemHandler_FindFirst(_arg0,*_arg1,_arg2));
 856
 857     wxPy_END_ALLOW_THREADS;
 858 }{
 859     _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
 860 }
 861 {
 862     if (_obj1)
 863         delete _arg1;
 864 }
 865 {
 866     delete _result;
 867 }
 868     return _resultobj;
 869 }
 870
 871 #define wxFileSystemHandler_FindNext(_swigobj)  (_swigobj->FindNext())
 872 static PyObject *_wrap_wxFileSystemHandler_FindNext(PyObject *self, PyObject *args, PyObject *kwargs) {
 873     PyObject * _resultobj;
 874     wxString * _result;
 875     wxPyFileSystemHandler * _arg0;
 876     PyObject * _argo0 = 0;
 877     char *_kwnames[] = { "self", NULL };
 878
 879     self = self;
 880     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxFileSystemHandler_FindNext",_kwnames,&_argo0))
 881         return NULL;
 882     if (_argo0) {
 883         if (_argo0 == Py_None) { _arg0 = NULL; }
 884         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyFileSystemHandler_p")) {
 885             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxFileSystemHandler_FindNext. Expected _wxPyFileSystemHandler_p.");
 886         return NULL;
 887         }
 888     }
 889 {
 890     wxPy_BEGIN_ALLOW_THREADS;
 891         _result = new wxString (wxFileSystemHandler_FindNext(_arg0));
 892
 893     wxPy_END_ALLOW_THREADS;
 894 }{
 895     _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
 896 }
 897 {
 898     delete _result;
 899 }
 900     return _resultobj;
 901 }
 902
 903 #define wxFileSystemHandler_GetProtocol(_swigobj,_swigarg0)  (_swigobj->GetProtocol(_swigarg0))
 904 static PyObject *_wrap_wxFileSystemHandler_GetProtocol(PyObject *self, PyObject *args, PyObject *kwargs) {
 905     PyObject * _resultobj;
 906     wxString * _result;
 907     wxPyFileSystemHandler * _arg0;
 908     wxString * _arg1;
 909     PyObject * _argo0 = 0;
 910     PyObject * _obj1 = 0;
 911     char *_kwnames[] = { "self","location", NULL };
 912
 913     self = self;
 914     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxFileSystemHandler_GetProtocol",_kwnames,&_argo0,&_obj1))
 915         return NULL;
 916     if (_argo0) {
 917         if (_argo0 == Py_None) { _arg0 = NULL; }
 918         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyFileSystemHandler_p")) {
 919             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxFileSystemHandler_GetProtocol. Expected _wxPyFileSystemHandler_p.");
 920         return NULL;
 921         }
 922     }
 923 {
 924 #if PYTHON_API_VERSION >= 1009
 925     char* tmpPtr; int tmpSize;
 926     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
 927         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
 928         return NULL;
 929     }
 930     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
 931         return NULL;
 932     _arg1 = new wxString(tmpPtr, tmpSize);
 933 #else
 934     if (!PyString_Check(_obj1)) {
 935         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
 936         return NULL;
 937     }
 938     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
 939 #endif
 940 }
 941 {
 942     wxPy_BEGIN_ALLOW_THREADS;
 943         _result = new wxString (wxFileSystemHandler_GetProtocol(_arg0,*_arg1));
 944
 945     wxPy_END_ALLOW_THREADS;
 946 }{
 947     _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
 948 }
 949 {
 950     if (_obj1)
 951         delete _arg1;
 952 }
 953 {
 954     delete _result;
 955 }
 956     return _resultobj;
 957 }
 958
 959 #define wxFileSystemHandler_GetLeftLocation(_swigobj,_swigarg0)  (_swigobj->GetLeftLocation(_swigarg0))
 960 static PyObject *_wrap_wxFileSystemHandler_GetLeftLocation(PyObject *self, PyObject *args, PyObject *kwargs) {
 961     PyObject * _resultobj;
 962     wxString * _result;
 963     wxPyFileSystemHandler * _arg0;
 964     wxString * _arg1;
 965     PyObject * _argo0 = 0;
 966     PyObject * _obj1 = 0;
 967     char *_kwnames[] = { "self","location", NULL };
 968
 969     self = self;
 970     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxFileSystemHandler_GetLeftLocation",_kwnames,&_argo0,&_obj1))
 971         return NULL;
 972     if (_argo0) {
 973         if (_argo0 == Py_None) { _arg0 = NULL; }
 974         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyFileSystemHandler_p")) {
 975             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxFileSystemHandler_GetLeftLocation. Expected _wxPyFileSystemHandler_p.");
 976         return NULL;
 977         }
 978     }
 979 {
 980 #if PYTHON_API_VERSION >= 1009
 981     char* tmpPtr; int tmpSize;
 982     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
 983         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
 984         return NULL;
 985     }
 986     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
 987         return NULL;
 988     _arg1 = new wxString(tmpPtr, tmpSize);
 989 #else
 990     if (!PyString_Check(_obj1)) {
 991         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
 992         return NULL;
 993     }
 994     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
 995 #endif
 996 }
 997 {
 998     wxPy_BEGIN_ALLOW_THREADS;
 999         _result = new wxString (wxFileSystemHandler_GetLeftLocation(_arg0,*_arg1));
1000
1001     wxPy_END_ALLOW_THREADS;
1002 }{
1003     _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
1004 }
1005 {
1006     if (_obj1)
1007         delete _arg1;
1008 }
1009 {
1010     delete _result;
1011 }
1012     return _resultobj;
1013 }
1014
1015 #define wxFileSystemHandler_GetAnchor(_swigobj,_swigarg0)  (_swigobj->GetAnchor(_swigarg0))
1016 static PyObject *_wrap_wxFileSystemHandler_GetAnchor(PyObject *self, PyObject *args, PyObject *kwargs) {
1017     PyObject * _resultobj;
1018     wxString * _result;
1019     wxPyFileSystemHandler * _arg0;
1020     wxString * _arg1;
1021     PyObject * _argo0 = 0;
1022     PyObject * _obj1 = 0;
1023     char *_kwnames[] = { "self","location", NULL };
1024
1025     self = self;
1026     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxFileSystemHandler_GetAnchor",_kwnames,&_argo0,&_obj1))
1027         return NULL;
1028     if (_argo0) {
1029         if (_argo0 == Py_None) { _arg0 = NULL; }
1030         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyFileSystemHandler_p")) {
1031             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxFileSystemHandler_GetAnchor. Expected _wxPyFileSystemHandler_p.");
1032         return NULL;
1033         }
1034     }
1035 {
1036 #if PYTHON_API_VERSION >= 1009
1037     char* tmpPtr; int tmpSize;
1038     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
1039         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1040         return NULL;
1041     }
1042     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
1043         return NULL;
1044     _arg1 = new wxString(tmpPtr, tmpSize);
1045 #else
1046     if (!PyString_Check(_obj1)) {
1047         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1048         return NULL;
1049     }
1050     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
1051 #endif
1052 }
1053 {
1054     wxPy_BEGIN_ALLOW_THREADS;
1055         _result = new wxString (wxFileSystemHandler_GetAnchor(_arg0,*_arg1));
1056
1057     wxPy_END_ALLOW_THREADS;
1058 }{
1059     _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
1060 }
1061 {
1062     if (_obj1)
1063         delete _arg1;
1064 }
1065 {
1066     delete _result;
1067 }
1068     return _resultobj;
1069 }
1070
1071 #define wxFileSystemHandler_GetRightLocation(_swigobj,_swigarg0)  (_swigobj->GetRightLocation(_swigarg0))
1072 static PyObject *_wrap_wxFileSystemHandler_GetRightLocation(PyObject *self, PyObject *args, PyObject *kwargs) {
1073     PyObject * _resultobj;
1074     wxString * _result;
1075     wxPyFileSystemHandler * _arg0;
1076     wxString * _arg1;
1077     PyObject * _argo0 = 0;
1078     PyObject * _obj1 = 0;
1079     char *_kwnames[] = { "self","location", NULL };
1080
1081     self = self;
1082     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxFileSystemHandler_GetRightLocation",_kwnames,&_argo0,&_obj1))
1083         return NULL;
1084     if (_argo0) {
1085         if (_argo0 == Py_None) { _arg0 = NULL; }
1086         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyFileSystemHandler_p")) {
1087             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxFileSystemHandler_GetRightLocation. Expected _wxPyFileSystemHandler_p.");
1088         return NULL;
1089         }
1090     }
1091 {
1092 #if PYTHON_API_VERSION >= 1009
1093     char* tmpPtr; int tmpSize;
1094     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
1095         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1096         return NULL;
1097     }
1098     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
1099         return NULL;
1100     _arg1 = new wxString(tmpPtr, tmpSize);
1101 #else
1102     if (!PyString_Check(_obj1)) {
1103         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1104         return NULL;
1105     }
1106     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
1107 #endif
1108 }
1109 {
1110     wxPy_BEGIN_ALLOW_THREADS;
1111         _result = new wxString (wxFileSystemHandler_GetRightLocation(_arg0,*_arg1));
1112
1113     wxPy_END_ALLOW_THREADS;
1114 }{
1115     _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
1116 }
1117 {
1118     if (_obj1)
1119         delete _arg1;
1120 }
1121 {
1122     delete _result;
1123 }
1124     return _resultobj;
1125 }
1126
1127 #define wxFileSystemHandler_GetMimeTypeFromExt(_swigobj,_swigarg0)  (_swigobj->GetMimeTypeFromExt(_swigarg0))
1128 static PyObject *_wrap_wxFileSystemHandler_GetMimeTypeFromExt(PyObject *self, PyObject *args, PyObject *kwargs) {
1129     PyObject * _resultobj;
1130     wxString * _result;
1131     wxPyFileSystemHandler * _arg0;
1132     wxString * _arg1;
1133     PyObject * _argo0 = 0;
1134     PyObject * _obj1 = 0;
1135     char *_kwnames[] = { "self","location", NULL };
1136
1137     self = self;
1138     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxFileSystemHandler_GetMimeTypeFromExt",_kwnames,&_argo0,&_obj1))
1139         return NULL;
1140     if (_argo0) {
1141         if (_argo0 == Py_None) { _arg0 = NULL; }
1142         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyFileSystemHandler_p")) {
1143             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxFileSystemHandler_GetMimeTypeFromExt. Expected _wxPyFileSystemHandler_p.");
1144         return NULL;
1145         }
1146     }
1147 {
1148 #if PYTHON_API_VERSION >= 1009
1149     char* tmpPtr; int tmpSize;
1150     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
1151         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1152         return NULL;
1153     }
1154     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
1155         return NULL;
1156     _arg1 = new wxString(tmpPtr, tmpSize);
1157 #else
1158     if (!PyString_Check(_obj1)) {
1159         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1160         return NULL;
1161     }
1162     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
1163 #endif
1164 }
1165 {
1166     wxPy_BEGIN_ALLOW_THREADS;
1167         _result = new wxString (wxFileSystemHandler_GetMimeTypeFromExt(_arg0,*_arg1));
1168
1169     wxPy_END_ALLOW_THREADS;
1170 }{
1171     _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
1172 }
1173 {
1174     if (_obj1)
1175         delete _arg1;
1176 }
1177 {
1178     delete _result;
1179 }
1180     return _resultobj;
1181 }
1182
1183 #define new_wxFileSystem() (new wxFileSystem())
1184 static PyObject *_wrap_new_wxFileSystem(PyObject *self, PyObject *args, PyObject *kwargs) {
1185     PyObject * _resultobj;
1186     wxFileSystem * _result;
1187     char *_kwnames[] = {  NULL };
1188     char _ptemp[128];
1189
1190     self = self;
1191     if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxFileSystem",_kwnames))
1192         return NULL;
1193 {
1194     wxPy_BEGIN_ALLOW_THREADS;
1195         _result = (wxFileSystem *)new_wxFileSystem();
1196
1197     wxPy_END_ALLOW_THREADS;
1198 }    if (_result) {
1199         SWIG_MakePtr(_ptemp, (char *) _result,"_wxFileSystem_p");
1200         _resultobj = Py_BuildValue("s",_ptemp);
1201     } else {
1202         Py_INCREF(Py_None);
1203         _resultobj = Py_None;
1204     }
1205     return _resultobj;
1206 }
1207
1208 #define wxFileSystem_ChangePathTo(_swigobj,_swigarg0,_swigarg1)  (_swigobj->ChangePathTo(_swigarg0,_swigarg1))
1209 static PyObject *_wrap_wxFileSystem_ChangePathTo(PyObject *self, PyObject *args, PyObject *kwargs) {
1210     PyObject * _resultobj;
1211     wxFileSystem * _arg0;
1212     wxString * _arg1;
1213     bool  _arg2 = (bool ) FALSE;
1214     PyObject * _argo0 = 0;
1215     PyObject * _obj1 = 0;
1216     int tempbool2 = (int) FALSE;
1217     char *_kwnames[] = { "self","location","is_dir", NULL };
1218
1219     self = self;
1220     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO|i:wxFileSystem_ChangePathTo",_kwnames,&_argo0,&_obj1,&tempbool2))
1221         return NULL;
1222     if (_argo0) {
1223         if (_argo0 == Py_None) { _arg0 = NULL; }
1224         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxFileSystem_p")) {
1225             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxFileSystem_ChangePathTo. Expected _wxFileSystem_p.");
1226         return NULL;
1227         }
1228     }
1229 {
1230 #if PYTHON_API_VERSION >= 1009
1231     char* tmpPtr; int tmpSize;
1232     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
1233         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1234         return NULL;
1235     }
1236     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
1237         return NULL;
1238     _arg1 = new wxString(tmpPtr, tmpSize);
1239 #else
1240     if (!PyString_Check(_obj1)) {
1241         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1242         return NULL;
1243     }
1244     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
1245 #endif
1246 }
1247     _arg2 = (bool ) tempbool2;
1248 {
1249     wxPy_BEGIN_ALLOW_THREADS;
1250         wxFileSystem_ChangePathTo(_arg0,*_arg1,_arg2);
1251
1252     wxPy_END_ALLOW_THREADS;
1253 }    Py_INCREF(Py_None);
1254     _resultobj = Py_None;
1255 {
1256     if (_obj1)
1257         delete _arg1;
1258 }
1259     return _resultobj;
1260 }
1261
1262 #define wxFileSystem_GetPath(_swigobj)  (_swigobj->GetPath())
1263 static PyObject *_wrap_wxFileSystem_GetPath(PyObject *self, PyObject *args, PyObject *kwargs) {
1264     PyObject * _resultobj;
1265     wxString * _result;
1266     wxFileSystem * _arg0;
1267     PyObject * _argo0 = 0;
1268     char *_kwnames[] = { "self", NULL };
1269
1270     self = self;
1271     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxFileSystem_GetPath",_kwnames,&_argo0))
1272         return NULL;
1273     if (_argo0) {
1274         if (_argo0 == Py_None) { _arg0 = NULL; }
1275         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxFileSystem_p")) {
1276             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxFileSystem_GetPath. Expected _wxFileSystem_p.");
1277         return NULL;
1278         }
1279     }
1280 {
1281     wxPy_BEGIN_ALLOW_THREADS;
1282         _result = new wxString (wxFileSystem_GetPath(_arg0));
1283
1284     wxPy_END_ALLOW_THREADS;
1285 }{
1286     _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
1287 }
1288 {
1289     delete _result;
1290 }
1291     return _resultobj;
1292 }
1293
1294 #define wxFileSystem_OpenFile(_swigobj,_swigarg0)  (_swigobj->OpenFile(_swigarg0))
1295 static PyObject *_wrap_wxFileSystem_OpenFile(PyObject *self, PyObject *args, PyObject *kwargs) {
1296     PyObject * _resultobj;
1297     wxFSFile * _result;
1298     wxFileSystem * _arg0;
1299     wxString * _arg1;
1300     PyObject * _argo0 = 0;
1301     PyObject * _obj1 = 0;
1302     char *_kwnames[] = { "self","location", NULL };
1303     char _ptemp[128];
1304
1305     self = self;
1306     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxFileSystem_OpenFile",_kwnames,&_argo0,&_obj1))
1307         return NULL;
1308     if (_argo0) {
1309         if (_argo0 == Py_None) { _arg0 = NULL; }
1310         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxFileSystem_p")) {
1311             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxFileSystem_OpenFile. Expected _wxFileSystem_p.");
1312         return NULL;
1313         }
1314     }
1315 {
1316 #if PYTHON_API_VERSION >= 1009
1317     char* tmpPtr; int tmpSize;
1318     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
1319         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1320         return NULL;
1321     }
1322     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
1323         return NULL;
1324     _arg1 = new wxString(tmpPtr, tmpSize);
1325 #else
1326     if (!PyString_Check(_obj1)) {
1327         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1328         return NULL;
1329     }
1330     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
1331 #endif
1332 }
1333 {
1334     wxPy_BEGIN_ALLOW_THREADS;
1335         _result = (wxFSFile *)wxFileSystem_OpenFile(_arg0,*_arg1);
1336
1337     wxPy_END_ALLOW_THREADS;
1338 }    if (_result) {
1339         SWIG_MakePtr(_ptemp, (char *) _result,"_wxFSFile_p");
1340         _resultobj = Py_BuildValue("s",_ptemp);
1341     } else {
1342         Py_INCREF(Py_None);
1343         _resultobj = Py_None;
1344     }
1345 {
1346     if (_obj1)
1347         delete _arg1;
1348 }
1349     return _resultobj;
1350 }
1351
1352 #define wxFileSystem_FindFirst(_swigobj,_swigarg0,_swigarg1)  (_swigobj->FindFirst(_swigarg0,_swigarg1))
1353 static PyObject *_wrap_wxFileSystem_FindFirst(PyObject *self, PyObject *args, PyObject *kwargs) {
1354     PyObject * _resultobj;
1355     wxString * _result;
1356     wxFileSystem * _arg0;
1357     wxString * _arg1;
1358     int  _arg2 = (int ) 0;
1359     PyObject * _argo0 = 0;
1360     PyObject * _obj1 = 0;
1361     char *_kwnames[] = { "self","spec","flags", NULL };
1362
1363     self = self;
1364     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO|i:wxFileSystem_FindFirst",_kwnames,&_argo0,&_obj1,&_arg2))
1365         return NULL;
1366     if (_argo0) {
1367         if (_argo0 == Py_None) { _arg0 = NULL; }
1368         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxFileSystem_p")) {
1369             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxFileSystem_FindFirst. Expected _wxFileSystem_p.");
1370         return NULL;
1371         }
1372     }
1373 {
1374 #if PYTHON_API_VERSION >= 1009
1375     char* tmpPtr; int tmpSize;
1376     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
1377         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1378         return NULL;
1379     }
1380     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
1381         return NULL;
1382     _arg1 = new wxString(tmpPtr, tmpSize);
1383 #else
1384     if (!PyString_Check(_obj1)) {
1385         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1386         return NULL;
1387     }
1388     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
1389 #endif
1390 }
1391 {
1392     wxPy_BEGIN_ALLOW_THREADS;
1393         _result = new wxString (wxFileSystem_FindFirst(_arg0,*_arg1,_arg2));
1394
1395     wxPy_END_ALLOW_THREADS;
1396 }{
1397     _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
1398 }
1399 {
1400     if (_obj1)
1401         delete _arg1;
1402 }
1403 {
1404     delete _result;
1405 }
1406     return _resultobj;
1407 }
1408
1409 #define wxFileSystem_FindNext(_swigobj)  (_swigobj->FindNext())
1410 static PyObject *_wrap_wxFileSystem_FindNext(PyObject *self, PyObject *args, PyObject *kwargs) {
1411     PyObject * _resultobj;
1412     wxString * _result;
1413     wxFileSystem * _arg0;
1414     PyObject * _argo0 = 0;
1415     char *_kwnames[] = { "self", NULL };
1416
1417     self = self;
1418     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxFileSystem_FindNext",_kwnames,&_argo0))
1419         return NULL;
1420     if (_argo0) {
1421         if (_argo0 == Py_None) { _arg0 = NULL; }
1422         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxFileSystem_p")) {
1423             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxFileSystem_FindNext. Expected _wxFileSystem_p.");
1424         return NULL;
1425         }
1426     }
1427 {
1428     wxPy_BEGIN_ALLOW_THREADS;
1429         _result = new wxString (wxFileSystem_FindNext(_arg0));
1430
1431     wxPy_END_ALLOW_THREADS;
1432 }{
1433     _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
1434 }
1435 {
1436     delete _result;
1437 }
1438     return _resultobj;
1439 }
1440
1441 static PyObject *_wrap_wxFileSystem_AddHandler(PyObject *self, PyObject *args, PyObject *kwargs) {
1442     PyObject * _resultobj;
1443     wxFileSystemHandler * _arg0;
1444     PyObject * _argo0 = 0;
1445     char *_kwnames[] = { "handler", NULL };
1446
1447     self = self;
1448     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxFileSystem_AddHandler",_kwnames,&_argo0))
1449         return NULL;
1450     if (_argo0) {
1451         if (_argo0 == Py_None) { _arg0 = NULL; }
1452         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxFileSystemHandler_p")) {
1453             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxFileSystem_AddHandler. Expected _wxFileSystemHandler_p.");
1454         return NULL;
1455         }
1456     }
1457 {
1458     wxPy_BEGIN_ALLOW_THREADS;
1459         wxFileSystem::AddHandler(_arg0);
1460
1461     wxPy_END_ALLOW_THREADS;
1462 }    Py_INCREF(Py_None);
1463     _resultobj = Py_None;
1464     return _resultobj;
1465 }
1466
1467 static PyObject *_wrap_wxFileSystem_CleanUpHandlers(PyObject *self, PyObject *args, PyObject *kwargs) {
1468     PyObject * _resultobj;
1469     char *_kwnames[] = {  NULL };
1470
1471     self = self;
1472     if(!PyArg_ParseTupleAndKeywords(args,kwargs,":wxFileSystem_CleanUpHandlers",_kwnames))
1473         return NULL;
1474 {
1475     wxPy_BEGIN_ALLOW_THREADS;
1476         wxFileSystem::CleanUpHandlers();
1477
1478     wxPy_END_ALLOW_THREADS;
1479 }    Py_INCREF(Py_None);
1480     _resultobj = Py_None;
1481     return _resultobj;
1482 }
1483
1484 static void *SwigwxInternetFSHandlerTowxFileSystemHandler(void *ptr) {
1485     wxInternetFSHandler *src;
1486     wxFileSystemHandler *dest;
1487     src = (wxInternetFSHandler *) ptr;
1488     dest = (wxFileSystemHandler *) src;
1489     return (void *) dest;
1490 }
1491
1492 #define new_wxInternetFSHandler() (new wxInternetFSHandler())
1493 static PyObject *_wrap_new_wxInternetFSHandler(PyObject *self, PyObject *args, PyObject *kwargs) {
1494     PyObject * _resultobj;
1495     wxInternetFSHandler * _result;
1496     char *_kwnames[] = {  NULL };
1497     char _ptemp[128];
1498
1499     self = self;
1500     if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxInternetFSHandler",_kwnames))
1501         return NULL;
1502 {
1503     wxPy_BEGIN_ALLOW_THREADS;
1504         _result = (wxInternetFSHandler *)new_wxInternetFSHandler();
1505
1506     wxPy_END_ALLOW_THREADS;
1507 }    if (_result) {
1508         SWIG_MakePtr(_ptemp, (char *) _result,"_wxInternetFSHandler_p");
1509         _resultobj = Py_BuildValue("s",_ptemp);
1510     } else {
1511         Py_INCREF(Py_None);
1512         _resultobj = Py_None;
1513     }
1514     return _resultobj;
1515 }
1516
1517 #define wxInternetFSHandler_CanOpen(_swigobj,_swigarg0)  (_swigobj->CanOpen(_swigarg0))
1518 static PyObject *_wrap_wxInternetFSHandler_CanOpen(PyObject *self, PyObject *args, PyObject *kwargs) {
1519     PyObject * _resultobj;
1520     bool  _result;
1521     wxInternetFSHandler * _arg0;
1522     wxString * _arg1;
1523     PyObject * _argo0 = 0;
1524     PyObject * _obj1 = 0;
1525     char *_kwnames[] = { "self","location", NULL };
1526
1527     self = self;
1528     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxInternetFSHandler_CanOpen",_kwnames,&_argo0,&_obj1))
1529         return NULL;
1530     if (_argo0) {
1531         if (_argo0 == Py_None) { _arg0 = NULL; }
1532         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxInternetFSHandler_p")) {
1533             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxInternetFSHandler_CanOpen. Expected _wxInternetFSHandler_p.");
1534         return NULL;
1535         }
1536     }
1537 {
1538 #if PYTHON_API_VERSION >= 1009
1539     char* tmpPtr; int tmpSize;
1540     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
1541         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1542         return NULL;
1543     }
1544     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
1545         return NULL;
1546     _arg1 = new wxString(tmpPtr, tmpSize);
1547 #else
1548     if (!PyString_Check(_obj1)) {
1549         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1550         return NULL;
1551     }
1552     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
1553 #endif
1554 }
1555 {
1556     wxPy_BEGIN_ALLOW_THREADS;
1557         _result = (bool )wxInternetFSHandler_CanOpen(_arg0,*_arg1);
1558
1559     wxPy_END_ALLOW_THREADS;
1560 }    _resultobj = Py_BuildValue("i",_result);
1561 {
1562     if (_obj1)
1563         delete _arg1;
1564 }
1565     return _resultobj;
1566 }
1567
1568 #define wxInternetFSHandler_OpenFile(_swigobj,_swigarg0,_swigarg1)  (_swigobj->OpenFile(_swigarg0,_swigarg1))
1569 static PyObject *_wrap_wxInternetFSHandler_OpenFile(PyObject *self, PyObject *args, PyObject *kwargs) {
1570     PyObject * _resultobj;
1571     wxFSFile * _result;
1572     wxInternetFSHandler * _arg0;
1573     wxFileSystem * _arg1;
1574     wxString * _arg2;
1575     PyObject * _argo0 = 0;
1576     PyObject * _argo1 = 0;
1577     PyObject * _obj2 = 0;
1578     char *_kwnames[] = { "self","fs","location", NULL };
1579     char _ptemp[128];
1580
1581     self = self;
1582     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO:wxInternetFSHandler_OpenFile",_kwnames,&_argo0,&_argo1,&_obj2))
1583         return NULL;
1584     if (_argo0) {
1585         if (_argo0 == Py_None) { _arg0 = NULL; }
1586         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxInternetFSHandler_p")) {
1587             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxInternetFSHandler_OpenFile. Expected _wxInternetFSHandler_p.");
1588         return NULL;
1589         }
1590     }
1591     if (_argo1) {
1592         if (_argo1 == Py_None) { _arg1 = NULL; }
1593         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxFileSystem_p")) {
1594             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxInternetFSHandler_OpenFile. Expected _wxFileSystem_p.");
1595         return NULL;
1596         }
1597     }
1598 {
1599 #if PYTHON_API_VERSION >= 1009
1600     char* tmpPtr; int tmpSize;
1601     if (!PyString_Check(_obj2) && !PyUnicode_Check(_obj2)) {
1602         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1603         return NULL;
1604     }
1605     if (PyString_AsStringAndSize(_obj2, &tmpPtr, &tmpSize) == -1)
1606         return NULL;
1607     _arg2 = new wxString(tmpPtr, tmpSize);
1608 #else
1609     if (!PyString_Check(_obj2)) {
1610         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1611         return NULL;
1612     }
1613     _arg2 = new wxString(PyString_AS_STRING(_obj2), PyString_GET_SIZE(_obj2));
1614 #endif
1615 }
1616 {
1617     wxPy_BEGIN_ALLOW_THREADS;
1618         _result = (wxFSFile *)wxInternetFSHandler_OpenFile(_arg0,*_arg1,*_arg2);
1619
1620     wxPy_END_ALLOW_THREADS;
1621 }    if (_result) {
1622         SWIG_MakePtr(_ptemp, (char *) _result,"_wxFSFile_p");
1623         _resultobj = Py_BuildValue("s",_ptemp);
1624     } else {
1625         Py_INCREF(Py_None);
1626         _resultobj = Py_None;
1627     }
1628 {
1629     if (_obj2)
1630         delete _arg2;
1631 }
1632     return _resultobj;
1633 }
1634
1635 static void *SwigwxZipFSHandlerTowxFileSystemHandler(void *ptr) {
1636     wxZipFSHandler *src;
1637     wxFileSystemHandler *dest;
1638     src = (wxZipFSHandler *) ptr;
1639     dest = (wxFileSystemHandler *) src;
1640     return (void *) dest;
1641 }
1642
1643 #define new_wxZipFSHandler() (new wxZipFSHandler())
1644 static PyObject *_wrap_new_wxZipFSHandler(PyObject *self, PyObject *args, PyObject *kwargs) {
1645     PyObject * _resultobj;
1646     wxZipFSHandler * _result;
1647     char *_kwnames[] = {  NULL };
1648     char _ptemp[128];
1649
1650     self = self;
1651     if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxZipFSHandler",_kwnames))
1652         return NULL;
1653 {
1654     wxPy_BEGIN_ALLOW_THREADS;
1655         _result = (wxZipFSHandler *)new_wxZipFSHandler();
1656
1657     wxPy_END_ALLOW_THREADS;
1658 }    if (_result) {
1659         SWIG_MakePtr(_ptemp, (char *) _result,"_wxZipFSHandler_p");
1660         _resultobj = Py_BuildValue("s",_ptemp);
1661     } else {
1662         Py_INCREF(Py_None);
1663         _resultobj = Py_None;
1664     }
1665     return _resultobj;
1666 }
1667
1668 #define wxZipFSHandler_CanOpen(_swigobj,_swigarg0)  (_swigobj->CanOpen(_swigarg0))
1669 static PyObject *_wrap_wxZipFSHandler_CanOpen(PyObject *self, PyObject *args, PyObject *kwargs) {
1670     PyObject * _resultobj;
1671     bool  _result;
1672     wxZipFSHandler * _arg0;
1673     wxString * _arg1;
1674     PyObject * _argo0 = 0;
1675     PyObject * _obj1 = 0;
1676     char *_kwnames[] = { "self","location", NULL };
1677
1678     self = self;
1679     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxZipFSHandler_CanOpen",_kwnames,&_argo0,&_obj1))
1680         return NULL;
1681     if (_argo0) {
1682         if (_argo0 == Py_None) { _arg0 = NULL; }
1683         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxZipFSHandler_p")) {
1684             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxZipFSHandler_CanOpen. Expected _wxZipFSHandler_p.");
1685         return NULL;
1686         }
1687     }
1688 {
1689 #if PYTHON_API_VERSION >= 1009
1690     char* tmpPtr; int tmpSize;
1691     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
1692         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1693         return NULL;
1694     }
1695     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
1696         return NULL;
1697     _arg1 = new wxString(tmpPtr, tmpSize);
1698 #else
1699     if (!PyString_Check(_obj1)) {
1700         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1701         return NULL;
1702     }
1703     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
1704 #endif
1705 }
1706 {
1707     wxPy_BEGIN_ALLOW_THREADS;
1708         _result = (bool )wxZipFSHandler_CanOpen(_arg0,*_arg1);
1709
1710     wxPy_END_ALLOW_THREADS;
1711 }    _resultobj = Py_BuildValue("i",_result);
1712 {
1713     if (_obj1)
1714         delete _arg1;
1715 }
1716     return _resultobj;
1717 }
1718
1719 #define wxZipFSHandler_OpenFile(_swigobj,_swigarg0,_swigarg1)  (_swigobj->OpenFile(_swigarg0,_swigarg1))
1720 static PyObject *_wrap_wxZipFSHandler_OpenFile(PyObject *self, PyObject *args, PyObject *kwargs) {
1721     PyObject * _resultobj;
1722     wxFSFile * _result;
1723     wxZipFSHandler * _arg0;
1724     wxFileSystem * _arg1;
1725     wxString * _arg2;
1726     PyObject * _argo0 = 0;
1727     PyObject * _argo1 = 0;
1728     PyObject * _obj2 = 0;
1729     char *_kwnames[] = { "self","fs","location", NULL };
1730     char _ptemp[128];
1731
1732     self = self;
1733     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO:wxZipFSHandler_OpenFile",_kwnames,&_argo0,&_argo1,&_obj2))
1734         return NULL;
1735     if (_argo0) {
1736         if (_argo0 == Py_None) { _arg0 = NULL; }
1737         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxZipFSHandler_p")) {
1738             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxZipFSHandler_OpenFile. Expected _wxZipFSHandler_p.");
1739         return NULL;
1740         }
1741     }
1742     if (_argo1) {
1743         if (_argo1 == Py_None) { _arg1 = NULL; }
1744         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxFileSystem_p")) {
1745             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxZipFSHandler_OpenFile. Expected _wxFileSystem_p.");
1746         return NULL;
1747         }
1748     }
1749 {
1750 #if PYTHON_API_VERSION >= 1009
1751     char* tmpPtr; int tmpSize;
1752     if (!PyString_Check(_obj2) && !PyUnicode_Check(_obj2)) {
1753         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1754         return NULL;
1755     }
1756     if (PyString_AsStringAndSize(_obj2, &tmpPtr, &tmpSize) == -1)
1757         return NULL;
1758     _arg2 = new wxString(tmpPtr, tmpSize);
1759 #else
1760     if (!PyString_Check(_obj2)) {
1761         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1762         return NULL;
1763     }
1764     _arg2 = new wxString(PyString_AS_STRING(_obj2), PyString_GET_SIZE(_obj2));
1765 #endif
1766 }
1767 {
1768     wxPy_BEGIN_ALLOW_THREADS;
1769         _result = (wxFSFile *)wxZipFSHandler_OpenFile(_arg0,*_arg1,*_arg2);
1770
1771     wxPy_END_ALLOW_THREADS;
1772 }    if (_result) {
1773         SWIG_MakePtr(_ptemp, (char *) _result,"_wxFSFile_p");
1774         _resultobj = Py_BuildValue("s",_ptemp);
1775     } else {
1776         Py_INCREF(Py_None);
1777         _resultobj = Py_None;
1778     }
1779 {
1780     if (_obj2)
1781         delete _arg2;
1782 }
1783     return _resultobj;
1784 }
1785
1786 #define wxZipFSHandler_FindFirst(_swigobj,_swigarg0,_swigarg1)  (_swigobj->FindFirst(_swigarg0,_swigarg1))
1787 static PyObject *_wrap_wxZipFSHandler_FindFirst(PyObject *self, PyObject *args, PyObject *kwargs) {
1788     PyObject * _resultobj;
1789     wxString * _result;
1790     wxZipFSHandler * _arg0;
1791     wxString * _arg1;
1792     int  _arg2 = (int ) 0;
1793     PyObject * _argo0 = 0;
1794     PyObject * _obj1 = 0;
1795     char *_kwnames[] = { "self","spec","flags", NULL };
1796
1797     self = self;
1798     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO|i:wxZipFSHandler_FindFirst",_kwnames,&_argo0,&_obj1,&_arg2))
1799         return NULL;
1800     if (_argo0) {
1801         if (_argo0 == Py_None) { _arg0 = NULL; }
1802         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxZipFSHandler_p")) {
1803             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxZipFSHandler_FindFirst. Expected _wxZipFSHandler_p.");
1804         return NULL;
1805         }
1806     }
1807 {
1808 #if PYTHON_API_VERSION >= 1009
1809     char* tmpPtr; int tmpSize;
1810     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
1811         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1812         return NULL;
1813     }
1814     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
1815         return NULL;
1816     _arg1 = new wxString(tmpPtr, tmpSize);
1817 #else
1818     if (!PyString_Check(_obj1)) {
1819         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1820         return NULL;
1821     }
1822     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
1823 #endif
1824 }
1825 {
1826     wxPy_BEGIN_ALLOW_THREADS;
1827         _result = new wxString (wxZipFSHandler_FindFirst(_arg0,*_arg1,_arg2));
1828
1829     wxPy_END_ALLOW_THREADS;
1830 }{
1831     _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
1832 }
1833 {
1834     if (_obj1)
1835         delete _arg1;
1836 }
1837 {
1838     delete _result;
1839 }
1840     return _resultobj;
1841 }
1842
1843 #define wxZipFSHandler_FindNext(_swigobj)  (_swigobj->FindNext())
1844 static PyObject *_wrap_wxZipFSHandler_FindNext(PyObject *self, PyObject *args, PyObject *kwargs) {
1845     PyObject * _resultobj;
1846     wxString * _result;
1847     wxZipFSHandler * _arg0;
1848     PyObject * _argo0 = 0;
1849     char *_kwnames[] = { "self", NULL };
1850
1851     self = self;
1852     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxZipFSHandler_FindNext",_kwnames,&_argo0))
1853         return NULL;
1854     if (_argo0) {
1855         if (_argo0 == Py_None) { _arg0 = NULL; }
1856         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxZipFSHandler_p")) {
1857             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxZipFSHandler_FindNext. Expected _wxZipFSHandler_p.");
1858         return NULL;
1859         }
1860     }
1861 {
1862     wxPy_BEGIN_ALLOW_THREADS;
1863         _result = new wxString (wxZipFSHandler_FindNext(_arg0));
1864
1865     wxPy_END_ALLOW_THREADS;
1866 }{
1867     _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
1868 }
1869 {
1870     delete _result;
1871 }
1872     return _resultobj;
1873 }
1874
1875 static void *SwigwxMemoryFSHandlerTowxFileSystemHandler(void *ptr) {
1876     wxMemoryFSHandler *src;
1877     wxFileSystemHandler *dest;
1878     src = (wxMemoryFSHandler *) ptr;
1879     dest = (wxFileSystemHandler *) src;
1880     return (void *) dest;
1881 }
1882
1883 #define new_wxMemoryFSHandler() (new wxMemoryFSHandler())
1884 static PyObject *_wrap_new_wxMemoryFSHandler(PyObject *self, PyObject *args, PyObject *kwargs) {
1885     PyObject * _resultobj;
1886     wxMemoryFSHandler * _result;
1887     char *_kwnames[] = {  NULL };
1888     char _ptemp[128];
1889
1890     self = self;
1891     if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxMemoryFSHandler",_kwnames))
1892         return NULL;
1893 {
1894     wxPy_BEGIN_ALLOW_THREADS;
1895         _result = (wxMemoryFSHandler *)new_wxMemoryFSHandler();
1896
1897     wxPy_END_ALLOW_THREADS;
1898 }    if (_result) {
1899         SWIG_MakePtr(_ptemp, (char *) _result,"_wxMemoryFSHandler_p");
1900         _resultobj = Py_BuildValue("s",_ptemp);
1901     } else {
1902         Py_INCREF(Py_None);
1903         _resultobj = Py_None;
1904     }
1905     return _resultobj;
1906 }
1907
1908 static PyObject *_wrap_wxMemoryFSHandler_RemoveFile(PyObject *self, PyObject *args, PyObject *kwargs) {
1909     PyObject * _resultobj;
1910     wxString * _arg0;
1911     PyObject * _obj0 = 0;
1912     char *_kwnames[] = { "filename", NULL };
1913
1914     self = self;
1915     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxMemoryFSHandler_RemoveFile",_kwnames,&_obj0))
1916         return NULL;
1917 {
1918 #if PYTHON_API_VERSION >= 1009
1919     char* tmpPtr; int tmpSize;
1920     if (!PyString_Check(_obj0) && !PyUnicode_Check(_obj0)) {
1921         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1922         return NULL;
1923     }
1924     if (PyString_AsStringAndSize(_obj0, &tmpPtr, &tmpSize) == -1)
1925         return NULL;
1926     _arg0 = new wxString(tmpPtr, tmpSize);
1927 #else
1928     if (!PyString_Check(_obj0)) {
1929         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1930         return NULL;
1931     }
1932     _arg0 = new wxString(PyString_AS_STRING(_obj0), PyString_GET_SIZE(_obj0));
1933 #endif
1934 }
1935 {
1936     wxPy_BEGIN_ALLOW_THREADS;
1937         wxMemoryFSHandler::RemoveFile(*_arg0);
1938
1939     wxPy_END_ALLOW_THREADS;
1940 }    Py_INCREF(Py_None);
1941     _resultobj = Py_None;
1942 {
1943     if (_obj0)
1944         delete _arg0;
1945 }
1946     return _resultobj;
1947 }
1948
1949 #define wxMemoryFSHandler_CanOpen(_swigobj,_swigarg0)  (_swigobj->CanOpen(_swigarg0))
1950 static PyObject *_wrap_wxMemoryFSHandler_CanOpen(PyObject *self, PyObject *args, PyObject *kwargs) {
1951     PyObject * _resultobj;
1952     bool  _result;
1953     wxMemoryFSHandler * _arg0;
1954     wxString * _arg1;
1955     PyObject * _argo0 = 0;
1956     PyObject * _obj1 = 0;
1957     char *_kwnames[] = { "self","location", NULL };
1958
1959     self = self;
1960     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxMemoryFSHandler_CanOpen",_kwnames,&_argo0,&_obj1))
1961         return NULL;
1962     if (_argo0) {
1963         if (_argo0 == Py_None) { _arg0 = NULL; }
1964         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxMemoryFSHandler_p")) {
1965             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMemoryFSHandler_CanOpen. Expected _wxMemoryFSHandler_p.");
1966         return NULL;
1967         }
1968     }
1969 {
1970 #if PYTHON_API_VERSION >= 1009
1971     char* tmpPtr; int tmpSize;
1972     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
1973         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1974         return NULL;
1975     }
1976     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
1977         return NULL;
1978     _arg1 = new wxString(tmpPtr, tmpSize);
1979 #else
1980     if (!PyString_Check(_obj1)) {
1981         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1982         return NULL;
1983     }
1984     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
1985 #endif
1986 }
1987 {
1988     wxPy_BEGIN_ALLOW_THREADS;
1989         _result = (bool )wxMemoryFSHandler_CanOpen(_arg0,*_arg1);
1990
1991     wxPy_END_ALLOW_THREADS;
1992 }    _resultobj = Py_BuildValue("i",_result);
1993 {
1994     if (_obj1)
1995         delete _arg1;
1996 }
1997     return _resultobj;
1998 }
1999
2000 #define wxMemoryFSHandler_OpenFile(_swigobj,_swigarg0,_swigarg1)  (_swigobj->OpenFile(_swigarg0,_swigarg1))
2001 static PyObject *_wrap_wxMemoryFSHandler_OpenFile(PyObject *self, PyObject *args, PyObject *kwargs) {
2002     PyObject * _resultobj;
2003     wxFSFile * _result;
2004     wxMemoryFSHandler * _arg0;
2005     wxFileSystem * _arg1;
2006     wxString * _arg2;
2007     PyObject * _argo0 = 0;
2008     PyObject * _argo1 = 0;
2009     PyObject * _obj2 = 0;
2010     char *_kwnames[] = { "self","fs","location", NULL };
2011     char _ptemp[128];
2012
2013     self = self;
2014     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO:wxMemoryFSHandler_OpenFile",_kwnames,&_argo0,&_argo1,&_obj2))
2015         return NULL;
2016     if (_argo0) {
2017         if (_argo0 == Py_None) { _arg0 = NULL; }
2018         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxMemoryFSHandler_p")) {
2019             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMemoryFSHandler_OpenFile. Expected _wxMemoryFSHandler_p.");
2020         return NULL;
2021         }
2022     }
2023     if (_argo1) {
2024         if (_argo1 == Py_None) { _arg1 = NULL; }
2025         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxFileSystem_p")) {
2026             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxMemoryFSHandler_OpenFile. Expected _wxFileSystem_p.");
2027         return NULL;
2028         }
2029     }
2030 {
2031 #if PYTHON_API_VERSION >= 1009
2032     char* tmpPtr; int tmpSize;
2033     if (!PyString_Check(_obj2) && !PyUnicode_Check(_obj2)) {
2034         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
2035         return NULL;
2036     }
2037     if (PyString_AsStringAndSize(_obj2, &tmpPtr, &tmpSize) == -1)
2038         return NULL;
2039     _arg2 = new wxString(tmpPtr, tmpSize);
2040 #else
2041     if (!PyString_Check(_obj2)) {
2042         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
2043         return NULL;
2044     }
2045     _arg2 = new wxString(PyString_AS_STRING(_obj2), PyString_GET_SIZE(_obj2));
2046 #endif
2047 }
2048 {
2049     wxPy_BEGIN_ALLOW_THREADS;
2050         _result = (wxFSFile *)wxMemoryFSHandler_OpenFile(_arg0,*_arg1,*_arg2);
2051
2052     wxPy_END_ALLOW_THREADS;
2053 }    if (_result) {
2054         SWIG_MakePtr(_ptemp, (char *) _result,"_wxFSFile_p");
2055         _resultobj = Py_BuildValue("s",_ptemp);
2056     } else {
2057         Py_INCREF(Py_None);
2058         _resultobj = Py_None;
2059     }
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     { "_wxDC","_class_wxDC",0},
2241     { "_class_wxBMPHandler","_wxBMPHandler",0},
2242     { "_size_t","_wxCoord",0},
2243     { "_size_t","_wxPrintQuality",0},
2244     { "_size_t","_time_t",0},
2245     { "_size_t","_unsigned_int",0},
2246     { "_size_t","_int",0},
2247     { "_size_t","_wxWindowID",0},
2248     { "_size_t","_uint",0},
2249     { "_class_wxRealPoint","_wxRealPoint",0},
2250     { "_wxPNMHandler","_class_wxPNMHandler",0},
2251     { "_class_wxGIFHandler","_wxGIFHandler",0},
2252     { "_wxFileConfig","_class_wxFileConfig",0},
2253     { "_class_wxMask","_wxMask",0},
2254     { "_class_wxPNGHandler","_wxPNGHandler",0},
2255     { "_wxColour","_class_wxColour",0},
2256     { "_wxBrush","_class_wxBrush",0},
2257     { "_uint","_wxCoord",0},
2258     { "_uint","_wxPrintQuality",0},
2259     { "_uint","_time_t",0},
2260     { "_uint","_size_t",0},
2261     { "_uint","_unsigned_int",0},
2262     { "_uint","_int",0},
2263     { "_uint","_wxWindowID",0},
2264     { "_wxChar","_char",0},
2265     { "_wxRect","_class_wxRect",0},
2266     { "_class_wxImage","_wxImage",0},
2267     { "_wxPoint","_class_wxPoint",0},
2268     { "_class_wxPNMHandler","_wxPNMHandler",0},
2269     { "_class_wxZipFSHandler","_wxZipFSHandler",0},
2270     { "_char","_wxChar",0},
2271     { "_wxBitmap","_class_wxBitmap",0},
2272     { "_wxPenList","_class_wxPenList",0},
2273     { "_wxWindowDC","_class_wxWindowDC",0},
2274     { "_class_wxInternetFSHandler","_wxInternetFSHandler",0},
2275     { "_class_wxIndividualLayoutConstraint","_wxIndividualLayoutConstraint",0},
2276     { "_wxConfig","_class_wxConfig",0},
2277     { "_class_wxFileConfig","_wxFileConfig",0},
2278     { "_class_wxColourDatabase","_wxColourDatabase",0},
2279     { "_class_wxMemoryFSHandler","_wxMemoryFSHandler",0},
2280     { "_EBool","_wxCoord",0},
2281     { "_EBool","_wxPrintQuality",0},
2282     { "_EBool","_signed_int",0},
2283     { "_EBool","_int",0},
2284     { "_EBool","_wxWindowID",0},
2285     { "_class_wxRegion","_wxRegion",0},
2286     { "_wxFont","_class_wxFont",0},
2287     { "_wxFSFile","_class_wxFSFile",0},
2288     { "_unsigned_long","_long",0},
2289     { "_class_wxRect","_wxRect",0},
2290     { "_class_wxDC","_wxDC",0},
2291     { "_class_wxBrushList","_wxBrushList",0},
2292     { "_wxPyInputStream","_class_wxPyInputStream",0},
2293     { "_wxTimeSpan","_class_wxTimeSpan",0},
2294     { "_class_wxPenList","_wxPenList",0},
2295     { "_class_wxOutputStream","_wxOutputStream",0},
2296     { "_wxAcceleratorEntry","_class_wxAcceleratorEntry",0},
2297     { "_signed_int","_wxCoord",0},
2298     { "_signed_int","_wxPrintQuality",0},
2299     { "_signed_int","_EBool",0},
2300     { "_signed_int","_wxWindowID",0},
2301     { "_signed_int","_int",0},
2302     { "_wxLayoutConstraints","_class_wxLayoutConstraints",0},
2303     { "_wxMetaFileDC","_class_wxMetaFileDC",0},
2304     { "_wxScreenDC","_class_wxScreenDC",0},
2305     { "_WXTYPE","_wxDateTime_t",0},
2306     { "_WXTYPE","_short",0},
2307     { "_WXTYPE","_signed_short",0},
2308     { "_WXTYPE","_unsigned_short",0},
2309     { "_class_wxBrush","_wxBrush",0},
2310     { "_unsigned_short","_wxDateTime_t",0},
2311     { "_unsigned_short","_WXTYPE",0},
2312     { "_unsigned_short","_short",0},
2313     { "_wxDateSpan","_class_wxDateSpan",0},
2314     { "_class_wxFont","_wxFont",0},
2315     { "_wxBusyInfo","_class_wxBusyInfo",0},
2316     { "_wxFontList","_class_wxFontList",0},
2317     { "_wxClientDC","_class_wxClientDC",0},
2318     { "_class_wxPoint","_wxPoint",0},
2319     { "_class_wxPyInputStream","_wxPyInputStream",0},
2320     { "_wxRealPoint","_class_wxRealPoint",0},
2321     { "_signed_short","_WXTYPE",0},
2322     { "_signed_short","_short",0},
2323     { "_wxMemoryDC","_class_wxMemoryDC",0},
2324     { "_wxPyFileSystemHandler","_class_wxPyFileSystemHandler",0},
2325     { "_wxPaintDC","_class_wxPaintDC",0},
2326     { "_class_wxWindowDC","_wxWindowDC",0},
2327     { "_class_wxAcceleratorEntry","_wxAcceleratorEntry",0},
2328     { "_class_wxCursor","_wxCursor",0},
2329     { "_class_wxImageHandler","_wxImageHandler",0},
2330     { "_unsigned_char","_byte",0},
2331     { "_class_wxMetaFileDC","_wxMetaFileDC",0},
2332     { "_unsigned_int","_wxCoord",0},
2333     { "_unsigned_int","_wxPrintQuality",0},
2334     { "_unsigned_int","_time_t",0},
2335     { "_unsigned_int","_size_t",0},
2336     { "_unsigned_int","_uint",0},
2337     { "_unsigned_int","_wxWindowID",0},
2338     { "_unsigned_int","_int",0},
2339     { "_wxIcon","_class_wxIcon",0},
2340     { "_wxConfigBase","_class_wxConfigBase",0},
2341     { "_class_wxPen","_wxPen",0},
2342     { "_short","_wxDateTime_t",0},
2343     { "_short","_WXTYPE",0},
2344     { "_short","_unsigned_short",0},
2345     { "_short","_signed_short",0},
2346     { "_class_wxImageList","_wxImageList",0},
2347     { "_wxFileSystemHandler","_class_wxMemoryFSHandler",SwigwxMemoryFSHandlerTowxFileSystemHandler},
2348     { "_wxFileSystemHandler","_wxMemoryFSHandler",SwigwxMemoryFSHandlerTowxFileSystemHandler},
2349     { "_wxFileSystemHandler","_class_wxZipFSHandler",SwigwxZipFSHandlerTowxFileSystemHandler},
2350     { "_wxFileSystemHandler","_wxZipFSHandler",SwigwxZipFSHandlerTowxFileSystemHandler},
2351     { "_wxFileSystemHandler","_class_wxInternetFSHandler",SwigwxInternetFSHandlerTowxFileSystemHandler},
2352     { "_wxFileSystemHandler","_wxInternetFSHandler",SwigwxInternetFSHandlerTowxFileSystemHandler},
2353     { "_wxFileSystemHandler","_class_wxPyFileSystemHandler",SwigwxPyFileSystemHandlerTowxFileSystemHandler},
2354     { "_wxFileSystemHandler","_wxPyFileSystemHandler",SwigwxPyFileSystemHandlerTowxFileSystemHandler},
2355     { "_wxFileSystemHandler","_class_wxFileSystemHandler",0},
2356     { "_wxPCXHandler","_class_wxPCXHandler",0},
2357     { "_wxJPEGHandler","_class_wxJPEGHandler",0},
2358     { "_wxWindowID","_wxCoord",0},
2359     { "_wxWindowID","_wxPrintQuality",0},
2360     { "_wxWindowID","_time_t",0},
2361     { "_wxWindowID","_size_t",0},
2362     { "_wxWindowID","_EBool",0},
2363     { "_wxWindowID","_uint",0},
2364     { "_wxWindowID","_int",0},
2365     { "_wxWindowID","_signed_int",0},
2366     { "_wxWindowID","_unsigned_int",0},
2367     { "_int","_wxCoord",0},
2368     { "_int","_wxPrintQuality",0},
2369     { "_int","_time_t",0},
2370     { "_int","_size_t",0},
2371     { "_int","_EBool",0},
2372     { "_int","_uint",0},
2373     { "_int","_wxWindowID",0},
2374     { "_int","_unsigned_int",0},
2375     { "_int","_signed_int",0},
2376     { "_wxDateTime_t","_unsigned_short",0},
2377     { "_wxDateTime_t","_short",0},
2378     { "_wxDateTime_t","_WXTYPE",0},
2379     { "_wxDateTime","_class_wxDateTime",0},
2380     { "_time_t","_wxCoord",0},
2381     { "_time_t","_wxPrintQuality",0},
2382     { "_time_t","_unsigned_int",0},
2383     { "_time_t","_int",0},
2384     { "_time_t","_wxWindowID",0},
2385     { "_time_t","_uint",0},
2386     { "_time_t","_size_t",0},
2387     { "_wxZipFSHandler","_class_wxZipFSHandler",0},
2388     { "_class_wxTimeSpan","_wxTimeSpan",0},
2389     { "_wxSize","_class_wxSize",0},
2390     { "_wxRegionIterator","_class_wxRegionIterator",0},
2391     { "_class_wxPyFileSystemHandler","_wxPyFileSystemHandler",0},
2392     { "_class_wxPaintDC","_wxPaintDC",0},
2393     { "_class_wxLayoutConstraints","_wxLayoutConstraints",0},
2394     { "_class_wxIcon","_wxIcon",0},
2395     { "_class_wxColour","_wxColour",0},
2396     { "_class_wxScreenDC","_wxScreenDC",0},
2397     { "_class_wxConfigBase","_wxConfigBase",0},
2398     { "_wxPalette","_class_wxPalette",0},
2399     { "_wxCoord","_int",0},
2400     { "_wxCoord","_signed_int",0},
2401     { "_wxCoord","_unsigned_int",0},
2402     { "_wxCoord","_wxWindowID",0},
2403     { "_wxCoord","_uint",0},
2404     { "_wxCoord","_EBool",0},
2405     { "_wxCoord","_size_t",0},
2406     { "_wxCoord","_time_t",0},
2407     { "_wxCoord","_wxPrintQuality",0},
2408     { "_wxMemoryFSHandler","_class_wxMemoryFSHandler",0},
2409     { "_class_wxDateSpan","_wxDateSpan",0},
2410     { "_wxRegion","_class_wxRegion",0},
2411     { "_wxFileSystem","_class_wxFileSystem",0},
2412     { "_class_wxPCXHandler","_wxPCXHandler",0},
2413     { "_wxTIFFHandler","_class_wxTIFFHandler",0},
2414     { "_class_wxBusyInfo","_wxBusyInfo",0},
2415     { "_class_wxFontList","_wxFontList",0},
2416     { "_class_wxClientDC","_wxClientDC",0},
2417     { "_wxBrushList","_class_wxBrushList",0},
2418     { "_class_wxSize","_wxSize",0},
2419     { "_class_wxBitmap","_wxBitmap",0},
2420     { "_class_wxMemoryDC","_wxMemoryDC",0},
2421     { "_wxOutputStream","_class_wxOutputStream",0},
2422     { "_class_wxConfig","_wxConfig",0},
2423     { "_class_wxPalette","_wxPalette",0},
2424     { "_class_wxFileSystemHandler","_class_wxMemoryFSHandler",SwigwxMemoryFSHandlerTowxFileSystemHandler},
2425     { "_class_wxFileSystemHandler","_wxMemoryFSHandler",SwigwxMemoryFSHandlerTowxFileSystemHandler},
2426     { "_class_wxFileSystemHandler","_class_wxZipFSHandler",SwigwxZipFSHandlerTowxFileSystemHandler},
2427     { "_class_wxFileSystemHandler","_wxZipFSHandler",SwigwxZipFSHandlerTowxFileSystemHandler},
2428     { "_class_wxFileSystemHandler","_class_wxInternetFSHandler",SwigwxInternetFSHandlerTowxFileSystemHandler},
2429     { "_class_wxFileSystemHandler","_wxInternetFSHandler",SwigwxInternetFSHandlerTowxFileSystemHandler},
2430     { "_class_wxFileSystemHandler","_class_wxPyFileSystemHandler",SwigwxPyFileSystemHandlerTowxFileSystemHandler},
2431     { "_class_wxFileSystemHandler","_wxPyFileSystemHandler",SwigwxPyFileSystemHandlerTowxFileSystemHandler},
2432     { "_class_wxFileSystemHandler","_wxFileSystemHandler",0},
2433     { "_class_wxFileSystem","_wxFileSystem",0},
2434 {0,0,0}};
2435
2436 static PyObject *SWIG_globals;
2437 #ifdef __cplusplus
2438 extern "C"
2439 #endif
2440 SWIGEXPORT(void) initfilesysc() {
2441          PyObject *m, *d;
2442          SWIG_globals = SWIG_newvarlink();
2443          m = Py_InitModule("filesysc", filesyscMethods);
2444          d = PyModule_GetDict(m);
2445 {
2446    int i;
2447    for (i = 0; _swig_mapping[i].n1; i++)
2448         SWIG_RegisterMapping(_swig_mapping[i].n1,_swig_mapping[i].n2,_swig_mapping[i].pcnv);
2449 }
2450 }