bump to v0.5.6b1

addresses issue #17

README.md

@@ -107,12 +107,30 @@ All sliders may be controlled in three different ways:
 - `Shift + Left|Right arrow` to move a slider by 0.1 steps.
 - `Control + Left|Right arrow` to move a slider by 3 steps.
 
+To reset a slider back to its default value you may use `Control + Shift + R`.
+
 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`.
 
 Pressing `Cancel` will close the popup window with no affect on the label.
 
+#### `Advanced Compressor|Gate`
+
+For potato version only, you may access advanced Compressor and Gate sliders. Simply focus any Gate or Compressor slider and press `Control + A`. This will open a popup window where you can navigate between the different sliders with `TAB`. Move the sliders with the same binds you would for normal sliders. However, there are a couple of extra binds for certain controls.
+
+For Compressor Release you may use:
+
+- `Alt + Left|Right arrow` to move the slider by 10 steps.
+- `Alt + Control +  Left|Right arrow` to move the slider by 50 steps.
+
+For Gate BP Sidechain, Attack, Hold, Release you may use:
+
+- `Alt + Left|Right arrow` to move the slider by 10 steps.
+- `Alt + Control +  Left|Right arrow` to move the slider by 50 steps.
+
+To reset a slider back to its default value you may use `Control + Shift + R`.
+
 #### `Menu`
 
 A single menu item `Voicemeeter` can be opened using `Alt` and then `v`. The menu allows you to:

pdm.lock

@@ -251,13 +251,13 @@ files = [
 
 [[package]]
 name = "voicemeeter-api"
-version = "2.4.10"
+version = "2.4.11"
 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.10-py3-none-any.whl", hash = "sha256:2f75acb7b472e56b6bd8d4f1141f32d948c55ef9b30d5a08e085a1c8e76e2464"},
-    {file = "voicemeeter_api-2.4.10.tar.gz", hash = "sha256:1d8dfc1e8922179f8b97c90b90b9ed051082018c6af5feb1d48250140a02d40c"},
+    {file = "voicemeeter_api-2.4.11-py3-none-any.whl", hash = "sha256:7a1b290d90c851204438c18e2d343e568c242fcd1e664c5b88d4019a553d44e1"},
+    {file = "voicemeeter_api-2.4.11.tar.gz", hash = "sha256:875591ad326a7a13ef141536cca83953edcda81da256191bab3844bac46a0e70"},
 ]

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nvda_voicemeeter"
-version = "0.4.2a1"
+version = "0.5.6b1"
 description = "A Voicemeeter app compatible with NVDA"
 authors = [
     { name = "onyx-and-iris", email = "code@onyxandiris.online" },
@@ -8,7 +8,7 @@ authors = [
 dependencies = [
     "pysimplegui>=4.60.5",
     "pyparsing>=3.1.1",
-    "voicemeeter-api>=2.4.10",
+    "voicemeeter-api>=2.4.11",
 ]
 requires-python = ">=3.10,<3.12"
 readme = "README.md"
@@ -35,16 +35,60 @@ shell = "build.ps1"
 line-length = 119
 
 [tool.ruff]
-# Enable pycodestyle (`E`) and Pyflakes (`F`) codes by default.
-select = ["E", "F"]
-# Avoid enforcing line-length violations (`E501`). Let Black deal with this.
-ignore = ["E501"]
-
-# Allow autofix for all enabled rules (when `--fix`) is provided.
-fixable = ["A", "B", "C", "D", "E", "F", "G", "I", "N", "Q", "S", "T", "W", "ANN", "ARG", "BLE", "COM", "DJ", "DTZ", "EM", "ERA", "EXE", "FBT", "ICN", "INP", "ISC", "NPY", "PD", "PGH", "PIE", "PL", "PT", "PTH", "PYI", "RET", "RSE", "RUF", "SIM", "SLF", "TCH", "TID", "TRY", "UP", "YTT"]
+select = [
+    "E",
+    "F",
+]
+ignore = [
+    "E501",
+]
+fixable = [
+    "A",
+    "B",
+    "C",
+    "D",
+    "E",
+    "F",
+    "G",
+    "I",
+    "N",
+    "Q",
+    "S",
+    "T",
+    "W",
+    "ANN",
+    "ARG",
+    "BLE",
+    "COM",
+    "DJ",
+    "DTZ",
+    "EM",
+    "ERA",
+    "EXE",
+    "FBT",
+    "ICN",
+    "INP",
+    "ISC",
+    "NPY",
+    "PD",
+    "PGH",
+    "PIE",
+    "PL",
+    "PT",
+    "PTH",
+    "PYI",
+    "RET",
+    "RSE",
+    "RUF",
+    "SIM",
+    "SLF",
+    "TCH",
+    "TID",
+    "TRY",
+    "UP",
+    "YTT",
+]
 unfixable = []
-
-# Exclude a variety of commonly ignored directories.
 exclude = [
     ".bzr",
     ".direnv",
@@ -68,19 +112,15 @@ exclude = [
     "node_modules",
     "venv",
 ]
-
-# Same as Black.
 line-length = 119
-
-# Allow unused variables when underscore-prefixed.
 dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
-
-# Assume Python 3.10
 target-version = "py310"
 
 [tool.ruff.mccabe]
-# Unlike Flake8, default to a complexity level of 10.
 max-complexity = 10
 
 [tool.ruff.per-file-ignores]
-"__init__.py" = ["E402", "F401"] # Ignore unused import and variable not accessed violations
+"__init__.py" = [
+    "E402",
+    "F401",
+]

src/nvda_voicemeeter/builder.py

@@ -26,7 +26,6 @@ class Builder:
             steps = (
                 self.make_tab0_row0,
                 self.make_tab0_row1,
-                self.make_tab0_row2,
                 self.make_tab0_row3,
                 self.make_tab0_row4,
                 self.make_tab0_row5,
@@ -152,61 +151,20 @@ class Builder:
         [step(hardware_out) for step in (add_physical_device_opts,)]
         return psg.Frame("Hardware Out", hardware_out)
 
-    def make_tab0_row2(self) -> psg.Frame:
-        """tab0 row2 represents patch asio inputs to strips"""
-
-        def add_asio_checkboxes(layout, i):
-            nums = list(range(99))
-            layout.append(
-                [
-                    psg.Spin(
-                        nums,
-                        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",
-                    )
-                ],
-            )
-            layout.append(
-                [
-                    psg.Spin(
-                        nums,
-                        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",
-                    )
-                ],
-            )
-
-        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,)]
-            inner.append(psg.Frame(f"In#{i + 1}", checkbox_list))
-
-        asio_checkboxes = [inner]
-        return psg.Frame("PATCH ASIO Inputs to Strips", asio_checkboxes)
-
     def make_tab0_row3(self) -> psg.Frame:
         """tab0 row3 represents patch composite"""
 
         def add_physical_device_opts(layout):
-            outputs = util.get_patch_composite_list(self.vm.kind)
+            outputs = util.get_patch_composite_list(self.kind)
             layout.append(
                 [
                     psg.ButtonMenu(
                         f"PC{i + 1}",
-                        size=(6, 2),
+                        size=(5, 2),
                         menu_def=["", outputs],
                         key=f"PATCH COMPOSITE||PC{i + 1}",
                     )
-                    for i in range(self.kind.phys_out)
+                    for i in range(self.kind.composite)
                 ]
             )
 
@@ -381,7 +339,7 @@ class Builder:
             if i == self.kind.phys_in + 1:
                 layout.append(
                     [
-                        psg.Button("K", size=(6, 2), key=f"STRIP {i}||MONO"),
+                        psg.Button("K", size=(6, 2), key=f"STRIP {i}||KARAOKE"),
                         psg.Button("Solo", size=(6, 2), key=f"STRIP {i}||SOLO"),
                         psg.Button("Mute", size=(6, 2), key=f"STRIP {i}||MUTE"),
                     ],
@@ -389,7 +347,7 @@ class Builder:
             else:
                 layout.append(
                     [
-                        psg.Button("MC", size=(6, 2), key=f"STRIP {i}||MONO"),
+                        psg.Button("MC", size=(6, 2), key=f"STRIP {i}||MC"),
                         psg.Button("Solo", size=(6, 2), key=f"STRIP {i}||SOLO"),
                         psg.Button("Mute", size=(6, 2), key=f"STRIP {i}||MUTE"),
                     ],
@@ -478,18 +436,26 @@ class Builder:
         """tab3 row represents bus composite toggle"""
 
         def add_strip_outputs(layout):
-            params = ["MONO", "EQ", "MUTE", "MODE"]
-            if self.vm.kind.name == "basic":
+            params = ["MONO", "EQ", "MUTE"]
+            if self.kind.name == "basic":
                 params.remove("EQ")
-            label = {"MODE": "BUSMODE"}
+            busmodes = [util._bus_mode_map[mode] for mode in util.get_bus_modes(self.vm)]
             layout.append(
                 [
+                    *[
                         psg.Button(
-                        label.get(param, param.capitalize()),
-                        size=(12 if param == "MODE" else 6, 2),
+                            param.capitalize(),
+                            size=(6, 2),
                             key=f"BUS {i}||{param}",
                         )
                         for param in params
+                    ],
+                    psg.ButtonMenu(
+                        "BUSMODE",
+                        size=(12, 2),
+                        menu_def=["", busmodes],
+                        key=f"BUS {i}||MODE",
+                    ),
                 ]
             )
 

src/nvda_voicemeeter/cdll.py

@@ -33,7 +33,7 @@ def get_nvdapath():
 
 try:
     NVDA_PATH = Path(get_nvdapath()) / "nvda.exe"
-except FileNotFoundError as e:
+except FileNotFoundError:
     NVDA_PATH = ""
 
 

src/nvda_voicemeeter/compound.py

@@ -1,5 +1,9 @@
+from typing import Union
+
 import PySimpleGUI as psg
 
+from . import util
+
 
 class LabelSlider(psg.Frame):
     """Compound Label Slider Strip element"""
@@ -46,6 +50,7 @@ class CompSlider(psg.Slider):
             expand_x=True,
             enable_events=True,
             orientation="horizontal",
+            key=f"COMPRESSOR||SLIDER {param}",
             **self.default_params(param),
         )
 
@@ -57,61 +62,144 @@ class CompSlider(psg.Slider):
                     "default_value": self.vm.strip[self.index].comp.gainin,
                     "resolution": 0.1,
                     "disabled": True,
-                    "key": f"COMPRESSOR||SLIDER {param}",
                 }
             case "RATIO":
                 return {
                     "range": (1, 8),
                     "default_value": self.vm.strip[self.index].comp.ratio,
                     "resolution": 0.1,
-                    "key": f"COMPRESSOR||SLIDER {param}",
                 }
             case "THRESHOLD":
                 return {
                     "range": (-40, -3),
                     "default_value": self.vm.strip[self.index].comp.threshold,
                     "resolution": 0.1,
-                    "key": f"COMPRESSOR||SLIDER {param}",
                 }
             case "ATTACK":
                 return {
                     "range": (0, 200),
                     "default_value": self.vm.strip[self.index].comp.attack,
                     "resolution": 0.1,
-                    "key": f"COMPRESSOR||SLIDER {param}",
                 }
             case "RELEASE":
                 return {
                     "range": (0, 5000),
                     "default_value": self.vm.strip[self.index].comp.release,
                     "resolution": 0.1,
-                    "key": f"COMPRESSOR||SLIDER {param}",
                 }
             case "KNEE":
                 return {
                     "range": (0, 1),
                     "default_value": self.vm.strip[self.index].comp.knee,
                     "resolution": 0.01,
-                    "key": f"COMPRESSOR||SLIDER {param}",
                 }
             case "OUTPUT GAIN":
                 return {
                     "range": (-24, 24),
                     "default_value": self.vm.strip[self.index].comp.gainout,
-                    "resolution": 0.01,
+                    "resolution": 0.1,
                     "disabled": True,
-                    "key": f"COMPRESSOR||SLIDER {param}",
                 }
 
+    @staticmethod
+    def check_bounds(param, val):
+        match param:
+            case "RATIO":
+                val = util.check_bounds(val, (1, 8))
+            case "THRESHOLD":
+                val = util.check_bounds(val, (-40, -3))
+            case "ATTACK":
+                val = util.check_bounds(val, (0, 200))
+            case "RELEASE":
+                val = util.check_bounds(val, (0, 5000))
+            case "KNEE":
+                val = util.check_bounds(val, (0, 1))
+        return val
 
-class LabelSliderCompressor(psg.Frame):
-    """Compound Label Slider Compressor element"""
 
-    def __init__(self, parent, index, param, *args, **kwargs):
+class GateSlider(psg.Slider):
+    def __init__(self, vm, index, param):
+        self.vm = vm
+        self.index = index
+        super().__init__(
+            disable_number_display=True,
+            expand_x=True,
+            enable_events=True,
+            orientation="horizontal",
+            key=f"GATE||SLIDER {param}",
+            **self.default_params(param),
+        )
+
+    def default_params(self, param):
+        match param:
+            case "THRESHOLD":
+                return {
+                    "range": (-60, -10),
+                    "default_value": self.vm.strip[self.index].gate.threshold,
+                    "resolution": 0.1,
+                }
+            case "DAMPING":
+                return {
+                    "range": (-60, -10),
+                    "default_value": self.vm.strip[self.index].gate.damping,
+                    "resolution": 0.1,
+                }
+            case "BPSIDECHAIN":
+                return {
+                    "range": (100, 4000),
+                    "default_value": self.vm.strip[self.index].gate.bpsidechain,
+                    "resolution": 1,
+                }
+            case "ATTACK":
+                return {
+                    "range": (0, 1000),
+                    "default_value": self.vm.strip[self.index].gate.attack,
+                    "resolution": 0.1,
+                }
+            case "HOLD":
+                return {
+                    "range": (0, 5000),
+                    "default_value": self.vm.strip[self.index].gate.hold,
+                    "resolution": 0.1,
+                }
+            case "RELEASE":
+                return {
+                    "range": (0, 5000),
+                    "default_value": self.vm.strip[self.index].gate.release,
+                    "resolution": 0.1,
+                }
+
+    @staticmethod
+    def check_bounds(param, val):
+        match param:
+            case "THRESHOLD":
+                val = util.check_bounds(val, (-60, -10))
+            case "DAMPING MAX":
+                val = util.check_bounds(val, (-60, -10))
+            case "BPSIDECHAIN":
+                val = util.check_bounds(val, (100, 4000))
+            case "ATTACK":
+                val = util.check_bounds(val, (0, 1000))
+            case "HOLD":
+                val = util.check_bounds(val, (0, 5000))
+            case "RELEASE":
+                val = util.check_bounds(val, (0, 5000))
+        return val
+
+
+class LabelSliderAdvanced(psg.Frame):
+    """Compound Label Slider element for Advanced Comp|Gate"""
+
+    def __init__(self, parent, index, param, slider_cls: Union[CompSlider, GateSlider], *args, **kwargs):
+        label_map = {
+            "DAMPING": "Damping Max",
+            "BPSIDECHAIN": "BP Sidechain",
+        }
+
         layout = [
             [
-                psg.Text(param.capitalize(), size=8),
-                CompSlider(parent.vm, index, param),
+                psg.Text(label_map.get(param, param.title()), size=10),
+                slider_cls(parent.vm, index, param),
             ]
         ]
         super().__init__(None, layout=layout, border_width=0, pad=0, *args, **kwargs)

src/nvda_voicemeeter/models.py

@@ -5,7 +5,7 @@ def _make_hardware_ins_cache(vm) -> dict:
 def _make_hardware_outs_cache(vm) -> dict:
     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}
+        hw_outs |= {"HARDWARE OUT||A2": vm.bus[1].device.name}
     return hw_outs
 
 
@@ -38,10 +38,15 @@ def _make_param_cache(vm, channel_type) -> dict:
                     **{f"STRIP {i}||B3": vm.strip[i].B3 for i in range(vm.kind.num_strip)},
                 }
         params |= {
-            **{f"STRIP {i}||MONO": vm.strip[i].mono for i in range(vm.kind.num_strip)},
+            **{f"STRIP {i}||MONO": vm.strip[i].mono for i in range(vm.kind.phys_in)},
             **{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)},
         }
+        for i in range(vm.kind.phys_in, vm.kind.phys_in + vm.kind.virt_in):
+            if i == vm.kind.phys_in + 1:
+                params[f"STRIP {i}||KARAOKE"] = vm.strip[i].k
+            else:
+                params[f"STRIP {i}||MC"] = vm.strip[i].mc
     else:
         params |= {
             **{f"BUS {i}||MONO": vm.bus[i].mono for i in range(vm.kind.num_bus)},
@@ -74,10 +79,17 @@ def _make_label_cache(vm) -> dict:
 
 
 def _make_patch_asio_cache(vm) -> dict:
+    params = {}
     if vm.kind.name != "basic":
-        return {**{f"ASIO CHECKBOX||{i}": vm.patch.asio[i].get() for i in range(vm.kind.phys_out * 2)}}
+        params |= {**{f"ASIO INPUT SPINBOX||{i}": vm.patch.asio[i].get() for i in range(vm.kind.phys_out * 2)}}
+        for i in range(vm.kind.phys_out - 1):
+            target = getattr(vm.patch, f"A{i + 2}")
+            params |= {**{f"ASIO OUTPUT A{i + 2} SPINBOX||{j}": target[j].get() for j in range(vm.kind.num_bus)}}
+    return params
 
 
 def _make_patch_insert_cache(vm) -> dict:
+    params = {}
     if vm.kind.name != "basic":
-        return {**{f"INSERT CHECKBOX||{i}": vm.patch.insert[i].on for i in range(vm.kind.num_strip_levels)}}
+        params |= {**{f"INSERT CHECKBOX||{i}": vm.patch.insert[i].on for i in range(vm.kind.num_strip_levels)}}
+    return params

src/nvda_voicemeeter/popup.py

@@ -4,7 +4,7 @@ from pathlib import Path
 import PySimpleGUI as psg
 
 from . import util
-from .compound import LabelSliderCompressor
+from .compound import CompSlider, GateSlider, LabelSliderAdvanced
 
 logger = logging.getLogger(__name__)
 
@@ -48,6 +48,30 @@ class Popup:
         if filepath:
             return Path(filepath)
 
+    def on_pdirty(self):
+        if self.popup.Title == "Advanced Settings":
+            if self.kind.name != "basic":
+                for key, value in self.window.cache["asio"].items():
+                    if "INPUT" in key:
+                        identifier, i = key.split("||")
+                        partial = util.get_channel_identifier_list(self.window.vm)[int(i)]
+                        self.popup[f"{identifier}||{partial}"].update(value=value)
+                    elif "OUTPUT" in key:
+                        self.popup[key].update(value=value)
+
+        if self.popup.Title == "Advanced Compressor":
+            for param in ("RATIO", "THRESHOLD", "ATTACK", "RELEASE", "KNEE"):
+                self.popup[f"COMPRESSOR||SLIDER {param}"].update(
+                    value=getattr(self.window.vm.strip[self.index].comp, param.lower())
+                )
+            self.popup["COMPRESSOR||SLIDER INPUT GAIN"].update(value=self.window.vm.strip[self.index].comp.gainin)
+            self.popup["COMPRESSOR||SLIDER OUTPUT GAIN"].update(value=self.window.vm.strip[self.index].comp.gainout)
+        elif self.popup.Title == "Advanced Gate":
+            for param in ("THRESHOLD", "DAMPING", "BPSIDECHAIN", "ATTACK", "HOLD", "RELEASE"):
+                self.popup[f"GATE||SLIDER {param}"].update(
+                    value=getattr(self.window.vm.strip[self.index].gate, param.lower())
+                )
+
     def rename(self, message, index, title=None, tab=None):
         if "Strip" in tab:
             if index < self.kind.phys_in:
@@ -94,6 +118,50 @@ class Popup:
         return data
 
     def advanced_settings(self, title):
+        def add_patch_asio_input_to_strips(layout, i):
+            nums = list(range(99))
+            layout.append(
+                [
+                    psg.Spin(
+                        nums,
+                        initial_value=self.window.cache["asio"][
+                            f"ASIO INPUT SPINBOX||{util.get_asio_input_spinbox_index(0, i)}"
+                        ],
+                        size=2,
+                        enable_events=True,
+                        key=f"ASIO INPUT SPINBOX||IN{i} 0",
+                    )
+                ],
+            )
+            layout.append(
+                [
+                    psg.Spin(
+                        nums,
+                        initial_value=self.window.cache["asio"][
+                            f"ASIO INPUT SPINBOX||{util.get_asio_input_spinbox_index(1, i)}"
+                        ],
+                        size=2,
+                        enable_events=True,
+                        key=f"ASIO INPUT SPINBOX||IN{i} 1",
+                    )
+                ],
+            )
+
+        def add_patch_bus_to_asio_outputs(layout, i):
+            nums = list(range(99))
+            layout.append(
+                [
+                    psg.Spin(
+                        nums,
+                        initial_value=self.window.cache["asio"][f"ASIO OUTPUT A{i} SPINBOX||{j}"],
+                        size=2,
+                        enable_events=True,
+                        key=f"ASIO OUTPUT A{i} SPINBOX||{j}",
+                    )
+                    for j in range(self.kind.num_bus)
+                ],
+            )
+
         def _make_buffering_frame() -> psg.Frame:
             buffer = [
                 [
@@ -109,27 +177,79 @@ class Popup:
             return psg.Frame("BUFFERING", buffer)
 
         layout = []
+        if self.kind.name != "basic":
+            inner = []
+            patch_input_to_strips = ([] for _ in range(self.kind.phys_in))
+            for i, checkbox_list in enumerate(patch_input_to_strips):
+                [step(checkbox_list, i + 1) for step in (add_patch_asio_input_to_strips,)]
+                inner.append(psg.Frame(f"In#{i + 1}", checkbox_list))
+            layout.append([psg.Frame("PATCH ASIO Inputs to Strips", [inner])])
+
+            inner_2 = []
+            patch_output_to_bus = ([] for _ in range(self.kind.phys_out - 1))
+            for i, checkbox_list in enumerate(patch_output_to_bus):
+                [step(checkbox_list, i + 2) for step in (add_patch_bus_to_asio_outputs,)]
+                inner_2.append([psg.Frame(f"OutA{i + 2}", checkbox_list)])
+            layout.append([psg.Frame("PATCH BUS to A1 ASIO Outputs", [*inner_2])])
+
         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)
+        self.popup = psg.Window(title, layout, finalize=True)
+        if self.kind.name != "basic":
+            for i in range(self.kind.phys_out):
+                self.popup[f"ASIO INPUT SPINBOX||IN{i + 1} 0"].Widget.config(state="readonly")
+                self.popup[f"ASIO INPUT SPINBOX||IN{i + 1} 1"].Widget.config(state="readonly")
+            for i in range(self.kind.phys_out - 1):
+                for j in range(self.kind.num_bus):
+                    self.popup[f"ASIO OUTPUT A{i + 2} SPINBOX||{j}"].Widget.config(state="readonly")
+        if self.kind.name != "basic":
+            for i in range(self.kind.phys_out):
+                self.popup[f"ASIO INPUT SPINBOX||IN{i + 1} 0"].bind("<FocusIn>", "||FOCUS IN")
+                self.popup[f"ASIO INPUT SPINBOX||IN{i + 1} 1"].bind("<FocusIn>", "||FOCUS IN")
+            for i in range(self.kind.phys_out - 1):
+                for j in range(self.kind.num_bus):
+                    self.popup[f"ASIO OUTPUT A{i + 2} SPINBOX||{j}"].bind("<FocusIn>", "||FOCUS IN")
         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")
+            self.popup[f"BUFFER {driver}"].Widget.config(**buttonmenu_opts)
+            self.popup[f"BUFFER {driver}"].bind("<FocusIn>", "||FOCUS IN")
+            self.popup[f"BUFFER {driver}"].bind("<space>", "||KEY SPACE", propagate=False)
+            self.popup[f"BUFFER {driver}"].bind("<Return>", "||KEY ENTER", propagate=False)
+        self.popup["Exit"].bind("<FocusIn>", "||FOCUS IN")
+        self.popup["Exit"].bind("<Return>", "||KEY ENTER")
+        self.window.vm.observer.add(self.on_pdirty)
         while True:
-            event, values = popup.read()
+            event, values = self.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 [["ASIO", "INPUT", "SPINBOX"], [in_num, channel]]:
+                    index = util.get_asio_input_spinbox_index(int(channel), int(in_num[-1]))
+                    val = values[f"ASIO INPUT SPINBOX||{in_num} {channel}"]
+                    self.window.vm.patch.asio[index].set(val)
+                    channel = ("left", "right")[int(channel)]
+                    self.window.nvda.speak(str(val))
+                case [["ASIO", "INPUT", "SPINBOX"], [in_num, channel], ["FOCUS", "IN"]]:
+                    if self.popup.find_element_with_focus() is not None:
+                        val = values[f"ASIO INPUT SPINBOX||{in_num} {channel}"]
+                        channel = ("left", "right")[int(channel)]
+                        num = int(in_num[-1])
+                        self.window.nvda.speak(f"Patch ASIO inputs to strips IN#{num} {channel} {val}")
+                case [["ASIO", "OUTPUT", param, "SPINBOX"], [index]]:
+                    target = getattr(self.window.vm.patch, param)[int(index)]
+                    target.set(values[event])
+                    self.window.nvda.speak(str(values[event]))
+                case [["ASIO", "OUTPUT", param, "SPINBOX"], [index], ["FOCUS", "IN"]]:
+                    if self.popup.find_element_with_focus() is not None:
+                        val = values[f"ASIO OUTPUT {param} SPINBOX||{index}"]
+                        self.window.nvda.speak(
+                            f"Patch BUS to A1 ASIO Outputs OUT {param} channel {int(index) + 1} {val}"
+                        )
                 case ["BUFFER MME" | "BUFFER WDM" | "BUFFER KS" | "BUFFER ASIO"]:
                     if values[event] == "Default":
                         if "MME" in event:
@@ -149,18 +269,21 @@ class Popup:
                     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}")
+                    util.open_context_menu_for_buttonmenu(self.popup, f"BUFFER {driver}")
                 case [[button], ["FOCUS", "IN"]]:
                     self.window.nvda.speak(button)
                 case [_, ["KEY", "ENTER"]]:
-                    popup.find_element_with_focus().click()
+                    self.popup.find_element_with_focus().click()
             self.logger.debug(f"parsed::{parsed_cmd}")
-        popup.close()
+        self.window.vm.observer.remove(self.on_pdirty)
+        self.popup.close()
 
     def compressor(self, index, title=None):
+        self.index = index
+
         def _make_comp_frame() -> psg.Frame:
             comp_layout = [
-                [LabelSliderCompressor(self.window, index, param)]
+                [LabelSliderAdvanced(self.window, index, param, CompSlider)]
                 for param in ("INPUT GAIN", "RATIO", "THRESHOLD", "ATTACK", "RELEASE", "KNEE", "OUTPUT GAIN")
             ]
             return psg.Frame("ADVANCED COMPRESSOR", comp_layout)
@@ -171,37 +294,39 @@ class Popup:
             layout.append([step()])
         layout.append([psg.Button("MAKEUP", size=(12, 1)), psg.Button("Exit", size=(8, 1))])
 
-        popup = psg.Window(title, layout, return_keyboard_events=False, finalize=True)
+        self.popup = psg.Window(title, layout, return_keyboard_events=False, finalize=True)
         buttonmenu_opts = {"takefocus": 1, "highlightthickness": 1}
         for param in ("INPUT GAIN", "RATIO", "THRESHOLD", "ATTACK", "RELEASE", "KNEE", "OUTPUT GAIN"):
-            popup[f"COMPRESSOR||SLIDER {param}"].Widget.config(**buttonmenu_opts)
-            popup[f"COMPRESSOR||SLIDER {param}"].bind("<FocusIn>", "||FOCUS IN")
-            popup[f"COMPRESSOR||SLIDER {param}"].bind("<FocusOut>", "||FOCUS OUT")
+            self.popup[f"COMPRESSOR||SLIDER {param}"].Widget.config(**buttonmenu_opts)
+            self.popup[f"COMPRESSOR||SLIDER {param}"].bind("<FocusIn>", "||FOCUS IN")
+            self.popup[f"COMPRESSOR||SLIDER {param}"].bind("<FocusOut>", "||FOCUS OUT")
             for event in ("KeyPress", "KeyRelease"):
                 event_id = event.removeprefix("Key").upper()
                 for direction in ("Left", "Right", "Up", "Down"):
-                    popup[f"COMPRESSOR||SLIDER {param}"].bind(
+                    self.popup[f"COMPRESSOR||SLIDER {param}"].bind(
                         f"<{event}-{direction}>", f"||KEY {direction.upper()} {event_id}"
                     )
-                    popup[f"COMPRESSOR||SLIDER {param}"].bind(
+                    self.popup[f"COMPRESSOR||SLIDER {param}"].bind(
                         f"<Shift-{event}-{direction}>", f"||KEY SHIFT {direction.upper()} {event_id}"
                     )
-                    popup[f"COMPRESSOR||SLIDER {param}"].bind(
+                    self.popup[f"COMPRESSOR||SLIDER {param}"].bind(
                         f"<Control-{event}-{direction}>", f"||KEY CTRL {direction.upper()} {event_id}"
                     )
                     if param == "RELEASE":
-                        popup[f"COMPRESSOR||SLIDER {param}"].bind(
+                        self.popup[f"COMPRESSOR||SLIDER {param}"].bind(
                             f"<Alt-{event}-{direction}>", f"||KEY ALT {direction.upper()} {event_id}"
                         )
-                        popup[f"COMPRESSOR||SLIDER {param}"].bind(
+                        self.popup[f"COMPRESSOR||SLIDER {param}"].bind(
                             f"<Control-Alt-{event}-{direction}>", f"||KEY CTRL ALT {direction.upper()} {event_id}"
                         )
-        popup["MAKEUP"].bind("<FocusIn>", "||FOCUS IN")
-        popup["MAKEUP"].bind("<Return>", "||KEY ENTER")
-        popup["Exit"].bind("<FocusIn>", "||FOCUS IN")
-        popup["Exit"].bind("<Return>", "||KEY ENTER")
+            self.popup[f"COMPRESSOR||SLIDER {param}"].bind("<Control-Shift-KeyPress-R>", "||KEY CTRL SHIFT R")
+        self.popup["MAKEUP"].bind("<FocusIn>", "||FOCUS IN")
+        self.popup["MAKEUP"].bind("<Return>", "||KEY ENTER")
+        self.popup["Exit"].bind("<FocusIn>", "||FOCUS IN")
+        self.popup["Exit"].bind("<Return>", "||KEY ENTER")
+        self.window.vm.observer.add(self.on_pdirty)
         while True:
-            event, values = popup.read()
+            event, values = self.popup.read()
             self.logger.debug(f"event::{event}")
             self.logger.debug(f"values::{values}")
             if event in (psg.WIN_CLOSED, "Exit"):
@@ -232,20 +357,10 @@ class Popup:
                                 else:
                                     val -= 1
 
-                        match param:
-                            case "RATIO":
-                                val = util.check_bounds(val, (1, 8))
-                            case "THRESHOLD":
-                                val = util.check_bounds(val, (-40, -3))
-                            case "ATTACK":
-                                val = util.check_bounds(val, (0, 200))
-                            case "RELEASE":
-                                val = util.check_bounds(val, (0, 5000))
-                            case "KNEE":
-                                val = util.check_bounds(val, (0, 1))
+                        val = CompSlider.check_bounds(param, val)
 
                         setattr(self.window.vm.strip[index].comp, param.lower(), val)
-                        popup[f"COMPRESSOR||SLIDER {param}"].update(value=val)
+                        self.popup[f"COMPRESSOR||SLIDER {param}"].update(value=val)
                         if param == "KNEE":
                             self.window.nvda.speak(str(round(val, 2)))
                         else:
@@ -277,20 +392,10 @@ class Popup:
                                 else:
                                     val -= 3
 
-                        match param:
-                            case "RATIO":
-                                val = util.check_bounds(val, (1, 8))
-                            case "THRESHOLD":
-                                val = util.check_bounds(val, (-40, -3))
-                            case "ATTACK":
-                                val = util.check_bounds(val, (0, 200))
-                            case "RELEASE":
-                                val = util.check_bounds(val, (0, 5000))
-                            case "KNEE":
-                                val = util.check_bounds(val, (0, 1))
+                        val = CompSlider.check_bounds(param, val)
 
                         setattr(self.window.vm.strip[index].comp, param.lower(), val)
-                        popup[f"COMPRESSOR||SLIDER {param}"].update(value=val)
+                        self.popup[f"COMPRESSOR||SLIDER {param}"].update(value=val)
                         if param == "KNEE":
                             self.window.nvda.speak(str(round(val, 2)))
                         else:
@@ -318,20 +423,10 @@ class Popup:
                                 else:
                                     val -= 0.1
 
-                        match param:
-                            case "RATIO":
-                                val = util.check_bounds(val, (1, 8))
-                            case "THRESHOLD":
-                                val = util.check_bounds(val, (-40, -3))
-                            case "ATTACK":
-                                val = util.check_bounds(val, (0, 200))
-                            case "RELEASE":
-                                val = util.check_bounds(val, (0, 5000))
-                            case "KNEE":
-                                val = util.check_bounds(val, (0, 1))
+                        val = CompSlider.check_bounds(param, val)
 
                         setattr(self.window.vm.strip[index].comp, param.lower(), val)
-                        popup[f"COMPRESSOR||SLIDER {param}"].update(value=val)
+                        self.popup[f"COMPRESSOR||SLIDER {param}"].update(value=val)
                         if param == "KNEE":
                             self.window.nvda.speak(str(round(val, 2)))
                         else:
@@ -355,7 +450,7 @@ class Popup:
 
                         val = util.check_bounds(val, (0, 5000))
                         self.window.vm.strip[index].comp.release = val
-                        popup[f"COMPRESSOR||SLIDER {param}"].update(value=val)
+                        self.popup[f"COMPRESSOR||SLIDER {param}"].update(value=val)
                         self.window.nvda.speak(str(round(val, 1)))
                     else:
                         self.window.vm.event.pdirty = True
@@ -376,7 +471,7 @@ class Popup:
 
                         val = util.check_bounds(val, (0, 5000))
                         self.window.vm.strip[index].comp.release = val
-                        popup[f"COMPRESSOR||SLIDER {param}"].update(value=val)
+                        self.popup[f"COMPRESSOR||SLIDER {param}"].update(value=val)
                         self.window.nvda.speak(str(round(val, 1)))
                     else:
                         self.window.vm.event.pdirty = True
@@ -412,7 +507,7 @@ class Popup:
                             self.window.vm.strip[index].comp.gainin = val
                         else:
                             self.window.vm.strip[index].comp.gainout = val
-                        popup[f"COMPRESSOR||SLIDER {direction} GAIN"].update(value=val)
+                        self.popup[f"COMPRESSOR||SLIDER {direction} GAIN"].update(value=val)
                         self.window.nvda.speak(str(round(val, 1)))
                     else:
                         self.window.vm.event.pdirty = True
@@ -439,7 +534,7 @@ class Popup:
                             self.window.vm.strip[index].comp.gainin = val
                         else:
                             self.window.vm.strip[index].comp.gainout = val
-                        popup[f"COMPRESSOR||SLIDER {direction} GAIN"].update(value=val)
+                        self.popup[f"COMPRESSOR||SLIDER {direction} GAIN"].update(value=val)
                         self.window.nvda.speak(str(round(val, 1)))
                     else:
                         self.window.vm.event.pdirty = True
@@ -466,21 +561,262 @@ class Popup:
                             self.window.vm.strip[index].comp.gainin = val
                         else:
                             self.window.vm.strip[index].comp.gainout = val
-                        popup[f"COMPRESSOR||SLIDER {direction} GAIN"].update(value=val)
+                        self.popup[f"COMPRESSOR||SLIDER {direction} GAIN"].update(value=val)
                         self.window.nvda.speak(str(round(val, 1)))
                     else:
                         self.window.vm.event.pdirty = True
 
+                case [
+                    ["COMPRESSOR"],
+                    ["SLIDER", "INPUT" | "OUTPUT" as direction, "GAIN"],
+                    ["KEY", "CTRL", "SHIFT", "R"],
+                ]:
+                    if direction == "INPUT":
+                        self.window.vm.strip[index].comp.gainin = 0
+                    else:
+                        self.window.vm.strip[index].comp.gainout = 0
+                    self.popup[f"COMPRESSOR||SLIDER {direction} GAIN"].update(value=0)
+                    self.window.nvda.speak(str(0))
+                case [["COMPRESSOR"], ["SLIDER", param], ["KEY", "CTRL", "SHIFT", "R"]]:
+                    match param:
+                        case "RATIO":
+                            val = 1
+                        case "THRESHOLD":
+                            val = -20
+                        case "ATTACK":
+                            val = 10
+                        case "RELEASE":
+                            val = 50
+                        case "KNEE":
+                            val = 0.5
+                    setattr(self.window.vm.strip[index].comp, param.lower(), val)
+                    self.popup[f"COMPRESSOR||SLIDER {param}"].update(value=val)
+                    self.window.nvda.speak(str(round(val, 1)))
+
                 case ["MAKEUP"]:
                     val = not self.window.vm.strip[index].comp.makeup
                     self.window.vm.strip[index].comp.makeup = val
                     self.window.nvda.speak("on" if val else "off")
                 case [[button], ["FOCUS", "IN"]]:
                     if button == "MAKEUP":
-                        self.window.nvda.speak(f"{button} {'on' if self.window.vm.strip[index].comp.makeup else 'off'}")
+                        self.window.nvda.speak(
+                            f"{button} {'on' if self.window.vm.strip[index].comp.makeup else 'off'}"
+                        )
                     else:
                         self.window.nvda.speak(button)
                 case [_, ["KEY", "ENTER"]]:
-                    popup.find_element_with_focus().click()
+                    self.popup.find_element_with_focus().click()
             self.logger.debug(f"parsed::{parsed_cmd}")
-        popup.close()
+        self.window.vm.observer.remove(self.on_pdirty)
+        self.popup.close()
+
+    def gate(self, index, title=None):
+        self.index = index
+
+        def _make_gate_frame() -> psg.Frame:
+            gate_layout = [
+                [LabelSliderAdvanced(self.window, index, param, GateSlider)]
+                for param in ("THRESHOLD", "DAMPING", "BPSIDECHAIN", "ATTACK", "HOLD", "RELEASE")
+            ]
+            return psg.Frame("ADVANCED GATE", gate_layout)
+
+        layout = []
+        steps = (_make_gate_frame,)
+        for step in steps:
+            layout.append([step()])
+        layout.append([psg.Button("Exit", size=(8, 1))])
+
+        self.popup = psg.Window(title, layout, return_keyboard_events=False, finalize=True)
+        buttonmenu_opts = {"takefocus": 1, "highlightthickness": 1}
+        for param in ("THRESHOLD", "DAMPING", "BPSIDECHAIN", "ATTACK", "HOLD", "RELEASE"):
+            self.popup[f"GATE||SLIDER {param}"].Widget.config(**buttonmenu_opts)
+            self.popup[f"GATE||SLIDER {param}"].bind("<FocusIn>", "||FOCUS IN")
+            self.popup[f"GATE||SLIDER {param}"].bind("<FocusOut>", "||FOCUS OUT")
+            for event in ("KeyPress", "KeyRelease"):
+                event_id = event.removeprefix("Key").upper()
+                for direction in ("Left", "Right", "Up", "Down"):
+                    self.popup[f"GATE||SLIDER {param}"].bind(
+                        f"<{event}-{direction}>", f"||KEY {direction.upper()} {event_id}"
+                    )
+                    self.popup[f"GATE||SLIDER {param}"].bind(
+                        f"<Shift-{event}-{direction}>", f"||KEY SHIFT {direction.upper()} {event_id}"
+                    )
+                    self.popup[f"GATE||SLIDER {param}"].bind(
+                        f"<Control-{event}-{direction}>", f"||KEY CTRL {direction.upper()} {event_id}"
+                    )
+                    if param in ("BPSIDECHAIN", "ATTACK", "HOLD", "RELEASE"):
+                        self.popup[f"GATE||SLIDER {param}"].bind(
+                            f"<Alt-{event}-{direction}>", f"||KEY ALT {direction.upper()} {event_id}"
+                        )
+                        self.popup[f"GATE||SLIDER {param}"].bind(
+                            f"<Control-Alt-{event}-{direction}>", f"||KEY CTRL ALT {direction.upper()} {event_id}"
+                        )
+            self.popup[f"GATE||SLIDER {param}"].bind("<Control-Shift-KeyPress-R>", "||KEY CTRL SHIFT R")
+        self.popup["Exit"].bind("<FocusIn>", "||FOCUS IN")
+        self.popup["Exit"].bind("<Return>", "||KEY ENTER")
+        self.window.vm.observer.add(self.on_pdirty)
+        while True:
+            event, values = self.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 [["GATE"], ["SLIDER", param]]:
+                    setattr(self.window.vm.strip[index].gate, param.lower(), values[event])
+                case [["GATE"], ["SLIDER", param], ["FOCUS", "IN"]]:
+                    label_map = {
+                        "DAMPING": "Damping Max",
+                        "BPSIDECHAIN": "BP Sidechain",
+                    }
+                    self.window.nvda.speak(f"{label_map.get(param, param)} {values[f'GATE||SLIDER {param}']}")
+
+                case [
+                    ["GATE"],
+                    ["SLIDER", param],
+                    ["KEY", "LEFT" | "RIGHT" | "UP" | "DOWN" as input_direction, "PRESS" | "RELEASE" as e],
+                ]:
+                    if e == "PRESS":
+                        self.window.vm.event.pdirty = False
+                        val = getattr(self.window.vm.strip[index].gate, param.lower())
+
+                        match input_direction:
+                            case "RIGHT" | "UP":
+                                val += 1
+                            case "LEFT" | "DOWN":
+                                val -= 1
+
+                        val = GateSlider.check_bounds(param, val)
+
+                        setattr(self.window.vm.strip[index].gate, param.lower(), val)
+                        self.popup[f"GATE||SLIDER {param}"].update(value=val)
+                        if param == "BPSIDECHAIN":
+                            self.window.nvda.speak(str(int(val)))
+                        else:
+                            self.window.nvda.speak(str(round(val, 1)))
+                    else:
+                        self.window.vm.event.pdirty = True
+                case [
+                    ["GATE"],
+                    ["SLIDER", param],
+                    ["KEY", "CTRL", "LEFT" | "RIGHT" | "UP" | "DOWN" as input_direction, "PRESS" | "RELEASE" as e],
+                ]:
+                    if e == "PRESS":
+                        self.window.vm.event.pdirty = False
+                        val = getattr(self.window.vm.strip[index].gate, param.lower())
+
+                        match input_direction:
+                            case "RIGHT" | "UP":
+                                val += 3
+                            case "LEFT" | "DOWN":
+                                val -= 3
+
+                        val = GateSlider.check_bounds(param, val)
+
+                        setattr(self.window.vm.strip[index].gate, param.lower(), val)
+                        self.popup[f"GATE||SLIDER {param}"].update(value=val)
+                        if param == "BPSIDECHAIN":
+                            self.window.nvda.speak(str(int(val)))
+                        else:
+                            self.window.nvda.speak(str(round(val, 1)))
+                    else:
+                        self.window.vm.event.pdirty = True
+                case [
+                    ["GATE"],
+                    ["SLIDER", param],
+                    ["KEY", "SHIFT", "LEFT" | "RIGHT" | "UP" | "DOWN" as input_direction, "PRESS" | "RELEASE" as e],
+                ]:
+                    if e == "PRESS":
+                        self.window.vm.event.pdirty = False
+                        val = getattr(self.window.vm.strip[index].gate, param.lower())
+
+                        match input_direction:
+                            case "RIGHT" | "UP":
+                                val += 0.1
+                            case "LEFT" | "DOWN":
+                                val -= 0.1
+
+                        val = GateSlider.check_bounds(param, val)
+
+                        setattr(self.window.vm.strip[index].gate, param.lower(), val)
+                        self.popup[f"GATE||SLIDER {param}"].update(value=val)
+                        if param == "BPSIDECHAIN":
+                            self.window.nvda.speak(str(int(val)))
+                        else:
+                            self.window.nvda.speak(str(round(val, 1)))
+                    else:
+                        self.window.vm.event.pdirty = True
+                case [
+                    ["GATE"],
+                    ["SLIDER", "BPSIDECHAIN" | "ATTACK" | "HOLD" | "RELEASE" as param],
+                    ["KEY", "ALT", "LEFT" | "RIGHT" as input_direction, "PRESS" | "RELEASE" as e],
+                ]:
+                    if e == "PRESS":
+                        self.window.vm.event.pdirty = False
+                        val = getattr(self.window.vm.strip[index].gate, param.lower())
+
+                        match input_direction:
+                            case "RIGHT" | "UP":
+                                val += 10
+                            case "LEFT" | "DOWN":
+                                val -= 10
+
+                        val = GateSlider.check_bounds(param, val)
+                        setattr(self.window.vm.strip[index].gate, param.lower(), val)
+                        self.popup[f"GATE||SLIDER {param}"].update(value=val)
+                        if param == "BPSIDECHAIN":
+                            self.window.nvda.speak(str(int(val)))
+                        else:
+                            self.window.nvda.speak(str(round(val, 1)))
+                    else:
+                        self.window.vm.event.pdirty = True
+                case [
+                    ["GATE"],
+                    ["SLIDER", "BPSIDECHAIN" | "ATTACK" | "HOLD" | "RELEASE" as param],
+                    ["KEY", "CTRL", "ALT", "LEFT" | "RIGHT" as input_direction, "PRESS" | "RELEASE" as e],
+                ]:
+                    if e == "PRESS":
+                        self.window.vm.event.pdirty = False
+                        val = getattr(self.window.vm.strip[index].gate, param.lower())
+
+                        match input_direction:
+                            case "RIGHT" | "UP":
+                                val += 50
+                            case "LEFT" | "DOWN":
+                                val -= 50
+
+                        val = GateSlider.check_bounds(param, val)
+                        setattr(self.window.vm.strip[index].gate, param.lower(), val)
+                        self.popup[f"GATE||SLIDER {param}"].update(value=val)
+                        if param == "BPSIDECHAIN":
+                            self.window.nvda.speak(str(int(val)))
+                        else:
+                            self.window.nvda.speak(str(round(val, 1)))
+                    else:
+                        self.window.vm.event.pdirty = True
+                case [["GATE"], ["SLIDER", param], ["KEY", "CTRL", "SHIFT", "R"]]:
+                    match param:
+                        case "THRESHOLD":
+                            val = -60
+                        case "DAMPING":
+                            val = -60
+                        case "BPSIDECHAIN":
+                            val = 100
+                        case "ATTACK":
+                            val = 0
+                        case "HOLD":
+                            val = 500
+                        case "RELEASE":
+                            val = 1000
+                    setattr(self.window.vm.strip[index].gate, param.lower(), val)
+                    self.popup[f"GATE||SLIDER {param}"].update(value=val)
+                    self.window.nvda.speak(str(round(val, 1)))
+
+                case [[button], ["FOCUS", "IN"]]:
+                    self.window.nvda.speak(button)
+                case [_, ["KEY", "ENTER"]]:
+                    self.popup.find_element_with_focus().click()
+
+            self.logger.debug(f"parsed::{parsed_cmd}")
+        self.window.vm.observer.remove(self.on_pdirty)
+        self.popup.close()

src/nvda_voicemeeter/util.py

@@ -1,7 +1,7 @@
 from typing import Iterable
 
 
-def get_asio_checkbox_index(channel, num) -> int:
+def get_asio_input_spinbox_index(channel, num) -> int:
     if channel == 0:
         return 2 * num - 2
     return 2 * num - 1
@@ -48,8 +48,11 @@ def get_patch_composite_list(kind) -> list:
     for i in range(kind.phys_out):
         [temp.append(f"IN#{i + 1} {channel}") for channel in ("Left", "Right")]
     for i in range(kind.phys_out, kind.phys_out + kind.virt_out):
-        [temp.append(f"IN#{i + 1} {channel}") for channel in ("Left", "Right", "Center", "LFE", "SL", "SR", "BL", "BR")]
-    temp.append(f"BUS Channel")
+        [
+            temp.append(f"IN#{i + 1} {channel}")
+            for channel in ("Left", "Right", "Center", "LFE", "SL", "SR", "BL", "BR")
+        ]
+    temp.append("BUS Channel")
     return temp
 
 
@@ -108,6 +111,24 @@ def get_channel_identifier_list(vm) -> list:
     return identifiers
 
 
+_bus_mode_map = {
+    "normal": "Normal",
+    "amix": "Mix Down A",
+    "bmix": "Mix Down B",
+    "repeat": "Stereo Repeat",
+    "composite": "Composite",
+    "tvmix": "Up Mix TV",
+    "upmix21": "Up Mix 2.1",
+    "upmix41": "Up Mix 4.1",
+    "upmix61": "Up Mix 6.1",
+    "centeronly": "Center Only",
+    "lfeonly": "Low Frequency Effect Only",
+    "rearonly": "Rear Only",
+}
+
+_bus_mode_map_reversed = dict((reversed(item) for item in _bus_mode_map.items()))
+
+
 def get_bus_modes(vm) -> list:
     if vm.kind.name == "basic":
         return [
@@ -157,3 +178,21 @@ def get_full_slider_params(i, kind) -> Iterable:
     if kind.name == "basic":
         params.remove("LIMIT")
     return params
+
+
+def get_slider_modes() -> Iterable:
+    return (
+        "GAIN MODE",
+        "BASS MODE",
+        "MID MODE",
+        "TREBLE MODE",
+        "AUDIBILITY MODE",
+        "COMP MODE",
+        "GATE MODE",
+        "DENOISER MODE",
+        "LIMIT MODE",
+    )
+
+
+def _get_bus_assignments(kind) -> list:
+    return [f"A{i}" for i in range(1, kind.phys_out + 1)] + [f"B{i}" for i in range(1, kind.virt_out + 1)]

src/nvda_voicemeeter/window.py

@@ -45,9 +45,9 @@ class NVDAVMWindow(psg.Window):
         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)
+            self["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[f"PATCH COMPOSITE||PC{i + 1}"].Widget.config(**buttonmenu_opts) for i in range(self.kind.composite)]
         slider_opts = {"takefocus": 1, "highlightthickness": 1}
         for i in range(self.kind.num_strip):
             for param in util.get_slider_params(i, self.kind):
@@ -57,10 +57,7 @@ class NVDAVMWindow(psg.Window):
                 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)
-        if self.kind.name != "basic":
-            for i in range(self.kind.phys_out):
-                self[f"ASIO CHECKBOX||IN{i + 1} 0"].Widget.config(state="readonly")
-                self[f"ASIO CHECKBOX||IN{i + 1} 1"].Widget.config(state="readonly")
+            self[f"BUS {i}||MODE"].Widget.config(**buttonmenu_opts)
 
         self.register_events()
         self["tabgroup"].set_focus()
@@ -123,10 +120,6 @@ class NVDAVMWindow(psg.Window):
         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 = 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 = util.get_channel_identifier_list(self.vm)[int(i)]
@@ -179,30 +172,24 @@ class NVDAVMWindow(psg.Window):
                 self.bind(f"<Alt-Control-{event}-{direction}>", f"ALT CTRL {direction.upper()}||{event_id}")
 
         # Hardware In
-        for i in range(self.vm.kind.phys_in):
+        for i in range(self.kind.phys_in):
             self[f"HARDWARE IN||{i + 1}"].bind("<FocusIn>", "||FOCUS IN")
             self[f"HARDWARE IN||{i + 1}"].bind("<space>", "||KEY SPACE", propagate=False)
             self[f"HARDWARE IN||{i + 1}"].bind("<Return>", "||KEY ENTER", propagate=False)
 
         # Hardware Out
-        for i in range(self.vm.kind.phys_out):
+        for i in range(self.kind.phys_out):
             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":
-            for i in range(self.kind.phys_out):
-                self[f"ASIO CHECKBOX||IN{i + 1} 0"].bind("<FocusIn>", "||FOCUS IN")
-                self[f"ASIO CHECKBOX||IN{i + 1} 1"].bind("<FocusIn>", "||FOCUS IN")
+        if self.kind.name == "basic":
+            self["HARDWARE OUT||A2"].bind("<FocusIn>", "||FOCUS IN")
+            self["HARDWARE OUT||A2"].bind("<space>", "||KEY SPACE", propagate=False)
+            self["HARDWARE OUT||A2"].bind("<Return>", "||KEY ENTER", propagate=False)
 
         # Patch Composite
         if self.kind.name != "basic":
-            for i in range(self.vm.kind.phys_out):
+            for i in range(self.kind.composite):
                 self[f"PATCH COMPOSITE||PC{i + 1}"].bind("<FocusIn>", "||FOCUS IN")
                 self[f"PATCH COMPOSITE||PC{i + 1}"].bind("<space>", "||KEY SPACE", propagate=False)
                 self[f"PATCH COMPOSITE||PC{i + 1}"].bind("<Return>", "||KEY ENTER", propagate=False)
@@ -236,7 +223,12 @@ class NVDAVMWindow(psg.Window):
                     self[f"STRIP {i}||{param}"].bind("<FocusIn>", "||FOCUS IN")
                     self[f"STRIP {i}||{param}"].bind("<Return>", "||KEY ENTER")
             else:
-                for param in ("MONO", "SOLO", "MUTE"):
+                if i == self.kind.phys_in + 1:
+                    for param in ("KARAOKE", "SOLO", "MUTE"):
+                        self[f"STRIP {i}||{param}"].bind("<FocusIn>", "||FOCUS IN")
+                        self[f"STRIP {i}||{param}"].bind("<Return>", "||KEY ENTER")
+                else:
+                    for param in ("MC", "SOLO", "MUTE"):
                         self[f"STRIP {i}||{param}"].bind("<FocusIn>", "||FOCUS IN")
                         self[f"STRIP {i}||{param}"].bind("<Return>", "||KEY ENTER")
 
@@ -260,13 +252,16 @@ class NVDAVMWindow(psg.Window):
                 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 = ["MONO", "EQ", "MUTE"]
+        if self.kind.name == "basic":
             params.remove("EQ")
         for i in range(self.kind.num_bus):
             for param in params:
                 self[f"BUS {i}||{param}"].bind("<FocusIn>", "||FOCUS IN")
                 self[f"BUS {i}||{param}"].bind("<Return>", "||KEY ENTER")
+            self[f"BUS {i}||MODE"].bind("<FocusIn>", "||FOCUS IN")
+            self[f"BUS {i}||MODE"].bind("<space>", "||KEY SPACE", propagate=False)
+            self[f"BUS {i}||MODE"].bind("<Return>", "||KEY ENTER", propagate=False)
 
         # Bus Sliders
         for i in range(self.kind.num_bus):
@@ -300,13 +295,15 @@ class NVDAVMWindow(psg.Window):
             self.logger.debug(f"values::{values}")
             if event in (psg.WIN_CLOSED, "Exit"):
                 break
-            elif event.endswith("MODE"):
+            elif event in util.get_slider_modes():
                 mode = event
                 self.nvda.speak(f"{mode} enabled")
+                self.logger.debug(f"entered slider mode {mode}")
                 continue
             elif event == "ESCAPE":
                 if mode:
                     self.nvda.speak(f"{mode} disabled")
+                    self.logger.debug(f"exited from slider mode {mode}")
                     mode = None
                 continue
 
@@ -423,7 +420,7 @@ class NVDAVMWindow(psg.Window):
                             identifier, partial = focus.Key.split("||")
                             _, index = identifier.split()
                             index = int(index)
-                            data = self.popup.rename("Label", index, title=f"Rename", tab=tab)
+                            data = self.popup.rename("Label", index, title="Rename", tab=tab)
                             if not data:  # cancel was pressed
                                 continue
                             match tab:
@@ -456,8 +453,12 @@ class NVDAVMWindow(psg.Window):
                                 if focus := self.find_element_with_focus():
                                     identifier, partial = focus.key.split("||")
                                     _, index = identifier.split()
+                                    match self.kind.name:
+                                        case "potato":
                                             if "SLIDER COMP" in partial:
                                                 self.popup.compressor(int(index), title="Advanced Compressor")
+                                            elif "SLIDER GATE" in partial:
+                                                self.popup.gate(int(index), title="Advanced Gate")
 
                 # Menus
                 case [["Restart", "Audio", "Engine"], ["MENU"]]:
@@ -576,33 +577,25 @@ class NVDAVMWindow(psg.Window):
                 case [["HARDWARE", "OUT"], [key], ["KEY", "SPACE" | "ENTER"]]:
                     util.open_context_menu_for_buttonmenu(self, f"HARDWARE OUT||{key}")
 
-                # Patch ASIO
-                case [["ASIO", "CHECKBOX"], [in_num, channel]]:
-                    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(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}"]
-                        channel = ("left", "right")[int(channel)]
-                        num = int(in_num[-1])
-                        self.nvda.speak(f"Patch ASIO inputs to strips IN#{num} {channel} {val}")
-
                 # Patch COMPOSITE
                 case [["PATCH", "COMPOSITE"], [key]]:
                     val = values[f"PATCH COMPOSITE||{key}"]
                     index = int(key[-1]) - 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}")
+                    self.TKroot.after(200, self.nvda.speak, 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 = util.get_patch_composite_list(self.kind)[self.vm.patch.composite[index].get() - 1]
+                            comp_index = self.vm.patch.composite[index].get()
+                            comp_list = util.get_patch_composite_list(self.kind)
+                            try:
+                                val = comp_list[comp_index - 1]
+                            except IndexError as e:
+                                val = comp_list[-1]
+                                self.logger.error(f"{type(e).__name__}: {e}")
                         self.nvda.speak(f"Patch COMPOSITE {key[-1]} {val}")
                 case [["PATCH", "COMPOSITE"], [key], ["KEY", "SPACE" | "ENTER"]]:
                     util.open_context_menu_for_buttonmenu(self, f"PATCH COMPOSITE||{key}")
@@ -643,54 +636,36 @@ class NVDAVMWindow(psg.Window):
 
                 # Strip Params
                 case [["STRIP", index], [param]]:
-                    label = self.cache["labels"][f"STRIP {index}||LABEL"]
                     match param:
-                        case "MONO":
-                            if int(index) < self.kind.phys_in:
-                                actual = param.lower()
-                            elif int(index) == self.kind.phys_in + 1:
-                                actual = "k"
-                            else:
-                                actual = "mc"
-                            phonetic = {"k": "karaoke"}
-                            if actual == "k":
+                        case "KARAOKE":
+                            opts = ["off", "k m", "k 1", "k 2", "k v"]
                             next_val = self.vm.strip[int(index)].k + 1
-                                if next_val == 4:
+                            if next_val == len(opts):
                                 next_val = 0
-                                setattr(self.vm.strip[int(index)], actual, next_val)
+                            self.vm.strip[int(index)].k = next_val
                             self.cache["strip"][f"STRIP {index}||{param}"] = 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(opts[next_val])
+                        case output if param in util._get_bus_assignments(self.kind):
+                            val = not self.cache["strip"][f"STRIP {index}||{output}"]
+                            setattr(self.vm.strip[int(index)], output, val)
+                            self.cache["strip"][f"STRIP {index}||{output}"] = val
                             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)
+                            setattr(self.vm.strip[int(index)], param.lower(), val)
                             self.cache["strip"][f"STRIP {index}||{param}"] = val
                             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}"]
-                        match param:
-                            case "MONO":
-                                if int(index) < self.kind.phys_in:
-                                    actual = param.lower()
-                                elif int(index) == self.kind.phys_in + 1:
-                                    actual = "k"
-                                else:
-                                    actual = "mc"
-                            case _:
-                                actual = param
-                        phonetic = {"k": "karaoke"}
+                        phonetic = {"KARAOKE": "karaoke"}
                         label = self.cache["labels"][f"STRIP {index}||LABEL"]
-                        if actual == "k":
+                        if param == "KARAOKE":
                             self.nvda.speak(
-                                f"{label} {phonetic.get(actual, actual)} {['off', 'k m', 'k 1', 'k 2'][self.cache['strip'][f'STRIP {int(index)}||{param}']]}"
+                                f"{label} {phonetic.get(param, param)} {['off', 'k m', 'k 1', 'k 2', 'k v'][self.cache['strip'][f'STRIP {int(index)}||{param}']]}"
                             )
                         else:
-                            self.nvda.speak(f"{label} {phonetic.get(actual, actual)} {'on' if val else 'off'}")
+                            self.nvda.speak(f"{label} {phonetic.get(param, param)} {'on' if val else 'off'}")
                 case [["STRIP", index], [param], ["KEY", "ENTER"]]:
                     self.find_element_with_focus().click()
 
@@ -960,6 +935,7 @@ class NVDAVMWindow(psg.Window):
                             self.vm.strip[int(index)].gain = 0
                             self[f"STRIP {index}||SLIDER {param}"].update(value=0)
                         case "COMP" | "GATE" | "DENOISER":
+                            target = getattr(self.vm.strip[int(index)], param.lower())
                             setattr(target, "knob", 0)
                             self[f"STRIP {index}||SLIDER {param}"].update(value=0)
                         case "AUDIBILITY":
@@ -971,7 +947,7 @@ class NVDAVMWindow(psg.Window):
                         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}")
+                    self.nvda.speak(f"{12 if param == 'LIMIT' else 0}")
 
                 # Bus Params
                 case [["BUS", index], [param]]:
@@ -997,39 +973,26 @@ class NVDAVMWindow(psg.Window):
                                 "on" if val else "off",
                             )
                         case "MODE":
-                            bus_modes = util.get_bus_modes(self.vm)
-                            next_index = bus_modes.index(val) + 1
-                            if next_index == len(bus_modes):
-                                next_index = 0
-                            next_bus = bus_modes[next_index]
-                            phonetic = {
-                                "amix": "Mix Down A",
-                                "bmix": "Mix Down B",
-                                "repeat": "Stereo Repeat",
-                                "tvmix": "Up Mix TV",
-                                "upmix21": "Up Mix 2.1",
-                                "upmix41": "Up Mix 4.1",
-                                "upmix61": "Up Mix 6.1",
-                                "centeronly": "Center Only",
-                                "lfeonly": "Low Frequency Effect Only",
-                                "rearonly": "Rear Only",
-                            }
-                            setattr(self.vm.bus[int(index)].mode, next_bus, True)
-                            self.cache["bus"][event] = next_bus
+                            chosen = util._bus_mode_map_reversed[values[event]]
+                            setattr(self.vm.bus[int(index)].mode, chosen, True)
+                            self.cache["bus"][event] = chosen
                             self.TKroot.after(
                                 200,
                                 self.nvda.speak,
-                                phonetic.get(next_bus, next_bus),
+                                util._bus_mode_map[chosen],
                             )
                 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":
-                            self.nvda.speak(f"{label} bus {param} {val}")
+                            self.nvda.speak(f"{label} bus {param} {util._bus_mode_map[val]}")
+                        else:
+                            self.nvda.speak(f"{label} {param} {'on' if val else 'off'}")
+                case [["BUS", index], [param], ["KEY", "SPACE" | "ENTER"]]:
+                    if param == "MODE":
+                        util.open_context_menu_for_buttonmenu(self, f"BUS {index}||MODE")
                     else:
-                            self.nvda.speak(f"{label} bus {param} {'on' if val else 'off'}")
-                case [["BUS", index], [param], ["KEY", "ENTER"]]:
                         self.find_element_with_focus().click()
 
                 # Bus Sliders
@@ -1104,7 +1067,7 @@ class NVDAVMWindow(psg.Window):
                 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))
+                    self.nvda.speak(str(0))
 
                 # Unknown
                 case _: