neofetch/neofetch

#!/usr/bin/env bash
# set -x
# vim: noai:ts=4:sw=4:expandtab
#
# Neofetch: Simple system information script.
# https://github.com/dylanaraps/neofetch
#
# Created by Dylan Araps
# https://github.com/dylanaraps/

bash_version="${BASH_VERSION/.*}"
sys_locale="${LANG:-C}"
XDG_CONFIG_HOME="${XDG_CONFIG_HOME:-${HOME}/.config}"
old_ifs="$IFS"

# Speed up script by not using unicode.
export LC_ALL=C
export LANG=C

# Add /usr/xpg4/bin, /usr/sbin, and /sbin to PATH.
export PATH="/usr/xpg4/bin:/usr/sbin:/sbin:${PATH}"

# Set no case match.
shopt -s nocasematch

# Reset colors and bold.
reset="\033[0m"

# DETECT INFORMATION

get_os() {
    # $kernel_name is set in a function called cache_uname and is
    # just the output of "uname -s".
    case "$kernel_name" in
        "Linux" | "GNU"*) os="Linux" ;;
        "Darwin") os="$(sw_vers -productName)" ;;
        *"BSD" | "DragonFly" | "Bitrig") os="BSD" ;;
        "CYGWIN"* | "MSYS"*) os="Windows" ;;
        "SunOS") os="Solaris" ;;
        "Haiku") os="Haiku" ;;
        "MINIX") os="MINIX" ;;
        "AIX") os="AIX" ;;
        *)
            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
}

get_distro() {
    [[ "$distro" ]] && return

    case "$os" in
        "Linux" | "BSD" | "MINIX")
            if [[ "$(< /proc/version)" == *"Microsoft"* || "$(< /proc/sys/kernel/osrelease)" == *"Microsoft"* ]]; then
                case "$distro_shorthand" in
                    "on")   distro="$(lsb_release -sir) [Windows 10]" ;;
                    "tiny") distro="Windows 10" ;;
                    *)      distro="$(lsb_release -sd) on Windows 10" ;;
                esac
                ascii_distro="Windows 10"

            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)"

            elif type -p guix >/dev/null; then
                distro="GuixSD"

            elif type -p crux >/dev/null; then
                distro="$(crux)"
                case "$distro_shorthand" in
                    "on")   distro="${distro//version}" ;;
                    "tiny") distro="${distro//version*}" ;;
                esac

            elif [[ -d "/system/app/" && -d "/system/priv-app" ]]; then
                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
                    source "$file" 2>/dev/null && break
                done

                # Format the distro name.
                case "$distro_shorthand" in
                    "on") distro="${NAME:-${DISTRIB_ID}} ${VERSION_ID:-${DISTRIB_RELEASE}}" ;;
                    "tiny") distro="${NAME:-${DISTRIB_ID:-${TAILS_PRODUCT_NAME}}}" ;;
                    "off") distro="${PRETTY_NAME:-${DISTRIB_DESCRIPTION}} ${UBUNTU_CODENAME}" ;;
                esac

                # Workarounds for distros that go against the os-release standard.
                [[ -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
                for release_file in /etc/*-release; do
                    distro+="$(< "$release_file")"
                done

                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")
            osx_version="$(sw_vers -productVersion)"
            osx_build="$(sw_vers -buildVersion)"

            case "$osx_version" in
                "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" ;;
                "10.10"*) codename="OS X Yosemite" ;;
                "10.11"*) codename="OS X El Capitan" ;;
                "10.12"*) codename="macOS Sierra" ;;
                *)        codename="macOS" ;;
            esac
            distro="$codename $osx_version $osx_build"

            case "$distro_shorthand" in
                "on") distro="${distro/ ${osx_build}}" ;;
                "tiny")
                    case "$osx_version" in
                        "10."[4-7]*) distro="${distro/${codename}/Mac OS X}" ;;
                        "10."[8-9]* | "10.1"[0-1]*) distro="${distro/${codename}/OS X}" ;;
                        "10.12"*) distro="${distro/${codename}/macOS}" ;;
                    esac
                    distro="${distro/ ${osx_build}}"
                ;;
            esac
        ;;

        "iPhone OS")
            distro="iOS $(sw_vers -productVersion)"

            # "uname -m" doesn't print architecture on iOS so we force it off.
            os_arch="off"
        ;;

        "Windows")
            distro="$(wmic os get Caption)"

            # Strip crap from the output of wmic.
            distro="${distro/Caption}"
            distro="${distro/Microsoft }"
        ;;

        "Solaris")
            case "$distro_shorthand" in
                "on" | "tiny") distro="$(awk 'NR==1{print $1 " " $3;}' /etc/release)" ;;
                *) distro="$(awk 'NR==1{print $1 " " $2 " " $3;}' /etc/release)" ;;
            esac
            distro="${distro/\(*}"
        ;;

        "Haiku")
            distro="$(uname -sv | awk '{print $1 " " $2}')"
        ;;

        "AIX")
            distro="AIX $(oslevel)"
        ;;
    esac

    [[ -z "$distro" ]] && distro="$os (Unknown)"

    # Get OS architecture.
    [[ "$os_arch" == "on" ]] && \
        distro+=" ${machine_arch}"

    [[ "${ascii_distro:-auto}" == "auto" ]] && \
        ascii_distro="$(trim "$distro")"
}

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
        ;;

        "Mac OS X") model="$(sysctl -n hw.model)" ;;
        "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" ;;
                "iPhone5,"[1-2]) model="iPhone 4" ;;
                "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
        ;;

        "BSD" | "MINIX")
            model="$(sysctl -n hw.vendor hw.product)"
        ;;

        "Windows")
            model="$(wmic computersystem get manufacturer,model)"
            model="${model/Manufacturer}"
            model="${model/Model}"
        ;;

        "Solaris")
            model="$(prtconf -b | awk -F':' '/banner-name/ {printf $2}')"
        ;;

        "AIX")
            model="$(prtconf | awk -F':' '/System Model/ {printf $2}')"
        ;;
    esac

    # Remove dummy OEM info.
    model="${model//To be filled by O.E.M.}"
    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}"
}

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))"
}

get_kernel() {
    # Since AIX is an integrated system, it's better to skip this function altogether
    [[ "$os" == "AIX" ]] && return

    case "$kernel_shorthand" in
        "on")  kernel="$kernel_version" ;;
        "off") kernel="$kernel_name $kernel_version" ;;
    esac

    # Hide kernel info if it's identical to the distro info.
    if [[ "$os" =~ (BSD|MINIX) && "$distro" == *"$kernel_name"* ]]; then
        case "$distro_shorthand" in
            "on" | "tiny") kernel="$kernel_version" ;;
            *) unset kernel ;;
        esac
    fi
}

get_uptime() {
    # Since Haiku's uptime cannot be fetched in seconds, a case outside
    # the usual case is needed.
    case "$os" in
        "Haiku")
            uptime="$(uptime -u)"
            uptime="${uptime/up }"
        ;;

        *)
            # Get uptime in seconds.
            case "$os" in
                "Linux" | "Windows" | "MINIX")
                    seconds="$(< /proc/uptime)"
                    seconds="${seconds/.*}"
                ;;

                "Mac OS X" | "iPhone OS" | "BSD")
                    boot="$(sysctl -n kern.boottime)"
                    boot="${boot/'{ sec = '}"
                    boot="${boot/,*}"

                    # Get current date in seconds.
                    now="$(date +%s)"
                    seconds="$((now - boot))"
                ;;

                "Solaris")
                    seconds="$(kstat -p unix:0:system_misc:snaptime | awk '{print $2}')"
                    seconds="${seconds/.*}"
                ;;

                "AIX")
                    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#*:}))"
                ;;
            esac

            days="$((seconds / 60 / 60 / 24)) days"
            hours="$((seconds / 60 / 60 % 24)) hours"
            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
            }

            days="$(strip_date "$days")"
            hours="$(strip_date "$hours")"
            mins="$(strip_date "$mins")"

            uptime="${days:+$days, }${hours:+$hours, }${mins}"
            uptime="${uptime%', '}"
            uptime="${uptime:-${seconds} seconds}"
        ;;
    esac

    # Make the output of uptime smaller.
    case "$uptime_shorthand" in
        "on")
            uptime="${uptime/minutes/mins}"
            uptime="${uptime/minute/min}"
            uptime="${uptime/seconds/secs}"
        ;;

        "tiny")
            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}"
            uptime="${uptime//,}"
        ;;
    esac
}

get_packages() {
    # Remove /usr/games from $PATH.
    # 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")
            type -p pacman >/dev/null && \
                packages="$(pacman -Qq --color never | wc -l)"

            type -p dpkg >/dev/null && \
                packages="$((packages+=$(dpkg --get-selections | grep -cv deinstall$)))"

            type -p pkgtool >/dev/null && \
                packages="$((packages+=$(ls -1 /var/log/packages | wc -l)))"

            type -p rpm >/dev/null && \
                packages="$((packages+=$(rpm -qa | wc -l)))"

            type -p xbps-query >/dev/null && \
                packages="$((packages+=$(xbps-query -l | wc -l)))"

            type -p pkginfo >/dev/null && \
                packages="$((packages+=$(pkginfo -i | wc -l)))"

            type -p emerge >/dev/null && \
                packages="$((packages+=$(ls -d /var/db/pkg/*/* | wc -l)))"

            type -p nix-env >/dev/null && \
                packages="$((packages+=$(ls -d -1 /nix/store/*/ | wc -l)))"

            type -p guix >/dev/null && \
                packages="$((packages+=$(ls -d -1 /gnu/store/*/ | wc -l)))"

            type -p apk >/dev/null && \
                packages="$((packages+=$(apk info | wc -l)))"

            type -p opkg >/dev/null && \
                packages="$((packages+=$(opkg list-installed | wc -l)))"

            type -p pacman-g2 >/dev/null && \
                packages="$((packages+=$(pacman-g2 -Q | wc -l)))"

            type -p cave >/dev/null && \
                packages="$((packages+=$(ls -d -1 /var/db/paludis/repositories/cross-installed/*/data/* /var/db/paludis/repositories/installed/data/* | wc -l)))"

            type -p lvu >/dev/null && \
                packages="$((packages+=$(lvu installed | wc -l)))"

            type -p tce-status >/dev/null && \
                packages="$((packages+=$(tce-status -i | wc -l)))"

            type -p Compile >/dev/null && \
                packages="$((packages+=$(ls -d -1 /Programs/*/ | wc -l)))"

            type -p eopkg >/dev/null && \
                packages="$((packages+=$(eopkg list-installed | wc -l)))"

            type -p pkg_info >/dev/null && \
                packages="$((packages+=$(pkg_info | wc -l)))"

            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)))"
                        ((packages == 0)) && packages="$((packages+=$(pkg list | wc -l)))"
                esac
            fi
        ;;

        "Mac OS X" | "MINIX")
            [[ -d "/usr/local/bin" ]] && \
                packages="$(($(ls -l /usr/local/bin/ | grep -cv "\(../Cellar/\|brew\)") - 1))"

            type -p port >/dev/null && \
                packages="$((packages + $(port installed | wc -l) - 1))"

            type -p brew >/dev/null && \
                packages="$((packages + $(find /usr/local/Cellar -maxdepth 1 | wc -l) - 1))"

            type -p pkgin >/dev/null && \
                packages="$((packages + $(pkgin list | wc -l)))"
        ;;

        "Windows")
            case "$kernel_name" in
                "CYGWIN"*) packages="$(cygcheck -cd | wc -l)" ;;
                "MSYS"*) packages="$(pacman -Qq --color never | wc -l)"
            esac

            # Count chocolatey packages.
            [[ -d "/cygdrive/c/ProgramData/chocolatey/lib" ]] && \
                packages="$((packages+=$(ls -1 /cygdrive/c/ProgramData/chocolatey/lib | wc -l)))"
        ;;

        "Haiku")
            packages="$(ls -1 /boot/system/package-links | wc -l)"
        ;;

        "AIX")
            packages="$(lslpp -J -l -q | grep -cv '^#')"
            packages="$((packages+=$(rpm -qa | wc -l)))"
        ;;
    esac

    ((packages == 0)) && unset packages
}

