#!/bin/sh
############################################################ IDENT(1)
#
# $Title: Script for managing conky and desktop wallpaper $
# $Copyright: 2019-2026 Devin Teske. All rights reserved. $
# $FrauBSD: condy/condy.in 2026-09-19 13:28:24 -0700 Devin Teske $
#
############################################################ ENVIRONMENT

#
# X display
#
: "${DISPLAY:=:0}"

############################################################ DEFAULTS

#
# Config file(s)
# NB: Can be used to override below CONFIGURATION settings
#
DEFAULT_CONDY_CONFIG=/usr/local/etc/condy.conf
DEFAULT_CONDY_USER_CONFIG=.condy.conf

#
# Pause/Unpause functionality
# NB: Paths are relative to home directory
#
PAUSE_FILE=.condy.paused

#
# Set wallpaper functionality
# NB: Paths are relative to home directory
#
SET_WALLPAPER_FILE=.condy.set_wallpaper

#
# Debugging
# NB: Paths are relative to home directory
#
DEFAULT_CONDY_LOG=.condy.log
DEFAULT_DEBUG=0

############################################################ CONFIGURATION

#
# Where to find landscape (wider than tall) wallpaper
# NB: Paths are relative to home directory
# NB: Sample images ship in theme/wallpaper (copy to ~/theme/wallpaper)
#
WALLPAPER=theme/wallpaper

#
# Where to find portrait (taller than wide) wallpaper
# NB: Paths are relative to home directory
# NB: Sample images ship in theme/tallpaper (copy to ~/theme/tallpaper)
#
TALLPAPER=theme/tallpaper

#
# Conky configuration file(s)
# NB: Paths are relative to home directory
# NB: ident.conkyrc is 1200-wide 10pt (1280 display)
# NB: ident-hires.conkyrc is 1536-wide 12pt (1600)
#
CONKY_CONFIG=theme/conky/ident.conkyrc
CONKY_GNOME_CONFIG=theme/conky/ident-gnome.conkyrc
CONKY_KDE_CONFIG=theme/conky/ident-kde.conkyrc

#
# How often (in seconds) to rotate the desktop
# NB: Rotation is to a random image in WALLPAPER/TALLPAPER directory
# MB: Should be evenly divisible by CONDY_DESKTOP_CHECK
#
CONDY_DESKTOP_INTERVAL=600 # 10 minutes
CONDY_DESKTOP_CHECK=5 # seconds

#
# Timeouts
# NB: Values are in seconds
#
CONDY_DESKTOP_TIMEOUT=10
DBUS_TIMEOUT=60

############################################################ GLOBALS

VERSION='$Version: 3.2 $'

pgm="${0##*/}" # Program basename

#
# Global exit status
#
SUCCESS=0
FAILURE=1

#
# Command-line options
#
CONDY_CONFIG="$DEFAULT_CONDY_CONFIG"		# -s file
CONDY_LOG="$DEFAULT_CONDY_LOG"			# -l file
CONDY_USER_CONFIG="$DEFAULT_CONDY_USER_CONFIG"	# -u file
DEBUG=$DEFAULT_DEBUG				# -d
QUIET=						# -q
UPDATE=						# -u

#
# DBus registry elements
# NB: Any one will trigger start, else timeout
#
DBUS_GNOME=org.gnome.SessionManager
DBUS_KDE=org.kde.kuiserver
DBUS_WAIT_FOR="
	$DBUS_GNOME
	$DBUS_KDE
" # END-QUOTE

#
# DBus regex
#
DBUS_GNOME_RE="\\<$( echo "$DBUS_GNOME" | awk 'gsub(/\./, "\\.")||1' )\\>"
DBUS_KDE_RE="\\<$( echo "$DBUS_KDE" | awk 'gsub(/\./, "\\.")||1' )\\>"
DBUS_WAIT_RE="\\<\\($( echo "$DBUS_WAIT_FOR" | xargs -n 1 | awk '
	{
		re = $0
		gsub(/\./, "\\.", re)
		buf = buf "\\|" re
	}
	END { print substr(buf, 3) }
' )\\)\\>"

