hyfetch/neofetch

5099 lines
160 KiB
Text
Raw Normal View History

2016-01-03 19:09:23 -07:00
#!/usr/bin/env bash
2016-04-11 18:21:11 -06:00
# set -x
2016-11-10 17:15:05 -07:00
# vim: noai:ts=4:sw=4:expandtab
2016-01-29 08:14:29 -07:00
#
# Neofetch: Simple system information script.
2016-02-27 17:44:45 -07:00
# https://github.com/dylanaraps/neofetch
2015-12-30 03:18:17 -07:00
#
# Created by Dylan Araps
2016-01-04 21:02:24 -07:00
# https://github.com/dylanaraps/
2015-12-30 03:18:17 -07:00
2017-01-30 01:44:12 -07:00
# Neofetch version.
2018-04-05 16:45:23 -06:00
version="3.4.1-git"
2017-01-30 01:44:12 -07:00
bash_version="${BASH_VERSION/.*}"
sys_locale="${LANG:-C}"
XDG_CONFIG_HOME="${XDG_CONFIG_HOME:-${HOME}/.config}"
2016-02-23 15:30:11 -07:00
2016-12-20 03:17:40 -07:00
# Speed up script by not using unicode.
export LC_ALL=C
export LANG=C
2016-01-06 00:34:34 -07:00
2017-08-01 19:33:29 -06:00
# Add more paths to $PATH.
export PATH="/usr/xpg4/bin:/usr/sbin:/sbin:/usr/etc:/usr/libexec:${PATH}"
2016-12-17 02:20:38 -07:00
# Fix issues with gsettings.
export GIO_EXTRA_MODULES="/usr/lib/x86_64-linux-gnu/gio/modules/"
2016-06-13 00:14:03 -06:00
# Set no case match.
shopt -s nocasematch
2016-12-20 03:17:40 -07:00
# Reset colors and bold.
reset="\e[0m"
2016-11-13 02:21:32 -07:00
2016-11-10 17:15:05 -07:00
# DETECT INFORMATION
get_os() {
2016-11-12 01:36:01 -07:00
# $kernel_name is set in a function called cache_uname and is
2016-12-20 03:17:40 -07:00
# just the output of "uname -s".
case "$kernel_name" in
2017-01-04 16:07:36 -07:00
"Linux" | "GNU"*) os="Linux" ;;
"Darwin") os="$(sw_vers -productName)" ;;
2016-10-15 20:48:25 -06:00
*"BSD" | "DragonFly" | "Bitrig") os="BSD" ;;
2017-04-05 02:08:09 -06:00
"CYGWIN"* | "MSYS"* | "MINGW"*) os="Windows" ;;
"SunOS") os="Solaris" ;;
2016-11-04 18:46:08 -06:00
"Haiku") os="Haiku" ;;
2016-12-18 07:34:29 -07:00
"MINIX") os="MINIX" ;;
2017-01-03 08:41:21 -07:00
"AIX") os="AIX" ;;
2018-01-08 17:25:24 -07:00
"IRIX"*) os="IRIX" ;;
"FreeMiNT") os="FreeMiNT" ;;
2016-12-23 05:28:59 -07:00
*)
printf "%s\n" "Unknown OS detected: '$kernel_name', aborting..." >&2
printf "%s\n" "Open an issue on GitHub to add support for your OS." >&2
exit 1
;;
esac
}
2015-12-30 03:18:17 -07:00
get_distro() {
[[ "$distro" ]] && return
2016-02-14 18:39:02 -07:00
case "$os" in
"Linux" | "BSD" | "MINIX")
2018-03-24 02:30:00 -06:00
if [[ -f "/etc/redstar-release" ]]; then
case "$distro_shorthand" in
"on" | "tiny") distro="Red Star OS" ;;
*) distro="Red Star OS $(awk -F'[^0-9*]' '$0=$2' /etc/redstar-release)"
esac
elif [[ -f "/etc/siduction-version" ]]; then
case "$distro_shorthand" in
"on" | "tiny") distro="Siduction" ;;
*) distro="Siduction ($(lsb_release -sic))"
esac
elif type -p lsb_release >/dev/null; then
case "$distro_shorthand" in
"on") lsb_flags="-sir" ;;
"tiny") lsb_flags="-si" ;;
2018-04-22 02:12:38 -06:00
*) lsb_flags="-sd" ;;
esac
2018-04-21 19:09:05 -06:00
distro="$(lsb_release "$lsb_flags")"
elif [[ -f "/etc/GoboLinuxVersion" ]]; then
case "$distro_shorthand" in
"on" | "tiny") distro="GoboLinux" ;;
*) distro="GoboLinux $(< /etc/GoboLinuxVersion)"
esac
2016-11-04 22:06:45 -06:00
elif type -p guix >/dev/null; then
case "$distro_shorthand" in
"on" | "tiny") distro="GuixSD" ;;
*) distro="GuixSD $(guix system -V | awk 'NR==1{printf $5}')"
esac
2016-08-29 08:36:57 -06:00
2016-11-04 22:06:45 -06:00
elif type -p crux >/dev/null; then
distro="$(crux)"
case "$distro_shorthand" in
"on") distro="${distro//version}" ;;
"tiny") distro="${distro//version*}" ;;
esac
2016-02-13 03:14:50 -07:00
2017-03-09 11:55:06 -07:00
elif type -p tazpkg >/dev/null; then
2017-03-09 14:27:16 -07:00
distro="SliTaz $(< /etc/slitaz-release)"
2017-05-18 00:47:02 -06:00
2017-12-21 16:26:48 -07:00
elif type -p kpt >/dev/null && \
type -p kpm >/dev/null; then
2017-05-17 18:47:46 -06:00
distro="KSLinux"
2017-05-18 00:47:02 -06:00
2016-11-06 04:12:35 -07:00
elif [[ -d "/system/app/" && -d "/system/priv-app" ]]; then
2016-08-27 16:59:11 -06:00
distro="Android $(getprop ro.build.version.release)"
2018-04-01 18:05:12 -06:00
# Chrome OS doesn't conform to the /etc/*-release standard.
# While the file is a series of variables they can't be sourced
# by the shell since the values aren't quoted.
elif [[ -f "/etc/lsb-release" && "$(< /etc/lsb-release)" == *CHROMEOS* ]]; then
distro="$(awk -F '=' '/NAME|VERSION/ {printf $2 " "}' /etc/lsb-release)"
elif [[ -f "/etc/os-release" || \
-f "/usr/lib/os-release" || \
-f "/etc/openwrt_release" ]]; then
2018-01-12 13:18:13 -07:00
files=("/etc/os-release" "/usr/lib/os-release" "/etc/openwrt_release")
2017-08-01 19:12:34 -06:00
# Source the os-release file
2017-08-01 19:12:34 -06:00
for file in "${files[@]}"; do
source "$file" && break
done
# Format the distro name.
case "$distro_shorthand" in
2016-11-06 03:32:29 -07:00
"on") distro="${NAME:-${DISTRIB_ID}} ${VERSION_ID:-${DISTRIB_RELEASE}}" ;;
"tiny") distro="${NAME:-${DISTRIB_ID:-${TAILS_PRODUCT_NAME}}}" ;;
2016-12-03 15:20:38 -07:00
"off") distro="${PRETTY_NAME:-${DISTRIB_DESCRIPTION}} ${UBUNTU_CODENAME}" ;;
esac
# Workarounds for distros that go against the os-release standard.
2017-08-01 19:12:34 -06:00
[[ -z "${distro// }" ]] && distro="$(awk '/BLAG/ {print $1; exit}')" "${files[@]}"
[[ -z "${distro// }" ]] && distro="$(awk -F'=' '{print $2; exit}')" "${files[@]}"
else
2016-12-27 19:03:58 -07:00
for release_file in /etc/*-release; do
distro+="$(< "$release_file")"
done
2017-01-04 16:11:17 -07:00
if [[ -z "$distro" ]]; then
case "$distro_shorthand" in
"on" | "tiny") distro="$kernel_name" ;;
*) distro="$kernel_name $kernel_version" ;;
esac
distro="${distro/DragonFly/DragonFlyBSD}"
# Workarounds for FreeBSD based distros.
[[ -f "/etc/pcbsd-lang" ]] && distro="PCBSD"
2017-11-19 08:49:49 -07:00
[[ -f "/etc/trueos-lang" ]] && distro="TrueOS"
2017-08-01 19:12:34 -06:00
# /etc/pacbsd-release is an empty file
[[ -f "/etc/pacbsd-release" ]] && distro="PacBSD"
fi
fi
if [[ "$(< /proc/version)" == *"Microsoft"* ||
"$kernel_version" == *"Microsoft"* ]]; then
case "$distro_shorthand" in
"on") distro+=" [Windows 10]" ;;
"tiny") distro="Windows 10" ;;
*) distro+=" on Windows 10" ;;
esac
2018-03-24 02:30:00 -06:00
elif [[ "$(< /proc/version)" == *"chrome-bot"* || -f "/dev/cros_ec" ]]; then
case "$distro_shorthand" in
"on") distro+=" [Chrome OS]" ;;
"tiny") distro="Chrome OS" ;;
*) distro+=" on Chrome OS" ;;
esac
fi
2018-03-24 02:30:00 -06:00
distro="$(trim_quotes "$distro")"
2017-09-14 16:16:51 -06:00
distro="${distro/'NAME='}"
;;
"Mac OS X")
2016-06-11 23:51:48 -06:00
osx_version="$(sw_vers -productVersion)"
osx_build="$(sw_vers -buildVersion)"
2016-08-13 22:33:36 -06:00
case "$osx_version" in
2017-01-04 16:11:17 -07:00
"10.4"*) codename="Mac OS X Tiger" ;;
"10.5"*) codename="Mac OS X Leopard" ;;
"10.6"*) codename="Mac OS X Snow Leopard" ;;
"10.7"*) codename="Mac OS X Lion" ;;
"10.8"*) codename="OS X Mountain Lion" ;;
"10.9"*) codename="OS X Mavericks" ;;
2016-08-13 22:33:36 -06:00
"10.10"*) codename="OS X Yosemite" ;;
"10.11"*) codename="OS X El Capitan" ;;
"10.12"*) codename="macOS Sierra" ;;
2017-10-17 21:37:00 -06:00
"10.13"*) codename="macOS High Sierra" ;;
2017-01-04 16:11:17 -07:00
*) codename="macOS" ;;
esac
distro="$codename $osx_version $osx_build"
2016-10-07 23:40:59 -06:00
case "$distro_shorthand" in
2016-11-06 03:37:13 -07:00
"on") distro="${distro/ ${osx_build}}" ;;
2016-10-07 23:40:59 -06:00
"tiny")
case "$osx_version" in
2016-10-17 06:48:30 -06:00
"10."[4-7]*) distro="${distro/${codename}/Mac OS X}" ;;
2016-10-17 06:59:54 -06:00
"10."[8-9]* | "10.1"[0-1]*) distro="${distro/${codename}/OS X}" ;;
2017-09-10 23:46:08 -06:00
"10.1"[2-3]*) distro="${distro/${codename}/macOS}" ;;
2016-10-07 23:40:59 -06:00
esac
2016-11-06 03:37:13 -07:00
distro="${distro/ ${osx_build}}"
2016-10-17 06:48:30 -06:00
;;
2016-10-07 23:40:59 -06:00
esac
;;
"iPhone OS")
2016-05-07 19:41:45 -06:00
distro="iOS $(sw_vers -productVersion)"
# "uname -m" doesn't print architecture on iOS so we force it off.
os_arch="off"
;;
"Windows")
2017-01-06 23:02:14 -07:00
distro="$(wmic os get Caption)"
2016-12-20 03:17:40 -07:00
# Strip crap from the output of wmic.
2017-01-06 23:02:14 -07:00
distro="${distro/Caption}"
2016-06-11 23:51:48 -06:00
distro="${distro/Microsoft }"
;;
2016-08-02 04:52:01 -06:00
"Solaris")
2016-10-14 06:09:57 -06:00
case "$distro_shorthand" in
2016-11-11 01:14:36 -07:00
"on" | "tiny") distro="$(awk 'NR==1{print $1 " " $3;}' /etc/release)" ;;
2016-10-14 06:09:57 -06:00
*) distro="$(awk 'NR==1{print $1 " " $2 " " $3;}' /etc/release)" ;;
esac
distro="${distro/\(*}"
2016-08-02 04:52:01 -06:00
;;
2016-11-04 18:46:08 -06:00
"Haiku")
distro="$(uname -sv | awk '{print $1 " " $2}')"
;;
2017-01-03 09:12:55 -07:00
"AIX")
distro="AIX $(oslevel)"
;;
2017-04-26 21:51:57 -06:00
"IRIX")
distro="IRIX ${kernel_version}"
;;
2018-01-08 17:25:24 -07:00
"FreeMiNT")
distro="FreeMiNT"
;;
esac
distro="${distro//Enterprise Server}"
[[ -z "$distro" ]] && distro="$os (Unknown)"
2016-12-20 03:17:40 -07:00
# Get OS architecture.
case "$os" in
2018-01-08 17:25:24 -07:00
"Solaris" | "AIX" | "Haiku" | "IRIX" | "FreeMiNT") machine_arch="$(uname -p)" ;;
*) machine_arch="$(uname -m)" ;;
2017-06-09 11:54:50 -06:00
esac
if [[ "$os_arch" == "on" ]]; then
distro+=" ${machine_arch}"
2017-06-09 11:54:50 -06:00
fi
[[ "${ascii_distro:-auto}" == "auto" ]] && \
2016-08-18 18:03:33 -06:00
ascii_distro="$(trim "$distro")"
}
2016-11-25 23:09:14 -07:00
get_model() {
case "$os" in
"Linux")
if [[ -d "/system/app/" && -d "/system/priv-app" ]]; then
model="$(getprop ro.product.brand) $(getprop ro.product.model)"
elif [[ -f /sys/devices/virtual/dmi/id/product_name ||
-f /sys/devices/virtual/dmi/id/product_version ]]; then
model="$(< /sys/devices/virtual/dmi/id/product_name)"
model+=" $(< /sys/devices/virtual/dmi/id/product_version)"
elif [[ -f /sys/firmware/devicetree/base/model ]]; then
model="$(< /sys/firmware/devicetree/base/model)"
elif [[ -f /tmp/sysinfo/model ]]; then
model="$(< /tmp/sysinfo/model)"
fi
;;
2017-06-13 21:23:44 -06:00
"Mac OS X")
2017-05-30 03:05:33 -06:00
if [[ "$(kextstat | grep "FakeSMC")" != "" ]]; then
model="Hackintosh (SMBIOS: $(sysctl -n hw.model))"
else
model="$(sysctl -n hw.model)"
fi
;;
2016-11-25 23:09:14 -07:00
"iPhone OS")
case "$machine_arch" in
"iPad1,1") model="iPad" ;;
2017-10-17 21:57:05 -06:00
"iPad2,"[1-4]) model="iPad 2" ;;
"iPad3,"[1-3]) model="iPad 3" ;;
"iPad3,"[4-6]) model="iPad 4" ;;
2017-10-17 23:17:52 -06:00
"iPad6,11" | "iPad 6,12") model="iPad 5" ;;
2016-11-25 23:09:14 -07:00
"iPad4,"[1-3]) model="iPad Air" ;;
"iPad5,"[3-4]) model="iPad Air 2" ;;
"iPad6,"[7-8]) model="iPad Pro (12.9 Inch)" ;;
"iPad6,"[3-4]) model="iPad Pro (9.7 Inch)" ;;
2017-10-17 21:57:05 -06:00
"iPad7,"[1-2]) model="iPad Pro 2 (12.9 Inch)" ;;
"iPad7,"[3-4]) model="iPad Pro (10.5 Inch)" ;;
2016-11-25 23:09:14 -07:00
"iPad2,"[5-7]) model="iPad mini" ;;
"iPad4,"[4-6]) model="iPad mini 2" ;;
"iPad4,"[7-9]) model="iPad mini 3" ;;
"iPad5,"[1-2]) model="iPad mini 4" ;;
"iPhone1,1") model="iPhone" ;;
"iPhone1,2") model="iPhone 3G" ;;
"iPhone2,1") model="iPhone 3GS" ;;
"iPhone3,"[1-3]) model="iPhone 4" ;;
"iPhone4,1") model="iPhone 4S" ;;
2017-05-25 17:21:22 -06:00
"iPhone5,"[1-2]) model="iPhone 5" ;;
2016-11-25 23:09:14 -07:00
"iPhone5,"[3-4]) model="iPhone 5c" ;;
"iPhone6,"[1-2]) model="iPhone 5s" ;;
"iPhone7,2") model="iPhone 6" ;;
"iPhone7,1") model="iPhone 6 Plus" ;;
"iPhone8,1") model="iPhone 6s" ;;
"iPhone8,2") model="iPhone 6s Plus" ;;
"iPhone8,4") model="iPhone SE" ;;
"iPhone9,1" | "iPhone9,3") model="iPhone 7" ;;
"iPhone9,2" | "iPhone9,4") model="iPhone 7 Plus" ;;
2017-10-17 21:57:05 -06:00
"iPhone10,1" | "iPhone10,4") model="iPhone 8" ;;
"iPhone10,2" | "iPhone10,5") model="iPhone 8 Plus" ;;
"iPhone10,3" | "iPhone10,6") model="iPhone X" ;;
2016-11-25 23:09:14 -07:00
"iPod1,1") model="iPod touch" ;;
"ipod2,1") model="iPod touch 2G" ;;
"ipod3,1") model="iPod touch 3G" ;;
"ipod4,1") model="iPod touch 4G" ;;
"ipod5,1") model="iPod touch 5G" ;;
"ipod7,1") model="iPod touch 6G" ;;
esac
;;
2016-12-18 07:34:29 -07:00
"BSD" | "MINIX")
2016-11-25 23:09:14 -07:00
model="$(sysctl -n hw.vendor hw.product)"
;;
"Windows")
2017-01-06 23:02:14 -07:00
model="$(wmic computersystem get manufacturer,model)"
model="${model/Manufacturer}"
model="${model/Model}"
2016-11-25 23:09:14 -07:00
;;
"Solaris")
model="$(prtconf -b | awk -F':' '/banner-name/ {printf $2}')"
;;
2017-01-03 19:31:55 -07:00
"AIX")
model="$(/usr/bin/uname -M)"
2017-01-03 19:31:55 -07:00
;;
2018-01-08 17:25:24 -07:00
"FreeMiNT")
model="$(sysctl -n hw.model)"
;;
2016-11-25 23:09:14 -07:00
esac
2016-12-02 23:35:11 -07:00
2016-12-20 03:17:40 -07:00
# Remove dummy OEM info.
2016-12-16 17:37:00 -07:00
model="${model//To be filled by O.E.M.}"
2016-12-02 23:35:11 -07:00
model="${model//To Be Filled*}"
model="${model//OEM*}"
model="${model//Not Applicable}"
model="${model//System Product Name}"
model="${model//System Version}"
model="${model//Undefined}"
model="${model//Default string}"
model="${model//Not Specified}"
model="${model//Type1ProductConfigId}"
2017-09-18 01:29:35 -06:00
model="${model//INVALID}"
2017-11-07 13:20:25 -07:00
model="${model//<2F>}"
2017-08-15 18:46:19 -06:00
case "$model" in
2017-08-15 18:49:37 -06:00
"Standard PC"*) model="KVM/QEMU (${model})" ;;
2017-08-15 18:46:19 -06:00
esac
2016-11-25 23:09:14 -07:00
}
get_title() {
user="${USER:-$(whoami || printf "%s" "${HOME/*\/}")}"
hostname="${HOSTNAME:-$(hostname)}"
title="${title_color}${bold}${user}${at_color}@${title_color}${bold}${hostname}"
length="$((${#user} + ${#hostname} + 1))"
}
2015-12-30 03:18:17 -07:00
get_kernel() {
2017-05-23 23:00:44 -06:00
# Since these OS are integrated systems, it's better to skip this function altogether
2017-05-08 04:49:47 -06:00
[[ "$os" =~ (AIX|IRIX) ]] && return
2017-01-09 04:48:21 -07:00
case "$kernel_shorthand" in
"on") kernel="$kernel_version" ;;
"off") kernel="$kernel_name $kernel_version" ;;
esac
2016-10-30 01:18:15 -06:00
2016-12-20 03:17:40 -07:00
# Hide kernel info if it's identical to the distro info.
if [[ "$os" =~ (BSD|MINIX) && "$distro" == *"$kernel_name"* ]]; then
2016-11-06 00:08:09 -06:00
case "$distro_shorthand" in
"on" | "tiny") kernel="$kernel_version" ;;
2016-11-06 00:08:09 -06:00
*) unset kernel ;;
esac
fi
}
2015-12-30 03:18:17 -07:00
get_uptime() {
2016-11-04 18:46:08 -06:00
# Since Haiku's uptime cannot be fetched in seconds, a case outside
2016-12-20 03:17:40 -07:00
# the usual case is needed.
case "$os" in
2016-11-04 18:46:08 -06:00
"Haiku")
uptime="$(uptime -u)"
uptime="${uptime/up }"
;;
2016-11-04 15:46:29 -06:00
*)
2016-12-20 03:17:40 -07:00
# Get uptime in seconds.
2016-11-04 15:46:29 -06:00
case "$os" in
2016-12-18 07:34:29 -07:00
"Linux" | "Windows" | "MINIX")
2016-11-04 15:46:29 -06:00
seconds="$(< /proc/uptime)"
seconds="${seconds/.*}"
;;
2016-01-03 21:30:14 -07:00
2018-01-08 17:25:24 -07:00
"Mac OS X" | "iPhone OS" | "BSD" | "FreeMiNT")
2016-11-04 15:46:29 -06:00
boot="$(sysctl -n kern.boottime)"
boot="${boot/'{ sec = '}"
boot="${boot/,*}"
2016-04-28 18:05:35 -06:00
2016-12-20 03:17:40 -07:00
# Get current date in seconds.
2016-11-04 15:46:29 -06:00
now="$(date +%s)"
seconds="$((now - boot))"
;;
"Solaris")
seconds="$(kstat -p unix:0:system_misc:snaptime | awk '{print $2}')"
seconds="${seconds/.*}"
;;
2017-01-03 22:52:05 -07:00
2017-05-08 04:59:48 -06:00
"AIX" | "IRIX")
2017-01-03 22:52:05 -07:00
t="$(LC_ALL=POSIX ps -o etime= -p 1)"
d="0" h="0"
case "$t" in *"-"*) d="${t%%-*}"; t="${t#*-}";; esac
case "$t" in *":"*":"*) h="${t%%:*}"; t="${t#*:}";; esac
h="${h#0}" t="${t#0}"
2017-01-03 22:52:05 -07:00
seconds="$((d*86400 + h*3600 + ${t%%:*}*60 + ${t#*:}))"
;;
2016-11-04 15:46:29 -06:00
esac
2016-04-28 18:05:35 -06:00
2016-11-04 15:46:29 -06:00
days="$((seconds / 60 / 60 / 24)) days"
hours="$((seconds / 60 / 60 % 24)) hours"
2016-12-15 04:55:15 -07:00
mins="$((seconds / 60 % 60)) minutes"
# Format the days, hours and minutes.
strip_date() {
case "$1" in
"0 "*) unset "${1/* }" ;;
"1 "*) printf "%s" "${1/s}" ;;
*) printf "%s" "$1" ;;
esac
}
2016-08-02 04:52:01 -06:00
2016-12-15 04:55:15 -07:00
days="$(strip_date "$days")"
hours="$(strip_date "$hours")"
mins="$(strip_date "$mins")"
2016-12-15 04:55:15 -07:00
uptime="${days:+$days, }${hours:+$hours, }${mins}"
2016-11-04 15:46:29 -06:00
uptime="${uptime%', '}"
uptime="${uptime:-${seconds} seconds}"
;;
2016-11-04 18:46:08 -06:00
esac
# Make the output of uptime smaller.
case "$uptime_shorthand" in
"on")
2016-06-11 23:51:48 -06:00
uptime="${uptime/minutes/mins}"
uptime="${uptime/minute/min}"
uptime="${uptime/seconds/secs}"
;;
"tiny")
2016-06-11 23:51:48 -06:00
uptime="${uptime/ days/d}"
uptime="${uptime/ day/d}"
uptime="${uptime/ hours/h}"
uptime="${uptime/ hour/h}"
uptime="${uptime/ minutes/m}"
uptime="${uptime/ minute/m}"
uptime="${uptime/ seconds/s}"
2016-10-20 17:00:09 -06:00
uptime="${uptime//,}"
;;
esac
2015-12-30 03:18:17 -07:00
}
get_packages() {
case "$os" in
"Linux" | "BSD" | "iPhone OS" | "Solaris")
type -p paclog-pkglist >/dev/null && \
2016-12-06 06:35:27 -07:00
packages="$(pacman -Qq --color never | wc -l)"
2016-02-15 04:59:28 -07:00
2016-11-04 22:06:45 -06:00
type -p dpkg >/dev/null && \
2016-12-06 06:35:27 -07:00
packages="$((packages+=$(dpkg --get-selections | grep -cv deinstall$)))"
2017-05-18 00:47:02 -06:00
2016-12-17 02:20:38 -07:00
type -p pkgtool >/dev/null && \
2016-12-06 06:35:27 -07:00
packages="$((packages+=$(ls -1 /var/log/packages | wc -l)))"
2016-02-15 21:21:45 -07:00
2016-11-04 22:06:45 -06:00
type -p rpm >/dev/null && \
2016-12-06 06:35:27 -07:00
packages="$((packages+=$(rpm -qa | wc -l)))"
2016-02-14 15:28:51 -07:00
2016-11-04 22:06:45 -06:00
type -p xbps-query >/dev/null && \
2016-12-06 06:35:27 -07:00
packages="$((packages+=$(xbps-query -l | wc -l)))"
2016-11-04 22:06:45 -06:00
type -p pkginfo >/dev/null && \
2016-12-06 06:35:27 -07:00
packages="$((packages+=$(pkginfo -i | wc -l)))"
2016-11-04 22:06:45 -06:00
type -p emerge >/dev/null && \
2016-12-06 06:35:27 -07:00
packages="$((packages+=$(ls -d /var/db/pkg/*/* | wc -l)))"
2015-12-30 03:18:17 -07:00
2016-11-04 22:06:45 -06:00
type -p nix-env >/dev/null && \
2016-12-06 06:35:27 -07:00
packages="$((packages+=$(ls -d -1 /nix/store/*/ | wc -l)))"
2016-11-04 22:06:45 -06:00
type -p guix >/dev/null && \
2016-12-06 06:35:27 -07:00
packages="$((packages+=$(ls -d -1 /gnu/store/*/ | wc -l)))"
2016-08-27 02:42:56 -06:00
2016-11-04 22:06:45 -06:00
type -p apk >/dev/null && \
2016-12-06 06:35:27 -07:00
packages="$((packages+=$(apk info | wc -l)))"
2016-03-09 04:43:52 -07:00
2016-11-04 22:06:45 -06:00
type -p opkg >/dev/null && \
2016-12-06 06:35:27 -07:00
packages="$((packages+=$(opkg list-installed | wc -l)))"
2016-08-25 20:17:58 -06:00
2016-11-04 22:06:45 -06:00
type -p pacman-g2 >/dev/null && \
2016-12-06 06:35:27 -07:00
packages="$((packages+=$(pacman-g2 -Q | wc -l)))"
2016-02-15 22:31:55 -07:00
2016-11-18 16:34:29 -07:00
type -p lvu >/dev/null && \
2016-12-06 06:35:27 -07:00
packages="$((packages+=$(lvu installed | wc -l)))"
2016-11-18 16:34:29 -07:00
type -p tce-status >/dev/null && \
2016-12-06 06:35:27 -07:00
packages="$((packages+=$(tce-status -i | wc -l)))"
2016-11-18 16:34:29 -07:00
2016-12-02 04:18:55 -07:00
type -p Compile >/dev/null && \
2016-12-06 06:35:27 -07:00
packages="$((packages+=$(ls -d -1 /Programs/*/ | wc -l)))"
2016-12-02 04:18:55 -07:00
2016-12-28 00:25:22 -07:00
type -p eopkg >/dev/null && \
packages="$((packages+=$(ls -1 /var/lib/eopkg/package | wc -l)))"
type -p pkg_info >/dev/null && \
packages="$((packages+=$(pkg_info | wc -l)))"
2017-01-29 17:03:39 -07:00
type -p crew >/dev/null && \
packages="$((packages+=$(ls -l /usr/local/etc/crew/meta/*.filelist | wc -l)))"
2017-03-09 11:55:06 -07:00
type -p tazpkg >/dev/null && \
2017-03-09 14:27:16 -07:00
packages="$((packages+=$(tazpkg list | wc -l) - 6))"
2017-03-09 11:55:06 -07:00
2017-07-21 20:34:12 -06:00
type -p sorcery >/dev/null && \
packages="$((packages+=$(gaze installed | wc -l)))"
2017-07-26 02:34:46 -06:00
type -p alps >/dev/null && \
packages="$((packages+=$(alps showinstalled | wc -l)))"
2017-12-21 16:26:48 -07:00
type -p kpt >/dev/null && \
type -p kpm >/dev/null && \
2017-12-21 16:22:03 -07:00
packages="$((packages+=$(kpm --get-selections | grep -cv deinstall$)))"
2017-07-26 02:34:46 -06:00
2017-08-01 19:12:34 -06:00
if type -p cave >/dev/null; then
package_dir=(/var/db/paludis/repositories/{cross-installed/*,installed}/data/*)
2017-08-01 19:12:34 -06:00
packages="$((packages+=$(ls -d -1 "${package_dir[@]}" | wc -l)))"
fi
2017-11-18 15:52:55 -07:00
type -p butch >/dev/null && \
packages="$((packages+=$(butch list | wc -l)))"
2017-08-01 19:12:34 -06:00
if type -p pkg >/dev/null; then
case "$kernel_name" in
"FreeBSD") packages="$((packages+=$(pkg info | wc -l)))" ;;
*)
packages="$((packages+=$(ls -1 /var/db/pkg | wc -l)))"
2017-01-04 06:36:04 -07:00
((packages == 0)) && packages="$((packages+=$(pkg list | wc -l)))"
esac
fi
2016-02-14 01:42:27 -07:00
;;
2016-12-18 07:34:29 -07:00
"Mac OS X" | "MINIX")
[[ -d "/usr/local/bin" ]] && \
2016-11-15 04:50:48 -07:00
packages="$(($(ls -l /usr/local/bin/ | grep -cv "\(../Cellar/\|brew\)") - 1))"
2016-11-04 22:06:45 -06:00
type -p port >/dev/null && \
2016-11-15 04:50:48 -07:00
packages="$((packages + $(port installed | wc -l) - 1))"
2016-11-04 22:06:45 -06:00
type -p brew >/dev/null && \
2016-11-15 04:50:48 -07:00
packages="$((packages + $(find /usr/local/Cellar -maxdepth 1 | wc -l) - 1))"
2016-11-04 22:06:45 -06:00
type -p pkgin >/dev/null && \
2016-11-15 04:50:48 -07:00
packages="$((packages + $(pkgin list | wc -l)))"
;;
"Windows")
2017-01-06 23:02:14 -07:00
case "$kernel_name" in
"CYGWIN"*) packages="$(cygcheck -cd | wc -l)" ;;
"MSYS"*) packages="$(pacman -Qq --color never | wc -l)"
esac
2016-12-20 03:17:40 -07:00
# Count chocolatey packages.
[[ -d "/cygdrive/c/ProgramData/chocolatey/lib" ]] && \
packages="$((packages+=$(ls -1 /cygdrive/c/ProgramData/chocolatey/lib | wc -l)))"
2016-01-04 22:32:34 -07:00
;;
2016-11-04 18:46:08 -06:00
"Haiku")
packages="$(ls -1 /boot/system/package-links | wc -l)"
;;
2017-01-09 07:42:12 -07:00
"AIX")
packages="$(lslpp -J -l -q | grep -cv '^#')"
packages="$((packages+=$(rpm -qa | wc -l)))"
;;
2017-05-16 02:08:09 -06:00
"IRIX")
packages="$(($(versions -b | wc -l)-3))"
;;
2018-01-08 17:25:24 -07:00
"FreeMiNT")
type -p rpm >/dev/null && \
packages="$((packages+=$(rpm -qa | wc -l)))"
;;
esac
2016-10-20 16:15:03 -06:00
2017-01-04 06:36:04 -07:00
((packages == 0)) && unset packages
}
get_shell() {
case "$shell_path" in
2016-12-15 03:19:29 -07:00
"on") shell="$SHELL " ;;
"off") shell="${SHELL##*/} " ;;
esac
if [[ "$shell_version" == "on" ]]; then
2017-01-24 06:49:14 -07:00
case "${shell_name:=${SHELL##*/}}" in
2016-12-15 03:19:29 -07:00
"bash") shell+="${BASH_VERSION/-*}" ;;
"sh" | "ash" | "dash") ;;
2016-12-15 18:49:59 -07:00
"mksh" | "ksh")
2016-01-28 21:40:52 -07:00
shell+="$("$SHELL" -c 'printf "%s" "$KSH_VERSION"')"
2016-06-11 23:51:48 -06:00
shell="${shell/ * KSH}"
2016-12-15 18:49:59 -07:00
shell="${shell/version}"
;;
2016-01-28 21:40:52 -07:00
2018-01-08 17:25:24 -07:00
"tcsh")
shell+="$("$SHELL" -c 'printf "%s" "$tcsh"')"
;;
*)
shell+="$("$SHELL" --version 2>&1)"
2017-01-24 06:49:14 -07:00
shell="${shell/ "${shell_name}"}"
2016-05-20 19:16:53 -06:00
;;
esac
2016-12-15 03:19:29 -07:00
2016-12-20 03:17:40 -07:00
# Remove unwanted info.
2016-12-15 03:19:29 -07:00
shell="${shell/, version}"
2016-12-15 04:02:32 -07:00
shell="${shell/xonsh\//xonsh }"
2016-12-15 03:19:29 -07:00
shell="${shell/options*}"
shell="${shell/\(*\)}"
fi
}
get_de() {
2016-12-22 06:38:21 -07:00
# If function was run, stop here.
2017-01-01 17:50:29 -07:00
((de_run == 1)) && return
2016-12-22 06:38:21 -07:00
2016-03-31 03:26:20 -06:00
case "$os" in
"Mac OS X") de="Aqua" ;;
2016-10-22 16:07:04 -06:00
"Windows")
case "$distro" in
"Windows 8"* | "Windows 10"*) de="Modern UI/Metro" ;;
*) de="Aero" ;;
esac
;;
2018-01-08 17:25:24 -07:00
"FreeMiNT")
get_wm
for files in /proc/*; do
case "$files" in
*thing*) de="Thing" ;;
*jinnee*) de="Jinnee" ;;
*tera*) de="Teradesk" ;;
*neod*) de="NeoDesk" ;;
*zdesk*) de="zDesk" ;;
*mdesk*) de="mDesk" ;;
esac
2018-01-08 17:25:24 -07:00
done
;;
2016-04-01 09:22:08 -06:00
*)
2017-01-01 17:50:29 -07:00
((wm_run != 1)) && get_wm
2016-12-22 06:25:23 -07:00
2016-12-12 17:22:39 -07:00
if [[ "$XDG_CURRENT_DESKTOP" ]]; then
2017-01-01 17:48:23 -07:00
de="${XDG_CURRENT_DESKTOP/'X-'}"
2016-12-12 17:22:39 -07:00
de="${de/Budgie:GNOME/Budgie}"
2018-04-27 03:54:38 -06:00
de="${de/:Unity7:ubuntu}"
2016-12-12 17:22:39 -07:00
elif [[ "$DESKTOP_SESSION" ]]; then
2017-07-13 17:07:39 -06:00
de="${DESKTOP_SESSION##*/}"
2016-12-22 22:09:28 -07:00
elif [[ "$GNOME_DESKTOP_SESSION_ID" ]]; then
de="GNOME"
elif [[ "$MATE_DESKTOP_SESSION_ID" ]]; then
de="MATE"
2017-12-21 16:11:45 -07:00
elif [[ "$TDE_FULL_SESSION" ]]; then
de="Trinity"
2016-12-12 17:22:39 -07:00
fi
2016-12-22 06:25:23 -07:00
2016-12-22 17:41:11 -07:00
# When a window manager is started from a display manager
# the desktop variables are sometimes also set to the
# window manager name. This checks to see if WM == DE
# and dicards the DE value.
2017-01-26 04:46:39 -07:00
[[ "$wm" && "$de" =~ ^$wm$ ]] && { unset -v de; return; }
2016-04-01 09:22:08 -06:00
;;
2016-03-31 03:26:20 -06:00
esac
2016-04-01 08:51:32 -06:00
# Fallback to using xprop.
2017-12-17 02:43:41 -07:00
[[ "$DISPLAY" && -z "$de" ]] && \
2016-11-04 22:06:45 -06:00
de="$(xprop -root | awk '/KDE_SESSION_VERSION|^_MUFFIN|xfce4|xfce5/')"
2016-04-01 08:51:32 -06:00
2016-12-20 03:17:40 -07:00
# Format strings.
case "$de" in
"KDE_SESSION_VERSION"*) de="KDE${de/* = }" ;;
*"MUFFIN"* | "Cinnamon") de="$(cinnamon --version)"; de="${de:-Cinnamon}" ;;
2017-01-17 14:47:17 -07:00
*"xfce4"*) de="Xfce4" ;;
*"xfce5"*) de="Xfce5" ;;
*"xfce"*) de="Xfce" ;;
*"mate"*) de="MATE" ;;
2017-12-12 14:45:47 -07:00
*"GNOME"*)
de="$(gnome-shell --version)"
de="${de/Shell }"
;;
esac
# Log that the function was run.
de_run=1
}
get_wm() {
2016-12-22 06:38:21 -07:00
# If function was run, stop here.
2017-01-01 17:50:29 -07:00
((wm_run == 1)) && return
2016-12-22 06:32:22 -07:00
2017-12-17 02:43:41 -07:00
if [[ "$WAYLAND_DISPLAY" ]]; then
2017-12-17 03:10:48 -07:00
wm="$(ps -e | grep -m 1 -o -F \
-e "arcan" \
2017-12-17 03:10:48 -07:00
-e "asc" \
-e "clayland" \
-e "dwc" \
2017-12-17 03:10:48 -07:00
-e "fireplace" \
-e "greenfield" \
2017-12-17 03:10:48 -07:00
-e "grefsen" \
-e "lipstick" \
2017-12-17 03:10:48 -07:00
-e "maynard" \
-e "mazecompositor" \
2017-12-17 03:10:48 -07:00
-e "motorcar" \
-e "orbital" \
-e "orbment" \
2017-12-17 03:10:48 -07:00
-e "perceptia" \
-e "rustland" \
-e "sway" \
-e "ulubis" \
2017-12-17 03:10:48 -07:00
-e "velox" \
-e "wavy" \
-e "way-cooler" \
-e "wayfire" \
-e "wayhouse" \
-e "westeros" \
2017-12-17 03:10:48 -07:00
-e "westford" \
-e "weston")"
2017-12-17 02:43:41 -07:00
2018-01-08 17:25:24 -07:00
elif [[ "$DISPLAY" && "$os" != "Mac OS X" && "$os" != "FreeMiNT" ]]; then
2017-07-14 06:45:19 -06:00
id="$(xprop -root -notype _NET_SUPPORTING_WM_CHECK)"
id="${id##* }"
2017-07-14 04:03:01 -06:00
wm="$(xprop -id "$id" -notype -len 100 -f _NET_WM_NAME 8t)"
2017-12-21 16:11:45 -07:00
wm="${wm/*WM_NAME = }"
2016-06-11 23:51:48 -06:00
wm="${wm/\"}"
wm="${wm/\"*}"
2016-02-16 22:54:18 -07:00
2017-07-14 04:03:01 -06:00
# Window Maker does not set _NET_WM_NAME
[[ "$wm" =~ "WINDOWMAKER" ]] && wm="wmaker"
2018-02-11 19:07:21 -07:00
# Fallback for non-EWMH WMs.
[[ -z "$wm" ]] && \
wm="$(ps -e | grep -m 1 -o -F \
-e "catwm" \
2018-04-18 18:25:37 -06:00
-e "dwm" \
2018-02-11 19:07:21 -07:00
-e "monsterwm" \
-e "tinywm")"
else
case "$os" in
2017-02-22 20:12:48 -07:00
"Mac OS X")
ps_line="$(ps -e | grep -o '[S]pectacle\|[A]methyst\|[k]wm\|[c]hun[k]wm')"
2017-03-26 16:50:52 -06:00
2017-03-21 17:58:47 -06:00
case "$ps_line" in
*"chunkwm"*) wm="chunkwm" ;;
*"kwm"*) wm="Kwm" ;;
2017-03-21 17:58:47 -06:00
*"Amethyst"*) wm="Amethyst" ;;
*"Spectacle"*) wm="Spectacle" ;;
*) wm="Quartz Compositor" ;;
2017-03-26 16:50:52 -06:00
esac
2017-02-22 20:12:48 -07:00
;;
2017-02-22 20:24:30 -07:00
"Windows")
2017-12-17 03:10:48 -07:00
wm="$(tasklist | grep -m 1 -o -F \
-e "bugn" \
-e "Windawesome" \
-e "blackbox" \
-e "emerge" \
-e "litestep")"
[[ "$wm" == "blackbox" ]] && wm="bbLean (Blackbox)"
2016-10-25 18:18:37 -06:00
wm="${wm:+$wm, }Explorer"
;;
2018-01-08 17:25:24 -07:00
"FreeMiNT")
wm="Atari AES"
for files in /proc/*; do
case "$files" in
*xaaes*) wm="XaAES" ;;
*myaes*) wm="MyAES" ;;
*naes*) wm="N.AES" ;;
geneva) wm="Geneva" ;;
esac
2018-01-08 17:25:24 -07:00
done
;;
esac
fi
# Log that the function was run.
wm_run=1
2015-12-30 17:21:10 -07:00
}
2015-12-30 03:18:17 -07:00
get_wm_theme() {
2017-01-01 17:50:29 -07:00
((wm_run != 1)) && get_wm
((de_run != 1)) && get_de
2016-03-31 18:26:59 -06:00
2016-03-31 18:28:56 -06:00
case "$wm" in
2017-08-01 19:12:34 -06:00
"E16")
wm_theme="$(awk -F "= " '/theme.name/ {print $2}' "${HOME}/.e16/e_config--0.0.cfg")"
;;
"Sawfish")
2017-12-12 20:43:21 -07:00
wm_theme="$(awk -F '\\(quote|\\)' '/default-frame-style/ {print $(NF-4)}' \
2017-08-01 19:12:34 -06:00
"${HOME}/.sawfish/custom")"
;;
2016-03-31 18:26:59 -06:00
2016-11-01 22:56:00 -06:00
"Cinnamon" | "Muffin" | "Mutter (Muffin)")
2016-03-31 18:35:26 -06:00
detheme="$(gsettings get org.cinnamon.theme name)"
wm_theme="$(gsettings get org.cinnamon.desktop.wm.preferences theme)"
wm_theme="$detheme (${wm_theme})"
2016-03-31 18:35:26 -06:00
;;
2016-11-01 22:56:00 -06:00
"Compiz" | "Mutter" | "GNOME Shell" | "Gala")
2016-11-04 22:06:45 -06:00
if type -p gsettings >/dev/null; then
wm_theme="$(gsettings get org.gnome.shell.extensions.user-theme name)"
2016-10-02 02:30:56 -06:00
[[ -z "${wm_theme//\'}" ]] && \
wm_theme="$(gsettings get org.gnome.desktop.wm.preferences theme)"
2016-03-31 18:35:26 -06:00
2016-11-04 22:06:45 -06:00
elif type -p gconftool-2 >/dev/null; then
wm_theme="$(gconftool-2 -g /apps/metacity/general/theme)"
2016-03-31 18:35:26 -06:00
fi
2016-03-31 18:26:59 -06:00
;;
2016-03-31 18:36:19 -06:00
2016-11-01 22:56:00 -06:00
"Metacity"*)
if [[ "$de" == "Deepin" ]]; then
wm_theme="$(gsettings get com.deepin.wrap.gnome.desktop.wm.preferences theme)"
2016-04-01 01:46:37 -06:00
2017-01-03 06:29:47 -07:00
elif [[ "$de" == "MATE" ]]; then
wm_theme="$(gsettings get org.mate.Marco.general theme)"
2016-04-01 01:46:37 -06:00
else
wm_theme="$(gconftool-2 -g /apps/metacity/general/theme)"
2016-04-01 01:46:37 -06:00
fi
2016-03-31 18:36:19 -06:00
;;
2016-03-31 18:39:53 -06:00
2016-11-01 22:56:00 -06:00
"E17" | "Enlightenment")
2016-11-04 22:06:45 -06:00
if type -p eet >/dev/null; then
2017-08-01 21:07:42 -06:00
wm_theme="$(eet -d "${HOME}/.e/e/config/standard/e.cfg" config |\
2017-08-01 19:12:34 -06:00
awk '/value \"file\" string.*.edj/ {print $4}')"
wm_theme="${wm_theme##*/}"
wm_theme="${wm_theme%.*}"
2016-03-31 18:41:49 -06:00
fi
;;
2016-03-31 18:44:20 -06:00
2016-11-01 22:56:00 -06:00
"Fluxbox")
[[ -f "${HOME}/.fluxbox/init" ]] && \
wm_theme="$(awk -F "/" '/styleFile/ {print $NF}' "${HOME}/.fluxbox/init")"
;;
2016-11-01 22:56:00 -06:00
"IceWM"*)
[[ -f "${HOME}/.icewm/theme" ]] && \
wm_theme="$(awk -F "[\",/]" '!/#/ {print $2}' "${HOME}/.icewm/theme")"
;;
2016-11-01 22:56:00 -06:00
"Openbox")
2016-11-06 04:12:35 -07:00
if [[ "$de" == "LXDE" && -f "${HOME}/.config/openbox/lxde-rc.xml" ]]; then
ob_file="lxde-rc"
elif [[ -f "${HOME}/.config/openbox/rc.xml" ]]; then
ob_file="rc"
fi
2017-08-01 19:12:34 -06:00
wm_theme="$(awk -F "[<,>]" '/<theme/ {getline; print $3}' \
"${XDG_CONFIG_HOME}/openbox/${ob_file}.xml")";
;;
2016-11-01 22:56:00 -06:00
"PekWM")
[[ -f "${HOME}/.pekwm/config" ]] && \
2017-08-01 20:29:09 -06:00
wm_theme="$(awk -F "/" '/Theme/{gsub(/\"/,""); print $NF}' "${HOME}/.pekwm/config")"
;;
2016-11-01 22:56:00 -06:00
"Xfwm4")
[[ -f "${HOME}/.config/xfce4/xfconf/xfce-perchannel-xml/xfwm4.xml" ]] && \
wm_theme="$(xfconf-query -c xfwm4 -p /general/theme)"
;;
2016-11-01 22:56:00 -06:00
"KWin"*)
kde_config_dir
2017-08-01 19:12:34 -06:00
kwinrc="${kde_config_dir}/kwinrc"
kdebugrc="${kde_config_dir}/kdebugrc"
2016-03-31 21:50:15 -06:00
2017-08-01 19:12:34 -06:00
if [[ -f "$kwinrc" ]]; then
2017-08-01 21:06:17 -06:00
wm_theme="$(awk '/theme=/{gsub(/theme=.*qml_|theme=.*svg__/,"",$0);\
2017-08-01 20:29:09 -06:00
print $0; exit}' "$kwinrc")"
[[ -z "$wm_theme" ]] && \
2017-08-01 21:06:17 -06:00
wm_theme="$(awk '/library=org.kde/{gsub(/library=org.kde./,"",$0);\
2017-08-01 20:29:09 -06:00
print $0; exit}' "$kwinrc")"
[[ -z "$wm_theme" ]] && \
2017-08-01 21:06:17 -06:00
wm_theme="$(awk '/PluginLib=kwin3_/{gsub(/PluginLib=kwin3_/,"",$0);\
2017-08-01 20:29:09 -06:00
print $0; exit}' "$kwinrc")"
2016-03-31 21:50:15 -06:00
2017-08-01 19:12:34 -06:00
elif [[ -f "$kdebugrc" ]]; then
wm_theme="$(awk '/(decoration)/ {gsub(/\[/,"",$1); print $1; exit}' "$kdebugrc")"
2016-03-31 21:50:15 -06:00
fi
wm_theme="${wm_theme/'theme='}"
2016-03-31 21:50:15 -06:00
;;
2016-11-01 22:56:00 -06:00
"Quartz Compositor")
2018-02-01 20:01:35 -07:00
global_preferences="${HOME}/Library/Preferences/.GlobalPreferences.plist"
wm_theme="$(PlistBuddy -c "Print AppleInterfaceStyle" "$global_preferences")"
wm_theme_color="$(PlistBuddy -c "Print AppleAquaColorVariant" "$global_preferences")"
2017-08-01 19:12:34 -06:00
[[ -z "$wm_theme" ]] && wm_theme="Light"
2018-02-01 20:01:35 -07:00
if [[ -z "$wm_theme_color" ]] || ((wm_theme_color == 1)); then
wm_theme_color="Blue"
2016-03-31 18:44:20 -06:00
else
2018-02-01 20:01:35 -07:00
wm_theme_color="Graphite"
2016-03-31 18:44:20 -06:00
fi
2018-02-01 20:01:35 -07:00
wm_theme="$wm_theme_color ($wm_theme)"
2016-03-31 18:44:20 -06:00
;;
2016-03-31 18:47:16 -06:00
2016-11-01 22:56:00 -06:00
*"Explorer")
2016-03-31 21:53:31 -06:00
path="/proc/registry/HKEY_CURRENT_USER/Software/Microsoft"
path+="/Windows/CurrentVersion/Themes/CurrentTheme"
wm_theme="$(head -n1 "$path")"
wm_theme="${wm_theme##*\\}"
wm_theme="${wm_theme%.*}"
2016-03-31 21:53:31 -06:00
;;
2016-11-01 22:56:00 -06:00
"Blackbox" | "bbLean"*)
path="$(wmic process get ExecutablePath | grep -F "blackbox")"
2016-11-06 05:00:09 -07:00
path="${path//\\/\/}"
2016-10-17 02:02:53 -06:00
wm_theme="$(grep "^session\.styleFile:" "${path/\.exe/.rc}")"
wm_theme="${wm_theme/'session.styleFile: '}"
wm_theme="${wm_theme##*\\}"
wm_theme="${wm_theme%.*}"
2016-10-17 02:02:53 -06:00
;;
2016-03-31 18:26:59 -06:00
esac
wm_theme="$(trim_quotes "$wm_theme")"
2016-11-15 18:20:14 -07:00
wm_theme="$(uppercase "$wm_theme")"
2016-03-31 18:23:23 -06:00
}
get_cpu() {
2016-12-20 03:17:40 -07:00
# NetBSD emulates the Linux /proc filesystem instead of using sysctl for hw
2016-05-12 17:06:51 -06:00
# information so we have to use this block below which temporarily sets the
2016-12-20 03:17:40 -07:00
# OS to "Linux" for the duration of this function.
[[ "$distro" == "NetBSD"* ]] && local os="Linux"
2016-05-12 17:02:44 -06:00
case "$os" in
"Linux" | "MINIX" | "Windows")
2016-12-20 03:17:40 -07:00
# Get CPU name.
2017-08-01 19:12:34 -06:00
cpu_file="/proc/cpuinfo"
case "$machine_arch" in
"frv" | "hppa" | "m68k" | "openrisc" | "or"* | "powerpc" | "ppc"* | "sparc"*)
cpu="$(awk -F':' '/^cpu\t|^CPU/ {printf $2; exit}' "$cpu_file")"
;;
"s390"*)
cpu="$(awk -F'=' '/machine/ {print $4; exit}' "$cpu_file")"
;;
"ia64" | "m32r")
cpu="$(awk -F':' '/model/ {print $2; exit}' "$cpu_file")"
[[ -z "$cpu" ]] && cpu="$(awk -F':' '/family/ {printf $2; exit}' "$cpu_file")"
;;
*)
2017-08-01 20:58:08 -06:00
cpu="$(awk -F ': | @' '/model name|Processor|^cpu model|chip type|^cpu type/\
2017-08-01 20:29:09 -06:00
{printf $2; exit}' "$cpu_file")"
[[ "$cpu" == *"processor rev"* ]] && \
cpu="$(awk -F':' '/Hardware/ {print $2; exit}' "$cpu_file")"
2017-08-01 19:12:34 -06:00
;;
esac
2016-10-22 16:45:03 -06:00
speed_dir="/sys/devices/system/cpu/cpu0/cpufreq"
2017-12-12 14:56:33 -07:00
# Select the right temperature file.
for temp_dir in /sys/class/hwmon/*; do
[[ "$(< "${temp_dir}/name")" =~ (coretemp|fam15h_power|k10temp) ]] && \
2017-12-12 14:56:33 -07:00
{ temp_dir="${temp_dir}/temp1_input"; break; }
done
2016-12-20 03:17:40 -07:00
# Get CPU speed.
if [[ -d "$speed_dir" ]]; then
# Fallback to bios_limit if $speed_type fails.
2017-08-01 21:07:42 -06:00
speed="$(< "${speed_dir}/${speed_type}")" ||\
speed="$(< "${speed_dir}/bios_limit")" ||\
speed="$(< "${speed_dir}/scaling_max_freq")" ||\
speed="$(< "${speed_dir}/cpuinfo_max_freq")"
speed="$((speed / 1000))"
2016-11-11 17:53:53 -07:00
else
2017-08-01 19:12:34 -06:00
speed="$(awk -F ': |\\.' '/cpu MHz|^clock/ {printf $2; exit}' "$cpu_file")"
speed="${speed/MHz}"
fi
2016-12-20 03:17:40 -07:00
# Get CPU temp.
if [[ -f "$temp_dir" ]]; then
deg="$(< "$temp_dir")"
deg="$((deg * 100 / 10000))"
2016-10-22 16:45:03 -06:00
fi
2016-12-20 03:17:40 -07:00
# Get CPU cores.
2016-10-20 23:38:02 -06:00
case "$cpu_cores" in
2017-08-01 19:12:34 -06:00
"logical" | "on") cores="$(grep -c "^processor" "$cpu_file")" ;;
"physical") cores="$(grep "^core id" "$cpu_file" | sort -u | wc -l)" ;;
esac
;;
"Mac OS X")
cpu="$(sysctl -n machdep.cpu.brand_string)"
2016-12-20 03:17:40 -07:00
# Get CPU cores.
2016-10-20 23:38:02 -06:00
case "$cpu_cores" in
"logical" | "on") cores="$(sysctl -n hw.logicalcpu_max)" ;;
"physical") cores="$(sysctl -n hw.physicalcpu_max)" ;;
esac
;;
"iPhone OS")
case "$machine_arch" in
2016-10-25 18:18:37 -06:00
"iPhone1,"[1-2] | "iPod1,1") cpu="Samsung S5L8900 (1) @ 412MHz" ;;
"iPhone2,1") cpu="Samsung S5PC100 (1) @ 600MHz" ;;
"iPhone3,"[1-3] | "iPod4,1") cpu="Apple A4 (1) @ 800MHz" ;;
"iPhone4,1" | "iPod5,1") cpu="Apple A5 (2) @ 800MHz" ;;
"iPhone5,"[1-4]) cpu="Apple A6 (2) @ 1.3GHz" ;;
"iPhone6,"[1-2]) cpu="Apple A7 (2) @ 1.3GHz" ;;
"iPhone7,"[1-2]) cpu="Apple A8 (2) @ 1.4GHz" ;;
"iPhone8,"[1-4]) cpu="Apple A9 (2) @ 1.85GHz" ;;
"iPhone9,"[1-4]) cpu="Apple A10 Fusion (4) @ 2.34GHz" ;;
2016-10-25 18:18:37 -06:00
"iPod2,1") cpu="Samsung S5L8720 (1) @ 533MHz" ;;
"iPod3,1") cpu="Samsung S5L8922 (1) @ 600MHz" ;;
"iPod7,1") cpu="Apple A8 (2) @ 1.1GHz" ;;
"iPad1,1") cpu="Apple A4 (1) @ 1GHz" ;;
"iPad2,"[1-7]) cpu="Apple A5 (2) @ 1GHz" ;;
"iPad3,"[1-3]) cpu="Apple A5X (2) @ 1GHz" ;;
"iPad3,"[4-6]) cpu="Apple A6X (2) @ 1.4GHz" ;;
"iPad4,"[1-3]) cpu="Apple A7 (2) @ 1.4GHz" ;;
"iPad4,"[4-9]) cpu="Apple A7 (2) @ 1.4GHz" ;;
"iPad5,"[1-2]) cpu="Apple A8 (2) @ 1.5GHz" ;;
"iPad5,"[3-4]) cpu="Apple A8X (3) @ 1.5GHz" ;;
"iPad6,"[3-4]) cpu="Apple A9X (2) @ 2.16GHz" ;;
"iPad6,"[7-8]) cpu="Apple A9X (2) @ 2.26GHz" ;;
2016-05-07 22:44:15 -06:00
esac
2016-05-07 21:32:44 -06:00
;;
"BSD")
2016-12-20 03:17:40 -07:00
# Get CPU name.
cpu="$(sysctl -n hw.model)"
2016-06-11 23:51:48 -06:00
cpu="${cpu/[0-9]\.*}"
cpu="${cpu/ @*}"
2016-01-18 23:33:41 -07:00
2016-12-20 03:17:40 -07:00
# Get CPU speed.
2016-06-11 23:51:48 -06:00
speed="$(sysctl -n hw.cpuspeed)"
[[ -z "$speed" ]] && speed="$(sysctl -n hw.clockrate)"
2016-12-20 03:17:40 -07:00
# Get CPU cores.
2016-06-11 23:51:48 -06:00
cores="$(sysctl -n hw.ncpu)"
2016-11-26 00:43:59 -07:00
2016-12-20 03:17:40 -07:00
# Get CPU temp.
case "$kernel_name" in
"FreeBSD"* | "DragonFly"* | "NetBSD"*)
deg="$(sysctl -n dev.cpu.0.temperature)"
deg="${deg/C}"
;;
"OpenBSD"* | "Bitrig"*)
deg="$(sysctl hw.sensors | \
awk -F '=| degC' '/lm0.temp|cpu0.temp/ {print $2; exit}')"
deg="${deg/00/0}"
;;
esac
;;
2016-08-02 04:52:01 -06:00
"Solaris")
2016-12-20 03:17:40 -07:00
# Get CPU name.
2016-11-11 01:14:36 -07:00
cpu="$(psrinfo -pv)"
cpu="${cpu//*$'\n'}"
2016-08-02 04:52:01 -06:00
cpu="${cpu/[0-9]\.*}"
cpu="${cpu/ @*}"
cpu="${cpu/\(portid*}"
2016-08-02 04:52:01 -06:00
2016-12-20 03:17:40 -07:00
# Get CPU speed.
2016-11-11 01:14:36 -07:00
speed="$(psrinfo -v | awk '/operates at/ {print $6; exit}')"
2016-08-02 04:52:01 -06:00
2016-12-20 03:17:40 -07:00
# Get CPU cores.
2016-10-21 03:27:35 -06:00
case "$cpu_cores" in
"logical" | "on") cores="$(kstat -m cpu_info | grep -c -F "chip_id")" ;;
2016-10-21 03:27:35 -06:00
"physical") cores="$(psrinfo -p)" ;;
esac
2016-08-02 04:52:01 -06:00
;;
2016-11-04 18:46:08 -06:00
"Haiku")
2016-12-20 03:17:40 -07:00
# Get CPU name.
2016-11-04 18:46:08 -06:00
cpu="$(sysinfo -cpu | awk -F '\\"' '/CPU #0/ {print $2}')"
cpu="${cpu/@*}"
2016-12-13 17:40:29 -07:00
2016-12-20 03:17:40 -07:00
# Get CPU speed.
2016-11-04 18:46:08 -06:00
speed="$(sysinfo -cpu | awk '/running at/ {print $NF; exit}')"
speed="${speed/MHz}"
2016-12-13 17:40:29 -07:00
2016-12-20 03:17:40 -07:00
# Get CPU cores.
cores="$(sysinfo -cpu | grep -c -F 'CPU #')"
2016-11-06 00:08:09 -06:00
;;
2017-01-03 19:31:55 -07:00
"AIX")
# Get CPU name.
cpu="$(lsattr -El proc0 -a type | awk '{printf $2}')"
2017-01-03 19:31:55 -07:00
# Get CPU speed.
speed="$(prtconf -s | awk -F':' '{printf $2}')"
2017-01-03 19:31:55 -07:00
speed="${speed/MHz}"
# Get CPU cores.
case "$cpu_cores" in
2017-08-01 19:12:34 -06:00
"logical" | "on")
cores="$(lparstat -i | awk -F':' '/Online Virtual CPUs/ {printf $2}')"
;;
2017-01-03 19:31:55 -07:00
"physical") cores="$(lparstat -i | awk -F':' '/Active Physical CPUs/ {printf $2}')"
esac
;;
2017-05-08 04:38:05 -06:00
"IRIX")
# Get CPU name.
2017-05-22 03:50:24 -06:00
cpu="$(hinv -c processor | awk -F':' '/CPU:/ {printf $2}')"
2017-05-08 04:38:05 -06:00
# Get CPU speed.
2017-05-23 22:48:08 -06:00
speed="$(hinv -c processor | awk '/MHZ/ {printf $2}')"
2017-05-22 03:50:24 -06:00
2017-05-08 04:38:05 -06:00
# Get CPU cores.
2017-05-22 03:50:24 -06:00
cores="$(sysconf NPROC_ONLN)"
2017-05-08 04:38:05 -06:00
;;
2018-01-08 17:25:24 -07:00
"FreeMiNT")
cpu="$(awk -F':' '/CPU:/ {printf $2}' /kern/cpuinfo)"
speed="$(awk -F '[:.M]' '/Clocking:/ {printf $2}' /kern/cpuinfo)"
;;
2016-11-06 00:08:09 -06:00
esac
2016-11-04 18:46:08 -06:00
2016-12-20 03:17:40 -07:00
# Remove un-needed patterns from cpu output.
2016-06-11 23:51:48 -06:00
cpu="${cpu//(TM)}"
2016-12-17 22:08:27 -07:00
cpu="${cpu//(tm)}"
2016-06-11 23:51:48 -06:00
cpu="${cpu//(R)}"
2016-12-17 22:08:27 -07:00
cpu="${cpu//(r)}"
2016-06-11 23:51:48 -06:00
cpu="${cpu//CPU}"
cpu="${cpu//Processor}"
cpu="${cpu//Dual-Core}"
cpu="${cpu//Quad-Core}"
2016-11-06 00:08:09 -06:00
cpu="${cpu//Six-Core}"
cpu="${cpu//Eight-Core}"
cpu="${cpu//, * Compute Cores}"
2018-04-01 15:51:27 -06:00
cpu="${cpu//Core / }"
2017-07-16 03:48:19 -06:00
cpu="${cpu//(\"AuthenticAMD\"*)}"
2016-11-24 02:25:30 -07:00
cpu="${cpu//with Radeon * Graphics}"
cpu="${cpu//, altivec supported}"
cpu="${cpu//FPU*}"
2017-06-20 07:48:56 -06:00
cpu="${cpu//Chip Revision*}"
cpu="${cpu//Technologies, Inc}"
2018-04-04 15:54:37 -06:00
cpu="${cpu//Core2/Core 2}"
2016-03-12 05:01:20 -07:00
2017-07-20 06:38:56 -06:00
# Trim spaces from core and speed output
2017-01-09 04:50:28 -07:00
cores="${cores//[[:space:]]}"
2017-07-20 06:38:56 -06:00
speed="${speed//[[:space:]]}"
2017-01-09 04:50:28 -07:00
# Remove CPU brand from the output.
if [[ "$cpu_brand" == "off" ]]; then
cpu="${cpu/AMD }"
cpu="${cpu/Intel }"
cpu="${cpu/Core? Duo }"
cpu="${cpu/Qualcomm }"
fi
2016-12-20 03:17:40 -07:00
# Add CPU cores to the output.
2016-11-06 04:12:35 -07:00
[[ "$cpu_cores" != "off" && "$cores" ]] && \
case "$os" in
"Mac OS X") cpu="${cpu/@/(${cores}) @}" ;;
*) cpu="$cpu ($cores)" ;;
esac
2016-03-12 05:01:20 -07:00
# Add CPU speed to the output.
if [[ "$cpu_speed" != "off" && "$speed" ]]; then
if (( speed < 1000 )); then
cpu="$cpu @ ${speed}MHz"
else
[[ "$speed_shorthand" == "on" ]] && speed="$((speed / 100))"
speed="${speed:0:1}.${speed:1}"
cpu="$cpu @ ${speed}GHz"
fi
fi
# Add CPU temp to the output.
if [[ "$cpu_temp" != "off" && "$deg" ]]; then
deg="${deg//.}"
# Convert to Fahrenheit if enabled
[[ "$cpu_temp" == "F" ]] && deg="$((deg * 90 / 50 + 320))"
# Format the output
deg="[${deg/${deg: -1}}.${deg: -1}°${cpu_temp:-C}]"
cpu="$cpu $deg"
fi
}
2015-12-30 03:18:17 -07:00
get_cpu_usage() {
2016-06-13 04:22:38 -06:00
case "$os" in
2016-06-13 05:21:32 -06:00
"Windows")
2017-01-06 23:02:14 -07:00
cpu_usage="$(wmic cpu get loadpercentage)"
cpu_usage="${cpu_usage/LoadPercentage}"
2016-06-13 05:21:32 -06:00
cpu_usage="${cpu_usage//[[:space:]]}"
;;
2016-11-13 07:03:19 -07:00
*)
2016-12-20 03:17:40 -07:00
# Get CPU cores if unset.
if [[ "$cpu_cores" != "logical" ]]; then
2016-06-13 04:22:38 -06:00
case "$os" in
2016-12-18 07:34:29 -07:00
"Linux" | "MINIX") cores="$(grep -c "^processor" /proc/cpuinfo)" ;;
"Mac OS X") cores="$(sysctl -n hw.logicalcpu_max)" ;;
"BSD") cores="$(sysctl -n hw.ncpu)" ;;
2016-11-06 05:00:09 -07:00
"Solaris") cores="$(kstat -m cpu_info | grep -c -F "chip_id")" ;;
"Haiku") cores="$(sysinfo -cpu | grep -c -F 'CPU #')" ;;
"iPhone OS") cores="${cpu/*\(}"; cores="${cores/\)*}" ;;
"AIX") cores="$(lparstat -i | awk -F':' '/Online Virtual CPUs/ {printf $2}')" ;;
2018-01-08 17:25:24 -07:00
"IRIX") cores="$(sysconf NPROC_ONLN)" ;;
"FreeMiNT") cores="$(sysctl -n hw.ncpu)"
2016-06-13 04:22:38 -06:00
esac
fi
cpu_usage="$(ps aux | awk 'BEGIN {sum=0} {sum+=$3}; END {print sum}')"
2016-06-13 04:22:38 -06:00
cpu_usage="$((${cpu_usage/\.*} / ${cores:-1}))"
;;
esac
2016-12-20 03:17:40 -07:00
# Print the bar.
2016-06-13 04:22:38 -06:00
case "$cpu_display" in
2016-11-06 03:21:23 -07:00
"bar") cpu_usage="$(bar "$cpu_usage" 100)" ;;
"infobar") cpu_usage="${cpu_usage}% $(bar "$cpu_usage" 100)" ;;
"barinfo") cpu_usage="$(bar "$cpu_usage" 100)${info_color} ${cpu_usage}%" ;;
*) cpu_usage="${cpu_usage}%" ;;
2016-06-13 04:22:38 -06:00
esac
}
get_gpu() {
2016-10-01 20:12:48 -06:00
case "$os" in
2016-12-17 00:50:23 -07:00
"Linux")
# Read GPUs into array.
2018-04-13 17:32:12 -06:00
gpu_cmd="$(lspci -mm | awk -F '\\"|\\" \\"|\\(' \
'/"Display|"3D|"VGA/ {a[$0] = $3 " " $4} END{for(i in a)
{if(!seen[a[i]]++) print a[i]}}')"
IFS=$'\n' read -d "" -ra gpus <<< "$gpu_cmd"
2018-04-08 17:51:23 -06:00
# Remove duplicate Intel Graphics outputs.
# This fixes cases where the outputs are both
# Intel but not entirely identical.
#
# Checking the first two array elements should
# be safe since there won't be 2 intel outputs if
# there's a dedicated GPU in play.
[[ "${gpus[0]}" == *Intel* && \
"${gpus[1]}" == *Intel* ]] && \
unset -v "gpus[0]"
for gpu in "${gpus[@]}"; do
# GPU shorthand tests.
2018-04-08 17:51:23 -06:00
[[ "$gpu_type" == "dedicated" && "$gpu" == *Intel* ]] || \
[[ "$gpu_type" == "integrated" && ! "$gpu" == *Intel* ]] && \
{ unset -v gpu; continue; }
case "$gpu" in
*"advanced"*)
gpu="${gpu/'[AMD/ATI]' }"
gpu="${gpu/'[AMD]' }"
gpu="${gpu/OEM }"
gpu="${gpu/Advanced Micro Devices, Inc.}"
gpu="${gpu/ \/ *}"
gpu="${gpu/*\[}"
gpu="${gpu/\]*}"
gpu="AMD $gpu"
;;
*"nvidia"*)
gpu="${gpu/*\[}"
gpu="${gpu/\]*}"
gpu="NVIDIA $gpu"
;;
*"intel"*)
type -p glxinfo >/dev/null && \
gpu="$(glxinfo | grep "Device:.*Intel")"
2017-01-23 02:34:13 -07:00
gpu="${gpu/*Intel/Intel}"
gpu="${gpu/'(R)'}"
gpu="${gpu/'Corporation'}"
2017-01-23 02:34:13 -07:00
gpu="${gpu/ \(*}"
2018-04-01 18:12:35 -06:00
gpu="${gpu/Integrated Graphics Controller}"
2017-01-23 02:34:13 -07:00
[[ -z "$(trim "$gpu")" ]] && gpu="Intel Integrated Graphics"
;;
*"virtualbox"*)
gpu="VirtualBox Graphics Adapter"
;;
esac
if [[ "$gpu_brand" == "off" ]]; then
2016-12-21 17:26:52 -07:00
gpu="${gpu/AMD }"
gpu="${gpu/NVIDIA }"
gpu="${gpu/Intel }"
fi
prin "${subtitle:+${subtitle}${gpu_name}}" "$gpu"
done
return
2016-01-18 17:55:45 -07:00
;;
"Mac OS X")
2016-12-11 19:14:36 -07:00
if [[ -f "${cache_dir}/neofetch/gpu" ]]; then
2016-12-11 19:10:08 -07:00
source "${cache_dir}/neofetch/gpu"
else
2017-08-01 21:07:42 -06:00
gpu="$(system_profiler SPDisplaysDataType |\
2017-08-01 19:12:34 -06:00
awk -F': ' '/^\ *Chipset Model:/ {printf $2 ", "}')"
2016-12-11 19:10:08 -07:00
gpu="${gpu//'/ $'}"
gpu="${gpu%,*}"
cache "gpu" "$gpu"
fi
2016-01-18 17:55:45 -07:00
;;
2016-05-07 21:32:44 -06:00
"iPhone OS")
case "$machine_arch" in
2016-10-25 18:29:46 -06:00
"iPhone1,"[1-2]) gpu="PowerVR MBX Lite 3D" ;;
"iPhone5,"[1-4]) gpu="PowerVR SGX543MP3" ;;
"iPhone8,"[1-4]) gpu="PowerVR GT7600" ;;
"iPad3,"[1-3]) gpu="PowerVR SGX534MP4" ;;
"iPad3,"[4-6]) gpu="PowerVR SGX554MP4" ;;
"iPad5,"[3-4]) gpu="PowerVR GXA6850" ;;
"iPad6,"[3-8]) gpu="PowerVR 7XT" ;;
"iPhone2,1" | "iPhone3,"[1-3] | "iPod3,1" | "iPod4,1" | "iPad1,1")
gpu="PowerVR SGX535"
;;
2016-10-25 18:29:46 -06:00
"iPhone4,1" | "iPad2,"[1-7] | "iPod5,1")
2016-05-07 22:44:15 -06:00
gpu="PowerVR SGX543MP2"
;;
2016-10-25 18:29:46 -06:00
"iPhone6,"[1-2] | "iPad4,"[1-9])
2016-05-07 22:44:15 -06:00
gpu="PowerVR G6430"
;;
2016-10-25 18:29:46 -06:00
"iPhone7,"[1-2] | "iPod7,1" | "iPad5,"[1-2])
gpu="PowerVR GX6450"
;;
"iPod1,1" | "iPod2,1")
gpu="PowerVR MBX Lite"
;;
2016-05-07 22:44:15 -06:00
esac
2016-05-07 21:32:44 -06:00
;;
"Windows")
gpu="$(wmic path Win32_VideoController get caption)"
gpu="${gpu//Caption}"
;;
"Haiku")
2017-08-01 21:07:42 -06:00
gpu="$(listdev | grep -A2 -F 'device Display controller' |\
2017-08-01 19:12:34 -06:00
awk -F':' '/device beef/ {print $2}')"
;;
*)
case "$kernel_name" in
"FreeBSD"* | "DragonFly"*)
gpu="$(pciconf -lv | grep -B 4 -F "VGA" | grep -F "device")"
2016-06-11 23:51:48 -06:00
gpu="${gpu/*device*= }"
gpu="$(trim_quotes "$gpu")"
2016-01-18 17:55:45 -07:00
;;
2016-05-05 11:39:28 -06:00
2016-05-05 11:44:09 -06:00
*)
2016-06-11 23:51:48 -06:00
gpu="$(glxinfo | grep -F 'OpenGL renderer string')"
gpu="${gpu/'OpenGL renderer string: '}"
2016-05-05 11:39:28 -06:00
;;
2016-01-18 17:55:45 -07:00
esac
;;
esac
2016-01-18 19:52:33 -07:00
if [[ "$gpu_brand" == "off" ]]; then
2016-12-21 17:26:52 -07:00
gpu="${gpu/AMD}"
gpu="${gpu/NVIDIA}"
gpu="${gpu/Intel}"
fi
2016-01-18 17:55:45 -07:00
}
get_memory() {
case "$os" in
2016-12-17 00:50:23 -07:00
"Linux" | "Windows")
# MemUsed = Memtotal + Shmem - MemFree - Buffers - Cached - SReclaimable
# Source: https://github.com/KittyKatt/screenFetch/issues/386#issuecomment-249312716
while IFS=":" read -r a b; do
case "$a" in
2016-11-16 07:04:01 -07:00
"MemTotal") mem_used="$((mem_used+=${b/kB}))"; mem_total="${b/kB}" ;;
"Shmem") mem_used="$((mem_used+=${b/kB}))" ;;
2017-08-01 19:12:34 -06:00
"MemFree" | "Buffers" | "Cached" | "SReclaimable")
mem_used="$((mem_used-=${b/kB}))"
;;
esac
done < /proc/meminfo
2016-05-06 02:35:09 -06:00
2016-11-16 07:04:01 -07:00
mem_used="$((mem_used / 1024))"
mem_total="$((mem_total / 1024))"
;;
2016-05-07 05:14:46 -06:00
"Mac OS X" | "iPhone OS")
mem_total="$(($(sysctl -n hw.memsize) / 1024 / 1024))"
2016-11-16 07:04:01 -07:00
mem_wired="$(vm_stat | awk '/wired/ { print $4 }')"
mem_active="$(vm_stat | awk '/active / { printf $3 }')"
mem_compressed="$(vm_stat | awk '/occupied/ { printf $5 }')"
2018-04-30 00:18:24 -06:00
mem_compressed="${mem_compressed:-0}"
2016-11-16 07:04:01 -07:00
mem_used="$(((${mem_wired//.} + ${mem_active//.} + ${mem_compressed//.}) * 4 / 1024))"
;;
2016-12-18 07:34:29 -07:00
"BSD" | "MINIX")
2016-12-20 03:17:40 -07:00
# Mem total.
case "$kernel_name" in
"NetBSD"*) mem_total="$(($(sysctl -n hw.physmem64) / 1024 / 1024))" ;;
*) mem_total="$(($(sysctl -n hw.physmem) / 1024 / 1024))" ;;
esac
2016-01-17 23:17:32 -07:00
2016-12-20 03:17:40 -07:00
# Mem free.
case "$kernel_name" in
2017-08-01 19:12:34 -06:00
"NetBSD"*)
mem_free="$(($(awk -F ':|kB' '/MemFree:/ {printf $2}' /proc/meminfo) / 1024))"
;;
2016-12-04 16:55:56 -07:00
"FreeBSD"* | "DragonFly"*)
hw_pagesize="$(sysctl -n hw.pagesize)"
mem_inactive="$(($(sysctl -n vm.stats.vm.v_inactive_count) * hw_pagesize))"
mem_unused="$(($(sysctl -n vm.stats.vm.v_free_count) * hw_pagesize))"
mem_cache="$(($(sysctl -n vm.stats.vm.v_cache_count) * hw_pagesize))"
mem_free="$(((mem_inactive + mem_unused + mem_cache) / 1024 / 1024))"
2016-12-04 16:55:56 -07:00
;;
2017-08-01 19:12:34 -06:00
2016-12-18 07:34:29 -07:00
"MINIX")
mem_free="$(top -d 1 | awk -F ',' '/^Memory:/ {print $2}')"
mem_free="${mem_free/M Free}"
;;
2017-08-01 19:12:34 -06:00
"OpenBSD"*) ;;
*) mem_free="$(($(vmstat | awk 'END{printf $5}') / 1024))" ;;
esac
2016-12-20 03:17:40 -07:00
# Mem used.
case "$kernel_name" in
2017-12-25 13:38:11 -07:00
"OpenBSD"*)
2018-01-16 12:46:25 -07:00
mem_used="$(vmstat | awk 'END{printf $3}')"
mem_used="${mem_used/M}"
2017-12-25 13:38:11 -07:00
;;
2018-01-16 12:46:25 -07:00
*) mem_used="$((mem_total - mem_free))" ;;
esac
;;
2016-08-02 04:52:01 -06:00
"Solaris")
2016-11-16 07:04:01 -07:00
mem_total="$(prtconf | awk '/Memory/ {print $3}')"
mem_free="$(($(vmstat | awk 'NR==3{printf $5}') / 1024))"
mem_used="$((mem_total - mem_free))"
2016-08-02 04:52:01 -06:00
;;
2016-11-04 18:46:08 -06:00
"Haiku")
mem_total="$(($(sysinfo -mem | awk -F '\\/ |)' '{print $2; exit}') / 1024 / 1024))"
2016-11-16 07:04:01 -07:00
mem_used="$(sysinfo -mem | awk -F '\\/|)' '{print $2; exit}')"
mem_used="$((${mem_used/max} / 1024 / 1024))"
2016-11-04 18:46:08 -06:00
;;
2017-01-03 22:45:33 -07:00
"AIX")
2018-04-15 03:54:36 -06:00
IFS=$'\n'"| " read -d "" -ra mem_stat <<< "$(svmon -G -O unit=MB)"
2018-04-13 17:40:44 -06:00
2017-01-03 22:45:33 -07:00
mem_total="${mem_stat[11]/.*}"
mem_free="${mem_stat[16]/.*}"
mem_used="$((mem_total - mem_free))"
mem_label="MB"
2017-01-03 22:45:33 -07:00
;;
2017-05-16 01:58:47 -06:00
"IRIX")
2018-04-13 17:40:44 -06:00
IFS=$'\n' read -d "" -ra mem_cmd <<< "$(pmem)"
IFS=" " read -ra mem_stat <<< "${mem_cmd[0]}"
2017-05-16 02:04:26 -06:00
mem_total="$((mem_stat[3] / 1024))"
mem_free="$((mem_stat[5] / 1024))"
2017-05-16 01:58:47 -06:00
mem_used="$((mem_total - mem_free))"
;;
2018-01-08 17:25:24 -07:00
"FreeMiNT")
mem="$(awk -F ':|kB' '/MemTotal:|MemFree:/ {printf $2, " "}' /kern/meminfo)"
mem_free="${mem/* }"
mem_total="${mem/ *}"
mem_used="$((mem_total - mem_free))"
mem_total="$((mem_total / 1024))"
mem_used="$((mem_used / 1024))"
;;
esac
memory="${mem_used}${mem_label:-MiB} / ${mem_total}${mem_label:-MiB}"
2016-12-20 03:17:40 -07:00
# Bars.
2016-03-12 13:58:46 -07:00
case "$memory_display" in
2016-11-16 07:04:01 -07:00
"bar") memory="$(bar "${mem_used}" "${mem_total}")" ;;
"infobar") memory="${memory} $(bar "${mem_used}" "${mem_total}")" ;;
"barinfo") memory="$(bar "${mem_used}" "${mem_total}")${info_color} ${memory}" ;;
2016-03-12 06:00:02 -07:00
esac
}
get_song() {
player="$(ps -e | grep -m 1 -o \
2018-02-02 09:00:44 -07:00
-e "Google Play" \
-e "Spotify" \
-e "amarok" \
-e "audacious" \
-e "banshee" \
-e "bluemindo" \
-e "clementine" \
-e "cmus" \
-e "deadbeef" \
-e "deepin-music" \
-e "elisa" \
-e "exaile" \
-e "gnome-music" \
-e "guayadeque" \
-e "iTunes$" \
2018-02-02 09:00:44 -07:00
-e "juk" \
-e "lollypop" \
-e "mocp" \
-e "mopidy" \
-e "mpd" \
-e "pogo" \
-e "pragha" \
-e "qmmp" \
-e "quodlibet" \
-e "rhythmbox" \
-e "spotify" \
-e "tomahawk" \
-e "xmms2d" \
-e "yarock")"
[[ "$music_player" && "$music_player" != "auto" ]] && \
player="$music_player"
2016-12-15 05:40:54 -07:00
get_song_dbus() {
# Multiple players use an almost identical dbus command to get the information.
2016-12-20 03:17:40 -07:00
# This function saves us using the same command throughout the function.
2016-12-15 05:40:54 -07:00
song="$(\
dbus-send --print-reply --dest=org.mpris.MediaPlayer2."${1}" /org/mpris/MediaPlayer2 \
2017-08-01 19:12:34 -06:00
org.freedesktop.DBus.Properties.Get string:'org.mpris.MediaPlayer2.Player' \
string:'Metadata' |\
2016-12-15 05:40:54 -07:00
awk -F 'string "' '/string|array/ {printf "%s",$2; next}{print ""}' |\
awk -F '"' '/artist/ {a=$2} /title/ {t=$2} END{print a " - " t}'
2016-12-15 05:40:54 -07:00
)"
}
2016-10-26 01:09:59 -06:00
case "${player/*\/}" in
2017-01-07 13:53:04 -07:00
"mpd"* | "mopidy"*) song="$(mpc current)" ;;
2017-04-11 16:16:50 -06:00
"mocp"*) song="$(mocp -Q "%artist - %song")" ;;
"google play"*) song="$(gpmdp-remote current)" ;;
"rhythmbox"*) song="$(rhythmbox-client --print-playing)" ;;
"deadbeef"*) song="$(deadbeef --nowplaying-tf '%artist% - %title%')" ;;
"xmms2d"*) song="$(xmms2 current -f '${artist} - ${title}')" ;;
"qmmp"*) song="$(qmmp --nowplaying '%p - %t')" ;;
"gnome-music"*) get_song_dbus "GnomeMusic" ;;
"lollypop"*) get_song_dbus "Lollypop" ;;
"clementine"*) get_song_dbus "clementine" ;;
"juk"*) get_song_dbus "juk" ;;
"bluemindo"*) get_song_dbus "Bluemindo" ;;
"guayadeque"*) get_song_dbus "guayadeque" ;;
"yarock"*) get_song_dbus "yarock" ;;
2017-04-11 11:03:17 -06:00
"deepin-music"*) get_song_dbus "deepinmusic" ;;
2017-04-11 16:16:50 -06:00
"tomahawk"*) get_song_dbus "tomahawk" ;;
2017-09-16 13:17:22 -06:00
"elisa"*) get_song_dbus "elisa" ;;
2017-02-18 16:42:45 -07:00
"audacious"*)
song="$(audtool current-song)"
# Remove Album from 'Artist - Album - Title'
song="${song/-* -/-}"
[[ -z "$song" ]] && get_song_dbus "audacious"
;;
2016-10-25 22:18:11 -06:00
"cmus"*)
2017-08-01 21:06:17 -06:00
song="$(cmus-remote -Q | awk '/tag artist/ {$1=$2=""; print; print " - "}\
2017-08-01 19:12:34 -06:00
/tag title/ {$1=$2=""; print}')"
2016-10-25 22:18:11 -06:00
;;
2016-10-25 22:18:11 -06:00
"spotify"*)
case "$os" in
2016-12-15 05:40:54 -07:00
"Linux") get_song_dbus "spotify" ;;
2016-10-25 22:18:11 -06:00
"Mac OS X")
song="$(osascript <<END
if application "Spotify" is running then
tell application "Spotify"
artist of current track as string & \
" - " & name of current track as string
end tell
end if
END
)"
2016-10-25 22:18:11 -06:00
;;
esac
;;
2016-09-04 06:28:08 -06:00
2016-10-26 04:18:46 -06:00
"itunes"*)
song="$(osascript <<END
if application "iTunes" is running then
tell application "iTunes"
artist of current track as string & \
" - " & name of current track as string
end tell
end if
END
)"
2016-10-25 22:18:11 -06:00
;;
2016-10-25 22:18:11 -06:00
"banshee"*)
2017-08-01 19:12:34 -06:00
song="$(banshee --query-artist --query-title |\
awk -F':' '/^artist/ {a=$2} /^title/ {t=$2} END{print a " - " t}')"
2016-10-25 22:18:11 -06:00
;;
"amarok"*)
2017-08-01 19:12:34 -06:00
song="$(qdbus org.kde.amarok /Player GetMetadata |\
awk -F':' '/^artist/ {a=$2} /^title/ {t=$2} END{print a " - " t}')"
2016-10-25 22:18:11 -06:00
;;
2016-11-24 08:08:52 -07:00
"pragha"*)
2017-01-05 06:50:39 -07:00
song="$(pragha -c | awk -F':' '/^artist/ {a=$2} /^title/ {t=$2} END{print a " - " t}')"
2016-11-24 08:08:52 -07:00
;;
2016-12-22 15:44:59 -07:00
"exaile"*)
song="$(dbus-send --print-reply --dest=org.exaile.Exaile /org/exaile/Exaile \
2016-12-26 09:11:53 -07:00
org.exaile.Exaile.Query | awk -F':|,' '{if ($6 && $4) printf $6 " -" $4}')"
2016-12-22 15:44:59 -07:00
;;
2017-01-08 07:08:03 -07:00
"quodlibet"*)
2017-08-01 19:12:34 -06:00
song="$(dbus-send --print-reply --dest=net.sacredchao.QuodLibet \
/net/sacredchao/QuodLibet net.sacredchao.QuodLibet.CurrentSong |\
2017-08-01 21:06:17 -06:00
awk -F'"' '/artist/ {getline; a=$2} \
2017-08-01 19:12:34 -06:00
/title/ {getline; t=$2} END{print a " - " t}')"
2017-01-08 07:08:03 -07:00
;;
2017-07-15 07:16:41 -06:00
"pogo"*)
2017-08-01 19:12:34 -06:00
song="$(dbus-send --print-reply --dest=org.mpris.pogo /Player \
org.freedesktop.MediaPlayer.GetMetadata |
2017-08-01 21:06:17 -06:00
awk -F'"' '/string "artist"/ {getline; a=$2} /string "title"/ {getline; t=$2} \
2017-08-01 19:12:34 -06:00
END{print a " - " t}')"
2017-07-15 07:16:41 -06:00
;;
2017-08-01 19:12:34 -06:00
*) mpc >/dev/null 2>&1 && song="$(mpc current)" ;;
2016-02-15 20:50:20 -07:00
esac
2017-01-26 00:19:44 -07:00
[[ "$(trim "$song")" == "-" ]] && unset -v song
2017-01-05 06:50:39 -07:00
2016-12-18 20:53:38 -07:00
# Display Artist and Title on separate lines.
if [[ "$song_shorthand" == "on" && "$song" ]]; then
artist="${song/ -*}"
song="${song/*-}"
if [[ "$song" != "$artist" ]]; then
2016-04-01 18:44:08 -06:00
prin "Artist" "$artist"
prin "Song" "$song"
else
2016-04-01 18:44:08 -06:00
prin "$subtitle" "$song"
fi
fi
}
get_resolution() {
case "$os" in
"Mac OS X")
2016-11-04 22:06:45 -06:00
if type -p screenresolution >/dev/null; then
resolution="$(screenresolution get 2>&1 | awk '/Display/ {printf $6 "Hz, "}')"
2016-06-11 23:51:48 -06:00
resolution="${resolution//x??@/ @ }"
2016-03-27 02:50:09 -06:00
else
2017-08-01 19:12:34 -06:00
resolution="$(system_profiler SPDisplaysDataType |\
awk '/Resolution:/ {printf $2"x"$4" @ "$6"Hz, "}')"
2016-03-27 02:50:09 -06:00
fi
2016-03-27 03:13:32 -06:00
if [[ -e "/Library/Preferences/com.apple.windowserver.plist" ]]; then
scale_factor="$(PlistBuddy -c "Print DisplayAnyUserSets:0:0:Resolution" \
/Library/Preferences/com.apple.windowserver.plist)"
else
scale_factor=""
fi
# If no refresh rate is empty.
2016-12-08 01:24:58 -07:00
[[ "$resolution" == *"@ Hz"* ]] && \
resolution="${resolution//@ Hz}"
[[ "${scale_factor%.*}" == 2 ]] && \
resolution="${resolution// @/@2x @}"
if [[ "$refresh_rate" == "off" ]]; then
resolution="${resolution// @ [0-9][0-9]Hz}"
resolution="${resolution// @ [0-9][0-9][0-9]Hz}"
fi
2016-12-08 01:24:58 -07:00
[[ "$resolution" == *"0Hz"* ]] && \
resolution="${resolution// @ 0Hz}"
;;
2016-01-17 23:24:08 -07:00
2016-02-21 03:01:46 -07:00
"Windows")
2017-01-13 15:50:41 -07:00
local width=""
width="$(wmic path Win32_VideoController get CurrentHorizontalResolution)"
width="${width//CurrentHorizontalResolution/}"
2017-01-13 15:50:41 -07:00
local height=""
height="$(wmic path Win32_VideoController get CurrentVerticalResolution)"
height="${height//CurrentVerticalResolution/}"
[[ "$(trim "$width")" ]] && resolution="${width//[[:space:]]}x${height//[[:space:]]}"
2016-02-21 03:01:46 -07:00
;;
2016-11-04 18:46:08 -06:00
"Haiku")
resolution="$(screenmode | awk -F ' |, ' '{printf $2 "x" $3 " @ " $6 $7}')"
[[ "$refresh_rate" == "off" ]] && resolution="${resolution/ @*}"
2016-11-04 18:46:08 -06:00
;;
*)
if type -p xrandr >/dev/null; then
case "$refresh_rate" in
2017-08-01 19:12:34 -06:00
"on")
resolution="$(xrandr --nograb --current |\
2017-08-01 21:06:17 -06:00
awk 'match($0,/[0-9]*\.[0-9]*\*/) {printf $1 " @ "\
2017-08-01 19:12:34 -06:00
substr($0,RSTART,RLENGTH) "Hz, "}')"
;;
"off")
2017-08-01 21:07:42 -06:00
resolution="$(xrandr --nograb --current |\
awk -F 'connected |\\+|\\(' \
'/ connected/ && $2 {printf $2 ", "}')"
resolution="${resolution/primary }"
;;
esac
resolution="${resolution//\*}"
elif type -p xdpyinfo >/dev/null; then
resolution="$(xdpyinfo | awk '/dimensions:/ {printf $2}')"
fi
;;
2016-01-29 06:34:48 -07:00
esac
2016-03-17 23:28:26 -06:00
2016-06-11 23:51:48 -06:00
resolution="${resolution%,*}"
}
get_style() {
2016-12-20 03:17:40 -07:00
# Fix weird output when the function is run multiple times.
2016-11-15 18:20:14 -07:00
unset gtk2_theme gtk3_theme theme path
2017-12-17 02:43:41 -07:00
if [[ "$DISPLAY" && "$os" != "Mac OS X" ]]; then
# Get DE if user has disabled the function.
2017-01-01 17:50:29 -07:00
((de_run != 1)) && get_de
2016-11-15 18:20:14 -07:00
# Check for DE Theme.
case "$de" in
"KDE"*)
kde_config_dir
2016-02-15 16:31:13 -07:00
if [[ -f "${kde_config_dir}/kdeglobals" ]]; then
kde_config_file="${kde_config_dir}/kdeglobals"
2016-02-15 16:31:13 -07:00
kde_theme="$(grep "^${kde}" "$kde_config_file")"
2017-09-12 07:02:13 -06:00
kde_theme="${kde_theme/*=}"
if [[ "$kde" == "font" ]]; then
kde_font_size="${kde_theme#*,}"
kde_font_size="${kde_font_size/,*}"
kde_theme="${kde_theme/,*} ${kde_theme/*,} ${kde_font_size}"
fi
2017-08-16 18:31:26 -06:00
kde_theme="$(uppercase "$kde_theme") [KDE], "
2016-12-22 00:57:01 -07:00
else
err "Theme: KDE config files not found, skipping."
fi
;;
*"Cinnamon"*)
2016-11-04 22:06:45 -06:00
if type -p gsettings >/dev/null; then
2016-11-15 18:20:14 -07:00
gtk3_theme="$(gsettings get org.cinnamon.desktop.interface "$gsettings")"
gtk2_theme="$gtk3_theme"
fi
;;
2016-11-01 17:16:16 -06:00
"Gnome"* | "Unity"* | "Budgie"*)
2016-11-04 22:06:45 -06:00
if type -p gsettings >/dev/null; then
2016-11-15 18:20:14 -07:00
gtk3_theme="$(gsettings get org.gnome.desktop.interface "$gsettings")"
gtk2_theme="$gtk3_theme"
2016-11-04 22:06:45 -06:00
elif type -p gconftool-2 >/dev/null; then
2016-11-15 18:20:14 -07:00
gtk2_theme="$(gconftool-2 -g /desktop/gnome/interface/"$gconf")"
fi
;;
"Mate"*)
2016-11-15 18:20:14 -07:00
gtk3_theme="$(gsettings get org.mate.interface "$gsettings")"
gtk2_theme="$gtk3_theme"
;;
"Xfce"*)
2016-11-04 22:06:45 -06:00
type -p xfconf-query >/dev/null && \
2016-11-15 18:20:14 -07:00
gtk2_theme="$(xfconf-query -c xsettings -p "$xfconf")"
;;
esac
2016-12-20 03:17:40 -07:00
# Check for general GTK2 Theme.
2016-11-15 18:20:14 -07:00
if [[ -z "$gtk2_theme" ]]; then
if [[ -f "${GTK2_RC_FILES:-${HOME}/.gtkrc-2.0}" ]]; then
gtk2_theme="$(grep "^[^#]*${name}" "${GTK2_RC_FILES:-${HOME}/.gtkrc-2.0}")"
2016-01-27 17:34:41 -07:00
elif [[ -f "/usr/share/gtk-2.0/gtkrc" ]]; then
2016-11-15 18:20:14 -07:00
gtk2_theme="$(grep "^[^#]*${name}" /usr/share/gtk-2.0/gtkrc)"
elif [[ -f "/etc/gtk-2.0/gtkrc" ]]; then
2016-11-15 18:20:14 -07:00
gtk2_theme="$(grep "^[^#]*${name}" /etc/gtk-2.0/gtkrc)"
2016-02-08 05:29:48 -07:00
fi
2016-11-15 18:20:14 -07:00
gtk2_theme="${gtk2_theme/${name}*=}"
fi
2016-12-20 03:17:40 -07:00
# Check for general GTK3 Theme.
2016-11-15 18:20:14 -07:00
if [[ -z "$gtk3_theme" ]]; then
if [[ -f "${XDG_CONFIG_HOME}/gtk-3.0/settings.ini" ]]; then
gtk3_theme="$(grep "^[^#]*$name" "${XDG_CONFIG_HOME}/gtk-3.0/settings.ini")"
2016-11-04 22:06:45 -06:00
elif type -p gsettings >/dev/null; then
2016-11-15 18:20:14 -07:00
gtk3_theme="$(gsettings get org.gnome.desktop.interface "$gsettings")"
2016-01-27 17:34:41 -07:00
elif [[ -f "/usr/share/gtk-3.0/settings.ini" ]]; then
2016-11-15 18:20:14 -07:00
gtk3_theme="$(grep "^[^#]*$name" /usr/share/gtk-3.0/settings.ini)"
elif [[ -f "/etc/gtk-3.0/settings.ini" ]]; then
2016-11-15 18:20:14 -07:00
gtk3_theme="$(grep "^[^#]*$name" /etc/gtk-3.0/settings.ini)"
fi
2016-11-15 18:20:14 -07:00
gtk3_theme="${gtk3_theme/${name}*=}"
fi
2016-01-23 16:38:46 -07:00
2016-12-20 03:17:40 -07:00
# Trim whitespace.
2016-11-15 18:20:14 -07:00
gtk2_theme="$(trim "$gtk2_theme")"
gtk3_theme="$(trim "$gtk3_theme")"
2016-12-20 03:17:40 -07:00
# Remove quotes.
2016-11-15 18:20:14 -07:00
gtk2_theme="$(trim_quotes "$gtk2_theme")"
gtk3_theme="$(trim_quotes "$gtk3_theme")"
2016-06-11 19:41:25 -06:00
2016-12-20 03:17:40 -07:00
# Uppercase the first letter of each GTK theme.
2016-11-15 18:20:14 -07:00
gtk2_theme="$(uppercase "$gtk2_theme")"
gtk3_theme="$(uppercase "$gtk3_theme")"
2016-12-20 03:17:40 -07:00
# Toggle visibility of GTK themes.
2016-11-15 18:20:14 -07:00
[[ "$gtk2" == "off" ]] && unset gtk2_theme
[[ "$gtk3" == "off" ]] && unset gtk3_theme
2016-12-20 03:17:40 -07:00
# Format the string based on which themes exist.
2017-08-16 18:31:26 -06:00
if [[ "$gtk2_theme" && "$gtk2_theme" == "$gtk3_theme" ]]; then
2016-11-15 18:20:14 -07:00
gtk3_theme+=" [GTK2/3]"
unset gtk2_theme
elif [[ "$gtk2_theme" && "$gtk3_theme" ]]; then
gtk2_theme+=" [GTK2], "
gtk3_theme+=" [GTK3] "
else
2016-11-15 18:20:14 -07:00
[[ "$gtk2_theme" ]] && gtk2_theme+=" [GTK2] "
[[ "$gtk3_theme" ]] && gtk3_theme+=" [GTK3] "
fi
2016-12-20 03:17:40 -07:00
# Final string.
theme="${kde_theme}${gtk2_theme}${gtk3_theme}"
2017-08-16 18:31:26 -06:00
theme="${theme%, }"
2016-12-20 03:17:40 -07:00
# Make the output shorter by removing "[GTKX]" from the string.
if [[ "$gtk_shorthand" == "on" ]]; then
2016-11-15 18:20:14 -07:00
theme="${theme// '[GTK'[0-9]']'}"
2016-06-11 23:51:48 -06:00
theme="${theme/ '[GTK2/3]'}"
theme="${theme/ '[KDE]'}"
fi
fi
}
get_theme() {
2016-11-15 18:20:14 -07:00
name="gtk-theme-name"
gsettings="gtk-theme"
gconf="gtk_theme"
xfconf="/Net/ThemeName"
kde="Name"
2016-11-15 18:20:14 -07:00
get_style
}
get_icons() {
2016-11-15 18:20:14 -07:00
name="gtk-icon-theme-name"
gsettings="icon-theme"
gconf="icon_theme"
xfconf="/Net/IconThemeName"
kde="Theme"
get_style
icons="$theme"
}
get_font() {
2016-11-15 18:20:14 -07:00
name="gtk-font-name"
gsettings="font-name"
gconf="font_theme"
xfconf="/Gtk/FontName"
kde="font"
get_style
font="$theme"
}
get_term() {
2016-12-22 06:38:21 -07:00
# If function was run, stop here.
2017-01-01 17:50:29 -07:00
((term_run == 1)) && return
2016-12-22 06:38:21 -07:00
# Workaround for macOS systems that
# don't support the block below.
case "$TERM_PROGRAM" in
"iTerm.app") term="iTerm2" ;;
"Terminal.app") term="Apple Terminal" ;;
"Hyper") term="HyperTerm" ;;
*) term="${TERM_PROGRAM/\.app}" ;;
2016-05-27 19:38:41 -06:00
esac
2018-01-08 17:25:24 -07:00
# Most likely TosWin2 on FreeMiNT - quick check
[[ "$TERM" == "tw52" || "$TERM" == "tw100" ]] && \
term="TosWin2"
# Check $PPID for terminal emulator.
2017-05-20 07:17:56 -06:00
while [[ -z "$term" ]]; do
if [[ "$SSH_CONNECTION" ]]; then
term="$SSH_TTY"; break
else
parent="$(get_ppid "$parent")"
[[ -z "$parent" ]] && break
name="$(get_process_name "$parent")"
case "${name// }" in
"${SHELL/*\/}" | *"sh" | "tmux"* | "screen" | "su"*) ;;
"login"* | *"Login"* | "init" | "(init)") term="$(tty)" ;;
2017-08-01 19:33:29 -06:00
"ruby" | "1" | "systemd" | "sshd"* | "python"* | "USER"*"PID"* | "kdeinit"*)
break
;;
"gnome-terminal-") term="gnome-terminal" ;;
*"nvim") term="Neovim Terminal" ;;
*"NeoVimServer"*) term="VimR Terminal" ;;
*) term="${name##*/}" ;;
esac
fi
done
# Log that the function was run.
term_run=1
2016-05-16 05:35:29 -06:00
}
get_term_font() {
2017-07-31 09:42:00 -06:00
((term_run != 1)) && get_term
2016-05-16 05:35:29 -06:00
case "$term" in
"alacritty"*)
if [[ -f "${XDG_CONFIG_HOME}/alacritty.yml" ]]; then
alacritty_file="${XDG_CONFIG_HOME}/alacritty.yml"
elif [[ -f "${XDG_CONFIG_HOME}/alacritty/alacritty.yml" ]]; then
alacritty_file="${XDG_CONFIG_HOME}/alacritty/alacritty.yml"
elif [[ -f "${HOME}/.alacritty.yml" ]]; then
alacritty_file="${HOME}/.alacritty.yml"
fi
2017-08-01 19:33:29 -06:00
term_font="$(awk -F ':|#' '/normal:/ {getline; print}' \
"$alacritty_file")"
term_font="${term_font/*family:}"
term_font="${term_font/$'\n'*}"
term_font="${term_font/\#*}"
2016-05-18 00:39:05 -06:00
;;
2016-05-22 20:35:47 -06:00
"Apple_Terminal")
term_font="$(osascript <<END
tell application "Terminal" to font name of window frontmost
END
)"
2016-05-22 20:35:47 -06:00
;;
2017-03-01 17:45:46 -07:00
"iTerm2")
# Unfortunately the profile name is not unique, but it seems to be the only thing
2017-08-01 19:33:29 -06:00
# that identifies an active profile. There is the "id of current session of current win-
# dow" though, but that does not match to a guid in the plist.
# So, be warned, collisions may occur!
# See: https://groups.google.com/forum/#!topic/iterm2-discuss/0tO3xZ4Zlwg
2017-08-01 19:33:29 -06:00
local current_profile_name profiles_count profile_name diff_font none_ascii
current_profile_name="$(osascript <<END
tell application "iTerm2" to profile name \
of current session of current window
END
)"
2017-03-01 17:45:46 -07:00
# Warning: Dynamic profiles are not taken into account here!
# https://www.iterm2.com/documentation-dynamic-profiles.html
2017-08-01 21:06:17 -06:00
font_file="${HOME}/Library/Preferences/com.googlecode.iterm2.plist"
2017-03-01 17:45:46 -07:00
# Count Guids in "New Bookmarks"; they should be unique
2017-08-01 21:06:17 -06:00
profiles_count="$(PlistBuddy -c "Print :New\ Bookmarks:" "$font_file" | grep -c "Guid")"
2017-03-08 17:13:31 -07:00
2017-03-08 15:19:03 -07:00
for ((i=0; i<=profiles_count; i++)); do
2017-08-01 19:33:29 -06:00
profile_name="$(PlistBuddy -c "Print :New\ Bookmarks:${i}:Name:" "$font_file")"
2017-03-08 17:13:31 -07:00
2017-03-08 15:19:03 -07:00
if [[ "$profile_name" == "$current_profile_name" ]]; then
2017-03-01 17:45:46 -07:00
# "Normal Font"
2017-08-01 19:33:29 -06:00
term_font="$(PlistBuddy -c "Print :New\ Bookmarks:${i}:Normal\ Font:" \
"$font_file")"
2017-03-01 17:45:46 -07:00
# Font for non-ascii characters
# Only check for a different non-ascii font, if the user checked
# the "use a different font for non-ascii text" switch.
2017-08-01 19:33:29 -06:00
diff_font="$(PlistBuddy -c "Print :New\ Bookmarks:${i}:Use\ Non-ASCII\ Font:" \
"$font_file")"
2017-03-08 17:13:31 -07:00
2017-08-01 19:33:29 -06:00
if [[ "$diff_font" == "true" ]]; then
non_ascii="$(PlistBuddy -c "Print :New\ Bookmarks:${i}:Non\ Ascii\ Font:" \
"$font_file")"
2017-03-08 17:17:31 -07:00
2017-08-01 19:33:29 -06:00
[[ "$term_font" != "$non_ascii" ]] && \
term_font="$term_font (normal) / $non_ascii (non-ascii)"
2017-03-01 17:45:46 -07:00
fi
fi
done
;;
"deepin-terminal"*)
2017-08-01 19:33:29 -06:00
term_font="$(awk -F '=' '/font=/ {a=$2} /font_size/ {b=$2} END{print a " " b}' \
"${XDG_CONFIG_HOME}/deepin/deepin-terminal/config.conf")"
;;
"GNUstep_Terminal")
term_font="$(awk -F '>|<' '/>TerminalFont</ {getline; f=$3}
/>TerminalFontSize</ {getline; s=$3} END{print f " " s}' \
"${HOME}/GNUstep/Defaults/Terminal.plist")"
;;
2016-11-04 16:52:11 -06:00
"Hyper"*)
2017-07-15 09:32:42 -06:00
term_font="$(awk -F':|,' '/fontFamily/ {print $2; exit}' "${HOME}/.hyper.js")"
term_font="$(trim_quotes "$term_font")"
;;
2016-12-23 12:45:08 -07:00
2018-02-26 06:56:07 -07:00
"kitty"*)
if [[ -f "${KITTY_CONFIG_DIRECTORY}/kitty/kitty.conf" ]]; then
kitty_file="${KITTY_CONFIG_DIRECTORY}/kitty/kitty.conf"
2018-03-07 17:11:42 -07:00
2018-02-26 06:56:07 -07:00
elif [[ -f "${XDG_CONFIG_HOME}/kitty/kitty.conf" ]]; then
kitty_file="${XDG_CONFIG_HOME}/kitty/kitty.conf"
2018-03-07 17:11:42 -07:00
2018-02-26 06:56:07 -07:00
elif [[ -f "${HOME}/.config/kitty/kitty.conf" ]]; then
kitty_file="${HOME}/.config/kitty/kitty.conf"
2018-03-07 17:11:42 -07:00
2018-02-26 06:56:07 -07:00
elif [[ -f "${HOME}/Library/Preferences/kitty/kitty.conf" ]]; then
kitty_file="${HOME}/Library/Preferences/kitty/kitty.conf"
2018-03-07 17:11:42 -07:00
2018-02-26 06:56:07 -07:00
fi
term_font="$(awk '/font_family/ { $1 = ""; gsub(/^[[:space:]]/, ""); font = $0 } \
2018-03-27 14:28:45 -06:00
/\s?font_size\s/ { size = $2 } END { print font " " size}' \
2018-02-26 06:56:07 -07:00
"${kitty_file}")"
;;
2016-12-24 03:46:14 -07:00
"konsole"*)
# Get Process ID of current konsole window / tab
2016-12-24 03:46:14 -07:00
child="$(get_ppid "$$")"
2017-01-03 10:01:30 -07:00
konsole_instances=($(qdbus | grep 'org.kde.konsole'))
2016-12-24 03:46:14 -07:00
2017-01-03 10:01:30 -07:00
for i in "${konsole_instances[@]}"; do
konsole_sessions=($(qdbus "${i}" | grep '/Sessions/'))
for session in "${konsole_sessions[@]}"; do
if ((child == "$(qdbus "${i}" "${session}" processId)")); then
2017-08-01 19:33:29 -06:00
profile="$(qdbus "${i}" "${session}" environment |\
awk -F '=' '/KONSOLE_PROFILE_NAME/ {print $2}')"
2017-01-03 10:01:30 -07:00
break
fi
done
[[ "$profile" ]] && break
2016-12-24 03:46:14 -07:00
done
2017-01-03 10:01:30 -07:00
# We could have two profile files for the same profile name, take first match
profile_filename="$(grep -l "Name=${profile}" "${HOME}"/.local/share/konsole/*.profile)"
profile_filename="${profile_filename/$'\n'*}"
2017-08-01 19:33:29 -06:00
[[ "$profile_filename" ]] && \
term_font="$(awk -F '=|,' '/Font=/ {print $2 " " $3}' "$profile_filename")"
2016-12-24 03:46:14 -07:00
;;
2017-07-15 07:27:11 -06:00
"lxterminal"*)
2017-08-01 19:33:29 -06:00
term_font="$(awk -F '=' '/fontname=/ {print $2; exit}' \
"${XDG_CONFIG_HOME}/lxterminal/lxterminal.conf")"
2017-07-15 07:27:11 -06:00
;;
"mate-terminal")
2017-08-01 19:33:29 -06:00
# To get the actual config we have to create a temporarily file with the
# --save-config option.
mateterm_config="/tmp/mateterm.cfg"
# Ensure /tmp exists and we do not overwrite anything.
if [[ -d /tmp && ! -f "$mateterm_config" ]]; then
mate-terminal --save-config="$mateterm_config"
role="$(xprop -id "${WINDOWID}" WM_WINDOW_ROLE)"
role="${role##* }"
role="${role//\"}"
profile="$(awk -F '=' -v r="$role" \
2017-08-01 21:06:17 -06:00
'$0~r {getline; if(/Maximized/) getline; \
if(/Fullscreen/) getline; id=$2"]"} \
$0~id {if(id) {getline; print $2; exit}}' "$mateterm_config")"
rm -f "$mateterm_config"
2017-08-01 20:29:09 -06:00
mate_get() {
2017-08-17 01:59:32 -06:00
gsettings get org.mate.terminal.profile:/org/mate/terminal/profiles/"$1"/ "$2"
2017-08-01 20:29:09 -06:00
}
if [[ "$(mate_get "$profile" "use-system-font")" == "true" ]]; then
term_font="$(gsettings get org.mate.interface monospace-font-name)"
else
2017-08-01 20:29:09 -06:00
term_font="$(mate_get "$profile" "font")"
fi
term_font="$(trim_quotes "$term_font")"
fi
;;
"mintty")
term_font="$(awk -F '=' '!/^($|#)/ && /Font/ {printf $2; exit}' "${HOME}/.minttyrc")"
;;
"pantheon"*)
term_font="$(gsettings get org.pantheon.terminal.settings font)"
2017-08-01 19:33:29 -06:00
[[ -z "${term_font//\'}" ]] && \
term_font="$(gsettings get org.gnome.desktop.interface monospace-font-name)"
term_font="$(trim_quotes "$term_font")"
;;
2018-05-03 11:46:14 -06:00
"qterminal")
term_font="$(awk -F '=' '/fontFamily=/ {a=$2} /fontSize=/ {b=$2} END{print a " " b}' \
"${XDG_CONFIG_HOME}/qterminal.org/qterminal.ini")"
;;
"sakura"*)
2017-08-01 19:33:29 -06:00
term_font="$(awk -F '=' '/^font=/ {print $2; exit}' \
"${XDG_CONFIG_HOME}/sakura/sakura.conf")"
;;
"st")
2018-04-09 20:55:08 -06:00
term_font="$(ps -o command= -p "$parent" | grep -F -- "-f")"
2018-04-13 16:40:28 -06:00
2018-04-09 20:55:08 -06:00
if [[ "$term_font" ]]; then
term_font="${term_font/*-f/}"
term_font="${term_font/ -*/}"
2018-04-13 16:40:28 -06:00
else
# On Linux we can get the exact path to the running binary through the procfs
2018-04-09 20:55:08 -06:00
# (in case `st` is launched from outside of $PATH) on other systems we just
# have to guess and assume `st` is invoked from somewhere in the users $PATH
[[ -L /proc/$parent/exe ]] && binary="/proc/$parent/exe" || binary="$(type -p st)"
# Grep the output of strings on the `st` binary for anything that looks vaguely
# like a font definition. NOTE: There is a slight limitation in this approach.
# Technically "Font Name" is a valid font. As it doesn't specify any font options
# though it is hard to match it correctly amongst the rest of the noise.
[[ -n "$binary" ]] && \
2018-04-13 16:40:28 -06:00
term_font="$(strings "$binary" | grep -F -m 1 \
-e "pixelsize=" \
-e "size=" \
-e "antialias=" \
-e "autohint=")"
fi
term_font="${term_font/xft:}"
term_font="${term_font/:*}"
;;
"terminology")
2017-08-01 19:33:29 -06:00
term_font="$(strings "${XDG_CONFIG_HOME}/terminology/config/standard/base.cfg" |\
awk '/^font\.name$/{print a}{a=$0}')"
term_font="${term_font/.pcf}"
term_font="${term_font/:*}"
;;
"termite")
2017-08-01 19:33:29 -06:00
[[ -f "${XDG_CONFIG_HOME}/termite/config" ]] && \
termite_config="${XDG_CONFIG_HOME}/termite/config"
2017-08-01 21:06:17 -06:00
term_font="$(awk -F '= ' '/\[options\]/ {opt=1} /^\s*font/ {if(opt==1) a=$2; opt=0} \
2017-08-01 19:33:29 -06:00
END{print a}' "/etc/xdg/termite/config" "$termite_config")"
;;
"urxvt" | "urxvtd" | "rxvt-unicode" | "xterm")
2018-04-01 18:07:43 -06:00
xrdb="$(xrdb -query)"
term_font="$(grep -i "${term/d}\**\.*font" <<< "$xrdb")"
term_font="${term_font/*"*font:"}"
2017-08-28 17:11:53 -06:00
term_font="${term_font/*".font:"}"
2017-08-27 21:56:39 -06:00
term_font="${term_font/*"*.font:"}"
term_font="$(trim "$term_font")"
2018-04-01 18:07:43 -06:00
if [[ -z "$term_font" && "$term" == "xterm" ]]; then
term_font="$(grep -E '^XTerm.vt100.faceName' <<< "$xrdb")"
term_font="${term_font/*"faceName:"}"
fi
# xft: isn't required at the beginning so we prepend it if it's missing
if [[ "${term_font:0:1}" != "-" && \
"${term_font:0:4}" != "xft:" ]]; then
term_font="xft:$term_font"
fi
# Xresources has two different font formats, this checks which
# one is in use and formats it accordingly.
case "$term_font" in
*"xft:"*)
term_font="${term_font/xft:}"
term_font="${term_font/:*}"
;;
"-"*) term_font="$(awk -F '\\-' '{printf $3}' <<< "$term_font")" ;;
esac
;;
"xfce4-terminal")
2017-08-01 19:33:29 -06:00
term_font="$(awk -F '=' '/^FontName/ {a=$2} /^FontUseSystem=TRUE/ {a=$0} END{print a}' \
"${XDG_CONFIG_HOME}/xfce4/terminal/terminalrc")"
if [[ "$term_font" == "FontUseSystem=TRUE" ]]; then
term_font="$(gsettings get org.gnome.desktop.interface monospace-font-name)"
term_font="$(trim_quotes "$term_font")"
fi
2017-07-15 12:29:19 -06:00
# Default fallback font hardcoded in terminal-preferences.c
[[ -z "$term_font" ]] && term_font="Monospace 12"
;;
2016-05-16 05:35:29 -06:00
esac
}
get_disk() {
2017-08-01 21:07:42 -06:00
type -p df >/dev/null 2>&1 ||\
2017-01-08 05:05:13 -07:00
{ err "Disk requires 'df' to function. Install 'df' to get disk info."; return; }
2016-12-18 18:07:20 -07:00
# Get "df" version.
df_version="$(df --version 2>&1)"
case "$df_version" in
*"Tracker"*) # Haiku
2017-08-01 19:33:29 -06:00
err "Your version of df cannot be used due to the non-standard flags"
return
;;
*"IMitv"*) df_flags=(-P -g) ;; # AIX
2017-05-16 01:47:35 -06:00
*"befhikm"*) df_flags=(-P -k) ;; # IRIX
*) df_flags=(-P -h) ;;
2016-12-18 18:07:20 -07:00
esac
2017-01-06 00:53:26 -07:00
# Create an array called 'disks' where each element is a separate line from
# df's output. We then unset the first element which removes the column titles.
2018-04-13 17:32:12 -06:00
IFS=$'\n' read -d "" -ra disks <<< "$(df "${df_flags[@]}" "${disk_show[@]:-/}")"
unset "disks[0]"
2016-01-26 03:25:28 -07:00
2017-01-06 00:53:26 -07:00
# Stop here if 'df' fails to print disk info.
2017-08-01 19:33:29 -06:00
if [[ -z "${disks[*]}" ]]; then
err "Disk: df failed to print the disks, make sure the disk_show array is set properly."
return
fi
2016-03-12 13:58:46 -07:00
2017-01-06 00:53:26 -07:00
for disk in "${disks[@]}"; do
2017-01-06 01:03:14 -07:00
# Create a second array and make each element split at whitespace this time.
2018-04-13 17:32:12 -06:00
IFS=" " read -ra disk_info <<< "$disk"
2017-01-06 00:53:26 -07:00
disk_perc="${disk_info[4]/'%'}"
case "$df_version" in
2017-08-01 19:33:29 -06:00
*"befhikm"*)
disk="$((disk_info[2]/1024/1024))G / $((disk_info[1]/1024/1024))G (${disk_perc}%)"
;;
2017-05-23 22:42:38 -06:00
*) disk="${disk_info[2]/i} / ${disk_info[1]/i} (${disk_perc}%)" ;;
esac
2017-01-06 00:53:26 -07:00
2017-01-08 05:05:13 -07:00
# Subtitle.
2017-01-07 20:23:55 -07:00
case "$disk_subtitle" in
"name") disk_sub="${disk_info[0]}" ;;
"dir")
disk_sub="${disk_info[5]/*\/}"
[[ -z "$disk_sub" ]] && disk_sub="${disk_info[5]}"
;;
2017-01-07 20:23:55 -07:00
*) disk_sub="${disk_info[5]}" ;;
esac
2017-01-06 00:53:26 -07:00
# Bar.
case "$disk_display" in
"bar") disk="$(bar "$disk_perc" "100")" ;;
"infobar") disk+=" $(bar "$disk_perc" "100")" ;;
"barinfo") disk="$(bar "$disk_perc" "100")${info_color} $disk" ;;
2017-01-06 00:53:26 -07:00
"perc") disk="${disk_perc}% $(bar "$disk_perc" "100")" ;;
esac
# Append '(disk mount point)' to the subtitle.
if [[ -z "$subtitle" ]]; then
prin "${disk_sub}" "$disk"
else
2017-01-26 20:51:18 -07:00
prin "${subtitle} (${disk_sub})" "$disk"
fi
2017-01-06 00:53:26 -07:00
done
2016-01-26 03:25:28 -07:00
}
get_battery() {
case "$os" in
"Linux")
# We use 'prin' here so that we can do multi battery support
# with a single battery per line.
for bat in "/sys/class/power_supply/"{BAT,axp288_fuel_gauge,CMB}*; do
2016-11-06 05:00:09 -07:00
capacity="$(< "${bat}/capacity")"
status="$(< "${bat}/status")"
if [[ "$capacity" ]]; then
battery="${capacity}% [${status}]"
2016-11-06 05:00:09 -07:00
case "$battery_display" in
"bar") battery="$(bar "$capacity" 100)" ;;
"infobar") battery+=" $(bar "$capacity" 100)" ;;
"barinfo") battery="$(bar "$capacity" 100)${info_color} ${battery}" ;;
esac
2016-11-06 05:00:09 -07:00
bat="${bat/*axp288_fuel_gauge}"
prin "${subtitle:+${subtitle}${bat: -1}}" "$battery"
fi
2016-11-06 05:00:09 -07:00
done
2016-10-26 00:56:50 -06:00
return
;;
2016-02-23 01:21:30 -07:00
2016-02-23 02:24:38 -07:00
"BSD")
case "$kernel_name" in
"FreeBSD"* | "DragonFly"*)
2016-06-11 23:51:48 -06:00
battery="$(acpiconf -i 0 | awk -F ':\t' '/Remaining capacity/ {print $2}')"
battery_state="$(acpiconf -i 0 | awk -F ':\t\t\t' '/State/ {print $2}')"
2016-02-23 01:21:30 -07:00
;;
2016-02-27 02:25:39 -07:00
"NetBSD"*)
2016-06-11 23:51:48 -06:00
battery="$(envstat | awk '\\(|\\)' '/charge:/ {print $2}')"
battery="${battery/\.*/%}"
2016-02-27 02:25:39 -07:00
;;
2016-02-23 02:21:16 -07:00
2016-10-15 20:48:25 -06:00
"OpenBSD"* | "Bitrig"*)
battery0full="$(sysctl -n hw.sensors.acpibat0.watthour0)"
battery0full="${battery0full/ Wh*}"
2016-02-23 02:21:16 -07:00
battery0now="$(sysctl -n hw.sensors.acpibat0.watthour3)"
battery0now="${battery0now/ Wh*}"
2016-02-23 02:24:38 -07:00
[[ "$battery0full" ]] && \
battery="$((100 * ${battery0now/\.} / ${battery0full/\.}))%"
2016-10-01 20:12:48 -06:00
;;
esac
2016-10-01 20:12:48 -06:00
;;
"Mac OS X")
battery="$(pmset -g batt | grep -o '[0-9]*%')"
2016-12-12 14:40:03 -07:00
state="$(pmset -g batt | awk '/;/ {print $4}')"
2016-12-12 15:57:49 -07:00
[[ "$state" == "charging;" ]] && battery_state="charging"
;;
"Windows")
2017-01-06 23:02:14 -07:00
battery="$(wmic Path Win32_Battery get EstimatedChargeRemaining)"
battery="${battery/EstimatedChargeRemaining}"
2018-01-29 17:16:08 -07:00
batttery="$(trim "$battery")%"
;;
2016-11-04 15:46:29 -06:00
"Haiku")
2016-11-04 15:55:06 -06:00
battery0full="$(awk -F '[^0-9]*' 'NR==2 {print $4}' /dev/power/acpi_battery/0)"
battery0now="$(awk -F '[^0-9]*' 'NR==5 {print $4}' /dev/power/acpi_battery/0)"
2016-11-06 05:00:09 -07:00
battery="$((battery0full * 100 / battery0now))%"
2016-11-04 15:46:29 -06:00
;;
esac
2016-03-02 17:09:40 -07:00
[[ "$battery_state" ]] && battery+=" Charging"
2016-03-25 07:18:16 -06:00
2016-03-12 13:58:46 -07:00
case "$battery_display" in
2016-06-11 22:35:29 -06:00
"bar") battery="$(bar "${battery/'%'*}" 100)" ;;
2016-03-25 08:26:42 -06:00
"infobar") battery="${battery} $(bar "${battery/'%'*}" 100)" ;;
"barinfo") battery="$(bar "${battery/'%'*}" 100)${info_color} ${battery}" ;;
2016-03-12 06:05:48 -07:00
esac
}
get_local_ip() {
case "$os" in
2017-05-08 09:12:03 -06:00
"Linux" | "BSD" | "Solaris" | "AIX" | "IRIX")
local_ip="$(ip route get 1 | awk -F'src' '{print $2; exit}')"
local_ip="${local_ip/uid*}"
2017-01-03 20:53:43 -07:00
[[ -z "$local_ip" ]] && local_ip="$(ifconfig -a | awk '/broadcast/ {print $2; exit}')"
;;
2016-12-18 17:58:49 -07:00
"MINIX")
local_ip="$(ifconfig | awk '{printf $3; exit}')"
;;
2016-05-07 05:20:03 -06:00
"Mac OS X" | "iPhone OS")
local_ip="$(ipconfig getifaddr en0)"
[[ -z "$local_ip" ]] && local_ip="$(ipconfig getifaddr en1)"
2016-02-08 16:48:37 -07:00
;;
"Windows")
local_ip="$(ipconfig | awk -F ': ' '/IPv4 Address/ {printf $2 ", "}')"
local_ip="${local_ip%\,*}"
;;
2016-11-04 18:46:08 -06:00
"Haiku")
local_ip="$(ifconfig | awk -F ': ' '/Bcast/ {print $2}')"
local_ip="${local_ip/', Bcast'}"
2016-11-04 18:46:08 -06:00
;;
esac
}
get_public_ip() {
if type -p dig >/dev/null; then
public_ip="$(dig +time=1 +tries=1 +short myip.opendns.com @resolver1.opendns.com)"
[[ "$public_ip" =~ ^\; ]] && unset public_ip
fi
if [[ -z "$public_ip" ]] && type -p curl >/dev/null; then
public_ip="$(curl --max-time 10 -w '\n' "$public_ip_host")"
fi
if [[ -z "$public_ip" ]] && type -p wget >/dev/null; then
public_ip="$(wget -T 10 -qO- "$public_ip_host")"
fi
}
get_users() {
users="$(who | awk '!seen[$1]++ {printf $1 ", "}')"
2016-06-11 23:51:48 -06:00
users="${users%\,*}"
}
get_install_date() {
2016-01-30 04:10:28 -07:00
case "$os" in
2017-01-01 00:20:24 -07:00
"Linux" | "iPhone OS") install_file="/lost+found" ;;
"Mac OS X") install_file="/var/log/install.log" ;;
"Solaris") install_file="/var/sadm/system/logs/install_log" ;;
2017-01-06 23:02:14 -07:00
"Windows")
case "$kernel_name" in
"CYGWIN"*) install_file="/cygdrive/c/Windows/explorer.exe" ;;
2017-04-05 02:08:09 -06:00
"MSYS"* | "MINGW"*) install_file="/c/Windows/explorer.exe" ;;
2017-01-06 23:02:14 -07:00
esac
;;
2017-01-01 00:20:24 -07:00
"Haiku") install_file="/boot" ;;
"BSD" | "MINIX" | "IRIX")
case "$kernel_name" in
2017-01-01 00:20:24 -07:00
"FreeBSD") install_file="/etc/hostid" ;;
"NetBSD" | "DragonFly"*) install_file="/etc/defaults/rc.conf" ;;
*) install_file="/" ;;
2016-01-30 16:38:20 -07:00
esac
2016-08-02 04:52:01 -06:00
;;
2017-01-09 06:46:26 -07:00
"AIX") install_file="/var/adm/ras/bosinstlog" ;;
2017-01-01 00:20:24 -07:00
esac
2016-11-04 18:46:08 -06:00
2017-01-01 00:20:24 -07:00
ls_prog="$(ls --version 2>&1)"
case "$ls_prog" in
2017-08-01 19:33:29 -06:00
*"BusyBox"*)
install_date="$(ls -tdce "$install_file" | awk '{printf $10 " " $7 " " $8 " " $9}')"
;;
*"crtime"*) # xpg4 (Solaris)
install_date="$(ls -tdcE "$install_file" | awk '{printf $6 " " $7}')"
;;
*"ACFHLRSZ"*) # Toybox
install_date="$(ls -dl "$install_file" | awk '{printf $6 " " $7}')"
;;
*"GNU coreutils"*)
install_date="$(ls -tcd --full-time "$install_file" | awk '{printf $6 " " $7}')"
;;
*"ACFHLNRS"* | *"RadC1xmnlog"*) # AIX ls / IRIX ls
err "Install Date doesn't work because your 'ls' doesn't support full date/time."
return
;;
*"HLOPRSTUWabc"*) # macOS ls
install_date="$(ls -dlctUT "$install_file" | awk '{printf $9 " " $6 " "$7 " " $8}')"
;;
2017-10-12 21:24:56 -06:00
*)
install_date="$(ls -dlctT "$install_file" | awk '{printf $9 " " $6 " " $7 " " $8}')"
2017-10-12 21:24:56 -06:00
;;
2016-01-30 04:10:28 -07:00
esac
2016-01-30 04:41:58 -07:00
install_date="${install_date//-/ }"
install_date="${install_date%:*}"
2018-04-13 17:49:12 -06:00
IFS=" " read -ra install_date <<< "$install_date"
install_date="$(convert_time "${install_date[@]}")"
2016-01-30 04:10:28 -07:00
}
2017-03-26 15:51:56 -06:00
get_locale() {
locale="$sys_locale"
}
2017-08-28 17:22:56 -06:00
get_gpu_driver() {
case "$os" in
"Linux")
2017-08-28 17:34:40 -06:00
gpu_driver="$(lspci -nnk | awk -F ': ' \
'/Display|3D|VGA/{nr[NR+2]}; NR in nr {printf $2 ", "}')"
gpu_driver="${gpu_driver%, }"
if [[ "$gpu_driver" == *"nvidia"* ]]; then
gpu_driver="$(< /proc/driver/nvidia/version)"
gpu_driver="${gpu_driver/*Module }"
gpu_driver="NVIDIA ${gpu_driver/ *}"
fi
2017-08-28 17:22:56 -06:00
;;
2017-10-17 06:13:36 -06:00
"Mac OS X")
if [[ "$(kextstat | grep "GeForceWeb")" != "" ]]; then
gpu_driver="NVIDIA Web Driver"
2017-10-17 06:13:36 -06:00
else
gpu_driver="macOS Default Graphics Driver"
fi
;;
2017-08-28 17:22:56 -06:00
esac
}
get_cols() {
if [[ "$color_blocks" == "on" ]]; then
# Convert the width to space chars.
2016-12-15 19:20:10 -07:00
printf -v block_width "%${block_width}s"
# Set variables.
start="${block_range[0]}"
end="${block_range[1]}"
# Generate the string.
for ((start; start<=end; start++)); do
case "$start" in
[0-6]) blocks+="${reset}\e[3${start}m\e[4${start}m${block_width}" ;;
7) blocks+="${reset}\e[3${start}m\e[4${start}m${block_width}" ;;
*) blocks2+="\e[38;5;${start}m\e[48;5;${start}m${block_width}" ;;
esac
done
# Convert height into spaces.
printf -v block_spaces "%${block_height}s"
# Convert the spaces into rows of blocks.
[[ "$blocks" ]] && cols+="${block_spaces// /${blocks}${reset}nl}"
[[ "$blocks2" ]] && cols+="${block_spaces// /${blocks2}${reset}nl}"
# Add newlines to the string.
2016-06-11 23:51:48 -06:00
cols="${cols%%'nl'}"
cols="${cols//nl/\\n\\e[${text_padding}C${zws}}"
2016-12-18 21:25:48 -07:00
# Add block height to info height.
info_height="$((info_height+=block_height+2))"
printf "%b\n" "\e[${text_padding}C${zws}${cols}"
fi
2016-12-18 21:25:48 -07:00
unset -v blocks blocks2 cols
2018-01-08 17:25:24 -07:00
# TosWin2 on FreeMiNT is terrible at this,
# so we'll reset colors arbitrarily.
[[ "$term" == "TosWin2" ]] && \
printf "%b\n" "\e[30;47m"
2018-01-08 17:25:24 -07:00
# Tell info() that we printed manually.
prin=1
}
2015-12-30 03:18:17 -07:00
2016-11-10 17:15:05 -07:00
# IMAGES
2017-01-14 02:59:12 -07:00
image_backend() {
2017-01-26 04:46:39 -07:00
if [[ ! "$image_backend" =~ ^(off|ascii)$ ]]; then
if ! type -p convert >/dev/null 2>&1; then
image_backend="ascii"
err "Image: Imagemagick not found, falling back to ascii mode."
fi
fi
2017-01-14 02:59:12 -07:00
case "${image_backend:-off}" in
"ascii") get_ascii ;;
"off") image_backend="off" ;;
2017-12-15 21:51:07 -07:00
"caca" | "catimg" | "jp2a" | "iterm2" | "termpix" |\
"tycat" | "w3m" | "sixel" | "pixterm" | "kitty")
2017-01-14 02:59:12 -07:00
get_image_source
2016-11-12 21:33:28 -07:00
if [[ ! -f "$image" ]]; then
2017-01-14 04:53:36 -07:00
to_ascii "Image: '$image_source' doesn't exist, falling back to ascii mode."
2016-11-12 21:12:22 -07:00
return
2016-01-20 03:35:32 -07:00
fi
2016-01-05 00:19:38 -07:00
get_term_size
2016-01-17 14:37:37 -07:00
2017-01-14 02:59:12 -07:00
if [[ "$term_width" ]] && ((term_width >= 1)); then
printf "\e[2J\e[H"
2017-01-14 02:59:12 -07:00
else
to_ascii "Image: Failed to find terminal window size."
err "Image: Check the 'Images in the terminal' wiki page for more info,"
return
2016-11-12 06:30:09 -07:00
fi
2016-01-05 00:19:38 -07:00
2016-11-12 21:12:22 -07:00
get_image_size
2016-11-12 06:30:09 -07:00
make_thumbnail
[[ "$image_backend" == *"w3m"* ]] && zws="\xE2\x80\x8B\x20"
display_image
2016-01-05 00:19:38 -07:00
;;
2016-04-23 22:14:35 -06:00
2017-01-14 02:59:12 -07:00
*)
err "Image: Unknown image backend specified '$image_backend'."
err "Image: Valid backends are: 'ascii', 'caca', 'catimg', 'jp2a', 'iterm2', 'kitty',
2017-12-15 21:51:07 -07:00
'off', 'sixel', 'pixterm', 'termpix', 'tycat', 'w3m')"
err "Image: Falling back to ascii mode."
get_ascii
2017-01-14 02:59:12 -07:00
;;
2016-01-05 00:19:38 -07:00
esac
2016-12-11 23:41:35 -07:00
2017-01-14 02:59:12 -07:00
# Set cursor position next image/ascii.
2018-04-27 06:16:07 -06:00
[[ "$image_backend" != "off" ]] && printf "%b" "\e[${lines:-0}A\e[9999999D"
2016-01-05 00:19:38 -07:00
}
get_ascii() {
if [[ ! -f "$image_source" ||
2017-01-26 04:36:08 -07:00
"$image_source" =~ ^(auto|ascii)$ ||
"$image_source" =~ \.(png|jpg|jpe|jpeg|gif)$ ]]; then
# Fallback to distro ascii mode if custom ascii isn't found.
2017-01-26 04:46:39 -07:00
[[ ! "$image_source" =~ ^(auto|ascii)$ ]] && \
2016-11-13 01:25:29 -07:00
err "Ascii: Ascii file not found, using distro ascii."
2016-04-23 22:14:35 -06:00
# Fallback to distro ascii mode if source is an image.
2017-01-26 04:36:08 -07:00
[[ "$image_source" =~ \.(png|jpg|jpe|jpeg|gif)$ ]] && \
err "Image: Source is image file but ascii backend was selected. Using distro ascii."
if [[ -d "ASCIIDIR" ]]; then
ascii_dir="ASCIIDIR"
else
[[ -z "$script_dir" ]] && script_dir="$(get_full_path "$0")"
ascii_dir="${script_dir%/*}/ascii/distro"
fi
2017-01-14 03:09:04 -07:00
image_source="${ascii_dir}/${ascii_file}"
# Fallback to no ascii mode if distro ascii isn't found.
2017-01-14 03:09:04 -07:00
[[ ! -f "$image_source" ]] && \
{ to_off "Ascii: Failed to find distro ascii, falling back to no ascii mode."; return; }
fi
2016-12-20 03:17:40 -07:00
# Set locale to get correct padding.
export LC_ALL="$sys_locale"
2016-02-09 16:20:51 -07:00
2016-12-20 03:17:40 -07:00
# Turn file into variable.
while IFS=$'\n' read -r line; do
2016-11-09 01:34:43 -07:00
print+="$line \n"
2016-11-06 23:54:38 -07:00
# Calculate size of ascii file in line length / line count.
line="${line//[??;?;??m}"
line="${line//[??;?;???m}"
line="${line//}"
2016-11-06 23:54:38 -07:00
line="${line//\$\{??\}}"
2016-11-11 19:19:01 -07:00
line="${line//\\\\/\\}"
2017-01-04 06:36:04 -07:00
((${#line} > ascii_length)) && ascii_length="${#line}"
((++lines))
2017-01-14 03:09:04 -07:00
done < "$image_source"
2016-11-06 23:54:38 -07:00
2016-12-20 03:17:40 -07:00
# Colors.
2016-11-06 23:54:38 -07:00
print="${print//'${c1}'/$c1}"
print="${print//'${c2}'/$c2}"
print="${print//'${c3}'/$c3}"
print="${print//'${c4}'/$c4}"
print="${print//'${c5}'/$c5}"
print="${print//'${c6}'/$c6}"
2016-10-21 02:01:25 -06:00
# Overwrite padding if ascii_length_force is set.
[[ "$ascii_length_force" ]] && ascii_length="$ascii_length_force"
2016-10-21 02:01:25 -06:00
2016-11-12 21:12:22 -07:00
text_padding="$((ascii_length + gap))"
2016-11-06 05:00:09 -07:00
printf "%b" "$print"
2016-02-09 16:20:51 -07:00
export LC_ALL=C
2016-01-27 04:33:22 -07:00
}
2017-01-14 02:59:12 -07:00
get_image_source() {
case "$image_source" in
2017-01-26 00:37:13 -07:00
"auto" | "wall" | "wallpaper")
get_wallpaper
2017-01-14 02:59:12 -07:00
;;
2016-11-12 06:30:09 -07:00
2017-01-14 02:59:12 -07:00
*)
# Get the absolute path.
image_source="$(get_full_path "$image_source")"
2017-01-14 02:59:12 -07:00
if [[ -d "$image_source" ]]; then
shopt -s nullglob
files=("${image_source%/}"/*.{png,jpg,jpeg,jpe,gif,svg})
shopt -u nullglob
image="${files[RANDOM % ${#files[@]}]}"
2016-11-12 06:30:09 -07:00
2017-01-14 02:59:12 -07:00
else
image="$image_source"
fi
;;
esac
2016-11-12 06:30:09 -07:00
2017-01-26 00:41:03 -07:00
err "Image: Using image '$image'"
2016-11-12 06:30:09 -07:00
}
get_wallpaper() {
case "$os" in
"Mac OS X")
image="$(osascript <<END
tell application "System Events" to picture of current desktop
END
)"
;;
"Windows")
case "$distro" in
"Windows XP")
case "$kernel_name" in
"CYGWIN"*) image="/cygdrive/c/Documents and Settings/${USER}" ;;
"MSYS2"* | "MINGW*") image="/c/Documents and Settings/${USER}" ;;
esac
image+="/Local Settings/Application Data/Microsoft"
image+="/Wallpaper1.bmp"
;;
"Windows"*)
image="$APPDATA/Microsoft/Windows/Themes"
image+="/TranscodedWallpaper.jpg"
;;
esac
;;
*)
2016-12-04 19:37:32 -07:00
# Get DE if user has disabled the function.
2017-01-01 17:50:29 -07:00
((de_run != 1)) && get_de
2016-11-12 06:30:09 -07:00
2018-04-13 16:18:08 -06:00
if type -p wal >/dev/null && [[ -f "${HOME}/.cache/wal/wal" ]]; then
image="$(< "${HOME}/.cache/wal/wal")"
return
fi
2016-12-04 19:37:32 -07:00
case "$de" in
"MATE"*) image="$(gsettings get org.mate.background picture-filename)" ;;
2017-08-01 19:47:15 -06:00
"Xfce"*)
image="$(xfconf-query -c xfce4-desktop -p \
"/backdrop/screen0/monitor0/workspace0/last-image")"
;;
"Cinnamon"*)
image="$(gsettings get org.cinnamon.desktop.background picture-uri)"
image="$(decode_url "$image")"
;;
2016-12-04 19:37:32 -07:00
*)
2018-04-13 16:18:08 -06:00
if type -p feh >/dev/null && [[ -f "${HOME}/.fehbg" ]]; then
image="$(awk -F\' '/feh/ {printf $(NF-1)}' "${HOME}/.fehbg")"
2016-11-12 06:30:09 -07:00
2018-04-19 15:47:15 -06:00
elif type -p setroot >/dev/null && \
[[ -f "${XDG_CONFIG_HOME}/setroot/.setroot-restore" ]]; then
image="$(awk -F\' '/setroot/ {printf $(NF-1)}' \
"${XDG_CONFIG_HOME}/setroot/.setroot-restore")"
2016-12-04 19:37:32 -07:00
elif type -p nitrogen >/dev/null; then
2017-08-01 19:47:15 -06:00
image="$(awk -F'=' '/file/ {printf $2;exit;}' \
"${XDG_CONFIG_HOME}/nitrogen/bg-saved.cfg")"
2016-11-12 06:30:09 -07:00
2016-12-04 19:37:32 -07:00
else
2017-01-04 06:36:04 -07:00
image="$(gsettings get org.gnome.desktop.background picture-uri)"
image="$(decode_url "$image")"
2016-12-04 19:37:32 -07:00
fi
;;
esac
2016-11-12 06:30:09 -07:00
2016-12-20 03:17:40 -07:00
# Strip un-needed info from the path.
2016-12-04 19:37:32 -07:00
image="${image/'file://'}"
image="$(trim_quotes "$image")"
;;
esac
2016-11-13 01:25:29 -07:00
# If image is an xml file, don't use it.
2016-11-12 21:33:28 -07:00
[[ "${image/*\./}" == "xml" ]] && image=""
2016-11-12 06:30:09 -07:00
}
get_w3m_img_path() {
# Find w3m-img path.
2017-01-14 15:18:17 -07:00
if [[ -x "/usr/lib/w3m/w3mimgdisplay" ]]; then
w3m_img_path="/usr/lib/w3m/w3mimgdisplay"
2017-01-14 02:59:12 -07:00
elif [[ -x "/usr/libexec/w3m/w3mimgdisplay" ]]; then
w3m_img_path="/usr/libexec/w3m/w3mimgdisplay"
2017-01-14 02:59:12 -07:00
elif [[ -x "/usr/lib64/w3m/w3mimgdisplay" ]]; then
w3m_img_path="/usr/lib64/w3m/w3mimgdisplay"
2017-01-14 02:59:12 -07:00
elif [[ -x "/usr/libexec64/w3m/w3mimgdisplay" ]]; then
w3m_img_path="/usr/libexec64/w3m/w3mimgdisplay"
2017-05-23 21:07:01 -06:00
elif [[ -x "/usr/local/libexec/w3m/w3mimgdisplay" ]]; then
w3m_img_path="/usr/local/libexec/w3m/w3mimgdisplay"
2017-05-23 21:07:01 -06:00
2017-07-24 14:48:48 -06:00
elif [[ -x "$HOME/.nix-profile/libexec/w3m/w3mimgdisplay" ]]; then
w3m_img_path="$HOME/.nix-profile/libexec/w3m/w3mimgdisplay"
2017-01-14 15:18:17 -07:00
else
err "Image: w3m-img wasn't found on your system"
2017-01-14 02:59:12 -07:00
fi
}
2016-11-12 21:12:22 -07:00
get_term_size() {
# This functions gets the current window size in
# pixels.
#
2016-12-20 03:17:40 -07:00
# We first try to use the escape sequence "\044[14t"
2016-11-12 21:12:22 -07:00
# to get the terminal window size in pixels. If this
2016-12-20 03:17:40 -07:00
# fails we then fallback to using "xdotool" or other
2016-11-12 21:12:22 -07:00
# programs.
# Tmux has a special way of reading escape sequences
# so we have to use a slightly different sequence to
# get the terminal size.
if [[ -n "$TMUX" ]]; then
printf "%b" "\ePtmux;\e\e[14t\e\e[c\e\\"
2016-12-08 01:50:04 -07:00
read_flags=(-d c)
2016-06-10 01:58:24 -06:00
elif [[ "$image_backend" == "tycat" ]]; then
printf "%b" "\e}qs\000"
2016-06-10 01:58:24 -06:00
2016-02-20 17:32:02 -07:00
else
printf "%b" "\e[14t\e[c"
2016-12-08 01:50:04 -07:00
read_flags=(-d c)
fi
2016-02-17 20:19:41 -07:00
2016-11-12 21:12:22 -07:00
# The escape codes above print the desired output as
# user input so we have to use read to store the out
# -put as a variable.
2016-12-22 02:39:43 -07:00
IFS=";" read -s -t 1 "${read_flags[@]}" -r -a term_size
2016-01-20 03:46:20 -07:00
2016-11-12 21:12:22 -07:00
# Split the string into height/width.
if [[ "$image_backend" == "tycat" ]]; then
term_width="$((term_size[2] * term_size[0]))"
term_height="$((term_size[3] * term_size[1]))"
else
2016-12-22 02:39:43 -07:00
term_height="${term_size[1]}"
term_width="${term_size[2]/t*}"
fi
# Get terminal width/height if \e[14t is unsupported.
2017-06-29 21:59:19 -06:00
if [[ -z "$term_width" ]] || (( "$term_width" < 50 )); then
2016-11-12 21:12:22 -07:00
if type -p xdotool >/dev/null 2>&1; then
current_window="$(xdotool getactivewindow)"
2016-11-06 23:54:38 -07:00
source <(xdotool getwindowgeometry --shell "$current_window")
term_height="$HEIGHT"
term_width="$WIDTH"
2016-11-12 21:12:22 -07:00
elif type -p xwininfo >/dev/null 2>&1; then
# Get the focused window's ID.
if type -p xdpyinfo >/dev/null 2>&1; then
2016-12-05 17:46:34 -07:00
current_window="$(xdpyinfo | grep -E -o "focus:.*0x[0-9a-f]+")"
current_window="${current_window/*window }"
elif type -p xprop >/dev/null 2>&1; then
2017-07-14 07:29:53 -06:00
current_window="$(xprop -root _NET_ACTIVE_WINDOW)"
current_window="${current_window##* }"
fi
2016-11-12 21:12:22 -07:00
# If the ID was found get the window size.
if [[ "$current_window" ]]; then
2017-08-01 19:47:15 -06:00
term_size="$(xwininfo -id "$current_window" |\
awk -F ': ' '/Width|Height/ {printf $2 " "}')"
2016-11-12 21:12:22 -07:00
term_width="${term_size/ *}"
term_height="${term_size/${term_width}}"
else
2016-12-22 02:39:43 -07:00
term_width=0
2016-11-12 21:12:22 -07:00
fi
else
2016-12-22 02:39:43 -07:00
term_width=0
fi
2016-06-10 01:58:24 -06:00
fi
2016-11-12 21:12:22 -07:00
}
get_image_size() {
# This functions determines the size to make
# the thumbnail image.
2018-04-21 19:01:18 -06:00
read -r lines columns <<< "$(stty size)"
2016-01-31 17:05:46 -07:00
2016-12-20 03:17:40 -07:00
# Calculate font size.
2016-06-11 23:51:48 -06:00
font_width="$((term_width / columns))"
font_height="$((term_height / lines))"
2016-02-17 20:19:41 -07:00
2016-02-19 19:35:07 -07:00
case "$image_size" in
"auto")
2016-06-11 23:51:48 -06:00
image_size="$((columns * font_width / 2))"
term_height="$((term_height - term_height / 4))"
2017-01-04 06:36:04 -07:00
((term_height < image_size)) && \
image_size="$term_height"
2016-02-19 19:35:07 -07:00
;;
*"%")
2016-06-11 23:51:48 -06:00
percent="${image_size/\%}"
image_size="$((percent * term_width / 100))"
2016-02-19 19:35:07 -07:00
2017-01-04 06:36:04 -07:00
(((percent * term_height / 50) < image_size)) && \
2016-06-11 23:51:48 -06:00
image_size="$((percent * term_height / 100))"
2016-02-19 19:35:07 -07:00
;;
2016-04-11 23:50:19 -06:00
"none")
2016-12-20 03:17:40 -07:00
# Get image size so that we can do a better crop.
2018-04-21 19:01:18 -06:00
read -r width height <<< "$(identify -format "%w %h" "$image")"
crop_mode="none"
while (( "$width" >= ("$term_width" / 2) ||
"$height" >= "$term_height" )); do
width="$((width / 2))"
height="$((height / 2))"
done
;;
2016-06-11 23:51:48 -06:00
*) image_size="${image_size/px}" ;;
2016-02-19 19:35:07 -07:00
esac
2016-02-17 20:19:41 -07:00
2016-06-11 23:51:48 -06:00
width="${width:-$image_size}"
height="${height:-$image_size}"
2016-11-12 21:12:22 -07:00
text_padding="$((width / font_width + gap + xoffset/font_width))"
}
2016-11-12 21:12:22 -07:00
make_thumbnail() {
# Name the thumbnail using variables so we can
# use it later.
image_name="$crop_mode-$crop_offset-$width-$height-${image##*/}"
# Handle file extensions.
case "${image##*.}" in
"eps"|"pdf"|"svg"|"gif"|"png")
image_name+=".png" ;;
*) image_name+=".jpg" ;;
esac
# Create the thumbnail dir if it doesn't exist.
mkdir -p "$thumbnail_dir"
# Check to see if the thumbnail exists before we do any cropping.
2016-11-12 21:33:28 -07:00
if [[ ! -f "$thumbnail_dir/$image_name" ]]; then
2016-12-20 03:17:40 -07:00
# Get image size so that we can do a better crop.
if [[ -z "$size" ]]; then
2018-04-21 19:01:18 -06:00
read -r og_width og_height <<< "$(identify -format "%w %h" "$image")"
((og_height > og_width)) && size="$og_width" || size="$og_height"
2016-05-27 22:07:19 -06:00
fi
case "$crop_mode" in
2016-11-12 21:12:22 -07:00
"fit")
2016-11-12 21:33:28 -07:00
c="$(convert "$image" \
-colorspace srgb \
2016-06-11 23:51:48 -06:00
-format "%[pixel:p{0,0}]" info:)"
convert \
-background none \
2016-11-12 21:33:28 -07:00
"$image" \
-trim +repage \
-gravity south \
-background "$c" \
-extent "$size"x"$size" \
-scale "$width"x"$height" \
2016-11-12 21:33:28 -07:00
"$thumbnail_dir/$image_name"
;;
2016-11-12 21:12:22 -07:00
"fill")
convert \
-background none \
2016-11-12 21:33:28 -07:00
"$image" \
-trim +repage \
-scale "$width"x"$height"^ \
-extent "$width"x"$height" \
2016-11-12 21:33:28 -07:00
"$thumbnail_dir/$image_name"
;;
2016-11-12 21:33:28 -07:00
"none") cp "$image" "$thumbnail_dir/$image_name" ;;
*)
convert \
-background none \
2016-11-12 21:33:28 -07:00
"$image" \
2016-11-06 02:11:12 -07:00
-gravity "$crop_offset" \
-crop "$size"x"$size"+0+0 \
-quality 95 \
-scale "$width"x"$height" \
2016-11-12 21:33:28 -07:00
"$thumbnail_dir/$image_name"
;;
esac
fi
2016-12-20 03:17:40 -07:00
# The final image.
2016-11-12 21:33:28 -07:00
image="$thumbnail_dir/$image_name"
2015-12-30 03:18:17 -07:00
}
display_image() {
case "$image_backend" in
2017-01-14 06:15:33 -07:00
"caca")
2017-08-01 19:47:15 -06:00
img2txt -W "$((width / font_width)))" \
-H "$((height / font_height))" \
--gamma=0.6 "$image" ||\
to_off "Image: libcaca failed to display the image."
2017-01-14 06:15:33 -07:00
;;
2017-01-14 06:15:33 -07:00
"catimg")
catimg -w "$((width * 2 / font_width))" "$image" ||\
2017-08-01 19:47:15 -06:00
to_off "Image: catimg failed to display the image."
2017-01-14 06:15:33 -07:00
;;
"jp2a")
2017-08-01 19:47:15 -06:00
jp2a --width="$((width / font_width))" --colors "$image" ||\
to_off "Image: jp2a failed to display the image."
2017-02-08 16:23:21 -07:00
;;
"kitty")
kitty icat --align left --place "${width}x${height}@${xoffset}x${yoffset}" "$image" ||\
to_off "Image: kitty failed to display the image."
;;
2017-12-15 21:51:07 -07:00
"pixterm")
pixterm -tc "$((width / font_width))" \
-tr "$((height / font_height))" \
"$image" ||\
to_off "Image: pixterm failed to display the image."
;;
2017-02-08 16:23:21 -07:00
"sixel")
2017-12-15 21:51:07 -07:00
img2sixel -w "$width" "$image" ||\
to_off "Image: libsixel failed to display the image."
2016-11-12 06:30:09 -07:00
;;
2016-01-29 23:44:52 -07:00
2017-02-08 16:36:21 -07:00
"termpix")
2017-08-01 19:47:15 -06:00
termpix --width "$((width / font_width))" "$image" ||\
to_off "Image: termpix failed to display the image."
2017-02-08 16:36:21 -07:00
;;
2016-11-12 06:30:09 -07:00
"iterm2")
2017-08-01 19:47:15 -06:00
image="$(base64 < "$image")"
iterm_cmd="\e]1337;File=width=${width}px;height=${height}px;inline=1:${image}"
# Tmux requires an additional escape sequence for this to work.
[[ -n "$TMUX" ]] && iterm_cmd="\ePtmux;\e${iterm_cmd}\e\\"
printf "%b\a\n" "$iterm_cmd"
2016-11-12 06:30:09 -07:00
;;
2016-01-29 23:44:52 -07:00
2016-11-12 06:30:09 -07:00
"tycat")
2017-08-01 19:47:15 -06:00
tycat "$image" ||\
to_off "Image: tycat failed to display the image."
2016-11-12 06:30:09 -07:00
;;
2017-01-13 21:30:37 -07:00
2017-01-14 06:15:33 -07:00
"w3m")
get_w3m_img_path
2017-01-13 21:43:34 -07:00
2017-01-14 06:15:33 -07:00
# Add a tiny delay to fix issues with images not
# appearing in specific terminal emulators.
sleep 0.05
printf "%b\n" "0;1;$xoffset;$yoffset;$width;$height;;;;;$image\n4;\n3;" |\
2017-08-01 19:47:15 -06:00
"${w3m_img_path:-false}" -bg "$background_color" >/dev/null 2>&1 ||\
to_off "Image: w3m-img failed to display the image."
2016-11-12 06:30:09 -07:00
;;
esac
2016-01-29 23:44:52 -07:00
}
to_ascii() {
# Log the error.
err "$1"
# This function makes neofetch fallback to ascii mode.
image_backend="ascii"
2016-12-22 02:39:43 -07:00
# Print the ascii art.
get_ascii
2016-12-22 02:39:43 -07:00
2017-01-14 04:53:36 -07:00
# Set cursor position next image/ascii.
printf "%b" "\e[${lines:-0}A\e[9999999D"
}
2016-08-13 03:42:31 -06:00
to_off() {
# This function makes neofetch fallback to off mode.
err "$1"
image_backend="off"
text_padding=
2016-08-13 03:42:31 -06:00
}
2016-11-10 17:15:05 -07:00
# SCREENSHOT
2016-10-02 02:29:13 -06:00
take_scrot() {
scrot_program "${scrot_dir}${scrot_name}"
err "Scrot: Saved screenshot as: ${scrot_dir}${scrot_name}"
[[ "$scrot_upload" == "on" ]] && scrot_upload
2016-10-02 02:29:13 -06:00
}
scrot_upload() {
if ! type -p curl >/dev/null 2>&1; then
printf "%s\n" "[!] Install curl to upload images"
return
fi
2016-10-02 02:29:13 -06:00
image_file="${scrot_dir}${scrot_name}"
# Print a message letting the user know we're uploading
# the screenshot.
printf "%s\r" "Uploading scrot"
sleep .2
printf "%s\r" "Uploading scrot."
sleep .2
printf "%s\r" "Uploading scrot.."
sleep .2
printf "%s\r" "Uploading scrot..."
2016-10-02 02:29:13 -06:00
case "$image_host" in
"teknik")
2017-08-01 19:47:15 -06:00
image_url="$(curl -sf -F file="@${image_file};type=image/png" \
"https://api.teknik.io/v1/Upload")"
image_url="$(awk -F 'url:|,' '{printf $2}' <<< "${image_url//\"}")"
2016-10-02 02:29:13 -06:00
;;
"imgur")
2017-08-01 19:47:15 -06:00
image_url="$(curl -sH "Authorization: Client-ID 0e8b44d15e9fc95" \
-F image="@${image_file}" "https://api.imgur.com/3/upload")"
image_url="$(awk -F 'id:|,' '{printf $2}' <<< "${image_url//\"}")"
[[ "$image_url" ]] && image_url="https://i.imgur.com/${image_url}.png"
;;
2016-10-02 02:29:13 -06:00
esac
2016-10-25 22:38:45 -06:00
printf "%s\n" "${image_url:-'[!] Image failed to upload'}"
2016-10-02 02:29:13 -06:00
}
2016-11-10 17:15:05 -07:00
scrot_args() {
scrot="on"
2017-03-26 15:29:04 -06:00
if [[ "$2" =~ \.(png|jpg|jpe|jpeg|gif)$ ]]; then
scrot_name="${2##*/}"
scrot_dir="${2/$scrot_name}"
elif [[ -d "$2" ]]; then
scrot_dir="$2"
else
scrot_dir="${PWD:+${PWD}/}"
fi
2016-11-10 17:15:05 -07:00
}
2015-12-30 03:18:17 -07:00
2016-12-04 21:14:44 -07:00
scrot_program() {
# Detect screenshot program.
#
# We first check to see if an X server is running before
# falling back to OS specific screenshot tools.
2016-12-04 21:14:44 -07:00
if [[ -n "$DISPLAY" ]]; then
if [[ "$scrot_cmd" != "auto" ]] && type -p "${scrot_cmd%% *}" >/dev/null; then
2018-04-13 17:49:12 -06:00
IFS=" " read -ra scrot_program <<< "$scrot_cmd"
2016-12-04 21:14:44 -07:00
elif type -p maim >/dev/null; then
2016-12-11 23:59:54 -07:00
scrot_program=(maim)
2016-12-04 21:14:44 -07:00
elif type -p scrot >/dev/null; then
scrot_program=(scrot)
2017-06-13 21:23:44 -06:00
elif type -p import >/dev/null && [[ "$os" != "Mac OS X" ]]; then
2016-12-11 23:59:54 -07:00
scrot_program=(import -window root)
2016-12-04 21:14:44 -07:00
elif type -p imlib2_grab >/dev/null; then
2016-12-11 23:59:54 -07:00
scrot_program=(imlib2_grab)
2016-12-04 21:14:44 -07:00
elif type -p gnome-screenshot >/dev/null; then
2016-12-11 23:59:54 -07:00
scrot_program=(gnome-screenshot -f)
2016-12-04 21:14:44 -07:00
else
err "Scrot: No screen capture tool found."
return
fi
else
case "$os" in
2016-12-11 23:59:54 -07:00
"Mac OS X") scrot_program=(screencapture -S) ;;
"Haiku") scrot_program=(screenshot -s) ;;
esac
fi
2016-12-04 21:14:44 -07:00
# Print a message letting the user know we're taking
# a screenshot.
printf "%s\r" "Taking scrot"
sleep .2
printf "%s\r" "Taking scrot."
sleep .2
printf "%s\r" "Taking scrot.."
sleep .2
printf "%s\r" "Taking scrot..."
# Take the scrot.
2016-12-11 23:59:54 -07:00
"${scrot_program[@]}" "$1"
2016-12-04 21:14:44 -07:00
2016-12-11 23:59:54 -07:00
err "Scrot: Screen captured using ${scrot_program[0]}"
2016-12-04 21:14:44 -07:00
}
2016-11-10 17:15:05 -07:00
# TEXT FORMATTING
2016-08-12 04:53:04 -06:00
info() {
2016-12-21 19:03:15 -07:00
# Save subtitle value.
[[ "$2" ]] && subtitle="$1"
2016-12-21 19:03:15 -07:00
# Make sure that $prin is unset.
unset -v prin
2016-12-11 19:10:08 -07:00
# Call the function.
"get_${2:-$1}"
# If the get_func function called 'prin' directly, stop here.
2016-12-14 16:28:52 -07:00
[[ "$prin" ]] && return
2016-12-20 03:17:40 -07:00
# Update the variable.
output="$(trim "${!2:-${!1}}")"
2016-12-14 03:33:05 -07:00
if [[ "$2" && "${output// }" ]]; then
prin "$1" "$output"
2016-12-14 03:33:05 -07:00
elif [[ "${output// }" ]]; then
prin "$output"
2016-09-30 20:28:21 -06:00
2016-12-14 03:33:05 -07:00
else
err "Info: Couldn't detect ${1}."
fi
unset -v subtitle
}
2016-08-12 04:53:04 -06:00
prin() {
2016-12-20 03:17:40 -07:00
# If $2 doesn't exist we format $1 as info.
if [[ "$(trim "$1")" && "$2" ]]; then
2017-01-27 09:01:11 -07:00
string="${1}${2:+: $2}"
else
string="${2:-$1}"
local subtitle_color="$info_color"
fi
string="$(trim "${string//$'\e[0m'}")"
2017-01-27 09:01:11 -07:00
# Log length if it doesn't exist.
if [[ -z "$length" ]]; then
length="$(strip_sequences "$string")"
length="${#length}"
fi
2016-08-02 07:50:05 -06:00
2016-12-20 03:17:40 -07:00
# Format the output.
2016-08-13 18:55:01 -06:00
string="${string/:/${reset}${colon_color}:${info_color}}"
2016-08-02 07:44:10 -06:00
string="${subtitle_color}${bold}${string}"
2016-12-20 03:17:40 -07:00
# Print the info.
printf "%b\n" "${text_padding:+\e[${text_padding}C}${zws}${string}${reset} "
2016-09-30 20:28:21 -06:00
2016-12-20 03:17:40 -07:00
# Calculate info height.
((++info_height))
2016-10-04 04:29:06 -06:00
# Log that prin was used.
2016-11-05 23:25:53 -06:00
prin=1
}
get_underline() {
if [[ "$underline_enabled" == "on" ]]; then
2016-12-15 19:20:10 -07:00
printf -v underline "%${length}s"
printf "%b%b\n" "${text_padding:+\e[${text_padding}C}${zws}${underline_color}" \
"${underline// /$underline_char}${reset} "
unset -v length
2016-11-06 01:06:23 -06:00
fi
2017-01-27 09:01:11 -07:00
prin=1
}
2016-11-13 03:29:25 -07:00
get_line_break() {
2016-12-18 21:23:20 -07:00
# Print it directly.
2017-05-06 17:55:24 -06:00
printf "%b\n" "${zws}"
2016-11-13 03:29:25 -07:00
2016-12-20 03:17:40 -07:00
# Calculate info height.
((++info_height))
2017-05-06 17:55:24 -06:00
line_breaks+="\n"
# Tell info() that we printed manually.
prin=1
2016-11-13 03:29:25 -07:00
}
get_bold() {
2016-11-13 02:58:59 -07:00
case "$ascii_bold" in
"on") ascii_bold="\e[1m" ;;
2016-11-13 02:58:59 -07:00
"off") ascii_bold="" ;;
esac
case "$bold" in
"on") bold="\e[1m" ;;
2016-11-13 02:58:59 -07:00
"off") bold="" ;;
esac
}
trim() {
set -f
2018-03-31 22:30:06 -06:00
# shellcheck disable=2048,2086
set -- $*
printf "%s\\n" "${*//[[:space:]]/ }"
2016-11-13 02:58:59 -07:00
set +f
}
2016-11-15 18:20:14 -07:00
trim_quotes() {
trim_output="${1//\'}"
trim_output="${trim_output//\"}"
2016-11-15 18:20:14 -07:00
printf "%s" "$trim_output"
}
2017-01-27 09:01:11 -07:00
strip_sequences() {
strip="${1//$'\e['3[0-9]m}"
strip="${strip//$'\e['38\;5\;[0-9]m}"
strip="${strip//$'\e['38\;5\;[0-9][0-9]m}"
strip="${strip//$'\e['38\;5\;[0-9][0-9][0-9]m}"
2017-01-27 09:01:11 -07:00
printf "%s\n" "$strip"
}
2016-11-15 18:20:14 -07:00
uppercase() {
if ((bash_version >= 4)); then
printf "%s" "${1^}"
else
printf "%s" "$1"
fi
2016-11-15 18:20:14 -07:00
}
2016-11-13 02:58:59 -07:00
# COLORS
2016-11-13 02:21:32 -07:00
get_distro_colors() {
# This function sets the text colors according
# to your OS/Distro's logo colors.
#
2016-12-20 03:17:40 -07:00
# $ascii_distro is the same as $distro.
2016-02-22 22:52:25 -07:00
case "$ascii_distro" in
2017-01-09 03:07:21 -07:00
"AIX"*)
set_colors 2 7
ascii_file="aix"
;;
2017-01-06 04:50:05 -07:00
"alpine_small")
set_colors 4 7
ascii_file="alpine_small"
;;
2017-01-02 00:02:28 -07:00
"Alpine"*)
set_colors 4 5 7 6
ascii_file="alpine"
;;
2017-07-21 04:53:24 -06:00
"Amazon"*)
set_colors 3 7
ascii_file="amazon"
;;
2018-01-31 07:17:12 -07:00
"Anarchy"*)
2018-02-02 08:49:32 -07:00
set_colors 7 4
2018-01-31 07:17:12 -07:00
ascii_file="anarchy"
;;
2017-01-02 00:02:28 -07:00
"Android"*)
set_colors 2 7
ascii_file="android"
;;
2017-01-02 00:02:28 -07:00
"Antergos"*)
set_colors 4 6
ascii_file="antergos"
2017-01-01 22:40:30 -07:00
;;
2017-01-02 00:02:28 -07:00
"antiX"*)
set_colors 1 7 3
ascii_file="antix"
2017-01-01 22:40:30 -07:00
;;
2017-01-02 00:02:28 -07:00
"AOSC"*)
2017-01-01 22:40:30 -07:00
set_colors 4 7 1
2017-01-02 00:02:28 -07:00
ascii_file="aosc"
2017-01-01 22:40:30 -07:00
;;
2017-01-02 00:02:28 -07:00
"Apricity"*)
2017-01-01 22:40:30 -07:00
set_colors 4 7 1
2017-01-02 00:02:28 -07:00
ascii_file="apricity"
2017-01-01 22:40:30 -07:00
;;
2018-04-24 15:43:07 -06:00
"ArcoLinux"*)
set_colors 7 4
ascii_file="arcolinux"
;;
2017-01-02 00:02:28 -07:00
"arch_small")
2017-03-27 15:49:46 -06:00
set_colors 6 7 1
2017-01-02 00:02:28 -07:00
ascii_file="arch_small"
2017-01-01 22:40:30 -07:00
;;
2017-01-02 00:02:28 -07:00
"arch_old")
2017-03-27 15:49:46 -06:00
set_colors 6 7 1
2017-01-02 00:02:28 -07:00
ascii_file="arch_old"
2017-01-01 22:40:30 -07:00
;;
"ArchBox"*)
set_colors 2 7 1
ascii_file="archbox"
;;
2017-04-24 20:44:41 -06:00
"ARCHlabs"*)
2017-03-27 15:49:46 -06:00
set_colors 6 6 7 1
2017-04-24 20:44:41 -06:00
ascii_file="archlabs"
2017-01-01 22:40:30 -07:00
;;
2017-05-08 08:44:13 -06:00
*"XFerience"*)
set_colors 6 6 7 1
ascii_file="arch_xferience"
;;
"ArchMerge"*)
set_colors 6 6 7 1
ascii_file="archmerge"
;;
2017-04-24 20:44:41 -06:00
"Arch"*)
set_colors 6 6 7 1
2017-04-24 20:44:41 -06:00
ascii_file="arch"
;;
2017-08-03 20:39:35 -06:00
"Artix"*)
set_colors 6 4 2 7
2017-08-03 20:39:35 -06:00
ascii_file="artix"
;;
2017-07-26 02:34:46 -06:00
"Arya"*)
set_colors 2 1
ascii_file="arya"
;;
2017-01-02 00:02:28 -07:00
"Bitrig"*)
set_colors 2 7
ascii_file="bitrig"
2016-11-02 00:40:50 -06:00
;;
2017-01-02 00:02:28 -07:00
"BLAG"*)
set_colors 5 7
ascii_file="blag"
2017-01-01 22:40:30 -07:00
;;
2017-01-02 00:02:28 -07:00
"BlankOn"*)
set_colors 1 7 3
ascii_file="blankon"
2017-01-01 22:40:30 -07:00
;;
2017-01-02 00:26:45 -07:00
"BSD")
set_colors 1 7 4 3 6
ascii_file="bsd"
;;
2017-01-02 00:02:28 -07:00
"BunsenLabs"*)
set_colors fg 7
ascii_file="bunsenlabs"
2017-01-01 22:40:30 -07:00
;;
2018-01-31 07:17:12 -07:00
"Calculate"*)
2018-02-02 08:49:32 -07:00
set_colors 7 3
2018-01-31 07:17:12 -07:00
ascii_file="calculate"
;;
2017-01-02 00:02:28 -07:00
"CentOS"*)
set_colors 3 2 4 5 7
ascii_file="centos"
2017-01-01 22:40:30 -07:00
;;
2017-01-02 00:02:28 -07:00
"Chakra"*)
set_colors 4 5 7 6
ascii_file="chakra"
2017-01-01 22:40:30 -07:00
;;
2017-01-02 00:02:28 -07:00
"ChaletOS"*)
2017-01-01 22:40:30 -07:00
set_colors 4 7 1
2017-01-02 00:02:28 -07:00
ascii_file="chaletos"
2017-01-01 22:40:30 -07:00
;;
2017-01-02 00:02:28 -07:00
"Chapeau"*)
set_colors 2 7
ascii_file="chapeau"
2017-01-01 22:40:30 -07:00
;;
2017-01-02 00:02:28 -07:00
"Chrom"*)
set_colors 2 1 3 4 7
ascii_file="chrome"
2017-01-01 22:40:30 -07:00
;;
2017-06-15 22:44:21 -06:00
"Clover"*)
set_colors 2 6
ascii_file="cloveros"
;;
2017-09-21 00:07:27 -06:00
"Container Linux by CoreOS"*)
set_colors 4 7 1
ascii_file="coreos"
;;
2017-01-02 00:02:28 -07:00
"crux_small")
set_colors 4 5 7 6
ascii_file="crux_small"
2017-01-01 22:40:30 -07:00
;;
2017-01-02 00:02:28 -07:00
"CRUX"*)
set_colors 4 5 7 6
ascii_file="crux"
2017-01-01 22:40:30 -07:00
;;
2017-07-22 08:20:33 -06:00
"debian_small")
set_colors 1 7 3
ascii_file="debian_small"
;;
2017-01-02 00:02:28 -07:00
"Debian"*)
set_colors 1 7 3
ascii_file="debian"
2017-01-01 22:40:30 -07:00
;;
2017-01-02 00:02:28 -07:00
"Deepin"*)
set_colors 2 7
ascii_file="deepin"
2017-01-01 22:40:30 -07:00
;;
2017-04-03 16:47:26 -06:00
"DesaOS")
set_colors 2 7
ascii_file="desaos"
;;
2017-01-02 00:02:28 -07:00
"Devuan"*)
set_colors 5 7
ascii_file="devuan"
2017-01-01 22:40:30 -07:00
;;
2017-01-02 00:02:28 -07:00
"DracOS"*)
set_colors 1 7 3
ascii_file="dracos"
2017-01-01 22:40:30 -07:00
;;
"dragonfly_old"*)
set_colors 1 7 3
ascii_file="dragonflybsd_old"
;;
"dragonfly_small"*)
set_colors 1 7 3
ascii_file="dragonflybsd_small"
;;
2017-01-02 00:02:28 -07:00
"DragonFly"*)
set_colors 1 7 3
ascii_file="dragonflybsd"
2017-01-01 22:40:30 -07:00
;;
2017-01-02 00:02:28 -07:00
"Elementary"*)
2017-01-01 22:40:30 -07:00
set_colors 4 7 1
2017-01-02 00:02:28 -07:00
ascii_file="elementary"
2017-01-01 22:40:30 -07:00
;;
2017-07-23 08:52:52 -06:00
"Endless"*)
set_colors 1 7
ascii_file="endless"
;;
2017-01-02 00:02:28 -07:00
"Exherbo"*)
2017-01-01 22:40:30 -07:00
set_colors 4 7 1
2017-01-02 00:02:28 -07:00
ascii_file="exherbo"
2017-01-01 22:40:30 -07:00
;;
2017-01-02 00:02:28 -07:00
"Fedora"* | "RFRemix"*)
2017-01-01 22:40:30 -07:00
set_colors 4 7 1
2017-01-02 00:02:28 -07:00
ascii_file="fedora"
2016-12-04 15:24:27 -07:00
;;
2017-07-22 08:09:18 -06:00
"freebsd_small")
set_colors 1 7 3
ascii_file="freebsd_small"
;;
2017-01-02 00:02:28 -07:00
"FreeBSD"*)
set_colors 1 7 3
ascii_file="freebsd"
2016-02-22 22:52:25 -07:00
;;
2018-01-08 17:25:24 -07:00
"FreeMiNT"*)
# Don't explicitly set colors since
# TosWin2 doesn't reset well.
ascii_file="gem"
;;
2017-01-02 00:02:28 -07:00
"Frugalware"*)
set_colors 4 7 1
ascii_file="frugalware"
2016-12-02 05:16:47 -07:00
;;
2017-01-02 00:02:28 -07:00
"Funtoo"*)
set_colors 5 7
ascii_file="funtoo"
2017-01-01 22:40:30 -07:00
;;
2017-01-02 00:02:28 -07:00
"GalliumOS"*)
set_colors 4 7 1
ascii_file="galliumos"
;;
2017-01-02 00:02:28 -07:00
"gentoo_small")
set_colors 5 7
ascii_file="gentoo_small"
2017-01-01 22:40:30 -07:00
;;
2017-01-02 00:02:28 -07:00
"Gentoo"*)
set_colors 5 7
ascii_file="gentoo"
2016-12-22 07:08:14 -07:00
;;
2017-01-01 22:40:30 -07:00
"gNewSense"*)
2016-11-13 02:21:32 -07:00
set_colors 4 5 7 6
2017-01-01 22:40:30 -07:00
ascii_file="gnewsense"
;;
2017-01-02 00:26:45 -07:00
"GNU")
set_colors fg 7
ascii_file="gnu"
;;
2017-01-02 00:02:28 -07:00
"GoboLinux"*)
set_colors 5 4 6 2
ascii_file="gobolinux"
2017-01-01 22:40:30 -07:00
;;
2017-01-02 00:02:28 -07:00
"Grombyang"*)
set_colors 4 2 1
ascii_file="grombyang"
2017-01-01 22:40:30 -07:00
;;
2017-01-02 00:02:28 -07:00
"GuixSD"*)
set_colors 3 7 6 1 8
ascii_file="guixsd"
2017-01-01 22:40:30 -07:00
;;
2017-01-02 00:02:28 -07:00
"Haiku"*)
set_colors 2 8
ascii_file="haiku"
2016-02-22 22:52:25 -07:00
;;
"Hyperbola"*)
set_colors 8
ascii_file="hyperbola"
;;
2017-01-02 00:02:28 -07:00
"Kali"*)
set_colors 4 8
ascii_file="kali"
2016-02-22 22:52:25 -07:00
;;
2017-01-02 00:02:28 -07:00
"KaOS"*)
set_colors 4 7 1
ascii_file="kaos"
2017-01-01 22:40:30 -07:00
;;
2017-01-02 00:02:28 -07:00
"KDE"*)
set_colors 2 7
ascii_file="kde"
2017-01-01 22:40:30 -07:00
;;
2017-01-02 00:02:28 -07:00
"Kogaion"*)
set_colors 4 7 1
ascii_file="kogaion"
;;
2017-01-02 00:02:28 -07:00
"Korora"*)
set_colors 4 7 1
ascii_file="korora"
2017-01-01 22:40:30 -07:00
;;
2017-05-17 18:47:46 -06:00
"KSLinux"*)
set_colors 4 7 1
2017-05-18 00:47:02 -06:00
ascii_file="kslinux"
2017-05-17 18:47:46 -06:00
;;
2017-01-02 00:02:28 -07:00
"Kubuntu"*)
set_colors 4 7 1
ascii_file="kubuntu"
;;
2017-11-13 14:37:29 -07:00
"LEDE"*)
set_colors 4 7 1
ascii_file="lede"
;;
2017-01-02 00:02:28 -07:00
"Linux")
set_colors fg 8 3
ascii_file="linux"
2017-01-01 22:40:30 -07:00
;;
2017-01-02 00:02:28 -07:00
"LMDE"*)
set_colors 2 7
ascii_file="lmde"
2017-01-01 22:40:30 -07:00
;;
2017-01-02 00:02:28 -07:00
"Lubuntu"*)
set_colors 4 7 1
ascii_file="lubuntu"
2017-01-01 22:40:30 -07:00
;;
2017-10-15 14:42:37 -06:00
"Lunar"*)
set_colors 4 7 3
ascii_file="lunar"
;;
2017-07-22 08:48:27 -06:00
"mac"*"_small")
set_colors 2 3 1 5 4
ascii_file="mac_small"
;;
2017-01-02 00:26:45 -07:00
"mac" | "Darwin")
set_colors 2 3 1 1 5 4
ascii_file="mac"
;;
2017-01-02 00:02:28 -07:00
"Mageia"*)
set_colors 6 7
ascii_file="mageia"
2017-01-01 22:40:30 -07:00
;;
"MagpieOS"*)
set_colors 2 1 3 5
ascii_file="magpieos"
;;
2017-01-02 00:02:28 -07:00
"Manjaro"*)
set_colors 2 7
ascii_file="manjaro"
2017-01-01 22:40:30 -07:00
;;
2017-05-12 10:42:04 -06:00
"Maui"*)
set_colors 6 7
ascii_file="maui"
;;
2017-01-13 14:07:50 -07:00
"Mer"*)
set_colors 4 7 1
ascii_file="mer"
;;
2017-01-01 22:40:30 -07:00
"Minix"*)
set_colors 1 7 3
ascii_file="minix"
;;
2017-01-02 00:33:38 -07:00
"Linux Mint"* | "LinuxMint"*)
2017-01-02 00:02:28 -07:00
set_colors 2 7
ascii_file="mint"
2016-12-19 21:00:16 -07:00
;;
2017-01-02 00:02:28 -07:00
"MX"*)
set_colors 4 6 7
ascii_file="mx"
2016-02-22 22:52:25 -07:00
;;
2017-01-02 00:02:28 -07:00
"NetBSD"*)
set_colors 5 7
ascii_file="netbsd"
;;
2017-01-02 00:02:28 -07:00
"Netrunner"*)
set_colors 4 7 1
ascii_file="netrunner"
2016-11-13 02:21:32 -07:00
;;
2017-03-22 04:07:59 -06:00
"Nitrux"*)
set_colors 4
ascii_file="nitrux"
;;
2017-07-22 08:33:46 -06:00
"nixos_small")
set_colors 4 6
ascii_file="nixos_small"
;;
2017-01-02 00:02:28 -07:00
"NixOS"*)
set_colors 4 6
2017-01-02 00:26:45 -07:00
ascii_file="nixos"
2016-02-22 22:52:25 -07:00
;;
2017-08-12 11:14:12 -06:00
"Nurunner"*)
set_colors 4
ascii_file="nurunner"
;;
2018-01-31 07:17:12 -07:00
"NuTyX"*)
2018-02-02 08:49:32 -07:00
set_colors 4 1
2018-01-31 07:17:12 -07:00
ascii_file="nutyx"
;;
"OBRevenge"*)
set_colors 1 7 3
ascii_file="obrevenge"
;;
2017-01-02 00:02:28 -07:00
"openbsd_small")
set_colors 3 7 6 1 8
ascii_file="openbsd_small"
2016-02-22 22:52:25 -07:00
;;
2017-01-02 00:02:28 -07:00
"OpenBSD"*)
set_colors 3 7 6 1 8
ascii_file="openbsd"
;;
"OpenIndiana"*)
set_colors 4 7 1
ascii_file="openindiana"
2016-11-06 23:54:38 -07:00
;;
2016-02-22 22:52:25 -07:00
"OpenMandriva"*)
2016-11-13 02:21:32 -07:00
set_colors 4 3
2017-01-02 00:26:45 -07:00
ascii_file="openmandriva"
2016-02-22 22:52:25 -07:00
;;
2017-01-02 00:02:28 -07:00
"OpenWrt"*)
set_colors 4 7 1
ascii_file="openwrt"
2017-01-01 22:40:30 -07:00
;;
"Open Source Media Center"* | "osmc")
set_colors 4 7 1
ascii_file="osmc"
;;
2017-01-02 00:02:28 -07:00
"Oracle"*)
set_colors 1 7 3
ascii_file="oracle"
2017-01-01 22:53:05 -07:00
;;
2017-01-01 22:40:30 -07:00
2017-01-02 00:02:28 -07:00
"PacBSD"*)
set_colors 1 7 3
ascii_file="pacbsd"
2017-01-01 22:53:05 -07:00
;;
2017-01-02 00:02:28 -07:00
"Parabola"*)
2017-01-01 22:53:05 -07:00
set_colors 5 7
2017-01-02 00:02:28 -07:00
ascii_file="parabola"
2017-01-01 22:53:05 -07:00
;;
2017-01-02 00:02:28 -07:00
"Pardus"*)
set_colors 3 7 6 1 8
ascii_file="pardus"
2017-01-01 22:53:05 -07:00
;;
2017-01-02 00:02:28 -07:00
"Parrot"*)
set_colors 6 7
ascii_file="parrot"
2017-01-01 22:53:05 -07:00
;;
2017-07-16 12:02:43 -06:00
"Parsix"*)
set_colors 3 1 7 8
ascii_file="parsix"
;;
2017-01-02 00:02:28 -07:00
"PCBSD"* | "TrueOS"*)
set_colors 1 7 3
ascii_file="trueos"
2016-02-22 22:52:25 -07:00
;;
2017-01-02 00:02:28 -07:00
"PCLinuxOS"*)
set_colors 4 7 1
ascii_file="pclinuxos"
;;
2017-01-02 00:02:28 -07:00
"Peppermint"*)
set_colors 1 7 3
ascii_file="peppermint"
2017-01-01 22:53:05 -07:00
;;
2017-11-02 14:13:55 -06:00
"Pop!_OS"*)
set_colors 6 7
ascii_file="pop_os"
;;
2017-01-02 00:02:28 -07:00
"Porteus"*)
set_colors 6 7
ascii_file="porteus"
;;
2018-02-11 14:41:12 -07:00
"PostMarketOS"*)
set_colors 2 7
ascii_file="postmarketos"
;;
2017-01-02 00:02:28 -07:00
"Puppy"* | "Quirky Werewolf"* | "Precise Puppy"*)
set_colors 4 7
ascii_file="puppy"
;;
2017-01-02 00:02:28 -07:00
"Qubes"*)
set_colors 4 5 7 6
ascii_file="qubes"
2017-01-01 22:53:05 -07:00
;;
2017-01-02 00:02:28 -07:00
"Raspbian"*)
set_colors 2 1
ascii_file="raspbian"
2017-01-01 22:53:05 -07:00
;;
2017-01-02 00:02:28 -07:00
"Red Star"* | "Redstar"*)
set_colors 1 7 3
ascii_file="redstar"
2017-01-01 22:53:05 -07:00
;;
2017-01-02 00:39:12 -07:00
"Redhat"* | "Red Hat"* | "rhel"*)
2017-01-02 00:02:28 -07:00
set_colors 1 7 3
ascii_file="redhat"
2016-02-22 22:52:25 -07:00
;;
2017-08-24 17:55:06 -06:00
"Refracted Devuan"*)
set_colors 8 7
ascii_file="refracta"
;;
2017-01-02 00:02:28 -07:00
"Rosa"*)
set_colors 4 7 1
ascii_file="rosa"
2016-02-22 22:52:25 -07:00
;;
"sabotage"*)
set_colors 4 7 1
ascii_file="sabotage"
;;
2017-01-02 00:02:28 -07:00
"Sabayon"*)
set_colors 4 7 1
ascii_file="sabayon"
2017-01-01 22:53:05 -07:00
;;
2017-01-02 00:02:28 -07:00
"SailfishOS"*)
set_colors 4 5 7 6
ascii_file="sailfishos"
2017-01-01 22:53:05 -07:00
;;
2017-01-02 00:02:28 -07:00
"SalentOS"*)
set_colors 2 1 3 7
ascii_file="salentos"
2016-02-22 22:52:25 -07:00
;;
2017-01-02 00:02:28 -07:00
"Scientific"*)
set_colors 4 7 1
ascii_file="scientific"
2016-02-22 22:52:25 -07:00
;;
2018-01-16 12:48:33 -07:00
"Siduction"*)
set_colors 4 4
ascii_file="siduction"
;;
2017-01-02 00:02:28 -07:00
"Slackware"*)
set_colors 4 7 1
ascii_file="slackware"
2016-02-22 22:52:25 -07:00
;;
2017-03-09 11:55:06 -07:00
"SliTaz"*)
set_colors 3 3
ascii_file="slitaz"
;;
2017-01-02 00:02:28 -07:00
"SmartOS"*)
set_colors 6 7
ascii_file="smartos"
2016-02-22 22:52:25 -07:00
;;
2017-01-02 00:02:28 -07:00
"Solus"*)
set_colors 4 7 1
ascii_file="solus"
2016-03-26 05:32:31 -06:00
;;
2017-07-21 20:34:12 -06:00
"Source Mage"*)
set_colors 4 7 1
ascii_file="source_mage"
;;
2016-10-15 16:38:56 -06:00
"Sparky"*)
2016-11-13 02:21:32 -07:00
set_colors 1 7
2017-01-01 22:53:05 -07:00
ascii_file="sparky"
;;
2017-01-02 00:02:28 -07:00
"SteamOS"*)
set_colors 5 7
ascii_file="steamos"
2017-01-01 22:53:05 -07:00
;;
2017-01-02 00:26:45 -07:00
"SunOS" | "Solaris")
set_colors 3 7
ascii_file="solaris"
;;
"openSUSE Tumbleweed"*)
set_colors 2 7
ascii_file="tumbleweed"
;;
2017-01-02 00:48:35 -07:00
"openSUSE"* | "open SUSE"* | "SUSE"*)
2017-01-02 00:02:28 -07:00
set_colors 2 7
2017-01-04 03:37:25 -07:00
ascii_file="suse"
2016-10-15 16:38:56 -06:00
;;
2017-01-02 00:02:28 -07:00
"SwagArch"*)
set_colors 4 7 1
ascii_file="swagarch"
2016-02-22 22:52:25 -07:00
;;
2017-01-02 00:02:28 -07:00
"Tails"*)
set_colors 5 7
ascii_file="tails"
2016-12-19 20:50:06 -07:00
;;
2018-02-02 09:00:44 -07:00
"Trisquel"*)
2017-01-02 00:02:28 -07:00
set_colors 4 6
ascii_file="trisquel"
2016-12-23 17:11:52 -07:00
;;
2017-01-02 00:02:28 -07:00
"Ubuntu-Budgie"*)
set_colors 4 7 1
ascii_file="ubuntu-budgie"
2016-02-22 22:52:25 -07:00
;;
2017-01-02 00:02:28 -07:00
"Ubuntu-GNOME"*)
set_colors 4 5 7 6
ascii_file="ubuntu-gnome"
2017-01-01 22:53:05 -07:00
;;
"Ubuntu-MATE"*)
set_colors 2 7
ascii_file="ubuntu-mate"
;;
2017-01-02 00:02:28 -07:00
"ubuntu_old")
set_colors 1 7 3
ascii_file="ubuntu_old"
2017-01-01 22:53:05 -07:00
;;
"Ubuntu-Studio")
set_colors 6 7
ascii_file="ubuntu-studio"
;;
2017-01-02 00:02:28 -07:00
"Ubuntu"*)
set_colors 1 7 3
ascii_file="ubuntu"
2017-01-01 22:53:05 -07:00
;;
2017-01-06 05:04:49 -07:00
"void_small")
set_colors 2 8
ascii_file="void_small"
;;
2017-01-02 00:02:28 -07:00
"Void"*)
set_colors 2 8
ascii_file="void"
;;
2017-08-01 19:47:15 -06:00
*"[Windows 10]"* | *"on Windows 10"* | "Windows 8"* |\
"Windows 10"* | "windows10" | "windows8" )
2016-11-13 02:21:32 -07:00
set_colors 6 7
2017-01-01 22:53:05 -07:00
ascii_file="windows10"
2016-02-22 22:52:25 -07:00
;;
"Windows"*)
2016-11-13 02:21:32 -07:00
set_colors 1 2 4 3
2017-01-01 22:53:05 -07:00
ascii_file="windows"
;;
2017-01-02 00:02:28 -07:00
"Xubuntu"*)
set_colors 4 7 1
ascii_file="xubuntu"
2017-01-01 22:53:05 -07:00
;;
2017-01-02 00:02:28 -07:00
"Zorin"*)
set_colors 4 6
ascii_file="zorin"
;;
*)
2016-12-17 00:50:23 -07:00
case "$kernel_name" in
*"BSD")
set_colors 1 7 4 3 6
2017-01-01 22:55:08 -07:00
ascii_file="bsd"
;;
2017-01-02 00:02:28 -07:00
"Darwin")
set_colors 2 3 1 1 5 4
ascii_file="mac"
;;
2016-12-17 00:50:23 -07:00
"GNU"*)
2017-01-02 00:26:45 -07:00
set_colors fg 7
2017-01-01 22:55:08 -07:00
ascii_file="gnu"
;;
2017-01-02 00:02:28 -07:00
"Linux")
set_colors fg 8 3
ascii_file="linux"
;;
2016-12-17 00:50:23 -07:00
"SunOS")
2017-01-02 00:26:45 -07:00
set_colors 3 7
2017-01-01 22:55:08 -07:00
ascii_file="solaris"
;;
2017-04-26 21:37:33 -06:00
"IRIX"*)
2017-04-26 21:37:33 -06:00
set_colors 4 7
ascii_file="irix"
;;
esac
;;
2016-02-22 22:52:25 -07:00
esac
2017-01-01 22:53:05 -07:00
# Overwrite distro colors if '$ascii_colors' doesn't
# equal 'distro'.
if [[ "${ascii_colors[0]}" != "distro" ]]; then
color_text="off"
set_colors "${ascii_colors[@]}"
fi
2015-12-30 03:18:17 -07:00
}
2016-11-13 02:21:32 -07:00
set_colors() {
2016-06-11 22:35:29 -06:00
c1="$(color "$1")${ascii_bold}"
c2="$(color "$2")${ascii_bold}"
c3="$(color "$3")${ascii_bold}"
c4="$(color "$4")${ascii_bold}"
c5="$(color "$5")${ascii_bold}"
c6="$(color "$6")${ascii_bold}"
2016-12-08 01:50:04 -07:00
[[ "$color_text" != "off" ]] && set_text_colors "$@"
}
set_text_colors() {
if [[ "${colors[0]}" == "distro" ]]; then
2016-11-06 02:12:25 -07:00
title_color="$(color "$1")"
2016-08-13 19:04:25 -06:00
at_color="$reset"
underline_color="$reset"
2016-11-06 02:12:25 -07:00
subtitle_color="$(color "$2")"
2016-08-13 19:04:25 -06:00
colon_color="$reset"
info_color="$reset"
2016-02-22 22:52:25 -07:00
# If the ascii art uses 8 as a color, make the text the fg.
2017-01-04 07:50:11 -07:00
((${1:-1} == 8)) && title_color="$reset"
((${2:-7} == 8)) && subtitle_color="$reset"
# If the second color is white use the first for the subtitle.
2017-01-04 07:50:11 -07:00
((${2:-7} == 7)) && subtitle_color="$(color "$1")"
((${1:-1} == 7)) && title_color="$reset"
2016-02-22 22:52:25 -07:00
else
2016-06-11 22:35:29 -06:00
title_color="$(color "${colors[0]}")"
at_color="$(color "${colors[1]}")"
underline_color="$(color "${colors[2]}")"
subtitle_color="$(color "${colors[3]}")"
colon_color="$(color "${colors[4]}")"
info_color="$(color "${colors[5]}")"
2016-02-22 22:52:25 -07:00
fi
2016-12-20 03:17:40 -07:00
# Bar colors.
if [[ "$bar_color_elapsed" == "distro" ]]; then
bar_color_elapsed="$(color fg)"
else
bar_color_elapsed="$(color "$bar_color_elapsed")"
2016-03-27 03:49:06 -06:00
fi
case "$bar_color_total $1" in
"distro "[736]) bar_color_total="$(color "$1")" ;;
"distro "[0-9]) bar_color_total="$(color "$2")" ;;
*) bar_color_total="$(color "$bar_color_total")" ;;
2016-03-29 06:31:08 -06:00
esac
2016-01-20 15:49:50 -07:00
}
2016-08-12 04:53:04 -06:00
color() {
case "$1" in
[0-6]) printf "%b" "${reset}\e[3${1}m" ;;
7 | "fg") printf "%b" "\e[37m${reset}" ;;
*) printf "%b" "\e[38;5;${1}m" ;;
esac
2016-03-03 19:15:03 -07:00
}
2016-11-10 17:15:05 -07:00
# OTHER
2017-08-03 02:16:52 -06:00
stdout() {
image_backend="off"
unset subtitle_color
unset colon_color
unset info_color
unset underline_color
unset bold
unset title_color
unset at_color
unset text_padding
unset zws
unset reset
2017-08-03 12:29:29 -06:00
unset color_blocks
2017-08-03 19:10:34 -06:00
unset get_line_break
2017-08-03 02:16:52 -06:00
}
2016-08-12 04:53:04 -06:00
err() {
err+="$(color 1)[!]\e[0m $1\n"
}
get_full_path() {
# This function finds the absolute path from a relative one.
# For example "Pictures/Wallpapers" --> "/home/dylan/Pictures/Wallpapers"
# If the file exists in the current directory, stop here.
2017-01-19 05:35:25 -07:00
[[ -f "${PWD}/${1/*\/}" ]] && { printf "%s\n" "${PWD}/${1/*\/}"; return; }
2016-08-11 17:47:09 -06:00
if ! cd "${1%/*}"; then
2017-01-17 22:21:43 -07:00
err "Error: Directory '${1%/*}' doesn't exist or is inaccessible"
err " Check that the directory exists or try another directory."
exit 1
fi
2016-08-11 17:47:09 -06:00
local full_dir="${1##*/}"
2016-01-29 08:14:29 -07:00
# Iterate down a (possible) chain of symlinks.
while [[ -L "$full_dir" ]]; do
full_dir="$(readlink "$full_dir")"
cd "${full_dir%/*}" || exit
full_dir="${full_dir##*/}"
2016-01-29 08:14:29 -07:00
done
2016-12-20 03:17:40 -07:00
# Final directory.
full_dir="$(pwd -P)/${1/*\/}"
[[ -e "$full_dir" ]] && printf "%s\n" "$full_dir"
2016-01-29 08:14:29 -07:00
}
get_default_config() {
2017-07-01 04:17:52 -06:00
if [[ -f "CONFDIR/config.conf" ]]; then
default_config="CONFDIR/config.conf"
else
[[ -z "$script_dir" ]] && script_dir="$(get_full_path "$0")"
default_config="${script_dir%/*}/config/config.conf"
fi
2016-08-11 19:38:32 -06:00
if source "$default_config"; then
err "Config: Sourced default config. (${default_config})"
else
err "Config: Default config not found, continuing..."
fi
}
get_user_config() {
2016-12-20 03:17:40 -07:00
# Check $config_file.
if [[ -f "$config_file" ]]; then
2016-01-29 08:14:29 -07:00
source "$config_file"
err "Config: Sourced user config. (${config_file})"
2017-01-01 17:27:37 -07:00
old_options
2016-01-29 08:14:29 -07:00
return
fi
mkdir -p "${XDG_CONFIG_HOME}/neofetch/"
2016-01-29 08:14:29 -07:00
# Check ${XDG_CONFIG_HOME}/neofetch and create the
2016-01-29 08:14:29 -07:00
# dir/files if they don't exist.
if [[ -f "${XDG_CONFIG_HOME}/neofetch/config" ]]; then
config_file="${XDG_CONFIG_HOME}/neofetch/config"
2016-01-29 08:18:27 -07:00
elif [[ -f "${XDG_CONFIG_HOME}/neofetch/config.conf" ]]; then
config_file="${XDG_CONFIG_HOME}/neofetch/config.conf"
2016-01-29 08:18:27 -07:00
2017-07-01 04:17:52 -06:00
elif [[ -f "CONFDIR/config.conf" ]]; then
cp "CONFDIR/config.conf" "${XDG_CONFIG_HOME}/neofetch"
config_file="${XDG_CONFIG_HOME}/neofetch/config.conf"
2016-01-29 08:14:29 -07:00
else
[[ -z "$script_dir" ]] && script_dir="$(get_full_path "$0")"
2016-01-29 08:14:29 -07:00
cp "${script_dir%/*}/config/config.conf" "${XDG_CONFIG_HOME}/neofetch"
config_file="${XDG_CONFIG_HOME}/neofetch/config.conf"
2016-01-29 08:14:29 -07:00
fi
source "$config_file"
err "Config: Sourced user config. (${config_file})"
old_options
2016-01-29 08:14:29 -07:00
}
2016-03-02 16:12:21 -07:00
bar() {
2016-12-20 03:17:40 -07:00
# Get the values.
elapsed="$(($1 * bar_length / $2))"
2016-03-02 16:12:21 -07:00
2016-12-20 03:17:40 -07:00
# Create the bar with spaces.
2016-12-15 19:20:10 -07:00
printf -v prog "%${elapsed}s"
printf -v total "%$((bar_length - elapsed))s"
2016-03-02 16:12:21 -07:00
2016-12-20 03:17:40 -07:00
# Set the colors and swap the spaces for $bar_char_.
bar+="${bar_color_elapsed}${prog// /${bar_char_elapsed}}"
bar+="${bar_color_total}${total// /${bar_char_total}}"
2016-04-24 02:30:57 -06:00
2016-12-20 03:17:40 -07:00
# Borders.
[[ "$bar_border" == "on" ]] && \
bar="$(color fg)[${bar}$(color fg)]"
2016-04-24 02:30:57 -06:00
printf "%b" "${bar}${info_color}"
2016-03-02 16:12:21 -07:00
}
2016-08-12 04:53:04 -06:00
cache() {
if [[ "$2" ]]; then
mkdir -p "${cache_dir}/neofetch"
printf "%s" "${1/*-}=\"$2\"" > "${cache_dir}/neofetch/${1/*-}"
fi
2016-12-02 02:06:43 -07:00
}
get_cache_dir() {
case "$os" in
"Mac OS X") cache_dir="/Library/Caches" ;;
*) cache_dir="/tmp" ;;
esac
}
kde_config_dir() {
# If the user is using KDE get the KDE
# configuration directory.
if [[ "$kde_config_dir" ]]; then
return
elif type -p kf5-config >/dev/null 2>&1; then
kde_config_dir="$(kf5-config --path config)"
2016-04-01 00:38:06 -06:00
2016-03-31 21:50:15 -06:00
elif type -p kde4-config >/dev/null 2>&1; then
kde_config_dir="$(kde4-config --path config)"
2016-03-31 21:50:15 -06:00
2016-12-22 01:07:34 -07:00
elif type -p kde-config >/dev/null 2>&1; then
kde_config_dir="$(kde-config --path config)"
2016-12-22 01:07:34 -07:00
2016-12-22 00:57:01 -07:00
elif [[ -d "${HOME}/.kde4" ]]; then
kde_config_dir="${HOME}/.kde4/share/config"
2016-12-22 01:04:28 -07:00
2016-12-22 01:07:34 -07:00
elif [[ -d "${HOME}/.kde3" ]]; then
kde_config_dir="${HOME}/.kde3/share/config"
2016-03-31 21:50:15 -06:00
fi
kde_config_dir="${kde_config_dir/$'/:'*}"
2016-03-31 21:50:15 -06:00
}
get_term_padding() {
2016-12-20 03:17:40 -07:00
# Terminal info.
2016-11-10 17:15:05 -07:00
#
# Parse terminal config files to get
# info about padding. Due to how w3m-img
# works padding around the terminal throws
# off the cursor placement calculation in
# specific terminals.
#
# Note: This issue only seems to affect
# URxvt.
2017-07-31 09:42:00 -06:00
((term_run != 1)) && get_term
case "$term" in
"URxvt"*)
2016-12-18 02:05:31 -07:00
border="$(xrdb -query | awk -F ':' '/^(URxvt|\*).internalBorder/ {printf $2; exit}')"
;;
esac
}
dynamic_prompt() {
2016-12-11 23:41:35 -07:00
case "$image_backend" in
"ascii") printf "\n" ;;
"off") return ;;
*)
get_term_padding
lines="$(((border + height + yoffset) / font_height))"
image_prompt="on"
2016-12-11 23:41:35 -07:00
;;
esac
2016-08-13 03:42:31 -06:00
# If the info is higher than the ascii/image place the prompt
# based on the info height instead of the ascii/image height.
2017-01-04 06:36:04 -07:00
if ((lines < info_height)); then
[[ "$image_prompt" ]] && printf "\n"
2016-11-08 02:50:39 -07:00
return
2016-09-30 20:28:21 -06:00
else
[[ "$image_prompt" ]] && printf "%b\n" "$line_breaks"
2018-02-11 14:43:22 -07:00
lines="$((lines - info_height + 1))"
2016-09-30 20:28:21 -06:00
fi
2016-08-13 03:42:31 -06:00
2016-12-20 03:17:40 -07:00
# Set the prompt location.
2017-12-25 13:20:50 -07:00
if ((lines > 1)); then
case "$kernel_name" in
"OpenBSD") tput cud "$lines" ;;
*) printf "%b" "\e[${lines}B" ;;
2017-12-25 13:20:50 -07:00
esac
2017-12-24 17:04:50 -07:00
fi
2016-08-13 03:42:31 -06:00
}
old_functions() {
2016-12-20 03:17:40 -07:00
# Deprecated functions.
2016-11-10 17:15:05 -07:00
# Neofetch 2.0 changed the names of a few variables.
# This function adds backwards compatibility for the
# old variable names.
if type printinfo >/dev/null 2>&1; then
print_info() { printinfo ; }
get_wmtheme() { get_wm_theme; wmtheme="$wm_theme"; }
get_termfont() { get_term_font; termfont="$term_font"; }
get_localip() { get_local_ip; localip="$local_ip"; }
get_publicip() { get_public_ip; publicip="$public_ip"; }
get_linebreak() { get_line_break; linebreak="$line_break"; }
fi
get_birthday() { get_install_date; birthday="$install_date"; }
}
old_options() {
2017-08-01 19:47:15 -06:00
[[ -n "$osx_buildversion" ]] && \
err "Config: \$osx_buildversion is deprecated, use \$distro_shorthand instead."
[[ -n "$osx_codename" ]] && \
err "Config: \$osx_codename is deprecated, use \$distro_shorthand instead."
[[ "$cpu_cores" == "on" ]] && \
err "Config: cpu_cores='on' is deprecated, use cpu_cores='logical|physical|off' instead."
[[ -n "$image" ]] && \
{ err "Config: \$image is deprecated, use \$image_source instead."; image_source="$image"; }
2016-12-20 03:17:40 -07:00
# All progress_ variables were changed to bar_.
2017-08-01 19:47:15 -06:00
[[ -n "$progress_char" ]] && \
err "Config: \$progress_char is deprecated, use \$bar_char_{elapsed,total} instead."
[[ -n "$progress_border" ]] && \
{ err "Config: \$progress_border is deprecated, use \$bar_border instead."; \
bar_border="$progress_border"; }
[[ -n "$progress_length" ]] && \
{ err "Config: \$progress_length is deprecated, use \$bar_length instead."; \
bar_length="$progress_length"; }
[[ -n "$progress_color_elapsed" ]] && \
{ err "Config: \$progress_color_elapsed is deprecated, use \$bar_color_elapsed instead."; \
bar_color_elapsed="$progress_color_elapsed"; }
[[ -n "$progress_color_total" ]] && \
{ err "Config: \$progress_color_total is deprecated, use \$bar_color_total instead."; \
bar_color_total="$progress_color_total"; }
2017-01-22 17:00:38 -07:00
# All cpufreq values were changed in 3.0.
2017-08-01 19:47:15 -06:00
[[ "$speed_type" == "current" ]] && \
err "Config: speed_type='current' is deprecated, use speed_type='scaling_cur_freq' instead."
[[ "$speed_type" == "min" ]] && \
err "Config: speed_type='min' is deprecated, use speed_type='scaling_min_freq' instead."
[[ "$speed_type" == "max" ]] && \
err "Config: speed_type='max' is deprecated, use speed_type='scaling_max_freq' instead."
[[ "$speed_type" == "bios" ]] && \
err "Config: speed_type='bios' is deprecated, use speed_type='bios_limit' instead."
2017-01-22 17:00:38 -07:00
# Ascii_logo_size was removed in 3.0.
2017-08-01 19:47:15 -06:00
[[ "$ascii_logo_size" ]] && \
err "Config: ascii_logo_size is deprecated, use ascii_distro='{distro}_small' instead."
2017-01-22 17:00:38 -07:00
# $start and $end were replaced with ${block_range[@]} in 3.0.
2017-08-01 19:47:15 -06:00
[[ "$start" && "$end" ]] && \
{ err "Config: \$start and \$end are deprecated, use block_range=(0 7) instead."; \
block_range=("$start" "$end"); }
2017-01-01 17:27:37 -07:00
# Fahrenheit support was added to CPU so the options were changed.
2017-08-01 19:47:15 -06:00
[[ "$cpu_temp" == "on" ]] && \
{ err "Config: cpu_temp='on' is deprecated, use cpu_temp='C' or 'F' instead.";
cpu_temp="C"; }
# Birthday was renamed to Install Date in 3.0
2017-08-01 19:47:15 -06:00
[[ -n "$birthday_time" ]] && \
{ err "Config: \$birthday_time is deprecated, use \3install_time instead."; \
install_time="$birthday_time"; }
# Scrot dir was removed in 3.1.0.
[[ -n "$scrot_dir" ]] && scrot_dir=
# cpu_shorthand was deprecated in 3.3.0
2017-08-01 19:47:15 -06:00
[[ -n "$cpu_shorthand" ]] && \
{ err "Config: \$cpu_shorthand is deprecated, use \$cpu_brand, \$cpu_cores, and
2017-08-01 20:54:41 -06:00
\$cpu_speed instead."; }
2016-11-13 01:44:03 -07:00
}
cache_uname() {
# Cache the output of uname so we don't
# have to spawn it multiple times.
2018-04-13 17:32:12 -06:00
IFS=" " read -ra uname <<< "$(uname -sr)"
kernel_name="${uname[0]}"
kernel_version="${uname[1]}"
}
convert_time() {
# Convert ls timestamp to 'Tue 06 Dec 2016 4:58 PM' format.
year="$1"
day="${3#0}"
2016-12-20 03:17:40 -07:00
# Split time into hours/minutes.
2016-12-15 18:07:01 -07:00
hour="${4/:*}"
min="${4/${hour}}"
# Get month. (Month code is used for day of week)
2016-12-15 20:44:04 -07:00
# Due to different versions of 'ls', the month can be 1, 01 or Jan.
case "$2" in
2017-01-05 15:15:59 -07:00
1 | 01 | "Jan") month="Jan"; month_code=0 ;;
2 | 02 | "Feb") month="Feb"; month_code=3 ;;
3 | 03 | "Mar") month="Mar"; month_code=3 ;;
4 | 04 | "Apr") month="Apr"; month_code=6 ;;
5 | 05 | "May") month="May"; month_code=1 ;;
6 | 06 | "Jun") month="Jun"; month_code=4 ;;
7 | 07 | "Jul") month="Jul"; month_code=6 ;;
8 | 08 | "Aug") month="Aug"; month_code=2 ;;
9 | 09 | "Sep") month="Sep"; month_code=5 ;;
10 | "Oct") month="Oct"; month_code=0 ;;
11 | "Nov") month="Nov"; month_code=3 ;;
12 | "Dec") month="Dec"; month_code=5 ;;
esac
# Get leap year.
2016-12-15 20:44:04 -07:00
# Source: http://stackoverflow.com/questions/725098/leap-year-calculation
[[ "$((year % 4))" == 0 && "$((year % 100))" != 0 || "$((year % 400))" == 0 ]] && \
[[ "$month" =~ (Jan|Feb) ]] && \
2017-01-05 15:15:59 -07:00
leap_code=1
# Calculate day of week.
2016-12-15 20:44:04 -07:00
# Source: http://blog.artofmemory.com/how-to-calculate-the-day-of-the-week-4203.html
2016-12-23 05:49:53 -07:00
year_code="$((${year/??} + (${year/??} / 4) % 7))"
week_day="$(((year_code + month_code + 6 + day - leap_code) % 7))"
case "$week_day" in
0) week_day="Sun" ;;
1) week_day="Mon" ;;
2) week_day="Tue" ;;
3) week_day="Wed" ;;
4) week_day="Thu" ;;
5) week_day="Fri" ;;
6) week_day="Sat" ;;
esac
2016-12-20 03:17:40 -07:00
# Convert 24 hour time to 12 hour time + AM/PM.
case "$install_time_format" in
"12h")
case "$hour" in
[0-9] | 0[0-9] | 1[0-1]) time="${hour/00/12}${min} AM" ;;
*) time="$((hour - 12))${min} PM" ;;
esac
;;
2016-12-25 05:02:26 -07:00
*) time="$4" ;;
esac
2016-12-20 03:17:40 -07:00
# Toggle showing the time.
[[ "$install_time" == "off" ]] && unset time
2016-12-15 21:59:07 -07:00
# Print the install date.
printf "%s" "$week_day $day $month $year $time"
}
get_ppid() {
# Get parent process ID of PID.
case "$os" in
"Windows")
ppid="$(ps -p "${1:-$PPID}" | awk '{printf $2}')"
ppid="${ppid/'PPID'}"
;;
"Linux")
ppid="$(grep -i -F "PPid:" "/proc/${1:-$PPID}/status")"
ppid="$(trim "${ppid/PPid:}")"
;;
*)
ppid="$(ps -p "${1:-$PPID}" -o ppid=)"
;;
esac
printf "%s" "$ppid"
}
get_process_name() {
# Get PID name.
case "$os" in
"Windows")
name="$(ps -p "${1:-$PPID}" | awk '{printf $8}')"
name="${name/'COMMAND'}"
name="${name/*\/}"
;;
"Linux")
name="$(< "/proc/${1:-$PPID}/comm")"
;;
*)
name="$(ps -p "${1:-$PPID}" -o comm=)"
;;
esac
printf "%s" "$name"
}
decode_url() {
decode="${1//+/ }"
printf "%b" "${decode//%/\\x}"
}
# FINISH UP
usage() { printf "%s" "\
Usage: neofetch --option \"value\" --option \"value\"
Neofetch is a CLI system information tool written in BASH. Neofetch
displays information about your system next to an image, your OS logo,
or any ASCII file of your choice.
NOTE: Every launch flag has a config option.
Options:
2016-12-29 01:26:44 -07:00
INFO:
--disable infoname Allows you to disable an info line from appearing
in the output.
2017-08-01 19:47:15 -06:00
NOTE: You can supply multiple args. eg. 'neofetch --disable cpu gpu'
--os_arch on/off Hide/Show OS architecture.
--speed_type type Change the type of cpu speed to display.
Possible values: current, min, max, bios,
scaling_current, scaling_min, scaling_max
NOTE: This only supports Linux with cpufreq.
--speed_shorthand on/off Whether or not to show decimals in CPU speed.
2017-07-13 06:04:42 -06:00
2017-08-01 19:47:15 -06:00
NOTE: This flag is not supported in systems with CPU speed less than
1 GHz.
2017-07-13 06:04:42 -06:00
--cpu_brand on/off Enable/Disable CPU brand in output.
2016-10-20 23:38:02 -06:00
--cpu_cores type Whether or not to display the number of CPU cores
2017-01-14 18:13:10 -07:00
Possible values: logical, physical, off
2016-10-22 16:45:03 -06:00
NOTE: 'physical' doesn't work on BSD.
2016-10-22 16:45:03 -06:00
--cpu_speed on/off Hide/Show cpu speed.
2017-01-01 17:30:34 -07:00
--cpu_temp C/F/off Hide/Show cpu temperature.
2016-11-26 00:43:59 -07:00
NOTE: This only works on Linux and BSD.
2017-08-01 19:47:15 -06:00
NOTE: For FreeBSD and NetBSD-based systems, you need to enable
coretemp kernel module. This only supports newer Intel processors.
--distro_shorthand on/off Shorten the output of distro (tiny, on, off)
2016-10-30 01:18:15 -06:00
NOTE: This option won't work in Windows (Cygwin)
2016-10-30 03:55:14 -06:00
--kernel_shorthand on/off Shorten the output of kernel
2016-10-30 01:18:15 -06:00
NOTE: This option won't work in BSDs (except PacBSD and PC-BSD)
--uptime_shorthand on/off Shorten the output of uptime (tiny, on, off)
2016-03-17 23:28:26 -06:00
--refresh_rate on/off Whether to display the refresh rate of each monitor
Unsupported on Windows
--gpu_brand on/off Enable/Disable GPU brand in output. (AMD/NVIDIA/Intel)
2016-12-21 19:23:48 -07:00
--gpu_type type Which GPU to display. (all, dedicated, integrated)
NOTE: This only supports Linux.
--gtk_shorthand on/off Shorten output of gtk theme/icons
2016-12-13 23:10:20 -07:00
--gtk2 on/off Enable/Disable gtk2 theme/font/icons output
--gtk3 on/off Enable/Disable gtk3 theme/font/icons output
--shell_path on/off Enable/Disable showing \$SHELL path
--shell_version on/off Enable/Disable showing \$SHELL version
2017-01-06 00:53:26 -07:00
--disk_show value Which disks to display.
2017-01-14 18:13:10 -07:00
Possible values: '/', '/dev/sdXX', '/path/to/mount point'
2017-01-06 00:53:26 -07:00
NOTE: Multiple values can be given. (--disk_show '/' '/dev/sdc1')
2017-01-07 20:23:55 -07:00
--disk_subtitle type What information to append to the Disk subtitle.
Takes: name, mount, dir
2017-01-07 20:23:55 -07:00
'name' shows the disk's name (sda1, sda2, etc)
'mount' shows the disk's mount point (/, /mnt/Local Disk, etc)
'dir' shows the basename of the disks's path. (/, Local Disk, etc)
2016-12-13 23:08:55 -07:00
--ip_host url URL to query for public IP
2016-12-18 20:53:38 -07:00
--song_shorthand on/off Print the Artist/Title on separate lines
--music_player player-name Manually specify a player to use.
Available values are listed in the config file
--install_time on/off Enable/Disable showing the time in Install Date output.
--install_time_format 12h/24h
Set time format in Install Date to be 12 hour or 24 hour.
2016-12-29 01:26:44 -07:00
TEXT FORMATTING:
--colors x x x x x x Changes the text colors in this order:
title, @, underline, subtitle, colon, info
2016-11-25 00:34:01 -07:00
--underline on/off Enable/Disable the underline.
--underline_char char Character to use when underlining title
--bold on/off Enable/Disable bold text
2016-12-29 01:26:44 -07:00
COLOR BLOCKS:
--color_blocks on/off Enable/Disable the color blocks
--block_width num Width of color blocks in spaces
--block_height num Height of color blocks in lines
--block_range num num Range of colors to print as blocks
2016-12-29 01:26:44 -07:00
BARS:
--bar_char 'elapsed char' 'total char'
Characters to use when drawing bars.
--bar_border on/off Whether or not to surround the bar with '[]'
--bar_length num Length in spaces to make the bars.
2016-11-13 03:37:41 -07:00
--bar_colors num num Colors to make the bar.
2016-03-12 15:14:56 -07:00
Set in this order: elapsed, total
--cpu_display mode Bar mode.
2017-01-14 18:13:10 -07:00
Possible values: bar, infobar, barinfo, off
--memory_display mode Bar mode.
2017-01-14 18:13:10 -07:00
Possible values: bar, infobar, barinfo, off
--battery_display mode Bar mode.
2017-01-14 18:13:10 -07:00
Possible values: bar, infobar, barinfo, off
--disk_display mode Bar mode.
2017-01-14 18:13:10 -07:00
Possible values: bar, infobar, barinfo, off
IMAGE BACKEND:
2017-01-16 20:59:57 -07:00
--backend backend Which image backend to use.
2017-08-01 19:47:15 -06:00
Possible values: 'ascii', 'caca', 'catimg', 'jp2a', 'iterm2', 'off',
'sixel', 'tycat', 'w3m'
2017-01-16 20:59:57 -07:00
--source source Which image or ascii file to use.
2017-08-01 19:47:15 -06:00
Possible values: 'auto', 'ascii', 'wallpaper', '/path/to/img',
'/path/to/ascii', '/path/to/dir/'
--ascii source Shortcut to use 'ascii' backend.
--caca source Shortcut to use 'caca' backend.
--catimg source Shortcut to use 'catimg' backend.
--iterm2 source Shortcut to use 'iterm2' backend.
2017-01-22 16:02:30 -07:00
--jp2a source Shortcut to use 'jp2a' backend.
--kitty source Shortcut to use 'kitty' backend.
2018-02-27 05:57:03 -07:00
--pixterm source Shortcut to use 'pixterm' backend.
2017-02-08 16:23:21 -07:00
--sixel source Shortcut to use 'sixel' backend.
2017-02-08 16:36:21 -07:00
--termpix source Shortcut to use 'termpix' backend.
--tycat source Shortcut to use 'tycat' backend.
--w3m source Shortcut to use 'w3m' backend.
--off Shortcut to use 'off' backend.
2017-01-16 20:59:57 -07:00
2017-08-01 19:47:15 -06:00
NOTE: 'source; can be any of the following: 'auto', 'ascii', 'wallpaper', '/path/to/img',
'/path/to/ascii', '/path/to/dir/'
2016-12-29 01:26:44 -07:00
ASCII:
2016-03-05 15:08:59 -07:00
--ascii_colors x x x x x x Colors to print the ascii art
--ascii_distro distro Which Distro's ascii art to print
2016-12-18 20:53:38 -07:00
NOTE: Arch and Ubuntu have 'old' logo variants.
2016-12-04 20:31:56 -07:00
NOTE: Use 'arch_old' or 'ubuntu_old' to use the old logos.
2016-12-18 20:53:38 -07:00
NOTE: Ubuntu has flavor variants.
2017-08-01 19:47:15 -06:00
NOTE: Change this to 'Lubuntu', 'Xubuntu', 'Ubuntu-GNOME',
'Ubuntu-Studio' or 'Ubuntu-Budgie' to use the flavors.
2017-08-01 19:47:15 -06:00
NOTE: Alpine, Arch, CRUX, Debian, Gentoo, FreeBSD, Mac, NixOS,
OpenBSD, and Void have a smaller logo variant.
2016-12-18 20:43:07 -07:00
2017-07-22 09:10:41 -06:00
NOTE: Use '{distro name}_small' to use the small variants.
2016-12-18 20:43:07 -07:00
--ascii_bold on/off Whether or not to bold the ascii logo.
-L, --logo Hide the info text and only show the ascii logo.
2016-01-27 04:33:22 -07:00
Possible values: bar, infobar, barinfo, off
IMAGE:
2017-08-01 19:47:15 -06:00
--loop Redraw the image constantly until Ctrl+C is used. This fixes issues
in some terminals emulators when using image mode.
--size 00px | --size 00% How to size the image.
Possible values: auto, 00px, 00%, none
--crop_mode mode Which crop mode to use
Takes the values: normal, fit, fill
--crop_offset value Change the crop offset for normal mode.
Possible values: northwest, north, northeast,
west, center, east, southwest, south, southeast
--xoffset px How close the image will be to the left edge of the
window. This only works with w3m.
--yoffset px How close the image will be to the top edge of the
window. This only works with w3m.
--bg_color color Background color to display behind transparent image.
This only works with w3m.
--gap num Gap between image and text.
2017-08-01 19:47:15 -06:00
NOTE: --gap can take a negative value which will move the text
closer to the left side.
--clean Delete cached files and thumbnails.
2016-12-29 01:26:44 -07:00
SCREENSHOT:
-s, --scrot /path/to/img Take a screenshot, if path is left empty the screen-
shot function will use \$scrot_dir and \$scrot_name.
-su, --upload /path/to/img Same as --scrot but uploads the scrot to a website.
2017-01-14 18:13:10 -07:00
--image_host imgur/teknik Website to upload scrots to.
--scrot_cmd cmd Screenshot program to launch
2016-12-29 01:26:44 -07:00
OTHER:
--config /path/to/config Specify a path to a custom config file
--config none Launch the script without a config file
2017-08-03 11:15:55 -06:00
--stdout Turn off all colors and disables any ASCII/image backend.
--help Print this text and exit
2016-05-29 23:14:16 -06:00
--version Show neofetch version
2016-04-29 01:45:51 -06:00
-v Display error messages.
-vv Display a verbose log for error reporting.
2016-12-29 01:26:44 -07:00
DEVELOPER:
--gen-man Generate a manpage for Neofetch in your PWD. (Requires GNU help2man)
2016-12-14 05:04:08 -07:00
Report bugs to https://github.com/dylanaraps/neofetch/issues
"
exit 1
}
get_args() {
2016-12-20 03:17:40 -07:00
# Check the commandline flags early for '--config'.
[[ "$*" != *--config* ]] && get_user_config
2016-08-13 21:13:21 -06:00
while [[ "$1" ]]; do
2016-11-06 02:11:12 -07:00
case "$1" in
2016-08-13 21:13:21 -06:00
# Info
2016-11-15 04:27:36 -07:00
"--os_arch") os_arch="$2" ;;
"--cpu_cores") cpu_cores="$2" ;;
"--cpu_speed") cpu_speed="$2" ;;
"--speed_type") speed_type="$2" ;;
"--speed_shorthand") speed_shorthand="$2" ;;
2016-11-15 04:27:36 -07:00
"--distro_shorthand") distro_shorthand="$2" ;;
"--kernel_shorthand") kernel_shorthand="$2" ;;
"--uptime_shorthand") uptime_shorthand="$2" ;;
"--cpu_brand") cpu_brand="$2" ;;
2016-11-15 04:27:36 -07:00
"--gpu_brand") gpu_brand="$2" ;;
2016-12-21 19:23:48 -07:00
"--gpu_type") gpu_type="$2" ;;
2016-11-15 04:27:36 -07:00
"--refresh_rate") refresh_rate="$2" ;;
"--gtk_shorthand") gtk_shorthand="$2" ;;
"--gtk2") gtk2="$2" ;;
"--gtk3") gtk3="$2" ;;
"--shell_path") shell_path="$2" ;;
"--shell_version") shell_version="$2" ;;
"--ip_host") public_ip_host="$2" ;;
"--song_shorthand") song_shorthand="$2" ;;
"--music_player") music_player="$2" ;;
"--install_time") install_time="$2" ;;
"--install_time_format") install_time_format="$2" ;;
2017-01-01 17:27:37 -07:00
"--cpu_temp")
cpu_temp="$2"
[[ "$cpu_temp" == "on" ]] && cpu_temp="C"
;;
2017-01-07 20:23:55 -07:00
"--disk_subtitle") disk_subtitle="$2" ;;
2017-01-06 00:53:26 -07:00
"--disk_show")
unset disk_show
for arg in "$@"; do
case "$arg" in
"--disk_show") ;;
"-"*) break ;;
2018-04-13 17:49:12 -06:00
*) disk_show+=("$arg") ;;
2017-01-06 00:53:26 -07:00
esac
done
;;
2016-11-15 04:27:36 -07:00
"--disable")
2016-08-13 21:13:21 -06:00
for func in "$@"; do
case "$func" in
"--disable") continue ;;
2016-11-15 04:27:36 -07:00
"-"*) break ;;
2016-11-25 00:34:01 -07:00
*)
2017-01-04 06:36:04 -07:00
((bash_version >= 4)) && func="${func,,}"
2016-11-25 00:34:01 -07:00
unset -f "get_$func"
;;
2016-08-13 21:13:21 -06:00
esac
done
;;
2016-01-27 04:33:22 -07:00
2016-08-13 21:13:21 -06:00
# Text Colors
2016-11-15 04:27:36 -07:00
"--colors")
2016-08-13 21:13:21 -06:00
unset colors
for arg in "$2" "$3" "$4" "$5" "$6" "$7"; do
case "$arg" in
2016-10-03 15:48:33 -06:00
"-"*) break ;;
2018-04-13 17:49:12 -06:00
*) colors+=("$arg") ;;
2016-08-13 21:13:21 -06:00
esac
done
colors+=(7 7 7 7 7 7)
;;
2016-08-13 21:13:21 -06:00
# Text Formatting
2016-11-15 04:27:36 -07:00
"--underline") underline_enabled="$2" ;;
"--underline_char") underline_char="$2" ;;
"--bold") bold="$2" ;;
2016-08-13 21:13:21 -06:00
# Color Blocks
2016-11-15 04:27:36 -07:00
"--color_blocks") color_blocks="$2" ;;
"--block_range") block_range=("$2" "$3") ;;
2016-11-15 04:27:36 -07:00
"--block_width") block_width="$2" ;;
"--block_height") block_height="$2" ;;
2016-08-13 21:13:21 -06:00
# Bars
2016-11-15 04:27:36 -07:00
"--bar_char")
bar_char_elapsed="$2"
bar_char_total="$3"
2016-08-13 21:13:21 -06:00
;;
2016-11-15 04:27:36 -07:00
"--bar_border") bar_border="$2" ;;
"--bar_length") bar_length="$2" ;;
"--bar_colors")
bar_color_elapsed="$2"
bar_color_total="$3"
2016-08-13 21:13:21 -06:00
;;
2016-11-15 04:27:36 -07:00
"--cpu_display") cpu_display="$2" ;;
"--memory_display") memory_display="$2" ;;
"--battery_display") battery_display="$2" ;;
"--disk_display") disk_display="$2" ;;
2016-08-13 21:13:21 -06:00
2017-01-14 03:51:26 -07:00
# Image backend
"--backend") image_backend="$2" ;;
"--source") image_source="$2" ;;
2017-12-15 21:51:07 -07:00
"--ascii" | "--caca" | "--catimg" | "--jp2a" | "--iterm2" | "--off" | "--pixterm" |\
"--sixel" | "--termpix" | "--tycat" | "--w3m" | "--kitty")
image_backend="${1/--}"
case "$2" in
"-"* | "") ;;
*) image_source="$2" ;;
esac
2016-08-13 21:13:21 -06:00
;;
2017-01-14 03:51:26 -07:00
# Image options
2017-04-25 15:39:10 -06:00
"--loop") image_loop="on" ;;
2016-11-15 04:27:36 -07:00
"--image_size" | "--size") image_size="$2" ;;
"--crop_mode") crop_mode="$2" ;;
"--crop_offset") crop_offset="$2" ;;
"--xoffset") xoffset="$2" ;;
"--yoffset") yoffset="$2" ;;
"--background_color" | "--bg_color") background_color="$2" ;;
"--gap") gap="$2" ;;
"--clean")
[[ -d "$thumbnail_dir" ]] && rm -rf "$thumbnail_dir"
2016-08-13 21:13:21 -06:00
rm -rf "/Library/Caches/neofetch/"
2016-10-26 06:50:54 -06:00
rm -rf "/tmp/neofetch/"
2016-08-13 21:13:21 -06:00
exit
;;
2016-11-15 04:27:36 -07:00
"--ascii_colors")
2016-08-13 21:13:21 -06:00
unset ascii_colors
for arg in "$2" "$3" "$4" "$5" "$6" "$7"; do
case "$arg" in
2016-10-03 15:48:33 -06:00
"-"*) break ;;
2018-04-13 17:49:12 -06:00
*) ascii_colors+=("$arg")
2016-08-13 21:13:21 -06:00
esac
done
ascii_colors+=(7 7 7 7 7 7)
;;
2016-08-11 18:41:52 -06:00
2016-11-15 04:27:36 -07:00
"--ascii_distro")
2016-11-12 21:33:28 -07:00
image_backend="ascii"
2016-08-13 21:13:21 -06:00
ascii_distro="$2"
2016-10-03 15:48:33 -06:00
case "$2" in "-"* | "") ascii_distro="$distro" ;; esac
2016-08-13 21:13:21 -06:00
;;
2016-11-15 04:27:36 -07:00
"--ascii_bold") ascii_bold="$2" ;;
"--logo" | "-L")
2016-11-12 21:33:28 -07:00
image_backend="ascii"
print_info() { info line_break; }
2016-10-03 04:51:42 -06:00
;;
2016-08-13 21:13:21 -06:00
# Screenshot
2016-11-15 04:27:36 -07:00
"--scrot" | "-s")
2016-10-02 06:58:08 -06:00
scrot_args "$@"
2016-08-13 21:13:21 -06:00
;;
2016-11-15 04:27:36 -07:00
"--upload" | "-su")
scrot_upload="on"
2016-10-02 06:58:08 -06:00
scrot_args "$@"
;;
2016-10-02 06:58:08 -06:00
2016-11-15 04:27:36 -07:00
"--image_host") image_host="$2" ;;
"--scrot_cmd") scrot_cmd="$2" ;;
2016-08-13 21:13:21 -06:00
# Other
2016-11-15 04:27:36 -07:00
"--config")
2016-08-13 21:13:21 -06:00
case "$2" in
2017-01-15 03:53:55 -07:00
"none" | "off" | "") ;;
*)
config_file="$(get_full_path "$2")"
get_user_config
;;
2016-08-13 21:13:21 -06:00
esac
;;
2017-08-03 02:16:52 -06:00
"--stdout") stdout="on" ;;
2016-11-15 04:27:36 -07:00
"-v") verbose="on" ;;
"-vv") set -x; verbose="on" ;;
"--help") usage ;;
2018-04-13 17:32:12 -06:00
"--version")
printf "%s\\n" "Neofetch $version"
exit 1
;;
2017-08-01 19:47:15 -06:00
"--gen-man")
help2man -n "A fast, highly customizable system info script" \
-N ./neofetch -o neofetch.1
exit 1
;;
2016-08-13 21:13:21 -06:00
esac
2015-12-30 03:18:17 -07:00
2016-08-13 21:13:21 -06:00
shift
done
}
2015-12-30 03:18:17 -07:00
2016-08-12 04:53:04 -06:00
main() {
cache_uname
get_os
get_default_config
get_args "$@"
[[ "$verbose" != "on" ]] && exec 2>/dev/null
get_distro
2016-11-13 03:29:25 -07:00
get_bold
2016-11-13 02:21:32 -07:00
get_distro_colors
2017-08-03 02:16:52 -06:00
[[ "$stdout" == "on" ]] && stdout
# Minix doesn't support these sequences.
2017-08-03 02:16:52 -06:00
if [[ "$TERM" != "minix" && "$stdout" != "on" ]]; then
# If the script exits for any reason, unhide the cursor.
trap 'printf "\e[?25h\e[?7h"' EXIT
2016-04-12 23:31:53 -06:00
2016-12-20 03:17:40 -07:00
# Hide the cursor and disable line wrap.
printf "\e[?25l\e[?7l"
fi
2016-01-29 23:44:52 -07:00
2017-01-14 02:59:12 -07:00
image_backend
old_functions
2016-12-02 02:06:43 -07:00
get_cache_dir
print_info
2016-12-11 23:41:35 -07:00
dynamic_prompt
2016-12-11 23:41:35 -07:00
# w3m-img: Draw the image a second time to fix
# rendering issues in specific terminal emulators.
[[ "$image_backend" == *w3m* ]] && display_image
2016-12-20 03:17:40 -07:00
# Take a screenshot.
[[ "$scrot" == "on" ]] && take_scrot
# Add neofetch info to verbose output.
err "Neofetch command: $0 $*"
err "Neofetch version: $version"
err "Neofetch config: $config_version"
2016-12-20 03:17:40 -07:00
# Show error messages.
2016-12-20 04:36:54 -07:00
[[ "$verbose" == "on" ]] && printf "%b" "$err" >&2
2017-04-25 15:39:10 -06:00
# If `--loop` was used, constantly redraw the image.
while [[ "$image_loop" == "on" && "$image_backend" == "w3m" ]]; do display_image; sleep 1s; done
2016-11-11 00:42:51 -07:00
return 0
}
2017-05-20 06:10:49 -06:00
main "$@"