bool configreader::deserialize(const QString &acsfilename) { QFile file(acsfilename); if (file.open(QIODevice::ReadOnly|QIODevice::Text) == false) return false; QTextStream in(&file); QString str; while (!in.atEnd()) { str += in.readLine(); } QTextCodec *codec = QTextCodec::codecForName("UTF-8"); QByteArray doc = codec->fromUnicode(str); QJsonParseError jerror; QJsonDocument jDocument = QJsonDocument::fromJson(doc, &jerror); if (jerror.error != QJsonParseError::NoError) return false; QJsonObject jRoot = jDocument.object(); if (jRoot["exams"] == QJsonValue::Undefined) return false; QJsonArray examarray = jRoot["exams"].toArray(); QJsonObject examobj; for (int i = 0; i < examarray.size(); ++i) { exam currexam; examobj = examarray[i].toObject(); if (examobj["title"] == QJsonValue::Undefined) return false; currexam.title = examobj["title"].toString(); if (examobj["points"] == QJsonValue::Undefined) return false; QJsonArray pointsarray = examobj["points"].toArray(); QJsonObject pointobj; for (int j = 0; j < pointsarray.size(); ++j) { currexam.point.push_back(pointsarray[j].toInt()); } _cexam.push_back(currexam); } return true; }
void ContactDetails::loadDetailsFromDocument() { if(!document->array().at(rowIndex).isObject()) { //qDebug() << "error! Item at rowIndex" << m_rowIndex << "is not an object!"; return; } QJsonObject object = document->array().at(rowIndex).toObject(); ui->nameLbl->setText(object.value("name").toString()); ui->nameLineEdit->setText(object.value("name").toString()); contactDetailList.clear(); while(QLayoutItem* item = ui->detailGroupLayout->takeAt(0)) { delete item->widget(); delete item; } if(object.contains("detailGroups")) { QJsonArray array = object.value("detailGroups").toArray(); QJsonArray::const_iterator begin = array.constBegin(); while(begin != array.end()) { on_addGroupBtn_clicked(); contactDetailList.last()->setJsonObject((*begin).toObject()); begin++; } } }
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 GeocodeDataManager::replyFinished(QNetworkReply* reply) { QByteArray json = reply->readAll(); qDebug() << "Reply = " << json; qDebug() << "URL = " << reply->url(); QString strUrl = reply->url().toString(); // json is a QString containing the data to convert QJsonDocument doc = QJsonDocument::fromJson(json); if( doc.isEmpty() ) { emit errorOccured(QString("Cannot convert to QJson object: %1").arg(QString(json))); return; } QJsonObject root = doc.object(); int code = root["Status"].toObject()["code"].toInt(); if(code != 200) { emit errorOccured(QString("Code of request is: %1").arg(code)); return; } QJsonArray placeMarks = root["Placemark"].toArray(); if(placeMarks.count() == 0) { emit errorOccured(QString("Cannot find any locations")); return; } double east = placeMarks[0].toObject()["Point"].toObject()["coordinates"].toArray()[0].toDouble(); double north = placeMarks[0].toObject()["Point"].toObject()["coordinates"].toArray()[1].toDouble(); emit coordinatesReady(east, north); }
QMap<QString, TLType> GeneratorNG::readTypes(const QJsonDocument &document) { const QJsonArray constructors = document.object().value("constructors").toArray(); QMap<QString, TLType> types; for (int i = 0; i < constructors.count(); ++i) { const QJsonObject obj = constructors.at(i).toObject(); const QString predicateName = formatName1stCapital(obj.value("predicate").toString()); const quint32 predicateId = obj.value("id").toString().toInt(); const QString typeName = formatType(obj.value("type").toString()); TLType tlType = types.value(typeName); tlType.name = typeName; TLSubType tlSubType; tlSubType.name = predicateName; tlSubType.id = predicateId; const QJsonArray params = obj.value("params").toArray(); foreach (const QJsonValue ¶mValue, params) { const QJsonObject ¶mObj = paramValue.toObject(); const QString paramName = formatMember(paramObj.value("name").toString()); const QString paramType = paramObj.value("type").toString(); tlSubType.members.append(TLParam(paramName, formatType(paramType))); } tlType.subTypes.append(tlSubType); types.insert(typeName, tlType); } return types; }
void Config::loadLayouts() { QFile layoutsFile(resourcesPath() + "/layouts.ltf"); if( layoutsFile.open(QIODevice::ReadOnly) ) { QJsonDocument jsonDoc = QJsonDocument::fromJson(layoutsFile.readAll()); QJsonArray jsonArray = jsonDoc.array(); for( int i = 0; i < jsonArray.count(); i++ ) { Layout *layout = new Layout; layout->name = jsonArray.at(i).toObject().value("layout").toString(); layout->title = jsonArray.at(i).toObject().value("title").toString(); layout->symbols = jsonArray.at(i).toObject().value("symbols").toString(); m_layouts.append(layout); if( layout->name == m_lastLayout ) { m_currentLayout = layout; } } if( m_layouts.count() < 1 ) { qDebug()<<"No layouts loaded!"; exit(EXIT_FAILURE); } if( !m_currentLayout ) { m_currentLayout = m_layouts.at(0); } loadLessons(); loadGeneratedLessons(); } else { qDebug()<<"Can't open layouts file!"; exit(EXIT_FAILURE); } }
void Serializable::Message::read (const QJsonObject &json) { timestamp = json["timestamp" ].toInt ( ); authorSha1 = json["authorSha1"].toString ( ); isRead = json["isRead" ].toBool ( ); direction = static_cast<Media::Media::Direction> ( json["direction"].toInt() ); type = static_cast<Serializable::Message::Type>( json["type" ].toInt() ); id = json["id" ].toVariant().value<uint64_t>( ); deliveryStatus = static_cast<Media::TextRecording::Status>(json["deliveryStatus"].toInt()); QJsonArray a = json["payloads"].toArray(); for (int i = 0; i < a.size(); ++i) { QJsonObject o = a[i].toObject(); Payload* p = new Payload(); p->read(o); payloads << p; if (p->mimeType == "text/plain") { m_PlainText = p->payload; m_HasText = true; } else if (p->mimeType == "text/html") { m_HTML = p->payload; m_HasText = true; } } //Load older conversation from a time when only 1 mime/payload pair was supported if (!json["payload" ].toString().isEmpty()) { Payload* p = new Payload(); p->payload = json["payload" ].toString(); p->mimeType = json["mimeType" ].toString(); payloads << p; m_PlainText = p->payload; m_HasText = true; } }
QVariant SQLExtDatabase::executeSql(const QString &q) const { QSqlDatabase db = QSqlDatabase::database(m_connectionName); QSqlQuery query = db.exec(q); bool error = query.lastError().type() != QSqlError::NoError; QJsonObject res; res.insert("error", error); if (error) { res.insert("errorStr", query.lastError().text()); return res; } if (query.isSelect()) { QJsonArray rows; int size = 0; int fields = query.record().count(); while (query.next()) { QJsonObject value; for (int i = 0; i < fields; ++i) value.insert(query.record().fieldName(i), query.value(i).toString()); rows.append(value); ++size; } res.insert("length", size); res.insert("items", rows); return res; } res.insert("rowsAffected", query.numRowsAffected()); res.insert("insertId", query.lastInsertId().toString()); return res; }
/*! * \brief JsonParser::addObject * Dodaje obiekt do pliku json * \param type typ obiektu * \param speed prędkość obiektu * \param model model tabeli ze wskazanymi punktami */ void JsonParser::addObject(QString type, double speed, QStandardItemModel *model) { QJsonValue type_ = type; QJsonObject object; object.insert("TypeObject", type_); object.insert("Speed", speed); QJsonArray array; QJsonObject point; QJsonValue value; for (int i = 0; i <model->rowCount(); i++) { value = model->takeItem(i,0)->data(Qt::DisplayRole).toDouble(); point.insert("CoordX", value); value = model->takeItem(i,1)->data(Qt::DisplayRole).toDouble(); point.insert("CoordY", value); array.insert(i,point); } value = array; object.insert("Points", value); objects.push_back(object); QJsonDocument d; QJsonObject obj; obj.insert("Objects", static_cast<QJsonValue>(objects)); d.setObject(obj); d.toJson(); QFile file; file.setFileName(fileName); file.open(QIODevice::WriteOnly | QIODevice::Text); file.write(d.toJson()); file.close(); }
void JSONExporter::Export(ResourceController *resources, QString filename) { //get the data QList<Image*> images = resources->GetAllImages(); QList<TileLayer*> layers = resources->GetAllLayers(); LevelProperties *levelProps = resources->GetLevelProperties(); //set up the JSON document QJsonObject documentObject; QJsonArray imageArray; QJsonArray layerArray; QJsonObject levelPropsObject; levelPropsObject["properties"] = ResourcePropertiesToJSON(levelProps); levelPropsObject["Tileset ID"] = levelProps->GetTilesetID(); Image *currentImage; foreach(currentImage, images) { QJsonObject imageObject; imageObject["properties"] = ResourcePropertiesToJSON(currentImage); imageArray.append(imageObject); }
/** * @brief ClassMethod::toJson * @return */ QJsonObject ClassMethod::toJson() const { QJsonObject result = BasicElement::toJson(); result.insert(sectionMark, m_Section); result.insert(typeMark, m_Type); result.insert(csMark, m_ConstStatus); result.insert(slotMark, m_SlotStatus); result.insert(signalMark, m_SignalStatus); result.insert(rtMark, m_ReturnTypeId.toJson()); result.insert(rhsiMark, int(m_RhsIdentificator)); QJsonArray parameters; for (auto &&value : m_Parameters) parameters.append(value->toJson()); result.insert(paramsMark, parameters); QJsonArray lhsIdentificators; for (auto &&id : m_LhsIdentificators) lhsIdentificators.append(int(id)); result.insert(lhsMark, lhsIdentificators); return result; }
void QEGLPlatformCursor::initCursorAtlas() { static QByteArray json = qgetenv("QT_QPA_EGLFS_CURSOR"); if (json.isEmpty()) json = ":/cursor.json"; QFile file(QString::fromUtf8(json)); if (!file.open(QFile::ReadOnly)) { m_visible = false; return; } QJsonDocument doc = QJsonDocument::fromJson(file.readAll()); QJsonObject object = doc.object(); QString atlas = object.value(QLatin1String("image")).toString(); Q_ASSERT(!atlas.isEmpty()); const int cursorsPerRow = object.value(QLatin1String("cursorsPerRow")).toDouble(); Q_ASSERT(cursorsPerRow); m_cursorAtlas.cursorsPerRow = cursorsPerRow; const QJsonArray hotSpots = object.value(QLatin1String("hotSpots")).toArray(); Q_ASSERT(hotSpots.count() == Qt::LastCursor + 1); for (int i = 0; i < hotSpots.count(); i++) { QPoint hotSpot(hotSpots[i].toArray()[0].toDouble(), hotSpots[i].toArray()[1].toDouble()); m_cursorAtlas.hotSpots << hotSpot; } QImage image = QImage(atlas).convertToFormat(QImage::Format_ARGB32_Premultiplied); m_cursorAtlas.cursorWidth = image.width() / m_cursorAtlas.cursorsPerRow; m_cursorAtlas.cursorHeight = image.height() / ((Qt::LastCursor + cursorsPerRow) / cursorsPerRow); m_cursorAtlas.width = image.width(); m_cursorAtlas.height = image.height(); m_cursorAtlas.image = image; }
void RemoteModel::parseDirectoryListing(const QString& json, const QVariant& userdata) { // Load new JSON root document assuming it's an array QJsonDocument doc = QJsonDocument::fromJson(json.toUtf8()); if(doc.isNull() || !doc.isArray()) return; QJsonArray array = doc.array(); // Get model index to store the new data under QModelIndex parent = userdata.toModelIndex(); RemoteModelItem* parentItem = const_cast<RemoteModelItem*>(modelIndexToItem(parent)); // An invalid model index indicates that this is a new root item. This means the old one needs to be entirely deleted first. if(!parent.isValid()) { // Clear root item beginResetModel(); delete rootItem; rootItem = new RemoteModelItem(); endResetModel(); // Set parent model index and parent item to the new values parent = QModelIndex(); parentItem = rootItem; } // Insert data beginInsertRows(parent, 0, array.size()); QList<RemoteModelItem*> items = RemoteModelItem::loadArray(QJsonValue(array), parentItem); foreach(RemoteModelItem* item, items) parentItem->appendChild(item); endInsertRows(); // Emit directory listing parsed signal emit directoryListingParsed(parent); }
QList<Note*> ServerCommunicator::fromJson(QByteArray json) { QJsonDocument document = QJsonDocument::fromJson(json); QList<Note*> notes; // handle an array of notes if(document.isArray()) { QJsonArray array = document.array(); for(int i = 0; i < array.size(); i++) { QJsonValue value = array.at(i); if(value.isObject()) { QJsonObject obj = value.toObject(); Note *note = new Note(obj.value("heading").toString(), obj.value("body").toString()); note->setRemoteId(obj.value("id").toDouble()); notes.append(note); } } } else { QJsonObject obj = document.object(); Note *note = new Note(obj.value("heading").toString(), obj.value("body").toString()); note->setRemoteId(obj.value("id").toDouble()); notes.append(note); } return notes; }
void PlayFilesModel::parseData(const QJsonArray &array) { beginResetModel(); m_playList.reserve(array.size()); for(const auto& record: array) { m_playList.push_back(PlayItem::fromJson(record.toObject())); } endResetModel(); if(!m_playList.isEmpty()) { emit mediaPlayListChanged(); } }
void PanelMenu::showMenu(int x, int y) { if (m_menuManager && m_menuManager->isValid()){ QDBusPendingReply<QDBusObjectPath> pr = m_menuManager->RegisterMenu(); if (pr.count() == 1) { QDBusObjectPath op = pr.argumentAt(0).value<QDBusObjectPath>(); m_menuInterfacePath = op.path(); DBusMenu *m_menu = new DBusMenu(m_menuInterfacePath,this); connect(m_menu,&DBusMenu::MenuUnregistered,m_menu,&DBusMenu::deleteLater); connect(m_menu,&DBusMenu::ItemInvoked,this,&PanelMenu::onItemInvoked); QJsonObject targetObj; targetObj.insert("x",QJsonValue(x)); targetObj.insert("y",QJsonValue(y)); targetObj.insert("isDockMenu",QJsonValue(false)); QJsonArray contentArry; contentArry.append(createRadioItemObj(tr("Fashion mode"),ToFashionMode,DockModeGroup,m_dockModeData->getDockMode() == Dock::FashionMode)); contentArry.append(createRadioItemObj(tr("Efficient mode"),ToEfficientMode,DockModeGroup,m_dockModeData->getDockMode() == Dock::EfficientMode)); contentArry.append(createRadioItemObj(tr("Classic mode"),ToClassicMode,DockModeGroup,m_dockModeData->getDockMode() == Dock::ClassicMode)); contentArry.append(createItemObj("",OperationType(-1))); contentArry.append(createRadioItemObj(tr("Keep showing"),ToKeepShowing,HideModeGroup,m_dockModeData->getHideMode() == Dock::KeepShowing)); contentArry.append(createRadioItemObj(tr("Keep hidden"),ToKeepHidden,HideModeGroup,m_dockModeData->getHideMode() == Dock::KeepHidden)); contentArry.append(createRadioItemObj(tr("Smart hide"),ToSmartHide,HideModeGroup,m_dockModeData->getHideMode() == Dock::SmartHide)); contentArry.append(createItemObj("",OperationType(-1))); contentArry.append(createItemObj(tr("Notification area settings"),ToPluginSetting)); QJsonObject contentObj; contentObj.insert("items",contentArry); targetObj.insert("menuJsonContent",QString(QJsonDocument(contentObj).toJson())); m_menu->ShowMenu(QString(QJsonDocument(targetObj).toJson())); } } }
void ImportDialog::setImportTypes() { switchToResourcesParentIfRequired(); QFile config("resources/config/config.json"); config.open(QFile::ReadOnly | QFile::Text); QJsonDocument document = QJsonDocument::fromJson(config.readAll()); if (!document.isNull() && !document.isEmpty()) { QString importFormatsInfo; QString importFormatsFilterList; QHash<QString, QString> iconsMap; QJsonObject configObject = document.object(); if (!configObject.isEmpty()) { QJsonArray fileFormats = configObject["importFormats"].toArray(); int formatsCounter = 0; foreach (const QJsonValue& fileFormat, fileFormats) { QJsonObject fileFormatObject = fileFormat.toObject(); QString ext(fileFormatObject["extension"].toString()); QString icon(fileFormatObject.value("icon").toString()); if (formatsCounter > 0) { importFormatsInfo.append(","); } // set ' or' on last import type text if (formatsCounter == fileFormats.count() - 1) { importFormatsInfo.append(" or"); } importFormatsFilterList.append(QString("*.%1 ").arg(ext)); importFormatsInfo.append(" .").append(ext); iconsMap[ext] = icon; formatsCounter++; }
void ConfigHelper::exportGuiConfigJson(const QString &file) { QJsonArray confArray; int size = model->rowCount(); for (int i = 0; i < size; ++i) { Connection *con = model->getItem(i)->getConnection(); QJsonObject json; json["remarks"] = QJsonValue(con->profile.name); json["method"] = QJsonValue(con->profile.method.toLower()); json["password"] = QJsonValue(con->profile.password); json["server_port"] = QJsonValue(con->profile.serverPort); json["server"] = QJsonValue(con->profile.serverAddress); confArray.append(QJsonValue(json)); } QJsonObject JSONObj; JSONObj["configs"] = QJsonValue(confArray); JSONObj["localPort"] = QJsonValue(1080); JSONObj["shareOverLan"] = QJsonValue(false); QJsonDocument JSONDoc(JSONObj); QFile JSONFile(file); JSONFile.open(QIODevice::WriteOnly | QIODevice::Text); if (!JSONFile.isOpen()) { qCritical() << "Error: cannot open " << file; return; } if(!JSONFile.isWritable()) { qCritical() << "Error: cannot write into " << file; return; } JSONFile.write(JSONDoc.toJson()); JSONFile.close(); }
void MainWindow::handleCategoryResp(QByteArray data) { if(!categorieMap.contains("Uncategorized")) { QStandardItem *uncategorized = new QStandardItem("Uncategorized"); uncategorized->setData(QVariant::fromValue(QString("user/" + userId + "/category/global.uncategorized")),CATEGORY_ENTRY_ID); treeModel->appendRow(uncategorized); categorieMap.insert("Uncategorized",uncategorized); } QJsonParseError jerror; QJsonDocument doc = QJsonDocument::fromJson(data,&jerror); qDebug()<<doc; if(jerror.error == QJsonParseError::NoError || ! doc.isEmpty()) { QJsonArray arr = doc.array(); QString tempLabel,tempId; for(int row = 0;row<arr.size();row++) { QJsonObject obj = arr[row].toObject(); tempLabel = obj.value("label").toString(); tempId = obj.value("id").toString(); qDebug()<<tempLabel; if(!categorieMap.contains(tempLabel)) { QStandardItem *category = new QStandardItem(tempLabel); category->setData(QVariant::fromValue(tempId),CATEGORY_ENTRY_ID); treeModel->appendRow(category); categorieMap.insert(tempLabel,category); } } } else { qDebug() << "error when parsing json"; } }
bool MainWindow::on_subscibe() { QJsonObject *json = new QJsonObject(); QJsonObject *j1 = new QJsonObject(); QJsonObject *j2 = new QJsonObject(); QJsonArray *jarr = new QJsonArray(); j1->insert("id",QJsonValue("user/" + userId + "/category/tech")); j1->insert("label",QJsonValue(QString("tech"))); //j2->insert("id",userIdjson); //j2->insert("label",QJsonValue(QString("weekly"))); json->insert("id",QJsonValue("feed/" + subDialog->getFeedUrl())); json->insert("title",QJsonValue(subDialog->getFeedTitle())); jarr->insert(0,*j1); //jarr->insert(1,*j2); json->insert("categories",*jarr); QJsonDocument *docu = new QJsonDocument(*json); //qDebug() << docu->toJson(); request.setUrl(SUBSCRIPTIONS_URL); request.setHeader(QNetworkRequest::ContentTypeHeader,"application/json"); o2req->post(request,docu->toJson()); reqCategories(); delete json; delete j1; delete j2; delete jarr; return true; }
void TomboyItemUploadJob::start() { // Convert note to JSON QJsonObject jsonNote; jsonNote[QLatin1String("guid")] = mSourceItem.remoteId(); switch (mJobType) { case JobType::DeleteItem: jsonNote[QLatin1String("command")] = QStringLiteral("delete"); break; case JobType::AddItem: jsonNote[QLatin1String("create-date")] = getCurrentISOTime(); // Missing break is intended case JobType::ModifyItem: jsonNote[QLatin1String("title")] = mNoteContent->headerByType("subject")->asUnicodeString(); jsonNote[QLatin1String("note-content")] = mNoteContent->mainBodyPart()->decodedText(); jsonNote[QLatin1String("note-content-version")] = QStringLiteral("1"); jsonNote[QLatin1String("last-change-date")] = getCurrentISOTime(); } // Create the full JSON object QJsonArray noteChanges; noteChanges.append(jsonNote); QJsonObject postJson; postJson[QLatin1String("note-changes")] = noteChanges; postJson[QLatin1String("latest-sync-revision")] = QString::number(++mRemoteRevision); QJsonDocument postData; postData.setObject(postJson); // Network request QNetworkRequest request = QNetworkRequest(QUrl(mContentURL)); request.setHeader(QNetworkRequest::ContentTypeHeader, QStringLiteral("application/json; boundary=7d44e178b0439")); request.setHeader(QNetworkRequest::ContentLengthHeader, postData.toJson().length()); mReply = mRequestor->put(request, QList<O0RequestParameter>(), postData.toJson()); connect(mReply, &QNetworkReply::finished, this, &TomboyItemUploadJob::onRequestFinished); qCDebug(TOMBOYNOTESRESOURCE_LOG) << "TomboyItemUploadJob: Start network request"; }
VNoteFile *VNoteFile::fromJson(VDirectory *p_directory, const QJsonObject &p_json, FileType p_type, bool p_modifiable) { // Attachments. QJsonArray attachmentJson = p_json[DirConfig::c_attachments].toArray(); QVector<VAttachment> attachments; for (int i = 0; i < attachmentJson.size(); ++i) { QJsonObject attachmentItem = attachmentJson[i].toObject(); attachments.push_back(VAttachment(attachmentItem[DirConfig::c_name].toString())); } return new VNoteFile(p_directory, p_json[DirConfig::c_name].toString(), p_type, p_modifiable, QDateTime::fromString(p_json[DirConfig::c_createdTime].toString(), Qt::ISODate), QDateTime::fromString(p_json[DirConfig::c_modifiedTime].toString(), Qt::ISODate), p_json[DirConfig::c_attachmentFolder].toString(), attachments); }
bool FileManager::open( QString path, QList<TrackModel*>* const trackModels, CategoryData* const categoryData, ImageData* const imageData ) { trackModels->clear(); QString jsonFromFile; QFile file; file.setFileName( path ); file.open( QIODevice::ReadOnly | QIODevice::Text ); jsonFromFile = file.readAll(); file.close(); // Get jsonObject out of jsonDoc QJsonDocument jsonDoc = QJsonDocument::fromJson( jsonFromFile.toUtf8() ); QJsonObject jsonObject = jsonDoc.object(); // Parse track data QJsonArray tracksArray = jsonObject.value("tracks").toArray(); for ( int i = 0; i < tracksArray.size(); i++ ) { QJsonObject trackObj = tracksArray.at(i).toObject(); TrackModel* trackModel = new TrackModel( trackObj ); trackModels->append( trackModel ); } // Parse category data if ( jsonObject.contains("categoryPath") ) { QString categoryPath = jsonObject.value("categoryPath").toString(""); FileManager::import( categoryPath, categoryData, imageData ); qDebug() << "Loaded category data from" << categoryPath; } else qDebug() << "No category data found..."; return trackModels->size() > 0; }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- ComparisonInput_t JsonFilterParametersReader::readComparisonInput(const QString name, ComparisonInput_t defaultValue, int arrayIndex) { BOOST_ASSERT(m_CurrentFilterIndex.isEmpty() == false); if (m_CurrentFilterIndex.contains(name) == false) { return defaultValue; } if (m_CurrentFilterIndex.value(name).isArray()) { QJsonArray cInputsArray = m_CurrentFilterIndex.value(name).toArray(); if (cInputsArray.size() > arrayIndex && cInputsArray[arrayIndex].isObject()) { QJsonObject cInputObject = cInputsArray[arrayIndex].toObject(); ComparisonInput_t cInput; if (cInput.readJson(cInputObject) == true) { return cInput; } } } return defaultValue; }
SimpleTask *SimpleTaskManager::STFromJSON(QJsonObject obj, SimpleTask *father) { SimpleTask *_st; _st = new SimpleTask; if(father != NULL) { _st->_father = father; } else { _st->_manager = this; } _st->_name = obj.value("name").toString().toUtf8().constData(); _st->_description = obj.value("description").toString().toUtf8().constData(); _st->_id = obj.value("id").toString().toUInt(); _st->_done = IntToSTDoneType(obj.value("done").toString().toInt()); _st->_timeCreation = obj.value("timeCreation").toString().toULongLong(); _st->_timeDone = obj.value("timeDone").toString().toULongLong(); _st->_timeStart = obj.value("timeStart").toString().toULongLong(); _st->_timeDue = obj.value("timeDue").toString().toULongLong(); _st->_priority = obj.value("priority").toString().toInt(); _st->_level = obj.value("level").toString().toUInt(); QJsonArray subTasks = obj.value("subTasks").toArray(); for(auto i = subTasks.begin(); i != subTasks.end(); ++i) { QJsonValue subTask = *i; SimpleTask *_subTask = STFromJSON(subTask.toObject(), _st); _st->addSubTask(_subTask); } return _st; }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- QVector<double> JsonFilterParametersReader::readArray(const QString name, QVector<double> value) { BOOST_ASSERT(m_CurrentFilterIndex.isEmpty() == false); if (m_CurrentFilterIndex.contains(name) == false) { return value; } if (m_CurrentFilterIndex.value(name).isArray()) { QJsonArray jsonArray = m_CurrentFilterIndex.value(name).toArray(); QVector<double> vector; for (QJsonArray::iterator iter = jsonArray.begin(); iter != jsonArray.end(); ++iter) { if ((*iter).isDouble()) { vector.push_back((*iter).toDouble()); } } return vector; } return value; }
bool QPubNub::decrypt(const QJsonArray& messages, const QStringList& channels) { QPubNubCrypt crypt(m_cipherKey); for (int i=0,len=messages.size();i<len;++i) { int errorCode = 0; QJsonValue value(crypt.decrypt(messages[i].toString().toLocal8Bit(), errorCode)); if (errorCode != 0) { char errorString[1024+1]; ERR_error_string_n(errorCode, errorString, 1024); emit error(errorString, errorCode); } else { emit message(value, m_timeToken, channels[i]); } } return true; }
bool UserBank::load() { QJsonArray a; QJsonDocument d; bool ok = loadJsonFile("giftrecord.json", d); a = d.array(); if (!ok) { qDebug()<< " load record file failed!!"; return false; } else { qDebug()<< " load record file succeed!!"; } for (int i=0; i<a.size(); i++) { QJsonObject b = a[i].toObject(); record[b["name"].toString()] = b["money"].toInt(); } record[myTr("麻由の天蝎1000")] = 10000000; record[myTr("麻由の天蝎10000")] = 10000000; record[myTr("麻由の天蝎1000000")] = 10000000; return true; }
QJsonArray QuickModWriter::versionToJson(const QuickMod &mod) { QJsonArray array; foreach (const QuickModVersion &ver, mod.versions) { QJsonObject obj; obj.insert("name", ver.name); if (!ver.version.isNull() && ver.name != ver.version) { obj.insert("version", ver.version); } obj.insert("type", ver.type); obj.insert("mcCompat", QJsonArray::fromStringList(ver.mcCompat)); QJsonArray refs; for (auto ref : ver.references.keys()) { QJsonObject refObj; refObj.insert("uid", ref); refObj.insert("version", ver.references[ref].version); refObj.insert("type", ver.references[ref].type); if (ver.references[ref].isSoft) { refObj.insert("isSoft", true); } refs.append(refObj); } obj.insert("references", refs); if (!ver.forgeCompat.isEmpty()) { obj.insert("forgeCompat", ver.forgeCompat); } if (!ver.liteloaderCompat.isEmpty()) { obj.insert("liteloaderCompat", ver.liteloaderCompat); } obj.insert("sha1", ver.sha1); switch (ver.installType) { case QuickModVersion::ForgeMod: obj.insert("installType", QStringLiteral("forgeMod")); break; case QuickModVersion::ForgeCoreMod: obj.insert("installType", QStringLiteral("forgeCoreMod")); break; case QuickModVersion::LiteLoaderMod: obj.insert("installType", QStringLiteral("liteloaderMod")); break; case QuickModVersion::Extract: obj.insert("installType", QStringLiteral("extract")); break; case QuickModVersion::ConfigPack: obj.insert("installType", QStringLiteral("configPack")); break; case QuickModVersion::Group: obj.insert("installType", QStringLiteral("group")); break; default: obj.insert("installType", QString("forgeMod")); break; } QJsonArray urls; for (auto download : ver.urls) { urls.append(downloadToJson(download, ver.urls.size() == 1)); } obj.insert("urls", urls); array.append(obj); } return array; }
void NewWakuSettingsWindow::loadPresets() { QStringList dir = QStandardPaths::standardLocations(QStandardPaths::DataLocation); if (dir.empty()) { mwin->insLog("save directory is not available"); return; } QFile file(dir[0] + "/newWakuSettings.json"); if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) { file.close(); mwin->insLog("opening settings file failed"); return; } QJsonDocument jsd = QJsonDocument::fromJson(file.readAll()); QJsonArray pages = jsd.array(); for (int i = 0; i < pages.size(); ++i) { ui->presetes->addItem(pages[i].toObject()["title"].toString(), pages[i].toObject()["data"].toObject()); } file.close(); }