volume: show percentage whilst changing volume

applets/volume/__init__.py

@@ -21,6 +21,7 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

                                
                                
                                
                            
                                
                                    
                                        
                                            21  
                                            OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            22  
                                            SOFTWARE.
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            23  
                                            """
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        24 +
                                        import locale
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            25  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            26  
                                            import panorama_panel
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            27  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        

@@ -39,6 +40,11 @@ class Volume(panorama_panel.Applet):

                                
                                
                                
                            
                                
                                    
                                        
                                            40  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            41  
                                                def __init__(self, orientation=Gtk.Orientation.HORIZONTAL, config=None):
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            42  
                                                    super().__init__()
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        43 +
                                                if config is None:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        44 +
                                                    config = {}
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        45 +
                                                self.popdown_after_manual = config.get("popdown_after_manual", 2000)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        46 +
                                                self.percentage_reveal = config.get("percentage_reveal", 1000)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        47 +
                                                self.percentage_animation_time = config.get("percentage_animation_time", 250)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            48  
                                                    asyncio.create_task(self.main())
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            49  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            50  
                                                async def main(self):
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        

@@ -57,9 +63,12 @@ class Volume(panorama_panel.Applet):

                                
                                
                                
                            
                                
                                    
                                        
                                            63  
                                                    self.volume_scale_changed_handler = self.volume_scale.connect("value-changed", self.on_scale_changed)
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            64  
                                                    self.volume_popover = Gtk.Popover()
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            65  
                                                    self.volume_popover.set_child(self.volume_scale)
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        60 -
                                                self.volume_popover.connect("show", self.on_popover_show)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            66  
                                                    self.menu_button.set_popover(self.volume_popover)
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            67  
                                                    self.menu_button.set_has_frame(False)
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        68 +
                                                self.button_content = Gtk.Box(orientation=self.get_orientation())
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        69 +
                                                self.icon = Gtk.Image()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        70 +
                                                self.button_content.append(self.icon)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        71 +
                                                self.menu_button.set_child(self.button_content)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            72  
                                                    scroll_controller = Gtk.EventControllerScroll.new(Gtk.EventControllerScrollFlags.VERTICAL)
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            73  
                                                    scroll_controller.set_propagation_phase(Gtk.PropagationPhase.CAPTURE)
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            74  
                                                    self.volume_popover.add_controller(scroll_controller)
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        

@@ -69,6 +78,7 @@ class Volume(panorama_panel.Applet):

                                
                                
                                
                            
                                
                                    
                                        
                                            78  
                                                    self.add_controller(scroll_controller)
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            79  
                                                    scroll_controller.connect("scroll", self.on_button_scroll)
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            80  
                                                    self.popdown_timeout = None
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        81 +
                                                self.conceal_timeout = None
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            82  
                                                    self.set_button_icon()
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            83  
                                                    gesture_click = Gtk.GestureClick()
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            84  
                                                    gesture_click.set_button(Gdk.BUTTON_MIDDLE)
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        

@@ -76,9 +86,47 @@ class Volume(panorama_panel.Applet):

                                
                                
                                
                            
                                
                                    
                                        
                                            86  
                                                    self.add_controller(gesture_click)
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            87  
                                                    self.append(self.menu_button)
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            88  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        89 +
                                                self.revealer = Gtk.Revealer(transition_duration=self.percentage_animation_time)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        90 +
                                                self.button_content.append(self.revealer)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        91 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        92 +
                                                if self.get_orientation() == Gtk.Orientation.HORIZONTAL:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        93 +
                                                    self.revealer.set_transition_type(Gtk.RevealerTransitionType.SLIDE_RIGHT)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        94 +
                                                elif self.get_orientation() == Gtk.Orientation.VERTICAL:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        95 +
                                                    self.revealer.set_transition_type(Gtk.RevealerTransitionType.SLIDE_DOWN)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        96 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        97 +
                                                self.percentage_label = Gtk.Label()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        98 +
                                                self.percentage_label.set_width_chars(5)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        99 +
                                                self.update_text()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        100 +
                                                self.revealer.set_child(self.percentage_label)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        101 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        102 +
                                                self.volume_popover.connect("show", self.popover_shown)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        103 +
                                                self.volume_popover.connect("closed", self.popover_hidden)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        104 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        105 +
                                                if not self.percentage_reveal:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        106 +
                                                    self.revealer.set_reveal_child(True)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        107 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            108  
                                                    loop = asyncio.get_event_loop()
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            109  
                                                    loop.create_task(self.listen())
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            110  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        111 +
                                            def popover_shown(self, *args):
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        112 +
                                                if self.percentage_reveal != -1:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        113 +
                                                    self.revealer.set_reveal_child(True)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        114 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        115 +
                                            def popover_hidden(self, *args):
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        116 +
                                                if self.percentage_reveal:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        117 +
                                                    self.revealer.set_reveal_child(False)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        118 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        119 +
                                            def set_panel_position(self, position: Gtk.PositionType):
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        120 +
                                                if not hasattr(self, "revealer"):
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        121 +
                                                    return
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        122 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        123 +
                                                if position in {Gtk.PositionType.TOP, Gtk.PositionType.BOTTOM}:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        124 +
                                                    self.revealer.set_transition_type(Gtk.RevealerTransitionType.SLIDE_RIGHT)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        125 +
                                                    self.button_content.set_orientation(Gtk.Orientation.HORIZONTAL)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        126 +
                                                elif position in {Gtk.PositionType.LEFT, Gtk.PositionType.RIGHT}:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        127 +
                                                    self.revealer.set_transition_type(Gtk.RevealerTransitionType.SLIDE_DOWN)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        128 +
                                                    self.button_content.set_orientation(Gtk.Orientation.VERTICAL)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        129 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            130  
                                                def on_middle_click_released(self, gesture, n_press, x, y):
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            131  
                                                    loop = asyncio.get_event_loop()
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            132  
                                                    loop.create_task(self.idle_on_middle_click_released())
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        

@@ -92,22 +140,17 @@ class Volume(panorama_panel.Applet):

                                
                                
                                
                            
                                
                                    
                                        
                                            140  
                                                        self.default_sink.mute = True
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            141  
                                                    self.set_button_icon()
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            142  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        95 -
                                            def on_popover_show(self, popover):
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        96 -
                                                if self.popdown_timeout is not None:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        97 -
                                                    GLib.source_remove(self.popdown_timeout)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        98 -
                                                self.popdown_timeout = GLib.timeout_add(2000, self.close_scale_popover)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        99 -
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            143  
                                                def set_button_icon(self):
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            144  
                                                    volume = self.current_volume
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        102 -
                                                threshold = 1.0 / 3.0
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        145 +
                                                threshold = 1 / 3
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            146  
                                                    if volume == 0.0 or self.default_sink.mute:
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        104 -
                                                    self.menu_button.set_icon_name("audio-volume-muted-symbolic")
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        147 +
                                                    self.icon.set_from_icon_name("audio-volume-muted-symbolic")
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            148  
                                                    elif volume < threshold:
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        106 -
                                                    self.menu_button.set_icon_name("audio-volume-low-symbolic")
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        149 +
                                                    self.icon.set_from_icon_name("audio-volume-low-symbolic")
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            150  
                                                    elif volume < threshold * 2:
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        108 -
                                                    self.menu_button.set_icon_name("audio-volume-medium-symbolic")
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        151 +
                                                    self.icon.set_from_icon_name("audio-volume-medium-symbolic")
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            152  
                                                    else:
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        110 -
                                                    self.menu_button.set_icon_name("audio-volume-high-symbolic")
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        153 +
                                                    self.icon.set_from_icon_name("audio-volume-high-symbolic")
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            154  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            155  
                                                def on_button_scroll(self, controller, dx, dy):
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            156  
                                                    if dy < 0 or dy > 0:
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        

@@ -128,9 +171,11 @@ class Volume(panorama_panel.Applet):

                                
                                
                                
                            
                                
                                    
                                        
                                            171  
                                                    self.volume_scale.set_value(new_volume)
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            172  
                                                    self.current_volume = new_volume
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            173  
                                                    self.set_button_icon()
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        174 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            175  
                                                    if self.popdown_timeout is not None:
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            176  
                                                        GLib.source_remove(self.popdown_timeout)
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        133 -
                                                self.popdown_timeout = GLib.timeout_add(2000, self.close_scale_popover)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        177 +
                                                if self.popdown_after_manual:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        178 +
                                                    self.popdown_timeout = GLib.timeout_add(self.popdown_after_manual, self.close_scale_popover)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            179  
                                                    return Gdk.EVENT_STOP
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            180  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            181  
                                                async def idle_volume_update(self):
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        

@@ -138,15 +183,20 @@ class Volume(panorama_panel.Applet):

                                
                                
                                
                            
                                
                                    
                                        
                                            183  
                                                    await self.pulse.volume_set_all_chans(self.default_sink, new_volume)
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            184  
                                                    self.current_volume = new_volume
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            185  
                                                    self.set_button_icon()
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        186 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            187  
                                                    if self.popdown_timeout is not None:
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            188  
                                                        GLib.source_remove(self.popdown_timeout)
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        143 -
                                                self.popdown_timeout = GLib.timeout_add(2000, self.close_scale_popover)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        189 +
                                                if self.popdown_after_manual:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        190 +
                                                    self.popdown_timeout = GLib.timeout_add(self.popdown_after_manual, self.close_scale_popover)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            191  
                                                    return False
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            192  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            193  
                                                def on_scale_changed(self, scale, *args):
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            194  
                                                    loop = asyncio.get_event_loop()
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            195  
                                                    loop.create_task(self.idle_volume_update())
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            196  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        197 +
                                            def update_text(self):
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        198 +
                                                self.percentage_label.set_text(f"{locale.format_string('%d', self.current_volume * 100)}%")
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        199 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            200  
                                                async def idle_update_scale(self):
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            201  
                                                    server_info = await self.pulse.server_info()
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            202  
                                                    self.default_sink = await self.pulse.get_sink_by_name(server_info.default_sink_name)
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        

@@ -157,11 +207,25 @@ class Volume(panorama_panel.Applet):

                                
                                
                                
                            
                                
                                    
                                        
                                            207  
                                                    self.current_volume = new_volume
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            208  
                                                    self.volume_scale.set_value(self.current_volume)
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            209  
                                                    self.set_button_icon()
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        160 -
                                                if self.popdown_timeout is not None:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        161 -
                                                    GLib.source_remove(self.popdown_timeout)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        162 -
                                                self.popdown_timeout = GLib.timeout_add(2000, self.close_scale_popover)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        210 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        211 +
                                                self.update_text()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        212 +
                                                if self.percentage_reveal != -1:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        213 +
                                                    self.revealer.set_reveal_child(True)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        214 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        215 +
                                                if self.conceal_timeout is not None:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        216 +
                                                    GLib.source_remove(self.conceal_timeout)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        217 +
                                                if self.percentage_reveal > 0:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        218 +
                                                    self.conceal_timeout = GLib.timeout_add(self.percentage_reveal, self.conceal_percentage)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            219  
                                                    return False
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            220  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        221 +
                                            def conceal_percentage(self):
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        222 +
                                                if not self.percentage_reveal:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        223 +
                                                    return
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        224 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        225 +
                                                if not self.volume_popover.get_visible():
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        226 +
                                                    self.revealer.set_reveal_child(False)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        227 +
                                                self.conceal_timeout = None
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        228 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            229  
                                                def close_scale_popover(self):
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            230  
                                                    self.popdown_timeout = None
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            231  
                                                    self.menu_button.popdown()
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        

@@ -177,3 +241,10 @@ class Volume(panorama_panel.Applet):

                                
                                
                                
                            
                                
                                    
                                        
                                            241  
                                                                loop.create_task(self.idle_update_scale())
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            242  
                                                            except pulsectl_asyncio.PulseOperationFailed:
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            243  
                                                                print(f"Could not retrieve info for sink index {event.index}")
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        244 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        245 +
                                            def get_config(self):
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        246 +
                                                return {
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        247 +
                                                    "percentage_reveal": self.percentage_reveal,
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        248 +
                                                    "popdown_after_manual": self.popdown_after_manual,
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        249 +
                                                    "percentage_animation_time": self.percentage_animation_time,
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        250 +
                                                }
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                            
                                

config.yaml

@@ -50,7 +50,10 @@ panels:

                                
                                
                                
                            
                                
                                    
                                        
                                            50  
                                                centre:
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            51  
                                                - NotifierApplet: {}
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            52  
                                                right:
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        53 -
                                            - Volume: {}
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        53 +
                                            - Volume:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        54 +
                                                percentage_reveal: 1000
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        55 +
                                                popdown_after_manual: 2000
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        56 +
                                                percentage_animation_time: 250
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            57  
                                                - ClockApplet:
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            58  
                                                    formatting: '%T, %a %-d %b %Y'
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            59  
                                            - position: bottom