wxPython/src/msw/filesys.cpp

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