Reintroduce menu-related platform callbacks

Nathan Sobo committed 2 years ago

Commit dffe0ea1 parent 30725d63 files · +73 −59Browse files

Unified · Split

3 files

crates/gpui2/src/platform.rs +5 −1
crates/gpui2/src/platform/mac/platform.rs +56 −58
crates/gpui2/src/platform/test/platform.rs +12 −0

 mod test;
 use crate::{
-    point, size, AnyWindowHandle, BackgroundExecutor, Bounds, DevicePixels, Font, FontId,
+    point, size, Action, AnyWindowHandle, BackgroundExecutor, Bounds, DevicePixels, Font, FontId,
     FontMetrics, FontRun, ForegroundExecutor, GlobalPixels, GlyphId, InputEvent, LineLayout,
     Pixels, Point, RenderGlyphParams, RenderImageParams, RenderSvgParams, Result, Scene,
     SharedString, Size, TaskLabel,
     fn on_reopen(&self, callback: Box<dyn FnMut()>);
     fn on_event(&self, callback: Box<dyn FnMut(InputEvent) -> bool>);
+    fn on_menu_command(&self, callback: Box<dyn FnMut(&dyn Action)>);
+    fn on_will_open_menu(&self, callback: Box<dyn FnMut()>);
+    fn on_validate_menu_command(&self, callback: Box<dyn FnMut(&dyn Action) -> bool>);
     fn os_name(&self) -> &'static str;
     fn os_version(&self) -> Result<SemanticVersion>;
     fn app_version(&self) -> Result<SemanticVersion>;

crates/gpui2/src/platform/mac/platform.rs+56−58

 use super::BoolExt;
 use crate::{
-    AnyWindowHandle, BackgroundExecutor, ClipboardItem, CursorStyle, DisplayId, ForegroundExecutor,
+    Action, AnyWindowHandle, BackgroundExecutor, ClipboardItem, CursorStyle, DisplayId,
-    InputEvent, MacDispatcher, MacDisplay, MacDisplayLinker, MacTextSystem, MacWindow,
+    ForegroundExecutor, InputEvent, MacDispatcher, MacDisplay, MacDisplayLinker, MacTextSystem,
-    PathPromptOptions, Platform, PlatformDisplay, PlatformTextSystem, PlatformWindow, Result,
+    MacWindow, PathPromptOptions, Platform, PlatformDisplay, PlatformTextSystem, PlatformWindow,
-    SemanticVersion, VideoTimestamp, WindowOptions,
+    Result, SemanticVersion, VideoTimestamp, WindowOptions,
 };
 use anyhow::anyhow;
 use block::ConcreteBlock;
     reopen: Option<Box<dyn FnMut()>>,
     quit: Option<Box<dyn FnMut()>>,
     event: Option<Box<dyn FnMut(InputEvent) -> bool>>,
-    // menu_command: Option<Box<dyn FnMut(&dyn Action)>>,
+    menu_command: Option<Box<dyn FnMut(&dyn Action)>>,
-    // validate_menu_command: Option<Box<dyn FnMut(&dyn Action) -> bool>>,
+    validate_menu_command: Option<Box<dyn FnMut(&dyn Action) -> bool>>,
     will_open_menu: Option<Box<dyn FnMut()>>,
+    menu_actions: Vec<Box<dyn Action>>,
     open_urls: Option<Box<dyn FnMut(Vec<String>)>>,
     finish_launching: Option<Box<dyn FnOnce()>>,
-    // menu_actions: Vec<Box<dyn Action>>,
 }
 impl MacPlatform {
             reopen: None,
             quit: None,
             event: None,
+            menu_command: None,
+            validate_menu_command: None,
             will_open_menu: None,
+            menu_actions: Default::default(),
             open_urls: None,
             finish_launching: None,
-            // menu_command: None,
-            // validate_menu_command: None,
-            // menu_actions: Default::default(),
         }))
     }
         }
     }
-    // fn on_menu_command(&self, callback: Box<dyn FnMut(&dyn Action)>) {
+    fn on_menu_command(&self, callback: Box<dyn FnMut(&dyn Action)>) {
-    //     self.0.lock().menu_command = Some(callback);
+        self.0.lock().menu_command = Some(callback);
-    // }
+    }
-    // fn on_will_open_menu(&self, callback: Box<dyn FnMut()>) {
+    fn on_will_open_menu(&self, callback: Box<dyn FnMut()>) {
-    //     self.0.lock().will_open_menu = Some(callback);
+        self.0.lock().will_open_menu = Some(callback);
-    // }
+    }
-    // fn on_validate_menu_command(&self, callback: Box<dyn FnMut(&dyn Action) -> bool>) {
+    fn on_validate_menu_command(&self, callback: Box<dyn FnMut(&dyn Action) -> bool>) {
-    //     self.0.lock().validate_menu_command = Some(callback);
+        self.0.lock().validate_menu_command = Some(callback);
-    // }
+    }
     // fn set_menus(&self, menus: Vec<Menu>, keystroke_matcher: &KeymapMatcher) {
     //     unsafe {
     PathBuf::from(path)
 }
