; Palette. Included at the top of config.ini, so ${colors.*} is available to

; every module file.

[colors]

background = #121113

background-alt = #333333

foreground = #c1c1c1

primary = #fbcb97

secondary = #5f8787

alert = #e78a53

disabled = #888888

; The bar window itself is invisible -- only the islands paint anything.

; Needs a compositor (xfwm4's is on) or this renders black.

transparent = #00000000

; vim:ft=dosini

; One transparent, full-width bar. The visible blocks are "islands": runs of

; modules that paint their own background between a pair of rounded caps.

; See modules/caps.ini for how that works and what a module owes an island.

;

;   colors.ini    the palette

;   fonts.ini     fonts, including the oversized one the caps are drawn with

;   layout.ini    which modules go in which island

;   modules/      one file per module; a file here is not enabled until it

;                 is named in layout.ini

;   scripts/      backing scripts for custom/script modules

;

; Relative includes resolve next to this file *as installed* -- polybar does

; not follow the symlink first -- so every one of them needs its own symlink

; in ~/.config/polybar.

include-file = colors.ini

include-directory = modules

[bar/main]

; 24pt = 32px at 96dpi. fonts.ini pins the cap glyph to this height, so the

; two move together.

; Inset 32px from both screen edges, on any monitor width.

width = 100%:-64px

offset-x = 32px

; The islands are rounded, the bar is not: it is invisible.

radius = 0

background = ${colors.transparent}

; No bar padding, no module-margin, no separator, on purpose: space between

; two modules is a see-through gap in the island. Spacing inside an island

; comes from each module's own format-padding, spacing between islands from

; [module/gap].

padding = 0

module-margin = 0

include-file = fonts.ini

include-file = layout.ini

; Included inside [bar/main], so these are bar keys.

; %{T1} -- everything except the island caps.

font-0 = BerkeleyMono Nerd Font:size=13;2

; %{T2} -- the island cap glyphs in modules/caps.ini, and nothing else. This

; is the corner-radius knob: the glyph is a half circle 1.213em tall, so at

; 30pt (40px em) it stands 48px against a 32px bar and only the flat middle

; shows, leaving a ~6px rounded corner. Raise the size for a squarer corner,

; lower it towards 20pt to go back to a full pill. The ;7 centres the clipped

; glyph on the bar; re-check it after changing either number.

font-1 = BerkeleyMono Nerd Font:size=30;7

; vim:ft=dosini

# Start the polybar bar defined in ./config.ini (installed at

# ~/.config/polybar/config.ini), replacing any bar already running.

# There is one bar window, spanning the screen and fully transparent; the

# visible islands are built inside it out of modules (see modules/caps.ini).

polybar main &

# Stay alive as the session client for as long as the bar is up. polybar

# re-execs in place on `polybar-msg cmd restart`, so this PID survives it.

; Which modules make up which island. Included inside [bar/main].

;

; Every run of modules wrapped in cap-left ... cap-right renders as one

; rounded island. To split a side into two islands, close and reopen with a

; gap between them:

;

;   modules-right = cap-left cpu memory cap-right gap cap-left date cap-right

;

; Only one bar may own the tray, and this is the only bar.

modules-left = xworkspaces

modules-right = filesystem memory cpu systray pulseaudio weather date

; vim:ft=dosini

; The island machinery, adopted from Murzchnvok/polybar-collection.

;

; [bar/main] is one full-width, fully transparent window. An island is just a

; run of modules that paint their own background, opened and closed by these

; two text modules: a half circle drawn in the island colour at font-1

; (%{T2}). The result is a rounded block only as wide as what is inside it --

; no bar widths to measure and no second bar window to keep in sync.

;

; The corner radius is font-1's *size*, and the trick is that the glyph is far

; taller than the bar: at 30pt it is 48px tall, the bar keeps the middle 32px,

; and a shallow 6px corner is all that shows. Bigger size, flatter corner --

; the inset at the bar's top and bottom edge works out to about

;

;   0.636 * em * (1 - sqrt(1 - (16 / (0.6065 * em))^2))      em = size * 4/3

;

; The %{O-8} is what keeps the cap from being fat: the glyph's advance is

; 0.6em (24px at 30pt), far more than the corner needs, so the cursor is

; pulled back 8px to leave a 16px cap. Which side of the glyph the pullback

; goes on matters. cap-left trims after, because its ink runs to the right

; into the next module's background, which is painted afterwards and covers

; it. cap-right trims before, because its ink runs left over the *previous*

; module -- so keep that pullback under that module's format-padding (10px)

; or the cap will paint over the last of its text.

;

; The contract for anything that goes in an island: set a background and some

; padding on every format the module can show, e.g.

;

;   format-background = ${colors.background}

;   format-padding = 1

;

; A format without a background leaves a see-through hole in the island. Note

; that it is format-<name>-background for modules with named formats

; (mounted, volume, connected, ...) -- there is no fallback to a bare

; format-background.

[module/cap-left]

type = custom/text

label = %{T2}%{T-}%{O-8}

label-foreground = ${colors.background}

[module/cap-right]

type = custom/text

label = %{O-8}%{T2}%{T-}

label-foreground = ${colors.background}

; A transparent spacer, for a real gap between two islands on the same side.

; One font-1 space, so it is a cap's worth of nothing: 24px.

[module/gap]

type = custom/text

label = %{T2} %{T-}

label-foreground = ${colors.transparent}

; vim:ft=dosini

[module/cpu]

type = internal/cpu

interval = 2

format = <label>

format-background = ${colors.background}

format-padding = 1

format-prefix = "󰘚 "

format-prefix-foreground = ${colors.primary}

label = %percentage:2%%

; vim:ft=dosini

[module/date]

type = internal/date

interval = 1

date = %H:%M

date-alt = %Y-%m-%d %H:%M:%S

format = <label>

format-background = ${colors.background}

format-padding = 1

format-prefix = "󰅐 "

format-prefix-foreground = ${colors.primary}

label = %date%

; vim:ft=dosini

[module/filesystem]

type = internal/fs

interval = 25

mount-0 = /

format-mounted = <label-mounted>

format-mounted-background = ${colors.background}

format-mounted-padding = 1

label-mounted = %{F#fbcb97}󰋊%{F-} %used%

format-unmounted = <label-unmounted>

format-unmounted-background = ${colors.background}

format-unmounted-padding = 1

label-unmounted = 󰋊 %mountpoint% not mounted

label-unmounted-foreground = ${colors.disabled}

; vim:ft=dosini

[module/memory]

type = internal/memory

interval = 2

format = <label>

format-background = ${colors.background}

format-padding = 1

format-prefix = "󰍛 "

format-prefix-foreground = ${colors.primary}

label = %used%

; vim:ft=dosini

; Not in layout.ini -- defined and ready, add wlan or eth to an island run.

[network-base]

type = internal/network

interval = 5

format-connected = <label-connected>

format-connected-background = ${colors.background}

format-connected-padding = 1

format-disconnected = <label-disconnected>

format-disconnected-background = ${colors.background}

format-disconnected-padding = 1

label-disconnected = %{F#888888}󰌙 %ifname%%{F-}

[module/wlan]

inherit = network-base

interface-type = wireless

label-connected = %{F#fbcb97}󰖩%{F-} %essid%

[module/eth]

inherit = network-base

interface-type = wired

label-connected = %{F#fbcb97}󰈀%{F-} %local_ip%

; vim:ft=dosini

[module/pulseaudio]

type = internal/pulseaudio

format-volume = <label-volume>

format-volume-background = ${colors.background}

format-volume-padding = 1

format-volume-prefix = "󰕾 "

format-volume-prefix-foreground = ${colors.primary}

label-volume = %percentage%%

format-muted = <label-muted>

format-muted-background = ${colors.background}

format-muted-padding = 1

label-muted = 󰝟 muted

label-muted-foreground = ${colors.disabled}

; vim:ft=dosini

; Only one tray may exist per session, so this module lives on exactly one

; bar. Padding rather than margin: a margin would be a hole in the island.

[module/systray]

type = internal/tray

format = <tray>

format-background = ${colors.background}

format-padding = 1

tray-background = ${colors.background}

tray-spacing = 8pt

; vim:ft=dosini

; Weather from the US National Weather Service, via ../scripts/weather.

; Nothing here needs an API key -- api.weather.gov is open -- but it is US-only,

; and the script wants NWS_UA pointed at a real contact address.

[module/weather]

type = custom/script

; scripts/ is symlinked into ~/.config/polybar the same way rofi/scripts is.

exec = ~/.config/polybar/scripts/weather

click-left = ~/.config/polybar/scripts/weather detail

; The script serves a cached line until NWS_INTERVAL (15 minutes) is up, so

; polling this often costs a file read, not a request. It only sets how soon a

; refreshed line reaches the bar.

interval = 300

; The palette stays in colors.ini; the script prints plain text unless told

; otherwise, so pass the two colours it uses in from here.

env-NWS_ICON_COLOR = ${colors.primary}

env-NWS_ALERT_COLOR = ${colors.alert}

; Pin the location to skip the geolocation lookup, and put a real address in

; NWS_UA -- NWS asks for one it can contact about a misbehaving client.

; env-NWS_LAT = 36.1627

; env-NWS_LON = -86.7816

; env-NWS_UA = (dotfiles polybar, you@example.com)

format = <label>

format-background = ${colors.background}

format-padding = 1

label = %output%

; vim:ft=dosini

; Not in layout.ini -- defined and ready, add xkeyboard to an island run.

[module/xkeyboard]

type = internal/xkeyboard

blacklist-0 = num lock

format = <label-layout><label-indicator>

format-background = ${colors.background}

format-padding = 1

label-layout = 󰌌 %layout%

label-layout-foreground = ${colors.primary}

label-indicator-padding = 2

label-indicator-margin = 1

label-indicator-foreground = ${colors.background}

label-indicator-background = ${colors.secondary}

; vim:ft=dosini

; Not in layout.ini -- defined and ready, add xwindow to an island run. It

; grows and shrinks with the window title, and so does its island.

[module/xwindow]

type = internal/xwindow

format = <label>

format-background = ${colors.background}

format-padding = 1

label = %title:0:60:...%

; vim:ft=dosini

[module/xworkspaces]

type = internal/xworkspaces

format = <label-state>

format-background = ${colors.background}

; Padding by prefix/suffix rather than format-padding, and a background on

; every state, both for the same reason: a label that carries its own

; background (label-active does) drops polybar back to the *bar's* colour for

; everything drawn after it -- and the bar is transparent, so anything left

; unpainted is a hole straight through the island.

format-padding = 0

format-prefix = " "

format-prefix-background = ${colors.background}

format-suffix = " "

format-suffix-background = ${colors.background}

label-active = %name%

label-active-background = ${colors.background-alt}

label-active-underline = ${colors.primary}

label-active-padding = 1

label-occupied = %name%

label-occupied-background = ${colors.background}

label-occupied-padding = 1

label-urgent = %name%

label-urgent-background = ${colors.alert}

label-urgent-padding = 1

label-empty = %name%

label-empty-background = ${colors.background}

label-empty-foreground = ${colors.disabled}

label-empty-padding = 1

; vim:ft=dosini

#!/bin/sh

# Requires: curl, jq, a Nerd Font (the glyphs are nf-md-*), and dunst or any

# notification daemon for the `detail` action.

# Weather for the bar, straight from the US National Weather Service. It began

# as polybar-scripts' openweathermap-fullfeatured, but against api.weather.gov,

# so there is no API key to keep out of the repo. The trade is that NWS only

# covers the US and its territories: /points returns 404 for anywhere else and

# the module goes blank.

#

# The bar gets current conditions and nothing else -- an icon and a temperature,

# the same shape as every other module here. The forecast is a click away.

#

#   weather          one line for the bar (the default)

#   weather detail   a notification with the full forecast and any alerts

#

# NWS asks callers for a contactable User-Agent and for restraint, and this

# honours both. The grid lookup is cached for a day because a grid square does

# not move, and the rendered line for NWS_INTERVAL seconds, so the polybar

# restarts that screenchange-reload makes routine cost no requests at all. A

# failed fetch falls back to the last good line rather than blanking the bar.

set -u

# Blank asks the network where we are; set both to pin a location and skip

# the geolocation request entirely.

LAT=${NWS_LAT:-}

LON=${NWS_LON:-}

# us = degrees F, si = degrees C. Passed straight through to NWS for the

# forecast; observations always arrive in Celsius and are converted here.

UNITS=${NWS_UNITS:-us}

# Seconds a rendered line is reused before refetching. The module may poll

# faster than this -- it just gets the cache back until this expires.

INTERVAL=${NWS_INTERVAL:-900}

# NWS wants a User-Agent it can contact about a misbehaving client; an email

# address or a URL is what they ask for. Put yours here.

UA=${NWS_UA:-"polybar-nws (https://github.com/polybar/polybar-scripts)"}

# Polybar colour markup, left empty so the script prints plain text anywhere

# else. modules/weather.ini fills both in from colors.ini, which is where the

# palette belongs -- nothing in here should need editing to match the bar.

ICON_COLOR=${NWS_ICON_COLOR:-}

ALERT_COLOR=${NWS_ALERT_COLOR:-}

# 1 names the active alert on the bar as well as flagging it. Off by default:

# "Severe Thunderstorm Warning" is wider than everything else put together,

# and it is one click away in `detail` either way.

SHOW_ALERT_LABEL=${NWS_SHOW_ALERT_LABEL:-0}

SYMBOL=°

API=https://api.weather.gov

CACHE=${XDG_CACHE_HOME:-$HOME/.cache}/polybar-nws

GRID=$CACHE/grid

# Icon, temperature and alert event, tab separated -- deliberately not the

# finished bar string. The colours arrive from the module, so a bare run from a

# shell has none; caching a painted line would let whichever ran last decide

# how the bar looked for the next quarter hour, and would freeze the palette

# in until the cache expired.

LINE=$CACHE/line

# How long the /points and station lookup is trusted. A day, so a laptop that

# travelled overnight re-locates on its own.

GRID_TTL=86400

# vol uses 7303; a separate id so a volume popup and a forecast popup do not

# replace each other.

NOTIFY_ID=7304

# NWS condition token -> glyph. $1 is day or night, $2 the token lifted out of

# the icon URL; the full token list is at https://api.weather.gov/icons.

#

# These are nf-md (Material Design) glyphs, the family every other module here

# draws from. nf-weather has a finer-grained set, but it is a visibly lighter

# weight and read as pasted-in next to the solid icons around it.

#

# Every glyph below was checked at 13pt against the bar's own font. Material

# only splits day from night for clear and partly cloudy skies; nothing else

# needs it, since rain looks like rain whatever the hour.

get_icon() {

    case $2 in

        skc)                          d='󰖙'; n='󰖔';;

        few|sct)                      d='󰖕'; n='󰼱';;

        bkn|ovc)                      d='󰖐'; n='󰖐';;

        wind_skc|wind_few|wind_sct|wind_bkn|wind_ovc)

                                      d='󰖝'; n='󰖝';;

        rain)                         d='󰖖'; n='󰖖';;

        rain_showers|rain_showers_hi) d='󰖗'; n='󰖗';;

        tsra|tsra_sct|tsra_hi)        d='󰙾'; n='󰙾';;

        snow)                         d='󰖘'; n='󰖘';;

        blizzard)                     d='󰼶'; n='󰼶';;

        sleet|fzra|rain_snow|rain_sleet|snow_sleet|rain_fzra|snow_fzra)

                                      d='󰙿'; n='󰙿';;

        fog)                          d='󰖑'; n='󰖑';;

        haze|dust)                    d='󰼰'; n='󰼰';;

        smoke)                        d='󰩱'; n='󰩱';;

        hot)                          d='󱃂'; n='󱃂';;

        cold)                         d='󱃃'; n='󱃃';;

        tornado)                      d='󰼸'; n='󰼸';;

        hurricane|tropical_storm)     d='󰢘'; n='󰢘';;

        *)                            d='󰼯'; n='󰼯';;

    esac

    if [ "$1" = night ]; then printf '%s' "$n"; else printf '%s' "$d"; fi

}

