smithay 0.3.0

Smithay is a library for writing wayland compositors.
Documentation 
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
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

use std::io;

use calloop::{EventSource, Interest, Mode, Poll, PostAction, Readiness, Token, TokenFactory};

use dbus::{
    blocking::LocalConnection,
    channel::{BusType, Channel, Watch},
    Message,
};

#[cfg(feature = "backend_session_logind")]
pub mod logind;

/// An internal wrapper for handling a DBus connection
///
/// It acts as a calloop event source to dispatch the DBus events
pub(crate) struct DBusConnection {
    cx: LocalConnection,
    current_watch: Watch,
    token: Token,
}

impl DBusConnection {
    pub fn new_system() -> Result<DBusConnection, dbus::Error> {
        let mut chan = Channel::get_private(BusType::System)?;
        chan.set_watch_enabled(true);
        Ok(DBusConnection {
            cx: chan.into(),
            token: Token::invalid(),
            current_watch: Watch {
                fd: -1,
                read: false,
                write: false,
            },
        })
    }

    pub fn add_match(&self, match_str: &str) -> Result<(), dbus::Error> {
        self.cx.add_match_no_cb(match_str)
    }

    pub fn channel(&self) -> &Channel {
        self.cx.channel()
    }
}

impl EventSource for DBusConnection {
    type Event = Message;
    type Metadata = DBusConnection;
    type Ret = ();

    fn process_events<F>(&mut self, _: Readiness, token: Token, mut callback: F) -> io::Result<PostAction>
    where
        F: FnMut(Message, &mut DBusConnection),
    {
        if token != self.token {
            return Ok(PostAction::Continue);
        }
        self.cx
            .channel()
            .read_write(Some(std::time::Duration::from_millis(0)))
            .map_err(|()| io::Error::new(io::ErrorKind::NotConnected, "DBus connection is closed"))?;
        while let Some(message) = self.cx.channel().pop_message() {
            callback(message, self);
        }
        self.cx.channel().flush();
        Ok(PostAction::Continue)
    }

    fn register(&mut self, poll: &mut Poll, factory: &mut TokenFactory) -> io::Result<()> {
        if self.current_watch.read || self.current_watch.write {
            return Err(io::Error::new(
                io::ErrorKind::AlreadyExists,
                "DBus session already registered to calloop",
            ));
        }
        // reregister handles all the watch logic
        self.reregister(poll, factory)
    }

    fn reregister(&mut self, poll: &mut Poll, factory: &mut TokenFactory) -> io::Result<()> {
        let new_watch = self.cx.channel().watch();
        let new_interest = match (new_watch.read, new_watch.write) {
            (true, true) => Some(Interest::BOTH),
            (true, false) => Some(Interest::READ),
            (false, true) => Some(Interest::WRITE),
            (false, false) => None,
        };
        self.token = factory.token();
        if new_watch.fd != self.current_watch.fd {
            // remove the previous fd
            if self.current_watch.read || self.current_watch.write {
                poll.unregister(self.current_watch.fd)?;
            }
            // insert the new one
            if let Some(interest) = new_interest {
                poll.register(new_watch.fd, interest, Mode::Level, self.token)?;
            }
        } else {
            // update the registration
            if let Some(interest) = new_interest {
                poll.reregister(self.current_watch.fd, interest, Mode::Level, self.token)?;
            } else {
                poll.unregister(self.current_watch.fd)?;
            }
        }
        self.current_watch = new_watch;
        Ok(())
    }

    fn unregister(&mut self, poll: &mut Poll) -> io::Result<()> {
        if self.current_watch.read || self.current_watch.write {
            poll.unregister(self.current_watch.fd)?;
        }
        self.token = Token::invalid();
        self.current_watch = Watch {
            fd: -1,
            read: false,
            write: false,
        };
        Ok(())
    }
}