mirror of
https://github.com/koreader/koreader
synced 2024-11-16 06:12:56 +00:00
311 lines
13 KiB
Lua
311 lines
13 KiB
Lua
--[[--
|
||
This module contains date translations and helper functions for the KOReader frontend.
|
||
]]
|
||
|
||
local BaseUtil = require("ffi/util")
|
||
local _ = require("gettext")
|
||
local C_ = _.pgettext
|
||
local T = BaseUtil.template
|
||
|
||
local datetime = {}
|
||
|
||
datetime.weekDays = { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" } -- in Lua wday order
|
||
|
||
datetime.shortMonthTranslation = {
|
||
["Jan"] = _("Jan"),
|
||
["Feb"] = _("Feb"),
|
||
["Mar"] = _("Mar"),
|
||
["Apr"] = _("Apr"),
|
||
["May"] = _("May"),
|
||
["Jun"] = _("Jun"),
|
||
["Jul"] = _("Jul"),
|
||
["Aug"] = _("Aug"),
|
||
["Sep"] = _("Sep"),
|
||
["Oct"] = _("Oct"),
|
||
["Nov"] = _("Nov"),
|
||
["Dec"] = _("Dec"),
|
||
}
|
||
|
||
datetime.longMonthTranslation = {
|
||
["January"] = _("January"),
|
||
["February"] = _("February"),
|
||
["March"] = _("March"),
|
||
["April"] = _("April"),
|
||
["May"] = _("May"),
|
||
["June"] = _("June"),
|
||
["July"] = _("July"),
|
||
["August"] = _("August"),
|
||
["September"] = _("September"),
|
||
["October"] = _("October"),
|
||
["November"] = _("November"),
|
||
["December"] = _("December"),
|
||
}
|
||
|
||
datetime.shortDayOfWeekTranslation = {
|
||
["Mon"] = _("Mon"),
|
||
["Tue"] = _("Tue"),
|
||
["Wed"] = _("Wed"),
|
||
["Thu"] = _("Thu"),
|
||
["Fri"] = _("Fri"),
|
||
["Sat"] = _("Sat"),
|
||
["Sun"] = _("Sun"),
|
||
}
|
||
|
||
datetime.shortDayOfWeekToLongTranslation = {
|
||
["Mon"] = _("Monday"),
|
||
["Tue"] = _("Tuesday"),
|
||
["Wed"] = _("Wednesday"),
|
||
["Thu"] = _("Thursday"),
|
||
["Fri"] = _("Friday"),
|
||
["Sat"] = _("Saturday"),
|
||
["Sun"] = _("Sunday"),
|
||
}
|
||
|
||
--[[--
|
||
Converts seconds to a clock string.
|
||
|
||
Source: <a href="https://gist.github.com/jesseadams/791673">https://gist.github.com/jesseadams/791673</a>
|
||
]]
|
||
---- @int seconds number of seconds
|
||
---- @bool withoutSeconds if true 00:00, if false 00:00:00
|
||
---- @treturn string clock string in the form of 00:00 or 00:00:00
|
||
function datetime.secondsToClock(seconds, withoutSeconds, withDays)
|
||
seconds = tonumber(seconds)
|
||
if not seconds then
|
||
if withoutSeconds then
|
||
return "--:--"
|
||
else
|
||
return "--:--:--"
|
||
end
|
||
elseif seconds == 0 or seconds ~= seconds then
|
||
if withoutSeconds then
|
||
return "00:00"
|
||
else
|
||
return "00:00:00"
|
||
end
|
||
else
|
||
local round = withoutSeconds and require("optmath").round or function(n) return n end
|
||
local days = "0"
|
||
local hours
|
||
if withDays then
|
||
days = string.format("%d", seconds * (1/(24*3600))) -- implicit math.floor for string.format
|
||
hours = string.format("%02d", (seconds * (1/3600)) % 24)
|
||
else
|
||
hours = string.format("%02d", seconds * (1/3600))
|
||
end
|
||
local mins = string.format("%02d", round(seconds % 3600 * (1/60)))
|
||
if withoutSeconds then
|
||
if mins == "60" then
|
||
-- Can only happen because of rounding, which only happens if withoutSeconds...
|
||
mins = string.format("%02d", 0)
|
||
hours = string.format("%02d", hours + 1)
|
||
end
|
||
return (days ~= "0" and (days .. C_("Time", "d")) or "") .. hours .. ":" .. mins
|
||
else
|
||
local secs = string.format("%02d", seconds % 60)
|
||
return (days ~= "0" and (days .. C_("Time", "d")) or "") .. hours .. ":" .. mins .. ":" .. secs
|
||
end
|
||
end
|
||
end
|
||
|
||
--- Converts seconds to a period of time string.
|
||
---- @int seconds number of seconds
|
||
---- @bool withoutSeconds if true 1h30', if false 1h30'10"
|
||
---- @bool hmsFormat, if true format 1h 30m 10s
|
||
---- @bool withDays, if true format 1d12h30'10" or 1d 12h 30m 10s
|
||
---- @bool compact, if set removes all leading zeros (incl. units if necessary) and turns thinspaces into hairspaces (if present)
|
||
---- @treturn string clock string in the form of 1h30'10" or 1h 30m 10s
|
||
function datetime.secondsToHClock(seconds, withoutSeconds, hmsFormat, withDays, compact)
|
||
local SECONDS_SYMBOL = "\""
|
||
seconds = tonumber(seconds)
|
||
if seconds == 0 then
|
||
if withoutSeconds then
|
||
if hmsFormat then
|
||
return T(_("%1m"), "0")
|
||
else
|
||
return "0'"
|
||
end
|
||
else
|
||
if hmsFormat then
|
||
return T(C_("Time", "%1s"), "0")
|
||
else
|
||
return "0" .. SECONDS_SYMBOL
|
||
end
|
||
end
|
||
elseif seconds < 60 then
|
||
if withoutSeconds and seconds < 30 then
|
||
if hmsFormat then
|
||
return T(C_("Time", "%1m"), "0")
|
||
else
|
||
return "0'"
|
||
end
|
||
elseif withoutSeconds and seconds >= 30 then
|
||
if hmsFormat then
|
||
return T(C_("Time", "%1m"), "1")
|
||
else
|
||
return "1'"
|
||
end
|
||
else
|
||
if hmsFormat then
|
||
if compact then
|
||
return T(C_("Time", "%1s"), string.format("%d", seconds))
|
||
else
|
||
return T(C_("Time", "%1m\xE2\x80\x89%2s"), "0", string.format("%d", seconds))
|
||
end
|
||
else
|
||
if compact then
|
||
return string.format("%d", seconds) .. SECONDS_SYMBOL
|
||
else
|
||
return "0'" .. string.format("%02d", seconds) .. SECONDS_SYMBOL
|
||
end
|
||
end
|
||
end
|
||
else
|
||
local time_string = datetime.secondsToClock(seconds, withoutSeconds, withDays)
|
||
if withoutSeconds then
|
||
time_string = time_string .. ":"
|
||
end
|
||
time_string = time_string:gsub(":", C_("Time", "h"), 1)
|
||
time_string = time_string:gsub(":", C_("Time", "m"), 1)
|
||
time_string = time_string:gsub("^00" .. C_("Time", "h"), "") -- delete leading "00h"
|
||
time_string = time_string:gsub("^00" .. C_("Time", "m"), "") -- delete leading "00m"
|
||
if time_string:find("^0%d") then
|
||
time_string = time_string:gsub("^0", "") -- delete leading "0"
|
||
end
|
||
if withoutSeconds and time_string == "" then
|
||
time_string = "0" .. C_("Time", "m")
|
||
end
|
||
|
||
if hmsFormat then
|
||
time_string = time_string:gsub("0(%d)", "%1") -- delete all leading "0"s
|
||
time_string = time_string:gsub(C_("Time", "d"), C_("Time", "d") .. "\xE2\x80\x89") -- add thin space after "d"
|
||
time_string = time_string:gsub(C_("Time", "h"), C_("Time", "h") .. "\xE2\x80\x89") -- add thin space after "h"
|
||
if not withoutSeconds then
|
||
time_string = time_string:gsub(C_("Time", "m"), C_("Time", "m") .. "\xE2\x80\x89") .. C_("Time", "s") -- add thin space after "m"
|
||
end
|
||
if compact then
|
||
time_string = time_string:gsub("\xE2\x80\x89", "\xE2\x80\x8A") -- replace thin space with hair space
|
||
end
|
||
return time_string
|
||
else
|
||
time_string = time_string:gsub(C_("Time", "m"), "'") -- replace m with '
|
||
return withoutSeconds and time_string or (time_string .. SECONDS_SYMBOL)
|
||
end
|
||
end
|
||
end
|
||
|
||
--- Converts seconds to a clock type (classic or modern), based on the given format preference
|
||
--- "Classic" format calls secondsToClock, "Modern" and "Letters" formats call secondsToHClock
|
||
---- @string Either "modern" for 1h30'10", "letters" for 1h 30m 10s, or "classic" for 1:30:10
|
||
---- @bool withoutSeconds if true 1h30' or 1h 30m, if false 1h30'10" or 1h 30m 10s
|
||
---- @bool withDays, if hours>=24 include days in clock string 1d12h10'10" or 1d 12h 10m 10s
|
||
---- @bool compact, if set removes all leading zeros (incl. units if necessary) and turns thinspaces into hairspaces (if present)
|
||
---- @treturn string clock string in the specific format of 1h30', 1h30'10" resp. 1h 30m, 1h 30m 10s
|
||
function datetime.secondsToClockDuration(format, seconds, withoutSeconds, withDays, compact)
|
||
if format == "modern" then
|
||
return datetime.secondsToHClock(seconds, withoutSeconds, false, withDays, compact)
|
||
elseif format == "letters" then
|
||
return datetime.secondsToHClock(seconds, withoutSeconds, true, withDays, compact)
|
||
else
|
||
-- Assume "classic" to give safe default
|
||
return datetime.secondsToClock(seconds, withoutSeconds, withDays)
|
||
end
|
||
end
|
||
|
||
if jit.os == "Windows" then
|
||
--- Converts timestamp to an hour string
|
||
---- @int seconds number of seconds
|
||
---- @bool twelve_hour_clock
|
||
---- @treturn string hour string
|
||
---- @note: The MS CRT doesn't support either %l & %k, or the - format modifier (as they're not technically C99 or POSIX).
|
||
---- They are otherwise supported on Linux, BSD & Bionic, so, just special-case Windows...
|
||
---- We *could* arguably feed the os.date output to gsub("^0(%d)(.*)$", "%1%2"), but, while unlikely,
|
||
---- it's conceivable that a translator would put something other that the hour at the front of the string ;).
|
||
function datetime.secondsToHour(seconds, twelve_hour_clock)
|
||
if twelve_hour_clock then
|
||
if os.date("%p", seconds) == "AM" then
|
||
-- @translators This is the time in the morning using a 12-hour clock (%I is the hour, %M the minute).
|
||
return os.date(_("%I:%M AM"), seconds)
|
||
else
|
||
-- @translators This is the time in the afternoon using a 12-hour clock (%I is the hour, %M the minute).
|
||
return os.date(_("%I:%M PM"), seconds)
|
||
end
|
||
else
|
||
-- @translators This is the time using a 24-hour clock (%H is the hour, %M the minute).
|
||
return os.date(_("%H:%M"), seconds)
|
||
end
|
||
end
|
||
else
|
||
function datetime.secondsToHour(seconds, twelve_hour_clock, pad_with_spaces)
|
||
if twelve_hour_clock then
|
||
if os.date("%p", seconds) == "AM" then
|
||
if pad_with_spaces then
|
||
-- @translators This is the time in the morning using a 12-hour clock (%_I is the hour, %M the minute).
|
||
return os.date(_("%_I:%M AM"), seconds)
|
||
else
|
||
-- @translators This is the time in the morning using a 12-hour clock (%-I is the hour, %M the minute).
|
||
return os.date(_("%-I:%M AM"), seconds)
|
||
end
|
||
else
|
||
if pad_with_spaces then
|
||
-- @translators This is the time in the afternoon using a 12-hour clock (%_I is the hour, %M the minute).
|
||
return os.date(_("%_I:%M PM"), seconds)
|
||
else
|
||
-- @translators This is the time in the afternoon using a 12-hour clock (%-I is the hour, %M the minute).
|
||
return os.date(_("%-I:%M PM"), seconds)
|
||
end
|
||
end
|
||
else
|
||
if pad_with_spaces then
|
||
-- @translators This is the time using a 24-hour clock (%_H is the hour, %M the minute).
|
||
return os.date(_("%_H:%M"), seconds)
|
||
else
|
||
-- @translators This is the time using a 24-hour clock (%-H is the hour, %M the minute).
|
||
return os.date(_("%-H:%M"), seconds)
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
--- Converts timestamp to a date string
|
||
---- @int seconds number of seconds
|
||
---- @use_locale if true allows to translate the date-time string, if false return "%Y-%m-%d time"
|
||
---- @treturn string date string
|
||
function datetime.secondsToDate(seconds, use_locale)
|
||
seconds = seconds or os.time()
|
||
if use_locale then
|
||
local wday = os.date("%a", seconds)
|
||
local month = os.date("%b", seconds)
|
||
local day = os.date("%d", seconds)
|
||
local year = os.date("%Y", seconds)
|
||
|
||
-- @translators Use the following placeholders in the desired order: %1 name of day, %2 name of month, %3 day, %4 year
|
||
return T(C_("Date string", "%1 %2 %3 %4"),
|
||
datetime.shortDayOfWeekTranslation[wday], datetime.shortMonthTranslation[month], day, year)
|
||
else
|
||
-- @translators This is the date (%Y is the year, %m the month, %d the day)
|
||
return os.date(C_("Date string", "%Y-%m-%d"), seconds)
|
||
end
|
||
end
|
||
|
||
--- Converts timestamp to a date+time string
|
||
---- @int seconds number of seconds
|
||
---- @bool twelve_hour_clock
|
||
---- @use_locale if true allows to translate the date-time string, if false return "%Y-%m-%d time"
|
||
---- @treturn string date+time
|
||
function datetime.secondsToDateTime(seconds, twelve_hour_clock, use_locale)
|
||
seconds = seconds or os.time()
|
||
if twelve_hour_clock == nil then
|
||
twelve_hour_clock = G_reader_settings:isTrue("twelve_hour_clock")
|
||
end
|
||
local BD = require("ui/bidi")
|
||
local date_string = datetime.secondsToDate(seconds, use_locale)
|
||
local time_string = datetime.secondsToHour(seconds, twelve_hour_clock, not use_locale)
|
||
|
||
-- @translators Use the following placeholders in the desired order: %1 date, %2 time
|
||
local message_text = T(C_("Date string", "%1 %2"), BD.wrap(date_string), BD.wrap(time_string))
|
||
return message_text
|
||
end
|
||
|
||
return datetime
|