[PyQt4/f13/master] adopt qreal_float_support patch from kubuntu
Rex Dieter
rdieter at fedoraproject.org
Fri Feb 25 19:18:20 UTC 2011
commit 1873c27e26df86c1559d7908871bdb39f86a984b
Author: Rex Dieter <rdieter at fedoraproject.org>
Date: Fri Feb 25 13:18:09 2011 -0600
adopt qreal_float_support patch from kubuntu
PyQt4.spec | 12 ++-
qreal_float_support.patch | 248 +++++++++++++++++++++++++++++++++++++++++++++
2 files changed, 259 insertions(+), 1 deletions(-)
---
diff --git a/PyQt4.spec b/PyQt4.spec
index 2c87339..ce86f43 100644
--- a/PyQt4.spec
+++ b/PyQt4.spec
@@ -4,7 +4,7 @@
Summary: Python bindings for Qt4
Name: PyQt4
Version: 4.7.3
-Release: 1%{?dist}
+Release: 2%{?dist}
# GPLv2 exceptions(see GPL_EXCEPTIONS*.txt)
License: GPLv3 or GPLv2 with exceptions
@@ -21,6 +21,9 @@ Patch4: PyQt-x11-gpl-4.5.1-pyuic_shebang.patch
Patch5: PyQt-x11-gpl-4.6.2-timestamp-multilib.patch
# fix implicit linking when checking for QtAssistant, QtHelp
Patch6: PyQt-x11-gpl-4.7.2-fix-implicit-linking.patch
+# arm qreal/float madness
+# http://www.riverbankcomputing.com/pipermail/pyqt/2011-February/029315.html
+Patch7: http://bazaar.launchpad.net/~ubuntu-branches/ubuntu/natty/python-qt4/natty/view/head:/debian/patches/qreal_float_support.patch
BuildRequires: chrpath
BuildRequires: dbus-devel dbus-python-devel
@@ -65,6 +68,10 @@ of the Qt4 classes (e.g. KDE or your own).
%patch4 -p1
%patch5 -p1 -b .timestamp
%patch6 -p1 -b .fix-implicit-linking
+# conditionalize for now, discussion is ongoing in upstream ml
+%ifarch armv5tel
+%patch7 -p1 -b .qreal_float_support
+%endif
## permissions
# mark examples non-executable
@@ -151,6 +158,9 @@ rm -rf %{buildroot}
%changelog
+* Fri Feb 25 2011 Rex Dieter <rdieter at fedoraproject.org> 4.7.3-2
+- adopt qreal_float_support patch from kubuntu
+
* Sat Apr 17 2010 Rex Dieter <rdieter at fedoraproject.org> - 4.7.3-1
- PyQt-x11-gpl-4.7.3
diff --git a/qreal_float_support.patch b/qreal_float_support.patch
new file mode 100644
index 0000000..abdf70f
--- /dev/null
+++ b/qreal_float_support.patch
@@ -0,0 +1,248 @@
+## 03_qreal_float_support.dpatch by Michael Casadevall <sonicmctails at gmail.com>
+Index: python-qt4-4.8.3/configure.py
+===================================================================
+--- python-qt4-4.8.3.orig/configure.py 2011-02-24 10:33:30.000000000 +0200
++++ python-qt4-4.8.3/configure.py 2011-02-24 10:33:18.000000000 +0200
+@@ -2004,8 +2004,9 @@
+ out << "PyQt_NoOpenGLES\\n";
+ #endif
+
+- if (sizeof (qreal) != sizeof (double))
++#if defined(QT_NO_FPU) || defined(QT_ARCH_ARM) || defined(QT_ARCH_WINDOWSCE)
+ out << "PyQt_qreal_double\\n";
++#endif
+
+ return 0;
+ }
+Index: python-qt4-4.8.3/sip/QtCore/qlist.sip
+===================================================================
+--- python-qt4-4.8.3.orig/sip/QtCore/qlist.sip 2011-02-24 10:33:27.000000000 +0200
++++ python-qt4-4.8.3/sip/QtCore/qlist.sip 2011-02-24 10:33:18.000000000 +0200
+@@ -811,3 +811,227 @@
+ return sipGetState(sipTransferObj);
+ %End
+ };
++
++// If we're on an architecture where qreal != double, then we need to also
++// explicately handle doubles. On architectures where qreal == double, they
++// will automaticially be cast upwards
++
++%If (!PyQt_qreal_double)
++
++%If (Qt_4_3_0 -)
++// QList<QPair<double, double> > is implemented as a Python list of 2-element tuples.
++%MappedType QList<QPair<double, double> >
++{
++%TypeHeaderCode
++#include <qlist.h>
++#include <qpair.h>
++%End
++
++%ConvertFromTypeCode
++ // Create the list.
++ PyObject *l;
++
++ if ((l = PyList_New(sipCpp->size())) == NULL)
++ return NULL;
++
++ // Set the list elements.
++ for (int i = 0; i < sipCpp->size(); ++i)
++ {
++ const QPair<double, double> &p = sipCpp->at(i);
++ PyObject *pobj;
++
++ if ((pobj = Py_BuildValue((char *)"dd", p.first, p.second)) == NULL)
++ {
++ Py_DECREF(l);
++
++ return NULL;
++ }
++
++ PyList_SET_ITEM(l, i, pobj);
++ }
++
++ return l;
++%End
++
++%ConvertToTypeCode
++ SIP_SSIZE_T len;
++
++ // Check the type if that is all that is required.
++ if (sipIsErr == NULL)
++ {
++ if (!PySequence_Check(sipPy) || (len = PySequence_Size(sipPy)) < 0)
++ return 0;
++
++ for (SIP_SSIZE_T i = 0; i < len; ++i)
++ {
++ PyObject *tup = PySequence_ITEM(sipPy, i);
++
++ if (!PySequence_Check(tup) || PySequence_Size(tup) != 2)
++ return 0;
++ }
++
++ return 1;
++ }
++
++ QList<QPair<double, double> > *ql = new QList<QPair<double, double> >;
++ len = PySequence_Size(sipPy);
++
++ for (SIP_SSIZE_T i = 0; i < len; ++i)
++ {
++ PyObject *tup = PySequence_ITEM(sipPy, i);
++
++ double first = PyFloat_AsDouble(PySequence_ITEM(tup, 0));
++ double second = PyFloat_AsDouble(PySequence_ITEM(tup, 1));
++
++ ql->append(QPair<double, double>(first, second));
++ }
++
++ *sipCppPtr = ql;
++
++ return sipGetState(sipTransferObj);
++%End
++};
++%End
++%If (Qt_4_3_0 -)
++// QList<QPair<double, TYPE> > is implemented as a Python list of 2-element tuples.
++template<double, TYPE>
++%MappedType QList<QPair<double, TYPE> >
++{
++%TypeHeaderCode
++#include <qlist.h>
++#include <qpair.h>
++%End
++
++%ConvertFromTypeCode
++ // Create the list.
++ PyObject *l;
++
++ if ((l = PyList_New(sipCpp->size())) == NULL)
++ return NULL;
++
++ // Set the list elements.
++ for (int i = 0; i < sipCpp->size(); ++i)
++ {
++ const QPair<double, TYPE> &p = sipCpp->at(i);
++ TYPE *t = new TYPE(p.second);
++ PyObject *pobj;
++
++ if ((pobj = sipBuildResult(NULL, "(dB)", p.first, t, sipClass_TYPE, sipTransferObj)) == NULL)
++ {
++ Py_DECREF(l);
++ delete t;
++
++ return NULL;
++ }
++
++ PyList_SET_ITEM(l, i, pobj);
++ }
++
++ return l;
++%End
++
++%ConvertToTypeCode
++ SIP_SSIZE_T len;
++
++ // Check the type if that is all that is required.
++ if (sipIsErr == NULL)
++ {
++ if (!PySequence_Check(sipPy) || (len = PySequence_Size(sipPy)) < 0)
++ return 0;
++
++ for (SIP_SSIZE_T i = 0; i < len; ++i)
++ {
++ PyObject *tup = PySequence_ITEM(sipPy, i);
++
++ if (!PySequence_Check(tup) || PySequence_Size(tup) != 2)
++ return 0;
++
++ if (!sipCanConvertToInstance(PySequence_ITEM(tup, 1), sipClass_TYPE, SIP_NOT_NONE))
++ return 0;
++ }
++
++ return 1;
++ }
++
++ QList<QPair<double, TYPE> > *ql = new QList<QPair<double, TYPE> >;
++ len = PySequence_Size(sipPy);
++
++ for (SIP_SSIZE_T i = 0; i < len; ++i)
++ {
++ PyObject *tup = PySequence_ITEM(sipPy, i);
++ double d;
++ int state;
++
++ d = PyFloat_AsDouble(PySequence_ITEM(tup, 0));
++ TYPE *t = reinterpret_cast<TYPE *>(sipConvertToInstance(PySequence_ITEM(tup, 1), sipClass_TYPE, sipTransferObj, SIP_NOT_NONE, &state, sipIsErr));
++
++ if (*sipIsErr)
++ {
++ sipReleaseInstance(t, sipClass_TYPE, state);
++
++ delete ql;
++ return 0;
++ }
++
++ ql->append(QPair<double, TYPE>(d, *t));
++
++ sipReleaseInstance(t, sipClass_TYPE, state);
++ }
++
++ *sipCppPtr = ql;
++
++ return sipGetState(sipTransferObj);
++%End
++};
++%End
++
++// QList<double> is implemented as a Python list of doubles.
++%MappedType QList<double>
++{
++%TypeHeaderCode
++#include <qlist.h>
++%End
++
++%ConvertFromTypeCode
++ // Create the list.
++ PyObject *l;
++
++ if ((l = PyList_New(sipCpp->size())) == NULL)
++ return NULL;
++
++ // Set the list elements.
++ for (int i = 0; i < sipCpp->size(); ++i)
++ {
++ PyObject *pobj;
++
++ if ((pobj = PyFloat_FromDouble(sipCpp->value(i))) == NULL)
++ {
++ Py_DECREF(l);
++
++ return NULL;
++ }
++
++ PyList_SET_ITEM(l, i, pobj);
++ }
++
++ return l;
++%End
++
++%ConvertToTypeCode
++ // Check the type if that is all that is required.
++ if (sipIsErr == NULL)
++ return (PySequence_Check(sipPy) && PySequence_Size(sipPy) >= 0);
++
++ QList<double> *ql = new QList<double>;
++ SIP_SSIZE_T len = PySequence_Size(sipPy);
++
++ for (SIP_SSIZE_T i = 0; i < len; ++i)
++ ql->append(PyFloat_AsDouble(PySequence_ITEM(sipPy, i)));
++
++ *sipCppPtr = ql;
++
++ return sipGetState(sipTransferObj);
++%End
++};
++
++%End
More information about the scm-commits
mailing list