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
|
# SPDX-License-Identifier: LGPL-3.0-or-later
# Copyright (C) 2020 Daniel Thompson
import wasp
import icons
import fonts
class StopwatchApp():
NAME = 'Timer'
ICON = icons.app
def __init__(self):
self._meter = wasp.widgets.BatteryMeter()
self._reset()
self._count = 0
def foreground(self):
"""Activate the application."""
self._last_clock = ( -1, -1, -1, -1, -1, -1 )
self._draw()
wasp.system.request_tick(97)
wasp.system.request_event(wasp.EventMask.TOUCH |
wasp.EventMask.BUTTON)
def sleep(self):
return True
def wake(self):
self._update()
def press(self, button, state):
if not state:
return
if self._started_at:
self._update()
self._started_at = 0
else:
uptime = wasp.watch.rtc.get_uptime_ms()
uptime //= 10
self._started_at = uptime - self._count
self._update()
def touch(self, event):
if self._started_at:
self._update()
self._splits.insert(0, self._count)
del self._splits[4:]
else:
self._reset()
self._update()
self._draw_splits()
def tick(self, ticks):
self._update()
def _reset(self):
self._started_at = 0
self._count = 0
self._last_count = -1
self._splits = []
def _draw_splits(self):
draw = wasp.watch.drawable
splits = self._splits
if 0 == len(splits):
draw.fill(0, 0, 120, 240, 120)
return
y = 240 - 12 - (len(splits) * 24)
for i, s in enumerate(splits):
if s:
centisecs = s
secs = centisecs // 100
centisecs %= 100
minutes = secs // 60
secs %= 60
t = '#{} {:02}:{:02}.{:02}'.format(i+1, minutes, secs, centisecs)
else:
t = ''
draw.set_font(fonts.sans24)
w = fonts.width(fonts.sans24, t)
draw.string(t, 0, y + (i*24), 240)
def _draw(self):
"""Draw the display from scratch."""
draw = wasp.watch.drawable
draw.fill()
self._last_count = -1
self._update()
self._meter.draw()
self._draw_splits()
def _update(self):
# Before we do anything else let's make sure _count is
# up to date
if self._started_at:
uptime = wasp.watch.rtc.get_uptime_ms()
uptime //= 10
self._count = uptime - self._started_at
if self._count > 999*60*100:
self._reset()
draw = wasp.watch.drawable
# Lazy update of the clock and battery meter
now = wasp.watch.rtc.get_localtime()
if now[4] != self._last_clock[4]:
t1 = '{:02}:{:02}'.format(now[3], now[4])
draw.set_font(fonts.sans24)
draw.string(t1, 48, 16, 240-96)
self._last_clock = now
self._meter.update()
if self._last_count != self._count:
centisecs = self._count
secs = centisecs // 100
centisecs %= 100
minutes = secs // 60
secs %= 60
t1 = '{}:{:02}'.format(minutes, secs)
t2 = '{:02}'.format(centisecs)
draw.set_font(fonts.sans36)
w = fonts.width(fonts.sans36, t1)
draw.string(t1, 180-w, 120-36)
draw.fill(0, 0, 120-36, 180-w, 36)
draw.set_font(fonts.sans24)
draw.string(t2, 180, 120-36+18, width=46)
self._last_count = self._count
|
