| #!/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 existance 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 manualpage. |
| --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" -o -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" -a -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" -o ! -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 `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) |
| DE=lxde; |
| ;; |
| xfce|xfce4) |
| 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" |
| ;; |
| |
| '') |
| screensaver_xserver "$1" |
| ;; |
| esac |
| |
| if [ "$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) |
| gnome-screensaver-command --lock > /dev/null 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 |
| gnome-screensaver-command -q > /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 |
