class FreqUnits(QWidget):
"""
Build and update widget for entering frequency unit, frequency range and
sampling frequency f_S
The following key-value pairs of the `fb.fil[0]` dict are modified:
- `'freq_specs_unit'` : The unit ('k', 'f_S', 'f_Ny', 'Hz' etc.) as a string
- `'freqSpecsRange'` : A list with two entries for minimum and maximum frequency
values for labelling the frequency axis
- `'f_S'` : The sampling frequency for referring frequency values to as a float
- `'f_max'` : maximum frequency for scaling frequency axis
- `'plt_fUnit'`: frequency unit as string
- `'plt_tUnit'`: time unit as string
- `'plt_fLabel'`: label for frequency axis
- `'plt_tLabel'`: label for time axis
"""
# class variables (shared between instances if more than one exists)
sig_tx = pyqtSignal(object) # outgoing
from pyfda.libs.pyfda_qt_lib import emit
def __init__(self, parent=None, title="Frequency Units"):
super(FreqUnits, self).__init__(parent)
self.title = title
self.spec_edited = False # flag whether QLineEdit field has been edited
self._construct_UI()
def _construct_UI(self):
"""
Construct the User Interface
"""
self.layVMain = QVBoxLayout() # Widget main layout
f_units = ['k', 'f_S', 'f_Ny', 'Hz', 'kHz', 'MHz', 'GHz']
self.t_units = ['', 'T_S', 'T_S', 's', 'ms', r'$\mu$s', 'ns']
bfont = QFont()
bfont.setBold(True)
self.lblUnits = QLabel(self)
self.lblUnits.setText("Freq. Unit")
self.lblUnits.setFont(bfont)
self.fs_old = fb.fil[0]['f_S'] # store current sampling frequency
self.lblF_S = QLabel(self)
self.lblF_S.setText(to_html("f_S =", frmt='bi'))
self.ledF_S = QLineEdit()
self.ledF_S.setText(str(fb.fil[0]["f_S"]))
self.ledF_S.setObjectName("f_S")
self.ledF_S.installEventFilter(self) # filter events
self.butLock = QToolButton(self)
self.butLock.setIcon(QIcon(':/lock-unlocked.svg'))
self.butLock.setCheckable(True)
self.butLock.setChecked(False)
self.butLock.setToolTip(
"<span><b>Unlocked:</b> When f_S is changed, all frequency related "
"widgets are updated, normalized frequencies stay the same.<br />"
"<b>Locked:</b> When f_S is changed, displayed absolute frequency "
"values don't change but normalized frequencies do.</span>")
# self.butLock.setStyleSheet("QToolButton:checked {font-weight:bold}")
layHF_S = QHBoxLayout()
layHF_S.addWidget(self.ledF_S)
layHF_S.addWidget(self.butLock)
self.cmbUnits = QComboBox(self)
self.cmbUnits.setObjectName("cmbUnits")
self.cmbUnits.addItems(f_units)
self.cmbUnits.setToolTip(
'Select whether frequencies are specified w.r.t. \n'
'the sampling frequency "f_S", to the Nyquist frequency \n'
'f_Ny = f_S/2 or as absolute values. "k" specifies frequencies w.r.t. f_S '
'but plots graphs over the frequency index k.')
self.cmbUnits.setCurrentIndex(1)
# self.cmbUnits.setItemData(0, (0,QColor("#FF333D"),Qt.BackgroundColorRole))#
# self.cmbUnits.setItemData(0, (QFont('Verdana', bold=True), Qt.FontRole)
fRanges = [("0...½", "half"), ("0...1", "whole"), ("-½...½", "sym")]
self.cmbFRange = QComboBox(self)
self.cmbFRange.setObjectName("cmbFRange")
for f in fRanges:
self.cmbFRange.addItem(f[0], f[1])
self.cmbFRange.setToolTip("Select frequency range (whole or half).")
self.cmbFRange.setCurrentIndex(0)
# Combobox resizes with longest entry
self.cmbUnits.setSizeAdjustPolicy(QComboBox.AdjustToContents)
self.cmbFRange.setSizeAdjustPolicy(QComboBox.AdjustToContents)
self.butSort = QToolButton(self)
self.butSort.setText("Sort")
self.butSort.setIcon(QIcon(':/sort-ascending.svg'))
#self.butDelCells.setIconSize(q_icon_size)
self.butSort.setCheckable(True)
self.butSort.setChecked(True)
self.butSort.setToolTip(
"Sort frequencies in ascending order when pushed.")
self.butSort.setStyleSheet("QToolButton:checked {font-weight:bold}")
self.layHUnits = QHBoxLayout()
self.layHUnits.addWidget(self.cmbUnits)
self.layHUnits.addWidget(self.cmbFRange)
self.layHUnits.addWidget(self.butSort)
# Create a gridLayout consisting of QLabel and QLineEdit fields
# for setting f_S, the units and the actual frequency specs:
self.layGSpecWdg = QGridLayout() # sublayout for spec fields
self.layGSpecWdg.addWidget(self.lblF_S, 1, 0)
# self.layGSpecWdg.addWidget(self.ledF_S,1,1)
self.layGSpecWdg.addLayout(layHF_S, 1, 1)
self.layGSpecWdg.addWidget(self.lblUnits, 0, 0)
self.layGSpecWdg.addLayout(self.layHUnits, 0, 1)
frmMain = QFrame(self)
frmMain.setLayout(self.layGSpecWdg)
self.layVMain.addWidget(frmMain)
self.layVMain.setContentsMargins(*params['wdg_margins'])
self.setLayout(self.layVMain)
#----------------------------------------------------------------------
# LOCAL SIGNALS & SLOTs
#----------------------------------------------------------------------
self.cmbUnits.currentIndexChanged.connect(self.update_UI)
self.butLock.clicked.connect(self._lock_freqs)
self.cmbFRange.currentIndexChanged.connect(self._freq_range)
self.butSort.clicked.connect(self._store_sort_flag)
# ----------------------------------------------------------------------
self.update_UI() # first-time initialization
# -------------------------------------------------------------
def _lock_freqs(self):
"""
Lock / unlock frequency entries: The values of frequency related widgets
are stored in normalized form (w.r.t. sampling frequency)`fb.fil[0]['f_S']`.
When the sampling frequency changes, absolute frequencies displayed in the
widgets change their values. Most of the time, this is the desired behaviour,
the properties of discrete time systems or signals are usually defined
by the normalized frequencies.
When the effect of varying the sampling frequency is to be analyzed, the
displayed values in the widgets can be locked by pressing the Lock button.
After changing the sampling frequency, normalized frequencies have to be
rescaled like `f_a *= fb.fil[0]['f_S_prev'] / fb.fil[0]['f_S']` to maintain
the displayed value `f_a * f_S`.
This has to be accomplished by each frequency widget (currently, these are
freq_specs and freq_units).
The setting is stored as bool in the global dict entry `fb.fil[0]['freq_locked'`,
the signal 'view_changed':'f_S' is emitted.
"""
if self.butLock.isChecked():
# Lock has been activated, keep displayed frequencies locked
fb.fil[0]['freq_locked'] = True
self.butLock.setIcon(QIcon(':/lock-locked.svg'))
else:
# Lock has been unlocked, scale displayed frequencies with f_S
fb.fil[0]['freq_locked'] = False
self.butLock.setIcon(QIcon(':/lock-unlocked.svg'))
self.emit({'view_changed': 'f_S'})
# -------------------------------------------------------------
def update_UI(self):
"""
update_UI is called
- during init
- when the unit combobox is changed
Set various scale factors and labels depending on the setting of the unit
combobox.
Update the freqSpecsRange and finally, emit 'view_changed':'f_S' signal
"""
f_unit = str(self.cmbUnits.currentText()) # selected frequency unit
idx = self.cmbUnits.currentIndex() # and its index
is_normalized_freq = f_unit in {"f_S", "f_Ny", "k"}
self.ledF_S.setVisible(not is_normalized_freq) # only vis. when
self.lblF_S.setVisible(not is_normalized_freq) # not normalized
self.butLock.setVisible(not is_normalized_freq)
f_S_scale = 1 # default setting for f_S scale
if is_normalized_freq:
# store current sampling frequency to restore it when returning to
# unnormalized frequencies
self.fs_old = fb.fil[0]['f_S']
if f_unit == "f_S": # normalized to f_S
fb.fil[0]['f_S'] = fb.fil[0]['f_max'] = 1.
fb.fil[0]['T_S'] = 1.
f_label = r"$F = f\, /\, f_S = \Omega \, /\, 2 \mathrm{\pi} \; \rightarrow$"
t_label = r"$n = t\, /\, T_S \; \rightarrow$"
elif f_unit == "f_Ny": # normalized to f_nyq = f_S / 2
fb.fil[0]['f_S'] = fb.fil[0]['f_max'] = 2.
fb.fil[0]['T_S'] = 1.
f_label = r"$F = 2f \, / \, f_S = \Omega \, / \, \mathrm{\pi} \; \rightarrow$"
t_label = r"$n = t\, /\, T_S \; \rightarrow$"
else: # frequency index k,
fb.fil[0]['f_S'] = 1.
fb.fil[0]['T_S'] = 1.
fb.fil[0]['f_max'] = params['N_FFT']
f_label = r"$k \; \rightarrow$"
t_label = r"$n\; \rightarrow$"
self.ledF_S.setText(params['FMT'].format(fb.fil[0]['f_S']))
else: # Hz, kHz, ...
# Restore sampling frequency when returning from f_S / f_Ny / k
if fb.fil[0]['freq_specs_unit'] in {
"f_S", "f_Ny", "k"
}: # previous setting normalized?
fb.fil[0]['f_S'] = fb.fil[0][
'f_max'] = self.fs_old # yes, restore prev.
fb.fil[0][
'T_S'] = 1. / self.fs_old # settings for sampling frequency
self.ledF_S.setText(params['FMT'].format(fb.fil[0]['f_S']))
if f_unit == "Hz":
f_S_scale = 1.
elif f_unit == "kHz":
f_S_scale = 1.e3
elif f_unit == "MHz":
f_S_scale = 1.e6
elif f_unit == "GHz":
f_S_scale = 1.e9
else:
logger.warning("Unknown frequency unit {0}".format(f_unit))
f_label = r"$f$ in " + f_unit + r"$\; \rightarrow$"
t_label = r"$t$ in " + self.t_units[idx] + r"$\; \rightarrow$"
if f_unit == "k":
plt_f_unit = "f_S"
else:
plt_f_unit = f_unit
fb.fil[0].update({'f_S_scale':
f_S_scale}) # scale factor for f_S (Hz, kHz, ...)
fb.fil[0].update({'freq_specs_unit': f_unit}) # frequency unit
# time and frequency unit as string e.g. for plot axis labeling
fb.fil[0].update({"plt_fUnit": plt_f_unit})
fb.fil[0].update({"plt_tUnit": self.t_units[idx]})
# complete plot axis labels including unit and arrow
fb.fil[0].update({"plt_fLabel": f_label})
fb.fil[0].update({"plt_tLabel": t_label})
self._freq_range(
emit=False) # update f_lim setting without emitting signal
self.emit({'view_changed': 'f_S'})
# ------------------------------------------------------------------------------
def eventFilter(self, source, event):
"""
Filter all events generated by the QLineEdit `f_S` widget. Source and type
of all events generated by monitored objects are passed to this eventFilter,
evaluated and passed on to the next hierarchy level.
- When a QLineEdit widget gains input focus (QEvent.FocusIn`), display
the stored value from filter dict with full precision
- When a key is pressed inside the text field, set the `spec_edited` flag
to True.
- When a QLineEdit widget loses input focus (QEvent.FocusOut`), store
current value with full precision (only if `spec_edited`== True) and
display the stored value in selected format. Emit 'view_changed':'f_S'
"""
def _store_entry():
"""
Update filter dictionary, set line edit entry with reduced precision
again.
"""
if self.spec_edited:
fb.fil[0].update({'f_S_prev': fb.fil[0]['f_S']})
fb.fil[0].update({
'f_S':
safe_eval(source.text(), fb.fil[0]['f_S'], sign='pos')
})
fb.fil[0].update({'T_S': 1. / fb.fil[0]['f_S']})
fb.fil[0].update({'f_max': fb.fil[0]['f_S']})
self._freq_range(emit=False) # update plotting range
self.emit({'view_changed': 'f_S'})
self.spec_edited = False # reset flag, changed entry has been saved
if source.objectName() == 'f_S':
if event.type() == QEvent.FocusIn:
self.spec_edited = False
source.setText(str(fb.fil[0]['f_S'])) # full precision
elif event.type() == QEvent.KeyPress:
self.spec_edited = True # entry has been changed
key = event.key()
if key in {QtCore.Qt.Key_Return, QtCore.Qt.Key_Enter}:
_store_entry()
elif key == QtCore.Qt.Key_Escape: # revert changes
self.spec_edited = False
source.setText(str(fb.fil[0]['f_S'])) # full precision
elif event.type() == QEvent.FocusOut:
_store_entry()
source.setText(params['FMT'].format(
fb.fil[0]['f_S'])) # reduced prec.
# Call base class method to continue normal event processing:
return super(FreqUnits, self).eventFilter(source, event)
# -------------------------------------------------------------
def _freq_range(self, emit=True):
"""
Set frequency plotting range for single-sided spectrum up to f_S/2 or f_S
or for double-sided spectrum between -f_S/2 and f_S/2
Emit 'view_changed':'f_range' when `emit=True`
"""
if type(emit) == int: # signal was emitted by combobox
emit = True
rangeType = qget_cmb_box(self.cmbFRange)
fb.fil[0].update({'freqSpecsRangeType': rangeType})
f_max = fb.fil[0]["f_max"]
if rangeType == 'whole':
f_lim = [0, f_max]
elif rangeType == 'sym':
f_lim = [-f_max / 2., f_max / 2.]
else:
f_lim = [0, f_max / 2.]
fb.fil[0]['freqSpecsRange'] = f_lim # store settings in dict
if emit:
self.emit({'view_changed': 'f_range'})
# -------------------------------------------------------------
def load_dict(self):
"""
Reload comboBox settings and textfields from filter dictionary
Block signals during update of combobox / lineedit widgets
"""
self.ledF_S.setText(params['FMT'].format(fb.fil[0]['f_S']))
self.cmbUnits.blockSignals(True)
idx = self.cmbUnits.findText(
fb.fil[0]['freq_specs_unit']) # get and set
self.cmbUnits.setCurrentIndex(idx) # index for freq. unit combo box
self.cmbUnits.blockSignals(False)
self.cmbFRange.blockSignals(True)
idx = self.cmbFRange.findData(fb.fil[0]['freqSpecsRangeType'])
self.cmbFRange.setCurrentIndex(idx) # set frequency range
self.cmbFRange.blockSignals(False)
self.butSort.blockSignals(True)
self.butSort.setChecked(fb.fil[0]['freq_specs_sort'])
self.butSort.blockSignals(False)
# -------------------------------------------------------------
def _store_sort_flag(self):
"""
Store sort flag in filter dict and emit 'specs_changed':'f_sort'
when sort button is checked.
"""
fb.fil[0]['freq_specs_sort'] = self.butSort.isChecked()
if self.butSort.isChecked():
self.emit({'specs_changed': 'f_sort'})
def _construct_UI(self):
"""
Intitialize the widget, consisting of:
- Checkboxes for selecting the info to be displayed
- A large text window for displaying infos about the filter design
algorithm
"""
bfont = QFont()
bfont.setBold(True)
# ============== UI Layout =====================================
# widget / subwindow for filter infos
# self.butFiltPerf = QToolButton("H(f)", self)
self.butFiltPerf = QPushButton(self)
self.butFiltPerf.setText("H(f)")
self.butFiltPerf.setCheckable(True)
self.butFiltPerf.setChecked(True)
self.butFiltPerf.setToolTip("Display frequency response at test frequencies.")
self.butDebug = QPushButton(self)
self.butDebug.setText("Debug")
self.butDebug.setCheckable(True)
self.butDebug.setChecked(False)
self.butDebug.setToolTip("Show debugging options.")
self.butAbout = QPushButton("About", self) # pop-up "About" window
self.butSettings = QPushButton("Settings", self) #
self.butSettings.setCheckable(True)
self.butSettings.setChecked(False)
self.butSettings.setToolTip("Display and set some settings")
layHControls1 = QHBoxLayout()
layHControls1.addWidget(self.butFiltPerf)
layHControls1.addWidget(self.butAbout)
layHControls1.addWidget(self.butSettings)
layHControls1.addWidget(self.butDebug)
self.butDocstring = QPushButton("Doc$", self)
self.butDocstring.setCheckable(True)
self.butDocstring.setChecked(False)
self.butDocstring.setToolTip("Display docstring from python filter method.")
self.butRichText = QPushButton("RTF", self)
self.butRichText.setCheckable(HAS_DOCUTILS)
self.butRichText.setChecked(HAS_DOCUTILS)
self.butRichText.setEnabled(HAS_DOCUTILS)
self.butRichText.setToolTip("Render documentation in Rich Text Format.")
self.butFiltDict = QPushButton("FiltDict", self)
self.butFiltDict.setToolTip("Show filter dictionary for debugging.")
self.butFiltDict.setCheckable(True)
self.butFiltDict.setChecked(False)
self.butFiltTree = QPushButton("FiltTree", self)
self.butFiltTree.setToolTip("Show filter tree for debugging.")
self.butFiltTree.setCheckable(True)
self.butFiltTree.setChecked(False)
layHControls2 = QHBoxLayout()
layHControls2.addWidget(self.butDocstring)
# layHControls2.addStretch(1)
layHControls2.addWidget(self.butRichText)
# layHControls2.addStretch(1)
layHControls2.addWidget(self.butFiltDict)
# layHControls2.addStretch(1)
layHControls2.addWidget(self.butFiltTree)
self.frmControls2 = QFrame(self)
self.frmControls2.setLayout(layHControls2)
self.frmControls2.setVisible(self.butDebug.isChecked())
self.frmControls2.setContentsMargins(0, 0, 0, 0)
lbl_settings_NFFT = QLabel(to_html("N_FFT =", frmt='bi'), self)
self.led_settings_NFFT = QLineEdit(self)
self.led_settings_NFFT.setText(str(params['N_FFT']))
self.led_settings_NFFT.setToolTip("<span>Number of FFT points for frequency "
"domain widgets.</span>")
layGSettings = QGridLayout()
layGSettings.addWidget(lbl_settings_NFFT, 1, 0)
layGSettings.addWidget(self.led_settings_NFFT, 1, 1)
self.frmSettings = QFrame(self)
self.frmSettings.setLayout(layGSettings)
self.frmSettings.setVisible(self.butSettings.isChecked())
self.frmSettings.setContentsMargins(0, 0, 0, 0)
layVControls = QVBoxLayout()
layVControls.addLayout(layHControls1)
layVControls.addWidget(self.frmControls2)
layVControls.addWidget(self.frmSettings)
self.frmMain = QFrame(self)
self.frmMain.setLayout(layVControls)
self.tblFiltPerf = QTableWidget(self)
self.tblFiltPerf.setAlternatingRowColors(True)
# self.tblFiltPerf.verticalHeader().setVisible(False)
self.tblFiltPerf.horizontalHeader().setHighlightSections(False)
self.tblFiltPerf.horizontalHeader().setFont(bfont)
self.tblFiltPerf.verticalHeader().setHighlightSections(False)
self.tblFiltPerf.verticalHeader().setFont(bfont)
self.txtFiltInfoBox = QTextBrowser(self)
self.txtFiltDict = QTextBrowser(self)
self.txtFiltTree = QTextBrowser(self)
layVMain = QVBoxLayout()
layVMain.addWidget(self.frmMain)
# layVMain.addLayout(self.layHControls)
splitter = QSplitter(self)
splitter.setOrientation(Qt.Vertical)
splitter.addWidget(self.tblFiltPerf)
splitter.addWidget(self.txtFiltInfoBox)
splitter.addWidget(self.txtFiltDict)
splitter.addWidget(self.txtFiltTree)
# setSizes uses absolute pixel values, but can be "misused" by specifying values
# that are way too large: in this case, the space is distributed according
# to the _ratio_ of the values:
splitter.setSizes([3000, 10000, 1000, 1000])
layVMain.addWidget(splitter)
layVMain.setContentsMargins(*params['wdg_margins'])
self.setLayout(layVMain)
# ----------------------------------------------------------------------
# GLOBAL SIGNALS & SLOTs
# ----------------------------------------------------------------------
self.sig_rx.connect(self.process_sig_rx)
# ----------------------------------------------------------------------
# LOCAL SIGNALS & SLOTs
# ----------------------------------------------------------------------
self.butFiltPerf.clicked.connect(self._show_filt_perf)
self.butAbout.clicked.connect(self._about_window)
self.butSettings.clicked.connect(self._show_settings)
self.led_settings_NFFT.editingFinished.connect(self._update_settings_nfft)
self.butDebug.clicked.connect(self._show_debug)
self.butFiltDict.clicked.connect(self._show_filt_dict)
self.butFiltTree.clicked.connect(self._show_filt_tree)
self.butDocstring.clicked.connect(self._show_doc)
self.butRichText.clicked.connect(self._show_doc)
def _construct_UI(self):
"""
Intitialize the widget, consisting of:
- top chkbox row
- coefficient table
- two bottom rows with action buttons
"""
self.bfont = QFont()
self.bfont.setBold(True)
self.bifont = QFont()
self.bifont.setBold(True)
self.bifont.setItalic(True)
# q_icon_size = QSize(20, 20) # optional, size is derived from butEnable
#######################################################################
# frmMain
#
# This frame contains all the buttons
#######################################################################
# ---------------------------------------------
# layHDisplay
#
# UI Elements for controlling the display
# ---------------------------------------------
self.butEnable = PushButton(self, icon=QIcon(':/circle-check.svg'), checked=True)
q_icon_size = self.butEnable.iconSize() # <- uncomment this for manual sizing
self.butEnable.setToolTip(
"<span>Show / hide filter coefficients in an editable table."
" For high order systems, table display might be slow.</span>")
fix_formats = ['Dec', 'Hex', 'Bin', 'CSD']
self.cmbFormat = QComboBox(self)
model = self.cmbFormat.model()
item = QtGui.QStandardItem('Float')
item.setData('child', Qt.AccessibleDescriptionRole)
model.appendRow(item)
item = QtGui.QStandardItem('Fixp.:')
item.setData('parent', Qt.AccessibleDescriptionRole)
item.setData(0, QtGui.QFont.Bold)
item.setFlags(item.flags() & ~Qt.ItemIsEnabled) # | Qt.ItemIsSelectable))
model.appendRow(item)
for idx in range(len(fix_formats)):
item = QtGui.QStandardItem(fix_formats[idx])
# item.setForeground(QtGui.QColor('red'))
model.appendRow(item)
self.cmbFormat.insertSeparator(1)
qset_cmb_box(self.cmbFormat, 'float')
self.cmbFormat.setToolTip('Set the display format.')
self.cmbFormat.setSizeAdjustPolicy(QComboBox.AdjustToContents)
self.spnDigits = QSpinBox(self)
self.spnDigits.setRange(0, 16)
self.spnDigits.setValue(params['FMT_ba'])
self.spnDigits.setToolTip("Number of digits to display.")
self.lblDigits = QLabel("Digits", self)
self.lblDigits.setFont(self.bifont)
self.cmbQFrmt = QComboBox(self)
q_formats = [('Norm. Frac.', 'qnfrac'), ('Integer', 'qint'),
('Fractional', 'qfrac')]
for q in q_formats:
self.cmbQFrmt.addItem(*q)
self.lbl_W = QLabel("W = ", self)
self.lbl_W.setFont(self.bifont)
self.ledW = QLineEdit(self)
self.ledW.setToolTip("Specify total wordlength.")
self.ledW.setText("16")
self.ledW.setMaxLength(2) # maximum of 2 digits
self.ledW.setFixedWidth(30) # width of lineedit in points(?)
layHDisplay = QHBoxLayout()
layHDisplay.setAlignment(Qt.AlignLeft)
layHDisplay.addWidget(self.butEnable)
layHDisplay.addWidget(self.cmbFormat)
layHDisplay.addWidget(self.spnDigits)
layHDisplay.addWidget(self.lblDigits)
layHDisplay.addWidget(self.cmbQFrmt)
layHDisplay.addWidget(self.lbl_W)
layHDisplay.addWidget(self.ledW)
layHDisplay.addStretch()
#######################################################################
# frmButtonsCoeffs
#
# This frame contains all buttons for manipulating coefficients
#######################################################################
# -----------------------------------------------------------------
# layHButtonsCoeffs1
#
# UI Elements for loading / storing / manipulating cells and rows
# -----------------------------------------------------------------
self.cmbFilterType = QComboBox(self)
self.cmbFilterType.setObjectName("comboFilterType")
self.cmbFilterType.setToolTip(
"<span>Select between IIR and FIR filter for manual entry."
"Changing the type reloads the filter from the filter dict.</span>")
self.cmbFilterType.addItems(["FIR", "IIR"])
self.cmbFilterType.setSizeAdjustPolicy(QComboBox.AdjustToContents)
self.butAddCells = QPushButton(self)
self.butAddCells.setIcon(QIcon(':/row_insert_above.svg'))
self.butAddCells.setIconSize(q_icon_size)
self.butAddCells.setToolTip(
"<span>Select cells to insert a new cell above each selected cell. "
"Use <SHIFT> or <CTRL> to select multiple cells. "
"When nothing is selected, add a row at the end.</span>")
self.butDelCells = QPushButton(self)
self.butDelCells.setIcon(QIcon(':/row_delete.svg'))
self.butDelCells.setIconSize(q_icon_size)
self.butDelCells.setToolTip(
"<span>Delete selected cell(s) from the table. "
"Use <SHIFT> or <CTRL> to select multiple cells. "
"When nothing is selected, delete the last row.</span>")
self.butSave = QPushButton(self)
self.butSave.setIcon(QIcon(':/upload.svg'))
self.butSave.setIconSize(q_icon_size)
self.butSave.setToolTip(
"<span>Copy coefficient table to filter dict and update all plots"
"and widgets.</span>")
self.butLoad = QPushButton(self)
self.butLoad.setIcon(QIcon(':/download.svg'))
self.butLoad.setIconSize(q_icon_size)
self.butLoad.setToolTip("Reload coefficient table from filter dict.")
self.butClear = QPushButton(self)
self.butClear.setIcon(QIcon(':/trash.svg'))
self.butClear.setIconSize(q_icon_size)
self.butClear.setToolTip("Clear all table entries.")
self.butFromTable = QPushButton(self)
self.butFromTable.setIconSize(q_icon_size)
self.butToTable = QPushButton(self)
self.butToTable.setIconSize(q_icon_size)
self.but_csv_options = PushButton(self, icon=QIcon(':/settings.svg'),
checked=False)
self.but_csv_options.setIconSize(q_icon_size)
self.but_csv_options.setToolTip(
"<span>Select CSV format and whether "
"to copy to/from clipboard or file.</span>")
self._set_load_save_icons() # initialize icon / button settings
layHButtonsCoeffs1 = QHBoxLayout()
layHButtonsCoeffs1.addWidget(self.cmbFilterType)
layHButtonsCoeffs1.addWidget(self.butAddCells)
layHButtonsCoeffs1.addWidget(self.butDelCells)
layHButtonsCoeffs1.addWidget(self.butClear)
layHButtonsCoeffs1.addWidget(self.butSave)
layHButtonsCoeffs1.addWidget(self.butLoad)
layHButtonsCoeffs1.addWidget(self.butFromTable)
layHButtonsCoeffs1.addWidget(self.butToTable)
layHButtonsCoeffs1.addWidget(self.but_csv_options)
layHButtonsCoeffs1.addStretch()
# ----------------------------------------------------------------------
# layHButtonsCoeffs2
#
# Eps / set zero settings
# ---------------------------------------------------------------------
self.butSetZero = QPushButton("= 0", self)
self.butSetZero.setToolTip(
"<span>Set selected coefficients = 0 with a magnitude < ε. "
"When nothing is selected, test the whole table.</span>")
self.butSetZero.setIconSize(q_icon_size)
lblEps = QLabel(self)
lblEps.setText("<b><i>for b, a</i> <</b>")
self.ledEps = QLineEdit(self)
self.ledEps.setToolTip("Specify tolerance value.")
layHButtonsCoeffs2 = QHBoxLayout()
layHButtonsCoeffs2.addWidget(self.butSetZero)
layHButtonsCoeffs2.addWidget(lblEps)
layHButtonsCoeffs2.addWidget(self.ledEps)
layHButtonsCoeffs2.addStretch()
# -------------------------------------------------------------------
# Now put the ButtonsCoeffs HBoxes into frmButtonsCoeffs
# ---------------------------------------------------------------------
layVButtonsCoeffs = QVBoxLayout()
layVButtonsCoeffs.addLayout(layHButtonsCoeffs1)
layVButtonsCoeffs.addLayout(layHButtonsCoeffs2)
layVButtonsCoeffs.setContentsMargins(0, 5, 0, 0)
# This frame encompasses all Quantization Settings
self.frmButtonsCoeffs = QFrame(self)
self.frmButtonsCoeffs.setLayout(layVButtonsCoeffs)
# ######################################################################
# frmQSettings
#
# This frame contains all quantization settings
# ######################################################################
# -------------------------------------------------------------------
# layHW_Scale
#
# QFormat and scale settings
# ---------------------------------------------------------------------
lbl_Q = QLabel("Q =", self)
lbl_Q.setFont(self.bifont)
self.ledWI = QLineEdit(self)
self.ledWI.setToolTip("Specify number of integer bits.")
self.ledWI.setText("0")
self.ledWI.setMaxLength(2) # maximum of 2 digits
self.ledWI.setFixedWidth(30) # width of lineedit in points(?)
self.lblDot = QLabel(".", self) # class attribute, visibility is toggled
self.lblDot.setFont(self.bfont)
self.ledWF = QLineEdit(self)
self.ledWF.setToolTip("Specify number of fractional bits.")
self.ledWF.setText("15")
self.ledWF.setMaxLength(2) # maximum of 2 digits
# self.ledWF.setFixedWidth(30) # width of lineedit in points(?)
self.ledWF.setMaximumWidth(30)
self.lblScale = QLabel("<b><i>Scale</i> =</b>", self)
self.ledScale = QLineEdit(self)
self.ledScale.setToolTip(
"Set the scale for converting float to fixpoint representation.")
self.ledScale.setText(str(1))
self.ledScale.setEnabled(False)
layHWI_WF = QHBoxLayout()
layHWI_WF.addWidget(lbl_Q)
layHWI_WF.addWidget(self.ledWI)
layHWI_WF.addWidget(self.lblDot)
layHWI_WF.addWidget(self.ledWF)
layHWI_WF.addStretch()
layHScale = QHBoxLayout()
layHScale.addWidget(self.lblScale)
layHScale.addWidget(self.ledScale)
layHScale.addStretch()
layHW_Scale = QHBoxLayout()
layHW_Scale.addLayout(layHWI_WF)
layHW_Scale.addLayout(layHScale)
# -------------------------------------------------------------------
# layGQOpt
#
# Quantization / Overflow / MSB / LSB settings
# ---------------------------------------------------------------------
lblQOvfl = QLabel("Ovfl.:", self)
lblQOvfl.setFont(self.bifont)
lblQuant = QLabel("Quant.:", self)
lblQuant.setFont(self.bifont)
self.cmbQOvfl = QComboBox(self)
qOvfl = ['wrap', 'sat']
self.cmbQOvfl.addItems(qOvfl)
qset_cmb_box(self.cmbQOvfl, 'sat')
self.cmbQOvfl.setToolTip("Select overflow behaviour.")
# ComboBox size is adjusted automatically to fit the longest element
self.cmbQOvfl.setSizeAdjustPolicy(QComboBox.AdjustToContents)
layHQOvflOpt = QHBoxLayout()
layHQOvflOpt.addWidget(lblQOvfl)
layHQOvflOpt.addWidget(self.cmbQOvfl)
layHQOvflOpt.addStretch()
self.cmbQuant = QComboBox(self)
qQuant = ['none', 'round', 'fix', 'floor']
self.cmbQuant.addItems(qQuant)
qset_cmb_box(self.cmbQuant, 'round')
self.cmbQuant.setToolTip("Select the kind of quantization.")
self.cmbQuant.setSizeAdjustPolicy(QComboBox.AdjustToContents)
layHQuantOpt = QHBoxLayout()
layHQuantOpt.addWidget(lblQuant)
layHQuantOpt.addWidget(self.cmbQuant)
layHQuantOpt.addStretch()
self.butQuant = QPushButton(self)
self.butQuant.setToolTip(
"<span>Quantize selected coefficients / "
"whole table with specified settings.</span>")
self.butQuant.setIcon(QIcon(':/quantize.svg'))
self.butQuant.setIconSize(q_icon_size)
self.butQuant.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
lblMSBtxt = QLabel(self)
lblMSBtxt.setText("<b><i>MSB</i><sub>10</sub> =</b>")
self.lblMSB = QLabel(self)
layHMSB = QHBoxLayout()
layHMSB.addWidget(lblMSBtxt)
layHMSB.addWidget(self.lblMSB)
layHMSB.addStretch()
lblLSBtxt = QLabel(self)
lblLSBtxt.setText("<b><i>LSB</i><sub>10</sub> =</b>")
self.lblLSB = QLabel(self)
layHLSB = QHBoxLayout()
layHLSB.addWidget(lblLSBtxt)
layHLSB.addWidget(self.lblLSB)
layHLSB.addStretch()
layGQOpt = QGridLayout()
layGQOpt.addLayout(layHQOvflOpt, 0, 0)
layGQOpt.addLayout(layHQuantOpt, 0, 1)
layGQOpt.addWidget(self.butQuant, 0, 2, Qt.AlignCenter)
layGQOpt.addLayout(layHMSB, 1, 0)
layGQOpt.addLayout(layHLSB, 1, 1)
# -------------------------------------------------------------------
# Display MAX
# ---------------------------------------------------------------------
lblMAXtxt = QLabel(self)
lblMAXtxt.setText("<b><i>Max =</i></b>")
self.lblMAX = QLabel(self)
layHCoeffs_MAX = QHBoxLayout()
layHCoeffs_MAX.addWidget(lblMAXtxt)
layHCoeffs_MAX.addWidget(self.lblMAX)
layHCoeffs_MAX.addStretch()
#######################################################################
# Now put all the coefficient HBoxes into frmQSettings
# ---------------------------------------------------------------------
layVButtonsQ = QVBoxLayout()
layVButtonsQ.addLayout(layHW_Scale)
layVButtonsQ.addLayout(layGQOpt)
layVButtonsQ.addLayout(layHCoeffs_MAX)
layVButtonsQ.setContentsMargins(0, 0, 0, 0)
# This frame encompasses all Quantization Settings
self.frmQSettings = QFrame(self)
self.frmQSettings.setLayout(layVButtonsQ)
#######################################################################
# ######################## Main UI Layout ############################
#######################################################################
# layout for frame (UI widget)
layVMainF = QVBoxLayout()
layVMainF.addLayout(layHDisplay)
layVMainF.addWidget(self.frmQSettings)
layVMainF.addWidget(QHLine())
layVMainF.addWidget(self.frmButtonsCoeffs)
# This frame encompasses all UI elements
frmMain = QFrame(self)
frmMain.setLayout(layVMainF)
layVMain = QVBoxLayout()
# the following affects only the first widget (intended here)
layVMain.setAlignment(Qt.AlignTop)
layVMain.addWidget(frmMain)
layVMain.setContentsMargins(*params['wdg_margins'])
self.setLayout(layVMain)
#######################################################################
# --- set initial values from dict ------------
self.spnDigits.setValue(params['FMT_ba'])
self.ledEps.setText(str(self.eps))
# ----------------------------------------------------------------------
# LOCAL SIGNALS & SLOTs
# ----------------------------------------------------------------------
self.but_csv_options.clicked.connect(self._open_csv_win)
def _construct_UI(self):
# ----------- ---------------------------------------------------
# Run control widgets
# ---------------------------------------------------------------
self.chk_auto_run = QCheckBox("Auto", self)
self.chk_auto_run.setObjectName("chk_auto_run")
self.chk_auto_run.setToolTip("<span>Update response automatically when "
"parameters have been changed.</span>")
self.chk_auto_run.setChecked(True)
self.but_run = QPushButton(self)
self.but_run.setText("RUN")
self.but_run.setToolTip("Run simulation")
self.but_run.setEnabled(not self.chk_auto_run.isChecked())
self.cmb_sim_select = QComboBox(self)
self.cmb_sim_select.addItems(["Float","Fixpoint"])
qset_cmb_box(self.cmb_sim_select, "Float")
self.cmb_sim_select.setToolTip("<span>Simulate floating-point or fixpoint response."
"</span>")
self.lbl_N_points = QLabel(to_html("N", frmt='bi') + " =", self)
self.led_N_points = QLineEdit(self)
self.led_N_points.setText(str(self.N))
self.led_N_points.setToolTip("<span>Number of displayed data points. "
"<i>N</i> = 0 tries to choose for you.</span>")
self.lbl_N_start = QLabel(to_html("N_0", frmt='bi') + " =", self)
self.led_N_start = QLineEdit(self)
self.led_N_start.setText(str(self.N_start))
self.led_N_start.setToolTip("<span>First point to plot.</span>")
self.chk_fx_scale = QCheckBox("Int. scale", self)
self.chk_fx_scale.setObjectName("chk_fx_scale")
self.chk_fx_scale.setToolTip("<span>Display data with integer (fixpoint) scale.</span>")
self.chk_fx_scale.setChecked(False)
self.chk_stim_options = QCheckBox("Stim. Options", self)
self.chk_stim_options.setObjectName("chk_stim_options")
self.chk_stim_options.setToolTip("<span>Show stimulus options.</span>")
self.chk_stim_options.setChecked(True)
self.but_fft_win = QPushButton(self)
self.but_fft_win.setText("WIN FFT")
self.but_fft_win.setToolTip('<span> time and frequency response of FFT Window '
'(can be modified in the "Frequency" tab)</span>')
self.but_fft_win.setCheckable(True)
self.but_fft_win.setChecked(False)
layH_ctrl_run = QHBoxLayout()
layH_ctrl_run.addWidget(self.but_run)
#layH_ctrl_run.addWidget(self.lbl_sim_select)
layH_ctrl_run.addWidget(self.cmb_sim_select)
layH_ctrl_run.addWidget(self.chk_auto_run)
layH_ctrl_run.addStretch(1)
layH_ctrl_run.addWidget(self.lbl_N_start)
layH_ctrl_run.addWidget(self.led_N_start)
layH_ctrl_run.addStretch(1)
layH_ctrl_run.addWidget(self.lbl_N_points)
layH_ctrl_run.addWidget(self.led_N_points)
layH_ctrl_run.addStretch(2)
layH_ctrl_run.addWidget(self.chk_fx_scale)
layH_ctrl_run.addStretch(2)
layH_ctrl_run.addWidget(self.chk_stim_options)
layH_ctrl_run.addStretch(2)
layH_ctrl_run.addWidget(self.but_fft_win)
layH_ctrl_run.addStretch(10)
#layH_ctrl_run.setContentsMargins(*params['wdg_margins'])
self.wdg_ctrl_run = QWidget(self)
self.wdg_ctrl_run.setLayout(layH_ctrl_run)
# --- end of run control ----------------------------------------
# ----------- ---------------------------------------------------
# Controls for time domain
# ---------------------------------------------------------------
plot_styles_list = ["None","Dots","Line","Line*","Stem","Stem*","Step","Step*"]
lbl_plt_time_title = QLabel("<b>View:</b>", self)
self.lbl_plt_time_stim = QLabel(to_html("Stimulus x", frmt='bi'), self)
self.cmb_plt_time_stim = QComboBox(self)
self.cmb_plt_time_stim.addItems(plot_styles_list)
qset_cmb_box(self.cmb_plt_time_stim, self.plt_time_stim)
self.cmb_plt_time_stim.setToolTip("<span>Plot style for stimulus.</span>")
self.lbl_plt_time_stmq = QLabel(to_html(" Fixp. Stim. x_Q", frmt='bi'), self)
self.cmb_plt_time_stmq = QComboBox(self)
self.cmb_plt_time_stmq.addItems(plot_styles_list)
qset_cmb_box(self.cmb_plt_time_stmq, self.plt_time_stmq)
self.cmb_plt_time_stmq.setToolTip("<span>Plot style for <em>fixpoint</em> (quantized) stimulus.</span>")
lbl_plt_time_resp = QLabel(to_html(" Response y", frmt='bi'), self)
self.cmb_plt_time_resp = QComboBox(self)
self.cmb_plt_time_resp.addItems(plot_styles_list)
qset_cmb_box(self.cmb_plt_time_resp, self.plt_time_resp)
self.cmb_plt_time_resp.setToolTip("<span>Plot style for response.</span>")
lbl_win_time = QLabel(to_html(" FFT Window", frmt='bi'), self)
self.chk_win_time = QCheckBox(self)
self.chk_win_time.setObjectName("chk_win_time")
self.chk_win_time.setToolTip('<span>Show FFT windowing function (can be modified in the "Frequency" tab).</span>')
self.chk_win_time.setChecked(False)
lbl_log_time = QLabel(to_html("dB", frmt='b'), self)
self.chk_log_time = QCheckBox(self)
self.chk_log_time.setObjectName("chk_log_time")
self.chk_log_time.setToolTip("<span>Logarithmic scale for y-axis.</span>")
self.chk_log_time.setChecked(False)
self.lbl_log_bottom_time = QLabel(to_html("min =", frmt='bi'), self)
self.lbl_log_bottom_time.setVisible(True)
self.led_log_bottom_time = QLineEdit(self)
self.led_log_bottom_time.setText(str(self.bottom_t))
self.led_log_bottom_time.setToolTip("<span>Minimum display value for time "
"and spectrogram plots with log. scale.</span>")
self.led_log_bottom_time.setVisible(True)
lbl_plt_time_spgr = QLabel(to_html(" Spectrogram", frmt='bi'), self)
self.cmb_plt_time_spgr = QComboBox(self)
self.cmb_plt_time_spgr.addItems(["None", "x[n]", "x_q[n]", "y[n]"])
qset_cmb_box(self.cmb_plt_time_spgr, self.plt_time_spgr)
self.cmb_plt_time_spgr.setToolTip("<span>Show Spectrogram for selected signal.</span>")
spgr_en = self.plt_time_spgr != "None"
self.lbl_log_spgr_time = QLabel(to_html(" dB", frmt='b'), self)
self.lbl_log_spgr_time.setVisible(spgr_en)
self.chk_log_spgr_time = QCheckBox(self)
self.chk_log_spgr_time.setObjectName("chk_log_spgr")
self.chk_log_spgr_time.setToolTip("<span>Logarithmic scale for spectrogram.</span>")
self.chk_log_spgr_time.setChecked(True)
self.chk_log_spgr_time.setVisible(spgr_en)
self.lbl_nfft_spgr_time = QLabel(to_html(" N_FFT =", frmt='bi'), self)
self.lbl_nfft_spgr_time.setVisible(spgr_en)
self.led_nfft_spgr_time = QLineEdit(self)
self.led_nfft_spgr_time.setText(str(self.nfft_spgr_time))
self.led_nfft_spgr_time.setToolTip("<span>Number of FFT points per spectrogram segment.</span>")
self.led_nfft_spgr_time.setVisible(spgr_en)
self.lbl_ovlp_spgr_time = QLabel(to_html(" N_OVLP =", frmt='bi'), self)
self.lbl_ovlp_spgr_time.setVisible(spgr_en)
self.led_ovlp_spgr_time = QLineEdit(self)
self.led_ovlp_spgr_time.setText(str(self.ovlp_spgr_time))
self.led_ovlp_spgr_time.setToolTip("<span>Number of overlap data points between spectrogram segments.</span>")
self.led_ovlp_spgr_time.setVisible(spgr_en)
self.lbl_mode_spgr_time = QLabel(to_html(" Mode", frmt='bi'), self)
self.lbl_mode_spgr_time.setVisible(spgr_en)
self.cmb_mode_spgr_time = QComboBox(self)
spgr_modes = [("PSD","psd"), ("Mag.","magnitude"),\
("Angle","angle"), ("Phase","phase")]
for i in spgr_modes:
self.cmb_mode_spgr_time.addItem(*i)
qset_cmb_box(self.cmb_mode_spgr_time, self.mode_spgr_time, data=True)
self.cmb_mode_spgr_time.setToolTip("<span>Spectrogram display mode.</span>")
self.cmb_mode_spgr_time.setVisible(spgr_en)
self.lbl_byfs_spgr_time = QLabel(to_html(" per f_S", frmt='b'), self)
self.lbl_byfs_spgr_time.setVisible(spgr_en)
self.chk_byfs_spgr_time = QCheckBox(self)
self.chk_byfs_spgr_time.setObjectName("chk_log_spgr")
self.chk_byfs_spgr_time.setToolTip("<span>Display spectral density i.e. scale by f_S</span>")
self.chk_byfs_spgr_time.setChecked(True)
self.chk_byfs_spgr_time.setVisible(spgr_en)
# self.lbl_colorbar_time = QLabel(to_html(" Col.bar", frmt='b'), self)
# self.lbl_colorbar_time.setVisible(spgr_en)
# self.chk_colorbar_time = QCheckBox(self)
# self.chk_colorbar_time.setObjectName("chk_colorbar_time")
# self.chk_colorbar_time.setToolTip("<span>Enable colorbar</span>")
# self.chk_colorbar_time.setChecked(True)
# self.chk_colorbar_time.setVisible(spgr_en)
self.chk_fx_limits = QCheckBox("Min/max.", self)
self.chk_fx_limits.setObjectName("chk_fx_limits")
self.chk_fx_limits.setToolTip("<span>Display limits of fixpoint range.</span>")
self.chk_fx_limits.setChecked(False)
layH_ctrl_time = QHBoxLayout()
layH_ctrl_time.addWidget(lbl_plt_time_title)
layH_ctrl_time.addStretch(1)
layH_ctrl_time.addWidget(self.lbl_plt_time_stim)
layH_ctrl_time.addWidget(self.cmb_plt_time_stim)
#
layH_ctrl_time.addWidget(self.lbl_plt_time_stmq)
layH_ctrl_time.addWidget(self.cmb_plt_time_stmq)
#
layH_ctrl_time.addWidget(lbl_plt_time_resp)
layH_ctrl_time.addWidget(self.cmb_plt_time_resp)
#
layH_ctrl_time.addWidget(lbl_win_time)
layH_ctrl_time.addWidget(self.chk_win_time)
layH_ctrl_time.addStretch(1)
layH_ctrl_time.addWidget(lbl_log_time)
layH_ctrl_time.addWidget(self.chk_log_time)
layH_ctrl_time.addWidget(self.lbl_log_bottom_time)
layH_ctrl_time.addWidget(self.led_log_bottom_time)
#
layH_ctrl_time.addStretch(1)
#
layH_ctrl_time.addWidget(lbl_plt_time_spgr)
layH_ctrl_time.addWidget(self.cmb_plt_time_spgr)
layH_ctrl_time.addWidget(self.lbl_log_spgr_time)
layH_ctrl_time.addWidget(self.chk_log_spgr_time)
layH_ctrl_time.addWidget(self.lbl_nfft_spgr_time)
layH_ctrl_time.addWidget(self.led_nfft_spgr_time)
layH_ctrl_time.addWidget(self.lbl_ovlp_spgr_time)
layH_ctrl_time.addWidget(self.led_ovlp_spgr_time)
layH_ctrl_time.addWidget(self.lbl_mode_spgr_time)
layH_ctrl_time.addWidget(self.cmb_mode_spgr_time)
layH_ctrl_time.addWidget(self.lbl_byfs_spgr_time)
layH_ctrl_time.addWidget(self.chk_byfs_spgr_time)
layH_ctrl_time.addStretch(2)
layH_ctrl_time.addWidget(self.chk_fx_limits)
layH_ctrl_time.addStretch(10)
#layH_ctrl_time.setContentsMargins(*params['wdg_margins'])
self.wdg_ctrl_time = QWidget(self)
self.wdg_ctrl_time.setLayout(layH_ctrl_time)
# ---- end time domain ------------------
# ---------------------------------------------------------------
# Controls for frequency domain
# ---------------------------------------------------------------
lbl_plt_freq_title = QLabel("<b>View:</b>", self)
self.lbl_plt_freq_stim = QLabel(to_html("Stimulus X", frmt='bi'), self)
self.cmb_plt_freq_stim = QComboBox(self)
self.cmb_plt_freq_stim.addItems(plot_styles_list)
qset_cmb_box(self.cmb_plt_freq_stim, self.plt_freq_stim)
self.cmb_plt_freq_stim.setToolTip("<span>Plot style for stimulus.</span>")
self.lbl_plt_freq_stmq = QLabel(to_html(" Fixp. Stim. X_Q", frmt='bi'), self)
self.cmb_plt_freq_stmq = QComboBox(self)
self.cmb_plt_freq_stmq.addItems(plot_styles_list)
qset_cmb_box(self.cmb_plt_freq_stmq, self.plt_freq_stmq)
self.cmb_plt_freq_stmq.setToolTip("<span>Plot style for <em>fixpoint</em> (quantized) stimulus.</span>")
lbl_plt_freq_resp = QLabel(to_html(" Response Y", frmt='bi'), self)
self.cmb_plt_freq_resp = QComboBox(self)
self.cmb_plt_freq_resp.addItems(plot_styles_list)
qset_cmb_box(self.cmb_plt_freq_resp, self.plt_freq_resp)
self.cmb_plt_freq_resp.setToolTip("<span>Plot style for response.</span>")
lbl_log_freq = QLabel(to_html("dB", frmt='b'), self)
self.chk_log_freq = QCheckBox(self)
self.chk_log_freq.setObjectName("chk_log_freq")
self.chk_log_freq.setToolTip("<span>Logarithmic scale for y-axis.</span>")
self.chk_log_freq.setChecked(True)
self.lbl_log_bottom_freq = QLabel(to_html("min =", frmt='bi'), self)
self.lbl_log_bottom_freq.setVisible(self.chk_log_freq.isChecked())
self.led_log_bottom_freq = QLineEdit(self)
self.led_log_bottom_freq.setText(str(self.bottom_f))
self.led_log_bottom_freq.setToolTip("<span>Minimum display value for log. scale.</span>")
self.led_log_bottom_freq.setVisible(self.chk_log_freq.isChecked())
if not self.chk_log_freq.isChecked():
self.bottom_f = 0
lbl_re_im_freq = QLabel(to_html("Re / Im", frmt='b'), self)
self.chk_re_im_freq = QCheckBox(self)
self.chk_re_im_freq.setObjectName("chk_re_im_freq")
self.chk_re_im_freq.setToolTip("<span>Show real and imaginary part of spectrum</span>")
self.chk_re_im_freq.setChecked(False)
self.lbl_win_fft = QLabel(to_html("Window", frmt='bi'), self)
self.cmb_win_fft = QComboBox(self)
self.cmb_win_fft.addItems(get_window_names())
self.cmb_win_fft.setToolTip("FFT window type.")
qset_cmb_box(self.cmb_win_fft, self.window_name)
self.cmb_win_fft_variant = QComboBox(self)
self.cmb_win_fft_variant.setToolTip("FFT window variant.")
self.cmb_win_fft_variant.setVisible(False)
self.lblWinPar1 = QLabel("Param1")
self.ledWinPar1 = QLineEdit(self)
self.ledWinPar1.setText("1")
self.ledWinPar1.setObjectName("ledWinPar1")
self.lblWinPar2 = QLabel("Param2")
self.ledWinPar2 = QLineEdit(self)
self.ledWinPar2.setText("2")
self.ledWinPar2.setObjectName("ledWinPar2")
self.chk_Hf = QCheckBox(self)
self.chk_Hf.setObjectName("chk_Hf")
self.chk_Hf.setToolTip("<span>Show ideal frequency response, calculated "
"from the filter coefficients.</span>")
self.chk_Hf.setChecked(False)
self.chk_Hf_lbl = QLabel(to_html("H_id (f)", frmt="bi"), self)
lbl_show_info_freq = QLabel(to_html("Info", frmt='b'), self)
self.chk_show_info_freq = QCheckBox(self)
self.chk_show_info_freq.setObjectName("chk_show_info_freq")
self.chk_show_info_freq.setToolTip("<span>Show infos about signal power "
"and window properties.</span>")
self.chk_show_info_freq.setChecked(False)
layH_ctrl_freq = QHBoxLayout()
layH_ctrl_freq.addWidget(lbl_plt_freq_title)
layH_ctrl_freq.addStretch(1)
layH_ctrl_freq.addWidget(self.lbl_plt_freq_stim)
layH_ctrl_freq.addWidget(self.cmb_plt_freq_stim)
#
layH_ctrl_freq.addWidget(self.lbl_plt_freq_stmq)
layH_ctrl_freq.addWidget(self.cmb_plt_freq_stmq)
#
layH_ctrl_freq.addWidget(lbl_plt_freq_resp)
layH_ctrl_freq.addWidget(self.cmb_plt_freq_resp)
#
layH_ctrl_freq.addWidget(self.chk_Hf_lbl)
layH_ctrl_freq.addWidget(self.chk_Hf)
layH_ctrl_freq.addStretch(1)
layH_ctrl_freq.addWidget(lbl_log_freq)
layH_ctrl_freq.addWidget(self.chk_log_freq)
layH_ctrl_freq.addWidget(self.lbl_log_bottom_freq)
layH_ctrl_freq.addWidget(self.led_log_bottom_freq)
layH_ctrl_freq.addStretch(1)
layH_ctrl_freq.addWidget(lbl_re_im_freq)
layH_ctrl_freq.addWidget(self.chk_re_im_freq)
layH_ctrl_freq.addStretch(2)
layH_ctrl_freq.addWidget(self.lbl_win_fft)
layH_ctrl_freq.addWidget(self.cmb_win_fft)
layH_ctrl_freq.addWidget(self.cmb_win_fft_variant)
layH_ctrl_freq.addWidget(self.lblWinPar1)
layH_ctrl_freq.addWidget(self.ledWinPar1)
layH_ctrl_freq.addWidget(self.lblWinPar2)
layH_ctrl_freq.addWidget(self.ledWinPar2)
layH_ctrl_freq.addStretch(1)
layH_ctrl_freq.addWidget(lbl_show_info_freq)
layH_ctrl_freq.addWidget(self.chk_show_info_freq)
layH_ctrl_freq.addStretch(10)
#layH_ctrl_freq.setContentsMargins(*params['wdg_margins'])
self.wdg_ctrl_freq = QWidget(self)
self.wdg_ctrl_freq.setLayout(layH_ctrl_freq)
# ---- end Frequency Domain ------------------
# ---------------------------------------------------------------
# Controls for stimuli
# ---------------------------------------------------------------
lbl_title_stim = QLabel("<b>Stimulus:</b>", self)
self.lblStimulus = QLabel(to_html("Type", frmt='bi'), self)
self.cmbStimulus = QComboBox(self)
self.cmbStimulus.addItems(["None","Impulse","Step","StepErr","Cos","Sine", "Chirp",
"Triang","Saw","Rect","Comb","AM","PM / FM","Formula"])
self.cmbStimulus.setToolTip("Stimulus type.")
qset_cmb_box(self.cmbStimulus, self.stim)
self.chk_stim_bl = QCheckBox("BL", self)
self.chk_stim_bl.setToolTip("<span>The signal is bandlimited to the Nyquist frequency "
"to avoid aliasing. However, it is much slower to generate "
"than the regular version.</span>")
self.chk_stim_bl.setChecked(True)
self.chk_stim_bl.setObjectName("stim_bl")
self.cmbChirpMethod = QComboBox(self)
for t in [("Lin","Linear"),("Square","Quadratic"),("Log", "Logarithmic"), ("Hyper", "Hyperbolic")]:
self.cmbChirpMethod.addItem(*t)
qset_cmb_box(self.cmbChirpMethod, self.chirp_method, data=False)
self.chk_scale_impz_f = QCheckBox("Scale", self)
self.chk_scale_impz_f.setToolTip("<span>Scale the FFT of the impulse response with <i>N<sub>FFT</sub></i> "
"so that it has the same magnitude as |H(f)|. DC and Noise need to be "
"turned off.</span>")
self.chk_scale_impz_f.setChecked(True)
self.chk_scale_impz_f.setObjectName("scale_impz_f")
self.lblDC = QLabel(to_html("DC =", frmt='bi'), self)
self.ledDC = QLineEdit(self)
self.ledDC.setText(str(self.DC))
self.ledDC.setToolTip("DC Level")
self.ledDC.setObjectName("stimDC")
layHCmbStim = QHBoxLayout()
layHCmbStim.addWidget(self.cmbStimulus)
layHCmbStim.addWidget(self.chk_stim_bl)
layHCmbStim.addWidget(self.chk_scale_impz_f)
layHCmbStim.addWidget(self.cmbChirpMethod)
#----------------------------------------------
self.lblAmp1 = QLabel(to_html(" A_1", frmt='bi') + " =", self)
self.ledAmp1 = QLineEdit(self)
self.ledAmp1.setText(str(self.A1))
self.ledAmp1.setToolTip("Stimulus amplitude, complex values like 3j - 1 are allowed")
self.ledAmp1.setObjectName("stimAmp1")
self.lblAmp2 = QLabel(to_html(" A_2", frmt='bi') + " =", self)
self.ledAmp2 = QLineEdit(self)
self.ledAmp2.setText(str(self.A2))
self.ledAmp2.setToolTip("Stimulus amplitude 2, complex values like 3j - 1 are allowed")
self.ledAmp2.setObjectName("stimAmp2")
#----------------------------------------------
self.lblPhi1 = QLabel(to_html(" φ_1", frmt='bi') + " =", self)
self.ledPhi1 = QLineEdit(self)
self.ledPhi1.setText(str(self.phi1))
self.ledPhi1.setToolTip("Stimulus phase")
self.ledPhi1.setObjectName("stimPhi1")
self.lblPhU1 = QLabel(to_html("°", frmt='b'), self)
self.lblPhi2 = QLabel(to_html(" φ_2", frmt='bi') + " =", self)
self.ledPhi2 = QLineEdit(self)
self.ledPhi2.setText(str(self.phi2))
self.ledPhi2.setToolTip("Stimulus phase 2")
self.ledPhi2.setObjectName("stimPhi2")
self.lblPhU2 = QLabel(to_html("°", frmt='b'), self)
#----------------------------------------------
self.lblFreq1 = QLabel(to_html(" f_1", frmt='bi') + " =", self)
self.ledFreq1 = QLineEdit(self)
self.ledFreq1.setText(str(self.f1))
self.ledFreq1.setToolTip("Stimulus frequency 1")
self.ledFreq1.setObjectName("stimFreq1")
self.lblFreqUnit1 = QLabel("f_S", self)
self.lblFreq2 = QLabel(to_html(" f_2", frmt='bi') + " =", self)
self.ledFreq2 = QLineEdit(self)
self.ledFreq2.setText(str(self.f2))
self.ledFreq2.setToolTip("Stimulus frequency 2")
self.ledFreq2.setObjectName("stimFreq2")
self.lblFreqUnit2 = QLabel("f_S", self)
#----------------------------------------------
self.lblNoise = QLabel(to_html(" Noise", frmt='bi'), self)
self.cmbNoise = QComboBox(self)
self.cmbNoise.addItems(["None","Gauss","Uniform","PRBS"])
self.cmbNoise.setToolTip("Type of additive noise.")
qset_cmb_box(self.cmbNoise, self.noise)
self.lblNoi = QLabel("not initialized", self)
self.ledNoi = QLineEdit(self)
self.ledNoi.setText(str(self.noi))
self.ledNoi.setToolTip("not initialized")
self.ledNoi.setObjectName("stimNoi")
layGStim = QGridLayout()
layGStim.addWidget(self.lblStimulus, 0, 0)
layGStim.addWidget(self.lblDC, 1, 0)
layGStim.addLayout(layHCmbStim, 0, 1)
layGStim.addWidget(self.ledDC, 1, 1)
layGStim.addWidget(self.lblAmp1, 0, 2)
layGStim.addWidget(self.lblAmp2, 1, 2)
layGStim.addWidget(self.ledAmp1, 0, 3)
layGStim.addWidget(self.ledAmp2, 1, 3)
layGStim.addWidget(self.lblPhi1, 0, 4)
layGStim.addWidget(self.lblPhi2, 1, 4)
layGStim.addWidget(self.ledPhi1, 0, 5)
layGStim.addWidget(self.ledPhi2, 1, 5)
layGStim.addWidget(self.lblPhU1, 0, 6)
layGStim.addWidget(self.lblPhU2, 1, 6)
layGStim.addWidget(self.lblFreq1, 0, 7)
layGStim.addWidget(self.lblFreq2, 1, 7)
layGStim.addWidget(self.ledFreq1, 0, 8)
layGStim.addWidget(self.ledFreq2, 1, 8)
layGStim.addWidget(self.lblFreqUnit1, 0, 9)
layGStim.addWidget(self.lblFreqUnit2, 1, 9)
layGStim.addWidget(self.lblNoise, 0, 10)
layGStim.addWidget(self.lblNoi, 1, 10)
layGStim.addWidget(self.cmbNoise, 0, 11)
layGStim.addWidget(self.ledNoi, 1, 11)
#----------------------------------------------
self.lblStimFormula = QLabel(to_html("x =", frmt='bi'), self)
self.ledStimFormula = QLineEdit(self)
self.ledStimFormula.setText(str(self.stim_formula))
self.ledStimFormula.setToolTip("<span>Enter formula for stimulus in numexpr syntax"
"</span>")
self.ledStimFormula.setObjectName("stimFormula")
layH_ctrl_stim_formula = QHBoxLayout()
layH_ctrl_stim_formula.addWidget(self.lblStimFormula)
layH_ctrl_stim_formula.addWidget(self.ledStimFormula,10)
#----------------------------------------------
#layG_ctrl_stim = QGridLayout()
layH_ctrl_stim_par = QHBoxLayout()
layH_ctrl_stim_par.addLayout(layGStim)
layV_ctrl_stim = QVBoxLayout()
layV_ctrl_stim.addLayout(layH_ctrl_stim_par)
layV_ctrl_stim.addLayout(layH_ctrl_stim_formula)
layH_ctrl_stim = QHBoxLayout()
layH_ctrl_stim.addWidget(lbl_title_stim)
layH_ctrl_stim.addStretch(1)
layH_ctrl_stim.addLayout(layV_ctrl_stim)
layH_ctrl_stim.addStretch(10)
self.wdg_ctrl_stim = QWidget(self)
self.wdg_ctrl_stim.setLayout(layH_ctrl_stim)
# --------- end stimuli ---------------------------------
# frequency widgets require special handling as they are scaled with f_s
self.ledFreq1.installEventFilter(self)
self.ledFreq2.installEventFilter(self)
#----------------------------------------------------------------------
# LOCAL SIGNALS & SLOTs
#----------------------------------------------------------------------
# --- run control ---
self.led_N_start.editingFinished.connect(self.update_N)
self.led_N_points.editingFinished.connect(self.update_N)
# --- frequency control ---
# careful! currentIndexChanged passes the current index to _update_win_fft
self.cmb_win_fft.currentIndexChanged.connect(self._update_win_fft)
self.ledWinPar1.editingFinished.connect(self._read_param1)
self.ledWinPar2.editingFinished.connect(self._read_param2)
# --- stimulus control ---
self.chk_stim_options.clicked.connect(self._show_stim_options)
self.chk_stim_bl.clicked.connect(self._enable_stim_widgets)
self.cmbStimulus.currentIndexChanged.connect(self._enable_stim_widgets)
self.cmbNoise.currentIndexChanged.connect(self._update_noi)
self.ledNoi.editingFinished.connect(self._update_noi)
self.ledAmp1.editingFinished.connect(self._update_amp1)
self.ledAmp2.editingFinished.connect(self._update_amp2)
self.ledPhi1.editingFinished.connect(self._update_phi1)
self.ledPhi2.editingFinished.connect(self._update_phi2)
self.cmbChirpMethod.currentIndexChanged.connect(self._update_chirp_method)
self.ledDC.editingFinished.connect(self._update_DC)
self.ledStimFormula.editingFinished.connect(self._update_stim_formula)
def _construct_UI(self):
self.but_log = PushButton("dB", checked=False)
self.but_log.setObjectName("but_log")
self.but_log.setToolTip("Logarithmic scale")
self.but_plot_in_UC = PushButton("|z| < 1 ", checked=False)
self.but_plot_in_UC.setObjectName("but_plot_in_UC")
self.but_plot_in_UC.setToolTip("Only plot H(z) within the unit circle")
self.lblBottom = QLabel(to_html("Bottom =", frmt='bi'), self)
self.ledBottom = QLineEdit(self)
self.ledBottom.setObjectName("ledBottom")
self.ledBottom.setText(str(self.zmin))
self.ledBottom.setToolTip("Minimum display value.")
self.lblBottomdB = QLabel("dB", self)
self.lblBottomdB.setVisible(self.but_log.isChecked())
self.lblTop = QLabel(to_html("Top =", frmt='bi'), self)
self.ledTop = QLineEdit(self)
self.ledTop.setObjectName("ledTop")
self.ledTop.setText(str(self.zmax))
self.ledTop.setToolTip("Maximum display value.")
self.lblTopdB = QLabel("dB", self)
self.lblTopdB.setVisible(self.but_log.isChecked())
self.plt_UC = PushButton("UC", checked=True)
self.plt_UC.setObjectName("plt_UC")
self.plt_UC.setToolTip("Plot unit circle")
self.but_PZ = PushButton("P/Z ", checked=True)
self.but_PZ.setObjectName("but_PZ")
self.but_PZ.setToolTip("Plot poles and zeros")
self.but_Hf = PushButton("H(f) ", checked=True)
self.but_Hf.setObjectName("but_Hf")
self.but_Hf.setToolTip("Plot H(f) along the unit circle")
modes = ['None', 'Mesh', 'Surf', 'Contour']
self.cmbMode3D = QComboBox(self)
self.cmbMode3D.addItems(modes)
self.cmbMode3D.setObjectName("cmbShow3D")
self.cmbMode3D.setToolTip("Select 3D-plot mode.")
self.cmbMode3D.setCurrentIndex(0)
self.cmbMode3D.setSizeAdjustPolicy(QComboBox.AdjustToContents)
self.but_colormap_r = PushButton("reverse", checked=True)
self.but_colormap_r.setObjectName("but_colormap_r")
self.but_colormap_r.setToolTip("reverse colormap")
self.cmbColormap = QComboBox(self)
self._init_cmb_colormap(cmap_init=self.cmap_default)
self.cmbColormap.setToolTip("Select colormap")
self.but_colbar = PushButton("Colorbar ", checked=False)
self.but_colbar.setObjectName("chkColBar")
self.but_colbar.setToolTip("Show colorbar")
self.but_lighting = PushButton("Lighting", checked=False)
self.but_lighting.setObjectName("but_lighting")
self.but_lighting.setToolTip("Enable light source")
self.lblAlpha = QLabel(to_html("Alpha", frmt='bi'), self)
self.diaAlpha = QDial(self)
self.diaAlpha.setRange(0, 10)
self.diaAlpha.setValue(10)
self.diaAlpha.setTracking(False) # produce less events when turning
self.diaAlpha.setFixedHeight(30)
self.diaAlpha.setFixedWidth(30)
self.diaAlpha.setWrapping(False)
self.diaAlpha.setToolTip(
"<span>Set transparency for surf and contour plots.</span>")
self.lblHatch = QLabel(to_html("Stride", frmt='bi'), self)
self.diaHatch = QDial(self)
self.diaHatch.setRange(0, 9)
self.diaHatch.setValue(5)
self.diaHatch.setTracking(False) # produce less events when turning
self.diaHatch.setFixedHeight(30)
self.diaHatch.setFixedWidth(30)
self.diaHatch.setWrapping(False)
self.diaHatch.setToolTip("Set line density for various plots.")
self.but_contour_2d = PushButton("Contour2D ", checked=False)
self.but_contour_2d.setObjectName("chkContour2D")
self.but_contour_2d.setToolTip("Plot 2D-contours at z =0")
# ----------------------------------------------------------------------
# LAYOUT for UI widgets
# ----------------------------------------------------------------------
layGControls = QGridLayout()
layGControls.addWidget(self.but_log, 0, 0)
layGControls.addWidget(self.but_plot_in_UC, 1, 0)
layGControls.addWidget(self.lblTop, 0, 2)
layGControls.addWidget(self.ledTop, 0, 4)
layGControls.addWidget(self.lblTopdB, 0, 5)
layGControls.addWidget(self.lblBottom, 1, 2)
layGControls.addWidget(self.ledBottom, 1, 4)
layGControls.addWidget(self.lblBottomdB, 1, 5)
layGControls.setColumnStretch(5, 1)
layGControls.addWidget(self.plt_UC, 0, 6)
layGControls.addWidget(self.but_Hf, 1, 6)
layGControls.addWidget(self.but_PZ, 0, 8)
layGControls.addWidget(self.cmbMode3D, 0, 10)
layGControls.addWidget(self.but_contour_2d, 1, 10)
layGControls.addWidget(self.cmbColormap, 0, 12, 1, 1)
layGControls.addWidget(self.but_colormap_r, 1, 12)
layGControls.addWidget(self.but_lighting, 0, 14)
layGControls.addWidget(self.but_colbar, 1, 14)
layGControls.addWidget(self.lblAlpha, 0, 15)
layGControls.addWidget(self.diaAlpha, 0, 16)
layGControls.addWidget(self.lblHatch, 1, 15)
layGControls.addWidget(self.diaHatch, 1, 16)
# This widget encompasses all control subwidgets
self.frmControls = QFrame(self)
self.frmControls.setObjectName("frmControls")
self.frmControls.setLayout(layGControls)
# ----------------------------------------------------------------------
# mplwidget
# ----------------------------------------------------------------------
# This is the plot pane widget, encompassing the other widgets
self.mplwidget = MplWidget(self)
self.mplwidget.layVMainMpl.addWidget(self.frmControls)
self.mplwidget.layVMainMpl.setContentsMargins(*params['mpl_margins'])
self.mplwidget.mplToolbar.a_he.setEnabled(True)
self.mplwidget.mplToolbar.a_he.info = "manual/plot_3d.html"
self.setLayout(self.mplwidget.layVMainMpl)
self._init_grid() # initialize grid and do initial plot
# ----------------------------------------------------------------------
# GLOBAL SIGNALS & SLOTs
# ----------------------------------------------------------------------
self.sig_rx.connect(self.process_sig_rx)
# ----------------------------------------------------------------------
# LOCAL SIGNALS & SLOTs
# ----------------------------------------------------------------------
self.but_log.clicked.connect(self._log_clicked)
self.ledBottom.editingFinished.connect(self._log_clicked)
self.ledTop.editingFinished.connect(self._log_clicked)
self.but_plot_in_UC.clicked.connect(self._init_grid)
self.plt_UC.clicked.connect(self.draw)
self.but_Hf.clicked.connect(self.draw)
self.but_PZ.clicked.connect(self.draw)
self.cmbMode3D.currentIndexChanged.connect(self.draw)
self.but_colbar.clicked.connect(self.draw)
self.cmbColormap.currentIndexChanged.connect(self.draw)
self.but_colormap_r.clicked.connect(self.draw)
self.but_lighting.clicked.connect(self.draw)
self.diaAlpha.valueChanged.connect(self.draw)
self.diaHatch.valueChanged.connect(self.draw)
self.but_contour_2d.clicked.connect(self.draw)
self.mplwidget.mplToolbar.sig_tx.connect(self.process_sig_rx)
def _construct_UI(self):
""" initialize the User Interface """
butClipboard = QPushButton(self)
butClipboard.setIcon(QIcon(':/clipboard.svg'))
butClipboard.setToolTip("Copy text to clipboard.")
butAbout = QPushButton(self)
butAbout.setText("About")
butAbout.setToolTip("Display 'About' info")
butChangelog = QPushButton(self)
butChangelog.setText("Changelog")
butChangelog.setToolTip("Display changelog")
butLicMIT = QPushButton(self)
butLicMIT.setText("MIT License")
butLicMIT.setToolTip("MIT License for pyFDA source code")
butLicGPLv3 = QPushButton(self)
butLicGPLv3.setText("GPLv3 License")
butLicGPLv3.setToolTip("GPLv3 License for bundled distribution")
butClose = QPushButton(self)
butClose.setIcon(QIcon(':/circle-x.svg'))
butClose.setToolTip("Close Window.")
layGButtons = QGridLayout()
layGButtons.addWidget(butClipboard, 0, 0)
layGButtons.addWidget(butAbout, 0, 1)
layGButtons.addWidget(butChangelog, 0, 2)
layGButtons.addWidget(butLicMIT, 0, 3)
layGButtons.addWidget(butLicGPLv3, 0, 4)
layGButtons.addWidget(butClose, 0, 5)
lblInfo = QLabel(self)
lblInfo.setText(self.info_str)
lblInfo.setFixedHeight(lblInfo.height() * 1.2)
#lblInfo.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
lblInfo.setOpenExternalLinks(True)
lblIcon = QLabel(self)
lblIcon.setPixmap(
QPixmap(':/pyfda_icon.svg').scaledToHeight(
lblInfo.height(), Qt.SmoothTransformation))
butClipboard.setFixedWidth(lblInfo.height())
butClose.setFixedWidth(lblInfo.height())
layHInfo = QHBoxLayout()
layHInfo.addWidget(lblIcon)
layHInfo.addWidget(lblInfo)
self.txtDisplay = QTextBrowser(self)
self.txtDisplay.setOpenExternalLinks(True)
self.display_about_str()
self.txtDisplay.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
#self.txtDisplay.setFixedHeight(self.txtDisplay.width() * 2)
layVMain = QVBoxLayout()
# layVMain.setAlignment(Qt.AlignTop) # this affects only the first widget (intended here)
layVMain.addLayout(layGButtons)
layVMain.addLayout(layHInfo)
layVMain.addWidget(self.txtDisplay)
layVMain.setContentsMargins(*params['wdg_margins_spc'])
self.setLayout(layVMain)
#self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
#self.resize(0,0)
#self.adjustSize()
#QApplication.processEvents()
butClipboard.clicked.connect(
lambda: self.to_clipboard(self.info_str + self.about_str))
butAbout.clicked.connect(self.display_about_str)
butChangelog.clicked.connect(self.display_changelog)
butLicMIT.clicked.connect(self.display_MIT_lic)
butLicGPLv3.clicked.connect(self.display_GPL_lic)
butClose.clicked.connect(self.close)
class AmplitudeSpecs(QWidget):
"""
Build and update widget for entering the amplitude
specifications like A_SB, A_PB etc.
"""
sig_tx = pyqtSignal(
object) # emitted when amplitude unit or spec has been changed
def __init__(self, parent, title="Amplitude Specs"):
"""
Initialize
"""
super(AmplitudeSpecs, self).__init__(parent)
self.title = title
self.qlabels = [] # list with references to QLabel widgets
self.qlineedit = [] # list with references to QLineEdit widgets
self.spec_edited = False # flag whether QLineEdit field has been edited
self._construct_UI()
#------------------------------------------------------------------------------
def _construct_UI(self):
"""
Construct User Interface
"""
amp_units = ["dB", "V", "W"]
bfont = QFont()
bfont.setBold(True)
lblTitle = QLabel(str(self.title), self) # field for widget title
lblTitle.setFont(bfont)
lblTitle.setWordWrap(True)
lblUnits = QLabel("in", self)
self.cmbUnitsA = QComboBox(self)
self.cmbUnitsA.addItems(amp_units)
self.cmbUnitsA.setObjectName("cmbUnitsA")
self.cmbUnitsA.setToolTip(
"<span>Unit for amplitude specifications:"
" dB is attenuation (> 0); levels in V and W have to be < 1.</span>"
)
# fit size dynamically to largest element:
self.cmbUnitsA.setSizeAdjustPolicy(QComboBox.AdjustToContents)
# find index for default unit from dictionary and set the unit
amp_idx = self.cmbUnitsA.findData(fb.fil[0]['amp_specs_unit'])
if amp_idx < 0:
amp_idx = 0
self.cmbUnitsA.setCurrentIndex(amp_idx) # initialize for dBs
layHTitle = QHBoxLayout() # layout for title and unit
layHTitle.addWidget(lblTitle)
layHTitle.addWidget(lblUnits, Qt.AlignLeft)
layHTitle.addWidget(self.cmbUnitsA, Qt.AlignLeft)
layHTitle.addStretch(1)
self.layGSpecs = QGridLayout() # sublayout for spec fields
# set the title as the first (fixed) entry in grid layout. The other
# fields are added and hidden dynamically in _show_entries and _hide_entries()
self.layGSpecs.addLayout(layHTitle, 0, 0, 1, 2)
self.layGSpecs.setAlignment(Qt.AlignLeft)
# This is the top level widget, encompassing the other widgets
self.frmMain = QFrame(self)
self.frmMain.setLayout(self.layGSpecs)
self.layVMain = QVBoxLayout() # Widget main layout
self.layVMain.addWidget(self.frmMain)
self.layVMain.setContentsMargins(*params['wdg_margins'])
self.setLayout(self.layVMain)
self.n_cur_labels = 0 # number of currently visible labels / qlineedits
# - Build a list from all entries in the fil_dict dictionary starting
# with "A" (= amplitude specifications of the current filter)
# - Pass the list to update_UI which recreates the widget
# ATTENTION: Entries need to be converted from QString to str for Py 2
new_labels = [str(l) for l in fb.fil[0] if l[0] == 'A']
self.update_UI(new_labels=new_labels)
#----------------------------------------------------------------------
# LOCAL SIGNALS & SLOTs / EVENT MONITORING
#----------------------------------------------------------------------
self.cmbUnitsA.currentIndexChanged.connect(self._set_amp_unit)
# ^ this also triggers the initial load_dict
# DYNAMIC EVENT MONITORING
# Every time a field is edited, call self._store_entry and
# self.load_dict. This is achieved by dynamically installing and
# removing event filters when creating / deleting subwidgets.
# The event filter monitors the focus of the input fields.
#------------------------------------------------------------------------------
def eventFilter(self, source, event):
"""
Filter all events generated by the QLineEdit widgets. Source and type
of all events generated by monitored objects are passed to this eventFilter,
evaluated and passed on to the next hierarchy level.
- When a QLineEdit widget gains input focus (QEvent.FocusIn`), display
the stored value from filter dict with full precision
- When a key is pressed inside the text field, set the `spec_edited` flag
to True.
- When a QLineEdit widget loses input focus (QEvent.FocusOut`), store
current value in linear format with full precision (only if
`spec_edited`== True) and display the stored value in selected format
"""
if isinstance(source,
QLineEdit): # could be extended for other widgets
if event.type() == QEvent.FocusIn:
self.spec_edited = False
self.load_dict()
# store current entry in case new value can't be evaluated:
fb.data_old = source.text()
elif event.type() == QEvent.KeyPress:
self.spec_edited = True # entry has been changed
key = event.key()
if key in {QtCore.Qt.Key_Return,
QtCore.Qt.Key_Enter}: # store entry
self._store_entry(source)
elif key == QtCore.Qt.Key_Escape: # revert changes
self.spec_edited = False
self.load_dict()
elif event.type() == QEvent.FocusOut:
self._store_entry(source)
# Call base class method to continue normal event processing:
return super(AmplitudeSpecs, self).eventFilter(source, event)
#-------------------------------------------------------------
def update_UI(self, new_labels=()):
"""
Called from filter_specs.update_UI() and target_specs.update_UI().
Set labels and get corresponding values from filter dictionary.
When number of entries has changed, the layout of subwidget is rebuilt,
using
- `self.qlabels`, a list with references to existing QLabel widgets,
- `new_labels`, a list of strings from the filter_dict for the current
filter design
- 'num_new_labels`, their number
- `self.n_cur_labels`, the number of currently visible labels / qlineedit
fields
"""
state = new_labels[0]
new_labels = new_labels[1:]
# W_lbl = max([self.qfm.width(l) for l in new_labels]) # max. label width in pixel
num_new_labels = len(new_labels)
if num_new_labels < self.n_cur_labels: # less new labels/qlineedit fields than before
self._hide_entries(num_new_labels)
elif num_new_labels > self.n_cur_labels: # more new labels, create / show new ones
self._show_entries(num_new_labels)
tool_tipp_sb = "Min. attenuation resp. maximum level in (this) stop band"
for i in range(num_new_labels):
# Update ALL labels and corresponding values
self.qlabels[i].setText(to_html(new_labels[i], frmt='bi'))
self.qlineedit[i].setText(str(fb.fil[0][new_labels[i]]))
self.qlineedit[i].setObjectName(new_labels[i]) # update ID
if "sb" in new_labels[i].lower():
self.qlineedit[i].setToolTip("<span>" + tool_tipp_sb +
" (> 0).</span>")
elif "pb" in new_labels[i].lower():
self.qlineedit[i].setToolTip(
"<span>Maximum ripple (> 0) in (this) pass band.<span/>"
)
qstyle_widget(self.qlineedit[i], state)
self.n_cur_labels = num_new_labels # update number of currently visible labels
self.load_dict(
) # display rounded filter dict entries in selected unit
#------------------------------------------------------------------------------
def load_dict(self):
"""
Reload and reformat the amplitude textfields from filter dict when a new filter
design algorithm is selected or when the user has changed the unit (V / W / dB):
- Reload amplitude entries from filter dictionary and convert to selected to reflect changed settings
unit.
- Update the lineedit fields, rounded to specified format.
"""
unit = fb.fil[0]['amp_specs_unit']
filt_type = fb.fil[0]['ft']
for i in range(len(self.qlineedit)):
amp_label = str(self.qlineedit[i].objectName())
amp_value = lin2unit(fb.fil[0][amp_label],
filt_type,
amp_label,
unit=unit)
if not self.qlineedit[i].hasFocus():
# widget has no focus, round the display
self.qlineedit[i].setText(params['FMT'].format(amp_value))
else:
# widget has focus, show full precision
self.qlineedit[i].setText(str(amp_value))
#------------------------------------------------------------------------------
def _set_amp_unit(self, source):
"""
Store unit for amplitude in filter dictionary, reload amplitude spec
entries via load_dict and fire a sigUnitChanged signal
"""
fb.fil[0]['amp_specs_unit'] = qget_cmb_box(self.cmbUnitsA, data=False)
self.load_dict()
self.sig_tx.emit({'sender': __name__, 'view_changed': 'a_unit'})
#------------------------------------------------------------------------------
def _store_entry(self, source):
"""
When the textfield of `source` has been edited (flag `self.spec_edited` = True),
transform the amplitude spec back to linear unit setting and store it
in filter dict.
This is triggered by `QEvent.focusOut`
Spec entries are *always* stored in linear units; only the
displayed values are adapted to the amplitude unit, not the dictionary!
"""
if self.spec_edited:
unit = str(self.cmbUnitsA.currentText())
filt_type = fb.fil[0]['ft']
amp_label = str(source.objectName())
amp_value = safe_eval(source.text(), fb.data_old, sign='pos')
fb.fil[0].update(
{amp_label: unit2lin(amp_value, filt_type, amp_label, unit)})
self.sig_tx.emit({'sender': __name__, 'specs_changed': 'a_specs'})
self.spec_edited = False # reset flag
self.load_dict()
#-------------------------------------------------------------
def _hide_entries(self, num_new_labels):
"""
Hide subwidgets so that only `num_new_labels` subwidgets are visible
"""
for i in range(num_new_labels, len(self.qlabels)):
self.qlabels[i].hide()
self.qlineedit[i].hide()
#------------------------------------------------------------------------
def _show_entries(self, num_new_labels):
"""
- check whether enough subwidgets (QLabel und QLineEdit) exist for the
the required number of `num_new_labels`:
- create new ones if required
- initialize them with dummy information
- install eventFilter for new QLineEdit widgets so that the filter
dict is updated automatically when a QLineEdit field has been
edited.
- if enough subwidgets exist already, make enough of them visible to
show all spec fields
"""
num_tot_labels = len(
self.qlabels) # number of existing labels (vis. + invis.)
if num_tot_labels < num_new_labels: # new widgets need to be generated
for i in range(num_tot_labels, num_new_labels):
self.qlabels.append(QLabel(self))
self.qlabels[i].setText(to_html("dummy", frmt='bi'))
self.qlineedit.append(QLineEdit(""))
self.qlineedit[i].setObjectName("dummy")
self.qlineedit[i].installEventFilter(self) # filter events
# first entry is title
self.layGSpecs.addWidget(self.qlabels[i], i + 1, 0)
self.layGSpecs.addWidget(self.qlineedit[i], i + 1, 1)
else: # make the right number of widgets visible
for i in range(self.n_cur_labels, num_new_labels):
self.qlabels[i].show()
self.qlineedit[i].show()
class FreqUnits(QWidget):
"""
Build and update widget for entering the frequency units
The following key-value pairs of the `fb.fil[0]` dict are modified:
- `'freq_specs_unit'` : The unit ('k', 'f_S', 'f_Ny', 'Hz' etc.) as a string
- `'freqSpecsRange'` : A list with two entries for minimum and maximum frequency
values for labelling the frequency axis
- `'f_S'` : The sampling frequency for referring frequency values to as a float
- `'f_max'` : maximum frequency for scaling frequency axis
- `'plt_fUnit'`: frequency unit as string
- `'plt_tUnit'`: time unit as string
- `'plt_fLabel'`: label for frequency axis
- `'plt_tLabel'`: label for time axis
"""
# class variables (shared between instances if more than one exists)
sig_tx = pyqtSignal(object) # outgoing
def __init__(self, parent, title="Frequency Units"):
super(FreqUnits, self).__init__(parent)
self.title = title
self.spec_edited = False # flag whether QLineEdit field has been edited
self._construct_UI()
def _construct_UI(self):
"""
Construct the User Interface
"""
self.layVMain = QVBoxLayout() # Widget main layout
f_units = ['k', 'f_S', 'f_Ny', 'Hz', 'kHz', 'MHz', 'GHz']
self.t_units = ['', '', '', 's', 'ms', r'$\mu$s', 'ns']
bfont = QFont()
bfont.setBold(True)
self.lblUnits = QLabel(self)
self.lblUnits.setText("Freq. Unit:")
self.lblUnits.setFont(bfont)
self.fs_old = fb.fil[0]['f_S'] # store current sampling frequency
self.ledF_S = QLineEdit()
self.ledF_S.setText(str(fb.fil[0]["f_S"]))
self.ledF_S.setObjectName("f_S")
self.ledF_S.installEventFilter(self) # filter events
self.lblF_S = QLabel(self)
self.lblF_S.setText(to_html("f_S", frmt='bi'))
self.cmbUnits = QComboBox(self)
self.cmbUnits.setObjectName("cmbUnits")
self.cmbUnits.addItems(f_units)
self.cmbUnits.setToolTip(
'Select whether frequencies are specified w.r.t. \n'
'the sampling frequency "f_S", to the Nyquist frequency \n'
'f_Ny = f_S/2 or as absolute values. "k" specifies frequencies w.r.t. f_S '
'but plots graphs over the frequency index k.')
self.cmbUnits.setCurrentIndex(1)
# self.cmbUnits.setItemData(0, (0,QColor("#FF333D"),Qt.BackgroundColorRole))#
# self.cmbUnits.setItemData(0, (QFont('Verdana', bold=True), Qt.FontRole)
fRanges = [("0...½", "half"), ("0...1", "whole"), ("-½...½", "sym")]
self.cmbFRange = QComboBox(self)
self.cmbFRange.setObjectName("cmbFRange")
for f in fRanges:
self.cmbFRange.addItem(f[0], f[1])
self.cmbFRange.setToolTip("Select frequency range (whole or half).")
self.cmbFRange.setCurrentIndex(0)
# Combobox resizes with longest entry
self.cmbUnits.setSizeAdjustPolicy(QComboBox.AdjustToContents)
self.cmbFRange.setSizeAdjustPolicy(QComboBox.AdjustToContents)
self.butSort = QToolButton(self)
self.butSort.setText("Sort")
self.butSort.setCheckable(True)
self.butSort.setChecked(True)
self.butSort.setToolTip(
"Sort frequencies in ascending order when pushed.")
self.butSort.setStyleSheet("QToolButton:checked {font-weight:bold}")
self.layHUnits = QHBoxLayout()
self.layHUnits.addWidget(self.cmbUnits)
self.layHUnits.addWidget(self.cmbFRange)
self.layHUnits.addWidget(self.butSort)
# Create a gridLayout consisting of QLabel and QLineEdit fields
# for setting f_S, the units and the actual frequency specs:
self.layGSpecWdg = QGridLayout() # sublayout for spec fields
self.layGSpecWdg.addWidget(self.lblF_S, 1, 0)
self.layGSpecWdg.addWidget(self.ledF_S, 1, 1)
self.layGSpecWdg.addWidget(self.lblUnits, 0, 0)
self.layGSpecWdg.addLayout(self.layHUnits, 0, 1)
frmMain = QFrame(self)
frmMain.setLayout(self.layGSpecWdg)
self.layVMain.addWidget(frmMain)
self.layVMain.setContentsMargins(*params['wdg_margins'])
self.setLayout(self.layVMain)
#----------------------------------------------------------------------
# LOCAL SIGNALS & SLOTs
#----------------------------------------------------------------------
self.cmbUnits.currentIndexChanged.connect(self.update_UI)
self.cmbFRange.currentIndexChanged.connect(self._freq_range)
self.butSort.clicked.connect(self._store_sort_flag)
#----------------------------------------------------------------------
self.update_UI() # first-time initialization
#-------------------------------------------------------------
def update_UI(self):
"""
Transform the displayed frequency spec input fields according to the units
setting. Spec entries are always stored normalized w.r.t. f_S in the
dictionary; when f_S or the unit are changed, only the displayed values
of the frequency entries are updated, not the dictionary!
Signals are blocked before changing the value for f_S programmatically
update_UI is called
- during init
- when the unit combobox is changed
Finally, store freqSpecsRange and emit 'view_changed' signal via _freq_range
"""
idx = self.cmbUnits.currentIndex() # read index of units combobox
f_unit = str(self.cmbUnits.currentText()) # and the label
self.ledF_S.setVisible(f_unit not in {"f_S", "f_Ny",
"k"}) # only vis. when
self.lblF_S.setVisible(f_unit not in {"f_S", "f_Ny",
"k"}) # not normalized
f_S_scale = 1 # default setting for f_S scale
if f_unit in {"f_S", "f_Ny", "k"}: # normalized frequency
self.fs_old = fb.fil[0]['f_S'] # store current sampling frequency
if f_unit == "f_S": # normalized to f_S
fb.fil[0]['f_S'] = fb.fil[0]['f_max'] = 1.
f_label = r"$F = f\, /\, f_S = \Omega \, /\, 2 \mathrm{\pi} \; \rightarrow$"
elif f_unit == "f_Ny": # idx == 1: normalized to f_nyq = f_S / 2
fb.fil[0]['f_S'] = fb.fil[0]['f_max'] = 2.
f_label = r"$F = 2f \, / \, f_S = \Omega \, / \, \mathrm{\pi} \; \rightarrow$"
else:
fb.fil[0]['f_S'] = 1
fb.fil[0]['f_max'] = params['N_FFT']
f_label = r"$k \; \rightarrow$"
t_label = r"$n \; \rightarrow$"
self.ledF_S.setText(params['FMT'].format(fb.fil[0]['f_S']))
else: # Hz, kHz, ...
if fb.fil[0]['freq_specs_unit'] in {"f_S", "f_Ny",
"k"}: # previous setting
fb.fil[0]['f_S'] = fb.fil[0][
'f_max'] = self.fs_old # restore prev. sampling frequency
self.ledF_S.setText(params['FMT'].format(fb.fil[0]['f_S']))
if f_unit == "Hz":
f_S_scale = 1.
elif f_unit == "kHz":
f_S_scale = 1.e3
elif f_unit == "MHz":
f_S_scale = 1.e6
elif f_unit == "GHz":
f_S_scale = 1.e9
else:
logger.warning("Unknown frequency unit {0}".format(f_unit))
f_label = r"$f$ in " + f_unit + r"$\; \rightarrow$"
t_label = r"$t$ in " + self.t_units[idx] + r"$\; \rightarrow$"
if f_unit == "k":
plt_f_unit = "f_S"
else:
plt_f_unit = f_unit
fb.fil[0].update({'f_S_scale': f_S_scale}) # scale factor for f_S
fb.fil[0].update({'freq_specs_unit': f_unit}) # frequency unit
fb.fil[0].update({"plt_fLabel": f_label}) # label for freq. axis
fb.fil[0].update({"plt_tLabel": t_label}) # label for time axis
fb.fil[0].update({"plt_fUnit": plt_f_unit}) # frequency unit as string
fb.fil[0].update({"plt_tUnit":
self.t_units[idx]}) # time unit as string
self._freq_range(
) # update f_lim setting and emit sigUnitChanged signal
#------------------------------------------------------------------------------
def eventFilter(self, source, event):
"""
Filter all events generated by the QLineEdit widgets. Source and type
of all events generated by monitored objects are passed to this eventFilter,
evaluated and passed on to the next hierarchy level.
- When a QLineEdit widget gains input focus (QEvent.FocusIn`), display
the stored value from filter dict with full precision
- When a key is pressed inside the text field, set the `spec_edited` flag
to True.
- When a QLineEdit widget loses input focus (QEvent.FocusOut`), store
current value with full precision (only if `spec_edited`== True) and
display the stored value in selected format. Emit 'view_changed':'f_S'
"""
def _store_entry():
"""
Update filter dictionary, set line edit entry with reduced precision
again.
"""
if self.spec_edited:
fb.fil[0].update({
'f_S':
safe_eval(source.text(), fb.fil[0]['f_S'], sign='pos')
})
# TODO: ?!
self._freq_range(emit_sig_range=False) # update plotting range
self.sig_tx.emit({'sender': __name__, 'view_changed': 'f_S'})
self.spec_edited = False # reset flag, changed entry has been saved
if source.objectName() == 'f_S':
if event.type() == QEvent.FocusIn:
self.spec_edited = False
source.setText(str(fb.fil[0]['f_S'])) # full precision
elif event.type() == QEvent.KeyPress:
self.spec_edited = True # entry has been changed
key = event.key()
if key in {QtCore.Qt.Key_Return, QtCore.Qt.Key_Enter}:
_store_entry()
elif key == QtCore.Qt.Key_Escape: # revert changes
self.spec_edited = False
source.setText(str(fb.fil[0]['f_S'])) # full precision
elif event.type() == QEvent.FocusOut:
_store_entry()
source.setText(params['FMT'].format(
fb.fil[0]['f_S'])) # reduced precision
# Call base class method to continue normal event processing:
return super(FreqUnits, self).eventFilter(source, event)
#-------------------------------------------------------------
def _freq_range(self, emit_sig_range=True):
"""
Set frequency plotting range for single-sided spectrum up to f_S/2 or f_S
or for double-sided spectrum between -f_S/2 and f_S/2 and emit
'view_changed':'f_range'.
"""
rangeType = qget_cmb_box(self.cmbFRange)
fb.fil[0].update({'freqSpecsRangeType': rangeType})
f_max = fb.fil[0]["f_max"]
if rangeType == 'whole':
f_lim = [0, f_max]
elif rangeType == 'sym':
f_lim = [-f_max / 2., f_max / 2.]
else:
f_lim = [0, f_max / 2.]
fb.fil[0]['freqSpecsRange'] = f_lim # store settings in dict
self.sig_tx.emit({'sender': __name__, 'view_changed': 'f_range'})
#-------------------------------------------------------------
def load_dict(self):
"""
Reload comboBox settings and textfields from filter dictionary
Block signals during update of combobox / lineedit widgets
"""
self.ledF_S.setText(params['FMT'].format(fb.fil[0]['f_S']))
self.cmbUnits.blockSignals(True)
idx = self.cmbUnits.findText(
fb.fil[0]['freq_specs_unit']) # get and set
self.cmbUnits.setCurrentIndex(idx) # index for freq. unit combo box
self.cmbUnits.blockSignals(False)
self.cmbFRange.blockSignals(True)
idx = self.cmbFRange.findData(fb.fil[0]['freqSpecsRangeType'])
self.cmbFRange.setCurrentIndex(idx) # set frequency range
self.cmbFRange.blockSignals(False)
self.butSort.blockSignals(True)
self.butSort.setChecked(fb.fil[0]['freq_specs_sort'])
self.butSort.blockSignals(False)
#-------------------------------------------------------------
def _store_sort_flag(self):
"""
Store sort flag in filter dict and emit 'specs_changed':'f_sort'
when sort button is checked.
"""
fb.fil[0]['freq_specs_sort'] = self.butSort.isChecked()
if self.butSort.isChecked():
self.sig_tx.emit({'sender': __name__, 'specs_changed': 'f_sort'})
class FreqSpecs(QWidget):
"""
Build and update widget for entering the frequency
specifications like F_sb, F_pb etc.
"""
# class variables (shared between instances if more than one exists)
sig_tx = pyqtSignal(object) # outgoing
sig_rx = pyqtSignal(object) # incoming
def __init__(self, parent, title="Frequency Specs"):
super(FreqSpecs, self).__init__(parent)
self.title = title
self.qlabels = [] # list with references to QLabel widgets
self.qlineedit = [] # list with references to QLineEdit widgetss
self.spec_edited = False # flag whether QLineEdit field has been edited
self._construct_UI()
#-------------------------------------------------------------
def process_sig_rx(self, dict_sig=None):
"""
Process signals coming in via subwidgets and sig_rx
"""
logger.debug("Processing {0}: {1}".format(
type(dict_sig).__name__, dict_sig))
if dict_sig['sender'] == __name__:
logger.warning("Infinite loop detected (and interrupted)!")
elif 'specs_changed' in dict_sig and dict_sig[
'specs_changed'] == 'f_specs':
self.sort_dict_freqs()
elif 'view_changed' in dict_sig:
self.load_dict()
#-------------------------------------------------------------
def _construct_UI(self):
"""
Construct the User Interface
"""
bfont = QFont()
bfont.setBold(True)
lblTitle = QLabel(str(self.title), self) # field for widget title
lblTitle.setFont(bfont)
lblTitle.setWordWrap(True)
self.lblUnit = QLabel(self)
self.lblUnit.setText("in " +
to_html(fb.fil[0]['freq_specs_unit'], frmt='bi'))
layHTitle = QHBoxLayout()
layHTitle.addWidget(lblTitle)
layHTitle.addWidget(self.lblUnit)
layHTitle.addStretch(1)
# Create a gridLayout consisting of QLabel and QLineEdit fields
# for the frequency specs:
self.layGSpecs = QGridLayout() # sublayout for spec fields
# set the title as the first (fixed) entry in grid layout. The other
# fields are added and hidden dynamically in _show_entries and _hide_entries()
self.layGSpecs.addLayout(layHTitle, 0, 0, 1, 2)
self.layGSpecs.setAlignment(Qt.AlignLeft)
self.frmMain = QFrame(self)
self.frmMain.setLayout(self.layGSpecs)
self.layVMain = QVBoxLayout() # Widget main layout
self.layVMain.addWidget(self.frmMain) #, Qt.AlignLeft)
self.layVMain.setContentsMargins(*params['wdg_margins'])
self.setLayout(self.layVMain)
self.n_cur_labels = 0 # number of currently visible labels / qlineedits
#----------------------------------------------------------------------
# GLOBAL SIGNALS & SLOTs
#----------------------------------------------------------------------
self.sig_rx.connect(self.process_sig_rx)
#----------------------------------------------------------------------
# EVENT FILTER
#----------------------------------------------------------------------
# DYNAMIC SIGNAL SLOT CONNECTION:
# Every time a field is edited, call self.store_entries
# This is achieved by dynamically installing and
# removing event filters when creating / deleting subwidgets.
# The event filter monitors the focus of the input fields.
#----------------------------------------------------------------------
#------------------------------------------------------------------------------
def eventFilter(self, source, event):
"""
Filter all events generated by the QLineEdit widgets. Source and type
of all events generated by monitored objects are passed to this eventFilter,
evaluated and passed on to the next hierarchy level.
- When a QLineEdit widget gains input focus (QEvent.FocusIn`), display
the stored value from filter dict with full precision
- When a key is pressed inside the text field, set the `spec_edited` flag
to True.
- When a QLineEdit widget loses input focus (QEvent.FocusOut`), store
current value normalized to f_S with full precision (only if
`spec_edited`== True) and display the stored value in selected format
"""
if isinstance(source,
QLineEdit): # could be extended for other widgets
if event.type() == QEvent.FocusIn:
self.spec_edited = False
self.load_dict()
# store current entry in case new value can't be evaluated:
fb.data_old = source.text()
elif event.type() == QEvent.KeyPress:
self.spec_edited = True # entry has been changed
key = event.key()
if key in {QtCore.Qt.Key_Return, QtCore.Qt.Key_Enter}:
self._store_entry(source)
elif key == QtCore.Qt.Key_Escape: # revert changes
self.spec_edited = False
self.load_dict()
elif event.type() == QEvent.FocusOut:
self._store_entry(source)
# Call base class method to continue normal event processing:
return super(FreqSpecs, self).eventFilter(source, event)
#------------------------------------------------------------------------------
def _store_entry(self, event_source):
"""
_store_entry is triggered by `QEvent.focusOut` in the eventFilter:
When the textfield of `widget` has been edited (`self.spec_edited` = True),
sort and store all entries in filter dict, then reload the text fields.
Finally, emit a SpecsChanged signal.
"""
if self.spec_edited:
f_label = str(event_source.objectName())
f_value = safe_eval(event_source.text(),
fb.data_old) / fb.fil[0]['f_S']
fb.fil[0].update({f_label: f_value})
self.sort_dict_freqs()
self.sig_tx.emit({'sender': __name__, 'specs_changed': 'f_specs'})
self.spec_edited = False # reset flag
#-------------------------------------------------------------
def update_UI(self, new_labels=()):
"""
Called from filter_specs.update_UI() and target_specs.update_UI()
Set labels and get corresponding values from filter dictionary.
When number of entries has changed, the layout of subwidget is rebuilt,
using
- `self.qlabels`, a list with references to existing QLabel widgets,
- `new_labels`, a list of strings from the filter_dict for the current
filter design
- 'num_new_labels`, their number
- `self.n_cur_labels`, the number of currently visible labels / qlineedit
fields
"""
self.update_f_unit()
state = new_labels[0]
new_labels = new_labels[1:]
num_new_labels = len(new_labels)
# hide / show labels / create new subwidgets if neccessary:
self._show_entries(num_new_labels)
# W_lbl = max([self.qfm.width(l) for l in new_labels]) # max. label width in pixel
#---------------------------- logging -----------------------------
logger.debug("update_UI: {0}-{1}-{2}".format(fb.fil[0]['rt'],
fb.fil[0]['fc'],
fb.fil[0]['fo']))
f_range = " (0 < <i>f</i> < <i>f<sub>S </sub></i>/2)"
for i in range(num_new_labels):
# Update ALL labels and corresponding values
if fb.fil[0]['freq_specs_unit'] in {"f_S", "f_Ny"}:
self.qlabels[i].setText(to_html(new_labels[i], frmt='bi'))
else: # convert 'F' to 'f' for frequencies in Hz
self.qlabels[i].setText(to_html(new_labels[i][0].lower()\
+ new_labels[i][1:], frmt='bi'))
self.qlineedit[i].setText(str(fb.fil[0][new_labels[i]]))
self.qlineedit[i].setObjectName(new_labels[i]) # update ID
qstyle_widget(self.qlineedit[i], state)
if "sb" in new_labels[i].lower():
self.qlineedit[i].setToolTip(
"<span>Corner frequency for (this) stop band" + f_range +
".</span>")
elif "pb" in new_labels[i].lower():
self.qlineedit[i].setToolTip(
"<span>Corner frequency for (this) pass band" + f_range +
".</span>")
else:
self.qlineedit[i].setToolTip(
"<span>Corner frequency for (this) band" + f_range +
".</span>")
self.n_cur_labels = num_new_labels # update number of currently visible labels
self.sort_dict_freqs(
) # sort frequency entries in dictionary and update display
#-------------------------------------------------------------
def update_f_unit(self):
"""
Set label for frequency unit according to selected unit.
"""
unit = fb.fil[0]['freq_specs_unit']
if unit in {"f_S", "f_Ny"}:
unit_frmt = 'bi'
else:
unit_frmt = 'b'
self.lblUnit.setText(" in " + to_html(unit, frmt=unit_frmt))
#-------------------------------------------------------------
def load_dict(self):
"""
Reload textfields from filter dictionary
Transform the displayed frequency spec input fields according to the units
setting (i.e. f_S). Spec entries are always stored normalized w.r.t. f_S
in the dictionary; when f_S or the unit are changed, only the displayed values
of the frequency entries are updated, not the dictionary!
Update the displayed frequency unit
load_dict is called during init and when the frequency unit or the
sampling frequency have been changed.
It should be called when sigSpecsChanged or sigFilterDesigned is emitted
at another place, indicating that a reload is required.
"""
# recalculate displayed freq spec values for (maybe) changed f_S
logger.debug("exec load_dict")
self.update_f_unit()
for i in range(len(self.qlineedit)):
f_name = str(self.qlineedit[i].objectName()).split(":", 1)
f_label = f_name[0]
f_value = fb.fil[0][f_label] * fb.fil[0]['f_S']
if not self.qlineedit[i].hasFocus():
# widget has no focus, round the display
self.qlineedit[i].setText(params['FMT'].format(f_value))
else:
# widget has focus, show full precision
self.qlineedit[i].setText(str(f_value))
#------------------------------------------------------------------------
def _show_entries(self, num_new_labels):
"""
- check whether subwidgets need to be shown or hidden
- check whether enough subwidgets (QLabel und QLineEdit) exist for the
the required number of `num_new_labels`:
- create new ones if required
- initialize them with dummy information
- install eventFilter for new QLineEdit widgets so that the filter
dict is updated automatically when a QLineEdit field has been
edited.
- if enough subwidgets exist already, make enough of them visible to
show all spec fields
"""
num_tot_labels = len(
self.qlabels) # number of existing labels (vis. + invis.)
# less new subwidgets than currently displayed -> _hide some
if num_new_labels < self.n_cur_labels: # less new labels/qlineedit fields than before
for i in range(num_new_labels, num_tot_labels):
self.qlabels[i].hide()
self.qlineedit[i].hide()
# enough hidden subwidgets but need to make more labels visible
elif num_tot_labels >= num_new_labels:
for i in range(self.n_cur_labels, num_new_labels):
self.qlabels[i].show()
self.qlineedit[i].show()
else: # new subwidgets need to be generated
for i in range(num_tot_labels, num_new_labels):
self.qlabels.append(QLabel(self))
self.qlabels[i].setText(to_html("dummy", frmt='bi'))
self.qlineedit.append(QLineEdit(""))
self.qlineedit[i].setObjectName("dummy")
self.qlineedit[i].installEventFilter(self) # filter events
# first entry is the title
self.layGSpecs.addWidget(self.qlabels[i], i + 1, 0)
self.layGSpecs.addWidget(self.qlineedit[i], i + 1, 1)
#------------------------------------------------------------------------------
def sort_dict_freqs(self):
"""
- Sort visible filter dict frequency spec entries with ascending frequency if
the sort button is activated
- Update the visible QLineEdit frequency widgets
The method is called when:
- update_UI has been called after changing the filter design algorithm # that the response type has been changed
eg. from LP -> HP, requiring a different order of frequency entries
- a frequency spec field has been edited
- the sort button has been clicked (from filter_specs.py)
"""
f_specs = [
fb.fil[0][str(self.qlineedit[i].objectName())]
for i in range(self.n_cur_labels)
]
if fb.fil[0]['freq_specs_sort']:
f_specs.sort()
# Make sure normalized freqs are in the range ]0, 0.5[ and are different
# by at least MIN_FREQ_STEP
for i in range(self.n_cur_labels):
if f_specs[i] <= MIN_FREQ:
logger.warning("Frequencies must be > 0, changed {0} from {1:.4g} to {2:.4g}."\
.format(str(self.qlineedit[i].objectName()),f_specs[i]*fb.fil[0]['f_S'],
(MIN_FREQ + MIN_FREQ_STEP)*fb.fil[0]['f_S']))
f_specs[i] = MIN_FREQ + MIN_FREQ_STEP
if f_specs[i] >= MAX_FREQ:
logger.warning("Frequencies must be < f_S /2, changed {0} from {1:.4g} to {2:.4g}."\
.format(str(self.qlineedit[i].objectName()),f_specs[i]*fb.fil[0]['f_S'],
(MAX_FREQ - MIN_FREQ_STEP)*fb.fil[0]['f_S']))
f_specs[i] = MAX_FREQ - MIN_FREQ_STEP
fb.fil[0][str(self.qlineedit[i].objectName())] = f_specs[i]
# check for (nearly) identical elements:
_, mult = unique_roots(f_specs, tol=MIN_FREQ_STEP)
ident = [x for x in mult if x > 1]
if ident:
logger.warning("Frequencies must differ by at least {0:.4g}"\
.format(MIN_FREQ_STEP * fb.fil[0]['f_S']))
self.load_dict()
def _construct_UI(self):
# =====================================================================
# Controls for stimuli
# =====================================================================
self.cmbStimulus = QComboBox(self)
qcmb_box_populate(self.cmbStimulus, self.cmb_stim_items,
self.cmb_stim_item)
self.lblStimPar1 = QLabel(to_html("α =", frmt='b'), self)
self.ledStimPar1 = QLineEdit(self)
self.ledStimPar1.setText("0.5")
self.ledStimPar1.setToolTip("Duty Cycle, 0 ... 1")
self.ledStimPar1.setObjectName("ledStimPar1")
self.but_stim_bl = QPushButton(self)
self.but_stim_bl.setText("BL")
self.but_stim_bl.setToolTip(
"<span>Bandlimit the signal to the Nyquist "
"frequency to avoid aliasing. However, this is much slower "
"to calculate especially for a large number of points.</span>")
self.but_stim_bl.setMaximumWidth(qtext_width(text="BL "))
self.but_stim_bl.setCheckable(True)
self.but_stim_bl.setChecked(True)
self.but_stim_bl.setObjectName("stim_bl")
# -------------------------------------
self.cmbChirpType = QComboBox(self)
qcmb_box_populate(self.cmbChirpType, self.cmb_stim_chirp_items,
self.chirp_type)
self.cmbImpulseType = QComboBox(self)
qcmb_box_populate(self.cmbImpulseType, self.cmb_stim_impulse_items,
self.impulse_type)
self.cmbSinusoidType = QComboBox(self)
qcmb_box_populate(self.cmbSinusoidType, self.cmb_stim_sinusoid_items,
self.sinusoid_type)
self.cmbPeriodicType = QComboBox(self)
qcmb_box_populate(self.cmbPeriodicType, self.cmb_stim_periodic_items,
self.cmb_stim_periodic_item)
self.cmbModulationType = QComboBox(self)
for t in [("AM", "am"), ("PM / FM", "pmfm")]: # text, data
self.cmbModulationType.addItem(*t)
qset_cmb_box(self.cmbModulationType, self.modulation_type, data=True)
# -------------------------------------
self.chk_step_err = QPushButton("Error", self)
self.chk_step_err.setToolTip(
"<span>Display the step response error.</span>")
self.chk_step_err.setMaximumWidth(qtext_width(text="Error "))
self.chk_step_err.setCheckable(True)
self.chk_step_err.setChecked(False)
self.chk_step_err.setObjectName("stim_step_err")
layHCmbStim = QHBoxLayout()
layHCmbStim.addWidget(self.cmbStimulus)
layHCmbStim.addWidget(self.cmbImpulseType)
layHCmbStim.addWidget(self.cmbSinusoidType)
layHCmbStim.addWidget(self.cmbChirpType)
layHCmbStim.addWidget(self.cmbPeriodicType)
layHCmbStim.addWidget(self.cmbModulationType)
layHCmbStim.addWidget(self.but_stim_bl)
layHCmbStim.addWidget(self.lblStimPar1)
layHCmbStim.addWidget(self.ledStimPar1)
layHCmbStim.addWidget(self.chk_step_err)
self.lblDC = QLabel(to_html("DC =", frmt='bi'), self)
self.ledDC = QLineEdit(self)
self.ledDC.setText(str(self.DC))
self.ledDC.setToolTip("DC Level")
self.ledDC.setObjectName("stimDC")
layHStimDC = QHBoxLayout()
layHStimDC.addWidget(self.lblDC)
layHStimDC.addWidget(self.ledDC)
# ======================================================================
self.lblAmp1 = QLabel(to_html(" A_1", frmt='bi') + " =", self)
self.ledAmp1 = QLineEdit(self)
self.ledAmp1.setText(str(self.A1))
self.ledAmp1.setToolTip(
"Stimulus amplitude, complex values like 3j - 1 are allowed")
self.ledAmp1.setObjectName("stimAmp1")
self.lblAmp2 = QLabel(to_html(" A_2", frmt='bi') + " =", self)
self.ledAmp2 = QLineEdit(self)
self.ledAmp2.setText(str(self.A2))
self.ledAmp2.setToolTip(
"Stimulus amplitude 2, complex values like 3j - 1 are allowed")
self.ledAmp2.setObjectName("stimAmp2")
# ----------------------------------------------
self.lblPhi1 = QLabel(to_html(" φ_1", frmt='bi') + " =", self)
self.ledPhi1 = QLineEdit(self)
self.ledPhi1.setText(str(self.phi1))
self.ledPhi1.setToolTip("Stimulus phase")
self.ledPhi1.setObjectName("stimPhi1")
self.lblPhU1 = QLabel(to_html("°", frmt='b'), self)
self.lblPhi2 = QLabel(to_html(" φ_2", frmt='bi') + " =", self)
self.ledPhi2 = QLineEdit(self)
self.ledPhi2.setText(str(self.phi2))
self.ledPhi2.setToolTip("Stimulus phase 2")
self.ledPhi2.setObjectName("stimPhi2")
self.lblPhU2 = QLabel(to_html("°", frmt='b'), self)
# ----------------------------------------------
self.lbl_T1 = QLabel(to_html(" T_1", frmt='bi') + " =", self)
self.led_T1 = QLineEdit(self)
self.led_T1.setText(str(self.T1))
self.led_T1.setToolTip("Time shift")
self.led_T1.setObjectName("stimT1")
self.lbl_TU1 = QLabel(to_html("T_S", frmt='b'), self)
self.lbl_T2 = QLabel(to_html(" T_2", frmt='bi') + " =", self)
self.led_T2 = QLineEdit(self)
self.led_T2.setText(str(self.T2))
self.led_T2.setToolTip("Time shift 2")
self.led_T2.setObjectName("stimT2")
self.lbl_TU2 = QLabel(to_html("T_S", frmt='b'), self)
# ---------------------------------------------
self.lbl_TW1 = QLabel(
to_html(" ΔT_1", frmt='bi') + " =", self)
self.led_TW1 = QLineEdit(self)
self.led_TW1.setText(str(self.TW1))
self.led_TW1.setToolTip("Time width")
self.led_TW1.setObjectName("stimTW1")
self.lbl_TWU1 = QLabel(to_html("T_S", frmt='b'), self)
self.lbl_TW2 = QLabel(
to_html(" ΔT_2", frmt='bi') + " =", self)
self.led_TW2 = QLineEdit(self)
self.led_TW2.setText(str(self.TW2))
self.led_TW2.setToolTip("Time width 2")
self.led_TW2.setObjectName("stimTW2")
self.lbl_TWU2 = QLabel(to_html("T_S", frmt='b'), self)
# ----------------------------------------------
self.txtFreq1_f = to_html(" f_1", frmt='bi') + " ="
self.txtFreq1_k = to_html(" k_1", frmt='bi') + " ="
self.lblFreq1 = QLabel(self.txtFreq1_f, self)
self.ledFreq1 = QLineEdit(self)
self.ledFreq1.setText(str(self.f1))
self.ledFreq1.setToolTip("Stimulus frequency")
self.ledFreq1.setObjectName("stimFreq1")
self.lblFreqUnit1 = QLabel("f_S", self)
self.txtFreq2_f = to_html(" f_2", frmt='bi') + " ="
self.txtFreq2_k = to_html(" k_2", frmt='bi') + " ="
self.lblFreq2 = QLabel(self.txtFreq2_f, self)
self.ledFreq2 = QLineEdit(self)
self.ledFreq2.setText(str(self.f2))
self.ledFreq2.setToolTip("Stimulus frequency 2")
self.ledFreq2.setObjectName("stimFreq2")
self.lblFreqUnit2 = QLabel("f_S", self)
# ----------------------------------------------
self.lbl_BW1 = QLabel(
to_html(self.tr(" BW_1"), frmt='bi') + " =", self)
self.led_BW1 = QLineEdit(self)
self.led_BW1.setText(str(self.BW1))
self.led_BW1.setToolTip(self.tr("Relative bandwidth"))
self.led_BW1.setObjectName("stimBW1")
self.lbl_BW2 = QLabel(
to_html(self.tr(" BW_2"), frmt='bi') + " =", self)
self.led_BW2 = QLineEdit(self)
self.led_BW2.setText(str(self.BW2))
self.led_BW2.setToolTip(self.tr("Relative bandwidth 2"))
self.led_BW2.setObjectName("stimBW2")
# ----------------------------------------------
self.lblNoise = QLabel(to_html(" Noise", frmt='bi'), self)
self.cmbNoise = QComboBox(self)
qcmb_box_populate(self.cmbNoise, self.cmb_stim_noise_items, self.noise)
self.lblNoi = QLabel("not initialized", self)
self.ledNoi = QLineEdit(self)
self.ledNoi.setText(str(self.noi))
self.ledNoi.setToolTip("not initialized")
self.ledNoi.setObjectName("stimNoi")
layGStim = QGridLayout()
layGStim.addLayout(layHCmbStim, 0, 1)
layGStim.addLayout(layHStimDC, 1, 1)
layGStim.addWidget(self.lblAmp1, 0, 2)
layGStim.addWidget(self.lblAmp2, 1, 2)
layGStim.addWidget(self.ledAmp1, 0, 3)
layGStim.addWidget(self.ledAmp2, 1, 3)
layGStim.addWidget(self.lblPhi1, 0, 4)
layGStim.addWidget(self.lblPhi2, 1, 4)
layGStim.addWidget(self.ledPhi1, 0, 5)
layGStim.addWidget(self.ledPhi2, 1, 5)
layGStim.addWidget(self.lblPhU1, 0, 6)
layGStim.addWidget(self.lblPhU2, 1, 6)
layGStim.addWidget(self.lbl_T1, 0, 7)
layGStim.addWidget(self.lbl_T2, 1, 7)
layGStim.addWidget(self.led_T1, 0, 8)
layGStim.addWidget(self.led_T2, 1, 8)
layGStim.addWidget(self.lbl_TU1, 0, 9)
layGStim.addWidget(self.lbl_TU2, 1, 9)
layGStim.addWidget(self.lbl_TW1, 0, 10)
layGStim.addWidget(self.lbl_TW2, 1, 10)
layGStim.addWidget(self.led_TW1, 0, 11)
layGStim.addWidget(self.led_TW2, 1, 11)
layGStim.addWidget(self.lbl_TWU1, 0, 12)
layGStim.addWidget(self.lbl_TWU2, 1, 12)
layGStim.addWidget(self.lblFreq1, 0, 13)
layGStim.addWidget(self.lblFreq2, 1, 13)
layGStim.addWidget(self.ledFreq1, 0, 14)
layGStim.addWidget(self.ledFreq2, 1, 14)
layGStim.addWidget(self.lblFreqUnit1, 0, 15)
layGStim.addWidget(self.lblFreqUnit2, 1, 15)
layGStim.addWidget(self.lbl_BW1, 0, 16)
layGStim.addWidget(self.lbl_BW2, 1, 16)
layGStim.addWidget(self.led_BW1, 0, 17)
layGStim.addWidget(self.led_BW2, 1, 17)
layGStim.addWidget(self.lblNoise, 0, 18)
layGStim.addWidget(self.lblNoi, 1, 18)
layGStim.addWidget(self.cmbNoise, 0, 19)
layGStim.addWidget(self.ledNoi, 1, 19)
# ----------------------------------------------
self.lblStimFormula = QLabel(to_html("x =", frmt='bi'), self)
self.ledStimFormula = QLineEdit(self)
self.ledStimFormula.setText(str(self.stim_formula))
self.ledStimFormula.setToolTip(
"<span>Enter formula for stimulus in numexpr syntax.</span>")
self.ledStimFormula.setObjectName("stimFormula")
layH_stim_formula = QHBoxLayout()
layH_stim_formula.addWidget(self.lblStimFormula)
layH_stim_formula.addWidget(self.ledStimFormula, 10)
# ----------------------------------------------------------------------
# Main Widget
# ----------------------------------------------------------------------
layH_stim_par = QHBoxLayout()
layH_stim_par.addLayout(layGStim)
layV_stim = QVBoxLayout()
layV_stim.addLayout(layH_stim_par)
layV_stim.addLayout(layH_stim_formula)
layH_stim = QHBoxLayout()
layH_stim.addLayout(layV_stim)
layH_stim.addStretch(10)
self.wdg_stim = QWidget(self)
self.wdg_stim.setLayout(layH_stim)
self.wdg_stim.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Minimum)
# ----------------------------------------------------------------------
# Event Filter
# ----------------------------------------------------------------------
# frequency related widgets are scaled with f_s, requiring special handling
self.ledFreq1.installEventFilter(self)
self.ledFreq2.installEventFilter(self)
self.led_T1.installEventFilter(self)
self.led_T2.installEventFilter(self)
self.led_TW1.installEventFilter(self)
self.led_TW2.installEventFilter(self)
# ----------------------------------------------------------------------
# GLOBAL SIGNALS & SLOTs
# ----------------------------------------------------------------------
self.sig_rx.connect(self.process_sig_rx)
# ----------------------------------------------------------------------
# LOCAL SIGNALS & SLOTs
# ----------------------------------------------------------------------
# --- stimulus control ---
self.but_stim_bl.clicked.connect(self._enable_stim_widgets)
self.chk_step_err.clicked.connect(self._enable_stim_widgets)
self.cmbStimulus.currentIndexChanged.connect(self._enable_stim_widgets)
self.cmbNoise.currentIndexChanged.connect(self._update_noi)
self.ledNoi.editingFinished.connect(self._update_noi)
self.ledAmp1.editingFinished.connect(self._update_amp1)
self.ledAmp2.editingFinished.connect(self._update_amp2)
self.ledPhi1.editingFinished.connect(self._update_phi1)
self.ledPhi2.editingFinished.connect(self._update_phi2)
self.led_BW1.editingFinished.connect(self._update_BW1)
self.led_BW2.editingFinished.connect(self._update_BW2)
self.cmbImpulseType.currentIndexChanged.connect(
self._update_impulse_type)
self.cmbSinusoidType.currentIndexChanged.connect(
self._update_sinusoid_type)
self.cmbChirpType.currentIndexChanged.connect(self._update_chirp_type)
self.cmbPeriodicType.currentIndexChanged.connect(
self._update_periodic_type)
self.cmbModulationType.currentIndexChanged.connect(
self._update_modulation_type)
self.ledDC.editingFinished.connect(self._update_DC)
self.ledStimFormula.editingFinished.connect(self._update_stim_formula)
self.ledStimPar1.editingFinished.connect(self._update_stim_par1)
class WeightSpecs(QWidget):
"""
Build and update widget for entering the weight
specifications like W_SB, W_PB etc.
"""
sig_tx = pyqtSignal(object) # outgoing
from pyfda.libs.pyfda_qt_lib import emit
def __init__(self, parent=None):
super(WeightSpecs, self).__init__(parent)
self.qlabels = [] # list with references to QLabel widgets
self.qlineedit = [] # list with references to QLineEdit widgets
self.spec_edited = False # flag whether QLineEdit field has been edited
self._construct_UI()
# ------------------------------------------------------------------------------
def _construct_UI(self):
"""
Construct User Interface
"""
self.layGSpecs = QGridLayout() # Sublayout for spec fields, populated
# dynamically in _show_entries()
title = "Weight Specifications"
bfont = QFont()
bfont.setBold(True)
lblTitle = QLabel(self) # field for widget title
lblTitle.setText(str(title))
lblTitle.setFont(bfont)
lblTitle.setWordWrap(True)
self.butReset = QToolButton(self)
self.butReset.setText("Reset")
self.butReset.setToolTip("Reset weights to 1")
layHTitle = QHBoxLayout() # Layout for title and reset button
layHTitle.addWidget(lblTitle)
layHTitle.addWidget(self.butReset)
# set the title as the first (fixed) entry in grid layout. The other
# fields are added and hidden dynamically in _show_entries and _hide_entries()
self.layGSpecs.addLayout(layHTitle, 0, 0, 1, 2)
# This is the top level widget, encompassing the other widgets
frmMain = QFrame(self)
frmMain.setLayout(self.layGSpecs)
self.layVMain = QVBoxLayout() # Widget main vertical layout
self.layVMain.addWidget(frmMain)
self.layVMain.setContentsMargins(*params['wdg_margins'])
self.setLayout(self.layVMain)
# - Build a list from all entries in the fil_dict dictionary starting
# with "W" (= weight specifications of the current filter)
# - Pass the list to setEntries which recreates the widget
# ATTENTION: Entries need to be converted from QString to str for Py 2
self.n_cur_labels = 0 # number of currently visible labels / qlineedits
new_labels = [str(lbl) for lbl in fb.fil[0] if lbl[0] == 'W']
self.update_UI(new_labels=new_labels)
# ----------------------------------------------------------------------
# LOCAL SIGNALS & SLOTs / EVENT FILTER
# ----------------------------------------------------------------------
self.butReset.clicked.connect(self._reset_weights)
# ^ this also initializes the weight text fields
# DYNAMIC EVENT MONITORING
# Every time a field is edited, call self._store_entry and
# self.load_dict. This is achieved by dynamically installing and
# removing event filters when creating / deleting subwidgets.
# The event filter monitors the focus of the input fields.
# ------------------------------------------------------------------------------
def eventFilter(self, source, event):
"""
Filter all events generated by the QLineEdit widgets. Source and type
of all events generated by monitored objects are passed to this eventFilter,
evaluated and passed on to the next hierarchy level.
- When a QLineEdit widget gains input focus (QEvent.FocusIn`), display
the stored value from filter dict with full precision
- When a key is pressed inside the text field, set the `spec_edited` flag
to True.
- When a QLineEdit widget loses input focus (QEvent.FocusOut`), store
current value in linear format with full precision (only if
`spec_edited`== True) and display the stored value in selected format
"""
if isinstance(source, QLineEdit): # could be extended for other widgets
if event.type() == QEvent.FocusIn:
self.spec_edited = False
self.load_dict()
# store current entry in case new value can't be evaluated:
fb.data_old = source.text()
elif event.type() == QEvent.KeyPress:
self.spec_edited = True # entry has been changed
key = event.key()
if key in {QtCore.Qt.Key_Return, QtCore.Qt.Key_Enter}:
self._store_entry(source)
elif key == QtCore.Qt.Key_Escape: # revert changes
self.spec_edited = False
self.load_dict()
elif event.type() == QEvent.FocusOut:
self._store_entry(source)
# Call base class method to continue normal event processing:
return super(WeightSpecs, self).eventFilter(source, event)
# -------------------------------------------------------------
def update_UI(self, new_labels=[]):
"""
Called from filter_specs.update_UI()
Set labels and get corresponding values from filter dictionary.
When number of entries has changed, the layout of subwidget is rebuilt,
using
- `self.qlabels`, a list with references to existing QLabel widgets,
- `new_labels`, a list of strings from the filter_dict for the current
filter design
- 'num_new_labels`, their number
- `self.n_cur_labels`, the number of currently visible labels / qlineedit
fields
"""
state = new_labels[0]
new_labels = new_labels[1:]
num_new_labels = len(new_labels)
# less new labels/qlineedit fields than before
if num_new_labels < self.n_cur_labels:
self._hide_entries(num_new_labels)
# more new labels than before, create / show new ones
elif num_new_labels > self.n_cur_labels:
self._show_entries(num_new_labels)
for i in range(num_new_labels):
# Update ALL labels and corresponding values
self.qlabels[i].setText(to_html(new_labels[i], frmt='bi'))
self.qlineedit[i].setText(str(fb.fil[0][new_labels[i]]))
self.qlineedit[i].setObjectName(new_labels[i]) # update ID
self.qlineedit[i].setToolTip(
"<span>Relative weight (importance) for approximating this band.</span>")
qstyle_widget(self.qlineedit[i], state)
self.n_cur_labels = num_new_labels # update number of currently visible labels
self.load_dict() # display rounded filter dict entries
# ------------------------------------------------------------------------------
def load_dict(self):
"""
Reload textfields from filter dictionary to update changed settings
"""
for i in range(len(self.qlineedit)):
weight_value = fb.fil[0][str(self.qlineedit[i].objectName())]
if not self.qlineedit[i].hasFocus():
# widget has no focus, round the display
self.qlineedit[i].setText(params['FMT'].format(weight_value))
else:
# widget has focus, show full precision
self.qlineedit[i].setText(str(weight_value))
# ------------------------------------------------------------------------------
def _store_entry(self, widget):
"""
When the textfield of `widget` has been edited (`self.spec_edited` = True),
store the weight spec in filter dict. This is triggered by `QEvent.focusOut`
"""
if self.spec_edited:
w_label = str(widget.objectName())
w_value = safe_eval(widget.text(), fb.data_old, sign='pos')
if w_value < 1:
w_value = 1
if w_value > 1.e6:
w_value = 1.e6
fb.fil[0].update({w_label: w_value})
self.emit({'specs_changed': 'w_specs'})
self.spec_edited = False # reset flag
self.load_dict()
# -------------------------------------------------------------
def _hide_entries(self, num_new_labels):
"""
Hide subwidgets so that only `len_new_labels` subwidgets are visible
"""
for i in range(num_new_labels, len(self.qlabels)):
self.qlabels[i].hide()
self.qlineedit[i].hide()
# ------------------------------------------------------------------------
def _show_entries(self, num_new_labels):
"""
- check whether enough subwidgets (QLabel und QLineEdit) exist for the
the required number of `num_new_labels`:
- create new ones if required
- initialize them with dummy information
- install eventFilter for new QLineEdit widgets so that the filter
dict is updated automatically when a QLineEdit field has been
edited.
- if enough subwidgets exist already, make enough of them visible to
show all spec fields
"""
num_tot_labels = len(self.qlabels) # number of existing labels / qlineedit fields
if num_tot_labels < num_new_labels: # new widgets need to be generated
for i in range(num_tot_labels, num_new_labels):
self.qlabels.append(QLabel(self))
self.qlabels[i].setText(to_html("dummy", frmt='bi'))
self.qlineedit.append(QLineEdit(""))
self.qlineedit[i].setObjectName("dummy")
self.qlineedit[i].installEventFilter(self) # filter events
# first entry is title and reset button
self.layGSpecs.addWidget(self.qlabels[i], i+1, 0)
self.layGSpecs.addWidget(self.qlineedit[i], i+1, 1)
else: # make the right number of widgets visible
for i in range(self.n_cur_labels, num_new_labels):
self.qlabels[i].show()
self.qlineedit[i].show()
# ------------------------------------------------------------------------------
def _reset_weights(self):
"""
Reset all entries to "1.0" and store them in the filter dictionary
"""
for i in range(len(self.qlineedit)):
self.qlineedit[i].setText("1")
w_label = str(self.qlineedit[i].objectName())
fb.fil[0].update({w_label: 1})
self.load_dict()
self.emit({'specs_changed': 'w_specs'})