adjust cache to match strip layout

event keys updated

_get_bus_assignments added to util.py

patch bump

pdm.lock

@@ -251,13 +251,13 @@ files = [
 
 [[package]]
 name = "voicemeeter-api"
-version = "2.4.10"
+version = "2.4.11"
 requires_python = ">=3.10,<4.0"
 summary = "A Python wrapper for the Voiceemeter API"
 dependencies = [
     "tomli<3.0.0,>=2.0.1; python_version < \"3.11\"",
 ]
 files = [
-    {file = "voicemeeter_api-2.4.10-py3-none-any.whl", hash = "sha256:2f75acb7b472e56b6bd8d4f1141f32d948c55ef9b30d5a08e085a1c8e76e2464"},
+    {file = "voicemeeter_api-2.4.11-py3-none-any.whl", hash = "sha256:7a1b290d90c851204438c18e2d343e568c242fcd1e664c5b88d4019a553d44e1"},
-    {file = "voicemeeter_api-2.4.10.tar.gz", hash = "sha256:1d8dfc1e8922179f8b97c90b90b9ed051082018c6af5feb1d48250140a02d40c"},
+    {file = "voicemeeter_api-2.4.11.tar.gz", hash = "sha256:875591ad326a7a13ef141536cca83953edcda81da256191bab3844bac46a0e70"},
 ]

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nvda_voicemeeter"
-version = "0.5.0"
+version = "0.5.5"
 description = "A Voicemeeter app compatible with NVDA"
 authors = [
     { name = "onyx-and-iris", email = "code@onyxandiris.online" },
@@ -8,7 +8,7 @@ authors = [
 dependencies = [
     "pysimplegui>=4.60.5",
     "pyparsing>=3.1.1",
-    "voicemeeter-api>=2.4.10",
+    "voicemeeter-api>=2.4.11",
 ]
 requires-python = ">=3.10,<3.12"
 readme = "README.md"

src/nvda_voicemeeter/builder.py

@@ -197,16 +197,16 @@ class Builder:
         """tab0 row3 represents patch composite"""
 
         def add_physical_device_opts(layout):
-            outputs = util.get_patch_composite_list(self.vm.kind)
+            outputs = util.get_patch_composite_list(self.kind)
             layout.append(
                 [
                     psg.ButtonMenu(
                         f"PC{i + 1}",
-                        size=(6, 2),
+                        size=(5, 2),
                         menu_def=["", outputs],
                         key=f"PATCH COMPOSITE||PC{i + 1}",
                     )
-                    for i in range(self.kind.phys_out)
+                    for i in range(self.kind.composite)
                 ]
             )
 
@@ -381,7 +381,7 @@ class Builder:
             if i == self.kind.phys_in + 1:
                 layout.append(
                     [
-                        psg.Button("K", size=(6, 2), key=f"STRIP {i}||MONO"),
+                        psg.Button("K", size=(6, 2), key=f"STRIP {i}||KARAOKE"),
                         psg.Button("Solo", size=(6, 2), key=f"STRIP {i}||SOLO"),
                         psg.Button("Mute", size=(6, 2), key=f"STRIP {i}||MUTE"),
                     ],
@@ -389,7 +389,7 @@ class Builder:
             else:
                 layout.append(
                     [
-                        psg.Button("MC", size=(6, 2), key=f"STRIP {i}||MONO"),
+                        psg.Button("MC", size=(6, 2), key=f"STRIP {i}||MC"),
                         psg.Button("Solo", size=(6, 2), key=f"STRIP {i}||SOLO"),
                         psg.Button("Mute", size=(6, 2), key=f"STRIP {i}||MUTE"),
                     ],
@@ -478,18 +478,26 @@ class Builder:
         """tab3 row represents bus composite toggle"""
 
         def add_strip_outputs(layout):
-            params = ["MONO", "EQ", "MUTE", "MODE"]
+            params = ["MONO", "EQ", "MUTE"]
-            if self.vm.kind.name == "basic":
+            if self.kind.name == "basic":
                 params.remove("EQ")
-            label = {"MODE": "BUSMODE"}
+            busmodes = [util._bus_mode_map[mode] for mode in util.get_bus_modes(self.vm)]
             layout.append(
                 [
-                    psg.Button(
+                    *[
-                        label.get(param, param.capitalize()),
+                        psg.Button(
-                        size=(12 if param == "MODE" else 6, 2),
+                            param.capitalize(),
-                        key=f"BUS {i}||{param}",
+                            size=(6, 2),
-                    )
+                            key=f"BUS {i}||{param}",
-                    for param in params
+                        )
+                        for param in params
+                    ],
+                    psg.ButtonMenu(
+                        "BUSMODE",
+                        size=(12, 2),
+                        menu_def=["", busmodes],
+                        key=f"BUS {i}||MODE",
+                    ),
                 ]
             )
 

src/nvda_voicemeeter/cdll.py

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

src/nvda_voicemeeter/compound.py

@@ -97,7 +97,7 @@ class CompSlider(psg.Slider):
                 return {
                     "range": (-24, 24),
                     "default_value": self.vm.strip[self.index].comp.gainout,
-                    "resolution": 0.01,
+                    "resolution": 0.1,
                     "disabled": True,
                 }
 

src/nvda_voicemeeter/models.py

@@ -5,7 +5,7 @@ def _make_hardware_ins_cache(vm) -> dict:
 def _make_hardware_outs_cache(vm) -> dict:
     hw_outs = {**{f"HARDWARE OUT||A{i + 1}": vm.bus[i].device.name for i in range(vm.kind.phys_out)}}
     if vm.kind.name == "basic":
-        hw_outs |= {f"HARDWARE OUT||A2": vm.bus[1].device.name}
+        hw_outs |= {"HARDWARE OUT||A2": vm.bus[1].device.name}
     return hw_outs
 
 
@@ -38,10 +38,15 @@ def _make_param_cache(vm, channel_type) -> dict:
                     **{f"STRIP {i}||B3": vm.strip[i].B3 for i in range(vm.kind.num_strip)},
                 }
         params |= {
-            **{f"STRIP {i}||MONO": vm.strip[i].mono for i in range(vm.kind.num_strip)},
+            **{f"STRIP {i}||MONO": vm.strip[i].mono for i in range(vm.kind.phys_in)},
             **{f"STRIP {i}||SOLO": vm.strip[i].solo for i in range(vm.kind.num_strip)},
             **{f"STRIP {i}||MUTE": vm.strip[i].mute for i in range(vm.kind.num_strip)},
         }
+        for i in range(vm.kind.phys_in, vm.kind.phys_in + vm.kind.virt_in):
+            if i == vm.kind.phys_in + 1:
+                params[f"STRIP {i}||KARAOKE"] = vm.strip[i].k
+            else:
+                params[f"STRIP {i}||MC"] = vm.strip[i].mc
     else:
         params |= {
             **{f"BUS {i}||MONO": vm.bus[i].mono for i in range(vm.kind.num_bus)},

src/nvda_voicemeeter/util.py

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

src/nvda_voicemeeter/window.py

@@ -45,9 +45,9 @@ class NVDAVMWindow(psg.Window):
         for i in range(self.kind.phys_out):
             self[f"HARDWARE OUT||A{i + 1}"].Widget.config(**buttonmenu_opts)
         if self.kind.name == "basic":
-            self[f"HARDWARE OUT||A2"].Widget.config(**buttonmenu_opts)
+            self["HARDWARE OUT||A2"].Widget.config(**buttonmenu_opts)
         if self.kind.name != "basic":
-            [self[f"PATCH COMPOSITE||PC{i + 1}"].Widget.config(**buttonmenu_opts) for i in range(self.kind.phys_out)]
+            [self[f"PATCH COMPOSITE||PC{i + 1}"].Widget.config(**buttonmenu_opts) for i in range(self.kind.composite)]
         slider_opts = {"takefocus": 1, "highlightthickness": 1}
         for i in range(self.kind.num_strip):
             for param in util.get_slider_params(i, self.kind):
@@ -57,6 +57,7 @@ class NVDAVMWindow(psg.Window):
                 self[f"STRIP {i}||SLIDER LIMIT"].Widget.config(**slider_opts)
         for i in range(self.kind.num_bus):
             self[f"BUS {i}||SLIDER GAIN"].Widget.config(**slider_opts)
+            self[f"BUS {i}||MODE"].Widget.config(**buttonmenu_opts)
         if self.kind.name != "basic":
             for i in range(self.kind.phys_out):
                 self[f"ASIO CHECKBOX||IN{i + 1} 0"].Widget.config(state="readonly")
@@ -179,20 +180,20 @@ class NVDAVMWindow(psg.Window):
                 self.bind(f"<Alt-Control-{event}-{direction}>", f"ALT CTRL {direction.upper()}||{event_id}")
 
         # Hardware In
-        for i in range(self.vm.kind.phys_in):
+        for i in range(self.kind.phys_in):
             self[f"HARDWARE IN||{i + 1}"].bind("<FocusIn>", "||FOCUS IN")
             self[f"HARDWARE IN||{i + 1}"].bind("<space>", "||KEY SPACE", propagate=False)
             self[f"HARDWARE IN||{i + 1}"].bind("<Return>", "||KEY ENTER", propagate=False)
 
         # Hardware Out
-        for i in range(self.vm.kind.phys_out):
+        for i in range(self.kind.phys_out):
             self[f"HARDWARE OUT||A{i + 1}"].bind("<FocusIn>", "||FOCUS IN")
             self[f"HARDWARE OUT||A{i + 1}"].bind("<space>", "||KEY SPACE", propagate=False)
             self[f"HARDWARE OUT||A{i + 1}"].bind("<Return>", "||KEY ENTER", propagate=False)
-        if self.vm.kind.name == "basic":
+        if self.kind.name == "basic":
-            self[f"HARDWARE OUT||A2"].bind("<FocusIn>", "||FOCUS IN")
+            self["HARDWARE OUT||A2"].bind("<FocusIn>", "||FOCUS IN")
-            self[f"HARDWARE OUT||A2"].bind("<space>", "||KEY SPACE", propagate=False)
+            self["HARDWARE OUT||A2"].bind("<space>", "||KEY SPACE", propagate=False)
-            self[f"HARDWARE OUT||A2"].bind("<Return>", "||KEY ENTER", propagate=False)
+            self["HARDWARE OUT||A2"].bind("<Return>", "||KEY ENTER", propagate=False)
 
         # Patch ASIO
         if self.kind.name != "basic":
@@ -202,7 +203,7 @@ class NVDAVMWindow(psg.Window):
 
         # Patch Composite
         if self.kind.name != "basic":
-            for i in range(self.vm.kind.phys_out):
+            for i in range(self.kind.composite):
                 self[f"PATCH COMPOSITE||PC{i + 1}"].bind("<FocusIn>", "||FOCUS IN")
                 self[f"PATCH COMPOSITE||PC{i + 1}"].bind("<space>", "||KEY SPACE", propagate=False)
                 self[f"PATCH COMPOSITE||PC{i + 1}"].bind("<Return>", "||KEY ENTER", propagate=False)
@@ -236,9 +237,14 @@ class NVDAVMWindow(psg.Window):
                     self[f"STRIP {i}||{param}"].bind("<FocusIn>", "||FOCUS IN")
                     self[f"STRIP {i}||{param}"].bind("<Return>", "||KEY ENTER")
             else:
-                for param in ("MONO", "SOLO", "MUTE"):
+                if i == self.kind.phys_in + 1:
-                    self[f"STRIP {i}||{param}"].bind("<FocusIn>", "||FOCUS IN")
+                    for param in ("KARAOKE", "SOLO", "MUTE"):
-                    self[f"STRIP {i}||{param}"].bind("<Return>", "||KEY ENTER")
+                        self[f"STRIP {i}||{param}"].bind("<FocusIn>", "||FOCUS IN")
+                        self[f"STRIP {i}||{param}"].bind("<Return>", "||KEY ENTER")
+                else:
+                    for param in ("MC", "SOLO", "MUTE"):
+                        self[f"STRIP {i}||{param}"].bind("<FocusIn>", "||FOCUS IN")
+                        self[f"STRIP {i}||{param}"].bind("<Return>", "||KEY ENTER")
 
         # Strip Sliders
         for i in range(self.kind.num_strip):
@@ -260,13 +266,16 @@ class NVDAVMWindow(psg.Window):
                 self[f"STRIP {i}||SLIDER {param}"].bind("<Control-Shift-KeyPress-R>", "||KEY CTRL SHIFT R")
 
         # Bus Params
-        params = ["MONO", "EQ", "MUTE", "MODE"]
+        params = ["MONO", "EQ", "MUTE"]
-        if self.vm.kind.name == "basic":
+        if self.kind.name == "basic":
             params.remove("EQ")
         for i in range(self.kind.num_bus):
             for param in params:
                 self[f"BUS {i}||{param}"].bind("<FocusIn>", "||FOCUS IN")
                 self[f"BUS {i}||{param}"].bind("<Return>", "||KEY ENTER")
+            self[f"BUS {i}||MODE"].bind("<FocusIn>", "||FOCUS IN")
+            self[f"BUS {i}||MODE"].bind("<space>", "||KEY SPACE", propagate=False)
+            self[f"BUS {i}||MODE"].bind("<Return>", "||KEY ENTER", propagate=False)
 
         # Bus Sliders
         for i in range(self.kind.num_bus):
@@ -300,13 +309,15 @@ class NVDAVMWindow(psg.Window):
             self.logger.debug(f"values::{values}")
             if event in (psg.WIN_CLOSED, "Exit"):
                 break
-            elif event.endswith("MODE"):
+            elif event in util.get_slider_modes():
                 mode = event
                 self.nvda.speak(f"{mode} enabled")
+                self.logger.debug(f"entered slider mode {mode}")
                 continue
             elif event == "ESCAPE":
                 if mode:
                     self.nvda.speak(f"{mode} disabled")
+                    self.logger.debug(f"exited from slider mode {mode}")
                     mode = None
                 continue
 
@@ -423,7 +434,7 @@ class NVDAVMWindow(psg.Window):
                             identifier, partial = focus.Key.split("||")
                             _, index = identifier.split()
                             index = int(index)
-                            data = self.popup.rename("Label", index, title=f"Rename", tab=tab)
+                            data = self.popup.rename("Label", index, title="Rename", tab=tab)
                             if not data:  # cancel was pressed
                                 continue
                             match tab:
@@ -599,14 +610,20 @@ class NVDAVMWindow(psg.Window):
                     val = values[f"PATCH COMPOSITE||{key}"]
                     index = int(key[-1]) - 1
                     self.vm.patch.composite[index].set(util.get_patch_composite_list(self.kind).index(val) + 1)
-                    self.TKroot.after(200, self.nvda.speak, f"PATCH COMPOSITE {key[-1]} set {val}")
+                    self.TKroot.after(200, self.nvda.speak, val)
                 case [["PATCH", "COMPOSITE"], [key], ["FOCUS", "IN"]]:
                     if self.find_element_with_focus() is not None:
                         if values[f"PATCH COMPOSITE||{key}"]:
                             val = values[f"PATCH COMPOSITE||{key}"]
                         else:
                             index = int(key[-1]) - 1
-                            val = util.get_patch_composite_list(self.kind)[self.vm.patch.composite[index].get() - 1]
+                            comp_index = self.vm.patch.composite[index].get()
+                            comp_list = util.get_patch_composite_list(self.kind)
+                            try:
+                                val = comp_list[comp_index - 1]
+                            except IndexError as e:
+                                val = comp_list[-1]
+                                self.logger.error(f"{type(e).__name__}: {e}")
                         self.nvda.speak(f"Patch COMPOSITE {key[-1]} {val}")
                 case [["PATCH", "COMPOSITE"], [key], ["KEY", "SPACE" | "ENTER"]]:
                     util.open_context_menu_for_buttonmenu(self, f"PATCH COMPOSITE||{key}")
@@ -647,54 +664,36 @@ class NVDAVMWindow(psg.Window):
 
                 # Strip Params
                 case [["STRIP", index], [param]]:
-                    label = self.cache["labels"][f"STRIP {index}||LABEL"]
                     match param:
-                        case "MONO":
+                        case "KARAOKE":
-                            if int(index) < self.kind.phys_in:
+                            opts = ["off", "k m", "k 1", "k 2", "k v"]
-                                actual = param.lower()
+                            next_val = self.vm.strip[int(index)].k + 1
-                            elif int(index) == self.kind.phys_in + 1:
+                            if next_val == len(opts):
-                                actual = "k"
+                                next_val = 0
-                            else:
+                            self.vm.strip[int(index)].k = next_val
-                                actual = "mc"
+                            self.cache["strip"][f"STRIP {index}||{param}"] = next_val
-                            phonetic = {"k": "karaoke"}
+                            self.nvda.speak(opts[next_val])
-                            if actual == "k":
+                        case output if param in util._get_bus_assignments(self.kind):
-                                next_val = self.vm.strip[int(index)].k + 1
+                            val = not self.cache["strip"][f"STRIP {index}||{output}"]
-                                if next_val == 4:
+                            setattr(self.vm.strip[int(index)], output, val)
-                                    next_val = 0
+                            self.cache["strip"][f"STRIP {index}||{output}"] = val
-                                setattr(self.vm.strip[int(index)], actual, next_val)
+                            self.nvda.speak("on" if val else "off")
-                                self.cache["strip"][f"STRIP {index}||{param}"] = next_val
-                                self.nvda.speak(["off", "k m", "k 1", "k 2"][next_val])
-                            else:
-                                val = not self.cache["strip"][f"STRIP {index}||{param}"]
-                                setattr(self.vm.strip[int(index)], actual, val)
-                                self.cache["strip"][f"STRIP {index}||{param}"] = val
-                                self.nvda.speak("on" if val else "off")
                         case _:
                             val = not self.cache["strip"][f"STRIP {index}||{param}"]
-                            setattr(self.vm.strip[int(index)], param if param[0] in ("A", "B") else param.lower(), val)
+                            setattr(self.vm.strip[int(index)], param.lower(), val)
                             self.cache["strip"][f"STRIP {index}||{param}"] = val
                             self.nvda.speak("on" if val else "off")
                 case [["STRIP", index], [param], ["FOCUS", "IN"]]:
                     if self.find_element_with_focus() is not None:
                         val = self.cache["strip"][f"STRIP {index}||{param}"]
-                        match param:
+                        phonetic = {"KARAOKE": "karaoke"}
-                            case "MONO":
-                                if int(index) < self.kind.phys_in:
-                                    actual = param.lower()
-                                elif int(index) == self.kind.phys_in + 1:
-                                    actual = "k"
-                                else:
-                                    actual = "mc"
-                            case _:
-                                actual = param
-                        phonetic = {"k": "karaoke"}
                         label = self.cache["labels"][f"STRIP {index}||LABEL"]
-                        if actual == "k":
+                        if param == "KARAOKE":
                             self.nvda.speak(
-                                f"{label} {phonetic.get(actual, actual)} {['off', 'k m', 'k 1', 'k 2'][self.cache['strip'][f'STRIP {int(index)}||{param}']]}"
+                                f"{label} {phonetic.get(param, param)} {['off', 'k m', 'k 1', 'k 2', 'k v'][self.cache['strip'][f'STRIP {int(index)}||{param}']]}"
                             )
                         else:
-                            self.nvda.speak(f"{label} {phonetic.get(actual, actual)} {'on' if val else 'off'}")
+                            self.nvda.speak(f"{label} {phonetic.get(param, param)} {'on' if val else 'off'}")
                 case [["STRIP", index], [param], ["KEY", "ENTER"]]:
                     self.find_element_with_focus().click()
 
@@ -1002,40 +1001,27 @@ class NVDAVMWindow(psg.Window):
                                 "on" if val else "off",
                             )
                         case "MODE":
-                            bus_modes = util.get_bus_modes(self.vm)
+                            chosen = util._bus_mode_map_reversed[values[event]]
-                            next_index = bus_modes.index(val) + 1
+                            setattr(self.vm.bus[int(index)].mode, chosen, True)
-                            if next_index == len(bus_modes):
+                            self.cache["bus"][event] = chosen
-                                next_index = 0
-                            next_bus = bus_modes[next_index]
-                            phonetic = {
-                                "amix": "Mix Down A",
-                                "bmix": "Mix Down B",
-                                "repeat": "Stereo Repeat",
-                                "tvmix": "Up Mix TV",
-                                "upmix21": "Up Mix 2.1",
-                                "upmix41": "Up Mix 4.1",
-                                "upmix61": "Up Mix 6.1",
-                                "centeronly": "Center Only",
-                                "lfeonly": "Low Frequency Effect Only",
-                                "rearonly": "Rear Only",
-                            }
-                            setattr(self.vm.bus[int(index)].mode, next_bus, True)
-                            self.cache["bus"][event] = next_bus
                             self.TKroot.after(
                                 200,
                                 self.nvda.speak,
-                                phonetic.get(next_bus, next_bus),
+                                util._bus_mode_map[chosen],
                             )
                 case [["BUS", index], [param], ["FOCUS", "IN"]]:
                     if self.find_element_with_focus() is not None:
                         label = self.cache["labels"][f"BUS {index}||LABEL"]
                         val = self.cache["bus"][f"BUS {index}||{param}"]
                         if param == "MODE":
-                            self.nvda.speak(f"{label} bus {param} {val}")
+                            self.nvda.speak(f"{label} bus {param} {util._bus_mode_map[val]}")
                         else:
-                            self.nvda.speak(f"{label} bus {param} {'on' if val else 'off'}")
+                            self.nvda.speak(f"{label} {param} {'on' if val else 'off'}")
-                case [["BUS", index], [param], ["KEY", "ENTER"]]:
+                case [["BUS", index], [param], ["KEY", "SPACE" | "ENTER"]]:
-                    self.find_element_with_focus().click()
+                    if param == "MODE":
+                        util.open_context_menu_for_buttonmenu(self, f"BUS {index}||MODE")
+                    else:
+                        self.find_element_with_focus().click()
 
                 # Bus Sliders
                 case [["BUS", index], ["SLIDER", "GAIN"]]: