adds sliders to on_pdirty

bump to b2
bump to 0.2.1.b1
2026-04-07 18:03:35 +00:00 · 2023-09-17 14:49:42 +01:00 · 2023-09-17 12:36:15 +01:00 · 2023-09-17 12:23:04 +01:00 · 2023-09-17 12:09:38 +01:00 · 2023-09-17 12:07:14 +01:00
9 changed files with 950 additions and 249 deletions
--- a/README.md
+++ b/README.md
@@ -6,7 +6,7 @@

 A remote control app for [Voicemeeter][voicemeeter], designed to be used with the [NVDA screen reader][nvda].

-This is still an early release but it should be usable.
+For an outline of this projects goals see the [SPECIFICATION][spec].

 <img src="./img/settings.png" width=350 alt="Image of Voicemeeter NVDA app settings tab">

@@ -18,11 +18,31 @@ This is still an early release but it should be usable.

 ### Installation

-First clone the source files from this repository
+#### `From Source`

-`git clone https://github.com/onyx-and-iris/nvda-voicemeeter.git`
+First clone the source files from this repository and install the dependencies.

-Then download the [Controller Client][controller_client] and place the files into the directory `controllerClient`.
+```
+git clone https://github.com/onyx-and-iris/nvda-voicemeeter.git
+cd nvda-voicemeeter
+pip install .
+```
+
+Then download the [Controller Client][controller_client] and place the dll files into the directory `controllerClient`.
+
+Your directory structure should look like this:
+
+├── `controllerClient/`
+
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;├── `x64/`
+
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;├── nvdaControllerClient64.dll
+
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;├── `x86/`
+
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;├── nvdaControllerClient32.dll
+
+#### `From Releases`

 If you want to get started quickly and easily I have uploaded some compiled versions of the app in the [Releases][releases] section.

@@ -42,7 +62,7 @@ with voicemeeterlib.api(KIND_ID, sync=True) as vm:
        window.run()
 ```

-### `KIND_ID`
+### KIND_ID

 May be one of the following:

@@ -52,24 +72,38 @@ May be one of the following:

 ### Use

-The app presents four tabs `Settings`, `Physical Strip`, `Virtual Strip` and `Buses`. Navigate between the tabs with `Control + TAB` and `Control + SHIFT + TAB`.
+#### `Tabs`
+
+The app presents four tabs `Settings`, `Physical Strip`, `Virtual Strip` and `Buses`. Navigate between the tabs with `Control + TAB` and `Control + SHIFT + TAB` or once focused on any tab, `Left` and `Right` arrow keys.

 All controls within the tabs may be navigated between using `TAB`.

+#### `Settings`
+
 The following controls offer context menus accessed by pressing `SPACE` or `ENTER`:

 - Hardware In
 - Hardware Out
 - Patch Composite

+Press `ESCAPE` to exit any context menu.
+
 All other buttons can be triggered by pressing `SPACE` or `ENTER`.

 To adjust Patch Asio Inputs to Strips and Patch Insert values use `UP` and `DOWN` arrows when in focus.

+To access Advanced Settings you may press the Advanced Settings button or use `Control + A` when in the `Settings` tab.
+
+#### `Strip/Bus`
+
 To rename a strip/bus channel navigate to the relevant tab, then press `F2`. This will open a popup window where you can set the channel index (with a spinbox) and set the new label using a text input box.
+
 Pressing the `OK` button with an empty text input will clear the label. In this case the label will be read as a default value for that channel. For example, if the leftmost Strip label were cleared, the screen reader will now read `Hardware Input 1`.
+
 Pressing `Cancel` will close the popup window with no affect on the label.

+#### `Menu`
+
 A single menu item `Voicemeeter` can be opened using `Alt` and then `v`. The menu allows you to:

 - Restart Voicemeeter audio engine
@@ -84,6 +118,17 @@ The `Save Settings` option opens a popup window with two buttons, `Browse` and `

 If you have any questions/suggestions feel free to raise an issue or open a new discussion.

