Add ContextMenuSystem for context menu

Listens for secondary click, support for sub-menus
/ · Oct 26, 2021 · Jul 6, 2021 · Jul 3, 2021 · Jul 3, 2021 · Jul 6, 2021
commit 04e52be74e15aaac3b854ac10c8969dd7a9d9dc3
diff --git a/egui/src/context_menu.rs b/egui/src/context_menu.rs
@@ -0,0 +1,220 @@
+use super::{
+    Color32, Id, Rect, Ui,
+    Frame, Area,
+    Response, CtxRef,
+    Pos2, Order,
+    Align, Layout,
+    PointerButton,
+};
+
+#[derive(Default, Clone)]
+#[cfg_attr(feature = "persistence", derive(serde::Deserialize, serde::Serialize))]
+#[cfg_attr(feature = "persistence", serde(default))]
+pub struct ContextMenuSystem {
+    context_menu: Option<ContextMenu>,
+}
+impl ContextMenuSystem {
+    pub fn listen(&mut self, ctx: &CtxRef, add_contents: impl FnOnce(&mut Ui, &mut MenuState)) {
+        let pointer = &ctx.input().pointer;
+        if let Some(pos) = pointer.interact_pos() {
+            let mut destroy = false;
+            let mut reset = true;
+            if let Some(context_menu) = &mut self.context_menu {
+                let response = context_menu.show_root(ctx, add_contents);
+                context_menu.state.rect = response.rect;
+
+                if context_menu.state.response.is_close() {
+                    destroy = true;
+                }
+                if !pointer.any_pressed() || context_menu.area_contains(pos) {
+                    reset = false;
+                }
+            }
+            if reset && pointer.button_down(PointerButton::Secondary) {
+                // todo: adapt to context
+                self.context_menu = Some(ContextMenu::new(pos));
+            } else if destroy || (reset && pointer.button_down(PointerButton::Primary))  {
+                self.context_menu = None;
+            }
+        }
+    }
+}
+#[derive(Clone)]
+#[cfg_attr(feature = "persistence", derive(serde::Deserialize, serde::Serialize))]
+enum MenuResponse {
+    Close,
+    Stay,
+}
+impl MenuResponse {
+    pub fn is_close(&self) -> bool {
+        match self {
+            &Self::Close => true,
+            _ => false,
+        }
+    }
+}
+#[derive(Default, Clone)]
+#[cfg_attr(feature = "persistence", derive(serde::Deserialize, serde::Serialize))]
+#[cfg_attr(feature = "persistence", serde(default))]
+struct ContextMenu {
+    state: MenuState,
+    position: Pos2,
+}
+impl ContextMenu {
+    pub fn new(position: Pos2) -> Self {
+        Self {
+            state: MenuState::default(),
+            position,
+        }
+    }
+    pub fn sub_menu(position: Pos2, state: MenuState) -> Self {
+        Self {
+            state,
+            position,
+        }
+    }
+    fn show_impl(&mut self, ctx: &CtxRef, add_contents: impl FnOnce(&mut Ui)) -> Response {
+        Area::new(format!("context_menu_{:#?}", self.position))
+            .order(Order::Foreground)
+            .fixed_pos(self.position.to_vec2())
+            .interactable(true)
+            .show(ctx, |ui| {
+                Frame::none()
+                    .fill(Color32::BLACK)
+                    .corner_radius(3.0)
+                    .margin((0.0, 3.0))
+                    .show(ui, |ui|
+                        ui.with_layout(
+                            Layout::top_down_justified(Align::LEFT),
+                            add_contents,
+                        )
+                    );
+            })
+    }
+    pub(crate) fn show_root(&mut self, ctx: &CtxRef, add_contents: impl FnOnce(&mut Ui, &mut MenuState)) -> Response {
+        let mut state = self.state.clone();
+        let response = self.show_impl(ctx, |ui| add_contents(ui, &mut state));
+        self.state = state;
+        response
+    }
+    pub fn show(&mut self, ctx: &CtxRef, add_contents: impl FnOnce(&mut Ui)) -> Response {
+        self.show_impl(ctx, add_contents)
+    }
+}
+impl std::ops::Deref for ContextMenu {
+    type Target = MenuState;
+    fn deref(&self) -> &Self::Target {
+        &self.state
+    }
+}
+impl std::ops::DerefMut for ContextMenu {
+    fn deref_mut(&mut self) -> &mut <Self as std::ops::Deref>::Target {
+        &mut self.state
+    }
+}
+#[derive(Clone)]
+pub struct SubMenu {
+    text: String,
+}
+impl SubMenu {
+    pub fn new(text: impl ToString) -> Self {
+        Self {
+            text: text.to_string(),
+        }
+    }
+    pub fn show(self, ui: &mut Ui, parent_state: &mut MenuState, add_contents: impl FnOnce(&mut Ui, &mut MenuState)) -> Response {
+        let button = ui.button(self.text);
+        let mut sub_hovered = false;
+        if let Some(sub_menu) = parent_state.get_submenu(button.id) {
+            if let Some(pos) = ui.input().pointer.hover_pos() {
+                sub_hovered = sub_menu.area_contains(pos);
+            }
+        }
+        if !sub_hovered {
+            if button.hovered() {
+                parent_state.open_submenu(button.id);
+            } else {
+                parent_state.close_submenu(button.id);
+            }
+        }
+        let responses = parent_state.get_submenu(button.id).map(|menu_state| {
+            let response = ContextMenu::sub_menu(button.rect.right_top(), menu_state.clone())
+                .show(ui.ctx(), |ui| add_contents(ui, menu_state));
+            // set submenu bounding box
+            menu_state.rect = response.rect;
+            (menu_state.response.clone(), response)
+        });
+        if let Some((menu_response, response)) = responses {
+            parent_state.cascade_response(menu_response);
+            response
+        } else {
+            button
+        }
+    }
+}
+
+#[derive(Clone)]
+#[cfg_attr(feature = "persistence", derive(serde::Deserialize, serde::Serialize))]
+#[cfg_attr(feature = "persistence", serde(default))]
+pub struct MenuState {
+    sub_menu: Option<(Id, Box<MenuState>)>,
+    pub rect: Rect,
+    response: MenuResponse,
+}
+impl Default for MenuState {
+    fn default() -> Self {
+        Self {
+            rect: Rect::NOTHING,
+            sub_menu: None,
+            response: MenuResponse::Stay
+        }
+    }
+}
+#[allow(unused)]
+impl MenuState {
+    pub(crate) fn area_contains(&self, pos: Pos2) -> bool{
+        self.rect.contains(pos) ||
+            self.sub_menu.as_ref()
+                .map(|(_, sub)| sub.area_contains(pos))
+                .unwrap_or(false)
+    }
+    pub fn close(&mut self) {
+        self.response = MenuResponse::Close;
+    }
+    fn cascade_response(&mut self, response: MenuResponse) {
+        if response.is_close() {
+            self.response = response;
+        }
+    }
+    pub fn get_submenu(&mut self, id: Id) -> Option<&mut MenuState> {
+        self.sub_menu.as_mut().and_then(|(k, sub)| if id == *k {
+            Some(sub.as_mut())
+        } else {
+            None
+        })
+    }
+    fn open_submenu(&mut self, id: Id) {
+        if let Some((k, _)) = self.sub_menu {
+            if k == id {
+                return;
+            }
+        }
+        self.sub_menu = Some((id, Box::new(MenuState::default())));
+    }
+    fn close_submenu(&mut self, id: Id) {
+        if let Some((k, _)) = self.sub_menu {
+            if k == id {
+                self.sub_menu = None;
+            }
+        }
+    }
+    pub fn toggle_submenu(&mut self, id: Id) {
+        if let Some((k, _)) = self.sub_menu.take() {
+            if k == id {
+                self.sub_menu = None;
+                return;
+            }
+        }
+        self.sub_menu = Some((id, Box::new(MenuState::default())));
+    }
+}
diff --git a/egui/src/lib.rs b/egui/src/lib.rs
@@ -369,6 +369,7 @@ pub mod style;
 mod ui;
 pub mod util;
 pub mod widgets;
+pub mod context_menu;
 
 pub use epaint;
 pub use epaint::emath;

diff --git a/egui_demo_lib/src/wrap_app.rs b/egui_demo_lib/src/wrap_app.rs
@@ -73,6 +73,8 @@ impl epi::App for WrapApp {
     }
 
     fn update(&mut self, ctx: &egui::CtxRef, frame: &mut epi::Frame<'_>) {
+        self.context_menu(ctx, frame);
+
         if let Some(web_info) = frame.info().web_info.as_ref() {
             if let Some(anchor) = web_info.web_location_hash.strip_prefix('#') {
                 self.selected_anchor = anchor.to_owned();
@@ -126,6 +128,39 @@ impl epi::App for WrapApp {
 }
 
 impl WrapApp {
+    fn context_menu(&mut self, ctx: &egui::CtxRef, _frame: &mut epi::Frame<'_>) {
+        use egui::context_menu::SubMenu;
+        self.context_menu.listen(ctx, |ui, menu_state| {
+            let open_button = ui.button("Open...");
+            if open_button.clicked() {
+                menu_state.close();
+            }
+            SubMenu::new("SubMenu")
+                .show(ui, menu_state, |ui, menu_state| {
+                    let open_button = ui.button("Open...");
+                    if open_button.clicked() {
+                        menu_state.close();
+                    }
+                    SubMenu::new("SubMenu")
+                        .show(ui, menu_state, |ui, menu_state| {
+                            let open_button = ui.button("Open...");
+                            if open_button.clicked() {
+                                menu_state.close();
+                            }
+                            let _ = ui.button("Item");
+                        });
+                    let _ = ui.button("Item");
+                });
+            SubMenu::new("SubMenu")
+                .show(ui, menu_state, |ui, _menu_state| {
+                    let _ = ui.button("Item1");
+                    let _ = ui.button("Item2");
+                    let _ = ui.button("Item3");
+                    let _ = ui.button("Item4");
+                });
+            let _ = ui.button("Item");
+        });
+    }
     fn bar_contents(&mut self, ui: &mut egui::Ui, frame: &mut epi::Frame<'_>) {
         // A menu-bar is a horizontal layout with some special styles applied.
         // egui::menu::bar(ui, |ui| {