def __init__(self):
super().__init__()
self._item_list = []
# The 'first item' is appended to the beginning of the list. The index returned
# by the functions of the class is the index of 'self._item_list' array, that
# does not include the 'first item'.
self._first_item = "Select Line:"
self.cb_element_list = QComboBox()
self.cb_element_list.currentIndexChanged.connect(
self.cb_element_list_current_index_changed)
self.setMaximumWidth(300)
self.pb_prev = PushButtonMinimumWidth("<")
self.pb_prev.pressed.connect(self.pb_prev_pressed)
self.pb_next = PushButtonMinimumWidth(">")
self.pb_next.pressed.connect(self.pb_next_pressed)
self.cb_element_list.addItems([self._first_item])
self.cb_element_list.setCurrentIndex(0)
hbox = QHBoxLayout()
hbox.setSpacing(0)
hbox.setContentsMargins(0, 0, 0, 0)
hbox.addWidget(self.pb_prev)
hbox.addWidget(self.cb_element_list)
hbox.addWidget(self.pb_next)
self.setLayout(hbox)
sp = QSizePolicy()
sp.setControlType(QSizePolicy.PushButton)
sp.setHorizontalPolicy(QSizePolicy.Maximum)
self.setSizePolicy(sp)
def __init__(self):
super().__init__()
self._range_table = []
self._limit_table = []
self._rgb_keys = ["red", "green", "blue"]
self._rgb_dict = {_: None for _ in self._rgb_keys}
widget_layout = self._setup_rgb_widget()
self.setLayout(widget_layout)
sp = QSizePolicy()
sp.setControlType(QSizePolicy.PushButton)
sp.setHorizontalPolicy(QSizePolicy.Expanding)
sp.setVerticalPolicy(QSizePolicy.Fixed)
self.setSizePolicy(sp)
def generate_pv_controls(self, pv_name, curve_color):
"""
Generate a set of widgets to manage the appearance of a curve. The set of widgets includes:
1. A checkbox which shows the curve on the chart if checked, and hide the curve if not
checked
2. Three buttons -- Modify..., Focus, and Remove. Modify... will bring up the Curve
Settings dialog. Focus adjusts the chart's zooming for the current curve.
Remove will delete the curve from the chart
Parameters
----------
pv_name: str
The name of the PV the current curve is being plotted for
curve_color : QColor
The color of the curve to paint for the checkbox label to help the user track the curve
to the checkbox
"""
individual_curve_layout = QVBoxLayout()
size_policy = QSizePolicy()
size_policy.setVerticalPolicy(QSizePolicy.Fixed)
size_policy.setHorizontalPolicy(QSizePolicy.Fixed)
individual_curve_grpbx = QGroupBox()
individual_curve_grpbx.setMinimumWidth(300)
individual_curve_grpbx.setMinimumHeight(120)
individual_curve_grpbx.setAlignment(Qt.AlignTop)
individual_curve_grpbx.setSizePolicy(size_policy)
individual_curve_grpbx.setObjectName(pv_name + "_grb")
individual_curve_grpbx.setLayout(individual_curve_layout)
checkbox = QCheckBox(parent=individual_curve_grpbx)
checkbox.setObjectName(pv_name + "_chb")
palette = checkbox.palette()
palette.setColor(QPalette.Active, QPalette.WindowText, curve_color)
checkbox.setPalette(palette)
display_name = pv_name.split("://")[1]
if len(display_name) > MAX_DISPLAY_PV_NAME_LENGTH:
# Only display max allowed number of characters of the PV Name
display_name = display_name[
:int(MAX_DISPLAY_PV_NAME_LENGTH / 2) - 1] + "..." + \
display_name[
-int(MAX_DISPLAY_PV_NAME_LENGTH / 2) + 2:]
checkbox.setText(display_name)
data_text = QLabel(parent=individual_curve_grpbx)
data_text.setWordWrap(True)
data_text.setObjectName(pv_name + "_lbl")
data_text.setPalette(palette)
checkbox.setChecked(True)
checkbox.toggled.connect(
partial(self.handle_curve_chkbox_toggled, checkbox))
if not self.chart.findCurve(pv_name).isVisible():
checkbox.setChecked(False)
modify_curve_btn = QPushButton("Modify...",
parent=individual_curve_grpbx)
modify_curve_btn.setObjectName(pv_name + "_btn_modify")
modify_curve_btn.setMaximumWidth(80)
modify_curve_btn.clicked.connect(
partial(self.display_curve_settings_dialog, pv_name))
focus_curve_btn = QPushButton("Focus", parent=individual_curve_grpbx)
focus_curve_btn.setObjectName(pv_name + "_btn_focus")
focus_curve_btn.setMaximumWidth(80)
focus_curve_btn.clicked.connect(partial(self.focus_curve, pv_name))
clear_curve_btn = QPushButton("Clear", parent=individual_curve_grpbx)
clear_curve_btn.setObjectName(pv_name + "_btn_clear")
clear_curve_btn.setMaximumWidth(80)
clear_curve_btn.clicked.connect(partial(self.clear_curve, pv_name))
# annotate_curve_btn = QPushButton("Annotate...",
# parent=individual_curve_grpbx)
# annotate_curve_btn.setObjectName(pv_name+"_btn_ann")
# annotate_curve_btn.setMaximumWidth(80)
# annotate_curve_btn.clicked.connect(
# partial(self.annotate_curve, pv_name))
remove_curve_btn = QPushButton("Remove", parent=individual_curve_grpbx)
remove_curve_btn.setObjectName(pv_name + "_btn_remove")
remove_curve_btn.setMaximumWidth(80)
remove_curve_btn.clicked.connect(partial(self.remove_curve, pv_name))
curve_btn_layout = QHBoxLayout()
curve_btn_layout.setSpacing(5)
curve_btn_layout.addWidget(modify_curve_btn)
curve_btn_layout.addWidget(focus_curve_btn)
curve_btn_layout.addWidget(clear_curve_btn)
# curve_btn_layout.addWidget(annotate_curve_btn)
curve_btn_layout.addWidget(remove_curve_btn)
individual_curve_layout.addWidget(checkbox)
individual_curve_layout.addWidget(data_text)
individual_curve_layout.addLayout(curve_btn_layout)
self.curve_settings_layout.addWidget(individual_curve_grpbx)
self.tab_panel.setCurrentIndex(0)
def __init__(self,
*,
name="",
add_sliders=False,
slider_steps=10000,
selection_to_range_min=0.001):
"""
Class constructor for RangeManager
Parameters
----------
add_sliders: bool
True - the widget will include sliders for controlling the range,
False - the widget will have no sliders without sliders
slider_steps: int
The number of slider steps. Determines the precision of the slider.
Default value is sufficient in most cases
selection_to_range_min: float
Minimum ratio of the selected range and total range. Must be floating
point number >=0. Used only when the value type is set to "float":
`self.set_value_type("float")`. Minimum selected range is always 1
when "int" value type is set.
"""
super().__init__()
self._name = name
# Set the maximum number of steps for the sliders (resolution)
self.sld_n_steps = slider_steps
# Ratio of the minimum range and total range. It is used to compute
# the value of 'self._range_min_diff'. The widget will prevent
# range to be set to smaller value than 'self._range_min_diff'.
self._selection_to_range_min = selection_to_range_min
self._range_low = 0.0
self._range_high = 100.0
self._range_min_diff = (self._range_high -
self._range_low) * self._selection_to_range_min
self._value_per_step = (self._range_high -
self._range_low) / self.sld_n_steps
self._value_type = "float"
# The following values are used to keep the low and high of the range.
# Those values are 'accepted' values that reflect current selected range.
self._value_low = self._range_low
self._value_high = self._range_high
max_element_width = 200
self.le_min_value = LineEditExtended()
self.le_max_value = LineEditExtended()
self.validator_low = DoubleValidatorRelaxed()
self.validator_high = DoubleValidatorRelaxed()
self.le_min_value.setMaximumWidth(max_element_width)
self.le_min_value.textEdited.connect(self.le_min_value_text_edited)
self.le_min_value.textChanged.connect(self.le_min_value_text_changed)
self.le_min_value.editingFinished.connect(
self.le_min_value_editing_finished)
self.le_max_value.setMaximumWidth(max_element_width)
self.le_max_value.textEdited.connect(self.le_max_value_text_edited)
self.le_max_value.textChanged.connect(self.le_max_value_text_changed)
self.le_max_value.editingFinished.connect(
self.le_max_value_editing_finished)
self.le_min_value.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
self.le_max_value.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
# The flag is set true if mouse is pressed on one of the sliders
# Both sliders can not be pressed at once, so one variable is sufficient
self._sld_mouse_pressed = False
self.sld_min_value = QSlider(Qt.Horizontal)
self.sld_min_value.valueChanged.connect(
self.sld_min_value_value_changed)
self.sld_min_value.sliderPressed.connect(
self.sld_min_value_slider_pressed)
self.sld_min_value.sliderReleased.connect(
self.sld_min_value_slider_released)
self.sld_max_value = QSlider(Qt.Horizontal)
self.sld_max_value.valueChanged.connect(
self.sld_max_value_value_changed)
self.sld_max_value.sliderPressed.connect(
self.sld_max_value_slider_pressed)
self.sld_max_value.sliderReleased.connect(
self.sld_max_value_slider_released)
self.sld_min_value.setMaximumWidth(max_element_width)
self.sld_max_value.setMaximumWidth(max_element_width)
# The slider for controlling minimum is inverted
self.sld_min_value.setInvertedAppearance(True)
self.sld_min_value.setInvertedControls(True)
self.sld_min_value.setMaximum(self.sld_n_steps)
self.sld_max_value.setMaximum(self.sld_n_steps)
self.sld_min_value.setValue(self.sld_min_value.maximum())
self.sld_max_value.setValue(self.sld_max_value.maximum())
self.set_value_type(self._value_type) # Set the validator
grid = QGridLayout()
grid.setHorizontalSpacing(0)
grid.setVerticalSpacing(0)
grid.setContentsMargins(0, 0, 0, 0)
grid.addWidget(self.le_min_value, 0, 0)
grid.addWidget(QLabel(".."), 0, 1)
grid.addWidget(self.le_max_value, 0, 2)
if add_sliders:
grid.addWidget(self.sld_min_value, 1, 0)
grid.addWidget(QLabel(""), 1, 1)
grid.addWidget(self.sld_max_value, 1, 2)
self.setLayout(grid)
sp = QSizePolicy()
sp.setControlType(QSizePolicy.PushButton)
sp.setHorizontalPolicy(QSizePolicy.Maximum)
self.setSizePolicy(sp)