get_shell() {
    case "$shell_path" in
        "on")  shell="$SHELL " ;;
        "off") shell="${SHELL##*/} " ;;
    esac

    if [[ "$shell_version" == "on" ]]; then
        case "${SHELL##*/}" in
            "bash") shell+="${BASH_VERSION/-*}" ;;
            "sh" | "ash" | "dash") ;;

            "mksh" | "ksh")
                shell+="$("$SHELL" -c 'printf "%s" "$KSH_VERSION"')"
                shell="${shell/ * KSH}"
                shell="${shell/version}"
            ;;

            *)
                shell+="$("$SHELL" --version 2>&1)"
                shell="${shell/ ${SHELL##*/}}"
            ;;
        esac

        # Remove unwanted info.
        shell="${shell/, version}"
        shell="${shell/xonsh\//xonsh }"
        shell="${shell/options*}"
        shell="${shell/\(*\)}"
    fi
}

get_de() {
    # If function was run, stop here.
    ((de_run == 1)) && return

    case "$os" in
        "Mac OS X") de="Aqua" ;;
        "Windows")
            case "$distro" in
                "Windows 8"* | "Windows 10"*) de="Modern UI/Metro" ;;
                *) de="Aero" ;;
            esac
        ;;

        *)
            ((wm_run != 1)) && get_wm

            if [[ "$XDG_CURRENT_DESKTOP" ]]; then
                de="${XDG_CURRENT_DESKTOP/'X-'}"
                de="${de/Budgie:GNOME/Budgie}"

            elif [[ "$DESKTOP_SESSION" ]]; then
                de="${DESKTOP_SESSION/ *}"

            elif [[ "$GNOME_DESKTOP_SESSION_ID" ]]; then
                de="GNOME"

            elif [[ "$MATE_DESKTOP_SESSION_ID" ]]; then
                de="MATE"
            fi

            # 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.
            [[ "$wm" && "$de" =~ $wm ]] && { unset -v de; return; }
        ;;
    esac

    # Fallback to using xprop.
    [[ -n "$DISPLAY" && -z "$de" ]] && \
        de="$(xprop -root | awk '/KDE_SESSION_VERSION|^_MUFFIN|xfce4|xfce5/')"

    # Format strings.
    case "$de" in
        "KDE_SESSION_VERSION"*) de="KDE${de/* = }" ;;
        *"TDE_FULL_SESSION"*) de="Trinity" ;;
        *"MUFFIN"* | "Cinnamon") de="$(cinnamon --version)"; de="${de:-Cinnamon}" ;;
        *"xfce4"*) de="XFCE4" ;;
        *"xfce5"*) de="XFCE5" ;;
        *"xfce"*)  de="XFCE" ;;
        *"mate"*)  de="MATE" ;;
    esac

    # Log that the function was run.
    de_run=1
}

get_wm() {
    # If function was run, stop here.
    ((wm_run == 1)) && return

    if [[ -n "$DISPLAY" && "$os" != "Mac OS X" ]]; then
        id="$(xprop -root -notype | awk '$1=="_NET_SUPPORTING_WM_CHECK:"{print $5}')"
        wm="$(xprop -id "$id" -notype -f _NET_WM_NAME 8t)"
        wm="${wm/*_NET_WM_NAME = }"
        wm="${wm/\"}"
        wm="${wm/\"*}"

        # 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
            "Mac OS X") wm="Quartz Compositor" ;;
            "Windows")
                wm="$(tasklist | grep -m 1 -o -F -e "bugn" -e "Windawesome" -e "blackbox" -e "emerge" -e "litestep")"
                [[ "$wm" == "blackbox" ]] && wm="bbLean (Blackbox)"
                wm="${wm:+$wm, }Explorer"
            ;;
        esac
    fi

    # Log that the function was run.
    wm_run=1
}

get_wm_theme() {
    ((wm_run != 1)) && get_wm
    ((de_run != 1)) && get_de

    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")" ;;

        "Cinnamon" | "Muffin" | "Mutter (Muffin)")
            detheme="$(gsettings get org.cinnamon.theme name)"
            wm_theme="$(gsettings get org.cinnamon.desktop.wm.preferences theme)"
            wm_theme="$detheme (${wm_theme})"
        ;;

        "Compiz" | "Mutter" | "GNOME Shell" | "Gala")
            if type -p gsettings >/dev/null; then
                wm_theme="$(gsettings get org.gnome.shell.extensions.user-theme name)"

                [[ -z "${wm_theme//\'}" ]] && \
                    wm_theme="$(gsettings get org.gnome.desktop.wm.preferences theme)"

            elif type -p gconftool-2 >/dev/null; then
                wm_theme="$(gconftool-2 -g /apps/metacity/general/theme)"
            fi
        ;;

        "Metacity"*)
            if [[ "$de" == "Deepin" ]]; then
                wm_theme="$(gsettings get com.deepin.wrap.gnome.desktop.wm.preferences theme)"

            elif [[ "$de" == "MATE" ]]; then
                wm_theme="$(gsettings get org.mate.Marco.general theme)"

            else
                wm_theme="$(gconftool-2 -g /apps/metacity/general/theme)"
            fi
        ;;

        "E17" | "Enlightenment")
            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%.*}"
            fi
        ;;

        "Fluxbox")
            [[ -f "${HOME}/.fluxbox/init" ]] && \
                wm_theme="$(awk -F "/" '/styleFile/ {print $NF}' "${HOME}/.fluxbox/init")"
        ;;

        "IceWM"*)
            [[ -f "${HOME}/.icewm/theme" ]] && \
                wm_theme="$(awk -F "[\",/]" '!/#/ {print $2}' "${HOME}/.icewm/theme")"
        ;;

        "Openbox")
            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")";
        ;;

        "PekWM")
            [[ -f "${HOME}/.pekwm/config" ]] && \
                wm_theme="$(awk -F "/" '/Theme/ {gsub(/\"/,""); print $NF}' "${HOME}/.pekwm/config")"
        ;;

        "Xfwm4")
            [[ -f "${HOME}/.config/xfce4/xfconf/xfce-perchannel-xml/xfwm4.xml" ]] && \
                wm_theme="$(xfconf-query -c xfwm4 -p /general/theme)"
        ;;

        "KWin"*)
            kde_config_dir

            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")"

            elif [[ -f "${kde_config_dir}/kdebugrc" ]]; then
                wm_theme="$(awk '/(decoration)/ {gsub(/\[/,"",$1); print $1; exit}' "${kde_config_dir}/kdebugrc")"
            fi
        ;;

        "Quartz Compositor")
            wm_theme="$(/usr/libexec/PlistBuddy -c "Print AppleAquaColorVariant" ~/Library/Preferences/.GlobalPreferences.plist)"
            if [[ -z "$wm_theme" ]] || ((wm_theme == 1)); then
                wm_theme="Blue"
            else
                wm_theme="Graphite"
            fi
        ;;

        *"Explorer")
            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%.*}"
        ;;

        "Blackbox" | "bbLean"*)
            path="$(wmic process get ExecutablePath | grep -F "blackbox")"
            path="${path//\\/\/}"

            wm_theme="$(grep "^session\.styleFile:" "${path/\.exe/.rc}")"
            wm_theme="${wm_theme/'session.styleFile: '}"
            wm_theme="${wm_theme##*\\}"
            wm_theme="${wm_theme%.*}"
        ;;
    esac

    wm_theme="$(trim_quotes "$wm_theme")"
    wm_theme="$(uppercase "$wm_theme")"
}

get_cpu() {
    # NetBSD emulates the Linux /proc filesystem instead of using sysctl for hw
    # information so we have to use this block below which temporarily sets the
    # OS to "Linux" for the duration of this function.
    [[ "$distro" == "NetBSD"* ]] && local os="Linux"

    case "$os" in
        "Linux" | "MINIX" | "Windows")
            # Get CPU name.
            case "$distro" in
                "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

            speed_dir="/sys/devices/system/cpu/cpu0/cpufreq"
            temp_dir="/sys/class/hwmon/hwmon0/temp1_input"

            # Get CPU speed.
            if [[ -d "$speed_dir" ]]; then
                # Fallback to bios_limit if $speed_type fails.
                speed="$(< "${speed_dir}/${speed_type}")" || \
                speed="$(< "${speed_dir}/bios_limit")" || \
                speed="$(< "${speed_dir}/scaling_max_freq")" || \
                speed="$(< "${speed_dir}/cpuinfo_max_freq")"
                speed="$((speed / 100000))"

            else
                speed="$(awk -F ': |\\.' '/cpu MHz/ {printf $2; exit}' /proc/cpuinfo)"
                speed="$((speed / 100))"
            fi

            # Get CPU temp.
            if [[ "$cpu_temp" != "off" && -f "$temp_dir" ]]; then
                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}]"
            fi

            # Get CPU cores.
            case "$cpu_cores" in
                "logical" | "on") cores="$(grep -c "^processor" /proc/cpuinfo)" ;;
                "physical") cores="$(grep "^core id" /proc/cpuinfo | sort -u | wc -l)" ;;
            esac
        ;;

        "Mac OS X")
            cpu="$(sysctl -n machdep.cpu.brand_string)"

            # Get CPU cores.
            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
                "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" ;;
                "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" ;;
            esac
        ;;

        "BSD")
            # Get CPU name.
            cpu="$(sysctl -n hw.model)"
            cpu="${cpu/[0-9]\.*}"
            cpu="${cpu/ @*}"

            # Get CPU speed.
            speed="$(sysctl -n hw.cpuspeed)"
            [[ -z "$speed" ]] && speed="$(sysctl -n  hw.clockrate)"
            speed="$((speed / 100))"

            # Get CPU cores.
            cores="$(sysctl -n hw.ncpu)"

            # Get CPU temp.
            if [[ "$cpu_temp" != "off" ]]; then
                case "$kernel_name" in
                    "FreeBSD"* | "DragonFly"*)
                        temp="$(sysctl -n dev.cpu.0.temperature)"
                        temp="${temp/C}"
                    ;;
                    "OpenBSD"* | "Bitrig"*)
                        temp="$(sysctl -n hw.sensors.lm0.temp0)"
                        temp="${temp/ degC}"
                    ;;
                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

            fi
        ;;

        "Solaris")
            # Get CPU name.
            cpu="$(psrinfo -pv)"
            cpu="${cpu//*$'\n'}"
            cpu="${cpu/[0-9]\.*}"
            cpu="${cpu/ @*}"

            # Get CPU speed.
            speed="$(psrinfo -v | awk '/operates at/ {print $6; exit}')"
            speed="$((speed / 100))"

            # Get CPU cores.
            case "$cpu_cores" in
                "logical" | "on") cores="$(kstat -m cpu_info | grep -c -F "chip_id")" ;;
                "physical") cores="$(psrinfo -p)" ;;
            esac
        ;;

        "Haiku")
            # Get CPU name.
            cpu="$(sysinfo -cpu | awk -F '\\"' '/CPU #0/ {print $2}')"
            cpu="${cpu/@*}"

            # Get CPU speed.
            speed="$(sysinfo -cpu | awk '/running at/ {print $NF; exit}')"
            speed="${speed/MHz}"
            speed="$((speed / 100))"

            # Get CPU cores.
            cores="$(sysinfo -cpu | grep -c -F 'CPU #')"
        ;;

        "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}"
            speed="$((speed / 100))"

            # 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
        ;;
    esac

    # Fix for speeds under 1ghz.
    if [[ "$speed" ]]; then
        if [[ -z "${speed:1}" ]]; then
            speed="0.${speed}"
        else
            speed="${speed:0:1}.${speed:1}"
        fi

        cpu="$cpu @ ${speed}GHz $temp"
    fi

    # Remove un-needed patterns from cpu output.
    cpu="${cpu//(TM)}"
    cpu="${cpu//(tm)}"
    cpu="${cpu//(R)}"
    cpu="${cpu//(r)}"
    cpu="${cpu//CPU}"
    cpu="${cpu//Processor}"
    cpu="${cpu//Dual-Core}"
    cpu="${cpu//Quad-Core}"
    cpu="${cpu//Six-Core}"
    cpu="${cpu//Eight-Core}"
    cpu="${cpu//Core}"
    cpu="${cpu//with Radeon * Graphics}"
    cpu="${cpu//, altivec supported}"
    cpu="${cpu//FPU*}"

    # Trim spaces from core output
    cores="${cores//[[:space:]]}"

    # Add CPU cores to the output.
    [[ "$cpu_cores" != "off" && "$cores" ]] && \
        cpu="${cpu/@/(${cores}) @}"

    # Remove CPU speed from the output.
    [[ "$cpu_speed" == "off" ]] && \
        cpu="${cpu/@ *GHz}"

    # Make the output of CPU shorter.
    case "$cpu_shorthand" in
        "name")  cpu="${cpu/@*}" ;;
        "speed") cpu="${cpu#*@ }" ;;

        "on" | "tiny")
            cpu="${cpu/AMD }"
            cpu="${cpu/Intel }"
            cpu="${cpu/Core? Duo }"

            [[ "$cpu_shorthand" == "tiny" ]] && cpu="${cpu/@*}"
        ;;
    esac
}

