Added min_brightness config option (#183)

* Added min_brightness config option

* Fixed the min brightness and max volume not being set to new default on start

Author: ErikReider

data/config/config.toml

@@ -8,6 +8,9 @@
 ## The maximum volume that can be reached in %
 # max_volume = 150
 
+## The minimum brightness that can be reached in %
+min_brightness = 5
+
 ## show percentage on the right of the OSD
 # show_percentage = true
 

src/argtypes.rs

@@ -11,6 +11,7 @@ pub enum ArgTypes {
 	Player = (i32::MIN + 4) as isize,
 	MonitorName = (i32::MIN + 5) as isize,
 	CustomProgressText = (i32::MIN + 6) as isize,
+	MinBrightness = (i32::MIN + 7) as isize,
 	// Other
 	None = 0,
 	CapsLock = 1,
@@ -56,6 +57,7 @@ impl fmt::Display for ArgTypes {
 			ArgTypes::MonitorName => "MONITOR-NAME",
 			ArgTypes::CustomProgress => "CUSTOM-PROGRESS",
 			ArgTypes::CustomProgressText => "CUSTOM-PROGRESS-TEXT",
+			ArgTypes::MinBrightness => "MIN-BRIGHTNESS",
 		};
 		write!(f, "{}", string)
 	}
@@ -88,6 +90,7 @@ impl str::FromStr for ArgTypes {
 			"MONITOR-NAME" => ArgTypes::MonitorName,
 			"CUSTOM-PROGRESS" => ArgTypes::CustomProgress,
 			"CUSTOM-PROGRESS-TEXT" => ArgTypes::CustomProgressText,
+			"MIN-BRIGHTNESS" => ArgTypes::MinBrightness,
 			other_type => return Err(other_type.to_owned()),
 		};
 		Ok(result)

src/brightness_backend/blight.rs

@@ -25,17 +25,18 @@ impl BrightnessBackend for Blight {
 		self.device.max()
 	}
 
-	fn lower(&mut self, by: u32) -> anyhow::Result<()> {
-		let val = self.device.calculate_change(by, Direction::Dec);
+	fn lower(&mut self, by: u32, min: u32) -> anyhow::Result<()> {
+		let val = self.device.calculate_change(by, Direction::Dec).max(min);
 		Ok(self.device.write_value(val)?)
 	}
 
-	fn raise(&mut self, by: u32) -> anyhow::Result<()> {
-		let val = self.device.calculate_change(by, Direction::Inc);
+	fn raise(&mut self, by: u32, min: u32) -> anyhow::Result<()> {
+		let val = self.device.calculate_change(by, Direction::Inc).max(min);
 		Ok(self.device.write_value(val)?)
 	}
 
-	fn set(&mut self, val: u32) -> anyhow::Result<()> {
+	fn set(&mut self, val: u32, min: u32) -> anyhow::Result<()> {
+		let val = val.max(min);
 		Ok(self.device.write_value(val)?)
 	}
 }

src/brightness_backend/brightnessctl.rs

@@ -142,17 +142,20 @@ impl BrightnessBackend for BrightnessCtl {
 		self.device.get_max()
 	}
 
-	fn lower(&mut self, by: u32) -> anyhow::Result<()> {
+	fn lower(&mut self, by: u32, min: u32) -> anyhow::Result<()> {
 		let curr = self.device.get_percent();
-		self.device.set_percent(curr.saturating_sub(by))
+		let val = curr.saturating_sub(by).max(min);
+		self.device.set_percent(val)
 	}
 
-	fn raise(&mut self, by: u32) -> anyhow::Result<()> {
+	fn raise(&mut self, by: u32, min: u32) -> anyhow::Result<()> {
 		let curr = self.device.get_percent();
-		self.device.set_percent(curr + by)
+		let val = (curr + by).max(min);
+		self.device.set_percent(val)
 	}
 
-	fn set(&mut self, val: u32) -> anyhow::Result<()> {
+	fn set(&mut self, val: u32, min: u32) -> anyhow::Result<()> {
+		let val = val.max(min);
 		self.device.set_percent(val)
 	}
 }

src/brightness_backend/mod.rs

@@ -23,9 +23,9 @@ pub trait BrightnessBackend {
 	fn get_current(&mut self) -> u32;
 	fn get_max(&mut self) -> u32;
 
-	fn lower(&mut self, by: u32) -> anyhow::Result<()>;
-	fn raise(&mut self, by: u32) -> anyhow::Result<()>;
-	fn set(&mut self, val: u32) -> anyhow::Result<()>;
+	fn lower(&mut self, by: u32, min: u32) -> anyhow::Result<()>;
+	fn raise(&mut self, by: u32, min: u32) -> anyhow::Result<()>;
+	fn set(&mut self, val: u32, min: u32) -> anyhow::Result<()>;
 }
 
 #[allow(dead_code)]

src/client/main.rs

@@ -171,6 +171,14 @@ fn main() -> Result<(), glib::Error> {
 		"Sets the maximum Volume",
 		Some("(+)number"),
 	);
+	app.add_main_option(
+		"min-brightness",
+		glib::Char::from(0),
+		OptionFlags::NONE,
+		OptionArg::String,
+		"Sets the minimum Brightness",
+		Some("(+)number"),
+	);
 	app.add_main_option(
 		"device",
 		glib::Char::from(0),

src/config/user.rs

@@ -17,6 +17,7 @@ pub struct ServerConfig {
 	pub max_volume: Option<u8>,
 	pub show_percentage: Option<bool>,
 	pub playerctl_format: Option<String>,
+	pub min_brightness: Option<u32>,
 }
 
 #[derive(Deserialize, Default, Debug)]

src/global_utils.rs

@@ -107,6 +107,16 @@ pub(crate) fn handle_application_args(
 					}
 				}
 			}
+			"min-brightness" => {
+				let value = child.value().str().unwrap_or("").trim();
+				match value.parse::<u8>() {
+					Ok(_) => (ArgTypes::MinBrightness, Some(value.to_string())),
+					Err(_) => {
+						eprintln!("{} is not a number between 0 and {}!", value, 100);
+						return (HandleLocalStatus::FAILURE, actions);
+					}
+				}
+			}
 			"playerctl" => {
 				let value = child.value().str().unwrap_or("");
 				match value {

src/server/application.rs

@@ -84,6 +84,11 @@ impl SwayOSDApplication {
 		}
 		if let Some(max_volume) = server_config.max_volume {
 			set_default_max_volume(max_volume);
+			reset_max_volume();
+		}
+		if let Some(min_brightness) = server_config.min_brightness {
+			set_default_min_brightness(min_brightness);
+			reset_min_brightness();
 		}
 		if let Some(show) = server_config.show_percentage {
 			set_show_percentage(show);
@@ -120,6 +125,13 @@ impl SwayOSDApplication {
 								set_default_max_volume(max);
 							}
 						}
+						(ArgTypes::MinBrightness, min) => {
+							let min: Option<u32> = min.and_then(|min| min.parse().ok());
+
+							if let Some(min) = min {
+								set_default_min_brightness(min);
+							}
+						}
 						(arg_type, data) => Self::action_activated(
 							&osd_app,
 							server_config_shared.clone(),
@@ -429,6 +441,7 @@ impl SwayOSDApplication {
 						window.changed_brightness(brightness_backend.as_mut());
 					}
 				}
+				reset_min_brightness();
 				reset_monitor_name();
 			}
 			(ArgTypes::BrightnessLower, step) => {
@@ -439,6 +452,7 @@ impl SwayOSDApplication {
 						window.changed_brightness(brightness_backend.as_mut());
 					}
 				}
+				reset_min_brightness();
 				reset_monitor_name();
 			}
 			(ArgTypes::BrightnessSet, value) => {
@@ -449,6 +463,7 @@ impl SwayOSDApplication {
 						window.changed_brightness(brightness_backend.as_mut());
 					}
 				}
+				reset_min_brightness();
 				reset_monitor_name();
 			}
 			(ArgTypes::CapsLock, value) => {
@@ -494,6 +509,16 @@ impl SwayOSDApplication {
 				};
 				set_max_volume(volume)
 			}
+			(ArgTypes::MinBrightness, min) => {
+				let brightness: u32 = match min {
+					Some(min) => match min.parse() {
+						Ok(min) => min,
+						_ => get_default_min_brightness(),
+					},
+					_ => get_default_min_brightness(),
+				};
+				set_min_brightness(brightness)
+			}
 			(ArgTypes::Player, name) => set_player(name.unwrap_or("".to_string())),
 			(ArgTypes::Playerctl, value) => {
 				let value = &value.unwrap_or("".to_string());

src/server/utils.rs

@@ -16,10 +16,13 @@ use crate::brightness_backend;
 use crate::playerctl::PlayerctlDeviceRaw;
 
 static PRIV_MAX_VOLUME_DEFAULT: u8 = 100_u8;
+static PRIV_MIN_BRIGHTNESS_DEFAULT: u32 = 5_u32;
 
 lazy_static! {
 	static ref MAX_VOLUME_DEFAULT: Mutex<u8> = Mutex::new(PRIV_MAX_VOLUME_DEFAULT);
 	static ref MAX_VOLUME: Mutex<u8> = Mutex::new(PRIV_MAX_VOLUME_DEFAULT);
+	static ref MIN_BRIGHTNESS_DEFAULT: Mutex<u32> = Mutex::new(PRIV_MIN_BRIGHTNESS_DEFAULT);
+	static ref MIN_BRIGHTNESS: Mutex<u32> = Mutex::new(PRIV_MIN_BRIGHTNESS_DEFAULT);
 	pub static ref DEVICE_NAME_DEFAULT: &'static str = "default";
 	static ref DEVICE_NAME: Mutex<Option<String>> = Mutex::new(None);
 	static ref MONITOR_NAME: Mutex<Option<String>> = Mutex::new(None);
@@ -62,6 +65,29 @@ pub fn reset_max_volume() {
 	*vol = *MAX_VOLUME_DEFAULT.lock().unwrap();
 }
 
+pub fn get_default_min_brightness() -> u32 {
+	*MIN_BRIGHTNESS_DEFAULT.lock().unwrap()
+}
+
+pub fn set_default_min_brightness(brightness: u32) {
+	let mut min = MIN_BRIGHTNESS_DEFAULT.lock().unwrap();
+	*min = brightness;
+}
+
+pub fn get_min_brightness() -> u32 {
+	*MIN_BRIGHTNESS.lock().unwrap()
+}
+
+pub fn set_min_brightness(brightness: u32) {
+	let mut min = MIN_BRIGHTNESS.lock().unwrap();
+	*min = brightness;
+}
+
+pub fn reset_min_brightness() {
+	let mut min = MIN_BRIGHTNESS.lock().unwrap();
+	*min = *MIN_BRIGHTNESS_DEFAULT.lock().unwrap();
+}
+
 pub fn get_top_margin() -> f32 {
 	*TOP_MARGIN.lock().unwrap()
 }
@@ -401,19 +427,22 @@ pub fn change_brightness(
 	change_type: BrightnessChangeType,
 	step: Option<String>,
 ) -> brightness_backend::BrightnessBackendResult {
+	let min_brightness = get_min_brightness();
 	const BRIGHTNESS_CHANGE_DELTA: u8 = 5;
 	let value = step.unwrap_or_default().parse::<u8>();
 
 	let mut backend = brightness_backend::get_preferred_backend(get_device_name())?;
 
 	match change_type {
-		BrightnessChangeType::Raise => {
-			backend.raise(value.unwrap_or(BRIGHTNESS_CHANGE_DELTA) as u32)?
-		}
-		BrightnessChangeType::Lower => {
-			backend.lower(value.unwrap_or(BRIGHTNESS_CHANGE_DELTA) as u32)?
-		}
-		BrightnessChangeType::Set => backend.set(value.unwrap() as u32)?,
+		BrightnessChangeType::Raise => backend.raise(
+			value.unwrap_or(BRIGHTNESS_CHANGE_DELTA) as u32,
+			min_brightness,
+		)?,
+		BrightnessChangeType::Lower => backend.lower(
+			value.unwrap_or(BRIGHTNESS_CHANGE_DELTA) as u32,
+			min_brightness,
+		)?,
+		BrightnessChangeType::Set => backend.set(value.unwrap() as u32, min_brightness)?,
 	};
 
 	Ok(backend)