+### Special Thanks
+
+[Mario Loreti](https://www.marioloreti.net/en/) for his help in testing and offering feedback during development.
+
+[NVAccess](https://www.nvaccess.org/) for creating the open source NVDA screen reader and its controller client.
+
+[Vincent Burel](https://github.com/vburel2018) for creating Voicemeeter and its SDK.
+
+[PySimpleGUI](https://github.com/PySimpleGUI) team for creating an awesome GUI framework.
+
+[spec]: ./SPECIFICATION.md
 [voicemeeter]: https://voicemeeter.com/
 [nvda]: https://www.nvaccess.org/
 [controller_client]: https://github.com/nvaccess/nvda/tree/master/extras/controllerClient
--- a/SPECIFICATION.md
+++ b/SPECIFICATION.md
@@ -0,0 +1,30 @@
+# Software Specification
+
+## Description
+
+A remote control utility for Voicemeeter designed to be used with the NVDA screen reader.
+
+## Requirements
+
+#### Functional Goals
+
+- Parameter updates caused by user input should be read back to the user via the screen reader.
+- When focusing a control the current value for that control should be read back to the user.
+- The application should scale correctly according to each kind of Voicemeeter (basic, banana, potato). This means the following:
+  - Correct number of strips/buses.
+  - Correct number of bus assignments for each strip.
+  - Where certain controls are valid for one kind they may not be for another.
+- Where possible set limits on data entry and keep controls appropriate for the type of parameter.
+
+#### Accessibility Goals
+
+- Every control must be usable with a keyboard.
+- Navigation around the application must be doable with a keyboard.
+- Should use standard Windows controls only.
+
+## Limitations
+
+- May not cover 100% of the Voicemeeter GUI, for example the many EQ parameters.
+- Only designed to work with the NVDA screen reader. Other screen readers not supported.
+- Only the main Voicemeeter GUI supported by this application. No support for Matrix or other Voicemeeter products.
+- Runs on Python version 3.10 or greater.
--- a/pdm.lock
+++ b/pdm.lock
@@ -6,7 +6,7 @@ groups = ["default", "build", "lint", "test"]
 cross_platform = true
 static_urls = false
 lock_version = "4.3"
-content_hash = "sha256:9051151ac4ac0edefdfaf52faa91dbff89d8bbc942a6ffa61b6ec6fee502aa8a"
+content_hash = "sha256:ba53368b628b713c9cf4eb54e6f5c5c4af207c8e247d473417e4c2a4b47f645d"

 [[package]]
 name = "altgraph"
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,6 +1,6 @@
 [project]
 name = "nvda_voicemeeter"
-version = "0.1.2"
+version = "0.2.1b2"
 description = "A Voicemeeter app compatible with NVDA"
 authors = [
    { name = "onyx-and-iris", email = "code@onyxandiris.online" },
@@ -10,7 +10,7 @@ dependencies = [
    "pyparsing>=3.1.1",
    "voicemeeter-api>=2.4.9",
 ]
-requires-python = ">=3.10,<3.11"
+requires-python = ">=3.10,<3.12"
 readme = "README.md"

 [project.license]
--- a/src/nvda_voicemeeter/builder.py
+++ b/src/nvda_voicemeeter/builder.py
@@ -1,14 +1,7 @@
 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,
-)
+from . import util
+from .compound import LabelSlider


 class Builder:
@@ -27,6 +20,7 @@ class Builder:
            steps = (
                self.make_tab0_row0,
                self.make_tab0_row1,
+                self.make_tab0_row5,
            )
        else:
            steps = (
@@ -40,25 +34,61 @@ class Builder:
        for step in steps:
            layout0.append([step()])

-        layout1 = []
-        steps = (self.make_tab1_rows,)
+        layout1_1 = []
+        steps = (self.make_tab1_button_rows,)
        for step in steps:
-            layout1.append([step()])
-
-        layout2 = []
-        steps = (self.make_tab2_rows,)
+            layout1_1.append([step()])
+        layout1_2 = []
+        steps = (self.make_tab1_slider_rows,)
        for step in steps:
-            layout2.append([step()])
+            layout1_2.append([step()])

-        layout3 = []
-        steps = (self.make_tab3_rows,)
+        layout2_1 = []
+        steps = (self.make_tab2_button_rows,)
        for step in steps:
-            layout3.append([step()])
+            layout2_1.append([step()])
+        layout2_2 = []
+        steps = (self.make_tab2_slider_rows,)
+        for step in steps:
+            layout2_2.append([step()])

-        layouts = [layout0, layout1, layout2, layout3]
+        layout3_1 = []
+        steps = (self.make_tab3_button_rows,)
+        for step in steps:
+            layout3_1.append([step()])
+        layout3_2 = []
+        steps = (self.make_tab3_slider_rows,)
+        for step in steps:
+            layout3_2.append([step()])

-        tabs = [psg.Tab(identifier, layouts[i], key=identifier) for i, identifier in enumerate(get_tabs_labels())]
-        tab_group = psg.TabGroup([tabs], change_submits=True, key="tabs")
+        def _make_inner_tabgroup(layouts, identifier) -> psg.TabGroup:
+            inner_layout = []
+            for i, tabname in enumerate(("buttons", "sliders")):
+                inner_layout.append([psg.Tab(tabname.capitalize(), layouts[i], key=f"tab||{identifier}||{tabname}")])
+            return psg.TabGroup(
+                inner_layout,
+                change_submits=True,
+                enable_events=True,
+                key=f"tabgroup||{identifier}",
+            )
+
+        def _make_tabs(identifier) -> psg.Tab:
+            match identifier:
+                case "Settings":
+                    return psg.Tab("Settings", layout0, key="tab||Settings")
+                case "Physical Strip":
+                    tabgroup = _make_inner_tabgroup((layout1_1, layout1_2), identifier)
+                case "Virtual Strip":
+                    tabgroup = _make_inner_tabgroup((layout2_1, layout2_2), identifier)
+                case "Buses":
+                    tabgroup = _make_inner_tabgroup((layout3_1, layout3_2), identifier)
+            return psg.Tab(identifier, [[tabgroup]], key=f"tab||{identifier}")
+
+        tabs = []
+        for tab in util.get_tabs_labels():
+            tabs.append(_make_tabs(tab))
+
+        tab_group = psg.TabGroup([tabs], change_submits=True, enable_events=True, key="tabgroup")

        return [[menu], [tab_group]]

@@ -80,7 +110,7 @@ class Builder:
        """tab0 row0 represents hardware ins"""

        def add_physical_device_opts(layout):
-            devices = get_input_device_list(self.vm)
+            devices = util.get_input_device_list(self.vm)
            devices.append("- remove device selection -")
            layout.append(
                [
@@ -94,7 +124,7 @@ class Builder:
                ]
            )

-        hardware_in = list()
+        hardware_in = []
        [step(hardware_in) for step in (add_physical_device_opts,)]
        return psg.Frame("Hardware In", hardware_in)

@@ -102,8 +132,6 @@ class Builder:
        """tab0 row1 represents hardware outs"""

        def add_physical_device_opts(layout):
-            devices = get_output_device_list(self.vm)
-            devices.append("- remove device selection -")
            if self.kind.name == "basic":
                num_outs = self.kind.phys_out + self.kind.virt_out
            else:
@@ -113,14 +141,14 @@ class Builder:
                    psg.ButtonMenu(
                        f"A{i + 1}",
                        size=(6, 3),
-                        menu_def=["", devices],
+                        menu_def=["", util.get_output_device_list(i, self.vm)],
                        key=f"HARDWARE OUT||A{i + 1}",
                    )
                    for i in range(num_outs)
                ]
            )

-        hardware_out = list()
+        hardware_out = []
        [step(hardware_out) for step in (add_physical_device_opts,)]
        return psg.Frame("Hardware Out", hardware_out)

@@ -133,7 +161,7 @@ class Builder:
                [
                    psg.Spin(
                        nums,
-                        initial_value=self.window.cache["asio"][f"ASIO CHECKBOX||{get_asio_checkbox_index(0, i)}"],
+                        initial_value=self.window.cache["asio"][f"ASIO CHECKBOX||{util.get_asio_checkbox_index(0, i)}"],
                        size=2,
                        enable_events=True,
                        key=f"ASIO CHECKBOX||IN{i} 0",
@@ -144,7 +172,7 @@ class Builder:
                [
                    psg.Spin(
                        nums,
-                        initial_value=self.window.cache["asio"][f"ASIO CHECKBOX||{get_asio_checkbox_index(1, i)}"],
+                        initial_value=self.window.cache["asio"][f"ASIO CHECKBOX||{util.get_asio_checkbox_index(1, i)}"],
                        size=2,
                        enable_events=True,
                        key=f"ASIO CHECKBOX||IN{i} 1",
@@ -152,7 +180,7 @@ class Builder:
                ],
            )

-        inner = list()
+        inner = []
        asio_checkboxlists = ([] for _ in range(self.kind.phys_out))
        for i, checkbox_list in enumerate(asio_checkboxlists):
            [step(checkbox_list, i + 1) for step in (add_asio_checkboxes,)]
@@ -165,7 +193,7 @@ class Builder:
        """tab0 row3 represents patch composite"""

        def add_physical_device_opts(layout):
-            outputs = get_patch_composite_list(self.vm.kind)
+            outputs = util.get_patch_composite_list(self.vm.kind)
            layout.append(
                [
                    psg.ButtonMenu(
@@ -178,7 +206,7 @@ class Builder:
                ]
            )

-        hardware_out = list()
+        hardware_out = []
        [step(hardware_out) for step in (add_physical_device_opts,)]
        return psg.Frame("PATCH COMPOSITE", hardware_out)

@@ -192,7 +220,7 @@ class Builder:
                        [
                            psg.Checkbox(
                                text=channel,
-                                default=self.vm.patch.insert[get_insert_checkbox_index(self.kind, j, i)].on,
+                                default=self.vm.patch.insert[util.get_insert_checkbox_index(self.kind, j, i)].on,
                                enable_events=True,
                                key=f"INSERT CHECKBOX||IN{i} {j}",
                            )
@@ -205,7 +233,7 @@ class Builder:
                    [
                        psg.Checkbox(
                            text=channel,
-                            default=self.vm.patch.insert[get_insert_checkbox_index(self.kind, j, i)].on,
+                            default=self.vm.patch.insert[util.get_insert_checkbox_index(self.kind, j, i)].on,
                            enable_events=True,
                            key=f"INSERT CHECKBOX||IN{i} {j}",
                        )
@@ -213,8 +241,8 @@ class Builder:
                    ],
                )

-        asio_checkboxes = list()
-        inner = list()
+        asio_checkboxes = []
+        inner = []
        checkbox_lists = ([] for _ in range(self.kind.num_strip))
        for i, checkbox_list in enumerate(checkbox_lists):
            if i < self.kind.phys_in:
@@ -228,27 +256,23 @@ class Builder:
        return psg.Frame("PATCH INSERT", asio_checkboxes)

    def make_tab0_row5(self) -> psg.Frame:
-        """tab0 row5 represents asio buffer"""
-
-        samples = get_asio_samples_list()
-        samples.append("Default")
+        """tab0 row5 represents advanced settings"""

        return psg.Frame(
-            "ASIO BUFFER",
+            "ADVANCED SETTINGS",
            [
                [
-                    psg.ButtonMenu(
-                        "ASIO BUFFER",
-                        size=(14, 2),
-                        menu_def=["", samples],
-                        key="ASIO BUFFER",
+                    psg.Button(
+                        "ADVANCED SETTINGS",
+                        size=(20, 2),
+                        key="ADVANCED SETTINGS",
                    )
-                ]
                ],
-            key="ASIO BUFFER FRAME",
+            ],
+            key="ADVANCED SETTINGS FRAME",
        )

-    def make_tab1_row(self, i) -> psg.Frame:
+    def make_tab1_button_row(self, i) -> psg.Frame:
        """tab1 row represents a strip's outputs (A1-A5, B1-B3)"""

        def add_strip_outputs(layout):
@@ -272,15 +296,64 @@ class Builder:
                ],
            )

-        outputs = list()
+        outputs = []
        [step(outputs) for step in (add_strip_outputs,)]
        return psg.Frame(self.window.cache["labels"][f"STRIP {i}||LABEL"], outputs, key=f"STRIP {i}||LABEL")

-    def make_tab1_rows(self) -> psg.Frame:
-        layout = [[self.make_tab1_row(i)] for i in range(self.kind.phys_in)]
+    def make_tab1_button_rows(self) -> psg.Frame:
+        layout = [[self.make_tab1_button_row(i)] for i in range(self.kind.phys_in)]
        return psg.Frame(None, layout, border_width=0)

-    def make_tab2_row(self, i) -> psg.Frame:
+    def make_tab1_slider_row(self, i) -> psg.Frame:
+        def add_gain_slider(layout):
+            layout.append(
+                [
+                    psg.Text("Gain"),
+                    psg.Slider(
+                        range=(-60, 12),
+                        default_value=self.vm.strip[i].gain,
+                        resolution=0.1,
+                        disable_number_display=True,
+                        expand_x=True,
+                        enable_events=True,
+                        orientation="horizontal",
+                        key=f"STRIP {i}||SLIDER GAIN",
+                    ),
+                ]
+            )
+
+        def add_param_sliders(layout):
+            layout.append([LabelSlider(self.window, i, param) for param in util.get_slider_params(i, self.vm)])
+
+        def add_limit_slider(layout):
+            layout.append(
+                [
+                    psg.Text("Limit"),
+                    psg.Slider(
+                        range=(-40, 12),
+                        default_value=self.vm.strip[i].limit,
+                        resolution=0.1,
+                        disable_number_display=True,
+                        expand_x=True,
+                        enable_events=True,
+                        orientation="horizontal",
+                        key=f"STRIP {i}||SLIDER LIMIT",
+                    ),
+                ]
+            )
+
+        layout = []
+        steps = (add_gain_slider, add_param_sliders)
+        if self.kind.name in ("banana", "potato"):
+            steps += (add_limit_slider,)
+        [step(layout) for step in steps]
+        return psg.Frame(self.window.cache["labels"][f"STRIP {i}||LABEL"], layout, key=f"STRIP {i}||LABEL||SLIDER")
+
+    def make_tab1_slider_rows(self) -> psg.Frame:
+        layout = [[self.make_tab1_slider_row(i)] for i in range(self.kind.phys_in)]
+        return psg.Frame(None, layout, border_width=0)
+
+    def make_tab2_button_row(self, i) -> psg.Frame:
        """tab2 row represents a strip's outputs (A1-A5, B1-B3)"""

        def add_strip_outputs(layout):
@@ -313,15 +386,77 @@ class Builder:
                    ],
                )

-        outputs = list()
+        outputs = []
        [step(outputs) for step in (add_strip_outputs,)]
        return psg.Frame(self.window.cache["labels"][f"STRIP {i}||LABEL"], outputs, key=f"STRIP {i}||LABEL")

-    def make_tab2_rows(self) -> psg.Frame:
-        layout = [[self.make_tab2_row(i)] for i in range(self.kind.phys_in, self.kind.phys_in + self.kind.virt_in)]
+    def make_tab2_button_rows(self) -> psg.Frame:
+        layout = [
+            [self.make_tab2_button_row(i)] for i in range(self.kind.phys_in, self.kind.phys_in + self.kind.virt_in)
+        ]
        return psg.Frame(None, layout, border_width=0)

-    def make_tab3_row(self, i) -> psg.Frame:
+    def make_tab2_slider_row(self, i) -> psg.Frame:
+        def add_gain_slider(layout):
+            layout.append(
+                [
+                    psg.Text("Gain"),
+                    psg.Slider(
+                        range=(-60, 12),
+                        default_value=self.vm.strip[i].gain,
+                        resolution=0.1,
+                        disable_number_display=True,
+                        expand_x=True,
+                        enable_events=True,
+                        orientation="horizontal",
+                        key=f"STRIP {i}||SLIDER GAIN",
+                    ),
+                ]
+            )
+
+        def add_param_sliders(layout):
+            if self.kind.name in ("basic", "banana"):
+                for param in util.get_slider_params(i, self.vm):
+                    layout.append([LabelSlider(self.window, i, param, range_=(-12, 12))])
+            else:
+                layout.append(
+                    [
+                        LabelSlider(self.window, i, param, range_=(-12, 12))
+                        for param in util.get_slider_params(i, self.vm)
+                    ]
+                )
+
+        def add_limit_slider(layout):
+            layout.append(
+                [
+                    psg.Text("Limit"),
+                    psg.Slider(
+                        range=(-40, 12),
+                        default_value=self.vm.strip[i].limit,
+                        resolution=0.1,
+                        disable_number_display=True,
+                        expand_x=True,
+                        enable_events=True,
+                        orientation="horizontal",
+                        key=f"STRIP {i}||SLIDER LIMIT",
+                    ),
+                ]
+            )
+
+        layout = []
+        steps = (add_gain_slider, add_param_sliders)
+        if self.kind.name in ("banana", "potato"):
+            steps += (add_limit_slider,)
+        [step(layout) for step in steps]
+        return psg.Frame(self.window.cache["labels"][f"STRIP {i}||LABEL"], layout, key=f"STRIP {i}||LABEL||SLIDER")
+
+    def make_tab2_slider_rows(self) -> psg.Frame:
+        layout = [
+            [self.make_tab2_slider_row(i)] for i in range(self.kind.phys_in, self.kind.phys_in + self.kind.virt_in)
+        ]
+        return psg.Frame(None, layout, border_width=0)
+
+    def make_tab3_button_row(self, i) -> psg.Frame:
        """tab3 row represents bus composite toggle"""

        def add_strip_outputs(layout):
@@ -340,10 +475,35 @@ class Builder:
                ]
            )

-        outputs = list()
+        outputs = []
        [step(outputs) for step in (add_strip_outputs,)]
        return psg.Frame(self.window.cache["labels"][f"BUS {i}||LABEL"], outputs, key=f"BUS {i}||LABEL")

-    def make_tab3_rows(self) -> psg.Frame:
-        layout = [[self.make_tab3_row(i)] for i in range(self.kind.num_bus)]
+    def make_tab3_button_rows(self) -> psg.Frame:
+        layout = [[self.make_tab3_button_row(i)] for i in range(self.kind.num_bus)]
+        return psg.Frame(None, layout, border_width=0)
+
+    def make_tab3_slider_row(self, i) -> psg.Frame:
+        def add_gain_slider(layout):
+            layout.append(
+                [
+                    psg.Slider(
+                        range=(-60, 12),
+                        default_value=self.vm.bus[i].gain,
+                        resolution=0.1,
+                        disable_number_display=True,
+                        expand_x=True,
+                        enable_events=True,
+                        orientation="horizontal",
+                        key=f"BUS {i}||SLIDER GAIN",
+                    )
+                ]
+            )
+
+        outputs = []
+        [step(outputs) for step in (add_gain_slider,)]
+        return psg.Frame(self.window.cache["labels"][f"BUS {i}||LABEL"], outputs, key=f"BUS {i}||LABEL||SLIDER")
+
+    def make_tab3_slider_rows(self) -> psg.Frame:
+        layout = [[self.make_tab3_slider_row(i)] for i in range(self.kind.num_bus)]
        return psg.Frame(None, layout, border_width=0)
--- a/src/nvda_voicemeeter/compound.py
+++ b/src/nvda_voicemeeter/compound.py
@@ -0,0 +1,39 @@
+import PySimpleGUI as psg
+
+
+class LabelSlider(psg.Frame):
+    """Compound Label Slider element"""
+
+    def __init__(self, parent, i, param, range_=(0, 10), *args, **kwargs):
+        self.parent = parent
+        if param in ("AUDIBILITY", "DENOISER"):
+            size = 7
+        else:
+            size = 4
+        if param == "LIMIT":
+            resolution = 1
+        else:
+            resolution = 0.1
+        layout = [
+            [
+                psg.Text(param.capitalize(), size=size),
+                psg.Slider(
+                    range=range_,
+                    default_value=self.default_value(i, param),
+                    resolution=resolution,
+                    disable_number_display=True,
+                    size=(12, 16),
+                    expand_x=True,
+                    enable_events=True,
+                    orientation="horizontal",
+                    key=f"STRIP {i}||SLIDER {param}",
+                ),
+            ]
+        ]
+        super().__init__(None, layout=layout, border_width=0, pad=0, *args, **kwargs)
+
+    def default_value(self, i, param):
+        target = getattr(self.parent.vm.strip[i], param.lower())
+        if param in ("COMP", "GATE", "DENOISER"):
+            return target.knob
+        return target
--- a/src/nvda_voicemeeter/models.py
+++ b/src/nvda_voicemeeter/models.py
@@ -42,14 +42,14 @@ def _make_param_cache(vm, channel_type) -> dict:
            **{f"STRIP {i}||SOLO": vm.strip[i].solo for i in range(vm.kind.num_strip)},
            **{f"STRIP {i}||MUTE": vm.strip[i].mute for i in range(vm.kind.num_strip)},
        }
-        return params
    else:
-        return {
+        params |= {
            **{f"BUS {i}||MONO": vm.bus[i].mono for i in range(vm.kind.num_bus)},
            **{f"BUS {i}||EQ": vm.bus[i].eq.on for i in range(vm.kind.num_bus)},
            **{f"BUS {i}||MUTE": vm.bus[i].mute for i in range(vm.kind.num_bus)},
            **{f"BUS {i}||MODE": vm.bus[i].mode.get() for i in range(vm.kind.num_bus)},
        }
+    return params


 def _make_label_cache(vm) -> dict:
--- a/src/nvda_voicemeeter/util.py
+++ b/src/nvda_voicemeeter/util.py
@@ -1,3 +1,6 @@
+from typing import Iterable
+
+
 def get_asio_checkbox_index(channel, num) -> int:
    if channel == 0:
        return 2 * num - 2
@@ -8,17 +11,36 @@ def get_insert_checkbox_index(kind, channel, num) -> int:
    if num <= kind.phys_in:
        if channel == 0:
            return 2 * num - 2
-        else:
        return 2 * num - 1
    return (2 * kind.phys_in) + (8 * (num - kind.phys_in - 1)) + channel


+_rejected_ids = (
+    "VBAudio100VMVAIO3",
+    "{F5735BD4-6EAF-4758-9710-9886E5AD0FF3}",
+    "{0239BE07-CEEF-4236-A900-AA778D432FD4}",
+)
+
+
 def get_input_device_list(vm) -> list:
-    return ["{type}: {name}".format(**vm.device.input(i)) for i in range(vm.device.ins)]
+    devices = []
+    for j in range(vm.device.ins):
+        device = vm.device.input(j)
+        if device["id"] not in _rejected_ids:
+            devices.append("{type}: {name}".format(**device))
+    return devices


-def get_output_device_list(vm) -> list:
-    return ["{type}: {name}".format(**vm.device.output(i)) for i in range(vm.device.outs)]
+def get_output_device_list(i, vm) -> list:
+    devices = []
+    for j in range(vm.device.outs):
+        device = vm.device.output(j)
+        if device["id"] not in _rejected_ids:
+            devices.append("{type}: {name}".format(**device))
+    if i == 0:
+        return devices
+    devices.append("- remove device selection -")
+    return [device for device in devices if not device.startswith("asio")]


 def get_patch_composite_list(kind) -> list:
@@ -47,28 +69,20 @@ def get_patch_insert_channels() -> list:
 _patch_insert_channels = get_patch_insert_channels()


-def get_asio_samples_list() -> list:
-    return [
-        "1024",
-        "768",
-        "704",
-        "640",
-        "576",
-        "512",
-        "480",
-        "448",
-        "441",
-        "416",
-        "384",
-        "352",
-        "320",
-        "288",
-        "256",
-        "224",
-        "192",
-        "160",
-        "128",
+def get_asio_samples_list(driver) -> list:
+    if driver == "MME":
+        samples = ["2048", "1536", "1024", "896", "768", "704", "640", "576", "512", "480", "441"]
+    else:
+        # fmt: off
+        samples = [
+            "2048", "1536", "1024", "768", "704", "640", "576", "512", "480", "448", "441", "416", "384",
+            "352", "320", "288", "256", "224", "192", "160", "128"
        ]
+        # fmt: on
+        if driver == "ASIO":
+            samples = [x for x in samples if x not in ("2048", "1536")]
+    samples.append("Default")
+    return samples


 def get_tabs_labels() -> list:
@@ -116,3 +130,23 @@ def get_bus_modes(vm) -> list:
        "lfeonly",
        "rearonly",
    ]
+
+
+def check_bounds(val, bounds: tuple) -> int | float:
+    lower, upper = bounds
+    if val > upper:
+        val = upper
+    elif val < lower:
+        val = lower
+    return val
+
+
+def get_slider_params(i, vm) -> Iterable:
+    if i < vm.kind.phys_in:
+        if vm.kind.name == "basic":
+            return ("AUDIBILITY",)
+        if vm.kind.name == "banana":
+            return ("COMP", "GATE")
+        if vm.kind.name == "potato":
+            return ("COMP", "GATE", "DENOISER")
+    return ("BASS", "MID", "TREBLE")
--- a/src/nvda_voicemeeter/window.py
+++ b/src/nvda_voicemeeter/window.py
@@ -4,26 +4,10 @@ from pathlib import Path

 import PySimpleGUI as psg

+from . import models, util
 from .builder import Builder
-from .models import (
-    _make_hardware_ins_cache,
-    _make_hardware_outs_cache,
-    _make_label_cache,
-    _make_param_cache,
-    _make_patch_asio_cache,
-    _make_patch_insert_cache,
-)
 from .nvda import Nvda
 from .parser import Parser
-from .util import (
-    _patch_insert_channels,
-    get_asio_checkbox_index,
-    get_bus_modes,
-    get_channel_identifier_list,
-    get_insert_checkbox_index,
-    get_patch_composite_list,
-    open_context_menu_for_buttonmenu,
-)

 logger = logging.getLogger(__name__)

@@ -40,13 +24,13 @@ class NVDAVMWindow(psg.Window):
        self.kind = self.vm.kind
        self.logger = logger.getChild(type(self).__name__)
        self.cache = {
-            "hw_ins": _make_hardware_ins_cache(self.vm),
-            "hw_outs": _make_hardware_outs_cache(self.vm),
-            "strip": _make_param_cache(self.vm, "strip"),
-            "bus": _make_param_cache(self.vm, "bus"),
-            "labels": _make_label_cache(self.vm),
-            "asio": _make_patch_asio_cache(self.vm),
-            "insert": _make_patch_insert_cache(self.vm),
+            "hw_ins": models._make_hardware_ins_cache(self.vm),
+            "hw_outs": models._make_hardware_outs_cache(self.vm),
+            "strip": models._make_param_cache(self.vm, "strip"),
+            "bus": models._make_param_cache(self.vm, "bus"),
+            "labels": models._make_label_cache(self.vm),
+            "asio": models._make_patch_asio_cache(self.vm),
+            "insert": models._make_patch_insert_cache(self.vm),
        }
        self.nvda = Nvda()
        self.parser = Parser()
@@ -62,11 +46,18 @@ class NVDAVMWindow(psg.Window):
            self[f"HARDWARE OUT||A2"].Widget.config(**buttonmenu_opts)
        if self.kind.name != "basic":
            [self[f"PATCH COMPOSITE||PC{i + 1}"].Widget.config(**buttonmenu_opts) for i in range(self.kind.phys_out)]
-            self["ASIO BUFFER"].Widget.config(**buttonmenu_opts)
+        slider_opts = {"takefocus": 1, "highlightthickness": 1}
+        for i in range(self.kind.num_strip):
+            for param in util.get_slider_params(i, self.vm):
+                self[f"STRIP {i}||SLIDER {param}"].Widget.config(**slider_opts)
+            self[f"STRIP {i}||SLIDER GAIN"].Widget.config(**slider_opts)
            if self.kind.name != "basic":
-            self["ASIO BUFFER FRAME"].update(visible=False)
-            self["ASIO BUFFER FRAME"].hide_row()
+                self[f"STRIP {i}||SLIDER LIMIT"].Widget.config(**slider_opts)
+        for i in range(self.kind.num_bus):
+            self[f"BUS {i}||SLIDER GAIN"].Widget.config(**slider_opts)
+
        self.register_events()
+        self["tabgroup"].set_focus()

    def __enter__(self):
        settings_path = Path.cwd() / self.SETTINGS
@@ -101,33 +92,51 @@ class NVDAVMWindow(psg.Window):

    def on_pdirty(self):
        self.cache = {
-            "hw_ins": _make_hardware_ins_cache(self.vm),
-            "hw_outs": _make_hardware_outs_cache(self.vm),
-            "strip": _make_param_cache(self.vm, "strip"),
-            "bus": _make_param_cache(self.vm, "bus"),
-            "labels": _make_label_cache(self.vm),
-            "asio": _make_patch_asio_cache(self.vm),
-            "insert": _make_patch_insert_cache(self.vm),
+            "hw_ins": models._make_hardware_ins_cache(self.vm),
+            "hw_outs": models._make_hardware_outs_cache(self.vm),
+            "strip": models._make_param_cache(self.vm, "strip"),
+            "bus": models._make_param_cache(self.vm, "bus"),
+            "labels": models._make_label_cache(self.vm),
+            "asio": models._make_patch_asio_cache(self.vm),
+            "insert": models._make_patch_insert_cache(self.vm),
        }
        for key, value in self.cache["labels"].items():
            self[key].update(value=value)
+            self[f"{key}||SLIDER"].update(value=value)
+        for i in range(self.kind.num_strip):
+            self[f"STRIP {i}||SLIDER GAIN"].update(value=self.vm.strip[i].gain)
+            if self.kind.name != "basic":
+                self[f"STRIP {i}||SLIDER LIMIT"].update(value=self.vm.strip[i].limit)
+            for param in util.get_slider_params(i, self.vm):
+                if param in ("AUDIBILITY", "BASS", "MID", "TREBLE"):
+                    val = getattr(self.vm.strip[i], param.lower())
+                else:
+                    target = getattr(self.vm.strip[i], param.lower())
+                    val = target.knob
+                self[f"STRIP {i}||SLIDER {param}"].update(value=val)
+        for i in range(self.kind.num_bus):
+            self[f"BUS {i}||SLIDER GAIN"].update(value=self.vm.bus[i].gain)
        if self.kind.name != "basic":
            for key, value in self.cache["asio"].items():
                identifier, i = key.split("||")
-                partial = get_channel_identifier_list(self.vm)[int(i)]
+                partial = util.get_channel_identifier_list(self.vm)[int(i)]
                self[f"{identifier}||{partial}"].update(value=value)
            for key, value in self.cache["insert"].items():
                identifier, i = key.split("||")
-                partial = get_channel_identifier_list(self.vm)[int(i)]
+                partial = util.get_channel_identifier_list(self.vm)[int(i)]
                self[f"{identifier}||{partial}"].update(value=value)

    def register_events(self):
        """Registers events for widgets"""

        # TABS
-        self["tabs"].bind("<FocusIn>", "||FOCUS IN")
+        self["tabgroup"].bind("<FocusIn>", "||FOCUS IN")
+        for tabname in util.get_tabs_labels()[1:]:
+            self[f"tabgroup||{tabname}"].bind("<FocusIn>", "||FOCUS IN")
+            self[f"tabgroup||{tabname}"].bind("<Shift-KeyPress-Tab>", "||KEY SHIFT TAB")
        self.bind("<Control-KeyPress-Tab>", "CTRL-TAB")
        self.bind("<Control-Shift-KeyPress-Tab>", "CTRL-SHIFT-TAB")
+        self.bind("<Control-a>", "CTRL-A")

        # Hardware In
        for i in range(self.vm.kind.phys_in):
@@ -167,6 +176,10 @@ class NVDAVMWindow(psg.Window):
                else:
                    [self[f"INSERT CHECKBOX||IN{i + 1} {j}"].bind("<FocusIn>", "||FOCUS IN") for j in range(8)]

+        # Advanced Settings
+        self["ADVANCED SETTINGS"].bind("<FocusIn>", "||FOCUS IN")
+        self["ADVANCED SETTINGS"].bind("<Return>", "||KEY ENTER")
+
        # Strip Params
        for i in range(self.kind.num_strip):
            for j in range(self.kind.phys_out):
@@ -184,6 +197,26 @@ class NVDAVMWindow(psg.Window):
                    self[f"STRIP {i}||{param}"].bind("<FocusIn>", "||FOCUS IN")
                    self[f"STRIP {i}||{param}"].bind("<Return>", "||KEY ENTER")

+        # Strip Sliders
+        for i in range(self.kind.num_strip):
+            for param in util.get_slider_params(i, self.vm) + ("GAIN", "LIMIT"):
+                if self.kind.name == "basic" and param == "LIMIT":
+                    continue
+                self[f"STRIP {i}||SLIDER {param}"].bind("<FocusIn>", "||FOCUS IN")
+                self[f"STRIP {i}||SLIDER {param}"].bind("<FocusOut>", "||FOCUS OUT")
+                self[f"STRIP {i}||SLIDER {param}"].bind("<Left>", "||KEY LEFT")
+                self[f"STRIP {i}||SLIDER {param}"].bind("<Right>", "||KEY RIGHT")
+                self[f"STRIP {i}||SLIDER {param}"].bind("<Shift-KeyPress-Left>", "||KEY SHIFT LEFT")
+                self[f"STRIP {i}||SLIDER {param}"].bind("<Shift-KeyPress-Right>", "||KEY SHIFT RIGHT")
+                self[f"STRIP {i}||SLIDER {param}"].bind("<Control-KeyPress-Left>", "||KEY CTRL LEFT")
+                self[f"STRIP {i}||SLIDER {param}"].bind("<Control-KeyPress-Right>", "||KEY CTRL RIGHT")
+                self[f"STRIP {i}||SLIDER {param}"].bind("<Up>", "||KEY UP")
+                self[f"STRIP {i}||SLIDER {param}"].bind("<Down>", "||KEY DOWN")
+                self[f"STRIP {i}||SLIDER {param}"].bind("<Shift-KeyPress-Up>", "||KEY SHIFT UP")
+                self[f"STRIP {i}||SLIDER {param}"].bind("<Shift-KeyPress-Down>", "||KEY SHIFT DOWN")
+                self[f"STRIP {i}||SLIDER {param}"].bind("<Control-KeyPress-Up>", "||KEY CTRL UP")
+                self[f"STRIP {i}||SLIDER {param}"].bind("<Control-KeyPress-Down>", "||KEY CTRL DOWN")
+
        # Bus Params
        params = ["MONO", "EQ", "MUTE", "MODE"]
        if self.vm.kind.name == "basic":
@@ -193,11 +226,22 @@ class NVDAVMWindow(psg.Window):
                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)
