>(path: Option) -> error::Result<()> {
156 | let mut message = Message::new_method_call(
157 | "meh.rust.ScreenSaver",
158 | "/meh/rust/ScreenSaver",
159 | "meh.rust.ScreenSaver",
160 | "Reload")?;
161 |
162 | if let Some(value) = path {
163 | message = message.append1(value.as_ref().to_string_lossy().into_owned());
164 | }
165 |
166 | Connection::new_session()?.send(message)?;
167 |
168 | Ok(())
169 | }
170 |
171 | /// Send a lock request.
172 | pub fn lock() -> error::Result<()> {
173 | Connection::new_session()?.send(Message::new_method_call(
174 | "org.gnome.ScreenSaver",
175 | "/org/gnome/ScreenSaver",
176 | "org.gnome.ScreenSaver",
177 | "Lock")?)?;
178 |
179 | Ok(())
180 | }
181 |
182 | /// Send an activation request.
183 | pub fn activate() -> error::Result<()> {
184 | Connection::new_session()?.send(Message::new_method_call(
185 | "org.gnome.ScreenSaver",
186 | "/org/gnome/ScreenSaver",
187 | "org.gnome.ScreenSaver",
188 | "SetActive")?
189 | .append1(true))?;
190 |
191 | Ok(())
192 | }
193 |
194 | /// Send a deactivation request.
195 | pub fn deactivate() -> error::Result<()> {
196 | Connection::new_session()?.send(Message::new_method_call(
197 | "org.gnome.ScreenSaver",
198 | "/org/gnome/ScreenSaver",
199 | "org.gnome.ScreenSaver",
200 | "SimulateUserActivity")?)?;
201 |
202 | Ok(())
203 | }
204 |
205 | /// Send an inhibition request.
206 | pub fn inhibit() -> error::Result {
207 | Connection::new_session()?.send_with_reply_and_block(Message::new_method_call(
208 | "org.gnome.ScreenSaver",
209 | "/org/gnome/ScreenSaver",
210 | "org.gnome.ScreenSaver",
211 | "Inhibit")?
212 | .append2("screenruster", "requested by user")
213 | , Duration::from_millis(5_000))?
214 | .get1::()
215 | .ok_or(dbus::Error::new_custom("inibhition", "wrong response").into())
216 | }
217 |
218 | /// Send an uninhibition request.
219 | pub fn uninhibit(cookie: u32) -> error::Result<()> {
220 | Connection::new_session()?.send(Message::new_method_call(
221 | "org.gnome.ScreenSaver",
222 | "/org/gnome/ScreenSaver",
223 | "org.gnome.ScreenSaver",
224 | "UnInhibit")?
225 | .append1(cookie))?;
226 |
227 | Ok(())
228 | }
229 |
230 | /// Send a throttle request.
231 | pub fn throttle() -> error::Result {
232 | Connection::new_session()?.send_with_reply_and_block(Message::new_method_call(
233 | "org.gnome.ScreenSaver",
234 | "/org/gnome/ScreenSaver",
235 | "org.gnome.ScreenSaver",
236 | "Throttle")?
237 | .append2("screenruster", "requested by user")
238 | , Duration::from_millis(5_000))?
239 | .get1::()
240 | .ok_or(dbus::Error::new_custom("throttle", "wrong response").into())
241 | }
242 |
243 | /// Send an unthrottle request.
244 | pub fn unthrottle(cookie: u32) -> error::Result<()> {
245 | Connection::new_session()?.send(Message::new_method_call(
246 | "org.gnome.ScreenSaver",
247 | "/org/gnome/ScreenSaver",
248 | "org.gnome.ScreenSaver",
249 | "UnThrottle")?
250 | .append1(cookie))?;
251 |
252 | Ok(())
253 | }
254 |
255 | /// Send a suspension request.
256 | pub fn suspend() -> error::Result {
257 | Connection::new_session()?.send_with_reply_and_block(Message::new_method_call(
258 | "meh.rust.ScreenSaver",
259 | "/meh/rust/ScreenSaver",
260 | "meh.rust.ScreenSaver",
261 | "Suspend")?
262 | .append2("screenruster", "requested by user")
263 | , Duration::from_millis(5_000))?
264 | .get1::()
265 | .ok_or(dbus::Error::new_custom("suspend", "wrong response").into())
266 | }
267 |
268 | /// Send a resume request.
269 | pub fn resume(cookie: u32) -> error::Result<()> {
270 | Connection::new_session()?.send(Message::new_method_call(
271 | "meh.rust.ScreenSaver",
272 | "/meh/rust/ScreenSaver",
273 | "meh.rust.ScreenSaver",
274 | "Resume")?
275 | .append1(cookie))?;
276 |
277 | Ok(())
278 | }
279 |
280 | /// Spawn a DBus interface with the given configuration.
281 | pub fn spawn(config: config::Interface) -> error::Result {
282 | let (sender, i_receiver) = channel::unbounded();
283 | let (i_sender, receiver) = channel::unbounded();
284 | let (s_sender, signals) = channel::unbounded();
285 | let (g_sender, g_receiver) = channel::unbounded::>();
286 |
287 | macro_rules! dbus {
288 | (connect system) => (
289 | Connection::new_system()
290 | );
291 |
292 | (connect session) => (
293 | match Connection::new_session() {
294 | Ok(value) => {
295 | value
296 | }
297 |
298 | Err(error) => {
299 | g_sender.send(Err(error.into())).unwrap();
300 | return;
301 | }
302 | }
303 | );
304 |
305 | (register $conn:expr, $name:expr) => (
306 | match $conn.request_name($name, false, false, true) {
307 | Ok(RequestNameReply::Exists) => {
308 | g_sender.send(Err(error::DBus::AlreadyRegistered.into())).unwrap();
309 | return;
310 | }
311 |
312 | Err(error) => {
313 | g_sender.send(Err(error.into())).unwrap();
314 | return;
315 | }
316 |
317 | Ok(value) => {
318 | value
319 | }
320 | }
321 | );
322 |
323 | (watch $conn:expr, $filter:expr) => (
324 | $conn.add_match_no_cb($filter)
325 | );
326 |
327 | (ready) => (
328 | g_sender.send(Ok(())).unwrap();
329 | );
330 |
331 | (check) => (
332 | g_receiver.recv().unwrap()
333 | );
334 |
335 | (try $body:expr) => (
336 | match $body {
337 | Ok(value) => {
338 | value
339 | }
340 |
341 | Err(err) => {
342 | error!("{:?}", err);
343 | return None;
344 | }
345 | }
346 | );
347 | }
348 |
349 | macro_rules! cloning {
350 | ([$($var:ident),*] $closure:expr) => ({
351 | $(let $var = $var.clone();)*
352 | $closure
353 | });
354 | }
355 |
356 | // System DBus handler.
357 | {
358 | let sender = sender.clone();
359 |
360 | thread::spawn(move || {
361 | /// Inhibits system suspension temporarily.
362 | fn inhibit(c: &Connection) -> Option {
363 | dbus!(try c.send_with_reply_and_block(dbus!(try Message::new_method_call(
364 | "org.freedesktop.login1",
365 | "/org/freedesktop/login1",
366 | "org.freedesktop.login1.Manager",
367 | "Inhibit"))
368 | .append1("sleep")
369 | .append1("ScreenRuster")
370 | .append1("Preparing for sleep.")
371 | .append1("delay"), Duration::from_millis(1_000)))
372 | .get1()
373 | }
374 |
375 | let system = dbus!(connect system).unwrap();
376 |
377 | // Delay the next suspension.
378 | let mut inhibitor = inhibit(&system);
379 |
380 | // Watch for PrepareForSleep events from SystemD.
381 | dbus!(watch system, "path='/org/freedesktop/login1',interface='org.freedesktop.login1.Manager',member='PrepareForSleep'").unwrap();
382 |
383 | #[derive(Debug)]
384 | pub struct PrepareForSleep {
385 | pub arg0: bool,
386 | }
387 |
388 | impl dbus::arg::AppendAll for PrepareForSleep {
389 | fn append(&self, i: &mut dbus::arg::IterAppend) {
390 | dbus::arg::RefArg::append(&self.arg0, i);
391 | }
392 | }
393 |
394 | impl dbus::arg::ReadAll for PrepareForSleep {
395 | fn read(i: &mut dbus::arg::Iter) -> Result {
396 | Ok(PrepareForSleep {
397 | arg0: i.read()?,
398 | })
399 | }
400 | }
401 |
402 | impl dbus::message::SignalArgs for PrepareForSleep {
403 | const NAME: &'static str = "PrepareForSleep";
404 | const INTERFACE: &'static str = "org.freedesktop.login1.Manager";
405 | }
406 |
407 | system.with_proxy("org.freedesktop.login1.Manager", "/org/freedesktop/login1", Duration::from_micros(5_000))
408 | .match_signal(|p: PrepareForSleep, _: &Connection, _: &Message| {
409 | sender.send(Request::PrepareForSleep(
410 | if p.arg0 { Some(SystemTime::now()) } else { None })).unwrap();
411 |
412 | // In case the system is suspending, unlock the suspension,
413 | // otherwise delay the next.
414 | if p.arg0 {
415 | inhibitor.take();
416 | }
417 | else {
418 | inhibitor = inhibit(&system);
419 | }
420 |
421 | true
422 | });
423 | });
424 | }
425 |
426 | // Session DBus handler.
427 | {
428 | let sender = sender.clone();
429 |
430 | thread::spawn(move || {
431 | let mut session = dbus!(connect session);
432 | let f = dbus::tree::Factory::new_sync::<()>();
433 |
434 | dbus!(register session, "org.gnome.ScreenSaver");
435 | dbus!(register session, "meh.rust.ScreenSaver");
436 | dbus!(ready);
437 |
438 | // GNOME screensaver signals.
439 | let active = Arc::new(f.signal("ActiveChanged", ()).sarg::("status"));
440 | let idle = Arc::new(f.signal("SessionIdleChanged", ()).sarg::("status"));
441 | let begin = Arc::new(f.signal("AuthenticationRequestBegin", ()));
442 | let end = Arc::new(f.signal("AuthenticationRequestEnd", ()));
443 |
444 | let tree = f.tree(())
445 | // ScreenRuster interface.
446 | .add(f.object_path("/meh/rust/ScreenSaver", ()).introspectable().add(f.interface("meh.rust.ScreenSaver", ())
447 | .add_m(f.method("Reload", (), cloning!([config, sender, receiver] move |m| {
448 | if config.ignores("reload") {
449 | return Err(dbus::tree::MethodErr::failed(&"Reload is ignored"));
450 | }
451 |
452 | sender.send(Request::Reload(m.msg.get1())).unwrap();
453 |
454 | if let Response::Reload(value) = receiver.recv().unwrap() {
455 | Ok(vec![m.msg.method_return().append1(value)])
456 | }
457 | else {
458 | unreachable!();
459 | }
460 | })).inarg::("path").outarg::("success"))
461 |
462 | .add_m(f.method("Suspend", (), cloning!([config, sender, receiver] move |m| {
463 | if config.ignores("suspend") {
464 | return Err(dbus::tree::MethodErr::failed(&"Suspend is ignored"));
465 | }
466 |
467 | if let (Some(application), Some(reason)) = m.msg.get2() {
468 | sender.send(Request::Suspend {
469 | application: application,
470 | reason: reason
471 | }).unwrap();
472 |
473 | if let Response::Suspend(value) = receiver.recv().unwrap() {
474 | Ok(vec![m.msg.method_return().append1(value)])
475 | }
476 | else {
477 | unreachable!();
478 | }
479 | }
480 | else {
481 | Err(dbus::tree::MethodErr::no_arg())
482 | }
483 | })).in_args(vec![dbus::Signature::make::(), dbus::Signature::make::()]))
484 |
485 | .add_m(f.method("Resume", (), cloning!([config, sender] move |m| {
486 | if config.ignores("suspend") {
487 | return Err(dbus::tree::MethodErr::failed(&"Suspend is ignored"));
488 | }
489 |
490 | if let Some(cookie) = m.msg.get1() {
491 | sender.send(Request::Resume(cookie)).unwrap();
492 |
493 | Ok(vec![m.msg.method_return()])
494 | }
495 | else {
496 | Err(dbus::tree::MethodErr::no_arg())
497 | }
498 | })).inarg::("cookie"))))
499 |
500 | // GNOME screensaver interface.
501 | .add(f.object_path("/org/gnome/ScreenSaver", ()).introspectable().add(f.interface("org.gnome.ScreenSaver", ())
502 | .add_m(f.method("Lock", (), cloning!([sender] move |m| {
503 | sender.send(Request::Lock).unwrap();
504 |
505 | Ok(vec![m.msg.method_return()])
506 | })))
507 |
508 | .add_m(f.method("Cycle", (), cloning!([sender] move |m| {
509 | sender.send(Request::Cycle).unwrap();
510 |
511 | Ok(vec![m.msg.method_return()])
512 | })))
513 |
514 | .add_m(f.method("SimulateUserActivity", (), cloning!([sender] move |m| {
515 | sender.send(Request::SimulateUserActivity).unwrap();
516 |
517 | Ok(vec![m.msg.method_return()])
518 | })))
519 |
520 | .add_m(f.method("Inhibit", (), cloning!([config, sender, receiver] move |m| {
521 | if config.ignores("inhibit") {
522 | return Err(dbus::tree::MethodErr::failed(&"Inhibit is ignored"));
523 | }
524 |
525 | if let (Some(application), Some(reason)) = m.msg.get2() {
526 | sender.send(Request::Inhibit {
527 | application: application,
528 | reason: reason
529 | }).unwrap();
530 |
531 | if let Response::Inhibit(value) = receiver.recv().unwrap() {
532 | Ok(vec![m.msg.method_return().append1(value)])
533 | }
534 | else {
535 | unreachable!();
536 | }
537 | }
538 | else {
539 | Err(dbus::tree::MethodErr::no_arg())
540 | }
541 | })).in_args(vec![dbus::Signature::make::(), dbus::Signature::make::()]))
542 |
543 | .add_m(f.method("UnInhibit", (), cloning!([config, sender] move |m| {
544 | if config.ignores("inhibit") {
545 | return Err(dbus::tree::MethodErr::failed(&"Inhibit is ignored"));
546 | }
547 |
548 | if let Some(cookie) = m.msg.get1() {
549 | sender.send(Request::UnInhibit(cookie)).unwrap();
550 |
551 | Ok(vec![m.msg.method_return()])
552 | }
553 | else {
554 | Err(dbus::tree::MethodErr::no_arg())
555 | }
556 | })).inarg::("cookie"))
557 |
558 | .add_m(f.method("Throttle", (), cloning!([config, sender, receiver] move |m| {
559 | if config.ignores("throttle") {
560 | return Err(dbus::tree::MethodErr::failed(&"Inhibit is ignored"));
561 | }
562 |
563 | if let (Some(application), Some(reason)) = m.msg.get2() {
564 | sender.send(Request::Throttle {
565 | application: application,
566 | reason: reason
567 | }).unwrap();
568 |
569 | if let Response::Throttle(value) = receiver.recv().unwrap() {
570 | Ok(vec![m.msg.method_return().append1(value)])
571 | }
572 | else {
573 | unreachable!();
574 | }
575 | }
576 | else {
577 | Err(dbus::tree::MethodErr::no_arg())
578 | }
579 | })).in_args(vec![dbus::Signature::make::(), dbus::Signature::make::()]))
580 |
581 | .add_m(f.method("UnThrottle", (), cloning!([config, sender] move |m| {
582 | if config.ignores("throttle") {
583 | return Err(dbus::tree::MethodErr::failed(&"Inhibit is ignored"));
584 | }
585 |
586 | if let Some(cookie) = m.msg.get1() {
587 | sender.send(Request::UnThrottle(cookie)).unwrap();
588 |
589 | Ok(vec![m.msg.method_return()])
590 | }
591 | else {
592 | Err(dbus::tree::MethodErr::no_arg())
593 | }
594 | })).inarg::("cookie"))
595 |
596 | .add_m(f.method("SetActive", (), cloning!([sender] move |m| {
597 | if let Some(value) = m.msg.get1() {
598 | sender.send(Request::SetActive(value)).unwrap();
599 |
600 | Ok(vec![m.msg.method_return()])
601 | }
602 | else {
603 | Err(dbus::tree::MethodErr::no_arg())
604 | }
605 | })).inarg::("active"))
606 |
607 | .add_m(f.method("GetActive", (), cloning!([sender, receiver] move |m| {
608 | sender.send(Request::GetActive).unwrap();
609 |
610 | if let Response::Active(value) = receiver.recv().unwrap() {
611 | Ok(vec![m.msg.method_return().append1(value)])
612 | }
613 | else {
614 | unreachable!();
615 | }
616 | })).outarg::("active"))
617 |
618 | .add_m(f.method("GetActiveTime", (), cloning!([sender, receiver] move |m| {
619 | sender.send(Request::GetActiveTime).unwrap();
620 |
621 | if let Response::ActiveTime(time) = receiver.recv().unwrap() {
622 | Ok(vec![m.msg.method_return().append1(time)])
623 | }
624 | else {
625 | unreachable!();
626 | }
627 | })).outarg::("time"))
628 |
629 | .add_m(f.method("GetSessionIdle", (), cloning!([sender, receiver] move |m| {
630 | sender.send(Request::GetSessionIdle).unwrap();
631 |
632 | if let Response::SessionIdle(value) = receiver.recv().unwrap() {
633 | Ok(vec![m.msg.method_return().append1(value)])
634 | }
635 | else {
636 | unreachable!();
637 | }
638 | })).outarg::("idle"))
639 |
640 | .add_m(f.method("GetSessionIdleTime", (), cloning!([sender, receiver] move |m| {
641 | sender.send(Request::GetSessionIdleTime).unwrap();
642 |
643 | if let Response::SessionIdleTime(time) = receiver.recv().unwrap() {
644 | Ok(vec![m.msg.method_return().append1(time)])
645 | }
646 | else {
647 | unreachable!();
648 | }
649 | })).outarg::("time"))
650 |
651 | .add_s(active.clone())
652 | .add_s(idle.clone())
653 | .add_s(begin.clone())
654 | .add_s(end.clone())));
655 |
656 | tree.start_receive(&session);
657 |
658 | loop {
659 | session.process(Duration::from_millis(500));
660 |
661 | while let Ok(signal) = signals.try_recv() {
662 | session.send(match signal {
663 | Signal::Active(status) =>
664 | active.msg(&"/meh/rust/ScreenSaver".into(), &"org.gnome.ScreenSaver".into()).append1(status),
665 |
666 | Signal::SessionIdle(status) =>
667 | idle.msg(&"/meh/rust/ScreenSaver".into(), &"org.gnome.ScreenSaver".into()).append1(status),
668 |
669 | Signal::AuthenticationRequest(true) =>
670 | begin.msg(&"/meh/rust/ScreenSaver".into(), &"org.gnome.ScreenSaver".into()),
671 |
672 | Signal::AuthenticationRequest(false) =>
673 | end.msg(&"/meh/rust/ScreenSaver".into(), &"org.gnome.ScreenSaver".into()),
674 | }).unwrap();
675 | }
676 | }
677 | });
678 | }
679 |
680 | dbus!(check)?;
681 |
682 | Ok(Interface {
683 | receiver: i_receiver,
684 | sender: i_sender,
685 | signals: s_sender,
686 | })
687 | }
688 |
689 | pub fn response(&self, value: Response) -> Result<(), SendError> {
690 | self.sender.send(value)
691 | }
692 |
693 | pub fn signal(&self, value: Signal) -> Result<(), SendError> {
694 | self.signals.send(value)
695 | }
696 | }
697 |
698 | impl Deref for Interface {
699 | type Target = Receiver;
700 |
701 | fn deref(&self) -> &Receiver {
702 | &self.receiver
703 | }
704 | }
705 |
--------------------------------------------------------------------------------
/src/locker/display.rs:
--------------------------------------------------------------------------------
1 | // Copyleft (ↄ) meh. | http://meh.schizofreni.co
2 | //
3 | // This file is part of screenruster.
4 | //
5 | // screenruster is free software: you can redistribute it and/or modify
6 | // it under the terms of the GNU General Public License as published by
7 | // the Free Software Foundation, either version 3 of the License, or
8 | // (at your option) any later version.
9 | //
10 | // screenruster is distributed in the hope that it will be useful,
11 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 | // GNU General Public License for more details.
14 | //
15 | // You should have received a copy of the GNU General Public License
16 | // along with screenruster. If not, see .
17 |
18 | use std::sync::Arc;
19 | use std::ops::Deref;
20 |
21 | use xcb;
22 | use crate::{error, config, platform};
23 |
24 | pub struct Display {
25 | display: Arc,
26 |
27 | randr: bool,
28 | dpms: bool,
29 | }
30 |
31 | unsafe impl Send for Display { }
32 | unsafe impl Sync for Display { }
33 |
34 | impl Display {
35 | /// Open the display.
36 | pub fn open(config: config::Locker) -> error::Result> {
37 | let display = platform::Display::open(config.display())?;
38 | let randr = display.get_extension_data(xcb::randr::id());
39 | let mut dpms = display.get_extension_data(xcb::dpms::id());
40 |
41 | if randr.is_some() {
42 | let version = xcb::randr::query_version(&display, 1, 1).get_reply()?;
43 |
44 | if version.major_version() < 1 || (version.major_version() >= 1 && version.minor_version() < 1) {
45 | return Err(error::X::MissingExtension.into());
46 | }
47 | }
48 |
49 | if let Some(ext) = dpms.take() {
50 | if config.dpms() && xcb::dpms::capable(&display).get_reply()?.capable() {
51 | dpms = Some(ext);
52 | }
53 | }
54 |
55 | let display = Arc::new(Display {
56 | display: display.clone(),
57 |
58 | randr: randr.is_some(),
59 | dpms: dpms.is_some(),
60 | });
61 |
62 | display.sanitize();
63 |
64 | Ok(display)
65 | }
66 |
67 | /// Get the XRandr extension data.
68 | pub fn randr(&self) -> Option {
69 | if self.randr {
70 | Some(self.display.get_extension_data(xcb::randr::id()).unwrap())
71 | }
72 | else {
73 | None
74 | }
75 | }
76 |
77 | /// Get the DPMS extension data.
78 | pub fn dpms(&self) -> Option {
79 | if self.dpms {
80 | Some(self.display.get_extension_data(xcb::dpms::id()).unwrap())
81 | }
82 | else {
83 | None
84 | }
85 | }
86 |
87 | /// Check if the monitor is powered on or not.
88 | pub fn is_powered(&self) -> bool {
89 | if !self.dpms {
90 | return true;
91 | }
92 |
93 | if let Ok(reply) = xcb::dpms::info(self).get_reply() {
94 | if !reply.state() {
95 | return true;
96 | }
97 |
98 | match reply.power_level() as u32 {
99 | xcb::dpms::DPMS_MODE_ON =>
100 | true,
101 |
102 | xcb::dpms::DPMS_MODE_OFF |
103 | xcb::dpms::DPMS_MODE_STANDBY |
104 | xcb::dpms::DPMS_MODE_SUSPEND =>
105 | false,
106 |
107 | _ => unreachable!()
108 | }
109 | }
110 | else {
111 | false
112 | }
113 | }
114 |
115 | /// Turn the monitor on or off.
116 | pub fn power(&self, value: bool) {
117 | if !self.dpms || self.is_powered() == value {
118 | return;
119 | }
120 |
121 | xcb::dpms::force_level(self, if value {
122 | xcb::dpms::DPMS_MODE_ON
123 | } else {
124 | xcb::dpms::DPMS_MODE_OFF
125 | } as u16);
126 |
127 | self.flush();
128 | }
129 |
130 | /// Sanitize the display from bad X11 things.
131 | pub fn sanitize(&self) {
132 | // Reset DPMS settings to usable.
133 | if self.dpms {
134 | xcb::dpms::set_timeouts(self, 0, 0, 0);
135 | xcb::dpms::enable(self);
136 | }
137 |
138 | // Reset screen saver timeout.
139 | xcb::set_screen_saver(self, 0, 0, 0, xcb::EXPOSURES_ALLOWED as u8);
140 | }
141 |
142 | /// Observe events on the given window and all its children.
143 | pub fn observe(&self, window: u32) -> error::Result<()> {
144 | let query = xcb::query_tree(self, window).get_reply()?;
145 |
146 | // Return if the window is one of ours.
147 | {
148 | let reply = xcb::get_property(self, false, window,
149 | xcb::intern_atom(self, false, "SCREENRUSTER_SAVER").get_reply().unwrap().atom(),
150 | xcb::ATOM_CARDINAL, 0, 1).get_reply();
151 |
152 | if let Ok(reply) = reply {
153 | if reply.type_() == xcb::ATOM_CARDINAL {
154 | return Ok(());
155 | }
156 | }
157 | }
158 |
159 | // Start listening for activity events from the window making sure to not
160 | // break it, by excluding various events.
161 | let attrs = xcb::get_window_attributes(self, window).get_reply()?;
162 | xcb::change_window_attributes_checked(self, window, &[
163 | (xcb::CW_EVENT_MASK, (attrs.all_event_masks() | attrs.do_not_propagate_mask() as u32) &
164 | (xcb::EVENT_MASK_KEY_PRESS | xcb::EVENT_MASK_KEY_RELEASE) |
165 | (xcb::EVENT_MASK_POINTER_MOTION | xcb::EVENT_MASK_SUBSTRUCTURE_NOTIFY))]).request_check()?;
166 |
167 | for &child in query.children() {
168 | self.observe(child)?;
169 | }
170 |
171 | Ok(())
172 | }
173 | }
174 |
175 | impl Deref for Display {
176 | type Target = Arc;
177 |
178 | fn deref(&self) -> &Self::Target {
179 | &self.display
180 | }
181 | }
182 |
--------------------------------------------------------------------------------
/src/locker/locker.rs:
--------------------------------------------------------------------------------
1 | // Copyleft (ↄ) meh. | http://meh.schizofreni.co
2 | //
3 | // This file is part of screenruster.
4 | //
5 | // screenruster is free software: you can redistribute it and/or modify
6 | // it under the terms of the GNU General Public License as published by
7 | // the Free Software Foundation, either version 3 of the License, or
8 | // (at your option) any later version.
9 | //
10 | // screenruster is distributed in the hope that it will be useful,
11 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 | // GNU General Public License for more details.
14 | //
15 | // You should have received a copy of the GNU General Public License
16 | // along with screenruster. If not, see .
17 |
18 | use std::collections::HashMap;
19 | use std::thread;
20 | use std::ops::Deref;
21 | use channel::{self, Receiver, Sender, SendError, select};
22 |
23 | use rand::{self, Rng};
24 | use xcb;
25 | use xkb::{self, key};
26 |
27 | use crate::error;
28 | use crate::config::Config;
29 | use crate::timer;
30 | use crate::saver::{self, Saver, Safety, Password, Pointer};
31 | use super::{Display, Window};
32 | use crate::platform::{self, Keyboard};
33 | use api;
34 |
35 | pub struct Locker {
36 | receiver: Receiver,
37 | sender: Sender,
38 | }
39 |
40 | #[derive(Clone)]
41 | pub enum Request {
42 | Sanitize,
43 | Timeout { id: u64 },
44 | Activity,
45 | Power(bool),
46 | Throttle(bool),
47 |
48 | Start,
49 | Lock,
50 | Auth(bool),
51 | Stop,
52 | }
53 |
54 | #[derive(Clone)]
55 | pub enum Response {
56 | Timeout(timer::Timeout),
57 | Activity,
58 | Password(String),
59 | Stopped,
60 | }
61 |
62 | impl Locker {
63 | pub fn spawn(config: Config) -> error::Result {
64 | let display = Display::open(config.locker())?;
65 | let mut keyboard = Keyboard::new((*display).clone(), None)?;
66 | let mut windows = HashMap::::new();
67 | let mut savers = HashMap::::new();
68 | let mut checking = false;
69 | let mut password = String::new();
70 |
71 | for screen in 0 .. display.screens() {
72 | let window = Window::create(display.clone(), screen as i32)?;
73 |
74 | display.observe(window.root()).unwrap();
75 | windows.insert(window.id(), window);
76 | }
77 |
78 | let (sender, i_receiver) = channel::unbounded();
79 | let (i_sender, receiver) = channel::unbounded();
80 | let (s_sender, s_receiver) = channel::unbounded();
81 |
82 | thread::spawn(move || {
83 | macro_rules! window {
84 | (list) => (
85 | windows.values_mut()
86 | );
87 |
88 | (? $id:expr) => (
89 | windows.get_mut(&$id)
90 | );
91 |
92 | ($id:expr) => (
93 | windows.get_mut(&$id).unwrap()
94 | );
95 | }
96 |
97 | macro_rules! saver {
98 | (list) => (
99 | savers.values_mut()
100 | );
101 |
102 | (add $id:expr => $saver:expr) => (
103 | savers.insert($id, $saver);
104 | );
105 |
106 | (remove $id:expr) => (
107 | savers.remove(&$id);
108 | );
109 |
110 | (safety $id:expr) => (
111 | saver!(safety on window!($id));
112 | );
113 |
114 | (safety on $window:expr) => (
115 | if let Some(saver) = saver!(? $window.id()) {
116 | if $window.has_keyboard() && $window.has_pointer() {
117 | saver.safety(Safety::High).unwrap();
118 | }
119 | else if $window.has_keyboard() {
120 | saver.safety(Safety::Medium).unwrap();
121 | }
122 | else {
123 | saver.safety(Safety::Low).unwrap();
124 | }
125 | }
126 | );
127 |
128 | (? $id:expr) => (
129 | savers.get_mut(&$id)
130 | );
131 |
132 | ($id:expr) => (
133 | savers.get_mut(&$id).unwrap()
134 | );
135 | }
136 |
137 | let x = platform::display::sink(&display);
138 |
139 | loop {
140 | select! {
141 | // Handle control events.
142 | recv(receiver) -> event => {
143 | match event.unwrap() {
144 | Request::Timeout { id } => {
145 | if let Some(saver) = saver!(? id as u32) {
146 | saver.kill();
147 | }
148 | }
149 |
150 | Request::Sanitize => {
151 | display.sanitize();
152 |
153 | for window in window!(list) {
154 | let keyboard = window.has_keyboard();
155 | let pointer = window.has_pointer();
156 |
157 | window.sanitize();
158 |
159 | if keyboard == window.has_keyboard() && pointer == window.has_pointer() {
160 | continue;
161 | }
162 |
163 | saver!(safety on window);
164 | }
165 | }
166 |
167 | Request::Activity => {
168 | sender.send(Response::Activity).unwrap();
169 | }
170 |
171 | Request::Throttle(value) => {
172 | for saver in saver!(list) {
173 | saver.throttle(value).unwrap();
174 | }
175 | }
176 |
177 | Request::Power(value) => {
178 | for window in window!(list) {
179 | window.power(value);
180 | }
181 |
182 | for saver in saver!(list) {
183 | saver.blank(!value).unwrap();
184 | }
185 |
186 | display.power(value);
187 | }
188 |
189 | Request::Start => {
190 | for window in window!(list) {
191 | if !config.saver().using().is_empty() {
192 | let name = &config.saver().using()[rand::thread_rng().gen_range(0, config.saver().using().len())];
193 |
194 | if let Ok(mut saver) = Saver::spawn(&name) {
195 | let id = window.id();
196 |
197 | sender.send(Response::Timeout(timer::Timeout::Set {
198 | id: id as u64,
199 | seconds: config.saver().timeout() as u64,
200 | })).unwrap();
201 |
202 | let receiver = saver.take().unwrap();
203 | let sender = s_sender.clone();
204 |
205 | thread::spawn(move || {
206 | while let Ok(event) = receiver.recv() {
207 | sender.send((id, event)).unwrap();
208 | }
209 | });
210 |
211 | saver.config(config.saver().get(&name)).unwrap();
212 | saver.target(display.name(), window.screen(), id as u64).unwrap();
213 |
214 | if config.saver().throttle() {
215 | saver.throttle(true).unwrap();
216 | }
217 |
218 | saver!(add id => saver);
219 |
220 | continue;
221 | }
222 | }
223 |
224 | window.lock().unwrap();
225 | window.blank();
226 | }
227 | }
228 |
229 | Request::Lock => {
230 | for saver in saver!(list) {
231 | saver.lock().unwrap();
232 | }
233 | }
234 |
235 | Request::Auth(state) => {
236 | checking = false;
237 |
238 | for saver in saver!(list) {
239 | saver.password(if state { Password::Success } else { Password::Failure }).unwrap();
240 | }
241 | }
242 |
243 | Request::Stop => {
244 | for (&id, window) in &mut windows {
245 | if let Some(saver) = saver!(? id) {
246 | sender.send(Response::Timeout(timer::Timeout::Set {
247 | id: id as u64,
248 | seconds: config.saver().timeout() as u64,
249 | })).unwrap();
250 |
251 | saver.stop().unwrap();
252 | }
253 | else {
254 | window.unlock().unwrap();
255 | }
256 | }
257 | }
258 | }
259 | },
260 |
261 | // Handle saver events.
262 | recv(s_receiver) -> event => {
263 | let (id, event) = event.unwrap();
264 |
265 | match event {
266 | saver::Response::Forward(api::Response::Initialized) => {
267 | saver!(id).start().unwrap();
268 | }
269 |
270 | saver::Response::Forward(api::Response::Started) => {
271 | if saver!(id).was_started() {
272 | sender.send(Response::Timeout(timer::Timeout::Cancel { id: id as u64 })).unwrap();
273 |
274 | window!(id).lock().unwrap();
275 | saver!(safety id);
276 | }
277 | else {
278 | saver!(id).kill();
279 | }
280 | }
281 |
282 | saver::Response::Forward(api::Response::Stopped) => {
283 | if !saver!(id).was_stopped() {
284 | saver!(id).kill();
285 | }
286 | else {
287 | sender.send(Response::Timeout(timer::Timeout::Cancel { id: id as u64 })).unwrap();
288 | }
289 | }
290 |
291 | saver::Response::Exit(..) => {
292 | if saver!(id).was_stopped() {
293 | window!(id).unlock().unwrap();
294 |
295 | if savers.len() == 1 {
296 | sender.send(Response::Stopped).unwrap();
297 | }
298 | }
299 | else {
300 | window!(id).lock().unwrap();
301 | window!(id).blank();
302 | }
303 |
304 | saver!(remove id);
305 | }
306 | }
307 | },
308 |
309 | // Handle X events.
310 | recv(x) -> event => {
311 | let event = event.unwrap();
312 |
313 | match event.response_type() {
314 | // Handle screen changes.
315 | e if display.randr().map_or(false, |rr| e == rr.first_event() + xcb::randr::SCREEN_CHANGE_NOTIFY) => {
316 | let event = unsafe { xcb::cast_event::(&event) };
317 |
318 | for window in window!(list) {
319 | if window.root() == event.root() {
320 | window.resize(event.width() as u32, event.height() as u32);
321 |
322 | if let Some(saver) = saver!(? window.id()) {
323 | saver.resize(event.width() as u32, event.height() as u32).unwrap();
324 | }
325 | }
326 | }
327 | }
328 |
329 | // Handle keyboard events.
330 | e if keyboard.owns_event(e) => {
331 | keyboard.handle(&event);
332 | }
333 |
334 | // Handle keyboard input.
335 | //
336 | // Note we only act on key presses because `Xutf8LookupString`
337 | // only generates strings from `KeyPress` events.
338 | xcb::KEY_PRESS => {
339 | sender.send(Response::Activity).unwrap();
340 |
341 | // Ignore keyboard input while checking authentication.
342 | if checking {
343 | continue;
344 | }
345 |
346 | let event = unsafe { xcb::cast_event::(&event) };
347 | if windows.values().find(|w| w.id() == event.event()).is_some() {
348 | match keyboard.symbol(event.detail().into()) {
349 | // Delete a character.
350 | Some(key::BackSpace) => {
351 | if !password.is_empty() {
352 | password.pop();
353 |
354 | for saver in saver!(list) {
355 | saver.password(Password::Delete).unwrap();
356 | }
357 | }
358 | }
359 |
360 | // Clear the password.
361 | Some(key::Escape) => {
362 | if !password.is_empty() {
363 | password.clear();
364 |
365 | for saver in saver!(list) {
366 | saver.password(Password::Reset).unwrap();
367 | }
368 | }
369 | }
370 |
371 | // Check authentication.
372 | Some(key::Return) => {
373 | for saver in saver!(list) {
374 | saver.password(Password::Check).unwrap();
375 | }
376 |
377 | sender.send(Response::Password(password)).unwrap();
378 |
379 | checking = true;
380 | password = String::new();
381 | }
382 |
383 | _ => {
384 | // Limit the maximum password length so keeping a button
385 | // pressed is not going to OOM us in the extremely long
386 | // run.
387 | if password.len() <= 255 {
388 | if let Some(string) = keyboard.string(event.detail().into()) {
389 | for ch in string.chars() {
390 | password.push(ch);
391 |
392 | for saver in saver!(list) {
393 | saver.password(Password::Insert).unwrap();
394 | }
395 | }
396 | }
397 | }
398 | }
399 | }
400 | }
401 | }
402 |
403 | xcb::KEY_RELEASE => {
404 | sender.send(Response::Activity).unwrap();
405 | }
406 |
407 | // Handle mouse button presses.
408 | xcb::BUTTON_PRESS | xcb::BUTTON_RELEASE => {
409 | sender.send(Response::Activity).unwrap();
410 |
411 | let event = unsafe { xcb::cast_event::(&event) };
412 | if let Some(window) = windows.values().find(|w| w.id() == event.event()) {
413 | if let Some(saver) = saver!(? window.id()) {
414 | saver.pointer(Pointer::Button {
415 | x: event.event_x() as i32,
416 | y: event.event_y() as i32,
417 |
418 | button: event.detail(),
419 | press: event.response_type() == xcb::BUTTON_PRESS,
420 | }).unwrap()
421 | }
422 | }
423 | }
424 |
425 | // Handle mouse motion.
426 | xcb::MOTION_NOTIFY => {
427 | sender.send(Response::Activity).unwrap();
428 |
429 | let event = unsafe { xcb::cast_event::(&event) };
430 | if let Some(window) = windows.values().find(|w| w.id() == event.event()) {
431 | if let Some(saver) = saver!(? window.id()) {
432 | saver.pointer(Pointer::Move {
433 | x: event.event_x() as i32,
434 | y: event.event_y() as i32,
435 | }).unwrap();
436 | }
437 | }
438 | }
439 |
440 | // On window changes, try to observe the window.
441 | xcb::MAP_NOTIFY | xcb::CONFIGURE_NOTIFY => {
442 | let event = unsafe { xcb::cast_event::(&event) };
443 | display.observe(event.window()).unwrap();
444 | }
445 |
446 | _ => ()
447 | }
448 | }
449 | }
450 | }
451 | });
452 |
453 | Ok(Locker {
454 | receiver: i_receiver,
455 | sender: i_sender,
456 | })
457 | }
458 |
459 | pub fn sanitize(&self) -> Result<(), SendError> {
460 | self.sender.send(Request::Sanitize)
461 | }
462 |
463 | pub fn timeout(&self, id: u64) -> Result<(), SendError> {
464 | self.sender.send(Request::Timeout { id: id })
465 | }
466 |
467 | pub fn start(&self) -> Result<(), SendError> {
468 | self.sender.send(Request::Start)
469 | }
470 |
471 | pub fn lock(&self) -> Result<(), SendError> {
472 | self.sender.send(Request::Lock)
473 | }
474 |
475 | pub fn auth(&self, value: bool) -> Result<(), SendError> {
476 | self.sender.send(Request::Auth(value))
477 | }
478 |
479 | pub fn stop(&self) -> Result<(), SendError> {
480 | self.sender.send(Request::Stop)
481 | }
482 |
483 | pub fn power(&self, value: bool) -> Result<(), SendError> {
484 | self.sender.send(Request::Power(value))
485 | }
486 |
487 | pub fn activity(&self) -> Result<(), SendError> {
488 | self.sender.send(Request::Activity)
489 | }
490 |
491 | pub fn throttle(&self, value: bool) -> Result<(), SendError> {
492 | self.sender.send(Request::Throttle(value))
493 | }
494 | }
495 |
496 | impl Deref for Locker {
497 | type Target = Receiver;
498 |
499 | fn deref(&self) -> &Receiver {
500 | &self.receiver
501 | }
502 | }
503 |
--------------------------------------------------------------------------------
/src/locker/mod.rs:
--------------------------------------------------------------------------------
1 | // Copyleft (ↄ) meh. | http://meh.schizofreni.co
2 | //
3 | // This file is part of screenruster.
4 | //
5 | // screenruster is free software: you can redistribute it and/or modify
6 | // it under the terms of the GNU General Public License as published by
7 | // the Free Software Foundation, either version 3 of the License, or
8 | // (at your option) any later version.
9 | //
10 | // screenruster is distributed in the hope that it will be useful,
11 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 | // GNU General Public License for more details.
14 | //
15 | // You should have received a copy of the GNU General Public License
16 | // along with screenruster. If not, see .
17 |
18 | mod locker;
19 | pub use self::locker::{Locker, Request, Response};
20 |
21 | mod display;
22 | pub use self::display::Display;
23 |
24 | mod window;
25 | pub use self::window::Window;
26 |
--------------------------------------------------------------------------------
/src/locker/window.rs:
--------------------------------------------------------------------------------
1 | // Copyleft (ↄ) meh. | http://meh.schizofreni.co
2 | //
3 | // This file is part of screenruster.
4 | //
5 | // screenruster is free software: you can redistribute it and/or modify
6 | // it under the terms of the GNU General Public License as published by
7 | // the Free Software Foundation, either version 3 of the License, or
8 | // (at your option) any later version.
9 | //
10 | // screenruster is distributed in the hope that it will be useful,
11 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 | // GNU General Public License for more details.
14 | //
15 | // You should have received a copy of the GNU General Public License
16 | // along with screenruster. If not, see .
17 |
18 | use std::thread;
19 | use std::sync::Arc;
20 | use std::time::Duration;
21 | use std::ops::Deref;
22 |
23 | use xcb;
24 | use log::warn;
25 |
26 | use crate::error;
27 | use super::Display;
28 | use crate::platform;
29 |
30 | pub struct Window {
31 | display: Arc,
32 | window: platform::Window,
33 | gc: u32,
34 | cursor: u32,
35 |
36 | locked: bool,
37 | keyboard: bool,
38 | pointer: bool,
39 | }
40 |
41 | #[derive(Eq, PartialEq, Copy, Clone, Debug)]
42 | pub enum Grab {
43 | Keyboard,
44 | Pointer,
45 | }
46 |
47 | impl Window {
48 | pub fn create(display: Arc, index: i32) -> error::Result {
49 | let screen = display.get_setup().roots().nth(display.screen() as usize).unwrap();
50 | let window = platform::Window::create((**display).clone(), display.screen(),
51 | screen.width_in_pixels() as u32, screen.height_in_pixels() as u32)?;
52 |
53 | let cursor = {
54 | let pixmap = display.generate_id();
55 | xcb::create_pixmap(&display, 1, pixmap, screen.root(), 1, 1);
56 |
57 | let cursor = display.generate_id();
58 | xcb::create_cursor(&display, cursor, pixmap, pixmap, 0, 0, 0, 0, 0, 0, 1, 1);
59 | xcb::free_pixmap(&display, pixmap);
60 |
61 | cursor
62 | };
63 |
64 | xcb::change_window_attributes(&display, window.id(), &[
65 | (xcb::CW_CURSOR, cursor),
66 | (xcb::CW_OVERRIDE_REDIRECT, 1)]);
67 |
68 | xcb::change_property(&display, xcb::PROP_MODE_REPLACE as u8, window.id(),
69 | xcb::intern_atom(&display, false, "SCREENRUSTER_SAVER").get_reply()?.atom(),
70 | xcb::ATOM_CARDINAL, 32, &[index]);
71 |
72 | let gc = display.generate_id();
73 | xcb::create_gc(&display, gc, window.id(), &[(xcb::GC_FOREGROUND, screen.black_pixel())]);
74 |
75 | display.flush();
76 |
77 | Ok(Window {
78 | display: display.clone(),
79 | window: window,
80 | gc: gc,
81 | cursor: cursor,
82 |
83 | locked: false,
84 | keyboard: false,
85 | pointer: false,
86 | })
87 | }
88 |
89 | /// Check if the window is locked.
90 | pub fn is_locked(&self) -> bool {
91 | self.locked
92 | }
93 |
94 | /// Check if the window grabbed the keyboard.
95 | pub fn has_keyboard(&self) -> bool {
96 | self.keyboard
97 | }
98 |
99 | /// Check if the window grabbed the pointer.
100 | pub fn has_pointer(&self) -> bool {
101 | self.pointer
102 | }
103 |
104 | /// Sanitize the window.
105 | pub fn sanitize(&mut self) {
106 | if self.locked {
107 | // Try to grab the keyboard again in case it wasn't grabbed when locking.
108 | if !self.keyboard && self.grab(Grab::Keyboard).is_ok() {
109 | self.keyboard = true;
110 | }
111 |
112 | // Try to grab the pointer again in case it wasn't grabbed when locking.
113 | if !self.pointer && self.grab(Grab::Pointer).is_ok() {
114 | self.pointer = true;
115 | }
116 |
117 | // Remap the window in case stuff like popups went above the locker.
118 | xcb::map_window(&self.display, self.id());
119 | xcb::configure_window(&self.display, self.id(), &[
120 | (xcb::CONFIG_WINDOW_STACK_MODE as u16, xcb::STACK_MODE_ABOVE)]);
121 | }
122 | }
123 |
124 | /// Grab the given input.
125 | pub fn grab(&self, grab: Grab) -> error::Result<()> {
126 | let result = match grab {
127 | Grab::Keyboard => {
128 | xcb::grab_keyboard(&self.display, false, self.id(), xcb::CURRENT_TIME,
129 | xcb::GRAB_MODE_ASYNC as u8, xcb::GRAB_MODE_ASYNC as u8
130 | ).get_reply()?.status()
131 | }
132 |
133 | Grab::Pointer => {
134 | xcb::grab_pointer(&self.display, false, self.id(),
135 | (xcb::EVENT_MASK_BUTTON_PRESS | xcb::EVENT_MASK_BUTTON_RELEASE | xcb::EVENT_MASK_POINTER_MOTION) as u16,
136 | xcb::GRAB_MODE_ASYNC as u8, xcb::GRAB_MODE_ASYNC as u8, 0, self.cursor, xcb::CURRENT_TIME
137 | ).get_reply()?.status()
138 | }
139 | };
140 |
141 | match result as u32 {
142 | xcb::GRAB_STATUS_SUCCESS =>
143 | Ok(()),
144 |
145 | xcb::GRAB_STATUS_ALREADY_GRABBED =>
146 | Err(error::Grab::Conflict.into()),
147 |
148 | xcb::GRAB_STATUS_NOT_VIEWABLE =>
149 | Err(error::Grab::Unmapped.into()),
150 |
151 | xcb::GRAB_STATUS_FROZEN =>
152 | Err(error::Grab::Frozen.into()),
153 |
154 | _ =>
155 | unreachable!()
156 | }
157 | }
158 |
159 | /// Try to grab the given input with 1ms pauses.
160 | pub fn try_grab(&self, grab: Grab, tries: usize) -> error::Result<()> {
161 | let mut result = Ok(());
162 |
163 | for _ in 0 .. tries {
164 | result = self.grab(grab);
165 |
166 | if result.is_ok() {
167 | break;
168 | }
169 |
170 | thread::sleep(Duration::from_millis(1));
171 | }
172 |
173 | result
174 | }
175 |
176 | /// Lock the window.
177 | pub fn lock(&mut self) -> error::Result<()> {
178 | if self.locked {
179 | return Ok(());
180 | }
181 |
182 | // Map the window and make sure it's raised.
183 | xcb::map_window(&self.display, self.id());
184 | xcb::configure_window(&self.display, self.id(), &[
185 | (xcb::CONFIG_WINDOW_STACK_MODE as u16, xcb::STACK_MODE_ABOVE)]);
186 |
187 | // Try to grab the keyboard and mouse.
188 | self.keyboard = self.try_grab(Grab::Keyboard, 500).is_ok();
189 | self.pointer = self.try_grab(Grab::Pointer, 500).is_ok();
190 |
191 | // Some retarded X11 applications grab the keyboard and pointer for long
192 | // periods of time for no reason, so try to change focus and grab again.
193 | if !self.keyboard || !self.pointer {
194 | warn!("could not grab keyboard or pointer, trying to change focus");
195 |
196 | xcb::set_input_focus(&self.display, xcb::INPUT_FOCUS_POINTER_ROOT as u8, self.id(), xcb::CURRENT_TIME);
197 | self.flush();
198 |
199 | // Failing to grab the keyboard is fatal since the window manager or
200 | // other applications may be stealing our thunder.
201 | if !self.keyboard {
202 | if let Err(err) = self.try_grab(Grab::Keyboard, 500) {
203 | warn!("could not grab pointer: {:?}", err);
204 | }
205 | else {
206 | self.keyboard = true;
207 | }
208 | }
209 |
210 | if !self.pointer {
211 | if let Err(err) = self.try_grab(Grab::Pointer, 500) {
212 | warn!("could not grab pointer: {:?}", err);
213 | }
214 | else {
215 | self.pointer = true;
216 | }
217 | }
218 | }
219 |
220 | // Listen for window change events.
221 | xcb::change_window_attributes(&self.display, self.root(), &[
222 | (xcb::CW_EVENT_MASK, xcb::EVENT_MASK_SUBSTRUCTURE_NOTIFY)]);
223 |
224 | // If the display supports XRandr listen for screen change events.
225 | if self.display.randr().is_some() {
226 | xcb::randr::select_input(&self.display, self.id(),
227 | xcb::randr::NOTIFY_MASK_SCREEN_CHANGE as u16);
228 | }
229 |
230 | self.locked = true;
231 |
232 | Ok(())
233 | }
234 |
235 | /// Notify the window the power status changed.
236 | pub fn power(&mut self, value: bool) {
237 | if !value {
238 | xcb::change_window_attributes(&self.display, self.id(), &[
239 | (xcb::CW_BACK_PIXEL, self.black())]);
240 | }
241 | }
242 |
243 | /// Make the window solid black.
244 | pub fn blank(&mut self) {
245 | let (width, height) = self.dimensions();
246 |
247 | xcb::poly_fill_rectangle(&self.display, self.id(), self.gc, &[
248 | xcb::Rectangle::new(0, 0, width as u16, height as u16)]);
249 |
250 | self.flush();
251 | }
252 |
253 | /// Unlock the window, hiding and ungrabbing whatever.
254 | pub fn unlock(&mut self) -> error::Result<()> {
255 | if !self.locked {
256 | return Ok(());
257 | }
258 |
259 | xcb::ungrab_keyboard(&self.display, xcb::CURRENT_TIME);
260 | self.keyboard = false;
261 |
262 | xcb::ungrab_pointer(&self.display, xcb::CURRENT_TIME);
263 | self.pointer = false;
264 |
265 | xcb::unmap_window(&self.display, self.id());
266 | self.locked = false;
267 |
268 | self.flush();
269 |
270 | Ok(())
271 | }
272 | }
273 |
274 | impl Deref for Window {
275 | type Target = platform::Window;
276 |
277 | fn deref(&self) -> &Self::Target {
278 | &self.window
279 | }
280 | }
281 |
--------------------------------------------------------------------------------
/src/main.rs:
--------------------------------------------------------------------------------
1 | // Copyleft (ↄ) meh. | http://meh.schizofreni.co
2 | //
3 | // This file is part of screenruster.
4 | //
5 | // screenruster is free software: you can redistribute it and/or modify
6 | // it under the terms of the GNU General Public License as published by
7 | // the Free Software Foundation, either version 3 of the License, or
8 | // (at your option) any later version.
9 | //
10 | // screenruster is distributed in the hope that it will be useful,
11 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 | // GNU General Public License for more details.
14 | //
15 | // You should have received a copy of the GNU General Public License
16 | // along with screenruster. If not, see .
17 |
18 | use clap::{ArgMatches, Arg, App, SubCommand};
19 | use channel::select;
20 | use log::info;
21 |
22 | mod error;
23 |
24 | mod config;
25 | use config::Config;
26 |
27 | mod platform;
28 | mod saver;
29 |
30 | mod preview;
31 | use preview::Preview;
32 |
33 | mod locker;
34 | use locker::Locker;
35 |
36 | mod auth;
37 | use auth::Auth;
38 |
39 | mod interface;
40 | use interface::Interface;
41 |
42 | mod timer;
43 | use timer::Timer;
44 |
45 | fn main() {
46 | env_logger::init();
47 |
48 | let mut app = App::new("screenruster")
49 | .version(env!("CARGO_PKG_VERSION"))
50 | .author("meh. ")
51 | .subcommand(SubCommand::with_name("reload")
52 | .about("Reload the configuration file.")
53 | .arg(Arg::with_name("config")
54 | .short("c")
55 | .long("config")
56 | .help("The path to the configuration file to use as replacement.")
57 | .takes_value(true)))
58 | .subcommand(SubCommand::with_name("lock")
59 | .about("Lock the screen."))
60 | .subcommand(SubCommand::with_name("activate")
61 | .about("Activate the screen saver."))
62 | .subcommand(SubCommand::with_name("deactivate")
63 | .about("Deactivate the screen saver like there was user input."))
64 | .subcommand(SubCommand::with_name("inhibit")
65 | .about("Inhibit the screen saver until uninhibit is called."))
66 | .subcommand(SubCommand::with_name("uninhibit")
67 | .about("Uninhibit a previous inhibition.")
68 | .arg(Arg::with_name("COOKIE")
69 | .required(true)
70 | .index(1)
71 | .help("The previously returned cookie.")))
72 | .subcommand(SubCommand::with_name("throttle")
73 | .about("Throttle the screen saver until unthrottle is called."))
74 | .subcommand(SubCommand::with_name("unthrottle")
75 | .about("Unthrottle a previous throttle.")
76 | .arg(Arg::with_name("COOKIE")
77 | .required(true)
78 | .index(1)
79 | .help("The previously returned cookie.")))
80 | .subcommand(SubCommand::with_name("suspend")
81 | .about("Prepare the saver for suspension."))
82 | .subcommand(SubCommand::with_name("resume")
83 | .about("Prepare the saver for resuming from suspension.")
84 | .arg(Arg::with_name("COOKIE")
85 | .required(true)
86 | .index(1)
87 | .help("The previously returned cookie.")))
88 | .subcommand(SubCommand::with_name("preview")
89 | .about("Preview a saver.")
90 | .arg(Arg::with_name("config")
91 | .short("c")
92 | .long("config")
93 | .help("The path to the configuration file.")
94 | .takes_value(true))
95 | .arg(Arg::with_name("SAVER")
96 | .required(true)
97 | .index(1)
98 | .help("The saver name.")))
99 | .subcommand(SubCommand::with_name("daemon")
100 | .about("Start the daemon.")
101 | .arg(Arg::with_name("config")
102 | .short("c")
103 | .long("config")
104 | .help("The path to the configuration file.")
105 | .takes_value(true)));
106 |
107 | let matches = app.clone().get_matches();
108 |
109 | exit(match matches.subcommand() {
110 | ("reload", Some(submatches)) =>
111 | Interface::reload(submatches.value_of("config")),
112 |
113 | ("lock", Some(_)) =>
114 | Interface::lock(),
115 |
116 | ("activate", Some(_)) =>
117 | Interface::activate(),
118 |
119 | ("deactivate", Some(_)) =>
120 | Interface::deactivate(),
121 |
122 | ("inhibit", Some(_)) =>
123 | Interface::inhibit().map(|v| println!("{}", v)),
124 |
125 | ("uninhibit", Some(submatches)) =>
126 | Interface::uninhibit(submatches.value_of("COOKIE").unwrap().parse::().unwrap()),
127 |
128 | ("throttle", Some(_)) =>
129 | Interface::throttle().map(|v| println!("{}", v)),
130 |
131 | ("unthrottle", Some(submatches)) =>
132 | Interface::unthrottle(submatches.value_of("COOKIE").unwrap().parse::().unwrap()),
133 |
134 | ("suspend", Some(_)) =>
135 | Interface::suspend().map(|v| println!("{}", v)),
136 |
137 | ("resume", Some(submatches)) =>
138 | Interface::resume(submatches.value_of("COOKIE").unwrap().parse::().unwrap()),
139 |
140 | ("preview", Some(submatches)) =>
141 | preview(submatches),
142 |
143 | ("daemon", Some(submatches)) =>
144 | daemon(submatches),
145 |
146 | _ =>
147 | app.print_help().map_err(|e| e.into())
148 | });
149 | }
150 |
151 | fn exit(value: error::Result) -> T {
152 | use std::io::Write;
153 | use error::Error;
154 |
155 | macro_rules! error {
156 | ($code:expr, $message:expr) => (
157 | error!($code, "{}", $message);
158 | );
159 |
160 | ($code:expr, $message:expr, $($rest:tt)*) => ({
161 | write!(&mut ::std::io::stderr(), "ERROR: ").unwrap();
162 | writeln!(&mut ::std::io::stderr(), $message, $($rest)*).unwrap();
163 | std::process::exit($code);
164 | });
165 | }
166 |
167 | match value {
168 | Ok(value) =>
169 | value,
170 |
171 | Err(error) => match error {
172 | Error::DBus(error::DBus::AlreadyRegistered) =>
173 | error!(10, "Another screen saver is currently running."),
174 |
175 | Error::DBus(_) =>
176 | error!(11, "The daemon is not running."),
177 |
178 | ref err =>
179 | error!(255, err),
180 | }
181 | }
182 | }
183 |
184 | fn preview(matches: &ArgMatches) -> error::Result<()> {
185 | let config = Config::load(matches.value_of("config"))?;
186 | let preview = Preview::spawn(matches.value_of("SAVER").unwrap(), config)?;
187 |
188 | loop {
189 | match preview.recv().unwrap() {
190 | preview::Response::Done => {
191 | break;
192 | }
193 | }
194 | }
195 |
196 | Ok(())
197 | }
198 |
199 | fn daemon(matches: &ArgMatches) -> error::Result<()> {
200 | use std::time::{Instant, SystemTime};
201 | use std::collections::HashSet;
202 | use rand::Rng;
203 |
204 | // Timer report IDs.
205 | const GET_ACTIVE_TIME: u64 = 1;
206 | const GET_SESSION_IDLE: u64 = 2;
207 | const GET_SESSION_IDLE_TIME: u64 = 3;
208 |
209 | // How many seconds to wait before acting on an Activity after one was
210 | // already acted upon.
211 | const ACTIVATION: u64 = 1;
212 |
213 | fn insert(set: &mut HashSet) -> u32 {
214 | loop {
215 | let cookie = rand::thread_rng().gen();
216 |
217 | if set.contains(&cookie) {
218 | continue;
219 | }
220 |
221 | set.insert(cookie);
222 |
223 | return cookie;
224 | }
225 | }
226 |
227 | let config = Config::load(matches.value_of("config"))?;
228 | let timer = Timer::spawn(config.timer())?;
229 | let auth = Auth::spawn(config.auth())?;
230 | let interface = Interface::spawn(config.interface())?;
231 | let locker = Locker::spawn(config.clone())?;
232 |
233 | let mut locked = None::;
234 | let mut started = None::;
235 | let mut blanked = None::;
236 | let mut suspended = None::;
237 |
238 | let mut inhibitors = HashSet::new();
239 | let mut throttlers = HashSet::new();
240 | let mut suspenders = HashSet::new();
241 |
242 | macro_rules! act {
243 | (suspend) => (
244 | act!(suspend SystemTime::now())
245 | );
246 |
247 | (suspend $time:expr) => (
248 | if suspenders.is_empty() && suspended.is_none() {
249 | timer.suspend($time).unwrap();
250 | }
251 | );
252 |
253 | (resume) => (
254 | if suspenders.is_empty() && suspended.is_some() {
255 | if blanked.is_some() {
256 | act!(unblank);
257 | }
258 |
259 | timer.resume().unwrap();
260 | }
261 | );
262 |
263 | (blank) => (
264 | blanked = Some(Instant::now());
265 |
266 | locker.power(false).unwrap();
267 | timer.blanked().unwrap();
268 | );
269 |
270 | (unblank) => (
271 | blanked = None;
272 |
273 | locker.power(true).unwrap();
274 | timer.unblanked().unwrap();
275 | );
276 |
277 | (start) => (
278 | started = Some(Instant::now());
279 |
280 | locker.start().unwrap();
281 | interface.signal(interface::Signal::Active(true)).unwrap();
282 | timer.started().unwrap();
283 | );
284 |
285 | (lock) => (
286 | locked = Some(Instant::now());
287 |
288 | locker.lock().unwrap();
289 | timer.locked().unwrap();
290 | );
291 |
292 | (stop) => (
293 | locker.stop().unwrap();
294 | );
295 |
296 | (stopped) => (
297 | started = None;
298 | locked = None;
299 |
300 | interface.signal(interface::Signal::Active(false)).unwrap();
301 | timer.stopped().unwrap();
302 | );
303 |
304 | (auth < $value:expr) => (
305 | interface.signal(interface::Signal::AuthenticationRequest(true)).unwrap();
306 | auth.authenticate($value).unwrap();
307 | );
308 |
309 | (auth success) => (
310 | locker.auth(true).unwrap();
311 | interface.signal(interface::Signal::AuthenticationRequest(false)).unwrap();
312 | );
313 |
314 | (auth failure) => (
315 | locker.auth(false).unwrap();
316 | interface.signal(interface::Signal::AuthenticationRequest(false)).unwrap();
317 | );
318 | }
319 |
320 | loop {
321 | select! {
322 | // Locker events.
323 | recv(locker) -> event => {
324 | match event.unwrap() {
325 | // Register timeout.
326 | locker::Response::Timeout(what) => {
327 | timer.timeout(what).unwrap();
328 | }
329 |
330 | // On system activity.
331 | locker::Response::Activity => {
332 | if suspended.is_some() {
333 | continue;
334 | }
335 |
336 | // Always reset the blank timer.
337 | timer.reset(timer::Event::Blank).unwrap();
338 |
339 | if blanked.is_some() {
340 | act!(unblank);
341 | }
342 |
343 | // If the saver has started but the screen is not locked, unlock
344 | // it, otherwise just reset the timers.
345 | if let Some(at) = started {
346 | if locked.is_none() && at.elapsed().as_secs() >= ACTIVATION {
347 | act!(stop);
348 | }
349 | }
350 | else {
351 | timer.reset(timer::Event::Idle).unwrap();
352 | }
353 | }
354 |
355 | // Try authorization.
356 | locker::Response::Password(pwd) => {
357 | act!(auth < pwd);
358 | }
359 |
360 | locker::Response::Stopped => {
361 | act!(stopped);
362 | }
363 | }
364 | },
365 |
366 | // Authentication events.
367 | recv(auth) -> event => {
368 | match event.unwrap() {
369 | auth::Response::Success => {
370 | info!("authorization: success");
371 |
372 | act!(auth success);
373 | act!(stop);
374 | }
375 |
376 | auth::Response::Failure => {
377 | info!("authorization: failure");
378 |
379 | act!(auth failure);
380 | }
381 | }
382 | },
383 |
384 | // DBus events.
385 | recv(interface) -> event => {
386 | match event.unwrap() {
387 | interface::Request::Reload(source) => {
388 | config.reset();
389 | interface.response(interface::Response::Reload(
390 | config.reload(source).is_ok())).unwrap();
391 | }
392 |
393 | interface::Request::Lock => {
394 | if started.is_none() {
395 | act!(start);
396 | }
397 |
398 | if locked.is_none() {
399 | act!(lock);
400 | }
401 | }
402 |
403 | // TODO: Implement cycling.
404 | interface::Request::Cycle => (),
405 |
406 | interface::Request::SimulateUserActivity => {
407 | locker.activity().unwrap();
408 | }
409 |
410 | interface::Request::Inhibit { .. } => {
411 | interface.response(interface::Response::Inhibit(insert(&mut inhibitors))).unwrap();
412 | }
413 |
414 | interface::Request::UnInhibit(cookie) => {
415 | if inhibitors.contains(&cookie) {
416 | inhibitors.remove(&cookie);
417 | }
418 | }
419 |
420 | interface::Request::Throttle { .. } => {
421 | if throttlers.is_empty() && !config.saver().throttle() {
422 | locker.throttle(true).unwrap();
423 | }
424 |
425 | interface.response(interface::Response::Throttle(insert(&mut throttlers))).unwrap();
426 | }
427 |
428 | interface::Request::UnThrottle(cookie) => {
429 | if throttlers.contains(&cookie) {
430 | throttlers.remove(&cookie);
431 |
432 | if throttlers.is_empty() && !config.saver().throttle() {
433 | locker.throttle(false).unwrap();
434 | }
435 | }
436 | }
437 |
438 | interface::Request::SetActive(active) => {
439 | if active {
440 | if started.is_none() {
441 | act!(start);
442 | }
443 | }
444 | else {
445 | if started.is_some() && locked.is_none() {
446 | act!(stop);
447 | }
448 | }
449 | }
450 |
451 | interface::Request::GetActive => {
452 | interface.response(interface::Response::Active(started.is_some())).unwrap();
453 | }
454 |
455 | interface::Request::GetActiveTime => {
456 | timer.report(GET_ACTIVE_TIME).unwrap();
457 | }
458 |
459 | interface::Request::GetSessionIdle => {
460 | timer.report(GET_SESSION_IDLE).unwrap();
461 | }
462 |
463 | interface::Request::GetSessionIdleTime => {
464 | timer.report(GET_SESSION_IDLE_TIME).unwrap();
465 | }
466 |
467 | interface::Request::Suspend { .. } => {
468 | act!(suspend);
469 |
470 | interface.response(interface::Response::Suspend(insert(&mut suspenders))).unwrap();
471 | }
472 |
473 | interface::Request::Resume(cookie) => {
474 | if suspenders.contains(&cookie) {
475 | suspenders.remove(&cookie);
476 |
477 | act!(resume);
478 | }
479 | }
480 |
481 | interface::Request::PrepareForSleep(time) => {
482 | if let Some(time) = time {
483 | match config.locker().on_suspend() {
484 | config::OnSuspend::Ignore |
485 | config::OnSuspend::Activate |
486 | config::OnSuspend::Lock => (),
487 |
488 | config::OnSuspend::UseSystemTime => {
489 | act!(suspend time);
490 | }
491 | }
492 | }
493 | else {
494 | match config.locker().on_suspend() {
495 | config::OnSuspend::Ignore => (),
496 |
497 | config::OnSuspend::UseSystemTime => {
498 | act!(resume);
499 | }
500 |
501 | config::OnSuspend::Activate => {
502 | act!(start);
503 | }
504 |
505 | config::OnSuspend::Lock => {
506 | act!(start);
507 | act!(lock);
508 | }
509 | }
510 | }
511 | }
512 | }
513 | },
514 |
515 | // Timer events.
516 | recv(timer) -> event => {
517 | match event.unwrap() {
518 | timer::Response::Report { id: GET_ACTIVE_TIME, started, .. } => {
519 | interface.response(interface::Response::ActiveTime(started.map_or(0, |i| i.elapsed().as_secs()))).unwrap();
520 | }
521 |
522 | timer::Response::Report { id: GET_SESSION_IDLE, idle, .. } => {
523 | interface.response(interface::Response::SessionIdle(idle.elapsed().as_secs() >= 5)).unwrap();
524 | }
525 |
526 | timer::Response::Report { id: GET_SESSION_IDLE_TIME, idle, .. } => {
527 | interface.response(interface::Response::SessionIdleTime(idle.elapsed().as_secs())).unwrap();
528 | }
529 |
530 | timer::Response::Report { .. } => {
531 | unreachable!();
532 | }
533 |
534 | timer::Response::Timeout { id } => {
535 | locker.timeout(id).unwrap();
536 | }
537 |
538 | timer::Response::Suspended(time) => {
539 | suspended = Some(time);
540 | }
541 |
542 | timer::Response::Resumed => {
543 | suspended = None;
544 | }
545 |
546 | timer::Response::Heartbeat(idle) => {
547 | locker.sanitize().unwrap();
548 |
549 | if idle.elapsed().as_secs() > 5 {
550 | interface.signal(interface::Signal::SessionIdle(true)).unwrap()
551 | }
552 | else {
553 | interface.signal(interface::Signal::SessionIdle(false)).unwrap()
554 | }
555 | }
556 |
557 | timer::Response::Start => {
558 | if inhibitors.is_empty() {
559 | act!(start);
560 | }
561 | else {
562 | timer.stopped().unwrap();
563 | }
564 | }
565 |
566 | timer::Response::Lock => {
567 | act!(lock);
568 | }
569 |
570 | timer::Response::Blank => {
571 | if inhibitors.is_empty() {
572 | act!(blank);
573 | }
574 | else {
575 | timer.unblanked().unwrap();
576 | }
577 | }
578 | }
579 | }
580 | }
581 | }
582 | }
583 |
--------------------------------------------------------------------------------
/src/platform/display.rs:
--------------------------------------------------------------------------------
1 | // Copyleft (ↄ) meh. | http://meh.schizofreni.co
2 | //
3 | // This file is part of screenruster.
4 | //
5 | // screenruster is free software: you can redistribute it and/or modify
6 | // it under the terms of the GNU General Public License as published by
7 | // the Free Software Foundation, either version 3 of the License, or
8 | // (at your option) any later version.
9 | //
10 | // screenruster is distributed in the hope that it will be useful,
11 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 | // GNU General Public License for more details.
14 | //
15 | // You should have received a copy of the GNU General Public License
16 | // along with screenruster. If not, see .
17 |
18 | use std::sync::Arc;
19 | use std::ops::Deref;
20 | use std::thread;
21 | use channel;
22 |
23 | use xcb;
24 | use xcbu::ewmh;
25 |
26 | use crate::error;
27 |
28 | pub struct Display {
29 | connection: ewmh::Connection,
30 |
31 | screen: i32,
32 | name: Option,
33 | }
34 |
35 | impl Display {
36 | pub fn open(name: Option) -> error::Result> {
37 | let (connection, screen) = xcb::Connection::connect(name.as_ref().map(AsRef::as_ref))?;
38 | let connection = ewmh::Connection::connect(connection).map_err(|(e, _)| e)?;
39 |
40 | Ok(Arc::new(Display {
41 | connection, screen, name
42 | }))
43 | }
44 |
45 | pub fn screen(&self) -> i32 {
46 | self.screen
47 | }
48 |
49 | pub fn name(&self) -> Option<&str> {
50 | self.name.as_ref().map(AsRef::as_ref)
51 | }
52 |
53 | pub fn screens(&self) -> u8 {
54 | self.get_setup().roots_len()
55 | }
56 | }
57 |
58 | pub fn sink(display: &Arc) -> channel::Receiver {
59 | let (sender, receiver) = channel::bounded(1);
60 | let display = display.clone();
61 |
62 | // Drain events into a channel.
63 | thread::spawn(move || {
64 | while let Some(event) = display.wait_for_event() {
65 | sender.send(event).unwrap();
66 | }
67 | });
68 |
69 | receiver
70 | }
71 |
72 | impl Deref for Display {
73 | type Target = xcb::Connection;
74 |
75 | fn deref(&self) -> &Self::Target {
76 | &self.connection
77 | }
78 | }
79 |
--------------------------------------------------------------------------------
/src/platform/keyboard.rs:
--------------------------------------------------------------------------------
1 | // Copyleft (ↄ) meh. | http://meh.schizofreni.co
2 | //
3 | // This file is part of screenruster.
4 | //
5 | // screenruster is free software: you can redistribute it and/or modify
6 | // it under the terms of the GNU General Public License as published by
7 | // the Free Software Foundation, either version 3 of the License, or
8 | // (at your option) any later version.
9 | //
10 | // screenruster is distributed in the hope that it will be useful,
11 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 | // GNU General Public License for more details.
14 | //
15 | // You should have received a copy of the GNU General Public License
16 | // along with screenruster. If not, see .
17 |
18 | use std::sync::Arc;
19 | use std::env;
20 |
21 | use xcb;
22 | use xkb;
23 |
24 | use crate::error;
25 | use super::Display;
26 |
27 | /// Keyboard manager and handler.
28 | ///
29 | /// Its job is to map X key events to proper symbols/strings based on the
30 | /// layout and mappings.
31 | pub struct Keyboard {
32 | display: Arc,
33 | context: xkb::Context,
34 | device: i32,
35 | keymap: xkb::Keymap,
36 | state: xkb::State,
37 | #[allow(dead_code)]
38 | table: xkb::compose::Table,
39 | compose: xkb::compose::State,
40 | }
41 |
42 | unsafe impl Send for Keyboard { }
43 | unsafe impl Sync for Keyboard { }
44 |
45 | impl Keyboard {
46 | /// Create a keyboard for the given display.
47 | pub fn new(display: Arc, locale: Option<&str>) -> error::Result {
48 | display.get_extension_data(xcb::xkb::id())
49 | .ok_or(error::X::MissingExtension)?;
50 |
51 | // Check the XKB extension version.
52 | {
53 | let cookie = xcb::xkb::use_extension(&display,
54 | xkb::x11::MIN_MAJOR_XKB_VERSION,
55 | xkb::x11::MIN_MINOR_XKB_VERSION);
56 |
57 | if !cookie.get_reply()?.supported() {
58 | return Err(error::X::MissingExtension.into());
59 | }
60 | }
61 |
62 | // Select events.
63 | {
64 | let map =
65 | xcb::xkb::MAP_PART_KEY_TYPES |
66 | xcb::xkb::MAP_PART_KEY_SYMS |
67 | xcb::xkb::MAP_PART_MODIFIER_MAP |
68 | xcb::xkb::MAP_PART_EXPLICIT_COMPONENTS |
69 | xcb::xkb::MAP_PART_KEY_ACTIONS |
70 | xcb::xkb::MAP_PART_KEY_BEHAVIORS |
71 | xcb::xkb::MAP_PART_VIRTUAL_MODS |
72 | xcb::xkb::MAP_PART_VIRTUAL_MOD_MAP;
73 |
74 | let events =
75 | xcb::xkb::EVENT_TYPE_NEW_KEYBOARD_NOTIFY |
76 | xcb::xkb::EVENT_TYPE_MAP_NOTIFY |
77 | xcb::xkb::EVENT_TYPE_STATE_NOTIFY;
78 |
79 | xcb::xkb::select_events_checked(&display,
80 | xcb::xkb::ID_USE_CORE_KBD as u16,
81 | events as u16, 0, events as u16,
82 | map as u16, map as u16, None).request_check()?;
83 | }
84 |
85 | let context = xkb::Context::default();
86 | let device = xkb::x11::device(&display)?;
87 | let keymap = xkb::x11::keymap(&display, device, &context, Default::default())?;
88 | let state = xkb::x11::state(&display, device, &keymap)?;
89 |
90 | let (table, compose) = {
91 | let locale = locale.map(String::from).or(env::var("LANG").ok()).unwrap_or("C".into());
92 | let table = if let Ok(table) = xkb::compose::Table::new(&context, &locale, Default::default()) {
93 | table
94 | }
95 | else {
96 | xkb::compose::Table::new(&context, "C", Default::default()).unwrap()
97 | };
98 |
99 | let state = table.state(Default::default());
100 |
101 | (table, state)
102 | };
103 |
104 | Ok(Keyboard { display, context, device, keymap, state, table, compose })
105 | }
106 |
107 | /// Get the extension data.
108 | pub fn extension(&self) -> xcb::QueryExtensionData {
109 | self.display.get_extension_data(xcb::xkb::id()).unwrap()
110 | }
111 |
112 | /// Checks if an event belongs to the keyboard.
113 | pub fn owns_event(&self, event: u8) -> bool {
114 | event >= self.extension().first_event() &&
115 | event < self.extension().first_event() + xcb::xkb::EXTENSION_DEVICE_NOTIFY
116 | }
117 |
118 | /// Handles an X event.
119 | pub fn handle(&mut self, event: &xcb::GenericEvent) {
120 | match event.response_type() - self.extension().first_event() {
121 | xcb::xkb::NEW_KEYBOARD_NOTIFY | xcb::xkb::MAP_NOTIFY => {
122 | self.keymap = xkb::x11::keymap(&self.display, self.device, &self.context, Default::default()).unwrap();
123 | self.state = xkb::x11::state(&self.display, self.device, &self.keymap).unwrap();
124 | }
125 |
126 | xcb::xkb::STATE_NOTIFY => {
127 | let event = unsafe { xcb::cast_event::(event) };
128 |
129 | self.state.update().mask(
130 | event.base_mods(),
131 | event.latched_mods(),
132 | event.locked_mods(),
133 | event.base_group(),
134 | event.latched_group(),
135 | event.locked_group());
136 | }
137 |
138 | _ => ()
139 | }
140 | }
141 |
142 | /// Translate a key code to the key symbol.
143 | pub fn symbol(&self, code: u8) -> Option {
144 | self.state.key(code).sym()
145 | }
146 |
147 | /// Translate a key code to an UTF-8 string.
148 | pub fn string(&self, code: u8) -> Option {
149 | self.state.key(code).utf8()
150 | }
151 | }
152 |
--------------------------------------------------------------------------------
/src/platform/mod.rs:
--------------------------------------------------------------------------------
1 | // Copyleft (ↄ) meh. | http://meh.schizofreni.co
2 | //
3 | // This file is part of screenruster.
4 | //
5 | // screenruster is free software: you can redistribute it and/or modify
6 | // it under the terms of the GNU General Public License as published by
7 | // the Free Software Foundation, either version 3 of the License, or
8 | // (at your option) any later version.
9 | //
10 | // screenruster is distributed in the hope that it will be useful,
11 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 | // GNU General Public License for more details.
14 | //
15 | // You should have received a copy of the GNU General Public License
16 | // along with screenruster. If not, see .
17 |
18 | pub mod display;
19 | pub use self::display::Display;
20 |
21 | mod window;
22 | pub use self::window::Window;
23 |
24 | mod keyboard;
25 | pub use self::keyboard::Keyboard;
26 |
--------------------------------------------------------------------------------
/src/platform/window.rs:
--------------------------------------------------------------------------------
1 | // Copyleft (ↄ) meh. | http://meh.schizofreni.co
2 | //
3 | // This file is part of screenruster.
4 | //
5 | // screenruster is free software: you can redistribute it and/or modify
6 | // it under the terms of the GNU General Public License as published by
7 | // the Free Software Foundation, either version 3 of the License, or
8 | // (at your option) any later version.
9 | //
10 | // screenruster is distributed in the hope that it will be useful,
11 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 | // GNU General Public License for more details.
14 | //
15 | // You should have received a copy of the GNU General Public License
16 | // along with screenruster. If not, see .
17 |
18 | use std::sync::Arc;
19 |
20 | use xcb;
21 |
22 | use crate::error;
23 | use super::Display;
24 |
25 | pub struct Window {
26 | display: Arc,
27 |
28 | id: u32,
29 | screen: i32,
30 | root: u32,
31 | black: u32,
32 | }
33 |
34 | unsafe impl Send for Window { }
35 | unsafe impl Sync for Window { }
36 |
37 | impl Window {
38 | pub fn create(display: Arc, index: i32, width: u32, height: u32) -> error::Result {
39 | let screen = display.get_setup().roots().nth(index as usize).unwrap();
40 | let id = display.generate_id();
41 |
42 | xcb::create_window(&display, xcb::COPY_FROM_PARENT as u8, id, screen.root(),
43 | 0, 0, width as u16, height as u16,
44 | 0, xcb::WINDOW_CLASS_INPUT_OUTPUT as u16, screen.root_visual(), &[
45 | (xcb::CW_BORDER_PIXEL, screen.black_pixel()),
46 | (xcb::CW_BACKING_PIXEL, screen.black_pixel()),
47 | (xcb::CW_BACKING_STORE, xcb::BACKING_STORE_NOT_USEFUL),
48 | (xcb::CW_EVENT_MASK,
49 | xcb::EVENT_MASK_KEY_PRESS |
50 | xcb::EVENT_MASK_KEY_RELEASE |
51 | xcb::EVENT_MASK_BUTTON_PRESS |
52 | xcb::EVENT_MASK_BUTTON_RELEASE |
53 | xcb::EVENT_MASK_POINTER_MOTION |
54 | xcb::EVENT_MASK_STRUCTURE_NOTIFY |
55 | xcb::EVENT_MASK_EXPOSURE)]);
56 |
57 | display.flush();
58 |
59 | Ok(Window {
60 | display: display.clone(),
61 |
62 | id: id,
63 | screen: index,
64 | root: screen.root(),
65 | black: screen.black_pixel(),
66 | })
67 | }
68 |
69 | /// Flush the request queue.
70 | pub fn flush(&self) {
71 | self.display.flush();
72 | }
73 |
74 | /// Get the id.
75 | pub fn id(&self) -> u32 {
76 | self.id
77 | }
78 |
79 | /// Get the screen.
80 | pub fn screen(&self) -> i32 {
81 | self.screen
82 | }
83 |
84 | /// Get the screen root.
85 | pub fn root(&self) -> u32 {
86 | self.root
87 | }
88 |
89 | /// Get the black pixel.
90 | pub fn black(&self) -> u32 {
91 | self.black
92 | }
93 |
94 | /// Resize the window.
95 | pub fn resize(&self, width: u32, height: u32) {
96 | xcb::configure_window(&self.display, self.id(), &[
97 | (xcb::CONFIG_WINDOW_WIDTH as u16, width),
98 | (xcb::CONFIG_WINDOW_HEIGHT as u16, height)]);
99 |
100 | self.flush();
101 | }
102 |
103 | /// Get the dimensions.
104 | pub fn dimensions(&self) -> (u32, u32) {
105 | if let Ok(reply) = xcb::get_geometry(&self.display, self.id()).get_reply() {
106 | (reply.width() as u32, reply.height() as u32)
107 | }
108 | else {
109 | (0, 0)
110 | }
111 | }
112 | }
113 |
114 | impl Drop for Window {
115 | fn drop(&mut self) {
116 | xcb::destroy_window(&self.display, self.id);
117 | }
118 | }
119 |
--------------------------------------------------------------------------------
/src/preview/mod.rs:
--------------------------------------------------------------------------------
1 | // Copyleft (ↄ) meh. | http://meh.schizofreni.co
2 | //
3 | // This file is part of screenruster.
4 | //
5 | // screenruster is free software: you can redistribute it and/or modify
6 | // it under the terms of the GNU General Public License as published by
7 | // the Free Software Foundation, either version 3 of the License, or
8 | // (at your option) any later version.
9 | //
10 | // screenruster is distributed in the hope that it will be useful,
11 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 | // GNU General Public License for more details.
14 | //
15 | // You should have received a copy of the GNU General Public License
16 | // along with screenruster. If not, see .
17 |
18 | mod preview;
19 | pub use self::preview::{Preview, Request, Response};
20 |
21 | mod window;
22 | pub use self::window::Window;
23 |
--------------------------------------------------------------------------------
/src/preview/preview.rs:
--------------------------------------------------------------------------------
1 | // Copyleft (ↄ) meh. | http://meh.schizofreni.co
2 | //
3 | // This file is part of screenruster.
4 | //
5 | // screenruster is free software: you can redistribute it and/or modify
6 | // it under the terms of the GNU General Public License as published by
7 | // the Free Software Foundation, either version 3 of the License, or
8 | // (at your option) any later version.
9 | //
10 | // screenruster is distributed in the hope that it will be useful,
11 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 | // GNU General Public License for more details.
14 | //
15 | // You should have received a copy of the GNU General Public License
16 | // along with screenruster. If not, see .
17 |
18 | use std::thread;
19 | use std::ops::Deref;
20 |
21 | use channel::{self, Receiver, Sender, select};
22 | use xcb;
23 | use xkb::{self, key};
24 |
25 | use crate::error;
26 | use crate::config::Config;
27 | use crate::saver::{self, Saver};
28 | use api::{self, Password, Pointer};
29 | use super::{Window};
30 | use crate::platform::{self, Display, Keyboard};
31 |
32 | pub struct Preview {
33 | receiver: Receiver,
34 | sender: Sender,
35 | }
36 |
37 | #[derive(Clone)]
38 | pub enum Request {
39 |
40 | }
41 |
42 | #[derive(Clone)]
43 | pub enum Response {
44 | Done,
45 | }
46 |
47 | impl Preview {
48 | pub fn spawn>(name: T, config: Config) -> error::Result {
49 | let display = Display::open(None)?;
50 | let mut keyboard = Keyboard::new(display.clone(), None)?;
51 | let window = Window::create(display.clone())?;
52 | let mut saver = Saver::spawn(name.as_ref())?;
53 | let mut throttle = config.saver().throttle();
54 |
55 | saver.config(config.saver().get(name)).unwrap();
56 | saver.target(display.name(), window.screen(), window.id() as u64).unwrap();
57 |
58 | if throttle {
59 | saver.throttle(true).unwrap();
60 | }
61 |
62 | let (sender, i_receiver) = channel::unbounded();
63 | let (i_sender, receiver) = channel::unbounded();
64 |
65 | thread::spawn(move || {
66 | let x = platform::display::sink(&display);
67 | let s = saver.take().unwrap();
68 |
69 | loop {
70 | select! {
71 | // Handle control events.
72 | recv(receiver) -> event => {
73 | match event {
74 | _ => ()
75 | }
76 | },
77 |
78 | // Handle saver events.
79 | recv(s) -> event => {
80 | match event.unwrap() {
81 | saver::Response::Forward(api::Response::Initialized) => {
82 | saver.start().unwrap();
83 | }
84 |
85 | saver::Response::Forward(api::Response::Started) => {
86 | if saver.was_started() {
87 | window.show();
88 | }
89 | else {
90 | saver.kill();
91 | }
92 | }
93 |
94 | saver::Response::Forward(api::Response::Stopped) => {
95 | if !saver.was_stopped() {
96 | saver.kill();
97 | }
98 | }
99 |
100 | saver::Response::Exit(..) => {
101 | break;
102 | }
103 | }
104 | },
105 |
106 | // Handle X events.
107 | recv(x) -> event => {
108 | let event = event.unwrap();
109 |
110 | match event.response_type() {
111 | // Handle keyboard events.
112 | e if keyboard.owns_event(e) => {
113 | keyboard.handle(&event);
114 | }
115 |
116 | xcb::CONFIGURE_NOTIFY => {
117 | let event = unsafe { xcb::cast_event::(&event) };
118 | saver.resize(event.width() as u32, event.height() as u32).unwrap();
119 | }
120 |
121 | // Handle keyboard input.
122 | xcb::KEY_PRESS => {
123 | let key = unsafe { xcb::cast_event::(&event) };
124 |
125 | match keyboard.symbol(key.detail().into()) {
126 | // Toggle throttling.
127 | Some(key::t) | Some(key::T) => {
128 | throttle = !throttle;
129 | saver.throttle(throttle).unwrap();
130 | }
131 |
132 | // Stop the preview.
133 | Some(key::q) | Some(key::Q) => {
134 | saver.stop().unwrap();
135 | }
136 |
137 | // Test password insertion.
138 | Some(key::i) | Some(key::I) => {
139 | saver.password(Password::Insert).unwrap();
140 | }
141 |
142 | // Test password deletetion.
143 | Some(key::d) | Some(key::D) => {
144 | saver.password(Password::Delete).unwrap();
145 | }
146 |
147 | // Test passsword reset.
148 | Some(key::r) | Some(key::R) => {
149 | saver.password(Password::Reset).unwrap();
150 | }
151 |
152 | // Test password check.
153 | Some(key::c) | Some(key::C) => {
154 | saver.password(Password::Check).unwrap();
155 | }
156 |
157 | // Test password success.
158 | Some(key::s) | Some(key::S) => {
159 | saver.password(Password::Success).unwrap();
160 | }
161 |
162 | // Test password failure.
163 | Some(key::f) | Some(key::F) => {
164 | saver.password(Password::Failure).unwrap();
165 | }
166 |
167 | _ => ()
168 | }
169 | }
170 |
171 | // Handle mouse button presses.
172 | xcb::BUTTON_PRESS | xcb::BUTTON_RELEASE => {
173 | let event = unsafe { xcb::cast_event::(&event) };
174 |
175 | saver.pointer(Pointer::Button {
176 | x: event.event_x() as i32,
177 | y: event.event_y() as i32,
178 |
179 | button: event.detail(),
180 | press: event.response_type() == xcb::BUTTON_PRESS,
181 | }).unwrap();
182 | }
183 |
184 | // Handle mouse motion.
185 | xcb::MOTION_NOTIFY => {
186 | let event = unsafe { xcb::cast_event::(&event) };
187 |
188 | saver.pointer(Pointer::Move {
189 | x: event.event_x() as i32,
190 | y: event.event_y() as i32,
191 | }).unwrap();
192 | }
193 |
194 | _ => ()
195 | }
196 | }
197 | }
198 | }
199 |
200 | sender.send(Response::Done).unwrap();
201 | });
202 |
203 | Ok(Preview {
204 | receiver: i_receiver,
205 | sender: i_sender,
206 | })
207 | }
208 | }
209 |
210 | impl Deref for Preview {
211 | type Target = Receiver;
212 |
213 | fn deref(&self) -> &Receiver {
214 | &self.receiver
215 | }
216 | }
217 |
--------------------------------------------------------------------------------
/src/preview/window.rs:
--------------------------------------------------------------------------------
1 | // Copyleft (ↄ) meh. | http://meh.schizofreni.co
2 | //
3 | // This file is part of screenruster.
4 | //
5 | // screenruster is free software: you can redistribute it and/or modify
6 | // it under the terms of the GNU General Public License as published by
7 | // the Free Software Foundation, either version 3 of the License, or
8 | // (at your option) any later version.
9 | //
10 | // screenruster is distributed in the hope that it will be useful,
11 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 | // GNU General Public License for more details.
14 | //
15 | // You should have received a copy of the GNU General Public License
16 | // along with screenruster. If not, see .
17 |
18 | use std::sync::Arc;
19 | use std::ops::Deref;
20 |
21 | use xcb;
22 | use xcbu::icccm;
23 |
24 | use crate::error;
25 | use crate::platform::{self, Display};
26 |
27 | pub struct Window {
28 | display: Arc,
29 | window: platform::Window,
30 | }
31 |
32 | impl Window {
33 | pub fn create(display: Arc) -> error::Result {
34 | let screen = display.get_setup().roots().nth(display.screen() as usize).unwrap();
35 | let window = platform::Window::create(display.clone(), display.screen(),
36 | (screen.width_in_pixels() as f32 / 1.2) as u32,
37 | (screen.height_in_pixels() as f32 / 1.2) as u32)?;
38 |
39 | xcb::change_property(&display, xcb::PROP_MODE_REPLACE as u8, window.id(),
40 | xcb::ATOM_WM_NAME, xcb::ATOM_STRING, 8, b"ScreenRuster");
41 |
42 | icccm::set_wm_size_hints(&display, window.id(), xcb::ATOM_WM_NORMAL_HINTS, &icccm::SizeHints::empty()
43 | .aspect((screen.width_in_pixels() as i32, screen.height_in_pixels() as i32),
44 | (screen.width_in_pixels() as i32, screen.height_in_pixels() as i32))
45 | .build());
46 |
47 | display.flush();
48 |
49 | Ok(Window {
50 | display: display.clone(),
51 | window: window,
52 | })
53 | }
54 |
55 | pub fn show(&self) {
56 | xcb::map_window(&self.display, self.id());
57 |
58 | self.flush();
59 | }
60 | }
61 |
62 | impl Deref for Window {
63 | type Target = platform::Window;
64 |
65 | fn deref(&self) -> &Self::Target {
66 | &self.window
67 | }
68 | }
69 |
--------------------------------------------------------------------------------
/src/saver.rs:
--------------------------------------------------------------------------------
1 | // Copyleft (ↄ) meh. | http://meh.schizofreni.co
2 | //
3 | // This file is part of screenruster.
4 | //
5 | // screenruster is free software: you can redistribute it and/or modify
6 | // it under the terms of the GNU General Public License as published by
7 | // the Free Software Foundation, either version 3 of the License, or
8 | // (at your option) any later version.
9 | //
10 | // screenruster is distributed in the hope that it will be useful,
11 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 | // GNU General Public License for more details.
14 | //
15 | // You should have received a copy of the GNU General Public License
16 | // along with screenruster. If not, see .
17 |
18 | use std::io::{self, BufRead, BufReader, Write};
19 | use std::process::{self, Child, Command, Stdio};
20 | use std::ops::Deref;
21 | use std::thread;
22 | use std::sync::{Arc, Mutex};
23 | use channel::{self, Receiver, TryRecvError, Sender, SendError};
24 |
25 | use toml;
26 | use log::{log_enabled};
27 | use api::{self, json::{self, object}};
28 | pub use api::{Safety, Password, Pointer};
29 |
30 | use crate::error;
31 |
32 | /// Interaction with an external process that implements the ScreenRuster IPC.
33 | ///
34 | /// It takes care of spawning the process and communicating with it, exposing a
35 | /// simple to use API.
36 | ///
37 | /// When the process dies it sends a message signaling the death, otherwise it
38 | /// just forwards requests and responses.
39 | pub struct Saver {
40 | process: Arc>,
41 | receiver: Option>,
42 | sender: Sender,
43 |
44 | started: bool,
45 | stopped: bool,
46 | }
47 |
48 | #[derive(Debug)]
49 | pub enum Request {
50 | Forward(api::Request),
51 | Exit,
52 | }
53 |
54 | #[derive(Debug)]
55 | pub enum Response {
56 | Forward(api::Response),
57 | Exit(Exit),
58 | }
59 |
60 | #[derive(Debug)]
61 | pub struct Exit {
62 | status: process::ExitStatus,
63 | }
64 |
65 | impl Deref for Exit {
66 | type Target = process::ExitStatus;
67 |
68 | fn deref(&self) -> &Self::Target {
69 | &self.status
70 | }
71 | }
72 |
73 | impl Saver {
74 | /// Spawn the saver with the given name.
75 | pub fn spawn>(name: S) -> error::Result {
76 | let child = Arc::new(Mutex::new(Command::new(format!("screenruster-saver-{}", name.as_ref()))
77 | .stdin(Stdio::piped()).stdout(Stdio::piped()).stderr(Stdio::piped())
78 | .spawn()?));
79 |
80 | let (sender, i_receiver) = channel::unbounded();
81 | let (i_sender, receiver) = channel::unbounded();
82 |
83 | // Read from the process stdout, decode the responses from JSON and send
84 | // them through the channel.
85 | {
86 | let input = child.lock().unwrap().stdout.take().unwrap();
87 | let child = child.clone();
88 | let internal = i_sender.clone();
89 |
90 | thread::spawn(move || {
91 | macro_rules! json {
92 | ($body:expr) => (
93 | if let Some(value) = $body {
94 | value
95 | }
96 | else {
97 | continue;
98 | }
99 | );
100 | }
101 |
102 | for line in BufReader::new(input).lines() {
103 | if line.is_err() {
104 | break;
105 | }
106 |
107 | if let Ok(message) = json::parse(&line.unwrap()) {
108 | sender.send(Response::Forward(match json!(message["type"].as_str()) {
109 | "initialized" => {
110 | api::Response::Initialized
111 | }
112 |
113 | "started" => {
114 | api::Response::Started
115 | }
116 |
117 | "stopped" => {
118 | api::Response::Stopped
119 | }
120 |
121 | _ =>
122 | continue
123 | })).unwrap();
124 | }
125 | }
126 |
127 | internal.send(Request::Exit).unwrap();
128 |
129 | let mut child = child.lock().unwrap();
130 | sender.send(Response::Exit(Exit {
131 | status: child.wait().unwrap(),
132 | })).unwrap()
133 | });
134 | }
135 |
136 | // Receive requests from the channel, encode them to JSON and send them to
137 | // the process stdin.
138 | {
139 | let mut output = child.lock().unwrap().stdin.take().unwrap();
140 |
141 | thread::spawn(move || {
142 | while let Ok(request) = receiver.recv() {
143 | match request {
144 | Request::Forward(request) => {
145 | output.write_all(json::stringify(match request {
146 | api::Request::Config(config) => object!{
147 | "type" => "config",
148 | "config" => config
149 | },
150 |
151 | api::Request::Safety(level) => object!{
152 | "type" => "safety",
153 | "safety" => match level {
154 | Safety::High => "high",
155 | Safety::Medium => "medium",
156 | Safety::Low => "low",
157 | }
158 | },
159 |
160 | api::Request::Target { display, screen, window } => object!{
161 | "type" => "target",
162 | "display" => display,
163 | "screen" => screen,
164 | "window" => window
165 | },
166 |
167 | api::Request::Throttle(value) => object!{
168 | "type" => "throttle",
169 | "throttle" => value
170 | },
171 |
172 | api::Request::Blank(value) => object!{
173 | "type" => "blank",
174 | "blank" => value
175 | },
176 |
177 | api::Request::Resize { width, height } => object!{
178 | "type" => "resize",
179 | "width" => width,
180 | "height" => height
181 | },
182 |
183 | api::Request::Pointer(Pointer::Move { x, y }) => object!{
184 | "type" => "pointer",
185 | "move" => object!{
186 | "x" => x,
187 | "y" => y
188 | }
189 | },
190 |
191 | api::Request::Pointer(Pointer::Button { x, y, button, press }) => object!{
192 | "type" => "pointer",
193 | "button" => object!{
194 | "x" => x,
195 | "y" => y,
196 | "button" => button,
197 | "press" => press
198 | }
199 | },
200 |
201 | api::Request::Password(password) => object!{
202 | "type" => "password",
203 | "password" => match password {
204 | Password::Insert => "insert",
205 | Password::Delete => "delete",
206 | Password::Reset => "reset",
207 | Password::Check => "check",
208 | Password::Success => "success",
209 | Password::Failure => "failure",
210 | }
211 | },
212 |
213 | api::Request::Start => object!{
214 | "type" => "start"
215 | },
216 |
217 | api::Request::Lock => object!{
218 | "type" => "lock"
219 | },
220 |
221 | api::Request::Stop => object!{
222 | "type" => "stop"
223 | },
224 | }).as_bytes()).unwrap();
225 |
226 | output.write_all(b"\n").unwrap();
227 | }
228 |
229 | Request::Exit => {
230 | break;
231 | }
232 | }
233 | }
234 | });
235 | }
236 |
237 | // Read from the process stderr and forward it to stderr.
238 | {
239 | let input = child.lock().unwrap().stderr.take().unwrap();
240 |
241 | thread::spawn(move || {
242 | for line in BufReader::new(input).lines() {
243 | if line.is_err() {
244 | break;
245 | }
246 |
247 | if log_enabled!(log::Level::Debug) {
248 | writeln!(&mut io::stderr(), "{}", line.unwrap()).unwrap();
249 | }
250 | }
251 | });
252 | }
253 |
254 | Ok(Saver {
255 | process: child,
256 | receiver: Some(i_receiver),
257 | sender: i_sender,
258 |
259 | started: false,
260 | stopped: false,
261 | })
262 | }
263 |
264 | /// Check if the saver was requested to start.
265 | pub fn was_started(&self) -> bool {
266 | self.started
267 | }
268 |
269 | /// Check if the saver was requested to stop.
270 | pub fn was_stopped(&self) -> bool {
271 | self.stopped
272 | }
273 |
274 | /// Kill the saver process.
275 | pub fn kill(&mut self) {
276 | let _ = self.process.lock().unwrap().kill();
277 | }
278 |
279 | /// Take the internal receiver.
280 | pub fn take(&mut self) -> Option> {
281 | self.receiver.take()
282 | }
283 |
284 | /// Try to receive a message from the saver.
285 | pub fn recv(&mut self) -> Option {
286 | if let Some(receiver) = self.receiver.as_ref() {
287 | match receiver.try_recv() {
288 | Ok(response) =>
289 | Some(response),
290 |
291 | Err(TryRecvError::Empty) =>
292 | None,
293 |
294 | Err(TryRecvError::Disconnected) => {
295 | None
296 | }
297 | }
298 | }
299 | else {
300 | None
301 | }
302 | }
303 |
304 | /// Send the API request.
305 | fn send(&mut self, request: api::Request) -> Result<(), SendError> {
306 | self.sender.send(Request::Forward(request))
307 | }
308 |
309 | /// Configure the saver.
310 | pub fn config(&mut self, config: toml::value::Table) -> Result<(), SendError> {
311 | fn convert(value: &toml::Value) -> json::JsonValue {
312 | match *value {
313 | toml::Value::String(ref value) =>
314 | value.clone().into(),
315 |
316 | toml::Value::Datetime(ref value) =>
317 | value.to_string().into(),
318 |
319 | toml::Value::Integer(value) =>
320 | value.into(),
321 |
322 | toml::Value::Float(value) =>
323 | value.into(),
324 |
325 | toml::Value::Boolean(value) =>
326 | value.into(),
327 |
328 | toml::Value::Array(ref value) =>
329 | json::JsonValue::Array(value.iter().map(|v| convert(v)).collect()),
330 |
331 | toml::Value::Table(ref value) =>
332 | json::JsonValue::Object(value.iter().fold(json::object::Object::new(),
333 | |mut acc, (key, value)| {
334 | acc.insert(key, convert(value));
335 | acc
336 | }))
337 | }
338 | }
339 |
340 | self.send(api::Request::Config(convert(&toml::Value::Table(config))))
341 | }
342 |
343 | /// Specify the safety level.
344 | pub fn safety(&mut self, level: Safety) -> Result<(), SendError> {
345 | self.send(api::Request::Safety(level))
346 | }
347 |
348 | /// Select the rendering target for the saver.
349 | pub fn target<'a, D: Into>>(&mut self, display: D, screen: i32, window: u64) -> Result<(), SendError> {
350 | self.send(api::Request::Target {
351 | display: display.into().map(String::from),
352 | screen: screen,
353 | window: window,
354 | })
355 | }
356 |
357 | /// Throttle or unthrottle the saer.
358 | pub fn throttle(&mut self, value: bool) -> Result<(), SendError> {
359 | self.send(api::Request::Throttle(value))
360 | }
361 |
362 | /// Tell the saver the screen has been blanked or unblanked.
363 | pub fn blank(&mut self, value: bool) -> Result<(), SendError> {
364 | self.send(api::Request::Blank(value))
365 | }
366 |
367 | /// Resize the saver.
368 | pub fn resize(&mut self, width: u32, height: u32) -> Result<(), SendError> {
369 | self.send(api::Request::Resize {
370 | width: width,
371 | height: height,
372 | })
373 | }
374 |
375 | /// Send a pointer event.
376 | pub fn pointer(&mut self, pointer: Pointer) -> Result<(), SendError> {
377 | self.send(api::Request::Pointer(pointer))
378 | }
379 |
380 | /// Send a password event.
381 | pub fn password(&mut self, password: Password) -> Result<(), SendError> {
382 | self.send(api::Request::Password(password))
383 | }
384 |
385 | /// Start the saver.
386 | pub fn start(&mut self) -> Result<(), SendError> {
387 | self.started = true;
388 | self.send(api::Request::Start)
389 | }
390 |
391 | /// Start the saver.
392 | pub fn lock(&mut self) -> Result<(), SendError> {
393 | self.send(api::Request::Lock)
394 | }
395 |
396 | /// Stop the saver.
397 | pub fn stop(&mut self) -> Result<(), SendError> {
398 | self.stopped = true;
399 | self.send(api::Request::Stop)
400 | }
401 | }
402 |
--------------------------------------------------------------------------------
/src/timer.rs:
--------------------------------------------------------------------------------
1 | // Copyleft (ↄ) meh. | http://meh.schizofreni.co
2 | //
3 | // This file is part of screenruster.
4 | //
5 | // screenruster is free software: you can redistribute it and/or modify
6 | // it under the terms of the GNU General Public License as published by
7 | // the Free Software Foundation, either version 3 of the License, or
8 | // (at your option) any later version.
9 | //
10 | // screenruster is distributed in the hope that it will be useful,
11 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 | // GNU General Public License for more details.
14 | //
15 | // You should have received a copy of the GNU General Public License
16 | // along with screenruster. If not, see .
17 |
18 | use std::collections::{HashMap, HashSet};
19 | use std::thread;
20 | use std::ops::Deref;
21 | use std::time::{Instant, SystemTime, Duration};
22 | use channel::{self, Receiver, Sender, SendError};
23 |
24 | use crate::error;
25 | use crate::config;
26 |
27 | /// The timer manager.
28 | ///
29 | /// It manages timers with a 1 second granularity, reporting timer expirations
30 | /// through a channel.
31 | ///
32 | /// It also handles custom timeouts on request.
33 | pub struct Timer {
34 | receiver: Receiver,
35 | sender: Sender,
36 | }
37 |
38 | #[derive(Clone, Debug)]
39 | pub enum Request {
40 | /// Request a report on all the timers.
41 | Report {
42 | id: u64,
43 | },
44 |
45 | /// Request a timeout.
46 | Timeout(Timeout),
47 |
48 | /// Reset the specific event.
49 | Reset(Event),
50 |
51 | /// Suspend the timers.
52 | Suspend(SystemTime),
53 |
54 | /// Resume the timers.
55 | Resume,
56 |
57 | /// The screen was blanked.
58 | Blanked,
59 |
60 | /// The screen was unblanked.
61 | Unblanked,
62 |
63 | /// The screen saver was started.
64 | Started,
65 |
66 | /// The screen was locked.
67 | Locked,
68 |
69 | /// The screen saver was stopped, restarts all timers.
70 | Stopped,
71 | }
72 |
73 | #[derive(Copy, Clone, Debug)]
74 | pub enum Timeout {
75 | /// Set a timeout.
76 | Set {
77 | id: u64,
78 | seconds: u64,
79 | },
80 |
81 | /// Cancel a timeout.
82 | Cancel {
83 | id: u64,
84 | }
85 | }
86 |
87 | #[derive(Clone, Debug)]
88 | pub enum Event {
89 | /// Deal with idle events.
90 | Idle,
91 |
92 | /// Deal with blanking events.
93 | Blank,
94 | }
95 |
96 | #[derive(Clone, Debug)]
97 | pub enum Response {
98 | /// Report various information about the timer internal status.
99 | Report {
100 | id: u64,
101 | beat: Instant,
102 | idle: Instant,
103 | started: Option,
104 | locked: Option,
105 | blanked: Option,
106 | unblanked: Option,
107 | suspended: Option,
108 | correction: u64,
109 | corrected: bool,
110 | timeouts: HashMap,
111 | },
112 |
113 | /// A custom timeout has expired.
114 | Timeout {
115 | id: u64
116 | },
117 |
118 | /// The timers were suspended.
119 | Suspended(SystemTime),
120 |
121 | /// The timers were resumed.
122 | Resumed,
123 |
124 | /// Hurts my kokoro.
125 | Heartbeat(Instant),
126 |
127 | /// The system has been idle long enough.
128 | Start,
129 |
130 | /// The system has been idle long enough after starting.
131 | Lock,
132 |
133 | /// The system has been idle long enough to blank.
134 | Blank,
135 | }
136 |
137 | impl Timer {
138 | /// Spawn the timer thread with the given configuration.
139 | pub fn spawn(config: config::Timer) -> error::Result {
140 | let (sender, i_receiver) = channel::unbounded();
141 | let (i_sender, receiver) = channel::unbounded();
142 |
143 | thread::spawn(move || {
144 | // Instant to check last heartbeat.
145 | let mut beat = Instant::now();
146 |
147 | // Instant to check last activity time.
148 | let mut idle = Instant::now();
149 |
150 | // Instant to check when the screen saver starter.
151 | let mut started = None::;
152 |
153 | // Instant to check when the screen was locked.
154 | let mut locked = None::;
155 |
156 | // Instant to check when the screen was blanked.
157 | let mut blanked = None::;
158 |
159 | // Instant to check when the screen was unblanked.
160 | let mut unblanked = None::;
161 |
162 | // Instant to check when the timer was suspended.
163 | let mut suspended = None::;
164 |
165 | // Time correction for suspension.
166 | let mut correction = 0;
167 |
168 | // Whether a correction loop has already been done.
169 | let mut corrected = false;
170 |
171 | // The registered timeouts.
172 | let mut timeouts = HashMap::::new();
173 |
174 | loop {
175 | thread::sleep(Duration::from_secs(1));
176 |
177 | while let Ok(request) = receiver.try_recv() {
178 | match request {
179 | Request::Report { id } => {
180 | sender.send(Response::Report {
181 | id: id,
182 | beat: beat,
183 | idle: idle,
184 | started: started,
185 | locked: locked,
186 | blanked: blanked,
187 | unblanked: unblanked,
188 | suspended: suspended,
189 | correction: correction,
190 | corrected: corrected,
191 | timeouts: timeouts.clone(),
192 | }).unwrap();
193 | }
194 |
195 | Request::Timeout(Timeout::Set { id, seconds }) => {
196 | timeouts.insert(id, (Instant::now(), seconds));
197 | }
198 |
199 | Request::Timeout(Timeout::Cancel { id }) => {
200 | timeouts.remove(&id);
201 | }
202 |
203 | Request::Reset(Event::Idle) => {
204 | idle = Instant::now();
205 | correction = 0;
206 | }
207 |
208 | Request::Reset(Event::Blank) | Request::Unblanked => {
209 | blanked = None;
210 | unblanked = Some(Instant::now());
211 | }
212 |
213 | Request::Suspend(time) => {
214 | suspended = Some(time);
215 | sender.send(Response::Suspended(time)).unwrap();
216 | }
217 |
218 | Request::Resume => {
219 | correction += suspended.take().unwrap().elapsed().unwrap_or(Duration::from_secs(0)).as_secs();
220 | corrected = false;
221 | }
222 |
223 | Request::Blanked => {
224 | blanked = Some(Instant::now());
225 | }
226 |
227 | Request::Started => {
228 | started = Some(Instant::now());
229 | }
230 |
231 | Request::Locked => {
232 | locked = Some(Instant::now());
233 | }
234 |
235 | Request::Stopped => {
236 | idle = Instant::now();
237 | started = None;
238 | locked = None;
239 | blanked = None;
240 | correction = 0;
241 | }
242 | }
243 | }
244 |
245 | // Handle custom timeouts.
246 | {
247 | let mut expired = HashSet::new();
248 |
249 | for (&id, &(ref started, seconds)) in &timeouts {
250 | if started.elapsed().as_secs() > seconds {
251 | expired.insert(id);
252 | }
253 | }
254 |
255 | for &id in &expired {
256 | sender.send(Response::Timeout { id }).unwrap();
257 | timeouts.remove(&id);
258 | }
259 | }
260 |
261 | // If it's time to send a heart beat, send one and reset.
262 | if beat.elapsed().as_secs() >= config.beat() as u64 {
263 | beat = Instant::now();
264 | sender.send(Response::Heartbeat(idle)).unwrap();
265 | }
266 |
267 | // Do not check events if the timers are suspended.
268 | if suspended.is_some() {
269 | continue;
270 | }
271 |
272 | // If blanking is enabled and the screen is not already blanked.
273 | if let (Some(after), false) = (config.blank(), blanked.is_some()) {
274 | if unblanked.unwrap_or(idle).elapsed().as_secs() >= after as u64 {
275 | sender.send(Response::Blank).unwrap();
276 | blanked = Some(Instant::now());
277 | }
278 | }
279 |
280 | // If the system has been idle long enough send the message.
281 | if started.is_none() && idle.elapsed().as_secs() + correction >= config.timeout() as u64 {
282 | sender.send(Response::Start).unwrap();
283 | started = Some(Instant::now());
284 | }
285 |
286 | // If the screen saver has been started, the screen is not locked and locking is enabled.
287 | if let (Some(start), Some(after), false) = (started, config.lock(), locked.is_some()) {
288 | if start.elapsed().as_secs() + correction >= after as u64 {
289 | sender.send(Response::Lock).unwrap();
290 | locked = Some(Instant::now());
291 | }
292 | }
293 |
294 | // Only resume after one corrected loop, this avoids activities right
295 | // after resume cancelling timer events.
296 | if !corrected {
297 | sender.send(Response::Resumed).unwrap();
298 | corrected = true;
299 | }
300 | }
301 | });
302 |
303 | Ok(Timer {
304 | receiver: i_receiver,
305 | sender: i_sender,
306 | })
307 | }
308 |
309 | pub fn timeout(&self, value: Timeout) -> Result<(), SendError> {
310 | self.sender.send(Request::Timeout(value))
311 | }
312 |
313 | /// Request a report wiht the given id.
314 | pub fn report(&self, id: u64) -> Result<(), SendError> {
315 | self.sender.send(Request::Report { id: id })
316 | }
317 |
318 | /// Reset the given timer.
319 | pub fn reset(&self, event: Event) -> Result<(), SendError> {
320 | self.sender.send(Request::Reset(event))
321 | }
322 |
323 | /// Request the timers to suspend at the given time.
324 | pub fn suspend(&self, value: SystemTime) -> Result<(), SendError> {
325 | self.sender.send(Request::Suspend(value))
326 | }
327 |
328 | /// Request the timers to resume.
329 | pub fn resume(&self) -> Result<(), SendError> {
330 | self.sender.send(Request::Resume)
331 | }
332 |
333 | /// Notice the screen has been blanked.
334 | pub fn blanked(&self) -> Result<(), SendError> {
335 | self.sender.send(Request::Blanked)
336 | }
337 |
338 | /// Notice the screen has been unblanked.
339 | pub fn unblanked(&self) -> Result<(), SendError> {
340 | self.sender.send(Request::Unblanked)
341 | }
342 |
343 | /// Notice the screen saver has started.
344 | pub fn started(&self) -> Result<(), SendError> {
345 | self.sender.send(Request::Started)
346 | }
347 |
348 | /// Notice the screen has been locked.
349 | pub fn locked(&self) -> Result<(), SendError> {
350 | self.sender.send(Request::Locked)
351 | }
352 |
353 | /// Notice the screen saver was stopped.
354 | pub fn stopped(&self) -> Result<(), SendError> {
355 | self.sender.send(Request::Stopped)
356 | }
357 | }
358 |
359 | impl Deref for Timer {
360 | type Target = Receiver;
361 |
362 | fn deref(&self) -> &Receiver {
363 | &self.receiver
364 | }
365 | }
366 |
--------------------------------------------------------------------------------