kodi: add missing files

srcpkgs/kodi/files/CMakeCache.txt.nojava

@@ -0,0 +1,10 @@
+Java_IDLJ_EXECUTABLE:FILEPATH=/bin/true
+Java_JARSIGNER_EXECUTABLE:FILEPATH=/bin/true
+Java_JAR_EXECUTABLE:FILEPATH=/bin/true
+Java_JAVAC_EXECUTABLE:FILEPATH=/bin/true
+Java_JAVADOC_EXECUTABLE:FILEPATH=/bin/true
+Java_JAVAH_EXECUTABLE:FILEPATH=/bin/true
+Java_JAVA_EXECUTABLE:FILEPATH=/bin/true
+SWIG_EXECUTABLE:FILEPATH=/bin/true
+SWIG_DIR:FILEPATH=/var/empty
+

srcpkgs/kodi/files/swig.nojava-17.1/AddonModuleXbmcaddon.i.cpp

@@ -0,0 +1,496 @@
+
+
+/*
+ *      Copyright (C) 2005-2013 Team XBMC
+ *      http://xbmc.org
+ *
+ *  This Program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2, or (at your option)
+ *  any later version.
+ *
+ *  This Program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with XBMC; see the file COPYING.  If not, write to
+ *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+ *  http://www.gnu.org/copyleft/gpl.html
+ *
+ */
+
+// ************************************************************************
+// This file was generated by xbmc compile process. DO NOT EDIT!!
+//  It was created by running the code generator on the spec file for
+//  the module "xbmcaddon" on the template file PythonSwig.template.cpp
+// ************************************************************************
+
+
+
+#include <Python.h>
+#include <string>
+#include "interfaces/python/LanguageHook.h"
+#include "interfaces/python/swig.h"
+#include "interfaces/python/PyContext.h"
+
+
+#include "interfaces/legacy/Addon.h"
+
+using namespace XBMCAddon;
+using namespace xbmcaddon;
+
+#if defined(__GNUG__) && (__GNUC__>4) || (__GNUC__==4 && __GNUC_MINOR__>=2)
+#pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif
+
+
+
+namespace PythonBindings
+{
+
+  //=========================================================================
+  // These variables will hold the Python Type information for XBMCAddon::xbmcaddon::Addon
+  TypeInfo TyXBMCAddon_xbmcaddon_Addon_Type(typeid(XBMCAddon::xbmcaddon::Addon));
+  //=========================================================================
+
+
+
+  static PyObject* xbmcaddon_XBMCAddon_xbmcaddon_Addon_New (PyTypeObject* pytype  , PyObject *args, PyObject *kwds  )
+  {
+    XBMC_TRACE;
+
+    static const char *keywords[] = {
+          "id",
+          NULL};
+         
+    char * id  = NULL;
+    if (!PyArg_ParseTupleAndKeywords(
+       args,
+       kwds,
+       (char*)"|s",
+       (char**)keywords,
+         &id
+       ))
+    {
+      return NULL;
+    }
+
+    XBMCAddon::xbmcaddon::Addon * apiResult;
+    try
+    {
+
+      XBMCAddon::SetLanguageHookGuard slhg(XBMCAddon::Python::PythonLanguageHook::GetIfExists(PyThreadState_Get()->interp).get());
+      apiResult = (XBMCAddon::xbmcaddon::Addon *)new XBMCAddon::xbmcaddon::Addon(  id  );
+      prepareForReturn(apiResult);
+    }
+    catch (const XBMCAddon::WrongTypeException& e)
+    { 
+      CLog::Log(LOGERROR,"EXCEPTION: %s",e.GetMessage());
+      PyErr_SetString(PyExc_TypeError, e.GetMessage()); 
+      return NULL; 
+    }
+    catch (const XbmcCommons::Exception& e)
+    { 
+      CLog::Log(LOGERROR,"EXCEPTION: %s",e.GetMessage());
+      PyErr_SetString(PyExc_RuntimeError, e.GetMessage()); 
+      return NULL; 
+    }
+    catch (...)
+    {
+      CLog::Log(LOGERROR,"EXCEPTION: Unknown exception thrown from the call \"new XBMCAddon::xbmcaddon::Addon\"");
+      PyErr_SetString(PyExc_RuntimeError, "Unknown exception thrown from the call \"new XBMCAddon::xbmcaddon::Addon\""); 
+      return NULL; 
+    }
+
+    PyObject* result = Py_None;
+
+    // transform the result
+    result = makePythonInstance(apiResult,pytype,false);
+
+    return result; 
+  } 
+
+  static PyObject* xbmcaddon_XBMCAddon_xbmcaddon_Addon_getLocalizedString (PyHolder* self  , PyObject *args, PyObject *kwds  )
+  {
+    XBMC_TRACE;
+
+    static const char *keywords[] = {
+          "id",
+          NULL};
+         
+    int  id ;
+    if (!PyArg_ParseTupleAndKeywords(
+       args,
+       kwds,
+       (char*)"i",
+       (char**)keywords,
+         &id
+       ))
+    {
+      return NULL;
+    }
+
+    std::string  apiResult;
+    try
+    {
+
+      apiResult = (std::string )((XBMCAddon::xbmcaddon::Addon*)retrieveApiInstance((PyObject*)self,&TyXBMCAddon_xbmcaddon_Addon_Type,"getLocalizedString","XBMCAddon::xbmcaddon::Addon"))-> getLocalizedString(  id  );
+
+    }
+    catch (const XBMCAddon::WrongTypeException& e)
+    { 
+      CLog::Log(LOGERROR,"EXCEPTION: %s",e.GetMessage());
+      PyErr_SetString(PyExc_TypeError, e.GetMessage()); 
+      return NULL; 
+    }
+    catch (const XbmcCommons::Exception& e)
+    { 
+      CLog::Log(LOGERROR,"EXCEPTION: %s",e.GetMessage());
+      PyErr_SetString(PyExc_RuntimeError, e.GetMessage()); 
+      return NULL; 
+    }
+    catch (...)
+    {
+      CLog::Log(LOGERROR,"EXCEPTION: Unknown exception thrown from the call \"getLocalizedString\"");
+      PyErr_SetString(PyExc_RuntimeError, "Unknown exception thrown from the call \"getLocalizedString\""); 
+      return NULL; 
+    }
+
+    PyObject* result = Py_None;
+
+    // transform the result
+    result = PyUnicode_DecodeUTF8(apiResult.c_str(),apiResult.size(),"replace");
+
+    return result; 
+  } 
+
+  static PyObject* xbmcaddon_XBMCAddon_xbmcaddon_Addon_getSetting (PyHolder* self  , PyObject *args, PyObject *kwds  )
+  {
+    XBMC_TRACE;
+
+    static const char *keywords[] = {
+          "id",
+          NULL};
+         
+    char * id ;
+    if (!PyArg_ParseTupleAndKeywords(
+       args,
+       kwds,
+       (char*)"s",
+       (char**)keywords,
+         &id
+       ))
+    {
+      return NULL;
+    }
+
+    std::string  apiResult;
+    try
+    {
+
+      apiResult = (std::string )((XBMCAddon::xbmcaddon::Addon*)retrieveApiInstance((PyObject*)self,&TyXBMCAddon_xbmcaddon_Addon_Type,"getSetting","XBMCAddon::xbmcaddon::Addon"))-> getSetting(  id  );
+
+    }
+    catch (const XBMCAddon::WrongTypeException& e)
+    { 
+      CLog::Log(LOGERROR,"EXCEPTION: %s",e.GetMessage());
+      PyErr_SetString(PyExc_TypeError, e.GetMessage()); 
+      return NULL; 
+    }
+    catch (const XbmcCommons::Exception& e)
+    { 
+      CLog::Log(LOGERROR,"EXCEPTION: %s",e.GetMessage());
+      PyErr_SetString(PyExc_RuntimeError, e.GetMessage()); 
+      return NULL; 
+    }
+    catch (...)
+    {
+      CLog::Log(LOGERROR,"EXCEPTION: Unknown exception thrown from the call \"getSetting\"");
+      PyErr_SetString(PyExc_RuntimeError, "Unknown exception thrown from the call \"getSetting\""); 
+      return NULL; 
+    }
+
+    PyObject* result = Py_None;
+
+    // transform the result
+    result = PyString_FromStringAndSize(apiResult.c_str(), apiResult.length());
+
+    return result; 
+  } 
+
+  static PyObject* xbmcaddon_XBMCAddon_xbmcaddon_Addon_setSetting (PyHolder* self  , PyObject *args, PyObject *kwds  )
+  {
+    XBMC_TRACE;
+
+    static const char *keywords[] = {
+          "id",
+          "value",
+          NULL};
+         
+    char * id ;         
+    std::string  value ;
+    PyObject* pyvalue = NULL;
+    if (!PyArg_ParseTupleAndKeywords(
+       args,
+       kwds,
+       (char*)"sO",
+       (char**)keywords,
+         &id,
+         &pyvalue
+       ))
+    {
+      return NULL;
+    }
+
+
+    try
+    {
+      if (pyvalue) PyXBMCGetUnicodeString(value,pyvalue,false,"value","setSetting"); 
+
+      ((XBMCAddon::xbmcaddon::Addon*)retrieveApiInstance((PyObject*)self,&TyXBMCAddon_xbmcaddon_Addon_Type,"setSetting","XBMCAddon::xbmcaddon::Addon"))-> setSetting(  id,  value  );
+
+    }
+    catch (const XBMCAddon::WrongTypeException& e)
+    { 
+      CLog::Log(LOGERROR,"EXCEPTION: %s",e.GetMessage());
+      PyErr_SetString(PyExc_TypeError, e.GetMessage()); 
+      return NULL; 
+    }
+    catch (const XbmcCommons::Exception& e)
+    { 
+      CLog::Log(LOGERROR,"EXCEPTION: %s",e.GetMessage());
+      PyErr_SetString(PyExc_RuntimeError, e.GetMessage()); 
+      return NULL; 
+    }
+    catch (...)
+    {
+      CLog::Log(LOGERROR,"EXCEPTION: Unknown exception thrown from the call \"setSetting\"");
+      PyErr_SetString(PyExc_RuntimeError, "Unknown exception thrown from the call \"setSetting\""); 
+      return NULL; 
+    }
+
+    PyObject* result = Py_None;
+
+    // transform the result
+    Py_INCREF(Py_None);
+    result = Py_None;
+
+    return result; 
+  } 
+
+  static PyObject* xbmcaddon_XBMCAddon_xbmcaddon_Addon_openSettings (PyHolder* self  , PyObject *args, PyObject *kwds  )
+  {
+    XBMC_TRACE;
+
+    try
+    {
+
+      ((XBMCAddon::xbmcaddon::Addon*)retrieveApiInstance((PyObject*)self,&TyXBMCAddon_xbmcaddon_Addon_Type,"openSettings","XBMCAddon::xbmcaddon::Addon"))-> openSettings(  );
+
+    }
+    catch (const XBMCAddon::WrongTypeException& e)
+    { 
+      CLog::Log(LOGERROR,"EXCEPTION: %s",e.GetMessage());
+      PyErr_SetString(PyExc_TypeError, e.GetMessage()); 
+      return NULL; 
+    }
+    catch (const XbmcCommons::Exception& e)
+    { 
+      CLog::Log(LOGERROR,"EXCEPTION: %s",e.GetMessage());
+      PyErr_SetString(PyExc_RuntimeError, e.GetMessage()); 
+      return NULL; 
+    }
+    catch (...)
+    {
+      CLog::Log(LOGERROR,"EXCEPTION: Unknown exception thrown from the call \"openSettings\"");
+      PyErr_SetString(PyExc_RuntimeError, "Unknown exception thrown from the call \"openSettings\""); 
+      return NULL; 
+    }
+
+    PyObject* result = Py_None;
+
+    // transform the result
+    Py_INCREF(Py_None);
+    result = Py_None;
+
+    return result; 
+  } 
+
+  static PyObject* xbmcaddon_XBMCAddon_xbmcaddon_Addon_getAddonInfo (PyHolder* self  , PyObject *args, PyObject *kwds  )
+  {
+    XBMC_TRACE;
+
+    static const char *keywords[] = {
+          "id",
+          NULL};
+         
+    char * id ;
+    if (!PyArg_ParseTupleAndKeywords(
+       args,
+       kwds,
+       (char*)"s",
+       (char**)keywords,
+         &id
+       ))
+    {
+      return NULL;
+    }
+
+    std::string  apiResult;
+    try
+    {
+
+      apiResult = (std::string )((XBMCAddon::xbmcaddon::Addon*)retrieveApiInstance((PyObject*)self,&TyXBMCAddon_xbmcaddon_Addon_Type,"getAddonInfo","XBMCAddon::xbmcaddon::Addon"))-> getAddonInfo(  id  );
+
+    }
+    catch (const XBMCAddon::WrongTypeException& e)
+    { 
+      CLog::Log(LOGERROR,"EXCEPTION: %s",e.GetMessage());
+      PyErr_SetString(PyExc_TypeError, e.GetMessage()); 
+      return NULL; 
+    }
+    catch (const XbmcCommons::Exception& e)
+    { 
+      CLog::Log(LOGERROR,"EXCEPTION: %s",e.GetMessage());
+      PyErr_SetString(PyExc_RuntimeError, e.GetMessage()); 
+      return NULL; 
+    }
+    catch (...)
+    {
+      CLog::Log(LOGERROR,"EXCEPTION: Unknown exception thrown from the call \"getAddonInfo\"");
+      PyErr_SetString(PyExc_RuntimeError, "Unknown exception thrown from the call \"getAddonInfo\""); 
+      return NULL; 
+    }
+
+    PyObject* result = Py_None;
+
+    // transform the result
+    result = PyString_FromStringAndSize(apiResult.c_str(), apiResult.length());
+
+    return result; 
+  } 
+
+  static void xbmcaddon_XBMCAddon_xbmcaddon_Addon_Dealloc (PyHolder* self  )
+  {
+    XBMC_TRACE;
+
+    try
+    {
+
+
+      XBMCAddon::xbmcaddon::Addon* theObj = (XBMCAddon::xbmcaddon::Addon*)retrieveApiInstance((PyObject*)self,&TyXBMCAddon_xbmcaddon_Addon_Type,"~XBMCAddon::xbmcaddon::Addon","XBMCAddon::xbmcaddon::Addon");
+      cleanForDealloc(theObj);
+
+    }
+    catch (const XBMCAddon::WrongTypeException& e)
+    { 
+      CLog::Log(LOGERROR,"EXCEPTION: %s",e.GetMessage());
+      PyErr_SetString(PyExc_TypeError, e.GetMessage()); 
+    }
+    catch (const XbmcCommons::Exception& e)
+    { 
+      CLog::Log(LOGERROR,"EXCEPTION: %s",e.GetMessage());
+      PyErr_SetString(PyExc_RuntimeError, e.GetMessage()); 
+    }
+    catch (...)
+    {
+      CLog::Log(LOGERROR,"EXCEPTION: Unknown exception thrown from the call \"XBMCAddon::xbmcaddon::Addon\"");
+      PyErr_SetString(PyExc_RuntimeError, "Unknown exception thrown from the call \"XBMCAddon::xbmcaddon::Addon\""); 
+    }
+
+    self->ob_type->tp_free((PyObject*)self); 
+    
+  } 
+  //=========================================================================
+  // This section contains the initialization for the
+  // Python extention for the Api class XBMCAddon::xbmcaddon::Addon
+  //=========================================================================
+  // All of the methods on this class
+  static PyMethodDef XBMCAddon_xbmcaddon_Addon_methods[] = { 
+    {(char*)"getLocalizedString", (PyCFunction)xbmcaddon_XBMCAddon_xbmcaddon_Addon_getLocalizedString, METH_VARARGS|METH_KEYWORDS, NULL }, 
+    {(char*)"getSetting", (PyCFunction)xbmcaddon_XBMCAddon_xbmcaddon_Addon_getSetting, METH_VARARGS|METH_KEYWORDS, NULL }, 
+    {(char*)"setSetting", (PyCFunction)xbmcaddon_XBMCAddon_xbmcaddon_Addon_setSetting, METH_VARARGS|METH_KEYWORDS, NULL }, 
+    {(char*)"openSettings", (PyCFunction)xbmcaddon_XBMCAddon_xbmcaddon_Addon_openSettings, METH_VARARGS|METH_KEYWORDS, NULL }, 
+    {(char*)"getAddonInfo", (PyCFunction)xbmcaddon_XBMCAddon_xbmcaddon_Addon_getAddonInfo, METH_VARARGS|METH_KEYWORDS, NULL }, 
+    {NULL, NULL, 0, NULL}
+  };
+
+
+
+  // This method initializes the above mentioned Python Type structure
+  static void initPyXBMCAddon_xbmcaddon_Addon_Type()
+  {
+
+
+    PyTypeObject& pythonType = TyXBMCAddon_xbmcaddon_Addon_Type.pythonType;
+    pythonType.tp_name = (char*)"xbmcaddon.Addon";
+    pythonType.tp_basicsize = sizeof(PyHolder);
+    pythonType.tp_dealloc = (destructor)xbmcaddon_XBMCAddon_xbmcaddon_Addon_Dealloc; 
+
+
+    pythonType.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE;
+
+    pythonType.tp_doc = NULL;
+    pythonType.tp_methods = XBMCAddon_xbmcaddon_Addon_methods; 
+
+    pythonType.tp_base = NULL;
+    pythonType.tp_new = xbmcaddon_XBMCAddon_xbmcaddon_Addon_New;
+
+    TyXBMCAddon_xbmcaddon_Addon_Type.swigType="p.XBMCAddon::xbmcaddon::Addon";
+    registerAddonClassTypeInformation(&TyXBMCAddon_xbmcaddon_Addon_Type);
+
+  }
+  //=========================================================================
+
+
+  static PyMethodDef xbmcaddon_methods[] = { 
+    {NULL, NULL, 0, NULL}
+  };
+
+  // This is the call that will call all of the other initializes 
+  //  for all of the classes in this module
+  static void initTypes()
+  {
+    static bool typesAlreadyInitialized = false;
+    if (!typesAlreadyInitialized)
+    {
+      typesAlreadyInitialized = true;
+
+      initPyXBMCAddon_xbmcaddon_Addon_Type();
+      if (PyType_Ready(&(TyXBMCAddon_xbmcaddon_Addon_Type.pythonType)) < 0)
+        return;
+    }
+  }
+
+  void initModule_xbmcaddon()
+  {
+    initTypes();
+
+    // init general xbmcaddon modules
+    PyObject* module;
+
+
+    Py_INCREF(&(TyXBMCAddon_xbmcaddon_Addon_Type.pythonType));
+
+    module = Py_InitModule((char*)"xbmcaddon", xbmcaddon_methods);
+    if (module == NULL) return;
+
+
+    PyModule_AddObject(module, (char*)"Addon", (PyObject*)(&(TyXBMCAddon_xbmcaddon_Addon_Type.pythonType)));
+
+   // constants
+   PyModule_AddStringConstant(module, (char*)"__author__", (char*)"Team Kodi <http://kodi.tv>");
+   PyModule_AddStringConstant(module, (char*)"__date__", (char*)"Sun May 21 20:33:17 GMT 2017");
+   PyModule_AddStringConstant(module, (char*)"__version__", (char*)"2.25.0");
+   PyModule_AddStringConstant(module, (char*)"__credits__", (char*)"Team Kodi");
+   PyModule_AddStringConstant(module, (char*)"__platform__", (char*)"ALL");
+
+   // need to handle constants
+
+  }
+
+} // end PythonBindings namespace for python type definitions
+
+

