adds ctrl+shift+r slider reset bind

closes #9

patch bump

README.md

@@ -1 +1,135 @@
-# example-package
+[![pdm-managed](https://img.shields.io/badge/pdm-managed-blueviolet)](https://pdm.fming.dev)
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+[![Imports: isort](https://img.shields.io/badge/%20imports-isort-%231674b1?style=flat&labelColor=ef8336)](https://pycqa.github.io/isort/)
+
+# NVDA Voicemeeter
+
+A remote control app for [Voicemeeter][voicemeeter], designed to be used with the [NVDA screen reader][nvda].
+
+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">
+
+## Requirements
+
+- [NVDA screen reader][nvda]
+- [NVDA's Controller Client files][controller_client]
+- Python 3.10 or greater
+
+### Installation
+
+#### `From Source`
+
+First clone the source files from this repository and install the dependencies.
+
+```
+git clone https://github.com/onyx-and-iris/nvda-voicemeeter.git
+cd nvda-voicemeeter
+pip install .
+```
+
+Then download the [Controller Client][controller_client] and place the dll files into the directory `controllerClient`.
+
+Your directory structure should look like this:
+
+├── `controllerClient/`
+
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;├── `x64/`
+
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;├── nvdaControllerClient64.dll
+
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;├── `x86/`
+
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;├── nvdaControllerClient32.dll
+
+#### `From Releases`
+
+If you want to get started quickly and easily I have uploaded some compiled versions of the app in the [Releases][releases] section.
+
+### Run
+
+Once the repository is downloaded and the controller client files in place you can launch the GUI with the following `__main__.py`:
+
+```python
+import voicemeeterlib
+
+import nvda_voicemeeter
+
+KIND_ID = "potato"
+
+with voicemeeterlib.api(KIND_ID, sync=True) as vm:
+    with nvda_voicemeeter.draw(KIND_ID, vm) as window:
+        window.run()
+```
+
+### KIND_ID
+
+May be one of the following:
+
+- `basic`
+- `banana`
+- `potato`
+
+### Use
+
+#### `Tabs`
+
+The app presents four tabs `Settings`, `Physical Strip`, `Virtual Strip` and `Buses`. Navigate between the tabs with `Control + TAB` and `Control + SHIFT + TAB` or once focused on any tab, `Left` and `Right` arrow keys.
+
+All controls within the tabs may be navigated between using `TAB`.
+
+#### `Settings`
+
+The following controls offer context menus accessed by pressing `SPACE` or `ENTER`:
+
+- Hardware In
+- Hardware Out
+- Patch Composite
+
+Press `ESCAPE` to exit any context menu.
+
+All other buttons can be triggered by pressing `SPACE` or `ENTER`.
+
+To adjust Patch Asio Inputs to Strips and Patch Insert values use `UP` and `DOWN` arrows when in focus.
+
+To access Advanced Settings you may press the Advanced Settings button or use `Control + A` when in the `Settings` tab.
+
+#### `Strip/Bus`
+
+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.
+
+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`.
+
+Pressing `Cancel` will close the popup window with no affect on the label.
+
+#### `Menu`
+
+A single menu item `Voicemeeter` can be opened using `Alt` and then `v`. The menu allows you to:
+
+- Restart Voicemeeter audio engine
+- Save/Load current settings (as an xml file)
+- Set a config to load automatically on app startup.
+
+The `Save Settings` option opens a popup window with two buttons, `Browse` and `Cancel`. Browse opens a Save As dialog, Cancel returns to the main app window.
+
+`Load Settings` and `Load on Startup` both open an Open dialog box immediately.
+
+### Issues
+
+If you have any questions/suggestions feel free to raise an issue or open a new discussion.
+
+### Special Thanks
+
+[Mario Loreti](https://www.marioloreti.net/en/) for his help in testing and offering feedback during development.
+
+[NVAccess](https://www.nvaccess.org/) for creating the open source NVDA screen reader and its controller client.
+
+[Vincent Burel](https://github.com/vburel2018) for creating Voicemeeter and its SDK.
+
+[PySimpleGUI](https://github.com/PySimpleGUI) team for creating an awesome GUI framework.
+
+[spec]: ./SPECIFICATION.md
+[voicemeeter]: https://voicemeeter.com/
+[nvda]: https://www.nvaccess.org/
+[controller_client]: https://github.com/nvaccess/nvda/tree/master/extras/controllerClient
+[releases]: https://github.com/onyx-and-iris/nvda-voicemeeter/releases

SPECIFICATION.md

@@ -0,0 +1,30 @@
+# Software Specification
+
+## Description
+
+A remote control utility for Voicemeeter designed to be used with the NVDA screen reader.
+
+## Requirements
+
+#### Functional Goals
+
+- Parameter updates caused by user input should be read back to the user via the screen reader.
+- When focusing a control the current value for that control should be read back to the user.
+- The application should scale correctly according to each kind of Voicemeeter (basic, banana, potato). This means the following:
+  - Correct number of strips/buses.
+  - Correct number of bus assignments for each strip.
+  - Where certain controls are valid for one kind they may not be for another.
+- Where possible set limits on data entry and keep controls appropriate for the type of parameter.
+
+#### Accessibility Goals
+
+- Every control must be usable with a keyboard.
+- Navigation around the application must be doable with a keyboard.
+- Should use standard Windows controls only.
+
+## Limitations
+
+- May not cover 100% of the Voicemeeter GUI, for example the many EQ parameters.
+- Only designed to work with the NVDA screen reader. Other screen readers not supported.
+- Only the main Voicemeeter GUI supported by this application. No support for Matrix or other Voicemeeter products.
+- Runs on Python version 3.10 or greater.

pdm.lock

@@ -6,7 +6,7 @@ groups = ["default", "build", "lint", "test"]
 cross_platform = true
 static_urls = false
 lock_version = "4.3"
-content_hash = "sha256:2aaf88f0abb701968bc22eb31fd189810850a505bb93553f67216e4d1d259750"
+content_hash = "sha256:ba53368b628b713c9cf4eb54e6f5c5c4af207c8e247d473417e4c2a4b47f645d"
 
 [[package]]
 name = "altgraph"
@@ -271,13 +271,13 @@ files = [
 
 [[package]]
 name = "voicemeeter-api"
-version = "2.4.8"
+version = "2.4.9"
 requires_python = ">=3.10,<4.0"
 summary = "A Python wrapper for the Voiceemeter API"
 dependencies = [
     "tomli<3.0.0,>=2.0.1; python_version < \"3.11\"",
 ]
 files = [
-    {file = "voicemeeter_api-2.4.8-py3-none-any.whl", hash = "sha256:a3ff9e6f7516d2adedde93f6976526b385d8ae6d86598bfe541a44f498f42ea6"},
+    {file = "voicemeeter_api-2.4.9-py3-none-any.whl", hash = "sha256:a09fd07fe3799cd5c880d491048da81d94e49aa97ec753aa1f9289acd27be965"},
-    {file = "voicemeeter_api-2.4.8.tar.gz", hash = "sha256:0d37a9f2af0f68087aa9c76a8cfb2ba44c6b75bb344e8dfa9fd18ad2c862730c"},
+    {file = "voicemeeter_api-2.4.9.tar.gz", hash = "sha256:47ad614a8b9ccb0b4e47acf65666ce0f0537a0890fffda9949e995bea70e679c"},
 ]

pyproject.toml

@@ -1,18 +1,20 @@
 [project]
 name = "nvda_voicemeeter"
-version = "0.1.0"
+version = "0.2.2"
 description = "A Voicemeeter app compatible with NVDA"
 authors = [
-    {name = "onyx-and-iris", email = "code@onyxandiris.online"},
+    { name = "onyx-and-iris", email = "code@onyxandiris.online" },
 ]
 dependencies = [
     "pysimplegui>=4.60.5",
     "pyparsing>=3.1.1",
-    "voicemeeter-api>=2.4.8",
+    "voicemeeter-api>=2.4.9",
 ]
-requires-python = ">=3.10,<3.11"
+requires-python = ">=3.10,<3.12"
 readme = "README.md"
-license = {text = "MIT"}
+
+[project.license]
+text = "MIT"
 
 [tool.pdm.dev-dependencies]
 build = [
@@ -26,5 +28,5 @@ test = [
     "psgdemos>=1.12.1",
 ]
 
-[tool.pdm.scripts]
+[tool.pdm.scripts.build]
-build = {shell = "build.ps1"}
+shell = "build.ps1"

src/nvda_voicemeeter/builder.py

@@ -1,14 +1,7 @@
 import PySimpleGUI as psg
 
-from .util import (
+from . import util
-    get_asio_checkbox_index,
+from .compound import LabelSlider
-    get_asio_samples_list,
-    get_input_device_list,
-    get_insert_checkbox_index,
-    get_output_device_list,
-    get_patch_composite_list,
-    get_tabs_labels,
-)
 
 
 class Builder:
@@ -27,6 +20,7 @@ class Builder:
             steps = (
                 self.make_tab0_row0,
                 self.make_tab0_row1,
+                self.make_tab0_row5,
             )
         else:
             steps = (
@@ -40,25 +34,61 @@ class Builder:
         for step in steps:
             layout0.append([step()])
 
-        layout1 = []
+        layout1_1 = []
-        steps = (self.make_tab1_rows,)
+        steps = (self.make_tab1_button_rows,)
         for step in steps:
-            layout1.append([step()])
+            layout1_1.append([step()])
-
+        layout1_2 = []
-        layout2 = []
+        steps = (self.make_tab1_slider_rows,)
-        steps = (self.make_tab2_rows,)
         for step in steps:
-            layout2.append([step()])
+            layout1_2.append([step()])
 
-        layout3 = []
+        layout2_1 = []
-        steps = (self.make_tab3_rows,)
+        steps = (self.make_tab2_button_rows,)
         for step in steps:
-            layout3.append([step()])
+            layout2_1.append([step()])
+        layout2_2 = []
+        steps = (self.make_tab2_slider_rows,)
+        for step in steps:
+            layout2_2.append([step()])
 
-        layouts = [layout0, layout1, layout2, layout3]
+        layout3_1 = []
+        steps = (self.make_tab3_button_rows,)
+        for step in steps:
+            layout3_1.append([step()])
+        layout3_2 = []
+        steps = (self.make_tab3_slider_rows,)
+        for step in steps:
+            layout3_2.append([step()])
 
-        tabs = [psg.Tab(identifier, layouts[i], key=identifier) for i, identifier in enumerate(get_tabs_labels())]
+        def _make_inner_tabgroup(layouts, identifier) -> psg.TabGroup:
-        tab_group = psg.TabGroup([tabs], change_submits=True, key="tabs")
+            inner_layout = []
+            for i, tabname in enumerate(("buttons", "sliders")):
+                inner_layout.append([psg.Tab(tabname.capitalize(), layouts[i], key=f"tab||{identifier}||{tabname}")])
+            return psg.TabGroup(
+                inner_layout,
+                change_submits=True,
+                enable_events=True,
+                key=f"tabgroup||{identifier}",
+            )
+
+        def _make_tabs(identifier) -> psg.Tab:
+            match identifier:
+                case "Settings":
+                    return psg.Tab("Settings", layout0, key="tab||Settings")
+                case "Physical Strip":
+                    tabgroup = _make_inner_tabgroup((layout1_1, layout1_2), identifier)
+                case "Virtual Strip":
+                    tabgroup = _make_inner_tabgroup((layout2_1, layout2_2), identifier)
+                case "Buses":
+                    tabgroup = _make_inner_tabgroup((layout3_1, layout3_2), identifier)
+            return psg.Tab(identifier, [[tabgroup]], key=f"tab||{identifier}")
+
+        tabs = []
+        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")
 
         return [[menu], [tab_group]]
 
@@ -80,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(
                 [
@@ -94,7 +124,7 @@ class Builder:
                 ]
             )
 
-        hardware_in = list()
+        hardware_in = []
         [step(hardware_in) for step in (add_physical_device_opts,)]
         return psg.Frame("Hardware In", hardware_in)
 
@@ -102,8 +132,6 @@ class Builder:
         """tab0 row1 represents hardware outs"""
 
         def add_physical_device_opts(layout):
-            devices = get_output_device_list(self.vm)
-            devices.append("- remove device selection -")
             if self.kind.name == "basic":
                 num_outs = self.kind.phys_out + self.kind.virt_out
             else:
@@ -113,14 +141,14 @@ class Builder:
                     psg.ButtonMenu(
                         f"A{i + 1}",
                         size=(6, 3),
-                        menu_def=["", devices],
+                        menu_def=["", util.get_output_device_list(i, self.vm)],
                         key=f"HARDWARE OUT||A{i + 1}",
                     )
                     for i in range(num_outs)
                 ]
             )
 
-        hardware_out = list()
+        hardware_out = []
         [step(hardware_out) for step in (add_physical_device_opts,)]
         return psg.Frame("Hardware Out", hardware_out)
 
@@ -133,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",
@@ -144,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",
@@ -152,7 +180,7 @@ class Builder:
                 ],
             )
 
-        inner = list()
+        inner = []
         asio_checkboxlists = ([] for _ in range(self.kind.phys_out))
         for i, checkbox_list in enumerate(asio_checkboxlists):
             [step(checkbox_list, i + 1) for step in (add_asio_checkboxes,)]
@@ -165,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(
@@ -178,7 +206,7 @@ class Builder:
                 ]
             )
 
-        hardware_out = list()
+        hardware_out = []
         [step(hardware_out) for step in (add_physical_device_opts,)]
         return psg.Frame("PATCH COMPOSITE", hardware_out)
 
@@ -192,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}",
                             )
@@ -205,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}",
                         )
@@ -213,8 +241,8 @@ class Builder:
                     ],
                 )
 
-        asio_checkboxes = list()
+        asio_checkboxes = []
-        inner = list()
+        inner = []
         checkbox_lists = ([] for _ in range(self.kind.num_strip))
         for i, checkbox_list in enumerate(checkbox_lists):
             if i < self.kind.phys_in:
@@ -228,27 +256,23 @@ class Builder:
         return psg.Frame("PATCH INSERT", asio_checkboxes)
 
     def make_tab0_row5(self) -> psg.Frame:
-        """tab0 row5 represents asio buffer"""
+        """tab0 row5 represents advanced settings"""
-
-        samples = get_asio_samples_list()
-        samples.append("Default")
 
         return psg.Frame(
-            "ASIO BUFFER",
+            "ADVANCED SETTINGS",
             [
                 [
-                    psg.ButtonMenu(
+                    psg.Button(
-                        "ASIO BUFFER",
+                        "ADVANCED SETTINGS",
-                        size=(14, 2),
+                        size=(20, 2),
-                        menu_def=["", samples],
+                        key="ADVANCED SETTINGS",
-                        key="ASIO BUFFER",
                     )
-                ]
                 ],
-            key="ASIO BUFFER FRAME",
+            ],
+            key="ADVANCED SETTINGS FRAME",
         )
 
-    def make_tab1_row(self, i) -> psg.Frame:
+    def make_tab1_button_row(self, i) -> psg.Frame:
         """tab1 row represents a strip's outputs (A1-A5, B1-B3)"""
 
         def add_strip_outputs(layout):
@@ -272,15 +296,64 @@ class Builder:
                 ],
             )
 
-        outputs = list()
+        outputs = []
         [step(outputs) for step in (add_strip_outputs,)]
         return psg.Frame(self.window.cache["labels"][f"STRIP {i}||LABEL"], outputs, key=f"STRIP {i}||LABEL")
 
-    def make_tab1_rows(self) -> psg.Frame:
+    def make_tab1_button_rows(self) -> psg.Frame:
-        layout = [[self.make_tab1_row(i)] for i in range(self.kind.phys_in)]
+        layout = [[self.make_tab1_button_row(i)] for i in range(self.kind.phys_in)]
         return psg.Frame(None, layout, border_width=0)
 
-    def make_tab2_row(self, i) -> psg.Frame:
+    def make_tab1_slider_row(self, i) -> psg.Frame:
+        def add_gain_slider(layout):
+            layout.append(
+                [
+                    psg.Text("Gain"),
+                    psg.Slider(
+                        range=(-60, 12),
+                        default_value=self.vm.strip[i].gain,
+                        resolution=0.1,
+                        disable_number_display=True,
+                        expand_x=True,
+                        enable_events=True,
+                        orientation="horizontal",
+                        key=f"STRIP {i}||SLIDER GAIN",
+                    ),
+                ]
+            )
+
+        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=0.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)]
+        return psg.Frame(None, layout, border_width=0)
+
+    def make_tab2_button_row(self, i) -> psg.Frame:
         """tab2 row represents a strip's outputs (A1-A5, B1-B3)"""
 
         def add_strip_outputs(layout):
@@ -296,7 +369,7 @@ class Builder:
                     for j in range(self.kind.phys_out + self.kind.virt_out)
                 ]
             )
-            if i == self.kind.phys_in + self.kind.virt_in - 2:
+            if i == self.kind.phys_in + 1:
                 layout.append(
                     [
                         psg.Button("K", size=(6, 2), key=f"STRIP {i}||MONO"),
@@ -313,31 +386,124 @@ class Builder:
                     ],
                 )
 
-        outputs = list()
+        outputs = []
         [step(outputs) for step in (add_strip_outputs,)]
         return psg.Frame(self.window.cache["labels"][f"STRIP {i}||LABEL"], outputs, key=f"STRIP {i}||LABEL")
 
-    def make_tab2_rows(self) -> psg.Frame:
+    def make_tab2_button_rows(self) -> psg.Frame:
-        layout = [[self.make_tab2_row(i)] for i in range(self.kind.phys_in, self.kind.phys_in + self.kind.virt_in)]
+        layout = [
+            [self.make_tab2_button_row(i)] for i in range(self.kind.phys_in, self.kind.phys_in + self.kind.virt_in)
+        ]
         return psg.Frame(None, layout, border_width=0)
 
-    def make_tab3_row(self, i) -> psg.Frame:
+    def make_tab2_slider_row(self, i) -> psg.Frame:
-        """tab3 row represents bus composite toggle"""
+        def add_gain_slider(layout):
-
-        def add_strip_outputs(layout):
             layout.append(
                 [
-                    psg.Button("Mono", size=(6, 2), key=f"BUS {i}||MONO"),
+                    psg.Text("Gain"),
-                    psg.Button("EQ", size=(6, 2), key=f"BUS {i}||EQ"),
+                    psg.Slider(
-                    psg.Button("Mute", size=(6, 2), key=f"BUS {i}||MUTE"),
+                        range=(-60, 12),
-                    psg.Button(f"BUSMODE", size=(12, 2), key=f"BUS {i}||MODE"),
+                        default_value=self.vm.strip[i].gain,
+                        resolution=0.1,
+                        disable_number_display=True,
+                        expand_x=True,
+                        enable_events=True,
+                        orientation="horizontal",
+                        key=f"STRIP {i}||SLIDER GAIN",
+                    ),
                 ]
             )
 
-        outputs = list()
+        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=0.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 = [
+            [self.make_tab2_slider_row(i)] for i in range(self.kind.phys_in, self.kind.phys_in + self.kind.virt_in)
+        ]
+        return psg.Frame(None, layout, border_width=0)
+
+    def make_tab3_button_row(self, i) -> psg.Frame:
+        """tab3 row represents bus composite toggle"""
+
+        def add_strip_outputs(layout):
+            params = ["MONO", "EQ", "MUTE", "MODE"]
+            if self.vm.kind.name == "basic":
+                params.remove("EQ")
+            label = {"MODE": "BUSMODE"}
+            layout.append(
+                [
+                    psg.Button(
+                        label.get(param, param.capitalize()),
+                        size=(12 if param == "MODE" else 6, 2),
+                        key=f"BUS {i}||{param}",
+                    )
+                    for param in params
+                ]
+            )
+
+        outputs = []
         [step(outputs) for step in (add_strip_outputs,)]
         return psg.Frame(self.window.cache["labels"][f"BUS {i}||LABEL"], outputs, key=f"BUS {i}||LABEL")
 
-    def make_tab3_rows(self) -> psg.Frame:
+    def make_tab3_button_rows(self) -> psg.Frame:
-        layout = [[self.make_tab3_row(i)] for i in range(self.kind.num_bus)]
+        layout = [[self.make_tab3_button_row(i)] for i in range(self.kind.num_bus)]
+        return psg.Frame(None, layout, border_width=0)
+
+    def make_tab3_slider_row(self, i) -> psg.Frame:
+        def add_gain_slider(layout):
+            layout.append(
+                [
+                    psg.Slider(
+                        range=(-60, 12),
+                        default_value=self.vm.bus[i].gain,
+                        resolution=0.1,
+                        disable_number_display=True,
+                        expand_x=True,
+                        enable_events=True,
+                        orientation="horizontal",
+                        key=f"BUS {i}||SLIDER GAIN",
+                    )
+                ]
+            )
+
+        outputs = []
+        [step(outputs) for step in (add_gain_slider,)]
+        return psg.Frame(self.window.cache["labels"][f"BUS {i}||LABEL"], outputs, key=f"BUS {i}||LABEL||SLIDER")
+
+    def make_tab3_slider_rows(self) -> psg.Frame:
+        layout = [[self.make_tab3_slider_row(i)] for i in range(self.kind.num_bus)]
         return psg.Frame(None, layout, border_width=0)

src/nvda_voicemeeter/compound.py

@@ -0,0 +1,39 @@
+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
+        if param == "LIMIT":
+            resolution = 1
+        else:
+            resolution = 0.1
+        layout = [
+            [
+                psg.Text(param.capitalize(), size=size),
+                psg.Slider(
+                    range=range_,
+                    default_value=self.default_value(i, param),
+                    resolution=resolution,
+                    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/models.py

@@ -3,7 +3,10 @@ def _make_hardware_ins_cache(vm) -> dict:
 
 
 def _make_hardware_outs_cache(vm) -> dict:
-    return {**{f"HARDWARE OUT||A{i + 1}": vm.bus[i].device.name for i in range(vm.kind.phys_out)}}
+    hw_outs = {**{f"HARDWARE OUT||A{i + 1}": vm.bus[i].device.name for i in range(vm.kind.phys_out)}}
+    if vm.kind.name == "basic":
+        hw_outs |= {f"HARDWARE OUT||A2": vm.bus[1].device.name}
+    return hw_outs
 
 
 def _make_param_cache(vm, channel_type) -> dict:
@@ -39,14 +42,14 @@ def _make_param_cache(vm, channel_type) -> dict:
             **{f"STRIP {i}||SOLO": vm.strip[i].solo for i in range(vm.kind.num_strip)},
             **{f"STRIP {i}||MUTE": vm.strip[i].mute for i in range(vm.kind.num_strip)},
         }
-        return params
     else:
-        return {
+        params |= {
             **{f"BUS {i}||MONO": vm.bus[i].mono for i in range(vm.kind.num_bus)},
             **{f"BUS {i}||EQ": vm.bus[i].eq.on for i in range(vm.kind.num_bus)},
             **{f"BUS {i}||MUTE": vm.bus[i].mute for i in range(vm.kind.num_bus)},
             **{f"BUS {i}||MODE": vm.bus[i].mode.get() for i in range(vm.kind.num_bus)},
         }
+    return params
 
 
 def _make_label_cache(vm) -> dict:

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,17 +11,36 @@ 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
 
 
+_rejected_ids = (
+    "VBAudio100VMVAIO3",
+    "{F5735BD4-6EAF-4758-9710-9886E5AD0FF3}",
+    "{0239BE07-CEEF-4236-A900-AA778D432FD4}",
+)
+
+
 def get_input_device_list(vm) -> list:
-    return ["{type}: {name}".format(**vm.device.input(i)) for i in range(vm.device.ins)]
+    devices = []
+    for j in range(vm.device.ins):
+        device = vm.device.input(j)
+        if device["id"] not in _rejected_ids:
+            devices.append("{type}: {name}".format(**device))
+    return devices
 
 
-def get_output_device_list(vm) -> list:
+def get_output_device_list(i, vm) -> list:
-    return ["{type}: {name}".format(**vm.device.output(i)) for i in range(vm.device.outs)]
+    devices = []
+    for j in range(vm.device.outs):
+        device = vm.device.output(j)
+        if device["id"] not in _rejected_ids:
+            devices.append("{type}: {name}".format(**device))
+    if i == 0:
+        return devices
+    devices.append("- remove device selection -")
+    return [device for device in devices if not device.startswith("asio")]
 
 
 def get_patch_composite_list(kind) -> list:
@@ -47,28 +69,20 @@ def get_patch_insert_channels() -> list:
 _patch_insert_channels = get_patch_insert_channels()
 
 
-def get_asio_samples_list() -> list:
+def get_asio_samples_list(driver) -> list:
-    return [
+    if driver == "MME":
-        "1024",
+        samples = ["2048", "1536", "1024", "896", "768", "704", "640", "576", "512", "480", "441"]
-        "768",
+    else:
-        "704",
+        # fmt: off
-        "640",
+        samples = [
-        "576",
+            "2048", "1536", "1024", "768", "704", "640", "576", "512", "480", "448", "441", "416", "384",
-        "512",
+            "352", "320", "288", "256", "224", "192", "160", "128"
-        "480",
-        "448",
-        "441",
-        "416",
-        "384",
-        "352",
-        "320",
-        "288",
-        "256",
-        "224",
-        "192",
-        "160",
-        "128",
         ]
+        # fmt: on
+        if driver == "ASIO":
+            samples = [x for x in samples if x not in ("2048", "1536")]
+    samples.append("Default")
+    return samples
 
 
 def get_tabs_labels() -> list:
@@ -94,7 +108,14 @@ def get_channel_identifier_list(vm) -> list:
     return identifiers
 
 
-def get_bus_modes() -> list:
+def get_bus_modes(vm) -> list:
+    if vm.kind.name == "basic":
+        return [
+            "normal",
+            "amix",
+            "repeat",
+            "composite",
+        ]
     return [
         "normal",
         "amix",
@@ -109,3 +130,23 @@ def get_bus_modes() -> list:
         "lfeonly",
         "rearonly",
     ]
+
+
+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,26 +4,10 @@ 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,
-    get_asio_checkbox_index,
-    get_bus_modes,
-    get_channel_identifier_list,
-    get_insert_checkbox_index,
-    get_patch_composite_list,
-    open_context_menu_for_buttonmenu,
-)
 
 logger = logging.getLogger(__name__)
 
@@ -40,13 +24,13 @@ 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_ins": models._make_hardware_ins_cache(self.vm),
-            "hw_outs": _make_hardware_outs_cache(self.vm),
+            "hw_outs": models._make_hardware_outs_cache(self.vm),
-            "strip": _make_param_cache(self.vm, "strip"),
+            "strip": models._make_param_cache(self.vm, "strip"),
-            "bus": _make_param_cache(self.vm, "bus"),
+            "bus": models._make_param_cache(self.vm, "bus"),
-            "labels": _make_label_cache(self.vm),
+            "labels": models._make_label_cache(self.vm),
-            "asio": _make_patch_asio_cache(self.vm),
+            "asio": models._make_patch_asio_cache(self.vm),
-            "insert": _make_patch_insert_cache(self.vm),
+            "insert": models._make_patch_insert_cache(self.vm),
         }
         self.nvda = Nvda()
         self.parser = Parser()
@@ -58,13 +42,22 @@ class NVDAVMWindow(psg.Window):
             self[f"HARDWARE IN||{i + 1}"].Widget.config(**buttonmenu_opts)
         for i in range(self.kind.phys_out):
             self[f"HARDWARE OUT||A{i + 1}"].Widget.config(**buttonmenu_opts)
+        if self.kind.name == "basic":
+            self[f"HARDWARE OUT||A2"].Widget.config(**buttonmenu_opts)
         if self.kind.name != "basic":
             [self[f"PATCH COMPOSITE||PC{i + 1}"].Widget.config(**buttonmenu_opts) for i in range(self.kind.phys_out)]
-            self["ASIO BUFFER"].Widget.config(**buttonmenu_opts)
+        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["ASIO BUFFER FRAME"].update(visible=False)
+                self[f"STRIP {i}||SLIDER LIMIT"].Widget.config(**slider_opts)
-            self["ASIO BUFFER FRAME"].hide_row()
+        for i in range(self.kind.num_bus):
+            self[f"BUS {i}||SLIDER GAIN"].Widget.config(**slider_opts)
+
         self.register_events()
+        self["tabgroup"].set_focus()
 
     def __enter__(self):
         settings_path = Path.cwd() / self.SETTINGS
@@ -99,33 +92,51 @@ class NVDAVMWindow(psg.Window):
 
     def on_pdirty(self):
         self.cache = {
-            "hw_ins": _make_hardware_ins_cache(self.vm),
+            "hw_ins": models._make_hardware_ins_cache(self.vm),
-            "hw_outs": _make_hardware_outs_cache(self.vm),
+            "hw_outs": models._make_hardware_outs_cache(self.vm),
-            "strip": _make_param_cache(self.vm, "strip"),
+            "strip": models._make_param_cache(self.vm, "strip"),
-            "bus": _make_param_cache(self.vm, "bus"),
+            "bus": models._make_param_cache(self.vm, "bus"),
-            "labels": _make_label_cache(self.vm),
+            "labels": models._make_label_cache(self.vm),
-            "asio": _make_patch_asio_cache(self.vm),
+            "asio": models._make_patch_asio_cache(self.vm),
-            "insert": _make_patch_insert_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):
         """Registers events for widgets"""
 
         # TABS
-        self["tabs"].bind("<FocusIn>", "||FOCUS IN")
+        self["tabgroup"].bind("<FocusIn>", "||FOCUS IN")
+        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")
+        self.bind("<Control-a>", "CTRL-A")
 
         # Hardware In
         for i in range(self.vm.kind.phys_in):
@@ -138,6 +149,10 @@ class NVDAVMWindow(psg.Window):
             self[f"HARDWARE OUT||A{i + 1}"].bind("<FocusIn>", "||FOCUS IN")
             self[f"HARDWARE OUT||A{i + 1}"].bind("<space>", "||KEY SPACE", propagate=False)
             self[f"HARDWARE OUT||A{i + 1}"].bind("<Return>", "||KEY ENTER", propagate=False)
+        if self.vm.kind.name == "basic":
+            self[f"HARDWARE OUT||A2"].bind("<FocusIn>", "||FOCUS IN")
+            self[f"HARDWARE OUT||A2"].bind("<space>", "||KEY SPACE", propagate=False)
+            self[f"HARDWARE OUT||A2"].bind("<Return>", "||KEY ENTER", propagate=False)
 
         # Patch ASIO
         if self.kind.name != "basic":
@@ -161,6 +176,10 @@ class NVDAVMWindow(psg.Window):
                 else:
                     [self[f"INSERT CHECKBOX||IN{i + 1} {j}"].bind("<FocusIn>", "||FOCUS IN") for j in range(8)]
 
+        # Advanced Settings
+        self["ADVANCED SETTINGS"].bind("<FocusIn>", "||FOCUS IN")
+        self["ADVANCED SETTINGS"].bind("<Return>", "||KEY ENTER")
+
         # Strip Params
         for i in range(self.kind.num_strip):
             for j in range(self.kind.phys_out):
@@ -178,17 +197,53 @@ class NVDAVMWindow(psg.Window):
                     self[f"STRIP {i}||{param}"].bind("<FocusIn>", "||FOCUS IN")
                     self[f"STRIP {i}||{param}"].bind("<Return>", "||KEY ENTER")
 
+        # Strip Sliders
+        for i in range(self.kind.num_strip):
+            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"]
+        if self.vm.kind.name == "basic":
+            params.remove("EQ")
         for i in range(self.kind.num_bus):
-            for param in ("MONO", "EQ", "MUTE", "MODE"):
+            for param in params:
                 self[f"BUS {i}||{param}"].bind("<FocusIn>", "||FOCUS IN")
                 self[f"BUS {i}||{param}"].bind("<Return>", "||KEY ENTER")
 
-        # ASIO Buffer
+        # Bus Sliders
-        if self.kind.name != "basic":
+        for i in range(self.kind.num_bus):
-            self["ASIO BUFFER"].bind("<FocusIn>", "||FOCUS IN")
+            self[f"BUS {i}||SLIDER GAIN"].bind("<FocusIn>", "||FOCUS IN")
-            self["ASIO BUFFER"].bind("<space>", "||KEY SPACE", propagate=False)
+            self[f"BUS {i}||SLIDER GAIN"].bind("<FocusOut>", "||FOCUS OUT")
-            self["ASIO BUFFER"].bind("<Return>", "||KEY ENTER", propagate=False)
+            self[f"BUS {i}||SLIDER GAIN"].bind("<Left>", "||KEY LEFT")
+            self[f"BUS {i}||SLIDER GAIN"].bind("<Right>", "||KEY RIGHT")
+            self[f"BUS {i}||SLIDER GAIN"].bind("<Shift-KeyPress-Left>", "||KEY SHIFT LEFT")
+            self[f"BUS {i}||SLIDER GAIN"].bind("<Shift-KeyPress-Right>", "||KEY SHIFT RIGHT")
+            self[f"BUS {i}||SLIDER GAIN"].bind("<Control-KeyPress-Left>", "||KEY CTRL LEFT")
+            self[f"BUS {i}||SLIDER GAIN"].bind("<Control-KeyPress-Right>", "||KEY CTRL RIGHT")
+            self[f"BUS {i}||SLIDER GAIN"].bind("<Up>", "||KEY UP")
+            self[f"BUS {i}||SLIDER GAIN"].bind("<Down>", "||KEY DOWN")
+            self[f"BUS {i}||SLIDER GAIN"].bind("<Shift-KeyPress-Up>", "||KEY SHIFT UP")
+            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 = [
@@ -210,27 +265,24 @@ class NVDAVMWindow(psg.Window):
             self.logger.debug(f"values::{values}")
             if event in (psg.WIN_CLOSED, "Cancel"):
                 break
-            elif event.endswith("||FOCUS IN"):
+            match parsed_cmd := self.parser.match.parseString(event):
+                case [[button], ["FOCUS", "IN"]]:
                     if values["Browse"]:
                         filepath = values["Browse"]
                         break
-                label = event.split("||")[0]
+                    self.nvda.speak(button)
-                self.TKroot.after(
+                case [[button], ["KEY", "ENTER"]]:
-                    200 if label == "Edit" else 1,
-                    self.nvda.speak,
-                    label,
-                )
-            elif event.endswith("||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_out + 1
+            upper = self.kind.phys_in + 1
         elif tab == "Virtual Strip":
-            upper = self.kind.virt_out + 1
+            upper = self.kind.virt_in + 1
         elif tab == "Buses":
             upper = self.kind.num_bus + 1
 
@@ -260,24 +312,87 @@ class NVDAVMWindow(psg.Window):
             self.logger.debug(f"values::{values}")
             if event in (psg.WIN_CLOSED, "Cancel"):
                 break
-            elif event.endswith("||KEY ENTER"):
+            match parsed_cmd := self.parser.match.parseString(event):
-                window.find_element_with_focus().click()
+                case ["Index"]:
-            elif event == "Index":
                     val = values["Index"]
                     self.nvda.speak(f"Index {val}")
-            elif event.endswith("||FOCUS IN"):
+                case [[button], ["FOCUS", "IN"]]:
-                if event.startswith("Index"):
+                    if button == "Index":
                         val = values["Index"]
                         self.nvda.speak(f"Index {val}")
                     else:
-                    self.nvda.speak(event.split("||")[0])
+                        self.nvda.speak(button)
-            elif event == "Ok":
+                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=["", 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))])
+
+        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"]]:
+                    util.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()
+
     def run(self):
         """
         Parses the event string and matches it to events
@@ -291,17 +406,16 @@ class NVDAVMWindow(psg.Window):
             self.logger.debug(f"values::{values}")
             if event in (psg.WIN_CLOSED, "Exit"):
                 break
-            elif event == "tabs":
-                self.nvda.speak(f"tab {values['tabs']}")
 
             match parsed_cmd := self.parser.match.parseString(event):
                 # Focus tabgroup
                 case ["CTRL-TAB"] | ["CTRL-SHIFT-TAB"]:
-                    self["tabs"].set_focus()
+                    self["tabgroup"].set_focus()
+                    self.nvda.speak(f"{values['tabgroup']}")
 
                 # Rename popups
                 case ["F2:113"]:
-                    tab = values["tabs"]
+                    tab = values["tabgroup"]
                     if tab in ("Physical Strip", "Virtual Strip", "Buses"):
                         data = self.popup_rename("Label", title=f"Rename {tab}", tab=tab)
                         if not data:  # cancel was pressed
@@ -309,20 +423,21 @@ class NVDAVMWindow(psg.Window):
                         index = int(data["Index"]) - 1
                         match tab:
                             case "Physical Strip":
-                                label = data.get("Edit") or f"Hardware Input {index + 1}"
+                                label = data.get("Edit", f"Hardware Input {index + 1}")
                                 self.vm.strip[index].label = label
                                 self[f"STRIP {index}||LABEL"].update(value=label)
                                 self.cache["labels"][f"STRIP {index}||LABEL"] = label
                             case "Virtual Strip":
-                                label = data.get("Edit") or f"Virtual Input {index + 1}"
+                                index += self.kind.phys_in
+                                label = data.get("Edit", f"Virtual Input {index - self.kind.phys_in + 1}")
                                 self.vm.strip[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 {index + 1}")
                                 else:
-                                    label = data.get("Edit") or f"Virtual Bus {index - self.kind.phys_out + 1}"
+                                    label = data.get("Edit", f"Virtual Bus {index - self.kind.phys_out + 1}")
                                 self.vm.bus[index].label = label
                                 self[f"BUS {index}||LABEL"].update(value=label)
                                 self.cache["labels"][f"BUS {index}||LABEL"] = label
@@ -360,6 +475,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,
@@ -385,11 +502,18 @@ class NVDAVMWindow(psg.Window):
                     else:
                         with open(self.SETTINGS, "wb") as f:
                             f.truncate()
-                        self.logger.debug("default bin was truncated")
+                        self.logger.debug("settings.json was truncated")
 
                 # Tabs
-                case [["tabs"], ["FOCUS", "IN"]]:
+                case ["tabgroup"] | [["tabgroup"], ["FOCUS", "IN"]]:
-                    self.nvda.speak(f"tab {values['tabs']}")
+                    if self.find_element_with_focus() is None:
+                        self.nvda.speak(f"{values['tabgroup']}")
+                case [["tabgroup"], tabname] | [["tabgroup"], tabname, ["FOCUS", "IN"]]:
+                    if self.find_element_with_focus() is None:
+                        name = " ".join(tabname)
+                        self.nvda.speak(f"{values[f'tabgroup||{name}']}")
+                case [["tabgroup"], _, ["KEY", "SHIFT", "TAB"]]:
+                    self.nvda.speak(values["tabgroup"])
 
                 # Hardware In
                 case [["HARDWARE", "IN"], [key]]:
@@ -400,7 +524,7 @@ class NVDAVMWindow(psg.Window):
                             setattr(self.vm.strip[index].device, "wdm", "")
                             self.TKroot.after(200, self.nvda.speak, f"HARDWARE IN {key} device selection removed")
                         case [driver, device_name]:
-                            setattr(self.vm.strip[index].device, driver, device_name.strip())
+                            setattr(self.vm.strip[index].device, driver, device_name.lstrip())
                             phonetic = {"mme": "em em e"}
                             self.TKroot.after(
                                 200,
@@ -408,9 +532,10 @@ class NVDAVMWindow(psg.Window):
                                 f"HARDWARE IN {key} set {phonetic.get(driver, driver)} {device_name}",
                             )
                 case [["HARDWARE", "IN"], [key], ["FOCUS", "IN"]]:
+                    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]]:
@@ -421,7 +546,7 @@ class NVDAVMWindow(psg.Window):
                             setattr(self.vm.bus[index].device, "wdm", "")
                             self.TKroot.after(200, self.nvda.speak, f"HARDWARE OUT {key} device selection removed")
                         case [driver, device_name]:
-                            setattr(self.vm.bus[index].device, driver, device_name.strip())
+                            setattr(self.vm.bus[index].device, driver, device_name.lstrip())
                             phonetic = {"mme": "em em e"}
                             self.TKroot.after(
                                 200,
@@ -429,18 +554,20 @@ class NVDAVMWindow(psg.Window):
                                 f"HARDWARE OUT {key} set {phonetic.get(driver, driver)} {device_name}",
                             )
                 case [["HARDWARE", "OUT"], [key], ["FOCUS", "IN"]]:
+                    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}")
                 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}"]
                         channel = ("left", "right")[int(channel)]
                         num = int(in_num[-1])
@@ -450,21 +577,22 @@ 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:
                         if values[f"PATCH COMPOSITE||{key}"]:
                             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]),
@@ -472,32 +600,28 @@ class NVDAVMWindow(psg.Window):
                     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'}"
+                        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"]]:
-                    index = get_insert_checkbox_index(
+                    if self.find_element_with_focus() is not None:
+                        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'}")
 
-                # ASIO Buffer
+                # Advanced Settings
-                case ["ASIO BUFFER"]:
+                case ["ADVANCED SETTINGS"] | ["CTRL-A"]:
-                    if values[event] == "Default":
+                    if values["tabgroup"] == "tab||Settings":
-                        val = 0
+                        self.popup_advanced_settings(title="Advanced Settings")
-                    else:
+                case [["ADVANCED", "SETTINGS"], ["FOCUS", "IN"]]:
-                        val = values[event]
+                    self.nvda.speak("ADVANCED SETTINGS")
-                    self.vm.option.buffer("asio", val)
+                case [["ADVANCED", "SETTINGS"], ["KEY", "ENTER"]]:
-                    self.TKroot.after(200, self.nvda.speak, f"ASIO BUFFER {val if val else 'default'}")
+                    self.find_element_with_focus().click()
-                case [["ASIO", "BUFFER"], ["FOCUS", "IN"]]:
-                    val = int(self.vm.get("option.buffer.asio"))
-                    self.nvda.speak(f"ASIO BUFFER {val if val else 'default'}")
-                case [["ASIO", "BUFFER"], ["KEY", "SPACE" | "ENTER"]]:
-                    open_context_menu_for_buttonmenu(self, "ASIO BUFFER")
 
                 # Strip Params
                 case [["STRIP", index], [param]]:
@@ -506,7 +630,7 @@ class NVDAVMWindow(psg.Window):
                         case "MONO":
                             if int(index) < self.kind.phys_in:
                                 actual = param.lower()
-                            elif int(index) == self.kind.phys_in + self.kind.virt_in - 2:
+                            elif int(index) == self.kind.phys_in + 1:
                                 actual = "k"
                             else:
                                 actual = "mc"
@@ -531,12 +655,13 @@ class NVDAVMWindow(psg.Window):
                             self.cache["strip"][f"STRIP {index}||{param}"] = val
                             self.nvda.speak(f"{label} {param} {'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}"]
                         match param:
                             case "MONO":
                                 if int(index) < self.kind.phys_in:
                                     actual = param.lower()
-                            elif int(index) == self.kind.phys_in + self.kind.virt_in - 2:
+                                elif int(index) == self.kind.phys_in + 1:
                                     actual = "k"
                                 else:
                                     actual = "mc"
@@ -553,6 +678,251 @@ class NVDAVMWindow(psg.Window):
                 case [["STRIP", index], [param], ["KEY", "ENTER"]]:
                     self.find_element_with_focus().click()
 
+                # Strip Sliders
+                case [
+                    ["STRIP", index],
+                    [
+                        "SLIDER",
+                        "GAIN"
+                        | "COMP"
+                        | "GATE"
+                        | "DENOISER"
+                        | "AUDIBILITY"
+                        | "LIMIT"
+                        | "BASS"
+                        | "MID"
+                        | "TREBLE" as param,
+                    ],
+                ]:
+                    label = self.cache["labels"][f"STRIP {index}||LABEL"]
+                    val = values[event]
+                    match param:
+                        case "GAIN":
+                            self.vm.strip[int(index)].gain = val
+                        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)
+                    self.nvda.speak(f"{label} {param} slider {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
+                        label = self.cache["labels"][f"STRIP {index}||LABEL"]
+                        val = values[f"STRIP {index}||SLIDER {param}"]
+                        self.nvda.speak(f"{label} {param} slider {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"
+                        | "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
+
+                    match param:
+                        case "GAIN":
+                            self.vm.strip[int(index)].gain = util.check_bounds(val, (-60, 12))
+                            self[f"STRIP {index}||SLIDER {param}"].update(value=util.check_bounds(val, (-60, 12)))
+                        case "COMP" | "GATE" | "DENOISER":
+                            setattr(target, "knob", util.check_bounds(val, (0, 10)))
+                            self[f"STRIP {index}||SLIDER {param}"].update(value=util.check_bounds(val, (0, 10)))
+                        case "AUDIBILITY":
+                            self.vm.strip[int(index)].audibility = util.check_bounds(val, (0, 10))
+                            self[f"STRIP {index}||SLIDER {param}"].update(value=util.check_bounds(val, (0, 10)))
+                        case "BASS" | "MID" | "TREBLE":
+                            setattr(self.vm.strip[int(index)], param.lower(), util.check_bounds(val, (-12, 12)))
+                            self[f"STRIP {index}||SLIDER {param}"].update(value=util.check_bounds(val, (-12, 12)))
+                        case "LIMIT":
+                            self.vm.strip[int(index)].limit = util.check_bounds(val, (-40, 12))
+                            self[f"STRIP {index}||SLIDER {param}"].update(value=util.check_bounds(val, (-40, 12)))
+                case [
+                    ["STRIP", index],
+                    [
+                        "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
+
+                    match param:
+                        case "GAIN":
+                            self.vm.strip[int(index)].gain = util.check_bounds(val, (-60, 12))
+                            self[f"STRIP {index}||SLIDER {param}"].update(value=util.check_bounds(val, (-60, 12)))
+                        case "COMP" | "GATE" | "DENOISER":
+                            setattr(target, "knob", util.check_bounds(val, (0, 10)))
+                            self[f"STRIP {index}||SLIDER {param}"].update(value=util.check_bounds(val, (0, 10)))
+                        case "AUDIBILITY":
+                            self.vm.strip[int(index)].audibility = util.check_bounds(val, (0, 10))
+                            self[f"STRIP {index}||SLIDER {param}"].update(value=util.check_bounds(val, (0, 10)))
+                        case "BASS" | "MID" | "TREBLE":
+                            setattr(self.vm.strip[int(index)], param.lower(), util.check_bounds(val, (-12, 12)))
+                            self[f"STRIP {index}||SLIDER {param}"].update(value=util.check_bounds(val, (-12, 12)))
+                        case "LIMIT":
+                            self.vm.strip[int(index)].limit = util.check_bounds(val, (-40, 12))
+                            self[f"STRIP {index}||SLIDER {param}"].update(value=util.check_bounds(val, (-40, 12)))
+                case [
+                    ["STRIP", index],
+                    [
+                        "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
+
+                    match param:
+                        case "GAIN":
+                            self.vm.strip[int(index)].gain = util.check_bounds(val, (-60, 12))
+                            self[f"STRIP {index}||SLIDER {param}"].update(value=util.check_bounds(val, (-60, 12)))
+                        case "COMP" | "GATE" | "DENOISER":
+                            setattr(target, "knob", util.check_bounds(val, (0, 10)))
+                            self[f"STRIP {index}||SLIDER {param}"].update(value=util.check_bounds(val, (0, 10)))
+                        case "AUDIBILITY":
+                            self.vm.strip[int(index)].audibility = util.check_bounds(val, (0, 10))
+                            self[f"STRIP {index}||SLIDER {param}"].update(value=util.check_bounds(val, (0, 10)))
+                        case "BASS" | "MID" | "TREBLE":
+                            setattr(self.vm.strip[int(index)], param.lower(), util.check_bounds(val, (-12, 12)))
+                            self[f"STRIP {index}||SLIDER {param}"].update(value=util.check_bounds(val, (-12, 12)))
+                        case "LIMIT":
+                            self.vm.strip[int(index)].limit = util.check_bounds(val, (-40, 12))
+                            self[f"STRIP {index}||SLIDER {param}"].update(value=util.check_bounds(val, (-40, 12)))
+                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)
+
                 # Bus Params
                 case [["BUS", index], [param]]:
                     val = self.cache["bus"][event]
@@ -577,7 +947,7 @@ class NVDAVMWindow(psg.Window):
                                 f"{label} bus {param} {'on' if val else 'off'}",
                             )
                         case "MODE":
-                            bus_modes = get_bus_modes()
+                            bus_modes = util.get_bus_modes(self.vm)
                             next_index = bus_modes.index(val) + 1
                             if next_index == len(bus_modes):
                                 next_index = 0
@@ -602,6 +972,7 @@ class NVDAVMWindow(psg.Window):
                                 f"{label} bus mode {phonetic.get(next_bus, next_bus)}",
                             )
                 case [["BUS", index], [param], ["FOCUS", "IN"]]:
+                    if self.find_element_with_focus() is not None:
                         label = self.cache["labels"][f"BUS {index}||LABEL"]
                         val = self.cache["bus"][f"BUS {index}||{param}"]
                         if param == "MODE":
@@ -611,6 +982,59 @@ class NVDAVMWindow(psg.Window):
                 case [["BUS", index], [param], ["KEY", "ENTER"]]:
                     self.find_element_with_focus().click()
 
+                # Bus Sliders
+                case [["BUS", index], ["SLIDER", "GAIN"]]:
+                    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}")
+                case [["BUS", index], ["SLIDER", "GAIN"], ["FOCUS", "OUT"]]:
+                    self.vm.event.pdirty = True
+                case [["BUS", index], ["SLIDER", "GAIN"], ["KEY", "LEFT" | "RIGHT" | "UP" | "DOWN" as direction]]:
+                    val = self.vm.bus[int(index)].gain
+                    match direction:
+                        case "RIGHT" | "UP":
+                            val += 1
+                        case "LEFT" | "DOWN":
+                            val -= 1
+                    self.vm.bus[int(index)].gain = util.check_bounds(val, (-60, 12))
+                    self[f"BUS {index}||SLIDER GAIN"].update(value=val)
+                case [
+                    ["BUS", index],
+                    ["SLIDER", "GAIN"],
+                    ["KEY", "CTRL", "LEFT" | "RIGHT" | "UP" | "DOWN" as direction],
+                ]:
+                    val = self.vm.bus[int(index)].gain
+                    match direction:
+                        case "RIGHT" | "UP":
+                            val += 3
+                        case "LEFT" | "DOWN":
+                            val -= 3
+                    self.vm.bus[int(index)].gain = util.check_bounds(val, (-60, 12))
+                    self[f"BUS {index}||SLIDER GAIN"].update(value=val)
+                case [
+                    ["BUS", index],
+                    ["SLIDER", "GAIN"],
+                    ["KEY", "SHIFT", "LEFT" | "RIGHT" | "UP" | "DOWN" as direction],
+                ]:
+                    val = self.vm.bus[int(index)].gain
+                    match direction:
+                        case "RIGHT" | "UP":
+                            val += 0.1
+                        case "LEFT" | "DOWN":
+                            val -= 0.1
+                    self.vm.bus[int(index)].gain = util.check_bounds(val, (-60, 12))
+                    self[f"BUS {index}||SLIDER GAIN"].update(value=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)
+
                 # Unknown
                 case _:
                     self.logger.debug(f"Unknown event {event}")