Funkwhale/Clementine-audio-player-Mac-Linux-Windows
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Add bindings for classes from network.h

Browse Source
This commit is contained in:
David Sansome 2011-05-15 16:12:49 +00:00
parent 25e63e4b42
commit 7b84b23366
7 changed files with 781 additions and 11 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
cmake/PythonQtBindings.cmake
View File

@ -2,20 +2,15 @@ add_custom_target(pythonqt-bindings)
macro(add_pythonqt_bindings)
parse_arguments(ADD_PYTHONQT_BINDINGS
"NAME;HEADERS;TYPESYSTEM"
"NAME;HEADER;TYPESYSTEM"
""
${ARGN}
)
set(allheaders_filename ${CMAKE_CURRENT_BINARY_DIR}/pythonqt_headers.h)
set(allheaders_filename ${CMAKE_CURRENT_SOURCE_DIR}/${ADD_PYTHONQT_BINDINGS_HEADER})
set(typesystem_filename ${CMAKE_CURRENT_SOURCE_DIR}/${ADD_PYTHONQT_BINDINGS_TYPESYSTEM})
set(target_name "pythonqt-bindings-${ADD_PYTHONQT_BINDINGS_NAME}")
file(WRITE ${allheaders_filename} "")
foreach(_header ${ADD_PYTHONQT_BINDINGS_HEADERS})
file(APPEND ${allheaders_filename} "#include \"${_header}\"\n")
endforeach(_header)
add_custom_target(${target_name}
pythonqt-generator
--output-directory=${CMAKE_CURRENT_SOURCE_DIR}

5
src/CMakeLists.txt
View File

@ -830,10 +830,7 @@ if(HAVE_SCRIPTING_PYTHON)
add_pythonqt_bindings(
NAME clementine
HEADERS
core/urlhandler.h
radio/radiomodel.h
radio/radioservice.h
HEADER scripting/python/bindings_includes.h
TYPESYSTEM scripting/python/typesystem_clementine.xml
)

621
src/generated_cpp/clementine/clementine0.cpp
View File

@ -4,10 +4,13 @@
#include <PythonQtSignalReceiver.h>
#include <QVariant>
#include <qabstractitemmodel.h>
#include <qabstractnetworkcache.h>
#include <qbytearray.h>
#include <qcoreevent.h>
#include <qdatastream.h>
#include <qiodevice.h>
#include <qlist.h>
#include <qnetworkrequest.h>
#include <qobject.h>
#include <qpoint.h>
#include <qsize.h>
@ -19,6 +22,280 @@
#include <radioservice.h>
#include <urlhandler.h>
void PythonQtShell_NetworkAccessManager::childEvent(QChildEvent* arg__1)
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"" , "QChildEvent*"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
void* args[2] = {NULL, (void*)&arg__1};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return;
}
}
NetworkAccessManager::childEvent(arg__1);
}
QNetworkReply* PythonQtShell_NetworkAccessManager::createRequest(QNetworkAccessManager::Operation op, const QNetworkRequest& request, QIODevice* outgoingData)
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "createRequest");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"QNetworkReply*" , "QNetworkAccessManager::Operation" , "const QNetworkRequest&" , "QIODevice*"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
QNetworkReply* returnValue;
void* args[4] = {NULL, (void*)&op, (void*)&request, (void*)&outgoingData};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("createRequest", methodInfo, result);
} else {
returnValue = *((QNetworkReply**)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
}
}
return NetworkAccessManager::createRequest(op, request, outgoingData);
}
void PythonQtShell_NetworkAccessManager::customEvent(QEvent* arg__1)
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"" , "QEvent*"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
void* args[2] = {NULL, (void*)&arg__1};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return;
}
}
NetworkAccessManager::customEvent(arg__1);
}
bool PythonQtShell_NetworkAccessManager::event(QEvent* arg__1)
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"bool" , "QEvent*"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
bool returnValue;
void* args[2] = {NULL, (void*)&arg__1};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
}
}
return NetworkAccessManager::event(arg__1);
}
bool PythonQtShell_NetworkAccessManager::eventFilter(QObject* arg__1, QEvent* arg__2)
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
bool returnValue;
void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
}
}
return NetworkAccessManager::eventFilter(arg__1, arg__2);
}
void PythonQtShell_NetworkAccessManager::timerEvent(QTimerEvent* arg__1)
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"" , "QTimerEvent*"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
void* args[2] = {NULL, (void*)&arg__1};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return;
}
}
NetworkAccessManager::timerEvent(arg__1);
}
NetworkAccessManager* PythonQtWrapper_NetworkAccessManager::new_NetworkAccessManager(QObject* parent)
{
return new PythonQtShell_NetworkAccessManager(parent); }
QNetworkReply* PythonQtWrapper_NetworkAccessManager::createRequest(NetworkAccessManager* theWrappedObject, QNetworkAccessManager::Operation op, const QNetworkRequest& request, QIODevice* outgoingData)
{
return ( ((PythonQtPublicPromoter_NetworkAccessManager*)theWrappedObject)->promoted_createRequest(op, request, outgoingData));
}
void PythonQtShell_NetworkTimeouts::childEvent(QChildEvent* arg__1)
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"" , "QChildEvent*"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
void* args[2] = {NULL, (void*)&arg__1};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return;
}
}
NetworkTimeouts::childEvent(arg__1);
}
void PythonQtShell_NetworkTimeouts::customEvent(QEvent* arg__1)
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"" , "QEvent*"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
void* args[2] = {NULL, (void*)&arg__1};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return;
}
}
NetworkTimeouts::customEvent(arg__1);
}
bool PythonQtShell_NetworkTimeouts::event(QEvent* arg__1)
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"bool" , "QEvent*"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
bool returnValue;
void* args[2] = {NULL, (void*)&arg__1};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
}
}
return NetworkTimeouts::event(arg__1);
}
bool PythonQtShell_NetworkTimeouts::eventFilter(QObject* arg__1, QEvent* arg__2)
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
bool returnValue;
void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
}
}
return NetworkTimeouts::eventFilter(arg__1, arg__2);
}
void PythonQtShell_NetworkTimeouts::timerEvent(QTimerEvent* e)
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"" , "QTimerEvent*"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
void* args[2] = {NULL, (void*)&e};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return;
}
}
NetworkTimeouts::timerEvent(e);
}
NetworkTimeouts* PythonQtWrapper_NetworkTimeouts::new_NetworkTimeouts(int timeout_msec, QObject* parent)
{
return new PythonQtShell_NetworkTimeouts(timeout_msec, parent); }
void PythonQtWrapper_NetworkTimeouts::AddReply(NetworkTimeouts* theWrappedObject, QNetworkReply* reply)
{
( theWrappedObject->AddReply(reply));
}
void PythonQtWrapper_NetworkTimeouts::SetTimeout(NetworkTimeouts* theWrappedObject, int msec)
{
( theWrappedObject->SetTimeout(msec));
}
void PythonQtWrapper_NetworkTimeouts::timerEvent(NetworkTimeouts* theWrappedObject, QTimerEvent* e)
{
( ((PythonQtPublicPromoter_NetworkTimeouts*)theWrappedObject)->promoted_timerEvent(e));
}
void PythonQtWrapper_RadioModel::AddService(RadioModel* theWrappedObject, RadioService* service)
{
( theWrappedObject->AddService(service));
@ -414,6 +691,350 @@ QString PythonQtWrapper_RadioService::name(RadioService* theWrappedObject) cons
qint64 PythonQtShell_ThreadSafeNetworkDiskCache::cacheSize() const
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "cacheSize");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"qint64"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
qint64 returnValue;
void* args[1] = {NULL};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("cacheSize", methodInfo, result);
} else {
returnValue = *((qint64*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
}
}
return ThreadSafeNetworkDiskCache::cacheSize();
}
void PythonQtShell_ThreadSafeNetworkDiskCache::childEvent(QChildEvent* arg__1)
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"" , "QChildEvent*"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
void* args[2] = {NULL, (void*)&arg__1};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return;
}
}
ThreadSafeNetworkDiskCache::childEvent(arg__1);
}
void PythonQtShell_ThreadSafeNetworkDiskCache::clear()
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "clear");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={""};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
void* args[1] = {NULL};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return;
}
}
ThreadSafeNetworkDiskCache::clear();
}
void PythonQtShell_ThreadSafeNetworkDiskCache::customEvent(QEvent* arg__1)
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"" , "QEvent*"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
void* args[2] = {NULL, (void*)&arg__1};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return;
}
}
ThreadSafeNetworkDiskCache::customEvent(arg__1);
}
QIODevice* PythonQtShell_ThreadSafeNetworkDiskCache::data(const QUrl& url)
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "data");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"QIODevice*" , "const QUrl&"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
QIODevice* returnValue;
void* args[2] = {NULL, (void*)&url};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("data", methodInfo, result);
} else {
returnValue = *((QIODevice**)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
}
}
return ThreadSafeNetworkDiskCache::data(url);
}
bool PythonQtShell_ThreadSafeNetworkDiskCache::event(QEvent* arg__1)
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"bool" , "QEvent*"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
bool returnValue;
void* args[2] = {NULL, (void*)&arg__1};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
}
}
return ThreadSafeNetworkDiskCache::event(arg__1);
}
bool PythonQtShell_ThreadSafeNetworkDiskCache::eventFilter(QObject* arg__1, QEvent* arg__2)
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
bool returnValue;
void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
}
}
return ThreadSafeNetworkDiskCache::eventFilter(arg__1, arg__2);
}
void PythonQtShell_ThreadSafeNetworkDiskCache::insert(QIODevice* device)
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "insert");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"" , "QIODevice*"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
void* args[2] = {NULL, (void*)&device};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return;
}
}
ThreadSafeNetworkDiskCache::insert(device);
}
QNetworkCacheMetaData PythonQtShell_ThreadSafeNetworkDiskCache::metaData(const QUrl& url)
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metaData");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"QNetworkCacheMetaData" , "const QUrl&"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
QNetworkCacheMetaData returnValue;
void* args[2] = {NULL, (void*)&url};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("metaData", methodInfo, result);
} else {
returnValue = *((QNetworkCacheMetaData*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
}
}
return ThreadSafeNetworkDiskCache::metaData(url);
}
QIODevice* PythonQtShell_ThreadSafeNetworkDiskCache::prepare(const QNetworkCacheMetaData& metaData)
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "prepare");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"QIODevice*" , "const QNetworkCacheMetaData&"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
QIODevice* returnValue;
void* args[2] = {NULL, (void*)&metaData};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("prepare", methodInfo, result);
} else {
returnValue = *((QIODevice**)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
}
}
return ThreadSafeNetworkDiskCache::prepare(metaData);
}
bool PythonQtShell_ThreadSafeNetworkDiskCache::remove(const QUrl& url)
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "remove");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"bool" , "const QUrl&"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
bool returnValue;
void* args[2] = {NULL, (void*)&url};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("remove", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
}
}
return ThreadSafeNetworkDiskCache::remove(url);
}
void PythonQtShell_ThreadSafeNetworkDiskCache::timerEvent(QTimerEvent* arg__1)
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"" , "QTimerEvent*"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
void* args[2] = {NULL, (void*)&arg__1};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return;
}
}
ThreadSafeNetworkDiskCache::timerEvent(arg__1);
}
void PythonQtShell_ThreadSafeNetworkDiskCache::updateMetaData(const QNetworkCacheMetaData& metaData)
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "updateMetaData");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"" , "const QNetworkCacheMetaData&"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
void* args[2] = {NULL, (void*)&metaData};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return;
}
}
ThreadSafeNetworkDiskCache::updateMetaData(metaData);
}
ThreadSafeNetworkDiskCache* PythonQtWrapper_ThreadSafeNetworkDiskCache::new_ThreadSafeNetworkDiskCache(QObject* parent)
{
return new PythonQtShell_ThreadSafeNetworkDiskCache(parent); }
qint64 PythonQtWrapper_ThreadSafeNetworkDiskCache::cacheSize(ThreadSafeNetworkDiskCache* theWrappedObject) const
{
return ( ((PythonQtPublicPromoter_ThreadSafeNetworkDiskCache*)theWrappedObject)->promoted_cacheSize());
}
void PythonQtWrapper_ThreadSafeNetworkDiskCache::clear(ThreadSafeNetworkDiskCache* theWrappedObject)
{
( ((PythonQtPublicPromoter_ThreadSafeNetworkDiskCache*)theWrappedObject)->promoted_clear());
}
QIODevice* PythonQtWrapper_ThreadSafeNetworkDiskCache::data(ThreadSafeNetworkDiskCache* theWrappedObject, const QUrl& url)
{
return ( ((PythonQtPublicPromoter_ThreadSafeNetworkDiskCache*)theWrappedObject)->promoted_data(url));
}
void PythonQtWrapper_ThreadSafeNetworkDiskCache::insert(ThreadSafeNetworkDiskCache* theWrappedObject, QIODevice* device)
{
( ((PythonQtPublicPromoter_ThreadSafeNetworkDiskCache*)theWrappedObject)->promoted_insert(device));
}
QNetworkCacheMetaData PythonQtWrapper_ThreadSafeNetworkDiskCache::metaData(ThreadSafeNetworkDiskCache* theWrappedObject, const QUrl& url)
{
return ( ((PythonQtPublicPromoter_ThreadSafeNetworkDiskCache*)theWrappedObject)->promoted_metaData(url));
}
QIODevice* PythonQtWrapper_ThreadSafeNetworkDiskCache::prepare(ThreadSafeNetworkDiskCache* theWrappedObject, const QNetworkCacheMetaData& metaData)
{
return ( ((PythonQtPublicPromoter_ThreadSafeNetworkDiskCache*)theWrappedObject)->promoted_prepare(metaData));
}
bool PythonQtWrapper_ThreadSafeNetworkDiskCache::remove(ThreadSafeNetworkDiskCache* theWrappedObject, const QUrl& url)
{
return ( ((PythonQtPublicPromoter_ThreadSafeNetworkDiskCache*)theWrappedObject)->promoted_remove(url));
}
void PythonQtWrapper_ThreadSafeNetworkDiskCache::updateMetaData(ThreadSafeNetworkDiskCache* theWrappedObject, const QNetworkCacheMetaData& metaData)
{
( ((PythonQtPublicPromoter_ThreadSafeNetworkDiskCache*)theWrappedObject)->promoted_updateMetaData(metaData));
}
UrlHandler::LoadResult PythonQtShell_UrlHandler::LoadNext(const QUrl& url)
{
if (_wrapper) {

125
src/generated_cpp/clementine/clementine0.h
View File

@ -1,11 +1,15 @@
#include <PythonQt.h>
#include <QObject>
#include <QVariant>
#include <network.h>
#include <qabstractitemmodel.h>
#include <qabstractnetworkcache.h>
#include <qbytearray.h>
#include <qcoreevent.h>
#include <qdatastream.h>
#include <qiodevice.h>
#include <qlist.h>
#include <qnetworkrequest.h>
#include <qobject.h>
#include <qpoint.h>
#include <qsize.h>
@ -19,6 +23,73 @@
class PythonQtShell_NetworkAccessManager : public NetworkAccessManager
{
public:
PythonQtShell_NetworkAccessManager(QObject* parent = 0):NetworkAccessManager(parent),_wrapper(NULL) {};
virtual void childEvent(QChildEvent* arg__1);
virtual QNetworkReply* createRequest(QNetworkAccessManager::Operation op, const QNetworkRequest& request, QIODevice* outgoingData);
virtual void customEvent(QEvent* arg__1);
virtual bool event(QEvent* arg__1);
virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
virtual void timerEvent(QTimerEvent* arg__1);
PythonQtInstanceWrapper* _wrapper;
};
class PythonQtPublicPromoter_NetworkAccessManager : public NetworkAccessManager
{ public:
inline QNetworkReply* promoted_createRequest(QNetworkAccessManager::Operation op, const QNetworkRequest& request, QIODevice* outgoingData) { return NetworkAccessManager::createRequest(op, request, outgoingData); }
};
class PythonQtWrapper_NetworkAccessManager : public QObject
{ Q_OBJECT
public:
public slots:
NetworkAccessManager* new_NetworkAccessManager(QObject* parent = 0);
void delete_NetworkAccessManager(NetworkAccessManager* obj) { delete obj; }
QNetworkReply* createRequest(NetworkAccessManager* theWrappedObject, QNetworkAccessManager::Operation op, const QNetworkRequest& request, QIODevice* outgoingData);
};
class PythonQtShell_NetworkTimeouts : public NetworkTimeouts
{
public:
PythonQtShell_NetworkTimeouts(int timeout_msec, QObject* parent = 0):NetworkTimeouts(timeout_msec, parent),_wrapper(NULL) {};
virtual void childEvent(QChildEvent* arg__1);
virtual void customEvent(QEvent* arg__1);
virtual bool event(QEvent* arg__1);
virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
virtual void timerEvent(QTimerEvent* e);
PythonQtInstanceWrapper* _wrapper;
};
class PythonQtPublicPromoter_NetworkTimeouts : public NetworkTimeouts
{ public:
inline void promoted_timerEvent(QTimerEvent* e) { NetworkTimeouts::timerEvent(e); }
};
class PythonQtWrapper_NetworkTimeouts : public QObject
{ Q_OBJECT
public:
public slots:
NetworkTimeouts* new_NetworkTimeouts(int timeout_msec, QObject* parent = 0);
void delete_NetworkTimeouts(NetworkTimeouts* obj) { delete obj; }
void AddReply(NetworkTimeouts* theWrappedObject, QNetworkReply* reply);
void SetTimeout(NetworkTimeouts* theWrappedObject, int msec);
void timerEvent(NetworkTimeouts* theWrappedObject, QTimerEvent* e);
};
class PythonQtPublicPromoter_RadioModel : public RadioModel
{ public:
inline Qt::ItemFlags promoted_flags(const QModelIndex& index) const { return RadioModel::flags(index); }
@ -109,6 +180,60 @@ void delete_RadioService(RadioService* obj) { delete obj; }
class PythonQtShell_ThreadSafeNetworkDiskCache : public ThreadSafeNetworkDiskCache
{
public:
PythonQtShell_ThreadSafeNetworkDiskCache(QObject* parent):ThreadSafeNetworkDiskCache(parent),_wrapper(NULL) {};
virtual qint64 cacheSize() const;
virtual void childEvent(QChildEvent* arg__1);
virtual void clear();
virtual void customEvent(QEvent* arg__1);
virtual QIODevice* data(const QUrl& url);
virtual bool event(QEvent* arg__1);
virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
virtual void insert(QIODevice* device);
virtual QNetworkCacheMetaData metaData(const QUrl& url);
virtual QIODevice* prepare(const QNetworkCacheMetaData& metaData);
virtual bool remove(const QUrl& url);
virtual void timerEvent(QTimerEvent* arg__1);
virtual void updateMetaData(const QNetworkCacheMetaData& metaData);
PythonQtInstanceWrapper* _wrapper;
};
class PythonQtPublicPromoter_ThreadSafeNetworkDiskCache : public ThreadSafeNetworkDiskCache
{ public:
inline qint64 promoted_cacheSize() const { return ThreadSafeNetworkDiskCache::cacheSize(); }
inline void promoted_clear() { ThreadSafeNetworkDiskCache::clear(); }
inline QIODevice* promoted_data(const QUrl& url) { return ThreadSafeNetworkDiskCache::data(url); }
inline void promoted_insert(QIODevice* device) { ThreadSafeNetworkDiskCache::insert(device); }
inline QNetworkCacheMetaData promoted_metaData(const QUrl& url) { return ThreadSafeNetworkDiskCache::metaData(url); }
inline QIODevice* promoted_prepare(const QNetworkCacheMetaData& metaData) { return ThreadSafeNetworkDiskCache::prepare(metaData); }
inline bool promoted_remove(const QUrl& url) { return ThreadSafeNetworkDiskCache::remove(url); }
inline void promoted_updateMetaData(const QNetworkCacheMetaData& metaData) { ThreadSafeNetworkDiskCache::updateMetaData(metaData); }
};
class PythonQtWrapper_ThreadSafeNetworkDiskCache : public QObject
{ Q_OBJECT
public:
public slots:
ThreadSafeNetworkDiskCache* new_ThreadSafeNetworkDiskCache(QObject* parent);
void delete_ThreadSafeNetworkDiskCache(ThreadSafeNetworkDiskCache* obj) { delete obj; }
qint64 cacheSize(ThreadSafeNetworkDiskCache* theWrappedObject) const;
void clear(ThreadSafeNetworkDiskCache* theWrappedObject);
QIODevice* data(ThreadSafeNetworkDiskCache* theWrappedObject, const QUrl& url);
void insert(ThreadSafeNetworkDiskCache* theWrappedObject, QIODevice* device);
QNetworkCacheMetaData metaData(ThreadSafeNetworkDiskCache* theWrappedObject, const QUrl& url);
QIODevice* prepare(ThreadSafeNetworkDiskCache* theWrappedObject, const QNetworkCacheMetaData& metaData);
bool remove(ThreadSafeNetworkDiskCache* theWrappedObject, const QUrl& url);
void updateMetaData(ThreadSafeNetworkDiskCache* theWrappedObject, const QNetworkCacheMetaData& metaData);
};
class PythonQtShell_UrlHandler : public UrlHandler
{
public:

3
src/generated_cpp/clementine/clementine_init.cpp
View File

@ -3,8 +3,11 @@
void PythonQt_init_Clementine(PyObject* module) {
PythonQt::priv()->registerClass(&NetworkAccessManager::staticMetaObject, "Clementine", PythonQtCreateObject<PythonQtWrapper_NetworkAccessManager>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_NetworkAccessManager>, module, 0);
PythonQt::priv()->registerClass(&NetworkTimeouts::staticMetaObject, "Clementine", PythonQtCreateObject<PythonQtWrapper_NetworkTimeouts>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_NetworkTimeouts>, module, 0);
PythonQt::priv()->registerClass(&RadioModel::staticMetaObject, "Clementine", PythonQtCreateObject<PythonQtWrapper_RadioModel>, NULL, module, 0);
PythonQt::priv()->registerClass(&RadioService::staticMetaObject, "Clementine", PythonQtCreateObject<PythonQtWrapper_RadioService>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_RadioService>, module, 0);
PythonQt::priv()->registerClass(&ThreadSafeNetworkDiskCache::staticMetaObject, "Clementine", PythonQtCreateObject<PythonQtWrapper_ThreadSafeNetworkDiskCache>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_ThreadSafeNetworkDiskCache>, module, 0);
PythonQt::priv()->registerClass(&UrlHandler::staticMetaObject, "Clementine", PythonQtCreateObject<PythonQtWrapper_UrlHandler>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_UrlHandler>, module, 0);
PythonQt::priv()->registerCPPClass("UrlHandler::LoadResult", "", "Clementine", PythonQtCreateObject<PythonQtWrapper_UrlHandler_LoadResult>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_UrlHandler_LoadResult>, module, 0);

26
src/scripting/python/bindings_includes.h Normal file
View File

@ -0,0 +1,26 @@
/* This file is part of Clementine.
Copyright 2010, David Sansome <me@davidsansome.com>
Clementine 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 3 of the License, or
(at your option) any later version.
Clementine 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 Clementine. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef BINDINGS_INCLUDES_H
#define BINDINGS_INCLUDES_H
#include "core/network.h"
#include "core/urlhandler.h"
#include "radio/radiomodel.h"
#include "radio/radioservice.h"
#endif // BINDINGS_INCLUDES_H

3
src/scripting/python/typesystem_clementine.xml
View File

@ -11,7 +11,10 @@
<value-type name="UrlHandler::LoadResult" />
<object-type name="NetworkAccessManager" />
<object-type name="NetworkTimeouts" />
<object-type name="RadioModel" />
<object-type name="RadioService" />
<object-type name="ThreadSafeNetworkDiskCache" />
<object-type name="UrlHandler" />
</typesystem>