/*!
Converts the variant hash \a hash to a QJsonObject.
\since 5.5
The keys in \a hash will be used as the keys in the JSON object,
and the QVariant values will be converted to JSON values.
\sa fromVariantMap(), toVariantHash(), QJsonValue::fromVariant()
*/
QJsonObject QJsonObject::fromVariantHash(const QVariantHash &hash)
{
// ### this is implemented the trivial way, not the most efficient way
QJsonObject object;
for (QVariantHash::const_iterator it = hash.constBegin(); it != hash.constEnd(); ++it)
object.insert(it.key(), QJsonValue::fromVariant(it.value()));
return object;
}
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();
}
}
// 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();
}
void ScanFoldersModel::configure()
{
const QVariantHash dirs = Preferences::instance()->getScanDirs();
for (QVariantHash::const_iterator i = dirs.begin(), e = dirs.end(); i != e; ++i) {
if (i.value().type() == QVariant::Int)
addPath(i.key(), static_cast<PathType>(i.value().toInt()), QString());
else
addPath(i.key(), CUSTOM_LOCATION, i.value().toString());
}
}
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");
}
}
/*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;
}
