+SWIGINTERN PyObject *_wrap_FileType_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
+ PyObject *resultobj = 0;
+ wxFileType *arg1 = (wxFileType *) 0 ;
+ wxString *arg2 = 0 ;
+ wxString const &arg3_defvalue = wxPyEmptyString ;
+ wxString *arg3 = (wxString *) &arg3_defvalue ;
+ PyObject *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ bool temp2 = false ;
+ bool temp3 = false ;
+ PyObject * obj0 = 0 ;
+ PyObject * obj1 = 0 ;
+ PyObject * obj2 = 0 ;
+ char * kwnames[] = {
+ (char *) "self",(char *) "filename",(char *) "mimetype", NULL
+ };
+
+ if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
+ }
+ arg1 = reinterpret_cast< wxFileType * >(argp1);
+ {
+ arg2 = wxString_in_helper(obj1);
+ if (arg2 == NULL) SWIG_fail;
+ temp2 = true;
+ }
+ if (obj2) {
+ {
+ arg3 = wxString_in_helper(obj2);
+ if (arg3 == NULL) SWIG_fail;
+ temp3 = true;
+ }
+ }
+ {
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) SWIG_fail;
+ }
+ resultobj = result;
+ {
+ if (temp2)
+ delete arg2;
+ }
+ {
+ if (temp3)
+ delete arg3;
+ }
+ return resultobj;
+fail:
+ {
+ if (temp2)
+ delete arg2;
+ }
+ {
+ if (temp3)
+ delete arg3;
+ }
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FileType_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
+ PyObject *resultobj = 0;
+ wxFileType *arg1 = (wxFileType *) 0 ;
+ wxString *arg2 = 0 ;
+ wxString const &arg3_defvalue = wxPyEmptyString ;
+ wxString *arg3 = (wxString *) &arg3_defvalue ;
+ PyObject *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ bool temp2 = false ;
+ bool temp3 = false ;
+ PyObject * obj0 = 0 ;
+ PyObject * obj1 = 0 ;
+ PyObject * obj2 = 0 ;
+ char * kwnames[] = {
+ (char *) "self",(char *) "filename",(char *) "mimetype", NULL
+ };
+
+ if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
+ }
+ arg1 = reinterpret_cast< wxFileType * >(argp1);
+ {
+ arg2 = wxString_in_helper(obj1);
+ if (arg2 == NULL) SWIG_fail;
+ temp2 = true;
+ }
+ if (obj2) {
+ {
+ arg3 = wxString_in_helper(obj2);
+ if (arg3 == NULL) SWIG_fail;
+ temp3 = true;
+ }
+ }
+ {
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) SWIG_fail;
+ }
+ resultobj = result;
+ {
+ if (temp2)
+ delete arg2;
+ }
+ {
+ if (temp3)
+ delete arg3;
+ }
+ return resultobj;
+fail:
+ {
+ if (temp2)
+ delete arg2;
+ }
+ {
+ if (temp3)
+ delete arg3;
+ }
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FileType_GetAllCommands(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
+ PyObject *resultobj = 0;
+ wxFileType *arg1 = (wxFileType *) 0 ;
+ wxString *arg2 = 0 ;
+ wxString const &arg3_defvalue = wxPyEmptyString ;
+ wxString *arg3 = (wxString *) &arg3_defvalue ;
+ PyObject *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ bool temp2 = false ;
+ bool temp3 = false ;
+ PyObject * obj0 = 0 ;
+ PyObject * obj1 = 0 ;
+ PyObject * obj2 = 0 ;
+ char * kwnames[] = {
+ (char *) "self",(char *) "filename",(char *) "mimetype", NULL
+ };
+
+ if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetAllCommands" "', expected argument " "1"" of type '" "wxFileType *""'");
+ }
+ arg1 = reinterpret_cast< wxFileType * >(argp1);
+ {
+ arg2 = wxString_in_helper(obj1);
+ if (arg2 == NULL) SWIG_fail;
+ temp2 = true;
+ }
+ if (obj2) {
+ {
+ arg3 = wxString_in_helper(obj2);
+ if (arg3 == NULL) SWIG_fail;
+ temp3 = true;
+ }
+ }
+ {
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) SWIG_fail;
+ }
+ resultobj = result;
+ {
+ if (temp2)
+ delete arg2;
+ }
+ {
+ if (temp3)
+ delete arg3;
+ }
+ return resultobj;
+fail:
+ {
+ if (temp2)
+ delete arg2;
+ }
+ {
+ if (temp3)
+ delete arg3;
+ }
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FileType_SetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
+ PyObject *resultobj = 0;
+ wxFileType *arg1 = (wxFileType *) 0 ;
+ wxString *arg2 = 0 ;
+ wxString *arg3 = 0 ;
+ bool arg4 = (bool) true ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ bool temp2 = false ;
+ bool temp3 = false ;
+ bool val4 ;
+ int ecode4 = 0 ;
+ PyObject * obj0 = 0 ;
+ PyObject * obj1 = 0 ;
+ PyObject * obj2 = 0 ;
+ PyObject * obj3 = 0 ;
+ char * kwnames[] = {
+ (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
+ };
+
+ if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
+ }
+ arg1 = reinterpret_cast< wxFileType * >(argp1);
+ {
+ arg2 = wxString_in_helper(obj1);
+ if (arg2 == NULL) SWIG_fail;
+ temp2 = true;
+ }
+ {
+ arg3 = wxString_in_helper(obj2);
+ if (arg3 == NULL) SWIG_fail;
+ temp3 = true;
+ }
+ if (obj3) {
+ ecode4 = SWIG_AsVal_bool(obj3, &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileType_SetCommand" "', expected argument " "4"" of type '" "bool""'");
+ }
+ arg4 = static_cast< bool >(val4);
+ }
+ {
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) SWIG_fail;
+ }
+ {
+ resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
+ }
+ {
+ if (temp2)
+ delete arg2;
+ }
+ {
+ if (temp3)
+ delete arg3;
+ }
+ return resultobj;
+fail:
+ {
+ if (temp2)
+ delete arg2;
+ }
+ {
+ if (temp3)
+ delete arg3;
+ }
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FileType_SetDefaultIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
+ PyObject *resultobj = 0;
+ wxFileType *arg1 = (wxFileType *) 0 ;
+ wxString const &arg2_defvalue = wxPyEmptyString ;
+ wxString *arg2 = (wxString *) &arg2_defvalue ;
+ int arg3 = (int) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ bool temp2 = false ;
+ int val3 ;
+ int ecode3 = 0 ;
+ PyObject * obj0 = 0 ;
+ PyObject * obj1 = 0 ;
+ PyObject * obj2 = 0 ;
+ char * kwnames[] = {
+ (char *) "self",(char *) "cmd",(char *) "index", NULL
+ };
+
+ if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetDefaultIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
+ }
+ arg1 = reinterpret_cast< wxFileType * >(argp1);
+ if (obj1) {
+ {
+ arg2 = wxString_in_helper(obj1);
+ if (arg2 == NULL) SWIG_fail;
+ temp2 = true;
+ }
+ }
+ if (obj2) {
+ ecode3 = SWIG_AsVal_int(obj2, &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileType_SetDefaultIcon" "', expected argument " "3"" of type '" "int""'");
+ }
+ arg3 = static_cast< int >(val3);
+ }
+ {
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) SWIG_fail;
+ }
+ {
+ resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
+ }
+ {
+ if (temp2)
+ delete arg2;
+ }
+ return resultobj;
+fail:
+ {
+ if (temp2)
+ delete arg2;
+ }
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FileType_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ wxFileType *arg1 = (wxFileType *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_Unassociate" "', expected argument " "1"" of type '" "wxFileType *""'");
+ }
+ arg1 = reinterpret_cast< wxFileType * >(argp1);
+ {
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ result = (bool)(arg1)->Unassociate();
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) SWIG_fail;
+ }
+ {
+ resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
+ }
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FileType_ExpandCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
+ PyObject *resultobj = 0;
+ wxString *arg1 = 0 ;
+ wxString *arg2 = 0 ;
+ wxString const &arg3_defvalue = wxPyEmptyString ;
+ wxString *arg3 = (wxString *) &arg3_defvalue ;
+ wxString result;
+ bool temp1 = false ;
+ bool temp2 = false ;
+ bool temp3 = false ;
+ PyObject * obj0 = 0 ;
+ PyObject * obj1 = 0 ;
+ PyObject * obj2 = 0 ;
+ char * kwnames[] = {
+ (char *) "command",(char *) "filename",(char *) "mimetype", NULL
+ };
+
+ if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
+ {
+ arg1 = wxString_in_helper(obj0);
+ if (arg1 == NULL) SWIG_fail;
+ temp1 = true;
+ }
+ {
+ arg2 = wxString_in_helper(obj1);
+ if (arg2 == NULL) SWIG_fail;
+ temp2 = true;
+ }
+ if (obj2) {
+ {
+ arg3 = wxString_in_helper(obj2);
+ if (arg3 == NULL) SWIG_fail;
+ temp3 = true;
+ }
+ }
+ {
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ result = wxFileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) SWIG_fail;
+ }
+ {
+#if wxUSE_UNICODE
+ resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
+#else
+ resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
+#endif
+ }
+ {
+ if (temp1)
+ delete arg1;
+ }
+ {
+ if (temp2)
+ delete arg2;
+ }
+ {
+ if (temp3)
+ delete arg3;
+ }
+ return resultobj;
+fail:
+ {
+ if (temp1)
+ delete arg1;
+ }
+ {
+ if (temp2)
+ delete arg2;
+ }
+ {
+ if (temp3)
+ delete arg3;
+ }
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *FileType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *obj;
+ if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
+ SWIG_TypeNewClientData(SWIGTYPE_p_wxFileType, SWIG_NewClientData(obj));
+ return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *FileType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ return SWIG_Python_InitShadowInstance(args);
+}
+
+SWIGINTERN int TheMimeTypesManager_set(PyObject *) {
+ SWIG_Error(SWIG_AttributeError,"Variable TheMimeTypesManager is read-only.");
+ return 1;
+}
+
+
+SWIGINTERN PyObject *TheMimeTypesManager_get(void) {
+ PyObject *pyobj = 0;
+
+ pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0 );
+ return pyobj;
+}
+
+
+SWIGINTERN PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
+ PyObject *resultobj = 0;
+ wxString *arg1 = 0 ;
+ wxString *arg2 = 0 ;
+ bool result;
+ bool temp1 = false ;
+ bool temp2 = false ;
+ PyObject * obj0 = 0 ;
+ PyObject * obj1 = 0 ;
+ char * kwnames[] = {
+ (char *) "mimeType",(char *) "wildcard", NULL
+ };
+
+ if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) SWIG_fail;
+ {
+ arg1 = wxString_in_helper(obj0);
+ if (arg1 == NULL) SWIG_fail;
+ temp1 = true;
+ }
+ {
+ arg2 = wxString_in_helper(obj1);
+ if (arg2 == NULL) SWIG_fail;
+ temp2 = true;
+ }
+ {
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) SWIG_fail;
+ }
+ {
+ resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
+ }
+ {
+ if (temp1)
+ delete arg1;
+ }
+ {
+ if (temp2)
+ delete arg2;
+ }
+ return resultobj;
+fail:
+ {
+ if (temp1)
+ delete arg1;
+ }
+ {
+ if (temp2)
+ delete arg2;
+ }
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ wxMimeTypesManager *result = 0 ;
+
+ if (!SWIG_Python_UnpackTuple(args,"new_MimeTypesManager",0,0,0)) SWIG_fail;
+ {
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ result = (wxMimeTypesManager *)new wxMimeTypesManager();
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) SWIG_fail;
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_NEW | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_MimeTypesManager_Initialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
+ PyObject *resultobj = 0;
+ wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
+ int arg2 = (int) wxMAILCAP_ALL ;
+ wxString const &arg3_defvalue = wxPyEmptyString ;
+ wxString *arg3 = (wxString *) &arg3_defvalue ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ bool temp3 = false ;
+ PyObject * obj0 = 0 ;
+ PyObject * obj1 = 0 ;
+ PyObject * obj2 = 0 ;
+ char * kwnames[] = {
+ (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
+ };
+
+ if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Initialize" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
+ }
+ arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
+ if (obj1) {
+ ecode2 = SWIG_AsVal_int(obj1, &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MimeTypesManager_Initialize" "', expected argument " "2"" of type '" "int""'");
+ }
+ arg2 = static_cast< int >(val2);
+ }
+ if (obj2) {
+ {
+ arg3 = wxString_in_helper(obj2);
+ if (arg3 == NULL) SWIG_fail;
+ temp3 = true;
+ }
+ }
+ {
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ (arg1)->Initialize(arg2,(wxString const &)*arg3);
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) SWIG_fail;
+ }
+ resultobj = SWIG_Py_Void();
+ {
+ if (temp3)
+ delete arg3;
+ }
+ return resultobj;
+fail:
+ {
+ if (temp3)
+ delete arg3;
+ }
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_MimeTypesManager_ClearData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ClearData" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
+ }
+ arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
+ {
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ (arg1)->ClearData();
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) SWIG_fail;
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
+ PyObject *resultobj = 0;
+ wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
+ wxString *arg2 = 0 ;
+ wxFileType *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ bool temp2 = false ;
+ PyObject * obj0 = 0 ;
+ PyObject * obj1 = 0 ;
+ char * kwnames[] = {
+ (char *) "self",(char *) "ext", NULL
+ };
+
+ if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromExtension" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
+ }
+ arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
+ {
+ arg2 = wxString_in_helper(obj1);
+ if (arg2 == NULL) SWIG_fail;
+ temp2 = true;
+ }
+ {
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) SWIG_fail;
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
+ {
+ if (temp2)
+ delete arg2;
+ }
+ return resultobj;
+fail:
+ {
+ if (temp2)
+ delete arg2;
+ }
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
+ PyObject *resultobj = 0;
+ wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
+ wxString *arg2 = 0 ;
+ wxFileType *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ bool temp2 = false ;
+ PyObject * obj0 = 0 ;
+ PyObject * obj1 = 0 ;
+ char * kwnames[] = {
+ (char *) "self",(char *) "mimeType", NULL
+ };
+
+ if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromMimeType" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
+ }
+ arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
+ {
+ arg2 = wxString_in_helper(obj1);
+ if (arg2 == NULL) SWIG_fail;
+ temp2 = true;
+ }
+ {
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) SWIG_fail;
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
+ {
+ if (temp2)
+ delete arg2;
+ }
+ return resultobj;
+fail:
+ {
+ if (temp2)
+ delete arg2;
+ }
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
+ PyObject *resultobj = 0;
+ wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
+ wxString *arg2 = 0 ;
+ bool arg3 = (bool) false ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ bool temp2 = false ;
+ bool val3 ;
+ int ecode3 = 0 ;
+ PyObject * obj0 = 0 ;
+ PyObject * obj1 = 0 ;
+ PyObject * obj2 = 0 ;
+ char * kwnames[] = {
+ (char *) "self",(char *) "filename",(char *) "fallback", NULL
+ };
+
+ if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
+ }
+ arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
+ {
+ arg2 = wxString_in_helper(obj1);
+ if (arg2 == NULL) SWIG_fail;
+ temp2 = true;
+ }
+ if (obj2) {
+ ecode3 = SWIG_AsVal_bool(obj2, &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "3"" of type '" "bool""'");
+ }
+ arg3 = static_cast< bool >(val3);
+ }
+ {
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) SWIG_fail;
+ }
+ {
+ resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
+ }
+ {
+ if (temp2)
+ delete arg2;
+ }
+ return resultobj;
+fail:
+ {
+ if (temp2)
+ delete arg2;
+ }
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
+ PyObject *resultobj = 0;
+ wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
+ wxString *arg2 = 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ bool temp2 = false ;
+ PyObject * obj0 = 0 ;
+ PyObject * obj1 = 0 ;
+ char * kwnames[] = {
+ (char *) "self",(char *) "filename", NULL
+ };
+
+ if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMimeTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
+ }
+ arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
+ {
+ arg2 = wxString_in_helper(obj1);
+ if (arg2 == NULL) SWIG_fail;
+ temp2 = true;
+ }
+ {
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) SWIG_fail;
+ }
+ {
+ resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
+ }
+ {
+ if (temp2)
+ delete arg2;
+ }
+ return resultobj;
+fail:
+ {
+ if (temp2)
+ delete arg2;
+ }
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
+ PyObject *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_EnumAllFileTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
+ }
+ arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
+ {
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) SWIG_fail;
+ }
+ resultobj = result;
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
+ PyObject *resultobj = 0;
+ wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
+ wxFileTypeInfo *arg2 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject * obj0 = 0 ;
+ PyObject * obj1 = 0 ;
+ char * kwnames[] = {
+ (char *) "self",(char *) "ft", NULL
+ };
+
+ if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
+ }
+ arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
+ res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
+ }
+ arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
+ {
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) SWIG_fail;
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_MimeTypesManager_Associate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
+ PyObject *resultobj = 0;
+ wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
+ wxFileTypeInfo *arg2 = 0 ;
+ wxFileType *result = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject * obj0 = 0 ;
+ PyObject * obj1 = 0 ;
+ char * kwnames[] = {
+ (char *) "self",(char *) "ftInfo", NULL
+ };
+
+ if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Associate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
+ }
+ arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
+ res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
+ }
+ arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
+ {
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) SWIG_fail;
+ }
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
+ PyObject *resultobj = 0;
+ wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
+ wxFileType *arg2 = (wxFileType *) 0 ;
+ bool result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject * obj0 = 0 ;
+ PyObject * obj1 = 0 ;
+ char * kwnames[] = {
+ (char *) "self",(char *) "ft", NULL
+ };
+
+ if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
+ }
+ arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
+ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFileType, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "2"" of type '" "wxFileType *""'");
+ }
+ arg2 = reinterpret_cast< wxFileType * >(argp2);
+ {
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ result = (bool)(arg1)->Unassociate(arg2);
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) SWIG_fail;
+ }
+ {
+ resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
+ }
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MimeTypesManager" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
+ }
+ arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
+ {
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ delete arg1;
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) SWIG_fail;
+ }
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *MimeTypesManager_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *obj;
+ if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
+ SWIG_TypeNewClientData(SWIGTYPE_p_wxMimeTypesManager, SWIG_NewClientData(obj));
+ return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *MimeTypesManager_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ return SWIG_Python_InitShadowInstance(args);
+}
+
+SWIGINTERN int ART_TOOLBAR_set(PyObject *) {
+ SWIG_Error(SWIG_AttributeError,"Variable ART_TOOLBAR is read-only.");
+ return 1;
+}
+
+
+SWIGINTERN PyObject *ART_TOOLBAR_get(void) {
+ PyObject *pyobj = 0;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+SWIGINTERN int ART_MENU_set(PyObject *) {
+ SWIG_Error(SWIG_AttributeError,"Variable ART_MENU is read-only.");
+ return 1;
+}
+
+
+SWIGINTERN PyObject *ART_MENU_get(void) {
+ PyObject *pyobj = 0;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+SWIGINTERN int ART_FRAME_ICON_set(PyObject *) {
+ SWIG_Error(SWIG_AttributeError,"Variable ART_FRAME_ICON is read-only.");
+ return 1;
+}
+
+
+SWIGINTERN PyObject *ART_FRAME_ICON_get(void) {
+ PyObject *pyobj = 0;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+SWIGINTERN int ART_CMN_DIALOG_set(PyObject *) {
+ SWIG_Error(SWIG_AttributeError,"Variable ART_CMN_DIALOG is read-only.");
+ return 1;
+}
+
+
+SWIGINTERN PyObject *ART_CMN_DIALOG_get(void) {
+ PyObject *pyobj = 0;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+SWIGINTERN int ART_HELP_BROWSER_set(PyObject *) {
+ SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BROWSER is read-only.");
+ return 1;
+}
+
+
+SWIGINTERN PyObject *ART_HELP_BROWSER_get(void) {
+ PyObject *pyobj = 0;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+SWIGINTERN int ART_MESSAGE_BOX_set(PyObject *) {
+ SWIG_Error(SWIG_AttributeError,"Variable ART_MESSAGE_BOX is read-only.");
+ return 1;
+}
+
+
+SWIGINTERN PyObject *ART_MESSAGE_BOX_get(void) {
+ PyObject *pyobj = 0;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+SWIGINTERN int ART_BUTTON_set(PyObject *) {
+ SWIG_Error(SWIG_AttributeError,"Variable ART_BUTTON is read-only.");
+ return 1;
+}
+
+
+SWIGINTERN PyObject *ART_BUTTON_get(void) {
+ PyObject *pyobj = 0;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+SWIGINTERN int ART_OTHER_set(PyObject *) {
+ SWIG_Error(SWIG_AttributeError,"Variable ART_OTHER is read-only.");
+ return 1;
+}
+
+
+SWIGINTERN PyObject *ART_OTHER_get(void) {
+ PyObject *pyobj = 0;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+SWIGINTERN int ART_ADD_BOOKMARK_set(PyObject *) {
+ SWIG_Error(SWIG_AttributeError,"Variable ART_ADD_BOOKMARK is read-only.");
+ return 1;
+}
+
+
+SWIGINTERN PyObject *ART_ADD_BOOKMARK_get(void) {
+ PyObject *pyobj = 0;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+SWIGINTERN int ART_DEL_BOOKMARK_set(PyObject *) {
+ SWIG_Error(SWIG_AttributeError,"Variable ART_DEL_BOOKMARK is read-only.");
+ return 1;
+}
+
+
+SWIGINTERN PyObject *ART_DEL_BOOKMARK_get(void) {
+ PyObject *pyobj = 0;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+SWIGINTERN int ART_HELP_SIDE_PANEL_set(PyObject *) {
+ SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
+ return 1;
+}
+
+
+SWIGINTERN PyObject *ART_HELP_SIDE_PANEL_get(void) {
+ PyObject *pyobj = 0;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+SWIGINTERN int ART_HELP_SETTINGS_set(PyObject *) {
+ SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SETTINGS is read-only.");
+ return 1;
+}
+
+
+SWIGINTERN PyObject *ART_HELP_SETTINGS_get(void) {
+ PyObject *pyobj = 0;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+SWIGINTERN int ART_HELP_BOOK_set(PyObject *) {
+ SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BOOK is read-only.");
+ return 1;
+}
+
+
+SWIGINTERN PyObject *ART_HELP_BOOK_get(void) {
+ PyObject *pyobj = 0;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+SWIGINTERN int ART_HELP_FOLDER_set(PyObject *) {
+ SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_FOLDER is read-only.");
+ return 1;
+}
+
+
+SWIGINTERN PyObject *ART_HELP_FOLDER_get(void) {
+ PyObject *pyobj = 0;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+SWIGINTERN int ART_HELP_PAGE_set(PyObject *) {
+ SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_PAGE is read-only.");
+ return 1;
+}
+
+
+SWIGINTERN PyObject *ART_HELP_PAGE_get(void) {
+ PyObject *pyobj = 0;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+SWIGINTERN int ART_GO_BACK_set(PyObject *) {
+ SWIG_Error(SWIG_AttributeError,"Variable ART_GO_BACK is read-only.");
+ return 1;
+}
+
+
+SWIGINTERN PyObject *ART_GO_BACK_get(void) {
+ PyObject *pyobj = 0;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+SWIGINTERN int ART_GO_FORWARD_set(PyObject *) {
+ SWIG_Error(SWIG_AttributeError,"Variable ART_GO_FORWARD is read-only.");
+ return 1;
+}
+
+
+SWIGINTERN PyObject *ART_GO_FORWARD_get(void) {
+ PyObject *pyobj = 0;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+SWIGINTERN int ART_GO_UP_set(PyObject *) {
+ SWIG_Error(SWIG_AttributeError,"Variable ART_GO_UP is read-only.");
+ return 1;
+}
+
+
+SWIGINTERN PyObject *ART_GO_UP_get(void) {
+ PyObject *pyobj = 0;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+SWIGINTERN int ART_GO_DOWN_set(PyObject *) {
+ SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DOWN is read-only.");
+ return 1;
+}
+
+
+SWIGINTERN PyObject *ART_GO_DOWN_get(void) {
+ PyObject *pyobj = 0;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+SWIGINTERN int ART_GO_TO_PARENT_set(PyObject *) {
+ SWIG_Error(SWIG_AttributeError,"Variable ART_GO_TO_PARENT is read-only.");
+ return 1;
+}
+
+
+SWIGINTERN PyObject *ART_GO_TO_PARENT_get(void) {
+ PyObject *pyobj = 0;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+SWIGINTERN int ART_GO_HOME_set(PyObject *) {
+ SWIG_Error(SWIG_AttributeError,"Variable ART_GO_HOME is read-only.");
+ return 1;
+}
+
+
+SWIGINTERN PyObject *ART_GO_HOME_get(void) {
+ PyObject *pyobj = 0;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+SWIGINTERN int ART_FILE_OPEN_set(PyObject *) {
+ SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_OPEN is read-only.");
+ return 1;
+}
+
+
+SWIGINTERN PyObject *ART_FILE_OPEN_get(void) {
+ PyObject *pyobj = 0;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+SWIGINTERN int ART_FILE_SAVE_set(PyObject *) {
+ SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE is read-only.");
+ return 1;
+}
+
+
+SWIGINTERN PyObject *ART_FILE_SAVE_get(void) {
+ PyObject *pyobj = 0;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+SWIGINTERN int ART_FILE_SAVE_AS_set(PyObject *) {
+ SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE_AS is read-only.");
+ return 1;
+}
+
+
+SWIGINTERN PyObject *ART_FILE_SAVE_AS_get(void) {
+ PyObject *pyobj = 0;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+SWIGINTERN int ART_PRINT_set(PyObject *) {
+ SWIG_Error(SWIG_AttributeError,"Variable ART_PRINT is read-only.");
+ return 1;
+}
+
+
+SWIGINTERN PyObject *ART_PRINT_get(void) {
+ PyObject *pyobj = 0;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+SWIGINTERN int ART_HELP_set(PyObject *) {
+ SWIG_Error(SWIG_AttributeError,"Variable ART_HELP is read-only.");
+ return 1;
+}
+
+
+SWIGINTERN PyObject *ART_HELP_get(void) {
+ PyObject *pyobj = 0;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+SWIGINTERN int ART_TIP_set(PyObject *) {
+ SWIG_Error(SWIG_AttributeError,"Variable ART_TIP is read-only.");
+ return 1;
+}
+
+
+SWIGINTERN PyObject *ART_TIP_get(void) {
+ PyObject *pyobj = 0;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+SWIGINTERN int ART_REPORT_VIEW_set(PyObject *) {
+ SWIG_Error(SWIG_AttributeError,"Variable ART_REPORT_VIEW is read-only.");
+ return 1;
+}
+
+
+SWIGINTERN PyObject *ART_REPORT_VIEW_get(void) {
+ PyObject *pyobj = 0;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+SWIGINTERN int ART_LIST_VIEW_set(PyObject *) {
+ SWIG_Error(SWIG_AttributeError,"Variable ART_LIST_VIEW is read-only.");
+ return 1;
+}
+
+
+SWIGINTERN PyObject *ART_LIST_VIEW_get(void) {
+ PyObject *pyobj = 0;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+SWIGINTERN int ART_NEW_DIR_set(PyObject *) {
+ SWIG_Error(SWIG_AttributeError,"Variable ART_NEW_DIR is read-only.");
+ return 1;
+}
+
+
+SWIGINTERN PyObject *ART_NEW_DIR_get(void) {
+ PyObject *pyobj = 0;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+SWIGINTERN int ART_HARDDISK_set(PyObject *) {
+ SWIG_Error(SWIG_AttributeError,"Variable ART_HARDDISK is read-only.");
+ return 1;
+}
+
+
+SWIGINTERN PyObject *ART_HARDDISK_get(void) {
+ PyObject *pyobj = 0;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+SWIGINTERN int ART_FLOPPY_set(PyObject *) {
+ SWIG_Error(SWIG_AttributeError,"Variable ART_FLOPPY is read-only.");
+ return 1;
+}
+
+
+SWIGINTERN PyObject *ART_FLOPPY_get(void) {
+ PyObject *pyobj = 0;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+SWIGINTERN int ART_CDROM_set(PyObject *) {
+ SWIG_Error(SWIG_AttributeError,"Variable ART_CDROM is read-only.");
+ return 1;
+}
+
+
+SWIGINTERN PyObject *ART_CDROM_get(void) {
+ PyObject *pyobj = 0;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+SWIGINTERN int ART_REMOVABLE_set(PyObject *) {
+ SWIG_Error(SWIG_AttributeError,"Variable ART_REMOVABLE is read-only.");
+ return 1;
+}
+
+
+SWIGINTERN PyObject *ART_REMOVABLE_get(void) {
+ PyObject *pyobj = 0;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+SWIGINTERN int ART_FOLDER_set(PyObject *) {
+ SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER is read-only.");
+ return 1;
+}
+
+
+SWIGINTERN PyObject *ART_FOLDER_get(void) {
+ PyObject *pyobj = 0;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+SWIGINTERN int ART_FOLDER_OPEN_set(PyObject *) {
+ SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER_OPEN is read-only.");
+ return 1;
+}
+
+
+SWIGINTERN PyObject *ART_FOLDER_OPEN_get(void) {
+ PyObject *pyobj = 0;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+SWIGINTERN int ART_GO_DIR_UP_set(PyObject *) {
+ SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DIR_UP is read-only.");
+ return 1;
+}
+
+
+SWIGINTERN PyObject *ART_GO_DIR_UP_get(void) {
+ PyObject *pyobj = 0;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+SWIGINTERN int ART_EXECUTABLE_FILE_set(PyObject *) {
+ SWIG_Error(SWIG_AttributeError,"Variable ART_EXECUTABLE_FILE is read-only.");
+ return 1;
+}
+
+
+SWIGINTERN PyObject *ART_EXECUTABLE_FILE_get(void) {
+ PyObject *pyobj = 0;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+SWIGINTERN int ART_NORMAL_FILE_set(PyObject *) {
+ SWIG_Error(SWIG_AttributeError,"Variable ART_NORMAL_FILE is read-only.");
+ return 1;
+}
+
+
+SWIGINTERN PyObject *ART_NORMAL_FILE_get(void) {
+ PyObject *pyobj = 0;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+SWIGINTERN int ART_TICK_MARK_set(PyObject *) {
+ SWIG_Error(SWIG_AttributeError,"Variable ART_TICK_MARK is read-only.");
+ return 1;
+}
+
+
+SWIGINTERN PyObject *ART_TICK_MARK_get(void) {
+ PyObject *pyobj = 0;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+SWIGINTERN int ART_CROSS_MARK_set(PyObject *) {
+ SWIG_Error(SWIG_AttributeError,"Variable ART_CROSS_MARK is read-only.");
+ return 1;
+}
+
+
+SWIGINTERN PyObject *ART_CROSS_MARK_get(void) {
+ PyObject *pyobj = 0;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+SWIGINTERN int ART_ERROR_set(PyObject *) {
+ SWIG_Error(SWIG_AttributeError,"Variable ART_ERROR is read-only.");
+ return 1;
+}
+
+
+SWIGINTERN PyObject *ART_ERROR_get(void) {
+ PyObject *pyobj = 0;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+SWIGINTERN int ART_QUESTION_set(PyObject *) {
+ SWIG_Error(SWIG_AttributeError,"Variable ART_QUESTION is read-only.");
+ return 1;
+}
+
+
+SWIGINTERN PyObject *ART_QUESTION_get(void) {
+ PyObject *pyobj = 0;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+SWIGINTERN int ART_WARNING_set(PyObject *) {
+ SWIG_Error(SWIG_AttributeError,"Variable ART_WARNING is read-only.");
+ return 1;
+}
+
+
+SWIGINTERN PyObject *ART_WARNING_get(void) {
+ PyObject *pyobj = 0;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+SWIGINTERN int ART_INFORMATION_set(PyObject *) {
+ SWIG_Error(SWIG_AttributeError,"Variable ART_INFORMATION is read-only.");
+ return 1;
+}
+
+
+SWIGINTERN PyObject *ART_INFORMATION_get(void) {
+ PyObject *pyobj = 0;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+SWIGINTERN int ART_MISSING_IMAGE_set(PyObject *) {
+ SWIG_Error(SWIG_AttributeError,"Variable ART_MISSING_IMAGE is read-only.");
+ return 1;
+}
+
+
+SWIGINTERN PyObject *ART_MISSING_IMAGE_get(void) {
+ PyObject *pyobj = 0;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+SWIGINTERN int ART_COPY_set(PyObject *) {
+ SWIG_Error(SWIG_AttributeError,"Variable ART_COPY is read-only.");
+ return 1;
+}
+
+
+SWIGINTERN PyObject *ART_COPY_get(void) {
+ PyObject *pyobj = 0;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+SWIGINTERN int ART_CUT_set(PyObject *) {
+ SWIG_Error(SWIG_AttributeError,"Variable ART_CUT is read-only.");
+ return 1;
+}
+
+
+SWIGINTERN PyObject *ART_CUT_get(void) {
+ PyObject *pyobj = 0;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+SWIGINTERN int ART_PASTE_set(PyObject *) {
+ SWIG_Error(SWIG_AttributeError,"Variable ART_PASTE is read-only.");
+ return 1;
+}
+
+
+SWIGINTERN PyObject *ART_PASTE_get(void) {
+ PyObject *pyobj = 0;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+SWIGINTERN int ART_DELETE_set(PyObject *) {
+ SWIG_Error(SWIG_AttributeError,"Variable ART_DELETE is read-only.");
+ return 1;
+}
+
+
+SWIGINTERN PyObject *ART_DELETE_get(void) {
+ PyObject *pyobj = 0;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+SWIGINTERN int ART_NEW_set(PyObject *) {
+ SWIG_Error(SWIG_AttributeError,"Variable ART_NEW is read-only.");
+ return 1;
+}
+
+
+SWIGINTERN PyObject *ART_NEW_get(void) {
+ PyObject *pyobj = 0;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+SWIGINTERN int ART_UNDO_set(PyObject *) {
+ SWIG_Error(SWIG_AttributeError,"Variable ART_UNDO is read-only.");
+ return 1;
+}
+
+
+SWIGINTERN PyObject *ART_UNDO_get(void) {
+ PyObject *pyobj = 0;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+SWIGINTERN int ART_REDO_set(PyObject *) {
+ SWIG_Error(SWIG_AttributeError,"Variable ART_REDO is read-only.");
+ return 1;
+}
+
+
+SWIGINTERN PyObject *ART_REDO_get(void) {
+ PyObject *pyobj = 0;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+SWIGINTERN int ART_QUIT_set(PyObject *) {
+ SWIG_Error(SWIG_AttributeError,"Variable ART_QUIT is read-only.");
+ return 1;
+}
+
+
+SWIGINTERN PyObject *ART_QUIT_get(void) {
+ PyObject *pyobj = 0;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+SWIGINTERN int ART_FIND_set(PyObject *) {
+ SWIG_Error(SWIG_AttributeError,"Variable ART_FIND is read-only.");
+ return 1;
+}
+
+
+SWIGINTERN PyObject *ART_FIND_get(void) {
+ PyObject *pyobj = 0;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+SWIGINTERN int ART_FIND_AND_REPLACE_set(PyObject *) {
+ SWIG_Error(SWIG_AttributeError,"Variable ART_FIND_AND_REPLACE is read-only.");
+ return 1;
+}
+
+
+SWIGINTERN PyObject *ART_FIND_AND_REPLACE_get(void) {