# The condition lives in the icon URL's path, not in a field of its own:

#   .../icons/land/day/tsra_hi,40/tsra,60?size=medium

# Prints "day tsra_hi" -- the leading period wins, and both the ",40" chance

# suffix and any second period are dropped.

icon_parts() {

    printf '%s' "${1%%\?*}" | awk -F/ '

        {

            for (i = 1; i < NF; i++)

                if ($i == "day" || $i == "night") {

                    sub(/,.*/, "", $(i + 1))

                    print $i, $(i + 1)

                    found = 1

                    exit

                }

        }

        END { if (!found) print "day unknown" }'

}

# curl with the headers NWS expects, plus a retry: gridpoint requests return

# a 500 often enough that one attempt is not a fair test.

fetch() {

    curl -sfL --compressed --max-time 8 --retry 2 --retry-delay 1 \

        -H "User-Agent: $UA" -H "Accept: application/geo+json" "$1"

}

# $2 wrapped in polybar's colour markup, or left alone when $1 is empty.

paint() {

    if [ -n "$1" ]; then printf '%%{F%s}%s%%{F-}' "$1" "$2"; else printf '%s' "$2"; fi

}

# The bar line, built from the three cached fields: glyph, temperature, and the

# active alert event (empty when there is none). Painting happens here, at the

