diff --git a/extra/pyqt/PKGBUILD b/extra/pyqt/PKGBUILD new file mode 100644 index 000000000..3fe1d3863 --- /dev/null +++ b/extra/pyqt/PKGBUILD @@ -0,0 +1,90 @@ +# $Id: PKGBUILD 135252 2011-08-11 16:55:55Z andrea $ +# Maintainer: Andrea Scarpino <andrea@archlinux.org> +# Contributor: Douglas Soares de Andrade <douglas@archlinux.org> +# Contributor: riai <riai@bigfoot.com> Ben <ben@benmazer.net> + +# ALARM: macau <tema.prokopenko@gmail.com> +# - Fix for qreal on v7h + +plugrel=1 + +pkgbase=pyqt +pkgname=('pyqt' 'python2-pyqt') +pkgver=4.8.6 +pkgrel=1 +arch=('i686' 'x86_64') +url="http://riverbankcomputing.co.uk/software/pyqt/intro" +license=('GPL') +makedepends=('qt' 'python-sip' 'dbus-python' 'python2-sip' 'phonon' + 'python-opengl' 'qt-assistant-compat') +source=("http://riverbankcomputing.co.uk/static/Downloads/PyQt4/PyQt-x11-gpl-${pkgver}.tar.gz" + "PyQt4-4.7.3-qreal_float_support.patch") +md5sums=('9bfd7b08b8e438b83cc50d5c58191f97' + 'a20d7022e91071f838bd4908851a0f7b') + +build() { + cd "${srcdir}" + cp -r PyQt-x11-gpl-${pkgver} Py2Qt-x11-gpl-${pkgver} + + cd "${srcdir}/PyQt-x11-gpl-${pkgver}" + + # ALARM: Fix for v7h + if [ "$CARCH" = "armv7h" ]; then + patch -Np1 -i ${srcdir}/PyQt4-4.7.3-qreal_float_support.patch + fi + + python configure.py \ + --confirm-license \ + --qsci-api + + # Thanks Gerardo for the rpath fix + find -name 'Makefile' | xargs sed -i 's|-Wl,-rpath,/usr/lib||g;s|-Wl,-rpath,.* ||g' + + make + + ### Python2 version ### + cd "${srcdir}/Py2Qt-x11-gpl-${pkgver}" + python2 configure.py \ + --confirm-license \ + -v /usr/share/sip \ + --qsci-api + + # Thanks Gerardo for the rpath fix + find -name 'Makefile' | xargs sed -i 's|-Wl,-rpath,/usr/lib||g;s|-Wl,-rpath,.* ||g' + + make +} + +package_pyqt(){ + pkgdesc="A set of Python bindings for the Qt toolkit" + depends=('qt' 'python-sip') + optdepends=('phonon: enable audio and video in PyQt applications' + 'qscintilla: QScintilla API' + 'qt-assistant-compat: add PyQt online help in Qt Assistant') + replaces=('python-qt') + provides=('python-qt') + + cd "${srcdir}/PyQt-x11-gpl-${pkgver}" + # INSTALL_ROOT is needed for the QtDesigner module, the other Makefiles use DESTDIR + make DESTDIR="${pkgdir}" INSTALL_ROOT="${pkgdir}" install +} + +package_python2-pyqt(){ + pkgdesc="PyQt: A set of Python2 bindings for the Qt toolkit" + depends=('pyqt' 'python2-sip' 'dbus-python') + optdepends=('phonon: enable audio and video in PyQt applications' + 'python-opengl: enable OpenGL 3D graphics in PyQt applications' + 'qscintilla: QScintilla API' + 'qt-assistant-compat: add PyQt online help in Qt Assistant') + replaces=('python2-qt') + provides=('python2-qt') + + cd "${srcdir}/Py2Qt-x11-gpl-${pkgver}" + # INSTALL_ROOT is needed for the QtDesigner module, the other Makefiles use DESTDIR + make DESTDIR="${pkgdir}" INSTALL_ROOT="${pkgdir}" install + + # Provided by pyqt + rm ${pkgdir}/usr/bin/{pylupdate4,pyrcc4,pyuic4} + rm ${pkgdir}/usr/lib/qt/plugins/designer/libpythonplugin.so + rm ${pkgdir}/usr/share/qt/qsci/api/python/PyQt4.api +} diff --git a/extra/pyqt/PyQt4-4.7.3-qreal_float_support.patch b/extra/pyqt/PyQt4-4.7.3-qreal_float_support.patch new file mode 100644 index 000000000..958fe56cb --- /dev/null +++ b/extra/pyqt/PyQt4-4.7.3-qreal_float_support.patch @@ -0,0 +1,254 @@ +#! /bin/sh /usr/share/dpatch/dpatch-run +## 03_qreal_float_support.dpatch by Michael Casadevall <sonicmctails@gmail.com> +## +## DP: Corrects a configure test, and adds explicate double handling +## to qlist.sip on architectures where qreal != double + +@DPATCH@ +Index: python-qt4-4.7.2/configure.py +=================================================================== +--- python-qt4-4.7.2.orig/configure.py 2010-03-17 19:29:19.000000000 +0100 ++++ python-qt4-4.7.2/configure.py 2010-03-25 23:53:55.468631945 +0100 +@@ -1915,8 +1915,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.7.2/sip/QtCore/qlist.sip +=================================================================== +--- python-qt4-4.7.2.orig/sip/QtCore/qlist.sip 2010-03-17 19:29:26.000000000 +0100 ++++ python-qt4-4.7.2/sip/QtCore/qlist.sip 2010-03-25 23:53:55.468631945 +0100 +@@ -749,3 +749,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