--[[-- Plugin for setting screen warmth based on the sun position and/or a time schedule @module koplugin.autowarmth --]]-- local ConfirmBox = require("ui/widget/confirmbox") local Device = require("device") local DateTimeWidget = require("ui/widget/datetimewidget") local DoubleSpinWidget = require("/ui/widget/doublespinwidget") local DeviceListener = require("device/devicelistener") local Dispatcher = require("dispatcher") local Event = require("ui/event") local FFIUtil = require("ffi/util") local Font = require("ui/font") local InfoMessage = require("ui/widget/infomessage") local InputDialog = require("ui/widget/inputdialog") local Notification = require("ui/widget/notification") local SpinWidget = require("ui/widget/spinwidget") local SunTime = require("suntime") local TextWidget = require("ui/widget/textwidget") local UIManager = require("ui/uimanager") local WidgetContainer = require("ui/widget/container/widgetcontainer") local logger = require("logger") local _ = require("gettext") local C_ = _.pgettext local Powerd = Device.powerd local T = FFIUtil.template local Screen = require("device").screen local datetime = require("datetime") local activate_sun = 1 local activate_schedule = 2 local activate_closer_noon = 3 local activate_closer_midnight = 4 local midnight_index = 11 local device_max_warmth = Device:hasNaturalLight() and Powerd.fl_warmth_max or 100 local device_warmth_fit_scale = device_max_warmth * (1/100) local function frac(x) return x - math.floor(x) end local AutoWarmth = WidgetContainer:extend{ name = "autowarmth", sched_times_s = nil, -- array sched_warmths = nil, -- array -- Static member that shall survive reloading of the plugin but not a restart fl_user_toggle = false, -- true/false if someone (AutoWarmth, gesture ...) has toggled the frontlight fl_turned_off = false, -- the frontlight toggle state } function AutoWarmth:init() self:onDispatcherRegisterActions() self.ui.menu:registerToMainMenu(self) self.easy_mode = G_reader_settings:nilOrTrue("autowarmth_easy_mode") self.activate = G_reader_settings:readSetting("autowarmth_activate") or 0 self.location = G_reader_settings:readSetting("autowarmth_location") or "Geysir" self.latitude = G_reader_settings:readSetting("autowarmth_latitude") or 64.31 --great Geysir in Iceland self.longitude = G_reader_settings:readSetting("autowarmth_longitude") or -20.30 self.altitude = G_reader_settings:readSetting("autowarmth_altitude") or 200 self.timezone = G_reader_settings:readSetting("autowarmth_timezone") or 0 self.scheduler_times = G_reader_settings:readSetting("autowarmth_scheduler_times") or {0.0, 5.5, 6.0, 6.5, 7.0, 13.0, 21.5, 22.0, 22.5, 23.0, 24.0} self.warmth = G_reader_settings:readSetting("autowarmth_warmth") or { 90, 90, 80, 60, 20, 20, 20, 60, 80, 90, 90} self.fl_off_during_day = G_reader_settings:readSetting("autowarmth_fl_off_during_day") self.fl_off_during_day_offset_s = G_reader_settings:readSetting("autowarmth_fl_off_during_day_offset_s", 0) if self.easy_mode then self.fl_off_during_day_offset_s = 0 end self.control_warmth = G_reader_settings:nilOrTrue("autowarmth_control_warmth") self.control_nightmode = G_reader_settings:nilOrTrue("autowarmth_control_nightmode") if not Device:hasNaturalLight() then self.control_nightmode = true elseif not self.control_warmth and not self.control_nightmode then logger.dbg("AutoWarmth: autowarmth_control_warmth and autowarmth_control_nightmode are both false, set them to true") self.control_warmth = true self.control_nightmode = true end -- Fix entries not in ascending order (only happens by manual editing of settings.reader.lua) for i = 1, #self.scheduler_times - 1 do if self.scheduler_times[i] > self.scheduler_times[i + 1] then self.scheduler_times[i + 1] = self.scheduler_times[i] logger.warn("AutoWarmth: scheduling times fixed.") end end -- schedule recalculation shortly afer midnight self:scheduleMidnightUpdate() end function AutoWarmth:onDispatcherRegisterActions() Dispatcher:registerAction("show_ephemeris", {category="none", event="ShowEphemeris", title=_("Show ephemeris"), general=true}) Dispatcher:registerAction("auto_warmth_off", {category="none", event="AutoWarmthOff", title=_("Auto warmth off"), screen=true}) Dispatcher:registerAction("auto_warmth_cycle_trough", {category="none", event="AutoWarmthMode", title=_("Auto warmth cycle through modes"), screen=true}) end function AutoWarmth:onShowEphemeris() self:showTimesInfo(_("Information about the sun in"), true, activate_sun, false) end function AutoWarmth:onAutoWarmthOff() self.activate = 0 G_reader_settings:saveSetting("autowarmth_activate", self.activate) Notification:notify(_("Auto warmth turned off")) self:scheduleMidnightUpdate() end function AutoWarmth:onAutoWarmthMode() if self.activate > 0 then self.activate = self.activate - 1 else self.activate = activate_closer_midnight end local notify_text if self.activate == 0 then notify_text = _("Auto warmth turned off") elseif self.activate == activate_sun then notify_text = _("Auto warmth use sun position") elseif self.activate == activate_schedule then notify_text = _("Auto warmth use schedule") elseif self.activate == activate_closer_midnight then notify_text = _("Auto warmth use whatever is closer to midnight") elseif self.activate == activate_closer_noon then notify_text = _("Auto warmth use whatever is closer to noon") end G_reader_settings:saveSetting("autowarmth_activate", self.activate) Notification:notify(notify_text) self:scheduleMidnightUpdate() end function AutoWarmth:_onResume() logger.dbg("AutoWarmth: onResume", AutoWarmth.fl_turned_off, AutoWarmth.fl_user_toggle) local resume_date = os.date("*t") if self.fl_off_during_day then -- We handle the frontlight state ourself. Powerd.fl_was_on = false end -- check if resume and suspend are done on the same day if resume_date.day == SunTime.date.day and resume_date.month == SunTime.date.month and resume_date.year == SunTime.date.year then local now_s = SunTime:getTimeInSec(resume_date) self.sched_warmth_index = self.sched_warmth_index - 1 -- scheduleNextWarmth will check this self:scheduleNextWarmthChange(true) self:scheduleToggleFrontlight(now_s) -- reset user toggles at sun set or sun rise if AutoWarmth.fl_user_toggle then self:setFrontlight(not AutoWarmth.fl_turned_off, true) -- keep user toggle state else self:toggleFrontlight(now_s) -- no user toggle end -- Reschedule 1sec after midnight UIManager:scheduleIn(24*3600 + 1 - now_s, self.scheduleMidnightUpdate, self) else self:scheduleMidnightUpdate(true) -- resume is on the other day, do all calcs again end end function AutoWarmth:_onSuspend() logger.dbg("AutoWarmth: onSuspend") UIManager:unschedule(self.scheduleMidnightUpdate) UIManager:unschedule(self.setWarmth) UIManager:unschedule(self.setFrontlight) UIManager:unschedule(self.scheduleNextWarmthChange) end function AutoWarmth:_onToggleNightMode() logger.dbg("AutoWarmth: onToggleNightMode") if not self.hide_nightmode_warning then local RadioButtonWidget = require("ui/widget/radiobuttonwidget") local radio_buttons = { {{ text = _("Show this warning again"), provider = function() end }}, {{ text = _("Hide the warning until the next book is opened"), provider = function() self.hide_nightmode_warning = true end, }}, {{ text = _("Disable AutoWarmth's nightmode control"), provider = function() self.control_nightmode = false G_reader_settings:makeFalse("autowarmth_control_nightmode") self:scheduleMidnightUpdate(true) end, }}, } UIManager:show(RadioButtonWidget:new{ title_text = _("Night mode changed"), info_text = _("The AutoWarmth plugin might change it again."), width_factor = 0.9, radio_buttons = radio_buttons, callback = function(radio) radio.provider() end, }) end end function AutoWarmth:_onToggleFrontlight() logger.dbg("AutoWarmth: onToggleFrontlight") AutoWarmth.fl_user_toggle = true AutoWarmth.fl_turned_off = not AutoWarmth.fl_turned_off end function AutoWarmth:setEventHandlers() self.onResume = self._onResume self.onSuspend = self._onSuspend if self.control_nightmode then self.onToggleNightMode = self._onToggleNightMode self.onSetNightMode = self._onToggleNightMode else self.onToggleNightMode = nil self.onSetNightMode = nil end if self.fl_off_during_day then self.onToggleFrontlight = self._onToggleFrontlight end end function AutoWarmth:clearEventHandlers() self.onResume = nil self.onSuspend = nil self.onToggleNightMode = nil self.onSetNightMode = nil self.onToggleFrontlight = nil end -- from_resume ... true if called from onResume function AutoWarmth:scheduleMidnightUpdate(from_resume) logger.dbg("AutoWarmth: scheduleMidnightUpdate") -- first unschedule all old functions UIManager:unschedule(self.scheduleMidnightUpdate) UIManager:unschedule(self.setWarmth) UIManager:unschedule(self.setFrontlight) -- Calculate current timezone of device, which might change due to daylight saving. local timezone = SunTime:getTimezoneOffset() if timezone ~= self.timezone then G_reader_settings:saveSetting("autowarmth_timezone", self.timezone) self.timezone = timezone end SunTime:setPosition(self.location, self.latitude, self.longitude, self.timezone, self.altitude, true) SunTime:setAdvanced() SunTime:setDate() -- today SunTime:calculateTimes() -- calculates times in hours self.sched_times_s = {} self.sched_warmths = {} local function prepareSchedule(times_h, index1, index2) local time1_h = times_h[index1] if not time1_h then return end local time1_s = SunTime:getTimeInSec(time1_h) self.sched_times_s[#self.sched_times_s + 1] = time1_s self.sched_warmths[#self.sched_warmths + 1] = self.warmth[index1] local time2_h = times_h[index2] if not time2_h then return end -- to near to the pole local warmth_diff = math.min(self.warmth[index2], 100) - math.min(self.warmth[index1], 100) local time_diff_s = SunTime:getTimeInSec(time2_h) - time1_s if warmth_diff ~= 0 and time_diff_s > 0 then local delta_t = time_diff_s / math.abs(warmth_diff) -- cannot be inf, no problem local delta_w = warmth_diff > 0 and 1 or -1 for i = 1, math.abs(warmth_diff) - 1 do local next_warmth = math.min(self.warmth[index1], 100) + delta_w * i -- only apply warmth for steps the hardware has (e.g. Tolino has 0-10 hw steps -- which map to warmth 0, 10, 20, 30 ... 100) if frac(next_warmth * device_warmth_fit_scale) == 0 then table.insert(self.sched_times_s, time1_s + delta_t * i) table.insert(self.sched_warmths, next_warmth) end end end end if self.activate == activate_sun then self.current_times_h = {unpack(SunTime.times, 1, midnight_index)} elseif self.activate == activate_schedule then self.current_times_h = {unpack(self.scheduler_times, 1, midnight_index)} else self.current_times_h = {unpack(SunTime.times, 1, midnight_index)} if self.activate == activate_closer_noon then for i = 1, midnight_index do if not self.current_times_h[i] then self.current_times_h[i] = self.scheduler_times[i] elseif self.scheduler_times[i] and math.abs(self.current_times_h[i]%24 - 12) > math.abs(self.scheduler_times[i]%24 - 12) then self.current_times_h[i] = self.scheduler_times[i] end end else -- activate_closer_midnight for i = 1, midnight_index do if not self.current_times_h[i] then self.current_times_h[i] = self.scheduler_times[i] elseif self.scheduler_times[i] and math.abs(self.current_times_h[i]%24 - 12) < math.abs(self.scheduler_times[i]%24 - 12) then self.current_times_h[i] = self.scheduler_times[i] end end end end if self.easy_mode then self.current_times_h[1] = nil -- Solar midnight prev. day self.current_times_h[2] = nil -- Astronomical dawn self.current_times_h[3] = nil -- Nautical dawn self.current_times_h[6] = nil -- Solar noon self.current_times_h[9] = nil -- Nautical dusk self.current_times_h[10] = nil -- Astronomical dusk self.current_times_h[11] = nil -- Solar midnight end -- here are dragons local prev_index = 1 -- find first valid entry (~= nil) while not self.current_times_h[prev_index] and prev_index <= midnight_index do prev_index = prev_index + 1 end local next_index while prev_index <= midnight_index do next_index = prev_index + 1 -- find next valid entry (~= nil) while not self.current_times_h[next_index] and next_index <= midnight_index do next_index = next_index + 1 end -- now we have two valid indices: prev_index and next_index prepareSchedule(self.current_times_h, prev_index, next_index) -- move on prev_index to the next valid entry prev_index = next_index end local now_s = SunTime:getTimeInSec() -- Reschedule 1sec after midnight UIManager:scheduleIn(24*3600 + 1 - now_s, self.scheduleMidnightUpdate, self) -- set event handlers if self.activate ~= 0 then self:setEventHandlers() -- Schedule the first warmth change self.sched_warmth_index = 1 self:scheduleNextWarmthChange(from_resume) self:scheduleToggleFrontlight(now_s) -- reset user toggles at sun set or sun rise self:toggleFrontlight(now_s) else self:clearEventHandlers() end end function AutoWarmth:scheduleToggleFrontlight(now_s) logger.dbg("AutoWarmth: scheduleToggleFrontlight") UIManager:unschedule(self.setFrontlight) if not self.fl_off_during_day then return end -- Reset user fl toggles at sunset or sunrise with offset, as `scheduleNextWarmthChange` gets called only -- on scheduled warmth changes. local sunset_in_s = self.current_times_h[7] * 3600 - self.fl_off_during_day_offset_s - now_s if sunset_in_s >= 0 then -- first check if we are before sunset UIManager:scheduleIn(sunset_in_s, self.setFrontlight, self, true, false) local sunrise_in_s = self.current_times_h[5] * 3600 + self.fl_off_during_day_offset_s - now_s if sunrise_in_s >= 0 then -- second check if we are before sunrise UIManager:scheduleIn(sunrise_in_s, self.setFrontlight, self, false, false) end end end -- turns frontlight on or off and notice AutoDim on turning it off -- enable ... true to enable frontlight, false/nil to disable it function AutoWarmth:setFrontlight(enable, keep_user_toggle) logger.dbg("AutoWarmth: setFrontlight", enable, keep_user_toggle) if not keep_user_toggle then AutoWarmth.fl_user_toggle = false end if not self.fl_off_during_day then return end if enable then Powerd:turnOnFrontlight() AutoWarmth.fl_turned_off = false else Powerd:turnOffFrontlight() AutoWarmth.fl_turned_off = true UIManager:broadcastEvent(Event:new("FrontlightTurnedOff")) -- used e.g. in AutoDim end end -- toggles Frontlight on or off, depending on `now_s` function AutoWarmth:toggleFrontlight(now_s) logger.dbg("AutoWarmth: toggleFrontlight", now_s) if not self.fl_off_during_day then return end now_s = now_s or SunTime:getTimeInSec() local sunrise_in_s = self.current_times_h[5] * 3600 + self.fl_off_during_day_offset_s - now_s local sunset_in_s = self.current_times_h[7] * 3600 - self.fl_off_during_day_offset_s - now_s self:setFrontlight(sunrise_in_s > 0 or sunset_in_s < 0) end -- schedules the next warmth change -- search_pos ... start searching from that index -- from_resume ... true if first call after resume function AutoWarmth:scheduleNextWarmthChange(from_resume) logger.dbg("AutoWarmth: scheduleNextWarmthChange") UIManager:unschedule(self.scheduleNextWarmthChange) if self.activate == 0 or #self.sched_warmths == 0 then return end if self.sched_warmth_index < 1 then self.sched_warmth_index = 1 end -- `warmth_now` is the value which should be applied now. -- `warmth_in_1p5_s` is valid `1.5` seconds after now for resume on some devices (KA1) -- Most of the times this will be the same as `warmth_now`. -- We need both, as we could have a very rapid change in warmth (depending on user settings) -- or by chance a change in warmth very shortly after (a few ms) resume time. -- Use the last (== solar midnight) warmth value, so that we have a valid value when resuming -- before 24:00:00 but after true midnight. OK, this value is actually not quite the right one, -- as it is calculated for the current day (and not the previous one), but this is for a corner case -- and the error is small. local warmth_now = self.sched_warmths[self.sched_warmth_index] local warmth_in_1p5_s = warmth_now local now_s = SunTime:getTimeInSec() while self.sched_warmth_index <= #self.sched_warmths do if self.sched_times_s[self.sched_warmth_index] > now_s then break end -- update warmth_now warmth_now = self.sched_warmths[self.sched_warmth_index] local j = self.sched_warmth_index if from_resume then -- update warmth_in_1p5_s while j <= #self.sched_warmths and self.sched_times_s[j] <= now_s + 1.5 do -- Most times only one iteration through this loop warmth_in_1p5_s = self.sched_warmths[j] j = j + 1 end end -- It might be possible that self.sched_warmth_index gets > #self.sched_warmths self.sched_warmth_index = self.sched_warmth_index + 1 end -- update current warmth immediately self:setWarmth(warmth_now, from_resume) -- force warmth, when from_resume if self.sched_warmth_index <= #self.sched_warmths then -- and only then, schedule next warmth change local next_sched_time_s = self.sched_times_s[self.sched_warmth_index] - now_s UIManager:scheduleIn(next_sched_time_s, self.scheduleNextWarmthChange, self, false) -- no force warmth end if from_resume then -- On some strange devices like KA1 setWarmth doesn't work right after a resume so -- schedule setting of another valid warmth (=`warmth_in_1p5_s`) again (one time) in 1.5s. -- On sane devices this schedule does no harm. -- see https://github.com/koreader/koreader/issues/8363 UIManager:scheduleIn(1.5, self.setWarmth, self, warmth_in_1p5_s, true) -- force warmth one time end end -- Set warmth and schedule the next warmth change function AutoWarmth:setWarmth(val, force_warmth) if val then if self.control_nightmode then DeviceListener:onSetNightMode(val > 100) end if self.control_warmth and Device:hasNaturalLight() then val = math.min(val, 100) -- "mask" night mode Powerd:setWarmth(val, force_warmth) end end end function AutoWarmth:hoursToClock(hours) if hours then hours = hours % 24 * 3600 + 0.01 -- round up, due to reduced precision in settings.reader.lua end return datetime.secondsToClock(hours, self.easy_mode) end function AutoWarmth:addToMainMenu(menu_items) menu_items.autowarmth = { text = Device:hasNaturalLight() and _("Auto warmth and night mode") or _("Auto night mode"), checked_func = function() return self.activate ~= 0 end, sub_item_table = self:getSubMenuItems(), } end local function tidy_menu(menu, request) for i = #menu, 1, -1 do if menu[i].mode ~=nil then if menu[i].mode ~= request then table.remove(menu, i) else menu[i].mode = nil end end end return menu end function AutoWarmth:updateItems(touchmenu_instance) touchmenu_instance:updateItems() UIManager:broadcastEvent(Event:new("UpdateFooter", self.view and self.view.footer_visible or false)) end local about_text = _([[Set the frontlight warmth (if available) and night mode based on a time schedule or the sun's position. There are three types of twilight: • Civil: You can read a newspaper • Nautical: You can see the first stars • Astronomical: It is really dark Custom warmth values can be set for every kind of twilight and sunrise, noon, sunset and midnight. The screen warmth is continuously adjusted to the current time. To use the sun's position, a geographical location must be entered. The calculations are very precise, with a deviation less than minute and a half.]]) function AutoWarmth:getSubMenuItems() return { { text = Device:hasNaturalLight() and _("About auto warmth and night mode") or _("About auto night mode"), callback = function() UIManager:show(InfoMessage:new{ text = about_text, width = math.floor(Screen:getWidth() * 0.9), }) end, keep_menu_open = true, separator = true, }, { text = _("Activate"), checked_func = function() return self.activate ~= 0 end, sub_item_table = self:getActivateMenu(), }, { text = _("Expert mode"), checked_func = function() return not self.easy_mode end, help_text = _("In the expert mode, different types of twilight can be used in addition to civil twilight."), callback = function(touchmenu_instance) self.easy_mode = not self.easy_mode G_reader_settings:saveSetting("autowarmth_easy_mode", self.easy_mode) if self.easy_mode then self.fl_off_during_day_offset_s = 0 -- don't store that value else self.fl_off_during_day_offset_s = G_reader_settings:readSetting("autowarmth_fl_off_during_day_offset_s", 0) end self:scheduleMidnightUpdate() if touchmenu_instance then touchmenu_instance.item_table = self:getSubMenuItems() self:updateItems(touchmenu_instance) end end, keep_menu_open = true, }, { text = _("Location settings"), sub_item_table = self:getLocationMenu(), }, { text = _("Fixed schedule settings"), enabled_func = function() return self.activate ~= activate_sun and self.activate ~= 0 end, sub_item_table = self:getScheduleMenu(), }, { enabled_func = function() return self.activate ~= 0 end, text = Device:hasNaturalLight() and _("Warmth and night mode settings") or _("Night mode settings"), sub_item_table = self:getWarmthMenu(), }, self:getFlOffDuringDayMenu(), self:getTimesMenu(_("Currently active parameters")), self:getTimesMenu(_("Sun position information for"), true, activate_sun), self:getTimesMenu(_("Fixed schedule information"), false, activate_schedule), } end function AutoWarmth:getFlOffDuringDayMenu() return { checked_func = function() return self.fl_off_during_day end, text_func = function() if self.fl_off_during_day and self.fl_off_during_day_offset_s ~= 0 and not self.easy_mode then return T(_("Frontlight off during day: %1 min offset"), math.floor(self.fl_off_during_day_offset_s/60)) else return _("Frontlight off during day") end end, callback = function(touchmenu_instance) if self.easy_mode then self.fl_off_during_day = not self.fl_off_during_day G_reader_settings:saveSetting("autowarmth_fl_off_during_day", self.fl_off_during_day) self:scheduleMidnightUpdate() self:toggleFrontlight() else -- hard limit offset to 15 min after sunset and 30 mins before sunset; sunrise vice versa UIManager:show(SpinWidget:new{ title_text = _("Offset for frontlight off"), info_text = _[[At this time the frontlight will be turned • off after sunrise and • on before sunset.]], ok_always_enabled = true, -- read the saved setting, as this get's not overwritten by toggling easy_mode value = G_reader_settings:readSetting("autowarmth_fl_off_during_day_offset_s", 0) * (1/60), value_min = -15, value_max = 30, wrap = false, value_step = 5, value_hold_step = 10, unit = "min", ok_text = _("Set"), callback = function(spin) self.fl_off_during_day_offset_s = spin.value * 60 G_reader_settings:saveSetting("autowarmth_fl_off_during_day_offset_s", self.fl_off_during_day_offset_s) self.fl_off_during_day = true G_reader_settings:saveSetting("autowarmth_fl_off_during_day", true) self:scheduleMidnightUpdate() self:toggleFrontlight() if touchmenu_instance then self:updateItems(touchmenu_instance) end end, extra_text = _("Disable"), extra_callback = function() self.fl_off_during_day = nil G_reader_settings:saveSetting("autowarmth_fl_off_during_day", nil) self:scheduleMidnightUpdate() self:toggleFrontlight() if touchmenu_instance then self:updateItems(touchmenu_instance) end end, }) end if touchmenu_instance then self:updateItems(touchmenu_instance) end end, hold_callback = function() UIManager:show(InfoMessage:new{ text = _([[This feature turns your front light on at sunset and off at sunrise according to the “Current Active Parameters” in this plugin. You can override this change by manually turning the front light on/off. At the next sunrise/sunset, AutoWarmth will toggle again if needed. For cloudy autumn days, the switch-on/off time can be shifted by an offset.]]), }) end, keep_menu_open = true, separator = true, } end function AutoWarmth:getActivateMenu() local function getActivateMenuEntry(text, help_text, activator) return { text = text, help_text = help_text, checked_func = function() return self.activate == activator end, callback = function() self.activate = self.activate ~= activator and activator or 0 G_reader_settings:saveSetting("autowarmth_activate", self.activate) self:scheduleMidnightUpdate() UIManager:broadcastEvent(Event:new("UpdateFooter", self.view and self.view.footer_visible or false)) end, } end return { getActivateMenuEntry(_("According to the sun's position"), _("Only use the times calculated from the position of the sun."), activate_sun), getActivateMenuEntry(_("According to the fixed schedule"), _("Only use the times from the fixed schedule."), activate_schedule), getActivateMenuEntry(_("Whatever is closer to noon"), _("Use the times from the sun position or schedule that are closer to noon."), activate_closer_noon), getActivateMenuEntry(_("Whatever is closer to midnight"), _("Use the times from the sun position or schedule that are closer to midnight."), activate_closer_midnight), } end function AutoWarmth:getLocationMenu() return {{ text_func = function() if self.location ~= "" then return T(_("Location: %1"), self.location) else return _("Location") end end, callback = function(touchmenu_instance) local location_name_dialog location_name_dialog = InputDialog:new{ title = _("Location name"), input = self.location, buttons = { { { text = _("Cancel"), id = "close", callback = function() UIManager:close(location_name_dialog) end, }, { text = _("OK"), callback = function() self.location = location_name_dialog:getInputText() G_reader_settings:saveSetting("autowarmth_location", self.location) UIManager:close(location_name_dialog) if touchmenu_instance then self:updateItems(touchmenu_instance) end end, }, } }, } UIManager:show(location_name_dialog) location_name_dialog:onShowKeyboard() end, keep_menu_open = true, }, { text_func = function() return T(_("Coordinates: (%1°, %2°)"), self.latitude, self.longitude) end, callback = function(touchmenu_instance) local location_widget = DoubleSpinWidget:new{ title_text = _("Set location"), info_text = _("Enter decimal degrees, northern hemisphere and eastern length are '+'."), left_text = _("Latitude"), left_value = self.latitude, left_min = -90, left_max = 90, left_step = 0.1, left_hold_step = 5, left_precision = "%0.2f", right_text = _("Longitude"), right_value = self.longitude, right_min = -180, right_max = 180, right_step = 0.1, right_hold_step = 5, right_precision = "%0.2f", unit = "°", callback = function(lat, long) self.latitude = lat self.longitude = long self.timezone = SunTime:getTimezoneOffset() -- use timezone of device G_reader_settings:saveSetting("autowarmth_latitude", self.latitude) G_reader_settings:saveSetting("autowarmth_longitude", self.longitude) G_reader_settings:saveSetting("autowarmth_timezone", self.timezone) self:scheduleMidnightUpdate() if touchmenu_instance then self:updateItems(touchmenu_instance) end end, } UIManager:show(location_widget) end, keep_menu_open = true, }, { text_func = function() return T(_("Altitude: %1 m"), self.altitude) end, callback = function(touchmenu_instance) UIManager:show(SpinWidget:new{ title_text = _("Altitude"), info_text = _("Enter the altitude in meters above sea level."), value = self.altitude, value_min = -100, value_max = 15000, -- intercontinental flight wrap = false, value_step = 10, value_hold_step = 100, unit = C_("Length", "m"), ok_text = _("Set"), callback = function(spin) self.altitude = spin.value G_reader_settings:saveSetting("autowarmth_altitude", self.altitude) self:scheduleMidnightUpdate() if touchmenu_instance then self:updateItems(touchmenu_instance) end end, extra_text = _("Default"), extra_callback = function() self.altitude = 200 G_reader_settings:saveSetting("autowarmth_altitude", self.altitude) self:scheduleMidnightUpdate() if touchmenu_instance then self:updateItems(touchmenu_instance) end end, }) end, keep_menu_open = true, }} end function AutoWarmth:getScheduleMenu() local function store_times(touchmenu_instance, new_time, num) self.scheduler_times[num] = new_time G_reader_settings:saveSetting("autowarmth_scheduler_times", self.scheduler_times) self:scheduleMidnightUpdate() if touchmenu_instance then self:updateItems(touchmenu_instance) end end -- mode == nil ... show always -- == true ... easy mode -- == false ... expert mode local function getScheduleMenuEntry(text, num, mode) return { mode = mode, text_func = function() return T(_("%1: %2"), text, self:hoursToClock(self.scheduler_times[num])) end, checked_func = function() return self.scheduler_times[num] ~= nil end, callback = function(touchmenu_instance) local hh = 12 local mm = 0 if self.scheduler_times[num] then hh = math.floor(self.scheduler_times[num]) mm = math.floor(frac(self.scheduler_times[num]) * 60 + 0.5) end UIManager:show(DateTimeWidget:new{ title_text = _("Set time"), info_text = _("Enter time in hours and minutes."), hour = hh, hour_min = -1, hour_max = 24, min = mm, ok_text = _("Set time"), callback = function(time) local new_time = time.hour + time.min * (1/60) local function get_valid_time(n, dir) for i = n+dir, dir > 0 and midnight_index or 1, dir do if self.scheduler_times[i] then return self.scheduler_times[i] end end return dir > 0 and 0 or 26 end if num > 1 and new_time < get_valid_time(num, -1) then UIManager:show(ConfirmBox:new{ text = _("This time is before the previous time.\nAdjust the previous time?"), ok_callback = function() for i = num - 1, 1, -1 do if self.scheduler_times[i] then if new_time < self.scheduler_times[i] then self.scheduler_times[i] = new_time else break end end end store_times(touchmenu_instance, new_time, num) end, }) elseif num < midnight_index and new_time > get_valid_time(num, 1) then UIManager:show(ConfirmBox:new{ text = _("This time is after the subsequent time.\nAdjust the subsequent time?"), ok_callback = function() for i = num + 1, midnight_index do if self.scheduler_times[i] then if new_time > self.scheduler_times[i] then self.scheduler_times[i] = new_time else break end end end store_times(touchmenu_instance, new_time, num) end, }) else store_times(touchmenu_instance, new_time, num) end end, extra_text = _("Invalidate"), extra_callback = function() store_times(touchmenu_instance, nil, num) end, }) end, keep_menu_open = true, } end local retval = { getScheduleMenuEntry(_("Solar midnight (previous day)"), 1, false), getScheduleMenuEntry(_("Astronomical dawn"), 2, false), getScheduleMenuEntry(_("Nautical dawn"), 3, false), getScheduleMenuEntry(_("Civil dawn"), 4), getScheduleMenuEntry(_("Sunrise"), 5), getScheduleMenuEntry(_("Solar noon"), 6, false), getScheduleMenuEntry(_("Sunset"), 7), getScheduleMenuEntry(_("Civil dusk"), 8), getScheduleMenuEntry(_("Nautical dusk"), 9, false), getScheduleMenuEntry(_("Astronomical dusk"), 10, false), getScheduleMenuEntry(_("Solar midnight"), 11, false), } return tidy_menu(retval, self.easy_mode) end function AutoWarmth:getWarmthMenu() -- mode == nil ... show always -- == true ... easy mode -- == false ... expert mode local function getWarmthMenuEntry(text, num, mode) return { mode = mode, text_func = function() if Device:hasNaturalLight() and self.control_warmth then if self.warmth[num] <= 100 then return T(_("%1: %2 %"), text, self.warmth[num]) else return T(_("%1: 100 % %2"), text, self.control_nightmode and "+ ☾" or "") end else if self.warmth[num] <= 100 then return T(_("%1: ☼"), text) else return T(_("%1: ☾"), text) end end end, callback = function(touchmenu_instance) if Device:hasNaturalLight() and self.control_warmth then UIManager:show(SpinWidget:new{ title_text = text, info_text = _("Enter percentage of warmth."), value = self.warmth[num], value_min = 0, value_max = 100, wrap = false, value_step = math.floor(100 / device_max_warmth), value_hold_step = 10, unit = "%", ok_text = _("Set"), callback = function(spin) self.warmth[num] = spin.value self.warmth[#self.warmth - num + 1] = spin.value G_reader_settings:saveSetting("autowarmth_warmth", self.warmth) self:scheduleMidnightUpdate() if touchmenu_instance then self:updateItems(touchmenu_instance) end end, extra_text = self.control_nightmode and _("Use night mode"), extra_callback = self.control_nightmode and function() self.warmth[num] = 110 self.warmth[#self.warmth - num + 1] = 110 G_reader_settings:saveSetting("autowarmth_warmth", self.warmth) self:scheduleMidnightUpdate() if touchmenu_instance then self:updateItems(touchmenu_instance) end end, }) else UIManager:show(ConfirmBox:new{ text = _("Night mode"), ok_text = _("Set"), ok_callback = function() self.warmth[num] = 110 self.warmth[#self.warmth - num + 1] = 110 G_reader_settings:saveSetting("autowarmth_warmth", self.warmth) self:scheduleMidnightUpdate() if touchmenu_instance then self:updateItems(touchmenu_instance) end end, cancel_text = _("Unset"), cancel_callback = function() self.warmth[num] = 0 self.warmth[#self.warmth - num + 1] = 0 G_reader_settings:saveSetting("autowarmth_warmth", self.warmth) self:scheduleMidnightUpdate() if touchmenu_instance then self:updateItems(touchmenu_instance) end end, other_buttons = {{ { text = _("Cancel"), } }}, }) end end, keep_menu_open = true, } end local retval = { { text_func = function() if Device:hasNaturalLight() then return T(_("Control: %1%2%3"), self.control_warmth and _("warmth") or "", self.control_warmth and self.control_nightmode and T(" %1 ", _("and")) or "", self.control_nightmode and _("night mode") or "") else return _("Control: night mode") end end, checked_func = function() if Device:hasNaturalLight() then return self.control_nightmode or self.control_warmth else return self.control_nightmode end end, hold_callback = function() if Device:hasNaturalLight() then UIManager:show(InfoMessage:new{ text = _("Tapping here chooses between the different AutoWarmth modes: 'warmth only', 'warmth and night mode', 'night mode only'."), }) else UIManager:show(InfoMessage:new{ text = _("Your device supports 'night mode' control only."), }) end end, callback = function(touchmenu_instance) if Device:hasNaturalLight() then if self.control_warmth and self.control_nightmode then self.control_warmth = true self.control_nightmode = false G_reader_settings:makeTrue("autowarmth_control_warmth") G_reader_settings:makeFalse("autowarmth_control_nightmode") elseif self.control_warmth and not self.control_nightmode then self.control_warmth = false self.control_nightmode = true G_reader_settings:makeFalse("autowarmth_control_warmth") G_reader_settings:makeTrue("autowarmth_control_nightmode") else self.control_warmth = true self.control_nightmode = true G_reader_settings:makeTrue("autowarmth_control_warmth") G_reader_settings:makeTrue("autowarmth_control_nightmode") end else self.control_nightmode = not self.control_nightmode G_reader_settings:toggle("autowarmth_control_nightmode") end self:scheduleMidnightUpdate() if touchmenu_instance then self:updateItems(touchmenu_instance) end end, keep_menu_open = true, separator = true, }, { text = Device:hasNaturalLight() and _("Set warmth and night mode for:") or _("Set night mode for:"), enabled = false, }, getWarmthMenuEntry(_("Solar noon"), 6, false), getWarmthMenuEntry(_("Sunset and sunrise"), 5), getWarmthMenuEntry(_("Darkest time of civil twilight"), 4), getWarmthMenuEntry(_("Darkest time of nautical twilight"), 3, false), getWarmthMenuEntry(_("Darkest time of astronomical twilight"), 2, false), getWarmthMenuEntry(_("Solar midnight"), 1, false), } return tidy_menu(retval, self.easy_mode) end -- title -- location: add a location string -- activator: nil .. current_times_h, -- activate_sun .. sun times -- activate_schedule .. scheduler times -- request_easy: true if easy_mode should be used function AutoWarmth:showTimesInfo(title, location, activator, request_easy) local times if not activator then times = self.current_times_h elseif activator == activate_sun then times = SunTime.times elseif activator == activate_schedule then times = self.scheduler_times end -- text to show -- t .. times -- num .. index in times local function info_line(indent, text, time, num, face, easy) -- get width of space local unit = " " local tmp = TextWidget:new{ text = unit, face = face, } local space_w = tmp:getSize().w -- get width of text unit = text tmp = TextWidget:new{ text = unit, face = face, } local text_w = tmp:getSize().w tmp:free() -- width of text in spaces local str_len = math.floor(text_w / space_w + 0.5) local tab_width = 18 - indent local retval = string.rep(" ", indent) .. text .. string.rep(" ", tab_width - str_len) .. self:hoursToClock(time) if easy then if time and num and self.current_times_h[num] and self.current_times_h[num] ~= time then return text .. "\n" else return "" end end if not time then -- entry deactivated return retval .. "\n" elseif Device:hasNaturalLight() and self.control_warmth then if self.current_times_h[num] == time then if self.warmth[num] <= 100 then return retval .. " (💡" .. self.warmth[num] .. "%)\n" else return retval .. " (💡100%" .. (self.control_nightmode and " + ☾" or "") .. ")\n" end else return retval .. "\n" end else if self.current_times_h[num] == time then if self.warmth[num] <= 100 then return retval .. " (☼)\n" else return retval .. " (☾)\n" end else return retval .. "\n" end end end local location_string = "" if location then location_string = " " .. self:getLocationString() end local function add_line(indent, text, easy) return easy and "" or (string.rep(" ", indent) .. text .. "\n") end local face = Font:getFace("scfont") UIManager:show(InfoMessage:new{ face = face, width = math.floor(Screen:getWidth() * (self.easy_mode and 0.75 or 0.90)), text = title .. location_string .. ":\n\n" .. info_line(0, _("Solar midnight:"), times[1], 1, face, request_easy) .. add_line(2, _("Dawn"), request_easy) .. info_line(4, _("Astronomic:"), times[2], 2, face, request_easy) .. info_line(4, _("Nautical:"), times[3], 3, face, request_easy).. info_line(request_easy and 0 or 4, request_easy and _("Twilight:") or _("Civil:"), times[4], 4, face) .. add_line(2, _("Dawn"), request_easy) .. info_line(0, _("Sunrise:"), times[5], 5, face) .. "\n" .. info_line(0, _("Solar noon:"), times[6], 6, face, request_easy) .. add_line(0, "", request_easy) .. info_line(0, _("Sunset:"), times[7], 7, face) .. add_line(2, _("Dusk"), request_easy) .. info_line(request_easy and 0 or 4, request_easy and _("Twilight:") or _("Civil:"), times[8], 8, face) .. info_line(4, _("Nautical:"), times[9], 9, face, request_easy) .. info_line(4, _("Astronomic:"), times[10], 10, face, request_easy) .. add_line(2, _("Dusk"), request_easy) .. info_line(0, _("Solar midnight:"), times[midnight_index], midnight_index, face, request_easy) .. -- add fl toggle add_line(0, "", not self.fl_off_during_day) .. add_line(0, _("Toggle frontlight off between"), not self.fl_off_during_day) .. add_line(4, T(_("%1 and %2"), self:hoursToClock(times[5] + self.fl_off_during_day_offset_s * (1/3600)), self:hoursToClock(times[7] - self.fl_off_during_day_offset_s * (1/3600))), not self.fl_off_during_day), }) end -- title -- location: add a location string -- activator: nil .. current_times_h, -- activate_sun .. sun times -- activate_schedule .. scheduler times function AutoWarmth:getTimesMenu(title, location, activator) return { enabled_func = function() -- always show sun position times so you can see ephemeris return self.activate ~= 0 and (self.activate ~= activate_sun or activator == nil) or activator == activate_sun end, text_func = function() if location then return title .. " " .. self:getLocationString() end return title end, callback = function() self:showTimesInfo(title, location, activator, self.easy_mode) end, keep_menu_open = true, } end function AutoWarmth:getLocationString() if self.location ~= "" then return self.location else return string.format("(%.2f°,%.2f°)", self.latitude, self.longitude) end end return AutoWarmth