dux 0.2.0

X11 backlight manager.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

// Copyleft (ↄ) meh. <meh@schizofreni.co> | http://meh.schizofreni.co
//
// This file is part of dux.
//
// dux is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// dux is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with dux.  If not, see <http://www.gnu.org/licenses/>.

use std::sync::Arc;

use crate::{Display, error};

pub trait Backlight {
	/// The raw backlight range.
	fn range(&self) -> (u32, u32) {
		(0, 100)
	}

	/// Get the current backlight value as a precentage.
	fn get(&mut self) -> error::Result<f32>;

	/// Set the backlight value as a percentage.
	fn set(&mut self, value: f32) -> error::Result<()>;
}

mod randr;
mod sys;

/// Open the first available backlight handler.
pub fn open(display: Arc<Display>) -> error::Result<Box<dyn Backlight>> {
	if let Ok(backlight) = randr::Backlight::open(display.clone()) {
		Ok(Box::new(backlight))
	}
	else if let Ok(backlight) = sys::Backlight::open() {
		Ok(Box::new(backlight))
	}
	else {
		Err(error::Error::Unsupported)
	}
}

/// Clamps the given value between `0.0` and `100.0`.
pub fn clamp(value: f32) -> f32 {
	if value > 100.0 {
		100.0
	}
	else if value < 0.0 {
		0.0
	}
	else {
		value
	}
}

/// Fades the backlight from the current value to the given value.
pub mod fade {
	use std::thread;
	use std::time::Duration;
	use std::f32;
	use super::{Backlight, clamp};
	use crate::error;

	/// It takes `time` milliseconds, split into `steps` increments/decrements.
	pub fn by_time(backlight: &mut dyn Backlight, value: f32, time: i32, steps: i32) -> error::Result<()> {
		let value = clamp(value);

		if steps != 0 && time != 0 {
			let mut current = backlight.get()?;
			let     step    = (value - current) as i32 / steps;
			let     sleep   = (time / steps) as u64;

			for _ in 0 .. steps {
				current += step as f32;
				backlight.set(current)?;
				thread::sleep(Duration::from_millis(sleep));
			}
		}

		backlight.set(value)
	}

	/// Waits `time` milliseconds between each `value` increment/decrement.
	pub fn by_step(backlight: &mut dyn Backlight, value: f32, step: f32, time: u64) -> error::Result<()> {
		if time != 0 {
			let mut current = backlight.get()?;
			let     step    = if current > value { -step } else { step };

			loop {
				current += step;

				if (step.is_sign_negative() && current < value) || (!step.is_sign_negative() && current > value) {
					break;
				}

				backlight.set(current)?;
				thread::sleep(Duration::from_millis(time));
			}
		}

		backlight.set(value)
	}
}