get_cpu_usage() {
    case "$os" in
        "Windows")
            cpu_usage="$(wmic cpu get loadpercentage)"
            cpu_usage="${cpu_usage/LoadPercentage}"
            cpu_usage="${cpu_usage//[[:space:]]}"
        ;;

        *)
            # Get CPU cores if unset.
            if [[ "$cpu_cores" != "logical" ]]; then
                case "$os" in
                    "Linux" | "MINIX") cores="$(grep -c "^processor" /proc/cpuinfo)" ;;
                    "Mac OS X") cores="$(sysctl -n hw.logicalcpu_max)" ;;
                    "BSD") cores="$(sysctl -n hw.ncpu)" ;;
                    "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}')" ;;
                esac
            fi

            cpu_usage="$(ps aux | awk 'BEGIN {sum=0} {sum+=$3}; END {print sum}')"
            cpu_usage="$((${cpu_usage/\.*} / ${cores:-1}))"
        ;;
    esac

    # Print the bar.
    case "$cpu_display" in
        "bar") cpu_usage="$(bar "$cpu_usage" 100)" ;;
        "infobar") cpu_usage="${cpu_usage}% $(bar "$cpu_usage" 100)" ;;
        "barinfo") cpu_usage="$(bar "$cpu_usage" 100) ${cpu_usage}%" ;;
        *) cpu_usage="${cpu_usage}%" ;;
    esac
}

get_gpu() {
    case "$os" in
        "Linux")
            # Read GPUs into array.
            IFS=$'\n'
            gpus=($(lspci -mm | awk -F '\\"|\\" \\"' '/"Display|"3D|"VGA/ {print $3 " " $4}'))
            IFS="$old_ifs"

            # Number the GPUs if more than one exists.
            ((${#gpus[@]} > 1)) && gpu_num=1

            for gpu in "${gpus[@]}"; do
                # GPU shorthand tests.
                [[ "$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"*)
                        gpu="Intel Integrated Graphics"
                    ;;

                    *"virtualbox"*)
                        gpu="VirtualBox Graphics Adapter"
                    ;;
                esac

                if [[ "$gpu_brand" == "off" ]]; then
                    gpu="${gpu/AMD }"
                    gpu="${gpu/NVIDIA }"
                    gpu="${gpu/Intel }"
                fi

                prin "${subtitle}${gpu_num}" "$gpu"
                ((++gpu_num))
            done

            return
        ;;

        "Mac OS X")
            if [[ -f "${cache_dir}/neofetch/gpu" ]]; then
                source "${cache_dir}/neofetch/gpu"

            else
                gpu="$(system_profiler SPDisplaysDataType | awk -F': ' '/^\ *Chipset Model:/ {printf $2 ", "}')"
                gpu="${gpu//'/ $'}"
                gpu="${gpu%,*}"

                cache "gpu" "$gpu"
            fi
        ;;

        "iPhone OS")
            case "$machine_arch" in
                "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"
                ;;

                "iPhone4,1" | "iPad2,"[1-7] | "iPod5,1")
                    gpu="PowerVR SGX543MP2"
                ;;

                "iPhone6,"[1-2] | "iPad4,"[1-9])
                    gpu="PowerVR G6430"
                ;;

                "iPhone7,"[1-2] | "iPod7,1" | "iPad5,"[1-2])
                    gpu="PowerVR GX6450"
                ;;

                "iPod1,1" | "iPod2,1")
                    gpu="PowerVR MBX Lite"
                ;;
            esac
        ;;

        "BSD" | "Solaris" | "MINIX" | "AIX")
            case "$kernel_name" in
                "FreeBSD"* | "DragonFly"*)
                    gpu="$(pciconf -lv | grep -B 4 -F "VGA" | grep -F "device")"
                    gpu="${gpu/*device*= }"
                    gpu="$(trim_quotes "$gpu")"
                ;;

                *)
                    gpu="$(glxinfo | grep -F 'OpenGL renderer string')"
                    gpu="${gpu/'OpenGL renderer string: '}"
                ;;
            esac
        ;;

        "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}')"
        ;;
    esac

    if [[ "$gpu_brand" == "off" ]]; then
        gpu="${gpu/AMD}"
        gpu="${gpu/NVIDIA}"
        gpu="${gpu/Intel}"
    fi
}

get_memory() {
    case "$os" in
        "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
                    "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

            mem_used="$((mem_used / 1024))"
            mem_total="$((mem_total / 1024))"
        ;;

        "Mac OS X" | "iPhone OS")
            mem_total="$(($(sysctl -n hw.memsize) / 1024 / 1024))"
            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))"
        ;;

        "BSD" | "MINIX")
            # Mem total.
            case "$kernel_name" in
                "NetBSD"*) mem_total="$(($(sysctl -n hw.physmem64) / 1024 / 1024))" ;;
                *) mem_total="$(($(sysctl -n hw.physmem) / 1024 / 1024))" ;;
            esac

            # Mem free.
            case "$kernel_name" in
                "NetBSD"*) mem_free="$(($(awk -F ':|kB' '/MemFree:/ {printf $2}' /proc/meminfo) / 1024))" ;;
                "FreeBSD"* | "DragonFly"*)
                    mem_free="$(top -d 1 | awk -F ',' '/^Mem:/ {print $5}')"
                    mem_free="${mem_free/M Free}"
                ;;
                "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

            # Mem used.
            case "$kernel_name" in
                "OpenBSD"*) mem_used="$(($(vmstat | awk 'END{printf $4}') / 1024))" ;;
                *) mem_used="$((mem_total - mem_free))" ;;
            esac
        ;;

        "Solaris")
            mem_total="$(prtconf | awk '/Memory/ {print $3}')"
            mem_free="$(($(vmstat | awk 'NR==3{printf $5}') / 1024))"
            mem_used="$((mem_total - mem_free))"
        ;;

        "Haiku")
            mem_total="$(($(sysinfo -mem | awk -F '\\/ |)' '{print $2; exit}') / 1024 / 1024))"
            mem_used="$(sysinfo -mem | awk -F '\\/|)' '{print $2; exit}')"
            mem_used="$((${mem_used/max} / 1024 / 1024))"
        ;;

        "AIX")
            mem_stat=($(svmon -G -O unit=MB))
            mem_total="${mem_stat[11]/.*}"
            mem_free="${mem_stat[16]/.*}"
            mem_used="$((mem_total - mem_free))"
        ;;
    esac
    memory="${mem_used}MB / ${mem_total}MB"

    # Bars.
    case "$memory_display" in
        "bar") memory="$(bar "${mem_used}" "${mem_total}")" ;;
        "infobar") memory="${memory} $(bar "${mem_used}" "${mem_total}")" ;;
        "barinfo") memory="$(bar "${mem_used}" "${mem_total}") ${memory}" ;;
    esac
}

get_song() {
    # This is absurdly long.
    player="$(ps x | awk '!(/awk|Helper|Cache/) && /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/ {printf $5 " " $6; exit}')"

    get_song_dbus() {
        # Multiple players use an almost identical dbus command to get the information.
        # This function saves us using the same command throughout the function.
        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}'
        )"
    }

    case "${player/*\/}" in
        "mpd"* | "mopidy"*) song="$(mpc current)" ;;
        "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%')" ;;
        "audacious"*)   song="$(audtool current-song)" ;;
        "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" ;;

        "cmus"*)
            song="$(cmus-remote -Q | awk '/tag artist/ {$1=$2=""; print; print " - "} /tag title/ {$1=$2=""; print}')"
        ;;

        "spotify"*)
            case "$os" in
                "Linux") get_song_dbus "spotify" ;;

                "Mac OS X")
                    song="$(osascript -e 'tell application "Spotify" to artist of current track as string & " - " & name of current track as string')"
                ;;
            esac
        ;;

        "itunes"*)
            song="$(osascript -e 'tell application "iTunes" to artist of current track as string & " - " & name of current track as string')"
        ;;

        "banshee"*)
            song="$(banshee --query-artist --query-title | awk -F':' '/^artist/ {a=$2} /^title/ {t=$2} END{print a " - " t}')"
        ;;

        "amarok"*)
            song="$(qdbus org.kde.amarok /Player GetMetadata | awk -F':' '/^artist/ {a=$2} /^title/ {t=$2} END{print a " - " t}')"
        ;;

        "pragha"*)
            song="$(pragha -c | awk -F':' '/^artist/ {a=$2} /^title/ {t=$2} END{print a " - " t}')"
        ;;

        "exaile"*)
            song="$(dbus-send --print-reply --dest=org.exaile.Exaile  /org/exaile/Exaile \
                    org.exaile.Exaile.Query | awk -F':|,' '{if ($6 && $4) printf $6 " -" $4}')"
        ;;

        "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}')"
        ;;
    esac

    [[ "$(trim "$song")" = "-" ]] && unset -v song

    # Display Artist and Title on separate lines.
    if [[ "$song_shorthand" == "on" ]]; then
        artist="${song/ -*}"
        song="${song/$artist - }"

        if [[ "$song" != "$artist" ]]; then
            prin "Artist" "$artist"
            prin "Song" "$song"
        else
            prin "$subtitle" "$song"
        fi
    fi
}

get_resolution() {
    case "$os" in
        "Linux" | "BSD" | "Solaris" | "MINIX" | "AIX")
            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//\*}"
                resolution="${resolution//\.[0-9][0-9]}"

            elif type -p xdpyinfo >/dev/null; then
                resolution="$(xdpyinfo | awk '/dimensions:/ {printf $2}')"
            fi
        ;;

        "Mac OS X")
            if type -p screenresolution >/dev/null; then
                resolution="$(screenresolution get | awk '/Display/ {printf $6 "Hz, "}')"
                resolution="${resolution//x??@/ @ }"

            else
                resolution="$(system_profiler SPDisplaysDataType | awk '/Resolution:/ {printf $2"x"$4" @ "$6"Hz, "}')"
            fi

            scale_factor="$(/usr/libexec/PlistBuddy -c "Print DisplayAnyUserSets:0:0:Resolution" /Library/Preferences/com.apple.windowserver.plist)"

            # If no refresh rate is empty.
            [[ "$resolution" == *"@ Hz"* ]] && \
                resolution="${resolution//@ Hz}"

            ((${scale_factor%.*} == 2)) && \
                resolution="${resolution// @/@2x @}"

            if [[ "$refresh_rate" == "off" ]]; then
                resolution="${resolution// @ [0-9][0-9]Hz}"
                resolution="${resolution// @ [0-9][0-9][0-9]Hz}"
            fi

            [[ "$resolution" == *"0Hz"* ]] && \
                resolution="${resolution// @ 0Hz}"
        ;;

        "Windows")
            width="$(wmic path Win32_VideoController get CurrentHorizontalResolution)"
            width="${width//CurrentHorizontalResolution/}"

            height="$(wmic path Win32_VideoController get CurrentVerticalResolution)"
            height="${height//CurrentVerticalResolution/}"

            [[ "$(trim "$width")" ]] && resolution="${width// }x${height// }"
        ;;

        "Haiku")
            resolution="$(screenmode | awk -F ' |, ' '{printf $2 "x" $3 " @ " $6 $7}')"

            [[ "$refresh_rate" == "off" ]] && resolution="${resolution/ @*}"
        ;;
    esac

    resolution="${resolution%,*}"
}

