autocommit 2022-02-09 17:26:50 CET

src/ifs/ipc/wl_data_offer.rs

@@ -1,13 +1,15 @@
 use crate::client::{Client, ClientError};
+use crate::ifs::ipc::wl_data_device::WlDataDevice;
+use crate::ifs::ipc::{break_offer_loops, destroy_offer, receive, OfferData, Role, OFFER_STATE_FINISHED, OFFER_STATE_DROPPED, OFFER_STATE_ACCEPTED, SOURCE_STATE_FINISHED};
 use crate::object::Object;
 use crate::utils::buffd::MsgParser;
 use crate::utils::buffd::MsgParserError;
 use crate::wire::wl_data_offer::*;
-use crate::wire::{WlDataOfferId};
+use crate::wire::WlDataOfferId;
 use std::rc::Rc;
 use thiserror::Error;
-use crate::ifs::ipc::{disconnect_offer, OfferData, receive};
-use crate::ifs::ipc::wl_data_device::WlDataDevice;
+use crate::ifs::ipc::wl_data_device_manager::{DND_ALL};
+use crate::utils::bitflags::BitflagsExt;
 
 #[allow(dead_code)]
 const INVALID_FINISH: u32 = 0;
@@ -18,11 +20,11 @@ const INVALID_ACTION: u32 = 2;
 #[allow(dead_code)]
 const INVALID_OFFER: u32 = 3;
 
-
 pub struct WlDataOffer {
     pub id: WlDataOfferId,
     pub client: Rc<Client>,
-    pub offer_data: OfferData<WlDataDevice>,
+    pub device: Rc<WlDataDevice>,
+    pub data: OfferData<WlDataDevice>,
 }
 
 impl WlDataOffer {
@@ -33,31 +35,101 @@ impl WlDataOffer {
         })
     }
 
+    pub fn send_source_actions(&self) {
+        if let Some(src) = self.data.source.get() {
+            if let Some(source_actions) = src.data.actions.get() {
+                self.client.event(SourceActions {
+                    self_id: self.id,
+                    source_actions,
+                })
+            }
+        }
+    }
+
+    pub fn send_action(&self, dnd_action: u32) {
+        self.client.event(Action {
+            self_id: self.id,
+            dnd_action,
+        })
+    }
+
     fn accept(&self, parser: MsgParser<'_, '_>) -> Result<(), AcceptError> {
-        let _req: Accept = self.client.parse(self, parser)?;
+        let req: Accept = self.client.parse(self, parser)?;
+        let mut state = self.data.shared.state.get();
+        if state.contains(OFFER_STATE_FINISHED) {
+            return Err(AcceptError::AlreadyFinished);
+        }
+        if req.mime_type.is_some() {
+            state |= OFFER_STATE_ACCEPTED;
+        } else {
+            state &= !OFFER_STATE_ACCEPTED;
+        }
+        self.data.shared.state.set(state);
+        if let Some(src) = self.data.source.get() {
+            src.send_target(req.mime_type);
+        }
         Ok(())
     }
 
     fn receive(&self, parser: MsgParser<'_, '_>) -> Result<(), ReceiveError> {
         let req: Receive = self.client.parse(self, parser)?;
+        if self.data.shared.state.get().contains(OFFER_STATE_FINISHED) {
+            return Err(ReceiveError::AlreadyFinished);
+        }
         receive::<WlDataDevice>(self, req.mime_type, req.fd);
         Ok(())
     }
 
     fn destroy(&self, parser: MsgParser<'_, '_>) -> Result<(), DestroyError> {
         let _req: Destroy = self.client.parse(self, parser)?;
-        disconnect_offer::<WlDataDevice>(self);
+        destroy_offer::<WlDataDevice>(self);
         self.client.remove_obj(self)?;
         Ok(())
     }
 
     fn finish(&self, parser: MsgParser<'_, '_>) -> Result<(), FinishError> {
         let _req: Finish = self.client.parse(self, parser)?;
+        if self.data.shared.role.get() != Role::Dnd {
+            return Err(FinishError::NotDnd);
+        }
+        let mut state = self.data.shared.state.get();
+        if state.contains(OFFER_STATE_FINISHED) {
+            return Err(FinishError::AlreadyFinished);
+        }
+        if !state.contains(OFFER_STATE_DROPPED) {
+            return Err(FinishError::StillDragging);
+        }
+        if !state.contains(OFFER_STATE_ACCEPTED) {
+            return Err(FinishError::NoMimeTypeAccepted);
+        }
+        state |= OFFER_STATE_FINISHED;
+        if let Some(src) = self.data.source.get() {
+            src.data.state.or_assign(SOURCE_STATE_FINISHED);
+            src.send_dnd_finished();
+        } else {
+            log::error!("no source");
+        }
+        self.data.shared.state.set(state);
         Ok(())
     }
 
     fn set_actions(&self, parser: MsgParser<'_, '_>) -> Result<(), SetActionsError> {
-        let _req: SetActions = self.client.parse(self, parser)?;
+        let req: SetActions = self.client.parse(self, parser)?;
+        let state = self.data.shared.state.get();
+        if state.contains(OFFER_STATE_FINISHED) {
+            return Err(SetActionsError::AlreadyFinished);
+        }
+        if (req.dnd_actions & !DND_ALL, req.preferred_action & !DND_ALL) != (0, 0) {
+            return Err(SetActionsError::InvalidActions);
+        }
+        if req.preferred_action.count_ones() > 1 {
+            return Err(SetActionsError::MultiplePreferred);
+        }
+        self.data.shared.receiver_actions.set(req.dnd_actions);
+        self.data.shared.receiver_preferred_action.set(req.preferred_action);
+        if let Some(src) = self.data.source.get() {
+            src.update_selected_action();
+        }
         Ok(())
     }
 }