+        # Bus Sliders
+        for i in range(self.kind.num_bus):
+            self[f"BUS {i}||SLIDER GAIN"].bind("<FocusIn>", "||FOCUS IN")
+            self[f"BUS {i}||SLIDER GAIN"].bind("<FocusOut>", "||FOCUS OUT")
+            self[f"BUS {i}||SLIDER GAIN"].bind("<Left>", "||KEY LEFT")
+            self[f"BUS {i}||SLIDER GAIN"].bind("<Right>", "||KEY RIGHT")
+            self[f"BUS {i}||SLIDER GAIN"].bind("<Shift-KeyPress-Left>", "||KEY SHIFT LEFT")
+            self[f"BUS {i}||SLIDER GAIN"].bind("<Shift-KeyPress-Right>", "||KEY SHIFT RIGHT")
+            self[f"BUS {i}||SLIDER GAIN"].bind("<Control-KeyPress-Left>", "||KEY CTRL LEFT")
+            self[f"BUS {i}||SLIDER GAIN"].bind("<Control-KeyPress-Right>", "||KEY CTRL RIGHT")
+            self[f"BUS {i}||SLIDER GAIN"].bind("<Up>", "||KEY UP")
+            self[f"BUS {i}||SLIDER GAIN"].bind("<Down>", "||KEY DOWN")
+            self[f"BUS {i}||SLIDER GAIN"].bind("<Shift-KeyPress-Up>", "||KEY SHIFT UP")
+            self[f"BUS {i}||SLIDER GAIN"].bind("<Shift-KeyPress-Down>", "||KEY SHIFT DOWN")
+            self[f"BUS {i}||SLIDER GAIN"].bind("<Control-KeyPress-Up>", "||KEY CTRL UP")
+            self[f"BUS {i}||SLIDER GAIN"].bind("<Control-KeyPress-Down>", "||KEY CTRL DOWN")

    def popup_save_as(self, message, title=None, initial_folder=None):
        layout = [
@@ -219,27 +263,24 @@ class NVDAVMWindow(psg.Window):
            self.logger.debug(f"values::{values}")
            if event in (psg.WIN_CLOSED, "Cancel"):
                break
-            elif event.endswith("||FOCUS IN"):
+            match parsed_cmd := self.parser.match.parseString(event):
+                case [[button], ["FOCUS", "IN"]]:
                    if values["Browse"]:
                        filepath = values["Browse"]
                        break
-                label = event.split("||")[0]
-                self.TKroot.after(
-                    200 if label == "Edit" else 1,
-                    self.nvda.speak,
-                    label,
-                )
-            elif event.endswith("||KEY ENTER"):
+                    self.nvda.speak(button)
+                case [[button], ["KEY", "ENTER"]]:
                    window.find_element_with_focus().click()
+            self.logger.debug(f"parsed::{parsed_cmd}")
        window.close()
        if filepath:
            return Path(filepath)

    def popup_rename(self, message, title=None, tab=None):
        if tab == "Physical Strip":
-            upper = self.kind.phys_out + 1
+            upper = self.kind.phys_in + 1
        elif tab == "Virtual Strip":
-            upper = self.kind.virt_out + 1
+            upper = self.kind.virt_in + 1
        elif tab == "Buses":
            upper = self.kind.num_bus + 1

@@ -269,24 +310,87 @@ class NVDAVMWindow(psg.Window):
            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":
+            match parsed_cmd := self.parser.match.parseString(event):
+                case ["Index"]:
                    val = values["Index"]
                    self.nvda.speak(f"Index {val}")
-            elif event.endswith("||FOCUS IN"):
-                if event.startswith("Index"):
+                case [[button], ["FOCUS", "IN"]]:
+                    if button == "Index":
                        val = values["Index"]
                        self.nvda.speak(f"Index {val}")
                    else:
-                    self.nvda.speak(event.split("||")[0])
-            elif event == "Ok":
+                        self.nvda.speak(button)
+                case [[button], ["KEY", "ENTER"]]:
+                    window.find_element_with_focus().click()
+                case ["Ok"]:
                    data = values
                    break
-
+            self.logger.debug(f"parsed::{parsed_cmd}")
        window.close()
        return data

+    def popup_advanced_settings(self, title):
+        def _make_buffering_frame() -> psg.Frame:
+            buffer = [
+                [
+                    psg.ButtonMenu(
+                        driver,
+                        size=(14, 2),
+                        menu_def=["", util.get_asio_samples_list(driver)],
+                        key=f"BUFFER {driver}",
+                    )
+                    for driver in ("MME", "WDM", "KS", "ASIO")
+                ],
+            ]
+            return psg.Frame("BUFFERING", buffer)
+
+        layout = []
+        steps = (_make_buffering_frame,)
+        for step in steps:
+            layout.append([step()])
+        layout.append([psg.Button("Exit", size=(8, 2))])
+
+        window = psg.Window(title, layout, finalize=True)
+        buttonmenu_opts = {"takefocus": 1, "highlightthickness": 1}
+        for driver in ("MME", "WDM", "KS", "ASIO"):
+            window[f"BUFFER {driver}"].Widget.config(**buttonmenu_opts)
+            window[f"BUFFER {driver}"].bind("<FocusIn>", "||FOCUS IN")
+            window[f"BUFFER {driver}"].bind("<space>", "||KEY SPACE", propagate=False)
+            window[f"BUFFER {driver}"].bind("<Return>", "||KEY ENTER", propagate=False)
+        window["Exit"].bind("<FocusIn>", "||FOCUS IN")
+        window["Exit"].bind("<Return>", "||KEY ENTER")
+        while True:
+            event, values = window.read()
+            self.logger.debug(f"event::{event}")
+            self.logger.debug(f"values::{values}")
+            if event in (psg.WIN_CLOSED, "Exit"):
+                break
+            match parsed_cmd := self.parser.match.parseString(event):
+                case ["BUFFER MME" | "BUFFER WDM" | "BUFFER KS" | "BUFFER ASIO"]:
+                    if values[event] == "Default":
+                        if "MME" in event:
+                            val = 1024
+                        elif "WDM" in event or "KS" in event:
+                            val = 512
+                        else:
+                            val = 0
+                    else:
+                        val = int(values[event])
+                    driver = event.split()[1]
+                    self.vm.set(f"option.buffer.{driver.lower()}", val)
+                    self.TKroot.after(200, self.nvda.speak, f"{driver} BUFFER {val if val else 'default'}")
+                case [["BUFFER", driver], ["FOCUS", "IN"]]:
+                    val = int(self.vm.get(f"option.buffer.{driver.lower()}"))
+                    self.nvda.speak(f"{driver} BUFFER {val if val else 'default'}")
+                case [["BUFFER", driver], ["KEY", "SPACE" | "ENTER"]]:
+                    util.open_context_menu_for_buttonmenu(window, f"BUFFER {driver}")
+                case [[button], ["FOCUS", "IN"]]:
+                    self.nvda.speak(button)
+                case [[button], ["KEY", "ENTER"]]:
+                    window.find_element_with_focus().click()
+            self.logger.debug(f"parsed::{parsed_cmd}")
+        window.close()
+
    def run(self):
        """
        Parses the event string and matches it to events
@@ -300,17 +404,16 @@ class NVDAVMWindow(psg.Window):
            self.logger.debug(f"values::{values}")
            if event in (psg.WIN_CLOSED, "Exit"):
                break
-            elif event == "tabs":
-                self.nvda.speak(f"tab {values['tabs']}")

            match parsed_cmd := self.parser.match.parseString(event):
                # Focus tabgroup
                case ["CTRL-TAB"] | ["CTRL-SHIFT-TAB"]:
-                    self["tabs"].set_focus()
+                    self["tabgroup"].set_focus()
+                    self.nvda.speak(f"{values['tabgroup']}")

                # Rename popups
                case ["F2:113"]:
-                    tab = values["tabs"]
+                    tab = values["tabgroup"]
                    if tab in ("Physical Strip", "Virtual Strip", "Buses"):
                        data = self.popup_rename("Label", title=f"Rename {tab}", tab=tab)
                        if not data:  # cancel was pressed
@@ -318,20 +421,21 @@ class NVDAVMWindow(psg.Window):
                        index = int(data["Index"]) - 1
                        match tab:
                            case "Physical Strip":
-                                label = data.get("Edit") or f"Hardware Input {index + 1}"
+                                label = data.get("Edit", f"Hardware Input {index + 1}")
                                self.vm.strip[index].label = label
                                self[f"STRIP {index}||LABEL"].update(value=label)
                                self.cache["labels"][f"STRIP {index}||LABEL"] = label
                            case "Virtual Strip":
-                                label = data.get("Edit") or f"Virtual Input {index + 1}"
+                                index += self.kind.phys_in
+                                label = data.get("Edit", f"Virtual Input {index - self.kind.phys_in + 1}")
                                self.vm.strip[index].label = label
                                self[f"STRIP {index}||LABEL"].update(value=label)
                                self.cache["labels"][f"STRIP {index}||LABEL"] = label
                            case "Buses":
                                if index < self.kind.phys_out:
-                                    label = data.get("Edit") or f"Physical Bus {index + 1}"
+                                    label = data.get("Edit", f"Physical Bus {index + 1}")
                                else:
-                                    label = data.get("Edit") or f"Virtual Bus {index - self.kind.phys_out + 1}"
+                                    label = data.get("Edit", f"Virtual Bus {index - self.kind.phys_out + 1}")
                                self.vm.bus[index].label = label
                                self[f"BUS {index}||LABEL"].update(value=label)
                                self.cache["labels"][f"BUS {index}||LABEL"] = label
@@ -369,6 +473,8 @@ class NVDAVMWindow(psg.Window):
                        filepath = Path(filepath)
                        self.vm.set("command.load", str(filepath))
                        self.logger.debug(f"loading config file from {filepath}")
+                        for i in (25, 50):  # for the benefit of the sliders
+                            self.TKroot.after(i, self.on_pdirty)
                        self.TKroot.after(
                            200,
                            self.nvda.speak,
@@ -394,11 +500,18 @@ class NVDAVMWindow(psg.Window):
                    else:
                        with open(self.SETTINGS, "wb") as f:
                            f.truncate()
-                        self.logger.debug("default bin was truncated")
+                        self.logger.debug("settings.json was truncated")

                # Tabs
-                case [["tabs"], ["FOCUS", "IN"]]:
-                    self.nvda.speak(f"tab {values['tabs']}")
+                case ["tabgroup"] | [["tabgroup"], ["FOCUS", "IN"]]:
+                    if self.find_element_with_focus() is None:
+                        self.nvda.speak(f"{values['tabgroup']}")
+                case [["tabgroup"], tabname] | [["tabgroup"], tabname, ["FOCUS", "IN"]]:
+                    if self.find_element_with_focus() is None:
+                        name = " ".join(tabname)
+                        self.nvda.speak(f"{values[f'tabgroup||{name}']}")
+                case [["tabgroup"], _, ["KEY", "SHIFT", "TAB"]]:
+                    self.nvda.speak(values["tabgroup"])

                # Hardware In
                case [["HARDWARE", "IN"], [key]]:
@@ -409,7 +522,7 @@ class NVDAVMWindow(psg.Window):
                            setattr(self.vm.strip[index].device, "wdm", "")
                            self.TKroot.after(200, self.nvda.speak, f"HARDWARE IN {key} device selection removed")
                        case [driver, device_name]:
-                            setattr(self.vm.strip[index].device, driver, device_name.strip())
+                            setattr(self.vm.strip[index].device, driver, device_name.lstrip())
                            phonetic = {"mme": "em em e"}
                            self.TKroot.after(
                                200,
@@ -417,9 +530,10 @@ class NVDAVMWindow(psg.Window):
                                f"HARDWARE IN {key} set {phonetic.get(driver, driver)} {device_name}",
                            )
                case [["HARDWARE", "IN"], [key], ["FOCUS", "IN"]]:
+                    if self.find_element_with_focus() is not None:
                        self.nvda.speak(f"HARDWARE INPUT {key} {self.cache['hw_ins'][f'HARDWARE IN||{key}']}")
                case [["HARDWARE", "IN"], [key], ["KEY", "SPACE" | "ENTER"]]:
-                    open_context_menu_for_buttonmenu(self, f"HARDWARE IN||{key}")
+                    util.open_context_menu_for_buttonmenu(self, f"HARDWARE IN||{key}")

                # Hardware out
                case [["HARDWARE", "OUT"], [key]]:
@@ -430,7 +544,7 @@ class NVDAVMWindow(psg.Window):
                            setattr(self.vm.bus[index].device, "wdm", "")
                            self.TKroot.after(200, self.nvda.speak, f"HARDWARE OUT {key} device selection removed")
                        case [driver, device_name]:
-                            setattr(self.vm.bus[index].device, driver, device_name.strip())
+                            setattr(self.vm.bus[index].device, driver, device_name.lstrip())
                            phonetic = {"mme": "em em e"}
                            self.TKroot.after(
                                200,
@@ -438,18 +552,20 @@ class NVDAVMWindow(psg.Window):
                                f"HARDWARE OUT {key} set {phonetic.get(driver, driver)} {device_name}",
                            )
                case [["HARDWARE", "OUT"], [key], ["FOCUS", "IN"]]:
+                    if self.find_element_with_focus() is not None:
                        self.nvda.speak(f"HARDWARE OUT {key} {self.cache['hw_outs'][f'HARDWARE OUT||{key}']}")
                case [["HARDWARE", "OUT"], [key], ["KEY", "SPACE" | "ENTER"]]:
-                    open_context_menu_for_buttonmenu(self, f"HARDWARE OUT||{key}")
+                    util.open_context_menu_for_buttonmenu(self, f"HARDWARE OUT||{key}")

                # Patch ASIO
                case [["ASIO", "CHECKBOX"], [in_num, channel]]:
-                    index = get_asio_checkbox_index(int(channel), int(in_num[-1]))
+                    index = util.get_asio_checkbox_index(int(channel), int(in_num[-1]))
                    val = values[f"ASIO CHECKBOX||{in_num} {channel}"]
                    self.vm.patch.asio[index].set(val)
                    channel = ("left", "right")[int(channel)]
                    self.nvda.speak(f"Patch ASIO {in_num} {channel} set to {val}")
                case [["ASIO", "CHECKBOX"], [in_num, channel], ["FOCUS", "IN"]]:
+                    if self.find_element_with_focus() is not None:
                        val = values[f"ASIO CHECKBOX||{in_num} {channel}"]
                        channel = ("left", "right")[int(channel)]
                        num = int(in_num[-1])
@@ -459,21 +575,22 @@ class NVDAVMWindow(psg.Window):
                case [["PATCH", "COMPOSITE"], [key]]:
                    val = values[f"PATCH COMPOSITE||{key}"]
                    index = int(key[-1]) - 1
-                    self.vm.patch.composite[index].set(get_patch_composite_list(self.kind).index(val) + 1)
+                    self.vm.patch.composite[index].set(util.get_patch_composite_list(self.kind).index(val) + 1)
                    self.TKroot.after(200, self.nvda.speak, f"PATCH COMPOSITE {key[-1]} set {val}")
                case [["PATCH", "COMPOSITE"], [key], ["FOCUS", "IN"]]:
+                    if self.find_element_with_focus() is not None:
                        if values[f"PATCH COMPOSITE||{key}"]:
                            val = values[f"PATCH COMPOSITE||{key}"]
                        else:
                            index = int(key[-1]) - 1
-                        val = get_patch_composite_list(self.kind)[self.vm.patch.composite[index].get() - 1]
+                            val = util.get_patch_composite_list(self.kind)[self.vm.patch.composite[index].get() - 1]
                        self.nvda.speak(f"Patch COMPOSITE {key[-1]} {val}")
                case [["PATCH", "COMPOSITE"], [key], ["KEY", "SPACE" | "ENTER"]]:
-                    open_context_menu_for_buttonmenu(self, f"PATCH COMPOSITE||{key}")
+                    util.open_context_menu_for_buttonmenu(self, f"PATCH COMPOSITE||{key}")

                # Patch INSERT
                case [["INSERT", "CHECKBOX"], [in_num, channel]]:
-                    index = get_insert_checkbox_index(
+                    index = util.get_insert_checkbox_index(
                        self.kind,
                        int(channel),
                        int(in_num[-1]),
@@ -481,32 +598,28 @@ class NVDAVMWindow(psg.Window):
                    val = values[f"INSERT CHECKBOX||{in_num} {channel}"]
                    self.vm.patch.insert[index].on = val
                    self.nvda.speak(
-                        f"PATCH INSERT {in_num} {_patch_insert_channels[int(channel)]} set to {'on' if val else 'off'}"
+                        f"PATCH INSERT {in_num} {util._patch_insert_channels[int(channel)]} set to {'on' if val else 'off'}"
                    )
                case [["INSERT", "CHECKBOX"], [in_num, channel], ["FOCUS", "IN"]]:
-                    index = get_insert_checkbox_index(
+                    if self.find_element_with_focus() is not None:
+                        index = util.get_insert_checkbox_index(
                            self.kind,
                            int(channel),
                            int(in_num[-1]),
                        )
                        val = values[f"INSERT CHECKBOX||{in_num} {channel}"]
-                    channel = _patch_insert_channels[int(channel)]
+                        channel = util._patch_insert_channels[int(channel)]
                        num = int(in_num[-1])
                        self.nvda.speak(f"Patch INSERT IN#{num} {channel} {'on' if val else 'off'}")

-                # ASIO Buffer
-                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")
+                # Advanced Settings
+                case ["ADVANCED SETTINGS"] | ["CTRL-A"]:
+                    if values["tabgroup"] == "tab||Settings":
+                        self.popup_advanced_settings(title="Advanced Settings")
+                case [["ADVANCED", "SETTINGS"], ["FOCUS", "IN"]]:
+                    self.nvda.speak("ADVANCED SETTINGS")
+                case [["ADVANCED", "SETTINGS"], ["KEY", "ENTER"]]:
+                    self.find_element_with_focus().click()

                # Strip Params
                case [["STRIP", index], [param]]:
@@ -540,6 +653,7 @@ class NVDAVMWindow(psg.Window):
                            self.cache["strip"][f"STRIP {index}||{param}"] = val
                            self.nvda.speak(f"{label} {param} {'on' if val else 'off'}")
                case [["STRIP", index], [param], ["FOCUS", "IN"]]:
+                    if self.find_element_with_focus() is not None:
                        val = self.cache["strip"][f"STRIP {index}||{param}"]
                        match param:
                            case "MONO":
@@ -562,6 +676,234 @@ class NVDAVMWindow(psg.Window):
                case [["STRIP", index], [param], ["KEY", "ENTER"]]:
                    self.find_element_with_focus().click()

+                # Strip Sliders
+                case [
+                    ["STRIP", index],
+                    [
+                        "SLIDER",
+                        "GAIN"
+                        | "COMP"
+                        | "GATE"
+                        | "DENOISER"
+                        | "AUDIBILITY"
+                        | "LIMIT"
+                        | "BASS"
+                        | "MID"
+                        | "TREBLE" as param,
+                    ],
+                ]:
+                    label = self.cache["labels"][f"STRIP {index}||LABEL"]
+                    val = values[event]
+                    match param:
+                        case "GAIN":
+                            self.vm.strip[int(index)].gain = val
+                        case "COMP" | "GATE" | "DENOISER":
+                            target = getattr(self.vm.strip[int(index)], param.lower())
+                            target.knob = val
+                        case "AUDIBILITY":
+                            self.vm.strip[int(index)].audibility = val
+                        case "LIMIT":
+                            val = int(val)
+                            self.vm.strip[int(index)].limit = val
+                        case "BASS" | "MID" | "TREBLE":
+                            setattr(self.vm.strip[int(index)], param.lower(), val)
+                    self.nvda.speak(f"{label} {param} slider {val}")
+                case [
+                    ["STRIP", index],
+                    [
+                        "SLIDER",
+                        "GAIN"
+                        | "COMP"
+                        | "GATE"
+                        | "DENOISER"
+                        | "AUDIBILITY"
+                        | "LIMIT"
+                        | "BASS"
+                        | "MID"
+                        | "TREBLE" as param,
+                    ],
+                    ["FOCUS", "IN"],
+                ]:
+                    if self.find_element_with_focus() is not None:
+                        self.vm.event.pdirty = False
+                        label = self.cache["labels"][f"STRIP {index}||LABEL"]
+                        val = values[f"STRIP {index}||SLIDER {param}"]
+                        self.nvda.speak(f"{label} {param} slider {int(val) if param == 'LIMIT' else val}")
+                case [
+                    ["STRIP", index],
+                    [
+                        "SLIDER",
+                        "GAIN" | "COMP" | "GATE" | "DENOISER" | "AUDIBILITY" | "LIMIT" | "BASS" | "MID" | "TREBLE",
+                    ],
+                    ["FOCUS", "OUT"],
+                ]:
+                    self.vm.event.pdirty = True
+                case [
+                    ["STRIP", index],
+                    [
+                        "SLIDER",
+                        "GAIN"
+                        | "COMP"
+                        | "GATE"
+                        | "DENOISER"
+                        | "AUDIBILITY"
+                        | "LIMIT"
+                        | "BASS"
+                        | "MID"
+                        | "TREBLE" as param,
+                    ],
+                    ["KEY", "LEFT" | "RIGHT" | "UP" | "DOWN" as direction],
+                ]:
+                    match param:
+                        case "GAIN":
+                            val = self.vm.strip[int(index)].gain
+                        case "COMP" | "GATE" | "DENOISER":
+                            target = getattr(self.vm.strip[int(index)], param.lower())
+                            val = target.knob
+                        case "AUDIBILITY":
+                            val = self.vm.strip[int(index)].audibility
+                        case "BASS" | "MID" | "TREBLE":
+                            val = getattr(self.vm.strip[int(index)], param.lower())
+                        case "LIMIT":
+                            val = self.vm.strip[int(index)].limit
+
+                    match direction:
+                        case "RIGHT" | "UP":
+                            val += 1
+                        case "LEFT" | "DOWN":
+                            val -= 1
+
+                    match param:
+                        case "GAIN":
+                            self.vm.strip[int(index)].gain = util.check_bounds(val, (-60, 12))
+                            self[f"STRIP {index}||SLIDER {param}"].update(value=util.check_bounds(val, (-60, 12)))
+                        case "COMP" | "GATE" | "DENOISER":
+                            setattr(target, "knob", util.check_bounds(val, (0, 10)))
+                            self[f"STRIP {index}||SLIDER {param}"].update(value=util.check_bounds(val, (0, 10)))
+                        case "AUDIBILITY":
+                            self.vm.strip[int(index)].audibility = util.check_bounds(val, (0, 10))
+                            self[f"STRIP {index}||SLIDER {param}"].update(value=util.check_bounds(val, (0, 10)))
+                        case "BASS" | "MID" | "TREBLE":
+                            setattr(self.vm.strip[int(index)], param.lower(), util.check_bounds(val, (-12, 12)))
+                            self[f"STRIP {index}||SLIDER {param}"].update(value=util.check_bounds(val, (-12, 12)))
+                        case "LIMIT":
+                            self.vm.strip[int(index)].limit = util.check_bounds(val, (-40, 12))
+                            self[f"STRIP {index}||SLIDER {param}"].update(value=util.check_bounds(val, (-40, 12)))
+                case [
+                    ["STRIP", index],
+                    [
+                        "SLIDER",
+                        "GAIN"
+                        | "COMP"
+                        | "GATE"
+                        | "DENOISER"
+                        | "AUDIBILITY"
+                        | "LIMIT"
+                        | "BASS"
+                        | "MID"
+                        | "TREBLE" as param,
+                    ],
+                    ["KEY", "CTRL", "LEFT" | "RIGHT" | "UP" | "DOWN" as direction],
+                ]:
+                    match param:
+                        case "GAIN":
+                            val = self.vm.strip[int(index)].gain
+                        case "COMP" | "GATE" | "DENOISER":
+                            target = getattr(self.vm.strip[int(index)], param.lower())
+                            val = target.knob
+                        case "AUDIBILITY":
+                            val = self.vm.strip[int(index)].audibility
+                        case "BASS" | "MID" | "TREBLE":
+                            val = getattr(self.vm.strip[int(index)], param.lower())
+                        case "LIMIT":
+                            val = self.vm.strip[int(index)].limit
+
+                    match direction:
+                        case "RIGHT" | "UP":
+                            if param in ("COMP", "GATE", "DENOISER", "AUDIBILITY", "BASS", "MID", "TREBLE"):
+                                val += 1
+                            else:
+                                val += 3
+                        case "LEFT" | "DOWN":
+                            if param in ("COMP", "GATE", "DENOISER", "AUDIBILITY", "BASS", "MID", "TREBLE"):
+                                val -= 1
+                            else:
+                                val -= 3
+
+                    match param:
+                        case "GAIN":
+                            self.vm.strip[int(index)].gain = util.check_bounds(val, (-60, 12))
+                            self[f"STRIP {index}||SLIDER {param}"].update(value=util.check_bounds(val, (-60, 12)))
+                        case "COMP" | "GATE" | "DENOISER":
+                            setattr(target, "knob", util.check_bounds(val, (0, 10)))
+                            self[f"STRIP {index}||SLIDER {param}"].update(value=util.check_bounds(val, (0, 10)))
+                        case "AUDIBILITY":
+                            self.vm.strip[int(index)].audibility = util.check_bounds(val, (0, 10))
+                            self[f"STRIP {index}||SLIDER {param}"].update(value=util.check_bounds(val, (0, 10)))
+                        case "BASS" | "MID" | "TREBLE":
+                            setattr(self.vm.strip[int(index)], param.lower(), util.check_bounds(val, (-12, 12)))
+                            self[f"STRIP {index}||SLIDER {param}"].update(value=util.check_bounds(val, (-12, 12)))
+                        case "LIMIT":
+                            self.vm.strip[int(index)].limit = util.check_bounds(val, (-40, 12))
+                            self[f"STRIP {index}||SLIDER {param}"].update(value=util.check_bounds(val, (-40, 12)))
+                case [
+                    ["STRIP", index],
+                    [
+                        "SLIDER",
+                        "GAIN"
+                        | "COMP"
+                        | "GATE"
+                        | "DENOISER"
+                        | "AUDIBILITY"
+                        | "LIMIT"
+                        | "BASS"
+                        | "MID"
+                        | "TREBLE" as param,
+                    ],
+                    ["KEY", "SHIFT", "LEFT" | "RIGHT" | "UP" | "DOWN" as direction],
+                ]:
+                    match param:
+                        case "GAIN":
+                            val = self.vm.strip[int(index)].gain
+                        case "COMP" | "GATE" | "DENOISER":
+                            target = getattr(self.vm.strip[int(index)], param.lower())
+                            val = target.knob
+                        case "AUDIBILITY":
+                            val = self.vm.strip[int(index)].audibility
+                        case "BASS" | "MID" | "TREBLE":
+                            val = getattr(self.vm.strip[int(index)], param.lower())
+                        case "LIMIT":
+                            val = self.vm.strip[int(index)].limit
+
+                    match direction:
+                        case "RIGHT" | "UP":
+                            if param == "LIMIT":
+                                val += 1
+                            else:
+                                val += 0.1
+                        case "LEFT" | "DOWN":
+                            if param == "LIMIT":
+                                val -= 1
+                            else:
+                                val -= 0.1
+
+                    match param:
+                        case "GAIN":
+                            self.vm.strip[int(index)].gain = util.check_bounds(val, (-60, 12))
+                            self[f"STRIP {index}||SLIDER {param}"].update(value=util.check_bounds(val, (-60, 12)))
+                        case "COMP" | "GATE" | "DENOISER":
+                            setattr(target, "knob", util.check_bounds(val, (0, 10)))
+                            self[f"STRIP {index}||SLIDER {param}"].update(value=util.check_bounds(val, (0, 10)))
+                        case "AUDIBILITY":
+                            self.vm.strip[int(index)].audibility = util.check_bounds(val, (0, 10))
+                            self[f"STRIP {index}||SLIDER {param}"].update(value=util.check_bounds(val, (0, 10)))
+                        case "BASS" | "MID" | "TREBLE":
+                            setattr(self.vm.strip[int(index)], param.lower(), util.check_bounds(val, (-12, 12)))
+                            self[f"STRIP {index}||SLIDER {param}"].update(value=util.check_bounds(val, (-12, 12)))
+                        case "LIMIT":
+                            self.vm.strip[int(index)].limit = util.check_bounds(val, (-40, 12))
+                            self[f"STRIP {index}||SLIDER {param}"].update(value=util.check_bounds(val, (-40, 12)))
+
                # Bus Params
                case [["BUS", index], [param]]:
                    val = self.cache["bus"][event]
@@ -586,7 +928,7 @@ class NVDAVMWindow(psg.Window):
                                f"{label} bus {param} {'on' if val else 'off'}",
                            )
                        case "MODE":
-                            bus_modes = get_bus_modes(self.vm)
+                            bus_modes = util.get_bus_modes(self.vm)
                            next_index = bus_modes.index(val) + 1
                            if next_index == len(bus_modes):
                                next_index = 0
@@ -611,6 +953,7 @@ class NVDAVMWindow(psg.Window):
                                f"{label} bus mode {phonetic.get(next_bus, next_bus)}",
                            )
                case [["BUS", index], [param], ["FOCUS", "IN"]]:
+                    if self.find_element_with_focus() is not None:
                        label = self.cache["labels"][f"BUS {index}||LABEL"]
                        val = self.cache["bus"][f"BUS {index}||{param}"]
                        if param == "MODE":
@@ -620,6 +963,56 @@ class NVDAVMWindow(psg.Window):
                case [["BUS", index], [param], ["KEY", "ENTER"]]:
                    self.find_element_with_focus().click()

+                # Bus Sliders
+                case [["BUS", index], ["SLIDER", "GAIN"]]:
+                    label = self.cache["labels"][f"BUS {index}||LABEL"]
+                    val = values[event]
+                    self.vm.bus[int(index)].gain = val
+                    self.nvda.speak(f"{label} gain slider {val}")
+                case [["BUS", index], ["SLIDER", "GAIN"], ["FOCUS", "IN"]]:
+                    if self.find_element_with_focus() is not None:
+                        self.vm.event.pdirty = False
+                        label = self.cache["labels"][f"BUS {index}||LABEL"]
+                        val = values[f"BUS {index}||SLIDER GAIN"]
+                        self.nvda.speak(f"{label} gain slider {val}")
+                case [["BUS", index], ["SLIDER", "GAIN"], ["FOCUS", "OUT"]]:
+                    self.vm.event.pdirty = True
+                case [["BUS", index], ["SLIDER", "GAIN"], ["KEY", "LEFT" | "RIGHT" | "UP" | "DOWN" as direction]]:
+                    val = self.vm.bus[int(index)].gain
+                    match direction:
+                        case "RIGHT" | "UP":
+                            val += 1
+                        case "LEFT" | "DOWN":
+                            val -= 1
+                    self.vm.bus[int(index)].gain = util.check_bounds(val, (-60, 12))
+                    self[f"BUS {index}||SLIDER GAIN"].update(value=val)
+                case [
+                    ["BUS", index],
+                    ["SLIDER", "GAIN"],
+                    ["KEY", "CTRL", "LEFT" | "RIGHT" | "UP" | "DOWN" as direction],
+                ]:
+                    val = self.vm.bus[int(index)].gain
+                    match direction:
+                        case "RIGHT" | "UP":
+                            val += 3
+                        case "LEFT" | "DOWN":
+                            val -= 3
+                    self.vm.bus[int(index)].gain = util.check_bounds(val, (-60, 12))
+                    self[f"BUS {index}||SLIDER GAIN"].update(value=val)
+                case [
+                    ["BUS", index],
+                    ["SLIDER", "GAIN"],
+                    ["KEY", "SHIFT", "LEFT" | "RIGHT" | "UP" | "DOWN" as direction],
+                ]:
+                    val = self.vm.bus[int(index)].gain
+                    match direction:
+                        case "RIGHT" | "UP":
+                            val += 0.1
+                        case "LEFT" | "DOWN":
+                            val -= 0.1
+                    self.vm.bus[int(index)].gain = util.check_bounds(val, (-60, 12))
+                    self[f"BUS {index}||SLIDER GAIN"].update(value=val)
+
                # Unknown
                case _:
                    self.logger.debug(f"Unknown event {event}")
Author	SHA1	Message	Date
onyx-and-iris	ac14b7ad0d	adds sliders to on_pdirty bump to b2	2023-09-17 14:49:42 +01:00
onyx-and-iris	78b7e01fa6	bump to 0.2.1.b1	2023-09-17 12:36:15 +01:00
onyx-and-iris	42fad86905	defines bass,mid,treble ctrl events	2023-09-17 12:23:04 +01:00
onyx-and-iris	6c54d28210	define focus out for bass,mid,treble	2023-09-17 12:09:38 +01:00
onyx-and-iris	d958167ded	fixes comp, gate, denoiser ctrl+up/down/left/right	2023-09-17 12:07:14 +01:00
onyx-and-iris	0570138963	bass, mid, treble slider events defined	2023-09-17 11:44:15 +01:00
onyx-and-iris	1fdb39a041	events defined for sliders resolution fix for limit slider	2023-09-17 11:25:11 +01:00
onyx-and-iris	3d7b33c8be	fix events for sliders	2023-09-17 10:18:22 +01:00
onyx-and-iris	cf5c8f81aa	bind events added for sliders	2023-09-17 09:30:38 +01:00
onyx-and-iris	c248808c7b	LabelSlider compound element added labels for sliders added. all sliders now focusable. todo: add events/binds for sliders	2023-09-16 23:13:56 +01:00
onyx-and-iris	d93f078365	upd type annotations cleanup global namespace.	2023-09-16 20:28:07 +01:00
onyx-and-iris	e0f36b2411	start laying out parameter sliders.	2023-09-16 10:45:56 +01:00
onyx-and-iris	719328c6de	adds check bounds. bump pre-release a3	2023-09-15 23:01:26 +01:00
onyx-and-iris	65a148aa7b	bump to pre-release a2	2023-09-15 19:16:30 +01:00
onyx-and-iris	ba1fb28187	use gain getters.	2023-09-15 19:12:07 +01:00
onyx-and-iris	e35bad9e1e	a1 version bump	2023-09-15 13:48:19 +01:00
onyx-and-iris	804af85e65	adds up,down bind events	2023-09-15 12:35:10 +01:00
onyx-and-iris	96de917b64	gain slider control events registered allows adjusting gain by different amounts.	2023-09-15 11:35:27 +01:00
onyx-and-iris	bc14116cd7	places gain sliders on slider tabs slider focus in/out events registered.	2023-09-15 10:55:22 +01:00
onyx-and-iris	086fbc1b8c	start laying out nested tab structure focus in events added for tabgroups focus the settings tab on startup	2023-09-14 13:46:26 +01:00
onyx-and-iris	047577265c	documentation changes python version upper limit increased to support 3.11	2023-09-14 08:43:15 +01:00
onyx-and-iris	7ab7c30e80	adds advanced settings for Basic kind.	2023-09-13 14:12:48 +01:00
onyx-and-iris	bfdc0306e3	update default values for each driver type open advanced settings popup if current tab is settings. minor version bump	2023-09-13 12:16:28 +01:00
onyx-and-iris	245476adfd	Merge remote-tracking branch 'origin/dev' into add-advanced-settings	2023-09-13 11:30:00 +01:00
onyx-and-iris	2562c02b7e	lstrip hardware in as well.	2023-09-13 10:59:41 +01:00
onyx-and-iris	aaa2c72668	fixes bug setting devices with trailing spaces adds rejected_ids to util. removes Voicemeeter devices as assignable hardware devices patch bump	2023-09-13 10:56:09 +01:00
onyx-and-iris	7648b68b85	remove asio devices from hardware out context menus if not A1 removes `-remove device selection-` from hardware out A1 context menu patch bump fixes #7	2023-09-11 12:36:40 +01:00
onyx-and-iris	14c6b937d1	implements advanced settings popup gives access to driver buffer settings. may open by button or ctrl-a	2023-09-11 07:51:16 +01:00
onyx-and-iris	5069db97da	ensure Virtual Input gets correct label if cleared	2023-09-10 14:32:31 +01:00
onyx-and-iris	681bf8e85c	fixes bug renaming virtual strips. patch bump	2023-09-10 14:23:34 +01:00
onyx-and-iris	8424558f3d	special thanks section added to readme	2023-09-07 07:29:04 +01:00