void PropertyEditor::set(const QVariantHash &hash)
{
QVariantHash::const_iterator it = mProperties.constBegin();
for (;it != mProperties.constEnd(); ++it) {
QVariantHash::const_iterator ti = hash.find(it.key());
if (ti == hash.constEnd())
continue;
mProperties[it.key()] = ti.value();
}
}
void FSTReader::writeVariant(QBuffer& buffer, QVariantHash::const_iterator& it) {
QByteArray key = it.key().toUtf8() + " = ";
QVariantHash hashValue = it.value().toHash();
if (hashValue.isEmpty()) {
buffer.write(key + it.value().toByteArray() + "\n");
return;
}
for (QVariantHash::const_iterator second = hashValue.constBegin(); second != hashValue.constEnd(); second++) {
QByteArray extendedKey = key + second.key().toUtf8();
QVariantList listValue = second.value().toList();
if (listValue.isEmpty()) {
buffer.write(extendedKey + " = " + second.value().toByteArray() + "\n");
continue;
}
buffer.write(extendedKey);
for (QVariantList::const_iterator third = listValue.constBegin(); third != listValue.constEnd(); third++) {
buffer.write(" = " + third->toByteArray());
}
buffer.write("\n");
}
}
// Convert a QVariantHash to a dict of Python objects.
static PyObject *convert_hash(const Chimera *ct, const QVariantHash &value)
{
PyObject *dict = PyDict_New();
if (!dict)
return 0;
for (QVariantHash::const_iterator it = value.constBegin(); it != value.constEnd(); ++it)
{
if (add_variant_to_dict(ct, dict, it.key(), it.value()) < 0)
{
Py_DECREF(dict);
return 0;
}
}
return dict;
}
QDebug operator<<( QDebug debug, const Snore::Hint &hint )
{
debug << "Snore::Hint(";
for(QVariantHash::const_iterator it = hint.m_data.constBegin();it != hint.m_data.constEnd();++it)
{
if(it != hint.m_data.constBegin())
{
debug << ", ";
}
debug << "(" << it.key() << ", " << it.value();
}
for(QHash< QPair<quintptr, QString>, QVariant>::const_iterator it = hint.m_privateData.constBegin();it != hint.m_privateData.constEnd();++it)
{
if(it != hint.m_privateData.constBegin())
{
debug << ", ";
}
debug << "(" << it.key() << ", " << it.value();
}
debug << ")" ;
return debug.maybeSpace();
}
MapBox::MapBox(MainWindow * parent) :
QWidget(parent),
m_qgv(0),
m_scene(0),
m_mapWidget(0),
m_serviceProvider(0),
m_mapManager(0),
m_connectivityMode(QGraphicsGeoMap::HybridMode),
m_popupMenu(0),
m_popupMenuMapObject(0),
m_displayMode(DisplayNone),
m_optionsWidget(0)
{
for (QVariantHash::const_iterator it = parent->programOptions().begin(); it != parent->programOptions().end(); ++it)
{
m_parameters.insert(it.key(), it.value());
}
m_scene = new QGraphicsScene(this);
m_qgv = new QGraphicsView(m_scene, this);
m_qgv->setOptimizationFlag(QGraphicsView::IndirectPainting, true);
m_qgv->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
m_qgv->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
m_qgv->setFrameShape(QFrame::NoFrame);
m_optionsButton = new QPushButton("Options", m_qgv);
m_optionsButton->resize(m_optionsButton->sizeHint());
connect(m_optionsButton, SIGNAL(clicked()), this, SLOT(showOptions()));
QVBoxLayout * layout = new QVBoxLayout(this);
layout->setMargin(0);
setLayout(layout);
setDisplayMode(DisplayMap);
createDialogs();
createPixmapIcon();
}
/*static*/
PyObject * PythonScript::VariantToPython(const QVariant & v)
{
int i;
QVariantList::const_iterator iList;
QVariantList list;
#if QT_VERSION >= 0x040500
QVariantHash::const_iterator iHash;
QVariantHash hash;
#endif
QVariantMap::const_iterator iMap;
QVariantMap map;
PyObject * pyList, * pyDict;
if (v.isNull()) Py_RETURN_NONE;
switch ((QMetaType::Type)v.type()) {
case QVariant::Double:
return Py_BuildValue("d", v.toDouble());
case QVariant::Bool:
if (v.toBool()) Py_RETURN_TRUE;
else Py_RETURN_FALSE;
case QVariant::Int:
return Py_BuildValue("i", v.toInt());
case QVariant::LongLong:
return Py_BuildValue("L", v.toLongLong());
case QVariant::UInt:
return Py_BuildValue("I", v.toUInt());
case QVariant::ULongLong:
return Py_BuildValue("K", v.toULongLong());
case QVariant::Char:
case QVariant::String:
#ifdef Py_UNICODE_WIDE
{
QVector<uint> tmp = v.toString().toUcs4();
return Py_BuildValue("u#", tmp.constData(), tmp.count());
}
#else
return Py_BuildValue("u", v.toString().constData());
#endif
case QVariant::List:
case QVariant::StringList:
list = v.toList();
pyList = PyList_New(list.size());
for (i = 0, iList = list.begin(); iList != list.end(); ++iList, ++i) {
PyList_SetItem(pyList, i, PythonScript::VariantToPython(*iList));
}
return pyList;
#if QT_VERSION >= 0x040500
case QVariant::Hash:
hash = v.toHash();
pyDict = PyDict_New();
for (iHash = hash.begin(); iHash != hash.end(); ++iHash) {
PyDict_SetItemString(pyDict, qPrintable(iHash.key()), PythonScript::VariantToPython(iHash.value()));
}
return pyDict;
#endif
case QVariant::Map:
map = v.toMap();
pyDict = PyDict_New();
for (iMap = map.begin(); iMap != map.end(); ++iMap) {
PyDict_SetItemString(pyDict, qPrintable(iMap.key()), PythonScript::VariantToPython(iMap.value()));
}
return pyDict;
case QMetaType::QObjectStar:
return PythonScript::QObjectToPython(v.value<QObject*>());
#if QT_VERSION < 0x050000
case QMetaType::QWidgetStar:
return PythonScript::QObjectToPython(qobject_cast<QObject*>(v.value<QWidget*>()));
#endif
default:
PyErr_Format(PyExc_TypeError, qPrintable(tr("the type %s is currently not supported")), v.typeName());
return NULL;
}
Py_RETURN_NONE;
}
// Convert a C++ object at an arbitary address to Python.
PyObject *Chimera::toPyObject(void *cpp) const
{
if (_metatype == PyQt_PyObject::metatype)
{
if (_type)
{
// SIP knows the type (therefore it isn't really wrapped in a
// PyQt_PyObject) but it's not registered with Qt.
if (_name.endsWith('*'))
cpp = *reinterpret_cast<void **>(cpp);
return sipConvertFromType(cpp, _type, 0);
}
else
{
// Otherwise unwrap the Python object.
PyQt_PyObject *pyobj_wrapper = reinterpret_cast<PyQt_PyObject *>(cpp);
if (!pyobj_wrapper->pyobject)
{
PyErr_SetString(PyExc_TypeError,
"unable to convert a QVariant back to a Python object");
return 0;
}
Py_INCREF(pyobj_wrapper->pyobject);
return pyobj_wrapper->pyobject;
}
}
PyObject *py = 0;
switch (_metatype)
{
case QMetaType::Bool:
py = PyBool_FromLong(*reinterpret_cast<bool *>(cpp));
break;
case QMetaType::Int:
if (isFlag())
{
py = sipConvertFromType(cpp, _type, 0);
}
else if (isEnum())
{
py = sipConvertFromEnum(*reinterpret_cast<int *>(cpp), _type);
}
else
{
py = SIPLong_FromLong(*reinterpret_cast<int *>(cpp));
}
break;
case QMetaType::UInt:
{
long ui = *reinterpret_cast<unsigned int *>(cpp);
if (ui < 0)
py = PyLong_FromUnsignedLong((unsigned long)ui);
else
py = SIPLong_FromLong(ui);
break;
}
case QMetaType::Double:
py = PyFloat_FromDouble(*reinterpret_cast<double *>(cpp));
break;
case QMetaType::VoidStar:
py = sipConvertFromVoidPtr(*reinterpret_cast<void **>(cpp));
break;
case QMetaType::Long:
py = SIPLong_FromLong(*reinterpret_cast<long *>(cpp));
break;
case QMetaType::LongLong:
py = PyLong_FromLongLong(*reinterpret_cast<qlonglong *>(cpp));
break;
case QMetaType::Short:
py = SIPLong_FromLong(*reinterpret_cast<short *>(cpp));
break;
case QMetaType::Char:
case QMetaType::UChar:
py = SIPBytes_FromStringAndSize(reinterpret_cast<char *>(cpp), 1);
break;
case QMetaType::ULong:
py = PyLong_FromUnsignedLong(*reinterpret_cast<unsigned long *>(cpp));
break;
case QMetaType::ULongLong:
py = PyLong_FromUnsignedLongLong(*reinterpret_cast<qulonglong *>(cpp));
break;
case QMetaType::UShort:
py = SIPLong_FromLong(*reinterpret_cast<unsigned short *>(cpp));
break;
case QMetaType::Float:
py = PyFloat_FromDouble(*reinterpret_cast<float *>(cpp));
break;
case QMetaType::QObjectStar:
py = sipConvertFromType(*reinterpret_cast<void **>(cpp),
sipType_QObject, 0);
break;
case QMetaType::QWidgetStar:
if (sipType_QWidget)
py = sipConvertFromType(*reinterpret_cast<void **>(cpp),
sipType_QWidget, 0);
break;
case QMetaType::QVariantList:
{
QVariantList *ql = reinterpret_cast<QVariantList *>(cpp);
py = PyList_New(ql->size());
if (py)
{
for (int i = 0; i < ql->size(); ++i)
{
PyObject *val_obj = toAnyPyObject(ql->at(i));
if (!val_obj)
{
Py_DECREF(py);
py = 0;
break;
}
PyList_SET_ITEM(py, i, val_obj);
}
}
break;
}
case QMetaType::QVariantMap:
{
py = PyDict_New();
if (py)
{
QVariantMap *qm = reinterpret_cast<QVariantMap *>(cpp);
for (QVariantMap::const_iterator it = qm->constBegin(); it != qm->constEnd(); ++it)
if (!add_variant_to_dict(py, it.key(), it.value()))
{
Py_DECREF(py);
py = 0;
break;
}
}
break;
}
#if QT_VERSION >= 0x040500
case QMetaType::QVariantHash:
{
py = PyDict_New();
if (py)
{
QVariantHash *qh = reinterpret_cast<QVariantHash *>(cpp);
for (QVariantHash::const_iterator it = qh->constBegin(); it != qh->constEnd(); ++it)
if (!add_variant_to_dict(py, it.key(), it.value()))
{
Py_DECREF(py);
py = 0;
break;
}
}
break;
}
#endif
case -1:
{
char *s = *reinterpret_cast<char **>(cpp);
if (s)
{
py = SIPBytes_FromString(s);
}
else
{
Py_INCREF(Py_None);
py = Py_None;
}
break;
}
default:
if (_type)
{
if (_name.endsWith('*'))
{
py = sipConvertFromType(*reinterpret_cast<void **>(cpp),
_type, 0);
}
else
{
// Make a copy as it is a value type.
void *copy = QMetaType::construct(_metatype, cpp);
py = sipConvertFromNewType(copy, _type, 0);
if (!py)
QMetaType::destroy(_metatype, copy);
}
}
}
if (!py)
PyErr_Format(PyExc_TypeError,
"unable to convert a C++ '%s' instance to a Python object",
_name.constData());
return py;
}