libnotify/tools/notify-send.c

/**
 * @file notify-send.c A tool for sending notifications.
 *
 * Copyright (C) 2004 Christian Hammond.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of
 * the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public
 * License along with this program; if not, write to the Free
 * Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 * MA  02111-1307  USA
 */
#include <config.h>

#include <libnotify/notify.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <glib.h>
#include <glib/gprintf.h>

#define N_(x) (x)
#define GETTEXT_PACKAGE NULL

static NotifyUrgency urgency = NOTIFY_URGENCY_NORMAL;

static gboolean
g_option_arg_urgency_cb(const gchar *option_name,
						const gchar *value,
						gpointer data,
						GError **error)
{
	if (value != NULL)
	{
		if (!strcasecmp(value, "low"))
			urgency = NOTIFY_URGENCY_LOW;
		else if (!strcasecmp(value, "normal"))
			urgency = NOTIFY_URGENCY_NORMAL;
		else if (!strcasecmp(value, "critical"))
			urgency = NOTIFY_URGENCY_CRITICAL;
		else
		{
			*error = g_error_new(G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE,
								 N_("Unknown urgency %s specified. "
									"Known urgency levels: low, "
									"normal, critical."),
								 value);

			return FALSE;
		}
	}

	return TRUE;
}

static gboolean
notify_notification_set_hint_variant(NotifyNotification *notification,
									 const gchar *type, const gchar *key,
									 const gchar *value, GError **error)
{
	static gboolean conv_error = FALSE;
	if (!strcasecmp(type, "string"))
	{
		notify_notification_set_hint_string(notification, key, value);
	}
	else if (!strcasecmp(type, "int"))
	{
		if (!g_ascii_isdigit(*value))
			conv_error = TRUE;
		else
		{
			gint h_int = (gint)g_ascii_strtoull(value, NULL, 10);
			notify_notification_set_hint_int32(notification, key, h_int);
		}
	}
	else if (!strcasecmp(type, "double"))
	{
		if (!g_ascii_isdigit(*value))
			conv_error = TRUE;
		else
		{
			gdouble h_double = g_strtod(value, NULL);
			notify_notification_set_hint_double(notification, key, h_double);
		}
	}
	else if (!strcasecmp(type, "byte"))
	{
		gint h_byte = (gint)g_ascii_strtoull(value, NULL, 10);

		if (h_byte < 0 || h_byte > 0xFF)
			conv_error = TRUE;
		else
		{
			notify_notification_set_hint_byte(notification, key,
											  (guchar)h_byte);
		}
	}
	else
	{
		*error = g_error_new(G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE,
							 N_("Invalid hint type \"%s\". Valid types "
								"are int, double, string and byte."),
							 type);
		return FALSE;
	}

	if (conv_error)
	{
		*error = g_error_new(G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE,
							 N_("Value \"%s\" of hint \"%s\" could not be "
								"parsed as type \"%s\"."),
							 value, key, type);
		return FALSE;
	}

	return TRUE;
}

int
main(int argc, char *argv[])
{
	static const gchar *summary = NULL;
	static const gchar *body = "";
	static const gchar *type = NULL;
	static gchar *icon_str = NULL;
	static gchar *icons = NULL;
	static gchar **n_text = NULL;
	static gchar **hints = NULL;
	static gboolean do_version = FALSE;
	static gboolean hint_error = FALSE;
	static glong expire_timeout = NOTIFY_EXPIRES_DEFAULT;
	GOptionContext *opt_ctx;
	NotifyNotification *notify;
	GError *error = NULL;
	gboolean retval;

	static const GOptionEntry entries[] =
	{
		{ "urgency", 'u', 0, G_OPTION_ARG_CALLBACK, g_option_arg_urgency_cb,
		  N_("Specifies the urgency level (low, normal, critical)."),
		  N_("LEVEL") },
		{ "expire-time", 't', 0,G_OPTION_ARG_INT, &expire_timeout,
		  N_("Specifies the timeout in milliseconds at which to expire the "
			 "notification."), N_("TIME") },
		{ "icon",  'i', 0, G_OPTION_ARG_FILENAME, &icons,
		  N_("Specifies an icon filename or stock icon to display."),
		  N_("ICON[,ICON...]") },
		{ "category",  'c', 0, G_OPTION_ARG_FILENAME, &type,
		  N_("Specifies the notification category."),
		  N_("TYPE[,TYPE...]") },
		{ "hint",  'h', 0, G_OPTION_ARG_FILENAME_ARRAY, &hints,
		  N_("Specifies basic extra data to pass. Valid types are int, double, string and byte."),
		  N_("TYPE:NAME:VALUE") },
		{ "version",  'v', 0, G_OPTION_ARG_NONE, &do_version,
		  N_("Version of the package."),
		  NULL },
		{ G_OPTION_REMAINING, 0, 0, G_OPTION_ARG_FILENAME_ARRAY, &n_text, NULL,
		  NULL },
		{ NULL }
	};

	g_type_init();

	g_set_prgname(argv[0]);

	opt_ctx = g_option_context_new(N_("<SUMMARY> [BODY] - "
									  "create a notification"));
	g_option_context_add_main_entries(opt_ctx, entries, GETTEXT_PACKAGE);
	retval = g_option_context_parse(opt_ctx, &argc, &argv, &error);
	g_option_context_free(opt_ctx);

	if (!retval)
	{
		fprintf(stderr, "%s\n", error->message);
		g_error_free(error);
		exit(1);
	}

	if (do_version)
	{
		g_printf("%s %s\n", g_get_prgname(), VERSION);
		exit(0);
	}

	if (n_text != NULL && n_text[0] != NULL && *n_text[0] != '\0')
		summary = n_text[0];

	if (summary == NULL)
	{
		fprintf(stderr, "%s\n", N_("No summary specified."));
		exit(1);
	}

	if (n_text[1] != NULL)
	{
		body = n_text[1];

		if (n_text[2] != NULL)
		{
			fprintf(stderr, "%s\n", N_("Invalid number of options."));
			exit(1);
		}
	}

	if (icons != NULL)
	{
		char *c;

		/* XXX */
		if((c = strchr(icons, ',')) != NULL)
			*c = '\0';

		icon_str = icons;
	}

	if (!notify_init("notify-send"))
		exit(1);

	notify = notify_notification_new(summary, body, icon_str, NULL);
	notify_notification_set_category(notify, type);
	notify_notification_set_urgency(notify, urgency);
	notify_notification_set_timeout(notify, expire_timeout);

	// Set hints
	if (hints != NULL)
	{
		gint i = 0;
		gint l;
		gchar *hint = NULL;
		gchar **tokens = NULL;

		while ((hint = hints[i++]))
		{
			tokens = g_strsplit(hint, ":", -1);
			l = g_strv_length(tokens);

			if (l != 3)
			{
				fprintf(stderr, "%s\n",
						N_("Invalid hint syntax specified. "
						   "Use TYPE:NAME:VALUE."));
				hint_error = TRUE;
			}
			else
			{
				retval = notify_notification_set_hint_variant(
					notify, tokens[0], tokens[1], tokens[2], &error);

				if (!retval)
				{
					fprintf(stderr, "%s\n", error->message);
					g_error_free(error);
					hint_error = TRUE;
				}
			}

			g_strfreev(tokens);
			if (hint_error)
				break;
		}
	}

	if (!hint_error)
		notify_notification_show(notify, NULL);

	g_object_unref(G_OBJECT(notify));

	notify_uninit();

	exit(hint_error);
}