107 lines
3.2 KiB
Rust
107 lines
3.2 KiB
Rust
use std::{rc::Rc, sync::LazyLock};
|
|
|
|
use gpui::{App, ElementId, Entity, IntoElement, RenderOnce, SharedString, Window};
|
|
use jiff::{
|
|
Timestamp,
|
|
tz::{self, Offset, TimeZone},
|
|
};
|
|
|
|
use super::super::{Choice, Combobox, TextInput, options::OnValue};
|
|
use crate::typography::format::MINUS;
|
|
|
|
/// An offset as "UTC+09:00", with a true minus sign west of Greenwich.
|
|
pub(crate) fn show_offset(offset: Offset) -> String {
|
|
let seconds = offset.seconds();
|
|
let sign = if seconds < 0 { MINUS } else { '+' };
|
|
let minutes = seconds.unsigned_abs() / 60;
|
|
format!("UTC{sign}{:02}:{:02}", minutes / 60, minutes % 60)
|
|
}
|
|
|
|
/// Every zone the system knows, by name.
|
|
static ZONES: LazyLock<Vec<(SharedString, TimeZone)>> = LazyLock::new(|| {
|
|
let mut zones: Vec<(SharedString, TimeZone)> = tz::db()
|
|
.available()
|
|
.filter_map(|name| match TimeZone::get(name.as_str()) {
|
|
Ok(zone) => Some((SharedString::from(name.as_str().to_string()), zone)),
|
|
Err(error) => {
|
|
log::error!("timezone select: skipped {}: {error}", name.as_str());
|
|
None
|
|
}
|
|
})
|
|
.collect();
|
|
zones.sort_by(|a, b| a.0.cmp(&b.0));
|
|
log::info!("timezone select: {} zones", zones.len());
|
|
zones
|
|
});
|
|
|
|
/// A searchable list of the system's time zones, each with its offset now.
|
|
#[derive(IntoElement)]
|
|
pub struct TimezoneSelect {
|
|
id: ElementId,
|
|
state: Entity<TextInput>,
|
|
selected: Option<SharedString>,
|
|
on_change: Option<OnValue>,
|
|
}
|
|
|
|
impl TimezoneSelect {
|
|
pub fn new(id: impl Into<ElementId>, state: &Entity<TextInput>) -> Self {
|
|
Self {
|
|
id: id.into(),
|
|
state: state.clone(),
|
|
selected: None,
|
|
on_change: None,
|
|
}
|
|
}
|
|
|
|
/// A zone by its IANA name, such as `Asia/Tokyo`.
|
|
pub fn selected(mut self, zone: impl Into<SharedString>) -> Self {
|
|
self.selected = Some(zone.into());
|
|
self
|
|
}
|
|
|
|
pub fn on_change(
|
|
mut self,
|
|
handler: impl Fn(&SharedString, &mut Window, &mut App) + 'static,
|
|
) -> Self {
|
|
self.on_change = Some(Rc::new(handler));
|
|
self
|
|
}
|
|
}
|
|
|
|
impl RenderOnce for TimezoneSelect {
|
|
fn render(self, _: &mut Window, _: &mut App) -> impl IntoElement {
|
|
let now = Timestamp::now();
|
|
let zones = ZONES.iter().map(|(name, zone)| {
|
|
Choice::new(name.clone(), name.clone()).note(show_offset(zone.to_offset(now)))
|
|
});
|
|
let mut combo = Combobox::new(self.id, &self.state, zones);
|
|
if let Some(zone) = self.selected {
|
|
combo = combo.selected(zone);
|
|
}
|
|
if let Some(on_change) = self.on_change {
|
|
combo = combo.on_change(move |zone, window, cx| on_change(zone, window, cx));
|
|
}
|
|
combo
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use jiff::tz::Offset;
|
|
|
|
use super::show_offset;
|
|
|
|
#[test]
|
|
fn offsets_read_as_utc_plus_or_minus() {
|
|
assert_eq!(
|
|
show_offset(Offset::from_seconds(9 * 3600).unwrap()),
|
|
"UTC+09:00"
|
|
);
|
|
assert_eq!(
|
|
show_offset(Offset::from_seconds(-(5 * 3600 + 1800)).unwrap()),
|
|
"UTC\u{2212}05:30"
|
|
);
|
|
assert_eq!(show_offset(Offset::UTC), "UTC+00:00");
|
|
}
|
|
}
|