adds ctrl+shift+r slider reset bind

closes #9 patch bump
adds sliders to on_pdirty
2026-04-07 09:53:35 +00:00 · 2023-09-18 09:12:12 +01: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
5 changed files with 424 additions and 122 deletions
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,6 +1,6 @@
 [project]
 name = "nvda_voicemeeter"
-version = "0.2.1a3"
+version = "0.2.2"
 description = "A Voicemeeter app compatible with NVDA"
 authors = [
    { name = "onyx-and-iris", email = "code@onyxandiris.online" },
--- a/src/nvda_voicemeeter/builder.py
+++ b/src/nvda_voicemeeter/builder.py
@@ -1,13 +1,7 @@
 import PySimpleGUI as psg

-from .util import (
-    get_asio_checkbox_index,
-    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:
@@ -91,7 +85,7 @@ class Builder:
            return psg.Tab(identifier, [[tabgroup]], key=f"tab||{identifier}")

        tabs = []
-        for tab in get_tabs_labels():
+        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")
@@ -116,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(
                [
@@ -147,7 +141,7 @@ class Builder:
                    psg.ButtonMenu(
                        f"A{i + 1}",
                        size=(6, 3),
-                        menu_def=["", get_output_device_list(i, self.vm)],
+                        menu_def=["", util.get_output_device_list(i, self.vm)],
                        key=f"HARDWARE OUT||A{i + 1}",
                    )
                    for i in range(num_outs)
@@ -167,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",
@@ -178,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",
@@ -199,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(
@@ -226,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}",
                            )
@@ -239,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}",
                        )
@@ -314,6 +308,7 @@ class Builder:
        def add_gain_slider(layout):
            layout.append(
                [
+                    psg.Text("Gain"),
                    psg.Slider(
                        range=(-60, 12),
                        default_value=self.vm.strip[i].gain,
@@ -323,13 +318,36 @@ class Builder:
                        enable_events=True,
                        orientation="horizontal",
                        key=f"STRIP {i}||SLIDER GAIN",
-                    )
+                    ),
                ]
            )

-        outputs = []
-        [step(outputs) for step in (add_gain_slider,)]
-        return psg.Frame(self.window.cache["labels"][f"STRIP {i}||LABEL"], outputs, key=f"STRIP {i}||LABEL||SLIDER")
+        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)]
@@ -382,6 +400,7 @@ class Builder:
        def add_gain_slider(layout):
            layout.append(
                [
+                    psg.Text("Gain"),
                    psg.Slider(
                        range=(-60, 12),
                        default_value=self.vm.strip[i].gain,
@@ -391,13 +410,45 @@ class Builder:
                        enable_events=True,
                        orientation="horizontal",
                        key=f"STRIP {i}||SLIDER GAIN",
-                    )
+                    ),
                ]
            )

-        outputs = []
-        [step(outputs) for step in (add_gain_slider,)]
-        return psg.Frame(self.window.cache["labels"][f"STRIP {i}||LABEL"], outputs, key=f"STRIP {i}||LABEL||SLIDER")
+        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 = [
--- 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/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,8 +11,7 @@ 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 * num - 1
    return (2 * kind.phys_in) + (8 * (num - kind.phys_in - 1)) + channel


@@ -130,10 +132,21 @@ def get_bus_modes(vm) -> list:
    ]


-def check_bounds(val, bounds):
+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,29 +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,
-    check_bounds,
-    get_asio_checkbox_index,
-    get_asio_samples_list,
-    get_bus_modes,
-    get_channel_identifier_list,
-    get_insert_checkbox_index,
-    get_patch_composite_list,
-    get_tabs_labels,
-    open_context_menu_for_buttonmenu,
-)

 logger = logging.getLogger(__name__)

@@ -43,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()
@@ -67,7 +48,11 @@ class NVDAVMWindow(psg.Window):
            [self[f"PATCH COMPOSITE||PC{i + 1}"].Widget.config(**buttonmenu_opts) for i in range(self.kind.phys_out)]
        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[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)

@@ -107,29 +92,38 @@ 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):
@@ -137,7 +131,7 @@ class NVDAVMWindow(psg.Window):

        # TABS
        self["tabgroup"].bind("<FocusIn>", "||FOCUS IN")
-        for tabname in get_tabs_labels()[1:]:
+        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")
@@ -205,20 +199,24 @@ class NVDAVMWindow(psg.Window):

        # Strip Sliders
        for i in range(self.kind.num_strip):
