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 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);
}
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();
}
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 DistroUpgrade::distroUpgrade(PackageKit::Transaction::DistroUpgrade type, const QString &name, const QString &description)
{
// TODO make use of the type
switch (m_configs[CFG_DISTRO_UPGRADE].toInt()) {
case Enum::DistroNever:
return;
case Enum::DistroStable:
if (type != Transaction::DistroUpgradeStable) {
// The user only wants to know about stable releases
return;
}
default:
break;
}
kDebug() << "Distro upgrade found!" << name << description;
if (m_shownDistroUpgrades.contains(name)) {
// ignore distro upgrade if the user already saw it
return;
}
KNotification *notify = new KNotification("DistroUpgradeAvailable", 0, KNotification::Persistent);
notify->setComponentName("apperd");
notify->setTitle(i18n("Distribution upgrade available"));
notify->setText(description);
QStringList actions;
actions << i18n("Start upgrade now");
notify->setActions(actions);
connect(notify, SIGNAL(activated(uint)),
this, SLOT(handleDistroUpgradeAction(uint)));
notify->sendEvent();
m_shownDistroUpgrades << name;
}
void WicdApplet::notify(const QString &event, const QString &message) const
{
if (m_status.State != 10) { //don't notify on startup
KNotification *notify = new KNotification(event);
notify->setText(message);
notify->setComponentData(KComponentData("wicd-kde"));
notify->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);
}
void ActivityList::dataUpdated(const QString& source, const Plasma::DataEngine::Data& data)
{
Q_UNUSED(source)
Q_ASSERT(m_engine);
int newItems = 0;
foreach(const QString& key, data.keys()) {
if (!data.value(key).value<Plasma::DataEngine::Data>().isEmpty()) {
if (m_knownEvents.contains(source + data[key].value<Plasma::DataEngine::Data>().value("id").toString())) {
continue;
}
QString id(source + data[key].value<Plasma::DataEngine::Data>().value("id").toString());
QDateTime time(data[key].value<Plasma::DataEngine::Data>().value("timestamp").toDateTime());
m_knownEvents.insert(id);
ActivityWidget* widget = new ActivityWidget(m_engine, m_container);
widget->setActivityData(data[key].value<Plasma::DataEngine::Data>());
int i;
for(i = 0; i < m_layout->count(); ++i) {
ActivityWidget* widget = static_cast<ActivityWidget*>(m_layout->itemAt(i));
if (time > widget->timestamp()) {
break;
}
}
m_layout->insertItem(i, widget);
++newItems;
}
}
while (m_layout->count() > m_limit) {
ActivityWidget* widget = static_cast<ActivityWidget*>(m_layout->itemAt(m_layout->count()-1));
m_layout->removeAt(m_layout->count()-1);
widget->deleteLater();
}
// Don't mass-spam the user with notifications
if (newItems < 4) {
for(int i = 0; i<newItems; ++i) {
ActivityWidget* widget = static_cast<ActivityWidget*>(m_layout->itemAt(i));
KNotification* notification = new KNotification("activity");
notification->setTitle("OpenDesktop Activities");
notification->setText(widget->message());
notification->setComponentData(KComponentData("plasma-applet-opendesktop-activities", "plasma-applet-opendesktop-activities", KComponentData::SkipMainComponentRegistration));
notification->sendEvent();
}
}
// Go to the top of the list
setScrollPosition(QPointF(0, 0));
}
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 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 EmoticonSetInstaller::showResult()
{
kDebug();
KNotification *notification = new KNotification(QLatin1String("emoticonsSuccess"), NULL, KNotification::Persistent);
notification->setText( i18n("Installed Emoticonset %1 successfully.", this->bundleName()) );
notification->setActions( QStringList() << i18n("OK") );
QObject::connect(notification, SIGNAL(action1Activated()), notification, SLOT(close()));
QObject::connect(notification, SIGNAL(ignored()), notification, SLOT(close()));
notification->sendEvent();
Q_EMIT showedResult();
}
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 KMixToolBox::notification(const char *notificationName, const QString &text,
const QStringList &actions, QObject *receiver,
const char *actionSlot)
{
KNotification *notification = new KNotification(notificationName);
//notification->setComponentData(componentData());
notification->setText(text);
//notification->setPixmap(...);
notification->addContext(QLatin1String("Application"), KGlobal::mainComponent().componentName());
if (!actions.isEmpty() && receiver && actionSlot) {
notification->setActions(actions);
QObject::connect(notification, SIGNAL(activated(uint)), receiver, actionSlot);
}
notification->sendEvent();
}
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 DhcpcdQt::notify(QString &title, QString &msg,
#ifdef NOTIFY
QSystemTrayIcon::MessageIcon
#else
QSystemTrayIcon::MessageIcon icon
#endif
)
{
#ifdef NOTIFY
KNotification *n = new KNotification("event", this);
n->setTitle(title);
n->setText(msg);
n->sendEvent();
#else
//trayIcon->showMessage(title, msg, icon);
#endif
}
void EmoticonSetInstaller::showRequest()
{
kDebug();
KNotification *notification = new KNotification(QLatin1String("emoticonsRequest"), NULL, KNotification::Persistent);
notification->setText( i18n("Install Emoticonset %1", this->bundleName()) );
notification->setActions( QStringList() << i18n("Install") << i18n("Cancel") );
QObject::connect(notification, SIGNAL(action1Activated()), this, SLOT(install()));
QObject::connect(notification, SIGNAL(action1Activated()), notification, SLOT(close()));
QObject::connect(notification, SIGNAL(ignored()), this, SLOT(ignoreRequest()));
QObject::connect(notification, SIGNAL(ignored()), notification, SLOT(close()));
QObject::connect(notification, SIGNAL(action2Activated()), this, SLOT(ignoreRequest()));
QObject::connect(notification, SIGNAL(action2Activated()), notification, SLOT(close()));
notification->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();
}
void AdiumxtraProtocolHandler::install()
{
if (m_url.isEmpty()) {
Q_EMIT finished();
return; // BundleInstaller:: xxxxx
}
QUrl url = QUrl::fromUserInput(m_url);
if(url.scheme() == QLatin1String("adiumxtra")) {
url.setScheme(QStringLiteral("http"));
}
QTemporaryFile *tmpFile = new QTemporaryFile();
if (tmpFile->open()) {
KIO::Job* getJob = KIO::file_copy(url, QUrl::fromLocalFile(tmpFile->fileName()), -1,
KIO::Overwrite | KIO::HideProgressInfo);
if (getJob->exec()) {
qWarning() << "Download failed";
Q_EMIT finished();
return; // BundleInstaller::BundleCannotOpen;
}
getJob->deleteLater();
}
KArchive *archive = 0L;
QMimeDatabase db;
QString currentBundleMimeType = db.mimeTypeForFile(tmpFile->fileName()).name();
if (currentBundleMimeType == QLatin1String("application/zip")) {
archive = new KZip(tmpFile->fileName());
} else if (currentBundleMimeType == QLatin1String("application/x-compressed-tar") ||
currentBundleMimeType == QLatin1String("application/x-bzip-compressed-tar") ||
currentBundleMimeType == QLatin1String("application/x-gzip") ||
currentBundleMimeType == QLatin1String("application/x-bzip")) {
archive = new KTar(tmpFile->fileName());
} else {
KNotification *notification = new KNotification(QLatin1String("packagenotrecognized"), NULL, KNotification::Persistent);
notification->setText( i18n("Package type not recognized or not supported") );
notification->setActions( QStringList() << i18n("OK") );
QObject::connect(notification, SIGNAL(action1Activated()), notification, SLOT(close()));
QObject::connect(notification, SIGNAL(ignored()), notification, SLOT(close()));
notification->setComponentName(ktelepathyComponentName());
notification->sendEvent();
qWarning() << "Unsupported file type" << currentBundleMimeType;
Q_EMIT finished();
return;// BundleInstaller::BundleNotValid;
}
if (!archive->open(QIODevice::ReadOnly)) {
delete archive;
qWarning() << "Cannot open theme file";
Q_EMIT finished();
return;// BundleInstaller::BundleCannotOpen;
}
ChatStyleInstaller *chatStyleInstaller = new ChatStyleInstaller(archive, tmpFile);
if (chatStyleInstaller->validate() == BundleInstaller::BundleValid) {
chatStyleInstaller->showRequest();
QObject::connect(chatStyleInstaller, SIGNAL(finished(BundleInstaller::BundleStatus)),
chatStyleInstaller, SLOT(showResult()));
QObject::connect(chatStyleInstaller, SIGNAL(showedResult()), this, SIGNAL(finished()));
QObject::connect(chatStyleInstaller, SIGNAL(showedResult()),
chatStyleInstaller, SLOT(deleteLater()));
QObject::connect(chatStyleInstaller, SIGNAL(ignoredRequest()), this, SIGNAL(finished()));
QObject::connect(chatStyleInstaller, SIGNAL(ignoredRequest()),
chatStyleInstaller, SLOT(deleteLater()));
return;// BundleInstaller::BundleValid;
}
delete chatStyleInstaller;
EmoticonSetInstaller *emoticonSetInstaller = new EmoticonSetInstaller(archive, tmpFile);
if(emoticonSetInstaller->validate() == BundleInstaller::BundleValid) {
emoticonSetInstaller->showRequest();
QObject::connect(emoticonSetInstaller, SIGNAL(finished(BundleInstaller::BundleStatus)),
emoticonSetInstaller, SLOT(showResult()));
QObject::connect(emoticonSetInstaller, SIGNAL(showedResult()), this, SIGNAL(finished()));
QObject::connect(emoticonSetInstaller, SIGNAL(showedResult()),
emoticonSetInstaller, SLOT(deleteLater()));
QObject::connect(emoticonSetInstaller, SIGNAL(ignoredRequest()), this, SIGNAL(finished()));
QObject::connect(emoticonSetInstaller, SIGNAL(ignoredRequest()),
emoticonSetInstaller, SLOT(deleteLater()));
return;// BundleInstaller::BundleValid;
}
delete emoticonSetInstaller;
KNotification *notification = new KNotification(QLatin1String("packagenotrecognized"),
NULL,
KNotification::Persistent);
notification->setText( i18n("Package type not recognized or not supported") );
QObject::connect(notification, SIGNAL(action1Activated()), notification, SLOT(close()));
QObject::connect(notification, SIGNAL(ignored()), notification, SLOT(close()));
notification->setActions( QStringList() << i18n("OK") );
notification->setComponentName(ktelepathyComponentName());
notification->sendEvent();
Q_EMIT finished();
return;// BundleInstaller::BundleUnknownError;
}
void PlanExecutor::notifyBackupSucceeded() {
KNotification *lNotification = new KNotification(QStringLiteral("BackupSucceeded"));
lNotification->setTitle(xi18nc("@title:window", "Backup Saved"));
lNotification->setText(xi18nc("@info notification", "Saving backup completed successfully."));
lNotification->sendEvent();
}