minor bump

closes #19
High Contrast theme added.
2026-04-07 09:53:35 +00:00 · 2023-11-19 22:45:57 +00:00 · 2023-11-19 01:22:40 +00:00 · 2023-11-16 15:43:39 +00:00 · 2023-11-15 23:34:53 +00:00 · 2023-10-29 19:26:03 +00:00
15 changed files with 1655 additions and 510 deletions
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -1,5 +0,0 @@
-{
-    "black-formatter.args": [
-        "--line-length=120"
-    ]
-}
--- a/README.md
+++ b/README.md
@@ -1,6 +1,7 @@
 [![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/)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)

 # NVDA Voicemeeter

@@ -106,15 +107,35 @@ 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.

-#### `Menu`
+#### `Advanced Compressor|Gate`

-A single menu item `Voicemeeter` can be opened using `Alt` and then `v`. The menu allows you to:
+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
+
+#### `Voicemeeter`
+
+The `Voicemeeter` menu can be opened using `Alt` and then `v`. It offers the following options:

 - Restart Voicemeeter audio engine
 - Save/Load current settings (as an xml file)
@@ -124,7 +145,11 @@ The `Save Settings` option opens a popup window with two buttons, `Browse` and `

 `Load Settings` and `Load on Startup` both open an Open dialog box immediately.

-### `Quick access binds`
+#### `Themes`
+
+The `Themes` menu can be opened using `Alt` and then `t`. Use this menu to select from a list of coloured themes. Some themes offer higher contrast colours. An application restart is required to load a new theme. Once a theme is selected it will become the default for future startups.
+
+### Quick access binds

 There are a number of quick binds available to assist with faster navigation and general use.

@@ -143,6 +168,9 @@ You may also enter slider modes which allow for control of the channels sliders
 - `Control + G` will enter Gain mode
 - `Control + T` will enter Gate mode
 - `Control + L` will enter Limit mode
+- `Control + B` will enter Bass mode
+- `Control + I` will enter Mid mode
+- `Control + R` will enter Treble mode

 To exit any of the slider modes press `Escape`.

--- a/img/busmode_buttonmenu.png
+++ b/img/busmode_buttonmenu.png
--- a/img/nvda-voicemeeter.png
+++ b/img/nvda-voicemeeter.png
--- a/img/settings.png
+++ b/img/settings.png
--- a/pdm.lock
+++ b/pdm.lock
@@ -3,10 +3,9 @@

 [metadata]
 groups = ["default", "build", "lint", "test"]
-cross_platform = true
-static_urls = false
-lock_version = "4.3"
-content_hash = "sha256:ba53368b628b713c9cf4eb54e6f5c5c4af207c8e247d473417e4c2a4b47f645d"
+strategy = ["cross_platform"]
+lock_version = "4.4"
+content_hash = "sha256:4295f6824f37484ec423b53bd425334b0e039a51d81261b52c8890928fcf3948"

 [[package]]
 name = "altgraph"
@@ -63,21 +62,6 @@ files = [
    {file = "colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44"},
 ]

-[[package]]
-name = "flake8"
-version = "6.1.0"
-requires_python = ">=3.8.1"
-summary = "the modular source code checker: pep8 pyflakes and co"
-dependencies = [
-    "mccabe<0.8.0,>=0.7.0",
-    "pycodestyle<2.12.0,>=2.11.0",
-    "pyflakes<3.2.0,>=3.1.0",
-]
-files = [
-    {file = "flake8-6.1.0-py2.py3-none-any.whl", hash = "sha256:ffdfce58ea94c6580c77888a86506937f9a1a227dfcd15f245d694ae20a6b6e5"},
-    {file = "flake8-6.1.0.tar.gz", hash = "sha256:d5b3857f07c030bdb5bf41c7f53799571d75c4491748a3adcd47de929e34cd23"},
-]
-
 [[package]]
 name = "macholib"
 version = "1.16.2"
@@ -91,13 +75,28 @@ files = [
 ]

 [[package]]
-name = "mccabe"
-version = "0.7.0"
-requires_python = ">=3.6"
-summary = "McCabe checker, plugin for flake8"
+name = "mypy"
+version = "1.7.0"
+requires_python = ">=3.8"
+summary = "Optional static typing for Python"
+dependencies = [
+    "mypy-extensions>=1.0.0",
+    "tomli>=1.1.0; python_version < \"3.11\"",
+    "typing-extensions>=4.1.0",
+]
 files = [
-    {file = "mccabe-0.7.0-py2.py3-none-any.whl", hash = "sha256:6c2d30ab6be0e4a46919781807b4f0d834ebdd6c6e3dca0bda5a15f863427b6e"},
-    {file = "mccabe-0.7.0.tar.gz", hash = "sha256:348e0240c33b60bbdf4e523192ef919f28cb2c3d7d5c7794f74009290f236325"},
+    {file = "mypy-1.7.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:5da84d7bf257fd8f66b4f759a904fd2c5a765f70d8b52dde62b521972a0a2357"},
+    {file = "mypy-1.7.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a3637c03f4025f6405737570d6cbfa4f1400eb3c649317634d273687a09ffc2f"},
+    {file = "mypy-1.7.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b633f188fc5ae1b6edca39dae566974d7ef4e9aaaae00bc36efe1f855e5173ac"},
+    {file = "mypy-1.7.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:d6ed9a3997b90c6f891138e3f83fb8f475c74db4ccaa942a1c7bf99e83a989a1"},
+    {file = "mypy-1.7.0-cp310-cp310-win_amd64.whl", hash = "sha256:1fe46e96ae319df21359c8db77e1aecac8e5949da4773c0274c0ef3d8d1268a9"},
+    {file = "mypy-1.7.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:df67fbeb666ee8828f675fee724cc2cbd2e4828cc3df56703e02fe6a421b7401"},
+    {file = "mypy-1.7.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:a79cdc12a02eb526d808a32a934c6fe6df07b05f3573d210e41808020aed8b5d"},
+    {file = "mypy-1.7.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f65f385a6f43211effe8c682e8ec3f55d79391f70a201575def73d08db68ead1"},
+    {file = "mypy-1.7.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:0e81ffd120ee24959b449b647c4b2fbfcf8acf3465e082b8d58fd6c4c2b27e46"},
+    {file = "mypy-1.7.0-cp311-cp311-win_amd64.whl", hash = "sha256:f29386804c3577c83d76520abf18cfcd7d68264c7e431c5907d250ab502658ee"},
+    {file = "mypy-1.7.0-py3-none-any.whl", hash = "sha256:96650d9a4c651bc2a4991cf46f100973f656d69edc7faf91844e87fe627f7e96"},
+    {file = "mypy-1.7.0.tar.gz", hash = "sha256:1e280b5697202efa698372d2f39e9a6713a0395a756b1c6bd48995f8d72690dc"},
 ]

 [[package]]
@@ -162,26 +161,6 @@ files = [
    {file = "psgdemos-1.12.1.tar.gz", hash = "sha256:4108af795477531a9b1c8675b9aa9b6628c109e660f6954baf8ba2dc3b5806e9"},
 ]

-[[package]]
-name = "pycodestyle"
-version = "2.11.0"
-requires_python = ">=3.8"
-summary = "Python style guide checker"
-files = [
-    {file = "pycodestyle-2.11.0-py2.py3-none-any.whl", hash = "sha256:5d1013ba8dc7895b548be5afb05740ca82454fd899971563d2ef625d090326f8"},
-    {file = "pycodestyle-2.11.0.tar.gz", hash = "sha256:259bcc17857d8a8b3b4a2327324b79e5f020a13c16074670f9c8c8f872ea76d0"},
-]
-
-[[package]]
-name = "pyflakes"
-version = "3.1.0"
-requires_python = ">=3.8"
-summary = "passive checker of Python programs"
-files = [
-    {file = "pyflakes-3.1.0-py2.py3-none-any.whl", hash = "sha256:4132f6d49cb4dae6819e5379898f2b8cce3c5f23994194c24b77d5da2e36f774"},
-    {file = "pyflakes-3.1.0.tar.gz", hash = "sha256:a0aae034c444db0071aa077972ba4768d40c830d9539fd45bf4cd3f8f6992efc"},
-]
-
 [[package]]
 name = "pyinstaller"
 version = "5.13.0"
@@ -249,6 +228,31 @@ files = [
    {file = "pywin32_ctypes-0.2.2-py3-none-any.whl", hash = "sha256:bf490a1a709baf35d688fe0ecf980ed4de11d2b3e37b51e5442587a75d9957e7"},
 ]

+[[package]]
+name = "ruff"
+version = "0.0.291"
+requires_python = ">=3.7"
+summary = "An extremely fast Python linter, written in Rust."
+files = [
+    {file = "ruff-0.0.291-py3-none-macosx_10_7_x86_64.whl", hash = "sha256:b97d0d7c136a85badbc7fd8397fdbb336e9409b01c07027622f28dcd7db366f2"},
+    {file = "ruff-0.0.291-py3-none-macosx_10_9_x86_64.macosx_11_0_arm64.macosx_10_9_universal2.whl", hash = "sha256:6ab44ea607967171e18aa5c80335237be12f3a1523375fa0cede83c5cf77feb4"},
+    {file = "ruff-0.0.291-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a04b384f2d36f00d5fb55313d52a7d66236531195ef08157a09c4728090f2ef0"},
+    {file = "ruff-0.0.291-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b727c219b43f903875b7503a76c86237a00d1a39579bb3e21ce027eec9534051"},
+    {file = "ruff-0.0.291-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:87671e33175ae949702774071b35ed4937da06f11851af75cd087e1b5a488ac4"},
+    {file = "ruff-0.0.291-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:b75f5801547f79b7541d72a211949754c21dc0705c70eddf7f21c88a64de8b97"},
+    {file = "ruff-0.0.291-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b09b94efdcd162fe32b472b2dd5bf1c969fcc15b8ff52f478b048f41d4590e09"},
+    {file = "ruff-0.0.291-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8d5b56bc3a2f83a7a1d7f4447c54d8d3db52021f726fdd55d549ca87bca5d747"},
+    {file = "ruff-0.0.291-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:13f0d88e5f367b2dc8c7d90a8afdcfff9dd7d174e324fd3ed8e0b5cb5dc9b7f6"},
+    {file = "ruff-0.0.291-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:b3eeee1b1a45a247758ecdc3ab26c307336d157aafc61edb98b825cadb153df3"},
+    {file = "ruff-0.0.291-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:6c06006350c3bb689765d71f810128c9cdf4a1121fd01afc655c87bab4fb4f83"},
+    {file = "ruff-0.0.291-py3-none-musllinux_1_2_i686.whl", hash = "sha256:fd17220611047de247b635596e3174f3d7f2becf63bd56301fc758778df9b629"},
+    {file = "ruff-0.0.291-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:5383ba67ad360caf6060d09012f1fb2ab8bd605ab766d10ca4427a28ab106e0b"},
+    {file = "ruff-0.0.291-py3-none-win32.whl", hash = "sha256:1d5f0616ae4cdc7a938b493b6a1a71c8a47d0300c0d65f6e41c281c2f7490ad3"},
+    {file = "ruff-0.0.291-py3-none-win_amd64.whl", hash = "sha256:8a69bfbde72db8ca1c43ee3570f59daad155196c3fbe357047cd9b77de65f15b"},
+    {file = "ruff-0.0.291-py3-none-win_arm64.whl", hash = "sha256:d867384a4615b7f30b223a849b52104214442b5ba79b473d7edd18da3cde22d6"},
+    {file = "ruff-0.0.291.tar.gz", hash = "sha256:c61109661dde9db73469d14a82b42a88c7164f731e6a3b0042e71394c1c7ceed"},
+]
+
 [[package]]
 name = "setuptools"
 version = "68.1.2"
@@ -269,15 +273,25 @@ files = [
    {file = "tomli-2.0.1.tar.gz", hash = "sha256:de526c12914f0c550d15924c62d72abc48d6fe7364aa87328337a31007fe8a4f"},
 ]

+[[package]]
+name = "typing-extensions"
+version = "4.8.0"
+requires_python = ">=3.8"
+summary = "Backported and Experimental Type Hints for Python 3.8+"
+files = [
+    {file = "typing_extensions-4.8.0-py3-none-any.whl", hash = "sha256:8f92fc8806f9a6b641eaa5318da32b44d401efaac0f6678c9bc448ba3605faa0"},
+    {file = "typing_extensions-4.8.0.tar.gz", hash = "sha256:df8e4339e9cb77357558cbdbceca33c303714cf861d1eef15e1070055ae8b7ef"},
+]
+
 [[package]]
 name = "voicemeeter-api"
-version = "2.4.9"
+version = "2.5.2"
 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.9-py3-none-any.whl", hash = "sha256:a09fd07fe3799cd5c880d491048da81d94e49aa97ec753aa1f9289acd27be965"},
-    {file = "voicemeeter_api-2.4.9.tar.gz", hash = "sha256:47ad614a8b9ccb0b4e47acf65666ce0f0537a0890fffda9949e995bea70e679c"},
+    {file = "voicemeeter_api-2.5.2-py3-none-any.whl", hash = "sha256:304c14a6eef5f95d8b883e8e1752d23f17c3d662d25a28d114d33134f62e93ec"},
+    {file = "voicemeeter_api-2.5.2.tar.gz", hash = "sha256:e2b9558a38ed290b184a3e46b598c0a716cef2e64521431f84a46e1180d539ca"},
 ]
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,6 +1,6 @@
 [project]
 name = "nvda_voicemeeter"
-version = "0.3.0b1"
+version = "0.6.0"
 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.9",
+    "voicemeeter-api>=2.5.2",
 ]
 requires-python = ">=3.10,<3.12"
 readme = "README.md"
@@ -22,7 +22,8 @@ build = [
 ]
 lint = [
    "black>=23.7.0",
-    "flake8>=6.1.0",
+    "ruff>=0.0.291",
+    "mypy>=1.7.0",
 ]
 test = [
    "psgdemos>=1.12.1",
@@ -30,3 +31,97 @@ test = [

 [tool.pdm.scripts.build]
 shell = "build.ps1"
+
+[tool.black]
+line-length = 119
+
+[tool.ruff]
+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 = [
+    ".bzr",
+    ".direnv",
+    ".eggs",
+    ".git",
+    ".git-rewrite",
+    ".hg",
+    ".mypy_cache",
+    ".nox",
+    ".pants.d",
+    ".pytype",
+    ".ruff_cache",
+    ".svn",
+    ".tox",
+    ".venv",
+    "__pypackages__",
+    "_build",
+    "buck-out",
+    "build",
+    "dist",
+    "node_modules",
+    "venv",
+]
+line-length = 119
+dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
+target-version = "py310"
+
+[tool.ruff.mccabe]
+max-complexity = 10
+
+[tool.ruff.per-file-ignores]
+"__init__.py" = [
+    "E402",
+    "F401",
+]
--- a/src/nvda_voicemeeter/builder.py
+++ b/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,
@@ -93,6 +92,8 @@ class Builder:
        return [[menu], [tab_group]]

    def make_menu(self) -> psg.Menu:
+        themes = [f"{theme}::MENU THEME" for theme in util.get_themes_list()]
+        themes.append("Default::MENU THEME")
        menu_def = [
            [
                "&Voicemeeter",
@@ -103,6 +104,7 @@ class Builder:
                    "Load Settings on Startup ::MENU",
                ],
            ],
+            ["&Theme", themes],
        ]
        return psg.Menu(menu_def, key="menus")

@@ -152,57 +154,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)
                ]
            )

@@ -220,7 +185,9 @@ class Builder:
                        [
                            psg.Checkbox(
                                text=channel,
-                                default=self.vm.patch.insert[util.get_insert_checkbox_index(self.kind, j, i)].on,
+                                default=self.window.cache["insert"][
+                                    f"INSERT CHECKBOX||{util.get_insert_checkbox_index(self.kind, j, i)}"
+                                ],
                                enable_events=True,
                                key=f"INSERT CHECKBOX||IN{i} {j}",
                            )
@@ -233,7 +200,9 @@ class Builder:
                    [
                        psg.Checkbox(
                            text=channel,
-                            default=self.vm.patch.insert[util.get_insert_checkbox_index(self.kind, j, i)].on,
+                            default=self.window.cache["insert"][
+                                f"INSERT CHECKBOX||{util.get_insert_checkbox_index(self.kind, j, i)}"
+                            ],
                            enable_events=True,
                            key=f"INSERT CHECKBOX||IN{i} {j}",
                        )
@@ -316,6 +285,7 @@ class Builder:
                        disable_number_display=True,
                        expand_x=True,
                        enable_events=True,
+                        disabled=True,
                        orientation="horizontal",
                        key=f"STRIP {i}||SLIDER GAIN",
                    ),
@@ -323,7 +293,7 @@ class Builder:
            )

        def add_param_sliders(layout):
-            layout.append([LabelSlider(self.window, i, param) for param in util.get_slider_params(i, self.vm)])
+            layout.append([LabelSlider(self.window, i, param) for param in util.get_slider_params(i, self.kind)])

        def add_limit_slider(layout):
            layout.append(
@@ -372,7 +342,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"),
                    ],
@@ -380,7 +350,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"),
                    ],
@@ -388,7 +358,11 @@ class Builder:

        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")
+        return psg.Frame(
+            self.window.cache["labels"][f"STRIP {i}||LABEL"],
+            outputs,
+            key=f"STRIP {i}||LABEL",
+        )

    def make_tab2_button_rows(self) -> psg.Frame:
        layout = [
@@ -408,6 +382,7 @@ class Builder:
                        disable_number_display=True,
                        expand_x=True,
                        enable_events=True,
+                        disabled=True,
                        orientation="horizontal",
                        key=f"STRIP {i}||SLIDER GAIN",
                    ),
@@ -416,13 +391,13 @@ class Builder:

        def add_param_sliders(layout):
            if self.kind.name in ("basic", "banana"):
-                for param in util.get_slider_params(i, self.vm):
+                for param in util.get_slider_params(i, self.kind):
                    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)
+                        for param in util.get_slider_params(i, self.kind)
                    ]
                )

@@ -448,7 +423,11 @@ class Builder:
        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")
+        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 = [
@@ -460,24 +439,36 @@ 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),
-                        key=f"BUS {i}||{param}",
-                    )
-                    for param in params
+                    *[
+                        psg.Button(
+                            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",
+                    ),
                ]
            )

        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")
+        return psg.Frame(
+            self.window.cache["labels"][f"BUS {i}||LABEL"],
+            outputs,
+            key=f"BUS {i}||LABEL",
+        )

    def make_tab3_button_rows(self) -> psg.Frame:
        layout = [[self.make_tab3_button_row(i)] for i in range(self.kind.num_bus)]
@@ -487,6 +478,7 @@ class Builder:
        def add_gain_slider(layout):
            layout.append(
                [
+                    psg.Text("Gain"),
                    psg.Slider(
                        range=(-60, 12),
                        default_value=self.vm.bus[i].gain,
@@ -494,9 +486,10 @@ class Builder:
                        disable_number_display=True,
                        expand_x=True,
                        enable_events=True,
+                        disabled=True,
                        orientation="horizontal",
                        key=f"BUS {i}||SLIDER GAIN",
-                    )
+                    ),
                ]
            )

--- a/src/nvda_voicemeeter/cdll.py
+++ b/src/nvda_voicemeeter/cdll.py
@@ -5,7 +5,7 @@ from pathlib import Path

 from .errors import NVDAVMError

-bits = 64 if ct.sizeof(ct.c_voidp) == 8 else 32
+bits = 64 if ct.sizeof(ct.c_void_p) == 8 else 32

 if platform.system() != "Windows":
    raise NVDAVMError("Only Windows OS supported")
@@ -33,7 +33,7 @@ def get_nvdapath():

 try:
    NVDA_PATH = Path(get_nvdapath()) / "nvda.exe"
-except FileNotFoundError as e:
+except FileNotFoundError:
    NVDA_PATH = ""


--- a/src/nvda_voicemeeter/compound.py
+++ b/src/nvda_voicemeeter/compound.py
@@ -1,15 +1,22 @@
+from typing import Union
+
 import PySimpleGUI as psg

+from . import util
+

 class LabelSlider(psg.Frame):
-    """Compound Label Slider element"""
+    """Compound Label Slider Strip 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 psg.theme() == "HighContrast":
+                size = 5
+            else:
+                size = 4
        layout = [
            [
                psg.Text(param.capitalize(), size=size),
@@ -33,3 +40,169 @@ class LabelSlider(psg.Frame):
        if param in ("COMP", "GATE", "DENOISER"):
            return target.knob
        return target
+
+
+class CompSlider(psg.Slider):
+    """Compressor Slider element"""
+
+    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"COMPRESSOR||SLIDER {param}",
+            **self.default_params(param),
+        )
+
+    def default_params(self, param):
+        match param:
+            case "INPUT GAIN":
+                return {
+                    "range": (-24, 24),
+                    "default_value": self.vm.strip[self.index].comp.gainin,
+                    "resolution": 0.1,
+                    "disabled": True,
+                }
+            case "RATIO":
+                return {
+                    "range": (1, 8),
+                    "default_value": self.vm.strip[self.index].comp.ratio,
+                    "resolution": 0.1,
+                }
+            case "THRESHOLD":
+                return {
+                    "range": (-40, -3),
+                    "default_value": self.vm.strip[self.index].comp.threshold,
+                    "resolution": 0.1,
+                }
+            case "ATTACK":
+                return {
+                    "range": (0, 200),
+                    "default_value": self.vm.strip[self.index].comp.attack,
+                    "resolution": 0.1,
+                }
+            case "RELEASE":
+                return {
+                    "range": (0, 5000),
+                    "default_value": self.vm.strip[self.index].comp.release,
+                    "resolution": 0.1,
+                }
+            case "KNEE":
+                return {
+                    "range": (0, 1),
+                    "default_value": self.vm.strip[self.index].comp.knee,
+                    "resolution": 0.01,
+                }
+            case "OUTPUT GAIN":
+                return {
+                    "range": (-24, 24),
+                    "default_value": self.vm.strip[self.index].comp.gainout,
+                    "resolution": 0.1,
+                    "disabled": True,
+                }
+
+    @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 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(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)
--- a/src/nvda_voicemeeter/configuration.py
+++ b/src/nvda_voicemeeter/configuration.py
@@ -0,0 +1,34 @@
+import json
+from pathlib import Path
+
+SETTINGS = Path.cwd() / "settings.json"
+
+
+def config_from_json():
+    data = {}
+    if not SETTINGS.exists():
+        return data
+    with open(SETTINGS, "r") as f:
+        data = json.load(f)
+    return data
+
+
+config = config_from_json()
+
+
+def get(key, default=None):
+    if key in config:
+        return config[key]
+    return default
+
+
+def set(key, value):
+    config[key] = value
+    with open(SETTINGS, "w") as f:
+        json.dump(config, f)
+
+
+def delete(key):
+    del config[key]
+    with open(SETTINGS, "w") as f:
+        json.dump(config, f)
--- a/src/nvda_voicemeeter/models.py
+++ b/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
--- a/src/nvda_voicemeeter/popup.py
+++ b/src/nvda_voicemeeter/popup.py
@@ -4,6 +4,7 @@ from pathlib import Path
 import PySimpleGUI as psg

 from . import util
+from .compound import CompSlider, GateSlider, LabelSliderAdvanced

 logger = logging.getLogger(__name__)

@@ -40,13 +41,37 @@ class Popup:
                        filepath = values["Browse"]
                        break
                    self.window.nvda.speak(button)
-                case [[button], ["KEY", "ENTER"]]:
+                case [_, ["KEY", "ENTER"]]:
                    popup.find_element_with_focus().click()
            self.logger.debug(f"parsed::{parsed_cmd}")
        popup.close()
        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:
@@ -83,7 +108,7 @@ class Popup:
            match parsed_cmd := self.window.parser.match.parseString(event):
                case [[button], ["FOCUS", "IN"]]:
                    self.window.nvda.speak(button)
-                case [[button], ["KEY", "ENTER"]]:
+                case [_, ["KEY", "ENTER"]]:
                    popup.find_element_with_focus().click()
                case ["Ok"]:
                    data = values
@@ -93,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 = [
                [
@@ -108,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:
@@ -148,10 +269,554 @@ 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 [[button], ["KEY", "ENTER"]]:
-                    popup.find_element_with_focus().click()
+                case [_, ["KEY", "ENTER"]]:
+                    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 = [
+                [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)
+
+        layout = []
+        steps = (_make_comp_frame,)
+        for step in steps:
+            layout.append([step()])
+        layout.append([psg.Button("MAKEUP", size=(12, 1)), 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 ("INPUT GAIN", "RATIO", "THRESHOLD", "ATTACK", "RELEASE", "KNEE", "OUTPUT GAIN"):
+            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"):
+                    self.popup[f"COMPRESSOR||SLIDER {param}"].bind(
+                        f"<{event}-{direction}>", f"||KEY {direction.upper()} {event_id}"
+                    )
+                    self.popup[f"COMPRESSOR||SLIDER {param}"].bind(
+                        f"<Shift-{event}-{direction}>", f"||KEY SHIFT {direction.upper()} {event_id}"
+                    )
+                    self.popup[f"COMPRESSOR||SLIDER {param}"].bind(
+                        f"<Control-{event}-{direction}>", f"||KEY CTRL {direction.upper()} {event_id}"
+                    )
+                    if param == "RELEASE":
+                        self.popup[f"COMPRESSOR||SLIDER {param}"].bind(
+                            f"<Alt-{event}-{direction}>", f"||KEY ALT {direction.upper()} {event_id}"
+                        )
+                        self.popup[f"COMPRESSOR||SLIDER {param}"].bind(
+                            f"<Control-Alt-{event}-{direction}>", f"||KEY CTRL ALT {direction.upper()} {event_id}"
+                        )
+            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 = 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 [["COMPRESSOR"], ["SLIDER", param]]:
+                    setattr(self.window.vm.strip[index].comp, param.lower(), values[event])
+                case [["COMPRESSOR"], ["SLIDER", param], ["FOCUS", "IN"]]:
+                    self.window.nvda.speak(f"{param} {values[f'COMPRESSOR||SLIDER {param}']}")
+                case [
+                    ["COMPRESSOR"],
+                    ["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].comp, param.lower())
+
+                        match input_direction:
+                            case "RIGHT" | "UP":
+                                if param == "KNEE":
+                                    val += 0.1
+                                else:
+                                    val += 1
+                            case "LEFT" | "DOWN":
+                                if param == "KNEE":
+                                    val -= 0.1
+                                else:
+                                    val -= 1
+
+                        val = CompSlider.check_bounds(param, val)
+
+                        setattr(self.window.vm.strip[index].comp, param.lower(), val)
+                        self.popup[f"COMPRESSOR||SLIDER {param}"].update(value=val)
+                        if param == "KNEE":
+                            self.window.nvda.speak(str(round(val, 2)))
+                        else:
+                            self.window.nvda.speak(str(round(val, 1)))
+                    else:
+                        self.window.vm.event.pdirty = True
+                case [
+                    ["COMPRESSOR"],
+                    ["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].comp, param.lower())
+
+                        match input_direction:
+                            case "RIGHT" | "UP":
+                                if param == "KNEE":
+                                    val += 0.3
+                                elif param == "RELEASE":
+                                    val += 5
+                                else:
+                                    val += 3
+                            case "LEFT" | "DOWN":
+                                if param == "KNEE":
+                                    val -= 0.3
+                                elif param == "RELEASE":
+                                    val -= 5
+                                else:
+                                    val -= 3
+
+                        val = CompSlider.check_bounds(param, val)
+
+                        setattr(self.window.vm.strip[index].comp, param.lower(), val)
+                        self.popup[f"COMPRESSOR||SLIDER {param}"].update(value=val)
+                        if param == "KNEE":
+                            self.window.nvda.speak(str(round(val, 2)))
+                        else:
+                            self.window.nvda.speak(str(round(val, 1)))
+                    else:
+                        self.window.vm.event.pdirty = True
+                case [
+                    ["COMPRESSOR"],
+                    ["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].comp, param.lower())
+
+                        match input_direction:
+                            case "RIGHT" | "UP":
+                                if param == "KNEE":
+                                    val += 0.01
+                                else:
+                                    val += 0.1
+                            case "LEFT" | "DOWN":
+                                if param == "KNEE":
+                                    val -= 0.01
+                                else:
+                                    val -= 0.1
+
+                        val = CompSlider.check_bounds(param, val)
+
+                        setattr(self.window.vm.strip[index].comp, param.lower(), val)
+                        self.popup[f"COMPRESSOR||SLIDER {param}"].update(value=val)
+                        if param == "KNEE":
+                            self.window.nvda.speak(str(round(val, 2)))
+                        else:
+                            self.window.nvda.speak(str(round(val, 1)))
+                    else:
+                        self.window.vm.event.pdirty = True
+                case [
+                    ["COMPRESSOR"],
+                    ["SLIDER", "RELEASE"],
+                    ["KEY", "ALT", "LEFT" | "RIGHT" as input_direction, "PRESS" | "RELEASE" as e],
+                ]:
+                    if e == "PRESS":
+                        self.window.vm.event.pdirty = False
+                        val = self.window.vm.strip[index].comp.release
+
+                        match input_direction:
+                            case "RIGHT" | "UP":
+                                val += 10
+                            case "LEFT" | "DOWN":
+                                val -= 10
+
+                        val = util.check_bounds(val, (0, 5000))
+                        self.window.vm.strip[index].comp.release = 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
+                case [
+                    ["COMPRESSOR"],
+                    ["SLIDER", "RELEASE"],
+                    ["KEY", "CTRL", "ALT", "LEFT" | "RIGHT" as input_direction, "PRESS" | "RELEASE" as e],
+                ]:
+                    if e == "PRESS":
+                        self.window.vm.event.pdirty = False
+                        val = self.window.vm.strip[index].comp.release
+
+                        match input_direction:
+                            case "RIGHT" | "UP":
+                                val += 50
+                            case "LEFT" | "DOWN":
+                                val -= 50
+
+                        val = util.check_bounds(val, (0, 5000))
+                        self.window.vm.strip[index].comp.release = 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
+
+                case [["COMPRESSOR"], ["SLIDER", "INPUT" | "OUTPUT" as direction, "GAIN"]]:
+                    if direction == "INPUT":
+                        self.window.vm.strip[index].comp.gainin = values[event]
+                    else:
+                        self.window.vm.strip[index].comp.gainout = values[event]
+                case [["COMPRESSOR"], ["SLIDER", "INPUT" | "OUTPUT" as direction, "GAIN"], ["FOCUS", "IN"]]:
+                    label = f"{direction} GAIN"
+                    self.window.nvda.speak(f"{label} {values[f'COMPRESSOR||SLIDER {label}']}")
+                case [
+                    ["COMPRESSOR"],
+                    ["SLIDER", "INPUT" | "OUTPUT" as direction, "GAIN"],
+                    ["KEY", "LEFT" | "RIGHT" | "UP" | "DOWN" as input_direction, "PRESS" | "RELEASE" as e],
+                ]:
+                    if e == "PRESS":
+                        self.window.vm.event.pdirty = False
+                        if direction == "INPUT":
+                            val = self.window.vm.strip[index].comp.gainin
+                        else:
+                            val = self.window.vm.strip[index].comp.gainout
+
+                        match input_direction:
+                            case "RIGHT" | "UP":
+                                val += 1
+                            case "LEFT" | "DOWN":
+                                val -= 1
+
+                        val = util.check_bounds(val, (-24, 24))
+                        if direction == "INPUT":
+                            self.window.vm.strip[index].comp.gainin = val
+                        else:
+                            self.window.vm.strip[index].comp.gainout = 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", "LEFT" | "RIGHT" | "UP" | "DOWN" as input_direction, "PRESS" | "RELEASE" as e],
+                ]:
+                    if e == "PRESS":
+                        self.window.vm.event.pdirty = False
+                        if direction == "INPUT":
+                            val = self.window.vm.strip[index].comp.gainin
+                        else:
+                            val = self.window.vm.strip[index].comp.gainout
+
+                        match input_direction:
+                            case "RIGHT" | "UP":
+                                val += 3
+                            case "LEFT" | "DOWN":
+                                val -= 3
+
+                        val = util.check_bounds(val, (-24, 24))
+                        if direction == "INPUT":
+                            self.window.vm.strip[index].comp.gainin = val
+                        else:
+                            self.window.vm.strip[index].comp.gainout = 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", "SHIFT", "LEFT" | "RIGHT" | "UP" | "DOWN" as input_direction, "PRESS" | "RELEASE" as e],
+                ]:
+                    if e == "PRESS":
+                        self.window.vm.event.pdirty = False
+                        if direction == "INPUT":
+                            val = self.window.vm.strip[index].comp.gainin
+                        else:
+                            val = self.window.vm.strip[index].comp.gainout
+
+                        match input_direction:
+                            case "RIGHT" | "UP":
+                                val += 0.1
+                            case "LEFT" | "DOWN":
+                                val -= 0.1
+
+                        val = util.check_bounds(val, (-24, 24))
+                        if direction == "INPUT":
+                            self.window.vm.strip[index].comp.gainin = val
+                        else:
+                            self.window.vm.strip[index].comp.gainout = 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'}"
+                        )
+                    else:
+                        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()
+
+    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()
--- a/src/nvda_voicemeeter/util.py
+++ b/src/nvda_voicemeeter/util.py
@@ -1,7 +1,9 @@
 from typing import Iterable

+import PySimpleGUI as psg

-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 +50,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 +113,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 [
@@ -141,12 +164,79 @@ def check_bounds(val, bounds: tuple) -> int | float:
    return val


-def get_slider_params(i, vm) -> Iterable:
-    if i < vm.kind.phys_in:
-        if vm.kind.name == "basic":
+def get_slider_params(i, kind) -> Iterable:
+    if i < kind.phys_in:
+        if kind.name == "basic":
            return ("AUDIBILITY",)
-        if vm.kind.name == "banana":
+        if kind.name == "banana":
            return ("COMP", "GATE")
-        if vm.kind.name == "potato":
+        if kind.name == "potato":
            return ("COMP", "GATE", "DENOISER")
    return ("BASS", "MID", "TREBLE")
+
+
+def get_full_slider_params(i, kind) -> Iterable:
+    params = list(get_slider_params(i, kind) + ("GAIN", "LIMIT"))
+    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)]
+
+
+psg.theme_add_new(
+    "HighContrast",
+    {
+        "BACKGROUND": "#FFFFFF",
+        "TEXT": "#000000",
+        "INPUT": "#FAF9F6",
+        "TEXT_INPUT": "#000000",
+        "SCROLL": "#FAF9F6",
+        "BUTTON": ("#000000", "#FFFFFF"),
+        "PROGRESS": ("#000000", "#FFFFFF"),
+        "BORDER": 2,
+        "SLIDER_DEPTH": 3,
+        "PROGRESS_DEPTH": 0,
+    },
+)
+
+
+def get_themes_list() -> list:
+    return [
+        "Bright Colors",
+        "Dark Blue 14",
+        "Dark Brown 2",
+        "Dark Brown 3",
+        "Dark Green 2",
+        "Dark Grey 2",
+        "Dark Teal1",
+        "Dark Teal6",
+        "Kayak",
+        "Light Blue 2",
+        "Light Brown 2",
+        "Light Brown 5",
+        "Light Green",
+        "Light Green 3",
+        "Light Grey 2",
+        "Light Purple",
+        "Neutral Blue",
+        "Reds",
+        "Sandy Beach",
+        "High Contrast",
+    ]
--- a/src/nvda_voicemeeter/window.py
+++ b/src/nvda_voicemeeter/window.py
Author	SHA1	Message	Date
onyx-and-iris	2ed1cad666	minor bump closes #19	2023-11-19 22:45:57 +00:00
onyx-and-iris	64361b2011	High Contrast theme added. Sets GUI font to Arial, size 14 version bumped to 0.5.7b2 Issue #19	2023-11-19 01:22:40 +00:00
onyx-and-iris	36003fe73f	theme list updated. themes section added to readme version bumped to 0.5.7b1 Issue #19	2023-11-16 15:43:39 +00:00
onyx-and-iris	cb82033e1c	theme menu initial implementation bump to 0.5.7a1 Issue #19	2023-11-15 23:34:53 +00:00
onyx-and-iris	bde9020471	closes #17	2023-10-29 19:26:03 +00:00
onyx-and-iris	364b0deeb4	bump to v0.5.6b1 addresses issue #17	2023-10-26 21:06:06 +01:00
onyx-and-iris	a80e4e2d83	Patch BUS to A1 ASIO Outputs implemented Patch ASIO Inputs to Strips moved to Advanced Settings	2023-10-26 20:12:49 +01:00
onyx-and-iris	6e146bac50	upd images	2023-10-04 05:22:08 +01:00
onyx-and-iris	c385476cc4	adjust cache to match strip layout event keys updated _get_bus_assignments added to util.py patch bump	2023-09-29 20:08:18 +01:00
onyx-and-iris	1c09556c61	adds missing karaoke mode `k v` patch bump	2023-09-29 18:30:53 +01:00
onyx-and-iris	421688eff8	resizes the patch composite buttons fixes possible (but unlikely) index out of range. patch bump	2023-09-29 13:38:40 +01:00
onyx-and-iris	bdd570738a	fix version bump...	2023-09-29 01:18:57 +01:00
onyx-and-iris	71b137a9c2	use self.kind	2023-09-29 01:16:48 +01:00
onyx-and-iris	912eb8c14d	number of patch composite buttons fixed for banana and potato kinds voicemeeter-api dependency bump patch bump	2023-09-29 01:09:18 +01:00
onyx-and-iris	9cd65737e5	bump to version 0.5.1 closes #16	2023-09-28 23:35:02 +01:00
onyx-and-iris	4a6ca2a353	check against slider modes explicitly add enter/exit slider mode debug logging	2023-09-28 22:43:06 +01:00
onyx-and-iris	cc99b14e89	define space bind event for bus buttons	2023-09-28 21:35:05 +01:00
onyx-and-iris	23458debaa	initial busmode buttonmenu implementation bump to 0.5.1a1 Issue #16	2023-09-28 19:44:42 +01:00
onyx-and-iris	496cc35321	fixes comp output gain resolution	2023-09-28 18:18:26 +01:00
onyx-and-iris	d758db9dee	lint/format fixes	2023-09-28 16:32:52 +01:00
onyx-and-iris	876de55ad2	Advanced Comp\|Gate sliders implemented bump to 0.5.0 closes #14	2023-09-27 23:34:07 +01:00
onyx-and-iris	eab4b1c6a9	fixes unboundlocalerror	2023-09-27 13:36:48 +01:00
onyx-and-iris	0aeb33608f	implements reset binds Advanced Comp\|Gate section added to README. bump to version 0.5.0b1	2023-09-26 23:51:34 +01:00
onyx-and-iris	5befe72ca1	adds pdirty events for advanced comp/gate	2023-09-26 19:38:55 +01:00
onyx-and-iris	abab560281	+10, +50 step binds added for gate bump to version 0.5.0a2 Initial gate slider implementation for Issue #14	2023-09-26 17:20:15 +01:00
onyx-and-iris	6882adb47b	gate as no Knee parameter	2023-09-26 15:56:12 +01:00
onyx-and-iris	af602e087d	GateSlider added to compound Advanced Gate slider layout and events defined needs more testing.	2023-09-26 15:53:43 +01:00
onyx-and-iris	01e80dc4f6	replace flake8 with ruff add tool.ruff to pyproject update lint dependencies removes settings.json ruff badge added to readme bump to version 0.4.2.a1 Initial compressor slider implementation for Issue #14	2023-09-26 14:37:41 +01:00
onyx-and-iris	7262af4bcf	disable default keyboard/mouse events for gain sliders	2023-09-26 13:33:13 +01:00
onyx-and-iris	ef10b224d7	remove redundant if statement	2023-09-25 18:24:43 +01:00
onyx-and-iris	89d0253591	add advanced comproessor slider events voicemeeter-api version bumped some of the spoken feedback for sliders corrected.	2023-09-25 18:22:17 +01:00
onyx-and-iris	85527e0749	defines layout for compressor popup	2023-09-25 12:14:29 +01:00
onyx-and-iris	9d8ea5f747	fixes regression, bus focus in/out readded patch bump	2023-09-23 17:04:33 +01:00
onyx-and-iris	0dd6c89f96	implements up/down slider mode binds adjustments to pdirty event toggling. press/release events defined for slider binds note: the main window no longer returns keyboard events minor bump	2023-09-23 16:36:48 +01:00
onyx-and-iris	893f9f59ff	patch asio spinboxes set as readonly patch insert checkboxes enter bind added	2023-09-21 16:39:21 +01:00
onyx-and-iris	3ca9e14e96	adds bass, mid and treble slider modes patch bump	2023-09-21 09:33:22 +01:00