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()));
}
