wxPython/src/gtk/filesys.cpp

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