void KNotificationBackend::notify(const Notification &n)
{
    QString type;
    switch (n.type) {
    case Highlight:
        type = "Highlight"; break;
    case HighlightFocused:
        type = "HighlightFocused"; break;
    case PrivMsg:
        type = "PrivMsg"; break;
    case PrivMsgFocused:
        type = "PrivMsgFocused"; break;
    }

#if QT_VERSION < 0x050000
    QString message = QString("<b>&lt;%1&gt;</b> %2").arg(n.sender, Qt::escape(n.message));
#else
    QString message = QString("<b>&lt;%1&gt;</b> %2").arg(n.sender, n.message.toHtmlEscaped());
#endif
    KNotification *notification = KNotification::event(type, message, QIcon::fromTheme("dialog-information").pixmap(48), QtUi::mainWindow(),
        KNotification::RaiseWidgetOnActivation
        |KNotification::CloseWhenWidgetActivated
        |KNotification::CloseOnTimeout);
    connect(notification, SIGNAL(activated(uint)), SLOT(notificationActivated()));
    notification->setActions(QStringList("View"));
    notification->setProperty("notificationId", n.notificationId);

    _notifications.append(qMakePair(n.notificationId, QPointer<KNotification>(notification)));

    updateToolTip();
    QtUi::mainWindow()->systemTray()->setAlert(true);
}
Esempio n. 2
0
void OpenCalaisTextMatchPlugin::doGetPossibleMatches( const QString& text )
{
    kDebug();
    // cancel previous jobs
    delete m_lookupJob;
    m_lookupJob = 0;

    if ( OpenCalais::Config::licenseKey().isEmpty() ) {
        kDebug() << "no key";
        if ( OpenCalais::Config::showKeyWarning() ) {
            KNotification* n = KNotification::event( KNotification::Warning,
                               i18n( "No OpenCalais API key configured." ) );
            n->setActions( QStringList() << i18n( "Configure..." ) );
            connect( n, SIGNAL( action1Activated() ), this, SLOT( slotConfigure() ) );
            OpenCalais::Config::self()->findItem( "ShowKeyWarning" )->setProperty( false );
            OpenCalais::Config::self()->writeConfig();
        }
        emitFinished();
    }
    else {
        // do the lookup
        m_lookupJob = new OpenCalais::LookupJob( this );
        connect( m_lookupJob, SIGNAL( result( KJob* ) ),
                 this, SLOT( slotResult( KJob* ) ) );
        m_lookupJob->setContent( text );
        m_lookupJob->start();
    }
}
Esempio n. 3
0
void DistroUpgrade::handleDistroUpgradeAction(uint action)
{
    // get the sender cause there might be more than one
    KNotification *notify = qobject_cast<KNotification*>(sender());
    switch(action) {
        case 1:
            // Check to see if there isn't another process running
            if (m_distroUpgradeProcess) {
                // if so we BREAK otherwise our running count gets
                // lost, and we leak as we don't close the caller.
                break;
            }
            m_distroUpgradeProcess = new QProcess;
            connect (m_distroUpgradeProcess, SIGNAL(error(QProcess::ProcessError)),
                    this, SLOT(distroUpgradeError(QProcess::ProcessError)));
            connect (m_distroUpgradeProcess, SIGNAL(finished(int,QProcess::ExitStatus)),
                    this, SLOT(distroUpgradeFinished(int,QProcess::ExitStatus)));
            QStringList env = QProcess::systemEnvironment();
            env << "DESKTOP=kde";
            m_distroUpgradeProcess->setEnvironment(env);
            m_distroUpgradeProcess->start("/usr/share/PackageKit/pk-upgrade-distro.sh");
            // TODO
//             suppressSleep(true);
            break;
        // perhaps more actions needed in the future
    }
    // in persistent mode we need to manually close it
    notify->close();
}
Esempio n. 4
0
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;
}
Esempio n. 5
0
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 KNotificationBackend::notificationActivated()
{
    uint id = 0;
    KNotification *n = qobject_cast<KNotification *>(sender());
    if (n)
        id = n->property("notificationId").toUInt();

    notificationActivated(id);
}
Esempio n. 7
0
// to avoid additional object definition this method is static
void AWActions::sendNotification(const QString eventId, const QString message)
{
    qCDebug(LOG_AW) << "Event" << eventId << "with message" << message;

    KNotification *notification = KNotification::event(
        eventId, QString("Awesome Widget ::: %1").arg(eventId), message);
    notification->setComponentName(
        QString("plasma-applet-org.kde.plasma.awesome-widget"));
}
Esempio n. 8
0
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));
}
Esempio n. 9
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;
}
Esempio n. 10
0
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 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();
}
Esempio n. 12
0
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();
}
Esempio n. 15
0
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;
    }
}
Esempio n. 16
0
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();
}
Esempio n. 17
0
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;
}
Esempio n. 18
0
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);
}
Esempio n. 19
0
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();
}
Esempio n. 20
0
void KNotificationBackend::notify(const Notification& n)
{
    QString type;
    switch (n.type) {
    case Highlight:
        type = "Highlight";
        break;
    case HighlightFocused:
        type = "HighlightFocused";
        break;
    case PrivMsg:
        type = "PrivMsg";
        break;
    case PrivMsgFocused:
        type = "PrivMsgFocused";
        break;
    }

    QString message = QString("<b>&lt;%1&gt;</b> %2").arg(n.sender, n.message.toHtmlEscaped());
    KNotification* notification = KNotification::event(type,
                                                       message,
                                                       icon::get("dialog-information").pixmap(48),
                                                       QtUi::mainWindow(),
                                                       KNotification::RaiseWidgetOnActivation | KNotification::CloseWhenWidgetActivated
                                                           | KNotification::CloseOnTimeout);
    connect(notification,
            selectOverload<uint>(&KNotification::activated),
            this,
            selectOverload<>(&KNotificationBackend::notificationActivated));
    notification->setActions(QStringList("View"));
    notification->setProperty("notificationId", n.notificationId);

    _notifications.append(qMakePair(n.notificationId, QPointer<KNotification>(notification)));

    updateToolTip();
}
Esempio n. 21
0
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();
}
Esempio n. 22
0
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;
}
Esempio n. 23
0
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();
}
Esempio n. 24
0
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);
}
Esempio n. 25
0
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();
}
Esempio n. 26
0
void KDEIntegration::notifyError(const QString &msg)
{
    KNotification *n = KNotification::event(KNotification::Error, tr("Error"), msg, QPixmap(":/svg/qtnote"));
    n->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;
}
Esempio n. 28
0
void ChatWindow::messNotify()
{
  KNotification* notification = new KNotification("chat");
  notification->sendEvent();
  notification->deleteLater();
}