# last possible moment, so the module's colours apply to a cached reading too.

#

# The trailing space goes *inside* the colour run. polybar clips each %{F...}

# segment at the advance width of the text in it, and these glyphs draw wider

# than the single cell they advance -- put the space after the %{F-} and the

# overflow is cut off, leaving a half-rendered blob. It is the same reason

# every other module here writes format-prefix = "<glyph> " rather than

# hanging the space off the label.

format_line() {

    line="$(paint "$ICON_COLOR" "$1 ")$2$SYMBOL"

    if [ -n "$3" ]; then

        if [ "$SHOW_ALERT_LABEL" = 1 ]; then flag="󰀦 $3"; else flag='󰀦'; fi

        line="$(paint "$ALERT_COLOR" "$flag ")$line"

    fi

    printf '%s\n' "$line"

}

# One field out of a JSON blob on stdin's place, empty rather than "null".

j() { printf '%s' "$1" | jq -r "$2 // empty" 2>/dev/null; }

# Seconds since $1 was last written; effectively infinite if it is not there.

age() {

    if [ -f "$1" ]; then

        echo $(( $(date +%s) - $(stat -c %Y "$1") ))

    else

        echo 999999999

    fi

}

# Observations are always Celsius no matter what ?units= asked for, so the

# conversion happens here rather than being left to the API.

