me/iced
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Remove trait-specific draw logic in iced_native

Browse source
This commit is contained in:
Héctor Ramón Jiménez 2021-10-14 16:07:22 +07:00
parent 3aae45c191
commit 03b3493138
No known key found for this signature in database
GPG key ID: 140CC052C94F138E
71 changed files with 641 additions and 3126 deletions
Download patch file Download diff file Expand all files Collapse all files

25
native/src/widget/button.rs
View file

@ -248,17 +248,7 @@ where
layout: Layout<'_>,
cursor_position: Point,
_viewport: &Rectangle,
) -> Renderer::Output {
renderer.draw(
defaults,
layout.bounds(),
cursor_position,
self.on_press.is_none(),
self.state.is_pressed,
&self.style,
&self.content,
layout.children().next().unwrap(),
)
) {
}
fn hash_layout(&self, state: &mut Hasher) {
@ -289,19 +279,6 @@ pub trait Renderer: crate::Renderer + Sized {
/// The style supported by this renderer.
type Style: Default;
/// Draws a [`Button`].
fn draw<Message>(
&mut self,
defaults: &Self::Defaults,
bounds: Rectangle,
cursor_position: Point,
is_disabled: bool,
is_pressed: bool,
style: &Self::Style,
content: &Element<'_, Message, Self>,
content_layout: Layout<'_>,
) -> Self::Output;
}
impl<'a, Message, Renderer> From<Button<'a, Message, Renderer>>

66
native/src/widget/checkbox.rs
View file

@ -5,7 +5,6 @@ use crate::alignment::{self, Alignment};
use crate::event::{self, Event};
use crate::layout;
use crate::mouse;
use crate::row;
use crate::text;
use crate::touch;
use crate::{
@ -121,7 +120,7 @@ impl<Message, Renderer: self::Renderer + text::Renderer>
impl<Message, Renderer> Widget<Message, Renderer>
for Checkbox<Message, Renderer>
where
Renderer: self::Renderer + text::Renderer + row::Renderer,
Renderer: self::Renderer + text::Renderer,
{
fn width(&self) -> Length {
self.width
@ -187,36 +186,29 @@ where
layout: Layout<'_>,
cursor_position: Point,
_viewport: &Rectangle,
) -> Renderer::Output {
let bounds = layout.bounds();
let mut children = layout.children();
) {
// let bounds = layout.bounds();
// let mut children = layout.children();
let checkbox_layout = children.next().unwrap();
let label_layout = children.next().unwrap();
let checkbox_bounds = checkbox_layout.bounds();
// let checkbox_layout = children.next().unwrap();
// let label_layout = children.next().unwrap();
// let checkbox_bounds = checkbox_layout.bounds();
let label = text::Renderer::draw(
renderer,
defaults,
label_layout.bounds(),
&self.label,
self.text_size.unwrap_or(renderer.default_size()),
self.font,
self.text_color,
alignment::Horizontal::Left,
alignment::Vertical::Center,
);
// let label = text::Renderer::draw(
// renderer,
// defaults,
// label_layout.bounds(),
// &self.label,
// self.text_size.unwrap_or(renderer.default_size()),
// self.font,
// self.text_color,
// alignment::Horizontal::Left,
// alignment::Vertical::Center,
// );
let is_mouse_over = bounds.contains(cursor_position);
// let is_mouse_over = bounds.contains(cursor_position);
self::Renderer::draw(
renderer,
checkbox_bounds,
self.is_checked,
is_mouse_over,
label,
&self.style,
)
// TODO
}
fn hash_layout(&self, state: &mut Hasher) {
@ -242,28 +234,12 @@ pub trait Renderer: crate::Renderer {
/// The default spacing of a [`Checkbox`].
const DEFAULT_SPACING: u16;
/// Draws a [`Checkbox`].
///
/// It receives:
/// * the bounds of the [`Checkbox`]
/// * whether the [`Checkbox`] is selected or not
/// * whether the mouse is over the [`Checkbox`] or not
/// * the drawn label of the [`Checkbox`]
fn draw(
&mut self,
bounds: Rectangle,
is_checked: bool,
is_mouse_over: bool,
label: Self::Output,
style: &Self::Style,
) -> Self::Output;
}
impl<'a, Message, Renderer> From<Checkbox<Message, Renderer>>
for Element<'a, Message, Renderer>
where
Renderer: 'a + self::Renderer + text::Renderer + row::Renderer,
Renderer: 'a + self::Renderer + text::Renderer,
Message: 'a,
{
fn from(

37
native/src/widget/column.rs
View file

@ -105,7 +105,7 @@ impl<'a, Message, Renderer> Column<'a, Message, Renderer> {
impl<'a, Message, Renderer> Widget<Message, Renderer>
for Column<'a, Message, Renderer>
where
Renderer: self::Renderer,
Renderer: crate::Renderer,
{
fn width(&self) -> Length {
self.width
@ -169,14 +169,8 @@ where
layout: Layout<'_>,
cursor_position: Point,
viewport: &Rectangle,
) -> Renderer::Output {
renderer.draw(
defaults,
&self.children,
layout,
cursor_position,
viewport,
)
) {
// TODO
}
fn hash_layout(&self, state: &mut Hasher) {
@ -208,33 +202,10 @@ where
}
}
/// The renderer of a [`Column`].
///
/// Your [renderer] will need to implement this trait before being
/// able to use a [`Column`] in your user interface.
///
/// [renderer]: crate::renderer
pub trait Renderer: crate::Renderer + Sized {
/// Draws a [`Column`].
///
/// It receives:
/// - the children of the [`Column`]
/// - the [`Layout`] of the [`Column`] and its children
/// - the cursor position
fn draw<Message>(
&mut self,
defaults: &Self::Defaults,
content: &[Element<'_, Message, Self>],
layout: Layout<'_>,
cursor_position: Point,
viewport: &Rectangle,
) -> Self::Output;
}
impl<'a, Message, Renderer> From<Column<'a, Message, Renderer>>
for Element<'a, Message, Renderer>
where
Renderer: 'a + self::Renderer,
Renderer: 'a + crate::Renderer,
Message: 'a,
{
fn from(

24
native/src/widget/container.rs
View file

@ -179,16 +179,8 @@ where
layout: Layout<'_>,
cursor_position: Point,
viewport: &Rectangle,
) -> Renderer::Output {
renderer.draw(
defaults,
layout.bounds(),
cursor_position,
viewport,
&self.style,
&self.content,
layout.children().next().unwrap(),
)
) {
// TODO
}
fn hash_layout(&self, state: &mut Hasher) {
@ -221,18 +213,6 @@ where
pub trait Renderer: crate::Renderer {
/// The style supported by this renderer.
type Style: Default;
/// Draws a [`Container`].
fn draw<Message>(
&mut self,
defaults: &Self::Defaults,
bounds: Rectangle,
cursor_position: Point,
viewport: &Rectangle,
style: &Self::Style,
content: &Element<'_, Message, Self>,
content_layout: Layout<'_>,
) -> Self::Output;
}
impl<'a, Message, Renderer> From<Container<'a, Message, Renderer>>

7
native/src/widget/image.rs
View file

@ -96,8 +96,8 @@ where
layout: Layout<'_>,
_cursor_position: Point,
_viewport: &Rectangle,
) -> Renderer::Output {
renderer.draw(self.handle.clone(), layout)
) {
// TODO
}
fn hash_layout(&self, state: &mut Hasher) {
@ -225,9 +225,6 @@ impl std::fmt::Debug for Data {
pub trait Renderer: crate::Renderer {
/// Returns the dimensions of an [`Image`] located on the given path.
fn dimensions(&self, handle: &Handle) -> (u32, u32);
/// Draws an [`Image`].
fn draw(&mut self, handle: Handle, layout: Layout<'_>) -> Self::Output;
}
impl<'a, Message, Renderer> From<Image> for Element<'a, Message, Renderer>

47
native/src/widget/image/viewer.rs
View file

@ -88,7 +88,7 @@ impl<'a> Viewer<'a> {
/// will be respected.
fn image_size<Renderer>(&self, renderer: &Renderer, bounds: Size) -> Size
where
Renderer: self::Renderer + image::Renderer,
Renderer: image::Renderer,
{
let (width, height) = renderer.dimensions(&self.handle);
@ -115,7 +115,7 @@ impl<'a> Viewer<'a> {
impl<'a, Message, Renderer> Widget<Message, Renderer> for Viewer<'a>
where
Renderer: self::Renderer + image::Renderer,
Renderer: image::Renderer,
{
fn width(&self) -> Length {
self.width
@ -287,7 +287,7 @@ where
layout: Layout<'_>,
cursor_position: Point,
_viewport: &Rectangle,
) -> Renderer::Output {
) {
let bounds = layout.bounds();
let image_size = self.image_size(renderer, bounds.size());
@ -302,16 +302,6 @@ where
};
let is_mouse_over = bounds.contains(cursor_position);
self::Renderer::draw(
renderer,
&self.state,
bounds,
image_size,
translation,
self.handle.clone(),
is_mouse_over,
)
}
fn hash_layout(&self, state: &mut Hasher) {
@ -373,38 +363,9 @@ impl State {
}
}
/// The renderer of an [`Viewer`].
///
/// Your [renderer] will need to implement this trait before being
/// able to use a [`Viewer`] in your user interface.
///
/// [renderer]: crate::renderer
pub trait Renderer: crate::Renderer + Sized {
/// Draws the [`Viewer`].
///
/// It receives:
/// - the [`State`] of the [`Viewer`]
/// - the bounds of the [`Viewer`] widget
/// - the [`Size`] of the scaled [`Viewer`] image
/// - the translation of the clipped image
/// - the [`Handle`] to the underlying image
/// - whether the mouse is over the [`Viewer`] or not
///
/// [`Handle`]: image::Handle
fn draw(
&mut self,
state: &State,
bounds: Rectangle,
image_size: Size,
translation: Vector,
handle: image::Handle,
is_mouse_over: bool,
) -> Self::Output;
}
impl<'a, Message, Renderer> From<Viewer<'a>> for Element<'a, Message, Renderer>
where
Renderer: 'a + self::Renderer + image::Renderer,
Renderer: 'a + image::Renderer,
Message: 'a,
{
fn from(viewer: Viewer<'a>) -> Element<'a, Message, Renderer> {

152
native/src/widget/pane_grid.rs
View file

@ -32,7 +32,6 @@ use crate::event::{self, Event};
use crate::layout;
use crate::mouse;
use crate::overlay;
use crate::row;
use crate::touch;
use crate::{
Clipboard, Element, Hasher, Layout, Length, Point, Rectangle, Size, Vector,
@ -480,66 +479,56 @@ where
layout: Layout<'_>,
cursor_position: Point,
viewport: &Rectangle,
) -> Renderer::Output {
let picked_split = self
.state
.picked_split()
.and_then(|(split, axis)| {
let bounds = layout.bounds();
) {
// let picked_split = self
// .state
// .picked_split()
// .and_then(|(split, axis)| {
// let bounds = layout.bounds();
let splits = self
.state
.split_regions(f32::from(self.spacing), bounds.size());
// let splits = self
// .state
// .split_regions(f32::from(self.spacing), bounds.size());
let (_axis, region, ratio) = splits.get(&split)?;
// let (_axis, region, ratio) = splits.get(&split)?;
let region = axis.split_line_bounds(
*region,
*ratio,
f32::from(self.spacing),
);
// let region = axis.split_line_bounds(
// *region,
// *ratio,
// f32::from(self.spacing),
// );
Some((axis, region + Vector::new(bounds.x, bounds.y), true))
})
.or_else(|| match self.on_resize {
Some((leeway, _)) => {
let bounds = layout.bounds();
// Some((axis, region + Vector::new(bounds.x, bounds.y), true))
// })
// .or_else(|| match self.on_resize {
// Some((leeway, _)) => {
// let bounds = layout.bounds();
let relative_cursor = Point::new(
cursor_position.x - bounds.x,
cursor_position.y - bounds.y,
);
// let relative_cursor = Point::new(
// cursor_position.x - bounds.x,
// cursor_position.y - bounds.y,
// );
let splits = self
.state
.split_regions(f32::from(self.spacing), bounds.size());
// let splits = self
// .state
// .split_regions(f32::from(self.spacing), bounds.size());
let (_split, axis, region) = hovered_split(
splits.iter(),
f32::from(self.spacing + leeway),
relative_cursor,
)?;
// let (_split, axis, region) = hovered_split(
// splits.iter(),
// f32::from(self.spacing + leeway),
// relative_cursor,
// )?;
Some((
axis,
region + Vector::new(bounds.x, bounds.y),
false,
))
}
None => None,
});
// Some((
// axis,
// region + Vector::new(bounds.x, bounds.y),
// false,
// ))
// }
// None => None,
// });
self::Renderer::draw(
renderer,
defaults,
&self.elements,
self.state.picked_pane(),
picked_split,
layout,
&self.style,
cursor_position,
viewport,
)
// TODO
}
fn hash_layout(&self, state: &mut Hasher) {
@ -578,69 +567,12 @@ where
pub trait Renderer: crate::Renderer + container::Renderer + Sized {
/// The style supported by this renderer.
type Style: Default;
/// Draws a [`PaneGrid`].
///
/// It receives:
/// - the elements of the [`PaneGrid`]
/// - the [`Pane`] that is currently being dragged
/// - the [`Axis`] that is currently being resized
/// - the [`Layout`] of the [`PaneGrid`] and its elements
/// - the cursor position
fn draw<Message>(
&mut self,
defaults: &Self::Defaults,
content: &[(Pane, Content<'_, Message, Self>)],
dragging: Option<(Pane, Point)>,
resizing: Option<(Axis, Rectangle, bool)>,
layout: Layout<'_>,
style: &<Self as self::Renderer>::Style,
cursor_position: Point,
viewport: &Rectangle,
) -> Self::Output;
/// Draws a [`Pane`].
///
/// It receives:
/// - the [`TitleBar`] of the [`Pane`], if any
/// - the [`Content`] of the [`Pane`]
/// - the [`Layout`] of the [`Pane`] and its elements
/// - the cursor position
fn draw_pane<Message>(
&mut self,
defaults: &Self::Defaults,
bounds: Rectangle,
style: &<Self as container::Renderer>::Style,
title_bar: Option<(&TitleBar<'_, Message, Self>, Layout<'_>)>,
body: (&Element<'_, Message, Self>, Layout<'_>),
cursor_position: Point,
viewport: &Rectangle,
) -> Self::Output;
/// Draws a [`TitleBar`].
///
/// It receives:
/// - the bounds, style of the [`TitleBar`]
/// - the style of the [`TitleBar`]
/// - the content of the [`TitleBar`] with its layout
/// - the controls of the [`TitleBar`] with their [`Layout`], if any
/// - the cursor position
fn draw_title_bar<Message>(
&mut self,
defaults: &Self::Defaults,
bounds: Rectangle,
style: &<Self as container::Renderer>::Style,
content: (&Element<'_, Message, Self>, Layout<'_>),
controls: Option<(&Element<'_, Message, Self>, Layout<'_>)>,
cursor_position: Point,
viewport: &Rectangle,
) -> Self::Output;
}
impl<'a, Message, Renderer> From<PaneGrid<'a, Message, Renderer>>
for Element<'a, Message, Renderer>
where
Renderer: 'a + self::Renderer + row::Renderer,
Renderer: 'a + self::Renderer,
Message: 'a,
{
fn from(

51
native/src/widget/pane_grid/content.rs
View file

@ -61,32 +61,33 @@ where
layout: Layout<'_>,
cursor_position: Point,
viewport: &Rectangle,
) -> Renderer::Output {
if let Some(title_bar) = &self.title_bar {
let mut children = layout.children();
let title_bar_layout = children.next().unwrap();
let body_layout = children.next().unwrap();
) {
// TODO
// if let Some(title_bar) = &self.title_bar {
// let mut children = layout.children();
// let title_bar_layout = children.next().unwrap();
// let body_layout = children.next().unwrap();
renderer.draw_pane(
defaults,
layout.bounds(),
&self.style,
Some((title_bar, title_bar_layout)),
(&self.body, body_layout),
cursor_position,
viewport,
)
} else {
renderer.draw_pane(
defaults,
layout.bounds(),
&self.style,
None,
(&self.body, layout),
cursor_position,
viewport,
)
}
// renderer.draw_pane(
// defaults,
// layout.bounds(),
// &self.style,
// Some((title_bar, title_bar_layout)),
// (&self.body, body_layout),
// cursor_position,
// viewport,
// )
// } else {
// renderer.draw_pane(
// defaults,
// layout.bounds(),
// &self.style,
// None,
// (&self.body, layout),
// cursor_position,
// viewport,
// )
// }
}
/// Returns whether the [`Content`] with the given [`Layout`] can be picked

48
native/src/widget/pane_grid/title_bar.rs
View file

@ -90,34 +90,34 @@ where
cursor_position: Point,
viewport: &Rectangle,
show_controls: bool,
) -> Renderer::Output {
let mut children = layout.children();
let padded = children.next().unwrap();
) {
// let mut children = layout.children();
// let padded = children.next().unwrap();
let mut children = padded.children();
let title_layout = children.next().unwrap();
// let mut children = padded.children();
// let title_layout = children.next().unwrap();
let controls = if let Some(controls) = &self.controls {
let controls_layout = children.next().unwrap();
// let controls = if let Some(controls) = &self.controls {
// let controls_layout = children.next().unwrap();
if show_controls || self.always_show_controls {
Some((controls, controls_layout))
} else {
None
}
} else {
None
};
// if show_controls || self.always_show_controls {
// Some((controls, controls_layout))
// } else {
// None
// }
// } else {
// None
// };
renderer.draw_title_bar(
defaults,
layout.bounds(),
&self.style,
(&self.content, title_layout),
controls,
cursor_position,
viewport,
)
// renderer.draw_title_bar(
// defaults,
// layout.bounds(),
// &self.style,
// (&self.content, title_layout),
// controls,
// cursor_position,
// viewport,
// )
}
/// Returns whether the mouse cursor is over the pick area of the

27
native/src/widget/pick_list.rs
View file

@ -327,18 +327,8 @@ where
layout: Layout<'_>,
cursor_position: Point,
_viewport: &Rectangle,
) -> Renderer::Output {
self::Renderer::draw(
renderer,
layout.bounds(),
cursor_position,
self.selected.as_ref().map(ToString::to_string),
self.placeholder.as_ref().map(String::as_str),
self.padding,
self.text_size.unwrap_or(renderer.default_size()),
self.font,
&self.style,
)
) {
// TODO
}
fn overlay(
@ -387,19 +377,6 @@ pub trait Renderer: text::Renderer + menu::Renderer {
fn menu_style(
style: &<Self as Renderer>::Style,
) -> <Self as menu::Renderer>::Style;
/// Draws a [`PickList`].
fn draw(
&mut self,
bounds: Rectangle,
cursor_position: Point,
selected: Option<String>,
placeholder: Option<&str>,
padding: Padding,
text_size: u16,
font: Self::Font,
style: &<Self as Renderer>::Style,
) -> Self::Output;
}
impl<'a, T: 'a, Message, Renderer> Into<Element<'a, Message, Renderer>>

25
native/src/widget/progress_bar.rs
View file

@ -97,13 +97,8 @@ where
layout: Layout<'_>,
_cursor_position: Point,
_viewport: &Rectangle,
) -> Renderer::Output {
renderer.draw(
layout.bounds(),
self.range.clone(),
self.value,
&self.style,
)
) {
// TODO
}
fn hash_layout(&self, state: &mut Hasher) {
@ -127,22 +122,6 @@ pub trait Renderer: crate::Renderer {
/// The default height of a [`ProgressBar`].
const DEFAULT_HEIGHT: u16;
/// Draws a [`ProgressBar`].
///
/// It receives:
/// * the bounds of the [`ProgressBar`]
/// * the range of values of the [`ProgressBar`]
/// * the current value of the [`ProgressBar`]
/// * maybe a specific background of the [`ProgressBar`]
/// * maybe a specific active color of the [`ProgressBar`]
fn draw(
&self,
bounds: Rectangle,
range: RangeInclusive<f32>,
value: f32,
style: &Self::Style,
) -> Self::Output;
}
impl<'a, Message, Renderer> From<ProgressBar<Renderer>>

74
native/src/widget/radio.rs
View file

@ -5,7 +5,6 @@ use crate::alignment::{self, Alignment};
use crate::event::{self, Event};
use crate::layout;
use crate::mouse;
use crate::row;
use crate::text;
use crate::touch;
use crate::{
@ -136,7 +135,7 @@ where
impl<Message, Renderer> Widget<Message, Renderer> for Radio<Message, Renderer>
where
Message: Clone,
Renderer: self::Renderer + text::Renderer + row::Renderer,
Renderer: self::Renderer + text::Renderer,
{
fn width(&self) -> Length {
self.width
@ -199,36 +198,37 @@ where
layout: Layout<'_>,
cursor_position: Point,
_viewport: &Rectangle,
) -> Renderer::Output {
let bounds = layout.bounds();
let mut children = layout.children();
) {
// TODO
// let bounds = layout.bounds();
// let mut children = layout.children();
let radio_layout = children.next().unwrap();
let label_layout = children.next().unwrap();
let radio_bounds = radio_layout.bounds();
// let radio_layout = children.next().unwrap();
// let label_layout = children.next().unwrap();
// let radio_bounds = radio_layout.bounds();
let label = text::Renderer::draw(
renderer,
defaults,
label_layout.bounds(),
&self.label,
self.text_size.unwrap_or(renderer.default_size()),
self.font,
self.text_color,
alignment::Horizontal::Left,
alignment::Vertical::Center,
);
// let label = text::Renderer::draw(
// renderer,
// defaults,
// label_layout.bounds(),
// &self.label,
// self.text_size.unwrap_or(renderer.default_size()),
// self.font,
// self.text_color,
// alignment::Horizontal::Left,
// alignment::Vertical::Center,
// );
let is_mouse_over = bounds.contains(cursor_position);
// let is_mouse_over = bounds.contains(cursor_position);
self::Renderer::draw(
renderer,
radio_bounds,
self.is_selected,
is_mouse_over,
label,
&self.style,
)
// self::Renderer::draw(
// renderer,
// radio_bounds,
// self.is_selected,
// is_mouse_over,
// label,
// &self.style,
// )
}
fn hash_layout(&self, state: &mut Hasher) {
@ -254,29 +254,13 @@ pub trait Renderer: crate::Renderer {
/// The default spacing of a [`Radio`] button.
const DEFAULT_SPACING: u16;
/// Draws a [`Radio`] button.
///
/// It receives:
/// * the bounds of the [`Radio`]
/// * whether the [`Radio`] is selected or not
/// * whether the mouse is over the [`Radio`] or not
/// * the drawn label of the [`Radio`]
fn draw(
&mut self,
bounds: Rectangle,
is_selected: bool,
is_mouse_over: bool,
label: Self::Output,
style: &Self::Style,
) -> Self::Output;
}
impl<'a, Message, Renderer> From<Radio<Message, Renderer>>
for Element<'a, Message, Renderer>
where
Message: 'a + Clone,
Renderer: 'a + self::Renderer + row::Renderer + text::Renderer,
Renderer: 'a + self::Renderer + text::Renderer,
{
fn from(radio: Radio<Message, Renderer>) -> Element<'a, Message, Renderer> {
Element::new(radio)

44
native/src/widget/row.rs
View file

@ -104,7 +104,7 @@ impl<'a, Message, Renderer> Row<'a, Message, Renderer> {
impl<'a, Message, Renderer> Widget<Message, Renderer>
for Row<'a, Message, Renderer>
where
Renderer: self::Renderer,
Renderer: crate::Renderer,
{
fn width(&self) -> Length {
self.width
@ -168,14 +168,15 @@ where
layout: Layout<'_>,
cursor_position: Point,
viewport: &Rectangle,
) -> Renderer::Output {
renderer.draw(
defaults,
&self.children,
layout,
cursor_position,
viewport,
)
) {
// TODO
// renderer.draw(
// defaults,
// &self.children,
// layout,
// cursor_position,
// viewport,
// )
}
fn hash_layout(&self, state: &mut Hasher) {
@ -207,33 +208,10 @@ where
}
}
/// The renderer of a [`Row`].
///
/// Your [renderer] will need to implement this trait before being
/// able to use a [`Row`] in your user interface.
///
/// [renderer]: crate::renderer
pub trait Renderer: crate::Renderer + Sized {
/// Draws a [`Row`].
///
/// It receives:
/// - the children of the [`Row`]
/// - the [`Layout`] of the [`Row`] and its children
/// - the cursor position
fn draw<Message>(
&mut self,
defaults: &Self::Defaults,
children: &[Element<'_, Message, Self>],
layout: Layout<'_>,
cursor_position: Point,
viewport: &Rectangle,
) -> Self::Output;
}
impl<'a, Message, Renderer> From<Row<'a, Message, Renderer>>
for Element<'a, Message, Renderer>
where
Renderer: 'a + self::Renderer,
Renderer: 'a + crate::Renderer,
Message: 'a,
{
fn from(row: Row<'a, Message, Renderer>) -> Element<'a, Message, Renderer> {

18
native/src/widget/rule.rs
View file

@ -72,8 +72,9 @@ where
layout: Layout<'_>,
_cursor_position: Point,
_viewport: &Rectangle,
) -> Renderer::Output {
renderer.draw(layout.bounds(), &self.style, self.is_horizontal)
) {
// TODO
// renderer.draw(layout.bounds(), &self.style, self.is_horizontal)
}
fn hash_layout(&self, state: &mut Hasher) {
@ -89,19 +90,6 @@ where
pub trait Renderer: crate::Renderer {
/// The style supported by this renderer.
type Style: Default;
/// Draws a [`Rule`].
///
/// It receives:
/// * the bounds of the [`Rule`]
/// * the style of the [`Rule`]
/// * whether the [`Rule`] is horizontal (true) or vertical (false)
fn draw(
&mut self,
bounds: Rectangle,
style: &Self::Style,
is_horizontal: bool,
) -> Self::Output;
}
impl<'a, Message, Renderer> From<Rule<Renderer>>

111
native/src/widget/scrollable.rs
View file

@ -1,5 +1,4 @@
//! Navigate an endless amount of content with a scrollbar.
use crate::column;
use crate::event::{self, Event};
use crate::layout;
use crate::mouse;
@ -381,57 +380,45 @@ where
layout: Layout<'_>,
cursor_position: Point,
_viewport: &Rectangle,
) -> Renderer::Output {
let bounds = layout.bounds();
let content_layout = layout.children().next().unwrap();
let content_bounds = content_layout.bounds();
let offset = self.state.offset(bounds, content_bounds);
let scrollbar = renderer.scrollbar(
bounds,
content_bounds,
offset,
self.scrollbar_width,
self.scrollbar_margin,
self.scroller_width,
);
) {
// TODO
// let bounds = layout.bounds();
// let content_layout = layout.children().next().unwrap();
// let content_bounds = content_layout.bounds();
// let offset = self.state.offset(bounds, content_bounds);
// let scrollbar = renderer.scrollbar(
// bounds,
// content_bounds,
// offset,
// self.scrollbar_width,
// self.scrollbar_margin,
// self.scroller_width,
// );
let is_mouse_over = bounds.contains(cursor_position);
let is_mouse_over_scrollbar = scrollbar
.as_ref()
.map(|scrollbar| scrollbar.is_mouse_over(cursor_position))
.unwrap_or(false);
// let is_mouse_over = bounds.contains(cursor_position);
// let is_mouse_over_scrollbar = scrollbar
// .as_ref()
// .map(|scrollbar| scrollbar.is_mouse_over(cursor_position))
// .unwrap_or(false);
let content = {
let cursor_position = if is_mouse_over && !is_mouse_over_scrollbar {
Point::new(cursor_position.x, cursor_position.y + offset as f32)
} else {
Point::new(cursor_position.x, -1.0)
};
// let content = {
// let cursor_position = if is_mouse_over && !is_mouse_over_scrollbar {
// Point::new(cursor_position.x, cursor_position.y + offset as f32)
// } else {
// Point::new(cursor_position.x, -1.0)
// };
self.content.draw(
renderer,
defaults,
content_layout,
cursor_position,
&Rectangle {
y: bounds.y + offset as f32,
..bounds
},
)
};
self::Renderer::draw(
renderer,
&self.state,
bounds,
content_layout.bounds(),
is_mouse_over,
is_mouse_over_scrollbar,
scrollbar,
offset,
&self.style,
content,
)
// self.content.draw(
// renderer,
// defaults,
// content_layout,
// cursor_position,
// &Rectangle {
// y: bounds.y + offset as f32,
// ..bounds
// },
// )
// };
}
fn hash_layout(&self, state: &mut Hasher) {
@ -635,7 +622,7 @@ pub struct Scroller {
/// able to use a [`Scrollable`] in your user interface.
///
/// [renderer]: crate::renderer
pub trait Renderer: column::Renderer + Sized {
pub trait Renderer: crate::Renderer + Sized {
/// The style supported by this renderer.
type Style: Default;
@ -650,30 +637,6 @@ pub trait Renderer: column::Renderer + Sized {
scrollbar_margin: u16,
scroller_width: u16,
) -> Option<Scrollbar>;
/// Draws the [`Scrollable`].
///
/// It receives:
/// - the [`State`] of the [`Scrollable`]
/// - the bounds of the [`Scrollable`] widget
/// - the bounds of the [`Scrollable`] content
/// - whether the mouse is over the [`Scrollable`] or not
/// - whether the mouse is over the [`Scrollbar`] or not
/// - a optional [`Scrollbar`] to be rendered
/// - the scrolling offset
/// - the drawn content
fn draw(
&mut self,
scrollable: &State,
bounds: Rectangle,
content_bounds: Rectangle,
is_mouse_over: bool,
is_mouse_over_scrollbar: bool,
scrollbar: Option<Scrollbar>,
offset: u32,
style: &Self::Style,
content: Self::Output,
) -> Self::Output;
}
impl<'a, Message, Renderer> From<Scrollable<'a, Message, Renderer>>

41
native/src/widget/slider.rs
View file

@ -250,18 +250,19 @@ where
layout: Layout<'_>,
cursor_position: Point,
_viewport: &Rectangle,
) -> Renderer::Output {
let start = *self.range.start();
let end = *self.range.end();
) {
// TODO
// let start = *self.range.start();
// let end = *self.range.end();
renderer.draw(
layout.bounds(),
cursor_position,
start.into() as f32..=end.into() as f32,
self.value.into() as f32,
self.state.is_dragging,
&self.style,
)
// renderer.draw(
// layout.bounds(),
// cursor_position,
// start.into() as f32..=end.into() as f32,
// self.value.into() as f32,
// self.state.is_dragging,
// &self.style,
// )
}
fn hash_layout(&self, state: &mut Hasher) {
@ -284,24 +285,6 @@ pub trait Renderer: crate::Renderer {
/// The default height of a [`Slider`].
const DEFAULT_HEIGHT: u16;
/// Draws a [`Slider`].
///
/// It receives:
/// * the current cursor position
/// * the bounds of the [`Slider`]
/// * the local state of the [`Slider`]
/// * the range of values of the [`Slider`]
/// * the current value of the [`Slider`]
fn draw(
&mut self,
bounds: Rectangle,
cursor_position: Point,
range: RangeInclusive<f32>,
value: f32,
is_dragging: bool,
style: &Self::Style,
) -> Self::Output;
}
impl<'a, T, Message, Renderer> From<Slider<'a, T, Message, Renderer>>

15
native/src/widget/space.rs
View file

@ -39,7 +39,7 @@ impl Space {
impl<Message, Renderer> Widget<Message, Renderer> for Space
where
Renderer: self::Renderer,
Renderer: crate::Renderer,
{
fn width(&self) -> Length {
self.width
@ -66,8 +66,7 @@ where
layout: Layout<'_>,
_cursor_position: Point,
_viewport: &Rectangle,
) -> Renderer::Output {
renderer.draw(layout.bounds())
) {
}
fn hash_layout(&self, state: &mut Hasher) {
@ -78,17 +77,9 @@ where
}
}
/// The renderer of an amount of [`Space`].
pub trait Renderer: crate::Renderer {
/// Draws an amount of empty [`Space`].
///
/// You should most likely return an empty primitive here.
fn draw(&mut self, bounds: Rectangle) -> Self::Output;
}
impl<'a, Message, Renderer> From<Space> for Element<'a, Message, Renderer>
where
Renderer: self::Renderer,
Renderer: crate::Renderer,
Message: 'a,
{
fn from(space: Space) -> Element<'a, Message, Renderer> {

8
native/src/widget/svg.rs
View file

@ -94,8 +94,9 @@ where
layout: Layout<'_>,
_cursor_position: Point,
_viewport: &Rectangle,
) -> Renderer::Output {
renderer.draw(self.handle.clone(), layout)
) {
// TODO
// renderer.draw(self.handle.clone(), layout)
}
fn hash_layout(&self, state: &mut Hasher) {
@ -187,9 +188,6 @@ impl std::fmt::Debug for Data {
pub trait Renderer: crate::Renderer {
/// Returns the default dimensions of an [`Svg`] for the given [`Handle`].
fn dimensions(&self, handle: &Handle) -> (u32, u32);
/// Draws an [`Svg`].
fn draw(&mut self, handle: Handle, layout: Layout<'_>) -> Self::Output;
}
impl<'a, Message, Renderer> From<Svg> for Element<'a, Message, Renderer>

40
native/src/widget/text.rs
View file

@ -133,22 +133,13 @@ where
fn draw(
&self,
renderer: &mut Renderer,
defaults: &Renderer::Defaults,
layout: Layout<'_>,
_renderer: &mut Renderer,
_defaults: &Renderer::Defaults,
_layout: Layout<'_>,
_cursor_position: Point,
_viewport: &Rectangle,
) -> Renderer::Output {
renderer.draw(
defaults,
layout.bounds(),
&self.content,
self.size.unwrap_or(renderer.default_size()),
self.font,
self.color,
self.horizontal_alignment,
self.vertical_alignment,
)
) {
// TODO
}
fn hash_layout(&self, state: &mut Hasher) {
@ -201,27 +192,6 @@ pub trait Renderer: crate::Renderer {
point: Point,
nearest_only: bool,
) -> Option<Hit>;
/// Draws a [`Text`] fragment.
///
/// It receives:
/// * the bounds of the [`Text`]
/// * the contents of the [`Text`]
/// * the size of the [`Text`]
/// * the color of the [`Text`]
/// * the [`HorizontalAlignment`] of the [`Text`]
/// * the [`VerticalAlignment`] of the [`Text`]
fn draw(
&mut self,
defaults: &Self::Defaults,
bounds: Rectangle,
content: &str,
size: u16,
font: Self::Font,
color: Option<Color>,
horizontal_alignment: alignment::Horizontal,
vertical_alignment: alignment::Vertical,
) -> Self::Output;
}
impl<'a, Message, Renderer> From<Text<Renderer>>

87
native/src/widget/text_input.rs
View file

@ -170,38 +170,39 @@ where
layout: Layout<'_>,
cursor_position: Point,
value: Option<&Value>,
) -> Renderer::Output {
let value = value.unwrap_or(&self.value);
let bounds = layout.bounds();
let text_bounds = layout.children().next().unwrap().bounds();
) {
// TODO
// let value = value.unwrap_or(&self.value);
// let bounds = layout.bounds();
// let text_bounds = layout.children().next().unwrap().bounds();
if self.is_secure {
self::Renderer::draw(
renderer,
bounds,
text_bounds,
cursor_position,
self.font,
self.size.unwrap_or(renderer.default_size()),
&self.placeholder,
&value.secure(),
&self.state,
&self.style,
)
} else {
self::Renderer::draw(
renderer,
bounds,
text_bounds,
cursor_position,
self.font,
self.size.unwrap_or(renderer.default_size()),
&self.placeholder,
value,
&self.state,
&self.style,
)
}
// if self.is_secure {
// self::Renderer::draw(
// renderer,
// bounds,
// text_bounds,
// cursor_position,
// self.font,
// self.size.unwrap_or(renderer.default_size()),
// &self.placeholder,
// &value.secure(),
// &self.state,
// &self.style,
// )
// } else {
// self::Renderer::draw(
// renderer,
// bounds,
// text_bounds,
// cursor_position,
// self.font,
// self.size.unwrap_or(renderer.default_size()),
// &self.placeholder,
// value,
// &self.state,
// &self.style,
// )
// }
}
}
@ -630,7 +631,7 @@ where
layout: Layout<'_>,
cursor_position: Point,
_viewport: &Rectangle,
) -> Renderer::Output {
) {
self.draw(renderer, layout, cursor_position, None)
}
@ -673,28 +674,6 @@ pub trait Renderer: text::Renderer + Sized {
state: &State,
) -> f32;
/// Draws a [`TextInput`].
///
/// It receives:
/// - the bounds of the [`TextInput`]
/// - the bounds of the text (i.e. the current value)
/// - the cursor position
/// - the placeholder to show when the value is empty
/// - the current [`Value`]
/// - the current [`State`]
fn draw(
&mut self,
bounds: Rectangle,
text_bounds: Rectangle,
cursor_position: Point,
font: Self::Font,
size: u16,
placeholder: &str,
value: &Value,
state: &State,
style: &Self::Style,
) -> Self::Output;
/// Computes the position of the text cursor at the given X coordinate of
/// a [`TextInput`].
fn find_cursor_position(

78
native/src/widget/toggler.rs
View file

@ -5,7 +5,6 @@ use crate::alignment;
use crate::event;
use crate::layout;
use crate::mouse;
use crate::row;
use crate::text;
use crate::{
Alignment, Clipboard, Element, Event, Hasher, Layout, Length, Point,
@ -119,7 +118,7 @@ impl<Message, Renderer: self::Renderer + text::Renderer>
impl<Message, Renderer> Widget<Message, Renderer> for Toggler<Message, Renderer>
where
Renderer: self::Renderer + text::Renderer + row::Renderer,
Renderer: self::Renderer + text::Renderer,
{
fn width(&self) -> Length {
self.width
@ -190,43 +189,35 @@ where
layout: Layout<'_>,
cursor_position: Point,
_viewport: &Rectangle,
) -> Renderer::Output {
let bounds = layout.bounds();
let mut children = layout.children();
) {
// TODO
// let bounds = layout.bounds();
// let mut children = layout.children();
let label = match &self.label {
Some(label) => {
let label_layout = children.next().unwrap();
// let label = match &self.label {
// Some(label) => {
// let label_layout = children.next().unwrap();
Some(text::Renderer::draw(
renderer,
defaults,
label_layout.bounds(),
&label,
self.text_size.unwrap_or(renderer.default_size()),
self.font,
None,
self.text_alignment,
alignment::Vertical::Center,
))
}
// Some(text::Renderer::draw(
// renderer,
// defaults,
// label_layout.bounds(),
// &label,
// self.text_size.unwrap_or(renderer.default_size()),
// self.font,
// None,
// self.text_alignment,
// alignment::Vertical::Center,
// ))
// }
None => None,
};
// None => None,
// };
let toggler_layout = children.next().unwrap();
let toggler_bounds = toggler_layout.bounds();
// let toggler_layout = children.next().unwrap();
// let toggler_bounds = toggler_layout.bounds();
let is_mouse_over = bounds.contains(cursor_position);
self::Renderer::draw(
renderer,
toggler_bounds,
self.is_active,
is_mouse_over,
label,
&self.style,
)
// let is_mouse_over = bounds.contains(cursor_position);
}
fn hash_layout(&self, state: &mut Hasher) {
@ -249,29 +240,12 @@ pub trait Renderer: crate::Renderer {
/// The default size of a [`Toggler`].
const DEFAULT_SIZE: u16;
/// Draws a [`Toggler`].
///
/// It receives:
/// * the bounds of the [`Toggler`]
/// * whether the [`Toggler`] is activated or not
/// * whether the mouse is over the [`Toggler`] or not
/// * the drawn label of the [`Toggler`]
/// * the style of the [`Toggler`]
fn draw(
&mut self,
bounds: Rectangle,
is_active: bool,
is_mouse_over: bool,
label: Option<Self::Output>,
style: &Self::Style,
) -> Self::Output;
}
impl<'a, Message, Renderer> From<Toggler<Message, Renderer>>
for Element<'a, Message, Renderer>
where
Renderer: 'a + self::Renderer + text::Renderer + row::Renderer,
Renderer: 'a + self::Renderer + text::Renderer,
Message: 'a,
{
fn from(

43
native/src/widget/tooltip.rs
View file

@ -136,25 +136,13 @@ where
fn draw(
&self,
renderer: &mut Renderer,
defaults: &Renderer::Defaults,
layout: Layout<'_>,
cursor_position: Point,
viewport: &Rectangle,
) -> Renderer::Output {
self::Renderer::draw(
renderer,
defaults,
cursor_position,
layout,
viewport,
&self.content,
&self.tooltip,
self.position,
&self.style,
self.gap,
self.padding,
)
_renderer: &mut Renderer,
_defaults: &Renderer::Defaults,
_layout: Layout<'_>,
_cursor_position: Point,
_viewport: &Rectangle,
) {
// TODO
}
fn hash_layout(&self, state: &mut Hasher) {
@ -177,23 +165,6 @@ pub trait Renderer:
{
/// The default padding of a [`Tooltip`] drawn by this renderer.
const DEFAULT_PADDING: u16;
/// Draws a [`Tooltip`].
///
/// [`Tooltip`]: struct.Tooltip.html
fn draw<Message>(
&mut self,
defaults: &Self::Defaults,
cursor_position: Point,
content_layout: Layout<'_>,
viewport: &Rectangle,
content: &Element<'_, Message, Self>,
tooltip: &Text<Self>,
position: Position,
style: &<Self as container::Renderer>::Style,
gap: u16,
padding: u16,
) -> Self::Output;
}
impl<'a, Message, Renderer> From<Tooltip<'a, Message, Renderer>>