hyfetch/neofetch

4384 lines
141 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.
2017-04-25 19:48:22 -06:00
version="3.1.0-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}"
2017-01-07 18:26:59 -07:00
old_ifs="$IFS"
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
# Add /usr/xpg4/bin, /usr/sbin, and /sbin to PATH.
export PATH="/usr/xpg4/bin:/usr/sbin:/sbin:${PATH}"
2016-12-17 02:20:38 -07:00
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.
2016-11-13 02:21:32 -07:00
reset="\033[0m"
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" ;;
2017-04-26 21:37:33 -06:00
"IRIX64") os="IRIX" ;;
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")
if [[ "$(< /proc/version)" == *"Microsoft"* || "$kernel_version" == *"Microsoft"* ]]; then
case "$distro_shorthand" in
2016-11-04 22:06:45 -06:00
"on") distro="$(lsb_release -sir) [Windows 10]" ;;
"tiny") distro="Windows 10" ;;
2016-11-04 22:06:45 -06:00
*) distro="$(lsb_release -sd) on Windows 10" ;;
esac
2017-04-24 12:49:34 -06:00
elif [[ "$(< /proc/version)" == *"cros"* || -f "/dev/cros_ec" ]]; then
case "$distro_shorthand" in
"on") distro="$(lsb_release -sir) [Chrome OS]" ;;
"tiny") distro="Chrome OS" ;;
*) distro="$(lsb_release -sd) on Chrome OS" ;;
esac
2016-12-02 04:18:55 -07:00
elif [[ -f "/etc/GoboLinuxVersion" ]]; then
case "$distro_shorthand" in
"on" | "tiny") distro="GoboLinux" ;;
*) distro="GoboLinux $(< /etc/GoboLinuxVersion)"
esac
elif [[ -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 type -p lsb_release >/dev/null; then
case "$distro_shorthand" in
"on") lsb_flags="-sir" ;;
"tiny") lsb_flags="-si" ;;
*) lsb_flags="-sd" ;;
esac
distro="$(lsb_release $lsb_flags)"
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-03-09 11:55:06 -07:00
2017-05-17 18:47:46 -06:00
elif type -p kpm > /dev/null; then
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)"
elif [[ -f "/etc/os-release" || -f "/usr/lib/os-release" ]]; then
# Source the os-release file
for file in /etc/os-release /usr/lib/os-release; do
2016-12-16 17:35:35 -07:00
source "$file" 2>/dev/null && 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.
2016-12-27 19:03:58 -07:00
[[ -z "${distro// }" ]] && distro="$(awk '/BLAG/ {print $1; exit}' /etc/os-release /usr/lib/os-release)"
[[ -z "${distro// }" ]] && distro="$(awk -F'=' '{print $2; exit}' /etc/os-release /usr/lib/os-release)"
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"
[[ -f "/etc/rc.conf.trueos" ]] && distro="TrueOS"
[[ -f "/etc/pacbsd-release" ]] && distro="PacBSD" # /etc/pacbsd-release is an empty file
fi
fi
distro="$(trim_quotes "$distro")"
;;
"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-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}" ;;
2016-10-17 06:48:30 -06:00
"10.12"*) 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}"
;;
esac
[[ -z "$distro" ]] && distro="$os (Unknown)"
2016-12-20 03:17:40 -07:00
# Get OS architecture.
2017-06-09 11:54:50 -06:00
if [[ "$os_arch" == "on" ]]; then
case "$os" in
2017-06-10 00:27:23 -06:00
"Solaris" | "AIX" | "BSD" | "Haiku" | "IRIX") machine_arch="$(uname -p)" ;;
2017-06-09 11:54:50 -06:00
*) machine_arch="$(uname -m)" ;;
esac
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-05-30 03:05:33 -06:00
"Mac OS X")
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" ;;
"iPad2,"[1-4]) model="iPad2" ;;
"iPad3,"[1-3]) model="iPad3" ;;
"iPad3,"[4-6]) model="iPad4" ;;
"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)" ;;
"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" ;;
"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="$(prtconf | awk -F':' '/System Model/ {printf $2}')"
;;
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}"
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
2016-11-04 15:46:29 -06:00
"Mac OS X" | "iPhone OS" | "BSD")
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
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() {
# Remove /usr/games from $PATH.
2016-12-20 03:17:40 -07:00
# This solves issues with neofetch opening the "pacman" game.
local PATH=":${PATH}:"
local PATH="${PATH/':/usr/games:'/:}"
local PATH="${PATH%:}"
local PATH="${PATH#:}"
case "$os" in
"Linux" | "BSD" | "iPhone OS" | "Solaris")
2016-11-04 22:06:45 -06:00
type -p pacman >/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$)))"
2016-04-11 19:17:21 -06:00
2017-05-17 18:47:46 -06:00
type -p kpm >/dev/null && \
packages="$((packages+=$(kpm --get-selections | grep -cv deinstall$)))"
2016-04-11 19:17:21 -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-04 22:06:45 -06:00
type -p cave >/dev/null && \
2016-12-06 06:35:27 -07:00
packages="$((packages+=$(ls -d -1 /var/db/paludis/repositories/cross-installed/*/data/* /var/db/paludis/repositories/installed/data/* | wc -l)))"
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
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))"
;;
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
*)
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
;;
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}"
elif [[ "$DESKTOP_SESSION" ]]; then
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"
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.
[[ -n "$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/* = }" ;;
*"TDE_FULL_SESSION"*) de="Trinity" ;;
*"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" ;;
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
2016-11-06 04:12:35 -07:00
if [[ -n "$DISPLAY" && "$os" != "Mac OS X" ]]; then
2016-11-04 22:06:45 -06:00
id="$(xprop -root -notype | awk '$1=="_NET_SUPPORTING_WM_CHECK:"{print $5}')"
wm="$(xprop -id "$id" -notype -f _NET_WM_NAME 8t)"
2016-06-11 23:51:48 -06:00
wm="${wm/*_NET_WM_NAME = }"
wm="${wm/\"}"
wm="${wm/\"*}"
2016-02-16 22:54:18 -07:00
2016-12-20 03:17:40 -07:00
# Fallback for Wayland wms.
[[ "$wm" == "xwlc" ]] && \
wm="$(ps -e | grep -m 1 -o -F -e "sway" -e "orbment" -e "velox" -e "orbital")"
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')"
2017-03-26 16:50:52 -06:00
2017-03-21 17:58:47 -06:00
case "$ps_line" in
*"kwm"*) wm="Kwm" ;;
*"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")
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"
;;
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
"E16") wm_theme="$(awk -F "= " '/theme.name/ {print $2}' "${HOME}/.e16/e_config--0.0.cfg")";;
"Sawfish") wm_theme="$(awk -F ")" '/\(quote default-frame-style/ {print $2}' "${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
wm_theme="$(eet -d "${HOME}/.e/e/config/standard/e.cfg" config | 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
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" ]] && \
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
2016-03-31 21:50:15 -06:00
if [[ -f "${kde_config_dir}/kwinrc" ]]; then
wm_theme="$(awk '/theme=kwin4/{gsub(/theme=kwin4_decoration_qml_/,"",$0); print $0; exit}' "${kde_config_dir}/kwinrc")"
[[ -z "$wm_theme" ]] && wm_theme="$(awk '/library=org.kde/{gsub(/library=org.kde./,"",$0); print $0; exit}' "${kde_config_dir}/kwinrc")"
[[ -z "$wm_theme" ]] && wm_theme="$(awk '/PluginLib=kwin3_/{gsub(/PluginLib=kwin3_/,"",$0); print $0; exit}' "${kde_config_dir}/kwinrc")"
2016-03-31 21:50:15 -06:00
elif [[ -f "${kde_config_dir}/kdebugrc" ]]; then
wm_theme="$(awk '/(decoration)/ {gsub(/\[/,"",$1); print $1; exit}' "${kde_config_dir}/kdebugrc")"
2016-03-31 21:50:15 -06:00
fi
;;
2016-11-01 22:56:00 -06:00
"Quartz Compositor")
wm_theme="$(/usr/libexec/PlistBuddy -c "Print AppleAquaColorVariant" ~/Library/Preferences/.GlobalPreferences.plist)"
2017-01-03 05:28:05 -07:00
if [[ -z "$wm_theme" ]] || ((wm_theme == 1)); then
wm_theme="Blue"
2016-03-31 18:44:20 -06:00
else
wm_theme="Graphite"
2016-03-31 18:44:20 -06:00
fi
;;
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.
case "$distro" in
2016-08-29 18:26:13 -06:00
"Android"*) cpu="$(getprop ro.product.board)" ;;
*)
case "$machine_arch" in
"frv" | "hppa" | "m68k" | "openrisc" | "or"* | "powerpc" | "ppc"* | "sparc"*)
cpu="$(awk -F':' '/^cpu\t|^CPU/ {printf $2; exit}' /proc/cpuinfo)"
;;
"s390"*)
cpu="$(awk -F'=' '/machine/ {print $4; exit}' /proc/cpuinfo)"
;;
"ia64" | "m32r")
cpu="$(awk -F':' '/model/ {print $2; exit}' /proc/cpuinfo)"
[[ -z "$cpu" ]] && cpu="$(awk -F':' '/family/ {printf $2; exit}' /proc/cpuinfo)"
;;
*)
cpu="$(awk -F ': | @' '/model name|Processor|^cpu model|chip type|^cpu type/ {printf $2; exit}' /proc/cpuinfo)"
;;
esac
;;
esac
2016-10-22 16:45:03 -06:00
speed_dir="/sys/devices/system/cpu/cpu0/cpufreq"
temp_dir="/sys/class/hwmon/hwmon0/temp1_input"
2016-12-20 03:17:40 -07:00
# Get CPU speed.
if [[ -d "$speed_dir" ]]; then
# Fallback to bios_limit if $speed_type fails.
2016-10-22 18:13:40 -06:00
speed="$(< "${speed_dir}/${speed_type}")" || \
2016-12-03 01:33:36 -07:00
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
2016-06-11 23:51:48 -06:00
speed="$(awk -F ': |\\.' '/cpu MHz/ {printf $2; exit}' /proc/cpuinfo)"
fi
2016-12-20 03:17:40 -07:00
# Get CPU temp.
if [[ "$cpu_temp" != "off" && -f "$temp_dir" ]]; then
2016-10-22 16:45:03 -06:00
temp="$(< "$temp_dir")"
temp="$((temp * 100 / 10000))"
# Convert to fahrenheit if enabled.
[[ "$cpu_temp" == "F" ]] && temp="$((temp * 90 / 50 + 320))"
# Format the output.
temp="[${temp/${temp: -1}}.${temp: -1}°${cpu_temp:-C}]"
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
2016-12-05 18:03:09 -07:00
"logical" | "on") cores="$(grep -c "^processor" /proc/cpuinfo)" ;;
2016-10-20 23:38:02 -06:00
"physical") cores="$(grep "^core id" /proc/cpuinfo | 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.
if [[ "$cpu_temp" != "off" ]]; then
case "$kernel_name" in
"FreeBSD"* | "DragonFly"*)
2016-11-26 00:43:59 -07:00
temp="$(sysctl -n dev.cpu.0.temperature)"
temp="${temp/C}"
2016-11-26 00:43:59 -07:00
;;
"OpenBSD"* | "Bitrig"*)
temp="$(sysctl -n hw.sensors.lm0.temp0)"
temp="${temp/ degC}"
2016-11-26 00:43:59 -07:00
;;
esac
# Convert to fahrenheit if enabled.
if [[ "$cpu_temp" == "F" ]]; then
temp="${temp//.}"
temp="$((temp * 90 / 50 + 320))"
temp="[${temp/${temp: -1}}.${temp: -1}°F]"
else
temp="[${temp}°C]"
fi
2016-11-26 00:43:59 -07:00
fi
;;
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="$(prtconf | awk -F':' '/Processor Type/ {printf $2}')"
# Get CPU speed.
speed="$(prtconf | awk -F':' '/Processor Clock Speed/ {printf $2}')"
speed="${speed/MHz}"
# Get CPU cores.
case "$cpu_cores" in
"logical" | "on") cores="$(lparstat -i | awk -F':' '/Online Virtual CPUs/ {printf $2}')" ;;
"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
;;
2016-11-06 00:08:09 -06:00
esac
2016-11-04 18:46:08 -06:00
2016-12-13 17:45:33 -07:00
if [[ "$speed" ]]; then
# Hide decimals if on.
[[ "$speed_shorthand" == "on" ]] && \
speed="$((speed / 100))"
# Fix for speeds under 1ghz.
2016-12-13 17:45:33 -07:00
if [[ -z "${speed:1}" ]]; then
speed="0.${speed}"
else
speed="${speed:0:1}.${speed:1}"
fi
2016-11-04 18:46:08 -06:00
2016-12-13 17:45:33 -07:00
cpu="$cpu @ ${speed}GHz $temp"
fi
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}"
2016-11-11 01:14:36 -07:00
cpu="${cpu//Core}"
2016-11-24 02:25:30 -07:00
cpu="${cpu//with Radeon * Graphics}"
cpu="${cpu//, altivec supported}"
cpu="${cpu//FPU*}"
2016-03-12 05:01:20 -07:00
2017-01-09 04:50:28 -07:00
# Trim spaces from core output
cores="${cores//[[:space:]]}"
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" ]] && \
cpu="${cpu/@/(${cores}) @}"
2016-03-15 01:55:35 -06:00
2016-12-20 03:17:40 -07:00
# Remove CPU speed from the output.
[[ "$cpu_speed" == "off" ]] && \
2016-10-22 16:45:03 -06:00
cpu="${cpu/@ *GHz}"
2016-12-20 03:17:40 -07:00
# Make the output of CPU shorter.
2016-03-12 05:01:20 -07:00
case "$cpu_shorthand" in
2016-06-11 23:51:48 -06:00
"name") cpu="${cpu/@*}" ;;
"speed") cpu="${cpu#*@ }" ;;
2016-03-12 05:01:20 -07:00
"on" | "tiny")
2016-12-13 17:57:02 -07:00
cpu="${cpu/AMD }"
2016-06-11 23:51:48 -06:00
cpu="${cpu/Intel }"
cpu="${cpu/Core? Duo }"
2016-03-12 05:01:20 -07:00
2016-12-13 17:40:29 -07:00
[[ "$cpu_shorthand" == "tiny" ]] && cpu="${cpu/@*}"
2016-03-12 05:01:20 -07:00
;;
esac
}
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}')" ;;
2017-05-22 03:50:24 -06:00
"IRIX") cores="$(sysconf NPROC_ONLN)"
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.
2017-01-07 18:26:59 -07:00
IFS=$'\n'
2017-04-26 17:09:36 -06:00
gpus=($(lspci -mm | awk -F '\\"|\\" \\"' '/"Display|"3D|"VGA/ {print $3 " " $4}'))
2017-01-07 18:26:59 -07:00
IFS="$old_ifs"
# Number the GPUs if more than one exists.
2017-01-04 06:36:04 -07:00
((${#gpus[@]} > 1)) && gpu_num=1
for gpu in "${gpus[@]}"; do
# GPU shorthand tests.
2016-12-21 19:23:48 -07:00
[[ "$gpu_type" == "dedicated" && "$gpu" =~ (i|I)ntel ]] || \
[[ "$gpu_type" == "integrated" && ! "$gpu" =~ (i|I)ntel ]] && \
{ 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"*)
2017-01-23 02:37:03 -07:00
gpu="$(glxinfo | grep "Device:.*Intel")"
2017-01-23 02:34:13 -07:00
gpu="${gpu/*Intel/Intel}"
gpu="${gpu/'(R)'}"
gpu="${gpu/ \(*}"
[[ -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"
((++gpu_num))
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
gpu="$(system_profiler SPDisplaysDataType | awk -F': ' '/^\ *Chipset Model:/ {printf $2 ", "}')"
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")
gpu="$(listdev | grep -A2 -F 'device Display controller' | 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}))" ;;
"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 }')"
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
"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
;;
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}"
;;
"OpenBSD"*) ;;
*) mem_free="$(($(vmstat | awk 'END{printf $5}') / 1024))" ;;
esac
2016-12-20 03:17:40 -07:00
# Mem used.
case "$kernel_name" in
"OpenBSD"*) mem_used="$(($(vmstat | awk 'END{printf $4}') / 1024))" ;;
*) 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")
mem_stat=($(svmon -G -O unit=MB))
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")
mem_stat=($(pmem | head -1))
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))"
;;
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() {
2016-10-26 01:22:08 -06:00
# This is absurdly long.
player="$(ps x | awk '!(/ awk|Helper|Cache|ibus|indicator/) && /mpd|mopidy|cmus|mocp|spotify|Google Play|iTunes.app|rhythmbox|banshee|amarok|deadbeef|audacious|xmms2d|gnome-music|lollypop|clementine|pragha|exaile|juk|bluemindo|guayadeque|yarock|qmmp|quodlibet|deepin-music|tomahawk/ {printf $5 " " $6; exit}')"
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 \
org.freedesktop.DBus.Properties.Get string:'org.mpris.MediaPlayer2.Player' string:'Metadata' |\
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-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"*)
2016-12-27 04:28:19 -07:00
song="$(cmus-remote -Q | awk '/tag artist/ {$1=$2=""; print; print " - "} /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 -e 'tell application "Spotify" to artist of current track as string & " - " & name of current track as string')"
;;
esac
;;
2016-09-04 06:28:08 -06:00
2016-10-26 04:18:46 -06:00
"itunes"*)
2016-10-25 22:18:11 -06:00
song="$(osascript -e 'tell application "iTunes" to artist of current track as string & " - " & name of current track as string')"
;;
2016-10-25 22:18:11 -06:00
"banshee"*)
2017-01-05 06:50:39 -07: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-01-05 06:50:39 -07: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"*)
song="$(dbus-send --print-reply --dest=net.sacredchao.QuodLibet /net/sacredchao/QuodLibet net.sacredchao.QuodLibet.CurrentSong |\
awk -F'"' '/artist/ {getline; a=$2} /title/ {getline; t=$2} END{print a " - " t}')"
;;
*)
2017-01-23 16:31:53 -07: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
2016-11-06 00:35:59 -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
scale_factor="$(/usr/libexec/PlistBuddy -c "Print DisplayAnyUserSets:0:0:Resolution" /Library/Preferences/com.apple.windowserver.plist)"
# If no refresh rate is empty.
2016-12-08 01:24:58 -07:00
[[ "$resolution" == *"@ Hz"* ]] && \
resolution="${resolution//@ Hz}"
2017-01-04 06:36:04 -07:00
((${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
"on") resolution="$(xrandr --nograb --current | awk 'match($0,/[0-9]*\.[0-9]*\*/) {printf $1 " @ " substr($0,RSTART,RLENGTH) "Hz, "}')" ;;
"off") resolution="$(xrandr --nograb --current | awk '/\*/ {printf $1 ", "}')" ;;
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
2016-11-06 04:12:35 -07:00
if [[ -n "$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
2016-12-22 00:57:01 -07:00
theme="$(grep "^[^#]*${kde}" "$kde_config_file")"
2016-06-11 23:51:48 -06:00
theme="${theme/${kde}*=}"
2016-11-15 18:20:14 -07:00
theme="$(uppercase "$theme")"
gtk_shorthand="on"
2016-12-22 00:57:01 -07:00
else
err "Theme: KDE config files not found, skipping."
fi
2016-12-22 00:57:01 -07:00
return
;;
*"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.
2016-11-15 18:20:14 -07:00
if [[ "$gtk2_theme" && "$gtk2_theme" == "$gtk3_theme" ]]; then
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.
2016-11-15 18:20:14 -07:00
theme="${gtk2_theme}${gtk3_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]'}"
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="widgetStyle"
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
# Check $PPID for terminal emulator.
while [[ -z "$term" ]]; do
if [[ "$SSH_CONNECTION" ]]; then
term="$SSH_TTY"
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)" ;;
"ruby" | "1" | "systemd" | "sshd"* | "python"* | "USER"*"PID"*) break ;;
"gnome-terminal-") term="gnome-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-01-01 17:50:29 -07:00
((term_run != 1)) && get_term
2016-05-16 05:35:29 -06:00
case "$term" in
"alacritty"*)
term_font="$(awk -F ':|#' '/normal:/ {getline; print}' "${XDG_CONFIG_HOME}/alacritty/alacritty.yml")"
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 -e 'tell application "Terminal" to font name of window frontmost')"
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
# that identifies an active profile. There is the "id of current session of current window"
# thou, 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-03-08 15:19:03 -07:00
local current_profile_name
current_profile_name="$(osascript -e 'tell application "iTerm2" to profile name of current session of current window')"
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-03-01 17:45:46 -07:00
# Count Guids in "New Bookmarks"; they should be unique
2017-03-08 15:19:03 -07:00
local profiles_count
profiles_count="$(/usr/libexec/PlistBuddy -c "Print :New\ Bookmarks:" ~/Library/Preferences/com.googlecode.iterm2.plist 2>/dev/null | 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
local profile_name
profile_name="$(/usr/libexec/PlistBuddy -c "Print :New\ Bookmarks:${i}:Name:" ~/Library/Preferences/com.googlecode.iterm2.plist 2>/dev/null)"
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-03-08 15:19:03 -07:00
term_font="$(/usr/libexec/PlistBuddy -c "Print :New\ Bookmarks:${i}:Normal\ Font:" ~/Library/Preferences/com.googlecode.iterm2.plist)"
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-03-08 15:19:03 -07:00
local use_different_font
use_different_font="$(/usr/libexec/PlistBuddy -c "Print :New\ Bookmarks:${i}:Use\ Non-ASCII\ Font:" ~/Library/Preferences/com.googlecode.iterm2.plist)"
2017-03-08 17:13:31 -07:00
2017-03-08 15:19:03 -07:00
if [[ "$use_different_font" == "true" ]]; then
local non_ascii_font
non_ascii_font="$(/usr/libexec/PlistBuddy -c "Print :New\ Bookmarks:${i}:Non\ Ascii\ Font:" ~/Library/Preferences/com.googlecode.iterm2.plist)"
2017-03-08 17:17:31 -07:00
2017-03-08 15:19:03 -07:00
[[ "$term_font" != "$non_ascii_font" ]] && \
term_font="$term_font (normal) / $non_ascii_font (non-ascii)"
2017-03-01 17:45:46 -07:00
fi
fi
done
;;
"deepin-terminal"*)
term_font="$(awk -F '=' '/font=/ {a=$2} /font_size/ {b=$2} END{print a " " b}' "${XDG_CONFIG_HOME}/deepin/deepin-terminal/config.conf")"
;;
2016-11-04 16:52:11 -06:00
"Hyper"*)
term_font="$(awk -F "," '/fontFamily/ {a=$1} END{print a}' "${HOME}/.hyper.js" | awk -F "'" '{a=$2} END{print a}')"
;;
2016-12-23 12:45:08 -07:00
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
profile="$(qdbus "${i}" "${session}" environment | awk -F '=' '/KONSOLE_PROFILE_NAME/ {print $2}')"
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'*}"
[[ "$profile_filename" ]] && term_font="$(awk -F '=|,' '/Font=/ {print $2 " " $3}' "$profile_filename")"
2016-12-24 03:46:14 -07:00
;;
"mate-terminal")
# 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##*= }"
term_id="$(grep -A1 "${role//\"}" "$mateterm_config")"
term_id="${term_id##*=}"
profile="$(grep -A1 "\[$term_id\]" "$mateterm_config")"
profile="${profile##*=}"
rm -f "$mateterm_config"
if [[ "$(gsettings get org.mate.terminal.profile:/org/mate/terminal/profiles/"${profile}"/ use-system-font)" == "true" ]]; then
term_font="$(gsettings get org.mate.interface monospace-font-name)"
else
term_font="$(gsettings get org.mate.terminal.profile:/org/mate/terminal/profiles/"${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)"
[[ -z "${term_font//\'}" ]] && term_font="$(gsettings get org.gnome.desktop.interface monospace-font-name)"
term_font="$(trim_quotes "$term_font")"
;;
"sakura"*)
term_font="$(awk -F '=' '/^font=/ {a=$2} END{print a}' "${XDG_CONFIG_HOME}/sakura/sakura.conf")"
;;
"terminology")
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")
[[ -f "${XDG_CONFIG_HOME}/termite/config" ]] && termite_config="${XDG_CONFIG_HOME}/termite/config"
term_font="$(awk -F '= ' '/\[options\]/ {opt=1} /^\s*font/ {if(opt==1) a=$2; opt=0} END{print a}' "/etc/xdg/termite/config" "$termite_config")"
;;
"urxvt" | "urxvtd" | "rxvt-unicode" | "xterm")
term_font="$(grep -i -F "${term/d}*font" < <(xrdb -query))"
term_font="${term_font/*font:}"
term_font="$(trim "$term_font")"
# 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")
term_font="$(awk -F '=' '/^FontName/ {a=$2} END{print a}' "${XDG_CONFIG_HOME}/xfce4/terminal/terminalrc")"
;;
2016-05-16 05:35:29 -06:00
esac
}
get_disk() {
2017-01-08 05:05:13 -07:00
type -p df >/dev/null 2>&1 || \
{ 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
*"blocks"*) err "Your version of df cannot be used due to the non-standard flags" ; return ;; # Haiku
*"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.
2017-01-07 18:26:59 -07:00
IFS=$'\n'
2017-01-10 14:15:28 -07:00
disks=($(df "${df_flags[@]}" "${disk_show[@]:-/}" 2>/dev/null))
unset 'disks[0]'
2017-01-07 18:26:59 -07:00
IFS="$old_ifs"
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.
[[ -z "${disks[@]}" ]] && \
{ err "Disk: df failed to print the disks, make sure the disk_show array is set properly."; return; }
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.
2017-01-06 00:53:26 -07:00
disk_info=($disk)
disk_perc="${disk_info[4]/'%'}"
case "$df_version" in
*"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}*; 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}"
[[ "$(trim "$battery")" ]] && 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
*"BusyBox"*) install_date="$(ls -tdce "$install_file" | awk '{printf $10 " " $7 " " $8 " " $9}')" ;;
2017-01-01 21:18:01 -07:00
*"crtime"*) install_date="$(ls -tdcE "$install_file" | awk '{printf $6 " " $7}')" ;; # xpg4 (Solaris)
*"ACFHLRSZ"*) install_date="$(ls -dl "$install_file" | awk '{printf $6 " " $7}')" ;; # Toybox
*"GNU coreutils"*) install_date="$(ls -tcd --full-time "$install_file" | awk '{printf $6 " " $7}')" ;;
*"ACFHLNRS"* | *"RadC1xmnlog"*) err "Install Date doesn't work because your 'ls' does not support showing full date and time."; return ;; # AIX ls / IRIX ls
*) install_date="$(ls -dlctT "$install_file" | awk '{printf $9 " " $6 " "$7 " " $8}')" ;;
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%:*}"
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"
}
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
2016-10-15 17:44:05 -06:00
[0-6]) blocks+="${reset}\033[3${start}m\033[4${start}m${block_width}" ;;
7) blocks+="${reset}\033[3${start}m\033[4${start}m${block_width}" ;;
*) blocks2+="\033[38;5;${start}m\033[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'}"
2016-11-12 21:12:22 -07:00
cols="${cols//nl/\\n\\033[${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))"
2016-12-18 21:29:39 -07:00
printf "%b\n" "\033[${text_padding}C${zws}${cols}"
fi
2016-12-18 21:25:48 -07:00
unset -v blocks blocks2 cols
# 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-02-08 16:36:21 -07:00
"caca" | "catimg" | "jp2a" | "iterm2" | "termpix" | "tycat" | "w3m" | "sixel")
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
clear
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
display_image 2>/dev/null
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'."
2017-02-08 16:36:21 -07:00
err "Image: Valid backends are: 'ascii', 'caca', 'catimg', 'jp2a', 'iterm2', 'off', 'sixel', '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.
2016-12-22 02:39:43 -07:00
[[ "$image_backend" != "off" ]] && printf "%b" "\033[${lines:-0}A\033[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."
2017-01-01 22:40:30 -07:00
if [[ -d "/usr/share/neofetch/ascii/distro" ]]; then
ascii_dir="/usr/share/neofetch/ascii/distro"
2017-01-01 22:40:30 -07:00
elif [[ -d "/usr/local/share/neofetch/ascii/distro" ]]; then
ascii_dir="/usr/local/share/neofetch/ascii/distro"
2017-01-01 22:40:30 -07:00
elif [[ -d "/data/data/com.termux/files/usr/share/neofetch/ascii/distro" ]]; then
ascii_dir="/data/data/com.termux/files/usr/share/neofetch/ascii/distro"
2017-01-26 04:46:39 -07:00
elif [[ -d "/boot/home/config/non-packaged/share/neofetch/ascii/distro" ]]; then
ascii_dir="/boot/home/config/non-packaged/share/neofetch/ascii/distro"
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.
2016-11-06 05:00:09 -07:00
while IFS=$'\n' read -r line 2>/dev/null; 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//\$\{??\}}"
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")
2017-01-14 02:59:12 -07:00
get_wallpaper 2>/dev/null
;;
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
2017-01-14 02:59:12 -07:00
files=("${image_source%/}"/*.{png,jpg,jpeg,jpe,gif})
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 -e 'tell application "System Events" to picture of current desktop')"
;;
"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
2016-12-04 19:37:32 -07:00
case "$de" in
"MATE"*) image="$(gsettings get org.mate.background picture-filename)" ;;
2017-01-17 14:47:17 -07: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
*)
if type -p feh >/dev/null && [[ -f "${HOME}/.fehbg" ]]; then
image="$(awk -F\' '/feh/ {printf $2}' "${HOME}/.fehbg")"
2016-11-12 06:30:09 -07:00
2016-12-04 19:37:32 -07:00
elif type -p nitrogen >/dev/null; then
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-01-14 15:18:17 -07: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-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
2016-11-06 05:00:09 -07:00
printf "%b" "\033Ptmux;\033\033[14t\033\033[c\033\\"
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
2016-11-06 05:00:09 -07:00
printf "%b" "\033}qs\000"
2016-06-10 01:58:24 -06:00
2016-02-20 17:32:02 -07:00
else
2016-11-06 05:00:09 -07:00
printf "%b" "\033[14t\033[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
2016-12-20 03:17:40 -07:00
# Get terminal width/height if \033[14t is unsupported.
if [[ -z "$term_width" ]]; 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
current_window="$(xprop -root | awk '/_NET_ACTIVE_WINDOW\(WINDOW\)/{print $NF}')"
fi
2016-11-12 21:12:22 -07:00
# If the ID was found get the window size.
if [[ "$current_window" ]]; then
term_size="$(xwininfo -id "$current_window" | awk -F ': ' '/Width|Height/ {printf $2 " "}')"
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.
2016-12-20 03:17:40 -07:00
# Get terminal lines and columns.
2016-08-18 18:29:27 -06:00
term_blocks="$(stty size)"
columns="${term_blocks/* }"
lines="${term_blocks/ *}"
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.
2016-11-12 21:33:28 -07:00
size="$(identify -format "%w %h" "$image")"
2016-06-11 23:51:48 -06:00
width="${size%% *}"
height="${size##* }"
crop_mode="none"
;;
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.
2016-11-12 21:33:28 -07:00
image_name="$crop_mode-$crop_offset-$width-$height"
2016-11-12 21:12:22 -07:00
# Check to see if the image has a file extension,
# if it doesn't then add one.
2016-11-12 21:33:28 -07:00
case "${image##*/}" in
*"."*) image_name="${image_name}-${image##*/}" ;;
*) image_name="${image_name}-${image##*/}.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
2016-11-12 21:33:28 -07:00
size="$(identify -format "%w %h" "$image")"
2016-06-11 23:51:48 -06:00
og_width="${size%% *}"
og_height="${size##* }"
2016-12-18 20:53:38 -07:00
# This checks to see if height is greater than width
2016-05-27 22:07:19 -06:00
# so we can do a better crop of portrait images.
2016-06-11 23:51:48 -06:00
size="$og_height"
2017-01-04 06:36:04 -07:00
((og_height > og_width)) && size="$og_width"
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 \
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 \
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 \
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-02-08 16:23:21 -07: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")
2017-01-22 16:12:26 -07:00
catimg -w "$((width * 2 / font_width))" -r 0 "$image" || to_off "Image: catimg failed to display the image."
2017-01-14 06:15:33 -07:00
;;
"jp2a")
jp2a --width="$((width / font_width))" --colors "$image" || to_off "Image: jp2a failed to display the image."
2017-02-08 16:23:21 -07:00
;;
"sixel")
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")
termpix --width "$((width / font_width))" "$image" || to_off "Image: termpix failed to display the image."
;;
2016-11-12 06:30:09 -07:00
"iterm2")
iterm_cmd="\033]1337;File=width=${width}px;height=${height}px;inline=1:$(base64 < "$image")"
# Tmux requires an additional escape sequence for this to work.
[[ -n "$TMUX" ]] && iterm_cmd="\033Ptmux;\033${iterm_cmd}\033\\"
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")
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;" |\
"${w3m_img_path:-false}" -bg "$background_color" >/dev/null & 2>&1 || to_off "Image: w3m-img failed to display the image."
2017-02-08 16:23:21 -07:00
2017-05-06 17:55:24 -06:00
zws="\xE2\x80\x8B\x20"
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 2>/dev/null
2016-12-22 02:39:43 -07:00
2017-01-14 04:53:36 -07:00
# Set cursor position next image/ascii.
2016-12-22 02:39:43 -07:00
printf "%b" "\033[${lines:-0}A\033[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() {
2017-03-26 15:29:04 -06:00
scrot_program "${scrot_dir}${scrot_name}" 2>/dev/null
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")
2016-12-05 01:40:56 -07: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")
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
2016-12-11 23:59:54 -07:00
scrot_program=("$scrot_cmd")
2016-12-04 21:14:44 -07:00
elif type -p scrot >/dev/null; then
2016-12-11 23:59:54 -07:00
scrot_program=(scrot)
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 import >/dev/null; 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}" 2>/dev/null
# 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
2017-01-27 09:01:11 -07:00
string="$(trim "${string//$'\033[0m'}")"
# 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:+\033[${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"
2017-01-27 13:30:13 -07:00
printf "%b\n" "${text_padding:+\033[${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="\033[1m" ;;
"off") ascii_bold="" ;;
esac
case "$bold" in
"on") bold="\033[1m" ;;
"off") bold="" ;;
esac
}
trim() {
2016-12-20 03:17:40 -07:00
# When a string is passed to "echo" all trailing and leading
2016-11-13 02:58:59 -07:00
# whitespace is removed and inside the string multiple spaces are
# condensed into single spaces.
#
2016-12-20 03:17:40 -07:00
# The "set -f/+f" is here so that "echo" doesn't cause any expansion
2016-11-13 02:58:59 -07:00
# of special characters.
#
# The whitespace trim doesn't work with multiline strings so we use
2016-12-20 03:17:40 -07:00
# "${1//[[:space:]]/ }" to remove newlines before we trim the whitespace.
2016-11-13 02:58:59 -07:00
set -f
2016-12-08 01:50:04 -07:00
# shellcheck disable=2086
2016-11-13 02:58:59 -07:00
builtin echo -E ${1//[[:space:]]/ }
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() {
2017-01-27 09:05:19 -07:00
strip="${1//$'\033['3[0-9]m}"
2017-01-27 09:01:11 -07:00
strip="${strip//$'\033['38\;5\;[0-9]m}"
strip="${strip//$'\033['38\;5\;[0-9][0-9]m}"
strip="${strip//$'\033['38\;5\;[0-9][0-9][0-9]m}"
printf "%s\n" "$strip"
}
2016-11-15 18:20:14 -07:00
uppercase() {
2017-01-04 06:36:04 -07:00
((bash_version >= 4)) && printf "%s" "${1^}"
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-01-02 00:02:28 -07:00
"Android"*)
set_colors 2 7
ascii_file="android"
2017-01-05 15:15:59 -07:00
ascii_length_force=19
;;
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
;;
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"
;;
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-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
;;
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-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-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
;;
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-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-01-02 00:02:28 -07:00
"FreeBSD"*)
set_colors 1 7 3
ascii_file="freebsd"
2016-02-22 22:52:25 -07:00
;;
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
;;
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-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-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
;;
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-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
;;
"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-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-01-02 00:02:28 -07:00
"Porteus"*)
set_colors 6 7
ascii_file="porteus"
;;
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-01-02 00:02:28 -07:00
"Rosa"*)
set_colors 4 7 1
ascii_file="rosa"
2016-02-22 22:52:25 -07:00
;;
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
;;
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
;;
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"
;;
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
;;
2017-01-02 00:02:28 -07:00
"Trisquel"*)
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-05-18 00:47:02 -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")
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
2016-11-06 05:00:09 -07:00
[0-6]) printf "%b" "${reset}\033[3${1}m" ;;
7 | "fg") printf "%b" "\033[37m${reset}" ;;
2016-11-06 05:00:09 -07:00
*) printf "%b" "\033[38;5;${1}m" ;;
esac
2016-03-03 19:15:03 -07:00
}
2016-11-10 17:15:05 -07:00
# OTHER
2016-08-12 04:53:04 -06:00
err() {
err+="$(color 1)[!]\033[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() {
if [[ -f "/etc/neofetch/config" ]]; then
default_config="/etc/neofetch/config"
2017-01-23 18:18:44 -07:00
elif [[ -f "/usr/local/etc/neofetch/config" ]]; then
default_config="/usr/local/etc/neofetch/config"
2017-01-27 23:54:40 -07:00
elif [[ -f "/data/data/com.termux/files/usr/etc/neofetch/config" ]]; then
default_config="/data/data/com.termux/files/usr/etc/neofetch/config"
2017-01-26 04:46:39 -07:00
elif [[ -f "/boot/home/config/non-packaged/etc/neofetch/config" ]]; then
default_config="/boot/home/config/non-packaged/etc/neofetch/config"
else
[[ -z "$script_dir" ]] && script_dir="$(get_full_path "$0")"
default_config="${script_dir%/*}/config/config"
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
2017-01-23 18:18:44 -07:00
elif [[ -f "/etc/neofetch/config" ]]; then
2017-05-23 21:07:01 -06:00
cp "/etc/neofetch/config" "${XDG_CONFIG_HOME}/neofetch"
config_file="${XDG_CONFIG_HOME}/neofetch/config"
2016-01-29 08:18:27 -07:00
2017-01-23 18:18:44 -07:00
elif [[ -f "/usr/local/etc/neofetch/config" ]]; then
cp "/usr/local/share/neofetch/config" "${XDG_CONFIG_HOME}/neofetch"
config_file="${XDG_CONFIG_HOME}/neofetch/config"
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" "${XDG_CONFIG_HOME}/neofetch"
config_file="${XDG_CONFIG_HOME}/neofetch/config"
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-01-01 17:50:29 -07: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"
2016-10-22 21:08:45 -06:00
lines="$((lines - info_height))"
2016-09-30 20:28:21 -06:00
fi
2016-08-13 03:42:31 -06:00
# Print a newline if color blocks are disabled.
[[ -z "$block_spaces" ]] && printf "\n"
2016-12-20 03:17:40 -07:00
# Set the prompt location.
((lines > 0)) && printf "%b" "\033[${lines}B"
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() {
2016-11-13 01:44:03 -07: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-01-23 16:23:07 -07:00
[[ -n "$progress_char" ]] && err "Config: \$progress_char is deprecated, use \$bar_char_elapsed and \$bar_char_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.
[[ "$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-01-06 05:08:50 -07:00
[[ "$ascii_logo_size" ]] && err "Config: ascii_logo_size is deprecated, use ascii_distro='{alpine,arch,crux,gentoo,openbsd,void}_small' instead."
2017-01-22 17:00:38 -07:00
# $start and $end were replaced with ${block_range[@]} in 3.0.
[[ "$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.
[[ "$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
[[ -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=
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.
2017-06-09 11:54:50 -06:00
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"
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.
NOTE: You can supply multiple args. eg. 'neofetch --disable cpu gpu disk shell'
--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.
--cpu_shorthand type Shorten the output of CPU
2016-03-10 19:59:22 -07:00
Possible values: name, speed, tiny, on, off
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.
NOTE: For FreeBSD-based systems, you need to enable coretemp kernel module.
--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
--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-02-08 16:23:21 -07: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.
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.
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
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.
2016-12-13 23:05:23 -07:00
NOTE: Change this to 'Lubuntu', 'Xubuntu', 'Ubuntu-GNOME', 'Ubuntu-Studio' or 'Ubuntu-Budgie' to use the flavors.
2017-01-06 05:08:50 -07:00
NOTE: Alpine, Arch, Crux, Gentoo, OpenBSD, and Void have a smaller logo variant.
2016-12-18 20:43:07 -07:00
2017-01-06 05:08:50 -07:00
NOTE: Change this to 'alpine_small', 'arch_small', 'crux_small', 'gentoo_small', 'openbsd_small', and 'void_small' to use the small logos.
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-04-25 15:39:10 -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.
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
--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
}
version() { printf "%s" "\
2017-01-30 01:44:12 -07:00
Neofetch $version
2017-01-06 05:16:44 -07:00
Copyright (c) 2016-2017 Dylan Araps
Permission is hereby granted, free of charge, to any person obtaining a copy
2016-12-13 23:21:17 -07:00
of this software and associated documentation files (the 'Software'), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
2016-12-13 23:21:17 -07:00
THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
Written by Dylan Araps with help from the following people:
https://github.com/dylanaraps/neofetch/contributors
2016-11-09 01:34:43 -07:00
"
exit 1
}
get_args() {
2016-12-20 03:17:40 -07:00
# Check the commandline flags early for '--config'.
2017-01-14 04:53:36 -07:00
[[ "$@" != *--config* ]] && get_user_config 2>/dev/null
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_shorthand") cpu_shorthand="$2" ;;
"--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" ;;
"--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 ;;
*) disk_show+=($arg)
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 ;;
2016-08-13 21:13:21 -06:00
*) colors+=($arg)
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-02-08 16:36:21 -07:00
"--ascii" | "--caca" | "--catimg" | "--jp2a" | "--iterm2" | "--off" | "--sixel" | "--termpix" | "--tycat" | "--w3m")
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 ;;
2016-08-13 21:13:21 -06:00
*) ascii_colors+=($arg)
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 2>/dev/null
;;
2016-08-13 21:13:21 -06:00
esac
;;
2016-11-15 04:27:36 -07:00
"-v") verbose="on" ;;
"-vv") set -x; verbose="on" ;;
"--help") usage ;;
"--version") version ;;
"--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 2>/dev/null
get_args "$@"
2016-12-27 20:15:06 -07:00
get_distro 2>/dev/null
2016-11-13 03:29:25 -07:00
get_bold
2016-11-13 02:21:32 -07:00
get_distro_colors
# Minix doesn't support these sequences.
if [[ "$TERM" != "minix" ]]; then
# If the script exits for any reason, unhide the cursor.
trap 'printf "\033[?25h\033[?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 "\033[?25l\033[?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 2>/dev/null
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 2>/dev/null
2016-12-20 03:17:40 -07:00
# Take a screenshot.
[[ "$scrot" == "on" ]] && take_scrot
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
}
2016-08-13 21:13:21 -06:00
main "$@"