1766 lines
69 KiB
Python
1766 lines
69 KiB
Python
# Many thanks to https://stackoverflow.com/questions/18923321/making-a-clock-in-kivy
|
|
import collections
|
|
import datetime
|
|
import math
|
|
import sys
|
|
import traceback
|
|
import copy
|
|
from os import uname, walk
|
|
from kivy.config import Config
|
|
from kivy.properties import ObjectProperty
|
|
import time
|
|
from sounds import WakeUpSounds
|
|
import json
|
|
from hsluv import hsluv_to_rgb, rgb_to_hsluv
|
|
import requests
|
|
import urllib.parse
|
|
|
|
from kivy.core.image import Image as CoreImage
|
|
from kivy.uix.image import Image as kiImage
|
|
from PIL import Image, ImageChops
|
|
from io import BytesIO
|
|
|
|
def is_arm():
|
|
if (uname()[4][:3] == 'arm') or (uname()[4][:7] == 'aarch64'):
|
|
return True
|
|
else:
|
|
return False
|
|
|
|
if is_arm():
|
|
# Do not forget to create udev rule:
|
|
# echo 'SUBSYSTEM=="backlight",RUN+="/bin/chmod 666 /sys/class/backlight/%k/brightness /sys/class/backlight/%k/bl_power"' | sudo tee -a /etc/udev/rules.d/backlight-permissions.rules
|
|
from rpi_backlight import Backlight
|
|
from rgbw_colorspace_converter.colors.converters import HSV, RGB
|
|
|
|
Config.set('graphics', 'width', '800')
|
|
Config.set('graphics', 'height', '480')
|
|
#Config.set('graphics', 'width', '750')
|
|
#Config.set('graphics', 'height', '450')
|
|
|
|
import board
|
|
import neopixel
|
|
pixel_pin = board.D10
|
|
num_pixels = 300
|
|
ORDER = neopixel.GRBW
|
|
|
|
pixels = neopixel.NeoPixel(
|
|
pixel_pin, num_pixels, brightness=0.2, auto_write=False, pixel_order=ORDER
|
|
)
|
|
pixels.fill((0, 0, 0, 0))
|
|
pixels.show()
|
|
|
|
backlight = Backlight()
|
|
else:
|
|
Config.set('graphics', 'width', '1200')
|
|
Config.set('graphics', 'height', '720')
|
|
|
|
pixels = None
|
|
backlight = None
|
|
|
|
Config.set('graphics', 'maxfps', '60')
|
|
|
|
from kivy.app import App
|
|
from kivy.uix.floatlayout import FloatLayout
|
|
from kivy.uix.label import Label
|
|
from kivy.uix.slider import Slider
|
|
from kivy.uix.button import Button
|
|
from kivy.uix.gridlayout import GridLayout
|
|
from kivy.uix.checkbox import CheckBox
|
|
from kivy.clock import Clock
|
|
from kivy.lang import Builder
|
|
from kivy.graphics import Color, Line, Rectangle, Ellipse
|
|
from kivy.core.window import Window
|
|
|
|
if is_arm():
|
|
Window.show_cursor = False
|
|
|
|
import alsaaudio
|
|
import vlc
|
|
|
|
Builder.load_file('clock.kv')
|
|
|
|
Position = collections.namedtuple('Position', 'x y')
|
|
|
|
class Theme():
|
|
def __init__(self, x="Dark"):
|
|
print("reading themes/" + x + "/theme.json")
|
|
f = open("themes/" + x + "/theme.json")
|
|
j = json.load(f)
|
|
f.close()
|
|
self.name = x
|
|
self.color_background = j["color_background"]
|
|
self.color_shade = j["color_shade"]
|
|
self.color_clock_hands_hours = j["color_clock_hands_hours"]
|
|
self.color_clock_hands_minutes = j["color_clock_hands_minutes"]
|
|
self.color_clock_hands_seconds = j["color_clock_hands_seconds"]
|
|
self.color_alarm_hands_hours = j["color_alarm_hands_hours"]
|
|
self.color_alarm_hands_minutes = j["color_alarm_hands_minutes"]
|
|
self.color_alarm_hands_seconds = j["color_alarm_hands_seconds"]
|
|
self.color_font = j["color_font"]
|
|
self.color_numbers = j["color_numbers"]
|
|
self.color_button = j["color_button"]
|
|
self.color_funky = j["color_funky"]
|
|
|
|
self.icon_light_off = "themes/" + x + "/light_off.png"
|
|
self.icon_light_reading = "themes/" + x + "/light_reading.png"
|
|
self.icon_light_sunrise = "themes/" + x + "/light_sunrise.png"
|
|
self.icon_light_on = "themes/" + x + "/light_on.png"
|
|
self.icon_media_playing = "themes/" + x + "/media_playing.png"
|
|
self.icon_media_stopped = "themes/" + x + "/media_stopped.png"
|
|
self.icon_alarm_on = "themes/" + x + "/alarm_on.png"
|
|
self.icon_alarm_off = "themes/" + x + "/alarm_off.png"
|
|
self.icon_settings_visible = "themes/" + x + "/settings_visible.png"
|
|
self.icon_settings_not_visible = "themes/" + x + "/settings_not_visible.png"
|
|
|
|
class Touch():
|
|
def __init__(self, x=None):
|
|
if x is None:
|
|
self.pos = []
|
|
self.spos = []
|
|
self.is_empty = True
|
|
self.angle = 0
|
|
self.corrected = False
|
|
else:
|
|
self.pos = [i for i in x.pos]
|
|
self.spos = [i for i in x.spos]
|
|
self.is_empty = False
|
|
x = self.spos[0] - 0.5
|
|
y = self.spos[1] - 0.5
|
|
self.angle = math.atan2(y, x) / math.pi; # angle is between -1 and 1
|
|
self.corrected = False
|
|
|
|
def __repr__(self):
|
|
return ".is_empty: " + str(self.is_empty) + ", .pos: " + str(self.pos) + ", .spos: " + str(self.spos), ", .corrected: " + str(self.corrected)
|
|
|
|
def copy(self, x):
|
|
self = Touch(x)
|
|
|
|
def clear(self):
|
|
self = Touch()
|
|
|
|
class TouchEvent():
|
|
def __init__(self, x=None):
|
|
self.time = time.time()
|
|
self.touch = copy.copy(x)
|
|
self.processed = False
|
|
|
|
class ClockSettings():
|
|
def __init__(self):
|
|
f = open("settings.json")
|
|
j = json.load(f)
|
|
f.close()
|
|
|
|
self.theme_selected = j["theme"]
|
|
self.wake_up_volume = j["volume"]
|
|
self.sound_selected = j["wake_up_sound"]
|
|
self.wake_up_brightness = j["wake_up_brightness"]
|
|
self.reading_light_brightness = j["reading_light_brightness"]
|
|
self.display_brightness = j["display_brightness"]
|
|
self.alarm_activated = j["alarm_activated"]
|
|
try:
|
|
self.address = j["address"]
|
|
except:
|
|
pass
|
|
|
|
hour = j["alarm_time_hour"]
|
|
minute = j["alarm_time_minute"]
|
|
|
|
t = datetime.datetime.now()
|
|
self.alarm_time = datetime.datetime(t.year, \
|
|
t.month, t.day, hour, minute, 0, 0)
|
|
|
|
self.alarm_activated = False
|
|
self.alarm_playing = False
|
|
|
|
self.alarm_modified = False
|
|
|
|
self.seconds_to_sunrise = 30 * 60 # 30 minutes
|
|
|
|
def read(self):
|
|
ClockSettings()
|
|
|
|
def write(self):
|
|
j = {}
|
|
j["theme"] = self.theme_selected
|
|
j["volume"] = self.wake_up_volume
|
|
j["wake_up_sound"] = self.sound_selected
|
|
j["wake_up_brightness"] = self.wake_up_brightness
|
|
j["reading_light_brightness"] = self.reading_light_brightness
|
|
j["display_brightness"] = self.display_brightness
|
|
j["alarm_activated"] = self.alarm_activated
|
|
j["alarm_time_hour"] = self.alarm_time.hour
|
|
j["alarm_time_minute"] = self.alarm_time.minute
|
|
if hasattr(self, "address"):
|
|
j["address"] = self.address
|
|
|
|
with open("settings.json", "w") as f:
|
|
json.dump(j, f, indent=4)
|
|
print("settings saved")
|
|
|
|
class MyClockWidget(FloatLayout):
|
|
settings = ClockSettings()
|
|
|
|
if settings.theme_selected == "Automatic":
|
|
theme_name = "Light"
|
|
else:
|
|
theme_name = settings.theme_selected
|
|
theme = ObjectProperty(Theme(theme_name))
|
|
|
|
for x in ('', 'PCM'):
|
|
try:
|
|
mixer = alsaaudio.Mixer()
|
|
break
|
|
except:
|
|
pass
|
|
else:
|
|
raise OSError('could not open mixer ' + x)
|
|
|
|
grabbed = ""
|
|
face_numbers = []
|
|
|
|
# if not grabbed, set_alarm_timeout_counter is incremented at every update call;
|
|
# this is used to blink the hands at 1 Hz when setting the alarm and releasing the hand
|
|
set_alarm_timeout_counter = 0
|
|
seconds_to_next_alarm = 0
|
|
|
|
light_state = "off" # "off", "reading", "sunrise" or "on"
|
|
intensity_target = 0
|
|
intensity_prev = 0
|
|
intensity_curr = 0
|
|
intensity_target_prev = None
|
|
rgbw_prev = None
|
|
|
|
volume_target = 0
|
|
volume_prev = 0
|
|
volume_curr = 0
|
|
volume_target_prev = None
|
|
|
|
# Ugly workaround for issue with Kivy and Raspberry Pi 3 + touch screen
|
|
# For each type of touch event, handling of the event is ignored until the last event is more than touch_delay_time seconds old
|
|
touch_delay_time = 0.1
|
|
touch_down_event_prev = None
|
|
touch_move_event_prev = None
|
|
touch_up_event_prev = None
|
|
touch_down_event_curr = None
|
|
touch_move_event_curr = None
|
|
touch_up_event_curr = None
|
|
|
|
# view can be one of the following strings:
|
|
# - "clock"
|
|
# - "set_alarm"
|
|
# - "settings_menu"
|
|
# - "settings_menu_wake_up_sound"
|
|
# - "settings_menu_theme"
|
|
view = "clock"
|
|
view_prev = ""
|
|
view_active_since = time.time()
|
|
|
|
# ugly workaround for issue where input is processed twice (specifically:
|
|
# pressing Ok in wake up sound view switches to settings view but also
|
|
# adjusts display brightness slider)
|
|
time_to_ignore_inputs_after_view_change = 0.5
|
|
|
|
# ugly workaround for issue where graphics are not drawn correctly after view change
|
|
time_to_force_redraws_after_view_change = 0.5
|
|
|
|
# we need a dirty hack to sensure that radio button is always in sync with selected setting
|
|
settings_menu_wake_up_sound_select_button_cb_hack = False
|
|
settings_menu_theme_select_button_cb_hack = False
|
|
|
|
# defer drawing to improve application speed: if list of draw calls for
|
|
# this frame is identical to list of previous frame then nothing needs to
|
|
# be drawed
|
|
draw_list_last_frame = []
|
|
draw_list_curr_frame = []
|
|
|
|
touch_prev = Touch()
|
|
light_button_move_init = []
|
|
vlc = vlc.Instance()
|
|
player = vlc.media_player_new()
|
|
|
|
is_arm = is_arm()
|
|
|
|
aqi_colors = [
|
|
[0.0, 0.0, 0.0], # x < 1.0 black (good)
|
|
[0.3, 0.3, 255.0/255.0], # 1.0 <= x < 2.0 blue (good)
|
|
[0.0, 160.0/255.0, 160.0/255.0], # 2.0 <= x < 3.0 cyan (good)
|
|
[1.0, 1.0, 1.0], # 3.0 <= x < 4.0 white (mediocre)
|
|
[1.0, 1.0, 150.0/255.0], # 4.0 <= < x 5.0 light yellow (mediocre)
|
|
[245.0/255.0, 245.0/255.0, 0.0], # 5.0 <= x < 6.0 yellow (mediocre)
|
|
[1.0, 175.0/255.0, 0.0], # 6.0 <= x < 7.0 orange (inadequate)
|
|
[1.0, 120.0/255.0, 0.0], # 7.0 <= x < 8.0 red orange (inadequate)
|
|
[200.0/255.0, 0.0, 0.0], # 8.0 <= x < 9.0 red (bad)
|
|
[200.0/255.0, 0.0, 200.0/255.0], # 9.0 <= x < 10.0 magenta (bad)
|
|
[100.0/255.0, 0.0, 200.0/255.0], # 10.0 <= x purple (terrible)
|
|
]
|
|
|
|
precipitation = []
|
|
precipitation_thresholds = [0.1, 0.22, 0.47, 1.0, 2.2, 4.7, 10, 22, 47, 100]
|
|
pollen = []
|
|
pollen_thresholds = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
|
|
aqi = []
|
|
aqi_thresholds = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
|
|
paqi = []
|
|
paqi_thresholds = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
|
|
uvi = []
|
|
uvi_thresholds = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
|
|
iaqi = []
|
|
iaqi_thresholds = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
|
|
|
|
def get_air_quality_metric(self, j, t, metric, periodicity):
|
|
x = []
|
|
try:
|
|
for i in j[metric]:
|
|
if i["time"]>= t - periodicity:
|
|
x.append(i["value"])
|
|
except:
|
|
print("Couldn't find metric " + metric)
|
|
|
|
return x
|
|
|
|
def get_air_quality(self, *args):
|
|
if hasattr(self.settings, "address") == False:
|
|
print("No address specified")
|
|
return
|
|
|
|
url = "https://sinoptik.luon.net/forecast?address=" + urllib.parse.quote(self.settings.address, safe="") + "&metrics=precipitation&metrics=UVI&metrics=AQI&metrics=pollen&metrics=PAQI"
|
|
response = requests.get(url)
|
|
|
|
self.precipitation = []
|
|
self.pollen = []
|
|
self.aqi = []
|
|
self.paqi = []
|
|
self.uvi = []
|
|
self.iaqi = []
|
|
|
|
if response.status_code == 200:
|
|
t = datetime.datetime.now().timestamp()
|
|
j = json.loads(response.text)
|
|
|
|
self.precipitation = self.get_air_quality_metric(j, t, "precipitation", 300)
|
|
# self.precipitation = [0, 0.1, 0.22, 0.47, 1, 2.2, 4.7, 10, 22, 47, 100]
|
|
self.pollen = self.get_air_quality_metric(j, t, "pollen", 3600)
|
|
self.aqi = self.get_air_quality_metric(j, t, "AQI", 3600)
|
|
self.paqi = self.get_air_quality_metric(j, t, "PAQI", 3600)
|
|
self.uvi = self.get_air_quality_metric(j, t, "UVI", 3600 * 24)
|
|
else:
|
|
print("Error retrieving air quality; got response " + str(response))
|
|
|
|
def sync_air_quality(self, *args):
|
|
Clock.schedule_interval(self.get_air_quality, 60)
|
|
|
|
def update_background_automatic_sunrise(self):
|
|
background = self.ids["background"]
|
|
self.draw_list_curr_frame.append(["canvas.clear()", background])
|
|
with background.canvas:
|
|
color = self.intensity_to_rgb(self.intensity_curr)
|
|
|
|
self.draw_list_curr_frame.append(["Color", background.canvas, color[0], color[1], color[2]])
|
|
self.draw_list_curr_frame.append(["Rectangle", background.canvas, background.size, background.pos, None])
|
|
|
|
def update_background_automatic_no_sunrise(self):
|
|
background = self.ids["background"]
|
|
self.draw_list_curr_frame.append(["canvas.clear()", background])
|
|
with background.canvas:
|
|
color = self.theme.color_background
|
|
|
|
self.draw_list_curr_frame.append(["Color", background.canvas, color[0], color[1], color[2]])
|
|
self.draw_list_curr_frame.append(["Rectangle", background.canvas, background.size, background.pos, None])
|
|
|
|
def apply_theme(self):
|
|
if self.settings.theme_selected == "Automatic":
|
|
if (self.light_state != "sunrise") and (self.light_state != "on"):
|
|
# switch to light theme after 7:00 AM, to dark theme after 19:00
|
|
t = datetime.datetime.now()
|
|
h = t.hour + t.minute / 60
|
|
if (h >= 7) and (h < 19):
|
|
if self.theme.name != "Light":
|
|
self.theme = Theme("Light")
|
|
else:
|
|
if self.theme.name != "Dark":
|
|
self.theme = Theme("Dark")
|
|
|
|
self.update_background_automatic_no_sunrise()
|
|
|
|
else:
|
|
if self.intensity_curr >= 0.5:
|
|
if self.theme.name != "Light":
|
|
self.theme = Theme("Light")
|
|
else:
|
|
if self.theme.name != "Dark":
|
|
self.theme = Theme("Dark")
|
|
|
|
self.update_background_automatic_sunrise()
|
|
|
|
else:
|
|
if self.theme.name != self.settings.theme_selected:
|
|
self.theme = Theme(self.settings.theme_selected)
|
|
self.update_background_automatic_no_sunrise()
|
|
|
|
self.ids["settings_menu_wake_up_sound_label_top"].color = self.theme.color_font
|
|
self.settings_menu_wake_up_sound_Ok_button.color = self.theme.color_font
|
|
self.ids["settings_menu_theme_label_top"].color = self.theme.color_font
|
|
self.settings_menu_theme_Ok_button.color = self.theme.color_font
|
|
|
|
def find_themes(self):
|
|
themes = next(walk('themes/'))[1]
|
|
if ('Dark' in themes) and ('Light' in themes):
|
|
themes.append('Automatic')
|
|
print('Found the following themes: ' + str(themes))
|
|
return themes
|
|
|
|
def add_themes(self):
|
|
self.themes = self.find_themes()
|
|
|
|
x = self.ids["settings_menu_theme_boxlayout"]
|
|
gl = GridLayout(
|
|
cols=2,
|
|
)
|
|
|
|
self.ids["settings_menu_theme_select_button"].text = self.settings.theme_selected
|
|
|
|
self.theme_checkboxes = []
|
|
self.theme_labels = []
|
|
|
|
i = 0
|
|
for w in self.themes:
|
|
c = CheckBox(
|
|
group = "settings_menu_theme",
|
|
size = [gl.size[0] * 0.1, gl.size[1]],
|
|
)
|
|
c.bind(active=self.settings_menu_theme_cb)
|
|
gl.add_widget(c)
|
|
self.theme_checkboxes.append(c)
|
|
|
|
if i == 0:
|
|
a = True
|
|
else:
|
|
a = False
|
|
|
|
l = Label(
|
|
text = w,
|
|
halign = "left",
|
|
valign = "middle",
|
|
size = [Window.size[0] * 0.3, Window.size[1]],
|
|
text_size = Window.size,
|
|
font_size = Window.height*0.05,
|
|
color = self.theme.color_font,
|
|
)
|
|
l.text_size = l.size
|
|
gl.add_widget(l)
|
|
self.theme_labels.append(l)
|
|
i = i + 1
|
|
|
|
x.add_widget(gl)
|
|
|
|
b = Button(
|
|
text = "Ok",
|
|
font_size = self.height*0.3,
|
|
color = self.theme.color_font,
|
|
background_normal = '',
|
|
background_color = self.theme.color_button
|
|
)
|
|
b.bind(on_press = self.settings_menu_theme_Ok_button_cb)
|
|
x.add_widget(b)
|
|
self.settings_menu_theme_Ok_button = b
|
|
|
|
self.apply_theme()
|
|
|
|
def apply_settings(self):
|
|
self.ids["volume_slider"].value = self.settings.wake_up_volume
|
|
self.ids["settings_menu_wake_up_sound_select_button"].text = self.settings.sound_selected
|
|
self.ids["wake_up_brightness_slider"].value = self.settings.wake_up_brightness
|
|
self.ids["reading_light_brightness_slider"].value = self.settings.reading_light_brightness
|
|
self.ids["display_brightness_slider"].value = self.settings.display_brightness
|
|
|
|
def add_wake_up_sounds(self):
|
|
x = self.ids["settings_menu_wake_up_sound_boxlayout"]
|
|
gl = GridLayout(
|
|
cols=2,
|
|
)
|
|
|
|
self.wake_up_sounds = WakeUpSounds
|
|
|
|
self.settings.sound_source = self.wake_up_sounds[self.settings.sound_selected]
|
|
|
|
self.wake_up_sound_checkboxes = []
|
|
self.wake_up_sound_labels = []
|
|
|
|
i = 0
|
|
for w in self.wake_up_sounds:
|
|
c = CheckBox(
|
|
group = "settings_menu_wake_up_sound",
|
|
size = [gl.size[0] * 0.1, gl.size[1]],
|
|
)
|
|
c.bind(active=self.settings_menu_wake_up_sound_cb)
|
|
gl.add_widget(c)
|
|
self.wake_up_sound_checkboxes.append(c)
|
|
|
|
if i == 0:
|
|
a = True
|
|
else:
|
|
a = False
|
|
|
|
l = Label(
|
|
text = w,
|
|
halign = "left",
|
|
valign = "middle",
|
|
size = [Window.size[0] * 0.3, Window.size[1]],
|
|
text_size = Window.size,
|
|
font_size = Window.height*0.05,
|
|
color = self.theme.color_font,
|
|
)
|
|
l.text_size = l.size
|
|
gl.add_widget(l)
|
|
self.wake_up_sound_labels.append(l)
|
|
i = i + 1
|
|
|
|
x.add_widget(gl)
|
|
|
|
b = Button(
|
|
text = "Ok",
|
|
font_size = self.height*0.3,
|
|
color = self.theme.color_font,
|
|
background_normal = '',
|
|
background_color = self.theme.color_button
|
|
)
|
|
b.bind(on_press = self.settings_menu_wake_up_sound_Ok_button_cb)
|
|
x.add_widget(b)
|
|
self.settings_menu_wake_up_sound_Ok_button = b
|
|
|
|
def set_volume(self, x):
|
|
self.mixer.setvolume(int(x * 100))
|
|
self.volume_prev = self.volume_curr
|
|
self.volume_curr = x
|
|
|
|
def play_sound(self, source):
|
|
if (self.player.get_state() == vlc.State.NothingSpecial) or \
|
|
(self.player.get_state() == vlc.State.Paused) or \
|
|
(self.player.get_state() == vlc.State.Stopped) or \
|
|
(self.player.get_state() == vlc.State.Ended) or \
|
|
(self.player.get_state() == vlc.State.Error):
|
|
print("beep beep! " + source)
|
|
self.volume_target = self.settings.wake_up_volume / 20.0
|
|
media = self.vlc.media_new(source)
|
|
self.player.set_media(media)
|
|
self.player.play()
|
|
self.settings.alarm_playing = True
|
|
|
|
|
|
def stop_sound(self):
|
|
self.player.stop()
|
|
self.settings.alarm_playing = False
|
|
|
|
def set_backlight(self, x):
|
|
offset = 3
|
|
# 20 steps to from 1 to 100 - offset
|
|
c = (100 - offset)**(1/20)
|
|
|
|
y = c**x + offset
|
|
z = max(1, round(y))
|
|
if self.is_arm:
|
|
if backlight.brightness != z:
|
|
backlight.brightness = z
|
|
|
|
def hide_widget(self, widget, hide=True):
|
|
if hasattr(widget, 'saved_attrs'):
|
|
if not hide:
|
|
widget.height, widget.size_hint_y, widget.opacity, widget.disabled = widget.saved_attrs
|
|
del widget.saved_attrs
|
|
elif hide:
|
|
widget.saved_attrs = widget.height, widget.size_hint_y, widget.opacity, widget.disabled
|
|
widget.height, widget.size_hint_y, widget.opacity, widget.disabled = 0, None, 0, True
|
|
|
|
def is_widget_hidden(self, widget):
|
|
return hasattr(widget, 'saved_attrs')
|
|
|
|
def draw_numbers(self):
|
|
"""
|
|
Add number labels when added in widget hierarchy
|
|
"""
|
|
|
|
if self.view == "set_alarm":
|
|
t = self.settings.alarm_time
|
|
else:
|
|
t = datetime.datetime.now()
|
|
|
|
for i in range(1, 13):
|
|
if t.hour < 12:
|
|
offset = 0
|
|
else:
|
|
offset = 12
|
|
|
|
self.face_numbers.append(Label(
|
|
text=str(i + offset),
|
|
font_size=float(Config.get('graphics', 'height'))*0.05,
|
|
color=self.theme.color_numbers,
|
|
pos_hint={
|
|
# pos_hint is a fraction in range (0, 1)
|
|
"center_x": 0.5 + 0.45*math.sin(2 * math.pi * i/12),
|
|
"center_y": 0.5 + 0.45*math.cos(2 * math.pi * i/12),
|
|
}
|
|
))
|
|
self.ids["face"].add_widget(self.face_numbers[i - 1])
|
|
|
|
def draw_colored_circle(self, reference, x, y, r, color):
|
|
if color != [0.0, 0.0, 0.0]:
|
|
if color == [1, 1, 1]:
|
|
# Draw black circle
|
|
p = [x - r, y - r]
|
|
self.draw_list_curr_frame.append(["Color", reference.canvas, 0, 0, 0])
|
|
self.draw_list_curr_frame.append(["Ellipse", reference.canvas, [2 * r, 2 * r], p])
|
|
|
|
# Draw slightly smaller white circle
|
|
p = [x - r * 0.95, y - r * 0.95]
|
|
self.draw_list_curr_frame.append(["Color", reference.canvas, color[0], color[1], color[2]])
|
|
self.draw_list_curr_frame.append(["Ellipse", reference.canvas, [2 * r * 0.95, 2 * r * 0.95], p])
|
|
else:
|
|
# Draw slightly smaller colored circle
|
|
p = [x - r, y - r]
|
|
self.draw_list_curr_frame.append(["Color", reference.canvas, color[0], color[1], color[2]])
|
|
self.draw_list_curr_frame.append(["Ellipse", reference.canvas, [2 * r, 2 * r], p])
|
|
|
|
def calculate_colors(self, x, x_thresholds):
|
|
colors = []
|
|
for i in range(0, len(x)):
|
|
idx = 0
|
|
for l in x_thresholds:
|
|
if l > x[i]:
|
|
break
|
|
idx = idx + 1
|
|
|
|
if idx >= len(self.aqi_colors):
|
|
idx = len(self.aqi_colors) - 1
|
|
|
|
colors.append(self.aqi_colors[idx])
|
|
return colors
|
|
|
|
def draw_precipitation_paqi_expectation(self, x, x_thresholds, location):
|
|
if len(x) == 0:
|
|
return
|
|
|
|
face_plate = self.ids["face_plate"]
|
|
with face_plate.canvas:
|
|
N = min(12, len(x))
|
|
colors = self.calculate_colors(x[:N], x_thresholds)
|
|
|
|
for i in range(0, N):
|
|
color = colors[i]
|
|
R = face_plate.size[0] / 2
|
|
r = R / 10
|
|
tmp_x = 0.5 + location*math.sin(2 * math.pi * i/12)
|
|
tmp_y = 0.5 + location*math.cos(2 * math.pi * i/12)
|
|
coord_x = face_plate.pos[0] + 2 * R * tmp_x
|
|
coord_y = face_plate.pos[1] + 2 * R * tmp_y
|
|
self.draw_colored_circle(face_plate, coord_x, coord_y, r, color)
|
|
|
|
def draw_precipitation_expectation(self):
|
|
self.draw_precipitation_paqi_expectation(self.precipitation, self.precipitation_thresholds, 0.45)
|
|
|
|
def draw_paqi_expectation(self):
|
|
self.draw_precipitation_paqi_expectation(self.paqi, self.paqi_thresholds, 0.32)
|
|
|
|
def paint_icon(self, color, img_source, label):
|
|
c = (int(256 * color[0]), int(256 * color[1]), int(256 * color[2]), int(256))
|
|
tmp = Image.new('RGBA', img_source.size, color = c)
|
|
img_modified = ImageChops.multiply(tmp, img_source)
|
|
|
|
data = BytesIO()
|
|
img_modified.save(data, format='png')
|
|
data.seek(0)
|
|
im = CoreImage(BytesIO(data.read()), ext='png')
|
|
|
|
icon = self.ids[label]
|
|
icon.texture = im.texture
|
|
|
|
def draw_icon_helper(self, x, x_thresholds, x_label, L, color_prev, img):
|
|
N = min(L, len(x))
|
|
colors = self.calculate_colors(x[:N], x_thresholds)
|
|
color = colors[x.index(max(x[:N]))]
|
|
|
|
if color_prev != color:
|
|
# Color has changed
|
|
if color == [1, 1, 1]:
|
|
img = Image.open("icons/" + x_label + "_outline.png")
|
|
else:
|
|
if color_prev == [1, 1, 1]:
|
|
img = Image.open("icons/" + x_label + ".png")
|
|
|
|
if self.is_arm:
|
|
img = img.resize((int(img.width * 0.67), int(img.height * 0.67)))
|
|
|
|
self.paint_icon(color, img, "icon_" + x_label)
|
|
|
|
return color
|
|
|
|
def draw_icon_iaqi(self):
|
|
if hasattr(self, 'image_iaqi') == False:
|
|
self.image_iaqi = Image.open("icons/iaqi.png")
|
|
|
|
if len(self.iaqi) == 0:
|
|
if self.is_widget_hidden(self.ids["icon_iaqi"]) == False:
|
|
self.draw_list_curr_frame.append(["self.hide_widget", self.ids["icon_iaqi"], True])
|
|
return
|
|
|
|
if self.is_widget_hidden(self.ids["icon_iaqi"]):
|
|
self.draw_list_curr_frame.append(["self.hide_widget", self.ids["icon_iaqi"], False])
|
|
|
|
if hasattr(self, 'iaqi_color_prev') == False:
|
|
self.iaqi_color_prev = []
|
|
|
|
if hasattr(self, 'iaqi_color') == False:
|
|
self.iaqi_color = []
|
|
|
|
color = self.draw_icon_helper(self.iaqi, self.iaqi_thresholds, "iaqi", 1, self.iaqi_color_prev, self.image_iaqi)
|
|
self.iaqi_color_prev = self.iaqi_color
|
|
self.iaqi_color = color
|
|
|
|
def draw_icon_uvi(self):
|
|
if hasattr(self, 'image_uvi') == False:
|
|
self.image_uvi = Image.open("icons/uvi.png")
|
|
|
|
if len(self.uvi) == 0:
|
|
if self.is_widget_hidden(self.ids["icon_uvi"]) == False:
|
|
self.draw_list_curr_frame.append(["self.hide_widget", self.ids["icon_uvi"], True])
|
|
return
|
|
|
|
if self.is_widget_hidden(self.ids["icon_uvi"]):
|
|
self.draw_list_curr_frame.append(["self.hide_widget", self.ids["icon_uvi"], False])
|
|
|
|
if hasattr(self, 'uvi_color_prev') == False:
|
|
self.uvi_color_prev = []
|
|
|
|
if hasattr(self, 'uvi_color') == False:
|
|
self.uvi_color = []
|
|
|
|
color = self.draw_icon_helper(self.uvi, self.uvi_thresholds, "uvi", 1, self.uvi_color_prev, self.image_uvi)
|
|
self.uvi_color_prev = self.uvi_color
|
|
self.uvi_color = color
|
|
|
|
def draw_icon_pollen(self):
|
|
if hasattr(self, 'image_pollen') == False:
|
|
self.image_pollen = Image.open("icons/pollen.png")
|
|
|
|
if len(self.pollen) == 0:
|
|
if self.is_widget_hidden(self.ids["icon_pollen"]) == False:
|
|
self.draw_list_curr_frame.append(["self.hide_widget", self.ids["icon_pollen"], True])
|
|
return
|
|
|
|
if self.is_widget_hidden(self.ids["icon_pollen"]):
|
|
self.draw_list_curr_frame.append(["self.hide_widget", self.ids["icon_pollen"], False])
|
|
|
|
if hasattr(self, 'pollen_color_prev') == False:
|
|
self.pollen_color_prev = []
|
|
|
|
if hasattr(self, 'pollen_color') == False:
|
|
self.pollen_color = []
|
|
|
|
color = self.draw_icon_helper(self.pollen, self.pollen_thresholds, "pollen", 12, self.pollen_color_prev, self.image_pollen)
|
|
self.pollen_color_prev = self.pollen_color
|
|
self.pollen_color = color
|
|
|
|
def draw_icon_aqi(self):
|
|
if hasattr(self, 'image_aqi') == False:
|
|
self.image_aqi = Image.open("icons/aqi.png")
|
|
|
|
if len(self.aqi) == 0:
|
|
if self.is_widget_hidden(self.ids["icon_aqi"]) == False:
|
|
self.draw_list_curr_frame.append(["self.hide_widget", self.ids["icon_aqi"], True])
|
|
return
|
|
|
|
if self.is_widget_hidden(self.ids["icon_aqi"]):
|
|
self.draw_list_curr_frame.append(["self.hide_widget", self.ids["icon_aqi"], False])
|
|
|
|
if hasattr(self, 'aqi_color_prev') == False:
|
|
self.aqi_color_prev = []
|
|
|
|
if hasattr(self, 'aqi_color') == False:
|
|
self.aqi_color = []
|
|
|
|
color = self.draw_icon_helper(self.aqi, self.aqi_thresholds, "aqi", 12, self.aqi_color_prev, self.image_aqi)
|
|
self.aqi_color_prev = self.aqi_color
|
|
self.aqi_color = color
|
|
|
|
def draw_icons(self):
|
|
self.draw_icon_uvi()
|
|
self.draw_icon_pollen()
|
|
self.draw_icon_aqi()
|
|
self.draw_icon_iaqi()
|
|
|
|
def draw_face(self):
|
|
self.draw_numbers()
|
|
|
|
def update_theme(self):
|
|
if self.settings.theme_selected == "Automatic":
|
|
self.apply_theme()
|
|
|
|
def update_face(self):
|
|
face_plate = self.ids["face_plate"]
|
|
self.draw_list_curr_frame.append(["canvas.clear()", face_plate])
|
|
|
|
if self.view == "set_alarm":
|
|
t = self.settings.alarm_time
|
|
else:
|
|
t = datetime.datetime.now()
|
|
|
|
if (self.view == "clock") and (self.precipitation != []) and (self.paqi != []):
|
|
for i in range(0, 12):
|
|
self.face_numbers[i].text = ""
|
|
|
|
self.draw_precipitation_expectation()
|
|
self.draw_paqi_expectation()
|
|
self.draw_icons()
|
|
else:
|
|
with face_plate.canvas:
|
|
color = self.theme.color_numbers
|
|
self.draw_list_curr_frame.append(["Color", face_plate.canvas, color[0], color[1], color[2]])
|
|
r = face_plate.size[0] / 2
|
|
p = [face_plate.pos[0] + r, face_plate.pos[1] + r]
|
|
self.draw_list_curr_frame.append(["Circle", face_plate.canvas, p, r])
|
|
|
|
for i in range(0, 12):
|
|
if t.hour < 12:
|
|
offset = 0
|
|
else:
|
|
offset = 12
|
|
|
|
self.face_numbers[i].color = self.theme.color_numbers
|
|
self.face_numbers[i].text = str(i + 1 + offset)
|
|
|
|
def on_parent(self, myclock, parent):
|
|
self.draw_face()
|
|
|
|
def position_on_clock(self, fraction, length):
|
|
"""
|
|
Calculate position in the clock using trygonometric functions
|
|
"""
|
|
center_x = self.size[0]/2
|
|
center_y = self.size[1]/2
|
|
return Position(
|
|
center_x + round(length * math.sin(2 * math.pi * fraction)),
|
|
center_y + round(length * math.cos(2 * math.pi * fraction)),
|
|
)
|
|
|
|
def update_light_button(self):
|
|
if (self.light_state == "off"):
|
|
source = self.theme.icon_light_off
|
|
rgb = [1.0, 1.0, 1.0]
|
|
elif (self.light_state == "reading"):
|
|
source = self.theme.icon_light_reading
|
|
rgb = [1.0, 1.0, 1.0]
|
|
elif (self.light_state == "sunrise"):
|
|
source = self.theme.icon_light_sunrise
|
|
rgb = [1.0, 1.0, 1.0]
|
|
elif (self.light_state == "on"):
|
|
source = self.theme.icon_light_on
|
|
rgb = [1.0, 1.0, 1.0]
|
|
|
|
light_button = self.ids["light_button"]
|
|
self.draw_list_curr_frame.append(["canvas.clear()", light_button])
|
|
with light_button.canvas:
|
|
self.draw_list_curr_frame.append(["Color", light_button.canvas, rgb[0], rgb[1], rgb[2]])
|
|
self.draw_list_curr_frame.append(["Rectangle", light_button.canvas, light_button.size, light_button.pos, source])
|
|
|
|
def update_play_button(self):
|
|
if self.settings.alarm_playing:
|
|
source = self.theme.icon_media_playing
|
|
rgb = [1.0, 1.0, 1.0]
|
|
else:
|
|
source = self.theme.icon_media_stopped
|
|
rgb = [1.0, 1.0, 1.0]
|
|
|
|
play_button = self.ids["play_button"]
|
|
self.draw_list_curr_frame.append(["canvas.clear()", play_button])
|
|
with play_button.canvas:
|
|
self.draw_list_curr_frame.append(["Color", play_button.canvas, rgb[0], rgb[1], rgb[2]])
|
|
self.draw_list_curr_frame.append(["Rectangle", play_button.canvas, play_button.size, play_button.pos, source])
|
|
|
|
def update_set_alarm_button(self):
|
|
if (self.view == "set_alarm") or self.settings.alarm_activated:
|
|
source = self.theme.icon_alarm_on
|
|
rgb = [1.0, 1.0, 1.0]
|
|
else:
|
|
source = self.theme.icon_alarm_off
|
|
rgb = [1.0, 1.0, 1.0]
|
|
|
|
set_alarm_button = self.ids["set_alarm_button"]
|
|
self.draw_list_curr_frame.append(["canvas.clear()", set_alarm_button])
|
|
with set_alarm_button.canvas:
|
|
self.draw_list_curr_frame.append(["Color", set_alarm_button.canvas, rgb[0], rgb[1], rgb[2]])
|
|
self.draw_list_curr_frame.append(["Rectangle", set_alarm_button.canvas, set_alarm_button.size, set_alarm_button.pos, source])
|
|
|
|
def update_settings_button(self):
|
|
if (self.view.startswith("settings_menu")):
|
|
source = self.theme.icon_settings_visible
|
|
rgb = [1.0, 1.0, 1.0]
|
|
else:
|
|
source = self.theme.icon_settings_not_visible
|
|
rgb = [1.0, 1.0, 1.0]
|
|
|
|
settings_button = self.ids["settings_button"]
|
|
self.draw_list_curr_frame.append(["canvas.clear()", settings_button])
|
|
with settings_button.canvas:
|
|
self.draw_list_curr_frame.append(["Color", settings_button.canvas, rgb[0], rgb[1], rgb[2]])
|
|
self.draw_list_curr_frame.append(["Rectangle", settings_button.canvas, settings_button.size, settings_button.pos, source])
|
|
|
|
def intensity_to_rgb(self, intensity):
|
|
if intensity < 0:
|
|
intensity = 0
|
|
elif intensity > 1:
|
|
intensity = 1
|
|
|
|
# sunlight intensity and color temperature vary with sine function
|
|
intensity = math.sin(2 * math.pi * intensity / 4)
|
|
|
|
# from https://tannerhelland.com/2012/09/18/convert-temperature-rgb-algorithm-code.html
|
|
# usable between 1000 and 40000 K
|
|
|
|
# we only want color temperatures between 2000 and 6500 K
|
|
CCT = 2000 + (6500 - 2000) * intensity
|
|
|
|
if CCT < 1000:
|
|
CCT = 1000
|
|
if CCT > 40000:
|
|
CCT = 40000
|
|
|
|
Temperature = CCT / 100
|
|
|
|
if Temperature <= 66:
|
|
Red = 255
|
|
else:
|
|
Red = Temperature - 60
|
|
Red = 329.698727446 * pow(Red, -0.1332047592)
|
|
if Red < 0:
|
|
Red = 0
|
|
if Red > 255:
|
|
Red = 255
|
|
|
|
if Temperature <= 66:
|
|
Green = Temperature
|
|
Green = 99.4708025861 * math.log(Green) - 161.1195681661
|
|
if Green < 0:
|
|
Green = 0
|
|
if Green > 255:
|
|
Green = 255
|
|
else:
|
|
Green = Temperature - 60
|
|
Green = 288.1221695283 * pow(Green, -0.0755148492)
|
|
if Green < 0:
|
|
Green = 0
|
|
if Green > 255:
|
|
Green = 255
|
|
|
|
if Temperature >= 66:
|
|
Blue = 255
|
|
else:
|
|
if Temperature <= 19:
|
|
Blue = 0
|
|
else:
|
|
Blue = Temperature - 10
|
|
Blue = 138.5177312231 * math.log(Blue) - 305.0447927307
|
|
if Blue < 0:
|
|
Blue = 0
|
|
if Blue > 255:
|
|
Blue = 255
|
|
|
|
rgb_cct = [Red / 255, Green / 255, Blue / 255]
|
|
|
|
# adjust intensity
|
|
[h, s, l]= rgb_to_hsluv(rgb_cct)
|
|
|
|
l = l * intensity
|
|
rgb = hsluv_to_rgb([h, s, l])
|
|
|
|
return rgb
|
|
|
|
def intensity_to_rgbw(self, intensity):
|
|
rgb = self.intensity_to_rgb(intensity)
|
|
led_color = RGB(rgb[0] * 255, rgb[1] * 255, rgb[2] * 255)
|
|
|
|
return led_color
|
|
|
|
def update_backlight(self):
|
|
# make sure brightness of display is never lower than intensity of leds
|
|
brightness_min = 20 * self.intensity_curr
|
|
if self.settings.display_brightness < brightness_min:
|
|
self.set_backlight(brightness_min)
|
|
else:
|
|
self.set_backlight(self.settings.display_brightness)
|
|
|
|
def set_leds(self):
|
|
if self.intensity_prev != self.intensity_curr:
|
|
self.intensity_prev = self.intensity_curr
|
|
if self.is_arm:
|
|
led_color = self.intensity_to_rgbw(self.intensity_curr)
|
|
if self.rgbw_prev != led_color.rgbw:
|
|
self.rgbw_prev = led_color.rgbw
|
|
# print(self.light_state + ", t: " + str(self.seconds_to_next_alarm) + ", i: " + str(self.intensity_curr) + ", rgbw: " + str(led_color.rgbw))
|
|
pixels.fill(led_color.rgbw)
|
|
pixels.show()
|
|
else:
|
|
# On non-arm rgbw_colorspace_converter and hsluv are not available; fake rgbw by setting w component to scaled value of intensity_curr
|
|
rgbw = [0, 0, 0, round(self.intensity_curr * 255)]
|
|
if self.rgbw_prev != rgbw:
|
|
self.rgbw_prev = rgbw
|
|
# print(self.light_state + ", t: " + str(self.seconds_to_next_alarm) + ", i: " + str(self.intensity_curr) + ", rgbw: " + str(rgbw))
|
|
|
|
def sunrise(self):
|
|
if self.view == "set_alarm":
|
|
# Do not simulate sunrise when adjusting alarm time
|
|
return
|
|
|
|
if self.seconds_to_next_alarm < 0.1:
|
|
intensity_target = (self.settings.wake_up_brightness / 20.0)
|
|
new_state = "on"
|
|
else:
|
|
intensity_target = (1.0 - self.seconds_to_next_alarm / self.settings.seconds_to_sunrise) * (self.settings.wake_up_brightness / 20.0)
|
|
new_state = "sunrise"
|
|
|
|
# only adjust intensity_target if new intensity_target is higher than current intesity, to avoid dimming light when reading mode is on
|
|
if self.intensity_target < intensity_target:
|
|
self.intensity_target = intensity_target
|
|
self.light_state = new_state
|
|
|
|
def process_led_state(self):
|
|
if (self.settings.alarm_activated) and (self.seconds_to_next_alarm < self.settings.seconds_to_sunrise):
|
|
self.sunrise()
|
|
else:
|
|
if (self.light_state == "off"):
|
|
self.intensity_target = 0
|
|
elif (self.light_state == "reading"):
|
|
self.intensity_target = self.settings.reading_light_brightness / 20.0
|
|
elif (self.light_state == "on"):
|
|
self.intensity_target = self.settings.wake_up_brightness / 20.0
|
|
|
|
weight = 0.05
|
|
intensity_next = weight * self.intensity_target + (1 - weight) * self.intensity_curr
|
|
|
|
step = intensity_next - self.intensity_curr
|
|
|
|
if abs(step) < 0.001:
|
|
step = self.intensity_target - self.intensity_curr
|
|
|
|
self.intensity_curr = self.intensity_curr + step
|
|
|
|
def process_volume_state(self):
|
|
if (self.settings.alarm_playing) and (self.player.get_state() == vlc.State.Playing):
|
|
step = 0.005
|
|
|
|
if (self.volume_curr <= self.volume_target):
|
|
if (self.volume_curr + step > self.volume_target):
|
|
step = self.volume_target - self.volume_curr
|
|
else:
|
|
step = -step
|
|
if (self.volume_curr + step < self.volume_target):
|
|
step = self.volume_target - self.volume_curr
|
|
|
|
if step != 0:
|
|
volume_next = self.volume_curr + step
|
|
self.set_volume(volume_next)
|
|
|
|
if volume_next == 0:
|
|
self.stop_sound()
|
|
|
|
def check_play_sound(self):
|
|
if self.settings.alarm_activated == False:
|
|
return
|
|
|
|
if (self.seconds_to_next_alarm < 0.1) or (self.settings.alarm_playing == True):
|
|
if self.settings.sound_source != "":
|
|
self.play_sound(self.settings.sound_source)
|
|
|
|
def calc_seconds_to_next_alarm(self):
|
|
if self.settings.alarm_activated == False:
|
|
return
|
|
|
|
# Make sure alarm_time is in the future but not more than 24 h from now
|
|
now = datetime.datetime.now()
|
|
d = self.settings.alarm_time - now
|
|
self.settings.alarm_time -= datetime.timedelta(days=d.days)
|
|
|
|
# Calculate number of seconds until next alarm
|
|
d = self.settings.alarm_time - now
|
|
self.seconds_to_next_alarm = d.days * 24 * 3600 + d.seconds + d.microseconds / 1000000.0
|
|
|
|
def check_alarm(self):
|
|
self.calc_seconds_to_next_alarm()
|
|
self.process_led_state()
|
|
self.set_leds()
|
|
self.update_backlight()
|
|
self.check_play_sound()
|
|
self.process_volume_state()
|
|
|
|
def update_clock(self):
|
|
self.draw_list_curr_frame.append(["self.hide_widget", self.ids["face_plate"], False])
|
|
self.draw_list_curr_frame.append(["self.hide_widget", self.ids["face"], False])
|
|
self.draw_list_curr_frame.append(["self.hide_widget", self.ids["hands"], False])
|
|
|
|
if self.view == "clock":
|
|
if len(self.uvi) > 0:
|
|
self.draw_list_curr_frame.append(["self.hide_widget", self.ids["icon_uvi"], False])
|
|
|
|
if len(self.pollen) > 0:
|
|
self.draw_list_curr_frame.append(["self.hide_widget", self.ids["icon_pollen"], False])
|
|
|
|
if len(self.aqi) > 0:
|
|
self.draw_list_curr_frame.append(["self.hide_widget", self.ids["icon_aqi"], False])
|
|
|
|
if self.view == "set_alarm":
|
|
t = self.settings.alarm_time
|
|
else:
|
|
t = datetime.datetime.now()
|
|
|
|
hands = self.ids["hands"]
|
|
seconds_hand = self.position_on_clock(t.second/60, length=0.45*hands.size[0])
|
|
minutes_hand = self.position_on_clock(t.minute/60+t.second/3600, length=0.38*hands.size[0])
|
|
hours_hand = self.position_on_clock(t.hour/12 + t.minute/720, length=0.32*hands.size[0])
|
|
|
|
self.draw_list_curr_frame.append(["canvas.clear()", hands])
|
|
update_rate = App.get_running_app().update_rate
|
|
with hands.canvas:
|
|
if self.view == "set_alarm":
|
|
if self.grabbed != "" or self.set_alarm_timeout_counter < 1 * update_rate or \
|
|
self.set_alarm_timeout_counter % update_rate <= update_rate / 2 or self.settings.alarm_modified == False:
|
|
self.draw_list_curr_frame.append(["Color", hands.canvas, self.theme.color_alarm_hands_hours[0], self.theme.color_alarm_hands_hours[1], self.theme.color_alarm_hands_hours[2]])
|
|
self.draw_list_curr_frame.append(["Line", hands.canvas, [hands.center_x, hands.center_y, hours_hand.x, hours_hand.y], 3, "round"])
|
|
self.draw_list_curr_frame.append(["Color", hands.canvas, self.theme.color_alarm_hands_minutes[0], self.theme.color_alarm_hands_minutes[1], self.theme.color_alarm_hands_minutes[2]])
|
|
self.draw_list_curr_frame.append(["Line", hands.canvas, [hands.center_x, hands.center_y, minutes_hand.x, minutes_hand.y], 2, "round"])
|
|
|
|
if self.grabbed == "":
|
|
self.set_alarm_timeout_counter += 1
|
|
|
|
if self.set_alarm_timeout_counter >= 4.5 * update_rate:
|
|
self.view = "clock"
|
|
self.settings.write()
|
|
self.set_alarm_timeout_counter = 0
|
|
self.view_active_since = time.time()
|
|
|
|
if self.settings.alarm_modified:
|
|
self.settings.alarm_activated = True
|
|
self.settings.alarm_modified = False
|
|
else:
|
|
self.draw_list_curr_frame.append(["Color", hands.canvas, self.theme.color_clock_hands_hours[0], self.theme.color_clock_hands_hours[1], self.theme.color_clock_hands_hours[2]])
|
|
self.draw_list_curr_frame.append(["Line", hands.canvas, [hands.center_x, hands.center_y, hours_hand.x, hours_hand.y], 3, "round"])
|
|
self.draw_list_curr_frame.append(["Color", hands.canvas, self.theme.color_clock_hands_minutes[0], self.theme.color_clock_hands_minutes[1], self.theme.color_clock_hands_minutes[2]])
|
|
self.draw_list_curr_frame.append(["Line", hands.canvas, [hands.center_x, hands.center_y, minutes_hand.x, minutes_hand.y], 2, "round"])
|
|
self.draw_list_curr_frame.append(["Color", hands.canvas, self.theme.color_clock_hands_seconds[0], self.theme.color_clock_hands_seconds[1], self.theme.color_clock_hands_seconds[2]])
|
|
self.draw_list_curr_frame.append(["Line", hands.canvas, [hands.center_x, hands.center_y, seconds_hand.x, seconds_hand.y], 1, "round"])
|
|
self.update_face()
|
|
|
|
def update_settings_menu(self):
|
|
self.draw_list_curr_frame.append(["self.hide_widget", self.ids["settings_menu_background"], False])
|
|
self.draw_list_curr_frame.append(["self.hide_widget", self.ids["settings_menu"], False])
|
|
|
|
background = self.ids["settings_menu_background"]
|
|
self.draw_list_curr_frame.append(["canvas.clear()", background])
|
|
with background.canvas:
|
|
rgb = self.theme.color_shade
|
|
self.draw_list_curr_frame.append(["Color", background.canvas, rgb[0], rgb[1], rgb[2]])
|
|
self.draw_list_curr_frame.append(["Rectangle", background.canvas, background.size, background.pos, ""])
|
|
|
|
for s in ["label_0", "label_1", "label_2", "label_3", "label_4", "label_5", "theme_select_button", "wake_up_sound_select_button"]:
|
|
i = self.ids["settings_menu_" + s]
|
|
i.color = self.theme.color_font
|
|
i = self.ids["settings_menu_theme_select_button"]
|
|
i.background_color = self.theme.color_button
|
|
i = self.ids["settings_menu_wake_up_sound_select_button"]
|
|
i.background_color = self.theme.color_button
|
|
|
|
def update_settings_menu_wake_up_sound(self):
|
|
self.draw_list_curr_frame.append(["self.hide_widget", self.ids["settings_menu_wake_up_sound_background"], False])
|
|
self.draw_list_curr_frame.append(["self.hide_widget", self.ids["settings_menu_wake_up_sound"], False])
|
|
|
|
background = self.ids["settings_menu_wake_up_sound_background"]
|
|
self.draw_list_curr_frame.append(["canvas.clear()", background])
|
|
with background.canvas:
|
|
rgb = self.theme.color_shade
|
|
self.draw_list_curr_frame.append(["Color", background.canvas, rgb[0], rgb[1], rgb[2]])
|
|
self.draw_list_curr_frame.append(["Rectangle", background.canvas, background.size, background.pos, ""])
|
|
|
|
for i in self.wake_up_sound_labels:
|
|
i.color = self.theme.color_font
|
|
|
|
self.settings_menu_wake_up_sound_Ok_button.background_color = self.theme.color_button
|
|
|
|
def update_settings_menu_theme(self):
|
|
self.draw_list_curr_frame.append(["self.hide_widget", self.ids["settings_menu_theme_background"], False])
|
|
self.draw_list_curr_frame.append(["self.hide_widget", self.ids["settings_menu_theme"], False])
|
|
|
|
background = self.ids["settings_menu_theme_background"]
|
|
self.draw_list_curr_frame.append(["canvas.clear()", background])
|
|
with background.canvas:
|
|
rgb = self.theme.color_shade
|
|
self.draw_list_curr_frame.append(["Color", background.canvas, rgb[0], rgb[1], rgb[2]])
|
|
self.draw_list_curr_frame.append(["Rectangle", background.canvas, background.size, background.pos, ""])
|
|
|
|
for i in self.theme_labels:
|
|
i.color = self.theme.color_font
|
|
|
|
self.settings_menu_theme_Ok_button.background_color = self.theme.color_button
|
|
|
|
def update_settings(self):
|
|
if self.view == "settings_menu":
|
|
self.update_settings_menu()
|
|
elif self.view == "settings_menu_wake_up_sound":
|
|
self.update_settings_menu_wake_up_sound()
|
|
elif self.view == "settings_menu_theme":
|
|
self.update_settings_menu_theme()
|
|
|
|
def draw_display(self):
|
|
t = time.time()
|
|
if (self.view != self.view_prev) or (t - self.view_active_since < self.time_to_force_redraws_after_view_change):
|
|
self.draw_list_last_frame = [] # force redraw when view has changed
|
|
self.view_prev = self.view
|
|
|
|
if self.draw_list_curr_frame != self.draw_list_last_frame:
|
|
for i in self.draw_list_curr_frame:
|
|
if i[0] == "self.hide_widget":
|
|
self.hide_widget(i[1], i[2])
|
|
elif i[0] == "canvas.clear()":
|
|
i[1].canvas.clear()
|
|
elif i[0] == "Color":
|
|
with i[1]:
|
|
if len(i) == 5:
|
|
Color(i[2], i[3], i[4])
|
|
else:
|
|
Color(i[2], i[3], i[4], i[5])
|
|
elif i[0] == "Rectangle":
|
|
with i[1]:
|
|
Rectangle(size=i[2], pos=i[3], source=i[4])
|
|
elif i[0] == "Ellipse":
|
|
with i[1]:
|
|
Ellipse(size=i[2], pos=i[3])
|
|
elif i[0] == "Circle":
|
|
with i[1]:
|
|
Line(circle=(i[2][0], i[2][1], i[3]), width=4)
|
|
elif i[0] == "Line":
|
|
with i[1]:
|
|
Line(points=i[2], width=i[3], cap=i[4])
|
|
else:
|
|
print("Unknown draw command: " + i[0])
|
|
self.draw_list_last_frame = self.draw_list_curr_frame
|
|
self.draw_list_curr_frame = []
|
|
|
|
def process_touch_events(self):
|
|
t = time.time()
|
|
if (self.touch_down_event_curr is not None) and (self.touch_down_event_curr.processed == False) and \
|
|
(t - self.touch_down_event_curr.time > self.touch_delay_time):
|
|
self.touch_down_function(self.touch_down_event_curr.touch)
|
|
self.touch_down_event_curr.processed = True
|
|
self.touch_down_event_prev = copy.copy(self.touch_down_event_curr)
|
|
self.touch_down_event_curr = None
|
|
|
|
if (self.touch_move_event_curr is not None) and (self.touch_move_event_curr.processed == False) and \
|
|
(t - self.touch_move_event_curr.time > self.touch_delay_time):
|
|
self.touch_move_function(self.touch_move_event_curr.touch)
|
|
self.touch_move_event_curr.processed = True
|
|
self.touch_move_event_prev = copy.copy(self.touch_move_event_curr)
|
|
self.touch_move_event_curr = None
|
|
|
|
if (self.touch_up_event_curr is not None) and (self.touch_up_event_curr.processed == False) and \
|
|
(t - self.touch_up_event_curr.time > self.touch_delay_time):
|
|
self.touch_up_function(self.touch_up_event_curr.touch)
|
|
self.touch_up_event_curr.processed = True
|
|
self.touch_up_event_prev = copy.copy(self.touch_up_event_curr)
|
|
self.touch_up_event_curr = None
|
|
|
|
def update_display(self, *args):
|
|
self.process_touch_events()
|
|
self.check_alarm()
|
|
|
|
# Hide all dynamic widgets; will be enabled when updating respecive view
|
|
self.draw_list_curr_frame.append(["self.hide_widget", self.ids["face_plate"], True])
|
|
self.draw_list_curr_frame.append(["self.hide_widget", self.ids["face"], True])
|
|
self.draw_list_curr_frame.append(["self.hide_widget", self.ids["hands"], True])
|
|
self.draw_list_curr_frame.append(["self.hide_widget", self.ids["settings_menu_background"], True])
|
|
self.draw_list_curr_frame.append(["self.hide_widget", self.ids["settings_menu"], True])
|
|
self.draw_list_curr_frame.append(["self.hide_widget", self.ids["settings_menu_wake_up_sound_background"], True])
|
|
self.draw_list_curr_frame.append(["self.hide_widget", self.ids["settings_menu_wake_up_sound"], True])
|
|
self.draw_list_curr_frame.append(["self.hide_widget", self.ids["settings_menu_theme_background"], True])
|
|
self.draw_list_curr_frame.append(["self.hide_widget", self.ids["settings_menu_theme"], True])
|
|
self.draw_list_curr_frame.append(["self.hide_widget", self.ids["icon_uvi"], True])
|
|
self.draw_list_curr_frame.append(["self.hide_widget", self.ids["icon_pollen"], True])
|
|
self.draw_list_curr_frame.append(["self.hide_widget", self.ids["icon_aqi"], True])
|
|
|
|
self.update_theme()
|
|
self.update_light_button()
|
|
self.update_play_button()
|
|
self.update_set_alarm_button()
|
|
self.update_settings_button()
|
|
if self.view == "clock" or self.view == "set_alarm":
|
|
self.update_clock()
|
|
elif self.view.startswith("settings_menu"):
|
|
self.update_settings()
|
|
else:
|
|
print("unknown view: " + self.view)
|
|
|
|
self.draw_display()
|
|
|
|
def settings_menu_wake_up_sound_select_button_cb(self):
|
|
self.settings_menu_wake_up_sound_select_button_cb_hack = True
|
|
|
|
for c in self.wake_up_sound_checkboxes:
|
|
c.active = False
|
|
|
|
print("sound selected: " + self.settings.sound_selected)
|
|
|
|
n = 0
|
|
for i in self.wake_up_sounds:
|
|
if i == self.settings.sound_selected:
|
|
self.wake_up_sound_checkboxes[n].active = True
|
|
n = n + 1
|
|
|
|
self.view = "settings_menu_wake_up_sound"
|
|
self.view_active_since = time.time()
|
|
|
|
def settings_menu_wake_up_sound_Ok_button_cb(self, event):
|
|
self.ids["settings_menu_wake_up_sound_select_button"].text = self.settings.sound_selected
|
|
self.view = "settings_menu"
|
|
self.view_active_since = time.time()
|
|
|
|
def settings_menu_wake_up_sound_cb(self, instance, value):
|
|
n = 0
|
|
for c in self.wake_up_sound_checkboxes:
|
|
if c == instance:
|
|
break
|
|
n = n + 1
|
|
|
|
k = 0
|
|
for sound in self.wake_up_sounds:
|
|
if k == n:
|
|
break
|
|
k = k + 1
|
|
|
|
if self.settings_menu_wake_up_sound_select_button_cb_hack:
|
|
self.settings_menu_wake_up_sound_select_button_cb_hack = False
|
|
if not (self.settings.sound_selected == "" and sound != ""):
|
|
return
|
|
|
|
if value == True:
|
|
print("You selected " + sound)
|
|
else:
|
|
print("You deselected " + sound)
|
|
|
|
self.settings.sound_source = self.wake_up_sounds[sound]
|
|
self.settings.sound_selected = sound
|
|
|
|
|
|
|
|
|
|
def settings_menu_theme_select_button_cb(self):
|
|
self.settings_menu_theme_select_button_cb_hack = True
|
|
|
|
for c in self.theme_checkboxes:
|
|
c.active = False
|
|
|
|
print("theme selected: " + self.settings.theme_selected)
|
|
|
|
n = 0
|
|
print("self.themes: " + str(self.themes))
|
|
for i in self.themes:
|
|
if i == self.settings.theme_selected:
|
|
self.theme_checkboxes[n].active = True
|
|
n = n + 1
|
|
|
|
self.view = "settings_menu_theme"
|
|
self.view_active_since = time.time()
|
|
|
|
def settings_menu_theme_Ok_button_cb(self, event):
|
|
self.ids["settings_menu_theme_select_button"].text = self.settings.theme_selected
|
|
self.view = "settings_menu"
|
|
self.view_active_since = time.time()
|
|
|
|
def settings_menu_theme_cb(self, instance, value):
|
|
n = 0
|
|
for c in self.theme_checkboxes:
|
|
if c == instance:
|
|
break
|
|
n = n + 1
|
|
|
|
k = 0
|
|
for theme in self.themes:
|
|
if k == n:
|
|
break
|
|
k = k + 1
|
|
|
|
if self.settings_menu_theme_select_button_cb_hack:
|
|
self.settings_menu_theme_select_button_cb_hack = False
|
|
if not (self.settings.theme_selected == "" and theme != ""):
|
|
return
|
|
|
|
if value == True:
|
|
print("You selected " + theme)
|
|
else:
|
|
print("You deselected " + theme)
|
|
|
|
self.settings.theme_selected = theme
|
|
self.apply_theme()
|
|
self.settings.write()
|
|
|
|
def volume_slider_value(self, *args):
|
|
self.settings.wake_up_volume = int(args[1])
|
|
|
|
old_vol = self.mixer.getvolume()
|
|
|
|
if (self.settings.alarm_playing) and (self.player.get_state() == vlc.State.Playing):
|
|
# immediately set volume when audio is playing
|
|
self.volume_target = self.settings.wake_up_volume / 20.0
|
|
self.set_volume(self.volume_target)
|
|
|
|
new_vol = self.mixer.getvolume()
|
|
|
|
|
|
def wake_up_brightness_slider_value(self, *args):
|
|
self.settings.wake_up_brightness = int(args[1])
|
|
print("Wake up brightness changed to " + str(self.settings.wake_up_brightness))
|
|
|
|
def reading_light_brightness_slider_value(self, *args):
|
|
self.settings.reading_light_brightness = int(args[1])
|
|
if (self.light_state == "reading"):
|
|
self.intensity_target = self.settings.reading_light_brightness / 20.0
|
|
print("Reading light brightness changed to " + str(self.settings.reading_light_brightness))
|
|
|
|
def display_brightness_slider_value(self, *args):
|
|
self.settings.display_brightness = int(args[1])
|
|
|
|
def on_light_button_pressed(self):
|
|
print("light button pressed from view " + self.view)
|
|
|
|
if self.light_state == "off":
|
|
self.light_state = "reading"
|
|
self.intensity_target = self.settings.reading_light_brightness / 20.0
|
|
elif self.light_state == "reading":
|
|
self.light_state = "off"
|
|
self.intensity_target = 0
|
|
if self.settings.alarm_playing:
|
|
self.volume_target = 0
|
|
elif self.light_state == "sunrise":
|
|
# allow enabling reading mode when sunrise has not yet reached that level
|
|
if self.intensity_target < self.settings.reading_light_brightness / 20.0:
|
|
self.light_state = "reading"
|
|
self.intensity_target = self.settings.reading_light_brightness / 20.0
|
|
else:
|
|
self.light_state = "off"
|
|
|
|
elif self.light_state == "on":
|
|
self.light_state = "reading"
|
|
self.intensity_target = 0
|
|
|
|
def on_play_button_pressed(self):
|
|
print("play button pressed from view " + self.view)
|
|
|
|
if self.settings.alarm_playing:
|
|
self.volume_target = 0
|
|
else:
|
|
self.play_sound(self.settings.sound_source)
|
|
|
|
def on_alarm_button_pressed(self):
|
|
print("alarm button pressed from view " + self.view)
|
|
|
|
self.settings.alarm_modified = False
|
|
self.set_alarm_timeout_counter = 0
|
|
|
|
if self.view == "set_alarm":
|
|
self.view = "clock"
|
|
self.view_active_since = time.time()
|
|
self.settings.alarm_activated = False
|
|
self.settings.write()
|
|
else:
|
|
if (self.view.startswith("settings_menu")):
|
|
self.settings.write()
|
|
self.view = "set_alarm"
|
|
self.view_active_since = time.time()
|
|
self.settings.alarm_activated = True
|
|
|
|
def on_settings_button_pressed(self):
|
|
print("settings button pressed from view " + self.view)
|
|
if self.view != "settings_menu":
|
|
self.view = "settings_menu"
|
|
self.view_active_since = time.time()
|
|
else:
|
|
self.view = "clock"
|
|
self.view_active_since = time.time()
|
|
self.settings.write()
|
|
print("view updated to " + self.view)
|
|
|
|
def touch_up_function(self, touch):
|
|
self.grabbed = ""
|
|
self.light_button_move_init = []
|
|
|
|
|
|
if (self.view == "set_alarm") and (self.grabbed == "hour" or self.grabbed == "minute"):
|
|
self.set_alarm_timeout_counter = 0
|
|
|
|
super(MyClockWidget, self).on_touch_up(touch)
|
|
|
|
def touch_move_function(self, touch):
|
|
if self.grabbed == "":
|
|
return
|
|
|
|
self.alarm_set_timeout = 0
|
|
|
|
touch_curr = Touch(touch)
|
|
|
|
# Ugly workaround for issue with Kivy and Raspberry Pi 3 + touch screen
|
|
tol = 0.5 # 0.5 is equal to 90 degrees
|
|
inc = 1 # 1 is equal to 180 degrees
|
|
if (self.touch_prev.is_empty == False) and (touch_curr.angle - self.touch_prev.angle >= tol):
|
|
touch_curr.spos[0] = 1 - touch_curr.spos[0]
|
|
touch_curr.spos[1] = 1 - touch_curr.spos[1]
|
|
touch_curr.corrected = True
|
|
while touch_curr.angle - self.touch_prev.angle >= tol:
|
|
touch_curr.angle -= inc
|
|
elif (self.touch_prev.is_empty == False) and (touch_curr.angle - self.touch_prev.angle <= -tol):
|
|
touch_curr.spos[0] = 1 - touch_curr.spos[0]
|
|
touch_curr.spos[1] = 1 - touch_curr.spos[1]
|
|
touch_curr.corrected = True
|
|
while touch_curr.angle - self.touch_prev.angle <= -tol:
|
|
touch_curr.angle += inc
|
|
|
|
self.touch_prev = copy.deepcopy(touch_curr)
|
|
|
|
if self.grabbed == "minute":
|
|
self.settings.alarm_modified = True
|
|
self.set_alarm_timeout_counter = 0
|
|
minute = round(-touch_curr.angle * 30 + 15)
|
|
|
|
while minute < 0:
|
|
minute += 60
|
|
while minute >= 60:
|
|
minute -= 60
|
|
|
|
# Sometimes the hand is 30 minutes ahead / behind the place where the user touches the screen --> correct for this behavior
|
|
if (((minute - self.settings.alarm_time.minute) >= 15) and ((minute - self.settings.alarm_time.minute) <= 45)):
|
|
minute = minute - 30
|
|
elif (((minute - self.settings.alarm_time.minute) <= -15) and ((minute - self.settings.alarm_time.minute) >= -45)):
|
|
minute = minute + 30
|
|
|
|
while minute < 0:
|
|
minute += 60
|
|
while minute >= 60:
|
|
minute -= 60
|
|
|
|
# hour correction
|
|
hour = self.settings.alarm_time.hour
|
|
if self.settings.alarm_time.minute >= 55 and minute <= 5:
|
|
hour += 1
|
|
elif self.settings.alarm_time.minute <= 5 and minute >= 55:
|
|
hour -= 1
|
|
|
|
while hour < 0:
|
|
hour += 24
|
|
while hour >= 24:
|
|
hour -= 24
|
|
|
|
self.settings.alarm_time = datetime.datetime(self.settings.alarm_time.year, \
|
|
self.settings.alarm_time.month, self.settings.alarm_time.day, \
|
|
hour, minute, self.settings.alarm_time.second, 0)
|
|
elif self.grabbed == "hour":
|
|
self.settings.alarm_modified = True
|
|
self.set_alarm_timeout_counter = 0
|
|
hour = round(-touch_curr.angle * 6 + 3)
|
|
|
|
while hour < 0:
|
|
hour += 12
|
|
while hour >= 12:
|
|
hour -= 12
|
|
|
|
# Sometimes the hand is 6 hours ahead / behind the place where the user touches the screen --> correct for this behavior
|
|
if (((hour - self.settings.alarm_time.hour) >= 3) and ((hour - self.settings.alarm_time.hour) <= 9)):
|
|
hour = hour - 6
|
|
if (((hour - self.settings.alarm_time.hour) <= -3) and ((hour - self.settings.alarm_time.hour) >= -9)):
|
|
hour = hour + 6
|
|
|
|
while hour < 0:
|
|
hour += 12
|
|
while hour >= 12:
|
|
hour -= 12
|
|
|
|
if self.settings.alarm_time.hour >= 12:
|
|
hour += 12
|
|
|
|
|
|
# AM / PM correction
|
|
if self.settings.alarm_time.hour == 11 and hour == 0:
|
|
hour = 12
|
|
elif self.settings.alarm_time.hour == 23 and hour == 12:
|
|
hour = 0
|
|
elif self.settings.alarm_time.hour == 0 and hour == 11:
|
|
hour = 23
|
|
elif self.settings.alarm_time.hour == 12 and hour == 23:
|
|
hour = 11
|
|
|
|
minute = self.settings.alarm_time.minute
|
|
self.settings.alarm_time = datetime.datetime(self.settings.alarm_time.year, \
|
|
self.settings.alarm_time.month, self.settings.alarm_time.day, \
|
|
hour, self.settings.alarm_time.minute, self.settings.alarm_time.second, 0)
|
|
|
|
elif self.grabbed == "light_button":
|
|
if len(self.light_button_move_init) == 0:
|
|
self.light_button_move_init = touch_curr.spos
|
|
|
|
|
|
d = touch_curr.spos[0] - self.light_button_move_init[0]
|
|
threshold = 0.05
|
|
|
|
# Ugly workaround for issue with Kivy and Raspberry Pi 3 + touch screen: mirror d if position is on other side
|
|
if self.light_button_move_init[0] > 0.5:
|
|
d = -d
|
|
|
|
if d > 0.05:
|
|
# move to the right: set light to wake up level
|
|
self.light_state = "on"
|
|
elif d < -0.05:
|
|
# move to the left: set light off
|
|
self.light_state = "off"
|
|
|
|
super(MyClockWidget, self).on_touch_move(touch)
|
|
|
|
def touch_down_function(self, touch):
|
|
t = self.settings.alarm_time
|
|
hands = self.ids["hands"]
|
|
minutes_hand = self.position_on_clock(t.minute/60+t.second/3600, length=0.40*hands.size[0])
|
|
hours_hand = self.position_on_clock(t.hour/12 + t.minute/720, length=0.35*hands.size[0])
|
|
|
|
if (0.02 <= touch.spos[0] <= 0.28) and (0.82 <= touch.spos[1] <= 0.98):
|
|
if self.grabbed == "":
|
|
self.grabbed = "light_button"
|
|
self.on_light_button_pressed()
|
|
elif (0.02 <= touch.spos[0] <= 0.18) and (0.02 <= touch.spos[1] <= 0.18):
|
|
self.on_play_button_pressed()
|
|
elif (0.82 <= touch.spos[0] <= 0.98) and (0.02 <= touch.spos[1] <= 0.18):
|
|
self.on_alarm_button_pressed()
|
|
elif (0.82 <= touch.spos[0] <= 0.98) and (0.82 <= touch.spos[1] <= 0.98):
|
|
self.on_settings_button_pressed()
|
|
elif self.view == "set_alarm":
|
|
self.set_alarm_timeout_counter = 0
|
|
if self.grabbed == "":
|
|
if (minutes_hand.x - 0.1 * self.size[0] <= touch.pos[0] <= minutes_hand.x + 0.1 * self.size[0]) and \
|
|
(minutes_hand.y - 0.1 * self.size[1] <= touch.pos[1] <= minutes_hand.y + 0.1 * self.size[1]):
|
|
self.grabbed = "minute"
|
|
self.touch_prev.clear()
|
|
elif (hours_hand.x - 0.1 * self.size[0] <= touch.pos[0] <= hours_hand.x + 0.1 * self.size[0]) and \
|
|
(hours_hand.y - 0.1 * self.size[1] <= touch.pos[1] <= hours_hand.y + 0.1 * self.size[1]):
|
|
self.grabbed = "hour"
|
|
self.touch_prev.clear()
|
|
else:
|
|
self.grabbed = ""
|
|
elif self.view == "settings_menu":
|
|
pass
|
|
elif self.view == "settings_menu_wake_up_sound":
|
|
pass
|
|
elif self.view == "settings_menu_theme_select":
|
|
pass
|
|
elif self.view == "clock":
|
|
self.volume_target = 0
|
|
|
|
super(MyClockWidget, self).on_touch_down(touch)
|
|
|
|
def on_touch_down(self, touch, after=False):
|
|
t = time.time()
|
|
|
|
if t - self.view_active_since <= self.time_to_ignore_inputs_after_view_change:
|
|
return True
|
|
|
|
"""
|
|
if self.touch_down_event_prev is None:
|
|
print("touch down at " + str(t) + " on " + str(touch.spos) + ", after: " + str(after) + ", prev event: None")
|
|
else:
|
|
print("touch down at " + str(t) + " on " + str(touch.spos) + ", after: " + str(after) + ", prev event at " + str(self.touch_down_event_prev.time) + " on " + str(self.touch_down_event_prev.touch.spos))
|
|
"""
|
|
|
|
if after:
|
|
self.touch_down_event_curr = TouchEvent(touch)
|
|
return True
|
|
else:
|
|
Clock.schedule_once(lambda dt: self.on_touch_down(touch, True))
|
|
return super(MyClockWidget, self).on_touch_down(touch)
|
|
|
|
def on_touch_move(self, touch, after=False):
|
|
t = time.time()
|
|
|
|
if t - self.view_active_since <= self.time_to_ignore_inputs_after_view_change:
|
|
return True
|
|
|
|
"""
|
|
if self.touch_move_event_prev is None:
|
|
print("touch move at " + str(t) + " on " + str(touch.spos) + ", after: " + str(after) + ", prev event: None")
|
|
else:
|
|
print("touch move at " + str(t) + " on " + str(touch.spos) + ", after: " + str(after) + ", prev event at " + str(self.touch_move_event_prev.time) + " on " + str(self.touch_move_event_prev.touch.spos))
|
|
"""
|
|
|
|
if after:
|
|
# Do not delay processing of move events
|
|
self.touch_move_function(touch)
|
|
return True
|
|
else:
|
|
Clock.schedule_once(lambda dt: self.on_touch_move(touch, True))
|
|
return super(MyClockWidget, self).on_touch_move(touch)
|
|
|
|
def on_touch_up(self, touch, after=False):
|
|
t = time.time()
|
|
|
|
if t - self.view_active_since <= self.time_to_ignore_inputs_after_view_change:
|
|
return True
|
|
|
|
"""
|
|
if self.touch_up_event_prev is None:
|
|
print("touch up at " + str(t) + " on " + str(touch.spos) + ", after: " + str(after) + ", prev event: None")
|
|
else:
|
|
print("touch up at " + str(t) + " on " + str(touch.spos) + ", after: " + str(after) + ", prev event at " + str(self.touch_up_event_prev.time) + " on " + str(self.touch_up_event_prev.touch.spos))
|
|
"""
|
|
|
|
if after:
|
|
self.touch_up_event_curr = TouchEvent(touch)
|
|
return True
|
|
else:
|
|
Clock.schedule_once(lambda dt: self.on_touch_up(touch, True))
|
|
return super(MyClockWidget, self).on_touch_up(touch)
|
|
|
|
class MyApp(App):
|
|
update_rate = 60.0
|
|
|
|
def build(self):
|
|
clock_widget = MyClockWidget()
|
|
|
|
clock_widget.add_wake_up_sounds()
|
|
clock_widget.add_themes()
|
|
|
|
update_rate = App.get_running_app().update_rate
|
|
# update initially, just after construction of the widget is complete
|
|
Clock.schedule_once(clock_widget.update_display, 0)
|
|
# then update at update_rate times per second
|
|
Clock.schedule_interval(clock_widget.update_display, 1.0/update_rate)
|
|
|
|
Clock.schedule_once(clock_widget.get_air_quality, 0)
|
|
|
|
t = datetime.datetime.now()
|
|
delay = 58 - (t.second + t.microsecond / 1000000)
|
|
if delay < 0:
|
|
delay = delay + 60
|
|
Clock.schedule_once(clock_widget.sync_air_quality, delay)
|
|
|
|
if is_arm():
|
|
Window.borderless = True
|
|
|
|
# Volume is in 0-1.0 range
|
|
old_vol = clock_widget.mixer.getvolume()
|
|
clock_widget.volume_target = clock_widget.settings.wake_up_volume / 20.0
|
|
new_vol = clock_widget.mixer.getvolume()
|
|
print("HW volume changed from " + str(old_vol) + " to " + str(new_vol))
|
|
|
|
clock_widget.apply_settings()
|
|
return clock_widget
|
|
|
|
def except_hook(type, value, tb):
|
|
if is_arm():
|
|
pixels.fill((0, 0, 0, 0))
|
|
pixels.show()
|
|
backlight.brightness = 50
|
|
return
|
|
|
|
if __name__ == '__main__':
|
|
if is_arm():
|
|
sys.excepthook = except_hook
|
|
MyApp().run()
|