-            self[f"STRIP {i}||SLIDER GAIN"].bind("<FocusIn>", "||FOCUS IN")
-            self[f"STRIP {i}||SLIDER GAIN"].bind("<FocusOut>", "||FOCUS OUT")
-            self[f"STRIP {i}||SLIDER GAIN"].bind("<Left>", "||KEY LEFT")
-            self[f"STRIP {i}||SLIDER GAIN"].bind("<Right>", "||KEY RIGHT")
-            self[f"STRIP {i}||SLIDER GAIN"].bind("<Shift-KeyPress-Left>", "||KEY SHIFT LEFT")
-            self[f"STRIP {i}||SLIDER GAIN"].bind("<Shift-KeyPress-Right>", "||KEY SHIFT RIGHT")
-            self[f"STRIP {i}||SLIDER GAIN"].bind("<Control-KeyPress-Left>", "||KEY CTRL LEFT")
-            self[f"STRIP {i}||SLIDER GAIN"].bind("<Control-KeyPress-Right>", "||KEY CTRL RIGHT")
-            self[f"STRIP {i}||SLIDER GAIN"].bind("<Up>", "||KEY UP")
-            self[f"STRIP {i}||SLIDER GAIN"].bind("<Down>", "||KEY DOWN")
-            self[f"STRIP {i}||SLIDER GAIN"].bind("<Shift-KeyPress-Up>", "||KEY SHIFT UP")
-            self[f"STRIP {i}||SLIDER GAIN"].bind("<Shift-KeyPress-Down>", "||KEY SHIFT DOWN")
-            self[f"STRIP {i}||SLIDER GAIN"].bind("<Control-KeyPress-Up>", "||KEY CTRL UP")
-            self[f"STRIP {i}||SLIDER GAIN"].bind("<Control-KeyPress-Down>", "||KEY CTRL DOWN")
+            for param in util.get_slider_params(i, self.vm) + ("GAIN", "LIMIT"):
+                if self.kind.name == "basic" and param == "LIMIT":
+                    continue
+                self[f"STRIP {i}||SLIDER {param}"].bind("<FocusIn>", "||FOCUS IN")
+                self[f"STRIP {i}||SLIDER {param}"].bind("<FocusOut>", "||FOCUS OUT")
+                self[f"STRIP {i}||SLIDER {param}"].bind("<Left>", "||KEY LEFT")
+                self[f"STRIP {i}||SLIDER {param}"].bind("<Right>", "||KEY RIGHT")
+                self[f"STRIP {i}||SLIDER {param}"].bind("<Shift-KeyPress-Left>", "||KEY SHIFT LEFT")
+                self[f"STRIP {i}||SLIDER {param}"].bind("<Shift-KeyPress-Right>", "||KEY SHIFT RIGHT")
+                self[f"STRIP {i}||SLIDER {param}"].bind("<Control-KeyPress-Left>", "||KEY CTRL LEFT")
+                self[f"STRIP {i}||SLIDER {param}"].bind("<Control-KeyPress-Right>", "||KEY CTRL RIGHT")
+                self[f"STRIP {i}||SLIDER {param}"].bind("<Up>", "||KEY UP")
+                self[f"STRIP {i}||SLIDER {param}"].bind("<Down>", "||KEY DOWN")
+                self[f"STRIP {i}||SLIDER {param}"].bind("<Shift-KeyPress-Up>", "||KEY SHIFT UP")
+                self[f"STRIP {i}||SLIDER {param}"].bind("<Shift-KeyPress-Down>", "||KEY SHIFT DOWN")
+                self[f"STRIP {i}||SLIDER {param}"].bind("<Control-KeyPress-Up>", "||KEY CTRL UP")
+                self[f"STRIP {i}||SLIDER {param}"].bind("<Control-KeyPress-Down>", "||KEY CTRL DOWN")
+                self[f"STRIP {i}||SLIDER {param}"].bind("<Control-Shift-KeyPress-R>", "||KEY CTRL SHIFT R")

        # Bus Params
        params = ["MONO", "EQ", "MUTE", "MODE"]
@@ -245,6 +243,7 @@ class NVDAVMWindow(psg.Window):
            self[f"BUS {i}||SLIDER GAIN"].bind("<Shift-KeyPress-Down>", "||KEY SHIFT DOWN")
            self[f"BUS {i}||SLIDER GAIN"].bind("<Control-KeyPress-Up>", "||KEY CTRL UP")
            self[f"BUS {i}||SLIDER GAIN"].bind("<Control-KeyPress-Down>", "||KEY CTRL DOWN")
+            self[f"BUS {i}||SLIDER GAIN"].bind("<Control-Shift-KeyPress-R>", "||KEY CTRL SHIFT R")

    def popup_save_as(self, message, title=None, initial_folder=None):
        layout = [
@@ -339,7 +338,7 @@ class NVDAVMWindow(psg.Window):
                    psg.ButtonMenu(
                        driver,
                        size=(14, 2),
-                        menu_def=["", get_asio_samples_list(driver)],
+                        menu_def=["", util.get_asio_samples_list(driver)],
                        key=f"BUFFER {driver}",
                    )
                    for driver in ("MME", "WDM", "KS", "ASIO")
@@ -386,7 +385,7 @@ class NVDAVMWindow(psg.Window):
                    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"]]:
-                    open_context_menu_for_buttonmenu(window, f"BUFFER {driver}")
+                    util.open_context_menu_for_buttonmenu(window, f"BUFFER {driver}")
                case [[button], ["FOCUS", "IN"]]:
                    self.nvda.speak(button)
                case [[button], ["KEY", "ENTER"]]:
@@ -424,21 +423,21 @@ class NVDAVMWindow(psg.Window):
                        index = int(data["Index"]) - 1
                        match tab:
                            case "Physical Strip":
-                                label = data.get("Edit") or f"Hardware Input {index + 1}"
+                                label = data.get("Edit", f"Hardware Input {index + 1}")
                                self.vm.strip[index].label = label
                                self[f"STRIP {index}||LABEL"].update(value=label)
                                self.cache["labels"][f"STRIP {index}||LABEL"] = label
                            case "Virtual Strip":
                                index += self.kind.phys_in
-                                label = data.get("Edit") or f"Virtual Input {index - self.kind.phys_in + 1}"
+                                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
@@ -476,6 +475,8 @@ class NVDAVMWindow(psg.Window):
                        filepath = Path(filepath)
                        self.vm.set("command.load", str(filepath))
                        self.logger.debug(f"loading config file from {filepath}")
+                        for i in (25, 50):  # for the benefit of the sliders
+                            self.TKroot.after(i, self.on_pdirty)
                        self.TKroot.after(
                            200,
                            self.nvda.speak,
@@ -534,7 +535,7 @@ class NVDAVMWindow(psg.Window):
                    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]]:
@@ -556,11 +557,11 @@ class NVDAVMWindow(psg.Window):
                    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)]
@@ -576,7 +577,7 @@ 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:
@@ -584,14 +585,14 @@ class NVDAVMWindow(psg.Window):
                            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]),
@@ -599,17 +600,17 @@ 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"]]:
                    if self.find_element_with_focus() is not None:
-                        index = get_insert_checkbox_index(
+                        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'}")

@@ -678,54 +679,249 @@ class NVDAVMWindow(psg.Window):
                    self.find_element_with_focus().click()

                # Strip Sliders
-                case [["STRIP", index], ["SLIDER", "GAIN"]]:
+                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]
-                    self.vm.strip[int(index)].gain = val
-                    self.nvda.speak(f"{label} gain slider {val}")
-                case [["STRIP", index], ["SLIDER", "GAIN"], ["FOCUS", "IN"]]:
+                    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 GAIN"]
-                        self.nvda.speak(f"{label} gain slider {val}")
-                case [["STRIP", index], ["SLIDER", "GAIN"], ["FOCUS", "OUT"]]:
+                        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"], ["KEY", "LEFT" | "RIGHT" | "UP" | "DOWN" as direction]]:
-                    val = self.vm.strip[int(index)].gain
+                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
-                    self.vm.strip[int(index)].gain = check_bounds(val, (-60, 12))
-                    self[f"STRIP {index}||SLIDER GAIN"].update(value=val)
+
+                    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"],
+                    [
+                        "SLIDER",
+                        "GAIN"
+                        | "COMP"
+                        | "GATE"
+                        | "DENOISER"
+                        | "AUDIBILITY"
+                        | "LIMIT"
+                        | "BASS"
+                        | "MID"
+                        | "TREBLE" as param,
+                    ],
                    ["KEY", "CTRL", "LEFT" | "RIGHT" | "UP" | "DOWN" as direction],
                ]:
-                    val = self.vm.strip[int(index)].gain
+                    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 += 3
+                            if param in ("COMP", "GATE", "DENOISER", "AUDIBILITY", "BASS", "MID", "TREBLE"):
+                                val += 1
+                            else:
+                                val += 3
                        case "LEFT" | "DOWN":
-                            val -= 3
-                    self.vm.strip[int(index)].gain = check_bounds(val, (-60, 12))
-                    self[f"STRIP {index}||SLIDER GAIN"].update(value=val)
+                            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"],
+                    [
+                        "SLIDER",
+                        "GAIN"
+                        | "COMP"
+                        | "GATE"
+                        | "DENOISER"
+                        | "AUDIBILITY"
+                        | "LIMIT"
+                        | "BASS"
+                        | "MID"
+                        | "TREBLE" as param,
+                    ],
                    ["KEY", "SHIFT", "LEFT" | "RIGHT" | "UP" | "DOWN" as direction],
                ]:
-                    val = self.vm.strip[int(index)].gain
+                    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 += 0.1
+                            if param == "LIMIT":
+                                val += 1
+                            else:
+                                val += 0.1
                        case "LEFT" | "DOWN":
-                            val -= 0.1
-                    self.vm.strip[int(index)].gain = check_bounds(val, (-60, 12))
-                    self[f"STRIP {index}||SLIDER GAIN"].update(value=val)
+                            if param == "LIMIT":
+                                val -= 1
+                            else:
+                                val -= 0.1
+
+                    match param:
+                        case "GAIN":
+                            self.vm.strip[int(index)].gain = util.check_bounds(val, (-60, 12))
+                            self[f"STRIP {index}||SLIDER {param}"].update(value=util.check_bounds(val, (-60, 12)))
+                        case "COMP" | "GATE" | "DENOISER":
+                            setattr(target, "knob", util.check_bounds(val, (0, 10)))
+                            self[f"STRIP {index}||SLIDER {param}"].update(value=util.check_bounds(val, (0, 10)))
+                        case "AUDIBILITY":
+                            self.vm.strip[int(index)].audibility = util.check_bounds(val, (0, 10))
+                            self[f"STRIP {index}||SLIDER {param}"].update(value=util.check_bounds(val, (0, 10)))
+                        case "BASS" | "MID" | "TREBLE":
+                            setattr(self.vm.strip[int(index)], param.lower(), util.check_bounds(val, (-12, 12)))
+                            self[f"STRIP {index}||SLIDER {param}"].update(value=util.check_bounds(val, (-12, 12)))
+                        case "LIMIT":
+                            self.vm.strip[int(index)].limit = util.check_bounds(val, (-40, 12))
+                            self[f"STRIP {index}||SLIDER {param}"].update(value=util.check_bounds(val, (-40, 12)))
+                case [["STRIP", index], ["SLIDER", param], ["KEY", "CTRL", "SHIFT", "R"]]:
+                    match param:
+                        case "GAIN":
+                            self.vm.strip[int(index)].gain = 0
+                            self[f"STRIP {index}||SLIDER {param}"].update(value=0)
+                        case "COMP" | "GATE" | "DENOISER":
+                            setattr(target, "knob", 0)
+                            self[f"STRIP {index}||SLIDER {param}"].update(value=0)
+                        case "AUDIBILITY":
+                            self.vm.strip[int(index)].audibility = 0
+                            self[f"STRIP {index}||SLIDER {param}"].update(value=0)
+                        case "BASS" | "MID" | "TREBLE":
+                            setattr(self.vm.strip[int(index)], param.lower(), 0)
+                            self[f"STRIP {index}||SLIDER {param}"].update(value=0)
+                        case "LIMIT":
+                            self.vm.strip[int(index)].limit = 12
+                            self[f"STRIP {index}||SLIDER {param}"].update(value=12)

                # Bus Params
                case [["BUS", index], [param]]:
@@ -751,7 +947,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
@@ -807,7 +1003,7 @@ class NVDAVMWindow(psg.Window):
                            val += 1
                        case "LEFT" | "DOWN":
                            val -= 1
-                    self.vm.bus[int(index)].gain = check_bounds(val, (-60, 12))
+                    self.vm.bus[int(index)].gain = util.check_bounds(val, (-60, 12))
                    self[f"BUS {index}||SLIDER GAIN"].update(value=val)
                case [
                    ["BUS", index],
@@ -820,7 +1016,7 @@ class NVDAVMWindow(psg.Window):
                            val += 3
                        case "LEFT" | "DOWN":
                            val -= 3
-                    self.vm.bus[int(index)].gain = check_bounds(val, (-60, 12))
+                    self.vm.bus[int(index)].gain = util.check_bounds(val, (-60, 12))
                    self[f"BUS {index}||SLIDER GAIN"].update(value=val)
                case [
                    ["BUS", index],
@@ -833,8 +1029,11 @@ class NVDAVMWindow(psg.Window):
                            val += 0.1
                        case "LEFT" | "DOWN":
                            val -= 0.1
-                    self.vm.bus[int(index)].gain = check_bounds(val, (-60, 12))
+                    self.vm.bus[int(index)].gain = util.check_bounds(val, (-60, 12))
                    self[f"BUS {index}||SLIDER GAIN"].update(value=val)
+                case [["BUS", index], ["SLIDER", "GAIN"], ["KEY", "CTRL", "SHIFT", "R"]]:
+                    self.vm.bus[int(index)].gain = 0
+                    self[f"BUS {index}||SLIDER GAIN"].update(value=0)

                # Unknown
                case _:
Author	SHA1	Message	Date
onyx-and-iris	d722154325	adds ctrl+shift+r slider reset bind closes #9 patch bump	2023-09-18 09:12:12 +01:00
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