get_style() {
    # Fix weird output when the function is run multiple times.
    unset gtk2_theme gtk3_theme theme path

    if [[ -n "$DISPLAY" && "$os" != "Mac OS X" ]]; then
        # Get DE if user has disabled the function.
        ((de_run != 1)) && get_de

        # Check for DE Theme.
        case "$de" in
            "KDE"*)
                kde_config_dir

                if [[ -f "${kde_config_dir}/kdeglobals" ]]; then
                    kde_config_file="${kde_config_dir}/kdeglobals"

                    theme="$(grep "^[^#]*${kde}" "$kde_config_file")"
                    theme="${theme/${kde}*=}"
                    theme="$(uppercase "$theme")"

                    gtk_shorthand="on"
                else
                    err "Theme: KDE config files not found, skipping."
                fi
                return
            ;;

            *"Cinnamon"*)
                if type -p gsettings >/dev/null; then
                    gtk3_theme="$(gsettings get org.cinnamon.desktop.interface "$gsettings")"
                    gtk2_theme="$gtk3_theme"
                fi
            ;;

            "Gnome"* | "Unity"* | "Budgie"*)
                if type -p gsettings >/dev/null; then
                    gtk3_theme="$(gsettings get org.gnome.desktop.interface "$gsettings")"
                    gtk2_theme="$gtk3_theme"

                elif type -p gconftool-2 >/dev/null; then
                    gtk2_theme="$(gconftool-2 -g /desktop/gnome/interface/"$gconf")"
                fi
            ;;

            "Mate"*)
                gtk3_theme="$(gsettings get org.mate.interface "$gsettings")"
                gtk2_theme="$gtk3_theme"
            ;;

            "Xfce"*)
                type -p xfconf-query >/dev/null && \
                    gtk2_theme="$(xfconf-query -c xsettings -p "$xfconf")"
            ;;
        esac

        # Check for general GTK2 Theme.
        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}")"

            elif [[ -f "/usr/share/gtk-2.0/gtkrc" ]]; then
                gtk2_theme="$(grep "^[^#]*${name}" /usr/share/gtk-2.0/gtkrc)"

            elif [[ -f "/etc/gtk-2.0/gtkrc" ]]; then
                gtk2_theme="$(grep "^[^#]*${name}" /etc/gtk-2.0/gtkrc)"
            fi

            gtk2_theme="${gtk2_theme/${name}*=}"
        fi

        # Check for general GTK3 Theme.
        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")"

            elif type -p gsettings >/dev/null; then
                gtk3_theme="$(gsettings get org.gnome.desktop.interface "$gsettings")"

            elif [[ -f "/usr/share/gtk-3.0/settings.ini" ]]; then
                gtk3_theme="$(grep "^[^#]*$name" /usr/share/gtk-3.0/settings.ini)"

            elif [[ -f "/etc/gtk-3.0/settings.ini" ]]; then
                gtk3_theme="$(grep "^[^#]*$name" /etc/gtk-3.0/settings.ini)"
            fi

            gtk3_theme="${gtk3_theme/${name}*=}"
        fi

        # Trim whitespace.
        gtk2_theme="$(trim "$gtk2_theme")"
        gtk3_theme="$(trim "$gtk3_theme")"

        # Remove quotes.
        gtk2_theme="$(trim_quotes "$gtk2_theme")"
        gtk3_theme="$(trim_quotes "$gtk3_theme")"

        # Uppercase the first letter of each GTK theme.
        gtk2_theme="$(uppercase "$gtk2_theme")"
        gtk3_theme="$(uppercase "$gtk3_theme")"

        # Toggle visibility of GTK themes.
        [[ "$gtk2" == "off" ]] && unset gtk2_theme
        [[ "$gtk3" == "off" ]] && unset gtk3_theme

        # Format the string based on which themes exist.
        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
            [[ "$gtk2_theme" ]] && gtk2_theme+=" [GTK2] "
            [[ "$gtk3_theme" ]] && gtk3_theme+=" [GTK3] "
        fi

        # Final string.
        theme="${gtk2_theme}${gtk3_theme}"

        # Make the output shorter by removing "[GTKX]" from the string.
        if [[ "$gtk_shorthand" == "on" ]]; then
            theme="${theme// '[GTK'[0-9]']'}"
            theme="${theme/ '[GTK2/3]'}"
        fi
    fi
}

get_theme() {
    name="gtk-theme-name"
    gsettings="gtk-theme"
    gconf="gtk_theme"
    xfconf="/Net/ThemeName"
    kde="widgetStyle"

    get_style
}

get_icons() {
    name="gtk-icon-theme-name"
    gsettings="icon-theme"
    gconf="icon_theme"
    xfconf="/Net/IconThemeName"
    kde="Theme"

    get_style
    icons="$theme"
}

get_font() {
    name="gtk-font-name"
    gsettings="font-name"
    gconf="font_theme"
    xfconf="/Gtk/FontName"
    kde="font"

    get_style
    font="$theme"
}

get_term() {
    # If function was run, stop here.
    ((term_run == 1)) && return

    # 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}" ;;
    esac

    # Check $PPID for terminal emulator.
    while [[ -z "$term" ]]; do
        parent="$(get_ppid "$parent")"
        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
    done

    # Log that the function was run.
    term_run=1
}

get_term_font() {
    ((term_run != 1)) && get_term

    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'*}"
        ;;

        "Apple_Terminal")
            term_font="$(osascript -e 'tell application "Terminal" to font name of window frontmost')"
        ;;

        "Hyper"*)
            term_font="$(awk -F "," '/fontFamily/ {a=$1} END{print a}' "${HOME}/.hyper.js" | awk -F "'" '{a=$2} END{print a}')"
        ;;

        "konsole"*)
            # Get Process ID of current konsole window / tab
            child="$(get_ppid "$$")"

            konsole_instances=($(qdbus | grep 'org.kde.konsole'))

            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
            done

            # 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")"
        ;;

        "mintty")
            term_font="$(awk -F '=' '!/^($|#)/ && /Font/ {printf $2; exit}' "${HOME}/.minttyrc")"
        ;;

        "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" ]] && config_file="${XDG_CONFIG_HOME}/termite/config"
            term_font="$(awk -F '= ' '/\[options\]/ {opt=1} /^font/ {if(opt==1) a=$2; opt=0} END{print a}' "/etc/xdg/termite/config" "$config_file")"
        ;;

        "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")"
        ;;
    esac
}

get_disk() {
    type -p df >/dev/null 2>&1 || \
        { err "Disk requires 'df' to function. Install 'df' to get disk info."; return; }

    # Get "df" flags.
    case "$os" in
        "Haiku") err "Disk doesn't work on Haiku due to the non-standard 'df'"; return ;;
        "Mac OS X") df_flags=(-P -h) ;;
        "AIX") df_flags=(-P -g) ;;
        *) df_flags=(-h) ;;
    esac

    # 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.
    IFS=$'\n'
    disks=($(df "${df_flags[@]}" "${disk_show[@]:-/}" 2>/dev/null))
    unset 'disks[0]'
    IFS="$old_ifs"

    # 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; }

    for disk in "${disks[@]}"; do
        # Create a second array and make each element split at whitespace this time.
        disk_info=($disk)
        disk_perc="${disk_info[4]/'%'}"

        disk="${disk_info[2]/i} / ${disk_info[1]/i} (${disk_perc}%)"

        # Subtitle.
        case "$disk_subtitle" in
            "name") disk_sub="${disk_info[0]}" ;;
            *) disk_sub="${disk_info[5]}" ;;
        esac

        # Bar.
        case "$disk_display" in
            "bar") disk="$(bar "$disk_perc" "100")" ;;
            "infobar") disk+=" $(bar "$disk_perc" "100")" ;;
            "barinfo") disk="$(bar "$disk_perc" "100") $disk" ;;
            "perc") disk="${disk_perc}% $(bar "$disk_perc" "100")" ;;
        esac

        # Append '(disk mount point)' to the subtitle.
        prin "${subtitle} (${disk_sub})" "$disk"
    done
}

get_battery() {
    case "$os" in
        "Linux")
            # We use 'prin' here and exit the function early so that we can
            # do multi battery support with a single battery per line.
            for bat in "/sys/class/power_supply/BAT"*; do
                capacity="$(< "${bat}/capacity")"
                status="$(< "${bat}/status")"

                # Fix for bash on Windows 10 which includes /proc files
                # for battery usage despite there not being a battery
                # installed.
                [[ -z "$capacity" ]] && return

                battery="${capacity}% [${status}]"

                case "$battery_display" in
                    "bar") battery="$(bar "$capacity" 100)" ;;
                    "infobar") battery+=" $(bar "$capacity" 100)" ;;
                    "barinfo") battery="$(bar "$capacity" 100) ${battery}" ;;
                esac

                prin "${subtitle}${bat: -1}" "$battery"
            done
            return
        ;;

        "BSD")
            case "$kernel_name" in
                "FreeBSD"* | "DragonFly"*)
                    battery="$(acpiconf -i 0 | awk -F ':\t' '/Remaining capacity/ {print $2}')"
                    battery_state="$(acpiconf -i 0 | awk -F ':\t\t\t' '/State/ {print $2}')"
                ;;

                "NetBSD"*)
                    battery="$(envstat | awk '\\(|\\)' '/charge:/ {print $2}')"
                    battery="${battery/\.*/%}"
                ;;

                "OpenBSD"* | "Bitrig"*)
                    battery0full="$(sysctl -n hw.sensors.acpibat0.watthour0)"
                    battery0full="${battery0full/ Wh*}"

                    battery0now="$(sysctl -n hw.sensors.acpibat0.watthour3)"
                    battery0now="${battery0now/ Wh*}"

                    [[ "$battery0full" ]] && \
                    battery="$((100 * ${battery0now/\.} / ${battery0full/\.}))%"
                ;;
            esac
        ;;

        "Mac OS X")
            battery="$(pmset -g batt | grep -o '[0-9]*%')"
            state="$(pmset -g batt | awk '/;/ {print $4}')"
            [[ "$state" == "charging;" ]] && battery_state="charging"
        ;;

        "Windows")
            battery="$(wmic Path Win32_Battery get EstimatedChargeRemaining)"
            battery="${battery/EstimatedChargeRemaining}"
            [[ "$(trim "$battery")" ]] && battery="%"
        ;;

        "Haiku")
            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)"
            battery="$((battery0full * 100 / battery0now))%"
        ;;
    esac

    [[ "$battery_state" ]] && battery+=" Charging"

    case "$battery_display" in
        "bar") battery="$(bar "${battery/'%'*}" 100)" ;;
        "infobar") battery="${battery} $(bar "${battery/'%'*}" 100)" ;;
        "barinfo") battery="$(bar "${battery/'%'*}" 100) ${battery}" ;;
    esac
}

get_local_ip() {
    case "$os" in
        "Linux" | "BSD" | "Solaris" | "AIX")
            local_ip="$(ip route get 1 | awk '{print $NF;exit}')"
            [[ -z "$local_ip" ]] && local_ip="$(ifconfig -a | awk '/broadcast/ {print $2; exit}')"
        ;;

        "MINIX")
            local_ip="$(ifconfig | awk '{printf $3; exit}')"
        ;;

        "Mac OS X" | "iPhone OS")
            local_ip="$(ipconfig getifaddr en0)"
            [[ -z "$local_ip" ]] && local_ip="$(ipconfig getifaddr en1)"
        ;;

        "Windows")
            local_ip="$(ipconfig | awk -F ': ' '/IPv4 Address/ {printf $2 ", "}')"
            local_ip="${local_ip%\,*}"
        ;;

        "Haiku")
            local_ip="$(ifconfig | awk -F ': ' '/Bcast/ {print $2}')"
            local_ip="${local_ip/', Bcast'}"
        ;;
    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 ", "}')"
    users="${users%\,*}"
}

