use std::collections::{HashMap, VecDeque};
use std::sync::{Arc, Mutex, MutexGuard, PoisonError};
use teksilo_canvas::Point;
use teksilo_core::window::TeksiloWindowId;
use teksilo_core::{AppEventPoster, DropOutcome, ExternalDropData, OsDragId, OutboundDragData};
use wayland_client::protocol::wl_data_device::Event as DataDeviceEvent;
use wayland_client::protocol::wl_data_device_manager::DndAction;
use wayland_client::protocol::wl_data_offer::WlDataOffer;
use wayland_client::protocol::wl_data_source::{Event as DataSourceEvent, WlDataSource};
use wayland_client::protocol::wl_surface::WlSurface;
use wayland_client::{Proxy, WEnum};
use super::{HubState, SourceKind, io, offer_mimes};
use crate::external_dnd::{
ExternalDndEventPayload, ExternalDragEvent, outbound_bytes, outbound_mimes,
};
const PREFERRED_MIMES: &[&str] = &["text/uri-list", "text/plain;charset=utf-8", "text/plain"];
const DROP_LIMITS: io::Limits = io::Limits {
idle: std::time::Duration::from_secs(5),
total: std::time::Duration::from_secs(30),
max_bytes: 64 * 1024 * 1024,
};
#[derive(Clone)]
pub(crate) struct Route {
pub(crate) window_id: TeksiloWindowId,
pub(crate) poster: Arc<dyn AppEventPoster>,
pub(crate) surface: WlSurface,
outbox: Arc<Mutex<Outbox>>,
}
#[derive(Default)]
struct Outbox {
queue: VecDeque<Slot>,
next_read: u64,
}
enum Slot {
Ready(ExternalDragEvent),
Reading(u64),
}
impl Route {
pub(crate) fn new(
window_id: TeksiloWindowId,
poster: Arc<dyn AppEventPoster>,
surface: WlSurface,
) -> Self {
Self {
window_id,
poster,
surface,
outbox: Arc::default(),
}
}
fn outbox(&self) -> MutexGuard<'_, Outbox> {
self.outbox.lock().unwrap_or_else(PoisonError::into_inner)
}
fn post(&self, event: ExternalDragEvent) {
self.outbox().post(event, |event| self.post_now(event));
}
fn post_now(&self, event: ExternalDragEvent) {
self.poster.post_external(Box::new(ExternalDndEventPayload {
window_id_owner: self.window_id,
event,
}));
}
fn begin_read(&self) -> u64 {
self.outbox().begin_read()
}
fn finish_read(&self, read: u64, event: ExternalDragEvent) {
self.outbox()
.finish_read(read, event, |event| self.post_now(event));
}
}
impl Outbox {
fn post(&mut self, event: ExternalDragEvent, mut post_now: impl FnMut(ExternalDragEvent)) {
if self.queue.is_empty() {
post_now(event);
} else {
self.queue.push_back(Slot::Ready(event));
}
}
fn begin_read(&mut self) -> u64 {
let read = self.next_read;
self.next_read += 1;
self.queue.push_back(Slot::Reading(read));
read
}
fn finish_read(
&mut self,
read: u64,
event: ExternalDragEvent,
mut post_now: impl FnMut(ExternalDragEvent),
) {
if let Some(slot) = self
.queue
.iter_mut()
.find(|slot| matches!(slot, Slot::Reading(r) if *r == read))
{
*slot = Slot::Ready(event);
}
while matches!(self.queue.front(), Some(Slot::Ready(_))) {
if let Some(Slot::Ready(event)) = self.queue.pop_front() {
post_now(event);
}
}
}
}
struct Outbound {
drag: OsDragId,
owner: Route,
source: WlDataSource,
data: OutboundDragData,
action: DndAction,
dropped: bool,
coarse: bool,
answered: bool,
}
#[derive(Default)]
pub(crate) struct DndState {
routes: HashMap<u32, Route>,
active_route: Option<Route>,
offer: Option<WlDataOffer>,
offer_serial: u32,
offer_accepted_mime: Option<String>,
position: Point,
outbound: Option<Outbound>,
}
impl DndState {
pub(crate) fn add_route(&mut self, key: u32, route: Route) {
self.routes.insert(key, route);
}
pub(crate) fn remove_route(&mut self, key: u32) {
if let Some(route) = self.routes.remove(&key)
&& self
.active_route
.as_ref()
.is_some_and(|active| active.window_id == route.window_id)
{
self.active_route = None;
}
}
fn route_for_window(&self, window_id: TeksiloWindowId) -> Option<&Route> {
self.routes.values().find(|r| r.window_id == window_id)
}
fn post_routed(&self, event: ExternalDragEvent) {
if let Some(route) = &self.active_route {
route.post(event);
}
}
}
pub(crate) fn revise_accept(state: &mut HubState, accepted: bool) {
let dnd = &state.dnd;
let Some(offer) = dnd.offer.clone() else {
return;
};
if accepted {
offer.accept(dnd.offer_serial, dnd.offer_accepted_mime.clone());
if offer.version() >= 3 {
offer.set_actions(DndAction::Copy, DndAction::Copy);
}
} else {
offer.accept(dnd.offer_serial, None);
if offer.version() >= 3 {
offer.set_actions(DndAction::empty(), DndAction::empty());
}
}
}
pub(crate) fn begin_outbound(
state: &mut HubState,
window_id: TeksiloWindowId,
poster: &Arc<dyn AppEventPoster>,
data: OutboundDragData,
pointer: teksilo_tokens::PointerKind,
drag: OsDragId,
) {
let cancelled = ExternalDragEvent::DragEnded {
outcome: DropOutcome::Cancelled,
drag: Some(drag),
};
let Some(owner) = state.dnd.route_for_window(window_id).cloned() else {
poster.post_external(Box::new(ExternalDndEventPayload {
window_id_owner: window_id,
event: cancelled,
}));
return;
};
let Some(serial) = state.press_serials.take_for_drag(pointer) else {
owner.post(cancelled);
return;
};
if let Some(previous) = state.dnd.outbound.take() {
previous.source.destroy();
previous.owner.post(ExternalDragEvent::DragEnded {
outcome: DropOutcome::Cancelled,
drag: Some(previous.drag),
});
}
owner.post(ExternalDragEvent::DragStarted { drag });
let source = state
.manager
.create_data_source(&state.qh, SourceKind::Drag);
for mime in outbound_mimes(&data) {
source.offer(mime);
}
if source.version() >= 3 {
source.set_actions(DndAction::Copy);
}
state
.device
.start_drag(Some(&source), &owner.surface, None, serial);
state.dnd.outbound = Some(Outbound {
drag,
owner,
source,
data,
action: DndAction::empty(),
dropped: false,
coarse: pointer.is_coarse(),
answered: false,
});
}
pub(crate) fn release_reached_us(state: &mut HubState, coarse: bool) {
if state
.dnd
.outbound
.as_ref()
.is_some_and(|o| o.coarse == coarse && !o.answered && !o.dropped)
{
finish_outbound(state, DropOutcome::Cancelled);
}
}
pub(crate) fn cancel_outbound(state: &mut HubState) {
if state.dnd.outbound.as_ref().is_some_and(|o| !o.dropped) {
finish_outbound(state, DropOutcome::Cancelled);
}
}
fn finish_outbound(state: &mut HubState, outcome: DropOutcome) {
let Some(outbound) = state.dnd.outbound.take() else {
return;
};
outbound.source.destroy();
if state.dnd.active_route.is_some() {
state.dnd.post_routed(ExternalDragEvent::Cancelled);
state.dnd.active_route = None;
}
outbound.owner.post(ExternalDragEvent::DragEnded {
outcome,
drag: Some(outbound.drag),
});
}
fn outcome_of(action: DndAction) -> DropOutcome {
if action.contains(DndAction::Move) {
DropOutcome::OsMove
} else {
DropOutcome::OsCopy
}
}
pub(super) fn source_event(state: &mut HubState, source: &WlDataSource, event: DataSourceEvent) {
let ours = state
.dnd
.outbound
.as_ref()
.is_some_and(|o| &o.source == source);
if !ours {
if matches!(event, DataSourceEvent::Cancelled) {
source.destroy();
}
return;
}
if let Some(outbound) = &mut state.dnd.outbound {
outbound.answered = true;
}
match event {
DataSourceEvent::Send { mime_type, fd } => {
if let Some(outbound) = &state.dnd.outbound {
let bytes: Arc<[u8]> = outbound_bytes(&outbound.data, &mime_type).into();
io::serve_in_background(fd, bytes, format!("a drag as {mime_type}"));
}
}
DataSourceEvent::Action {
dnd_action: WEnum::Value(action),
} => {
if let Some(outbound) = &mut state.dnd.outbound {
outbound.action = action;
}
}
DataSourceEvent::DndDropPerformed => {
if let Some(outbound) = &mut state.dnd.outbound {
outbound.dropped = true;
}
}
DataSourceEvent::DndFinished => {
let action = state
.dnd
.outbound
.as_ref()
.map_or(DndAction::empty(), |o| o.action);
finish_outbound(state, outcome_of(action));
}
DataSourceEvent::Cancelled => {
let (dropped, action) = state
.dnd
.outbound
.as_ref()
.map_or((false, DndAction::empty()), |o| (o.dropped, o.action));
let outcome = if dropped {
outcome_of(action)
} else {
DropOutcome::Cancelled
};
finish_outbound(state, outcome);
}
_ => {}
}
}
pub(super) fn device_event(state: &mut HubState, event: DataDeviceEvent) {
match event {
DataDeviceEvent::Enter {
serial,
surface,
x,
y,
id,
} => {
if let Some(previous) = state.dnd.offer.take()
&& id.as_ref() != Some(&previous)
{
previous.destroy();
}
state.dnd.offer = id.clone();
if let Some(outbound) = &mut state.dnd.outbound {
outbound.answered = true;
}
let Some(route) = state.dnd.routes.get(&surface.id().protocol_id()).cloned() else {
state.dnd.active_route = None;
return;
};
let mimes = id.as_ref().map(offer_mimes).unwrap_or_default();
state.dnd.active_route = Some(route);
state.dnd.position = Point::new(x as f32, y as f32);
state.dnd.offer_serial = serial;
state.dnd.offer_accepted_mime = pick_mime(&mimes);
if let Some(offer) = &id {
if let Some(mime) = state.dnd.offer_accepted_mime.clone() {
offer.accept(serial, Some(mime));
}
if offer.version() >= 3 {
offer.set_actions(DndAction::Copy, DndAction::Copy);
}
}
state.dnd.post_routed(ExternalDragEvent::Entered {
data: ExternalDropData {
formats: mimes,
..Default::default()
},
position: state.dnd.position,
});
}
DataDeviceEvent::Motion { x, y, .. } => {
if state.dnd.active_route.is_none() {
return;
}
state.dnd.position = Point::new(x as f32, y as f32);
state.dnd.post_routed(ExternalDragEvent::Moved {
position: state.dnd.position,
});
}
DataDeviceEvent::Leave => {
state.dnd.post_routed(ExternalDragEvent::Left);
state.dnd.active_route = None;
if let Some(offer) = state.dnd.offer.take() {
offer.destroy();
}
state.dnd.offer_accepted_mime = None;
state.dnd.offer_serial = 0;
}
DataDeviceEvent::Drop => {
let Some(route) = state.dnd.active_route.take() else {
return;
};
let position = state.dnd.position;
state.dnd.offer_accepted_mime = None;
state.dnd.offer_serial = 0;
let offer = state.dnd.offer.take();
if state.dnd.outbound.is_some() {
route.post(ExternalDragEvent::Dropped {
data: ExternalDropData::default(),
position,
});
if let Some(offer) = offer {
finish_offer(&offer);
}
return;
}
let Some(offer) = offer else {
route.post(ExternalDragEvent::Dropped {
data: ExternalDropData::default(),
position,
});
return;
};
receive_drop(state.conn().clone(), offer, route, position);
}
_ => {}
}
}
fn finish_offer(offer: &WlDataOffer) {
if offer.version() >= 3 {
offer.finish();
}
offer.destroy();
}
fn receive_drop(
conn: wayland_client::Connection,
offer: WlDataOffer,
route: Route,
position: Point,
) {
let mimes = offer_mimes(&offer);
let Some(mime) = pick_mime(&mimes) else {
route.post(ExternalDragEvent::Dropped {
data: ExternalDropData::default(),
position,
});
finish_offer(&offer);
return;
};
let (read, write) = match io::pipe() {
Ok(pair) => pair,
Err(err) => {
eprintln!("teksilo-platform: cannot read a drop: {err}");
route.post(ExternalDragEvent::Dropped {
data: ExternalDropData::default(),
position,
});
finish_offer(&offer);
return;
}
};
offer.receive(mime.clone(), std::os::fd::AsFd::as_fd(&write));
let _ = conn.flush();
drop(write);
let pending = route.begin_read();
let reader = route.clone();
let spawned = std::thread::Builder::new()
.name("teksilo-wayland-drop".into())
.spawn(move || {
let data = match io::read_bounded(read, DROP_LIMITS) {
Ok(bytes) => decode_drop(&mime, &bytes),
Err(err) => {
eprintln!("teksilo-platform: reading a drop failed: {err}");
ExternalDropData::default()
}
};
reader.finish_read(pending, ExternalDragEvent::Dropped { data, position });
finish_offer(&offer);
let _ = conn.flush();
});
if let Err(err) = spawned {
eprintln!("teksilo-platform: cannot start a thread to read a drop: {err}");
route.finish_read(
pending,
ExternalDragEvent::Dropped {
data: ExternalDropData::default(),
position,
},
);
}
}
fn pick_mime(offered: &[String]) -> Option<String> {
PREFERRED_MIMES
.iter()
.find_map(|pref| offered.iter().find(|m| m.as_str() == *pref).cloned())
}
fn decode_drop(mime: &str, bytes: &[u8]) -> ExternalDropData {
let text = String::from_utf8_lossy(bytes).into_owned();
if mime == "text/uri-list" {
ExternalDropData::from_uri_list(&text)
} else {
ExternalDropData {
text: Some(text),
..Default::default()
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn uri_list_is_preferred_over_text() {
let offered = vec![
"text/plain".to_string(),
"text/uri-list".to_string(),
"text/plain;charset=utf-8".to_string(),
];
assert_eq!(pick_mime(&offered).as_deref(), Some("text/uri-list"));
}
#[test]
fn an_offer_of_nothing_readable_picks_nothing() {
assert_eq!(pick_mime(&["image/png".to_string()]), None);
}
fn name(event: &ExternalDragEvent) -> &'static str {
match event {
ExternalDragEvent::Entered { .. } => "entered",
ExternalDragEvent::Moved { .. } => "moved",
ExternalDragEvent::Left => "left",
ExternalDragEvent::Dropped { .. } => "dropped",
_ => "other",
}
}
fn dropped() -> ExternalDragEvent {
ExternalDragEvent::Dropped {
data: ExternalDropData::default(),
position: Point::new(0.0, 0.0),
}
}
fn entered() -> ExternalDragEvent {
ExternalDragEvent::Entered {
data: ExternalDropData::default(),
position: Point::new(0.0, 0.0),
}
}
#[test]
fn events_wait_behind_a_drop_being_read() {
let mut posted = Vec::new();
let mut outbox = Outbox::default();
outbox.post(entered(), |e| posted.push(name(&e)));
let read = outbox.begin_read();
outbox.post(entered(), |e| posted.push(name(&e)));
outbox.post(ExternalDragEvent::Left, |e| posted.push(name(&e)));
assert_eq!(posted, ["entered"]);
outbox.finish_read(read, dropped(), |e| posted.push(name(&e)));
assert_eq!(posted, ["entered", "dropped", "entered", "left"]);
outbox.post(entered(), |e| posted.push(name(&e)));
assert_eq!(posted.len(), 5);
}
#[test]
fn drops_finishing_out_of_order_are_posted_in_order() {
let mut posted = Vec::new();
let mut outbox = Outbox::default();
let first = outbox.begin_read();
outbox.post(entered(), |e| posted.push(name(&e)));
let second = outbox.begin_read();
outbox.post(ExternalDragEvent::Left, |e| posted.push(name(&e)));
outbox.finish_read(second, dropped(), |e| posted.push(name(&e)));
assert!(posted.is_empty());
outbox.finish_read(first, dropped(), |e| posted.push(name(&e)));
assert_eq!(posted, ["dropped", "entered", "dropped", "left"]);
}
#[test]
fn a_dropped_uri_list_becomes_files() {
let data = decode_drop("text/uri-list", b"file:///tmp/a.txt\r\n");
assert_eq!(data.files.len(), 1);
}
}