jay-compositor 1.15.0

use crate::client::Client;
use crate::dmabuf_feedback::DmaBufFeedbackId;
use crate::ifs::wl_surface::WlSurface;
use crate::leaks::Tracker;
use crate::object::BreakLoops;
use crate::object::Version;
use crate::wire::ZwpLinuxDmabufFeedbackV1Id;
use crate::wire::zwp_linux_dmabuf_feedback_v1::*;
use jay_proc::Object;
use std::cell::Cell;
use std::convert::Infallible;
use std::rc::Rc;
use uapi::OwnedFd;
use uapi::c;

pub const FB_SCANOUT: u32 = 1;
pub const FB_SAMPLING: u32 = 2;

#[derive(Object)]
#[break_loops]
pub struct ZwpLinuxDmabufFeedbackV1 {
    id: ZwpLinuxDmabufFeedbackV1Id,
    client: Rc<Client>,
    pub tracker: Tracker<Self>,
    pub last_format_table: Cell<Option<DmaBufFeedbackId>>,
    surface: Option<Rc<WlSurface>>,
    pub version: Version,
}

impl ZwpLinuxDmabufFeedbackV1 {
    pub fn new(
        id: ZwpLinuxDmabufFeedbackV1Id,
        client: &Rc<Client>,
        surface: Option<&Rc<WlSurface>>,
        version: Version,
    ) -> Self {
        Self {
            id,
            client: client.clone(),
            tracker: Default::default(),
            last_format_table: Default::default(),
            surface: surface.cloned(),
            version,
        }
    }

    pub fn send_done(&self) {
        self.client.event(Done { self_id: self.id });
    }

    pub fn send_format_table(&self, fd: &Rc<OwnedFd>, size: u32) {
        self.client.event(FormatTable {
            self_id: self.id,
            fd: fd.clone(),
            size,
        });
    }

    pub fn send_main_device(&self, dev: c::dev_t) {
        self.client.event(MainDevice {
            self_id: self.id,
            device: dev,
        });
    }

    pub fn send_tranche_done(&self) {
        self.client.event(TrancheDone { self_id: self.id });
    }

    pub fn send_tranche_target_device(&self, dev: c::dev_t) {
        self.client.event(TrancheTargetDevice {
            self_id: self.id,
            device: dev,
        });
    }

    pub fn send_tranche_formats(&self, indices: &[u16]) {
        self.client.event(TrancheFormats {
            self_id: self.id,
            indices,
        });
    }

    pub fn send_tranche_flags(&self, flags: u32) {
        self.client.event(TrancheFlags {
            self_id: self.id,
            flags,
        });
    }
}

impl ZwpLinuxDmabufFeedbackV1RequestHandler for ZwpLinuxDmabufFeedbackV1 {
    type Error = Infallible;

    fn destroy(&self, _req: Destroy, _slf: &Rc<Self>) -> Result<(), Self::Error> {
        self.detach();
        self.client.remove_obj(self);
        Ok(())
    }
}

impl ZwpLinuxDmabufFeedbackV1 {
    fn detach(&self) {
        if let Some(surface) = &self.surface {
            surface.dmabuf_feedback.remove(&self.id);
        } else {
            self.client
                .state
                .dmabuf_feedback
                .default
                .remove(&(self.client.id, self.id));
        }
    }
}

impl BreakLoops for ZwpLinuxDmabufFeedbackV1 {
    fn break_loops(self: Rc<Self>) {
        self.detach();
    }
}