c_to_display() {

    [ -n "${1:-}" ] || return 1

    if [ "$UNITS" = us ]; then

        awk -v c="$1" 'BEGIN { printf "%.0f", c * 9 / 5 + 32 }'

    else

        awk -v c="$1" 'BEGIN { printf "%.0f", c }'

    fi

}

kmh_to_display() {

    [ -n "${1:-}" ] || return 1

    if [ "$UNITS" = us ]; then

        awk -v k="$1" 'BEGIN { printf "%.0f mph", k * 0.621371 }'

    else

        awk -v k="$1" 'BEGIN { printf "%.0f km/h", k }'

    fi

}

# Whether $obs is recent enough to show as "now". Stations that report hourly

# routinely skip a cycle, so the cutoff is two hours; past that the forecast is

# the better answer. busybox date cannot parse an ISO stamp with an offset, and

# jq's fromdateiso8601 insists on a "Z" -- NWS only ever sends "+00:00", so that

# is the one offset translated, and anything else counts as fresh rather than

# throwing away a good observation over a timestamp this cannot read.

fresh_obs() {

    [ -n "$obs" ] || return 1

    ts=$(j "$obs" '.properties.timestamp | sub("\\+00:00$"; "Z") | fromdateiso8601')

    [ -n "$ts" ] || return 0

    [ $(( $(date +%s) - ts )) -lt 7200 ]

}

