zx/quisk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
e6b9d9dd0575cae70246b9bfb0024bd8349cc32e
quisk/configure.py
T

4681 lines
185 KiB
Python
Raw Blame History

import sys, wx, wx.lib, os, re, pickle, traceback, json, copy
# Quisk will alter quisk_conf_defaults to include the user's config file.
import quisk_conf_defaults as conf
import _quisk as QS
from quisk_widgets import QuiskPushbutton, QuiskCheckbutton, QuiskBitField, SliderBoxH, SliderBoxHH
from quisk_widgets import FreqFormatter
from quisk_widgets import wxVersion
if wxVersion in ('2', '3'):
import wx.combo as wxcombo
else:
wxcombo = wx # wxPython Phoenix
try:
from soapypkg import soapy
except:
soapy = None
# Settings is [
# 0: Radio_requested, a string radio name or "Ask me" or "ConfigFileRadio"
# 1: Radio in use and last used, a string radio name or "ConfigFileRadio"
# 2: List of radio names
# 3: Parallel list of radio dicts. These are all the parameters for the corresponding radio. In
# general, they are a subset of all the parameters listed in self.sections and self.receiver_data[radio_name].
# 4: Global data common to all radios. This is similar to the radio dicts. Available as local_conf.globals.
# ]
# radio_dict is a dictionary of variable names and text values for each radio including radio ConfigFileRadio.
# Only variable names from the specified radio and all sections are included. The data comes from the JSON file, and
# may be missing recently added config file items. Use GetValue() to get a configuration datum.
# local_conf is the single instance of class Configuration. conf is the configuration data from quisk_conf_defaults as
# over-writen by JSON data in radio_dict. Items in the radio_dict are generally strings. We convert these strings to Python
# integers, floats, etc. and write them to conf.
# The format for data items is read from quisk_conf_defaults.py, but there are data items not in this file. The
# dictionary name2format has formats and defaults for these additional items.
# The value is a tuple (format name, default value).
name2format = {
"digital_rx1_name":('text', ''), "digital_rx2_name":('text', ''), "digital_rx3_name":('text', ''),
"digital_rx4_name":('text', ''), "digital_rx5_name":('text', ''), "digital_rx6_name":('text', ''),
"digital_rx7_name":('text', ''), "digital_rx8_name":('text', ''), "digital_rx9_name":('text', ''),
"win_digital_rx1_name":('text', ''), "win_digital_rx2_name":('text', ''), "win_digital_rx3_name":('text', ''),
"win_digital_rx4_name":('text', ''), "win_digital_rx5_name":('text', ''), "win_digital_rx6_name":('text', ''),
"win_digital_rx7_name":('text', ''), "win_digital_rx8_name":('text', ''), "win_digital_rx9_name":('text', ''),
"lin_digital_rx1_name":('text', ''), "lin_digital_rx2_name":('text', ''), "lin_digital_rx3_name":('text', ''),
"lin_digital_rx4_name":('text', ''), "lin_digital_rx5_name":('text', ''), "lin_digital_rx6_name":('text', ''),
"lin_digital_rx7_name":('text', ''), "lin_digital_rx8_name":('text', ''), "lin_digital_rx9_name":('text', ''),
}
# Increasing the software version will display a message to re-read the soapy device.
soapy_software_version = 3
wxpython_gtk3_bug = 0
def FormatKhz(dnum): # Round to 3 decimal places; remove ending ".000"
t = "%.3f" % dnum
if t[-4:] == '.000':
t = t[0:-4]
return t
def FormatMHz(dnum): # Pretty print in MHz
t = "%.6f" % dnum
for i in range(3):
if t[-1] == '0':
t = t[0:-1]
else:
break
return t
def SortKey(x):
try:
k = float(x)
except:
k = 0.0
return k
class Configuration:
def __init__(self, app, AskMe=False, Radio=''): # Called first
global application, local_conf, Settings, noname_enable, platform_ignore, platform_accept
Settings = ["ConfigFileRadio", "ConfigFileRadio", [], [], {}]
self.globals = Settings[4] # Will be replaced by quisk_settings.json
application = app
local_conf = self
noname_enable = []
if sys.platform == 'win32':
platform_ignore = 'lin_'
platform_accept = 'win_'
else:
platform_accept = 'lin_'
platform_ignore = 'win_'
self.sections = []
self.receiver_data = []
self.receiver_explain = []
self.StatePath = conf.settings_file_path
if not self.StatePath:
self.StatePath = os.path.join(app.QuiskFilesDir, "quisk_settings.json")
self.ReadState()
if AskMe == 'Same':
pass
elif Radio:
choices = Settings[2] + ["ConfigFileRadio"]
if Radio in choices:
if Settings[1] != Radio:
Settings[1] = Radio
self.settings_changed = True
else:
t = "There is no radio named %s. Radios are " % Radio
for choice in choices:
t = "%s%s, " % (t, choice)
t = t[0:-2] + '.'
dlg = wx.MessageDialog(application.main_frame, t, 'Specify Radio', wx.OK|wx.ICON_ERROR)
dlg.ShowModal()
dlg.Destroy()
sys.exit(0)
elif AskMe or Settings[0] == "Ask me":
choices = Settings[2] + ["ConfigFileRadio"]
dlg = wx.SingleChoiceDialog(None, "", "Start Quisk with this Radio",
choices, style=wx.DEFAULT_FRAME_STYLE|wx.OK|wx.CANCEL)
dlg.SetSizeHints(dlg.GetCharWidth() * 36, -1, -1, -1)
try:
n = choices.index(Settings[1]) # Set default to last used radio
except:
pass
else:
dlg.SetSelection(n)
ok = dlg.ShowModal()
if ok != wx.ID_OK:
sys.exit(0)
select = dlg.GetStringSelection()
dlg.Destroy()
if Settings[1] != select:
Settings[1] = select
self.settings_changed = True
else:
Settings[1] = Settings[0]
if Settings[1] == "ConfigFileRadio":
Settings[2].append("ConfigFileRadio")
Settings[3].append({})
self.ParseConfig()
self.originalBandEdge = {} # save original BandEdge
self.originalBandEdge.update(conf.BandEdge)
self.UpdateGlobals()
def RequiredValues(self, radio_dict):
radio_type = radio_dict['hardware_file_type']
# Fill in required values
if radio_type == "SdrIQ":
radio_dict["use_sdriq"] = '1'
if radio_dict['hardware_file_name'] == "sdriqpkg/quisk_hardware.py":
radio_dict['hardware_file_name'] = "quisk_hardware_sdriq.py"
else:
radio_dict["use_sdriq"] = '0'
if radio_type == "Hermes":
radio_dict["hermes_bias_adjust"] = "False"
if radio_type == 'SoapySDR':
radio_dict["use_soapy"] = '1'
self.InitSoapyNames(radio_dict)
if radio_dict.get("soapy_file_version", 0) < soapy_software_version:
text = "Your SoapySDR device parameters are out of date. Please go to the radio configuration screen and re-read the device parameters."
dlg = wx.MessageDialog(None, text, 'Please Re-Read Device', wx.OK|wx.ICON_INFORMATION)
dlg.ShowModal()
dlg.Destroy()
else:
radio_dict["use_soapy"] = '0'
if radio_type not in ("HiQSDR", "Hermes", "Red Pitaya", "Odyssey", "Odyssey2", "OpenHPSDR"):
radio_dict["use_rx_udp"] = '0'
if radio_type in ("Hermes", "Red Pitaya", "Odyssey2", "OpenHPSDR"):
if "Hermes_BandDict" not in radio_dict:
radio_dict["Hermes_BandDict"] = {}
if "Hermes_BandDictTx" not in radio_dict:
radio_dict["Hermes_BandDictTx"] = {}
def UpdateGlobals(self):
self.RadioName = Settings[1]
application.BandPlanC2T = {}
if self.RadioName == "ConfigFileRadio":
application.BandPlan = conf.BandPlan
for mode, color in conf.BandPlanColors:
application.BandPlanC2T[color] = mode
elif "BandPlanColors" in Settings[4] and "BandPlan" in Settings[4]:
mode_dict = {"End":None}
for mode, color in Settings[4]["BandPlanColors"]:
mode_dict[mode] = color
application.BandPlanC2T[color] = mode
plan = []
for freq, mode in Settings[4]["BandPlan"]:
freq = int(float(freq) * 1E6 + 0.1)
try:
color = mode_dict[mode]
except:
print ("Missing color for mode", mode)
color = '#777777'
plan.append([freq, color])
application.BandPlan = plan
else:
application.BandPlan = conf.BandPlan
for mode, color in conf.BandPlanColors:
application.BandPlanC2T[color] = mode
if "MidiNoteDict" not in Settings[4]:
Settings[4]["MidiNoteDict"] = {}
self.settings_changed = True
self.MidiNoteDict = Settings[4]["MidiNoteDict"]
# Convert old to new format, October, 2021
for txt_note in list(local_conf.MidiNoteDict): # txt_note is a string
int_note = int(txt_note, base=0)
if int_note < 128:
target = local_conf.MidiNoteDict[txt_note]
if len(target) > 3 and target[-3] == " " and target[-2] in "+-" and target[-1] in "0123456789": # Jog wheel
key = "0xB0%02X" % int_note
elif target in ("Vol", "STo", "Rit", "Ys", "Yz", "Zo", "Tune"): # Knob
key = "0xB0%02X" % int_note
else: # Button. Enter as the Note On message.
key = "0x90%02X" % int_note
local_conf.MidiNoteDict[key] = target
del local_conf.MidiNoteDict[txt_note]
self.settings_changed = True
def UpdateConf(self): # Called second to update the configuration for the selected radio
# Items in the radio_dict are generally strings. Convert these strings to Python integers, floats,
# etc. and write them to conf.
if Settings[1] == "ConfigFileRadio":
return
radio_dict = self.GetRadioDict()
# fill in conf from our configuration data; convert text items to Python objects
errors = ''
for k, v in list(radio_dict.items()): # radio_dict may change size during iteration
if k == 'favorites_file_path': # A null string is equivalent to "not entered"
if not v.strip():
continue
if k in ('power_meter_local_calibrations', ): # present in configuration data but not in the config file
continue
if k[0:6] == 'soapy_': # present in configuration data but not in the config file
continue
if k[0:6] == 'Hware_': # contained in hardware file, not in configuration data nor config file
continue
try:
fmt = self.format4name[k]
except:
errors = errors + "Ignore obsolete parameter %s\n" % k
del radio_dict[k]
self.settings_changed = True
continue
k4 = k[0:4]
if k4 == platform_ignore:
continue
elif k4 == platform_accept:
k = k[4:]
fmt4 = fmt[0:4]
if fmt4 not in ('dict', 'list'):
i1 = v.find('#')
if i1 > 0:
v = v[0:i1]
try:
if fmt4 == 'text': # Note: JSON returns Unicode strings !!!
setattr(conf, k, v)
elif fmt4 == 'dict':
if isinstance(v, dict):
setattr(conf, k, v)
else:
raise ValueError()
elif fmt4 == 'list':
if isinstance(v, list):
setattr(conf, k, v)
else:
raise ValueError()
elif fmt4 == 'inte':
setattr(conf, k, int(v, base=0))
elif fmt4 == 'numb':
setattr(conf, k, float(v))
elif fmt4 == 'bool':
if v == "True":
setattr(conf, k, True)
else:
setattr(conf, k, False)
elif fmt4 == 'rfil':
pass
elif fmt4 == 'keyc': # key code
if v == "None":
x = None
else:
x = eval(v)
x = int(x)
if k == 'hot_key_ptt2' and not isinstance(x, int):
setattr(conf, k, wx.ACCEL_NORMAL)
else:
setattr(conf, k, x)
else:
print ("Unknown format for", k, fmt)
except:
del radio_dict[k]
self.settings_changed = True
errors = errors + "Failed to set %s to %s using format %s\n" % (k, v, fmt)
#traceback.print_exc()
if conf.color_scheme != 'A':
conf.__dict__.update(getattr(conf, 'color_scheme_' + conf.color_scheme))
self.RequiredValues(radio_dict) # Why not update conf too??? This only updates the radio_dict.
if errors:
dlg = wx.MessageDialog(None, errors,
'Update Settings', wx.OK|wx.ICON_ERROR)
ret = dlg.ShowModal()
dlg.Destroy()
def InitSoapyNames(self, radio_dict): # Set Soapy data items, but not the hardware available lists and ranges.
if radio_dict.get('soapy_getFullDuplex_rx', 0):
radio_dict["add_fdx_button"] = '1'
else:
radio_dict["add_fdx_button"] = '0'
name = 'soapy_gain_mode_rx'
if name not in radio_dict:
radio_dict[name] = 'total'
name = 'soapy_setAntenna_rx'
if name not in radio_dict:
radio_dict[name] = ''
name = 'soapy_gain_values_rx'
if name not in radio_dict:
radio_dict[name] = {}
name = 'soapy_gain_mode_tx'
if name not in radio_dict:
radio_dict[name] = 'total'
name = 'soapy_setAntenna_tx'
if name not in radio_dict:
radio_dict[name] = ''
name = 'soapy_gain_values_tx'
if name not in radio_dict:
radio_dict[name] = {}
def NormPath(self, path): # Convert between Unix and Window file paths
if sys.platform == 'win32':
path = path.replace('/', '\\')
else:
path = path.replace('\\', '/')
return path
def GetHardware(self): # Called third to open the hardware file
if Settings[1] == "ConfigFileRadio":
return False
path = self.GetRadioDict()["hardware_file_name"]
path = self.NormPath(path)
if not os.path.isfile(path):
dlg = wx.MessageDialog(None,
"Can not find the hardware file %s!" % path,
'Hardware File', wx.OK|wx.ICON_ERROR)
ret = dlg.ShowModal()
dlg.Destroy()
path = 'quisk_hardware_model.py'
dct = {}
dct.update(conf.__dict__) # make items from conf available
if "Hardware" in dct:
del dct["Hardware"]
if 'quisk_hardware' in dct:
del dct["quisk_hardware"]
exec(compile(open(path).read(), path, 'exec'), dct)
if "Hardware" in dct:
application.Hardware = dct['Hardware'](application, conf)
return True
return False
def Initialize(self): # Called fourth to fill in our ConfigFileRadio radio from conf
if Settings[1] == "ConfigFileRadio":
radio_dict = self.GetRadioDict("ConfigFileRadio")
typ = self.GuessType()
radio_dict['hardware_file_type'] = typ
all_data = []
all_data = all_data + self.GetReceiverData(typ)
for name, sdata in self.sections:
all_data = all_data + sdata
for data_name, text, fmt, help_text, values in all_data:
data_name4 = data_name[0:4]
if data_name4 == platform_ignore:
continue
elif data_name4 == platform_accept:
conf_name = data_name[4:]
else:
conf_name = data_name
try:
if fmt in ("dict", "list"):
radio_dict[data_name] = getattr(conf, conf_name)
else:
radio_dict[data_name] = str(getattr(conf, conf_name))
except:
if data_name == 'playback_rate':
pass
else:
print ('No config file value for', data_name)
def GetWidgets(self, app, hardware, conf, frame, gbs, vertBox): # Called fifth
if Settings[1] == "ConfigFileRadio":
return False
path = self.GetRadioDict().get("widgets_file_name", '')
path = self.NormPath(path)
if os.path.isfile(path):
dct = {}
dct.update(conf.__dict__) # make items from conf available
exec(compile(open(path).read(), path, 'exec'), dct)
if "BottomWidgets" in dct:
app.bottom_widgets = dct['BottomWidgets'](app, hardware, conf, frame, gbs, vertBox)
return True
def OnPageChanging(self, event): # Called when the top level page changes (not RadioNotebook pages)
global wxpython_gtk3_bug
event.Skip()
notebook = event.GetEventObject()
index = event.GetSelection()
page = notebook.GetPage(index)
if sys.platform != 'win32': # Work around a bug in wxPython 4.2.1 and gtk3
w, h = application.main_frame.GetSize() # Change main window size by +/- one pixel to recalculate sizes
if wxpython_gtk3_bug:
wxpython_gtk3_bug = 0
h += 1
else:
wxpython_gtk3_bug = 1
h -= 1
application.main_frame.SetSize((w, h))
if isinstance(page, RadioNotebook):
if not page.pages:
page.MakePages()
def AddPages(self, notebk, width): # Called sixth to add pages Help, Radios, all radio names
global win_width
win_width = width
self.notebk = notebk
self.radio_page = Radios(notebk)
notebk.AddPage(self.radio_page, "Radios")
self.radios_page_start = notebk.GetPageCount()
notebk.Bind(wx.EVT_NOTEBOOK_PAGE_CHANGED, self.OnPageChanging, notebk)
if Settings[1] in Settings[2]:
page = RadioNotebook(notebk, Settings[1])
notebk.AddPage(page, "*%s*" % Settings[1])
for name in Settings[2]:
if name != Settings[1]:
page = RadioNotebook(notebk, name)
notebk.AddPage(page, name)
def GuessType(self):
udp = conf.use_rx_udp
if conf.use_sdriq:
return 'SdrIQ'
elif udp == 1:
return 'HiQSDR'
elif udp == 2:
return 'HiQSDR'
elif udp == 10:
return 'Hermes'
elif udp > 0:
return 'HiQSDR'
return 'SoftRock USB'
def FindNotebookPage(self, name):
for index in range(self.radios_page_start, self.notebk.GetPageCount()):
tab_text = self.notebk.GetPageText(index)
if tab_text[0] == '*':
tab_text = tab_text[1:-1]
if tab_text == name:
return index
return None
def AddRadio(self, radio_name, typ):
radio_dict = {}
radio_dict['hardware_file_type'] = typ
Settings[2].append(radio_name)
Settings[3].append(radio_dict)
for data_name, text, fmt, help_text, values in self.GetReceiverData(typ):
radio_dict[data_name] = values[0]
for name, data in self.sections:
for data_name, text, fmt, help_text, values in data:
radio_dict[data_name] = values[0]
# Change some default values in quisk_conf_defaults.py based on radio type
if typ in ("HiQSDR", "Hermes", "Red Pitaya", "Odyssey", "Odyssey2"):
radio_dict["add_fdx_button"] = '1'
page = RadioNotebook(self.notebk, radio_name)
self.notebk.AddPage(page, radio_name)
return True
def CopyRadio(self, old_name, new_name):
radio_dict = {}
index = Settings[2].index(old_name)
radio_dict.update(Settings[3][index])
Settings[2].append(new_name)
Settings[3].append(radio_dict)
page = RadioNotebook(self.notebk, new_name)
self.notebk.AddPage(page, new_name)
return True
def RenameRadio(self, old, new):
n = self.FindNotebookPage(old)
if n is None:
return
if old == Settings[1]:
self.notebk.SetPageText(n, "*%s*" % new)
else:
self.notebk.SetPageText(n, new)
index = Settings[2].index(old)
Settings[2][index] = new
self.notebk.GetPage(n).NewName(new)
if old == "ConfigFileRadio":
for ctrl in noname_enable:
ctrl.Enable()
return True
def DeleteRadio(self, name):
index = Settings[2].index(name)
del Settings[2][index]
del Settings[3][index]
n = self.FindNotebookPage(name)
if n is not None:
self.notebk.DeletePage(n)
return True
def GetRadioDict(self, radio_name=None): # None radio_name means the current radio
if radio_name:
index = Settings[2].index(radio_name)
else: # index of radio in use
index = Settings[2].index(Settings[1])
return Settings[3][index]
#def GetItem(self, name, deflt=None, accept=None): # return item or default. accept can be "win_" or "lin_"
# dct = self.GetRadioDict()
# if accept:
# return dct.get(accept+name, deflt)
# return dct.get(name, deflt)
def GetSectionData(self, section_name):
for sname, data in self.sections:
if sname == section_name:
return data
return None
def GetReceiverData(self, receiver_name):
for rxname, data in self.receiver_data:
if rxname == receiver_name:
return data
return ()
def GetReceiverDatum(self, receiver_name, item_name):
for rxname, data in self.receiver_data:
if rxname == receiver_name:
for data_name, text, fmt, help_text, values in data:
if item_name == data_name:
return values[0]
break
return ''
def GetReceiverItemTH(self, receiver_name, item_name):
for rxname, data in self.receiver_data:
if rxname == receiver_name:
for data_name, text, fmt, help_text, values in data:
if item_name == data_name:
return text, help_text
break
return '', ''
def ReceiverHasName(self, receiver_name, item_name):
for rxname, data in self.receiver_data:
if rxname == receiver_name:
for data_name, text, fmt, help_text, values in data:
if item_name == data_name:
return True
break
return False
def ReadState(self):
self.settings_changed = False
global Settings
try:
fp = open(self.StatePath, "r")
except:
return
try:
Settings = json.load(fp)
except:
traceback.print_exc()
fp.close()
try: # Do not save settings for radio ConfigFileRadio
index = Settings[2].index("ConfigFileRadio")
except ValueError:
pass
else:
del Settings[2][index]
del Settings[3][index]
for sdict in Settings[3]:
# Fixup for prior errors that save dictionaries as strings
for name in ("tx_level", "HiQSDR_BandDict", "Hermes_BandDict", "Hermes_BandDictTx"):
if name in sdict:
if not isinstance(sdict[name], dict):
print ("Bad dictionary for", name)
sdict[name] = {}
self.settings_changed = True
# Python None is saved as "null"
if "tx_level" in sdict:
if "null" in sdict["tx_level"]:
v = sdict["tx_level"]["null"]
sdict["tx_level"][None] = v
del sdict["tx_level"]["null"]
# Add global section if it is absent
length = len(Settings)
if length < 4: # Serious error
pass
elif length == 4: # Old file without global section
Settings.append({})
self.settings_changed = True
else: # Settings[4] must be a dict
if not isinstance(Settings[4], dict):
Settings[4] = {}
self.settings_changed = True
self.globals = Settings[4]
def SaveState(self):
if not self.settings_changed:
return
try:
fp = open(self.StatePath, "w")
except:
traceback.print_exc()
return
json.dump(Settings, fp, indent=2)
fp.close()
self.settings_changed = False
def ParseConfig(self):
# ParseConfig() fills self.sections, self.receiver_data, and
# self.format4name with the items that Configuration understands.
# Dicts and lists are Python objects. All other items are text, not Python objects.
#
# This parses the quisk_conf_defaults.py file and user-defined radios in ./*pkg/quisk_hardware.py.
#
# Sections start with 16 #, section name
# self.sections is a list of [section_name, section_data]
# section_data is a list of [data_name, text, fmt, help_text, values]
# Receiver sections start with 16 #, "Receivers ", receiver name, explain
# self.receiver_data is a list of [receiver_name, receiver_data]
# receiver_data is a list of [data_name, text, fmt, help_text, values]
# self.receiver_explain is a list of the text in Receivers: the name, a comma and the explanation.
# Variable names start with ## variable_name variable_text, format
# The format is integer, number, text, boolean, integer choice, text choice, rfile
# Then some help text starting with "# "
# Then a list of possible value#explain with the default first
# Then a blank line to end.
self.format4name = {}
for name in name2format:
self.format4name[name] = name2format[name][0]
self.format4name['hardware_file_type'] = 'text'
self._ParserConf('quisk_conf_defaults.py')
# Read any user-defined radio types
for dirname in os.listdir('.'):
if not os.path.isdir(dirname) or dirname[-3:] != 'pkg':
continue
if dirname in ('freedvpkg', 'sdriqpkg', 'soapypkg'):
continue
filename = os.path.join(dirname, 'quisk_hardware.py')
if not os.path.isfile(filename):
continue
try:
self._ParserConf(filename)
except:
traceback.print_exc()
def _ParserConf(self, filename):
re_AeqB = re.compile(r"^#?(\w+)\s*=\s*([^#]+)#*(.*)") # item values "a = b"
section = None
data_name = None
multi_line = False
fp = open(filename, "r", encoding="utf8")
for line in fp:
line = line.strip()
if not line:
data_name = None
continue
if line[0:27] == '################ Receivers ':
section = 'Receivers'
self.receiver_explain.append(line[27:].strip())
args = line[27:].split(',', 1)
rxname = args[0].strip()
section_data = []
self.receiver_data.append((rxname, section_data))
elif line[0:17] == '################ ':
section = line[17:].strip()
if section in ('Colors', 'Obsolete'):
section = None
continue
rxname = None
section_data = []
self.sections.append((section, section_data))
if not section:
continue
if line[0:3] == '## ': # item_name item_text, format
args = line[3:].split(None, 1)
data_name = args[0]
args = args[1].split(',', 1)
dspl = args[0].strip()
fmt = args[1].strip()
value_list = []
if data_name in self.format4name:
if self.format4name[data_name] != fmt:
print (filename, ": Inconsistent format for", data_name, self.format4name[data_name], fmt)
else:
self.format4name[data_name] = fmt
section_data.append([data_name, dspl, fmt, '', value_list])
multi_line = False
if not data_name:
continue
if multi_line:
value += line
#print ("Multi", data_name, type(value), value)
count = self._multi_count(value)
if count == 0:
value = eval(value, conf.__dict__)
value_list.append(value)
#print ("Multi done", data_name, type(value), value)
multi_line = False
continue
mo = re_AeqB.match(line)
if mo:
if data_name != mo.group(1):
print (filename, ": Parse error for", data_name)
continue
value = mo.group(2).strip()
expln = mo.group(3).strip()
if value[0] in ('"', "'"):
value = value[1:-1]
elif value[0] == '{': # item is a dictionary
if self._multi_count(value) == 0: # dictionary is complete
value = eval(value, conf.__dict__)
#print ("Single", data_name, type(value), value)
else:
multi_line = True
#print ("Start multi", data_name, type(value), value)
continue
elif value[0] == '[': # item is a list
if self._multi_count(value) == 0: # list is complete
value = eval(value, conf.__dict__)
#print ("Single", data_name, type(value), value)
else:
multi_line = True
#print ("Start multi", data_name, type(value), value)
continue
if expln:
value_list.append("%s # %s" % (value, expln))
else:
value_list.append(value)
elif line[0:2] == '# ':
section_data[-1][3] = section_data[-1][3] + line[2:] + ' '
fp.close()
def _multi_count(self, value):
char_start = value[0]
if char_start == '{':
char_end = '}'
elif char_start == '[':
char_end = ']'
count = 0
for ch in value:
if ch == char_start:
count += 1
elif ch == char_end:
count -= 1
return count
class xxConfigHelp(wx.html.HtmlWindow): # The "Help with Radios" first-level page
"""Create the help screen for the configuration tabs."""
def __init__(self, parent):
wx.html.HtmlWindow.__init__(self, parent, -1, size=(win_width, 100))
if "gtk2" in wx.PlatformInfo:
self.SetStandardFonts()
self.SetFonts("", "", [10, 12, 14, 16, 18, 20, 22])
self.SetBackgroundColour(parent.bg_color)
# read in text from file help_conf.html in the directory of this module
self.LoadFile('help_conf.html')
class QPowerMeterCalibration(wx.Frame):
"""Create a window to enter the power output and corresponding ADC value AIN1/2"""
def __init__(self, parent, local_names):
self.parent = parent
self.local_names = local_names
self.table = [] # calibration table: list of [ADC code, power watts]
try: # may be missing in wxPython 2.x
wx.Frame.__init__(self, application.main_frame, -1, "Power Meter Calibration",
pos=(50, 100), style=wx.CAPTION|wx.FRAME_FLOAT_ON_PARENT)
except AttributeError:
wx.Frame.__init__(self, application.main_frame, -1, "Power Meter Calibration",
pos=(50, 100), style=wx.CAPTION)
panel = wx.Panel(self)
self.MakeControls(panel)
self.Show()
def MakeControls(self, panel):
charx = panel.GetCharWidth()
tab1 = charx * 5
y = 20
# line 1
txt = wx.StaticText(panel, -1, 'Name for new calibration table', pos=(tab1, y))
w, h = txt.GetSize().Get()
tab2 = tab1 + w + tab1 // 2
self.cal_name = wx.TextCtrl(panel, -1, pos=(tab2, h), size=(charx * 16, h * 13 // 10))
y += h * 3
# line 2
txt = wx.StaticText(panel, -1, 'Measured power level in watts', pos=(tab1, y))
self.cal_power = wx.TextCtrl(panel, -1, pos=(tab2, y), size=(charx * 16, h * 13 // 10))
x = tab2 + charx * 20
add = QuiskPushbutton(panel, self.OnBtnAdd, "Add to Table")
add.SetPosition((x, y - h * 3 // 10))
add.SetColorGray()
ww, hh = add.GetSize().Get()
width = x + ww + tab1
y += h * 3
# line 3
sv = QuiskPushbutton(panel, self.OnBtnSave, "Save")
sv.SetColorGray()
cn = QuiskPushbutton(panel, self.OnBtnCancel, "Cancel")
cn.SetColorGray()
w, h = cn.GetSize().Get()
sv.SetPosition((width // 4, y))
cn.SetPosition((width - width // 4 - w, y))
y += h * 12 // 10
# help text at bottom
wx.StaticText(panel, -1, '1. Attach a 50 ohm load and power meter to the antenna connector.', pos=(tab1, y))
w, h = txt.GetSize().Get()
h = h * 12 // 10
y += h
wx.StaticText(panel, -1, '2. Use the Spot button to transmit at a very low power.', pos=(tab1, y))
y += h
wx.StaticText(panel, -1, '3. Enter the measured power in the box above and press "Add to Table".', pos=(tab1, y))
y += h
wx.StaticText(panel, -1, '4. Increase the power a small amount and repeat step 3.', pos=(tab1, y))
y += h
wx.StaticText(panel, -1, '5. Increase power again and repeat step 3.', pos=(tab1, y))
y += h
wx.StaticText(panel, -1, '6. Keep adding measurements to the table until you reach full power.', pos=(tab1, y))
y += h
wx.StaticText(panel, -1, '7. Ten or twelve measurements should be enough. Then press "Save".', pos=(tab1, y))
y += h
wx.StaticText(panel, -1, 'To delete a table, save a table with zero measurements.', pos=(tab1, y))
y += h * 2
self.SetClientSize(wx.Size(width, y))
def OnBtnCancel(self, event=None):
self.parent.ChangePMcalFinished(None, None)
self.Destroy()
def OnBtnSave(self, event):
name = self.cal_name.GetValue().strip()
if not name:
dlg = wx.MessageDialog(self,
'Please enter a name for the new calibration table.',
'Missing Name', wx.OK|wx.ICON_ERROR)
dlg.ShowModal()
dlg.Destroy()
elif name in conf.power_meter_std_calibrations: # known calibration names from the config file
dlg = wx.MessageDialog(self,
'That name is reserved. Please enter a different name.',
'Reserved Name', wx.OK|wx.ICON_ERROR)
dlg.ShowModal()
dlg.Destroy()
elif name in self.local_names:
if self.table:
dlg = wx.MessageDialog(self,
'That name exists. Replace the existing table?',
'Replace Table', wx.OK|wx.CANCEL|wx.ICON_EXCLAMATION)
ret = dlg.ShowModal()
dlg.Destroy()
if ret == wx.ID_OK:
self.parent.ChangePMcalFinished(name, self.table)
self.Destroy()
else:
dlg = wx.MessageDialog(self,
'That name exists but the table is empty. Delete the existing table?.',
'Delete Table', wx.OK|wx.CANCEL|wx.ICON_EXCLAMATION)
ret = dlg.ShowModal()
dlg.Destroy()
if ret == wx.ID_OK:
self.parent.ChangePMcalFinished(name, None)
self.Destroy()
else:
self.parent.ChangePMcalFinished(name, self.table)
self.Destroy()
def OnBtnAdd(self, event):
power = self.cal_power.GetValue().strip()
self.cal_power.Clear()
try:
power = float(power)
except:
dlg = wx.MessageDialog(self, 'Missing or bad measured power.', 'Error in Power', wx.OK|wx.ICON_ERROR)
dlg.ShowModal()
dlg.Destroy()
else:
## Convert measured voltage to power
#power *= 6.388
#power = power**2 / 50.0
fwd = application.Hardware.hermes_fwd_power
rev = application.Hardware.hermes_rev_power
if fwd >= rev:
self.table.append([fwd, power]) # Item must use lists; sort() will fail with mixed lists and tuples
else:
self.table.append([rev, power])
## Note: The amplitude/phase adjustments have ideas provided by Andrew Nilsson, VK6JBL.
## October 2020: changed to make RxTx frequency and VFO two independent variables.
## June 2024: Added a Grid control and automatic receive measurement.
class QAdjustPhase(wx.Frame):
"""Create a window with amplitude and phase adjustment controls"""
def __init__(self, parent, width, rx_tx):
self.rx_tx = rx_tx # Must be "rx" or "tx"
if rx_tx == 'tx':
self.is_tx = 1
t = "Adjust Sound Card Transmit Amplitude and Phase"
else:
self.is_tx = 0
t = "Adjust Sound Card Receive Amplitude and Phase"
wx.Frame.__init__(self, application.main_frame, -1, t, pos=(50, 100), style=wx.CAPTION|wx.RESIZE_BORDER)
self.client_width = application.screen_width * 5 // 10
self.SetClientSize((self.client_width, application.screen_height * 5 // 10))
self.new_amplitude = self.new_phase = 0.0
self.new_tune = 0
self.bandAmplPhase = copy.deepcopy(application.bandAmplPhase)
self.new_cell = None
self.dirty = False
self.manual = True
self.panel = wx.Panel(self)
self.MakeControls()
self.Redraw()
self.Show()
self.Bind(wx.EVT_CLOSE, self.OnBtnExit)
QS.softrock_corrections(1)
QS.set_ampl_phase(0.0, 0.0, self.is_tx)
self.grid.GoToCell(0, 2)
def MakeControls(self): # Make controls for phase/amplitude adjustment
panel = self.panel
sizer = wx.BoxSizer(wx.VERTICAL)
panel.SetSizer(sizer)
sl_max = application.screen_width * 4 // 10 # maximum +/- value for slider
self.ampl_scale = float(conf.rx_max_amplitude_correct) / sl_max
self.phase_scale = float(conf.rx_max_phase_correct) / sl_max
main_font = wx.Font(conf.default_font_size, wx.FONTFAMILY_SWISS, wx.NORMAL,
wx.FONTWEIGHT_NORMAL, False, conf.quisk_typeface)
self.SetFont(main_font)
panel.SetFont(main_font)
charx = self.GetCharWidth()
chary = self.GetCharHeight()
# Create the grid heading and Destroy button
self.cell_amph = wx.StaticText(panel, -1, "")
font = wx.Font(conf.default_font_size, wx.FONTFAMILY_SWISS, wx.NORMAL,
wx.FONTWEIGHT_BOLD, False, conf.quisk_typeface)
self.cell_amph.SetFont(font)
self.cell_amph.SetLabel("Cell frequency %s, gain %.3f, phase %.3f\u00B0 " % (FreqFormatter(144000000), -1.123, -12.456))
dv = wx.lib.buttons.GenButton(panel, label=" Destroy ")
dv.SetBezelWidth(3)
dv.SetBackgroundColour("#DDD")
dv.Bind(wx.EVT_BUTTON, self.OnBtnDestroy)
hbox = wx.BoxSizer(wx.HORIZONTAL)
sizer.Add(hbox, flag=wx.BOTTOM|wx.EXPAND, border=chary * 3 // 10)
hbox.Add(self.cell_amph, flag=wx.ALL|wx.ALIGN_CENTER_VERTICAL, border=chary // 2)
hbox.Add(dv, flag=wx.LEFT|wx.RIGHT|wx.ALIGN_CENTER_VERTICAL, border=charx * 5)
# Create the grid
self.grid = wx.grid.Grid(panel, style=wx.BORDER_SIMPLE)
self.grid.CreateGrid(4, 3)
self.grid.HideRowLabels()
self.selected_row = 0
self.selected_col = 0
self.cell_bg_color = self.grid.GetDefaultCellBackgroundColour()
self.grid.SetDefaultCellFont(main_font)
width, h = self.GetTextExtent("987-24 000")
self.grid.SetDefaultColSize(width, True)
self.grid.EnableEditing(False)
self.grid.SetColLabelValue(0, "Band")
self.grid.SetColLabelValue(1, "VFO")
self.grid.SetColLabelValue(2, "Tune")
self.grid.SetColSize(0, width // 2)
self.grid.SetColSize(1, width * 14 // 10)
num_tune = (self.client_width - width * 2) // width
#print ("num_tune", num_tune)
for col in range(3, num_tune + 2):
self.grid.AppendCols()
self.grid.SetColLabelValue(col, "Tune")
#self.grid.Bind(wx.grid.EVT_GRID_CELL_LEFT_CLICK, self.OnGridLeftClick)
self.grid.Bind(wx.grid.EVT_GRID_SELECT_CELL, self.OnGridSelectCell)
gbox = wx.BoxSizer(wx.VERTICAL)
sizer.Add(gbox, proportion=1, flag=wx.LEFT|wx.RIGHT|wx.EXPAND, border=charx)
gbox.Add(self.grid, proportion=1)
# Create the New Cell text, Manual/Measure, AddCell button
sbs = wx.StaticBoxSizer(wx.VERTICAL, panel, " New Cell")
sizer.Add(sbs, flag=wx.EXPAND|wx.LEFT|wx.TOP|wx.RIGHT|wx.BOTTOM, border=charx*3)
self.add_cell_text = wx.StaticText(panel, -1, "Band")
self.add_cell_text.SetFont(main_font)
sbs.Add(self.add_cell_text, flag=wx.LEFT|wx.TOP, border=charx)
box0 = wx.BoxSizer(wx.HORIZONTAL)
sbs.Add(1, charx)
sbs.Add(box0, flag=wx.EXPAND)
rb_manual = wx.RadioButton(panel, -1, "Manual adjustment", style=wx.RB_GROUP)
self.Bind(wx.EVT_RADIOBUTTON, self.OnBtnManMeasure)
rb_measure = wx.RadioButton(panel, -1, "Measure")
if self.is_tx:
rb_manual.Enable(False)
rb_measure.Enable(False)
b = wx.lib.buttons.GenButton(panel, label=" Add cell ")
b.Bind(wx.EVT_BUTTON, self.OnBtnAddCell)
b.SetBezelWidth(3)
b.SetBackgroundColour("#DDD")
box0.Add(rb_manual, flag=wx.LEFT|wx.ALIGN_CENTER_VERTICAL, border=charx)
box0.Add(rb_measure, flag=wx.LEFT|wx.ALIGN_CENTER_VERTICAL, border=charx*5)
box0.Add(b, flag=wx.LEFT, border=charx*5)
# Create the amplitude slider controls
box1 = wx.BoxSizer(wx.HORIZONTAL)
box2 = wx.BoxSizer(wx.HORIZONTAL)
sbs.Add(box1, flag=wx.EXPAND)
sbs.Add(box2, flag=wx.EXPAND)
# ST_ELLIPSIZE_END needed to work around a layout bug
fine = wx.StaticText(panel, -1, 'Gain Fine', style=wx.ST_ELLIPSIZE_END)
coarse = wx.StaticText(panel, -1, 'Gain Coarse', style=wx.ST_ELLIPSIZE_END)
box1.Add(fine, flag=wx.LEFT|wx.ALIGN_CENTER_VERTICAL, border=charx*3)
box2.Add(coarse, flag=wx.LEFT|wx.ALIGN_CENTER_VERTICAL, border=charx*3)
self.ampl1 = wx.Slider(panel, -1, 0, -sl_max, sl_max)
self.ampl2 = wx.Slider(panel, -1, 0, -sl_max, sl_max)
box1.Add(self.ampl1, flag=wx.LEFT, proportion=1, border=0)
box2.Add(self.ampl2, flag=wx.LEFT, proportion=1, border=0)
self.ampl1.Bind(wx.EVT_SCROLL, self.OnAmpl1)
self.ampl2.Bind(wx.EVT_SCROLL, self.OnAmpl2)
# Create the phase slider controls
box3 = wx.BoxSizer(wx.HORIZONTAL)
box4 = wx.BoxSizer(wx.HORIZONTAL)
sbs.Add(box3, flag=wx.EXPAND)
sbs.Add(box4, flag=wx.EXPAND)
fine = wx.StaticText(panel, -1, 'Phase Fine', style=wx.ST_ELLIPSIZE_END)
coarse = wx.StaticText(panel, -1, 'Phase Coarse', style=wx.ST_ELLIPSIZE_END)
box3.Add(fine, flag=wx.LEFT|wx.ALIGN_CENTER_VERTICAL, border=charx*3)
box4.Add(coarse, flag=wx.LEFT|wx.ALIGN_CENTER_VERTICAL, border=charx*3)
self.phas1 = wx.Slider(panel, -1, 0, -sl_max, sl_max)
self.phas2 = wx.Slider(panel, -1, 0, -sl_max, sl_max)
box3.Add(self.phas1, flag=wx.LEFT, proportion=1, border=0)
box4.Add(self.phas2, flag=wx.LEFT, proportion=1, border=0)
self.phas1.Bind(wx.EVT_SCROLL, self.OnPhase1)
self.phas2.Bind(wx.EVT_SCROLL, self.OnPhase2)
# Create the button row
btnbox = wx.BoxSizer(wx.HORIZONTAL)
sizer.Add(btnbox, flag=wx.EXPAND)
btns = []
btnbox.Add(1, 1, proportion=10)
b = wx.lib.buttons.GenButton(panel, label=" Save ")
btnbox.Add(b)
btnbox.Add(1, 1, proportion=5)
btns.append(b)
size = b.GetSize()
b.Bind(wx.EVT_BUTTON, self.OnBtnSave)
b = wx.lib.buttons.GenButton(panel, label=" Exit ")
btnbox.Add(b)
btnbox.Add(1, 1, proportion=5)
btns.append(b)
b.Bind(wx.EVT_BUTTON, self.OnBtnExit)
b = wx.lib.buttons.GenButton(panel, label=" Help ")
btnbox.Add(b)
btnbox.Add(1, 1, proportion=10)
btns.append(b)
b.Bind(wx.EVT_BUTTON, self.OnBtnHelp)
#b.Bind(wx.EVT_BUTTON, self.OnGraphData)
for b in btns:
b.SetBezelWidth(3)
b.SetBackgroundColour("#DDD")
b.SetSize(size)
sizer.Add(charx, chary)
def Redraw(self):
self.grid.ClearGrid()
# Print available data cells
row = 0
bands = []
self.cell_dict = {}
for band in self.bandAmplPhase:
if band != "Version" and self.rx_tx in self.bandAmplPhase[band]:
bands.append(band)
bands.sort(reverse=True)
for band in bands:
vfos_tunes = self.bandAmplPhase[band][self.rx_tx]
if vfos_tunes:
if self.grid.GetNumberRows() <= row:
self.grid.AppendRows()
self.grid.SetCellValue(row, 0, band)
self.grid.SetCellAlignment(row, 0, wx.ALIGN_CENTER, wx.ALIGN_CENTER)
for vfo, tunes in vfos_tunes:
if self.grid.GetNumberRows() <= row:
self.grid.AppendRows()
self.cell_dict[(row, 0)] = band, vfo, 0.0
self.grid.SetCellValue(row, 1, FreqFormatter(vfo))
self.grid.SetCellAlignment(row, 1, wx.ALIGN_RIGHT, wx.ALIGN_CENTER)
col = 2
for tune, ampl, phase in tunes:
if self.grid.GetNumberCols() <= col:
self.grid.AppendCols()
self.grid.SetColLabelValue(col, "Tune")
self.grid.SetCellValue(row, col, FreqFormatter(tune))
self.grid.SetCellAlignment(row, col, wx.ALIGN_RIGHT, wx.ALIGN_CENTER)
self.cell_dict[(row, col)] = tune, ampl, phase
if (vfo, tune) == self.new_cell:
self.grid.GoToCell(row, col)
col += 1
row += 1
self.new_cell = None
self.grid.ForceRefresh()
def SetNewCellText(self):
vfo = FreqFormatter(application.VFO)
self.add_cell_text.SetLabel("Band %s, Center (VFO) %s, Tune %d, Gain %5.3f, Phase %5.3f\u00B0" % (
application.lastBand, vfo, self.new_tune, self.new_amplitude + 1.0, self.new_phase))
def SlowHeartBeat(self):
if self.manual:
self.new_tune = application.txFreq
else:
self.new_tune, gain, phase = QS.softrock_corrections(2)
ampl = gain - 1.0
self.new_amplitude = ampl
phase *= 57.2958
self.new_phase = phase
self.PosAmpl(ampl)
self.PosPhase(phase)
self.SetNewCellText()
def OnGridSelectCell(self, event=None):
self.grid.SetCellBackgroundColour(self.selected_row, self.selected_col, self.cell_bg_color)
if event:
event.Skip()
row = self.selected_row = event.GetRow()
col = self.selected_col = event.GetCol()
else:
row = self.selected_row
col = self.selected_col
self.grid.SetCellBackgroundColour(row, col, '#FEA')
self.grid.ForceRefresh()
band, vfo, z = self.cell_dict.get((row, 0), ('', None, 0))
tune, am, ph = self.cell_dict.get((row, col), (None, None, None))
if not band or vfo is None:
self.cell_amph.SetLabel("Cell is empty")
elif col == 0:
self.cell_amph.SetLabel("Band %s" % band)
elif col == 1:
self.cell_amph.SetLabel("Center (VFO) frequency %s" % FreqFormatter(vfo))
elif tune is None:
self.cell_amph.SetLabel("Cell is empty")
else:
self.cell_amph.SetLabel("Cell frequency %s, gain %.3f, phase %.3f\u00B0" % (FreqFormatter(vfo + tune), am + 1.0, ph))
def PosAmpl(self, ampl): # set pos1, pos2 for amplitude
pos2 = round(ampl / self.ampl_scale)
remain = ampl - pos2 * self.ampl_scale
pos1 = round(remain / self.ampl_scale * 50.0)
self.ampl1.SetValue(pos1)
self.ampl2.SetValue(pos2)
def PosPhase(self, phase): # set pos1, pos2 for phase
pos2 = round(phase / self.phase_scale)
remain = phase - pos2 * self.phase_scale
pos1 = round(remain / self.phase_scale * 50.0)
self.phas1.SetValue(pos1)
self.phas2.SetValue(pos2)
def OnAmpl2(self, event): # re-center the fine slider when the coarse slider is adjusted
ampl = self.ampl_scale * self.ampl1.GetValue() / 50.0 + self.ampl_scale * self.ampl2.GetValue()
self.PosAmpl(ampl)
self.OnAmpl1(event)
def OnAmpl1(self, event):
ampl = self.ampl_scale * self.ampl1.GetValue() / 50.0 + self.ampl_scale * self.ampl2.GetValue()
self.new_amplitude = ampl
self.SetNewCellText()
QS.set_ampl_phase(self.new_amplitude, self.new_phase, self.is_tx)
def OnPhase2(self, event): # re-center the fine slider when the coarse slider is adjusted
phase = self.phase_scale * self.phas1.GetValue() / 50.0 + self.phase_scale * self.phas2.GetValue()
self.PosPhase(phase)
self.OnPhase1(event)
def OnPhase1(self, event):
phase = self.phase_scale * self.phas1.GetValue() / 50.0 + self.phase_scale * self.phas2.GetValue()
self.new_phase = phase
self.SetNewCellText()
QS.set_ampl_phase(self.new_amplitude, self.new_phase, self.is_tx)
def OnBtnAddCell(self, event):
band = application.lastBand
vfo = application.VFO
self.new_cell = (vfo, self.new_tune)
ampl = self.new_amplitude
phase = self.new_phase
tune = self.new_tune
if band not in self.bandAmplPhase:
self.bandAmplPhase[band] = {}
if self.rx_tx not in self.bandAmplPhase[band]:
self.bandAmplPhase[band][self.rx_tx] = []
vfos_tunes = self.bandAmplPhase[band][self.rx_tx]
for i in range(0, len(vfos_tunes)):
vfo_tunes = vfos_tunes[i]
if vfo_tunes[0] == vfo:
tunes = vfo_tunes[1]
for j in range(0, len(tunes)):
if tunes[j][0] == tune:
tunes[j] = [tune, ampl, phase]
break
else:
tunes.append([tune, ampl, phase])
tunes.sort()
self.dirty = True
self.Redraw()
return
vfos_tunes.append([vfo, [[tune, ampl, phase]]])
vfos_tunes = vfos_tunes.sort()
self.dirty = True
self.Redraw()
self.grid.ClearSelection()
def OnBtnDestroy(self, event):
# Create a list of cells to be deleted
col_row = []
# print("Rows", self.grid.GetSelectedRows())
# print("Cols", self.grid.GetSelectedCols())
# print("Cells", self.grid.GetSelectedCells())
# print("Left", self.grid.GetSelectionBlockTopLeft())
# print("Right", self.grid.GetSelectionBlockBottomRight())
#
# delete the cell at the grid cursor
row = self.grid.GetGridCursorRow()
col = self.grid.GetGridCursorCol()
cr = col, row
if cr not in col_row:
col_row.append(cr)
#rows = self.grid.GetSelectedRows() # Not used
# delete whole columns
cols = self.grid.GetSelectedCols()
for col in cols:
for row in range(0, self.grid.GetNumberRows()):
cr = col, row
if cr not in col_row:
col_row.append(cr)
# delete cells
cells = self.grid.GetSelectedCells()
for cell in cells:
row, col = cell.Get()
cr = col, row
if cr not in col_row:
col_row.append(cr)
# delete blocks
top_left_list = self.grid.GetSelectionBlockTopLeft()
bottom_right_list = self.grid.GetSelectionBlockBottomRight()
for i in range(len(top_left_list)):
row1, col1 = top_left_list[i].Get()
row2, col2 = bottom_right_list[i].Get()
for row in range(row1, row2 + 1):
for col in range(col1, col2 + 1):
cr = col, row
if cr not in col_row:
col_row.append(cr)
col_row.sort(reverse=True)
changed = False
for col, row in col_row:
try:
band, vfo, z = self.cell_dict[(row, 0)]
vfos_tunes = self.bandAmplPhase[band][self.rx_tx]
except:
continue
if col in (0, 1): # Destroy row
for i in range(0, len(vfos_tunes)):
if vfos_tunes[i][0] == vfo:
del vfos_tunes[i]
changed = True
break
else: # Destroy cell
try:
tune, am, ph = self.cell_dict[(row, col)]
except:
continue
for i in range(0, len(vfos_tunes)):
if vfos_tunes[i][0] != vfo:
continue
tunes = vfos_tunes[i][1]
for j in range(0, len(tunes)):
if tunes[j][0] == tune:
del tunes[j]
changed = True
break
if changed:
self.dirty = True
self.Redraw()
self.selected_row = self.grid.GetGridCursorRow()
self.selected_col = self.grid.GetGridCursorCol()
self.OnGridSelectCell()
self.grid.ClearSelection()
def OnBtnManMeasure(self, event):
self.manual = event.GetEventObject().GetLabel()[0:3] == "Man"
self.ampl1.Enable(self.manual)
self.ampl2.Enable(self.manual)
self.phas1.Enable(self.manual)
self.phas2.Enable(self.manual)
if self.manual:
QS.softrock_corrections(1)
QS.set_ampl_phase(self.new_amplitude, self.new_phase, self.is_tx)
else:
QS.softrock_corrections(2)
QS.set_ampl_phase(0.0, 0.0, self.is_tx)
def OnBtnSave(self, event):
application.bandAmplPhase = copy.deepcopy(self.bandAmplPhase)
self.dirty = False
def OnBtnExit(self, event):
#self.OnGraphData(None)
if self.dirty:
dlg = wx.MessageDialog(self,
"Your changes are not saved. Do you want to save them?", "Changes Were Made",
wx.OK|wx.CANCEL|wx.CANCEL_DEFAULT|wx.ICON_WARNING)
dlg.SetOKLabel("Discard Changes")
ret = dlg.ShowModal()
dlg.Destroy()
if ret == wx.ID_CANCEL:
return
QS.softrock_corrections(0)
ampl, phase = application.GetAmplPhase(self.rx_tx)
QS.set_ampl_phase(ampl, phase, self.is_tx)
application.w_phase = None
self.Destroy()
def OnBtnHelp(self, event=None):
dlg = wx.MessageDialog(self,
'For manual adjustment attach a signal generator or look at a strong signal in the band. Set the Quisk frequency to the signal frequency. \
Adjust the amplitude and phase sliders to minimize the image. To save the adjustment, press Add Cell. \
For automatic measurement, attach a signal generator and choose some frequencies. Press Add Cell for each one. \
Adjustments must be made for both receive and transmit on each band. \
No changes are made to the table of adjustments until you press Save. \
The maximum slider adjustment range can be changed on the radio Hardware screen. \
For more information, press the main "Help" button, then "Documentation", then "SoftRock".'
, "Adjustment Help", style=wx.OK)
dlg.ShowModal()
def OnGraphData(self, event):
if not hasattr(self, "VFO"):
self.VFO = []
self.Tune = []
self.Gain = []
self.Phase = []
if event:
self.VFO.append(application.VFO)
self.Tune.append(self.new_tune)
self.Gain.append(self.new_amplitude + 1.0)
self.Phase.append(self.new_phase)
else:
for name in ("VFO", "Tune", "Gain", "Phase"):
print ("%s = [" % name)
lst = getattr(self, name)
for i in range(0, len(lst)):
if name[0] in "VT":
print("%d," % lst[i])
else:
print("%.5f," % lst[i])
print ("]")
class ListEditDialog(wx.Dialog): # Display a dialog with a List-Edit control, plus Ok/Cancel
def __init__(self, parent, title, choice, choices, width):
wx.Dialog.__init__(self, parent, title=title, style=wx.CAPTION|wx.CLOSE_BOX)
cancel = wx.Button(self, wx.ID_CANCEL, "Cancel")
bsize = cancel.GetSize()
margin = bsize.height
self.combo = wx.ComboBox(self, -1, choice, pos=(margin, margin), size=(width - margin * 2, -1), choices=choices, style=wx.CB_DROPDOWN)
y = margin + self.combo.GetSize().height + margin
x = width - margin * 2 - bsize.width * 2
x = x // 3
ok = wx.Button(self, wx.ID_OK, "OK", pos=(margin + x, y))
cancel.SetPosition((width - margin - x - bsize.width, y))
self.SetClientSize(wx.Size(width, y + bsize.height * 14 // 10))
def GetValue(self):
return self.combo.GetValue()
class RadioNotebook(wx.Notebook): # The second-level notebook for each radio name
def __init__(self, parent, radio_name):
wx.Notebook.__init__(self, parent)
font = wx.Font(conf.config_font_size, wx.FONTFAMILY_SWISS, wx.NORMAL,
wx.FONTWEIGHT_NORMAL, False, conf.quisk_typeface)
self.SetFont(font)
self.SetBackgroundColour(parent.bg_color)
self.radio_name = radio_name
self.pages = []
self.Bind(wx.EVT_NOTEBOOK_PAGE_CHANGED, self.OnPageChanging)
def MakePages(self):
radio_name = self.radio_name
radio_dict = local_conf.GetRadioDict(radio_name)
radio_type = radio_dict['hardware_file_type']
if radio_type == 'SoapySDR':
page = RadioHardwareSoapySDR(self, radio_name)
else:
page = RadioHardware(self, radio_name)
self.AddPage(page, "Hardware")
self.pages.append(page)
page = RadioSound(self, radio_name)
self.AddPage(page, "Sound")
self.pages.append(page)
for section, names in local_conf.sections:
if section == 'Sound': # There is a special page for these sections
continue
if section == 'Bands':
continue
if section == 'Filters':
continue
if section == 'Remote':
page = RadioRemote(self, radio_name, section, names)
self.AddPage(page, section)
self.pages.append(page)
continue
page = RadioSection(self, radio_name, section, names)
self.AddPage(page, section)
self.pages.append(page)
page = RadioBands(self, radio_name)
self.AddPage(page, "Bands")
self.pages.append(page)
#if "use_rx_udp" in radio_dict and radio_dict["use_rx_udp"] == '10':
# page = RadioFilters(self, radio_name)
# self.AddPage(page, "Filters")
# self.pages.append(page)
def NewName(self, new_name):
self.radio_name = new_name
for page in self.pages:
page.radio_name = new_name
def OnPageChanging(self, event):
global wxpython_gtk3_bug
event.Skip()
index = event.GetSelection()
page = self.GetPage(index)
if sys.platform != 'win32': # Work around a bug in wxPython 4.2.1 and gtk3
w, h = application.main_frame.GetSize() # Change main window size by +/- one pixel to recalculate sizes
if wxpython_gtk3_bug:
wxpython_gtk3_bug = 0
h += 1
else:
wxpython_gtk3_bug = 1
h -= 1
application.main_frame.SetSize((w, h))
class ChoiceCombo(wx.Choice):
text_for_blank = "-blank-"
def __init__(self, parent, value, choices):
wx.Choice.__init__(self, parent, choices=choices)
self.choices = choices[:]
self.handler = None
try:
index = self.choices.index(value)
except:
index = 0
self.Bind(wx.EVT_CHOICE, self.OnChoice)
self._ChangeItems(index)
def _ChangeItems(self, index):
length = len(self.choices)
if length <= 0:
self.Enable(False)
elif length == 1:
wx.Choice.SetSelection(self, 0)
self.Enable(False)
else:
wx.Choice.SetSelection(self, index)
self.Enable(True)
self._ReplaceBlank()
self.GetValue()
def _ReplaceBlank(self):
try:
n = self.choices.index('')
except:
pass
else:
self.SetString(n, self.text_for_blank)
def SetItems(self, lst):
wx.Choice.SetItems(self, lst)
self.choices = lst[:]
self._ChangeItems(0)
def SetSelection(self, n):
if 0 <= n < len(self.choices):
wx.Choice.SetSelection(self, n)
self.GetValue()
def SetText(self, text):
try:
n = self.choices.index(text)
except:
print("Failed to set choice list to", text)
else:
wx.Choice.SetSelection(self, n)
self.GetValue()
def GetValue(self):
n = self.GetSelection()
if n == wx.NOT_FOUND:
self.value = ''
else:
self.value = self.GetString(n)
if self.value == self.text_for_blank:
self.value = ''
return self.value
def OnChoice(self, event):
event.Skip()
old = self.value
self.GetValue()
if self.value != old:
if self.handler:
self.handler(self)
class ComboCtrl(wxcombo.ComboCtrl):
def __init__(self, parent, value, choices, no_edit=False):
self.value = value
self.choices = choices[:]
self.handler = None
self.dirty = False
try:
self.bgColor = wx.SystemSettings.GetColour(wx.SYS_COLOUR_LISTBOX)
except:
self.bgColor = wx.Colour('#f6f5f4')
if no_edit:
wxcombo.ComboCtrl.__init__(self, parent, -1, style=wx.CB_READONLY)
else:
wxcombo.ComboCtrl.__init__(self, parent, -1, style=wx.TE_PROCESS_ENTER)
self.Bind(wx.EVT_KILL_FOCUS, self.OnKillFocus)
self.Bind(wx.EVT_TEXT, self.OnText)
self.Bind(wx.EVT_TEXT_ENTER, self.OnTextEnter)
try:
self.height = parent.quisk_height
except:
self.chary = self.GetCharHeight()
self.height = self.chary * 14 // 10
self.SetBackgroundColour(self.bgColor)
self.Refresh()
try:
font = parent.font
except:
font = self.GetFont()
self.ctrl = ListBoxComboPopup(choices, font)
self.SetPopupControl(self.ctrl)
self.SetText(value)
self.SetSizes()
self.Bind(wx.EVT_COMBOBOX_CLOSEUP, self.OnCloseup)
def SetItems(self, lst):
self.ctrl.SetItems(lst)
self.choices = lst[:]
self.SetSizes()
def SetSizes(self):
charx = self.GetCharWidth()
wm = charx
w, h = self.GetTextExtent(self.value)
if wm < w:
wm = w
for ch in self.choices:
w, h = self.GetTextExtent(ch)
if wm < w:
wm = w
wm += charx * 5
self.SetSizeHints(wm, self.height, 9999, self.height)
def SetValue(self, value):
wxcombo.ComboCtrl.SetValue(self, value)
self.SetBackgroundColour(self.bgColor)
self.Refresh()
def SetSelection(self, n): # Set text to item in list box. Name conflict with wxcombo.ComboCtrl.
self.SetBackgroundColour(self.bgColor)
self.Refresh()
try:
text = self.choices[n]
except IndexError:
self.SetText('')
self.value = ''
else:
self.ctrl.SetSelection(n)
self.SetText(text)
self.value = text
def OnText(self, event):
self.dirty = True
self.SetBackgroundColour('#e0e0ff')
self.Refresh()
def OnTextEnter(self, event=None):
self.SetBackgroundColour(self.bgColor)
self.Refresh()
self.dirty = False
if event:
event.Skip()
new = self.GetValue()
if self.value != new:
self.value = new
if self.handler:
self.handler(self)
def OnKillFocus(self, event):
event.Skip()
if self.dirty:
self.OnTextEnter(None)
def OnListbox(self):
self.Dismiss()
self.OnTextEnter()
def OnButtonClick(self):
wxcombo.ComboCtrl.OnButtonClick(self)
wxcombo.ComboCtrl.SetSelection(self, 0, 0)
wxcombo.ComboCtrl.SetInsertionPointEnd(self)
def OnCloseup(self, event):
event.Skip()
wxcombo.ComboCtrl.SetSelection(self, 0, 0)
wxcombo.ComboCtrl.SetInsertionPointEnd(self)
class ListBoxComboPopup(wxcombo.ComboPopup):
text_for_blank = "-blank-"
def __init__(self, choices, font):
wxcombo.ComboPopup.__init__(self)
self.choices = choices
self.font = font
self.lbox = None
self.index = None
def Create(self, parent):
self.lbox = wx.ListBox(parent, choices=self.choices, style=wx.LB_SINGLE|wx.LB_NEEDED_SB)
self.lbox.SetFont(self.font)
self.lbox.Bind(wx.EVT_MOTION, self.OnMotion)
self.lbox.Bind(wx.EVT_LEFT_DOWN, self.OnLeftDown)
self._ReplaceBlank()
return True
def SetItems(self, lst):
self.choices = lst[:]
self.lbox.Set(self.choices)
self._ReplaceBlank()
def _ReplaceBlank(self):
try:
n = self.choices.index('')
except:
pass
else:
self.lbox.SetString(n, self.text_for_blank)
def SetSelection(self, n):
self.lbox.SetSelection(n)
def GetStringValue(self):
try:
text = self.choices[self.lbox.GetSelection()]
except IndexError:
text = ''
else:
if text == self.text_for_blank:
text = ''
return text
def GetAdjustedSize(self, minWidth, prefHeight, maxHeight):
chary = self.lbox.GetCharHeight()
height = chary * len(self.choices) * 15 // 10 + chary
if height > prefHeight:
height = prefHeight
return (minWidth, height)
def OnLeftDown(self, event):
event.Skip()
self.index = self.lbox.GetSelection() # index of selected item
if wxVersion in ('2', '3'):
self.GetCombo().OnListbox()
else:
self.GetComboCtrl().OnListbox()
def OnMotion(self, event):
event.Skip()
item = self.lbox.HitTest(event.GetPosition())
if item >= 0:
self.lbox.SetSelection(item)
def GetControl(self):
return self.lbox
class QuiskTextCtrl(wx.TextCtrl):
def __init__(self, parent, text, style):
wx.TextCtrl.__init__(self, parent, -1, text, style=style)
self.dirty = False
self.bgColor = wx.Colour('#f6f5f4')
#self.Bind(wx.EVT_KILL_FOCUS, self.OnKillFocus)
if not (style & wx.TE_READONLY):
self.Bind(wx.EVT_TEXT, self.OnText)
self.Bind(wx.EVT_TEXT_ENTER, self.OnTextEnter)
def SetValue(self, value):
wx.TextCtrl.SetValue(self, value)
self.SetBackgroundColour(self.bgColor)
self.Refresh()
self.dirty = False
def OnText(self, event):
event.Skip()
self.dirty = True
self.SetBackgroundColour('#e0e0ff')
self.Refresh()
def OnTextEnter(self, event=None):
if event:
event.Skip()
self.SetBackgroundColour(self.bgColor)
self.Refresh()
self.dirty = False
#def OnKillFocus(self, event):
# event.Skip()
# if self.dirty:
# self.OnTextEnter(None)
class QuiskControl(wx.Control):
def __init__(self, parent, text, height, pos=wx.DefaultPosition, style=0):
wx.Control.__init__(self, parent, -1, pos=pos, style=style)
self.text = text
self.handler = None
self.value = ''
if wxVersion in ('2', '3'):
self.SetBackgroundStyle(wx.BG_STYLE_CUSTOM)
else:
self.SetBackgroundStyle(wx.BG_STYLE_PAINT)
from quisk_widgets import button_font
self.SetFont(button_font)
w, h = self.GetTextExtent(text)
self.SetSizeHints(w + height * 3, height, 999, height)
self.bg_brush = wx.Brush('#dcdcdc')
self.black_brush = wx.Brush(wx.Colour(0x000000))
self.text_color = wx.Colour(0x000000)
self.black_pen = wx.Pen(self.text_color)
self.no_pen = wx.Pen(self.text_color, style=wx.PENSTYLE_TRANSPARENT)
self.Bind(wx.EVT_PAINT, self.OnPaint)
self.Bind(wx.EVT_LEFT_DOWN, self.OnLeftDown)
self.MakeMenu()
def OnPaint(self, event):
dc = wx.AutoBufferedPaintDC(self)
dc.SetBackground(self.bg_brush)
dc.SetTextForeground(self.text_color)
dc.Clear()
self._Glyph1(dc)
def _Glyph1(self, dc):
win_w, win_h = self.GetClientSize()
x = win_w - win_h
l = win_h * 20 // 100
if l < 3:
l = 3
y = win_h // 2 - 2
pen = wx.Pen('#555555', 1)
dc.SetPen(pen)
points = [(0, 0), (l, l), (l + 1, l), (l * 2 + 2, -1)]
dc.DrawLines(points, x, y)
pen = wx.Pen('#888888', 1)
dc.SetPen(pen)
points = [(1, 0), (l, l - 1), (l + 1, l - 1), (l * 2 + 1, -1)]
dc.DrawLines(points, x, y)
w, h = dc.GetTextExtent(self.text)
x = (win_w - win_h - w) // 2
if x < 0:
x = 0
y = (win_h - h) // 2
if y < 0:
y = 0
dc.DrawText(self.text, x, y)
def _Glyph2(self, dc): # Not used
dc.SetBrush(self.black_brush)
win_w, win_h = self.GetClientSize()
spacing = 2
rect_h = (win_h - spacing * 4) // 3
if rect_h % 2 == 0: # Make rect_h an odd number
rect_h -= 1
spacing = (win_h - rect_h * 3) // 4
width = rect_h * 25 // 10
x0 = win_w - (rect_h + 2 + width + 3)
y0 = (win_h - rect_h * 3 - spacing * 2) // 2
x = (x0 - dc.GetCharWidth()) // 2
y = (win_h - dc.GetCharHeight()) // 2
dc.DrawText(u"\u2BA9", x, y)
for y in range(3):
dc.SetPen(self.no_pen)
dc.DrawRectangle(x0, y0, rect_h, rect_h)
x = x0 + rect_h + 2
y = y0 + rect_h // 2
dc.SetPen(self.black_pen)
dc.DrawLine(x, y, x + width, y)
y0 += rect_h + spacing
def MakeMenu(self):
self.menu = wx.Menu()
def OnLeftDown(self, event):
pos = wx.Point(0, 0)
self.PopupMenu(self.menu, pos)
class MidiButton(QuiskControl):
def __init__(self, parent, text, height, pos=wx.DefaultPosition, style=0):
QuiskControl.__init__(self, parent, text, height, pos, style)
def MakeMenu(self):
main_names = []
bands = wx.Menu()
filters = wx.Menu()
modes = wx.Menu()
screens = wx.Menu()
for idName in application.idName2Button:
if not idName:
item = None
elif idName in conf.BandList or idName in ("Audio", "Time"):
item = bands.Append(-1, idName)
elif idName[0:7] == 'Filter ':
item = filters.Append(-1, idName)
elif idName in ("CW U/L", "CWL", "CWU", "SSB U/L", "LSB", "USB", "AM", "FM", "DGT",
"DGT-U", "DGT-L", "DGT-FM", "DGT-IQ", "FDV", "FDV-U", "IMD", ):
item = modes.Append(-1, idName)
elif idName in ("Graph", "GraphP1", "GraphP2", "WFall", "Scope", "Config", "Audio FFT", "Bscope", "RX Filter", "Help"):
item = screens.Append(-1, idName)
else:
item = None
main_names.append(idName)
if item:
self.Bind(wx.EVT_MENU, self.OnMenu, item)
main_names.sort()
self.menu = wx.Menu()
main1 = wx.Menu()
main2 = wx.Menu()
for name in main_names:
if name[0].upper() in "ABCDEFGHIJKLMN":
item = main1.Append(-1, name)
else:
item = main2.Append(-1, name)
self.Bind(wx.EVT_MENU, self.OnMenu, item)
self.menu.AppendSubMenu(main1, "Button A-N")
self.menu.AppendSubMenu(main2, "Button O-Z")
item = self.menu.AppendSubMenu(bands, "Bands")
if bands.GetMenuItemCount() <= 0:
self.menu.Enable(item.GetId(), False)
item = self.menu.AppendSubMenu(filters, "Filters")
if filters.GetMenuItemCount() <= 0:
self.menu.Enable(item.GetId(), False)
item = self.menu.AppendSubMenu(modes, "Modes")
if modes.GetMenuItemCount() <= 0:
self.menu.Enable(item.GetId(), False)
item = self.menu.AppendSubMenu(screens, "Screens")
if screens.GetMenuItemCount() <= 0:
self.menu.Enable(item.GetId(), False)
def OnMenu(self, event):
self.value = self.menu.GetLabel(event.GetId())
if self.handler:
self.handler(self)
class MidiKnob(QuiskControl):
def __init__(self, parent, text, height, pos=wx.DefaultPosition, style=0):
QuiskControl.__init__(self, parent, text, height, pos, style)
def MakeMenu(self):
self.menu = wx.Menu()
for name in application.midiControls:
ctrl, func = application.midiControls[name]
if name != "Tune" and (not ctrl or not func):
continue
item = self.menu.Append(-1, name)
self.Bind(wx.EVT_MENU, self.OnMenu, item)
def OnMenu(self, event):
self.value = self.menu.GetLabel(event.GetId())
if self.handler:
self.handler(self)
class MidiJogWheel(QuiskControl):
def __init__(self, parent, text, height, pos=wx.DefaultPosition, style=0):
self.jog_direction = "+"
self.jog_speed = "5"
self.MakeText()
QuiskControl.__init__(self, parent, self.text, height, pos, style)
def MakeText(self):
self.text = "Jog Wheel %s%s" % (self.jog_direction, self.jog_speed)
def MakeMenu(self):
self.menu = wx.Menu()
self.direc_menu = wx.Menu()
item = self.direc_menu.AppendRadioItem(-1, "Move +")
self.Bind(wx.EVT_MENU, self.OnDirecMenu, item)
item = self.direc_menu.AppendRadioItem(-1, "Move -")
self.Bind(wx.EVT_MENU, self.OnDirecMenu, item)
self.menu.AppendSubMenu(self.direc_menu, "Direction")
self.speed_menu = wx.Menu()
for i in range(10):
item = self.speed_menu.AppendRadioItem(-1, "Speed %d" % i)
self.Bind(wx.EVT_MENU, self.OnSpeedMenu, item)
if i == 5:
item.Check()
self.menu.AppendSubMenu(self.speed_menu, "Speed")
controls = wx.Menu()
for name in application.midiControls:
ctrl, func = application.midiControls[name]
if name != "Tune" and (not ctrl or not func):
continue
item = controls.Append(-1, name)
self.Bind(wx.EVT_MENU, self.OnMenu, item)
self.menu.AppendSubMenu(controls, "Name")
def OnMenu(self, event):
value = self.menu.GetLabel(event.GetId())
self.value = "%s %s%s" % (value, self.jog_direction, self.jog_speed)
if self.handler:
self.handler(self)
def OnDirecMenu(self, event):
value = self.menu.GetLabel(event.GetId())
self.jog_direction = value[-1]
self.MakeText()
self.Refresh()
if self.handler:
self.handler(self, "%s%s" % (self.jog_direction, self.jog_speed))
def OnSpeedMenu(self, event):
value = self.menu.GetLabel(event.GetId())
self.jog_speed = value[-1]
self.MakeText()
self.Refresh()
if self.handler:
self.handler(self, "%s%s" % (self.jog_direction, self.jog_speed))
def ChangeSelection(self, text):
self.jog_direction = text[0]
self.jog_speed = text[1]
self.MakeText()
self.Refresh()
if self.jog_direction == '+':
self.direc_menu.FindItemByPosition(0).Check()
else:
self.direc_menu.FindItemByPosition(1).Check()
index = int(self.jog_speed)
self.speed_menu.FindItemByPosition(index).Check()
class ControlMixin:
def __init__(self, parent):
self.font = wx.Font(conf.config_font_size, wx.FONTFAMILY_SWISS, wx.NORMAL,
wx.FONTWEIGHT_NORMAL, False, conf.quisk_typeface)
self.SetFont(self.font)
self.row = 1
self.charx = self.GetCharWidth()
self.chary = self.GetCharHeight()
self.quisk_height = self.chary * 14 // 10
# GBS
self.gbs = wx.GridBagSizer(2, 2)
self.gbs.SetEmptyCellSize((self.charx, self.charx))
self.SetSizer(self.gbs)
self.gbs.Add((self.charx, self.charx), (0, 0))
def MarkCols(self):
for col in range(1, self.num_cols):
c = wx.StaticText(self, -1, str(col % 10))
self.gbs.Add(c, (self.row, col))
self.row += 1
def NextRow(self, row=None):
if row is None:
self.row += 1
else:
self.row = row
def AddHelpButton(self, col, text, help_text, border=1):
hbtn = QuiskPushbutton(self, self._BTnHelp, "..")
hbtn.SetColorGray()
hbtn.quisk_help_text = help_text
hbtn.quisk_caption = text
h = self.quisk_height + 2
hbtn.SetSizeHints(h, h, h, h)
self.gbs.Add(hbtn, (self.row, col), flag=wx.ALIGN_CENTER_VERTICAL|wx.RIGHT, border=self.charx*border)
def AddTextL(self, col, text, span=None):
c = wx.StaticText(self, -1, text)
if col < 0:
pass
elif span is None:
self.gbs.Add(c, (self.row, col), flag=wx.ALIGN_CENTER_VERTICAL)
else:
self.gbs.Add(c, (self.row, col), span=(1, span), flag=wx.ALIGN_CENTER_VERTICAL)
return c
def AddTextC(self, col, text, span=None, flag=wx.ALIGN_CENTER):
c = wx.StaticText(self, -1, text)
if col < 0:
pass
elif span is None:
self.gbs.Add(c, (self.row, col), flag=flag)
else:
self.gbs.Add(c, (self.row, col), span=(1, span), flag=flag)
return c
def AddTextCHelp(self, col, text, help_text, span=None):
bsizer = wx.BoxSizer(wx.HORIZONTAL)
txt = wx.StaticText(self, -1, text)
bsizer.Add(txt, flag=wx.ALIGN_CENTER_VERTICAL)
btn = QuiskPushbutton(self, self._BTnHelp, "..")
btn.SetColorGray()
btn.quisk_help_text = help_text
btn.quisk_caption = text
h = self.quisk_height + 2
btn.SetSizeHints(h, h, h, h)
bsizer.Add(btn, flag=wx.ALIGN_CENTER_VERTICAL|wx.LEFT|wx.RIGHT, border=self.charx)
if col < 0:
pass
elif span is None:
self.gbs.Add(bsizer, (self.row, col), flag = wx.ALIGN_CENTER)
else:
self.gbs.Add(bsizer, (self.row, col), span=(1, span), flag = wx.ALIGN_CENTER)
return bsizer
def AddTextLHelp(self, col, text, help_text, span=None):
bsizer = wx.BoxSizer(wx.HORIZONTAL)
btn = QuiskPushbutton(self, self._BTnHelp, "..")
btn.SetColorGray()
btn.quisk_help_text = help_text
btn.quisk_caption = text
h = self.quisk_height + 2
btn.SetSizeHints(h, h, h, h)
bsizer.Add(btn, flag=wx.ALIGN_CENTER_VERTICAL|wx.LEFT|wx.RIGHT, border=self.charx)
txt = wx.StaticText(self, -1, text)
bsizer.Add(txt, flag=wx.ALIGN_CENTER_VERTICAL)
if col < 0:
pass
elif span is None:
self.gbs.Add(bsizer, (self.row, col), flag = 0)
else:
self.gbs.Add(bsizer, (self.row, col), span=(1, span), flag = 0)
return bsizer
def AddTextColorChangeHelp(self, col, text, color, btn_text, handler, help_text, border=2, span1=1, span2=1, span3=1):
txt = wx.StaticText(self, -1, text)
self.gbs.Add(txt, (self.row, col), span=(1, span1), flag=wx.ALIGN_CENTER_VERTICAL|wx.RIGHT, border=self.charx)
col += span1
Cbar = wx.StaticText(self, -1, '')
h = self.quisk_height - 2
Cbar.SetSizeHints(h, h, -1, h)
if color:
Cbar.SetBackgroundColour(color)
self.gbs.Add(Cbar, (self.row, col), span=(1, span2),
flag=wx.ALIGN_CENTER_VERTICAL|wx.EXPAND|wx.RIGHT,
border=self.charx*2//10)
col += span2
btn = QuiskPushbutton(self, handler, btn_text)
btn.SetColorGray()
h = self.quisk_height + 2
btn.SetSizeHints(-1, h, -1, h)
self.gbs.Add(btn, (self.row, col), span=(1, span3), flag = wx.EXPAND)
col += span3
hbtn = QuiskPushbutton(self, self._BTnHelp, "..")
hbtn.SetColorGray()
hbtn.quisk_help_text = help_text
hbtn.quisk_caption = text
h = self.quisk_height + 2
hbtn.SetSizeHints(h, h, h, h)
self.gbs.Add(hbtn, (self.row, col), flag=wx.ALIGN_CENTER_VERTICAL|wx.RIGHT, border=self.charx*border)
return txt, Cbar, btn
def AddTextEditHelp(self, col, text1, text2, help_text, border=2, span1=1, span2=1, no_edit=True):
txt = wx.StaticText(self, -1, text1)
self.gbs.Add(txt, (self.row, col), span=(1, span1), flag=wx.ALIGN_CENTER_VERTICAL|wx.RIGHT, border=self.charx)
col += span1
#txt = wx.StaticText(self, -1, text2)
if no_edit:
edt = QuiskTextCtrl(self, text2, style=wx.TE_READONLY)
else:
edt = QuiskTextCtrl(self, text2, style=wx.TE_PROCESS_ENTER)
#self.gbs.Add(txt, (self.row, col), span=(1, span2), flag=wx.ALIGN_CENTER_VERTICAL|wx.RIGHT, border=self.charx)
self.gbs.Add(edt, (self.row, col), span=(1, span2),
flag=wx.ALIGN_CENTER_VERTICAL|wx.EXPAND|wx.RIGHT,
border=self.charx*2//10)
col += span2
btn = QuiskPushbutton(self, self._BTnHelp, "..")
btn.SetColorGray()
btn.quisk_help_text = help_text
btn.quisk_caption = text1
h = self.quisk_height + 2
btn.SetSizeHints(h, h, h, h)
self.gbs.Add(btn, (self.row, col), flag=wx.ALIGN_CENTER_VERTICAL|wx.RIGHT, border=self.charx*border)
return txt, edt, btn
def AddTextSliderHelp(self, col, text, value, themin, themax, handler, help_text, border=2, span=1, scale=1):
display = "%" in text
sld = SliderBoxHH(self, text, value, themin, themax, handler, display, scale)
self.gbs.Add(sld, (self.row, col), span=(1, span),
flag=wx.ALIGN_CENTER_VERTICAL|wx.EXPAND|wx.RIGHT,
border=self.charx*2//10)
col += span
btn = QuiskPushbutton(self, self._BTnHelp, "..")
btn.SetColorGray()
btn.quisk_help_text = help_text
btn.quisk_caption = text
h = self.quisk_height + 2
btn.SetSizeHints(h, h, h, h)
self.gbs.Add(btn, (self.row, col), flag=wx.ALIGN_CENTER_VERTICAL|wx.RIGHT, border=self.charx*border)
return sld, btn
def AddTextHeading(self, key, text, help_text):
if key in text: # Start of heading
self.NextRow()
self.SetFont(self.heading_font)
self.AddTextL(1, help_text, span=7)
self.SetFont(self.font)
self.NextRow()
self.col = 2
return key
return None
def AddPopupMenuHelp(self, Qclass, col, text, btn_text, help_text, span1=1, span2=1, border=1):
if text:
txt = wx.StaticText(self, -1, text)
self.gbs.Add(txt, (self.row, col), span=(1, span1), flag=wx.ALIGN_CENTER_VERTICAL|wx.RIGHT, border=self.charx)
col += span1
ctrl = Qclass(self, btn_text, self.quisk_height - 2, style=wx.BORDER_RAISED)
self.gbs.Add(ctrl, (self.row, col), span=(1, span2), flag = wx.EXPAND|wx.RIGHT|wx.TOP|wx.BOTTOM|wx.LEFT, border=2)
col += span2
self.AddHelpButton(col, text, help_text, border)
return ctrl
def AddTextButtonHelp(self, col, text, butn_text, handler, help_text, span1=1, span2=1, border=1):
if text:
txt = wx.StaticText(self, -1, text)
self.gbs.Add(txt, (self.row, col), span=(1, span1), flag = 0)
col += span1
else:
txt = None
btn = QuiskPushbutton(self, handler, butn_text)
btn.SetColorGray()
h = self.quisk_height + 2
btn.SetSizeHints(-1, h, -1, h)
self.gbs.Add(btn, (self.row, col), span=(1, span2), flag = wx.EXPAND)
col += span2
hbtn = QuiskPushbutton(self, self._BTnHelp, "..")
hbtn.SetColorGray()
hbtn.quisk_help_text = help_text
hbtn.quisk_caption = text
h = self.quisk_height + 2
hbtn.SetSizeHints(h, h, h, h)
self.gbs.Add(hbtn, (self.row, col), flag=wx.ALIGN_CENTER_VERTICAL|wx.RIGHT, border=self.charx*border)
return txt, btn
def AddText2CheckHelp(self, col, text, butn1_text, handler1, butn2_text, handler2, help_text, span1=1, span2=1, border=1):
if text:
txt = wx.StaticText(self, -1, text)
self.gbs.Add(txt, (self.row, col), span=(1, span1), flag = wx.ALIGN_CENTER_VERTICAL | wx.EXPAND)
col += span1
else:
txt = None
btn1 = QuiskCheckbutton(self, handler1, butn1_text)
btn1.SetColorGray()
btn2 = QuiskCheckbutton(self, handler2, butn2_text)
btn2.SetColorGray()
w1 = btn1.GetSize().Width
w2 = btn2.GetSize().Width
w = max(w1, w2)
h = self.quisk_height + 2
btn1.SetSizeHints(w, h, w, h)
btn2.SetSizeHints(w, h, w, h)
bsizer = wx.BoxSizer(wx.HORIZONTAL)
bsizer.Add(btn1, proportion=1)
bsizer.Add(2, h, proportion=0)
bsizer.Add(btn2, proportion=1)
self.gbs.Add(bsizer, (self.row, col), span=(1, span2), flag = wx.EXPAND)
col += span2
hbtn = QuiskPushbutton(self, self._BTnHelp, "..")
hbtn.SetColorGray()
hbtn.quisk_help_text = help_text
hbtn.quisk_caption = text
h = self.quisk_height + 2
hbtn.SetSizeHints(h, h, h, h)
self.gbs.Add(hbtn, (self.row, col), flag=wx.ALIGN_CENTER_VERTICAL|wx.RIGHT, border=self.charx*border)
return txt, btn1, btn2
def AddText2ButtonHelp(self, col, text, butn1_text, handler1, butn2_text, handler2, help_text, span1=1, span2=1, border=1):
if text:
txt = wx.StaticText(self, -1, text)
self.gbs.Add(txt, (self.row, col), span=(1, span1), flag = 0)
col += span1
else:
txt = None
btn1 = QuiskPushbutton(self, handler1, butn1_text)
btn1.SetColorGray()
btn2 = QuiskPushbutton(self, handler2, butn2_text)
btn2.SetColorGray()
w1 = btn1.GetSize().Width
w2 = btn2.GetSize().Width
w = max(w1, w2)
h = self.quisk_height + 2
btn1.SetSizeHints(w, h, 999, h)
btn2.SetSizeHints(w, h, 999, h)
bsizer = wx.BoxSizer(wx.HORIZONTAL)
bsizer.Add(btn1, proportion=1)
bsizer.Add(2, h, proportion=0)
bsizer.Add(btn2, proportion=1)
self.gbs.Add(bsizer, (self.row, col), span=(1, span2), flag = wx.EXPAND)
col += span2
hbtn = QuiskPushbutton(self, self._BTnHelp, "..")
hbtn.SetColorGray()
hbtn.quisk_help_text = help_text
hbtn.quisk_caption = text
h = self.quisk_height + 2
hbtn.SetSizeHints(h, h, h, h)
self.gbs.Add(hbtn, (self.row, col), flag=wx.ALIGN_CENTER_VERTICAL|wx.RIGHT, border=self.charx*border)
return txt, btn1, btn2
def AddTextCtrl(self, col, text, handler=None, span=None):
c = wx.TextCtrl(self, -1, text, style=wx.TE_RIGHT)
if col < 0:
pass
elif span is None:
self.gbs.Add(c, (self.row, col), flag=wx.ALIGN_CENTER)
else:
self.gbs.Add(c, (self.row, col), span=(1, span), flag=wx.ALIGN_CENTER)
if handler:
c.Bind(wx.EVT_TEXT, handler)
return c
def AddBoxSizer(self, col, span):
bsizer = wx.BoxSizer(wx.HORIZONTAL)
self.gbs.Add(bsizer, (self.row, col), span=(1, span))
return bsizer
def AddColSpacer(self, col, width): # add a width spacer to row 0
self.gbs.Add((width * self.charx, 1), (0, col)) # width is in characters
def AddRadioButton(self, col, text, handler=None, span=None, start=False):
if start:
c = wx.RadioButton(self, -1, text, style=wx.RB_GROUP)
else:
c = wx.RadioButton(self, -1, text)
if col < 0:
pass
elif span is None:
self.gbs.Add(c, (self.row, col), flag=wx.ALIGN_CENTER_VERTICAL)
else:
self.gbs.Add(c, (self.row, col), span=(1, span), flag=wx.ALIGN_CENTER_VERTICAL)
if handler:
c.Bind(wx.EVT_RADIOBUTTON, handler)
return c
def AddCheckBox(self, col, text, handler=None, flag=0, border=0):
btn = wx.CheckBox(self, -1, text)
h = self.quisk_height + 2
btn.SetSizeHints(-1, h, -1, h)
if col >= 0:
self.gbs.Add(btn, (self.row, col), flag=flag, border=border*self.charx)
if self.radio_name == "ConfigFileRadio":
btn.Enable(False)
noname_enable.append(btn)
if handler:
btn.Bind(wx.EVT_CHECKBOX, handler)
return btn
def AddBitField(self, col, number, name, band, value, handler=None, span=None, border=1):
bf = QuiskBitField(self, number, value, self.quisk_height, handler)
if col < 0:
pass
elif span is None:
self.gbs.Add(bf, (self.row, col), flag=wx.ALIGN_RIGHT|wx.ALIGN_CENTER_VERTICAL|wx.RIGHT|wx.LEFT, border=border*self.charx)
else:
self.gbs.Add(bf, (self.row, col), span=(1, span), flag=wx.ALIGN_RIGHT|wx.ALIGN_CENTER_VERTICAL|wx.RIGHT|wx.LEFT, border=border*self.charx)
bf.quisk_data_name = name
bf.quisk_band = band
return bf
def AddPushButton(self, col, text, handler, border=0):
btn = QuiskPushbutton(self, handler, text)
btn.SetColorGray()
h = self.quisk_height + 2
btn.SetSizeHints(-1, h, -1, h)
if col >= 0:
self.gbs.Add(btn, (self.row, col), flag=wx.RIGHT|wx.LEFT, border=border*self.charx)
if self.radio_name == "ConfigFileRadio":
btn.Enable(False)
noname_enable.append(btn)
return btn
def AddPushButtonR(self, col, text, handler, border=0):
btn = self.AddPushButton(-1, text, handler, border)
if col >= 0:
self.gbs.Add(btn, (self.row, col), flag=wx.ALIGN_RIGHT|wx.RIGHT|wx.LEFT, border=border*self.charx)
return btn
def AddComboCtrl(self, col, value, choices, right=False, no_edit=False, span=None, border=1):
if no_edit:
cb = ChoiceCombo(self, value, choices)
else:
cb = ComboCtrl(self, value, choices)
if col < 0:
pass
elif span is None:
self.gbs.Add(cb, (self.row, col), flag=wx.ALIGN_CENTER_VERTICAL|wx.EXPAND|wx.RIGHT|wx.LEFT, border=border*self.charx)
else:
self.gbs.Add(cb, (self.row, col), span=(1, span), flag=wx.ALIGN_CENTER_VERTICAL|wx.EXPAND|wx.RIGHT|wx.LEFT, border=border*self.charx)
if self.radio_name == "ConfigFileRadio":
cb.Enable(False)
noname_enable.append(cb)
return cb
def AddComboCtrlTx(self, col, text, value, choices, right=False, no_edit=False):
c = wx.StaticText(self, -1, text)
if col >= 0:
self.gbs.Add(c, (self.row, col))
cb = self.AddComboCtrl(col + 1, value, choices, right, no_edit)
else:
cb = self.AddComboCtrl(col, value, choices, right, no_edit)
return c, cb
def AddTextComboHelp(self, col, text, value, choices, help_text, no_edit=False, border=2, span_text=1, span_combo=1):
txt = wx.StaticText(self, -1, text)
self.gbs.Add(txt, (self.row, col), span=(1, span_text), flag=wx.ALIGN_CENTER_VERTICAL|wx.RIGHT, border=self.charx)
col += span_text
cb = self.AddComboCtrl(-1, value, choices, False, no_edit)
if no_edit:
if '#' in value:
value = value[0:value.index('#')]
value = value.strip()
l = len(value)
for i in range(len(choices)):
ch = choices[i]
if '#' in ch:
ch = ch[0:ch.index('#')]
ch.strip()
if value == ch[0:l]:
cb.SetSelection(i)
break
else:
if 'fail' in value:
pass
else:
print ("Failure to set value for", text, value, choices)
self.gbs.Add(cb, (self.row, col), span=(1, span_combo),
flag=wx.ALIGN_CENTER_VERTICAL|wx.EXPAND|wx.RIGHT, border=self.charx*2//10)
col += span_combo
btn = QuiskPushbutton(self, self._BTnHelp, "..")
btn.SetColorGray()
btn.quisk_help_text = help_text
btn.quisk_caption = text
h = self.quisk_height + 2
btn.SetSizeHints(h, h, h, h)
self.gbs.Add(btn, (self.row, col), flag=wx.ALIGN_CENTER_VERTICAL|wx.RIGHT, border=self.charx*border)
return txt, cb, btn
def AddTextDblSpinnerHelp(self, col, text, value, dmin, dmax, dinc, help_text, border=2, span_text=1, span_spinner=1):
txt = wx.StaticText(self, -1, text)
self.gbs.Add(txt, (self.row, col), span=(1, span_text), flag=wx.ALIGN_CENTER_VERTICAL|wx.RIGHT, border=self.charx)
col += span_text
spn = wx.SpinCtrlDouble(self, -1, initial=value, min=dmin, max=dmax, inc=dinc)
self.gbs.Add(spn, (self.row, col), span=(1, span_spinner),
flag=wx.ALIGN_CENTER_VERTICAL|wx.EXPAND|wx.RIGHT,
border=self.charx*2//10)
col += span_spinner
btn = QuiskPushbutton(self, self._BTnHelp, "..")
btn.SetColorGray()
btn.quisk_help_text = help_text
btn.quisk_caption = text
h = self.quisk_height + 2
btn.SetSizeHints(h, h, h, h)
self.gbs.Add(btn, (self.row, col), flag=wx.ALIGN_CENTER_VERTICAL|wx.RIGHT, border=self.charx*border)
return txt, spn, btn
def AddTextSpinnerHelp(self, col, text, value, imin, imax, help_text, border=2, span_text=1, span_spinner=1):
txt = wx.StaticText(self, -1, text)
self.gbs.Add(txt, (self.row, col), span=(1, span_text), flag=wx.ALIGN_CENTER_VERTICAL|wx.RIGHT, border=self.charx)
col += span_text
spn = wx.SpinCtrl(self, -1, "")
spn.SetRange(imin, imax)
spn.SetValue(value)
self.gbs.Add(spn, (self.row, col), span=(1, span_spinner),
flag=wx.ALIGN_CENTER_VERTICAL|wx.EXPAND|wx.RIGHT,
border=self.charx*2//10)
col += span_spinner
btn = QuiskPushbutton(self, self._BTnHelp, "..")
btn.SetColorGray()
btn.quisk_help_text = help_text
btn.quisk_caption = text
h = self.quisk_height + 2
btn.SetSizeHints(h, h, h, h)
self.gbs.Add(btn, (self.row, col), flag=wx.ALIGN_CENTER_VERTICAL|wx.RIGHT, border=self.charx*border)
return txt, spn, btn
def _BTnHelp(self, event):
btn = event.GetEventObject()
caption = btn.quisk_caption
i = caption.find('%') # remove formats %.2f
if i > 0:
caption = caption[0:i]
dlg = wx.MessageDialog(self, btn.quisk_help_text, caption, style=wx.OK|wx.ICON_INFORMATION)
dlg.ShowModal()
dlg.Destroy()
def ErrorCheck(self, ctrl): # Return True for OK
name = ctrl.quisk_data_name
value = ctrl.GetValue()
#if name == 'quisk_debug_sound' and value in ("New Sound", "Debug New Sound") and not QS.get_params('have_soundio'):
# dlg = wx.MessageDialog(None, "Please install the libsoundio-dev package, and re-make", 'New Sound', wx.OK|wx.ICON_ERROR)
# dlg.ShowModal()
# dlg.Destroy()
# return False
return True
def OnChange(self, ctrl):
value = ctrl.GetValue()
self.OnChange2(ctrl, value)
def OnChange2(self, ctrl, value):
# Careful: value is Unicode
name = ctrl.quisk_data_name
try:
fmt4 = local_conf.format4name[name]
except:
if name[0:4] in ("lin_", "win_"):
fmt4 = local_conf.format4name[name[4:]]
fmt4 = fmt4[0:4]
ok, x = self.EvalItem(value, fmt4) # Only evaluates integer, number, boolean, text, rfile
if ok:
radio_dict = local_conf.GetRadioDict(self.radio_name)
if name in name2format and name2format[name][1] == value:
if name in radio_dict:
del radio_dict[name]
local_conf.settings_changed = True
else:
radio_dict[name] = value
local_conf.settings_changed = True
# Immediate changes
if self.radio_name == Settings[1]: # changed for current radio
if name in ('hot_key_ptt_toggle', 'hot_key_ptt_if_hidden', 'keyupDelay', 'cwTone', 'pulse_audio_verbose_output',
'start_cw_delay', 'start_ssb_delay', 'maximum_tx_secs', 'quisk_serial_cts', 'quisk_serial_dsr',
'hot_key_ptt1', 'hot_key_ptt2', 'midi_ptt_toggle', 'TxRxSilenceMsec',
'fixed_tune_offset', 'calibrate_temp_20', 'calibrate_temp_40', 'calibrate_current_0', 'calibrate_current_1'):
setattr(conf, name, x)
application.ImmediateChange(name)
elif name[0:4] in ('lin_', 'win_'):
name = name[4:]
if name in ('quisk_serial_port', ):
setattr(conf, name, x)
application.ImmediateChange(name)
elif name == "reverse_tx_sideband":
setattr(conf, name, x)
QS.set_tx_audio(reverse_tx_sideband=x)
elif name == "dc_remove_bw":
setattr(conf, name, x)
QS.set_sparams(dc_remove_bw=x)
elif name == "digital_output_level":
setattr(conf, name, x)
QS.set_sparams(digital_output_level=x)
elif name == "file_play_level":
setattr(conf, name, x)
QS.set_sparams(file_play_level=x)
elif name[0:7] == 'hermes_':
if name == 'hermes_TxLNA_dB':
application.Hardware.ChangeTxLNA(x)
elif name == "hermes_bias_adjust" and self.HermesBias0:
self.HermesBias0.Enable(x)
self.HermesBias1.Enable(x)
self.HermesWriteBiasButton.Enable(x)
application.Hardware.EnableBiasChange(x)
elif hasattr(application.Hardware, "ImmediateChange"):
setattr(conf, name, x)
application.Hardware.ImmediateChange(name)
elif name[0:6] == 'keyer_':
setattr(conf, name, x)
application.ImmediateChange(name)
def FormatOK(self, value, fmt4): # Check formats integer, number, boolean
ok, v = self.EvalItem(value, fmt4)
return ok
def EvalItem(self, value, fmt4): # Return Python integer, number, boolean, text, rfile, keycode
# return is (item_is_ok, evaluated_item)
if fmt4 not in ('inte', 'numb', 'bool', 'keyc'): # only certain formats are evaluated
return True, value # text, rfile are returned by default
jj = value.find('#')
if jj > 0:
value = value[0:jj]
try: # only certain formats are evaluated
if fmt4 == 'inte':
v = int(value, base=0)
elif fmt4 == 'numb':
v = float(value)
elif fmt4 == 'bool':
if value == "True":
v = True
else:
v = False
elif fmt4 == 'keyc': # key code
if value == "None":
v = None
else:
v = eval(value)
v = int(v)
else:
raise ValueError
except:
#traceback.print_exc()
dlg = wx.MessageDialog(None,
"Can not set item with format %s to value %s" % (fmt4, value),
'Change to item', wx.OK|wx.ICON_ERROR)
dlg.ShowModal()
dlg.Destroy()
return False, None
return True, v
def GetValue(self, name, radio_dict):
try:
value = radio_dict[name]
except:
pass
else:
return value
# Value was not in radio_dict. Get it from conf. There are values for platform win_data_name and lin_data_name.
# The win_ and lin_ names are not in conf.
try:
fmt = local_conf.format4name[name]
except:
fmt = '' # not all items in conf are in section_data or receiver_data
try:
if fmt == 'dict': # make a copy for this radio
value = {}
value.update(getattr(conf, name))
elif fmt == 'list': # make a copy for this radio
value = getattr(conf, name)[:]
else:
value = str(getattr(conf, name))
except:
return ''
else:
return value
class BaseWindow(wx.ScrolledWindow, ControlMixin):
def __init__(self, parent):
wx.ScrolledWindow.__init__(self, parent)
ControlMixin.__init__(self, parent)
self.SetScrollRate(8, 8)
class ConfigConfig(BaseWindow):
def __init__(self, parent, width):
BaseWindow.__init__(self, parent)
self.width = width
self.SetBackgroundColour(parent.bg_color)
self.num_cols = 7
#self.MarkCols()
self.radio_name = None
# Choice (combo) box for decimation
lst = application.Hardware.VarDecimGetChoices()
if lst:
txt = application.Hardware.VarDecimGetLabel()
index = application.Hardware.VarDecimGetIndex()
else:
txt = "Variable decimation"
lst = ["None"]
index = 0
help_text = "If your hardware supports different sample rates, choose one here. For SoftRock, \
change the sample rate of your sound card."
txt, cb, btn = self.AddTextComboHelp(1, txt, lst[index], lst, help_text, True)
if lst:
cb.handler = application.OnBtnDecimation
self.btn_decimation = cb
self.NextRow()
self.NextRow()
help_text = "SoftRock and other radios that use a sound card for Rx and Tx will need small corrections \
to the amplitude and phase. Click here for an adjustment screen."
txt, btn = self.AddTextButtonHelp(1, "Adjust receive amplitude and phase", "Rx Phase..", self.OnBtnPhase, help_text)
self.rx_phase = btn
if not conf.name_of_sound_capt:
btn.Enable(0)
self.NextRow()
txt, btn = self.AddTextButtonHelp(1, "Adjust transmit amplitude and phase", "Tx Phase..", self.OnBtnPhase, help_text)
self.tx_phase = btn
if not conf.name_of_mic_play:
btn.Enable(0)
self.NextRow()
help_text = "There is a color bar under the X-axis showing the band plan. Click here for a screen to change the colors."
txt, btn = self.AddTextButtonHelp(1, "Colors on X-axis for CW, Phone", "Band plan..", self.OnBtnBandPlan, help_text)
self.NextRow()
help_text = "Click here to configure the link to WSJT-X."
txt, btn = self.AddTextButtonHelp(1, "Configure WSJT-X", "WSJT-X..", self.OnConfigureWsjtx, help_text)
self.NextRow()
lst = ("Never", "Main Rx0 on startup", "Main Rx0 now")
value = application.local_conf.globals.get("start_wsjtx", "Never")
txt, cb, btn = self.AddTextComboHelp(1, "Start WSJT-X", value, lst, help_text, True)
cb.handler = application.OnStartWsjtx
self.NextRow()
help_text = "This controls the Tx level for non-digital modes. It is usually 100%."
c1, btn = self.AddTextSliderHelp(1, "Tx level %d%% ", 100, 0, 100, self.OnTxLevel, help_text, span=2)
self.NextRow()
level = conf.digital_tx_level
help_text = "This controls the TX level for digital modes. Digital modes require greater linearity, and the digital level is often 25%."
c2, btn = self.AddTextSliderHelp(1, "Digital Tx level %d%% ", level, 0, level, self.OnDigitalTxLevel, help_text, span=2)
if not hasattr(application.Hardware, "SetTxLevel"):
c1.slider.Enable(0)
c2.slider.Enable(0)
self.NextRow()
#### Make controls SECOND column
self.row = 3
self.AddTextL(4, "Configuration for the file record button: " + conf.Xbtn_text_file_rec, span=2)
self.NextRow()
# File for recording speaker audio
text = "Record Rx audio to WAV files 1, 2, ... "
path = application.file_name_rec_audio
help_text = 'These check buttons control what happens when you press the "File Record" button. \
Please choose a directory for your recordings; perhaps the "Music" directory on your computer. \
Then choose your file name. This "Record Rx audio" file is used for recording the radio speaker sound. \
Recording stops when the button is released. When pressed again new files are created with names 001, 002, etc. \
You will need to delete recordings you no longer need.'
self.file_button_rec_speaker = self.MakeFileButton(text, path, 0, 'rec_audio', help_text)
# File for recording samples
text = "Record I/Q samples to WAV files 1, 2, ... "
path = application.file_name_rec_samples
help_text = 'This file is used to record the I/Q samples and it works like the "Record Rx audio" button.'
self.file_button_rec_iq = self.MakeFileButton(text, path, 1, 'rec_samples', help_text)
# File for recording the microphone
text = "Record the mic to make a CQ message"
path = application.file_name_rec_mic
help_text = 'This file is used to record the microphone. It can be used to record a CQ message that can be played \
over and over until someone answers. Change the "Play audio" to the same file to test the recording. Keep recording and \
playing until you are satisfied, and then un-check the "Record mic" button. The file is replaced when the Record button \
is pressed again (no 001, 002, ...).'
self.file_button_rec_mic = self.MakeFileButton(text, path, 2, 'rec_mic', help_text)
## Play buttons
self.AddTextL(4, "Configuration for the file play button: " + conf.Xbtn_text_file_play, span=2)
self.NextRow()
# File for playing speaker audio
text = "Play audio from a WAV file"
path = application.file_name_play_audio
help_text = 'These record check buttons control what happens when you press the "File Play" button. \
This button plays normal audio files, not samples.'
self.file_button_play_speaker = self.MakeFileButton(text, path, 10, 'play_audio', help_text)
# file for playing samples
text = "Receive saved I/Q samples from a file"
path = application.file_name_play_samples
help_text = 'This button plays I/Q samples. You can tune in different stations from the I/Q recording.'
self.file_button_play_iq = self.MakeFileButton(text, path, 11, 'play_samples', help_text)
# File for playing a file to the mic input for a CQ message
text = "Repeat a CQ message until a station answers"
path = application.file_name_play_cq
help_text = "This button enables the File Play button to start playing your CQ message."
self.file_button_play_mic = self.MakeFileButton(text, path, 12, 'play_cq', help_text)
# CQ repeat time
help_text = 'This is the amount of time to wait for someone to respond to your CQ message. \
The CW message will then repeat. A time of zero means no repeat.'
sl, btn = self.AddTextSliderHelp(4, " Repeat secs %.1f ", 0, 0, 100, self.OnPlayFileRepeat, help_text, span=2, scale=0.1)
self.NextRow()
self.FitInside()
def MakeFileButton(self, text, path, index, name, help_text):
if index < 10: # record buttons
cb = self.AddCheckBox(4, text, self.OnCheckRecPlay)
elif index == 10:
cb = self.AddRadioButton(4, text, self.OnCheckRecPlay, start=True)
else:
cb = self.AddRadioButton(4, text, self.OnCheckRecPlay, start=False)
txt, b = self.AddTextButtonHelp(5, '', "File..", self.OnBtnFileName, help_text)
b.check_box = cb
b.index = cb.index = index
b.path = cb.path = path
b.name = 'file_name_' + name
if index < 10: # record buttons
if path:
enable = True
if index == 0: # check record audio if there is a path
cb.SetValue(True)
else:
enable = False
else: # playback buttons
enable = os.path.isfile(path)
cb.Enable(enable)
self.NextRow()
return b
def OnTxLevel(self, event):
application.tx_level = event.GetEventObject().GetValue()
application.Hardware.SetTxLevel()
def OnDigitalTxLevel(self, event):
application.digital_tx_level = event.GetEventObject().GetValue()
application.Hardware.SetTxLevel()
def OnBtnPhase(self, event):
btn = event.GetEventObject()
if btn.GetLabel()[0:2] == 'Tx':
rx_tx = 'tx'
else:
rx_tx = 'rx'
application.screenBtnGroup.SetLabel('Graph', do_cmd=True)
if application.w_phase:
application.w_phase.Raise()
else:
application.w_phase = QAdjustPhase(self, self.width, rx_tx)
def OnBtnFileName(self, event):
btn = event.GetEventObject()
dr, fn = os.path.split(btn.path)
if btn.index in (0, 1): # record audio or samples
dlg = wx.FileDialog(self, 'Choose WAV file', dr, fn, style=wx.FD_SAVE, wildcard="Wave files (*.wav)|*.wav")
elif btn.index == 2: # record mic
dlg = wx.FileDialog(self, 'Choose WAV file', dr, fn, style=wx.FD_SAVE|wx.FD_OVERWRITE_PROMPT, wildcard="Wave files (*.wav)|*.wav")
else: # play buttons
dlg = wx.FileDialog(self, 'Choose WAV file', dr, fn, style=wx.FD_OPEN, wildcard="Wave files (*.wav)|*.wav")
if dlg.ShowModal() == wx.ID_OK:
path = dlg.GetPath()
if path[-4:].lower() != '.wav':
path = path + '.wav'
btn.path = path
setattr(application, btn.name, path)
btn.check_box.path = path
btn.check_box.Enable(True)
if btn.index >= 10: # play buttons
btn.check_box.SetValue(True)
application.file_play_source = btn.index
self.EnableRecPlay()
dlg.Destroy()
def ChangePlayFile(self, btn, path):
btn.path = path
setattr(application, btn.name, path)
btn.check_box.path = path
btn.check_box.Enable(True)
self.EnableRecPlay()
def OnBtnBandPlan(self, ctrl):
from configure import BandPlanDlg
dlg = BandPlanDlg(self)
dlg.ShowModal()
dlg.Destroy()
def OnConfigureWsjtx(self, ctrl):
from configure import WsjtxDlg
dlg = WsjtxDlg(self)
dlg.ShowModal()
dlg.Destroy()
def InitRecPlay(self):
for btn in (self.file_button_play_speaker, self.file_button_play_iq, self.file_button_play_mic):
if btn.index == application.file_play_source:
btn.check_box.SetValue(True)
def EnableRecPlay(self): # Enable or disable file record/play buttons on main screen
enable_rec = False
enable_play = False
for btn in (self.file_button_rec_speaker, self.file_button_rec_iq, self.file_button_rec_mic):
if btn.check_box.GetValue():
enable_rec = True
break
for btn in (self.file_button_play_speaker, self.file_button_play_iq, self.file_button_play_mic):
if btn.check_box.GetValue() and os.path.isfile(btn.path):
enable_play = True
break
application.btn_file_record.Enable(enable_rec)
application.btnFilePlay.Enable(enable_play)
def OnCheckRecPlay(self, event):
btn = event.GetEventObject()
if btn.GetValue():
if btn.index >= 10: # play button
application.file_play_source = btn.index
self.EnableRecPlay()
def OnPlayFileRepeat(self, event):
application.file_play_repeat = event.GetEventObject().GetValue() * 0.1
def OnFilePlayButton(self, play):
if play:
for btn in (self.file_button_play_speaker, self.file_button_play_iq, self.file_button_play_mic):
if application.file_play_source == btn.index and btn.check_box.GetValue() and os.path.isfile(btn.path):
QS.open_wav_file_play(btn.path)
break
else:
QS.set_file_name(play_button=0) # Close all play files
def OnFileRecordButton(self, record): # The File Record button on the main screen
if record:
for btn in (self.file_button_rec_speaker, self.file_button_rec_iq, self.file_button_rec_mic):
if btn.check_box.GetValue(): # open this file
if btn.index in (0, 1) and os.path.isfile(btn.path): # Change path
direc, fname = os.path.split(btn.path)
base = os.path.splitext(fname)[0]
while base and base[-1] in '0123456789':
base = base[0:-1]
if not base:
base = "rec"
index = 0
for dir_entry in os.scandir(direc):
if dir_entry.is_file():
name = dir_entry.name
if len(name) > 4 and name[-4] == '.' and name.startswith(base):
ma = re.match(base + '([0-9]+)[.]', name)
if ma:
index = max(index, int(ma.group(1), base=10))
btn.path = os.path.join(direc, "%s%03d.wav" % (base, index + 1))
QS.set_file_name(btn.index, btn.path, record_button=1)
if btn.index == 0: # Change play files to equal record files
self.ChangePlayFile(self.file_button_play_speaker, btn.path)
elif btn.index == 1:
self.ChangePlayFile(self.file_button_play_iq, btn.path)
else:
QS.set_file_name(record_button=0) # Close all record files
class ConfigTxAudio(BaseWindow):
def __init__(self, parent):
BaseWindow.__init__(self, parent)
self.tmp_playing = False
self.timer = wx.Timer(self)
self.Bind(wx.EVT_TIMER, self.OnTimer)
self.SetBackgroundColour(parent.bg_color)
self.num_cols = 4
#self.MarkCols()
self.NextRow()
t = "This is a test screen for transmit audio. SSB, AM and FM have separate settings."
item = self.AddTextL(1, t, span=2)
self.NextRow()
self.NextRow()
self.NextRow()
help_text = "Record the transmit audio while adjusting clip and preemphasis; then play back the result."
txt, self.btn_record, self.btn_playback = self.AddText2CheckHelp(1, "Record transmit audio" + ' ' * 10,
"Record", self.OnBtnRecord, "Playback", self.OnBtnPlayback, help_text)
self.btn_playback.Enable(0)
if not conf.microphone_name:
self.btn_record.Enable(0)
self.NextRow()
help_text = "Audio level that triggers VOX (all modes)."
self.AddTextSliderHelp(1, "VOX level %d dB", application.levelVOX, -40, 0, application.OnLevelVOX, help_text, span=2)
self.NextRow()
help_text = "Time to hold VOX after end of audio in seconds."
self.AddTextSliderHelp(1, "VOX hold %0.2f secs", application.timeVOX, 0, 4000, application.OnTimeVOX, help_text, span=2, scale=0.001)
self.NextRow()
help_text = "Tx audio clipping level in dB for this mode."
sld, btn = self.AddTextSliderHelp(1, "Clip level %2d dB", 0, 0, 20, application.OnTxAudioClip, help_text, span=2)
application.CtrlTxAudioClip = sld
self.NextRow()
help_text = "Tx audio preemphasis of high frequencies."
sld, btn = self.AddTextSliderHelp(1, "Preemphasis %4.2f", 0, 0, 100, application.OnTxAudioPreemph, help_text, span=2, scale=0.01)
application.CtrlTxAudioPreemph = sld
self.NextRow()
self.FitInside()
def OnTimer(self, event):
if not self.tmp_playing:
self.timer.Stop()
elif QS.set_record_state(-1): # poll to see if playback is finished
self.tmp_playing = False
self.timer.Stop()
self.btn_playback.SetValue(False)
self.btn_record.Enable(1)
def OnBtnRecord(self, event):
if event.GetEventObject().GetValue():
QS.set_kill_audio(1)
self.btn_playback.Enable(0)
QS.set_record_state(4)
else:
QS.set_kill_audio(0)
self.btn_playback.Enable(1)
QS.set_record_state(1)
def OnBtnPlayback(self, event):
if event.GetEventObject().GetValue():
self.btn_record.Enable(0)
QS.set_record_state(2)
self.tmp_playing = True
self.timer.Start(milliseconds=200)
else:
self.btn_record.Enable(1)
QS.set_record_state(3)
self.tmp_playing = False
class Radios(BaseWindow): # The "Radios" first-level page
def __init__(self, parent):
BaseWindow.__init__(self, parent)
self.SetBackgroundColour(parent.bg_color)
self.num_cols = 5
self.radio_name = None
self.index = 0
txt = 'Each "radio" is a block of settings that describes a radio to use with Quisk.'
self.AddTextL(1, txt, self.num_cols - 1)
self.NextRow()
self.NextRow()
self.radio_buttons = []
rb = self.AddRadioButton(1, "When Quisk starts, use the radio", self.NewTop, start=True)
rb.SetValue(True)
self.start_radio = self.AddComboCtrl(2, 'big_radio_name', choices=[], no_edit=True)
self.start_radio.handler = self.OnChoiceStartup
self.radio_buttons.append((rb, self.start_radio))
self.NextRow()
rb = self.AddRadioButton(1, "Add a new radio with the general type", self.NewTop)
choices = []
for explain in local_conf.receiver_explain:
choices.append(explain)
choices.sort()
self.add_type = self.AddComboCtrl(2, '', choices=choices, no_edit=True)
self.add_type.SetSelection(0)
item = self.AddTextL(3, "and name the new radio")
self.add_name = self.AddComboCtrl(4, '', choices=["My Radio", "Transverter", "SoftRock", "HL2"])
self.radio_buttons.append((rb, self.add_type, self.add_name))
self.NextRow()
rb = self.AddRadioButton(1, "Add a new radio copied from radio", self.NewTop)
self.add_from = self.AddComboCtrl(2, 'big_radio_name', choices=[], no_edit=True)
item = self.AddTextL(3, "and name the new radio")
self.add_name2 = self.AddComboCtrl(4, '', choices=["My Radio", "Transverter", "SoftRock", "HL2"])
self.radio_buttons.append((rb, self.add_from, self.add_name2))
self.NextRow()
rb = self.AddRadioButton(1, "Rename the radio named", self.NewTop)
self.rename_old = self.AddComboCtrl(2, 'big_radio_name', choices=[], no_edit=True)
item = self.AddTextL(3, "to the new name")
self.rename_new = self.AddComboCtrl(4, '', choices=["My Radio", "Transverter", "SoftRock", "HL2"])
self.radio_buttons.append((rb, self.rename_old, self.rename_new))
self.NextRow()
rb = self.AddRadioButton(1, "Delete the radio named", self.NewTop)
self.delete_name = self.AddComboCtrl(2, 'big_radio_name', choices=[], no_edit=True)
self.radio_buttons.append((rb, self.delete_name))
self.NextRow()
self.NextRow()
self.apply_btn = self.AddPushButton(3, "Apply", self.OnBtnApply)
self.NewRadioNames()
self.NewTop()
def NewTop(self, event=None):
if event:
btn = event.GetEventObject()
else: # set first button
btn = self.radio_buttons[0][0]
for i in range(len(self.radio_buttons)):
data = self.radio_buttons[i]
rb = data[0]
if rb == btn:
self.index = i
for c in data[1:]:
c.Enable(rb == btn)
if self.index == 0:
self.apply_btn.Enable(False)
else:
self.apply_btn.Enable(True)
def OnBtnApply(self, event):
index = self.index
ok = False
if index == 1: # add from hardware type
ok = self.OnBtnAdd()
elif index == 2: # add from existing radio
ok = self.OnBtnCopy()
elif index == 3: # rename
ok = self.OnBtnRename()
elif index == 4: # delete
ok = self.OnBtnDelete()
if ok:
self.radio_buttons[0][0].SetValue(True)
self.NewTop()
def DuplicateName(self, name):
if name in Settings[2] or name == "ConfigFileRadio":
dlg = wx.MessageDialog(self, "The name already exists. Please choose a different name.",
'Quisk', wx.OK)
dlg.ShowModal()
dlg.Destroy()
return True
return False
def OnBtnAdd(self):
name = self.add_name.GetValue().strip()
if not name or self.DuplicateName(name):
return
self.add_name.SetValue('')
typ = self.add_type.GetValue().split(',')[0].strip()
if local_conf.AddRadio(name, typ):
self.NewRadioNames()
local_conf.settings_changed = True
return True
def OnBtnCopy(self):
new_name = self.add_name2.GetValue().strip()
if not new_name or self.DuplicateName(new_name):
return
self.add_name2.SetValue('')
old_name = self.add_from.GetValue()
if local_conf.CopyRadio(old_name, new_name):
self.NewRadioNames()
local_conf.settings_changed = True
return True
def OnBtnRename(self):
old = self.rename_old.GetValue()
new = self.rename_new.GetValue().strip()
if not old or not new or self.DuplicateName(new):
return
self.rename_new.SetValue('')
if local_conf.RenameRadio(old, new):
if Settings[1] == old:
Settings[1] = new
self.NewRadioNames()
local_conf.settings_changed = True
return True
def OnBtnDelete(self):
name = self.delete_name.GetValue()
if not name:
return
dlg = wx.MessageDialog(self,
"Are you sure you want to permanently delete the radio %s?" % name,
'Quisk', wx.OK|wx.CANCEL|wx.ICON_EXCLAMATION)
ret = dlg.ShowModal()
dlg.Destroy()
if ret == wx.ID_OK and local_conf.DeleteRadio(name):
self.NewRadioNames()
local_conf.settings_changed = True
return True
def OnChoiceStartup(self, ctrl):
choice = self.start_radio.GetValue()
if Settings[0] != choice:
Settings[0] = choice
local_conf.settings_changed = True
def NewRadioNames(self): # Correct all choice lists for changed radio names
choices = Settings[2][:] # can rename any available radio
self.rename_old.SetItems(choices)
self.rename_old.SetSelection(0)
self.add_from.SetItems(choices)
self.add_from.SetSelection(0)
if "ConfigFileRadio" in choices: # can not delete ConfigFileRadio
choices.remove("ConfigFileRadio")
self.delete_name.SetItems(choices)
self.delete_name.SetSelection(0)
choices = Settings[2] + ["Ask me"]
if "ConfigFileRadio" not in choices:
choices.append("ConfigFileRadio")
self.start_radio.SetItems(choices) # can start any radio, plus "Ask me" and "ConfigFileRadio"
try: # Set text in control
index = choices.index(Settings[0]) # last used radio, or new or renamed radio
except:
num = len(Settings[2]) # number of radios
if num == 0: # no radios
index = 1 # use ConfigFileRadio
elif num == 1: # one radio
index = 0 # use the one radio
else:
index = len(choices) - 2 # use the last radio
Settings[0] = choices[index]
self.start_radio.SetSelection(index)
class RadioSection(BaseWindow): # The pages for each section in the second-level notebook for each radio
help_cw = \
'If your CW key is not connected to your radio hardware, you can connect the key to Quisk using a serial port or MIDI. '\
'For the serial port, enter the serial port name and either CTS or DSR for the key. '\
'You can use MIDI for keying. See the "Keys" screen . '\
'If you turn on the Quisk internal sidetone, be sure to use the Fast Sound setting for Windows. '\
'And for Linux, use Alsa for the radio sound output. '\
'Reduce the hardware poll time for faster response.'
def __init__(self, parent, radio_name, section, names):
BaseWindow.__init__(self, parent)
self.radio_name = radio_name
self.section = section
self.names = names
self.MakeControls()
def MakeControls(self):
self.num_cols = 8
#self.MarkCols()
self.NextRow(3)
Keys = self.section == "Keys"
if Keys:
col = 5
else:
col = 1
start_row = self.row
radio_dict = local_conf.GetRadioDict(self.radio_name)
radio_type = radio_dict['hardware_file_type']
for name, text, fmt, help_text, values in self.names:
if name == 'favorites_file_path':
self.favorites_path = radio_dict.get('favorites_file_path', '')
row = self.row
self.row = 1
item, self.favorites_combo, btn = self.AddTextComboHelp(1, text, self.favorites_path, values, help_text, False, span_text=1, span_combo=4)
self.favorites_combo.handler = self.OnButtonChangeFavorites
item = self.AddPushButtonR(7, "Change..", self.OnButtonChangeFavorites, border=0)
self.row = row
else:
if name == "keyupDelay":
if col != 1:
col = 1
self.NextRow()
self.NextRow()
self.NextRow()
self.AddTextCHelp(1, "CW Settings for Remote and Local Operation", self.help_cw, 8)
col = 1
self.NextRow()
self.NextRow()
if fmt[0:4] in ('dict', 'list'):
continue
if name[0:4] == platform_ignore:
continue
if name == 'use_fast_sound' and sys.platform != 'win32':
continue
value = self.GetValue(name, radio_dict)
no_edit = "choice" in fmt or fmt == 'boolean'
if name == "midi_cwkey_device":
# Start of MIDI
values = QS.control_midi(get_in_names=1)
values.insert(0, '')
txt, cb, btn = self.AddTextComboHelp(col, text, value, values, help_text, no_edit)
cb.handler = self.OnChange
cb.quisk_data_name = name
if Keys:
self.NextRow()
elif col == 1:
col = 4
else:
col = 1
self.NextRow()
if self.section == "Keys":
if self.radio_name == Settings[1]: # Current radio in use
application.config_midi_window = self
charx = self.charx
self.list_ctrl = list_ctrl = wx.ListCtrl(self, size=(charx * 19 + 5, self.quisk_height * 8),
style=wx.LC_REPORT | wx.LC_SINGLE_SEL | wx.BORDER_SIMPLE)
list_ctrl.InsertColumn(0, 'Midi', width=charx*10)
list_ctrl.InsertColumn(1, 'Quisk', width=charx*9)
list_ctrl.SetBackgroundColour(wx.Colour(0xeaeaea))
list_ctrl.Bind(wx.EVT_LIST_ITEM_SELECTED, self.OnMidiListSelected)
index = 0
for txt_note in local_conf.MidiNoteDict: # txt_note is a string
int_note = int(txt_note, base=0)
self.list_ctrl.InsertItem(index, txt_note)
self.list_ctrl.SetItemData(index, int_note)
self.list_ctrl.SetItem(index, 1, local_conf.MidiNoteDict[txt_note])
index += 1
list_ctrl.SortItems(lambda x, y: x - y)
rows = self.row - start_row + 1
self.row = start_row
self.gbs.Add(list_ctrl, (start_row, 1), span=(rows, 1), flag=wx.RIGHT, border=charx * 15 // 10)
#self.gbs.Add (charx, self.chary // 2, wx.GBPosition(start_row + rows, 1)) # Spacer at the bottom
hlp = \
'You can use a MIDI keyboard or other MIDI device to control Quisk. '\
'These Midi devices generate a control number and value for buttons, knobs and jog wheels. '\
'You can assign the number to a Quisk button or slider. '\
'Operate the control and look here to see the note or control number received by Quisk. '\
'Then press a button below to assign the control.'
txt, self.midi_edt, btn = self.AddTextEditHelp(2, "Midi control", '', hlp, border=2, span1=1, span2=1, no_edit=True)
self.NextRow()
hlp = 'Assign the Midi button to a Quisk button.'
ctrl = self.AddPopupMenuHelp(MidiButton, 2, "Assign Midi control to", "Button", hlp)
ctrl.handler = self.OnMidiMenu
self.NextRow()
hlp = \
'A "knob" is a Midi control that rotates left and right one turn. It sends a value from 0 to 127. '\
'Assign the Midi knob to a Quisk control.'
ctrl = self.AddPopupMenuHelp(MidiKnob, 2, "Assign Midi control to", "Knob", hlp)
ctrl.handler = self.OnMidiMenu
self.NextRow()
hlp = \
'A "jog wheel" is a Midi control that rotates around and around. It sends continuous high or low values. '\
'Assign the Midi jog wheel to a Quisk control.'
self.midiJogWheel = self.AddPopupMenuHelp(MidiJogWheel, 2, "Assign Midi control to", "Jog Wheel", hlp)
self.midiJogWheel.handler = self.OnMidiMenu
self.NextRow()
hlp = "To delete a row, select it and press this button."
self.AddTextButtonHelp(2, "Delete Midi row", "Delete", self.OnMidiDelete, hlp)
self.NextRow()
if not Keys:
self.AddColSpacer(2, 20)
self.AddColSpacer(5, 20)
self.FitInside()
def OnButtonChangeFavorites(self, event):
if isinstance(event, (ChoiceCombo, ComboCtrl)):
path = event.GetValue()
else:
direc, fname = os.path.split(getattr(conf, 'favorites_file_in_use'))
dlg = wx.FileDialog(None, "Choose Favorites File", direc, fname, "*.txt", wx.FD_OPEN)
if dlg.ShowModal() == wx.ID_OK:
path = dlg.GetPath()
self.favorites_combo.SetText(path)
dlg.Destroy()
else:
dlg.Destroy()
return
path = path.strip()
self.favorites_path = path
local_conf.GetRadioDict(self.radio_name)["favorites_file_path"] = path
local_conf.settings_changed = True
def OnMidiDelete(self, event):
ctrl = self.list_ctrl
index = ctrl.GetFirstSelected()
if index < 0:
return
txt_note = ctrl.GetItem(index, 0).GetText()
ctrl.DeleteItem(index)
del local_conf.MidiNoteDict[txt_note]
local_conf.settings_changed = True
if index > 0:
index -= 1
if ctrl.GetItemCount() > 0:
ctrl.Select(index)
ctrl.EnsureVisible(index)
def MidiAddNote(self):
note = self.midi_edt.GetValue()
self.midi_edt.Clear()
if not note:
return -1
txt_note = note.split()[0]
if txt_note[2] == '8':
txt_note = "0x9%s" % txt_note[3:] # Change Note Off to store as Note On
int_note = int(txt_note, base=0)
ctrl = self.list_ctrl
index = ctrl.FindItem(-1, txt_note)
if index < 0: # Item is not in the list. Add it.
ctrl.Append((txt_note, ''))
ctrl.SetItemData(ctrl.GetItemCount() - 1, int_note)
ctrl.SortItems(lambda x, y: x-y)
index = ctrl.FindItem(-1, txt_note)
local_conf.MidiNoteDict[txt_note] = ''
local_conf.settings_changed = True
if index >= 0:
ctrl.Select(index)
ctrl.EnsureVisible(index)
return index
def OnMidiMenu(self, ctrl, jog_tag=None):
if jog_tag: # Change the jog tag on the current line
index = self.list_ctrl.GetFirstSelected()
if index < 0:
return
text = self.list_ctrl.GetItem(index, 1).GetText()
if len(text) > 3 and text[-3] == ' ' and text[-2] in "+-" and text[-1] in '0123456789': # Item is a jog wheel item
text = text[0:-2] + jog_tag
else: # There is no jog tag on the current item
return
else: # Assign the Midi message to a Quisk control
index = self.MidiAddNote()
if index < 0:
return
text = ctrl.value
self.list_ctrl.SetItem(index, 1, text)
txt_note = self.list_ctrl.GetItem(index, 0).GetText()
local_conf.MidiNoteDict[txt_note] = text
local_conf.settings_changed = True
def OnMidiListSelected(self, event):
event.Skip()
self.midi_edt.Clear()
index = self.list_ctrl.GetFirstSelected()
text = self.list_ctrl.GetItem(index, 1).GetText()
if len(text) > 3 and text[-3] == ' ' and text[-2] in "+-" and text[-1] in '0123456789': # Item is a jog wheel item
self.midiJogWheel.ChangeSelection(text[-2:])
def OnNewMidiNote(self, message):
txt_note = "0x%02X%02X %d" % tuple(message)
self.midi_edt.SetValue(txt_note)
if txt_note[2] == '8': # Note off. We already saw the Note On message.
return
txt_note = txt_note.split()[0]
index = self.list_ctrl.FindItem(-1, txt_note)
if index >= 0:
self.list_ctrl.Select(index)
self.list_ctrl.EnsureVisible(index)
else:
index = self.list_ctrl.GetFirstSelected()
if index >= 0:
self.list_ctrl.Select(index, 0)
class RadioHardwareBase(BaseWindow): # The Hardware page in the second-level notebook for each radio
def __init__(self, parent, radio_name):
BaseWindow.__init__(self, parent)
self.radio_name = radio_name
self.num_cols = 8
self.PMcalDialog = None
#self.MarkCols()
def AlwaysMakeControls(self):
radio_dict = local_conf.GetRadioDict(self.radio_name)
radio_type = radio_dict['hardware_file_type']
data_names = local_conf.GetReceiverData(radio_type)
self.AddTextL(1, "These are the hardware settings for a radio of type %s" % radio_type, self.num_cols-1)
for name, text, fmt, help_text, values in data_names:
if name == 'hardware_file_name':
self.hware_path = self.GetValue(name, radio_dict)
row = self.row
self.row = 3
item, self.hware_combo, btn = self.AddTextComboHelp(1, text, self.hware_path, values, help_text, False, span_text=1, span_combo=4)
self.hware_combo.handler = self.OnButtonChangeHardware
item = self.AddPushButtonR(7, "Change..", self.OnButtonChangeHardware, border=0)
elif name == 'widgets_file_name':
self.widgets_path = self.GetValue(name, radio_dict)
row = self.row
self.row = 5
item, self.widgets_combo, btn = self.AddTextComboHelp(1, text, self.widgets_path, values, help_text, False, span_text=1, span_combo=4)
self.widgets_combo.handler = self.OnButtonChangeWidgets
item = self.AddPushButtonR(7, "Change..", self.OnButtonChangeWidgets, border=0)
self.NextRow(7)
self.AddColSpacer(2, 20)
self.AddColSpacer(5, 20)
def OnButtonChangeHardware(self, event):
if isinstance(event, (ChoiceCombo, ComboCtrl)):
path = event.GetValue()
else:
direc, fname = os.path.split(self.hware_path)
dlg = wx.FileDialog(None, "Choose Hardware File", direc, fname, "*.py", wx.FD_OPEN)
if dlg.ShowModal() == wx.ID_OK:
path = dlg.GetPath()
self.hware_combo.SetText(path)
dlg.Destroy()
else:
dlg.Destroy()
return
path = path.strip()
self.hware_path = path
local_conf.GetRadioDict(self.radio_name)["hardware_file_name"] = path
local_conf.settings_changed = True
def OnButtonChangeWidgets(self, event):
if isinstance(event, (ChoiceCombo, ComboCtrl)):
path = event.GetValue()
else:
direc, fname = os.path.split(self.widgets_path)
dlg = wx.FileDialog(None, "Choose Widgets File", direc, fname, "*.py", wx.FD_OPEN)
if dlg.ShowModal() == wx.ID_OK:
path = dlg.GetPath()
self.widgets_combo.SetText(path)
dlg.Destroy()
else:
dlg.Destroy()
return
path = path.strip()
self.widgets_path = path
local_conf.GetRadioDict(self.radio_name)["widgets_file_name"] = path
local_conf.settings_changed = True
class RadioHardware(RadioHardwareBase): # The Hardware page in the second-level notebook for each radio
def __init__(self, parent, radio_name):
RadioHardwareBase.__init__(self, parent, radio_name)
self.AlwaysMakeControls()
self.HermesBias0 = None
self.HermesBias1 = None
radio_dict = local_conf.GetRadioDict(radio_name)
radio_type = radio_dict['hardware_file_type']
data_names = local_conf.GetReceiverData(radio_type)
col = 1
border = 2
try:
is_HermesLite2 = application.Hardware.is_HermesLite2
except:
is_HermesLite2 = False
if radio_name == Settings[1] and hasattr(application.Hardware, "ProgramGateware"):
help_text = "Choose an RBF file and program the Gateware (FPGA software) over Ethernet."
self.AddTextButtonHelp(1, "Gateware Update", "Program from RBF file..", application.Hardware.ProgramGateware, help_text)
col = 1
self.NextRow(self.row + 2)
for name, text, fmt, help_text, values in data_names:
text = text.replace("\\u2103", "\u2103")
if name in ('hardware_file_name', 'widgets_file_name'):
pass
elif name[0:4] == platform_ignore:
pass
elif name in ('Hermes_BandDictEnTx', ):
pass
elif 'Hl2_' in name and not is_HermesLite2:
pass
elif fmt[0:4] in ('dict', 'list'):
pass
else:
if name[0:6] == 'Hware_': # value comes from the hardware file
value = application.Hardware.GetValue(name)
else:
value = self.GetValue(name, radio_dict)
no_edit = "choice" in fmt or fmt == 'boolean'
if name == 'power_meter_calib_name':
values = self.PowerMeterCalChoices()
txt, cb, btn = self.AddTextComboHelp(col, text, value, values, help_text, no_edit, border=border)
cb.handler = self.OnButtonChangePMcal
self.power_meter_cal_choices = cb
else:
txt, cb, btn = self.AddTextComboHelp(col, text, value, values, help_text, no_edit, border=border)
if name[0:6] == 'Hware_':
cb.handler = application.Hardware.SetValue
else:
cb.handler = self.OnChange
cb.quisk_data_name = name
if col == 1:
col = 4
border = 0
else:
col = 1
border = 2
self.NextRow()
if is_HermesLite2:
if col == 4:
self.NextRow()
help_text = ('This controls the bias level for transistors in the final power amplifier. Enter a level from 0 to 255.'
' These changes are temporary. Press the "Write" button to write the value to the hardware and make it permanent.')
## Bias is 0 indexed to match schematic
txt, self.HermesBias0, btn = self.AddTextSpinnerHelp(1, "Power amp bias 0", 0, 0, 255, help_text)
txt, self.HermesBias1, btn = self.AddTextSpinnerHelp(4, "Power amp bias 1", 0, 0, 255, help_text)
enbl = radio_dict["hermes_bias_adjust"] == "True"
self.HermesBias0.Enable(enbl)
self.HermesBias1.Enable(enbl)
self.HermesBias0.Bind(wx.EVT_SPINCTRL, self.OnHermesChangeBias0)
self.HermesBias1.Bind(wx.EVT_SPINCTRL, self.OnHermesChangeBias1)
self.HermesWriteBiasButton = self.AddPushButton(7, "Write", self.OnButtonHermesWriteBias, border=0)
self.HermesWriteBiasButton.Enable(enbl)
self.FitInside()
def OnHermesChangeBias0(self, event):
value = self.HermesBias0.GetValue()
application.Hardware.ChangeBias0(value)
def OnHermesChangeBias1(self, event):
value = self.HermesBias1.GetValue()
application.Hardware.ChangeBias1(value)
def OnButtonHermesWriteBias(self, event):
value0 = self.HermesBias0.GetValue()
value1 = self.HermesBias1.GetValue()
application.Hardware.WriteBias(value0, value1)
def PowerMeterCalChoices(self):
values = list(conf.power_meter_std_calibrations) # known calibration names from the config file
radio_dict = local_conf.GetRadioDict(self.radio_name)
values += list(radio_dict.get('power_meter_local_calibrations', {})) # local calibrations
values.sort()
values.append('New')
return values
def OnButtonChangePMcal(self, ctrl):
value = ctrl.GetValue()
name = ctrl.quisk_data_name
radio_dict = local_conf.GetRadioDict(self.radio_name)
local_cal = radio_dict.get('power_meter_local_calibrations', {})
if value == 'New':
if not self.PMcalDialog:
self.PMcalDialog = QPowerMeterCalibration(self, list(local_cal))
else:
setattr(conf, name, value)
radio_dict[name] = value
local_conf.settings_changed = True
application.Hardware.MakePowerCalibration()
def ChangePMcalFinished(self, name, table):
self.PMcalDialog = None
radio_dict = local_conf.GetRadioDict(self.radio_name)
local_cal = radio_dict.get('power_meter_local_calibrations', {})
if name is None: # Cancel
name = conf.power_meter_calib_name
values = self.PowerMeterCalChoices()
else:
if table is None: # delete name
del local_cal[name]
name = list(conf.power_meter_std_calibrations)[0] # replacement name
else: # new entry
local_cal[name] = table
conf.power_meter_calib_name = name
radio_dict['power_meter_calib_name'] = name
radio_dict['power_meter_local_calibrations'] = local_cal
local_conf.settings_changed = True
values = self.PowerMeterCalChoices()
self.power_meter_cal_choices.SetItems(values)
application.Hardware.MakePowerCalibration()
try:
index = values.index(name)
except:
index = 0
self.power_meter_cal_choices.SetSelection(index)
class RadioHardwareSoapySDR(RadioHardwareBase): # The Hardware page in the second-level notebook for the SoapySDR radios
name_text = {
'soapy_gain_mode_rx' : 'Rx gain mode',
'soapy_setAntenna_rx' : 'Rx antenna name',
'soapy_setBandwidth_rx' : 'Rx bandwidth kHz',
'soapy_setSampleRate_rx' : 'Rx sample rate kHz',
'soapy_device' : 'Device name',
'soapy_gain_mode_tx' : 'Tx gain mode',
'soapy_setAntenna_tx' : 'Tx antenna name',
'soapy_setBandwidth_tx' : 'Tx bandwidth kHz',
'soapy_setSampleRate_tx' : 'Tx sample rate kHz',
}
help_text = {
'soapy_gain_mode_rx' : 'Choose "total" to set the total gain, "detailed" to set multiple gain elements individually, \
or "automatic" for automatic gain control. The "detailed" or "automatic" may not be available depending on your hardware.',
'soapy_setAntenna_rx' : 'Choose the antenna to use for receive.',
'soapy_device' : "SoapySDR provides an interface to various radio hardware. The device name specifies \
the hardware device. Create a new radio for each hardware you have. Changing the device \
name requires re-entering all the hardware settings because different hardware has \
different settings. Also, the hardware device must be turned on when you change the \
device name so that Quisk can read the available settings.",
'soapy_gain_mode_tx' : 'Choose "total" to set the total gain, "detailed" to set multiple gain elements individually, \
or "automatic" for automatic gain control. The "detailed" or "automatic" may not be available depending on your hardware.',
'soapy_setAntenna_tx' : 'Choose the antenna to use for transmit.',
}
def __init__(self, parent, radio_name):
RadioHardwareBase.__init__(self, parent, radio_name)
self.no_device = "No device specified"
if soapy:
self.AlwaysMakeControls()
self.MakeSoapyControls()
else:
radio_dict = local_conf.GetRadioDict(self.radio_name)
radio_type = radio_dict['hardware_file_type']
self.AddTextL(1, "These are the hardware settings for a radio of type %s" % radio_type, self.num_cols-1)
self.NextRow()
self.AddTextL(1, "The shared library from the SoapySDR project is not available.")
self.NextRow()
self.AddTextL(1, "The shared library is not installed or is not compatible (perhaps 32 versus 64 bit versions).")
self.NextRow()
return
#self.MarkCols()
def NextCol(self):
if self.col == 1:
self.col = 4
self.border = 0
else:
self.col = 1
self.border = 2
self.NextRow()
def MakeSoapyControls(self):
self.gains_rx = []
self.gains_tx = []
radio_dict = local_conf.GetRadioDict(self.radio_name)
local_conf.InitSoapyNames(radio_dict)
self.border = 2
name = 'soapy_device'
device = radio_dict.get(name, self.no_device)
txt, self.edit_soapy_device, btn = self.AddTextEditHelp(1, self.name_text[name], device, self.help_text[name], span1=1, span2=4)
self.AddPushButtonR(7, "Change..", self.OnButtonChangeSoapyDevice, border=0)
self.NextRow()
self.NextRow()
self.col = 1
if device == self.no_device:
self.FitInside()
return
if radio_dict.get("soapy_file_version", 0) < soapy_software_version:
text = "Please re-enter the device name. This will read additional parameters from the hardware."
self.AddTextL(self.col, text, span=6)
self.FitInside()
return
# Receive parameters
name = 'soapy_setSampleRate_rx'
help_text = 'Available sample rates: '
rates = ['48', '50', '240', '250', '960', '1000']
for dmin, dmax, dstep in radio_dict.get('soapy_getSampleRateRange_rx', ()):
tmin = FormatKhz(dmin * 1E-3)
if tmin not in rates:
rates.append(tmin)
if abs(dmin - dmax) < 0.5:
help_text = help_text + '%s; ' % tmin
elif dstep < 0.5:
help_text = help_text + '%s to %s; ' % (tmin, FormatKhz(dmax * 1E-3))
else:
help_text = help_text + '%s to %s by %s; ' % (tmin, FormatKhz(dmax * 1E-3), FormatKhz(dstep * 1E-3))
help_text = help_text[0:-2] + '.'
if rates:
rates.sort(key=SortKey)
rate = radio_dict.get(name, '')
txt, cb, btn = self.AddTextComboHelp(self.col, self.name_text[name], rate, rates, help_text, False, border=self.border)
cb.handler = self.OnChange
cb.quisk_data_name = name
self.NextCol()
len_gain_names = len(radio_dict.get('soapy_listGainsValues_rx', ()))
name = 'soapy_gain_mode_rx'
gain_mode = radio_dict[name]
choices = ['total']
if len_gain_names >= 3:
choices.append('detailed')
if radio_dict.get('soapy_hasGainMode_rx', 0):
choices.append('automatic')
if gain_mode not in choices:
gain_mode = radio_dict[name] = 'total'
local_conf.settings_changed = True
txt, cb, btn = self.AddTextComboHelp(self.col, self.name_text[name], gain_mode, choices, self.help_text[name], True, border=self.border)
cb.handler = self.OnChange
cb.quisk_data_name = name
self.NextCol()
name = 'soapy_gain_values_rx'
values = radio_dict[name]
for name2, dmin, dmax, dstep in radio_dict.get('soapy_listGainsValues_rx', ()):
if dstep < 1E-4:
dstep = 0.5
text = "Rx gain %s" % name2
help_text = 'Rf gain min %f, max %f, step %f' % (dmin, dmax, dstep)
value = values.get(name2, '0')
value = float(value)
txt, spn, btn = self.AddTextDblSpinnerHelp(self.col, text, value, dmin, dmax, dstep, help_text, border=self.border)
spn.quisk_data_name = name
spn.quisk_data_name2 = name2
spn.Bind(wx.EVT_SPINCTRLDOUBLE, self.OnGain)
self.gains_rx.append(spn)
self.NextCol()
if len_gain_names < 3: # for 1 or 2 names, just show total gain item
break
self.FixGainButtons('soapy_gain_mode_rx')
name = 'soapy_setAntenna_rx'
antenna = radio_dict[name]
antennas = radio_dict.get('soapy_listAntennas_rx', ())
if antenna not in antennas:
if antennas:
antenna = antennas[0]
else:
antenna = ''
radio_dict[name] = antenna
local_conf.settings_changed = True
if antennas:
txt, cb, btn = self.AddTextComboHelp(self.col, self.name_text[name], antenna, antennas, self.help_text[name], True, border=self.border)
cb.handler = self.OnChange
cb.quisk_data_name = name
self.NextCol()
name = 'soapy_setBandwidth_rx'
help_text = 'Available bandwidth: '
bandwidths = []
for dmin, dmax, dstep in radio_dict.get('soapy_getBandwidthRange_rx', ()):
tmin = FormatKhz(dmin * 1E-3)
bandwidths.append(tmin)
if abs(dmin - dmax) < 0.5:
help_text = help_text + '%s; ' % tmin
elif dstep < 0.5:
help_text = help_text + '%s to %s; ' % (tmin, FormatKhz(dmax * 1E-3))
else:
help_text = help_text + '%s to %s by %s; ' % (tmin, FormatKhz(dmax * 1E-3), FormatKhz(dstep * 1E-3))
help_text = help_text[0:-2] + '.'
if bandwidths:
bandwidth = radio_dict.get(name, '')
txt, cb, btn = self.AddTextComboHelp(self.col, self.name_text[name], bandwidth, bandwidths, help_text, False, border=self.border)
cb.handler = self.OnChange
cb.quisk_data_name = name
self.NextCol()
# Transmit parameters
if self.col != 1:
self.NextCol()
name = 'soapy_enable_tx'
enable = radio_dict.get(name, 'Disable')
help_text = 'This will enable or disable the transmit function. If changed, you must restart Quisk.'
txt, cb, btn = self.AddTextComboHelp(self.col, 'Tx enable', enable, ['Enable', 'Disable'], help_text, True, border=self.border)
cb.handler = self.OnChange
cb.quisk_data_name = name
self.NextCol()
name = 'soapy_setSampleRate_tx'
help_text = 'Available sample rates: '
rates = []
for dmin, dmax, dstep in radio_dict.get('soapy_getSampleRateRange_tx', ()):
tmin = FormatKhz(dmin * 1E-3)
rates.append(tmin)
if abs(dmin - dmax) < 0.5:
help_text = help_text + '%s; ' % tmin
elif dstep < 0.5:
help_text = help_text + '%s to %s; ' % (tmin, FormatKhz(dmax * 1E-3))
else:
help_text = help_text + '%s to %s by %s; ' % (tmin, FormatKhz(dmax * 1E-3), FormatKhz(dstep * 1E-3))
help_text = help_text[0:-2] + '.'
if rates:
rate = radio_dict.get(name, '')
rates = ('48', '50', '96', '100', '192')
txt, cb, btn = self.AddTextComboHelp(self.col, self.name_text[name], rate, rates, help_text, True, border=self.border)
cb.handler = self.OnChange
cb.quisk_data_name = name
self.NextCol()
len_gain_names = len(radio_dict.get('soapy_listGainsValues_tx', ()))
name = 'soapy_gain_mode_tx'
gain_mode = radio_dict[name]
choices = ['total']
if len_gain_names >= 3:
choices.append('detailed')
if radio_dict.get('soapy_hasGainMode_tx', 0):
choices.append('automatic')
if gain_mode not in choices:
gain_mode = radio_dict[name] = 'total'
local_conf.settings_changed = True
txt, cb, btn = self.AddTextComboHelp(self.col, self.name_text[name], gain_mode, choices, self.help_text[name], True, border=self.border)
cb.handler = self.OnChange
cb.quisk_data_name = name
self.NextCol()
name = 'soapy_gain_values_tx'
values = radio_dict[name]
for name2, dmin, dmax, dstep in radio_dict.get('soapy_listGainsValues_tx', ()):
if dstep < 1E-4:
dstep = 0.5
text = "Tx gain %s" % name2
help_text = 'Rf gain min %f, max %f, step %f' % (dmin, dmax, dstep)
value = values.get(name2, '0')
value = float(value)
txt, spn, btn = self.AddTextDblSpinnerHelp(self.col, text, value, dmin, dmax, dstep, help_text, border=self.border)
spn.quisk_data_name = name
spn.quisk_data_name2 = name2
spn.Bind(wx.EVT_SPINCTRLDOUBLE, self.OnGain)
self.gains_tx.append(spn)
self.NextCol()
if len_gain_names < 3: # for 1 or 2 names, just show total gain item
break
self.FixGainButtons('soapy_gain_mode_tx')
name = 'soapy_setAntenna_tx'
antenna = radio_dict[name]
antennas = radio_dict.get('soapy_listAntennas_tx', ())
if antenna not in antennas:
if antennas:
antenna = antennas[0]
else:
antenna = ''
radio_dict[name] = antenna
local_conf.settings_changed = True
if antennas:
txt, cb, btn = self.AddTextComboHelp(self.col, self.name_text[name], antenna, antennas, self.help_text[name], True, border=self.border)
cb.handler = self.OnChange
cb.quisk_data_name = name
self.NextCol()
name = 'soapy_setBandwidth_tx'
help_text = 'Available bandwidths: '
bandwidths = []
for dmin, dmax, dstep in radio_dict.get('soapy_getBandwidthRange_tx', ()):
tmin = FormatKhz(dmin * 1E-3)
bandwidths.append(tmin)
if abs(dmin - dmax) < 0.5:
help_text = help_text + '%s; ' % tmin
elif dstep < 0.5:
help_text = help_text + '%s to %s; ' % (tmin, FormatKhz(dmax * 1E-3))
else:
help_text = help_text + '%s to %s by %s; ' % (tmin, FormatKhz(dmax * 1E-3), FormatKhz(dstep * 1E-3))
help_text = help_text[0:-2] + '.'
if bandwidths:
bandwidth = radio_dict.get(name, '')
txt, cb, btn = self.AddTextComboHelp(self.col, self.name_text[name], bandwidth, bandwidths, help_text, False, border=self.border)
cb.handler = self.OnChange
cb.quisk_data_name = name
self.NextCol()
self.FitInside()
def FixGainButtons(self, name):
radio_dict = local_conf.GetRadioDict(self.radio_name)
gain_mode = radio_dict[name]
if name[-3:] == '_tx':
controls = self.gains_tx
else:
controls = self.gains_rx
for i in range(len(controls)):
ctrl = controls[i]
if gain_mode == "automatic":
ctrl.Enable(False)
elif gain_mode == "total":
if i == 0:
ctrl.Enable(True)
else:
ctrl.Enable(False)
else: # gain_mode is "detailed"
if i == 0:
ctrl.Enable(False)
else:
ctrl.Enable(True)
def OnButtonChangeSoapyDevice(self, event):
if not soapy:
txt = "Soapy shared library (DLL) is not available."
msg = wx.MessageDialog(None, txt, 'SoapySDR Error', wx.OK|wx.ICON_ERROR)
msg.ShowModal()
msg.Destroy()
return
try:
choices = self.GetSoapyDevices()
except:
#traceback.print_exc()
choices = []
if not choices:
choices = ['No devices were found.']
device = self.edit_soapy_device.GetValue()
width = application.main_frame.GetSize().width
width = width * 50 // 100
parent = self.edit_soapy_device.GetParent()
dlg = ListEditDialog(parent, "Change Soapy Device", device, choices, width)
ok = dlg.ShowModal()
if ok != wx.ID_OK:
dlg.Destroy()
return
device = dlg.GetValue()
dlg.Destroy()
if device == self.no_device:
return
if Settings[1] == self.radio_name:
txt = "Changing the active radio requires a shutdown and restart. Proceed?"
msg = wx.MessageDialog(None, txt, 'SoapySDR Change to Active Radio', wx.OK|wx.CANCEL|wx.ICON_INFORMATION)
ok = msg.ShowModal()
msg.Destroy()
if ok == wx.ID_OK:
soapy.close_device(1)
else:
return
txt = soapy.open_device(device, 0, 0)
if txt[0:8] == 'Capture ':
radio_dict = local_conf.GetRadioDict(self.radio_name)
radio_dict['soapy_device'] = device
radio_dict['soapy_file_version'] = soapy_software_version
self.edit_soapy_device.ChangeValue(device)
# Record the new SoapySDR parameters for the new device. Do not change the old data values yet.
for name in ('soapy_listAntennas_rx', 'soapy_hasGainMode_rx', 'soapy_listGainsValues_rx',
'soapy_listAntennas_tx', 'soapy_hasGainMode_tx', 'soapy_listGainsValues_tx',
'soapy_getFullDuplex_rx', 'soapy_getSampleRateRange_rx', 'soapy_getSampleRateRange_tx',
'soapy_getBandwidthRange_rx', 'soapy_getBandwidthRange_tx',
):
radio_dict[name] = soapy.get_parameter(name, 0)
soapy.close_device(0)
local_conf.settings_changed = True
# Clear our sizer and re-create all the controls
self.gbs.Clear(True)
self.gbs.Add((self.charx, self.charx), (0, 0))
self.row = 1
RadioHardwareBase.AlwaysMakeControls(self)
self.MakeSoapyControls()
txt = "Please check the settings for the new hardware device."
msg = wx.MessageDialog(None, txt, 'SoapySDR Change to Radio', wx.OK|wx.ICON_INFORMATION)
msg.ShowModal()
msg.Destroy()
else:
msg = wx.MessageDialog(None, txt, 'SoapySDR Device Error', wx.OK|wx.ICON_ERROR)
msg.ShowModal()
msg.Destroy()
def GetSoapyDevices(self):
choices = []
for dct in soapy.get_device_list():
text = ''
try:
driver = dct["driver"]
except:
pass
else:
text = 'driver=%s' % driver
try:
label = dct["label"]
except:
pass
else:
text = text + ', label=%s' % label
choices.append(text)
return choices
def OnChange(self, ctrl):
name = ctrl.quisk_data_name
value = ctrl.GetValue()
radio_dict = local_conf.GetRadioDict(self.radio_name)
radio_dict[name] = value
local_conf.settings_changed = True
# Immediate changes
if name in ('soapy_gain_mode_rx', 'soapy_gain_mode_tx'):
self.FixGainButtons(name)
if soapy and self.radio_name == Settings[1]: # changed for current radio
application.Hardware.ImmediateChange(name, value)
def OnGain(self, event):
radio_dict = local_conf.GetRadioDict(self.radio_name)
obj = event.GetEventObject()
value = obj.GetValue()
name = obj.quisk_data_name
radio_dict[name][obj.quisk_data_name2] = value
local_conf.settings_changed = True
if soapy and self.radio_name == Settings[1]: # changed for current radio
application.Hardware.ChangeGain(name[-3:])
class RadioSound(BaseWindow): # The Sound page in the second-level notebook for each radio
"""Configure the available sound devices."""
sound_names = ( # same order as label_help
('playback_rate', '', '', '', 'name_of_sound_play'),
('mic_sample_rate', 'mic_channel_I', 'mic_channel_Q', '', 'microphone_name'),
('sample_rate', 'channel_i', 'channel_q', 'channel_delay', 'name_of_sound_capt'),
('mic_playback_rate', 'mic_play_chan_I', 'mic_play_chan_Q', 'tx_channel_delay', 'name_of_mic_play'),
('', '', '', '', 'sample_playback_name'),
('', '', '', '', 'digital_input_name'),
('', '', '', '', 'digital_output_name'),
('', '', '', '', 'digital_rx1_name'),
('', '', '', '', 'digital_rx2_name'),
('', '', '', '', 'digital_rx3_name'),
('', '', '', '', 'digital_rx4_name'),
('', '', '', '', 'digital_rx5_name'),
('', '', '', '', 'digital_rx6_name'),
('', '', '', '', 'digital_rx7_name'),
('', '', '', '', 'digital_rx8_name'),
('', '', '', '', 'digital_rx9_name'),
)
hRx0 = "This is almost the same as the radio sound, but it is sent to a digital mode program on a different sound device."\
" It is analog audio and it is only sent if one of the DGT- modes is selected."\
" The volume is set by the digital output level instead of the volume control so you can mute the speaker if desired."\
" It can receive a greater bandwidth than the 3000 Hz limit of SSB."
hTx0 = "This is used instead of the microphone when one of the DGT- modes is selected."\
" The normal speech clipping and filtering is not used for DGT- modes."
label_help = ( # Same order as sound_names
(1, "Radio Sound Output", "This is the radio sound going to the headphones or speakers."),
(0, "Microphone Input", "This is the monophonic microphone source. Set the channel if the source is stereo."),
(0, "I/Q Rx Sample Input", "This is the sample source if it comes from a sound device, such as a SoftRock."),
(1, "I/Q Tx Sample Output", "This is the transmit sample audio sent to a SoftRock."),
(1, "Raw Digital Output", "This sends the received I/Q data to another program as stereo."),
(0, "Digital Tx0 Input", hTx0),
(1, "Digital Rx0 Output", hRx0),
(1, "Digital Rx1 Output", "This is the sub-receiver 1 audio going to a digital mode program."),
(1, "Digital Rx2 Output", "This is the sub-receiver 2 audio going to a digital mode program."),
(1, "Digital Rx3 Output", "This is the sub-receiver 3 audio going to a digital mode program."),
(1, "Digital Rx4 Output", "This is the sub-receiver 4 audio going to a digital mode program."),
(1, "Digital Rx5 Output", "This is the sub-receiver 5 audio going to a digital mode program."),
(1, "Digital Rx6 Output", "This is the sub-receiver 6 audio going to a digital mode program."),
(1, "Digital Rx7 Output", "This is the sub-receiver 7 audio going to a digital mode program."),
(1, "Digital Rx8 Output", "This is the sub-receiver 8 audio going to a digital mode program."),
(1, "Digital Rx9 Output", "This is the sub-receiver 9 audio going to a digital mode program."),
)
def __init__(self, parent, radio_name):
BaseWindow.__init__(self, parent)
self.radio_name = radio_name
self.MakeControls()
def MakeControls(self):
self.radio_dict = local_conf.GetRadioDict(self.radio_name)
self.num_cols = 8
for name, text, fmt, help_text, values in local_conf.GetSectionData('Sound'):
if name in ('digital_output_level', 'file_play_level', 'IQ_Server_IP'):
value = self.GetValue(name, self.radio_dict)
no_edit = "choice" in fmt or fmt == 'boolean'
txt, cb, btn = self.AddTextComboHelp(1, text, value, values, help_text, no_edit)
cb.handler = self.OnChange
cb.quisk_data_name = name
self.NextRow()
self.NextRow()
# Add the grid for the sound settings
sizer = wx.GridBagSizer(2, 2)
sizer.SetEmptyCellSize((self.charx, self.charx))
self.gbs.Add(sizer, (self.row, 0), span=(1, self.num_cols))
gbs = self.gbs
self.gbs = sizer
self.row = 1
help_chan = "For the usual stereo device enter 0 for the I channel and 1 for the Q channel. Reversing the 0 and 1 switches the left\
and right channels. For a monophonic device, enter 0 for both I and Q. If you have more channels enter the channel number. Channels\
are numbered from zero, so a four channel device has channels 0, 1, 2 and 3."
self.AddTextC(1, "Stream")
self.AddTextCHelp(2, "Rate",
"This is the sample rate for the device in Hertz." "Some devices have fixed rates that can not be changed.")
self.AddTextCHelp(3, "Ch I", "This is the in-phase channel for devices with I/Q data. " + help_chan)
self.AddTextCHelp(4, "Ch Q", "This is the quadrature channel for devices with I/Q data. " + help_chan)
self.AddTextCHelp(5, "Delay", "Some older devices have a one sample channel delay between channels. "
"This must be corrected for devices with I/Q data. Enter the channel number to delay; either the I or Q channel number. "
"For no delay, leave this blank.")
self.AddTextCHelp(6, "Sound Device", "This is the name of the sound device. For Windows, this is the Wasapi name. "
"For Linux you can use the Alsa device, the PortAudio device or the PulseAudio device. "
"The Alsa device are recommended because they have lower latency. See the documentation for more information.")
self.NextRow()
choices = (("48000", "96000", "192000"), ("0", "1"), ("0", "1"), (" ", "0", "1"))
r = 0
if "SoftRock" in self.radio_dict['hardware_file_type']:
softrock = True # Samples come from sound card
elif hasattr(application.Hardware, "use_softrock"):
softrock = application.Hardware.use_softrock
else:
softrock = False
last_row = 8
for is_output, label, helptxt in self.label_help:
self.AddTextLHelp(1, label, helptxt)
# Add col 0
value = self.ItemValue(r, 0)
if value is None:
value = ''
data_name = self.sound_names[r][0]
if r == 0:
cb = self.AddComboCtrl(2, value, choices=("48000", "96000", "192000"), right=True)
if r == 1:
cb = self.AddComboCtrl(2, value, choices=("48000", "8000"), right=True, no_edit=True)
if softrock:
if r == 2:
cb = self.AddComboCtrl(2, value, choices=("48000", "96000", "192000"), right=True)
if r == 3:
cb = self.AddComboCtrl(2, value, choices=("48000", "96000", "192000"), right=True)
else:
if r == 2:
cb = self.AddComboCtrl(2, '', choices=("",), right=True)
cb.Enable(False)
if r == 3:
cb = self.AddComboCtrl(2, '', choices=("",), right=True)
cb.Enable(False)
if r >= 4:
cb = self.AddComboCtrl(2, "48000", choices=("48000",), right=True, no_edit=True)
cb.Enable(False)
cb.handler = self.OnChange
cb.quisk_data_name = data_name
# Add col 1, 2, 3
for col in range(1, 4):
value = self.ItemValue(r, col)
data_name = self.sound_names[r][col]
if value is None:
cb = self.AddComboCtrl(col + 2, ' ', choices=[], right=True)
cb.Enable(False)
else:
cb = self.AddComboCtrl(col + 2, value, choices=choices[col], right=True)
cb.handler = self.OnChange
cb.quisk_data_name = self.sound_names[r][col]
# Add col 4
if not softrock and r in (2, 3):
cb = self.AddComboCtrl(6, self.ItemValue(r, 4), choices=[''])
elif is_output:
if label == "Digital Rx0 Output" and sys.platform != 'win32':
play_names = application.dev_play[:]
play_names += ["pulse: Use name QuiskDigitalOutput.monitor"]
else:
play_names = application.dev_play
cb = self.AddComboCtrl(6, self.ItemValue(r, 4), choices=play_names)
else:
if label == "Digital Tx0 Input" and sys.platform != 'win32':
capt_names = application.dev_capt[:]
capt_names += ["pulse: Use name QuiskDigitalInput"]
else:
capt_names = application.dev_capt
cb = self.AddComboCtrl(6, self.ItemValue(r, 4), choices=capt_names)
cb.handler = self.OnChange
cb.quisk_data_name = platform_accept + self.sound_names[r][4]
self.NextRow()
r += 1
if r >= last_row:
break
self.gbs = gbs
self.FitInside()
def ItemValue(self, row, col):
data_name = self.sound_names[row][col]
if col == 4: # Device names
data_name = platform_accept + data_name
value = self.GetValue(data_name, self.radio_dict)
return value
elif data_name:
value = self.GetValue(data_name, self.radio_dict)
if col == 3: # Delay
if value == "-1":
value = ''
return value
return None
def OnChange(self, ctrl):
data_name = ctrl.quisk_data_name
value = ctrl.GetValue()
#index = ctrl.ctrl.lbox.GetSelections()[0]
#print (value, index, ctrl.choices[index])
if data_name in ('channel_delay', 'tx_channel_delay'):
value = value.strip()
if not value:
value = "-1"
self.OnChange2(ctrl, value)
class RadioBands(BaseWindow): # The Bands page in the second-level notebook for each radio
def __init__(self, parent, radio_name):
BaseWindow.__init__(self, parent)
self.radio_name = radio_name
self.parent = parent
self.MakeControls()
def MakeControls(self):
radio_dict = local_conf.GetRadioDict(self.radio_name)
radio_type = radio_dict['hardware_file_type']
self.num_cols = 8
#self.MarkCols()
self.NextRow()
self.AddTextCHelp(1, "Bands",
"This is a list of the bands that Quisk understands. A check mark means that the band button is displayed. A maximum of "
"14 bands may be displayed.")
self.AddTextCHelp(2, " Start MHz",
"This is the start of the band in megahertz.")
self.AddTextCHelp(3, " End MHz",
"This is the end of the band in megahertz.")
heading_row = self.row
self.NextRow()
band_labels = radio_dict['bandLabels'][:]
for i in range(len(band_labels)):
if isinstance(band_labels[i], (list, tuple)):
band_labels[i] = band_labels[i][0]
band_edge = radio_dict['BandEdge']
# band_list is a list of all known bands
band_list = conf.BandList[:]
band_list.append('Time')
if local_conf.ReceiverHasName(radio_type, 'tx_level'): # Must show and edit tx_level
if 'tx_level' in radio_dict:
tx_level = radio_dict['tx_level']
else:
tx_level = {}
radio_dict['tx_level'] = {}
local_conf.settings_changed = True
else:
tx_level = None
try:
transverter_offset = radio_dict['bandTransverterOffset']
except:
transverter_offset = {}
radio_dict['bandTransverterOffset'] = transverter_offset # Make sure the dictionary is in radio_dict
try:
hiqsdr_bus = radio_dict['HiQSDR_BandDict']
except:
hiqsdr_bus = None
try:
hermes_bus = radio_dict['Hermes_BandDict']
except:
hermes_bus = None
self.band_checks = []
# Add the Audio band. This must be first to allow for column labels.
cb = self.AddCheckBox(1, 'Audio', self.OnChangeBands)
self.band_checks.append(cb)
if 'Audio' in band_labels:
cb.SetValue(True)
self.NextRow()
start_row = self.row
# Add check box, start, end
for band in band_list:
cb = self.AddCheckBox(1, band, self.OnChangeBands)
self.band_checks.append(cb)
if band in band_labels:
cb.SetValue(True)
try:
start, end = band_edge[band]
start = "%.3f" % (start * 1E-6)
end = "%.3f" % (end * 1E-6)
except:
try:
start, end = local_conf.originalBandEdge[band]
start = "%.3f" % (start * 1E-6)
end = "%.3f" % (end * 1E-6)
except:
start = ''
end = ''
cb = self.AddComboCtrl(2, start, choices=(start, ), right=True)
cb.handler = self.OnChangeBandStart
cb.quisk_band = band
cb = self.AddComboCtrl(3, end, choices=(end, ), right=True)
cb.handler = self.OnChangeBandEnd
cb.quisk_band = band
self.NextRow()
col = 3
# Add tx_level
if tx_level is not None:
col += 1
self.row = heading_row
text, help_text = local_conf.GetReceiverItemTH(radio_type, 'tx_level')
self.AddTextCHelp(col, " %s" % text, help_text)
self.row = start_row
for band in band_list:
try:
level = tx_level[band]
level = str(level)
except:
try:
level = tx_level[None]
tx_level[band] = level # Fill in tx_level for each band
level = str(level)
except:
tx_level[band] = 70
level = '70'
cb = self.AddComboCtrl(col, level, choices=(level, ), right=True)
cb.handler = self.OnChangeDict
cb.quisk_data_name = 'tx_level'
cb.quisk_band = band
self.NextRow()
# Add transverter offset
if isinstance(transverter_offset, dict):
col += 1
self.row = heading_row
self.AddTextCHelp(col, " Transverter Offset",
"If you use a transverter, you need to tune your hardware to a frequency lower than\
the frequency displayed by Quisk. For example, if you have a 2 meter transverter,\
you may need to tune your hardware from 28 to 30 MHz to receive 144 to 146 MHz.\
Enter the transverter offset in Hertz. For this to work, your\
hardware must support it. Currently, the HiQSDR, SDR-IQ and SoftRock are supported.")
self.row = start_row
for band in band_list:
try:
offset = transverter_offset[band]
except:
offset = ''
else:
offset = str(offset)
cb = self.AddComboCtrl(col, offset, choices=(offset, ), right=True)
cb.handler = self.OnChangeDictBlank
cb.quisk_data_name = 'bandTransverterOffset'
cb.quisk_band = band
self.NextRow()
# Add hiqsdr_bus
if hiqsdr_bus is not None:
bus_text = 'The IO bus is used to select filters for each band. Refer to the documentation for your filter board to see what number to enter.'
col += 1
self.row = heading_row
self.AddTextCHelp(col, " IO Bus", bus_text)
self.row = start_row
for band in band_list:
try:
bus = hiqsdr_bus[band]
except:
bus = ''
bus_choice = ('11', )
else:
bus = str(bus)
bus_choice = (bus, )
cb = self.AddComboCtrl(col, bus, bus_choice, right=True)
cb.handler = self.OnChangeDict
cb.quisk_data_name = 'HiQSDR_BandDict'
cb.quisk_band = band
self.NextRow()
# Add hermes_bus
if hermes_bus is not None:
rx_bus_text = 'The IO bus is used to select filters for each band. Check the bit for a "1", and uncheck the bit for a "0".\
Bits are shown in binary number order. For example, decimal 9 is 0b1001, so check bits 3 and 0.\
Changes are immediate (no need to restart).\
Refer to the documentation for your filter board to see which bits to set. For the Hermes Lite 2 N2ADR filter set:\n\n\
160: 0000001\n\
80: 1000010\n\
60: 1000100\n\
40: 1000100\n\
30: 1001000\n\
20: 1001000\n\
17: 1010000\n\
15: 1010000\n\
12: 1100000\n\
10: 1100000\n\
\n\
If multiple receivers are in use, the Rx filter will be that of the highest frequency band.\
The Rx bits are sent as the "Alex" filters (Protocol 1, address 9) and are sent to the J16 interface.'
tx_bus_text = 'The Rx bits are used for both receive and transmit unless the "Enable" box is checked.\
Then you can specify different filters for Rx and Tx.\n\n\
The Tx bits are sent as the "Alex" filters and are sent to the J16 interface.'
col += 1
self.row = heading_row
self.AddTextCHelp(col, " Rx IO Bus", rx_bus_text)
self.AddTextCHelp(col + 1, " Tx IO Bus", tx_bus_text)
self.row += 1
self.AddTextC(col, "6...Bits...0")
btn = self.AddCheckBox(col + 1, " Enable", self.ChangeIOTxEnable, flag=wx.ALIGN_CENTER|wx.ALIGN_CENTER_VERTICAL)
value = self.GetValue("Hermes_BandDictEnTx", radio_dict)
value = value == 'True'
btn.SetValue(value)
self.row = start_row
try:
hermes_tx_bus = radio_dict['Hermes_BandDictTx']
except:
hermes_tx_bus = {}
for band in band_list:
try:
bus = int(hermes_bus[band])
except:
bus = 0
self.AddBitField(col, 7, 'Hermes_BandDict', band, bus, self.ChangeIO)
try:
bus = int(hermes_tx_bus[band])
except:
bus = 0
self.AddBitField(col + 1, 7, 'Hermes_BandDictTx', band, bus, self.ChangeIO)
self.NextRow()
self.FitInside()
def SortCmp(self, item1):
# Numerical conversion of band name to megahertz
try:
if item1[-2:] == 'cm':
item1 = float(item1[0:-2]) * .01
item1 = 300.0 / item1
elif item1[-1] == 'k':
item1 = float(item1[0:-1]) * .001
else:
item1 = float(item1)
item1 = 300.0 / item1
except:
item1 = 50000.0
return item1
def OnChangeBands(self, ctrl):
band_list = []
count = 0
for cb in self.band_checks:
if cb.IsChecked():
band = cb.GetLabel()
count += 1
if band == '60' and len(conf.freq60) > 1:
band_list.append(('60', ) * len(conf.freq60))
elif band == 'Time' and len(conf.bandTime) > 1:
band_list.append(('Time', ) * len(conf.bandTime))
else:
band_list.append(band)
if count > 14:
dlg = wx.MessageDialog(None,
"There are more than the maximum of 14 bands checked. Please remove some checks.",
'List of Bands', wx.OK|wx.ICON_ERROR)
dlg.ShowModal()
dlg.Destroy()
else:
radio_dict = local_conf.GetRadioDict(self.radio_name)
radio_dict['bandLabels'] = band_list
local_conf.settings_changed = True
def OnChangeBandStart(self, ctrl):
radio_dict = local_conf.GetRadioDict(self.radio_name)
band_edge = radio_dict['BandEdge']
band = ctrl.quisk_band
start, end = band_edge.get(band, (0, 9999))
value = ctrl.GetValue()
if self.FormatOK(value, 'numb'):
start = int(float(value) * 1E6 + 0.1)
band_edge[band] = (start, end)
local_conf.settings_changed = True
def OnChangeBandEnd(self, ctrl):
radio_dict = local_conf.GetRadioDict(self.radio_name)
band_edge = radio_dict['BandEdge']
band = ctrl.quisk_band
start, end = band_edge.get(band, (0, 9999))
value = ctrl.GetValue()
if self.FormatOK(value, 'numb'):
end = int(float(value) * 1E6 + 0.1)
band_edge[band] = (start, end)
local_conf.settings_changed = True
def OnChangeDict(self, ctrl):
radio_dict = local_conf.GetRadioDict(self.radio_name)
dct = radio_dict[ctrl.quisk_data_name]
band = ctrl.quisk_band
value = ctrl.GetValue()
if self.FormatOK(value, 'inte'):
value = int(value)
dct[band] = value
local_conf.settings_changed = True
if ctrl.quisk_data_name == 'tx_level' and hasattr(application.Hardware, "SetTxLevel"):
application.Hardware.SetTxLevel()
def OnChangeDictBlank(self, ctrl):
radio_dict = local_conf.GetRadioDict(self.radio_name)
dct = radio_dict[ctrl.quisk_data_name]
band = ctrl.quisk_band
value = ctrl.GetValue()
value = value.strip()
if not value:
if band in dct:
del dct[band]
local_conf.settings_changed = True
elif self.FormatOK(value, 'inte'):
value = int(value)
dct[band] = value
local_conf.settings_changed = True
def ChangeIO(self, control):
radio_dict = local_conf.GetRadioDict(self.radio_name)
dct = radio_dict[control.quisk_data_name]
band = control.quisk_band
dct[band] = control.value
local_conf.settings_changed = True
if hasattr(application.Hardware, "ChangeBandFilters"):
application.Hardware.ChangeBandFilters()
def ChangeIOTxEnable(self, event):
name = "Hermes_BandDictEnTx"
radio_dict = local_conf.GetRadioDict(self.radio_name)
if event.IsChecked():
radio_dict[name] = "True"
setattr(conf, name, True)
else:
radio_dict[name] = "False"
setattr(conf, name, False)
local_conf.settings_changed = True
if hasattr(application.Hardware, "ImmediateChange"):
application.Hardware.ImmediateChange(name)
class RadioRemote(BaseWindow): # The Remote page in the second-level notebook for each radio
def __init__(self, parent, radio_name, section, names):
BaseWindow.__init__(self, parent)
self.radio_name = radio_name
self.section = section
self.names = names
self.heading_font = wx.Font(conf.config_font_size, wx.FONTFAMILY_SWISS, wx.ITALIC,
wx.FONTWEIGHT_NORMAL, False, conf.quisk_typeface)
self.MakeControls()
def MakeControls(self):
self.num_cols = 8
#self.MarkCols()
self.AddColSpacer(1, 3)
self.NextRow()
self.col = 2
radio_dict = local_conf.GetRadioDict(self.radio_name)
radio_type = radio_dict['hardware_file_type']
heading = None
for name, text, fmt, help_text, values in self.names:
if heading:
if heading not in text: # End of heading
heading = None
self.NextRow()
self.col = 2
if not heading:
heading = self.AddTextHeading("TCI", text,
'Rig control commands and digital sample streams are sent to multiple clients using the TCI protocol.')
if not heading:
heading = self.AddTextHeading("Hamlib Rig 2", text,
'Rig control commands using "Hamlib Rig 2" are sent to a Quisk TCP port from multiple clients.')
if not heading:
heading = self.AddTextHeading("XML-RPC", text,
'XML-RPC is a protocol that allows clients to call methods on a remote server using XML passed via HTTP')
if not heading:
heading = self.AddTextHeading("CAT serial", text,
'"CAT serial" supports the FlexRadio PowerSDR 2.x command set sent over a serial port. Some Kenwood commands are included.')
if not heading:
heading = self.AddTextHeading("remote radio", text,
'Quisk can be used as a control head to control a real radio located remotely. This feature is due to AC2YD.')
if not heading:
heading = self.AddTextHeading("K4 TCP", text,
'Rig control commands using "K4 TCP" use the Elecraft K4 command set, and are sent to a Quisk TCP port from multiple clients.')
if not heading:
heading = self.AddTextHeading("Dx cluster", text,
'"Dx Cluster" is a telnet service used to announce Dx spots in real time.')
if name == 'remote_radio_password':
self.AddTextButtonHelp(self.col, text, "Change", self.OnChangePassword, help_text)
if self.col == 2:
self.col = 5
else:
self.col = 2
self.NextRow()
elif name == 'remote_radio_ip' and radio_type != "Control Head":
continue
else:
if fmt[0:4] in ('dict', 'list'):
continue
if name[0:4] == platform_ignore:
continue
value = self.GetValue(name, radio_dict)
no_edit = "choice" in fmt or fmt == 'boolean'
txt, cb, btn = self.AddTextComboHelp(self.col, text, value, values, help_text, no_edit)
cb.handler = self.OnChange
cb.quisk_data_name = name
if self.col == 2:
self.col = 5
else:
self.col = 2
self.NextRow()
self.NextRow()
self.AddTextL(1, "End of list", span=7)
self.AddColSpacer(3, 20)
self.AddColSpacer(6, 20)
self.FitInside()
def OnChangePassword(self, event):
text = local_conf.globals.get('remote_radio_password', '')
dlg = wx.TextEntryDialog(self, "Please enter a password for remote access",
"Password Entry", text)
if dlg.ShowModal() == wx.ID_OK:
local_conf.globals["remote_radio_password"] = dlg.GetValue()
local_conf.settings_changed = True
local_conf.SaveState()
class xxRadioFilters(BaseWindow): # The Filters page in the second-level notebook for each radio
def __init__(self, parent, radio_name):
BaseWindow.__init__(self, parent)
self.radio_name = radio_name
self.MakeControls()
def MakeControls(self):
radio_dict = local_conf.GetRadioDict(self.radio_name)
self.num_cols = 8
self.NextRow()
bus_text = 'These high-pass and low-pass filters are only available for radios that support the Hermes protocol.\
Enter a frequency range and the control bits for that range. Leave the frequencies blank for unused ranges.\
Place whole bands within the frequency ranges because filters are only changed when changing bands.\
Check the bit for a "1", and uncheck the bit for a "0".\
Bits are shown in binary number order. For example, decimal 9 is 0b1001, so check bits 3 and 0.\
Changes are immediate (no need to restart).\
Refer to the documentation for your filter board to see which bits to set.\
The Rx bits are used for both receive and transmit, unless the "Tx Enable" box is checked.\
Then you can specify different filters for Rx and Tx.\
If multiple receivers are in use, the filters will accommodate the highest and lowest frequencies of all receivers.'
self.AddTextCHelp(1, 'Hermes Protocol: Alex High and Low Pass Filters', bus_text, span=self.num_cols)
self.NextRow()
self.AddTextC(1, 'Start MHz')
self.AddTextC(2, 'End MHz')
self.AddTextC(3, "Alex HPF Rx")
btn = self.AddCheckBox(4, "Alex HPF Tx", self.ChangeEnable, flag=wx.ALIGN_CENTER|wx.ALIGN_CENTER_VERTICAL)
btn.quisk_data_name = "AlexHPF_TxEn"
value = self.GetValue("AlexHPF_TxEn", radio_dict)
value = value == 'True'
btn.SetValue(value)
self.AddTextC(5, 'Start MHz')
self.AddTextC(6, 'End MHz')
self.AddTextC(7, "Alex LPF Rx")
btn = self.AddCheckBox(8, "Alex LPF Tx", self.ChangeEnable, flag=wx.ALIGN_CENTER|wx.ALIGN_CENTER_VERTICAL)
btn.quisk_data_name = "AlexLPF_TxEn"
value = self.GetValue("AlexLPF_TxEn", radio_dict)
value = value == 'True'
btn.SetValue(value)
self.NextRow()
hp_filters = self.GetValue("AlexHPF", radio_dict)
lp_filters = self.GetValue("AlexLPF", radio_dict)
row = self.row
for index in range(len(hp_filters)):
f1, f2, rx, tx = hp_filters[index] # f1 and f2 are strings; rx and tx are integers
cb = self.AddTextCtrl(1, f1, self.OnChangeFreq)
cb.quisk_data_name = "AlexHPF"
cb.index = (index, 0)
cb = self.AddTextCtrl(2, f2, self.OnChangeFreq)
cb.quisk_data_name = "AlexHPF"
cb.index = (index, 1)
bf = self.AddBitField(3, 8, 'AlexHPF', None, rx, self.ChangeBits)
bf.index = (index, 2)
bf = self.AddBitField(4, 8, 'AlexHPF', None, tx, self.ChangeBits)
bf.index = (index, 3)
self.NextRow()
index += 1
self.row = row
for index in range(len(lp_filters)):
f1, f2, rx, tx = lp_filters[index] # f1 and f2 are strings; rx and tx are integers
cb = self.AddTextCtrl(5, f1, self.OnChangeFreq)
cb.quisk_data_name = "AlexLPF"
cb.index = (index, 0)
cb = self.AddTextCtrl(6, f2, self.OnChangeFreq)
cb.quisk_data_name = "AlexLPF"
cb.index = (index, 1)
bf = self.AddBitField(7, 8, 'AlexLPF', None, rx, self.ChangeBits)
bf.index = (index, 2)
bf = self.AddBitField(8, 8, 'AlexLPF', None, tx, self.ChangeBits)
bf.index = (index, 3)
self.NextRow()
index += 1
self.FitInside()
def OnChangeFreq(self, event):
freq = event.GetString()
radio_dict = local_conf.GetRadioDict(self.radio_name)
ctrl = event.GetEventObject()
name = ctrl.quisk_data_name
filters = self.GetValue(name, radio_dict)
filters[ctrl.index[0]][ctrl.index[1]] = freq
setattr(conf, name, filters)
radio_dict[name] = filters
local_conf.settings_changed = True
def ChangeBits(self, control):
radio_dict = local_conf.GetRadioDict(self.radio_name)
name = control.quisk_data_name
filters = self.GetValue(name, radio_dict)
filters[control.index[0]][control.index[1]] = control.value
setattr(conf, name, filters)
radio_dict[name] = filters
local_conf.settings_changed = True
def ChangeEnable(self, event):
btn = event.GetEventObject()
name = btn.quisk_data_name
radio_dict = local_conf.GetRadioDict(self.radio_name)
if event.IsChecked():
radio_dict[name] = "True"
setattr(conf, name, True)
else:
radio_dict[name] = "False"
setattr(conf, name, False)
local_conf.settings_changed = True
class BandPlanDlg(wx.Dialog, ControlMixin):
# BandPlan in the application and the config file is a list of [integer hertz, color] and the color is None for "End".
# BandPlan in Settings[4] (global settings) is a list of [string freq in MHz, mode].
# BandPlanColors is always a list of [mode, color] and the mode "End" is not in the list.
# The color is a string "#aa88cc". The mode is a string "DxData", etc.
def __init__(self, parent):
txt = 'Color Bars on the Frequency X-axis Mark the Band Plan'
wx.Dialog.__init__(self, None, -1, txt, size=(-1, 100))
ControlMixin.__init__(self, parent)
self.Bind(wx.EVT_SHOW, self.OnBug)
bg_color = parent.GetBackgroundColour()
self.SetBackgroundColour(bg_color)
self.parent = parent
self.radio_name = "_Global_"
self.select_index = 0
if "BandPlanColors" in Settings[4] and "BandPlan" in Settings[4]:
colors = Settings[4]["BandPlanColors"]
else:
colors = conf.BandPlanColors
self.modes = []
self.color_dict = {None:"End"}
self.mode_dict = {"End":None}
for mode, color in colors:
self.modes.append(mode)
self.color_dict[color] = mode
self.mode_dict[mode] = color
self.modes.append("End")
self.MakeControls()
def OnBug(self, event): # Bug 16088
self.gbs.Fit(self)
self.Unbind(wx.EVT_SHOW, handler=self.OnBug)
def MakeControls(self):
self.num_cols = 7
#self.MarkCols()
self.BgColor1 = wx.Colour(0xf8f8f8)
self.BgColor2 = wx.Colour(0xe0e0e0)
charx = self.charx
chary = self.chary
self.gbs.Add (charx, chary // 2, wx.GBPosition(self.row, 6)) # Spacer at the right ends control expansion
start_row = self.row
self.list_ctrl = list_ctrl = wx.ListCtrl(self, size=(charx * 36, application.screen_height * 6 // 10),
style=wx.LC_REPORT | wx.LC_SINGLE_SEL | wx.BORDER_SIMPLE | wx.LC_NO_HEADER)
list_ctrl.InsertColumn(0, '', width=charx*16)
list_ctrl.InsertColumn(1, '', width=charx*20)
list_ctrl.SetBackgroundColour(self.BgColor1)
list_ctrl.Bind(wx.EVT_LIST_ITEM_SELECTED, self.OnSelected)
hlp = '\
The graph X-axis has colored bars to mark band segments; CW, phone etc. \
Colors start at each frequency and continue until the next frequency or "End". \
To add a row, enter the frequency that starts the segment. Then press the Enter key. \
It is easier to add all the frequencies for a band first and then correct the modes later.'
txt, edt, btn = self.AddTextEditHelp(3, "New frequency MHz", "", hlp, no_edit=False, border=0)
self.Bind(wx.EVT_TEXT_ENTER, self.OnNewFreq, source=edt)
self.NextRow()
hlp = 'This changes the mode on the selected row. \
The mode begins at the start frequency and ends at the next frequency.'
txt, self.ComboMode, btn = self.AddTextComboHelp(3, "Mode at start frequency", "AM", self.modes, hlp, no_edit=True, border=0)
self.ComboMode.handler = self.OnChangeMode
self.NextRow()
hlp = 'To delete a row, click the row and press this button.'
self.AddTextButtonHelp(3, "Delete frequency", "Delete", self.OnDelete, hlp, border=0)
self.NextRow()
hlp = 'Press "Save" to save your changes. Press "Cancel" to discard your changes.'
self.AddText2ButtonHelp(3, "Save changes", "Save", self.OnSave, "Cancel", self.OnCancel, hlp, border=0)
self.NextRow()
self.gbs.Add (charx, chary, wx.GBPosition(self.row, 3)) # Spacer before color table
self.NextRow()
width = 0
buttons = []
colors = []
for mode in self.modes:
if mode != "End":
colors.append(self.mode_dict[mode])
btn = QuiskPushbutton(self, self.OnColorButton, mode)
btn.SetColorGray()
buttons.append(btn)
width = max(width, btn.GetSize().Width)
h = self.quisk_height + 2
for btn in buttons: # Make all buttons the same size
btn.SetSizeHints(width, h, width, h)
h = self.quisk_height
for i in range(0, len(buttons), 2): # Must be an even number
btn1 = buttons[i]
btn2 = buttons[i + 1]
color1 = wx.StaticText(self, -1, '')
color1.SetSizeHints(h, h, -1, h)
color1.SetBackgroundColour(wx.Colour(colors[i]))
btn1.color_ctrl = color1
color2 = wx.StaticText(self, -1, '')
color2.SetSizeHints(h, h, -1, h)
color2.SetBackgroundColour(wx.Colour(colors[i + 1]))
btn2.color_ctrl = color2
bsizer = wx.BoxSizer(wx.HORIZONTAL)
bsizer.Add(btn1, proportion=0)
bsizer.Add(color1, proportion=1, border=3, flag=wx.ALIGN_CENTER_VERTICAL|wx.LEFT)
bsizer.Add(color2, proportion=1, border=3, flag=wx.ALIGN_CENTER_VERTICAL|wx.LEFT|wx.RIGHT)
bsizer.Add(btn2, proportion=0)
self.gbs.Add(bsizer, (self.row, 3), span=(1, 3), flag=wx.EXPAND)
self.NextRow()
self.NextRow()
self.gbs.Add(list_ctrl, (start_row, 1), span=(self.row, 1))
self.gbs.Add (charx, chary // 2, wx.GBPosition(start_row + self.row, 1)) # Spacer at the bottom
self.DrawPlan()
self.gbs.Fit(self)
def DrawPlan(self):
index = 0
sel = 0
if "BandPlanColors" in Settings[4] and "BandPlan" in Settings[4]:
for freq, mode in Settings[4]["BandPlan"]:
self.list_ctrl.InsertItem(index, freq)
self.list_ctrl.SetItem(index, 1, mode)
if freq == "3.500":
sel = index
index += 1
else:
for freq, color in conf.BandPlan:
mode = self.color_dict.get(color, "Other")
self.list_ctrl.InsertItem(index, FormatMHz(freq * 1E-6))
self.list_ctrl.SetItem(index, 1, mode)
if freq == 3500000:
sel = index
index += 1
self.MakeBackground()
self.list_ctrl.Select(sel)
self.list_ctrl.EnsureVisible(sel)
def OnSelected(self, event):
self.select_index = event.GetIndex()
mode = self.list_ctrl.GetItem(self.select_index, 1).GetText()
j = self.modes.index(mode)
self.ComboMode.SetSelection(j)
def OnChangeMode(self, ctrl):
self.list_ctrl.EnsureVisible(self.select_index)
mode = self.ComboMode.GetValue()
self.list_ctrl.SetItem(self.select_index, 1, mode)
self.MakeBackground()
def MakeBackground(self):
ctrl = self.list_ctrl
color = self.BgColor1
for index in range(ctrl.GetItemCount()):
mode = self.list_ctrl.GetItem(index, 1).GetText()
self.list_ctrl.SetItemBackgroundColour(index, color)
if mode == "End":
if color is self.BgColor1:
color = self.BgColor2
else:
color = self.BgColor1
def OnNewFreq(self, event):
freq = event.GetString()
win = event.GetEventObject()
win.Clear()
try:
freq = float(freq)
hertz = int(freq * 1E6 + 0.1)
except:
return
i1, i2 = self.SearchBandPlan(hertz)
if i1 != i2: # Frequency is not in the list. Add it at i2.
mode = self.ComboMode.GetValue()
self.list_ctrl.InsertItem(i2, FormatMHz(hertz * 1E-6))
self.list_ctrl.SetItem(i2, 1, mode)
self.MakeBackground()
self.list_ctrl.Select(i2)
self.list_ctrl.EnsureVisible(i2)
def SearchBandPlan(self, hertz):
# Binary search for the bracket frequency
ctrl = self.list_ctrl
i1 = 0
i2 = length = ctrl.GetItemCount()
index = (i1 + i2) // 2
for i in range(length):
freq = ctrl.GetItem(index, 0).GetText()
freq = int(float(freq) * 1E6 + 0.1)
diff = freq - hertz
if diff < 0:
i1 = index
elif diff > 0:
i2 = index
else: # equal to an item in the list
return index, index
if i2 - i1 <= 1:
break
index = (i1 + i2) // 2
return i1, i2
def OnDelete(self, event):
self.list_ctrl.DeleteItem(self.select_index)
self.MakeBackground()
if self.select_index > 0:
self.select_index -= 1
self.list_ctrl.Select(self.select_index)
self.list_ctrl.EnsureVisible(self.select_index)
def OnColorButton(self, event):
btn = event.GetEventObject()
mode = btn.GetLabel()
color = wx.Colour(self.mode_dict[mode])
data = wx.ColourData()
data.SetColour(color)
dlg = wx.ColourDialog(self, data)
dlg.GetColourData().SetChooseFull(True)
if dlg.ShowModal() == wx.ID_OK:
color = dlg.GetColourData()
color = color.GetColour()
btn.color_ctrl.SetBackgroundColour(color)
btn.color_ctrl.Refresh()
color = color.GetAsString(wx.C2S_HTML_SYNTAX)
self.mode_dict[mode] = color
self.color_dict[color] = mode
dlg.Destroy()
def OnSave(self, event):
mode_color = []
for mode in self.modes:
if mode != "End":
mode_color.append([mode, self.mode_dict[mode]])
Settings[4]["BandPlanColors"] = mode_color
freq_mode = []
plan = []
ctrl = self.list_ctrl
for index in range(ctrl.GetItemCount()):
freq = ctrl.GetItem(index, 0).GetText()
mode = ctrl.GetItem(index, 1).GetText()
freq_mode.append([freq, mode])
hertz = int(float(freq) * 1E6 + 0.1)
color = self.mode_dict[mode]
plan.append([hertz, color])
Settings[4]["BandPlan"] = freq_mode
application.BandPlan = plan
application.BandPlanC2T = {}
for mode, color in mode_color:
application.BandPlanC2T[color] = mode
local_conf.settings_changed = True
self.EndModal(wx.ID_OK)
def OnCancel(self, event):
self.EndModal(wx.ID_CANCEL)
class WsjtxDlg(wx.Dialog, ControlMixin):
def __init__(self, parent):
txt = 'Configure WSJT-X'
wx.Dialog.__init__(self, None, -1, txt)
ControlMixin.__init__(self, parent)
self.Bind(wx.EVT_SHOW, self.OnBug)
bg_color = parent.GetBackgroundColour()
self.SetBackgroundColour(bg_color)
self.parent = parent
self.radio_name = "_Global_"
self.MakeControls()
def OnBug(self, event): # Bug 16088
self.gbs.Fit(self)
self.Unbind(wx.EVT_SHOW, handler=self.OnBug)
def MakeControls(self):
self.num_cols = 10
#self.MarkCols()
charx = self.charx
chary = self.chary
self.gbs.Add (charx * 3, chary * 1, wx.GBPosition(self.row, 9)) # Spacer at the top right
self.NextRow()
# Path to WSJT-X
path = local_conf.globals.get('path_to_wsjtx', '')
help_text = "Leave blank for the usual installation path to WSJT-X. If WSJT-X is not in the usual place, enter the path."
txt, self.edit_path, btn = self.AddTextEditHelp(1, "Path to Wsjt-x", path, help_text, no_edit=False, span2=5, border=0)
self.Bind(wx.EVT_TEXT_ENTER, self.OnEditPath, source=self.edit_path)
item = self.AddPushButtonR(8, "Change..", self.OnChangePath, border=0)
self.NextRow()
self.NextRow()
# Configuration name option
value = local_conf.globals.get('config_wsjtx', '')
hlp = '\
This is the "--config" option used to specify a configuration when WSJT-X starts. It is normally left blank.'
txt, edt, btn = self.AddTextEditHelp(1, "Config name option", value, hlp, no_edit=False, border=0)
edt.SetSizeHints(charx * 20, -1, -1, -1)
self.Bind(wx.EVT_TEXT_ENTER, self.OnConfigName, source=edt)
self.gbs.Add (charx * 3, chary // 2, wx.GBPosition(self.row, 4)) # Middle spacer
# Rig name option
value = local_conf.globals.get('rig_name_wsjtx', 'quisk')
hlp = '\
When WSJT-X starts, it uses a rig name to keep different instances separate. \
This is the "--rig-name" option, and it defaults to "quisk".'
txt, edt, btn = self.AddTextEditHelp(5, "Rig name option", value, hlp, no_edit=False, border=0)
self.Bind(wx.EVT_TEXT_ENTER, self.OnConfigRigName, source=edt)
self.NextRow()
self.NextRow()
# End of controls
self.gbs.Add (charx, chary * 2, wx.GBPosition(self.row, 1)) # Spacer at the bottom
self.gbs.Fit(self)
def OnConfigName(self, event):
value = event.GetString()
value = value.strip()
local_conf.globals['config_wsjtx'] = value
local_conf.settings_changed = True
def OnConfigRigName(self, event):
value = event.GetString()
value = value.strip()
local_conf.globals['rig_name_wsjtx'] = value
local_conf.settings_changed = True
def OnChangePath(self, event):
path = self.edit_path.GetValue()
path = path.strip()
if not path:
if sys.platform == 'win32':
path = "C:\\WSJT\\wsjtx\\bin\\wsjtx.exe"
else:
path = "/usr/bin/wsjtx"
direc, fname = os.path.split(path)
dlg = wx.FileDialog(application.main_frame, "Path to WSJT-X", direc, fname, "", wx.FD_OPEN|wx.FD_FILE_MUST_EXIST)
if dlg.ShowModal() == wx.ID_OK:
path = dlg.GetPath()
path = path.strip()
self.edit_path.SetValue(path)
local_conf.globals['path_to_wsjtx'] = path
local_conf.settings_changed = True
dlg.Destroy()
def OnEditPath(self, event):
path = self.edit_path.GetValue()
path = path.strip()
local_conf.globals['path_to_wsjtx'] = path
local_conf.settings_changed = True
Reference in New Issue View Git Blame Copy Permalink