Skip to content

Commit

Permalink
Unified change_sink_volume and change_source_volume
Browse files Browse the repository at this point in the history
  • Loading branch information
@ErikReider
ErikReider committed May 8, 2023
1 parent b4afd47 commit 5c2176a
Show file tree
Hide file tree
Showing 3 changed files with 135 additions and 150 deletions.
46 changes: 34 additions & 12 deletions src/application.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -6,6 +6,7 @@ use gtk::glib::variant::DictEntry;
use gtk::glib::{clone, OptionArg, OptionFlags, SignalHandlerId, Variant, VariantTy};
use gtk::prelude::*;
use gtk::*;
use pulsectl::controllers::{SinkController, SourceController};

use crate::osd_window::SwayosdWindow;
use crate::utils::*;
Expand Down Expand Up @@ -325,44 +326,65 @@ impl SwayOSDApplication {
};
match ArgTypes::parse(osd_type, value) {
(ArgTypes::SinkVolumeRaise, step) => {
if let Some(device) = change_sink_volume(VolumeChangeType::Raise, step) {
let mut device_type = VolumeDeviceType::Sink(SinkController::create().unwrap());
if let Some(device) =
change_device_volume(&mut device_type, VolumeChangeType::Raise, step)
{
for window in self.windows.borrow().to_owned() {
window.changed_volume(&device, VolumeDeviceType::Sink);
window.changed_volume(&device, &device_type);
}
}
}
(ArgTypes::SinkVolumeLower, step) => {
if let Some(device) = change_sink_volume(VolumeChangeType::Lower, step) {
let mut device_type = VolumeDeviceType::Sink(SinkController::create().unwrap());
if let Some(device) =
change_device_volume(&mut device_type, VolumeChangeType::Lower, step)
{
for window in self.windows.borrow().to_owned() {
window.changed_volume(&device, VolumeDeviceType::Sink);
window.changed_volume(&device, &device_type);
}
}
}
(ArgTypes::SinkVolumeMuteToggle, _) => {
if let Some(device) = change_sink_volume(VolumeChangeType::MuteToggle, None) {
let mut device_type = VolumeDeviceType::Sink(SinkController::create().unwrap());
if let Some(device) =
change_device_volume(&mut device_type, VolumeChangeType::MuteToggle, None)
{
for window in self.windows.borrow().to_owned() {
window.changed_volume(&device, VolumeDeviceType::Sink);
window.changed_volume(&device, &device_type);
}
}
}
(ArgTypes::SourceVolumeRaise, step) => {
if let Some(device) = change_source_volume(VolumeChangeType::Raise, step) {
let mut device_type =
VolumeDeviceType::Source(SourceController::create().unwrap());
if let Some(device) =
change_device_volume(&mut device_type, VolumeChangeType::Raise, step)
{
for window in self.windows.borrow().to_owned() {
window.changed_volume(&device, VolumeDeviceType::Source);
window.changed_volume(&device, &device_type);
}
}
}
(ArgTypes::SourceVolumeLower, step) => {
if let Some(device) = change_source_volume(VolumeChangeType::Lower, step) {
let mut device_type =
VolumeDeviceType::Source(SourceController::create().unwrap());
if let Some(device) =
change_device_volume(&mut device_type, VolumeChangeType::Lower, step)
{
for window in self.windows.borrow().to_owned() {
window.changed_volume(&device, VolumeDeviceType::Source);
window.changed_volume(&device, &device_type);
}
}
}
(ArgTypes::SourceVolumeMuteToggle, _) => {
if let Some(device) = change_source_volume(VolumeChangeType::MuteToggle, None) {
let mut device_type =
VolumeDeviceType::Source(SourceController::create().unwrap());
if let Some(device) =
change_device_volume(&mut device_type, VolumeChangeType::MuteToggle, None)
{
for window in self.windows.borrow().to_owned() {
window.changed_volume(&device, VolumeDeviceType::Source);
window.changed_volume(&device, &device_type);
}
}
}
Expand Down
6 changes: 3 additions & 3 deletions src/osd_window.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -126,13 +126,13 @@ impl SwayosdWindow {
self.window.close();
}

pub fn changed_volume(&self, device: &DeviceInfo, device_type: VolumeDeviceType) {
pub fn changed_volume(&self, device: &DeviceInfo, device_type: &VolumeDeviceType) {
self.clear_osd();

let volume = volume_to_f64(&device.volume.avg());
let icon_prefix = match device_type {
VolumeDeviceType::Sink => "audio-volume",
VolumeDeviceType::Source => "microphone-sensitivity",
VolumeDeviceType::Sink(_) => "audio-volume",
VolumeDeviceType::Source(_) => "microphone-sensitivity",
};
let icon_name = &match (device.mute, volume) {
(true, _) => format!("{}-muted-symbolic", icon_prefix),
Expand Down
233 changes: 98 additions & 135 deletions src/utils.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -80,34 +80,54 @@ pub enum VolumeChangeType {
}

pub enum VolumeDeviceType {
Sink,
Source,
Sink(SinkController),
Source(SourceController),
}

pub enum BrightnessChangeType {
Raise,
Lower,
}

pub fn change_sink_volume(
pub fn change_device_volume(
device_type: &mut VolumeDeviceType,
change_type: VolumeChangeType,
step: Option<String>,
) -> Option<DeviceInfo> {
let mut controller = SinkController::create().unwrap();

let server_info = controller.get_server_info();
let device_name = &match server_info {
Ok(info) => info.default_sink_name.unwrap_or("".to_string()),
Err(e) => {
eprintln!("Pulse Error: {}", e);
return None;
let (device, device_name): (DeviceInfo, String) = match device_type {
VolumeDeviceType::Sink(controller) => {
let server_info = controller.get_server_info();
let device_name = &match server_info {
Ok(info) => info.default_sink_name.unwrap_or("".to_string()),
Err(e) => {
eprintln!("Pulse Error: {}", e);
return None;
}
};
match controller.get_device_by_name(device_name) {
Ok(device) => (device, device_name.clone()),
Err(e) => {
eprintln!("Pulse Error: {}", e);
return None;
}
}
}
};
let device = match controller.get_device_by_name(device_name) {
Ok(device) => device,
Err(e) => {
eprintln!("Pulse Error: {}", e);
return None;
VolumeDeviceType::Source(controller) => {
let server_info = controller.get_server_info();
let device_name = &match server_info {
Ok(info) => info.default_sink_name.unwrap_or("".to_string()),
Err(e) => {
eprintln!("Pulse Error: {}", e);
return None;
}
};
match controller.get_device_by_name(device_name) {
Ok(device) => (device, device_name.clone()),
Err(e) => {
eprintln!("Pulse Error: {}", e);
return None;
}
}
}
};

Expand Down Expand Up @@ -152,7 +172,14 @@ pub fn change_sink_volume(
// if we are exactle at max volume
if at_max_volume {
// only show the OSD
controller.increase_device_volume_by_percent(device.index, 0.0)
match device_type {
VolumeDeviceType::Sink(controller) => {
controller.increase_device_volume_by_percent(device.index, 0.0)
}
VolumeDeviceType::Source(controller) => {
controller.increase_device_volume_by_percent(device.index, 0.0)
}
}
}
// if we would increase over the max step exactly to the max
else if over_max_volume {
Expand All @@ -162,134 +189,70 @@ pub fn change_sink_volume(
.parse::<u8>()
.unwrap_or(delta_to_max) as f64
* 0.01;
controller.increase_device_volume_by_percent(device.index, volume_delta)
match device_type {
VolumeDeviceType::Sink(controller) => {
controller.increase_device_volume_by_percent(device.index, volume_delta)
}
VolumeDeviceType::Source(controller) => {
controller.increase_device_volume_by_percent(device.index, volume_delta)
}
}
}
// if neither of the above are true increase normally
else {
controller.increase_device_volume_by_percent(device.index, volume_delta)
match device_type {
VolumeDeviceType::Sink(controller) => {
controller.increase_device_volume_by_percent(device.index, volume_delta)
}
VolumeDeviceType::Source(controller) => {
controller.increase_device_volume_by_percent(device.index, volume_delta)
}
}
}
}
VolumeChangeType::Lower => {
controller.decrease_device_volume_by_percent(device.index, volume_delta)
}
VolumeChangeType::MuteToggle => {
let op = controller.handler.introspect.set_sink_mute_by_index(
device.index,
!device.mute,
None,
);
controller.handler.wait_for_operation(op).ok();
}
}

match controller.get_device_by_name(device_name) {
Ok(device) => Some(device),
Err(e) => {
eprintln!("Pulse Error: {}", e);
None
}
}
}

pub fn change_source_volume(
change_type: VolumeChangeType,
step: Option<String>,
) -> Option<DeviceInfo> {
let mut controller = SourceController::create().unwrap();

let server_info = controller.get_server_info();
let device_name = &match server_info {
Ok(info) => info.default_sink_name.unwrap_or("".to_string()),
Err(e) => {
eprintln!("Pulse Error: {}", e);
return None;
}
};
let device = match controller.get_device_by_name(device_name) {
Ok(device) => device,
Err(e) => {
eprintln!("Pulse Error: {}", e);
return None;
}
};

const VOLUME_CHANGE_DELTA: u8 = 5;
let volume_delta = step
.clone()
.unwrap_or(String::new())
.parse::<u8>()
.unwrap_or(VOLUME_CHANGE_DELTA) as f64
* 0.01;
match change_type {
VolumeChangeType::Raise => {
let max_volume = get_max_volume();
// if we are already exactly at or over the max volume
let mut at_max_volume = false;
// if we are under the next volume but increasing by the given amount would be over the max
let mut over_max_volume = false;

let mut volume_percent = max_volume;
// iterate through all devices in the volume group
for v in device.volume.get() {
// the string looks like this: ' NUMBER% '
let volume_string = v.to_string();
// trim it to remove the empty space 'NUMBER%'
let mut volume_string = volume_string.trim();
// remove the '%'
volume_string = volume_string.substring(0, volume_string.len() - 1);

// parse the string to a u8, we do it this convoluted to get the % and I haven't found another way
volume_percent = volume_string.parse::<u8>().unwrap();

if volume_percent >= max_volume {
at_max_volume = true;
break;
}

if volume_percent + VOLUME_CHANGE_DELTA > max_volume {
over_max_volume = true;
break;
}
VolumeChangeType::Lower => match device_type {
VolumeDeviceType::Sink(controller) => {
controller.decrease_device_volume_by_percent(device.index, volume_delta)
}
// if we are exactle at max volume
if at_max_volume {
// only show the OSD
controller.increase_device_volume_by_percent(device.index, 0.0)
VolumeDeviceType::Source(controller) => {
controller.decrease_device_volume_by_percent(device.index, volume_delta)
}
// if we would increase over the max step exactly to the max
else if over_max_volume {
let delta_to_max = max_volume - volume_percent;
let volume_delta = step
.unwrap_or(String::new())
.parse::<u8>()
.unwrap_or(delta_to_max) as f64
* 0.01;
controller.increase_device_volume_by_percent(device.index, volume_delta)
},
VolumeChangeType::MuteToggle => match device_type {
VolumeDeviceType::Sink(controller) => {
let op = controller.handler.introspect.set_sink_mute_by_index(
device.index,
!device.mute,
None,
);
controller.handler.wait_for_operation(op).ok();
}
// if neither of the above are true increase normally
else {
controller.increase_device_volume_by_percent(device.index, volume_delta)
VolumeDeviceType::Source(controller) => {
let op = controller.handler.introspect.set_sink_mute_by_index(
device.index,
!device.mute,
None,
);
controller.handler.wait_for_operation(op).ok();
}
}
VolumeChangeType::Lower => {
controller.decrease_device_volume_by_percent(device.index, volume_delta)
}
VolumeChangeType::MuteToggle => {
let op = controller.handler.introspect.set_sink_mute_by_index(
device.index,
!device.mute,
None,
);
controller.handler.wait_for_operation(op).ok();
}
},
}

match controller.get_device_by_name(device_name) {
Ok(device) => Some(device),
Err(e) => {
eprintln!("Pulse Error: {}", e);
None
}
match device_type {
VolumeDeviceType::Sink(controller) => match controller.get_device_by_name(&device_name) {
Ok(device) => Some(device),
Err(e) => {
eprintln!("Pulse Error: {}", e);
None
}
},
VolumeDeviceType::Source(controller) => match controller.get_device_by_name(&device_name) {
Ok(device) => Some(device),
Err(e) => {
eprintln!("Pulse Error: {}", e);
None
}
},
}
}

Expand Down

0 comments on commit 5c2176a

Please sign in to comment.