void save_data_list_dialog::UpdateList()
{
m_list->clearContents();
m_list->setRowCount((int)m_save_entries.size());
QVariantMap currNotes = m_gui_settings->GetValue(gui::m_saveNotes).toMap();
int row = 0;
for (const SaveDataEntry& entry: m_save_entries)
{
QString title = qstr(entry.title);
QString subtitle = qstr(entry.subtitle);
QString dirName = qstr(entry.dirName);
QTableWidgetItem* titleItem = new QTableWidgetItem(title);
titleItem->setData(Qt::UserRole, row); // For sorting to work properly
titleItem->setFlags(titleItem->flags() & ~Qt::ItemIsEditable);
m_list->setItem(row, 0, titleItem);
QTableWidgetItem* subtitleItem = new QTableWidgetItem(subtitle);
subtitleItem->setFlags(subtitleItem->flags() & ~Qt::ItemIsEditable);
m_list->setItem(row, 1, subtitleItem);
QTableWidgetItem* dirNameItem = new QTableWidgetItem(dirName);
dirNameItem->setFlags(dirNameItem->flags() & ~Qt::ItemIsEditable);
m_list->setItem(row, 2, dirNameItem);
QTableWidgetItem* noteItem = new QTableWidgetItem();
noteItem->setFlags(noteItem->flags() | Qt::ItemIsEditable);
if (currNotes.contains(dirName))
{
noteItem->setText(currNotes[dirName].toString());
}
m_list->setItem(row, 3, noteItem);
++row;
}
m_list->horizontalHeader()->resizeSections(QHeaderView::ResizeToContents);
m_list->verticalHeader()->resizeSections(QHeaderView::ResizeToContents);
QSize tableSize = QSize
(
m_list->verticalHeader()->width() + m_list->horizontalHeader()->length() + m_list->frameWidth() * 2,
m_list->horizontalHeader()->height() + m_list->verticalHeader()->length() + m_list->frameWidth() * 2
);
QSize preferredSize = minimumSize().expandedTo(sizeHint() - m_list->sizeHint() + tableSize);
QSize maxSize = QSize(preferredSize.width(), static_cast<int>(QApplication::desktop()->screenGeometry().height()*.6));
resize(preferredSize.boundedTo(maxSize));
}
void AstSipPeer::sExtensionStatusEvent(const QVariantMap &event)
{
if(event.contains("Status"))
{
bool ok = false;
uint status = event.value("Status").toUInt(&ok);
if(ok)
_extStatus = (AsteriskManager::ExtStatus)status;
}
emit sigExtensionStatusEvent(this, event);
}
bool SetTaskHandler::validate(QVariantMap task) {
bool isValid = true;
bool ok;
try {
if (task.contains("id")) {
int v = task["id"].toString().toInt(&ok, 16);
assert_ex(ok && 0 <= v && v <= 255, ValidationError(""));
}
if (task.contains("categories")) {
QVariantMap categories = task["categories"].toMap();
for (auto it = categories.begin(); it != categories.end(); it++) {
int v = it.key().toInt(&ok, 16);
assert_ex(ok && 0 <= v && v <= 255, ValidationError(""));
}
}
} catch (ValidationError& e) {
isValid = false;
}
return isValid;
}
QVariant EstimateProfileOperationCommand::estimateStealthLink(const QVariantMap &request)
{
if(!request.contains("uri"))
{
return makeFeeObject(BigInt(136000), request);
}
else
{
return makeFeeObject(estimateEdit(request["uri"].toString(), "payments", request["stealth"].toString()), request);
}
}
void ClientWindow::on_server_usersChanged(QVariantList users)
{
listWidgetUsers->clear();
foreach (QVariant v, users) {
QVariantMap map = v.toMap();
QListWidgetItem *item = new QListWidgetItem(map["username"].toString());
if(map.contains("avator"))
item->setIcon(QIcon(map["avator"].value<QPixmap>()));
listWidgetUsers->addItem(item);
}
void GreeterStatus::greeterPropertiesChanged(const QString &interface, const QVariantMap &changed, const QStringList &invalidated)
{
Q_UNUSED(invalidated);
if (interface == "com.canonical.UnityGreeter") {
if (changed.contains("IsActive")) {
m_greeterActive = changed.value("IsActive").toBool();
Q_EMIT greeterActiveChanged();
}
}
}
void AstSipPeer::sDndStatusEvent(const QVariantMap &event)
{
if(event.contains("Status"))
{
uint statusNum = event.value("Status").toUInt();
AsteriskManager::ExtStatuses statuses(statusNum);
_isDndOn = !statuses.testFlag(AsteriskManager::NotInUse);
emit sUpdated(this);
emit sigDndStatusEvent(this, event, _isDndOn);
}
}
// ----------------------------------------------------------------------------
// SifUiDialog::prepareForErrorDetails()
// ----------------------------------------------------------------------------
//
void SifUiDialog::prepareForErrorDetails(const QVariantMap ¶meters)
{
if (parameters.contains(KSifUiErrorDetails)) {
mErrorDetails = parameters.value(KSifUiErrorDetails).toString();
}
if (parameters.contains(KSifUiErrorCode)) {
bool ok = false;
int errorCode = parameters.value(KSifUiErrorCode).toInt(&ok);
if (ok) {
mErrorCode = errorCode;
}
}
if (parameters.contains(KSifUiErrorCodeExtended)) {
bool ok = false;
int errorCode = parameters.value(KSifUiErrorCodeExtended).toInt(&ok);
if (ok) {
mExtendedErrorCode = errorCode;
}
}
}
bool PhoneInfo::updateStatus(const QVariantMap & prop)
{
bool haschanged = false;
haschanged |= setIfChangeString(prop, "hintstatus", & m_hintstatus);
if (prop.contains("channels")) {
m_channels = prop.value("channels").toStringList();
m_xchannels.clear();
foreach (QString channel, m_channels) {
QString xchannel = QString("%1/%2").arg(m_ipbxid).arg(channel);
m_xchannels.append(xchannel);
}
CPB::AutoSendEventData CPB::AutoSendEventData::parseMap(const QVariantMap &objMap, bool &valid)
{
AutoSendEventData obj;
if(objMap.contains("type") && objMap.contains("content")
&& objMap.contains("dateTime"))
{
Z_DEFINE_PARSE_VALUE_FOR_INT(obj,objMap,type);
Z_DEFINE_PARSE_VALUE_FOR_STRING(obj,objMap,content);
QDateTime dateTime = QDateTime::fromString(objMap.value("dateTime").toString(),"yyyyMMdd hh:mm:ss");
if(!dateTime.isValid() || dateTime.isNull())
{
dateTime = QDateTime::fromString(objMap.value("dateTime").toString(),"yyyy-MM-dd hh:mm:ss");
}
if(!dateTime.isValid() || dateTime.isNull())
{
QDate date = QDate::fromString(objMap.value("dateTime").toString(),"yyyy-MM-dd");
if(date.isValid() && !date.isNull())
{
dateTime = QDateTime(date,QTime(0,0,0));
}
}
if(dateTime.isValid() && !dateTime.isNull())
{
valid = true;
obj.dateTime = dateTime.toTime_t();
}
else
{
ZW_LOG_WARNING(QString("dateTime is error value=%1").arg(objMap.value("dateTime").toString()));
}
}
else
{
ZW_LOG_WARNING(QString("keys not complete"));
valid = false;
}
return obj;
}
RulePtr Grammar::makeRule(const QVariantMap& ruleData) const
{
RulePtr rule(new RuleData);
rule->name = ruleData.value("name").toString();
if (ruleData.contains("contentName"))
rule->contentName = ruleData.value("contentName").toString();
else
rule->contentName = rule->name;
rule->includeName = ruleData.value("include").toString();
if (ruleData.contains("begin")) {
rule->beginPattern = ruleData.value("begin").toString();
rule->begin.setPattern(rule->beginPattern);
}
if (ruleData.contains("end")) {
rule->endPattern = ruleData.value("end").toString();
}
if (ruleData.contains("match")) {
rule->matchPattern = ruleData.value("match").toString();
rule->match.setPattern(rule->matchPattern);
}
QVariant ruleListData = ruleData.value("patterns");
if (ruleListData.isValid()) {
rule->patterns = makeRuleList(ruleListData.toList());
}
QVariant capturesData = ruleData.value("captures");
rule->captures = makeCaptures(capturesData.toMap());
QVariant beginCapturesData = ruleData.value("beginCaptures");
if (beginCapturesData.isValid())
rule->beginCaptures = makeCaptures(beginCapturesData.toMap());
else
rule->beginCaptures = rule->captures;
QVariant endCapturesData = ruleData.value("endCaptures");
if (endCapturesData.isValid())
rule->endCaptures = makeCaptures(endCapturesData.toMap());
else
rule->endCaptures = rule->captures;
return rule;
}
DigitallyImportedClient::AuthReply
DigitallyImportedClient::ParseAuthReply(QNetworkReply* reply) const {
AuthReply ret;
ret.success_ = false;
ret.error_reason_ = tr("Unknown error");
const int http_status = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
if (http_status == 403) {
ret.error_reason_ = reply->readAll();
return ret;
} else if (http_status != 200) {
return ret;
}
QJson::Parser parser;
QVariantMap data = parser.parse(reply).toMap();
if (!data.contains("subscriptions")) {
return ret;
}
QVariantList subscriptions = data.value("subscriptions", QVariantList()).toList();
if (subscriptions.isEmpty() ||
subscriptions[0].toMap().value("status").toString() != "active") {
ret.error_reason_ = tr("You do not have an active subscription");
return ret;
}
if (!data.contains("first_name") ||
!data.contains("last_name") ||
!subscriptions[0].toMap().contains("expires_on") ||
!data.contains("listen_key"))
return ret;
ret.success_ = true;
ret.first_name_ = data["first_name"].toString();
ret.last_name_ = data["last_name"].toString();
ret.expires_ = QDateTime::fromString(subscriptions[0].toMap()["expires_on"].toString(), Qt::ISODate);
ret.listen_hash_ = data["listen_key"].toString();
return ret;
}
void Preferences::upgrade()
{
QStringList labels = value("TransferListFilters/customLabels").toStringList();
if (!labels.isEmpty()) {
QVariantMap categories = value("BitTorrent/Session/Categories").toMap();
foreach (const QString &label, labels) {
if (!categories.contains(label))
categories[label] = "";
}
setValue("BitTorrent/Session/Categories", categories);
SettingsStorage::instance()->removeValue("TransferListFilters/customLabels");
}
void Server::add(const QVariantMap& entry) {
CHECK_PARAM_RET(entry.contains(KEY));
const QString& sKey = entry.value(KEY).toString();
CHECK_PARAM_RET(!sKey.isEmpty());
m_database.insert(sKey, entry);
qDebug() << "database:";
qDebug() << m_database;
emit entryAdded(entry);
}
void NotificationThread::processIP1(QByteArray const& data)
{
QVariantMap result = bb::data::JsonDataAccess().loadFromBuffer(data).toMap();
if ( result.contains("latitude") && result.contains("longitude") )
{
qreal latitude = result.value("latitude").toReal();
qreal longitude = result.value("longitude").toReal();
QString country = result.value("country").toString();
QString city = result.value("city").toString();
QString region = result.value("region").toString();
saveLocation(country, city, latitude, longitude, region);
} else if ( m_network.online() ) {
m_network.doGet( QUrl("http://www.freegeoip.net/csv/"), COOKIE_IP2_FETCH); // try a different provider
AppLogFetcher::getInstance()->record("FailedIP1FetchIP2");
} else {
LOGGER("OfflineDontFetchIP2");
AppLogFetcher::getInstance()->record("OfflineDontFetchIP2");
}
}
int QSListModel::indexOf(QString field, QVariant value) const
{
int res = -1;
for (int i = 0 ; i < m_storage.count();i++) {
QVariantMap item = m_storage.at(i).toMap();
if (item.contains(field) && item[field] == value) {
res = i;
break;
}
}
return res;
}
void ObjectEditorWidget::onObjectDataChanged(const QVariantMap & data)
{
int w=-1, h=-1;
mXSpin->blockSignals(true);
mYSpin->blockSignals(true);
if (data.contains("x") && data.value("x").canConvert(QVariant::Int))
mXSpin->setValue(data.value("x").toInt());
if (data.contains("y") && data.value("y").canConvert(QVariant::Int))
mYSpin->setValue(data.value("y").toInt());
if (data.contains("width") && data.value("width").canConvert(QVariant::String))
w = data.value("width").toInt();
if (data.contains("height") && data.value("height").canConvert(QVariant::String))
h = data.value("height").toInt();
setObjectSize(w, h);
mXSpin->blockSignals(false);
mYSpin->blockSignals(false);
}
FileReference toFileReference(const QVariant& variant, const VersionString& version) {
QVariantMap map = variant.toMap();
OptionalDateTime timestampLast;
if (version < VersionString("1.0.4")) {
timestampLast = DateTime(map["timestamp_last"].toString().toStdString());
}
else {
timestampLast = DateTime::fromISO8601(map["timestamp_last"].toString().toStdString());
}
OS_ASSERT(timestampLast);
return FileReference(toUUID(map["uuid"].toString().toStdString()),
toUUID(map["version_uuid"].toString().toStdString()),
map.contains("name") ? map["name"].toString().toStdString() : std::string(),
map.contains("display_name") ? map["display_name"].toString().toStdString() : std::string(),
map.contains("description") ? map["description"].toString().toStdString() : std::string(),
toPath(map["path"].toString()),
FileReferenceType(map["file_type"].toString().toStdString()),
timestampLast.get(),
map["checksum_create"].toString().toStdString(),
map["checksum_last"].toString().toStdString());
}
void ParticleEmitterSystem::fromVariantMap(QtEntity::EntityId eid, const QVariantMap& m, int)
{
ParticleEmitter* e;
if(component(eid, e))
{
if(m.contains("emitters"))
{
setEmitters(eid, m["emitters"].value<QtEntityUtils::ItemList>());
}
}
}
void RequestDialog::load(const QVariant& settings)
{
const QVariantMap map = settings.toMap();
m_sbPeriod->setValue(map["period"].toInt());
m_sbTimes->setValue(map["times"].toInt());
m_cbUseStored->setChecked(map["use_stored"].toBool());
m_pbStartStop->setChecked(map["start_stop"].toBool());
if (map.contains("form"))
m_dlg->load(map["form"]);
}
void ShaderLibrary::setFilterVariables(QVariantMap const& map)
{
if (!filtersAvailable()) return;
bool aa(map.contains("Antialias") && map.value("Antialias").toBool());
bool bd(map.contains("Border") && map.value("Border").toBool());
bool ao(map.contains("AmbientOcclusion") && map.value("AmbientOcclusion").toBool());
m_filtersActive = aa || bd || ao;
// Let the shaders know whether or not the Mask texture is valid
QStringList shaders(availableShaders());
QStringList::const_iterator iter;
for (iter = shaders.begin(); iter != shaders.end(); ++iter) {
setUniformVariable(*iter, "FiltersAreValid", m_filtersActive);
}
// Ambient Occlusion parameters
if (ao) {
setUniformVariables("Filters", map);
}
}
bool RmToolChainOperation::test() const
{
// Add toolchain:
QVariantMap map = AddToolChainOperation::initializeToolChains();
map = AddToolChainOperation::addToolChain(map, QLatin1String("testId"), QLatin1String("name"), QLatin1String("/tmp/test"),
QLatin1String("test-abi"), QLatin1String("test-abi,test-abi2"),
KeyValuePairList() << KeyValuePair(QLatin1String("ExtraKey"), QVariant(QLatin1String("ExtraValue"))));
map = AddToolChainOperation::addToolChain(map, QLatin1String("testId2"), QLatin1String("other name"), QLatin1String("/tmp/test2"),
QLatin1String("test-abi"), QLatin1String("test-abi,test-abi2"),
KeyValuePairList());
QVariantMap result = rmToolChain(QVariantMap(), QLatin1String("nonexistant"));
if (!result.isEmpty())
return false;
result = rmToolChain(map, QLatin1String("nonexistant"));
if (result != map)
return false;
result = rmToolChain(map, QLatin1String("testId2"));
if (result == map
|| result.value(QLatin1String(COUNT), 0).toInt() != 1
|| !result.contains(QLatin1String("ToolChain.0"))
|| result.value(QLatin1String("ToolChain.0")) != map.value(QLatin1String("ToolChain.0")))
return false;
result = rmToolChain(map, QLatin1String("testId"));
if (result == map
|| result.value(QLatin1String(COUNT), 0).toInt() != 1
|| !result.contains(QLatin1String("ToolChain.0"))
|| result.value(QLatin1String("ToolChain.0")) != map.value(QLatin1String("ToolChain.1")))
return false;
result = rmToolChain(result, QLatin1String("testId2"));
if (result == map
|| result.value(QLatin1String(COUNT), 0).toInt() != 0)
return false;
return true;
}
void MprisControlPlugin::propertiesChanged(const QString& propertyInterface, const QVariantMap& properties)
{
Q_UNUSED(propertyInterface);
NetworkPackage np(PACKAGE_TYPE_MPRIS);
bool somethingToSend = false;
if (properties.contains("Volume")) {
int volume = (int) (properties["Volume"].toDouble()*100);
if (volume != prevVolume) {
np.set("volume",volume);
prevVolume = volume;
somethingToSend = true;
}
}
if (properties.contains("Metadata")) {
QDBusArgument bullshit = qvariant_cast<QDBusArgument>(properties["Metadata"]);
QVariantMap nowPlayingMap;
bullshit >> nowPlayingMap;
if (nowPlayingMap.contains("xesam:title")) {
QString nowPlaying = nowPlayingMap["xesam:title"].toString();
if (nowPlayingMap.contains("xesam:artist")) {
nowPlaying = nowPlayingMap["xesam:artist"].toString() + " - " + nowPlaying;
}
np.set("nowPlaying",nowPlaying);
somethingToSend = true;
}
if (nowPlayingMap.contains("mpris:length")) {
if (nowPlayingMap.contains("mpris:length")) {
long long length = nowPlayingMap["mpris:length"].toLongLong();
np.set("length",length/1000); //milis to nanos
}
somethingToSend = true;
}
}
void NetworkManager::VlanSetting::fromMap(const QVariantMap &setting)
{
if (setting.contains(QLatin1String(NM_SETTING_VLAN_INTERFACE_NAME))) {
setInterfaceName(setting.value(QLatin1String(NM_SETTING_VLAN_INTERFACE_NAME)).toString());
}
if (setting.contains(QLatin1String(NM_SETTING_VLAN_PARENT))) {
setParent(setting.value(QLatin1String(NM_SETTING_VLAN_PARENT)).toString());
}
if (setting.contains(QLatin1String(NM_SETTING_VLAN_ID))) {
setId(setting.value(QLatin1String(NM_SETTING_VLAN_ID)).toUInt());
}
if (setting.contains(QLatin1String(NM_SETTING_VLAN_FLAGS))) {
setFlags((Flag)setting.value(QLatin1String(NM_SETTING_VLAN_FLAGS)).toUInt());
}
if (setting.contains(QLatin1String(NM_SETTING_VLAN_INGRESS_PRIORITY_MAP))) {
setIngressPriorityMap(setting.value(QLatin1String(NM_SETTING_VLAN_INGRESS_PRIORITY_MAP)).toStringList());
}
if (setting.contains(QLatin1String(NM_SETTING_VLAN_EGRESS_PRIORITY_MAP))) {
setEgressPriorityMap(setting.value(QLatin1String(NM_SETTING_VLAN_EGRESS_PRIORITY_MAP)).toStringList());
}
}
// From a QvariantMap representing a location response from the Location Manager fill the lists of
// QGeoSatelliteInfo instances intended to be emitted via satellitesInUseUpdated() and
// satellitesInViewUpdated() signals.
void QGeoSatelliteInfoSourceBbPrivate::populateSatelliteLists(const QVariantMap &map)
{
// populate _currentSatelliteInfo
QVariantMap datMap = map.value("dat").toMap();
QVariantList satelliteList = datMap.value("satellites").toList();
_satellitesInView.clear();
_satellitesInUse.clear();
Q_FOREACH (const QVariant &satelliteData, satelliteList) {
datMap = satelliteData.toMap();
QGeoSatelliteInfo satelliteInfo = QGeoSatelliteInfo();
if (datMap.contains("id"))
satelliteInfo.setSatelliteIdentifier(static_cast<int>(datMap.value("id").toDouble()));
satelliteInfo.setSatelliteSystem(determineSatSystem(satelliteInfo.satelliteIdentifier()));
if (datMap.contains("cno"))
satelliteInfo.setSignalStrength(static_cast<int>(datMap.value("cno").toDouble()));
// attributes
if (datMap.contains("elevation"))
satelliteInfo.setAttribute(QGeoSatelliteInfo::Elevation,
static_cast<qreal>(datMap.value("elevation").toDouble()));
else
satelliteInfo.removeAttribute(QGeoSatelliteInfo::Elevation);
if (datMap.contains("azimuth"))
satelliteInfo.setAttribute(QGeoSatelliteInfo::Azimuth,
static_cast<qreal>(datMap.value("azimuth").toDouble()));
else
satelliteInfo.removeAttribute(QGeoSatelliteInfo::Azimuth);
// each satellite in this list is considered "in view"
_satellitesInView.append(satelliteInfo);
if (datMap.value("used").toBool() == true)
_satellitesInUse.append(satelliteInfo);
}
void MemoryUsageModelTest::testDetails()
{
const QVariantMap allocated = model.details(0);
QCOMPARE(allocated[QString("displayName")].toString(), model.tr("Memory Allocated"));
QCOMPARE(allocated[model.tr("Total")].toString(), model.tr("%1 bytes").arg(4096));
QCOMPARE(allocated[model.tr("Allocated")].toString(), model.tr("%1 bytes").arg(4096));
QCOMPARE(allocated[model.tr("Allocations")].toString(), QString::number(2));
QCOMPARE(allocated[model.tr("Type")].toString(), model.tr("Heap Allocation"));
QCOMPARE(allocated[model.tr("Location")].toString(), QmlProfilerDataModel::tr("<bytecode>"));
QVERIFY(!allocated.contains(model.tr("Deallocated")));
QVERIFY(!allocated.contains(model.tr("Deallocations")));
const QVariantMap large = model.details(2);
QCOMPARE(large[QString("displayName")].toString(), model.tr("Memory Allocated"));
QCOMPARE(large[model.tr("Total")].toString(), model.tr("%1 bytes").arg(5120));
QCOMPARE(large[model.tr("Allocated")].toString(), model.tr("%1 bytes").arg(1024));
QCOMPARE(large[model.tr("Allocations")].toString(), QString::number(1));
QCOMPARE(large[model.tr("Type")].toString(), model.tr("Large Item Allocation"));
QCOMPARE(large[model.tr("Location")].toString(), QmlProfilerDataModel::tr("<bytecode>"));
QVERIFY(!large.contains(model.tr("Deallocated")));
QVERIFY(!large.contains(model.tr("Deallocations")));
const QVariantMap freed = model.details(9);
QCOMPARE(freed[QString("displayName")].toString(), model.tr("Memory Freed"));
QCOMPARE(freed[model.tr("Total")].toString(), model.tr("%1 bytes").arg(2048));
QCOMPARE(freed[model.tr("Deallocated")].toString(), model.tr("%1 bytes").arg(1024));
QCOMPARE(freed[model.tr("Deallocations")].toString(), QString::number(1));
QCOMPARE(freed[model.tr("Type")].toString(), model.tr("Heap Usage"));
QCOMPARE(freed[model.tr("Location")].toString(), QmlProfilerDataModel::tr("<bytecode>"));
QVERIFY(!freed.contains(model.tr("Allocated")));
QVERIFY(!freed.contains(model.tr("Allocations")));
}
bool CheckServerJob::finished()
{
account()->setSslConfiguration(reply()->sslConfiguration());
// The serverInstalls to /owncloud. Let's try that if the file wasn't found
// at the original location
if ((reply()->error() == QNetworkReply::ContentNotFoundError) && (!_subdirFallback)) {
_subdirFallback = true;
setPath(QLatin1String(owncloudDirC)+QLatin1String(statusphpC));
start();
qDebug() << "Retrying with" << reply()->url();
return false;
}
bool success = false;
QByteArray body = reply()->readAll();
int httpStatus = reply()->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
if( body.isEmpty() || httpStatus != 200) {
qDebug() << "error: status.php replied " << httpStatus << body;
emit instanceNotFound(reply());
} else {
QVariantMap status = QtJson::parse(QString::fromUtf8(body), success).toMap();
// empty or invalid response
if (!success || status.isEmpty()) {
qDebug() << "status.php from server is not valid JSON!";
}
qDebug() << "status.php returns: " << status << " " << reply()->error() << " Reply: " << reply();
if( status.contains("installed")
&& status.contains("version")
&& status.contains("versionstring") ) {
emit instanceFound(reply()->url(), status);
} else {
qDebug() << "No proper answer on " << reply()->url();
emit instanceNotFound(reply());
}
}
return true;
}
void TelescopeClientJsonRts2::telescopeGoto(const Vec3d &j2000Pos, StelObjectP selectObject)
{
if (!isConnected())
return;
QUrl set(baseurl);
set.setPath(baseurl.path() + "/api/cmd");
QUrlQuery query;
query.addQueryItem("d", telName);
bool commanded = false;
// if it's satellite, use move_tle
if (selectObject)
{
QVariantMap objectMap = selectObject->getInfoMap(StelApp::getInstance().getCore());
if (objectMap.contains("tle1") && objectMap.contains("tle2"))
{
query.addQueryItem("c", QString("move_tle+%22") + objectMap["tle1"].toString() + QString("%22+%22") + objectMap["tle2"].toString() + QString("%22"));
commanded = true;
}
}
if (commanded == false)
{
double ra, dec;
StelUtils::rectToSphe(&ra, &dec, j2000Pos);
query.addQueryItem("c", QString("move+%1+%2").arg(ra * 180 / M_PI).arg(dec * 180 / M_PI));
}
set.setQuery(query);
QNetworkRequest setR;
setR.setUrl(set);
qDebug() << "TelescopeRTS2(" << name << ")::telescopeGoto: request: " << set.toString();
networkManager.get(setR);
}
void NetworkManager::TunSetting::fromMap(const QVariantMap &setting)
{
if (setting.contains(QLatin1String(NM_SETTING_TUN_GROUP))) {
setGroup(setting.value(QLatin1String(NM_SETTING_TUN_GROUP)).toString());
}
if (setting.contains(QLatin1String(NM_SETTING_TUN_MODE))) {
setMode((Mode)setting.value(QLatin1String(NM_SETTING_TUN_MODE)).toUInt());
}
if (setting.contains(QLatin1String(NM_SETTING_TUN_MULTI_QUEUE))) {
setMultiQueue(setting.value(QLatin1String(NM_SETTING_TUN_MULTI_QUEUE)).toBool());
}
if (setting.contains(QLatin1String(NM_SETTING_TUN_OWNER))) {
setOwner(setting.value(QLatin1String(NM_SETTING_TUN_OWNER)).toString());
}
if (setting.contains(QLatin1String(NM_SETTING_TUN_PI))) {
setPi(setting.value(QLatin1String(NM_SETTING_TUN_PI)).toBool());
}
if (setting.contains(QLatin1String(NM_SETTING_TUN_VNET_HDR))) {
setVnetHdr(setting.value(QLatin1String(NM_SETTING_TUN_VNET_HDR)).toBool());
}
}
void
FdoNotifyPlugin::pushInfo( QString caller, Tomahawk::InfoSystem::InfoType type, QVariant pushData )
{
Q_UNUSED( caller );
qDebug() << Q_FUNC_INFO;
if ( type != Tomahawk::InfoSystem::InfoNotifyUser || !pushData.canConvert< QVariantMap >() )
{
qDebug() << Q_FUNC_INFO << " not the right type or could not convert the hash";
return;
}
QVariantMap hash = pushData.value< QVariantMap >();
if ( !hash.contains( "message" ) )
{
qDebug() << Q_FUNC_INFO << " hash did not contain a message";
return;
}
QDBusMessage message = QDBusMessage::createMethodCall( "org.freedesktop.Notifications", "/org/freedesktop/Notifications", "org.freedesktop.Notifications", "Notify" );
QList<QVariant> arguments;
arguments << QString( "Tomahawk" ); //app_name
arguments << quint32( 0 ); //notification_id
arguments << QString(); //app_icon
arguments << QString( "Tomahawk" ); //summary
arguments << hash["message"].toString(); //body
arguments << QStringList(); //actions
QVariantMap dict;
dict["desktop-entry"] = QString( "tomahawk" );
if ( hash.contains( "image" ) )
{
QVariant tempVariant = hash["image"];
QImage tempImage = tempVariant.value< QImage >();
dict["image_data"] = ImageConverter::variantForImage( tempImage );
}
else
dict["image_data"] = ImageConverter::variantForImage( QImage( RESPATH "icons/tomahawk-icon-128x128.png" ) );
arguments << dict; //hints
arguments << qint32( -1 ); //expire_timeout
message.setArguments( arguments );
QDBusConnection::sessionBus().send( message );
}
