class LegendPropertiesWindow(PyDialog):
"""
+-------------------+
| Legend Properties |
+-----------------------+
| Title ______ Default |
| Min ______ Default |
| Max ______ Default |
| Format ______ Default |
| Scale ______ Default |
| Phase ______ Default |
| Number of Colors ____ |
| Number of Labels ____ |
| Label Size ____ | (TODO)
| ColorMap ____ | (TODO)
| |
| x Min/Max (Blue->Red) |
| o Max/Min (Red->Blue) |
| |
| x Vertical/Horizontal |
| x Show/Hide |
| |
| Animate |
| Apply OK Cancel |
+-----------------------+
"""
def __init__(self, data, win_parent=None, show_animation_button=True):
PyDialog.__init__(self, data, win_parent)
self.is_gui = win_parent is not None
self._updated_legend = False
self.external_call = True
#if win_parent is None:
self._icase_fringe = data['icase_fringe']
self._icase_disp = data['icase_disp']
self._icase_vector = data['icase_vector']
#else:
#self._icase_fringe = data['icase']
#self._icase_disp = data['icase']
#self._icase_vector = data['icase']
self._default_icase_fringe = self._icase_fringe
self._default_icase_disp = self._icase_disp
self._default_icase_vector = self._icase_vector
#print('*icase_fringe=%s icase_disp=%s icase_vector=%s' % (
#self._default_icase_fringe, self._default_icase_disp, self._default_icase_vector))
self._default_title = data['title']
self._default_min = data['min_value']
self._default_max = data['max_value']
self._default_scale = data['default_scale']
self._scale = data['scale']
#if win_parent is None:
self._default_arrow_scale = data['default_arrow_scale']
self._arrow_scale = data['arrow_scale']
#else:
#self._default_arrow_scale = data['default_scale']
#self._arrow_scale = data['scale']
self._default_phase = data['default_phase']
self._phase = data['phase']
self._default_format = data['default_format']
self._format = data['format']
self._default_labelsize = data['default_labelsize']
self._labelsize = data['labelsize']
self._default_nlabels = data['default_nlabels']
self._nlabels = data['nlabels']
self._default_ncolors = data['default_ncolors']
self._ncolors = data['ncolors']
self._default_colormap = data['default_colormap']
self._colormap = data['colormap']
self._default_is_low_to_high = data['is_low_to_high']
self._default_is_discrete = data['is_discrete']
self._default_is_horizontal = data['is_horizontal']
self._default_is_shown = data['is_shown']
self._is_fringe = data['is_fringe']
self._update_defaults_to_blank()
self.setWindowTitle('Legend Properties')
self.create_widgets(show_animation_button=show_animation_button)
self.create_layout()
self.set_connections()
self.set_font_size(data['font_size'])
def _update_defaults_to_blank(self):
"""Changes the default (None) to a blank string"""
if self._default_colormap is None:
self._default_colormap = 'jet'
if self._default_labelsize is None:
self._default_labelsize = ''
if self._default_ncolors is None:
self._default_ncolors = ''
if self._default_nlabels is None:
self._default_nlabels = ''
if self._colormap is None:
self._colormap = 'jet'
if self._labelsize is None:
self._labelsize = ''
if self._ncolors is None:
self._ncolors = ''
if self._nlabels is None:
self._nlabels = ''
def update_legend(self,
icase_fringe,
icase_disp,
icase_vector,
title,
min_value,
max_value,
data_format,
nlabels,
labelsize,
ncolors,
colormap,
is_fringe,
scale,
phase,
arrow_scale,
default_title,
default_min_value,
default_max_value,
default_data_format,
default_nlabels,
default_labelsize,
default_ncolors,
default_colormap,
default_scale,
default_phase,
default_arrow_scale,
font_size=8,
external_call=False):
"""
We need to update the legend if there's been a result change request
"""
self.external_call = external_call
self.set_font_size(font_size)
update_fringe = False
update_disp = False
update_vector = False
#print('update_legend; fringe=%s disp=%s vector=%s' % (
#icase_fringe, icase_disp, icase_vector))
#print('update_legend; default: fringe=%s disp=%s vector=%s' % (
# self._default_icase_fringe, self._default_icase_disp, self._default_icase_vector))
if icase_fringe != self._default_icase_fringe:
self._icase_fringe = icase_fringe
self._default_icase_fringe = icase_fringe
update_fringe = True
#is_fringe = icase_fringe is not None
is_disp = icase_disp is not None
is_vector = icase_vector is not None
if icase_disp != self._default_icase_disp:
assert isinstance(
scale, float_types), 'scale=%r type=%s' % (scale, type(scale))
#assert isinstance(default_scale, float), 'default_scale=%r' % default_scale
self._icase_disp = icase_disp
self._default_icase_disp = icase_disp
self._default_scale = default_scale
self._default_phase = default_phase
update_disp = True
if icase_vector != self._default_icase_vector:
assert isinstance(
arrow_scale,
float_types), 'arrow_scale=%r type=%s' % (arrow_scale,
type(scale))
#assert isinstance(default_arrow_scale, float), 'default_arrow_scale=%r' % default_arrow_scale
self._icase_vector = icase_vector
self._default_icase_vector = icase_vector
self._default_arrow_scale = default_arrow_scale
update_vector = True
#print('*update_legend; default: fringe=%s disp=%s vector=%s' % (
# self._default_icase_fringe, self._default_icase_disp, self._default_icase_vector))
#print('update_fringe=%s update_disp=%s update_vector=%s' % (
# update_fringe, update_disp, update_vector))
#print('is_fringe=%s is_disp=%s is_vector=%s' % (
# is_fringe, is_disp, is_vector))
if update_fringe:
self._icase_fringe = icase_fringe
self._default_icase_fringe = icase_fringe
self._default_title = default_title
self._default_min = default_min_value
self._default_max = default_max_value
self._default_format = default_data_format
#self._default_is_low_to_high = is_low_to_high
self._default_is_discrete = True
#self._default_is_horizontal = is_horizontal_scalar_bar
self._default_nlabels = default_nlabels
self._default_labelsize = default_labelsize
self._default_ncolors = default_ncolors
self._default_colormap = default_colormap
self._is_fringe = is_fringe
if colormap is None:
colormap = 'jet'
if labelsize is None:
labelsize = ''
if ncolors is None:
ncolors = ''
if nlabels is None:
nlabels = ''
self._update_defaults_to_blank()
#-----------------------------------------------------------------------
update = update_fringe or update_disp or update_vector
if update:
#self.scale_label.setEnabled(is_disp)
#self.scale_edit.setEnabled(is_disp)
#self.scale_button.setEnabled(is_disp)
self.scale_label.setVisible(is_disp)
self.scale_edit.setVisible(is_disp)
self.scale_button.setVisible(is_disp)
is_complex_disp = self._default_phase is not None
self.phase_label.setVisible(is_complex_disp)
self.phase_edit.setVisible(is_complex_disp)
self.phase_button.setVisible(is_complex_disp)
self._scale = set_cell_to_blank_if_value_is_none(
self.scale_edit, scale)
self._phase = set_cell_to_blank_if_value_is_none(
self.phase_edit, phase)
if self._default_icase_disp is None: # or self._default_icase_vector is None:
self.animate_button.setEnabled(False)
self.animate_button.setToolTip(ANIMATE_TOOLTIP_OFF)
else:
self.animate_button.setEnabled(True)
self.animate_button.setToolTip(ANIMATE_TOOLTIP_ON)
#-----------------------------------------------------------------------
if update:
#self.arrow_scale_label.setEnabled(is_vector)
#self.arrow_scale_edit.setEnabled(is_vector)
#self.arrow_scale_button.setEnabled(is_vector)
self.arrow_scale_label.setVisible(is_vector)
self.arrow_scale_edit.setVisible(is_vector)
self.arrow_scale_button.setVisible(is_vector)
self._arrow_scale = set_cell_to_blank_if_value_is_none(
self.arrow_scale_edit, arrow_scale)
#-----------------------------------------------------------------------
if update_fringe:
#self.on_default_title()
#self.on_default_min()
#self.on_default_max()
#self.on_default_format()
#self.on_default_scale()
# reset defaults
self.title_edit.setText(title)
self.title_edit.setStyleSheet("QLineEdit{background: white;}")
self.min_edit.setText(str(min_value))
self.min_edit.setStyleSheet("QLineEdit{background: white;}")
self.max_edit.setText(str(max_value))
self.max_edit.setStyleSheet("QLineEdit{background: white;}")
self.format_edit.setText(str(data_format))
self.format_edit.setStyleSheet("QLineEdit{background: white;}")
self.nlabels_edit.setText(str(nlabels))
self.nlabels_edit.setStyleSheet("QLineEdit{background: white;}")
self.labelsize_edit.setText(str(labelsize))
self.labelsize_edit.setStyleSheet("QLineEdit{background: white;}")
self.ncolors_edit.setText(str(ncolors))
self.ncolors_edit.setStyleSheet("QLineEdit{background: white;}")
self.colormap_edit.setCurrentIndex(
colormap_keys.index(str(colormap)))
self._set_legend_fringe(self._is_fringe)
if update:
self.on_apply()
self.external_call = True
#print('---------------------------------')
def clear_disp(self):
"""hides dispacement blocks"""
self._icase_disp = None
self._default_icase_disp = None
self.scale_label.setVisible(False)
self.scale_edit.setVisible(False)
self.scale_button.setVisible(False)
self.phase_label.setVisible(False)
self.phase_edit.setVisible(False)
self.phase_button.setVisible(False)
def clear_vector(self):
"""hides vector blocks"""
self._icase_vector = None
self._default_icase_vector = None
self.arrow_scale_label.setVisible(False)
self.arrow_scale_edit.setVisible(False)
self.arrow_scale_button.setVisible(False)
def clear(self):
"""hides fringe, displacemnt, and vector blocks"""
self._icase_fringe = None
self._default_icase_fringe = None
self._set_legend_fringe(False)
self.clear_disp()
self.clear_vector()
def _set_legend_fringe(self, is_fringe):
"""
Show/hide buttons if we dont have a result. This is used for normals.
A result can still exist (i.e., icase_fringe is not None).
"""
# lots of hacking for the Normal vectors
self._is_fringe = is_fringe
#self._default_icase_fringe = None
enable = True
if not is_fringe:
enable = False
show_title = self._icase_fringe is not None
self.title_label.setVisible(show_title)
self.title_edit.setVisible(show_title)
self.title_button.setVisible(show_title)
self.max_label.setVisible(enable)
self.min_label.setVisible(enable)
self.max_edit.setVisible(enable)
self.min_edit.setVisible(enable)
self.max_button.setVisible(enable)
self.min_button.setVisible(enable)
self.show_radio.setVisible(enable)
self.hide_radio.setVisible(enable)
self.low_to_high_radio.setVisible(enable)
self.high_to_low_radio.setVisible(enable)
self.format_label.setVisible(enable)
self.format_edit.setVisible(enable)
self.format_edit.setVisible(enable)
self.format_button.setVisible(enable)
self.nlabels_label.setVisible(enable)
self.nlabels_edit.setVisible(enable)
self.nlabels_button.setVisible(enable)
self.ncolors_label.setVisible(enable)
self.ncolors_edit.setVisible(enable)
self.ncolors_button.setVisible(enable)
self.grid2_title.setVisible(enable)
self.vertical_radio.setVisible(enable)
self.horizontal_radio.setVisible(enable)
self.colormap_label.setVisible(enable)
self.colormap_edit.setVisible(enable)
self.colormap_button.setVisible(enable)
def create_widgets(self, show_animation_button=True):
"""creates the menu objects"""
# title
self.title_label = QLabel("Title:")
self.title_edit = QLineEdit(str(self._default_title))
self.title_button = QPushButton("Default")
# Min
self.min_label = QLabel("Min:")
self.min_edit = QLineEdit(str(self._default_min))
self.min_button = QPushButton("Default")
# Max
self.max_label = QLabel("Max:")
self.max_edit = QLineEdit(str(self._default_max))
self.max_button = QPushButton("Default")
#---------------------------------------
# Format
self.format_label = QLabel("Format (e.g. %.3f, %g, %.6e):")
self.format_edit = QLineEdit(str(self._format))
self.format_button = QPushButton("Default")
#---------------------------------------
# Scale
self.scale_label = QLabel("True Scale:")
self.scale_edit = QLineEdit(str(self._scale))
self.scale_button = QPushButton("Default")
if self._icase_disp is None:
self.scale_label.setVisible(False)
self.scale_edit.setVisible(False)
self.scale_button.setVisible(False)
# Phase
self.phase_label = QLabel("Phase (deg):")
self.phase_edit = QLineEdit(str(self._phase))
self.phase_button = QPushButton("Default")
if self._icase_disp is None or self._default_phase is None:
self.phase_label.setVisible(False)
self.phase_edit.setVisible(False)
self.phase_button.setVisible(False)
self.phase_edit.setText('0.0')
#---------------------------------------
self.arrow_scale_label = QLabel("Arrow Scale:")
self.arrow_scale_edit = QLineEdit(str(self._arrow_scale))
self.arrow_scale_button = QPushButton("Default")
if self._icase_vector is None:
self.arrow_scale_label.setVisible(False)
self.arrow_scale_edit.setVisible(False)
self.arrow_scale_button.setVisible(False)
#tip = QtGui.QToolTip()
#tip.setTe
#self.format_edit.toolTip(tip)
#---------------------------------------
# nlabels
self.nlabels_label = QLabel("Number of Labels:")
self.nlabels_edit = QLineEdit(str(self._nlabels))
self.nlabels_button = QPushButton("Default")
self.labelsize_label = QLabel("Label Size:")
self.labelsize_edit = QLineEdit(str(self._labelsize))
self.labelsize_button = QPushButton("Default")
self.ncolors_label = QLabel("Number of Colors:")
self.ncolors_edit = QLineEdit(str(self._ncolors))
self.ncolors_button = QPushButton("Default")
self.colormap_label = QLabel("Color Map:")
self.colormap_edit = QComboBox(self)
self.colormap_button = QPushButton("Default")
for key in colormap_keys:
self.colormap_edit.addItem(key)
self.colormap_edit.setCurrentIndex(colormap_keys.index(self._colormap))
# --------------------------------------------------------------
# the header
self.grid2_title = QLabel("Color Scale:")
# red/blue or blue/red
self.low_to_high_radio = QRadioButton('Low -> High')
self.high_to_low_radio = QRadioButton('High -> Low')
widget = QWidget(self)
low_to_high_group = QButtonGroup(widget)
low_to_high_group.addButton(self.low_to_high_radio)
low_to_high_group.addButton(self.high_to_low_radio)
self.low_to_high_radio.setChecked(self._default_is_low_to_high)
self.high_to_low_radio.setChecked(not self._default_is_low_to_high)
# horizontal / vertical
self.horizontal_radio = QRadioButton("Horizontal")
self.vertical_radio = QRadioButton("Vertical")
widget = QWidget(self)
horizontal_vertical_group = QButtonGroup(widget)
horizontal_vertical_group.addButton(self.horizontal_radio)
horizontal_vertical_group.addButton(self.vertical_radio)
self.horizontal_radio.setChecked(self._default_is_horizontal)
self.vertical_radio.setChecked(not self._default_is_horizontal)
# on / off
self.show_radio = QRadioButton("Show")
self.hide_radio = QRadioButton("Hide")
widget = QWidget(self)
show_hide_group = QButtonGroup(widget)
show_hide_group.addButton(self.show_radio)
show_hide_group.addButton(self.hide_radio)
self.show_radio.setChecked(self._default_is_shown)
self.hide_radio.setChecked(not self._default_is_shown)
# --------------------------------------------------------------
if self._icase_fringe is None:
self.title_label.setVisible(False)
self.title_edit.setVisible(False)
self.title_button.setVisible(False)
if not self._is_fringe:
self.max_label.hide()
self.min_label.hide()
self.max_edit.hide()
self.min_edit.hide()
self.max_button.hide()
self.min_button.hide()
self.format_label.hide()
self.format_edit.hide()
self.format_button.hide()
self.nlabels_label.hide()
self.nlabels_edit.hide()
self.nlabels_button.hide()
self.ncolors_label.hide()
self.ncolors_edit.hide()
self.ncolors_button.hide()
self.grid2_title.hide()
self.vertical_radio.hide()
self.horizontal_radio.hide()
self.show_radio.hide()
self.hide_radio.hide()
self.low_to_high_radio.hide()
self.high_to_low_radio.hide()
self.colormap_label.hide()
self.colormap_edit.hide()
self.colormap_button.hide()
self.animate_button = QPushButton('Create Animation')
self.animate_button.setVisible(show_animation_button)
#self.advanced_button = QPushButton('Advanced')
if self._default_icase_disp is None: # or self._default_icase_vector is None:
self.animate_button.setEnabled(False)
self.animate_button.setToolTip(ANIMATE_TOOLTIP_OFF)
else:
self.animate_button.setEnabled(True)
self.animate_button.setToolTip(ANIMATE_TOOLTIP_ON)
# closing
self.apply_button = QPushButton("Apply")
self.ok_button = QPushButton("OK")
self.cancel_button = QPushButton("Cancel")
def create_layout(self):
"""displays the menu objects"""
grid = QGridLayout()
grid.addWidget(self.title_label, 0, 0)
grid.addWidget(self.title_edit, 0, 1)
grid.addWidget(self.title_button, 0, 2)
grid.addWidget(self.min_label, 1, 0)
grid.addWidget(self.min_edit, 1, 1)
grid.addWidget(self.min_button, 1, 2)
grid.addWidget(self.max_label, 2, 0)
grid.addWidget(self.max_edit, 2, 1)
grid.addWidget(self.max_button, 2, 2)
grid.addWidget(self.format_label, 3, 0)
grid.addWidget(self.format_edit, 3, 1)
grid.addWidget(self.format_button, 3, 2)
grid.addWidget(self.scale_label, 4, 0)
grid.addWidget(self.scale_edit, 4, 1)
grid.addWidget(self.scale_button, 4, 2)
grid.addWidget(self.phase_label, 6, 0)
grid.addWidget(self.phase_edit, 6, 1)
grid.addWidget(self.phase_button, 6, 2)
grid.addWidget(self.arrow_scale_label, 5, 0)
grid.addWidget(self.arrow_scale_edit, 5, 1)
grid.addWidget(self.arrow_scale_button, 5, 2)
grid.addWidget(self.nlabels_label, 7, 0)
grid.addWidget(self.nlabels_edit, 7, 1)
grid.addWidget(self.nlabels_button, 7, 2)
#grid.addWidget(self.labelsize_label, 6, 0)
#grid.addWidget(self.labelsize_edit, 6, 1)
#grid.addWidget(self.labelsize_button, 6, 2)
grid.addWidget(self.ncolors_label, 8, 0)
grid.addWidget(self.ncolors_edit, 8, 1)
grid.addWidget(self.ncolors_button, 8, 2)
grid.addWidget(self.colormap_label, 9, 0)
grid.addWidget(self.colormap_edit, 9, 1)
grid.addWidget(self.colormap_button, 9, 2)
ok_cancel_box = QHBoxLayout()
ok_cancel_box.addWidget(self.apply_button)
ok_cancel_box.addWidget(self.ok_button)
ok_cancel_box.addWidget(self.cancel_button)
grid2 = QGridLayout()
grid2.addWidget(self.grid2_title, 0, 0)
grid2.addWidget(self.low_to_high_radio, 1, 0)
grid2.addWidget(self.high_to_low_radio, 2, 0)
grid2.addWidget(self.vertical_radio, 1, 1)
grid2.addWidget(self.horizontal_radio, 2, 1)
grid2.addWidget(self.show_radio, 1, 2)
grid2.addWidget(self.hide_radio, 2, 2)
grid2.addWidget(self.animate_button, 3, 1)
#grid2.setSpacing(0)
vbox = QVBoxLayout()
vbox.addLayout(grid)
#vbox.addLayout(checkboxes)
vbox.addLayout(grid2)
vbox.addStretch()
vbox.addLayout(ok_cancel_box)
self.setLayout(vbox)
def set_connections(self):
"""creates the actions for the menu"""
self.title_button.clicked.connect(self.on_default_title)
self.min_button.clicked.connect(self.on_default_min)
self.max_button.clicked.connect(self.on_default_max)
self.format_button.clicked.connect(self.on_default_format)
self.scale_button.clicked.connect(self.on_default_scale)
self.arrow_scale_button.clicked.connect(self.on_default_arrow_scale)
self.phase_button.clicked.connect(self.on_default_phase)
self.nlabels_button.clicked.connect(self.on_default_nlabels)
self.labelsize_button.clicked.connect(self.on_default_labelsize)
self.ncolors_button.clicked.connect(self.on_default_ncolors)
self.colormap_button.clicked.connect(self.on_default_colormap)
self.animate_button.clicked.connect(self.on_animate)
self.show_radio.clicked.connect(self.on_show_hide)
self.hide_radio.clicked.connect(self.on_show_hide)
self.apply_button.clicked.connect(self.on_apply)
self.ok_button.clicked.connect(self.on_ok)
self.cancel_button.clicked.connect(self.on_cancel)
def set_font_size(self, font_size):
"""
Updates the font size of the objects
Parameters
----------
font_size : int
the font size
"""
if self.font_size == font_size:
return
self.font_size = font_size
font = QFont()
font.setPointSize(font_size)
self.setFont(font)
self.title_edit.setFont(font)
self.min_edit.setFont(font)
self.max_edit.setFont(font)
self.format_edit.setFont(font)
self.scale_edit.setFont(font)
self.phase_edit.setFont(font)
self.nlabels_edit.setFont(font)
self.labelsize_edit.setFont(font)
self.ncolors_edit.setFont(font)
def on_animate(self):
"""opens the animation window"""
title, flag0 = check_name_str(self.title_edit)
if not flag0:
return
scale, flag1 = check_float(self.scale_edit)
if not flag1:
scale = self._scale
data = {
'font_size': self.out_data['font_size'],
'icase_fringe': self._icase_fringe,
'icase_disp': self._icase_disp,
'icase_vector': self._icase_vector,
'title': title,
'time': 2,
'frames/sec': 30,
'resolution': 1,
'iframe': 0,
'scale': scale,
'default_scale': self._default_scale,
'arrow_scale': scale,
'default_arrow_scale': self._default_arrow_scale,
'is_scale': self._default_phase is None,
'phase': self._phase,
'default_phase': self._default_phase,
'dirname': os.path.abspath(os.getcwd()),
'clicked_ok': False,
'close': False,
}
self.win_parent.legend_obj.set_animation_window(data)
def on_default_title(self):
"""action when user clicks 'Default' for title"""
title = str(self._default_title)
self.title_edit.setText(title)
self.title_edit.setStyleSheet("QLineEdit{background: white;}")
def on_default_min(self):
"""action when user clicks 'Default' for min value"""
self.min_edit.setText(str(self._default_min))
self.min_edit.setStyleSheet("QLineEdit{background: white;}")
def on_default_max(self):
"""action when user clicks 'Default' for max value"""
self.max_edit.setText(str(self._default_max))
self.max_edit.setStyleSheet("QLineEdit{background: white;}")
def on_default_format(self):
"""action when user clicks 'Default' for the number format"""
self.format_edit.setText(str(self._default_format))
self.format_edit.setStyleSheet("QLineEdit{background: white;}")
def on_default_scale(self):
"""action when user clicks 'Default' for scale factor"""
self.scale_edit.setText(str(self._default_scale))
self.scale_edit.setStyleSheet("QLineEdit{background: white;}")
def on_default_arrow_scale(self):
"""action when user clicks 'Default' for arrow_scale factor"""
self.arrow_scale_edit.setText(str(self._default_arrow_scale))
self.arrow_scale_edit.setStyleSheet("QLineEdit{background: white;}")
def on_default_phase(self):
"""action when user clicks 'Default' for phase angle"""
self.phase_edit.setText(str(self._default_phase))
self.phase_edit.setStyleSheet("QLineEdit{background: white;}")
def on_default_ncolors(self):
"""action when user clicks 'Default' for number of colors"""
self.ncolors_edit.setText(str(self._default_ncolors))
self.ncolors_edit.setStyleSheet("QLineEdit{background: white;}")
def on_default_colormap(self):
"""action when user clicks 'Default' for the color map"""
self.colormap_edit.setCurrentIndex(
colormap_keys.index(self._default_colormap))
def on_default_nlabels(self):
"""action when user clicks 'Default' for number of labels"""
self.nlabels_edit.setStyleSheet("QLineEdit{background: white;}")
self.nlabels_edit.setText(str(self._default_nlabels))
def on_default_labelsize(self):
"""action when user clicks 'Default' for number of labelsize"""
self.labelsize_edit.setText(str(self._default_labelsize))
self.labelsize_edit.setStyleSheet("QLineEdit{background: white;}")
def on_show_hide(self):
"""action when user clicks the 'Show/Hide' radio button"""
#self.colormap_edit.setCurrentIndex(colormap_keys.index(self._default_colormap))
is_shown = self.show_radio.isChecked()
self.nlabels_edit.setEnabled(is_shown)
self.nlabels_button.setEnabled(is_shown)
self.ncolors_edit.setEnabled(is_shown)
self.ncolors_button.setEnabled(is_shown)
self.high_to_low_radio.setEnabled(is_shown)
self.low_to_high_radio.setEnabled(is_shown)
self.colormap_edit.setEnabled(is_shown)
self.colormap_button.setEnabled(is_shown)
self.vertical_radio.setEnabled(is_shown)
self.horizontal_radio.setEnabled(is_shown)
def show_legend(self):
"""shows the legend"""
self._set_legend(True)
def hide_legend(self):
"""hides the legend"""
self._set_legend(False)
def _set_legend(self, is_shown):
"""shows/hides the legend"""
self.show_radio.setChecked(is_shown)
self.hide_radio.setChecked(not is_shown)
#if self.is_gui:
#self.win_parent.scalar_bar_actor.SetVisibility(is_shown)
def on_validate(self):
"""checks to see if the ``on_apply`` method can be called"""
show_title = self._icase_fringe is not None
flag_title = True
title_value = ''
if show_title:
title_value, flag_title = check_name_str(self.title_edit)
flag_fringe = True
min_value = max_value = format_value = nlabels = ncolors = labelsize = colormap = None
if self._icase_fringe is not None:
min_value, flag1 = check_float(self.min_edit)
max_value, flag2 = check_float(self.max_edit)
format_value, flag3 = check_format(self.format_edit)
nlabels, flag4 = check_positive_int_or_blank(self.nlabels_edit)
ncolors, flag5 = check_positive_int_or_blank(self.ncolors_edit)
labelsize, flag6 = check_positive_int_or_blank(self.labelsize_edit)
colormap = str(self.colormap_edit.currentText())
if flag3 and 'i' in format_value:
format_value = '%i'
flag_fringe = all([flag1, flag2, flag3, flag4, flag5, flag6])
flag_disp = True
scale = phase = None
if self._icase_disp is not None:
scale, flag1 = check_float(self.scale_edit)
phase, flag2 = check_float(self.phase_edit)
assert isinstance(scale, float), scale
flag_disp = all([flag1, flag2])
flag_vector = True
arrow_scale = None
if self._icase_vector is not None:
arrow_scale, flag_vector = check_float(self.arrow_scale_edit)
if all([flag_title, flag_fringe, flag_disp, flag_vector]):
self.out_data['title'] = title_value
self.out_data['min_value'] = min_value
self.out_data['max_value'] = max_value
self.out_data['format'] = format_value
self.out_data['scale'] = scale
self.out_data['phase'] = phase
self.out_data['arrow_scale'] = arrow_scale
self.out_data['nlabels'] = nlabels
self.out_data['ncolors'] = ncolors
self.out_data['labelsize'] = labelsize
self.out_data['colormap'] = colormap
self.out_data['is_low_to_high'] = self.low_to_high_radio.isChecked(
)
self.out_data['is_horizontal'] = self.horizontal_radio.isChecked()
self.out_data['is_shown'] = self.show_radio.isChecked()
self.out_data['clicked_ok'] = True
self.out_data['close'] = True
#print('self.out_data = ', self.out_data)
#print("title = %r" % self.title_edit.text())
#print("min = %r" % self.min_edit.text())
#print("max = %r" % self.max_edit.text())
#print("format = %r" % self.format_edit.text())
return True
return False
def on_apply(self):
"""applies the current values"""
passed = self.on_validate()
if passed and self.external_call:
self.win_parent.legend_obj._apply_legend(self.out_data)
self.external_call = True
return passed
def on_ok(self):
"""applies the current values and closes the window"""
passed = self.on_apply()
if passed:
self.close()
#self.destroy()
def on_cancel(self):
"""closes the windows and reverts the legend"""
self.out_data['close'] = True
self.close()
class PluginListItem(QFrame):
def __init__(
self,
package_name: str,
version: str = '',
url: str = '',
summary: str = '',
author: str = '',
license: str = "UNKNOWN",
*,
plugin_name: str = None,
parent: QWidget = None,
enabled: bool = True,
installed: bool = False,
npe_version=1,
):
super().__init__(parent)
self.setup_ui(enabled)
self.plugin_name.setText(package_name)
self.package_name.setText(version)
self.summary.setText(summary)
self.package_author.setText(author)
self.cancel_btn.setVisible(False)
self.help_button.setText(trans._("Website"))
self.help_button.setObjectName("help_button")
if npe_version != 1:
self._handle_npe2_plugin()
if installed:
self.enabled_checkbox.show()
self.action_button.setText(trans._("uninstall"))
self.action_button.setObjectName("remove_button")
else:
self.enabled_checkbox.hide()
self.action_button.setText(trans._("install"))
self.action_button.setObjectName("install_button")
def _handle_npe2_plugin(self):
npe2_icon = QLabel(self)
icon = QColoredSVGIcon.from_resources('logo_silhouette')
npe2_icon.setPixmap(icon.colored(color='#33F0FF').pixmap(20, 20))
self.row1.insertWidget(2, QLabel('npe2'))
self.row1.insertWidget(2, npe2_icon)
def _get_dialog(self) -> QDialog:
p = self.parent()
while not isinstance(p, QDialog) and p.parent():
p = p.parent()
return p
def set_busy(self, text: str, update: bool = False):
self.item_status.setText(text)
self.cancel_btn.setVisible(True)
if not update:
self.action_button.setVisible(False)
else:
self.update_btn.setVisible(False)
def setup_ui(self, enabled=True):
self.v_lay = QVBoxLayout(self)
self.v_lay.setContentsMargins(-1, 6, -1, 6)
self.v_lay.setSpacing(0)
self.row1 = QHBoxLayout()
self.row1.setSpacing(6)
self.enabled_checkbox = QCheckBox(self)
self.enabled_checkbox.setChecked(enabled)
self.enabled_checkbox.stateChanged.connect(self._on_enabled_checkbox)
self.enabled_checkbox.setToolTip(trans._("enable/disable"))
sizePolicy = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.enabled_checkbox.sizePolicy().hasHeightForWidth())
self.enabled_checkbox.setSizePolicy(sizePolicy)
self.enabled_checkbox.setMinimumSize(QSize(20, 0))
self.enabled_checkbox.setText("")
self.row1.addWidget(self.enabled_checkbox)
self.plugin_name = QLabel(self)
sizePolicy = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Minimum)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.plugin_name.sizePolicy().hasHeightForWidth())
self.plugin_name.setSizePolicy(sizePolicy)
font15 = QFont()
font15.setPointSize(15)
self.plugin_name.setFont(font15)
self.row1.addWidget(self.plugin_name)
icon = QColoredSVGIcon.from_resources("warning")
self.warning_tooltip = QtToolTipLabel(self)
# TODO: This color should come from the theme but the theme needs
# to provide the right color. Default warning should be orange, not
# red. Code example:
# theme_name = get_settings().appearance.theme
# napari.utils.theme.get_theme(theme_name, as_dict=False).warning.as_hex()
self.warning_tooltip.setPixmap(
icon.colored(color="#E3B617").pixmap(15, 15))
self.warning_tooltip.setVisible(False)
self.row1.addWidget(self.warning_tooltip)
self.item_status = QLabel(self)
self.item_status.setObjectName("small_italic_text")
self.item_status.setSizePolicy(sizePolicy)
self.row1.addWidget(self.item_status)
self.row1.addStretch()
self.package_name = QLabel(self)
self.package_name.setAlignment(Qt.AlignRight | Qt.AlignTrailing
| Qt.AlignVCenter)
self.row1.addWidget(self.package_name)
self.cancel_btn = QPushButton("cancel", self)
self.cancel_btn.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.cancel_btn.setObjectName("remove_button")
self.row1.addWidget(self.cancel_btn)
self.update_btn = QPushButton(self)
self.update_btn.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.update_btn.setObjectName("install_button")
self.row1.addWidget(self.update_btn)
self.update_btn.setVisible(False)
self.help_button = QPushButton(self)
self.action_button = QPushButton(self)
sizePolicy = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.action_button.sizePolicy().hasHeightForWidth())
self.help_button.setSizePolicy(sizePolicy)
self.action_button.setSizePolicy(sizePolicy)
self.row1.addWidget(self.help_button)
self.row1.addWidget(self.action_button)
self.v_lay.addLayout(self.row1)
self.row2 = QHBoxLayout()
self.error_indicator = QPushButton()
self.error_indicator.setObjectName("warning_icon")
self.error_indicator.setCursor(Qt.PointingHandCursor)
self.error_indicator.hide()
self.row2.addWidget(self.error_indicator)
self.row2.setContentsMargins(-1, 4, 0, -1)
self.summary = QElidingLabel(parent=self)
sizePolicy = QSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.summary.sizePolicy().hasHeightForWidth())
self.summary.setSizePolicy(sizePolicy)
self.summary.setObjectName("small_text")
self.row2.addWidget(self.summary)
self.package_author = QLabel(self)
sizePolicy = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.package_author.sizePolicy().hasHeightForWidth())
self.package_author.setSizePolicy(sizePolicy)
self.package_author.setObjectName("small_text")
self.row2.addWidget(self.package_author)
self.v_lay.addLayout(self.row2)
def _on_enabled_checkbox(self, state: int):
"""Called with `state` when checkbox is clicked."""
enabled = bool(state)
plugin_name = self.plugin_name.text()
pm2 = PluginManager.instance()
if plugin_name in pm2:
pm2.enable(plugin_name) if state else pm2.disable(plugin_name)
return
for npe1_name, _, distname in plugin_manager.iter_available():
if distname and (distname == plugin_name):
plugin_manager.set_blocked(npe1_name, not enabled)
def show_warning(self, message: str = ""):
"""Show warning icon and tooltip."""
self.warning_tooltip.setVisible(bool(message))
self.warning_tooltip.setToolTip(message)
class KiteInstallation(QWidget):
"""Kite progress installation widget."""
def __init__(self, parent):
super(KiteInstallation, self).__init__(parent)
# Left side
action_layout = QVBoxLayout()
progress_layout = QHBoxLayout()
self._progress_widget = QWidget(self)
self._progress_widget.setFixedHeight(50)
self._progress_filter = HoverEventFilter()
self._progress_bar = QProgressBar(self)
self._progress_bar.setFixedWidth(180)
self._progress_widget.installEventFilter(self._progress_filter)
self.cancel_button = QPushButton()
self.cancel_button.setIcon(ima.icon('DialogCloseButton'))
self.cancel_button.hide()
progress_layout.addWidget(self._progress_bar, alignment=Qt.AlignLeft)
progress_layout.addWidget(self.cancel_button)
self._progress_widget.setLayout(progress_layout)
self._progress_label = QLabel(_('Downloading'))
install_info = QLabel(
_("Kite comes with a native app called the Copilot <br>"
"which provides you with real time <br>"
"documentation as you code.<br><br>"
"When Kite is done installing, the Copilot will <br>"
"launch automatically and guide you throught the <br>"
"rest of the setup process."))
button_layout = QHBoxLayout()
self.ok_button = QPushButton(_('OK'))
button_layout.addStretch()
button_layout.addWidget(self.ok_button)
button_layout.addStretch()
action_layout.addStretch()
action_layout.addWidget(self._progress_label)
action_layout.addWidget(self._progress_widget)
action_layout.addWidget(install_info)
action_layout.addSpacing(10)
action_layout.addLayout(button_layout)
action_layout.addStretch()
# Right side
copilot_image_source = get_image_path('kite_copilot.png')
copilot_image = QPixmap(copilot_image_source)
copilot_label = QLabel()
screen = QApplication.primaryScreen()
device_pixel_ratio = screen.devicePixelRatio()
if device_pixel_ratio > 1:
copilot_image.setDevicePixelRatio(device_pixel_ratio)
copilot_label.setPixmap(copilot_image)
else:
image_height = int(copilot_image.height() * 0.4)
image_width = int(copilot_image.width() * 0.4)
copilot_label.setPixmap(
copilot_image.scaled(image_width, image_height,
Qt.KeepAspectRatio,
Qt.SmoothTransformation))
# Layout
general_layout = QHBoxLayout()
general_layout.addLayout(action_layout)
general_layout.addWidget(copilot_label)
self.setLayout(general_layout)
# Signals
self._progress_filter.sig_hover_enter.connect(
lambda: self.cancel_button.show())
self._progress_filter.sig_hover_leave.connect(
lambda: self.cancel_button.hide())
def update_installation_status(self, status):
"""Update installation status (downloading, installing, finished)."""
self._progress_label.setText(status)
if status == INSTALLING:
self._progress_bar.setRange(0, 0)
def update_installation_progress(self, current_value, total):
"""Update installation progress bar."""
self._progress_bar.setMaximum(total)
self._progress_bar.setValue(current_value)
class PluginListItem(QFrame):
def __init__(
self,
package_name: str,
version: str = '',
url: str = '',
summary: str = '',
author: str = '',
license: str = "UNKNOWN",
*,
plugin_name: str = None,
parent: QWidget = None,
enabled: bool = True,
):
super().__init__(parent)
self.setup_ui()
if plugin_name:
self.plugin_name.setText(plugin_name)
self.package_name.setText(f"{package_name} {version}")
self.summary.setText(summary)
self.package_author.setText(author)
self.action_button.setText(trans._("remove"))
self.action_button.setObjectName("remove_button")
self.enabled_checkbox.setChecked(enabled)
if PluginError.get(plugin_name=plugin_name):
def _show_error():
rep = QtPluginErrReporter(parent=self._get_dialog(),
initial_plugin=plugin_name)
rep.setWindowFlags(Qt.Sheet)
close = QPushButton(trans._("close"), rep)
rep.layout.addWidget(close)
rep.plugin_combo.hide()
close.clicked.connect(rep.close)
rep.open()
self.error_indicator.clicked.connect(_show_error)
self.error_indicator.show()
self.summary.setIndent(18)
else:
self.summary.setIndent(38)
else:
self.plugin_name.setText(package_name)
self.package_name.setText(version)
self.summary.setText(summary)
self.package_author.setText(author)
self.action_button.setText(trans._("install"))
self.enabled_checkbox.hide()
def _get_dialog(self) -> QDialog:
p = self.parent()
while not isinstance(p, QDialog) and p.parent():
p = p.parent()
return p
def setup_ui(self):
self.v_lay = QVBoxLayout(self)
self.v_lay.setContentsMargins(-1, 8, -1, 8)
self.v_lay.setSpacing(0)
self.row1 = QHBoxLayout()
self.row1.setSpacing(8)
self.enabled_checkbox = QCheckBox(self)
self.enabled_checkbox.setChecked(True)
self.enabled_checkbox.setDisabled(True)
self.enabled_checkbox.setToolTip(trans._("enable/disable"))
sizePolicy = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.enabled_checkbox.sizePolicy().hasHeightForWidth())
self.enabled_checkbox.setSizePolicy(sizePolicy)
self.enabled_checkbox.setMinimumSize(QSize(20, 0))
self.enabled_checkbox.setText("")
self.row1.addWidget(self.enabled_checkbox)
self.plugin_name = QLabel(self)
sizePolicy = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Minimum)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.plugin_name.sizePolicy().hasHeightForWidth())
self.plugin_name.setSizePolicy(sizePolicy)
font16 = QFont()
font16.setPointSize(16)
self.plugin_name.setFont(font16)
self.row1.addWidget(self.plugin_name)
self.package_name = QLabel(self)
self.package_name.setAlignment(Qt.AlignRight | Qt.AlignTrailing
| Qt.AlignVCenter)
self.row1.addWidget(self.package_name)
self.action_button = QPushButton(self)
sizePolicy = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.action_button.sizePolicy().hasHeightForWidth())
self.action_button.setSizePolicy(sizePolicy)
self.row1.addWidget(self.action_button)
self.v_lay.addLayout(self.row1)
self.row2 = QHBoxLayout()
self.error_indicator = QPushButton()
self.error_indicator.setObjectName("warning_icon")
self.error_indicator.setCursor(Qt.PointingHandCursor)
self.error_indicator.hide()
self.row2.addWidget(self.error_indicator)
self.row2.setContentsMargins(-1, 4, 0, -1)
self.summary = ElidingLabel(parent=self)
sizePolicy = QSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.summary.sizePolicy().hasHeightForWidth())
self.summary.setSizePolicy(sizePolicy)
self.summary.setObjectName("small_text")
self.row2.addWidget(self.summary)
self.package_author = QLabel(self)
sizePolicy = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.package_author.sizePolicy().hasHeightForWidth())
self.package_author.setSizePolicy(sizePolicy)
self.package_author.setObjectName("small_text")
self.row2.addWidget(self.package_author)
self.v_lay.addLayout(self.row2)
class LegendPropertiesWindow(PyDialog):
"""
+-------------------+
| Legend Properties |
+-----------------------+
| Title ______ Default |
| Min ______ Default |
| Max ______ Default |
| Format ______ Default |
| Scale ______ Default |
| Phase ______ Default |
| Number of Colors ____ |
| Number of Labels ____ |
| Label Size ____ | (TODO)
| ColorMap ____ | (TODO)
| |
| x Min/Max (Blue->Red) |
| o Max/Min (Red->Blue) |
| |
| x Vertical/Horizontal |
| x Show/Hide |
| |
| Animate |
| Apply OK Cancel |
+-----------------------+
"""
def __init__(self, data, win_parent=None):
PyDialog.__init__(self, data, win_parent)
self._updated_legend = False
self._animation_window_shown = False
self._icase = data['icase']
self._default_icase = self._icase
self._default_name = data['name']
self._default_min = data['min']
self._default_max = data['max']
self._default_scale = data['default_scale']
self._scale = data['scale']
self._default_phase = data['default_phase']
self._phase = data['phase']
self._default_format = data['default_format']
self._format = data['format']
self._default_labelsize = data['default_labelsize']
self._labelsize = data['labelsize']
self._default_nlabels = data['default_nlabels']
self._nlabels = data['nlabels']
self._default_ncolors = data['default_ncolors']
self._ncolors = data['ncolors']
self._default_colormap = data['default_colormap']
self._colormap = data['colormap']
self._default_is_low_to_high = data['is_low_to_high']
self._default_is_discrete = data['is_discrete']
self._default_is_horizontal = data['is_horizontal']
self._default_is_shown = data['is_shown']
self._is_normals = data['is_normals']
self._update_defaults_to_blank()
#self.setupUi(self)
self.setWindowTitle('Legend Properties')
self.create_widgets()
self.create_layout()
self.set_connections()
self.set_font_size(data['font_size'])
def _update_defaults_to_blank(self):
"""Changes the default (None) to a blank string"""
if self._default_colormap is None:
self._default_colormap = 'jet'
if self._default_labelsize is None:
self._default_labelsize = ''
if self._default_ncolors is None:
self._default_ncolors = ''
if self._default_nlabels is None:
self._default_nlabels = ''
if self._colormap is None:
self._colormap = 'jet'
if self._labelsize is None:
self._labelsize = ''
if self._ncolors is None:
self._ncolors = ''
if self._nlabels is None:
self._nlabels = ''
def update_legend(self,
icase,
name,
min_value,
max_value,
data_format,
scale,
phase,
nlabels,
labelsize,
ncolors,
colormap,
default_title,
default_min_value,
default_max_value,
default_data_format,
default_scale,
default_phase,
default_nlabels,
default_labelsize,
default_ncolors,
default_colormap,
is_low_to_high,
is_horizontal_scalar_bar,
is_normals,
font_size=8):
"""
We need to update the legend if there's been a result change request
"""
self.set_font_size(font_size)
if icase != self._default_icase:
self._icase = icase
self._default_icase = icase
self._default_name = default_title
self._default_min = default_min_value
self._default_max = default_max_value
self._default_format = default_data_format
self._default_is_low_to_high = is_low_to_high
self._default_is_discrete = True
self._default_is_horizontal = is_horizontal_scalar_bar
self._default_scale = default_scale
self._default_phase = default_phase
self._default_nlabels = default_nlabels
self._default_labelsize = default_labelsize
self._default_ncolors = default_ncolors
self._default_colormap = default_colormap
self._is_normals = is_normals
if colormap is None:
colormap = 'jet'
if labelsize is None:
labelsize = ''
if ncolors is None:
ncolors = ''
if nlabels is None:
nlabels = ''
self._update_defaults_to_blank()
assert isinstance(scale, float), 'scale=%r' % scale
assert isinstance(default_scale,
float), 'default_scale=%r' % default_scale
if self._default_scale == 0.0:
self.scale.setEnabled(False)
self.scale_edit.setEnabled(False)
self.scale_button.setEnabled(False)
else:
self.scale.setEnabled(True)
self.scale_edit.setEnabled(True)
self.scale_button.setEnabled(True)
if self._default_phase is None:
self._phase = None
self.phase.setEnabled(False)
self.phase_edit.setEnabled(False)
self.phase_button.setEnabled(False)
self.phase_edit.setText('0.0')
self.phase_edit.setStyleSheet("QLineEdit{background: white;}")
else:
self._phase = phase
self.phase.setEnabled(True)
self.phase_edit.setEnabled(True)
self.phase_button.setEnabled(True)
self.phase_edit.setText(str(phase))
self.phase_edit.setStyleSheet("QLineEdit{background: white;}")
#self.on_default_name()
#self.on_default_min()
#self.on_default_max()
#self.on_default_format()
#self.on_default_scale()
# reset defaults
self._name = name
self.name_edit.setText(name)
self.name_edit.setStyleSheet("QLineEdit{background: white;}")
self.min_edit.setText(str(min_value))
self.min_edit.setStyleSheet("QLineEdit{background: white;}")
self.max_edit.setText(str(max_value))
self.max_edit.setStyleSheet("QLineEdit{background: white;}")
self.format_edit.setText(str(data_format))
self.format_edit.setStyleSheet("QLineEdit{background: white;}")
self._scale = scale
self.scale_edit.setText(str(scale))
self.scale_edit.setStyleSheet("QLineEdit{background: white;}")
self.nlabels_edit.setText(str(nlabels))
self.nlabels_edit.setStyleSheet("QLineEdit{background: white;}")
self.labelsize_edit.setText(str(labelsize))
self.labelsize_edit.setStyleSheet("QLineEdit{background: white;}")
self.ncolors_edit.setText(str(ncolors))
self.ncolors_edit.setStyleSheet("QLineEdit{background: white;}")
self.colormap_edit.setCurrentIndex(
colormap_keys.index(str(colormap)))
# lots of hacking for the Normal vectors
enable = True
if self._is_normals:
enable = False
self.max.setVisible(enable)
self.min.setVisible(enable)
self.max_edit.setVisible(enable)
self.min_edit.setVisible(enable)
self.max_button.setVisible(enable)
self.min_button.setVisible(enable)
self.show_radio.setVisible(enable)
self.hide_radio.setVisible(enable)
self.low_to_high_radio.setVisible(enable)
self.high_to_low_radio.setVisible(enable)
self.format.setVisible(enable)
self.format_edit.setVisible(enable)
self.format_edit.setVisible(enable)
self.format_button.setVisible(enable)
self.nlabels.setVisible(enable)
self.nlabels_edit.setVisible(enable)
self.nlabels_button.setVisible(enable)
self.ncolors.setVisible(enable)
self.ncolors_edit.setVisible(enable)
self.ncolors_button.setVisible(enable)
self.grid2_title.setVisible(enable)
self.vertical_radio.setVisible(enable)
self.horizontal_radio.setVisible(enable)
self.colormap.setVisible(enable)
self.colormap_edit.setVisible(enable)
self.colormap_button.setVisible(enable)
self.on_apply()
def create_widgets(self):
"""creates the menu objects"""
# Name
self.name = QLabel("Title:")
self.name_edit = QLineEdit(str(self._default_name))
self.name_button = QPushButton("Default")
# Min
self.min = QLabel("Min:")
self.min_edit = QLineEdit(str(self._default_min))
self.min_button = QPushButton("Default")
# Max
self.max = QLabel("Max:")
self.max_edit = QLineEdit(str(self._default_max))
self.max_button = QPushButton("Default")
#---------------------------------------
# Format
self.format = QLabel("Format (e.g. %.3f, %g, %.6e):")
self.format_edit = QLineEdit(str(self._format))
self.format_button = QPushButton("Default")
#---------------------------------------
# Scale
self.scale = QLabel("Scale:")
self.scale_edit = QLineEdit(str(self._scale))
self.scale_button = QPushButton("Default")
if self._default_scale == 0.0:
self.scale.setVisible(False)
self.scale_edit.setVisible(False)
self.scale_button.setVisible(False)
# Phase
self.phase = QLabel("Phase (deg):")
self.phase_edit = QLineEdit(str(self._phase))
self.phase_button = QPushButton("Default")
if self._default_phase is None:
self.phase.setVisible(False)
self.phase_edit.setVisible(False)
self.phase_button.setVisible(False)
self.phase_edit.setText('0.0')
#tip = QtGui.QToolTip()
#tip.setTe
#self.format_edit.toolTip(tip)
#---------------------------------------
# nlabels
self.nlabels = QLabel("Number of Labels:")
self.nlabels_edit = QLineEdit(str(self._nlabels))
self.nlabels_button = QPushButton("Default")
self.labelsize = QLabel("Label Size:")
self.labelsize_edit = QLineEdit(str(self._labelsize))
self.labelsize_button = QPushButton("Default")
self.ncolors = QLabel("Number of Colors:")
self.ncolors_edit = QLineEdit(str(self._ncolors))
self.ncolors_button = QPushButton("Default")
self.colormap = QLabel("Color Map:")
self.colormap_edit = QComboBox(self)
self.colormap_button = QPushButton("Default")
for key in colormap_keys:
self.colormap_edit.addItem(key)
self.colormap_edit.setCurrentIndex(colormap_keys.index(self._colormap))
# --------------------------------------------------------------
# the header
self.grid2_title = QLabel("Color Scale:")
# red/blue or blue/red
self.low_to_high_radio = QRadioButton('Low -> High')
self.high_to_low_radio = QRadioButton('High -> Low')
widget = QWidget(self)
low_to_high_group = QButtonGroup(widget)
low_to_high_group.addButton(self.low_to_high_radio)
low_to_high_group.addButton(self.high_to_low_radio)
self.low_to_high_radio.setChecked(self._default_is_low_to_high)
self.high_to_low_radio.setChecked(not self._default_is_low_to_high)
# horizontal / vertical
self.horizontal_radio = QRadioButton("Horizontal")
self.vertical_radio = QRadioButton("Vertical")
widget = QWidget(self)
horizontal_vertical_group = QButtonGroup(widget)
horizontal_vertical_group.addButton(self.horizontal_radio)
horizontal_vertical_group.addButton(self.vertical_radio)
self.horizontal_radio.setChecked(self._default_is_horizontal)
self.vertical_radio.setChecked(not self._default_is_horizontal)
# on / off
self.show_radio = QRadioButton("Show")
self.hide_radio = QRadioButton("Hide")
widget = QWidget(self)
show_hide_group = QButtonGroup(widget)
show_hide_group.addButton(self.show_radio)
show_hide_group.addButton(self.hide_radio)
self.show_radio.setChecked(self._default_is_shown)
self.hide_radio.setChecked(not self._default_is_shown)
# --------------------------------------------------------------
if self._is_normals:
self.max.hide()
self.min.hide()
self.max_edit.hide()
self.min_edit.hide()
self.max_button.hide()
self.min_button.hide()
self.format.hide()
self.format_edit.hide()
self.format_button.hide()
self.nlabels.hide()
self.nlabels_edit.hide()
self.nlabels_button.hide()
self.ncolors.hide()
self.ncolors_edit.hide()
self.ncolors_button.hide()
self.grid2_title.hide()
self.vertical_radio.hide()
self.horizontal_radio.hide()
self.show_radio.hide()
self.hide_radio.hide()
self.low_to_high_radio.hide()
self.high_to_low_radio.hide()
self.colormap.hide()
self.colormap_edit.hide()
self.colormap_button.hide()
self.animate_button = QPushButton('Create Animation')
if self._default_scale == 0.0:
self.animate_button.setEnabled(False)
self.animate_button.setToolTip(
'This must be a displacement-like result to animate')
# closing
self.apply_button = QPushButton("Apply")
self.ok_button = QPushButton("OK")
self.cancel_button = QPushButton("Cancel")
def create_layout(self):
"""displays the menu objects"""
grid = QGridLayout()
grid.addWidget(self.name, 0, 0)
grid.addWidget(self.name_edit, 0, 1)
grid.addWidget(self.name_button, 0, 2)
grid.addWidget(self.min, 1, 0)
grid.addWidget(self.min_edit, 1, 1)
grid.addWidget(self.min_button, 1, 2)
grid.addWidget(self.max, 2, 0)
grid.addWidget(self.max_edit, 2, 1)
grid.addWidget(self.max_button, 2, 2)
grid.addWidget(self.format, 3, 0)
grid.addWidget(self.format_edit, 3, 1)
grid.addWidget(self.format_button, 3, 2)
grid.addWidget(self.scale, 4, 0)
grid.addWidget(self.scale_edit, 4, 1)
grid.addWidget(self.scale_button, 4, 2)
grid.addWidget(self.phase, 5, 0)
grid.addWidget(self.phase_edit, 5, 1)
grid.addWidget(self.phase_button, 5, 2)
grid.addWidget(self.nlabels, 6, 0)
grid.addWidget(self.nlabels_edit, 6, 1)
grid.addWidget(self.nlabels_button, 6, 2)
#grid.addWidget(self.labelsize, 6, 0)
#grid.addWidget(self.labelsize_edit, 6, 1)
#grid.addWidget(self.labelsize_button, 6, 2)
grid.addWidget(self.ncolors, 7, 0)
grid.addWidget(self.ncolors_edit, 7, 1)
grid.addWidget(self.ncolors_button, 7, 2)
grid.addWidget(self.colormap, 8, 0)
grid.addWidget(self.colormap_edit, 8, 1)
grid.addWidget(self.colormap_button, 8, 2)
ok_cancel_box = QHBoxLayout()
ok_cancel_box.addWidget(self.apply_button)
ok_cancel_box.addWidget(self.ok_button)
ok_cancel_box.addWidget(self.cancel_button)
grid2 = QGridLayout()
grid2.addWidget(self.grid2_title, 0, 0)
grid2.addWidget(self.low_to_high_radio, 1, 0)
grid2.addWidget(self.high_to_low_radio, 2, 0)
grid2.addWidget(self.vertical_radio, 1, 1)
grid2.addWidget(self.horizontal_radio, 2, 1)
grid2.addWidget(self.show_radio, 1, 2)
grid2.addWidget(self.hide_radio, 2, 2)
grid2.addWidget(self.animate_button, 3, 1)
#grid2.setSpacing(0)
vbox = QVBoxLayout()
vbox.addLayout(grid)
#vbox.addLayout(checkboxes)
vbox.addLayout(grid2)
vbox.addStretch()
vbox.addLayout(ok_cancel_box)
#Create central widget, add layout and set
#central_widget = QtGui.QWidget()
#central_widget.setLayout(vbox)
#self.setCentralWidget(central_widget)
self.setLayout(vbox)
def set_connections(self):
"""creates the actions for the buttons"""
self.name_button.clicked.connect(self.on_default_name)
self.min_button.clicked.connect(self.on_default_min)
self.max_button.clicked.connect(self.on_default_max)
self.format_button.clicked.connect(self.on_default_format)
self.scale_button.clicked.connect(self.on_default_scale)
self.phase_button.clicked.connect(self.on_default_phase)
self.nlabels_button.clicked.connect(self.on_default_nlabels)
self.labelsize_button.clicked.connect(self.on_default_labelsize)
self.ncolors_button.clicked.connect(self.on_default_ncolors)
self.colormap_button.clicked.connect(self.on_default_colormap)
self.animate_button.clicked.connect(self.on_animate)
self.show_radio.clicked.connect(self.on_show_hide)
self.hide_radio.clicked.connect(self.on_show_hide)
self.apply_button.clicked.connect(self.on_apply)
self.ok_button.clicked.connect(self.on_ok)
self.cancel_button.clicked.connect(self.on_cancel)
if qt_version == 4:
self.connect(self, QtCore.SIGNAL('triggered()'), self.closeEvent)
#self.colormap_edit.activated[str].connect(self.onActivated)
#else:
# closeEvent???
def set_font_size(self, font_size):
"""
Updates the font size of the objects
Parameters
----------
font_size : int
the font size
"""
if self.font_size == font_size:
return
self.font_size = font_size
font = QFont()
font.setPointSize(font_size)
self.setFont(font)
self.name_edit.setFont(font)
self.min_edit.setFont(font)
self.max_edit.setFont(font)
self.format_edit.setFont(font)
self.scale_edit.setFont(font)
self.phase_edit.setFont(font)
self.nlabels_edit.setFont(font)
self.labelsize_edit.setFont(font)
self.ncolors_edit.setFont(font)
def on_animate(self):
"""opens the animation window"""
name, flag0 = self.check_name(self.name_edit)
if not flag0:
return
scale, flag1 = self.check_float(self.scale_edit)
if not flag1:
scale = self._scale
data = {
'font_size': self.out_data['font_size'],
'icase': self._icase,
'name': name,
'time': 2,
'frames/sec': 30,
'resolution': 1,
'iframe': 0,
'scale': scale,
'default_scale': self._default_scale,
'is_scale': self._default_phase is None,
'phase': self._phase,
'default_phase': self._default_phase,
'dirname': os.path.abspath(os.getcwd()),
'clicked_ok': False,
'close': False,
}
if not self._animation_window_shown:
self._animation_window = AnimationWindow(data, win_parent=self)
self._animation_window.show()
self._animation_window_shown = True
self._animation_window.exec_()
else:
self._animation_window.activateWindow()
if data['close']:
if not self._animation_window._updated_animation:
#self._apply_animation(data)
pass
self._animation_window_shown = False
del self._animation_window
else:
self._animation_window.activateWindow()
def on_default_name(self):
"""action when user clicks 'Default' for name"""
name = str(self._default_name)
self.name_edit.setText(name)
self.name_edit.setStyleSheet("QLineEdit{background: white;}")
def on_default_min(self):
"""action when user clicks 'Default' for min value"""
self.min_edit.setText(str(self._default_min))
self.min_edit.setStyleSheet("QLineEdit{background: white;}")
def on_default_max(self):
"""action when user clicks 'Default' for max value"""
self.max_edit.setText(str(self._default_max))
self.max_edit.setStyleSheet("QLineEdit{background: white;}")
def on_default_format(self):
"""action when user clicks 'Default' for the number format"""
self.format_edit.setText(str(self._default_format))
self.format_edit.setStyleSheet("QLineEdit{background: white;}")
def on_default_scale(self):
"""action when user clicks 'Default' for scale factor"""
self.scale_edit.setText(str(self._default_scale))
self.scale_edit.setStyleSheet("QLineEdit{background: white;}")
def on_default_phase(self):
"""action when user clicks 'Default' for phase angle"""
self.phase_edit.setText(str(self._default_phase))
self.phase_edit.setStyleSheet("QLineEdit{background: white;}")
def on_default_ncolors(self):
"""action when user clicks 'Default' for number of colors"""
self.ncolors_edit.setText(str(self._default_ncolors))
self.ncolors_edit.setStyleSheet("QLineEdit{background: white;}")
def on_default_colormap(self):
"""action when user clicks 'Default' for the color map"""
self.colormap_edit.setCurrentIndex(
colormap_keys.index(self._default_colormap))
def on_default_nlabels(self):
"""action when user clicks 'Default' for number of labels"""
self.nlabels_edit.setStyleSheet("QLineEdit{background: white;}")
self.nlabels_edit.setText(str(self._default_nlabels))
def on_default_labelsize(self):
"""action when user clicks 'Default' for number of labelsize"""
self.labelsize_edit.setText(str(self._default_labelsize))
self.labelsize_edit.setStyleSheet("QLineEdit{background: white;}")
def on_show_hide(self):
"""action when user clicks the 'Show/Hide' radio button"""
self.colormap_edit.setCurrentIndex(
colormap_keys.index(self._default_colormap))
is_shown = self.show_radio.isChecked()
self.vertical_radio.setEnabled(is_shown)
self.horizontal_radio.setEnabled(is_shown)
@staticmethod
def check_name(cell):
cell_value = cell.text()
try:
text = str(cell_value).strip()
except UnicodeEncodeError:
cell.setStyleSheet("QLineEdit{background: red;}")
return None, False
if len(text):
cell.setStyleSheet("QLineEdit{background: white;}")
return text, True
else:
cell.setStyleSheet("QLineEdit{background: red;}")
return None, False
@staticmethod
def check_colormap(cell):
text = str(cell.text()).strip()
if text in colormap_keys:
cell.setStyleSheet("QLineEdit{background: white;}")
return text, True
else:
cell.setStyleSheet("QLineEdit{background: red;}")
return None, False
def on_validate(self):
name_value, flag0 = self.check_name(self.name_edit)
min_value, flag1 = self.check_float(self.min_edit)
max_value, flag2 = self.check_float(self.max_edit)
format_value, flag3 = self.check_format(self.format_edit)
scale, flag4 = self.check_float(self.scale_edit)
phase, flag5 = self.check_float(self.phase_edit)
nlabels, flag6 = self.check_positive_int_or_blank(self.nlabels_edit)
ncolors, flag7 = self.check_positive_int_or_blank(self.ncolors_edit)
labelsize, flag8 = self.check_positive_int_or_blank(
self.labelsize_edit)
colormap = str(self.colormap_edit.currentText())
if all([flag0, flag1, flag2, flag3, flag4, flag5, flag6, flag7,
flag8]):
if 'i' in format_value:
format_value = '%i'
assert isinstance(scale, float), scale
self.out_data['name'] = name_value
self.out_data['min'] = min_value
self.out_data['max'] = max_value
self.out_data['format'] = format_value
self.out_data['scale'] = scale
self.out_data['phase'] = phase
self.out_data['nlabels'] = nlabels
self.out_data['ncolors'] = ncolors
self.out_data['labelsize'] = labelsize
self.out_data['colormap'] = colormap
self.out_data['is_low_to_high'] = self.low_to_high_radio.isChecked(
)
self.out_data['is_horizontal'] = self.horizontal_radio.isChecked()
self.out_data['is_shown'] = self.show_radio.isChecked()
self.out_data['clicked_ok'] = True
self.out_data['close'] = True
#print('self.out_data = ', self.out_data)
#print("name = %r" % self.name_edit.text())
#print("min = %r" % self.min_edit.text())
#print("max = %r" % self.max_edit.text())
#print("format = %r" % self.format_edit.text())
return True
return False
def on_apply(self):
passed = self.on_validate()
if passed:
self.win_parent._apply_legend(self.out_data)
return passed
def on_ok(self):
passed = self.on_apply()
if passed:
self.close()
#self.destroy()
def on_cancel(self):
self.out_data['close'] = True
self.close()
class MainMenu(BaseMainMenu):
def __init__(self, settings: PartSettings, main_window):
super().__init__(settings, main_window)
self.settings = settings
self.open_btn = QPushButton("Open")
self.save_btn = QPushButton("Save")
self.advanced_btn = QPushButton("Settings and Measurement")
self.mask_manager_btn = QPushButton("Mask manager")
self.batch_processing_btn = QPushButton("Batch Processing")
layout = QHBoxLayout()
# layout.setSpacing(0)
layout.setContentsMargins(0, 0, 4, 4)
layout.addWidget(self.open_btn)
layout.addWidget(self.save_btn)
layout.addWidget(self.advanced_btn)
layout.addWidget(self.mask_manager_btn)
layout.addWidget(self.batch_processing_btn)
self.setLayout(layout)
self.open_btn.clicked.connect(self.load_data)
self.save_btn.clicked.connect(self.save_file)
self.advanced_btn.clicked.connect(self.advanced_window_show)
self.mask_manager_btn.clicked.connect(self.mask_manager)
self.batch_processing_btn.clicked.connect(self.batch_window)
self.setFocusPolicy(Qt.StrongFocus)
# self.test_btn.clicked.connect(self.test_fun)
def resizeEvent(self, event: QResizeEvent):
if event.size().width() < 800:
self.batch_processing_btn.hide()
else:
self.batch_processing_btn.show()
def keyPressEvent(self, event: QKeyEvent):
if event.matches(QKeySequence.Save):
self.save_file()
elif event.matches(QKeySequence.Open):
self.load_data()
super().keyPressEvent(event)
def save_file(self):
base_values = self.settings.get("save_parameters", dict())
dial = SaveDialog(
save_dict, system_widget=False, base_values=base_values, history=self.settings.get_path_history()
)
dial.selectFile(os.path.splitext(os.path.basename(self.settings.image_path))[0])
dial.setDirectory(
self.settings.get("io.save_directory", self.settings.get("io.open_directory", str(Path.home())))
)
dial.selectNameFilter(self.settings.get("io.save_filter", ""))
if dial.exec():
save_location, selected_filter, save_class, values = dial.get_result()
project_info = self.settings.get_project_info()
self.settings.set("io.save_filter", selected_filter)
save_dir = os.path.dirname(save_location)
self.settings.set("io.save_directory", save_dir)
self.settings.add_path_history(save_dir)
base_values[selected_filter] = values
def exception_hook(exception):
from qtpy.QtCore import QMetaObject
from qtpy.QtWidgets import QApplication
instance = QApplication.instance()
if isinstance(exception, ValueError):
instance.warning = "Save error", f"Error during saving\n{exception}"
QMetaObject.invokeMethod(instance, "show_warning", Qt.QueuedConnection)
else:
raise exception
dial2 = ExecuteFunctionDialog(
save_class.save, [save_location, project_info, values], exception_hook=exception_hook
)
dial2.exec()
def mask_manager(self):
if self.settings.segmentation is None:
QMessageBox.information(self, "No segmentation", "Cannot create mask without segmentation")
return
dial = MaskDialog(self.settings)
dial.exec_()
def load_data(self):
def exception_hook(exception):
from qtpy.QtCore import QMetaObject
from qtpy.QtWidgets import QApplication
instance = QApplication.instance()
if isinstance(exception, ValueError) and exception.args[0] == "Incompatible shape of mask and image":
instance.warning = (
"Open error",
"Most probably you try to load mask from other image. " "Check selected files",
)
QMetaObject.invokeMethod(instance, "show_warning", Qt.QueuedConnection)
elif isinstance(exception, MemoryError):
instance.warning = "Open error", f"Not enough memory to read this image: {exception}"
QMetaObject.invokeMethod(instance, "show_warning", Qt.QueuedConnection)
elif isinstance(exception, IOError):
instance.warning = "Open error", f"Some problem with reading from disc: {exception}"
QMetaObject.invokeMethod(instance, "show_warning", Qt.QueuedConnection)
elif isinstance(exception, KeyError):
instance.warning = "Open error", f"Some problem project file: {exception}"
QMetaObject.invokeMethod(instance, "show_warning", Qt.QueuedConnection)
print(exception, file=sys.stderr)
elif isinstance(exception, WrongFileTypeException):
instance.warning = (
"Open error",
"No needed files inside archive. Most probably you choose file from segmentation mask",
)
QMetaObject.invokeMethod(instance, "show_warning", Qt.QueuedConnection)
else:
raise exception
try:
dial = CustomLoadDialog(load_functions.load_dict, history=self.settings.get_path_history())
dial.setDirectory(self.settings.get("io.open_directory", str(Path.home())))
dial.selectNameFilter(self.settings.get("io.open_filter", next(iter(load_functions.load_dict.keys()))))
if dial.exec_():
result = dial.get_result()
self.settings.set("io.open_filter", result.selected_filter)
load_dir = os.path.dirname(result.load_location[0])
self.settings.set("io.open_directory", load_dir)
self.settings.add_path_history(load_dir)
dial2 = ExecuteFunctionDialog(
result.load_class.load,
[result.load_location],
{"metadata": {"default_spacing": self.settings.image_spacing}},
exception_hook=exception_hook,
)
if dial2.exec():
result = dial2.get_result()
self.set_data(result)
except ValueError as e:
QMessageBox.warning(self, "Open error", "{}".format(e))
def batch_window(self):
if self.main_window.batch_window is not None:
if self.main_window.batch_window.isVisible():
self.main_window.batch_window.activateWindow()
else:
self.main_window.batch_window.show()
else:
self.main_window.batch_window = BatchWindow(self.settings)
self.main_window.batch_window.show()
def advanced_window_show(self):
if self.main_window.advanced_window.isVisible():
self.main_window.advanced_window.activateWindow()
else:
self.main_window.advanced_window.show()
class SpyderErrorDialog(QDialog):
"""Custom error dialog for error reporting."""
def __init__(self, parent=None, is_report=False):
QDialog.__init__(self, parent)
self.is_report = is_report
# Set to true to run tests on the dialog. This is the default
# in the test function at the end of this file.
self._testing = False
self.setWindowTitle(_("Issue reporter"))
self._github_org = 'spyder-ide'
self._github_repo = 'spyder'
# To save the traceback sent to the internal console
self.error_traceback = ""
# Dialog main label
if self.is_report:
title = _("Please fill the following information")
else:
title = _("Spyder has encountered an internal problem!")
self.main_label = QLabel(
_("<h3>{title}</h3>"
"Before reporting this problem, <i>please</i> consult our "
"comprehensive "
"<b><a href=\"{trouble_url}\">Troubleshooting Guide</a></b> "
"which should help solve most issues, and search for "
"<b><a href=\"{project_url}\">known bugs</a></b> "
"matching your error message or problem description for a "
"quicker solution.").format(title=title,
trouble_url=__trouble_url__,
project_url=__project_url__))
self.main_label.setOpenExternalLinks(True)
self.main_label.setWordWrap(True)
self.main_label.setAlignment(Qt.AlignJustify)
self.main_label.setStyleSheet('font-size: 12px;')
# Issue title
self.title = QLineEdit()
self.title.textChanged.connect(self._contents_changed)
self.title_chars_label = QLabel(
_("{} more characters "
"to go...").format(TITLE_MIN_CHARS))
form_layout = QFormLayout()
form_layout.setFieldGrowthPolicy(QFormLayout.ExpandingFieldsGrow)
red_asterisk = '<font color="Red">*</font>'
title_label = QLabel(_("<b>Title</b>: {}").format(red_asterisk))
form_layout.setWidget(0, QFormLayout.LabelRole, title_label)
form_layout.setWidget(0, QFormLayout.FieldRole, self.title)
# Description
steps_header = QLabel(
_("<b>Steps to reproduce:</b> {}").format(red_asterisk))
self.steps_text = QLabel(
_("Please enter a detailed step-by-step "
"description (in English) of what led up to "
"the problem below. Issue reports without a "
"clear way to reproduce them will be closed."))
self.steps_text.setWordWrap(True)
self.steps_text.setAlignment(Qt.AlignJustify)
self.steps_text.setStyleSheet('font-size: 12px;')
# Field to input the description of the problem
self.input_description = DescriptionWidget(self)
# Only allow to submit to Github if we have a long enough description
self.input_description.textChanged.connect(self._contents_changed)
# Widget to show errors
self.details = ShowErrorWidget(self)
self.details.set_pythonshell_font(get_font())
self.details.hide()
self.description_minimum_length = DESC_MIN_CHARS
self.require_minimum_length = True
# Label to show missing chars
self.initial_chars = len(self.input_description.toPlainText())
self.desc_chars_label = QLabel(
_("{} more characters "
"to go...").format(self.description_minimum_length))
# Checkbox to dismiss future errors
self.dismiss_box = QCheckBox(
_("Hide all future errors during this "
"session"))
if self.is_report:
self.dismiss_box.hide()
# Dialog buttons
gh_icon = ima.icon('github')
self.submit_btn = QPushButton(gh_icon, _('Submit to Github'))
self.submit_btn.setEnabled(False)
self.submit_btn.clicked.connect(self._submit_to_github)
self.details_btn = QPushButton(_('Show details'))
self.details_btn.clicked.connect(self._show_details)
if self.is_report:
self.details_btn.hide()
self.close_btn = QPushButton(_('Close'))
if self.is_report:
self.close_btn.clicked.connect(self.reject)
# Buttons layout
buttons_layout = QHBoxLayout()
buttons_layout.addWidget(self.submit_btn)
buttons_layout.addWidget(self.details_btn)
buttons_layout.addWidget(self.close_btn)
# Main layout
layout = QVBoxLayout()
layout.addWidget(self.main_label)
layout.addSpacing(20)
layout.addLayout(form_layout)
layout.addWidget(self.title_chars_label)
layout.addSpacing(12)
layout.addWidget(steps_header)
layout.addSpacing(-1)
layout.addWidget(self.steps_text)
layout.addSpacing(1)
layout.addWidget(self.input_description)
layout.addWidget(self.details)
layout.addWidget(self.desc_chars_label)
layout.addSpacing(15)
layout.addWidget(self.dismiss_box)
layout.addSpacing(15)
layout.addLayout(buttons_layout)
layout.setContentsMargins(25, 20, 25, 10)
self.setLayout(layout)
self.resize(570, 600)
self.title.setFocus()
# Set Tab key focus order
self.setTabOrder(self.title, self.input_description)
@staticmethod
def render_issue(description='', traceback=''):
"""
Render issue content.
Parameters
----------
description: str
Description to include in issue message.
traceback: str
Traceback text.
"""
# Get component versions
versions = get_versions()
# Get dependencies if they haven't beed computed yet.
if not dependencies.DEPENDENCIES:
try:
dependencies.declare_dependencies()
except ValueError:
pass
# Get git revision for development version
revision = ''
if versions['revision']:
revision = versions['revision']
# Make a description header in case no description is supplied
if not description:
description = "### What steps reproduce the problem?"
# Make error section from traceback and add appropriate reminder header
if traceback:
error_section = ("### Traceback\n"
"```python-traceback\n"
"{}\n"
"```".format(traceback))
else:
error_section = ''
issue_template = """\
## Description
{description}
{error_section}
## Versions
* Spyder version: {spyder_version} {commit}
* Python version: {python_version}
* Qt version: {qt_version}
* {qt_api_name} version: {qt_api_version}
* Operating System: {os_name} {os_version}
### Dependencies
```
{dependencies}
```
""".format(description=description,
error_section=error_section,
spyder_version=versions['spyder'],
commit=revision,
python_version=versions['python'],
qt_version=versions['qt'],
qt_api_name=versions['qt_api'],
qt_api_version=versions['qt_api_ver'],
os_name=versions['system'],
os_version=versions['release'],
dependencies=dependencies.status())
return issue_template
@staticmethod
def open_web_report(body, title=None):
"""
Open a new issue on Github with prefilled information.
Parameters
----------
body: str
The body content of the report.
title: str or None, optional
The title of the report. Default is None.
"""
url = QUrl(__project_url__ + '/issues/new')
query = QUrlQuery()
query.addQueryItem("body", quote(body))
if title:
query.addQueryItem("title", quote(title))
url.setQuery(query)
QDesktopServices.openUrl(url)
def set_require_minimum_length(self, state):
"""Remove the requirement for minimum length."""
self.require_minimum_length = state
if state:
self._contents_changed()
else:
self.desc_chars_label.setText('')
def set_github_repo_org(self, repo_fullname):
"""Set the report Github organization and repository."""
org, repo = repo_fullname.split('/')
self._github_org = org
self._github_repo = repo
def _submit_to_github(self):
"""Action to take when pressing the submit button."""
# Getting description and traceback
title = self.title.text()
description = self.input_description.toPlainText()
traceback = self.error_traceback[:-1] # Remove last EOL
# Render issue
issue_text = self.render_issue(description=description,
traceback=traceback)
try:
org = self._github_org if not self._testing else 'ccordoba12'
repo = self._github_repo
github_backend = GithubBackend(org, repo, parent_widget=self)
github_report = github_backend.send_report(title, issue_text)
if github_report:
self.close()
except Exception:
ret = QMessageBox.question(
self,
_('Error'),
_("An error occurred while trying to send the issue to "
"Github automatically. Would you like to open it "
"manually?<br><br>"
"If so, please make sure to paste your clipboard "
"into the issue report box that will appear in a new "
"browser tab before clicking <i>Submit</i> on that "
"page."),
)
if ret in [QMessageBox.Yes, QMessageBox.Ok]:
QApplication.clipboard().setText(issue_text)
issue_body = (
" \n<!--- *** BEFORE SUBMITTING: PASTE CLIPBOARD HERE "
"TO COMPLETE YOUR REPORT *** ---!>\n")
self.open_web_report(body=issue_body, title=title)
def append_traceback(self, text):
"""Append text to the traceback, to be displayed in details."""
self.error_traceback += text
def _show_details(self):
"""Show traceback on its own dialog"""
if self.details.isVisible():
self.details.hide()
self.details_btn.setText(_('Show details'))
else:
self.resize(570, 700)
self.details.document().setPlainText('')
self.details.append_text_to_shell(self.error_traceback,
error=True,
prompt=False)
self.details.show()
self.details_btn.setText(_('Hide details'))
def _contents_changed(self):
"""Activate submit_btn."""
if not self.require_minimum_length:
return
desc_chars = (len(self.input_description.toPlainText()) -
self.initial_chars)
if desc_chars < self.description_minimum_length:
self.desc_chars_label.setText(u"{} {}".format(
self.description_minimum_length - desc_chars,
_("more characters to go...")))
else:
self.desc_chars_label.setText(_("Description complete; thanks!"))
title_chars = len(self.title.text())
if title_chars < TITLE_MIN_CHARS:
self.title_chars_label.setText(u"{} {}".format(
TITLE_MIN_CHARS - title_chars, _("more characters to go...")))
else:
self.title_chars_label.setText(_("Title complete; thanks!"))
submission_enabled = (desc_chars >= self.description_minimum_length
and title_chars >= TITLE_MIN_CHARS)
self.submit_btn.setEnabled(submission_enabled)
def set_title(self, title):
"""Set the title for the report."""
self.title.setText(title)
def set_description(self, description):
"""Set the description for the report."""
self.input_description.setPlainText(description)
def set_color_scheme(self, color_scheme):
"""Set the color scheme for the description input."""
self.input_description.set_color_scheme(color_scheme)
class AnimationWindow(PyDialog):
"""
+-------------------+
| Animation |
+-------------------------+
| icase ______ |
| scale ______ Default |
| time ______ Default |
| |
| nframes ______ Default |
| resolu. ______ Default |
| Dir ______ Browse |
| iFrame ______ |
| |
| Animations: |
| o Scale, Phase, Time |
| |
| x delete images |
| x repeat | # TODO: change to an integer
| x make gif |
| |
| Step, RunAll |
| Close |
+-------------------------+
TODO: add key-frame support
"""
def __init__(self, data, win_parent=None):
PyDialog.__init__(self, data, win_parent)
self.set_font_size(data['font_size'])
self.istep = 0
self._animate_type = 'time'
self._updated_animation = False
self._active_deformation = 0.
self._icase_fringe = data['icase_fringe']
self._icase_disp = data['icase_disp']
self._icase_vector = data['icase_vector']
self._default_name = data['name']
self._default_time = data['time']
self._default_fps = data['frames/sec']
self._default_resolution = data['resolution']
self._scale = data['scale']
self._default_scale = data['default_scale']
self._default_is_scale = data['is_scale']
self._arrow_scale = data['arrow_scale']
self._default_arrow_scale = data['default_arrow_scale']
self._phase = data['phase']
self._default_phase = data['default_phase']
self._default_dirname = data['dirname']
self._default_gif_name = os.path.join(self._default_dirname,
data['name'] + '.gif')
self.animation_types = [
'Animate Scale',
]
#'Animate Phase',
#'Animate Time',
#'Animate Frequency Sweep'
#]
self.setWindowTitle('Animate Model')
self.create_widgets()
self.create_layout()
self.set_connections()
self.is_gui = False
if hasattr(self.win_parent, '_updated_legend'):
self.win_parent.is_animate_open = True
self.is_gui = True
self.on_update_min_max_defaults()
def create_widgets(self):
"""creates the menu objects"""
self.box_scale = QGroupBox('Animate Scale')
self.box_time = QGroupBox('Animate Time')
icase_max = 1000 # TODO: update 1000
self.checkbox_fringe = QCheckBox('Animate')
self.checkbox_fringe.setToolTip(
'Animate the fringe in addition to the deflection')
#self.checkbox_disp = QCheckBox('Animate')
self.checkbox_fringe.setEnabled(False)
self.icase_fringe_label = QLabel("iCase (Fringe):")
self.icase_fringe_edit = QSpinBox(self)
self.icase_fringe_edit.setRange(0, icase_max)
self.icase_fringe_edit.setSingleStep(1)
if self._icase_fringe is not None:
self.icase_fringe_edit.setValue(self._icase_fringe)
self.icase_fringe_edit.setToolTip(
'Case Number for the Scale/Phase Animation Type.\n'
'Defaults to the result you had shown when you clicked "Create Animation".\n'
'iCase can be seen by clicking "Apply" on a result.')
self.icase_disp_label = QLabel("iCase (Disp):")
self.icase_disp_edit = QSpinBox(self)
self.icase_disp_edit.setRange(1, icase_max)
self.icase_disp_edit.setSingleStep(1)
if self._icase_disp is not None:
self.icase_disp_edit.setValue(self._icase_disp)
self.checkbox_vector = QCheckBox('Animate')
self.checkbox_vector.setToolTip(
'Animate the vector in addition to the deflection')
self.checkbox_vector.hide()
#self.checkbox_disp = QCheckBox('Animate')
self.icase_vector_label = QLabel("iCase (Vector):")
self.icase_vector_edit = QSpinBox(self)
self.icase_vector_edit.setRange(1, icase_max)
self.icase_vector_edit.setSingleStep(1)
if self._icase_vector is not None:
self.icase_vector_edit.setValue(self._icase_vector)
self.scale_label = QLabel("True Scale:")
self.scale_edit = QLineEdit(str(self._scale))
self.scale_button = QPushButton("Default")
self.scale_edit.setToolTip('Scale factor of the "deflection"')
self.scale_button.setToolTip('Sets the scale factor of the gif to %s' %
self._scale)
self.arrow_scale_label = QLabel("Arrow Scale:")
self.arrow_scale_edit = QLineEdit(str(self._scale))
self.arrow_scale_button = QPushButton("Default")
self.arrow_scale_edit.setToolTip('Scale factor of the "arrows"')
self.arrow_scale_button.setToolTip(
'Sets the arrow scale factor of the gif to %s' % self._arrow_scale)
self.arrow_scale_label.setVisible(False)
self.arrow_scale_edit.setVisible(False)
self.arrow_scale_button.setVisible(False)
self.time_label = QLabel("Total Time (sec):")
self.time_edit = QDoubleSpinBox(self)
self.time_edit.setValue(self._default_time)
self.time_edit.setRange(0.1, 5. * 60.)
self.time_edit.setDecimals(2)
self.time_edit.setSingleStep(0.1)
self.time_button = QPushButton("Default")
self.time_edit.setToolTip("Total time of the gif")
self.time_button.setToolTip('Sets the total time of the gif to %.2f' %
self._default_time)
self.fps_label = QLabel("Frames/Second:")
self.fps_edit = QSpinBox(self)
self.fps_edit.setRange(1, 60)
self.fps_edit.setSingleStep(1)
self.fps_edit.setValue(self._default_fps)
self.fps_button = QPushButton("Default")
self.fps_edit.setToolTip(
"A higher FPS is smoother, but may not play well for large gifs")
self.fps_button.setToolTip('Sets the FPS to %s' % self._default_fps)
self.resolution_label = QLabel("Resolution Scale:")
self.resolution_edit = QSpinBox(self)
self.resolution_edit.setRange(1, 5)
self.resolution_edit.setSingleStep(1)
self.resolution_edit.setValue(self._default_resolution)
self.resolution_button = QPushButton("Default")
self.resolution_edit.setToolTip(
'Scales the window resolution by an integer factor')
self.resolution_button.setToolTip('Sets the resolution to %s' %
self._default_resolution)
#-----------------
# Time plot
self.fringe_label = QLabel("Fringe")
self.icase_fringe_start_edit = QSpinBox(self)
self.icase_fringe_start_edit.setRange(0, icase_max)
self.icase_fringe_start_edit.setSingleStep(1)
self.icase_fringe_start_edit.setValue(self._icase_fringe)
self.icase_fringe_start_button = QPushButton("Default")
self.icase_fringe_end_edit = QSpinBox(self)
self.icase_fringe_end_edit.setRange(0, icase_max)
self.icase_fringe_end_edit.setSingleStep(1)
self.icase_fringe_end_edit.setValue(self._icase_fringe)
self.icase_fringe_end_button = QPushButton("Default")
self.icase_fringe_delta_edit = QSpinBox(self)
self.icase_fringe_delta_edit.setRange(1, icase_max)
self.icase_fringe_delta_edit.setSingleStep(1)
self.icase_fringe_delta_edit.setValue(1)
self.icase_fringe_delta_button = QPushButton("Default")
self.displacement_label = QLabel("Displacement")
self.icase_start = QLabel("iCase Start:")
self.icase_disp_start_edit = QSpinBox(self)
self.icase_disp_start_edit.setRange(0, icase_max)
self.icase_disp_start_edit.setSingleStep(1)
self.icase_disp_start_edit.setValue(self._icase_fringe)
self.icase_disp_start_button = QPushButton("Default")
self.icase_end_label = QLabel("iCase End:")
self.icase_disp_end_edit = QSpinBox(self)
self.icase_disp_end_edit.setRange(0, icase_max)
self.icase_disp_end_edit.setSingleStep(1)
self.icase_disp_end_edit.setValue(self._icase_fringe)
self.icase_disp_end_button = QPushButton("Default")
self.icase_delta_label = QLabel("iCase Delta:")
self.icase_disp_delta_edit = QSpinBox(self)
self.icase_disp_delta_edit.setRange(1, icase_max)
self.icase_disp_delta_edit.setSingleStep(1)
self.icase_disp_delta_edit.setValue(1)
self.icase_disp_delta_button = QPushButton("Default")
self.min_value_enable = QCheckBox()
self.min_value_label = QLabel("Min Value:")
self.min_value_edit = QLineEdit('')
#self.min_value_edit.setRange(1, 1000)
#self.min_value_edit.setSingleStep(1)
#self.min_value_edit.setValue(1)
self.min_value_button = QPushButton("Default")
self.max_value_enable = QCheckBox()
self.max_value_label = QLabel("Max Value:")
self.max_value_edit = QLineEdit('')
#self.min_value_edit.setRange(1, 1000) # TODO: update 1000
#self.min_value_edit.setSingleStep(1)
#self.min_value_edit.setValue(1)
self.max_value_button = QPushButton("Default")
# TODO: enable this (uncomment) ------------------------------------------
#self.min_value_enable.hide()
#self.min_value.hide()
#self.min_value_edit.hide()
#self.min_value_button.hide()
#self.max_value_enable.hide()
#self.max_value.hide()
#self.max_value_edit.hide()
#self.max_value_button.hide()
# TODO: enable this (uncomment) ------------------------------------------
self.icase_disp_start_edit.setToolTip(
'The first frame of the animation')
self.icase_disp_end_edit.setToolTip(
'The last frame of the animation\n'
'Assumes icase_start + nframes * icase_delta = icase_end')
self.icase_disp_delta_edit.setToolTip(
'The frame step size (to skip non-consecutive results).\n'
'Frame skipping can be used to:\n'
" - skip across results that you don't want to plot\n"
' - adjust the FPS')
self.min_value_edit.setToolTip(
'Min value of the legend (not supported)')
self.max_value_edit.setToolTip(
'Max value of the legend (not supported)')
#'time' : 0.,
#'default_time' : 0,
#'icase_start' : 10,
#'icase_delta' : 3,
#'min_value' : 0.,
#'max_value' : 1000.,
self.browse_folder_label = QLabel('Output Directory:')
self.browse_folder_edit = QLineEdit(str(self._default_dirname))
self.browse_folder_button = QPushButton('Browse')
self.browse_folder_edit.setToolTip(
'Location to save the png/gif files')
self.gif_label = QLabel("Gif Filename:")
self.gif_edit = QLineEdit(str(self._default_name + '.gif'))
self.gif_button = QPushButton('Default')
self.gif_edit.setToolTip('Name of the gif')
self.gif_button.setToolTip('Sets the name of the gif to %s.gif' %
self._default_name)
# scale / phase
if 1: # pragma: no cover
self.animate_scale_radio = QRadioButton("Animate Scale")
self.animate_phase_radio = QRadioButton("Animate Phase")
self.animate_time_radio = QRadioButton("Animate Time")
self.animate_freq_sweeep_radio = QRadioButton(
"Animate Frequency Sweep")
self.animate_scale_radio.setToolTip(
'Animates the scale factor based on the "Animation Type"')
self.animate_time_radio.setToolTip(
'Animates the time/load/mode step')
self.animate_scale_radio.setChecked(self._default_is_scale)
self.animate_phase_radio.setChecked(not self._default_is_scale)
self.animate_time_radio.setChecked(False)
msg = 'Scale : Animates the scale factor based on the "Animation Profile"\n'
if self._default_phase is None:
self.animate_phase_radio.setDisabled(True)
self.animate_phase_radio.setToolTip(
'Animates the phase angle '
'(only for complex results)')
msg += 'Phase : Animates the phase angle (only for complex results)\n'
else:
self.animate_phase_radio.setToolTip("Animates the phase angle")
msg += 'Phase : Animates the phase angle\n'
msg += (
'Time : Animates the time/load/mode step\n'
'Freq Sweep : Animates a complex result across a range of frequencies '
'(not supported)\n')
self.animate_freq_sweeep_radio.setDisabled(True)
self.animate_freq_sweeep_radio.setToolTip(
'Animates a complex result across a range of frequencies (not supported)'
)
else:
msg = 'Scale : Animates the scale factor based on the "Animation Profile"\n'
if self._default_phase is None:
#self.animate_phase_radio.setDisabled(True)
#self.animate_phase_radio.setToolTip('Animates the phase angle '
#'(only for complex results)')
msg += 'Phase : Animates the phase angle (only for complex results)\n'
else:
#self.animate_phase_radio.setToolTip("Animates the phase angle")
msg += 'Phase : Animates the phase angle\n'
msg += (
'Time : Animates the time/load/mode step\n'
'Freq Sweep : Animates a complex result across a range of frequencies '
'(not supported)\n')
self.animation_type = QLabel("Animation Type:")
animation_type = OrderedDict()
#scale_msg = 'Scale\n'
#phase_msg = 'Phase\n'
#time_msg = 'Time\n'
#animation_types = [
#('Animate Scale', scale_msg),
#('Animate Phase', phase_msg),
#('Animate Time', time_msg),
##'Animate Frequency Sweep'
#]
if self._phase is not None:
self.animation_types.append('Animate Phase')
self.animation_types.append('Animate Time')
self.animation_profile_label = QLabel("Animation Profile:")
self.animation_profile_edit = QComboBox()
for animation_profile in ANIMATION_PROFILES:
self.animation_profile_edit.addItem(animation_profile)
self.animation_profile_edit.setToolTip('The profile for a scaled GIF')
self.animation_type_edit = QComboBox()
# TODO: add a tooltip for each item
for animation_type in self.animation_types:
self.animation_type_edit.addItem(animation_type)
#self.animation_type_edit.setToolTip('The profile for a scaled GIF')
self.animation_type_edit.setToolTip(msg.rstrip())
self.csv_profile_label = QLabel("CSV profile:")
self.csv_profile_edit = QLineEdit()
self.csv_profile_browse_button = QPushButton('Browse')
self.csv_profile_edit.setToolTip(
'The path to the CSV file of (Scale1, Scale2, Scale3, ...)')
#widget = QWidget(self)
#horizontal_vertical_group = QButtonGroup(widget)
#horizontal_vertical_group.addButton(self.animate_scale_radio)
#horizontal_vertical_group.addButton(self.animate_phase_radio)
#horizontal_vertical_group.addButton(self.animate_time_radio)
#horizontal_vertical_group.addButton(self.animate_freq_sweeep_radio)
# animate in gui
self.animate_in_gui_checkbox = QCheckBox("Animate In GUI?")
self.animate_in_gui_checkbox.setChecked(True)
# make images
self.make_images_checkbox = QCheckBox("Make images?")
self.make_images_checkbox.setChecked(True)
# make images
self.overwrite_images_checkbox = QCheckBox("Overwrite images?")
self.overwrite_images_checkbox.setChecked(True)
# delete images when finished
self.delete_images_checkbox = QCheckBox("Delete images when finished?")
self.delete_images_checkbox.setChecked(True)
# endless loop
self.repeat_checkbox = QCheckBox("Repeat?")
self.repeat_checkbox.setChecked(True)
self.repeat_checkbox.setToolTip(
"Repeating creates an infinitely looping gif")
# endless loop
self.make_gif_checkbox = QCheckBox("Make Gif?")
if IS_IMAGEIO:
self.make_gif_checkbox.setChecked(True)
else:
self.make_gif_checkbox.setChecked(False)
self.make_gif_checkbox.setEnabled(False)
self.make_gif_checkbox.setToolTip(
'imageio is not available; install it')
# bottom buttons
self.step_button = QPushButton("Step")
self.wipe_button = QPushButton("Wipe Deformed Shape")
self.stop_button = QPushButton("Stop")
self.run_button = QPushButton("Run")
self.step_button.setToolTip(
'Steps through the animation (for testing)')
self.wipe_button.setToolTip(
'Removes the existing "deflecton" from the animation')
self.stop_button.setToolTip('Stops the animation')
self.run_button.setToolTip('Creates the animation')
self.step_button.hide()
self.wipe_button.hide()
self.wipe_button.setEnabled(False)
#self.wipe_button.hide()
self.stop_button.setEnabled(False)
self.cancel_button = QPushButton("Close")
#self.set_grid_time(enabled=False)
#self.set_grid_scale(enabled=self._default_is_scale)
if self._default_phase:
self.on_animate_phase(force=True)
set_combo_box_text(self.animation_type_edit, 'Animate Phase')
else:
self.on_animate_scale(force=True)
def set_connections(self):
"""creates button actions"""
self.checkbox_vector.clicked.connect(self.on_checkbox_vector)
self.scale_button.clicked.connect(self.on_default_scale)
self.arrow_scale_button.clicked.connect(self.on_default_arrow_scale)
self.time_button.clicked.connect(self.on_default_time)
self.fps_button.clicked.connect(self.on_default_fps)
self.resolution_button.clicked.connect(self.on_default_resolution)
self.browse_folder_button.clicked.connect(self.on_browse_folder)
self.csv_profile_browse_button.clicked.connect(self.on_browse_csv)
self.gif_button.clicked.connect(self.on_default_name)
self.step_button.clicked.connect(self.on_step)
self.wipe_button.clicked.connect(self.on_wipe)
self.stop_button.clicked.connect(self.on_stop)
self.run_button.clicked.connect(self.on_run)
self.min_value_enable.clicked.connect(self.on_min_value_enable)
self.max_value_enable.clicked.connect(self.on_max_value_enable)
self.min_value_button.clicked.connect(self.on_min_value_default)
self.max_value_button.clicked.connect(self.on_max_value_default)
self.icase_disp_start_button.clicked.connect(
self.on_update_min_max_defaults)
#self.animate_scale_radio.clicked.connect(self.on_animate_scale)
#self.animate_phase_radio.clicked.connect(self.on_animate_phase)
#self.animate_time_radio.clicked.connect(self.on_animate_time)
self.animation_type_edit.currentIndexChanged.connect(self.on_animate)
#self.animate_freq_sweeep_radio
self.cancel_button.clicked.connect(self.on_cancel)
self.animate_in_gui_checkbox.clicked.connect(self.on_animate_in_gui)
self.animate_in_gui_checkbox.setChecked(True)
self.on_animate_in_gui()
def on_checkbox_vector(self):
is_enabled = self.checkbox_vector.isEnabled()
is_checked = self.checkbox_vector.isChecked()
enable_edit = is_enabled and is_checked
self.icase_vector_label.setEnabled(is_checked)
self.icase_vector_edit.setEnabled(enable_edit)
def on_animate_in_gui(self):
animate_in_gui = self.animate_in_gui_checkbox.isChecked()
enable = not animate_in_gui
if HIDE_WHEN_INACTIVE:
self.make_images_checkbox.setVisible(enable)
self.delete_images_checkbox.setVisible(enable)
self.make_gif_checkbox.setVisible(enable)
self.repeat_checkbox.setVisible(enable)
self.resolution_button.setVisible(enable)
self.resolution_label.setVisible(enable)
self.resolution_edit.setVisible(enable)
self.gif_label.setVisible(enable)
self.gif_edit.setVisible(enable)
self.gif_button.setVisible(enable)
self.browse_folder_label.setVisible(enable)
self.browse_folder_button.setVisible(enable)
self.browse_folder_edit.setVisible(enable)
self.step_button.setEnabled(enable)
self.make_images_checkbox.setEnabled(enable)
self.delete_images_checkbox.setEnabled(enable)
self.make_gif_checkbox.setEnabled(enable)
self.repeat_checkbox.setEnabled(enable)
self.resolution_button.setEnabled(enable)
self.resolution_edit.setEnabled(enable)
self.gif_edit.setEnabled(enable)
self.gif_button.setEnabled(enable)
self.browse_folder_button.setEnabled(enable)
self.browse_folder_edit.setEnabled(enable)
self.step_button.setEnabled(enable)
#wipe_button
def on_animate(self, value):
"""
animate pulldown
Parameters
----------
value : int
index in animation_types
"""
#animation_types = ['Animate Scale', 'Animate Phase', 'Animate Time',
#'Animate Frequency Sweep']
animation_type = self.animation_types[value]
if animation_type == 'Animate Scale':
self.on_animate_scale()
elif animation_type == 'Animate Phase':
self.on_animate_phase()
elif animation_type == 'Animate Time':
self.on_animate_time()
else:
raise NotImplementedError('value = ', value)
def on_animate_time(self, force=False):
"""enables the secondary input"""
#print('on_animate_time')
if self._animate_type == 'scale' or force:
self.set_grid_scale(False, 'time')
self.set_grid_time(True, 'time')
self._animate_type = 'time'
def on_animate_scale(self, force=False):
"""enables the secondary input"""
#print('on_animate_scale')
self.set_grid_scale(True, 'scale')
if self._animate_type == 'time' or force:
self.set_grid_time(False, 'scale')
self._animate_type = 'scale'
def on_animate_phase(self, force=False):
"""enables the secondary input"""
#print('on_animate_phase')
if self._animate_type == 'scale' or force:
self.set_grid_scale(False, 'phase')
if self._animate_type == 'time' or force:
self.set_grid_time(False, 'phase')
self._animate_type = 'phase'
def set_grid_scale(self, enabled=True, word=''):
"""enables/disables the secondary input"""
#print('%s-set_grid_scale; enabled = %r' % (word, enabled))
if HIDE_WHEN_INACTIVE:
self.box_scale.setVisible(enabled)
self.animation_profile_label.setVisible(enabled)
self.animation_profile_edit.setVisible(enabled)
#self.min_value_enable.setVisible(enabled)
#self.max_value_enable.setVisible(enabled)
self.animation_profile_label.setEnabled(enabled)
self.animation_profile_edit.setEnabled(enabled)
# TODO: doesn't work...
#self.csv_profile.setEnabled(enabled)
#self.csv_profile_edit.setEnabled(enabled)
#self.csv_profile_button.setEnabled(enabled)
self.min_value_enable.setEnabled(enabled)
self.max_value_enable.setEnabled(enabled)
self.on_min_value_enable()
self.on_max_value_enable()
def set_grid_time(self, enabled=True, word=''):
"""enables/disables the secondary input"""
#print('%s-set_grid_time; enabled = %r' % (word, enabled))
if HIDE_WHEN_INACTIVE:
self.box_time.setVisible(enabled)
self.checkbox_fringe.setVisible(not enabled)
self.icase_fringe_label.setVisible(not enabled)
self.icase_fringe_edit.setVisible(not enabled)
self.icase_disp_label.setVisible(not enabled)
self.icase_disp_edit.setVisible(not enabled)
self.icase_vector_label.setVisible(not enabled)
self.icase_vector_edit.setVisible(not enabled)
#self.icase_fringe_delta_edit.setVisible(enabled)
self.icase_disp_delta_edit.setVisible(enabled)
self.icase_disp_delta_edit.setVisible(enabled)
self.fps_label.setVisible(enabled)
self.fps_edit.setVisible(enabled)
self.fps_button.setVisible(enabled)
self.displacement_label.setEnabled(enabled)
self.fringe_label.setEnabled(enabled)
self.icase_start.setEnabled(enabled)
self.icase_disp_start_edit.setEnabled(enabled)
self.icase_disp_start_button.setEnabled(enabled)
self.icase_fringe_start_edit.setEnabled(enabled)
self.icase_fringe_start_button.setEnabled(enabled)
self.icase_end_label.setEnabled(enabled)
self.icase_disp_end_edit.setEnabled(enabled)
self.icase_disp_end_button.setEnabled(enabled)
self.icase_fringe_end_edit.setEnabled(enabled)
self.icase_fringe_end_button.setEnabled(enabled)
self.icase_delta_label.setEnabled(enabled)
self.icase_disp_delta_edit.setEnabled(enabled)
self.icase_disp_delta_button.setEnabled(enabled)
self.icase_fringe_delta_edit.setEnabled(enabled)
self.icase_fringe_delta_button.setEnabled(enabled)
#-----------------------------------------------------------------------
is_min_enabled = self.min_value_enable.isChecked()
self.min_value_label.setEnabled(is_min_enabled)
self.min_value_edit.setEnabled(is_min_enabled)
self.min_value_button.setEnabled(is_min_enabled)
is_max_enabled = self.max_value_enable.isChecked()
self.max_value_label.setEnabled(is_max_enabled)
self.max_value_edit.setEnabled(is_max_enabled)
self.max_value_button.setEnabled(is_max_enabled)
self.min_value_enable.setEnabled(enabled)
self.on_min_value_enable()
#self.min_value.setEnabled(enabled)
#self.min_value_edit.setEnabled(enabled)
#self.min_value_button.setEnabled(enabled)
self.max_value_enable.setEnabled(enabled)
self.on_max_value_enable()
#self.max_value.setEnabled(enabled)
#self.max_value_edit.setEnabled(enabled)
#self.max_value_button.setEnabled(enabled)
self.icase_fringe_label.setEnabled(not enabled)
self.icase_fringe_edit.setEnabled(not enabled)
self.checkbox_fringe.setEnabled(not enabled)
self.icase_disp_label.setEnabled(not enabled)
self.icase_disp_edit.setEnabled(not enabled)
self.icase_vector_label.setEnabled(not enabled)
self.icase_vector_edit.setEnabled(not enabled)
self.checkbox_vector.setEnabled(not enabled)
self.on_checkbox_vector()
self.fps_label.setEnabled(not enabled)
self.fps_edit.setEnabled(not enabled)
self.fps_button.setEnabled(not enabled)
def on_min_value_enable(self):
"""
The min edit value box is enabled when we switch to time
and the box is checked
"""
is_min_enabled = self.min_value_enable.isChecked(
) and self.min_value_enable.isEnabled()
self.min_value_label.setEnabled(is_min_enabled)
self.min_value_edit.setEnabled(is_min_enabled)
self.min_value_button.setEnabled(is_min_enabled)
def on_max_value_enable(self):
"""
The max edit value box is enabled when we switch to time
and the box is checked
"""
is_max_enabled = self.max_value_enable.isChecked(
) and self.max_value_enable.isEnabled()
self.max_value_label.setEnabled(is_max_enabled)
self.max_value_edit.setEnabled(is_max_enabled)
self.max_value_button.setEnabled(is_max_enabled)
def on_update_min_max_defaults(self):
"""
When the icase is changed, the min/max value default message is changed
"""
icase = self.icase_disp_start_edit.value()
min_value, max_value = self.get_min_max(icase)
self.min_value_button.setToolTip('Sets the min value to %g' %
min_value)
self.max_value_button.setToolTip('Sets the max value to %g' %
max_value)
def on_min_value_default(self):
"""When min default icase is pressued, update the value"""
icase = self.icase_disp_start_edit.value()
min_value = self.get_min_max(icase)[0]
self.min_value_edit.setText(str(min_value))
self.min_value_edit.setStyleSheet("QLineEdit{background: white;}")
def on_max_value_default(self):
"""When max default icase is pressued, update the value"""
icase = self.icase_disp_start_edit.value()
max_value = self.get_min_max(icase)[1]
self.max_value_edit.setText(str(max_value))
self.max_value_edit.setStyleSheet("QLineEdit{background: white;}")
def on_browse_folder(self):
"""opens a folder dialog"""
dirname = getexistingdirectory(parent=self,
caption='Select a Directory',
basedir='',
options=QFileDialog.ShowDirsOnly)
if not dirname:
return
self.browse_folder_edit.setText(dirname)
def on_browse_csv(self):
"""opens a file dialog"""
default_filename = ''
file_types = 'Delimited Text (*.txt; *.dat; *.csv)'
dirname = open_file_dialog(self, 'Select a CSV File', default_filename,
file_types)
if not dirname:
return
self.csv_profile_browse_button.setText(dirname)
def on_default_name(self):
"""sets the default gif name"""
self.gif_edit.setText(self._default_name + '.gif')
def on_default_scale(self):
"""sets the default displacement scale factor"""
self.scale_edit.setText(str(self._default_scale))
self.scale_edit.setStyleSheet("QLineEdit{background: white;}")
def on_default_arrow_scale(self):
"""sets the default arrow scale factor"""
self.arrow_scale_edit.setText(str(self._default_arrow_scale))
self.arrow_scale_edit.setStyleSheet("QLineEdit{background: white;}")
def on_default_time(self):
"""sets the default gif time"""
self.time_edit.setValue(self._default_time)
def on_default_fps(self):
"""sets the default FPS"""
self.fps_edit.setValue(self._default_fps)
def on_default_resolution(self):
"""sets the default image resolution scale factor"""
self.resolution_edit.setValue(self._default_resolution)
def create_layout(self):
"""displays the menu objects"""
grid = QGridLayout()
irow = 0
grid.addWidget(self.icase_fringe_label, irow, 0)
grid.addWidget(self.icase_fringe_edit, irow, 1)
grid.addWidget(self.checkbox_fringe, irow, 2)
irow += 1
grid.addWidget(self.icase_disp_label, irow, 0)
grid.addWidget(self.icase_disp_edit, irow, 1)
#grid.addWidget(self.checkbox_disp, irow, 2)
irow += 1
grid.addWidget(self.icase_vector_label, irow, 0)
grid.addWidget(self.icase_vector_edit, irow, 1)
grid.addWidget(self.checkbox_vector, irow, 2)
irow += 1
grid.addWidget(self.scale_label, irow, 0)
grid.addWidget(self.scale_edit, irow, 1)
grid.addWidget(self.scale_button, irow, 2)
irow += 1
grid.addWidget(self.arrow_scale_label, irow, 0)
grid.addWidget(self.arrow_scale_edit, irow, 1)
grid.addWidget(self.arrow_scale_button, irow, 2)
irow += 1
grid.addWidget(self.time_label, irow, 0)
grid.addWidget(self.time_edit, irow, 1)
grid.addWidget(self.time_button, irow, 2)
irow += 1
# spacer
spacer = QLabel('')
grid.addWidget(self.fps_label, irow, 0)
grid.addWidget(self.fps_edit, irow, 1)
grid.addWidget(self.fps_button, irow, 2)
irow += 1
grid.addWidget(self.animation_type, irow, 0)
grid.addWidget(self.animation_type_edit, irow, 1)
irow += 1
grid.addWidget(spacer, irow, 0)
irow += 1
#----------
#Time
grid_time = QGridLayout()
jrow = 0
self.fringe_label.setAlignment(Qt.AlignCenter)
self.displacement_label.setAlignment(Qt.AlignCenter)
if not IS_TIME_FRINGE:
self.fringe_label.hide()
self.icase_fringe_delta_edit.hide()
self.icase_fringe_start_edit.hide()
self.icase_fringe_end_edit.hide()
self.icase_fringe_delta_button.hide()
grid_time.addWidget(self.displacement_label, jrow, 1)
grid_time.addWidget(self.fringe_label, jrow, 2)
jrow += 1
grid_time.addWidget(self.icase_start, jrow, 0)
grid_time.addWidget(self.icase_disp_start_edit, jrow, 1)
grid_time.addWidget(self.icase_fringe_start_edit, jrow, 2)
#grid_time.addWidget(self.icase_disp_start_button, jrow, 2)
jrow += 1
grid_time.addWidget(self.icase_end_label, jrow, 0)
grid_time.addWidget(self.icase_disp_end_edit, jrow, 1)
grid_time.addWidget(self.icase_fringe_end_edit, jrow, 2)
#grid_time.addWidget(self.icase_end_button, jrow, 2)
jrow += 1
grid_time.addWidget(self.icase_delta_label, jrow, 0)
grid_time.addWidget(self.icase_disp_delta_edit, jrow, 1)
grid_time.addWidget(self.icase_fringe_delta_edit, jrow, 2)
#grid_time.addWidget(self.icase_delta_button, jrow, 2)
jrow += 1
hbox_min = QHBoxLayout()
hbox_min.addWidget(self.min_value_enable)
hbox_min.addWidget(self.min_value_label)
grid_time.addLayout(hbox_min, jrow, 0)
grid_time.addWidget(self.min_value_edit, jrow, 1)
grid_time.addWidget(self.min_value_button, jrow, 2)
jrow += 1
hbox_max = QHBoxLayout()
hbox_max.addWidget(self.max_value_enable)
hbox_max.addWidget(self.max_value_label)
grid_time.addLayout(hbox_max, jrow, 0)
grid_time.addWidget(self.max_value_edit, jrow, 1)
grid_time.addWidget(self.max_value_button, jrow, 2)
jrow += 1
grid_time.addWidget(spacer, jrow, 0)
jrow += 1
#--------------
grid_scale = QGridLayout()
grid_scale.addWidget(self.animation_profile_label, 0, 0)
grid_scale.addWidget(self.animation_profile_edit, 0, 1)
#grid_scale.addWidget(self.csv_profile, 1, 0)
#grid_scale.addWidget(self.csv_profile_edit, 1, 1)
#grid_scale.addWidget(self.csv_profile_browse_button, 1, 2)
self.csv_profile = QLabel("CSV profile:")
self.csv_profile_edit = QLineEdit()
self.csv_profile_button = QPushButton('Browse')
#box_time = QVBoxLayout()
# TODO: It's super annoying that the animate time box doesn't
# line up with the previous box
self.box_scale.setLayout(grid_scale)
self.box_time.setLayout(grid_time)
#----------
grid2 = QGridLayout()
irow = 0
#grid2.addWidget(self.animate_scale_radio, 8, 0)
#grid2.addWidget(self.animate_phase_radio, 8, 1)
#grid2.addWidget(self.animate_time_radio, 8, 2)
#grid2.addWidget(self.animate_freq_sweeep_radio, 8, 3)
grid2.addWidget(self.animate_in_gui_checkbox, irow, 0)
irow += 1
grid2.addWidget(self.resolution_label, irow, 0)
grid2.addWidget(self.resolution_edit, irow, 1)
grid2.addWidget(self.resolution_button, irow, 2)
irow += 1
grid2.addWidget(self.browse_folder_label, irow, 0)
grid2.addWidget(self.browse_folder_edit, irow, 1)
grid2.addWidget(self.browse_folder_button, irow, 2)
irow += 1
grid2.addWidget(self.gif_label, irow, 0)
grid2.addWidget(self.gif_edit, irow, 1)
grid2.addWidget(self.gif_button, irow, 2)
irow += 1
grid2.addWidget(self.make_images_checkbox, irow, 0)
#grid2.addWidget(self.overwrite_images_checkbox, irow, 0)
grid2.addWidget(self.delete_images_checkbox, irow, 1)
grid2.addWidget(self.make_gif_checkbox, irow, 2)
irow += 1
grid2.addWidget(self.repeat_checkbox, irow, 0)
irow += 1
grid2.addWidget(spacer, irow, 0)
grid_hbox = QHBoxLayout()
grid_hbox.addWidget(spacer)
grid_hbox.addLayout(grid2)
grid_hbox.addWidget(spacer)
# bottom buttons
step_run_box = QHBoxLayout()
step_run_box.addWidget(self.step_button)
step_run_box.addWidget(self.wipe_button)
step_run_box.addWidget(self.stop_button)
step_run_box.addWidget(self.run_button)
ok_cancel_box = QHBoxLayout()
ok_cancel_box.addWidget(self.cancel_button)
vbox = QVBoxLayout()
vbox.addLayout(grid)
vbox.addWidget(self.box_scale)
vbox.addWidget(self.box_time)
#vbox.addLayout(checkboxes)
vbox.addLayout(grid_hbox)
vbox.addStretch()
vbox.addLayout(step_run_box)
vbox.addLayout(ok_cancel_box)
self.setLayout(vbox)
def on_step(self):
"""click the Step button"""
passed, validate_out = self.on_validate()
if passed:
try:
self._make_gif(validate_out, istep=self.istep)
self.istep += 1
except IndexError:
self._make_gif(validate_out, istep=0)
self.istep += 1
self.wipe_button.setEnabled(True)
def on_wipe(self):
"""click the Wipe button"""
passed, validate_out = self.on_validate(wipe=True)
if passed:
self.istep = 0
self._make_gif(validate_out, istep=self.istep)
self.wipe_button.setEnabled(False)
self.stop_button.setEnabled(False)
def on_stop(self):
"""click the Stop button"""
#passed, validate_out = self.on_validate()
#if passed:
#self._make_gif(validate_out, stop_animation=True)
if self.is_gui:
self.win_parent.win_parent.stop_animation()
self.wipe_button.setEnabled(True)
self.stop_button.setEnabled(False)
def on_run(self):
"""click the Run button"""
self.istep = 0
self.wipe_button.setEnabled(False)
self.stop_button.setEnabled(True)
passed, validate_out = self.on_validate()
if passed:
self._make_gif(validate_out, istep=None)
return passed
def _make_gif(self, validate_out, istep=None, stop_animation=False):
"""interface for making the gif"""
(icase_fringe, icase_disp, icase_vector, scale, time, fps,
animate_in_gui, magnify, output_dir, gifbase, min_value,
max_value) = validate_out
fps = int(fps)
gif_filename = None
if not stop_animation and not animate_in_gui and gifbase is not None:
if gifbase.lower().endswith('.gif'):
gifbase = gifbase[:-4]
gif_filename = os.path.join(output_dir, gifbase + '.gif')
animate_fringe = self.checkbox_fringe.isChecked()
animate_vector = self.checkbox_vector.isChecked()
animate_scale = self.animate_scale_radio.isChecked()
animate_phase = self.animate_phase_radio.isChecked()
animate_time = self.animate_time_radio.isChecked()
if not self.checkbox_vector.isEnabled():
icase_vector = None
animate_scale = False
animate_phase = False
animate_time = False
if self._animate_type == 'scale':
animate_scale = True
elif self._animate_type == 'phase':
animate_phase = True
elif self._animate_type == 'time':
animate_time = True
else:
raise NotImplementedError(self._animate_type)
make_images = self.make_images_checkbox.isChecked()
delete_images = self.delete_images_checkbox.isChecked()
make_gif = self.make_gif_checkbox.isChecked()
animation_profile = str(self.animation_profile_edit.currentText())
icase_disp_start = self.icase_disp_start_edit.value()
icase_disp_end = self.icase_disp_end_edit.value()
icase_disp_delta = self.icase_disp_delta_edit.value()
bool_repeat = self.repeat_checkbox.isChecked(
) # TODO: change this to an integer
if bool_repeat:
nrepeat = 0
else:
nrepeat = 1
#self.out_data['is_shown'] = self.show_radio.isChecked()
#icase = self._icase
if self.is_gui:
self.win_parent.win_parent.make_gif(
gif_filename,
scale,
istep=istep,
animate_scale=animate_scale,
animate_phase=animate_phase,
animate_time=animate_time,
icase_fringe=icase_fringe,
icase_disp=icase_disp,
icase_vector=icase_vector,
animate_fringe=animate_fringe,
animate_vector=animate_vector,
icase_start=icase_disp_start,
icase_end=icase_disp_end,
icase_delta=icase_disp_delta,
time=time,
animation_profile=animation_profile,
nrepeat=nrepeat,
fps=fps,
magnify=magnify,
make_images=make_images,
delete_images=delete_images,
make_gif=make_gif,
stop_animation=stop_animation,
animate_in_gui=animate_in_gui,
min_value=min_value,
max_value=max_value,
)
self.out_data['clicked_ok'] = True
self.out_data['close'] = True
def get_min_max(self, icase):
if self.is_gui:
(obj, (i, name)) = self.win_parent.win_parent.result_cases[icase]
min_value, max_value = obj.get_min_max(i, name)
else:
return 0., 1.0
return min_value, max_value
def on_validate(self, wipe=False):
"""checks to see if the input is valid"""
# requires no special validation
icase_fringe, flag0 = check_int(self.icase_fringe_edit)
icase_disp, unused_flaga = check_int(self.icase_disp_edit)
icase_vector, unused_flagb = check_int(self.icase_vector_edit)
#icase_disp = self._icase_disp
#icase_vector = self._icase_vector
scale, flag1 = check_float(self.scale_edit)
time, flag2 = check_float(self.time_edit)
fps, flag3 = check_float(self.fps_edit)
min_value = max_value = None
flag4 = flag5 = True
if self.min_value_edit.isEnabled():
min_value, flag4 = check_float(self.min_value_edit)
if self.max_value_edit.isEnabled():
max_value, flag5 = check_float(self.max_value_edit)
if wipe:
animate_in_gui = False
scale = 0.
flag1 = True
else:
animate_in_gui = self.animate_in_gui_checkbox.isChecked()
if animate_in_gui or wipe:
passed = all([flag0, flag1, flag2, flag3, flag4, flag5])
magnify, output_dir, gifbase = None, None, None
else:
magnify, flag6 = check_int(self.resolution_edit)
output_dir, flag7 = self.check_path(self.browse_folder_edit)
gifbase, flag8 = self.check_name(self.gif_edit)
passed = all([
flag0, flag1, flag2, flag3, flag4, flag5, flag6, flag7, flag8
])
return passed, (icase_fringe, icase_disp, icase_vector, scale, time,
fps, animate_in_gui, magnify, output_dir, gifbase,
min_value, max_value)
@staticmethod
def check_name(cell):
"""verifies that the data is string-able"""
cell_value = cell.text()
try:
text = str(cell_value).strip()
except UnicodeEncodeError:
cell.setStyleSheet("QLineEdit{background: red;}")
return None, False
if len(text):
cell.setStyleSheet("QLineEdit{background: white;}")
return text, True
else:
cell.setStyleSheet("QLineEdit{background: red;}")
return None, False
def check_path(self, cell):
"""verifies that the path exists"""
text, passed = self.check_name(cell)
if not passed:
return None, False
if os.path.exists(text):
cell.setStyleSheet("QLineEdit{background: white;}")
return text, True
else:
cell.setStyleSheet("QLineEdit{background: red;}")
return None, False
#def on_ok(self):
#"""click the OK button"""
#passed = self.on_apply()
#if passed:
#self.win_parent._animation_window_shown = False
#self.close()
##self.destroy()
def on_cancel(self):
"""click the Cancel button"""
self.on_stop()
self.out_data['close'] = True
self.close()
class PluginListItem(QFrame):
def __init__(
self,
package_name: str,
version: str = '',
url: str = '',
summary: str = '',
author: str = '',
license: str = "UNKNOWN",
*,
plugin_name: str = None,
parent: QWidget = None,
enabled: bool = True,
installed: bool = False,
npe_version=1,
):
super().__init__(parent)
self.setup_ui(enabled)
self.plugin_name.setText(package_name)
self.package_name.setText(version)
self.summary.setText(summary)
self.package_author.setText(author)
self.cancel_btn.setVisible(False)
self.help_button.setText(trans._("Website"))
self.help_button.setObjectName("help_button")
if npe_version != 1:
self.enabled_checkbox.setEnabled(False)
if installed:
self.enabled_checkbox.show()
self.action_button.setText(trans._("uninstall"))
self.action_button.setObjectName("remove_button")
else:
self.enabled_checkbox.hide()
self.action_button.setText(trans._("install"))
self.action_button.setObjectName("install_button")
def _get_dialog(self) -> QDialog:
p = self.parent()
while not isinstance(p, QDialog) and p.parent():
p = p.parent()
return p
def set_busy(self, text: str, update: bool = False):
self.item_status.setText(text)
self.cancel_btn.setVisible(True)
if not update:
self.action_button.setVisible(False)
else:
self.update_btn.setVisible(False)
def setup_ui(self, enabled=True):
self.v_lay = QVBoxLayout(self)
self.v_lay.setContentsMargins(-1, 6, -1, 6)
self.v_lay.setSpacing(0)
self.row1 = QHBoxLayout()
self.row1.setSpacing(6)
self.enabled_checkbox = QCheckBox(self)
self.enabled_checkbox.setChecked(enabled)
self.enabled_checkbox.stateChanged.connect(self._on_enabled_checkbox)
self.enabled_checkbox.setToolTip(trans._("enable/disable"))
sizePolicy = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.enabled_checkbox.sizePolicy().hasHeightForWidth()
)
self.enabled_checkbox.setSizePolicy(sizePolicy)
self.enabled_checkbox.setMinimumSize(QSize(20, 0))
self.enabled_checkbox.setText("")
self.row1.addWidget(self.enabled_checkbox)
self.plugin_name = QLabel(self)
sizePolicy = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Minimum)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.plugin_name.sizePolicy().hasHeightForWidth()
)
self.plugin_name.setSizePolicy(sizePolicy)
font15 = QFont()
font15.setPointSize(15)
self.plugin_name.setFont(font15)
self.row1.addWidget(self.plugin_name)
self.item_status = QLabel(self)
self.item_status.setObjectName("small_italic_text")
self.item_status.setSizePolicy(sizePolicy)
self.row1.addWidget(self.item_status)
self.row1.addStretch()
self.package_name = QLabel(self)
self.package_name.setAlignment(
Qt.AlignRight | Qt.AlignTrailing | Qt.AlignVCenter
)
self.row1.addWidget(self.package_name)
self.cancel_btn = QPushButton("cancel", self)
self.cancel_btn.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.cancel_btn.setObjectName("remove_button")
self.row1.addWidget(self.cancel_btn)
self.update_btn = QPushButton(self)
self.update_btn.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.update_btn.setObjectName("install_button")
self.row1.addWidget(self.update_btn)
self.update_btn.setVisible(False)
self.help_button = QPushButton(self)
self.action_button = QPushButton(self)
sizePolicy = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.action_button.sizePolicy().hasHeightForWidth()
)
self.help_button.setSizePolicy(sizePolicy)
self.action_button.setSizePolicy(sizePolicy)
self.row1.addWidget(self.help_button)
self.row1.addWidget(self.action_button)
self.v_lay.addLayout(self.row1)
self.row2 = QHBoxLayout()
self.error_indicator = QPushButton()
self.error_indicator.setObjectName("warning_icon")
self.error_indicator.setCursor(Qt.PointingHandCursor)
self.error_indicator.hide()
self.row2.addWidget(self.error_indicator)
self.row2.setContentsMargins(-1, 4, 0, -1)
self.summary = QElidingLabel(parent=self)
sizePolicy = QSizePolicy(
QSizePolicy.MinimumExpanding, QSizePolicy.Preferred
)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.summary.sizePolicy().hasHeightForWidth()
)
self.summary.setSizePolicy(sizePolicy)
self.summary.setObjectName("small_text")
self.row2.addWidget(self.summary)
self.package_author = QLabel(self)
sizePolicy = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.package_author.sizePolicy().hasHeightForWidth()
)
self.package_author.setSizePolicy(sizePolicy)
self.package_author.setObjectName("small_text")
self.row2.addWidget(self.package_author)
self.v_lay.addLayout(self.row2)
def _on_enabled_checkbox(self, state: int):
"""Called with `state` when checkbox is clicked."""
enabled = bool(state)
current_distname = self.plugin_name.text()
for plugin_name, _, distname in plugin_manager.iter_available():
if distname and distname == current_distname:
plugin_manager.set_blocked(plugin_name, not enabled)
class EditGeometryProperties(PyDialog):
force = True
def __init__(self, data, win_parent=None):
"""
+------------------+
| Edit Actor Props |
+------------------+------+
| Name1 |
| Name2 |
| Name3 |
| Name4 |
| |
| Active_Name main |
| Color box |
| Line_Width 2 |
| Point_Size 2 |
| Bar_Scale 2 |
| Opacity 0.5 |
| Show/Hide |
| |
| Apply OK Cancel |
+-------------------------+
"""
PyDialog.__init__(self, data, win_parent)
self.set_font_size(data['font_size'])
del self.out_data['font_size']
self.setWindowTitle('Edit Geometry Properties')
self.allow_update = True
#default
#self.win_parent = win_parent
#self.out_data = data
self.keys = sorted(data.keys())
self.keys = data.keys()
keys = self.keys
items = list(keys)
#nrows = len(keys)
active_key = 'main'
if 'main' not in items:
active_key = items[0]
self.active_key = active_key
header_labels = ['Groups']
table_model = Model(items, header_labels, self)
view = SingleChoiceQTableView(self) #Call your custom QTableView here
view.setModel(table_model)
#if qt_version == 4:
#view.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
self.table = view
#self.opacity_edit.valueChanged.connect(self.on_opacity)
#mListWidget, SIGNAL(itemClicked(QListWidgetItem*)), this, SLOT(itemClicked(QListWidgetItem*)));
#self.table.itemClicked.connect(self.table.mouseDoubleClickEvent)
actor_obj = data[self.active_key]
if isinstance(actor_obj, CoordProperties):
opacity = 1.0
representation = 'coord'
show = actor_obj.is_visible
color = None
line_width = 0
point_size = 0
bar_scale = 0
name = 'Coord'
else:
name = actor_obj.name
line_width = actor_obj.line_width
point_size = actor_obj.point_size
bar_scale = actor_obj.bar_scale
opacity = actor_obj.opacity
color = actor_obj.color
show = actor_obj.is_visible
representation = actor_obj.representation
self.representation = representation
# table
header = self.table.horizontalHeader()
header.setStretchLastSection(True)
self._default_is_apply = False
self.name = QLabel("Name:")
self.name_edit = QLineEdit(str(name))
self.name_edit.setDisabled(True)
self.color = QLabel("Color:")
self.color_edit = QPushButton()
#self.color_edit.setFlat(True)
if color is not None:
qcolor = QtGui.QColor()
qcolor.setRgb(*color)
#print('color =%s' % str(color))
palette = QtGui.QPalette(
self.color_edit.palette()) # make a copy of the palette
#palette.setColor(QtGui.QPalette.Active, QtGui.QPalette.Base, \
#qcolor)
palette.setColor(QtGui.QPalette.Background,
QtGui.QColor('blue')) # ButtonText
self.color_edit.setPalette(palette)
self.color_edit.setStyleSheet(
"QPushButton {"
"background-color: rgb(%s, %s, %s);" % tuple(color) +
#"border:1px solid rgb(255, 170, 255); "
"}")
self.representation_label = QLabel('Representation:')
self.checkbox_wire = QCheckBox('Wireframe')
self.checkbox_surf = QCheckBox('Surface/Solid')
#print('representation = %s' % self.representation)
#self.check_point = QCheckBox()
self.use_slider = True
self.is_opacity_edit_active = False
self.is_opacity_edit_slider_active = False
self.is_line_width_edit_active = False
self.is_line_width_edit_slider_active = False
self.is_point_size_edit_active = False
self.is_point_size_edit_slider_active = False
self.is_bar_scale_edit_active = False
self.is_bar_scale_edit_slider_active = False
self.opacity = QLabel("Opacity:")
self.opacity_edit = QDoubleSpinBox(self)
self.opacity_edit.setRange(0.1, 1.0)
self.opacity_edit.setDecimals(1)
self.opacity_edit.setSingleStep(0.1)
self.opacity_edit.setValue(opacity)
if self.use_slider:
self.opacity_slider_edit = QSlider(QtCore.Qt.Horizontal)
self.opacity_slider_edit.setRange(1, 10)
self.opacity_slider_edit.setValue(opacity * 10)
self.opacity_slider_edit.setTickInterval(1)
self.opacity_slider_edit.setTickPosition(QSlider.TicksBelow)
self.line_width = QLabel("Line Width:")
self.line_width_edit = QSpinBox(self)
self.line_width_edit.setRange(1, MAX_LINE_WIDTH)
self.line_width_edit.setSingleStep(1)
self.line_width_edit.setValue(line_width)
if self.use_slider:
self.line_width_slider_edit = QSlider(QtCore.Qt.Horizontal)
self.line_width_slider_edit.setRange(1, MAX_LINE_WIDTH)
self.line_width_slider_edit.setValue(line_width)
self.line_width_slider_edit.setTickInterval(1)
self.line_width_slider_edit.setTickPosition(QSlider.TicksBelow)
if self.representation in ['point', 'surface']:
self.line_width.setEnabled(False)
self.line_width_edit.setEnabled(False)
self.line_width_slider_edit.setEnabled(False)
self.point_size = QLabel("Point Size:")
self.point_size_edit = QSpinBox(self)
self.point_size_edit.setRange(1, MAX_POINT_SIZE)
self.point_size_edit.setSingleStep(1)
self.point_size_edit.setValue(point_size)
self.point_size.setVisible(False)
self.point_size_edit.setVisible(False)
if self.use_slider:
self.point_size_slider_edit = QSlider(QtCore.Qt.Horizontal)
self.point_size_slider_edit.setRange(1, MAX_POINT_SIZE)
self.point_size_slider_edit.setValue(point_size)
self.point_size_slider_edit.setTickInterval(1)
self.point_size_slider_edit.setTickPosition(QSlider.TicksBelow)
self.point_size_slider_edit.setVisible(False)
if self.representation in ['wire', 'surface']:
self.point_size.setEnabled(False)
self.point_size_edit.setEnabled(False)
if self.use_slider:
self.point_size_slider_edit.setEnabled(False)
self.bar_scale = QLabel("Bar Scale:")
self.bar_scale_edit = QDoubleSpinBox(self)
#self.bar_scale_edit.setRange(0.01, 1.0) # was 0.1
#self.bar_scale_edit.setRange(0.05, 5.0)
self.bar_scale_edit.setDecimals(1)
#self.bar_scale_edit.setSingleStep(bar_scale / 10.)
self.bar_scale_edit.setSingleStep(0.1)
self.bar_scale_edit.setValue(bar_scale)
#if self.use_slider:
#self.bar_scale_slider_edit = QSlider(QtCore.Qt.Horizontal)
#self.bar_scale_slider_edit.setRange(1, 100) # 1/0.05 = 100/5.0
#self.bar_scale_slider_edit.setValue(opacity * 0.05)
#self.bar_scale_slider_edit.setTickInterval(10)
#self.bar_scale_slider_edit.setTickPosition(QSlider.TicksBelow)
if self.representation != 'bar':
self.bar_scale.setEnabled(False)
self.bar_scale_edit.setEnabled(False)
self.bar_scale.setVisible(False)
self.bar_scale_edit.setVisible(False)
#self.bar_scale_slider_edit.setVisible(False)
#self.bar_scale_slider_edit.setEnabled(False)
# show/hide
self.checkbox_show = QCheckBox("Show")
self.checkbox_hide = QCheckBox("Hide")
self.checkbox_show.setChecked(show)
self.checkbox_hide.setChecked(not show)
if name == 'main':
self.color.setEnabled(False)
self.color_edit.setEnabled(False)
self.point_size.setEnabled(False)
self.point_size_edit.setEnabled(False)
if self.use_slider:
self.point_size_slider_edit.setEnabled(False)
self.cancel_button = QPushButton("Close")
self.create_layout()
self.set_connections()
if isinstance(actor_obj, CoordProperties):
self.color_edit.hide()
self.color.hide()
self.opacity.hide()
self.opacity_edit.hide()
self.opacity_slider_edit.hide()
self.line_width.hide()
self.line_width_edit.hide()
self.line_width_slider_edit.hide()
def on_delete(self, irow):
"""deletes an actor based on the row number"""
if irow == 0: # main
return
nkeys = len(self.keys)
if nkeys in [0, 1]:
return
name = self.keys[irow]
nrows = nkeys - 1
self.keys.pop(irow)
header_labels = ['Groups']
table_model = Model(self.keys, header_labels, self)
self.table.setModel(table_model)
if len(self.keys) == 0:
self.update()
self.set_as_null()
return
if irow == nrows:
irow -= 1
new_name = self.keys[irow]
self.update_active_name(new_name)
if self.is_gui:
self.win_parent.delete_actor(name)
def set_as_null(self):
"""sets the null case"""
self.name.setVisible(False)
self.name_edit.setVisible(False)
self.color.setVisible(False)
self.color_edit.setVisible(False)
self.line_width.setVisible(False)
self.line_width_edit.setVisible(False)
self.point_size.setVisible(False)
self.point_size_edit.setVisible(False)
self.bar_scale.setVisible(False)
self.bar_scale_edit.setVisible(False)
self.opacity.setVisible(False)
self.opacity_edit.setVisible(False)
self.opacity_slider_edit.setVisible(False)
self.point_size_slider_edit.setVisible(False)
self.line_width_slider_edit.setVisible(False)
self.checkbox_show.setVisible(False)
self.checkbox_hide.setVisible(False)
def on_update_geometry_properties_window(self, data):
"""Not Implemented"""
return
#new_keys = sorted(data.keys())
#if self.active_key in new_keys:
#i = new_keys.index(self.active_key)
#else:
#i = 0
#self.table.update_data(new_keys)
#self.out_data = data
#self.update_active_key(i)
def update_active_key(self, index):
"""
Parameters
----------
index : PyQt4.QtCore.QModelIndex
the index of the list
Internal Parameters
-------------------
name : str
the name of obj
obj : CoordProperties, AltGeometry
the storage object for things like line_width, point_size, etc.
"""
name = str(index.data())
#print('name = %r' % name)
#i = self.keys.index(self.active_key)
self.update_active_name(name)
def update_active_name(self, name):
self.active_key = name
self.name_edit.setText(name)
obj = self.out_data[name]
if isinstance(obj, CoordProperties):
opacity = 1.0
representation = 'coord'
is_visible = obj.is_visible
elif isinstance(obj, AltGeometry):
line_width = obj.line_width
point_size = obj.point_size
bar_scale = obj.bar_scale
opacity = obj.opacity
representation = obj.representation
is_visible = obj.is_visible
self.color_edit.setStyleSheet(
"QPushButton {"
"background-color: rgb(%s, %s, %s);" % tuple(obj.color) +
#"border:1px solid rgb(255, 170, 255); "
"}")
self.allow_update = False
self.force = False
self.line_width_edit.setValue(line_width)
self.point_size_edit.setValue(point_size)
self.bar_scale_edit.setValue(bar_scale)
self.force = True
self.allow_update = True
else:
raise NotImplementedError(obj)
#allowed_representations = [
#'main', 'surface', 'coord', 'toggle', 'wire', 'point', 'bar']
if self.representation != representation:
self.representation = representation
#if representation not in allowed_representations:
#msg = 'name=%r; representation=%r is invalid\nrepresentations=%r' % (
#name, representation, allowed_representations)
if self.representation == 'coord':
self.color.setVisible(False)
self.color_edit.setVisible(False)
self.line_width.setVisible(False)
self.line_width_edit.setVisible(False)
self.point_size.setVisible(False)
self.point_size_edit.setVisible(False)
self.bar_scale.setVisible(False)
self.bar_scale_edit.setVisible(False)
self.opacity.setVisible(False)
self.opacity_edit.setVisible(False)
if self.use_slider:
self.opacity_slider_edit.setVisible(False)
self.point_size_slider_edit.setVisible(False)
self.line_width_slider_edit.setVisible(False)
#self.bar_scale_slider_edit.setVisible(False)
else:
self.color.setVisible(True)
self.color_edit.setVisible(True)
self.line_width.setVisible(True)
self.line_width_edit.setVisible(True)
self.point_size.setVisible(True)
self.point_size_edit.setVisible(True)
self.bar_scale.setVisible(True)
#self.bar_scale_edit.setVisible(True)
self.opacity.setVisible(True)
self.opacity_edit.setVisible(True)
if self.use_slider:
self.opacity_slider_edit.setVisible(True)
self.line_width_slider_edit.setVisible(True)
self.point_size_slider_edit.setVisible(True)
#self.bar_scale_slider_edit.setVisible(True)
if name == 'main':
self.color.setEnabled(False)
self.color_edit.setEnabled(False)
self.point_size.setEnabled(False)
self.point_size_edit.setEnabled(False)
self.line_width.setEnabled(True)
self.line_width_edit.setEnabled(True)
self.bar_scale.setEnabled(False)
self.bar_scale_edit.setEnabled(False)
show_points = False
show_line_width = True
show_bar_scale = False
if self.use_slider:
self.line_width_slider_edit.setEnabled(True)
#self.bar_scale_slider_edit.setVisible(False)
else:
self.color.setEnabled(True)
self.color_edit.setEnabled(True)
show_points = False
if self.representation in ['point', 'wire+point']:
show_points = True
show_line_width = False
if self.representation in [
'wire', 'wire+point', 'wire+surf', 'bar', 'toggle'
]:
show_line_width = True
if representation == 'bar':
show_bar_scale = True
else:
show_bar_scale = False
#self.bar_scale_button.setVisible(show_bar_scale)
#self.bar_scale_edit.setSingleStep(bar_scale / 10.)
#if self.use_slider:
#self.bar_scale_slider_edit.setEnabled(False)
self.point_size.setEnabled(show_points)
self.point_size_edit.setEnabled(show_points)
self.point_size.setVisible(show_points)
self.point_size_edit.setVisible(show_points)
self.line_width.setEnabled(show_line_width)
self.line_width_edit.setEnabled(show_line_width)
self.bar_scale.setEnabled(show_bar_scale)
self.bar_scale_edit.setEnabled(show_bar_scale)
self.bar_scale.setVisible(show_bar_scale)
self.bar_scale_edit.setVisible(show_bar_scale)
if self.use_slider:
self.point_size_slider_edit.setEnabled(show_points)
self.point_size_slider_edit.setVisible(show_points)
self.line_width_slider_edit.setEnabled(show_line_width)
#if self.representation in ['wire', 'surface']:
self.opacity_edit.setValue(opacity)
#if self.use_slider:
#self.opacity_slider_edit.setValue(opacity*10)
self.checkbox_show.setChecked(is_visible)
self.checkbox_hide.setChecked(not is_visible)
passed = self.on_validate()
#self.on_apply(force=True) # TODO: was turned on...do I want this???
#self.allow_update = True
def create_layout(self):
ok_cancel_box = QHBoxLayout()
ok_cancel_box.addWidget(self.cancel_button)
grid = QGridLayout()
irow = 0
grid.addWidget(self.name, irow, 0)
grid.addWidget(self.name_edit, irow, 1)
irow += 1
grid.addWidget(self.color, irow, 0)
grid.addWidget(self.color_edit, irow, 1)
irow += 1
grid.addWidget(self.opacity, irow, 0)
if self.use_slider:
grid.addWidget(self.opacity_edit, irow, 2)
grid.addWidget(self.opacity_slider_edit, irow, 1)
else:
grid.addWidget(self.opacity_edit, irow, 1)
irow += 1
grid.addWidget(self.line_width, irow, 0)
if self.use_slider:
grid.addWidget(self.line_width_edit, irow, 2)
grid.addWidget(self.line_width_slider_edit, irow, 1)
else:
grid.addWidget(self.line_width_edit, irow, 1)
irow += 1
grid.addWidget(self.point_size, irow, 0)
if self.use_slider:
grid.addWidget(self.point_size_edit, irow, 2)
grid.addWidget(self.point_size_slider_edit, irow, 1)
else:
grid.addWidget(self.point_size_edit, irow, 1)
irow += 1
grid.addWidget(self.bar_scale, irow, 0)
if self.use_slider and 0:
grid.addWidget(self.bar_scale_edit, irow, 2)
grid.addWidget(self.bar_scale_slider_edit, irow, 1)
else:
grid.addWidget(self.bar_scale_edit, irow, 1)
irow += 1
wire_surf_checkboxes = QButtonGroup(self)
wire_surf_checkboxes.addButton(self.checkbox_wire)
wire_surf_checkboxes.addButton(self.checkbox_surf)
checkboxs = QButtonGroup(self)
checkboxs.addButton(self.checkbox_show)
checkboxs.addButton(self.checkbox_hide)
vbox = QVBoxLayout()
vbox.addWidget(self.table, stretch=1)
vbox.addLayout(grid)
vbox1 = QVBoxLayout()
vbox1.addWidget(self.checkbox_wire)
vbox1.addWidget(self.checkbox_surf)
vbox2 = QVBoxLayout()
vbox2.addWidget(self.checkbox_show)
vbox2.addWidget(self.checkbox_hide)
#vbox.addLayout(vbox1)
vbox.addLayout(vbox2)
vbox.addStretch()
#vbox.addWidget(self.check_apply)
vbox.addLayout(ok_cancel_box)
self.setLayout(vbox)
def set_connections(self):
"""creates the actions for the menu"""
self.opacity_edit.valueChanged.connect(self.on_opacity)
self.line_width_edit.valueChanged.connect(self.on_line_width)
self.point_size_edit.valueChanged.connect(self.on_point_size)
self.bar_scale_edit.valueChanged.connect(self.on_bar_scale)
if self.use_slider:
self.opacity_slider_edit.valueChanged.connect(
self.on_opacity_slider)
self.line_width_slider_edit.valueChanged.connect(
self.on_line_width_slider)
self.point_size_slider_edit.valueChanged.connect(
self.on_point_size_slider)
#self.bar_scale_slider_edit.valueChanged.connect(self.on_bar_scale_slider)
# self.connect(self.opacity_edit, QtCore.SIGNAL('clicked()'), self.on_opacity)
# self.connect(self.line_width, QtCore.SIGNAL('clicked()'), self.on_line_width)
# self.connect(self.point_size, QtCore.SIGNAL('clicked()'), self.on_point_size)
if qt_version == 4:
self.connect(self, QtCore.SIGNAL('triggered()'), self.closeEvent)
self.color_edit.clicked.connect(self.on_color)
self.checkbox_show.clicked.connect(self.on_show)
self.checkbox_hide.clicked.connect(self.on_hide)
self.cancel_button.clicked.connect(self.on_cancel)
# closeEvent
def keyPressEvent(self, event):
if event.key() == QtCore.Qt.Key_Escape:
self.close()
def closeEvent(self, event):
self.on_cancel()
def on_color(self):
"""called when the user clicks on the color box"""
name = self.active_key
obj = self.out_data[name]
rgb_color_ints = obj.color
msg = name
col = QColorDialog.getColor(QtGui.QColor(*rgb_color_ints), self,
"Choose a %s color" % msg)
if col.isValid():
color_float = col.getRgbF()[:3]
obj.color = color_float
color_int = [int(colori * 255) for colori in color_float]
self.color_edit.setStyleSheet(
"QPushButton {"
"background-color: rgb(%s, %s, %s);" % tuple(color_int) +
#"border:1px solid rgb(255, 170, 255); "
"}")
self.on_apply(force=self.force)
#print(self.allow_update)
def on_show(self):
"""shows the actor"""
name = self.active_key
is_checked = self.checkbox_show.isChecked()
self.out_data[name].is_visible = is_checked
self.on_apply(force=self.force)
def on_hide(self):
"""hides the actor"""
name = self.active_key
is_checked = self.checkbox_hide.isChecked()
self.out_data[name].is_visible = not is_checked
self.on_apply(force=self.force)
def on_line_width(self):
"""increases/decreases the wireframe (for solid bodies) or the bar thickness"""
self.is_line_width_edit_active = True
name = self.active_key
line_width = self.line_width_edit.value()
self.out_data[name].line_width = line_width
if not self.is_line_width_edit_slider_active:
if self.use_slider:
self.line_width_slider_edit.setValue(line_width)
self.is_line_width_edit_active = False
self.on_apply(force=self.force)
self.is_line_width_edit_active = False
def on_line_width_slider(self):
"""increases/decreases the wireframe (for solid bodies) or the bar thickness"""
self.is_line_width_edit_slider_active = True
#name = self.active_key
line_width = self.line_width_slider_edit.value()
if not self.is_line_width_edit_active:
self.line_width_edit.setValue(line_width)
self.is_line_width_edit_slider_active = False
def on_point_size(self):
"""increases/decreases the point size"""
self.is_point_size_edit_active = True
name = self.active_key
point_size = self.point_size_edit.value()
self.out_data[name].point_size = point_size
if not self.is_point_size_edit_slider_active:
if self.use_slider:
self.point_size_slider_edit.setValue(point_size)
self.is_point_size_edit_active = False
self.on_apply(force=self.force)
self.is_point_size_edit_active = False
def on_point_size_slider(self):
"""increases/decreases the point size"""
self.is_point_size_edit_slider_active = True
#name = self.active_key
point_size = self.point_size_slider_edit.value()
if not self.is_point_size_edit_active:
self.point_size_edit.setValue(point_size)
self.is_point_size_edit_slider_active = False
def on_bar_scale(self):
"""
Vectors start at some xyz coordinate and can increase in length.
Increases/decreases the length scale factor.
"""
self.is_bar_scale_edit_active = True
name = self.active_key
float_bar_scale = self.bar_scale_edit.value()
self.out_data[name].bar_scale = float_bar_scale
if not self.is_bar_scale_edit_slider_active:
#int_bar_scale = int(round(float_bar_scale * 20, 0))
#if self.use_slider:
#self.bar_scale_slider_edit.setValue(int_bar_scale)
self.is_bar_scale_edit_active = False
self.on_apply(force=self.force)
self.is_bar_scale_edit_active = False
def on_bar_scale_slider(self):
"""
Vectors start at some xyz coordinate and can increase in length.
Increases/decreases the length scale factor.
"""
self.is_bar_scale_edit_slider_active = True
#name = self.active_key
int_bar_scale = self.bar_scale_slider_edit.value()
if not self.is_bar_scale_edit_active:
float_bar_scale = int_bar_scale / 20.
self.bar_scale_edit.setValue(float_bar_scale)
self.is_bar_scale_edit_slider_active = False
def on_opacity(self):
"""
opacity = 1.0 (solid/opaque)
opacity = 0.0 (invisible)
"""
self.is_opacity_edit_active = True
name = self.active_key
float_opacity = self.opacity_edit.value()
self.out_data[name].opacity = float_opacity
if not self.is_opacity_edit_slider_active:
int_opacity = int(round(float_opacity * 10, 0))
if self.use_slider:
self.opacity_slider_edit.setValue(int_opacity)
self.is_opacity_edit_active = False
self.on_apply(force=self.force)
self.is_opacity_edit_active = False
def on_opacity_slider(self):
"""
opacity = 1.0 (solid/opaque)
opacity = 0.0 (invisible)
"""
self.is_opacity_edit_slider_active = True
#name = self.active_key
int_opacity = self.opacity_slider_edit.value()
if not self.is_opacity_edit_active:
float_opacity = int_opacity / 10.
self.opacity_edit.setValue(float_opacity)
self.is_opacity_edit_slider_active = False
def on_validate(self):
self.out_data['clicked_ok'] = True
self.out_data['clicked_cancel'] = False
old_obj = self.out_data[self.active_key]
old_obj.line_width = self.line_width_edit.value()
old_obj.point_size = self.point_size_edit.value()
old_obj.bar_scale = self.bar_scale_edit.value()
old_obj.opacity = self.opacity_edit.value()
#old_obj.color = self.color_edit
old_obj.is_visible = self.checkbox_show.isChecked()
return True
#name_value, flag0 = self.check_name(self.name_edit)
#ox_value, flag1 = check_float(self.transparency_edit)
#if flag0 and flag1:
#self.out_data['clicked_ok'] = True
#return True
#return False
@property
def is_gui(self):
return hasattr(self.win_parent, 'on_update_geometry_properties')
def on_apply(self, force=False):
passed = self.on_validate()
#print("passed=%s force=%s allow=%s" % (passed, force, self.allow_update))
if (passed or force) and self.allow_update and self.is_gui:
#print('obj = %s' % self.out_data[self.active_key])
self.win_parent.on_update_geometry_properties(self.out_data,
name=self.active_key)
return passed
def on_cancel(self):
passed = self.on_apply(force=True)
if passed:
self.close()
class MainMenu(BaseMainMenu):
def __init__(self, settings: PartSettings, main_window):
super().__init__(settings, main_window)
self.settings = settings
self.open_btn = QPushButton("Open")
self.save_btn = QPushButton("Save")
self.advanced_btn = QPushButton("Settings and Measurement")
self.mask_manager_btn = QPushButton("Mask manager")
self.batch_processing_btn = QPushButton("Batch Processing")
layout = QHBoxLayout()
# layout.setSpacing(0)
layout.setContentsMargins(0, 0, 4, 4)
layout.addWidget(self.open_btn)
layout.addWidget(self.save_btn)
layout.addWidget(self.advanced_btn)
layout.addWidget(self.mask_manager_btn)
layout.addWidget(self.batch_processing_btn)
self.setLayout(layout)
self.open_btn.clicked.connect(self.load_data)
self.save_btn.clicked.connect(self.save_file)
self.advanced_btn.clicked.connect(self.advanced_window_show)
self.mask_manager_btn.clicked.connect(self.mask_manager)
self.batch_processing_btn.clicked.connect(self.batch_window)
self.setFocusPolicy(Qt.StrongFocus)
# self.test_btn.clicked.connect(self.test_fun)
def resizeEvent(self, event: QResizeEvent):
if event.size().width() < 800:
self.batch_processing_btn.hide()
else:
self.batch_processing_btn.show()
def keyPressEvent(self, event: QKeyEvent):
if event.matches(QKeySequence.Save):
self.save_file()
elif event.matches(QKeySequence.Open):
self.load_data()
super().keyPressEvent(event)
def save_file(self):
base_values = self.settings.get("save_parameters", {})
dial = PSaveDialog(
save_dict,
system_widget=False,
base_values=base_values,
settings=self.settings,
path=IO_SAVE_DIRECTORY,
filter_path="io.save_filter",
)
dial.selectFile(
os.path.splitext(os.path.basename(self.settings.image_path))[0])
if dial.exec_():
save_location, selected_filter, save_class, values = dial.get_result(
)
project_info = self.settings.get_project_info()
base_values[selected_filter] = values
def exception_hook(exception):
if isinstance(exception, ValueError):
show_warning("Save error",
f"Error during saving\n{exception}")
else:
raise exception
dial2 = ExecuteFunctionDialog(
save_class.save, [save_location, project_info, values],
exception_hook=exception_hook)
dial2.exec_()
def mask_manager(self):
if self.settings.roi is None:
QMessageBox.information(self, "No segmentation",
"Cannot create mask without segmentation")
return
dial = MaskDialog(self.settings)
dial.exec_()
def load_data(self):
def exception_hook(exception):
if isinstance(exception, WrongFileTypeException):
show_warning(
OPEN_ERROR,
"No needed files inside archive. Most probably you choose file from segmentation mask",
)
else:
load_data_exception_hook(exception)
try:
dial = PLoadDialog(load_functions.load_dict,
settings=self.settings,
path=OPEN_DIRECTORY,
filter_path=OPEN_FILE_FILTER)
file_path = self.settings.get(OPEN_FILE, "")
if os.path.isfile(file_path):
dial.selectFile(file_path)
if dial.exec_():
result = dial.get_result()
self.settings.set(OPEN_FILE, result.load_location[0])
self.settings.add_last_files(result.load_location,
result.load_class.get_name())
dial2 = ExecuteFunctionDialog(
result.load_class.load,
[result.load_location],
{
"metadata": {
"default_spacing": self.settings.image_spacing
}
},
exception_hook=exception_hook,
)
if dial2.exec_():
result = dial2.get_result()
self.set_data(result)
except ValueError as e:
show_warning("Open error", f"{e}")
def batch_window(self):
if self.main_window.batch_window is None:
self.main_window.batch_window = BatchWindow(self.settings)
self.main_window.batch_window.show()
elif self.main_window.batch_window.isVisible():
self.main_window.batch_window.activateWindow()
else:
self.main_window.batch_window.show()
def advanced_window_show(self):
if self.main_window.advanced_window.isVisible():
self.main_window.advanced_window.activateWindow()
else:
self.main_window.advanced_window.show()
class TimeChartDisplay(Display):
def __init__(self,
parent=None,
args=[],
macros=None,
show_pv_add_panel=True,
config_file=None):
"""
Create all the widgets, including any child dialogs.
Parameters
----------
parent : QWidget
The parent widget of the charting display
args : list
The command parameters
macros : str
Macros to modify the UI parameters at runtime
show_pv_add_panel : bool
Whether or not to show the PV add panel on top of the graph
"""
super(TimeChartDisplay, self).__init__(parent=parent,
args=args,
macros=macros)
self.legend_font = None
self.channel_map = dict()
self.setWindowTitle("TimeChart Tool")
self.main_layout = QVBoxLayout()
self.body_layout = QVBoxLayout()
self.pv_add_panel = QFrame()
self.pv_add_panel.setVisible(show_pv_add_panel)
self.pv_add_panel.setMaximumHeight(50)
self.pv_layout = QHBoxLayout()
self.pv_name_line_edt = QLineEdit()
self.pv_name_line_edt.setAcceptDrops(True)
self.pv_name_line_edt.returnPressed.connect(self.add_curve)
self.pv_protocol_cmb = QComboBox()
self.pv_protocol_cmb.addItems(["ca://", "archive://"])
self.pv_protocol_cmb.setEnabled(False)
self.pv_connect_push_btn = QPushButton("Connect")
self.pv_connect_push_btn.clicked.connect(self.add_curve)
self.tab_panel = QTabWidget()
self.tab_panel.setMinimumWidth(350)
self.tab_panel.setMaximumWidth(350)
self.curve_settings_tab = QWidget()
self.data_settings_tab = QWidget()
self.chart_settings_tab = QWidget()
self.charting_layout = QHBoxLayout()
self.chart = PyDMTimePlot(plot_by_timestamps=False)
self.chart.setDownsampling(ds=False, auto=False, mode=None)
self.chart.plot_redrawn_signal.connect(self.update_curve_data)
self.chart.setBufferSize(DEFAULT_BUFFER_SIZE)
self.chart.setPlotTitle(DEFAULT_CHART_TITLE)
self.splitter = QSplitter()
self.curve_settings_layout = QVBoxLayout()
self.curve_settings_layout.setAlignment(Qt.AlignTop)
self.curve_settings_layout.setSizeConstraint(QLayout.SetMinAndMaxSize)
self.curve_settings_layout.setSpacing(5)
self.crosshair_settings_layout = QVBoxLayout()
self.crosshair_settings_layout.setAlignment(Qt.AlignTop)
self.crosshair_settings_layout.setSpacing(5)
self.enable_crosshair_chk = QCheckBox("Crosshair")
self.crosshair_coord_lbl = QLabel()
self.crosshair_coord_lbl.setWordWrap(True)
self.curve_settings_inner_frame = QFrame()
self.curve_settings_inner_frame.setLayout(self.curve_settings_layout)
self.curve_settings_scroll = QScrollArea()
self.curve_settings_scroll.setVerticalScrollBarPolicy(
Qt.ScrollBarAsNeeded)
self.curve_settings_scroll.setHorizontalScrollBarPolicy(
Qt.ScrollBarAlwaysOff)
self.curve_settings_scroll.setWidget(self.curve_settings_inner_frame)
self.curve_settings_scroll.setWidgetResizable(True)
self.enable_crosshair_chk.setChecked(False)
self.enable_crosshair_chk.clicked.connect(
self.handle_enable_crosshair_checkbox_clicked)
self.enable_crosshair_chk.clicked.emit(False)
self.curves_tab_layout = QHBoxLayout()
self.curves_tab_layout.addWidget(self.curve_settings_scroll)
self.data_tab_layout = QVBoxLayout()
self.data_tab_layout.setAlignment(Qt.AlignTop)
self.data_tab_layout.setSpacing(5)
self.chart_settings_layout = QVBoxLayout()
self.chart_settings_layout.setAlignment(Qt.AlignTop)
self.chart_settings_layout.setSpacing(5)
self.chart_layout = QVBoxLayout()
self.chart_layout.setSpacing(10)
self.chart_panel = QWidget()
self.chart_panel.setMinimumHeight(400)
self.chart_control_layout = QHBoxLayout()
self.chart_control_layout.setAlignment(Qt.AlignHCenter)
self.chart_control_layout.setSpacing(10)
self.zoom_x_layout = QVBoxLayout()
self.zoom_x_layout.setAlignment(Qt.AlignTop)
self.zoom_x_layout.setSpacing(5)
self.plus_icon = IconFont().icon("plus", color=QColor("green"))
self.minus_icon = IconFont().icon("minus", color=QColor("red"))
self.view_all_icon = IconFont().icon("globe", color=QColor("blue"))
self.reset_icon = IconFont().icon("circle-o-notch",
color=QColor("green"))
self.zoom_in_x_btn = QPushButton("X Zoom")
self.zoom_in_x_btn.setIcon(self.plus_icon)
self.zoom_in_x_btn.clicked.connect(
partial(self.handle_zoom_in_btn_clicked, "x", True))
self.zoom_in_x_btn.setEnabled(False)
self.zoom_out_x_btn = QPushButton("X Zoom")
self.zoom_out_x_btn.setIcon(self.minus_icon)
self.zoom_out_x_btn.clicked.connect(
partial(self.handle_zoom_in_btn_clicked, "x", False))
self.zoom_out_x_btn.setEnabled(False)
self.zoom_y_layout = QVBoxLayout()
self.zoom_y_layout.setAlignment(Qt.AlignTop)
self.zoom_y_layout.setSpacing(5)
self.zoom_in_y_btn = QPushButton("Y Zoom")
self.zoom_in_y_btn.setIcon(self.plus_icon)
self.zoom_in_y_btn.clicked.connect(
partial(self.handle_zoom_in_btn_clicked, "y", True))
self.zoom_in_y_btn.setEnabled(False)
self.zoom_out_y_btn = QPushButton("Y Zoom")
self.zoom_out_y_btn.setIcon(self.minus_icon)
self.zoom_out_y_btn.clicked.connect(
partial(self.handle_zoom_in_btn_clicked, "y", False))
self.zoom_out_y_btn.setEnabled(False)
self.view_all_btn = QPushButton("View All")
self.view_all_btn.setIcon(self.view_all_icon)
self.view_all_btn.clicked.connect(self.handle_view_all_button_clicked)
self.view_all_btn.setEnabled(False)
self.view_all_reset_chart_layout = QVBoxLayout()
self.view_all_reset_chart_layout.setAlignment(Qt.AlignTop)
self.view_all_reset_chart_layout.setSpacing(5)
self.pause_chart_layout = QVBoxLayout()
self.pause_chart_layout.setAlignment(Qt.AlignTop)
self.pause_chart_layout.setSpacing(5)
self.reset_chart_btn = QPushButton("Reset")
self.reset_chart_btn.setIcon(self.reset_icon)
self.reset_chart_btn.clicked.connect(
self.handle_reset_chart_btn_clicked)
self.reset_chart_btn.setEnabled(False)
self.pause_icon = IconFont().icon("pause", color=QColor("red"))
self.play_icon = IconFont().icon("play", color=QColor("green"))
self.pause_chart_btn = QPushButton()
self.pause_chart_btn.setIcon(self.pause_icon)
self.pause_chart_btn.clicked.connect(
self.handle_pause_chart_btn_clicked)
self.title_settings_layout = QVBoxLayout()
self.title_settings_layout.setAlignment(Qt.AlignTop)
self.title_settings_layout.setSpacing(5)
self.title_settings_grpbx = QGroupBox("Title and Legend")
self.title_settings_grpbx.setMaximumHeight(120)
self.import_export_data_layout = QVBoxLayout()
self.import_export_data_layout.setAlignment(Qt.AlignTop)
self.import_export_data_layout.setSpacing(5)
self.import_data_btn = QPushButton("Import...")
self.import_data_btn.clicked.connect(
self.handle_import_data_btn_clicked)
self.export_data_btn = QPushButton("Export...")
self.export_data_btn.clicked.connect(
self.handle_export_data_btn_clicked)
self.chart_title_layout = QHBoxLayout()
self.chart_title_layout.setSpacing(10)
self.chart_title_lbl = QLabel(text="Graph Title")
self.chart_title_line_edt = QLineEdit()
self.chart_title_line_edt.setText(self.chart.getPlotTitle())
self.chart_title_line_edt.textChanged.connect(
self.handle_title_text_changed)
self.chart_title_font_btn = QPushButton()
self.chart_title_font_btn.setFixedHeight(24)
self.chart_title_font_btn.setFixedWidth(24)
self.chart_title_font_btn.setIcon(IconFont().icon("font"))
self.chart_title_font_btn.clicked.connect(
partial(self.handle_chart_font_changed, "title"))
self.chart_change_axis_settings_btn = QPushButton(
text="Change Axis Settings...")
self.chart_change_axis_settings_btn.clicked.connect(
self.handle_change_axis_settings_clicked)
self.update_datetime_timer = QTimer(self)
self.update_datetime_timer.timeout.connect(
self.handle_update_datetime_timer_timeout)
self.chart_sync_mode_layout = QVBoxLayout()
self.chart_sync_mode_layout.setSpacing(5)
self.chart_sync_mode_grpbx = QGroupBox("Data Sampling Mode")
self.chart_sync_mode_grpbx.setMaximumHeight(100)
self.chart_sync_mode_sync_radio = QRadioButton("Synchronous")
self.chart_sync_mode_async_radio = QRadioButton("Asynchronous")
self.chart_sync_mode_async_radio.setChecked(True)
self.graph_drawing_settings_layout = QVBoxLayout()
self.graph_drawing_settings_layout.setAlignment(Qt.AlignVCenter)
self.chart_interval_layout = QFormLayout()
self.chart_redraw_rate_lbl = QLabel("Redraw Rate (Hz)")
self.chart_redraw_rate_spin = QSpinBox()
self.chart_redraw_rate_spin.setRange(MIN_REDRAW_RATE_HZ,
MAX_REDRAW_RATE_HZ)
self.chart_redraw_rate_spin.setValue(DEFAULT_REDRAW_RATE_HZ)
self.chart_redraw_rate_spin.editingFinished.connect(
self.handle_redraw_rate_changed)
self.chart_data_sampling_rate_lbl = QLabel("Data Sampling Rate (Hz)")
self.chart_data_async_sampling_rate_spin = QSpinBox()
self.chart_data_async_sampling_rate_spin.setRange(
MIN_DATA_SAMPLING_RATE_HZ, MAX_DATA_SAMPLING_RATE_HZ)
self.chart_data_async_sampling_rate_spin.setValue(
DEFAULT_DATA_SAMPLING_RATE_HZ)
self.chart_data_async_sampling_rate_spin.editingFinished.connect(
self.handle_data_sampling_rate_changed)
self.chart_data_sampling_rate_lbl.hide()
self.chart_data_async_sampling_rate_spin.hide()
self.chart_limit_time_span_layout = QHBoxLayout()
self.chart_limit_time_span_layout.setSpacing(5)
self.limit_time_plan_text = "Limit Time Span"
self.chart_limit_time_span_chk = QCheckBox(self.limit_time_plan_text)
self.chart_limit_time_span_chk.hide()
self.chart_limit_time_span_lbl = QLabel("Hr:Min:Sec")
self.chart_limit_time_span_hours_spin_box = QSpinBox()
self.chart_limit_time_span_hours_spin_box.setMaximum(999)
self.chart_limit_time_span_minutes_spin_box = QSpinBox()
self.chart_limit_time_span_minutes_spin_box.setMaximum(59)
self.chart_limit_time_span_seconds_spin_box = QSpinBox()
self.chart_limit_time_span_seconds_spin_box.setMaximum(59)
self.chart_limit_time_span_activate_btn = QPushButton("Apply")
self.chart_limit_time_span_activate_btn.setDisabled(True)
self.chart_ring_buffer_layout = QFormLayout()
self.chart_ring_buffer_size_lbl = QLabel("Ring Buffer Size")
self.chart_ring_buffer_size_edt = QLineEdit()
self.chart_ring_buffer_size_edt.returnPressed.connect(
self.handle_buffer_size_changed)
self.chart_ring_buffer_size_edt.setText(str(DEFAULT_BUFFER_SIZE))
self.show_legend_chk = QCheckBox("Show Legend")
self.show_legend_chk.clicked.connect(
self.handle_show_legend_checkbox_clicked)
self.show_legend_chk.setChecked(self.chart.showLegend)
self.legend_font_btn = QPushButton()
self.legend_font_btn.setFixedHeight(24)
self.legend_font_btn.setFixedWidth(24)
self.legend_font_btn.setIcon(IconFont().icon("font"))
self.legend_font_btn.clicked.connect(
partial(self.handle_chart_font_changed, "legend"))
self.graph_background_color_layout = QFormLayout()
self.axis_grid_color_layout = QFormLayout()
self.background_color_lbl = QLabel("Graph Background Color ")
self.background_color_btn = QPushButton()
self.background_color_btn.setStyleSheet(
"background-color: " + self.chart.getBackgroundColor().name())
self.background_color_btn.setContentsMargins(10, 0, 5, 5)
self.background_color_btn.setMaximumWidth(20)
self.background_color_btn.clicked.connect(
self.handle_background_color_button_clicked)
self.axis_settings_layout = QVBoxLayout()
self.axis_settings_layout.setSpacing(10)
self.show_x_grid_chk = QCheckBox("Show x Grid")
self.show_x_grid_chk.setChecked(self.chart.showXGrid)
self.show_x_grid_chk.clicked.connect(
self.handle_show_x_grid_checkbox_clicked)
self.show_y_grid_chk = QCheckBox("Show y Grid")
self.show_y_grid_chk.setChecked(self.chart.showYGrid)
self.show_y_grid_chk.clicked.connect(
self.handle_show_y_grid_checkbox_clicked)
self.axis_color_lbl = QLabel("Axis and Grid Color")
self.axis_color_btn = QPushButton()
self.axis_color_btn.setStyleSheet("background-color: " +
DEFAULT_CHART_AXIS_COLOR.name())
self.axis_color_btn.setContentsMargins(10, 0, 5, 5)
self.axis_color_btn.setMaximumWidth(20)
self.axis_color_btn.clicked.connect(
self.handle_axis_color_button_clicked)
self.grid_opacity_lbl = QLabel("Grid Opacity")
self.grid_opacity_lbl.setEnabled(False)
self.grid_opacity_slr = QSlider(Qt.Horizontal)
self.grid_opacity_slr.setFocusPolicy(Qt.StrongFocus)
self.grid_opacity_slr.setRange(0, 10)
self.grid_opacity_slr.setValue(5)
self.grid_opacity_slr.setTickInterval(1)
self.grid_opacity_slr.setSingleStep(1)
self.grid_opacity_slr.setTickPosition(QSlider.TicksBelow)
self.grid_opacity_slr.valueChanged.connect(
self.handle_grid_opacity_slider_mouse_release)
self.grid_opacity_slr.setEnabled(False)
self.reset_data_settings_btn = QPushButton("Reset Data Settings")
self.reset_data_settings_btn.clicked.connect(
self.handle_reset_data_settings_btn_clicked)
self.reset_chart_settings_btn = QPushButton("Reset Chart Settings")
self.reset_chart_settings_btn.clicked.connect(
self.handle_reset_chart_settings_btn_clicked)
self.curve_checkbox_panel = QWidget()
self.graph_drawing_settings_grpbx = QGroupBox("Graph Intervals")
self.graph_drawing_settings_grpbx.setAlignment(Qt.AlignTop)
self.axis_settings_grpbx = QGroupBox("Graph Appearance")
self.app = QApplication.instance()
self.setup_ui()
self.curve_settings_disp = None
self.axis_settings_disp = None
self.chart_data_export_disp = None
self.chart_data_import_disp = None
self.grid_alpha = 5
self.time_span_limit_hours = None
self.time_span_limit_minutes = None
self.time_span_limit_seconds = None
self.data_sampling_mode = ASYNC_DATA_SAMPLING
# If there is an imported config file, let's start TimeChart with the imported configuration data
if config_file:
importer = SettingsImporter(self)
try:
importer.import_settings(config_file)
except SettingsImporterException:
display_message_box(
QMessageBox.Critical, "Import Failure",
"Cannot import the file '{0}'. Check the log for the error details."
.format(config_file))
logger.exception(
"Cannot import the file '{0}'.".format(config_file))
def ui_filepath(self):
"""
The path to the UI file created by Qt Designer, if applicable.
"""
# No UI file is being used
return None
def ui_filename(self):
"""
The name the UI file created by Qt Designer, if applicable.
"""
# No UI file is being used
return None
def setup_ui(self):
"""
Initialize the widgets and layouts.
"""
self.setLayout(self.main_layout)
self.pv_layout.addWidget(self.pv_protocol_cmb)
self.pv_layout.addWidget(self.pv_name_line_edt)
self.pv_layout.addWidget(self.pv_connect_push_btn)
self.pv_add_panel.setLayout(self.pv_layout)
QTimer.singleShot(0, self.pv_name_line_edt.setFocus)
self.curve_settings_tab.setLayout(self.curves_tab_layout)
self.chart_settings_tab.setLayout(self.chart_settings_layout)
self.setup_chart_settings_layout()
self.data_settings_tab.setLayout(self.data_tab_layout)
self.setup_data_tab_layout()
self.tab_panel.addTab(self.curve_settings_tab, "Curves")
self.tab_panel.addTab(self.data_settings_tab, "Data")
self.tab_panel.addTab(self.chart_settings_tab, "Graph")
self.crosshair_settings_layout.addWidget(self.enable_crosshair_chk)
self.crosshair_settings_layout.addWidget(self.crosshair_coord_lbl)
self.zoom_x_layout.addWidget(self.zoom_in_x_btn)
self.zoom_x_layout.addWidget(self.zoom_out_x_btn)
self.zoom_y_layout.addWidget(self.zoom_in_y_btn)
self.zoom_y_layout.addWidget(self.zoom_out_y_btn)
self.view_all_reset_chart_layout.addWidget(self.reset_chart_btn)
self.view_all_reset_chart_layout.addWidget(self.view_all_btn)
self.pause_chart_layout.addWidget(self.pause_chart_btn)
self.import_export_data_layout.addWidget(self.import_data_btn)
self.import_export_data_layout.addWidget(self.export_data_btn)
self.chart_control_layout.addLayout(self.zoom_x_layout)
self.chart_control_layout.addLayout(self.zoom_y_layout)
self.chart_control_layout.addLayout(self.view_all_reset_chart_layout)
self.chart_control_layout.addLayout(self.pause_chart_layout)
self.chart_control_layout.addLayout(self.crosshair_settings_layout)
self.chart_control_layout.addLayout(self.import_export_data_layout)
self.chart_control_layout.insertSpacing(5, 30)
self.chart_layout.addWidget(self.chart)
self.chart_layout.addLayout(self.chart_control_layout)
self.chart_panel.setLayout(self.chart_layout)
self.splitter.addWidget(self.chart_panel)
self.splitter.addWidget(self.tab_panel)
self.splitter.setSizes([1, 0])
self.splitter.setHandleWidth(10)
self.splitter.setStretchFactor(0, 0)
self.splitter.setStretchFactor(1, 1)
self.charting_layout.addWidget(self.splitter)
self.body_layout.addWidget(self.pv_add_panel)
self.body_layout.addLayout(self.charting_layout)
self.body_layout.setSpacing(0)
self.body_layout.setContentsMargins(0, 0, 0, 0)
self.main_layout.addLayout(self.body_layout)
self.enable_chart_control_buttons(False)
handle = self.splitter.handle(1)
layout = QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
button = QToolButton(handle)
button.setArrowType(Qt.LeftArrow)
button.clicked.connect(lambda: self.handle_splitter_button(True))
layout.addWidget(button)
button = QToolButton(handle)
button.setArrowType(Qt.RightArrow)
button.clicked.connect(lambda: self.handle_splitter_button(False))
layout.addWidget(button)
handle.setLayout(layout)
def handle_splitter_button(self, left=True):
if left:
self.splitter.setSizes([1, 1])
else:
self.splitter.setSizes([1, 0])
def change_legend_font(self, font):
if font is None:
return
self.legend_font = font
items = self.chart.plotItem.legend.items
for i in items:
i[1].item.setFont(font)
i[1].resizeEvent(None)
i[1].updateGeometry()
def change_title_font(self, font):
current_text = self.chart.plotItem.titleLabel.text
args = {
"family": font.family,
"size": "{}pt".format(font.pointSize()),
"bold": font.bold(),
"italic": font.italic(),
}
self.chart.plotItem.titleLabel.setText(current_text, **args)
def handle_chart_font_changed(self, target):
if target not in ("title", "legend"):
return
dialog = QFontDialog(self)
dialog.setOption(QFontDialog.DontUseNativeDialog, True)
if target == "title":
dialog.fontSelected.connect(self.change_title_font)
else:
dialog.fontSelected.connect(self.change_legend_font)
dialog.open()
def setup_data_tab_layout(self):
self.chart_sync_mode_sync_radio.toggled.connect(
partial(self.handle_sync_mode_radio_toggle,
self.chart_sync_mode_sync_radio))
self.chart_sync_mode_async_radio.toggled.connect(
partial(self.handle_sync_mode_radio_toggle,
self.chart_sync_mode_async_radio))
self.chart_sync_mode_layout.addWidget(self.chart_sync_mode_sync_radio)
self.chart_sync_mode_layout.addWidget(self.chart_sync_mode_async_radio)
self.chart_sync_mode_grpbx.setLayout(self.chart_sync_mode_layout)
self.data_tab_layout.addWidget(self.chart_sync_mode_grpbx)
self.chart_limit_time_span_layout.addWidget(
self.chart_limit_time_span_lbl)
self.chart_limit_time_span_layout.addWidget(
self.chart_limit_time_span_hours_spin_box)
self.chart_limit_time_span_layout.addWidget(
self.chart_limit_time_span_minutes_spin_box)
self.chart_limit_time_span_layout.addWidget(
self.chart_limit_time_span_seconds_spin_box)
self.chart_limit_time_span_layout.addWidget(
self.chart_limit_time_span_activate_btn)
self.chart_limit_time_span_lbl.hide()
self.chart_limit_time_span_hours_spin_box.hide()
self.chart_limit_time_span_minutes_spin_box.hide()
self.chart_limit_time_span_seconds_spin_box.hide()
self.chart_limit_time_span_activate_btn.hide()
self.chart_limit_time_span_hours_spin_box.valueChanged.connect(
self.handle_time_span_changed)
self.chart_limit_time_span_minutes_spin_box.valueChanged.connect(
self.handle_time_span_changed)
self.chart_limit_time_span_seconds_spin_box.valueChanged.connect(
self.handle_time_span_changed)
self.chart_limit_time_span_chk.clicked.connect(
self.handle_limit_time_span_checkbox_clicked)
self.chart_limit_time_span_activate_btn.clicked.connect(
self.handle_chart_limit_time_span_activate_btn_clicked)
self.chart_interval_layout.addRow(self.chart_redraw_rate_lbl,
self.chart_redraw_rate_spin)
self.chart_interval_layout.addRow(
self.chart_data_sampling_rate_lbl,
self.chart_data_async_sampling_rate_spin)
self.graph_drawing_settings_layout.addLayout(
self.chart_interval_layout)
self.graph_drawing_settings_layout.addWidget(
self.chart_limit_time_span_chk)
self.graph_drawing_settings_layout.addLayout(
self.chart_limit_time_span_layout)
self.chart_ring_buffer_layout.addRow(self.chart_ring_buffer_size_lbl,
self.chart_ring_buffer_size_edt)
self.graph_drawing_settings_layout.addLayout(
self.chart_ring_buffer_layout)
self.graph_drawing_settings_grpbx.setLayout(
self.graph_drawing_settings_layout)
self.data_tab_layout.addWidget(self.graph_drawing_settings_grpbx)
self.chart_sync_mode_async_radio.toggled.emit(True)
self.data_tab_layout.addWidget(self.reset_data_settings_btn)
def setup_chart_settings_layout(self):
self.chart_title_layout.addWidget(self.chart_title_lbl)
self.chart_title_layout.addWidget(self.chart_title_line_edt)
self.chart_title_layout.addWidget(self.chart_title_font_btn)
self.title_settings_layout.addLayout(self.chart_title_layout)
legend_layout = QHBoxLayout()
legend_layout.addWidget(self.show_legend_chk)
legend_layout.addWidget(self.legend_font_btn)
self.title_settings_layout.addLayout(legend_layout)
self.title_settings_layout.addWidget(
self.chart_change_axis_settings_btn)
self.title_settings_grpbx.setLayout(self.title_settings_layout)
self.chart_settings_layout.addWidget(self.title_settings_grpbx)
self.graph_background_color_layout.addRow(self.background_color_lbl,
self.background_color_btn)
self.axis_settings_layout.addLayout(self.graph_background_color_layout)
self.axis_grid_color_layout.addRow(self.axis_color_lbl,
self.axis_color_btn)
self.axis_settings_layout.addLayout(self.axis_grid_color_layout)
self.axis_settings_layout.addWidget(self.show_x_grid_chk)
self.axis_settings_layout.addWidget(self.show_y_grid_chk)
self.axis_settings_layout.addWidget(self.grid_opacity_lbl)
self.axis_settings_layout.addWidget(self.grid_opacity_slr)
self.axis_settings_grpbx.setLayout(self.axis_settings_layout)
self.chart_settings_layout.addWidget(self.axis_settings_grpbx)
self.chart_settings_layout.addWidget(self.reset_chart_settings_btn)
self.update_datetime_timer.start(1000)
def add_curve(self):
"""
Add a new curve to the chart.
"""
pv_name = self._get_full_pv_name(self.pv_name_line_edt.text())
if pv_name and len(pv_name):
color = random_color(curve_colors_only=True)
for k, v in self.channel_map.items():
if color == v.color:
color = random_color(curve_colors_only=True)
self.add_y_channel(pv_name=pv_name,
curve_name=pv_name,
color=color)
self.handle_splitter_button(left=True)
def show_mouse_coordinates(self, x, y):
self.crosshair_coord_lbl.clear()
self.crosshair_coord_lbl.setText("x = {0:.3f}\ny = {1:.3f}".format(
x, y))
def handle_enable_crosshair_checkbox_clicked(self, is_checked):
self.chart.enableCrosshair(is_checked)
self.crosshair_coord_lbl.setVisible(is_checked)
self.chart.crosshair_position_updated.connect(
self.show_mouse_coordinates)
def add_y_channel(self,
pv_name,
curve_name,
color,
line_style=Qt.SolidLine,
line_width=2,
symbol=None,
symbol_size=None,
is_visible=True):
if pv_name in self.channel_map:
logger.error("'{0}' has already been added.".format(pv_name))
return
curve = self.chart.addYChannel(y_channel=pv_name,
name=curve_name,
color=color,
lineStyle=line_style,
lineWidth=line_width,
symbol=symbol,
symbolSize=symbol_size)
curve.show() if is_visible else curve.hide()
if self.show_legend_chk.isChecked():
self.change_legend_font(self.legend_font)
self.channel_map[pv_name] = curve
self.generate_pv_controls(pv_name, color)
self.enable_chart_control_buttons()
try:
self.app.add_connection(curve.channel)
except AttributeError:
# these methods are not needed on future versions of pydm
pass
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 handle_curve_chkbox_toggled(self, checkbox):
"""
Handle a checkbox's checked and unchecked events.
If a checkbox is checked, find the curve from the channel map. If found, re-draw the curve with its previous
appearance settings.
If a checkbox is unchecked, remove the curve from the chart, but keep the cached data in the channel map.
Parameters
----------
checkbox : QCheckBox
The current checkbox being toggled
"""
pv_name = self._get_full_pv_name(checkbox.text())
if checkbox.isChecked():
curve = self.channel_map.get(pv_name, None)
if curve:
curve.show()
self.chart.addLegendItem(curve, pv_name,
self.show_legend_chk.isChecked())
self.change_legend_font(self.legend_font)
else:
curve = self.chart.findCurve(pv_name)
if curve:
curve.hide()
self.chart.removeLegendItem(pv_name)
def display_curve_settings_dialog(self, pv_name):
"""
Bring up the Curve Settings dialog to modify the appearance of a curve.
Parameters
----------
pv_name : str
The name of the PV the curve is being plotted for
"""
self.curve_settings_disp = CurveSettingsDisplay(self, pv_name)
self.curve_settings_disp.show()
def focus_curve(self, pv_name):
curve = self.chart.findCurve(pv_name)
if curve:
self.chart.plotItem.setYRange(curve.minY, curve.maxY, padding=0)
def clear_curve(self, pv_name):
curve = self.chart.findCurve(pv_name)
if curve:
curve.initialize_buffer()
def annotate_curve(self, pv_name):
curve = self.chart.findCurve(pv_name)
if curve:
annot = TextItem(
html=
'<div style="text-align: center"><span style="color: #FFF;">This is the'
'</span><br><span style="color: #FF0; font-size: 16pt;">PEAK</span></div>',
anchor=(-0.3, 0.5),
border='w',
fill=(0, 0, 255, 100))
self.chart.annotateCurve(curve, annot)
def remove_curve(self, pv_name):
"""
Remove a curve from the chart permanently. This will also clear the channel map cache from retaining the
removed curve's appearance settings.
Parameters
----------
pv_name : str
The name of the PV the curve is being plotted for
"""
curve = self.chart.findCurve(pv_name)
if curve:
try:
self.app.remove_connection(curve.channel)
except AttributeError:
# these methods are not needed on future versions of pydm
pass
self.chart.removeYChannel(curve)
del self.channel_map[pv_name]
self.chart.removeLegendItem(pv_name)
widget = self.findChild(QGroupBox, pv_name + "_grb")
if widget:
widget.deleteLater()
if len(self.chart.getCurves()) < 1:
self.enable_chart_control_buttons(False)
self.show_legend_chk.setChecked(False)
def handle_title_text_changed(self, new_text):
self.chart.setPlotTitle(new_text)
def handle_change_axis_settings_clicked(self):
self.axis_settings_disp = AxisSettingsDisplay(self)
self.axis_settings_disp.show()
def handle_limit_time_span_checkbox_clicked(self, is_checked):
self.chart_limit_time_span_lbl.setVisible(is_checked)
self.chart_limit_time_span_hours_spin_box.setVisible(is_checked)
self.chart_limit_time_span_minutes_spin_box.setVisible(is_checked)
self.chart_limit_time_span_seconds_spin_box.setVisible(is_checked)
self.chart_limit_time_span_activate_btn.setVisible(is_checked)
self.chart_ring_buffer_size_lbl.setDisabled(is_checked)
self.chart_ring_buffer_size_edt.setDisabled(is_checked)
if not is_checked:
self.chart_limit_time_span_chk.setText(self.limit_time_plan_text)
def handle_time_span_changed(self):
self.time_span_limit_hours = self.chart_limit_time_span_hours_spin_box.value(
)
self.time_span_limit_minutes = self.chart_limit_time_span_minutes_spin_box.value(
)
self.time_span_limit_seconds = self.chart_limit_time_span_seconds_spin_box.value(
)
status = self.time_span_limit_hours > 0 or self.time_span_limit_minutes > 0 or self.time_span_limit_seconds > 0
self.chart_limit_time_span_activate_btn.setEnabled(status)
def handle_chart_limit_time_span_activate_btn_clicked(self):
timeout_milliseconds = (self.time_span_limit_hours * 3600 +
self.time_span_limit_minutes * 60 +
self.time_span_limit_seconds) * 1000
self.chart.setTimeSpan(timeout_milliseconds / 1000.0)
self.chart_ring_buffer_size_edt.setText(str(
self.chart.getBufferSize()))
def handle_buffer_size_changed(self):
try:
new_buffer_size = int(self.chart_ring_buffer_size_edt.text())
if new_buffer_size and int(new_buffer_size) >= MINIMUM_BUFFER_SIZE:
self.chart.setBufferSize(new_buffer_size)
except ValueError:
display_message_box(QMessageBox.Critical, "Invalid Values",
"Only integer values are accepted.")
def handle_redraw_rate_changed(self):
self.chart.maxRedrawRate = self.chart_redraw_rate_spin.value()
def handle_data_sampling_rate_changed(self):
# The chart expects the value in milliseconds
sampling_rate_seconds = 1.0 / self.chart_data_async_sampling_rate_spin.value(
)
buffer_size = self.chart.getBufferSize()
self.chart.setUpdateInterval(sampling_rate_seconds)
if self.chart.getBufferSize() < buffer_size:
self.chart.setBufferSize(buffer_size)
self.chart_ring_buffer_size_edt.setText(str(
self.chart.getBufferSize()))
def handle_background_color_button_clicked(self):
selected_color = QColorDialog.getColor()
self.chart.setBackgroundColor(selected_color)
self.background_color_btn.setStyleSheet("background-color: " +
selected_color.name())
def handle_axis_color_button_clicked(self):
selected_color = QColorDialog.getColor()
self.chart.setAxisColor(selected_color)
self.axis_color_btn.setStyleSheet("background-color: " +
selected_color.name())
def handle_grid_opacity_slider_mouse_release(self):
self.grid_alpha = float(self.grid_opacity_slr.value()) / 10.0
self.chart.setShowXGrid(self.show_x_grid_chk.isChecked(),
self.grid_alpha)
self.chart.setShowYGrid(self.show_y_grid_chk.isChecked(),
self.grid_alpha)
def handle_show_x_grid_checkbox_clicked(self, is_checked):
self.chart.setShowXGrid(is_checked, self.grid_alpha)
self.grid_opacity_lbl.setEnabled(is_checked
or self.show_y_grid_chk.isChecked())
self.grid_opacity_slr.setEnabled(is_checked
or self.show_y_grid_chk.isChecked())
def handle_show_y_grid_checkbox_clicked(self, is_checked):
self.chart.setShowYGrid(is_checked, self.grid_alpha)
self.grid_opacity_lbl.setEnabled(is_checked
or self.show_x_grid_chk.isChecked())
self.grid_opacity_slr.setEnabled(is_checked
or self.show_x_grid_chk.isChecked())
def handle_show_legend_checkbox_clicked(self, is_checked):
self.chart.setShowLegend(is_checked)
def handle_export_data_btn_clicked(self):
self.chart_data_export_disp = ChartDataExportDisplay(self)
self.chart_data_export_disp.show()
def handle_import_data_btn_clicked(self):
open_file_info = QFileDialog.getOpenFileName(
self,
caption="Open File",
directory=os.path.expanduser('~'),
filter=IMPORT_FILE_FORMAT)
open_filename = open_file_info[0]
if open_filename:
try:
importer = SettingsImporter(self)
importer.import_settings(open_filename)
except SettingsImporterException:
display_message_box(
QMessageBox.Critical, "Import Failure",
"Cannot import the file '{0}'. Check the log for the error details."
.format(open_filename))
logger.exception(
"Cannot import the file '{0}'".format(open_filename))
def handle_sync_mode_radio_toggle(self, radio_btn):
if radio_btn.isChecked():
if radio_btn.text() == "Synchronous":
self.data_sampling_mode = SYNC_DATA_SAMPLING
self.chart_data_sampling_rate_lbl.hide()
self.chart_data_async_sampling_rate_spin.hide()
self.chart.resetTimeSpan()
self.chart_limit_time_span_chk.setChecked(False)
self.chart_limit_time_span_chk.clicked.emit(False)
self.chart_limit_time_span_chk.hide()
self.chart.setUpdatesAsynchronously(False)
elif radio_btn.text() == "Asynchronous":
self.data_sampling_mode = ASYNC_DATA_SAMPLING
self.chart_data_sampling_rate_lbl.show()
self.chart_data_async_sampling_rate_spin.show()
self.chart_limit_time_span_chk.show()
self.chart.setUpdatesAsynchronously(True)
def handle_zoom_in_btn_clicked(self, axis, is_zoom_in):
scale_factor = 0.5
if not is_zoom_in:
scale_factor += 1.0
if axis == "x":
self.chart.getViewBox().scaleBy(x=scale_factor)
elif axis == "y":
self.chart.getViewBox().scaleBy(y=scale_factor)
def handle_view_all_button_clicked(self):
self.chart.plotItem.getViewBox().autoRange()
def handle_pause_chart_btn_clicked(self):
if self.chart.pausePlotting():
self.pause_chart_btn.setIcon(self.pause_icon)
else:
self.pause_chart_btn.setIcon(self.play_icon)
def handle_reset_chart_btn_clicked(self):
self.chart.getViewBox().setXRange(DEFAULT_X_MIN, 0)
self.chart.resetAutoRangeY()
@Slot()
def handle_reset_chart_settings_btn_clicked(self):
self.chart.setBackgroundColor(DEFAULT_CHART_BACKGROUND_COLOR)
self.background_color_btn.setStyleSheet(
"background-color: " + DEFAULT_CHART_BACKGROUND_COLOR.name())
self.chart.setAxisColor(DEFAULT_CHART_AXIS_COLOR)
self.axis_color_btn.setStyleSheet("background-color: " +
DEFAULT_CHART_AXIS_COLOR.name())
self.grid_opacity_slr.setValue(5)
self.show_x_grid_chk.setChecked(False)
self.show_x_grid_chk.clicked.emit(False)
self.show_y_grid_chk.setChecked(False)
self.show_y_grid_chk.clicked.emit(False)
self.show_legend_chk.setChecked(False)
self.chart.setShowXGrid(False)
self.chart.setShowYGrid(False)
self.chart.setShowLegend(False)
@Slot()
def handle_reset_data_settings_btn_clicked(self):
self.chart_ring_buffer_size_edt.setText(str(DEFAULT_BUFFER_SIZE))
self.chart_redraw_rate_spin.setValue(DEFAULT_REDRAW_RATE_HZ)
self.handle_redraw_rate_changed()
self.chart_data_async_sampling_rate_spin.setValue(
DEFAULT_DATA_SAMPLING_RATE_HZ)
self.chart_data_sampling_rate_lbl.hide()
self.chart_data_async_sampling_rate_spin.hide()
self.chart_sync_mode_async_radio.setChecked(True)
self.chart_sync_mode_async_radio.toggled.emit(True)
self.chart_limit_time_span_chk.setChecked(False)
self.chart_limit_time_span_chk.setText(self.limit_time_plan_text)
self.chart_limit_time_span_chk.clicked.emit(False)
self.chart.setUpdatesAsynchronously(True)
self.chart.resetTimeSpan()
self.chart.resetUpdateInterval()
self.chart.setBufferSize(DEFAULT_BUFFER_SIZE)
def enable_chart_control_buttons(self, enabled=True):
self.zoom_in_x_btn.setEnabled(enabled)
self.zoom_out_x_btn.setEnabled(enabled)
self.zoom_in_y_btn.setEnabled(enabled)
self.zoom_out_y_btn.setEnabled(enabled)
self.view_all_btn.setEnabled(enabled)
self.reset_chart_btn.setEnabled(enabled)
self.pause_chart_btn.setIcon(self.pause_icon)
self.pause_chart_btn.setEnabled(enabled)
self.export_data_btn.setEnabled(enabled)
def _get_full_pv_name(self, pv_name):
"""
Append the protocol to the PV Name.
Parameters
----------
pv_name : str
The name of the PV the curve is being plotted for
"""
if pv_name and "://" not in pv_name:
pv_name = ''.join([self.pv_protocol_cmb.currentText(), pv_name])
return pv_name
def handle_update_datetime_timer_timeout(self):
current_label = self.chart.getBottomAxisLabel()
new_label = "Current Time: " + TimeChartDisplay.get_current_datetime()
if X_AXIS_LABEL_SEPARATOR in current_label:
current_label = current_label[current_label.
find(X_AXIS_LABEL_SEPARATOR) +
len(X_AXIS_LABEL_SEPARATOR):]
new_label += X_AXIS_LABEL_SEPARATOR + current_label
self.chart.setLabel("bottom", text=new_label)
def update_curve_data(self, curve):
"""
Determine if the PV is active. If not, disable the related PV controls.
If the PV is active, update the PV controls' states.
Parameters
----------
curve : PlotItem
A PlotItem, i.e. a plot, to draw on the chart.
"""
pv_name = curve.address
min_y = curve.minY if curve.minY else 0
max_y = curve.maxY if curve.maxY else 0
current_y = curve.data_buffer[1, -1]
grb = self.findChild(QGroupBox, pv_name + "_grb")
lbl = grb.findChild(QLabel, pv_name + "_lbl")
lbl.setText("(yMin = {0:.3f}, yMax = {1:.3f}) y = {2:.3f}".format(
min_y, max_y, current_y))
chb = grb.findChild(QCheckBox, pv_name + "_chb")
connected = curve.connected
if connected and chb.isEnabled():
return
chb.setEnabled(connected)
btn_modify = grb.findChild(QPushButton, pv_name + "_btn_modify")
btn_modify.setEnabled(connected)
btn_focus = grb.findChild(QPushButton, pv_name + "_btn_focus")
btn_focus.setEnabled(connected)
# btn_ann = grb.findChild(QPushButton, pv_name + "_btn_ann")
# btn_ann.setEnabled(connected)
@staticmethod
def get_current_datetime():
current_date = datetime.datetime.now().strftime("%b %d, %Y")
current_time = datetime.datetime.now().strftime("%H:%M:%S")
current_datetime = current_time + ' (' + current_date + ')'
return current_datetime
@property
def gridAlpha(self):
return self.grid_alpha
class SpyderErrorDialog(QDialog):
"""Custom error dialog for error reporting."""
def __init__(self, parent=None, is_report=False):
QDialog.__init__(self, parent)
self.is_report = is_report
self.setWindowTitle(_("Issue reporter"))
self.setModal(True)
# To save the traceback sent to the internal console
self.error_traceback = ""
# Dialog main label
if self.is_report:
title = _("Please fill the following information")
else:
title = _("Spyder has encountered an internal problem!")
main_label = QLabel(
_("<h3>{title}</h3>"
"Before reporting this problem, <i>please</i> consult our "
"comprehensive "
"<b><a href=\"{trouble_url}\">Troubleshooting Guide</a></b> "
"which should help solve most issues, and search for "
"<b><a href=\"{project_url}\">known bugs</a></b> "
"matching your error message or problem description for a "
"quicker solution."
).format(title=title, trouble_url=__trouble_url__,
project_url=__project_url__))
main_label.setOpenExternalLinks(True)
main_label.setWordWrap(True)
main_label.setAlignment(Qt.AlignJustify)
main_label.setStyleSheet('font-size: 12px;')
# Issue title
self.title = QLineEdit()
self.title.textChanged.connect(self._contents_changed)
self.title_chars_label = QLabel(_("{} more characters "
"to go...").format(TITLE_MIN_CHARS))
form_layout = QFormLayout()
form_layout.setFieldGrowthPolicy(QFormLayout.ExpandingFieldsGrow)
red_asterisk = '<font color="Red">*</font>'
title_label = QLabel(_("<b>Title</b>: {}").format(red_asterisk))
form_layout.setWidget(0, QFormLayout.LabelRole, title_label)
form_layout.setWidget(0, QFormLayout.FieldRole, self.title)
# Description
steps_header = QLabel(
_("<b>Steps to reproduce:</b> {}").format(red_asterisk))
steps_text = QLabel(_("Please enter a detailed step-by-step "
"description (in English) of what led up to "
"the problem below. Issue reports without a "
"clear way to reproduce them will be closed."))
steps_text.setWordWrap(True)
steps_text.setAlignment(Qt.AlignJustify)
steps_text.setStyleSheet('font-size: 12px;')
# Field to input the description of the problem
self.input_description = DescriptionWidget(self)
# Only allow to submit to Github if we have a long enough description
self.input_description.textChanged.connect(self._contents_changed)
# Widget to show errors
self.details = ShowErrorWidget(self)
self.details.set_pythonshell_font(get_font())
self.details.hide()
# Label to show missing chars
self.initial_chars = len(self.input_description.toPlainText())
self.desc_chars_label = QLabel(_("{} more characters "
"to go...").format(DESC_MIN_CHARS))
# Checkbox to dismiss future errors
self.dismiss_box = QCheckBox(_("Hide all future errors during this "
"session"))
if self.is_report:
self.dismiss_box.hide()
# Dialog buttons
gh_icon = ima.icon('github')
self.submit_btn = QPushButton(gh_icon, _('Submit to Github'))
self.submit_btn.setEnabled(False)
self.submit_btn.clicked.connect(self._submit_to_github)
self.details_btn = QPushButton(_('Show details'))
self.details_btn.clicked.connect(self._show_details)
if self.is_report:
self.details_btn.hide()
self.close_btn = QPushButton(_('Close'))
if self.is_report:
self.close_btn.clicked.connect(self.reject)
# Buttons layout
buttons_layout = QHBoxLayout()
buttons_layout.addWidget(self.submit_btn)
buttons_layout.addWidget(self.details_btn)
buttons_layout.addWidget(self.close_btn)
# Main layout
layout = QVBoxLayout()
layout.addWidget(main_label)
layout.addSpacing(20)
layout.addLayout(form_layout)
layout.addWidget(self.title_chars_label)
layout.addSpacing(12)
layout.addWidget(steps_header)
layout.addSpacing(-1)
layout.addWidget(steps_text)
layout.addSpacing(1)
layout.addWidget(self.input_description)
layout.addWidget(self.details)
layout.addWidget(self.desc_chars_label)
layout.addSpacing(15)
layout.addWidget(self.dismiss_box)
layout.addSpacing(15)
layout.addLayout(buttons_layout)
layout.setContentsMargins(25, 20, 25, 10)
self.setLayout(layout)
self.resize(570, 600)
self.title.setFocus()
# Set Tab key focus order
self.setTabOrder(self.title, self.input_description)
def _submit_to_github(self):
"""Action to take when pressing the submit button."""
# Get reference to the main window
if self.parent() is not None:
if getattr(self.parent(), 'main', False):
# This covers the case when the dialog is attached
# to the internal console
main = self.parent().main
else:
# Else the dialog is attached to the main window
# directly
main = self.parent()
else:
main = None
# Getting description and traceback
title = self.title.text()
description = self.input_description.toPlainText()
traceback = self.error_traceback[:-1] # Remove last EOL
# Render issue
if main is not None:
issue_text = main.render_issue(description=description,
traceback=traceback)
else:
issue_text = description
try:
if main is None:
org = 'ccordoba12'
else:
org = 'spyder-ide'
github_backend = GithubBackend(org, 'spyder', parent_widget=main)
github_report = github_backend.send_report(title, issue_text)
if github_report:
self.close()
except Exception:
ret = QMessageBox.question(
self, _('Error'),
_("An error occurred while trying to send the issue to "
"Github automatically. Would you like to open it "
"manually?<br><br>"
"If so, please make sure to paste your clipboard "
"into the issue report box that will appear in a new "
"browser tab before clicking <i>Submit</i> on that "
"page."))
if ret in [QMessageBox.Yes, QMessageBox.Ok]:
QApplication.clipboard().setText(issue_text)
issue_body = (
" \n<!--- *** BEFORE SUBMITTING: PASTE CLIPBOARD HERE "
"TO COMPLETE YOUR REPORT *** ---!>\n")
if main is not None:
main.report_issue(body=issue_body, title=title,
open_webpage=True)
else:
pass
def append_traceback(self, text):
"""Append text to the traceback, to be displayed in details."""
self.error_traceback += text
def _show_details(self):
"""Show traceback on its own dialog"""
if self.details.isVisible():
self.details.hide()
self.details_btn.setText(_('Show details'))
else:
self.resize(570, 700)
self.details.document().setPlainText('')
self.details.append_text_to_shell(self.error_traceback,
error=True,
prompt=False)
self.details.show()
self.details_btn.setText(_('Hide details'))
def _contents_changed(self):
"""Activate submit_btn."""
desc_chars = (len(self.input_description.toPlainText()) -
self.initial_chars)
if desc_chars < DESC_MIN_CHARS:
self.desc_chars_label.setText(
u"{} {}".format(DESC_MIN_CHARS - desc_chars,
_("more characters to go...")))
else:
self.desc_chars_label.setText(_("Description complete; thanks!"))
title_chars = len(self.title.text())
if title_chars < TITLE_MIN_CHARS:
self.title_chars_label.setText(
u"{} {}".format(TITLE_MIN_CHARS - title_chars,
_("more characters to go...")))
else:
self.title_chars_label.setText(_("Title complete; thanks!"))
submission_enabled = (desc_chars >= DESC_MIN_CHARS and
title_chars >= TITLE_MIN_CHARS)
self.submit_btn.setEnabled(submission_enabled)
class SummaryWidget(QWidget):
open = Signal([str, list])
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.uid_label = QLabel()
self.open_individually_button = QPushButton('Open individually')
self.open_individually_button.hide()
self.open_individually_button.clicked.connect(self._open_individually)
self.open_overplotted_button = QPushButton('Open over-plotted')
self.open_overplotted_button.hide()
self.open_overplotted_button.clicked.connect(self._open_overplotted)
self.open_overplotted_on_button = QPushButton('Add to tab...')
self.open_overplotted_on_button.hide()
self.open_overplotted_on_button.setEnabled(False)
self.open_overplotted_on_button.clicked.connect(
self._open_overplotted_on)
self.copy_uid_button = QPushButton('Copy UID to Clipboard')
self.copy_uid_button.hide()
self.copy_uid_button.clicked.connect(self._copy_uid)
self.streams = QLabel()
self.entries = []
uid_layout = QHBoxLayout()
uid_layout.addWidget(self.uid_label)
uid_layout.addWidget(self.copy_uid_button)
layout = QVBoxLayout()
layout.addWidget(self.open_individually_button)
layout.addWidget(self.open_overplotted_button)
layout.addWidget(self.open_overplotted_on_button)
layout.addLayout(uid_layout)
layout.addWidget(self.streams)
self.setLayout(layout)
self._tab_titles = ()
def cache_tab_titles(self, titles):
self._tab_titles = titles
self.open_overplotted_on_button.setEnabled(bool(titles))
def _copy_uid(self):
QApplication.clipboard().setText(self.uid)
def _open_individually(self):
for entry in self.entries:
self.open.emit(None, [entry])
def _open_overplotted(self):
self.open.emit(None, self.entries)
def _open_overplotted_on(self):
item, ok = QInputDialog.getItem(self, "Select Tab", "Tab",
self._tab_titles, 0, False)
if not ok:
return
self.open.emit(item, self.entries)
def set_entries(self, entries):
self.entries.clear()
self.entries.extend(entries)
if not entries:
self.uid_label.setText('')
self.streams.setText('')
self.copy_uid_button.hide()
self.open_individually_button.hide()
self.open_overplotted_button.hide()
self.open_overplotted_on_button.hide()
elif len(entries) == 1:
entry, = entries
self.uid = entry.metadata['start']['uid']
self.uid_label.setText(self.uid[:8])
self.copy_uid_button.show()
self.open_individually_button.show()
self.open_individually_button.setText('Open')
self.open_overplotted_on_button.show()
self.open_overplotted_button.hide()
num_events = entry.metadata.get('stop', {}).get('num_events')
if num_events:
self.streams.setText('Streams:\n' + ('\n'.join(
f'{k} ({v} Events)' for k, v in num_events.items())))
else:
# Either the RunStop document has not been emitted yet or was never
# emitted due to critical failure or this is an old document stream
# from before 'num_events' was added to the schema. Get the list of
# stream names another way, and omit the Event count.
self.streams.setText('Streams:\n' + ('\n'.join(list(entry()))))
else:
self.uid_label.setText('(Multiple Selected)')
self.streams.setText('')
self.copy_uid_button.hide()
self.open_individually_button.setText('Open individually')
self.open_individually_button.show()
self.open_overplotted_button.show()
self.open_overplotted_on_button.show()
class CreatePlan(QWidget):
plan_created = Signal()
plan_node_changed = Signal()
def __init__(self, settings: PartSettings):
super().__init__()
self.settings = settings
self.save_translate_dict: typing.Dict[str, SaveBase] = {x.get_short_name(): x for x in save_dict.values()}
self.plan = PlanPreview(self)
self.save_plan_btn = QPushButton("Save")
self.clean_plan_btn = QPushButton("Remove all")
self.remove_btn = QPushButton("Remove")
self.update_element_chk = QCheckBox("Update element")
self.change_root = EnumComboBox(RootType)
self.save_choose = QComboBox()
self.save_choose.addItem("<none>")
self.save_choose.addItems(list(self.save_translate_dict.keys()))
self.save_btn = QPushButton("Save")
self.segment_profile = SearchableListWidget()
self.pipeline_profile = SearchableListWidget()
self.segment_stack = QTabWidget()
self.segment_stack.addTab(self.segment_profile, "Profile")
self.segment_stack.addTab(self.pipeline_profile, "Pipeline")
self.generate_mask_btn = QPushButton("Add mask")
self.generate_mask_btn.setToolTip("Mask need to have unique name")
self.mask_name = QLineEdit()
self.mask_operation = EnumComboBox(MaskOperation)
self.chanel_num = QSpinBox()
self.choose_channel_for_measurements = QComboBox()
self.choose_channel_for_measurements.addItems(
["Same as segmentation"] + [str(x + 1) for x in range(MAX_CHANNEL_NUM)]
)
self.units_choose = EnumComboBox(Units)
self.units_choose.set_value(self.settings.get("units_value", Units.nm))
self.chanel_num.setRange(0, 10)
self.expected_node_type = None
self.save_constructor = None
self.chose_profile_btn = QPushButton("Add Profile")
self.get_big_btn = QPushButton("Leave the biggest")
self.get_big_btn.hide()
self.get_big_btn.setDisabled(True)
self.measurements_list = SearchableListWidget(self)
self.measurement_name_prefix = QLineEdit(self)
self.add_calculation_btn = QPushButton("Add measurement calculation")
self.information = QTextEdit()
self.information.setReadOnly(True)
self.protect = False
self.mask_set = set()
self.calculation_plan = CalculationPlan()
self.plan.set_plan(self.calculation_plan)
self.segmentation_mask = MaskWidget(settings)
self.file_mask = FileMask()
self.change_root.currentIndexChanged.connect(self.change_root_type)
self.save_choose.currentTextChanged.connect(self.save_changed)
self.measurements_list.currentTextChanged.connect(self.show_measurement)
self.segment_profile.currentTextChanged.connect(self.show_segment)
self.measurements_list.currentTextChanged.connect(self.show_measurement_info)
self.segment_profile.currentTextChanged.connect(self.show_segment_info)
self.pipeline_profile.currentTextChanged.connect(self.show_segment_info)
self.pipeline_profile.currentTextChanged.connect(self.show_segment)
self.mask_name.textChanged.connect(self.mask_name_changed)
self.generate_mask_btn.clicked.connect(self.create_mask)
self.clean_plan_btn.clicked.connect(self.clean_plan)
self.remove_btn.clicked.connect(self.remove_element)
self.mask_name.textChanged.connect(self.mask_text_changed)
self.chose_profile_btn.clicked.connect(self.add_segmentation)
self.get_big_btn.clicked.connect(self.add_leave_biggest)
self.add_calculation_btn.clicked.connect(self.add_measurement)
self.save_plan_btn.clicked.connect(self.add_calculation_plan)
# self.forgot_mask_btn.clicked.connect(self.forgot_mask)
# self.cmap_save_btn.clicked.connect(self.save_to_cmap)
self.save_btn.clicked.connect(self.add_save_to_project)
self.update_element_chk.stateChanged.connect(self.mask_text_changed)
self.update_element_chk.stateChanged.connect(self.show_measurement)
self.update_element_chk.stateChanged.connect(self.show_segment)
self.update_element_chk.stateChanged.connect(self.update_names)
self.segment_stack.currentChanged.connect(self.change_segmentation_table)
plan_box = QGroupBox("Prepare workflow:")
lay = QVBoxLayout()
lay.addWidget(self.plan)
bt_lay = QGridLayout()
bt_lay.setSpacing(1)
bt_lay.addWidget(self.save_plan_btn, 0, 0)
bt_lay.addWidget(self.clean_plan_btn, 0, 1)
bt_lay.addWidget(self.remove_btn, 1, 0)
bt_lay.addWidget(self.update_element_chk, 1, 1)
lay.addLayout(bt_lay)
plan_box.setLayout(lay)
plan_box.setStyleSheet(group_sheet)
other_box = QGroupBox("Other operations:")
other_box.setContentsMargins(0, 0, 0, 0)
bt_lay = QVBoxLayout()
bt_lay.setSpacing(0)
bt_lay.addWidget(QLabel("Root type:"))
bt_lay.addWidget(self.change_root)
bt_lay.addStretch(1)
bt_lay.addWidget(QLabel("Saving:"))
bt_lay.addWidget(self.save_choose)
bt_lay.addWidget(self.save_btn)
other_box.setLayout(bt_lay)
other_box.setStyleSheet(group_sheet)
mask_box = QGroupBox("Use mask from:")
mask_box.setStyleSheet(group_sheet)
self.mask_stack = QTabWidget()
self.mask_stack.addTab(stretch_widget(self.file_mask), "File")
self.mask_stack.addTab(stretch_widget(self.segmentation_mask), "Current ROI")
self.mask_stack.addTab(stretch_widget(self.mask_operation), "Operations on masks")
self.mask_stack.setTabToolTip(2, "Allows to create mask which is based on masks previously added to plan.")
lay = QGridLayout()
lay.setSpacing(0)
lay.addWidget(self.mask_stack, 0, 0, 1, 2)
label = QLabel("Mask name:")
label.setToolTip("Needed if you would like to reuse this mask in tab 'Operations on masks'")
self.mask_name.setToolTip("Needed if you would like to reuse this mask in tab 'Operations on masks'")
lay.addWidget(label, 1, 0)
lay.addWidget(self.mask_name, 1, 1)
lay.addWidget(self.generate_mask_btn, 2, 0, 1, 2)
mask_box.setLayout(lay)
segment_box = QGroupBox("ROI extraction:")
segment_box.setStyleSheet(group_sheet)
lay = QVBoxLayout()
lay.setSpacing(0)
lay.addWidget(self.segment_stack)
lay.addWidget(self.chose_profile_btn)
lay.addWidget(self.get_big_btn)
segment_box.setLayout(lay)
measurement_box = QGroupBox("Set of measurements:")
measurement_box.setStyleSheet(group_sheet)
lay = QGridLayout()
lay.setSpacing(0)
lay.addWidget(self.measurements_list, 0, 0, 1, 2)
lab = QLabel("Name prefix:")
lab.setToolTip("Prefix added before each column name")
lay.addWidget(lab, 1, 0)
lay.addWidget(self.measurement_name_prefix, 1, 1)
lay.addWidget(QLabel("Channel:"), 2, 0)
lay.addWidget(self.choose_channel_for_measurements, 2, 1)
lay.addWidget(QLabel("Units:"), 3, 0)
lay.addWidget(self.units_choose, 3, 1)
lay.addWidget(self.add_calculation_btn, 4, 0, 1, 2)
measurement_box.setLayout(lay)
info_box = QGroupBox("Information")
info_box.setStyleSheet(group_sheet)
lay = QVBoxLayout()
lay.addWidget(self.information)
info_box.setLayout(lay)
layout = QGridLayout()
fst_col = QVBoxLayout()
fst_col.addWidget(plan_box, 1)
fst_col.addWidget(mask_box)
layout.addWidget(plan_box, 0, 0, 5, 1)
# layout.addWidget(plan_box, 0, 0, 3, 1)
# layout.addWidget(mask_box, 3, 0, 2, 1)
# layout.addWidget(segmentation_mask_box, 1, 1)
layout.addWidget(mask_box, 0, 2, 1, 2)
layout.addWidget(other_box, 0, 1)
layout.addWidget(segment_box, 1, 1, 1, 2)
layout.addWidget(measurement_box, 1, 3)
layout.addWidget(info_box, 3, 1, 1, 3)
self.setLayout(layout)
self.generate_mask_btn.setDisabled(True)
self.chose_profile_btn.setDisabled(True)
self.add_calculation_btn.setDisabled(True)
self.mask_allow = False
self.segment_allow = False
self.file_mask_allow = False
self.node_type = NodeType.root
self.node_name = ""
self.plan_node_changed.connect(self.mask_text_changed)
self.plan.changed_node.connect(self.node_type_changed)
self.plan_node_changed.connect(self.show_segment)
self.plan_node_changed.connect(self.show_measurement)
self.plan_node_changed.connect(self.mask_stack_change)
self.mask_stack.currentChanged.connect(self.mask_stack_change)
self.file_mask.value_changed.connect(self.mask_stack_change)
self.mask_name.textChanged.connect(self.mask_stack_change)
self.node_type_changed()
def change_root_type(self):
value: RootType = self.change_root.get_value()
self.calculation_plan.set_root_type(value)
self.plan.update_view()
def change_segmentation_table(self):
index = self.segment_stack.currentIndex()
text = self.segment_stack.tabText(index)
if self.update_element_chk.isChecked():
self.chose_profile_btn.setText("Replace " + text)
else:
self.chose_profile_btn.setText("Add " + text)
self.segment_profile.setCurrentItem(None)
self.pipeline_profile.setCurrentItem(None)
def save_changed(self, text):
text = str(text)
if text == "<none>":
self.save_btn.setText("Save")
self.save_btn.setToolTip("Choose file type")
self.expected_node_type = None
self.save_constructor = None
else:
save_class = self.save_translate_dict.get(text, None)
if save_class is None:
self.save_choose.setCurrentText("<none>")
return
self.save_btn.setText(f"Save to {save_class.get_short_name()}")
self.save_btn.setToolTip("Choose mask create in plan view")
if save_class.need_mask():
self.expected_node_type = NodeType.mask
elif save_class.need_segmentation():
self.expected_node_type = NodeType.segment
else:
self.expected_node_type = NodeType.root
self.save_constructor = Save
self.save_activate()
def save_activate(self):
self.save_btn.setDisabled(True)
if self.node_type == self.expected_node_type:
self.save_btn.setEnabled(True)
return
def segmentation_from_project(self):
self.calculation_plan.add_step(Operations.reset_to_base)
self.plan.update_view()
def update_names(self):
if self.update_element_chk.isChecked():
self.chose_profile_btn.setText("Replace Profile")
self.add_calculation_btn.setText("Replace set of measurements")
self.generate_mask_btn.setText("Replace mask")
else:
self.chose_profile_btn.setText("Add Profile")
self.add_calculation_btn.setText("Add set of measurements")
self.generate_mask_btn.setText("Generate mask")
def node_type_changed(self):
# self.cmap_save_btn.setDisabled(True)
self.save_btn.setDisabled(True)
self.node_name = ""
if self.plan.currentItem() is None:
self.mask_allow = False
self.file_mask_allow = False
self.segment_allow = False
self.remove_btn.setDisabled(True)
self.plan_node_changed.emit()
logging.debug("[node_type_changed] return")
return
node_type = self.calculation_plan.get_node_type()
self.node_type = node_type
if node_type in [NodeType.file_mask, NodeType.mask, NodeType.segment, NodeType.measurement, NodeType.save]:
self.remove_btn.setEnabled(True)
else:
self.remove_btn.setEnabled(False)
if node_type in (NodeType.mask, NodeType.file_mask):
self.mask_allow = False
self.segment_allow = True
self.file_mask_allow = False
self.node_name = self.calculation_plan.get_node().operation.name
elif node_type == NodeType.segment:
self.mask_allow = True
self.segment_allow = False
self.file_mask_allow = False
self.save_btn.setEnabled(True)
# self.cmap_save_btn.setEnabled(True)
elif node_type == NodeType.root:
self.mask_allow = False
self.segment_allow = True
self.file_mask_allow = True
elif node_type in (NodeType.none, NodeType.measurement, NodeType.save):
self.mask_allow = False
self.segment_allow = False
self.file_mask_allow = False
self.save_activate()
self.plan_node_changed.emit()
def add_save_to_project(self):
save_class = self.save_translate_dict.get(self.save_choose.currentText(), None)
if save_class is None:
QMessageBox.warning(self, "Save problem", "Not found save class")
dial = FormDialog(
[AlgorithmProperty("suffix", "File suffix", ""), AlgorithmProperty("directory", "Sub directory", "")]
+ save_class.get_fields()
)
if dial.exec():
values = dial.get_values()
suffix = values["suffix"]
directory = values["directory"]
del values["suffix"]
del values["directory"]
save_elem = Save(suffix, directory, save_class.get_name(), save_class.get_short_name(), values)
if self.update_element_chk.isChecked():
self.calculation_plan.replace_step(save_elem)
else:
self.calculation_plan.add_step(save_elem)
self.plan.update_view()
def create_mask(self):
text = str(self.mask_name.text()).strip()
if text != "" and text in self.mask_set:
QMessageBox.warning(self, "Already exists", "Mask with this name already exists", QMessageBox.Ok)
return
if _check_widget(self.mask_stack, EnumComboBox): # existing mask
mask_dialog = TwoMaskDialog
if self.mask_operation.get_value() == MaskOperation.mask_intersection: # Mask intersection
MaskConstruct = MaskIntersection
else:
MaskConstruct = MaskSum
dial = mask_dialog(self.mask_set)
if not dial.exec():
return
names = dial.get_result()
mask_ob = MaskConstruct(text, *names)
elif _check_widget(self.mask_stack, MaskWidget):
mask_ob = MaskCreate(text, self.segmentation_mask.get_mask_property())
elif _check_widget(self.mask_stack, FileMask):
mask_ob = self.file_mask.get_value(text)
else:
raise ValueError("Unknowsn widget")
if self.update_element_chk.isChecked():
node = self.calculation_plan.get_node()
name = node.operation.name
if name in self.calculation_plan.get_reused_mask() and name != text:
QMessageBox.warning(
self, "Cannot remove", f"Cannot remove mask '{name}' from plan because it is used in other elements"
)
return
self.mask_set.remove(name)
self.mask_set.add(mask_ob.name)
self.calculation_plan.replace_step(mask_ob)
else:
self.mask_set.add(mask_ob.name)
self.calculation_plan.add_step(mask_ob)
self.plan.update_view()
self.mask_text_changed()
def mask_stack_change(self):
node_type = self.calculation_plan.get_node_type()
if self.update_element_chk.isChecked() and node_type not in [NodeType.mask, NodeType.file_mask]:
self.generate_mask_btn.setDisabled(True)
text = self.mask_name.text()
update = self.update_element_chk.isChecked()
if self.node_type == NodeType.none:
self.generate_mask_btn.setDisabled(True)
return
operation = self.calculation_plan.get_node().operation
if (
not update
and isinstance(operation, (MaskMapper, MaskBase))
and self.calculation_plan.get_node().operation.name == text
):
self.generate_mask_btn.setDisabled(True)
return
if _check_widget(self.mask_stack, EnumComboBox): # reuse mask
if len(self.mask_set) > 1 and (
(not update and node_type == NodeType.root) or (update and node_type == NodeType.file_mask)
):
self.generate_mask_btn.setEnabled(True)
else:
self.generate_mask_btn.setEnabled(False)
self.generate_mask_btn.setToolTip("Need at least two named mask and root selected")
elif _check_widget(self.mask_stack, MaskWidget): # mask from segmentation
if (not update and node_type == NodeType.segment) or (update and node_type == NodeType.mask):
self.generate_mask_btn.setEnabled(True)
else:
self.generate_mask_btn.setEnabled(False)
self.generate_mask_btn.setToolTip("Select segmentation")
else:
if (not update and node_type == NodeType.root) or (update and node_type == NodeType.file_mask):
self.generate_mask_btn.setEnabled(self.file_mask.is_valid())
else:
self.generate_mask_btn.setEnabled(False)
self.generate_mask_btn.setToolTip("Need root selected")
def mask_name_changed(self, text):
if str(text) in self.mask_set:
self.generate_mask_btn.setDisabled(True)
else:
self.generate_mask_btn.setDisabled(False)
def add_leave_biggest(self):
profile = self.calculation_plan.get_node().operation
profile.leave_biggest_swap()
self.calculation_plan.replace_step(profile)
self.plan.update_view()
def add_segmentation(self):
if self.segment_stack.currentIndex() == 0:
text = str(self.segment_profile.currentItem().text())
if text not in self.settings.segmentation_profiles:
self.refresh_all_profiles()
return
profile = self.settings.segmentation_profiles[text]
if self.update_element_chk.isChecked():
self.calculation_plan.replace_step(profile)
else:
self.calculation_plan.add_step(profile)
self.plan.update_view()
else: # self.segment_stack.currentIndex() == 1
text = self.pipeline_profile.currentItem().text()
segmentation_pipeline = self.settings.segmentation_pipelines[text]
pos = self.calculation_plan.current_pos[:]
old_pos = self.calculation_plan.current_pos[:]
for el in segmentation_pipeline.mask_history:
self.calculation_plan.add_step(el.segmentation)
self.plan.update_view()
node = self.calculation_plan.get_node(pos)
pos.append(len(node.children) - 1)
self.calculation_plan.set_position(pos)
self.calculation_plan.add_step(MaskCreate("", el.mask_property))
self.plan.update_view()
pos.append(0)
self.calculation_plan.set_position(pos)
self.calculation_plan.add_step(segmentation_pipeline.segmentation)
self.calculation_plan.set_position(old_pos)
self.plan.update_view()
def add_measurement(self):
text = str(self.measurements_list.currentItem().text())
measurement_copy = deepcopy(self.settings.measurement_profiles[text])
prefix = str(self.measurement_name_prefix.text()).strip()
channel = self.choose_channel_for_measurements.currentIndex() - 1
measurement_copy.name_prefix = prefix
# noinspection PyTypeChecker
measurement_calculate = MeasurementCalculate(
channel=channel,
measurement_profile=measurement_copy,
name_prefix=prefix,
units=self.units_choose.get_value(),
)
if self.update_element_chk.isChecked():
self.calculation_plan.replace_step(measurement_calculate)
else:
self.calculation_plan.add_step(measurement_calculate)
self.plan.update_view()
def remove_element(self):
conflict_mask, used_mask = self.calculation_plan.get_file_mask_names()
if len(conflict_mask) > 0:
logging.info("Mask in use")
QMessageBox.warning(self, "In use", "Masks {} are used in other places".format(", ".join(conflict_mask)))
return
self.mask_set -= used_mask
self.calculation_plan.remove_step()
self.plan.update_view()
def clean_plan(self):
self.calculation_plan = CalculationPlan()
self.plan.set_plan(self.calculation_plan)
self.node_type_changed()
self.mask_set = set()
def mask_text_changed(self):
name = str(self.mask_name.text()).strip()
self.generate_mask_btn.setDisabled(True)
# load mask from file
if not self.update_element_chk.isChecked():
# generate mask from segmentation
if self.mask_allow and (name == "" or name not in self.mask_set):
self.generate_mask_btn.setEnabled(True)
else:
if self.node_type != NodeType.file_mask and self.node_type != NodeType.mask:
return
# generate mask from segmentation
if self.node_type == NodeType.mask and (name == "" or name == self.node_name or name not in self.mask_set):
self.generate_mask_btn.setEnabled(True)
def add_calculation_plan(self, text=None):
if text is None or isinstance(text, bool):
text, ok = QInputDialog.getText(self, "Plan title", "Set plan title")
else:
text, ok = QInputDialog.getText(
self, "Plan title", f"Set plan title. Previous ({text}) is already in use", text=text
)
text = text.strip()
if ok:
if text == "":
QMessageBox.information(
self, "Name cannot be empty", "Name cannot be empty, Please set correct name", QMessageBox.Ok
)
self.add_calculation_plan()
return
if text in self.settings.batch_plans:
res = QMessageBox.information(
self,
"Name already in use",
"Name already in use. Would like to overwrite?",
QMessageBox.Yes | QMessageBox.No,
)
if res == QMessageBox.No:
self.add_calculation_plan(text)
return
plan = copy(self.calculation_plan)
plan.set_name(text)
self.settings.batch_plans[text] = plan
self.settings.dump()
self.plan_created.emit()
@staticmethod
def get_index(item: QListWidgetItem, new_values: typing.List[str]) -> int:
if item is None:
return -1
text = item.text()
try:
return new_values.index(text)
except ValueError:
return -1
@staticmethod
def refresh_profiles(list_widget: QListWidget, new_values: typing.List[str], index: int):
list_widget.clear()
list_widget.addItems(new_values)
if index != -1:
list_widget.setCurrentRow(index)
def showEvent(self, _event):
self.refresh_all_profiles()
def refresh_all_profiles(self):
new_measurements = list(sorted(self.settings.measurement_profiles.keys()))
new_segment = list(sorted(self.settings.segmentation_profiles.keys()))
new_pipelines = list(sorted(self.settings.segmentation_pipelines.keys()))
measurement_index = self.get_index(self.measurements_list.currentItem(), new_measurements)
segment_index = self.get_index(self.segment_profile.currentItem(), new_segment)
pipeline_index = self.get_index(self.pipeline_profile.currentItem(), new_pipelines)
self.protect = True
self.refresh_profiles(self.measurements_list, new_measurements, measurement_index)
self.refresh_profiles(self.segment_profile, new_segment, segment_index)
self.refresh_profiles(self.pipeline_profile, new_pipelines, pipeline_index)
self.protect = False
def show_measurement_info(self, text=None):
if self.protect:
return
if text is None:
if self.measurements_list.currentItem() is not None:
text = str(self.measurements_list.currentItem().text())
else:
return
profile = self.settings.measurement_profiles[text]
self.information.setText(str(profile))
def show_measurement(self):
if self.update_element_chk.isChecked():
if self.node_type == NodeType.measurement:
self.add_calculation_btn.setEnabled(True)
else:
self.add_calculation_btn.setDisabled(True)
else:
if self.measurements_list.currentItem() is not None:
self.add_calculation_btn.setEnabled(self.mask_allow)
else:
self.add_calculation_btn.setDisabled(True)
def show_segment_info(self, text=None):
if self.protect:
return
if text == "":
return
if self.segment_stack.currentIndex() == 0:
if text is None:
if self.segment_profile.currentItem() is not None:
text = str(self.segment_profile.currentItem().text())
else:
return
profile = self.settings.segmentation_profiles[text]
else:
if text is None:
if self.pipeline_profile.currentItem() is not None:
text = str(self.pipeline_profile.currentItem().text())
else:
return
profile = self.settings.segmentation_pipelines[text]
self.information.setText(profile.pretty_print(analysis_algorithm_dict))
def show_segment(self):
if self.update_element_chk.isChecked() and self.segment_stack.currentIndex() == 0:
self.get_big_btn.setDisabled(True)
if self.node_type == NodeType.segment:
self.chose_profile_btn.setEnabled(True)
else:
self.chose_profile_btn.setDisabled(True)
else:
if self.node_type == NodeType.segment:
self.get_big_btn.setEnabled(True)
else:
self.get_big_btn.setDisabled(True)
if (
self.segment_stack.currentIndex() == 0 and self.segment_profile.currentItem()
) or self.pipeline_profile.currentItem() is not None:
self.chose_profile_btn.setEnabled(self.segment_allow)
else:
self.chose_profile_btn.setDisabled(True)
def edit_plan(self):
plan = self.sender().plan_to_edit # type: CalculationPlan
self.calculation_plan = copy(plan)
self.plan.set_plan(self.calculation_plan)
self.mask_set.clear()
self.calculation_plan.set_position([])
self.mask_set.update(self.calculation_plan.get_mask_names())
class GcodeBackplot(QBackPlot):
line_selected = Signal(int)
gcode_error = Signal(str)
def __init__(self, parent=None, standalone=False):
super(GcodeBackplot, self).__init__(parent)
# This prevents doing unneeded initialization
# when QtDesginer loads the plugin.
if parent is None and not standalone:
return
self.show_overlay = False # no DRO or DRO overlay
self.program_alpha = True
self.grid_size = 1
self._reload_filename = None
# Add loading progress bar and abort button
self.progressBar = QProgressBar(visible=False)
self.progressBar.setFormat("Loading backplot: %p%")
self.abortButton = QPushButton('Abort', visible=False)
hBox = QHBoxLayout()
hBox.addWidget(self.progressBar)
hBox.addWidget(self.abortButton)
vBox = QVBoxLayout(self)
vBox.addStretch()
vBox.addLayout(hBox)
self.abortButton.clicked.connect(self.abort)
STATUS.actual_position.onValueChanged(self.update)
STATUS.joint_actual_position.onValueChanged(self.update)
STATUS.homed.onValueChanged(self.update)
STATUS.limit.onValueChanged(self.update)
STATUS.tool_in_spindle.onValueChanged(self.update)
STATUS.motion_mode.onValueChanged(self.update)
STATUS.current_vel.onValueChanged(self.update)
STATUS.g5x_offset.onValueChanged(self.reloadBackplot)
STATUS.g92_offset.onValueChanged(self.reloadBackplot)
# Connect status signals
STATUS.file.notify(self.loadBackplot)
# STATUS.reload_backplot.notify(self.reloadBackplot)
STATUS.program_units.notify(lambda v: self.setMetricUnits(v == 2))
def loadBackplot(self, fname):
LOG.debug('load the display: {}'.format(fname.encode('utf-8')))
self._reload_filename = fname
self.load(fname)
@Slot()
def reloadBackplot(self):
QTimer.singleShot(100, lambda: self._reloadBackplot())
def _reloadBackplot(self):
LOG.debug('reload the display: {}'.format(self._reload_filename))
dist = self.get_zoom_distance()
try:
self.load(self._reload_filename)
self.set_zoom_distance(dist)
except:
LOG.warning("Problem reloading backplot file: {}".format(self._reload_filename), exc_info=True)
# ==========================================================================
# Override QBackPlot methods
# ==========================================================================
def report_loading_started(self):
self.progressBar.show()
self.abortButton.show()
self.start = time.time()
def report_progress_percentage(self, percentage):
QApplication.processEvents()
self.progressBar.setValue(percentage)
def report_loading_finished(self):
print((time.time() - self.start))
self.progressBar.hide()
self.abortButton.hide()
# overriding functions
def report_gcode_error(self, result, seq, filename):
error = gcode.strerror(result)
file = os.path.basename(filename)
line = seq - 1
msg = "G-code error in '{}' near line {}: {}".format(file, line, error)
LOG.error(msg)
STATUS.backplot_gcode_error.emit(msg)
# Override gremlin's / glcannon.py function so we can emit a GObject signal
def update_highlight_variable(self, line):
self.highlight_line = line
if line is None:
line = -1
STATUS.backplot_line_selected.emit(line)
# ==============================================================================
# QtDesigner property setters/getters
# ==============================================================================
@Slot(str)
def setView(self, view):
view = view.lower()
if self.is_lathe:
if view not in ['p', 'y', 'y2']:
return False
elif view not in ['p', 'x', 'y', 'z', 'z2']:
return False
self.current_view = view
if self.initialised:
self.set_current_view()
def getView(self):
return self.current_view
defaultView = Property(str, getView, setView)
@Slot()
def setViewP(self):
self.setView('p')
@Slot()
def setViewX(self):
self.setView('x')
@Slot()
def setViewY(self):
self.setView('y')
@Slot()
def setViewZ(self):
self.setView('z')
@Slot()
def setViewZ2(self):
self.setView('z2')
@Slot()
def clearLivePlot(self):
self.clear_live_plotter()
@Slot()
def zoomIn(self):
self.zoomin()
@Slot()
def zoomOut(self):
self.zoomout()
@Slot(bool)
def alphaBlend(self, alpha):
self.program_alpha = alpha
self.update()
@Slot(bool)
def showGrid(self, grid):
self.grid_size = int(grid) # ugly hack for now
self.update()
# @Slot(str) Fixme check for the correct data type
def setdro(self, state):
self.enable_dro = state
self.updateGL()
def getdro(self):
return self.enable_dro
_dro = Property(bool, getdro, setdro)
# DTG
# @Slot(str) Fixme check for the correct data type
def setdtg(self, state):
self.show_dtg = state
self.updateGL()
def getdtg(self):
return self.show_dtg
_dtg = Property(bool, getdtg, setdtg)
# METRIC
# @Slot(str) Fixme check for the correct data type
def setMetricUnits(self, metric):
self.metric_units = metric
self.updateGL()
def getMetricUnits(self):
return self.metric_units
metricUnits = Property(bool, getMetricUnits, setMetricUnits)
# @Slot(str) Fixme check for the correct data type
def setProgramAlpha(self, alpha):
self.program_alpha = alpha
self.updateGL()
def getProgramAlpha(self):
return self.program_alpha
renderProgramAlpha = Property(bool, getProgramAlpha, setProgramAlpha)
# @Slot(str) Fixme check for the correct data type
def setBackgroundColor(self, color):
self.colors['back'] = color.getRgbF()[:3]
self.updateGL()
def getBackgroundColor(self):
r, g, b = self.colors['back']
color = QColor()
color.setRgbF(r, g, b, 1.0)
return color
backgroundColor = Property(QColor, getBackgroundColor, setBackgroundColor)
class SummaryWidget(QWidget):
open = Signal([str, list])
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.uid_label = QLabel()
self.open_individually_button = QPushButton('Open individually')
self.open_individually_button.hide()
self.open_individually_button.clicked.connect(self._open_individually)
self.open_overplotted_button = QPushButton('Open over-plotted')
self.open_overplotted_button.hide()
self.open_overplotted_button.clicked.connect(self._open_overplotted)
self.open_overplotted_on_button = QPushButton('Add to tab...')
self.open_overplotted_on_button.hide()
self.open_overplotted_on_button.setEnabled(False)
self.open_overplotted_on_button.clicked.connect(self._open_overplotted_on)
self.copy_uid_button = QPushButton('Copy UID to Clipboard')
self.copy_uid_button.hide()
self.copy_uid_button.clicked.connect(self._copy_uid)
self.streams = QLabel()
self.entries = []
uid_layout = QHBoxLayout()
uid_layout.addWidget(self.uid_label)
uid_layout.addWidget(self.copy_uid_button)
layout = QVBoxLayout()
layout.addWidget(self.open_individually_button)
layout.addWidget(self.open_overplotted_button)
layout.addWidget(self.open_overplotted_on_button)
layout.addLayout(uid_layout)
layout.addWidget(self.streams)
self.setLayout(layout)
self._tab_titles = ()
def cache_tab_titles(self, titles):
self._tab_titles = titles
self.open_overplotted_on_button.setEnabled(bool(titles))
def _copy_uid(self):
QApplication.clipboard().setText(self.uid)
def _open_individually(self):
for entry in self.entries:
self.open.emit(None, [entry])
def _open_overplotted(self):
self.open.emit(None, self.entries)
def _open_overplotted_on(self):
item, ok = QInputDialog.getItem(
self, "Select Tab", "Tab", self._tab_titles, 0, False)
if not ok:
return
self.open.emit(item, self.entries)
def set_entries(self, entries):
self.entries.clear()
self.entries.extend(entries)
if not entries:
self.uid_label.setText('')
self.streams.setText('')
self.copy_uid_button.hide()
self.open_individually_button.hide()
self.open_overplotted_button.hide()
self.open_overplotted_on_button.hide()
elif len(entries) == 1:
entry, = entries
self.uid = entry.metadata['start']['uid']
self.uid_label.setText(self.uid[:8])
self.copy_uid_button.show()
self.open_individually_button.show()
self.open_individually_button.setText('Open')
self.open_overplotted_on_button.show()
self.open_overplotted_button.hide()
num_events = entry.metadata.get('stop', {}).get('num_events')
if num_events:
self.streams.setText(
'Streams:\n' + ('\n'.join(f'{k} ({v} Events)' for k, v in num_events.items())))
else:
# Either the RunStop document has not been emitted yet or was never
# emitted due to critical failure or this is an old document stream
# from before 'num_events' was added to the schema. Get the list of
# stream names another way, and omit the Event count.
self.streams.setText('Streams:\n' + ('\n'.join(list(entry()))))
else:
self.uid_label.setText('(Multiple Selected)')
self.streams.setText('')
self.copy_uid_button.hide()
self.open_individually_button.setText('Open individually')
self.open_individually_button.show()
self.open_overplotted_button.show()
self.open_overplotted_on_button.show()
class SpyderErrorDialog(QDialog):
"""Custom error dialog for error reporting."""
def __init__(self, parent=None, is_report=False):
QDialog.__init__(self, parent)
self.is_report = is_report
self.setWindowTitle(_("Issue reporter"))
# To save the traceback sent to the internal console
self.error_traceback = ""
# Dialog main label
if self.is_report:
title = _("Please fill the following information")
else:
title = _("Spyder has encountered an internal problem!")
main_label = QLabel(
_("<h3>{title}</h3>"
"Before reporting this problem, <i>please</i> consult our "
"comprehensive "
"<b><a href=\"{trouble_url}\">Troubleshooting Guide</a></b> "
"which should help solve most issues, and search for "
"<b><a href=\"{project_url}\">known bugs</a></b> "
"matching your error message or problem description for a "
"quicker solution.").format(title=title,
trouble_url=__trouble_url__,
project_url=__project_url__))
main_label.setOpenExternalLinks(True)
main_label.setWordWrap(True)
main_label.setAlignment(Qt.AlignJustify)
main_label.setStyleSheet('font-size: 12px;')
# Issue title
self.title = QLineEdit()
self.title.textChanged.connect(self._contents_changed)
self.title_chars_label = QLabel(
_("{} more characters "
"to go...").format(TITLE_MIN_CHARS))
form_layout = QFormLayout()
form_layout.setFieldGrowthPolicy(QFormLayout.ExpandingFieldsGrow)
red_asterisk = '<font color="Red">*</font>'
title_label = QLabel(_("<b>Title</b>: {}").format(red_asterisk))
form_layout.setWidget(0, QFormLayout.LabelRole, title_label)
form_layout.setWidget(0, QFormLayout.FieldRole, self.title)
# Description
steps_header = QLabel(
_("<b>Steps to reproduce:</b> {}").format(red_asterisk))
steps_text = QLabel(
_("Please enter a detailed step-by-step "
"description (in English) of what led up to "
"the problem below. Issue reports without a "
"clear way to reproduce them will be closed."))
steps_text.setWordWrap(True)
steps_text.setAlignment(Qt.AlignJustify)
steps_text.setStyleSheet('font-size: 12px;')
# Field to input the description of the problem
self.input_description = DescriptionWidget(self)
# Only allow to submit to Github if we have a long enough description
self.input_description.textChanged.connect(self._contents_changed)
# Widget to show errors
self.details = ShowErrorWidget(self)
self.details.set_pythonshell_font(get_font())
self.details.hide()
# Label to show missing chars
self.initial_chars = len(self.input_description.toPlainText())
self.desc_chars_label = QLabel(
_("{} more characters "
"to go...").format(DESC_MIN_CHARS))
# Checkbox to dismiss future errors
self.dismiss_box = QCheckBox(
_("Hide all future errors during this "
"session"))
if self.is_report:
self.dismiss_box.hide()
# Dialog buttons
gh_icon = ima.icon('github')
self.submit_btn = QPushButton(gh_icon, _('Submit to Github'))
self.submit_btn.setEnabled(False)
self.submit_btn.clicked.connect(self._submit_to_github)
self.details_btn = QPushButton(_('Show details'))
self.details_btn.clicked.connect(self._show_details)
if self.is_report:
self.details_btn.hide()
self.close_btn = QPushButton(_('Close'))
if self.is_report:
self.close_btn.clicked.connect(self.reject)
# Buttons layout
buttons_layout = QHBoxLayout()
buttons_layout.addWidget(self.submit_btn)
buttons_layout.addWidget(self.details_btn)
buttons_layout.addWidget(self.close_btn)
# Main layout
layout = QVBoxLayout()
layout.addWidget(main_label)
layout.addSpacing(20)
layout.addLayout(form_layout)
layout.addWidget(self.title_chars_label)
layout.addSpacing(12)
layout.addWidget(steps_header)
layout.addSpacing(-1)
layout.addWidget(steps_text)
layout.addSpacing(1)
layout.addWidget(self.input_description)
layout.addWidget(self.details)
layout.addWidget(self.desc_chars_label)
layout.addSpacing(15)
layout.addWidget(self.dismiss_box)
layout.addSpacing(15)
layout.addLayout(buttons_layout)
layout.setContentsMargins(25, 20, 25, 10)
self.setLayout(layout)
self.resize(570, 600)
self.title.setFocus()
# Set Tab key focus order
self.setTabOrder(self.title, self.input_description)
def _submit_to_github(self):
"""Action to take when pressing the submit button."""
# Get reference to the main window
if self.parent() is not None:
if getattr(self.parent(), 'main', False):
# This covers the case when the dialog is attached
# to the internal console
main = self.parent().main
else:
# Else the dialog is attached to the main window
# directly
main = self.parent()
else:
main = None
# Getting description and traceback
title = self.title.text()
description = self.input_description.toPlainText()
traceback = self.error_traceback[:-1] # Remove last EOL
# Render issue
if main is not None:
issue_text = main.render_issue(description=description,
traceback=traceback)
else:
issue_text = description
try:
if main is None:
org = 'ccordoba12'
else:
org = 'spyder-ide'
github_backend = GithubBackend(org, 'spyder', parent_widget=main)
github_report = github_backend.send_report(title, issue_text)
if github_report:
self.close()
except Exception:
ret = QMessageBox.question(
self, _('Error'),
_("An error occurred while trying to send the issue to "
"Github automatically. Would you like to open it "
"manually?<br><br>"
"If so, please make sure to paste your clipboard "
"into the issue report box that will appear in a new "
"browser tab before clicking <i>Submit</i> on that "
"page."))
if ret in [QMessageBox.Yes, QMessageBox.Ok]:
QApplication.clipboard().setText(issue_text)
issue_body = (
" \n<!--- *** BEFORE SUBMITTING: PASTE CLIPBOARD HERE "
"TO COMPLETE YOUR REPORT *** ---!>\n")
if main is not None:
main.report_issue(body=issue_body,
title=title,
open_webpage=True)
else:
pass
def append_traceback(self, text):
"""Append text to the traceback, to be displayed in details."""
self.error_traceback += text
def _show_details(self):
"""Show traceback on its own dialog"""
if self.details.isVisible():
self.details.hide()
self.details_btn.setText(_('Show details'))
else:
self.resize(570, 700)
self.details.document().setPlainText('')
self.details.append_text_to_shell(self.error_traceback,
error=True,
prompt=False)
self.details.show()
self.details_btn.setText(_('Hide details'))
def _contents_changed(self):
"""Activate submit_btn."""
desc_chars = (len(self.input_description.toPlainText()) -
self.initial_chars)
if desc_chars < DESC_MIN_CHARS:
self.desc_chars_label.setText(u"{} {}".format(
DESC_MIN_CHARS - desc_chars, _("more characters to go...")))
else:
self.desc_chars_label.setText(_("Description complete; thanks!"))
title_chars = len(self.title.text())
if title_chars < TITLE_MIN_CHARS:
self.title_chars_label.setText(u"{} {}".format(
TITLE_MIN_CHARS - title_chars, _("more characters to go...")))
else:
self.title_chars_label.setText(_("Title complete; thanks!"))
submission_enabled = (desc_chars >= DESC_MIN_CHARS
and title_chars >= TITLE_MIN_CHARS)
self.submit_btn.setEnabled(submission_enabled)
def set_title(self, title):
"""Set the title for the report."""
self.title.setText(title)
def set_description(self, description):
"""Set the description for the report."""
self.input_description.setPlainText(description)
def set_color_scheme(self, color_scheme):
"""Set the color scheme for the description input."""
self.input_description.set_color_scheme(color_scheme)
class PyDMChartingDisplay(Display):
def __init__(self, parent=None, args=[], macros=None):
"""
Create all the widgets, including any child dialogs.
Parameters
----------
parent : QWidget
The parent widget of the charting display
args : list
The command parameters
macros : str
Macros to modify the UI parameters at runtime
"""
super(PyDMChartingDisplay, self).__init__(parent=parent,
args=args,
macros=macros)
self.channel_map = dict()
self.setWindowTitle("PyDM Charting Tool")
self.main_layout = QVBoxLayout()
self.body_layout = QVBoxLayout()
self.pv_layout = QHBoxLayout()
self.pv_name_line_edt = QLineEdit()
self.pv_name_line_edt.setAcceptDrops(True)
self.pv_name_line_edt.installEventFilter(self)
self.pv_protocol_cmb = QComboBox()
self.pv_protocol_cmb.addItems(["ca://", "archive://"])
self.pv_connect_push_btn = QPushButton("Connect")
self.pv_connect_push_btn.clicked.connect(self.add_curve)
self.tab_panel = QTabWidget()
self.tab_panel.setMaximumWidth(450)
self.curve_settings_tab = QWidget()
self.chart_settings_tab = QWidget()
self.charting_layout = QHBoxLayout()
self.chart = PyDMTimePlot(plot_by_timestamps=False, plot_display=self)
self.chart.setPlotTitle("Time Plot")
self.splitter = QSplitter()
self.curve_settings_layout = QVBoxLayout()
self.curve_settings_layout.setAlignment(Qt.AlignTop)
self.curve_settings_layout.setSizeConstraint(QLayout.SetMinAndMaxSize)
self.curve_settings_layout.setSpacing(5)
self.crosshair_settings_layout = QVBoxLayout()
self.crosshair_settings_layout.setAlignment(Qt.AlignTop)
self.crosshair_settings_layout.setSpacing(5)
self.enable_crosshair_chk = QCheckBox("Enable Crosshair")
self.cross_hair_coord_lbl = QLabel()
self.curve_settings_inner_frame = QFrame()
self.curve_settings_inner_frame.setLayout(self.curve_settings_layout)
self.curve_settings_scroll = QScrollArea()
self.curve_settings_scroll.setVerticalScrollBarPolicy(
Qt.ScrollBarAsNeeded)
self.curve_settings_scroll.setWidget(self.curve_settings_inner_frame)
self.curves_tab_layout = QHBoxLayout()
self.curves_tab_layout.addWidget(self.curve_settings_scroll)
self.enable_crosshair_chk.setChecked(False)
self.enable_crosshair_chk.clicked.connect(
self.handle_enable_crosshair_checkbox_clicked)
self.enable_crosshair_chk.clicked.emit(False)
self.chart_settings_layout = QVBoxLayout()
self.chart_settings_layout.setAlignment(Qt.AlignTop)
self.chart_layout = QVBoxLayout()
self.chart_panel = QWidget()
self.chart_control_layout = QHBoxLayout()
self.chart_control_layout.setAlignment(Qt.AlignHCenter)
self.chart_control_layout.setSpacing(10)
self.view_all_btn = QPushButton("View All")
self.view_all_btn.clicked.connect(self.handle_view_all_button_clicked)
self.view_all_btn.setEnabled(False)
self.auto_scale_btn = QPushButton("Auto Scale")
self.auto_scale_btn.clicked.connect(self.handle_auto_scale_btn_clicked)
self.auto_scale_btn.setEnabled(False)
self.reset_chart_btn = QPushButton("Reset")
self.reset_chart_btn.clicked.connect(
self.handle_reset_chart_btn_clicked)
self.reset_chart_btn.setEnabled(False)
self.resume_chart_text = "Resume"
self.pause_chart_text = "Pause"
self.pause_chart_btn = QPushButton(self.pause_chart_text)
self.pause_chart_btn.clicked.connect(
self.handle_pause_chart_btn_clicked)
self.title_settings_layout = QVBoxLayout()
self.title_settings_layout.setSpacing(10)
self.title_settings_grpbx = QGroupBox()
self.title_settings_grpbx.setFixedHeight(150)
self.import_data_btn = QPushButton("Import Data...")
self.import_data_btn.clicked.connect(
self.handle_import_data_btn_clicked)
self.export_data_btn = QPushButton("Export Data...")
self.export_data_btn.clicked.connect(
self.handle_export_data_btn_clicked)
self.chart_title_lbl = QLabel(text="Chart Title")
self.chart_title_line_edt = QLineEdit()
self.chart_title_line_edt.setText(self.chart.getPlotTitle())
self.chart_title_line_edt.textChanged.connect(
self.handle_title_text_changed)
self.chart_change_axis_settings_btn = QPushButton(
text="Change Axis Settings...")
self.chart_change_axis_settings_btn.clicked.connect(
self.handle_change_axis_settings_clicked)
self.update_datetime_timer = QTimer(self)
self.update_datetime_timer.timeout.connect(
self.handle_update_datetime_timer_timeout)
self.chart_sync_mode_layout = QVBoxLayout()
self.chart_sync_mode_layout.setSpacing(5)
self.chart_sync_mode_grpbx = QGroupBox("Data Sampling Mode")
self.chart_sync_mode_grpbx.setFixedHeight(80)
self.chart_sync_mode_sync_radio = QRadioButton("Synchronous")
self.chart_sync_mode_async_radio = QRadioButton("Asynchronous")
self.chart_sync_mode_async_radio.setChecked(True)
self.graph_drawing_settings_layout = QVBoxLayout()
self.chart_redraw_rate_lbl = QLabel("Redraw Rate (Hz)")
self.chart_redraw_rate_spin = QSpinBox()
self.chart_redraw_rate_spin.setRange(MIN_REDRAW_RATE_HZ,
MAX_REDRAW_RATE_HZ)
self.chart_redraw_rate_spin.setValue(DEFAULT_REDRAW_RATE_HZ)
self.chart_redraw_rate_spin.valueChanged.connect(
self.handle_redraw_rate_changed)
self.chart_data_sampling_rate_lbl = QLabel(
"Asynchronous Data Sampling Rate (Hz)")
self.chart_data_async_sampling_rate_spin = QSpinBox()
self.chart_data_async_sampling_rate_spin.setRange(
MIN_DATA_SAMPLING_RATE_HZ, MAX_DATA_SAMPLING_RATE_HZ)
self.chart_data_async_sampling_rate_spin.setValue(
DEFAULT_DATA_SAMPLING_RATE_HZ)
self.chart_data_async_sampling_rate_spin.valueChanged.connect(
self.handle_data_sampling_rate_changed)
self.chart_data_sampling_rate_lbl.hide()
self.chart_data_async_sampling_rate_spin.hide()
self.chart_limit_time_span_layout = QHBoxLayout()
self.chart_limit_time_span_layout.setSpacing(5)
self.limit_time_plan_text = "Limit Time Span"
self.chart_limit_time_span_chk = QCheckBox(self.limit_time_plan_text)
self.chart_limit_time_span_chk.hide()
self.chart_limit_time_span_lbl = QLabel("Hours : Minutes : Seconds")
self.chart_limit_time_span_hours_line_edt = QLineEdit()
self.chart_limit_time_span_minutes_line_edt = QLineEdit()
self.chart_limit_time_span_seconds_line_edt = QLineEdit()
self.chart_limit_time_span_activate_btn = QPushButton("Apply")
self.chart_limit_time_span_activate_btn.setDisabled(True)
self.chart_ring_buffer_size_lbl = QLabel("Ring Buffer Size")
self.chart_ring_buffer_size_edt = QLineEdit()
self.chart_ring_buffer_size_edt.installEventFilter(self)
self.chart_ring_buffer_size_edt.textChanged.connect(
self.handle_buffer_size_changed)
self.chart_ring_buffer_size_edt.setText(str(DEFAULT_BUFFER_SIZE))
self.show_legend_chk = QCheckBox("Show Legend")
self.show_legend_chk.setChecked(self.chart.showLegend)
self.show_legend_chk.clicked.connect(
self.handle_show_legend_checkbox_clicked)
self.graph_background_color_layout = QFormLayout()
self.background_color_lbl = QLabel("Graph Background Color ")
self.background_color_btn = QPushButton()
self.background_color_btn.setStyleSheet(
"background-color: " + self.chart.getBackgroundColor().name())
self.background_color_btn.setContentsMargins(10, 0, 5, 5)
self.background_color_btn.setMaximumWidth(20)
self.background_color_btn.clicked.connect(
self.handle_background_color_button_clicked)
self.axis_settings_layout = QVBoxLayout()
self.axis_settings_layout.setSpacing(5)
self.show_x_grid_chk = QCheckBox("Show x Grid")
self.show_x_grid_chk.setChecked(self.chart.showXGrid)
self.show_x_grid_chk.clicked.connect(
self.handle_show_x_grid_checkbox_clicked)
self.show_y_grid_chk = QCheckBox("Show y Grid")
self.show_y_grid_chk.setChecked(self.chart.showYGrid)
self.show_y_grid_chk.clicked.connect(
self.handle_show_y_grid_checkbox_clicked)
self.axis_color_lbl = QLabel("Axis and Grid Color")
self.axis_color_lbl.setEnabled(False)
self.axis_color_btn = QPushButton()
self.axis_color_btn.setStyleSheet("background-color: " +
DEFAULT_CHART_AXIS_COLOR.name())
self.axis_color_btn.setContentsMargins(10, 0, 5, 5)
self.axis_color_btn.setMaximumWidth(20)
self.axis_color_btn.clicked.connect(
self.handle_axis_color_button_clicked)
self.axis_color_btn.setEnabled(False)
self.grid_opacity_lbl = QLabel("Grid Opacity")
self.grid_opacity_lbl.setEnabled(False)
self.grid_opacity_slr = QSlider(Qt.Horizontal)
self.grid_opacity_slr.setFocusPolicy(Qt.StrongFocus)
self.grid_opacity_slr.setRange(0, 10)
self.grid_opacity_slr.setValue(5)
self.grid_opacity_slr.setTickInterval(1)
self.grid_opacity_slr.setSingleStep(1)
self.grid_opacity_slr.setTickPosition(QSlider.TicksBelow)
self.grid_opacity_slr.valueChanged.connect(
self.handle_grid_opacity_slider_mouse_release)
self.grid_opacity_slr.setEnabled(False)
self.reset_chart_settings_btn = QPushButton("Reset Chart Settings")
self.reset_chart_settings_btn.clicked.connect(
self.handle_reset_chart_settings_btn_clicked)
self.curve_checkbox_panel = QWidget()
self.graph_drawing_settings_grpbx = QGroupBox()
self.graph_drawing_settings_grpbx.setFixedHeight(270)
self.axis_settings_grpbx = QGroupBox()
self.axis_settings_grpbx.setFixedHeight(180)
self.app = QApplication.instance()
self.setup_ui()
self.curve_settings_disp = None
self.axis_settings_disp = None
self.chart_data_export_disp = None
self.chart_data_import_disp = None
self.grid_alpha = 5
self.time_span_limit_hours = None
self.time_span_limit_minutes = None
self.time_span_limit_seconds = None
self.data_sampling_mode = ASYNC_DATA_SAMPLING
def minimumSizeHint(self):
"""
The minimum recommended size of the main window.
"""
return QSize(1490, 800)
def ui_filepath(self):
"""
The path to the UI file created by Qt Designer, if applicable.
"""
# No UI file is being used
return None
def ui_filename(self):
"""
The name the UI file created by Qt Designer, if applicable.
"""
# No UI file is being used
return None
def setup_ui(self):
"""
Initialize the widgets and layouts.
"""
self.setLayout(self.main_layout)
self.pv_layout.addWidget(self.pv_protocol_cmb)
self.pv_layout.addWidget(self.pv_name_line_edt)
self.pv_layout.addWidget(self.pv_connect_push_btn)
QTimer.singleShot(0, self.pv_name_line_edt.setFocus)
self.curve_settings_tab.setLayout(self.curves_tab_layout)
self.chart_settings_tab.setLayout(self.chart_settings_layout)
self.setup_chart_settings_layout()
self.tab_panel.addTab(self.curve_settings_tab, "Curves")
self.tab_panel.addTab(self.chart_settings_tab, "Chart")
self.tab_panel.hide()
self.crosshair_settings_layout.addWidget(self.enable_crosshair_chk)
self.crosshair_settings_layout.addWidget(self.cross_hair_coord_lbl)
self.chart_control_layout.addWidget(self.auto_scale_btn)
self.chart_control_layout.addWidget(self.view_all_btn)
self.chart_control_layout.addWidget(self.reset_chart_btn)
self.chart_control_layout.addWidget(self.pause_chart_btn)
self.chart_control_layout.addLayout(self.crosshair_settings_layout)
self.chart_control_layout.addWidget(self.import_data_btn)
self.chart_control_layout.addWidget(self.export_data_btn)
self.chart_control_layout.setStretch(4, 15)
self.chart_control_layout.insertSpacing(5, 350)
self.chart_layout.addWidget(self.chart)
self.chart_layout.addLayout(self.chart_control_layout)
self.chart_panel.setLayout(self.chart_layout)
self.splitter.addWidget(self.chart_panel)
self.splitter.addWidget(self.tab_panel)
self.splitter.setStretchFactor(0, 0)
self.splitter.setStretchFactor(1, 1)
self.charting_layout.addWidget(self.splitter)
self.body_layout.addLayout(self.pv_layout)
self.body_layout.addLayout(self.charting_layout)
self.body_layout.addLayout(self.chart_control_layout)
self.main_layout.addLayout(self.body_layout)
self.enable_chart_control_buttons(False)
def setup_chart_settings_layout(self):
self.chart_sync_mode_sync_radio.toggled.connect(
partial(self.handle_sync_mode_radio_toggle,
self.chart_sync_mode_sync_radio))
self.chart_sync_mode_async_radio.toggled.connect(
partial(self.handle_sync_mode_radio_toggle,
self.chart_sync_mode_async_radio))
self.title_settings_layout.addWidget(self.chart_title_lbl)
self.title_settings_layout.addWidget(self.chart_title_line_edt)
self.title_settings_layout.addWidget(self.show_legend_chk)
self.title_settings_layout.addWidget(
self.chart_change_axis_settings_btn)
self.title_settings_grpbx.setLayout(self.title_settings_layout)
self.chart_settings_layout.addWidget(self.title_settings_grpbx)
self.chart_sync_mode_layout.addWidget(self.chart_sync_mode_sync_radio)
self.chart_sync_mode_layout.addWidget(self.chart_sync_mode_async_radio)
self.chart_sync_mode_grpbx.setLayout(self.chart_sync_mode_layout)
self.chart_settings_layout.addWidget(self.chart_sync_mode_grpbx)
self.chart_settings_layout.addWidget(self.chart_sync_mode_grpbx)
self.chart_limit_time_span_layout.addWidget(
self.chart_limit_time_span_lbl)
self.chart_limit_time_span_layout.addWidget(
self.chart_limit_time_span_hours_line_edt)
self.chart_limit_time_span_layout.addWidget(
self.chart_limit_time_span_minutes_line_edt)
self.chart_limit_time_span_layout.addWidget(
self.chart_limit_time_span_seconds_line_edt)
self.chart_limit_time_span_layout.addWidget(
self.chart_limit_time_span_activate_btn)
self.chart_limit_time_span_lbl.hide()
self.chart_limit_time_span_hours_line_edt.hide()
self.chart_limit_time_span_minutes_line_edt.hide()
self.chart_limit_time_span_seconds_line_edt.hide()
self.chart_limit_time_span_activate_btn.hide()
self.chart_limit_time_span_hours_line_edt.textChanged.connect(
self.handle_time_span_edt_text_changed)
self.chart_limit_time_span_minutes_line_edt.textChanged.connect(
self.handle_time_span_edt_text_changed)
self.chart_limit_time_span_seconds_line_edt.textChanged.connect(
self.handle_time_span_edt_text_changed)
self.chart_limit_time_span_chk.clicked.connect(
self.handle_limit_time_span_checkbox_clicked)
self.chart_limit_time_span_activate_btn.clicked.connect(
self.handle_chart_limit_time_span_activate_btn_clicked)
self.chart_limit_time_span_activate_btn.installEventFilter(self)
self.graph_background_color_layout.addRow(self.background_color_lbl,
self.background_color_btn)
self.graph_drawing_settings_layout.addLayout(
self.graph_background_color_layout)
self.graph_drawing_settings_layout.addWidget(
self.chart_redraw_rate_lbl)
self.graph_drawing_settings_layout.addWidget(
self.chart_redraw_rate_spin)
self.graph_drawing_settings_layout.addWidget(
self.chart_data_sampling_rate_lbl)
self.graph_drawing_settings_layout.addWidget(
self.chart_data_async_sampling_rate_spin)
self.graph_drawing_settings_layout.addWidget(
self.chart_limit_time_span_chk)
self.graph_drawing_settings_layout.addLayout(
self.chart_limit_time_span_layout)
self.graph_drawing_settings_layout.addWidget(
self.chart_ring_buffer_size_lbl)
self.graph_drawing_settings_layout.addWidget(
self.chart_ring_buffer_size_edt)
self.graph_drawing_settings_grpbx.setLayout(
self.graph_drawing_settings_layout)
self.axis_settings_layout.addWidget(self.show_x_grid_chk)
self.axis_settings_layout.addWidget(self.show_y_grid_chk)
self.axis_settings_layout.addWidget(self.axis_color_lbl)
self.axis_settings_layout.addWidget(self.axis_color_btn)
self.axis_settings_layout.addWidget(self.grid_opacity_lbl)
self.axis_settings_layout.addWidget(self.grid_opacity_slr)
self.axis_settings_grpbx.setLayout(self.axis_settings_layout)
self.chart_settings_layout.addWidget(self.graph_drawing_settings_grpbx)
self.chart_settings_layout.addWidget(self.axis_settings_grpbx)
self.chart_settings_layout.addWidget(self.reset_chart_settings_btn)
self.chart_sync_mode_async_radio.toggled.emit(True)
self.update_datetime_timer.start(1000)
def eventFilter(self, obj, event):
"""
Handle key and mouse events for any applicable widget.
Parameters
----------
obj : QWidget
The current widget that accepts the event
event : QEvent
The key or mouse event to handle
Returns
-------
True if the event was handled successfully; False otherwise
"""
if obj == self.pv_name_line_edt and event.type() == QEvent.KeyPress:
if event.key() == Qt.Key_Enter or event.key() == Qt.Key_Return:
self.add_curve()
return True
elif obj == self.chart_limit_time_span_activate_btn and event.type(
) == QEvent.KeyPress:
if event.key() == Qt.Key_Enter or event.key() == Qt.Key_Return:
self.handle_chart_limit_time_span_activate_btn_clicked()
return True
elif obj == self.chart_ring_buffer_size_edt:
if event.type() == QEvent.KeyPress and (event.key() == Qt.Key_Enter or event.key() == Qt.Key_Return) or \
event.type() == QEvent.FocusOut:
try:
buffer_size = int(self.chart_ring_buffer_size_edt.text())
if buffer_size < MINIMUM_BUFFER_SIZE:
self.chart_ring_buffer_size_edt.setText(
str(MINIMUM_BUFFER_SIZE))
except ValueError:
display_message_box(QMessageBox.Critical, "Invalid Values",
"Only integer values are accepted.")
return True
return super(PyDMChartingDisplay, self).eventFilter(obj, event)
def add_curve(self):
"""
Add a new curve to the chart.
"""
pv_name = self._get_full_pv_name(self.pv_name_line_edt.text())
color = random_color()
for k, v in self.channel_map.items():
if color == v.color:
color = random_color()
self.add_y_channel(pv_name=pv_name, curve_name=pv_name, color=color)
def handle_enable_crosshair_checkbox_clicked(self, is_checked):
self.chart.enableCrosshair(is_checked)
self.cross_hair_coord_lbl.setVisible(is_checked)
def add_y_channel(self,
pv_name,
curve_name,
color,
line_style=Qt.SolidLine,
line_width=2,
symbol=None,
symbol_size=None):
if pv_name in self.channel_map:
logger.error("'{0}' has already been added.".format(pv_name))
return
curve = self.chart.addYChannel(y_channel=pv_name,
name=curve_name,
color=color,
lineStyle=line_style,
lineWidth=line_width,
symbol=symbol,
symbolSize=symbol_size)
self.channel_map[pv_name] = curve
self.generate_pv_controls(pv_name, color)
self.enable_chart_control_buttons()
self.app.establish_widget_connections(self)
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. Two buttons -- Modify... and Remove. Modify... will bring up the Curve Settings dialog. Remove will
delete the curve from the chart
This set of widgets will be hidden initially, until the first curve is plotted.
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
"""
checkbox = QCheckBox()
checkbox.setObjectName(pv_name)
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()
data_text.setObjectName(pv_name)
data_text.setPalette(palette)
checkbox.setChecked(True)
checkbox.clicked.connect(
partial(self.handle_curve_chkbox_toggled, checkbox))
curve_btn_layout = QHBoxLayout()
modify_curve_btn = QPushButton("Modify...")
modify_curve_btn.setObjectName(pv_name)
modify_curve_btn.setMaximumWidth(100)
modify_curve_btn.clicked.connect(
partial(self.display_curve_settings_dialog, pv_name))
focus_curve_btn = QPushButton("Focus")
focus_curve_btn.setObjectName(pv_name)
focus_curve_btn.setMaximumWidth(100)
focus_curve_btn.clicked.connect(partial(self.focus_curve, pv_name))
annotate_curve_btn = QPushButton("Annotate...")
annotate_curve_btn.setObjectName(pv_name)
annotate_curve_btn.setMaximumWidth(100)
annotate_curve_btn.clicked.connect(
partial(self.annotate_curve, pv_name))
remove_curve_btn = QPushButton("Remove")
remove_curve_btn.setObjectName(pv_name)
remove_curve_btn.setMaximumWidth(100)
remove_curve_btn.clicked.connect(partial(self.remove_curve, pv_name))
curve_btn_layout.addWidget(modify_curve_btn)
curve_btn_layout.addWidget(focus_curve_btn)
curve_btn_layout.addWidget(annotate_curve_btn)
curve_btn_layout.addWidget(remove_curve_btn)
individual_curve_layout = QVBoxLayout()
individual_curve_layout.addWidget(checkbox)
individual_curve_layout.addWidget(data_text)
individual_curve_layout.addLayout(curve_btn_layout)
size_policy = QSizePolicy()
size_policy.setVerticalPolicy(QSizePolicy.Fixed)
individual_curve_grpbx = QGroupBox()
individual_curve_grpbx.setSizePolicy(size_policy)
individual_curve_grpbx.setObjectName(pv_name)
individual_curve_grpbx.setLayout(individual_curve_layout)
self.curve_settings_layout.addWidget(individual_curve_grpbx)
self.tab_panel.show()
def handle_curve_chkbox_toggled(self, checkbox):
"""
Handle a checkbox's checked and unchecked events.
If a checkbox is checked, find the curve from the channel map. If found, re-draw the curve with its previous
appearance settings.
If a checkbox is unchecked, remove the curve from the chart, but keep the cached data in the channel map.
Parameters
----------
checkbox : QCheckBox
The current checkbox being toggled
"""
pv_name = self._get_full_pv_name(checkbox.text())
if checkbox.isChecked():
curve = self.channel_map.get(pv_name, None)
if curve:
self.chart.addLegendItem(curve, pv_name,
self.show_legend_chk.isChecked())
curve.show()
else:
curve = self.chart.findCurve(pv_name)
if curve:
curve.hide()
self.chart.removeLegendItem(pv_name)
def display_curve_settings_dialog(self, pv_name):
"""
Bring up the Curve Settings dialog to modify the appearance of a curve.
Parameters
----------
pv_name : str
The name of the PV the curve is being plotted for
"""
self.curve_settings_disp = CurveSettingsDisplay(self, pv_name)
self.curve_settings_disp.show()
def focus_curve(self, pv_name):
curve = self.chart.findCurve(pv_name)
if curve:
self.chart.plotItem.setYRange(curve.minY, curve.maxY, padding=0)
def annotate_curve(self, pv_name):
curve = self.chart.findCurve(pv_name)
if curve:
annot = TextItem(
html=
'<div style="text-align: center"><span style="color: #FFF;">This is the'
'</span><br><span style="color: #FF0; font-size: 16pt;">PEAK</span></div>',
anchor=(-0.3, 0.5),
border='w',
fill=(0, 0, 255, 100))
annot = TextItem("test", anchor=(-0.3, 0.5))
self.chart.annotateCurve(curve, annot)
def remove_curve(self, pv_name):
"""
Remove a curve from the chart permanently. This will also clear the channel map cache from retaining the
removed curve's appearance settings.
Parameters
----------
pv_name : str
The name of the PV the curve is being plotted for
"""
curve = self.chart.findCurve(pv_name)
if curve:
self.chart.removeYChannel(curve)
del self.channel_map[pv_name]
self.chart.removeLegendItem(pv_name)
widgets = self.findChildren(
(QCheckBox, QLabel, QPushButton, QGroupBox), pv_name)
for w in widgets:
w.deleteLater()
if len(self.chart.getCurves()) < 1:
self.enable_chart_control_buttons(False)
self.show_legend_chk.setChecked(False)
def handle_title_text_changed(self, new_text):
self.chart.setPlotTitle(new_text)
def handle_change_axis_settings_clicked(self):
self.axis_settings_disp = AxisSettingsDisplay(self)
self.axis_settings_disp.show()
def handle_limit_time_span_checkbox_clicked(self, is_checked):
self.chart_limit_time_span_lbl.setVisible(is_checked)
self.chart_limit_time_span_hours_line_edt.setVisible(is_checked)
self.chart_limit_time_span_minutes_line_edt.setVisible(is_checked)
self.chart_limit_time_span_seconds_line_edt.setVisible(is_checked)
self.chart_limit_time_span_activate_btn.setVisible(is_checked)
self.chart_ring_buffer_size_lbl.setDisabled(is_checked)
self.chart_ring_buffer_size_edt.setDisabled(is_checked)
if not is_checked:
self.chart_limit_time_span_chk.setText(self.limit_time_plan_text)
def handle_time_span_edt_text_changed(self, new_text):
try:
self.time_span_limit_hours = int(
self.chart_limit_time_span_hours_line_edt.text())
self.time_span_limit_minutes = int(
self.chart_limit_time_span_minutes_line_edt.text())
self.time_span_limit_seconds = int(
self.chart_limit_time_span_seconds_line_edt.text())
except ValueError as e:
self.time_span_limit_hours = None
self.time_span_limit_minutes = None
self.time_span_limit_seconds = None
if self.time_span_limit_hours is not None and self.time_span_limit_minutes is not None and \
self.time_span_limit_seconds is not None:
self.chart_limit_time_span_activate_btn.setEnabled(True)
else:
self.chart_limit_time_span_activate_btn.setEnabled(False)
def handle_chart_limit_time_span_activate_btn_clicked(self):
if self.time_span_limit_hours is None or self.time_span_limit_minutes is None or \
self.time_span_limit_seconds is None:
display_message_box(
QMessageBox.Critical, "Invalid Values",
"Hours, minutes, and seconds expect only integer values.")
else:
timeout_milliseconds = (self.time_span_limit_hours * 3600 +
self.time_span_limit_minutes * 60 +
self.time_span_limit_seconds) * 1000
self.chart.setTimeSpan(timeout_milliseconds / 1000.0)
self.chart_ring_buffer_size_edt.setText(
str(self.chart.getBufferSize()))
def handle_buffer_size_changed(self, new_buffer_size):
try:
if new_buffer_size and int(new_buffer_size) > MINIMUM_BUFFER_SIZE:
self.chart.setBufferSize(new_buffer_size)
except ValueError:
display_message_box(QMessageBox.Critical, "Invalid Values",
"Only integer values are accepted.")
def handle_redraw_rate_changed(self, new_redraw_rate):
self.chart.maxRedrawRate = new_redraw_rate
def handle_data_sampling_rate_changed(self, new_data_sampling_rate):
# The chart expects the value in milliseconds
sampling_rate_seconds = 1 / new_data_sampling_rate
self.chart.setUpdateInterval(sampling_rate_seconds)
def handle_background_color_button_clicked(self):
selected_color = QColorDialog.getColor()
self.chart.setBackgroundColor(selected_color)
self.background_color_btn.setStyleSheet("background-color: " +
selected_color.name())
def handle_axis_color_button_clicked(self):
selected_color = QColorDialog.getColor()
self.chart.setAxisColor(selected_color)
self.axis_color_btn.setStyleSheet("background-color: " +
selected_color.name())
def handle_grid_opacity_slider_mouse_release(self):
self.grid_alpha = float(self.grid_opacity_slr.value()) / 10.0
self.chart.setShowXGrid(self.show_x_grid_chk.isChecked(),
self.grid_alpha)
self.chart.setShowYGrid(self.show_y_grid_chk.isChecked(),
self.grid_alpha)
def handle_show_x_grid_checkbox_clicked(self, is_checked):
self.chart.setShowXGrid(is_checked, self.grid_alpha)
self.axis_color_lbl.setEnabled(is_checked
or self.show_y_grid_chk.isChecked())
self.axis_color_btn.setEnabled(is_checked
or self.show_y_grid_chk.isChecked())
self.grid_opacity_lbl.setEnabled(is_checked
or self.show_y_grid_chk.isChecked())
self.grid_opacity_slr.setEnabled(is_checked
or self.show_y_grid_chk.isChecked())
def handle_show_y_grid_checkbox_clicked(self, is_checked):
self.chart.setShowYGrid(is_checked, self.grid_alpha)
self.axis_color_lbl.setEnabled(is_checked
or self.show_x_grid_chk.isChecked())
self.axis_color_btn.setEnabled(is_checked
or self.show_x_grid_chk.isChecked())
self.grid_opacity_lbl.setEnabled(is_checked
or self.show_x_grid_chk.isChecked())
self.grid_opacity_slr.setEnabled(is_checked
or self.show_x_grid_chk.isChecked())
def handle_show_legend_checkbox_clicked(self, is_checked):
self.chart.setShowLegend(is_checked)
def handle_export_data_btn_clicked(self):
self.chart_data_export_disp = ChartDataExportDisplay(self)
self.chart_data_export_disp.show()
def handle_import_data_btn_clicked(self):
open_file_info = QFileDialog.getOpenFileName(self,
caption="Save File",
filter="*." +
IMPORT_FILE_FORMAT)
open_file_name = open_file_info[0]
if open_file_name:
importer = SettingsImporter(self)
importer.import_settings(open_file_name)
def handle_sync_mode_radio_toggle(self, radio_btn):
if radio_btn.isChecked():
if radio_btn.text() == "Synchronous":
self.data_sampling_mode = SYNC_DATA_SAMPLING
self.chart_data_sampling_rate_lbl.hide()
self.chart_data_async_sampling_rate_spin.hide()
self.chart.resetTimeSpan()
self.chart_limit_time_span_chk.setChecked(False)
self.chart_limit_time_span_chk.clicked.emit(False)
self.chart_limit_time_span_chk.hide()
self.graph_drawing_settings_grpbx.setFixedHeight(180)
self.chart.setUpdatesAsynchronously(False)
elif radio_btn.text() == "Asynchronous":
self.data_sampling_mode = ASYNC_DATA_SAMPLING
self.chart_data_sampling_rate_lbl.show()
self.chart_data_async_sampling_rate_spin.show()
self.chart_limit_time_span_chk.show()
self.graph_drawing_settings_grpbx.setFixedHeight(270)
self.chart.setUpdatesAsynchronously(True)
self.app.establish_widget_connections(self)
def handle_auto_scale_btn_clicked(self):
self.chart.resetAutoRangeX()
self.chart.resetAutoRangeY()
def handle_view_all_button_clicked(self):
self.chart.getViewBox().autoRange()
def handle_pause_chart_btn_clicked(self):
if self.chart.pausePlotting():
self.pause_chart_btn.setText(self.pause_chart_text)
else:
self.pause_chart_btn.setText(self.resume_chart_text)
def handle_reset_chart_btn_clicked(self):
self.chart.getViewBox().setXRange(DEFAULT_X_MIN, 0)
self.chart.resetAutoRangeY()
@Slot()
def handle_reset_chart_settings_btn_clicked(self):
self.chart_ring_buffer_size_edt.setText(str(DEFAULT_BUFFER_SIZE))
self.chart_redraw_rate_spin.setValue(DEFAULT_REDRAW_RATE_HZ)
self.chart_data_async_sampling_rate_spin.setValue(
DEFAULT_DATA_SAMPLING_RATE_HZ)
self.chart_data_sampling_rate_lbl.hide()
self.chart_data_async_sampling_rate_spin.hide()
self.chart_sync_mode_async_radio.setChecked(True)
self.chart_sync_mode_async_radio.toggled.emit(True)
self.chart_limit_time_span_chk.setChecked(False)
self.chart_limit_time_span_chk.setText(self.limit_time_plan_text)
self.chart_limit_time_span_chk.clicked.emit(False)
self.chart.setUpdatesAsynchronously(True)
self.chart.resetTimeSpan()
self.chart.resetUpdateInterval()
self.chart.setBufferSize(DEFAULT_BUFFER_SIZE)
self.chart.setBackgroundColor(DEFAULT_CHART_BACKGROUND_COLOR)
self.background_color_btn.setStyleSheet(
"background-color: " + DEFAULT_CHART_BACKGROUND_COLOR.name())
self.chart.setAxisColor(DEFAULT_CHART_AXIS_COLOR)
self.axis_color_btn.setStyleSheet("background-color: " +
DEFAULT_CHART_AXIS_COLOR.name())
self.grid_opacity_slr.setValue(5)
self.show_x_grid_chk.setChecked(False)
self.show_x_grid_chk.clicked.emit(False)
self.show_y_grid_chk.setChecked(False)
self.show_y_grid_chk.clicked.emit(False)
self.show_legend_chk.setChecked(False)
self.chart.setShowXGrid(False)
self.chart.setShowYGrid(False)
self.chart.setShowLegend(False)
def enable_chart_control_buttons(self, enabled=True):
self.auto_scale_btn.setEnabled(enabled)
self.view_all_btn.setEnabled(enabled)
self.reset_chart_btn.setEnabled(enabled)
self.pause_chart_btn.setText(self.pause_chart_text)
self.pause_chart_btn.setEnabled(enabled)
self.export_data_btn.setEnabled(enabled)
def _get_full_pv_name(self, pv_name):
"""
Append the protocol to the PV Name.
Parameters
----------
pv_name : str
The name of the PV the curve is being plotted for
"""
if pv_name and "://" not in pv_name:
pv_name = ''.join([self.pv_protocol_cmb.currentText(), pv_name])
return pv_name
def handle_update_datetime_timer_timeout(self):
current_label = self.chart.getBottomAxisLabel()
new_label = "Current Time: " + PyDMChartingDisplay.get_current_datetime(
)
if X_AXIS_LABEL_SEPARATOR in current_label:
current_label = current_label[current_label.
find(X_AXIS_LABEL_SEPARATOR) +
len(X_AXIS_LABEL_SEPARATOR):]
new_label += X_AXIS_LABEL_SEPARATOR + current_label
self.chart.setLabel("bottom", text=new_label)
def update_curve_data(self, curve):
"""
Determine if the PV is active. If not, disable the related PV controls. If the PV is active, update the PV
controls' states.
Parameters
----------
curve : PlotItem
A PlotItem, i.e. a plot, to draw on the chart.
"""
pv_name = curve.name()
max_x = self.chart.getViewBox().viewRange()[1][0]
max_y = self.chart.getViewBox().viewRange()[1][1]
current_y = curve.data_buffer[1, -1]
widgets = self.findChildren((QCheckBox, QLabel, QPushButton), pv_name)
for w in widgets:
if np.isnan(current_y):
if isinstance(w, QCheckBox):
w.setChecked(False)
else:
if isinstance(w, QCheckBox) and not w.isEnabled():
w.setChecked(True)
if isinstance(w, QLabel):
w.clear()
w.setText(
"(yMin = {0:.3f}, yMax = {1:.3f}) y = {2:.3f}".format(
max_x, max_y, current_y))
w.show()
w.setEnabled(not np.isnan(current_y))
if isinstance(w, QPushButton) and w.text() == "Remove":
# Enable the Remove button to make removing inactive PVs possible anytime
w.setEnabled(True)
def show_mouse_coordinates(self, x, y):
self.cross_hair_coord_lbl.clear()
self.cross_hair_coord_lbl.setText("x = {0:.3f}, y = {1:.3f}".format(
x, y))
@staticmethod
def get_current_datetime():
current_date = datetime.datetime.now().strftime("%b %d, %Y")
current_time = datetime.datetime.now().strftime("%H:%M:%S")
current_datetime = current_time + ' (' + current_date + ')'
return current_datetime
@property
def gridAlpha(self):
return self.grid_alpha
class QtPluginErrReporter(QDialog):
"""Dialog that allows users to review and report PluginError tracebacks.
Parameters
----------
parent : QWidget, optional
Optional parent widget for this widget.
initial_plugin : str, optional
If provided, errors from ``initial_plugin`` will be shown when the
dialog is created, by default None
Attributes
----------
text_area : qtpy.QtWidgets.QTextEdit
The text area where traceback information will be shown.
plugin_combo : qtpy.QtWidgets.QComboBox
The dropdown menu used to select the current plugin
github_button : qtpy.QtWidgets.QPushButton
A button that, when pressed, will open an issue at the current plugin's
github issue tracker, prepopulated with a formatted traceback. Button
is only visible if a github URL is detected in the package metadata for
the current plugin.
clipboard_button : qtpy.QtWidgets.QPushButton
A button that, when pressed, copies the current traceback information
to the clipboard. (HTML tags are removed in the copied text.)
plugin_meta : qtpy.QtWidgets.QLabel
A label that will show available plugin metadata (such as home page).
"""
NULL_OPTION = 'select plugin... '
def __init__(
self,
plugin_manager: Optional[PluginManager] = None,
*,
parent: Optional[QWidget] = None,
initial_plugin: Optional[str] = None,
) -> None:
super().__init__(parent)
if not plugin_manager:
from ..plugins import plugin_manager as _pm
self.plugin_manager = _pm
else:
self.plugin_manager = plugin_manager
self.setWindowTitle('Recorded Plugin Exceptions')
self.setWindowModality(Qt.NonModal)
self.layout = QVBoxLayout()
self.layout.setSpacing(0)
self.layout.setContentsMargins(10, 10, 10, 10)
self.setLayout(self.layout)
self.text_area = QTextEdit()
self.text_area.setTextInteractionFlags(Qt.TextSelectableByMouse)
self.text_area.setMinimumWidth(360)
# Create plugin dropdown menu
self.plugin_combo = QComboBox()
self.plugin_combo.addItem(self.NULL_OPTION)
bad_plugins = [e.plugin_name for e in self.plugin_manager.get_errors()]
self.plugin_combo.addItems(list(sorted(set(bad_plugins))))
self.plugin_combo.currentTextChanged.connect(self.set_plugin)
self.plugin_combo.setCurrentText(self.NULL_OPTION)
# create github button (gets connected in self.set_plugin)
self.github_button = QPushButton('Open issue on GitHub', self)
self.github_button.setToolTip(
"Open a web browser to submit this error log\n"
"to the developer's GitHub issue tracker")
self.github_button.hide()
# create copy to clipboard button
self.clipboard_button = QPushButton()
self.clipboard_button.hide()
self.clipboard_button.setObjectName("QtCopyToClipboardButton")
self.clipboard_button.setToolTip("Copy error log to clipboard")
self.clipboard_button.clicked.connect(self.copyToClipboard)
# plugin_meta contains a URL to the home page, (and/or other details)
self.plugin_meta = QLabel('', parent=self)
self.plugin_meta.setObjectName("pluginInfo")
self.plugin_meta.setTextFormat(Qt.RichText)
self.plugin_meta.setTextInteractionFlags(Qt.TextBrowserInteraction)
self.plugin_meta.setOpenExternalLinks(True)
self.plugin_meta.setAlignment(Qt.AlignRight)
# make layout
row_1_layout = QHBoxLayout()
row_1_layout.setContentsMargins(11, 5, 10, 0)
row_1_layout.addStretch(1)
row_1_layout.addWidget(self.plugin_meta)
row_2_layout = QHBoxLayout()
row_2_layout.setContentsMargins(11, 5, 10, 0)
row_2_layout.addWidget(self.plugin_combo)
row_2_layout.addStretch(1)
row_2_layout.addWidget(self.github_button)
row_2_layout.addWidget(self.clipboard_button)
row_2_layout.setSpacing(5)
self.layout.addLayout(row_1_layout)
self.layout.addLayout(row_2_layout)
self.layout.addWidget(self.text_area, 1)
self.setMinimumWidth(750)
self.setMinimumHeight(600)
if initial_plugin:
self.set_plugin(initial_plugin)
def set_plugin(self, plugin: str) -> None:
"""Set the current plugin shown in the dropdown and text area.
Parameters
----------
plugin : str
name of a plugin that has created an error this session.
"""
self.github_button.hide()
self.clipboard_button.hide()
try:
self.github_button.clicked.disconnect()
# when disconnecting a non-existent signal
# PySide2 raises runtimeError, PyQt5 raises TypeError
except (RuntimeError, TypeError):
pass
if not plugin or (plugin == self.NULL_OPTION):
self.plugin_meta.setText('')
self.text_area.setHtml('')
return
if not self.plugin_manager.get_errors(plugin):
raise ValueError(f"No errors reported for plugin '{plugin}'")
self.plugin_combo.setCurrentText(plugin)
err_string = format_exceptions(plugin, as_html=True)
self.text_area.setHtml(err_string)
self.clipboard_button.show()
# set metadata and outbound links/buttons
err0 = self.plugin_manager.get_errors(plugin)[0]
meta = standard_metadata(err0.plugin) if err0.plugin else {}
meta_text = ''
if not meta:
self.plugin_meta.setText(meta_text)
return
url = meta.get('url')
if url:
meta_text += (
'<span style="color:#999;">plugin home page: '
f'</span><a href="{url}" style="color:#999">{url}</a>')
if 'github.com' in url:
def onclick():
import webbrowser
err = format_exceptions(plugin, as_html=False)
err = (
"<!--Provide detail on the error here-->\n\n\n\n"
"<details>\n<summary>Traceback from napari</summary>"
f"\n\n```\n{err}\n```\n</details>")
url = f'{meta.get("url")}/issues/new?&body={err}'
webbrowser.open(url, new=2)
self.github_button.clicked.connect(onclick)
self.github_button.show()
self.plugin_meta.setText(meta_text)
def copyToClipboard(self) -> None:
"""Copy current plugin traceback info to clipboard as plain text."""
plugin = self.plugin_combo.currentText()
err_string = format_exceptions(plugin, as_html=False)
cb = QGuiApplication.clipboard()
cb.setText(err_string)
class PMGTableViewer(QWidget):
"""
一个含有QTableView的控件。
有切片和保存两个按钮。点击Slice的时候可以切片查看，点击Save保存。
"""
data_modified_signal = Signal()
signal_need_save = Signal(bool)
def __init__(self, parent=None, table_view: 'PMTableView' = None):
super().__init__(parent)
self.setLayout(QVBoxLayout())
self.top_layout = QHBoxLayout()
self.layout().addLayout(self.top_layout)
self.table_view = table_view
self.slice_input = QLineEdit()
self.help_button = QPushButton(QCoreApplication.translate('PMGTableViewer','Help'))
self.slice_refresh_button = QPushButton(QCoreApplication.translate('PMGTableViewer','Slice'))
self.save_change_button = QPushButton(QCoreApplication.translate('PMGTableViewer','Save'))
self.goto_cell_button = QPushButton(QCoreApplication.translate('PMGTableViewer','Go To Cell'))
self.save_change_button.clicked.connect(self.on_save)
self.slice_refresh_button.clicked.connect(self.slice)
self.help_button.clicked.connect(self.on_help)
self.goto_cell_button.clicked.connect(self.on_goto_cell)
self.slice_input.hide()
self.slice_refresh_button.hide()
self.table_view.signal_need_save.connect(self.signal_need_save.emit)
self.signal_need_save.connect(self.on_signal_need_save)
self.top_layout.addWidget(self.goto_cell_button)
self.top_layout.addWidget(self.save_change_button)
self.top_layout.addWidget(self.help_button)
self.top_layout.addWidget(self.slice_input)
self.top_layout.addWidget(self.slice_refresh_button)
self.top_layout.addItem(QSpacerItem(0, 0, QSizePolicy.Expanding, QSizePolicy.Minimum))
if table_view is not None:
self.layout().addWidget(self.table_view)
self.shortcut_save = QShortcut(QKeySequence.Save, self.table_view, context=Qt.WidgetShortcut)
self.shortcut_save.activated.connect(self.on_save)
self.shortcut_goto = QShortcut(QKeySequence('Ctrl+G'), self.table_view, context=Qt.WidgetShortcut)
self.shortcut_goto.activated.connect(self.on_goto_cell)
def on_help(self):
dlg = TextShowDialog(title=QCoreApplication.translate('PMGTableViewer','Help'))
with open(os.path.join(os.path.dirname(__file__), 'help', 'help.md'), 'r', encoding='utf8',
errors='replace') as f:
dlg.set_markdown(f.read())
dlg.exec_()
def on_signal_need_save(self, need_save: str):
title = self.windowTitle()
if need_save:
if not title.startswith('*'):
self.setWindowTitle('*' + title)
else:
if title.startswith('*'):
self.setWindowTitle(title.strip('*'))
def on_save(self):
self.signal_need_save.emit(False)
self.data_modified_signal.emit()
def set_data(self, data: typing.Any) -> None:
"""
set_data方法在初次调用时，设置其内部的data参数；
当后面调用的时候，不会更改内部的data参数。
get_default_slicing_statement的意思是可以获取默认的切片索引。
这是因为表格一般只能显示二维的数据，当数组维数超过二维的时候，就需要尽可能地利用切片进行显示了。
比如对于四维np.array张量，返回的默认就是[:,:,0,0]。用户可以根据自己的需要进行切片。
:param data:
:return:
"""
if self.table_view is not None:
self.table_view.set_data(data)
self.slice_input.setText(self.table_view.get_default_slicing_statement())
self.slice()
def get_data(self):
return self.table_view.model._data
def slice(self):
"""
切片操作。同时屏蔽可能出现的非法字符。
目前做不到对array数组进行索引。
:return:
"""
data = self.table_view.data
text = self.slice_input.text().strip()
for char in text:
if not char in "[]:,.1234567890iloc":
QMessageBox.warning(self, QCoreApplication.translate('PMGTableViewer','Invalid Input'),
QCoreApplication.translate('PMGTableViewer',"invalid character \"%s\" in slicing statement.") % char)
return
try:
data = eval('data' + text)
except Exception as exeption:
QMessageBox.warning(self, QCoreApplication.translate('PMGTableViewer','Invalid Input'),
QCoreApplication.translate('PMGTableViewer',str(exeption)))
self.table_view.show_data(data)
def closeEvent(self, a0: 'QCloseEvent') -> None:
super().closeEvent(a0)
def on_goto_cell(self):
if isinstance(self.table_view.model, (TableModelForPandasDataframe, TableModelForNumpyArray)):
min_row, max_row = 1, self.table_view.model.rowCount(None)
current_row = self.table_view.currentIndex().row() + 1
current_col = self.table_view.currentIndex().column() + 1
row, _ = QInputDialog.getInt(self, QCoreApplication.translate('PMGTableViewer','Input Row'),
QCoreApplication.translate('PMGTableViewer','Target Row No.:({min}~{max})').format(min=min_row, max=max_row),
current_row,
min_row, max_row, step=1)
if _:
self.table_view.on_goto_index(row - 1, 0)
else:
raise NotImplementedError