@@ -78,7 +150,7 @@ impl Object for WlDataOffer {
     }
 
     fn break_loops(&self) {
-        disconnect_offer::<WlDataDevice>(self);
+        break_offer_loops::<WlDataDevice>(self);
     }
 }
 
@@ -107,6 +179,8 @@ pub enum AcceptError {
     ParseFailed(#[source] Box<MsgParserError>),
     #[error(transparent)]
     ClientError(Box<ClientError>),
+    #[error("`finish` was already called")]
+    AlreadyFinished,
 }
 efrom!(AcceptError, ParseFailed, MsgParserError);
 efrom!(AcceptError, ClientError);
@@ -117,6 +191,8 @@ pub enum ReceiveError {
     ParseFailed(#[source] Box<MsgParserError>),
     #[error(transparent)]
     ClientError(Box<ClientError>),
+    #[error("`finish` was already called")]
+    AlreadyFinished,
 }
 efrom!(ReceiveError, ParseFailed, MsgParserError);
 efrom!(ReceiveError, ClientError);
@@ -137,6 +213,14 @@ pub enum FinishError {
     ParseFailed(#[source] Box<MsgParserError>),
     #[error(transparent)]
     ClientError(Box<ClientError>),
+    #[error("`finish` was already called")]
+    AlreadyFinished,
+    #[error("The drag operation is still ongoing")]
+    StillDragging,
+    #[error("Client did not accept a mime type")]
+    NoMimeTypeAccepted,
+    #[error("This is not a drag-and-drop offer")]
+    NotDnd,
 }
 efrom!(FinishError, ParseFailed, MsgParserError);
 efrom!(FinishError, ClientError);
@@ -147,6 +231,12 @@ pub enum SetActionsError {
     ParseFailed(#[source] Box<MsgParserError>),
     #[error(transparent)]
     ClientError(Box<ClientError>),
+    #[error("`finish` was already called")]
+    AlreadyFinished,
+    #[error("The set of actions is invalid")]
+    InvalidActions,
+    #[error("Multiple preferred actions were specified")]
+    MultiplePreferred,
 }
 efrom!(SetActionsError, ParseFailed, MsgParserError);
 efrom!(SetActionsError, ClientError);