try make work on gnome

Author: MoAlyousef

AGENTS.md

@@ -0,0 +1,35 @@
+# Repository Guidelines
+
+## Project Structure & Module Organization
+- Root crate: `Cargo.toml`, library entry at `src/lib.rs` (public `Webview` API).
+- FFI layer: `fltk-webview-sys/` with `build.rs` and platform helpers (`cocoa_helper.m`, `gtk_helper.c`).
+- Examples: `examples/*.rs` (e.g., `basic.rs`, `dispatch.rs`, `markdown.rs`).
+- CI: `.github/workflows/rust.yml` builds on Windows, macOS, and Linux.
+- Assets: `screenshots/` used in the README.
+
+## Build, Test, and Development Commands
+- Build: `cargo build` (add `--features fltk/fltk-bundled` to use bundled FLTK like CI).
+- Run example: `cargo run --example basic` (replace `basic` with any file in `examples/`).
+- Lint: `cargo clippy --all-targets -- -D warnings` (treat warnings as errors).
+- Format: `cargo fmt --all` (required before PRs).
+- Docs: `cargo doc --open` (browse crate docs, README is included).
+- Test: `cargo test` (add tests as described below; currently minimal).
+
+Linux note: install `libwebkit2gtk-4.1-dev` and common X11 deps (see workflow). Windows/macOS need no extra packages.
+
+## Coding Style & Naming Conventions
+- Rust style with `rustfmt` (4-space indent, max line width per default config).
+- Naming: `snake_case` for functions/modules, `CamelCase` for types/traits, `SCREAMING_SNAKE_CASE` for consts.
+- Keep platform-specific code behind `cfg` gates and isolate FFI in `fltk-webview-sys`.
+
+## Testing Guidelines
+- Prefer small unit tests co-located with modules (`#[cfg(test)] mod tests { ... }`) or `tests/` for integration.
+- Name tests after behavior, e.g., `creates_webview_from_fltk_window`.
+- Run with `cargo test`; avoid platform GUI assumptions—mock or guard with `#[cfg]`.
+
+## Commit & Pull Request Guidelines
+- Commits: imperative present, concise, scoped. Example: `fix: correct SetFocus usage on Windows` or `docs: expand usage section`.
+- PRs must include: summary, rationale, affected platforms, screenshots if UI-visible, and any linked issues.
+- CI must pass on all platforms; run `cargo fmt`, `cargo clippy`, and build examples locally where feasible.
+- For Linux changes, note any new `apt`/`dnf` packages or `pkg-config` requirements.
+

README.md

@@ -37,13 +37,15 @@ fn main() {
 ## Dependencies
 - fltk-rs's dependencies, which can be found [here](https://github.com/fltk-rs/fltk-rs#dependencies).
 - On Windows: No other dependencies.
-- On MacOS: No other dependencies.
-- On X11/wayland platforms, webkit2gtk:
-    - Debian-based distros: `sudo apt-get install libwebkit2gtk-4.1-dev`.
-    - RHEL-based distros: `sudo dnf install webkit2gtk3-devel`.
-
-## Known Issues
-The situation on linux is quite bad. It depends on whether you're running X11 or wayland. On wayland, this will use xwayland. On X11, I can't get embedding to work on Gnome's mutter window manager, which keeps fighting for ownership of the webview window, causing flickering or a blank screen!D=x11 environment variable for webkit2gtk to work properly.
+- On macOS: No other dependencies.
+- On Linux (X11 only): WebKitGTK and X11 dev packages.
+    - Debian-based distros: `sudo apt-get install libwebkit2gtk-4.1-dev libx11-dev`.
+    - RHEL-based distros: `sudo dnf install webkit2gtk3-devel libX11-devel`.
+
+## Linux Notes
+- This crate supports X11 only on Linux. On GNOME or Wayland sessions, force X11: `GDK_BACKEND=x11`.
+- GNOME/Mutter can interfere with embedded toplevels; the X11 path mitigates this by making the webview unmanaged.
+- If you see blanking, try: `WEBKIT_DISABLE_COMPOSITING_MODE=1`.
 
 ![alt_test](screenshots/ex.jpg)
 

examples/basic2.rs

@@ -1,4 +1,4 @@
-use fltk::{app, prelude::*, group, input, window};
+use fltk::{app, group, input, prelude::*, window};
 use fltk_webview::*;
 
 fn main() {

examples/bind.rs

@@ -50,6 +50,5 @@ fn main() {
         wv.return_(seq, 0, &format!("\"Hello {}\"", val));
     });
 
-    
     app.run().unwrap();
 }

fltk-webview-sys/src/gtk_helper.c

@@ -12,12 +12,22 @@ GdkWindow *my_get_win(GtkWindow *win) {
 }
 
 void x_init(Display *disp, Window child, Window parent) {
-  XMoveWindow(disp, child, 0, 0);
+  // Make the child unmanaged (override-redirect) to avoid WM interference (e.g., Mutter)
+  XUnmapWindow(disp, child);
+  XSetWindowAttributes attrs;
+  attrs.override_redirect = True;
+  XChangeWindowAttributes(disp, child, CWOverrideRedirect, &attrs);
 
+  // Position and reparent under the FLTK window
+  XMoveWindow(disp, child, 0, 0);
   XReparentWindow(disp, child, parent, 0, 0);
 
+  // Ensure the child remains mapped with the parent
   XFixesChangeSaveSet(disp, child, SetModeInsert, SaveSetRoot, SaveSetUnmap);
+  XMapWindow(disp, child);
+  XSync(disp, False);
 
+  // Send a synthetic ConfigureNotify to ensure size is correct
   XEvent client_event;
   XWindowAttributes childAttributes;
   XWindowAttributes parentAttributes;
@@ -29,6 +39,8 @@ void x_init(Display *disp, Window child, Window parent) {
   client_event.xconfigure.display = disp;
   client_event.xconfigure.event = child;
   client_event.xconfigure.window = child;
+  client_event.xconfigure.x = 0;
+  client_event.xconfigure.y = 0;
   client_event.xconfigure.width = childAttributes.width;
   client_event.xconfigure.height = childAttributes.height;
   client_event.xconfigure.border_width = 0;
@@ -37,3 +49,9 @@ void x_init(Display *disp, Window child, Window parent) {
 
   XSendEvent(disp, child, False, StructureNotifyMask, &client_event);
 }
+
+void x_focus(Display *disp, Window child) {
+  XSetInputFocus(disp, child, RevertToParent, CurrentTime);
+}
+
+int my_gtk_events_pending() { return gtk_events_pending(); }

src/lib.rs

@@ -1,3 +1,4 @@
+#![allow(clippy::needless_doctest_main)]
 #![doc = include_str!("../README.md")]
 
 use fltk::{
@@ -6,39 +7,11 @@ use fltk::{
     window,
 };
 use fltk_webview_sys as wv;
-pub use wv::Webview;
+use std::{os::raw, sync::Arc};
 pub use wv::SizeHint;
-use std::{
-    os::raw,
-    sync::Arc,
-};
+pub use wv::Webview;
 
-#[cfg(not(any(target_os = "macos", target_os = "windows")))]
-fn win_manager(prog: &str) -> bool {
-    let sm = std::env::var("SESSION_MANAGER");
-    if let Ok(sm) = sm {
-        let pid = sm.split("/").last();
-        if let Some(pid) = pid {
-            match std::process::Command::new("ps")
-                .args(&["-p", pid, "-o", "comm="])
-                .output()
-            {
-                Ok(out) => {
-                    if String::from_utf8_lossy(&out.stdout).contains(prog) {
-                        true
-                    } else {
-                        false
-                    }
-                }
-                _ => false,
-            }
-        } else {
-            false
-        }
-    } else {
-        false
-    }
-}
+// Linux path is unified under X11; Wayland embedding is not supported.
 
 pub trait FromFltkWindow {
     fn create(debug: bool, win: &mut window::Window) -> Webview;
@@ -75,15 +48,19 @@ impl FromFltkWindow for Webview {
                     fltk::enums::Event::Push => {
                         SetFocus(w.raw_handle() as _);
                         true
-                    },
-                    _ => false
+                    }
+                    _ => false,
                 });
             }
             #[cfg(target_os = "macos")]
             {
                 pub enum NSWindow {}
                 extern "C" {
-                    pub fn make_delegate(child: *mut NSWindow, parent: *mut NSWindow, add_menu: i32);
+                    pub fn make_delegate(
+                        child: *mut NSWindow,
+                        parent: *mut NSWindow,
+                        add_menu: i32,
+                    );
                     pub fn my_close_win(win: *mut NSWindow);
                 }
                 let handle = win.raw_handle();
@@ -107,9 +84,11 @@ impl FromFltkWindow for Webview {
                 pub enum Display {}
                 extern "C" {
                     pub fn gtk_init(argc: *mut i32, argv: *mut *mut raw::c_char);
+                    pub fn my_gtk_events_pending() -> i32;
                     pub fn my_get_win(wid: *mut GtkWindow) -> *mut GdkWindow;
                     pub fn my_get_xid(w: *mut GdkWindow) -> u64;
                     pub fn x_init(disp: *mut Display, child: u64, parent: u64);
+                    pub fn x_focus(disp: *mut Display, child: u64);
                     pub fn gtk_main_iteration_do(blocking: bool);
                 }
                 gtk_init(&mut 0, std::ptr::null_mut());
@@ -121,25 +100,37 @@ impl FromFltkWindow for Webview {
                 assert!(!temp.is_null());
                 let xid = my_get_xid(temp as _);
                 let flxid = win.raw_handle();
-                if win_manager("gnome-session") {
-                    win.draw(move |w| {
-                        x_init(app::display() as _, xid, flxid);
-                        app::sleep(0.03);
-                        wv::webview_set_size(inner, w.w(), w.h(), 0);
-                    });
-                    win.flush();
-                } else {
-                    x_init(app::display() as _, xid, flxid);
-                    win.draw(move |w| wv::webview_set_size(inner, w.w(), w.h(), 0));
-                }
 
-                app::add_timeout3(0.001, |handle| {
-                    gtk_main_iteration_do(false);
-                    app::repeat_timeout3(0.001, handle);
+                // Unified X11 path: make child unmanaged and reparent into FLTK window
+                x_init(app::display() as _, xid, flxid);
+                // Ensure input focus goes to the embedded child when shown
+                x_focus(app::display() as _, xid);
+
+                win.draw(move |w| wv::webview_set_size(inner, w.w(), w.h(), 0));
+
+                // Set focus to child on mouse press to ensure keystrokes reach WebKit
+                let xid_for_focus = xid;
+                win.handle(move |_, ev| {
+                    if ev == enums::Event::Push {
+                        x_focus(app::display() as _, xid_for_focus);
+                        true
+                    } else {
+                        false
+                    }
+                });
+
+                app::add_timeout3(0.016, |handle| {
+                    let mut spins = 0;
+                    while my_gtk_events_pending() != 0 && spins < 4 {
+                        gtk_main_iteration_do(false);
+                        spins += 1;
+                    }
+                    app::repeat_timeout3(0.016, handle);
                 });
             }
         }
         assert!(!inner.is_null());
+        #[allow(clippy::arc_with_non_send_sync)]
         let inner = Arc::new(inner);
         Webview::from_raw(inner)
     }