#
# pgrep regex
#
CONDY_DESKTOP_WORKER_RE="^/bin/sh .*CONDY_DESKTOP_WORKER"
CONDY_STARTUP_RE="^/bin/sh .*CONDY_STARTUP"
CONKY_RE="^conky"

############################################################ EXPORTED FUNCTIONS

exec 9<<'EOF'
die(){ log "$@"; exit $FAILURE; }
emit(){ [ ! "$QUIET" ] || return $SUCCESS; echo "$@"; }
have(){ type "$@" > /dev/null 2>&1; }
print(){ [ ! "$QUIET" ] || return $SUCCESS; printf "$@"; }

if [ $DEBUG -gt 0 ]; then
log()
{
	local OPTIND=1 OPTARG flag
	local debug_min=1

	while getopts d: flag; do
		case "$flag" in
		d) debug_min="$OPTARG" ;;
		*) break
		esac
	done
	shift $(( $OPTIND - 1 ))

	[ $DEBUG -ge $debug_min ] || return $SUCCESS

	local fmt="$1"
	[ "$fmt" ] || return $SUCCESS

	shift 1 # fmt
	printf "[%s] $fmt\n" "$( date )" "$@" >> "$CONDY_LOG"
}
else
log()
{
	return $SUCCESS
}
fi # ! DEBUG

dbus_listnames()
{
	dbus-send \
		--session \
		--dest=org.freedesktop.DBus \
		--type=method_call \
		--print-reply \
		/org/freedesktop/DBus \
		org.freedesktop.DBus.ListNames
}

load_configs()
{
	local config
	local log=/dev/null
	local note
	local path
	local var

	# Load default configuration settings
	load_defaults

	# Load configuration files
	[ $DEBUG -lt 1 ] || log="$CONDY_LOG"
	for config in \
		"$CONDY_CONFIG" \
		"$CONDY_USER_CONFIG" \
	; do
		[ -f "$config" ] || continue
		log "Loading %s" "$config"
		. "$config" >> "$log" 2>&1 || : errors ignored
	done

	for var in WALLPAPER TALLPAPER; do
		eval path=\"\$$var\"
		note=exists
		[ -e "$path" ] || note="does not exist"
		log -d 2 "$var=[%s] %s" "$path" "$note"
	done

	return $SUCCESS
}