get_install_date() {
    case "$os" in
        "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" ;;
        "Windows")
            case "$kernel_name" in
                "CYGWIN"*) install_file="/cygdrive/c/Windows/explorer.exe" ;;
                "MSYS"*) install_file="/c/Windows/explorer.exe" ;;
            esac
        ;;
        "Haiku") install_file="/boot" ;;
        "BSD" | "MINIX")
            case "$kernel_name" in
                "FreeBSD") install_file="/etc/hostid" ;;
                "NetBSD" | "DragonFly"*) install_file="/etc/defaults/rc.conf" ;;
                *) install_file="/" ;;
            esac
        ;;
        "AIX") install_file="/var/adm/ras/bosinstlog" ;;
    esac

    ls_prog="$(ls --version 2>&1)"
    case "$ls_prog" in
        *"BusyBox"*) install_date="$(ls -tdce "$install_file" | awk '{printf $10 " " $7 " " $8 " " $9}')" ;;
        *"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"*) err "Install Date doesn't work because your 'ls' does not support showing full date and time."; return ;; # AIX ls
        *) install_date="$(ls -dlctT "$install_file" | awk '{printf $9 " " $6 " "$7 " " $8}')" ;;
    esac

    install_date="${install_date//-/ }"
    install_date="${install_date%:*}"
    install_date=($install_date)
    install_date="$(convert_time "${install_date[@]}")"
}

get_cols() {
    if [[ "$color_blocks" == "on" ]]; then
        # Convert the width to space chars.
        printf -v block_width "%${block_width}s"

        # Set variables.
        start="${block_range[0]}"
        end="${block_range[1]}"

        # Generate the string.
        for ((start; start<=end; start++)); do
            case "$start" in
                [0-6]) blocks+="${reset}\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 spaces "%${block_height}s"

        # Convert the spaces into rows of blocks.
        [[ "$blocks" ]] &&  cols+="${spaces// /${blocks}${reset}nl}"
        [[ "$blocks2" ]] && cols+="${spaces// /${blocks2}${reset}nl}"

        # Add newlines to the string.
        cols="${cols%%'nl'}"
        cols="${cols//nl/\\n\\033[${text_padding}C${zws}}"

        printf "%b\n" "\033[${text_padding}C${zws}${cols}"
        info_height="$((info_height+=block_height+2))"
    fi

    unset -v blocks blocks2 cols

    # Tell info() that we printed manually.
    prin=1
}

# IMAGES

get_image_backend() {
    # This function determines which image backend to use
    # by checking for programs and etc.

    # If the image source isn't "ascii" or "off".
    if [[ ! "${image_source}" =~ ^(off|ascii)$ ]]; then
        # If X isn't running force ascii mode here.
        [[ -z "$DISPLAY" ]] && image_source="ascii"

        # Fallback to ascii mode if imagemagick isn't installed.
        type -p convert >/dev/null 2>&1 || image_source="ascii"
    fi

    # Get the image program.
    get_image_program

    # If image source is ascii fallback to ascii.
    if [[ "$image_source" == "ascii" ]]; then
        to_ascii "Image: \$image_source set to 'ascii', falling back to ascii mode."
        err "Image: Change \$image_source to another value to use image mode."
        return
    fi

    case "${image_backend:=image}" in
        "image")
            case "$image_source" in
                "wall"*) get_wallpaper 2>/dev/null ;;
                "off") image_backend="off"; return ;;
                *)
                    if [[ -d "$image_source" ]]; then
                        files=("${image_source%/}"/*.{png,jpg,jpeg})
                        printf -v image "%s" "${files[RANDOM % (${#files[@]} - 1)]}"
                    else
                        image="$image_source"
                    fi
                ;;
            esac

            # Fallback to ascii mode if image isn't a file.
            if [[ ! -f "$image" ]]; then
                to_ascii "Image: '$image' doesn't exist, falling back to ascii mode."
                return
            fi

            get_term_size

            # Fallback to ascii mode if terminal size wasn't found.
            if [[ -z "$term_width" ]] || ((term_width == 0)); then
                to_ascii "Image: Failed to find terminal window size"
                err "Image: Check the 'Images in the terminal' wiki page for more info"
                return
            fi

            get_image_size
            make_thumbnail

            # If the backend is still set to "image" after
            # make_thumbnail(), then display the image.
            [[ "$image_backend" == "image" ]] && display_image
        ;;

        "ascii") get_ascii 2>/dev/null ;;
    esac

    # Set cursor position next to ascii art.
    [[ "$image_backend" != "off" ]] && printf "%b" "\033[${lines:-0}A\033[9999999D"
}

get_ascii() {
    if [[ ! -f "$ascii" || "$ascii" == "distro" ]]; then
        # Fallback to distro ascii mode if custom ascii isn't found.
        [[ "$ascii" != "distro" && ! -f "$ascii" ]] && \
            err "Ascii: Ascii file not found, using distro ascii."

        if [[ -d "/usr/share/neofetch/ascii/distro" ]]; then
            ascii_dir="/usr/share/neofetch/ascii/distro"

        elif [[ -d "/usr/local/share/neofetch/ascii/distro" ]]; then
            ascii_dir="/usr/local/share/neofetch/ascii/distro"

        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"

        else
            get_script_dir 2>/dev/null
            ascii_dir="${script_dir}/ascii/distro"
        fi

        ascii="${ascii_dir}/${ascii_file}"

        # Fallback to no ascii mode if distro ascii isn't found.
        [[ ! -f "$ascii" ]] && \
            { to_off "Ascii: Failed to find distro ascii, falling back to no ascii mode."; return; }
    fi

    # Set locale to get correct padding.
    export LC_ALL="$sys_locale"

    # Turn file into variable.
    while IFS=$'\n' read -r line 2>/dev/null; do
        print+="$line \n"

        # Calculate size of ascii file in line length / line count.
        line="${line//\$\{??\}}"
        line="${line//\\\\/\\}"
        ((${#line} > ascii_length)) && ascii_length="${#line}"
        ((++lines))
    done < "$ascii"

    # Colors.
    print="${print//'${c1}'/$c1}"
    print="${print//'${c2}'/$c2}"
    print="${print//'${c3}'/$c3}"
    print="${print//'${c4}'/$c4}"
    print="${print//'${c5}'/$c5}"
    print="${print//'${c6}'/$c6}"

    # Overwrite padding if ascii_length_force is set.
    [[ "$ascii_length_force" ]] && ascii_length="$ascii_length_force"

    text_padding="$((ascii_length + gap))"
    printf "%b" "$print"
    export LC_ALL=C
}

get_image_program() {
    if [[ -n "$ITERM_PROFILE" ]]; then
        image_program="iterm2"

    elif [[ "$(tycat 2>/dev/null)" ]]; then
        image_program="tycat"

    else
        image_program="w3m"
        get_w3m_img_path
    fi
}

get_w3m_img_path() {
    if [[ -x "$w3m_img_path" ]]; then
        return

    elif [[ -x "/usr/lib/w3m/w3mimgdisplay" ]]; then
        w3m_img_path="/usr/lib/w3m/w3mimgdisplay"

    elif [[ -x "/usr/libexec/w3m/w3mimgdisplay" ]]; then
        w3m_img_path="/usr/libexec/w3m/w3mimgdisplay"

    elif [[ -x "/usr/lib64/w3m/w3mimgdisplay" ]]; then
        w3m_img_path="/usr/lib64/w3m/w3mimgdisplay"

    elif [[ -x  "/usr/libexec64/w3m/w3mimgdisplay" ]]; then
        w3m_img_path="/usr/libexec64/w3m/w3mimgdisplay"

    else
        image_backend="ascii"
        err "Image: w3m-img wasn't found on your system, falling back to ascii mode."
    fi
}

get_wallpaper() {
    case "$os" in
        "Linux" | "BSD" | "Solaris" | "MINIX" | "AIX")
            # Get DE if user has disabled the function.
            ((de_run != 1)) && get_de

            case "$de" in
                "MATE"*) image="$(gsettings get org.mate.background picture-filename)" ;;
                "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")"
                ;;

                *)
                    if type -p feh >/dev/null && [[ -f "${HOME}/.fehbg" ]]; then
                        image="$(awk -F\' '/feh/ {printf $2}' "${HOME}/.fehbg")"

                    elif type -p nitrogen >/dev/null; then
                        image="$(awk -F'=' '/file/ {printf $2;exit;}' "${XDG_CONFIG_HOME}/nitrogen/bg-saved.cfg")"

                    else
                        image="$(gsettings get org.gnome.desktop.background picture-uri)"
                        image="$(decode_url "$image")"
                    fi
                ;;
            esac

            # Strip un-needed info from the path.
            image="${image/'file://'}"
            image="$(trim_quotes "$image")"
        ;;

        "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"*)  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
        ;;
    esac

    # If image is an xml file, don't use it.
    [[ "${image/*\./}" == "xml" ]] && image=""
}

get_term_size() {
    # This functions gets the current window size in
    # pixels.
    #
    # We first try to use the escape sequence "\044[14t"
    # to get the terminal window size in pixels. If this
    # fails we then fallback to using "xdotool" or other
    # programs.

    # Tmux has a special way of reading escape sequences
    # so we have to use a slightly different sequence to
    # get the terminal size.
    if [[ -n "$TMUX" ]]; then
        printf "%b" "\033Ptmux;\033\033[14t\033\033[c\033\\"
        read_flags=(-d c)

    elif [[ "$image_program" == "tycat" ]]; then
        printf "%b" "\033}qs\000"

    else
        printf "%b" "\033[14t\033[c"
        read_flags=(-d c)
    fi

    # 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.
    IFS=";" read -s -t 1 "${read_flags[@]}" -r -a term_size

    # Split the string into height/width.
    if [[ "$image_program" == "tycat" ]]; then
        term_width="$((term_size[2] * term_size[0]))"
        term_height="$((term_size[3] * term_size[1]))"

    else
        term_height="${term_size[1]}"
        term_width="${term_size[2]/t*}"
    fi

    # Get terminal width/height if \033[14t is unsupported.
    if [[ -z "$term_width" && "$image_program" == "w3m" ]]; then
        if type -p xdotool >/dev/null 2>&1; then
            current_window="$(xdotool getactivewindow)"
            source <(xdotool getwindowgeometry --shell "$current_window")
            term_height="$HEIGHT"
            term_width="$WIDTH"

        elif type -p xwininfo >/dev/null 2>&1; then
            # Get the focused window's ID.
            if type -p xdpyinfo >/dev/null 2>&1; then
                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

            # 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
                term_width=0
            fi
        else
            term_width=0
        fi
    fi

    # If the terminal size was found correctly.
    if [[ "$term_width" ]] && ((term_width >= 1)); then
        clear
        zws="​ "
    fi
}

get_image_size() {
    # This functions determines the size to make
    # the thumbnail image.

    # Get terminal lines and columns.
    term_blocks="$(stty size)"
    columns="${term_blocks/* }"
    lines="${term_blocks/ *}"

    # Calculate font size.
    font_width="$((term_width / columns))"
    font_height="$((term_height / lines))"

    case "$image_size" in
        "auto")
            image_size="$((columns * font_width / 2))"
            term_height="$((term_height - term_height / 4))"

            ((term_height < image_size)) && \
                image_size="$term_height"
        ;;

        *"%")
            percent="${image_size/\%}"
            image_size="$((percent * term_width / 100))"

            (((percent * term_height / 50) < image_size)) && \
                image_size="$((percent * term_height / 100))"
        ;;

        "none")
            # Get image size so that we can do a better crop.
            size="$(identify -format "%w %h" "$image")"
            width="${size%% *}"
            height="${size##* }"
            crop_mode="none"
        ;;

        *) image_size="${image_size/px}" ;;
    esac

    width="${width:-$image_size}"
    height="${height:-$image_size}"

    text_padding="$((width / font_width + gap + xoffset/font_width))"
}

make_thumbnail() {
    # Name the thumbnail using variables so we can
    # use it later.
    image_name="$crop_mode-$crop_offset-$width-$height"

    # Check to see if the image has a file extension,
    # if it doesn't then add one.
    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.
    if [[ ! -f "$thumbnail_dir/$image_name" ]]; then
        # Get image size so that we can do a better crop.
        if [[ -z "$size" ]]; then
            size="$(identify -format "%w %h" "$image")"
            og_width="${size%% *}"
            og_height="${size##* }"

            # This checks to see if height is greater than width
            # so we can do a better crop of portrait images.
            size="$og_height"
            ((og_height > og_width)) && size="$og_width"
        fi

        case "$crop_mode" in
            "fit")
                c="$(convert "$image" \
                    -colorspace srgb \
                    -format "%[pixel:p{0,0}]" info:)"

                convert \
                    "$image" \
                    -trim +repage \
                    -gravity south \
                    -background "$c" \
                    -extent "$size"x"$size" \
                    -scale "$width"x"$height" \
                    "$thumbnail_dir/$image_name"
            ;;

            "fill")
                convert \
                    "$image" \
                    -trim +repage \
                    -scale "$width"x"$height"^ \
                    -extent "$width"x"$height" \
                    "$thumbnail_dir/$image_name"
            ;;

            "none") cp "$image" "$thumbnail_dir/$image_name" ;;
            *)
                convert \
                    "$image" \
                    -gravity "$crop_offset" \
                    -crop "$size"x"$size"+0+0 \
                    -quality 95 \
                    -scale "$width"x"$height" \
                    "$thumbnail_dir/$image_name"
            ;;
        esac
    fi

    # The final image.
    image="$thumbnail_dir/$image_name"
}

display_image() {
    case "$image_program" in
        "w3m")
            # 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" -bg "$background_color" >/dev/null & 2>&1 || to_off "Images: w3m-img failed to display the image."
        ;;

        "iterm2")
            printf "%b\a\n" "\033]1337;File=width=${width}px;height=${height}px;inline=1:$(base64 < "$image")"
        ;;

        "tycat")
            tycat "$image" || to_off "Images: tycat failed to display the image."
        ;;
    esac
}

to_ascii() {
    # This function makes neofetch fallback to ascii mode.
    image_backend="ascii"

    # Print the ascii art.
    get_ascii 2>/dev/null

    # Move cursor next to ascii art.
    printf "%b" "\033[${lines:-0}A\033[9999999D"

    # Log the error.
    err "$1"
}

to_off() {
    # This function makes neofetch fallback to off mode.
    image_backend="off"
    text_padding=
    zws=
    err "$1"
}

# SCREENSHOT

take_scrot() {
    if [[ -d "$scrot_dir" ]]; then
        scrot_program "${scrot_dir}${scrot_name}" 2>/dev/null
    else
        printf "%s\n" "Screenshot: $scrot_dir doesn't exist. Edit the config file or create the directory to take screenshots."
    fi

    [[ "$scrot_upload" == "on" ]] && scrot_upload
}

scrot_upload() {
    if ! type -p curl >/dev/null 2>&1; then
        printf "%s\n" "[!] Install curl to upload images"
        return
    fi

    image_file="${scrot_dir}${scrot_name}"
    printf "%s\n" "Uploading image..."

    case "$image_host" in
        "teknik")
            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//\"}")"
        ;;

        "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"
        ;;
    esac

    printf "%s\n" "${image_url:-'[!] Image failed to upload'}"
}

scrot_args() {
    scrot="on"
    case "$2" in
        "-"* | "") ;;
        *)
            scrot_name="${2##*/}"
            scrot_dir="${2/$scrot_name}"
        ;;
    esac
}

