Add led style vu meter option.

Author: saivert

data/com.saivert.pwvucontrol.gschema.xml.in

@@ -21,5 +21,10 @@
             <summary>Enable over-amplification</summary>
             <description></description>
         </key>
+        <key name="use-peakmeter-led" type="b">
+            <default>false</default>
+            <summary>Use led style peak meter</summary>
+            <description></description>
+        </key>
 	</schema>
 </schemalist>

data/resources/ui/volumebox.ui

@@ -115,6 +115,7 @@
                                 <property name="use-overamplification">1</property>
                             </object>
                         </child>
+                        <!--
                         <child>
                             <object class="GtkLevelBar" id="level_bar">
                                 <property name="hexpand">True</property>
@@ -124,6 +125,20 @@
                                 <property name="min-value">0.0</property>
                             </object>
                         </child>
+                        <child>
+                            <object class="PwPeakMeter" id="peak_meter">
+                                <property name="hexpand">True</property>
+                                <property name="hexpand-set">True</property>
+                            </object>
+                        </child>
+                        -->
+                        <child>
+                            <object class="GtkBox" id="peakmeterbox">
+                                <property name="orientation">vertical</property>
+                                <property name="valign">center</property>
+                                <property name="hexpand">1</property>
+                            </object>
+                        </child>
                     </object>
                 </child>
                 <child>

data/resources/ui/window.ui

@@ -309,6 +309,10 @@
         <attribute name="label" translatable="yes">_Enable over-amplification</attribute>
         <attribute name="action">win.enable-overamplification</attribute>
       </item>
+      <item>
+        <attribute name="label" translatable="yes">Use led peak meter</attribute>
+        <attribute name="action">win.use-peakmeter-led</attribute>
+      </item>
       <item>
         <attribute name="label" translatable="yes">_Keyboard Shortcuts</attribute>
         <attribute name="action">win.show-help-overlay</attribute>

src/ui/mod.rs

@@ -11,6 +11,8 @@ mod devicebox;
 mod profilerow;
 mod route_dropdown;
 mod volumescale;
+mod peakmeter;
+mod peak_meter_abstraction;
 
 pub use window::PwvucontrolWindow;
 pub use profile_dropdown::PwProfileDropDown;
@@ -24,3 +26,5 @@ pub use streambox::PwStreamBox;
 pub use profilerow::PwProfileRow;
 pub use route_dropdown::PwRouteDropDown;
 pub use volumescale::PwVolumeScale;
+pub use peakmeter::PwPeakMeter;
+pub use peak_meter_abstraction::{PeakMeterAbstraction, PeakMeterType};

src/ui/peak_meter_abstraction.rs

@@ -0,0 +1,77 @@
+use glib::object::Cast;
+use gtk::prelude::WidgetExt;
+
+use super::PwPeakMeter;
+
+pub enum PeakMeterType {
+    None,
+    Basic,
+    Led
+}
+
+
+#[derive(Debug)]
+enum PeakMeterWidget {
+    None,
+    Basic(gtk::LevelBar),
+    Led(PwPeakMeter)
+}
+
+#[derive(Debug)]
+pub struct PeakMeterAbstraction {
+    peak_meter: PeakMeterWidget,
+}
+
+impl PeakMeterAbstraction {
+    pub fn new(peak_meter_type: PeakMeterType) -> PeakMeterAbstraction {
+        match peak_meter_type {
+            PeakMeterType::Basic => {
+                let level_bar = gtk::LevelBar::new();
+                level_bar.set_mode(gtk::LevelBarMode::Continuous);
+                level_bar.set_min_value(0.0);
+                level_bar.set_max_value(1.0);
+    
+                level_bar.add_offset_value(gtk::LEVEL_BAR_OFFSET_LOW, 0.0);
+                level_bar.add_offset_value(gtk::LEVEL_BAR_OFFSET_HIGH, 0.0);
+                level_bar.add_offset_value(gtk::LEVEL_BAR_OFFSET_FULL, 1.0);
+
+                Self { peak_meter: PeakMeterWidget::Basic(level_bar)}
+            },
+            PeakMeterType::Led => {
+                let widget = PwPeakMeter::new();
+                Self { peak_meter: PeakMeterWidget::Led(widget)}
+            },
+            PeakMeterType::None => Self { peak_meter: PeakMeterWidget::None }
+        }
+    }
+
+    pub fn set_visible(&self, visible: bool) {
+        match &self.peak_meter {
+            PeakMeterWidget::Basic(level_bar) => level_bar.set_visible(visible),
+            PeakMeterWidget::Led(pw_peak_meter) => pw_peak_meter.set_visible(visible),
+            PeakMeterWidget::None => {},
+        }
+    }
+
+    pub fn set_level(&self, level: f32) {
+        match &self.peak_meter {
+            PeakMeterWidget::Basic(level_bar) => level_bar.set_value(level as f64),
+            PeakMeterWidget::Led(pw_peak_meter) => pw_peak_meter.set_level(level),
+            PeakMeterWidget::None => {},
+        }
+    }
+
+    pub fn get_widget(&self) -> Option<&gtk::Widget> {
+        match &self.peak_meter {
+            PeakMeterWidget::Basic(level_bar) => Some(level_bar.upcast_ref()),
+            PeakMeterWidget::Led(pw_peak_meter) => Some(pw_peak_meter.upcast_ref()),
+            PeakMeterWidget::None => None,
+        }
+    }
+}
+
+impl Default for PeakMeterAbstraction {
+    fn default() -> Self {
+        Self::new(PeakMeterType::None)
+    }
+}

