pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nvda_voicemeeter"
-version = "0.2.1b2"
+version = "0.2.1a3"
 description = "A Voicemeeter app compatible with NVDA"
 authors = [
     { name = "onyx-and-iris", email = "code@onyxandiris.online" },

src/nvda_voicemeeter/compound.py

@@ -10,17 +10,13 @@ class LabelSlider(psg.Frame):
             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,
+                    resolution=0.1,
                     disable_number_display=True,
                     size=(12, 16),
                     expand_x=True,

src/nvda_voicemeeter/window.py

@@ -48,8 +48,12 @@ 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):
+            if i < self.kind.phys_in:
-                self[f"STRIP {i}||SLIDER {param}"].Widget.config(**slider_opts)
+                for param in util.get_slider_params(i, self.vm):
+                    self[f"STRIP {i}||SLIDER {param}"].Widget.config(**slider_opts)
+            else:
+                for param in ("BASS", "MID", "TREBLE"):
+                    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)
@@ -105,15 +109,6 @@ class NVDAVMWindow(psg.Window):
             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":
@@ -199,23 +194,20 @@ class NVDAVMWindow(psg.Window):
 
         # Strip Sliders
         for i in range(self.kind.num_strip):
-            for param in util.get_slider_params(i, self.vm) + ("GAIN", "LIMIT"):
+            self[f"STRIP {i}||SLIDER GAIN"].bind("<FocusIn>", "||FOCUS IN")
-                if self.kind.name == "basic" and param == "LIMIT":
+            self[f"STRIP {i}||SLIDER GAIN"].bind("<FocusOut>", "||FOCUS OUT")
-                    continue
+            self[f"STRIP {i}||SLIDER GAIN"].bind("<Left>", "||KEY LEFT")
-                self[f"STRIP {i}||SLIDER {param}"].bind("<FocusIn>", "||FOCUS IN")
+            self[f"STRIP {i}||SLIDER GAIN"].bind("<Right>", "||KEY RIGHT")
-                self[f"STRIP {i}||SLIDER {param}"].bind("<FocusOut>", "||FOCUS OUT")
+            self[f"STRIP {i}||SLIDER GAIN"].bind("<Shift-KeyPress-Left>", "||KEY SHIFT LEFT")
-                self[f"STRIP {i}||SLIDER {param}"].bind("<Left>", "||KEY LEFT")
+            self[f"STRIP {i}||SLIDER GAIN"].bind("<Shift-KeyPress-Right>", "||KEY SHIFT RIGHT")
-                self[f"STRIP {i}||SLIDER {param}"].bind("<Right>", "||KEY RIGHT")
+            self[f"STRIP {i}||SLIDER GAIN"].bind("<Control-KeyPress-Left>", "||KEY CTRL LEFT")
-                self[f"STRIP {i}||SLIDER {param}"].bind("<Shift-KeyPress-Left>", "||KEY SHIFT LEFT")
+            self[f"STRIP {i}||SLIDER GAIN"].bind("<Control-KeyPress-Right>", "||KEY CTRL RIGHT")
-                self[f"STRIP {i}||SLIDER {param}"].bind("<Shift-KeyPress-Right>", "||KEY SHIFT RIGHT")
+            self[f"STRIP {i}||SLIDER GAIN"].bind("<Up>", "||KEY UP")
-                self[f"STRIP {i}||SLIDER {param}"].bind("<Control-KeyPress-Left>", "||KEY CTRL LEFT")
+            self[f"STRIP {i}||SLIDER GAIN"].bind("<Down>", "||KEY DOWN")
-                self[f"STRIP {i}||SLIDER {param}"].bind("<Control-KeyPress-Right>", "||KEY CTRL RIGHT")
+            self[f"STRIP {i}||SLIDER GAIN"].bind("<Shift-KeyPress-Up>", "||KEY SHIFT UP")
-                self[f"STRIP {i}||SLIDER {param}"].bind("<Up>", "||KEY UP")
+            self[f"STRIP {i}||SLIDER GAIN"].bind("<Shift-KeyPress-Down>", "||KEY SHIFT DOWN")
-                self[f"STRIP {i}||SLIDER {param}"].bind("<Down>", "||KEY DOWN")
+            self[f"STRIP {i}||SLIDER GAIN"].bind("<Control-KeyPress-Up>", "||KEY CTRL UP")
-                self[f"STRIP {i}||SLIDER {param}"].bind("<Shift-KeyPress-Up>", "||KEY SHIFT UP")
+            self[f"STRIP {i}||SLIDER GAIN"].bind("<Control-KeyPress-Down>", "||KEY CTRL DOWN")
-                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"]
@@ -677,232 +669,54 @@ class NVDAVMWindow(psg.Window):
                     self.find_element_with_focus().click()
 
                 # Strip Sliders
-                case [
+                case [["STRIP", index], ["SLIDER", "GAIN"]]:
-                    ["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:
+                    self.vm.strip[int(index)].gain = val
-                        case "GAIN":
+                    self.nvda.speak(f"{label} gain slider {val}")
-                            self.vm.strip[int(index)].gain = val
+                case [["STRIP", index], ["SLIDER", "GAIN"], ["FOCUS", "IN"]]:
-                        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}"]
+                        val = values[f"STRIP {index}||SLIDER GAIN"]
-                        self.nvda.speak(f"{label} {param} slider {int(val) if param == 'LIMIT' else val}")
+                        self.nvda.speak(f"{label} gain slider {val}")
-                case [
+                case [["STRIP", index], ["SLIDER", "GAIN"], ["FOCUS", "OUT"]]:
-                    ["STRIP", index],
-                    [
-                        "SLIDER",
-                        "GAIN" | "COMP" | "GATE" | "DENOISER" | "AUDIBILITY" | "LIMIT" | "BASS" | "MID" | "TREBLE",
-                    ],
-                    ["FOCUS", "OUT"],
-                ]:
                     self.vm.event.pdirty = True
-                case [
+                case [["STRIP", index], ["SLIDER", "GAIN"], ["KEY", "LEFT" | "RIGHT" | "UP" | "DOWN" as direction]]:
-                    ["STRIP", index],
+                    val = self.vm.strip[int(index)].gain
-                    [
-                        "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 = util.check_bounds(val, (-60, 12))
-                    match param:
+                    self[f"STRIP {index}||SLIDER GAIN"].update(value=val)
-                        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],
                 ]:
-                    match param:
+                    val = self.vm.strip[int(index)].gain
-                        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 += 3
-                                val += 1
-                            else:
-                                val += 3
                         case "LEFT" | "DOWN":
-                            if param in ("COMP", "GATE", "DENOISER", "AUDIBILITY", "BASS", "MID", "TREBLE"):
+                            val -= 3
-                                val -= 1
+                    self.vm.strip[int(index)].gain = util.check_bounds(val, (-60, 12))
-                            else:
+                    self[f"STRIP {index}||SLIDER GAIN"].update(value=val)
-                                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],
                 ]:
-                    match param:
+                    val = self.vm.strip[int(index)].gain
-                        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 += 0.1
-                                val += 1
-                            else:
-                                val += 0.1
                         case "LEFT" | "DOWN":
-                            if param == "LIMIT":
+                            val -= 0.1
-                                val -= 1
+                    self.vm.strip[int(index)].gain = util.check_bounds(val, (-60, 12))
-                            else:
+                    self[f"STRIP {index}||SLIDER GAIN"].update(value=val)
-                                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]]: