use crate::types::{Content, Mime};
use crate::write::Offers;
use crate::wayland::pipe;
use crate::write::{SelectionOutcome, Waiter};
use std::sync::Arc;
use wayland_client::protocol::{wl_registry, wl_seat};
use wayland_client::{event_created_child, Connection, Dispatch, Proxy, QueueHandle};
use wayland_protocols::ext::data_control::v1::client::{
ext_data_control_device_v1::{self, ExtDataControlDeviceV1},
ext_data_control_manager_v1::{self, ExtDataControlManagerV1},
ext_data_control_offer_v1::ExtDataControlOfferV1,
ext_data_control_source_v1::{self, ExtDataControlSourceV1},
};
struct State {
manager: Option<ExtDataControlManagerV1>,
seat: Option<wl_seat::WlSeat>,
offers: Offers,
done: bool,
waiter: Arc<Waiter>,
}
impl Dispatch<wl_registry::WlRegistry, ()> for State {
fn event(
state: &mut Self,
registry: &wl_registry::WlRegistry,
event: wl_registry::Event,
_: &(),
_: &Connection,
qh: &QueueHandle<Self>,
) {
if let wl_registry::Event::Global {
name,
interface,
version,
} = event
{
if interface == ExtDataControlManagerV1::interface().name {
let bound = version.min(ExtDataControlManagerV1::interface().version);
state.manager =
Some(registry.bind::<ExtDataControlManagerV1, _, _>(name, bound, qh, ()));
} else if interface == wl_seat::WlSeat::interface().name && state.seat.is_none() {
let bound = version.min(wl_seat::WlSeat::interface().version);
state.seat = Some(registry.bind::<wl_seat::WlSeat, _, _>(name, bound, qh, ()));
}
}
}
}
impl Dispatch<wl_seat::WlSeat, ()> for State {
fn event(_: &mut Self, _: &wl_seat::WlSeat, _: wl_seat::Event, _: &(), _: &Connection, _: &QueueHandle<Self>) {
}
}
impl Dispatch<ExtDataControlManagerV1, ()> for State {
fn event(
_: &mut Self,
_: &ExtDataControlManagerV1,
_: ext_data_control_manager_v1::Event,
_: &(),
_: &Connection,
_: &QueueHandle<Self>,
) {
}
}
impl Dispatch<ExtDataControlDeviceV1, ()> for State {
fn event(
state: &mut Self,
_: &ExtDataControlDeviceV1,
event: ext_data_control_device_v1::Event,
_: &(),
_: &Connection,
_: &QueueHandle<Self>,
) {
if let ext_data_control_device_v1::Event::Finished = event {
tracing::warn!("compositor closed the ext-data-control-v1 device while writing");
state.done = true;
state.waiter.signal(SelectionOutcome::Superseded);
}
}
event_created_child!(State, ExtDataControlDeviceV1, [
ext_data_control_device_v1::EVT_DATA_OFFER_OPCODE => (ExtDataControlOfferV1, ()),
]);
}
impl Dispatch<ExtDataControlSourceV1, ()> for State {
fn event(
state: &mut Self,
source: &ExtDataControlSourceV1,
event: ext_data_control_source_v1::Event,
_: &(),
_: &Connection,
_: &QueueHandle<Self>,
) {
match event {
ext_data_control_source_v1::Event::Send { mime_type, fd } => {
let bytes = state.offers.bytes_for(&Mime::new(mime_type));
pipe::send(fd, bytes);
state.waiter.signal(SelectionOutcome::Served);
}
ext_data_control_source_v1::Event::Cancelled => {
source.destroy();
state.done = true;
state.waiter.signal(SelectionOutcome::Superseded);
}
_ => {}
}
}
}
pub fn set_selection(content: Content) -> anyhow::Result<Arc<Waiter>> {
set_offers(Offers::of(&content))
}
pub fn set_offers(offers: Offers) -> anyhow::Result<Arc<Waiter>> {
let connection = Connection::connect_to_env()?;
let display = connection.display();
let mut event_queue = connection.new_event_queue::<State>();
let qh = event_queue.handle();
let waiter = Waiter::new();
let mut state = State {
manager: None,
seat: None,
offers,
done: false,
waiter: waiter.clone(),
};
let _registry = display.get_registry(&qh, ());
event_queue.roundtrip(&mut state)?;
let manager = state.manager.clone().ok_or_else(|| {
anyhow::anyhow!("compositor does not advertise ext-data-control-manager-v1")
})?;
let seat = state.seat.clone().ok_or_else(|| {
anyhow::anyhow!("compositor advertises ext-data-control-manager-v1 but no wl_seat")
})?;
let device = manager.get_data_device(&seat, &qh, ());
let source = manager.create_data_source(&qh, ());
for mime in state.offers.mimes() {
source.offer(mime.as_str().to_string());
}
device.set_selection(Some(&source));
connection.flush()?;
std::thread::Builder::new()
.name("hyprforge-clip-write-ext".to_string())
.spawn(move || {
loop {
if state.done {
break;
}
if let Err(e) = event_queue.blocking_dispatch(&mut state) {
tracing::warn!(error = %e, "ext-data-control-v1 write connection closed; the clipboard may now be empty");
state.waiter.signal(SelectionOutcome::Superseded);
break;
}
}
})?;
Ok(waiter)
}
impl Dispatch<ExtDataControlOfferV1, ()> for State {
fn event(
_: &mut Self,
_: &ExtDataControlOfferV1,
_: <ExtDataControlOfferV1 as Proxy>::Event,
_: &(),
_: &Connection,
_: &QueueHandle<Self>,
) {
}
}