1821 lines
69 KiB
Python
1821 lines
69 KiB
Python
""" Base frame
|
|
"""
|
|
from datetime import datetime
|
|
from decimal import Decimal
|
|
import inspect
|
|
import os
|
|
import re
|
|
|
|
from matplotlib.backends.backend_qt5agg import (
|
|
FigureCanvasQTAgg, NavigationToolbar2QT as NavigationToolbar)
|
|
|
|
from qtpy.QtCore import QSize, Qt, Slot
|
|
from qtpy.QtGui import QColor, QFont, QFontMetricsF, QIcon, QPainter, QPixmap
|
|
from qtpy.QtWidgets import (QCheckBox, QComboBox, QDoubleSpinBox, QFrame,
|
|
QGridLayout, QGroupBox, QHBoxLayout, QLabel,
|
|
QLineEdit, QPushButton, QRadioButton, QSpinBox,
|
|
QStackedWidget, QTabBar, QTabWidget, QToolButton,
|
|
QVBoxLayout, QWidget)
|
|
from caqtwidgets.pvwidgets import (CAQLabel, CAQTableWidget, QMessageWidget,
|
|
QHLine)
|
|
|
|
from pyqtacc.bdbase.enumkind import Facility, MsgSeverity, UserMode
|
|
|
|
_pymodule = os.path.basename(__file__)
|
|
_appversion = "1.0.0"
|
|
|
|
INPUT_PARAMETERS_HEIGHT = 200
|
|
EXPERT_PARAMETERS_HEIGHT = 200
|
|
|
|
|
|
def _line():
|
|
"""Macro to return the current line number.
|
|
|
|
The current line number within the file is used when
|
|
reporting messages to the message logging window.
|
|
|
|
Returns:
|
|
int: Current line number.
|
|
"""
|
|
return inspect.currentframe().f_back.f_lineno
|
|
|
|
class GUIFrame(QWidget):
|
|
""" GUI Class
|
|
"""
|
|
def __init__(self, parent, has_optics=True):
|
|
#super(GUIFrame, self).__init__()
|
|
super().__init__()
|
|
self.parent = parent
|
|
self.has_optics = has_optics
|
|
self.appname = parent.appname
|
|
self.facility = parent.facility
|
|
self.settings = parent.settings
|
|
self.cafe = parent.cafe
|
|
self.cyca = parent.cyca
|
|
self.input_parameters = parent.input_parameters
|
|
self.input_labels = parent.input_labels
|
|
self.expert_parameters = parent.expert_parameters
|
|
self.expert_labels = parent.expert_labels
|
|
self.all_input_parameters = parent.all_input_parameters
|
|
self.all_input_labels = parent.all_input_labels
|
|
self.all_expert_parameters = parent.all_expert_parameters
|
|
self.all_expert_labels = parent.all_expert_labels
|
|
|
|
try:
|
|
self.widget_height = self.settings.data["StyleGuide"][
|
|
"widgetHeight"]
|
|
except KeyError as error:
|
|
print("KeyError in guiframe.py, init:", error)
|
|
self.widget_height = 25
|
|
|
|
self.autopost_elog = parent.autopost_elog
|
|
self.autopost_epics = parent.autopost_epics
|
|
self.autopost_hdf = parent.autopost_hdf
|
|
self.autopost_save = None
|
|
|
|
self.expert_parameters_group = None
|
|
self.operator_parameters_group = None
|
|
self.optics_group = None
|
|
|
|
self.energy_stacked_widget = None
|
|
self.phase_stacked_widget = None
|
|
|
|
self.table_tab_wgt = None
|
|
self.radiobutton = None
|
|
self.multiple_figure_dict = None
|
|
|
|
self.line_sender_dict = {}
|
|
self.radio_stack_dict = {}
|
|
self.stack_radiolist_dict = {}
|
|
self.stacked_wgt_dict = {}
|
|
self.current_stacked_wgt_dict = {}
|
|
|
|
self.msg_severity_qcolor = parent.msg_severity_qcolor
|
|
self.msg_severity = MsgSeverity
|
|
self.font_gui = QFont("sans serif")
|
|
self.font_gui.setPointSize(11)
|
|
self.font_pts10 = QFont("sans serif")
|
|
self.font_pts10.setPointSize(10)
|
|
self.central_tab_widget = QTabWidget()
|
|
|
|
self.measurement_wgt = QWidget()
|
|
#self.measurement_layout = QHBoxLayout(self.measurement_wgt)
|
|
self.measurement_layout = QGridLayout(self.measurement_wgt)
|
|
self.measurement_layout.setAlignment(Qt.AlignLeft | Qt.AlignTop)
|
|
self.measurement_layout.setSpacing(50)
|
|
self.measurement_tab_wgt = QTabWidget(self.measurement_wgt)
|
|
self.measurement_tab_wgt.setMinimumWidth(480)
|
|
|
|
self.operator_wgt = QWidget(self.measurement_tab_wgt)
|
|
self.expert_wgt = QWidget(self.measurement_tab_wgt)
|
|
|
|
self.results_wgt = QWidget()
|
|
self.results_layout = QHBoxLayout(self.results_wgt)
|
|
self.results_tab_wgt = QTabWidget(self.results_wgt)
|
|
|
|
self.canvas_fig_dict = {}
|
|
|
|
self.left_arrow_dict = {}
|
|
self.right_arrow_dict = {}
|
|
|
|
self.analysis_wgt = QWidget()
|
|
self.abort_wgt = QWidget()
|
|
self.start_wgt = QWidget()
|
|
self.start_wgt_text = "Start"
|
|
self.save_all_wgt = QWidget()
|
|
|
|
if "GUI" in self.settings.data:
|
|
self.results_tab_wgt_titles = self.settings.data[
|
|
"GUI"]["subResultsTabTitle"]
|
|
|
|
self.sub_results_wgt = [None] * len(self.results_tab_wgt_titles)
|
|
self.sub_results_layout = [None] * len(self.results_tab_wgt_titles)
|
|
|
|
for i in range(0, len(self.results_tab_wgt_titles)):
|
|
self.sub_results_wgt[i] = QWidget(self.results_tab_wgt)
|
|
|
|
self.canvas = [None] * len(self.results_tab_wgt_titles)
|
|
self.nav = [None] * len(self.results_tab_wgt_titles)
|
|
|
|
self.arrow_button_widget = [None] * len(self.results_tab_wgt_titles)
|
|
self.canvas_current_idx = [0] * len(self.results_tab_wgt_titles)
|
|
self.init_results_tab_wgt()
|
|
|
|
|
|
self.slice_orientation = "vertical" #horizontal/vertical for SATMA02
|
|
|
|
self.init_measurement_tab_wgt()
|
|
|
|
self.log_wgt = QMessageWidget()
|
|
self.log_layout = QVBoxLayout(self.log_wgt)
|
|
#self.show_log_message(MsgSeverity.INFO, _pymodule, _line(),
|
|
# "Application started")
|
|
|
|
self.input_wgt_grid = QGridLayout()
|
|
self.input_wgt_grid.setHorizontalSpacing(0)
|
|
self.input_wgt_grid.setVerticalSpacing(2)
|
|
|
|
self.expert_wgt_grid = QGridLayout()
|
|
self.expert_wgt_grid.setHorizontalSpacing(0)
|
|
self.expert_wgt_grid.setVerticalSpacing(2)
|
|
|
|
self.init_central_tab_widget()
|
|
self.enter_input_parameters()
|
|
|
|
def init_central_tab_widget(self):
|
|
""" Add tabs to central widget
|
|
"""
|
|
self.central_tab_widget.setFont(self.font_gui)
|
|
self.central_tab_widget.addTab(self.measurement_wgt, "Measurement")
|
|
if "GUI" in self.settings.data:
|
|
self.central_tab_widget.addTab(
|
|
self.results_wgt, self.settings.data["GUI"]["resultsTabTitle"])
|
|
self.central_tab_widget.addTab(self.log_wgt, "Log")
|
|
|
|
def init_measurement_tab_wgt(self):
|
|
""" Add tabs to measurement widget
|
|
"""
|
|
self.measurement_tab_wgt.setFont(self.font_gui)
|
|
self.measurement_tab_wgt.addTab(self.operator_wgt, "Operator")
|
|
self.measurement_tab_wgt.addTab(self.expert_wgt, "Expert")
|
|
self.measurement_layout.addWidget(self.measurement_tab_wgt, 0, 0)
|
|
|
|
def init_results_tab_wgt(self):
|
|
""" Add canvas tabs for plots/results
|
|
"""
|
|
self.results_tab_wgt.setFont(self.font_gui)
|
|
|
|
for i, (wgt, subtitle) in enumerate(zip(self.sub_results_wgt,
|
|
self.results_tab_wgt_titles)):
|
|
|
|
top_widget = QWidget(self.results_tab_wgt)
|
|
top_layout = QVBoxLayout()
|
|
self.sub_results_layout[i] = QVBoxLayout()
|
|
|
|
if self.settings.data["GUI"]["resultsSeq"][i] > 1:
|
|
top_layout.addWidget(self.get_arrow_button_widget(i))
|
|
|
|
wgt.setLayout(self.sub_results_layout[i])
|
|
top_layout.addWidget(wgt)
|
|
|
|
top_widget.setLayout(top_layout)
|
|
self.results_tab_wgt.addTab(top_widget, subtitle)
|
|
|
|
self.results_layout.addWidget(self.results_tab_wgt)
|
|
|
|
|
|
def show_log_message(self, severity=None, pymodule="", lineno=0, message="",
|
|
options=None):
|
|
""" Post to log window
|
|
"""
|
|
source = "{0}:{1:d} ".format(pymodule, lineno)
|
|
#datetime.utcnow()
|
|
message_to_send = datetime.now().strftime(
|
|
"%Y-%m-%d %H:%M:%S.%f")[:-5]
|
|
message_to_send += " "
|
|
if isinstance(severity, self.msg_severity):
|
|
message_to_send += severity.name
|
|
elif severity in self.msg_severity_qcolor.keys():
|
|
message_to_send += str(severity)
|
|
elif str(severity) == "WARNING":
|
|
message_to_send += "WARN"
|
|
message_to_send += (" {" + source + message + "} ")
|
|
if options:
|
|
for k, v in options.items():
|
|
message_to_send += (" [" + str(k) + ": " + str(v) + "]")
|
|
|
|
self.log_wgt.insertItem(0, message_to_send)
|
|
self.log_wgt.item(0).setFlags(
|
|
Qt.ItemIsSelectable | Qt.ItemIsDragEnabled | Qt.ItemIsEnabled |
|
|
Qt.NoItemFlags)
|
|
self.log_wgt.item(0).setForeground(
|
|
self.msg_severity_qcolor.get(severity, QColor(8, 8, 8)))
|
|
|
|
|
|
#Top level groups
|
|
def analysis_procedure_group(self):
|
|
""" Procedure group box
|
|
"""
|
|
group_box = QGroupBox("Procedure")
|
|
group_box.setObjectName("OUTER")
|
|
hbox = QVBoxLayout()
|
|
hbox.addLayout(self.create_analysis_wgt())
|
|
hbox.setContentsMargins(9, 19, 9, 9)
|
|
hbox.setSpacing(5)
|
|
hbox.setAlignment(Qt.AlignTop | Qt.AlignHCenter)
|
|
group_box.setMaximumWidth(208)
|
|
group_box.setMinimumHeight(196)
|
|
group_box.setFont(self.font_gui)
|
|
group_box.setAlignment(Qt.AlignTop | Qt.AlignHCenter)
|
|
group_box.setLayout(hbox)
|
|
return group_box
|
|
|
|
def optics_groupbox(self):
|
|
""" Optice set and restore group box
|
|
"""
|
|
self.optics_group = QGroupBox("Optics")
|
|
self.optics_group.setObjectName("OUTER")
|
|
self.optics_group.setMaximumWidth(208)
|
|
self.optics_group.setMaximumHeight(220)
|
|
self.optics_group.setFont(self.font_gui)
|
|
self.optics_group.setAlignment(Qt.AlignTop | Qt.AlignHCenter)
|
|
self.optics_group.setAlignment(Qt.AlignCenter)
|
|
self.optics_group.setLayout(self.create_optics_layout())
|
|
self.optics_group.table = None
|
|
self.optics_group.deflector = None
|
|
self.optics_group.profile_monitor = None
|
|
self.optics_group.quads = None
|
|
self.optics_group.cycle_quads = None
|
|
return self.optics_group
|
|
|
|
def input_parameters_group(self, title="Input Parameters"):
|
|
""" Generic group box for user supplied input
|
|
"""
|
|
group_box = QGroupBox(title)
|
|
group_box.setObjectName("OUTER")
|
|
hbox = QVBoxLayout()
|
|
hbox.setContentsMargins(9, 19, 9, 9)
|
|
hbox.setAlignment(Qt.AlignTop | Qt.AlignHCenter)
|
|
group_box.setContentsMargins(0, 0, 0, 0)
|
|
group_box.setMinimumWidth(200)
|
|
group_box.setMaximumHeight(400)
|
|
group_box.setFont(self.font_gui)
|
|
group_box.setAlignment(Qt.AlignTop | Qt.AlignHCenter)
|
|
group_box.setLayout(hbox)
|
|
return group_box
|
|
|
|
def operator_parameters_groupbox(self, title="Input Parameters"):
|
|
""" Operator input parameters group box
|
|
"""
|
|
self.operator_parameters_group = self.input_parameters_group(title)
|
|
return self.operator_parameters_group
|
|
|
|
def expert_parameters_groupbox(self, title="Expert Parameters"):
|
|
""" Expert input parameters group box
|
|
"""
|
|
self.expert_parameters_group = self.input_parameters_group(title)
|
|
return self.expert_parameters_group
|
|
|
|
|
|
def create_checkbox(self, top_key, key, text="", tip="",
|
|
default_value=Qt.Unchecked):
|
|
""" Generic check box
|
|
"""
|
|
|
|
def on_checkbox_change(value):
|
|
self.input_parameters[key] = bool(value)
|
|
#print("CB fired")
|
|
#print(self.input_parameters[key])
|
|
#print(self.input_parameters)
|
|
|
|
checkbox = QCheckBox(text)
|
|
checkbox.setToolTip(tip)
|
|
checkbox.setFont(self.font_gui)
|
|
checkbox.stateChanged.connect(on_checkbox_change)
|
|
#checkbox.setFixedHeight(30)
|
|
|
|
checked_value = default_value
|
|
if key in self.parent.input_parameters.keys():
|
|
if "data" in self.settings.data[top_key][key].keys():
|
|
if "value" in self.settings.data[top_key][key]["data"].keys():
|
|
if self.settings.data[top_key][key]["data"]["value"]:
|
|
checked_value = Qt.Checked
|
|
else:
|
|
checked_value = Qt.Unchecked
|
|
|
|
checkbox.setCheckState(checked_value)
|
|
|
|
return checkbox
|
|
|
|
def create_label_qdoublespinbox(self, key, label="", min_val=0, max_val=1,
|
|
step=0.1, start_val=0.5):
|
|
""" Generic QDoubleSpinbox with buddy label
|
|
"""
|
|
|
|
def callback(value):
|
|
self.input_parameters[key] = value
|
|
|
|
widget_height = 24
|
|
suggested = "WWW"
|
|
lab = QLabel(label)
|
|
lab.setFixedHeight(widget_height)
|
|
lab.setFont(self.font_pts10)
|
|
lab.setContentsMargins(5, 0, 0, 0)
|
|
wgt = QDoubleSpinBox()
|
|
wgt.setObjectName("Write")
|
|
wgt.setFixedHeight(widget_height)
|
|
wgt.setFont(self.font_pts10)
|
|
wgt.setContentsMargins(5, 0, 0, 0)
|
|
decimal = Decimal(str(step))
|
|
wgt.setDecimals(abs(decimal.as_tuple().exponent)) #precision
|
|
wgt.setRange(min_val, max_val)
|
|
wgt.setSingleStep(step)
|
|
fm = QFontMetricsF(wgt.font())
|
|
param_width = max(fm.width(str(decimal)), fm.width(suggested))
|
|
wgt.setMaximumWidth(param_width + 40)
|
|
wgt.valueChanged.connect(callback)
|
|
wgt.setValue(start_val)
|
|
return lab, wgt
|
|
|
|
|
|
def create_label_qspinbox(self, key, label="", min_val=0, max_val=100,
|
|
step=1, start_val=5):
|
|
""" Generic QSpinbox with buddy label
|
|
"""
|
|
|
|
def cb(value):
|
|
self.input_parameters[key] = value
|
|
|
|
widget_height = 24
|
|
suggested = "WWW"
|
|
lab = QLabel(label)
|
|
lab.setFixedHeight(widget_height)
|
|
lab.setFont(self.font_pts10)
|
|
lab.setContentsMargins(5, 0, 0, 0)
|
|
wgt = QSpinBox()
|
|
wgt.setObjectName("Write")
|
|
wgt.setFixedHeight(widget_height)
|
|
wgt.setFont(self.font_pts10)
|
|
wgt.setContentsMargins(5, 0, 0, 0)
|
|
decimal = Decimal(str(step))
|
|
wgt.setRange(min_val, max_val)
|
|
wgt.setSingleStep(step)
|
|
fm = QFontMetricsF(wgt.font())
|
|
param_width = max(fm.width(str(decimal)), fm.width(suggested))
|
|
wgt.setMaximumWidth(param_width + 40)
|
|
wgt.valueChanged.connect(cb)
|
|
wgt.setValue(start_val)
|
|
return lab, wgt
|
|
|
|
|
|
def create_label_qcombobox(self, key, label="", values: list = []):
|
|
""" Generic QCombobox with buddy label
|
|
"""
|
|
|
|
def cb(new_text):
|
|
self.input_parameters[key] = new_text
|
|
|
|
widget_height = 26
|
|
suggested = "WWW"
|
|
lab = QLabel(label)
|
|
lab.setFixedHeight(widget_height)
|
|
lab.setFont(self.font_pts10)
|
|
lab.setContentsMargins(5, 0, 0, 0)
|
|
wgt = QComboBox()
|
|
wgt.clear()
|
|
if values:
|
|
wgt.addItems(values)
|
|
wgt.setObjectName("Write")
|
|
wgt.setFixedHeight(widget_height)
|
|
wgt.setFont(self.font_pts10)
|
|
wgt.setContentsMargins(5, 0, 0, 0)
|
|
wgt.currentTextChanged.connect(cb)
|
|
wgt.setCurrentIndex(0)
|
|
wgt.currentTextChanged.emit(values[0])
|
|
|
|
value_for_width = max(values, key=len)
|
|
|
|
fm = QFontMetricsF(wgt.font())
|
|
param_width = max(fm.width(str(value_for_width)), fm.width(suggested))
|
|
wgt.setFixedWidth(param_width + 50)
|
|
|
|
|
|
return lab, wgt
|
|
|
|
def image_parameters_group(self):
|
|
group_box = QGroupBox("Image Pipeline Parameters")
|
|
|
|
box = QHBoxLayout()
|
|
box.setSpacing(10)
|
|
box.addWidget(self.create_checkbox(
|
|
top_key="Expert", key="goodRegion", text="Good region",
|
|
tip="Enables good region in pipeline", default_value=Qt.Checked))
|
|
|
|
box.addWidget(self.create_checkbox(
|
|
top_key="Expert", key="subtractBackground",
|
|
text="Subtract bkgrnd",
|
|
tip="Enables background subtraction in pipeline",
|
|
default_value=Qt.Checked))
|
|
|
|
group_box.setAlignment(Qt.AlignCenter)
|
|
group_box.setObjectName("INNERCENTER")
|
|
|
|
good_region = QGroupBox("Good Region")
|
|
good_region.setObjectName("INNER")
|
|
|
|
lab_thresh, thresh = self.create_label_qdoublespinbox(
|
|
key="grThreshold", label="Threshold:")
|
|
lab_gfscale, gfscale = self.create_label_qspinbox(
|
|
key="grScale", label="Scale:")
|
|
layout = QGridLayout()
|
|
layout.addWidget(lab_thresh, 0, 0)
|
|
layout.addWidget(thresh, 0, 1)
|
|
layout.addWidget(lab_gfscale, 1, 0)
|
|
layout.addWidget(gfscale, 1, 1)
|
|
good_region.setLayout(layout)
|
|
|
|
slicing = QGroupBox("Slicing")
|
|
slicing.setObjectName("INNER")
|
|
|
|
lab_slices, slices = self.create_label_qspinbox(
|
|
key="slices", label="No. Slices:", start_val=21)
|
|
lab_scale, scale = self.create_label_qspinbox(
|
|
key="slicingScale", label="Scale:")
|
|
lab_orientation, self.slice_orientation = self.create_label_qcombobox(
|
|
key="orientation", label="Orientation:",
|
|
values=["vertical", "horizontal"])
|
|
|
|
layout = QGridLayout()
|
|
|
|
layout.addWidget(lab_slices, 0, 0)
|
|
layout.addWidget(slices, 0, 1)
|
|
layout.addWidget(lab_scale, 1, 0)
|
|
layout.addWidget(scale, 1, 1)
|
|
layout.addWidget(lab_orientation, 2, 0, 1, 2, Qt.AlignBottom)
|
|
layout.addWidget(self.slice_orientation, 3, 0, 1, 2, Qt.AlignTop | Qt.AlignRight)
|
|
slicing.setLayout(layout)
|
|
|
|
layout_top = QGridLayout()
|
|
layout_top.addLayout(box, 0, 0, 1, 2)
|
|
layout_top.addWidget(good_region, 1, 0, 1, 1,
|
|
Qt.AlignHCenter | Qt.AlignTop)
|
|
layout_top.addWidget(slicing, 1, 1, 1, 1, Qt.AlignCenter | Qt.AlignTop)
|
|
layout_top.setHorizontalSpacing(8)
|
|
group_box.setLayout(layout_top)
|
|
group_box.setFixedHeight(200)
|
|
return group_box
|
|
|
|
|
|
def create_analysis_wgt(
|
|
self, start_title="Start", start_action=None,
|
|
start_tooltip="Start measurement and analysis procedure",
|
|
abort_title="Abort", abort_action=None,
|
|
abort_tooltip="Abort procedure at next break point"):
|
|
|
|
if start_action is None:
|
|
start_action = self.parent.start_analysis_thread
|
|
if abort_action is None:
|
|
abort_action = self.parent.receive_abort_analysis
|
|
|
|
self.start_wgt = self.create_start_wgt(start_title, start_action,
|
|
start_tooltip)
|
|
self.abort_wgt = self.create_abort_wgt(abort_title, abort_action,
|
|
abort_tooltip)
|
|
|
|
self.save_all_wgt = self.save_all_group()
|
|
grid = QVBoxLayout()
|
|
grid.addWidget(self.start_wgt)
|
|
grid.addWidget(self.abort_wgt)
|
|
grid.addWidget(self.save_all_wgt)
|
|
grid.setAlignment(Qt.AlignLeft | Qt.AlignTop)
|
|
|
|
return grid
|
|
|
|
|
|
def create_optics_layout(self):
|
|
vbox = QGridLayout()
|
|
self.set_optics_btn = QPushButton("Set")
|
|
self.set_optics_btn.setFixedWidth(100)
|
|
self.set_optics_btn.setFixedHeight(40)
|
|
self.set_optics_btn.setObjectName("Controller")
|
|
self.set_optics_btn.setProperty("actOnBeam", True)
|
|
self.set_optics_btn.clicked.connect(self.parent.set_optics)
|
|
_tip = "Set associated quadruples"
|
|
self.set_optics_btn.setToolTip(_tip)
|
|
self.restore_optics_btn = QPushButton("Restore")
|
|
self.restore_optics_btn.setFixedWidth(100)
|
|
self.restore_optics_btn.setFixedHeight(40)
|
|
self.restore_optics_btn.setObjectName("Controller")
|
|
self.restore_optics_btn.setProperty("actOnBeam", True)
|
|
self.restore_optics_btn.clicked.connect(self.parent.restore_optics)
|
|
_tip = "Restore quadruples to their pre-measurement values"
|
|
self.restore_optics_btn.setToolTip(_tip)
|
|
|
|
#_text = """<p> <font style="color:{0}; background-color:'white'";>
|
|
# {1} <br> {2} </font>
|
|
# </p>
|
|
# """.format('gray', 'Deflector', 'PM')
|
|
self.target_optics = QLabel()
|
|
#self.target_optics.setText(_text)
|
|
self.target_optics.setFixedWidth(150)
|
|
self.target_optics.setFixedHeight(40)
|
|
self.target_optics.setStyleSheet("background-color:white;")
|
|
_tip = "Shows target for optics settings"
|
|
self.target_optics.setToolTip(_tip)
|
|
vbox.addWidget(self.set_optics_btn, 0, 0, Qt.AlignCenter)
|
|
vbox.addWidget(self.target_optics, 1, 0, Qt.AlignCenter)
|
|
vbox.addWidget(self.restore_optics_btn, 2, 0, Qt.AlignCenter)
|
|
vbox.setContentsMargins(0, 19, 0, 9)
|
|
vbox.setAlignment(Qt.AlignCenter)
|
|
vbox.setSpacing(8)
|
|
return vbox
|
|
|
|
def in_measurement_procedure(self):
|
|
self.abort_wgt.setVisible(True)
|
|
self.abort_wgt.setEnabled(True)
|
|
self.start_wgt.setEnabled(False)
|
|
self.start_wgt.setText("in progress...")
|
|
self.save_all_group_box.setEnabled(False)
|
|
self.operator_parameters_group.setEnabled(False)
|
|
self.expert_parameters_group.setEnabled(False)
|
|
if self.optics_group is not None:
|
|
self.optics_group.setEnabled(False)
|
|
if self.table_tab_wgt is not None:
|
|
for table in self.table_wgt:
|
|
table.init_value_button.setEnabled(False)
|
|
table.restore_value_button.setEnabled(False)
|
|
|
|
def in_abort_procedure(self):
|
|
self.abort_wgt.setEnabled(False)
|
|
self.start_wgt.setEnabled(False)
|
|
self.start_wgt.setText("Aborting...")
|
|
|
|
|
|
def reset_procedure(self):
|
|
self.abort_wgt.setVisible(False)
|
|
self.abort_wgt.setEnabled(True)
|
|
self.start_wgt.setEnabled(True)
|
|
self.start_wgt.setText(self.start_wgt_text)
|
|
self.save_all_group_box.setEnabled(True)
|
|
self.operator_parameters_group.setEnabled(True)
|
|
self.expert_parameters_group.setEnabled(True)
|
|
if self.optics_group is not None:
|
|
self.optics_group.setEnabled(True)
|
|
if self.table_tab_wgt is not None:
|
|
for table in self.table_wgt:
|
|
table.init_value_button.setEnabled(True)
|
|
table.restore_value_button.setEnabled(True)
|
|
|
|
def in_hdf_measurement_procedure(self):
|
|
self.parent.h5_groupbox.analyze_h5_widget.setEnabled(False)
|
|
self.parent.h5_groupbox.analyze_h5_widget.setText("Analysing")
|
|
self.start_wgt.setEnabled(False)
|
|
self.start_wgt.setText("HDF analysis...")
|
|
self.save_all_group_box.setEnabled(False)
|
|
|
|
def hdf_reset_procedure(self):
|
|
self.parent.h5_groupbox.analyze_h5_widget.setEnabled(True)
|
|
self.parent.h5_groupbox.analyze_h5_widget.setText("Analyze")
|
|
self.start_wgt.setEnabled(True)
|
|
self.start_wgt.setText(self.start_wgt_text)
|
|
self.save_all_group_box.setEnabled(True)
|
|
|
|
def create_abort_wgt(self, title, action, tooltip):
|
|
abort_wgt = QPushButton(title)
|
|
abort_wgt.setObjectName("Abort")
|
|
abort_wgt.setFixedWidth(150)
|
|
abort_wgt.setFixedHeight(40)
|
|
abort_wgt.setToolTip(tooltip)
|
|
if action:
|
|
abort_wgt.clicked.connect(action)
|
|
abort_wgt.setVisible(False)
|
|
sp_retain = abort_wgt.sizePolicy()
|
|
sp_retain.setRetainSizeWhenHidden(True)
|
|
abort_wgt.setSizePolicy(sp_retain)
|
|
return abort_wgt
|
|
|
|
def create_start_wgt(self, title, action, tooltip):
|
|
start_wgt = QPushButton(title)
|
|
start_wgt.setObjectName("Controller")
|
|
start_wgt.setProperty("actOnBeam", True)
|
|
start_wgt.setFixedWidth(150)
|
|
start_wgt.setFixedHeight(40)
|
|
start_wgt.setToolTip(tooltip)
|
|
if action:
|
|
start_wgt.clicked.connect(action)
|
|
start_wgt.setVisible(True)
|
|
return start_wgt
|
|
|
|
def combine_save_icons(self): #epics=False, hdf=False, elog=False):
|
|
epics = self.autopost_epics
|
|
hdf = self.autopost_hdf
|
|
elog = self.autopost_elog
|
|
combinedIcon = QIcon()
|
|
startx1 = 0
|
|
startx2 = 0
|
|
startx3 = 0
|
|
true_list = [epics, hdf, elog]
|
|
if true_list.count(True) == 1:
|
|
startx1 = 150
|
|
startx2 = 150
|
|
startx3 = 150
|
|
elif true_list.count(True) == 3:
|
|
startx1 = 0
|
|
startx2 = 150
|
|
startx3 = 300
|
|
else:
|
|
if epics:
|
|
startx1 = 75
|
|
startx2 = 225
|
|
startx3 = 225
|
|
elif hdf:
|
|
startx2 = 75
|
|
startx3 = 225
|
|
comboPixmap = QPixmap(420, 100) #420, 100
|
|
comboPixmap.fill(Qt.transparent)
|
|
epicsImage = QPixmap(":/epics.png")
|
|
hdfImage = QPixmap(":/hdfS.png")
|
|
elogImage = QPixmap(":/elog.png")
|
|
painter = QPainter(comboPixmap)
|
|
if epics:
|
|
painter.drawPixmap(startx1, 0, epicsImage, 0, -20, 100, 160)
|
|
if hdf:
|
|
painter.drawPixmap(startx2, 0, hdfImage, 0, -20, 100, 160)
|
|
if elog:
|
|
painter.drawPixmap(startx3, 0, elogImage)
|
|
combinedIcon.addPixmap(comboPixmap)
|
|
painter.end()
|
|
return combinedIcon
|
|
|
|
def post_measurement_save_button(self): # epics=True, hdf=True, elog=True):
|
|
epics = self.autopost_epics #= epics
|
|
hdf = self.autopost_hdf #= hdf
|
|
elog = self.autopost_elog #= elog
|
|
widget_height = 40
|
|
true_list = [epics, hdf, elog]
|
|
widget_width = max(75, 45 * true_list.count(True))
|
|
save_data_btn = QPushButton("")
|
|
save_data_btn.setIconSize(QSize(100, 38))
|
|
save_data_btn.setIcon(self.combine_save_icons())
|
|
#epics=epics, hdf=hdf, elog=elog))
|
|
save_data_btn.setFixedHeight(widget_height)
|
|
save_data_btn.setObjectName("WriteData")
|
|
save_data_btn.clicked.connect(self.parent.write_to_destinations)
|
|
save_data_btn.setFixedHeight(widget_height)
|
|
save_data_btn.setFixedWidth(widget_width) #80 for one
|
|
if epics and hdf and elog:
|
|
choices = "epics/hdf5/elog"
|
|
elif epics and hdf:
|
|
choices = "epics/hdf5"
|
|
elif hdf and elog:
|
|
choices = "hdf/elog"
|
|
elif epics:
|
|
choices = "epics"
|
|
elif hdf:
|
|
choices = "hdf"
|
|
elif elog:
|
|
choices = "elog"
|
|
_tip = "Saves data to {0}".format(choices)
|
|
save_data_btn.setToolTip(_tip)
|
|
self.autopost_save = save_data_btn
|
|
return self.autopost_save
|
|
|
|
def post_measurement_group(self):
|
|
group_box = QGroupBox("Post-measurement")
|
|
group_box.setObjectName("OUTER")
|
|
hbox = QVBoxLayout()
|
|
hbox.addWidget(self.post_measurement_save_button())
|
|
hbox.setContentsMargins(9, 19, 9, 9)
|
|
hbox.setAlignment(Qt.AlignTop | Qt.AlignHCenter)
|
|
group_box.setContentsMargins(0, 0, 0, 0)
|
|
group_box.setFixedWidth(208)
|
|
group_box.setMaximumHeight(130)
|
|
group_box.setFont(self.font_gui)
|
|
group_box.setAlignment(Qt.AlignTop | Qt.AlignHCenter)
|
|
group_box.setLayout(hbox)
|
|
return group_box
|
|
|
|
def save_all_group(self):
|
|
self.save_all_group_box = QGroupBox("Save All")
|
|
self.save_all_group_box.setObjectName("INNERCENTER")
|
|
hbox = QVBoxLayout()
|
|
hbox.addWidget(self.post_measurement_save_button())
|
|
hbox.setContentsMargins(1, 4, 1, 2)
|
|
hbox.setAlignment(Qt.AlignTop | Qt.AlignHCenter)
|
|
self.save_all_group_box.setContentsMargins(0, 0, 0, 0)
|
|
self.save_all_group_box.setMaximumWidth(160)
|
|
self.save_all_group_box.setFixedHeight(60)
|
|
self.save_all_group_box.setFont(self.font_gui)
|
|
self.save_all_group_box.setAlignment(Qt.AlignTop | Qt.AlignHCenter)
|
|
self.save_all_group_box.setLayout(hbox)
|
|
return self.save_all_group_box
|
|
|
|
|
|
def checkbox_wgt(self, key: str = "", tooltip: str = "", object_name=None,
|
|
hline="NONE"):
|
|
def on_change(state):
|
|
self.input_parameters[key] = bool(state)
|
|
|
|
widget = QWidget()
|
|
layout = QGridLayout()
|
|
layout.setContentsMargins(0, 0, 0, 0)
|
|
row_wgt = 0
|
|
if hline == "TOP":
|
|
layout.addWidget(QHLine(), 0, 0, 1, 3)
|
|
row_wgt = 1
|
|
try:
|
|
text = self.settings.data["Expert"][key]["data"]["text"]
|
|
except KeyError as error:
|
|
print(("KeyError in guiframe.py; Unknown key {0} " +
|
|
"in def checkbox_wgt: {1}").format(key, error))
|
|
text = key
|
|
|
|
checkbox = QCheckBox(text)
|
|
checkbox.setToolTip(tooltip)
|
|
checkbox.setFont(self.font_gui)
|
|
if object_name:
|
|
checkbox.setObjectName(object_name)
|
|
|
|
checkbox.stateChanged.connect(on_change)
|
|
checked_value = Qt.Unchecked
|
|
|
|
if "Expert" not in self.settings.data:
|
|
return widget
|
|
#if key in self.parent.input_parameters.keys():
|
|
if key in self.settings.data["Expert"].keys():
|
|
if "data" in self.settings.data["Expert"][key].keys():
|
|
if "value" in self.settings.data["Expert"][key]["data"].keys():
|
|
if self.settings.data["Expert"][key]["data"]["value"]:
|
|
checked_value = Qt.Checked
|
|
|
|
checkbox.setCheckState(checked_value)
|
|
|
|
layout.addWidget(checkbox, row_wgt, 0)
|
|
layout.addWidget(QFrame(), row_wgt, 1, 1, 2)
|
|
|
|
if hline == "BOTTOM":
|
|
layout.addWidget(QHLine(), row_wgt+1, 0, 1, 3)
|
|
widget.setLayout(layout)
|
|
return widget
|
|
|
|
def checkbox_rawdata(self, hline="None"):
|
|
tooltip = ("Save scanned data to separate hdf file " +
|
|
"(for later reanalysis)")
|
|
return self.checkbox_wgt(key="rawData", tooltip=tooltip, hline=hline)
|
|
|
|
def checkbox_autoRestore(self, hline="None"):
|
|
tooltip = ("Automatically restores quads to initial values before " +
|
|
"new setting or exit")
|
|
return self.checkbox_wgt(key="autoRestore", tooltip=tooltip,
|
|
hline=hline)
|
|
|
|
def checkbox_keepImages(self, hline="None"):
|
|
tooltip = ("Store plots/images on disk")
|
|
return self.checkbox_wgt(key="keepImages", tooltip=tooltip, hline=hline)
|
|
|
|
def checkbox_autoCycle(self, hline="None"):
|
|
tooltip = ("Always cycle quads when setting to new values")
|
|
return self.checkbox_wgt(key="autoCycle", tooltip=tooltip,
|
|
hline=hline)
|
|
|
|
def checkbox_debug(self, hline="None"):
|
|
tooltip = "Activates print statements in user code"
|
|
self.input_parameters["debug"] = False
|
|
return self.checkbox_wgt(key="debug", tooltip=tooltip, hline=hline)
|
|
|
|
def checkbox_simulation(self, hline="NONE"):
|
|
def on_change(state):
|
|
if bool(state):
|
|
self.parent.simulation = True
|
|
self.parent.gui_header.change_operation_mode(
|
|
user_mode=UserMode.SIMULATION)
|
|
self.parent.progressbar_color \
|
|
= self.parent.progressbar_simulation
|
|
else:
|
|
self.parent.simulation = False
|
|
self.parent.gui_header.reset_operation_mode()
|
|
self.parent.progressbar_color = self.parent.progressbar_standard
|
|
|
|
self.input_parameters["simulation"] = self.parent.simulation
|
|
|
|
widget = QWidget()
|
|
layout = QGridLayout()
|
|
layout.setContentsMargins(0, 0, 0, 0)
|
|
row_wgt = 0
|
|
if hline == "TOP":
|
|
layout.addWidget(QHLine(), 0, 0, 1, 3)
|
|
row_wgt = 1
|
|
try:
|
|
text = self.settings.data["Expert"]["simulation"]["data"]["text"]
|
|
except KeyError as error:
|
|
print("KeyError in guiframe.py; def checkbox_simulation:", error)
|
|
text = "Simulation"
|
|
|
|
checkbox = QCheckBox(text)
|
|
checkbox.setObjectName("Simulation")
|
|
checkbox.setToolTip(
|
|
"Dry-run only; does not write to EPICS Process Variables")
|
|
checkbox.setFont(self.font_gui)
|
|
#checkbox.setStyleSheet(
|
|
#"QCheckBox::indicator::checked {width=85px; height: 85px;};")
|
|
|
|
checkbox.stateChanged.connect(on_change)
|
|
|
|
checked_value = Qt.Unchecked
|
|
if "simulation" in self.parent.input_parameters.keys():
|
|
if "data" in self.settings.data["Expert"]["simulation"].keys():
|
|
if "value" in self.settings.data["Expert"]["simulation"][
|
|
"data"].keys():
|
|
if self.settings.data["Expert"]["simulation"]["data"][
|
|
"value"]:
|
|
checked_value = Qt.Checked
|
|
|
|
checkbox.setCheckState(checked_value)
|
|
|
|
layout.addWidget(checkbox, row_wgt, 0)
|
|
layout.addWidget(QFrame(), row_wgt, 1, 1, 2)
|
|
if hline == "BOTTOM":
|
|
layout.addWidget(QHLine(), row_wgt+1, 0, 1, 3)
|
|
widget.setLayout(layout)
|
|
return widget
|
|
|
|
|
|
def get_arrow_button_widget(self, parent_idx=0):
|
|
#Back/Forward Buttons START####
|
|
arrow_button_widget = QWidget() #self.plot_widget[i])
|
|
layout = QHBoxLayout()
|
|
layout.setContentsMargins(0, 0, 0, 0)
|
|
layout.setAlignment(Qt.AlignLeft|Qt.AlignTop)
|
|
button_left = QToolButton(arrow_button_widget)
|
|
button_left.setArrowType(Qt.LeftArrow)
|
|
button_left.clicked.connect(self.on_toggle_left)
|
|
layout.addWidget(button_left)
|
|
|
|
button_right = QToolButton(arrow_button_widget)
|
|
button_right.setArrowType(Qt.RightArrow)
|
|
button_right.clicked.connect(self.on_toggle_right)
|
|
layout.addWidget(button_right)
|
|
arrow_button_widget.setLayout(layout)
|
|
self.left_arrow_dict[button_left] = parent_idx
|
|
self.right_arrow_dict[button_right] = parent_idx
|
|
|
|
layout.setAlignment(Qt.AlignTop)
|
|
arrow_button_widget.setMaximumHeight(25)
|
|
return arrow_button_widget
|
|
|
|
#Back/Forward Buttons Actions
|
|
def on_toggle_left(self): #(self, is_clicked)
|
|
#print(self.sender())
|
|
#print(self.left_arrow_dict[self.sender()])
|
|
self.next_figure(self.left_arrow_dict[self.sender()], -1)
|
|
|
|
|
|
def on_toggle_right(self): #(self, is_clicked)
|
|
#print(self.sender())
|
|
#print(self.right_arrow_dict[self.sender()])
|
|
self.next_figure(self.right_arrow_dict[self.sender()], 1)
|
|
|
|
|
|
def next_figure(self, det=0, idx=0):
|
|
|
|
if det not in self.canvas_fig_dict:
|
|
return
|
|
fig = self.canvas_fig_dict[det]
|
|
|
|
no_plots_seq = len(self.multiple_figure_dict[fig])
|
|
|
|
self.canvas_current_idx[det] = (
|
|
self.canvas_current_idx[det] + idx) % no_plots_seq
|
|
|
|
if self.canvas[det] is not None:
|
|
self.sub_results_layout[det].removeWidget(self.canvas[det])
|
|
self.canvas[det].deleteLater()
|
|
if self.nav[det] is not None:
|
|
self.sub_results_layout[det].removeWidget(self.nav[det])
|
|
self.nav[det].deleteLater()
|
|
|
|
if fig in self.multiple_figure_dict:
|
|
if self.multiple_figure_dict[fig]:
|
|
self.canvas[det] = FigureCanvasQTAgg(self.multiple_figure_dict[
|
|
fig][self.canvas_current_idx[det]])
|
|
self.sub_results_layout[det].addWidget(self.canvas[det])
|
|
self.sub_results_wgt[det].setLayout(
|
|
self.sub_results_layout[det])
|
|
self.nav[det] = NavigationToolbar(
|
|
self.canvas[det], self.sub_results_wgt[det],
|
|
coordinates=False)
|
|
self.nav[det].setMinimumWidth(400)
|
|
self.nav[det].setMinimumHeight(50)
|
|
self.nav[det].setVisible(True)
|
|
self.nav[det].setStyleSheet("QToolBar { border: 0px }")
|
|
|
|
|
|
def canvas_update(self, fig_data, idx=0):
|
|
#place figures in a list
|
|
|
|
|
|
|
|
self.parent.clear_screenshot()
|
|
self.multiple_figure_dict = fig_data
|
|
|
|
for i, key in enumerate(self.multiple_figure_dict.keys()):
|
|
self.canvas_fig_dict[i] = key
|
|
|
|
|
|
for i, (canvas, nav, wgt, layout, key) in enumerate(
|
|
zip(self.canvas, self.nav,
|
|
self.sub_results_wgt,
|
|
self.sub_results_layout,
|
|
self.multiple_figure_dict.keys())):
|
|
|
|
|
|
|
|
if canvas is not None:
|
|
layout.removeWidget(canvas)
|
|
canvas.deleteLater()
|
|
if nav is not None:
|
|
nav.deleteLater()
|
|
|
|
if self.multiple_figure_dict[key]: #'Figure 1']:
|
|
|
|
if not isinstance(self.multiple_figure_dict[key], list):
|
|
temp_list = []
|
|
temp_list.append(self.multiple_figure_dict[key])
|
|
self.multiple_figure_dict[key] = temp_list
|
|
|
|
|
|
self.canvas[i] = FigureCanvasQTAgg(
|
|
self.multiple_figure_dict[key][idx])
|
|
self.sub_results_layout[i].addWidget(self.canvas[i])
|
|
self.nav[i] = NavigationToolbar(
|
|
self.canvas[i], self.sub_results_wgt[i], coordinates=False)
|
|
self.nav[i].setMinimumWidth(400)
|
|
self.nav[i].setMinimumHeight(50)
|
|
#self.nav[i].setContentsMargins(0, 0, 0, 0)
|
|
self.nav[i].setVisible(True)
|
|
self.nav[i].setStyleSheet("QToolBar { border: 0px }")
|
|
|
|
self.parent.add_screenshot(title=self.results_tab_wgt_titles[i],
|
|
item=wgt)
|
|
|
|
else:
|
|
self.canvas[i] = None
|
|
self.nav[i] = None
|
|
|
|
|
|
##### GUI Input Widget
|
|
def pv_stacked_wgt(self, pvlist, title, default_value, key, object_name):
|
|
stacked_widget = QStackedWidget()
|
|
self.cafe.openPrepare()
|
|
self.cafe.open(pvlist)
|
|
self.cafe.openNowAndWait(0.4)
|
|
|
|
for pv in pvlist:
|
|
self.cafe.setGetActionWhenMonitorPolicy(
|
|
pv, self.cyca.GET_FROM_CACHE)
|
|
|
|
stack_list = []
|
|
|
|
for pv, head, val, obj in zip(pvlist, title, default_value,
|
|
object_name):
|
|
stack, radiobutton_list = self.pv_selector_wgt(
|
|
title=head, key=key, pv=pv, manual_value=val)
|
|
self.stack_radiolist_dict[stack] = radiobutton_list
|
|
|
|
stack_list.append(stack)
|
|
stack.setObjectName(obj)
|
|
stack.style().polish(stack)
|
|
stacked_widget.addWidget(stack)
|
|
|
|
|
|
stacked_widget.setMaximumHeight(320)
|
|
self.stacked_wgt_dict[stacked_widget] = stack_list
|
|
return stacked_widget
|
|
|
|
def pv_energy_stacked_wgt(self):
|
|
pvlist = self.settings.data["EnergyStackedWgt"]["pvlist"]
|
|
title = self.settings.data["EnergyStackedWgt"]["title"]
|
|
default_value = self.settings.data["EnergyStackedWgt"]["value"]
|
|
key = self.settings.data["EnergyStackedWgt"]["key"]
|
|
object_name = self.settings.data["EnergyStackedWgt"]["objectName"]
|
|
self.energy_stacked_widget = self.pv_stacked_wgt(
|
|
pvlist, title, default_value, key, object_name)
|
|
|
|
radio_list = self.stack_radiolist_dict[
|
|
self.energy_stacked_widget.currentWidget()]
|
|
for radio in radio_list:
|
|
if radio.isChecked():
|
|
radio.toggled.emit(True)
|
|
|
|
return self.energy_stacked_widget
|
|
|
|
|
|
def pv_phase_stacked_wgt(self):
|
|
pvlist = self.settings.data["PhaseStackedWgt"]["pvlist"]
|
|
title = self.settings.data["PhaseStackedWgt"]["title"]
|
|
default_value = self.settings.data["PhaseStackedWgt"]["value"]
|
|
key = self.settings.data["PhaseStackedWgt"]["key"]
|
|
object_name = self.settings.data["PhaseStackedWgt"]["objectName"]
|
|
self.phase_stacked_widget = self.pv_stacked_wgt(
|
|
pvlist, title, default_value, key, object_name)
|
|
|
|
radio_list = self.stack_radiolist_dict[
|
|
self.phase_stacked_widget.currentWidget()]
|
|
for radio in radio_list:
|
|
if radio.isChecked():
|
|
radio.toggled.emit(True)
|
|
|
|
return self.phase_stacked_widget
|
|
|
|
|
|
def pv_selector_wgt(self, title="Select", key="beamEnergy", pv=None,
|
|
manual_value="", monitor=True, read=True, manual=True):
|
|
group_box = QGroupBox(title)
|
|
group_box.setObjectName("INNERCENTER")
|
|
grid = QGridLayout()
|
|
|
|
radio_buddy_text_dict = {}
|
|
radiobutton_title = ["Monitor", "Update", "Manual"]
|
|
radiobutton_flag = [monitor, read, manual]
|
|
radiobutton_list = [None] * len(radiobutton_title)
|
|
pv_local = pv
|
|
monitor_pv = None
|
|
|
|
|
|
def cb_pv_selector(value):
|
|
|
|
value_str = radio_buddy_text_dict[self.sender()].text()
|
|
|
|
#print("cb_pv_selector", value_str)
|
|
#Find which group the radio button belongs to:
|
|
#Find which stack the group belongs to:
|
|
#Set this to the current stack?
|
|
|
|
for k, v in self.stack_radiolist_dict.items():
|
|
if self.sender() in v:
|
|
#get groupbox from key
|
|
for k2, v2 in self.stacked_wgt_dict.items():
|
|
if k in v2:
|
|
self.current_stacked_wgt_dict[k2] = pv_local #self.sender()
|
|
#print("Current STACK FOUND")
|
|
|
|
self.radio_stack_dict[self.sender()] = value
|
|
|
|
if not value_str:
|
|
print("Fired on Initialization when not connected", value)
|
|
print("sender", self.sender())
|
|
print("radio_buddy_text", radio_buddy_text_dict)
|
|
print("value", radio_buddy_text_dict[self.sender()].text())
|
|
self.input_parameters[key] = 0
|
|
return
|
|
|
|
if hasattr(radio_buddy_text_dict[self.sender()], "pv_info"):
|
|
|
|
dt = radio_buddy_text_dict[self.sender()].pv_info.dataType
|
|
|
|
if dt not in [self.cyca.CY_DBR_STRING, self.cyca.CY_DBR_ENUM,
|
|
self.cyca.CY_DBR_CHAR]:
|
|
value_input = re.findall(r"-?\d+\.?\d*", value_str)
|
|
if dt in [self.cyca.CY_DBR_FLOAT, self.cyca.CY_DBR_DOUBLE]:
|
|
self.input_parameters[key] = float(value_input[0])
|
|
elif dt in [self.cyca.CY_DBR_SHORT, self.cyca.CY_DBR_LONG]:
|
|
self.input_parameters[key] = int(value_input[0])
|
|
else:
|
|
self.input_parameters[key] = value_str
|
|
else:
|
|
self.input_parameters[key] = value_str
|
|
|
|
|
|
for irow, (radio, flag) in enumerate(zip(radiobutton_list,
|
|
radiobutton_flag)):
|
|
radio = QRadioButton("")
|
|
radio.toggled.connect(cb_pv_selector)
|
|
radio.setFont(self.font_pts10)
|
|
radio.setFixedWidth(15)
|
|
radiobutton_list[irow] = radio
|
|
if flag:
|
|
grid.addWidget(radio, irow, 0)
|
|
|
|
|
|
if monitor:
|
|
ql = QLabel(radiobutton_title[0])
|
|
ql.setFont(self.font_pts10)
|
|
ql.setFixedHeight(self.widget_height)
|
|
ql.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
|
|
grid.addWidget(ql, 0, 1)
|
|
|
|
if manual:
|
|
ql = QLabel(radiobutton_title[2])
|
|
ql.setFont(self.font_pts10)
|
|
ql.setFixedHeight(self.widget_height)
|
|
ql.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
|
|
grid.addWidget(ql, 2, 1)
|
|
|
|
def mon_cb(handle, pvname, pvdata):
|
|
if monitor_pv is not None:
|
|
monitor_pv.py_monitor_callback(handle, pvname, pvdata)
|
|
|
|
if pvname in self.current_stacked_wgt_dict.values() and \
|
|
radiobutton_list[0].isChecked(): #
|
|
self.input_parameters[key] = pvdata.value[0]
|
|
|
|
if monitor:
|
|
monitor_pv = CAQLabel(self, pv_name=pv, monitor_callback=mon_cb,
|
|
show_units=True)
|
|
|
|
monitor_pv.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
|
|
monitor_pv.setFont(self.font_pts10)
|
|
monitor_pv.setFixedHeight(self.widget_height)
|
|
monitor_pv.setFixedWidth(122)
|
|
grid.addWidget(monitor_pv, 0, 2, 1, 2)
|
|
|
|
if read:
|
|
read_pv = CAQLabel(self, pv_name=pv, pv_within_daq_group=True,
|
|
color_mode="static", show_units=True)
|
|
read_pv.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
|
|
#read_pv.setObjectName("Readback")
|
|
#read_pv.setProperty("static", True)
|
|
#read_pv.setStyleSheet('background-color: rgb(255, 255,223)')
|
|
read_pv.setFont(self.font_pts10)
|
|
init_value = self.cafe.getCache(pv)
|
|
|
|
if init_value is not None:
|
|
val = read_pv.format_display_value(init_value)
|
|
#else:
|
|
# val = 0.0
|
|
read_pv.setText(str(val))
|
|
read_pv.setFixedHeight(self.widget_height)
|
|
read_pv.setFixedWidth(122)
|
|
|
|
grid.addWidget(read_pv, 1, 2, 1, 2)
|
|
|
|
def update_read_value():
|
|
#print("sender = ", self.sender())
|
|
pvdata = self.cafe.getPV(pv)
|
|
init_value = pvdata.value[0]
|
|
|
|
if init_value is not None:
|
|
#value_str = read_pv.format_display_value(init_value)
|
|
#read_pv.setText(str(value_str))
|
|
#print(len(read_pv.text()))
|
|
#val = re.findall(r'-?\d+\.?\d*', value_str)
|
|
#print (val)
|
|
#val[0] = val[0] #add space that we stripped off
|
|
read_pv.receive_monitor_update(init_value, pvdata.status,
|
|
pvdata.alarmSeverity)
|
|
|
|
if radiobutton_list[1].isChecked():
|
|
radiobutton_list[1].toggled.emit(True)
|
|
|
|
if read:
|
|
qpb = QPushButton(radiobutton_title[1])
|
|
qpb.setObjectName("Update")
|
|
qpb.pressed.connect(update_read_value)
|
|
qpb.setFixedHeight(self.widget_height)
|
|
qpb.setFixedWidth(60)
|
|
grid.addWidget(qpb, 1, 1)
|
|
qpb.pressed.emit()
|
|
|
|
def update_manual_value(new_text):
|
|
if radiobutton_list[2].isChecked():
|
|
radiobutton_list[2].toggled.emit(True)
|
|
|
|
if manual:
|
|
manual_wgt = QLineEdit(str(manual_value))
|
|
manual_wgt.setObjectName("WriteCenter")
|
|
manual_wgt.textChanged.connect(update_manual_value)
|
|
manual_wgt.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
|
|
manual_wgt.setFixedHeight(self.widget_height)
|
|
manual_wgt.setFixedWidth(74)
|
|
grid.addWidget(manual_wgt, 2, 2)
|
|
ql = QLabel(self.cafe.getUnits(pv))
|
|
ql.setFont(self.font_pts10)
|
|
ql.setFixedHeight(self.widget_height)
|
|
ql.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
|
|
grid.addWidget(ql, 2, 3)
|
|
|
|
grid.setContentsMargins(5, 10, 5, 0)
|
|
#grid.setContentsMargins(9, 15, 9, 0)
|
|
grid.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
|
|
grid.setVerticalSpacing(2)
|
|
grid.setHorizontalSpacing(4)
|
|
group_box.setContentsMargins(0, 0, 0, 0)
|
|
group_box.setMaximumWidth(280)
|
|
group_box.setMaximumHeight(320)
|
|
group_box.setFont(self.font_pts10)
|
|
group_box.setAlignment(Qt.AlignTop | Qt.AlignHCenter)
|
|
group_box.setLayout(grid)
|
|
|
|
if monitor:
|
|
radio_buddy_text_dict[radiobutton_list[0]] = monitor_pv
|
|
|
|
if read:
|
|
radio_buddy_text_dict[radiobutton_list[1]] = read_pv
|
|
|
|
if manual:
|
|
radio_buddy_text_dict[radiobutton_list[2]] = manual_wgt
|
|
|
|
idx = 0 #1 if read else 0
|
|
#print("idx", idx)
|
|
#print(radio_buddy_text_dict)
|
|
radiobutton_list[idx].setChecked(True)
|
|
radiobutton_list[idx].toggled.emit(True)
|
|
|
|
return group_box, radiobutton_list
|
|
|
|
def input_wgt_qcombobox(self, label, key, value, irow, wgt_grid):
|
|
suggested = "WW"
|
|
if key in self.settings.data["Expert"].keys():
|
|
top_key = "Expert"
|
|
elif key in self.settings.data["Parameters"].keys():
|
|
top_key = "Parameters"
|
|
|
|
def combo_cb(new_text):
|
|
self.input_parameters[key] = new_text
|
|
|
|
line = QComboBox()
|
|
line.clear()
|
|
line.addItems(value)
|
|
line.setFixedHeight(26)
|
|
line.currentTextChanged.connect(combo_cb)
|
|
line.setCurrentIndex(0)
|
|
line.currentTextChanged.emit(value[0])
|
|
value_for_width = max(value, key=len)
|
|
|
|
fm = QFontMetricsF(line.font())
|
|
param_width = max(fm.width(str(value_for_width)), fm.width(suggested))
|
|
line.setFixedWidth(param_width + 56)
|
|
line.setObjectName("Write")
|
|
|
|
if "layout" in self.settings.data[top_key][key]['data']:
|
|
if "VERT" in self.settings.data[top_key][key]['data'][
|
|
'layout'].upper():
|
|
box = QVBoxLayout()
|
|
label.setAlignment(Qt.AlignBottom)
|
|
else:
|
|
box = QHBoxLayout()
|
|
label.setAlignment(Qt.AlignCenter)
|
|
else:
|
|
box = QVBoxLayout()
|
|
label.setAlignment(Qt.AlignBottom)
|
|
|
|
box.addWidget(label)
|
|
box.addWidget(line)
|
|
|
|
wgt_grid.addLayout(box, irow, 0, 1, 3, Qt.AlignLeft | Qt.AlignVCenter)
|
|
|
|
return line
|
|
|
|
def input_wgt_qradiobutton(self, key, value, irow, wgt_grid):
|
|
def on_radiobutton_change(new_value):
|
|
radio_button = self.sender()
|
|
if radio_button.isChecked():
|
|
self.parent.input_parameters[key] = radio_button.target
|
|
print("KEY================", key, self.parent.input_parameters[key], new_value)
|
|
|
|
if key in self.settings.data["Expert"].keys():
|
|
top_key = "Expert"
|
|
elif key in self.settings.data["Parameters"].keys():
|
|
top_key = "Parameters"
|
|
|
|
if 'forwardLink' in self.settings.data[top_key][key]['data']:
|
|
link = self.settings.data[top_key][key]['data'][
|
|
'forwardLink'][0]
|
|
|
|
for item in self.settings.data[link][radio_button.target]:
|
|
value_list = self.settings.data[link][radio_button.target][
|
|
item]
|
|
|
|
if item in self.line_sender_dict:
|
|
if self.settings.data[top_key][item]['data'][
|
|
'widget'] in 'QComboBox':
|
|
self.line_sender_dict[item].clear()
|
|
self.line_sender_dict[item].addItems(value_list)
|
|
self.line_sender_dict[item].setCurrentIndex(0)
|
|
self.line_sender_dict[item].currentTextChanged.emit(
|
|
value_list[0])
|
|
elif self.settings.data[top_key][item]['data'][
|
|
'widget'] in 'QLineEdit':
|
|
self.line_sender_dict[item].setText(str(value_list))
|
|
|
|
line = self.radio_buttons(key=key, options=value)
|
|
rblist = line.findChildren(QRadioButton)
|
|
|
|
for rb in rblist:
|
|
rb.toggled.connect(on_radiobutton_change)
|
|
|
|
wgt_grid.addWidget(line, irow, 0, 1, 4, Qt.AlignLeft)
|
|
|
|
rblist[0].setChecked(True)
|
|
rblist[0].toggled.emit(True)
|
|
|
|
|
|
return line
|
|
|
|
def input_wgt_qcheckbox(self, key, value, label_text, irow, wgt_grid):
|
|
def check_cb(new_value):
|
|
self.parent.input_parameters[key] = bool(new_value)
|
|
|
|
line = QCheckBox(label_text)
|
|
line.setChecked(Qt.Checked if value else Qt.Unchecked)
|
|
line.stateChanged.connect(check_cb)
|
|
line.setMaximumWidth(320)
|
|
line.setMinimumWidth(220)
|
|
line.setFixedHeight(28)
|
|
|
|
wgt_grid.addWidget(line, irow, 0, 1, 4, Qt.AlignLeft | Qt.AlignVCenter)
|
|
|
|
return line
|
|
|
|
def input_wgt_qlabel(self, value, irow, wgt_grid):
|
|
#Read only has no callback
|
|
suggested = "WWWW"
|
|
line = QLabel()
|
|
line.setText(str(value)) #"{0: 3.1f}".format(value))
|
|
line.setFixedHeight(24)
|
|
line.setAlignment(Qt.AlignRight | Qt.AlignBottom)
|
|
line.setStyleSheet("QLabel{text-align: right}")
|
|
fm = QFontMetricsF(line.font())
|
|
param_width = max(fm.width(str(value)), fm.width(suggested))
|
|
line.setMaximumWidth(param_width + 40)
|
|
wgt_grid.addWidget(line, irow, 0, 1, 4)
|
|
|
|
return line
|
|
|
|
def input_wgt_qlineread(self, value, label, irow, wgt_grid):
|
|
#Read only has no callback
|
|
suggested = "WW"
|
|
line = QLineEdit()
|
|
line.setObjectName("Read")
|
|
line.setText(str(value)) #"{0: 3.1f}".format(value))
|
|
line.setFixedHeight(24)
|
|
line.setAlignment(Qt.AlignRight | Qt.AlignBottom)
|
|
line.setStyleSheet("QLabel{text-align: right}")
|
|
fm = QFontMetricsF(line.font())
|
|
param_width = max(fm.width(str(value)), fm.width(suggested))
|
|
line.setMaximumWidth(param_width + 24)
|
|
|
|
wgt_grid.addWidget(label, irow, 0, 1, 2, Qt.AlignLeft | Qt.AlignVCenter)
|
|
wgt_grid.addWidget(line, irow, 2, 1, 2, Qt.AlignLeft | Qt.AlignVCenter)
|
|
|
|
return line
|
|
|
|
def input_wgt_qlineedit(self, key, value, label, irow, wgt_grid):
|
|
def line_cb(new_value):
|
|
self.parent.input_parameters[key] = new_value
|
|
|
|
suggested = "WW"
|
|
line = QLineEdit()
|
|
line.setObjectName("Write")
|
|
line.setFixedHeight(24)
|
|
line.textEdited.connect(line_cb)
|
|
line.setText(str(value))
|
|
fm = QFontMetricsF(line.font())
|
|
param_width = max(fm.width(str(value)), fm.width(suggested))
|
|
line.setMaximumWidth(param_width + 20)
|
|
|
|
wgt_grid.addWidget(label, irow, 0, 1, 2, Qt.AlignLeft | Qt.AlignVCenter)
|
|
wgt_grid.addWidget(line, irow, 2, 1, 2, Qt.AlignLeft | Qt.AlignVCenter)
|
|
|
|
return line
|
|
|
|
|
|
def input_wgt_qdoublespinbox(self, key, value, label, irow, wgt_grid):
|
|
def line_cb(new_value):
|
|
self.parent.input_parameters[key] = new_value
|
|
|
|
suggested = "WWWW"
|
|
line = QDoubleSpinBox()
|
|
line.setObjectName("Write")
|
|
line.setFixedHeight(24)
|
|
line.valueChanged.connect(line_cb)
|
|
line.setValue(value)
|
|
min_val = self.settings.data["Expert"][key]["data"]["min"]
|
|
max_val = self.settings.data["Expert"][key]["data"]["max"]
|
|
step = self.settings.data["Expert"][key]["data"]["step"]
|
|
decimal = Decimal(str(step))
|
|
line.setDecimals(abs(decimal.as_tuple().exponent)) #precision
|
|
line.setRange(min_val, max_val)
|
|
line.setSingleStep(step)
|
|
fm = QFontMetricsF(line.font())
|
|
param_width = max(fm.width(str(decimal)), fm.width(suggested))
|
|
line.setMaximumWidth(param_width + 40)
|
|
|
|
wgt_grid.addWidget(label, irow, 0, 1, 2, Qt.AlignLeft | Qt.AlignVCenter)
|
|
wgt_grid.addWidget(line, irow, 2, 1, 2, Qt.AlignLeft | Qt.AlignVCenter)
|
|
|
|
return line
|
|
|
|
|
|
def input_wgt_qspinbox(self, key, value, label, irow, wgt_grid):
|
|
def line_cb(new_value):
|
|
self.parent.input_parameters[key] = new_value
|
|
|
|
suggested = "WWWW"
|
|
line = QSpinBox()
|
|
line.setObjectName("Write")
|
|
line.setFixedHeight(24)
|
|
line.valueChanged.connect(line_cb)
|
|
line.setValue(value)
|
|
if key in self.settings.data["Expert"].keys():
|
|
top_key = "Expert"
|
|
elif key in self.settings.data["Parameters"].keys():
|
|
top_key = "Parameters"
|
|
|
|
min_val = self.settings.data[top_key][key]["data"]["min"]
|
|
max_val = self.settings.data[top_key][key]["data"]["max"]
|
|
step = self.settings.data[top_key][key]["data"]["step"]
|
|
|
|
|
|
line.setRange(min_val, max_val)
|
|
line.setSingleStep(step)
|
|
fm = QFontMetricsF(line.font())
|
|
param_width = max(fm.width(str(max_val)), fm.width(suggested))
|
|
line.setMaximumWidth(param_width + 40)
|
|
|
|
wgt_grid.addWidget(label, irow, 0, 1, 2, Qt.AlignLeft | Qt.AlignVCenter)
|
|
wgt_grid.addWidget(line, irow, 2, 1, 2, Qt.AlignLeft | Qt.AlignVCenter)
|
|
|
|
return line
|
|
|
|
def input_wgt_qenergystacked(self, irow, wgt_grid):
|
|
qFrame = QFrame()
|
|
qFrame.setFixedHeight(10)
|
|
line = self.pv_energy_stacked_wgt()
|
|
wgt_grid.addWidget(qFrame, irow, 0, 1, 4)
|
|
wgt_grid.addWidget(line, irow+1, 0, 1, 4)
|
|
|
|
return line
|
|
|
|
def input_wgt_qphasestacked(self, irow, wgt_grid):
|
|
qFrame = QFrame()
|
|
qFrame.setFixedHeight(10)
|
|
line = self.pv_phase_stacked_wgt()
|
|
wgt_grid.addWidget(qFrame, irow, 0, 1, 4)
|
|
wgt_grid.addWidget(line, irow+1, 0, 1, 4)
|
|
|
|
return line
|
|
|
|
def input_wgt_qhline(self, irow, wgt_grid):
|
|
qHLine = QHLine()
|
|
qHLine.setFixedHeight(10)
|
|
wgt_grid.addWidget(qHLine, irow, 0, 1, 4)
|
|
|
|
|
|
def input_wgt_frame(self, irow, wgt_grid):
|
|
qFrame = QFrame()
|
|
qFrame.setFixedHeight(10)
|
|
wgt_grid.addWidget(qFrame, irow, 0, 1, 4)
|
|
|
|
|
|
def input_wgt(self, buddy, label, key, value, irow=0, wgt_grid=None):
|
|
|
|
if wgt_grid is None:
|
|
wgt_grid = self.input_wgt_grid
|
|
|
|
label_text = label
|
|
label = QLabel(label_text if buddy != "QCheckBox".upper() else "")
|
|
label.setFixedHeight(24)
|
|
label.setFont(self.font_pts10)
|
|
label.setContentsMargins(5, 0, 0, 0)
|
|
|
|
line = None
|
|
|
|
#Add callbacksand actions
|
|
if buddy == "QComboBox".upper():
|
|
line = self.input_wgt_qcombobox(label, key, value, irow, wgt_grid)
|
|
|
|
elif buddy == "QRadioButton".upper():
|
|
line = self.input_wgt_qradiobutton(key, value, irow, wgt_grid)
|
|
|
|
elif buddy == "QCheckBox".upper():
|
|
line = self.input_wgt_qcheckbox(key, value, label_text, irow,
|
|
wgt_grid)
|
|
elif buddy == "QLabel".upper():
|
|
line = self.input_wgt_qlabel(value, irow, wgt_grid)
|
|
|
|
elif buddy == "QLineRead".upper():
|
|
line = self.input_wgt_qlineread(value, label, irow, wgt_grid)
|
|
|
|
elif buddy == "QDoubleSpinBox".upper():
|
|
line = self.input_wgt_qdoublespinbox(key, value, label, irow,
|
|
wgt_grid)
|
|
elif buddy == "QSpinBox".upper():
|
|
line = self.input_wgt_qspinbox(key, value, label, irow, wgt_grid)
|
|
|
|
elif buddy == "QPhaseStackedWidget".upper():
|
|
line = self.input_wgt_qphasestacked(irow, wgt_grid)
|
|
|
|
elif buddy == "QEnergyStackedWidget".upper():
|
|
line = self.input_wgt_qenergystacked(irow, wgt_grid)
|
|
|
|
elif buddy == "QLineEdit".upper():
|
|
line = self.input_wgt_qlineedit(key, value, label, irow, wgt_grid)
|
|
|
|
elif buddy == "QHLine".upper():
|
|
self.input_wgt_qhline(irow, wgt_grid)
|
|
|
|
elif buddy == "QFrame".upper():
|
|
self.input_wgt_qframe(irow, wgt_grid)
|
|
|
|
elif buddy == "QTabWidget".upper():
|
|
pass
|
|
else:
|
|
wgt_list = ["QCheckBox", "QComboBox", "QDoubleSpinBox", "QFrame",
|
|
"QHLine", "QLabel", "QLineEdit", "QLineRead",
|
|
"QRadioButton", "QSpinBox", "QPhaseStackedWidget",
|
|
"QEnergyStackedWidget"]
|
|
print("Widget {0} is not Supported".format(buddy))
|
|
print("Supported widgets are: {0}".format(wgt_list))
|
|
pass
|
|
|
|
if line is not None:
|
|
self.line_sender_dict[key] = line
|
|
|
|
|
|
|
|
def enter_input_parameters(self):
|
|
#"undulator": {"flag": 0, "data" :
|
|
#{"widget": "None", "text" : "Target:", "value" : "Aramis"}},
|
|
#"deflector": {"flag": 1, "data" :
|
|
#{"widget": "QComboBox", "text" : "RF Tranverse Deflector:",
|
|
# "forwardLink": ["RFDeflector"]}},
|
|
#profileMonitor": {"flag": 1, "data" :
|
|
#{"widget": "QComboBox", "text" : "Profile Monitor:",
|
|
# "link": ["RFDeflector", "SINDI01", "profileMonitor"]
|
|
#json input "Parameters" key
|
|
# All key values added to self.input_parameters
|
|
#flag 1: add to self.input_parameters for analysis thread
|
|
#widget None: does not add widget into container
|
|
#text: Will add label to a widget
|
|
#forwardLink: Will substitute for target and execute
|
|
#link: Will substitute for target
|
|
#operator
|
|
self.operator_parameters_group = self.operator_parameters_groupbox()
|
|
|
|
if self.facility == Facility.SwissFEL:
|
|
try:
|
|
if self.settings.data["Parameters"]["undulator"]["flag"]:
|
|
self.operator_parameters_group.layout().addWidget(
|
|
self.parent.gui_header.operator_group_header())
|
|
except KeyError:
|
|
pass
|
|
|
|
for (key, val), label in zip(self.all_input_parameters.items(),
|
|
self.all_input_labels.values()):
|
|
buddy = self.settings.data[
|
|
"Parameters"][key]["data"]["widget"].upper()
|
|
j = self.input_wgt_grid.rowCount()
|
|
if buddy != "NONE":
|
|
self.input_wgt(buddy=buddy, label=label, key=key, value=val,
|
|
irow=j, wgt_grid=self.input_wgt_grid)
|
|
|
|
self.operator_parameters_group.layout().addLayout(self.input_wgt_grid)
|
|
self.operator_parameters_group.setMinimumHeight(INPUT_PARAMETERS_HEIGHT)
|
|
|
|
|
|
lo = QGridLayout()
|
|
lo.setContentsMargins(9, 19, 9, 9)
|
|
lo.addWidget(self.operator_parameters_group, 0, 0, 4, 1, alignment=Qt.AlignTop)
|
|
#if random.randint(1, 10) > 9:
|
|
# lo.addWidget(self.create_analysis_wgt(), 0, 1)
|
|
#else:
|
|
if self.has_optics:
|
|
lo.addWidget(self.optics_groupbox(), 0, 1)
|
|
row_count = 1
|
|
else:
|
|
row_count = 0
|
|
lo.addWidget(self.analysis_procedure_group(), row_count, 1)
|
|
|
|
|
|
#Centers input parameters group box
|
|
lo.setAlignment(Qt.AlignHCenter | Qt.AlignTop)
|
|
lo.setHorizontalSpacing(20)
|
|
lo.setVerticalSpacing(40)
|
|
self.operator_wgt.setLayout(lo)
|
|
|
|
#expert
|
|
self.expert_parameters_group = self.expert_parameters_groupbox()
|
|
|
|
for (key, val), label in zip(self.all_expert_parameters.items(),
|
|
self.all_expert_labels.values()):
|
|
|
|
buddy = self.settings.data[
|
|
"Expert"][key]["data"]["widget"].upper()
|
|
j = self.expert_wgt_grid.rowCount()
|
|
if buddy != "NONE":
|
|
self.input_wgt(buddy=buddy, label=label, key=key, value=val,
|
|
irow=j, wgt_grid=self.expert_wgt_grid)
|
|
|
|
#Add expert parameters to input_parameters
|
|
self.input_parameters.update(self.expert_parameters)
|
|
|
|
#Need to emit radio button here as input_parameters is overwritten by sel.expoert_parameters
|
|
#which give a list [Gasusian and FWMH]
|
|
if self.radiobutton:
|
|
self.radiobutton[0].toggled.emit(True)
|
|
|
|
if self.expert_wgt_grid:
|
|
self.expert_parameters_group.layout().addLayout(
|
|
self.expert_wgt_grid)
|
|
|
|
|
|
if "pipeline" in self.parent.input_parameters.keys():
|
|
self.expert_parameters_group.layout().addWidget(
|
|
self.image_parameters_group())
|
|
|
|
self.expert_parameters_group.layout().addWidget(QHLine())
|
|
|
|
if "autoRestore" in self.parent.input_parameters.keys() and \
|
|
"autoCycle" in self.parent.input_parameters.keys():
|
|
|
|
hbox = QHBoxLayout()
|
|
hbox.addWidget(self.checkbox_autoRestore(hline="None"))
|
|
hbox.addWidget(self.checkbox_autoCycle(hline="None"))
|
|
self.expert_parameters_group.layout().addLayout(hbox)
|
|
|
|
elif "autoRestore" in self.parent.input_parameters.keys():
|
|
self.expert_parameters_group.layout().addWidget(
|
|
self.checkbox_autoRestore(hline="TOP"))
|
|
|
|
elif "autoCycle" in self.parent.input_parameters.keys():
|
|
self.expert_parameters_group.layout().addWidget(
|
|
self.checkbox_autoCycle())
|
|
|
|
if "keepImages" in self.parent.input_parameters.keys():
|
|
self.expert_parameters_group.layout().addWidget(
|
|
self.checkbox_keepImages())
|
|
|
|
self.expert_parameters_group.layout().addWidget(QHLine())
|
|
|
|
hbox2 = QHBoxLayout()
|
|
hbox2.addWidget(self.checkbox_debug(hline="None"))
|
|
hbox2.addWidget(self.checkbox_simulation(hline="None"))
|
|
self.expert_parameters_group.layout().addLayout(hbox2)
|
|
|
|
#if "debug" in self.parent.input_parameters.keys():
|
|
# self.expert_parameters_group.layout().addWidget(
|
|
# self.checkbox_debug(hline="TOP"))
|
|
|
|
#if "simulation" in self.parent.input_parameters.keys():
|
|
# self.expert_parameters_group.layout().addWidget(
|
|
# self.checkbox_simulation(hline="BOTTOM"))
|
|
|
|
self.expert_parameters_group.layout().addWidget(QHLine())
|
|
|
|
self.expert_parameters_group.setMinimumHeight(EXPERT_PARAMETERS_HEIGHT)
|
|
|
|
lo = QGridLayout()
|
|
lo.setContentsMargins(9, 19, 9, 9)
|
|
lo.addWidget(self.expert_parameters_group, 0, 0, 1, 1, alignment=Qt.AlignTop)
|
|
lo.setAlignment(Qt.AlignHCenter | Qt.AlignTop)
|
|
lo.setHorizontalSpacing(20)
|
|
self.expert_wgt.setLayout(lo)
|
|
|
|
#test
|
|
def radio_buttons(self, key="", options: list = [], start_idx=0):
|
|
widget = QWidget()
|
|
layout = QGridLayout()
|
|
layout.setContentsMargins(5, 0, 5, 0)
|
|
widget.setFixedWidth(220)
|
|
#self.setLayout(layout)
|
|
|
|
target_list = options
|
|
|
|
color_list = ["#894961", "teal", "darkblue"]
|
|
|
|
self.radiobutton = [None] * len(options)
|
|
for i, title in enumerate(options):
|
|
self.radiobutton[i] = QRadioButton(title)
|
|
|
|
width_list = [70, 70, 70]
|
|
|
|
if key in self.settings.data["Expert"].keys():
|
|
top_key = "Expert"
|
|
elif key in self.settings.data["Parameters"].keys():
|
|
top_key = "Parameters"
|
|
|
|
_width = 1
|
|
_full_width = _width * len(options) + 1
|
|
|
|
layout.addWidget(QHLine(), 0, 0, 1, _full_width)
|
|
layout.addWidget(QLabel(
|
|
self.settings.data[top_key][key]['data']['text']), 1, 0, 1, 1,
|
|
Qt.AlignCenter)
|
|
|
|
for i, (radio, target, color, width) in enumerate(
|
|
zip(self.radiobutton, target_list, color_list, width_list)):
|
|
|
|
radio.setFont(self.font_pts10)
|
|
radio.setStyleSheet("color : {0};".format(color))
|
|
radio.target = target
|
|
|
|
layout.addWidget(radio, 1, _width*i+1, 1, _width, Qt.AlignCenter)
|
|
|
|
#_qf = QFrame()
|
|
#_qf.setFixedWidth(10)
|
|
#layout.addWidget(_qf, 1, layout.columnCount())
|
|
|
|
#self.radiobutton[start_idx].setChecked(True)
|
|
#self.radiobutton[start_idx].toggled.emit(True)
|
|
|
|
layout.addWidget(QHLine(), 2, 0, 1, layout.columnCount())
|
|
|
|
widget.setLayout(layout)
|
|
|
|
return widget
|
|
|
|
|
|
def create_table_wgt(self, pv_list: list):
|
|
return CAQTableWidget(self, pv_list=pv_list, init_column=True,
|
|
notify_freq_hz=5, notify_unison=True)
|
|
|
|
def create_table_layout(self, branches):
|
|
@Slot(int)
|
|
def on_table_tab_changed(tab_idx):
|
|
#print("Changed", tab_idx, self.table_wgt[tab_idx].tab_text)
|
|
#print("PM", self.line_sender_dict['profileMonitor'].currentIndex())
|
|
#print("PM", self.line_sender_dict['profileMonitor'].currentText())
|
|
#key = self.line_sender_dict['profileMonitor'].currentText()
|
|
|
|
#cannot enumerate self.branches!!
|
|
for i, table in enumerate(self.table_wgt):
|
|
|
|
branch_key = self.branches[i]['key'] #branch['key']
|
|
key = self.line_sender_dict[branch_key].currentText()
|
|
|
|
#print(branch_key, key, i, tab_idx)
|
|
#if key in self.branches[i]['lastLine'][key]:
|
|
# print("i/idx", i, tab_idx,
|
|
# self.branches[i]['lastLine'][key])
|
|
#else:
|
|
# self.branches[i]['lastLine'][key] = [' ',' ']
|
|
#print(self.branches[i]['tagged'])
|
|
if i == tab_idx:
|
|
if key in self.branches[i]['tagged']:
|
|
table.paint_rows(reset=True, last_row=[' ', ' '])
|
|
table.paint_rows(
|
|
row_range=self.branches[i]['tagged'][key],
|
|
reset=False,
|
|
last_row=self.branches[i]['lastLine'][key])
|
|
else:
|
|
table.paint_rows(reset=True, last_row=[' ', ' '])
|
|
|
|
self.branches = branches
|
|
pv_dict = {}
|
|
for i in range(0, len(self.branches)):
|
|
_title = self.branches[i]['tabTitle']
|
|
pv_dict[_title] = self.branches[i]['magnets']
|
|
|
|
self.table_layout = QGridLayout()
|
|
self.table_layout.setAlignment(Qt.AlignCenter | Qt.AlignTop)
|
|
self.table_tab_wgt = QTabWidget()
|
|
self.table_tab_wgt.setFixedWidth(600)
|
|
self.table_tab_wgt.tabBar().setShape(QTabBar.TriangularNorth)
|
|
|
|
#self.table_tab_wgt.tabBar().setDrawBase(False)
|
|
|
|
#Initialization has to loop
|
|
self.table_wgt = [None] * len(pv_dict)
|
|
|
|
for i, tab_text in enumerate(pv_dict.keys()):
|
|
self.table_wgt[i] = self.create_table_wgt(
|
|
pv_list=pv_dict[tab_text])
|
|
self.table_wgt[i].tab_text = tab_text
|
|
|
|
self.table_wgt[i].setFont(self.font_pts10)
|
|
self.table_tab_wgt.addTab(self.table_wgt[i], tab_text)
|
|
color = self.branches[i]['tabTextColor']
|
|
self.table_tab_wgt.tabBar().setTabTextColor(i, QColor(color))
|
|
|
|
|
|
self.table_tab_wgt.currentChanged.connect(on_table_tab_changed)
|
|
self.table_layout.addWidget(self.table_tab_wgt, 0, 0)
|
|
|
|
#self.line_sender_dict['tableTabIdx'] = self.table_tab_wgt
|
|
self.table_layout.setContentsMargins(0, 27, 0, 0)
|
|
|
|
self.table_tab_wgt.currentChanged.emit(0)
|
|
|
|
return self.table_layout #tab_wgt
|