Filename: //usr//bin/xdg-screensaver

#!/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
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" ] || [ -d "$dir/applnk" ] || continue
        # Check if desktop file contains -
        if [ "${desktop#*-}" != "$desktop" ]; then
            vendor=${desktop%-*}
            app=${desktop#*-}
            if [ -r "$dir/applications/$vendor/$app" ]; then
                file_path=$dir/applications/$vendor/$app
            elif [ -r "$dir/applnk/$vendor/$app" ]; then
                file_path=$dir/applnk/$vendor/$app
            fi
        fi
        if test -z "$file_path" ; then
            for indir in "$dir"/applications/ "$dir"/applications/*/ "$dir"/applnk/ "$dir"/applnk/*/; do
                file="$indir/$desktop"
                if [ -r "$file" ]; then
                    file_path=$file
                    break
                fi
            done
        fi
        if [ -r "$file_path" ]; then
            # Remove any arguments (%F, %f, %U, %u, etc.).
            command="`grep -E "^Exec(\[[^]=]*])?=" "$file_path" | cut -d= -f 2- | first_word`"
            command="`which "$command"`"
            readlink -f "$command"
            return
        fi
    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
       [[:alpha:]]*-*)
         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.3"
            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
         # only recently added to menu-spec, pre-spec X- still in use
         Cinnamon|X-Cinnamon)
           DE=cinnamon;
           ;;
         ENLIGHTENMENT)
           DE=enlightenment;
           ;;
         # GNOME, GNOME-Classic:GNOME, or GNOME-Flashback:GNOME
         GNOME*)
           DE=gnome;
           ;;
         KDE)
           DE=kde;
           ;;
         DEEPIN|Deepin|deepin)
           DE=deepin;
           ;;
         LXDE)
           DE=lxde;
           ;;
         LXQt)
           DE=lxqt;
           ;;
         MATE)
           DE=mate;
           ;;
         XFCE)
           DE=xfce
           ;;
         X-Generic)
           DE=generic
           ;;
      esac
    fi

    if [ x"$DE" = x"" ]; then
      # classic fallbacks
      if [ x"$KDE_FULL_SESSION" != x"" ]; 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
      elif echo $DESKTOP | grep -q '^Enlightenment'; then DE=enlightenment;
      elif [ x"$LXQT_SESSION_CONFIG" != x"" ]; then DE=lxqt;
      fi
    fi

    if [ x"$DE" = x"" ]; then
      # fallback to checking $DESKTOP_SESSION
      case "$DESKTOP_SESSION" in
         gnome)
           DE=gnome;
           ;;
         LXDE|Lubuntu)
           DE=lxde; 
           ;;
         MATE)
           DE=mate;
           ;;
         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 
        CYGWIN*)
          DE=cygwin;
          ;;
        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

    if [ -f "$XDG_RUNTIME_DIR/flatpak-info" ]; then
      DE="flatpak"
    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
}

#----------------------------------------------------------------------------
# Returns true if there is a graphical display attached.

has_display()
{
    if [ -n "$DISPLAY" ] || [ -n "$WAYLAND_DISPLAY" ]; then
        return 0
    else
        return 1
    fi
}

# 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
          xset +dpms
          xset dpms force on
      fi
  fi

  case "$DE" in
    kde)
      if [ -n "${KDE_SESSION_VERSION}" ]; then
        screensaver_freedesktop "$1"
      else
        screensaver_kde3 "$1"
      fi
      ;;
    gnome_screensaver)
      screensaver_gnome_screensaver "$1"
      ;;

    mate_screensaver)
      screensaver_mate_screensaver "$1"
      ;;

    cinnamon)
      screensaver_cinnamon_screensaver "$1"
      ;;

    xscreensaver)
      screensaver_xscreensaver "$1"
      ;;

    xautolock_screensaver)
      xautolock_screensaver "$1"
      ;;

    xfce)
      [ -n "$DISPLAY" ] && screensaver_xserver "$1"
      ;;

    ''|generic)
      [ -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 exit, 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" -o x"$status" = "xfalse" ]; then
            echo "enabled"
        elif [ x"$result" != "x0" ]; then
            echo "ERROR: dbus org.freedesktop.ScreenSaver.GetActive returned '$status'" >&2
            return 1
        else
            echo "disabled"
        fi
        ;;

        *)
        echo "ERROR: Unknown command '$1'" >&2
        return 1
        ;;
    esac
}