getres()
{
	local size=
	local debug=

	[ $DEBUG -gt 0 ] && debug='2>> "$CONDY_LOG"'

	USE_TALLPAPER=

	# Try to get the current resolution
	if have xwininfo; then
		log -d 3 "Getting current resolution with xwininfo"
		if ! size=$( eval xwininfo -root $debug ); then
			log -d 4 "xwininfo failed"
			return $FAILURE
		fi
		size=$( echo "$size" | awk '
			$1 == "Width:" { width = $2 }
			$1 == "Height:" { height = $2 }
			END { print height, width }
		' )
	elif have xrandr; then
		log -d 3 "Getting current resolution with xrandr"
		if ! size=$( eval xrandr $debug ); then
			log -d 4 "xrandr failed"
			return $FAILURE
		fi
		size=$( echo "$size" | awk '
			sub(/.*current /, "") {
				sub(/,.*/, "")
				print $3, $1
				exit
			}
		' )
	fi

	if [ ! "$size" ]; then
		log -d 4 "Unable to get current resolution"
		return $FAILURE
	fi 

	HEIGHT="${size%%[$IFS]*}"
	WIDTH="${size#*[$IFS]}"

	if [ ${HEIGHT:-0} -gt ${WIDTH:-0} ]; then
		[ ! -e "$TALLPAPER" ] || USE_TALLPAPER=1
	fi

	return $SUCCESS
}
EOF
FUNCTIONS=$( cat <&9 )

exec 9<<EOF
load_defaults()
{
	log -d 2 "Loading config defaults"
	WALLPAPER=$WALLPAPER
	TALLPAPER=$TALLPAPER
	CONDY_DESKTOP_INTERVAL=$CONDY_DESKTOP_INTERVAL
	CONDY_DESKTOP_CHECK=$CONDY_DESKTOP_CHECK
	CONDY_DESKTOP_TIMEOUT=$CONDY_DESKTOP_TIMEOUT
	DBUS_TIMEOUT=$DBUS_TIMEOUT
}
EOF
FUNCTIONS="$FUNCTIONS
$( cat <&9 )"

eval "$FUNCTIONS"

############################################################ FUNCTIONS

usage()
{
	local fmt="$1"
	local pgmfmt="Usage: %s [OPTIONS] %s\n"
	local argfmt="\t%-10s %s\n"
	local optfmt="\t%-10s %s\n"
	exec >&2
	if [ "$fmt" ]; then
		shift 1 # fmt
		printf "%s: $fmt\n" "$pgm" "$@"
	fi
	printf "$pgmfmt" "$pgm" "arg"
	printf "Arguments:\n"
	printf "$argfmt" "start" "Start conky and desktop worker(s)."
	printf "$argfmt" "stop" "Stop conky and desktop worker(s)."
	printf "$argfmt" "status" \
		"Display status of conky and desktop worker(s)."
	printf "$argfmt" "restart" "Restart conky and desktop worker(s)."
	printf "More Arguments:\n"
	printf "$argfmt" "cycle" "Cycle through wallpaper."
	printf "$argfmt" "load" "Same as restart."
	printf "$argfmt" "pause" "Pause desktop wallpaper."
	printf "$argfmt" "refresh" "Refresh existing desktop wallpaper."
	printf "$argfmt" "reload" "Change desktop wallpaper."
	printf "$argfmt" "resume" "Unpause desktop wallpaper."
	printf "$argfmt" "set" "Set wallpaper. Requires file path."
	printf "$argfmt" "unpause" "Same as resume."
	printf "Options:\n"
	printf "$optfmt" "-d" "Enable debugging to \`$CONDY_LOG'."
	printf "$optfmt" "" \
		"Can be specified multiple (up to 5) times."
	printf "$optfmt" "-h" "Print usage statement and exit."
	printf "$optfmt" "-l file" \
		"Debug log file. Default \`$DEFAULT_CONDY_LOG'."
	printf "$optfmt" "-q" "Quiet. Hide informational messages."
	printf "$optfmt" "-s file" \
		"System config file. Default \`$DEFAULT_CONDY_CONFIG'."
	printf "$optfmt" "-u file" \
		"User config file. Default \`$DEFAULT_CONDY_USER_CONFIG'."
	printf "$optfmt" "-v" "Print version and exit."
	die
}

start()
{
	local pids

	#
	# [Re-]Initialize log file
	#
	if [ $DEBUG -gt 0 ]; then
		emit "Logging to $CONDY_LOG"
		:> "$CONDY_LOG"
		log "Condy started"
		log "DISPLAY=[%s]" "$DISPLAY"
		if have xauth; then
			log "xauth list"
			xauth list >> "$CONDY_LOG"
		fi
		if [ $DEBUG -ge 5 ]; then
			log "DBus monitor log monitor.%u.log" $$
			nohup /bin/sh -c 'dbus-monitor > monitor.$$.log 2>&1' \
				> /dev/null 2>&1 &
		fi
	fi

	#
	# Load configuration files
	#
	load_configs

	#
	# export variables required by backgrounded processes
	#
	export CONDY_DESKTOP_CHECK CONDY_DESKTOP_INTERVAL CONDY_DESKTOP_TIMEOUT
	export CONDY_DESKTOP_WORKER CONDY_DESKTOP_WORKER_RE
	export CONDY_CONFIG CONDY_USER_CONFIG CONDY_LOG PAUSE_FILE
	export CONDY_STARTUP CONDY_STARTUP_RE
	export CONKY_CONFIG CONKY_GNOME_CONFIG CONKY_KDE_CONFIG CONKY_RE
	export DBUS_GNOME_RE DBUS_KDE_RE DBUS_WAIT_RE DBUS_TIMEOUT
	export DEBUG QUIET SET_WALLPAPER_FILE TALLPAPER WALLPAPER
	export DISPLAY
	export FUNCTIONS
	export SUCCESS FAILURE

	#
	# conky
	#
	if pids=$( pgrep "$CONKY_RE" ); then
		emit "conky already running (pid ${pids%%[$IFS]*})"
	else
		start_conky
	fi

	#
	# desktop worker
	#
	if pids=$( pgrep -f "$CONDY_DESKTOP_WORKER_RE" ); then
		emit "desktop worker already running (pid ${pids%%[$IFS]*})"
	else
		start_desktop_worker
	fi

	return $SUCCESS
}

start_conky()
{
	local log="$CONDY_LOG"
	[ $DEBUG -gt 0 ] || log=/dev/null
	/bin/sh -c ': condy ; eval "$CONDY_STARTUP"' >> "$log" 2>&1 &
	emit "conky starting (pid $!)"
}

start_desktop_worker()
{
	local log="$CONDY_LOG"
	[ $DEBUG -gt 0 ] || log=/dev/null
	/bin/sh -c ': condy ; eval "$CONDY_DESKTOP_WORKER"' >> "$log" 2>&1 &
	emit "started desktop worker (pid $!)"
}

stop()
{
	local ret=$SUCCESS
	stop_conky || ret=$FAILURE
	stop_desktop_worker || ret=$FAILURE
	return $ret
}

stop_conky()
{
	local pid pids list=

	if pids=$( pgrep "$CONKY_RE" ); then
		print "Stopping conky"
		for pid in $pids; do list="$list $pid"; done
		pkill "$CONKY_RE" > /dev/null 2>&1
		print ".\nWaiting for pids:%s" "$list"
		countup=0
		while [ $countup -le $CONDY_DESKTOP_TIMEOUT ]; do
			pgrep -q "$CONKY_RE" > /dev/null 2>&1 || break
			sleep 1
			countup=$(( $countup + 1 ))
		done
		emit .
	elif pids=$( pgrep -f "$CONDY_STARTUP_RE" ); then
		print "Stopping conky"
		for pid in $pids; do list="$list $pid"; done
		pkill -f "$CONDY_STARTUP_RE" > /dev/null 2>&1
		print ".\nWaiting for pids:%s" "$list"
		countup=0
		while [ $countup -le $CONDY_DESKTOP_TIMEOUT ]; do
			pgrep -qf "$CONDY_STARTUP_RE" > /dev/null 2>&1 || break
			sleep 1
			countup=$(( $countup + 1 ))
		done
		emit .
	else
		emit "conky not running."
		return $FAILURE
	fi

	return $SUCCESS
}

stop_desktop_worker()
{
	local pid pids list=

	if pids=$( pgrep -f "$CONDY_DESKTOP_WORKER_RE" ); then
		print "Stopping desktop worker"
		for pid in $pids; do list="$list $pid"; done
		pkill -f "$CONDY_DESKTOP_WORKER_RE" > /dev/null 2>&1
		print ".\nWaiting for pids:%s" "$list"
		countup=0
		while [ $countup -le $CONDY_DESKTOP_TIMEOUT ]; do
			pgrep -qf "$CONDY_DESKTOP_WORKER_RE" \
				> /dev/null 2>&1 || break
			sleep 1
			countup=$(( $countup + 1 ))
		done
		emit .
	else
		emit "desktop worker not running."
		return $FAILURE
	fi
}

status()
{
	local pids ret=$SUCCESS
	local paused=

	if pids=$( pgrep "$CONKY_RE" ); then
		echo "conky running (pid ${pids%%[$IFS]*})"
	elif pids=$( pgrep -f "$CONDY_STARTUP_RE" ); then
		echo "conky starting (pid ${pids%%[$IFS]*})"
	else
		echo "conky not running"
		ret=$FAILURE
	fi

	if pids=$( pgrep -f "$CONDY_DESKTOP_WORKER_RE" ); then
		[ ! -e "$PAUSE_FILE" ] || paused=" [PAUSED]"
		echo "desktop worker running (pid ${pids%%[$IFS]*})$paused"
	else
		echo "desktop worker not running"
		ret=$FAILURE
	fi

	return $ret
}

reload()
{
	pkill -USR1 -f "$CONDY_DESKTOP_WORKER_RE"
}

refresh()
{
	pkill -USR2 -f "$CONDY_DESKTOP_WORKER_RE"
}

pause()
{
	if [ -e "$PAUSE_FILE" ]; then
		echo "Already paused."
	else
		:> "$PAUSE_FILE"
		pkill -HUP -f "$CONDY_DESKTOP_WORKER_RE" && echo "Paused."
	fi
}

resume()
{
	if [ -e "$PAUSE_FILE" ]; then
		rm -f "$PAUSE_FILE"
		pkill -HUP -f "$CONDY_DESKTOP_WORKER_RE" && echo "Resumed."
	else
		echo "Not paused."
	fi
}

unpause()
{
	resume
}

set_wallpaper()
{
	local file="$1"

	if [ ! "$file" ]; then
		echo "$pgm: Missing file argument" >&2
		return $FAILURE
	elif [ ! -e "$file" ]; then
		echo "$pgm: $file: No such file or directory" >&2
		return $FAILURE
	elif [ -d "$file" ]; then
		echo "$pgm: $file: Is a directory" >&2
		return $FAILURE
	elif [ ! -r "$file" ]; then
		echo "$pgm: $file: Permission denied" >&2
		return $FAILURE
	fi

	if echo "$file" > "$SET_WALLPAPER_FILE"; then
		pkill -HUP -f "$CONDY_DESKTOP_WORKER_RE" &&
			echo "Wallpaper set to $file"
	fi
}

cycle()
{
	local interval=5
	local dir

	# Load configuration files
	load_configs

	# Determine if we should use portrait or landscape wallpaper
	dir="$WALLPAPER"
	! getres || [ ! "$USE_TALLPAPER" ] || dir="$TALLPAPER"


	echo "Cycling $dir (at ${interval}s intervals)..."
	for file in "$dir"/*; do
		[ -e "$file" ] || continue
		set_wallpaper "$file"
		sleep $interval
	done
}

############################################################ WORKERS

#
# CONDY_STARTUP
#
exec 9<<'EOF'
################################################## STARTUP GLOBALS

_FVWM=
_GNOME=
_KDE=

################################################## STARTUP FUNCTIONS

eval "$FUNCTIONS"

################################################## STARTUP MAIN

log "Starting conky (pid %u)" $$

#
# Init
#
countup=0
names=
log -d 3 "Detecting window manager"
if pgrep -aq fvwm || pgrep -aq bvwm; then
	log -d 3 "fvwm/bvwm detected"
	config="$CONKY_CONFIG"
	_FVWM=1
else
	while : forever ; do
		names=$( dbus_listnames )
		echo "$names" | grep -q "$DBUS_WAIT_RE" && break
		[ $countup -gt $DBUS_TIMEOUT ] && break
		sleep 5
		countup=$(( $countup + 5 ))
	done
	if echo "$names" | grep -q "$DBUS_GNOME_RE"; then
		log -d 3 "Gnome detected"
		config="$CONKY_GNOME_CONFIG"
		_GNOME=1
	elif echo "$names" | grep -q "$DBUS_KDE_RE"; then
		log -d 3 "KDE detected"
		config="$CONKY_KDE_CONFIG"
		_KDE=1
	else
		log -d 3 "Unable to detect window manager"
		config="$CONKY_CONFIG"
	fi
fi

#
# Start conky
#
log -d 2 'conky -c "%s"' "$config"
conky -c "$config" > /dev/null 2>&1 &

#
# Log
#
if [ ! "$QUIET" ]; then
	pids=$( pgrep "$CONKY_RE" )
	log "Started conky (pid ${pids%%[$IFS]*})"
fi
EOF
CONDY_STARTUP=$( cat <&9 )

#
# CONDY_DESKTOP_WORKER
# NB: Rotates Wallpaper every $CONDY_DESKTOP_INTERVAL seconds
#
exec 9<<'EOF'
################################################## DESKTOP GLOBALS

_FVWM=
_GNOME=
_KDE=
_WM_DETECT=3

#
# Screen resolution
#
HEIGHT=
WIDTH=
_HEIGHT=
_WIDTH=

#
# Landscape vs Portrait
#
USE_TALLPAPER=
_USE_TALLPAPER=

#
# Miscellaneous
#
PAUSED=

################################################## DESKTOP FUNCTIONS

eval "$FUNCTIONS"

check_conky()
{
	log -d 3 "Check if conky is running"
	if pgrep -q "$CONKY_RE"; then
		log -d 3 "conky is running"
		return 0
	fi
	if pgrep -qf "$CONDY_STARTUP_RE"; then
		log -d 3 "conky is starting"
		return 1
	fi
	log -d 3 "conky not running"
	return 2
}

refresh_desktop()
{
	[ "$wallpaper" ] || return $SUCCESS
	log "Setting %s" "$wallpaper"
	hsetroot -fill "$wallpaper" ||
		log "Unable to set %s" "$wallpaper"
}

logres()
{
	log -d 2 "Current resolution (W x H) is $WIDTH x $HEIGHT"
	if [ ${HEIGHT:-0} -gt ${WIDTH:-0} ]; then
		log -d 2 "Portrait view detected"
	else
		log -d 2 "Landscape view detected"
	fi
}

reload_desktop()
{
	local dir

	log -d 5 "Loading new desktop wallpaper"

	# Load configuration files
	load_configs

	# Determine if we should use portrait or landscape wallpaper
	dir="$WALLPAPER"
	! getres || [ ! "$USE_TALLPAPER" ] || dir="$TALLPAPER"

	# Get a list of installed wallpapers
	wallpapers=$( find "$dir/" -mindepth 1 -maxdepth 1 -type f ) ||
		die "Unable to list %s" "$dir"

	# Pick one at random
	nwallpapers=$( echo "$wallpapers" | sort | awk 'END{print NR}' )
	n=$( awk -v max=$nwallpapers 'BEGIN {
		srand()
		srand(srand())
		r = sprintf("%0.f", rand() * max)
		print (r > 0 ? r : 1)
	}' )
	wallpaper=$( echo "$wallpapers" | awk -v n=$n 'NR==n' )

	# Render the wallpaper
	refresh_desktop
}

################################################## DESKTOP MAIN

log "Started desktop worker (pid %u)" $$
sleep 0.1 # yield

#
# Setup
#
if [ -e "$PAUSE_FILE" ]; then
	log "Removing %s" "$PAUSE_FILE"
	rm -f "$PAUSE_FILE"
fi

#
# Init
#
countdown=0
if pgrep -aq fvwm || pgrep -aq bvwm; then
	_FVWM=1
	_WM_DETECT=0
else
	log -d 2 "Waiting for dbus"
	countup=0
	while ! dbus_listnames | grep -q "$DBUS_WAIT_RE"; do
		[ $countup -gt $DBUS_TIMEOUT ] && break
		sleep 5
		countup=$(( $countup + 5 ))
	done
	log "dbus initialized"
fi

#
# Signal handling
#
trap - SIGCHLD # Default handler
for sig in SIGINT; do
	trap "log -d 2 'Caught %s (ignored)' $sig; continue" $sig
done
for sig in SIGQUIT SIGTERM; do
	trap "log 'Caught %s (exiting)' $sig; exit 2" $sig
done
trap '
	if [ -f "$SET_WALLPAPER_FILE" ]; then
		log "Caught SIGHUP -- setting wallpaper"
		_wallpaper=$( cat "$SET_WALLPAPER_FILE" ) &&
			wallpaper="$_wallpaper"
		log "Removing %s" "$SET_WALLPAPER_FILE"
		rm -f "$SET_WALLPAPER_FILE"
		kill $sleep_pid
		refresh_desktop
		continue
	elif [ "$PAUSED" ]; then
		log "Caught SIGHUP -- unpausing desktop"
		PAUSED=
		kill $sleep_pid
		continue
	else
		log "Caught SIGHUP -- pausing desktop"
		PAUSED=1
	fi
' SIGHUP
trap '
	log "Caught SIGUSR1 -- reload desktop"
	kill $sleep_pid
	reload_desktop
	continue
' SIGUSR1
trap '
	log "Caught SIGUSR2 -- refresh desktop"
	kill $sleep_pid
	refresh_desktop
	continue
' SIGUSR2
trap 'log "Worker exited (unexpectedly)"' EXIT

#
# Wait for conky to start
#
while : forever; do
	check_conky
	case $? in
	0) break ;; # started
	1) sleep $CONDY_DESKTOP_INTERVAL ;; # starting
	*) die # failed to start
	esac
done

#
# Main loop
#
log -d 3 "Looping forever"
if getres; then
	logres

	# Cache width/height to detect changes
	_WIDTH="$WIDTH"
	_HEIGHT="$HEIGHT"
	_USE_TALLPAPER="$USE_TALLPAPER"
fi
while : forever; do
	# Detect window manager
	if [ $_WM_DETECT -gt 0 ]; then
		_WM_DETECT=$(( $_WM_DETECT - 1 ))
		names=$( dbus_listnames )
		if echo "$names" | grep -q "$DBUS_WAIT_RE"; then
			if echo "$names" | grep -q "$DBUS_GNOME_RE"; then
				_GNOME=1
				_WM_DETECT=0
			elif echo "$names" | grep -q "$DBUS_KDE_RE"; then
				_KDE=1
				_WM_DETECT=0
			fi
		fi
	fi

	# Wallpaper interval and resolution handling
	if [ $countdown -le 0 ]; then
		[ "$PAUSED" ] || reload_desktop
		countdown=$CONDY_DESKTOP_INTERVAL
	else
		countdown=$(( $countdown - $CONDY_DESKTOP_CHECK ))
		log -d 3 "Sleeping %s seconds" "$CONDY_DESKTOP_CHECK"
		sleep $CONDY_DESKTOP_CHECK &
		sleep_pid=$!
		wait $sleep_pid || : errors ignored
		log -d 4 "Awake"
		if getres; then
			changes=1
			[ "$HEIGHT" = "$_HEIGHT" ] &&
				[ "$WIDTH" = "$_WIDTH" ] &&
				[ "$USE_TALLPAPER" = "$_USE_TALLPAPER" ] &&
				changes=
			if [ "$changes" ]; then
				log "Detected resolution change"
				logres
				if [ "$_KDE" ]; then
					# Send signal if larger resolution
					if [ ${WIDTH:-0} -gt ${_WIDTH:-0} ] ||
					   [ ${HEIGHT:-0} -gt ${_HEIGHT:-0} ]
					then
						pkill -USR1 "$CONKY_RE"
					fi
				fi
				if [ "$USE_TALLPAPER" = "$_USE_TALLPAPER" ]
				then
					refresh_desktop
				else
					reload_desktop
				fi
				_HEIGHT="$HEIGHT"
				_WIDTH="$WIDTH"
				_USE_TALLPAPER="$USE_TALLPAPER"
			fi
		fi
	fi
	check_conky || die
done
EOF
CONDY_DESKTOP_WORKER=$( cat <&9 )

############################################################ MAIN

cd # home directory

#
# Process command-line options
#
while getopts dhl:qs:u:v flag; do
	case "$flag" in
	d) DEBUG=$(( $DEBUG + 1 )) ;;
	l) CONDY_LOG="$OPTARG"
		[ $DEBUG -gt 0 ] || DEBUG=1 ;;
	q) QUIET=1 ;;
	s) CONDY_CONFIG="$OPTARG" ;;
	u) CONDY_USER_CONFIG="$OPTARG" ;;
	v) VERSION="${VERSION#*: }"
		echo "${VERSION% $}"
		exit $SUCCESS
		;;
	*) usage # NOTREACHED
	esac
done
shift $(( OPTIND - 1 ))

#
# Process command-line argument
#
case "$1" in
"") usage "Argument required" ;; # NOTREACHED
cycle|pause|refresh|reload|resume|start|status|stop|unpause) $1 ;;
set) set_wallpaper "$2" ;;
load|restart)
	stop
	start
	;;
*) usage "%s: Unknown argument" "$1" # NOTREACHED
esac

################################################################################
# END
################################################################################
