void GlosbeDic::processData(const QByteArray& _buff, const QString& _word, void* _resultStorage) { QJsonParseError Error; QStringList* Storage = (QStringList*)_resultStorage; QJsonDocument JSonDoc = QJsonDocument::fromJson(_buff, &Error); if (Error.error != QJsonParseError::NoError) throw ("[Glosbe] Json Parse Error" + Error.errorString() + QString::number(Error.offset)); if (JSonDoc.isObject()){ QJsonObject JsonObject = JSonDoc.object(); for(auto ObjectIter = JsonObject.constBegin(); ObjectIter != JsonObject.constEnd(); ObjectIter++) { if(ObjectIter.key().toLower().startsWith("tuc")) { for (QJsonValue ArrayIterValue : ObjectIter.value().toArray()) { QJsonObject JsonObject = ArrayIterValue.toObject(); for(auto ObjectIter = JsonObject.constBegin(); ObjectIter != JsonObject.constEnd(); ObjectIter++) { if(ObjectIter.key().toLower().startsWith("phrase")) { if (ObjectIter.value().toObject().value("language").toString() == this->SecondLangID) { QString Translation = ObjectIter.value().toObject().value("text").toString().trimmed().toLower(); Storage->append(Translation); this->add2Cache(_word.trimmed().toLower(), Translation); } }else if(ObjectIter.key().toLower() == "authors") { }else if(ObjectIter.key().toLower() == "meaningid") { }else if(ObjectIter.key().toLower() == "meanings") { }else wmaDebug<<"[Glosbe] Unkwon JSON Tag2: "<<wmaPrintable(ObjectIter.key())<<std::endl; } } }else if(ObjectIter.key().toLower() == "result") { }else if(ObjectIter.key().toLower() == "dest") { }else if(ObjectIter.key().toLower() == "from") { }else if(ObjectIter.key().toLower() == "phrase") { }else wmaDebug<<"[Glosbe] Unkwon JSON Tag1: "<<wmaPrintable(ObjectIter.key())<<std::endl; } } }
QMap<QString, QMap<QString, QString>> Info::getServiceServerAddressMeta() { QString filename = getAddressMetaFilename(); QByteArray json("[]"); if(Filesystem::fileExist(filename)){ json = Filesystem::fileGetContents(filename); } QJsonParseError parserError; QJsonDocument doc = QJsonDocument::fromJson(json, &parserError); QMap<QString, QMap<QString, QString>> ret; if(parserError.error == QJsonParseError::NoError){ QJsonArray array = doc.array(); QJsonArray::const_iterator ait = array.constBegin(); QJsonArray::const_iterator aendmarker = array.constEnd(); while(ait != aendmarker){ QJsonValue v = *ait; if(v.isObject()){ QJsonObject item = v.toObject(); QJsonObject::const_iterator oit = item.constBegin(); QJsonObject::const_iterator oendmarker = item.constEnd(); QMap<QString, QString> dataItem; while(oit != oendmarker){ dataItem.insert(oit.key(), oit.value().toString()); oit++; } ret.insert(dataItem.value("key"), dataItem); } ait++; } } return ret; }
void ShellUI::reloadConfig() { m_properties.clear(); qDeleteAll(m_bindings); m_bindings.clear(); QJsonObject object; if (m_config.contains(QStringLiteral("Shell"))) { object = m_config[QStringLiteral("Shell")].toObject(); } else { QJsonParseError err; QJsonDocument doc = QJsonDocument::fromJson(defaultShell, &err); if (err.error != QJsonParseError::NoError) { qDebug() << "Cannot parse the default shell config" << err.errorString(); } object = doc.object(); m_config[QStringLiteral("Shell")] = object; } QJsonObject properties = object[QStringLiteral("properties")].toObject(); for (auto i = properties.constBegin(); i != properties.constEnd(); ++i) { setProperty(qPrintable(i.key()), i.value().toVariant()); m_properties << i.key(); } QJsonArray bindings = object[QStringLiteral("bindings")].toArray(); for (auto i = bindings.begin(); i != bindings.end(); ++i) { const QJsonObject &binding = (*i).toObject(); if (!parseBinding(binding)) { qDebug() << "Cannot parse binding" << binding; } } foreach (UiScreen *screen, m_screens) { loadScreen(screen); }
BtsApiNotifier *BtsApi::getFolderPrefs(const QString &secret) { QueryList ql; ql << QueryPair("secret", secret); QUrl apiUrl = getApiUrl(p, "get_folder_prefs", ql); QNetworkReply *reply = p->nam->get(QNetworkRequest(apiUrl)); BtsApiNotifier *notifier = new BtsApiNotifier(this); connect(reply, &QNetworkReply::finished, [this, reply, notifier, secret]() { notifier->deleteLater(); if(checkForError(reply, notifier)) return; QJsonDocument doc = QJsonDocument::fromJson(reply->readAll()); if(checkForError(doc, notifier)) return; QJsonObject obj = doc.object(); QVariantHash res; for(auto it = obj.constBegin(); it != obj.constEnd(); ++it) res[it.key()] = it.value().toVariant(); emit getFolderPrefsResult(res, secret); emit notifier->getFolderPrefsResult(res, secret); }); return notifier; }
Nuria::JsonMetaObjectReader::Error Nuria::JsonMetaObjectReader::parse (const QJsonObject &root) { Error error = NoError; auto it = root.constBegin (); auto end = root.constEnd (); for (; it != end && error == NoError; ++it) { QString fileName = it.key (); QJsonValue fileValue = *it; MetaObjectMap metaObjectMap; if (!fileValue.isObject ()) { error = FileIsNotAnObject; break; } error = parseTypesObject (fileValue.toObject (), metaObjectMap); // Store this->d_ptr->objects.insert (fileName, metaObjectMap); } // if (error != NoError) { this->d_ptr->clearData (); } return error; }
void ServerSummaryPage::saveSettings() { QJsonObject o { {config::ClientTimeout.name, int(d->clientTimeout->value() * 60)}, {config::AllowGuests.name, d->allowGuests->isChecked()}, {config::AllowGuestHosts.name, d->allowGuestHosts->isChecked()}, {config::SessionSizeLimit.name, d->sessionSizeLimit->value() * 1024 * 1024}, {config::IdleTimeLimit.name, d->idleTimeout->value() * 60}, {config::SessionCountLimit.name, d->sessionSizeLimit->value()}, {config::EnablePersistence.name, d->persistence->isChecked()}, {config::ArchiveMode.name, d->archiveSessions->isChecked()}, {config::PrivateUserList.name, d->privateUserList->isChecked()} }; QJsonObject update; for(auto i=o.constBegin();i!=o.constEnd();++i) { if(d->lastUpdate[i.key()] != i.value()) update[i.key()] = i.value(); } if(!update.isEmpty()) { d->lastUpdate = o; qDebug() << "update" << update; d->server->makeApiRequest(REQ_ID, JsonApiMethod::Update, QStringList() << "server", update); } }
void ResultRecorder::mergeResults(const QJsonObject &o) { // Merge the keys from the subprocess in where they should be. for (auto it = o.constBegin(); it != o.constEnd(); ++it) { m_results[it.key()] = it.value().toVariant(); } }
BtsApiNotifier *BtsApi::getPreferences() { QUrl apiUrl = getApiUrl(p, "get_prefs"); QNetworkReply *reply = p->nam->get(QNetworkRequest(apiUrl)); BtsApiNotifier *notifier = new BtsApiNotifier(this); connect(reply, &QNetworkReply::finished, [this, reply, notifier]() { notifier->deleteLater(); if(checkForError(reply, notifier)) return; QJsonDocument doc = QJsonDocument::fromJson(reply->readAll()); if(checkForError(doc, notifier)) return; QJsonObject obj = doc.object(); QVariantHash res; for(auto it = obj.constBegin(); it != obj.constEnd(); ++it) res[it.key()] = it.value().toVariant(); emit getPreferencesResult(res); emit notifier->getPreferencesResult(res); }); return notifier; }
void GetFaceResourceTest::testFaces(const QString& fileName) { QString base = testResources + QDir::separator() + fileName; QFile file(base + ".jpg"); QJsonDocument current; int status = faceResource->getJSONFaces(&file, current); file.close(); QCOMPARE(HttpHeaders::STATUS_SUCCESS, status); QFile jsonFile(base + ".json"); QVERIFY(jsonFile.exists()); jsonFile.open(QIODevice::ReadOnly | QIODevice::Text); QJsonDocument expected = QJsonDocument().fromJson(jsonFile.readAll()); jsonFile.close(); QJsonArray currentArray = current.array(); QJsonArray expectedArray = expected.array(); // Make sure we're not comparing zero to zero QVERIFY(expectedArray.size() > 0); QCOMPARE(currentArray.size(), expectedArray.size()); for (int i=0; i<currentArray.size(); ++i) { QJsonObject cFaceParts = currentArray[i].toObject(); QJsonObject eFaceParts = expectedArray[i].toObject(); QJsonObject cFace = eFaceParts["face"].toObject(); QJsonObject eFace = eFaceParts["face"].toObject(); compareDoubles(cFace["x1"].toDouble(), eFace["x1"].toDouble(), 0.0001); compareDoubles(cFace["x2"].toDouble(), eFace["x2"].toDouble(), 0.0001); compareDoubles(cFace["y1"].toDouble(), eFace["y1"].toDouble(), 0.0001); compareDoubles(cFace["y2"].toDouble(), eFace["y2"].toDouble(), 0.0001); QCOMPARE(cFaceParts["pose"], eFaceParts["pose"]); QCOMPARE(cFaceParts["model"], eFaceParts["model"]); QJsonObject cParts = cFaceParts["parts"].toObject(); QJsonObject eParts = eFaceParts["parts"].toObject(); QCOMPARE(cParts.size(), eParts.size()); for (QJsonObject::const_iterator cIter = cParts.constBegin(); cIter != cParts.constEnd(); ++cIter) { QJsonArray cSubpart = cIter.value().toArray(); QJsonArray eSubpart = cParts[cIter.key()].toArray(); QCOMPARE(cSubpart.size(), eSubpart.size()); for (int i=0; i<cSubpart.size(); ++i) { QJsonObject cPart = cSubpart[i].toObject(); QJsonObject ePart = eSubpart[i].toObject(); compareDoubles(cPart["x"].toDouble(), ePart["x"].toDouble(), 0.0001); compareDoubles(cPart["y"].toDouble(), ePart["y"].toDouble(), 0.0001); QCOMPARE(cPart["num"], ePart["num"]); } } } }
static PyObject *convertFrom_QJsonObject(void *sipCppV, PyObject *sipTransferObj) { QJsonObject *sipCpp = reinterpret_cast<QJsonObject *>(sipCppV); #line 28 "C:\\Users\\marcus\\Downloads\\PyQt-gpl-5.4\\PyQt-gpl-5.4\\sip/QtCore/qjsonobject.sip" PyObject *d = PyDict_New(); if (!d) return 0; QJsonObject::const_iterator it = sipCpp->constBegin(); QJsonObject::const_iterator end = sipCpp->constEnd(); while (it != end) { QString *k = new QString(it.key()); PyObject *kobj = sipConvertFromNewType(k, sipType_QString, sipTransferObj); if (!kobj) { delete k; Py_DECREF(d); return 0; } QJsonValue *v = new QJsonValue(it.value()); PyObject *vobj = sipConvertFromNewType(v, sipType_QJsonValue, sipTransferObj); if (!vobj) { delete v; Py_DECREF(kobj); Py_DECREF(d); return 0; } int rc = PyDict_SetItem(d, kobj, vobj); Py_DECREF(vobj); Py_DECREF(kobj); if (rc < 0) { Py_DECREF(d); return 0; } ++it; } return d; #line 182 "C:\\Users\\marcus\\Downloads\\PyQt-gpl-5.4\\PyQt-gpl-5.4\\QtCore/sipQtCoreQJsonObject.cpp" }
QStringList DBSchema::fields(QString tableName) const { QJsonArray table = jsondoc.object().value(tableName).toArray(); QStringList li; for (int i = 0; i < table.size(); ++i){ QJsonObject field = table.at(i).toObject(); QJsonObject::const_iterator it = field.constBegin(); li.append( it.key() ); } return li; }
void XSAppBuilder::cmopileJsonObject(const QJsonObject &obj) { QJsonObject::const_iterator it = obj.constBegin(); while(it != obj.constEnd()) { if(root.contains(it.key())) { //暂时不需要json } it++; } }
QString DBSchema::type(QString tableName, QString fieldName) const { QJsonArray table = jsondoc.object().value(tableName).toArray(); for (int i = 0; i < table.size(); ++i){ QJsonObject field = table.at(i).toObject(); QJsonObject::const_iterator it = field.constBegin(); if (it.key() == fieldName ){ return it.value().toString(); } } return QString(); }
void XSAppBuilder::createPropertyObject(const QString &proName, const QString &proData, xsObject *proObject) { if(proObject == NULL) { return; } if(root.contains(proName)) { QStringList list = proData.split(";", QString::SkipEmptyParts); QJsonObject obj = root.value(proName).toObject(); QJsonObject::const_iterator it = obj.constBegin(); while(it != obj.constEnd()) { if(it.key() == "prototype" || it.key() == "@prototype") { it++; continue; } for(int i = 0; i < list.size(); i++) { if(list.at(i).contains(it.key())) { if(it.key() == "@inherit") { createPropertyObject(it.value().toString(), proData, proObject); } else { QJsonObject subObj = it.value().toObject(); QStringList dataList = list.at(i).split(":",QString::SkipEmptyParts); if(dataList.size() == 2) { xsValue property; transformValue(subObj, &property, dataList.at(1), it.key()); proObject->setProperty(it.key().toStdString().c_str(), &property); } } } } it++; } } return; }
static Nuria::JsonMetaObjectReader::Error parseFieldsObject (const QJsonObject &fields, Nuria::RuntimeMetaObject *metaObject) { Nuria::JsonMetaObjectReader::Error error = Nuria::JsonMetaObjectReader::NoError; auto it = fields.constBegin (); auto end = fields.constEnd (); for (; it != end && error == Nuria::JsonMetaObjectReader::NoError; ++it) { QString name = it.key (); QJsonValue value = *it; if (!value.isObject ()) return Nuria::JsonMetaObjectReader::FieldIsNotAnObject; error = parseFieldObject (name, value.toObject (), metaObject); } // return error; }
QByteArray SnapSocket::createRequest(const QByteArray& method, const QByteArray& path, const QJsonObject& content) const { QByteArray ret; if (method == "GET") { QUrlQuery uq; for(auto it = content.constBegin(), itEnd = content.constEnd(); it!=itEnd; ++it) { uq.addQueryItem(it.key(), it.value().toString()); } const auto query = uq.toString().toUtf8(); ret = createRequest(method, path+'?'+query, QByteArray()); } else if(method == "POST") ret = createRequest(method, path, QJsonDocument(content).toJson()); else qWarning() << "unknown method" << method; return ret; }
static Nuria::JsonMetaObjectReader::Error parseEnumValues (const QJsonObject &obj, QMap< QByteArray, int > &map) { auto it = obj.constBegin (); auto end = obj.constEnd (); for (; it != end; ++it) { QString key = it.key (); QJsonValue jsonValue = it.value (); if (!jsonValue.isDouble ()) return Nuria::JsonMetaObjectReader::EnumValueObjectValueIsNotAnInteger; map.insert (key.toLatin1 (), jsonValue.toInt ()); } // return Nuria::JsonMetaObjectReader::NoError; }
static Nuria::JsonMetaObjectReader::Error parseTypesObject (const QJsonObject &types, Nuria::MetaObjectMap &objects) { Nuria::JsonMetaObjectReader::Error error = Nuria::JsonMetaObjectReader::NoError; auto it = types.constBegin (); auto end = types.constEnd (); for (; it != end && error == Nuria::JsonMetaObjectReader::NoError; ++it) { QString name = it.key (); QJsonValue typeValue = *it; if (!typeValue.isObject ()) return Nuria::JsonMetaObjectReader::TypeIsNotAnObject; error = parseTypeObject (name.toLatin1 (), typeValue.toObject (), objects); } // return error; }
void XSAppBuilder::compileObjectProperty(const QString &qName, const QXmlAttributes &atts, xsObject *object) { if(root.contains(qName)) { QJsonObject obj = root.value(qName).toObject(); QJsonObject::const_iterator it = obj.constBegin(); while(it != obj.constEnd()) { if(it.key() == "prototype") { it++; continue; } if(it.key() == "@inherit") { compileObjectProperty(it.value().toString().toLower(), atts, object); } else if(it.value().isObject()) { if(atts.value(it.key()).isEmpty()) { it++; continue; } QJsonObject subObj = it.value().toObject(); if(subObj.contains("type")) { xsValue property; transformValue(subObj, &property, atts.value(it.key()).remove(" "), it.key()); object->setProperty(it.key().toStdString().c_str(), &property); if(it.key() == "position") { qDebug()<<it.key().toStdString().c_str(); qDebug()<<property.type; qDebug()<<property.data.n; } } } it ++; } } }
void NetworkManager::reloadDevices() { const QJsonDocument doc = QJsonDocument::fromJson(m_networkInter->devices().toUtf8()); Q_ASSERT(doc.isObject()); const QJsonObject obj = doc.object(); NetworkDevice::NetworkTypes types = NetworkDevice::None; QSet<NetworkDevice> deviceSet; for (auto infoList(obj.constBegin()); infoList != obj.constEnd(); ++infoList) { Q_ASSERT(infoList.value().isArray()); const NetworkDevice::NetworkType deviceType = NetworkDevice::deviceType(infoList.key()); const auto list = infoList.value().toArray(); if (list.isEmpty()) continue; types |= deviceType; for (auto device : list) deviceSet.insert(NetworkDevice(deviceType, device.toObject())); } const QSet<NetworkDevice> removedDeviceList = m_deviceSet - deviceSet; for (auto dev : removedDeviceList) emit deviceRemoved(dev); for (auto dev : deviceSet) { if (m_deviceSet.contains(dev)) emit deviceChanged(dev); else emit deviceAdded(dev); } m_deviceSet = std::move(deviceSet); if (m_types == types) return; m_types = types; emit deviceTypesChanged(m_types); // qDebug() << "device type: " << m_types; }
void AddonsManager::loadUserScripts() { qDeleteAll(m_userScripts.values()); m_userScripts.clear(); QHash<QString, bool> enabledScripts; QFile file(SessionsManager::getWritableDataPath(QLatin1String("scripts/scripts.json"))); if (file.open(QIODevice::ReadOnly)) { const QJsonObject settings(QJsonDocument::fromJson(file.readAll()).object()); QJsonObject::const_iterator iterator; for (iterator = settings.constBegin(); iterator != settings.constEnd(); ++iterator) { enabledScripts[iterator.key()] = iterator.value().toObject().value(QLatin1String("isEnabled")).toBool(false); } file.close(); } const QList<QFileInfo> scripts(QDir(SessionsManager::getWritableDataPath(QLatin1String("scripts"))).entryInfoList(QDir::Dirs | QDir::NoDotAndDotDot)); for (int i = 0; i < scripts.count(); ++i) { const QString path(QDir(scripts.at(i).absoluteFilePath()).filePath(scripts.at(i).fileName() + QLatin1String(".js"))); if (QFile::exists(path)) { UserScript *script(new UserScript(path, m_instance)); script->setEnabled(enabledScripts.value(scripts.at(i).fileName(), false)); m_userScripts[scripts.at(i).fileName()] = script; } else { Console::addMessage(QCoreApplication::translate("main", "Failed to find User Script file: %1").arg(path), Console::OtherCategory, Console::WarningLevel); } } m_areUserScripsInitialized = true; }
void NetworkManager::reloadActiveConnections() { const QJsonDocument doc = QJsonDocument::fromJson(m_networkInter->activeConnections().toUtf8()); Q_ASSERT(doc.isObject()); const QJsonObject obj = doc.object(); NetworkDevice::NetworkTypes states = NetworkDevice::None; QSet<QUuid> activeConnList; for (auto info(obj.constBegin()); info != obj.constEnd(); ++info) { Q_ASSERT(info.value().isObject()); const QJsonObject infoObj = info.value().toObject(); const QUuid uuid = infoObj.value("Uuid").toString(); // if uuid not in device list, its a wireless connection const bool isWireless = std::find(m_deviceSet.cbegin(), m_deviceSet.cend(), uuid) == m_deviceSet.cend(); if (isWireless) states |= NetworkDevice::Wireless; else states |= NetworkDevice::Wired; activeConnList.insert(uuid); } const QSet<QUuid> removedConnList = m_activeConnSet - activeConnList; m_activeConnSet = std::move(activeConnList); for (auto uuid : removedConnList) emit activeConnectionChanged(uuid); for (auto uuid : m_activeConnSet) emit activeConnectionChanged(uuid); if (m_states == states) return; m_states = states; emit networkStateChanged(m_states); // qDebug() << "network states: " << m_states; }
QJsonObject DomainServerNodeData::overrideValuesIfNeeded(const QJsonObject& newStats) { QJsonObject result; for (auto it = newStats.constBegin(); it != newStats.constEnd(); ++it) { const auto& key = it.key(); const auto& value = it.value(); auto overrideIt = value.isString() ? _overrideHash.find({key, value.toString()}) : _overrideHash.end(); if (overrideIt != _overrideHash.end()) { // We have a match, override the value result[key] = *overrideIt; } else if (value.isObject()) { result[key] = overrideValuesIfNeeded(value.toObject()); } else if (value.isArray()) { result[key] = overrideValuesIfNeeded(value.toArray()); } else { result[key] = newStats[key]; } } return result; }
//================================================================================= ModifyObjectCmd::ModifyObjectCmd(QJsonObject oldData, QJsonObject newData, ObjectItem* item, Modifications mod, QUndoCommand* parent) : QUndoCommand(parent), m_oldData(oldData), m_newData(oldData), // Set newData to oldData for the time being, update it later with the newData m_item(item), m_mod(mod) { // Overwrite the old data with the new data if available for (auto it = newData.constBegin(); it != newData.constEnd(); ++it) { if (it->isDouble()) m_newData[it.key()] = it->toDouble(); // This includes integers else if (it->isObject()) m_newData[it.key()] = it->toObject(); else if (it->isArray()) m_newData[it.key()] = it->toArray(); else if (it->isString()) m_newData[it.key()] = it->toString(); else if (it->isBool()) m_newData[it.key()] = it->toBool(); } // Set the type of modification for the data m_oldData["modifications"] = static_cast<int>(mod); m_newData["modifications"] = static_cast<int>(mod); setText(QObject::tr(qPrintable("Modify " + newData["type"].toString() + " " + newData["name"].toString()))); }
void ShellUI::reloadConfig() { m_properties.clear(); qDeleteAll(m_bindings); m_bindings.clear(); QJsonObject object; if (m_config.contains("Shell")) { object = m_config["Shell"].toObject(); } else { QJsonDocument doc = QJsonDocument::fromJson(defaultShell); object = doc.object(); } QJsonObject properties = object["properties"].toObject(); for (auto i = properties.constBegin(); i != properties.constEnd(); ++i) { setProperty(qPrintable(i.key()), i.value().toVariant()); m_properties << i.key(); } QJsonArray bindings = object["bindings"].toArray(); for (auto i = bindings.begin(); i != bindings.end(); ++i) { QJsonObject binding = (*i).toObject(); int key = binding["key"].toInt(-1); QString exec = binding["exec"].toString(); if (key < 0 || exec.isEmpty()) { qDebug() << "Cannot parse binding" << binding; continue; } Binding *b = m_client->addKeyBinding(key, 0); m_bindings << b; connect(b, &Binding::triggered, [exec]() { QProcess::startDetached(exec); }); } for (UiScreen *screen: m_screens) { loadScreen(screen); } }
AppInfo AppInfo::fromPath(const QString &path) { AppInfo info(Bundle::fromPath(path)); if (!static_cast<Bundle>(info).isValid()) { qCWarning(l) << "bundle" << path << "is not valid"; return AppInfo(); } QScopedPointer<QIODevice> appInfoJSON(info.openFile(AppInfo::INFO, QIODevice::Text)); if (!appInfoJSON) { qCWarning(l) << "cannot find app" << path << "info json"; return AppInfo(); } QJsonParseError parseError; QJsonDocument doc = QJsonDocument::fromJson(appInfoJSON->readAll(), &parseError); if (parseError.error != QJsonParseError::NoError) { qCWarning(l) << "cannot parse app" << path << "info json" << parseError.errorString(); return AppInfo(); } appInfoJSON->close(); const QJsonObject root = doc.object(); info.d->uuid = QUuid(root["uuid"].toString()); info.d->shortName = root["shortName"].toString(); info.d->longName = root["longName"].toString(); info.d->companyName = root["companyName"].toString(); info.d->versionCode = root["versionCode"].toInt(); info.d->versionLabel = root["versionLabel"].toString(); const QJsonObject watchapp = root["watchapp"].toObject(); info.d->watchface = watchapp["watchface"].toBool(); info.d->jskit = info.fileExists(AppInfo::APPJS); if (root.contains("capabilities")) { const QJsonArray capabilities = root["capabilities"].toArray(); AppInfo::Capabilities caps = 0; for (auto it = capabilities.constBegin(); it != capabilities.constEnd(); ++it) { QString cap = (*it).toString(); if (cap == "location") caps |= AppInfo::Location; if (cap == "configurable") caps |= AppInfo::Configurable; } info.d->capabilities = caps; } if (root.contains("appKeys")) { const QJsonObject appkeys = root["appKeys"].toObject(); for (auto it = appkeys.constBegin(); it != appkeys.constEnd(); ++it) { info.addAppKey(it.key(), it.value().toInt()); } } if (root.contains("resources")) { const QJsonObject resources = root["resources"].toObject(); const QJsonArray media = resources["media"].toArray(); int index = 0; for (auto it = media.constBegin(); it != media.constEnd(); ++it) { const QJsonObject res = (*it).toObject(); const QJsonValue menuIcon = res["menuIcon"]; switch (menuIcon.type()) { case QJsonValue::Bool: info.d->menuIcon = menuIcon.toBool(); info.d->menuIconResource = index; break; case QJsonValue::String: info.d->menuIcon = !menuIcon.toString().isEmpty(); info.d->menuIconResource = index; break; default: break; } index++; } } if (info.uuid().isNull() || info.shortName().isEmpty()) { qCWarning(l) << "invalid or empty uuid/name in json of" << path; return AppInfo(); } return info; }
void BSClient::replySeriesGenresFinished() { qDebug() << "BSClient::replySeriesGenresFinished()"; QByteArray byteArray = m_reply->readAll(); if(isCaptcha(byteArray)) { loadSeriesGenres(); return; } QJsonDocument document = QJsonDocument::fromJson(byteArray); if(!document.isObject()) { Q_EMIT error(tr("JSON-Parse-Fehler: 0x0007")); return; } QHash<QString, QList<QPair<int, QString> > > seriesCategories; QJsonObject object = document.object(); for(QJsonObject::const_iterator iter = object.constBegin(); iter != object.constEnd(); iter++) { if(!iter.value().isObject()) { qDebug() << iter.value(); Q_EMIT error(tr("JSON-Parse-Fehler: 0x0008")); return; } QJsonObject object_ = iter.value().toObject(); if(!object_.contains("series")) { Q_EMIT error(tr("JSON-Parse-Fehler: 0x0009")); return; } QJsonValue value = object_.value("series"); if(!value.isArray()) { Q_EMIT error(tr("JSON-Parse-Fehler: 0x000A")); return; } QList<QPair<int, QString> > series; QJsonArray array = iter.value().toArray(); Q_FOREACH(const QJsonValue &value_, value.toArray()) { if(!value_.isObject()) { Q_EMIT error(tr("JSON-Parse-Fehler: 0x000B")); return; } QJsonObject object__ = value_.toObject(); if(!object__.contains("name")) { Q_EMIT error(tr("JSON-Parse-Fehler: 0x000C")); return; } QJsonValue idValue = object__.value("id"); if(!idValue.isDouble()) { Q_EMIT error(tr("JSON-Parse-Fehler: 0x000D")); return; } QJsonValue nameValue = object__.value("name"); if(!nameValue.isString()) { Q_EMIT error(tr("JSON-Parse-Fehler: 0x000E")); return; } series << qMakePair(idValue.toInt(), nameValue.toString()); } seriesCategories.insert(iter.key(), series); } Q_EMIT loadSeriesGenresFinished(seriesCategories); }
void WidgetIOProperties::createIOProperties() { ui->mainLayout->setColumnMinimumWidth(0, 150); ui->optionLayout->setColumnMinimumWidth(0, 150); QString lang = Utils::GetLocale(); QString rsc = QString(":/doc/%1/io_doc.json").arg(lang); QFile f(rsc); if (!f.open(QIODevice::ReadOnly | QIODevice::Text)) { QMessageBox::warning(this, tr("Error"), tr("Failed to load IO documentation from %1").arg(rsc)); return; } QJsonParseError jerr; QJsonDocument jdoc = QJsonDocument::fromJson(f.readAll(), &jerr); if (jerr.error != QJsonParseError::NoError || !jdoc.isObject()) { QMessageBox::warning(this, tr("Error"), tr("Failed to parse JSON IO documentation from %1").arg(rsc)); return; } QString iotype = QString::fromUtf8(params["type"].c_str()); QJsonObject jobj = jdoc.object(); for (auto it = jobj.begin();it != jobj.end();it++) jobj.insert(it.key().toLower(), it.value()); QJsonObject jobjAlias; if (!jobj.contains(iotype)) { //Search in aliases bool aliasfound = false; for (auto it = jobj.constBegin();it != jobj.constEnd();it++) { QJsonObject o = it.value().toObject(); QJsonArray jalias = o["alias"].toArray(); for (int i = 0;i < jalias.size();i++) { if (jalias.at(i).toString() == iotype) { aliasfound = true; jobjAlias = o; } } } if (!aliasfound) { QMessageBox::warning(this, tr("Error"), tr("IO type %1 is not found in %2").arg(iotype).arg(rsc)); return; } } QJsonObject jioobj; if (jobjAlias.isEmpty()) jioobj = jobj[iotype].toObject(); else jioobj = jobjAlias; ui->labelTitle->setText(iotype); ui->labelDesc->setText(jioobj["description"].toString()); int rowMain = 0, rowOption = 0; QJsonArray jparams = jioobj["parameters"].toArray(); for (int i = 0;i < jparams.size();i++) { QJsonObject jparam = jparams[i].toObject(); QGridLayout *layout = jparam["mandatory"].toString() == "true"?ui->mainLayout:ui->optionLayout; int row = jparam["mandatory"].toBool()?rowMain:rowOption; QLabel *title = new QLabel(jparam["name"].toString()); layout->addWidget(title, row, 0); QPushButton *revert = new QPushButton(); revert->setIcon(QIcon(":/img/document-revert.png")); revert->setToolTip(tr("Revert modification")); layout->addWidget(revert, row, 1); hider.hide(revert); QString pvalue; string prop = jparam["name"].toString().toUtf8().constData(); if (params.Exists(prop)) pvalue = QString::fromUtf8(params[prop].c_str()); else pvalue = jparam["default"].toString(); if (jparam["type"].toString() == "string") { QLineEdit *w = new QLineEdit(); w->setEnabled(jparam["readonly"].toString() != "true" && editable); w->setText(pvalue); layout->addWidget(w, row, 2); UiObject uiObject; uiObject.type = UiObjectType::LineEdit; uiObject.lineEdit = w; uiObjectMap[prop] = uiObject; connect(w, &QLineEdit::textChanged, [=]() { updateChangedParam(prop, w->text(), pvalue, title, revert); }); connect(revert, &QPushButton::clicked, [=]() { w->setText(pvalue); }); } else if (jparam["type"].toString() == "bool") { QCheckBox *w = new QCheckBox(); w->setEnabled(jparam["readonly"].toString() != "true" && editable); w->setChecked(pvalue == "true"); layout->addWidget(w, row, 2); UiObject uiObject; uiObject.type = UiObjectType::CheckBox; uiObject.checkBox = w; uiObjectMap[prop] = uiObject; connect(w, &QCheckBox::stateChanged, [=]() { updateChangedParam(prop, w->isChecked()?"true":"false", pvalue, title, revert); }); connect(revert, &QPushButton::clicked, [=]() { w->setChecked(pvalue == "true"); }); } else if (jparam["type"].toString() == "int") { QSpinBox *w = new QSpinBox(); w->setEnabled(jparam["readonly"].toString() != "true" && editable); if (!jparam["min"].toString().isEmpty()) w->setMinimum(jparam["min"].toString().toInt()); else w->setMinimum(-999999999); if (!jparam["max"].toString().isEmpty()) w->setMaximum(jparam["max"].toString().toInt()); else w->setMaximum(999999999); w->setValue(pvalue.toInt()); layout->addWidget(w, row, 2); UiObject uiObject; uiObject.type = UiObjectType::SpinBox; uiObject.spinBox = w; uiObjectMap[prop] = uiObject; connect(w, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged), [=]() { updateChangedParam(prop, QString("%1").arg(w->value()), pvalue.isEmpty()?"0":pvalue, title, revert); }); connect(revert, &QPushButton::clicked, [=]() { w->setValue(pvalue.toInt()); }); } else if (jparam["type"].toString() == "float") { QDoubleSpinBox *w = new QDoubleSpinBox(); w->setEnabled(jparam["readonly"].toString() != "true" && editable); if (!jparam["min"].toString().isEmpty()) w->setMinimum(jparam["min"].toString().toDouble()); else w->setMinimum(-999999999.0); if (!jparam["max"].toString().isEmpty()) w->setMaximum(jparam["max"].toString().toDouble()); else w->setMaximum(999999999.0); w->setValue(pvalue.toDouble()); layout->addWidget(w, row, 2); w->setDecimals(3); UiObject uiObject; uiObject.type = UiObjectType::DoubleSpinBox; uiObject.doubleSpinBox = w; uiObjectMap[prop] = uiObject; connect(w, static_cast<void (QDoubleSpinBox::*)(double)>(&QDoubleSpinBox::valueChanged), [=]() { updateChangedParam(prop, QString("%1").arg(w->value()), pvalue.isEmpty()?"0":pvalue, title, revert); }); connect(revert, &QPushButton::clicked, [=]() { w->setValue(pvalue.toDouble()); }); } else if (jparam["type"].toString() == "list") { QComboBox *w = new QComboBox(); int defIndex = 0; w->setEnabled(jparam["readonly"].toString() != "true" && editable); //fill combobox with values, if no value, set editable to true QJsonObject jvalues = jparam["list_value"].toObject(); if (jvalues.empty()) w->setEditable(true); else { w->setEditable(false); for (auto it = jvalues.begin();it != jvalues.end();it++) { w->addItem(it.value().toString(), it.key()); if (it.key() == pvalue) { defIndex = w->count() - 1; w->setCurrentIndex(defIndex); } } } layout->addWidget(w, row, 2); UiObject uiObject; uiObject.type = UiObjectType::ComboBox; uiObject.comboBox = w; uiObjectMap[prop] = uiObject; if (w->isEditable()) { connect(w, &QComboBox::currentTextChanged, [=]() { updateChangedParam(prop, w->currentText(), pvalue, title, revert); }); } else { connect(w, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), [=]() { updateChangedParam(prop, w->currentData().toString(), pvalue, title, revert); }); } connect(revert, &QPushButton::clicked, [=]() { if (w->isEditable()) w->setEditText(pvalue); else w->setCurrentIndex(defIndex); }); } QPushButton *help = new QPushButton(); help->setIcon(QIcon(":/img/icon_unkown.png")); help->setFlat(true); layout->addWidget(help, row, 3); if((i==0)&&(entryHelper != nullptr)) { QPushButton *entryHelperButton = new QPushButton(); entryHelperButton->setIcon(QIcon(":/img/icon_entry_helper.png")); entryHelperButton->setFlat(true); layout->addWidget(entryHelperButton, row, 4); connect(entryHelperButton, &QPushButton::clicked, [=]() { if (entryHelper->exec() == QDialog::Accepted) setValues(entryHelper->getParams()); }); } //avoid copy the QJsonObject in the lambda QString helpInfo = jparam["description"].toString(); connect(help, &QPushButton::clicked, [=]() { if (balloonTip) delete balloonTip; balloonTip = new BalloonTip(QPixmap(":/img/icon_unkown.png"), title->text(), helpInfo, 800, help); balloonTip->setArrowPosition(BalloonTip::TopLeft); balloonTip->move(QCursor::pos()); balloonTip->show(); }); if (jparam["mandatory"].toBool()) rowMain++; else rowOption++; } }
void XSAppBuilder::transformValue(const QJsonObject &subObj, xsValue *property, const QString &data, const QString &name) { if(subObj.value("type").toString() == "int") { property->type = XS_VALUE_INT32; property->data.n = data.toInt(); } else if(subObj.value("type").toString() == "boolean") { property->type = XS_VALUE_BOOL; if(data == "true") property->data.n = true; else property->data.n = false; } else if(subObj.value("type").toString() == "hashcode") { property->type = XS_VALUE_UINT32; property->data.n = data.toInt(); } else if(subObj.value("type").toString() == "string") { property->type = XS_VALUE_STRING; property->data.s = const_cast<char *>(data.toStdString().c_str()); } else if(subObj.value("type").toString() == "text") { property->type = XS_VALUE_TEXT; #ifdef XS_UNICODE property->data.t = const_cast<xsTChar *>(data.toStdWString().c_str()); #else property->data.s = const_cast<char *>(data.toStdString().c_str()); #endif } else if(subObj.value("type").toString() == "array")//功能可能有问题 { QString regex = subObj.value(("regex")).toString(); QString subStringType = subObj.value("stringType").toString(); bool toText = false; if(!subStringType.isEmpty() && subStringType == "text") { toText = true; } if(regex.isEmpty()) { if(toText) { property->type = XS_VALUE_TEXT; #ifdef XS_UNICODE property->data.t = const_cast<xsTChar *>(data.toStdWString().c_str()); #else property->data.s = const_cast<char *>(data.toStdString().c_str()); #endif } else { property->type = XS_VALUE_STRING; property->data.s = const_cast<char *>(data.toStdString().c_str()); } return; } xsArray *ar = xsArrayCreate(2); property->type = XS_VALUE_ARRAY; property->data.array = ar; if(regex.length() == 0) { xsValue str; str.type = XS_VALUE_STRING; str.data.s = const_cast<char *>(data.toStdString().c_str()); xsArrayAdd(ar, &str); } else { QStringList strs = data.split(regex); for(int i = 0; i < strs.size(); i++) { if(toText) { xsValue str; str.type = XS_VALUE_TEXT; #ifdef XS_UNICODE str.data.t = const_cast<xsTChar *>(strs.at(i).toStdWString().c_str()); #else str.data.s = const_cast<char *>(strs.at(i).toStdString().c_str()); #endif } else { xsValue str; str.type = XS_VALUE_STRING; str.data.s = const_cast<char *>(strs.at(i).toStdString().c_str()); xsArrayAdd(ar, &str); } } } } else if(subObj.value("type").toString() == "enum") { property->type = XS_VALUE_INT32; QJsonObject enumObj = subObj.value("enum").toObject(); property->data.n = enumObj.value(data).toInt(); } else if(subObj.value("type").toString() == "combine") { property->type = XS_VALUE_UINT32; property->data.n = 0; QJsonObject enumObj = subObj.value("enum").toObject(); QJsonObject::const_iterator enumIt = enumObj.constBegin(); while(enumIt != enumObj.constEnd()) { if(data.contains(enumIt.key())) { property->data.n |= enumIt.value().toInt(); } enumIt++; } } else if(subObj.value("type").toString() == "object") { property->type = XS_VALUE_OBJECT; xsObject *proObject = static_cast<xsObject *>(xsObject::createInstance()); property->data.obj = proObject; QString realProName = name; QStringList list = data.split(";", QString::SkipEmptyParts); for(int i = 0; i < list.size(); i++) { if(list.at(i).contains("prototype")) { QStringList dataList = list.at(i).split(":",QString::SkipEmptyParts); realProName = dataList.at(1); } } xsValue prototype; prototype.type = XS_VALUE_STRING; prototype.data.s = const_cast<char *>(realProName.toStdString().c_str()); proObject->setProperty("prototype", &prototype); createPropertyObject(realProName, data, proObject); } else if(subObj.value("type").toString() == "any") { property->type = XS_VALUE_UNDEFINE; property->data.ptr = const_cast<char *>(data.toStdString().c_str()); } }
void YouGetBridge::onFinished() { QJsonParseError json_error; QJsonObject obj = QJsonDocument::fromJson(process->readAllStandardOutput(), &json_error).object(); if (json_error.error == QJsonParseError::NoError) { if (obj.contains("streams")) { QString title = obj["title"].toString(); QJsonObject streams = obj["streams"].toObject(); QJsonObject::const_iterator i; for (i = streams.constBegin(); i != streams.constEnd(); i++) { QJsonObject item = i.value().toObject(); if (item.contains("src")) { QString container = item["container"].toString(); QJsonArray json_urls = item["src"].toArray(); QStringList names, urls; // Make file list for (int i = 0; i < json_urls.size(); i++) { names << QString("%1_%2.%3").arg(title, QString::number(i), container); urls << json_urls[i].toString(); } // Download if (download) { // Build file path list QDir dir = QDir(Settings::downloadDir); QString dirname = title + '.' + container; if (urls.size() > 1) { if (!dir.cd(dirname)) { dir.mkdir(dirname); dir.cd(dirname); } } for (int i = 0; i < names.size(); i++) names[i] = dir.filePath(names[i]); // Download more than 1 video clips with danmaku if (!danmaku.isEmpty() && urls.size() > 1) new DanmakuDelayGetter(names, urls, danmaku, true); // Download without danmaku or only 1 clip with danmaku else { for (int i = 0; i < urls.size(); i++) downloader->addTask(urls[i].toUtf8(), names[i], urls.size() > 1, danmaku.toUtf8()); } QMessageBox::information(NULL, "Message", tr("Add download task successfully!")); } // Play else { // Play more than 1 clips with danmaku if (!danmaku.isEmpty() && urls.size() > 1) new DanmakuDelayGetter(names, urls, danmaku, false); // Play clips without danmaku or only 1 clip with danmaku else { playlist->addFileAndPlay(names[0], urls[0], danmaku); for (int i = 1; i < urls.size(); i++) playlist->addFile(names[i], urls[i]); } if (Settings::autoCloseWindow) webvideo->close(); } return; } } } } QMessageBox::warning(NULL, "Error", " Parse failed!\n" + QString::fromUtf8(process->readAllStandardError())); }