scrot_program() {
    # Detect screenshot program.
    #
    # We first check to see if an X server is running before
    # falling back to OS specific screenshot tools.
    if [[ -n "$DISPLAY" ]]; then
        if [[ "$scrot_cmd" != "auto" ]] && type -p "$scrot_cmd" >/dev/null; then
            scrot_program=("$scrot_cmd")

        elif type -p scrot >/dev/null; then
            scrot_program=(scrot)

        elif type -p maim >/dev/null; then
            scrot_program=(maim)

        elif type -p import >/dev/null; then
            scrot_program=(import -window root)

        elif type -p imlib2_grab >/dev/null; then
            scrot_program=(imlib2_grab)

        elif type -p gnome-screenshot >/dev/null; then
            scrot_program=(gnome-screenshot -f)

        else
            err "Scrot: No screen capture tool found."
            return
        fi
    else
        case "$os" in
            "Mac OS X") scrot_program=(screencapture -S) ;;
            "Haiku") scrot_program=(screenshot -s) ;;
        esac
    fi

    # Take the scrot.
    "${scrot_program[@]}" "$1"

    err "Scrot: Screen captured using ${scrot_program[0]}"
}

# TEXT FORMATTING

info() {
    # Save subtitle value.
    subtitle="$1"

    # Make sure that $prin is unset.
    unset -v prin

    # Call the function.
    "get_${2:-$1}" 2>/dev/null

    # If the get_func function called 'prin' directly, stop here.
    [[ "$prin" ]] && return

    # Update the variable.
    output="$(trim "${!2:-${!1}}")"

    if [[ "$2" && "${output// }" ]]; then
        length="$((${#1} + ${#output} + 2))"
        prin "$1" "$output"

    elif [[ "${output// }" ]]; then
        [[ -z "$length" ]] && length="${#output}"
        prin "$output"

    else
        err "Info: Couldn't detect ${1}."
    fi
}

prin() {
    # If $2 doesn't exist we format $1 as info.
    [[ -z "$2" ]] && local subtitle_color="$info_color"

    # Format the output.
    string="${1//$'\033[0m'}${2:+: $2}"
    string="$(trim "$string")"
    string="${string/:/${reset}${colon_color}:${info_color}}"
    string="${subtitle_color}${bold}${string}"

    # Print the info.
    printf "%b\n" "${text_padding:+\033[${text_padding}C}${zws}${string}${reset} "

    # Calculate info height.
    ((++info_height))

    # Log that prin was used.
    prin=1
}

get_underline() {
    if [[ "$underline_enabled" == "on" ]]; then
        printf -v underline "%${length}s"
        underline="${underline_color}${underline// /$underline_char}"
        unset -v length
    fi
}

get_line_break() {
    # Print it directly.
    printf "%s\n" "${zws} "

    # Calculate info height.
    ((++info_height))

    # Tell info() that we printed manually.
    prin=1
}

get_bold() {
    case "$ascii_bold" in
        "on") ascii_bold="\033[1m" ;;
        "off") ascii_bold="" ;;
    esac

    case "$bold" in
        "on") bold="\033[1m" ;;
        "off") bold="" ;;
    esac
}

