1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
|
-- Weather: current conditions over a sunrise-to-sunset arc.
--
-- Shape follows idea1.png, which splits this across two cards; this merges
-- them into one vertical cell. Every colour comes from the palette, every size
-- derives from the rect, so the card composes on either monitor.
local card = require 'lib.card'
local weather = require 'lib.weather'
local M = {}
local CACHE = (os.getenv('XDG_CACHE_HOME') or (os.getenv('HOME') .. '/.cache'))
.. '/udt/weather.json'
-- Draw the card chrome with a message in it. Used for every no-data state, so
-- the dashboard keeps its shape instead of showing an empty cell, which is
-- indistinguishable from a crashed widget.
local function draw_notice(cr, inner, colors, line1, line2)
card.font(cr, card.FONT_UI, 15, true)
card.rgba(cr, colors.label)
card.text(cr, inner.x, inner.y + 24, line1)
card.font(cr, card.FONT_MONO, 12, false)
card.text(cr, inner.x, inner.y + 48, line2)
end
-- The daylight arc: a curve, its baseline, the sun, and the two times.
--
-- The dot is placed by evaluating the curve at t rather than by computing a
-- point on a circle: the curve IS the path, so evaluating it keeps the dot on
-- the arc if the control points are ever adjusted.
local function draw_arc(cr, x, y, w, h, colors, w_data, now)
local pad = 4
local x0, x1 = x + pad, x + w - pad
-- Room under the curve for the time labels.
local base = y + h - 20
local top = y + 6
-- Cubic Bezier control points, chosen so the curve peaks near the middle at
-- about two thirds of the band height.
local p0 = { x0, base }
local c1 = { x0 + (x1 - x0) * 0.22, top - 10 }
local c2 = { x1 - (x1 - x0) * 0.22, top - 10 }
local p3 = { x1, base }
-- The baseline: the horizon the sun rises from and sets into.
card.rgba(cr, colors.rule, 0.6)
cairo_set_line_width(cr, 1)
cairo_move_to(cr, x0, base)
cairo_line_to(cr, x1, base)
cairo_stroke(cr)
-- The arc itself.
card.rgba(cr, colors.rule, 0.9)
cairo_set_line_width(cr, 1.5)
cairo_move_to(cr, p0[1], p0[2])
cairo_curve_to(cr, c1[1], c1[2], c2[1], c2[2], p3[1], p3[2])
cairo_stroke(cr)
local t = weather.sun_t(now, w_data.sunrise, w_data.sunset) or 0
local day = weather.is_day(now, w_data.sunrise, w_data.sunset)
-- Evaluate the cubic at t.
local function bez(a, b, c, d)
local u = 1 - t
return u * u * u * a + 3 * u * u * t * b + 3 * u * t * t * c + t * t * t * d
end
local sx = bez(p0[1], c1[1], c2[1], p3[1])
local sy = bez(p0[2], c1[2], c2[2], p3[2])
-- At night the dot is parked at an end, so it takes the dim colour: a bright
-- dot sitting on the horizon would read as a sun that is still up.
card.rgba(cr, day and colors.body or colors.label, 1)
cairo_arc(cr, sx, sy, 5, 0, math.pi * 2)
cairo_fill(cr)
-- The times, each behind its own glyph, at the ends of the arc.
card.font(cr, card.FONT_MONO, 12, false)
card.rgba(cr, colors.label)
local ty = y + h - 2
card.text(cr, x0, ty,
weather.ICON.sunrise .. ' ' .. os.date('%H:%M', w_data.sunrise))
card.text_right(cr, x1, ty,
weather.ICON.sunset .. ' ' .. os.date('%H:%M', w_data.sunset))
end
function M.draw(cr, rect, colors)
local inner = card.card(cr, rect, colors)
local now = os.time()
local src = nil
local f = io.open(CACHE, 'r')
if f then src = f:read('*a'); f:close() end
local w = weather.parse(src)
if not w then
-- Closed explicitly: an unclosed handle here would accumulate one per
-- draw (every update_interval), since this whole branch reruns each
-- frame until a fetch succeeds.
local envf = io.open(os.getenv('HOME') .. '/.config/udt/weather.env', 'r')
if envf then
envf:close()
draw_notice(cr, inner, colors, 'no weather data', 'waiting for first fetch')
else
draw_notice(cr, inner, colors, 'no weather data', 'set ~/.config/udt/weather.env')
end
return
end
local y = inner.y
-- Header: condition glyph, then the temperature with the city beneath it.
local glyph = weather.icon(w.id, now, w.sunrise, w.sunset)
card.font(cr, card.FONT_MONO, 36, false)
card.rgba(cr, colors.highlight)
card.text(cr, inner.x, y + 34, glyph)
local gx = inner.x + card.advance(cr, glyph) + 14
card.font(cr, card.FONT_HEAVY, 44, false)
card.rgba(cr, colors.body)
card.text(cr, gx, y + 38, string.format('%d\u{00B0}', math.floor(w.temp + 0.5)))
card.font(cr, card.FONT_MONO, 11, false)
card.rgba(cr, colors.label)
local city = (w.city or ''):upper()
if weather.is_stale(w.dt, now) then
city = city .. ' stale ' .. weather.age_str(w.dt, now)
end
card.text(cr, gx, y + 56, city)
-- Condition, in OWM's own words, first letter capitalised.
card.font(cr, card.FONT_UI, 13, false)
card.rgba(cr, colors.body)
local desc = w.description or ''
desc = desc:sub(1, 1):upper() .. desc:sub(2)
card.text(cr, inner.x, y + 84, desc)
-- Rule.
local ry = y + 100
card.rgba(cr, colors.rule, 0.8)
cairo_set_line_width(cr, 1)
cairo_move_to(cr, inner.x, ry)
cairo_line_to(cr, inner.x + inner.w, ry)
cairo_stroke(cr)
-- Stats: label left, value right.
local kmh = weather.kmh(w.wind_speed)
local wind_txt = kmh
and string.format('%s %d km/h', weather.arrow(w.wind_deg), math.floor(kmh + 0.5))
or '--'
local rows = {
{ 'FEELS LIKE', w.feels_like and string.format('%d\u{00B0}', math.floor(w.feels_like + 0.5)) or '--' },
{ 'HUMIDITY', w.humidity and (w.humidity .. '%') or '--' },
{ 'WIND', wind_txt },
}
local sy = ry + 22
for _, row in ipairs(rows) do
card.font(cr, card.FONT_MONO, 11, false)
card.rgba(cr, colors.label)
card.text(cr, inner.x, sy, row[1])
card.rgba(cr, colors.value)
card.text_right(cr, inner.x + inner.w, sy, row[2])
sy = sy + 20
end
-- Rule.
local ry2 = sy + 2
card.rgba(cr, colors.rule, 0.8)
cairo_move_to(cr, inner.x, ry2)
cairo_line_to(cr, inner.x + inner.w, ry2)
cairo_stroke(cr)
-- The arc fills whatever height is left.
draw_arc(cr, inner.x, ry2 + 10, inner.w, (inner.y + inner.h) - (ry2 + 10),
colors, w, now)
end
return M
|
