wip: menus

src/widget/wrapper.rs

@@ -0,0 +1,155 @@
+use std::sync::{Arc, Mutex};
+
+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>>>);
+
+impl<M> Widget<M, crate::Theme, crate::Renderer> for ArcElementWrapper<M> {
+    fn size(&self) -> Size<Length> {
+        self.0.lock().unwrap().as_widget().size()
+    }
+
+    fn size_hint(&self) -> Size<Length> {
+        self.0.lock().unwrap().as_widget().size_hint()
+    }
+
+    fn layout(
+        &self,
+        tree: &mut tree::Tree,
+        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)
+    }
+
+    fn draw(
+        &self,
+        tree: &tree::Tree,
+        renderer: &mut crate::Renderer,
+        theme: &crate::Theme,
+        style: &crate::iced_core::renderer::Style,
+        layout: crate::iced_core::Layout<'_>,
+        cursor: crate::iced_core::mouse::Cursor,
+        viewport: &Rectangle,
+    ) {
+        self.0
+            .lock()
+            .unwrap()
+            .as_widget()
+            .draw(tree, renderer, theme, style, layout, cursor, viewport)
+    }
+
+    fn tag(&self) -> tree::Tag {
+        self.0.lock().unwrap().as_widget().tag()
+    }
+
+    fn state(&self) -> tree::State {
+        self.0.lock().unwrap().as_widget().state()
+    }
+
+    fn children(&self) -> Vec<tree::Tree> {
+        self.0.lock().unwrap().as_widget().children()
+    }
+
+    fn diff(&mut self, tree: &mut tree::Tree) {
+        self.0.lock().unwrap().as_widget_mut().diff(tree)
+    }
+
+    fn operate(
+        &self,
+        state: &mut tree::Tree,
+        layout: crate::iced_core::Layout<'_>,
+        renderer: &crate::Renderer,
+        operation: &mut dyn widget::Operation,
+    ) {
+        self.0
+            .lock()
+            .unwrap()
+            .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,
+    ) -> event::Status {
+        self.0.lock().unwrap().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,
+    ) -> crate::iced_core::mouse::Interaction {
+        self.0
+            .lock()
+            .unwrap()
+            .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,
+    ) -> Option<crate::iced_core::overlay::Element<'a, M, crate::Theme, crate::Renderer>> {
+        // TODO
+        None
+    }
+
+    fn id(&self) -> Option<Id> {
+        self.0.lock().unwrap().as_widget().id()
+    }
+
+    fn set_id(&mut self, _id: Id) {
+        self.0.lock().unwrap().as_widget_mut().set_id(_id)
+    }
+
+    fn drag_destinations(
+        &self,
+        _state: &tree::Tree,
+        _layout: crate::iced_core::Layout<'_>,
+        renderer: &crate::Renderer,
+        _dnd_rectangles: &mut crate::iced_core::clipboard::DndDestinationRectangles,
+    ) {
+        self.0.lock().unwrap().as_widget().drag_destinations(
+            _state,
+            _layout,
+            renderer,
+            _dnd_rectangles,
+        )
+    }
+}
+
+impl<Message: 'static> From<ArcElementWrapper<Message>> for Element<'static, Message> {
+    fn from(wrapper: ArcElementWrapper<Message>) -> Self {
+        Element::new(wrapper)
+    }
+}
+
+impl<Message: 'static> From<Element<'static, Message>> for ArcElementWrapper<Message> {
+    fn from(e: Element<'static, Message>) -> Self {
+        ArcElementWrapper(Arc::new(Mutex::new(e)))
+    }
+}