hardware ins implemented

strip, bus params implemented
(mute, mono, eq etc)

bus mode buttons now rotate through all bus modes

.gitignore

@@ -161,4 +161,17 @@ cython_debug/
 #  option (not recommended) you can uncomment the following to ignore the entire idea folder.
 #.idea/
 
-controllerClient/
+# nvda files
+controllerClient/*
+!.gitkeep
+
+# build files
+basic.py
+banana.py
+potato.py
+
+# persistent storage
+settings.json
+
+# quick test
+quick.py

__main__.py

@@ -2,8 +2,8 @@ import voicemeeterlib
 
 import nvda_voicemeeter
 
-kind_id = "potato"
+KIND_ID = "potato"
 
-with voicemeeterlib.api("potato") as vm:
+with voicemeeterlib.api(KIND_ID, sync=True) as vm:
-    with nvda_voicemeeter.build(f"Voicemeeter {kind_id.capitalize()} NVDA", vm) as window:
+    with nvda_voicemeeter.draw(KIND_ID, vm) as window:
         window.run()

build.ps1

@@ -0,0 +1,20 @@
+function Compress-Builds {
+    $target = Join-Path -Path $PSScriptRoot -ChildPath "dist"
+    @("basic", "banana", "potato") | ForEach-Object {
+        Compress-Archive -Path $(Join-Path -Path $target -ChildPath $_) -DestinationPath $(Join-Path -Path $target -ChildPath "${_}.zip") -Force
+    } 
+}
+
+function Get-Builds {
+    @("basic", "banana", "potato") | ForEach-Object {
+        pdm run pyinstaller "${_}.spec" --noconfirm
+    }  
+}
+
+function main {
+    Get-Builds
+
+    Compress-Builds
+}
+
+if ($MyInvocation.InvocationName -ne '.') { main }

pdm.lock

@@ -2,11 +2,223 @@
 # It is not intended for manual editing.
 
 [metadata]
-groups = ["default"]
+groups = ["default", "build", "lint", "test"]
 cross_platform = true
 static_urls = false
 lock_version = "4.3"
-content_hash = "sha256:0dfd1ea07c294dd2b837a34ff9d286134e5119c6249e4f9cd6c1ed121de97851"
+content_hash = "sha256:2aaf88f0abb701968bc22eb31fd189810850a505bb93553f67216e4d1d259750"
+
+[[package]]
+name = "altgraph"
+version = "0.17.3"
+summary = "Python graph (network) package"
+files = [
+    {file = "altgraph-0.17.3-py2.py3-none-any.whl", hash = "sha256:c8ac1ca6772207179ed8003ce7687757c04b0b71536f81e2ac5755c6226458fe"},
+    {file = "altgraph-0.17.3.tar.gz", hash = "sha256:ad33358114df7c9416cdb8fa1eaa5852166c505118717021c6a8c7c7abbd03dd"},
+]
+
+[[package]]
+name = "black"
+version = "23.7.0"
+requires_python = ">=3.8"
+summary = "The uncompromising code formatter."
+dependencies = [
+    "click>=8.0.0",
+    "mypy-extensions>=0.4.3",
+    "packaging>=22.0",
+    "pathspec>=0.9.0",
+    "platformdirs>=2",
+    "tomli>=1.1.0; python_version < \"3.11\"",
+]
+files = [
+    {file = "black-23.7.0-cp310-cp310-macosx_10_16_arm64.whl", hash = "sha256:5c4bc552ab52f6c1c506ccae05681fab58c3f72d59ae6e6639e8885e94fe2587"},
+    {file = "black-23.7.0-cp310-cp310-macosx_10_16_universal2.whl", hash = "sha256:552513d5cd5694590d7ef6f46e1767a4df9af168d449ff767b13b084c020e63f"},
+    {file = "black-23.7.0-cp310-cp310-macosx_10_16_x86_64.whl", hash = "sha256:86cee259349b4448adb4ef9b204bb4467aae74a386bce85d56ba4f5dc0da27be"},
+    {file = "black-23.7.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:501387a9edcb75d7ae8a4412bb8749900386eaef258f1aefab18adddea1936bc"},
+    {file = "black-23.7.0-cp310-cp310-win_amd64.whl", hash = "sha256:fb074d8b213749fa1d077d630db0d5f8cc3b2ae63587ad4116e8a436e9bbe995"},
+    {file = "black-23.7.0-py3-none-any.whl", hash = "sha256:9fd59d418c60c0348505f2ddf9609c1e1de8e7493eab96198fc89d9f865e7a96"},
+    {file = "black-23.7.0.tar.gz", hash = "sha256:022a582720b0d9480ed82576c920a8c1dde97cc38ff11d8d8859b3bd6ca9eedb"},
+]
+
+[[package]]
+name = "click"
+version = "8.1.7"
+requires_python = ">=3.7"
+summary = "Composable command line interface toolkit"
+dependencies = [
+    "colorama; platform_system == \"Windows\"",
+]
+files = [
+    {file = "click-8.1.7-py3-none-any.whl", hash = "sha256:ae74fb96c20a0277a1d615f1e4d73c8414f5a98db8b799a7931d1582f3390c28"},
+    {file = "click-8.1.7.tar.gz", hash = "sha256:ca9853ad459e787e2192211578cc907e7594e294c7ccc834310722b41b9ca6de"},
+]
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+requires_python = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,>=2.7"
+summary = "Cross-platform colored terminal text."
+files = [
+    {file = "colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6"},
+    {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"
+summary = "Mach-O header analysis and editing"
+dependencies = [
+    "altgraph>=0.17",
+]
+files = [
+    {file = "macholib-1.16.2-py2.py3-none-any.whl", hash = "sha256:44c40f2cd7d6726af8fa6fe22549178d3a4dfecc35a9cd15ea916d9c83a688e0"},
+    {file = "macholib-1.16.2.tar.gz", hash = "sha256:557bbfa1bb255c20e9abafe7ed6cd8046b48d9525db2f9b77d3122a63a2a8bf8"},
+]
+
+[[package]]
+name = "mccabe"
+version = "0.7.0"
+requires_python = ">=3.6"
+summary = "McCabe checker, plugin for flake8"
+files = [
+    {file = "mccabe-0.7.0-py2.py3-none-any.whl", hash = "sha256:6c2d30ab6be0e4a46919781807b4f0d834ebdd6c6e3dca0bda5a15f863427b6e"},
+    {file = "mccabe-0.7.0.tar.gz", hash = "sha256:348e0240c33b60bbdf4e523192ef919f28cb2c3d7d5c7794f74009290f236325"},
+]
+
+[[package]]
+name = "mypy-extensions"
+version = "1.0.0"
+requires_python = ">=3.5"
+summary = "Type system extensions for programs checked with the mypy type checker."
+files = [
+    {file = "mypy_extensions-1.0.0-py3-none-any.whl", hash = "sha256:4392f6c0eb8a5668a69e23d168ffa70f0be9ccfd32b5cc2d26a34ae5b844552d"},
+    {file = "mypy_extensions-1.0.0.tar.gz", hash = "sha256:75dbf8955dc00442a438fc4d0666508a9a97b6bd41aa2f0ffe9d2f2725af0782"},
+]
+
+[[package]]
+name = "packaging"
+version = "23.1"
+requires_python = ">=3.7"
+summary = "Core utilities for Python packages"
+files = [
+    {file = "packaging-23.1-py3-none-any.whl", hash = "sha256:994793af429502c4ea2ebf6bf664629d07c1a9fe974af92966e4b8d2df7edc61"},
+    {file = "packaging-23.1.tar.gz", hash = "sha256:a392980d2b6cffa644431898be54b0045151319d1e7ec34f0cfed48767dd334f"},
+]
+
+[[package]]
+name = "pathspec"
+version = "0.11.2"
+requires_python = ">=3.7"
+summary = "Utility library for gitignore style pattern matching of file paths."
+files = [
+    {file = "pathspec-0.11.2-py3-none-any.whl", hash = "sha256:1d6ed233af05e679efb96b1851550ea95bbb64b7c490b0f5aa52996c11e92a20"},
+    {file = "pathspec-0.11.2.tar.gz", hash = "sha256:e0d8d0ac2f12da61956eb2306b69f9469b42f4deb0f3cb6ed47b9cce9996ced3"},
+]
+
+[[package]]
+name = "pefile"
+version = "2023.2.7"
+requires_python = ">=3.6.0"
+summary = "Python PE parsing module"
+files = [
+    {file = "pefile-2023.2.7-py3-none-any.whl", hash = "sha256:da185cd2af68c08a6cd4481f7325ed600a88f6a813bad9dea07ab3ef73d8d8d6"},
+    {file = "pefile-2023.2.7.tar.gz", hash = "sha256:82e6114004b3d6911c77c3953e3838654b04511b8b66e8583db70c65998017dc"},
+]
+
+[[package]]
+name = "platformdirs"
+version = "3.10.0"
+requires_python = ">=3.7"
+summary = "A small Python package for determining appropriate platform-specific dirs, e.g. a \"user data dir\"."
+files = [
+    {file = "platformdirs-3.10.0-py3-none-any.whl", hash = "sha256:d7c24979f292f916dc9cbf8648319032f551ea8c49a4c9bf2fb556a02070ec1d"},
+    {file = "platformdirs-3.10.0.tar.gz", hash = "sha256:b45696dab2d7cc691a3226759c0d3b00c47c8b6e293d96f6436f733303f77f6d"},
+]
+
+[[package]]
+name = "psgdemos"
+version = "1.12.1"
+summary = "Installs the full set of PySimpleGUI Demo Programs and the Demo Browser."
+dependencies = [
+    "PySimpleGUI",
+]
+files = [
+    {file = "psgdemos-1.12.1-py3-none-any.whl", hash = "sha256:a035540dd0ff92f410aed9b7af8d5a641d9d5a9eac3e0072ef115adf06abb447"},
+    {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"
+requires_python = "<3.13,>=3.7"
+summary = "PyInstaller bundles a Python application and all its dependencies into a single package."
+dependencies = [
+    "altgraph",
+    "macholib>=1.8; sys_platform == \"darwin\"",
+    "pefile>=2022.5.30; sys_platform == \"win32\"",
+    "pyinstaller-hooks-contrib>=2021.4",
+    "pywin32-ctypes>=0.2.1; sys_platform == \"win32\"",
+    "setuptools>=42.0.0",
+]
+files = [
+    {file = "pyinstaller-5.13.0-py3-none-macosx_10_13_universal2.whl", hash = "sha256:7fdd319828de679f9c5e381eff998ee9b4164bf4457e7fca56946701cf002c3f"},
+    {file = "pyinstaller-5.13.0-py3-none-manylinux2014_aarch64.whl", hash = "sha256:0df43697c4914285ecd333be968d2cd042ab9b2670124879ee87931d2344eaf5"},
+    {file = "pyinstaller-5.13.0-py3-none-manylinux2014_i686.whl", hash = "sha256:28d9742c37e9fb518444b12f8c8ab3cb4ba212d752693c34475c08009aa21ccf"},
+    {file = "pyinstaller-5.13.0-py3-none-manylinux2014_ppc64le.whl", hash = "sha256:e5fb17de6c325d3b2b4ceaeb55130ad7100a79096490e4c5b890224406fa42f4"},
+    {file = "pyinstaller-5.13.0-py3-none-manylinux2014_s390x.whl", hash = "sha256:78975043edeb628e23a73fb3ef0a273cda50e765f1716f75212ea3e91b09dede"},
+    {file = "pyinstaller-5.13.0-py3-none-manylinux2014_x86_64.whl", hash = "sha256:cd7d5c06f2847195a23d72ede17c60857d6f495d6f0727dc6c9bc1235f2eb79c"},
+    {file = "pyinstaller-5.13.0-py3-none-musllinux_1_1_aarch64.whl", hash = "sha256:24009eba63cfdbcde6d2634e9c87f545eb67249ddf3b514e0cd3b2cdaa595828"},
+    {file = "pyinstaller-5.13.0-py3-none-musllinux_1_1_x86_64.whl", hash = "sha256:1fde4381155f21d6354dc450dcaa338cd8a40aaacf6bd22b987b0f3e1f96f3ee"},
+    {file = "pyinstaller-5.13.0-py3-none-win32.whl", hash = "sha256:2d03419904d1c25c8968b0ad21da0e0f33d8d65716e29481b5bd83f7f342b0c5"},
+    {file = "pyinstaller-5.13.0-py3-none-win_amd64.whl", hash = "sha256:9fc27c5a853b14a90d39c252707673c7a0efec921cd817169aff3af0fca8c127"},
+    {file = "pyinstaller-5.13.0-py3-none-win_arm64.whl", hash = "sha256:3a331951f9744bc2379ea5d65d36f3c828eaefe2785f15039592cdc08560b262"},
+    {file = "pyinstaller-5.13.0.tar.gz", hash = "sha256:5e446df41255e815017d96318e39f65a3eb807e74a796c7e7ff7f13b6366a2e9"},
+]
+
+[[package]]
+name = "pyinstaller-hooks-contrib"
+version = "2023.7"
+requires_python = ">=3.7"
+summary = "Community maintained hooks for PyInstaller"
+files = [
+    {file = "pyinstaller-hooks-contrib-2023.7.tar.gz", hash = "sha256:0c436a4c3506020e34116a8a7ddfd854c1ad6ddca9a8cd84500bd6e69c9e68f9"},
+    {file = "pyinstaller_hooks_contrib-2023.7-py2.py3-none-any.whl", hash = "sha256:3c10df14c0f71ab388dfbf1625375b087e7330d9444cbfd2b310ba027fa0cff0"},
+]
 
 [[package]]
 name = "pyparsing"
@@ -27,6 +239,26 @@ files = [
     {file = "PySimpleGUI-4.60.5.tar.gz", hash = "sha256:31014d1cc5eef1373d7e93564ff2604662645cc774a939b1f01aa253e7f9d78b"},
 ]
 
+[[package]]
+name = "pywin32-ctypes"
+version = "0.2.2"
+requires_python = ">=3.6"
+summary = "A (partial) reimplementation of pywin32 using ctypes/cffi"
+files = [
+    {file = "pywin32-ctypes-0.2.2.tar.gz", hash = "sha256:3426e063bdd5fd4df74a14fa3cf80a0b42845a87e1d1e81f6549f9daec593a60"},
+    {file = "pywin32_ctypes-0.2.2-py3-none-any.whl", hash = "sha256:bf490a1a709baf35d688fe0ecf980ed4de11d2b3e37b51e5442587a75d9957e7"},
+]
+
+[[package]]
+name = "setuptools"
+version = "68.1.2"
+requires_python = ">=3.8"
+summary = "Easily download, build, install, upgrade, and uninstall Python packages"
+files = [
+    {file = "setuptools-68.1.2-py3-none-any.whl", hash = "sha256:3d8083eed2d13afc9426f227b24fd1659489ec107c0e86cec2ffdde5c92e790b"},
+    {file = "setuptools-68.1.2.tar.gz", hash = "sha256:3d4dfa6d95f1b101d695a6160a7626e15583af71a5f52176efa5d39a054d475d"},
+]
+
 [[package]]
 name = "tomli"
 version = "2.0.1"

pyproject.toml

@@ -10,7 +10,21 @@ dependencies = [
     "pyparsing>=3.1.1",
     "voicemeeter-api>=2.4.8",
 ]
-requires-python = ">=3.10"
+requires-python = ">=3.10,<3.11"
 readme = "README.md"
 license = {text = "MIT"}
 
+[tool.pdm.dev-dependencies]
+build = [
+    "pyinstaller>=5.1",
+]
+lint = [
+    "black>=23.7.0",
+    "flake8>=6.1.0",
+]
+test = [
+    "psgdemos>=1.12.1",
+]
+
+[tool.pdm.scripts]
+build = {shell = "build.ps1"}

src/nvda_voicemeeter/__init__.py

@@ -1 +1,14 @@
-from .window import request_window_object as build
+import subprocess as sp
+import time
+
+from .cdll import NVDA_PATH
+from .window import request_window_object as draw
+
+
+def launch(delay=1):
+    if NVDA_PATH:
+        sp.Popen([NVDA_PATH], shell=True)
+        time.sleep(delay)
+
+
+__ALL__ = ["launch", "draw"]

src/nvda_voicemeeter/builder.py

@@ -0,0 +1,343 @@
+import PySimpleGUI as psg
+
+from .util import (
+    get_asio_checkbox_index,
+    get_asio_samples_list,
+    get_input_device_list,
+    get_insert_checkbox_index,
+    get_output_device_list,
+    get_patch_composite_list,
+    get_tabs_labels,
+)
+
+
+class Builder:
+    """Responsible for building the Window layout"""
+
+    def __init__(self, window):
+        self.window = window
+        self.vm = self.window.vm
+        self.kind = self.vm.kind
+
+    def run(self) -> list:
+        menu = [[self.make_menu()]]
+
+        layout0 = []
+        if self.kind.name == "basic":
+            steps = (
+                self.make_tab0_row0,
+                self.make_tab0_row1,
+            )
+        else:
+            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,
+            )
+        for step in steps:
+            layout0.append([step()])
+
+        layout1 = []
+        steps = (self.make_tab1_rows,)
+        for step in steps:
+            layout1.append([step()])
+
+        layout2 = []
+        steps = (self.make_tab2_rows,)
+        for step in steps:
+            layout2.append([step()])
+
+        layout3 = []
+        steps = (self.make_tab3_rows,)
+        for step in steps:
+            layout3.append([step()])
+
+        layouts = [layout0, layout1, layout2, layout3]
+
+        tabs = [psg.Tab(identifier, layouts[i], key=identifier) for i, identifier in enumerate(get_tabs_labels())]
+        tab_group = psg.TabGroup([tabs], change_submits=True, key="tabs")
+
+        return [[menu], [tab_group]]
+
+    def make_menu(self) -> psg.Menu:
+        menu_def = [
+            [
+                "&Voicemeeter",
+                [
+                    "Restart Audio Engine::MENU",
+                    "Save Settings::MENU",
+                    "Load Settings::MENU",
+                    "Load Settings on Startup ::MENU",
+                ],
+            ],
+        ]
+        return psg.Menu(menu_def, key="menus")
+
+    def make_tab0_row0(self) -> psg.Frame:
+        """tab0 row0 represents hardware ins"""
+
+        def add_physical_device_opts(layout):
+            devices = get_input_device_list(self.vm)
+            devices.append("- remove device selection -")
+            layout.append(
+                [
+                    psg.ButtonMenu(
+                        f"IN {i + 1}",
+                        size=(6, 3),
+                        menu_def=["", devices],
+                        key=f"HARDWARE IN||{i + 1}",
+                    )
+                    for i in range(self.kind.phys_in)
+                ]
+            )
+
+        hardware_in = list()
+        [step(hardware_in) for step in (add_physical_device_opts,)]
+        return psg.Frame("Hardware In", hardware_in)
+
+    def make_tab0_row1(self) -> psg.Frame:
+        """tab0 row1 represents hardware outs"""
+
+        def add_physical_device_opts(layout):
+            devices = get_output_device_list(self.vm)
+            devices.append("- remove device selection -")
+            if self.kind.name == "basic":
+                num_outs = self.kind.phys_out + self.kind.virt_out
+            else:
+                num_outs = self.kind.phys_out
+            layout.append(
+                [
+                    psg.ButtonMenu(
+                        f"A{i + 1}",
+                        size=(6, 3),
+                        menu_def=["", devices],
+                        key=f"HARDWARE OUT||A{i + 1}",
+                    )
+                    for i in range(num_outs)
+                ]
+            )
+
+        hardware_out = list()
+        [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||{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||{get_asio_checkbox_index(1, i)}"],
+                        size=2,
+                        enable_events=True,
+                        key=f"ASIO CHECKBOX||IN{i} 1",
+                    )
+                ],
+            )
+
+        inner = list()
+        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 = get_patch_composite_list(self.vm.kind)
+            layout.append(
+                [
+                    psg.ButtonMenu(
+                        f"PC{i + 1}",
+                        size=(6, 2),
+                        menu_def=["", outputs],
+                        key=f"PATCH COMPOSITE||PC{i + 1}",
+                    )
+                    for i in range(self.kind.phys_out)
+                ]
+            )
+
+        hardware_out = list()
+        [step(hardware_out) for step in (add_physical_device_opts,)]
+        return psg.Frame("PATCH COMPOSITE", hardware_out)
+
+    def make_tab0_row4(self) -> psg.Frame:
+        """tab0 row4 represents patch insert"""
+
+        def add_insert_checkboxes(layout, i):
+            if i <= self.kind.phys_in:
+                [
+                    layout.append(
+                        [
+                            psg.Checkbox(
+                                text=channel,
+                                default=self.vm.patch.insert[get_insert_checkbox_index(self.kind, j, i)].on,
+                                enable_events=True,
+                                key=f"INSERT CHECKBOX||IN{i} {j}",
+                            )
+                        ],
+                    )
+                    for j, channel in enumerate(("LEFT", "RIGHT"))
+                ]
+            else:
+                layout.append(
+                    [
+                        psg.Checkbox(
+                            text=channel,
+                            default=self.vm.patch.insert[get_insert_checkbox_index(self.kind, j, i)].on,
+                            enable_events=True,
+                            key=f"INSERT CHECKBOX||IN{i} {j}",
+                        )
+                        for j, channel in enumerate(("LEFT", "RIGHT", "C", "LFE", "SL", "SR", "BL", "BR"))
+                    ],
+                )
+
+        asio_checkboxes = list()
+        inner = list()
+        checkbox_lists = ([] for _ in range(self.kind.num_strip))
+        for i, checkbox_list in enumerate(checkbox_lists):
+            if i < self.kind.phys_in:
+                [step(checkbox_list, i + 1) for step in (add_insert_checkboxes,)]
+                inner.append(psg.Frame(f"In#{i + 1}", checkbox_list))
+            else:
+                [step(checkbox_list, i + 1) for step in (add_insert_checkboxes,)]
+                asio_checkboxes.append([psg.Frame(f"In#{i + 1}", checkbox_list)])
+        asio_checkboxes.insert(0, inner)
+
+        return psg.Frame("PATCH INSERT", asio_checkboxes)
+
+    def make_tab0_row5(self) -> psg.Frame:
+        """tab0 row5 represents asio buffer"""
+
+        samples = get_asio_samples_list()
+        samples.append("Default")
+
+        return psg.Frame(
+            "ASIO BUFFER",
+            [
+                [
+                    psg.ButtonMenu(
+                        "ASIO BUFFER",
+                        size=(14, 2),
+                        menu_def=["", samples],
+                        key="ASIO BUFFER",
+                    )
+                ]
+            ],
+            key="ASIO BUFFER FRAME",
+        )
+
+    def make_tab1_row(self, i) -> psg.Frame:
+        """tab1 row represents a strip's outputs (A1-A5, B1-B3)"""
+
+        def add_strip_outputs(layout):
+            layout.append(
+                [
+                    psg.Button(
+                        f"A{j + 1}" if j < self.kind.phys_out else f"B{j - self.kind.phys_out + 1}",
+                        size=(4, 2),
+                        key=f"STRIP {i}||A{j + 1}"
+                        if j < self.kind.phys_out
+                        else f"STRIP {i}||B{j - self.kind.phys_out + 1}",
+                    )
+                    for j in range(self.kind.phys_out + self.kind.virt_out)
+                ],
+            )
+            layout.append(
+                [
+                    psg.Button("Mono", size=(6, 2), key=f"STRIP {i}||MONO"),
+                    psg.Button("Solo", size=(6, 2), key=f"STRIP {i}||SOLO"),
+                    psg.Button("Mute", size=(6, 2), key=f"STRIP {i}||MUTE"),
+                ],
+            )
+
+        outputs = list()
+        [step(outputs) for step in (add_strip_outputs,)]
+        return psg.Frame(self.window.cache["labels"][f"STRIP {i}||LABEL"], outputs, key=f"STRIP {i}||LABEL")
+
+    def make_tab1_rows(self) -> psg.Frame:
+        layout = [[self.make_tab1_row(i)] for i in range(self.kind.phys_in)]
+        return psg.Frame(None, layout, border_width=0)
+
+    def make_tab2_row(self, i) -> psg.Frame:
+        """tab2 row represents a strip's outputs (A1-A5, B1-B3)"""
+
+        def add_strip_outputs(layout):
+            layout.append(
+                [
+                    psg.Button(
+                        f"A{j + 1}" if j < self.kind.phys_out else f"B{j - self.kind.phys_out + 1}",
+                        size=(4, 2),
+                        key=f"STRIP {i}||A{j + 1}"
+                        if j < self.kind.phys_out
+                        else f"STRIP {i}||B{j - self.kind.phys_out + 1}",
+                    )
+                    for j in range(self.kind.phys_out + self.kind.virt_out)
+                ]
+            )
+            if i == self.kind.phys_in + self.kind.virt_in - 2:
+                layout.append(
+                    [
+                        psg.Button("K", size=(6, 2), key=f"STRIP {i}||MONO"),
+                        psg.Button("Solo", size=(6, 2), key=f"STRIP {i}||SOLO"),
+                        psg.Button("Mute", size=(6, 2), key=f"STRIP {i}||MUTE"),
+                    ],
+                )
+            else:
+                layout.append(
+                    [
+                        psg.Button("MC", size=(6, 2), key=f"STRIP {i}||MONO"),
+                        psg.Button("Solo", size=(6, 2), key=f"STRIP {i}||SOLO"),
+                        psg.Button("Mute", size=(6, 2), key=f"STRIP {i}||MUTE"),
+                    ],
+                )
+
+        outputs = list()
+        [step(outputs) for step in (add_strip_outputs,)]
+        return psg.Frame(self.window.cache["labels"][f"STRIP {i}||LABEL"], outputs, key=f"STRIP {i}||LABEL")
+
+    def make_tab2_rows(self) -> psg.Frame:
+        layout = [[self.make_tab2_row(i)] for i in range(self.kind.phys_in, self.kind.phys_in + self.kind.virt_in)]
+        return psg.Frame(None, layout, border_width=0)
+
+    def make_tab3_row(self, i) -> psg.Frame:
+        """tab3 row represents bus composite toggle"""
+
+        def add_strip_outputs(layout):
+            layout.append(
+                [
+                    psg.Button("Mono", size=(6, 2), key=f"BUS {i}||MONO"),
+                    psg.Button("EQ", size=(6, 2), key=f"BUS {i}||EQ"),
+                    psg.Button("Mute", size=(6, 2), key=f"BUS {i}||MUTE"),
+                    psg.Button(f"BUSMODE", size=(12, 2), key=f"BUS {i}||MODE"),
+                ]
+            )
+
+        outputs = list()
+        [step(outputs) for step in (add_strip_outputs,)]
+        return psg.Frame(self.window.cache["labels"][f"BUS {i}||LABEL"], outputs, key=f"BUS {i}||LABEL")
+
+    def make_tab3_rows(self) -> psg.Frame:
+        layout = [[self.make_tab3_row(i)] for i in range(self.kind.num_bus)]
+        return psg.Frame(None, layout, border_width=0)

src/nvda_voicemeeter/cdll.py

@@ -1,9 +1,45 @@
 import ctypes as ct
+import platform
+import winreg
 from pathlib import Path
 
+from .errors import NVDAVMError
+
 bits = 64 if ct.sizeof(ct.c_voidp) == 8 else 32
 
+if platform.system() != "Windows":
+    raise NVDAVMError("Only Windows OS supported")
+
+REG_KEY = "\\".join(
+    filter(
+        None,
+        (
+            "SOFTWARE",
+            "WOW6432Node" if bits == 64 else "",
+            "Microsoft",
+            "Windows",
+            "CurrentVersion",
+            "Uninstall",
+            "NVDA",
+        ),
+    )
+)
+
+
+def get_nvdapath():
+    with winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, r"{}".format(REG_KEY)) as nvda_key:
+        return winreg.QueryValueEx(nvda_key, r"UninstallDirectory")[0]
+
+
+try:
+    NVDA_PATH = Path(get_nvdapath()) / "nvda.exe"
+except FileNotFoundError as e:
+    NVDA_PATH = ""
+
+
 controller_path = Path(__file__).parents[2].resolve() / "controllerClient"
+if not controller_path.exists():
+    controller_path = Path("controllerClient")
 
 DLL_PATH = controller_path / f"x{64 if bits == 64 else 86}" / f"nvdaControllerClient{bits}.dll"
 

src/nvda_voicemeeter/errors.py

@@ -0,0 +1,11 @@
+class NVDAVMError(Exception):
+    """Base NVDAVM error class"""
+
+
+class NVDAVMCAPIError(NVDAVMError):
+    """Exception raised when the NVDA C-API returns an error code"""
+
+    def __init__(self, fn_name, code):
+        self.fn_name = fn_name
+        self.code = code
+        super().__init__(f"{self.fn_name} returned {self.code}")

src/nvda_voicemeeter/models.py

@@ -1,26 +1,80 @@
-def _make_cache(vm) -> dict:
+def _make_hardware_ins_cache(vm) -> dict:
+    return {**{f"HARDWARE IN||{i + 1}": vm.strip[i].device.name for i in range(vm.kind.phys_in)}}
+
+
+def _make_hardware_outs_cache(vm) -> dict:
+    return {**{f"HARDWARE OUT||A{i + 1}": vm.bus[i].device.name for i in range(vm.kind.phys_out)}}
+
+
+def _make_param_cache(vm, channel_type) -> dict:
+    params = {}
+    if channel_type == "strip":
         match vm.kind.name:
             case "basic":
-            return {
+                params |= {
-                **{f"BUTTON||strip {i} A1": vm.strip[i].A1 for i in range(vm.kind.num_strip)},
+                    **{f"STRIP {i}||A1": vm.strip[i].A1 for i in range(vm.kind.num_strip)},
-                **{f"BUTTON||strip {i} B1": vm.strip[i].B1 for i in range(vm.kind.num_strip)},
+                    **{f"STRIP {i}||B1": vm.strip[i].B1 for i in range(vm.kind.num_strip)},
                 }
             case "banana":
-            return {
+                params |= {
-                **{f"BUTTON||strip {i} A1": vm.strip[i].A1 for i in range(vm.kind.num_strip)},
+                    **{f"STRIP {i}||A1": vm.strip[i].A1 for i in range(vm.kind.num_strip)},
-                **{f"BUTTON||strip {i} A2": vm.strip[i].A2 for i in range(vm.kind.num_strip)},
+                    **{f"STRIP {i}||A2": vm.strip[i].A2 for i in range(vm.kind.num_strip)},
-                **{f"BUTTON||strip {i} A3": vm.strip[i].A3 for i in range(vm.kind.num_strip)},
+                    **{f"STRIP {i}||A3": vm.strip[i].A3 for i in range(vm.kind.num_strip)},
-                **{f"BUTTON||strip {i} B1": vm.strip[i].B1 for i in range(vm.kind.num_strip)},
+                    **{f"STRIP {i}||B1": vm.strip[i].B1 for i in range(vm.kind.num_strip)},
-                **{f"BUTTON||strip {i} B2": vm.strip[i].B2 for i in range(vm.kind.num_strip)},
+                    **{f"STRIP {i}||B2": vm.strip[i].B2 for i in range(vm.kind.num_strip)},
                 }
             case "potato":
-            return {
+                params |= {
-                **{f"BUTTON||strip {i} A1": vm.strip[i].A1 for i in range(vm.kind.num_strip)},
+                    **{f"STRIP {i}||A1": vm.strip[i].A1 for i in range(vm.kind.num_strip)},
-                **{f"BUTTON||strip {i} A2": vm.strip[i].A2 for i in range(vm.kind.num_strip)},
+                    **{f"STRIP {i}||A2": vm.strip[i].A2 for i in range(vm.kind.num_strip)},
-                **{f"BUTTON||strip {i} A3": vm.strip[i].A3 for i in range(vm.kind.num_strip)},
+                    **{f"STRIP {i}||A3": vm.strip[i].A3 for i in range(vm.kind.num_strip)},
-                **{f"BUTTON||strip {i} A4": vm.strip[i].A4 for i in range(vm.kind.num_strip)},
+                    **{f"STRIP {i}||A4": vm.strip[i].A4 for i in range(vm.kind.num_strip)},
-                **{f"BUTTON||strip {i} A5": vm.strip[i].A5 for i in range(vm.kind.num_strip)},
+                    **{f"STRIP {i}||A5": vm.strip[i].A5 for i in range(vm.kind.num_strip)},
-                **{f"BUTTON||strip {i} B1": vm.strip[i].B1 for i in range(vm.kind.num_strip)},
+                    **{f"STRIP {i}||B1": vm.strip[i].B1 for i in range(vm.kind.num_strip)},
-                **{f"BUTTON||strip {i} B2": vm.strip[i].B2 for i in range(vm.kind.num_strip)},
+                    **{f"STRIP {i}||B2": vm.strip[i].B2 for i in range(vm.kind.num_strip)},
-                **{f"BUTTON||strip {i} B3": vm.strip[i].B3 for i in range(vm.kind.num_strip)},
+                    **{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}||SOLO": vm.strip[i].solo for i in range(vm.kind.num_strip)},
+            **{f"STRIP {i}||MUTE": vm.strip[i].mute for i in range(vm.kind.num_strip)},
+        }
+        return params
+    else:
+        return {
+            **{f"BUS {i}||MONO": vm.bus[i].mono for i in range(vm.kind.num_bus)},
+            **{f"BUS {i}||EQ": vm.bus[i].eq.on for i in range(vm.kind.num_bus)},
+            **{f"BUS {i}||MUTE": vm.bus[i].mute for i in range(vm.kind.num_bus)},
+            **{f"BUS {i}||MODE": vm.bus[i].mode.get() for i in range(vm.kind.num_bus)},
+        }
+
+
+def _make_label_cache(vm) -> dict:
+    return {
+        **{
+            f"STRIP {i}||LABEL": vm.strip[i].label if vm.strip[i].label else f"Hardware Input {i + 1}"
+            for i in range(vm.kind.phys_in)
+        },
+        **{
+            f"STRIP {i}||LABEL": vm.strip[i].label if vm.strip[i].label else f"Virtual Input {i - vm.kind.phys_in + 1}"
+            for i in range(vm.kind.phys_in, vm.kind.phys_in + vm.kind.virt_in)
+        },
+        **{
+            f"BUS {i}||LABEL": vm.bus[i].label if vm.bus[i].label else f"Physical Bus {i + 1}"
+            for i in range(vm.kind.phys_out)
+        },
+        **{
+            f"BUS {i}||LABEL": vm.bus[i].label if vm.bus[i].label else f"Virtual Bus {i - vm.kind.phys_out + 1}"
+            for i in range(vm.kind.phys_out, vm.kind.phys_out + vm.kind.virt_out)
+        },
+    }
+
+
+def _make_patch_asio_cache(vm) -> dict:
+    if vm.kind.name != "basic":
+        return {**{f"ASIO CHECKBOX||{i}": vm.patch.asio[i].get() for i in range(vm.kind.phys_out * 2)}}
+
+
+def _make_patch_insert_cache(vm) -> dict:
+    if vm.kind.name != "basic":
+        return {**{f"INSERT CHECKBOX||{i}": vm.patch.insert[i].on for i in range(vm.kind.num_strip_levels)}}

src/nvda_voicemeeter/nvda.py

@@ -1,4 +1,5 @@
 from .cdll import libc
+from .errors import NVDAVMCAPIError
 
 
 class CBindings:
@@ -10,14 +11,14 @@ class CBindings:
     def call(self, fn, *args, ok=(0,)):
         retval = fn(*args)
         if retval not in ok:
-            raise RuntimeError(f"{fn.__name__} returned {retval}")
+            raise NVDAVMCAPIError(fn.__name__, retval)
         return retval
 
 
 class Nvda(CBindings):
     @property
     def is_running(self):
-        return self.call(self.bind_test_if_running, ok=(0, 1)) == 0
+        return self.call(self.bind_test_if_running) == 0
 
     def speak(self, text):
         self.call(self.bind_speak_text, text)

src/nvda_voicemeeter/parser.py

@@ -1,10 +1,15 @@
-from pyparsing import Group, OneOrMore, Optional, Suppress, Word, alphanums
+from pyparsing import Group, OneOrMore, Optional, Suppress, Word, alphanums, restOfLine
 
 
 class Parser:
     def __init__(self):
         self.widget = Group(OneOrMore(Word(alphanums)))
-        self.token = Suppress("||")
+        self.widget_token = Suppress("||")
         self.identifier = Group(OneOrMore(Word(alphanums)))
-        self.event = OneOrMore(Word(alphanums))
+        self.event = Group(OneOrMore(Word(alphanums)))
-        self.match = self.widget + self.token + self.identifier + Optional(self.token) + Optional(self.event)
+        self.menu_token = Suppress("::")
+        self.match = (
+            self.widget + self.widget_token + self.identifier + Optional(self.widget_token) + Optional(self.event)
+            | self.identifier + self.menu_token + self.event
+            | restOfLine
+        )

src/nvda_voicemeeter/util.py

@@ -0,0 +1,111 @@
+def get_asio_checkbox_index(channel, num) -> int:
+    if channel == 0:
+        return 2 * num - 2
+    return 2 * num - 1
+
+
+def get_insert_checkbox_index(kind, channel, num) -> int:
+    if num <= kind.phys_in:
+        if channel == 0:
+            return 2 * num - 2
+        else:
+            return 2 * num - 1
+    return (2 * kind.phys_in) + (8 * (num - kind.phys_in - 1)) + channel
+
+
+def get_input_device_list(vm) -> list:
+    return ["{type}: {name}".format(**vm.device.input(i)) for i in range(vm.device.ins)]
+
+
+def get_output_device_list(vm) -> list:
+    return ["{type}: {name}".format(**vm.device.output(i)) for i in range(vm.device.outs)]
+
+
+def get_patch_composite_list(kind) -> list:
+    temp = []
+    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")
+    return temp
+
+
+def get_patch_insert_channels() -> list:
+    return [
+        "left",
+        "right",
+        "center",
+        "low frequency effect",
+        "surround left",
+        "surround right",
+        "back left",
+        "back right",
+    ]
+
+
+_patch_insert_channels = get_patch_insert_channels()
+
+
+def get_asio_samples_list() -> list:
+    return [
+        "1024",
+        "768",
+        "704",
+        "640",
+        "576",
+        "512",
+        "480",
+        "448",
+        "441",
+        "416",
+        "384",
+        "352",
+        "320",
+        "288",
+        "256",
+        "224",
+        "192",
+        "160",
+        "128",
+    ]
+
+
+def get_tabs_labels() -> list:
+    return ["Settings", "Physical Strip", "Virtual Strip", "Buses"]
+
+
+def open_context_menu_for_buttonmenu(window, identifier) -> None:
+    element = window[identifier]
+    widget = element.widget
+    x = widget.winfo_rootx()
+    y = widget.winfo_rooty() + widget.winfo_height()
+    element.TKMenu.post(x, y)
+
+
+def get_channel_identifier_list(vm) -> list:
+    identifiers = []
+    for i in range(vm.kind.phys_in):
+        for j in range(2):
+            identifiers.append(f"IN{i + 1} {j}")
+    for i in range(vm.kind.phys_in, vm.kind.phys_in + vm.kind.virt_in):
+        for j in range(8):
+            identifiers.append(f"IN{i + 1} {j}")
+    return identifiers
+
+
+def get_bus_modes() -> list:
+    return [
+        "normal",
+        "amix",
+        "bmix",
+        "repeat",
+        "composite",
+        "tvmix",
+        "upmix21",
+        "upmix41",
+        "upmix61",
+        "centeronly",
+        "lfeonly",
+        "rearonly",
+    ]

src/nvda_voicemeeter/window.py

@@ -1,60 +1,622 @@
+import json
+import logging
+from pathlib import Path
+
 import PySimpleGUI as psg
 
-from .models import _make_cache
+from .builder import Builder
+from .models import (
+    _make_hardware_ins_cache,
+    _make_hardware_outs_cache,
+    _make_label_cache,
+    _make_param_cache,
+    _make_patch_asio_cache,
+    _make_patch_insert_cache,
+)
 from .nvda import Nvda
 from .parser import Parser
+from .util import (
+    _patch_insert_channels,
+    get_asio_checkbox_index,
+    get_bus_modes,
+    get_channel_identifier_list,
+    get_insert_checkbox_index,
+    get_patch_composite_list,
+    open_context_menu_for_buttonmenu,
+)
+
+logger = logging.getLogger(__name__)
+
+psg.theme("Dark Blue 3")
 
 
-class Window(psg.Window):
+class NVDAVMWindow(psg.Window):
+    """Represents the main window of the Voicemeeter NVDA application"""
+
+    SETTINGS = "settings.json"
+
     def __init__(self, title, vm):
         self.vm = vm
         self.kind = self.vm.kind
-        super().__init__(title, self.make_layout(), finalize=True)
+        self.logger = logger.getChild(type(self).__name__)
-        self.cache = _make_cache(self.vm)
+        self.cache = {
+            "hw_ins": _make_hardware_ins_cache(self.vm),
+            "hw_outs": _make_hardware_outs_cache(self.vm),
+            "strip": _make_param_cache(self.vm, "strip"),
+            "bus": _make_param_cache(self.vm, "bus"),
+            "labels": _make_label_cache(self.vm),
+            "asio": _make_patch_asio_cache(self.vm),
+            "insert": _make_patch_insert_cache(self.vm),
+        }
         self.nvda = Nvda()
         self.parser = Parser()
+        self.builder = Builder(self)
+        layout = self.builder.run()
+        super().__init__(title, layout, return_keyboard_events=True, finalize=True)
+        buttonmenu_opts = {"takefocus": 1, "highlightthickness": 1}
+        for i in range(self.kind.phys_in):
+            self[f"HARDWARE IN||{i + 1}"].Widget.config(**buttonmenu_opts)
+        for i in range(self.kind.phys_out):
+            self[f"HARDWARE OUT||A{i + 1}"].Widget.config(**buttonmenu_opts)
+        if self.kind.name != "basic":
+            [self[f"PATCH COMPOSITE||PC{i + 1}"].Widget.config(**buttonmenu_opts) for i in range(self.kind.phys_out)]
+            self["ASIO BUFFER"].Widget.config(**buttonmenu_opts)
+        if self.kind.name != "basic":
+            self["ASIO BUFFER FRAME"].update(visible=False)
+            self["ASIO BUFFER FRAME"].hide_row()
+        self.register_events()
 
     def __enter__(self):
+        settings_path = Path.cwd() / self.SETTINGS
+        if settings_path.exists():
+            try:
+                with open(settings_path, "r") as f:
+                    data = json.load(f)
+                defaultconfig = Path(data["default_config"])
+                if defaultconfig.exists():
+                    self.vm.set("command.load", str(defaultconfig))
+                    self.logger.debug(f"config {defaultconfig} loaded")
+                    self.TKroot.after(
+                        200,
+                        self.nvda.speak,
+                        f"config {defaultconfig.stem} has been loaded",
+                    )
+            except json.JSONDecodeError:
+                self.logger.debug("no data in settings.json. silently continuing...")
+
+        self.vm.init_thread()
+        self.vm.observer.add(self.on_pdirty)
+        self.TKroot.after(1000, self.enable_parameter_updates)
+
         return self
 
+    def enable_parameter_updates(self):
+        self.vm.event.pdirty = True
+
     def __exit__(self, exc_type, exc_value, traceback):
+        self.vm.end_thread()
         self.close()
 
-    def make_layout(self) -> list:
+    def on_pdirty(self):
-        """Builds the window layout step by step"""
+        self.cache = {
+            "hw_ins": _make_hardware_ins_cache(self.vm),
+            "hw_outs": _make_hardware_outs_cache(self.vm),
+            "strip": _make_param_cache(self.vm, "strip"),
+            "bus": _make_param_cache(self.vm, "bus"),
+            "labels": _make_label_cache(self.vm),
+            "asio": _make_patch_asio_cache(self.vm),
+            "insert": _make_patch_insert_cache(self.vm),
+        }
+        for key, value in self.cache["labels"].items():
+            self[key].update(value=value)
+        if self.kind.name != "basic":
+            for key, value in self.cache["asio"].items():
+                identifier, i = key.split("||")
+                partial = get_channel_identifier_list(self.vm)[int(i)]
+                self[f"{identifier}||{partial}"].update(value=value)
+            for key, value in self.cache["insert"].items():
+                identifier, i = key.split("||")
+                partial = get_channel_identifier_list(self.vm)[int(i)]
+                self[f"{identifier}||{partial}"].update(value=value)
 
-        def add_physical_device_opts(layout):
+    def register_events(self):
-            devices = ["{type}: {name}".format(**self.vm.device.output(i)) for i in range(self.vm.device.outs)]
+        """Registers events for widgets"""
-            layout.append(
+
+        # TABS
+        self["tabs"].bind("<FocusIn>", "||FOCUS IN")
+        self.bind("<Control-KeyPress-Tab>", "CTRL-TAB")
+        self.bind("<Control-Shift-KeyPress-Tab>", "CTRL-SHIFT-TAB")
+
+        # Hardware In
+        for i in range(self.vm.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):
+            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)
+
+        # 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")
+
+        # Patch Composite
+        if self.kind.name != "basic":
+            for i in range(self.vm.kind.phys_out):
+                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)
+
+        # Patch Insert
+        if self.kind.name != "basic":
+            for i in range(self.kind.num_strip):
+                if i < self.kind.phys_in:
+                    self[f"INSERT CHECKBOX||IN{i + 1} 0"].bind("<FocusIn>", "||FOCUS IN")
+                    self[f"INSERT CHECKBOX||IN{i + 1} 1"].bind("<FocusIn>", "||FOCUS IN")
+                else:
+                    [self[f"INSERT CHECKBOX||IN{i + 1} {j}"].bind("<FocusIn>", "||FOCUS IN") for j in range(8)]
+
+        # Strip Params
+        for i in range(self.kind.num_strip):
+            for j in range(self.kind.phys_out):
+                self[f"STRIP {i}||A{j + 1}"].bind("<FocusIn>", "||FOCUS IN")
+                self[f"STRIP {i}||A{j + 1}"].bind("<Return>", "||KEY ENTER")
+            for j in range(self.kind.virt_out):
+                self[f"STRIP {i}||B{j + 1}"].bind("<FocusIn>", "||FOCUS IN")
+                self[f"STRIP {i}||B{j + 1}"].bind("<Return>", "||KEY ENTER")
+            if i < self.kind.phys_in:
+                for param in ("MONO", "SOLO", "MUTE"):
+                    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"):
+                    self[f"STRIP {i}||{param}"].bind("<FocusIn>", "||FOCUS IN")
+                    self[f"STRIP {i}||{param}"].bind("<Return>", "||KEY ENTER")
+
+        # Bus Params
+        for i in range(self.kind.num_bus):
+            for param in ("MONO", "EQ", "MUTE", "MODE"):
+                self[f"BUS {i}||{param}"].bind("<FocusIn>", "||FOCUS IN")
+                self[f"BUS {i}||{param}"].bind("<Return>", "||KEY ENTER")
+
+        # ASIO Buffer
+        if self.kind.name != "basic":
+            self["ASIO BUFFER"].bind("<FocusIn>", "||FOCUS IN")
+            self["ASIO BUFFER"].bind("<space>", "||KEY SPACE", propagate=False)
+            self["ASIO BUFFER"].bind("<Return>", "||KEY ENTER", propagate=False)
+
+    def popup_save_as(self, message, title=None, initial_folder=None):
+        layout = [
+            [psg.Text(message)],
             [
-                    psg.Combo(
+                psg.FileSaveAs("Browse", initial_folder=str(initial_folder), file_types=(("XML", ".xml"),)),
-                        devices,
+                psg.Button("Cancel"),
-                        size=(22, 4),
+            ],
-                        expand_x=True,
-                        enable_events=True,
-                        key=f"DEVICE LIST||PHYSOUT {i}",
-                    )
-                    for i in range(self.kind.phys_out)
         ]
+        window = psg.Window(title, layout, finalize=True)
+        window["Browse"].bind("<FocusIn>", "||FOCUS IN")
+        window["Browse"].bind("<Return>", "||KEY ENTER")
+        window["Cancel"].bind("<FocusIn>", "||FOCUS IN")
+        window["Cancel"].bind("<Return>", "||KEY ENTER")
+        filepath = None
+        while True:
+            event, values = window.read()
+            self.logger.debug(f"event::{event}")
+            self.logger.debug(f"values::{values}")
+            if event in (psg.WIN_CLOSED, "Cancel"):
+                break
+            elif event.endswith("||FOCUS IN"):
+                if values["Browse"]:
+                    filepath = values["Browse"]
+                    break
+                label = event.split("||")[0]
+                self.TKroot.after(
+                    200 if label == "Edit" else 1,
+                    self.nvda.speak,
+                    label,
                 )
+            elif event.endswith("||KEY ENTER"):
+                window.find_element_with_focus().click()
+        window.close()
+        if filepath:
+            return Path(filepath)
 
-        upper_layout = list()
+    def popup_rename(self, message, title=None, tab=None):
-        [step(upper_layout) for step in (add_physical_device_opts,)]
+        if tab == "Physical Strip":
-        row0 = psg.Frame("Hardware Out", upper_layout)
+            upper = self.kind.phys_out + 1
+        elif tab == "Virtual Strip":
+            upper = self.kind.virt_out + 1
+        elif tab == "Buses":
+            upper = self.kind.num_bus + 1
 
-        return [[row0]]
+        layout = [
+            [psg.Text(message)],
+            [
+                [
+                    psg.Spin(
+                        list(range(1, upper)), initial_value=1, size=2, enable_events=True, key=f"Index", readonly=True
+                    ),
+                    psg.Input(key="Edit"),
+                ],
+                [psg.Button("Ok"), psg.Button("Cancel")],
+            ],
+        ]
+        window = psg.Window(title, layout, finalize=True)
+        window["Index"].bind("<FocusIn>", "||FOCUS IN")
+        window["Edit"].bind("<FocusIn>", "||FOCUS IN")
+        window["Ok"].bind("<FocusIn>", "||FOCUS IN")
+        window["Ok"].bind("<Return>", "||KEY ENTER")
+        window["Cancel"].bind("<FocusIn>", "||FOCUS IN")
+        window["Cancel"].bind("<Return>", "||KEY ENTER")
+        data = {}
+        while True:
+            event, values = window.read()
+            self.logger.debug(f"event::{event}")
+            self.logger.debug(f"values::{values}")
+            if event in (psg.WIN_CLOSED, "Cancel"):
+                break
+            elif event.endswith("||KEY ENTER"):
+                window.find_element_with_focus().click()
+            elif event == "Index":
+                val = values["Index"]
+                self.nvda.speak(f"Index {val}")
+            elif event.endswith("||FOCUS IN"):
+                if event.startswith("Index"):
+                    val = values["Index"]
+                    self.nvda.speak(f"Index {val}")
+                else:
+                    self.nvda.speak(event.split("||")[0])
+            elif event == "Ok":
+                data = values
+                break
+
+        window.close()
+        return data
 
     def run(self):
-        """Runs the main window until an Close/Exit event"""
+        """
+        Parses the event string and matches it to events
+
+        Main thread will shutdown once a close or exit event occurs
+        """
+
         while True:
             event, values = self.read()
+            self.logger.debug(f"event::{event}")
+            self.logger.debug(f"values::{values}")
             if event in (psg.WIN_CLOSED, "Exit"):
                 break
-            match self.parser.match.parseString(event):
+            elif event == "tabs":
+                self.nvda.speak(f"tab {values['tabs']}")
+
+            match parsed_cmd := self.parser.match.parseString(event):
+                # Focus tabgroup
+                case ["CTRL-TAB"] | ["CTRL-SHIFT-TAB"]:
+                    self["tabs"].set_focus()
+
+                # Rename popups
+                case ["F2:113"]:
+                    tab = values["tabs"]
+                    if tab in ("Physical Strip", "Virtual Strip", "Buses"):
+                        data = self.popup_rename("Label", title=f"Rename {tab}", tab=tab)
+                        if not data:  # cancel was pressed
+                            continue
+                        index = int(data["Index"]) - 1
+                        match tab:
+                            case "Physical Strip":
+                                label = data.get("Edit") or f"Hardware Input {index + 1}"
+                                self.vm.strip[index].label = label
+                                self[f"STRIP {index}||LABEL"].update(value=label)
+                                self.cache["labels"][f"STRIP {index}||LABEL"] = label
+                            case "Virtual Strip":
+                                label = data.get("Edit") or f"Virtual Input {index + 1}"
+                                self.vm.strip[index].label = label
+                                self[f"STRIP {index}||LABEL"].update(value=label)
+                                self.cache["labels"][f"STRIP {index}||LABEL"] = label
+                            case "Buses":
+                                if index < self.kind.phys_out:
+                                    label = data.get("Edit") or f"Physical Bus {index + 1}"
+                                else:
+                                    label = data.get("Edit") or f"Virtual Bus {index - self.kind.phys_out + 1}"
+                                self.vm.bus[index].label = label
+                                self[f"BUS {index}||LABEL"].update(value=label)
+                                self.cache["labels"][f"BUS {index}||LABEL"] = label
+
+                # Menus
+                case [["Restart", "Audio", "Engine"], ["MENU"]]:
+                    self.perform_long_operation(self.vm.command.restart, "ENGINE RESTART||END")
+                case [["ENGINE", "RESTART"], ["END"]]:
+                    self.TKroot.after(
+                        200,
+                        self.nvda.speak,
+                        "Audio Engine restarted",
+                    )
+                case [["Save", "Settings"], ["MENU"]]:
+                    initial_folder = Path.home() / "Documents" / "Voicemeeter"
+                    if filepath := self.popup_save_as(
+                        "Open the file browser", title="Save As", initial_folder=initial_folder
+                    ):
+                        self.vm.set("command.save", str(filepath))
+                        self.logger.debug(f"saving config file to {filepath}")
+                        self.TKroot.after(
+                            200,
+                            self.nvda.speak,
+                            f"config file {filepath.stem} has been saved",
+                        )
+                case [["Load", "Settings"], ["MENU"]]:
+                    initial_folder = Path.home() / "Documents" / "Voicemeeter"
+                    if filepath := psg.popup_get_file(
+                        "Filename",
+                        title="Load Settings",
+                        initial_folder=initial_folder,
+                        no_window=True,
+                        file_types=(("XML", ".xml"),),
+                    ):
+                        filepath = Path(filepath)
+                        self.vm.set("command.load", str(filepath))
+                        self.logger.debug(f"loading config file from {filepath}")
+                        self.TKroot.after(
+                            200,
+                            self.nvda.speak,
+                            f"config file {filepath.stem} has been loaded",
+                        )
+                case [["Load", "Settings", "on", "Startup"], ["MENU"]]:
+                    initial_folder = Path.home() / "Documents" / "Voicemeeter"
+                    if filepath := psg.popup_get_file(
+                        "Filename",
+                        title="Load Settings",
+                        initial_folder=initial_folder,
+                        no_window=True,
+                        file_types=(("XML", ".xml"),),
+                    ):
+                        filepath = Path(filepath)
+                        with open(self.SETTINGS, "w") as f:
+                            json.dump({"default_config": str(filepath)}, f)
+                        self.TKroot.after(
+                            200,
+                            self.nvda.speak,
+                            f"config {filepath.stem} set as default on startup",
+                        )
+                    else:
+                        with open(self.SETTINGS, "wb") as f:
+                            f.truncate()
+                        self.logger.debug("default bin was truncated")
+
+                # Tabs
+                case [["tabs"], ["FOCUS", "IN"]]:
+                    self.nvda.speak(f"tab {values['tabs']}")
+
+                # Hardware In
+                case [["HARDWARE", "IN"], [key]]:
+                    selection = values[f"HARDWARE IN||{key}"]
+                    index = int(key) - 1
+                    match selection.split(":"):
+                        case [device_name]:
+                            setattr(self.vm.strip[index].device, "wdm", "")
+                            self.TKroot.after(200, self.nvda.speak, f"HARDWARE IN {key} device selection removed")
+                        case [driver, device_name]:
+                            setattr(self.vm.strip[index].device, driver, device_name.strip())
+                            phonetic = {"mme": "em em e"}
+                            self.TKroot.after(
+                                200,
+                                self.nvda.speak,
+                                f"HARDWARE IN {key} set {phonetic.get(driver, driver)} {device_name}",
+                            )
+                case [["HARDWARE", "IN"], [key], ["FOCUS", "IN"]]:
+                    self.nvda.speak(f"HARDWARE INPUT {key} {self.cache['hw_ins'][f'HARDWARE IN||{key}']}")
+                case [["HARDWARE", "IN"], [key], ["KEY", "SPACE" | "ENTER"]]:
+                    open_context_menu_for_buttonmenu(self, f"HARDWARE IN||{key}")
+
+                # Hardware out
+                case [["HARDWARE", "OUT"], [key]]:
+                    selection = values[f"HARDWARE OUT||{key}"]
+                    index = int(key[1]) - 1
+                    match selection.split(":"):
+                        case [device_name]:
+                            setattr(self.vm.bus[index].device, "wdm", "")
+                            self.TKroot.after(200, self.nvda.speak, f"HARDWARE OUT {key} device selection removed")
+                        case [driver, device_name]:
+                            setattr(self.vm.bus[index].device, driver, device_name.strip())
+                            phonetic = {"mme": "em em e"}
+                            self.TKroot.after(
+                                200,
+                                self.nvda.speak,
+                                f"HARDWARE OUT {key} set {phonetic.get(driver, driver)} {device_name}",
+                            )
+                case [["HARDWARE", "OUT"], [key], ["FOCUS", "IN"]]:
+                    self.nvda.speak(f"HARDWARE OUT {key} {self.cache['hw_outs'][f'HARDWARE OUT||{key}']}")
+                case [["HARDWARE", "OUT"], [key], ["KEY", "SPACE" | "ENTER"]]:
+                    open_context_menu_for_buttonmenu(self, f"HARDWARE OUT||{key}")
+
+                # Patch ASIO
+                case [["ASIO", "CHECKBOX"], [in_num, channel]]:
+                    index = get_asio_checkbox_index(int(channel), int(in_num[-1]))
+                    val = values[f"ASIO CHECKBOX||{in_num} {channel}"]
+                    self.vm.patch.asio[index].set(val)
+                    channel = ("left", "right")[int(channel)]
+                    self.nvda.speak(f"Patch ASIO {in_num} {channel} set to {val}")
+                case [["ASIO", "CHECKBOX"], [in_num, channel], ["FOCUS", "IN"]]:
+                    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(get_patch_composite_list(self.kind).index(val) + 1)
+                    self.TKroot.after(200, self.nvda.speak, f"PATCH COMPOSITE {key[-1]} set {val}")
+                case [["PATCH", "COMPOSITE"], [key], ["FOCUS", "IN"]]:
+                    if values[f"PATCH COMPOSITE||{key}"]:
+                        val = values[f"PATCH COMPOSITE||{key}"]
+                    else:
+                        index = int(key[-1]) - 1
+                        val = get_patch_composite_list(self.kind)[self.vm.patch.composite[index].get() - 1]
+                    self.nvda.speak(f"Patch COMPOSITE {key[-1]} {val}")
+                case [["PATCH", "COMPOSITE"], [key], ["KEY", "SPACE" | "ENTER"]]:
+                    open_context_menu_for_buttonmenu(self, f"PATCH COMPOSITE||{key}")
+
+                # Patch INSERT
+                case [["INSERT", "CHECKBOX"], [in_num, channel]]:
+                    index = get_insert_checkbox_index(
+                        self.kind,
+                        int(channel),
+                        int(in_num[-1]),
+                    )
+                    val = values[f"INSERT CHECKBOX||{in_num} {channel}"]
+                    self.vm.patch.insert[index].on = val
+                    self.nvda.speak(
+                        f"PATCH INSERT {in_num} {_patch_insert_channels[int(channel)]} set to {'on' if val else 'off'}"
+                    )
+                case [["INSERT", "CHECKBOX"], [in_num, channel], ["FOCUS", "IN"]]:
+                    index = get_insert_checkbox_index(
+                        self.kind,
+                        int(channel),
+                        int(in_num[-1]),
+                    )
+                    val = values[f"INSERT CHECKBOX||{in_num} {channel}"]
+                    channel = _patch_insert_channels[int(channel)]
+                    num = int(in_num[-1])
+                    self.nvda.speak(f"Patch INSERT IN#{num} {channel} {'on' if val else 'off'}")
+
+                # ASIO Buffer
+                case ["ASIO BUFFER"]:
+                    if values[event] == "Default":
+                        val = 0
+                    else:
+                        val = values[event]
+                    self.vm.option.buffer("asio", val)
+                    self.TKroot.after(200, self.nvda.speak, f"ASIO BUFFER {val if val else 'default'}")
+                case [["ASIO", "BUFFER"], ["FOCUS", "IN"]]:
+                    val = int(self.vm.get("option.buffer.asio"))
+                    self.nvda.speak(f"ASIO BUFFER {val if val else 'default'}")
+                case [["ASIO", "BUFFER"], ["KEY", "SPACE" | "ENTER"]]:
+                    open_context_menu_for_buttonmenu(self, "ASIO BUFFER")
+
+                # Strip Params
+                case [["STRIP", index], [param]]:
+                    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 + self.kind.virt_in - 2:
+                                actual = "k"
+                            else:
+                                actual = "mc"
+                            phonetic = {"k": "karaoke"}
+                            if actual == "k":
+                                next_val = self.vm.strip[int(index)].k + 1
+                                if next_val == 4:
+                                    next_val = 0
+                                setattr(self.vm.strip[int(index)], actual, next_val)
+                                self.cache["strip"][f"STRIP {index}||{param}"] = next_val
+                                self.nvda.speak(
+                                    f"{label} {phonetic.get(actual, actual)} {['off', 'k m', 'k 1', 'k 2'][next_val]}"
+                                )
+                            else:
+                                val = not self.cache["strip"][f"STRIP {index}||{param}"]
+                                setattr(self.vm.strip[int(index)], actual, val)
+                                self.cache["strip"][f"STRIP {index}||{param}"] = val
+                                self.nvda.speak(f"{label} {phonetic.get(actual, actual)} {'on' if val else 'off'}")
                         case _:
-                    pass
+                            val = not self.cache["strip"][f"STRIP {index}||{param}"]
+                            setattr(self.vm.strip[int(index)], param if param[0] in ("A", "B") else param.lower(), val)
+                            self.cache["strip"][f"STRIP {index}||{param}"] = val
+                            self.nvda.speak(f"{label} {param} {'on' if val else 'off'}")
+                case [["STRIP", index], [param], ["FOCUS", "IN"]]:
+                    val = self.cache["strip"][f"STRIP {index}||{param}"]
+                    match param:
+                        case "MONO":
+                            if int(index) < self.kind.phys_in:
+                                actual = param.lower()
+                            elif int(index) == self.kind.phys_in + self.kind.virt_in - 2:
+                                actual = "k"
+                            else:
+                                actual = "mc"
+                        case _:
+                            actual = param
+                    phonetic = {"k": "karaoke"}
+                    label = self.cache["labels"][f"STRIP {index}||LABEL"]
+                    if actual == "k":
+                        self.nvda.speak(
+                            f"{label} {phonetic.get(actual, actual)} {['off', 'k m', 'k 1', 'k 2'][self.cache['strip'][f'STRIP {int(index)}||{param}']]}"
+                        )
+                    else:
+                        self.nvda.speak(f"{label} {phonetic.get(actual, actual)} {'on' if val else 'off'}")
+                case [["STRIP", index], [param], ["KEY", "ENTER"]]:
+                    self.find_element_with_focus().click()
+
+                # Bus Params
+                case [["BUS", index], [param]]:
+                    val = self.cache["bus"][event]
+                    label = self.cache["labels"][f"BUS {index}||LABEL"]
+                    match param:
+                        case "EQ":
+                            val = not val
+                            self.vm.bus[int(index)].eq.on = val
+                            self.cache["bus"][event] = val
+                            self.TKroot.after(
+                                200,
+                                self.nvda.speak,
+                                f"{label} bus {param} {'on' if val else 'off'}",
+                            )
+                        case "MONO" | "MUTE":
+                            val = not val
+                            setattr(self.vm.bus[int(index)], param.lower(), val)
+                            self.cache["bus"][event] = val
+                            self.TKroot.after(
+                                200,
+                                self.nvda.speak,
+                                f"{label} bus {param} {'on' if val else 'off'}",
+                            )
+                        case "MODE":
+                            bus_modes = get_bus_modes()
+                            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
+                            self.TKroot.after(
+                                200,
+                                self.nvda.speak,
+                                f"{label} bus mode {phonetic.get(next_bus, next_bus)}",
+                            )
+                case [["BUS", index], [param], ["FOCUS", "IN"]]:
+                    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}")
+                    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()
+
+                # Unknown
+                case _:
+                    self.logger.debug(f"Unknown event {event}")
+            self.logger.debug(f"parsed::{parsed_cmd}")
 
 
-def request_window_object(title, vm):
+def request_window_object(kind_id, vm):
-    WINDOW_cls = Window
+    NVDAVMWindow_cls = NVDAVMWindow
-    return WINDOW_cls(title, vm)
+    return NVDAVMWindow_cls(f"Voicemeeter {kind_id.capitalize()} NVDA", vm)