screensaver_kde3()
{
    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
}

xset_screensaver_timeout()
{
  xset q | sed '/^Screen Saver:/,/^[^ ]/ { s/.*timeout: *\([0-9]*\).*/\1/; t }; d'
}

screensaver_xserver()
{
    case "$1" in
        suspend)
        timeout=`xset_screensaver_timeout`
        if [ "$timeout" -gt 0 ]; then
            echo "$timeout" > "$screensaver_file.xset"
            xset s off > /dev/null
        fi
        result=$?
        ;;

        resume)
        if [ -f "$screensaver_file.xset" ] ; then
            value=`cat "$screensaver_file.xset"`
            xset s $value > /dev/null
            rm -f "$screensaver_file.xset"
        fi
        result=$?
        ;;

        activate)
        xset s activate > /dev/null
        result=$?
        ;;

        reset)
        xset s reset > /dev/null
        result=$?
        ;;

        status)
        timeout=`xset_screensaver_timeout`
        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)
        perl -e '
use strict;
use warnings;
use Encode qw(decode);
use IO::File;
use Net::DBus;
use X11::Protocol;

my ($window_id, $screensaver_file) = @ARGV;

# Find window name to pass to session manager.
my $x = X11::Protocol->new();
my $named_window_id = hex($window_id);
my $window_name;
while (1) {
  eval { ($window_name) = $x->GetProperty($named_window_id, $x->atom("WM_NAME"),
				   $x->atom("STRING"), 0, 1000, 0); };
  $window_name = "?" if $@;
  last if defined($window_name) && $window_name ne "";
  (undef, $named_window_id) = $x->QueryTree($named_window_id);
  if (!defined($named_window_id)) {
    $window_name = "?";
    last;
  }
}

# Replace any invalid unicode characters with U+FFFD, so we dont crash when we
# pass them over to D-Bus
$window_name = decode("utf8", $window_name, Encode::FB_DEFAULT);

# Inhibit idle detection (flags = 8) with window name and ID.
# We have no reason so just send the window name again.
my $bus = Net::DBus->session();
my $sm_svc = $bus->get_service("org.gnome.SessionManager");
my $sm = $sm_svc->get_object("/org/gnome/SessionManager",
			     "org.gnome.SessionManager");
$sm->Inhibit($window_name, hex($window_id), $window_name, 8);

