File indexing completed on 2024-04-14 03:54:12

 /*
     This file is part of the KDE libraries
     SPDX-FileCopyrightText: 2005-2006 Olivier Goffart <ogoffart at kde.org>
     SPDX-FileCopyrightText: 2013-2015 Martin Klapetek <mklapetek@kde.org>
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #ifndef KNOTIFICATION_H
 #define KNOTIFICATION_H
 
 #include <knotifications_export.h>
 
 #include <QList>
 #include <QObject>
 #include <QPair>
 #include <QPixmap>
 #include <QUrl>
 #include <QVariant>
 #include <QWindow>
 
 #include <memory>
 
 class KNotificationReplyAction;
 class KNotificationAction;
 
 class KNotificationActionPrivate;
 
 /**
  * @class KNotificationAction knotification.h KNotificationAction
  *
  * This class represents a notification. This can be a button on the notification
  * popup, or triggered by clicking the notification popup itself.
  *
  * @since 6.0
  */
 class KNOTIFICATIONS_EXPORT KNotificationAction : public QObject
 {
     Q_OBJECT
     /**
      * @copydoc label
      */
     Q_PROPERTY(QString label READ label WRITE setLabel NOTIFY labelChanged)
 
 public:
     explicit KNotificationAction(QObject *parent = nullptr);
 
     /**
      * Creates an action with given label
      * @param label The label for the action
      */
     explicit KNotificationAction(const QString &label);
 
     ~KNotificationAction() override;
 
     /**
      * The user-facing label for the action
      */
     QString label() const;
 
     /**
      * Set the user-facing label for the action
      */
     void setLabel(const QString &label);
 
 Q_SIGNALS:
     /**
      * Emitted when the user activates the action
      */
     void activated();
 
     /**
      * Emitted when @p label changed.
      */
     void labelChanged(const QString &label);
 
 private:
     friend class KNotification;
     friend class NotifyByPortalPrivate;
     friend class NotifyByPopup;
     friend class NotifyBySnore;
     friend class NotifyByAndroid;
 
     void setId(const QString &id);
     QString id() const;
 
     std::unique_ptr<KNotificationActionPrivate> const d;
 };
 
 /**
  * @class KNotification knotification.h KNotification
  *
  * KNotification is the main class for creating notifications.
  */
 class KNOTIFICATIONS_EXPORT KNotification : public QObject
 {
     Q_OBJECT
     /**
      * @copydoc setEventId
      * @since 5.88
      */
     Q_PROPERTY(QString eventId READ eventId WRITE setEventId NOTIFY eventIdChanged)
     /**
      * @copydoc setTitle
      * @since 5.88
      */
     Q_PROPERTY(QString title READ title WRITE setTitle NOTIFY titleChanged)
     /**
      * @copydoc setText
      * @since 5.88
      */
     Q_PROPERTY(QString text READ text WRITE setText NOTIFY textChanged)
     /**
      * @copydoc setIconName
      * @since 5.88
      */
     Q_PROPERTY(QString iconName READ iconName WRITE setIconName NOTIFY iconNameChanged)
     /**
      * @copydoc setFlags
      * @since 5.88
      */
     Q_PROPERTY(NotificationFlags flags READ flags WRITE setFlags NOTIFY flagsChanged)
     /**
      * @copydoc setComponentName
      * @since 5.88
      */
     Q_PROPERTY(QString componentName READ componentName WRITE setComponentName NOTIFY componentNameChanged)
     /**
      * @copydoc setUrls
      * @since 5.88
      */
     Q_PROPERTY(QList<QUrl> urls READ urls WRITE setUrls NOTIFY urlsChanged)
     /**
      * @copydoc setUrgency
      * @since 5.88
      */
     Q_PROPERTY(Urgency urgency READ urgency WRITE setUrgency NOTIFY urgencyChanged)
     /**
      * @copydoc setAutoDelete
      * @since 5.88
      */
     Q_PROPERTY(bool autoDelete READ isAutoDelete WRITE setAutoDelete NOTIFY autoDeleteChanged)
     /**
      * @since 5.90
      */
     Q_PROPERTY(QString xdgActivationToken READ xdgActivationToken NOTIFY xdgActivationTokenChanged)
     /**
      * @copydoc setHint
      * @since 5.101
      */
     Q_PROPERTY(QVariantMap hints READ hints WRITE setHints NOTIFY hintsChanged)
 
 public:
     /**
      * @see NotificationFlags
      */
     enum NotificationFlag {
         /**
          * The notification will be automatically closed after a timeout. (this is the default)
          */
         CloseOnTimeout = 0x00,
 
         /**
          * The notification will NOT be automatically closed after a timeout.
          * You will have to track the notification, and close it with the
          * close function manually when the event is done, otherwise there will be a memory leak
          */
         Persistent = 0x02,
 
         /**
          * The audio plugin will loop the sound until the notification is closed
          */
         LoopSound = 0x08,
 
         /**
          * Sends a hint to Plasma to skip grouping for this notification
          *
          * @since 5.18
          */
         SkipGrouping = 0x10,
 
         /**
          * The notification will be automatically closed if the window() becomes
          * activated.
          *
          * You need to set a window using setWindow().
          *
          * @since 6.0
          */
         CloseWhenWindowActivated = 0x20,
 
         /**
          * @internal
          * The event is a standard kde event, and not an event of the application
          */
         DefaultEvent = 0xF000,
 
     };
 
     /**
      * Stores a combination of #NotificationFlag values.
      */
     Q_DECLARE_FLAGS(NotificationFlags, NotificationFlag)
     Q_FLAG(NotificationFlags)
 
     /**
      * default events you can use in the event function
      */
     enum StandardEvent {
         Notification,
         Warning,
         Error,
         Catastrophe,
     };
 
     /**
      * The urgency of a notification.
      *
      * @since 5.58
      * @sa setUrgency
      */
     enum Urgency {
         DefaultUrgency = -1,
         LowUrgency = 10,
         NormalUrgency = 50,
         HighUrgency = 70,
         CriticalUrgency = 90,
     };
     Q_ENUM(Urgency)
 
     /**
      * Create a new notification.
      *
      * You have to use sendEvent to show the notification.
      *
      * The pointer is automatically deleted when the event is closed.
      *
      * @since 4.4
      *
      * @param eventId is the name of the event
      * @param flags is a bitmask of NotificationFlag
      * @param parent parent object
      */
     explicit KNotification(const QString &eventId, NotificationFlags flags = CloseOnTimeout, QObject *parent = nullptr);
 
     ~KNotification() override;
 
     /**
      * @return the name of the event
      */
     QString eventId() const;
     /**
      * Set the event id, if not already passed to the constructor.
      * @since 5.88
      */
     void setEventId(const QString &eventId);
 
     /**
      * @return the notification title
      * @see setTitle
      * @since 4.3
      */
     QString title() const;
 
     /**
      * Set the title of the notification popup.
      * If no title is set, the application name will be used.
      *
      * @param title The title of the notification
      * @since 4.3
      */
     void setTitle(const QString &title);
 
     /**
      * @return the notification text
      * @see setText
      */
     QString text() const;
 
     /**
      * Set the notification text that will appear in the popup.
      *
      * In Plasma workspace, the text is shown in a QML label which uses Text.StyledText,
      * ie. it supports a small subset of HTML entities (mostly just formatting tags)
      *
      * If the notifications server does not advertise "body-markup" capability,
      * all HTML tags are stripped before sending it to the server
      *
      * @param text The text to display in the notification popup
      */
     void setText(const QString &text);
 
     /**
      * \return the icon shown in the popup
      * \see setIconName
      * \since 5.4
      */
     QString iconName() const;
 
     /**
      * Set the icon that will be shown in the popup.
      *
      * @param icon the icon
      * @since 5.4
      */
     void setIconName(const QString &icon);
 
     /**
      * \return the pixmap shown in the popup
      * \see setPixmap
      */
     QPixmap pixmap() const;
     /**
      * Set the pixmap that will be shown in the popup. If you want to use an icon from the icon theme use setIconName instead.
      *
      * @param pix the pixmap
      */
     void setPixmap(const QPixmap &pix);
 
     /**
      * @return the default action, or nullptr if none is set
      * @since 6.0
      */
     KNotificationAction *defaultAction() const;
 
     /**
      * Add a default action that will be triggered when the notification is
      * activated (typically, by clicking on the notification popup). The default
      * action typically raises a window belonging to the application that sent it.
      *
      * The string will be used as a label for the action, so ideally it should
      * be wrapped in i18n() or tr() calls.
      *
      * The visual representation of actions depends on the notification server.
      * In Plasma and Gnome desktops, the actions are performed by clicking on
      * the notification popup, and the label is not presented to the user.
      *
      * Calling this overrides the current default action
      *
      * @since 6.0
      */
     [[nodiscard]] KNotificationAction *addDefaultAction(const QString &label);
 
     /**
      * Add an action to the notification.
      *
      * The visual representation of actions depends
      * on the notification server.
      *
      * @param label the user-visible label of the action
      *
      * @see KNotificationAction
      *
      * @since 6.0
      */
     [[nodiscard]] KNotificationAction *addAction(const QString &label);
 
     /**
      * Removes all actions previously added by addAction()
      * from the notification.
      *
      * @see addAction
      *
      * @since 6.0
      */
     void clearActions();
 
     /**
      * @return the inline reply action.
      * @since 5.81
      */
     KNotificationReplyAction *replyAction() const;
 
     /**
      * @brief Add an inline reply action to the notification.
      *
      * On supported platforms this lets the user type a reply to a notification,
      * such as replying to a chat message, from the notification popup, for example:
      *
      * @code{.cpp}
      * KNotification *notification = new KNotification(QStringLiteral("notification"));
      * ...
      * auto replyAction = std::make_unique<KNotificationReplyAction>(i18nc("@action:button", "Reply"));
      * replyAction->setPlaceholderText(i18nc("@info:placeholder", "Reply to Dave..."));
      * QObject::connect(replyAction.get(), &KNotificationReplyAction::replied, [](const QString &text) {
      *     qDebug() << "you replied with" << text;
      * });
      * notification->setReplyAction(std::move(replyAction));
      * @endcode
      *
      * @param replyAction the reply action to set
      * @since 5.81
      */
     void setReplyAction(std::unique_ptr<KNotificationReplyAction> replyAction);
 
     /**
      * @return the notification flags.
      */
     NotificationFlags flags() const;
 
     /**
      * Set the notification flags.
      * These must be set before calling sendEvent()
      */
     void setFlags(const NotificationFlags &flags);
 
     /**
      * Returns the component name used to determine the location of the configuration file.
      * @since 5.88
      */
     QString componentName() const;
     /**
      * The componentData is used to determine the location of the config file.
      *
      * If no componentName is set, the app name is used by default
      *
      * @param componentName the new component name
      */
     void setComponentName(const QString &componentName);
 
     /**
      * URLs associated with this notification
      * @since 5.29
      */
     QList<QUrl> urls() const;
 
     /**
      * Sets URLs associated with this notification
      *
      * For example, a screenshot application might want to provide the
      * URL to the file that was just taken so the notification service
      * can show a preview.
      *
      * @note This feature might not be supported by the user's notification service
      *
      * @param urls A list of URLs
      * @since 5.29
      */
     void setUrls(const QList<QUrl> &urls);
 
     /**
      * The urgency of the notification.
      * @since 5.58
      */
     Urgency urgency() const;
 
     /**
      * Sets the urgency of the notification.
      *
      * This defines the importance of the notification. For example,
      * a track change in a media player would be a low urgency.
      * "You have new mail" would be normal urgency. "Your battery level
      * is low" would be a critical urgency.
      *
      * Use critical notifications with care as they might be shown even
      * when giving a presentation or when notifications are turned off.
      *
      * @param urgency The urgency.
      * @since 5.58
      */
     void setUrgency(Urgency urgency);
 
     /**
      * Sets the window associated with this notification.
      * This is relevant when using the CloseWhenWindowActivated flag.
      *
      * @since 6.0
      */
     void setWindow(QWindow *window);
 
     /**
      * The window associated with this notification. nullptr by default.
      * @return the window set by setWindow()
      *
      * @since 6.0
      */
     QWindow *window() const;
 
     /**
      * @internal
      * appname used for the D-Bus object
      */
     QString appName() const;
 
     /**
      * Returns whether this notification object will be automatically deleted after closing.
      * @since 5.88
      */
     bool isAutoDelete() const;
     /**
      * Sets whether this notification object will be automatically deleted after closing.
      * This is on by default for C++, and off by default for QML.
      * @since 5.88
      */
     void setAutoDelete(bool autoDelete);
 
     /**
      * Returns the activation token to use to activate a window.
      * @since 5.90
      */
     QString xdgActivationToken() const;
 
 Q_SIGNALS:
     /**
      * Emitted when the notification is closed.
      *
      * Can be closed either by the user clicking the close button,
      * the timeout running out or when an action was triggered.
      */
     void closed();
 
     /**
      * The notification has been ignored
      */
     void ignored();
 
     /**
      * Emitted when @c eventId changed.
      * @since 5.88
      */
     void eventIdChanged();
     /**
      * Emitted when @c title changed.
      * @since 5.88
      */
     void titleChanged();
     /**
      * Emitted when @c text changed.
      * @since 5.88
      */
     void textChanged();
     /**
      * Emitted when @c iconName changed.
      * @since 5.88
      */
     void iconNameChanged();
     /**
      * Emitted when @c defaultAction changed.
      * @since 5.88
      */
     void defaultActionChanged();
     /**
      * Emitted when @c actions changed.
      * @since 5.88
      */
     void actionsChanged();
     /**
      * Emitted when @p flags changed.
      * @since 5.88
      */
     void flagsChanged();
     /**
      * Emitted when @p componentName changed.
      * @since 5.88
      */
     void componentNameChanged();
     /**
      * Emitted when @p urls changed.
      * @since 5.88
      */
     void urlsChanged();
     /**
      * Emitted when @p urgency changed.
      * @since 5.88
      */
     void urgencyChanged();
     /**
      * Emitted when @p autoDelete changed.
      * @since 5.88
      */
     void autoDeleteChanged();
     /**
      * Emitted when @p xdgActivationToken changes.
      * @since 5.90
      */
     void xdgActivationTokenChanged();
     /**
      * Emitted when @p hints changes.
      * @since 5.101
      */
     void hintsChanged();
 
 public Q_SLOTS:
     /**
      * Close the notification without activating it.
      *
      * This will delete the notification.
      */
     void close();
 
     /**
      * Send the notification to the server.
      *
      * This will cause all the configured plugins to execute their actions on this notification
      * (eg. a sound will play, a popup will show, a command will be executed etc).
      */
     void sendEvent();
 
     /**
      * @since 5.57
      * Adds a custom hint to the notification. Those are key-value pairs that can be interpreted by the respective notification backend to trigger additional,
      * non-standard features.
      * @param hint the hint's key
      * @param value the hint's value
      */
     Q_INVOKABLE void setHint(const QString &hint, const QVariant &value);
 
     /**
      * @since 5.57
      * Returns the custom hints set by setHint()
      */
     QVariantMap hints() const;
 
     /**
      * @since 5.101
      * Set custom hints on the notification.
      * @sa setHint
      */
     void setHints(const QVariantMap &hints);
 
 private:
     friend class KNotificationManager;
     friend class NotificationWrapper;
     friend class NotifyByPopup;
     friend class NotifyByPortal;
     friend class NotifyByPortalPrivate;
     friend class NotifyByExecute;
     friend class NotifyBySnore;
     friend class NotifyByAndroid;
     friend class NotifyByMacOSNotificationCenter;
     struct Private;
 
     KNOTIFICATIONS_NO_EXPORT void slotWindowActiveChanged();
 
     /**
      * @brief Activate the action specified action
      * If the action is zero, then the default action is activated
      */
     KNOTIFICATIONS_NO_EXPORT void activate(const QString &action);
 
     /**
      * @internal
      * the id given by the notification manager
      */
     KNOTIFICATIONS_NO_EXPORT int id();
 
     /**
      * @internal
      * update the texts, the icon, and the actions of one existing notification
      */
     KNOTIFICATIONS_NO_EXPORT void update();
 
     /**
      * The notification will automatically be closed if all presentations are finished.
      * if you want to show your own presentation in your application, you should use this
      * function, so it will not be automatically closed when there is nothing to show.
      *
      * Don't forgot to deref, or the notification may be never closed if there is no timeout.
      *
      * @see deref
      */
     KNOTIFICATIONS_NO_EXPORT void ref();
 
     /**
      * Remove a reference made with ref(). If the ref counter hits zero,
      * the notification will be closed and deleted.
      *
      * @see ref
      */
     KNOTIFICATIONS_NO_EXPORT void deref();
 
     // Like setActions, but doesn't take ownership
     void setActionsQml(QList<KNotificationAction *> actions);
     void setDefaultActionQml(KNotificationAction *action);
     QList<KNotificationAction *> actions() const;
 
     static QString standardEventToEventId(StandardEvent event);
     static QString standardEventToIconName(StandardEvent event);
 
     std::unique_ptr<Private> const d;
 
 public:
     /**
      * @brief emit an event
      *
      * This method creates the KNotification, setting every parameter, and fire the event.
      * You don't need to call sendEvent
      *
      * A popup may be displayed or a sound may be played, depending the config.
      *
      * @return a KNotification .  You may use that pointer to connect some signals or slot.
      * the pointer is automatically deleted when the event is closed.
      *
      * @param eventId is the name of the event
      * @param title is title of the notification to show in the popup.
      * @param text is the text of the notification to show in the popup.
      * @param pixmap is a picture which may be shown in the popup.
      * @param flags is a bitmask of NotificationFlag
      * @param componentName used to determine the location of the config file.  by default, appname is used
      * @since 4.4
      */
     static KNotification *event(const QString &eventId,
                                 const QString &title,
                                 const QString &text,
                                 const QPixmap &pixmap = QPixmap(),
                                 const NotificationFlags &flags = CloseOnTimeout,
                                 const QString &componentName = QString());
 
     /**
      * @brief emit a standard event
      *
      * @overload
      *
      * This will emit a standard event
      *
      * @param eventId is the name of the event
      * @param text is the text of the notification to show in the popup.
      * @param pixmap is a picture which may be shown in the popup.
      * @param flags is a bitmask of NotificationFlag
      * @param componentName used to determine the location of the config file.  by default, plasma_workspace is used
      */
     static KNotification *event(const QString &eventId,
                                 const QString &text = QString(),
                                 const QPixmap &pixmap = QPixmap(),
                                 const NotificationFlags &flags = CloseOnTimeout,
                                 const QString &componentName = QString());
 
     /**
      * @brief emit a standard event
      *
      * @overload
      *
      * This will emit a standard event
      *
      * @param eventId is the name of the event
      * @param text is the text of the notification to show in the popup
      * @param pixmap is a picture which may be shown in the popup
      * @param flags is a bitmask of NotificationFlag
      */
     static KNotification *
     event(StandardEvent eventId, const QString &text = QString(), const QPixmap &pixmap = QPixmap(), const NotificationFlags &flags = CloseOnTimeout);
 
     /**
      * @brief emit a standard event
      *
      * @overload
      *
      * This will emit a standard event
      *
      * @param eventId is the name of the event
      * @param title is title of the notification to show in the popup.
      * @param text is the text of the notification to show in the popup
      * @param pixmap is a picture which may be shown in the popup
      * @param flags is a bitmask of NotificationFlag
      * @since 4.4
      */
     static KNotification *
     event(StandardEvent eventId, const QString &title, const QString &text, const QPixmap &pixmap, const NotificationFlags &flags = CloseOnTimeout);
 
     /**
      * @brief emit a standard event with the possibility of setting an icon by icon name
      *
      * @overload
      *
      * This will emit a standard event
      *
      * @param eventId is the name of the event
      * @param title is title of the notification to show in the popup.
      * @param text is the text of the notification to show in the popup
      * @param iconName a Freedesktop compatible icon name to be shown in the popup
      * @param flags is a bitmask of NotificationFlag
      * @param componentName used to determine the location of the config file.  by default, plasma_workspace is used
      * @since 5.4
      */
     static KNotification *event(const QString &eventId,
                                 const QString &title,
                                 const QString &text,
                                 const QString &iconName,
                                 const NotificationFlags &flags = CloseOnTimeout,
                                 const QString &componentName = QString());
 
     /**
      * @brief emit a standard event with the possibility of setting an icon by icon name
      *
      * @overload
      *
      * This will emit a standard event with a custom icon
      *
      * @param eventId the type of the standard (not app-defined) event
      * @param title is title of the notification to show in the popup.
      * @param text is the text of the notification to show in the popup
      * @param iconName a Freedesktop compatible icon name to be shown in the popup
      * @param flags is a bitmask of NotificationFlag
      * @since 5.9
      */
     static KNotification *
     event(StandardEvent eventId, const QString &title, const QString &text, const QString &iconName, const NotificationFlags &flags = CloseOnTimeout);
 
     /**
      * @brief emit a standard event
      *
      * @overload
      *
      * This will emit a standard event with its standard icon
      *
      * @param eventId the type of the standard (not app-defined) event
      * @param title is title of the notification to show in the popup.
      * @param text is the text of the notification to show in the popup
      * @param flags is a bitmask of NotificationFlag
      * @since 5.9
      */
     static KNotification *event(StandardEvent eventId, const QString &title, const QString &text, const NotificationFlags &flags = CloseOnTimeout);
 
     /**
      * This is a simple substitution for QApplication::beep()
      *
      * @param reason a short text explaining what has happened (may be empty)
      */
     static void beep(const QString &reason = QString());
 
     // prevent warning
     using QObject::event;
 };
 
 Q_DECLARE_OPERATORS_FOR_FLAGS(KNotification::NotificationFlags)
 
 #endif