trim() {
    # When a string is passed to "echo" all trailing and leading
    # whitespace is removed and inside the string multiple spaces are
    # condensed into single spaces.
    #
    # The "set -f/+f" is here so that "echo" doesn't cause any expansion
    # of special characters.
    #
    # The whitespace trim doesn't work with multiline strings so we use
    # "${1//[[:space:]]/ }" to remove newlines before we trim the whitespace.

    set -f
    # shellcheck disable=2086
    builtin echo -E ${1//[[:space:]]/ }
    set +f
}

trim_quotes() {
    trim_output="${1//\'}"
    trim_output="${trim_output//\"}"
    printf "%s" "$trim_output"
}

uppercase() {
    ((bash_version >= 4)) && printf "%s" "${1^}"
}

# COLORS

get_distro_colors() {
    # This function sets the text colors according
    # to your OS/Distro's logo colors.
    #
    # $ascii_distro is the same as $distro.
    case "$ascii_distro" in
        "AIX"*)
            set_colors 2 7
            ascii_file="aix"
        ;;

        "alpine_small")
            set_colors 4 7
            ascii_file="alpine_small"
        ;;

        "Alpine"*)
            set_colors 4 5 7 6
            ascii_file="alpine"
        ;;

        "Android"*)
            set_colors 2 7
            ascii_file="android"
            ascii_length_force=19
        ;;

        "Antergos"*)
            set_colors 4 6
            ascii_file="antergos"
        ;;

        "antiX"*)
            set_colors 1 7 3
            ascii_file="antix"
        ;;

        "AOSC"*)
            set_colors 4 7 1
            ascii_file="aosc"
        ;;

        "Apricity"*)
            set_colors 4 7 1
            ascii_file="apricity"
        ;;

        "arch_small")
            set_colors 4 7 1
            ascii_file="arch_small"
        ;;

        "arch_old")
            set_colors 4 7 1
            ascii_file="arch_old"
        ;;

        "Arch"*)
            set_colors 4 7 1
            ascii_file="arch"
        ;;

        "Bitrig"*)
            set_colors 2 7
            ascii_file="bitrig"
        ;;

        "BLAG"*)
            set_colors 5 7
            ascii_file="blag"
        ;;

        "BlankOn"*)
            set_colors 1 7 3
            ascii_file="blankon"
        ;;

       "BSD")
            set_colors 1 7 4 3 6
            ascii_file="bsd"
        ;;

        "BunsenLabs"*)
            set_colors fg 7
            ascii_file="bunsenlabs"
        ;;

        "CentOS"*)
            set_colors 3 2 4 5 7
            ascii_file="centos"
        ;;

        "Chakra"*)
            set_colors 4 5 7 6
            ascii_file="chakra"
        ;;

        "ChaletOS"*)
            set_colors 4 7 1
            ascii_file="chaletos"
        ;;

        "Chapeau"*)
            set_colors 2 7
            ascii_file="chapeau"
        ;;

        "Chrom"*)
            set_colors 2 1 3 4 7
            ascii_file="chrome"
        ;;

        "crux_small")
            set_colors 4 5 7 6
            ascii_file="crux_small"
        ;;

        "CRUX"*)
            set_colors 4 5 7 6
            ascii_file="crux"
        ;;

        "Debian"*)
            set_colors 1 7 3
            ascii_file="debian"
        ;;

        "Deepin"*)
            set_colors 2 7
            ascii_file="deepin"
        ;;

        "Devuan"*)
            set_colors 5 7
            ascii_file="devuan"
        ;;

        "DracOS"*)
            set_colors 1 7 3
            ascii_file="dracos"
        ;;

        "DragonFly"*)
            set_colors 1 7 3
            ascii_file="dragonflybsd"
        ;;

        "Elementary"*)
            set_colors 4 7 1
            ascii_file="elementary"
        ;;

        "Exherbo"*)
            set_colors 4 7 1
            ascii_file="exherbo"
        ;;

        "Fedora"* | "RFRemix"*)
            set_colors 4 7 1
            ascii_file="fedora"
        ;;

        "FreeBSD"*)
            set_colors 1 7 3
            ascii_file="freebsd"
        ;;

        "Frugalware"*)
            set_colors 4 7 1
            ascii_file="frugalware"
        ;;

        "Funtoo"*)
            set_colors 5 7
            ascii_file="funtoo"
        ;;

        "GalliumOS"*)
            set_colors 4 7 1
            ascii_file="galliumos"
        ;;

        "gentoo_small")
            set_colors 5 7
            ascii_file="gentoo_small"
        ;;

        "Gentoo"*)
            set_colors 5 7
            ascii_file="gentoo"
        ;;

        "gNewSense"*)
            set_colors 4 5 7 6
            ascii_file="gnewsense"
        ;;

        "GNU")
            set_colors fg 7
            ascii_file="gnu"
        ;;

        "GoboLinux"*)
            set_colors 5 4 6 2
            ascii_file="gobolinux"
        ;;

        "Grombyang"*)
            set_colors 4 2 1
            ascii_file="grombyang"
        ;;

        "GuixSD"*)
            set_colors 3 7 6 1 8
            ascii_file="guixsd"
        ;;

        "Haiku"*)
            set_colors 2 8
            ascii_file="haiku"
        ;;

        "Kali"*)
            set_colors 4 8
            ascii_file="kali"
        ;;

        "KaOS"*)
            set_colors 4 7 1
            ascii_file="kaos"
        ;;

        "KDE"*)
            set_colors 2 7
            ascii_file="kde"
        ;;

        "Kogaion"*)
            set_colors 4 7 1
            ascii_file="kogaion"
        ;;

        "Korora"*)
            set_colors 4 7 1
            ascii_file="korora"
        ;;

        "Kubuntu"*)
            set_colors 4 7 1
            ascii_file="kubuntu"
        ;;

        "Linux")
            set_colors fg 8 3
            ascii_file="linux"
        ;;

        "LMDE"*)
            set_colors 2 7
            ascii_file="lmde"
        ;;

        "Lubuntu"*)
            set_colors 4 7 1
            ascii_file="lubuntu"
        ;;

        "mac" | "Darwin")
            set_colors 2 3 1 1 5 4
            ascii_file="mac"
        ;;

        "Mageia"*)
            set_colors 6 7
            ascii_file="mageia"
        ;;

        "Manjaro"*)
            set_colors 2 7
            ascii_file="manjaro"
        ;;

        "Minix"*)
            set_colors 1 7 3
            ascii_file="minix"
        ;;

        "Linux Mint"* | "LinuxMint"*)
            set_colors 2 7
            ascii_file="mint"
        ;;

        "MX"*)
            set_colors 4 6 7
            ascii_file="mx"
        ;;

        "NetBSD"*)
            set_colors 5 7
            ascii_file="netbsd"
        ;;

        "Netrunner"*)
            set_colors 4 7 1
            ascii_file="netrunner"
        ;;

        "NixOS"*)
            set_colors 4 6
            ascii_file="nixos"
        ;;

        "openbsd_small")
            set_colors 3 7 6 1 8
            ascii_file="openbsd_small"
        ;;

        "OpenBSD"*)
            set_colors 3 7 6 1 8
            ascii_file="openbsd"
        ;;

        "OpenIndiana"*)
            set_colors 4 7 1
            ascii_file="openindiana"
        ;;

        "OpenMandriva"*)
            set_colors 4 3
            ascii_file="openmandriva"
        ;;

        "OpenWrt"*)
            set_colors 4 7 1
            ascii_file="openwrt"
        ;;

        "Open Source Media Center"* | "osmc")
            set_colors 4 7 1
            ascii_file="osmc"
        ;;

        "Oracle"*)
            set_colors 1 7 3
            ascii_file="oracle"
        ;;

        "PacBSD"*)
            set_colors 1 7 3
            ascii_file="pacbsd"
        ;;

        "Parabola"*)
            set_colors 5 7
            ascii_file="parabola"
        ;;

        "Pardus"*)
            set_colors 3 7 6 1 8
            ascii_file="pardus"
        ;;

        "Parrot"*)
            set_colors 6 7
            ascii_file="parrot"
        ;;

        "PCBSD"* | "TrueOS"*)
            set_colors 1 7 3
            ascii_file="trueos"
        ;;

        "PCLinuxOS"*)
            set_colors 4 7 1
            ascii_file="pclinuxos"
        ;;

        "Peppermint"*)
            set_colors 1 7 3
            ascii_file="peppermint"
        ;;

        "Porteus"*)
            set_colors 6 7
            ascii_file="porteus"
        ;;

        "Puppy"* | "Quirky Werewolf"* | "Precise Puppy"*)
            set_colors 4 7
            ascii_file="puppy"
        ;;

        "Qubes"*)
            set_colors 4 5 7 6
            ascii_file="qubes"
        ;;

        "Raspbian"*)
            set_colors 2 1
            ascii_file="raspbian"
        ;;

        "Red Star"* | "Redstar"*)
            set_colors 1 7 3
            ascii_file="redstar"
        ;;

        "Redhat"* | "Red Hat"* | "rhel"*)
            set_colors 1 7 3
            ascii_file="redhat"
        ;;

        "Rosa"*)
            set_colors 4 7 1
            ascii_file="rosa"
        ;;

        "Sabayon"*)
            set_colors 4 7 1
            ascii_file="sabayon"
        ;;

        "SailfishOS"*)
            set_colors 4 5 7 6
            ascii_file="sailfishos"
        ;;

        "SalentOS"*)
            set_colors 2 1 3 7
            ascii_file="salentos"
        ;;

        "Scientific"*)
            set_colors 4 7 1
            ascii_file="scientific"
        ;;

        "Slackware"*)
            set_colors 4 7 1
            ascii_file="slackware"
        ;;

        "SmartOS"*)
            set_colors 6 7
            ascii_file="smartos"
        ;;

        "Solus"*)
            set_colors 4 7 1
            ascii_file="solus"
        ;;

        "Sparky"*)
            set_colors 1 7
            ascii_file="sparky"
        ;;

        "SteamOS"*)
            set_colors 5 7
            ascii_file="steamos"
        ;;

        "SunOS" | "Solaris")
            set_colors 3 7
            ascii_file="solaris"
        ;;

        "openSUSE"* | "open SUSE"* | "SUSE"*)
            set_colors 2 7
            ascii_file="suse"
        ;;

        "SwagArch"*)
            set_colors 4 7 1
            ascii_file="swagarch"
        ;;

        "Tails"*)
            set_colors 5 7
            ascii_file="tails"
        ;;

        "Trisquel"*)
            set_colors 4 6
            ascii_file="trisquel"
        ;;

        "Ubuntu-Budgie"*)
            set_colors 4 7 1
            ascii_file="ubuntu-budgie"
        ;;

        "Ubuntu-GNOME"*)
            set_colors 4 5 7 6
            ascii_file="ubuntu-gnome"
        ;;

        "ubuntu_old")
            set_colors 1 7 3
            ascii_file="ubuntu_old"
        ;;

        "Ubuntu"*)
            set_colors 1 7 3
            ascii_file="ubuntu"
        ;;

        "void_small")
            set_colors 2 8
            ascii_file="void_small"
        ;;

        "Void"*)
            set_colors 2 8
            ascii_file="void"
        ;;

        "Windows 8"* | "Windows 10"*)
            set_colors 6 7
            ascii_file="windows10"
        ;;

        "Windows"*)
            set_colors 1 2 4 3
            ascii_file="windows"
        ;;

        "Xubuntu"*)
            set_colors 4 7 1
            ascii_file="xubuntu"
        ;;

        "Zorin"*)
            set_colors 4 6
            ascii_file="zorin"
        ;;

        *)
            case "$kernel_name" in
                *"BSD")
                    set_colors 1 7 4 3 6
                    ascii_file="bsd"
                ;;

                "Darwin")
                    set_colors 2 3 1 1 5 4
                    ascii_file="mac"
                ;;

                "GNU"*)
                    set_colors fg 7
                    ascii_file="gnu"
                ;;

                "Linux")
                    set_colors fg 8 3
                    ascii_file="linux"
                ;;

                "SunOS")
                    set_colors 3 7
                    ascii_file="solaris"
                ;;
            esac
        ;;
    esac

    # Overwrite distro colors if '$ascii_colors' doesn't
    # equal 'distro'.
    if [[ "${ascii_colors[0]}" != "distro" ]]; then
        color_text="off"
        set_colors "${ascii_colors[@]}"
    fi
}

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

    [[ "$color_text" != "off" ]] && set_text_colors "$@"
}

set_text_colors() {
    if [[ "${colors[0]}" == "distro" ]]; then
        title_color="$(color "$1")"
        at_color="$reset"
        underline_color="$reset"
        subtitle_color="$(color "$2")"
        colon_color="$reset"
        info_color="$reset"

        # If the ascii art uses 8 as a color, make the text the fg.
        ((${1:-1} == 8)) && title_color="$reset"
        ((${2:-7} == 8)) && subtitle_color="$reset"

        # If the second color is white use the first for the subtitle.
        ((${2:-7} == 7)) && subtitle_color="$(color "$1")"
        ((${1:-1} == 7)) && title_color="$reset"
    else
        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]}")"
    fi

    # Bar colors.
    if [[ "$bar_color_elapsed" == "distro" ]]; then
        bar_color_elapsed="$(color fg)"
    else
        bar_color_elapsed="$(color "$bar_color_elapsed")"
    fi

    case "$bar_color_total $1" in
        "distro "[736]) bar_color_total="$c2" ;;
        "distro "[0-9]) bar_color_total="$c1" ;;
        *) bar_color_total="$(color "$bar_color_total")" ;;
    esac
}

color() {
    case "$1" in
        [0-6]) printf "%b" "${reset}\033[3${1}m" ;;
        7 | "fg") printf "%b" "$reset" ;;
        *) printf "%b" "\033[38;5;${1}m" ;;
    esac
}

# OTHER

err() {
    err+="$(color 1)[!]\033[0m $1\n"
}

get_script_dir() {
    [[ "$script_dir" ]] && return

    # Use $0 to get the script's physical path.
    cd "${0%/*}" || exit
    script_dir="${0##*/}"

    # Iterate down a (possible) chain of symlinks.
    while [[ -L "$script_dir" ]]; do
        script_dir="$(readlink "$script_dir")"
        cd "${script_dir%/*}" || exit
        script_dir="${script_dir##*/}"
    done

    # Final directory.
    script_dir="$(pwd -P)"
}

get_default_config() {
    if [[ -f "/usr/share/neofetch/config" ]]; then
        default_config="/usr/share/neofetch/config"

    elif [[ -f "/usr/local/share/neofetch/config" ]]; then
        default_config="/usr/local/share/neofetch/config"

    elif [[ -f "/data/data/com.termux/files/usr/share/neofetch/config" ]]; then
        default_config="/data/data/com.termux/files/usr/share/neofetch/config"

    else
        get_script_dir
        default_config="${script_dir}/config/config"
        travis_config="${script_dir}/config/travis"
    fi

    if source "$default_config"; then
        err "Config: Sourced default config. (${default_config})"
    else
        err "Config: Default config not found, continuing..."
    fi
}

get_user_config() {
    # Check $config_file.
    if [[ -f "$config_file" ]]; then
        source "$config_file"
        err "Config: Sourced user config.    (${config_file})"
        old_options
        return

    elif [[ "$config_file" == "travis" ]]; then
        source "$travis_config"
        err "Config: Sourced user config.    (${travis_config})"
        old_options
        return
    fi
    mkdir -p "${XDG_CONFIG_HOME}/neofetch/"

    # Check ${XDG_CONFIG_HOME}/neofetch and create the
    # dir/files if they don't exist.
    if [[ -f "${XDG_CONFIG_HOME}/neofetch/config" ]]; then
        config_file="${XDG_CONFIG_HOME}/neofetch/config"

    elif [[ -f "/usr/share/neofetch/config" ]]; then
        cp "/usr/share/neofetch/config" "${XDG_CONFIG_HOME}/neofetch"
        config_file="${XDG_CONFIG_HOME}/neofetch/config"

    elif [[ -f "/usr/local/share/neofetch/config" ]]; then
        cp "/usr/local/share/neofetch/config" "${XDG_CONFIG_HOME}/neofetch"
        config_file="${XDG_CONFIG_HOME}/neofetch/config"

    else
        get_script_dir

        cp "${script_dir}/config/config" "${XDG_CONFIG_HOME}/neofetch"
        config_file="${XDG_CONFIG_HOME}/neofetch/config"
    fi

    source "$config_file"
    err "Config: Sourced user config.    (${config_file})"
    old_options
}

bar() {
    # Get the values.
    elapsed="$(($1 * bar_length / $2))"

    # Create the bar with spaces.
    printf -v prog  "%${elapsed}s"
    printf -v total "%$((bar_length - elapsed))s"

    # 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}"

    # Borders.
    [[ "$bar_border" == "on" ]] && \
        bar="$(color fg)[${bar}$(color fg)]"

    printf "%b\n" "${bar}${info_color}"
}

cache() {
    if [[ "$2" ]]; then
        mkdir -p "${cache_dir}/neofetch"
        printf "%s" "${1/*-}=\"$2\"" > "${cache_dir}/neofetch/${1/*-}"
    fi
}

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)"

    elif type -p kde4-config >/dev/null 2>&1; then
        kde_config_dir="$(kde4-config --path config)"

    elif type -p kde-config >/dev/null 2>&1; then
        kde_config_dir="$(kde-config --path config)"

    elif [[ -d "${HOME}/.kde4" ]]; then
        kde_config_dir="${HOME}/.kde4/share/config"

    elif [[ -d "${HOME}/.kde3" ]]; then
        kde_config_dir="${HOME}/.kde3/share/config"
    fi

    kde_config_dir="${kde_config_dir/$'/:'*}"
}