# Wait until removed from the status file.
while (1) {
  sleep(10);
  my $status = new IO::File($screensaver_file, "r")
    or exit 0;
  my $found;
  while (<$status>) {
    if (/^$window_id:/) {
      $found = 1;
      last;
    }
  }
  exit 0 unless $found;
}
' $window_id $screensaver_file &
        result=0
        ;;

        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_mate_screensaver()
{
# DBUS interface for mate-screensaver
# This is same as gnome's for now but may change in the future as MATE
# does not follow gnome's development necessarily.
    case "$1" in
        suspend)
        screensaver_suspend_loop \
        dbus-send --session \
                  --dest=org.mate.ScreenSaver \
                  --type=method_call \
                  /org/mate/ScreenSaver \
                  org.mate.ScreenSaver.SimulateUserActivity \
                  2> /dev/null
        result=$?
        ;;

        resume)
        # Automatic resume when $screensaver_file disappears
        result=0
        ;;

        activate)
        dbus-send --session \
                  --dest=org.mate.ScreenSaver \
                  --type=method_call \
                  /org/mate/ScreenSaver \
                  org.mate.ScreenSaver.SetActive \
                  boolean:true \
                  2> /dev/null
        result=$?
        ;;

        lock)
        mate-screensaver-command --lock > /dev/null 2> /dev/null
        result=$?
        ;;

        reset)
        # Turns the screensaver off right now
        dbus-send --session \
                  --dest=org.mate.ScreenSaver \
                  --type=method_call \
                  /org/mate/ScreenSaver \
                  org.mate.ScreenSaver.SimulateUserActivity \
                 2> /dev/null
        result=$?
        ;;

        status)
        status=`dbus-send --session \
                          --dest=org.mate.ScreenSaver \
                          --type=method_call \
                          --print-reply \
                          --reply-timeout=2000 \
                          /org/mate/ScreenSaver \
                          org.mate.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.mate.ScreenSaver.GetActive returned '$status'" >&2
            return 1
        else
            echo "disabled"
        fi
        ;;

        *)
        echo "ERROR: Unknown command '$1" >&2
        return 1
        ;;
    esac
}

screensaver_cinnamon_screensaver()
{
# DBUS interface for cinnamon-screensaver
# https://raw.githubusercontent.com/linuxmint/cinnamon-screensaver/master/doc/dbus-interface.html
    case "$1" in
        suspend)
        screensaver_suspend_loop \
        dbus-send --session \
                  --dest=org.cinnamon.ScreenSaver \
                  --type=method_call \
                  /org/cinnamon/ScreenSaver \
                  org.cinnamon.ScreenSaver.SimulateUserActivity \
                  2> /dev/null
        result=$?
        ;;

        resume)
        # Automatic resume when $screensaver_file disappears
        result=0
        ;;

        activate)
        dbus-send --session \
                  --dest=org.cinnamon.ScreenSaver \
                  --type=method_call \
                  /org/cinnamon/ScreenSaver \
                  org.cinnamon.ScreenSaver.SetActive \
                  boolean:true \
                  2> /dev/null
        result=$?
        ;;

        lock)
        dbus-send --session \
                  --dest=org.cinnamon.ScreenSaver \
                  --type=method_call \
                  /org/cinnamon/ScreenSaver \
                  org.cinnamon.ScreenSaver.Lock \
                  string:"" \
                  2> /dev/null

        result=$?
        ;;

        reset)
        # Turns the screensaver off right now
        dbus-send --session \
                  --dest=org.cinnamon.ScreenSaver \
                  --type=method_call \
                  /org/cinnamon/ScreenSaver \
                  org.cinnamon.ScreenSaver.SimulateUserActivity \
                 2> /dev/null
        result=$?
        ;;

        status)
        status=`dbus-send --session \
                          --dest=org.cinnamon.ScreenSaver \
                          --type=method_call \
                          --print-reply \
                          --reply-timeout=2000 \
                          /org/cinnamon/ScreenSaver \
                          org.cinnamon.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.cinnamon.ScreenSaver.GetActive returned '$status'" >&2
            return 1
        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
}

xautolock_screensaver()
{
    case "$1" in
        suspend)
        xset s off && xautolock -disable > /dev/null
        result=$?
        ;;

        resume)
        xset s default && xautolock -enable > /dev/null
        result=$?
        ;;

        activate)
        xautolock -enable
        result=$?
        ;;

        lock)
        xautolock -locknow
        result=$?
        ;;

        reset)
        xautolock -restart
        result=$?
        ;;

        status)
        xautolock -unlocknow >/dev/null
        result=$?
        if [ $result -eq 0 ]; then
            echo "enabled"
        else
            echo "disabled"
        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"
# Consider "mate-screensaver" a separate DE
dbus-send --print-reply --dest=org.freedesktop.DBus /org/freedesktop/DBus org.freedesktop.DBus.GetNameOwner string:org.mate.ScreenSaver > /dev/null 2>&1 && DE="mate_screensaver"
# Consider "cinnamon-screensaver" a separate DE
dbus-send --print-reply --dest=org.freedesktop.DBus /org/freedesktop/DBus org.freedesktop.DBus.GetNameOwner string:org.cinnamon.ScreenSaver > /dev/null 2>&1 && DE="cinnamon"
# Consider "xautolock" a separate DE
xautolock -enable > /dev/null 2>&1 && DE="xautolock_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

./Ninja\.