diff --git a/CMakeLists.txt b/CMakeLists.txt index e3e1a8f..a7ffbd5 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -5,8 +5,7 @@ project(pysidebindings) cmake_minimum_required(VERSION 2.6) set(CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake/Macros/ ${CMAKE_MODULE_PATH}) -find_package(GeneratorRunner 0.6.11 REQUIRED) -find_package(Shiboken 1.0.4 REQUIRED) +find_package(Shiboken 1.1.1 REQUIRED) find_package(Qt4 4.5.0 REQUIRED) find_file(GL_H "gl.h" PATH_SUFFIXES "GL") include(FindQt4Extra) @@ -32,7 +31,7 @@ endif() if(MSVC) set(CMAKE_CXX_FLAGS "/Zc:wchar_t- /GR /EHsc /DNOCOLOR /DWIN32 /D_WINDOWS /D_SCL_SECURE_NO_WARNINGS") else() - if(CMAKE_HOST_UNIX) + if(CMAKE_HOST_UNIX AND NOT CYGWIN) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -fvisibility=hidden -Wno-strict-aliasing") endif() set(CMAKE_CXX_FLAGS_DEBUG "-g") @@ -62,8 +61,8 @@ endif() set(BINDING_NAME PySide) set(BINDING_API_MAJOR_VERSION "1") -set(BINDING_API_MINOR_VERSION "0") -set(BINDING_API_MICRO_VERSION "4") +set(BINDING_API_MINOR_VERSION "1") +set(BINDING_API_MICRO_VERSION "1") set(BINDING_API_RELEASE_LEVEL "final") # alpha, beta, rc, or final set(BINDING_API_SERIAL 1) # leave as 0 when release level is final set(BINDING_API_VERSION "${BINDING_API_MAJOR_VERSION}.${BINDING_API_MINOR_VERSION}.${BINDING_API_MICRO_VERSION}" CACHE STRING "PySide version" FORCE) @@ -142,7 +141,7 @@ add_custom_target(dist if (NOT SITE_PACKAGE) execute_process( COMMAND ${SHIBOKEN_PYTHON_INTERPRETER} -c "from distutils import sysconfig; \\ - print sysconfig.get_python_lib(1,0,prefix='${CMAKE_INSTALL_PREFIX}')" + print(sysconfig.get_python_lib(1,0,prefix='${CMAKE_INSTALL_PREFIX}'))" OUTPUT_VARIABLE SITE_PACKAGE OUTPUT_STRIP_TRAILING_WHITESPACE) if (NOT SITE_PACKAGE) diff --git a/PySide/CMakeLists.txt b/PySide/CMakeLists.txt index 62c8068..d8371c0 100644 --- a/PySide/CMakeLists.txt +++ b/PySide/CMakeLists.txt @@ -9,9 +9,6 @@ configure_file("${CMAKE_CURRENT_SOURCE_DIR}/global.h.in" configure_file("${CMAKE_CURRENT_SOURCE_DIR}/__init__.py.in" "${CMAKE_CURRENT_BINARY_DIR}/__init__.py" @ONLY) -execute_process(COMMAND ${CMAKE_COMMAND} -E copy_if_different "${CMAKE_CURRENT_SOURCE_DIR}/private.py" - "${CMAKE_BINARY_DIR}/PySide/private.py") - HAS_QT_MODULE(QT_QTCORE_FOUND QtCore) HAS_QT_MODULE(QT_QTGUI_FOUND QtGui) HAS_QT_MODULE(QT_QTNETWORK_FOUND QtNetwork) @@ -34,7 +31,7 @@ HAS_QT_MODULE(QT_PHONON_FOUND phonon) HAS_QT_MODULE(QT_QTDECLARATIVE_FOUND QtDeclarative) # install -install(FILES "${CMAKE_CURRENT_BINARY_DIR}/__init__.py" "${CMAKE_CURRENT_BINARY_DIR}/private.py" +install(FILES "${CMAKE_CURRENT_BINARY_DIR}/__init__.py" DESTINATION "${SITE_PACKAGE}/${BINDING_NAME}${pyside_SUFFIX}") install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/typesystem_templates.xml DESTINATION share/PySide${pyside_SUFFIX}/typesystems) diff --git a/PySide/QtCore/CMakeLists.txt b/PySide/QtCore/CMakeLists.txt index 86df1d1..a2337c0 100644 --- a/PySide/QtCore/CMakeLists.txt +++ b/PySide/QtCore/CMakeLists.txt @@ -37,14 +37,12 @@ else() endif() if(ENABLE_WIN) - set(QtCore_typesystem "typesystem_core_win.xml") - set(QtCore_extra_SRC + set(SPECIFIC_OS_FILES ${CMAKE_CURRENT_BINARY_DIR}/PySide/QtCore/msg_wrapper.cpp ${CMAKE_CURRENT_BINARY_DIR}/PySide/QtCore/point_wrapper.cpp ) else() - set(QtCore_typesystem "typesystem_core.xml") - set(QtCore_extra_SRC "") + set(SPECIFIC_OS_FILES "") endif() set(QtCore_SRC @@ -146,10 +144,14 @@ ${CMAKE_CURRENT_BINARY_DIR}/PySide/QtCore/qxmlstreamreader_wrapper.cpp ${CMAKE_CURRENT_BINARY_DIR}/PySide/QtCore/qxmlstreamwriter_wrapper.cpp ${QtCore_46_SRC} ${QtCore_47_SRC} -${QtCore_extra_SRC} +${SPECIFIC_OS_FILES} ) -set(QtCore_typesystem_path "") +configure_file("${CMAKE_CURRENT_SOURCE_DIR}/typesystem_core.xml.in" + "${CMAKE_CURRENT_BINARY_DIR}/typesystem_core.xml" @ONLY) + +set(QtCore_typesystem_path "${QtCore_SOURCE_DIR}") + set(QtCore_include_dirs ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR}/${BINDING_NAME}/QtCore/ ${QT_INCLUDE_DIR} @@ -168,4 +170,4 @@ create_pyside_module(QtCore QtCore_typesystem_path QtCore_SRC QtCore_gluecode - ${CMAKE_CURRENT_SOURCE_DIR}/${QtCore_typesystem}) + ${CMAKE_CURRENT_BINARY_DIR}/typesystem_core.xml) diff --git a/PySide/QtCore/glue/hwnd_conversions.h b/PySide/QtCore/glue/hwnd_conversions.h deleted file mode 100644 index bf2de4d..0000000 --- a/PySide/QtCore/glue/hwnd_conversions.h +++ /dev/null @@ -1,32 +0,0 @@ -namespace Shiboken { -template <> -struct Converter -{ - static bool checkType(PyObject* pyObj) - { - return false; - } - - static bool isConvertible(PyObject* pyobj) - { - return PyCObject_Check(pyobj); - } - - static inline PyObject* toPython(void* cppobj) - { - // not supported - Q_ASSERT(true); - return 0; - } - - static PyObject* toPython(HWND__ cppobj) - { - return PyCObject_FromVoidPtr(&cppobj, 0); - } - - static HWND__ toCpp(PyObject* pyobj) - { - return *((HWND__*) PyCObject_AsVoidPtr(pyobj)); - } -}; -} diff --git a/PySide/QtCore/glue/qbytearray_bufferprotocol.cpp b/PySide/QtCore/glue/qbytearray_bufferprotocol.cpp index 03ffcb4..acc7bb9 100644 --- a/PySide/QtCore/glue/qbytearray_bufferprotocol.cpp +++ b/PySide/QtCore/glue/qbytearray_bufferprotocol.cpp @@ -18,7 +18,7 @@ static Py_ssize_t SbkQByteArray_readbufferproc(PyObject* self, Py_ssize_t segmen if (segment || !Shiboken::Object::isValid(self)) return -1; - QByteArray* cppSelf = Shiboken::Converter::toCpp(self); + QByteArray* cppSelf = %CONVERTTOCPP[QByteArray*](self); *ptrptr = reinterpret_cast(cppSelf->data()); return cppSelf->size(); } diff --git a/PySide/QtCore/glue/qeasingcurve_glue.cpp b/PySide/QtCore/glue/qeasingcurve_glue.cpp index fd2dee0..7f56315 100644 --- a/PySide/QtCore/glue/qeasingcurve_glue.cpp +++ b/PySide/QtCore/glue/qeasingcurve_glue.cpp @@ -93,7 +93,7 @@ qreal PySideEasingCurveFunctor::operator()(qreal progress) PyObject* result = PyObject_CallObject(m_func, args); qreal cppResult = 0.0; if (result) { - cppResult = Shiboken::Converter::toCpp(result); + Shiboken::Conversions::pythonToCppCopy(Shiboken::Conversions::PrimitiveTypeConverter(), result, &cppResult); Py_DECREF(result); } Py_DECREF(args); diff --git a/PySide/QtCore/glue/qobject_connect.cpp b/PySide/QtCore/glue/qobject_connect.cpp index 91a272c..96bcfb2 100644 --- a/PySide/QtCore/glue/qobject_connect.cpp +++ b/PySide/QtCore/glue/qobject_connect.cpp @@ -8,18 +8,18 @@ static bool isDecorator(PyObject* method, PyObject* self) reinterpret_cast(method)->im_func; } -static bool getReceiver(PyObject* callback, QObject** receiver, PyObject** self) +static bool getReceiver(QObject *source, const char* signal, PyObject* callback, QObject** receiver, PyObject** self, QByteArray* callbackSig) { bool forceGlobalReceiver = false; if (PyMethod_Check(callback)) { *self = PyMethod_GET_SELF(callback); - if (Shiboken::Converter::checkType(*self)) - *receiver = Shiboken::Converter::toCpp(*self); + if (%CHECKTYPE[QObject*](*self)) + *receiver = %CONVERTTOCPP[QObject*](*self); forceGlobalReceiver = isDecorator(callback, *self); } else if (PyCFunction_Check(callback)) { *self = PyCFunction_GET_SELF(callback); - if (*self && Shiboken::Converter::checkType(*self)) - *receiver = Shiboken::Converter::toCpp(*self); + if (*self && %CHECKTYPE[QObject*](*self)) + *receiver = %CONVERTTOCPP[QObject*](*self); } else if (PyCallable_Check(callback)) { // Ok, just a callable object *receiver = 0; @@ -27,9 +27,20 @@ static bool getReceiver(PyObject* callback, QObject** receiver, PyObject** self) } bool usingGlobalReceiver = !*receiver || forceGlobalReceiver; + + // Check if this callback is a overwrite of a non-virtual Qt slot. + if (!usingGlobalReceiver && receiver && self) { + *callbackSig = PySide::Signal::getCallbackSignature(signal, *receiver, callback, usingGlobalReceiver).toAscii(); + const QMetaObject* metaObject = (*receiver)->metaObject(); + int slotIndex = metaObject->indexOfSlot(callbackSig->constData()); + if (slotIndex != -1 && slotIndex < metaObject->methodOffset() && PyMethod_Check(callback)) + usingGlobalReceiver = true; + } + if (usingGlobalReceiver) { PySide::SignalManager& signalManager = PySide::SignalManager::instance(); - *receiver = signalManager.globalReceiver(); + *receiver = signalManager.globalReceiver(source, callback); + *callbackSig = PySide::Signal::getCallbackSignature(signal, *receiver, callback, usingGlobalReceiver).toAscii(); } return usingGlobalReceiver; @@ -59,40 +70,48 @@ static bool qobjectConnectCallback(QObject* source, const char* signal, PyObject return false; signal++; - if (!PySide::SignalManager::registerMetaMethod(source, signal, QMetaMethod::Signal)) + int signalIndex = PySide::SignalManager::registerMetaMethodGetIndex(source, signal, QMetaMethod::Signal); + if (signalIndex == -1) return false; - int signalIndex = source->metaObject()->indexOfMethod(signal); - PySide::SignalManager& signalManager = PySide::SignalManager::instance(); // Extract receiver from callback QObject* receiver = 0; PyObject* self = 0; - bool usingGlobalReceiver = getReceiver(callback, &receiver, &self); + QByteArray callbackSig; + bool usingGlobalReceiver = getReceiver(source, signal, callback, &receiver, &self, &callbackSig); if (receiver == 0 && self == 0) return false; const QMetaObject* metaObject = receiver->metaObject(); - const QByteArray callbackSig = PySide::Signal::getCallbackSignature(signal, receiver, callback, usingGlobalReceiver).toAscii(); const char* slot = callbackSig.constData(); int slotIndex = metaObject->indexOfSlot(slot); + if (slotIndex == -1) { if (!usingGlobalReceiver && self && !Shiboken::Object::hasCppWrapper((SbkObject*)self)) { qWarning() << "You can't add dynamic slots on an object originated from C++."; + if (usingGlobalReceiver) + signalManager.releaseGlobalReceiver(source, receiver); + return false; } - if (usingGlobalReceiver) { - signalManager.addGlobalSlot(slot, callback); - } else { - if (!PySide::SignalManager::registerMetaMethod(receiver, slot, QMetaMethod::Slot)) - return false; + + if (usingGlobalReceiver) + slotIndex = signalManager.globalReceiverSlotIndex(receiver, slot); + else + slotIndex = PySide::SignalManager::registerMetaMethodGetIndex(receiver, slot, QMetaMethod::Slot); + + if (slotIndex == -1) { + if (usingGlobalReceiver) + signalManager.releaseGlobalReceiver(source, receiver); + + return false; } - slotIndex = metaObject->indexOfSlot(slot); } if (QMetaObject::connect(source, signalIndex, receiver, slotIndex, type)) { if (usingGlobalReceiver) - signalManager.globalReceiverConnectNotify(source, slotIndex); + signalManager.notifyGlobalReceiver(receiver); #ifndef AVOID_PROTECTED_HACK source->connectNotify(signal - 1); #else @@ -103,6 +122,10 @@ static bool qobjectConnectCallback(QObject* source, const char* signal, PyObject return true; } + + if (usingGlobalReceiver) + signalManager.releaseGlobalReceiver(source, receiver); + return false; } @@ -117,27 +140,28 @@ static bool qobjectDisconnectCallback(QObject* source, const char* signal, PyObj // Extract receiver from callback QObject* receiver = 0; PyObject* self = 0; - bool usingGlobalReceiver = getReceiver(callback, &receiver, &self); + QByteArray callbackSig; + bool usingGlobalReceiver = getReceiver(NULL, signal, callback, &receiver, &self, &callbackSig); if (receiver == 0 && self == 0) return false; const QMetaObject* metaObject = receiver->metaObject(); - const QByteArray callbackSig = PySide::Signal::getCallbackSignature(signal, receiver, callback, usingGlobalReceiver).toAscii(); - QByteArray qtSlotName(callbackSig); - qtSlotName = qtSlotName.prepend('1'); + int signalIndex = source->metaObject()->indexOfSignal(++signal); + int slotIndex = -1; + + slotIndex = metaObject->indexOfSlot(callbackSig); + + if (QMetaObject::disconnectOne(source, signalIndex, receiver, slotIndex)) { + if (usingGlobalReceiver) + signalManager.releaseGlobalReceiver(source, receiver); - if (QObject::disconnect(source, signal, receiver, qtSlotName.constData())) { - if (usingGlobalReceiver) { - int slotIndex = metaObject->indexOfSlot(callbackSig.constData()); - signalManager.globalReceiverDisconnectNotify(source, slotIndex); #ifndef AVOID_PROTECTED_HACK - source->disconnectNotify(signal - 1); + source->disconnectNotify(callbackSig); #else // Need to cast to QObjectWrapper* and call the public version of // connectNotify when avoiding the protected hack. - reinterpret_cast(source)->disconnectNotify(signal - 1); + reinterpret_cast(source)->disconnectNotify(callbackSig); #endif - } return true; } return false; diff --git a/PySide/QtCore/glue/qt_version.cpp b/PySide/QtCore/glue/qt_version.cpp deleted file mode 100644 index 66f8c00..0000000 --- a/PySide/QtCore/glue/qt_version.cpp +++ /dev/null @@ -1,5 +0,0 @@ -QList version = QByteArray(qVersion()).split('.'); -PyObject *pyQtVersion = Shiboken::makeTuple(version[0].toInt(), version[1].toInt(), version[2].toInt()); - -PyModule_AddStringConstant(module, "__version__", qVersion()); -PyModule_AddObject(module, "__version_info__", pyQtVersion); diff --git a/PySide/QtCore/qbool_conversions.h b/PySide/QtCore/qbool_conversions.h deleted file mode 100644 index f4fb43f..0000000 --- a/PySide/QtCore/qbool_conversions.h +++ /dev/null @@ -1,16 +0,0 @@ -namespace Shiboken { -template <> -struct Converter : public ValueTypeConverter -{ - using ValueTypeConverter::toPython; - - static PyObject* toPython(const QBool& cppobj) - { - return PyBool_FromLong((bool) cppobj); - } - static QBool toCpp(PyObject* pyobj) - { - return QBool(pyobj == Py_True); - } -}; -} diff --git a/PySide/QtCore/qbytearray_conversions.h b/PySide/QtCore/qbytearray_conversions.h deleted file mode 100644 index daa1609..0000000 --- a/PySide/QtCore/qbytearray_conversions.h +++ /dev/null @@ -1,34 +0,0 @@ -namespace Shiboken { - -inline bool Converter::checkType(PyObject* pyObj) -{ - return ValueTypeConverter::checkType(pyObj); -} - -inline bool Converter::isConvertible(PyObject* pyObj) -{ - if (ValueTypeConverter::isConvertible(pyObj)) - return true; - SbkObjectType* shiboType = reinterpret_cast(SbkType< ::QByteArray >()); - return Shiboken::Converter::checkType(pyObj) - || (ObjectType::isExternalConvertible(shiboType, pyObj)); -} - -inline QByteArray Converter::toCpp(PyObject* pyObj) -{ - if (pyObj == Py_None) - return 0; - else if (PyObject_TypeCheck(pyObj, SbkType())) - return *Converter::toCpp(pyObj); - else if (PyString_Check(pyObj)) - return QByteArray(PyString_AS_STRING(pyObj), PyString_GET_SIZE(pyObj)); - else - return ValueTypeConverter::toCpp(pyObj); -} - -inline PyObject* Converter::toPython(const ::QByteArray& cppObj) -{ - return ValueTypeConverter::toPython(cppObj); -} - -} diff --git a/PySide/QtCore/qchar_conversions.h b/PySide/QtCore/qchar_conversions.h deleted file mode 100644 index 1ebcb64..0000000 --- a/PySide/QtCore/qchar_conversions.h +++ /dev/null @@ -1,35 +0,0 @@ -namespace Shiboken { - -template<> -struct Converter -{ - static bool checkType(PyObject* pyObj) - { - return PyString_Check(pyObj) && (PyString_Size(pyObj) == 1); - } - - static bool isConvertible(PyObject* pyObj) - { - return (PyString_Check(pyObj) && (PyString_Size(pyObj) == 1)) - || pyObj == Py_None - || PyInt_Check(pyObj); - } - - static QChar toCpp(PyObject* pyObj) - { - if (PyString_Check(pyObj) && PyString_Size(pyObj) == 1) - return QChar(Shiboken::Converter::toCpp(pyObj)); - else if (PyInt_Check(pyObj)) - return QChar(Shiboken::Converter::toCpp(pyObj)); - return QChar(); - } - - static PyObject* toPython(void* cppObj) { return toPython(*reinterpret_cast(cppObj)); } - static PyObject* toPython(const QChar& cppObj) - { - wchar_t c = (wchar_t)cppObj.unicode(); - PyObject* pyObj = PyUnicode_FromWideChar(&c, 1); - return pyObj; - } -}; -} diff --git a/PySide/QtCore/qdate_conversions.h b/PySide/QtCore/qdate_conversions.h deleted file mode 100644 index 7c45eec..0000000 --- a/PySide/QtCore/qdate_conversions.h +++ /dev/null @@ -1,45 +0,0 @@ -namespace Shiboken { - -inline bool Converter::checkType(PyObject* pyObj) -{ - return ValueTypeConverter::checkType(pyObj); -} - -inline PyObject* Converter::toPython(const ::QDate& cppObj) -{ - return ValueTypeConverter::toPython(cppObj); -} - -inline bool Converter::isConvertible(PyObject* pyObj) -{ - if (ValueTypeConverter::isConvertible(pyObj)) - return true; - - if (!PyDateTimeAPI) - PyDateTime_IMPORT; - - SbkObjectType* shiboType = reinterpret_cast(SbkType< ::QDate >()); - return PyDate_Check(pyObj) || ObjectType::isExternalConvertible(shiboType, pyObj); -} - -inline QDate Converter::toCpp(PyObject* pyObj) -{ - if (!PyDateTimeAPI) - PyDateTime_IMPORT; - - if (pyObj == Py_None) { - return QDate(); - } else if (PyObject_TypeCheck(pyObj, SbkType())) { - return *Converter::toCpp(pyObj); - } else if (PyDate_Check(pyObj)) { - int day = PyDateTime_GET_DAY(pyObj); - int month = PyDateTime_GET_MONTH(pyObj); - int year = PyDateTime_GET_YEAR(pyObj); - return QDate(year, month, day); - } else { - return ValueTypeConverter::toCpp(pyObj); - } -} - - -} diff --git a/PySide/QtCore/qdatetime_conversions.h b/PySide/QtCore/qdatetime_conversions.h deleted file mode 100644 index 38c0336..0000000 --- a/PySide/QtCore/qdatetime_conversions.h +++ /dev/null @@ -1,49 +0,0 @@ -namespace Shiboken { - -inline bool Converter::checkType(PyObject* pyObj) -{ - return ValueTypeConverter::checkType(pyObj); -} - -inline PyObject* Converter::toPython(const ::QDateTime& cppObj) -{ - return ValueTypeConverter::toPython(cppObj); -} - -inline bool Converter::isConvertible(PyObject* pyObj) -{ - if (ValueTypeConverter::isConvertible(pyObj)) - return true; - - if (!PyDateTimeAPI) - PyDateTime_IMPORT; - - SbkObjectType* shiboType = reinterpret_cast(SbkType< ::QDateTime >()); - return PyDateTime_Check(pyObj) || ObjectType::isExternalConvertible(shiboType, pyObj); -} - - -inline QDateTime Converter::toCpp(PyObject* pyObj) -{ - if (!PyDateTimeAPI) - PyDateTime_IMPORT; - - if (pyObj == Py_None) { - return QDateTime(); - } else if (PyObject_TypeCheck(pyObj, SbkType())) { - return *Converter::toCpp(pyObj); - } else if (PyDateTime_Check(pyObj)) { - int day = PyDateTime_GET_DAY(pyObj); - int month = PyDateTime_GET_MONTH(pyObj); - int year = PyDateTime_GET_YEAR(pyObj); - int hour = PyDateTime_DATE_GET_HOUR(pyObj); - int min = PyDateTime_DATE_GET_MINUTE(pyObj); - int sec = PyDateTime_DATE_GET_SECOND(pyObj); - int usec = PyDateTime_DATE_GET_MICROSECOND(pyObj); - return QDateTime(QDate(year, month, day), QTime(hour, min, sec, usec/1000)); - } else { - return ValueTypeConverter::toCpp(pyObj); - } -} - -} diff --git a/PySide/QtCore/qhash_conversions.h b/PySide/QtCore/qhash_conversions.h deleted file mode 100644 index f9e2e42..0000000 --- a/PySide/QtCore/qhash_conversions.h +++ /dev/null @@ -1,4 +0,0 @@ -namespace Shiboken { -template -struct Converter > : QtDictConverter > {}; -} diff --git a/PySide/QtCore/qlist_conversions.h b/PySide/QtCore/qlist_conversions.h deleted file mode 100644 index cb1d26b..0000000 --- a/PySide/QtCore/qlist_conversions.h +++ /dev/null @@ -1,4 +0,0 @@ -namespace Shiboken { -template -struct Converter > : StdListConverter > {}; -} diff --git a/PySide/QtCore/qmap_conversions.h b/PySide/QtCore/qmap_conversions.h deleted file mode 100644 index 3153fae..0000000 --- a/PySide/QtCore/qmap_conversions.h +++ /dev/null @@ -1,5 +0,0 @@ -namespace Shiboken { -template -struct Converter > : QtDictConverter > { -}; -} diff --git a/PySide/QtCore/qmultimap_conversions.h b/PySide/QtCore/qmultimap_conversions.h deleted file mode 100644 index 43abd84..0000000 --- a/PySide/QtCore/qmultimap_conversions.h +++ /dev/null @@ -1,5 +0,0 @@ -namespace Shiboken { -template -struct Converter > : QtMultiMapConverter > { -}; -} diff --git a/PySide/QtCore/qpair_conversions.h b/PySide/QtCore/qpair_conversions.h deleted file mode 100644 index 99e9cd8..0000000 --- a/PySide/QtCore/qpair_conversions.h +++ /dev/null @@ -1,4 +0,0 @@ -namespace Shiboken { -template -struct Converter > : StdPairConverter > {}; -} diff --git a/PySide/QtCore/qset_conversions.h b/PySide/QtCore/qset_conversions.h deleted file mode 100644 index c46fef0..0000000 --- a/PySide/QtCore/qset_conversions.h +++ /dev/null @@ -1,4 +0,0 @@ -namespace Shiboken { -template -struct Converter > : QSequenceConverter > {}; -} diff --git a/PySide/QtCore/qstack_conversion.h b/PySide/QtCore/qstack_conversion.h deleted file mode 100644 index 709a918..0000000 --- a/PySide/QtCore/qstack_conversion.h +++ /dev/null @@ -1,4 +0,0 @@ -namespace Shiboken { -template -struct Converter > : StdListConverter > {}; -} diff --git a/PySide/QtCore/qstring_conversions.h b/PySide/QtCore/qstring_conversions.h deleted file mode 100644 index bfb06f2..0000000 --- a/PySide/QtCore/qstring_conversions.h +++ /dev/null @@ -1,51 +0,0 @@ -namespace Shiboken { - -template<> -inline PyTypeObject* SbkType() -{ - return &PyUnicode_Type; -} - -template<> -struct Converter -{ - static bool checkType(PyObject* pyObj) - { - return PyString_Check(pyObj) || PyUnicode_Check(pyObj); - } - - static bool isConvertible(PyObject* pyObj) - { - return PyString_Check(pyObj) - || PyUnicode_Check(pyObj) - || pyObj == Py_None; - } - - static QString toCpp(PyObject* pyObj) - { - if (PyUnicode_Check(pyObj)) { - Py_UNICODE* unicode = PyUnicode_AS_UNICODE(pyObj); - #if defined(Py_UNICODE_WIDE) - // cast as Py_UNICODE can be a different type - return QString::fromUcs4(reinterpret_cast(unicode)); - #else - return QString::fromUtf16(unicode, PyUnicode_GET_SIZE(pyObj)); - #endif - } else if (PyString_Check(pyObj)) { - return QString(Converter::toCpp(pyObj)); - } - return QString(); - } - - static PyObject* toPython(void* cppObj) { return toPython(*reinterpret_cast(cppObj)); } - static PyObject* toPython(const QString& cppObj) - { - const int N = cppObj.length(); - wchar_t* str = new wchar_t[N]; - cppObj.toWCharArray(str); - PyObject* pyObj = PyUnicode_FromWideChar(str, N); - delete[] str; - return pyObj; - } -}; -} diff --git a/PySide/QtCore/qstringlist_conversions.h b/PySide/QtCore/qstringlist_conversions.h deleted file mode 100644 index 6075c16..0000000 --- a/PySide/QtCore/qstringlist_conversions.h +++ /dev/null @@ -1,5 +0,0 @@ -namespace Shiboken -{ -template<> -struct Converter : StdListConverter {}; -} diff --git a/PySide/QtCore/qstringref_conversions.h b/PySide/QtCore/qstringref_conversions.h deleted file mode 100644 index db3eefc..0000000 --- a/PySide/QtCore/qstringref_conversions.h +++ /dev/null @@ -1,18 +0,0 @@ -namespace Shiboken { - -template<> -struct Converter : public Converter -{ - static PyObject* toPython(void* cppObj) { return toPython(*reinterpret_cast(cppObj)); } - - static PyObject* toPython(const QStringRef& cppObj) - { - return Converter::toPython(cppObj.toString()); - } - - static QStringRef toCpp(PyObject* pyObj) - { - return QStringRef(); - } -}; -} diff --git a/PySide/QtCore/qtime_conversions.h b/PySide/QtCore/qtime_conversions.h deleted file mode 100644 index 4600ef7..0000000 --- a/PySide/QtCore/qtime_conversions.h +++ /dev/null @@ -1,45 +0,0 @@ -namespace Shiboken { - -inline bool Converter::checkType(PyObject* pyObj) -{ - return ValueTypeConverter::checkType(pyObj); -} - -inline PyObject* Converter::toPython(const ::QTime& cppObj) -{ - return ValueTypeConverter::toPython(cppObj); -} - -inline bool Converter::isConvertible(PyObject* pyObj) -{ - if (ValueTypeConverter::isConvertible(pyObj)) - return true; - - if (!PyDateTimeAPI) - PyDateTime_IMPORT; - - SbkObjectType* shiboType = reinterpret_cast(SbkType< ::QTime >()); - return PyTime_Check(pyObj) || ObjectType::isExternalConvertible(shiboType, pyObj); -} - -inline QTime Converter::toCpp(PyObject* pyObj) -{ - if (!PyDateTimeAPI) - PyDateTime_IMPORT; - - if (pyObj == Py_None) { - return QTime(); - } else if (PyObject_TypeCheck(pyObj, SbkType())) { - return *Converter::toCpp(pyObj); - } else if (PyTime_Check(pyObj)) { - int hour = PyDateTime_TIME_GET_HOUR(pyObj); - int min = PyDateTime_TIME_GET_MINUTE(pyObj); - int sec = PyDateTime_TIME_GET_SECOND(pyObj); - int usec = PyDateTime_TIME_GET_MICROSECOND(pyObj); - return QTime(hour, min, sec, usec/1000); - } else { - return ValueTypeConverter::toCpp(pyObj); - } -} - -} diff --git a/PySide/QtCore/qvariant_conversions.h b/PySide/QtCore/qvariant_conversions.h deleted file mode 100644 index 354955b..0000000 --- a/PySide/QtCore/qvariant_conversions.h +++ /dev/null @@ -1,216 +0,0 @@ -namespace Shiboken { - -template<> -struct Converter -{ - static bool checkType(PyObject* pyObj) - { - return false; // lets avoid the chaos - } - - // all types are convertible to QVariant - static bool isConvertible(PyObject* pyObj) - { - return true; - } - - static const char* resolveMetaType(PyTypeObject* type, int* typeId) - { - if (PyObject_TypeCheck(type, &SbkObjectType_Type)) { - SbkObjectType* sbkType = reinterpret_cast(type); - const char* typeName = Shiboken::ObjectType::getOriginalName(sbkType); - if (!typeName) - return 0; - bool valueType = '*' != typeName[qstrlen(typeName) - 1]; - - // Do not convert user type of value - if (valueType && Shiboken::ObjectType::isUserType(type)) - return 0; - - int obTypeId = QMetaType::type(typeName); - if (obTypeId) { - *typeId = obTypeId; - return typeName; - } - - // Do not resolve types to value type - if (valueType) - return 0; - - // find in base types - if (type->tp_base) { - return resolveMetaType(type->tp_base, typeId); - } else if (type->tp_bases) { - int size = PyTuple_GET_SIZE(type->tp_bases); - for(int i=0; i < size; i++){ - const char* derivedName = resolveMetaType(reinterpret_cast(PyTuple_GET_ITEM(type->tp_bases, i)), typeId); - if (derivedName) - return derivedName; - } - } - } - *typeId = 0; - return 0; - } - - static QVariant toCpp(PyObject* pyObj) - { - using namespace Shiboken; - - // Primitive types - if (Converter::checkType(pyObj)) { - // QVariant(bool) - return QVariant(Converter::toCpp(pyObj)); - } else if (pyObj == Py_None) { - // QVariant() - return QVariant(); - } else if (Converter::checkType(pyObj)) { - // QVariant(const char*) - return QVariant(Converter::toCpp(pyObj)); - } else if (Converter::checkType(pyObj)) { - // QVariant(QByteArray) - return QVariant(Converter::toCpp(pyObj)); - } else if (PyFloat_CheckExact(pyObj)) { - // QVariant(double) - return QVariant(Converter::toCpp(pyObj)); - } else if (PyInt_Check(pyObj)) { - // QVariant(int) - return QVariant(Converter::toCpp(pyObj)); - } else if (PyLong_CheckExact(pyObj)) { - // QVariant(qlonglong) - return QVariant(Converter::toCpp(pyObj)); - } else if (Shiboken::isShibokenEnum(pyObj)) { - // QVariant(enum) - return QVariant(Converter::toCpp(pyObj)); - } else if (Shiboken::Object::checkType(pyObj)) { - // a class supported by QVariant? - int typeCode; - const char* typeName = resolveMetaType(pyObj->ob_type, &typeCode); - if (typeCode && typeName) { - Shiboken::TypeResolver* tr = Shiboken::TypeResolver::get(typeName); - QVariant var(typeCode, (void*)0); - void* args[] = { var.data() }; - tr->toCpp(pyObj, args); - return var; - } - } - - //sequence and dictornay - if (PyDict_Check(pyObj)) { - QVariant ret = convertToVariantMap(pyObj); - if (ret.isValid()) - return ret; - } else if (PySequence_Check(pyObj)) { - return convertToVariantList(pyObj); - } - - // Is a shiboken type not known by Qt - return QVariant::fromValue(pyObj); - } - - static PyObject* toPython(void* cppObj) - { - return toPython(*reinterpret_cast(cppObj)); - } - - static PyObject* toPython(const QVariant& cppObj) - { - if (cppObj.isValid()) { - if (qstrcmp(cppObj.typeName(), "QVariantList") == 0) - return Converter >::toPython(cppObj.value()); - - if (qstrcmp(cppObj.typeName(), "QStringList") == 0) - return Converter >::toPython(cppObj.value()); - - if (qstrcmp(cppObj.typeName(), "QVariantMap") == 0) - return Converter >::toPython(cppObj.value()); - - Shiboken::TypeResolver* tr = Shiboken::TypeResolver::get(cppObj.typeName()); - if (tr) - return tr->toPython(const_cast(cppObj.data())); - } - Py_RETURN_NONE; - } - - static QVariant convertToValueList(PyObject* list) - { - if (PySequence_Size(list) < 1) - return QVariant(); - - Shiboken::AutoDecRef element(PySequence_GetItem(list, 0)); - int typeId; - const char* typeName = resolveMetaType(element.cast(), &typeId); - if (typeName) { - QByteArray listTypeName("QList<"); - listTypeName += typeName; - listTypeName += '>'; - typeId = QMetaType::type(listTypeName); - if (typeId > 0) { - Shiboken::TypeResolver* tr = Shiboken::TypeResolver::get(listTypeName); - if (!tr) { - qWarning() << "TypeResolver for :" << listTypeName << "not registered."; - } else { - QVariant var(typeId, (void*)0); - void* args[] = { var.data(), 0 }; - tr->toCpp(list, args); - return var; - } - } - } - return QVariant(); - } - - static QVariant convertToVariantMap(PyObject* map) - { - PyObject *key, *value; - Py_ssize_t pos = 0; - AutoDecRef keys(PyDict_Keys(map)); - bool keysIsString = isStringList(keys); - if (keysIsString) { - QMap ret; - while (PyDict_Next(map, &pos, &key, &value)) - ret.insert(Converter::toCpp(key), toCpp(value)); - return QVariant(ret); - } else { - return QVariant(); - } - } - - static bool isStringList(PyObject *list) - { - bool allString = true; - AutoDecRef fast(PySequence_Fast(list, "Failed to convert QVariantList")); - Py_ssize_t size = PySequence_Fast_GET_SIZE(fast.object()); - for(int i=0; i < size; i++) { - PyObject* item = PySequence_Fast_GET_ITEM(fast.object(), i); - if (!Converter::checkType(item)) { - allString = false; - break; - } - } - return allString; - } - - static QVariant convertToVariantList(PyObject* list) - { - bool allString = isStringList(list); - if (allString) { - QStringList lst = Converter >::toCpp(list); - return QVariant(lst); - } else { - QVariant valueList = convertToValueList(list); - if (valueList.isValid()) - return valueList; - QList lst; - AutoDecRef fast(PySequence_Fast(list, "Failed to convert QVariantList")); - Py_ssize_t size = PySequence_Fast_GET_SIZE(fast.object()); - for(int i=0; i < size; i++) { - PyObject* item = PySequence_Fast_GET_ITEM(fast.object(), i); - lst.append(toCpp(item)); - } - return QVariant(lst); - } - Q_ASSERT(false); - } -}; -} diff --git a/PySide/QtCore/qvariant_type_conversions.h b/PySide/QtCore/qvariant_type_conversions.h deleted file mode 100644 index bacf6c0..0000000 --- a/PySide/QtCore/qvariant_type_conversions.h +++ /dev/null @@ -1,87 +0,0 @@ -namespace Shiboken { - -template<> -struct Converter -{ - static bool checkType(PyObject* pyObj) - { - return pyObj == Py_None || PyType_Check(pyObj) || Converter::checkType(pyObj); - } - - static bool isConvertible(PyObject* pyObj) - { - return checkType(pyObj); - } - - static QVariant::Type toCpp(PyObject* pyObj) - { - const char* typeName = 0; - if (pyObj == Py_None) - return QVariant::Invalid; - - if (pyObj == reinterpret_cast(&PyString_Type) || pyObj == reinterpret_cast(&PyUnicode_Type)) - typeName = "QString"; - else if (pyObj == reinterpret_cast(&PyFloat_Type)) - typeName = "double"; // float is a UserType in QVariant. - else if (pyObj == reinterpret_cast(&PyLong_Type)) - typeName = "int"; // long is a UserType in QVariant. - else if (PyType_Check(pyObj)) { - if (pyObj->ob_type == &SbkObjectType_Type) - typeName = Shiboken::ObjectType::getOriginalName(reinterpret_cast(pyObj)); - else - typeName = reinterpret_cast(pyObj)->tp_name; - } - else if (PyString_Check(pyObj)) - typeName = PyString_AS_STRING(pyObj); - else if (PyUnicode_Check(pyObj)) - typeName = PyString_AsString(pyObj); - else if (PyDict_Check(pyObj) && checkAllStringKeys(pyObj)) - typeName = "QVariantMap"; - else if (PySequence_Check(pyObj)) - if (isStringList(pyObj)) - typeName = "QStringList"; - else - typeName = "QVariantList"; - else - Q_ASSERT(false); - - return QVariant::nameToType(typeName); - } - - static PyObject* toPython(void* cppObj) { return toPython(*reinterpret_cast(cppObj)); } - static PyObject* toPython(const QVariant::Type& cppObj) - { - const char* typeName = QVariant::typeToName(cppObj); - PyObject* pyObj; - if (!typeName) { - pyObj = Py_None; - } else { - Shiboken::TypeResolver* tr = Shiboken::TypeResolver::get(typeName); - pyObj = tr ? reinterpret_cast(tr->pythonType()) : Py_None; - } - Py_INCREF(pyObj); - return pyObj; - } - - static bool isStringList(PyObject* list) - { - bool allString = true; - AutoDecRef fast(PySequence_Fast(list, "Failed to convert QVariantList")); - Py_ssize_t size = PySequence_Fast_GET_SIZE(fast.object()); - for(int i=0; i < size; i++) { - PyObject* item = PySequence_Fast_GET_ITEM(fast.object(), i); - if (!Converter::checkType(item)) { - allString = false; - break; - } - } - return allString; - } - - static bool checkAllStringKeys(PyObject* dict) - { - AutoDecRef keys(PyDict_Keys(dict)); - return isStringList(keys); - } -}; -} diff --git a/PySide/QtCore/qvector_conversions.h b/PySide/QtCore/qvector_conversions.h deleted file mode 100644 index 0857036..0000000 --- a/PySide/QtCore/qvector_conversions.h +++ /dev/null @@ -1,4 +0,0 @@ -namespace Shiboken { -template -struct Converter > : StdListConverter > {}; -} diff --git a/PySide/QtCore/typesystem_core.xml.in b/PySide/QtCore/typesystem_core.xml.in new file mode 100644 index 0000000..9de2082 --- /dev/null +++ b/PySide/QtCore/typesystem_core.xml.in @@ -0,0 +1,24 @@ + + + + + + diff --git a/PySide/QtCore/typesystem_core.xml b/PySide/QtCore/typesystem_core_common.xml similarity index 73% rename from PySide/QtCore/typesystem_core.xml rename to PySide/QtCore/typesystem_core_common.xml index 1c0baf7..2e83131 100644 --- a/PySide/QtCore/typesystem_core.xml +++ b/PySide/QtCore/typesystem_core_common.xml @@ -1,7 +1,7 @@ @@ -62,7 +99,6 @@ - @@ -99,101 +135,603 @@ - - + + - + + - + + - + - + - + - - + + + - + + - - - - - + + + return PyBool_FromLong((bool)%in); + + + + %out = %OUTTYPE(%in == Py_True); + + + - + + bool py2kStrCheck(PyObject* obj) + { + #ifdef IS_PY3K + return false; + #else + return PyString_Check(obj); + #endif + } + + + - - - - - - - - - - - - - - - - + + + const int N = %in.length(); + wchar_t* str = new wchar_t[N]; + %in.toWCharArray(str); + PyObject* %out = PyUnicode_FromWideChar(str, N); + delete[] str; + return %out; + + + + Py_UNICODE* unicode = PyUnicode_AS_UNICODE(%in); + #if defined(Py_UNICODE_WIDE) + // cast as Py_UNICODE can be a different type + %out = QString::fromUcs4((const uint*)unicode); + #else + %out = QString::fromUtf16(unicode, PyUnicode_GET_SIZE(%in)); + #endif + + + #ifndef IS_PY3K + const char* str = %CONVERTTOCPP[const char*](%in); + %out = %OUTTYPE(str); + #endif + + + %out = %OUTTYPE(); + + + - - + + + + const int N = %in.toString().length(); + wchar_t* str = new wchar_t[N]; + %in.toString().toWCharArray(str); + PyObject* %out = PyUnicode_FromWideChar(str, N); + delete[] str; + return %out; + + + + %out = %OUTTYPE(); + + + + + + + wchar_t c = (wchar_t)%in.unicode(); + return PyUnicode_FromWideChar(&c, 1); + + + + char c = %CONVERTTOCPP[char](%in); + %out = %OUTTYPE(c); + + + int i = %CONVERTTOCPP[int](%in); + %out = %OUTTYPE(i); + + + %out = %OUTTYPE(); + + + + + + + + + + if (!%in.isValid()) + Py_RETURN_NONE; + + if (qstrcmp(%in.typeName(), "QVariantList") == 0) { + QList<QVariant> var = %in.value<QVariantList>(); + return %CONVERTTOPYTHON[QList<QVariant>](var); + } + + if (qstrcmp(%in.typeName(), "QStringList") == 0) { + QStringList var = %in.value<QStringList>(); + return %CONVERTTOPYTHON[QList<QString>](var); + } + + if (qstrcmp(%in.typeName(), "QVariantMap") == 0) { + QMap<QString, QVariant> var = %in.value<QVariantMap>(); + return %CONVERTTOPYTHON[QMap<QString, QVariant>](var); + } + + Shiboken::Conversions::SpecificConverter converter(cppInRef.typeName()); + if (converter) { + void* ptr = cppInRef.data(); + return converter.toPython(ptr); + } + PyErr_Format(PyExc_RuntimeError, "Can't find converter for '%s'.", %in.typeName()); + return 0; + + + + %out = %OUTTYPE(%in == Py_True); + + + %out = %OUTTYPE(); + + + QString in = %CONVERTTOCPP[QString](%in); + %out = %OUTTYPE(in); + + + QByteArray in = %CONVERTTOCPP[QByteArray](%in); + %out = %OUTTYPE(in); + + + double in = %CONVERTTOCPP[double](%in); + %out = %OUTTYPE(in); + + + int in = %CONVERTTOCPP[int](%in); + %out = %OUTTYPE(in); + + + qlonglong in = %CONVERTTOCPP[qlonglong](%in); + %out = %OUTTYPE(in); + + + int in = %CONVERTTOCPP[int](%in); + %out = %OUTTYPE(in); + + + // a class supported by QVariant? + int typeCode; + const char* typeName = QVariant_resolveMetaType(%in->ob_type, &typeCode); + if (!typeCode || !typeName) + return; + QVariant var(typeCode, (void*)0); + Shiboken::Conversions::SpecificConverter converter(typeName); + converter.toCpp(pyIn, var.data()); + %out = var; + + + QVariant ret = QVariant_convertToVariantMap(%in); + %out = ret.isValid() ? ret : QVariant::fromValue<PySide::PyObjectWrapper>(%in); + + + %out = QVariant_convertToVariantList(%in); + + + // Is a shiboken type not known by Qt + %out = QVariant::fromValue<PySide::PyObjectWrapper>(%in); + + + + + + static const char* QVariant_resolveMetaType(PyTypeObject* type, int* typeId) + { + if (PyObject_TypeCheck(type, &SbkObjectType_Type)) { + SbkObjectType* sbkType = (SbkObjectType*)type; + const char* typeName = Shiboken::ObjectType::getOriginalName(sbkType); + if (!typeName) + return 0; + bool valueType = '*' != typeName[qstrlen(typeName) - 1]; + // Do not convert user type of value + if (valueType &∓ Shiboken::ObjectType::isUserType(type)) + return 0; + int obTypeId = QMetaType::type(typeName); + if (obTypeId) { + *typeId = obTypeId; + return typeName; + } + // Do not resolve types to value type + if (valueType) + return 0; + // find in base types + if (type->tp_base) { + return QVariant_resolveMetaType(type->tp_base, typeId); + } else if (type->tp_bases) { + for(int i = 0; i < PyTuple_GET_SIZE(type->tp_bases); ++i) { + const char* derivedName = QVariant_resolveMetaType((PyTypeObject*)PyTuple_GET_ITEM(type->tp_bases, i), typeId); + if (derivedName) + return derivedName; + } + } + } + *typeId = 0; + return 0; + } + static QVariant QVariant_convertToValueList(PyObject* list) + { + if (PySequence_Size(list) < 1) + return QVariant(); + Shiboken::AutoDecRef element(PySequence_GetItem(list, 0)); + int typeId; + const char* typeName = QVariant_resolveMetaType(element.cast<PyTypeObject*>(), &typeId); + if (typeName) { + QByteArray listTypeName("QList<"); + listTypeName += typeName; + listTypeName += '>'; + typeId = QMetaType::type(listTypeName); + if (typeId > 0) { + Shiboken::Conversions::SpecificConverter converter(listTypeName); + if (converter) { + QVariant var(typeId, (void*)0); + converter.toCpp(list, &var); + return var; + } + qWarning() << "Type converter for :" << listTypeName << "not registered."; + } + } + return QVariant(); + } + static bool QVariant_isStringList(PyObject *list) + { + bool allString = true; + Shiboken::AutoDecRef fast(PySequence_Fast(list, "Failed to convert QVariantList")); + Py_ssize_t size = PySequence_Fast_GET_SIZE(fast.object()); + for(int i = 0; i < size; ++i) { + PyObject* item = PySequence_Fast_GET_ITEM(fast.object(), i); + if (!%CHECKTYPE[QString](item)) { + allString = false; + break; + } + } + return allString; + } + static QVariant QVariant_convertToVariantMap(PyObject* map) + { + Py_ssize_t pos = 0; + Shiboken::AutoDecRef keys(PyDict_Keys(map)); + if (!QVariant_isStringList(keys)) + return QVariant(); + PyObject* key; + PyObject* value; + QMap<QString,QVariant> ret; + while (PyDict_Next(map, &pos, &key, &value)) { + QString cppKey = %CONVERTTOCPP[QString](key); + QVariant cppValue = %CONVERTTOCPP[QVariant](value); + ret.insert(cppKey, cppValue); + } + return QVariant(ret); + } + static QVariant QVariant_convertToVariantList(PyObject* list) + { + if (QVariant_isStringList(list)) { + QList<QString > lst = %CONVERTTOCPP[QList<QString>](list); + return QVariant(QStringList(lst)); + } + QVariant valueList = QVariant_convertToValueList(list); + if (valueList.isValid()) + return valueList; + QList<QVariant> lst; + Shiboken::AutoDecRef fast(PySequence_Fast(list, "Failed to convert QVariantList")); + Py_ssize_t size = PySequence_Fast_GET_SIZE(fast.object()); + for (int i = 0; i < size; ++i) { + PyObject* pyItem = PySequence_Fast_GET_ITEM(fast.object(), i); + QVariant item = %CONVERTTOCPP[QVariant](pyItem); + lst.append(item); + } + return QVariant(lst); + } + + + + + + const char* typeName = QVariant::typeToName(%in); + PyObject* %out; + PyTypeObject* pyType = 0; + if (typeName) + pyType = Shiboken::Conversions::getPythonTypeObject(typeName); + %out = pyType ? ((PyObject*)pyType) : Py_None; + Py_INCREF(%out); + return %out; + + + + %out = QVariant::Invalid; + + + const char* typeName; + if (Shiboken::String::checkType((PyTypeObject*)%in)) + typeName = "QString"; + else if (%in == (PyObject*)&PyFloat_Type) + typeName = "double"; // float is a UserType in QVariant. + else if (%in == (PyObject*)&PyLong_Type) + typeName = "int"; // long is a UserType in QVariant. + else if (%in->ob_type == &SbkObjectType_Type) + typeName = Shiboken::ObjectType::getOriginalName((SbkObjectType*)%in); + else + typeName = ((PyTypeObject*)%in)->tp_name; + %out = QVariant::nameToType(typeName); + + + %out = QVariant::nameToType(Shiboken::String::toCString(%in)); + + + %out = QVariant::nameToType("QVariantMap"); + + + const char* typeName; + if (QVariantType_isStringList(%in)) + typeName = "QStringList"; + else + typeName = "QVariantList"; + %out = QVariant::nameToType(typeName); + + + + + + + + Shiboken::Conversions::registerConverterName(SbkPySide_QtCoreTypeConverters[SBK_QTCORE_QMAP_QSTRING_QVARIANT_IDX], "QVariantMap"); + + + + static bool QVariantType_isStringList(PyObject* list) + { + bool allString = true; + Shiboken::AutoDecRef fast(PySequence_Fast(list, "Failed to convert QVariantList")); + Py_ssize_t size = PySequence_Fast_GET_SIZE(fast.object()); + for(int i=0; i < size; i++) { + PyObject* item = PySequence_Fast_GET_ITEM(fast.object(), i); + if (!%CHECKTYPE[QString](item)) { + allString = false; + break; + } + } + return allString; + } + static bool QVariantType_checkAllStringKeys(PyObject* dict) + { + Shiboken::AutoDecRef keys(PyDict_Keys(dict)); + return QVariantType_isStringList(keys); + } + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + + + + + + + + + + - + + + + + + + + + + - + + + + + + + + + + + - + - + + + + + + + + + + - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + + + + + + + + + + - - + + + + + + + + + + - + + + + + + + + + + + - + + + PyObject* %out = PyTuple_New(2); + PyTuple_SET_ITEM(%out, 0, %CONVERTTOPYTHON[%INTYPE_0](%in.first)); + PyTuple_SET_ITEM(%out, 1, %CONVERTTOPYTHON[%INTYPE_1](%in.second)); + return %out; + + + + %out.first = %CONVERTTOCPP[%OUTTYPE_0](PySequence_Fast_GET_ITEM(%in, 0)); + %out.second = %CONVERTTOCPP[%OUTTYPE_1](PySequence_Fast_GET_ITEM(%in, 1)); + + + @@ -240,7 +778,6 @@ - @@ -318,6 +855,7 @@ + @@ -332,7 +870,8 @@ - %PYARG_0 = %CONVERTTOPYTHON[double](qAbs(%1)); + double _abs = qAbs(%1); + %PYARG_0 = %CONVERTTOPYTHON[double](_abs); @@ -367,7 +906,26 @@ qAddPostRoutine(PySide::globalPostRoutineCallback); - + + QList<QByteArray> version = QByteArray(qVersion()).split('.'); + PyObject* pyQtVersion = PyTuple_New(3); + for (int i = 0; i < 3; ++i) + PyTuple_SET_ITEM(pyQtVersion, i, PyInt_FromLong(version[i].toInt())); + PyModule_AddObject(module, "__version_info__", pyQtVersion); + PyModule_AddStringConstant(module, "__version__", qVersion()); + + + + { // Avoid name clash + Shiboken::AutoDecRef atexit(Shiboken::Module::import("atexit")); + Shiboken::AutoDecRef regFunc(PyObject_GetAttrString(atexit, "register")); + PyObject* shutDownFunc = PyObject_GetAttrString(module, "__moduleShutdown"); + Shiboken::AutoDecRef args(PyTuple_New(1)); + PyTuple_SET_ITEM(args, 0, shutDownFunc); + Shiboken::AutoDecRef retval(PyObject_Call(regFunc, args, 0)); + Q_ASSERT(!retval.isNull()); + } + @@ -377,8 +935,10 @@ - Shiboken::TypeResolver::createValueTypeResolver<QString>("unicode"); - Shiboken::TypeResolver::createValueTypeResolver<QString>("str"); + Shiboken::Conversions::registerConverterName(SbkPySide_QtCoreTypeConverters[SBK_QSTRING_IDX], "unicode"); + Shiboken::Conversions::registerConverterName(SbkPySide_QtCoreTypeConverters[SBK_QSTRING_IDX], "str"); + Shiboken::Conversions::registerConverterName(SbkPySide_QtCoreTypeConverters[SBK_QTCORE_QLIST_QVARIANT_IDX], "QVariantList"); + PySide::init(module); Py_AtExit(QtCoreModuleExit); @@ -393,7 +953,9 @@ static void msgHandlerCallback(QtMsgType type, const char* msg) { Shiboken::GilState state; - Shiboken::AutoDecRef arglist(Shiboken::makeTuple(type, msg)); + Shiboken::AutoDecRef arglist(PyTuple_New(2)); + PyTuple_SET_ITEM(arglist, 0, %CONVERTTOPYTHON[QtMsgType](type)); + PyTuple_SET_ITEM(arglist, 1, %CONVERTTOPYTHON[const char*](msg)); Shiboken::AutoDecRef ret(PyObject_CallObject(qtmsghandler, arglist)); } static void QtCoreModuleExit() @@ -503,9 +1065,11 @@ - QPointF p; - %RETURN_TYPE retval = %CPPSELF.%FUNCTION_NAME(%ARGUMENT_NAMES, &p); - %PYARG_0 = Shiboken::makeTuple(retval, p); + QPointF p; + %RETURN_TYPE retval = %CPPSELF.%FUNCTION_NAME(%ARGUMENT_NAMES, &p); + %PYARG_0 = PyTuple_New(2); + PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[%RETURN_TYPE](retval)); + PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[QPointF](p)); @@ -528,8 +1092,9 @@ @@ -553,12 +1118,42 @@ - + + + + + + + + + + %out = %OUTTYPE(); + + + int day = PyDateTime_GET_DAY(%in); + int month = PyDateTime_GET_MONTH(%in); + int year = PyDateTime_GET_YEAR(%in); + %out = %OUTTYPE(year, month, day); + + + - + @@ -567,7 +1162,7 @@ - + @@ -577,8 +1172,8 @@ - if (!PyDateTimeAPI) PyDateTime_IMPORT; - %PYARG_0 = PyDate_FromDate(%CPPSELF.year(), %CPPSELF.month(), %CPPSELF.day()); + if (!PyDateTimeAPI) PySideDateTime_IMPORT; + %PYARG_0 = PyDate_FromDate(%CPPSELF.year(), %CPPSELF.month(), %CPPSELF.day()); @@ -596,8 +1191,13 @@ int year, month, day; + %BEGIN_ALLOW_THREADS %CPPSELF.%FUNCTION_NAME(&year, &month, &day); - %PYARG_0 = Shiboken::makeTuple(year, month, day); + %END_ALLOW_THREADS + %PYARG_0 = PyTuple_New(3); + PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[int](year)); + PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[int](month)); + PyTuple_SET_ITEM(%PYARG_0, 2, %CONVERTTOPYTHON[int](day)); @@ -609,15 +1209,40 @@ int yearNumber; + %BEGIN_ALLOW_THREADS int week = %CPPSELF.%FUNCTION_NAME(&yearNumber); - %PYARG_0 = Shiboken::makeTuple(week, yearNumber); + %END_ALLOW_THREADS + %PYARG_0 = PyTuple_New(2); + PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[int](week)); + PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[int](yearNumber)); - + + + + + + + + + %out = %OUTTYPE(); + + + int day = PyDateTime_GET_DAY(%in); + int month = PyDateTime_GET_MONTH(%in); + int year = PyDateTime_GET_YEAR(%in); + int hour = PyDateTime_DATE_GET_HOUR(%in); + int min = PyDateTime_DATE_GET_MINUTE(%in); + int sec = PyDateTime_DATE_GET_SECOND(%in); + int usec = PyDateTime_DATE_GET_MICROSECOND(%in); + %out = %OUTTYPE(QDate(year, month, day), QTime(hour, min, sec, usec/1000)); + + + @@ -632,6 +1257,13 @@ %0 = new %TYPE(date, time, Qt::TimeSpec(%8)); + + + QDate date(%1, %2, %3); + QTime time(%4, %5, %6); + %0 = new %TYPE(date, time); + + @@ -650,10 +1282,10 @@ - QDate date = %CPPSELF.date(); - QTime time = %CPPSELF.time(); - if (!PyDateTimeAPI) PyDateTime_IMPORT; - %PYARG_0 = PyDateTime_FromDateAndTime(date.year(), date.month(), date.day(), time.hour(), time.minute(), time.second(), time.msec()*1000); + QDate date = %CPPSELF.date(); + QTime time = %CPPSELF.time(); + if (!PyDateTimeAPI) PySideDateTime_IMPORT; + %PYARG_0 = PyDateTime_FromDateAndTime(date.year(), date.month(), date.day(), time.hour(), time.minute(), time.second(), time.msec()*1000); @@ -767,6 +1399,7 @@ } }; + @@ -784,9 +1417,9 @@ - int a, b, c, d; - %CPPSELF.%FUNCTION_NAME(&a, &b, &c, &d); - %PYARG_0 = Shiboken::makeTuple(a, b, c, d); + + + @@ -806,9 +1439,9 @@ - int a, b, c, d; - %CPPSELF.%FUNCTION_NAME(&a, &b, &c, &d); - %PYARG_0 = Shiboken::makeTuple(a, b, c, d); + + + @@ -851,9 +1484,9 @@ - qreal a, b, c, d; - %CPPSELF.%FUNCTION_NAME(&a, &b, &c, &d); - %PYARG_0 = Shiboken::makeTuple(a, b, c, d); + + + @@ -873,9 +1506,9 @@ - qreal a, b, c, d; - %CPPSELF.%FUNCTION_NAME(&a, &b, &c, &d); - %PYARG_0 = Shiboken::makeTuple(a, b, c, d); + + + @@ -954,7 +1587,26 @@ - + + + + + + + + + %out = %OUTTYPE(); + + + int hour = PyDateTime_TIME_GET_HOUR(%in); + int min = PyDateTime_TIME_GET_MINUTE(%in); + int sec = PyDateTime_TIME_GET_SECOND(%in); + int usec = PyDateTime_TIME_GET_MICROSECOND(%in); + %out = %OUTTYPE(hour, min, sec, usec/1000); + + + + @@ -977,8 +1629,8 @@ - if (!PyDateTimeAPI) PyDateTime_IMPORT; - %PYARG_0 = PyTime_FromTime(%CPPSELF.hour(), %CPPSELF.minute(), %CPPSELF.second(), %CPPSELF.msec()*1000); + if (!PyDateTimeAPI) PySideDateTime_IMPORT; + %PYARG_0 = PyTime_FromTime(%CPPSELF.hour(), %CPPSELF.minute(), %CPPSELF.second(), %CPPSELF.msec()*1000); @@ -1021,6 +1673,9 @@ + + + @@ -1140,11 +1795,12 @@ - if (_i < 0 || _i >= %CPPSELF.size()) { - PyErr_SetString(PyExc_IndexError, "index out of bounds"); - return 0; - } - return %CONVERTTOPYTHON[bool](%CPPSELF.at(_i)); + if (_i < 0 || _i >= %CPPSELF.size()) { + PyErr_SetString(PyExc_IndexError, "index out of bounds"); + return 0; + } + bool ret = %CPPSELF.at(_i); + return %CONVERTTOPYTHON[bool](ret); @@ -1233,7 +1889,8 @@ - %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%CPPSELF.%FUNCTION_NAME(%1, %2, %PYARG_3)); + %RETURN_TYPE %0 = %CPPSELF.%FUNCTION_NAME(%1, %2, %PYARG_3); + %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0); Creates a model index for the given row and column with the internal pointer ptr. @@ -1243,7 +1900,7 @@ .. warning:: Because of some Qt/Python itegration rules, the ptr argument do not get the reference incremented during the QModelIndex life time. So it is necessary to keep the object used on ptr argument alive during the whole process. Do not destroy the object if you are not sure about that. - + @@ -1264,7 +1921,8 @@ - %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%CPPSELF.%FUNCTION_NAME()); + %RETURN_TYPE %0 = %CPPSELF.%FUNCTION_NAME(); + %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0); @@ -1275,16 +1933,6 @@ - - - Shiboken::Object::keepReference((SbkObject*)%PYARG_1, "eventFilter", %PYSELF, true); - - - - - Shiboken::Object::removeReference((SbkObject*)%PYARG_1, "eventFilter", %PYSELF); - - @@ -1321,7 +1969,8 @@ // %FUNCTION_NAME() - disable generation of function call. - %PYARG_0 = %CONVERTTOPYTHON[bool](qobjectConnect(%1, %2, %CPPSELF, %3, %4)); + %RETURN_TYPE %0 = qobjectConnect(%1, %2, %CPPSELF, %3, %4); + %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0); @@ -1330,7 +1979,8 @@ // %FUNCTION_NAME() - disable generation of function call. - %PYARG_0 = %CONVERTTOPYTHON[bool](qobjectConnect(%1, %2, %3, %4, %5)); + %RETURN_TYPE %0 = qobjectConnect(%1, %2, %3, %4, %5); + %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0); @@ -1341,7 +1991,8 @@ // %FUNCTION_NAME() - disable generation of function call. - %PYARG_0 = %CONVERTTOPYTHON[bool](qobjectConnectCallback(%1, %2, %PYARG_3, %4)); + %RETURN_TYPE %0 = qobjectConnectCallback(%1, %2, %PYARG_3, %4); + %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0); @@ -1352,7 +2003,8 @@ // %FUNCTION_NAME() - disable generation of function call. - %PYARG_0 = %CONVERTTOPYTHON[bool](qobjectConnectCallback(%CPPSELF, %1, %PYARG_2, %3)); + %RETURN_TYPE %0 = qobjectConnectCallback(%CPPSELF, %1, %PYARG_2, %3); + %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0); @@ -1362,30 +2014,35 @@ // %FUNCTION_NAME() - disable generation of function call. - %PYARG_0 = %CONVERTTOPYTHON[bool](qobjectConnect(%CPPSELF, %1, %2, %3, %4)); + %RETURN_TYPE %0 = qobjectConnect(%CPPSELF, %1, %2, %3, %4); + %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0); - %PYARG_0 = %CONVERTTOPYTHON[bool](PySide::SignalManager::instance().emitSignal(%CPPSELF, %1, %PYARG_2)); + %RETURN_TYPE %0 = PySide::SignalManager::instance().emitSignal(%CPPSELF, %1, %PYARG_2); + %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0); // %FUNCTION_NAME() - disable generation of function call. - %PYARG_0 = %CONVERTTOPYTHON[bool](qobjectDisconnectCallback(%CPPSELF, %1, %2)); + %RETURN_TYPE %0 = qobjectDisconnectCallback(%CPPSELF, %1, %2); + %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0); // %FUNCTION_NAME() - disable generation of function call. - %PYARG_0 = %CONVERTTOPYTHON[bool](qobjectDisconnectCallback(%1, %2, %3)); + %RETURN_TYPE %0 = qobjectDisconnectCallback(%1, %2, %3); + %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0); - %PYARG_0 = %CONVERTTOPYTHON[QObject*](_findChildHelper(%CPPSELF, %2, (PyTypeObject*)%PYARG_1)); + QObject* child = _findChildHelper(%CPPSELF, %2, (PyTypeObject*)%PYARG_1); + %PYARG_0 = %CONVERTTOPYTHON[QObject*](child); @@ -1429,7 +2086,7 @@ if (QCoreApplication::instance()) { PyObject *klass = PyObject_GetAttrString(%PYSELF, "__class__"); PyObject *cname = PyObject_GetAttrString(klass, "__name__"); - result = QString(QCoreApplication::instance()->translate(PyString_AsString(cname), %1, %2, QCoreApplication::CodecForTr, %3)); + result = QString(QCoreApplication::instance()->translate(Shiboken::String::toCString(cname), %1, %2, QCoreApplication::CodecForTr, %3)); Py_DECREF(klass); Py_DECREF(cname); @@ -1440,6 +2097,18 @@ + @@ -1448,18 +2117,12 @@ - if (QCoreApplication::instance()) { - Shiboken::AutoDecRef klass(PyObject_GetAttrString(%PYSELF, "__class__")); - Shiboken::AutoDecRef cname(PyObject_GetAttrString(klass, "__name__")); - QString result = QCoreApplication::instance()->translate(PyString_AS_STRING(cname.object()), %1, %2, QCoreApplication::UnicodeUTF8, %3); - %PYARG_0 = %CONVERTTOPYTHON[QString](result); - } else { - Py_INCREF(%PYARG_1); - %PYARG_0 = %PYARG_1; - } + + + + - @@ -1468,28 +2131,20 @@ - if (QCoreApplication::instance()) { - Shiboken::AutoDecRef klass(PyObject_GetAttrString(%PYSELF, "__class__")); - Shiboken::AutoDecRef cname(PyObject_GetAttrString(klass, "__name__")); - Shiboken::AutoDecRef str(PyUnicode_AsUTF8String(%1)); - QString result = QCoreApplication::instance()->translate(PyString_AS_STRING(cname.object()), PyString_AS_STRING(str.object()), %2, QCoreApplication::UnicodeUTF8, %3); - %PYARG_0 = %CONVERTTOPYTHON[QString](result); - } else { - Py_INCREF(%PYARG_1); - %PYARG_0 = %PYARG_1; - } + + + + - // Avoid return +1 because SignalManager connect to "destroyed()" signal to control object timelife int ret = %CPPSELF.%FUNCTION_NAME(%1); - if (ret > 0 && ((strcmp(%1, SIGNAL(destroyed())) == 0) || (strcmp(%1, SIGNAL(destroyed(QObject*))) == 0))) { - if (PySide::SignalManager::instance().hasConnectionWith(%CPPSELF)) - ret--; - } + if (ret > 0 && ((strcmp(%1, SIGNAL(destroyed())) == 0) || (strcmp(%1, SIGNAL(destroyed(QObject*))) == 0))) + ret -= PySide::SignalManager::instance().countConnectionsWith(%CPPSELF); + %PYARG_0 = %CONVERTTOPYTHON[int](ret); @@ -1504,7 +2159,20 @@ - + + + + + + + + + + + + + + @@ -1613,7 +2281,21 @@ - + + + + %out = %OUTTYPE(); + + + %out = %OUTTYPE(Shiboken::String::toCString(%in), Shiboken::String::len(%in)); + + + #ifdef IS_PY3K + %out = %OUTTYPE(PyBytes_AS_STRING(%in), PyBytes_GET_SIZE(%in)); + #endif + + + @@ -1674,9 +2356,9 @@ - Shiboken::AutoDecRef str(PyUnicode_AsASCIIString(arg)); + Shiboken::AutoDecRef str(PyUnicode_AsASCIIString(%PYARG_1)); if (!str.isNull()) { - QByteArray b(PyString_AS_STRING(str.object()), PyString_GET_SIZE(str.object())); + QByteArray b(PyBytes_AS_STRING(str.object()), PyBytes_GET_SIZE (str.object())); b.prepend(*%CPPSELF); %PYARG_0 = %CONVERTTOPYTHON[QByteArray](b); } @@ -1684,18 +2366,18 @@ - Shiboken::AutoDecRef str(PyUnicode_AsASCIIString(arg)); + Shiboken::AutoDecRef str(PyUnicode_AsASCIIString(%PYARG_1)); if (!str.isNull()) { - QByteArray b(PyString_AS_STRING(str.object()), PyString_GET_SIZE(str.object())); + QByteArray b(PyBytes_AS_STRING(str.object()), PyBytes_GET_SIZE(str.object())); b.append(*%CPPSELF); %PYARG_0 = %CONVERTTOPYTHON[QByteArray](b); } - + - QByteArray b(PyString_AS_STRING(arg), PyString_GET_SIZE(arg)); - %PYARG_0 = %CONVERTTOPYTHON[QByteArray](b + *%CPPSELF); + QByteArray ba = QByteArray(PyBytes_AS_STRING(%PYARG_1), PyBytes_GET_SIZE(%PYARG_1)) + *%CPPSELF; + %PYARG_0 = %CONVERTTOPYTHON[QByteArray](ba); @@ -1703,11 +2385,16 @@ QByteArray b(((PyObject*)%PYSELF)->ob_type->tp_name); - b += '('; - Shiboken::AutoDecRef contents(PyObject_Repr(PyString_FromStringAndSize(%CPPSELF.constData(), %CPPSELF.size()))); - b += PyString_AS_STRING(contents.object()); - b += ")"; - %PYARG_0 = PyString_FromStringAndSize(b.constData(), b.size()); + PyObject* aux = Shiboken::String::fromStringAndSize(%CPPSELF.constData(), %CPPSELF.size()); + if (PyUnicode_CheckExact(aux)) { + PyObject* tmp = PyUnicode_AsASCIIString(aux); + Py_DECREF(aux); + aux = tmp; + } + b += "('"; + b += QByteArray(PyBytes_AS_STRING(aux), PyBytes_GET_SIZE(aux)); + b += "')"; + %PYARG_0 = Shiboken::String::fromStringAndSize(b.constData(), b.size()); @@ -1715,15 +2402,21 @@ - + - int size = PyString_GET_SIZE(pyargs[0]); - %0 = new QByteArray(%1, size); + if (PyBytes_Check(%PYARG_1)) { + %0 = new QByteArray(PyBytes_AsString(%PYARG_1), PyBytes_GET_SIZE(%PYARG_1)); + } if (PyUnicode_CheckExact(%PYARG_1)) { + Shiboken::AutoDecRef data(PyUnicode_AsASCIIString(%PYARG_1)); + %0 = new QByteArray(PyBytes_AsString(data.object()), PyBytes_GET_SIZE(data.object())); + } else if (Shiboken::String::check(%PYARG_1)) { + %0 = new QByteArray(Shiboken::String::toCString(%PYARG_1), Shiboken::String::len(%PYARG_1)); + } @@ -1737,7 +2430,7 @@ - %PYARG_0 = PyString_FromStringAndSize(%CPPSELF.%FUNCTION_NAME(), %CPPSELF.size()); + %PYARG_0 = PyBytes_FromStringAndSize(%CPPSELF.%FUNCTION_NAME(), %CPPSELF.size()); @@ -1852,11 +2545,15 @@ + + + - %PYARG_0 = %CONVERTTOPYTHON[QByteArray](%CPPSELF.%FUNCTION_NAME(PyString_AS_STRING(%PYARG_1), PyString_GET_SIZE(%PYARG_1))); + %RETURN_TYPE %0 = %CPPSELF.%FUNCTION_NAME(PyBytes_AsString(%PYARG_1), PyBytes_GET_SIZE(%PYARG_1)); + %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0); @@ -1877,7 +2574,7 @@ - %PYARG_0 = PyString_FromStringAndSize(%CPPSELF.constData(), %CPPSELF.size()); + %PYARG_0 = Shiboken::String::fromStringAndSize(%CPPSELF.constData(), %CPPSELF.size()); @@ -1894,7 +2591,7 @@ char res[2]; res[0] = %CPPSELF.at(_i); res[1] = 0; - return PyString_FromString(res); + return PyBytes_FromStringAndSize(res, 1); } @@ -1913,10 +2610,10 @@ Py_ssize_t max = %CPPSELF.count(); _i1 = qBound(Py_ssize_t(0), _i1, max); _i2 = qBound(Py_ssize_t(0), _i2, max); - - if (_i1 >= _i2) - return %CONVERTTOPYTHON[QByteArray](QByteArray()); - return %CONVERTTOPYTHON[QByteArray](%CPPSELF.mid(_i1, _i2 - _i1)); + QByteArray ba; + if (_i1 < _i2) + ba = %CPPSELF.mid(_i1, _i2 - _i1); + return %CONVERTTOPYTHON[QByteArray](ba); @@ -1943,6 +2640,7 @@ + @@ -1952,10 +2650,14 @@ uchar* ptr = (uchar*) Shiboken::Buffer::getPointer(%PYARG_1); - %PYARG_0 = %CONVERTTOPYTHON[bool](%CPPSELF.%FUNCTION_NAME(ptr)); + %RETURN_TYPE %0 = %CPPSELF.%FUNCTION_NAME(ptr); + %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0); + + + %PYARG_0 = Shiboken::Buffer::newObject(%CPPSELF.%FUNCTION_NAME(%1, %2, %3), %2, Shiboken::Buffer::ReadWrite); @@ -1981,14 +2683,15 @@ - + - + - + - - + + + @@ -1997,7 +2700,7 @@ - + QByteArray ba; ba.resize(%2); @@ -2011,16 +2714,17 @@ %RETURN_TYPE %out; - if (!PyString_Check(%PYARG_0)) { - %out = -1; - } else { - %out = PyString_GET_SIZE((PyObject*)%PYARG_0); - qstrncpy(%1, PyString_AS_STRING((PyObject*)%PYARG_0), %out + 1); + if (PyBytes_Check(%PYARG_0)) { + %out = PyBytes_GET_SIZE((PyObject*)%PYARG_0); + memcpy(%1, PyBytes_AS_STRING((PyObject*)%PYARG_0), %out); + } else if (Shiboken::String::check(%PYARG_0)) { + %out = Shiboken::String::len((PyObject*)%PYARG_0); + memcpy(%1, Shiboken::String::toCString((PyObject*)%PYARG_0), %out); } - + QByteArray ba; ba.resize(%2); @@ -2034,11 +2738,11 @@ %RETURN_TYPE %out; - if (!PyString_Check(%PYARG_0)) { + if (!PyBytes_Check(%PYARG_0)) { %out = -1; } else { - %out = PyString_GET_SIZE((PyObject*)%PYARG_0); - qstrncpy(%1, PyString_AS_STRING((PyObject*)%PYARG_0), %out + 1); + %out = PyBytes_GET_SIZE((PyObject*)%PYARG_0); + memcpy(%1, PyBytes_AS_STRING((PyObject*)%PYARG_0), %out); } @@ -2051,7 +2755,7 @@ - %CPPSELF.%FUNCTION_NAME(PyString_AS_STRING(%PYARG_1), PyString_GET_SIZE(%PYARG_1)); + %CPPSELF.%FUNCTION_NAME(Shiboken::String::toCString(%PYARG_1), Shiboken::String::len(%PYARG_1)); @@ -2096,12 +2800,14 @@ - Shiboken::AutoDecRef fileNo(PyObject_GetAttrString(%PYARG_1, "fileno")); - if (!fileNo.isNull()) { - Shiboken::AutoDecRef fileNoValue(PyObject_CallObject(fileNo, 0)); - if (%CHECKTYPE[int](fileNoValue)) - %0 = new %TYPE(%CONVERTTOCPP[int](fileNoValue), %2, %3); + Shiboken::AutoDecRef fileNo(PyObject_GetAttrString(%PYARG_1, "fileno")); + if (!fileNo.isNull()) { + Shiboken::AutoDecRef fileNoValue(PyObject_CallObject(fileNo, 0)); + if (%CHECKTYPE[int](fileNoValue)) { + int cppFileNoValue = %CONVERTTOCPP[int](fileNoValue); + %0 = new %TYPE(cppFileNoValue, %2, %3); } + } @@ -2151,6 +2857,9 @@ + + + @@ -2159,7 +2868,7 @@ - + @@ -2176,9 +2885,10 @@ - Py_ssize_t size; - uchar* ptr = (uchar*) Shiboken::Buffer::getPointer(%PYARG_1, &size); - %PYARG_0 = %CONVERTTOPYTHON[bool](%CPPSELF.%FUNCTION_NAME(const_cast<const uchar*>(ptr), size)); + Py_ssize_t size; + uchar* ptr = (uchar*) Shiboken::Buffer::getPointer(%PYARG_1, &size); + %RETURN_TYPE %0 = %CPPSELF.%FUNCTION_NAME(const_cast<const uchar*>(ptr), size); + %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0); @@ -2232,7 +2942,7 @@ if (PyObject_TypeCheck(%2, &PySideSignalInstanceType)) { PySideSignalInstance* signalInstance = reinterpret_cast<PySideSignalInstance*>(%2); - Shiboken::AutoDecRef signalSignature(PyString_FromFormat("2%s", PySide::Signal::getSignature(signalInstance))); + Shiboken::AutoDecRef signalSignature(Shiboken::String::fromFormat("2%s", PySide::Signal::getSignature(signalInstance))); Shiboken::AutoDecRef result( PyObject_CallMethod(pyTimer, const_cast<char*>("connect"), @@ -2249,7 +2959,7 @@ const_cast<char*>("OsO"), pyTimer, SIGNAL(timeout()), - pyargs[1]) + %PYARG_2) ); } @@ -2303,11 +3013,15 @@ - uchar* ptr = (uchar*)Shiboken::Buffer::getPointer(%PYARG_1); - %PYARG_0 = %CONVERTTOPYTHON[bool](%CPPSELF.%FUNCTION_NAME(ptr)); + uchar* ptr = (uchar*)Shiboken::Buffer::getPointer(%PYARG_1); + %RETURN_TYPE %0 = %CPPSELF.%FUNCTION_NAME(ptr); + %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0); + + + %PYARG_0 = Shiboken::Buffer::newObject(%CPPSELF.%FUNCTION_NAME(%1, %2, %3), %2, Shiboken::Buffer::ReadWrite); @@ -2318,7 +3032,7 @@ QByteArray ba; ba.resize(%2); %CPPSELF.%FUNCTION_NAME(ba.data(), ba.size()); - %PYARG_0 = PyString_FromStringAndSize(ba.constData(), ba.size()); + %PYARG_0 = PyBytes_FromStringAndSize(ba.constData(), ba.size()); @@ -2327,11 +3041,11 @@ %RETURN_TYPE %out; - if (!PyString_Check(%PYARG_0)) { + if (!Shiboken::String::check(%PYARG_0)) { %out = -1; } else { - %out = PyString_GET_SIZE((PyObject*)%PYARG_0); - qstrncpy(%1, PyString_AS_STRING((PyObject*)%PYARG_0), %out + 1); + %out = PyBytes_GET_SIZE((PyObject*)%PYARG_0); + memcpy(%1, PyBytes_AS_STRING((PyObject*)%PYARG_0), %out); } @@ -2341,7 +3055,7 @@ QByteArray ba; ba.resize(%2); %CPPSELF.%FUNCTION_NAME(ba.data(), ba.size()); - %PYARG_0 = PyString_FromStringAndSize(ba.constData(), ba.size()); + %PYARG_0 = PyBytes_FromStringAndSize(ba.constData(), ba.size()); @@ -2350,11 +3064,11 @@ %RETURN_TYPE %out; - if (!PyString_Check(%PYARG_0)) { + if (!Shiboken::String::check(%PYARG_0)) { %out = -1; } else { - %out = PyString_GET_SIZE((PyObject*)%PYARG_0); - qstrncpy(%1, PyString_AS_STRING((PyObject*)%PYARG_0), %out + 1); + %out = PyBytes_GET_SIZE((PyObject*)%PYARG_0); + memcpy(%1, PyBytes_AS_STRING((PyObject*)%PYARG_0), %out); } @@ -2384,9 +3098,25 @@ qint64 pid; %RETURN_TYPE retval = %TYPE::%FUNCTION_NAME(%1, %2, %3, &pid); - %PYARG_0 = Shiboken::makeTuple(retval, pid); + %PYARG_0 = PyTuple_New(2); + PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[%RETURN_TYPE](retval)); + PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[qint64](pid)); + + + + + long result; + #ifdef WIN32 + _PROCESS_INFORMATION* procInfo = %CPPSELF.%FUNCTION_NAME(); + result = procInfo ? procInfo->dwProcessId : 0; + #else + result = %CPPSELF.%FUNCTION_NAME(); + #endif + %PYARG_0 = %CONVERTTOPYTHON[long](result); + + @@ -2396,6 +3126,7 @@ + @@ -2477,8 +3208,10 @@ - %PYARG_0 = Shiboken::makeTuple(%0, *result_out); - delete result_out; + %PYARG_0 = PyTuple_New(2); + PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[%RETURN_TYPE](%0)); + PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[long](*result_out)); + delete result_out; @@ -2498,6 +3231,11 @@ + + + .. warning:: QSettings.value can return different types (QVariant types) depending on the platform it's running on, so the safest way to use it is always casting the result to the desired type, e.g.: int(settings.value("myKey")) + + @@ -2567,55 +3305,51 @@ + + + + + - - *(%CPPSELF) << %1; + + - - %RETURN_TYPE val; - *(%CPPSELF) >> val; - %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](val); + + - - *(%CPPSELF) << %1; + + - - %RETURN_TYPE val; - *(%CPPSELF) >> val; - %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](val); + + - - *(%CPPSELF) << %1; + + - - %RETURN_TYPE val; - *(%CPPSELF) >> val; - %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](val); + + - - *(%CPPSELF) << %1; + + - - %RETURN_TYPE val; - *(%CPPSELF) >> val; - %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](val); + + - @@ -2628,7 +3362,7 @@ Py_INCREF(Py_None); %PYARG_0 = Py_None; } else { - %PYARG_0 = PyString_FromStringAndSize(data.data(), result); + %PYARG_0 = PyBytes_FromStringAndSize(data.data(), result); } @@ -2637,7 +3371,7 @@ - int r = %CPPSELF.%FUNCTION_NAME(%1, PyString_GET_SIZE(%PYARG_1)); + int r = %CPPSELF.%FUNCTION_NAME(%1, Shiboken::String::len(%PYARG_1)); %PYARG_0 = %CONVERTTOPYTHON[int](r); @@ -2774,7 +3508,7 @@ - + @@ -2783,9 +3517,10 @@ - - + + + @@ -2798,12 +3533,18 @@ + + + + + + @@ -2811,6 +3552,15 @@ + + + + + QString& res = *%0; + %PYARG_0 = %CONVERTTOPYTHON[QString](res); + + + @@ -2828,7 +3578,24 @@ - + + + + + + + + + + + + + + + Shiboken::Object::releaseOwnership(%PYARG_0); + + + @@ -2837,7 +3604,7 @@ - + @@ -2908,7 +3675,13 @@ - + + + + + + + @@ -2984,12 +3757,13 @@ - for(int counter = 0; counter < %CPPSELF.animationCount(); ++counter ) { - PyObject* obj = %CONVERTTOPYTHON[QAbstractAnimation*](%CPPSELF.animationAt(counter)); - Shiboken::Object::setParent(NULL, obj); - Py_DECREF(obj); - } - %CPPSELF.clear(); + for(int counter = 0; counter < %CPPSELF.animationCount(); ++counter ) { + QAbstractAnimation* animation = %CPPSELF.animationAt(counter); + PyObject* obj = %CONVERTTOPYTHON[QAbstractAnimation*](animation); + Shiboken::Object::setParent(NULL, obj); + Py_DECREF(obj); + } + %CPPSELF.clear(); @@ -3040,6 +3814,27 @@ + + <code>machine = QStateMachine() + +s1 = new QState() +s11 = new QState(s1) +s12 = new QState(s1) + +s1h = QHistoryState(s1) +s1h.setDefaultState(s11) + +machine.addState(s1) + +s2 = QState() +machine.addState(s2) + +button = QPushButton() +# Clicking the button will cause the state machine to enter the child state +# that s1 was in the last time s1 was exited, or the history state's default +# state if s1 has never been entered. +s1.addTransition(button.clicked, s1h)</code> + @@ -3087,13 +3882,14 @@ - QString signalName(%2); - if (PySide::SignalManager::registerMetaMethod(%1, signalName.mid(1).toAscii().data(), QMetaMethod::Signal)) { - %PYARG_0 = %CONVERTTOPYTHON[QSignalTransition*](%CPPSELF->addTransition(%1, %2, %3)); - } else { + QString signalName(%2); + if (PySide::SignalManager::registerMetaMethod(%1, signalName.mid(1).toAscii().data(), QMetaMethod::Signal)) { + QSignalTransition* %0 = %CPPSELF->addTransition(%1, %2, %3); + %PYARG_0 = %CONVERTTOPYTHON[QSignalTransition*](%0); + } else { Py_INCREF(Py_None); %PYARG_0 = Py_None; - } + } @@ -3110,15 +3906,16 @@ - // Obviously the label used by the following goto is a very awkward solution, - // since it refers to a name very tied to the generator implementation. - // Check bug #362 for more information on this - // http://bugs.openbossa.org/show_bug.cgi?id=362 - if (!PyObject_TypeCheck(%1, &PySideSignalInstanceType)) - goto Sbk_%TYPEFunc_%FUNCTION_NAME_TypeError; - PySideSignalInstance* signalInstance = reinterpret_cast<PySideSignalInstance*>(%1); - QObject* sender = %CONVERTTOCPP[QObject*](PySide::Signal::getObject(signalInstance)); - %PYARG_0 = %CONVERTTOPYTHON[QSignalTransition*](%CPPSELF->%FUNCTION_NAME(sender, PySide::Signal::getSignature(signalInstance), %2)); + // Obviously the label used by the following goto is a very awkward solution, + // since it refers to a name very tied to the generator implementation. + // Check bug #362 for more information on this + // http://bugs.openbossa.org/show_bug.cgi?id=362 + if (!PyObject_TypeCheck(%1, &PySideSignalInstanceType)) + goto Sbk_%TYPEFunc_%FUNCTION_NAME_TypeError; + PySideSignalInstance* signalInstance = reinterpret_cast<PySideSignalInstance*>(%1); + QObject* sender = %CONVERTTOCPP[QObject*](PySide::Signal::getObject(signalInstance)); + QSignalTransition* %0 = %CPPSELF->%FUNCTION_NAME(sender, PySide::Signal::getSignature(signalInstance), %2); + %PYARG_0 = %CONVERTTOPYTHON[QSignalTransition*](%0); @@ -3177,15 +3974,15 @@ - + - %PYARG_0 = PyString_FromFormat("2%s", QMetaObject::normalizedSignature(%1).constData()); + %PYARG_0 = Shiboken::String::fromFormat("2%s", QMetaObject::normalizedSignature(%1).constData()); - + - %PYARG_0 = PyString_FromFormat("1%s", QMetaObject::normalizedSignature(%1).constData()); + %PYARG_0 = Shiboken::String::fromFormat("1%s", QMetaObject::normalizedSignature(%1).constData()); @@ -3228,14 +4025,20 @@ const unsigned char *, const unsigned char *); - + - %PYARG_0 = %CONVERTTOPYTHON[bool](%FUNCTION_NAME(%1, (uchar*)%2, (uchar*)%3, (uchar*)%4)); + %RETURN_TYPE %0 = %FUNCTION_NAME(%1, (uchar*)PyBytes_AS_STRING(%PYARG_2), + (uchar*)PyBytes_AS_STRING(%PYARG_3), + (uchar*)PyBytes_AS_STRING(%PYARG_4)); + %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0); - + - %PYARG_0 = %CONVERTTOPYTHON[bool](%FUNCTION_NAME(%1, (uchar*)%2, (uchar*)%3, (uchar*)%4)); + %RETURN_TYPE %0 = %FUNCTION_NAME(%1, (uchar*)PyBytes_AS_STRING(%PYARG_2), + (uchar*)PyBytes_AS_STRING(%PYARG_3), + (uchar*)PyBytes_AS_STRING(%PYARG_4)); + %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0); @@ -3283,8 +4086,12 @@ + + + + diff --git a/PySide/QtCore/typesystem_core_mac.xml b/PySide/QtCore/typesystem_core_mac.xml new file mode 100644 index 0000000..0f9c511 --- /dev/null +++ b/PySide/QtCore/typesystem_core_mac.xml @@ -0,0 +1,23 @@ + + + + + diff --git a/PySide/QtCore/typesystem_core_maemo.xml b/PySide/QtCore/typesystem_core_maemo.xml new file mode 100644 index 0000000..eba223c --- /dev/null +++ b/PySide/QtCore/typesystem_core_maemo.xml @@ -0,0 +1,26 @@ + + + + + + + + diff --git a/PySide/QtCore/typesystem_core_win.xml b/PySide/QtCore/typesystem_core_win.xml index c4150cd..26c7a82 100644 --- a/PySide/QtCore/typesystem_core_win.xml +++ b/PySide/QtCore/typesystem_core_win.xml @@ -19,9 +19,33 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA --> - - + + + + + #ifdef IS_PY3K + return PyCapsule_New(%in, 0, 0); + #else + return PyCObject_FromVoidPtr(%in, 0); + #endif + + + + %out = 0; + + + #ifdef IS_PY3K + %out = (%OUTTYPE)PyCapsule_GetPointer(%in, 0); + #else + %out = (%OUTTYPE)PyCObject_AsVoidPtr(%in); + #endif + + + + + + @@ -30,6 +54,4 @@ - - diff --git a/PySide/QtCore/typesystem_core_x11.xml b/PySide/QtCore/typesystem_core_x11.xml new file mode 100644 index 0000000..eba223c --- /dev/null +++ b/PySide/QtCore/typesystem_core_x11.xml @@ -0,0 +1,26 @@ + + + + + + + + diff --git a/PySide/QtDeclarative/CMakeLists.txt b/PySide/QtDeclarative/CMakeLists.txt index 01cf877..c9ea931 100644 --- a/PySide/QtDeclarative/CMakeLists.txt +++ b/PySide/QtDeclarative/CMakeLists.txt @@ -23,7 +23,7 @@ ${CMAKE_CURRENT_BINARY_DIR}/PySide/QtDeclarative/qdeclarativeview_wrapper.cpp ${CMAKE_CURRENT_BINARY_DIR}/PySide/QtDeclarative/qtdeclarative_module_wrapper.cpp ) -set(QtDeclarative_typesystem_path "${QtCore_SOURCE_DIR}${PATH_SEP}${QtGui_SOURCE_DIR}${PATH_SEP}${QtNetwork_SOURCE_DIR}${PATH_SEP}${QtDeclarative_SOURCE_DIR}${PATH_SEP}${QtGui_BINARY_DIR}") +set(QtDeclarative_typesystem_path "${QtCore_SOURCE_DIR}${PATH_SEP}${QtCore_BINARY_DIR}${PATH_SEP}${QtGui_SOURCE_DIR}${PATH_SEP}${QtNetwork_SOURCE_DIR}${PATH_SEP}${QtDeclarative_SOURCE_DIR}${PATH_SEP}${QtGui_BINARY_DIR}") set(QtDeclarative_include_dirs ${CMAKE_CURRENT_SOURCE_DIR} ${QT_QTCORE_INCLUDE_DIR} diff --git a/PySide/QtDeclarative/pysideqmlregistertype.cpp b/PySide/QtDeclarative/pysideqmlregistertype.cpp index f5b878b..4efc4bf 100644 --- a/PySide/QtDeclarative/pysideqmlregistertype.cpp +++ b/PySide/QtDeclarative/pysideqmlregistertype.cpp @@ -52,9 +52,7 @@ static void propListMetaCall(PySideProperty* pp, PyObject* self, QMetaObject::Ca static PyObject* pyTypes[PYSIDE_MAX_QML_TYPES]; static void (*createFuncs[PYSIDE_MAX_QML_TYPES])(void*); -/// QDeclarativeItem will create objects using placement new then this pointer is non-null. -void* PySide::nextQmlElementMemoryAddr = 0; -// Mutex used to avoid race condition on PySide::nextQmlElementMemoryAddr +// Mutex used to avoid race condition on PySide::nextQObjectMemoryAddr static QMutex nextQmlElementMutex; template @@ -63,12 +61,12 @@ struct ElementFactoryBase static void createInto(void* memory) { QMutexLocker locker(&nextQmlElementMutex); - PySide::nextQmlElementMemoryAddr = memory; + PySide::setNextQObjectMemoryAddr(memory); Shiboken::GilState state; PyObject* obj = PyObject_CallObject(pyTypes[N], 0); if (!obj || PyErr_Occurred()) PyErr_Print(); - PySide::nextQmlElementMemoryAddr = 0; + PySide::setNextQObjectMemoryAddr(0); } }; @@ -95,8 +93,9 @@ int PySide::qmlRegisterType(PyObject* pyObj, const char* uri, int versionMajor, { using namespace Shiboken; - static PyTypeObject* declarativeItemType = TypeResolver::get("QDeclarativeItem*")->pythonType(); - assert(declarativeItemType); + static PyTypeObject* qobjectType = Shiboken::Conversions::getPythonTypeObject("QObject*"); + static PyTypeObject* qdeclarativeType = Shiboken::Conversions::getPythonTypeObject("QDeclarativeItem*"); + assert(qobjectType); static int nextType = 0; if (nextType >= PYSIDE_MAX_QML_TYPES) { @@ -104,23 +103,46 @@ int PySide::qmlRegisterType(PyObject* pyObj, const char* uri, int versionMajor, return -1; } - if (!PySequence_Contains(((PyTypeObject*)pyObj)->tp_mro, (PyObject*)declarativeItemType)) { - PyErr_Format(PyExc_TypeError, "A type inherited from %s expected, got %s.", declarativeItemType->tp_name, ((PyTypeObject*)pyObj)->tp_name); + if (!PySequence_Contains(((PyTypeObject*)pyObj)->tp_mro, (PyObject*)qobjectType)) { + PyErr_Format(PyExc_TypeError, "A type inherited from %s expected, got %s.", qobjectType->tp_name, ((PyTypeObject*)pyObj)->tp_name); return -1; } + bool isDeclarativeType = PySequence_Contains(((PyTypeObject*)pyObj)->tp_mro, (PyObject*)qdeclarativeType); + QMetaObject* metaObject = reinterpret_cast(ObjectType::getTypeUserData(reinterpret_cast(pyObj))); Q_ASSERT(metaObject); + // Inc ref the type object, don't worry about dec ref them because there's no way to unregister a QML type + Py_INCREF(pyObj); + // All ready... now the ugly code begins... :-) pyTypes[nextType] = pyObj; // Init proxy object static meta object QDeclarativePrivate::RegisterType type; type.version = 0; - type.typeId = qMetaTypeId(); - type.listId = qMetaTypeId >(); - type.objectSize = sizeof(QDeclarativeItemWrapper); + if (isDeclarativeType) { + type.typeId = qMetaTypeId(); + type.listId = qMetaTypeId >(); + + type.attachedPropertiesFunction = QDeclarativePrivate::attachedPropertiesFunc(); + type.attachedPropertiesMetaObject = QDeclarativePrivate::attachedPropertiesMetaObject(); + + type.parserStatusCast = QDeclarativePrivate::StaticCastSelector::cast(); + type.valueSourceCast = QDeclarativePrivate::StaticCastSelector::cast(); + type.valueInterceptorCast = QDeclarativePrivate::StaticCastSelector::cast(); + } else { + type.typeId = qMetaTypeId(); + type.listId = qMetaTypeId >(); + type.attachedPropertiesFunction = QDeclarativePrivate::attachedPropertiesFunc(); + type.attachedPropertiesMetaObject = QDeclarativePrivate::attachedPropertiesMetaObject(); + + type.parserStatusCast = QDeclarativePrivate::StaticCastSelector::cast(); + type.valueSourceCast = QDeclarativePrivate::StaticCastSelector::cast(); + type.valueInterceptorCast = QDeclarativePrivate::StaticCastSelector::cast(); + } + type.objectSize = PySide::getSizeOfQObject(reinterpret_cast(pyObj)); type.create = createFuncs[nextType]; type.uri = uri; type.versionMajor = versionMajor; @@ -128,13 +150,6 @@ int PySide::qmlRegisterType(PyObject* pyObj, const char* uri, int versionMajor, type.elementName = qmlName; type.metaObject = metaObject; - type.attachedPropertiesFunction = QDeclarativePrivate::attachedPropertiesFunc(); - type.attachedPropertiesMetaObject = QDeclarativePrivate::attachedPropertiesMetaObject(); - - type.parserStatusCast = QDeclarativePrivate::StaticCastSelector::cast(); - type.valueSourceCast = QDeclarativePrivate::StaticCastSelector::cast(); - type.valueInterceptorCast = QDeclarativePrivate::StaticCastSelector::cast(); - type.extensionObjectCreate = 0; type.extensionMetaObject = 0; type.customParser = 0; @@ -185,12 +200,11 @@ void propListTpFree(void* self) PySideProperty* pySelf = reinterpret_cast(self); delete reinterpret_cast(PySide::Property::userData(pySelf)); // calls base type constructor - pySelf->ob_type->tp_base->tp_free(self); + Py_TYPE(pySelf)->tp_base->tp_free(self); } PyTypeObject PropertyListType = { - PyObject_HEAD_INIT(0) - 0, /*ob_size*/ + PyVarObject_HEAD_INIT(0, 0) "ListProperty", /*tp_name*/ sizeof(PySideProperty), /*tp_basicsize*/ 0, /*tp_itemsize*/ @@ -244,7 +258,10 @@ PyTypeObject PropertyListType = { void propListAppender(QDeclarativeListProperty* propList, QDeclarativeItem* item) { Shiboken::GilState state; - Shiboken::AutoDecRef args(Shiboken::makeTuple(propList->object, item)); + + Shiboken::AutoDecRef args(PyTuple_New(2)); + PyTuple_SET_ITEM(args, 0, Shiboken::Conversions::pointerToPython((SbkObjectType*)SbkPySide_QtCoreTypes[SBK_QOBJECT_IDX], propList->object)); + PyTuple_SET_ITEM(args, 1, Shiboken::Conversions::pointerToPython((SbkObjectType*)SbkPySide_QtDeclarativeTypes[SBK_QDECLARATIVEITEM_IDX], item)); DeclarativeListProperty* data = reinterpret_cast(propList->data); Shiboken::AutoDecRef retVal(PyObject_CallObject(data->append, args)); @@ -257,42 +274,50 @@ void propListAppender(QDeclarativeListProperty* propList, QDec int propListCount(QDeclarativeListProperty* propList) { Shiboken::GilState state; - Shiboken::AutoDecRef args(Shiboken::makeTuple(propList->object)); + + Shiboken::AutoDecRef args(PyTuple_New(1)); + PyTuple_SET_ITEM(args, 0, Shiboken::Conversions::pointerToPython((SbkObjectType*)SbkPySide_QtCoreTypes[SBK_QOBJECT_IDX], propList->object)); DeclarativeListProperty* data = reinterpret_cast(propList->data); Shiboken::AutoDecRef retVal(PyObject_CallObject(data->count, args)); // Check return type + int cppResult = 0; + PythonToCppFunc pythonToCpp; if (PyErr_Occurred()) PyErr_Print(); - else if (Shiboken::Converter::isConvertible(retVal)) - return Shiboken::Converter::toCpp(retVal); - - return 0; + else if ((pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(Shiboken::Conversions::PrimitiveTypeConverter(), retVal))) + pythonToCpp(retVal, &cppResult); + return cppResult; } // Implementation of QDeclarativeListProperty::AtFunction callback QDeclarativeItem* propListAt(QDeclarativeListProperty* propList, int index) { Shiboken::GilState state; - Shiboken::AutoDecRef args(Shiboken::makeTuple(propList->object, index)); + + Shiboken::AutoDecRef args(PyTuple_New(2)); + PyTuple_SET_ITEM(args, 0, Shiboken::Conversions::pointerToPython((SbkObjectType*)SbkPySide_QtCoreTypes[SBK_QOBJECT_IDX], propList->object)); + PyTuple_SET_ITEM(args, 1, Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter(), &index)); DeclarativeListProperty* data = reinterpret_cast(propList->data); Shiboken::AutoDecRef retVal(PyObject_CallObject(data->at, args)); + QDeclarativeItem* result = 0; if (PyErr_Occurred()) PyErr_Print(); else if (PyType_IsSubtype(Py_TYPE(retVal), data->type)) - return Shiboken::Converter::toCpp(retVal); - - return 0; + Shiboken::Conversions::pythonToCppPointer((SbkObjectType*)SbkPySide_QtCoreTypes[SBK_QDECLARATIVEITEM_IDX], retVal, &result); + return result; } // Implementation of QDeclarativeListProperty::ClearFunction callback void propListClear(QDeclarativeListProperty* propList) { Shiboken::GilState state; - Shiboken::AutoDecRef args(Shiboken::makeTuple(propList->object)); + + Shiboken::AutoDecRef args(PyTuple_New(1)); + PyTuple_SET_ITEM(args, 0, Shiboken::Conversions::pointerToPython((SbkObjectType*)SbkPySide_QtCoreTypes[SBK_QOBJECT_IDX], propList->object)); DeclarativeListProperty* data = reinterpret_cast(propList->data); Shiboken::AutoDecRef retVal(PyObject_CallObject(data->clear, args)); @@ -308,7 +333,9 @@ static void propListMetaCall(PySideProperty* pp, PyObject* self, QMetaObject::Ca return; DeclarativeListProperty* data = reinterpret_cast(PySide::Property::userData(pp)); - QDeclarativeListProperty declProp(Shiboken::Converter::toCpp(self), data, &propListAppender); + QObject* qobj; + Shiboken::Conversions::pythonToCppPointer((SbkObjectType*)SbkPySide_QtCoreTypes[SBK_QOBJECT_IDX], self, &qobj); + QDeclarativeListProperty declProp(qobj, data, &propListAppender); if (data->count) declProp.count = &propListCount; diff --git a/PySide/QtDeclarative/typesystem_declarative.xml b/PySide/QtDeclarative/typesystem_declarative.xml index bf9a575..1bc18ba 100644 --- a/PySide/QtDeclarative/typesystem_declarative.xml +++ b/PySide/QtDeclarative/typesystem_declarative.xml @@ -46,7 +46,8 @@ - %PYARG_0 = %CONVERTTOPYTHON[int](PySide::qmlRegisterType(%1, %2, %3, %4, %5)); + int %0 = PySide::qmlRegisterType(%ARGUMENT_NAMES); + %PYARG_0 = %CONVERTTOPYTHON[int](%0); @@ -59,8 +60,7 @@ - Shiboken::TypeResolver::createValueTypeResolver< QList<QObject*> >("QList<QObject*>"); - PySide::initQmlSupport(module); + PySide::initQmlSupport(module); @@ -91,26 +91,44 @@ + + + + + + + + + QString errorString; + %BEGIN_ALLOW_THREADS + %RETURN_TYPE ok_ = %CPPSELF.%FUNCTION_NAME(%1, %2, &errorString); + %END_ALLOW_THREADS + %PYARG_0 = PyTuple_New(2); + PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[%RETURN_TYPE](ok_)); + PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[QString](errorString)); + + - + + + + + + + + + + - + - - - if (PySide::nextQmlElementMemoryAddr) - %0 = new (PySide::nextQmlElementMemoryAddr) ::QDeclarativePrivate::QDeclarativeElement<%TYPE>(); - else - %0 = new %TYPE(%1); - - diff --git a/PySide/QtGui/CMakeLists.txt b/PySide/QtGui/CMakeLists.txt index 8f8ff97..7625634 100644 --- a/PySide/QtGui/CMakeLists.txt +++ b/PySide/QtGui/CMakeLists.txt @@ -15,7 +15,6 @@ if(ENABLE_X11) endif() endif() - if (${QT_VERSION_MAJOR} EQUAL 4 AND ${QT_VERSION_MINOR} LESS 6) set(QtGui_46_SRC "") else() @@ -60,6 +59,14 @@ else() ) endif () +if (${QT_VERSION_MAJOR} EQUAL 4 AND ${QT_VERSION_MINOR} LESS 7) + set(QtGui_47_SRC "") +else() + set(QtGui_47_SRC + ${CMAKE_CURRENT_BINARY_DIR}/PySide/QtGui/qpainter_pixmapfragment_wrapper.cpp + ) +endif() + set(QtGui_OPTIONAL_SRC ) set(QtGui_DROPPED_ENTRIES ) check_qt_class(QtGui QAbstractPageSetupDialog QtGui_OPTIONAL_SRC QtGui_DROPPED_ENTRIES) @@ -398,13 +405,15 @@ ${CMAKE_CURRENT_BINARY_DIR}/PySide/QtGui/qworkspace_wrapper.cpp ${SPECIFIC_OS_FILES} ${QPYTEXTOBJECT_MOC} ${QtGui_46_SRC} +${QtGui_47_SRC} ${QtGui_OPTIONAL_SRC} ) configure_file("${CMAKE_CURRENT_SOURCE_DIR}/typesystem_gui.xml.in" "${CMAKE_CURRENT_BINARY_DIR}/typesystem_gui.xml" @ONLY) -set(QtGui_typesystem_path "${QtCore_SOURCE_DIR}${PATH_SEP}${QtGui_SOURCE_DIR}") +set(QtGui_typesystem_path "${QtCore_SOURCE_DIR}${PATH_SEP}${QtCore_BINARY_DIR}${PATH_SEP}${QtGui_SOURCE_DIR}") + set(QtGui_include_dirs ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR}/PySide/QtGui/ ${pyside_SOURCE_DIR} diff --git a/PySide/QtGui/glue/qlayout_help_functions.cpp b/PySide/QtGui/glue/qlayout_help_functions.cpp new file mode 100644 index 0000000..b366061 --- /dev/null +++ b/PySide/QtGui/glue/qlayout_help_functions.cpp @@ -0,0 +1,122 @@ +void addLayoutOwnership(QLayout* layout, QLayoutItem* item); +void removeLayoutOwnership(QLayout* layout, QWidget* widget); + +inline QByteArray retrieveObjectName(PyObject* obj) +{ + Shiboken::AutoDecRef objName(PyObject_Str(obj)); + return Shiboken::String::toCString(objName); +} + +inline void addLayoutOwnership(QLayout* layout, QWidget* widget) +{ + //transfer ownership to parent widget + QWidget *lw = layout->parentWidget(); + QWidget *pw = widget->parentWidget(); + + Shiboken::AutoDecRef pyChild(%CONVERTTOPYTHON[QWidget*](widget)); + + //Transfer parent to layout widget + if (pw && lw && pw != lw) + Shiboken::Object::setParent(0, pyChild); + + if (!lw && !pw) { + //keep the reference while the layout is orphan + Shiboken::AutoDecRef pyParent(%CONVERTTOPYTHON[QWidget*](layout)); + Shiboken::Object::keepReference(reinterpret_cast(pyParent.object()), retrieveObjectName(pyParent).data(), pyChild, true); + } else { + if (!lw) + lw = pw; + Shiboken::AutoDecRef pyParent(%CONVERTTOPYTHON[QWidget*](lw)); + Shiboken::Object::setParent(pyParent, pyChild); + } +} + +inline void addLayoutOwnership(QLayout* layout, QLayout* other) +{ + //transfer all children widgets from other to layout parent widget + QWidget* parent = layout->parentWidget(); + if (!parent) { + //keep the reference while the layout is orphan + Shiboken::AutoDecRef pyParent(%CONVERTTOPYTHON[QLayout*](layout)); + Shiboken::AutoDecRef pyChild(%CONVERTTOPYTHON[QLayout*](other)); + Shiboken::Object::keepReference(reinterpret_cast(pyParent.object()), retrieveObjectName(pyParent).data(), pyChild, true); + return; + } + + for (int i=0, i_max=other->count(); i < i_max; i++) { + QLayoutItem* item = other->itemAt(i); + if (PyErr_Occurred() || !item) + return; + addLayoutOwnership(layout, item); + } + + Shiboken::AutoDecRef pyParent(%CONVERTTOPYTHON[QLayout*](layout)); + Shiboken::AutoDecRef pyChild(%CONVERTTOPYTHON[QLayout*](other)); + Shiboken::Object::setParent(pyParent, pyChild); +} + +inline void addLayoutOwnership(QLayout* layout, QLayoutItem* item) +{ + if (!item) + return; + + QWidget* w = item->widget(); + if (w) + addLayoutOwnership(layout, w); + else { + QLayout* l = item->layout(); + if (l) + addLayoutOwnership(layout, l); + } + + Shiboken::AutoDecRef pyParent(%CONVERTTOPYTHON[QLayout*](layout)); + Shiboken::AutoDecRef pyChild(%CONVERTTOPYTHON[QLayoutItem*](item)); + Shiboken::Object::setParent(pyParent, pyChild); +} + +static void removeWidgetFromLayout(QLayout* layout, QWidget* widget) +{ + QWidget* parent = widget->parentWidget(); + + if (!parent) { + //remove reference on layout + Shiboken::AutoDecRef pyParent(%CONVERTTOPYTHON[QWidget*](layout)); + Shiboken::AutoDecRef pyChild(%CONVERTTOPYTHON[QWidget*](widget)); + Shiboken::Object::removeReference(reinterpret_cast(pyParent.object()), retrieveObjectName(pyParent).data(), pyChild); + } else { + //give the ownership to parent + Shiboken::AutoDecRef pyParent(%CONVERTTOPYTHON[QWidget*](parent)); + Shiboken::AutoDecRef pyChild(%CONVERTTOPYTHON[QWidget*](widget)); + Shiboken::Object::setParent(pyParent, pyChild); + } +} + +inline void removeLayoutOwnership(QLayout* layout, QLayoutItem* item) +{ + QWidget* w = item->widget(); + if (w) + removeWidgetFromLayout(layout, w); + else { + QLayout* l = item->layout(); + if (l) + removeLayoutOwnership(layout, l); + } + + Shiboken::AutoDecRef pyChild(%CONVERTTOPYTHON[QLayoutItem*](item)); + Shiboken::Object::invalidate(pyChild); + Shiboken::Object::setParent(0, pyChild); +} + +inline void removeLayoutOwnership(QLayout* layout, QWidget* widget) +{ + if (!widget) + return; + + for (int i=0, i_max=layout->count(); i < i_max; i++) { + QLayoutItem* item = layout->itemAt(i); + if (PyErr_Occurred() || !item) + return; + if (item->widget() == widget) + removeLayoutOwnership(layout, item); + } +} diff --git a/PySide/QtGui/glue/qlayout_help_functions.h b/PySide/QtGui/glue/qlayout_help_functions.h deleted file mode 100644 index 90c950a..0000000 --- a/PySide/QtGui/glue/qlayout_help_functions.h +++ /dev/null @@ -1,71 +0,0 @@ -#ifndef QLAYOUT_HELP_FUNCTIONS -#define QLAYOUT_HELP_FUNCTIONS - -void addLayoutOwnership(QLayout* layout, QLayoutItem* item); - -inline QByteArray retrieveObjectName(PyObject* obj) -{ - Shiboken::AutoDecRef objName(PyObject_Str(obj)); - return PyString_AsString(objName); -} - -inline void addLayoutOwnership(QLayout* layout, QWidget* widget) -{ - //transfer ownership to parent widget - QWidget* parent = layout->parentWidget(); - - if (!parent) { - //keep the reference while the layout is orphan - Shiboken::AutoDecRef pyParent(Shiboken::Converter::toPython(layout)); - Shiboken::AutoDecRef pyChild(Shiboken::Converter::toPython(widget)); - Shiboken::Object::keepReference(reinterpret_cast(pyParent.object()), retrieveObjectName(pyParent).data(), pyChild, true); - } else { - Shiboken::AutoDecRef pyParent(Shiboken::Converter::toPython(parent)); - Shiboken::AutoDecRef pyChild(Shiboken::Converter::toPython(widget)); - Shiboken::Object::setParent(pyParent, pyChild); - } -} - -inline void addLayoutOwnership(QLayout* layout, QLayout* other) -{ - //transfer all children widgets from other to layout parent widget - QWidget* parent = layout->parentWidget(); - if (!parent) { - //keep the reference while the layout is orphan - Shiboken::AutoDecRef pyParent(Shiboken::Converter::toPython(layout)); - Shiboken::AutoDecRef pyChild(Shiboken::Converter::toPython(other)); - Shiboken::Object::keepReference(reinterpret_cast(pyParent.object()), retrieveObjectName(pyParent).data(), pyChild, true); - return; - } - - for (int i=0, i_max=other->count(); i < i_max; i++) { - QLayoutItem* item = other->itemAt(i); - if (PyErr_Occurred() || !item) - return; - - addLayoutOwnership(layout, item); - } - - Shiboken::AutoDecRef pyParent(Shiboken::Converter::toPython(layout)); - Shiboken::AutoDecRef pyChild(Shiboken::Converter::toPython(other)); - Shiboken::Object::setParent(pyParent, pyChild); - -} - -inline void addLayoutOwnership(QLayout* layout, QLayoutItem* item) -{ - QWidget* w = item->widget(); - if (w) - addLayoutOwnership(layout, w); - else { - QLayout* l = item->layout(); - if (l) - addLayoutOwnership(layout, l); - } - - Shiboken::AutoDecRef pyParent(Shiboken::Converter::toPython(layout)); - Shiboken::AutoDecRef pyChild(Shiboken::Converter::toPython(item)); - Shiboken::Object::setParent(pyParent, pyChild); -} - -#endif diff --git a/PySide/QtGui/glue/qmenu_glue.h b/PySide/QtGui/glue/qmenu_glue.cpp similarity index 88% rename from PySide/QtGui/glue/qmenu_glue.h rename to PySide/QtGui/glue/qmenu_glue.cpp index 94eab15..0636dfa 100644 --- a/PySide/QtGui/glue/qmenu_glue.h +++ b/PySide/QtGui/glue/qmenu_glue.cpp @@ -1,4 +1,3 @@ - inline PyObject* addActionWithPyObject(QMenu* self, const QIcon& icon, const QString& text, PyObject* callback, const QKeySequence& shortcut) { QAction* act = new QAction(text, self); @@ -11,7 +10,7 @@ inline PyObject* addActionWithPyObject(QMenu* self, const QIcon& icon, const QSt self->addAction(act); - PyObject* pyAct = Shiboken::Converter::toPython(act); + PyObject* pyAct = %CONVERTTOPYTHON[QAction*](act); Shiboken::AutoDecRef result(PyObject_CallMethod(pyAct, "connect", "OsO", pyAct, SIGNAL(triggered()), callback)); if (result.isNull()) { Py_DECREF(pyAct); diff --git a/PySide/QtGui/glue/qmenubar_glue.h b/PySide/QtGui/glue/qmenubar_glue.cpp similarity index 87% rename from PySide/QtGui/glue/qmenubar_glue.h rename to PySide/QtGui/glue/qmenubar_glue.cpp index 9568fa8..2326a76 100644 --- a/PySide/QtGui/glue/qmenubar_glue.h +++ b/PySide/QtGui/glue/qmenubar_glue.cpp @@ -5,7 +5,7 @@ addActionWithPyObject(QMenuBar* self, const QString& text, PyObject* callback) self->addAction(act); - PyObject* pyAct = Shiboken::Converter::toPython(act); + PyObject* pyAct = %CONVERTTOPYTHON[QAction*](act); PyObject* result = PyObject_CallMethod(pyAct, "connect", "OsO", pyAct, SIGNAL(triggered(bool)), callback); diff --git a/PySide/QtGui/glue/qtgui_qapp.cpp b/PySide/QtGui/glue/qtgui_qapp.cpp index 4c4508b..5148b57 100644 --- a/PySide/QtGui/glue/qtgui_qapp.cpp +++ b/PySide/QtGui/glue/qtgui_qapp.cpp @@ -1,6 +1,6 @@ // Init qApp macro to None. if (qApp) { - PyObject* pyApp = Shiboken::Converter::toPython(qApp); + PyObject* pyApp = %CONVERTTOPYTHON[QApplication*](qApp); Py_INCREF(pyApp); PyModule_AddObject(module, "qApp", pyApp); } else { diff --git a/PySide/QtGui/glue/qwidget_glue.h b/PySide/QtGui/glue/qwidget_glue.cpp similarity index 82% rename from PySide/QtGui/glue/qwidget_glue.h rename to PySide/QtGui/glue/qwidget_glue.cpp index 129a54a..cfa3f67 100644 --- a/PySide/QtGui/glue/qwidget_glue.h +++ b/PySide/QtGui/glue/qwidget_glue.cpp @@ -1,7 +1,7 @@ static QString retrieveObjectName(PyObject *obj) { Shiboken::AutoDecRef objName(PyObject_Str(obj)); - return QString(PyString_AsString(objName)); + return QString(Shiboken::String::toCString(objName)); } @@ -10,7 +10,7 @@ static QString retrieveObjectName(PyObject *obj) **/ static inline void qwidgetReparentLayout(QWidget *parent, QLayout *layout) { - Shiboken::AutoDecRef pyParent(Shiboken::Converter::toPython(parent)); + Shiboken::AutoDecRef pyParent(%CONVERTTOPYTHON[QWidget*](parent)); for (int i=0; i < layout->count(); i++) { QLayoutItem* item = layout->itemAt(i); @@ -21,7 +21,7 @@ static inline void qwidgetReparentLayout(QWidget *parent, QLayout *layout) if (w) { QWidget* pw = w->parentWidget(); if (pw != parent) { - Shiboken::AutoDecRef pyChild(Shiboken::Converter::toPython(w)); + Shiboken::AutoDecRef pyChild(%CONVERTTOPYTHON[QWidget*](w)); Shiboken::Object::setParent(pyParent, pyChild); } } else { @@ -31,7 +31,7 @@ static inline void qwidgetReparentLayout(QWidget *parent, QLayout *layout) } } - Shiboken::AutoDecRef pyChild(Shiboken::Converter::toPython(layout)); + Shiboken::AutoDecRef pyChild(%CONVERTTOPYTHON[QLayout*](layout)); Shiboken::Object::setParent(pyParent, pyChild); //remove previous references Shiboken::Object::keepReference(reinterpret_cast(pyChild.object()), qPrintable(retrieveObjectName(pyChild)), Py_None); @@ -46,7 +46,7 @@ static inline void qwidgetSetLayout(QWidget *self, QLayout *layout) if (oldParent && oldParent != self) { if (oldParent->isWidgetType()) { // remove old parent policy - Shiboken::AutoDecRef pyLayout(Shiboken::Converter::toPython(layout)); + Shiboken::AutoDecRef pyLayout(%CONVERTTOPYTHON[QLayout*](layout)); Shiboken::Object::setParent(Py_None, pyLayout); } else { PyErr_Format(PyExc_RuntimeError, "QWidget::setLayout: Attempting to set QLayout \"%s\" on %s \"%s\", when the QLayout already has a parent", diff --git a/PySide/QtGui/glue/wid_conversions.h b/PySide/QtGui/glue/wid_conversions.h deleted file mode 100644 index 9901218..0000000 --- a/PySide/QtGui/glue/wid_conversions.h +++ /dev/null @@ -1,32 +0,0 @@ -namespace Shiboken { -template <> -struct Converter -{ - static bool checkType(PyObject* pyObj) - { - return false; - } - - static bool isConvertible(PyObject* pyobj) - { - return PyCObject_Check(pyobj); - } - - static inline PyObject* toPython(void* cppobj) - { - // not supported - Q_ASSERT(true); - return 0; - } - - static PyObject* toPython(WId cppobj) - { - return PyCObject_FromVoidPtr(cppobj, 0); - } - - static WId toCpp(PyObject* pyobj) - { - return (WId) PyCObject_AsVoidPtr(pyobj); - } -}; -} diff --git a/PySide/QtGui/qpixmap_conversion.h b/PySide/QtGui/qpixmap_conversion.h deleted file mode 100644 index fc49af6..0000000 --- a/PySide/QtGui/qpixmap_conversion.h +++ /dev/null @@ -1,49 +0,0 @@ -namespace Shiboken { -inline bool Converter::checkType(PyObject* pyObj) -{ - return ValueTypeConverter::checkType(pyObj); -} - -inline bool Converter::isConvertible(PyObject* pyobj) -{ - if (ValueTypeConverter::isConvertible(pyobj)) - return true; - SbkObjectType* shiboType = reinterpret_cast(SbkType()); - bool isVariant = Shiboken::Converter::checkType(pyobj); - if (isVariant) { - QVariant var(Shiboken::Converter::toCpp(pyobj)); - return var.type() == QVariant::Pixmap; - } else if (Shiboken::Converter::checkType(pyobj) || Shiboken::Converter::checkType(pyobj)) { - return true; - } else { - return Shiboken::ObjectType::isExternalConvertible(shiboType, pyobj); - } - return false; - -} - -inline QPixmap Converter::toCpp(PyObject* pyobj) -{ - SbkObjectType* shiboType = reinterpret_cast(SbkType()); - bool isVariant = Converter::checkType(pyobj); - if (isVariant) { - QVariant var(Converter::toCpp(pyobj)); - return var.value(); - } else if (Converter::checkType(pyobj)) { - return QPixmap(Shiboken::Converter::toCpp(pyobj)); - } else if (Converter::checkType(pyobj)) { - return QPixmap(Shiboken::Converter::toCpp(pyobj)); - } else if (Shiboken::ObjectType::isExternalConvertible(shiboType, pyobj) && Shiboken::ObjectType::hasExternalCppConversions(shiboType)) { - QPixmap* cptr = reinterpret_cast(Shiboken::ObjectType::callExternalCppConversion(shiboType, pyobj)); - std::auto_ptr cptr_auto_ptr(cptr); - return *cptr; - } - - return *Converter::toCpp(pyobj); -} - -inline PyObject* Converter::toPython(const QPixmap& cppObj) -{ - return ValueTypeConverter::toPython(cppObj); -} -} diff --git a/PySide/QtGui/typesystem_gui_common.xml b/PySide/QtGui/typesystem_gui_common.xml index d3473d4..552636a 100644 --- a/PySide/QtGui/typesystem_gui_common.xml +++ b/PySide/QtGui/typesystem_gui_common.xml @@ -22,11 +22,12 @@ - + + + + + + + + @@ -811,15 +831,15 @@ - + - const uchar* %out = reinterpret_cast<const uchar*>(PyString_AS_STRING(%PYARG_1)); + const uchar* %out = reinterpret_cast<const uchar*>(PyBytes_AS_STRING(%PYARG_1)); - uint %out = static_cast<uint>(PyString_GET_SIZE(%PYARG_1)); + uint %out = static_cast<uint>(PyBytes_Size(%PYARG_1)); @@ -900,9 +920,11 @@ @@ -949,6 +971,7 @@ + @@ -996,14 +1019,14 @@ - + - + @@ -1056,11 +1079,17 @@ %PYARG_0 = Shiboken::Buffer::newObject(%CPPSELF.%FUNCTION_NAME(%1), %CPPSELF.bytesPerLine()); + + + %PYARG_0 = Shiboken::Buffer::newObject(%CPPSELF.%FUNCTION_NAME(%1), %CPPSELF.bytesPerLine(), Shiboken::Buffer::ReadWrite); + + + @@ -1220,7 +1307,9 @@ - + + + @@ -1245,7 +1334,9 @@ - + + + @@ -1395,7 +1486,7 @@ - + @@ -1404,7 +1495,7 @@ - + @@ -1471,7 +1562,7 @@ - + @@ -1480,7 +1571,7 @@ - + @@ -1618,13 +1709,20 @@ + - - - - - - + + + + + + @@ -1692,11 +1790,25 @@ - QGraphicsItem *item_ = NULL; - %RETURN_TYPE retval_ = %CPPSELF.%FUNCTION_NAME(&item_); - %PYARG_0 = Shiboken::makeTuple(retval_, item_); + QGraphicsItem *item_ = NULL; + %RETURN_TYPE retval_ = %CPPSELF.%FUNCTION_NAME(&item_); + %PYARG_0 = PyTuple_New(2); + PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[%RETURN_TYPE](retval_)); + PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[QGraphicsItem*](item_)); + + + + + + + + + + + + @@ -1795,8 +1907,6 @@ - - @@ -1990,6 +2100,17 @@ + + + + + + + + + + + @@ -2134,6 +2255,7 @@ + @@ -2144,16 +2266,18 @@ + - + + @@ -2164,6 +2288,7 @@ + @@ -2239,9 +2364,7 @@ - - - + @@ -2291,30 +2414,51 @@ - + + + + + %PYARG_0 = addActionWithPyObject(%CPPSELF, QIcon(), %1, %2, %3); - + + + + + %PYARG_0 = addActionWithPyObject(%CPPSELF, %1, %2, %3, %4); + + + Shiboken::BindingManager& bm = Shiboken::BindingManager::instance(); + PyObject* pyObj; + foreach(QAction* act, %CPPSELF.actions()) { + if ((pyObj = (PyObject*)bm.retrieveWrapper(act)) != 0) { + Py_INCREF(pyObj); + Shiboken::Object::setParent(NULL, pyObj); + Shiboken::Object::invalidate(pyObj); + Py_DECREF(pyObj); + } + } + + + - - - + @@ -2359,6 +2503,15 @@ + + + foreach(QAction *act, %CPPSELF.actions()) { + Shiboken::AutoDecRef pyAct(%CONVERTTOPYTHON[QAction*](act)); + Shiboken::Object::setParent(NULL, pyAct); + Shiboken::Object::invalidate(pyAct); + } + + @@ -2375,8 +2528,18 @@ + + + QPixmap p; + if (%CPPSELF.%FUNCTION_NAME(%1, &p)) { + %PYARG_0 = %CONVERTTOPYTHON[QPixmap](p); + } else { + %PYARG_0 = Py_None; + Py_INCREF(%PYARG_0); + } + + - @@ -2400,7 +2563,7 @@ - + @@ -2563,6 +2726,11 @@ + + + + + @@ -2876,7 +3044,8 @@ - %PYARG_0 = %CONVERTTOPYTHON[bool](!(&%CPPSELF == %1)); + bool ret = !(&%CPPSELF == %1); + %PYARG_0 = %CONVERTTOPYTHON[bool](ret); @@ -2927,12 +3096,30 @@ + + + + + + + + + + + + + + + + + + @@ -2952,10 +3139,7 @@ - - - - + @@ -2968,6 +3152,17 @@ + + + removeLayoutOwnership(%CPPSELF, %1); + + + + + removeLayoutOwnership(%CPPSELF, %1); + + + @@ -3044,9 +3239,7 @@ - - - + @@ -3056,9 +3249,7 @@ - - - + @@ -3102,9 +3293,15 @@ - - - + + + + + + + addLayoutOwnership(%CPPSELF, %0); + + @@ -3169,9 +3366,13 @@ - int a, b, c, d; - %CPPSELF.%FUNCTION_NAME(%1, &a, &b, &c, &d); - %PYARG_0 = Shiboken::makeTuple(a, b, c, d); + int a, b, c, d; + %CPPSELF.%FUNCTION_NAME(%1, &a, &b, &c, &d); + %PYARG_0 = PyTuple_New(4); + PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[int](a)); + PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[int](b)); + PyTuple_SET_ITEM(%PYARG_0, 2, %CONVERTTOPYTHON[int](c)); + PyTuple_SET_ITEM(%PYARG_0, 3, %CONVERTTOPYTHON[int](d)); @@ -3193,6 +3394,9 @@ + + + @@ -3216,10 +3420,6 @@ - - - - @@ -3231,7 +3431,7 @@ int numItems = PySequence_Size(%PYARG_1); - PySide::AutoArrayPointer<QGraphicsItem*> %out(numItems); + Shiboken::AutoArrayPointer<QGraphicsItem*> %out(numItems); for (int i=0; i < numItems; i++) { %out[i] = %CONVERTTOCPP[QGraphicsItem*](PySequence_Fast_GET_ITEM(%PYARG_1, i)); } @@ -3251,14 +3451,15 @@ Shiboken::AutoDecRef option_object(PyList_New(0)); for (int i=0, max=numItems; i < max; i++) { - PyList_Append(option_object, %CONVERTTOPYTHON[QStyleOptionGraphicsItem](%in[i])); + const QStyleOptionGraphicsItem* item = &%in[i]; + PyList_Append(option_object, %CONVERTTOPYTHON[QStyleOptionGraphicsItem](item)); } - PyObject *%out = option_object.object(); + PyObject* %out = option_object.object(); int numOptions = PySequence_Size(%PYARG_2); - PySide::AutoArrayPointer<QStyleOptionGraphicsItem> %out(numOptions); + Shiboken::AutoArrayPointer<QStyleOptionGraphicsItem> %out(numOptions); for (int i=0; i < numOptions; i++) { %out[i] = %CONVERTTOCPP[QStyleOptionGraphicsItem](PySequence_Fast_GET_ITEM(%PYARG_1, i)); } @@ -3269,7 +3470,7 @@ - + @@ -3278,7 +3479,7 @@ - + @@ -3287,7 +3488,7 @@ - + @@ -3296,7 +3497,7 @@ - + @@ -3305,7 +3506,7 @@ - + @@ -3337,14 +3538,15 @@ - Shiboken::AutoDecRef parent(%CONVERTTOPYTHON[QGraphicsItem*](%1->parentItem())); - foreach (QGraphicsItem* item, %1->children()) - Shiboken::Object::setParent(parent, %CONVERTTOPYTHON[QGraphicsItem*](item)); - %BEGIN_ALLOW_THREADS - %CPPSELF.%FUNCTION_NAME(%1); - %END_ALLOW_THREADS - // the arg was destroyed by Qt. - Shiboken::Object::invalidate(%PYARG_1); + QGraphicsItem* parentItem = %1->parentItem(); + Shiboken::AutoDecRef parent(%CONVERTTOPYTHON[QGraphicsItem*](parentItem)); + foreach (QGraphicsItem* item, %1->children()) + Shiboken::Object::setParent(parent, %CONVERTTOPYTHON[QGraphicsItem*](item)); + %BEGIN_ALLOW_THREADS + %CPPSELF.%FUNCTION_NAME(%1); + %END_ALLOW_THREADS + // the arg was destroyed by Qt. + Shiboken::Object::invalidate(%PYARG_1); @@ -3402,24 +3604,24 @@ - + - + - + - + @@ -3430,38 +3632,38 @@ - + - + - + - + - + - + - + @@ -3470,8 +3672,9 @@ - %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%CPPSELF.%FUNCTION_NAME(%1, %2)); - Shiboken::Object::keepReference((SbkObject*)%PYARG_0, "setWidget(QWidget*)1", %PYARG_1); + %RETURN_TYPE %0 = %CPPSELF.%FUNCTION_NAME(%1, %2); + %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0); + Shiboken::Object::keepReference((SbkObject*)%PYARG_0, "setWidget(QWidget*)1", %PYARG_1); @@ -3489,7 +3692,7 @@ foreach (QGraphicsItem* item, items) { SbkObject* obj = bm.retrieveWrapper(item); if (obj) { - if (obj->ob_refcnt > 1) // If the refcnt is 1 the object will vannish anyway. + if (reinterpret_cast<PyObject*>(obj)->ob_refcnt > 1) // If the refcnt is 1 the object will vannish anyway. Shiboken::Object::invalidate(obj); Shiboken::Object::removeParent(obj); } @@ -3556,7 +3759,7 @@ - + @@ -3618,17 +3821,17 @@ - + - + - + @@ -3665,17 +3868,17 @@ - + - + - + @@ -3690,17 +3893,17 @@ - + - + - + @@ -3710,12 +3913,12 @@ - + - + @@ -3791,12 +3994,12 @@ - + - + @@ -3818,9 +4021,10 @@ - + + @@ -4043,7 +4247,7 @@ - + @@ -4079,11 +4283,17 @@ If a widget is non-native (alien) and winId() is invoked on it, that widget will be provided a native handle. - On X11 the type returned is long, on other platforms it's a PyCObject. + On X11 the type returned is long, on other platforms it's void pointer casted to a Python long long. This value may change at run-time. An event with type PySide.QtCore.QEvent.WinIdChange will be sent to the widget following a change in window system identifier. + + + + + + @@ -4291,7 +4501,8 @@ for (int i = 0; i < %CPPSELF.count(); i++) { - Shiboken::AutoDecRef pyWidget(%CONVERTTOPYTHON[QWidget*](%CPPSELF.widget(i))); + QWidget* widget = %CPPSELF.widget(i); + Shiboken::AutoDecRef pyWidget(%CONVERTTOPYTHON[QWidget*](widget)); Shiboken::Object::setParent(0, pyWidget); } %CPPSELF.%FUNCTION_NAME(); @@ -4318,7 +4529,7 @@ - + @@ -4329,7 +4540,7 @@ - + @@ -4344,7 +4555,7 @@ - + @@ -4520,29 +4731,29 @@ - + - + - + - + - + // Clear parent from the old child QStandardItem* _i = %CPPSELF->item(%1, %2); @@ -4555,7 +4766,7 @@ - + // Clear parent from the old child QStandardItem* _i = %CPPSELF->item(%1); @@ -4568,13 +4779,13 @@ - + - + // Clear parent from the old child QStandardItem* _i = %CPPSELF->verticalHeaderItem(%1); @@ -4606,19 +4817,19 @@ - + - + - + @@ -4658,8 +4869,12 @@ - %RETURN_TYPE retval_ = %CPPSELF.%FUNCTION_NAME(%1, %2); - %PYARG_0 = Shiboken::makeTuple(retval_, %1); + %BEGIN_ALLOW_THREADS + %RETURN_TYPE retval_ = %CPPSELF.%FUNCTION_NAME(%1, %2); + %END_ALLOW_THREADS + %PYARG_0 = PyTuple_New(2); + PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[%RETURN_TYPE](retval_)); + PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[%ARG1_TYPE](%1)); @@ -4871,18 +5086,18 @@ - + - + - + @@ -4952,17 +5167,46 @@ - + + + +:: + + def callback_int(value_as_int): + print 'int value changed:', repr(value_as_int) + + app = QApplication(sys.argv) + spinbox = QSpinBox() + spinbox.valueChanged[unicode].connect(callback_unicode) + spinbox.show() + sys.exit(app.exec_()) + + + + +:: + + def callback_unicode(value_as_unicode): + print 'unicode value changed:', repr(value_as_unicode) + + app = QApplication(sys.argv) + spinbox = QSpinBox() + spinbox.valueChanged[unicode].connect(callback_unicode) + spinbox.show() + sys.exit(app.exec_()) + + + - + - + @@ -4988,8 +5232,13 @@ + + + + - %PYARG_0 = %CONVERTTOPYTHON[QAction*](%CPPSELF.addAction(%1, %2)); + QAction* action = %CPPSELF.addAction(%1, %2); + %PYARG_0 = %CONVERTTOPYTHON[QAction*](action); Shiboken::AutoDecRef result(PyObject_CallMethod(%PYARG_0, "connect", "OsO", %PYARG_0, SIGNAL(triggered()), %PYARG_3)); @@ -5000,17 +5249,21 @@ + + + - %PYARG_0 = %CONVERTTOPYTHON[QAction*](%CPPSELF.addAction(%1)); + QAction* action = %CPPSELF.addAction(%1); + %PYARG_0 = %CONVERTTOPYTHON[QAction*](action); Shiboken::AutoDecRef result(PyObject_CallMethod(%PYARG_0, "connect", "OsO", %PYARG_0, SIGNAL(triggered()), %PYARG_2)); - + - + @@ -5048,13 +5301,19 @@ foreach(QToolButton* child, %CPPSELF.findChildren<QToolButton*>()) { if (bm.hasWrapper(child)) { PyObject* pyChild = %CONVERTTOPYTHON[QToolButton*](child); - Shiboken::Object::setParent(0, pyChild); + Shiboken::Object::setParent(0, pyChild); lst << pyChild; } } - %CPPSELF.clear(); + //Remove actions + foreach(QAction *act, %CPPSELF.actions()) { + Shiboken::AutoDecRef pyAct(%CONVERTTOPYTHON[QAction*](act)); + Shiboken::Object::setParent(NULL, pyAct); + Shiboken::Object::invalidate(pyAct); + } + %CPPSELF.clear(); foreach(PyObject* obj, lst) { Shiboken::Object::invalidate(reinterpret_cast<SbkObject* >(obj)); Py_XDECREF(obj); @@ -5166,9 +5425,12 @@ + + + - + - + - + - - - - - - + + + + + + - + - + - + %BEGIN_ALLOW_THREADS @@ -5216,7 +5478,7 @@ %END_ALLOW_THREADS - + %BEGIN_ALLOW_THREADS @@ -5224,13 +5486,13 @@ %END_ALLOW_THREADS - + - + @@ -5244,32 +5506,32 @@ - + - + - + - + - + - + @@ -5423,21 +5685,21 @@ - - - + @@ -5698,9 +5960,13 @@ - - - + + QWidget* _old = %CPPSELF.widget(); + if (_old) + Shiboken::Object::setParent(NULL, %CONVERTTOPYTHON[QWidget*](_old)); + %CPPSELF.%FUNCTION_NAME(%1); + Shiboken::Object::setParent(%PYSELF, %PYARG_1); + @@ -5889,24 +6155,42 @@ + + + + + + - return %CONVERTTOPYTHON[QMatrix2x2](*%CPPSELF *= %1); + - return %CONVERTTOPYTHON[QMatrix2x2](*%CPPSELF += %1); + - return %CONVERTTOPYTHON[QMatrix2x2](*%CPPSELF -= %1); + - return %CONVERTTOPYTHON[QMatrix2x2](*%CPPSELF /= %1); + @@ -5961,22 +6245,22 @@ - return %CONVERTTOPYTHON[QMatrix2x3](*%CPPSELF *= %1); + - return %CONVERTTOPYTHON[QMatrix2x3](*%CPPSELF += %1); + - return %CONVERTTOPYTHON[QMatrix2x3](*%CPPSELF -= %1); + - return %CONVERTTOPYTHON[QMatrix2x3](*%CPPSELF /= %1); + @@ -6031,22 +6315,22 @@ - return %CONVERTTOPYTHON[QMatrix2x4](*%CPPSELF *= %1); + - return %CONVERTTOPYTHON[QMatrix2x4](*%CPPSELF += %1); + - return %CONVERTTOPYTHON[QMatrix2x4](*%CPPSELF -= %1); + - return %CONVERTTOPYTHON[QMatrix2x4](*%CPPSELF /= %1); + @@ -6101,22 +6385,22 @@ - return %CONVERTTOPYTHON[QMatrix3x2](*%CPPSELF *= %1); + - return %CONVERTTOPYTHON[QMatrix3x2](*%CPPSELF += %1); + - return %CONVERTTOPYTHON[QMatrix3x2](*%CPPSELF -= %1); + - return %CONVERTTOPYTHON[QMatrix3x2](*%CPPSELF /= %1); + @@ -6171,22 +6455,22 @@ - return %CONVERTTOPYTHON[QMatrix3x3](*%CPPSELF *= %1); + - return %CONVERTTOPYTHON[QMatrix3x3](*%CPPSELF += %1); + - return %CONVERTTOPYTHON[QMatrix3x3](*%CPPSELF -= %1); + - return %CONVERTTOPYTHON[QMatrix3x3](*%CPPSELF /= %1); + @@ -6241,22 +6525,22 @@ - return %CONVERTTOPYTHON[QMatrix3x4](*%CPPSELF *= %1); + - return %CONVERTTOPYTHON[QMatrix3x4](*%CPPSELF += %1); + - return %CONVERTTOPYTHON[QMatrix3x4](*%CPPSELF -= %1); + - return %CONVERTTOPYTHON[QMatrix3x4](*%CPPSELF /= %1); + @@ -6311,22 +6595,22 @@ - return %CONVERTTOPYTHON[QMatrix4x2](*%CPPSELF *= %1); + - return %CONVERTTOPYTHON[QMatrix4x2](*%CPPSELF += %1); + - return %CONVERTTOPYTHON[QMatrix4x2](*%CPPSELF -= %1); + - return %CONVERTTOPYTHON[QMatrix4x2](*%CPPSELF /= %1); + @@ -6381,22 +6665,22 @@ - return %CONVERTTOPYTHON[QMatrix4x3](*%CPPSELF *= %1); + - return %CONVERTTOPYTHON[QMatrix4x3](*%CPPSELF += %1); + - return %CONVERTTOPYTHON[QMatrix4x3](*%CPPSELF -= %1); + - return %CONVERTTOPYTHON[QMatrix4x3](*%CPPSELF /= %1); + @@ -6468,6 +6752,18 @@ + + + + + + + + + + + + @@ -6483,7 +6779,8 @@ PyObject* posy = PySequence_Fast_GET_ITEM(key.object(), 1); Py_ssize_t x = PyInt_AsSsize_t(posx); Py_ssize_t y = PyInt_AsSsize_t(posy); - return %CONVERTTOPYTHON[qreal]((*%CPPSELF)(x,y)); + qreal ret = (*%CPPSELF)(x,y); + return %CONVERTTOPYTHON[qreal](ret); } } PyErr_SetString(PyExc_IndexError, "Invalid matrix index."); @@ -6786,7 +7083,11 @@ + + + + diff --git a/PySide/QtGui/typesystem_gui_win.xml b/PySide/QtGui/typesystem_gui_win.xml index 1249296..387964d 100644 --- a/PySide/QtGui/typesystem_gui_win.xml +++ b/PySide/QtGui/typesystem_gui_win.xml @@ -19,9 +19,31 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA --> - - + + + #ifdef IS_PY3K + return PyCapsule_New(%in, 0, 0); + #else + return PyCObject_FromVoidPtr(%in, 0); + #endif + + + + %out = 0; + + + #ifdef IS_PY3K + %out = (%OUTTYPE)PyCapsule_GetPointer(%in, 0); + #else + %out = (%OUTTYPE)PyCObject_AsVoidPtr(%in); + #endif + + + + + + diff --git a/PySide/QtGui/typesystem_gui_x11.xml b/PySide/QtGui/typesystem_gui_x11.xml index 96bfb24..54d8882 100644 --- a/PySide/QtGui/typesystem_gui_x11.xml +++ b/PySide/QtGui/typesystem_gui_x11.xml @@ -23,10 +23,21 @@ - - - - + + + %PYARG_0 = PyLong_FromVoidPtr(%TYPE::%FUNCTION_NAME()); + + + + + %PYARG_0 = PyLong_FromVoidPtr(%CPPSELF.%FUNCTION_NAME()); + + + + + %PYARG_0 = PyLong_FromVoidPtr(%CPPSELF.%FUNCTION_NAME()); + + diff --git a/PySide/QtHelp/CMakeLists.txt b/PySide/QtHelp/CMakeLists.txt index 0ca0272..041ef63 100644 --- a/PySide/QtHelp/CMakeLists.txt +++ b/PySide/QtHelp/CMakeLists.txt @@ -15,7 +15,7 @@ set(QtHelp_SRC ${CMAKE_CURRENT_BINARY_DIR}/PySide/QtHelp/qthelp_module_wrapper.cpp ) -set(QtHelp_typesystem_path "${QtCore_SOURCE_DIR}${PATH_SEP}${QtGui_SOURCE_DIR}${PATH_SEP}${QtHelp_SOURCE_DIR}${PATH_SEP}${QtGui_BINARY_DIR}") +set(QtHelp_typesystem_path "${QtCore_SOURCE_DIR}${PATH_SEP}${QtCore_BINARY_DIR}${PATH_SEP}${QtGui_SOURCE_DIR}${PATH_SEP}${QtHelp_SOURCE_DIR}${PATH_SEP}${QtGui_BINARY_DIR}") set(QtHelp_include_dirs ${CMAKE_CURRENT_SOURCE_DIR} ${QT_QTCORE_INCLUDE_DIR} ${QT_QTGUI_INCLUDE_DIR} diff --git a/PySide/QtMaemo5/CMakeLists.txt b/PySide/QtMaemo5/CMakeLists.txt index 30bf15c..41397f4 100644 --- a/PySide/QtMaemo5/CMakeLists.txt +++ b/PySide/QtMaemo5/CMakeLists.txt @@ -11,7 +11,7 @@ ${CMAKE_CURRENT_BINARY_DIR}/${BINDING_NAME}/QtMaemo5/qmaemo5valuebutton_wrapper. ${CMAKE_CURRENT_BINARY_DIR}/${BINDING_NAME}/QtMaemo5/qtmaemo5_module_wrapper.cpp ) -set(QtMaemo5_typesystem_path "${QtCore_SOURCE_DIR}${PATH_SEP}${QtGui_SOURCE_DIR}${PATH_SEP}${QtMaemo5_SOURCE_DIR}${PATH_SEP}${QtGui_BINARY_DIR}") +set(QtMaemo5_typesystem_path "${QtCore_SOURCE_DIR}${PATH_SEP}${QtCore_BINARY_DIR}${PATH_SEP}${QtGui_SOURCE_DIR}${PATH_SEP}${QtMaemo5_SOURCE_DIR}${PATH_SEP}${QtGui_BINARY_DIR}") # QT_QTMAEMO5_* variables are not defined by CMake if(NOT QT_QTMAEMO5_INCLUDE_DIR) diff --git a/PySide/QtMultimedia/CMakeLists.txt b/PySide/QtMultimedia/CMakeLists.txt index 8823838..ea37c80 100644 --- a/PySide/QtMultimedia/CMakeLists.txt +++ b/PySide/QtMultimedia/CMakeLists.txt @@ -17,7 +17,7 @@ set(QtMultimedia_SRC ${CMAKE_CURRENT_BINARY_DIR}/PySide/QtMultimedia/qvideoframe_wrapper.cpp ${CMAKE_CURRENT_BINARY_DIR}/PySide/QtMultimedia/qtmultimedia_module_wrapper.cpp ) -set(QtMultimedia_typesystem_path "${QtCore_SOURCE_DIR}${PATH_SEP}${QtGui_SOURCE_DIR}${PATH_SEP}${QtGui_BINARY_DIR}") +set(QtMultimedia_typesystem_path "${QtCore_SOURCE_DIR}${PATH_SEP}${QtCore_BINARY_DIR}${PATH_SEP}${QtGui_SOURCE_DIR}${PATH_SEP}${QtGui_BINARY_DIR}") set(QtMultimedia_include_dirs ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR}/PySide/QtMultimedia/ diff --git a/PySide/QtMultimedia/typesystem_multimedia.xml b/PySide/QtMultimedia/typesystem_multimedia.xml index 04e064b..b1a684f 100644 --- a/PySide/QtMultimedia/typesystem_multimedia.xml +++ b/PySide/QtMultimedia/typesystem_multimedia.xml @@ -37,6 +37,8 @@ + + diff --git a/PySide/QtNetwork/CMakeLists.txt b/PySide/QtNetwork/CMakeLists.txt index 9149202..c18d70a 100644 --- a/PySide/QtNetwork/CMakeLists.txt +++ b/PySide/QtNetwork/CMakeLists.txt @@ -56,7 +56,7 @@ ${QtNetwork_47_SRC} ${QtNetwork_OPTIONAL_SRC} ) -set(QtNetwork_typesystem_path "${QtCore_SOURCE_DIR}") +set(QtNetwork_typesystem_path "${QtCore_SOURCE_DIR}${PATH_SEP}${QtCore_BINARY_DIR}") set(QtNetwork_include_dirs ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR}/PySide/QtNetwork/ ${QT_INCLUDE_DIR} diff --git a/PySide/QtNetwork/glue/qudpsocket_read_datagram_glue.cpp b/PySide/QtNetwork/glue/qudpsocket_read_datagram_glue.cpp deleted file mode 100644 index db38f45..0000000 --- a/PySide/QtNetwork/glue/qudpsocket_read_datagram_glue.cpp +++ /dev/null @@ -1,6 +0,0 @@ - PySide::AutoArrayPointer data(%ARGUMENT_NAMES); - QHostAddress ha; - quint16 port; - - %RETURN_TYPE retval = %CPPSELF.%FUNCTION_NAME(data, %ARGUMENT_NAMES, &ha, &port); - %PYARG_0 = Shiboken::makeTuple(QByteArray(data, retval), ha, port); diff --git a/PySide/QtNetwork/typesystem_network.xml b/PySide/QtNetwork/typesystem_network.xml index ab3f1ef..a8327cd 100644 --- a/PySide/QtNetwork/typesystem_network.xml +++ b/PySide/QtNetwork/typesystem_network.xml @@ -53,10 +53,6 @@ - - - - @@ -88,10 +84,6 @@ - - - - @@ -129,10 +121,6 @@ - - - - @@ -148,7 +136,19 @@ - + + Shiboken::AutoArrayPointer<char> data(%ARGUMENT_NAMES); + QHostAddress ha; + quint16 port; + %BEGIN_ALLOW_THREADS + %RETURN_TYPE retval = %CPPSELF.%FUNCTION_NAME(data, %ARGUMENT_NAMES, &ha, &port); + %END_ALLOW_THREADS + QByteArray ba(data, retval); + %PYARG_0 = PyTuple_New(3); + PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[QByteArray](ba)); + PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[QHostAddress](ha)); + PyTuple_SET_ITEM(%PYARG_0, 2, %CONVERTTOPYTHON[quint16](port)); + @@ -185,6 +185,9 @@ + + + @@ -208,6 +211,7 @@ + @@ -245,17 +249,17 @@ return 16; - + - if (_i >= 16) { - PyErr_SetString(PyExc_IndexError, "index out of bounds"); - return 0; - } + if (_i >= 16) { + PyErr_SetString(PyExc_IndexError, "index out of bounds"); + return 0; + } + if (_i < 0) + _i = 16 - qAbs(_i); - if (_i < 0) - _i = 16 - qAbs(_i); - - return %CONVERTTOPYTHON[uint](%CPPSELF->c[_i]); + uint item = %CPPSELF.c[_i]; + return %CONVERTTOPYTHON[uint](item); @@ -265,17 +269,15 @@ - if (_i >= 16) { - PyErr_SetString(PyExc_IndexError, "index out of bounds"); - return -1; - } - - if (_i < 0) - _i = 16 - qAbs(_i); - - %CPPSELF->c[_i] = %CONVERTTOCPP[quint8](_value); - - return 0; + if (_i >= 16) { + PyErr_SetString(PyExc_IndexError, "index out of bounds"); + return -1; + } + if (_i < 0) + _i = 16 - qAbs(_i); + quint8 item = %CONVERTTOCPP[quint8](_value); + %CPPSELF.c[_i] = item; + return 0; diff --git a/PySide/QtOpenGL/CMakeLists.txt b/PySide/QtOpenGL/CMakeLists.txt index 44ba1c1..3f977db 100644 --- a/PySide/QtOpenGL/CMakeLists.txt +++ b/PySide/QtOpenGL/CMakeLists.txt @@ -32,7 +32,7 @@ set(QtOpenGL_SRC ${QtOpenGL_47_SRC} ) -set(QtOpenGL_typesystem_path "${QtCore_SOURCE_DIR}${PATH_SEP}${QtGui_SOURCE_DIR}${PATH_SEP}${QtOpenGL_SOURCE_DIR}${PATH_SEP}${QtGui_BINARY_DIR}") +set(QtOpenGL_typesystem_path "${QtCore_SOURCE_DIR}${PATH_SEP}${QtCore_BINARY_DIR}${PATH_SEP}${QtGui_SOURCE_DIR}${PATH_SEP}${QtOpenGL_SOURCE_DIR}${PATH_SEP}${QtGui_BINARY_DIR}") set(QtOpenGL_include_dirs ${CMAKE_CURRENT_SOURCE_DIR} ${QT_QTCORE_INCLUDE_DIR} ${QT_QTGUI_INCLUDE_DIR} diff --git a/PySide/QtOpenGL/typesystem_opengl.xml b/PySide/QtOpenGL/typesystem_opengl.xml index abed718..60a2d18 100644 --- a/PySide/QtOpenGL/typesystem_opengl.xml +++ b/PySide/QtOpenGL/typesystem_opengl.xml @@ -21,6 +21,21 @@ + + + + + + + + + + + + + + + @@ -91,14 +106,568 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - + + + + + + @@ -109,15 +678,13 @@ - + - int size = %2; - if (size < 0) - size = %1.size(); + int size = (%2 < 0) ? %1.size() : %2; %CPPSELF.allocate((const void*) %1.data(), size); @@ -149,21 +716,21 @@ QByteArray ret; if (result) ret.append((const char*)data, %3); - %PYARG_0 = Shiboken::makeTuple(result, ret); + %PYARG_0 = PyTuple_New(2); + PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[bool](result)); + PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[QByteArray](ret)); delete[] data; - + - int size = %3; - if (size < 0) - size = %2.size(); + int size = (%3 < 0) ? %2.size() : %3; %CPPSELF.write(%1, (const void*) %2.data(), size); diff --git a/PySide/QtScript/CMakeLists.txt b/PySide/QtScript/CMakeLists.txt index 88b0a06..48dc85f 100644 --- a/PySide/QtScript/CMakeLists.txt +++ b/PySide/QtScript/CMakeLists.txt @@ -1,10 +1,10 @@ project(QtScript) -if (${QT_VERSION_MAJOR} EQUAL 4 AND ${QT_VERSION_MINOR} LESS 6) - set (QtCore_46_SRC ) +if (${QT_VERSION_MAJOR} EQUAL 4 AND ${QT_VERSION_MINOR} LESS 7) + set (QtScript_47_SRC ) else() - set(QtScript_46_SRC - ${CMAKE_CURRENT_BINARY_DIR}/PySide/QtScript/qscriptprogram_wrapper.cpp + set(QtScript_47_SRC + ${CMAKE_CURRENT_BINARY_DIR}/PySide/QtScript/qscriptprogram_wrapper.cpp ) endif() @@ -22,10 +22,10 @@ ${CMAKE_CURRENT_BINARY_DIR}/PySide/QtScript/qscriptextensionplugin_wrapper.cpp ${CMAKE_CURRENT_BINARY_DIR}/PySide/QtScript/qscriptstring_wrapper.cpp ${CMAKE_CURRENT_BINARY_DIR}/PySide/QtScript/qscriptvalue_wrapper.cpp ${CMAKE_CURRENT_BINARY_DIR}/PySide/QtScript/qscriptvalueiterator_wrapper.cpp -${QtScript_46_SRC} +${QtScript_47_SRC} ) -set(QtScript_typesystem_path "${QtCore_SOURCE_DIR}") +set(QtScript_typesystem_path "${QtCore_SOURCE_DIR}${PATH_SEP}${QtCore_BINARY_DIR}") set(QtScript_include_dirs ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR}/PySide/QtScript ${QT_INCLUDE_DIR} diff --git a/PySide/QtScript/typesystem_script.xml b/PySide/QtScript/typesystem_script.xml index 870aec0..d787b22 100644 --- a/PySide/QtScript/typesystem_script.xml +++ b/PySide/QtScript/typesystem_script.xml @@ -40,16 +40,76 @@ + + - + + + + + + + + + + + + + if (%CPPSELF.isVariant() || %CPPSELF.isString()) { + QString format = QString().sprintf("%s(\"%s\")", ((PyObject*)%PYSELF)->ob_type->tp_name, qPrintable(%CPPSELF.toString())); + %PYARG_0 = Shiboken::String::fromCString(qPrintable(format)); + } else { + %PYARG_0 = Shiboken::String::fromCString( + ((PyObject* )%PYSELF)->ob_type->tp_name); + } + + + + + Shiboken::AutoDecRef key(PyObject_Str(_key)); + QVariant res = %CPPSELF.property(Shiboken::String::toCString(key.object())).toVariant(); + if (res.isValid()) { + return %CONVERTTOPYTHON[QVariant](res); + } else { + PyObject* errorType = PyInt_Check(_key) ? PyExc_IndexError : PyExc_KeyError; + PyErr_SetString(errorType, "Key not found."); + return 0; + } + + + + + %PYARG_0 = Shiboken::createWrapper(new QScriptValueIterator(*%CPPSELF), true, true); + + - + + + + + + + + + if (%CPPSELF.hasNext()) { + %CPPSELF.next(); + QString name = %CPPSELF.name(); + QVariant value = %CPPSELF.value().toVariant(); + %PYARG_0 = PyTuple_New(2); + PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[QString](name)); + PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[QVariant](value)); + } else { + PyErr_SetNone(PyExc_StopIteration); + } + + + diff --git a/PySide/QtScriptTools/CMakeLists.txt b/PySide/QtScriptTools/CMakeLists.txt index 575dcc3..0a98042 100644 --- a/PySide/QtScriptTools/CMakeLists.txt +++ b/PySide/QtScriptTools/CMakeLists.txt @@ -5,7 +5,7 @@ set(QtScriptTools_SRC ${CMAKE_CURRENT_BINARY_DIR}/PySide/QtScriptTools/qscriptenginedebugger_wrapper.cpp ) -set(QtScriptTools_typesystem_path "${QtCore_SOURCE_DIR}${PATH_SEP}${QtGui_SOURCE_DIR}${PATH_SEP}${QtScript_SOURCE_DIR}${PATH_SEP}${QtScriptTools_SOURCE_DIR}${PATH_SEP}${QtGui_BINARY_DIR}") +set(QtScriptTools_typesystem_path "${QtCore_SOURCE_DIR}${PATH_SEP}${QtCore_BINARY_DIR}${PATH_SEP}${QtGui_SOURCE_DIR}${PATH_SEP}${QtScript_SOURCE_DIR}${PATH_SEP}${QtScriptTools_SOURCE_DIR}${PATH_SEP}${QtGui_BINARY_DIR}") set(QtScriptTools_include_dirs ${CMAKE_CURRENT_SOURCE_DIR} ${QT_QTCORE_INCLUDE_DIR} diff --git a/PySide/QtSql/CMakeLists.txt b/PySide/QtSql/CMakeLists.txt index 7da42d4..f1dc384 100644 --- a/PySide/QtSql/CMakeLists.txt +++ b/PySide/QtSql/CMakeLists.txt @@ -21,7 +21,7 @@ set(QtSql_SRC ${CMAKE_CURRENT_BINARY_DIR}/PySide/QtSql/qtsql_module_wrapper.cpp ) -set(QtSql_typesystem_path "${QtCore_SOURCE_DIR}${PATH_SEP}${QtGui_SOURCE_DIR}${PATH_SEP}${QtSql_SOURCE_DIR}${PATH_SEP}${QtGui_BINARY_DIR}") +set(QtSql_typesystem_path "${QtCore_SOURCE_DIR}${PATH_SEP}${QtCore_BINARY_DIR}${PATH_SEP}${QtGui_SOURCE_DIR}${PATH_SEP}${QtSql_SOURCE_DIR}${PATH_SEP}${QtGui_BINARY_DIR}") set(QtSql_include_dirs ${CMAKE_CURRENT_SOURCE_DIR} ${QT_QTCORE_INCLUDE_DIR} ${QT_QTGUI_INCLUDE_DIR} diff --git a/PySide/QtSvg/CMakeLists.txt b/PySide/QtSvg/CMakeLists.txt index b1e5477..eb0f9a2 100644 --- a/PySide/QtSvg/CMakeLists.txt +++ b/PySide/QtSvg/CMakeLists.txt @@ -8,7 +8,7 @@ ${CMAKE_CURRENT_BINARY_DIR}/PySide/QtSvg/qsvgwidget_wrapper.cpp ${CMAKE_CURRENT_BINARY_DIR}/PySide/QtSvg/qtsvg_module_wrapper.cpp ) -set(QtSvg_typesystem_path "${QtCore_SOURCE_DIR}${PATH_SEP}${QtGui_SOURCE_DIR}${PATH_SEP}${QtGui_BINARY_DIR}") +set(QtSvg_typesystem_path "${QtCore_SOURCE_DIR}${PATH_SEP}${QtCore_BINARY_DIR}${PATH_SEP}${QtGui_SOURCE_DIR}${PATH_SEP}${QtGui_BINARY_DIR}") set(QtSvg_include_dirs ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR}/PySide/QtSvg/ ${QT_INCLUDE_DIR} diff --git a/PySide/QtTest/CMakeLists.txt b/PySide/QtTest/CMakeLists.txt index 6ef7a42..bf86ad5 100644 --- a/PySide/QtTest/CMakeLists.txt +++ b/PySide/QtTest/CMakeLists.txt @@ -14,7 +14,7 @@ ${CMAKE_CURRENT_BINARY_DIR}/PySide/QtTest/qttest_module_wrapper.cpp ${QtTest_46_SRC} ) -set(QtTest_typesystem_path "${QtCore_SOURCE_DIR}${PATH_SEP}${QtGui_SOURCE_DIR}${PATH_SEP}${QtGui_BINARY_DIR}") +set(QtTest_typesystem_path "${QtCore_SOURCE_DIR}${PATH_SEP}${QtCore_BINARY_DIR}${PATH_SEP}${QtGui_SOURCE_DIR}${PATH_SEP}${QtGui_BINARY_DIR}") set(QtTest_include_dirs ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR}/PySide/QtTest/ ${QT_INCLUDE_DIR} diff --git a/PySide/QtTest/typesystem_test.xml b/PySide/QtTest/typesystem_test.xml index 9897225..4a1a72c 100644 --- a/PySide/QtTest/typesystem_test.xml +++ b/PySide/QtTest/typesystem_test.xml @@ -49,6 +49,7 @@ + diff --git a/PySide/QtUiTools/CMakeLists.txt b/PySide/QtUiTools/CMakeLists.txt index 195cb81..89d2988 100644 --- a/PySide/QtUiTools/CMakeLists.txt +++ b/PySide/QtUiTools/CMakeLists.txt @@ -5,7 +5,7 @@ set(QtUiTools_SRC ${CMAKE_CURRENT_BINARY_DIR}/PySide/QtUiTools/quiloader_wrapper.cpp ) -set(QtUiTools_typesystem_path "${QtCore_SOURCE_DIR}${PATH_SEP}${QtGui_SOURCE_DIR}${PATH_SEP}${QtXml_SOURCE_DIR}${PATH_SEP}${QtUiTools_SOURCE_DIR}${PATH_SEP}${QtGui_BINARY_DIR}") +set(QtUiTools_typesystem_path "${QtCore_SOURCE_DIR}${PATH_SEP}${QtCore_BINARY_DIR}${PATH_SEP}${QtGui_SOURCE_DIR}${PATH_SEP}${QtXml_SOURCE_DIR}${PATH_SEP}${QtUiTools_SOURCE_DIR}${PATH_SEP}${QtGui_BINARY_DIR}") set(QtUiTools_include_dirs ${CMAKE_CURRENT_SOURCE_DIR} ${QT_QTCORE_INCLUDE_DIR} ${QT_QTGUI_INCLUDE_DIR} @@ -23,10 +23,10 @@ set(QtUiTools_include_dirs ${CMAKE_CURRENT_SOURCE_DIR} set(QtUiTools_libraries pyside uiplugin ${SHIBOKEN_PYTHON_LIBRARIES} - ${QT_QTCORE_LIBRARY} - ${QT_QTGUI_LIBRARY} + ${QT_QTUITOOLS_LIBRARY} ${QT_QTDESIGNER_LIBRARY} - ${QT_QTUITOOLS_LIBRARY}) + ${QT_QTCORE_LIBRARY} + ${QT_QTGUI_LIBRARY}) set(QtUiTools_deps QtGui QtXml) create_pyside_module(QtUiTools QtUiTools_include_dirs diff --git a/PySide/QtUiTools/glue/plugins.h b/PySide/QtUiTools/glue/plugins.h index 09070bf..78e5a20 100644 --- a/PySide/QtUiTools/glue/plugins.h +++ b/PySide/QtUiTools/glue/plugins.h @@ -33,13 +33,13 @@ inline void registerCustomWidget(PyObject* obj) if (plugin == 0) { foreach(QObject* o, QPluginLoader::staticInstances()) { plugin = qobject_cast(o); - if (o) + if (plugin) break; } } if (!plugin) - qDebug() << "Fail to load uiloader plugin"; + qDebug() << "Failed to load uiloader plugin."; else plugin->registerWidgetType(obj); } diff --git a/PySide/QtUiTools/glue/uitools_loadui.cpp b/PySide/QtUiTools/glue/uitools_loadui.cpp new file mode 100644 index 0000000..829adf7 --- /dev/null +++ b/PySide/QtUiTools/glue/uitools_loadui.cpp @@ -0,0 +1,52 @@ +/* + * Based on code provided by: + * Antonio Valentino + * Frédéric + */ + +#include +#include +#include +#include + +static void createChildrenNameAttributes(PyObject* root, QObject* object) +{ + foreach (QObject* child, object->children()) { + const QByteArray name = child->objectName().toLocal8Bit(); + + if (!name.isEmpty() && !name.startsWith("_") && !name.startsWith("qt_")) { + bool hasAttr = PyObject_HasAttrString(root, name.constData()); + if (!hasAttr) { + Shiboken::AutoDecRef pyChild(%CONVERTTOPYTHON[QObject*](child)); + PyObject_SetAttrString(root, name.constData(), pyChild); + } + createChildrenNameAttributes(root, child); + } + createChildrenNameAttributes(root, child); + } +} + +static PyObject* QUiLoadedLoadUiFromDevice(QUiLoader* self, QIODevice* dev, QWidget* parent) +{ + QWidget* wdg = self->load(dev, parent); + + if (wdg) { + PyObject* pyWdg = %CONVERTTOPYTHON[QWidget*](wdg); + createChildrenNameAttributes(pyWdg, wdg); + if (parent) { + Shiboken::AutoDecRef pyParent(%CONVERTTOPYTHON[QWidget*](parent)); + Shiboken::Object::setParent(pyParent, pyWdg); + } + return pyWdg; + } + + if (!PyErr_Occurred()) + PyErr_SetString(PyExc_RuntimeError, "Unable to open/read ui device"); + return 0; +} + +static PyObject* QUiLoaderLoadUiFromFileName(QUiLoader* self, const QString& uiFile, QWidget* parent) +{ + QFile fd(uiFile); + return QUiLoadedLoadUiFromDevice(self, &fd, parent); +} diff --git a/PySide/QtUiTools/glue/uitools_loadui.h b/PySide/QtUiTools/glue/uitools_loadui.h deleted file mode 100644 index a6e339a..0000000 --- a/PySide/QtUiTools/glue/uitools_loadui.h +++ /dev/null @@ -1,77 +0,0 @@ -/* - * Based on code provided by: - * Antonio Valentino - * Frédéric - */ - -#include - -static void -_populate_parent(PyObject* pyParent, QObject *parent) -{ - if (parent->children().isEmpty()) - return; - - foreach(QObject *child, parent->children()) { - QString name(child->objectName()); - if (!name.isEmpty() && !name.startsWith("_") && !name.startsWith("qt_")) { - bool has_attr = PyObject_HasAttrString(pyParent, qPrintable(name)); - Shiboken::AutoDecRef pyChild(Shiboken::Converter::toPython(child)); - if (!has_attr) - PyObject_SetAttrString(pyParent, qPrintable(name), pyChild); - - Shiboken::Object::setParent(pyParent, pyChild); - _populate_parent(pyChild, qobject_cast(child)); - } - } -} - -static PyObject* -quiloader_load_ui_from_device(QUiLoader* self, QIODevice* dev, QWidget *parent) -{ - QWidget *w = self->load(dev, parent); - if (w) { - QObject* _parent = parent; - if (!_parent) - _parent = w; - - if (parent && parent->layout()) - parent->layout()->deleteLater(); - - PyObject* pyParent = Shiboken::Converter::toPython(w); - _populate_parent(pyParent, _parent); - - return pyParent; - } - - if (!PyErr_Occurred()) - PyErr_SetString(PyExc_RuntimeError, "Unable to open ui file"); - return 0; -} - -static PyObject* -quiloader_load_ui(QUiLoader* self, const QString &ui_file, QWidget *parent) -{ - QFile fd(ui_file); - - if (fd.exists(ui_file) && fd.open(QFile::ReadOnly)) { - QWidget* w = self->load(&fd, parent); - fd.close(); - if (w != 0) { - QObject *_parent = parent; - if (!_parent) - _parent = w; - - Shiboken::AutoDecRef pyParent(Shiboken::Converter::toPython(_parent)); - if (parent && parent->layout()) - parent->layout()->deleteLater(); - - _populate_parent(pyParent, _parent); - - return Shiboken::Converter::toPython(w); - } - } - if (!PyErr_Occurred()) - PyErr_SetString(PyExc_RuntimeError, "Unable to open ui file"); - return 0; -} diff --git a/PySide/QtUiTools/typesystem_uitools.xml b/PySide/QtUiTools/typesystem_uitools.xml index 130880c..08e98bd 100644 --- a/PySide/QtUiTools/typesystem_uitools.xml +++ b/PySide/QtUiTools/typesystem_uitools.xml @@ -1,7 +1,7 @@ - - - - + // Avoid calling the original function: %CPPSELF.%FUNCTION_NAME() - %PYARG_0 = quiloader_load_ui(%CPPSELF, %1, %2); + %PYARG_0 = QUiLoaderLoadUiFromFileName(%CPPSELF, %1, %2); diff --git a/PySide/QtWebKit/CMakeLists.txt b/PySide/QtWebKit/CMakeLists.txt index 83445db..74d89f8 100644 --- a/PySide/QtWebKit/CMakeLists.txt +++ b/PySide/QtWebKit/CMakeLists.txt @@ -37,7 +37,7 @@ ${CMAKE_CURRENT_BINARY_DIR}/PySide/QtWebKit/webcore_wrapper.cpp ${QtWebKit_46_SRC} ) -set(QtWebKit_typesystem_path "${QtCore_SOURCE_DIR}${PATH_SEP}${QtGui_SOURCE_DIR}${PATH_SEP}${QtNetwork_SOURCE_DIR}${PATH_SEP}${QtGui_BINARY_DIR}") +set(QtWebKit_typesystem_path "${QtCore_SOURCE_DIR}${PATH_SEP}${QtCore_BINARY_DIR}${PATH_SEP}${QtGui_SOURCE_DIR}${PATH_SEP}${QtNetwork_SOURCE_DIR}${PATH_SEP}${QtGui_BINARY_DIR}") set(QtWebkit_include_dirs ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR}/PySide/QtWebkit/ ${QT_INCLUDE_DIR} diff --git a/PySide/QtWebKit/typesystem_webkit.xml b/PySide/QtWebKit/typesystem_webkit.xml index a021a04..86b8431 100644 --- a/PySide/QtWebKit/typesystem_webkit.xml +++ b/PySide/QtWebKit/typesystem_webkit.xml @@ -25,9 +25,6 @@ - - - @@ -84,6 +81,9 @@ + + + @@ -93,28 +93,31 @@ - + + - PyObject* %out = 0; - // Cast the parameters according to the extension type - if (extension == QWebPage::ChooseMultipleFilesExtension) - %out = %CONVERTTOPYTHON[ChooseMultipleFilesExtensionOption*](reinterpret_cast<const ChooseMultipleFilesExtensionOption*>(option)); - #if QT_VERSION >= 0x040600 - else if (extension == QWebPage::ErrorPageExtension) - %out = %CONVERTTOPYTHON[ErrorPageExtensionOption*](reinterpret_cast<const ErrorPageExtensionOption*>(option)); - #endif + + + - PyObject* %out = 0; - // Cast the parameters according to the extension type - if (extension == QWebPage::ChooseMultipleFilesExtension) - %out = %CONVERTTOPYTHON[ChooseMultipleFilesExtensionReturn*](reinterpret_cast<const ChooseMultipleFilesExtensionReturn*>(output)); - #if QT_VERSION >= 0x040600 - else if (extension == QWebPage::ErrorPageExtension) - %out = %CONVERTTOPYTHON[ErrorPageExtensionReturn*](reinterpret_cast<const ErrorPageExtensionReturn*>(output)); - #endif + + + @@ -141,21 +144,49 @@ - - - + + QString _local; + QString* %4 = &_local; + - + + + Shiboken::AutoDecRef pyRes(PySequence_GetItem(%PYARG_0, 0)); + Shiboken::AutoDecRef pyStr(PySequence_GetItem(%PYARG_0, 1)); + %RETURN_TYPE %out = %CONVERTTOCPP[%RETURN_TYPE](pyRes); + *%4 = %CONVERTTOCPP[QString](pyStr); + + + %PYARG_0 = PyTuple_New(2); + PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[%RETURN_TYPE](%0)); + PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[QString](*%4)); + - - QString str; - %RETURN_TYPE retval_ = %CPPSELF.%FUNCTION_NAME(%1, %2, %3, &str); - %PYARG_0 = Shiboken::makeTuple(retval_, str); - + + + + static int _signalIndex = -1; + static QMetaMethod _m; + + if (_signalIndex == -1) { + _signalIndex = QWebPage::staticMetaObject.indexOfSlot("shouldInterruptJavaScript()"); + _m = QWebPage::staticMetaObject.method(_signalIndex); + } + + if (_signalIndex == id) { + Shiboken::GilState gil; + PyObject* self = (PyObject*)Shiboken::BindingManager::instance().retrieveWrapper(this); + if (self) { + Shiboken::AutoDecRef _pyMethod(PyObject_GetAttrString(self, "shouldInterruptJavaScript")); + return PySide::SignalManager::callPythonMetaMethod(_m, args, _pyMethod, false); + } + } + + @@ -163,6 +194,12 @@ + + + + + + @@ -178,16 +215,17 @@ - return %CPPSELF.count(); + return %CPPSELF.count(); - if (_i < 0 || _i >= %CPPSELF.count()) { - PyErr_SetString(PyExc_IndexError, "index out of bounds"); - return 0; - } - return %CONVERTTOPYTHON[QWebElement](%CPPSELF.at(_i)); + if (_i < 0 || _i >= %CPPSELF.count()) { + PyErr_SetString(PyExc_IndexError, "index out of bounds"); + return 0; + } + QWebElement element = %CPPSELF.at(_i); + return %CONVERTTOPYTHON[QWebElement](element); diff --git a/PySide/QtXml/CMakeLists.txt b/PySide/QtXml/CMakeLists.txt index a06c710..3e5a7c7 100644 --- a/PySide/QtXml/CMakeLists.txt +++ b/PySide/QtXml/CMakeLists.txt @@ -35,7 +35,7 @@ ${CMAKE_CURRENT_BINARY_DIR}/PySide/QtXml/qxmlreader_wrapper.cpp ${CMAKE_CURRENT_BINARY_DIR}/PySide/QtXml/qxmlsimplereader_wrapper.cpp ) -set(QtXml_typesystem_path "${QtCore_SOURCE_DIR}") +set(QtXml_typesystem_path "${QtCore_SOURCE_DIR}${PATH_SEP}${QtCore_BINARY_DIR}") set(QtXml_include_dirs ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR}/PySide/QtXml ${CMAKE_SOURCE_DIR} diff --git a/PySide/QtXml/typesystem_xml.xml b/PySide/QtXml/typesystem_xml.xml index 1bf07de..19b1520 100644 --- a/PySide/QtXml/typesystem_xml.xml +++ b/PySide/QtXml/typesystem_xml.xml @@ -33,14 +33,17 @@ @@ -269,13 +272,13 @@ - QXmlInputSource* _qxmlinputsource_arg_ = 0; - - %BEGIN_ALLOW_THREADS - %RETURN_TYPE %0 = %CPPSELF.%FUNCTION_NAME(%1, %2, _qxmlinputsource_arg_); - %END_ALLOW_THREADS - - %PYARG_0 = Shiboken::makeTuple(%0, _qxmlinputsource_arg_); + QXmlInputSource* _qxmlinputsource_arg_ = 0; + %BEGIN_ALLOW_THREADS + %RETURN_TYPE %0 = %CPPSELF.%FUNCTION_NAME(%1, %2, _qxmlinputsource_arg_); + %END_ALLOW_THREADS + %PYARG_0 = PyTuple_New(2); + PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[%RETURN_TYPE](%0)); + PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[QXmlInputSource*](_qxmlinputsource_arg_)); @@ -296,11 +299,13 @@ - QXmlInputSource* _qxmlinputsource_arg_ = 0; - %BEGIN_ALLOW_THREADS - %RETURN_TYPE %0 = %CPPSELF.%TYPE::%FUNCTION_NAME(%1, %2, _qxmlinputsource_arg_); - %END_ALLOW_THREADS - %PYARG_0 = Shiboken::makeTuple(%0, _qxmlinputsource_arg_); + QXmlInputSource* _qxmlinputsource_arg_ = 0; + %BEGIN_ALLOW_THREADS + %RETURN_TYPE %0 = %CPPSELF.%TYPE::%FUNCTION_NAME(%1, %2, _qxmlinputsource_arg_); + %END_ALLOW_THREADS + %PYARG_0 = PyTuple_New(2); + PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[%RETURN_TYPE](%0)); + PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[QXmlInputSource*](_qxmlinputsource_arg_)); diff --git a/PySide/QtXmlPatterns/CMakeLists.txt b/PySide/QtXmlPatterns/CMakeLists.txt index 0d789ff..6efa4b0 100644 --- a/PySide/QtXmlPatterns/CMakeLists.txt +++ b/PySide/QtXmlPatterns/CMakeLists.txt @@ -26,7 +26,7 @@ set(QtXmlPatterns_SRC ${CMAKE_CURRENT_BINARY_DIR}/PySide/QtXmlPatterns/qxmlserializer_wrapper.cpp ${QtXmlPatterns_46_SRC} ) -set(QtXmlPatterns_typesystem_path "${QtCore_SOURCE_DIR}") +set(QtXmlPatterns_typesystem_path "${QtCore_SOURCE_DIR}${PATH_SEP}${QtCore_BINARY_DIR}") set(QtXmlPatterns_include_dirs ${CMAKE_CURRENT_SOURCE_DIR} ${QT_QTCORE_INCLUDE_DIR} ${QT_QTXMLPATTERNS_INCLUDE_DIR} diff --git a/PySide/QtXmlPatterns/typesystem_xmlpatterns.xml b/PySide/QtXmlPatterns/typesystem_xmlpatterns.xml index 665b302..d3ae58f 100644 --- a/PySide/QtXmlPatterns/typesystem_xmlpatterns.xml +++ b/PySide/QtXmlPatterns/typesystem_xmlpatterns.xml @@ -29,7 +29,8 @@ - %PYARG_0 = %CONVERTTOPYTHON[QXmlSchema*](new QXmlSchema(%CPPSELF.schema())); + QXmlSchema* %0 = new QXmlSchema(%CPPSELF.schema()); + %PYARG_0 = %CONVERTTOPYTHON[QXmlSchema*](%0); @@ -86,7 +87,11 @@ + + + + diff --git a/PySide/__init__.py.in b/PySide/__init__.py.in index 40731a8..da6cd69 100644 --- a/PySide/__init__.py.in +++ b/PySide/__init__.py.in @@ -1,5 +1,3 @@ __all__ = ['QtCore', 'QtGui', 'QtNetwork', 'QtOpenGL', 'QtSql', 'QtSvg', 'QtTest', 'QtWebKit', 'QtScript'] -import private - __version__ = "@BINDING_API_VERSION_FULL@" __version_info__ = (@BINDING_API_MAJOR_VERSION@, @BINDING_API_MINOR_VERSION@, @BINDING_API_MICRO_VERSION@, "@BINDING_API_RELEASE_LEVEL@", @BINDING_API_SERIAL@) diff --git a/PySide/licensecomment.txt b/PySide/licensecomment.txt index cbfe04e..dfeef80 100644 --- a/PySide/licensecomment.txt +++ b/PySide/licensecomment.txt @@ -1,7 +1,7 @@ /* * This file is part of PySide: Python for Qt * - * Copyright (C) 2009-2010 Nokia Corporation and/or its subsidiary(-ies). + * Copyright (C) 2009-2011 Nokia Corporation and/or its subsidiary(-ies). * * Contact: PySide team * diff --git a/PySide/phonon/CMakeLists.txt b/PySide/phonon/CMakeLists.txt index c11fe43..0564029 100644 --- a/PySide/phonon/CMakeLists.txt +++ b/PySide/phonon/CMakeLists.txt @@ -49,7 +49,7 @@ ${CMAKE_CURRENT_BINARY_DIR}/PySide/phonon/phonon_backendcapabilities_notifierwra ${phonon_OPTIONAL_SRC} ) -set(phonon_typesystem_path "${QtCore_SOURCE_DIR}${PATH_SEP}${QtGui_SOURCE_DIR}${PATH_SEP}${phonon_SOURCE_DIR}${PATH_SEP}${QtGui_BINARY_DIR}") +set(phonon_typesystem_path "${QtCore_SOURCE_DIR}${PATH_SEP}${QtCore_BINARY_DIR}${PATH_SEP}${QtGui_SOURCE_DIR}${PATH_SEP}${phonon_SOURCE_DIR}${PATH_SEP}${QtGui_BINARY_DIR}") set(phonon_include_dirs ${CMAKE_CURRENT_SOURCE_DIR} ${QT_QTCORE_INCLUDE_DIR} ${QT_QTGUI_INCLUDE_DIR} diff --git a/PySide/private.py b/PySide/private.py deleted file mode 100644 index 0fe1c13..0000000 --- a/PySide/private.py +++ /dev/null @@ -1,4 +0,0 @@ -import atexit -from QtCore import __moduleShutdown - -atexit.register(__moduleShutdown) diff --git a/PySide/typesystem_templates.xml b/PySide/typesystem_templates.xml index 3a46c62..2903ae4 100644 --- a/PySide/typesystem_templates.xml +++ b/PySide/typesystem_templates.xml @@ -21,76 +21,89 @@ + + + - - -