srcpkgs/kodi/files/swig.nojava-17.1/AddonModuleXbmcplugin.i.cpp

@@ -0,0 +1,915 @@
+
+
+/*
+ *      Copyright (C) 2005-2013 Team XBMC
+ *      http://xbmc.org
+ *
+ *  This Program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2, or (at your option)
+ *  any later version.
+ *
+ *  This Program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with XBMC; see the file COPYING.  If not, write to
+ *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+ *  http://www.gnu.org/copyleft/gpl.html
+ *
+ */
+
+// ************************************************************************
+// This file was generated by xbmc compile process. DO NOT EDIT!!
+//  It was created by running the code generator on the spec file for
+//  the module "xbmcplugin" on the template file PythonSwig.template.cpp
+// ************************************************************************
+
+
+
+#include <Python.h>
+#include <string>
+#include "interfaces/python/LanguageHook.h"
+#include "interfaces/python/swig.h"
+#include "interfaces/python/PyContext.h"
+
+
+#include "interfaces/legacy/ModuleXbmcplugin.h"
+
+using namespace XBMCAddon;
+using namespace xbmcplugin;
+
+#if defined(__GNUG__) && (__GNUC__>4) || (__GNUC__==4 && __GNUC_MINOR__>=2)
+#pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif
+
+
+
+namespace PythonBindings
+{
+
+  //=========================================================================
+  // These variables define the type XBMCAddon::xbmcgui::ListItem from another module 
+  extern TypeInfo TyXBMCAddon_xbmcgui_ListItem_Type;
+  //=========================================================================
+
+
+
+  static PyObject* xbmcplugin_addDirectoryItem (PyObject* self  , PyObject *args, PyObject *kwds  )
+  {
+    XBMC_TRACE;
+
+    static const char *keywords[] = {
+          "handle",
+          "url",
+          "listitem",
+          "isFolder",
+          "totalItems",
+          NULL};
+         
+    int  handle ;         
+    std::string  url ;
+    PyObject* pyurl = NULL;         
+    XBMCAddon::xbmcgui::ListItem * listitem ;
+    PyObject* pylistitem = NULL;         
+    bool  isFolder  = false;         
+    int  totalItems  = 0;
+    if (!PyArg_ParseTupleAndKeywords(
+       args,
+       kwds,
+       (char*)"iOO|bi",
+       (char**)keywords,
+         &handle,
+         &pyurl,
+         &pylistitem,
+         &isFolder,
+         &totalItems
+       ))
+    {
+      return NULL;
+    }
+
+    bool  apiResult;
+    try
+    {
+      if (pyurl) PyXBMCGetUnicodeString(url,pyurl,false,"url","XBMCAddon::xbmcplugin::addDirectoryItem"); 
+      listitem = (XBMCAddon::xbmcgui::ListItem *)retrieveApiInstance(pylistitem,"p.XBMCAddon::xbmcgui::ListItem","XBMCAddon::xbmcplugin::","XBMCAddon::xbmcplugin::addDirectoryItem"); 
+
+      XBMCAddon::SetLanguageHookGuard slhg(XBMCAddon::Python::PythonLanguageHook::GetIfExists(PyThreadState_Get()->interp).get());
+      apiResult = (bool )XBMCAddon::xbmcplugin::addDirectoryItem(  handle,  url,  listitem,  isFolder,  totalItems  );
+
+    }
+    catch (const XBMCAddon::WrongTypeException& e)
+    { 
+      CLog::Log(LOGERROR,"EXCEPTION: %s",e.GetMessage());
+      PyErr_SetString(PyExc_TypeError, e.GetMessage()); 
+      return NULL; 
+    }
+    catch (const XbmcCommons::Exception& e)
+    { 
+      CLog::Log(LOGERROR,"EXCEPTION: %s",e.GetMessage());
+      PyErr_SetString(PyExc_RuntimeError, e.GetMessage()); 
+      return NULL; 
+    }
+    catch (...)
+    {
+      CLog::Log(LOGERROR,"EXCEPTION: Unknown exception thrown from the call \"XBMCAddon::xbmcplugin::addDirectoryItem\"");
+      PyErr_SetString(PyExc_RuntimeError, "Unknown exception thrown from the call \"XBMCAddon::xbmcplugin::addDirectoryItem\""); 
+      return NULL; 
+    }
+
+    PyObject* result = Py_None;
+
+    // transform the result
+    result = Py_BuildValue((char*)"b", apiResult);
+
+    return result; 
+  } 
+
+  static PyObject* xbmcplugin_addDirectoryItems (PyObject* self  , PyObject *args, PyObject *kwds  )
+  {
+    XBMC_TRACE;
+
+    static const char *keywords[] = {
+          "handle",
+          "items",
+          "totalItems",
+          NULL};
+         
+    int  handle ;         
+    std::vector< Tuple< XBMCAddon::String ,XBMCAddon::xbmcgui::ListItem const *,bool  >  >  items ;
+    PyObject* pyitems = NULL;         
+    int  totalItems  = 0;
+    if (!PyArg_ParseTupleAndKeywords(
+       args,
+       kwds,
+       (char*)"iO|i",
+       (char**)keywords,
+         &handle,
+         &pyitems,
+         &totalItems
+       ))
+    {
+      return NULL;
+    }
+
+    bool  apiResult;
+    try
+    {
+      
+    if (pyitems)
+    {
+      bool isTuple = PyObject_TypeCheck(pyitems,&PyTuple_Type);
+      if (!isTuple && !PyObject_TypeCheck(pyitems,&PyList_Type))
+        throw WrongTypeException("The parameter \"items\" must be either a Tuple or a List.");
+
+      
+      PyObject *pyentry1 = NULL;
+      int vecSize = (isTuple ? PyTuple_Size(pyitems) : PyList_Size(pyitems));
+      for(int i = 0; i < vecSize; i++)
+      {
+        pyentry1 = (isTuple ? PyTuple_GetItem(pyitems, i) : PyList_GetItem(pyitems, i));
+        Tuple< XBMCAddon::String ,XBMCAddon::xbmcgui::ListItem const *,bool  >  entry1;
+        
+    if(pyentry1)
+    {
+      bool isTuple = PyObject_TypeCheck(pyentry1,&PyTuple_Type);
+      if (!isTuple && !PyObject_TypeCheck(pyentry1,&PyList_Type))
+        throw WrongTypeException("The parameter \"entry1\" must be either a Tuple or a List.");
+      int vecSize = (isTuple ? PyTuple_Size(pyentry1) : PyList_Size(pyentry1));
+
+      if (vecSize > 0)
+      {
+        PyObject *pyentry0_2 = NULL;
+        pyentry0_2 = (isTuple ? PyTuple_GetItem(pyentry1, 0) : PyList_GetItem(pyentry1, 0));
+        std::string  entry0_2;
+        if (pyentry0_2) PyXBMCGetUnicodeString(entry0_2,pyentry0_2,false,"entry0_2","XBMCAddon::xbmcplugin::addDirectoryItems");
+        entry1.first() = entry0_2;
+      }
+
+      if (vecSize > 1)
+      {
+        PyObject *pyentry1_2 = NULL;
+        pyentry1_2 = (isTuple ? PyTuple_GetItem(pyentry1, 1) : PyList_GetItem(pyentry1, 1));
+        XBMCAddon::xbmcgui::ListItem * entry1_2;
+        entry1_2 = (XBMCAddon::xbmcgui::ListItem *)retrieveApiInstance(pyentry1_2,"p.XBMCAddon::xbmcgui::ListItem","XBMCAddon::xbmcplugin::","XBMCAddon::xbmcplugin::addDirectoryItems");
+        entry1.second() = entry1_2;
+      }
+
+      if (vecSize > 2)
+      {
+        PyObject *pyentry2_2 = NULL;
+        pyentry2_2 = (isTuple ? PyTuple_GetItem(pyentry1, 2) : PyList_GetItem(pyentry1, 2));
+        bool  entry2_2;
+        entry2_2 = (PyInt_AsLong(pyentry2_2) == 0L ? false : true);
+        entry1.third() = entry2_2;
+      }
+
+    }
+
+        items.push_back(entry1);
+      }
+    }
+ 
+
+      XBMCAddon::SetLanguageHookGuard slhg(XBMCAddon::Python::PythonLanguageHook::GetIfExists(PyThreadState_Get()->interp).get());
+      apiResult = (bool )XBMCAddon::xbmcplugin::addDirectoryItems(  handle,  items,  totalItems  );
+
+    }
+    catch (const XBMCAddon::WrongTypeException& e)
+    { 
+      CLog::Log(LOGERROR,"EXCEPTION: %s",e.GetMessage());
+      PyErr_SetString(PyExc_TypeError, e.GetMessage()); 
+      return NULL; 
+    }
+    catch (const XbmcCommons::Exception& e)
+    { 
+      CLog::Log(LOGERROR,"EXCEPTION: %s",e.GetMessage());
+      PyErr_SetString(PyExc_RuntimeError, e.GetMessage()); 
+      return NULL; 
+    }
+    catch (...)
+    {
+      CLog::Log(LOGERROR,"EXCEPTION: Unknown exception thrown from the call \"XBMCAddon::xbmcplugin::addDirectoryItems\"");
+      PyErr_SetString(PyExc_RuntimeError, "Unknown exception thrown from the call \"XBMCAddon::xbmcplugin::addDirectoryItems\""); 
+      return NULL; 
+    }
+
+    PyObject* result = Py_None;
+
+    // transform the result
+    result = Py_BuildValue((char*)"b", apiResult);
+
+    return result; 
+  } 
+
+  static PyObject* xbmcplugin_endOfDirectory (PyObject* self  , PyObject *args, PyObject *kwds  )
+  {
+    XBMC_TRACE;
+
+    static const char *keywords[] = {
+          "handle",
+          "succeeded",
+          "updateListing",
+          "cacheToDisc",
+          NULL};
+         
+    int  handle ;         
+    bool  succeeded  = true;         
+    bool  updateListing  = false;         
+    bool  cacheToDisc  = true;
+    if (!PyArg_ParseTupleAndKeywords(
+       args,
+       kwds,
+       (char*)"i|bbb",
+       (char**)keywords,
+         &handle,
+         &succeeded,
+         &updateListing,
+         &cacheToDisc
+       ))
+    {
+      return NULL;
+    }
+
+
+    try
+    {
+
+      XBMCAddon::SetLanguageHookGuard slhg(XBMCAddon::Python::PythonLanguageHook::GetIfExists(PyThreadState_Get()->interp).get());
+      XBMCAddon::xbmcplugin::endOfDirectory(  handle,  succeeded,  updateListing,  cacheToDisc  );
+
+    }
+    catch (const XBMCAddon::WrongTypeException& e)
+    { 
+      CLog::Log(LOGERROR,"EXCEPTION: %s",e.GetMessage());
+      PyErr_SetString(PyExc_TypeError, e.GetMessage()); 
+      return NULL; 
+    }
+    catch (const XbmcCommons::Exception& e)
+    { 
+      CLog::Log(LOGERROR,"EXCEPTION: %s",e.GetMessage());
+      PyErr_SetString(PyExc_RuntimeError, e.GetMessage()); 
+      return NULL; 
+    }
+    catch (...)
+    {
+      CLog::Log(LOGERROR,"EXCEPTION: Unknown exception thrown from the call \"XBMCAddon::xbmcplugin::endOfDirectory\"");
+      PyErr_SetString(PyExc_RuntimeError, "Unknown exception thrown from the call \"XBMCAddon::xbmcplugin::endOfDirectory\""); 
+      return NULL; 
+    }
+
+    PyObject* result = Py_None;
+
+    // transform the result
+    Py_INCREF(Py_None);
+    result = Py_None;
+
+    return result; 
+  } 
+
+  static PyObject* xbmcplugin_setResolvedUrl (PyObject* self  , PyObject *args, PyObject *kwds  )
+  {
+    XBMC_TRACE;
+
+    static const char *keywords[] = {
+          "handle",
+          "succeeded",
+          "listitem",
+          NULL};
+         
+    int  handle ;         
+    bool  succeeded ;         
+    XBMCAddon::xbmcgui::ListItem * listitem ;
+    PyObject* pylistitem = NULL;
+    if (!PyArg_ParseTupleAndKeywords(
+       args,
+       kwds,
+       (char*)"ibO",
+       (char**)keywords,
+         &handle,
+         &succeeded,
+         &pylistitem
+       ))
+    {
+      return NULL;
+    }
+
+
+    try
+    {
+      listitem = (XBMCAddon::xbmcgui::ListItem *)retrieveApiInstance(pylistitem,"p.XBMCAddon::xbmcgui::ListItem","XBMCAddon::xbmcplugin::","XBMCAddon::xbmcplugin::setResolvedUrl"); 
+
+      XBMCAddon::SetLanguageHookGuard slhg(XBMCAddon::Python::PythonLanguageHook::GetIfExists(PyThreadState_Get()->interp).get());
+      XBMCAddon::xbmcplugin::setResolvedUrl(  handle,  succeeded,  listitem  );
+
+    }
+    catch (const XBMCAddon::WrongTypeException& e)
+    { 
+      CLog::Log(LOGERROR,"EXCEPTION: %s",e.GetMessage());
+      PyErr_SetString(PyExc_TypeError, e.GetMessage()); 
+      return NULL; 
+    }
+    catch (const XbmcCommons::Exception& e)
+    { 
+      CLog::Log(LOGERROR,"EXCEPTION: %s",e.GetMessage());
+      PyErr_SetString(PyExc_RuntimeError, e.GetMessage()); 
+      return NULL; 
+    }
+    catch (...)
+    {
+      CLog::Log(LOGERROR,"EXCEPTION: Unknown exception thrown from the call \"XBMCAddon::xbmcplugin::setResolvedUrl\"");
+      PyErr_SetString(PyExc_RuntimeError, "Unknown exception thrown from the call \"XBMCAddon::xbmcplugin::setResolvedUrl\""); 
+      return NULL; 
+    }
+
+    PyObject* result = Py_None;
+
+    // transform the result
+    Py_INCREF(Py_None);
+    result = Py_None;
+
+    return result; 
+  } 
+
+  static PyObject* xbmcplugin_addSortMethod (PyObject* self  , PyObject *args, PyObject *kwds  )
+  {
+    XBMC_TRACE;
+
+    static const char *keywords[] = {
+          "handle",
+          "sortMethod",
+          "label2Mask",
+          NULL};
+         
+    int  handle ;         
+    int  sortMethod ;         
+    std::string  label2Mask  = XBMCAddon::emptyString;
+    PyObject* pylabel2Mask = NULL;
+    if (!PyArg_ParseTupleAndKeywords(
+       args,
+       kwds,
+       (char*)"ii|O",
+       (char**)keywords,
+         &handle,
+         &sortMethod,
+         &pylabel2Mask
+       ))
+    {
+      return NULL;
+    }
+
+
+    try
+    {
+      if (pylabel2Mask) PyXBMCGetUnicodeString(label2Mask,pylabel2Mask,false,"label2Mask","XBMCAddon::xbmcplugin::addSortMethod"); 
+
+      XBMCAddon::SetLanguageHookGuard slhg(XBMCAddon::Python::PythonLanguageHook::GetIfExists(PyThreadState_Get()->interp).get());
+      XBMCAddon::xbmcplugin::addSortMethod(  handle,  sortMethod,  label2Mask  );
+
+    }
+    catch (const XBMCAddon::WrongTypeException& e)
+    { 
+      CLog::Log(LOGERROR,"EXCEPTION: %s",e.GetMessage());
+      PyErr_SetString(PyExc_TypeError, e.GetMessage()); 
+      return NULL; 
+    }
+    catch (const XbmcCommons::Exception& e)
+    { 
+      CLog::Log(LOGERROR,"EXCEPTION: %s",e.GetMessage());
+      PyErr_SetString(PyExc_RuntimeError, e.GetMessage()); 
+      return NULL; 
+    }
+    catch (...)
+    {
+      CLog::Log(LOGERROR,"EXCEPTION: Unknown exception thrown from the call \"XBMCAddon::xbmcplugin::addSortMethod\"");
+      PyErr_SetString(PyExc_RuntimeError, "Unknown exception thrown from the call \"XBMCAddon::xbmcplugin::addSortMethod\""); 
+      return NULL; 
+    }
+
+    PyObject* result = Py_None;
+
+    // transform the result
+    Py_INCREF(Py_None);
+    result = Py_None;
+
+    return result; 
+  } 
+
+  static PyObject* xbmcplugin_getSetting (PyObject* self  , PyObject *args, PyObject *kwds  )
+  {
+    XBMC_TRACE;
+
+    static const char *keywords[] = {
+          "handle",
+          "id",
+          NULL};
+         
+    int  handle ;         
+    char * id ;
+    if (!PyArg_ParseTupleAndKeywords(
+       args,
+       kwds,
+       (char*)"is",
+       (char**)keywords,
+         &handle,
+         &id
+       ))
+    {
+      return NULL;
+    }
+
+    std::string  apiResult;
+    try
+    {
+
+      XBMCAddon::SetLanguageHookGuard slhg(XBMCAddon::Python::PythonLanguageHook::GetIfExists(PyThreadState_Get()->interp).get());
+      apiResult = (std::string )XBMCAddon::xbmcplugin::getSetting(  handle,  id  );
+
+    }
+    catch (const XBMCAddon::WrongTypeException& e)
+    { 
+      CLog::Log(LOGERROR,"EXCEPTION: %s",e.GetMessage());
+      PyErr_SetString(PyExc_TypeError, e.GetMessage()); 
+      return NULL; 
+    }
+    catch (const XbmcCommons::Exception& e)
+    { 
+      CLog::Log(LOGERROR,"EXCEPTION: %s",e.GetMessage());
+      PyErr_SetString(PyExc_RuntimeError, e.GetMessage()); 
+      return NULL; 
+    }
+    catch (...)
+    {
+      CLog::Log(LOGERROR,"EXCEPTION: Unknown exception thrown from the call \"XBMCAddon::xbmcplugin::getSetting\"");
+      PyErr_SetString(PyExc_RuntimeError, "Unknown exception thrown from the call \"XBMCAddon::xbmcplugin::getSetting\""); 
+      return NULL; 
+    }
+
+    PyObject* result = Py_None;
+
+    // transform the result
+    result = PyString_FromStringAndSize(apiResult.c_str(), apiResult.length());
+
+    return result; 
+  } 
+
+  static PyObject* xbmcplugin_setSetting (PyObject* self  , PyObject *args, PyObject *kwds  )
+  {
+    XBMC_TRACE;
+
+    static const char *keywords[] = {
+          "handle",
+          "id",
+          "value",
+          NULL};
+         
+    int  handle ;         
+    std::string  id ;
+    PyObject* pyid = NULL;         
+    std::string  value ;
+    PyObject* pyvalue = NULL;
+    if (!PyArg_ParseTupleAndKeywords(
+       args,
+       kwds,
+       (char*)"iOO",
+       (char**)keywords,
+         &handle,
+         &pyid,
+         &pyvalue
+       ))
+    {
+      return NULL;
+    }
+
+
+    try
+    {
+      if (pyid) PyXBMCGetUnicodeString(id,pyid,false,"id","XBMCAddon::xbmcplugin::setSetting"); 
+      if (pyvalue) PyXBMCGetUnicodeString(value,pyvalue,false,"value","XBMCAddon::xbmcplugin::setSetting"); 
+
+      XBMCAddon::SetLanguageHookGuard slhg(XBMCAddon::Python::PythonLanguageHook::GetIfExists(PyThreadState_Get()->interp).get());
+      XBMCAddon::xbmcplugin::setSetting(  handle,  id,  value  );
+
+    }
+    catch (const XBMCAddon::WrongTypeException& e)
+    { 
+      CLog::Log(LOGERROR,"EXCEPTION: %s",e.GetMessage());
+      PyErr_SetString(PyExc_TypeError, e.GetMessage()); 
+      return NULL; 
+    }
+    catch (const XbmcCommons::Exception& e)
+    { 
+      CLog::Log(LOGERROR,"EXCEPTION: %s",e.GetMessage());
+      PyErr_SetString(PyExc_RuntimeError, e.GetMessage()); 
+      return NULL; 
+    }
+    catch (...)
+    {
+      CLog::Log(LOGERROR,"EXCEPTION: Unknown exception thrown from the call \"XBMCAddon::xbmcplugin::setSetting\"");
+      PyErr_SetString(PyExc_RuntimeError, "Unknown exception thrown from the call \"XBMCAddon::xbmcplugin::setSetting\""); 
+      return NULL; 
+    }
+
+    PyObject* result = Py_None;
+
+    // transform the result
+    Py_INCREF(Py_None);
+    result = Py_None;
+
+    return result; 
+  } 
+
+  static PyObject* xbmcplugin_setContent (PyObject* self  , PyObject *args, PyObject *kwds  )
+  {
+    XBMC_TRACE;
+
+    static const char *keywords[] = {
+          "handle",
+          "content",
+          NULL};
+         
+    int  handle ;         
+    char * content ;
+    if (!PyArg_ParseTupleAndKeywords(
+       args,
+       kwds,
+       (char*)"is",
+       (char**)keywords,
+         &handle,
+         &content
+       ))
+    {
+      return NULL;
+    }
+
+
+    try
+    {
+
+      XBMCAddon::SetLanguageHookGuard slhg(XBMCAddon::Python::PythonLanguageHook::GetIfExists(PyThreadState_Get()->interp).get());
+      XBMCAddon::xbmcplugin::setContent(  handle,  content  );
+
+    }
+    catch (const XBMCAddon::WrongTypeException& e)
+    { 
+      CLog::Log(LOGERROR,"EXCEPTION: %s",e.GetMessage());
+      PyErr_SetString(PyExc_TypeError, e.GetMessage()); 
+      return NULL; 
+    }
+    catch (const XbmcCommons::Exception& e)
+    { 
+      CLog::Log(LOGERROR,"EXCEPTION: %s",e.GetMessage());
+      PyErr_SetString(PyExc_RuntimeError, e.GetMessage()); 
+      return NULL; 
+    }
+    catch (...)
+    {
+      CLog::Log(LOGERROR,"EXCEPTION: Unknown exception thrown from the call \"XBMCAddon::xbmcplugin::setContent\"");
+      PyErr_SetString(PyExc_RuntimeError, "Unknown exception thrown from the call \"XBMCAddon::xbmcplugin::setContent\""); 
+      return NULL; 
+    }
+
+    PyObject* result = Py_None;
+
+    // transform the result
+    Py_INCREF(Py_None);
+    result = Py_None;
+
+    return result; 
+  } 
+
+  static PyObject* xbmcplugin_setPluginCategory (PyObject* self  , PyObject *args, PyObject *kwds  )
+  {
+    XBMC_TRACE;
+
+    static const char *keywords[] = {
+          "handle",
+          "category",
+          NULL};
+         
+    int  handle ;         
+    std::string  category ;
+    PyObject* pycategory = NULL;
+    if (!PyArg_ParseTupleAndKeywords(
+       args,
+       kwds,
+       (char*)"iO",
+       (char**)keywords,
+         &handle,
+         &pycategory
+       ))
+    {
+      return NULL;
+    }
+
+
+    try
+    {
+      if (pycategory) PyXBMCGetUnicodeString(category,pycategory,false,"category","XBMCAddon::xbmcplugin::setPluginCategory"); 
+
+      XBMCAddon::SetLanguageHookGuard slhg(XBMCAddon::Python::PythonLanguageHook::GetIfExists(PyThreadState_Get()->interp).get());
+      XBMCAddon::xbmcplugin::setPluginCategory(  handle,  category  );
+
+    }
+    catch (const XBMCAddon::WrongTypeException& e)
+    { 
+      CLog::Log(LOGERROR,"EXCEPTION: %s",e.GetMessage());
+      PyErr_SetString(PyExc_TypeError, e.GetMessage()); 
+      return NULL; 
+    }
+    catch (const XbmcCommons::Exception& e)
+    { 
+      CLog::Log(LOGERROR,"EXCEPTION: %s",e.GetMessage());
+      PyErr_SetString(PyExc_RuntimeError, e.GetMessage()); 
+      return NULL; 
+    }
+    catch (...)
+    {
+      CLog::Log(LOGERROR,"EXCEPTION: Unknown exception thrown from the call \"XBMCAddon::xbmcplugin::setPluginCategory\"");
+      PyErr_SetString(PyExc_RuntimeError, "Unknown exception thrown from the call \"XBMCAddon::xbmcplugin::setPluginCategory\""); 
+      return NULL; 
+    }
+
+    PyObject* result = Py_None;
+
+    // transform the result
+    Py_INCREF(Py_None);
+    result = Py_None;
+
+    return result; 
+  } 
+
+  static PyObject* xbmcplugin_setPluginFanart (PyObject* self  , PyObject *args, PyObject *kwds  )
+  {
+    XBMC_TRACE;
+
+    static const char *keywords[] = {
+          "handle",
+          "image",
+          "color1",
+          "color2",
+          "color3",
+          NULL};
+         
+    int  handle ;         
+    char * image  = NULL;         
+    char * color1  = NULL;         
+    char * color2  = NULL;         
+    char * color3  = NULL;
+    if (!PyArg_ParseTupleAndKeywords(
+       args,
+       kwds,
+       (char*)"i|ssss",
+       (char**)keywords,
+         &handle,
+         &image,
+         &color1,
+         &color2,
+         &color3
+       ))
+    {
+      return NULL;
+    }
+
+
+    try
+    {
+
+      XBMCAddon::SetLanguageHookGuard slhg(XBMCAddon::Python::PythonLanguageHook::GetIfExists(PyThreadState_Get()->interp).get());
+      XBMCAddon::xbmcplugin::setPluginFanart(  handle,  image,  color1,  color2,  color3  );
+
+    }
+    catch (const XBMCAddon::WrongTypeException& e)
+    { 
+      CLog::Log(LOGERROR,"EXCEPTION: %s",e.GetMessage());
+      PyErr_SetString(PyExc_TypeError, e.GetMessage()); 
+      return NULL; 
+    }
+    catch (const XbmcCommons::Exception& e)
+    { 
+      CLog::Log(LOGERROR,"EXCEPTION: %s",e.GetMessage());
+      PyErr_SetString(PyExc_RuntimeError, e.GetMessage()); 
+      return NULL; 
+    }
+    catch (...)
+    {
+      CLog::Log(LOGERROR,"EXCEPTION: Unknown exception thrown from the call \"XBMCAddon::xbmcplugin::setPluginFanart\"");
+      PyErr_SetString(PyExc_RuntimeError, "Unknown exception thrown from the call \"XBMCAddon::xbmcplugin::setPluginFanart\""); 
+      return NULL; 
+    }
+
+    PyObject* result = Py_None;
+
+    // transform the result
+    Py_INCREF(Py_None);
+    result = Py_None;
+
+    return result; 
+  } 
+
+  static PyObject* xbmcplugin_setProperty (PyObject* self  , PyObject *args, PyObject *kwds  )
+  {
+    XBMC_TRACE;
+
+    static const char *keywords[] = {
+          "handle",
+          "key",
+          "value",
+          NULL};
+         
+    int  handle ;         
+    char * key ;         
+    std::string  value ;
+    PyObject* pyvalue = NULL;
+    if (!PyArg_ParseTupleAndKeywords(
+       args,
+       kwds,
+       (char*)"isO",
+       (char**)keywords,
+         &handle,
+         &key,
+         &pyvalue
+       ))
+    {
+      return NULL;
+    }
+
+
+    try
+    {
+      if (pyvalue) PyXBMCGetUnicodeString(value,pyvalue,false,"value","XBMCAddon::xbmcplugin::setProperty"); 
+
+      XBMCAddon::SetLanguageHookGuard slhg(XBMCAddon::Python::PythonLanguageHook::GetIfExists(PyThreadState_Get()->interp).get());
+      XBMCAddon::xbmcplugin::setProperty(  handle,  key,  value  );
+
+    }
+    catch (const XBMCAddon::WrongTypeException& e)
+    { 
+      CLog::Log(LOGERROR,"EXCEPTION: %s",e.GetMessage());
+      PyErr_SetString(PyExc_TypeError, e.GetMessage()); 
+      return NULL; 
+    }
+    catch (const XbmcCommons::Exception& e)
+    { 
+      CLog::Log(LOGERROR,"EXCEPTION: %s",e.GetMessage());
+      PyErr_SetString(PyExc_RuntimeError, e.GetMessage()); 
+      return NULL; 
+    }
+    catch (...)
+    {
+      CLog::Log(LOGERROR,"EXCEPTION: Unknown exception thrown from the call \"XBMCAddon::xbmcplugin::setProperty\"");
+      PyErr_SetString(PyExc_RuntimeError, "Unknown exception thrown from the call \"XBMCAddon::xbmcplugin::setProperty\""); 
+      return NULL; 
+    }
+
+    PyObject* result = Py_None;
+
+    // transform the result
+    Py_INCREF(Py_None);
+    result = Py_None;
+
+    return result; 
+  } 
+
+
+  static PyMethodDef xbmcplugin_methods[] = { 
+    {(char*)"addDirectoryItem", (PyCFunction)xbmcplugin_addDirectoryItem, METH_VARARGS|METH_KEYWORDS, NULL }, 
+    {(char*)"addDirectoryItems", (PyCFunction)xbmcplugin_addDirectoryItems, METH_VARARGS|METH_KEYWORDS, NULL }, 
+    {(char*)"endOfDirectory", (PyCFunction)xbmcplugin_endOfDirectory, METH_VARARGS|METH_KEYWORDS, NULL }, 
+    {(char*)"setResolvedUrl", (PyCFunction)xbmcplugin_setResolvedUrl, METH_VARARGS|METH_KEYWORDS, NULL }, 
+    {(char*)"addSortMethod", (PyCFunction)xbmcplugin_addSortMethod, METH_VARARGS|METH_KEYWORDS, NULL }, 
+    {(char*)"getSetting", (PyCFunction)xbmcplugin_getSetting, METH_VARARGS|METH_KEYWORDS, NULL }, 
+    {(char*)"setSetting", (PyCFunction)xbmcplugin_setSetting, METH_VARARGS|METH_KEYWORDS, NULL }, 
+    {(char*)"setContent", (PyCFunction)xbmcplugin_setContent, METH_VARARGS|METH_KEYWORDS, NULL }, 
+    {(char*)"setPluginCategory", (PyCFunction)xbmcplugin_setPluginCategory, METH_VARARGS|METH_KEYWORDS, NULL }, 
+    {(char*)"setPluginFanart", (PyCFunction)xbmcplugin_setPluginFanart, METH_VARARGS|METH_KEYWORDS, NULL }, 
+    {(char*)"setProperty", (PyCFunction)xbmcplugin_setProperty, METH_VARARGS|METH_KEYWORDS, NULL }, 
+    {NULL, NULL, 0, NULL}
+  };
+
+  // This is the call that will call all of the other initializes 
+  //  for all of the classes in this module
+  static void initTypes()
+  {
+    static bool typesAlreadyInitialized = false;
+    if (!typesAlreadyInitialized)
+    {
+      typesAlreadyInitialized = true;
+
+    }
+  }
+
+  void initModule_xbmcplugin()
+  {
+    initTypes();
+
+    // init general xbmcplugin modules
+    PyObject* module;
+
+
+
+    module = Py_InitModule((char*)"xbmcplugin", xbmcplugin_methods);
+    if (module == NULL) return;
+
+
+
+   // constants
+   PyModule_AddStringConstant(module, (char*)"__author__", (char*)"Team Kodi <http://kodi.tv>");
+   PyModule_AddStringConstant(module, (char*)"__date__", (char*)"Sun May 21 20:33:31 GMT 2017");
+   PyModule_AddStringConstant(module, (char*)"__version__", (char*)"2.25.0");
+   PyModule_AddStringConstant(module, (char*)"__credits__", (char*)"Team Kodi");
+   PyModule_AddStringConstant(module, (char*)"__platform__", (char*)"ALL");
+
+   // need to handle constants
+
+   PyModule_AddIntConstant(module,"SORT_METHOD_NONE",SORT_METHOD_NONE); 
+   PyModule_AddIntConstant(module,"SORT_METHOD_LABEL",SORT_METHOD_LABEL); 
+   PyModule_AddIntConstant(module,"SORT_METHOD_LABEL_IGNORE_THE",SORT_METHOD_LABEL_IGNORE_THE); 
+   PyModule_AddIntConstant(module,"SORT_METHOD_DATE",SORT_METHOD_DATE); 
+   PyModule_AddIntConstant(module,"SORT_METHOD_SIZE",SORT_METHOD_SIZE); 
+   PyModule_AddIntConstant(module,"SORT_METHOD_FILE",SORT_METHOD_FILE); 
+   PyModule_AddIntConstant(module,"SORT_METHOD_DRIVE_TYPE",SORT_METHOD_DRIVE_TYPE); 
+   PyModule_AddIntConstant(module,"SORT_METHOD_TRACKNUM",SORT_METHOD_TRACKNUM); 
+   PyModule_AddIntConstant(module,"SORT_METHOD_DURATION",SORT_METHOD_DURATION); 
+   PyModule_AddIntConstant(module,"SORT_METHOD_TITLE",SORT_METHOD_TITLE); 
+   PyModule_AddIntConstant(module,"SORT_METHOD_TITLE_IGNORE_THE",SORT_METHOD_TITLE_IGNORE_THE); 
+   PyModule_AddIntConstant(module,"SORT_METHOD_ARTIST",SORT_METHOD_ARTIST); 
+   PyModule_AddIntConstant(module,"SORT_METHOD_ARTIST_IGNORE_THE",SORT_METHOD_ARTIST_IGNORE_THE); 
+   PyModule_AddIntConstant(module,"SORT_METHOD_ALBUM",SORT_METHOD_ALBUM); 
+   PyModule_AddIntConstant(module,"SORT_METHOD_ALBUM_IGNORE_THE",SORT_METHOD_ALBUM_IGNORE_THE); 
+   PyModule_AddIntConstant(module,"SORT_METHOD_GENRE",SORT_METHOD_GENRE); 
+   PyModule_AddIntConstant(module,"SORT_METHOD_VIDEO_YEAR",SORT_METHOD_YEAR); 
+   PyModule_AddIntConstant(module,"SORT_METHOD_VIDEO_RATING",SORT_METHOD_VIDEO_RATING); 
+   PyModule_AddIntConstant(module,"SORT_METHOD_PROGRAM_COUNT",SORT_METHOD_PROGRAM_COUNT); 
+   PyModule_AddIntConstant(module,"SORT_METHOD_PLAYLIST_ORDER",SORT_METHOD_PLAYLIST_ORDER); 
+   PyModule_AddIntConstant(module,"SORT_METHOD_EPISODE",SORT_METHOD_EPISODE); 
+   PyModule_AddIntConstant(module,"SORT_METHOD_VIDEO_TITLE",SORT_METHOD_VIDEO_TITLE); 
+   PyModule_AddIntConstant(module,"SORT_METHOD_VIDEO_SORT_TITLE",SORT_METHOD_VIDEO_SORT_TITLE); 
+   PyModule_AddIntConstant(module,"SORT_METHOD_VIDEO_SORT_TITLE_IGNORE_THE",SORT_METHOD_VIDEO_SORT_TITLE_IGNORE_THE); 
+   PyModule_AddIntConstant(module,"SORT_METHOD_PRODUCTIONCODE",SORT_METHOD_PRODUCTIONCODE); 
+   PyModule_AddIntConstant(module,"SORT_METHOD_SONG_RATING",SORT_METHOD_SONG_RATING); 
+   PyModule_AddIntConstant(module,"SORT_METHOD_MPAA_RATING",SORT_METHOD_MPAA_RATING); 
+   PyModule_AddIntConstant(module,"SORT_METHOD_VIDEO_RUNTIME",SORT_METHOD_VIDEO_RUNTIME); 
+   PyModule_AddIntConstant(module,"SORT_METHOD_STUDIO",SORT_METHOD_STUDIO); 
+   PyModule_AddIntConstant(module,"SORT_METHOD_STUDIO_IGNORE_THE",SORT_METHOD_STUDIO_IGNORE_THE); 
+   PyModule_AddIntConstant(module,"SORT_METHOD_UNSORTED",SORT_METHOD_UNSORTED); 
+   PyModule_AddIntConstant(module,"SORT_METHOD_BITRATE",SORT_METHOD_BITRATE); 
+   PyModule_AddIntConstant(module,"SORT_METHOD_LISTENERS",SORT_METHOD_LISTENERS); 
+   PyModule_AddIntConstant(module,"SORT_METHOD_COUNTRY",SORT_METHOD_COUNTRY); 
+   PyModule_AddIntConstant(module,"SORT_METHOD_DATEADDED",SORT_METHOD_DATEADDED); 
+   PyModule_AddIntConstant(module,"SORT_METHOD_FULLPATH",SORT_METHOD_FULLPATH); 
+   PyModule_AddIntConstant(module,"SORT_METHOD_LABEL_IGNORE_FOLDERS",SORT_METHOD_LABEL_IGNORE_FOLDERS); 
+   PyModule_AddIntConstant(module,"SORT_METHOD_LASTPLAYED",SORT_METHOD_LASTPLAYED); 
+   PyModule_AddIntConstant(module,"SORT_METHOD_PLAYCOUNT",SORT_METHOD_PLAYCOUNT); 
+   PyModule_AddIntConstant(module,"SORT_METHOD_CHANNEL",SORT_METHOD_CHANNEL); 
+   PyModule_AddIntConstant(module,"SORT_METHOD_DATE_TAKEN",SORT_METHOD_DATE_TAKEN); 
+   PyModule_AddIntConstant(module,"SORT_METHOD_VIDEO_USER_RATING",SORT_METHOD_VIDEO_USER_RATING); 
+   PyModule_AddIntConstant(module,"SORT_METHOD_SONG_USER_RATING",SORT_METHOD_SONG_USER_RATING); 
+  }
+
+} // end PythonBindings namespace for python type definitions
+
+