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