mirror of
https://github.com/hanzoai/dev.git
synced 2026-11-21 14:22:49 +00:00
776 lines
25 KiB
Rust
776 lines
25 KiB
Rust
use crate::{
|
|
Result, emit,
|
|
ipc::{self, Rect},
|
|
};
|
|
use serde::Deserialize;
|
|
use smithay_client_toolkit::{
|
|
compositor::{CompositorHandler, CompositorState},
|
|
delegate_compositor, delegate_layer, delegate_output, delegate_registry, delegate_shm,
|
|
output::{OutputHandler, OutputState},
|
|
registry::{ProvidesRegistryState, RegistryState},
|
|
shell::{
|
|
WaylandSurface,
|
|
wlr_layer::{
|
|
Anchor, KeyboardInteractivity, Layer, LayerShell, LayerShellHandler, LayerSurface,
|
|
LayerSurfaceConfigure,
|
|
},
|
|
},
|
|
shm::{
|
|
Shm, ShmHandler,
|
|
slot::{Buffer, SlotPool},
|
|
},
|
|
};
|
|
use std::{
|
|
fs::File,
|
|
io::{BufReader, Read},
|
|
os::unix::net::UnixStream,
|
|
path::Path,
|
|
time::{Duration, Instant},
|
|
};
|
|
use wayland_client::{
|
|
Connection, Dispatch, QueueHandle, delegate_noop,
|
|
globals::registry_queue_init,
|
|
protocol::{
|
|
wl_output::{self, WlOutput},
|
|
wl_shm,
|
|
wl_subcompositor::WlSubcompositor,
|
|
wl_subsurface::WlSubsurface,
|
|
wl_surface::WlSurface,
|
|
},
|
|
};
|
|
use wayland_protocols::wp::presentation_time::client::{
|
|
wp_presentation::WpPresentation,
|
|
wp_presentation_feedback::{self, WpPresentationFeedback},
|
|
};
|
|
use wayland_protocols::wp::viewporter::client::{
|
|
wp_viewport::WpViewport, wp_viewporter::WpViewporter,
|
|
};
|
|
|
|
enum Receipt {
|
|
Initial(usize),
|
|
Landed,
|
|
}
|
|
|
|
#[derive(Clone, Copy, PartialEq)]
|
|
enum Texture {
|
|
None,
|
|
Flash,
|
|
Image,
|
|
}
|
|
|
|
#[derive(Deserialize)]
|
|
pub struct Options {
|
|
bounds: Rect,
|
|
pid: u32,
|
|
flash: bool,
|
|
animate: bool,
|
|
}
|
|
#[derive(Deserialize)]
|
|
#[serde(tag = "command", rename_all = "lowercase")]
|
|
enum Command {
|
|
Close,
|
|
Animate { title: String, frame: Rect },
|
|
}
|
|
struct Overlay {
|
|
layer: LayerSurface,
|
|
image: WlSurface,
|
|
subsurface: WlSubsurface,
|
|
viewport: WpViewport,
|
|
_background: WpViewport,
|
|
bounds: Rect,
|
|
configured: bool,
|
|
presented: bool,
|
|
frame_pending: bool,
|
|
receipt_pending: bool,
|
|
texture: Texture,
|
|
background_attached: bool,
|
|
}
|
|
struct Feedback {
|
|
registry: RegistryState,
|
|
output: OutputState,
|
|
shm: Shm,
|
|
presentation: WpPresentation,
|
|
_pool: SlotPool,
|
|
overlays: Vec<Overlay>,
|
|
background: Buffer,
|
|
image: Buffer,
|
|
flash: Buffer,
|
|
image_size: (u32, u32),
|
|
options: Options,
|
|
start: Instant,
|
|
flight: Option<(Rect, Instant)>,
|
|
destination: Option<ipc::Window>,
|
|
ready: bool,
|
|
landed: bool,
|
|
landing_receipts: usize,
|
|
done: bool,
|
|
}
|
|
|
|
fn clip(rect: Rect, output: Rect, image: (u32, u32)) -> Option<(Rect, Rect)> {
|
|
if !rect.valid() || !output.valid() || !rect.intersects(output) {
|
|
return None;
|
|
}
|
|
let x = rect.x.max(output.x);
|
|
let y = rect.y.max(output.y);
|
|
let right = (rect.x + rect.width).min(output.x + output.width);
|
|
let bottom = (rect.y + rect.height).min(output.y + output.height);
|
|
if right - x < 1. || bottom - y < 1. {
|
|
return None;
|
|
}
|
|
// Wayland source rectangles use 24.8 fixed point. Quantize edges together so rounding
|
|
// can never put the right/bottom edge outside the image at fractional output scales.
|
|
let left_px = ((x - rect.x) / rect.width * f64::from(image.0) * 256.).floor() / 256.;
|
|
let top_px = ((y - rect.y) / rect.height * f64::from(image.1) * 256.).floor() / 256.;
|
|
let right_px = ((right - rect.x) / rect.width * f64::from(image.0) * 256.).floor() / 256.;
|
|
let bottom_px = ((bottom - rect.y) / rect.height * f64::from(image.1) * 256.).floor() / 256.;
|
|
if right_px <= left_px || bottom_px <= top_px {
|
|
return None;
|
|
}
|
|
Some((
|
|
Rect {
|
|
x: x - output.x,
|
|
y: y - output.y,
|
|
width: right - x,
|
|
height: bottom - y,
|
|
},
|
|
Rect {
|
|
x: left_px,
|
|
y: top_px,
|
|
width: right_px - left_px,
|
|
height: bottom_px - top_px,
|
|
},
|
|
))
|
|
}
|
|
fn interpolate(from: Rect, to: Rect, progress: f64) -> Rect {
|
|
let t = 1.0 - (1.0 - progress.clamp(0., 1.)).powi(3);
|
|
Rect {
|
|
x: from.x + (to.x - from.x) * t,
|
|
y: from.y + (to.y - from.y) * t,
|
|
width: from.width + (to.width - from.width) * t,
|
|
height: from.height + (to.height - from.height) * t,
|
|
}
|
|
}
|
|
fn target(bounds: Rect, frame: Rect) -> Result<Rect> {
|
|
if !bounds.valid()
|
|
|| !frame.valid()
|
|
|| frame.x < 0.
|
|
|| frame.y < 0.
|
|
|| frame.x + frame.width > 1.01
|
|
|| frame.y + frame.height > 1.01
|
|
{
|
|
return Err("Invalid capture animation destination.".into());
|
|
}
|
|
Ok(Rect {
|
|
x: bounds.x + frame.x * bounds.width,
|
|
y: bounds.y + frame.y * bounds.height,
|
|
width: frame.width * bounds.width,
|
|
height: frame.height * bounds.height,
|
|
})
|
|
}
|
|
|
|
pub fn run(directory: &Path, mut options: Options) -> Result<()> {
|
|
if !options.bounds.valid() {
|
|
return Err("Invalid capture bounds.".into());
|
|
}
|
|
ipc::ensure_unlocked()?;
|
|
options.animate &= ipc::animations_enabled();
|
|
let mut events = UnixStream::connect(ipc::session_directory()?.join(".socket2.sock"))?;
|
|
events.set_nonblocking(true)?;
|
|
let mut decoder = png::Decoder::new(BufReader::new(File::open(directory.join("capture.png"))?));
|
|
decoder.set_limits(png::Limits {
|
|
bytes: 128 * 1024 * 1024,
|
|
});
|
|
let mut reader = decoder.read_info()?;
|
|
let mut bytes = vec![
|
|
0;
|
|
reader
|
|
.output_buffer_size()
|
|
.ok_or("Invalid capture image size.")?
|
|
];
|
|
let info = reader.next_frame(&mut bytes)?;
|
|
if info.color_type != png::ColorType::Rgba || info.bit_depth != png::BitDepth::Eight {
|
|
return Err("Expected RGBA capture image.".into());
|
|
}
|
|
let (connection, mut queue, mut state, compositor, layer_shell, subcompositor, viewporter) = {
|
|
let connection = Connection::connect_to_env()?;
|
|
let (globals, queue) = registry_queue_init::<Feedback>(&connection)?;
|
|
let qh = queue.handle();
|
|
let compositor = CompositorState::bind(&globals, &qh)?;
|
|
let layer_shell = LayerShell::bind(&globals, &qh)?;
|
|
let subcompositor: WlSubcompositor = globals.bind(&qh, 1..=1, ())?;
|
|
let viewporter: WpViewporter = globals.bind(&qh, 1..=1, ())?;
|
|
let presentation: WpPresentation = globals.bind(&qh, 1..=1, ())?;
|
|
let shm = Shm::bind(&globals, &qh)?;
|
|
let mut pool = SlotPool::new(bytes.len() * 2 + 4, &shm)?;
|
|
let (background, canvas) = pool.create_buffer(1, 1, 4, wl_shm::Format::Argb8888)?;
|
|
canvas.fill(0);
|
|
let (image, canvas) = pool.create_buffer(
|
|
info.width as i32,
|
|
info.height as i32,
|
|
info.width as i32 * 4,
|
|
wl_shm::Format::Argb8888,
|
|
)?;
|
|
// Wayland's ARGB8888 is native-endian and premultiplied; PNG is straight RGBA.
|
|
for (src, dst) in bytes.chunks_exact(4).zip(canvas.chunks_exact_mut(4)) {
|
|
let a = u32::from(src[3]);
|
|
dst.copy_from_slice(&[
|
|
(u32::from(src[2]) * a / 255) as u8,
|
|
(u32::from(src[1]) * a / 255) as u8,
|
|
(u32::from(src[0]) * a / 255) as u8,
|
|
src[3],
|
|
]);
|
|
}
|
|
let (flash, canvas) = pool.create_buffer(
|
|
info.width as i32,
|
|
info.height as i32,
|
|
info.width as i32 * 4,
|
|
wl_shm::Format::Argb8888,
|
|
)?;
|
|
for (src, dst) in bytes.chunks_exact(4).zip(canvas.chunks_exact_mut(4)) {
|
|
let a = u32::from(src[3]);
|
|
for (i, channel) in [2, 1, 0].into_iter().enumerate() {
|
|
dst[i] = ((u32::from(src[channel]) * 3 + 255) / 4 * a / 255) as u8;
|
|
}
|
|
dst[3] = src[3];
|
|
}
|
|
let state = Feedback {
|
|
registry: RegistryState::new(&globals),
|
|
output: OutputState::new(&globals, &qh),
|
|
shm,
|
|
presentation,
|
|
_pool: pool,
|
|
overlays: Vec::new(),
|
|
background,
|
|
image,
|
|
flash,
|
|
image_size: (info.width, info.height),
|
|
options,
|
|
start: Instant::now(),
|
|
flight: None,
|
|
destination: None,
|
|
ready: false,
|
|
landed: false,
|
|
landing_receipts: 0,
|
|
done: false,
|
|
};
|
|
(
|
|
connection,
|
|
queue,
|
|
state,
|
|
compositor,
|
|
layer_shell,
|
|
subcompositor,
|
|
viewporter,
|
|
)
|
|
};
|
|
let qh = queue.handle();
|
|
queue.roundtrip(&mut state)?;
|
|
queue.roundtrip(&mut state)?;
|
|
let region = compositor.wl_compositor().create_region(&qh, ());
|
|
for output in state.output.outputs() {
|
|
let data = state
|
|
.output
|
|
.info(&output)
|
|
.ok_or("Missing output information.")?;
|
|
let (x, y) = data.logical_position.ok_or("Missing output position.")?;
|
|
let (width, height) = data.logical_size.ok_or("Missing output size.")?;
|
|
if width <= 0 || height <= 0 {
|
|
continue;
|
|
}
|
|
let surface = compositor.create_surface(&qh);
|
|
surface.set_input_region(Some(®ion));
|
|
let background = viewporter.get_viewport(&surface, &qh, ());
|
|
background.set_destination(width, height);
|
|
let image = compositor.create_surface(&qh);
|
|
image.set_input_region(Some(®ion));
|
|
let viewport = viewporter.get_viewport(&image, &qh, ());
|
|
let subsurface = subcompositor.get_subsurface(&image, &surface, &qh, ());
|
|
let layer = layer_shell.create_layer_surface(
|
|
&qh,
|
|
surface,
|
|
Layer::Overlay,
|
|
Some("hanzo-snap-shot"),
|
|
Some(&output),
|
|
);
|
|
layer.set_anchor(Anchor::TOP | Anchor::BOTTOM | Anchor::LEFT | Anchor::RIGHT);
|
|
layer.set_keyboard_interactivity(KeyboardInteractivity::None);
|
|
layer.set_exclusive_zone(-1);
|
|
layer.set_size(width as u32, height as u32);
|
|
layer.commit();
|
|
state.overlays.push(Overlay {
|
|
layer,
|
|
image,
|
|
subsurface,
|
|
viewport,
|
|
_background: background,
|
|
bounds: Rect {
|
|
x: x.into(),
|
|
y: y.into(),
|
|
width: width.into(),
|
|
height: height.into(),
|
|
},
|
|
configured: false,
|
|
presented: !state.options.bounds.intersects(Rect {
|
|
x: x.into(),
|
|
y: y.into(),
|
|
width: width.into(),
|
|
height: height.into(),
|
|
}),
|
|
frame_pending: false,
|
|
receipt_pending: false,
|
|
texture: Texture::None,
|
|
background_attached: false,
|
|
});
|
|
}
|
|
region.destroy();
|
|
if state.overlays.is_empty() {
|
|
return Err("No output is available for capture effects.".into());
|
|
}
|
|
let stdin = std::io::stdin();
|
|
if state.overlays.iter().all(|o| o.presented) {
|
|
return Err("The captured window is outside the visible outputs.".into());
|
|
}
|
|
let deadline = Instant::now() + Duration::from_secs(8);
|
|
let mut commands = Vec::new();
|
|
while !state.done {
|
|
queue.dispatch_pending(&mut state)?;
|
|
if state.done {
|
|
break;
|
|
}
|
|
connection.flush()?;
|
|
let Some(read) = queue.prepare_read() else {
|
|
continue;
|
|
};
|
|
let timeout = rustix::event::Timespec::try_from(
|
|
deadline
|
|
.checked_duration_since(Instant::now())
|
|
.ok_or("Capture feedback expired.")?,
|
|
)?;
|
|
let mut fds = [
|
|
rustix::event::PollFd::new(&connection, rustix::event::PollFlags::IN),
|
|
rustix::event::PollFd::new(&stdin, rustix::event::PollFlags::IN),
|
|
rustix::event::PollFd::new(&events, rustix::event::PollFlags::IN),
|
|
];
|
|
if rustix::event::poll(&mut fds, Some(&timeout))? == 0 {
|
|
break;
|
|
}
|
|
if fds[0].revents().intersects(
|
|
rustix::event::PollFlags::IN
|
|
| rustix::event::PollFlags::HUP
|
|
| rustix::event::PollFlags::ERR,
|
|
) {
|
|
read.read()?;
|
|
} else {
|
|
drop(read);
|
|
}
|
|
let input_ready = fds[1]
|
|
.revents()
|
|
.intersects(rustix::event::PollFlags::IN | rustix::event::PollFlags::HUP);
|
|
let events_ready = !fds[2].revents().is_empty();
|
|
drop(fds);
|
|
if events_ready {
|
|
let mut bytes = [0; 8192];
|
|
match events.read(&mut bytes) {
|
|
Ok(0) => break,
|
|
Ok(_) => {
|
|
ipc::ensure_unlocked()?;
|
|
if let Some(destination) = &state.destination {
|
|
let current = ipc::destination(
|
|
ipc::windows()?,
|
|
state.options.pid,
|
|
&destination.title,
|
|
)?;
|
|
if current.as_ref() != Some(destination) {
|
|
break;
|
|
}
|
|
if ipc::active_window()?.address != destination.address {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
Err(error) if error.kind() == std::io::ErrorKind::WouldBlock => {}
|
|
Err(error) => return Err(error.into()),
|
|
}
|
|
}
|
|
if input_ready {
|
|
let mut buf = [0; 2048];
|
|
let count = stdin.lock().read(&mut buf)?;
|
|
if count == 0 {
|
|
break;
|
|
}
|
|
commands.extend_from_slice(&buf[..count]);
|
|
if commands.len() > 4096 {
|
|
return Err("Oversized feedback command.".into());
|
|
}
|
|
while let Some(end) = commands.iter().position(|byte| *byte == b'\n') {
|
|
let line = commands.drain(..=end).collect::<Vec<_>>();
|
|
match serde_json::from_slice::<Command>(&line)? {
|
|
Command::Close => state.done = true,
|
|
Command::Animate { title, frame }
|
|
if state.options.animate && state.flight.is_none() =>
|
|
{
|
|
ipc::ensure_unlocked()?;
|
|
let window = ipc::destination(ipc::windows()?, state.options.pid, &title)?
|
|
.ok_or("Capture destination is not visible.")?;
|
|
let dest = target(window.bounds(), frame)?;
|
|
state.flight = Some((dest, Instant::now()));
|
|
state.destination = Some(window);
|
|
state.draw(&qh)?;
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// Dropping the connection destroys every overlay, including cancellation/error paths.
|
|
emit(serde_json::json!({"event":"done"}))
|
|
}
|
|
|
|
impl Feedback {
|
|
fn draw(&mut self, qh: &QueueHandle<Self>) -> Result<()> {
|
|
let progress = self
|
|
.flight
|
|
.map(|(_, start)| start.elapsed().as_secs_f64() / 0.48);
|
|
let rect = self
|
|
.flight
|
|
.map(|(to, _)| interpolate(self.options.bounds, to, progress.unwrap_or(0.)))
|
|
.unwrap_or(self.options.bounds);
|
|
let flashing = self.options.flash
|
|
&& self.start.elapsed() < Duration::from_millis(130)
|
|
&& self.flight.is_none();
|
|
let visible = self.options.animate || flashing;
|
|
let driver = self
|
|
.overlays
|
|
.iter()
|
|
.position(|o| o.bounds.intersects(rect))
|
|
.unwrap_or(0);
|
|
let landing = progress.is_some_and(|p| p >= 1.) && !self.landed;
|
|
for (index, overlay) in self.overlays.iter_mut().enumerate() {
|
|
if !overlay.configured {
|
|
continue;
|
|
}
|
|
let surface = overlay.layer.wl_surface();
|
|
if let Some((dest, src)) =
|
|
clip(rect, overlay.bounds, self.image_size).filter(|_| visible)
|
|
{
|
|
overlay
|
|
.viewport
|
|
.set_source(src.x, src.y, src.width, src.height);
|
|
overlay.viewport.set_destination(
|
|
dest.width.round().max(1.) as i32,
|
|
dest.height.round().max(1.) as i32,
|
|
);
|
|
overlay
|
|
.subsurface
|
|
.set_position(dest.x.round() as i32, dest.y.round() as i32);
|
|
// Hyprland 0.56.2 retains the old surface size on viewport-only commits.
|
|
// Reattach the immutable buffer so the destination size is applied too.
|
|
let texture = if flashing {
|
|
Texture::Flash
|
|
} else {
|
|
Texture::Image
|
|
};
|
|
overlay.image.attach(
|
|
Some((if flashing { &self.flash } else { &self.image }).wl_buffer()),
|
|
0,
|
|
0,
|
|
);
|
|
if overlay.texture != texture {
|
|
overlay.image.damage_buffer(0, 0, i32::MAX, i32::MAX);
|
|
}
|
|
overlay.texture = texture;
|
|
} else {
|
|
if overlay.texture != Texture::None {
|
|
overlay.image.attach(None, 0, 0);
|
|
overlay.texture = Texture::None;
|
|
}
|
|
}
|
|
overlay.image.commit();
|
|
if !overlay.background_attached {
|
|
surface.attach(Some(self.background.wl_buffer()), 0, 0);
|
|
overlay.background_attached = true;
|
|
}
|
|
if !overlay.presented && !overlay.receipt_pending {
|
|
self.presentation
|
|
.feedback(surface, qh, Receipt::Initial(index));
|
|
overlay.receipt_pending = true;
|
|
}
|
|
if landing && overlay.bounds.intersects(rect) {
|
|
self.presentation.feedback(surface, qh, Receipt::Landed);
|
|
self.landing_receipts += 1;
|
|
}
|
|
if !overlay.frame_pending
|
|
&& self.ready
|
|
&& index == driver
|
|
&& (flashing || progress.is_some_and(|p| p < 1.))
|
|
{
|
|
surface.frame(qh, surface.clone());
|
|
overlay.frame_pending = true;
|
|
}
|
|
surface.commit();
|
|
}
|
|
if landing {
|
|
// Presentation feedback, not a frame callback, acknowledges the final painted image.
|
|
self.landed = true;
|
|
if self.landing_receipts == 0 {
|
|
self.done = true;
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
}
|
|
impl CompositorHandler for Feedback {
|
|
fn scale_factor_changed(
|
|
&mut self,
|
|
_: &Connection,
|
|
_: &QueueHandle<Self>,
|
|
_: &WlSurface,
|
|
_: i32,
|
|
) {
|
|
}
|
|
fn transform_changed(
|
|
&mut self,
|
|
_: &Connection,
|
|
_: &QueueHandle<Self>,
|
|
_: &WlSurface,
|
|
_: wl_output::Transform,
|
|
) {
|
|
}
|
|
fn surface_enter(
|
|
&mut self,
|
|
_: &Connection,
|
|
_: &QueueHandle<Self>,
|
|
_: &WlSurface,
|
|
_: &WlOutput,
|
|
) {
|
|
}
|
|
fn surface_leave(
|
|
&mut self,
|
|
_: &Connection,
|
|
_: &QueueHandle<Self>,
|
|
_: &WlSurface,
|
|
_: &WlOutput,
|
|
) {
|
|
}
|
|
fn frame(&mut self, _: &Connection, qh: &QueueHandle<Self>, surface: &WlSurface, _: u32) {
|
|
if self.landed {
|
|
return;
|
|
}
|
|
if let Some(overlay) = self
|
|
.overlays
|
|
.iter_mut()
|
|
.find(|o| o.layer.wl_surface() == surface)
|
|
{
|
|
overlay.frame_pending = false;
|
|
}
|
|
if self.ready && self.draw(qh).is_err() {
|
|
self.done = true;
|
|
}
|
|
}
|
|
}
|
|
impl LayerShellHandler for Feedback {
|
|
fn closed(&mut self, _: &Connection, _: &QueueHandle<Self>, _: &LayerSurface) {
|
|
self.done = true;
|
|
}
|
|
fn configure(
|
|
&mut self,
|
|
_: &Connection,
|
|
qh: &QueueHandle<Self>,
|
|
layer: &LayerSurface,
|
|
config: LayerSurfaceConfigure,
|
|
_: u32,
|
|
) {
|
|
if let Some(overlay) = self.overlays.iter_mut().find(|o| o.layer == *layer) {
|
|
if overlay.configured
|
|
|| (config.new_size.0 != 0
|
|
&& config.new_size
|
|
!= (overlay.bounds.width as u32, overlay.bounds.height as u32))
|
|
{
|
|
self.done = true;
|
|
return;
|
|
}
|
|
overlay.configured = true;
|
|
}
|
|
if self.overlays.iter().all(|o| o.configured) && self.draw(qh).is_err() {
|
|
self.done = true;
|
|
}
|
|
}
|
|
}
|
|
impl OutputHandler for Feedback {
|
|
fn output_state(&mut self) -> &mut OutputState {
|
|
&mut self.output
|
|
}
|
|
fn new_output(&mut self, _: &Connection, _: &QueueHandle<Self>, _: WlOutput) {
|
|
if !self.overlays.is_empty() {
|
|
self.done = true;
|
|
}
|
|
}
|
|
fn update_output(&mut self, _: &Connection, _: &QueueHandle<Self>, _: WlOutput) {
|
|
if self.ready {
|
|
self.done = true;
|
|
}
|
|
}
|
|
fn output_destroyed(&mut self, _: &Connection, _: &QueueHandle<Self>, _: WlOutput) {
|
|
self.done = true;
|
|
}
|
|
}
|
|
impl ShmHandler for Feedback {
|
|
fn shm_state(&mut self) -> &mut Shm {
|
|
&mut self.shm
|
|
}
|
|
}
|
|
impl ProvidesRegistryState for Feedback {
|
|
fn registry(&mut self) -> &mut RegistryState {
|
|
&mut self.registry
|
|
}
|
|
smithay_client_toolkit::registry_handlers!(OutputState);
|
|
}
|
|
delegate_registry!(Feedback);
|
|
delegate_output!(Feedback);
|
|
delegate_shm!(Feedback);
|
|
delegate_layer!(Feedback);
|
|
delegate_compositor!(Feedback);
|
|
delegate_noop!(Feedback: ignore WlSubcompositor);
|
|
delegate_noop!(Feedback: ignore WlSubsurface);
|
|
delegate_noop!(Feedback: ignore WpViewporter);
|
|
delegate_noop!(Feedback: ignore WpViewport);
|
|
delegate_noop!(Feedback: ignore WpPresentation);
|
|
impl Dispatch<WpPresentationFeedback, Receipt> for Feedback {
|
|
fn event(
|
|
state: &mut Self,
|
|
_: &WpPresentationFeedback,
|
|
event: wp_presentation_feedback::Event,
|
|
receipt: &Receipt,
|
|
_: &Connection,
|
|
qh: &QueueHandle<Self>,
|
|
) {
|
|
match event {
|
|
wp_presentation_feedback::Event::Presented { .. } => {
|
|
match receipt {
|
|
Receipt::Initial(index) => {
|
|
state.overlays[*index].presented = true;
|
|
if !state.ready && state.overlays.iter().all(|o| o.presented) {
|
|
state.ready = true;
|
|
if emit(serde_json::json!({"event":"ready","animate":state.options.animate})).is_err() || state.draw(qh).is_err() {state.done=true;}
|
|
}
|
|
}
|
|
Receipt::Landed => {
|
|
state.landing_receipts = state.landing_receipts.saturating_sub(1);
|
|
if state.landing_receipts == 0
|
|
&& emit(serde_json::json!({"event":"landed"})).is_err()
|
|
{
|
|
state.done = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
wp_presentation_feedback::Event::Discarded => state.done = true,
|
|
_ => {}
|
|
}
|
|
}
|
|
}
|
|
delegate_noop!(Feedback: ignore wayland_client::protocol::wl_region::WlRegion);
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
#[test]
|
|
fn clips_across_negative_origin_and_scaled_outputs() {
|
|
let rect = Rect {
|
|
x: -100.,
|
|
y: 0.,
|
|
width: 200.,
|
|
height: 100.,
|
|
};
|
|
let (dest, src) = clip(
|
|
rect,
|
|
Rect {
|
|
x: 0.,
|
|
y: 0.,
|
|
width: 1920.,
|
|
height: 1080.,
|
|
},
|
|
(400, 200),
|
|
)
|
|
.unwrap();
|
|
assert_eq!(
|
|
dest,
|
|
Rect {
|
|
x: 0.,
|
|
y: 0.,
|
|
width: 100.,
|
|
height: 100.
|
|
}
|
|
);
|
|
assert_eq!(
|
|
src,
|
|
Rect {
|
|
x: 200.,
|
|
y: 0.,
|
|
width: 200.,
|
|
height: 200.
|
|
}
|
|
);
|
|
assert!(
|
|
clip(
|
|
rect,
|
|
Rect {
|
|
x: 200.,
|
|
y: 0.,
|
|
width: 100.,
|
|
height: 100.
|
|
},
|
|
(400, 200)
|
|
)
|
|
.is_none()
|
|
);
|
|
}
|
|
#[test]
|
|
fn flight_ends_at_exact_composer_bounds() {
|
|
let a = Rect {
|
|
x: -300.,
|
|
y: 0.,
|
|
width: 600.,
|
|
height: 500.,
|
|
};
|
|
let b = Rect {
|
|
x: 100.,
|
|
y: 400.,
|
|
width: 100.,
|
|
height: 80.,
|
|
};
|
|
assert_eq!(interpolate(a, b, 0.), a);
|
|
assert_eq!(interpolate(a, b, 1.), b);
|
|
assert_eq!(
|
|
target(
|
|
a,
|
|
Rect {
|
|
x: 0.5,
|
|
y: 0.4,
|
|
width: 0.2,
|
|
height: 0.1
|
|
}
|
|
)
|
|
.unwrap(),
|
|
Rect {
|
|
x: 0.,
|
|
y: 200.,
|
|
width: 120.,
|
|
height: 50.
|
|
}
|
|
);
|
|
assert!(
|
|
target(
|
|
a,
|
|
Rect {
|
|
x: 590.,
|
|
y: 0.,
|
|
width: 30.,
|
|
height: 30.
|
|
}
|
|
)
|
|
.is_err()
|
|
);
|
|
}
|
|
}
|