#include "PythonQtSignalReceiver.h"

#include "PythonQtClassInfo.h"

#include "PythonQtMethodInfo.h"

#include "PythonQtConversion.h"

#include <QMetaObject>

#include <QMetaMethod>

#include "funcobject.h"

int PythonQtSignalReceiver::_destroyedSignal1Id = -2;

int PythonQtSignalReceiver::_destroyedSignal2Id = -2;

void PythonQtSignalTarget::call(void **arguments) const {

}

PyObject* PythonQtSignalTarget::call(PyObject* callable, const PythonQtMethodInfo* methodInfos, void **arguments, bool skipFirstArgumentOfMethodInfo)

{

Q_UNUSED(skipFirstArgumentOfMethodInfo)

// Note: we check if the callable is a PyFunctionObject and has a fixed number of arguments

// if that is the case, we only pass these arguments to python and skip the additional arguments from the signal

int numPythonArgs = -1;

if (PyFunction_Check(callable)) {

PyObject* o = callable;

PyFunctionObject* func = (PyFunctionObject*)o;

PyCodeObject* code = (PyCodeObject*)func->func_code;

if (!(code->co_flags & CO_VARARGS)) {

numPythonArgs = code->co_argcount;

} else {

// variable numbers of arguments allowed

}

} else if (PyMethod_Check(callable)) {

PyObject* o = callable;

PyMethodObject* method = (PyMethodObject*)o;

if (PyFunction_Check(method->im_func)) {

PyFunctionObject* func = (PyFunctionObject*)method->im_func;

PyCodeObject* code = (PyCodeObject*)func->func_code;

if (!(code->co_flags & CO_VARARGS)) {

numPythonArgs = code->co_argcount - 1; // we subtract one because the first is "self"

} else {

// variable numbers of arguments allowed

}

}

}

const PythonQtMethodInfo* m = methodInfos;

// parameterCount includes return value:

int count = m->parameterCount();

if (numPythonArgs!=-1) {

if (count>numPythonArgs+1) {

// take less arguments

count = numPythonArgs+1;

}

}

PyObject* pargs = NULL;

if (count>1) {

pargs = PyTuple_New(count-1);

}

bool err = false;

// transform Qt values to Python

const QList<PythonQtMethodInfo::ParameterInfo>& params = m->parameters();

for (int i = 1; i < count; i++) {

const PythonQtMethodInfo::ParameterInfo& param = params.at(i);

PyObject* arg = PythonQtConv::ConvertQtValueToPython(param, arguments[i]);

if (arg) {

// steals reference, no unref

PyTuple_SetItem(pargs, i-1,arg);

} else {

err = true;

break;

}

}

PyObject* result = NULL;

if (!err) {

PyErr_Clear();

result = PyObject_CallObject(callable, pargs);

if (result) {

// ok

} else {

PythonQt::self()->handleError();

}

}

if (pargs) {

// free the arguments again

Py_DECREF(pargs);

}

return result;

}

bool PythonQtSignalTarget::isSame( int signalId, PyObject* callable ) const

{

return PyObject_RichCompareBool(callable, _callable, Py_EQ) && (signalId == _signalId);

}

PythonQtSignalReceiver::PythonQtSignalReceiver(QObject* obj):PythonQtSignalReceiverBase(obj)

}

PythonQtSignalReceiver::~PythonQtSignalReceiver()

{

if (PythonQt::priv()) {

// we need the GIL scope here, because the targets keep references to Python objects

PYTHONQT_GIL_SCOPE;

PythonQt::priv()->removeSignalEmitter(_obj);

_targets.clear();

}

}

bool PythonQtSignalReceiver::addSignalHandler(const char* signal, PyObject* callable)

}

bool PythonQtSignalReceiver::removeSignalHandler(const char* signal, PyObject* callable)

}

int PythonQtSignalReceiver::getSignalIndex(const char* signal)

}

int PythonQtSignalReceiver::qt_metacall(QMetaObject::Call c, int id, void **arguments)

}