shortens the spoken feedback

for most of the controls.

needs more testing...

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nvda_voicemeeter"
-version = "0.2.1b1"
+version = "0.2.2a1"
 description = "A Voicemeeter app compatible with NVDA"
 authors = [
     { name = "onyx-and-iris", email = "code@onyxandiris.online" },

src/nvda_voicemeeter/window.py

@@ -48,12 +48,8 @@ class NVDAVMWindow(psg.Window):
             [self[f"PATCH COMPOSITE||PC{i + 1}"].Widget.config(**buttonmenu_opts) for i in range(self.kind.phys_out)]
         slider_opts = {"takefocus": 1, "highlightthickness": 1}
         for i in range(self.kind.num_strip):
-            if i < self.kind.phys_in:
+            for param in util.get_slider_params(i, self.vm):
-                for param in util.get_slider_params(i, self.vm):
+                self[f"STRIP {i}||SLIDER {param}"].Widget.config(**slider_opts)
-                    self[f"STRIP {i}||SLIDER {param}"].Widget.config(**slider_opts)
-            else:
-                for param in ("BASS", "MID", "TREBLE"):
-                    self[f"STRIP {i}||SLIDER {param}"].Widget.config(**slider_opts)
             self[f"STRIP {i}||SLIDER GAIN"].Widget.config(**slider_opts)
             if self.kind.name != "basic":
                 self[f"STRIP {i}||SLIDER LIMIT"].Widget.config(**slider_opts)
@@ -109,6 +105,15 @@ class NVDAVMWindow(psg.Window):
             self[f"{key}||SLIDER"].update(value=value)
         for i in range(self.kind.num_strip):
             self[f"STRIP {i}||SLIDER GAIN"].update(value=self.vm.strip[i].gain)
+            if self.kind.name != "basic":
+                self[f"STRIP {i}||SLIDER LIMIT"].update(value=self.vm.strip[i].limit)
+            for param in util.get_slider_params(i, self.vm):
+                if param in ("AUDIBILITY", "BASS", "MID", "TREBLE"):
+                    val = getattr(self.vm.strip[i], param.lower())
+                else:
+                    target = getattr(self.vm.strip[i], param.lower())
+                    val = target.knob
+                self[f"STRIP {i}||SLIDER {param}"].update(value=val)
         for i in range(self.kind.num_bus):
             self[f"BUS {i}||SLIDER GAIN"].update(value=self.vm.bus[i].gain)
         if self.kind.name != "basic":
@@ -132,6 +137,30 @@ class NVDAVMWindow(psg.Window):
         self.bind("<Control-KeyPress-Tab>", "CTRL-TAB")
         self.bind("<Control-Shift-KeyPress-Tab>", "CTRL-SHIFT-TAB")
         self.bind("<Control-a>", "CTRL-A")
+        for i in range(1, 10):
+            self.bind(f"<Control-Key-{i}>", f"CTRL-{i}")
+        for i in range(1, 10):
+            self.bind(f"<Alt-Key-{i}>", f"ALT-{i}")
+        self.bind("<Control-o>", "CTRL-O")
+        self.bind("<Control-s>", "CTRL-S")
+        self.bind("<Control-m>", "CTRL-M")
+        self.bind("<Control-Alt-Right>", "CTRL-ALT-RIGHT")
+        self.bind("<Control-Alt-Left>", "CTRL-ALT-LEFT")
+
+        if self.kind.name == "basic":
+            self.bind("<Control-u>", "AUDIBILITY MODE")
+            self.bind("<Control-g>", "GAIN MODE")
+        elif self.kind.name == "banana":
+            self.bind("<Control-g>", "GAIN MODE")
+            self.bind("<Control-c>", "COMP MODE")
+            self.bind("<Control-t>", "GATE MODE")
+            self.bind("<Control-l>", "LIMIT MODE")
+        else:
+            self.bind("<Control-g>", "GAIN MODE")
+            self.bind("<Control-c>", "COMP MODE")
+            self.bind("<Control-t>", "GATE MODE")
+            self.bind("<Control-d>", "DENOISER MODE")
+            self.bind("<Control-l>", "LIMIT MODE")
 
         # Hardware In
         for i in range(self.vm.kind.phys_in):
@@ -211,6 +240,7 @@ class NVDAVMWindow(psg.Window):
                 self[f"STRIP {i}||SLIDER {param}"].bind("<Shift-KeyPress-Down>", "||KEY SHIFT DOWN")
                 self[f"STRIP {i}||SLIDER {param}"].bind("<Control-KeyPress-Up>", "||KEY CTRL UP")
                 self[f"STRIP {i}||SLIDER {param}"].bind("<Control-KeyPress-Down>", "||KEY CTRL DOWN")
+                self[f"STRIP {i}||SLIDER {param}"].bind("<Control-Shift-KeyPress-R>", "||KEY CTRL SHIFT R")
 
         # Bus Params
         params = ["MONO", "EQ", "MUTE", "MODE"]
@@ -237,6 +267,7 @@ class NVDAVMWindow(psg.Window):
             self[f"BUS {i}||SLIDER GAIN"].bind("<Shift-KeyPress-Down>", "||KEY SHIFT DOWN")
             self[f"BUS {i}||SLIDER GAIN"].bind("<Control-KeyPress-Up>", "||KEY CTRL UP")
             self[f"BUS {i}||SLIDER GAIN"].bind("<Control-KeyPress-Down>", "||KEY CTRL DOWN")
+            self[f"BUS {i}||SLIDER GAIN"].bind("<Control-Shift-KeyPress-R>", "||KEY CTRL SHIFT R")
 
     def popup_save_as(self, message, title=None, initial_folder=None):
         layout = [
@@ -392,6 +423,7 @@ class NVDAVMWindow(psg.Window):
 
         Main thread will shutdown once a close or exit event occurs
         """
+        mode = None
 
         while True:
             event, values = self.read()
@@ -399,6 +431,20 @@ class NVDAVMWindow(psg.Window):
             self.logger.debug(f"values::{values}")
             if event in (psg.WIN_CLOSED, "Exit"):
                 break
+            if event in ("GAIN MODE", "COMP MODE", "GATE MODE", "DENOISER MODE", "LIMIT MODE"):
+                mode = event
+                if mode:
+                    self.nvda.speak(f"{mode} enabled")
+            elif event == "Escape:27":
+                if mode:
+                    self.nvda.speak(f"{mode.split()[0]} mode disabled")
+                    mode = None
+
+            if mode:
+                if event == "Left:37":
+                    self.write_event_value("SLIDER-MODE-LEFT", mode.split()[0])
+                elif event == "Right:39":
+                    self.write_event_value("SLIDER-MODE-RIGHT", mode.split()[0])
 
             match parsed_cmd := self.parser.match.parseString(event):
                 # Focus tabgroup
@@ -406,6 +452,85 @@ class NVDAVMWindow(psg.Window):
                     self["tabgroup"].set_focus()
                     self.nvda.speak(f"{values['tabgroup']}")
 
+                # Quick Navigation
+                case ["CTRL-1" | "CTRL-2" | "CTRL-3" | "CTRL-4" | "CTRL-5" | "CTRL-6" | "CTRL-7" | "CTRL-8" as bind]:
+                    key, index = bind.split("-")
+                    match values["tabgroup"]:
+                        case "tab||Physical Strip":
+                            if int(index) > self.kind.phys_in:
+                                continue
+                            self[f"STRIP {int(index) - 1}||A1"].set_focus()
+                            if (
+                                self.find_element_with_focus() is None
+                                or self.find_element_with_focus().Key != f"STRIP {int(index) - 1}||A1"
+                            ):
+                                self[f"STRIP {int(index) - 1}||SLIDER GAIN"].set_focus()
+                        case "tab||Virtual Strip":
+                            index = int(index) + self.kind.phys_in
+                            if index > self.kind.num_strip:
+                                continue
+                            self[f"STRIP {index - 1}||A1"].set_focus()
+                            if (
+                                self.find_element_with_focus() is None
+                                or self.find_element_with_focus().Key != f"STRIP {int(index) - 1}||A1"
+                            ):
+                                self[f"STRIP {int(index) - 1}||SLIDER GAIN"].set_focus()
+                        case "tab||Buses":
+                            if int(index) > self.kind.num_bus:
+                                continue
+                            self[f"BUS {int(index) - 1}||MONO"].set_focus()
+                            if (
+                                self.find_element_with_focus() is None
+                                or self.find_element_with_focus().Key != f"BUS {int(index) - 1}||MONO"
+                            ):
+                                self[f"BUS {int(index) - 1}||SLIDER GAIN"].set_focus()
+                case ["ALT-1" | "ALT-2" | "ALT-3" | "ALT-4" | "ALT-5" | "ALT-6" | "ALT-7" | "ALT-8" as bind]:
+                    if values["tabgroup"] not in ("tab||Physical Strip", "tab||Virtual Strip", "tab||Buses"):
+                        continue
+                    key, index = bind.split("-")
+                    if int(index) > self.kind.phys_out + self.kind.virt_out:
+                        continue
+                    if focus := self.find_element_with_focus():
+                        identifier, param = focus.Key.split("||")
+                        if int(index) <= self.kind.phys_out:
+                            self.write_event_value(f"{identifier}||A{int(index)}", None)
+                        else:
+                            self.write_event_value(f"{identifier}||B{int(index) - self.kind.phys_out}", None)
+                case ["CTRL-O"]:
+                    if values["tabgroup"] not in ("tab||Physical Strip", "tab||Virtual Strip", "tab||Buses"):
+                        continue
+                    if focus := self.find_element_with_focus():
+                        identifier, param = focus.Key.split("||")
+                        self.write_event_value(f"{identifier}||MONO", None)
+                case ["CTRL-S"]:
+                    if values["tabgroup"] not in ("tab||Physical Strip", "tab||Virtual Strip"):
+                        continue
+                    if focus := self.find_element_with_focus():
+                        identifier, param = focus.Key.split("||")
+                        self.write_event_value(f"{identifier}||SOLO", None)
+                case ["CTRL-M"]:
+                    if values["tabgroup"] not in ("tab||Physical Strip", "tab||Virtual Strip", "tab||Buses"):
+                        continue
+                    if focus := self.find_element_with_focus():
+                        identifier, param = focus.Key.split("||")
+                        self.write_event_value(f"{identifier}||MUTE", None)
+                case ["SLIDER-MODE-LEFT"]:
+                    if values["tabgroup"] not in ("tab||Physical Strip", "tab||Virtual Strip", "tab||Buses"):
+                        continue
+                    param = values[event]
+                    if focus := self.find_element_with_focus():
+                        identifier, partial = focus.Key.split("||")
+                        if "SLIDER" not in partial:
+                            self.write_event_value(f"{identifier}||SLIDER {param}||KEY LEFT", None)
+                case ["SLIDER-MODE-RIGHT"]:
+                    if values["tabgroup"] not in ("tab||Physical Strip", "tab||Virtual Strip", "tab||Buses"):
+                        continue
+                    param = values[event]
+                    if focus := self.find_element_with_focus():
+                        identifier, partial = focus.Key.split("||")
+                        if "SLIDER" not in partial:
+                            self.write_event_value(f"{identifier}||SLIDER {param}||KEY RIGHT", None)
+
                 # Rename popups
                 case ["F2:113"]:
                     tab = values["tabgroup"]
@@ -558,7 +683,7 @@ class NVDAVMWindow(psg.Window):
                     val = values[f"ASIO CHECKBOX||{in_num} {channel}"]
                     self.vm.patch.asio[index].set(val)
                     channel = ("left", "right")[int(channel)]
-                    self.nvda.speak(f"Patch ASIO {in_num} {channel} set to {val}")
+                    self.nvda.speak(str(val))
                 case [["ASIO", "CHECKBOX"], [in_num, channel], ["FOCUS", "IN"]]:
                     if self.find_element_with_focus() is not None:
                         val = values[f"ASIO CHECKBOX||{in_num} {channel}"]
@@ -592,9 +717,7 @@ class NVDAVMWindow(psg.Window):
                     )
                     val = values[f"INSERT CHECKBOX||{in_num} {channel}"]
                     self.vm.patch.insert[index].on = val
-                    self.nvda.speak(
+                    self.nvda.speak(f"{'on' if val else 'off'}")
-                        f"PATCH INSERT {in_num} {util._patch_insert_channels[int(channel)]} set to {'on' if val else 'off'}"
-                    )
                 case [["INSERT", "CHECKBOX"], [in_num, channel], ["FOCUS", "IN"]]:
                     if self.find_element_with_focus() is not None:
                         index = util.get_insert_checkbox_index(
@@ -634,19 +757,17 @@ class NVDAVMWindow(psg.Window):
                                     next_val = 0
                                 setattr(self.vm.strip[int(index)], actual, next_val)
                                 self.cache["strip"][f"STRIP {index}||{param}"] = next_val
-                                self.nvda.speak(
+                                self.nvda.speak(["off", "k m", "k 1", "k 2"][next_val])
-                                    f"{label} {phonetic.get(actual, actual)} {['off', 'k m', 'k 1', 'k 2'][next_val]}"
-                                )
                             else:
                                 val = not self.cache["strip"][f"STRIP {index}||{param}"]
                                 setattr(self.vm.strip[int(index)], actual, val)
                                 self.cache["strip"][f"STRIP {index}||{param}"] = val
-                                self.nvda.speak(f"{label} {phonetic.get(actual, actual)} {'on' if val else 'off'}")
+                                self.nvda.speak("on" if val else "off")
                         case _:
                             val = not self.cache["strip"][f"STRIP {index}||{param}"]
                             setattr(self.vm.strip[int(index)], param if param[0] in ("A", "B") else param.lower(), val)
                             self.cache["strip"][f"STRIP {index}||{param}"] = val
-                            self.nvda.speak(f"{label} {param} {'on' if val else 'off'}")
+                            self.nvda.speak("on" if val else "off")
                 case [["STRIP", index], [param], ["FOCUS", "IN"]]:
                     if self.find_element_with_focus() is not None:
                         val = self.cache["strip"][f"STRIP {index}||{param}"]
@@ -687,7 +808,6 @@ class NVDAVMWindow(psg.Window):
                         | "TREBLE" as param,
                     ],
                 ]:
-                    label = self.cache["labels"][f"STRIP {index}||LABEL"]
                     val = values[event]
                     match param:
                         case "GAIN":
@@ -702,7 +822,6 @@ class NVDAVMWindow(psg.Window):
                             self.vm.strip[int(index)].limit = val
                         case "BASS" | "MID" | "TREBLE":
                             setattr(self.vm.strip[int(index)], param.lower(), val)
-                    self.nvda.speak(f"{label} {param} slider {val}")
                 case [
                     ["STRIP", index],
                     [
@@ -721,11 +840,9 @@ class NVDAVMWindow(psg.Window):
                 ]:
                     if self.find_element_with_focus() is not None:
                         self.vm.event.pdirty = False
-                        label = self.cache["labels"][f"STRIP {index}||LABEL"]
                         val = values[f"STRIP {index}||SLIDER {param}"]
-                        if param == "LIMIT":
+                        label = self.cache["labels"][f"STRIP {index}||LABEL"]
-                            val = int(val)
+                        self.nvda.speak(f"{label} {param} {int(val) if param == 'LIMIT' else val}")
-                        self.nvda.speak(f"{label} {param} slider {val}")
                 case [
                     ["STRIP", index],
                     [
@@ -772,20 +889,26 @@ class NVDAVMWindow(psg.Window):
 
                     match param:
                         case "GAIN":
-                            self.vm.strip[int(index)].gain = util.check_bounds(val, (-60, 12))
+                            val = util.check_bounds(val, (-60, 12))
-                            self[f"STRIP {index}||SLIDER {param}"].update(value=util.check_bounds(val, (-60, 12)))
+                            self.vm.strip[int(index)].gain = val
+                            self[f"STRIP {index}||SLIDER {param}"].update(value=val)
                         case "COMP" | "GATE" | "DENOISER":
-                            setattr(target, "knob", util.check_bounds(val, (0, 10)))
+                            val = util.check_bounds(val, (0, 10))
-                            self[f"STRIP {index}||SLIDER {param}"].update(value=util.check_bounds(val, (0, 10)))
+                            setattr(target, "knob", val)
+                            self[f"STRIP {index}||SLIDER {param}"].update(value=val)
                         case "AUDIBILITY":
-                            self.vm.strip[int(index)].audibility = util.check_bounds(val, (0, 10))
+                            val = util.check_bounds(val, (0, 10))
-                            self[f"STRIP {index}||SLIDER {param}"].update(value=util.check_bounds(val, (0, 10)))
+                            self.vm.strip[int(index)].audibility = val
+                            self[f"STRIP {index}||SLIDER {param}"].update(value=val)
                         case "BASS" | "MID" | "TREBLE":
-                            setattr(self.vm.strip[int(index)], param.lower(), util.check_bounds(val, (-12, 12)))
+                            val = util.check_bounds(val, (-12, 12))
-                            self[f"STRIP {index}||SLIDER {param}"].update(value=util.check_bounds(val, (-12, 12)))
+                            setattr(self.vm.strip[int(index)], param.lower(), val)
+                            self[f"STRIP {index}||SLIDER {param}"].update(value=val)
                         case "LIMIT":
-                            self.vm.strip[int(index)].limit = util.check_bounds(val, (-40, 12))
+                            val = util.check_bounds(val, (-40, 12))
-                            self[f"STRIP {index}||SLIDER {param}"].update(value=util.check_bounds(val, (-40, 12)))
+                            self.vm.strip[int(index)].limit = val
+                            self[f"STRIP {index}||SLIDER {param}"].update(value=val)
+                    self.nvda.speak(str(val))
                 case [
                     ["STRIP", index],
                     [
@@ -829,20 +952,26 @@ class NVDAVMWindow(psg.Window):
 
                     match param:
                         case "GAIN":
-                            self.vm.strip[int(index)].gain = util.check_bounds(val, (-60, 12))
+                            val = util.check_bounds(val, (-60, 12))
-                            self[f"STRIP {index}||SLIDER {param}"].update(value=util.check_bounds(val, (-60, 12)))
+                            self.vm.strip[int(index)].gain = val
+                            self[f"STRIP {index}||SLIDER {param}"].update(value=val)
                         case "COMP" | "GATE" | "DENOISER":
-                            setattr(target, "knob", util.check_bounds(val, (0, 10)))
+                            val = util.check_bounds(val, (0, 10))
-                            self[f"STRIP {index}||SLIDER {param}"].update(value=util.check_bounds(val, (0, 10)))
+                            setattr(target, "knob", val)
+                            self[f"STRIP {index}||SLIDER {param}"].update(value=val)
                         case "AUDIBILITY":
-                            self.vm.strip[int(index)].audibility = util.check_bounds(val, (0, 10))
+                            val = util.check_bounds(val, (0, 10))
-                            self[f"STRIP {index}||SLIDER {param}"].update(value=util.check_bounds(val, (0, 10)))
+                            self.vm.strip[int(index)].audibility = val
+                            self[f"STRIP {index}||SLIDER {param}"].update(value=val)
                         case "BASS" | "MID" | "TREBLE":
-                            setattr(self.vm.strip[int(index)], param.lower(), util.check_bounds(val, (-12, 12)))
+                            val = util.check_bounds(val, (-12, 12))
-                            self[f"STRIP {index}||SLIDER {param}"].update(value=util.check_bounds(val, (-12, 12)))
+                            setattr(self.vm.strip[int(index)], param.lower(), val)
+                            self[f"STRIP {index}||SLIDER {param}"].update(value=val)
                         case "LIMIT":
-                            self.vm.strip[int(index)].limit = util.check_bounds(val, (-40, 12))
+                            val = util.check_bounds(val, (-40, 12))
-                            self[f"STRIP {index}||SLIDER {param}"].update(value=util.check_bounds(val, (-40, 12)))
+                            self.vm.strip[int(index)].limit = val
+                            self[f"STRIP {index}||SLIDER {param}"].update(value=val)
+                    self.nvda.speak(f"{param} {val}")
                 case [
                     ["STRIP", index],
                     [
@@ -886,20 +1015,44 @@ class NVDAVMWindow(psg.Window):
 
                     match param:
                         case "GAIN":
-                            self.vm.strip[int(index)].gain = util.check_bounds(val, (-60, 12))
+                            val = util.check_bounds(val, (-60, 12))
-                            self[f"STRIP {index}||SLIDER {param}"].update(value=util.check_bounds(val, (-60, 12)))
+                            self.vm.strip[int(index)].gain = val
+                            self[f"STRIP {index}||SLIDER {param}"].update(value=val)
                         case "COMP" | "GATE" | "DENOISER":
-                            setattr(target, "knob", util.check_bounds(val, (0, 10)))
+                            val = util.check_bounds(val, (0, 10))
-                            self[f"STRIP {index}||SLIDER {param}"].update(value=util.check_bounds(val, (0, 10)))
+                            setattr(target, "knob", val)
+                            self[f"STRIP {index}||SLIDER {param}"].update(value=val)
                         case "AUDIBILITY":
-                            self.vm.strip[int(index)].audibility = util.check_bounds(val, (0, 10))
+                            val = util.check_bounds(val, (0, 10))
-                            self[f"STRIP {index}||SLIDER {param}"].update(value=util.check_bounds(val, (0, 10)))
+                            self.vm.strip[int(index)].audibility = val
+                            self[f"STRIP {index}||SLIDER {param}"].update(value=val)
                         case "BASS" | "MID" | "TREBLE":
-                            setattr(self.vm.strip[int(index)], param.lower(), util.check_bounds(val, (-12, 12)))
+                            val = util.check_bounds(val, (-12, 12))
-                            self[f"STRIP {index}||SLIDER {param}"].update(value=util.check_bounds(val, (-12, 12)))
+                            setattr(self.vm.strip[int(index)], param.lower(), val)
+                            self[f"STRIP {index}||SLIDER {param}"].update(value=val)
                         case "LIMIT":
-                            self.vm.strip[int(index)].limit = util.check_bounds(val, (-40, 12))
+                            val = util.check_bounds(val, (-40, 12))
-                            self[f"STRIP {index}||SLIDER {param}"].update(value=util.check_bounds(val, (-40, 12)))
+                            self.vm.strip[int(index)].limit = val
+                            self[f"STRIP {index}||SLIDER {param}"].update(value=val)
+                    self.nvda.speak(f"{param} {val}")
+                case [["STRIP", index], ["SLIDER", param], ["KEY", "CTRL", "SHIFT", "R"]]:
+                    match param:
+                        case "GAIN":
+                            self.vm.strip[int(index)].gain = 0
+                            self[f"STRIP {index}||SLIDER {param}"].update(value=0)
+                        case "COMP" | "GATE" | "DENOISER":
+                            setattr(target, "knob", 0)
+                            self[f"STRIP {index}||SLIDER {param}"].update(value=0)
+                        case "AUDIBILITY":
+                            self.vm.strip[int(index)].audibility = 0
+                            self[f"STRIP {index}||SLIDER {param}"].update(value=0)
+                        case "BASS" | "MID" | "TREBLE":
+                            setattr(self.vm.strip[int(index)], param.lower(), 0)
+                            self[f"STRIP {index}||SLIDER {param}"].update(value=0)
+                        case "LIMIT":
+                            self.vm.strip[int(index)].limit = 12
+                            self[f"STRIP {index}||SLIDER {param}"].update(value=12)
+                    self.nvda.speak(f"{param} {12 if param == 'LABEL' else 0}")
 
                 # Bus Params
                 case [["BUS", index], [param]]:
@@ -913,7 +1066,7 @@ class NVDAVMWindow(psg.Window):
                             self.TKroot.after(
                                 200,
                                 self.nvda.speak,
-                                f"{label} bus {param} {'on' if val else 'off'}",
+                                "on" if val else "off",
                             )
                         case "MONO" | "MUTE":
                             val = not val
@@ -922,7 +1075,7 @@ class NVDAVMWindow(psg.Window):
                             self.TKroot.after(
                                 200,
                                 self.nvda.speak,
-                                f"{label} bus {param} {'on' if val else 'off'}",
+                                "on" if val else "off",
                             )
                         case "MODE":
                             bus_modes = util.get_bus_modes(self.vm)
@@ -947,7 +1100,7 @@ class NVDAVMWindow(psg.Window):
                             self.TKroot.after(
                                 200,
                                 self.nvda.speak,
-                                f"{label} bus mode {phonetic.get(next_bus, next_bus)}",
+                                phonetic.get(next_bus, next_bus),
                             )
                 case [["BUS", index], [param], ["FOCUS", "IN"]]:
                     if self.find_element_with_focus() is not None:
@@ -965,13 +1118,12 @@ class NVDAVMWindow(psg.Window):
                     label = self.cache["labels"][f"BUS {index}||LABEL"]
                     val = values[event]
                     self.vm.bus[int(index)].gain = val
-                    self.nvda.speak(f"{label} gain slider {val}")
                 case [["BUS", index], ["SLIDER", "GAIN"], ["FOCUS", "IN"]]:
                     if self.find_element_with_focus() is not None:
                         self.vm.event.pdirty = False
                         label = self.cache["labels"][f"BUS {index}||LABEL"]
                         val = values[f"BUS {index}||SLIDER GAIN"]
-                        self.nvda.speak(f"{label} gain slider {val}")
+                        self.nvda.speak(f"{label} gain {val}")
                 case [["BUS", index], ["SLIDER", "GAIN"], ["FOCUS", "OUT"]]:
                     self.vm.event.pdirty = True
                 case [["BUS", index], ["SLIDER", "GAIN"], ["KEY", "LEFT" | "RIGHT" | "UP" | "DOWN" as direction]]:
@@ -994,8 +1146,10 @@ class NVDAVMWindow(psg.Window):
                             val += 3
                         case "LEFT" | "DOWN":
                             val -= 3
-                    self.vm.bus[int(index)].gain = util.check_bounds(val, (-60, 12))
+                    val = util.check_bounds(val, (-60, 12))
+                    self.vm.bus[int(index)].gain = val
                     self[f"BUS {index}||SLIDER GAIN"].update(value=val)
+                    self.nvda.speak(str(val))
                 case [
                     ["BUS", index],
                     ["SLIDER", "GAIN"],
@@ -1009,6 +1163,11 @@ class NVDAVMWindow(psg.Window):
                             val -= 0.1
                     self.vm.bus[int(index)].gain = util.check_bounds(val, (-60, 12))
                     self[f"BUS {index}||SLIDER GAIN"].update(value=val)
+                    self.nvda.speak(str(val))
+                case [["BUS", index], ["SLIDER", "GAIN"], ["KEY", "CTRL", "SHIFT", "R"]]:
+                    self.vm.bus[int(index)].gain = 0
+                    self[f"BUS {index}||SLIDER GAIN"].update(value=0)
+                    self.nvda.speak(str(val))
 
                 # Unknown
                 case _: