akanjs 3.0.0-beta.9 → 3.0.1

package/vendor/@akanjs/native/native/desktop/src/linux/notify.rs

@@ -0,0 +1,211 @@
+//! Local notifications on Linux: the desktop's notification server (org.freedesktop.Notifications,
+//! Desktop Notifications Specification 1.2) on the session bus, through GDBus from gtk-rs (no
+//! notify-rust or libnotify binding). tauri-plugins-workspace/plugins/notification goes through
+//! notify-rust, which makes the same Notify call. The server only shows: it keeps no schedule
+//! (notify_schedule.rs does) and cannot list what it shows, so the shown ones are remembered here
+//! until the server reports them closed.
+//!   notify.status / notify.request → {"status": 2} while a server answers: showing needs no
+//!     permission and there is nothing to ask. UNSUPPORTED when the session has no server (not
+//!     even a D-Bus activatable one) or no session bus.
+//!   notify.add / notify.pending / notify.removePending → notify_schedule.rs
+//!   notify.delivered → the shown ones, with the time they were shown
+//!   notify.removeDelivered {ids} → CloseNotification
+//! Argument `app` {id, name}: the name is the notification's app_name.
+//! Events: "received" when one is shown, "action" when its body is clicked (the "default" action).
+//! A clicked notification is then closed, as on macOS and Windows: servers close it themselves
+//! (spec: unless it is "resident"), but not all do (dunstctl action, checked), so the shell asks too.
+
+use std::collections::HashMap;
+use std::path::Path;
+use std::sync::{Mutex, Once, OnceLock};
+
+use gtk::gio;
+use gtk::glib::{self, ToVariant, Variant, VariantTy};
+
+use crate::json;
+use crate::notify_schedule::{self as schedule, Item};
+
+const NAME: &str = "org.freedesktop.Notifications";
+const PATH: &str = "/org/freedesktop/Notifications";
+/// Per call, D-Bus activation of the server included.
+const TIMEOUT_MS: i32 = 10_000;
+/// Side of the image sent with each notification (the app icon, downscaled from icon.rgba).
+const IMAGE_SIDE: u32 = 64;
+
+struct Shown {
+  /// The server's id for it.
+  server: u32,
+  item: Item,
+  date: f64,
+}
+
+static SHOWN: Mutex<Vec<Shown>> = Mutex::new(Vec::new());
+static APP_NAME: Mutex<String> = Mutex::new(String::new());
+static IMAGE: OnceLock<Option<Variant>> = OnceLock::new();
+static SUBSCRIBE: Once = Once::new();
+
+fn bus() -> Result<gio::DBusConnection, String> {
+  gio::bus_get_sync(gio::BusType::Session, None::<&gio::Cancellable>).map_err(|e| format!("UNSUPPORTED: no D-Bus session bus ({e})"))
+}
+
+/// The D-Bus error name of a failed call ("GDBus.Error:<name>: <message>").
+fn remote_error(e: &glib::Error) -> Option<String> {
+  let rest = e.message().strip_prefix("GDBus.Error:")?;
+  Some(rest.split_once(':').map_or(rest, |(name, _)| name).to_string())
+}
+
+fn call(conn: &gio::DBusConnection, method: &str, args: Option<&Variant>, reply: &str) -> Result<Variant, glib::Error> {
+  let reply = VariantTy::new(reply).expect("a D-Bus reply type");
+  conn.call_sync(Some(NAME), PATH, NAME, method, args, Some(reply), gio::DBusCallFlags::NONE, TIMEOUT_MS, None::<&gio::Cancellable>)
+}
+
+fn status() -> Result<String, String> {
+  let conn = bus()?;
+  match call(&conn, "GetServerInformation", None, "(ssss)") {
+    Ok(_) => Ok(r#"{"status":2}"#.into()),
+    Err(e) => match remote_error(&e).as_deref() {
+      Some(name) if name == "org.freedesktop.DBus.Error.ServiceUnknown" || name == "org.freedesktop.DBus.Error.NameHasNoOwner" || name.starts_with("org.freedesktop.DBus.Error.Spawn.") => {
+        Err(format!("UNSUPPORTED: this session has no notification server ({NAME}): {}", e.message()))
+      }
+      _ => Err(format!("INTERNAL: the notification server did not answer: {}", e.message())),
+    },
+  }
+}
+
+/// The app icon as the "image-data" hint (iiibiiay), from the CLI's icon.rgba next to the app
+/// folder.
+fn image(resources: &Path) -> Option<Variant> {
+  let (side, rgba) = super::app_icon(resources, IMAGE_SIDE)?;
+  let side = side as i32;
+  Some(Variant::tuple_from_iter([
+    side.to_variant(),
+    side.to_variant(),
+    (side * 4).to_variant(),
+    true.to_variant(),
+    8i32.to_variant(),
+    4i32.to_variant(),
+    Variant::array_from_fixed_array(&rgba),
+  ]))
+}
+
+fn event(kind: &str, item: &Item) {
+  crate::push_event(&format!(r#"{{"type":"notification","event":"{kind}","notification":{}}}"#, item.json(None)));
+}
+
+fn show(item: &Item) -> Result<(), String> {
+  let conn = bus()?;
+  let mut hints: HashMap<String, Variant> = HashMap::new();
+  if let Some(image) = IMAGE.get().and_then(Option::as_ref) {
+    hints.insert("image-data".into(), image.clone());
+  }
+  let app_name = APP_NAME.lock().unwrap().clone();
+  // Held across the call, so a NotificationClosed for the new id cannot be handled before it is known.
+  let mut shown = SHOWN.lock().unwrap();
+  // The same id again replaces the one on screen, as a request with the same identifier does on macOS.
+  let replaces = shown.iter().find(|s| s.item.id == item.id).map_or(0, |s| s.server);
+  // "default" is the click on the body (spec: the action key of the default action).
+  let args = (app_name, replaces, "", item.title.as_str(), item.body.as_str(), vec!["default", "Open"], hints, -1i32).to_variant();
+  let reply = call(&conn, "Notify", Some(&args), "(u)").map_err(|e| format!("the notification server refused it: {}", e.message()))?;
+  let (server,) = reply.get::<(u32,)>().ok_or("Notify answered no id")?;
+  shown.retain(|s| s.item.id != item.id && s.server != server);
+  shown.push(Shown { server, item: item.clone(), date: schedule::now_ms() });
+  drop(shown);
+  event("received", item);
+  Ok(())
+}
+
+fn on_signal(member: &str, params: &Variant) {
+  match member {
+    "ActionInvoked" => {
+      let Some((server, key)) = params.get::<(u32, String)>() else { return };
+      if key != "default" {
+        return;
+      }
+      let item = {
+        let mut shown = SHOWN.lock().unwrap();
+        let item = shown.iter().find(|s| s.server == server).map(|s| s.item.clone());
+        shown.retain(|s| s.server != server);
+        item
+      };
+      let Some(item) = item else { return };
+      event("action", &item);
+      // From the main loop, like this callback; nothing waits for the answer.
+      if let Ok(conn) = bus() {
+        let args = (server,).to_variant();
+        conn.call(Some(NAME), PATH, NAME, "CloseNotification", Some(&args), None, gio::DBusCallFlags::NONE, TIMEOUT_MS, None::<&gio::Cancellable>, |_| {});
+      }
+    }
+    "NotificationClosed" => {
+      if let Some((server, _reason)) = params.get::<(u32, u32)>() {
+        SHOWN.lock().unwrap().retain(|s| s.server != server);
+      }
+    }
+    _ => {}
+  }
+}
+
+/// Local days through GLib's calendar arithmetic (g_date_time_add_days keeps the time of day).
+fn add_days(ms: f64, days: i64) -> f64 {
+  let secs = (ms / 1000.0).floor();
+  let local = glib::DateTime::from_unix_local(secs as i64).and_then(|d| d.add_days(days as i32));
+  match local {
+    Ok(d) => d.to_unix() as f64 * 1000.0 + (ms - secs * 1000.0),
+    Err(_) => ms + days as f64 * 86_400_000.0,
+  }
+}
+
+fn run(op: &str, cmd: &json::V) -> Result<String, String> {
+  if let Some(name) = cmd.get("app").and_then(|a| a.get("name")).and_then(|v| v.as_str()) {
+    *APP_NAME.lock().unwrap() = name.to_string();
+  }
+  if let Some(result) = schedule::op(op, cmd) {
+    return result;
+  }
+  match op {
+    "notify.status" | "notify.request" => status(),
+    "notify.delivered" => {
+      let shown = SHOWN.lock().unwrap();
+      Ok(format!("[{}]", shown.iter().map(|s| s.item.json(Some(s.date))).collect::<Vec<_>>().join(",")))
+    }
+    "notify.removeDelivered" => {
+      let ids = schedule::ids(cmd)?;
+      let servers: Vec<u32> = {
+        let mut shown = SHOWN.lock().unwrap();
+        let servers = shown.iter().filter(|s| ids.contains(&s.item.id)).map(|s| s.server).collect();
+        shown.retain(|s| !ids.contains(&s.item.id));
+        servers
+      };
+      if !servers.is_empty() {
+        let conn = bus()?;
+        for server in servers {
+          // Already closed by the user or expired meanwhile: nothing to do.
+          let _ = call(&conn, "CloseNotification", Some(&(server,).to_variant()), "()");
+        }
+      }
+      Ok("null".into())
+    }
+    _ => Err(format!("unknown op {op}")),
+  }
+}
+
+/// notify.* ops, answered from a thread (a D-Bus call can wait for the server to start).
+/// `app_dir`: the shell's app folder, next to the CLI's icon.rgba.
+pub fn async_op(id: u64, json_text: &str, app_dir: &Path) -> bool {
+  if !json_text.contains("\"notify.") {
+    return false;
+  }
+  let Ok(cmd) = json::parse(json_text) else { return false };
+  let Some(op) = cmd.get("op").and_then(|v| v.as_str()).filter(|op| op.starts_with("notify.")) else { return false };
+  IMAGE.get_or_init(|| app_dir.parent().and_then(image));
+  schedule::start(schedule::Host { show, add_days });
+  // On the main thread: GDBus runs signal callbacks on the context of the thread that subscribed,
+  // here the main loop (GTK's, which tao runs).
+  if let Ok(conn) = bus() {
+    SUBSCRIBE.call_once(|| {
+      conn.signal_subscribe(Some(NAME), Some(NAME), None, Some(PATH), None, gio::DBusSignalFlags::NONE, |_, _, _, _, member, params| on_signal(member, params));
+    });
+  }
+  let op = op.to_string();
+  std::thread::spawn(move || crate::reply(id, run(&op, &cmd)));
+  true
+}

package/vendor/@akanjs/native/native/desktop/src/linux/open.rs

@@ -0,0 +1,79 @@
+//! Opening URLs with their default app on Linux (opener, browser and auth-session plugins).
+//!   shell.open    {url} → null      g_app_info_launch_default_for_uri_async, answered through crate::reply
+//!   shell.handler {url} → {"app"}   the desktop entry registered for the URL's scheme, or null
+//! Errors: `NOT_FOUND: …` when no app is registered for the scheme, `INTERNAL: …` otherwise.
+//!
+//! GIO reads the same associations as xdg-open (mimeapps.list, x-scheme-handler/<scheme>) and goes
+//! through the OpenURI portal by itself inside Flatpak or Snap. Asynchronously, because launching
+//! may wait for D-Bus activation. electrobun calls it synchronously and falls back to
+//! `system("xdg-open …")` (electrobun/package/src/native/linux/nativeWrapper.cpp:9931-9965), which
+//! splices the URL into a shell command; GIO needs no fallback. The lookup is what Tauri's
+//! deep-link plugin asks `xdg-mime query default x-scheme-handler/<scheme>` for
+//! (tauri-plugins-workspace/plugins/deep-link/src/lib.rs:494-513), without a process.
+
+use gtk::gio;
+use gtk::prelude::*;
+
+use crate::json;
+
+fn url_arg(cmd: &json::V) -> Result<String, String> {
+  let url = cmd.get("url").and_then(|v| v.as_str()).ok_or("url must be a string")?;
+  if url.is_empty() || url.chars().any(char::is_control) {
+    return Err("url must be a URL".into());
+  }
+  Ok(url.to_string())
+}
+
+fn scheme(url: &str) -> Option<String> {
+  let (scheme, _) = url.split_once(':')?;
+  let ok = scheme.starts_with(|c: char| c.is_ascii_alphabetic()) && scheme.chars().all(|c| c.is_ascii_alphanumeric() || "+-.".contains(c));
+  ok.then(|| scheme.to_ascii_lowercase())
+}
+
+/// The app for `url`'s scheme: its desktop file id ("firefox.desktop"), else its name.
+pub fn handler(url: &str) -> Option<String> {
+  let app = gio::AppInfo::default_for_uri_scheme(&scheme(url)?)?;
+  Some(app.id().map_or_else(|| app.name().to_string(), |id| id.to_string()))
+}
+
+/// `shell.handler`; None for other ops.
+pub fn shell_op(op: &str, cmd: &json::V) -> Option<Result<String, String>> {
+  if op != "shell.handler" {
+    return None;
+  }
+  Some(url_arg(cmd).map(|url| format!(r#"{{"app":{}}}"#, handler(&url).map_or("null".into(), |app| json::quote(&app)))))
+}
+
+/// `shell.open`, answered once GIO launched the app; false for other ops.
+pub fn async_op(id: u64, json_text: &str) -> bool {
+  if !json_text.contains("\"shell.open\"") {
+    return false;
+  }
+  let Ok(cmd) = json::parse(json_text) else { return false };
+  if cmd.get("op").and_then(|v| v.as_str()) != Some("shell.open") {
+    return false;
+  }
+  let url = match url_arg(&cmd) {
+    Ok(url) => url,
+    Err(e) => {
+      crate::reply(id, Err(e));
+      return true;
+    }
+  };
+  let what = scheme(&url).map_or_else(|| url.clone(), |s| format!("{s}:"));
+  let target = url.clone();
+  gio::AppInfo::launch_default_for_uri_async(&target, None::<&gio::AppLaunchContext>, gio::Cancellable::NONE, move |result| {
+    crate::reply(
+      id,
+      result.map(|()| "null".to_string()).map_err(|e| {
+        // "No application is registered as handling this file" (g_app_info_launch_default_for_uri).
+        if e.matches(gio::IOErrorEnum::NotSupported) || (e.matches(gio::IOErrorEnum::NotFound) && handler(&url).is_none()) {
+          format!("NOT_FOUND: no app is registered for {what}")
+        } else {
+          format!("INTERNAL: cannot open {what}: {e}")
+        }
+      }),
+    )
+  });
+  true
+}

package/vendor/@akanjs/native/native/desktop/src/linux/power.rs

@@ -0,0 +1,155 @@
+//! Keeping the display and the system awake on Linux (keep-awake plugin), over the session bus.
+//!   power.preventSleep → null   an inhibitor, answered once the desktop granted it
+//!   power.allowSleep   → null
+//! Tried in order:
+//! 1. The desktop portal: org.freedesktop.portal.Inhibit.Inhibit("", idle | suspend, {reason}) →
+//!    a Request handle, released with org.freedesktop.portal.Request.Close. The portal forwards to
+//!    GNOME's session manager, KDE's PowerDevil and the others, sandboxed or not.
+//! 2. org.freedesktop.ScreenSaver.Inhibit(app, reason) → a cookie, released with UnInhibit (KDE,
+//!    GNOME's gsd-screensaver-proxy, Xfce, Cinnamon). Idle only: the desktop's idle suspend follows it.
+//! Both end when the app's bus connection closes, so a killed app never leaves the machine awake,
+//! as caffeinate -w does on macOS. No service (a bare X server, the test container's D-Bus
+//! session): UNSUPPORTED. Firefox tries the same services (widget/gtk/WakeLockListener.cpp); none of
+//! the reference frameworks keep a Linux desktop awake. GTK's gtk_application_inhibit needs a
+//! registered application id, which TAO does not set.
+
+use std::cell::RefCell;
+
+use gtk::{gio, glib, prelude::*};
+
+/// Inhibit flags of the portal: 4 suspend, 8 idle (org.freedesktop.portal.Inhibit).
+const SUSPEND_AND_IDLE: u32 = 4 | 8;
+const TIMEOUT_MS: i32 = 10_000;
+
+enum Held {
+  None,
+  /// Asking; these calls wait for the answer. `release`: allowSleep came meanwhile.
+  Pending { waiting: Vec<u64>, release: bool },
+  Portal(String),
+  ScreenSaver(u32),
+}
+
+thread_local! {
+  static HELD: RefCell<Held> = const { RefCell::new(Held::None) };
+}
+
+fn session() -> Result<gio::DBusConnection, String> {
+  gio::bus_get_sync(gio::BusType::Session, gio::Cancellable::NONE).map_err(|e| format!("UNSUPPORTED: no D-Bus session bus: {e}"))
+}
+
+fn call(conn: &gio::DBusConnection, dest: &str, path: &str, iface: &str, method: &str, args: glib::Variant, reply: &str, done: impl FnOnce(Result<glib::Variant, glib::Error>) + 'static) {
+  conn.call(Some(dest), path, iface, method, Some(&args), glib::VariantTy::new(reply).ok(), gio::DBusCallFlags::NONE, TIMEOUT_MS, gio::Cancellable::NONE, done);
+}
+
+fn release(conn: &gio::DBusConnection, held: Held) {
+  let ignore = |r: Result<glib::Variant, glib::Error>| {
+    if let Err(e) = r {
+      log!("keep-awake: releasing the inhibitor failed: {e}");
+    }
+  };
+  match held {
+    Held::Portal(handle) => call(conn, "org.freedesktop.portal.Desktop", &handle, "org.freedesktop.portal.Request", "Close", glib::Variant::tuple_from_iter([] as [glib::Variant; 0]), "()", ignore),
+    Held::ScreenSaver(cookie) => call(conn, "org.freedesktop.ScreenSaver", "/org/freedesktop/ScreenSaver", "org.freedesktop.ScreenSaver", "UnInhibit", (cookie,).to_variant(), "()", ignore),
+    Held::None | Held::Pending { .. } => {}
+  }
+}
+
+/// The inhibitor arrived (or not): answer every waiting call, or release it at once when
+/// allowSleep came meanwhile.
+fn settle(conn: &gio::DBusConnection, result: Result<Held, String>) {
+  let pending = HELD.with(|h| std::mem::replace(&mut *h.borrow_mut(), Held::None));
+  let Held::Pending { waiting, release: released } = pending else { return };
+  let answer = match result {
+    Ok(held) if released => {
+      release(conn, held);
+      Ok("null".to_string())
+    }
+    Ok(held) => {
+      HELD.with(|h| *h.borrow_mut() = held);
+      Ok("null".to_string())
+    }
+    Err(e) => Err(e),
+  };
+  for id in waiting {
+    crate::reply(id, answer.clone());
+  }
+}
+
+fn prevent(id: u64, app: &str) {
+  let conn = match session() {
+    Ok(conn) => conn,
+    Err(e) => return crate::reply(id, Err(e)),
+  };
+  let started = HELD.with(|h| {
+    let mut held = h.borrow_mut();
+    match &mut *held {
+      Held::Portal(_) | Held::ScreenSaver(_) => {
+        crate::reply(id, Ok("null".into()));
+        false
+      }
+      Held::Pending { waiting, release } => {
+        waiting.push(id);
+        *release = false;
+        false
+      }
+      Held::None => {
+        *held = Held::Pending { waiting: vec![id], release: false };
+        true
+      }
+    }
+  });
+  if !started {
+    return;
+  }
+  let reason = format!("{app} keeps the display on");
+  let options = glib::VariantDict::new(None);
+  options.insert_value("reason", &reason.to_variant());
+  let args = glib::Variant::tuple_from_iter(["".to_variant(), SUSPEND_AND_IDLE.to_variant(), options.end()]);
+  let (app, portal_conn) = (app.to_string(), conn.clone());
+  call(&conn, "org.freedesktop.portal.Desktop", "/org/freedesktop/portal/desktop", "org.freedesktop.portal.Inhibit", "Inhibit", args, "(o)", move |result| {
+    match result.map(|reply| reply.child_value(0).str().map(str::to_string)) {
+      Ok(Some(handle)) => settle(&portal_conn, Ok(Held::Portal(handle))),
+      portal => {
+        let portal_error = portal.err().map_or_else(|| "no request handle".to_string(), |e| e.to_string());
+        let conn = portal_conn.clone();
+        call(&portal_conn, "org.freedesktop.ScreenSaver", "/org/freedesktop/ScreenSaver", "org.freedesktop.ScreenSaver", "Inhibit", (app.as_str(), reason.as_str()).to_variant(), "(u)", move |result| {
+          let held = result.map(|reply| Held::ScreenSaver(reply.child_value(0).get::<u32>().unwrap_or(0))).map_err(|e| {
+            format!("UNSUPPORTED: no inhibit service on the session bus (xdg-desktop-portal: {portal_error}; org.freedesktop.ScreenSaver: {e})")
+          });
+          settle(&conn, held);
+        });
+      }
+    }
+  });
+}
+
+fn allow(id: u64) {
+  let held = HELD.with(|h| {
+    let mut held = h.borrow_mut();
+    if let Held::Pending { release, .. } = &mut *held {
+      *release = true;
+      return Held::None;
+    }
+    std::mem::replace(&mut *held, Held::None)
+  });
+  if !matches!(held, Held::None) {
+    if let Ok(conn) = session() {
+      release(&conn, held);
+    }
+  }
+  crate::reply(id, Ok("null".into()));
+}
+
+/// `power.*` ops, answered through crate::reply; false for other ops. `app` names the app to the desktop.
+pub fn async_op(id: u64, json_text: &str, app: &str) -> bool {
+  if !json_text.contains("\"power.") {
+    return false;
+  }
+  let Ok(cmd) = crate::json::parse(json_text) else { return false };
+  match cmd.get("op").and_then(|v| v.as_str()) {
+    Some("power.preventSleep") => prevent(id, app),
+    Some("power.allowSleep") => allow(id),
+    _ => return false,
+  }
+  true
+}

package/vendor/@akanjs/native/native/desktop/src/linux/screen.rs

@@ -0,0 +1,158 @@
+//! Displays and the mouse cursor on Linux (screen plugin, plugins.md §5), with the ops and JSON of
+//! screen.rs: GDK monitors.
+//!
+//! - bounds are the monitor's GDK geometry: logical pixels in the space of the X screen (or the
+//!   Wayland compositor), the same numbers tao's monitors give as physical pixels divided by the
+//!   integer scale (tao-0.37.0/src/platform_impl/linux/monitor.rs:28-51, the rects lib.rs
+//!   `monitors` hands to placement.rs) and the space window.setPosition uses. Its origin is the
+//!   top-left corner of the whole desktop, which need not be the primary display's.
+//! - workArea: gdk_monitor_get_workarea (Electrobun reads the same, electrobun/package/src/native/
+//!   linux/nativeWrapper.cpp:12009-12060). On X11 GDK takes it from _GTK_WORKAREAS or
+//!   _NET_WORKAREA, which window managers keep only for the primary monitor; on Wayland it is the
+//!   geometry. Clamped into bounds.
+//! - name: "<manufacturer> <model>"; on X11 the model is the RandR output ("HDMI-1"), so `id`
+//!   hashes it: stable while the display stays connected.
+//! - primary: the monitor GDK calls primary, else the first one (X servers without a RandR
+//!   primary output, such as Xvfb).
+//! - screen.watch: GdkScreen monitors-changed and each monitor's geometry and scale notifications.
+//!   Work area changes (a panel appearing) send nothing.
+//! - The cursor: the seat pointer's position in the same space (Electrobun does the same,
+//!   nativeWrapper.cpp:12116-12153). Wayland tells an app where the pointer is only over its own
+//!   windows (tao answers 0,0 there, tao-0.37.0/src/platform_impl/linux/util.rs:17-38): UNSUPPORTED.
+
+use std::cell::Cell;
+
+use gtk::{gdk, prelude::*};
+
+use crate::{json, placement::Rect, push_event};
+
+fn rect(r: gdk::Rectangle) -> Rect {
+  Rect { x: r.x() as f64, y: r.y() as f64, width: r.width() as f64, height: r.height() as f64 }
+}
+
+/// `inner` cut to `outer`.
+fn clamp(inner: Rect, outer: Rect) -> Rect {
+  let x = inner.x.max(outer.x);
+  let y = inner.y.max(outer.y);
+  let right = (inner.x + inner.width).min(outer.x + outer.width);
+  let bottom = (inner.y + inner.height).min(outer.y + outer.height);
+  if right <= x || bottom <= y {
+    return outer;
+  }
+  Rect { x, y, width: right - x, height: bottom - y }
+}
+
+/// FNV-1a: a stable number from the output's name.
+fn hash(s: &str) -> u32 {
+  s.bytes().fold(0x811c9dc5u32, |h, b| (h ^ b as u32).wrapping_mul(0x01000193))
+}
+
+fn rect_json(r: Rect) -> String {
+  format!(r#"{{"x":{},"y":{},"width":{},"height":{}}}"#, r.x, r.y, r.width, r.height)
+}
+
+fn displays() -> Result<String, String> {
+  let display = gdk::Display::default().ok_or("there is no display")?;
+  let monitors: Vec<gdk::Monitor> = (0..display.n_monitors()).filter_map(|i| display.monitor(i)).collect();
+  let primary = monitors.iter().position(|m| m.is_primary()).unwrap_or(0);
+  let mut list: Vec<(bool, String)> = Vec::new();
+  let mut seen: Vec<u32> = Vec::new();
+  for (i, m) in monitors.iter().enumerate() {
+    let bounds = rect(m.geometry());
+    let work_area = clamp(rect(m.workarea()), bounds);
+    let model = m.model().map(|s| s.to_string()).unwrap_or_default();
+    let manufacturer = m.manufacturer().map(|s| s.to_string()).unwrap_or_default();
+    let name = [manufacturer.as_str(), model.as_str()].iter().filter(|s| !s.is_empty()).copied().collect::<Vec<_>>().join(" ");
+    let mut id = hash(&format!("{manufacturer}/{model}"));
+    while seen.contains(&id) {
+      id = id.wrapping_add(1); // two monitors of the same model on Wayland
+    }
+    seen.push(id);
+    let json = format!(
+      r#"{{"id":{id},"name":{},"bounds":{},"workArea":{},"scale":{},"primary":{}}}"#,
+      json::quote(&name),
+      rect_json(bounds),
+      rect_json(work_area),
+      m.scale_factor(),
+      i == primary
+    );
+    list.push((i == primary, json));
+  }
+  list.sort_by_key(|(primary, _)| !primary);
+  Ok(format!("[{}]", list.into_iter().map(|(_, j)| j).collect::<Vec<_>>().join(",")))
+}
+
+fn cursor() -> Result<String, String> {
+  let display = gdk::Display::default().ok_or("there is no display")?;
+  if display.type_().name() != "GdkX11Display" {
+    return Err("UNSUPPORTED: Wayland tells apps where the pointer is only over their own windows".into());
+  }
+  let pointer = display.default_seat().and_then(|s| s.pointer()).ok_or("there is no pointer")?;
+  let (_, x, y) = pointer.position_double();
+  Ok(format!(r#"{{"x":{x},"y":{y}}}"#))
+}
+
+thread_local! {
+  static WATCHING: Cell<bool> = const { Cell::new(false) };
+}
+
+fn changed() {
+  push_event(r#"{"type":"screen","event":"changed"}"#);
+}
+
+fn watch_monitor(m: &gdk::Monitor) {
+  m.connect_geometry_notify(|_| changed());
+  m.connect_scale_factor_notify(|_| changed());
+}
+
+fn watch() -> Result<String, String> {
+  if WATCHING.with(|w| w.replace(true)) {
+    return Ok("null".into());
+  }
+  let display = gdk::Display::default().ok_or("there is no display")?;
+  for i in 0..display.n_monitors() {
+    if let Some(m) = display.monitor(i) {
+      watch_monitor(&m);
+    }
+  }
+  display.connect_monitor_added(|_, m| {
+    watch_monitor(m);
+    changed();
+  });
+  display.connect_monitor_removed(|_, _| changed());
+  display.default_screen().connect_monitors_changed(|_| changed());
+  Ok("null".into())
+}
+
+/// screen.* shell ops; None for other ops.
+pub fn shell_op(op: &str) -> Option<Result<String, String>> {
+  let result = match op {
+    "screen.displays" => displays(),
+    "screen.cursor" => cursor(),
+    "screen.watch" => watch(),
+    _ if op.starts_with("screen.") => Err(format!("unknown op {op}")),
+    _ => return None,
+  };
+  Some(result)
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+
+  fn r(x: f64, y: f64, width: f64, height: f64) -> Rect {
+    Rect { x, y, width, height }
+  }
+
+  #[test]
+  fn work_area_inside_bounds() {
+    let b = r(0.0, 0.0, 1920.0, 1080.0);
+    assert_eq!(clamp(r(0.0, 27.0, 1920.0, 1053.0), b), r(0.0, 27.0, 1920.0, 1053.0));
+    // _NET_WORKAREA spans the whole desktop: cut to the monitor.
+    assert_eq!(clamp(r(0.0, 27.0, 3840.0, 1053.0), r(1920.0, 0.0, 1920.0, 1080.0)), r(1920.0, 27.0, 1920.0, 1053.0));
+    // No overlap: the bounds.
+    assert_eq!(clamp(r(5000.0, 0.0, 10.0, 10.0), b), b);
+    assert_eq!(hash("HDMI-1"), hash("HDMI-1"));
+    assert_ne!(hash("HDMI-1"), hash("HDMI-2"));
+  }
+}