src/ui/peakmeter.rs

@@ -0,0 +1,108 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+use gtk::{self, prelude::*, subclass::prelude::*};
+use std::cell::Cell;
+
+mod imp {
+    use gtk::{gdk::RGBA, graphene, gsk};
+
+    use super::*;
+
+    #[derive(Debug, Default, glib::Properties)]
+    #[properties(wrapper_type = super::PwPeakMeter)]
+    pub struct PwPeakMeter {
+        #[property(get, set = Self::set_level)]
+        pub(super) level: Cell<f32>,
+    }
+
+    #[glib::object_subclass]
+    impl ObjectSubclass for PwPeakMeter {
+        const NAME: &'static str = "PwPeakMeter";
+        type Type = super::PwPeakMeter;
+        type ParentType = gtk::Widget;
+    }
+
+    impl PwPeakMeter {
+        fn set_level(&self, level: f32) {
+            self.level.set(level);
+            self.obj().queue_draw();
+        }
+    }
+
+    #[glib::derived_properties]
+    impl ObjectImpl for PwPeakMeter {
+        fn constructed(&self) {
+            self.parent_constructed();
+            self.obj().add_css_class("vumeter");
+        }
+    }
+
+    impl WidgetImpl for PwPeakMeter {
+        fn snapshot(&self, snapshot: &gtk::Snapshot) {
+            const NUM_BLOCKS: u32 = 20;
+            const GREEN_LIMIT: u32 = (0.6 * NUM_BLOCKS as f32) as u32;
+            const YELLOW_LIMIT: u32 = (0.9 * NUM_BLOCKS as f32) as u32;
+
+            let width = self.obj().width() as u32;
+            let w = self.obj().width() as f32;
+            let h = self.obj().height() as f32;
+
+            let level = self.level.get() as f32;
+            let bounding_box = graphene::Rect::new(0.0, 0.0, w, h);
+
+            let rounded_rect = gsk::RoundedRect::from_rect(bounding_box, 5.0);
+
+            snapshot.push_rounded_clip(&rounded_rect);
+            snapshot.append_color(&RGBA::new(1.0, 1.0, 1.0, 0.1), &bounding_box);
+
+            let discrete_level = (level * NUM_BLOCKS as f32).floor() as u32;
+            let mut block_width = width / NUM_BLOCKS;
+            let extra_space = width - block_width * NUM_BLOCKS;
+            if extra_space > 0 {
+                block_width += 1;
+            }
+            let mut block_area_width = block_width;
+            let mut block_area_x = 0;
+
+            for i in 0..discrete_level {
+                if extra_space > 0 && i == extra_space {
+                    block_area_width -= 1;
+                }
+
+                let color = match i {
+                    0..GREEN_LIMIT => RGBA::GREEN,
+                    GREEN_LIMIT..YELLOW_LIMIT => RGBA::new(1.0, 1.0, 0.0, 1.0),
+                    _ => RGBA::RED,
+                };
+                snapshot.append_color(&color, &graphene::Rect::new(block_area_x as f32, 0.0, block_area_width as f32 - 1.0, h));
+                block_area_x += block_area_width;
+            }
+            snapshot.pop();
+        }
+
+        fn measure(&self, orientation: gtk::Orientation, _for_size: i32) -> (i32, i32, i32, i32) {
+            match orientation {
+                gtk::Orientation::Horizontal => (10, 10, -1, -1),
+                gtk::Orientation::Vertical => (10, 20, -1, -1),
+                _ => panic!("Invalid orientation passed to measure"),
+            }
+        }
+    }
+}
+
+glib::wrapper! {
+    pub struct PwPeakMeter(ObjectSubclass<imp::PwPeakMeter>) @extends gtk::Widget;
+}
+
+impl PwPeakMeter {
+    pub fn new() -> Self {
+        glib::Object::builder()
+        .build()
+    }
+}
+
+impl Default for PwPeakMeter {
+    fn default() -> Self {
+        Self::new()
+    }
+}

src/ui/volumebox.rs

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 use crate::{
-    backend::{NodeType, PwChannelObject, PwNodeObject, PwvucontrolManager}, ui::{LevelbarProvider, PwChannelBox, PwVolumeScale}
+    backend::{NodeType, PwChannelObject, PwNodeObject, PwvucontrolManager}, ui::{LevelbarProvider, PwChannelBox, PwVolumeScale, PeakMeterAbstraction}
 };
 use glib::{clone, closure_local, ControlFlow, SignalHandlerId};
 use gtk::{prelude::*, subclass::prelude::*};
