summaryrefslogtreecommitdiffstats
path: root/widget/src/pane_grid.rs
diff options
context:
space:
mode:
Diffstat (limited to 'widget/src/pane_grid.rs')
-rw-r--r--widget/src/pane_grid.rs442
1 files changed, 256 insertions, 186 deletions
diff --git a/widget/src/pane_grid.rs b/widget/src/pane_grid.rs
index e6fda660..5c3b343c 100644
--- a/widget/src/pane_grid.rs
+++ b/widget/src/pane_grid.rs
@@ -79,7 +79,6 @@ pub use state::State;
pub use title_bar::TitleBar;
use crate::container;
-use crate::core::event::{self, Event};
use crate::core::layout;
use crate::core::mouse;
use crate::core::overlay::{self, Group};
@@ -87,8 +86,9 @@ use crate::core::renderer;
use crate::core::touch;
use crate::core::widget;
use crate::core::widget::tree::{self, Tree};
+use crate::core::window;
use crate::core::{
- self, Background, Border, Clipboard, Color, Element, Layout, Length,
+ self, Background, Border, Clipboard, Color, Element, Event, Layout, Length,
Pixels, Point, Rectangle, Shell, Size, Theme, Vector, Widget,
};
@@ -157,7 +157,9 @@ pub struct PaneGrid<
Theme: Catalog,
Renderer: core::Renderer,
{
- contents: Contents<'a, Content<'a, Message, Theme, Renderer>>,
+ internal: &'a state::Internal,
+ panes: Vec<Pane>,
+ contents: Vec<Content<'a, Message, Theme, Renderer>>,
width: Length,
height: Length,
spacing: f32,
@@ -165,6 +167,7 @@ pub struct PaneGrid<
on_drag: Option<Box<dyn Fn(DragEvent) -> Message + 'a>>,
on_resize: Option<(f32, Box<dyn Fn(ResizeEvent) -> Message + 'a>)>,
class: <Theme as Catalog>::Class<'a>,
+ last_mouse_interaction: Option<mouse::Interaction>,
}
impl<'a, Message, Theme, Renderer> PaneGrid<'a, Message, Theme, Renderer>
@@ -180,29 +183,19 @@ where
state: &'a State<T>,
view: impl Fn(Pane, &'a T, bool) -> Content<'a, Message, Theme, Renderer>,
) -> Self {
- let contents = if let Some((pane, pane_state)) =
- state.maximized.and_then(|pane| {
- state.panes.get(&pane).map(|pane_state| (pane, pane_state))
- }) {
- Contents::Maximized(
- pane,
- view(pane, pane_state, true),
- Node::Pane(pane),
- )
- } else {
- Contents::All(
- state
- .panes
- .iter()
- .map(|(pane, pane_state)| {
- (*pane, view(*pane, pane_state, false))
- })
- .collect(),
- &state.internal,
- )
- };
+ let panes = state.panes.keys().copied().collect();
+ let contents = state
+ .panes
+ .iter()
+ .map(|(pane, pane_state)| match state.maximized() {
+ Some(p) if *pane == p => view(*pane, pane_state, true),
+ _ => view(*pane, pane_state, false),
+ })
+ .collect();
Self {
+ internal: &state.internal,
+ panes,
contents,
width: Length::Fill,
height: Length::Fill,
@@ -211,6 +204,7 @@ where
on_drag: None,
on_resize: None,
class: <Theme as Catalog>::default(),
+ last_mouse_interaction: None,
}
}
@@ -248,7 +242,9 @@ where
where
F: 'a + Fn(DragEvent) -> Message,
{
- self.on_drag = Some(Box::new(f));
+ if self.internal.maximized().is_none() {
+ self.on_drag = Some(Box::new(f));
+ }
self
}
@@ -265,7 +261,9 @@ where
where
F: 'a + Fn(ResizeEvent) -> Message,
{
- self.on_resize = Some((leeway.into().0, Box::new(f)));
+ if self.internal.maximized().is_none() {
+ self.on_resize = Some((leeway.into().0, Box::new(f)));
+ }
self
}
@@ -291,46 +289,114 @@ where
}
fn drag_enabled(&self) -> bool {
- (!self.contents.is_maximized())
+ self.internal
+ .maximized()
+ .is_none()
.then(|| self.on_drag.is_some())
.unwrap_or_default()
}
+
+ fn grid_interaction(
+ &self,
+ action: &state::Action,
+ layout: Layout<'_>,
+ cursor: mouse::Cursor,
+ ) -> Option<mouse::Interaction> {
+ if action.picked_pane().is_some() {
+ return Some(mouse::Interaction::Grabbing);
+ }
+
+ let resize_leeway = self.on_resize.as_ref().map(|(leeway, _)| *leeway);
+ let node = self.internal.layout();
+
+ let resize_axis =
+ action.picked_split().map(|(_, axis)| axis).or_else(|| {
+ resize_leeway.and_then(|leeway| {
+ let cursor_position = cursor.position()?;
+ let bounds = layout.bounds();
+
+ let splits =
+ node.split_regions(self.spacing, bounds.size());
+
+ let relative_cursor = Point::new(
+ cursor_position.x - bounds.x,
+ cursor_position.y - bounds.y,
+ );
+
+ hovered_split(
+ splits.iter(),
+ self.spacing + leeway,
+ relative_cursor,
+ )
+ .map(|(_, axis, _)| axis)
+ })
+ });
+
+ if let Some(resize_axis) = resize_axis {
+ return Some(match resize_axis {
+ Axis::Horizontal => mouse::Interaction::ResizingVertically,
+ Axis::Vertical => mouse::Interaction::ResizingHorizontally,
+ });
+ }
+
+ None
+ }
+}
+
+#[derive(Default)]
+struct Memory {
+ action: state::Action,
+ order: Vec<Pane>,
}
-impl<'a, Message, Theme, Renderer> Widget<Message, Theme, Renderer>
- for PaneGrid<'a, Message, Theme, Renderer>
+impl<Message, Theme, Renderer> Widget<Message, Theme, Renderer>
+ for PaneGrid<'_, Message, Theme, Renderer>
where
Theme: Catalog,
Renderer: core::Renderer,
{
fn tag(&self) -> tree::Tag {
- tree::Tag::of::<state::Action>()
+ tree::Tag::of::<Memory>()
}
fn state(&self) -> tree::State {
- tree::State::new(state::Action::Idle)
+ tree::State::new(Memory::default())
}
fn children(&self) -> Vec<Tree> {
- self.contents
- .iter()
- .map(|(_, content)| content.state())
- .collect()
+ self.contents.iter().map(Content::state).collect()
}
fn diff(&self, tree: &mut Tree) {
- match &self.contents {
- Contents::All(contents, _) => tree.diff_children_custom(
- contents,
- |state, (_, content)| content.diff(state),
- |(_, content)| content.state(),
- ),
- Contents::Maximized(_, content, _) => tree.diff_children_custom(
- &[content],
- |state, content| content.diff(state),
- |content| content.state(),
- ),
- }
+ let Memory { order, .. } = tree.state.downcast_ref();
+
+ // `Pane` always increments and is iterated by Ord so new
+ // states are always added at the end. We can simply remove
+ // states which no longer exist and `diff_children` will
+ // diff the remaining values in the correct order and
+ // add new states at the end
+
+ let mut i = 0;
+ let mut j = 0;
+ tree.children.retain(|_| {
+ let retain = self.panes.get(i) == order.get(j);
+
+ if retain {
+ i += 1;
+ }
+ j += 1;
+
+ retain
+ });
+
+ tree.diff_children_custom(
+ &self.contents,
+ |state, content| content.diff(state),
+ Content::state,
+ );
+
+ let Memory { order, .. } = tree.state.downcast_mut();
+ order.clone_from(&self.panes);
}
fn size(&self) -> Size<Length> {
@@ -347,14 +413,23 @@ where
limits: &layout::Limits,
) -> layout::Node {
let size = limits.resolve(self.width, self.height, Size::ZERO);
- let node = self.contents.layout();
- let regions = node.pane_regions(self.spacing, size);
+ let regions = self.internal.layout().pane_regions(self.spacing, size);
let children = self
- .contents
+ .panes
.iter()
+ .copied()
+ .zip(&self.contents)
.zip(tree.children.iter_mut())
.filter_map(|((pane, content), tree)| {
+ if self
+ .internal
+ .maximized()
+ .is_some_and(|maximized| maximized != pane)
+ {
+ return Some(layout::Node::new(Size::ZERO));
+ }
+
let region = regions.get(&pane)?;
let size = Size::new(region.width, region.height);
@@ -379,17 +454,24 @@ where
operation: &mut dyn widget::Operation,
) {
operation.container(None, layout.bounds(), &mut |operation| {
- self.contents
+ self.panes
.iter()
+ .copied()
+ .zip(&self.contents)
.zip(&mut tree.children)
.zip(layout.children())
- .for_each(|(((_pane, content), state), layout)| {
+ .filter(|(((pane, _), _), _)| {
+ self.internal
+ .maximized()
+ .map_or(true, |maximized| *pane == maximized)
+ })
+ .for_each(|(((_, content), state), layout)| {
content.operate(state, layout, renderer, operation);
});
});
}
- fn on_event(
+ fn update(
&mut self,
tree: &mut Tree,
event: Event,
@@ -399,11 +481,9 @@ where
clipboard: &mut dyn Clipboard,
shell: &mut Shell<'_, Message>,
viewport: &Rectangle,
- ) -> event::Status {
- let mut event_status = event::Status::Ignored;
-
- let action = tree.state.downcast_mut::<state::Action>();
- let node = self.contents.layout();
+ ) {
+ let Memory { action, .. } = tree.state.downcast_mut();
+ let node = self.internal.layout();
let on_drag = if self.drag_enabled() {
&self.on_drag
@@ -411,13 +491,43 @@ where
&None
};
+ let picked_pane = action.picked_pane().map(|(pane, _)| pane);
+
+ for (((pane, content), tree), layout) in self
+ .panes
+ .iter()
+ .copied()
+ .zip(&mut self.contents)
+ .zip(&mut tree.children)
+ .zip(layout.children())
+ .filter(|(((pane, _), _), _)| {
+ self.internal
+ .maximized()
+ .map_or(true, |maximized| *pane == maximized)
+ })
+ {
+ let is_picked = picked_pane == Some(pane);
+
+ content.update(
+ tree,
+ event.clone(),
+ layout,
+ cursor,
+ renderer,
+ clipboard,
+ shell,
+ viewport,
+ is_picked,
+ );
+ }
+
match event {
Event::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left))
| Event::Touch(touch::Event::FingerPressed { .. }) => {
let bounds = layout.bounds();
if let Some(cursor_position) = cursor.position_over(bounds) {
- event_status = event::Status::Captured;
+ shell.capture_event();
match &self.on_resize {
Some((leeway, _)) => {
@@ -448,7 +558,10 @@ where
layout,
cursor_position,
shell,
- self.contents.iter(),
+ self.panes
+ .iter()
+ .copied()
+ .zip(&self.contents),
&self.on_click,
on_drag,
);
@@ -460,7 +573,7 @@ where
layout,
cursor_position,
shell,
- self.contents.iter(),
+ self.panes.iter().copied().zip(&self.contents),
&self.on_click,
on_drag,
);
@@ -486,8 +599,10 @@ where
}
} else {
let dropped_region = self
- .contents
+ .panes
.iter()
+ .copied()
+ .zip(&self.contents)
.zip(layout.children())
.find_map(|(target, layout)| {
layout_region(
@@ -513,13 +628,13 @@ where
};
shell.publish(on_drag(event));
+ } else {
+ shell.publish(on_drag(DragEvent::Canceled {
+ pane,
+ }));
}
}
}
-
- event_status = event::Status::Captured;
- } else if action.picked_split().is_some() {
- event_status = event::Status::Captured;
}
*action = state::Action::Idle;
@@ -561,37 +676,48 @@ where
ratio,
}));
- event_status = event::Status::Captured;
+ shell.capture_event();
}
}
+ } else if action.picked_pane().is_some() {
+ shell.request_redraw();
}
}
}
_ => {}
}
- let picked_pane = action.picked_pane().map(|(pane, _)| pane);
-
- self.contents
- .iter_mut()
- .zip(&mut tree.children)
- .zip(layout.children())
- .map(|(((pane, content), tree), layout)| {
- let is_picked = picked_pane == Some(pane);
-
- content.on_event(
- tree,
- event.clone(),
- layout,
- cursor,
- renderer,
- clipboard,
- shell,
- viewport,
- is_picked,
- )
- })
- .fold(event_status, event::Status::merge)
+ if shell.redraw_request() != Some(window::RedrawRequest::NextFrame) {
+ let interaction = self
+ .grid_interaction(action, layout, cursor)
+ .or_else(|| {
+ self.panes
+ .iter()
+ .zip(&self.contents)
+ .zip(layout.children())
+ .filter(|((&pane, _content), _layout)| {
+ self.internal
+ .maximized()
+ .map_or(true, |maximized| pane == maximized)
+ })
+ .find_map(|((_pane, content), layout)| {
+ content.grid_interaction(
+ layout,
+ cursor,
+ on_drag.is_some(),
+ )
+ })
+ })
+ .unwrap_or(mouse::Interaction::None);
+
+ if let Event::Window(window::Event::RedrawRequested(_now)) = event {
+ self.last_mouse_interaction = Some(interaction);
+ } else if self.last_mouse_interaction.is_some_and(
+ |last_mouse_interaction| last_mouse_interaction != interaction,
+ ) {
+ shell.request_redraw();
+ }
+ }
}
fn mouse_interaction(
@@ -602,50 +728,26 @@ where
viewport: &Rectangle,
renderer: &Renderer,
) -> mouse::Interaction {
- let action = tree.state.downcast_ref::<state::Action>();
-
- if action.picked_pane().is_some() {
- return mouse::Interaction::Grabbing;
- }
-
- let resize_leeway = self.on_resize.as_ref().map(|(leeway, _)| *leeway);
- let node = self.contents.layout();
-
- let resize_axis =
- action.picked_split().map(|(_, axis)| axis).or_else(|| {
- resize_leeway.and_then(|leeway| {
- let cursor_position = cursor.position()?;
- let bounds = layout.bounds();
-
- let splits =
- node.split_regions(self.spacing, bounds.size());
-
- let relative_cursor = Point::new(
- cursor_position.x - bounds.x,
- cursor_position.y - bounds.y,
- );
-
- hovered_split(
- splits.iter(),
- self.spacing + leeway,
- relative_cursor,
- )
- .map(|(_, axis, _)| axis)
- })
- });
+ let Memory { action, .. } = tree.state.downcast_ref();
- if let Some(resize_axis) = resize_axis {
- return match resize_axis {
- Axis::Horizontal => mouse::Interaction::ResizingVertically,
- Axis::Vertical => mouse::Interaction::ResizingHorizontally,
- };
+ if let Some(grid_interaction) =
+ self.grid_interaction(action, layout, cursor)
+ {
+ return grid_interaction;
}
- self.contents
+ self.panes
.iter()
+ .copied()
+ .zip(&self.contents)
.zip(&tree.children)
.zip(layout.children())
- .map(|(((_pane, content), tree), layout)| {
+ .filter(|(((pane, _), _), _)| {
+ self.internal
+ .maximized()
+ .map_or(true, |maximized| *pane == maximized)
+ })
+ .map(|(((_, content), tree), layout)| {
content.mouse_interaction(
tree,
layout,
@@ -669,16 +771,10 @@ where
cursor: mouse::Cursor,
viewport: &Rectangle,
) {
- let action = tree.state.downcast_ref::<state::Action>();
- let node = self.contents.layout();
+ let Memory { action, .. } = tree.state.downcast_ref();
+ let node = self.internal.layout();
let resize_leeway = self.on_resize.as_ref().map(|(leeway, _)| *leeway);
- let contents = self
- .contents
- .iter()
- .zip(&tree.children)
- .map(|((pane, content), tree)| (pane, (content, tree)));
-
let picked_pane = action.picked_pane().filter(|(_, origin)| {
cursor
.position()
@@ -747,8 +843,18 @@ where
let style = Catalog::style(theme, &self.class);
- for ((id, (content, tree)), pane_layout) in
- contents.zip(layout.children())
+ for (((id, content), tree), pane_layout) in self
+ .panes
+ .iter()
+ .copied()
+ .zip(&self.contents)
+ .zip(&tree.children)
+ .zip(layout.children())
+ .filter(|(((pane, _), _), _)| {
+ self.internal
+ .maximized()
+ .map_or(true, |maximized| maximized == *pane)
+ })
{
match picked_pane {
Some((dragging, origin)) if id == dragging => {
@@ -883,11 +989,21 @@ where
translation: Vector,
) -> Option<overlay::Element<'b, Message, Theme, Renderer>> {
let children = self
- .contents
- .iter_mut()
+ .panes
+ .iter()
+ .copied()
+ .zip(&mut self.contents)
.zip(&mut tree.children)
.zip(layout.children())
- .filter_map(|(((_, content), state), layout)| {
+ .filter_map(|(((pane, content), state), layout)| {
+ if self
+ .internal
+ .maximized()
+ .is_some_and(|maximized| maximized != pane)
+ {
+ return None;
+ }
+
content.overlay(state, layout, renderer, translation)
})
.collect::<Vec<_>>();
@@ -1136,52 +1252,6 @@ fn hovered_split<'a>(
})
}
-/// The visible contents of the [`PaneGrid`]
-#[derive(Debug)]
-pub enum Contents<'a, T> {
- /// All panes are visible
- All(Vec<(Pane, T)>, &'a state::Internal),
- /// A maximized pane is visible
- Maximized(Pane, T, Node),
-}
-
-impl<'a, T> Contents<'a, T> {
- /// Returns the layout [`Node`] of the [`Contents`]
- pub fn layout(&self) -> &Node {
- match self {
- Contents::All(_, state) => state.layout(),
- Contents::Maximized(_, _, layout) => layout,
- }
- }
-
- /// Returns an iterator over the values of the [`Contents`]
- pub fn iter(&self) -> Box<dyn Iterator<Item = (Pane, &T)> + '_> {
- match self {
- Contents::All(contents, _) => Box::new(
- contents.iter().map(|(pane, content)| (*pane, content)),
- ),
- Contents::Maximized(pane, content, _) => {
- Box::new(std::iter::once((*pane, content)))
- }
- }
- }
-
- fn iter_mut(&mut self) -> Box<dyn Iterator<Item = (Pane, &mut T)> + '_> {
- match self {
- Contents::All(contents, _) => Box::new(
- contents.iter_mut().map(|(pane, content)| (*pane, content)),
- ),
- Contents::Maximized(pane, content, _) => {
- Box::new(std::iter::once((*pane, content)))
- }
- }
- }
-
- fn is_maximized(&self) -> bool {
- matches!(self, Self::Maximized(..))
- }
-}
-
/// The appearance of a [`PaneGrid`].
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct Style {
generated by cgit (git 2.34.1) at 2025-04-17 20:34:09 +0000