# Resolve coordinates to the three URLs everything else needs, and cache them.

# NWS models the country as a grid of 2.5km squares; /points is the only way

# to learn which square a latitude and longitude fall in, and the answer is

# stable, so this runs once a day at most.

resolve_grid() {

    if [ -n "$LAT" ] && [ -n "$LON" ]; then

        loc="$LAT,$LON"

    else

        # Two providers because both are free endpoints that go away without

        # warning; either one is accurate enough to pick a 2.5km square.

        loc=$(curl -sf --max-time 6 https://ipinfo.io/json | jq -r '.loc // empty')

        [ -n "$loc" ] || loc=$(curl -sf --max-time 6 'http://ip-api.com/json/?fields=lat,lon' |

            jq -r 'if .lat then "\(.lat),\(.lon)" else empty end')

        [ -n "$loc" ] || return 1

    fi

    # NWS caps coordinate precision at four decimals: /points answers anything

    # longer with a 301 to the truncated form, and /alerts just returns a 500.

    # Round here so neither can surprise a hand-set NWS_LAT later on.

    loc=$(printf '%s' "$loc" | awk -F, '{ printf "%.4f,%.4f", $1, $2 }')

    points=$(fetch "$API/points/$loc") || return 1

    hourly=$(j "$points" '.properties.forecastHourly')

    daily=$(j "$points" '.properties.forecast')

    stations=$(j "$points" '.properties.observationStations')

    place=$(j "$points" '.properties.relativeLocation.properties |

        if .city then "\(.city), \(.state)" else empty end')

    [ -n "$hourly" ] && [ -n "$stations" ] || return 1

    # The station list is not sorted by distance despite looking like it is --

    # for Denver it leads with an airport 24km up the highway -- so pick the

    # nearest one properly. Flat-earth distance with a cosine correction on the

    # longitude is plenty over the handful of kilometres in play here.

    station=$(fetch "$stations" | jq -r --argjson lat "${loc%,*}" --argjson lon "${loc#*,}" '

        [ .features[]

          | { id: .properties.stationIdentifier,

              dx: ((.geometry.coordinates[0] - $lon) * (($lat * 3.14159265 / 180) | cos)),

              dy: (.geometry.coordinates[1] - $lat) } ]

        | min_by(.dx * .dx + .dy * .dy)

        | .id // empty')

    [ -n "$station" ] || return 1

    mkdir -p "$CACHE"

    printf '%s\n%s\n%s\n%s\n%s\n' "$hourly" "$daily" "$station" "$loc" "$place" > "$GRID"

}

# Populates grid_hourly, grid_daily, grid_station, grid_point and grid_place.

load_grid() {

    if [ "$(age "$GRID")" -gt "$GRID_TTL" ]; then

        resolve_grid || [ -f "$GRID" ] || return 1

    fi

    grid_hourly=$(sed -n 1p "$GRID")

    grid_daily=$(sed -n 2p "$GRID")

    grid_station=$(sed -n 3p "$GRID")

    grid_point=$(sed -n 4p "$GRID")

    grid_place=$(sed -n 5p "$GRID")

    [ -n "$grid_hourly" ]

}

# NWS hands back active alerts in no particular order, so severity has to be

# sorted on rather than assumed. Shared by the bar, which wants only the worst

# one, and by detail, which lists them all. The severity has to be bound before

# the ranking array is piped in, or the index lookup reads .severity off the

# array instead of off the alert.

ALERT_ORDER='[.features[].properties]

    | sort_by((.severity // "Unknown") as $s

              | (["Extreme", "Severe", "Moderate", "Minor"] | index($s)) // 9)'

# The most serious active alert for our point, or nothing.

active_alert() {

    fetch "$API/alerts/active?point=$grid_point" | jq -r "$ALERT_ORDER | .[0].event // empty"

}

render() {

    load_grid || return 1

    temp=

    icon_url=

    obs=$(fetch "$API/stations/$grid_station/observations/latest")

    # The observation is a real measurement and is what "now" ought to mean.

    if fresh_obs; then

        temp=$(c_to_display "$(j "$obs" '.properties.temperature.value')") || temp=

        icon_url=$(j "$obs" '.properties.icon')

    fi

    # Small stations drop out for hours at a time, and a four-hour-old reading

    # is worse than none. Period 1 of the hourly forecast covers the current

    # hour and stands in when that happens -- which is why this request sits

    # down here rather than up beside the observation: in the ordinary case the

    # station answers and it never runs at all.

    if [ -z "$temp" ] || [ -z "$icon_url" ]; then

        hourly=$(fetch "$grid_hourly?units=$UNITS")

        [ -n "$temp" ] || temp=$(j "$hourly" '.properties.periods[0].temperature')

        [ -n "$icon_url" ] || icon_url=$(j "$hourly" '.properties.periods[0].icon')

    fi

    [ -n "$temp" ] || return 1

    # NWS sends whole numbers today; this is here so a stray decimal cannot

    # turn up inside the bar label.

    temp=${temp%%.*}

    # Unquoted on purpose: icon_parts prints the two arguments get_icon takes.

    icon=$(get_icon $(icon_parts "$icon_url"))

    alert=$(active_alert)

    mkdir -p "$CACHE"

    printf '%s\t%s\t%s\n' "$icon" "$temp" "$alert" > "$LINE"

    format_line "$icon" "$temp" "$alert"

}

# The cached reading, repainted with whatever colours this run was given.

# Fails on a missing file, and on the painted single-field line older versions

# of this script wrote, so either one just falls through to a fresh fetch.

show_cached() {

    [ -f "$LINE" ] || return 1

    IFS=$(printf '\t') read -r icon temp alert < "$LINE" || return 1

    [ -n "$temp" ] || return 1

    format_line "$icon" "$temp" "$alert"

}

# The bar line, from cache when it is still fresh. A failed fetch prints the

# last good line however old it is: a stale temperature is more use on a bar

# than a module that vanishes whenever the wifi hiccups.

bar() {

    if [ "$(age "$LINE")" -lt "$INTERVAL" ] && show_cached; then

        return 0

    fi

    render && return 0

    # Nothing new and nothing cached is either the first run without a network

    # or a location NWS does not cover. Say so on stderr, where polybar's log

    # will keep it, and exit clean so polybar does not treat it as a crash.

    show_cached ||

        echo "${0##*/}: no forecast (offline, or outside NWS coverage)" >&2

    return 0

}

# Everything that does not fit on the bar: the alerts in full, what the nearest

# station is actually reading, and the NWS forecaster's own prose for the

# current period.

detail() {

    load_grid || { notify "Weather" "No NWS grid for this location"; return 1; }

    obs=$(fetch "$API/stations/$grid_station/observations/latest")

    daily=$(fetch "$grid_daily?units=$UNITS")

    body=""

    alerts=$(fetch "$API/alerts/active?point=$grid_point" |

        jq -r "$ALERT_ORDER"' | .[] | "\(.event) - \(.headline // "")"')

    [ -n "$alerts" ] && body="$alerts

"

    if fresh_obs; then

        temp=$(c_to_display "$(j "$obs" '.properties.temperature.value')") || temp=""

        hum=$(j "$obs" '.properties.relativeHumidity.value')

        wind=$(kmh_to_display "$(j "$obs" '.properties.windSpeed.value')") || wind=""

        # Whichever of the two "feels like" numbers is in season; NWS leaves

        # the other null rather than sending both.

        feels=$(c_to_display "$(j "$obs" '.properties.heatIndex.value')") ||

            feels=$(c_to_display "$(j "$obs" '.properties.windChill.value')") || feels=""

        line="$(j "$obs" '.properties.textDescription') $temp$SYMBOL"

        [ -n "$feels" ] && line="$line (feels $feels$SYMBOL)"

        [ -n "$hum" ] && line="$line, $(awk -v h="$hum" 'BEGIN { printf "%.0f", h }')% humidity"

        [ -n "$wind" ] && line="$line, wind $wind"

    else

        line="No recent reading from $grid_station"

    fi

    body="$body$line

$(j "$daily" '.properties.periods[0] | "\(.name): \(.detailedForecast)"')"

    notify "${grid_place:-Weather} ($grid_station)" "$body"

}

notify() {

    dunstify -r "$NOTIFY_ID" -t 15000 "$1" "$2" 2>/dev/null ||

        notify-send "$1" "$2"

}

case "${1:-bar}" in

    bar)    bar ;;

    detail) detail ;;

    *) echo "usage: ${0##*/} [bar|detail]" >&2; exit 2 ;;

esac

# xfwm4's compositor shadows a dock as a rectangle the size of its window,

# ignoring what the window actually paints. polybar's bar spans the screen and

# is transparent everywhere except the islands, so that shadow shows up as a

# band hanging across the empty middle. Turning it off is the only knob for it;

# true is xfwm4's default, which --remove puts back.

dock_shadow() {

    command -v xfconf-query >/dev/null 2>&1 || return 0

    xfconf-query -c xfwm4 -p /general/show_dock_shadow -s "$1" 2>/dev/null ||

        xfconf-query -c xfwm4 -p /general/show_dock_shadow -n -t bool -s "$1"

}

    dock_shadow true

    dock_shadow false