diff options
Diffstat (limited to 'src/mate-screensaver-command.c.orig')
| -rw-r--r-- | src/mate-screensaver-command.c.orig | 551 |
1 files changed, 551 insertions, 0 deletions
diff --git a/src/mate-screensaver-command.c.orig b/src/mate-screensaver-command.c.orig new file mode 100644 index 0000000..441f81e --- /dev/null +++ b/src/mate-screensaver-command.c.orig @@ -0,0 +1,551 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2004-2006 William Jon McCann <[email protected]> + * + * 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. + * + * Authors: William Jon McCann <[email protected]> + * + */ + +#include "config.h" + +#include <stdlib.h> +#include <locale.h> +#include <glib.h> +#include <glib/gi18n.h> + +#define DBUS_API_SUBJECT_TO_CHANGE +#include <dbus/dbus.h> +#include <dbus/dbus-glib.h> +#include <dbus/dbus-glib-lowlevel.h> + +#define GS_SERVICE "org.mate.ScreenSaver" +#define GS_PATH "/org/mate/ScreenSaver" +#define GS_INTERFACE "org.mate.ScreenSaver" + +/* this is for dbus < 0.3 */ +#if ((DBUS_VERSION_MAJOR == 0) && (DBUS_VERSION_MINOR < 30)) +#define dbus_bus_name_has_owner(connection, name, err) dbus_bus_service_exists(connection, name, err) +#endif + +static gboolean do_quit = FALSE; +static gboolean do_lock = FALSE; +static gboolean do_cycle = FALSE; +static gboolean do_activate = FALSE; +static gboolean do_deactivate = FALSE; +static gboolean do_version = FALSE; +static gboolean do_poke = FALSE; +static gboolean do_inhibit = FALSE; + +static gboolean do_query = FALSE; +static gboolean do_time = FALSE; + +static char *inhibit_reason = NULL; +static char *inhibit_application = NULL; + +static GOptionEntry entries [] = +{ + { + "exit", 0, 0, G_OPTION_ARG_NONE, &do_quit, + N_("Causes the screensaver to exit gracefully"), NULL + }, + { + "query", 'q', 0, G_OPTION_ARG_NONE, &do_query, + N_("Query the state of the screensaver"), NULL + }, + { + "time", 't', 0, G_OPTION_ARG_NONE, &do_time, + N_("Query the length of time the screensaver has been active"), NULL + }, + { + "lock", 'l', 0, G_OPTION_ARG_NONE, &do_lock, + N_("Tells the running screensaver process to lock the screen immediately"), NULL + }, + { + "cycle", 'c', 0, G_OPTION_ARG_NONE, &do_cycle, + N_("If the screensaver is active then switch to another graphics demo"), NULL + }, + { + "activate", 'a', 0, G_OPTION_ARG_NONE, &do_activate, + N_("Turn the screensaver on (blank the screen)"), NULL + }, + { + "deactivate", 'd', 0, G_OPTION_ARG_NONE, &do_deactivate, + N_("If the screensaver is active then deactivate it (un-blank the screen)"), NULL + }, + { + "poke", 'p', 0, G_OPTION_ARG_NONE, &do_poke, + N_("Poke the running screensaver to simulate user activity"), NULL + }, + { + "inhibit", 'i', 0, G_OPTION_ARG_NONE, &do_inhibit, + N_("Inhibit the screensaver from activating. Command blocks while inhibit is active."), NULL + }, + { + "application-name", 'n', 0, G_OPTION_ARG_STRING, &inhibit_application, + N_("The calling application that is inhibiting the screensaver"), NULL + }, + { + "reason", 'r', 0, G_OPTION_ARG_STRING, &inhibit_reason, + N_("The reason for inhibiting the screensaver"), NULL + }, + { + "version", 'V', 0, G_OPTION_ARG_NONE, &do_version, + N_("Version of this application"), NULL + }, + { NULL } +}; + +static GMainLoop *loop = NULL; + +static gboolean +screensaver_is_running (DBusConnection *connection) +{ + DBusError error; + gboolean exists; + + g_return_val_if_fail (connection != NULL, FALSE); + + dbus_error_init (&error); + exists = dbus_bus_name_has_owner (connection, GS_SERVICE, &error); + if (dbus_error_is_set (&error)) + dbus_error_free (&error); + + return exists; +} + +static DBusMessage * +screensaver_send_message_inhibit (DBusConnection *connection, + const char *application, + const char *reason) +{ + DBusMessage *message; + DBusMessage *reply; + DBusError error; + DBusMessageIter iter; + + g_return_val_if_fail (connection != NULL, NULL); + + dbus_error_init (&error); + + message = dbus_message_new_method_call (GS_SERVICE, GS_PATH, GS_INTERFACE, "Inhibit"); + if (message == NULL) + { + g_warning ("Couldn't allocate the dbus message"); + return NULL; + } + + dbus_message_iter_init_append (message, &iter); + dbus_message_iter_append_basic (&iter, DBUS_TYPE_STRING, &application); + dbus_message_iter_append_basic (&iter, DBUS_TYPE_STRING, &reason); + + reply = dbus_connection_send_with_reply_and_block (connection, + message, + -1, &error); + if (dbus_error_is_set (&error)) + { + g_warning ("%s raised:\n %s\n\n", error.name, error.message); + reply = NULL; + } + + dbus_connection_flush (connection); + + dbus_message_unref (message); + dbus_error_free (&error); + + return reply; +} + +static DBusMessage * +screensaver_send_message_bool (DBusConnection *connection, + const char *name, + gboolean value) +{ + DBusMessage *message; + DBusMessage *reply; + DBusError error; + DBusMessageIter iter; + + g_return_val_if_fail (connection != NULL, NULL); + g_return_val_if_fail (name != NULL, NULL); + + dbus_error_init (&error); + + message = dbus_message_new_method_call (GS_SERVICE, GS_PATH, GS_INTERFACE, name); + if (message == NULL) + { + g_warning ("Couldn't allocate the dbus message"); + return NULL; + } + + dbus_message_iter_init_append (message, &iter); + dbus_message_iter_append_basic (&iter, DBUS_TYPE_BOOLEAN, &value); + + reply = dbus_connection_send_with_reply_and_block (connection, + message, + -1, &error); + if (dbus_error_is_set (&error)) + { + g_warning ("%s raised:\n %s\n\n", error.name, error.message); + reply = NULL; + } + + dbus_connection_flush (connection); + + dbus_message_unref (message); + dbus_error_free (&error); + + return reply; +} + +static DBusMessage * +screensaver_send_message_void (DBusConnection *connection, + const char *name, + gboolean expect_reply) +{ + DBusMessage *message; + DBusMessage *reply; + DBusError error; + + g_return_val_if_fail (connection != NULL, NULL); + g_return_val_if_fail (name != NULL, NULL); + + dbus_error_init (&error); + + message = dbus_message_new_method_call (GS_SERVICE, GS_PATH, GS_INTERFACE, name); + if (message == NULL) + { + g_warning ("Couldn't allocate the dbus message"); + return NULL; + } + + if (! expect_reply) + { + if (!dbus_connection_send (connection, message, NULL)) + g_warning ("could not send message"); + reply = NULL; + } + else + { + reply = dbus_connection_send_with_reply_and_block (connection, + message, + -1, &error); + if (dbus_error_is_set (&error)) + { + g_warning ("%s raised:\n %s\n\n", error.name, error.message); + reply = NULL; + } + } + dbus_connection_flush (connection); + + dbus_message_unref (message); + dbus_error_free (&error); + + return reply; +} + +static char ** +get_string_from_iter (DBusMessageIter *iter, + int *num_elements) +{ + int count; + char **buffer; + + if (num_elements != NULL) + { + *num_elements = 0; + } + + count = 0; + buffer = (char **)malloc (sizeof (char *) * 8); + + if (buffer == NULL) + { + goto oom; + } + + buffer[0] = NULL; + while (dbus_message_iter_get_arg_type (iter) == DBUS_TYPE_STRING) + { + const char *value; + char *str; + + if ((count % 8) == 0 && count != 0) + { + buffer = realloc (buffer, sizeof (char *) * (count + 8)); + if (buffer == NULL) + { + goto oom; + } + } + + dbus_message_iter_get_basic (iter, &value); + str = strdup (value); + if (str == NULL) + { + goto oom; + } + + buffer[count] = str; + + dbus_message_iter_next (iter); + count++; + } + + if ((count % 8) == 0) + { + buffer = realloc (buffer, sizeof (char *) * (count + 1)); + if (buffer == NULL) + { + goto oom; + } + } + + buffer[count] = NULL; + if (num_elements != NULL) + { + *num_elements = count; + } + return buffer; + +oom: + g_debug ("%s %d : error allocating memory\n", __FILE__, __LINE__); + return NULL; + +} + +static gboolean +do_command (DBusConnection *connection) +{ + DBusMessage *reply; + + if (do_quit) + { + reply = screensaver_send_message_void (connection, "Quit", FALSE); + goto done; + } + + if (do_query) + { + DBusMessageIter iter; + DBusMessageIter array; + dbus_bool_t v; + + reply = screensaver_send_message_void (connection, "GetActive", TRUE); + if (! reply) + { + g_message ("Did not receive a reply from the screensaver."); + goto done; + } + + dbus_message_iter_init (reply, &iter); + dbus_message_iter_get_basic (&iter, &v); + g_print (_("The screensaver is %s\n"), v ? _("active") : _("inactive")); + + dbus_message_unref (reply); + + reply = screensaver_send_message_void (connection, "GetInhibitors", TRUE); + if (! reply) + { + g_message ("Did not receive a reply from screensaver."); + goto done; + } + + dbus_message_iter_init (reply, &iter); + dbus_message_iter_recurse (&iter, &array); + + if (dbus_message_iter_get_arg_type (&array) == DBUS_TYPE_INVALID) + { + g_print (_("The screensaver is not inhibited\n")); + } + else + { + char **inhibitors; + int i; + int num; + + g_print (_("The screensaver is being inhibited by:\n")); + inhibitors = get_string_from_iter (&array, &num); + for (i = 0; i < num; i++) + { + g_print ("\t%s\n", inhibitors[i]); + } + g_strfreev (inhibitors); + } + + dbus_message_unref (reply); + } + + if (do_time) + { + DBusMessageIter iter; + dbus_bool_t v; + dbus_int32_t t; + + reply = screensaver_send_message_void (connection, "GetActive", TRUE); + if (! reply) + { + g_message ("Did not receive a reply from the screensaver."); + goto done; + } + + dbus_message_iter_init (reply, &iter); + dbus_message_iter_get_basic (&iter, &v); + dbus_message_unref (reply); + + if (v) + { + + reply = screensaver_send_message_void (connection, "GetActiveTime", TRUE); + dbus_message_iter_init (reply, &iter); + dbus_message_iter_get_basic (&iter, &t); + g_print (_("The screensaver has been active for %d seconds.\n"), t); + + dbus_message_unref (reply); + } + else + { + g_print (_("The screensaver is not currently active.\n")); + } + } + + if (do_lock) + { + reply = screensaver_send_message_void (connection, "Lock", FALSE); + } + + if (do_cycle) + { + reply = screensaver_send_message_void (connection, "Cycle", FALSE); + } + + if (do_poke) + { + reply = screensaver_send_message_void (connection, "SimulateUserActivity", FALSE); + } + + if (do_activate) + { + reply = screensaver_send_message_bool (connection, "SetActive", TRUE); + if (! reply) + { + g_message ("Did not receive a reply from the screensaver."); + goto done; + } + dbus_message_unref (reply); + } + + if (do_deactivate) + { + reply = screensaver_send_message_bool (connection, "SetActive", FALSE); + if (! reply) + { + g_message ("Did not receive a reply from the screensaver."); + goto done; + } + dbus_message_unref (reply); + } + + if (do_inhibit) + { + reply = screensaver_send_message_inhibit (connection, + inhibit_application ? inhibit_application : "Unknown", + inhibit_reason ? inhibit_reason : "Unknown"); + if (! reply) + { + g_message ("Did not receive a reply from the screensaver."); + goto done; + } + dbus_message_unref (reply); + + return FALSE; + } + +done: + g_main_loop_quit (loop); + + return FALSE; +} + +int +main (int argc, + char **argv) +{ + DBusConnection *connection; + DBusError dbus_error; + GOptionContext *context; + gboolean retval; + GError *error = NULL; + +#ifdef ENABLE_NLS + bindtextdomain (GETTEXT_PACKAGE, MATELOCALEDIR); +# ifdef HAVE_BIND_TEXTDOMAIN_CODESET + bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); +# endif + textdomain (GETTEXT_PACKAGE); +#endif + + g_type_init (); + + g_set_prgname (argv[0]); + + if (setlocale (LC_ALL, "") == NULL) + g_warning ("Locale not understood by C library, internationalization will not work\n"); + + context = g_option_context_new (NULL); + g_option_context_add_main_entries (context, entries, NULL); + retval = g_option_context_parse (context, &argc, &argv, &error); + + g_option_context_free (context); + + if (! retval) + { + g_warning ("%s", error->message); + g_error_free (error); + exit (1); + } + + if (do_version) + { + g_print ("%s %s\n", argv [0], VERSION); + exit (1); + } + + dbus_error_init (&dbus_error); + connection = dbus_bus_get (DBUS_BUS_SESSION, &dbus_error); + if (! connection) + { + g_message ("Failed to connect to the D-BUS daemon: %s", dbus_error.message); + dbus_error_free (&dbus_error); + exit (1); + } + + dbus_connection_setup_with_g_main (connection, NULL); + + if (! screensaver_is_running (connection)) + { + g_message ("Screensaver is not running!"); + exit (1); + } + + g_idle_add ((GSourceFunc)do_command, connection); + + loop = g_main_loop_new (NULL, FALSE); + g_main_loop_run (loop); + + return 0; +} |