@bobfrankston/msger 0.1.74 → 0.1.75

package/msger-native/src/main.rs

@@ -1,11 +1,100 @@
 use serde::{Deserialize, Serialize};
 use std::io::{self, Read};
 use tao::{
-    event::{Event, WindowEvent},
+    event::{Event, WindowEvent, ElementState, KeyEvent},
     event_loop::{ControlFlow, EventLoop},
+    keyboard::KeyCode,
     window::WindowBuilder,
 };
-use wry::WebViewBuilder;
+use wry::{WebViewBuilder, WebContext};
+
+// JavaScript API to inject into webviews
+const MSGER_JS_API: &str = r#"
+(function() {
+    console.log('[MSGER] Initializing msger API...');
+
+    // Check if IPC is available
+    const hasIPC = typeof window.ipc !== 'undefined' && window.ipc.postMessage;
+    console.log('[MSGER] IPC available:', hasIPC);
+
+    // Helper to safely send IPC messages
+    function safePostMessage(data) {
+        try {
+            if (!hasIPC) {
+                console.error('msger API: window.ipc not available');
+                return false;
+            }
+            window.ipc.postMessage(JSON.stringify(data));
+            return true;
+        } catch(e) {
+            console.error('msger API error:', e);
+            return false;
+        }
+    }
+
+    window.msger = {
+        // Window control - only close() with window.close() workaround (IPC broken)
+        close: function(result) {
+            // IPC is broken in wry 0.47.2, so we use window.close() instead
+            // Result cannot be returned to parent process
+            try {
+                window.close();
+                return true;
+            } catch(e) {
+                console.error('window.close() failed:', e);
+                return false;
+            }
+        },
+        saveData: function(key, value) {
+            try {
+                localStorage.setItem('msger_' + key, JSON.stringify(value));
+                return true;
+            } catch(e) {
+                console.error('Failed to save data:', e);
+                return false;
+            }
+        },
+        loadData: function(key, defaultValue) {
+            try {
+                const item = localStorage.getItem('msger_' + key);
+                return item ? JSON.parse(item) : defaultValue;
+            } catch(e) {
+                console.error('Failed to load data:', e);
+                return defaultValue;
+            }
+        },
+        removeData: function(key) {
+            try {
+                localStorage.removeItem('msger_' + key);
+                return true;
+            } catch(e) {
+                console.error('Failed to remove data:', e);
+                return false;
+            }
+        },
+        clearData: function() {
+            try {
+                const keys = Object.keys(localStorage);
+                for (const key of keys) {
+                    if (key.startsWith('msger_')) {
+                        localStorage.removeItem(key);
+                    }
+                }
+                return true;
+            } catch(e) {
+                console.error('Failed to clear data:', e);
+                return false;
+            }
+        },
+        // Check if running in msger environment
+        isAvailable: function() {
+            return true;
+        }
+    };
+
+    console.log('[MSGER] API initialized successfully! window.msger =', window.msger);
+})();
+"#;
 
 #[derive(Deserialize, Debug)]
 #[serde(rename_all = "camelCase")]
@@ -54,6 +143,10 @@ struct MessageBoxOptions {
     zoom_percent: Option<f64>,
     #[serde(default)]
     debug: bool,
+    #[serde(default)]
+    icon: Option<String>,
+    #[serde(default)]
+    dev: bool,
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
@@ -98,6 +191,29 @@ fn default_buttons() -> Vec<String> {
     vec!["OK".to_string()]
 }
 
+fn load_icon(icon_path: &str) -> Option<tao::window::Icon> {
+    use image::GenericImageView;
+
+    match image::open(icon_path) {
+        Ok(img) => {
+            let (width, height) = img.dimensions();
+            let rgba = img.to_rgba8().into_raw();
+
+            match tao::window::Icon::from_rgba(rgba, width, height) {
+                Ok(icon) => Some(icon),
+                Err(e) => {
+                    eprintln!("Failed to create icon from {}: {}", icon_path, e);
+                    None
+                }
+            }
+        }
+        Err(e) => {
+            eprintln!("Failed to load icon {}: {}", icon_path, e);
+            None
+        }
+    }
+}
+
 fn generate_html(options: &MessageBoxOptions) -> String {
     let html_content = if let Some(ref html) = options.html {
         html.clone()
@@ -148,10 +264,11 @@ fn generate_html(options: &MessageBoxOptions) -> String {
         .replace("{INPUT}", &input_html)
         .replace("{BUTTONS}", &buttons_html)
         .replace("{AUTO_SIZE}", if options.auto_size { "true" } else { "false" })
+        .replace("{FULLSCREEN}", if options.fullscreen { "true" } else { "false" })
         .replace("{ZOOM_PERCENT}", &options.zoom_percent.unwrap_or(100.0).to_string())
         .replace("{DEFAULT_BUTTON}", options.buttons.first().unwrap_or(&"Cancel".to_string()))
         .replace("{TIMEOUT_SECONDS}", &options.timeout.map(|t| t.to_string()).unwrap_or_else(|| "0".to_string()));
-    
+
     html
 }
 
@@ -178,32 +295,41 @@ fn main() {
     
     // Calculate position with optional screen offset (Windows only)
     let final_position = if let Some(ref pos) = options.pos {
-        #[cfg(target_os = "windows")]
         let mut x = pos.x;
-        #[cfg(not(target_os = "windows"))]
-        let x = pos.x;
-        let y = pos.y;
-        
-        // On Windows, calculate screen offset if screen number provided
+        let mut y = pos.y;
+
+        // On Windows, get the actual monitor position if screen number provided
         #[cfg(target_os = "windows")]
         if let Some(screen_num) = pos.screen {
-            if screen_num > 0 {
-                // Get all monitors and calculate X offset
-                let monitors: Vec<_> = event_loop.available_monitors().collect();
-                for (idx, monitor) in monitors.iter().enumerate() {
-                    if idx < screen_num as usize {
-                        let size = monitor.size();
-                        x += size.width as i32;
-                    }
-                }
+            // Get all monitors
+            let monitors: Vec<_> = event_loop.available_monitors().collect();
+
+            // Get the specific monitor by index
+            if let Some(monitor) = monitors.get(screen_num as usize) {
+                // Get the monitor's actual position from the OS
+                let monitor_pos = monitor.position();
+
+                // Add user's offset to monitor's position
+                x += monitor_pos.x;
+                y += monitor_pos.y;
+            } else {
+                eprintln!("Warning: Screen {} not found, using primary monitor", screen_num);
             }
         }
-        
+
         Some(tao::dpi::LogicalPosition::new(x as f64, y as f64))
     } else {
         None
     };
-    
+
+    // Load window icon (default or custom)
+    let icon = if let Some(ref icon_path) = options.icon {
+        load_icon(icon_path)
+    } else {
+        // Try default icon.png in current directory
+        load_icon("icon.png")
+    };
+
     let mut window_builder = WindowBuilder::new()
         .with_title(&options.title)
         .with_inner_size(tao::dpi::LogicalSize::new(
@@ -213,6 +339,11 @@ fn main() {
         .with_resizable(true)
         .with_always_on_top(options.always_on_top);
 
+    // Set icon if loaded successfully
+    if let Some(icon) = icon {
+        window_builder = window_builder.with_window_icon(Some(icon));
+    }
+
     // Set fullscreen mode if requested
     if options.fullscreen {
         window_builder = window_builder.with_fullscreen(Some(tao::window::Fullscreen::Borderless(None)));
@@ -222,9 +353,9 @@ fn main() {
         window_builder = window_builder.with_position(position);
     }
 
-    let window = window_builder
+    let window = std::sync::Arc::new(window_builder
         .build(&event_loop)
-        .expect("Failed to create window");
+        .expect("Failed to create window"));
 
     // Generate HTML
     let html = generate_html(&options);
@@ -248,6 +379,14 @@ fn main() {
     let debug_info_clone = debug_info.clone();
     let debug_info_clone2 = debug_info.clone();
 
+    // Create action holder for window operations from JavaScript
+    let pending_action = std::sync::Arc::new(std::sync::Mutex::new(None::<serde_json::Value>));
+    let pending_action_clone = pending_action.clone();
+    let pending_action_clone2 = pending_action.clone();
+
+    // Clone window for event loop
+    let window_clone = window.clone();
+
     // Set up timeout if specified
     let timeout_instant = options.timeout.map(|secs| {
         std::time::Instant::now() + std::time::Duration::from_secs(secs)
@@ -256,22 +395,42 @@ fn main() {
     let timeout_debug = debug_info.clone();
     let timeout_buttons = options.buttons.clone();
 
+    // Create WebContext with custom user data directory for msger (separate from other WebView2 apps)
+    let data_directory = if let Some(local_app_data) = std::env::var_os("LOCALAPPDATA") {
+        let mut path = std::path::PathBuf::from(local_app_data);
+        path.push("msger");
+        path.push("webview2");
+        Some(path)
+    } else {
+        None
+    };
+    let mut web_context = WebContext::new(data_directory);
+
     // Create webview with IPC handler
-    let _webview = if let Some(ref url) = options.url {
-        // Load URL
-        WebViewBuilder::new()
+    let mut webview = if let Some(ref url) = options.url {
+        // Load URL with msger API injected
+        WebViewBuilder::with_web_context(&mut web_context)
             .with_url(url)
+            .with_initialization_script(MSGER_JS_API)
             .with_devtools(true)
             .with_ipc_handler(move |msg| {
-                // Check for resize message first
-                if let Ok(resize_msg) = serde_json::from_str::<serde_json::Value>(msg.body()) {
-                    if resize_msg.get("_resize").and_then(|v| v.as_bool()).unwrap_or(false) {
+                // Parse message as JSON
+                if let Ok(json_msg) = serde_json::from_str::<serde_json::Value>(msg.body()) {
+                    // Check for action messages
+                    if json_msg.get("_action").is_some() {
+                        let mut action_lock = pending_action_clone.lock().unwrap();
+                        *action_lock = Some(json_msg);
+                        return;
+                    }
+
+                    // Check for resize message
+                    if json_msg.get("_resize").and_then(|v| v.as_bool()).unwrap_or(false) {
                         // This is a resize message - we'll handle it in the event loop
                         // For now, just ignore it (window resize from IPC is complex in wry/tao)
                         return;
                     }
                 }
-                
+
                 // Parse the result from JavaScript (msg is now a Request<String>)
                 if let Ok(mut res) = serde_json::from_str::<MessageBoxResult>(msg.body()) {
                     // Add debug info if requested
@@ -280,23 +439,31 @@ fn main() {
                     *result_lock = Some(res);
                 }
             })
-            .build(&window)
+            .build(window.as_ref())
             .expect("Failed to create webview")
     } else {
-        // Use HTML content
-        WebViewBuilder::new()
+        // Use HTML content (msger API already in template.html)
+        WebViewBuilder::with_web_context(&mut web_context)
             .with_html(&html)
             .with_devtools(true)
             .with_ipc_handler(move |msg| {
-                // Check for resize message first
-                if let Ok(resize_msg) = serde_json::from_str::<serde_json::Value>(msg.body()) {
-                    if resize_msg.get("_resize").and_then(|v| v.as_bool()).unwrap_or(false) {
+                // Parse message as JSON
+                if let Ok(json_msg) = serde_json::from_str::<serde_json::Value>(msg.body()) {
+                    // Check for action messages
+                    if json_msg.get("_action").is_some() {
+                        let mut action_lock = pending_action_clone2.lock().unwrap();
+                        *action_lock = Some(json_msg);
+                        return;
+                    }
+
+                    // Check for resize message
+                    if json_msg.get("_resize").and_then(|v| v.as_bool()).unwrap_or(false) {
                         // This is a resize message - we'll handle it in the event loop
                         // For now, just ignore it (window resize from IPC is complex in wry/tao)
                         return;
                     }
                 }
-                
+
                 // Parse the result from JavaScript (msg is now a Request<String>)
                 if let Ok(mut res) = serde_json::from_str::<MessageBoxResult>(msg.body()) {
                     // Add debug info if requested
@@ -305,10 +472,18 @@ fn main() {
                     *result_lock = Some(res);
                 }
             })
-            .build(&window)
+            .build(window.as_ref())
             .expect("Failed to create webview")
     };
 
+    // Open DevTools if -dev flag was specified
+    if options.dev {
+        // TODO: open_devtools() method not available in wry 0.47.2
+        // webview.open_devtools();
+        eprintln!("Warning: -dev flag specified but open_devtools() not available in wry 0.47.2");
+        eprintln!("DevTools are enabled - press F12 to open manually");
+    }
+
     // Run event loop
     event_loop.run(move |event, _,control_flow| {
         // Check timeout
@@ -335,6 +510,56 @@ fn main() {
         }
 
         match event {
+            Event::WindowEvent {
+                event: WindowEvent::KeyboardInput {
+                    event: KeyEvent {
+                        physical_key: key_code,
+                        state: ElementState::Pressed,
+                        ..
+                    },
+                    ..
+                },
+                ..
+            } => {
+                match key_code {
+                    // F11 toggles fullscreen
+                    KeyCode::F11 => {
+                        let is_fullscreen = window_clone.fullscreen().is_some();
+                        if is_fullscreen {
+                            window_clone.set_fullscreen(None);
+                        } else {
+                            // Get current monitor for fullscreen
+                            let monitor = window_clone.current_monitor()
+                                .or_else(|| window_clone.primary_monitor());
+                            window_clone.set_fullscreen(Some(tao::window::Fullscreen::Borderless(monitor)));
+                        }
+                    }
+                    // Escape exits fullscreen or dismisses window
+                    KeyCode::Escape => {
+                        let is_fullscreen = window_clone.fullscreen().is_some();
+                        if is_fullscreen {
+                            // Exit fullscreen
+                            window_clone.set_fullscreen(None);
+                        } else {
+                            // Dismiss window
+                            let mut result_lock = result.lock().unwrap();
+                            if result_lock.is_none() {
+                                *result_lock = Some(MessageBoxResult {
+                                    button: "Cancel".to_string(),
+                                    value: None,
+                                    form: None,
+                                    closed: None,
+                                    dismissed: Some(true),
+                                    timeout: None,
+                                    debug: debug_info.clone(),
+                                });
+                            }
+                            *control_flow = ControlFlow::Exit;
+                        }
+                    }
+                    _ => {}
+                }
+            }
             Event::WindowEvent {
                 event: WindowEvent::CloseRequested,
                 ..
@@ -355,6 +580,87 @@ fn main() {
                 *control_flow = ControlFlow::Exit;
             }
             Event::MainEventsCleared => {
+                // Process pending actions from JavaScript
+                let mut action_lock = pending_action.lock().unwrap();
+                if let Some(action_msg) = action_lock.take() {
+                    if let Some(action) = action_msg.get("_action").and_then(|v| v.as_str()) {
+                        eprintln!("DEBUG: Received IPC action: {}", action);
+                        // Wrap all window operations in catch_unwind to prevent crashes
+                        let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+                            match action {
+                                "toggleFullscreen" => {
+                                    let is_fullscreen = window_clone.fullscreen().is_some();
+                                    if is_fullscreen {
+                                        window_clone.set_fullscreen(None);
+                                    } else {
+                                        // Get current monitor for fullscreen
+                                        let monitor = window_clone.current_monitor()
+                                            .or_else(|| window_clone.primary_monitor());
+                                        window_clone.set_fullscreen(Some(tao::window::Fullscreen::Borderless(monitor)));
+                                    }
+                                }
+                                "setFullscreen" => {
+                                    if let Some(enabled) = action_msg.get("enabled").and_then(|v| v.as_bool()) {
+                                        if enabled {
+                                            // Get current monitor for fullscreen
+                                            let monitor = window_clone.current_monitor()
+                                                .or_else(|| window_clone.primary_monitor());
+                                            window_clone.set_fullscreen(Some(tao::window::Fullscreen::Borderless(monitor)));
+                                        } else {
+                                            window_clone.set_fullscreen(None);
+                                        }
+                                    }
+                                }
+                                "minimize" => {
+                                    window_clone.set_minimized(true);
+                                }
+                                "maximize" => {
+                                    window_clone.set_maximized(!window_clone.is_maximized());
+                                }
+                                "setSize" => {
+                                    if let (Some(width), Some(height)) = (
+                                        action_msg.get("width").and_then(|v| v.as_f64()),
+                                        action_msg.get("height").and_then(|v| v.as_f64())
+                                    ) {
+                                        window_clone.set_inner_size(tao::dpi::LogicalSize::new(width, height));
+                                    }
+                                }
+                                "setPosition" => {
+                                    if let (Some(x), Some(y)) = (
+                                        action_msg.get("x").and_then(|v| v.as_f64()),
+                                        action_msg.get("y").and_then(|v| v.as_f64())
+                                    ) {
+                                        window_clone.set_outer_position(tao::dpi::LogicalPosition::new(x, y));
+                                    }
+                                }
+                                "setAlwaysOnTop" => {
+                                    if let Some(enabled) = action_msg.get("enabled").and_then(|v| v.as_bool()) {
+                                        window_clone.set_always_on_top(enabled);
+                                    }
+                                }
+                                "setTitle" => {
+                                    if let Some(title) = action_msg.get("title").and_then(|v| v.as_str()) {
+                                        window_clone.set_title(title);
+                                    }
+                                }
+                                "test" => {
+                                    eprintln!("DEBUG: Test IPC message received successfully!");
+                                    // Don't do anything, just testing if IPC works
+                                }
+                                _ => {
+                                    eprintln!("DEBUG: Unknown action: {}", action);
+                                }
+                            }
+                        }));
+
+                        // Log if operation failed
+                        if let Err(e) = result {
+                            eprintln!("Window operation '{}' panicked: {:?}", action, e);
+                        }
+                    }
+                }
+                drop(action_lock);
+
                 // Check if result is set
                 let result_lock = result.lock().unwrap();
                 if result_lock.is_some() {