feat: support base popup

iced_examples/counter_muti/src/main.rs

@@ -1,11 +1,12 @@
 use std::collections::HashMap;
 
-use iced::widget::{button, column, row, text, text_input};
+use iced::theme::Container;
+use iced::widget::{button, column, container, row, text, text_input};
 use iced::window::Id;
 use iced::{event, Alignment, Command, Element, Event, Length, Theme};
 use iced_layershell::actions::{
-    LayershellCustomActions, LayershellCustomActionsWithId, LayershellCustomActionsWithIdAndInfo,
-    LayershellCustomActionsWithInfo,
+    IcedNewMenuSettings, LayershellCustomActions, LayershellCustomActionsWithId,
+    LayershellCustomActionsWithIdAndInfo, LayershellCustomActionsWithInfo, MenuDirection,
 };
 use iced_runtime::command::Action;
 use iced_runtime::window::Action as WindowAction;
@@ -35,6 +36,7 @@ struct Counter {
 enum WindowInfo {
     Left,
     Right,
+    PopUp,
 }
 
 #[derive(Debug, Clone, Copy)]
@@ -57,6 +59,16 @@ enum Message {
     IcedEvent(Event),
 }
 
+#[derive(Default)]
+struct BlackMenu;
+
+impl container::StyleSheet for BlackMenu {
+    type Style = iced::Theme;
+    fn appearance(&self, _style: &Self::Style) -> container::Appearance {
+        container::Appearance::default().with_background(iced::Color::new(0., 0.5, 0.7, 0.6))
+    }
+}
+
 impl Counter {
     fn window_id(&self, info: &WindowInfo) -> Option<&iced::window::Id> {
         for (k, v) in self.ids.iter() {
@@ -79,7 +91,7 @@ impl MultiApplication for Counter {
         (
             Self {
                 value: 0,
-                text: "eee".to_string(),
+                text: "type something".to_string(),
                 ids: HashMap::new(),
             },
             Command::none(),
@@ -112,14 +124,31 @@ impl MultiApplication for Counter {
         use iced::Event;
         match message {
             Message::IcedEvent(event) => {
-                if let Event::Keyboard(keyboard::Event::KeyPressed {
-                    key: keyboard::Key::Named(Named::Escape),
-                    ..
-                }) = event
-                {
-                    if let Some(id) = self.window_id(&WindowInfo::Left) {
-                        return Command::single(Action::Window(WindowAction::Close(*id)));
+                match event {
+                    Event::Keyboard(keyboard::Event::KeyPressed {
+                        key: keyboard::Key::Named(Named::Escape),
+                        ..
+                    }) => {
+                        if let Some(id) = self.window_id(&WindowInfo::Left) {
+                            return Command::single(Action::Window(WindowAction::Close(*id)));
+                        }
                     }
+                    Event::Mouse(iced::mouse::Event::ButtonPressed(iced::mouse::Button::Right)) => {
+                        return Command::single(
+                            LayershellCustomActionsWithIdAndInfo::new(
+                                iced::window::Id::MAIN,
+                                LayershellCustomActionsWithInfo::NewMenu((
+                                    IcedNewMenuSettings {
+                                        size: (100, 100),
+                                        direction: MenuDirection::Up,
+                                    },
+                                    WindowInfo::PopUp,
+                                )),
+                            )
+                            .into(),
+                        );
+                    }
+                    _ => {}
                 }
                 Command::none()
             }
@@ -254,12 +283,21 @@ impl MultiApplication for Counter {
         if let Some(WindowInfo::Right) = self.id_info(id) {
             return button("close right").on_press(Message::Close(id)).into();
         }
+        if let Some(WindowInfo::PopUp) = self.id_info(id) {
+            return container(button("close PopUp").on_press(Message::Close(id)))
+                .center_x()
+                .center_y()
+                .style(Container::Custom(Box::new(BlackMenu)))
+                .width(Length::Fill)
+                .height(Length::Fill)
+                .into();
+        }
         let center = column![
             button("Increment").on_press(Message::IncrementPressed),
-            text(self.value).size(50),
             button("Decrement").on_press(Message::DecrementPressed),
+            text(self.value).size(50),
             button("newwindowLeft").on_press(Message::NewWindowLeft),
-            button("newwindowRight").on_press(Message::NewWindowRight)
+            button("newwindowRight").on_press(Message::NewWindowRight),
         ]
         .padding(20)
         .align_items(Alignment::Center)

iced_layershell/src/actions.rs

@@ -4,14 +4,34 @@ use iced_core::mouse::Interaction;
 use iced_runtime::command::Action;
 use layershellev::id::Id as LayerId;
 use layershellev::NewLayerShellSettings;
+
 #[allow(unused)]
 #[derive(Debug, Clone)]
 pub(crate) enum LayerShellActions<INFO: Clone> {
     Mouse(Interaction),
     CustomActions(Vec<LayershellCustomActionsWithInfo<INFO>>),
     CustomActionsWithId(Vec<LayershellCustomActionsWithIdInner<INFO>>),
     RedrawAll,
-    RedrawWindow(LayerId),
+    RedrawWindow(LayerId), // maybe one day it is useful, but now useless
+    NewMenu((IcedNewPopupSettings, INFO)),
+}
+
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+pub struct IcedNewPopupSettings {
+    pub size: (u32, u32),
+    pub position: (i32, i32),
+}
+
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+pub enum MenuDirection {
+    Up,
+    Down,
+}
+
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+pub struct IcedNewMenuSettings {
+    pub size: (u32, u32),
+    pub direction: MenuDirection,
 }
 
 #[derive(Debug, Clone, Copy)]
@@ -24,8 +44,10 @@ pub enum LayershellCustomActionsWithInfo<INFO: Clone> {
         key: u32,
     },
     NewLayerShell((NewLayerShellSettings, INFO)),
+    NewPopUp((IcedNewPopupSettings, INFO)),
+    NewMenu((IcedNewMenuSettings, INFO)),
     /// is same with WindowAction::Close(id)
-    RemoveLayerShell(IcedId),
+    RemoveWindow(IcedId),
 }
 
 pub type LayershellCustomActions = LayershellCustomActionsWithInfo<()>;

iced_layershell/src/conversion.rs

@@ -28,8 +28,8 @@ pub fn window_event(
         }
         LayerShellEvent::CursorEnter { .. } => Some(IcedEvent::Mouse(mouse::Event::CursorEntered)),
         LayerShellEvent::MouseInput(state) => Some(IcedEvent::Mouse(match state {
-            IcedButtonState::Pressed => mouse::Event::ButtonPressed(mouse::Button::Left),
-            IcedButtonState::Released => mouse::Event::ButtonReleased(mouse::Button::Left),
+            IcedButtonState::Pressed(btn) => mouse::Event::ButtonPressed(*btn),
+            IcedButtonState::Released(btn) => mouse::Event::ButtonReleased(*btn),
         })),
         LayerShellEvent::Axis { x, y } => Some(IcedEvent::Mouse(mouse::Event::WheelScrolled {
             delta: mouse::ScrollDelta::Lines { x: *x, y: *y },

iced_layershell/src/event.rs

@@ -1,14 +1,24 @@
+use iced::mouse;
 use layershellev::id::Id;
 use layershellev::keyboard::ModifiersState;
 use layershellev::reexport::wayland_client::{ButtonState, KeyState, WEnum};
 use layershellev::xkb_keyboard::KeyEvent as LayerShellKeyEvent;
 use layershellev::{DispatchMessage, WindowWrapper};
 
 use iced_core::keyboard::Modifiers as IcedModifiers;
+
+use crate::actions::IcedNewMenuSettings;
+
+fn from_u32_to_icedmouse(code: u32) -> mouse::Button {
+    match code {
+        273 => mouse::Button::Right,
+        _ => mouse::Button::Left,
+    }
+}
 #[derive(Debug, Clone, Copy)]
 pub enum IcedButtonState {
-    Pressed,
-    Released,
+    Pressed(mouse::Button),
+    Released(mouse::Button),
 }
 
 #[derive(Debug, Clone, Copy)]
@@ -77,6 +87,7 @@ pub enum IcedLayerEvent<Message: 'static, INFO: Clone> {
     NormalUpdate,
     UserEvent(Message),
     WindowRemoved(iced_core::window::Id),
+    NewMenu((IcedNewMenuSettings, INFO)),
 }
 
 #[allow(unused)]
@@ -117,15 +128,18 @@ impl<Message: 'static, INFO: Clone> From<&DispatchMessage> for IcedLayerEvent<Me
                 IcedLayerEvent::Window(WindowEvent::CursorMoved { x: *x, y: *y })
             }
             DispatchMessage::MouseLeave => IcedLayerEvent::Window(WindowEvent::CursorLeft),
-            DispatchMessage::MouseButton { state, .. } => match state {
-                WEnum::Value(ButtonState::Pressed) => {
-                    IcedLayerEvent::Window(WindowEvent::MouseInput(IcedButtonState::Pressed))
+            DispatchMessage::MouseButton { state, button, .. } => {
+                let btn = from_u32_to_icedmouse(*button);
+                match state {
+                    WEnum::Value(ButtonState::Pressed) => IcedLayerEvent::Window(
+                        WindowEvent::MouseInput(IcedButtonState::Pressed(btn)),
+                    ),
+                    WEnum::Value(ButtonState::Released) => IcedLayerEvent::Window(
+                        WindowEvent::MouseInput(IcedButtonState::Released(btn)),
+                    ),
+                    _ => unreachable!(),
                 }
-                WEnum::Value(ButtonState::Released) => {
-                    IcedLayerEvent::Window(WindowEvent::MouseInput(IcedButtonState::Released))
-                }
-                _ => unreachable!(),
-            },
+            }
             DispatchMessage::PrefredScale(scale) => {
                 IcedLayerEvent::Window(WindowEvent::ScaleChanged(*scale))
             }