int main(int argc, char **argv)
{
GSMonitor* monitor;
GError* error = NULL;
static gboolean show_version = FALSE;
static gboolean no_daemon = TRUE;
static gboolean debug = FALSE;
static GOptionEntry entries[] = {
{"version", 0, 0, G_OPTION_ARG_NONE, &show_version, N_("Version of this application"), NULL},
{"no-daemon", 0, 0, G_OPTION_ARG_NONE, &no_daemon, N_("Don't become a daemon"), NULL},
{"debug", 0, 0, G_OPTION_ARG_NONE, &debug, N_("Enable debugging code"), NULL},
{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
if (!gtk_init_with_args(&argc, &argv, NULL, entries, NULL, &error))
{
if (error)
{
g_warning("%s", error->message);
g_error_free(error);
}
else
{
g_warning("Unable to initialize GTK+");
}
exit(1);
}
if (show_version)
{
g_print("%s %s\n", argv[0], VERSION);
exit(1);
}
/* debug to a file if in deamon mode */
gs_debug_init(debug, FALSE);
gs_debug("initializing mate-screensaver %s", VERSION);
monitor = gs_monitor_new();
if (monitor == NULL)
{
exit (1);
}
error = NULL;
if (!gs_monitor_start(monitor, &error))
{
if (error)
{
g_warning("%s", error->message);
g_error_free(error);
}
else
{
g_warning("Unable to start screensaver");
}
exit(1);
}
gtk_main();
g_object_unref(monitor);
gs_debug("mate-screensaver finished");
gs_debug_shutdown();
return 0;
}
static gboolean
gs_grab_move_mouse (GSGrab *grab,
GdkWindow *window,
GdkScreen *screen,
gboolean hide_cursor)
{
gboolean result;
GdkWindow *old_window;
GdkScreen *old_screen;
gboolean old_hide_cursor;
/* if the pointer is not grabbed and we have a
mouse_grab_window defined then we lost the grab */
if (! gdk_pointer_is_grabbed ())
{
gs_grab_mouse_reset (grab);
}
if (grab->priv->mouse_grab_window == window)
{
gs_debug ("Window %X is already grabbed, skipping",
(guint32) GDK_WINDOW_XID (grab->priv->mouse_grab_window));
return TRUE;
}
#if 0
gs_debug ("Intentionally skipping move pointer grabs");
/* FIXME: GTK doesn't like having the pointer grabbed */
return TRUE;
#else
if (grab->priv->mouse_grab_window)
{
gs_debug ("Moving pointer grab from %X to %X",
(guint32) GDK_WINDOW_XID (grab->priv->mouse_grab_window),
(guint32) GDK_WINDOW_XID (window));
}
else
{
gs_debug ("Getting pointer grab on %X",
(guint32) GDK_WINDOW_XID (window));
}
#endif
gs_debug ("*** doing X server grab");
gdk_x11_grab_server ();
old_window = grab->priv->mouse_grab_window;
old_screen = grab->priv->mouse_grab_screen;
old_hide_cursor = grab->priv->mouse_hide_cursor;
if (old_window)
{
gs_grab_release_mouse (grab);
}
result = gs_grab_get_mouse (grab, window, screen, hide_cursor);
if (result != GDK_GRAB_SUCCESS)
{
sleep (1);
result = gs_grab_get_mouse (grab, window, screen, hide_cursor);
}
if ((result != GDK_GRAB_SUCCESS) && old_window)
{
gs_debug ("Could not grab mouse for new window. Resuming previous grab.");
gs_grab_get_mouse (grab, old_window, old_screen, old_hide_cursor);
}
gs_debug ("*** releasing X server grab");
gdk_x11_ungrab_server ();
gdk_flush ();
return (result == GDK_GRAB_SUCCESS);
}
gboolean
gs_grab_grab_window (GSGrab *grab,
GdkWindow *window,
GdkScreen *screen,
gboolean hide_cursor)
{
gboolean mstatus = FALSE;
gboolean kstatus = FALSE;
int i;
int retries = 4;
gboolean focus_fuckus = FALSE;
AGAIN:
for (i = 0; i < retries; i++)
{
kstatus = gs_grab_get_keyboard (grab, window, screen);
if (kstatus == GDK_GRAB_SUCCESS)
{
break;
}
/* else, wait a second and try to grab again. */
sleep (1);
}
if (kstatus != GDK_GRAB_SUCCESS)
{
if (!focus_fuckus)
{
focus_fuckus = TRUE;
gs_grab_nuke_focus ();
goto AGAIN;
}
}
for (i = 0; i < retries; i++)
{
mstatus = gs_grab_get_mouse (grab, window, screen, hide_cursor);
if (mstatus == GDK_GRAB_SUCCESS)
{
break;
}
/* else, wait a second and try to grab again. */
sleep (1);
}
if (mstatus != GDK_GRAB_SUCCESS)
{
gs_debug ("Couldn't grab pointer! (%s)",
grab_string (mstatus));
}
#if 0
/* FIXME: release the pointer grab so GTK will work */
gs_grab_release_mouse (grab);
#endif
/* When should we allow blanking to proceed? The current theory
is that both a keyboard grab and a mouse grab are mandatory
- If we don't have a keyboard grab, then we won't be able to
read a password to unlock, so the kbd grab is manditory.
- If we don't have a mouse grab, then we might not see mouse
clicks as a signal to unblank, on-screen widgets won't work ideally,
and gs_grab_move_to_window() will spin forever when it gets called.
*/
if (kstatus != GDK_GRAB_SUCCESS || mstatus != GDK_GRAB_SUCCESS)
{
/* Do not blank without a keyboard and mouse grabs. */
/* Release keyboard or mouse which was grabbed. */
if (kstatus == GDK_GRAB_SUCCESS)
{
gs_grab_release_keyboard (grab);
}
if (mstatus == GDK_GRAB_SUCCESS)
{
gs_grab_release_mouse (grab);
}
return FALSE;
}
/* Grab is good, go ahead and blank. */
return TRUE;
}
static void
on_screen_monitors_changed (GdkScreen *screen,
GSManager *manager)
{
GSList *l;
int n_monitors;
int n_windows;
int i;
n_monitors = gdk_screen_get_n_monitors (screen);
n_windows = g_slist_length (manager->priv->windows);
gs_debug ("Monitors changed for screen %d: num=%d",
gdk_screen_get_number (screen),
n_monitors);
if (n_monitors > n_windows) {
/* Tear down unlock dialog in case we want to move it
* to a new monitor
*/
l = manager->priv->windows;
while (l != NULL) {
gs_window_cancel_unlock_request (GS_WINDOW (l->data));
l = l->next;
}
/* add more windows */
for (i = n_windows; i < n_monitors; i++) {
gs_manager_create_window_for_monitor (manager, screen, i);
}
/* And put unlock dialog up where ever it's supposed to be
*/
gs_manager_request_unlock (manager);
} else {
gdk_x11_grab_server ();
/* remove the extra windows */
l = manager->priv->windows;
while (l != NULL) {
GdkScreen *this_screen;
int this_monitor;
GSList *next = l->next;
this_screen = gs_window_get_screen (GS_WINDOW (l->data));
this_monitor = gs_window_get_monitor (GS_WINDOW (l->data));
if (this_screen == screen && this_monitor >= n_monitors) {
gs_window_destroy (GS_WINDOW (l->data));
manager->priv->windows = g_slist_delete_link (manager->priv->windows, l);
}
l = next;
}
/* make sure there is a lock dialog on a connected monitor,
* and that the keyboard is still properly grabbed after all
* the windows above got destroyed*/
if (n_windows > n_monitors) {
gs_manager_request_unlock (manager);
}
gdk_flush ();
gdk_x11_ungrab_server ();
}
}
static void
window_unmap_cb (GSWindow *window,
GSManager *manager)
{
gs_debug ("window unmapped!");
}
static void
window_map_cb (GSWindow *window,
GSManager *manager)
{
gs_debug ("Handling window map event");
}
static void
on_bg_changed (GnomeBG *bg,
GSManager *manager)
{
gs_debug ("background changed");
}
/* Figuring out what the appropriate XSetScreenSaver() parameters are
(one wouldn't expect this to be rocket science.)
*/
static void
disable_builtin_screensaver (GSWatcher *watcher,
gboolean unblank_screen)
{
int current_server_timeout, current_server_interval;
int current_prefer_blank, current_allow_exp;
int desired_server_timeout, desired_server_interval;
int desired_prefer_blank, desired_allow_exp;
XGetScreenSaver (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()),
¤t_server_timeout,
¤t_server_interval,
¤t_prefer_blank,
¤t_allow_exp);
desired_server_timeout = current_server_timeout;
desired_server_interval = current_server_interval;
desired_prefer_blank = current_prefer_blank;
desired_allow_exp = current_allow_exp;
desired_server_interval = 0;
/* I suspect (but am not sure) that DontAllowExposures might have
something to do with powering off the monitor as well, at least
on some systems that don't support XDPMS? Who know... */
desired_allow_exp = AllowExposures;
/* When we're not using an extension, set the server-side timeout to 0,
so that the server never gets involved with screen blanking, and we
do it all ourselves. (However, when we *are* using an extension,
we tell the server when to notify us, and rather than blanking the
screen, the server will send us an X event telling us to blank.)
*/
desired_server_timeout = 0;
if (desired_server_timeout != current_server_timeout
|| desired_server_interval != current_server_interval
|| desired_prefer_blank != current_prefer_blank
|| desired_allow_exp != current_allow_exp) {
gs_debug ("disabling server builtin screensaver:"
" (xset s %d %d; xset s %s; xset s %s)",
desired_server_timeout,
desired_server_interval,
(desired_prefer_blank ? "blank" : "noblank"),
(desired_allow_exp ? "expose" : "noexpose"));
XSetScreenSaver (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()),
desired_server_timeout,
desired_server_interval,
desired_prefer_blank,
desired_allow_exp);
XSync (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), FALSE);
}
if (unblank_screen) {
/* Turn off the server builtin saver if it is now running. */
XForceScreenSaver (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), ScreenSaverReset);
}
}
