void Handler::activateConnection(const QString& connection, const QString& device, const QString& specificObject)
{
NetworkManager::Connection::Ptr con = NetworkManager::findConnection(connection);
if (!con) {
qCWarning(NM) << "Not possible to activate this connection";
return;
}
if (con->settings()->connectionType() == NetworkManager::ConnectionSettings::Vpn) {
NetworkManager::VpnSetting::Ptr vpnSetting = con->settings()->setting(NetworkManager::Setting::Vpn).staticCast<NetworkManager::VpnSetting>();
if (vpnSetting) {
// qCDebug(NM) << "Checking VPN" << con->name() << "type:" << vpnSetting->serviceType();
#if 0
// get the list of supported VPN service types
const KService::List services = KServiceTypeTrader::self()->query("PlasmaNetworkManagement/VpnUiPlugin",
QString::fromLatin1("[X-NetworkManager-Services]=='%1'").arg(vpnSetting->serviceType()));
if (services.isEmpty()) {
qCWarning(NM) << "VPN" << vpnSetting->serviceType() << "not found, skipping";
KNotification *notification = new KNotification("MissingVpnPlugin", KNotification::CloseOnTimeout, this);
notification->setComponentName("networkmanagement");
notification->setTitle(con->name());
notification->setText(i18n("Missing VPN plugin"));
notification->setPixmap(QIcon::fromTheme("dialog-warning").pixmap(KIconLoader::SizeHuge));
notification->sendEvent();
return;
}
#endif
}
}
#if WITH_MODEMMANAGER_SUPPORT
if (con->settings()->connectionType() == NetworkManager::ConnectionSettings::Gsm) {
NetworkManager::ModemDevice::Ptr nmModemDevice = NetworkManager::findNetworkInterface(device).objectCast<NetworkManager::ModemDevice>();
if (nmModemDevice) {
ModemManager::ModemDevice::Ptr mmModemDevice = ModemManager::findModemDevice(nmModemDevice->udi());
if (mmModemDevice) {
ModemManager::Modem::Ptr modem = mmModemDevice->interface(ModemManager::ModemDevice::ModemInterface).objectCast<ModemManager::Modem>();
NetworkManager::GsmSetting::Ptr gsmSetting = con->settings()->setting(NetworkManager::Setting::Gsm).staticCast<NetworkManager::GsmSetting>();
if (gsmSetting && gsmSetting->pinFlags() == NetworkManager::Setting::NotSaved &&
modem && modem->unlockRequired() > MM_MODEM_LOCK_NONE) {
QDBusInterface managerIface("org.kde.plasmanetworkmanagement", "/org/kde/plasmanetworkmanagement", "org.kde.plasmanetworkmanagement", QDBusConnection::sessionBus(), this);
managerIface.call("unlockModem", mmModemDevice->uni());
connect(modem.data(), &ModemManager::Modem::unlockRequiredChanged, this, &Handler::unlockRequiredChanged);
m_tmpConnectionPath = connection;
m_tmpDevicePath = device;
m_tmpSpecificPath = specificObject;
return;
}
}
}
}
#endif
QDBusPendingReply<QDBusObjectPath> reply = NetworkManager::activateConnection(connection, device, specificObject);
QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(reply, this);
watcher->setProperty("action", Handler::ActivateConnection);
watcher->setProperty("connection", con->name());
connect(watcher, &QDBusPendingCallWatcher::finished, this, &Handler::replyFinished);
}
QString Logger::path()
{
QDir dir;
QString path = KStandardDirs::locateLocal("data", "lancelot", true);
if (!path.endsWith('/')) {
path += '/';
}
path += "log/";
if (!dir.exists(path)) {
if (!dir.mkpath(path)) {
return QString();
}
KNotification * notify = new KNotification("UsageLoggingOn");
notify->setText(i18n("Usage logging is activated."));
notify->setPixmap(KIcon("view-history").pixmap(KIconLoader::SizeMedium, KIconLoader::SizeMedium));
notify->setActions(QStringList(i18n("Configure")));
QObject::connect(notify, SIGNAL(activated(uint)), Logger::self(), SLOT(configureMenu()));
notify->sendEvent();
}
QDate date = QDate::currentDate();
path += "log-" + QString::number(date.year())
+ '-' + QString::number(date.month());
return path;
}
void Notify::connectionFailed(const QString &title, BluezQt::PendingCall *call)
{
QString text;
switch (call->error()) {
case BluezQt::PendingCall::Failed:
if (call->errorText() == QLatin1String("Host is down")) {
text = i18nc("Notification when the connection failed due to Failed:HostIsDown",
"The device is unreachable");
} else {
text = i18nc("Notification when the connection failed due to Failed",
"Connection to the device failed");
}
break;
case BluezQt::PendingCall::NotReady:
text = i18nc("Notification when the connection failed due to NotReady",
"The device is not ready");
break;
default:
return;
}
KNotification *notification = new KNotification(QStringLiteral("ConnectionFailed"),
KNotification::CloseOnTimeout, this);
notification->setComponentName(QStringLiteral("bluedevil"));
notification->setPixmap(QIcon::fromTheme(QStringLiteral("dialog-warning")).pixmap(64));
notification->setTitle(title);
notification->setText(text);
notification->sendEvent();
}
void DistroUpgrade::distroUpgradeFinished(int exitCode, QProcess::ExitStatus exitStatus)
{
KNotification *notify = new KNotification("DistroUpgradeFinished");
notify->setComponentName("apperd");
if (exitStatus == QProcess::NormalExit && exitCode == 0) {
notify->setPixmap(KIcon("security-high").pixmap(64, 64));
notify->setText(i18n("Distribution upgrade finished. "));
} else if (exitStatus == QProcess::NormalExit) {
notify->setPixmap(KIcon("dialog-warning").pixmap(64, 64));
notify->setText(i18n("Distribution upgrade process exited with code %1.", exitCode));
}/* else {
notify->setText(i18n("Distribution upgrade didn't exit normally, the process probably crashed. "));
}*/
notify->sendEvent();
m_distroUpgradeProcess->deleteLater();
m_distroUpgradeProcess = 0;
// suppressSleep(false);
}
KNotification *KNotification::event(const QString &eventid, const QString &title, const QString &text,
const QPixmap &pixmap, QWidget *widget, const NotificationFlags &flags, const QString &componentName)
{
KNotification *notify = new KNotification(eventid, widget, flags);
notify->setTitle(title);
notify->setText(text);
notify->setPixmap(pixmap);
notify->setComponentName(flags & DefaultEvent ? QStringLiteral("plasma_workspace") : componentName);
QTimer::singleShot(0, notify, SLOT(sendEvent()));
return notify;
}
void JuK::coverDownloaded(const QPixmap &cover)
{
QString event(cover.isNull() ? "coverFailed" : "coverDownloaded");
KNotification *notification = new KNotification(event, this);
notification->setPixmap(cover);
notification->setFlags(KNotification::CloseOnTimeout);
if(cover.isNull())
notification->setText(i18n("Your album art failed to download."));
else
notification->setText(i18n("Your album art has finished downloading."));
notification->sendEvent();
}
void notifier_t::notify_reboot() {
KNotification* note = new KNotification("requestreboot",0L, KNotification::Persistent);
note->setTitle(i18n("Please reboot your system."));
note->setText(i18n("In order to complete this upgrade, you need to reboot your system."));
note->setPixmap(KIcon("system-reboot").pixmap(QSize(32,32)));
note->setComponentData(m_component_data);
note->setActions(QStringList()
<< i18nc("Do the proposed action (upgrade, reboot, etc) later", "Later")
<< i18nc("Reboot the system", "Reboot"));
connect(note,SIGNAL(closed()),m_reboot_nagger,SLOT(start()));
connect(note,SIGNAL(action1Activated()),m_reboot_nagger,SLOT(start()));
connect(note,SIGNAL(action2Activated()),SLOT(reboot()));
note->sendEvent();
}
void notifier_t::show_update_notification(const QString& title, const QString& message, const QString& iconname) {
if(m_upgrade_notification) {
m_upgrade_notification.data()->close();
}
KNotification* note = new KNotification("updatesavailable",0L, KNotification::Persistent);
note->setTitle(title);
note->setText(message);
note->setPixmap(KIcon(iconname).pixmap(QSize(32,32)));
note->setComponentData(m_component_data);
note->setActions(QStringList()
<< i18nc("Do the proposed action (upgrade, reboot, etc) later", "Later"));
note->sendEvent();
m_upgrade_notification=note;
return;
}
void lemon::reactOnLogOn()
{
if (m_view->canStartSelling())
enableUi();
else {
disableUi();
QString msg = i18n("Administrator or Supervisor needs to start operation before you can start selling...");
//Show a dialog saying that operations need to be started by admin ???
if (m_view->getLoggedUserRole() == roleBasic ) {
KNotification *notify = new KNotification("information", this);
notify->setText(msg);
QPixmap pixmap = DesktopIcon("dialog-information",48);
notify->setPixmap(pixmap);
notify->sendEvent();
}
}
}
void Logger::Private::openFile()
{
if (file) {
return;
}
file = new QFile(Logger::path());
if (file->open(QIODevice::WriteOnly | QIODevice::Unbuffered | QIODevice::Append)) {
stream = new QDataStream(file);
stream->setVersion(QDataStream::Qt_4_0);
} else {
KNotification * notify = new KNotification("ErrorOpeningLog");
notify->setText(i18n("Failed to open the log file. Logging is disabled."));
notify->setPixmap(KIcon("view-history").pixmap(KIconLoader::SizeMedium, KIconLoader::SizeMedium));
notify->sendEvent();
// Show error message
delete file;
}
}
void DistroUpgrade::distroUpgradeError(QProcess::ProcessError error)
{
QString text;
KNotification *notify = new KNotification("DistroUpgradeError");
notify->setComponentName("apperd");
switch(error) {
case QProcess::FailedToStart:
text = i18n("The distribution upgrade process failed to start.");
break;
case QProcess::Crashed:
text = i18n("The distribution upgrade process crashed some time after starting successfully.") ;
break;
default:
text = i18n("The distribution upgrade process failed with an unknown error.");
break;
}
notify->setPixmap(KIcon("dialog-error").pixmap(64,64));
notify->setText(text);
notify->sendEvent();
}