/** * @file libnotify/notify.c Notifications library * * @Copyright (C) 2004-2006 Christian Hammond * @Copyright (C) 2004-2006 Mike Hearn * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library 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 * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the * Free Software Foundation, Inc., 59 Temple Place - Suite 330, * Boston, MA 02111-1307, USA. */ #include #include #include #include #include #include #include static gboolean _initted = FALSE; static gchar *_app_name = NULL; static DBusGProxy *_proxy = NULL; static DBusGConnection *_dbus_gconn = NULL; static GList *_active_notifications = NULL; /** * notify_init: * @app_name: The name of the application initializing libnotify. * * Initialized libnotify. This must be called before any other functions. * * Returns: %TRUE if successful, or %FALSE on error. */ gboolean notify_init(const char *app_name) { GError *error = NULL; DBusGConnection *bus = NULL; g_return_val_if_fail(app_name != NULL, FALSE); g_return_val_if_fail(*app_name != '\0', FALSE); if (_initted) return TRUE; _app_name = g_strdup(app_name); g_type_init(); bus = dbus_g_bus_get(DBUS_BUS_SESSION, &error); if (error != NULL) { g_message("Unable to get session bus: %s", error->message); g_error_free(error); return FALSE; } _proxy = dbus_g_proxy_new_for_name(bus, NOTIFY_DBUS_NAME, NOTIFY_DBUS_CORE_OBJECT, NOTIFY_DBUS_CORE_INTERFACE); dbus_g_connection_unref(bus); dbus_g_object_register_marshaller(notify_marshal_VOID__UINT_UINT, G_TYPE_NONE, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_INVALID); dbus_g_object_register_marshaller(notify_marshal_VOID__UINT_STRING, G_TYPE_NONE, G_TYPE_UINT, G_TYPE_STRING, G_TYPE_INVALID); dbus_g_proxy_add_signal(_proxy, "NotificationClosed", G_TYPE_UINT, G_TYPE_UINT, G_TYPE_INVALID); dbus_g_proxy_add_signal(_proxy, "ActionInvoked", G_TYPE_UINT, G_TYPE_STRING, G_TYPE_INVALID); _initted = TRUE; return TRUE; } /** * notify_get_app_name: * * Gets the application name registered. * * Returns: The registered application name, passed to notify_init(). */ const gchar * notify_get_app_name(void) { return _app_name; } /** * notify_uninit: * * Uninitialized libnotify. * * This should be called when the program no longer needs libnotify for * the rest of its lifecycle, typically just before exitting. */ void notify_uninit(void) { GList *l; if (!_initted) return; if (_app_name != NULL) { g_free(_app_name); _app_name = NULL; } for (l = _active_notifications; l != NULL; l = l->next) { NotifyNotification *n = NOTIFY_NOTIFICATION(l->data); if (_notify_notification_get_timeout(n) == 0 || _notify_notification_has_nondefault_actions(n)) { notify_notification_close(n, NULL); } } g_object_unref(_proxy); _initted = FALSE; } /** * notify_is_initted: * * Gets whether or not libnotify is initialized. * * Returns: %TRUE if libnotify is initialized, or %FALSE otherwise. */ gboolean notify_is_initted(void) { return _initted; } DBusGConnection * _notify_get_dbus_g_conn(void) { return _dbus_gconn; } DBusGProxy * _notify_get_g_proxy(void) { return _proxy; } /** * notify_get_server_caps: * * Queries the server for its capabilities and returns them in a #GList. * * Returns: A #GList of server capability strings. */ GList * notify_get_server_caps(void) { GError *error = NULL; char **caps = NULL, **cap; GList *result = NULL; DBusGProxy *proxy = _notify_get_g_proxy(); g_return_val_if_fail(proxy != NULL, NULL); if (!dbus_g_proxy_call(proxy, "GetCapabilities", &error, G_TYPE_INVALID, G_TYPE_STRV, &caps, G_TYPE_INVALID)) { g_message("GetCapabilities call failed: %s", error->message); g_error_free(error); return NULL; } for (cap = caps; *cap != NULL; cap++) { result = g_list_append(result, g_strdup(*cap)); } g_strfreev(caps); return result; } /** * notify_get_server_info: * @ret_name: The resulting server name. * @ret_vendor: The resulting server vendor. * @ret_version: The resulting server version. * @ret_spec_version: The resulting version of the specification the server is * compliant with. * * Queries the server for its information, specifically, the name, vendor, * server version, and the version of the notifications specification that it * is compliant with. * * Returns: %TRUE if successful, and the variables passed will be set. %FALSE * on failure. */ gboolean notify_get_server_info(char **ret_name, char **ret_vendor, char **ret_version, char **ret_spec_version) { GError *error = NULL; DBusGProxy *proxy = _notify_get_g_proxy(); char *name, *vendor, *version, *spec_version; g_return_val_if_fail(proxy != NULL, FALSE); if (!dbus_g_proxy_call(proxy, "GetServerInformation", &error, G_TYPE_INVALID, G_TYPE_STRING, &name, G_TYPE_STRING, &vendor, G_TYPE_STRING, &version, G_TYPE_STRING, &spec_version, G_TYPE_INVALID)) { g_message("GetServerInformation call failed: %s", error->message); return FALSE; } if (ret_name != NULL) *ret_name = name; if (ret_vendor != NULL) *ret_vendor = vendor; if (ret_version != NULL) *ret_version = version; if (spec_version != NULL) *ret_spec_version = spec_version; return TRUE; } void _notify_cache_add_notification(NotifyNotification *n) { _active_notifications = g_list_prepend(_active_notifications, n); } void _notify_cache_remove_notification(NotifyNotification *n) { _active_notifications = g_list_remove(_active_notifications, n); }