removes the spinbox from the rename popup

updates README

fixes #12

b1 bump

README.md

@@ -8,7 +8,7 @@ A remote control app for [Voicemeeter][voicemeeter], designed to be used with th
 
 For an outline of this projects goals see the [SPECIFICATION][spec].
 
-<img src="./img/settings.png" width=350 alt="Image of Voicemeeter NVDA app settings tab">
+<img src="./img/nvda-voicemeeter.png" width=960 alt="Image of Voicemeeter NVDA app settings tab">
 
 ## Requirements
 
@@ -57,7 +57,7 @@ import nvda_voicemeeter
 
 KIND_ID = "potato"
 
-with voicemeeterlib.api(KIND_ID, sync=True) as vm:
+with voicemeeterlib.api(KIND_ID) as vm:
     with nvda_voicemeeter.draw(KIND_ID, vm) as window:
         window.run()
 ```
@@ -94,9 +94,19 @@ To adjust Patch Asio Inputs to Strips and Patch Insert values use `UP` and `DOWN
 
 To access Advanced Settings you may press the Advanced Settings button or use `Control + A` when in the `Settings` tab.
 
-#### `Strip/Bus`
+#### `Physical Strip|Virtual Strip|Buses`
 
-To rename a strip/bus channel navigate to the relevant tab, then press `F2`. This will open a popup window where you can set the channel index (with a spinbox) and set the new label using a text input box.
+You will find in each of these tabs two nested tabs,`Buttons` and `Sliders`. For each nested tab you will find the controls appropriate for the Voicemeeter kind and channel type.
+
+All buttons may be triggered by pressing `SPACE` or `ENTER`.
+
+All sliders may be controlled in three different ways:
+
+- `Left|Right arrow` to move a slider by 1 step.
+- `Shift + Left|Right arrow` to move a slider by 0.1 steps.
+- `Control + Left|Right arrow` to move a slider by 3 steps.
+
+To rename a strip/bus channel focus on the channel in question and press `F2`. Then enter the new channel name into the text input widget and press the `Ok` button.
 
 Pressing the `OK` button with an empty text input will clear the label. In this case the label will be read as a default value for that channel. For example, if the leftmost Strip label were cleared, the screen reader will now read `Hardware Input 1`.
 