-unsafe fn get_foreground_platform(object: &mut Object) -> &MacPlatform {
+unsafe fn get_mac_platform(object: &mut Object) -> &MacPlatform {
     let platform_ptr: *mut c_void = *object.get_ivar(MAC_PLATFORM_IVAR);
     assert!(!platform_ptr.is_null());
     &*(platform_ptr as *const MacPlatform)
 extern "C" fn send_event(this: &mut Object, _sel: Sel, native_event: id) {
     unsafe {
         if let Some(event) = InputEvent::from_native(native_event, None) {
-            let platform = get_foreground_platform(this);
+            let platform = get_mac_platform(this);
             if let Some(callback) = platform.0.lock().event.as_mut() {
                 if !callback(event) {
                     return;
         let app: id = msg_send![APP_CLASS, sharedApplication];
         app.setActivationPolicy_(NSApplicationActivationPolicyRegular);
-        let platform = get_foreground_platform(this);
+        let platform = get_mac_platform(this);
         let callback = platform.0.lock().finish_launching.take();
         if let Some(callback) = callback {
             callback();
 extern "C" fn should_handle_reopen(this: &mut Object, _: Sel, _: id, has_open_windows: bool) {
     if !has_open_windows {
-        let platform = unsafe { get_foreground_platform(this) };
+        let platform = unsafe { get_mac_platform(this) };
         if let Some(callback) = platform.0.lock().reopen.as_mut() {
             callback();
         }
 }
 extern "C" fn did_become_active(this: &mut Object, _: Sel, _: id) {
-    let platform = unsafe { get_foreground_platform(this) };
+    let platform = unsafe { get_mac_platform(this) };
     if let Some(callback) = platform.0.lock().become_active.as_mut() {
         callback();
     }
 }
 extern "C" fn did_resign_active(this: &mut Object, _: Sel, _: id) {
-    let platform = unsafe { get_foreground_platform(this) };
+    let platform = unsafe { get_mac_platform(this) };
     if let Some(callback) = platform.0.lock().resign_active.as_mut() {
         callback();
     }
 }
 extern "C" fn will_terminate(this: &mut Object, _: Sel, _: id) {
-    let platform = unsafe { get_foreground_platform(this) };
+    let platform = unsafe { get_mac_platform(this) };
     if let Some(callback) = platform.0.lock().quit.as_mut() {
         callback();
     }
             })
             .collect::<Vec<_>>()
     };
-    let platform = unsafe { get_foreground_platform(this) };
+    let platform = unsafe { get_mac_platform(this) };
     if let Some(callback) = platform.0.lock().open_urls.as_mut() {
         callback(urls);
     }
 }
-extern "C" fn handle_menu_item(__this: &mut Object, _: Sel, __item: id) {
+extern "C" fn handle_menu_item(this: &mut Object, _: Sel, item: id) {
-    todo!()
+    unsafe {
-    // unsafe {
+        let platform = get_mac_platform(this);
-    //     let platform = get_foreground_platform(this);
+        let mut platform = platform.0.lock();
-    //     let mut platform = platform.0.lock();
+        if let Some(mut callback) = platform.menu_command.take() {
-    //     if let Some(mut callback) = platform.menu_command.take() {
+            let tag: NSInteger = msg_send![item, tag];
-    //         let tag: NSInteger = msg_send![item, tag];
+            let index = tag as usize;
-    //         let index = tag as usize;
+            if let Some(action) = platform.menu_actions.get(index) {
-    //         if let Some(action) = platform.menu_actions.get(index) {
+                callback(action.as_ref());
-    //             callback(action.as_ref());
+            }
-    //         }
+            platform.menu_command = Some(callback);
-    //         platform.menu_command = Some(callback);
+        }
-    //     }
+    }
-    // }
 }
-extern "C" fn validate_menu_item(__this: &mut Object, _: Sel, __item: id) -> bool {
+extern "C" fn validate_menu_item(this: &mut Object, _: Sel, item: id) -> bool {
-    todo!()
+    unsafe {
-    // unsafe {
+        let mut result = false;
-    //     let mut result = false;
+        let platform = get_mac_platform(this);
-    //     let platform = get_foreground_platform(this);
+        let mut platform = platform.0.lock();
-    //     let mut platform = platform.0.lock();
+        if let Some(mut callback) = platform.validate_menu_command.take() {
-    //     if let Some(mut callback) = platform.validate_menu_command.take() {
+            let tag: NSInteger = msg_send![item, tag];
-    //         let tag: NSInteger = msg_send![item, tag];
+            let index = tag as usize;
-    //         let index = tag as usize;
+            if let Some(action) = platform.menu_actions.get(index) {
-    //         if let Some(action) = platform.menu_actions.get(index) {
+                result = callback(action.as_ref());
-    //             result = callback(action.as_ref());
+            }
-    //         }
+            platform.validate_menu_command = Some(callback);
-    //         platform.validate_menu_command = Some(callback);
+        }
-    //     }
+        result
-    //     result
+    }
-    // }
 }
 extern "C" fn menu_will_open(this: &mut Object, _: Sel, _: id) {
     unsafe {
-        let platform = get_foreground_platform(this);
+        let platform = get_mac_platform(this);
         let mut platform = platform.0.lock();
         if let Some(mut callback) = platform.will_open_menu.take() {
             callback();

crates/gpui2/src/platform/test/platform.rs+12−0

@@ -205,6 +205,18 @@ impl Platform for TestPlatform { · 204 unmodified lines
205	unimplemented!()	205	unimplemented!()
206	}	206	}
207		207
		208	fn on_menu_command(&self, _callback: Box<dyn FnMut(&dyn crate::Action)>) {
		209	unimplemented!()
		210	}
		211
		212	fn on_will_open_menu(&self, _callback: Box<dyn FnMut()>) {
		213	unimplemented!()
		214	}
		215
		216	fn on_validate_menu_command(&self, _callback: Box<dyn FnMut(&dyn crate::Action) -> bool>) {
		217	unimplemented!()
		218	}
		219
208	fn os_name(&self) -> &'static str {	220	fn os_name(&self) -> &'static str {
209	"test"	221	"test"
210	}	222	}

Reintroduce menu-related platform callbacks

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code