void PythonPaletteManager::loadSettings()
{
const QVariant vLight = GlobalSettingsManger::instance().value(GSK_LightPalette);
const QVariant vDark = GlobalSettingsManger::instance().value(GSK_DarkPalette);
const QString scheme = GlobalSettingsManger::instance().value(GSK_ColorScheme, kColorSchemeLight).toString().toLower();
PythonPalette light = getDefaultLightPalette();
if (fromVariant(vLight, light))
m_SpecsLight = light;
PythonPalette dark = getDefaultDarkPalette();
if (fromVariant(vDark, dark))
m_SpecsDark = dark;
m_Specs = scheme == kColorSchemeLight ? m_SpecsLight : m_SpecsDark;
}
AbstractHousingDriver::RequestProperties::RequestProperties( const QVariant& variant )
{
if ( variant.isNull() ) {
type = AbstractHousingDriver::SearchTypeNone;
sorting = AbstractHousingDriver::SearchSortingNone;
properties = AbstractHousingDriver::SearchPropertyNone;
features = AbstractHousingDriver::SearchFeatureNone;
}
else {
fromVariant( variant );
}
}
bool PropertyGroup::fromString(const std::string & string)
{
// Convert from JSON
Variant values;
SerializerJSON json;
if (json.fromString(values, string)) {
return fromVariant(values);
}
// Error
return false;
}
PyObject* PythonTypeConverter::fromVariant(const QVariant &var)
{
if(var.type() == QVariant::Invalid)
Py_RETURN_NONE;
if(var.type() == QVariant::Bool)
return PyBool_FromLong(var.toInt());
if(var.type() == QVariant::Int)
return PyLong_FromLong(var.toInt());
if(var.type() == QVariant::Double || var.userType() == QMetaType::Float)
return PyFloat_FromDouble(var.toDouble());
if(var.type() == QVariant::String)
return PyUnicode_FromString(var.toString().toUtf8().data());
if(var.type() == QVariant::List)
{
const QList<QVariant> list = var.toList();
PyObject* pyList = PyList_New(list.size());
for(int i=0; i<list.size(); i++)
{
PyObject* obj = fromVariant(list[i]);
PyList_SET_ITEM(pyList, i , obj);
}
return pyList;
}
if(var.type() == QVariant::Map)
{
QVariantMap map = var.toMap();
PyObject* dict = PyDict_New();
foreach(const QString& key, map.keys())
{
const QVariant& value = map[key];
PyObject* pKey = fromVariant(key);
PyObject* pValue = fromVariant(value);
PyDict_SetItem(dict, pKey, pValue);
Py_DecRef(pKey);
Py_DecRef(pValue);
}
return dict;
}
QVariant ConversionUtil::fromVariant(QVariant::Type type, int userType, const QVariant &variant) {
switch (type) {
case QVariant::Bool:
case QVariant::Int:
case QVariant::Double:
case QVariant::String:
return variant;
case QVariant::StringList:
return variant.toStringList();
case QVariant::DateTime:
return QDateTime::fromMSecsSinceEpoch(variant.toLongLong());
case QVariant::Map: {
QVariantMap variantMap;
QVariantMap map = variant.toMap();
for (const QString &key : map.keys()) {
QVariantList valueList = map[key].toList();
if (valueList.length() == 3) {
QVariant::Type valueType = (QVariant::Type) valueList[0].toInt();
int valueUserType = valueList[1].toInt();
QVariant value = valueList[2];
variantMap[key] = fromVariant(valueType, valueUserType, value);
} else {
LogUtil::logError("Invalid map format in key: %1", key);
}
}
return variantMap;
}
case QVariant::UserType: {
MetaTypeRegistry::JsonConverters converters =
MetaTypeRegistry::jsonConverters(QMetaType::typeName(userType));
if (converters.jsonVariantToTypeConverter) {
return converters.jsonVariantToTypeConverter(variant);
} else {
const char *typeName = QMetaType::typeName(userType);
if (typeName) {
LogUtil::logError("User type not serializable: %1", typeName);
} else {
LogUtil::logError("Unknown user type: %1", QString::number(userType));
}
return QVariant();
}
}
default:
LogUtil::logError("Unknown type: %1", QVariant::typeToName(type));
return QVariant();
}
}
