summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--native/src/widget/pane_grid.rs3
-rw-r--r--native/src/widget/pane_grid/axis.rs182
-rw-r--r--native/src/widget/pane_grid/content.rs30
-rw-r--r--native/src/widget/pane_grid/node.rs187
-rw-r--r--native/src/widget/pane_grid/state.rs93
-rw-r--r--wgpu/src/shader/quad.vert12
-rw-r--r--wgpu/src/shader/quad.vert.spvbin3372 -> 3348 bytes
-rw-r--r--wgpu/src/widget/pane_grid.rs4
8 files changed, 407 insertions, 104 deletions
diff --git a/native/src/widget/pane_grid.rs b/native/src/widget/pane_grid.rs
index cb623b29..076ae76f 100644
--- a/native/src/widget/pane_grid.rs
+++ b/native/src/widget/pane_grid.rs
@@ -9,6 +9,7 @@
//! [`pane_grid` example]: https://github.com/hecrj/iced/tree/0.1/examples/pane_grid
//! [`PaneGrid`]: struct.PaneGrid.html
mod axis;
+mod content;
mod direction;
mod node;
mod pane;
@@ -16,7 +17,9 @@ mod split;
mod state;
pub use axis::Axis;
+pub use content::Content;
pub use direction::Direction;
+pub use node::Node;
pub use pane::Pane;
pub use split::Split;
pub use state::{Focus, State};
diff --git a/native/src/widget/pane_grid/axis.rs b/native/src/widget/pane_grid/axis.rs
index f0e3f362..b3a306d5 100644
--- a/native/src/widget/pane_grid/axis.rs
+++ b/native/src/widget/pane_grid/axis.rs
@@ -14,37 +14,39 @@ impl Axis {
&self,
rectangle: &Rectangle,
ratio: f32,
- halved_spacing: f32,
+ spacing: f32,
) -> (Rectangle, Rectangle) {
match self {
Axis::Horizontal => {
- let height_top = (rectangle.height * ratio).round();
- let height_bottom = rectangle.height - height_top;
+ let height_top =
+ (rectangle.height * ratio - spacing / 2.0).round();
+ let height_bottom = rectangle.height - height_top - spacing;
(
Rectangle {
- height: height_top - halved_spacing,
+ height: height_top,
..*rectangle
},
Rectangle {
- y: rectangle.y + height_top + halved_spacing,
- height: height_bottom - halved_spacing,
+ y: rectangle.y + height_top + spacing,
+ height: height_bottom,
..*rectangle
},
)
}
Axis::Vertical => {
- let width_left = (rectangle.width * ratio).round();
- let width_right = rectangle.width - width_left;
+ let width_left =
+ (rectangle.width * ratio - spacing / 2.0).round();
+ let width_right = rectangle.width - width_left - spacing;
(
Rectangle {
- width: width_left - halved_spacing,
+ width: width_left,
..*rectangle
},
Rectangle {
- x: rectangle.x + width_left + halved_spacing,
- width: width_right - halved_spacing,
+ x: rectangle.x + width_left + spacing,
+ width: width_right,
..*rectangle
},
)
@@ -52,3 +54,161 @@ impl Axis {
}
}
}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ enum Case {
+ Horizontal {
+ overall_height: f32,
+ spacing: f32,
+ top_height: f32,
+ bottom_y: f32,
+ bottom_height: f32,
+ },
+ Vertical {
+ overall_width: f32,
+ spacing: f32,
+ left_width: f32,
+ right_x: f32,
+ right_width: f32,
+ },
+ }
+
+ #[test]
+ fn split() {
+ let cases = vec![
+ // Even height, even spacing
+ Case::Horizontal {
+ overall_height: 10.0,
+ spacing: 2.0,
+ top_height: 4.0,
+ bottom_y: 6.0,
+ bottom_height: 4.0,
+ },
+ // Odd height, even spacing
+ Case::Horizontal {
+ overall_height: 9.0,
+ spacing: 2.0,
+ top_height: 4.0,
+ bottom_y: 6.0,
+ bottom_height: 3.0,
+ },
+ // Even height, odd spacing
+ Case::Horizontal {
+ overall_height: 10.0,
+ spacing: 1.0,
+ top_height: 5.0,
+ bottom_y: 6.0,
+ bottom_height: 4.0,
+ },
+ // Odd height, odd spacing
+ Case::Horizontal {
+ overall_height: 9.0,
+ spacing: 1.0,
+ top_height: 4.0,
+ bottom_y: 5.0,
+ bottom_height: 4.0,
+ },
+ // Even width, even spacing
+ Case::Vertical {
+ overall_width: 10.0,
+ spacing: 2.0,
+ left_width: 4.0,
+ right_x: 6.0,
+ right_width: 4.0,
+ },
+ // Odd width, even spacing
+ Case::Vertical {
+ overall_width: 9.0,
+ spacing: 2.0,
+ left_width: 4.0,
+ right_x: 6.0,
+ right_width: 3.0,
+ },
+ // Even width, odd spacing
+ Case::Vertical {
+ overall_width: 10.0,
+ spacing: 1.0,
+ left_width: 5.0,
+ right_x: 6.0,
+ right_width: 4.0,
+ },
+ // Odd width, odd spacing
+ Case::Vertical {
+ overall_width: 9.0,
+ spacing: 1.0,
+ left_width: 4.0,
+ right_x: 5.0,
+ right_width: 4.0,
+ },
+ ];
+ for case in cases {
+ match case {
+ Case::Horizontal {
+ overall_height,
+ spacing,
+ top_height,
+ bottom_y,
+ bottom_height,
+ } => {
+ let a = Axis::Horizontal;
+ let r = Rectangle {
+ x: 0.0,
+ y: 0.0,
+ width: 10.0,
+ height: overall_height,
+ };
+ let (top, bottom) = a.split(&r, 0.5, spacing);
+ assert_eq!(
+ top,
+ Rectangle {
+ height: top_height,
+ ..r
+ }
+ );
+ assert_eq!(
+ bottom,
+ Rectangle {
+ y: bottom_y,
+ height: bottom_height,
+ ..r
+ }
+ );
+ }
+ Case::Vertical {
+ overall_width,
+ spacing,
+ left_width,
+ right_x,
+ right_width,
+ } => {
+ let a = Axis::Vertical;
+ let r = Rectangle {
+ x: 0.0,
+ y: 0.0,
+ width: overall_width,
+ height: 10.0,
+ };
+ let (left, right) = a.split(&r, 0.5, spacing);
+ assert_eq!(
+ left,
+ Rectangle {
+ width: left_width,
+ ..r
+ }
+ );
+ assert_eq!(
+ right,
+ Rectangle {
+ x: right_x,
+ width: right_width,
+ ..r
+ }
+ );
+ }
+ }
+ }
+ }
+}
diff --git a/native/src/widget/pane_grid/content.rs b/native/src/widget/pane_grid/content.rs
new file mode 100644
index 00000000..8822083e
--- /dev/null
+++ b/native/src/widget/pane_grid/content.rs
@@ -0,0 +1,30 @@
+use crate::pane_grid::Axis;
+
+/// The content of a [`PaneGrid`].
+///
+/// [`PaneGrid`]: struct.PaneGrid.html
+#[derive(Debug, Clone)]
+pub enum Content<T> {
+ /// A split of the available space.
+ Split {
+ /// The direction of the split.
+ axis: Axis,
+
+ /// The ratio of the split in [0.0, 1.0].
+ ratio: f32,
+
+ /// The left/top [`Content`] of the split.
+ ///
+ /// [`Content`]: enum.Node.html
+ a: Box<Content<T>>,
+
+ /// The right/bottom [`Content`] of the split.
+ ///
+ /// [`Content`]: enum.Node.html
+ b: Box<Content<T>>,
+ },
+ /// A [`Pane`].
+ ///
+ /// [`Pane`]: struct.Pane.html
+ Pane(T),
+}
diff --git a/native/src/widget/pane_grid/node.rs b/native/src/widget/pane_grid/node.rs
index 4d5970b8..b13c5e26 100644
--- a/native/src/widget/pane_grid/node.rs
+++ b/native/src/widget/pane_grid/node.rs
@@ -5,20 +5,98 @@ use crate::{
use std::collections::HashMap;
-#[derive(Debug, Clone, Hash)]
+/// A layout node of a [`PaneGrid`].
+///
+/// [`PaneGrid`]: struct.PaneGrid.html
+#[derive(Debug, Clone)]
pub enum Node {
+ /// The region of this [`Node`] is split into two.
+ ///
+ /// [`Node`]: enum.Node.html
Split {
+ /// The [`Split`] of this [`Node`].
+ ///
+ /// [`Split`]: struct.Split.html
+ /// [`Node`]: enum.Node.html
id: Split,
+
+ /// The direction of the split.
axis: Axis,
- ratio: u32,
+
+ /// The ratio of the split in [0.0, 1.0].
+ ratio: f32,
+
+ /// The left/top [`Node`] of the split.
+ ///
+ /// [`Node`]: enum.Node.html
a: Box<Node>,
+
+ /// The right/bottom [`Node`] of the split.
+ ///
+ /// [`Node`]: enum.Node.html
b: Box<Node>,
},
+ /// The region of this [`Node`] is taken by a [`Pane`].
+ ///
+ /// [`Pane`]: struct.Pane.html
Pane(Pane),
}
impl Node {
- pub fn find(&mut self, pane: &Pane) -> Option<&mut Node> {
+ /// 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(
+ &self,
+ spacing: f32,
+ size: Size,
+ ) -> HashMap<Pane, Rectangle> {
+ let mut regions = HashMap::new();
+
+ self.compute_regions(
+ spacing,
+ &Rectangle {
+ x: 0.0,
+ y: 0.0,
+ width: size.width,
+ height: size.height,
+ },
+ &mut regions,
+ );
+
+ regions
+ }
+
+ /// Returns the axis, rectangular region, and ratio for each [`Split`] in
+ /// the [`Node`] given the spacing between panes and the total available
+ /// space.
+ ///
+ /// [`Split`]: struct.Split.html
+ /// [`Node`]: enum.Node.html
+ pub fn splits(
+ &self,
+ spacing: f32,
+ size: Size,
+ ) -> HashMap<Split, (Axis, Rectangle, f32)> {
+ let mut splits = HashMap::new();
+
+ self.compute_splits(
+ spacing,
+ &Rectangle {
+ x: 0.0,
+ y: 0.0,
+ width: size.width,
+ height: size.height,
+ },
+ &mut splits,
+ );
+
+ splits
+ }
+
+ pub(crate) fn find(&mut self, pane: &Pane) -> Option<&mut Node> {
match self {
Node::Split { a, b, .. } => {
a.find(pane).or_else(move || b.find(pane))
@@ -33,17 +111,17 @@ impl Node {
}
}
- pub fn split(&mut self, id: Split, axis: Axis, new_pane: Pane) {
+ pub(crate) fn split(&mut self, id: Split, axis: Axis, new_pane: Pane) {
*self = Node::Split {
id,
axis,
- ratio: 500_000,
+ ratio: 0.5,
a: Box::new(self.clone()),
b: Box::new(Node::Pane(new_pane)),
};
}
- pub fn update(&mut self, f: &impl Fn(&mut Node)) {
+ pub(crate) fn update(&mut self, f: &impl Fn(&mut Node)) {
match self {
Node::Split { a, b, .. } => {
a.update(f);
@@ -55,13 +133,13 @@ impl Node {
f(self);
}
- pub fn resize(&mut self, split: &Split, percentage: f32) -> bool {
+ pub(crate) fn resize(&mut self, split: &Split, percentage: f32) -> bool {
match self {
Node::Split {
id, ratio, a, b, ..
} => {
if id == split {
- *ratio = (percentage * 1_000_000.0).round() as u32;
+ *ratio = percentage;
true
} else if a.resize(split, percentage) {
@@ -74,7 +152,7 @@ impl Node {
}
}
- pub fn remove(&mut self, pane: &Pane) -> Option<Pane> {
+ pub(crate) fn remove(&mut self, pane: &Pane) -> Option<Pane> {
match self {
Node::Split { a, b, .. } => {
if a.pane() == Some(*pane) {
@@ -91,56 +169,14 @@ impl Node {
}
}
- pub fn regions(
- &self,
- spacing: f32,
- size: Size,
- ) -> HashMap<Pane, Rectangle> {
- let mut regions = HashMap::new();
-
- self.compute_regions(
- spacing / 2.0,
- &Rectangle {
- x: 0.0,
- y: 0.0,
- width: size.width,
- height: size.height,
- },
- &mut regions,
- );
-
- regions
- }
-
- pub fn splits(
- &self,
- spacing: f32,
- size: Size,
- ) -> HashMap<Split, (Axis, Rectangle, f32)> {
- let mut splits = HashMap::new();
-
- self.compute_splits(
- spacing / 2.0,
- &Rectangle {
- x: 0.0,
- y: 0.0,
- width: size.width,
- height: size.height,
- },
- &mut splits,
- );
-
- splits
- }
-
- pub fn pane(&self) -> Option<Pane> {
+ fn pane(&self) -> Option<Pane> {
match self {
Node::Split { .. } => None,
Node::Pane(pane) => Some(*pane),
}
}
- pub fn first_pane(&self) -> Pane {
+ fn first_pane(&self) -> Pane {
match self {
Node::Split { a, .. } => a.first_pane(),
Node::Pane(pane) => *pane,
@@ -149,7 +185,7 @@ impl Node {
fn compute_regions(
&self,
- halved_spacing: f32,
+ spacing: f32,
current: &Rectangle,
regions: &mut HashMap<Pane, Rectangle>,
) {
@@ -157,12 +193,10 @@ impl Node {
Node::Split {
axis, ratio, a, b, ..
} => {
- let ratio = *ratio as f32 / 1_000_000.0;
- let (region_a, region_b) =
- axis.split(current, ratio, halved_spacing);
+ let (region_a, region_b) = axis.split(current, *ratio, spacing);
- a.compute_regions(halved_spacing, &region_a, regions);
- b.compute_regions(halved_spacing, &region_b, regions);
+ a.compute_regions(spacing, &region_a, regions);
+ b.compute_regions(spacing, &region_b, regions);
}
Node::Pane(pane) => {
let _ = regions.insert(*pane, *current);
@@ -172,7 +206,7 @@ impl Node {
fn compute_splits(
&self,
- halved_spacing: f32,
+ spacing: f32,
current: &Rectangle,
splits: &mut HashMap<Split, (Axis, Rectangle, f32)>,
) {
@@ -184,16 +218,37 @@ impl Node {
b,
id,
} => {
- let ratio = *ratio as f32 / 1_000_000.0;
- let (region_a, region_b) =
- axis.split(current, ratio, halved_spacing);
+ let (region_a, region_b) = axis.split(current, *ratio, spacing);
- let _ = splits.insert(*id, (*axis, *current, ratio));
+ let _ = splits.insert(*id, (*axis, *current, *ratio));
- a.compute_splits(halved_spacing, &region_a, splits);
- b.compute_splits(halved_spacing, &region_b, splits);
+ a.compute_splits(spacing, &region_a, splits);
+ b.compute_splits(spacing, &region_b, splits);
}
Node::Pane(_) => {}
}
}
}
+
+impl std::hash::Hash for Node {
+ fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+ match self {
+ Node::Split {
+ id,
+ axis,
+ ratio,
+ a,
+ b,
+ } => {
+ id.hash(state);
+ axis.hash(state);
+ ((ratio * 100_000.0) as u32).hash(state);
+ a.hash(state);
+ b.hash(state);
+ }
+ Node::Pane(pane) => {
+ pane.hash(state);
+ }
+ }
+ }
+}
diff --git a/native/src/widget/pane_grid/state.rs b/native/src/widget/pane_grid/state.rs
index ed2813b8..4b13fb8e 100644
--- a/native/src/widget/pane_grid/state.rs
+++ b/native/src/widget/pane_grid/state.rs
@@ -1,6 +1,6 @@
use crate::{
keyboard,
- pane_grid::{node::Node, Axis, Direction, Pane, Split},
+ pane_grid::{Axis, Content, Direction, Node, Pane, Split},
Hasher, Point, Rectangle, Size,
};
@@ -21,7 +21,7 @@ use std::collections::HashMap;
/// [`Pane`]: struct.Pane.html
/// [`Split`]: struct.Split.html
/// [`State`]: struct.State.html
-#[derive(Debug)]
+#[derive(Debug, Clone)]
pub struct State<T> {
pub(super) panes: HashMap<Pane, T>,
pub(super) internal: Internal,
@@ -53,23 +53,28 @@ impl<T> State<T> {
/// [`State`]: struct.State.html
/// [`Pane`]: struct.Pane.html
pub fn new(first_pane_state: T) -> (Self, Pane) {
- let first_pane = Pane(0);
+ (Self::with_content(Content::Pane(first_pane_state)), Pane(0))
+ }
+ /// Creates a new [`State`] with the given [`Content`].
+ ///
+ /// [`State`]: struct.State.html
+ /// [`Content`]: enum.Content.html
+ pub fn with_content(content: impl Into<Content<T>>) -> Self {
let mut panes = HashMap::new();
- let _ = panes.insert(first_pane, first_pane_state);
-
- (
- State {
- panes,
- internal: Internal {
- layout: Node::Pane(first_pane),
- last_id: 0,
- action: Action::Idle { focus: None },
- },
- modifiers: keyboard::ModifiersState::default(),
+
+ let (layout, last_id) =
+ Self::distribute_content(&mut panes, content.into(), 0);
+
+ State {
+ panes,
+ internal: Internal {
+ layout,
+ last_id,
+ action: Action::Idle { focus: None },
},
- first_pane,
- )
+ modifiers: keyboard::ModifiersState::default(),
+ }
}
/// Returns the total amount of panes in the [`State`].
@@ -82,6 +87,14 @@ impl<T> State<T> {
/// Returns the internal state of the given [`Pane`], if it exists.
///
/// [`Pane`]: struct.Pane.html
+ pub fn get(&self, pane: &Pane) -> Option<&T> {
+ self.panes.get(pane)
+ }
+
+ /// Returns the internal state of the given [`Pane`] with mutability, if it
+ /// exists.
+ ///
+ /// [`Pane`]: struct.Pane.html
pub fn get_mut(&mut self, pane: &Pane) -> Option<&mut T> {
self.panes.get_mut(pane)
}
@@ -102,6 +115,13 @@ impl<T> State<T> {
self.panes.iter_mut()
}
+ /// Returns the layout of the [`State`].
+ ///
+ /// [`State`]: struct.State.html
+ pub fn layout(&self) -> &Node {
+ &self.internal.layout
+ }
+
/// Returns the active [`Pane`] of the [`State`], if there is one.
///
/// A [`Pane`] is active if it is focused and is __not__ being dragged.
@@ -176,7 +196,12 @@ impl<T> State<T> {
///
/// [`Pane`]: struct.Pane.html
/// [`Axis`]: enum.Axis.html
- pub fn split(&mut self, axis: Axis, pane: &Pane, state: T) -> Option<Pane> {
+ pub fn split(
+ &mut self,
+ axis: Axis,
+ pane: &Pane,
+ state: T,
+ ) -> Option<(Pane, Split)> {
let node = self.internal.layout.find(pane)?;
let new_pane = {
@@ -196,7 +221,7 @@ impl<T> State<T> {
let _ = self.panes.insert(new_pane, state);
self.focus(&new_pane);
- Some(new_pane)
+ Some((new_pane, new_split))
}
/// Swaps the position of the provided panes in the [`State`].
@@ -246,9 +271,39 @@ impl<T> State<T> {
None
}
}
+
+ fn distribute_content(
+ panes: &mut HashMap<Pane, T>,
+ content: Content<T>,
+ next_id: usize,
+ ) -> (Node, usize) {
+ match content {
+ Content::Split { axis, ratio, a, b } => {
+ let (a, next_id) = Self::distribute_content(panes, *a, next_id);
+ let (b, next_id) = Self::distribute_content(panes, *b, next_id);
+
+ (
+ Node::Split {
+ id: Split(next_id),
+ axis,
+ ratio,
+ a: Box::new(a),
+ b: Box::new(b),
+ },
+ next_id + 1,
+ )
+ }
+ Content::Pane(state) => {
+ let id = Pane(next_id);
+ let _ = panes.insert(id, state);
+
+ (Node::Pane(id), next_id + 1)
+ }
+ }
+ }
}
-#[derive(Debug)]
+#[derive(Debug, Clone)]
pub struct Internal {
layout: Node,
last_id: usize,
diff --git a/wgpu/src/shader/quad.vert b/wgpu/src/shader/quad.vert
index 1d9a4fd2..11f95eeb 100644
--- a/wgpu/src/shader/quad.vert
+++ b/wgpu/src/shader/quad.vert
@@ -21,14 +21,14 @@ layout(location = 4) out float o_BorderRadius;
layout(location = 5) out float o_BorderWidth;
void main() {
- vec2 p_Pos = i_Pos * u_Scale;
- vec2 p_Scale = i_Scale * u_Scale;
+ vec2 p_Pos = floor(i_Pos * u_Scale);
+ vec2 p_Scale = floor(i_Scale * u_Scale);
mat4 i_Transform = mat4(
- vec4(p_Scale.x + 1.0, 0.0, 0.0, 0.0),
- vec4(0.0, p_Scale.y + 1.0, 0.0, 0.0),
+ vec4(p_Scale.x, 0.0, 0.0, 0.0),
+ vec4(0.0, p_Scale.y, 0.0, 0.0),
vec4(0.0, 0.0, 1.0, 0.0),
- vec4(p_Pos - vec2(0.5, 0.5), 0.0, 1.0)
+ vec4(p_Pos, 0.0, 1.0)
);
o_Color = i_Color;
@@ -36,7 +36,7 @@ void main() {
o_Pos = p_Pos;
o_Scale = p_Scale;
o_BorderRadius = i_BorderRadius * u_Scale;
- o_BorderWidth = i_BorderWidth * u_Scale;
+ o_BorderWidth = floor(i_BorderWidth * u_Scale);
gl_Position = u_Transform * i_Transform * vec4(v_Pos, 0.0, 1.0);
}
diff --git a/wgpu/src/shader/quad.vert.spv b/wgpu/src/shader/quad.vert.spv
index 7059b51b..b3025a93 100644
--- a/wgpu/src/shader/quad.vert.spv
+++ b/wgpu/src/shader/quad.vert.spv
Binary files differ
diff --git a/wgpu/src/widget/pane_grid.rs b/wgpu/src/widget/pane_grid.rs
index 578e8960..6f437df7 100644
--- a/wgpu/src/widget/pane_grid.rs
+++ b/wgpu/src/widget/pane_grid.rs
@@ -11,8 +11,8 @@
use crate::Renderer;
pub use iced_native::pane_grid::{
- Axis, Direction, DragEvent, Focus, KeyPressEvent, Pane, ResizeEvent, Split,
- State,
+ Axis, Content, Direction, DragEvent, Focus, KeyPressEvent, Node, Pane,
+ ResizeEvent, Split, State,
};
/// A collection of panes distributed using either vertical or horizontal splits
generated by cgit (git 2.34.1) at 2025-04-16 01:15:29 +0000