waterui-browser-cef 0.1.0

Shared CEF runtime for WaterUI WebView and Chromium components
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

#[cfg(any(target_os = "linux", target_os = "macos", target_os = "windows"))]
use num_traits::ToPrimitive as _;

use waterui_graphics::gpu_surface::GpuFrame;

use crate::CefPageHandle;
#[cfg(any(target_os = "linux", target_os = "macos", target_os = "windows"))]
use crate::input::{CefInputGpuView, CefSurfaceInput};

#[cfg(target_os = "linux")]
mod linux;
#[cfg(target_os = "macos")]
mod macos;
#[cfg(any(target_os = "linux", target_os = "macos", target_os = "windows"))]
mod presenter;
#[cfg(target_os = "windows")]
mod windows;

/// Sizes the browser's off-screen viewport to `frame` and returns its scale.
///
/// The device-pixel ratio is the frame's own — every backend already tells the
/// surface how many physical pixels a logical unit spans, so there is nothing
/// for a host to remember to publish separately.
///
/// # Panics
///
/// Panics when the logical viewport does not fit a `u32`, or the scale a `f32`.
#[cfg(any(target_os = "linux", target_os = "macos", target_os = "windows"))]
fn sync_browser_viewport(page: &CefPageHandle, frame: &GpuFrame<'_>) -> f64 {
    let scale = frame.scale();
    let logical_width = (f64::from(frame.width) / scale).round().max(1.0);
    let logical_height = (f64::from(frame.height) / scale).round().max(1.0);
    page.set_viewport(
        logical_width
            .to_u32()
            .expect("CEF logical width exceeds u32"),
        logical_height
            .to_u32()
            .expect("CEF logical height exceeds u32"),
        scale.to_f32().expect("CEF scale exceeds f32"),
    );
    scale
}

#[cfg(target_os = "macos")]
fn request_browser_frame(page: &CefPageHandle, _frame: &mut GpuFrame<'_>) {
    page.request_frame();
}

#[cfg(not(target_os = "macos"))]
fn request_browser_frame(page: &CefPageHandle, frame: &mut GpuFrame<'_>) {
    page.request_frame();
    frame.request_redraw();
}

/// Creates the target-specific GPU-only presenter for one visible CEF page.
#[cfg(target_os = "linux")]
#[must_use]
pub fn gpu_view(page: CefPageHandle) -> impl waterui_graphics::gpu_surface::GpuView {
    linux::gpu_view(page)
}

/// Creates the target-specific GPU-only presenter for one visible CEF page.
#[cfg(target_os = "macos")]
#[must_use]
pub fn gpu_view(page: CefPageHandle) -> impl waterui_graphics::gpu_surface::GpuView {
    macos::CefGpuView::new(page)
}

/// Creates the target-specific GPU-only presenter for one visible CEF page.
#[cfg(target_os = "windows")]
#[must_use]
pub fn gpu_view(page: CefPageHandle) -> impl waterui_graphics::gpu_surface::GpuView {
    windows::CefGpuView::new(page)
}

/// Creates the presenter for one visible CEF page, wired to take its own input.
///
/// The view reports
/// [`wants_input_events`](waterui_graphics::gpu_surface::GpuView::wants_input_events),
/// so a backend that routes surface input to GPU views needs nothing
/// CEF-specific: the pointer, keyboard, scroll and composition events landing
/// on this layer reach Chromium through [`CefSurfaceInput`]. A backend whose
/// input arrives somewhere else entirely — GTK delivers it to the `GtkGLArea`'s
/// event controllers — uses [`gpu_view`] and owns a [`CefSurfaceInput`] beside
/// it instead.
#[cfg(any(target_os = "linux", target_os = "macos", target_os = "windows"))]
#[must_use]
pub fn gpu_view_with_input(page: CefPageHandle) -> impl waterui_graphics::gpu_surface::GpuView {
    CefInputGpuView::new(gpu_view(page.clone()), CefSurfaceInput::new(page))
}