mirror of
https://github.com/marcoallegretti/WEFT_OS.git
synced 2026-11-22 08:13:59 +00:00
The software rendering path (softbuffer) and the EGL path keep their own Wayland objects on winit's display, so dropping the rendering context after the event loop could destroy proxies on a disconnected display just like the shell client did. Both hosts now release the rendering context and the window in winit's exiting handler as well. The compositor records the keys whose press a shortcut took and takes only those releases, so no client sees a release without its press or keeps a key pressed. check_activation.py watches the panel for six seconds after Alt+F4 instead of sampling it once.
705 lines
25 KiB
Rust
705 lines
25 KiB
Rust
use std::num::NonZeroU32;
|
|
use std::rc::Rc;
|
|
use std::sync::atomic::{AtomicBool, Ordering};
|
|
use std::sync::{Arc, Mutex};
|
|
|
|
use servo::{
|
|
DeviceIntRect, DeviceIntSize, DevicePoint, EventLoopWaker, InputEvent, LoadStatus,
|
|
MouseButton as ServoMouseButton, MouseButtonAction, MouseButtonEvent, MouseMoveEvent,
|
|
NavigationRequest, RenderingContext, RgbaImage, ServoBuilder, ServoDelegate, ServoUrl,
|
|
UserContentManager, UserScript, WebViewBuilder, WebViewDelegate,
|
|
};
|
|
use winit::{
|
|
application::ApplicationHandler,
|
|
dpi::PhysicalSize,
|
|
event::{ElementState, MouseButton, WindowEvent},
|
|
event_loop::{ActiveEventLoop, EventLoop, EventLoopProxy},
|
|
keyboard::ModifiersState,
|
|
raw_window_handle::{HasDisplayHandle, HasWindowHandle, RawDisplayHandle, RawWindowHandle},
|
|
window::{Window, WindowAttributes, WindowId},
|
|
};
|
|
|
|
#[derive(Clone)]
|
|
struct WeftEventLoopWaker {
|
|
proxy: Arc<Mutex<EventLoopProxy<ServoWake>>>,
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
struct ServoWake;
|
|
|
|
impl EventLoopWaker for WeftEventLoopWaker {
|
|
fn clone_box(&self) -> Box<dyn EventLoopWaker> {
|
|
Box::new(self.clone())
|
|
}
|
|
|
|
fn wake(&self) {
|
|
let _ = self
|
|
.proxy
|
|
.lock()
|
|
.unwrap_or_else(|p| p.into_inner())
|
|
.send_event(ServoWake);
|
|
}
|
|
}
|
|
|
|
struct WeftServoDelegate;
|
|
|
|
impl ServoDelegate for WeftServoDelegate {
|
|
fn notify_error(&self, error: servo::ServoError) {
|
|
tracing::error!(?error, "Servo error");
|
|
}
|
|
|
|
/// Loads not tied to the webview, such as `navigator.sendBeacon()`,
|
|
/// worklets and notification icons, also come from the application page,
|
|
/// and none of them is needed: all are refused.
|
|
fn load_web_resource(&self, load: servo::WebResourceLoad) {
|
|
let url = load.request().url.clone();
|
|
tracing::warn!(%url, "resource load outside the webview denied");
|
|
load.intercept(servo::WebResourceResponse::new(url))
|
|
.cancel();
|
|
}
|
|
}
|
|
|
|
/// Frame and load progress reported by Servo, shared with the event loop.
|
|
#[derive(Default)]
|
|
struct FrameSignals {
|
|
/// A new frame is waiting to be painted.
|
|
redraw: AtomicBool,
|
|
/// Servo has requested at least one repaint.
|
|
content: AtomicBool,
|
|
/// The document has loaded and Servo reports its rendering is up to date.
|
|
settled: AtomicBool,
|
|
}
|
|
|
|
struct WeftWebViewDelegate {
|
|
signals: Arc<FrameSignals>,
|
|
/// URL prefix of the application's UI directory; see `ui_scope`.
|
|
scope: String,
|
|
/// The UI directory with symbolic links resolved, if it exists.
|
|
ui_dir: Option<std::path::PathBuf>,
|
|
/// The bridge's WebSocket handshake URL, as the network layer requests it
|
|
/// (`ws:` becomes `http:`).
|
|
bridge: String,
|
|
}
|
|
|
|
impl WebViewDelegate for WeftWebViewDelegate {
|
|
fn notify_new_frame_ready(&self, _webview: servo::WebView) {
|
|
self.signals.content.store(true, Ordering::Relaxed);
|
|
self.signals.redraw.store(true, Ordering::Relaxed);
|
|
}
|
|
|
|
/// The webview carries the session's bridge, so it stays within the
|
|
/// application's own UI files.
|
|
fn request_navigation(&self, _webview: servo::WebView, request: NavigationRequest) {
|
|
if in_scope(request.url.as_str(), &self.scope) {
|
|
request.allow();
|
|
} else {
|
|
tracing::warn!(url = %request.url, "navigation outside the application UI denied");
|
|
request.deny();
|
|
}
|
|
}
|
|
|
|
/// Every resource the webview loads passes through here, including
|
|
/// `fetch()`, XHR, subresources and WebSocket handshakes. The page may
|
|
/// read its own UI files and open the session bridge; any other local
|
|
/// file or network destination is refused with a network error. Network
|
|
/// access belongs to the component, under its fetch grants.
|
|
///
|
|
/// On a redirect Servo reports the first URL of the chain again, not the
|
|
/// target, so every redirect is refused.
|
|
fn load_web_resource(&self, _webview: servo::WebView, load: servo::WebResourceLoad) {
|
|
let request = load.request();
|
|
let url = request.url.clone();
|
|
if !request.is_redirect && self.allows(&ServoUrl::from_url(url.clone())) {
|
|
return;
|
|
}
|
|
tracing::warn!(%url, "resource outside the application denied");
|
|
load.intercept(servo::WebResourceResponse::new(url))
|
|
.cancel();
|
|
}
|
|
|
|
fn notify_load_status_changed(&self, webview: servo::WebView, status: LoadStatus) {
|
|
if status != LoadStatus::Complete {
|
|
return;
|
|
}
|
|
// Servo completes a screenshot request only once every frame has fired
|
|
// `load`, render-blocking resources, images and web fonts are done and
|
|
// the rendering is up to date, which is the readiness this host reports.
|
|
let signals = Arc::clone(&self.signals);
|
|
webview.take_screenshot(None, move |result| match result {
|
|
Ok(_) => {
|
|
signals.settled.store(true, Ordering::Relaxed);
|
|
signals.redraw.store(true, Ordering::Relaxed);
|
|
}
|
|
Err(e) => tracing::error!(?e, "document rendering did not settle; not ready"),
|
|
});
|
|
}
|
|
}
|
|
|
|
/// The readiness line for weft-appd: `READY <token>` with the session token
|
|
/// from `WEFT_READY_TOKEN`, or `READY` when run without appd.
|
|
fn ready_line() -> String {
|
|
match std::env::var("WEFT_READY_TOKEN") {
|
|
Ok(token) => format!("READY {token}"),
|
|
Err(_) => "READY".to_owned(),
|
|
}
|
|
}
|
|
|
|
/// The session's application bridge credential from weft-appd.
|
|
///
|
|
/// Only 32 lowercase hex characters are accepted, so the value can be placed
|
|
/// in the injected script without escaping.
|
|
fn bridge_token() -> Option<String> {
|
|
let token = std::env::var("WEFT_BRIDGE_TOKEN").ok()?;
|
|
(token.len() == 32
|
|
&& token
|
|
.bytes()
|
|
.all(|b| b.is_ascii_digit() || (b'a'..=b'f').contains(&b)))
|
|
.then_some(token)
|
|
}
|
|
|
|
/// The URL prefix covering the application's UI: the directory holding its
|
|
/// entry document.
|
|
fn ui_scope(entry: &ServoUrl) -> String {
|
|
let url = entry.as_str();
|
|
let end = url.rfind('/').map_or(url.len(), |slash| slash + 1);
|
|
url[..end].to_owned()
|
|
}
|
|
|
|
/// Whether `url` lies inside the UI directory `scope`. Encoded path
|
|
/// separators are refused, since a file loader may decode them into a path
|
|
/// that leaves the directory.
|
|
fn in_scope(url: &str, scope: &str) -> bool {
|
|
url.strip_prefix(scope).is_some_and(|rest| {
|
|
let rest = rest.to_ascii_lowercase();
|
|
!rest.contains("%2f") && !rest.contains("%5c")
|
|
})
|
|
}
|
|
|
|
impl WeftWebViewDelegate {
|
|
/// Whether an application page may load `url`: a file inside its UI
|
|
/// directory, also after resolving symbolic links, an inline (`data:`,
|
|
/// `blob:`) resource, `about:blank`, or the session bridge.
|
|
fn allows(&self, url: &ServoUrl) -> bool {
|
|
match url.scheme() {
|
|
"file" => {
|
|
in_scope(url.as_str(), &self.scope)
|
|
&& self.ui_dir.as_deref().is_some_and(|dir| {
|
|
url.to_file_path()
|
|
.ok()
|
|
.and_then(|path| path.canonicalize().ok())
|
|
.is_some_and(|path| path.starts_with(dir))
|
|
})
|
|
}
|
|
"data" | "blob" => true,
|
|
"about" => url.as_str() == "about:blank",
|
|
_ => url.as_str() == self.bridge,
|
|
}
|
|
}
|
|
}
|
|
|
|
/// The UI directory behind the URL prefix `scope`, with symbolic links
|
|
/// resolved.
|
|
fn ui_dir(scope: &str) -> Option<std::path::PathBuf> {
|
|
ServoUrl::parse(scope)
|
|
.ok()?
|
|
.to_file_path()
|
|
.ok()?
|
|
.canonicalize()
|
|
.ok()
|
|
}
|
|
|
|
/// `value` as a single-quoted JavaScript string literal.
|
|
fn js_string(value: &str) -> String {
|
|
let mut literal = String::with_capacity(value.len() + 2);
|
|
literal.push('\'');
|
|
for c in value.chars() {
|
|
match c {
|
|
' '..='~' if c != '\'' && c != '\\' => literal.push(c),
|
|
_ => literal.push_str(&format!("\\u{{{:x}}}", u32::from(c))),
|
|
}
|
|
}
|
|
literal.push('\'');
|
|
literal
|
|
}
|
|
|
|
/// The `window.weftIpc` bridge injected into the application document.
|
|
///
|
|
/// Servo runs user scripts in every document, frames included, so the bridge
|
|
/// installs itself only in a top-level document within the application's UI
|
|
/// directory `scope`. It authenticates as this session's application bridge and exchanges
|
|
/// `APP_MESSAGE` envelopes with weft-appd. `send` accepts a string or a
|
|
/// JSON-serialisable value; `onmessage` receives each payload string. The
|
|
/// credential stays inside the closure.
|
|
fn bridge_script(port: u16, session_id: u64, token: &str, scope: &str) -> String {
|
|
let scope = js_string(scope);
|
|
format!(
|
|
r#"(function () {{
|
|
var rest = location.href.indexOf({scope}) === 0 ? location.href.slice({scope}.length) : null;
|
|
if (window !== window.top || rest === null || /%2f|%5c/i.test(rest)) return;
|
|
var ws = new WebSocket('ws://127.0.0.1:{port}/app');
|
|
var queue = [];
|
|
var open = false;
|
|
function envelope(m) {{
|
|
return JSON.stringify({{ type: 'APP_MESSAGE', payload: typeof m === 'string' ? m : JSON.stringify(m) }});
|
|
}}
|
|
ws.onopen = function () {{
|
|
ws.send(JSON.stringify({{ type: 'HELLO', role: 'app', session_id: {session_id}, token: '{token}' }}));
|
|
open = true;
|
|
queue.forEach(function (m) {{ ws.send(envelope(m)); }});
|
|
queue.length = 0;
|
|
}};
|
|
ws.onmessage = function (e) {{
|
|
var msg;
|
|
try {{ msg = JSON.parse(e.data); }} catch (_) {{ return; }}
|
|
if (msg.type === 'APP_MESSAGE' && window.weftIpc.onmessage) window.weftIpc.onmessage(msg.payload);
|
|
}};
|
|
window.weftSessionId = {session_id};
|
|
window.weftIpc = {{
|
|
send: function (m) {{ if (open) ws.send(envelope(m)); else queue.push(m); }},
|
|
onmessage: null
|
|
}};
|
|
}})();"#
|
|
)
|
|
}
|
|
|
|
/// Servo preferences shared by the WEFT hosts.
|
|
fn host_preferences() -> servo::Preferences {
|
|
servo::Preferences {
|
|
// The system UI and application pages lay out with CSS Grid, which
|
|
// Servo disables by default.
|
|
layout_grid_enabled: true,
|
|
..Default::default()
|
|
}
|
|
}
|
|
|
|
// ── Rendering ───────────────────────────────────────────────────────────────
|
|
|
|
type BlitSurface = softbuffer::Surface<Arc<Window>, Arc<Window>>;
|
|
|
|
enum RenderingCtx {
|
|
/// Servo renders offscreen; each frame is read back and copied to the window.
|
|
Software {
|
|
context: Rc<servo::SoftwareRenderingContext>,
|
|
surface: BlitSurface,
|
|
},
|
|
/// Servo renders directly to the window's EGL surface.
|
|
Egl(Rc<servo::WindowRenderingContext>),
|
|
}
|
|
|
|
impl RenderingCtx {
|
|
fn as_dyn(&self) -> Rc<dyn RenderingContext> {
|
|
match self {
|
|
Self::Software { context, .. } => Rc::clone(context) as Rc<dyn RenderingContext>,
|
|
Self::Egl(context) => Rc::clone(context) as Rc<dyn RenderingContext>,
|
|
}
|
|
}
|
|
|
|
/// Paints the webview into this context and presents the frame on the window.
|
|
fn paint_and_present(&mut self, webview: &servo::WebView) -> Result<(), String> {
|
|
match self {
|
|
Self::Software { context, surface } => {
|
|
context
|
|
.make_current()
|
|
.map_err(|e| format!("make_current: {e:?}"))?;
|
|
webview.paint();
|
|
let size = context.size();
|
|
let rect = DeviceIntRect::from_size(DeviceIntSize::new(
|
|
size.width as i32,
|
|
size.height as i32,
|
|
));
|
|
let image = context.read_to_image(rect);
|
|
context.present();
|
|
let image = image.ok_or("frame readback failed")?;
|
|
blit(surface, &image)
|
|
}
|
|
Self::Egl(context) => {
|
|
context
|
|
.make_current()
|
|
.map_err(|e| format!("make_current: {e:?}"))?;
|
|
webview.paint();
|
|
context.present();
|
|
Ok(())
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Copies an RGBA frame into the window's software surface and presents it.
|
|
fn blit(surface: &mut BlitSurface, image: &RgbaImage) -> Result<(), String> {
|
|
let (width, height) = image.dimensions();
|
|
let (Some(w), Some(h)) = (NonZeroU32::new(width), NonZeroU32::new(height)) else {
|
|
return Ok(());
|
|
};
|
|
surface.resize(w, h).map_err(|e| format!("resize: {e}"))?;
|
|
let mut buffer = surface.buffer_mut().map_err(|e| format!("buffer: {e}"))?;
|
|
for (dst, src) in buffer.iter_mut().zip(image.as_raw().chunks_exact(4)) {
|
|
*dst = u32::from(src[0]) << 16 | u32::from(src[1]) << 8 | u32::from(src[2]);
|
|
}
|
|
buffer.present().map_err(|e| format!("present: {e}"))
|
|
}
|
|
|
|
/// Returns winit's `wl_display` and `wl_surface` pointers when running on Wayland.
|
|
fn wayland_handles(
|
|
event_loop: &ActiveEventLoop,
|
|
window: &Window,
|
|
) -> Option<(*mut std::ffi::c_void, *mut std::ffi::c_void)> {
|
|
let RawDisplayHandle::Wayland(display) = event_loop.display_handle().ok()?.as_raw() else {
|
|
return None;
|
|
};
|
|
let RawWindowHandle::Wayland(surface) = window.window_handle().ok()?.as_raw() else {
|
|
return None;
|
|
};
|
|
Some((display.display.as_ptr(), surface.surface.as_ptr()))
|
|
}
|
|
|
|
struct App {
|
|
url: ServoUrl,
|
|
app_id: String,
|
|
session_id: u64,
|
|
ws_port: u16,
|
|
window: Option<Arc<Window>>,
|
|
servo: Option<servo::Servo>,
|
|
webview: Option<servo::WebView>,
|
|
rendering_context: Option<RenderingCtx>,
|
|
signals: Arc<FrameSignals>,
|
|
waker: WeftEventLoopWaker,
|
|
shutting_down: bool,
|
|
ready_signalled: bool,
|
|
modifiers: ModifiersState,
|
|
cursor_pos: DevicePoint,
|
|
shell_client: Option<crate::shell_client::ShellClient>,
|
|
}
|
|
|
|
impl App {
|
|
fn new(
|
|
url: ServoUrl,
|
|
app_id: String,
|
|
session_id: u64,
|
|
ws_port: u16,
|
|
waker: WeftEventLoopWaker,
|
|
) -> Self {
|
|
Self {
|
|
url,
|
|
app_id,
|
|
session_id,
|
|
ws_port,
|
|
window: None,
|
|
servo: None,
|
|
webview: None,
|
|
rendering_context: None,
|
|
signals: Arc::default(),
|
|
waker,
|
|
shutting_down: false,
|
|
ready_signalled: false,
|
|
modifiers: ModifiersState::default(),
|
|
cursor_pos: DevicePoint::origin(),
|
|
shell_client: None,
|
|
}
|
|
}
|
|
|
|
/// Paints and presents once Servo has requested its first repaint.
|
|
///
|
|
/// Nothing is presented before that request; the first frames can still be
|
|
/// blank or unstyled while the document loads. READY is printed after a
|
|
/// frame is presented once the document has loaded and its rendering has
|
|
/// settled.
|
|
fn render_frame(&mut self) {
|
|
if !self.signals.content.load(Ordering::Relaxed) {
|
|
return;
|
|
}
|
|
let (Some(webview), Some(context)) = (&self.webview, &mut self.rendering_context) else {
|
|
return;
|
|
};
|
|
if let Err(e) = context.paint_and_present(webview) {
|
|
tracing::warn!("frame not presented: {e}");
|
|
return;
|
|
}
|
|
if !self.ready_signalled && self.signals.settled.load(Ordering::Relaxed) {
|
|
self.ready_signalled = true;
|
|
println!("{}", ready_line());
|
|
use std::io::Write;
|
|
let _ = std::io::stdout().flush();
|
|
}
|
|
}
|
|
|
|
/// Drops the webview and Servo; dropping the last `Servo` handle shuts it down.
|
|
fn shut_down(&mut self) {
|
|
self.shutting_down = true;
|
|
self.webview = None;
|
|
self.servo = None;
|
|
}
|
|
}
|
|
|
|
impl ApplicationHandler<ServoWake> for App {
|
|
/// Releases everything that holds Wayland objects of winit's display
|
|
/// (Servo, the rendering context, whose software and EGL paths keep
|
|
/// their own proxies on it, the shell protocol client and the window)
|
|
/// while that display is still connected; dropped after the event loop,
|
|
/// they would be destroyed on a display that is gone. A panic unwinding
|
|
/// out of a handler skips this.
|
|
fn exiting(&mut self, _event_loop: &ActiveEventLoop) {
|
|
self.shut_down();
|
|
self.rendering_context = None;
|
|
self.shell_client = None;
|
|
self.window = None;
|
|
}
|
|
|
|
fn resumed(&mut self, event_loop: &ActiveEventLoop) {
|
|
if self.window.is_some() {
|
|
return;
|
|
}
|
|
|
|
let title = format!("WEFT App — {}", self.url.host_str().unwrap_or("app"));
|
|
let attrs = WindowAttributes::default().with_title(title);
|
|
let window = match event_loop.create_window(attrs) {
|
|
Ok(w) => Arc::new(w),
|
|
Err(e) => {
|
|
tracing::error!(error = %e, "failed to create app window; exiting");
|
|
event_loop.exit();
|
|
return;
|
|
}
|
|
};
|
|
let size = window.inner_size();
|
|
self.window = Some(Arc::clone(&window));
|
|
|
|
if self.shell_client.is_none()
|
|
&& let Some((disp, surf)) = wayland_handles(event_loop, &window)
|
|
{
|
|
match crate::shell_client::ShellClient::connect_as_app_with_display(
|
|
&self.app_id,
|
|
self.session_id,
|
|
disp,
|
|
surf,
|
|
) {
|
|
Ok(sc) => self.shell_client = Some(sc),
|
|
Err(e) => tracing::warn!(error = %e, "shell protocol unavailable"),
|
|
}
|
|
}
|
|
|
|
let servo = ServoBuilder::default()
|
|
.preferences(host_preferences())
|
|
.event_loop_waker(Box::new(self.waker.clone()))
|
|
.build();
|
|
|
|
servo.set_delegate(Rc::new(WeftServoDelegate));
|
|
|
|
let Some(rendering_context) = build_rendering_ctx(event_loop, &window, size) else {
|
|
tracing::error!("no rendering context available; exiting without READY signal");
|
|
event_loop.exit();
|
|
return;
|
|
};
|
|
|
|
let ucm = Rc::new(UserContentManager::new(&servo));
|
|
if let Some(kit_js) = load_ui_kit_script() {
|
|
ucm.add_script(Rc::new(UserScript::new(kit_js, None)));
|
|
}
|
|
match bridge_token() {
|
|
Some(token) => ucm.add_script(Rc::new(UserScript::new(
|
|
bridge_script(self.ws_port, self.session_id, &token, &ui_scope(&self.url)),
|
|
None,
|
|
))),
|
|
None => {
|
|
tracing::warn!("WEFT_BRIDGE_TOKEN missing or malformed; app messaging disabled")
|
|
}
|
|
}
|
|
|
|
let webview = WebViewBuilder::new(&servo, rendering_context.as_dyn())
|
|
.delegate(Rc::new(WeftWebViewDelegate {
|
|
signals: Arc::clone(&self.signals),
|
|
scope: ui_scope(&self.url),
|
|
ui_dir: ui_dir(&ui_scope(&self.url)),
|
|
bridge: format!("http://127.0.0.1:{}/app", self.ws_port),
|
|
}))
|
|
.user_content_manager(ucm)
|
|
.url(self.url.clone().into_url())
|
|
.build();
|
|
|
|
self.servo = Some(servo);
|
|
self.webview = Some(webview);
|
|
self.rendering_context = Some(rendering_context);
|
|
}
|
|
|
|
fn user_event(&mut self, _event_loop: &ActiveEventLoop, _event: ServoWake) {
|
|
if let Some(servo) = &self.servo {
|
|
servo.spin_event_loop();
|
|
}
|
|
}
|
|
|
|
fn about_to_wait(&mut self, event_loop: &ActiveEventLoop) {
|
|
if self.shutting_down {
|
|
event_loop.exit();
|
|
return;
|
|
}
|
|
let mut compositor_closed = false;
|
|
if let Some(sc) = &mut self.shell_client {
|
|
match sc.dispatch_pending() {
|
|
Ok(false) => compositor_closed = true,
|
|
Err(e) => tracing::warn!("shell client dispatch error: {e}"),
|
|
Ok(true) => {}
|
|
}
|
|
}
|
|
if compositor_closed {
|
|
self.shut_down();
|
|
event_loop.exit();
|
|
return;
|
|
}
|
|
if let Some(servo) = &self.servo {
|
|
servo.spin_event_loop();
|
|
}
|
|
if self.signals.redraw.swap(false, Ordering::Relaxed)
|
|
&& let Some(w) = &self.window
|
|
{
|
|
w.request_redraw();
|
|
}
|
|
}
|
|
|
|
fn window_event(
|
|
&mut self,
|
|
event_loop: &ActiveEventLoop,
|
|
_window_id: WindowId,
|
|
event: WindowEvent,
|
|
) {
|
|
match event {
|
|
WindowEvent::RedrawRequested => self.render_frame(),
|
|
WindowEvent::Resized(new_size) => {
|
|
if new_size.width == 0 || new_size.height == 0 {
|
|
return;
|
|
}
|
|
if let Some(wv) = &self.webview {
|
|
wv.resize(new_size);
|
|
}
|
|
}
|
|
WindowEvent::ModifiersChanged(mods) => {
|
|
self.modifiers = mods.state();
|
|
}
|
|
WindowEvent::KeyboardInput { event, .. } => {
|
|
if let Some(wv) = &self.webview {
|
|
let ev = super::keyutils::keyboard_event_from_winit(&event, self.modifiers);
|
|
let _ = wv.notify_input_event(InputEvent::Keyboard(ev));
|
|
}
|
|
}
|
|
WindowEvent::CursorMoved { position, .. } => {
|
|
let pt = DevicePoint::new(position.x as f32, position.y as f32);
|
|
self.cursor_pos = pt;
|
|
if let Some(wv) = &self.webview {
|
|
let _ = wv
|
|
.notify_input_event(InputEvent::MouseMove(MouseMoveEvent::new(pt.into())));
|
|
}
|
|
}
|
|
WindowEvent::MouseInput { state, button, .. } => {
|
|
let btn = match button {
|
|
MouseButton::Left => ServoMouseButton::Left,
|
|
MouseButton::Right => ServoMouseButton::Right,
|
|
MouseButton::Middle => ServoMouseButton::Middle,
|
|
_ => return,
|
|
};
|
|
let action = match state {
|
|
ElementState::Pressed => MouseButtonAction::Down,
|
|
ElementState::Released => MouseButtonAction::Up,
|
|
};
|
|
if let Some(wv) = &self.webview {
|
|
let _ = wv.notify_input_event(InputEvent::MouseButton(MouseButtonEvent::new(
|
|
action,
|
|
btn,
|
|
self.cursor_pos.into(),
|
|
)));
|
|
}
|
|
}
|
|
WindowEvent::CloseRequested => {
|
|
self.shut_down();
|
|
event_loop.exit();
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn build_rendering_ctx(
|
|
event_loop: &ActiveEventLoop,
|
|
window: &Arc<Window>,
|
|
size: PhysicalSize<u32>,
|
|
) -> Option<RenderingCtx> {
|
|
if std::env::var_os("WEFT_EGL_RENDERING").is_some() {
|
|
let display_handle = event_loop.display_handle();
|
|
let window_handle = window.window_handle();
|
|
if let (Ok(dh), Ok(wh)) = (display_handle, window_handle) {
|
|
match servo::WindowRenderingContext::new(dh, wh, size) {
|
|
Ok(rc) => {
|
|
tracing::info!("using EGL rendering context");
|
|
return Some(RenderingCtx::Egl(Rc::new(rc)));
|
|
}
|
|
Err(e) => {
|
|
tracing::warn!(
|
|
"EGL rendering context failed ({e:?}), falling back to software"
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
let context = match servo::SoftwareRenderingContext::new(size) {
|
|
Ok(rc) => Rc::new(rc),
|
|
Err(e) => {
|
|
tracing::error!("SoftwareRenderingContext failed: {e:?}");
|
|
return None;
|
|
}
|
|
};
|
|
let surface = softbuffer::Context::new(Arc::clone(window))
|
|
.and_then(|display| softbuffer::Surface::new(&display, Arc::clone(window)));
|
|
match surface {
|
|
Ok(surface) => Some(RenderingCtx::Software { context, surface }),
|
|
Err(e) => {
|
|
tracing::error!("software presentation surface failed: {e}");
|
|
None
|
|
}
|
|
}
|
|
}
|
|
|
|
fn ui_kit_path() -> std::path::PathBuf {
|
|
if let Ok(p) = std::env::var("WEFT_UI_KIT_JS") {
|
|
return std::path::PathBuf::from(p);
|
|
}
|
|
std::path::PathBuf::from("/usr/share/weft/system/weft-ui-kit.js")
|
|
}
|
|
|
|
fn load_ui_kit_script() -> Option<String> {
|
|
std::fs::read_to_string(ui_kit_path()).ok()
|
|
}
|
|
|
|
#[allow(dead_code)]
|
|
fn resolve_weft_system_url(url: &ServoUrl) -> Option<ServoUrl> {
|
|
if url.scheme() != "weft-system" {
|
|
return None;
|
|
}
|
|
let host = url.host_str().unwrap_or("");
|
|
let path = url.path().trim_start_matches('/');
|
|
let system_root = std::env::var("WEFT_SYSTEM_RESOURCES")
|
|
.unwrap_or_else(|_| "/usr/share/weft/system".to_owned());
|
|
let file = std::path::Path::new(&system_root).join(host).join(path);
|
|
ServoUrl::parse(&format!("file://{}", file.display())).ok()
|
|
}
|
|
|
|
/// Shows the UI document `ui` of `app_id`, the file weft-appd resolved from
|
|
/// the package; the shell never looks for the package itself.
|
|
pub fn run(
|
|
app_id: &str,
|
|
session_id: u64,
|
|
ws_port: u16,
|
|
ui: &std::path::Path,
|
|
) -> anyhow::Result<()> {
|
|
let url = ServoUrl::from_file_path(ui)
|
|
.map_err(|_| anyhow::anyhow!("{} is not an absolute path", ui.display()))?;
|
|
tracing::info!(%app_id, %url, "showing application UI");
|
|
|
|
let event_loop = EventLoop::<ServoWake>::with_user_event()
|
|
.build()
|
|
.map_err(|e| anyhow::anyhow!("event loop: {e}"))?;
|
|
|
|
let waker = WeftEventLoopWaker {
|
|
proxy: Arc::new(Mutex::new(event_loop.create_proxy())),
|
|
};
|
|
|
|
let mut app = App::new(url, app_id.to_owned(), session_id, ws_port, waker);
|
|
event_loop
|
|
.run_app(&mut app)
|
|
.map_err(|e| anyhow::anyhow!("event loop run: {e}"))
|
|
}
|