jyapayne/PySide
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Replaced TypeResolver by SbkConverter and SpecificConverter.

Browse source 
Also updated QtGui's WId conversion to Python 3.
This commit is contained in:
Marcelo Lira 2011-11-01 18:42:47 -03:00 • committed by Hugo Parente Lima
commit 2a87b74bfe
14 changed files with 175 additions and 104 deletions
Download patch file Download diff file Expand all files Collapse all files

7
libpyside/globalreceiver.cpp
View file

@ -29,6 +29,7 @@
#include <QEvent>
#include <QLinkedList>
#include <autodecref.h>
#include <sbkconverter.h>
#include <gilstate.h>
#include "typeresolver.h"
@ -293,8 +294,9 @@ int GlobalReceiver::qt_metacall(QMetaObject::Call call, int id, void** args)
QList<QByteArray> paramTypes = slot.parameterTypes();
Shiboken::AutoDecRef preparedArgs(PyTuple_New(paramTypes.count()));
for (int i = 0, max = paramTypes.count(); i < max; ++i) {
PyObject* arg = Shiboken::TypeResolver::get(paramTypes[i].constData())->toPython(args[i+1]); // Do not increment the reference
PyTuple_SET_ITEM(preparedArgs.object(), i, arg);
const QByteArray& paramType = paramTypes[i];
Shiboken::Conversions::SpecificConverter converter(paramType.constData());
PyTuple_SET_ITEM(preparedArgs.object(), i, converter.toPython(args[i+1]));
}
retval = data->call(preparedArgs);
}
@ -306,4 +308,3 @@ int GlobalReceiver::qt_metacall(QMetaObject::Call call, int id, void** args)
return -1;
}

2
libpyside/globalreceiverv2.cpp
View file

