|
Linux server.jmdstrack.com 3.10.0-1160.119.1.el7.tuxcare.els10.x86_64 #1 SMP Fri Oct 11 21:40:41 UTC 2024 x86_64
/ usr/ bin/ |
|
|
#!/bin/sh
#---------------------------------------------
# xdg-screensaver
#
# Utility script to control screensaver.
#
# Refer to the usage() function below for usage.
#
# Copyright 2006, Bryce Harrington <bryce@osdl.org>
#
# LICENSE:
#
# Permission is hereby granted, free of charge, to any person obtaining a
# copy of this software and associated documentation files (the "Software"),
# to deal in the Software without restriction, including without limitation
# the rights to use, copy, modify, merge, publish, distribute, sublicense,
# and/or sell copies of the Software, and to permit persons to whom the
# Software is furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included
# in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
# OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
# ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
# OTHER DEALINGS IN THE SOFTWARE.
#
#---------------------------------------------
manualpage()
{
cat << _MANUALPAGE
Name
xdg-screensaver -- command line tool for controlling the
screensaver
Synopsis
xdg-screensaver suspend WindowID
xdg-screensaver resume WindowID
xdg-screensaver { activate | lock | reset | status }
xdg-screensaver { --help | --manual | --version }
Description
xdg-screensaver provides commands to control the screensaver.
xdg-screensaver is for use inside a desktop session only. It is
not recommended to use xdg-screensaver as root.
Commands
suspend WindowID
Suspends the screensaver and monitor power management.
WindowID must be the X Window ID of an existing window
of the calling application. The window must remain in
existence for the duration of the suspension.
WindowID can be represented as either a decimal number
or as a hexadecimal number consisting of the prefix 0x
followed by one or more hexadecimal digits.
The screensaver can be suspended in relation to multiple
windows at the same time. In that case screensaver
operation is only restored once the screensaver has been
resumed in relation to each of the windows
resume WindowID
Resume the screensaver and monitor power management
after being suspended. WindowID must be the same X
Window ID that was passed to a previous call of
xdg-screensaver suspend
activate
Turns the screensaver on immediately. This may result in
the screen getting locked, depending on existing system
policies.
lock
Lock the screen immediately.
reset
Turns the screensaver off immediately. If the screen was
locked the user may be asked to authenticate first.
status
Prints enabled to stdout if the screensaver is enabled
to turn on after a period of inactivity and prints
disabled if the screensaver is not enabled.
Options
--help
Show command synopsis.
--manual
Show this manual page.
--version
Show the xdg-utils version information.
Exit Codes
An exit code of 0 indicates success while a non-zero exit code
indicates failure. The following failure codes can be returned:
1
Error in command line syntax.
3
A required tool could not be found.
4
The action failed.
Examples
xdg-screensaver suspend 0x1c00007
Causes the screensaver to be disabled till xdg-screensaver
resume 0x1c00007 is called. 0x1c00007 must be the X Window ID
of an existing window.
_MANUALPAGE
}
usage()
{
cat << _USAGE
xdg-screensaver -- command line tool for controlling the
screensaver
Synopsis
xdg-screensaver suspend WindowID
xdg-screensaver resume WindowID
xdg-screensaver { activate | lock | reset | status }
xdg-screensaver { --help | --manual | --version }
_USAGE
}
#@xdg-utils-common@
#----------------------------------------------------------------------------
# Common utility functions included in all XDG wrapper scripts
#----------------------------------------------------------------------------
DEBUG()
{
[ -z "${XDG_UTILS_DEBUG_LEVEL}" ] && return 0;
[ ${XDG_UTILS_DEBUG_LEVEL} -lt $1 ] && return 0;
shift
echo "$@" >&2
}
# This handles backslashes but not quote marks.
first_word()
{
read first rest
echo "$first"
}
#-------------------------------------------------------------
# map a binary to a .desktop file
binary_to_desktop_file()
{
search="${XDG_DATA_HOME:-$HOME/.local/share}:${XDG_DATA_DIRS:-/usr/local/share:/usr/share}"
binary="`which "$1"`"
binary="`readlink -f "$binary"`"
base="`basename "$binary"`"
IFS=:
for dir in $search; do
unset IFS
[ "$dir" ] || continue
[ -d "$dir/applications" ] || [ -d "$dir/applnk" ] || continue
for file in "$dir"/applications/*.desktop "$dir"/applications/*/*.desktop "$dir"/applnk/*.desktop "$dir"/applnk/*/*.desktop; do
[ -r "$file" ] || continue
# Check to make sure it's worth the processing.
grep -q "^Exec.*$base" "$file" || continue
# Make sure it's a visible desktop file (e.g. not "preferred-web-browser.desktop").
grep -Eq "^(NoDisplay|Hidden)=true" "$file" && continue
command="`grep -E "^Exec(\[[^]=]*])?=" "$file" | cut -d= -f 2- | first_word`"
command="`which "$command"`"
if [ x"`readlink -f "$command"`" = x"$binary" ]; then
# Fix any double slashes that got added path composition
echo "$file" | sed -e 's,//*,/,g'
return
fi
done
done
}
#-------------------------------------------------------------
# map a .desktop file to a binary
## FIXME: handle vendor dir case
desktop_file_to_binary()
{
search="${XDG_DATA_HOME:-$HOME/.local/share}:${XDG_DATA_DIRS:-/usr/local/share:/usr/share}"
desktop="`basename "$1"`"
IFS=:
for dir in $search; do
unset IFS
[ "$dir" ] && [ -d "$dir/applications" ] || continue
file="$dir/applications/$desktop"
[ -r "$file" ] || continue
# Remove any arguments (%F, %f, %U, %u, etc.).
command="`grep -E "^Exec(\[[^]=]*])?=" "$file" | cut -d= -f 2- | first_word`"
command="`which "$command"`"
readlink -f "$command"
return
done
}
#-------------------------------------------------------------
# Exit script on successfully completing the desired operation
exit_success()
{
if [ $# -gt 0 ]; then
echo "$@"
echo
fi
exit 0
}
#-----------------------------------------
# Exit script on malformed arguments, not enough arguments
# or missing required option.
# prints usage information
exit_failure_syntax()
{
if [ $# -gt 0 ]; then
echo "xdg-screensaver: $@" >&2
echo "Try 'xdg-screensaver --help' for more information." >&2
else
usage
echo "Use 'man xdg-screensaver' or 'xdg-screensaver --manual' for additional info."
fi
exit 1
}
#-------------------------------------------------------------
# Exit script on missing file specified on command line
exit_failure_file_missing()
{
if [ $# -gt 0 ]; then
echo "xdg-screensaver: $@" >&2
fi
exit 2
}
#-------------------------------------------------------------
# Exit script on failure to locate necessary tool applications
exit_failure_operation_impossible()
{
if [ $# -gt 0 ]; then
echo "xdg-screensaver: $@" >&2
fi
exit 3
}
#-------------------------------------------------------------
# Exit script on failure returned by a tool application
exit_failure_operation_failed()
{
if [ $# -gt 0 ]; then
echo "xdg-screensaver: $@" >&2
fi
exit 4
}
#------------------------------------------------------------
# Exit script on insufficient permission to read a specified file
exit_failure_file_permission_read()
{
if [ $# -gt 0 ]; then
echo "xdg-screensaver: $@" >&2
fi
exit 5
}
#------------------------------------------------------------
# Exit script on insufficient permission to write a specified file
exit_failure_file_permission_write()
{
if [ $# -gt 0 ]; then
echo "xdg-screensaver: $@" >&2
fi
exit 6
}
check_input_file()
{
if [ ! -e "$1" ]; then
exit_failure_file_missing "file '$1' does not exist"
fi
if [ ! -r "$1" ]; then
exit_failure_file_permission_read "no permission to read file '$1'"
fi
}
check_vendor_prefix()
{
file_label="$2"
[ -n "$file_label" ] || file_label="filename"
file=`basename "$1"`
case "$file" in
[a-zA-Z]*-*)
return
;;
esac
echo "xdg-screensaver: $file_label '$file' does not have a proper vendor prefix" >&2
echo 'A vendor prefix consists of alpha characters ([a-zA-Z]) and is terminated' >&2
echo 'with a dash ("-"). An example '"$file_label"' is '"'example-$file'" >&2
echo "Use --novendor to override or 'xdg-screensaver --manual' for additional info." >&2
exit 1
}
check_output_file()
{
# if the file exists, check if it is writeable
# if it does not exists, check if we are allowed to write on the directory
if [ -e "$1" ]; then
if [ ! -w "$1" ]; then
exit_failure_file_permission_write "no permission to write to file '$1'"
fi
else
DIR=`dirname "$1"`
if [ ! -w "$DIR" ] || [ ! -x "$DIR" ]; then
exit_failure_file_permission_write "no permission to create file '$1'"
fi
fi
}
#----------------------------------------
# Checks for shared commands, e.g. --help
check_common_commands()
{
while [ $# -gt 0 ] ; do
parm="$1"
shift
case "$parm" in
--help)
usage
echo "Use 'man xdg-screensaver' or 'xdg-screensaver --manual' for additional info."
exit_success
;;
--manual)
manualpage
exit_success
;;
--version)
echo "xdg-screensaver 1.1.0 rc1"
exit_success
;;
esac
done
}
check_common_commands "$@"
[ -z "${XDG_UTILS_DEBUG_LEVEL}" ] && unset XDG_UTILS_DEBUG_LEVEL;
if [ ${XDG_UTILS_DEBUG_LEVEL-0} -lt 1 ]; then
# Be silent
xdg_redirect_output=" > /dev/null 2> /dev/null"
else
# All output to stderr
xdg_redirect_output=" >&2"
fi
#--------------------------------------
# Checks for known desktop environments
# set variable DE to the desktop environments name, lowercase
detectDE()
{
# see https://bugs.freedesktop.org/show_bug.cgi?id=34164
unset GREP_OPTIONS
if [ -n "${XDG_CURRENT_DESKTOP}" ]; then
case "${XDG_CURRENT_DESKTOP}" in
GNOME)
DE=gnome;
;;
KDE)
DE=kde;
;;
LXDE)
DE=lxde;
;;
XFCE)
DE=xfce
esac
fi
if [ x"$DE" = x"" ]; then
# classic fallbacks
if [ x"$KDE_FULL_SESSION" = x"true" ]; then DE=kde;
elif [ x"$GNOME_DESKTOP_SESSION_ID" != x"" ]; then DE=gnome;
elif [ x"$MATE_DESKTOP_SESSION_ID" != x"" ]; then DE=mate;
elif `dbus-send --print-reply --dest=org.freedesktop.DBus /org/freedesktop/DBus org.freedesktop.DBus.GetNameOwner string:org.gnome.SessionManager > /dev/null 2>&1` ; then DE=gnome;
elif xprop -root _DT_SAVE_MODE 2> /dev/null | grep ' = \"xfce4\"$' >/dev/null 2>&1; then DE=xfce;
elif xprop -root 2> /dev/null | grep -i '^xfce_desktop_window' >/dev/null 2>&1; then DE=xfce
fi
fi
if [ x"$DE" = x"" ]; then
# fallback to checking $DESKTOP_SESSION
case "$DESKTOP_SESSION" in
gnome)
DE=gnome;
;;
LXDE|Lubuntu)
DE=lxde;
;;
xfce|xfce4|'Xfce Session')
DE=xfce;
;;
esac
fi
if [ x"$DE" = x"" ]; then
# fallback to uname output for other platforms
case "$(uname 2>/dev/null)" in
Darwin)
DE=darwin;
;;
esac
fi
if [ x"$DE" = x"gnome" ]; then
# gnome-default-applications-properties is only available in GNOME 2.x
# but not in GNOME 3.x
which gnome-default-applications-properties > /dev/null 2>&1 || DE="gnome3"
fi
}
#----------------------------------------------------------------------------
# kfmclient exec/openURL can give bogus exit value in KDE <= 3.5.4
# It also always returns 1 in KDE 3.4 and earlier
# Simply return 0 in such case
kfmclient_fix_exit_code()
{
version=`LC_ALL=C.UTF-8 kde-config --version 2>/dev/null | grep '^KDE'`
major=`echo $version | sed 's/KDE.*: \([0-9]\).*/\1/'`
minor=`echo $version | sed 's/KDE.*: [0-9]*\.\([0-9]\).*/\1/'`
release=`echo $version | sed 's/KDE.*: [0-9]*\.[0-9]*\.\([0-9]\).*/\1/'`
test "$major" -gt 3 && return $1
test "$minor" -gt 5 && return $1
test "$release" -gt 4 && return $1
return 0
}
# Check if we can use "mv -T"
if mv -T ... ... 2>&1 | grep '\.\.\.' > /dev/null ; then
# We can securely move files in /tmp with mv -T
DEBUG 1 "mv -T available"
MV="mv -T"
screensaver_file="/tmp/xdg-screensaver-$USER-"`echo $DISPLAY | sed 's/:/-/g'`
else
# No secure moves available, use home dir
DEBUG 1 "mv -T not available"
MV="mv"
screensaver_file="$HOME/.xdg-screensaver-"`echo $(hostname)-$DISPLAY | sed 's/:/-/g'`
fi
lockfile_command=`which lockfile 2> /dev/null`
lockfile()
{
if [ -n "$lockfile_command" ] ; then
$lockfile_command -1 -l 10 -s 3 "$screensaver_file".lock
else
# Poor man's attempt at doing a lockfile
# Be careful not to facilitate a symlink attack
local try
try=0
while ! ln -s "$screensaver_file".lock "$screensaver_file".lock 2> /dev/null;
do
sleep 1
try=$(($try+1))
if [ $try -eq 3 ] ; then
rm -f "$screensaver_file".lock || return # Can't remove lockfile
try=0
fi
done
fi
}
unlockfile()
{
rm -f "$screensaver_file".lock
}
perform_action()
{
result=1
if [ "$1" = "resume" ] ; then
# Restore DPMS state
if [ -f "$screensaver_file.dpms" ]; then
rm "$screensaver_file.dpms"
# Re-enable DPMS
xset +dpms
fi
fi
if [ "$1" = "reset" ] ; then
if xset -q | grep 'DPMS is Enabled' > /dev/null 2> /dev/null; then
xset dpms force on
fi
fi
case "$DE" in
kde)
if [ x"$KDE_SESSION_VERSION" = x"4" ]; then
screensaver_freedesktop "$1"
else
screensaver_kde "$1"
fi
;;
gnome_screensaver)
screensaver_gnome_screensaver "$1"
;;
xscreensaver)
screensaver_xscreensaver "$1"
;;
'')
[ -n "$DISPLAY" ] && screensaver_xserver "$1"
;;
esac
if [ -n "$DISPLAY" -a "$1" = "suspend" ] ; then
# Save DPMS state
if xset -q | grep 'DPMS is Enabled' > /dev/null 2> /dev/null; then
test "${TMPDIR+set}" = set || TMPDIR=/tmp
tmpfile=`mktemp $TMPDIR/tmp.XXXXXXXXXX`
$MV "$tmpfile" "$screensaver_file.dpms"
# Disable DPMS
xset -dpms
fi
fi
}
cleanup_suspend()
{
lockfile
test "${TMPDIR+set}" = set || TMPDIR=/tmp
tmpfile=`mktemp $TMPDIR/tmp.XXXXXXXXXX`
grep -v "$window_id:$xprop_pid\$" "$screensaver_file" > "$tmpfile" 2> /dev/null
$MV "$tmpfile" "$screensaver_file"
if [ ! -s "$screensaver_file" ] ; then
rm "$screensaver_file"
unlockfile
# $screensaver_file is empty, do resume
perform_action resume
else
unlockfile
fi
}
do_resume()
{
lockfile # Obtain lockfile
# Find the PID of the trackingprocess
xprop_pid=`grep "$window_id:" "$screensaver_file" 2> /dev/null | cut -d ':' -f 2`
unlockfile # Free lockfile
if [ -n "$xprop_pid" ] && ps -p "$xprop_pid" 2> /dev/null | grep xprop > /dev/null; then
# Kill the tracking process
kill -s TERM $xprop_pid
fi
cleanup_suspend
}
XPROP=`which xprop 2> /dev/null`
check_window_id()
{
if [ -z "$XPROP" ]; then
DEBUG 3 "xprop not found"
return
fi
DEBUG 2 "Running $XPROP -id $window_id"
if $XPROP -id $window_id > /dev/null 2> /dev/null; then
DEBUG 3 Window $window_id exists
else
DEBUG 3 Window $window_id does not exist
exit_failure_operation_failed "Window $window_id does not exist"
fi
}
track_window()
{
if [ -z "$XPROP" ]; then
# Don't track window if we don't have xprop
return
fi
lockfile
test "${TMPDIR+set}" = set || TMPDIR=/tmp
tmpfile=`mktemp $TMPDIR/tmp.XXXXXXXXXX`
# Filter stale entries from the xdg-screensaver status file
# Return if $window_id is being tracked already
(
already_tracked=1
IFS_save="$IFS"
IFS=":"
while read wid pid; do
if ps -p "$pid" 2> /dev/null | grep xprop > /dev/null; then
echo "$wid:$pid"
if [ $wid = $window_id ] ; then
already_tracked=0
fi
fi
done
IFS="$IFS_save"
exit $already_tracked
) < $screensaver_file > $tmpfile
already_tracked=$?
if [ "$already_tracked" -eq "0" ] ; then
$MV "$tmpfile" "$screensaver_file"
# We are already tracking $window_id, don't do anything
unlockfile
return
fi
# Start tracking $window_id
$XPROP -id $window_id -spy > /dev/null &
xprop_pid=$!
# Add window_id and xprop_pid to the xdg-screensave status file
echo "$window_id:$xprop_pid" >> $tmpfile
$MV "$tmpfile" "$screensaver_file"
unlockfile
# Wait for xprop to edit, it means that the window disappeared
wait $xprop_pid
# Clean up the administration and resume the screensaver
cleanup_suspend
}
screensaver_freedesktop()
{
case "$1" in
suspend)
dbus-send --session \
--dest=org.freedesktop.ScreenSaver \
--type=method_call \
--print-reply \
--reply-timeout=2000 \
/ScreenSaver \
org.freedesktop.ScreenSaver.Inhibit \
string:$window_id \
string:xdg-screensaver \
| grep uint32 | cut -d ' ' -f 5 >| "$screensaver_file.cookie" \
2> /dev/null
result=$?
;;
resume)
if [ -f "$screensaver_file.cookie" ] ; then
value=`cat "$screensaver_file.cookie"`
dbus-send --session \
--dest=org.freedesktop.ScreenSaver \
--type=method_call \
/ScreenSaver \
org.freedesktop.ScreenSaver.UnInhibit \
uint32:$value \
2> /dev/null
rm -f "$screensaver_file.cookie"
fi
result=$?
;;
activate)
dbus-send --session \
--dest=org.freedesktop.ScreenSaver \
--type=method_call \
/ScreenSaver \
org.freedesktop.ScreenSaver.SetActive \
boolean:true \
2> /dev/null
result=$?
;;
lock)
dbus-send --session \
--dest=org.freedesktop.ScreenSaver \
--type=method_call \
/ScreenSaver \
org.freedesktop.ScreenSaver.Lock \
2> /dev/null
;;
reset)
if [ -f "$screensaver_file.cookie" ] ; then
value=`cat "$screensaver_file.cookie"`
dbus-send --session \
--dest=org.freedesktop.ScreenSaver \
--type=method_call \
/ScreenSaver \
org.freedesktop.ScreenSaver.UnInhibit \
uint32:$value \
2> /dev/null
rm -f "$screensaver_file.cookie"
fi
result=$?
;;
status)
status=`dbus-send --session \
--dest=org.freedesktop.ScreenSaver \
--type=method_call \
--print-reply \
--reply-timeout=2000 \
/ScreenSaver \
org.freedesktop.ScreenSaver.GetActive \
| grep boolean | cut -d ' ' -f 5`
result=$?
if [ x"$status" = "xtrue" ]; then
echo "enabled"
elif [ x"$status" = "xfalse" ]; then
echo "disabled"
else
echo "ERROR: dbus org.freedesktop.ScreenSaver.GetActive returned '$status'" >&2
return 1
fi
;;
*)
echo "ERROR: Unknown command '$1'" >&2
return 1
;;
esac
}
screensaver_kde()
{
case "$1" in
suspend)
dcop kdesktop KScreensaverIface enable false > /dev/null
result=$?
;;
resume)
dcop kdesktop KScreensaverIface configure > /dev/null
result=$?
;;
activate)
dcop kdesktop KScreensaverIface save > /dev/null
result=$?
;;
lock)
dcop kdesktop KScreensaverIface lock > /dev/null
result=$?
;;
reset)
# Turns the screensaver off right now
dcop kdesktop KScreensaverIface quit > /dev/null
result=$?
;;
status)
status=`dcop kdesktop KScreensaverIface isEnabled`
result=$?
if [ x"$status" = "xtrue" ]; then
echo "enabled"
elif [ x"$status" = "xfalse" ]; then
echo "disabled"
else
echo "ERROR: kdesktop KScreensaverIface isEnabled returned '$status'" >&2
return 1
fi
;;
*)
echo "ERROR: Unknown command '$1'" >&2
return 1
;;
esac
}
screensaver_xserver()
{
case "$1" in
suspend)
xset s off > /dev/null
result=$?
;;
resume)
xset s default > /dev/null
result=$?
;;
activate)
xset s activate > /dev/null
result=$?
;;
reset)
xset s reset > /dev/null
result=$?
;;
status)
timeout=`xset q | sed '/^Screen Saver:/,/^[^ ]/ { s/.*timeout: *\([0-9]*\).*/\1/; t }; d'`
result=$?
if [ "$timeout" -gt 0 ]; then
echo "enabled"
elif [ "$timeout" -eq 0 ]; then
echo "disabled"
else
echo "ERROR: xset q did not report the screensaver timeout" >&2
return 1
fi
;;
*)
echo "ERROR: Unknown command '$1'" >&2
return 1
;;
esac
}
screensaver_suspend_loop()
{
lockfile
test "${TMPDIR+set}" = set || TMPDIR=/tmp
tmpfile=`mktemp $TMPDIR/tmp.XXXXXXXXXX`
# Filter stale entries from the xdg-screensaver status file
cat "$screensaver_file" 2> /dev/null | (
IFS_save="$IFS"
IFS=":"
while read wid pid; do
if ps -p "$pid" 2> /dev/null | grep xprop > /dev/null; then
echo "$wid:$pid"
fi
done
IFS="$IFS_save"
) > $tmpfile
if [ -s "$tmpfile" ] ; then
# Suspend pending, don't do a thing
$MV "$tmpfile" "$screensaver_file"
unlockfile
return
fi
$MV "$tmpfile" "$screensaver_file"
unlockfile
(while [ -f "$screensaver_file" ]; do $*; sleep 50; done) > /dev/null 2> /dev/null &
}
screensaver_gnome_screensaver()
{
# DBUS interface for gnome-screensaver
# http://people.gnome.org/~mccann/gnome-screensaver/docs/gnome-screensaver.html
case "$1" in
suspend)
screensaver_suspend_loop \
dbus-send --session \
--dest=org.gnome.ScreenSaver \
--type=method_call \
/org/gnome/ScreenSaver \
org.gnome.ScreenSaver.SimulateUserActivity \
2> /dev/null
result=$?
;;
resume)
# Automatic resume when $screensaver_file disappears
result=0
;;
activate)
dbus-send --session \
--dest=org.gnome.ScreenSaver \
--type=method_call \
/org/gnome/ScreenSaver \
org.gnome.ScreenSaver.SetActive \
boolean:true \
2> /dev/null
result=$?
;;
lock)
dbus-send --session \
--dest=org.gnome.ScreenSaver \
--type=method_call \
/org/gnome/ScreenSaver \
org.gnome.ScreenSaver.Lock \
2> /dev/null
result=$?
;;
reset)
# Turns the screensaver off right now
dbus-send --session \
--dest=org.gnome.ScreenSaver \
--type=method_call \
/org/gnome/ScreenSaver \
org.gnome.ScreenSaver.SimulateUserActivity \
2> /dev/null
result=$?
;;
status)
status=`dbus-send --session \
--dest=org.gnome.ScreenSaver \
--type=method_call \
--print-reply \
--reply-timeout=2000 \
/org/gnome/ScreenSaver \
org.gnome.ScreenSaver.GetActive \
| grep boolean | cut -d ' ' -f 5`
result=$?
if [ x"$status" = "xtrue" -o x"$status" = "xfalse" ]; then
echo "enabled"
elif [ x"$result" != "x0" ]; then
echo "ERROR: dbus org.gnome.ScreenSaver.GetActive returned '$status'" >&2
return 1
else
echo "disabled"
fi
;;
*)
echo "ERROR: Unknown command '$1" >&2
return 1
;;
esac
}
screensaver_xscreensaver()
{
case "$1" in
suspend)
screensaver_suspend_loop xscreensaver-command -deactivate
result=0
;;
resume)
# Automatic resume when $screensaver_file disappears
result=0
;;
activate)
xscreensaver-command -activate > /dev/null 2> /dev/null
result=$?
;;
lock)
xscreensaver-command -lock > /dev/null 2> /dev/null
result=$?
;;
reset)
# Turns the screensaver off right now
xscreensaver-command -deactivate > /dev/null 2> /dev/null
result=$?
;;
status)
result=0
if [ -f "$screensaver_file" ] ; then
echo "disabled"
else
echo "enabled"
fi
;;
*)
echo "ERROR: Unknown command '$1" >&2
return 1
;;
esac
}
[ x"$1" != x"" ] || exit_failure_syntax
action=
window_id=
case $1 in
suspend)
action="$1"
shift
if [ -z "$1" ] ; then
exit_failure_syntax "WindowID argument missing"
fi
window_id="$1"
check_window_id
;;
resume)
action="$1"
shift
if [ -z "$1" ] ; then
exit_failure_syntax "WindowID argument missing"
fi
window_id="$1"
check_window_id
;;
activate)
action="$1"
;;
lock)
action="$1"
;;
reset)
action="$1"
;;
status)
action="$1"
;;
*)
exit_failure_syntax "unknown command '$1'"
;;
esac
detectDE
# Consider "xscreensaver" a separate DE
xscreensaver-command -version 2> /dev/null | grep XScreenSaver > /dev/null && DE="xscreensaver"
# Consider "gnome-screensaver" a separate DE
dbus-send --print-reply --dest=org.freedesktop.DBus /org/freedesktop/DBus org.freedesktop.DBus.GetNameOwner string:org.gnome.ScreenSaver > /dev/null 2>&1 && DE="gnome_screensaver"
if [ "$action" = "resume" ] ; then
do_resume
exit_success
fi
perform_action "$action"
if [ "$action" = "suspend" ] ; then
# Start tracking $window_id and resume the screensaver once it disappears
( track_window ) 2> /dev/null > /dev/null &
fi
if [ $result -eq 0 ]; then
exit_success
else
exit_failure_operation_failed
fi