onyx_online/nvda-voicemeeter
1
0
Fork 0
mirror of https://github.com/onyx-and-iris/nvda-voicemeeter.git synced 2025-02-22 04:45:08 +00:00
Code Issues Packages Projects Releases Wiki Activity

re-run files through ruff formatter

Browse Source
This commit is contained in:
Onyx and Iris 2025-01-20 16:29:47 +00:00
parent b5ea41c604
commit fbd4962fb2
9 changed files with 1202 additions and 1202 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

196
src/nvda_voicemeeter/builder.py
View File

@ -16,7 +16,7 @@ class Builder:
menu = [[self.make_menu()]] menu = [[self.make_menu()]]
layout0 = [] layout0 = []
if self.kind.name == "basic": if self.kind.name == 'basic':
steps = ( steps = (
self.make_tab0_row0, self.make_tab0_row0,
self.make_tab0_row1, self.make_tab0_row1,
@ -62,65 +62,65 @@ class Builder:
def _make_inner_tabgroup(layouts, identifier) -> psg.TabGroup: def _make_inner_tabgroup(layouts, identifier) -> psg.TabGroup:
inner_layout = [] inner_layout = []
for i, tabname in enumerate(("buttons", "sliders")): for i, tabname in enumerate(('buttons', 'sliders')):
inner_layout.append([psg.Tab(tabname.capitalize(), layouts[i], key=f"tab||{identifier}||{tabname}")]) inner_layout.append([psg.Tab(tabname.capitalize(), layouts[i], key=f'tab||{identifier}||{tabname}')])
return psg.TabGroup( return psg.TabGroup(
inner_layout, inner_layout,
change_submits=True, change_submits=True,
enable_events=True, enable_events=True,
key=f"tabgroup||{identifier}", key=f'tabgroup||{identifier}',
) )
def _make_tabs(identifier) -> psg.Tab: def _make_tabs(identifier) -> psg.Tab:
match identifier: match identifier:
case "Settings": case 'Settings':
return psg.Tab("Settings", layout0, key="tab||Settings") return psg.Tab('Settings', layout0, key='tab||Settings')
case "Physical Strip": case 'Physical Strip':
tabgroup = _make_inner_tabgroup((layout1_1, layout1_2), identifier) tabgroup = _make_inner_tabgroup((layout1_1, layout1_2), identifier)
case "Virtual Strip": case 'Virtual Strip':
tabgroup = _make_inner_tabgroup((layout2_1, layout2_2), identifier) tabgroup = _make_inner_tabgroup((layout2_1, layout2_2), identifier)
case "Buses": case 'Buses':
tabgroup = _make_inner_tabgroup((layout3_1, layout3_2), identifier) tabgroup = _make_inner_tabgroup((layout3_1, layout3_2), identifier)
return psg.Tab(identifier, [[tabgroup]], key=f"tab||{identifier}") return psg.Tab(identifier, [[tabgroup]], key=f'tab||{identifier}')
tabs = [] tabs = []
for tab in util.get_tabs_labels(): for tab in util.get_tabs_labels():
tabs.append(_make_tabs(tab)) tabs.append(_make_tabs(tab))
tab_group = psg.TabGroup([tabs], change_submits=True, enable_events=True, key="tabgroup") tab_group = psg.TabGroup([tabs], change_submits=True, enable_events=True, key='tabgroup')
return [[menu], [tab_group]] return [[menu], [tab_group]]
def make_menu(self) -> psg.Menu: def make_menu(self) -> psg.Menu:
themes = [f"{theme}::MENU THEME" for theme in util.get_themes_list()] themes = [f'{theme}::MENU THEME' for theme in util.get_themes_list()]
themes.append("Default::MENU THEME") themes.append('Default::MENU THEME')
menu_def = [ menu_def = [
[ [
"&Voicemeeter", '&Voicemeeter',
[ [
"Restart Audio Engine::MENU", 'Restart Audio Engine::MENU',
"Save Settings::MENU", 'Save Settings::MENU',
"Load Settings::MENU", 'Load Settings::MENU',
"Load Settings on Startup ::MENU", 'Load Settings on Startup ::MENU',
], ],
], ],
["&Theme", themes], ['&Theme', themes],
] ]
return psg.Menu(menu_def, key="menus") return psg.Menu(menu_def, key='menus')
def make_tab0_row0(self) -> psg.Frame: def make_tab0_row0(self) -> psg.Frame:
"""tab0 row0 represents hardware ins""" """tab0 row0 represents hardware ins"""
def add_physical_device_opts(layout): def add_physical_device_opts(layout):
devices = util.get_input_device_list(self.vm) devices = util.get_input_device_list(self.vm)
devices.append("- remove device selection -") devices.append('- remove device selection -')
layout.append( layout.append(
[ [
psg.ButtonMenu( psg.ButtonMenu(
f"IN {i + 1}", f'IN {i + 1}',
size=(6, 3), size=(6, 3),
menu_def=["", devices], menu_def=['', devices],
key=f"HARDWARE IN||{i + 1}", key=f'HARDWARE IN||{i + 1}',
) )
for i in range(self.kind.phys_in) for i in range(self.kind.phys_in)
] ]
@ -128,23 +128,23 @@ class Builder:
hardware_in = [] hardware_in = []
[step(hardware_in) for step in (add_physical_device_opts,)] [step(hardware_in) for step in (add_physical_device_opts,)]
return psg.Frame("Hardware In", hardware_in) return psg.Frame('Hardware In', hardware_in)
def make_tab0_row1(self) -> psg.Frame: def make_tab0_row1(self) -> psg.Frame:
"""tab0 row1 represents hardware outs""" """tab0 row1 represents hardware outs"""
def add_physical_device_opts(layout): def add_physical_device_opts(layout):
if self.kind.name == "basic": if self.kind.name == 'basic':
num_outs = self.kind.phys_out + self.kind.virt_out num_outs = self.kind.phys_out + self.kind.virt_out
else: else:
num_outs = self.kind.phys_out num_outs = self.kind.phys_out
layout.append( layout.append(
[ [
psg.ButtonMenu( psg.ButtonMenu(
f"A{i + 1}", f'A{i + 1}',
size=(6, 3), size=(6, 3),
menu_def=["", util.get_output_device_list(i, self.vm)], menu_def=['', util.get_output_device_list(i, self.vm)],
key=f"HARDWARE OUT||A{i + 1}", key=f'HARDWARE OUT||A{i + 1}',
) )
for i in range(num_outs) for i in range(num_outs)
] ]
@ -152,7 +152,7 @@ class Builder:
hardware_out = [] hardware_out = []
[step(hardware_out) for step in (add_physical_device_opts,)] [step(hardware_out) for step in (add_physical_device_opts,)]
return psg.Frame("Hardware Out", hardware_out) return psg.Frame('Hardware Out', hardware_out)
def make_tab0_row3(self) -> psg.Frame: def make_tab0_row3(self) -> psg.Frame:
"""tab0 row3 represents patch composite""" """tab0 row3 represents patch composite"""
@ -162,10 +162,10 @@ class Builder:
layout.append( layout.append(
[ [
psg.ButtonMenu( psg.ButtonMenu(
f"PC{i + 1}", f'PC{i + 1}',
size=(5, 2), size=(5, 2),
menu_def=["", outputs], menu_def=['', outputs],
key=f"PATCH COMPOSITE||PC{i + 1}", key=f'PATCH COMPOSITE||PC{i + 1}',
) )
for i in range(self.kind.composite) for i in range(self.kind.composite)
] ]
@ -173,7 +173,7 @@ class Builder:
hardware_out = [] hardware_out = []
[step(hardware_out) for step in (add_physical_device_opts,)] [step(hardware_out) for step in (add_physical_device_opts,)]
return psg.Frame("PATCH COMPOSITE", hardware_out) return psg.Frame('PATCH COMPOSITE', hardware_out)
def make_tab0_row4(self) -> psg.Frame: def make_tab0_row4(self) -> psg.Frame:
"""tab0 row4 represents patch insert""" """tab0 row4 represents patch insert"""
@ -185,28 +185,28 @@ class Builder:
[ [
psg.Checkbox( psg.Checkbox(
text=channel, text=channel,
default=self.window.cache["insert"][ default=self.window.cache['insert'][
f"INSERT CHECKBOX||{util.get_insert_checkbox_index(self.kind, j, i)}" f'INSERT CHECKBOX||{util.get_insert_checkbox_index(self.kind, j, i)}'
], ],
enable_events=True, enable_events=True,
key=f"INSERT CHECKBOX||IN{i} {j}", key=f'INSERT CHECKBOX||IN{i} {j}',
) )
], ],
) )
for j, channel in enumerate(("LEFT", "RIGHT")) for j, channel in enumerate(('LEFT', 'RIGHT'))
] ]
else: else:
layout.append( layout.append(
[ [
psg.Checkbox( psg.Checkbox(
text=channel, text=channel,
default=self.window.cache["insert"][ default=self.window.cache['insert'][
f"INSERT CHECKBOX||{util.get_insert_checkbox_index(self.kind, j, i)}" f'INSERT CHECKBOX||{util.get_insert_checkbox_index(self.kind, j, i)}'
], ],
enable_events=True, enable_events=True,
key=f"INSERT CHECKBOX||IN{i} {j}", key=f'INSERT CHECKBOX||IN{i} {j}',
) )
for j, channel in enumerate(("LEFT", "RIGHT", "C", "LFE", "SL", "SR", "BL", "BR")) for j, channel in enumerate(('LEFT', 'RIGHT', 'C', 'LFE', 'SL', 'SR', 'BL', 'BR'))
], ],
) )
@ -216,29 +216,29 @@ class Builder:
for i, checkbox_list in enumerate(checkbox_lists): for i, checkbox_list in enumerate(checkbox_lists):
if i < self.kind.phys_in: if i < self.kind.phys_in:
[step(checkbox_list, i + 1) for step in (add_insert_checkboxes,)] [step(checkbox_list, i + 1) for step in (add_insert_checkboxes,)]
inner.append(psg.Frame(f"In#{i + 1}", checkbox_list)) inner.append(psg.Frame(f'In#{i + 1}', checkbox_list))
else: else:
[step(checkbox_list, i + 1) for step in (add_insert_checkboxes,)] [step(checkbox_list, i + 1) for step in (add_insert_checkboxes,)]
asio_checkboxes.append([psg.Frame(f"In#{i + 1}", checkbox_list)]) asio_checkboxes.append([psg.Frame(f'In#{i + 1}', checkbox_list)])
asio_checkboxes.insert(0, inner) asio_checkboxes.insert(0, inner)
return psg.Frame("PATCH INSERT", asio_checkboxes) return psg.Frame('PATCH INSERT', asio_checkboxes)
def make_tab0_row5(self) -> psg.Frame: def make_tab0_row5(self) -> psg.Frame:
"""tab0 row5 represents advanced settings""" """tab0 row5 represents advanced settings"""
return psg.Frame( return psg.Frame(
"ADVANCED SETTINGS", 'ADVANCED SETTINGS',
[ [
[ [
psg.Button( psg.Button(
"ADVANCED SETTINGS", 'ADVANCED SETTINGS',
size=(20, 2), size=(20, 2),
key="ADVANCED SETTINGS", key='ADVANCED SETTINGS',
) )
], ],
], ],
key="ADVANCED SETTINGS FRAME", key='ADVANCED SETTINGS FRAME',
) )
def make_tab1_button_row(self, i) -> psg.Frame: def make_tab1_button_row(self, i) -> psg.Frame:
@ -248,26 +248,26 @@ class Builder:
layout.append( layout.append(
[ [
psg.Button( psg.Button(
f"A{j + 1}" if j < self.kind.phys_out else f"B{j - self.kind.phys_out + 1}", f'A{j + 1}' if j < self.kind.phys_out else f'B{j - self.kind.phys_out + 1}',
size=(4, 2), size=(4, 2),
key=f"STRIP {i}||A{j + 1}" key=f'STRIP {i}||A{j + 1}'
if j < self.kind.phys_out if j < self.kind.phys_out
else f"STRIP {i}||B{j - self.kind.phys_out + 1}", else f'STRIP {i}||B{j - self.kind.phys_out + 1}',
) )
for j in range(self.kind.phys_out + self.kind.virt_out) for j in range(self.kind.phys_out + self.kind.virt_out)
], ],
) )
layout.append( layout.append(
[ [
psg.Button("Mono", size=(6, 2), key=f"STRIP {i}||MONO"), psg.Button('Mono', size=(6, 2), key=f'STRIP {i}||MONO'),
psg.Button("Solo", size=(6, 2), key=f"STRIP {i}||SOLO"), psg.Button('Solo', size=(6, 2), key=f'STRIP {i}||SOLO'),
psg.Button("Mute", size=(6, 2), key=f"STRIP {i}||MUTE"), psg.Button('Mute', size=(6, 2), key=f'STRIP {i}||MUTE'),
], ],
) )
outputs = [] outputs = []
[step(outputs) for step in (add_strip_outputs,)] [step(outputs) for step in (add_strip_outputs,)]
return psg.Frame(self.window.cache["labels"][f"STRIP {i}||LABEL"], outputs, key=f"STRIP {i}||LABEL") return psg.Frame(self.window.cache['labels'][f'STRIP {i}||LABEL'], outputs, key=f'STRIP {i}||LABEL')
def make_tab1_button_rows(self) -> psg.Frame: def make_tab1_button_rows(self) -> psg.Frame:
layout = [[self.make_tab1_button_row(i)] for i in range(self.kind.phys_in)] layout = [[self.make_tab1_button_row(i)] for i in range(self.kind.phys_in)]
@ -277,7 +277,7 @@ class Builder:
def add_gain_slider(layout): def add_gain_slider(layout):
layout.append( layout.append(
[ [
psg.Text("Gain"), psg.Text('Gain'),
psg.Slider( psg.Slider(
range=(-60, 12), range=(-60, 12),
default_value=self.vm.strip[i].gain, default_value=self.vm.strip[i].gain,
@ -286,8 +286,8 @@ class Builder:
expand_x=True, expand_x=True,
enable_events=True, enable_events=True,
disabled=True, disabled=True,
orientation="horizontal", orientation='horizontal',
key=f"STRIP {i}||SLIDER GAIN", key=f'STRIP {i}||SLIDER GAIN',
), ),
] ]
) )
@ -298,7 +298,7 @@ class Builder:
def add_limit_slider(layout): def add_limit_slider(layout):
layout.append( layout.append(
[ [
psg.Text("Limit"), psg.Text('Limit'),
psg.Slider( psg.Slider(
range=(-40, 12), range=(-40, 12),
default_value=self.vm.strip[i].limit, default_value=self.vm.strip[i].limit,
@ -306,18 +306,18 @@ class Builder:
disable_number_display=True, disable_number_display=True,
expand_x=True, expand_x=True,
enable_events=True, enable_events=True,
orientation="horizontal", orientation='horizontal',
key=f"STRIP {i}||SLIDER LIMIT", key=f'STRIP {i}||SLIDER LIMIT',
), ),
] ]
) )
layout = [] layout = []
steps = (add_gain_slider, add_param_sliders) steps = (add_gain_slider, add_param_sliders)
if self.kind.name in ("banana", "potato"): if self.kind.name in ('banana', 'potato'):
steps += (add_limit_slider,) steps += (add_limit_slider,)
[step(layout) for step in steps] [step(layout) for step in steps]
return psg.Frame(self.window.cache["labels"][f"STRIP {i}||LABEL"], layout, key=f"STRIP {i}||LABEL||SLIDER") 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: def make_tab1_slider_rows(self) -> psg.Frame:
layout = [[self.make_tab1_slider_row(i)] for i in range(self.kind.phys_in)] layout = [[self.make_tab1_slider_row(i)] for i in range(self.kind.phys_in)]
@ -330,11 +330,11 @@ class Builder:
layout.append( layout.append(
[ [
psg.Button( psg.Button(
f"A{j + 1}" if j < self.kind.phys_out else f"B{j - self.kind.phys_out + 1}", f'A{j + 1}' if j < self.kind.phys_out else f'B{j - self.kind.phys_out + 1}',
size=(4, 2), size=(4, 2),
key=f"STRIP {i}||A{j + 1}" key=f'STRIP {i}||A{j + 1}'
if j < self.kind.phys_out if j < self.kind.phys_out
else f"STRIP {i}||B{j - self.kind.phys_out + 1}", else f'STRIP {i}||B{j - self.kind.phys_out + 1}',
) )
for j in range(self.kind.phys_out + self.kind.virt_out) for j in range(self.kind.phys_out + self.kind.virt_out)
] ]
@ -342,26 +342,26 @@ class Builder:
if i == self.kind.phys_in + 1: if i == self.kind.phys_in + 1:
layout.append( layout.append(
[ [
psg.Button("K", size=(6, 2), key=f"STRIP {i}||KARAOKE"), psg.Button('K', size=(6, 2), key=f'STRIP {i}||KARAOKE'),
psg.Button("Solo", size=(6, 2), key=f"STRIP {i}||SOLO"), psg.Button('Solo', size=(6, 2), key=f'STRIP {i}||SOLO'),
psg.Button("Mute", size=(6, 2), key=f"STRIP {i}||MUTE"), psg.Button('Mute', size=(6, 2), key=f'STRIP {i}||MUTE'),
], ],
) )
else: else:
layout.append( layout.append(
[ [
psg.Button("MC", size=(6, 2), key=f"STRIP {i}||MC"), psg.Button('MC', size=(6, 2), key=f'STRIP {i}||MC'),
psg.Button("Solo", size=(6, 2), key=f"STRIP {i}||SOLO"), psg.Button('Solo', size=(6, 2), key=f'STRIP {i}||SOLO'),
psg.Button("Mute", size=(6, 2), key=f"STRIP {i}||MUTE"), psg.Button('Mute', size=(6, 2), key=f'STRIP {i}||MUTE'),
], ],
) )
outputs = [] outputs = []
[step(outputs) for step in (add_strip_outputs,)] [step(outputs) for step in (add_strip_outputs,)]
return psg.Frame( return psg.Frame(
self.window.cache["labels"][f"STRIP {i}||LABEL"], self.window.cache['labels'][f'STRIP {i}||LABEL'],
outputs, outputs,
key=f"STRIP {i}||LABEL", key=f'STRIP {i}||LABEL',
) )
def make_tab2_button_rows(self) -> psg.Frame: def make_tab2_button_rows(self) -> psg.Frame:
@ -374,7 +374,7 @@ class Builder:
def add_gain_slider(layout): def add_gain_slider(layout):
layout.append( layout.append(
[ [
psg.Text("Gain"), psg.Text('Gain'),
psg.Slider( psg.Slider(
range=(-60, 12), range=(-60, 12),
default_value=self.vm.strip[i].gain, default_value=self.vm.strip[i].gain,
@ -383,14 +383,14 @@ class Builder:
expand_x=True, expand_x=True,
enable_events=True, enable_events=True,
disabled=True, disabled=True,
orientation="horizontal", orientation='horizontal',
key=f"STRIP {i}||SLIDER GAIN", key=f'STRIP {i}||SLIDER GAIN',
), ),
] ]
) )
def add_param_sliders(layout): def add_param_sliders(layout):
if self.kind.name in ("basic", "banana"): if self.kind.name in ('basic', 'banana'):
for param in util.get_slider_params(i, self.kind): for param in util.get_slider_params(i, self.kind):
layout.append([LabelSlider(self.window, i, param, range_=(-12, 12))]) layout.append([LabelSlider(self.window, i, param, range_=(-12, 12))])
else: else:
@ -404,7 +404,7 @@ class Builder:
def add_limit_slider(layout): def add_limit_slider(layout):
layout.append( layout.append(
[ [
psg.Text("Limit"), psg.Text('Limit'),
psg.Slider( psg.Slider(
range=(-40, 12), range=(-40, 12),
default_value=self.vm.strip[i].limit, default_value=self.vm.strip[i].limit,
@ -412,21 +412,21 @@ class Builder:
disable_number_display=True, disable_number_display=True,
expand_x=True, expand_x=True,
enable_events=True, enable_events=True,
orientation="horizontal", orientation='horizontal',
key=f"STRIP {i}||SLIDER LIMIT", key=f'STRIP {i}||SLIDER LIMIT',
), ),
] ]
) )
layout = [] layout = []
steps = (add_gain_slider, add_param_sliders) steps = (add_gain_slider, add_param_sliders)
if self.kind.name in ("banana", "potato"): if self.kind.name in ('banana', 'potato'):
steps += (add_limit_slider,) steps += (add_limit_slider,)
[step(layout) for step in steps] [step(layout) for step in steps]
return psg.Frame( return psg.Frame(
self.window.cache["labels"][f"STRIP {i}||LABEL"], self.window.cache['labels'][f'STRIP {i}||LABEL'],
layout, layout,
key=f"STRIP {i}||LABEL||SLIDER", key=f'STRIP {i}||LABEL||SLIDER',
) )
def make_tab2_slider_rows(self) -> psg.Frame: def make_tab2_slider_rows(self) -> psg.Frame:
@ -439,9 +439,9 @@ class Builder:
"""tab3 row represents bus composite toggle""" """tab3 row represents bus composite toggle"""
def add_strip_outputs(layout): def add_strip_outputs(layout):
params = ["MONO", "EQ", "MUTE"] params = ['MONO', 'EQ', 'MUTE']
if self.kind.name == "basic": if self.kind.name == 'basic':
params.remove("EQ") params.remove('EQ')
busmodes = [util._bus_mode_map[mode] for mode in util.get_bus_modes(self.vm)] busmodes = [util._bus_mode_map[mode] for mode in util.get_bus_modes(self.vm)]
layout.append( layout.append(
[ [
@ -449,15 +449,15 @@ class Builder:
psg.Button( psg.Button(
param.capitalize(), param.capitalize(),
size=(6, 2), size=(6, 2),
key=f"BUS {i}||{param}", key=f'BUS {i}||{param}',
) )
for param in params for param in params
], ],
psg.ButtonMenu( psg.ButtonMenu(
"BUSMODE", 'BUSMODE',
size=(12, 2), size=(12, 2),
menu_def=["", busmodes], menu_def=['', busmodes],
key=f"BUS {i}||MODE", key=f'BUS {i}||MODE',
), ),
] ]
) )
@ -465,9 +465,9 @@ class Builder:
outputs = [] outputs = []
[step(outputs) for step in (add_strip_outputs,)] [step(outputs) for step in (add_strip_outputs,)]
return psg.Frame( return psg.Frame(
self.window.cache["labels"][f"BUS {i}||LABEL"], self.window.cache['labels'][f'BUS {i}||LABEL'],
outputs, outputs,
key=f"BUS {i}||LABEL", key=f'BUS {i}||LABEL',
) )
def make_tab3_button_rows(self) -> psg.Frame: def make_tab3_button_rows(self) -> psg.Frame:
@ -478,7 +478,7 @@ class Builder:
def add_gain_slider(layout): def add_gain_slider(layout):
layout.append( layout.append(
[ [
psg.Text("Gain"), psg.Text('Gain'),
psg.Slider( psg.Slider(
range=(-60, 12), range=(-60, 12),
default_value=self.vm.bus[i].gain, default_value=self.vm.bus[i].gain,
@ -487,15 +487,15 @@ class Builder:
expand_x=True, expand_x=True,
enable_events=True, enable_events=True,
disabled=True, disabled=True,
orientation="horizontal", orientation='horizontal',
key=f"BUS {i}||SLIDER GAIN", key=f'BUS {i}||SLIDER GAIN',
), ),
] ]
) )
outputs = [] outputs = []
[step(outputs) for step in (add_gain_slider,)] [step(outputs) for step in (add_gain_slider,)]
return psg.Frame(self.window.cache["labels"][f"BUS {i}||LABEL"], outputs, key=f"BUS {i}||LABEL||SLIDER") return psg.Frame(self.window.cache['labels'][f'BUS {i}||LABEL'], outputs, key=f'BUS {i}||LABEL||SLIDER')
def make_tab3_slider_rows(self) -> psg.Frame: def make_tab3_slider_rows(self) -> psg.Frame:
layout = [[self.make_tab3_slider_row(i)] for i in range(self.kind.num_bus)] layout = [[self.make_tab3_slider_row(i)] for i in range(self.kind.num_bus)]

152
src/nvda_voicemeeter/compound.py
View File

@ -10,10 +10,10 @@ class LabelSlider(psg.Frame):
def __init__(self, parent, i, param, range_=(0, 10), *args, **kwargs): def __init__(self, parent, i, param, range_=(0, 10), *args, **kwargs):
self.parent = parent self.parent = parent
if param in ("AUDIBILITY", "DENOISER"): if param in ('AUDIBILITY', 'DENOISER'):
size = 7 size = 7
else: else:
if psg.theme() == "HighContrast": if psg.theme() == 'HighContrast':
size = 5 size = 5
else: else:
size = 4 size = 4
@ -28,8 +28,8 @@ class LabelSlider(psg.Frame):
size=(12, 16), size=(12, 16),
expand_x=True, expand_x=True,
enable_events=True, enable_events=True,
orientation="horizontal", orientation='horizontal',
key=f"STRIP {i}||SLIDER {param}", key=f'STRIP {i}||SLIDER {param}',
), ),
] ]
] ]
@ -37,7 +37,7 @@ class LabelSlider(psg.Frame):
def default_value(self, i, param): def default_value(self, i, param):
target = getattr(self.parent.vm.strip[i], param.lower()) target = getattr(self.parent.vm.strip[i], param.lower())
if param in ("COMP", "GATE", "DENOISER"): if param in ('COMP', 'GATE', 'DENOISER'):
return target.knob return target.knob
return target return target
@ -52,70 +52,70 @@ class CompSlider(psg.Slider):
disable_number_display=True, disable_number_display=True,
expand_x=True, expand_x=True,
enable_events=True, enable_events=True,
orientation="horizontal", orientation='horizontal',
key=f"COMPRESSOR||SLIDER {param}", key=f'COMPRESSOR||SLIDER {param}',
**self.default_params(param), **self.default_params(param),
) )
def default_params(self, param): def default_params(self, param):
match param: match param:
case "INPUT GAIN": case 'INPUT GAIN':
return { return {
"range": (-24, 24), 'range': (-24, 24),
"default_value": self.vm.strip[self.index].comp.gainin, 'default_value': self.vm.strip[self.index].comp.gainin,
"resolution": 0.1, 'resolution': 0.1,
"disabled": True, 'disabled': True,
} }
case "RATIO": case 'RATIO':
return { return {
"range": (1, 8), 'range': (1, 8),
"default_value": self.vm.strip[self.index].comp.ratio, 'default_value': self.vm.strip[self.index].comp.ratio,
"resolution": 0.1, 'resolution': 0.1,
} }
case "THRESHOLD": case 'THRESHOLD':
return { return {
"range": (-40, -3), 'range': (-40, -3),
"default_value": self.vm.strip[self.index].comp.threshold, 'default_value': self.vm.strip[self.index].comp.threshold,
"resolution": 0.1, 'resolution': 0.1,
} }
case "ATTACK": case 'ATTACK':
return { return {
"range": (0, 200), 'range': (0, 200),
"default_value": self.vm.strip[self.index].comp.attack, 'default_value': self.vm.strip[self.index].comp.attack,
"resolution": 0.1, 'resolution': 0.1,
} }
case "RELEASE": case 'RELEASE':
return { return {
"range": (0, 5000), 'range': (0, 5000),
"default_value": self.vm.strip[self.index].comp.release, 'default_value': self.vm.strip[self.index].comp.release,
"resolution": 0.1, 'resolution': 0.1,
} }
case "KNEE": case 'KNEE':
return { return {
"range": (0, 1), 'range': (0, 1),
"default_value": self.vm.strip[self.index].comp.knee, 'default_value': self.vm.strip[self.index].comp.knee,
"resolution": 0.01, 'resolution': 0.01,
} }
case "OUTPUT GAIN": case 'OUTPUT GAIN':
return { return {
"range": (-24, 24), 'range': (-24, 24),
"default_value": self.vm.strip[self.index].comp.gainout, 'default_value': self.vm.strip[self.index].comp.gainout,
"resolution": 0.1, 'resolution': 0.1,
"disabled": True, 'disabled': True,
} }
@staticmethod @staticmethod
def check_bounds(param, val): def check_bounds(param, val):
match param: match param:
case "RATIO": case 'RATIO':
val = util.check_bounds(val, (1, 8)) val = util.check_bounds(val, (1, 8))
case "THRESHOLD": case 'THRESHOLD':
val = util.check_bounds(val, (-40, -3)) val = util.check_bounds(val, (-40, -3))
case "ATTACK": case 'ATTACK':
val = util.check_bounds(val, (0, 200)) val = util.check_bounds(val, (0, 200))
case "RELEASE": case 'RELEASE':
val = util.check_bounds(val, (0, 5000)) val = util.check_bounds(val, (0, 5000))
case "KNEE": case 'KNEE':
val = util.check_bounds(val, (0, 1)) val = util.check_bounds(val, (0, 1))
return val return val
@ -128,64 +128,64 @@ class GateSlider(psg.Slider):
disable_number_display=True, disable_number_display=True,
expand_x=True, expand_x=True,
enable_events=True, enable_events=True,
orientation="horizontal", orientation='horizontal',
key=f"GATE||SLIDER {param}", key=f'GATE||SLIDER {param}',
**self.default_params(param), **self.default_params(param),
) )
def default_params(self, param): def default_params(self, param):
match param: match param:
case "THRESHOLD": case 'THRESHOLD':
return { return {
"range": (-60, -10), 'range': (-60, -10),
"default_value": self.vm.strip[self.index].gate.threshold, 'default_value': self.vm.strip[self.index].gate.threshold,
"resolution": 0.1, 'resolution': 0.1,
} }
case "DAMPING": case 'DAMPING':
return { return {
"range": (-60, -10), 'range': (-60, -10),
"default_value": self.vm.strip[self.index].gate.damping, 'default_value': self.vm.strip[self.index].gate.damping,
"resolution": 0.1, 'resolution': 0.1,
} }
case "BPSIDECHAIN": case 'BPSIDECHAIN':
return { return {
"range": (100, 4000), 'range': (100, 4000),
"default_value": self.vm.strip[self.index].gate.bpsidechain, 'default_value': self.vm.strip[self.index].gate.bpsidechain,
"resolution": 1, 'resolution': 1,
} }
case "ATTACK": case 'ATTACK':
return { return {
"range": (0, 1000), 'range': (0, 1000),
"default_value": self.vm.strip[self.index].gate.attack, 'default_value': self.vm.strip[self.index].gate.attack,
"resolution": 0.1, 'resolution': 0.1,
} }
case "HOLD": case 'HOLD':
return { return {
"range": (0, 5000), 'range': (0, 5000),
"default_value": self.vm.strip[self.index].gate.hold, 'default_value': self.vm.strip[self.index].gate.hold,
"resolution": 0.1, 'resolution': 0.1,
} }
case "RELEASE": case 'RELEASE':
return { return {
"range": (0, 5000), 'range': (0, 5000),
"default_value": self.vm.strip[self.index].gate.release, 'default_value': self.vm.strip[self.index].gate.release,
"resolution": 0.1, 'resolution': 0.1,
} }
@staticmethod @staticmethod
def check_bounds(param, val): def check_bounds(param, val):
match param: match param:
case "THRESHOLD": case 'THRESHOLD':
val = util.check_bounds(val, (-60, -10)) val = util.check_bounds(val, (-60, -10))
case "DAMPING MAX": case 'DAMPING MAX':
val = util.check_bounds(val, (-60, -10)) val = util.check_bounds(val, (-60, -10))
case "BPSIDECHAIN": case 'BPSIDECHAIN':
val = util.check_bounds(val, (100, 4000)) val = util.check_bounds(val, (100, 4000))
case "ATTACK": case 'ATTACK':
val = util.check_bounds(val, (0, 1000)) val = util.check_bounds(val, (0, 1000))
case "HOLD": case 'HOLD':
val = util.check_bounds(val, (0, 5000)) val = util.check_bounds(val, (0, 5000))
case "RELEASE": case 'RELEASE':
val = util.check_bounds(val, (0, 5000)) val = util.check_bounds(val, (0, 5000))
return val return val
@ -195,8 +195,8 @@ class LabelSliderAdvanced(psg.Frame):
def __init__(self, parent, index, param, slider_cls: Union[CompSlider, GateSlider], *args, **kwargs): def __init__(self, parent, index, param, slider_cls: Union[CompSlider, GateSlider], *args, **kwargs):
label_map = { label_map = {
"DAMPING": "Damping Max", 'DAMPING': 'Damping Max',
"BPSIDECHAIN": "BP Sidechain", 'BPSIDECHAIN': 'BP Sidechain',
} }
layout = [ layout = [

8
src/nvda_voicemeeter/configuration.py
View File

@ -1,14 +1,14 @@
import json import json
from pathlib import Path from pathlib import Path
SETTINGS = Path.cwd() / "settings.json" SETTINGS = Path.cwd() / 'settings.json'
def config_from_json(): def config_from_json():
data = {} data = {}
if not SETTINGS.exists(): if not SETTINGS.exists():
return data return data
with open(SETTINGS, "r") as f: with open(SETTINGS, 'r') as f:
data = json.load(f) data = json.load(f)
return data return data
@ -24,11 +24,11 @@ def get(key, default=None):
def set(key, value): def set(key, value):
config[key] = value config[key] = value
with open(SETTINGS, "w") as f: with open(SETTINGS, 'w') as f:
json.dump(config, f) json.dump(config, f)
def delete(key): def delete(key):
del config[key] del config[key]
with open(SETTINGS, "w") as f: with open(SETTINGS, 'w') as f:
json.dump(config, f) json.dump(config, f)

2
src/nvda_voicemeeter/errors.py
View File

@ -8,4 +8,4 @@ class NVDAVMCAPIError(NVDAVMError):
def __init__(self, fn_name, code): def __init__(self, fn_name, code):
self.fn_name = fn_name self.fn_name = fn_name
self.code = code self.code = code
super().__init__(f"{self.fn_name} returned {self.code}") super().__init__(f'{self.fn_name} returned {self.code}')

84
src/nvda_voicemeeter/models.py
View File

@ -1,58 +1,58 @@
def _make_hardware_ins_cache(vm) -> dict: def _make_hardware_ins_cache(vm) -> dict:
return {**{f"HARDWARE IN||{i + 1}": vm.strip[i].device.name for i in range(vm.kind.phys_in)}} return {**{f'HARDWARE IN||{i + 1}': vm.strip[i].device.name for i in range(vm.kind.phys_in)}}
def _make_hardware_outs_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)}} 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": if vm.kind.name == 'basic':
hw_outs |= {"HARDWARE OUT||A2": vm.bus[1].device.name} hw_outs |= {'HARDWARE OUT||A2': vm.bus[1].device.name}
return hw_outs return hw_outs
def _make_param_cache(vm, channel_type) -> dict: def _make_param_cache(vm, channel_type) -> dict:
params = {} params = {}
if channel_type == "strip": if channel_type == 'strip':
match vm.kind.name: match vm.kind.name:
case "basic": case 'basic':
params |= { params |= {
**{f"STRIP {i}||A1": vm.strip[i].A1 for i in range(vm.kind.num_strip)}, **{f'STRIP {i}||A1': vm.strip[i].A1 for i in range(vm.kind.num_strip)},
**{f"STRIP {i}||B1": vm.strip[i].B1 for i in range(vm.kind.num_strip)}, **{f'STRIP {i}||B1': vm.strip[i].B1 for i in range(vm.kind.num_strip)},
} }
case "banana": case 'banana':
params |= { params |= {
**{f"STRIP {i}||A1": vm.strip[i].A1 for i in range(vm.kind.num_strip)}, **{f'STRIP {i}||A1': vm.strip[i].A1 for i in range(vm.kind.num_strip)},
**{f"STRIP {i}||A2": vm.strip[i].A2 for i in range(vm.kind.num_strip)}, **{f'STRIP {i}||A2': vm.strip[i].A2 for i in range(vm.kind.num_strip)},
**{f"STRIP {i}||A3": vm.strip[i].A3 for i in range(vm.kind.num_strip)}, **{f'STRIP {i}||A3': vm.strip[i].A3 for i in range(vm.kind.num_strip)},
**{f"STRIP {i}||B1": vm.strip[i].B1 for i in range(vm.kind.num_strip)}, **{f'STRIP {i}||B1': vm.strip[i].B1 for i in range(vm.kind.num_strip)},
**{f"STRIP {i}||B2": vm.strip[i].B2 for i in range(vm.kind.num_strip)}, **{f'STRIP {i}||B2': vm.strip[i].B2 for i in range(vm.kind.num_strip)},
} }
case "potato": case 'potato':
params |= { params |= {
**{f"STRIP {i}||A1": vm.strip[i].A1 for i in range(vm.kind.num_strip)}, **{f'STRIP {i}||A1': vm.strip[i].A1 for i in range(vm.kind.num_strip)},
**{f"STRIP {i}||A2": vm.strip[i].A2 for i in range(vm.kind.num_strip)}, **{f'STRIP {i}||A2': vm.strip[i].A2 for i in range(vm.kind.num_strip)},
**{f"STRIP {i}||A3": vm.strip[i].A3 for i in range(vm.kind.num_strip)}, **{f'STRIP {i}||A3': vm.strip[i].A3 for i in range(vm.kind.num_strip)},
**{f"STRIP {i}||A4": vm.strip[i].A4 for i in range(vm.kind.num_strip)}, **{f'STRIP {i}||A4': vm.strip[i].A4 for i in range(vm.kind.num_strip)},
**{f"STRIP {i}||A5": vm.strip[i].A5 for i in range(vm.kind.num_strip)}, **{f'STRIP {i}||A5': vm.strip[i].A5 for i in range(vm.kind.num_strip)},
**{f"STRIP {i}||B1": vm.strip[i].B1 for i in range(vm.kind.num_strip)}, **{f'STRIP {i}||B1': vm.strip[i].B1 for i in range(vm.kind.num_strip)},
**{f"STRIP {i}||B2": vm.strip[i].B2 for i in range(vm.kind.num_strip)}, **{f'STRIP {i}||B2': vm.strip[i].B2 for i in range(vm.kind.num_strip)},
**{f"STRIP {i}||B3": vm.strip[i].B3 for i in range(vm.kind.num_strip)}, **{f'STRIP {i}||B3': vm.strip[i].B3 for i in range(vm.kind.num_strip)},
} }
params |= { params |= {
**{f"STRIP {i}||MONO": vm.strip[i].mono for i in range(vm.kind.phys_in)}, **{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}||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)}, **{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): for i in range(vm.kind.phys_in, vm.kind.phys_in + vm.kind.virt_in):
if i == vm.kind.phys_in + 1: if i == vm.kind.phys_in + 1:
params[f"STRIP {i}||KARAOKE"] = vm.strip[i].k params[f'STRIP {i}||KARAOKE'] = vm.strip[i].k
else: else:
params[f"STRIP {i}||MC"] = vm.strip[i].mc params[f'STRIP {i}||MC'] = vm.strip[i].mc
else: else:
params |= { params |= {
**{f"BUS {i}||MONO": vm.bus[i].mono for i in range(vm.kind.num_bus)}, **{f'BUS {i}||MONO': vm.bus[i].mono for i in range(vm.kind.num_bus)},
**{f"BUS {i}||EQ": vm.bus[i].eq.on for i in range(vm.kind.num_bus)}, **{f'BUS {i}||EQ': vm.bus[i].eq.on for i in range(vm.kind.num_bus)},
**{f"BUS {i}||MUTE": vm.bus[i].mute for i in range(vm.kind.num_bus)}, **{f'BUS {i}||MUTE': vm.bus[i].mute for i in range(vm.kind.num_bus)},
**{f"BUS {i}||MODE": vm.bus[i].mode.get() for i in range(vm.kind.num_bus)}, **{f'BUS {i}||MODE': vm.bus[i].mode.get() for i in range(vm.kind.num_bus)},
} }
return params return params
@ -60,19 +60,19 @@ def _make_param_cache(vm, channel_type) -> dict:
def _make_label_cache(vm) -> dict: def _make_label_cache(vm) -> dict:
return { return {
**{ **{
f"STRIP {i}||LABEL": vm.strip[i].label if vm.strip[i].label else f"Hardware Input {i + 1}" f'STRIP {i}||LABEL': vm.strip[i].label if vm.strip[i].label else f'Hardware Input {i + 1}'
for i in range(vm.kind.phys_in) for i in range(vm.kind.phys_in)
}, },
**{ **{
f"STRIP {i}||LABEL": vm.strip[i].label if vm.strip[i].label else f"Virtual Input {i - vm.kind.phys_in + 1}" f'STRIP {i}||LABEL': vm.strip[i].label if vm.strip[i].label else f'Virtual Input {i - vm.kind.phys_in + 1}'
for i in range(vm.kind.phys_in, vm.kind.phys_in + vm.kind.virt_in) for i in range(vm.kind.phys_in, vm.kind.phys_in + vm.kind.virt_in)
}, },
**{ **{
f"BUS {i}||LABEL": vm.bus[i].label if vm.bus[i].label else f"Physical Bus {i + 1}" f'BUS {i}||LABEL': vm.bus[i].label if vm.bus[i].label else f'Physical Bus {i + 1}'
for i in range(vm.kind.phys_out) for i in range(vm.kind.phys_out)
}, },
**{ **{
f"BUS {i}||LABEL": vm.bus[i].label if vm.bus[i].label else f"Virtual Bus {i - vm.kind.phys_out + 1}" f'BUS {i}||LABEL': vm.bus[i].label if vm.bus[i].label else f'Virtual Bus {i - vm.kind.phys_out + 1}'
for i in range(vm.kind.phys_out, vm.kind.phys_out + vm.kind.virt_out) for i in range(vm.kind.phys_out, vm.kind.phys_out + vm.kind.virt_out)
}, },
} }
@ -80,16 +80,16 @@ def _make_label_cache(vm) -> dict:
def _make_patch_asio_cache(vm) -> dict: def _make_patch_asio_cache(vm) -> dict:
params = {} params = {}
if vm.kind.name != "basic": if vm.kind.name != 'basic':
params |= {**{f"ASIO INPUT SPINBOX||{i}": vm.patch.asio[i].get() for i in range(vm.kind.phys_out * 2)}} params |= {**{f'ASIO INPUT SPINBOX||{i}': vm.patch.asio[i].get() for i in range(vm.kind.phys_out * 2)}}
for i in range(vm.kind.phys_out - 1): for i in range(vm.kind.phys_out - 1):
target = getattr(vm.patch, f"A{i + 2}") target = getattr(vm.patch, f'A{i + 2}')
params |= {**{f"ASIO OUTPUT A{i + 2} SPINBOX||{j}": target[j].get() for j in range(vm.kind.num_bus)}} params |= {**{f'ASIO OUTPUT A{i + 2} SPINBOX||{j}': target[j].get() for j in range(vm.kind.num_bus)}}
return params return params
def _make_patch_insert_cache(vm) -> dict: def _make_patch_insert_cache(vm) -> dict:
params = {} params = {}
if vm.kind.name != "basic": if vm.kind.name != 'basic':
params |= {**{f"INSERT CHECKBOX||{i}": vm.patch.insert[i].on for i in range(vm.kind.num_strip_levels)}} params |= {**{f'INSERT CHECKBOX||{i}': vm.patch.insert[i].on for i in range(vm.kind.num_strip_levels)}}
return params return params

