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

Fix bug#320 - "OR'ing Qt alignments doesn't work; adding them does"

Browse source 
Reviewer: Luciano Wolf <luciano.wolf@openbossa.org>
          Renato Araújo <renato.filho@openbossa.org>
This commit is contained in:
Hugo Parente Lima 2010-09-02 20:33:00 -03:00
commit 823eec81c2
3 changed files with 22 additions and 12 deletions
Download patch file Download diff file Expand all files Collapse all files

2
PySide/QtCore/qvariant_conversions.h
View file

@ -34,7 +34,7 @@ struct Converter<QVariant>
} else if (PyFloat_CheckExact(pyObj)) { } else if (PyFloat_CheckExact(pyObj)) {
// QVariant(double) // QVariant(double)
return QVariant(Converter<double>::toCpp(pyObj)); return QVariant(Converter<double>::toCpp(pyObj));
} else if (PyInt_CheckExact(pyObj)) { } else if (PyInt_Check(pyObj)) {
// QVariant(int) // QVariant(int)
return QVariant(Converter<int>::toCpp(pyObj)); return QVariant(Converter<int>::toCpp(pyObj));
} else if (PyLong_CheckExact(pyObj)) { } else if (PyLong_CheckExact(pyObj)) {

17
libpyside/pysideconversions.h
View file

@ -237,19 +237,24 @@ struct QFlagsConverter
|| PyObject_TypeCheck(pyObj, Shiboken::SbkType<typename T::enum_type>()); || PyObject_TypeCheck(pyObj, Shiboken::SbkType<typename T::enum_type>());
} }
static inline PyObject* toPython(void* cppobj) static inline PyObject* toPython(void* cppObj)
{ {
return toPython(*reinterpret_cast<T*>(cppobj)); return toPython(*reinterpret_cast<T*>(cppObj));
} }
static inline PyObject* toPython(T cppenum) static inline PyObject* toPython(const T& cppObj)
{ {
return Shiboken::SbkEnumObject_New(Shiboken::SbkType<T>(), (long) cppenum); PyObject* qflags = Shiboken::SbkType<T>()->tp_alloc(Shiboken::SbkType<T>(), 0);
reinterpret_cast<PyIntObject*>(qflags)->ob_ival = cppObj;
return qflags;
} }
static inline T toCpp(PyObject* pyobj) static inline T toCpp(PyObject* pyObj)
{ {
return T(QFlag(reinterpret_cast<Shiboken::SbkEnumObject*>(pyobj)->ob_ival)); if (Shiboken::isShibokenEnum(pyObj))
return T(QFlag(reinterpret_cast<Shiboken::SbkEnumObject*>(pyObj)->ob_ival));
else
return T(QFlag(reinterpret_cast<PyIntObject*>(pyObj)->ob_ival));
} }
}; };

15
tests/QtCore/qflags_test.py
View file

@ -2,7 +2,7 @@
'''Test cases for QFlags''' '''Test cases for QFlags'''
import unittest import unittest
from PySide.QtCore import QIODevice, Qt, QFile, QTemporaryFile from PySide.QtCore import *
class QFlagTest(unittest.TestCase): class QFlagTest(unittest.TestCase):
'''Test case for usage of flags''' '''Test case for usage of flags'''
@ -28,15 +28,15 @@ class QFlagOperatorTest(unittest.TestCase):
def testInvert(self): def testInvert(self):
'''QFlags ~ (invert) operator''' '''QFlags ~ (invert) operator'''
self.assert_(isinstance(~QIODevice.ReadOnly, QIODevice.OpenMode)) self.assertEqual(type(~QIODevice.ReadOnly), QIODevice.OpenMode)
def testOr(self): def testOr(self):
'''QFlags | (or) operator''' '''QFlags | (or) operator'''
self.assert_(isinstance(QIODevice.ReadOnly | QIODevice.WriteOnly, QIODevice.OpenMode)) self.assertEqual(type(QIODevice.ReadOnly | QIODevice.WriteOnly), QIODevice.OpenMode)
def testAnd(self): def testAnd(self):
'''QFlags & (and) operator''' '''QFlags & (and) operator'''
self.assert_(isinstance(QIODevice.ReadOnly & QIODevice.WriteOnly, QIODevice.OpenMode)) self.assertEqual(type(QIODevice.ReadOnly & QIODevice.WriteOnly), QIODevice.OpenMode)
def testIOr(self): def testIOr(self):
'''QFlags |= (ior) operator''' '''QFlags |= (ior) operator'''
@ -47,7 +47,7 @@ class QFlagOperatorTest(unittest.TestCase):
def testInvertOr(self): def testInvertOr(self):
'''QFlags ~ (invert) operator over the result of an | (or) operator''' '''QFlags ~ (invert) operator over the result of an | (or) operator'''
self.assert_(isinstance(~(Qt.ItemIsSelectable | Qt.ItemIsEditable), Qt.ItemFlags)) self.assertEqual(type(~(Qt.ItemIsSelectable | Qt.ItemIsEditable)), Qt.ItemFlags)
def testEqual(self): def testEqual(self):
'''QFlags == operator''' '''QFlags == operator'''
@ -56,6 +56,11 @@ class QFlagOperatorTest(unittest.TestCase):
flag_type = (flags & Qt.WindowType_Mask) flag_type = (flags & Qt.WindowType_Mask)
self.assertEqual(flag_type, Qt.Window) self.assertEqual(flag_type, Qt.Window)
class QFlagsOnQVariant(unittest.TestCase):
def testQFlagsOnQVariant(self):
o = QObject()
o.setProperty("foo", QIODevice.ReadOnly | QIODevice.WriteOnly)
self.assertEqual(type(o.property("foo")), int)
if __name__ == '__main__': if __name__ == '__main__':
unittest.main() unittest.main()