/*
* initialize OrderData from QVariantMap
* Map got from JsonDataAccess or so
* includes also transient values
* uses foreign property names - per ex. from Server API
* corresponding export method: toForeignMap()
*/
void Customer::fillFromForeignMap(const QVariantMap& customerMap)
{
mId = customerMap.value(idForeignKey).toInt();
mCompanyName = customerMap.value(companyNameForeignKey).toString();
// mCoordinate points to GeoCoordinate*
if (customerMap.contains(coordinateForeignKey)) {
QVariantMap coordinateMap;
coordinateMap = customerMap.value(coordinateForeignKey).toMap();
if (!coordinateMap.isEmpty()) {
mCoordinate = 0;
mCoordinate = new GeoCoordinate();
mCoordinate->setParent(this);
mCoordinate->fillFromForeignMap(coordinateMap);
}
}
// mGeoAddress points to GeoAddress*
if (customerMap.contains(geoAddressForeignKey)) {
QVariantMap geoAddressMap;
geoAddressMap = customerMap.value(geoAddressForeignKey).toMap();
if (!geoAddressMap.isEmpty()) {
mGeoAddress = 0;
mGeoAddress = new GeoAddress();
mGeoAddress->setParent(this);
mGeoAddress->fillFromForeignMap(geoAddressMap);
}
}
}
void NodeModel::fromVariantMap(const QVariantMap& map){
QVariantList pos = map["Position"].toList();
QVariantMap netDeviceMap = map["NetDevice"].toMap();
QVariantMap noiseSourceMap = map["NoiseSource"].toMap();
//Migration for older versions of the dgm files.
if(netDeviceMap.isEmpty()){
QVariantList netDevicesList = map["NetDevices"].toList();
if(!netDevicesList.isEmpty()){
netDeviceMap = netDevicesList.at(0).toMap();
}
}
if(noiseSourceMap.isEmpty()){
QVariantList noiseSourcesList = map["NoiseSources"].toList();
if(!noiseSourcesList.isEmpty()){
noiseSourceMap = noiseSourcesList.at(0).toMap();
}
}
name = map["Name"].toString();
position = QPointF(pos.at(0).toDouble(), pos.at(1).toDouble());
if (!netDeviceMap.isEmpty()){
netDevice = new NetDeviceModel(netDeviceMap);
}
if(!noiseSourceMap.isEmpty()){
noiseSource = new NoiseSourceModel(noiseSourceMap);
}
this->hasOutlet = map["HasOutlet"].toBool();
this->outletImpedance.setValue(map["OutletImpedance"].toString());
}
void
YTVideoUrlFetcher::onProcessFinished(int code, QProcess::ExitStatus status)
{
qDebug() << "youtube-dl process finished, status:" << status
<< ", exit code:" << code;
if (status == QProcess::NormalExit && code == 0) {
QByteArray rawJson = _process->readAllStandardOutput();
QJsonParseError error;
QJsonDocument doc = QJsonDocument::fromJson(rawJson, &error);
if (error.error != QJsonParseError::NoError) {
qCritical() << "JSON parse error:" << error.errorString();
emit failure();
} else {
Q_ASSERT(!doc.isNull());
QVariantMap response = parseResponse(doc);
if (!response.isEmpty()) {
QVariantMap map = doc.toVariant().toMap();
Q_ASSERT(!map.isEmpty() && map.contains("id"));
_response_cache.insert(map["id"].toString(), new QVariantMap(response));
emit success(response);
} else {
emit failure();
}
}
} else {
qCritical() << "YouTubeDL process did not finish cleanly:"
<< _process->readAllStandardError();
emit failure();
}
delete _process;
_process = NULL;
}
int AddToolChainOperation::execute() const
{
QVariantMap map = load(QLatin1String("toolchains"));
if (map.isEmpty())
map = initializeToolChains();
QVariantMap result = addToolChain(map, m_id, m_displayName, m_path, m_targetAbi, m_supportedAbis, m_extra);
if (result.isEmpty() || map == result)
return 2;
return save(result, QLatin1String("toolchains")) ? 0 : 3;
}
bool QgsAfsSourceSelect::connectToService( const QgsOwsConnection &connection )
{
QString errorTitle, errorMessage;
QVariantMap serviceInfoMap = QgsArcGisRestUtils::getServiceInfo( connection.uri().param( "url" ), errorTitle, errorMessage );
if ( serviceInfoMap.isEmpty() )
{
QMessageBox::warning( this, tr( "Error" ), tr( "Failed to retrieve service capabilities:\n%1: %2" ).arg( errorTitle ).arg( errorMessage ) );
return false;
}
QStringList layerErrors;
foreach ( const QVariant& layerInfo, serviceInfoMap["layers"].toList() )
{
QVariantMap layerInfoMap = layerInfo.toMap();
if ( !layerInfoMap["id"].isValid() )
{
continue;
}
// Get layer info
QVariantMap layerData = QgsArcGisRestUtils::getLayerInfo( connection.uri().param( "url" ) + "/" + layerInfoMap["id"].toString(), errorTitle, errorMessage );
if ( layerData.isEmpty() )
{
layerErrors.append( tr( "Layer %1: %2 - %3" ).arg( layerInfoMap["id"].toString() ).arg( errorTitle ).arg( errorMessage ) );
continue;
}
// insert the typenames, titles and abstracts into the tree view
QStandardItem* idItem = new QStandardItem( layerData["id"].toString() );
QStandardItem* nameItem = new QStandardItem( layerData["name"].toString() );
QStandardItem* abstractItem = new QStandardItem( layerData["description"].toString() );
abstractItem->setToolTip( layerData["description"].toString() );
QStandardItem* cachedItem = new QStandardItem();
QStandardItem* filterItem = new QStandardItem();
cachedItem->setCheckable( true );
cachedItem->setCheckState( Qt::Checked );
QgsCoordinateReferenceSystem crs = QgsArcGisRestUtils::parseSpatialReference( serviceInfoMap["spatialReference"].toMap() );
if ( !crs.isValid() )
{
// If not spatial reference, just use WGS84
crs.createFromString( "EPSG:4326" );
}
mAvailableCRS[layerData["name"].toString()] = QList<QString>() << crs.authid();
mModel->appendRow( QList<QStandardItem*>() << idItem << nameItem << abstractItem << cachedItem << filterItem );
}
if ( !layerErrors.isEmpty() )
{
QMessageBox::warning( this, tr( "Error" ), tr( "Failed to query some layers:\n%1" ).arg( layerErrors.join( "\n" ) ) );
}
return true;
}
int AddQtOperation::execute() const
{
QVariantMap map = load(QLatin1String("qtversions"));
if (map.isEmpty())
map = initializeQtVersions();
QVariantMap result = addQt(map, m_id, m_displayName, m_type, m_qmake, m_extra);
if (result.isEmpty() || result == map)
return 2;
return save(result, QLatin1String("qtversions")) ? 0 : 3;
}
int AddDebuggerOperation::execute() const
{
QVariantMap map = load(QLatin1String("Debuggers"));
if (map.isEmpty())
map = initializeDebuggers();
QVariantMap result = addDebugger(map, m_id, m_displayName, m_engine, m_binary, m_abis,
m_extra);
if (result.isEmpty() || map == result)
return 2;
return save(result, QLatin1String("Debuggers")) ? 0 : 3;
}
int AddKitOperation::execute() const
{
QVariantMap map = load(QLatin1String("profiles"));
if (map.isEmpty())
map = initializeKits();
map = addKit(map, m_id, m_displayName, m_icon, m_debuggerEngine, m_debugger,
m_deviceType.toUtf8(), m_sysRoot, m_tc, m_qt, m_mkspec, m_extra);
if (map.isEmpty())
return -2;
return save(map, QLatin1String("profiles")) ? 0 : -3;
}
static QVariantMap mergeMaps(const QVariantMap &map1,
const QVariantMap &map2)
{
if (map1.isEmpty()) return map2;
if (map2.isEmpty()) return map1;
QVariantMap map = map1;
//map2 values will overwrite map1 values for the same keys.
QMapIterator<QString, QVariant> it(map2);
while (it.hasNext()) {
it.next();
map.insert(it.key(), it.value());
}
return map;
}
int AddKitOperation::execute() const
{
QVariantMap map = load("Profiles");
if (map.isEmpty())
map = initializeKits();
QVariantMap result = addKit(map, m_id, m_displayName, m_icon, m_debuggerId, m_debuggerEngine,
m_debugger, m_deviceType, m_device, m_sysRoot, m_tcs, m_qt,
m_mkspec, m_env, m_extra);
if (result.isEmpty() || map == result)
return 2;
return save(result, "Profiles") ? 0 : 3;
}
bool AddToolChainOperation::test() const
{
QVariantMap map = initializeToolChains();
// Add toolchain:
map = addToolChain(map, QLatin1String("testId"), QLatin1String("name"), QLatin1String("/tmp/test"),
QLatin1String("test-abi"), QLatin1String("test-abi,test-abi2"),
KeyValuePairList() << KeyValuePair(QLatin1String("ExtraKey"), QVariant(QLatin1String("ExtraValue"))));
if (map.value(QLatin1String(COUNT)).toInt() != 1
|| !map.contains(QString::fromLatin1(PREFIX) + QLatin1Char('0')))
return false;
QVariantMap tcData = map.value(QString::fromLatin1(PREFIX) + QLatin1Char('0')).toMap();
if (tcData.count() != 7
|| tcData.value(QLatin1String(ID)).toString() != QLatin1String("testId")
|| tcData.value(QLatin1String(DISPLAYNAME)).toString() != QLatin1String("name")
|| tcData.value(QLatin1String(AUTODETECTED)).toBool() != true
|| tcData.value(QLatin1String(PATH)).toString() != QLatin1String("/tmp/test")
|| tcData.value(QLatin1String(TARGET_ABI)).toString() != QLatin1String("test-abi")
|| tcData.value(QLatin1String(SUPPORTED_ABIS)).toList().count() != 2
|| tcData.value(QLatin1String("ExtraKey")).toString() != QLatin1String("ExtraValue"))
return false;
// Ignore same Id:
QVariantMap unchanged = addToolChain(map, QLatin1String("testId"), QLatin1String("name2"), QLatin1String("/tmp/test2"),
QLatin1String("test-abi2"), QLatin1String("test-abi2,test-abi3"),
KeyValuePairList() << KeyValuePair(QLatin1String("ExtraKey"), QVariant(QLatin1String("ExtraValue2"))));
if (!unchanged.isEmpty())
return false;
// Make sure name stays unique:
map = addToolChain(map, QLatin1String("testId2"), QLatin1String("name"), QLatin1String("/tmp/test"),
QLatin1String("test-abi"), QLatin1String("test-abi,test-abi2"),
KeyValuePairList() << KeyValuePair(QLatin1String("ExtraKey"), QVariant(QLatin1String("ExtraValue"))));
if (map.value(QLatin1String(COUNT)).toInt() != 2
|| !map.contains(QString::fromLatin1(PREFIX) + QLatin1Char('0'))
|| !map.contains(QString::fromLatin1(PREFIX) + QLatin1Char('1')))
return false;
tcData = map.value(QString::fromLatin1(PREFIX) + QLatin1Char('0')).toMap();
if (tcData.count() != 7
|| tcData.value(QLatin1String(ID)).toString() != QLatin1String("testId")
|| tcData.value(QLatin1String(DISPLAYNAME)).toString() != QLatin1String("name")
|| tcData.value(QLatin1String(AUTODETECTED)).toBool() != true
|| tcData.value(QLatin1String(PATH)).toString() != QLatin1String("/tmp/test")
|| tcData.value(QLatin1String(TARGET_ABI)).toString() != QLatin1String("test-abi")
|| tcData.value(QLatin1String(SUPPORTED_ABIS)).toList().count() != 2
|| tcData.value(QLatin1String("ExtraKey")).toString() != QLatin1String("ExtraValue"))
return false;
tcData = map.value(QString::fromLatin1(PREFIX) + QLatin1Char('1')).toMap();
if (tcData.count() != 7
|| tcData.value(QLatin1String(ID)).toString() != QLatin1String("testId2")
|| tcData.value(QLatin1String(DISPLAYNAME)).toString() != QLatin1String("name2")
|| tcData.value(QLatin1String(AUTODETECTED)).toBool() != true
|| tcData.value(QLatin1String(PATH)).toString() != QLatin1String("/tmp/test")
|| tcData.value(QLatin1String(TARGET_ABI)).toString() != QLatin1String("test-abi")
|| tcData.value(QLatin1String(SUPPORTED_ABIS)).toList().count() != 2
|| tcData.value(QLatin1String("ExtraKey")).toString() != QLatin1String("ExtraValue"))
return false;
return true;
}
bool Theme::generate(const QString &path, Theme *theme)
{
QJsonDocument doc = QkUtils::jsonFromFile(path);
if(doc.isNull())
return false;
QVariantMap themeJson = doc.object().toVariantMap();
theme->globalStyle = themeJson["globalStyle"].toString();
theme->editorStyle = themeJson["editorStyle"].toString();
theme->syntax = themeJson["syntax"].toString();
QVariantMap paletteJson = themeJson["palette"].toJsonObject().toVariantMap();
if(!paletteJson.isEmpty())
{
theme->globalPalette.setColor(QPalette::Window, QColor(paletteJson["window"].toString()));
theme->globalPalette.setColor(QPalette::WindowText, QColor(paletteJson["windowText"].toString()));
theme->globalPalette.setColor(QPalette::Base, QColor(paletteJson["base"].toString()));
theme->globalPalette.setColor(QPalette::AlternateBase, QColor(paletteJson["alternateBase"].toString()));
theme->globalPalette.setColor(QPalette::ToolTipBase, QColor(paletteJson["toolTipBase"].toString()));
theme->globalPalette.setColor(QPalette::ToolTipText, QColor(paletteJson["toolTipText"].toString()));
theme->globalPalette.setColor(QPalette::Text, QColor(paletteJson["text"].toString()));
theme->globalPalette.setColor(QPalette::Button, QColor(paletteJson["button"].toString()));
theme->globalPalette.setColor(QPalette::ButtonText, QColor(paletteJson["buttonText"].toString()));
}
return true;
}
void ResourcesModelPrivate::_q_onRequestFinished() {
if (!request) {
return;
}
Q_Q(ResourcesModel);
if (request->status() == ResourcesRequest::Ready) {
const QVariantMap result = request->result().toMap();
if (!result.isEmpty()) {
next = result.value("next").toString();
previous = result.value("previous").toString();
const QVariantList list = result.value("items").toList();
if (!list.isEmpty()) {
if (roles.isEmpty()) {
setRoleNames(list.first().toMap());
}
q->beginInsertRows(QModelIndex(), items.size(), items.size() + list.size() - 1);
foreach (const QVariant &item, list) {
items << item.toMap();
}
q->endInsertRows();
emit q->countChanged(q->rowCount());
}
}
}
foreach(QVariantMap devil, mDevilData)
{
if( devil.isEmpty() )
continue;
QVariantMap devil_info = cache->devilByID( devil.value("id").toInt() );
QString lbl = tr("lv%2 %1").arg( devil_info.value("name").toString()
).arg(devil.value("lvl").toInt() );
QPixmap icon( QString("icons/devils/icon_%1.png").arg(
devil_info.value("icon").toString() ) );
QString tooltip = cache->devilToolTip(devil);
mDevilLabels.at(i)->setText(lbl);
mDevilLabels.at(i)->setToolTip(tooltip);
mDevilIcons.at(i)->setPixmap(icon);
mDevilIcons.at(i)->setToolTip(tooltip);
mDevilIcons2.at(i)->setPixmap(icon);
mDevilIcons2.at(i)->setToolTip(tooltip);
for(int j = 0; j < max; j++)
{
if(j <= i)
continue;
if( mDevilData.at(j).isEmpty() )
continue;
calculateFusion(i, j);
}
i++;
}
void AppController::processMessageRequest(QList<QByteArray> return_path, QList<QByteArray> payload) {
QVariantMap response;
QString request = QString::fromUtf8(payload.at(0));
// qDebug() << "request has" << payload.size() << "packets (expecting 2)";
// qDebug() << "request verb:" << request;
if(request == "get-devices") {
response = doGetDevices();
} else if(request == "get-device" && payload.size() == 2) {
QString key = payload.at(1);
// qDebug() << "get-device for key:" << key;
response = doGetDevice(key);
} else {
qDebug() << "request payload not recognized - ignoring";
return;
}
MessageHandler* msg_handler = dynamic_cast<MessageHandler*>(sender());
if(!response.isEmpty() && msg_handler) {
QList<QByteArray> data;
data.append(variantMapToJson(response));
// qDebug() << "sending:" << data;
msg_handler->sendResponse(return_path, data);
}
}
//load data from json into controllers
//{ "device" : int,
// "buttons": [ int, int, int, ..., 16]
//}
int Frontend::loadConfigFromJson(QString file) {
JsonDataAccess jda;
int i;
QVariantMap data = jda.load(file).toMap();
if(data.isEmpty()){
return -1;
}
m_controllers[0].device = data["device"].toInt();
if(data["buttons"].isValid()){
for(i=0;i<16;++i) {
m_controllers[0].buttons[i] = data["buttons"].toList()[i].toInt();
}
}
if(data["gamepad"].isValid()){
for(i=0;i<16;++i) {
m_controllers[0].gamepad[i] = data["gamepad"].toList()[i].toInt();
}
}
return 0;
}
bool PollJob::finished()
{
QNetworkReply::NetworkError err = reply()->error();
if (err != QNetworkReply::NoError) {
_item->_httpErrorCode = reply()->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
_item->_status = classifyError(err, _item->_httpErrorCode);
_item->_errorString = reply()->errorString();
if (reply()->hasRawHeader("OC-ErrorString")) {
_item->_errorString = reply()->rawHeader("OC-ErrorString");
}
if (_item->_status == SyncFileItem::FatalError || _item->_httpErrorCode >= 400) {
if (_item->_status != SyncFileItem::FatalError
&& _item->_httpErrorCode != 503) {
SyncJournalDb::PollInfo info;
info._file = _item->_file;
// no info._url removes it from the database
_journal->setPollInfo(info);
_journal->commit("remove poll info");
}
emit finishedSignal();
return true;
}
start();
return false;
}
bool ok = false;
QByteArray jsonData = reply()->readAll().trimmed();
qDebug() << Q_FUNC_INFO << ">" << jsonData << "<" << reply()->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
QVariantMap status = QtJson::parse(QString::fromUtf8(jsonData), ok).toMap();
if (!ok || status.isEmpty()) {
_item->_errorString = tr("Invalid JSON reply from the poll URL");
_item->_status = SyncFileItem::NormalError;
emit finishedSignal();
return true;
}
if (status["unfinished"].isValid()) {
start();
return false;
}
_item->_errorString = status["error"].toString();
_item->_status = _item->_errorString.isEmpty() ? SyncFileItem::Success : SyncFileItem::NormalError;
_item->_fileId = status["fileid"].toByteArray();
_item->_etag = status["etag"].toByteArray();
_item->_responseTimeStamp = responseTimestamp();
SyncJournalDb::PollInfo info;
info._file = _item->_file;
// no info._url removes it from the database
_journal->setPollInfo(info);
_journal->commit("remove poll info");
emit finishedSignal();
return true;
}
void Auction::requestFinished(QNetworkReply* reply)
{
qDebug() << "\n Got Auctions";
// Check the network reply for errors
if (reply->error() == QNetworkReply::NoError) {
mListView = root->findChild<ListView*>("auctionView");
QString xmldata = QString(reply->readAll());
qDebug() << "\n "+xmldata;
GroupDataModel *model = new GroupDataModel(QStringList() << "albumid");
// Specify the type of grouping to use for the headers in the list
model->setGrouping(ItemGrouping::None);
XmlDataAccess xda;
QVariant list = xda.loadFromBuffer(xmldata, "/cardcategories/album");
QVariantMap tempMap = list.value<QVariantMap>();
QVariantList tempList;
if (tempMap.isEmpty()) {
tempList = list.value<QVariantList>();
}
else {
tempList.append(tempMap);
}
model->insertList(tempList);
mListView->setDataModel(model);
}
else
{
qDebug() << "\n Problem with the network";
qDebug() << "\n" << reply->errorString();
}
mActivityIndicator->stop();
}
bool LoadFromJSON(QVariantMap &data, QIODevice &f, const char *magicIdentifier, uint32_t magicVersion)
{
QByteArray json = f.readAll();
if(json.isEmpty())
{
qCritical() << "Read invalid empty JSON data from file " << f.errorString();
return false;
}
QJsonDocument doc = QJsonDocument::fromJson(json);
if(doc.isEmpty() || doc.isNull())
{
qCritical() << "Failed to convert file to JSON document";
return false;
}
data = doc.toVariant().toMap();
if(data.isEmpty() || !data.contains(magicIdentifier))
{
qCritical() << "Converted config data is invalid or unrecognised";
return false;
}
if(data[magicIdentifier].toUInt() != magicVersion)
{
qCritical() << "Converted config data is not the right version";
return false;
}
return true;
}
void Mpris::updateStatus()
{
QVariantMap map;
if (MPDStatus::self()->repeat()!=status.repeat) {
map.insert("LoopStatus", LoopStatus());
}
if (MPDStatus::self()->random()!=status.random) {
map.insert("Shuffle", Shuffle());
}
if (MPDStatus::self()->volume()!=status.volume) {
map.insert("Volume", Volume());
}
if (MPDStatus::self()->playlistLength()!=status.playlistLength) {
map.insert("CanGoNext", CanGoNext());
map.insert("CanGoPrevious", CanGoPrevious());
}
if (MPDStatus::self()->state()!=status.state) {
map.insert("PlaybackStatus", PlaybackStatus());
map.insert("CanPlay", CanPlay());
map.insert("CanPause", CanPause());
map.insert("CanSeek", CanSeek());
}
if (MPDStatus::self()->timeElapsed()!=status.timeElapsed) {
map.insert("Position", convertTime(MPDStatus::self()->timeElapsed()));
}
if (!map.isEmpty() || MPDStatus::self()->songId()!=status.songId) {
if (!map.contains("Position")) {
map.insert("Position", convertTime(MPDStatus::self()->timeElapsed()));
}
map.insert("Metadata", Metadata());
signalUpdate(map);
}
status=MPDStatus::self()->getValues();
}
int AddMerSdkOperation::execute() const
{
QVariantMap map = load(QLatin1String("mersdk"));
if (map.isEmpty())
map = initializeSdks();
map.insert(QLatin1String(Mer::Constants::MER_SDK_INSTALLDIR), m_installDir);
const QVariantMap result = addSdk(map, m_name, m_autoDetected, m_sharedHomePath, m_sharedTargetsPath, m_sharedSshPath,
m_sharedSrcPath, m_sharedConfigPath, m_host, m_userName, m_privateKeyFile, m_sshPort,
m_wwwPort, m_headless);
if (result.isEmpty() || map == result)
return 2;
return save(result,QLatin1String("mersdk")) ? 0 : 3;
}
bool BuildConfiguration::fromMap(const QVariantMap &map)
{
m_clearSystemEnvironment = map.value(QLatin1String(CLEAR_SYSTEM_ENVIRONMENT_KEY)).toBool();
m_userEnvironmentChanges = Utils::EnvironmentItem::fromStringList(map.value(QLatin1String(USER_ENVIRONMENT_CHANGES_KEY)).toStringList());
m_buildDirectory = Utils::FileName::fromString(map.value(QLatin1String(BUILDDIRECTORY_KEY)).toString());
updateCacheAndEmitEnvironmentChanged();
qDeleteAll(m_stepLists);
m_stepLists.clear();
int maxI = map.value(QLatin1String(BUILD_STEP_LIST_COUNT), 0).toInt();
for (int i = 0; i < maxI; ++i) {
QVariantMap data = map.value(QLatin1String(BUILD_STEP_LIST_PREFIX) + QString::number(i)).toMap();
if (data.isEmpty()) {
qWarning() << "No data for build step list" << i << "found!";
continue;
}
auto list = new BuildStepList(this, idFromMap(data));
if (!list->fromMap(data)) {
qWarning() << "Failed to restore build step list" << i;
delete list;
return false;
}
m_stepLists.append(list);
}
// We currently assume there to be at least a clean and build list!
QTC_CHECK(knownStepLists().contains(Core::Id(Constants::BUILDSTEPS_BUILD)));
QTC_CHECK(knownStepLists().contains(Core::Id(Constants::BUILDSTEPS_CLEAN)));
return ProjectConfiguration::fromMap(map);
}
bool HistoryFeedHook::hook(const FeedNotify ¬ify, QVariantMap &out)
{
if (notify.name() != MESSAGES_FEED_LAST_REQ && notify.name() != MESSAGES_FEED_SINCE_REQ)
return false;
QVariantMap data = out.value(FeedNotify::kData).toMap();
if (data.isEmpty())
return false;
const QStringList messages = data.value(MESSAGES_FEED_MESSAGES_KEY).toStringList();
if (messages.isEmpty())
return false;
QStringList list;
# if QT_VERSION >= 0x040700
list.reserve(messages.size());
# endif
ChatId id;
foreach (const QString &message, messages) {
id.init(message.toLatin1());
if (id.hasOid())
list.append(ChatId::toBase32(id.oid().byteArray()));
else
list.append(message);
}
static void setupCompilerPathByLanguage(Profile &profile, const QStringList &toolchainTypes,
const QString &toolchainInstallPath, const QString &toolchainPrefix)
{
QVariantMap m;
if (toolchainTypes.contains(QLatin1String("clang"))) {
m[QLatin1String("c")] = m[QLatin1String("objc")] = QLatin1String("clang");
m[QLatin1String("cpp")] = m[QLatin1String("objcpp")] = QLatin1String("clang++");
} else if (toolchainTypes.contains(QLatin1String("gcc"))) {
m[QLatin1String("c")] = m[QLatin1String("objc")] = QLatin1String("gcc");
m[QLatin1String("cpp")] = m[QLatin1String("objcpp")] = QLatin1String("g++");
} else {
qDebug("WARNING: unexpected toolchain %s", qPrintable(toJSLiteral(toolchainTypes)));
return;
}
const QString toolchainPathPrefix = toolchainInstallPath + QLatin1Char('/') + toolchainPrefix;
for (QVariantMap::iterator it = m.begin(); it != m.end();) {
const QString filePath = HostOsInfo::appendExecutableSuffix(toolchainPathPrefix
+ it.value().toString());
if (QFile::exists(filePath)) {
it.value() = filePath;
++it;
continue;
}
qDebug("WARNING: Compiler %s for file tag %s not found.",
qPrintable(QDir::toNativeSeparators(filePath)), qPrintable(it.key()));
it = m.erase(it);
}
if (!m.isEmpty())
profile.setValue(QLatin1String("cpp.compilerPathByLanguage"), m);
}
void VotingManager::onReplyFinished()
{
if (m_reply->error() == QNetworkReply::NoError) {
bool ok;
const QVariantMap result = QtJson::parse(QString::fromUtf8(m_reply->readAll()), ok).toMap();
Q_ASSERT_X(ok, Q_FUNC_INFO, "Error parsing JSON");
Q_ASSERT_X(!result.isEmpty(), Q_FUNC_INFO, "Error parsing JSON or JSON is empty");
const QString id = result.value("id").toString();
const int score = result.value("myScore").toInt();
const QString msg = result.value("msg").toString();
if (msg.contains("loved", Qt::CaseInsensitive)) // if success, msg can be "Loved" or "Not loved"
emit voteSuccess(id, score);
else
emit failure(msg);
} else {
emit failure(m_reply->errorString());
}
m_reply->deleteLater();
m_reply = 0;
if (m_isBusy != false) {
m_isBusy = false;
emit busyChanged();
}
}
void LayerManager::setSelectionPrivate(const Coordinate& crd, LayerModel * layer) {
CoverageLayerModel *coverageLayer = dynamic_cast<CoverageLayerModel *>(layer);
if (coverageLayer) {
Coordinate coord = crd;
if (coverageLayer->coverage()->coordinateSystem() != rootLayer()->screenCsy()) {
coord = coverageLayer->coverage()->coordinateSystem()->coord2coord(rootLayer()->screenCsy(), crd);
}
QVariant var = coverageLayer->coverage()->coord2value(coord);
QVariantMap mp = var.toMap();
if (!mp.isEmpty()) {
bool ok;
quint64 featureid = mp[FEATUREIDDCOLUMN].toULongLong(&ok);
if (ok) {
coverageLayer->addSelection(featureid, true);
QVariantMap data;
data["identity"] = featureid;
data["ilwisobjectid"] = coverageLayer->coverage()->id();
data["ilwistype"] = coverageLayer->coverage()->ilwisType();
data["index"] = mp["index"].toUInt();
coverageLayer->sendLink(data);
}
}
}
for (int layerIndex = 0; layerIndex < layer->rowCount(); ++layerIndex) {
LayerModel *childLayer = static_cast<LayerModel *>(layer->child(layerIndex));
setSelectionPrivate(crd, childLayer);
}
}
bool DeployConfiguration::fromMap(const QVariantMap &map)
{
if (!ProjectConfiguration::fromMap(map))
return false;
int maxI = map.value(QLatin1String(BUILD_STEP_LIST_COUNT), 0).toInt();
if (maxI != 1)
return false;
QVariantMap data = map.value(QLatin1String(BUILD_STEP_LIST_PREFIX) + QLatin1String("0")).toMap();
if (!data.isEmpty()) {
delete m_stepList;
m_stepList = new BuildStepList(this, data);
if (m_stepList->isNull()) {
qWarning() << "Failed to restore deploy step list";
delete m_stepList;
m_stepList = 0;
return false;
}
m_stepList->setDefaultDisplayName(tr("Deploy"));
} else {
qWarning() << "No data for deploy step list found!";
return false;
}
// We assume that we hold the deploy list
Q_ASSERT(m_stepList && m_stepList->id() == ProjectExplorer::Constants::BUILDSTEPS_DEPLOY);
return true;
}
int AddDeviceOperation::execute() const
{
QVariantMap map = load(QLatin1String("devices"));
if (map.isEmpty())
map = initializeDevices();
QVariantMap result = addDevice(map, m_id, m_displayName, m_type, m_authentication,
m_b2q_platformHardware, m_b2q_platformSoftware, m_debugServer,
m_freePortsSpec, m_host, m_keyFile, m_origin, m_osType,
m_password, m_sshPort, m_timeout, m_uname, m_version, m_extra);
if (result.isEmpty() || map == result)
return 2;
return save(result, QLatin1String("devices")) ? 0 : 3;
}
void EditorConfiguration::fromMap(const QVariantMap &map)
{
d->m_useGlobal = map.value(kUseGlobal, d->m_useGlobal).toBool();
const QByteArray &codecName = map.value(kCodec, d->m_textCodec->name()).toByteArray();
d->m_textCodec = QTextCodec::codecForName(codecName);
if (!d->m_textCodec)
d->m_textCodec = Core::EditorManager::instance()->defaultTextCodec();
const int codeStyleCount = map.value(kCodeStyleCount, 0).toInt();
for (int i = 0; i < codeStyleCount; ++i) {
QVariantMap settingsIdMap = map.value(kCodeStylePrefix + QString::number(i)).toMap();
if (settingsIdMap.isEmpty()) {
qWarning() << "No data for code style settings list" << i << "found!";
continue;
}
QString languageId = settingsIdMap.value(QLatin1String("language")).toString();
QVariantMap value = settingsIdMap.value(QLatin1String("value")).toMap();
ICodeStylePreferences *preferences = d->m_languageCodeStylePreferences.value(languageId);
if (preferences) {
preferences->fromMap(QString(), value);
}
}
d->m_defaultCodeStyle->fromMap(kPrefix, map);
d->m_typingSettings.fromMap(kPrefix, map);
d->m_storageSettings.fromMap(kPrefix, map);
d->m_behaviorSettings.fromMap(kPrefix, map);
d->m_extraEncodingSettings.fromMap(kPrefix, map);
}
QVariantMap QgsProcessingAlgorithm::run( const QVariantMap ¶meters, QgsProcessingContext &context, QgsProcessingFeedback *feedback, bool *ok, const QVariantMap &configuration ) const
{
std::unique_ptr< QgsProcessingAlgorithm > alg( create( configuration ) );
if ( ok )
*ok = false;
bool res = alg->prepare( parameters, context, feedback );
if ( !res )
return QVariantMap();
QVariantMap runRes;
try
{
runRes = alg->runPrepared( parameters, context, feedback );
}
catch ( QgsProcessingException &e )
{
QgsMessageLog::logMessage( e.what(), QObject::tr( "Processing" ), Qgis::Critical );
feedback->reportError( e.what() );
return QVariantMap();
}
if ( ok )
*ok = true;
QVariantMap ppRes = alg->postProcess( context, feedback );
if ( !ppRes.isEmpty() )
return ppRes;
else
return runRes;
}
