CoreBufferViewManager::CoreBufferViewManager(SignalProxy *proxy, CoreSession *parent)
: BufferViewManager(proxy, parent),
_coreSession(parent)
{
QVariantMap views = Core::getUserSetting(_coreSession->user(), "BufferViews").toMap();
QVariantMap::iterator iter = views.begin();
QVariantMap::iterator iterEnd = views.end();
CoreBufferViewConfig *config = 0;
while (iter != iterEnd) {
config = new CoreBufferViewConfig(iter.key().toInt(), iter.value().toMap(), this);
addBufferViewConfig(config);
++iter;
}
}
QVariantMap AddQtOperation::addQt(const QVariantMap &map,
const QString &id, const QString &displayName, const QString &type,
const QString &qmake, const KeyValuePairList &extra)
{
QString sdkId = extendId(id);
// Sanity check: Make sure autodetection source is not in use already:
if (exists(map, sdkId)) {
std::cerr << "Error: Id " << qPrintable(id) << " already defined as Qt versions." << std::endl;
return QVariantMap();
}
// Find position to insert:
int versionCount = 0;
for (QVariantMap::const_iterator i = map.begin(); i != map.end(); ++i) {
if (!i.key().startsWith(QLatin1String(PREFIX)))
continue;
QString number = i.key().mid(QString::fromLatin1(PREFIX).count());
bool ok;
int count = number.toInt(&ok);
if (ok && count >= versionCount)
versionCount = count + 1;
}
const QString qt = QString::fromLatin1(PREFIX) + QString::number(versionCount);
// Sanity check: Make sure displayName is unique.
QStringList nameKeys = FindKeyOperation::findKey(map, QLatin1String(DISPLAYNAME));
QStringList nameList;
foreach (const QString &nameKey, nameKeys)
nameList << GetOperation::get(map, nameKey).toString();
const QString uniqueName = makeUnique(displayName, nameList);
// Sanitize qmake path:
QString saneQmake = QDir::cleanPath(QDir::fromNativeSeparators(qmake));
// insert data:
KeyValuePairList data;
data << KeyValuePair(QStringList() << qt << QLatin1String(ID), QVariant(-1));
data << KeyValuePair(QStringList() << qt << QLatin1String(DISPLAYNAME), QVariant(uniqueName));
data << KeyValuePair(QStringList() << qt << QLatin1String(AUTODETECTED), QVariant(true));
data << KeyValuePair(QStringList() << qt << QLatin1String(AUTODETECTION_SOURCE), QVariant(sdkId));
data << KeyValuePair(QStringList() << qt << QLatin1String(QMAKE), QVariant(saneQmake));
data << KeyValuePair(QStringList() << qt << QLatin1String(TYPE), QVariant(type));
KeyValuePairList qtExtraList;
foreach (const KeyValuePair &pair, extra)
qtExtraList << KeyValuePair(QStringList() << qt << pair.key, pair.value);
data.append(qtExtraList);
return AddKeysOperation::addKeys(map, data);
}
void dataBase::fillFromJson(const QString &path)
{
QProgressBar bar;
bar.show();
QFile file(path);
if(!file.open(QFile::ReadOnly))
{
throw std::runtime_error(("No file "+ path).toStdString());
}
bool ok = false;
QVariantMap map = QtJson::parse(QString::fromUtf8(file.readAll().data()), ok).toMap();
if(!ok)
{
throw std::runtime_error(("Cant parse "+ path).toStdString());
}
for(QVariantMap::const_iterator it = map.begin(); it != map.end(); ++it)
{
QList<QVariant> list = it.value().toList();
for(QList<QVariant>::const_iterator list_it = list.begin(); list_it != list.end(); ++list_it)
{
bar.setValue(bar.value() >= bar.maximum() ? 0 : bar.value()+1);
qApp->processEvents();
QList<QVariant> values = list_it->toList();
QString q_text = QString("INSERT INTO %1 ( coeff, hrn ) VALUES ( '%2', '%3' )")
.arg(it.key())
.arg(values.at(0).toString())
.arg(values.at(1).toString());
query(q_text);
}
}
QList<QVariant> regions = map["regions"].toList();
for(QList<QVariant>::const_iterator it = regions.begin(); it!= regions.end(); ++it )
{
QList<QVariant> towns = it->toList().at(2).toList();
for(QList<QVariant>::const_iterator town_it = towns.begin(); town_it != towns.end(); ++town_it )
{
bar.setValue(bar.value() >= bar.maximum() ? 0 : bar.value()+1);
qApp->processEvents();
QList<QVariant> town_desc = town_it->toList();
QString q_text = QString("INSERT INTO towns VALUES ( %1, '%2', %3, %4, %5)")
.arg(town_desc.at(0).toInt())
.arg(town_desc.at(1).toString())
.arg(town_desc.at(2).toString())
.arg(town_desc.at(3).toString())
.arg(it->toList().at(0).toInt());
query(q_text);
}
}
bar.close();
}
QStringList FindKeyOperation::findKey(const QVariantMap &map, const QString &key)
{
QStringList result;
for (QVariantMap::const_iterator i = map.begin(); i != map.end(); ++i) {
if (i.key() == key) {
result << key;
continue;
}
if (i.value().type() == QVariant::Map) {
QStringList subKeyList = findKey(i.value().toMap(), key);
foreach (const QString &subKey, subKeyList)
result << i.key() + QLatin1Char('/') + subKey;
}
}
void table_widget_delegate::setWidgetData(const QModelIndex &index, QWidget *editor, const QVariant& data) const
{
if (!editor){
return;
}
column_data_ptr cd = _column_datas[index.column()];
if (!cd){
return;
}
switch (cd->type)
{
case WIDGET_CHECKBOX:
{
QCheckBox *widget = qobject_cast<QCheckBox*>(editor);
if(widget){
widget->setChecked(data.toBool());
}
}
break;
case WIDGET_COMBOBOX:
{
QComboBox *widget = qobject_cast<QComboBox*>(editor);
switch (cd->data.type())
{
case QVariant::StringList:
widget->setCurrentText(data.toString());
break;
case QVariant::Map:
{
QVariantMap map = cd->data.toMap();
QString text;
for (auto it = map.begin(); it != map.end(); ++it){
if (data == it.value()){
text = it.key();
}
}
widget->setCurrentText(text);
}
break;
default:
break;
}
}
default:
break;
}
}
static bool compare(const QVariantMap& one, const QVariantMap& other)
{
if (one.size() != other.size())
return false;
QVariantMap::const_iterator it1 = one.begin();
QVariantMap::const_iterator it2 = other.begin();
while (it1 != one.end()) {
if (it1.value().userType() != it2.value().userType())
return false;
if (!(it1.value() == it2.value())) {
if (it1.value().userType() == qMetaTypeId<QDBusObjectPath>()) {
if (!(it1.value().value<QDBusObjectPath>() == it2.value().value<QDBusObjectPath>()))
return false;
}
}
if (qMapLessThanKey(it1.key(), it2.key()) || qMapLessThanKey(it2.key(), it1.key()))
return false;
++it2;
++it1;
}
return true;
}
void RecognitionDatabase::setParameters(const QVariantMap& parameters)
{
if (!d || !d->dbAvailable)
{
return;
}
QMutexLocker lock(&d->mutex);
for (QVariantMap::const_iterator it = parameters.begin(); it != parameters.end(); ++it)
{
d->parameters.insert(it.key(), it.value());
}
d->applyParameters();
}
QString
Utilities::prettyPrint(const QVariantMap & map)
{
QString res;
res.append("{\n");
QVariantMap::const_iterator itr = map.begin();
res.append(QString("%1=%2").arg(itr.key(), prettyPrint(itr.value())));
for (++itr; itr != map.end(); ++itr) {
res.append(QString("; %1=%2").arg(itr.key(), prettyPrint(itr.value())));
}
res.append("}\n");
return res;
}
void JSONSerializer::serialize(const QVariant &variant) {
if (!variant.isValid()) { // Case of JSON null/undefined
// TODO:find a way to differenciate null/undefined
m_stream << JSON_NULL;
} else if (variant.type() == QVariant::Bool) { // Case of JSON boolean
m_stream << (variant.toBool() ? JSON_TRUE: JSON_FALSE);
} else if (variant.type() == QVariant::Map) { // Case of JSON object
m_stream << JSON_OBJECT_BEGIN;
const QVariantMap elements = variant.toMap();
auto it = elements.begin();
if (it != elements.end()) {
m_stream << sanitizeString(it.key()) << JSON_MEMBER_SEP;
serialize(it.value());
it++;
}
while (it != elements.end()) {
m_stream << JSON_ELEMENT_SEP << sanitizeString(it.key()) << JSON_MEMBER_SEP;
serialize(it.value());
it++;
}
m_stream << JSON_OBJECT_END;
} else if (variant.type() == QVariant::List) { // Case of JSON array
m_stream << JSON_ARRAY_BEGIN;
const QVariantList elements = variant.toList();
auto it = elements.begin();
if (it != elements.end()) {
serialize(*it);
it++;
}
while (it != elements.end()) {
m_stream << JSON_MEMBER_SEP;
serialize(*it);
it++;
}
m_stream << JSON_ARRAY_END;
} else if ((variant.type() == QVariant::String)
|| (variant.type() == QVariant::ByteArray)) { // Case of JSON string
m_stream << sanitizeString(variant.toString());
} else if ((variant.type() == QVariant::Double) || variant.canConvert<double>()) {
m_stream << QString::number(variant.toDouble()).replace("inf", "infinity");
} else if ((variant.type() == QVariant::String) || variant.canConvert<QString>()) {
m_stream << variant.toString();
} else {
throw JSONSerializerException("Fatal: QVariant type not managed.");
}
}
QVariantMap SetConfigHandler::handleRequest(QVariantMap request) {
if (request["target"] != "set_config") {
return next->handleRequest(request);
}
QSettings settings("config/config.ini", QSettings::IniFormat);
settings.setIniCodec("UTF-8");
QVariantMap items = request["items"].toMap();
QVariantMap response;
// 依次设置每一项，未作检测，危险
for (auto it = items.begin(); it != items.end(); it++) {
settings.setValue(it.key(), it.value());
}
response["status"] = "ok";
return response;
}
void qvariant2qobject(const QVariantMap& variant, T* object)
{
for ( QVariantMap::const_iterator iter = variant.begin(); iter != variant.end(); ++iter )
{
const int propertyIndex = T::staticMetaObject.indexOfProperty(iter.key().toLatin1());
if (propertyIndex < 0) {
qCWarning(KDECONNECT_CORE) << "missing property" << object << iter.key();
continue;
}
QMetaProperty property = T::staticMetaObject.property(propertyIndex);
bool ret = property.writeOnGadget(object, *iter);
if (!ret) {
qCWarning(KDECONNECT_CORE) << "couldn't set" << object << "->" << property.name() << '=' << *iter;
}
}
}
bool LicenseOperation::undoOperation()
{
const QVariantMap licenses = value(QLatin1String("licenses")).toMap();
if (licenses.isEmpty()) {
setError(UserDefinedError);
setErrorString(tr("No license files found to delete."));
return false;
}
QString targetDir = arguments().value(0);
for (QVariantMap::const_iterator it = licenses.begin(); it != licenses.end(); ++it)
QFile::remove(targetDir + QDir::separator() + it.key());
QDir dir;
dir.rmdir(targetDir);
return true;
}
static QString toJSLiteral_impl(const QVariantMap &vm, int level = 0)
{
QString indent;
for (int i = 0; i < level; ++i)
indent += QLatin1String(" ");
QString str;
for (QVariantMap::const_iterator it = vm.begin(); it != vm.end(); ++it) {
if (it.value().type() == QVariant::Map) {
str += indent + it.key() + QLatin1String(": {\n");
str += toJSLiteral_impl(it.value().toMap(), level + 1);
str += indent + QLatin1String("}\n");
} else {
str += indent + it.key() + QLatin1String(": ") + toJSLiteral(it.value())
+ QLatin1Char('\n');
}
}
return str;
}
QString confOption::getValueAsString() const
{
// Used when fetching data for the QTableView
if (type == MULTILIST)
{
QVariantMap map = value.toMap();
QString mapAsString;
for(QVariantMap::const_iterator iter = map.begin(); iter != map.end(); ++iter)
{
if (iter.value() == true && mapAsString.isEmpty())
mapAsString = QString(iter.key());
else if (iter.value() == true)
mapAsString = QString(mapAsString + " " + iter.key());
}
return mapAsString;
}
return value.toString();
}
void ReplicaSetSettings::fromVariant(const QVariantMap &map)
{
setSetName(map.value("setName").toString().toStdString());
// Extract and set replica members
std::vector<std::string> vec;
auto itr = map.begin();
int idx = 0;
do
{
itr = map.find(QString::number(idx));
if (map.end() == itr) break;
vec.push_back(itr->toString().toStdString());
++idx;
} while (map.end() != itr);
setMembers(vec);
// Extract and set read reference
setReadPreference(static_cast<ReadPreference>(map.value("readPreference").toInt()));
}
void QgsValueMapConfigDlg::setConfig( const QVariantMap& config )
{
tableWidget->clearContents();
for ( int i = tableWidget->rowCount() - 1; i > 0; i-- )
{
tableWidget->removeRow( i );
}
int row = 0;
QVariantMap values = config.value( QStringLiteral( "map" ) ).toMap();
for ( QVariantMap::ConstIterator mit = values.begin(); mit != values.end(); mit++, row++ )
{
if ( mit.value().isNull() )
setRow( row, mit.key(), QString() );
else
setRow( row, mit.value().toString(), mit.key() );
}
}
bool ICISettingsPrivate::evaluate(ICI::StatementNode* node, ICI::StatementListNode* parent){
if(!node)
return true;
currentNode = node;
switch(node->type){
case ICI::Node::Type_Assignement:{
QVariant out;
return evaluate(static_cast<ICI::AssignementStatementNode*>(node)->node, out);
}
case ICI::Node::Type_IfStatement:
return evaluate(static_cast<ICI::IfStatementNode*>(node));
case ICI::Node::Type_ForeachStatement:
return evaluate(static_cast<ICI::ForeachStatementNode*>(node));
case ICI::Node::Type_Include:
return evaluate(static_cast<ICI::IncludeStatementNode*>(node), parent);
case ICI::Node::Type_FunctionCall:{
QVariant returnValue;
bool success = evaluate(static_cast<ICI::FunctionCallStatementNode*>(node)->funct, returnValue);
if(!returnValue.isNull()){
qWarning() << QString("ignored return value of function %1 at line %2")
.arg(static_cast<ICI::FunctionCallStatementNode*>(node)->funct->name)
.arg(static_cast<ICI::FunctionCallStatementNode*>(node)->funct->line);
}
return success;
}
case ICI::Node::Type_Map:{
QVariant value;
bool success = evaluate(static_cast<ICI::MapStatementNode*>(node)->map, value);
if(!success || value.type() != QVariant::Map){
return false;
}
QVariantMap map = value.toMap();
for(QVariantMap::const_iterator it = map.begin(); it != map.end(); ++it){
setValue(it.key(), it.value());
}
return true;
}
case ICI::Node::Type_Unset:
return evaluate(static_cast<ICI::UnsetStatementNode*>(node));
default:return false;
}
return false;
}
ContactListFrontModel::ContactListFrontModel(QObject *parent) :
QSortFilterProxyModel(parent), m_showOffline(true)
{
Config config;
config.beginGroup("contactList");
m_showOffline = config.value("showOffline", true);
QVariantMap order = config.value("order", QVariantMap());
for (QVariantMap::Iterator it = order.begin(); it != order.end(); ++it)
m_order[it.key()] = it.value().toStringList();
setFilterCaseSensitivity(Qt::CaseInsensitive);
setSortCaseSensitivity(Qt::CaseInsensitive);
sort(0);
setDynamicSortFilter(true);
onServiceChanged(m_model.name(), m_model, NULL);
onServiceChanged(m_metaManager.name(), m_metaManager, NULL);
connect(ServiceManager::instance(), SIGNAL(serviceChanged(QByteArray,QObject*,QObject*)),
this, SLOT(onServiceChanged(QByteArray,QObject*,QObject*)));
}
void ShaderDialog::setParameters(QVariantMap const& map)
{
QString name;
double val;
bool ok;
hideOptionControls();
int sliderCount(0);
int checkBoxCount(0);
for (QVariantMap::const_iterator iter = map.begin(); iter != map.end(); ++iter) {
name = iter.key();
name.replace("_"," ");
switch (iter.value().type()) {
case QVariant::Bool:
if (checkBoxCount < s_maxCheckBoxes) {
m_checkBoxes[checkBoxCount]->show();
m_checkBoxes[checkBoxCount]->setText(name);
m_checkBoxes[checkBoxCount]->setChecked(iter.value().toBool());
++checkBoxCount;
}
break;
case QVariant::Double:
val = iter.value().toDouble(&ok);
if (ok && val <= 1.0 && sliderCount < s_maxSliders) {
m_labels[sliderCount]->show();
m_labels[sliderCount]->setText(name);
m_sliders[sliderCount]->show();
m_sliders[sliderCount]->setValue(100*val);
++sliderCount;
}
break;
default:
qDebug() << "Unsupported QVariant type in ShaderDialog" << iter.value().type();
break;
}
}
}
void ColorThemes::setCurrentColors(const QVariantMap &colorData)
{
if (!m_document)
return;
QStringList serializedColors;
QVector<QColor> colors = ColorThemeView::defaultColors();
for (QVariantMap::const_iterator i = colorData.begin(); i != colorData.end(); ++i) {
const int k = i.key().toInt();
if (k >= 0 && k < colors.count()) {
colors[k] = QColor(i.value().toString());
serializedColors << QString::fromLatin1("%1_%2").arg(k).arg(colors[k].name());
}
}
m_document->setLevelColors(colors);
m_document->setEditorInfo(m_document->scxmlRootTag(), Constants::C_SCXML_EDITORINFO_COLORS, serializedColors.join(";;"));
}
bool SetTaskHandler::validate(QVariantMap task) {
bool isValid = true;
bool ok;
try {
if (task.contains("id")) {
int v = task["id"].toString().toInt(&ok, 16);
assert_ex(ok && 0 <= v && v <= 255, ValidationError(""));
}
if (task.contains("categories")) {
QVariantMap categories = task["categories"].toMap();
for (auto it = categories.begin(); it != categories.end(); it++) {
int v = it.key().toInt(&ok, 16);
assert_ex(ok && 0 <= v && v <= 255, ValidationError(""));
}
}
} catch (ValidationError& e) {
isValid = false;
}
return isValid;
}
QVariantMap QSDiffRunnerAlgo::compareMap(const QVariantMap &prev, const QVariantMap ¤t)
{
// To make this function faster, it won't track removed fields from prev.
// Clear a field to null value should set it explicitly.
QVariantMap diff;
QMap<QString, QVariant>::const_iterator iter = current.begin();
while (iter != current.end()) {
QString key = iter.key();
if (!prev.contains(key) ||
prev[key] != iter.value()) {
diff[key] = iter.value();
}
iter++;
}
return diff;
}
void CanvasContextAttributes::setFrom(const QVariantMap &options)
{
for (QVariantMap::const_iterator iter = options.begin(); iter != options.end(); ++iter) {
if (iter.key() == "alpha")
setAlpha(iter.value().toBool());
else if (iter.key() == "depth")
setDepth(iter.value().toBool());
else if (iter.key() == "stencil")
setStencil(iter.value().toBool());
else if (iter.key() == "antialias")
setAntialias(iter.value().toBool());
else if (iter.key() == "premultipliedAlpha")
setPremultipliedAlpha(iter.value().toBool());
else if (iter.key() == "preserveDrawingBuffer")
setPreserveDrawingBuffer(iter.value().toBool());
else if (iter.key() == "preferLowPowerToHighPerformance")
setPreferLowPowerToHighPerformance(iter.value().toBool());
else if (iter.key() == "failIfMajorPerformanceCaveat")
setFailIfMajorPerformanceCaveat(iter.value().toBool());
}
}
void QDeclarativeGalleryQueryModel::set(int index, const QJSValue &values)
{
if (index < 0
|| index >= m_rowCount
|| (m_resultSet->currentIndex() != index && !m_resultSet->fetch(index))) {
return;
}
QVariant variant = values.toVariant();
if (variant.type() == QVariant::List) {
const QVariantList list = variant.toList();
for (int i = 0; i < list.size(); ++i)
m_resultSet->setMetaData(m_resultSet->propertyKey(QString::number(i)), list[i]);
} else if (variant.type() == QVariant::Map) {
const QVariantMap map = variant.toMap();
const QVariantMap::const_iterator end = map.end();
for (QVariantMap::const_iterator it = map.begin(); it != end; ++it)
m_resultSet->setMetaData(m_resultSet->propertyKey(it.key()), it.value());
}
}
JsonValue *JsonValue::build(const QVariant &variant, JsonMemoryPool *pool)
{
switch (variant.type()) {
case QVariant::List: {
JsonArrayValue *newValue = new (pool) JsonArrayValue;
foreach (const QVariant &element, variant.toList())
newValue->addElement(build(element, pool));
return newValue;
}
case QVariant::Map: {
JsonObjectValue *newValue = new (pool) JsonObjectValue;
const QVariantMap variantMap = variant.toMap();
for (QVariantMap::const_iterator it = variantMap.begin(); it != variantMap.end(); ++it)
newValue->addMember(it.key(), build(it.value(), pool));
return newValue;
}
case QVariant::String:
return new (pool) JsonStringValue(variant.toString());
case QVariant::Int:
return new (pool) JsonIntValue(variant.toInt());
case QVariant::Double:
return new (pool) JsonDoubleValue(variant.toDouble());
case QVariant::Bool:
return new (pool) JsonBooleanValue(variant.toBool());
case QVariant::Invalid:
return new (pool) JsonNullValue;
default:
break;
}
return 0;
}
QWidget * table_widget_delegate::createWidget(const QModelIndex &index, const QStyleOptionViewItem &option,
QWidget *parent) const
{
column_data_ptr cd = _column_datas[index.column()];
if (!cd){
return 0;
}
switch (cd->type)
{
case WIDGET_CHECKBOX:
return 0;
case WIDGET_COMBOBOX:
{
QComboBox *widget = new QComboBox(parent);
widget->setEditable(true);
switch (cd->data.type())
{
case QVariant::StringList:
widget->addItems(cd->data.toStringList());
break;
case QVariant::Map:
{
QVariantMap map = cd->data.toMap();
for (auto it = map.begin(); it != map.end(); ++it){
widget->addItem(it.key(), it.value());
}
}
break;
default:
break;
}
return widget;
}
default:
break;
}
return 0;
}
bool ShaderLibrary::setUniformVariables(QString const& shaderName, QVariantMap const& map)
{
// If there is no shader, the parameters affect the material
if (shaderName == NoShader) return setMaterialParameters(map);
bool ok;
double val;
QColor color;
QString name;
for (QVariantMap::const_iterator iter = map.begin(); iter != map.end(); ++iter) {
name = iter.key();
switch (iter.value().type()) {
// case QVariant::QColor:
// color = iter.value().value<QColor>();
// if (!color.isValid() || !setUniformVariable(shaderName, name, color)) {
// return false;
// }
// break;
case QVariant::Bool:
ok = iter.value().toBool();
if (!setUniformVariable(shaderName, name, ok)) return false;
break;
case QVariant::Double:
val = iter.value().toDouble(&ok);
if (!ok || !setUniformVariable(shaderName, name, val)) return false;
break;
default:
QLOG_DEBUG() << "Unsupported QVariant type in ShaderLibrary";
break;
}
}
return true;
}
QVariantMap RmQtOperation::rmQt(const QVariantMap &map, const QString &id)
{
QString sdkId = id;
if (!id.startsWith(QLatin1String("SDK.")))
sdkId = QString::fromLatin1("SDK.") + id;
QVariantList qtList;
for (QVariantMap::const_iterator i = map.begin(); i != map.end(); ++i) {
if (!i.key().startsWith(QLatin1String(PREFIX)))
continue;
QVariantMap qtData = i.value().toMap();
const QString dataId = qtData.value(QLatin1String(AUTODETECTION_SOURCE)).toString();
if ((dataId != id) && (dataId != sdkId))
qtList.append(qtData);
}
QVariantMap newMap = AddQtOperation::initializeQtVersions();
for (int i = 0; i < qtList.count(); ++i)
newMap.insert(QString::fromLatin1(PREFIX) + QString::number(i), qtList.at(i));
return newMap;
}
QScriptValue variantToScriptValue(const QVariant &var, QScriptEngine *e)
{
QScriptValue value;
switch (var.type()) {
case QVariant::Map: {
value = e->newObject();
const QVariantMap map = var.toMap();
for (QVariantMap::const_iterator it = map.begin(); it != map.end(); it++)
value.setProperty(it.key(), variantToScriptValue(it.value(), e));
break;
}
case QVariant::List: {
const QVariantList list = var.toList();
value = e->newArray(list.size());
for (int i = 0; i < list.size(); i++)
value.setProperty(i, variantToScriptValue(list.at(i), e));
break;
}
default:
value = e->newVariant(var);
}
return value;
}
QMap<QString, DictionaryParams> Dictionary::parseAvailableDictionaries(const QString& json, QString& dixioToken)
{
qDebug() << Q_FUNC_INFO << json;
QMap<QString, DictionaryParams> dictionaryList;
bool parseOk;
QVariantMap result = Json::parse(json, parseOk).toMap();
if(!parseOk)
return dictionaryList;
dixioToken = result["tokenDixio"].toString();
QVariantMap dictionaries = result["dictionaries"].toMap();
if(!dictionaries.size())
return dictionaryList;
QMap<QString, QVariant>::iterator i;
for (i = dictionaries.begin(); i != dictionaries.end(); ++i)
{
QVariantMap dictionaryMap = i.value().toMap();
DictionaryParams dictionary;
dictionary.id = dictionaryMap["id"].toString();
dictionary.commercialName = dictionaryMap["commercialName"].toString();
dictionary.shortName = dictionaryMap["shortName"].toString();
dictionary.downloadUrl = dictionaryMap["url"].toString();
dictionary.dixFileSize = dictionaryMap["url_size"].toInt();
dictionary.downloadUrlComp = dictionaryMap["url_comp"].toString();
dictionary.compFileSize = dictionaryMap["url_comp_size"].toInt();
dictionary.downloadFileName = dictionaryMap["downloadFileName"].toString();
dictionary.downloadFileNameComp = dictionaryMap["downloadFileName_comp"].toString();
dictionary.activationState = true;
dictionaryList.insert(dictionary.commercialName, dictionary);
}
return dictionaryList;
}
