700 lines
22 KiB
Rust
700 lines
22 KiB
Rust
// For now, to implement a custom native widget you will need to add
|
|
// `iced_native` and `iced_wgpu` to your dependencies.
|
|
//
|
|
// Then, you simply need to define your widget type and implement the
|
|
// `iced_native::Widget` trait with the `iced_wgpu::Renderer`.
|
|
//
|
|
// Of course, you can choose to make the implementation renderer-agnostic,
|
|
// if you wish to, by creating your own `Renderer` trait, which could be
|
|
// implemented by `iced_wgpu` and other renderers.
|
|
|
|
use iced_native::layout::{self, Layout};
|
|
use iced_native::renderer;
|
|
use iced_native::{Color, Element, Length, Point, Rectangle, Size, Widget};
|
|
use iced_native::text;
|
|
use iced_native::alignment;
|
|
use iced_native::widget::Tree;
|
|
use chrono::{NaiveDate, Datelike, Duration, Weekday, Local};
|
|
|
|
const MONTH_NAMES: [&str;12] = [
|
|
"gen",
|
|
"feb",
|
|
"mar",
|
|
"apr",
|
|
"mag",
|
|
"giu",
|
|
"lug",
|
|
"ago",
|
|
"set",
|
|
"ott",
|
|
"nov",
|
|
"dic",
|
|
];
|
|
|
|
//-------------------------------------------------------------------------
|
|
|
|
#[derive(Clone)]
|
|
pub struct CalendarParams {
|
|
show_weeks: bool,
|
|
header_fg: Color,
|
|
header_bg: Color,
|
|
day_text: Color,
|
|
day_text_other_month: Color,
|
|
day_weekend_bg: Color,
|
|
day_today_bg: Color,
|
|
day_text_margin: f32,
|
|
}
|
|
|
|
impl CalendarParams {
|
|
pub fn new() -> Self {
|
|
Self {
|
|
show_weeks: true,
|
|
header_fg: Color::BLACK,
|
|
header_bg: Color::TRANSPARENT,
|
|
day_today_bg: Color::from_rgb8(214, 242, 252),
|
|
day_text: Color::BLACK,
|
|
day_text_other_month: Color::from_rgb8(220, 220, 220),
|
|
// day_background: Color::from_rgb8(230, 230, 255),
|
|
day_weekend_bg: Color::from_rgb8(245, 245, 245),
|
|
day_text_margin: 5.0,
|
|
}
|
|
}
|
|
}
|
|
|
|
//-------------------------------------------------------------------------
|
|
|
|
pub struct CalendarMonthView {
|
|
first_day: NaiveDate,
|
|
first_day_in_view: NaiveDate,
|
|
params: CalendarParams,
|
|
weekday_on_first: Weekday,
|
|
week_column_width: f32,
|
|
week_column_font_size: f32,
|
|
}
|
|
|
|
impl CalendarMonthView {
|
|
pub fn new(params: &CalendarParams, day: NaiveDate) -> Self {
|
|
// first day of the month
|
|
let first_day = if day.day() == 1 {
|
|
day
|
|
} else {
|
|
NaiveDate::from_ymd(day.year(), day.month(), 1)
|
|
};
|
|
|
|
// weekday on first day of the month
|
|
let weekday_on_first = first_day.weekday();
|
|
|
|
// first visible day in the view
|
|
let first_day_in_view = first_day - Duration::days(weekday_on_first.num_days_from_monday() as i64);
|
|
|
|
Self {
|
|
first_day,
|
|
first_day_in_view,
|
|
params: params.clone(),
|
|
weekday_on_first,
|
|
week_column_width: 30.0,
|
|
week_column_font_size: 18.0,
|
|
}
|
|
}
|
|
|
|
pub fn set_month(&mut self, day: NaiveDate) {
|
|
// first day of the month
|
|
let first_day = if day.day() == 1 {
|
|
day
|
|
} else {
|
|
NaiveDate::from_ymd(day.year(), day.month(), 1)
|
|
};
|
|
|
|
// weekday on first day of the month
|
|
let weekday_on_first = first_day.weekday();
|
|
|
|
// first visible day in the view
|
|
let first_day_in_view = first_day - Duration::days(weekday_on_first.num_days_from_monday() as i64);
|
|
|
|
self.first_day = first_day;
|
|
self.weekday_on_first = weekday_on_first;
|
|
self.first_day_in_view = first_day_in_view;
|
|
}
|
|
|
|
fn draw_header(
|
|
&self,
|
|
renderer: &mut impl text::Renderer,
|
|
bounds: Rectangle,
|
|
week_w: f32,
|
|
) {
|
|
// paint background over full width
|
|
if self.params.header_bg != Color::TRANSPARENT {
|
|
renderer.fill_quad(renderer::Quad {
|
|
bounds,
|
|
border_radius: 0.0,
|
|
border_width: 0.0,
|
|
border_color: Color::TRANSPARENT,
|
|
},
|
|
self.params.header_bg);
|
|
}
|
|
|
|
// redefine bounds to skip the week column
|
|
let bounds = Rectangle {
|
|
x: bounds.x + week_w,
|
|
y: bounds.y,
|
|
width: bounds.width - week_w,
|
|
height: bounds.height};
|
|
|
|
let origin = bounds.position();
|
|
|
|
// font dimension
|
|
let font_size = renderer.default_size() as f32;
|
|
|
|
// dimensions of each box representing a day
|
|
let w: f32 = bounds.width / 7.0;
|
|
let h: f32 = bounds.height;
|
|
|
|
let days_of_week = ["LUN", "MAR", "MER", "GIO", "VEN", "SAB", "DOM"];
|
|
|
|
for weekday in 0..7i32 {
|
|
let bounds = Rectangle {
|
|
x: (weekday as f32) * w + origin.x,
|
|
y: origin.y,
|
|
width: w,
|
|
height: h
|
|
};
|
|
|
|
// label (day letter on row 0, day number on the rest)
|
|
let t = days_of_week[weekday as usize];
|
|
|
|
// color of text
|
|
let fg = self.params.header_fg;
|
|
|
|
let x = bounds.x + self.params.day_text_margin;
|
|
let y = bounds.center_y();
|
|
renderer.fill_text(text::Text {
|
|
content : t,
|
|
size: font_size,
|
|
bounds: Rectangle {x, y, ..bounds},
|
|
color: fg,
|
|
font: Default::default(),
|
|
horizontal_alignment: alignment::Horizontal::Left,
|
|
vertical_alignment: alignment::Vertical::Center,
|
|
});
|
|
}
|
|
}
|
|
|
|
fn draw_week_column(
|
|
&self,
|
|
renderer: &mut impl text::Renderer,
|
|
bounds: Rectangle,
|
|
) {
|
|
// dimensions of each box representing a week number
|
|
let h: f32 = bounds.height / 6.0;
|
|
let r: f32 = if h > self.week_column_width {
|
|
self.week_column_width
|
|
} else {
|
|
h
|
|
} / 2.0;
|
|
|
|
let mut day = self.first_day;
|
|
|
|
for week in 0..6u32 {
|
|
// where to place the week number
|
|
let day_bounds = Rectangle {
|
|
x: bounds.x,
|
|
y: (week as f32) * h + bounds.y + self.params.day_text_margin,
|
|
width: r * 2.0,
|
|
height: r * 2.0
|
|
};
|
|
|
|
let week_of_first_day_of_month = day.iso_week().week();
|
|
day += Duration::weeks(1);
|
|
|
|
// render week cell text
|
|
renderer.fill_text(text::Text {
|
|
content : &(week_of_first_day_of_month).to_string(),
|
|
size: self.week_column_font_size,
|
|
bounds: Rectangle {
|
|
x: day_bounds.center_x(),
|
|
y: day_bounds.y,
|
|
..day_bounds
|
|
},
|
|
color: self.params.day_text,
|
|
font: Default::default(),
|
|
horizontal_alignment: alignment::Horizontal::Center,
|
|
vertical_alignment: alignment::Vertical::Top,
|
|
});
|
|
}
|
|
}
|
|
|
|
fn draw_days(
|
|
&self,
|
|
renderer: &mut impl text::Renderer,
|
|
bounds: Rectangle,
|
|
) {
|
|
let size: Size = bounds.size();
|
|
let origin = bounds.position();
|
|
|
|
// font dimension
|
|
let font_size = renderer.default_size() as f32;
|
|
|
|
// dimensions of each box representing a day
|
|
let w: f32 = size.width / 7.0;
|
|
let h: f32 = size.height / 6.0;
|
|
|
|
let mut current_day = self.first_day_in_view;
|
|
for week in 0..6i32 {
|
|
for weekday in 0..7i32 {
|
|
let day_bounds = Rectangle {
|
|
x: (weekday as f32) * w + origin.x,
|
|
y: (week as f32) * h + origin.y,
|
|
width: w,
|
|
height: h
|
|
};
|
|
|
|
// label (day letter on row 0, day number on the rest)
|
|
let t = current_day.day().to_string();
|
|
let content = t.as_str();
|
|
|
|
// color of text
|
|
let fg = if current_day.month() == self.first_day.month() {
|
|
self.params.day_text
|
|
} else {
|
|
self.params.day_text_other_month
|
|
};
|
|
|
|
// background color of the day cell
|
|
let bg_color = if current_day == Local::today().naive_local() {
|
|
self.params.day_today_bg
|
|
} else if weekday > 4 {
|
|
self.params.day_weekend_bg
|
|
} else {
|
|
Color::TRANSPARENT
|
|
};
|
|
|
|
// where to place the day content
|
|
let x = day_bounds.x + self.params.day_text_margin;
|
|
let y = day_bounds.y + self.params.day_text_margin;
|
|
|
|
renderer.fill_quad(renderer::Quad {
|
|
bounds: Rectangle {width: day_bounds.width + 0.5, height: day_bounds.height + 0.5, ..day_bounds},
|
|
border_radius: 0.0,
|
|
border_width: 1.0,
|
|
border_color: self.params.day_text_other_month,
|
|
},
|
|
bg_color);
|
|
|
|
// render day cell text
|
|
renderer.fill_text(text::Text {
|
|
content,
|
|
size: font_size,
|
|
bounds: Rectangle {x, y, ..day_bounds},
|
|
color: fg,
|
|
font: Default::default(),
|
|
horizontal_alignment: alignment::Horizontal::Left,
|
|
vertical_alignment: alignment::Vertical::Top,
|
|
});
|
|
current_day = current_day.succ();
|
|
}
|
|
}
|
|
}
|
|
|
|
} // CalendarMonthView
|
|
|
|
impl<Message, Renderer> Widget<Message, Renderer> for CalendarMonthView
|
|
where
|
|
Renderer: text::Renderer,
|
|
{
|
|
fn width(&self) -> Length {
|
|
Length::Shrink
|
|
}
|
|
|
|
fn height(&self) -> Length {
|
|
Length::Shrink
|
|
}
|
|
|
|
fn layout(
|
|
&self,
|
|
_renderer: &Renderer,
|
|
limits: &layout::Limits,
|
|
) -> layout::Node {
|
|
layout::Node::new(limits.max())
|
|
}
|
|
|
|
fn draw(
|
|
&self,
|
|
_state: &Tree,
|
|
renderer: &mut Renderer,
|
|
_theme: &Renderer::Theme,
|
|
_style: &renderer::Style,
|
|
layout: Layout<'_>,
|
|
_cursor_position: Point,
|
|
_viewport: &Rectangle,
|
|
) {
|
|
let size: Size = layout.bounds().size();
|
|
let origin = layout.bounds().position();
|
|
let margin: f32 = 20.0;
|
|
|
|
// week column only visible if there is enough space
|
|
let week_w = if self.params.show_weeks && size.width > self.week_column_width {
|
|
self.week_column_width
|
|
} else {
|
|
0.0
|
|
};
|
|
|
|
// font and header dimension
|
|
let font_size = renderer.default_size() as f32;
|
|
let first_row_h = font_size + margin;
|
|
|
|
// header
|
|
let x = origin.x;
|
|
let y = origin.y;
|
|
let width = size.width;
|
|
let height = first_row_h;
|
|
self.draw_header(renderer, Rectangle {x, y, width, height}, week_w);
|
|
|
|
// week column
|
|
if week_w > 0.0 {
|
|
let x = origin.x;
|
|
let y = origin.y + first_row_h;
|
|
let width = self.week_column_width;
|
|
let height = size.height - first_row_h;
|
|
self.draw_week_column(renderer, Rectangle{x, y, width, height});
|
|
}
|
|
|
|
// monthly calendar cells
|
|
let x = origin.x + week_w;
|
|
let y = origin.y + first_row_h;
|
|
let width = size.width - week_w;
|
|
let height = size.height - first_row_h;
|
|
self.draw_days(renderer, Rectangle{x, y, width, height});
|
|
}
|
|
}
|
|
|
|
impl<'a, Message, Renderer> From<CalendarMonthView> for Element<'a, Message, Renderer>
|
|
where
|
|
Renderer: text::Renderer,
|
|
{
|
|
fn from(month_view: CalendarMonthView) -> Self {
|
|
Self::new(month_view)
|
|
}
|
|
}
|
|
|
|
//-------------------------------------------------------------------------
|
|
|
|
pub struct CalendarYearView {
|
|
first_day: NaiveDate,
|
|
first_day_in_view: NaiveDate,
|
|
params: CalendarParams,
|
|
weekday_on_first: Weekday,
|
|
month_column_font_size: f32,
|
|
margin: f32,
|
|
}
|
|
|
|
impl CalendarYearView {
|
|
pub fn new(params: &CalendarParams, day: NaiveDate) -> Self {
|
|
// first day of the year
|
|
let first_day = NaiveDate::from_ymd(day.year(), 1, 1);
|
|
|
|
// weekday on first day of the year
|
|
let weekday_on_first = first_day.weekday();
|
|
|
|
// first visible day in the view
|
|
let first_day_in_view = first_day - Duration::days(weekday_on_first.num_days_from_monday() as i64);
|
|
|
|
Self {
|
|
first_day,
|
|
first_day_in_view,
|
|
params: params.clone(),
|
|
weekday_on_first,
|
|
month_column_font_size: 24.0,
|
|
margin: 10.0
|
|
}
|
|
}
|
|
|
|
pub fn set_year(&mut self, day: NaiveDate) {
|
|
// first day of the year
|
|
self.first_day = NaiveDate::from_ymd(day.year(), 1, 1);
|
|
|
|
// weekday on first day of the year
|
|
self.weekday_on_first = self.first_day.weekday();
|
|
|
|
// first visible day in the view
|
|
self.first_day_in_view = self.first_day - Duration::days(self.weekday_on_first.num_days_from_monday() as i64);
|
|
}
|
|
|
|
fn draw_header(
|
|
&self,
|
|
renderer: &mut impl text::Renderer,
|
|
bounds: Rectangle,
|
|
week_w: f32,
|
|
) {
|
|
// paint background over full width
|
|
if self.params.header_bg != Color::TRANSPARENT {
|
|
renderer.fill_quad(renderer::Quad {
|
|
bounds,
|
|
border_radius: 0.0,
|
|
border_width: 0.0,
|
|
border_color: Color::TRANSPARENT,
|
|
},
|
|
self.params.header_bg);
|
|
}
|
|
|
|
// redefine bounds to skip the week column
|
|
let bounds = Rectangle {
|
|
x: bounds.x + week_w,
|
|
y: bounds.y,
|
|
width: bounds.width - week_w,
|
|
height: bounds.height};
|
|
|
|
let origin = bounds.position();
|
|
|
|
// font dimension
|
|
let font_size = renderer.default_size() as f32;
|
|
|
|
// dimensions of each box representing a day
|
|
let w: f32 = bounds.width / (7.0 * 6.0);
|
|
let h: f32 = bounds.height;
|
|
|
|
let days_of_week = ["L", "M", "M", "G", "V", "S", "D"];
|
|
|
|
for col in 0..42i32 {
|
|
let bounds = Rectangle {
|
|
x: (col as f32) * w + origin.x,
|
|
y: origin.y,
|
|
width: w,
|
|
height: h
|
|
};
|
|
|
|
let weekday = (col as usize) % 7;
|
|
|
|
// background color of the day cell
|
|
let bg_color = if weekday > 4 {
|
|
self.params.day_weekend_bg
|
|
} else {
|
|
Color::TRANSPARENT
|
|
};
|
|
|
|
renderer.fill_quad(renderer::Quad {
|
|
bounds,
|
|
border_radius: 0.0,
|
|
border_width: 1.0,
|
|
border_color: Color::TRANSPARENT,
|
|
},
|
|
bg_color);
|
|
|
|
// label (day letter on row 0, day number on the rest)
|
|
let t = days_of_week[weekday];
|
|
|
|
// color of text
|
|
let fg = self.params.header_fg;
|
|
|
|
let x = bounds.x + self.params.day_text_margin;
|
|
let y = bounds.center_y();
|
|
renderer.fill_text(text::Text {
|
|
content : t,
|
|
size: font_size,
|
|
bounds: Rectangle {x, y, ..bounds},
|
|
color: fg,
|
|
font: Default::default(),
|
|
horizontal_alignment: alignment::Horizontal::Left,
|
|
vertical_alignment: alignment::Vertical::Center,
|
|
});
|
|
}
|
|
}
|
|
|
|
fn draw_month_column(
|
|
&self,
|
|
renderer: &mut impl text::Renderer,
|
|
bounds: Rectangle,
|
|
) {
|
|
// dimensions of each box representing a month name
|
|
let h: f32 = bounds.height / 12.0;
|
|
|
|
for month in 0..12usize {
|
|
// where to place the month name
|
|
let month_name_bounds = Rectangle {
|
|
x: bounds.x,
|
|
y: (month as f32) * h + bounds.y + self.params.day_text_margin,
|
|
width: bounds.width,
|
|
height: h
|
|
};
|
|
|
|
// render month name
|
|
renderer.fill_text(text::Text {
|
|
content : MONTH_NAMES[month],
|
|
size: self.month_column_font_size,
|
|
bounds: Rectangle {
|
|
x: month_name_bounds.x + self.margin,
|
|
y: month_name_bounds.center_y(),
|
|
..month_name_bounds
|
|
},
|
|
color: self.params.day_text,
|
|
font: Default::default(),
|
|
horizontal_alignment: alignment::Horizontal::Left,
|
|
vertical_alignment: alignment::Vertical::Center,
|
|
});
|
|
}
|
|
}
|
|
|
|
fn draw_days(
|
|
&self,
|
|
renderer: &mut impl text::Renderer,
|
|
bounds: Rectangle,
|
|
) {
|
|
let size: Size = bounds.size();
|
|
let origin = bounds.position();
|
|
|
|
// font dimension
|
|
let font_size = renderer.default_size() as f32;
|
|
|
|
// dimensions of each box representing a day
|
|
let w: f32 = size.width / 42.0;
|
|
let h: f32 = size.height / 12.0;
|
|
|
|
for current_day in self.first_day.iter_days() {
|
|
if current_day.year() != self.first_day.year() {
|
|
break;
|
|
}
|
|
let month = current_day.month0();
|
|
let weekday = current_day.weekday().num_days_from_monday();
|
|
let first_day_of_month = current_day.with_day0(0).unwrap().weekday().num_days_from_monday();
|
|
let monthday = current_day.day0() + first_day_of_month;
|
|
let day_bounds = Rectangle {
|
|
x: (monthday as f32) * w + origin.x,
|
|
y: (month as f32) * h + origin.y,
|
|
width: w,
|
|
height: h
|
|
};
|
|
|
|
|
|
// label (day letter on row 0, day number on the rest)
|
|
let t = current_day.day().to_string();
|
|
let content = t.as_str();
|
|
|
|
// color of text
|
|
let fg = self.params.day_text;
|
|
|
|
// background color of the day cell
|
|
let bg_color = if current_day == Local::today().naive_local() {
|
|
self.params.day_today_bg
|
|
} else if weekday > 4 {
|
|
self.params.day_weekend_bg
|
|
} else {
|
|
Color::TRANSPARENT
|
|
};
|
|
|
|
// where to place the day content
|
|
let x = day_bounds.x + self.params.day_text_margin;
|
|
let y = day_bounds.y + self.params.day_text_margin;
|
|
|
|
renderer.fill_quad(renderer::Quad {
|
|
bounds: Rectangle {width: day_bounds.width + 0.5, height: day_bounds.height + 0.5, ..day_bounds},
|
|
border_radius: 0.0,
|
|
border_width: 1.0,
|
|
border_color: self.params.day_text_other_month,
|
|
},
|
|
bg_color);
|
|
|
|
// render day cell text
|
|
renderer.fill_text(text::Text {
|
|
content,
|
|
size: font_size,
|
|
bounds: Rectangle {x, y, ..day_bounds},
|
|
color: fg,
|
|
font: Default::default(),
|
|
horizontal_alignment: alignment::Horizontal::Left,
|
|
vertical_alignment: alignment::Vertical::Top,
|
|
});
|
|
}
|
|
}
|
|
|
|
fn compute_month_col_width(&self, renderer: &mut impl text::Renderer) -> f32 {
|
|
let mut max_max_font_width = 0.0;
|
|
for month_name in MONTH_NAMES {
|
|
let month_width = renderer.measure_width(month_name, self.month_column_font_size as u16, Default::default());
|
|
if month_width > max_max_font_width {
|
|
max_max_font_width = month_width;
|
|
}
|
|
}
|
|
return max_max_font_width;
|
|
}
|
|
|
|
} // CalendarYearView
|
|
|
|
impl<Message, Renderer> Widget<Message, Renderer> for CalendarYearView
|
|
where
|
|
Renderer: text::Renderer,
|
|
{
|
|
fn width(&self) -> Length {
|
|
Length::Shrink
|
|
}
|
|
|
|
fn height(&self) -> Length {
|
|
Length::Shrink
|
|
}
|
|
|
|
fn layout(
|
|
&self,
|
|
_renderer: &Renderer,
|
|
limits: &layout::Limits,
|
|
) -> layout::Node {
|
|
layout::Node::new(limits.max())
|
|
}
|
|
|
|
fn draw(
|
|
&self,
|
|
_state: &Tree,
|
|
renderer: &mut Renderer,
|
|
_theme: &Renderer::Theme,
|
|
_style: &renderer::Style,
|
|
layout: Layout<'_>,
|
|
_cursor_position: Point,
|
|
_viewport: &Rectangle,
|
|
) {
|
|
let size: Size = layout.bounds().size();
|
|
let origin = layout.bounds().position();
|
|
let margin: f32 = 20.0;
|
|
|
|
// week column only visible if there is enough space
|
|
let month_w = if self.params.show_weeks {
|
|
//self.month_column_width
|
|
self.compute_month_col_width(renderer) + self.margin
|
|
} else {
|
|
0.0
|
|
};
|
|
|
|
// font and header dimension
|
|
let font_size = renderer.default_size() as f32;
|
|
let first_row_h = font_size + margin;
|
|
|
|
// header
|
|
let x = origin.x;
|
|
let y = origin.y;
|
|
let width = size.width;
|
|
let height = first_row_h;
|
|
self.draw_header(renderer, Rectangle {x, y, width, height}, month_w);
|
|
|
|
// month column
|
|
if month_w > 0.0 && size.width > month_w {
|
|
let x = origin.x;
|
|
let y = origin.y + first_row_h;
|
|
let width = month_w;
|
|
let height = size.height - first_row_h;
|
|
self.draw_month_column(renderer, Rectangle{x, y, width, height});
|
|
}
|
|
|
|
// monthly calendar cells
|
|
let x = origin.x + month_w;
|
|
let y = origin.y + first_row_h;
|
|
let width = size.width - month_w;
|
|
let height = size.height - first_row_h;
|
|
self.draw_days(renderer, Rectangle{x, y, width, height});
|
|
}
|
|
}
|
|
|
|
impl<'a, Message, Renderer> From<CalendarYearView> for Element<'a, Message, Renderer>
|
|
where
|
|
Renderer: text::Renderer,
|
|
{
|
|
fn from(year_view: CalendarYearView) -> Self {
|
|
Self::new(year_view)
|
|
}
|
|
}
|