betterlockscreen-openrc/betterlockscreen

973 lines
28 KiB
Bash
Executable file

#!/usr/bin/env bash
# Author : Copyright (c) 2017-2022 Pavan Jadhaw, and others (https://github.com/betterlockscreen/betterlockscreen/graphs/contributors)
# Project Repository : https://github.com/betterlockscreen/betterlockscreen
cmd_exists () {
command -v "$1" >/dev/null
}
init_config () {
# default options
display_on=0
span_image=false
lock_timeout=300
fx_list=(dim blur dimblur pixel dimpixel color)
dim_level=40
blur_level=1
pixel_scale=10,1000
solid_color=333333
description=""
quiet=false
i3lockcolor_bin="i3lock-color"
if ! cmd_exists "$i3lockcolor_bin" && cmd_exists "i3lock"; then
i3lockcolor_bin="i3lock"
fi
# default theme
loginbox=00000066
loginshadow=00000000
locktext="Type password to unlock..."
font="sans-serif"
ringcolor=ffffffff
insidecolor=00000000
separatorcolor=00000000
ringvercolor=ffffffff
insidevercolor=00000000
ringwrongcolor=ffffffff
insidewrongcolor=d23c3dff
timecolor=ffffffff
time_format="%H:%M:%S"
greetercolor=ffffffff
layoutcolor=ffffffff
keyhlcolor=d23c3dff
bshlcolor=d23c3dff
verifcolor=ffffffff
wrongcolor=d23c3dff
modifcolor=d23c3dff
bgcolor=000000ff
wallpaper_cmd="feh --bg-fill"
time_format="%H:%M:%S"
# read user config
USER_CONF="${XDG_CONFIG_HOME:-$HOME/.config}/betterlockscreenrc"
if [ -e "$USER_CONF" ]; then
# shellcheck source=/dev/null
source "$USER_CONF"
fi
if ! cmd_exists "$i3lockcolor_bin"; then
echof error "Unable to find i3lock-color binary under detected/configured name: '$i3lockcolor_bin'!"
exit
fi
# Please make sure to adjust this before release!
VERSION="4.0.3"
# paths
CACHE_DIR="${XDG_CACHE_HOME:-$HOME/.cache}/betterlockscreen"
CUR_DIR="$CACHE_DIR/current"
# wallpaper
CUR_W_RESIZE="$CUR_DIR/wall_resize.png"
CUR_W_DIM="$CUR_DIR/wall_dim.png"
CUR_W_BLUR="$CUR_DIR/wall_blur.png"
CUR_W_DIMBLUR="$CUR_DIR/wall_dimblur.png"
CUR_W_PIXEL="$CUR_DIR/wall_pixel.png"
CUR_W_DIMPIXEL="$CUR_DIR/wall_dimpixel.png"
CUR_W_COLOR="$CUR_DIR/wall_color.png"
# lockscreen
CUR_L_RESIZE="$CUR_DIR/lock_resize.png"
CUR_L_DIM="$CUR_DIR/lock_dim.png"
CUR_L_BLUR="$CUR_DIR/lock_blur.png"
CUR_L_DIMBLUR="$CUR_DIR/lock_dimblur.png"
CUR_L_PIXEL="$CUR_DIR/lock_pixel.png"
CUR_L_DIMPIXEL="$CUR_DIR/lock_dimpixel.png"
CUR_L_COLOR="$CUR_DIR/lock_color.png"
# Original DPMS timeout
DEFAULT_TIMEOUT=$(cut -d ' ' -f4 <<< "$(xset q | sed -n '25p')")
# Original DPMS status
DEFAULT_DPMS=$(xset q | awk '/^[[:blank:]]*DPMS is/ {print $(NF)}')
# Dunst
DUNST_INSTALLED=false && [[ -e "$(command -v dunstctl)" ]] && DUNST_INSTALLED=true
DUNST_IS_PAUSED=false && [[ "$DUNST_INSTALLED" == "true" ]] && DUNST_IS_PAUSED=$(dunstctl is-paused)
# Feh
FEH_INSTALLED=false && [[ -e "$(command -v feh)" ]] && FEH_INSTALLED=true
}
# called before screen is locked
prelock() {
# set dpms timeout
if [ "$DEFAULT_DPMS" == "Enabled" ]; then
xset dpms "$lock_timeout"
fi
# If dusnt is already paused don't pause it again
if [[ "$DUNST_INSTALLED" == "true" && "$DUNST_IS_PAUSED" == "false" ]]; then
dunstctl set-paused true
fi
if [[ "$runsuspend" = "true" ]]; then
lockargs="$lockargs -n"
fi
}
# lock screen with specified image
lock() {
echof act "Locking screen..."
local image="$1"
local fontlg=32
local fontmd=16
local fontsm=12
$i3lockcolor_bin \
--image "$image" \
--color "$bgcolor" \
--screen "$display_on" \
--ind-pos="x+310:y+h-80" \
--radius=25 \
--ring-width=5 \
--inside-color="$insidecolor" \
--ring-color="$ringcolor" \
--separator-color=$separatorcolor \
--insidever-color="$insidevercolor" \
--insidewrong-color="$insidewrongcolor" \
--ringver-color="$ringvercolor" \
--ringwrong-color="$ringwrongcolor" \
--line-uses-inside \
--keyhl-color="$keyhlcolor" \
--bshl-color="$bshlcolor" \
--clock --force-clock \
--time-pos="ix-265:iy-10" \
--time-align 1 \
--time-str "$time_format" \
--time-color="$timecolor" \
--time-font="$font" \
--time-size="$fontlg" \
--date-str "" \
--greeter-pos="ix-265:iy+12" \
--greeter-align 1 \
--greeter-text "$locktext" \
--greeter-color="$greetercolor" \
--greeter-font="$font" \
--greeter-size="$fontmd" \
--layout-pos="ix-265:iy+32" \
--layout-align 1 \
--layout-color="$layoutcolor" \
--layout-font="$font" \
--layout-size="$fontsm" \
--keylayout "${keylayout:-0}" \
--verif-pos="ix+35:iy-34" \
--verif-align 2 \
--verif-text="Verifying..." \
--verif-color="$verifcolor" \
--verif-font="$font" \
--verif-size="$fontsm" \
--wrong-pos="ix+24:iy-34" \
--wrong-align 2 \
--wrong-text="Failure!" \
--wrong-color="$wrongcolor" \
--wrong-font="$font" \
--wrong-size="$fontsm" \
--modif-pos="ix+45:iy+43" \
--modif-align 2 \
--modif-size="$fontsm" \
--modif-color="$modifcolor" \
--noinput-text="" \
--pass-media-keys \
--pass-screen-keys \
--pass-volume-keys \
--pass-power-keys \
"${lockargs[@]}"
}
# in case image isn't found
failsafe() {
echof act "Locking screen... (FAILSAFE MODE)"
local fontlg=32
local fontmd=16
local fontsm=12
$i3lockcolor_bin \
--color "$bgcolor" \
--ind-pos="x+310:y+h-80" \
--radius=25 \
--ring-width=5 \
--inside-color="$insidecolor" \
--ring-color="$ringcolor" \
--separator-color=$separatorcolor \
--insidever-color="$insidevercolor" \
--insidewrong-color="$insidewrongcolor" \
--ringver-color="$ringvercolor" \
--ringwrong-color="$ringwrongcolor" \
--line-uses-inside \
--keyhl-color="$keyhlcolor" \
--bshl-color="$bshlcolor" \
--clock --force-clock \
--time-pos="ix-265:iy-10" \
--time-align 1 \
--time-str "$time_format" \
--time-color="$timecolor" \
--time-font="$font" \
--time-size="$fontlg" \
--date-str "" \
--greeter-pos="ix-265:iy+12" \
--greeter-align 1 \
--greeter-text "$locktext" \
--greeter-color="$greetercolor" \
--greeter-font="$font" \
--greeter-size="$fontmd" \
--layout-pos="ix-265:iy+32" \
--layout-align 1 \
--layout-color="$layoutcolor" \
--layout-font="$font" \
--layout-size="$fontsm" \
--keylayout "${keylayout:-0}" \
--verif-pos="ix+45:iy-35" \
--verif-align 2 \
--verif-text="Verifying..." \
--verif-color="$verifcolor" \
--verif-font="$font" \
--verif-size="$fontsm" \
--wrong-pos="ix+45:iy-35" \
--wrong-align 2 \
--wrong-text="Failure!" \
--wrong-color="$wrongcolor" \
--wrong-font="$font" \
--wrong-size="$fontsm" \
--modif-pos="ix+45:iy+43" \
--modif-align 2 \
--modif-size="$fontsm" \
--modif-color="$modifcolor" \
--noinput-text="" \
--pass-media-keys \
--pass-screen-keys \
--pass-volume-keys \
--pass-power-keys
}
# called after screen is unlocked
postlock() {
# restore default dpms timeout
if [ "$DEFAULT_DPMS" == "Enabled" ]; then
xset dpms "$DEFAULT_TIMEOUT"
fi
# If dunst already paused before locking don't unpause dunst
if [[ "$DUNST_INSTALLED" == "true" && "$DUNST_IS_PAUSED" == "false" ]]; then
dunstctl set-paused false
fi
}
# select effect and lock screen
lockselect() {
echof act "Running prelock..."
prelock &
case "$1" in
dim) if [ -f "$CUR_L_DIM" ]; then lock "$CUR_L_DIM"; else failsafe; fi ;;
blur) if [ -f "$CUR_L_BLUR" ]; then lock "$CUR_L_BLUR"; else failsafe; fi ;;
dimblur) if [ -f "$CUR_L_DIMBLUR" ]; then lock "$CUR_L_DIMBLUR"; else failsafe; fi ;;
pixel) if [ -f "$CUR_L_PIXEL" ]; then lock "$CUR_L_PIXEL"; else failsafe; fi ;;
dimpixel) if [ -f "$CUR_L_DIMPIXEL" ]; then lock "$CUR_L_DIMPIXEL"; else failsafe; fi ;;
color) if [ -f "$CUR_L_COLOR" ]; then lock "$CUR_L_COLOR"; else failsafe; fi ;;
*) if [ -f "$CUR_L_RESIZE" ]; then lock "$CUR_L_RESIZE"; else failsafe; fi ;;
esac
echof act "Running postlock..."
postlock &
}
# calculate adjustments for hidpi displays
logical_px() {
# $1: number of pixels to convert
# $2: 1 for width. 2 for height
local pixels="$1"
local direction="$2"
local dpi
# use DPI set by user in .Xresources
dpi=$(xrdb -q | grep -oP '^\s*Xft.dpi:\s*\K\d+' | bc)
# or get dpi value from xdpyinfo
if [ -z "$dpi" ]; then
dpi=$(xdpyinfo | sed -En "s/\s*resolution:\s*([0-9]*)x([0-9]*)\s.*/\\$direction/p" | head -n1)
fi
# adjust scaling
if [ -n "$dpi" ]; then
local scale
scale=$(echo "scale=3; $dpi / 96.0" | bc)
echo "$scale * $pixels / 1" | bc
else
# return the default value if no DPI is set
echo "$pixels"
fi
}
# get total resolution, sets $TOTAL_SIZE
get_total_size () {
TOTAL_SIZE=$(xdpyinfo | grep -w "dimensions" | sed -r 's/^[^0-9]*([0-9]+x[0-9]+).*$/\1/')
}
# get list of displays, sets $DISPLAY_LIST
get_display_list () {
local count=0
mapfile -t displays < <(xrandr --listactivemonitors)
for display in "${displays[@]:1}"; do
((count++))
display="$(echo "$display" | sed -r 's/\/[0-9]*//g')"
IFS=' ' read -r -a info <<< "$display"
DISPLAY_LIST+=("$count ${info[3]} ${info[2]}")
done
}
# populate $WALL_LIST depending on number of displays and images passed
get_wall_list() {
local paths=("$@")
declare -ga WALL_LIST
# multiple images and spanning conflict, bail out
if [ "${#paths[@]}" -gt 1 ] && [ "$span_image" = true ]; then
echof err "Can't use --span with multiple images!"
exit 1
fi
# if spanning return 1 image
if [ "$span_image" = true ]; then
get_image "${paths[0]}"
# if # paths is 1
elif [ "${#paths[@]}" -eq 1 ]; then
for ((i=0; i<${#DISPLAY_LIST[@]}; i++)); do
# add same image to $WALL_LIST for each display
get_image "${paths[0]}"
done
# if # of paths equals # of displays
elif [ ${#paths[@]} -eq "${#DISPLAY_LIST[@]}" ]; then
for ((i=0; i<${#DISPLAY_LIST[@]}; i++)); do
# add each image to $WALL_LIST
get_image "${paths[$i]}"
done
# if # of paths differ from # of display, bail out
else
echof err "${#paths[@]} images provided for ${#DISPLAY_LIST[@]} displays!"
exit 1
fi
}
# get image path, append to $WALL_LIST
get_image() {
local path="$1"
# we have a file
if [ -f "$path" ]; then
WALL_LIST+=("$path")
return
# we have a directory
elif [ -d "$path" ]; then
dir=("$path"/*)
rdir="${dir[RANDOM % ${#dir[@]}]}"
get_image "$rdir" # <-- calls itself
# not file or directory, bail out
else
echof err "invalid path: $path"
exit 1
fi
}
# scale base image and generate effects
resize_and_render () {
local base="$1"
local path="$2"
local resolution="$3"
# resource paths
RES_RESIZE="$path/resize.png"
RES_DIM="$path/dim.png"
RES_BLUR="$path/blur.png"
RES_DIMBLUR="$path/dimblur.png"
RES_PIXEL="$path/pixel.png"
RES_DIMPIXEL="$path/dimpixel.png"
RES_COLOR="$path/color.png"
# resize
base_resize "$base" "$RES_RESIZE" "$resolution"
# effects
for effect in "${fx_list[@]}"; do
case $effect in
dim) fx_dim "$RES_RESIZE" "$RES_DIM";;
blur) fx_blur "$RES_RESIZE" "$RES_BLUR" "$resolution";;
dimblur) fx_dimblur "$RES_RESIZE" "$RES_DIMBLUR" "$resolution";;
pixel) fx_pixel "$RES_RESIZE" "$RES_PIXEL";;
dimpixel) fx_dimpixel "$RES_RESIZE" "$RES_DIMPIXEL";;
color) fx_color "$RES_COLOR" "$resolution";;
esac
done
}
# apply resize
base_resize() {
local input="$1"
local output="$2"
local size="$3"
echof act "Resizing base image..."
eval convert "$input" \
-resize "$size""^" \
-gravity center \
-extent "$size" \
"$output"
}
# apply dim
fx_dim() {
local input="$1"
local output="$2"
echof act "Rendering 'dim' effect..."
eval convert "$input" \
-fill black -colorize "$dim_level"% \
"$output"
}
# apply blur
fx_blur() {
local input="$1"
local output="$2"
local size="$3"
echof act "Rendering 'blur' effect..."
blur_shrink=$(echo "scale=2; 20 / $blur_level" | bc)
blur_sigma=$(echo "scale=2; 0.6 * $blur_level" | bc)
eval convert "$input" \
-filter Gaussian \
-resize "$blur_shrink%" \
-define "filter:sigma=$blur_sigma" \
-resize "$size^" -gravity center -extent "$size" \
"$output"
}
# apply dimblur
fx_dimblur() {
local input="$1"
local output="$2"
local size="$3"
echof act "Rendering 'dimblur' effect..."
blur_shrink=$(echo "scale=2; 20 / $blur_level" | bc)
blur_sigma=$(echo "scale=2; 0.6 * $blur_level" | bc)
eval convert "$input" \
-fill black -colorize "$dim_level"% \
-filter Gaussian \
-resize "$blur_shrink%" \
-define "filter:sigma=$blur_sigma" \
-resize "$size^" -gravity center -extent "$size" \
"$output"
}
# pixelate
fx_pixel() {
local input="$1"
local output="$2"
echof act "Rendering 'pixel' effect..."
IFS=',' read -ra range <<< "$pixel_scale"
eval convert "$input" \
-scale "${range[0]}"% -scale "${range[1]}"% \
"$output"
}
# apply dimpixel
fx_dimpixel() {
local input="$1"
local output="$2"
echof act "Rendering 'dimpixel' effect..."
IFS=',' read -ra range <<< "$pixel_scale"
eval convert "$input" \
-fill black -colorize "$dim_level"% \
-scale "${range[0]}"% -scale "${range[1]}"% \
"$output"
}
# create solid color
fx_color() {
local output="$1"
local size="$2"
echof act "Rendering 'color' effect..."
eval convert -size "$size" canvas:\#"$solid_color" "$RES_COLOR"
}
# create loginbox rectangle, set "$RECTANGLE"
create_loginbox () {
RECTANGLE="$CUR_DIR/rectangle.png"
local shadow="$CUR_DIR/shadow.png"
local width height
width=$(logical_px 340 1)
height=$(logical_px 100 2)
convert -size "$width"x"$height" xc:\#"$loginbox" -fill none "$RECTANGLE"
convert "$RECTANGLE" \
\( -clone 0 -background \#"$loginshadow" -shadow 100x5+0+0 \) +swap \
-background none -layers merge +repage "$shadow"
composite -compose Dst_Out -gravity center \
"$RECTANGLE" "$shadow" -alpha Set "$shadow"
convert "$shadow" "$RECTANGLE" -geometry +10+10 -composite "$RECTANGLE"
[[ "$shadow" ]] && rm "$shadow"
}
# create rectangle with description, set "$DESCRECT"
create_description () {
DESCRECT="$CUR_DIR/description.png"
local shadow="$CUR_DIR/shadow.png"
convert -background none -family "$(fc-match "$font" family)" -style Normal -pointsize 14 -fill \#"$greetercolor" label:"\ $description\ " -bordercolor \#"$loginbox" -border 10 "$DESCRECT"
convert "$DESCRECT" \
\( -clone 0 -background \#"$loginshadow" -shadow 100x5+0+0 \) +swap \
-background none -layers merge +repage "$shadow"
composite -compose Dst_Out -gravity center \
"$DESCRECT" "$shadow" -alpha Set "$shadow"
convert "$shadow" "$DESCRECT" -geometry +10+10 -composite "$DESCRECT"
[[ "$shadow" ]] && rm "$shadow"
}
# delete and recreate directory
purge_cache () {
if [[ -d "$1" ]]; then
rm -r "$1"
fi
mkdir -p "$1"
}
# update lockscreen and wallpaper images
update () {
local images=("$@")
echof act "Updating image cache..."
mkdir -p "$CACHE_DIR" &>/dev/null
get_display_list # DISPLAY_LIST
get_total_size # TOTAL_SIZE
echof info "Detected ${#DISPLAY_LIST[@]} display(s) @ $TOTAL_SIZE total resolution"
get_wall_list "${images[@]}" # WALL_LIST
echof info "Original image(s): ${WALL_LIST[*]##*/}"
# Prepare description box to obtain width for positioning
local descwidth
local descheight
if [ -z "$description" ]; then
descwidth=0
descheight=0
else
create_description
descwidth=$(identify -format "%[fx:w]" "$DESCRECT")
descheight=$(identify -format "%[fx:h]" "$DESCRECT")
fi
for ((i=0; i<${#DISPLAY_LIST[@]}; i++)); do
display="${DISPLAY_LIST[$i]}"
USER_WALL="${WALL_LIST[$i]}"
# escape spaces for IM
if echo "$USER_WALL" | grep -E -q "[[:space:]]"; then
USER_WALL="${USER_WALL// /\\ }"
fi
IFS=' ' read -r -a dinfo <<< "$display"
local id="${dinfo[0]}"
local device="${dinfo[1]}"
local geometry="${dinfo[2]}"
read -r -a cols <<< "${geometry//[x+-]/ }"
local position="${geometry#*"${cols[1]}"}"
local resolution="${geometry%"${position}"*}"
if [[ $id -eq "$display_on" ]] || [[ "$display_on" -eq 0 ]]; then
IFS='x' read -r -a dimension <<< "$resolution"
res_x="${dimension[0]}"
res_y="${dimension[1]}"
read -r -a val <<< "${position//[+-]/ }"
read -r -a sym <<< "${position//[0-9]/ }"
pos_x="${sym[0]}${val[0]}"
pos_y="${sym[1]}${val[1]}"
rect_x=$((pos_x + $(logical_px 15 1)))
rect_y=$((pos_y + res_y - $(logical_px 140 2)))
positions+=("+$((rect_x))+$((rect_y))")
descrect_x=$((pos_x + res_x - descwidth - $(logical_px 15 1)))
descrect_y=$((pos_y + res_y - descheight - $(logical_px 20 2)))
positions_desc+=("+$((descrect_x))+$((descrect_y))")
fi
local path="$CACHE_DIR/$id-$device"
purge_cache "$path"
if [ "$span_image" = true ]; then
if [ "$id" -gt 1 ]; then
continue
else
device="[span]"
id="*"
resolution="$TOTAL_SIZE"
fi
fi
echof info "Processing display: $device ($id)"
echof info "Resolution: $resolution"
if [ "$span_image" = true ]; then
resize_and_render "$USER_WALL" "$path" "$resolution"
else
resize_and_render "$USER_WALL" "$path" "$resolution"
PARAM_RESIZE="$PARAM_RESIZE $RES_RESIZE -geometry $position -composite "
PARAM_DIM="$PARAM_DIM $RES_DIM -geometry $position -composite "
PARAM_BLUR="$PARAM_BLUR $RES_BLUR -geometry $position -composite "
PARAM_DIMBLUR="$PARAM_DIMBLUR $RES_DIMBLUR -geometry $position -composite "
PARAM_PIXEL="$PARAM_PIXEL $RES_PIXEL -geometry $position -composite "
PARAM_DIMPIXEL="$PARAM_DIMPIXEL $RES_DIMPIXEL -geometry $position -composite "
PARAM_COLOR="$PARAM_COLOR $RES_COLOR -geometry $position -composite "
fi
done
purge_cache "$CUR_DIR"
if [ "$span_image" = true ] || [ ${#DISPLAY_LIST[@]} -lt 2 ]; then
echof act "Rendering final wallpaper images..."
[[ -f "$RES_RESIZE" ]] && eval "cp $RES_RESIZE $CUR_W_RESIZE"
[[ -f "$RES_DIM" ]] && eval "cp $RES_DIM $CUR_W_DIM"
[[ -f "$RES_BLUR" ]] && eval "cp $RES_BLUR $CUR_W_BLUR"
[[ -f "$RES_DIMBLUR" ]] && eval "cp $RES_DIMBLUR $CUR_W_DIMBLUR"
[[ -f "$RES_PIXEL" ]] && eval "cp $RES_PIXEL $CUR_W_PIXEL"
[[ -f "$RES_DIMPIXEL" ]] && eval "cp $RES_DIMPIXEL $CUR_W_DIMPIXEL"
[[ -f "$RES_COLOR" ]] && eval "cp $RES_COLOR $CUR_W_COLOR"
else
echof act "Creating canvas: $TOTAL_SIZE"
[[ -f "$RES_RESIZE" ]] && eval "convert -size $TOTAL_SIZE 'xc:blue' $CUR_W_RESIZE"
[[ -f "$RES_DIM" ]] && eval "convert -size $TOTAL_SIZE 'xc:blue' $CUR_W_DIM"
[[ -f "$RES_BLUR" ]] && eval "convert -size $TOTAL_SIZE 'xc:blue' $CUR_W_BLUR"
[[ -f "$RES_DIMBLUR" ]] && eval "convert -size $TOTAL_SIZE 'xc:blue' $CUR_W_DIMBLUR"
[[ -f "$RES_PIXEL" ]] && eval "convert -size $TOTAL_SIZE 'xc:blue' $CUR_W_PIXEL"
[[ -f "$RES_DIMPIXEL" ]] && eval "convert -size $TOTAL_SIZE 'xc:blue' $CUR_W_DIMPIXEL"
[[ -f "$RES_COLOR" ]] && eval "convert -size $TOTAL_SIZE 'xc:blue' $CUR_W_COLOR"
echof act "Rendering final wallpaper images..."
[[ -f "$CUR_W_RESIZE" ]] && eval "convert $CUR_W_RESIZE $PARAM_RESIZE $CUR_W_RESIZE"
[[ -f "$CUR_W_DIM" ]] && eval "convert $CUR_W_DIM $PARAM_DIM $CUR_W_DIM"
[[ -f "$CUR_W_BLUR" ]] && eval "convert $CUR_W_BLUR $PARAM_BLUR $CUR_W_BLUR"
[[ -f "$CUR_W_DIMBLUR" ]] && eval "convert $CUR_W_DIMBLUR $PARAM_DIMBLUR $CUR_W_DIMBLUR"
[[ -f "$CUR_W_PIXEL" ]] && eval "convert $CUR_W_PIXEL $PARAM_PIXEL $CUR_W_PIXEL"
[[ -f "$CUR_W_DIMPIXEL" ]] && eval "convert $CUR_W_DIMPIXEL $PARAM_DIMPIXEL $CUR_W_DIMPIXEL"
[[ -f "$CUR_W_COLOR" ]] && eval "convert $CUR_W_COLOR $PARAM_COLOR $CUR_W_COLOR"
fi
echof act "Rendering final lockscreen images..."
create_loginbox
for pos in "${positions[@]}"; do
PARAM_RECT="$PARAM_RECT $RECTANGLE -geometry $pos -composite "
done
if [ -n "$description" ]; then
create_description
for descpos in "${positions_desc[@]}"; do
PARAM_RECT="$PARAM_RECT $DESCRECT -geometry $descpos -composite "
done
fi
[[ -f "$CUR_W_RESIZE" ]] && eval "convert $CUR_W_RESIZE $PARAM_RECT $CUR_L_RESIZE"
[[ -f "$CUR_W_DIM" ]] && eval "convert $CUR_W_DIM $PARAM_RECT $CUR_L_DIM"
[[ -f "$CUR_W_BLUR" ]] && eval "convert $CUR_W_BLUR $PARAM_RECT $CUR_L_BLUR"
[[ -f "$CUR_W_DIMBLUR" ]] && eval "convert $CUR_W_DIMBLUR $PARAM_RECT $CUR_L_DIMBLUR"
[[ -f "$CUR_W_PIXEL" ]] && eval "convert $CUR_W_PIXEL $PARAM_RECT $CUR_L_PIXEL"
[[ -f "$CUR_W_DIMPIXEL" ]] && eval "convert $CUR_W_DIMPIXEL $PARAM_RECT $CUR_L_DIMPIXEL"
[[ -f "$CUR_W_COLOR" ]] && eval "convert $CUR_W_COLOR $PARAM_RECT $CUR_L_COLOR"
[[ "$RECTANGLE" ]] && rm "$RECTANGLE"
[[ "$DESCRECT" ]] && rm "$DESCRECT"
echof ok "Done"
}
# set wallpaper with effect
wallpaper() {
local effect="$1"
# make wallpaper span displays
get_display_list
if [ "$span_image" = true ] || [[ "${#DISPLAY_LIST[@]}" -gt 1 ]]; then
wallpaper_cmd="$wallpaper_cmd --no-xinerama"
fi
# set wallpaper
case "$effect" in
dim) wallpaper="$CUR_W_DIM";;
blur) wallpaper="$CUR_W_BLUR";;
dimblur) wallpaper="$CUR_W_DIMBLUR";;
pixel) wallpaper="$CUR_W_PIXEL";;
dimpixel) wallpaper="$CUR_W_DIMPIXEL";;
color) wallpaper="$CUR_W_COLOR";;
*) wallpaper="$CUR_W_RESIZE";;
esac
eval "$wallpaper_cmd $wallpaper"
}
# wrap echo with fancy prefix
echof() {
local prefix="$1"
local message="$2"
case "$prefix" in
header) msgpfx="[\e[1;95mB\e[m]";;
info) msgpfx="[\e[1;97m=\e[m]";;
act) msgpfx="[\e[1;92m*\e[m]";;
ok) msgpfx="[\e[1;93m+\e[m]";;
error) msgpfx="[\e[1;91m!\e[m]";;
*) msgpfx="";;
esac
[ "$quiet" != true ] && echo -e "$msgpfx $message"
}
# help message
usage() {
echo
echo "Usage: betterlockscreen [-u <PATH>] [-l <EFFECT>] [-w <EFFECT>]"
echo
echo " -q --quiet"
echo " Do not produce any text output on locking"
echo
echo " -u --update <PATH>"
echo " Update lock screen image"
echo
echo " -l --lock <EFFECT>"
echo " Lock screen with cached image"
echo
echo " -w --wall <EFFECT>"
echo " Set wallpaper with cached image"
echo
echo "Additional arguments:"
echo
echo " --display <N>"
echo " Set display to draw loginbox"
echo
echo " --span"
echo " Scale image to span multiple displays"
echo
echo " --off <N>"
echo " Turn display off after N minutes"
echo
echo " --fx <EFFECT,EFFECT,EFFECT>"
echo " List of effects to generate"
echo
echo " --desc <DESCRIPTION>"
echo " Set a description for the new lock screen image"
echo " (Only has an effect in combination with --update)"
echo
echo " --show-layout"
echo " Show current keyboard layout"
echo
echo " --wallpaper-cmd <command>"
echo " to set your custom wallpaper setter"
echo
echo " --time-format <format>"
echo " to set the time format used by i3lock-color"
echo
echo " -- <ARGS>"
echo " Pass additional arguments to i3lock"
echo
echo "Effects arguments:"
echo
echo " --dim <N>"
echo " Dim image N percent (0-100)"
echo
echo " --blur <N>"
echo " Blur image N amount (0.0-1.0)"
echo
echo " --pixel <N,N>"
echo " Pixelate image with N shrink and N grow (unsupported)"
echo
echo " --color <HEX>"
echo " Solid color background with HEX"
echo
exit 1
}
init_config
# show usage when no arguments passed
[[ "$1" = "" ]] && usage
# process arguments
lockargs=()
for arg in "$@"; do
[[ "${arg:0:1}" = '-' ]] || continue
case "$1" in
-q | --quiet)
quiet=true
shift
;;
-u | --update)
runupdate=true
imagepaths+=("$2")
shift 2
;;
-s | --suspend)
runsuspend=true
;&
-l | --lock)
runlock=true
if [[ ${2:0:1} = '-' ]]; then
shift 1
else
lockstyle="$2"; shift 2
fi
;;
-w | --wall)
wallpaper "$2"
shift 2
;;
--wallpaper-cmd)
wallpaper_cmd="$2"
shift 2
;;
--time-format)
time_format="$2"
shift 2
;;
--display)
display_on="$2"
shift 2
;;
--span)
span_image=true
shift 1
;;
--off)
lock_timeout="$2"
shift 2
;;
--text)
locktext="$2"
shift 2
;;
--show-layout)
keylayout="$2";
shift 2
;;
--fx)
IFS=',' read -ra fx_list <<< "$2"
shift 2
;;
--dim)
dim_level="$2"
shift 2
;;
--blur)
blur_level="$2"
shift 2
;;
--pixel)
pixel_scale="$2"
shift 2
;;
--color)
solid_color="${2//\#/}"
shift 2
;;
--desc)
description="$2"
shift 2
;;
-v | --version)
echo
echo "Betterlockscreen: version: v$VERSION (dunst: $DUNST_INSTALLED, feh: $FEH_INSTALLED)"
$i3lockcolor_bin --version
convert --version
if [[ "$DUNST_INSTALLED" == "true" ]]; then
dunstctl debug
fi
if [[ "$FEH_INSTALLED" == "true" ]]; then
feh --version
fi
break
;;
--)
lockargs+=("${@:2}")
break
;;
-h | --help | *)
usage
break
;;
esac
done
echof header "Betterlockscreen"
# Run image generation
[[ $runupdate ]] && update "${imagepaths[@]}"
# Activate lockscreen
[[ $runsuspend ]] || lockargs+=(-n)
[[ $runlock ]] && lockselect "$lockstyle" && \
{ [[ $runsuspend ]] && systemctl suspend; }
exit 0