1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

/*
 * SPDX-License-Identifier: MIT
 */

//! PipeWire [Link](https://docs.pipewire.org/group__pw__link.html) bindings.
//!
use std::pin::Pin;

use crate::wrapper::RawWrapper;
use pipewire_wrapper_proc_macro::{interface, proxy_wrapper, RawWrapper};

use crate::{
    listeners::{AddListener, Listeners, OwnListeners},
    spa::interface,
    spa_interface_call,
    wrapper::Wrapper,
};

use self::events::LinkEvents;

use super::{
    core::Core,
    proxy::{Proxy, ProxyRef},
    registry::restricted::RegistryBind,
};

pub mod events;
pub mod info;

#[derive(RawWrapper, Debug)]
#[interface(methods=pw_sys::pw_link_methods, interface="Link")]
#[repr(transparent)]
pub struct LinkRef {
    #[raw]
    raw: pw_sys::pw_link,
}

impl<'a> AddListener<'a> for LinkRef {
    type Events = LinkEvents<'a>;

    fn add_listener(&self, events: Pin<Box<Self::Events>>) -> Pin<Box<Self::Events>> {
        unsafe {
            spa_interface_call!(
                self,
                add_listener,
                events.hook().as_raw_ptr(),
                events.as_raw_ptr(),
                &*events as *const _ as *mut _
            )
        };

        events
    }
}

#[derive(Clone, Debug)]
#[proxy_wrapper(LinkRef)]
pub struct Link<'c> {
    ref_: Proxy<'c>,

    listeners: Listeners<Pin<Box<LinkEvents<'c>>>>,
}

impl<'c> RegistryBind<'c> for Link<'c> {
    fn from_ref(core: &'c Core, ref_: &ProxyRef) -> Self {
        Self {
            ref_: Proxy::from_ref(core, ref_),
            listeners: Listeners::default(),
        }
    }
}

impl<'a> OwnListeners<'a> for Link<'a> {
    fn listeners(
        &self,
    ) -> &Listeners<Pin<Box<<<Self as Wrapper>::RawWrapperType as AddListener<'a>>::Events>>> {
        &self.listeners
    }
}