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     wxPyInputStream * temp;
 333     bool  created;
 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 (SWIG_GetPtrObj(_obj0, (void **) &temp, "_wxPyInputStream_p") == 0) {
 347         _arg0 = temp->m_wxis;
 348         created = FALSE;
 349     } else {
 350         _arg0 = wxPyCBInputStream::create(_obj0, FALSE);
 351         if (_arg0 == NULL) {
 352             PyErr_SetString(PyExc_TypeError,"Expected _wxInputStream_p or Python file-like object.");
 353             return NULL;
 354         }
 355         created = TRUE;
 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, wxStringErrorMsg);
 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, wxStringErrorMsg);
 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, wxStringErrorMsg);
 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     PyThreadState* __tstate = wxPyBeginAllowThreads();
 421         _result = (wxFSFile *)new_wxFSFile(_arg0,*_arg1,*_arg2,*_arg3,*_arg4);
 422
 423     wxPyEndAllowThreads(__tstate);
 424     if (PyErr_Occurred()) return NULL;
 425 }    if (_result) {
 426         SWIG_MakePtr(_ptemp, (char *) _result,"_wxFSFile_p");
 427         _resultobj = Py_BuildValue("s",_ptemp);
 428     } else {
 429         Py_INCREF(Py_None);
 430         _resultobj = Py_None;
 431     }
 432 {
 433     if (created)
 434         delete _arg0;
 435 }
 436 {
 437     if (_obj1)
 438         delete _arg1;
 439 }
 440 {
 441     if (_obj2)
 442         delete _arg2;
 443 }
 444 {
 445     if (_obj3)
 446         delete _arg3;
 447 }
 448     return _resultobj;
 449 }
 450
 451 #define wxFSFile_GetStream(_swigobj)  (_swigobj->GetStream())
 452 static PyObject *_wrap_wxFSFile_GetStream(PyObject *self, PyObject *args, PyObject *kwargs) {
 453     PyObject * _resultobj;
 454     wxInputStream * _result;
 455     wxFSFile * _arg0;
 456     PyObject * _argo0 = 0;
 457     char *_kwnames[] = { "self", NULL };
 458
 459     self = self;
 460     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxFSFile_GetStream",_kwnames,&_argo0))
 461         return NULL;
 462     if (_argo0) {
 463         if (_argo0 == Py_None) { _arg0 = NULL; }
 464         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxFSFile_p")) {
 465             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxFSFile_GetStream. Expected _wxFSFile_p.");
 466         return NULL;
 467         }
 468     }
 469 {
 470     PyThreadState* __tstate = wxPyBeginAllowThreads();
 471         _result = (wxInputStream *)wxFSFile_GetStream(_arg0);
 472
 473     wxPyEndAllowThreads(__tstate);
 474     if (PyErr_Occurred()) return NULL;
 475 }{
 476     wxPyInputStream * _ptr = NULL;
 477
 478     if (_result) {
 479         _ptr = new wxPyInputStream(_result);
 480     }
 481     _resultobj = wxPyConstructObject(_ptr, "wxInputStream", TRUE);
 482 }
 483     return _resultobj;
 484 }
 485
 486 #define wxFSFile_GetMimeType(_swigobj)  (_swigobj->GetMimeType())
 487 static PyObject *_wrap_wxFSFile_GetMimeType(PyObject *self, PyObject *args, PyObject *kwargs) {
 488     PyObject * _resultobj;
 489     wxString * _result;
 490     wxFSFile * _arg0;
 491     PyObject * _argo0 = 0;
 492     char *_kwnames[] = { "self", NULL };
 493
 494     self = self;
 495     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxFSFile_GetMimeType",_kwnames,&_argo0))
 496         return NULL;
 497     if (_argo0) {
 498         if (_argo0 == Py_None) { _arg0 = NULL; }
 499         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxFSFile_p")) {
 500             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxFSFile_GetMimeType. Expected _wxFSFile_p.");
 501         return NULL;
 502         }
 503     }
 504 {
 505     PyThreadState* __tstate = wxPyBeginAllowThreads();
 506         const wxString & _result_ref = wxFSFile_GetMimeType(_arg0);
 507     _result = (wxString *) &_result_ref;
 508
 509     wxPyEndAllowThreads(__tstate);
 510     if (PyErr_Occurred()) return NULL;
 511 }{
 512     _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
 513 }
 514     return _resultobj;
 515 }
 516
 517 #define wxFSFile_GetLocation(_swigobj)  (_swigobj->GetLocation())
 518 static PyObject *_wrap_wxFSFile_GetLocation(PyObject *self, PyObject *args, PyObject *kwargs) {
 519     PyObject * _resultobj;
 520     wxString * _result;
 521     wxFSFile * _arg0;
 522     PyObject * _argo0 = 0;
 523     char *_kwnames[] = { "self", NULL };
 524
 525     self = self;
 526     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxFSFile_GetLocation",_kwnames,&_argo0))
 527         return NULL;
 528     if (_argo0) {
 529         if (_argo0 == Py_None) { _arg0 = NULL; }
 530         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxFSFile_p")) {
 531             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxFSFile_GetLocation. Expected _wxFSFile_p.");
 532         return NULL;
 533         }
 534     }
 535 {
 536     PyThreadState* __tstate = wxPyBeginAllowThreads();
 537         const wxString & _result_ref = wxFSFile_GetLocation(_arg0);
 538     _result = (wxString *) &_result_ref;
 539
 540     wxPyEndAllowThreads(__tstate);
 541     if (PyErr_Occurred()) return NULL;
 542 }{
 543     _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
 544 }
 545     return _resultobj;
 546 }
 547
 548 #define wxFSFile_GetAnchor(_swigobj)  (_swigobj->GetAnchor())
 549 static PyObject *_wrap_wxFSFile_GetAnchor(PyObject *self, PyObject *args, PyObject *kwargs) {
 550     PyObject * _resultobj;
 551     wxString * _result;
 552     wxFSFile * _arg0;
 553     PyObject * _argo0 = 0;
 554     char *_kwnames[] = { "self", NULL };
 555
 556     self = self;
 557     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxFSFile_GetAnchor",_kwnames,&_argo0))
 558         return NULL;
 559     if (_argo0) {
 560         if (_argo0 == Py_None) { _arg0 = NULL; }
 561         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxFSFile_p")) {
 562             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxFSFile_GetAnchor. Expected _wxFSFile_p.");
 563         return NULL;
 564         }
 565     }
 566 {
 567     PyThreadState* __tstate = wxPyBeginAllowThreads();
 568         const wxString & _result_ref = wxFSFile_GetAnchor(_arg0);
 569     _result = (wxString *) &_result_ref;
 570
 571     wxPyEndAllowThreads(__tstate);
 572     if (PyErr_Occurred()) return NULL;
 573 }{
 574     _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
 575 }
 576     return _resultobj;
 577 }
 578
 579 #define wxFSFile_GetModificationTime(_swigobj)  (_swigobj->GetModificationTime())
 580 static PyObject *_wrap_wxFSFile_GetModificationTime(PyObject *self, PyObject *args, PyObject *kwargs) {
 581     PyObject * _resultobj;
 582     wxDateTime * _result;
 583     wxFSFile * _arg0;
 584     PyObject * _argo0 = 0;
 585     char *_kwnames[] = { "self", NULL };
 586     char _ptemp[128];
 587
 588     self = self;
 589     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxFSFile_GetModificationTime",_kwnames,&_argo0))
 590         return NULL;
 591     if (_argo0) {
 592         if (_argo0 == Py_None) { _arg0 = NULL; }
 593         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxFSFile_p")) {
 594             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxFSFile_GetModificationTime. Expected _wxFSFile_p.");
 595         return NULL;
 596         }
 597     }
 598 {
 599     PyThreadState* __tstate = wxPyBeginAllowThreads();
 600         _result = new wxDateTime (wxFSFile_GetModificationTime(_arg0));
 601
 602     wxPyEndAllowThreads(__tstate);
 603     if (PyErr_Occurred()) return NULL;
 604 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxDateTime_p");
 605     _resultobj = Py_BuildValue("s",_ptemp);
 606     return _resultobj;
 607 }
 608
 609 static void *SwigwxFileSystemHandlerTowxObject(void *ptr) {
 610     wxFileSystemHandler *src;
 611     wxObject *dest;
 612     src = (wxFileSystemHandler *) ptr;
 613     dest = (wxObject *) src;
 614     return (void *) dest;
 615 }
 616
 617 static void *SwigwxPyFileSystemHandlerTowxFileSystemHandler(void *ptr) {
 618     wxPyFileSystemHandler *src;
 619     wxFileSystemHandler *dest;
 620     src = (wxPyFileSystemHandler *) ptr;
 621     dest = (wxFileSystemHandler *) src;
 622     return (void *) dest;
 623 }
 624
 625 static void *SwigwxPyFileSystemHandlerTowxObject(void *ptr) {
 626     wxPyFileSystemHandler *src;
 627     wxObject *dest;
 628     src = (wxPyFileSystemHandler *) ptr;
 629     dest = (wxObject *) src;
 630     return (void *) dest;
 631 }
 632
 633 #define new_wxFileSystemHandler() (new wxPyFileSystemHandler())
 634 static PyObject *_wrap_new_wxFileSystemHandler(PyObject *self, PyObject *args, PyObject *kwargs) {
 635     PyObject * _resultobj;
 636     wxPyFileSystemHandler * _result;
 637     char *_kwnames[] = {  NULL };
 638     char _ptemp[128];
 639
 640     self = self;
 641     if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxFileSystemHandler",_kwnames))
 642         return NULL;
 643 {
 644     PyThreadState* __tstate = wxPyBeginAllowThreads();
 645         _result = (wxPyFileSystemHandler *)new_wxFileSystemHandler();
 646
 647     wxPyEndAllowThreads(__tstate);
 648     if (PyErr_Occurred()) return NULL;
 649 }    if (_result) {
 650         SWIG_MakePtr(_ptemp, (char *) _result,"_wxPyFileSystemHandler_p");
 651         _resultobj = Py_BuildValue("s",_ptemp);
 652     } else {
 653         Py_INCREF(Py_None);
 654         _resultobj = Py_None;
 655     }
 656     return _resultobj;
 657 }
 658
 659 #define wxFileSystemHandler__setCallbackInfo(_swigobj,_swigarg0,_swigarg1)  (_swigobj->_setCallbackInfo(_swigarg0,_swigarg1))
 660 static PyObject *_wrap_wxFileSystemHandler__setCallbackInfo(PyObject *self, PyObject *args, PyObject *kwargs) {
 661     PyObject * _resultobj;
 662     wxPyFileSystemHandler * _arg0;
 663     PyObject * _arg1;
 664     PyObject * _arg2;
 665     PyObject * _argo0 = 0;
 666     PyObject * _obj1 = 0;
 667     PyObject * _obj2 = 0;
 668     char *_kwnames[] = { "self","self","_class", NULL };
 669
 670     self = self;
 671     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO:wxFileSystemHandler__setCallbackInfo",_kwnames,&_argo0,&_obj1,&_obj2))
 672         return NULL;
 673     if (_argo0) {
 674         if (_argo0 == Py_None) { _arg0 = NULL; }
 675         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyFileSystemHandler_p")) {
 676             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxFileSystemHandler__setCallbackInfo. Expected _wxPyFileSystemHandler_p.");
 677         return NULL;
 678         }
 679     }
 680 {
 681   _arg1 = _obj1;
 682 }
 683 {
 684   _arg2 = _obj2;
 685 }
 686 {
 687     PyThreadState* __tstate = wxPyBeginAllowThreads();
 688         wxFileSystemHandler__setCallbackInfo(_arg0,_arg1,_arg2);
 689
 690     wxPyEndAllowThreads(__tstate);
 691     if (PyErr_Occurred()) return NULL;
 692 }    Py_INCREF(Py_None);
 693     _resultobj = Py_None;
 694     return _resultobj;
 695 }
 696
 697 #define wxFileSystemHandler_CanOpen(_swigobj,_swigarg0)  (_swigobj->CanOpen(_swigarg0))
 698 static PyObject *_wrap_wxFileSystemHandler_CanOpen(PyObject *self, PyObject *args, PyObject *kwargs) {
 699     PyObject * _resultobj;
 700     bool  _result;
 701     wxPyFileSystemHandler * _arg0;
 702     wxString * _arg1;
 703     PyObject * _argo0 = 0;
 704     PyObject * _obj1 = 0;
 705     char *_kwnames[] = { "self","location", NULL };
 706
 707     self = self;
 708     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxFileSystemHandler_CanOpen",_kwnames,&_argo0,&_obj1))
 709         return NULL;
 710     if (_argo0) {
 711         if (_argo0 == Py_None) { _arg0 = NULL; }
 712         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyFileSystemHandler_p")) {
 713             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxFileSystemHandler_CanOpen. Expected _wxPyFileSystemHandler_p.");
 714         return NULL;
 715         }
 716     }
 717 {
 718 #if PYTHON_API_VERSION >= 1009
 719     char* tmpPtr; int tmpSize;
 720     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
 721         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
 722         return NULL;
 723     }
 724     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
 725         return NULL;
 726     _arg1 = new wxString(tmpPtr, tmpSize);
 727 #else
 728     if (!PyString_Check(_obj1)) {
 729         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
 730         return NULL;
 731     }
 732     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
 733 #endif
 734 }
 735 {
 736     PyThreadState* __tstate = wxPyBeginAllowThreads();
 737         _result = (bool )wxFileSystemHandler_CanOpen(_arg0,*_arg1);
 738
 739     wxPyEndAllowThreads(__tstate);
 740     if (PyErr_Occurred()) return NULL;
 741 }    _resultobj = Py_BuildValue("i",_result);
 742 {
 743     if (_obj1)
 744         delete _arg1;
 745 }
 746     return _resultobj;
 747 }
 748
 749 #define wxFileSystemHandler_OpenFile(_swigobj,_swigarg0,_swigarg1)  (_swigobj->OpenFile(_swigarg0,_swigarg1))
 750 static PyObject *_wrap_wxFileSystemHandler_OpenFile(PyObject *self, PyObject *args, PyObject *kwargs) {
 751     PyObject * _resultobj;
 752     wxFSFile * _result;
 753     wxPyFileSystemHandler * _arg0;
 754     wxFileSystem * _arg1;
 755     wxString * _arg2;
 756     PyObject * _argo0 = 0;
 757     PyObject * _argo1 = 0;
 758     PyObject * _obj2 = 0;
 759     char *_kwnames[] = { "self","fs","location", NULL };
 760
 761     self = self;
 762     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO:wxFileSystemHandler_OpenFile",_kwnames,&_argo0,&_argo1,&_obj2))
 763         return NULL;
 764     if (_argo0) {
 765         if (_argo0 == Py_None) { _arg0 = NULL; }
 766         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyFileSystemHandler_p")) {
 767             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxFileSystemHandler_OpenFile. Expected _wxPyFileSystemHandler_p.");
 768         return NULL;
 769         }
 770     }
 771     if (_argo1) {
 772         if (_argo1 == Py_None) { _arg1 = NULL; }
 773         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxFileSystem_p")) {
 774             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxFileSystemHandler_OpenFile. Expected _wxFileSystem_p.");
 775         return NULL;
 776         }
 777     }
 778 {
 779 #if PYTHON_API_VERSION >= 1009
 780     char* tmpPtr; int tmpSize;
 781     if (!PyString_Check(_obj2) && !PyUnicode_Check(_obj2)) {
 782         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
 783         return NULL;
 784     }
 785     if (PyString_AsStringAndSize(_obj2, &tmpPtr, &tmpSize) == -1)
 786         return NULL;
 787     _arg2 = new wxString(tmpPtr, tmpSize);
 788 #else
 789     if (!PyString_Check(_obj2)) {
 790         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
 791         return NULL;
 792     }
 793     _arg2 = new wxString(PyString_AS_STRING(_obj2), PyString_GET_SIZE(_obj2));
 794 #endif
 795 }
 796 {
 797     PyThreadState* __tstate = wxPyBeginAllowThreads();
 798         _result = (wxFSFile *)wxFileSystemHandler_OpenFile(_arg0,*_arg1,*_arg2);
 799
 800     wxPyEndAllowThreads(__tstate);
 801     if (PyErr_Occurred()) return NULL;
 802 }{ _resultobj = wxPyMake_wxObject(_result); }
 803 {
 804     if (_obj2)
 805         delete _arg2;
 806 }
 807     return _resultobj;
 808 }
 809
 810 #define wxFileSystemHandler_FindFirst(_swigobj,_swigarg0,_swigarg1)  (_swigobj->FindFirst(_swigarg0,_swigarg1))
 811 static PyObject *_wrap_wxFileSystemHandler_FindFirst(PyObject *self, PyObject *args, PyObject *kwargs) {
 812     PyObject * _resultobj;
 813     wxString * _result;
 814     wxPyFileSystemHandler * _arg0;
 815     wxString * _arg1;
 816     int  _arg2 = (int ) 0;
 817     PyObject * _argo0 = 0;
 818     PyObject * _obj1 = 0;
 819     char *_kwnames[] = { "self","spec","flags", NULL };
 820
 821     self = self;
 822     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO|i:wxFileSystemHandler_FindFirst",_kwnames,&_argo0,&_obj1,&_arg2))
 823         return NULL;
 824     if (_argo0) {
 825         if (_argo0 == Py_None) { _arg0 = NULL; }
 826         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyFileSystemHandler_p")) {
 827             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxFileSystemHandler_FindFirst. Expected _wxPyFileSystemHandler_p.");
 828         return NULL;
 829         }
 830     }
 831 {
 832 #if PYTHON_API_VERSION >= 1009
 833     char* tmpPtr; int tmpSize;
 834     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
 835         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
 836         return NULL;
 837     }
 838     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
 839         return NULL;
 840     _arg1 = new wxString(tmpPtr, tmpSize);
 841 #else
 842     if (!PyString_Check(_obj1)) {
 843         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
 844         return NULL;
 845     }
 846     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
 847 #endif
 848 }
 849 {
 850     PyThreadState* __tstate = wxPyBeginAllowThreads();
 851         _result = new wxString (wxFileSystemHandler_FindFirst(_arg0,*_arg1,_arg2));
 852
 853     wxPyEndAllowThreads(__tstate);
 854     if (PyErr_Occurred()) return NULL;
 855 }{
 856     _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
 857 }
 858 {
 859     if (_obj1)
 860         delete _arg1;
 861 }
 862 {
 863     delete _result;
 864 }
 865     return _resultobj;
 866 }
 867
 868 #define wxFileSystemHandler_FindNext(_swigobj)  (_swigobj->FindNext())
 869 static PyObject *_wrap_wxFileSystemHandler_FindNext(PyObject *self, PyObject *args, PyObject *kwargs) {
 870     PyObject * _resultobj;
 871     wxString * _result;
 872     wxPyFileSystemHandler * _arg0;
 873     PyObject * _argo0 = 0;
 874     char *_kwnames[] = { "self", NULL };
 875
 876     self = self;
 877     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxFileSystemHandler_FindNext",_kwnames,&_argo0))
 878         return NULL;
 879     if (_argo0) {
 880         if (_argo0 == Py_None) { _arg0 = NULL; }
 881         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyFileSystemHandler_p")) {
 882             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxFileSystemHandler_FindNext. Expected _wxPyFileSystemHandler_p.");
 883         return NULL;
 884         }
 885     }
 886 {
 887     PyThreadState* __tstate = wxPyBeginAllowThreads();
 888         _result = new wxString (wxFileSystemHandler_FindNext(_arg0));
 889
 890     wxPyEndAllowThreads(__tstate);
 891     if (PyErr_Occurred()) return NULL;
 892 }{
 893     _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
 894 }
 895 {
 896     delete _result;
 897 }
 898     return _resultobj;
 899 }
 900
 901 #define wxFileSystemHandler_GetProtocol(_swigobj,_swigarg0)  (_swigobj->GetProtocol(_swigarg0))
 902 static PyObject *_wrap_wxFileSystemHandler_GetProtocol(PyObject *self, PyObject *args, PyObject *kwargs) {
 903     PyObject * _resultobj;
 904     wxString * _result;
 905     wxPyFileSystemHandler * _arg0;
 906     wxString * _arg1;
 907     PyObject * _argo0 = 0;
 908     PyObject * _obj1 = 0;
 909     char *_kwnames[] = { "self","location", NULL };
 910
 911     self = self;
 912     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxFileSystemHandler_GetProtocol",_kwnames,&_argo0,&_obj1))
 913         return NULL;
 914     if (_argo0) {
 915         if (_argo0 == Py_None) { _arg0 = NULL; }
 916         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyFileSystemHandler_p")) {
 917             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxFileSystemHandler_GetProtocol. Expected _wxPyFileSystemHandler_p.");
 918         return NULL;
 919         }
 920     }
 921 {
 922 #if PYTHON_API_VERSION >= 1009
 923     char* tmpPtr; int tmpSize;
 924     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
 925         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
 926         return NULL;
 927     }
 928     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
 929         return NULL;
 930     _arg1 = new wxString(tmpPtr, tmpSize);
 931 #else
 932     if (!PyString_Check(_obj1)) {
 933         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
 934         return NULL;
 935     }
 936     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
 937 #endif
 938 }
 939 {
 940     PyThreadState* __tstate = wxPyBeginAllowThreads();
 941         _result = new wxString (wxFileSystemHandler_GetProtocol(_arg0,*_arg1));
 942
 943     wxPyEndAllowThreads(__tstate);
 944     if (PyErr_Occurred()) return NULL;
 945 }{
 946     _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
 947 }
 948 {
 949     if (_obj1)
 950         delete _arg1;
 951 }
 952 {
 953     delete _result;
 954 }
 955     return _resultobj;
 956 }
 957
 958 #define wxFileSystemHandler_GetLeftLocation(_swigobj,_swigarg0)  (_swigobj->GetLeftLocation(_swigarg0))
 959 static PyObject *_wrap_wxFileSystemHandler_GetLeftLocation(PyObject *self, PyObject *args, PyObject *kwargs) {
 960     PyObject * _resultobj;
 961     wxString * _result;
 962     wxPyFileSystemHandler * _arg0;
 963     wxString * _arg1;
 964     PyObject * _argo0 = 0;
 965     PyObject * _obj1 = 0;
 966     char *_kwnames[] = { "self","location", NULL };
 967
 968     self = self;
 969     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxFileSystemHandler_GetLeftLocation",_kwnames,&_argo0,&_obj1))
 970         return NULL;
 971     if (_argo0) {
 972         if (_argo0 == Py_None) { _arg0 = NULL; }
 973         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyFileSystemHandler_p")) {
 974             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxFileSystemHandler_GetLeftLocation. Expected _wxPyFileSystemHandler_p.");
 975         return NULL;
 976         }
 977     }
 978 {
 979 #if PYTHON_API_VERSION >= 1009
 980     char* tmpPtr; int tmpSize;
 981     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
 982         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
 983         return NULL;
 984     }
 985     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
 986         return NULL;
 987     _arg1 = new wxString(tmpPtr, tmpSize);
 988 #else
 989     if (!PyString_Check(_obj1)) {
 990         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
 991         return NULL;
 992     }
 993     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
 994 #endif
 995 }
 996 {
 997     PyThreadState* __tstate = wxPyBeginAllowThreads();
 998         _result = new wxString (wxFileSystemHandler_GetLeftLocation(_arg0,*_arg1));
 999
1000     wxPyEndAllowThreads(__tstate);
1001     if (PyErr_Occurred()) return NULL;
1002 }{
1003     _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
1004 }
1005 {
1006     if (_obj1)
1007         delete _arg1;
1008 }
1009 {
1010     delete _result;
1011 }
1012     return _resultobj;
1013 }
1014
1015 #define wxFileSystemHandler_GetAnchor(_swigobj,_swigarg0)  (_swigobj->GetAnchor(_swigarg0))
1016 static PyObject *_wrap_wxFileSystemHandler_GetAnchor(PyObject *self, PyObject *args, PyObject *kwargs) {
1017     PyObject * _resultobj;
1018     wxString * _result;
1019     wxPyFileSystemHandler * _arg0;
1020     wxString * _arg1;
1021     PyObject * _argo0 = 0;
1022     PyObject * _obj1 = 0;
1023     char *_kwnames[] = { "self","location", NULL };
1024
1025     self = self;
1026     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxFileSystemHandler_GetAnchor",_kwnames,&_argo0,&_obj1))
1027         return NULL;
1028     if (_argo0) {
1029         if (_argo0 == Py_None) { _arg0 = NULL; }
1030         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyFileSystemHandler_p")) {
1031             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxFileSystemHandler_GetAnchor. Expected _wxPyFileSystemHandler_p.");
1032         return NULL;
1033         }
1034     }
1035 {
1036 #if PYTHON_API_VERSION >= 1009
1037     char* tmpPtr; int tmpSize;
1038     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
1039         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1040         return NULL;
1041     }
1042     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
1043         return NULL;
1044     _arg1 = new wxString(tmpPtr, tmpSize);
1045 #else
1046     if (!PyString_Check(_obj1)) {
1047         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1048         return NULL;
1049     }
1050     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
1051 #endif
1052 }
1053 {
1054     PyThreadState* __tstate = wxPyBeginAllowThreads();
1055         _result = new wxString (wxFileSystemHandler_GetAnchor(_arg0,*_arg1));
1056
1057     wxPyEndAllowThreads(__tstate);
1058     if (PyErr_Occurred()) return NULL;
1059 }{
1060     _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
1061 }
1062 {
1063     if (_obj1)
1064         delete _arg1;
1065 }
1066 {
1067     delete _result;
1068 }
1069     return _resultobj;
1070 }
1071
1072 #define wxFileSystemHandler_GetRightLocation(_swigobj,_swigarg0)  (_swigobj->GetRightLocation(_swigarg0))
1073 static PyObject *_wrap_wxFileSystemHandler_GetRightLocation(PyObject *self, PyObject *args, PyObject *kwargs) {
1074     PyObject * _resultobj;
1075     wxString * _result;
1076     wxPyFileSystemHandler * _arg0;
1077     wxString * _arg1;
1078     PyObject * _argo0 = 0;
1079     PyObject * _obj1 = 0;
1080     char *_kwnames[] = { "self","location", NULL };
1081
1082     self = self;
1083     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxFileSystemHandler_GetRightLocation",_kwnames,&_argo0,&_obj1))
1084         return NULL;
1085     if (_argo0) {
1086         if (_argo0 == Py_None) { _arg0 = NULL; }
1087         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyFileSystemHandler_p")) {
1088             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxFileSystemHandler_GetRightLocation. Expected _wxPyFileSystemHandler_p.");
1089         return NULL;
1090         }
1091     }
1092 {
1093 #if PYTHON_API_VERSION >= 1009
1094     char* tmpPtr; int tmpSize;
1095     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
1096         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1097         return NULL;
1098     }
1099     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
1100         return NULL;
1101     _arg1 = new wxString(tmpPtr, tmpSize);
1102 #else
1103     if (!PyString_Check(_obj1)) {
1104         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1105         return NULL;
1106     }
1107     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
1108 #endif
1109 }
1110 {
1111     PyThreadState* __tstate = wxPyBeginAllowThreads();
1112         _result = new wxString (wxFileSystemHandler_GetRightLocation(_arg0,*_arg1));
1113
1114     wxPyEndAllowThreads(__tstate);
1115     if (PyErr_Occurred()) return NULL;
1116 }{
1117     _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
1118 }
1119 {
1120     if (_obj1)
1121         delete _arg1;
1122 }
1123 {
1124     delete _result;
1125 }
1126     return _resultobj;
1127 }
1128
1129 #define wxFileSystemHandler_GetMimeTypeFromExt(_swigobj,_swigarg0)  (_swigobj->GetMimeTypeFromExt(_swigarg0))
1130 static PyObject *_wrap_wxFileSystemHandler_GetMimeTypeFromExt(PyObject *self, PyObject *args, PyObject *kwargs) {
1131     PyObject * _resultobj;
1132     wxString * _result;
1133     wxPyFileSystemHandler * _arg0;
1134     wxString * _arg1;
1135     PyObject * _argo0 = 0;
1136     PyObject * _obj1 = 0;
1137     char *_kwnames[] = { "self","location", NULL };
1138
1139     self = self;
1140     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxFileSystemHandler_GetMimeTypeFromExt",_kwnames,&_argo0,&_obj1))
1141         return NULL;
1142     if (_argo0) {
1143         if (_argo0 == Py_None) { _arg0 = NULL; }
1144         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyFileSystemHandler_p")) {
1145             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxFileSystemHandler_GetMimeTypeFromExt. Expected _wxPyFileSystemHandler_p.");
1146         return NULL;
1147         }
1148     }
1149 {
1150 #if PYTHON_API_VERSION >= 1009
1151     char* tmpPtr; int tmpSize;
1152     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
1153         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1154         return NULL;
1155     }
1156     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
1157         return NULL;
1158     _arg1 = new wxString(tmpPtr, tmpSize);
1159 #else
1160     if (!PyString_Check(_obj1)) {
1161         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1162         return NULL;
1163     }
1164     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
1165 #endif
1166 }
1167 {
1168     PyThreadState* __tstate = wxPyBeginAllowThreads();
1169         _result = new wxString (wxFileSystemHandler_GetMimeTypeFromExt(_arg0,*_arg1));
1170
1171     wxPyEndAllowThreads(__tstate);
1172     if (PyErr_Occurred()) return NULL;
1173 }{
1174     _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
1175 }
1176 {
1177     if (_obj1)
1178         delete _arg1;
1179 }
1180 {
1181     delete _result;
1182 }
1183     return _resultobj;
1184 }
1185
1186 static void *SwigwxFileSystemTowxObject(void *ptr) {
1187     wxFileSystem *src;
1188     wxObject *dest;
1189     src = (wxFileSystem *) ptr;
1190     dest = (wxObject *) src;
1191     return (void *) dest;
1192 }
1193
1194 #define new_wxFileSystem() (new wxFileSystem())
1195 static PyObject *_wrap_new_wxFileSystem(PyObject *self, PyObject *args, PyObject *kwargs) {
1196     PyObject * _resultobj;
1197     wxFileSystem * _result;
1198     char *_kwnames[] = {  NULL };
1199     char _ptemp[128];
1200
1201     self = self;
1202     if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxFileSystem",_kwnames))
1203         return NULL;
1204 {
1205     PyThreadState* __tstate = wxPyBeginAllowThreads();
1206         _result = (wxFileSystem *)new_wxFileSystem();
1207
1208     wxPyEndAllowThreads(__tstate);
1209     if (PyErr_Occurred()) return NULL;
1210 }    if (_result) {
1211         SWIG_MakePtr(_ptemp, (char *) _result,"_wxFileSystem_p");
1212         _resultobj = Py_BuildValue("s",_ptemp);
1213     } else {
1214         Py_INCREF(Py_None);
1215         _resultobj = Py_None;
1216     }
1217     return _resultobj;
1218 }
1219
1220 #define wxFileSystem_ChangePathTo(_swigobj,_swigarg0,_swigarg1)  (_swigobj->ChangePathTo(_swigarg0,_swigarg1))
1221 static PyObject *_wrap_wxFileSystem_ChangePathTo(PyObject *self, PyObject *args, PyObject *kwargs) {
1222     PyObject * _resultobj;
1223     wxFileSystem * _arg0;
1224     wxString * _arg1;
1225     bool  _arg2 = (bool ) FALSE;
1226     PyObject * _argo0 = 0;
1227     PyObject * _obj1 = 0;
1228     int tempbool2 = (int) FALSE;
1229     char *_kwnames[] = { "self","location","is_dir", NULL };
1230
1231     self = self;
1232     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO|i:wxFileSystem_ChangePathTo",_kwnames,&_argo0,&_obj1,&tempbool2))
1233         return NULL;
1234     if (_argo0) {
1235         if (_argo0 == Py_None) { _arg0 = NULL; }
1236         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxFileSystem_p")) {
1237             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxFileSystem_ChangePathTo. Expected _wxFileSystem_p.");
1238         return NULL;
1239         }
1240     }
1241 {
1242 #if PYTHON_API_VERSION >= 1009
1243     char* tmpPtr; int tmpSize;
1244     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
1245         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1246         return NULL;
1247     }
1248     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
1249         return NULL;
1250     _arg1 = new wxString(tmpPtr, tmpSize);
1251 #else
1252     if (!PyString_Check(_obj1)) {
1253         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1254         return NULL;
1255     }
1256     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
1257 #endif
1258 }
1259     _arg2 = (bool ) tempbool2;
1260 {
1261     PyThreadState* __tstate = wxPyBeginAllowThreads();
1262         wxFileSystem_ChangePathTo(_arg0,*_arg1,_arg2);
1263
1264     wxPyEndAllowThreads(__tstate);
1265     if (PyErr_Occurred()) return NULL;
1266 }    Py_INCREF(Py_None);
1267     _resultobj = Py_None;
1268 {
1269     if (_obj1)
1270         delete _arg1;
1271 }
1272     return _resultobj;
1273 }
1274
1275 #define wxFileSystem_GetPath(_swigobj)  (_swigobj->GetPath())
1276 static PyObject *_wrap_wxFileSystem_GetPath(PyObject *self, PyObject *args, PyObject *kwargs) {
1277     PyObject * _resultobj;
1278     wxString * _result;
1279     wxFileSystem * _arg0;
1280     PyObject * _argo0 = 0;
1281     char *_kwnames[] = { "self", NULL };
1282
1283     self = self;
1284     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxFileSystem_GetPath",_kwnames,&_argo0))
1285         return NULL;
1286     if (_argo0) {
1287         if (_argo0 == Py_None) { _arg0 = NULL; }
1288         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxFileSystem_p")) {
1289             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxFileSystem_GetPath. Expected _wxFileSystem_p.");
1290         return NULL;
1291         }
1292     }
1293 {
1294     PyThreadState* __tstate = wxPyBeginAllowThreads();
1295         _result = new wxString (wxFileSystem_GetPath(_arg0));
1296
1297     wxPyEndAllowThreads(__tstate);
1298     if (PyErr_Occurred()) return NULL;
1299 }{
1300     _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
1301 }
1302 {
1303     delete _result;
1304 }
1305     return _resultobj;
1306 }
1307
1308 #define wxFileSystem_OpenFile(_swigobj,_swigarg0)  (_swigobj->OpenFile(_swigarg0))
1309 static PyObject *_wrap_wxFileSystem_OpenFile(PyObject *self, PyObject *args, PyObject *kwargs) {
1310     PyObject * _resultobj;
1311     wxFSFile * _result;
1312     wxFileSystem * _arg0;
1313     wxString * _arg1;
1314     PyObject * _argo0 = 0;
1315     PyObject * _obj1 = 0;
1316     char *_kwnames[] = { "self","location", NULL };
1317
1318     self = self;
1319     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxFileSystem_OpenFile",_kwnames,&_argo0,&_obj1))
1320         return NULL;
1321     if (_argo0) {
1322         if (_argo0 == Py_None) { _arg0 = NULL; }
1323         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxFileSystem_p")) {
1324             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxFileSystem_OpenFile. Expected _wxFileSystem_p.");
1325         return NULL;
1326         }
1327     }
1328 {
1329 #if PYTHON_API_VERSION >= 1009
1330     char* tmpPtr; int tmpSize;
1331     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
1332         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1333         return NULL;
1334     }
1335     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
1336         return NULL;
1337     _arg1 = new wxString(tmpPtr, tmpSize);
1338 #else
1339     if (!PyString_Check(_obj1)) {
1340         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1341         return NULL;
1342     }
1343     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
1344 #endif
1345 }
1346 {
1347     PyThreadState* __tstate = wxPyBeginAllowThreads();
1348         _result = (wxFSFile *)wxFileSystem_OpenFile(_arg0,*_arg1);
1349
1350     wxPyEndAllowThreads(__tstate);
1351     if (PyErr_Occurred()) return NULL;
1352 }{ _resultobj = wxPyMake_wxObject(_result); }
1353 {
1354     if (_obj1)
1355         delete _arg1;
1356 }
1357     return _resultobj;
1358 }
1359
1360 #define wxFileSystem_FindFirst(_swigobj,_swigarg0,_swigarg1)  (_swigobj->FindFirst(_swigarg0,_swigarg1))
1361 static PyObject *_wrap_wxFileSystem_FindFirst(PyObject *self, PyObject *args, PyObject *kwargs) {
1362     PyObject * _resultobj;
1363     wxString * _result;
1364     wxFileSystem * _arg0;
1365     wxString * _arg1;
1366     int  _arg2 = (int ) 0;
1367     PyObject * _argo0 = 0;
1368     PyObject * _obj1 = 0;
1369     char *_kwnames[] = { "self","spec","flags", NULL };
1370
1371     self = self;
1372     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO|i:wxFileSystem_FindFirst",_kwnames,&_argo0,&_obj1,&_arg2))
1373         return NULL;
1374     if (_argo0) {
1375         if (_argo0 == Py_None) { _arg0 = NULL; }
1376         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxFileSystem_p")) {
1377             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxFileSystem_FindFirst. Expected _wxFileSystem_p.");
1378         return NULL;
1379         }
1380     }
1381 {
1382 #if PYTHON_API_VERSION >= 1009
1383     char* tmpPtr; int tmpSize;
1384     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
1385         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1386         return NULL;
1387     }
1388     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
1389         return NULL;
1390     _arg1 = new wxString(tmpPtr, tmpSize);
1391 #else
1392     if (!PyString_Check(_obj1)) {
1393         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1394         return NULL;
1395     }
1396     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
1397 #endif
1398 }
1399 {
1400     PyThreadState* __tstate = wxPyBeginAllowThreads();
1401         _result = new wxString (wxFileSystem_FindFirst(_arg0,*_arg1,_arg2));
1402
1403     wxPyEndAllowThreads(__tstate);
1404     if (PyErr_Occurred()) return NULL;
1405 }{
1406     _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
1407 }
1408 {
1409     if (_obj1)
1410         delete _arg1;
1411 }
1412 {
1413     delete _result;
1414 }
1415     return _resultobj;
1416 }
1417
1418 #define wxFileSystem_FindNext(_swigobj)  (_swigobj->FindNext())
1419 static PyObject *_wrap_wxFileSystem_FindNext(PyObject *self, PyObject *args, PyObject *kwargs) {
1420     PyObject * _resultobj;
1421     wxString * _result;
1422     wxFileSystem * _arg0;
1423     PyObject * _argo0 = 0;
1424     char *_kwnames[] = { "self", NULL };
1425
1426     self = self;
1427     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxFileSystem_FindNext",_kwnames,&_argo0))
1428         return NULL;
1429     if (_argo0) {
1430         if (_argo0 == Py_None) { _arg0 = NULL; }
1431         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxFileSystem_p")) {
1432             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxFileSystem_FindNext. Expected _wxFileSystem_p.");
1433         return NULL;
1434         }
1435     }
1436 {
1437     PyThreadState* __tstate = wxPyBeginAllowThreads();
1438         _result = new wxString (wxFileSystem_FindNext(_arg0));
1439
1440     wxPyEndAllowThreads(__tstate);
1441     if (PyErr_Occurred()) return NULL;
1442 }{
1443     _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
1444 }
1445 {
1446     delete _result;
1447 }
1448     return _resultobj;
1449 }
1450
1451 static PyObject *_wrap_wxFileSystem_AddHandler(PyObject *self, PyObject *args, PyObject *kwargs) {
1452     PyObject * _resultobj;
1453     wxFileSystemHandler * _arg0;
1454     PyObject * _argo0 = 0;
1455     char *_kwnames[] = { "handler", NULL };
1456
1457     self = self;
1458     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxFileSystem_AddHandler",_kwnames,&_argo0))
1459         return NULL;
1460     if (_argo0) {
1461         if (_argo0 == Py_None) { _arg0 = NULL; }
1462         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxFileSystemHandler_p")) {
1463             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxFileSystem_AddHandler. Expected _wxFileSystemHandler_p.");
1464         return NULL;
1465         }
1466     }
1467 {
1468     PyThreadState* __tstate = wxPyBeginAllowThreads();
1469         wxFileSystem::AddHandler(_arg0);
1470
1471     wxPyEndAllowThreads(__tstate);
1472     if (PyErr_Occurred()) return NULL;
1473 }    Py_INCREF(Py_None);
1474     _resultobj = Py_None;
1475     return _resultobj;
1476 }
1477
1478 static PyObject *_wrap_wxFileSystem_CleanUpHandlers(PyObject *self, PyObject *args, PyObject *kwargs) {
1479     PyObject * _resultobj;
1480     char *_kwnames[] = {  NULL };
1481
1482     self = self;
1483     if(!PyArg_ParseTupleAndKeywords(args,kwargs,":wxFileSystem_CleanUpHandlers",_kwnames))
1484         return NULL;
1485 {
1486     PyThreadState* __tstate = wxPyBeginAllowThreads();
1487         wxFileSystem::CleanUpHandlers();
1488
1489     wxPyEndAllowThreads(__tstate);
1490     if (PyErr_Occurred()) return NULL;
1491 }    Py_INCREF(Py_None);
1492     _resultobj = Py_None;
1493     return _resultobj;
1494 }
1495
1496 static void *SwigwxInternetFSHandlerTowxFileSystemHandler(void *ptr) {
1497     wxInternetFSHandler *src;
1498     wxFileSystemHandler *dest;
1499     src = (wxInternetFSHandler *) ptr;
1500     dest = (wxFileSystemHandler *) src;
1501     return (void *) dest;
1502 }
1503
1504 static void *SwigwxInternetFSHandlerTowxObject(void *ptr) {
1505     wxInternetFSHandler *src;
1506     wxObject *dest;
1507     src = (wxInternetFSHandler *) ptr;
1508     dest = (wxObject *) src;
1509     return (void *) dest;
1510 }
1511
1512 #define new_wxInternetFSHandler() (new wxInternetFSHandler())
1513 static PyObject *_wrap_new_wxInternetFSHandler(PyObject *self, PyObject *args, PyObject *kwargs) {
1514     PyObject * _resultobj;
1515     wxInternetFSHandler * _result;
1516     char *_kwnames[] = {  NULL };
1517     char _ptemp[128];
1518
1519     self = self;
1520     if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxInternetFSHandler",_kwnames))
1521         return NULL;
1522 {
1523     PyThreadState* __tstate = wxPyBeginAllowThreads();
1524         _result = (wxInternetFSHandler *)new_wxInternetFSHandler();
1525
1526     wxPyEndAllowThreads(__tstate);
1527     if (PyErr_Occurred()) return NULL;
1528 }    if (_result) {
1529         SWIG_MakePtr(_ptemp, (char *) _result,"_wxInternetFSHandler_p");
1530         _resultobj = Py_BuildValue("s",_ptemp);
1531     } else {
1532         Py_INCREF(Py_None);
1533         _resultobj = Py_None;
1534     }
1535     return _resultobj;
1536 }
1537
1538 #define wxInternetFSHandler_CanOpen(_swigobj,_swigarg0)  (_swigobj->CanOpen(_swigarg0))
1539 static PyObject *_wrap_wxInternetFSHandler_CanOpen(PyObject *self, PyObject *args, PyObject *kwargs) {
1540     PyObject * _resultobj;
1541     bool  _result;
1542     wxInternetFSHandler * _arg0;
1543     wxString * _arg1;
1544     PyObject * _argo0 = 0;
1545     PyObject * _obj1 = 0;
1546     char *_kwnames[] = { "self","location", NULL };
1547
1548     self = self;
1549     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxInternetFSHandler_CanOpen",_kwnames,&_argo0,&_obj1))
1550         return NULL;
1551     if (_argo0) {
1552         if (_argo0 == Py_None) { _arg0 = NULL; }
1553         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxInternetFSHandler_p")) {
1554             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxInternetFSHandler_CanOpen. Expected _wxInternetFSHandler_p.");
1555         return NULL;
1556         }
1557     }
1558 {
1559 #if PYTHON_API_VERSION >= 1009
1560     char* tmpPtr; int tmpSize;
1561     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
1562         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1563         return NULL;
1564     }
1565     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
1566         return NULL;
1567     _arg1 = new wxString(tmpPtr, tmpSize);
1568 #else
1569     if (!PyString_Check(_obj1)) {
1570         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1571         return NULL;
1572     }
1573     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
1574 #endif
1575 }
1576 {
1577     PyThreadState* __tstate = wxPyBeginAllowThreads();
1578         _result = (bool )wxInternetFSHandler_CanOpen(_arg0,*_arg1);
1579
1580     wxPyEndAllowThreads(__tstate);
1581     if (PyErr_Occurred()) return NULL;
1582 }    _resultobj = Py_BuildValue("i",_result);
1583 {
1584     if (_obj1)
1585         delete _arg1;
1586 }
1587     return _resultobj;
1588 }
1589
1590 #define wxInternetFSHandler_OpenFile(_swigobj,_swigarg0,_swigarg1)  (_swigobj->OpenFile(_swigarg0,_swigarg1))
1591 static PyObject *_wrap_wxInternetFSHandler_OpenFile(PyObject *self, PyObject *args, PyObject *kwargs) {
1592     PyObject * _resultobj;
1593     wxFSFile * _result;
1594     wxInternetFSHandler * _arg0;
1595     wxFileSystem * _arg1;
1596     wxString * _arg2;
1597     PyObject * _argo0 = 0;
1598     PyObject * _argo1 = 0;
1599     PyObject * _obj2 = 0;
1600     char *_kwnames[] = { "self","fs","location", NULL };
1601
1602     self = self;
1603     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO:wxInternetFSHandler_OpenFile",_kwnames,&_argo0,&_argo1,&_obj2))
1604         return NULL;
1605     if (_argo0) {
1606         if (_argo0 == Py_None) { _arg0 = NULL; }
1607         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxInternetFSHandler_p")) {
1608             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxInternetFSHandler_OpenFile. Expected _wxInternetFSHandler_p.");
1609         return NULL;
1610         }
1611     }
1612     if (_argo1) {
1613         if (_argo1 == Py_None) { _arg1 = NULL; }
1614         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxFileSystem_p")) {
1615             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxInternetFSHandler_OpenFile. Expected _wxFileSystem_p.");
1616         return NULL;
1617         }
1618     }
1619 {
1620 #if PYTHON_API_VERSION >= 1009
1621     char* tmpPtr; int tmpSize;
1622     if (!PyString_Check(_obj2) && !PyUnicode_Check(_obj2)) {
1623         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1624         return NULL;
1625     }
1626     if (PyString_AsStringAndSize(_obj2, &tmpPtr, &tmpSize) == -1)
1627         return NULL;
1628     _arg2 = new wxString(tmpPtr, tmpSize);
1629 #else
1630     if (!PyString_Check(_obj2)) {
1631         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1632         return NULL;
1633     }
1634     _arg2 = new wxString(PyString_AS_STRING(_obj2), PyString_GET_SIZE(_obj2));
1635 #endif
1636 }
1637 {
1638     PyThreadState* __tstate = wxPyBeginAllowThreads();
1639         _result = (wxFSFile *)wxInternetFSHandler_OpenFile(_arg0,*_arg1,*_arg2);
1640
1641     wxPyEndAllowThreads(__tstate);
1642     if (PyErr_Occurred()) return NULL;
1643 }{ _resultobj = wxPyMake_wxObject(_result); }
1644 {
1645     if (_obj2)
1646         delete _arg2;
1647 }
1648     return _resultobj;
1649 }
1650
1651 static void *SwigwxZipFSHandlerTowxFileSystemHandler(void *ptr) {
1652     wxZipFSHandler *src;
1653     wxFileSystemHandler *dest;
1654     src = (wxZipFSHandler *) ptr;
1655     dest = (wxFileSystemHandler *) src;
1656     return (void *) dest;
1657 }
1658
1659 static void *SwigwxZipFSHandlerTowxObject(void *ptr) {
1660     wxZipFSHandler *src;
1661     wxObject *dest;
1662     src = (wxZipFSHandler *) ptr;
1663     dest = (wxObject *) src;
1664     return (void *) dest;
1665 }
1666
1667 #define new_wxZipFSHandler() (new wxZipFSHandler())
1668 static PyObject *_wrap_new_wxZipFSHandler(PyObject *self, PyObject *args, PyObject *kwargs) {
1669     PyObject * _resultobj;
1670     wxZipFSHandler * _result;
1671     char *_kwnames[] = {  NULL };
1672     char _ptemp[128];
1673
1674     self = self;
1675     if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxZipFSHandler",_kwnames))
1676         return NULL;
1677 {
1678     PyThreadState* __tstate = wxPyBeginAllowThreads();
1679         _result = (wxZipFSHandler *)new_wxZipFSHandler();
1680
1681     wxPyEndAllowThreads(__tstate);
1682     if (PyErr_Occurred()) return NULL;
1683 }    if (_result) {
1684         SWIG_MakePtr(_ptemp, (char *) _result,"_wxZipFSHandler_p");
1685         _resultobj = Py_BuildValue("s",_ptemp);
1686     } else {
1687         Py_INCREF(Py_None);
1688         _resultobj = Py_None;
1689     }
1690     return _resultobj;
1691 }
1692
1693 #define wxZipFSHandler_CanOpen(_swigobj,_swigarg0)  (_swigobj->CanOpen(_swigarg0))
1694 static PyObject *_wrap_wxZipFSHandler_CanOpen(PyObject *self, PyObject *args, PyObject *kwargs) {
1695     PyObject * _resultobj;
1696     bool  _result;
1697     wxZipFSHandler * _arg0;
1698     wxString * _arg1;
1699     PyObject * _argo0 = 0;
1700     PyObject * _obj1 = 0;
1701     char *_kwnames[] = { "self","location", NULL };
1702
1703     self = self;
1704     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxZipFSHandler_CanOpen",_kwnames,&_argo0,&_obj1))
1705         return NULL;
1706     if (_argo0) {
1707         if (_argo0 == Py_None) { _arg0 = NULL; }
1708         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxZipFSHandler_p")) {
1709             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxZipFSHandler_CanOpen. Expected _wxZipFSHandler_p.");
1710         return NULL;
1711         }
1712     }
1713 {
1714 #if PYTHON_API_VERSION >= 1009
1715     char* tmpPtr; int tmpSize;
1716     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
1717         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1718         return NULL;
1719     }
1720     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
1721         return NULL;
1722     _arg1 = new wxString(tmpPtr, tmpSize);
1723 #else
1724     if (!PyString_Check(_obj1)) {
1725         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1726         return NULL;
1727     }
1728     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
1729 #endif
1730 }
1731 {
1732     PyThreadState* __tstate = wxPyBeginAllowThreads();
1733         _result = (bool )wxZipFSHandler_CanOpen(_arg0,*_arg1);
1734
1735     wxPyEndAllowThreads(__tstate);
1736     if (PyErr_Occurred()) return NULL;
1737 }    _resultobj = Py_BuildValue("i",_result);
1738 {
1739     if (_obj1)
1740         delete _arg1;
1741 }
1742     return _resultobj;
1743 }
1744
1745 #define wxZipFSHandler_OpenFile(_swigobj,_swigarg0,_swigarg1)  (_swigobj->OpenFile(_swigarg0,_swigarg1))
1746 static PyObject *_wrap_wxZipFSHandler_OpenFile(PyObject *self, PyObject *args, PyObject *kwargs) {
1747     PyObject * _resultobj;
1748     wxFSFile * _result;
1749     wxZipFSHandler * _arg0;
1750     wxFileSystem * _arg1;
1751     wxString * _arg2;
1752     PyObject * _argo0 = 0;
1753     PyObject * _argo1 = 0;
1754     PyObject * _obj2 = 0;
1755     char *_kwnames[] = { "self","fs","location", NULL };
1756
1757     self = self;
1758     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO:wxZipFSHandler_OpenFile",_kwnames,&_argo0,&_argo1,&_obj2))
1759         return NULL;
1760     if (_argo0) {
1761         if (_argo0 == Py_None) { _arg0 = NULL; }
1762         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxZipFSHandler_p")) {
1763             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxZipFSHandler_OpenFile. Expected _wxZipFSHandler_p.");
1764         return NULL;
1765         }
1766     }
1767     if (_argo1) {
1768         if (_argo1 == Py_None) { _arg1 = NULL; }
1769         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxFileSystem_p")) {
1770             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxZipFSHandler_OpenFile. Expected _wxFileSystem_p.");
1771         return NULL;
1772         }
1773     }
1774 {
1775 #if PYTHON_API_VERSION >= 1009
1776     char* tmpPtr; int tmpSize;
1777     if (!PyString_Check(_obj2) && !PyUnicode_Check(_obj2)) {
1778         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1779         return NULL;
1780     }
1781     if (PyString_AsStringAndSize(_obj2, &tmpPtr, &tmpSize) == -1)
1782         return NULL;
1783     _arg2 = new wxString(tmpPtr, tmpSize);
1784 #else
1785     if (!PyString_Check(_obj2)) {
1786         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1787         return NULL;
1788     }
1789     _arg2 = new wxString(PyString_AS_STRING(_obj2), PyString_GET_SIZE(_obj2));
1790 #endif
1791 }
1792 {
1793     PyThreadState* __tstate = wxPyBeginAllowThreads();
1794         _result = (wxFSFile *)wxZipFSHandler_OpenFile(_arg0,*_arg1,*_arg2);
1795
1796     wxPyEndAllowThreads(__tstate);
1797     if (PyErr_Occurred()) return NULL;
1798 }{ _resultobj = wxPyMake_wxObject(_result); }
1799 {
1800     if (_obj2)
1801         delete _arg2;
1802 }
1803     return _resultobj;
1804 }
1805
1806 #define wxZipFSHandler_FindFirst(_swigobj,_swigarg0,_swigarg1)  (_swigobj->FindFirst(_swigarg0,_swigarg1))
1807 static PyObject *_wrap_wxZipFSHandler_FindFirst(PyObject *self, PyObject *args, PyObject *kwargs) {
1808     PyObject * _resultobj;
1809     wxString * _result;
1810     wxZipFSHandler * _arg0;
1811     wxString * _arg1;
1812     int  _arg2 = (int ) 0;
1813     PyObject * _argo0 = 0;
1814     PyObject * _obj1 = 0;
1815     char *_kwnames[] = { "self","spec","flags", NULL };
1816
1817     self = self;
1818     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO|i:wxZipFSHandler_FindFirst",_kwnames,&_argo0,&_obj1,&_arg2))
1819         return NULL;
1820     if (_argo0) {
1821         if (_argo0 == Py_None) { _arg0 = NULL; }
1822         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxZipFSHandler_p")) {
1823             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxZipFSHandler_FindFirst. Expected _wxZipFSHandler_p.");
1824         return NULL;
1825         }
1826     }
1827 {
1828 #if PYTHON_API_VERSION >= 1009
1829     char* tmpPtr; int tmpSize;
1830     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
1831         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1832         return NULL;
1833     }
1834     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
1835         return NULL;
1836     _arg1 = new wxString(tmpPtr, tmpSize);
1837 #else
1838     if (!PyString_Check(_obj1)) {
1839         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1840         return NULL;
1841     }
1842     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
1843 #endif
1844 }
1845 {
1846     PyThreadState* __tstate = wxPyBeginAllowThreads();
1847         _result = new wxString (wxZipFSHandler_FindFirst(_arg0,*_arg1,_arg2));
1848
1849     wxPyEndAllowThreads(__tstate);
1850     if (PyErr_Occurred()) return NULL;
1851 }{
1852     _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
1853 }
1854 {
1855     if (_obj1)
1856         delete _arg1;
1857 }
1858 {
1859     delete _result;
1860 }
1861     return _resultobj;
1862 }
1863
1864 #define wxZipFSHandler_FindNext(_swigobj)  (_swigobj->FindNext())
1865 static PyObject *_wrap_wxZipFSHandler_FindNext(PyObject *self, PyObject *args, PyObject *kwargs) {
1866     PyObject * _resultobj;
1867     wxString * _result;
1868     wxZipFSHandler * _arg0;
1869     PyObject * _argo0 = 0;
1870     char *_kwnames[] = { "self", NULL };
1871
1872     self = self;
1873     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxZipFSHandler_FindNext",_kwnames,&_argo0))
1874         return NULL;
1875     if (_argo0) {
1876         if (_argo0 == Py_None) { _arg0 = NULL; }
1877         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxZipFSHandler_p")) {
1878             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxZipFSHandler_FindNext. Expected _wxZipFSHandler_p.");
1879         return NULL;
1880         }
1881     }
1882 {
1883     PyThreadState* __tstate = wxPyBeginAllowThreads();
1884         _result = new wxString (wxZipFSHandler_FindNext(_arg0));
1885
1886     wxPyEndAllowThreads(__tstate);
1887     if (PyErr_Occurred()) return NULL;
1888 }{
1889     _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
1890 }
1891 {
1892     delete _result;
1893 }
1894     return _resultobj;
1895 }
1896
1897 static void *SwigwxMemoryFSHandlerTowxFileSystemHandler(void *ptr) {
1898     wxMemoryFSHandler *src;
1899     wxFileSystemHandler *dest;
1900     src = (wxMemoryFSHandler *) ptr;
1901     dest = (wxFileSystemHandler *) src;
1902     return (void *) dest;
1903 }
1904
1905 static void *SwigwxMemoryFSHandlerTowxObject(void *ptr) {
1906     wxMemoryFSHandler *src;
1907     wxObject *dest;
1908     src = (wxMemoryFSHandler *) ptr;
1909     dest = (wxObject *) src;
1910     return (void *) dest;
1911 }
1912
1913 #define new_wxMemoryFSHandler() (new wxMemoryFSHandler())
1914 static PyObject *_wrap_new_wxMemoryFSHandler(PyObject *self, PyObject *args, PyObject *kwargs) {
1915     PyObject * _resultobj;
1916     wxMemoryFSHandler * _result;
1917     char *_kwnames[] = {  NULL };
1918     char _ptemp[128];
1919
1920     self = self;
1921     if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxMemoryFSHandler",_kwnames))
1922         return NULL;
1923 {
1924     PyThreadState* __tstate = wxPyBeginAllowThreads();
1925         _result = (wxMemoryFSHandler *)new_wxMemoryFSHandler();
1926
1927     wxPyEndAllowThreads(__tstate);
1928     if (PyErr_Occurred()) return NULL;
1929 }    if (_result) {
1930         SWIG_MakePtr(_ptemp, (char *) _result,"_wxMemoryFSHandler_p");
1931         _resultobj = Py_BuildValue("s",_ptemp);
1932     } else {
1933         Py_INCREF(Py_None);
1934         _resultobj = Py_None;
1935     }
1936     return _resultobj;
1937 }
1938
1939 static PyObject *_wrap_wxMemoryFSHandler_RemoveFile(PyObject *self, PyObject *args, PyObject *kwargs) {
1940     PyObject * _resultobj;
1941     wxString * _arg0;
1942     PyObject * _obj0 = 0;
1943     char *_kwnames[] = { "filename", NULL };
1944
1945     self = self;
1946     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxMemoryFSHandler_RemoveFile",_kwnames,&_obj0))
1947         return NULL;
1948 {
1949 #if PYTHON_API_VERSION >= 1009
1950     char* tmpPtr; int tmpSize;
1951     if (!PyString_Check(_obj0) && !PyUnicode_Check(_obj0)) {
1952         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1953         return NULL;
1954     }
1955     if (PyString_AsStringAndSize(_obj0, &tmpPtr, &tmpSize) == -1)
1956         return NULL;
1957     _arg0 = new wxString(tmpPtr, tmpSize);
1958 #else
1959     if (!PyString_Check(_obj0)) {
1960         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1961         return NULL;
1962     }
1963     _arg0 = new wxString(PyString_AS_STRING(_obj0), PyString_GET_SIZE(_obj0));
1964 #endif
1965 }
1966 {
1967     PyThreadState* __tstate = wxPyBeginAllowThreads();
1968         wxMemoryFSHandler::RemoveFile(*_arg0);
1969
1970     wxPyEndAllowThreads(__tstate);
1971     if (PyErr_Occurred()) return NULL;
1972 }    Py_INCREF(Py_None);
1973     _resultobj = Py_None;
1974 {
1975     if (_obj0)
1976         delete _arg0;
1977 }
1978     return _resultobj;
1979 }
1980
1981 #define wxMemoryFSHandler_CanOpen(_swigobj,_swigarg0)  (_swigobj->CanOpen(_swigarg0))
1982 static PyObject *_wrap_wxMemoryFSHandler_CanOpen(PyObject *self, PyObject *args, PyObject *kwargs) {
1983     PyObject * _resultobj;
1984     bool  _result;
1985     wxMemoryFSHandler * _arg0;
1986     wxString * _arg1;
1987     PyObject * _argo0 = 0;
1988     PyObject * _obj1 = 0;
1989     char *_kwnames[] = { "self","location", NULL };
1990
1991     self = self;
1992     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxMemoryFSHandler_CanOpen",_kwnames,&_argo0,&_obj1))
1993         return NULL;
1994     if (_argo0) {
1995         if (_argo0 == Py_None) { _arg0 = NULL; }
1996         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxMemoryFSHandler_p")) {
1997             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMemoryFSHandler_CanOpen. Expected _wxMemoryFSHandler_p.");
1998         return NULL;
1999         }
2000     }
2001 {
2002 #if PYTHON_API_VERSION >= 1009
2003     char* tmpPtr; int tmpSize;
2004     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
2005         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
2006         return NULL;
2007     }
2008     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
2009         return NULL;
2010     _arg1 = new wxString(tmpPtr, tmpSize);
2011 #else
2012     if (!PyString_Check(_obj1)) {
2013         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
2014         return NULL;
2015     }
2016     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
2017 #endif
2018 }
2019 {
2020     PyThreadState* __tstate = wxPyBeginAllowThreads();
2021         _result = (bool )wxMemoryFSHandler_CanOpen(_arg0,*_arg1);
2022
2023     wxPyEndAllowThreads(__tstate);
2024     if (PyErr_Occurred()) return NULL;
2025 }    _resultobj = Py_BuildValue("i",_result);
2026 {
2027     if (_obj1)
2028         delete _arg1;
2029 }
2030     return _resultobj;
2031 }
2032
2033 #define wxMemoryFSHandler_OpenFile(_swigobj,_swigarg0,_swigarg1)  (_swigobj->OpenFile(_swigarg0,_swigarg1))
2034 static PyObject *_wrap_wxMemoryFSHandler_OpenFile(PyObject *self, PyObject *args, PyObject *kwargs) {
2035     PyObject * _resultobj;
2036     wxFSFile * _result;
2037     wxMemoryFSHandler * _arg0;
2038     wxFileSystem * _arg1;
2039     wxString * _arg2;
2040     PyObject * _argo0 = 0;
2041     PyObject * _argo1 = 0;
2042     PyObject * _obj2 = 0;
2043     char *_kwnames[] = { "self","fs","location", NULL };
2044
2045     self = self;
2046     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO:wxMemoryFSHandler_OpenFile",_kwnames,&_argo0,&_argo1,&_obj2))
2047         return NULL;
2048     if (_argo0) {
2049         if (_argo0 == Py_None) { _arg0 = NULL; }
2050         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxMemoryFSHandler_p")) {
2051             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMemoryFSHandler_OpenFile. Expected _wxMemoryFSHandler_p.");
2052         return NULL;
2053         }
2054     }
2055     if (_argo1) {
2056         if (_argo1 == Py_None) { _arg1 = NULL; }
2057         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxFileSystem_p")) {
2058             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxMemoryFSHandler_OpenFile. Expected _wxFileSystem_p.");
2059         return NULL;
2060         }
2061     }
2062 {
2063 #if PYTHON_API_VERSION >= 1009
2064     char* tmpPtr; int tmpSize;
2065     if (!PyString_Check(_obj2) && !PyUnicode_Check(_obj2)) {
2066         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
2067         return NULL;
2068     }
2069     if (PyString_AsStringAndSize(_obj2, &tmpPtr, &tmpSize) == -1)
2070         return NULL;
2071     _arg2 = new wxString(tmpPtr, tmpSize);
2072 #else
2073     if (!PyString_Check(_obj2)) {
2074         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
2075         return NULL;
2076     }
2077     _arg2 = new wxString(PyString_AS_STRING(_obj2), PyString_GET_SIZE(_obj2));
2078 #endif
2079 }
2080 {
2081     PyThreadState* __tstate = wxPyBeginAllowThreads();
2082         _result = (wxFSFile *)wxMemoryFSHandler_OpenFile(_arg0,*_arg1,*_arg2);
2083
2084     wxPyEndAllowThreads(__tstate);
2085     if (PyErr_Occurred()) return NULL;
2086 }{ _resultobj = wxPyMake_wxObject(_result); }
2087 {
2088     if (_obj2)
2089         delete _arg2;
2090 }
2091     return _resultobj;
2092 }
2093
2094 #define wxMemoryFSHandler_FindFirst(_swigobj,_swigarg0,_swigarg1)  (_swigobj->FindFirst(_swigarg0,_swigarg1))
2095 static PyObject *_wrap_wxMemoryFSHandler_FindFirst(PyObject *self, PyObject *args, PyObject *kwargs) {
2096     PyObject * _resultobj;
2097     wxString * _result;
2098     wxMemoryFSHandler * _arg0;
2099     wxString * _arg1;
2100     int  _arg2 = (int ) 0;
2101     PyObject * _argo0 = 0;
2102     PyObject * _obj1 = 0;
2103     char *_kwnames[] = { "self","spec","flags", NULL };
2104
2105     self = self;
2106     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO|i:wxMemoryFSHandler_FindFirst",_kwnames,&_argo0,&_obj1,&_arg2))
2107         return NULL;
2108     if (_argo0) {
2109         if (_argo0 == Py_None) { _arg0 = NULL; }
2110         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxMemoryFSHandler_p")) {
2111             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMemoryFSHandler_FindFirst. Expected _wxMemoryFSHandler_p.");
2112         return NULL;
2113         }
2114     }
2115 {
2116 #if PYTHON_API_VERSION >= 1009
2117     char* tmpPtr; int tmpSize;
2118     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
2119         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
2120         return NULL;
2121     }
2122     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
2123         return NULL;
2124     _arg1 = new wxString(tmpPtr, tmpSize);
2125 #else
2126     if (!PyString_Check(_obj1)) {
2127         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
2128         return NULL;
2129     }
2130     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
2131 #endif
2132 }
2133 {
2134     PyThreadState* __tstate = wxPyBeginAllowThreads();
2135         _result = new wxString (wxMemoryFSHandler_FindFirst(_arg0,*_arg1,_arg2));
2136
2137     wxPyEndAllowThreads(__tstate);
2138     if (PyErr_Occurred()) return NULL;
2139 }{
2140     _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
2141 }
2142 {
2143     if (_obj1)
2144         delete _arg1;
2145 }
2146 {
2147     delete _result;
2148 }
2149     return _resultobj;
2150 }
2151
2152 #define wxMemoryFSHandler_FindNext(_swigobj)  (_swigobj->FindNext())
2153 static PyObject *_wrap_wxMemoryFSHandler_FindNext(PyObject *self, PyObject *args, PyObject *kwargs) {
2154     PyObject * _resultobj;
2155     wxString * _result;
2156     wxMemoryFSHandler * _arg0;
2157     PyObject * _argo0 = 0;
2158     char *_kwnames[] = { "self", NULL };
2159
2160     self = self;
2161     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxMemoryFSHandler_FindNext",_kwnames,&_argo0))
2162         return NULL;
2163     if (_argo0) {
2164         if (_argo0 == Py_None) { _arg0 = NULL; }
2165         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxMemoryFSHandler_p")) {
2166             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMemoryFSHandler_FindNext. Expected _wxMemoryFSHandler_p.");
2167         return NULL;
2168         }
2169     }
2170 {
2171     PyThreadState* __tstate = wxPyBeginAllowThreads();
2172         _result = new wxString (wxMemoryFSHandler_FindNext(_arg0));
2173
2174     wxPyEndAllowThreads(__tstate);
2175     if (PyErr_Occurred()) return NULL;
2176 }{
2177     _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
2178 }
2179 {
2180     delete _result;
2181 }
2182     return _resultobj;
2183 }
2184
2185 static PyMethodDef filesyscMethods[] = {
2186          { "wxMemoryFSHandler_FindNext", (PyCFunction) _wrap_wxMemoryFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS },
2187          { "wxMemoryFSHandler_FindFirst", (PyCFunction) _wrap_wxMemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS },
2188          { "wxMemoryFSHandler_OpenFile", (PyCFunction) _wrap_wxMemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS },
2189          { "wxMemoryFSHandler_CanOpen", (PyCFunction) _wrap_wxMemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS },
2190          { "wxMemoryFSHandler_RemoveFile", (PyCFunction) _wrap_wxMemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS },
2191          { "new_wxMemoryFSHandler", (PyCFunction) _wrap_new_wxMemoryFSHandler, METH_VARARGS | METH_KEYWORDS },
2192          { "wxZipFSHandler_FindNext", (PyCFunction) _wrap_wxZipFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS },
2193          { "wxZipFSHandler_FindFirst", (PyCFunction) _wrap_wxZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS },
2194          { "wxZipFSHandler_OpenFile", (PyCFunction) _wrap_wxZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS },
2195          { "wxZipFSHandler_CanOpen", (PyCFunction) _wrap_wxZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS },
2196          { "new_wxZipFSHandler", (PyCFunction) _wrap_new_wxZipFSHandler, METH_VARARGS | METH_KEYWORDS },
2197          { "wxInternetFSHandler_OpenFile", (PyCFunction) _wrap_wxInternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS },
2198          { "wxInternetFSHandler_CanOpen", (PyCFunction) _wrap_wxInternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS },
2199          { "new_wxInternetFSHandler", (PyCFunction) _wrap_new_wxInternetFSHandler, METH_VARARGS | METH_KEYWORDS },
2200          { "wxFileSystem_CleanUpHandlers", (PyCFunction) _wrap_wxFileSystem_CleanUpHandlers, METH_VARARGS | METH_KEYWORDS },
2201          { "wxFileSystem_AddHandler", (PyCFunction) _wrap_wxFileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS },
2202          { "wxFileSystem_FindNext", (PyCFunction) _wrap_wxFileSystem_FindNext, METH_VARARGS | METH_KEYWORDS },
2203          { "wxFileSystem_FindFirst", (PyCFunction) _wrap_wxFileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS },
2204          { "wxFileSystem_OpenFile", (PyCFunction) _wrap_wxFileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS },
2205          { "wxFileSystem_GetPath", (PyCFunction) _wrap_wxFileSystem_GetPath, METH_VARARGS | METH_KEYWORDS },
2206          { "wxFileSystem_ChangePathTo", (PyCFunction) _wrap_wxFileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS },
2207          { "new_wxFileSystem", (PyCFunction) _wrap_new_wxFileSystem, METH_VARARGS | METH_KEYWORDS },
2208          { "wxFileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_wxFileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS },
2209          { "wxFileSystemHandler_GetRightLocation", (PyCFunction) _wrap_wxFileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS },
2210          { "wxFileSystemHandler_GetAnchor", (PyCFunction) _wrap_wxFileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS },
2211          { "wxFileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_wxFileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS },
2212          { "wxFileSystemHandler_GetProtocol", (PyCFunction) _wrap_wxFileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS },
2213          { "wxFileSystemHandler_FindNext", (PyCFunction) _wrap_wxFileSystemHandler_FindNext, METH_VARARGS | METH_KEYWORDS },
2214          { "wxFileSystemHandler_FindFirst", (PyCFunction) _wrap_wxFileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS },
2215          { "wxFileSystemHandler_OpenFile", (PyCFunction) _wrap_wxFileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS },
2216          { "wxFileSystemHandler_CanOpen", (PyCFunction) _wrap_wxFileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS },
2217          { "wxFileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_wxFileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS },
2218          { "new_wxFileSystemHandler", (PyCFunction) _wrap_new_wxFileSystemHandler, METH_VARARGS | METH_KEYWORDS },
2219          { "wxFSFile_GetModificationTime", (PyCFunction) _wrap_wxFSFile_GetModificationTime, METH_VARARGS | METH_KEYWORDS },
2220          { "wxFSFile_GetAnchor", (PyCFunction) _wrap_wxFSFile_GetAnchor, METH_VARARGS | METH_KEYWORDS },
2221          { "wxFSFile_GetLocation", (PyCFunction) _wrap_wxFSFile_GetLocation, METH_VARARGS | METH_KEYWORDS },
2222          { "wxFSFile_GetMimeType", (PyCFunction) _wrap_wxFSFile_GetMimeType, METH_VARARGS | METH_KEYWORDS },
2223          { "wxFSFile_GetStream", (PyCFunction) _wrap_wxFSFile_GetStream, METH_VARARGS | METH_KEYWORDS },
2224          { "new_wxFSFile", (PyCFunction) _wrap_new_wxFSFile, METH_VARARGS | METH_KEYWORDS },
2225          { "__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS },
2226          { "__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS },
2227          { "__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS },
2228          { NULL, NULL }
2229 };
2230 #ifdef __cplusplus
2231 }
2232 #endif
2233 /*
2234  * This table is used by the pointer type-checker
2235  */
2236 static struct { char *n1; char *n2; void *(*pcnv)(void *); } _swig_mapping[] = {
2237     { "_signed_long","_long",0},
2238     { "_wxPrintQuality","_wxCoord",0},
2239     { "_wxPrintQuality","_int",0},
2240     { "_wxPrintQuality","_signed_int",0},
2241     { "_wxPrintQuality","_unsigned_int",0},
2242     { "_wxPrintQuality","_wxWindowID",0},
2243     { "_wxPrintQuality","_uint",0},
2244     { "_wxPrintQuality","_EBool",0},
2245     { "_wxPrintQuality","_size_t",0},
2246     { "_wxPrintQuality","_time_t",0},
2247     { "_byte","_unsigned_char",0},
2248     { "_long","_unsigned_long",0},
2249     { "_long","_signed_long",0},
2250     { "_size_t","_wxCoord",0},
2251     { "_size_t","_wxPrintQuality",0},
2252     { "_size_t","_time_t",0},
2253     { "_size_t","_unsigned_int",0},
2254     { "_size_t","_int",0},
2255     { "_size_t","_wxWindowID",0},
2256     { "_size_t","_uint",0},
2257     { "_uint","_wxCoord",0},
2258     { "_uint","_wxPrintQuality",0},
2259     { "_uint","_time_t",0},
2260     { "_uint","_size_t",0},
2261     { "_uint","_unsigned_int",0},
2262     { "_uint","_int",0},
2263     { "_uint","_wxWindowID",0},
2264     { "_wxChar","_char",0},
2265     { "_char","_wxChar",0},
2266     { "_struct_wxNativeFontInfo","_wxNativeFontInfo",0},
2267     { "_EBool","_wxCoord",0},
2268     { "_EBool","_wxPrintQuality",0},
2269     { "_EBool","_signed_int",0},
2270     { "_EBool","_int",0},
2271     { "_EBool","_wxWindowID",0},
2272     { "_unsigned_long","_long",0},
2273     { "_wxNativeFontInfo","_struct_wxNativeFontInfo",0},
2274     { "_signed_int","_wxCoord",0},
2275     { "_signed_int","_wxPrintQuality",0},
2276     { "_signed_int","_EBool",0},
2277     { "_signed_int","_wxWindowID",0},
2278     { "_signed_int","_int",0},
2279     { "_WXTYPE","_wxDateTime_t",0},
2280     { "_WXTYPE","_short",0},
2281     { "_WXTYPE","_signed_short",0},
2282     { "_WXTYPE","_unsigned_short",0},
2283     { "_unsigned_short","_wxDateTime_t",0},
2284     { "_unsigned_short","_WXTYPE",0},
2285     { "_unsigned_short","_short",0},
2286     { "_wxObject","_wxMemoryFSHandler",SwigwxMemoryFSHandlerTowxObject},
2287     { "_wxObject","_wxZipFSHandler",SwigwxZipFSHandlerTowxObject},
2288     { "_wxObject","_wxInternetFSHandler",SwigwxInternetFSHandlerTowxObject},
2289     { "_wxObject","_wxFileSystem",SwigwxFileSystemTowxObject},
2290     { "_wxObject","_wxPyFileSystemHandler",SwigwxPyFileSystemHandlerTowxObject},
2291     { "_wxObject","_wxFileSystemHandler",SwigwxFileSystemHandlerTowxObject},
2292     { "_wxObject","_wxFSFile",SwigwxFSFileTowxObject},
2293     { "_signed_short","_WXTYPE",0},
2294     { "_signed_short","_short",0},
2295     { "_unsigned_char","_byte",0},
2296     { "_unsigned_int","_wxCoord",0},
2297     { "_unsigned_int","_wxPrintQuality",0},
2298     { "_unsigned_int","_time_t",0},
2299     { "_unsigned_int","_size_t",0},
2300     { "_unsigned_int","_uint",0},
2301     { "_unsigned_int","_wxWindowID",0},
2302     { "_unsigned_int","_int",0},
2303     { "_short","_wxDateTime_t",0},
2304     { "_short","_WXTYPE",0},
2305     { "_short","_unsigned_short",0},
2306     { "_short","_signed_short",0},
2307     { "_wxFileSystemHandler","_wxMemoryFSHandler",SwigwxMemoryFSHandlerTowxFileSystemHandler},
2308     { "_wxFileSystemHandler","_wxZipFSHandler",SwigwxZipFSHandlerTowxFileSystemHandler},
2309     { "_wxFileSystemHandler","_wxInternetFSHandler",SwigwxInternetFSHandlerTowxFileSystemHandler},
2310     { "_wxFileSystemHandler","_wxPyFileSystemHandler",SwigwxPyFileSystemHandlerTowxFileSystemHandler},
2311     { "_wxWindowID","_wxCoord",0},
2312     { "_wxWindowID","_wxPrintQuality",0},
2313     { "_wxWindowID","_time_t",0},
2314     { "_wxWindowID","_size_t",0},
2315     { "_wxWindowID","_EBool",0},
2316     { "_wxWindowID","_uint",0},
2317     { "_wxWindowID","_int",0},
2318     { "_wxWindowID","_signed_int",0},
2319     { "_wxWindowID","_unsigned_int",0},
2320     { "_int","_wxCoord",0},
2321     { "_int","_wxPrintQuality",0},
2322     { "_int","_time_t",0},
2323     { "_int","_size_t",0},
2324     { "_int","_EBool",0},
2325     { "_int","_uint",0},
2326     { "_int","_wxWindowID",0},
2327     { "_int","_unsigned_int",0},
2328     { "_int","_signed_int",0},
2329     { "_wxDateTime_t","_unsigned_short",0},
2330     { "_wxDateTime_t","_short",0},
2331     { "_wxDateTime_t","_WXTYPE",0},
2332     { "_time_t","_wxCoord",0},
2333     { "_time_t","_wxPrintQuality",0},
2334     { "_time_t","_unsigned_int",0},
2335     { "_time_t","_int",0},
2336     { "_time_t","_wxWindowID",0},
2337     { "_time_t","_uint",0},
2338     { "_time_t","_size_t",0},
2339     { "_wxCoord","_int",0},
2340     { "_wxCoord","_signed_int",0},
2341     { "_wxCoord","_unsigned_int",0},
2342     { "_wxCoord","_wxWindowID",0},
2343     { "_wxCoord","_uint",0},
2344     { "_wxCoord","_EBool",0},
2345     { "_wxCoord","_size_t",0},
2346     { "_wxCoord","_time_t",0},
2347     { "_wxCoord","_wxPrintQuality",0},
2348 {0,0,0}};
2349
2350 static PyObject *SWIG_globals;
2351 #ifdef __cplusplus
2352 extern "C"
2353 #endif
2354 SWIGEXPORT(void) initfilesysc() {
2355          PyObject *m, *d;
2356          SWIG_globals = SWIG_newvarlink();
2357          m = Py_InitModule("filesysc", filesyscMethods);
2358          d = PyModule_GetDict(m);
2359
2360     wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
2361 {
2362    int i;
2363    for (i = 0; _swig_mapping[i].n1; i++)
2364         SWIG_RegisterMapping(_swig_mapping[i].n1,_swig_mapping[i].n2,_swig_mapping[i].pcnv);
2365 }
2366 }