leyoda/libcosmic
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

refactor: remove menu tree changes

Browse source
This commit is contained in:
Ashley Wulber 2025-02-17 16:40:11 -05:00
parent 93e3d4fd42
commit 5a5670eda5
No known key found for this signature in database
GPG key ID: 5216D4F46A90A820
9 changed files with 221 additions and 197 deletions
Download patch file Download diff file Expand all files Collapse all files

166
src/widget/wrapper.rs
View file

@ -1,19 +1,55 @@
use std::sync::{Arc, Mutex};
use std::{
cell::RefCell,
rc::Rc,
thread::{self, ThreadId},
};
use crate::Element;
use iced::{event, Length, Rectangle, Size};
use iced_core::{id::Id, widget, widget::tree, Widget};
#[derive(Clone)]
pub struct ArcElementWrapper<M>(pub Arc<Mutex<Element<'static, M>>>);
pub struct RcElementWrapper<M> {
pub(crate) element: Rc<RefCell<Element<'static, M>>>,
pub(crate) thread_id: ThreadId,
}
impl<M> Widget<M, crate::Theme, crate::Renderer> for ArcElementWrapper<M> {
impl<M> RcElementWrapper<M> {
pub fn new(element: Element<'static, M>) -> Self {
Self {
element: Rc::new(RefCell::new(element)),
thread_id: thread::current().id(),
}
}
pub fn with_element<T>(&self, f: impl FnOnce(&Element<'static, M>) -> T) -> T {
assert_eq!(self.thread_id, thread::current().id());
let my_ref: &Element<'static, M> = &RefCell::borrow(self.element.as_ref());
f(my_ref)
}
pub fn with_element_mut<T>(&self, f: impl FnOnce(&mut Element<'static, M>) -> T) -> T {
assert_eq!(self.thread_id, thread::current().id());
let my_refmut: &mut Element<'static, M> = &mut RefCell::borrow_mut(self.element.as_ref());
f(my_refmut)
}
pub(crate) unsafe fn as_ptr(&self) -> *mut Element<'static, M> {
assert_eq!(self.thread_id, thread::current().id());
RefCell::as_ptr(self.element.as_ref())
}
}
unsafe impl<M: 'static> Send for RcElementWrapper<M> {}
unsafe impl<M: 'static> Sync for RcElementWrapper<M> {}
impl<M> Widget<M, crate::Theme, crate::Renderer> for RcElementWrapper<M> {
fn size(&self) -> Size<Length> {
self.0.lock().unwrap().as_widget().size()
self.with_element(|e| e.as_widget().size())
}
fn size_hint(&self) -> Size<Length> {
self.0.lock().unwrap().as_widget().size_hint()
self.element.borrow_mut().as_widget().size_hint()
}
fn layout(
@ -22,11 +58,7 @@ impl<M> Widget<M, crate::Theme, crate::Renderer> for ArcElementWrapper<M> {
renderer: &crate::Renderer,
limits: &crate::iced_core::layout::Limits,
) -> crate::iced_core::layout::Node {
self.0
.lock()
.unwrap()
.as_widget_mut()
.layout(tree, renderer, limits)
self.with_element_mut(|e| e.as_widget_mut().layout(tree, renderer, limits))
}
fn draw(
@ -39,27 +71,26 @@ impl<M> Widget<M, crate::Theme, crate::Renderer> for ArcElementWrapper<M> {
cursor: crate::iced_core::mouse::Cursor,
viewport: &Rectangle,
) {
self.0
.lock()
.unwrap()
.as_widget()
.draw(tree, renderer, theme, style, layout, cursor, viewport)
self.with_element(move |e| {
e.as_widget()
.draw(tree, renderer, theme, style, layout, cursor, viewport)
})
}
fn tag(&self) -> tree::Tag {
self.0.lock().unwrap().as_widget().tag()
self.with_element(|e| e.as_widget().tag())
}
fn state(&self) -> tree::State {
self.0.lock().unwrap().as_widget().state()
self.with_element(|e| e.as_widget().state())
}
fn children(&self) -> Vec<tree::Tree> {
self.0.lock().unwrap().as_widget().children()
self.with_element(|e| e.as_widget().children())
}
fn diff(&mut self, tree: &mut tree::Tree) {
self.0.lock().unwrap().as_widget_mut().diff(tree)
self.with_element_mut(|e| e.as_widget_mut().diff(tree))
}
fn operate(
@ -69,87 +100,88 @@ impl<M> Widget<M, crate::Theme, crate::Renderer> for ArcElementWrapper<M> {
renderer: &crate::Renderer,
operation: &mut dyn widget::Operation,
) {
self.0
.lock()
.unwrap()
.as_widget()
.operate(state, layout, renderer, operation)
self.with_element(|e| {
e.as_widget().operate(state, layout, renderer, operation);
})
}
fn on_event(
&mut self,
_state: &mut tree::Tree,
_event: crate::iced::Event,
_layout: crate::iced_core::Layout<'_>,
_cursor: crate::iced_core::mouse::Cursor,
_renderer: &crate::Renderer,
_clipboard: &mut dyn crate::iced_core::Clipboard,
_shell: &mut crate::iced_core::Shell<'_, M>,
_viewport: &Rectangle,
state: &mut tree::Tree,
event: crate::iced::Event,
layout: crate::iced_core::Layout<'_>,
cursor: crate::iced_core::mouse::Cursor,
renderer: &crate::Renderer,
clipboard: &mut dyn crate::iced_core::Clipboard,
shell: &mut crate::iced_core::Shell<'_, M>,
viewport: &Rectangle,
) -> event::Status {
self.0.lock().unwrap().as_widget_mut().on_event(
_state, _event, _layout, _cursor, _renderer, _clipboard, _shell, _viewport,
)
self.with_element_mut(|e| {
e.as_widget_mut().on_event(
state, event, layout, cursor, renderer, clipboard, shell, viewport,
)
})
}
fn mouse_interaction(
&self,
_state: &tree::Tree,
_layout: crate::iced_core::Layout<'_>,
_cursor: crate::iced_core::mouse::Cursor,
_viewport: &Rectangle,
_renderer: &crate::Renderer,
state: &tree::Tree,
layout: crate::iced_core::Layout<'_>,
cursor: crate::iced_core::mouse::Cursor,
viewport: &Rectangle,
renderer: &crate::Renderer,
) -> crate::iced_core::mouse::Interaction {
self.0
.lock()
.unwrap()
.as_widget()
.mouse_interaction(_state, _layout, _cursor, _viewport, _renderer)
self.with_element(|e| {
e.as_widget()
.mouse_interaction(state, layout, cursor, viewport, renderer)
})
}
fn overlay<'a>(
&'a mut self,
_state: &'a mut tree::Tree,
_layout: crate::iced_core::Layout<'_>,
_renderer: &crate::Renderer,
_translation: crate::iced_core::Vector,
state: &'a mut tree::Tree,
layout: crate::iced_core::Layout<'_>,
renderer: &crate::Renderer,
translation: crate::iced_core::Vector,
) -> Option<crate::iced_core::overlay::Element<'a, M, crate::Theme, crate::Renderer>> {
// TODO
None
assert_eq!(self.thread_id, thread::current().id());
Rc::get_mut(&mut self.element).and_then(|e| {
e.get_mut()
.as_widget_mut()
.overlay(state, layout, renderer, translation)
})
}
fn id(&self) -> Option<Id> {
self.0.lock().unwrap().as_widget().id()
self.with_element_mut(|e| e.as_widget_mut().id())
}
fn set_id(&mut self, _id: Id) {
self.0.lock().unwrap().as_widget_mut().set_id(_id)
fn set_id(&mut self, id: Id) {
self.with_element_mut(|e| e.as_widget_mut().set_id(id))
}
fn drag_destinations(
&self,
_state: &tree::Tree,
_layout: crate::iced_core::Layout<'_>,
state: &tree::Tree,
layout: crate::iced_core::Layout<'_>,
renderer: &crate::Renderer,
_dnd_rectangles: &mut crate::iced_core::clipboard::DndDestinationRectangles,
dnd_rectangles: &mut crate::iced_core::clipboard::DndDestinationRectangles,
) {
self.0.lock().unwrap().as_widget().drag_destinations(
_state,
_layout,
renderer,
_dnd_rectangles,
)
self.with_element_mut(|e| {
e.as_widget_mut()
.drag_destinations(state, layout, renderer, dnd_rectangles)
})
}
}
impl<Message: 'static> From<ArcElementWrapper<Message>> for Element<'static, Message> {
fn from(wrapper: ArcElementWrapper<Message>) -> Self {
impl<Message: 'static> From<RcElementWrapper<Message>> for Element<'static, Message> {
fn from(wrapper: RcElementWrapper<Message>) -> Self {
Element::new(wrapper)
}
}
impl<Message: 'static> From<Element<'static, Message>> for ArcElementWrapper<Message> {
impl<Message: 'static> From<Element<'static, Message>> for RcElementWrapper<Message> {
fn from(e: Element<'static, Message>) -> Self {
ArcElementWrapper(Arc::new(Mutex::new(e)))
RcElementWrapper::new(e)
}
}