onyx_online/nvda-voicemeeter
1
0
Fork 0
mirror of https://github.com/onyx-and-iris/nvda-voicemeeter.git synced 2024-11-23 10:20:50 +00:00
Code Issues Packages Projects Releases Wiki Activity
ed5f9ae45b
nvda-voicemeeter/src/nvda_voicemeeter/window.py
onyx-and-iris ed5f9ae45b fixes hardware out A2 for basic kind. 
patch bump
2023-09-06 16:20:04 +01:00

629 lines
30 KiB
Python
Raw Blame History

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