4
src/nvda_voicemeeter/parser.py
View File

@ -4,10 +4,10 @@ from pyparsing import Group, OneOrMore, Optional, Suppress, Word, alphanums, res
class Parser: class Parser:
def __init__(self): def __init__(self):
self.widget = Group(OneOrMore(Word(alphanums))) self.widget = Group(OneOrMore(Word(alphanums)))
self.widget_token = Suppress("||") self.widget_token = Suppress('||')
self.identifier = Group(OneOrMore(Word(alphanums))) self.identifier = Group(OneOrMore(Word(alphanums)))
self.event = Group(OneOrMore(Word(alphanums))) self.event = Group(OneOrMore(Word(alphanums)))
self.menu_token = Suppress("::") self.menu_token = Suppress('::')
self.match = ( self.match = (
self.widget + self.widget_token + self.identifier + Optional(self.widget_token) + Optional(self.event) self.widget + self.widget_token + self.identifier + Optional(self.widget_token) + Optional(self.event)
| self.identifier + self.menu_token + self.event | self.identifier + self.menu_token + self.event

648
src/nvda_voicemeeter/popup.py
View File

File diff suppressed because it is too large Load Diff

218
src/nvda_voicemeeter/util.py
View File

@ -18,9 +18,9 @@ def get_insert_checkbox_index(kind, channel, num) -> int:
_rejected_ids = ( _rejected_ids = (
"VBAudio100VMVAIO3", 'VBAudio100VMVAIO3',
"{F5735BD4-6EAF-4758-9710-9886E5AD0FF3}", '{F5735BD4-6EAF-4758-9710-9886E5AD0FF3}',
"{0239BE07-CEEF-4236-A900-AA778D432FD4}", '{0239BE07-CEEF-4236-A900-AA778D432FD4}',
) )
@ -28,8 +28,8 @@ def get_input_device_list(vm) -> list:
devices = [] devices = []
for j in range(vm.device.ins): for j in range(vm.device.ins):
device = vm.device.input(j) device = vm.device.input(j)
if device["id"] not in _rejected_ids: if device['id'] not in _rejected_ids:
devices.append("{type}: {name}".format(**device)) devices.append('{type}: {name}'.format(**device))
return devices return devices
@ -37,37 +37,37 @@ def get_output_device_list(i, vm) -> list:
devices = [] devices = []
for j in range(vm.device.outs): for j in range(vm.device.outs):
device = vm.device.output(j) device = vm.device.output(j)
if device["id"] not in _rejected_ids: if device['id'] not in _rejected_ids:
devices.append("{type}: {name}".format(**device)) devices.append('{type}: {name}'.format(**device))
if i == 0: if i == 0:
return devices return devices
devices.append("- remove device selection -") devices.append('- remove device selection -')
return [device for device in devices if not device.startswith("asio")] return [device for device in devices if not device.startswith('asio')]
def get_patch_composite_list(kind) -> list: def get_patch_composite_list(kind) -> list:
temp = [] temp = []
for i in range(kind.phys_out): for i in range(kind.phys_out):
[temp.append(f"IN#{i + 1} {channel}") for channel in ("Left", "Right")] [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): for i in range(kind.phys_out, kind.phys_out + kind.virt_out):
[ [
temp.append(f"IN#{i + 1} {channel}") temp.append(f'IN#{i + 1} {channel}')
for channel in ("Left", "Right", "Center", "LFE", "SL", "SR", "BL", "BR") for channel in ('Left', 'Right', 'Center', 'LFE', 'SL', 'SR', 'BL', 'BR')
] ]
temp.append("BUS Channel") temp.append('BUS Channel')
return temp return temp
def get_patch_insert_channels() -> list: def get_patch_insert_channels() -> list:
return [ return [
"left", 'left',
"right", 'right',
"center", 'center',
"low frequency effect", 'low frequency effect',
"surround left", 'surround left',
"surround right", 'surround right',
"back left", 'back left',
"back right", 'back right',
] ]
@ -75,8 +75,8 @@ _patch_insert_channels = get_patch_insert_channels()
def get_asio_samples_list(driver) -> list: def get_asio_samples_list(driver) -> list:
if driver == "MME": if driver == 'MME':
samples = ["2048", "1536", "1024", "896", "768", "704", "640", "576", "512", "480", "441"] samples = ['2048', '1536', '1024', '896', '768', '704', '640', '576', '512', '480', '441']
else: else:
# fmt: off # fmt: off
samples = [ samples = [
@ -84,14 +84,14 @@ def get_asio_samples_list(driver) -> list:
"352", "320", "288", "256", "224", "192", "160", "128" "352", "320", "288", "256", "224", "192", "160", "128"
] ]
# fmt: on # fmt: on
if driver == "ASIO": if driver == 'ASIO':
samples = [x for x in samples if x not in ("2048", "1536")] samples = [x for x in samples if x not in ('2048', '1536')]
samples.append("Default") samples.append('Default')
return samples return samples
def get_tabs_labels() -> list: def get_tabs_labels() -> list:
return ["Settings", "Physical Strip", "Virtual Strip", "Buses"] return ['Settings', 'Physical Strip', 'Virtual Strip', 'Buses']
def open_context_menu_for_buttonmenu(window, identifier) -> None: def open_context_menu_for_buttonmenu(window, identifier) -> None:
@ -106,52 +106,52 @@ def get_channel_identifier_list(vm) -> list:
identifiers = [] identifiers = []
for i in range(vm.kind.phys_in): for i in range(vm.kind.phys_in):
for j in range(2): for j in range(2):
identifiers.append(f"IN{i + 1} {j}") identifiers.append(f'IN{i + 1} {j}')
for i in range(vm.kind.phys_in, vm.kind.phys_in + vm.kind.virt_in): for i in range(vm.kind.phys_in, vm.kind.phys_in + vm.kind.virt_in):
for j in range(8): for j in range(8):
identifiers.append(f"IN{i + 1} {j}") identifiers.append(f'IN{i + 1} {j}')
return identifiers return identifiers
_bus_mode_map = { _bus_mode_map = {
"normal": "Normal", 'normal': 'Normal',
"amix": "Mix Down A", 'amix': 'Mix Down A',
"bmix": "Mix Down B", 'bmix': 'Mix Down B',
"repeat": "Stereo Repeat", 'repeat': 'Stereo Repeat',
"composite": "Composite", 'composite': 'Composite',
"tvmix": "Up Mix TV", 'tvmix': 'Up Mix TV',
"upmix21": "Up Mix 2.1", 'upmix21': 'Up Mix 2.1',
"upmix41": "Up Mix 4.1", 'upmix41': 'Up Mix 4.1',
"upmix61": "Up Mix 6.1", 'upmix61': 'Up Mix 6.1',
"centeronly": "Center Only", 'centeronly': 'Center Only',
"lfeonly": "Low Frequency Effect Only", 'lfeonly': 'Low Frequency Effect Only',
"rearonly": "Rear Only", 'rearonly': 'Rear Only',
} }
_bus_mode_map_reversed = dict((reversed(item) for item in _bus_mode_map.items())) _bus_mode_map_reversed = dict((reversed(item) for item in _bus_mode_map.items()))
def get_bus_modes(vm) -> list: def get_bus_modes(vm) -> list:
if vm.kind.name == "basic": if vm.kind.name == 'basic':
return [ return [
"normal", 'normal',
"amix", 'amix',
"repeat", 'repeat',
"composite", 'composite',
] ]
return [ return [
"normal", 'normal',
"amix", 'amix',
"bmix", 'bmix',
"repeat", 'repeat',
"composite", 'composite',
"tvmix", 'tvmix',
"upmix21", 'upmix21',
"upmix41", 'upmix41',
"upmix61", 'upmix61',
"centeronly", 'centeronly',
"lfeonly", 'lfeonly',
"rearonly", 'rearonly',
] ]
@ -166,77 +166,77 @@ def check_bounds(val, bounds: tuple) -> int | float:
def get_slider_params(i, kind) -> Iterable: def get_slider_params(i, kind) -> Iterable:
if i < kind.phys_in: if i < kind.phys_in:
if kind.name == "basic": if kind.name == 'basic':
return ("AUDIBILITY",) return ('AUDIBILITY',)
if kind.name == "banana": if kind.name == 'banana':
return ("COMP", "GATE") return ('COMP', 'GATE')
if kind.name == "potato": if kind.name == 'potato':
return ("COMP", "GATE", "DENOISER") return ('COMP', 'GATE', 'DENOISER')
return ("BASS", "MID", "TREBLE") return ('BASS', 'MID', 'TREBLE')
def get_full_slider_params(i, kind) -> Iterable: def get_full_slider_params(i, kind) -> Iterable:
params = list(get_slider_params(i, kind) + ("GAIN", "LIMIT")) params = list(get_slider_params(i, kind) + ('GAIN', 'LIMIT'))
if kind.name == "basic": if kind.name == 'basic':
params.remove("LIMIT") params.remove('LIMIT')
return params return params
def get_slider_modes() -> Iterable: def get_slider_modes() -> Iterable:
return ( return (
"GAIN MODE", 'GAIN MODE',
"BASS MODE", 'BASS MODE',
"MID MODE", 'MID MODE',
"TREBLE MODE", 'TREBLE MODE',
"AUDIBILITY MODE", 'AUDIBILITY MODE',
"COMP MODE", 'COMP MODE',
"GATE MODE", 'GATE MODE',
"DENOISER MODE", 'DENOISER MODE',
"LIMIT MODE", 'LIMIT MODE',
) )
def _get_bus_assignments(kind) -> list: 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)] 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)]
psg.theme_add_new( psg.theme_add_new(
"HighContrast", 'HighContrast',
{ {
"BACKGROUND": "#FFFFFF", 'BACKGROUND': '#FFFFFF',
"TEXT": "#000000", 'TEXT': '#000000',
"INPUT": "#FAF9F6", 'INPUT': '#FAF9F6',
"TEXT_INPUT": "#000000", 'TEXT_INPUT': '#000000',
"SCROLL": "#FAF9F6", 'SCROLL': '#FAF9F6',
"BUTTON": ("#000000", "#FFFFFF"), 'BUTTON': ('#000000', '#FFFFFF'),
"PROGRESS": ("#000000", "#FFFFFF"), 'PROGRESS': ('#000000', '#FFFFFF'),
"BORDER": 2, 'BORDER': 2,
"SLIDER_DEPTH": 3, 'SLIDER_DEPTH': 3,
"PROGRESS_DEPTH": 0, 'PROGRESS_DEPTH': 0,
}, },
) )
def get_themes_list() -> list: def get_themes_list() -> list:
return [ return [
"Bright Colors", 'Bright Colors',
"Dark Blue 14", 'Dark Blue 14',
"Dark Brown 2", 'Dark Brown 2',
"Dark Brown 3", 'Dark Brown 3',
"Dark Green 2", 'Dark Green 2',
"Dark Grey 2", 'Dark Grey 2',
"Dark Teal1", 'Dark Teal1',
"Dark Teal6", 'Dark Teal6',
"Kayak", 'Kayak',
"Light Blue 2", 'Light Blue 2',
"Light Brown 2", 'Light Brown 2',
"Light Brown 5", 'Light Brown 5',
"Light Green", 'Light Green',
"Light Green 3", 'Light Green 3',
"Light Grey 2", 'Light Grey 2',
"Light Purple", 'Light Purple',
"Neutral Blue", 'Neutral Blue',
"Reds", 'Reds',
"Sandy Beach", 'Sandy Beach',
"High Contrast", 'High Contrast',
] ]

1092
src/nvda_voicemeeter/window.py
View File

File diff suppressed because it is too large Load Diff