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

Merge branch 'master' into feature/pane-grid-titlebar

Browse source
This commit is contained in:
Héctor Ramón Jiménez 2020-07-08 11:44:40 +02:00
commit f3dfaa2c43
59 changed files with 1064 additions and 311 deletions
Download patch file Download diff file Expand all files Collapse all files

10
native/src/debug/basic.rs
View file

@ -174,9 +174,13 @@ impl Debug {
lines.push(key_value("Render:", self.render_durations.average()));
lines.push(key_value("Message count:", self.message_count));
lines.push(String::from("Last messages:"));
lines.extend(
self.last_messages.iter().map(|msg| format!(" {}", msg)),
);
lines.extend(self.last_messages.iter().map(|msg| {
if msg.len() <= 100 {
format!(" {}", msg)
} else {
format!(" {:.100}...", msg)
}
}));
lines
}

24
native/src/program/state.rs
View file

@ -1,5 +1,5 @@
use crate::{
Cache, Clipboard, Command, Debug, Event, Program, Renderer, Size,
Cache, Clipboard, Command, Debug, Event, Point, Program, Renderer, Size,
UserInterface,
};
@ -31,6 +31,7 @@ where
pub fn new(
mut program: P,
bounds: Size,
cursor_position: Point,
renderer: &mut P::Renderer,
debug: &mut Debug,
) -> Self {
@ -43,7 +44,7 @@ where
);
debug.draw_started();
let primitive = user_interface.draw(renderer);
let primitive = user_interface.draw(renderer, cursor_position);
debug.draw_finished();
let cache = Some(user_interface.into_cache());
@ -88,6 +89,13 @@ where
self.queued_messages.push(message);
}
/// Returns whether the event queue of the [`State`] is empty or not.
///
/// [`State`]: struct.State.html
pub fn is_queue_empty(&self) -> bool {
self.queued_events.is_empty() && self.queued_messages.is_empty()
}
/// Processes all the queued events and messages, rebuilding and redrawing
/// the widgets of the linked [`Program`] if necessary.
///
@ -97,15 +105,12 @@ where
/// [`Program`]: trait.Program.html
pub fn update(
&mut self,
clipboard: Option<&dyn Clipboard>,
bounds: Size,
cursor_position: Point,
clipboard: Option<&dyn Clipboard>,
renderer: &mut P::Renderer,
debug: &mut Debug,
) -> Option<Command<P::Message>> {
if self.queued_events.is_empty() && self.queued_messages.is_empty() {
return None;
}
let mut user_interface = build_user_interface(
&mut self.program,
self.cache.take().unwrap(),
@ -117,6 +122,7 @@ where
debug.event_processing_started();
let mut messages = user_interface.update(
self.queued_events.drain(..),
cursor_position,
clipboard,
renderer,
);
@ -125,7 +131,7 @@ where
if messages.is_empty() {
debug.draw_started();
self.primitive = user_interface.draw(renderer);
self.primitive = user_interface.draw(renderer, cursor_position);
debug.draw_finished();
self.cache = Some(user_interface.into_cache());
@ -156,7 +162,7 @@ where
);
debug.draw_started();
self.primitive = user_interface.draw(renderer);
self.primitive = user_interface.draw(renderer, cursor_position);
debug.draw_finished();
self.cache = Some(user_interface.into_cache());

9
native/src/renderer/null.rs
View file

@ -50,7 +50,9 @@ impl row::Renderer for Null {
impl text::Renderer for Null {
type Font = Font;
const DEFAULT_SIZE: u16 = 20;
fn default_size(&self) -> u16 {
20
}
fn measure(
&self,
@ -104,13 +106,8 @@ impl scrollable::Renderer for Null {
}
impl text_input::Renderer for Null {
type Font = Font;
type Style = ();
fn default_size(&self) -> u16 {
20
}
fn measure_value(&self, _value: &str, _size: u16, _font: Font) -> f32 {
0.0
}

46
native/src/user_interface.rs
View file

@ -1,4 +1,4 @@
use crate::{layout, mouse, Clipboard, Element, Event, Layout, Point, Size};
use crate::{layout, Clipboard, Element, Event, Layout, Point, Size};
use std::hash::Hasher;
@ -23,7 +23,6 @@ pub struct UserInterface<'a, Message, Renderer> {
root: Element<'a, Message, Renderer>,
layout: layout::Node,
bounds: Size,
cursor_position: Point,
}
impl<'a, Message, Renderer> UserInterface<'a, Message, Renderer>
@ -115,7 +114,6 @@ where
root,
layout,
bounds,
cursor_position: cache.cursor_position,
}
}
@ -132,7 +130,7 @@ where
/// completing [the previous example](#example):
///
/// ```no_run
/// use iced_native::{UserInterface, Cache, Size};
/// use iced_native::{UserInterface, Cache, Size, Point};
/// use iced_wgpu::Renderer;
///
/// # mod iced_wgpu {
@ -154,6 +152,7 @@ where
/// let mut cache = Cache::new();
/// let mut renderer = Renderer::new();
/// let mut window_size = Size::new(1024.0, 768.0);
/// let mut cursor_position = Point::default();
///
/// // Initialize our event storage
/// let mut events = Vec::new();
@ -169,7 +168,12 @@ where
/// );
///
/// // Update the user interface
/// let messages = user_interface.update(events.drain(..), None, &renderer);
/// let messages = user_interface.update(
/// events.drain(..),
/// cursor_position,
/// None,
/// &renderer,
/// );
///
/// cache = user_interface.into_cache();
///
@ -182,20 +186,17 @@ where
pub fn update(
&mut self,
events: impl IntoIterator<Item = Event>,
cursor_position: Point,
clipboard: Option<&dyn Clipboard>,
renderer: &Renderer,
) -> Vec<Message> {
let mut messages = Vec::new();
for event in events {
if let Event::Mouse(mouse::Event::CursorMoved { x, y }) = event {
self.cursor_position = Point::new(x, y);
}
self.root.widget.on_event(
event,
Layout::new(&self.layout),
self.cursor_position,
cursor_position,
&mut messages,
renderer,
clipboard,
@ -219,7 +220,7 @@ where
/// [completing the last example](#example-1):
///
/// ```no_run
/// use iced_native::{UserInterface, Cache, Size};
/// use iced_native::{UserInterface, Cache, Size, Point};
/// use iced_wgpu::Renderer;
///
/// # mod iced_wgpu {
@ -241,6 +242,7 @@ where
/// let mut cache = Cache::new();
/// let mut renderer = Renderer::new();
/// let mut window_size = Size::new(1024.0, 768.0);
/// let mut cursor_position = Point::default();
/// let mut events = Vec::new();
///
/// loop {
@ -253,10 +255,15 @@ where
/// &mut renderer,
/// );
///
/// let messages = user_interface.update(events.drain(..), None, &renderer);
/// let messages = user_interface.update(
/// events.drain(..),
/// cursor_position,
/// None,
/// &renderer,
/// );
///
/// // Draw the user interface
/// let mouse_cursor = user_interface.draw(&mut renderer);
/// let mouse_cursor = user_interface.draw(&mut renderer, cursor_position);
///
/// cache = user_interface.into_cache();
///
@ -268,12 +275,16 @@ where
/// // Flush rendering operations...
/// }
/// ```
pub fn draw(&self, renderer: &mut Renderer) -> Renderer::Output {
pub fn draw(
&self,
renderer: &mut Renderer,
cursor_position: Point,
) -> Renderer::Output {
self.root.widget.draw(
renderer,
&Renderer::Defaults::default(),
Layout::new(&self.layout),
self.cursor_position,
cursor_position,
)
}
@ -287,7 +298,6 @@ where
hash: self.hash,
layout: self.layout,
bounds: self.bounds,
cursor_position: self.cursor_position,
}
}
}
@ -300,7 +310,6 @@ pub struct Cache {
hash: u64,
layout: layout::Node,
bounds: Size,
cursor_position: Point,
}
impl Cache {
@ -316,7 +325,6 @@ impl Cache {
hash: 0,
layout: layout::Node::new(Size::new(0.0, 0.0)),
bounds: Size::ZERO,
cursor_position: Point::new(-1.0, -1.0),
}
}
}
@ -329,7 +337,7 @@ impl Default for Cache {
impl PartialEq for Cache {
fn eq(&self, other: &Cache) -> bool {
self.hash == other.hash && self.cursor_position == other.cursor_position
self.hash == other.hash
}
}

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

@ -32,7 +32,7 @@ pub struct Checkbox<Message, Renderer: self::Renderer + text::Renderer> {
width: Length,
size: u16,
spacing: u16,
text_size: u16,
text_size: Option<u16>,
style: Renderer::Style,
}
@ -60,7 +60,7 @@ impl<Message, Renderer: self::Renderer + text::Renderer>
width: Length::Shrink,
size: <Renderer as self::Renderer>::DEFAULT_SIZE,
spacing: Renderer::DEFAULT_SPACING,
text_size: <Renderer as text::Renderer>::DEFAULT_SIZE,
text_size: None,
style: Renderer::Style::default(),
}
}
@ -93,7 +93,7 @@ impl<Message, Renderer: self::Renderer + text::Renderer>
///
/// [`Checkbox`]: struct.Checkbox.html
pub fn text_size(mut self, text_size: u16) -> Self {
self.text_size = text_size;
self.text_size = Some(text_size);
self
}
@ -136,7 +136,7 @@ where
.push(
Text::new(&self.label)
.width(self.width)
.size(self.text_size),
.size(self.text_size.unwrap_or(renderer.default_size())),
)
.layout(renderer, limits)
}
@ -181,7 +181,7 @@ where
defaults,
label_layout.bounds(),
&self.label,
self.text_size,
self.text_size.unwrap_or(renderer.default_size()),
Default::default(),
None,
HorizontalAlignment::Left,

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

@ -216,6 +216,10 @@ where
/// The `leeway` describes the amount of space around a split that can be
/// used to grab it.
///
/// The grabbable area of a split will have a length of `spacing + leeway`,
/// properly centered. In other words, a length of
/// `(spacing + leeway) / 2.0` on either side of the split line.
///
/// [`PaneGrid`]: struct.PaneGrid.html
pub fn on_resize<F>(mut self, leeway: u16, f: F) -> Self
where
@ -284,8 +288,6 @@ where
self.state.focus(pane);
}
}
} else {
self.state.unfocus();
}
}
@ -299,7 +301,7 @@ where
if let Some((split, _)) = self.state.picked_split() {
let bounds = layout.bounds();
let splits = self.state.splits(
let splits = self.state.split_regions(
f32::from(self.spacing),
Size::new(bounds.width, bounds.height),
);
@ -421,7 +423,7 @@ where
let limits = limits.width(self.width).height(self.height);
let size = limits.resolve(Size::ZERO);
let regions = self.state.regions(f32::from(self.spacing), size);
let regions = self.state.pane_regions(f32::from(self.spacing), size);
let children = self
.elements
@ -464,7 +466,7 @@ where
cursor_position.y - bounds.y,
);
let splits = self.state.splits(
let splits = self.state.split_regions(
f32::from(self.spacing),
Size::new(bounds.width, bounds.height),
);
@ -493,6 +495,8 @@ where
);
}
}
} else {
self.state.unfocus();
}
}
mouse::Event::ButtonReleased(mouse::Button::Left) => {
@ -550,10 +554,8 @@ where
}
}
}
*self.pressed_modifiers = modifiers;
}
keyboard::Event::KeyReleased { modifiers, .. } => {
keyboard::Event::ModifiersChanged(modifiers) => {
*self.pressed_modifiers = modifiers;
}
_ => {}
@ -601,7 +603,7 @@ where
let splits = self
.state
.splits(f32::from(self.spacing), bounds.size());
.split_regions(f32::from(self.spacing), bounds.size());
hovered_split(
splits.iter(),

28
native/src/widget/pane_grid/node.rs
View file

@ -43,12 +43,36 @@ pub enum Node {
}
impl Node {
/// Returns an iterator over each [`Split`] in this [`Node`].
///
/// [`Split`]: struct.Split.html
/// [`Node`]: enum.Node.html
pub fn splits(&self) -> impl Iterator<Item = &Split> {
let mut unvisited_nodes = vec![self];
std::iter::from_fn(move || {
while let Some(node) = unvisited_nodes.pop() {
match node {
Node::Split { id, a, b, .. } => {
unvisited_nodes.push(a);
unvisited_nodes.push(b);
return Some(id);
}
_ => {}
}
}
None
})
}
/// Returns the rectangular region for each [`Pane`] in the [`Node`] given
/// the spacing between panes and the total available space.
///
/// [`Pane`]: struct.Pane.html
/// [`Node`]: enum.Node.html
pub fn regions(
pub fn pane_regions(
&self,
spacing: f32,
size: Size,
@ -75,7 +99,7 @@ impl Node {
///
/// [`Split`]: struct.Split.html
/// [`Node`]: enum.Node.html
pub fn splits(
pub fn split_regions(
&self,
spacing: f32,
size: Size,

21
native/src/widget/pane_grid/state.rs
View file

@ -157,8 +157,10 @@ impl<T> State<T> {
/// [`Pane`]: struct.Pane.html
/// [`State::active`]: struct.State.html#method.active
pub fn adjacent(&self, pane: &Pane, direction: Direction) -> Option<Pane> {
let regions =
self.internal.layout.regions(0.0, Size::new(4096.0, 4096.0));
let regions = self
.internal
.layout
.pane_regions(0.0, Size::new(4096.0, 4096.0));
let current_region = regions.get(pane)?;
@ -194,6 +196,13 @@ impl<T> State<T> {
self.internal.focus(pane);
}
/// Unfocuses the current focused [`Pane`].
///
/// [`Pane`]: struct.Pane.html
pub fn unfocus(&mut self) {
self.internal.unfocus();
}
/// Splits the given [`Pane`] into two in the given [`Axis`] and
/// initializing the new [`Pane`] with the provided internal state.
///
@ -366,20 +375,20 @@ impl Internal {
}
}
pub fn regions(
pub fn pane_regions(
&self,
spacing: f32,
size: Size,
) -> HashMap<Pane, Rectangle> {
self.layout.regions(spacing, size)
self.layout.pane_regions(spacing, size)
}
pub fn splits(
pub fn split_regions(
&self,
spacing: f32,
size: Size,
) -> HashMap<Split, (Axis, Rectangle, f32)> {
self.layout.splits(spacing, size)
self.layout.split_regions(spacing, size)
}
pub fn focus(&mut self, pane: &Pane) {

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

@ -41,7 +41,7 @@ pub struct Radio<Message, Renderer: self::Renderer + text::Renderer> {
width: Length,
size: u16,
spacing: u16,
text_size: u16,
text_size: Option<u16>,
style: Renderer::Style,
}
@ -75,7 +75,7 @@ impl<Message, Renderer: self::Renderer + text::Renderer>
width: Length::Shrink,
size: <Renderer as self::Renderer>::DEFAULT_SIZE,
spacing: Renderer::DEFAULT_SPACING, //15
text_size: <Renderer as text::Renderer>::DEFAULT_SIZE,
text_size: None,
style: Renderer::Style::default(),
}
}
@ -108,7 +108,7 @@ impl<Message, Renderer: self::Renderer + text::Renderer>
///
/// [`Radio`]: struct.Radio.html
pub fn text_size(mut self, text_size: u16) -> Self {
self.text_size = text_size;
self.text_size = Some(text_size);
self
}
@ -151,7 +151,7 @@ where
.push(
Text::new(&self.label)
.width(self.width)
.size(self.text_size),
.size(self.text_size.unwrap_or(renderer.default_size())),
)
.layout(renderer, limits)
}
@ -194,7 +194,7 @@ where
defaults,
label_layout.bounds(),
&self.label,
self.text_size,
self.text_size.unwrap_or(renderer.default_size()),
Default::default(),
None,
HorizontalAlignment::Left,

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

@ -16,13 +16,16 @@ use std::{hash::Hash, ops::RangeInclusive};
///
/// A [`Slider`] will try to fill the horizontal space of its container.
///
/// The [`Slider`] range of numeric values is generic and its step size defaults
/// to 1 unit.
///
/// [`Slider`]: struct.Slider.html
///
/// # Example
/// ```
/// # use iced_native::{slider, renderer::Null};
/// #
/// # pub type Slider<'a, Message> = iced_native::Slider<'a, Message, Null>;
/// # pub type Slider<'a, T, Message> = iced_native::Slider<'a, T, Message, Null>;
/// pub enum Message {
/// SliderChanged(f32),
/// }
@ -35,17 +38,22 @@ use std::{hash::Hash, ops::RangeInclusive};
///
/// ![Slider drawn by Coffee's renderer](https://github.com/hecrj/coffee/blob/bda9818f823dfcb8a7ad0ff4940b4d4b387b5208/images/ui/slider.png?raw=true)
#[allow(missing_debug_implementations)]
pub struct Slider<'a, Message, Renderer: self::Renderer> {
pub struct Slider<'a, T, Message, Renderer: self::Renderer> {
state: &'a mut State,
range: RangeInclusive<f32>,
value: f32,
on_change: Box<dyn Fn(f32) -> Message>,
range: RangeInclusive<T>,
step: T,
value: T,
on_change: Box<dyn Fn(T) -> Message>,
on_release: Option<Message>,
width: Length,
style: Renderer::Style,
}
impl<'a, Message, Renderer: self::Renderer> Slider<'a, Message, Renderer> {
impl<'a, T, Message, Renderer> Slider<'a, T, Message, Renderer>
where
T: Copy + From<u8> + std::cmp::PartialOrd,
Renderer: self::Renderer,
{
/// Creates a new [`Slider`].
///
/// It expects:
@ -60,17 +68,30 @@ impl<'a, Message, Renderer: self::Renderer> Slider<'a, Message, Renderer> {
/// [`State`]: struct.State.html
pub fn new<F>(
state: &'a mut State,
range: RangeInclusive<f32>,
value: f32,
range: RangeInclusive<T>,
value: T,
on_change: F,
) -> Self
where
F: 'static + Fn(f32) -> Message,
F: 'static + Fn(T) -> Message,
{
let value = if value >= *range.start() {
value
} else {
*range.start()
};
let value = if value <= *range.end() {
value
} else {
*range.end()
};
Slider {
state,
value: value.max(*range.start()).min(*range.end()),
value,
range,
step: T::from(1),
on_change: Box::new(on_change),
on_release: None,
width: Length::Fill,
@ -106,6 +127,14 @@ impl<'a, Message, Renderer: self::Renderer> Slider<'a, Message, Renderer> {
self.style = style.into();
self
}
/// Sets the step size of the [`Slider`].
///
/// [`Slider`]: struct.Slider.html
pub fn step(mut self, step: T) -> Self {
self.step = step;
self
}
}
/// The local state of a [`Slider`].
@ -125,9 +154,10 @@ impl State {
}
}
impl<'a, Message, Renderer> Widget<Message, Renderer>
for Slider<'a, Message, Renderer>
impl<'a, T, Message, Renderer> Widget<Message, Renderer>
for Slider<'a, T, Message, Renderer>
where
T: Copy + Into<f64> + num_traits::FromPrimitive,
Renderer: self::Renderer,
Message: Clone,
{
@ -164,17 +194,24 @@ where
) {
let mut change = || {
let bounds = layout.bounds();
if cursor_position.x <= bounds.x {
messages.push((self.on_change)(*self.range.start()));
} else if cursor_position.x >= bounds.x + bounds.width {
messages.push((self.on_change)(*self.range.end()));
} else {
let percent = (cursor_position.x - bounds.x) / bounds.width;
let value = (self.range.end() - self.range.start()) * percent
+ self.range.start();
let step = self.step.into();
let start = (*self.range.start()).into();
let end = (*self.range.end()).into();
messages.push((self.on_change)(value));
let percent = f64::from(cursor_position.x - bounds.x)
/ f64::from(bounds.width);
let steps = (percent * (end - start) / step).round();
let value = steps * step + start;
if let Some(value) = T::from_f64(value) {
messages.push((self.on_change)(value));
}
}
};
@ -212,11 +249,14 @@ where
layout: Layout<'_>,
cursor_position: Point,
) -> Renderer::Output {
let start = *self.range.start();
let end = *self.range.end();
renderer.draw(
layout.bounds(),
cursor_position,
self.range.clone(),
self.value,
start.into() as f32..=end.into() as f32,
self.value.into() as f32,
self.state.is_dragging,
&self.style,
)
@ -269,14 +309,15 @@ pub trait Renderer: crate::Renderer {
) -> Self::Output;
}
impl<'a, Message, Renderer> From<Slider<'a, Message, Renderer>>
impl<'a, T, Message, Renderer> From<Slider<'a, T, Message, Renderer>>
for Element<'a, Message, Renderer>
where
T: 'a + Copy + Into<f64> + num_traits::FromPrimitive,
Renderer: 'a + self::Renderer,
Message: 'a + Clone,
{
fn from(
slider: Slider<'a, Message, Renderer>,
slider: Slider<'a, T, Message, Renderer>,
) -> Element<'a, Message, Renderer> {
Element::new(slider)
}

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

@ -131,7 +131,7 @@ where
) -> layout::Node {
let limits = limits.width(self.width).height(self.height);
let size = self.size.unwrap_or(Renderer::DEFAULT_SIZE);
let size = self.size.unwrap_or(renderer.default_size());
let bounds = limits.max();
@ -154,7 +154,7 @@ where
defaults,
layout.bounds(),
&self.content,
self.size.unwrap_or(Renderer::DEFAULT_SIZE),
self.size.unwrap_or(renderer.default_size()),
self.font,
self.color,
self.horizontal_alignment,
@ -187,10 +187,10 @@ pub trait Renderer: crate::Renderer {
/// [`Text`]: struct.Text.html
type Font: Default + Copy;
/// The default size of [`Text`].
/// Returns the default size of [`Text`].
///
/// [`Text`]: struct.Text.html
const DEFAULT_SIZE: u16;
fn default_size(&self) -> u16;
/// Measures the [`Text`] in the given bounds and returns the minimum
/// boundaries that can fit the contents.

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

@ -17,8 +17,8 @@ use editor::Editor;
use crate::{
keyboard, layout,
mouse::{self, click},
Clipboard, Element, Event, Hasher, Layout, Length, Point, Rectangle, Size,
Widget,
text, Clipboard, Element, Event, Hasher, Layout, Length, Point, Rectangle,
Size, Widget,
};
use std::u32;
@ -486,7 +486,8 @@ where
let text_bounds = layout.children().next().unwrap().bounds();
if self.is_secure {
renderer.draw(
self::Renderer::draw(
renderer,
bounds,
text_bounds,
cursor_position,
@ -498,7 +499,8 @@ where
&self.style,
)
} else {
renderer.draw(
self::Renderer::draw(
renderer,
bounds,
text_bounds,
cursor_position,
@ -531,20 +533,10 @@ where
///
/// [`TextInput`]: struct.TextInput.html
/// [renderer]: ../../renderer/index.html
pub trait Renderer: crate::Renderer + Sized {
/// The font type used for [`TextInput`].
///
/// [`TextInput`]: struct.TextInput.html
type Font: Default + Copy;
pub trait Renderer: text::Renderer + Sized {
/// The style supported by this renderer.
type Style: Default;
/// Returns the default size of the text of the [`TextInput`].
///
/// [`TextInput`]: struct.TextInput.html
fn default_size(&self) -> u16;
/// Returns the width of the value of the [`TextInput`].
///
/// [`TextInput`]: struct.TextInput.html
@ -683,6 +675,30 @@ impl State {
pub fn cursor(&self) -> Cursor {
self.cursor
}
/// Moves the [`Cursor`] of the [`TextInput`] to the front of the input text.
///
/// [`Cursor`]: struct.Cursor.html
/// [`TextInput`]: struct.TextInput.html
pub fn move_cursor_to_front(&mut self) {
self.cursor.move_to(0);
}
/// Moves the [`Cursor`] of the [`TextInput`] to the end of the input text.
///
/// [`Cursor`]: struct.Cursor.html
/// [`TextInput`]: struct.TextInput.html
pub fn move_cursor_to_end(&mut self) {
self.cursor.move_to(usize::MAX);
}
/// Moves the [`Cursor`] of the [`TextInput`] to an arbitrary location.
///
/// [`Cursor`]: struct.Cursor.html
/// [`TextInput`]: struct.TextInput.html
pub fn move_cursor_to(&mut self, position: usize) {
self.cursor.move_to(position);
}
}
// TODO: Reduce allocations