static
QJsonValue readLocalValue(const QJsonObject &json, const QString &key)
{
// start with language_country
const QString localeName = QLocale().name();
QString localKey = key + QLatin1Char('[') + localeName + QLatin1Char(']');
QJsonObject::ConstIterator it = json.constFind(localKey);
if (it != json.constEnd()) {
return it.value();
}
// drop _country
const int separatorIndex = localeName.indexOf(QLatin1Char('_'));
if (separatorIndex != -1) {
const int localKeySeparatorIndex = key.length() + 1 + separatorIndex;
localKey[localKeySeparatorIndex] = QLatin1Char(']');
localKey.truncate(localKeySeparatorIndex + 1);
it = json.constFind(localKey);
if (it != json.constEnd()) {
return it.value();
}
}
// default to unlocalized value
return json.value(key);
}
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);
}
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);
}
}
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 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"
}
void XSAppBuilder::cmopileJsonObject(const QJsonObject &obj)
{
QJsonObject::const_iterator it = obj.constBegin();
while(it != obj.constEnd())
{
if(root.contains(it.key()))
{
//暂时不需要json
}
it++;
}
}
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;
}
void NetWork::dealLogIn(QNetworkReply *reply)
{
QJsonObject obj = getObject(*reply);
if (obj.isEmpty())
return;
int code = obj.find("code").value().toInt();
if (code != 200)
{
emit logInStatus(code, "");
return;
}
QJsonObject::const_iterator it = obj.find("profile");
if (it != obj.constEnd())
{
QJsonObject profileObj = it.value().toObject();
m_userId = profileObj.find("userId").value().toInt();
m_nickName = profileObj.find("nickname").value().toString();
// 头像....
logInStatus(code, m_nickName);
}
}
//=================================================================================
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);
}
}
void NetWork::dealGetMusicList(QNetworkReply *reply)
{
QJsonObject obj = getObject(*reply);
if (obj.isEmpty())
return;
QStringList list;
QVector<int> vector;
// 获取歌单...
QJsonObject::const_iterator it = obj.find("playlist");
if (it != obj.constEnd())
{
QJsonArray array = it.value().toArray();
for (int j = 0; j < array.count(); j++)
{
QJsonObject mObj = array.at(j).toObject();
QString name = mObj.find("name").value().toString();
int id = mObj.find("id").value().toInt();
list.append(name);
vector.append(id);
}
}
emit musicList(list, vector);
}
void PluginSettingsView::handleAddon(const QJsonObject& obj)
{
m_addonsToRetrieve--;
if(m_addonsToRetrieve == 0)
{
m_progress->setHidden(true);
}
using Funmap = std::map<QString, std::function<void(QJsonValue)>>;
RemoteAddon add;
QString smallImage, largeImage; // thank you, Microsh**, for #define small char
const Funmap funmap
{
{ "name", [&] (QJsonValue v) { add.name = v.toString(); } },
{ "version", [&] (QJsonValue v) { add.version = v.toString(); } },
{ "url", [&] (QJsonValue v) { add.latestVersionAddress = v.toString(); } },
{ "short", [&] (QJsonValue v) { add.shortDescription = v.toString(); } },
{ "long", [&] (QJsonValue v) { add.longDescription = v.toString(); } },
{ "small", [&] (QJsonValue v) { smallImage = v.toString(); } },
{ "large", [&] (QJsonValue v) { largeImage = v.toString(); } },
{ "key", [&] (QJsonValue v) { add.key = UuidKey<iscore::Addon>(v.toString().toLatin1().constData()); } }
};
// Add metadata keys
for(const auto& k : obj.keys())
{
auto it = funmap.find(k);
if(it != funmap.end())
{
it->second(obj[k]);
}
}
if(add.key.impl().is_nil() || add.name.isEmpty())
{
return;
}
// Add architecture keys
add.architectures = addonArchitectures();
for(auto& k : add.architectures)
{
auto it = obj.constFind(k.first);
if(it != obj.constEnd())
{
k.second = (*it).toString();
}
}
// Load images
RemotePluginItemModel* model = static_cast<RemotePluginItemModel*>(m_remoteAddons->model());
if(!smallImage.isEmpty())
{
// c.f. https://wiki.qt.io/Download_Data_from_URL
auto dl = new iscore::FileDownloader{QUrl{smallImage}};
connect(dl, &iscore::FileDownloader::downloaded,
this, [=] (QByteArray arr) {
model->updateAddon(add.key, [=] (RemoteAddon& add) {
add.smallImage.loadFromData(arr);
});
dl->deleteLater();
});
}
if(!largeImage.isEmpty())
{
// c.f. https://wiki.qt.io/Download_Data_from_URL
auto dl = new iscore::FileDownloader{QUrl{largeImage}};
connect(dl, &iscore::FileDownloader::downloaded,
this, [=] (QByteArray arr) {
model->updateAddon(add.key, [=] (RemoteAddon& add) {
add.largeImage.loadFromData(arr);
});
dl->deleteLater();
});
}
model->addAddon(std::move(add));
}
static std::shared_ptr<AndroidStyle> loadAndroidStyle(QPalette *defaultPalette)
{
std::shared_ptr<AndroidStyle> style(new AndroidStyle);
style->m_styleData = AndroidStyle::loadStyleData();
if (style->m_styleData.isEmpty())
return std::shared_ptr<AndroidStyle>();
for (QJsonObject::const_iterator objectIterator = style->m_styleData.constBegin();
objectIterator != style->m_styleData.constEnd();
++objectIterator) {
QString key = objectIterator.key();
QJsonValue value = objectIterator.value();
if (!value.isObject()) {
qWarning("Style.json structure is unrecognized.");
continue;
}
QJsonObject item = value.toObject();
QJsonObject::const_iterator attributeIterator = item.find(QLatin1String("qtClass"));
QByteArray qtClassName;
if (attributeIterator != item.constEnd()) {
// The item has palette and font information for a specific Qt Class (e.g. QWidget, QPushButton, etc.)
qtClassName = attributeIterator.value().toString().toLatin1();
}
const int ft = fontType(key);
if (ft > -1 || !qtClassName.isEmpty()) {
// Extract font information
QFont font;
// Font size (in pixels)
attributeIterator = item.find(QLatin1String("TextAppearance_textSize"));
if (attributeIterator != item.constEnd())
font.setPixelSize(int(attributeIterator.value().toDouble()));
// Font style
attributeIterator = item.find(QLatin1String("TextAppearance_textStyle"));
if (attributeIterator != item.constEnd()) {
const int style = int(attributeIterator.value().toDouble());
font.setBold(style & textStyle_bold);
font.setItalic(style & textStyle_italic);
}
// Font typeface
attributeIterator = item.find(QLatin1String("TextAppearance_typeface"));
if (attributeIterator != item.constEnd()) {
QFont::StyleHint styleHint = QFont::AnyStyle;
switch (int(attributeIterator.value().toDouble())) {
case typeface_sans:
styleHint = QFont::SansSerif;
break;
case typeface_serif:
styleHint = QFont::Serif;
break;
case typeface_monospace:
styleHint = QFont::Monospace;
break;
}
font.setStyleHint(styleHint, QFont::PreferMatch);
}
if (!qtClassName.isEmpty())
style->m_QWidgetsFonts.insert(qtClassName, font);
if (ft > -1) {
style->m_fonts.insert(ft, font);
if (ft == QPlatformTheme::SystemFont)
QGuiApplication::setFont(font);
}
// Extract font information
}
const int pt = paletteType(key);
if (pt > -1 || !qtClassName.isEmpty()) {
// Extract palette information
QPalette palette = *defaultPalette;
attributeIterator = item.find(QLatin1String("defaultTextColorPrimary"));
if (attributeIterator != item.constEnd())
palette.setColor(QPalette::WindowText, QRgb(int(attributeIterator.value().toDouble())));
attributeIterator = item.find(QLatin1String("defaultBackgroundColor"));
if (attributeIterator != item.constEnd())
palette.setColor(QPalette::Background, QRgb(int(attributeIterator.value().toDouble())));
attributeIterator = item.find(QLatin1String("TextAppearance_textColor"));
if (attributeIterator != item.constEnd())
setPaletteColor(attributeIterator.value().toObject().toVariantMap(), palette, QPalette::WindowText);
attributeIterator = item.find(QLatin1String("TextAppearance_textColorLink"));
if (attributeIterator != item.constEnd())
setPaletteColor(attributeIterator.value().toObject().toVariantMap(), palette, QPalette::Link);
attributeIterator = item.find(QLatin1String("TextAppearance_textColorHighlight"));
if (attributeIterator != item.constEnd())
palette.setColor(QPalette::Highlight, QRgb(int(attributeIterator.value().toDouble())));
if (pt == QPlatformTheme::SystemPalette)
*defaultPalette = style->m_standardPalette = palette;
if (pt > -1)
style->m_palettes.insert(pt, palette);
// Extract palette information
}
}
return style;
}
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()));
}
