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