@ -111,7 +111,7 @@ QByteArray DynamicSlotDataV2::hash(PyObject* callback)
{
Shiboken::GilState gil;
if (PyMethod_Check(callback))
return QByteArray::number((qlonglong)PyObject_Hash(PyMethod_GET_FUNCTION(callback)))
return QByteArray::number((qlonglong)PyObject_Hash(PyMethod_GET_FUNCTION(callback)))
+ QByteArray::number((qlonglong)PyObject_Hash(PyMethod_GET_SELF(callback)));
else
return QByteArray::number((qlonglong)PyObject_Hash(callback));

10
libpyside/pyside.cpp
View file

@ -35,6 +35,7 @@
#include <basewrapper.h>
#include <conversions.h>
#include <sbkconverter.h>
#include <typeresolver.h>
#include <bindingmanager.h>
#include <algorithm>
@ -141,7 +142,7 @@ void destroyQCoreApplication()
Shiboken::BindingManager& bm = Shiboken::BindingManager::instance();
SbkObject* pyQApp = bm.retrieveWrapper(app);
PyTypeObject* pyQObjectType = Shiboken::TypeResolver::get("QObject*")->pythonType();
PyTypeObject* pyQObjectType = Shiboken::Conversions::getPythonTypeObject("QObject*");
assert(pyQObjectType);
void* data[2] = {pyQApp, pyQObjectType};
@ -174,7 +175,10 @@ void initDynamicMetaObject(SbkObjectType* type, const QMetaObject* base, const s
//initialize staticQMetaObject property
void* metaObjectPtr = &userData->mo;
Shiboken::AutoDecRef pyMetaObject(Shiboken::TypeResolver::get("QMetaObject*")->toPython(&metaObjectPtr));
static SbkConverter* converter = Shiboken::Conversions::getConverter("QMetaObject");
if (!converter)
return;
Shiboken::AutoDecRef pyMetaObject(Shiboken::Conversions::pointerToPython(converter, metaObjectPtr));
PyObject_SetAttrString(reinterpret_cast<PyObject*>(type), "staticMetaObject", pyMetaObject);
}
@ -185,7 +189,7 @@ void initDynamicMetaObject(SbkObjectType* type, const QMetaObject* base)
void initQObjectSubType(SbkObjectType* type, PyObject* args, PyObject* kwds)
{
PyTypeObject* qObjType = Shiboken::TypeResolver::get("QObject*")->pythonType();
PyTypeObject* qObjType = Shiboken::Conversions::getPythonTypeObject("QObject*");
QByteArray className(Shiboken::String::toCString(PyTuple_GET_ITEM(args, 0)));
PyObject* bases = PyTuple_GET_ITEM(args, 1);

27
libpyside/pysidemetafunction.cpp
View file

@ -169,10 +169,10 @@ bool call(QObject* self, int methodIndex, PyObject* args, PyObject** retVal)
continue;
}
Shiboken::TypeResolver* typeResolver = Shiboken::TypeResolver::get(typeName);
if (typeResolver) {
if (Shiboken::TypeResolver::getType(typeName) == Shiboken::TypeResolver::ValueType) {
int typeId = QMetaType::type(typeName);
Shiboken::Conversions::SpecificConverter converter(typeName);
if (converter) {
int typeId = QMetaType::type(typeName);
if (!Shiboken::Conversions::pythonTypeIsObjectType(converter)) {
if (!typeId) {
PyErr_Format(PyExc_TypeError, "Value types used on meta functions (including signals) need to be "
"registered on meta type: %s", typeName.data());
@ -181,8 +181,15 @@ bool call(QObject* self, int methodIndex, PyObject* args, PyObject** retVal)
methValues[i] = QVariant(typeId, (void*) 0);
}
methArgs[i] = methValues[i].data();
if (i != 0) // Don't do this for return type
typeResolver->toCpp(PySequence_Fast_GET_ITEM(sequence.object(), i - 1), &methArgs[i]);
if (i == 0) // Don't do this for return type
continue;
if (typeId == QVariant::String) {
QString tmp;
converter.toCpp(PySequence_Fast_GET_ITEM(sequence.object(), i - 1), &tmp);
methValues[i] = tmp;
} else {
converter.toCpp(PySequence_Fast_GET_ITEM(sequence.object(), i - 1), methArgs[i]);
}
} else {
PyErr_Format(PyExc_TypeError, "Unknown type used to call meta function (that may be a signal): %s", argTypes[i].constData());
break;
@ -195,10 +202,10 @@ bool call(QObject* self, int methodIndex, PyObject* args, PyObject** retVal)
if (retVal) {
if (methArgs[0]) {
static Shiboken::TypeResolver* qVariantTypeResolver = Shiboken::TypeResolver::get("QVariant");
Q_ASSERT(qVariantTypeResolver);
*retVal = qVariantTypeResolver->toPython(&methValues[0]);
static SbkConverter* qVariantTypeConverter = Shiboken::Conversions::getConverter("QVariant");
Q_ASSERT(qVariantTypeConverter);
*retVal = Shiboken::Conversions::copyToPython(qVariantTypeConverter, &methValues[0]);
SbkDbg() << (*retVal);
} else {
*retVal = Py_None;
Py_INCREF(*retVal);

10
libpyside/pysideproperty.cpp
View file

@ -104,8 +104,10 @@ PyTypeObject PySidePropertyType = {
static void qpropertyMetaCall(PySideProperty* pp, PyObject* self, QMetaObject::Call call, void** args)
{
Shiboken::TypeResolver* typeResolver = Shiboken::TypeResolver::get(pp->d->typeName);
Q_ASSERT(typeResolver);
Shiboken::Conversions::SpecificConverter converter(pp->d->typeName);
Q_ASSERT(converter);
QByteArray type(pp->d->typeName);
switch(call) {
case QMetaObject::ReadProperty:
@ -113,7 +115,7 @@ static void qpropertyMetaCall(PySideProperty* pp, PyObject* self, QMetaObject::C
Shiboken::GilState gil;
PyObject* value = PySide::Property::getValue(pp, self);
if (value) {
typeResolver->toCpp(value, &args[0]);
converter.toCpp(value, args[0]);
Py_DECREF(value);
} else if (PyErr_Occurred()) {
PyErr_Print(); // Clear any errors but print them to stderr
@ -124,7 +126,7 @@ static void qpropertyMetaCall(PySideProperty* pp, PyObject* self, QMetaObject::C
case QMetaObject::WriteProperty:
{
Shiboken::GilState gil;
Shiboken::AutoDecRef value(typeResolver->toPython(args[0]));
Shiboken::AutoDecRef value(converter.toPython(args[0]));
PySide::Property::setValue(pp, self, value);
break;
}

46
libpyside/signalmanager.cpp
View file

@ -38,6 +38,7 @@
#include <algorithm>
#include <typeresolver.h>
#include <basewrapper.h>
#include <sbkconverter.h>
#include <conversions.h>
#if QSLOT_CODE != 1 || QSIGNAL_CODE != 2
@ -225,6 +226,22 @@ static void clearSignalManager()
PySide::SignalManager::instance().clear();
}
static void PyObject_PythonToCpp_PyObject_PTR(PyObject* pyIn, void* cppOut)
{
*((PyObject**)cppOut) = pyIn;
}
static PythonToCppFunc is_PyObject_PythonToCpp_PyObject_PTR_Convertible(PyObject* pyIn)
{
return PyObject_PythonToCpp_PyObject_PTR;
}
static PyObject* PyObject_PTR_CppToPython_PyObject(const void* cppIn)
{
PyObject* pyOut = (PyObject*)cppIn;
if (pyOut)
Py_INCREF(pyOut);
return pyOut;
}
SignalManager::SignalManager() : m_d(new SignalManagerPrivate)
{
// Register Qt primitive typedefs used on signals.
@ -234,9 +251,14 @@ SignalManager::SignalManager() : m_d(new SignalManagerPrivate)
qRegisterMetaType<PyObjectWrapper>(PYTHON_TYPE);
qRegisterMetaTypeStreamOperators<PyObjectWrapper>(PYTHON_TYPE);
TypeResolver::createValueTypeResolver<PyObjectWrapper>(PYTHON_TYPE);
TypeResolver::createValueTypeResolver<PyObjectWrapper>("object");
TypeResolver::createValueTypeResolver<PyObjectWrapper>("PySide::PyObjectWrapper");
SbkConverter* converter = Shiboken::Conversions::createConverter(&PyBaseObject_Type, 0);
Shiboken::Conversions::setCppPointerToPythonFunction(converter, PyObject_PTR_CppToPython_PyObject);
Shiboken::Conversions::setPythonToCppPointerFunctions(converter, PyObject_PythonToCpp_PyObject_PTR, is_PyObject_PythonToCpp_PyObject_PTR_Convertible);
Shiboken::Conversions::registerConverterName(converter, PYTHON_TYPE);
Shiboken::Conversions::registerConverterName(converter, "object");
Shiboken::Conversions::registerConverterName(converter, "PyObjectWrapper");
Shiboken::Conversions::registerConverterName(converter, "PySide::PyObjectWrapper");
PySide::registerCleanupFunction(clearSignalManager);
if (!metaObjectAttr)
@ -436,11 +458,12 @@ int SignalManager::callPythonMetaMethod(const QMetaMethod& method, void** args,
if (!retval.isNull() && retval != Py_None && !PyErr_Occurred()) {
const char* returnType = method.typeName();
if (returnType && std::strcmp("", returnType)) {
Shiboken::TypeResolver* typeResolver = Shiboken::TypeResolver::get(returnType);
if (typeResolver)
typeResolver->toCpp(retval, &args[0]);
Shiboken::Conversions::SpecificConverter converter(returnType);
if (converter)
converter.toCpp(retval, args[0]);
else
PyErr_Format(PyExc_RuntimeError, "Can't fidn type resolver \"%s\" to call Python meta method.", returnType);
PyErr_Format(PyExc_RuntimeError, "Can't find converter for '%s' to call Python meta method.", returnType);
}
}
}
@ -555,13 +578,10 @@ static PyObject* parseArguments(const QList<QByteArray>& paramTypes, void** args
for (int i = 0, max = argsSize; i < max; ++i) {
void* data = args[i+1];
const char* dataType = paramTypes[i].constData();
Shiboken::TypeResolver* tr = Shiboken::TypeResolver::get(dataType);
if (tr) {
PyObject* arg = tr->toPython(data);
PyTuple_SET_ITEM(preparedArgs, i, arg);
Shiboken::Conversions::SpecificConverter converter(dataType);
if (converter) {
PyTuple_SET_ITEM(preparedArgs, i, converter.toPython(data));
} else {
PyErr_Format(PyExc_TypeError, "Can't call meta function because I have no idea how to handle %s", dataType);
Py_DECREF(preparedArgs);
return 0;