@@ -25,6 +25,7 @@ mod imp {
         pub(super) level: Cell<f32>,
         pub(super) default_node: Cell<u32>,
         pub(super) default_node_changed_handler: RefCell<Option<Box<dyn Fn()>>>,
+        pub peak_meter: RefCell<PeakMeterAbstraction>,
 
         // Template widgets
         #[template_child]
@@ -36,7 +37,7 @@ mod imp {
         #[template_child]
         pub volume_scale: TemplateChild<PwVolumeScale>,
         #[template_child]
-        pub level_bar: TemplateChild<gtk::LevelBar>,
+        pub peakmeterbox: TemplateChild<gtk::Box>,
         #[template_child]
         pub mutebtn: TemplateChild<gtk::ToggleButton>,
         #[template_child]
@@ -156,13 +157,14 @@ mod imp {
                 widget.obj().grab_focus();
             }));
 
-            self.level_bar.set_min_value(0.0);
-            self.level_bar.set_max_value(1.0);
-
-            self.level_bar.add_offset_value(gtk::LEVEL_BAR_OFFSET_LOW, 0.0);
-            self.level_bar.add_offset_value(gtk::LEVEL_BAR_OFFSET_HIGH, 0.0);
-            self.level_bar.add_offset_value(gtk::LEVEL_BAR_OFFSET_FULL, 1.0);
+            let window = crate::ui::PwvucontrolWindow::default();
+            window
+                .imp()
+                .settings.connect_changed(Some("use-peakmeter-led"), clone!(@weak self as widget => move |_settings, _detail| {
+                    widget.setup_levelbar_widget();
+                }));
 
+            self.setup_levelbar_widget();
         }
 
         fn dispose(&self) {
@@ -186,14 +188,14 @@ mod imp {
 
         fn map(&self) {
             self.parent_map();
-
+            
             // Monitoring ourselves cause an infinite loop.
             let item = self.node_object.borrow();
             let item = item.as_ref().unwrap();
             if item.name() != "pwvucontrol-peak-detect" {
                 self.setuplevelbar();
             } else {
-                self.level_bar.set_visible(false);
+                self.peak_meter.borrow().set_visible(false);
             }
         }
     }
@@ -218,18 +220,35 @@ mod imp {
     impl PwVolumeBox {
         fn setuplevelbar(&self) {
             let item = self.node_object.borrow();
-            let item = item.as_ref().cloned().unwrap();
+            let item = item.as_ref().unwrap();
 
             if let Ok(provider) = LevelbarProvider::new(&self.obj(), item.boundid()) {
                 self.levelbarprovider.set(Some(provider));
 
                 let callbackid = self.obj().add_tick_callback(|widget, _fc| {
-                    widget.imp().level_bar.set_value(widget.imp().level.get() as f64);
+
+                    widget.imp().peak_meter.borrow().set_level(widget.imp().level.get());
                     ControlFlow::Continue
                 });
                 self.timeoutid.set(Some(callbackid));
             }
         }
+
+        fn setup_levelbar_widget(&self) {
+            let window = crate::ui::PwvucontrolWindow::default();
+            let peak_meter = match window.imp().settings.boolean("use-peakmeter-led") {
+                true => PeakMeterAbstraction::new(crate::ui::PeakMeterType::Led),
+                false => PeakMeterAbstraction::new(crate::ui::PeakMeterType::Basic)
+            };
+
+            if let Some (widget) = self.peak_meter.borrow().get_widget() {
+                self.peakmeterbox.remove(widget);
+            }
+            if let Some(widget) = peak_meter.get_widget() {
+                self.peakmeterbox.append(widget);
+            }
+            self.peak_meter.set(peak_meter);
+        }
     }
 }
 

src/ui/window.rs

@@ -5,7 +5,7 @@ use crate::{
     application::PwvucontrolApplication,
     backend::{PwDeviceObject, PwNodeObject, PwvucontrolManager},
     config::{APP_ID, PROFILE},
-    ui::{devicebox::PwDeviceBox, PwSinkBox, PwStreamBox, PwVolumeBox},
+    ui::{devicebox::PwDeviceBox, PwSinkBox, PwStreamBox},
 };
 use adw::subclass::prelude::*;
 use gettextrs::gettext;
@@ -71,8 +71,6 @@ mod imp {
         type ParentType = adw::ApplicationWindow;
 
         fn class_init(klass: &mut Self::Class) {
-            PwVolumeBox::ensure_type();
-
             klass.bind_template();
         }
 
@@ -179,6 +177,8 @@ mod imp {
 
             let overamplification_action = self.settings.create_action("enable-overamplification");
             self.obj().add_action(&overamplification_action);
+            let use_led_peakmeter_action = self.settings.create_action("use-peakmeter-led");
+            self.obj().add_action(&use_led_peakmeter_action);
 
             self.obj().load_window_state();
         }