wxPython/src/gtk/filesys.cpp

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