137 lines
3.1 KiB
Rust
137 lines
3.1 KiB
Rust
use iced::{
|
|
Align, Application, Checkbox, Column, Command, Container, Element, Length,
|
|
Settings, Subscription, Text,
|
|
};
|
|
|
|
pub fn main() {
|
|
Clock::run(Settings::default())
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
struct Clock {
|
|
time: chrono::DateTime<chrono::Local>,
|
|
enabled: bool,
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
enum Message {
|
|
Ticked(chrono::DateTime<chrono::Local>),
|
|
Toggled(bool),
|
|
}
|
|
|
|
impl Application for Clock {
|
|
type Message = Message;
|
|
|
|
fn new() -> (Clock, Command<Message>) {
|
|
(
|
|
Clock {
|
|
time: chrono::Local::now(),
|
|
enabled: false,
|
|
},
|
|
Command::none(),
|
|
)
|
|
}
|
|
|
|
fn title(&self) -> String {
|
|
String::from("Clock - Iced")
|
|
}
|
|
|
|
fn update(&mut self, message: Message) -> Command<Message> {
|
|
match message {
|
|
Message::Ticked(time) => {
|
|
self.time = time;
|
|
}
|
|
Message::Toggled(enabled) => {
|
|
self.enabled = enabled;
|
|
}
|
|
};
|
|
|
|
Command::none()
|
|
}
|
|
|
|
fn subscriptions(&self) -> Subscription<Message> {
|
|
if self.enabled {
|
|
time::every(std::time::Duration::from_millis(500), Message::Ticked)
|
|
} else {
|
|
Subscription::none()
|
|
}
|
|
}
|
|
|
|
fn view(&mut self) -> Element<Message> {
|
|
let clock = Text::new(format!("{}", self.time.format("%H:%M:%S")))
|
|
.size(40)
|
|
.width(Length::Shrink);
|
|
|
|
let toggle = Checkbox::new(self.enabled, "Enabled", Message::Toggled)
|
|
.width(Length::Shrink);
|
|
|
|
let content = Column::new()
|
|
.width(Length::Shrink)
|
|
.align_items(Align::Center)
|
|
.spacing(20)
|
|
.push(clock)
|
|
.push(toggle);
|
|
|
|
Container::new(content)
|
|
.width(Length::Fill)
|
|
.height(Length::Fill)
|
|
.center_x()
|
|
.center_y()
|
|
.into()
|
|
}
|
|
}
|
|
|
|
mod time {
|
|
use std::sync::Arc;
|
|
|
|
pub fn every<Message>(
|
|
duration: std::time::Duration,
|
|
f: impl Fn(chrono::DateTime<chrono::Local>) -> Message
|
|
+ 'static
|
|
+ Send
|
|
+ Sync,
|
|
) -> iced::Subscription<Message>
|
|
where
|
|
Message: Send + 'static,
|
|
{
|
|
Tick {
|
|
duration,
|
|
message: Arc::new(f),
|
|
}
|
|
.into()
|
|
}
|
|
|
|
struct Tick<Message> {
|
|
duration: std::time::Duration,
|
|
message: Arc<
|
|
dyn Fn(chrono::DateTime<chrono::Local>) -> Message + Send + Sync,
|
|
>,
|
|
}
|
|
|
|
impl<Message> iced::subscription::Handle for Tick<Message>
|
|
where
|
|
Message: 'static,
|
|
{
|
|
type Output = Message;
|
|
|
|
fn id(&self) -> u64 {
|
|
0
|
|
}
|
|
|
|
fn stream(&self) -> futures::stream::BoxStream<'static, Message> {
|
|
use futures::StreamExt;
|
|
|
|
let duration = self.duration.clone();
|
|
let function = self.message.clone();
|
|
|
|
let stream =
|
|
futures::stream::iter(std::iter::repeat(())).map(move |_| {
|
|
std::thread::sleep(duration);
|
|
|
|
function(chrono::Local::now())
|
|
});
|
|
|
|
stream.boxed()
|
|
}
|
|
}
|
|
}
|