LXMusicNotification lxmusic_do_notify_prepare(const gchar *artist, const gchar *title, const char *summary, GtkStatusIcon *status_icon)
{
#if HAVE_LIBNOTIFY
if (!notify_is_initted ())
notify_init ("LXMusic");
GString* message = g_string_new("");
if ( (artist != NULL) && (title != NULL ) ) {
/* metadata available */
g_string_append_printf(message, "<b>%s: </b><i>%s</i>", _("Artist"), artist );
g_string_append_printf(message, "\n<b>%s: </b><i>%s</i>", _("Title"), title );
}
/* use filename without markup */
else
g_string_append( message, title );
struct _LXMusicNotification *lxn = g_new ( struct _LXMusicNotification, 1);
#if !defined(NOTIFY_VERSION_MINOR) || (NOTIFY_VERSION_MAJOR == 0 && NOTIFY_VERSION_MINOR < 7)
lxn->notify = notify_notification_new (summary, message->str, NULL, NULL);
#else
lxn->notify = notify_notification_new (summary, message->str, NULL);
#endif
notify_notification_set_urgency (lxn->notify, NOTIFY_URGENCY_NORMAL);
#if !defined(NOTIFY_VERSION_MINOR) || (NOTIFY_VERSION_MAJOR == 0 && NOTIFY_VERSION_MINOR < 7)
notify_notification_attach_to_status_icon( lxn->notify, status_icon );
#endif
notify_notification_set_timeout (lxn->notify, NOTIFY_EXPIRES_DEFAULT);
g_string_free( message, TRUE );
return lxn;
#endif /* HAVE_LIBNOTIFY */
}
static void SendNotification(PianoSong_t *song) {
NotifyNotification *songNotification;
char coverArtWgetBuffer[512];
char coverArtLocation[256];
char *coverArtURL;
int result;
// if there is no cover art, download the no album art image
// TODO: cache this image
coverArtURL = *song->coverArt == '\0' ? "http://www.pandora.com/images/no_album_art.jpg" : song->coverArt;
snprintf(coverArtLocation, 256, "/tmp/%llu-coverArt.jpg", (unsigned long long) getpid());
snprintf(coverArtWgetBuffer, 512, "wget --quiet -O %s %s", coverArtLocation, coverArtURL);
result = system(coverArtWgetBuffer);
songNotification = notify_notification_new(song->artist,
song->title,
coverArtLocation,
NULL);
notify_notification_set_timeout(songNotification, 3000);
notify_notification_set_urgency(songNotification, NOTIFY_URGENCY_CRITICAL);
GError *error = NULL;
notify_notification_show(songNotification,&error);
g_object_unref(G_OBJECT(songNotification));
free(error);
}
static void
create_new_gnome_notification(gchar *title, gchar *body, NotifyUrgency urgency, gint timeout)
{
#if USE_NOTIFY
GnomeNotification notif;
if (eel_gconf_get_integer(NOTIFY_ALL)) {
notify_init("SFLphone");
// Set struct fields
notif.notification = notify_notification_new(title, body, NULL);
notif.icon = gdk_pixbuf_new_from_file(LOGO_SMALL, NULL);
notify_notification_set_urgency(notif.notification, urgency);
if (notif.icon != NULL)
notify_notification_set_icon_from_pixbuf(notif.notification, notif.icon);
else
ERROR("notify(), cannot load notification icon");
notify_notification_set_timeout(notif.notification, timeout);
if (!notify_notification_show(notif.notification, NULL)) {
ERROR("notify(), failed to send notification");
}
}
g_free(title);
g_free(body);
#endif
}
static void
show_notification(MnpAlarmInstance *alarm)
{
MnpAlarmInstancePrivate *priv = ALARM_INSTANCE_PRIVATE(alarm);
gboolean once = FALSE;
NotifyNotification *notify;
char *string;
MnpAlarmItem *item = priv->item;
if (!once) {
once = TRUE;
notify_init(_("Alarm Notify"));
}
string = g_strdup_printf(_("Alarm at %d:%.2d %s"), item->hour, item->minute, item->am_pm ? _("am") : _("pm"));
#ifdef HAVE_NOTIFY_0_7
notify = notify_notification_new(_("Dawati Alarm Notify"), string, NULL);
#else
notify = notify_notification_new(_("Dawati Alarm Notify"), string, NULL, NULL);
#endif
notify_notification_set_timeout(notify,10000);
notify_notification_set_category(notify,_("AlarmNotifications"));
notify_notification_set_urgency (notify,NOTIFY_URGENCY_CRITICAL);
notify_notification_show(notify,NULL);
g_free(string);
}
void DesktopNotifierLinux::showNotification(const std::string& notification_title, const std::string& notification_message, const std::string& notification_type)
{
LL_INFOS("DesktopNotifierLinux") << "New notification title: " << notification_title << LL_ENDL;
LL_INFOS("DesktopNotifierLinux") << "New notification message: " << notification_message << LL_ENDL;
LL_INFOS("DesktopNotifierLinux") << "New notification type: " << notification_type << LL_ENDL;
static NotifyNotification* notification = notify_notification_new(
"Emerald Viewer",//(gchar*)notification_title.c_str(),
NULL,//(gchar*)notification_message.c_str(),
icon_wholename,
NULL
);
notify_notification_update(
notification,
(gchar*)notification_title.c_str(),
(gchar*)notification_message.c_str(),
icon_wholename
);
notify_notification_set_urgency(notification, NOTIFY_URGENCY_LOW);
notify_notification_set_category(notification, (gchar*)notification_type.c_str());
notify_notification_set_timeout(notification, NOTIFICATION_TIMEOUT_MS); // NotifyOSD ignores this, sadly.
GError* error = NULL;
if (notify_notification_show(notification, &error)) {
LL_INFOS("DesktopNotifierLinux") << "Linux desktop notification type " << notification_type << "sent." << LL_ENDL;
} else {
LL_WARNS("DesktopNotifierLinux") << "Linux desktop notification FAILED to send. " << error->message << LL_ENDL;
}
}
static void
add_notify (char *summary, char *message)
{
NotifyNotification *notify = NULL;
GError *error = NULL;
gchar *escaped;
escaped = g_markup_escape_text (message, strlen(message));
notify = notify_notification_new (summary, escaped, NULL);
notify_notification_set_urgency (notify, NOTIFY_URGENCY_NORMAL);
notify_notification_set_icon_from_pixbuf (notify, notify_icon);
if (notify_manager_has_capability ("x-canonical-append"))
notify_notification_set_hint_string(notify, "x-canonical-append", "");
if (!notify_notification_show (notify, &error)) {
g_warning (_("Failed to send notification: %s\n"), error->message);
g_error_free (error);
return;
}
notifications = g_slist_prepend (notifications, notify);
g_free (escaped);
}
static void
nemo_main_application_notify_unmount_show (NemoApplication *application,
const gchar *message)
{
NemoMainApplication *app = NEMO_MAIN_APPLICATION (application);
gchar **strings;
strings = g_strsplit (message, "\n", 0);
if (!app->priv->unmount_notify) {
app->priv->unmount_notify = notify_notification_new (strings[0], strings[1],
"media-removable");
notify_notification_set_hint (app->priv->unmount_notify,
"transient", g_variant_new_boolean (TRUE));
notify_notification_set_urgency (app->priv->unmount_notify,
NOTIFY_URGENCY_CRITICAL);
} else {
notify_notification_update (app->priv->unmount_notify,
strings[0], strings[1],
"media-removable");
}
notify_notification_show (app->priv->unmount_notify, NULL);
g_strfreev (strings);
}
int notification_show(char *title, char *body, char *icon)
{
GError *error = NULL;
NotifyNotification *notify_p;
if (title == NULL)
return -1;
//you should init notify using app's name
if(notify_is_initted() == FALSE)
if(notify_init("argv[0]") == FALSE){
return -1;
}
notify_p = notify_notification_new(title, body, icon, NULL);
//miliseconds, NOTIFY_EXPIRES_DEFAULT NOTIFY_EXPIRES_NEVER
notify_notification_set_timeout(notify_p, 1000);
//NOTIFY_URGENCY_LOW,NOTIFY_URGENCY_NORMAL, NOTIFY_URGENCY_CRITICAL,
notify_notification_set_urgency (notify_p,NOTIFY_URGENCY_NORMAL);
//notify_notification_update(title, body, icon, NULL);
//notify_notification_close(notify_p, &error);
if (notify_notification_show(notify_p, &error) == FALSE)
return -1;
//notify_uninit();
return 0;
}
static void _do_notify_message(
const char * const source, const char * const message, int win) {
#ifdef HAVE_LIBNOTIFY
if (notify_is_initted()) {
GString *title = g_string_new("");
g_string_append(title, source);
g_string_append_printf(title, " (Profanity %d)", win);
NotifyNotification *notification =
notify_notification_new(title->str, message, NULL);
notify_notification_set_timeout(notification, 3000);
notify_notification_set_category(notification, "incoming message");
notify_notification_set_urgency(notification, NOTIFY_URGENCY_NORMAL);
GError *error = NULL;
gboolean notify_success = notify_notification_show(notification, &error);
if (!notify_success) {
log_error("Error sending desktop notification:");
log_error(" -> Message : %s", message);
log_error(" -> Error : %s", error->message);
}
g_string_free(title, TRUE);
} else {
log_error("Libnotify initialisation error.");
}
#endif
}
void
nautilus_application_notify_unmount_show (NautilusApplication *application,
const gchar *message)
{
gchar **strings;
strings = g_strsplit (message, "\n", 0);
if (!application->priv->unmount_notify) {
application->priv->unmount_notify =
notify_notification_new (strings[0], strings[1],
"media-removable");
notify_notification_set_hint (application->priv->unmount_notify,
"desktop-entry", g_variant_new_string ("nautilus"));
notify_notification_set_hint (application->priv->unmount_notify,
"transient", g_variant_new_boolean (TRUE));
notify_notification_set_urgency (application->priv->unmount_notify,
NOTIFY_URGENCY_CRITICAL);
} else {
notify_notification_update (application->priv->unmount_notify,
strings[0], strings[1],
"media-removable");
}
notify_notification_show (application->priv->unmount_notify, NULL);
g_strfreev (strings);
}
void
NotificationScreen::logMessage (const char *component,
CompLogLevel level,
const char *message)
{
NotifyNotification *n;
char *logLevel, *homeDir;
CompString iconUri;
int timeout;
NotifyUrgency urgency;
if (level > optionGetMaxLogLevel ())
{
screen->logMessage (component, level, message);
return;
}
homeDir = getenv ("HOME");
if (!homeDir)
return;
/* FIXME: when not installing manually, the image will likely reside
in $PREFIX/share/compiz, not in the home dir */
iconUri = "file://";
iconUri += homeDir;
iconUri += "/" IMAGE_DIR "/compiz.png";
logLevel = (char *) logLevelToString (level);
n = notify_notification_new (logLevel, message,
iconUri.c_str ()
#ifndef HAVE_LIBNOTIFY_0_6_1
, NULL
#endif
);
timeout = optionGetTimeout ();
if (timeout > 0)
timeout *= 1000;
notify_notification_set_timeout (n, timeout);
if (level == CompLogLevelFatal || level == CompLogLevelError)
urgency = NOTIFY_URGENCY_CRITICAL;
else if (level == CompLogLevelWarn)
urgency = NOTIFY_URGENCY_NORMAL;
else
urgency = NOTIFY_URGENCY_LOW;
notify_notification_set_urgency (n, urgency);
notify_notification_show (n, NULL);
g_object_unref (G_OBJECT (n));
screen->logMessage (component, level, message);
}
/*
* open a notification window (expires in 5 seconds) to say thank you
* to the user for his bug feedback.
*/
static void sent_an_oops(void)
{
char *summary = _("Kernel bug diagnostic information sent");
char *message = NULL;
char *message_1 =
_("Diagnostic information from your Linux kernel has been "
"sent to http://oops.kernel.org/ "
"for the Linux kernel developers to work on. \n"
"Thank you for contributing to improve the quality of the Linux kernel.\n");
char *message_2 =
_("Diagnostic information from your Linux kernel has been "
"sent to http://oops.kernel.org "
"for the Linux kernel developers to work on. \n"
"Thank you for contributing to improve the quality of the Linux kernel.\n"
"You can view your submitted oops here: %s\n");
NotifyActionCallback callback = notify_action;
close_notification();
if (strlen(url_to_oops)==0)
message = g_strdup_printf("%s", message_1);
else
message = g_strdup_printf(message_2, url_to_oops);
url_to_oops[0] = 0;
#if NOTIFY_CHECK_VERSION(0,7,0)
notify = notify_notification_new(summary, message,
"/usr/share/kerneloops/icon.png");
#else
notify = notify_notification_new(summary, message,
"/usr/share/kerneloops/icon.png", NULL);
#endif
notify_notification_set_timeout(notify, 5000);
notify_notification_set_urgency(notify, NOTIFY_URGENCY_LOW);
notify_notification_add_action(notify, "default", "action",
callback, "default", NULL);
if (user_preference <= 0)
notify_notification_add_action(notify, "always", _("Always"),
callback, "always", NULL);
notify_notification_add_action(notify, "never", _("Never again"),
callback, "never", NULL);
notify_notification_show(notify, NULL);
g_free(message);
}
static int Notify( vlc_object_t *p_this, const char *psz_temp )
{
NotifyNotification * notification;
notification = notify_notification_new( _("Now Playing"),
psz_temp,
DATA_PATH "/vlc48x48.png",NULL);
notify_notification_set_timeout( notification,
config_GetInt(p_this, "notify-timeout") );
notify_notification_set_urgency( notification, NOTIFY_URGENCY_LOW );
notify_notification_show( notification, NULL);
return VLC_SUCCESS;
}
static void osd_setup (NotifyNotification *notification)
{
bool_t resident = aud_get_bool ("notify", "resident");
notify_notification_set_hint (notification, "desktop-entry",
g_variant_new_string ("audacious"));
notify_notification_set_hint (notification, "action-icons", g_variant_new_boolean (TRUE));
notify_notification_set_hint (notification, "resident", g_variant_new_boolean (resident));
notify_notification_set_hint (notification, "transient", g_variant_new_boolean (! resident));
notify_notification_set_urgency (notification, NOTIFY_URGENCY_LOW);
notify_notification_set_timeout (notification, resident ?
NOTIFY_EXPIRES_NEVER : NOTIFY_EXPIRES_DEFAULT);
}
static void got_a_message(void)
{
char *summary = _("Your system had a kernel failure");
char *message =
_("There is diagnostic information available for this failure."
" Do you want to submit this information to the http://oops.kernel.org/"
" website for use by the Linux kernel developers?\n");
NotifyActionCallback callback = notify_action;
/* if there's a notification active already, close it first */
close_notification();
#if NOTIFY_CHECK_VERSION(0,7,0)
notify = notify_notification_new(summary, message,
"/usr/share/kerneloops/icon.png");
#else
notify = notify_notification_new(summary, message,
"/usr/share/kerneloops/icon.png", NULL);
#endif
notify_notification_set_timeout(notify, 0);
notify_notification_set_urgency(notify, NOTIFY_URGENCY_CRITICAL);
/*
* add the buttons and default action
*/
notify_notification_add_action(notify, "default", "action",
callback, "default", NULL);
notify_notification_add_action(notify, "always", _("Always"),
callback, "always", NULL);
notify_notification_add_action(notify, "yes", _("Yes"),
callback, "yes", NULL);
notify_notification_add_action(notify, "no", _("No"),
callback, "no", NULL);
notify_notification_add_action(notify, "never", _("Never"),
callback, "never", NULL);
if (detail_file_name) {
notify_notification_add_action(notify,
"details", _("Show Details"),
detail_action, "details", NULL);
}
notify_notification_show(notify, NULL);
}
void notify (void) {
NotifyNotification *notify;
GError *error_notify = NULL;
entry_text = gtk_entry_get_text (GTK_ENTRY (entry));
if(g_strcmp0 (entry_text, "Notification text") != 0)
notify = notify_notification_new (entry_text, NULL, "clocks");
else
notify = notify_notification_new (_("Time is up!"), NULL, "clocks");
notify_notification_set_category (notify, "GTimeUtils");
notify_notification_set_urgency (notify, NOTIFY_URGENCY_NORMAL);
notify_notification_show (notify, &error_notify);
if(error_notify)
g_fprintf (stderr, "Can not initialize notification: %s\n", error_notify->message);
ca_context_play(sound, 0, CA_PROP_APPLICATION_NAME, "Gtimer", CA_PROP_EVENT_ID, "complete-copy", CA_PROP_MEDIA_ROLE, "notification", CA_PROP_APPLICATION_ICON_NAME, "clocks", CA_PROP_CANBERRA_CACHE_CONTROL, "never", NULL);
}
void lassi_tray_show_notification(LassiTrayInfo *i, char *summary, char *body, LassiTrayNotificationIcon icon) {
static const char * const icon_name[] = {
[LASSI_TRAY_NOTIFICATION_WELCOME] = "user-desktop",
[LASSI_TRAY_NOTIFICATION_LEFT] = "go-previous",
[LASSI_TRAY_NOTIFICATION_RIGHT] = "go-next"
};
NotifyNotification *n;
n = notify_notification_new_with_status_icon(summary, body, icon_name[icon], i->status_icon);
notify_notification_set_timeout(n, 10000);
notify_notification_set_urgency(n, NOTIFY_URGENCY_LOW);
notify_notification_set_category(n, "network");
notify_notification_show(n, NULL);
}
void send_notify (std::string message, int timeout)
{
NotifyNotification *notification;
// Create notification and set properties
notification = notify_notification_new (settings.getTitle ().c_str (),
message.c_str (), NULL);
notify_notification_set_urgency (notification, NOTIFY_URGENCY_LOW);
notify_notification_set_timeout (notification, timeout * 1000);
// Show the notification.
GError *error = NULL;
notify_notification_show (notification, &error);
// Add to the vector.
notifications.push_back (*notification);
}
static void
_import_clicked_cb (MxButton *button,
MpdStorageDeviceTile *self)
{
MpdStorageDeviceTilePrivate *priv = GET_PRIVATE (self);
char const *program = NULL;
GError *error = NULL;
if (0 == g_strcmp0 ("x-content/image-dcf", priv->mime_type))
{
/* Photo devices are handled by GThumb.
* + gphoto2 devices are launched through gthumb-import.desktop with
* its Exec hack for exclusive device access.
* + others (USB cameras) don't work with that hack, so GThumb is
* launched in import mode manually. */
char *scheme = g_uri_parse_scheme (priv->mount_point);
program = "gthumb";
if (0 == g_strcmp0 ("gphoto2", scheme))
launch_gthumb_import (self, &error);
else
launch_import (self, program, "--import-photos", &error);
} else
{
program = "banshee-1";
launch_import (self, program, "--show-import-media", &error);
}
if (error)
{
NotifyNotification *note;
char *message = g_strdup_printf (_("Could not run \"%s\""), program);
note = notify_notification_new (_("Import error"), message, NULL);
notify_notification_set_urgency (note, NOTIFY_URGENCY_CRITICAL);
notify_notification_show (note, NULL);
g_signal_connect (note, "closed",
G_CALLBACK (g_object_unref), NULL);
g_free (message);
g_clear_error (&error);
} else {
g_signal_emit_by_name (self, "request-hide");
}
}
void show_notification(const gchar *summary, const gchar *message,
const gchar *action, gint timeout, GCallback handler)
{
NotifyActionCallback callback;
#ifndef HAVE_APP_INDICATOR
GdkScreen *screen;
GdkRectangle area;
#endif /* HAVE_APP_INDICATOR */
if (notify_is_initted() == FALSE)
return;
if (notify) {
g_signal_handlers_destroy(notify);
notify_notification_close(notify, NULL);
}
notify = notify_notification_new(summary, message, ACTIVE_ICON_NAME);
notify_notification_set_timeout(notify, timeout);
#ifndef HAVE_APP_INDICATOR
if (gtk_status_icon_get_visible(statusicon) == TRUE) {
gtk_status_icon_get_geometry(statusicon, &screen, &area, NULL);
notify_notification_set_hint_int32(notify,
"x", area.x + area.width / 2);
notify_notification_set_hint_int32(notify,
"y", area.y + area.height / 2);
}
#endif /* HAVE_APP_INDICATOR */
notify_notification_set_urgency(notify, NOTIFY_URGENCY_NORMAL);
callback = handler ? NOTIFY_ACTION_CALLBACK(handler) : notify_action;
notify_notification_add_action(notify, "default", "action",
callback, NULL, NULL);
if (action != NULL)
notify_notification_add_action(notify, "button", action,
callback, NULL, NULL);
notify_notification_show(notify, NULL);
}
static void
gnac_ui_notify(const gchar *msg)
{
#ifdef HAVE_LIBNOTIFY
NotifyNotification *notification = notify_notification_new(
PACKAGE_NAME, msg, PACKAGE);
notify_notification_set_timeout(notification, NOTIFY_EXPIRES_DEFAULT);
notify_notification_set_urgency(notification, NOTIFY_URGENCY_NORMAL);
notify_notification_show(notification, NULL);
#else /* HAVE_LIBNOTIFY */
libgnac_info(msg);
#endif /* !HAVE_LIBNOTIFY */
}
bool notify(gpointer user_data)
{
timeout=false;
tres* lastres = (tres*)user_data;
NotifyNotification *n;
char str[20];
if (lastres->time>POTIME)
sprintf(str,"Time's up!(%d)",lastres->time-POTIME);
else
sprintf(str,"Time's up!");
n = notify_notification_new (APPNAME,str, NULL);
notify_notification_set_urgency(n,NOTIFY_URGENCY_CRITICAL);
notify_notification_add_action(n,"M", "More",(NotifyActionCallback)timeup,lastres,NULL);
notify_notification_add_action(n,"G", "Good",(NotifyActionCallback)timeup,lastres,NULL);
g_signal_connect (n, "closed", G_CALLBACK(quit), NULL);
notify_notification_set_timeout(n,0); //3 seconds
notify_notification_show(n,NULL);
return FALSE;
}
void Notification::show()
{
assert(note == nullptr);
assert(name.size());
notify_init(name.c_str());
note = notify_notification_new(name.c_str(), content.c_str(), icon.c_str());
notify_notification_set_timeout(note, timeout.count());
notify_notification_set_category(note, "Testing Notifications");
notify_notification_set_urgency(note, NOTIFY_URGENCY_NORMAL);
GError* error = nullptr;
notify_notification_show(note, &error);
if (error != nullptr)
{
throw std::runtime_error("error during 'notify_notification_show");
}
}
static int Notify( vlc_object_t *p_this, const char *psz_temp, GdkPixbuf *pix,
intf_thread_t *p_intf )
{
intf_sys_t *p_sys = p_intf->p_sys;
NotifyNotification * notification;
/* Close previous notification if still active */
if( p_sys->notification )
{
GError *p_error = NULL;
notify_notification_close( p_sys->notification, &p_error );
g_object_unref( p_sys->notification );
}
notification = notify_notification_new( _("Now Playing"),
psz_temp, NULL, NULL );
notify_notification_set_timeout( notification,
var_InheritInteger(p_this, "notify-timeout") );
notify_notification_set_urgency( notification, NOTIFY_URGENCY_LOW );
if( pix )
{
notify_notification_set_icon_from_pixbuf( notification, pix );
gdk_pixbuf_unref( pix );
}
/* Adds previous and next buttons in the notification if actions are supported. */
if( p_sys->b_has_actions )
{
notify_notification_add_action( notification, "previous", _("Previous"), Prev,
(gpointer*)p_intf, NULL );
notify_notification_add_action( notification, "next", _("Next"), Next,
(gpointer*)p_intf, NULL );
}
notify_notification_show( notification, NULL);
/* Stores the notification to be able to close it */
p_sys->notification = notification;
return VLC_SUCCESS;
}
static void
update_notification (GduSdMonitor *monitor,
GList *problems,
NotifyNotification **notification,
const gchar *title,
const gchar *text,
const gchar *icon_name,
const gchar *action,
const gchar *action_label)
{
if (g_list_length (problems) > 0)
{
/* it could be the notification has already been presented, in that
* case, don't show another one
*/
if (*notification == NULL)
{
*notification = notify_notification_new (title, text, icon_name);
notify_notification_set_urgency (*notification, NOTIFY_URGENCY_CRITICAL);
notify_notification_set_timeout (*notification, NOTIFY_EXPIRES_NEVER);
notify_notification_set_hint_string (*notification, "desktop-entry", "gnome-disks");
notify_notification_add_action (*notification,
action,
action_label,
(NotifyActionCallback) on_examine_action_clicked,
monitor,
NULL);
notify_notification_show (*notification, NULL);
}
}
else
{
if (*notification != NULL)
{
notify_notification_close (*notification, NULL);
g_clear_object (notification);
}
}
}
NotifyNotification *sendNotify(char *title, char *message, pid_t *p_PID)
{
NotifyNotification *notification;
notification = notify_notification_new(title, message, iconType);
notify_notification_set_urgency(notification, NOTIFY_URGENCY_CRITICAL);
notify_notification_set_timeout(notification, NOTIFY_EXPIRES_NEVER);
notify_notification_add_action(notification, "button", "Kill this process",
(NotifyActionCallback)killApp, p_PID, NULL
);
if (!notify_notification_show(notification, &error)) {
g_error("Sending notification failed: %s", error->message);
g_error_free(error);
}
g_signal_connect(notification, "closed", G_CALLBACK(notifyClosed), NULL);
isNotifyActive = 1;
return notification;
}
static int
set_urgency (lua_State * L)
{
int l = 0;
NotifyUrgency level = 0;
NotifyNotification *notify = (NotifyNotification *) lua_touserdata (L, 1);
if (!notify) luaL_argerror(L, 1, "Unknown type");
if (lua_isnumber(L, 2)) {
l = lua_tointeger(L, 2);
}
else {
const char *lstr = luaL_checkstring(L, 2);
if (strcmp(lstr, "low") == 0) l = 1;
else if (strcmp(lstr, "normal") == 0) l = 2;
else if (strcmp(lstr, "critical") == 0) l = 3;
else luaL_argerror(L, 2, lstr);
}
switch(l) {
case 1:
level = NOTIFY_URGENCY_LOW;
break;
case 2:
level = NOTIFY_URGENCY_NORMAL;
break;
case 3:
level = NOTIFY_URGENCY_CRITICAL;
break;
default:
luaL_argerror(L, 2, lua_tolstring(L, 2, NULL)); /* coerce int to string */
}
notify_notification_set_urgency (notify, level);
return 0;
}
static void notify_message (NotifyNotification **notification, gchar *summary, gchar *body, gint timeout, NotifyUrgency urgency)
{
g_return_if_fail (notification != NULL);
g_return_if_fail (summary != NULL);
if (configuration.hide_notification == TRUE) {
return;
}
if (*notification == NULL) {
#if NOTIFY_CHECK_VERSION (0, 7, 0)
*notification = notify_notification_new (summary, body, NULL);
#else
*notification = notify_notification_new (summary, body, NULL, NULL);
#endif
} else {
notify_notification_update (*notification, summary, body, NULL);
}
notify_notification_set_timeout (*notification, timeout);
notify_notification_set_urgency (*notification, urgency);
notify_notification_show (*notification, NULL);
}
static void
notify (const gchar *title,
const gchar *body,
PurpleBuddy *buddy,
PurpleConversation *conv)
{
NotifyNotification *notification = NULL;
GdkPixbuf *icon;
PurpleBuddyIcon *buddy_icon;
gchar *tr_body;
PurpleContact *contact;
if (buddy)
contact = purple_buddy_get_contact (buddy);
else
contact = NULL;
if (body)
tr_body = truncate_escape_string (body, 60);
else
tr_body = NULL;
if (!conv && buddy)
conv = purple_find_conversation_with_account (PURPLE_CONV_TYPE_ANY, buddy->name, buddy->account);
if (conv && conv->ui_ops && conv->ui_ops->has_focus) {
if (conv->ui_ops->has_focus(conv) == TRUE) {
/* do not notify if the conversation is currently in focus */
return;
}
}
if (contact)
notification = g_hash_table_lookup (buddy_hash, contact);
else if (conv)
notification = g_hash_table_lookup (buddy_hash, conv);
else
notification = NULL;
if (notification != NULL) {
notify_notification_update (notification, title, tr_body, NULL);
notify_notification_set_timeout(notification, purple_prefs_get_int("/plugins/gtk/libnotify/timeout"));
/* this shouldn't be necessary, file a bug */
notify_notification_show (notification, NULL);
purple_debug_info (PLUGIN_ID, "notify(), update: "
"title: '%s', body: '%s', buddy: '%s'\n",
title, tr_body, buddy ? best_name (buddy) : "");
g_free (tr_body);
return;
}
#ifdef LIBNOTIFY_07
notification = notify_notification_new (title, tr_body, NULL);
#else
notification = notify_notification_new (title, tr_body, NULL, NULL);
#endif
purple_debug_info (PLUGIN_ID, "notify(), new: "
"title: '%s', body: '%s', buddy: '%s'\n",
title, tr_body, buddy ? best_name (buddy) : "");
g_free (tr_body);
if (buddy)
buddy_icon = purple_buddy_get_icon (buddy);
else
buddy_icon = NULL;
if (buddy_icon) {
icon = pixbuf_from_buddy_icon (buddy_icon);
purple_debug_info (PLUGIN_ID, "notify(), has a buddy icon.\n");
} else if (buddy) {
icon = pidgin_create_prpl_icon (buddy->account, 1);
purple_debug_info (PLUGIN_ID, "notify(), has a prpl icon.\n");
} else if (conv) {
icon = pidgin_create_prpl_icon (conv->account, 1);
purple_debug_info (PLUGIN_ID, "notify(), has a prpl icon.\n");
} else {
icon = NULL;
purple_debug_info (PLUGIN_ID, "notify(), has no icon.\n");
}
if (icon) {
notify_notification_set_icon_from_pixbuf (notification, icon);
g_object_unref (icon);
} else {
purple_debug_warning (PLUGIN_ID, "notify(), couldn't find any icon!\n");
}
if (contact)
g_hash_table_insert (buddy_hash, contact, notification);
else if (conv)
g_hash_table_insert (buddy_hash, conv, notification);
g_object_set_data (G_OBJECT(notification), "contact", contact);
g_object_set_data (G_OBJECT(notification), "conv", conv);
g_object_set_data (G_OBJECT(notification), "buddy", buddy);
g_signal_connect (notification, "closed", G_CALLBACK(closed_cb), NULL);
notify_notification_set_urgency (notification, NOTIFY_URGENCY_NORMAL);
notify_notification_add_action (notification, "show", _("Show"), action_cb, NULL, NULL);
notify_notification_set_timeout(notification, purple_prefs_get_int("/plugins/gtk/libnotify/timeout"));
if (!notify_notification_show (notification, NULL)) {
purple_debug_error (PLUGIN_ID, "notify(), failed to send notification\n");
}
}
static void
_notify(const char * const message, int timeout,
const char * const category)
{
#ifdef HAVE_LIBNOTIFY
if (notify_is_initted()) {
NotifyNotification *notification;
notification = notify_notification_new("Profanity", message, NULL);
notify_notification_set_timeout(notification, timeout);
notify_notification_set_category(notification, category);
notify_notification_set_urgency(notification, NOTIFY_URGENCY_NORMAL);
GError *error = NULL;
gboolean notify_success = notify_notification_show(notification, &error);
if (!notify_success) {
log_error("Error sending desktop notification:");
log_error(" -> Message : %s", message);
log_error(" -> Error : %s", error->message);
}
} else {
log_error("Libnotify initialisation error.");
}
#endif
#ifdef PLATFORM_CYGWIN
NOTIFYICONDATA nid;
nid.cbSize = sizeof(NOTIFYICONDATA);
//nid.hWnd = hWnd;
nid.uID = 100;
nid.uVersion = NOTIFYICON_VERSION;
//nid.uCallbackMessage = WM_MYMESSAGE;
nid.hIcon = LoadIcon(NULL, IDI_APPLICATION);
strncpy(nid.szTip, "Tray Icon", 10);
nid.uFlags = NIF_MESSAGE | NIF_ICON | NIF_TIP;
Shell_NotifyIcon(NIM_ADD, &nid);
// For a Ballon Tip
nid.uFlags = NIF_INFO;
strncpy(nid.szInfoTitle, "Profanity", 10); // Title
strncpy(nid.szInfo, message, 256); // Copy Tip
nid.uTimeout = timeout; // 3 Seconds
nid.dwInfoFlags = NIIF_INFO;
Shell_NotifyIcon(NIM_MODIFY, &nid);
#endif
#ifdef HAVE_OSXNOTIFY
GString *notify_command = g_string_new("terminal-notifier -title 'Profanity' -message '");
g_string_append(notify_command, message);
g_string_append(notify_command, "'");
char *term_name = getenv("TERM_PROGRAM");
char *app_id = NULL;
if (g_strcmp0(term_name, "Apple_Terminal") == 0) {
app_id = "com.apple.Terminal";
} else if (g_strcmp0(term_name, "iTerm.app") == 0) {
app_id = "com.googlecode.iterm2";
}
if (app_id != NULL) {
g_string_append(notify_command, " -sender ");
g_string_append(notify_command, app_id);
}
int res = system(notify_command->str);
if (res == -1) {
log_error("Could not send desktop notificaion.");
}
g_string_free(notify_command, TRUE);
#endif
}