270 lines
8.4 KiB
Rust
270 lines
8.4 KiB
Rust
//! Show a circular progress indicator.
|
|
use super::animation::{Animation, Progress};
|
|
use super::style::StyleSheet;
|
|
use iced::advanced::widget::tree::{self, Tree};
|
|
use iced::advanced::{self, Clipboard, Layout, Shell, Widget, layout, renderer};
|
|
use iced::widget::canvas;
|
|
use iced::{Element, Event, Length, Radians, Rectangle, Renderer, Size, Vector, mouse, window};
|
|
|
|
use std::f32::consts::PI;
|
|
use std::time::Duration;
|
|
|
|
const MIN_ANGLE: Radians = Radians(PI / 8.0);
|
|
|
|
#[must_use]
|
|
pub struct Circular<Theme>
|
|
where
|
|
Theme: StyleSheet,
|
|
{
|
|
size: f32,
|
|
bar_height: f32,
|
|
style: Theme::Style,
|
|
cycle_duration: Duration,
|
|
period: Duration,
|
|
progress: Option<f32>,
|
|
}
|
|
|
|
impl<Theme> Circular<Theme>
|
|
where
|
|
Theme: StyleSheet,
|
|
{
|
|
/// Creates a new [`Circular`] with the given content.
|
|
pub fn new() -> Self {
|
|
Circular {
|
|
size: 40.0,
|
|
bar_height: 4.0,
|
|
style: Theme::Style::default(),
|
|
cycle_duration: Duration::from_millis(1500),
|
|
period: Duration::from_secs(2),
|
|
progress: None,
|
|
}
|
|
}
|
|
|
|
/// Sets the size of the [`Circular`].
|
|
pub fn size(mut self, size: f32) -> Self {
|
|
self.size = size;
|
|
self
|
|
}
|
|
|
|
/// Sets the bar height of the [`Circular`].
|
|
pub fn bar_height(mut self, bar_height: f32) -> Self {
|
|
self.bar_height = bar_height;
|
|
self
|
|
}
|
|
|
|
/// Sets the style variant of this [`Circular`].
|
|
pub fn style(mut self, style: Theme::Style) -> Self {
|
|
self.style = style;
|
|
self
|
|
}
|
|
|
|
/// Sets the cycle duration of this [`Circular`].
|
|
pub fn cycle_duration(mut self, duration: Duration) -> Self {
|
|
self.cycle_duration = duration / 2;
|
|
self
|
|
}
|
|
|
|
/// Sets the base period of this [`Circular`]. This is the duration that a full rotation
|
|
/// would take if the cycle duration were set to 0.0 (no expanding or contracting)
|
|
pub fn period(mut self, duration: Duration) -> Self {
|
|
self.period = duration;
|
|
self
|
|
}
|
|
|
|
/// Override the default behavior by providing a determinate progress value between `0.0` and `1.0`.
|
|
pub fn progress(mut self, progress: f32) -> Self {
|
|
self.progress = Some(progress.clamp(0.0, 1.0));
|
|
self
|
|
}
|
|
|
|
fn min_wrap(&self, track_radius: f32) -> (f32, f32) {
|
|
let cap_angle = self.bar_height / track_radius;
|
|
let gap = MIN_ANGLE.0.max(cap_angle);
|
|
((gap - cap_angle) / (2.0 * PI), 1.0 - gap / PI)
|
|
}
|
|
}
|
|
|
|
impl<Theme> Default for Circular<Theme>
|
|
where
|
|
Theme: StyleSheet,
|
|
{
|
|
fn default() -> Self {
|
|
Self::new()
|
|
}
|
|
}
|
|
|
|
#[derive(Default)]
|
|
struct State {
|
|
animation: Animation,
|
|
cache: canvas::Cache,
|
|
progress: Progress,
|
|
}
|
|
|
|
impl<Message, Theme> Widget<Message, Theme, Renderer> for Circular<Theme>
|
|
where
|
|
Message: Clone,
|
|
Theme: StyleSheet,
|
|
{
|
|
fn tag(&self) -> tree::Tag {
|
|
tree::Tag::of::<State>()
|
|
}
|
|
|
|
fn state(&self) -> tree::State {
|
|
tree::State::new(State::default())
|
|
}
|
|
|
|
fn size(&self) -> Size<Length> {
|
|
Size {
|
|
width: Length::Fixed(self.size),
|
|
height: Length::Fixed(self.size),
|
|
}
|
|
}
|
|
|
|
fn layout(
|
|
&mut self,
|
|
_tree: &mut Tree,
|
|
_renderer: &Renderer,
|
|
limits: &layout::Limits,
|
|
) -> layout::Node {
|
|
layout::atomic(limits, self.size, self.size)
|
|
}
|
|
|
|
fn update(
|
|
&mut self,
|
|
tree: &mut Tree,
|
|
event: &Event,
|
|
_layout: Layout<'_>,
|
|
_cursor: mouse::Cursor,
|
|
_renderer: &Renderer,
|
|
_clipboard: &mut dyn Clipboard,
|
|
shell: &mut Shell<'_, Message>,
|
|
_viewport: &Rectangle,
|
|
) {
|
|
let state = tree.state.downcast_mut::<State>();
|
|
if let Event::Window(window::Event::RedrawRequested(now)) = event {
|
|
if let Some(target) = self.progress {
|
|
if state.progress.update(target, *now) {
|
|
state.cache.clear();
|
|
shell.request_redraw();
|
|
}
|
|
} else {
|
|
let (_, wrap) = self.min_wrap(self.size / 2.0 - self.bar_height);
|
|
state.animation =
|
|
state
|
|
.animation
|
|
.timed_transition(self.cycle_duration, self.period, wrap, *now);
|
|
state.cache.clear();
|
|
shell.request_redraw();
|
|
}
|
|
}
|
|
}
|
|
|
|
fn draw(
|
|
&self,
|
|
tree: &Tree,
|
|
renderer: &mut Renderer,
|
|
theme: &Theme,
|
|
_style: &renderer::Style,
|
|
layout: Layout<'_>,
|
|
_cursor: mouse::Cursor,
|
|
_viewport: &Rectangle,
|
|
) {
|
|
use advanced::Renderer as _;
|
|
|
|
let state = tree.state.downcast_ref::<State>();
|
|
let bounds = layout.bounds();
|
|
let custom_style = Theme::appearance(theme, &self.style, self.progress.is_some(), true);
|
|
|
|
let geometry = state.cache.draw(renderer, bounds.size(), |frame| {
|
|
let track_radius = frame.width() / 2.0 - self.bar_height;
|
|
if track_radius <= 0.0 {
|
|
return;
|
|
}
|
|
let track_path = canvas::Path::circle(frame.center(), track_radius);
|
|
|
|
frame.stroke(
|
|
&track_path,
|
|
canvas::Stroke::default()
|
|
.with_color(custom_style.track_color)
|
|
.with_width(self.bar_height),
|
|
);
|
|
|
|
// Converts a track fraction to an angle in radians, with 0 being top of circle
|
|
let to_angle = |t: f32| t * 2.0 * PI - PI / 2.0;
|
|
|
|
let draw_cap = |frame: &mut canvas::Frame, t: f32, flip: bool| {
|
|
let angle = to_angle(t);
|
|
let center = frame.center() + Vector::new(angle.cos(), angle.sin()) * track_radius;
|
|
let (start_angle, end_angle) = if flip {
|
|
(angle - PI, angle)
|
|
} else {
|
|
(angle, angle + PI)
|
|
};
|
|
let mut builder = canvas::path::Builder::new();
|
|
builder.arc(canvas::path::Arc {
|
|
center,
|
|
radius: self.bar_height / 2.0,
|
|
start_angle: Radians(start_angle),
|
|
end_angle: Radians(end_angle),
|
|
});
|
|
frame.fill(&builder.build(), custom_style.bar_color);
|
|
};
|
|
|
|
let draw_bar = |frame: &mut canvas::Frame, start: f32, end: f32| {
|
|
let mut builder = canvas::path::Builder::new();
|
|
builder.arc(canvas::path::Arc {
|
|
center: frame.center(),
|
|
radius: track_radius,
|
|
start_angle: Radians(to_angle(start)),
|
|
end_angle: Radians(to_angle(end)),
|
|
});
|
|
frame.stroke(
|
|
&builder.build(),
|
|
canvas::Stroke::default()
|
|
.with_color(custom_style.bar_color)
|
|
.with_width(self.bar_height),
|
|
);
|
|
draw_cap(frame, end, false);
|
|
draw_cap(frame, start, true);
|
|
};
|
|
|
|
if self.progress.is_some() {
|
|
if let Some(border_color) = custom_style.border_color {
|
|
for radius_offset in [self.bar_height / 2.0, -(self.bar_height / 2.0)] {
|
|
let border_path =
|
|
canvas::Path::circle(frame.center(), track_radius + radius_offset);
|
|
frame.stroke(
|
|
&border_path,
|
|
canvas::Stroke::default()
|
|
.with_color(border_color)
|
|
.with_width(1.0),
|
|
);
|
|
}
|
|
}
|
|
draw_bar(frame, 0.0, state.progress.current);
|
|
} else {
|
|
let (min, wrap) = self.min_wrap(track_radius);
|
|
let (start, end) = state
|
|
.animation
|
|
.bar_positions(self.cycle_duration, min, wrap);
|
|
draw_bar(frame, start, end);
|
|
}
|
|
});
|
|
|
|
renderer.with_translation(Vector::new(bounds.x, bounds.y), |renderer| {
|
|
use iced::advanced::graphics::geometry::Renderer as _;
|
|
|
|
renderer.draw_geometry(geometry);
|
|
});
|
|
}
|
|
}
|
|
|
|
impl<'a, Message, Theme> From<Circular<Theme>> for Element<'a, Message, Theme, Renderer>
|
|
where
|
|
Message: Clone + 'a,
|
|
Theme: StyleSheet + 'a,
|
|
{
|
|
fn from(circular: Circular<Theme>) -> Self {
|
|
Self::new(circular)
|
|
}
|
|
}
|