@@ -114,6 +124,30 @@ The `Save Settings` option opens a popup window with two buttons, `Browse` and `
 
 `Load Settings` and `Load on Startup` both open an Open dialog box immediately.
 
+### `Quick access binds`
+
+There are a number of quick binds available to assist with faster navigation and general use.
+
+When focused on any one of "Physical Strip", "Virtual Strip" or "Buses" you may use `Control + Number` to skip to the corresponding channel.
+
+When focused on any single channel (Strip or Bus), the following binds exist:
+
+- `Alt + Number` will trigger the Bus output button corresponding to the number. For example `Alt + 3` will trigger the `A3` button
+- `Control + O` will trigger the Mono button
+- `Control + S` will trigger the Solo button
+- `Control + M` will trigger the Mute button
+
+You may also enter slider modes which allow for control of the channels sliders until the slider mode is exited. You may access the slider modes with the following binds:
+
+- `Control + U` will enter Audibility mode
+- `Control + G` will enter Gain mode
+- `Control + T` will enter Gate mode
+- `Control + L` will enter Limit mode
+
+To exit any of the slider modes press `Escape`.
+
+Once you are in a slider mode you may now control the slider that matches the slider mode. Slider mode binds are the same as the normal slider binds with the addition of the Alt keypress. For example, where you would normally use `Right Arrow` to shift a slider rightwards by 1 step, in slider mode you would now use `Alt + Right Arrow`.
+
 ### Issues
 
 If you have any questions/suggestions feel free to raise an issue or open a new discussion.

__main__.py

@@ -4,6 +4,6 @@ import nvda_voicemeeter
 
 KIND_ID = "potato"
 
-with voicemeeterlib.api(KIND_ID, sync=True) as vm:
+with voicemeeterlib.api(KIND_ID) as vm:
     with nvda_voicemeeter.draw(KIND_ID, vm) as window:
         window.run()

pyproject.toml

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

src/nvda_voicemeeter/builder.py

@@ -1,13 +1,7 @@
 import PySimpleGUI as psg
 
-from .util import (
-    get_asio_checkbox_index,
-    get_input_device_list,
-    get_insert_checkbox_index,
-    get_output_device_list,
-    get_patch_composite_list,
-    get_tabs_labels,
-)
+from . import util
+from .compound import LabelSlider
 
 
 class Builder:
@@ -91,7 +85,7 @@ class Builder:
             return psg.Tab(identifier, [[tabgroup]], key=f"tab||{identifier}")
 
         tabs = []
-        for tab in get_tabs_labels():
+        for tab in util.get_tabs_labels():
             tabs.append(_make_tabs(tab))
 
         tab_group = psg.TabGroup([tabs], change_submits=True, enable_events=True, key="tabgroup")
@@ -116,7 +110,7 @@ class Builder:
         """tab0 row0 represents hardware ins"""
 
         def add_physical_device_opts(layout):
-            devices = get_input_device_list(self.vm)
+            devices = util.get_input_device_list(self.vm)
             devices.append("- remove device selection -")
             layout.append(
                 [
@@ -147,7 +141,7 @@ class Builder:
                     psg.ButtonMenu(
                         f"A{i + 1}",
                         size=(6, 3),
-                        menu_def=["", get_output_device_list(i, self.vm)],
+                        menu_def=["", util.get_output_device_list(i, self.vm)],
                         key=f"HARDWARE OUT||A{i + 1}",
                     )
                     for i in range(num_outs)
@@ -167,7 +161,7 @@ class Builder:
                 [
                     psg.Spin(
                         nums,
-                        initial_value=self.window.cache["asio"][f"ASIO CHECKBOX||{get_asio_checkbox_index(0, i)}"],
+                        initial_value=self.window.cache["asio"][f"ASIO CHECKBOX||{util.get_asio_checkbox_index(0, i)}"],
                         size=2,
                         enable_events=True,
                         key=f"ASIO CHECKBOX||IN{i} 0",
@@ -178,7 +172,7 @@ class Builder:
                 [
                     psg.Spin(
                         nums,
-                        initial_value=self.window.cache["asio"][f"ASIO CHECKBOX||{get_asio_checkbox_index(1, i)}"],
+                        initial_value=self.window.cache["asio"][f"ASIO CHECKBOX||{util.get_asio_checkbox_index(1, i)}"],
                         size=2,
                         enable_events=True,
                         key=f"ASIO CHECKBOX||IN{i} 1",
@@ -199,7 +193,7 @@ class Builder:
         """tab0 row3 represents patch composite"""
 
         def add_physical_device_opts(layout):
-            outputs = get_patch_composite_list(self.vm.kind)
+            outputs = util.get_patch_composite_list(self.vm.kind)
             layout.append(
                 [
                     psg.ButtonMenu(
@@ -226,7 +220,7 @@ class Builder:
                         [
                             psg.Checkbox(
                                 text=channel,
-                                default=self.vm.patch.insert[get_insert_checkbox_index(self.kind, j, i)].on,
+                                default=self.vm.patch.insert[util.get_insert_checkbox_index(self.kind, j, i)].on,
                                 enable_events=True,
                                 key=f"INSERT CHECKBOX||IN{i} {j}",
                             )
@@ -239,7 +233,7 @@ class Builder:
                     [
                         psg.Checkbox(
                             text=channel,
-                            default=self.vm.patch.insert[get_insert_checkbox_index(self.kind, j, i)].on,
+                            default=self.vm.patch.insert[util.get_insert_checkbox_index(self.kind, j, i)].on,
                             enable_events=True,
                             key=f"INSERT CHECKBOX||IN{i} {j}",
                         )
@@ -314,6 +308,7 @@ class Builder:
         def add_gain_slider(layout):
             layout.append(
                 [
+                    psg.Text("Gain"),
                     psg.Slider(
                         range=(-60, 12),
                         default_value=self.vm.strip[i].gain,
@@ -323,13 +318,36 @@ class Builder:
                         enable_events=True,
                         orientation="horizontal",
                         key=f"STRIP {i}||SLIDER GAIN",
-                    )
+                    ),
                 ]
             )
 
-        outputs = []
-        [step(outputs) for step in (add_gain_slider,)]
-        return psg.Frame(self.window.cache["labels"][f"STRIP {i}||LABEL"], outputs, key=f"STRIP {i}||LABEL||SLIDER")
+        def add_param_sliders(layout):
+            layout.append([LabelSlider(self.window, i, param) for param in util.get_slider_params(i, self.vm)])
+
+        def add_limit_slider(layout):
+            layout.append(
+                [
+                    psg.Text("Limit"),
+                    psg.Slider(
+                        range=(-40, 12),
+                        default_value=self.vm.strip[i].limit,
+                        resolution=1,
+                        disable_number_display=True,
+                        expand_x=True,
+                        enable_events=True,
+                        orientation="horizontal",
+                        key=f"STRIP {i}||SLIDER LIMIT",
+                    ),
+                ]
+            )
+
+        layout = []
+        steps = (add_gain_slider, add_param_sliders)
+        if self.kind.name in ("banana", "potato"):
+            steps += (add_limit_slider,)
+        [step(layout) for step in steps]
+        return psg.Frame(self.window.cache["labels"][f"STRIP {i}||LABEL"], layout, key=f"STRIP {i}||LABEL||SLIDER")
 
     def make_tab1_slider_rows(self) -> psg.Frame:
         layout = [[self.make_tab1_slider_row(i)] for i in range(self.kind.phys_in)]
@@ -382,6 +400,7 @@ class Builder:
         def add_gain_slider(layout):
             layout.append(
                 [
+                    psg.Text("Gain"),
                     psg.Slider(
                         range=(-60, 12),
                         default_value=self.vm.strip[i].gain,
@@ -391,13 +410,45 @@ class Builder:
                         enable_events=True,
                         orientation="horizontal",
                         key=f"STRIP {i}||SLIDER GAIN",
-                    )
+                    ),
                 ]
             )
 
-        outputs = []
-        [step(outputs) for step in (add_gain_slider,)]
-        return psg.Frame(self.window.cache["labels"][f"STRIP {i}||LABEL"], outputs, key=f"STRIP {i}||LABEL||SLIDER")
+        def add_param_sliders(layout):
+            if self.kind.name in ("basic", "banana"):
+                for param in util.get_slider_params(i, self.vm):
+                    layout.append([LabelSlider(self.window, i, param, range_=(-12, 12))])
+            else:
+                layout.append(
+                    [
+                        LabelSlider(self.window, i, param, range_=(-12, 12))
+                        for param in util.get_slider_params(i, self.vm)
+                    ]
+                )
+
+        def add_limit_slider(layout):
+            layout.append(
+                [
+                    psg.Text("Limit"),
+                    psg.Slider(
+                        range=(-40, 12),
+                        default_value=self.vm.strip[i].limit,
+                        resolution=1,
+                        disable_number_display=True,
+                        expand_x=True,
+                        enable_events=True,
+                        orientation="horizontal",
+                        key=f"STRIP {i}||SLIDER LIMIT",
+                    ),
+                ]
+            )
+
+        layout = []
+        steps = (add_gain_slider, add_param_sliders)
+        if self.kind.name in ("banana", "potato"):
+            steps += (add_limit_slider,)
+        [step(layout) for step in steps]
+        return psg.Frame(self.window.cache["labels"][f"STRIP {i}||LABEL"], layout, key=f"STRIP {i}||LABEL||SLIDER")
 
     def make_tab2_slider_rows(self) -> psg.Frame:
         layout = [

src/nvda_voicemeeter/compound.py

@@ -0,0 +1,35 @@
+import PySimpleGUI as psg
+
+
+class LabelSlider(psg.Frame):
+    """Compound Label Slider element"""
+
+    def __init__(self, parent, i, param, range_=(0, 10), *args, **kwargs):
+        self.parent = parent
+        if param in ("AUDIBILITY", "DENOISER"):
+            size = 7
+        else:
+            size = 4
+        layout = [
+            [
+                psg.Text(param.capitalize(), size=size),
+                psg.Slider(
+                    range=range_,
+                    default_value=self.default_value(i, param),
+                    resolution=0.1,
+                    disable_number_display=True,
+                    size=(12, 16),
+                    expand_x=True,
+                    enable_events=True,
+                    orientation="horizontal",
+                    key=f"STRIP {i}||SLIDER {param}",
+                ),
+            ]
+        ]
+        super().__init__(None, layout=layout, border_width=0, pad=0, *args, **kwargs)
+
+    def default_value(self, i, param):
+        target = getattr(self.parent.vm.strip[i], param.lower())
+        if param in ("COMP", "GATE", "DENOISER"):
+            return target.knob
+        return target

src/nvda_voicemeeter/popup.py

@@ -0,0 +1,157 @@
+import logging
+from pathlib import Path
+
+import PySimpleGUI as psg
+
+from . import util
+
+logger = logging.getLogger(__name__)
+
+
+class Popup:
+    def __init__(self, window):
+        self.window = window
+        self.kind = self.window.kind
+        self.logger = logger.getChild(type(self).__name__)
+
+    def save_as(self, message, title=None, initial_folder=None):
+        layout = [
+            [psg.Text(message)],
+            [
+                psg.FileSaveAs("Browse", initial_folder=str(initial_folder), file_types=(("XML", ".xml"),)),
+                psg.Button("Cancel"),
+            ],
+        ]
+        popup = psg.Window(title, layout, finalize=True)
+        popup["Browse"].bind("<FocusIn>", "||FOCUS IN")
+        popup["Browse"].bind("<Return>", "||KEY ENTER")
+        popup["Cancel"].bind("<FocusIn>", "||FOCUS IN")
+        popup["Cancel"].bind("<Return>", "||KEY ENTER")
+        filepath = None
+        while True:
+            event, values = popup.read()
+            self.logger.debug(f"event::{event}")
+            self.logger.debug(f"values::{values}")
+            if event in (psg.WIN_CLOSED, "Cancel"):
+                break
+            match parsed_cmd := self.window.parser.match.parseString(event):
+                case [[button], ["FOCUS", "IN"]]:
+                    if values["Browse"]:
+                        filepath = values["Browse"]
+                        break
+                    self.window.nvda.speak(button)
+                case [[button], ["KEY", "ENTER"]]:
+                    popup.find_element_with_focus().click()
+            self.logger.debug(f"parsed::{parsed_cmd}")
+        popup.close()
+        if filepath:
+            return Path(filepath)
+
+    def rename(self, message, index, title=None, tab=None):
+        if "Strip" in tab:
+            if index < self.kind.phys_in:
+                title += f" Physical Strip {index + 1}"
+            else:
+                title += f" Virtual Strip {index - self.kind.phys_in + 1}"
+        else:
+            if index < self.kind.phys_out:
+                title += f" Physical Bus {index + 1}"
+            else:
+                title += f" Virtual Bus {index - self.kind.phys_out + 1}"
+        layout = [
+            [psg.Text(message)],
+            [
+                [
+                    psg.Input(key="Edit"),
+                ],
+                [psg.Button("Ok"), psg.Button("Cancel")],
+            ],
+        ]
+        popup = psg.Window(title, layout, finalize=True)
+        popup["Edit"].bind("<FocusIn>", "||FOCUS IN")
+        popup["Ok"].bind("<FocusIn>", "||FOCUS IN")
+        popup["Ok"].bind("<Return>", "||KEY ENTER")
+        popup["Cancel"].bind("<FocusIn>", "||FOCUS IN")
+        popup["Cancel"].bind("<Return>", "||KEY ENTER")
+        data = {}
+        while True:
+            event, values = popup.read()
+            self.logger.debug(f"event::{event}")
+            self.logger.debug(f"values::{values}")
+            if event in (psg.WIN_CLOSED, "Cancel"):
+                break
+            match parsed_cmd := self.window.parser.match.parseString(event):
+                case [[button], ["FOCUS", "IN"]]:
+                    self.window.nvda.speak(button)
+                case [[button], ["KEY", "ENTER"]]:
+                    popup.find_element_with_focus().click()
+                case ["Ok"]:
+                    data = values
+                    break
+            self.logger.debug(f"parsed::{parsed_cmd}")
+        popup.close()
+        return data
+
+    def advanced_settings(self, title):
+        def _make_buffering_frame() -> psg.Frame:
+            buffer = [
+                [
+                    psg.ButtonMenu(
+                        driver,
+                        size=(14, 2),
+                        menu_def=["", util.get_asio_samples_list(driver)],
+                        key=f"BUFFER {driver}",
+                    )
+                    for driver in ("MME", "WDM", "KS", "ASIO")
+                ],
+            ]
+            return psg.Frame("BUFFERING", buffer)
+
+        layout = []
+        steps = (_make_buffering_frame,)
+        for step in steps:
+            layout.append([step()])
+        layout.append([psg.Button("Exit", size=(8, 2))])
+
+        popup = psg.Window(title, layout, finalize=True)
+        buttonmenu_opts = {"takefocus": 1, "highlightthickness": 1}
+        for driver in ("MME", "WDM", "KS", "ASIO"):
+            popup[f"BUFFER {driver}"].Widget.config(**buttonmenu_opts)
+            popup[f"BUFFER {driver}"].bind("<FocusIn>", "||FOCUS IN")
+            popup[f"BUFFER {driver}"].bind("<space>", "||KEY SPACE", propagate=False)
+            popup[f"BUFFER {driver}"].bind("<Return>", "||KEY ENTER", propagate=False)
+        popup["Exit"].bind("<FocusIn>", "||FOCUS IN")
+        popup["Exit"].bind("<Return>", "||KEY ENTER")
+        while True:
+            event, values = popup.read()
+            self.logger.debug(f"event::{event}")
+            self.logger.debug(f"values::{values}")
+            if event in (psg.WIN_CLOSED, "Exit"):
+                break
+            match parsed_cmd := self.window.parser.match.parseString(event):
+                case ["BUFFER MME" | "BUFFER WDM" | "BUFFER KS" | "BUFFER ASIO"]:
+                    if values[event] == "Default":
+                        if "MME" in event:
+                            val = 1024
+                        elif "WDM" in event or "KS" in event:
+                            val = 512
+                        else:
+                            val = 0
+                    else:
+                        val = int(values[event])
+                    driver = event.split()[1]
+                    self.window.vm.set(f"option.buffer.{driver.lower()}", val)
+                    self.window.TKroot.after(
+                        200, self.window.nvda.speak, f"{driver} BUFFER {val if val else 'default'}"
+                    )
+                case [["BUFFER", driver], ["FOCUS", "IN"]]:
+                    val = int(self.window.vm.get(f"option.buffer.{driver.lower()}"))
+                    self.window.nvda.speak(f"{driver} BUFFER {val if val else 'default'}")
+                case [["BUFFER", driver], ["KEY", "SPACE" | "ENTER"]]:
+                    util.open_context_menu_for_buttonmenu(popup, f"BUFFER {driver}")
+                case [[button], ["FOCUS", "IN"]]:
+                    self.window.nvda.speak(button)
+                case [[button], ["KEY", "ENTER"]]:
+                    popup.find_element_with_focus().click()
+            self.logger.debug(f"parsed::{parsed_cmd}")
+        popup.close()

src/nvda_voicemeeter/util.py

@@ -1,3 +1,6 @@
+from typing import Iterable
+
+
 def get_asio_checkbox_index(channel, num) -> int:
     if channel == 0:
         return 2 * num - 2
@@ -8,7 +11,6 @@ def get_insert_checkbox_index(kind, channel, num) -> int:
     if num <= kind.phys_in:
         if channel == 0:
             return 2 * num - 2
-        else:
         return 2 * num - 1
     return (2 * kind.phys_in) + (8 * (num - kind.phys_in - 1)) + channel
 
@@ -130,10 +132,21 @@ def get_bus_modes(vm) -> list:
     ]
 
 
-def check_bounds(val, bounds):
+def check_bounds(val, bounds: tuple) -> int | float:
     lower, upper = bounds
     if val > upper:
         val = upper
     elif val < lower:
         val = lower
     return val
+
+
+def get_slider_params(i, vm) -> Iterable:
+    if i < vm.kind.phys_in:
+        if vm.kind.name == "basic":
+            return ("AUDIBILITY",)
+        if vm.kind.name == "banana":
+            return ("COMP", "GATE")
+        if vm.kind.name == "potato":
+            return ("COMP", "GATE", "DENOISER")
+    return ("BASS", "MID", "TREBLE")

src/nvda_voicemeeter/window.py

@@ -4,29 +4,11 @@ from pathlib import Path
 
 import PySimpleGUI as psg
 
+from . import models, util
 from .builder import Builder
-from .models import (
-    _make_hardware_ins_cache,
-    _make_hardware_outs_cache,
-    _make_label_cache,
-    _make_param_cache,
-    _make_patch_asio_cache,
-    _make_patch_insert_cache,
-)
 from .nvda import Nvda
 from .parser import Parser
-from .util import (
-    _patch_insert_channels,
-    check_bounds,
-    get_asio_checkbox_index,
-    get_asio_samples_list,
-    get_bus_modes,
-    get_channel_identifier_list,
-    get_insert_checkbox_index,
-    get_patch_composite_list,
-    get_tabs_labels,
-    open_context_menu_for_buttonmenu,
-)
+from .popup import Popup
 
 logger = logging.getLogger(__name__)
 
@@ -43,16 +25,17 @@ class NVDAVMWindow(psg.Window):
         self.kind = self.vm.kind
         self.logger = logger.getChild(type(self).__name__)
         self.cache = {
-            "hw_ins": _make_hardware_ins_cache(self.vm),
-            "hw_outs": _make_hardware_outs_cache(self.vm),
-            "strip": _make_param_cache(self.vm, "strip"),
-            "bus": _make_param_cache(self.vm, "bus"),
-            "labels": _make_label_cache(self.vm),
-            "asio": _make_patch_asio_cache(self.vm),
-            "insert": _make_patch_insert_cache(self.vm),
+            "hw_ins": models._make_hardware_ins_cache(self.vm),
+            "hw_outs": models._make_hardware_outs_cache(self.vm),
+            "strip": models._make_param_cache(self.vm, "strip"),
+            "bus": models._make_param_cache(self.vm, "bus"),
+            "labels": models._make_label_cache(self.vm),
+            "asio": models._make_patch_asio_cache(self.vm),
+            "insert": models._make_patch_insert_cache(self.vm),
         }
         self.nvda = Nvda()
         self.parser = Parser()
+        self.popup = Popup(self)
         self.builder = Builder(self)
         layout = self.builder.run()
         super().__init__(title, layout, return_keyboard_events=True, finalize=True)
@@ -67,7 +50,11 @@ 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):
+            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 GAIN"].Widget.config(**slider_opts)
+            if self.kind.name != "basic":
+                self[f"STRIP {i}||SLIDER LIMIT"].Widget.config(**slider_opts)
         for i in range(self.kind.num_bus):
             self[f"BUS {i}||SLIDER GAIN"].Widget.config(**slider_opts)
 
@@ -107,29 +94,38 @@ class NVDAVMWindow(psg.Window):
 
     def on_pdirty(self):
         self.cache = {
-            "hw_ins": _make_hardware_ins_cache(self.vm),
-            "hw_outs": _make_hardware_outs_cache(self.vm),
-            "strip": _make_param_cache(self.vm, "strip"),
-            "bus": _make_param_cache(self.vm, "bus"),
-            "labels": _make_label_cache(self.vm),
-            "asio": _make_patch_asio_cache(self.vm),
-            "insert": _make_patch_insert_cache(self.vm),
+            "hw_ins": models._make_hardware_ins_cache(self.vm),
+            "hw_outs": models._make_hardware_outs_cache(self.vm),
+            "strip": models._make_param_cache(self.vm, "strip"),
+            "bus": models._make_param_cache(self.vm, "bus"),
+            "labels": models._make_label_cache(self.vm),
+            "asio": models._make_patch_asio_cache(self.vm),
+            "insert": models._make_patch_insert_cache(self.vm),
         }
         for key, value in self.cache["labels"].items():
             self[key].update(value=value)
             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":
             for key, value in self.cache["asio"].items():
                 identifier, i = key.split("||")
-                partial = get_channel_identifier_list(self.vm)[int(i)]
+                partial = util.get_channel_identifier_list(self.vm)[int(i)]
                 self[f"{identifier}||{partial}"].update(value=value)
             for key, value in self.cache["insert"].items():
                 identifier, i = key.split("||")
-                partial = get_channel_identifier_list(self.vm)[int(i)]
+                partial = util.get_channel_identifier_list(self.vm)[int(i)]
                 self[f"{identifier}||{partial}"].update(value=value)
 
     def register_events(self):
@@ -137,12 +133,42 @@ class NVDAVMWindow(psg.Window):
 
         # TABS
         self["tabgroup"].bind("<FocusIn>", "||FOCUS IN")
-        for tabname in get_tabs_labels()[1:]:
+        for tabname in util.get_tabs_labels()[1:]:
             self[f"tabgroup||{tabname}"].bind("<FocusIn>", "||FOCUS IN")
             self[f"tabgroup||{tabname}"].bind("<Shift-KeyPress-Tab>", "||KEY SHIFT TAB")
         self.bind("<Control-KeyPress-Tab>", "CTRL-TAB")
         self.bind("<Control-Shift-KeyPress-Tab>", "CTRL-SHIFT-TAB")
+
+        # NAV
         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")
+        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")
+
+        self.bind("<Alt-Left>", "LEFT")
+        self.bind("<Alt-Right>", "RIGHT")
+        self.bind("<Alt-Shift-KeyPress-Left>", "SHIFT-LEFT")
+        self.bind("<Alt-Shift-KeyPress-Right>", "SHIFT-RIGHT")
+        self.bind("<Alt-Control-KeyPress-Left>", "CTRL-LEFT")
+        self.bind("<Alt-Control-KeyPress-Right>", "CTRL-RIGHT")
 
         # Hardware In
         for i in range(self.vm.kind.phys_in):
@@ -205,20 +231,24 @@ class NVDAVMWindow(psg.Window):
 
         # Strip Sliders
         for i in range(self.kind.num_strip):
-            self[f"STRIP {i}||SLIDER GAIN"].bind("<FocusIn>", "||FOCUS IN")
-            self[f"STRIP {i}||SLIDER GAIN"].bind("<FocusOut>", "||FOCUS OUT")
-            self[f"STRIP {i}||SLIDER GAIN"].bind("<Left>", "||KEY LEFT")
-            self[f"STRIP {i}||SLIDER GAIN"].bind("<Right>", "||KEY RIGHT")
-            self[f"STRIP {i}||SLIDER GAIN"].bind("<Shift-KeyPress-Left>", "||KEY SHIFT LEFT")
-            self[f"STRIP {i}||SLIDER GAIN"].bind("<Shift-KeyPress-Right>", "||KEY SHIFT RIGHT")
-            self[f"STRIP {i}||SLIDER GAIN"].bind("<Control-KeyPress-Left>", "||KEY CTRL LEFT")
-            self[f"STRIP {i}||SLIDER GAIN"].bind("<Control-KeyPress-Right>", "||KEY CTRL RIGHT")
-            self[f"STRIP {i}||SLIDER GAIN"].bind("<Up>", "||KEY UP")
-            self[f"STRIP {i}||SLIDER GAIN"].bind("<Down>", "||KEY DOWN")
-            self[f"STRIP {i}||SLIDER GAIN"].bind("<Shift-KeyPress-Up>", "||KEY SHIFT UP")
-            self[f"STRIP {i}||SLIDER GAIN"].bind("<Shift-KeyPress-Down>", "||KEY SHIFT DOWN")
-            self[f"STRIP {i}||SLIDER GAIN"].bind("<Control-KeyPress-Up>", "||KEY CTRL UP")
-            self[f"STRIP {i}||SLIDER GAIN"].bind("<Control-KeyPress-Down>", "||KEY CTRL DOWN")
+            for param in util.get_slider_params(i, self.vm) + ("GAIN", "LIMIT"):
+                if self.kind.name == "basic" and param == "LIMIT":
+                    continue
+                self[f"STRIP {i}||SLIDER {param}"].bind("<FocusIn>", "||FOCUS IN")
+                self[f"STRIP {i}||SLIDER {param}"].bind("<FocusOut>", "||FOCUS OUT")
+                self[f"STRIP {i}||SLIDER {param}"].bind("<Left>", "||KEY LEFT")
+                self[f"STRIP {i}||SLIDER {param}"].bind("<Right>", "||KEY RIGHT")
+                self[f"STRIP {i}||SLIDER {param}"].bind("<Shift-KeyPress-Left>", "||KEY SHIFT LEFT")
+                self[f"STRIP {i}||SLIDER {param}"].bind("<Shift-KeyPress-Right>", "||KEY SHIFT RIGHT")
+                self[f"STRIP {i}||SLIDER {param}"].bind("<Control-KeyPress-Left>", "||KEY CTRL LEFT")
+                self[f"STRIP {i}||SLIDER {param}"].bind("<Control-KeyPress-Right>", "||KEY CTRL RIGHT")
+                self[f"STRIP {i}||SLIDER {param}"].bind("<Up>", "||KEY UP")
+                self[f"STRIP {i}||SLIDER {param}"].bind("<Down>", "||KEY DOWN")
+                self[f"STRIP {i}||SLIDER {param}"].bind("<Shift-KeyPress-Up>", "||KEY SHIFT UP")
+                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"]
@@ -245,154 +275,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")
-
-    def popup_save_as(self, message, title=None, initial_folder=None):
-        layout = [
-            [psg.Text(message)],
-            [
-                psg.FileSaveAs("Browse", initial_folder=str(initial_folder), file_types=(("XML", ".xml"),)),
-                psg.Button("Cancel"),
-            ],
-        ]
-        window = psg.Window(title, layout, finalize=True)
-        window["Browse"].bind("<FocusIn>", "||FOCUS IN")
-        window["Browse"].bind("<Return>", "||KEY ENTER")
-        window["Cancel"].bind("<FocusIn>", "||FOCUS IN")
-        window["Cancel"].bind("<Return>", "||KEY ENTER")
-        filepath = None
-        while True:
-            event, values = window.read()
-            self.logger.debug(f"event::{event}")
-            self.logger.debug(f"values::{values}")
-            if event in (psg.WIN_CLOSED, "Cancel"):
-                break
-            match parsed_cmd := self.parser.match.parseString(event):
-                case [[button], ["FOCUS", "IN"]]:
-                    if values["Browse"]:
-                        filepath = values["Browse"]
-                        break
-                    self.nvda.speak(button)
-                case [[button], ["KEY", "ENTER"]]:
-                    window.find_element_with_focus().click()
-            self.logger.debug(f"parsed::{parsed_cmd}")
-        window.close()
-        if filepath:
-            return Path(filepath)
-
-    def popup_rename(self, message, title=None, tab=None):
-        if tab == "Physical Strip":
-            upper = self.kind.phys_in + 1
-        elif tab == "Virtual Strip":
-            upper = self.kind.virt_in + 1
-        elif tab == "Buses":
-            upper = self.kind.num_bus + 1
-
-        layout = [
-            [psg.Text(message)],
-            [
-                [
-                    psg.Spin(
-                        list(range(1, upper)), initial_value=1, size=2, enable_events=True, key=f"Index", readonly=True
-                    ),
-                    psg.Input(key="Edit"),
-                ],
-                [psg.Button("Ok"), psg.Button("Cancel")],
-            ],
-        ]
-        window = psg.Window(title, layout, finalize=True)
-        window["Index"].bind("<FocusIn>", "||FOCUS IN")
-        window["Edit"].bind("<FocusIn>", "||FOCUS IN")
-        window["Ok"].bind("<FocusIn>", "||FOCUS IN")
-        window["Ok"].bind("<Return>", "||KEY ENTER")
-        window["Cancel"].bind("<FocusIn>", "||FOCUS IN")
-        window["Cancel"].bind("<Return>", "||KEY ENTER")
-        data = {}
-        while True:
-            event, values = window.read()
-            self.logger.debug(f"event::{event}")
-            self.logger.debug(f"values::{values}")
-            if event in (psg.WIN_CLOSED, "Cancel"):
-                break
-            match parsed_cmd := self.parser.match.parseString(event):
-                case ["Index"]:
-                    val = values["Index"]
-                    self.nvda.speak(f"Index {val}")
-                case [[button], ["FOCUS", "IN"]]:
-                    if button == "Index":
-                        val = values["Index"]
-                        self.nvda.speak(f"Index {val}")
-                    else:
-                        self.nvda.speak(button)
-                case [[button], ["KEY", "ENTER"]]:
-                    window.find_element_with_focus().click()
-                case ["Ok"]:
-                    data = values
-                    break
-            self.logger.debug(f"parsed::{parsed_cmd}")
-        window.close()
-        return data
-
-    def popup_advanced_settings(self, title):
-        def _make_buffering_frame() -> psg.Frame:
-            buffer = [
-                [
-                    psg.ButtonMenu(
-                        driver,
-                        size=(14, 2),
-                        menu_def=["", get_asio_samples_list(driver)],
-                        key=f"BUFFER {driver}",
-                    )
-                    for driver in ("MME", "WDM", "KS", "ASIO")
-                ],
-            ]
-            return psg.Frame("BUFFERING", buffer)
-
-        layout = []
-        steps = (_make_buffering_frame,)
-        for step in steps:
-            layout.append([step()])
-        layout.append([psg.Button("Exit", size=(8, 2))])
-
-        window = psg.Window(title, layout, finalize=True)
-        buttonmenu_opts = {"takefocus": 1, "highlightthickness": 1}
-        for driver in ("MME", "WDM", "KS", "ASIO"):
-            window[f"BUFFER {driver}"].Widget.config(**buttonmenu_opts)
-            window[f"BUFFER {driver}"].bind("<FocusIn>", "||FOCUS IN")
-            window[f"BUFFER {driver}"].bind("<space>", "||KEY SPACE", propagate=False)
-            window[f"BUFFER {driver}"].bind("<Return>", "||KEY ENTER", propagate=False)
-        window["Exit"].bind("<FocusIn>", "||FOCUS IN")
-        window["Exit"].bind("<Return>", "||KEY ENTER")
-        while True:
-            event, values = window.read()
-            self.logger.debug(f"event::{event}")
-            self.logger.debug(f"values::{values}")
-            if event in (psg.WIN_CLOSED, "Exit"):
-                break
-            match parsed_cmd := self.parser.match.parseString(event):
-                case ["BUFFER MME" | "BUFFER WDM" | "BUFFER KS" | "BUFFER ASIO"]:
-                    if values[event] == "Default":
-                        if "MME" in event:
-                            val = 1024
-                        elif "WDM" in event or "KS" in event:
-                            val = 512
-                        else:
-                            val = 0
-                    else:
-                        val = int(values[event])
-                    driver = event.split()[1]
-                    self.vm.set(f"option.buffer.{driver.lower()}", val)
-                    self.TKroot.after(200, self.nvda.speak, f"{driver} BUFFER {val if val else 'default'}")
-                case [["BUFFER", driver], ["FOCUS", "IN"]]:
-                    val = int(self.vm.get(f"option.buffer.{driver.lower()}"))
-                    self.nvda.speak(f"{driver} BUFFER {val if val else 'default'}")
-                case [["BUFFER", driver], ["KEY", "SPACE" | "ENTER"]]:
-                    open_context_menu_for_buttonmenu(window, f"BUFFER {driver}")
-                case [[button], ["FOCUS", "IN"]]:
-                    self.nvda.speak(button)
-                case [[button], ["KEY", "ENTER"]]:
-                    window.find_element_with_focus().click()
-            self.logger.debug(f"parsed::{parsed_cmd}")
-        window.close()
+            self[f"BUS {i}||SLIDER GAIN"].bind("<Control-Shift-KeyPress-R>", "||KEY CTRL SHIFT R")
 
     def run(self):
         """
@@ -400,6 +283,7 @@ class NVDAVMWindow(psg.Window):
 
         Main thread will shutdown once a close or exit event occurs
         """
+        mode = None
 
         while True:
             event, values = self.read()
@@ -407,6 +291,18 @@ class NVDAVMWindow(psg.Window):
             self.logger.debug(f"values::{values}")
             if event in (psg.WIN_CLOSED, "Exit"):
                 break
+            elif event in ("GAIN MODE", "COMP MODE", "GATE MODE", "DENOISER MODE", "LIMIT MODE"):
+                mode = event
+                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 in ("LEFT", "RIGHT", "SHIFT-LEFT", "SHIFT-RIGHT", "CTRL-LEFT", "CTRL-RIGHT"):
+                    self.write_event_value(f"SLIDER-MODE-{event}", mode.split()[0])
+                    continue
 
             match parsed_cmd := self.parser.match.parseString(event):
                 # Focus tabgroup
@@ -414,32 +310,113 @@ 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"
+                    | "SLIDER-MODE-RIGHT"
+                    | "SLIDER-MODE-SHIFT-LEFT"
+                    | "SLIDER-MODE-SHIFT-RIGHT"
+                    | "SLIDER-MODE-CTRL-LEFT"
+                    | "SLIDER-MODE-CTRL-RIGHT" as op
+                ]:
+                    op = op.removeprefix("SLIDER-MODE-").split("-")
+                    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 {' '.join(op)}", None)
+
                 # Rename popups
                 case ["F2:113"]:
-                    tab = values["tabgroup"]
+                    tab = values["tabgroup"].split("||")[1]
                     if tab in ("Physical Strip", "Virtual Strip", "Buses"):
-                        data = self.popup_rename("Label", title=f"Rename {tab}", tab=tab)
+                        if focus := self.find_element_with_focus():
+                            identifier, partial = focus.Key.split("||")
+                            _, index = identifier.split()
+                            index = int(index)
+                            data = self.popup.rename("Label", index, title=f"Rename", tab=tab)
                             if not data:  # cancel was pressed
                                 continue
-                        index = int(data["Index"]) - 1
                             match tab:
                                 case "Physical Strip":
-                                label = data.get("Edit") or f"Hardware Input {index + 1}"
-                                self.vm.strip[index].label = label
+                                    label = data.get("Edit", f"Hardware Input {int(index) + 1}")
+                                    self.vm.strip[int(index)].label = label
                                     self[f"STRIP {index}||LABEL"].update(value=label)
                                     self.cache["labels"][f"STRIP {index}||LABEL"] = label
                                 case "Virtual Strip":
-                                index += self.kind.phys_in
-                                label = data.get("Edit") or f"Virtual Input {index - self.kind.phys_in + 1}"
-                                self.vm.strip[index].label = label
+                                    label = data.get("Edit", f"Virtual Input {int(index) + 1}")
+                                    self.vm.strip[int(index)].label = label
                                     self[f"STRIP {index}||LABEL"].update(value=label)
                                     self.cache["labels"][f"STRIP {index}||LABEL"] = label
                                 case "Buses":
                                     if index < self.kind.phys_out:
-                                    label = data.get("Edit") or f"Physical Bus {index + 1}"
+                                        label = data.get("Edit", f"Physical Bus {int(index) + 1}")
                                     else:
-                                    label = data.get("Edit") or f"Virtual Bus {index - self.kind.phys_out + 1}"
-                                self.vm.bus[index].label = label
+                                        label = data.get("Edit", f"Virtual Bus {int(index) - self.kind.phys_out + 1}")
+                                    self.vm.bus[int(index)].label = label
                                     self[f"BUS {index}||LABEL"].update(value=label)
                                     self.cache["labels"][f"BUS {index}||LABEL"] = label
 
@@ -454,7 +431,7 @@ class NVDAVMWindow(psg.Window):
                     )
                 case [["Save", "Settings"], ["MENU"]]:
                     initial_folder = Path.home() / "Documents" / "Voicemeeter"
-                    if filepath := self.popup_save_as(
+                    if filepath := self.popup.save_as(
                         "Open the file browser", title="Save As", initial_folder=initial_folder
                     ):
                         self.vm.set("command.save", str(filepath))
@@ -476,6 +453,8 @@ class NVDAVMWindow(psg.Window):
                         filepath = Path(filepath)
                         self.vm.set("command.load", str(filepath))
                         self.logger.debug(f"loading config file from {filepath}")
+                        for i in (25, 50):  # for the benefit of the sliders
+                            self.TKroot.after(i, self.on_pdirty)
                         self.TKroot.after(
                             200,
                             self.nvda.speak,
@@ -534,7 +513,7 @@ class NVDAVMWindow(psg.Window):
                     if self.find_element_with_focus() is not None:
                         self.nvda.speak(f"HARDWARE INPUT {key} {self.cache['hw_ins'][f'HARDWARE IN||{key}']}")
                 case [["HARDWARE", "IN"], [key], ["KEY", "SPACE" | "ENTER"]]:
-                    open_context_menu_for_buttonmenu(self, f"HARDWARE IN||{key}")
+                    util.open_context_menu_for_buttonmenu(self, f"HARDWARE IN||{key}")
 
                 # Hardware out
                 case [["HARDWARE", "OUT"], [key]]:
@@ -556,15 +535,15 @@ class NVDAVMWindow(psg.Window):
                     if self.find_element_with_focus() is not None:
                         self.nvda.speak(f"HARDWARE OUT {key} {self.cache['hw_outs'][f'HARDWARE OUT||{key}']}")
                 case [["HARDWARE", "OUT"], [key], ["KEY", "SPACE" | "ENTER"]]:
-                    open_context_menu_for_buttonmenu(self, f"HARDWARE OUT||{key}")
+                    util.open_context_menu_for_buttonmenu(self, f"HARDWARE OUT||{key}")
 
                 # Patch ASIO
                 case [["ASIO", "CHECKBOX"], [in_num, channel]]:
-                    index = get_asio_checkbox_index(int(channel), int(in_num[-1]))
+                    index = util.get_asio_checkbox_index(int(channel), int(in_num[-1]))
                     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}"]
@@ -576,7 +555,7 @@ class NVDAVMWindow(psg.Window):
                 case [["PATCH", "COMPOSITE"], [key]]:
                     val = values[f"PATCH COMPOSITE||{key}"]
                     index = int(key[-1]) - 1
-                    self.vm.patch.composite[index].set(get_patch_composite_list(self.kind).index(val) + 1)
+                    self.vm.patch.composite[index].set(util.get_patch_composite_list(self.kind).index(val) + 1)
                     self.TKroot.after(200, self.nvda.speak, f"PATCH COMPOSITE {key[-1]} set {val}")
                 case [["PATCH", "COMPOSITE"], [key], ["FOCUS", "IN"]]:
                     if self.find_element_with_focus() is not None:
@@ -584,39 +563,37 @@ class NVDAVMWindow(psg.Window):
                             val = values[f"PATCH COMPOSITE||{key}"]
                         else:
                             index = int(key[-1]) - 1
-                            val = get_patch_composite_list(self.kind)[self.vm.patch.composite[index].get() - 1]
+                            val = util.get_patch_composite_list(self.kind)[self.vm.patch.composite[index].get() - 1]
                         self.nvda.speak(f"Patch COMPOSITE {key[-1]} {val}")
                 case [["PATCH", "COMPOSITE"], [key], ["KEY", "SPACE" | "ENTER"]]:
-                    open_context_menu_for_buttonmenu(self, f"PATCH COMPOSITE||{key}")
+                    util.open_context_menu_for_buttonmenu(self, f"PATCH COMPOSITE||{key}")
 
                 # Patch INSERT
                 case [["INSERT", "CHECKBOX"], [in_num, channel]]:
-                    index = get_insert_checkbox_index(
+                    index = util.get_insert_checkbox_index(
                         self.kind,
                         int(channel),
                         int(in_num[-1]),
                     )
                     val = values[f"INSERT CHECKBOX||{in_num} {channel}"]
                     self.vm.patch.insert[index].on = val
-                    self.nvda.speak(
-                        f"PATCH INSERT {in_num} {_patch_insert_channels[int(channel)]} set to {'on' if val else 'off'}"
-                    )
+                    self.nvda.speak(f"{'on' if val else 'off'}")
                 case [["INSERT", "CHECKBOX"], [in_num, channel], ["FOCUS", "IN"]]:
                     if self.find_element_with_focus() is not None:
-                        index = get_insert_checkbox_index(
+                        index = util.get_insert_checkbox_index(
                             self.kind,
                             int(channel),
                             int(in_num[-1]),
                         )
                         val = values[f"INSERT CHECKBOX||{in_num} {channel}"]
-                        channel = _patch_insert_channels[int(channel)]
+                        channel = util._patch_insert_channels[int(channel)]
                         num = int(in_num[-1])
                         self.nvda.speak(f"Patch INSERT IN#{num} {channel} {'on' if val else 'off'}")
 
                 # Advanced Settings
                 case ["ADVANCED SETTINGS"] | ["CTRL-A"]:
                     if values["tabgroup"] == "tab||Settings":
-                        self.popup_advanced_settings(title="Advanced Settings")
+                        self.popup.advanced_settings(title="Advanced Settings")
                 case [["ADVANCED", "SETTINGS"], ["FOCUS", "IN"]]:
                     self.nvda.speak("ADVANCED SETTINGS")
                 case [["ADVANCED", "SETTINGS"], ["KEY", "ENTER"]]:
@@ -640,19 +617,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(
-                                    f"{label} {phonetic.get(actual, actual)} {['off', 'k m', 'k 1', 'k 2'][next_val]}"
-                                )
+                                self.nvda.speak(["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}"]
@@ -678,54 +653,266 @@ class NVDAVMWindow(psg.Window):
                     self.find_element_with_focus().click()
 
                 # Strip Sliders
-                case [["STRIP", index], ["SLIDER", "GAIN"]]:
-                    label = self.cache["labels"][f"STRIP {index}||LABEL"]
+                case [
+                    ["STRIP", index],
+                    [
+                        "SLIDER",
+                        "GAIN"
+                        | "COMP"
+                        | "GATE"
+                        | "DENOISER"
+                        | "AUDIBILITY"
+                        | "LIMIT"
+                        | "BASS"
+                        | "MID"
+                        | "TREBLE" as param,
+                    ],
+                ]:
                     val = values[event]
+                    match param:
+                        case "GAIN":
                             self.vm.strip[int(index)].gain = val
-                    self.nvda.speak(f"{label} gain slider {val}")
-                case [["STRIP", index], ["SLIDER", "GAIN"], ["FOCUS", "IN"]]:
+                        case "COMP" | "GATE" | "DENOISER":
+                            target = getattr(self.vm.strip[int(index)], param.lower())
+                            target.knob = val
+                        case "AUDIBILITY":
+                            self.vm.strip[int(index)].audibility = val
+                        case "LIMIT":
+                            val = int(val)
+                            self.vm.strip[int(index)].limit = val
+                        case "BASS" | "MID" | "TREBLE":
+                            setattr(self.vm.strip[int(index)], param.lower(), val)
+                case [
+                    ["STRIP", index],
+                    [
+                        "SLIDER",
+                        "GAIN"
+                        | "COMP"
+                        | "GATE"
+                        | "DENOISER"
+                        | "AUDIBILITY"
+                        | "LIMIT"
+                        | "BASS"
+                        | "MID"
+                        | "TREBLE" as param,
+                    ],
+                    ["FOCUS", "IN"],
+                ]:
                     if self.find_element_with_focus() is not None:
                         self.vm.event.pdirty = False
+                        val = values[f"STRIP {index}||SLIDER {param}"]
                         label = self.cache["labels"][f"STRIP {index}||LABEL"]
-                        val = values[f"STRIP {index}||SLIDER GAIN"]
-                        self.nvda.speak(f"{label} gain slider {val}")
-                case [["STRIP", index], ["SLIDER", "GAIN"], ["FOCUS", "OUT"]]:
+                        self.nvda.speak(f"{label} {param} {int(val) if param == 'LIMIT' else val}")
+                case [
+                    ["STRIP", index],
+                    [
+                        "SLIDER",
+                        "GAIN" | "COMP" | "GATE" | "DENOISER" | "AUDIBILITY" | "LIMIT" | "BASS" | "MID" | "TREBLE",
+                    ],
+                    ["FOCUS", "OUT"],
+                ]:
                     self.vm.event.pdirty = True
-                case [["STRIP", index], ["SLIDER", "GAIN"], ["KEY", "LEFT" | "RIGHT" | "UP" | "DOWN" as direction]]:
+                case [
+                    ["STRIP", index],
+                    [
+                        "SLIDER",
+                        "GAIN"
+                        | "COMP"
+                        | "GATE"
+                        | "DENOISER"
+                        | "AUDIBILITY"
+                        | "LIMIT"
+                        | "BASS"
+                        | "MID"
+                        | "TREBLE" as param,
+                    ],
+                    ["KEY", "LEFT" | "RIGHT" | "UP" | "DOWN" as direction],
+                ]:
+                    match param:
+                        case "GAIN":
                             val = self.vm.strip[int(index)].gain
+                        case "COMP" | "GATE" | "DENOISER":
+                            target = getattr(self.vm.strip[int(index)], param.lower())
+                            val = target.knob
+                        case "AUDIBILITY":
+                            val = self.vm.strip[int(index)].audibility
+                        case "BASS" | "MID" | "TREBLE":
+                            val = getattr(self.vm.strip[int(index)], param.lower())
+                        case "LIMIT":
+                            val = self.vm.strip[int(index)].limit
+
                     match direction:
                         case "RIGHT" | "UP":
                             val += 1
                         case "LEFT" | "DOWN":
                             val -= 1
-                    self.vm.strip[int(index)].gain = check_bounds(val, (-60, 12))
-                    self[f"STRIP {index}||SLIDER GAIN"].update(value=val)
+
+                    match param:
+                        case "GAIN":
+                            val = 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":
+                            val = util.check_bounds(val, (0, 10))
+                            setattr(target, "knob", val)
+                            self[f"STRIP {index}||SLIDER {param}"].update(value=val)
+                        case "AUDIBILITY":
+                            val = 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":
+                            val = 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":
+                            val = 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],
-                    ["SLIDER", "GAIN"],
+                    [
+                        "SLIDER",
+                        "GAIN"
+                        | "COMP"
+                        | "GATE"
+                        | "DENOISER"
+                        | "AUDIBILITY"
+                        | "LIMIT"
+                        | "BASS"
+                        | "MID"
+                        | "TREBLE" as param,
+                    ],
                     ["KEY", "CTRL", "LEFT" | "RIGHT" | "UP" | "DOWN" as direction],
                 ]:
+                    match param:
+                        case "GAIN":
                             val = self.vm.strip[int(index)].gain
+                        case "COMP" | "GATE" | "DENOISER":
+                            target = getattr(self.vm.strip[int(index)], param.lower())
+                            val = target.knob
+                        case "AUDIBILITY":
+                            val = self.vm.strip[int(index)].audibility
+                        case "BASS" | "MID" | "TREBLE":
+                            val = getattr(self.vm.strip[int(index)], param.lower())
+                        case "LIMIT":
+                            val = self.vm.strip[int(index)].limit
+
                     match direction:
                         case "RIGHT" | "UP":
+                            if param in ("COMP", "GATE", "DENOISER", "AUDIBILITY", "BASS", "MID", "TREBLE"):
+                                val += 1
+                            else:
                                 val += 3
                         case "LEFT" | "DOWN":
+                            if param in ("COMP", "GATE", "DENOISER", "AUDIBILITY", "BASS", "MID", "TREBLE"):
+                                val -= 1
+                            else:
                                 val -= 3
-                    self.vm.strip[int(index)].gain = check_bounds(val, (-60, 12))
-                    self[f"STRIP {index}||SLIDER GAIN"].update(value=val)
+
+                    match param:
+                        case "GAIN":
+                            val = 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":
+                            val = util.check_bounds(val, (0, 10))
+                            setattr(target, "knob", val)
+                            self[f"STRIP {index}||SLIDER {param}"].update(value=val)
+                        case "AUDIBILITY":
+                            val = 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":
+                            val = 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":
+                            val = 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", "GAIN"],
+                    [
+                        "SLIDER",
+                        "GAIN"
+                        | "COMP"
+                        | "GATE"
+                        | "DENOISER"
+                        | "AUDIBILITY"
+                        | "LIMIT"
+                        | "BASS"
+                        | "MID"
+                        | "TREBLE" as param,
+                    ],
                     ["KEY", "SHIFT", "LEFT" | "RIGHT" | "UP" | "DOWN" as direction],
                 ]:
+                    match param:
+                        case "GAIN":
                             val = self.vm.strip[int(index)].gain
+                        case "COMP" | "GATE" | "DENOISER":
+                            target = getattr(self.vm.strip[int(index)], param.lower())
+                            val = target.knob
+                        case "AUDIBILITY":
+                            val = self.vm.strip[int(index)].audibility
+                        case "BASS" | "MID" | "TREBLE":
+                            val = getattr(self.vm.strip[int(index)], param.lower())
+                        case "LIMIT":
+                            val = self.vm.strip[int(index)].limit
+
                     match direction:
                         case "RIGHT" | "UP":
+                            if param == "LIMIT":
+                                val += 1
+                            else:
                                 val += 0.1
                         case "LEFT" | "DOWN":
+                            if param == "LIMIT":
+                                val -= 1
+                            else:
                                 val -= 0.1
-                    self.vm.strip[int(index)].gain = check_bounds(val, (-60, 12))
-                    self[f"STRIP {index}||SLIDER GAIN"].update(value=val)
+
+                    match param:
+                        case "GAIN":
+                            val = 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":
+                            val = util.check_bounds(val, (0, 10))
+                            setattr(target, "knob", val)
+                            self[f"STRIP {index}||SLIDER {param}"].update(value=val)
+                        case "AUDIBILITY":
+                            val = 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":
+                            val = 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":
+                            val = 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]]:
@@ -739,7 +926,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
@@ -748,10 +935,10 @@ 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 = get_bus_modes(self.vm)
+                            bus_modes = util.get_bus_modes(self.vm)
                             next_index = bus_modes.index(val) + 1
                             if next_index == len(bus_modes):
                                 next_index = 0
@@ -773,7 +960,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:
@@ -791,13 +978,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]]:
@@ -807,8 +993,10 @@ class NVDAVMWindow(psg.Window):
                             val += 1
                         case "LEFT" | "DOWN":
                             val -= 1
-                    self.vm.bus[int(index)].gain = 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"],
@@ -820,8 +1008,10 @@ class NVDAVMWindow(psg.Window):
                             val += 3
                         case "LEFT" | "DOWN":
                             val -= 3
-                    self.vm.bus[int(index)].gain = 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"],
@@ -833,8 +1023,14 @@ class NVDAVMWindow(psg.Window):
                             val += 0.1
                         case "LEFT" | "DOWN":
                             val -= 0.1
-                    self.vm.bus[int(index)].gain = 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"], ["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 _: