summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--native/src/element.rs7
-rw-r--r--native/src/layout.rs2
-rw-r--r--native/src/layout/debugger.rs (renamed from native/src/renderer/debugger.rs)10
-rw-r--r--native/src/lib.rs4
-rw-r--r--native/src/renderer.rs9
-rw-r--r--native/src/user_interface.rs30
-rw-r--r--native/src/window.rs2
-rw-r--r--native/src/window/renderer.rs (renamed from native/src/renderer/windowed.rs)6
-rw-r--r--wgpu/src/renderer.rs11
-rw-r--r--wgpu/src/renderer/target.rs3
-rw-r--r--winit/src/application.rs80
11 files changed, 91 insertions, 73 deletions
diff --git a/native/src/element.rs b/native/src/element.rs
index 9b5adb9c..fab73f77 100644
--- a/native/src/element.rs
+++ b/native/src/element.rs
@@ -1,6 +1,5 @@
use crate::{
- layout, renderer, Clipboard, Color, Event, Hasher, Layout, Length, Point,
- Widget,
+ layout, Clipboard, Color, Event, Hasher, Layout, Length, Point, Widget,
};
/// A generic [`Widget`].
@@ -195,7 +194,7 @@ where
) -> Element<'a, Message, Renderer>
where
Message: 'static,
- Renderer: 'a + renderer::Debugger,
+ Renderer: 'a + layout::Debugger,
{
Element {
widget: Box::new(Explain::new(self, color.into())),
@@ -348,7 +347,7 @@ where
impl<'a, Message, Renderer> Widget<Message, Renderer>
for Explain<'a, Message, Renderer>
where
- Renderer: crate::Renderer + renderer::Debugger,
+ Renderer: crate::Renderer + layout::Debugger,
{
fn width(&self) -> Length {
self.element.widget.width()
diff --git a/native/src/layout.rs b/native/src/layout.rs
index e945706b..4a3ab94a 100644
--- a/native/src/layout.rs
+++ b/native/src/layout.rs
@@ -1,9 +1,11 @@
//! Position your widgets properly.
+mod debugger;
mod limits;
mod node;
pub mod flex;
+pub use debugger::Debugger;
pub use limits::Limits;
pub use node::Node;
diff --git a/native/src/renderer/debugger.rs b/native/src/layout/debugger.rs
index 30f3d9a0..e4b21609 100644
--- a/native/src/renderer/debugger.rs
+++ b/native/src/layout/debugger.rs
@@ -1,9 +1,9 @@
-use crate::{Color, Layout, Point, Widget};
+use crate::{Color, Layout, Point, Renderer, Widget};
/// A renderer able to graphically explain a [`Layout`].
///
-/// [`Layout`]: ../struct.Layout.html
-pub trait Debugger: super::Renderer {
+/// [`Layout`]: struct.Layout.html
+pub trait Debugger: Renderer {
/// Explains the [`Layout`] of an [`Element`] for debugging purposes.
///
/// This will be called when [`Element::explain`] has been used. It should
@@ -13,8 +13,8 @@ pub trait Debugger: super::Renderer {
/// [`Layout`] and its children.
///
/// [`Layout`]: struct.Layout.html
- /// [`Element`]: struct.Element.html
- /// [`Element::explain`]: struct.Element.html#method.explain
+ /// [`Element`]: ../struct.Element.html
+ /// [`Element::explain`]: ../struct.Element.html#method.explain
fn explain<Message>(
&mut self,
defaults: &Self::Defaults,
diff --git a/native/src/lib.rs b/native/src/lib.rs
index e65c6596..340b9ea7 100644
--- a/native/src/lib.rs
+++ b/native/src/lib.rs
@@ -14,7 +14,7 @@
//! - A [`Widget`] trait, which is used to implement new widgets: from layout
//! requirements to event and drawing logic.
//! - A bunch of `Renderer` traits, meant to keep the crate renderer-agnostic.
-//! - A [`Windowed`] trait, leveraging [`raw-window-handle`], which can be
+//! - A [`window::Renderer`] trait, leveraging [`raw-window-handle`], which can be
//! implemented by graphical renderers that target _windows_. Window-based
//! shells (like [`iced_winit`]) can use this trait to stay renderer-agnostic.
//!
@@ -31,7 +31,7 @@
//! [`druid`]: https://github.com/xi-editor/druid
//! [`raw-window-handle`]: https://github.com/rust-windowing/raw-window-handle
//! [`Widget`]: widget/trait.Widget.html
-//! [`Windowed`]: renderer/trait.Windowed.html
+//! [`window::Renderer`]: window/trait.Renderer.html
//! [`UserInterface`]: struct.UserInterface.html
//! [renderer]: renderer/index.html
#![deny(missing_docs)]
diff --git a/native/src/renderer.rs b/native/src/renderer.rs
index 284c95f6..a16df72b 100644
--- a/native/src/renderer.rs
+++ b/native/src/renderer.rs
@@ -20,12 +20,6 @@
//! [`Checkbox`]: ../widget/checkbox/struct.Checkbox.html
//! [`checkbox::Renderer`]: ../widget/checkbox/trait.Renderer.html
-mod debugger;
-mod windowed;
-
-pub use debugger::Debugger;
-pub use windowed::{Target, Windowed};
-
#[cfg(debug_assertions)]
mod null;
#[cfg(debug_assertions)]
@@ -58,7 +52,8 @@ pub trait Renderer: Sized {
fn layout<'a, Message>(
&mut self,
element: &Element<'a, Message, Self>,
+ limits: &layout::Limits,
) -> layout::Node {
- element.layout(self, &layout::Limits::NONE)
+ element.layout(self, limits)
}
}
diff --git a/native/src/user_interface.rs b/native/src/user_interface.rs
index 970bf0c1..85b25bc7 100644
--- a/native/src/user_interface.rs
+++ b/native/src/user_interface.rs
@@ -17,6 +17,7 @@ pub struct UserInterface<'a, Message, Renderer> {
hash: u64,
root: Element<'a, Message, Renderer>,
layout: layout::Node,
+ bounds: Size,
cursor_position: Point,
}
@@ -39,7 +40,7 @@ where
/// is naive way to set up our application loop:
///
/// ```no_run
- /// use iced_native::{UserInterface, Cache};
+ /// use iced_native::{UserInterface, Cache, Size};
/// use iced_wgpu::Renderer;
///
/// # mod iced_wgpu {
@@ -60,6 +61,7 @@ where
/// let mut counter = Counter::new();
/// let mut cache = Cache::new();
/// let mut renderer = Renderer::new();
+ /// let mut window_size = Size::new(1024.0, 768.0);
///
/// // Application loop
/// loop {
@@ -68,6 +70,7 @@ where
/// // Build the user interface
/// let user_interface = UserInterface::build(
/// counter.view(),
+ /// window_size,
/// cache,
/// &mut renderer,
/// );
@@ -81,26 +84,30 @@ where
/// ```
pub fn build<E: Into<Element<'a, Message, Renderer>>>(
root: E,
+ bounds: Size,
cache: Cache,
renderer: &mut Renderer,
) -> Self {
let root = root.into();
- let hasher = &mut crate::Hasher::default();
- root.hash_layout(hasher);
+ let hash = {
+ let hasher = &mut crate::Hasher::default();
+ root.hash_layout(hasher);
- let hash = hasher.finish();
+ hasher.finish()
+ };
- let layout = if hash == cache.hash {
+ let layout = if hash == cache.hash && bounds == cache.bounds {
cache.layout
} else {
- renderer.layout(&root)
+ renderer.layout(&root, &layout::Limits::new(Size::ZERO, bounds))
};
UserInterface {
hash,
root,
layout,
+ bounds,
cursor_position: cache.cursor_position,
}
}
@@ -118,7 +125,7 @@ where
/// completing [the previous example](#example):
///
/// ```no_run
- /// use iced_native::{UserInterface, Cache};
+ /// use iced_native::{UserInterface, Cache, Size};
/// use iced_wgpu::Renderer;
///
/// # mod iced_wgpu {
@@ -139,6 +146,7 @@ where
/// let mut counter = Counter::new();
/// let mut cache = Cache::new();
/// let mut renderer = Renderer::new();
+ /// let mut window_size = Size::new(1024.0, 768.0);
///
/// // Initialize our event storage
/// let mut events = Vec::new();
@@ -148,6 +156,7 @@ where
///
/// let mut user_interface = UserInterface::build(
/// counter.view(),
+ /// window_size,
/// cache,
/// &mut renderer,
/// );
@@ -203,7 +212,7 @@ where
/// [completing the last example](#example-1):
///
/// ```no_run
- /// use iced_native::{UserInterface, Cache};
+ /// use iced_native::{UserInterface, Cache, Size};
/// use iced_wgpu::Renderer;
///
/// # mod iced_wgpu {
@@ -224,6 +233,7 @@ where
/// let mut counter = Counter::new();
/// let mut cache = Cache::new();
/// let mut renderer = Renderer::new();
+ /// let mut window_size = Size::new(1024.0, 768.0);
/// let mut events = Vec::new();
///
/// loop {
@@ -231,6 +241,7 @@ where
///
/// let mut user_interface = UserInterface::build(
/// counter.view(),
+ /// window_size,
/// cache,
/// &mut renderer,
/// );
@@ -268,6 +279,7 @@ where
Cache {
hash: self.hash,
layout: self.layout,
+ bounds: self.bounds,
cursor_position: self.cursor_position,
}
}
@@ -280,6 +292,7 @@ where
pub struct Cache {
hash: u64,
layout: layout::Node,
+ bounds: Size,
cursor_position: Point,
}
@@ -295,6 +308,7 @@ impl Cache {
Cache {
hash: 0,
layout: layout::Node::new(Size::new(0.0, 0.0)),
+ bounds: Size::ZERO,
cursor_position: Point::new(-1.0, -1.0),
}
}
diff --git a/native/src/window.rs b/native/src/window.rs
index 220bb3be..db9226dc 100644
--- a/native/src/window.rs
+++ b/native/src/window.rs
@@ -1,4 +1,6 @@
//! Build window-based GUI applications.
mod event;
+mod renderer;
pub use event::Event;
+pub use renderer::{Renderer, Target};
diff --git a/native/src/renderer/windowed.rs b/native/src/window/renderer.rs
index ee020ab1..be9765fa 100644
--- a/native/src/renderer/windowed.rs
+++ b/native/src/window/renderer.rs
@@ -3,16 +3,16 @@ use crate::MouseCursor;
use raw_window_handle::HasRawWindowHandle;
/// A renderer that can target windows.
-pub trait Windowed: super::Renderer + Sized {
+pub trait Renderer: crate::Renderer + Sized {
/// The settings of the renderer.
type Settings: Default;
/// The type of target.
type Target: Target<Renderer = Self>;
- /// Creates a new [`Windowed`] renderer.
+ /// Creates a new window [`Renderer`].
///
- /// [`Windowed`]: trait.Windowed.html
+ /// [`Renderer`]: trait.Renderer.html
fn new(settings: Self::Settings) -> Self;
/// Performs the drawing operations described in the output on the given
diff --git a/wgpu/src/renderer.rs b/wgpu/src/renderer.rs
index 9757904c..6f35e247 100644
--- a/wgpu/src/renderer.rs
+++ b/wgpu/src/renderer.rs
@@ -3,8 +3,8 @@ use crate::{
Transformation,
};
use iced_native::{
- renderer::{Debugger, Windowed},
- Background, Color, Layout, MouseCursor, Point, Rectangle, Vector, Widget,
+ layout, window, Background, Color, Layout, MouseCursor, Point, Rectangle,
+ Vector, Widget,
};
use std::sync::Arc;
use wgpu::{
@@ -445,8 +445,9 @@ impl iced_native::Renderer for Renderer {
fn layout<'a, Message>(
&mut self,
element: &iced_native::Element<'a, Message, Self>,
+ limits: &iced_native::layout::Limits,
) -> iced_native::layout::Node {
- let node = element.layout(self, &iced_native::layout::Limits::NONE);
+ let node = element.layout(self, limits);
self.text_pipeline.clear_measurement_cache();
@@ -454,7 +455,7 @@ impl iced_native::Renderer for Renderer {
}
}
-impl Windowed for Renderer {
+impl window::Renderer for Renderer {
type Settings = Settings;
type Target = Target;
@@ -472,7 +473,7 @@ impl Windowed for Renderer {
}
}
-impl Debugger for Renderer {
+impl layout::Debugger for Renderer {
fn explain<Message>(
&mut self,
defaults: &Defaults,
diff --git a/wgpu/src/renderer/target.rs b/wgpu/src/renderer/target.rs
index 569f3c62..5fe4b50b 100644
--- a/wgpu/src/renderer/target.rs
+++ b/wgpu/src/renderer/target.rs
@@ -1,4 +1,5 @@
use crate::{Renderer, Transformation};
+use iced_native::window;
use raw_window_handle::HasRawWindowHandle;
@@ -31,7 +32,7 @@ impl Target {
}
}
-impl iced_native::renderer::Target for Target {
+impl window::Target for Target {
type Renderer = Renderer;
fn new<W: HasRawWindowHandle>(
diff --git a/winit/src/application.rs b/winit/src/application.rs
index 8529c99c..a712632e 100644
--- a/winit/src/application.rs
+++ b/winit/src/application.rs
@@ -1,9 +1,8 @@
use crate::{
- container, conversion,
+ conversion,
input::{keyboard, mouse},
- renderer::{Target, Windowed},
- subscription, window, Cache, Clipboard, Command, Container, Debug, Element,
- Event, Length, MouseCursor, Settings, Subscription, UserInterface,
+ subscription, window, Cache, Clipboard, Command, Debug, Element, Event,
+ MouseCursor, Settings, Size, Subscription, UserInterface,
};
/// An interactive, native cross-platform application.
@@ -18,7 +17,7 @@ pub trait Application: Sized {
/// The renderer to use to draw the [`Application`].
///
/// [`Application`]: trait.Application.html
- type Renderer: Windowed + container::Renderer;
+ type Renderer: window::Renderer;
/// The type of __messages__ your [`Application`] will produce.
///
@@ -83,10 +82,11 @@ pub trait Application: Sized {
/// [`Application`]: trait.Application.html
fn run(
settings: Settings,
- renderer_settings: <Self::Renderer as Windowed>::Settings,
+ renderer_settings: <Self::Renderer as window::Renderer>::Settings,
) where
Self: 'static,
{
+ use window::{Renderer as _, Target as _};
use winit::{
event::{self, WindowEvent},
event_loop::{ControlFlow, EventLoop},
@@ -147,18 +147,18 @@ pub trait Application: Sized {
let mut target = {
let (width, height) = to_physical(size, dpi);
- <Self::Renderer as Windowed>::Target::new(
+ <Self::Renderer as window::Renderer>::Target::new(
&window, width, height, dpi as f32, &renderer,
)
};
- debug.layout_started();
- let user_interface = UserInterface::build(
- document(&mut application, size, &mut debug),
+ let user_interface = build_user_interface(
+ &mut application,
Cache::default(),
&mut renderer,
+ size,
+ &mut debug,
);
- debug.layout_finished();
debug.draw_started();
let mut primitive = user_interface.draw(&mut renderer);
@@ -183,13 +183,13 @@ pub trait Application: Sized {
//
// This will allow us to rebuild it only when a message is
// handled.
- debug.layout_started();
- let mut user_interface = UserInterface::build(
- document(&mut application, size, &mut debug),
+ let mut user_interface = build_user_interface(
+ &mut application,
cache.take().unwrap(),
&mut renderer,
+ size,
+ &mut debug,
);
- debug.layout_finished();
debug.event_processing_started();
events.iter().for_each(|event| {
@@ -244,13 +244,13 @@ pub trait Application: Sized {
title = new_title;
}
- debug.layout_started();
- let user_interface = UserInterface::build(
- document(&mut application, size, &mut debug),
+ let user_interface = build_user_interface(
+ &mut application,
temp_cache,
&mut renderer,
+ size,
+ &mut debug,
);
- debug.layout_finished();
debug.draw_started();
primitive = user_interface.draw(&mut renderer);
@@ -390,6 +390,29 @@ pub trait Application: Sized {
}
}
+fn build_user_interface<'a, A: Application>(
+ application: &'a mut A,
+ cache: Cache,
+ renderer: &mut A::Renderer,
+ size: winit::dpi::LogicalSize,
+ debug: &mut Debug,
+) -> UserInterface<'a, A::Message, A::Renderer> {
+ debug.view_started();
+ let view = application.view();
+ debug.view_finished();
+
+ debug.layout_started();
+ let user_interface = UserInterface::build(
+ view,
+ Size::new(size.width.round() as f32, size.height.round() as f32),
+ cache,
+ renderer,
+ );
+ debug.layout_finished();
+
+ user_interface
+}
+
fn to_physical(size: winit::dpi::LogicalSize, dpi: f64) -> (u16, u16) {
let physical_size = size.to_physical(dpi);
@@ -399,25 +422,6 @@ fn to_physical(size: winit::dpi::LogicalSize, dpi: f64) -> (u16, u16) {
)
}
-fn document<'a, Application>(
- application: &'a mut Application,
- size: winit::dpi::LogicalSize,
- debug: &mut Debug,
-) -> Element<'a, Application::Message, Application::Renderer>
-where
- Application: self::Application,
- Application::Message: 'static,
-{
- debug.view_started();
- let view = application.view();
- debug.view_finished();
-
- Container::new(view)
- .width(Length::Units(size.width.round() as u16))
- .height(Length::Units(size.height.round() as u16))
- .into()
-}
-
fn spawn<Message: Send>(
command: Command<Message>,
thread_pool: &mut futures::executor::ThreadPool,
generated by cgit (git 2.34.1) at 2025-05-31 07:33:42 +0000