get_term_padding() {
    # Terminal info.
    #
    # 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.
    ((term_run != 1)) && get_term

    case "$term" in
        "URxvt"*)
            border="$(xrdb -query | awk -F ':' '/^(URxvt|\*).internalBorder/ {printf $2; exit}')"
        ;;
    esac
}

dynamic_prompt() {
    case "$image_backend" in
        "image")
            get_term_padding 2>/dev/null

            # Calculate image height in terminal cells.
            lines="$(((border * 2 + height + yoffset) / font_height))"
        ;;
        "off") return ;;
    esac

    # If the info is higher than the ascii/image place the prompt
    # based on the info height instead of the ascii/image height.
    if ((lines < info_height)); then
        printf "\n"
        return
    else
        lines="$((lines - info_height))"
    fi

    # Set the prompt location.
    if ((lines < 0)); then
        printf "%b" "\033[${lines/-}A"
    else
        printf "%b" "\033[${lines}B"
    fi

    # Add some padding.
    printf "\n\n\n\n"
}

old_functions() {
    # Deprecated functions.
    # 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() {
    [[ -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"; }

    # All progress_ variables were changed to bar_.
    [[ -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."
    [[ -n "$progress_length" ]]        && err "Config: \$progress_length is deprecated, use \$bar_length instead."
    [[ -n "$progress_color_elapsed" ]] && err "Config: \$progress_color_elapsed is deprecated, use \$bar_color_elapsed instead."
    [[ -n "$progress_color_total" ]]   && err "Config: \$progress_color_total is deprecated, use \$bar_color_total instead."

    # All cpufreq values were changed in 2.1.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."

    # Ascii_logo_size was removed in 2.1.0.
    [[ "$ascii_logo_size" ]] && err "Config: ascii_logo_size is deprecated, use ascii_distro='{alpine,arch,crux,gentoo,openbsd,void}_small' instead."

    # $start and $end were replaced with ${block_range[@]} in 2.1.0.
    [[ "$start" && "$end" ]] && { err "Config: \$start and \$end are deprecated, use block_range=(0 7) instead."; block_range=("$start" "$end"); }

    # 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"; }
}

cache_uname() {
    # Cache the output of uname so we don't
    # have to spawn it multiple times.
    uname=($(uname -srm))

    kernel_name="${uname[0]}"
    kernel_version="${uname[1]}"
    machine_arch="${uname[2]}"
}

convert_time() {
    # Convert ls timestamp to 'Tue 06 Dec 2016 4:58 PM' format.
    year="$1"
    day="$3"

    # Split time into hours/minutes.
    hour="${4/:*}"
    min="${4/${hour}}"

    # Get month. (Month code is used for day of week)
    # Due to different versions of 'ls', the month can be 1, 01 or Jan.
    case "$2" in
        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.
    # Source: http://stackoverflow.com/questions/725098/leap-year-calculation
    [[ "$((year % 4))" == 0 && "$((year % 100))" != 0 || "$((year % 400))" == 0 ]] && \
    [[ "$month" =~ (Jan|Feb) ]] && \
        leap_code=1

    # Calculate day of week.
    # Source: http://blog.artofmemory.com/how-to-calculate-the-day-of-the-week-4203.html
    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

    # 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
        ;;
        *) time="$4" ;;
    esac

    # Toggle showing the time.
    [[ "$install_time" == "off" ]] && unset time

    # 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:

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.

    --cpu_shorthand type        Shorten the output of CPU
                                Possible values: name, speed, tiny, on, off
    --cpu_cores type            Whether or not to display the number of CPU cores
                                Takes: logical, physical, off

                                NOTE: 'physical' doesn't work on BSD.

    --cpu_speed on/off          Hide/Show cpu speed.
    --cpu_temp C/F/off          Hide/Show cpu temperature.

                                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)

                                NOTE: This option won't work in Windows (Cygwin)

    --kernel_shorthand on/off   Shorten the output of kernel

                                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)
    --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)
    --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
    --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
    --disk_show value           Which disks to display.
                                Takes: '/', '/dev/sdXX', '/path/to/mount point'

                                NOTE: Multiple values can be given. (--disk_show '/' '/dev/sdc1')

    --disk_subtitle name/mount  What information to append to the Disk subtitle.

                                'name' shows the disk's name (sda1, sda2, etc)

                                'mount' shows the disk's mount point (/, /mnt/Local Disk, etc)

    --ip_host url               URL to query for public IP
    --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.

TEXT FORMATTING:
    --colors x x x x x x        Changes the text colors in this order:
                                title, @, underline, subtitle, colon, info
    --underline on/off          Enable/Disable the underline.
    --underline_char char       Character to use when underlining title
    --bold on/off               Enable/Disable bold text

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

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.
    --bar_colors num num        Colors to make the bar.
                                Set in this order: elapsed, total
    --cpu_display mode          Bar mode.
                                Takes: bar, infobar, barinfo, off
    --memory_display mode       Bar mode.
                                Takes: bar, infobar, barinfo, off
    --battery_display mode      Bar mode.
                                Takes: bar, infobar, barinfo, off
    --disk_display mode         Bar mode.
                                Takes: bar, infobar, barinfo, off
IMAGE:
    --image type                Image source. Where and what image we display.
                                Possible values: wall, ascii,
                                /path/to/img, /path/to/dir/, off
    --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.

ASCII:
    --ascii value               Where to get the ascii from, Possible values:
                                distro, /path/to/ascii
    --ascii_colors x x x x x x  Colors to print the ascii art
    --ascii_distro distro       Which Distro's ascii art to print

                                NOTE: Arch and Ubuntu have 'old' logo variants.

                                NOTE: Use 'arch_old' or 'ubuntu_old' to use the old logos.

                                NOTE: Ubuntu has flavor variants.

                                NOTE: Change this to 'Lubuntu', 'Xubuntu', 'Ubuntu-GNOME', 'Ubuntu-Studio' or 'Ubuntu-Budgie' to use the flavors.

                                NOTE: Alpine, Arch, Crux, Gentoo, OpenBSD, and Void have a smaller logo variant.

                                NOTE: Change this to 'alpine_small', 'arch_small', 'crux_small', 'gentoo_small', 'openbsd_small', and 'void_small' to use the small logos.

    --ascii_bold on/off         Whether or not to bold the ascii logo.
    -L, --logo                  Hide the info text and only show the ascii logo.

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.
    --image_host                Website to upload scrots to. Takes: imgur, teknik
    --scrot_cmd cmd             Screenshot program to launch

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
    --version                   Show neofetch version
    -v                          Display error messages.
    -vv                         Display a verbose log for error reporting.

DEVELOPER:
    --gen-man                   Generate a manpage for Neofetch in your PWD. (Requires GNU help2man)


Report bugs to https://github.com/dylanaraps/neofetch/issues

"
exit 1
}

version() { printf "%s" "\
Neofetch 2.1.0

Copyright (c) 2016-2017 Dylan Araps

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the 'Software'), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

THE 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

"
exit 1
}

get_args() {
    # Check the commandline flags early for '--config'.
    [[ "$@" =~ --config ]] || get_user_config 2>/dev/null

    while [[ "$1" ]]; do
        case "$1" in
            # Info
            "--os_arch") os_arch="$2" ;;
            "--cpu_cores") cpu_cores="$2" ;;
            "--cpu_speed") cpu_speed="$2" ;;
            "--speed_type") speed_type="$2" ;;
            "--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" ;;
            "--gpu_type") gpu_type="$2" ;;
            "--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" ;;
            "--cpu_temp")
                cpu_temp="$2"
                [[ "$cpu_temp" == "on" ]] && cpu_temp="C"
            ;;

            "--disk_subtitle") disk_subtitle="$2" ;;
            "--disk_show")
                unset disk_show
                for arg in "$@"; do
                    case "$arg" in
                        "--disk_show") ;;
                        "-"*) break ;;
                        *) disk_show+=($arg)
                    esac
                done
            ;;

            "--disable")
                for func in "$@"; do
                    case "$func" in
                        "--disable") continue ;;
                        "-"*) break ;;
                        *)
                            ((bash_version >= 4)) && func="${func,,}"
                            unset -f "get_$func"
                        ;;
                    esac
                done
            ;;

            # Text Colors
            "--colors")
                unset colors
                for arg in "$2" "$3" "$4" "$5" "$6" "$7"; do
                    case "$arg" in
                        "-"*) break ;;
                        *) colors+=($arg)
                    esac
                done
                colors+=(7 7 7 7 7 7)
            ;;

            # Text Formatting
            "--underline") underline_enabled="$2" ;;
            "--underline_char") underline_char="$2" ;;
            "--bold") bold="$2" ;;

            # Color Blocks
            "--color_blocks") color_blocks="$2" ;;
            "--block_range") block_range=("$2" "$3") ;;
            "--block_width") block_width="$2" ;;
            "--block_height") block_height="$2" ;;

            # Bars
            "--bar_char")
                bar_char_elapsed="$2"
                bar_char_total="$3"
            ;;

            "--bar_border") bar_border="$2" ;;
            "--bar_length") bar_length="$2" ;;
            "--bar_colors")
                bar_color_elapsed="$2"
                bar_color_total="$3"
            ;;

            "--cpu_display") cpu_display="$2" ;;
            "--memory_display") memory_display="$2" ;;
            "--battery_display") battery_display="$2" ;;
            "--disk_display") disk_display="$2" ;;

            # Image
            "--image")
                image_source="$2"
                case "$2" in "-"* | "" | "ascii") image_backend="ascii" ;; esac
            ;;

            "--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"
                rm -rf "/Library/Caches/neofetch/"
                rm -rf "/tmp/neofetch/"
                exit
            ;;

            # Ascii
            "--ascii")
                image_backend="ascii"
                ascii="$2"
                case "$2" in "-"* | "") ascii="distro" ;; esac
            ;;

            "--ascii_colors")
                unset ascii_colors
                for arg in "$2" "$3" "$4" "$5" "$6" "$7"; do
                    case "$arg" in
                        "-"*) break ;;
                        *) ascii_colors+=($arg)
                    esac
                done
                ascii_colors+=(7 7 7 7 7 7)
            ;;

            "--ascii_distro")
                image_backend="ascii"
                ascii_distro="$2"
                case "$2" in "-"* | "") ascii_distro="$distro" ;; esac
            ;;

            "--ascii_bold") ascii_bold="$2" ;;
            "--logo" | "-L")
                image_backend="ascii"
                print_info() { info line_break; }
            ;;

            # Screenshot
            "--scrot" | "-s")
                scrot_args "$@"
            ;;
            "--upload" | "-su")
                scrot_upload="on"
                scrot_args "$@"
            ;;

            "--image_host") image_host="$2" ;;
            "--scrot_cmd") scrot_cmd="$2" ;;

            # Other
            "--config")
                case "$2" in
                    "none" | "off" | "") config="off" ;;
                    *) config_file="$2"; config="on"; get_user_config 2>/dev/null ;;
                esac
            ;;
            "-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 ;;
        esac

        shift
    done
}

main() {
    cache_uname
    get_os
    get_default_config 2>/dev/null
    get_args "$@"
    get_distro 2>/dev/null
    get_bold
    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

        # Hide the cursor and disable line wrap.
        printf "\033[?25l\033[?7l"
    fi

    get_image_backend
    old_functions
    get_cache_dir
    print_info 2>/dev/null
    dynamic_prompt

    # w3m-img: Draw the image a second time to fix
    # rendering issues in specific terminal emulators.
    [[ "$image_backend" == "image" && "$image_program" == "w3m" ]] && display_image

    # Take a screenshot.
    [[ "$scrot" == "on" ]] && take_scrot

    # Show error messages.
    [[ "$verbose" == "on" ]] && printf "%b" "$err" >&2

    return 0
}

main "$@"