class FormComboWidget(QWidget):
update_buttons = Signal()
def __init__(self, datalist, comment="", parent=None):
QWidget.__init__(self, parent)
layout = QVBoxLayout()
self.setLayout(layout)
self.combobox = QComboBox()
layout.addWidget(self.combobox)
self.stackwidget = QStackedWidget(self)
layout.addWidget(self.stackwidget)
self.combobox.currentIndexChanged.connect(
self.stackwidget.setCurrentIndex)
self.widgetlist = []
for data, title, comment in datalist:
self.combobox.addItem(title)
widget = FormWidget(data, comment=comment, parent=self)
self.stackwidget.addWidget(widget)
self.widgetlist.append(widget)
def setup(self):
for widget in self.widgetlist:
widget.setup()
def get(self):
return [ widget.get() for widget in self.widgetlist]
def create_controls(self):
self.setWindowTitle(tr(self.plugin.name))
vbox = QVBoxLayout()
form = QFormLayout()
for Name, (enabled, url) in self.packages.items():
name = Name.lower()
cbo = QComboBox()
if enabled:
branches = get_branches(name, url)
for n, b in branches.items():
cbo.addItem(n, b)
if not check_git_repo(name):
cbo.insertItem(0, "<Select to change>", None)
cbo.setCurrentIndex(0)
self._prev_indices[cbo] = 0
cbo.currentIndexChanged.connect(
partial(self._cbo_changed, cbo))
else:
cbo.setEditText("<git repository>")
cbo.setToolTip(tr(
"This is installed in a git repository but we're set to "
"not use git."))
cbo.setEnabled(enabled)
form.addRow(Name + ':', cbo)
vbox.addLayout(form)
vbox.addWidget(QLabel(tr(
"You should restart the application if you make any changes!")))
btns = QDialogButtonBox(QDialogButtonBox.Ok, Qt.Horizontal, self)
btns.accepted.connect(self.accept)
vbox.addWidget(btns)
self.setLayout(vbox)
def create_combobox(self, text, choices, option, default=NoDefault,
tip=None, restart=False):
"""choices: couples (name, key)"""
label = QLabel(text)
combobox = QComboBox()
if tip is not None:
combobox.setToolTip(tip)
for name, key in choices:
if not (name is None and key is None):
combobox.addItem(name, to_qvariant(key))
# Insert separators
count = 0
for index, item in enumerate(choices):
name, key = item
if name is None and key is None:
combobox.insertSeparator(index + count)
count += 1
self.comboboxes[combobox] = (option, default)
layout = QHBoxLayout()
layout.addWidget(label)
layout.addWidget(combobox)
layout.addStretch(1)
layout.setContentsMargins(0, 0, 0, 0)
widget = QWidget(self)
widget.label = label
widget.combobox = combobox
widget.setLayout(layout)
combobox.restart_required = restart
combobox.label_text = text
return widget
class RunConfigDialog(BaseRunConfigDialog):
"""Run configuration dialog box: multiple file version"""
def __init__(self, parent=None):
BaseRunConfigDialog.__init__(self, parent)
self.file_to_run = None
self.combo = None
self.stack = None
def run_btn_clicked(self):
"""Run button was just clicked"""
self.file_to_run = to_text_string(self.combo.currentText())
def setup(self, fname):
"""Setup Run Configuration dialog with filename *fname*"""
combo_label = QLabel(_("Select a run configuration:"))
self.combo = QComboBox()
self.combo.setMaxVisibleItems(20)
self.combo.setSizeAdjustPolicy(QComboBox.AdjustToMinimumContentsLength)
self.combo.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
self.stack = QStackedWidget()
configurations = _get_run_configurations()
for index, (filename, options) in enumerate(configurations):
if fname == filename:
break
else:
# There is no run configuration for script *fname*:
# creating a temporary configuration that will be kept only if
# dialog changes are accepted by the user
configurations.insert(0, (fname, RunConfiguration(fname).get()))
index = 0
for filename, options in configurations:
widget = RunConfigOptions(self)
widget.set(options)
self.combo.addItem(filename)
self.stack.addWidget(widget)
self.combo.currentIndexChanged.connect(self.stack.setCurrentIndex)
self.combo.setCurrentIndex(index)
self.add_widgets(combo_label, self.combo, 10, self.stack)
self.add_button_box(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
self.setWindowTitle(_("Run configuration per file"))
def accept(self):
"""Reimplement Qt method"""
configurations = []
for index in range(self.stack.count()):
filename = to_text_string(self.combo.itemText(index))
runconfigoptions = self.stack.widget(index)
if index == self.stack.currentIndex() and\
not runconfigoptions.is_valid():
return
options = runconfigoptions.get()
configurations.append((filename, options))
_set_run_configurations(configurations)
QDialog.accept(self)
class RunConfigDialog(BaseRunConfigDialog):
"""Run configuration dialog box: multiple file version"""
def __init__(self, parent=None):
BaseRunConfigDialog.__init__(self, parent)
self.file_to_run = None
self.combo = None
self.stack = None
def run_btn_clicked(self):
"""Run button was just clicked"""
self.file_to_run = to_text_string(self.combo.currentText())
def setup(self, fname):
"""Setup Run Configuration dialog with filename *fname*"""
combo_label = QLabel(_("Select a run configuration:"))
self.combo = QComboBox()
self.combo.setMaxVisibleItems(20)
self.combo.setSizeAdjustPolicy(QComboBox.AdjustToMinimumContentsLength)
self.combo.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
self.stack = QStackedWidget()
configurations = _get_run_configurations()
for index, (filename, options) in enumerate(configurations):
if fname == filename:
break
else:
# There is no run configuration for script *fname*:
# creating a temporary configuration that will be kept only if
# dialog changes are accepted by the user
configurations.insert(0, (fname, RunConfiguration(fname).get()))
index = 0
for filename, options in configurations:
widget = RunConfigOptions(self)
widget.set(options)
self.combo.addItem(filename)
self.stack.addWidget(widget)
self.combo.currentIndexChanged.connect(self.stack.setCurrentIndex)
self.combo.setCurrentIndex(index)
self.add_widgets(combo_label, self.combo, 10, self.stack)
self.add_button_box(QDialogButtonBox.Ok|QDialogButtonBox.Cancel)
self.setWindowTitle(_("Run configuration per file"))
def accept(self):
"""Reimplement Qt method"""
configurations = []
for index in range(self.stack.count()):
filename = to_text_string(self.combo.itemText(index))
runconfigoptions = self.stack.widget(index)
if index == self.stack.currentIndex() and\
not runconfigoptions.is_valid():
return
options = runconfigoptions.get()
configurations.append( (filename, options) )
_set_run_configurations(configurations)
QDialog.accept(self)
class LandscapeView(ViewBase):
def setup_ui(self):
"""Initialize widgets."""
info_label = QLabel()
info_label.setText("Hit enter to capture your image!")
self.image_label = QLabel()
self.image_label.setMinimumSize(320, 240)
self.image_label.setScaledContents(True)
button_layout = QVBoxLayout()
button_layout.setAlignment(Qt.AlignLeft)
self.style_buttons = [
QRadioButton(settings.STYLE_SHORTCUTS[i] + ". " + style.name
if i < len(settings.STYLE_SHORTCUTS) else style.name)
for i, style in enumerate(self.styles)
]
self.style_buttons[self.styles.index(
self.selected_style)].setChecked(True)
self.style_button_group = QButtonGroup()
for i, btn in enumerate(self.style_buttons):
button_layout.addWidget(btn)
self.style_button_group.addButton(btn, i)
btn.clicked.connect(
partial(lambda style: self.style_button_clicked(style),
self.styles[i]))
button_layout.addStretch(1)
ctrl_layout = QHBoxLayout()
if not settings.KIOSK:
fullscreen_button = QPushButton('[ ]')
fullscreen_button.setMaximumWidth(
fullscreen_button.fontMetrics().boundingRect('[ ]').width() +
10)
fullscreen_button.clicked.connect(self.toggle_fullscreen)
ctrl_layout.addWidget(fullscreen_button)
ctrl_layout.addStretch(1)
self.size_combo = QComboBox()
for s in settings.SIZES:
self.size_combo.addItem(s)
self.size_combo.setCurrentIndex(settings.SIZES.index(self.quality))
ctrl_layout.addWidget(self.size_combo)
self.size_combo.activated[str].connect(self.quality_choice)
button_layout.addLayout(ctrl_layout)
sub_layout = QHBoxLayout()
sub_layout.addLayout(button_layout)
sub_layout.addWidget(self.image_label, 1)
main_layout = QVBoxLayout()
main_layout.addWidget(info_label)
main_layout.addLayout(sub_layout)
self.setLayout(main_layout)
def __init__(self, layer):
super().__init__(layer)
self.layer.events.edge_width.connect(self._on_edge_width_change)
self.layer.events.edge_color.connect(self._on_edge_color_change)
self.layer.events.face_color.connect(self._on_face_color_change)
sld = QSlider(Qt.Horizontal, self)
sld.setFocusPolicy(Qt.NoFocus)
sld.setFixedWidth(75)
sld.setMinimum(0)
sld.setMaximum(40)
sld.setSingleStep(1)
value = self.layer.edge_width
if isinstance(value, Iterable):
if isinstance(value, list):
value = np.asarray(value)
value = value.mean()
sld.setValue(int(value))
sld.valueChanged[int].connect(lambda value=sld:
self.changeWidth(value))
self.widthSlider = sld
self.grid_layout.addWidget(QLabel('width:'), 3, 0)
self.grid_layout.addWidget(sld, 3, 1)
face_comboBox = QComboBox()
colors = self.layer._colors
for c in colors:
face_comboBox.addItem(c)
index = face_comboBox.findText(
self.layer.face_color, Qt.MatchFixedString)
if index >= 0:
face_comboBox.setCurrentIndex(index)
face_comboBox.activated[str].connect(lambda text=face_comboBox:
self.changeFaceColor(text))
self.faceComboBox = face_comboBox
self.grid_layout.addWidget(QLabel('face_color:'), 4, 0)
self.grid_layout.addWidget(face_comboBox, 4, 1)
edge_comboBox = QComboBox()
colors = self.layer._colors
for c in colors:
edge_comboBox.addItem(c)
index = edge_comboBox.findText(
self.layer.edge_color, Qt.MatchFixedString)
if index >= 0:
edge_comboBox.setCurrentIndex(index)
edge_comboBox.activated[str].connect(lambda text=edge_comboBox:
self.changeEdgeColor(text))
self.edgeComboBox = edge_comboBox
self.grid_layout.addWidget(QLabel('edge_color:'), 5, 0)
self.grid_layout.addWidget(edge_comboBox, 5, 1)
self.setExpanded(False)
def __init__(self, layer):
super().__init__(layer)
self.layer.events.edge_width.connect(self._on_width_change)
self.layer.events.length.connect(self._on_len_change)
self.layer.events.edge_color.connect(self._on_edge_color_change)
# vector color adjustment and widget
edge_comboBox = QComboBox()
colors = self.layer._colors
for c in colors:
edge_comboBox.addItem(c)
edge_comboBox.activated[str].connect(
lambda text=edge_comboBox: self.change_edge_color(text))
self.edgeComboBox = edge_comboBox
self.edgeColorSwatch = QFrame()
self.edgeColorSwatch.setObjectName('swatch')
self.edgeColorSwatch.setToolTip('Edge color swatch')
self._on_edge_color_change(None)
# line width in pixels
self.widthSpinBox = QDoubleSpinBox()
self.widthSpinBox.setKeyboardTracking(False)
self.widthSpinBox.setSingleStep(0.1)
self.widthSpinBox.setMinimum(0.1)
value = self.layer.edge_width
self.widthSpinBox.setValue(value)
self.widthSpinBox.valueChanged.connect(self.change_width)
# line length
self.lengthSpinBox = QDoubleSpinBox()
self.lengthSpinBox.setKeyboardTracking(False)
self.lengthSpinBox.setSingleStep(0.1)
value = self.layer.length
self.lengthSpinBox.setValue(value)
self.lengthSpinBox.setMinimum(0.1)
self.lengthSpinBox.valueChanged.connect(self.change_length)
# grid_layout created in QtLayerControls
# addWidget(widget, row, column, [row_span, column_span])
self.grid_layout.addWidget(QLabel('opacity:'), 0, 0)
self.grid_layout.addWidget(self.opacitySilder, 0, 1, 1, 2)
self.grid_layout.addWidget(QLabel('width:'), 1, 0)
self.grid_layout.addWidget(self.widthSpinBox, 1, 1, 1, 2)
self.grid_layout.addWidget(QLabel('length:'), 2, 0)
self.grid_layout.addWidget(self.lengthSpinBox, 2, 1, 1, 2)
self.grid_layout.addWidget(QLabel('blending:'), 3, 0)
self.grid_layout.addWidget(self.blendComboBox, 3, 1, 1, 2)
self.grid_layout.addWidget(QLabel('edge color:'), 4, 0)
self.grid_layout.addWidget(self.edgeComboBox, 4, 2)
self.grid_layout.addWidget(self.edgeColorSwatch, 4, 1)
self.grid_layout.setRowStretch(5, 1)
self.grid_layout.setColumnStretch(1, 1)
self.grid_layout.setSpacing(4)
def __init__(self, layer):
super().__init__(layer)
self.layer.events.averaging.connect(self._on_avg_change)
self.layer.events.width.connect(self._on_width_change)
self.layer.events.length.connect(self._on_len_change)
# vector color adjustment and widget
face_comboBox = QComboBox()
colors = self.layer._colors
for c in colors:
face_comboBox.addItem(c)
index = face_comboBox.findText(self.layer.color, Qt.MatchFixedString)
if index >= 0:
face_comboBox.setCurrentIndex(index)
face_comboBox.activated[str].connect(
lambda text=face_comboBox: self.change_face_color(text))
self.grid_layout.addWidget(QLabel('color:'), 3, 0)
self.grid_layout.addWidget(face_comboBox, 3, 1)
# line width in pixels
self.width_field = QDoubleSpinBox()
self.width_field.setSingleStep(0.1)
self.width_field.setMinimum(0.1)
value = self.layer.width
self.width_field.setValue(value)
self.width_field.valueChanged.connect(self.change_width)
self.grid_layout.addWidget(QLabel('width:'), 4, 0)
self.grid_layout.addWidget(self.width_field, 4, 1)
# averaging spinbox
self.averaging_spinbox = QSpinBox()
self.averaging_spinbox.setSingleStep(1)
self.averaging_spinbox.setValue(1)
self.averaging_spinbox.setMinimum(1)
self.averaging_spinbox.valueChanged.connect(self.change_average_type)
self.grid_layout.addWidget(QLabel('avg kernel'), 5, 0)
self.grid_layout.addWidget(self.averaging_spinbox, 5, 1)
# line length
self.length_field = QDoubleSpinBox()
self.length_field.setSingleStep(0.1)
value = self.layer.length
self.length_field.setValue(value)
self.length_field.setMinimum(0.1)
self.length_field.valueChanged.connect(self.change_length)
self.grid_layout.addWidget(QLabel('length:'), 6, 0)
self.grid_layout.addWidget(self.length_field, 6, 1)
self.setExpanded(False)
def _create_dropdown(self, layout, value, path):
def _atomic_set_str(value):
local_params = self.copy_params
for path_element in path:
local_params = local_params[path_element]
local_params["value"] = value
widget = QComboBox()
for element in value["range"]:
widget.addItem(element)
widget.setCurrentText(value["value"])
widget.currentTextChanged.connect(_atomic_set_str)
layout.addWidget(widget)
self.test_dropdown = widget # for testing
class CSVSettingsDialog(QDialog):
def __init__(self, parent=None):
super().__init__(parent)
self.settings = QSettings()
# decimal
self.decimalLabel = QLabel(self.tr("decimal:"))
self.decimalComboBox = QComboBox()
self.decimalLabel.setBuddy(self.decimalComboBox)
self.decimalComboBox.addItems([",", "."])
# separator
self.separatorLabel = QLabel(self.tr("separator:"))
self.separatorComboBox = QComboBox()
self.separatorLabel.setBuddy(self.separatorComboBox)
self.separatorComboBox.addItem("Semicolon ';'", ';')
self.separatorComboBox.addItem("Comma ','", ',')
self.separatorComboBox.addItem("Tabulator '\\t'", '\t')
self.separatorComboBox.addItem("Whitespace ' '", ' ')
# buttons
self.buttons = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
self.buttons.accepted.connect(self.accept)
self.buttons.rejected.connect(self.reject)
# layout
layout = QGridLayout()
layout.addWidget(self.decimalLabel, 0, 0)
layout.addWidget(self.decimalComboBox, 0, 1)
layout.addWidget(self.separatorLabel, 1, 0)
layout.addWidget(self.separatorComboBox, 1, 1)
layout.addWidget(self.buttons, 2, 0, 1, 2)
self.setLayout(layout)
# settings
self.decimalComboBox.setCurrentIndex(
self.decimalComboBox.findText(
self.settings.value(DECIMAL_SETTING, ",")))
self.separatorComboBox.setCurrentIndex(
self.separatorComboBox.findData(
self.settings.value(SEPARATOR_SETTING, ";")))
self.setWindowTitle(self.tr("record settings"))
def accept(self):
self.settings.setValue(DECIMAL_SETTING, self.decimal)
self.settings.setValue(SEPARATOR_SETTING, self.separator)
super().accept()
# decimal property
@property
def decimal(self):
return self.decimalComboBox.currentText()
# seperator property
@property
def separator(self):
return self.separatorComboBox.itemData(
self.separatorComboBox.currentIndex())
def uicreate_combobox(self, parent, orb_tp, idx):
"""."""
combo = QComboBox(parent)
combo.setObjectName('ComboBox_' + orb_tp + str(idx))
sz_pol = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
combo.setSizePolicy(sz_pol)
combo.setMaxVisibleItems(10)
for name in sorted(self.controls.keys()):
combo.addItem(name)
combo.addItem('Zero')
combo.currentTextChanged.connect(
_part(self.updater[idx].some_changed, orb_tp))
combo.setCurrentIndex(0)
return combo
class ParamComboBox(WidgetForParam):
def __init__(self):
super().__init__()
self.keys_to_check.extend(['choices'])
self.conditions.extend([lambda param_x: param_x['type'] == str])
def create_widget(self):
self.check_param(self.param, assert_error=True)
self.widget = QComboBox()
for choice in self.param["choices"]:
self.widget.addItem(str(choice))
def connect_widget(self):
self.widget.currentTextChanged.connect(lambda value: self.change_param(value))
class SFeatureFilterWidget(QWidget):
"""Widget for the features filter plugin"""
def __init__(self, napari_viewer, layer_name, parent_plugin):
super().__init__()
self.viewer = napari_viewer
self.layer_name = layer_name
self.parent_plugin = parent_plugin
self.features_box = QComboBox()
if len(napari_viewer.layers) > 0:
for key in napari_viewer.layers[layer_name].metadata.keys():
self.features_box.addItem(key)
layout = QGridLayout()
layout.addWidget(QLabel('Feature:'), 0, 0)
layout.addWidget(self.features_box, 0, 1)
min_label = QLabel("Min:")
self.min_val = QLineEdit()
layout.addWidget(min_label, 1, 0)
layout.addWidget(self.min_val, 1, 1)
max_label = QLabel("Max:")
self.max_val = QLineEdit()
layout.addWidget(max_label, 2, 0)
layout.addWidget(self.max_val, 2, 1)
self.setLayout(layout)
def check_inputs(self):
try:
_ = float(self.min_val.text())
except ValueError as err:
self.parent_plugin.show_error(f"Min value must be a number")
return False
try:
_ = float(self.max_val.text())
except ValueError as err:
self.parent_plugin.show_error(f"Max value must be a number")
return False
return True
def parameters(self):
return {
'feature': self.features_box.currentText(),
'min': float(self.min_val.text()),
'max': float(self.max_val.text())
}
def __init__(self, layer):
super().__init__(layer)
self.layer.events.interpolation.connect(self._on_interpolation_change)
self.layer.events.rendering.connect(self._on_rendering_change)
interp_comboBox = QComboBox()
for interp in Interpolation:
interp_comboBox.addItem(str(interp))
index = interp_comboBox.findText(
self.layer.interpolation, Qt.MatchFixedString
)
interp_comboBox.setCurrentIndex(index)
interp_comboBox.activated[str].connect(
lambda text=interp_comboBox: self.changeInterpolation(text)
)
self.interpComboBox = interp_comboBox
renderComboBox = QComboBox()
for render in Rendering:
renderComboBox.addItem(str(render))
index = renderComboBox.findText(
self.layer.rendering, Qt.MatchFixedString
)
renderComboBox.setCurrentIndex(index)
renderComboBox.activated[str].connect(
lambda text=renderComboBox: self.changeRendering(text)
)
self.renderComboBox = renderComboBox
# grid_layout created in QtLayerControls
# addWidget(widget, row, column, [row_span, column_span])
self.grid_layout.addWidget(QLabel('opacity:'), 0, 0, 1, 3)
self.grid_layout.addWidget(self.opacitySilder, 0, 3, 1, 4)
self.grid_layout.addWidget(QLabel('contrast limits:'), 1, 0, 1, 3)
self.grid_layout.addWidget(self.contrastLimitsSlider, 1, 3, 1, 4)
self.grid_layout.addWidget(QLabel('colormap:'), 2, 0, 1, 3)
self.grid_layout.addWidget(self.colormapComboBox, 2, 3, 1, 3)
self.grid_layout.addWidget(self.colorbarLabel, 2, 6)
self.grid_layout.addWidget(QLabel('blending:'), 3, 0, 1, 3)
self.grid_layout.addWidget(self.blendComboBox, 3, 3, 1, 4)
self.grid_layout.addWidget(QLabel('rendering:'), 4, 0, 1, 3)
self.grid_layout.addWidget(self.renderComboBox, 4, 3, 1, 4)
self.grid_layout.addWidget(QLabel('interpolation:'), 5, 0, 1, 3)
self.grid_layout.addWidget(self.interpComboBox, 5, 3, 1, 4)
self.grid_layout.setRowStretch(6, 1)
self.grid_layout.setVerticalSpacing(4)
def __init__(self, layer):
super().__init__(layer)
self.layer.events.colormap.connect(self._on_colormap_change)
self.layer.events.contrast_limits.connect(
lambda e: self.contrast_limits_slider_update()
)
self.layer.events.gamma.connect(lambda e: self.gamma_slider_update())
comboBox = QComboBox()
for cmap in self.layer.colormaps:
comboBox.addItem(cmap)
comboBox._allitems = set(self.layer.colormaps)
comboBox.activated[str].connect(
lambda text=comboBox: self.changeColor(text)
)
self.colormapComboBox = comboBox
# Create contrast_limits slider
self.contrastLimitsSlider = QHRangeSlider(
slider_range=[0, 1, 0.0001], values=[0, 1]
)
self.contrastLimitsSlider.setEmitWhileMoving(True)
self.contrastLimitsSlider.collapsable = False
self.contrastLimitsSlider.setEnabled(True)
self.contrastLimitsSlider.rangeChanged.connect(
self.contrast_limits_slider_changed
)
self.contrast_limits_slider_update()
# gamma slider
sld = QSlider(Qt.Horizontal)
sld.setFocusPolicy(Qt.NoFocus)
sld.setMinimum(2)
sld.setMaximum(200)
sld.setSingleStep(2)
sld.setValue(100)
sld.valueChanged[int].connect(self.gamma_slider_changed)
self.gammaSlider = sld
self.gamma_slider_update()
self.colorbarLabel = QLabel()
self.colorbarLabel.setObjectName('colorbar')
self.colorbarLabel.setToolTip('Colorbar')
self._on_colormap_change(None)
def __init__(self, layer):
super().__init__(layer)
self.layer.events.edge_width.connect(self._on_width_change)
self.layer.events.length.connect(self._on_len_change)
# vector color adjustment and widget
face_comboBox = QComboBox()
colors = self.layer._colors
for c in colors:
face_comboBox.addItem(c)
index = face_comboBox.findText(self.layer.edge_color,
Qt.MatchFixedString)
if index >= 0:
face_comboBox.setCurrentIndex(index)
face_comboBox.activated[str].connect(
lambda text=face_comboBox: self.change_edge_color(text))
row = self.grid_layout.rowCount()
self.grid_layout.addWidget(QLabel('color:'), row, self.name_column)
self.grid_layout.addWidget(face_comboBox, row, self.property_column)
# line width in pixels
self.width_field = QDoubleSpinBox()
self.width_field.setSingleStep(0.1)
self.width_field.setMinimum(0.1)
value = self.layer.edge_width
self.width_field.setValue(value)
self.width_field.valueChanged.connect(self.change_width)
row = self.grid_layout.rowCount()
self.grid_layout.addWidget(QLabel('width:'), row, self.name_column)
self.grid_layout.addWidget(self.width_field, row, self.property_column)
# line length
self.length_field = QDoubleSpinBox()
self.length_field.setSingleStep(0.1)
value = self.layer.length
self.length_field.setValue(value)
self.length_field.setMinimum(0.1)
self.length_field.valueChanged.connect(self.change_length)
row = self.grid_layout.rowCount()
self.grid_layout.addWidget(QLabel('length:'), row, self.name_column)
self.grid_layout.addWidget(self.length_field, row,
self.property_column)
self.setExpanded(False)
class ImageAdjustmentDialog(QDialog):
def __init__(self,
image: Image,
transform_dict: Dict[str, TransformBase] = None):
super().__init__()
if transform_dict is None:
transform_dict = image_transform_dict
self.choose = QComboBox()
self.stacked = QStackedWidget()
for key, val in transform_dict.items():
self.choose.addItem(key)
initial_values = val.calculate_initial(image)
form_widget = FormWidget(
val.get_fields_per_dimension(image.get_dimension_letters()),
initial_values)
self.stacked.addWidget(form_widget)
self.choose.currentIndexChanged.connect(self.stacked.setCurrentIndex)
self.cancel_btn = QPushButton("Cancel")
self.cancel_btn.clicked.connect(self.reject)
self.process_btn = QPushButton("Process")
self.process_btn.clicked.connect(self.process)
self.transform_dict = transform_dict
self.result_val: ImageAdjustTuple = None
layout = QGridLayout()
layout.addWidget(self.choose, 0, 0, 1, 3)
layout.addWidget(self.stacked, 1, 0, 1, 3)
layout.addWidget(self.cancel_btn, 2, 0)
layout.addWidget(self.process_btn, 2, 2)
self.setLayout(layout)
def process(self):
values = self.stacked.currentWidget().get_values()
algorithm = self.transform_dict[self.choose.currentText()]
self.result_val = ImageAdjustTuple(values, algorithm)
self.accept()
class PairPlotIntentCanvas(XicamIntentCanvas):
def __init__(self, *args, **kwargs):
super(PairPlotIntentCanvas, self).__init__()
self.transform_data = None
self.plot_widget = PlotIntentCanvasBlend()
self.plot_widget.setAspectLocked(True)
self.componentA = QComboBox()
self.componentB = QComboBox()
self.setLayout(QVBoxLayout())
self.layout().addWidget(self.plot_widget)
self.layout().addWidget(self.componentA)
self.layout().addWidget(self.componentB)
# Signals
self.componentA.currentIndexChanged.connect(self.show_pair)
self.componentB.currentIndexChanged.connect(self.show_pair)
def render(self, intent: PairPlotIntent):
n_components = intent.transform_data.shape[-1]
for i in range(n_components):
self.componentA.addItem(f'Component {i+1}')
self.componentB.addItem(f'Component {i + 1}')
self.transform_data = intent.transform_data
def show_pair(self):
if self.transform_data is not None:
A = self.componentA.currentIndex()
B = self.componentB.currentIndex()
A_data = np.asarray(self.transform_data[:, :, A]).ravel()
B_data = np.asarray(self.transform_data[:, :, B]).ravel()
self.plot_widget.clear()
item = pg.ScatterPlotItem(x=B_data, y=A_data)
self.plot_widget.addItem(item)
self.plot_widget.setLabels(left=f'Component {A+1}',
bottom=f'Component {B+1}')
def dropdown_row(label: str,
placeholder: str = None,
default: str = None,
options=None,
enabled=False) -> FormRow:
"""
Given the contents of a dropdown and a label, return a FormRow containing
a label and a QComboBox widget that can be used with the custom Form widget
"""
dropdown = QComboBox()
dropdown.setDisabled(not enabled)
dropdown.setStyleSheet("QComboBox { combobox-popup: 0; }")
if placeholder is not None:
dropdown.addItem(placeholder)
if options is not None:
str_options = [str(option) for option in options]
dropdown.addItems(str_options)
if placeholder is None and default is not None and options is not None:
default_index = options.index(default)
dropdown.setCurrentIndex(default_index)
return FormRow(label, dropdown)
def __init__(self, iterable=False, load_all=False, help_link=""):
QWidget.__init__(self)
self._iterable = iterable
addHelpToWidget(self, help_link)
layout = QHBoxLayout()
analysis_module_combo = QComboBox()
self._module_names = getAnalysisModuleNames(self._iterable)
if load_all:
self._module_names += getAnalysisModuleNames(not self._iterable)
suffix = {"STD_ENKF": " - Recommended"}
for module_name in self._module_names:
analysis_module_combo.addItem(module_name +
suffix.get(module_name, ""))
self._current_module_name = self._getCurrentAnalysisModuleName()
if self._current_module_name is not None:
analysis_module_combo.setCurrentIndex(
self._module_names.index(self._current_module_name))
analysis_module_combo.currentIndexChanged[int].connect(
self.analysisModuleChanged)
variables_popup_button = QToolButton()
variables_popup_button.setIcon(resourceIcon("ide/small/cog_edit.png"))
variables_popup_button.clicked.connect(self.showVariablesPopup)
variables_popup_button.setMaximumSize(20, 20)
layout.addWidget(analysis_module_combo, 0, Qt.AlignLeft)
layout.addWidget(variables_popup_button, 0, Qt.AlignLeft)
layout.setContentsMargins(QMargins(0, 0, 0, 0))
layout.addStretch()
self.setLayout(layout)
def create_combobox(self,
text,
choices,
option,
default=NoDefault,
tip=None,
restart=False,
section=None):
"""choices: couples (name, key)"""
if section is not None and section != self.CONF_SECTION:
self.cross_section_options[option] = section
label = QLabel(text)
combobox = QComboBox()
if tip is not None:
combobox.setToolTip(tip)
for name, key in choices:
if not (name is None and key is None):
combobox.addItem(name, to_qvariant(key))
# Insert separators
count = 0
for index, item in enumerate(choices):
name, key = item
if name is None and key is None:
combobox.insertSeparator(index + count)
count += 1
self.comboboxes[combobox] = (section, option, default)
layout = QHBoxLayout()
layout.addWidget(label)
layout.addWidget(combobox)
layout.addStretch(1)
layout.setContentsMargins(0, 0, 0, 0)
widget = QWidget(self)
widget.label = label
widget.combobox = combobox
widget.setLayout(layout)
combobox.restart_required = restart
combobox.label_text = text
return widget
def createEditor(self, parent, option, index):
if index.isValid():
role = index.data(ProjectModel.TYPE_ROLE)
if role == 'combo':
node_types = list(presets.nodes.keys())
cbox = QComboBox(parent)
current_item = index.data(Qt.DisplayRole)
for idx, node_type in enumerate(node_types):
cbox.addItem(node_type)
if node_type == current_item:
cbox.setCurrentIndex(idx)
def text_changed(txt):
"""
go up the tree to get which topo preset it is
model.index.sibling
"""
presets.topo_changed.emit() # pass which topo has changed
# then update the viz
cbox.currentTextChanged.connect(text_changed)
return cbox
return super().createEditor(parent, option, index)
def __init__(self, layer):
super().__init__()
self.layer = layer
self.layer.events.blending.connect(self._on_blending_change)
self.layer.events.opacity.connect(self._on_opacity_change)
self.setAttribute(Qt.WA_DeleteOnClose)
self.setObjectName('layer')
self.setMouseTracking(True)
self.grid_layout = QGridLayout(self)
self.grid_layout.setContentsMargins(0, 0, 0, 0)
self.grid_layout.setSpacing(2)
self.grid_layout.setColumnMinimumWidth(0, 86)
self.grid_layout.setColumnStretch(1, 1)
self.setLayout(self.grid_layout)
sld = QSlider(Qt.Horizontal, parent=self)
sld.setFocusPolicy(Qt.NoFocus)
sld.setMinimum(0)
sld.setMaximum(100)
sld.setSingleStep(1)
sld.valueChanged.connect(self.changeOpacity)
self.opacitySlider = sld
self._on_opacity_change()
blend_comboBox = QComboBox(self)
for index, (data, text) in enumerate(BLENDING_TRANSLATIONS.items()):
data = data.value
blend_comboBox.addItem(text, data)
if data == self.layer.blending:
blend_comboBox.setCurrentIndex(index)
blend_comboBox.activated[str].connect(self.changeBlending)
self.blendComboBox = blend_comboBox
def __init__(self, layer):
super().__init__(layer)
colormap_layout = QHBoxLayout()
colormap_layout.addWidget(self.colorbarLabel)
colormap_layout.addWidget(self.colormapComboBox)
colormap_layout.addStretch(1)
shading_comboBox = QComboBox(self)
for display_name, shading in SHADING_TRANSLATION.items():
shading_comboBox.addItem(display_name, shading)
index = shading_comboBox.findData(
SHADING_TRANSLATION[self.layer.shading])
shading_comboBox.setCurrentIndex(index)
shading_comboBox.activated[str].connect(self.changeShading)
self.shadingComboBox = shading_comboBox
# grid_layout created in QtLayerControls
# addWidget(widget, row, column, [row_span, column_span])
self.grid_layout.addWidget(QLabel(trans._('opacity:')), 0, 0)
self.grid_layout.addWidget(self.opacitySlider, 0, 1)
self.grid_layout.addWidget(QLabel(trans._('contrast limits:')), 1, 0)
self.grid_layout.addWidget(self.contrastLimitsSlider, 1, 1)
self.grid_layout.addWidget(QLabel(trans._('auto-contrast:')), 2, 0)
self.grid_layout.addWidget(self.autoScaleBar, 2, 1)
self.grid_layout.addWidget(QLabel(trans._('gamma:')), 3, 0)
self.grid_layout.addWidget(self.gammaSlider, 3, 1)
self.grid_layout.addWidget(QLabel(trans._('colormap:')), 4, 0)
self.grid_layout.addLayout(colormap_layout, 4, 1)
self.grid_layout.addWidget(QLabel(trans._('blending:')), 5, 0)
self.grid_layout.addWidget(self.blendComboBox, 5, 1)
self.grid_layout.addWidget(QLabel(trans._('shading:')), 6, 0)
self.grid_layout.addWidget(self.shadingComboBox, 6, 1)
self.grid_layout.setRowStretch(7, 1)
self.grid_layout.setColumnStretch(1, 1)
self.grid_layout.setSpacing(4)
def create_controls(self):
self.setWindowTitle(tr(self.plugin.name))
vbox = QVBoxLayout()
form = QFormLayout()
for Name, (enabled, url) in self.packages.items():
name = Name.lower()
cbo = QComboBox()
if enabled:
branches = get_branches(name, url)
for n, b in branches.items():
cbo.addItem(n, b)
if not check_git_repo(name):
cbo.insertItem(0, "<Select to change>", None)
cbo.setCurrentIndex(0)
self._prev_indices[cbo] = 0
cbo.currentIndexChanged.connect(partial(
self._cbo_changed, cbo))
else:
cbo.setEditText("<git repository>")
cbo.setToolTip(
tr("This is installed in a git repository but we're set to "
"not use git."))
cbo.setEnabled(enabled)
form.addRow(Name + ':', cbo)
vbox.addLayout(form)
vbox.addWidget(
QLabel(
tr("You should restart the application if you make any changes!"
)))
btns = QDialogButtonBox(QDialogButtonBox.Ok, Qt.Horizontal, self)
btns.accepted.connect(self.accept)
vbox.addWidget(btns)
self.setLayout(vbox)
def __init__(self, layer):
super().__init__()
self.layer = layer
layer.events.blending.connect(self._on_blending_change)
layer.events.opacity.connect(self._on_opacity_change)
self.setObjectName('layer')
self.setMouseTracking(True)
self.grid_layout = QGridLayout()
self.grid_layout.setContentsMargins(0, 0, 0, 0)
self.grid_layout.setSpacing(2)
self.setLayout(self.grid_layout)
sld = QSlider(Qt.Horizontal)
sld.setFocusPolicy(Qt.NoFocus)
sld.setMinimum(0)
sld.setMaximum(100)
sld.setSingleStep(1)
sld.setValue(self.layer.opacity * 100)
sld.valueChanged[int].connect(
lambda value=sld: self.changeOpacity(value)
)
self.opacitySilder = sld
blend_comboBox = QComboBox()
for blend in Blending:
blend_comboBox.addItem(str(blend))
index = blend_comboBox.findText(
self.layer.blending, Qt.MatchFixedString
)
blend_comboBox.setCurrentIndex(index)
blend_comboBox.activated[str].connect(
lambda text=blend_comboBox: self.changeBlending(text)
)
self.blendComboBox = blend_comboBox
def __init__(self, layer):
super().__init__(layer)
self.layer.events.colormap.connect(self._on_colormap_change)
self.layer.events.interpolation.connect(self._on_interpolation_change)
self.layer.events.rendering.connect(self._on_rendering_change)
row = self.grid_layout.rowCount()
comboBox = QComboBox()
for cmap in self.layer.colormaps:
comboBox.addItem(cmap)
comboBox._allitems = set(self.layer.colormaps)
index = comboBox.findText(self.layer.colormap[0], Qt.MatchFixedString)
comboBox.setCurrentIndex(index)
comboBox.activated[str].connect(
lambda text=comboBox: self.changeColor(text))
self.grid_layout.addWidget(QLabel('colormap:'), row, self.name_column)
self.grid_layout.addWidget(comboBox, row, self.property_column)
self.colormap_combobox = comboBox
row = self.grid_layout.rowCount()
interp_comboBox = QComboBox()
for interp in Interpolation:
interp_comboBox.addItem(str(interp))
index = interp_comboBox.findText(self.layer.interpolation,
Qt.MatchFixedString)
interp_comboBox.setCurrentIndex(index)
interp_comboBox.activated[str].connect(
lambda text=interp_comboBox: self.changeInterpolation(text))
self.interpComboBox = interp_comboBox
self.grid_layout.addWidget(QLabel('interpolation:'), row,
self.name_column)
self.grid_layout.addWidget(interp_comboBox, row, self.property_column)
row = self.grid_layout.rowCount()
renderComboBox = QComboBox()
for render in Rendering:
renderComboBox.addItem(str(render))
index = renderComboBox.findText(self.layer.rendering,
Qt.MatchFixedString)
renderComboBox.setCurrentIndex(index)
renderComboBox.activated[str].connect(
lambda text=renderComboBox: self.changeRendering(text))
self.renderComboBox = renderComboBox
self.grid_layout.addWidget(QLabel('rendering:'), row, self.name_column)
self.grid_layout.addWidget(renderComboBox, row, self.property_column)
self.setExpanded(False)
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 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 PyDMLogDisplay(QWidget, LogLevels):
"""
Standard display for Log Output
This widget handles instantating a ``GuiHandler`` and displaying log
messages to a ``QPlainTextEdit``. The level of the log can be changed from
inside the widget itself, allowing users to select from any of the
``.levels`` specified by the widget.
Parameters
----------
parent : QObject, optional
logname : str
Name of log to display in widget
level : logging.Level
Initial level of log display
"""
Q_ENUMS(LogLevels)
LogLevels = LogLevels
terminator = '\n'
default_format = '%(asctime)s %(message)s'
default_level = logging.INFO
def __init__(self, parent=None, logname=None, level=logging.NOTSET):
QWidget.__init__(self, parent=parent)
# Create Widgets
self.label = QLabel('Minimum displayed log level: ', parent=self)
self.combo = QComboBox(parent=self)
self.text = QPlainTextEdit(parent=self)
self.text.setReadOnly(True)
self.clear_btn = QPushButton("Clear", parent=self)
# Create layout
layout = QVBoxLayout()
level_control = QHBoxLayout()
level_control.addWidget(self.label)
level_control.addWidget(self.combo)
layout.addLayout(level_control)
layout.addWidget(self.text)
layout.addWidget(self.clear_btn)
self.setLayout(layout)
# Allow QCombobox to control log level
for log_level, value in LogLevels.as_dict().items():
self.combo.addItem(log_level, value)
self.combo.currentIndexChanged[str].connect(self.setLevel)
# Allow QPushButton to clear log text
self.clear_btn.clicked.connect(self.clear)
# Create a handler with the default format
self.handler = GuiHandler(level=level, parent=self)
self.logFormat = self.default_format
self.handler.message.connect(self.write)
# Create logger. Either as a root or given logname
self.log = None
self.level = None
self.logName = logname or ''
self.logLevel = level
self.destroyed.connect(functools.partial(logger_destroyed, self.log))
def sizeHint(self):
return QSize(400, 300)
@Property(LogLevels)
def logLevel(self):
return self.level
@logLevel.setter
def logLevel(self, level):
if level != self.level:
self.level = level
idx = self.combo.findData(level)
self.combo.setCurrentIndex(idx)
@Property(str)
def logName(self):
"""Name of associated log"""
return self.log.name
@logName.setter
def logName(self, name):
# Disconnect prior log from handler
if self.log:
self.log.removeHandler(self.handler)
# Reattach handler to new handler
self.log = logging.getLogger(name)
# Ensure that the log matches level of handler
# only if the handler level is less than the log.
if self.log.level < self.handler.level:
self.log.setLevel(self.handler.level)
# Attach preconfigured handler
self.log.addHandler(self.handler)
@Property(str)
def logFormat(self):
"""Format for log messages"""
return self.handler.formatter._fmt
@logFormat.setter
def logFormat(self, fmt):
self.handler.setFormatter(logging.Formatter(fmt))
@Slot(str)
def write(self, message):
"""Write a message to the log display"""
# We split the incoming message by new lines. In prior iterations of
# this widget it was discovered that large blocks of text cause issues
# at the Qt level.
for msg in message.split(self.terminator):
self.text.appendPlainText(msg)
@Slot()
def clear(self):
"""Clear the text area."""
self.text.clear()
@Slot(str)
def setLevel(self, level):
"""Set the level of the contained logger"""
# Get the level from the incoming string specification
try:
level = getattr(logging, level.upper())
except AttributeError as exc:
logger.exception("Invalid logging level specified %s",
level.upper())
else:
# Set the existing handler and logger to this level
self.handler.setLevel(level)
if self.log.level > self.handler.level or self.log.level == logging.NOTSET:
self.log.setLevel(self.handler.level)
def __init__(self, layer):
super().__init__(layer)
self.layer.events.mode.connect(self._on_mode_change)
self.layer.events.n_dimensional.connect(self._on_n_dimensional_change)
self.layer.events.symbol.connect(self._on_symbol_change)
self.layer.events.size.connect(self._on_size_change)
self.layer.events.current_edge_color.connect(
self._on_current_edge_color_change)
self.layer._edge.events.current_color.connect(
self._on_current_edge_color_change)
self.layer.events.current_face_color.connect(
self._on_current_face_color_change)
self.layer._face.events.current_color.connect(
self._on_current_face_color_change)
self.layer.events.editable.connect(self._on_editable_change)
self.layer.text.events.visible.connect(self._on_text_visibility_change)
sld = QSlider(Qt.Horizontal)
sld.setFocusPolicy(Qt.NoFocus)
sld.setMinimum(1)
sld.setMaximum(100)
sld.setSingleStep(1)
value = self.layer.current_size
sld.setValue(int(value))
sld.valueChanged.connect(self.changeSize)
self.sizeSlider = sld
self.faceColorEdit = QColorSwatchEdit(
initial_color=self.layer.current_face_color,
tooltip=trans._('click to set current face color'),
)
self.edgeColorEdit = QColorSwatchEdit(
initial_color=self.layer.current_edge_color,
tooltip=trans._('click to set current edge color'),
)
self.faceColorEdit.color_changed.connect(self.changeFaceColor)
self.edgeColorEdit.color_changed.connect(self.changeEdgeColor)
symbol_comboBox = QComboBox()
current_index = 0
for index, (data, text) in enumerate(SYMBOL_TRANSLATION.items()):
data = data.value
symbol_comboBox.addItem(text, data)
if data == self.layer.symbol:
current_index = index
symbol_comboBox.setCurrentIndex(current_index)
symbol_comboBox.activated[str].connect(self.changeSymbol)
self.symbolComboBox = symbol_comboBox
ndim_cb = QCheckBox()
ndim_cb.setToolTip(trans._('N-dimensional points'))
ndim_cb.setChecked(self.layer.n_dimensional)
ndim_cb.stateChanged.connect(self.change_ndim)
self.ndimCheckBox = ndim_cb
self.select_button = QtModeRadioButton(
layer,
'select_points',
Mode.SELECT,
)
action_manager.bind_button('napari:activate_points_select_mode',
self.select_button)
self.addition_button = QtModeRadioButton(layer, 'add_points', Mode.ADD)
action_manager.bind_button('napari:activate_points_add_mode',
self.addition_button)
self.panzoom_button = QtModeRadioButton(
layer,
'pan_zoom',
Mode.PAN_ZOOM,
checked=True,
)
action_manager.bind_button('napari:activate_points_pan_zoom_mode',
self.panzoom_button)
self.delete_button = QtModePushButton(
layer,
'delete_shape',
)
action_manager.bind_button('napari:delete_selected_points',
self.delete_button)
text_disp_cb = QCheckBox()
text_disp_cb.setToolTip(trans._('toggle text visibility'))
text_disp_cb.setChecked(self.layer.text.visible)
text_disp_cb.stateChanged.connect(self.change_text_visibility)
self.textDispCheckBox = text_disp_cb
self.button_group = QButtonGroup(self)
self.button_group.addButton(self.select_button)
self.button_group.addButton(self.addition_button)
self.button_group.addButton(self.panzoom_button)
button_row = QHBoxLayout()
button_row.addStretch(1)
button_row.addWidget(self.delete_button)
button_row.addWidget(self.addition_button)
button_row.addWidget(self.select_button)
button_row.addWidget(self.panzoom_button)
button_row.setContentsMargins(0, 0, 0, 5)
button_row.setSpacing(4)
# grid_layout created in QtLayerControls
# addWidget(widget, row, column, [row_span, column_span])
self.grid_layout.addLayout(button_row, 0, 1)
self.grid_layout.addWidget(QLabel(trans._('opacity:')), 1, 0)
self.grid_layout.addWidget(self.opacitySlider, 1, 1)
self.grid_layout.addWidget(QLabel(trans._('point size:')), 2, 0)
self.grid_layout.addWidget(self.sizeSlider, 2, 1)
self.grid_layout.addWidget(QLabel(trans._('blending:')), 3, 0)
self.grid_layout.addWidget(self.blendComboBox, 3, 1)
self.grid_layout.addWidget(QLabel(trans._('symbol:')), 4, 0)
self.grid_layout.addWidget(self.symbolComboBox, 4, 1)
self.grid_layout.addWidget(QLabel(trans._('face color:')), 5, 0)
self.grid_layout.addWidget(self.faceColorEdit, 5, 1)
self.grid_layout.addWidget(QLabel(trans._('edge color:')), 6, 0)
self.grid_layout.addWidget(self.edgeColorEdit, 6, 1)
self.grid_layout.addWidget(QLabel(trans._('display text:')), 7, 0)
self.grid_layout.addWidget(self.textDispCheckBox, 7, 1)
self.grid_layout.addWidget(QLabel(trans._('n-dim:')), 8, 0)
self.grid_layout.addWidget(self.ndimCheckBox, 8, 1)
self.grid_layout.setRowStretch(9, 1)
self.grid_layout.setColumnStretch(1, 1)
self.grid_layout.setSpacing(4)
class ShearMomentTorqueWindow(PyDialog):
"""
+-------------------------+
| ShearMomentTorqueWindow |
+-------------------------+
| Origin cid x y z |
| P2 cid x y z |
| z-axis cid x y z |
| tol cid x y z |
| |
| Apply OK Cancel |
+-------------------------+
"""
def __init__(self, data, win_parent=None):
"""
Saves the data members from data and
performs type checks
"""
PyDialog.__init__(self, data, win_parent)
self._updated_preference = False
self._default_font_size = data['font_size']
#self.dim_max = data['dim_max']
self.model_name = data['model_name']
self.cids = data['cids']
self.gpforce = data['gpforce']
#self._origin = data['origin']
#self._p1 = data['origin']
#self._p2 = data['origin']
#self.out_data = data
self.plane_color_float, self.plane_color_int = check_color(
data['plane_color'])
self.plane_opacity = data['plane_opacity']
self.methods = ['Z-Axis Projection', 'CORD2R']
self.zaxis_methods = ['Global Z', 'Camera Normal', 'Manual']
self._zaxis_method = 0 # Global Z
self.setWindowTitle('Shear, Moment, Torque')
self.create_widgets()
self.create_layout()
self.set_connections()
self.on_font(self._default_font_size)
#self.on_gradient_scale()
#self.show()
def on_font(self, value=None):
"""update the font for the current window"""
if value is None:
value = self.font_size_edit.value()
font = QtGui.QFont()
font.setPointSize(value)
self.setFont(font)
def set_font_size(self, font_size):
"""
Updates the font size of all objects in the PyDialog
Parameters
----------
font_size : int
the font size
"""
if self.font_size == font_size:
return
self.font_size = font_size
font = make_font(font_size, is_bold=False)
self.setFont(font)
self.set_bold_font(font_size)
def set_bold_font(self, font_size):
"""
Updates the font size of all bolded objects in the dialog
Parameters
----------
font_size : int
the font size
"""
bold_font = make_font(font_size, is_bold=True)
self.additional_params_label.setFont(bold_font)
self.case_info_label.setFont(bold_font)
self.plane_label.setFont(bold_font)
self.location_label.setFont(bold_font)
self.cid_label.setFont(bold_font)
self.x_label.setFont(bold_font)
self.y_label.setFont(bold_font)
self.z_label.setFont(bold_font)
def create_widgets(self):
"""creates the display window"""
# CORD2R
#self.origin_label = QLabel("Origin:")
#self.zaxis_label = QLabel("Z Axis:")
#self.xz_plane_label = QLabel("XZ Plane:")
# Z-Axis Projection
self.p1_label = QLabel("Origin:")
self.p3_label = QLabel("End:")
self.p2_label = QLabel("XZ Plane:")
self.p1_label.setToolTip(
'Defines the starting point for the shear, moment, torque plot')
self.p3_label.setToolTip(
'Defines the end point for the shear, moment, torque plot')
self.p2_label.setToolTip('Defines the XZ plane for the shears/moments')
self.zaxis_label = QLabel("Z Axis:")
self.method_pulldown = QComboBox()
for method in self.methods:
self.method_pulldown.addItem(method)
self.zaxis_method_pulldown = QComboBox()
for method in self.zaxis_methods:
self.zaxis_method_pulldown.addItem(method)
self.cid_label = QLabel("Coordinate System:")
self.p1_cid_pulldown = QComboBox()
self.p2_cid_pulldown = QComboBox()
self.p3_cid_pulldown = QComboBox()
self.zaxis_cid_pulldown = QComboBox()
cid_global_str = '0/Global'
for cid in sorted(self.cids):
if cid == 0:
cid_str = cid_global_str
else:
cid_str = str(cid)
#print('cid_str = %r' % cid_str)
self.p1_cid_pulldown.addItem(cid_str)
self.p2_cid_pulldown.addItem(cid_str)
self.p3_cid_pulldown.addItem(cid_str)
self.zaxis_cid_pulldown.addItem(cid_str)
self.p1_cid_pulldown.setCurrentIndex(0)
self.p2_cid_pulldown.setCurrentIndex(0)
self.p3_cid_pulldown.setCurrentIndex(0)
self.zaxis_cid_pulldown.setCurrentIndex(0)
if len(self.cids) == 1:
self.p1_cid_pulldown.setEnabled(False)
self.p2_cid_pulldown.setEnabled(False)
self.p3_cid_pulldown.setEnabled(False)
self.zaxis_cid_pulldown.setEnabled(False)
#self.p1_cid_pulldown.setItemText(0, cid_str)
#self.p2_cid_pulldown.setItemText(0, cid_str)
#self.zaxis_cid_pulldown.setItemText(0, cid_str)
self.p1_cid_pulldown.setToolTip(
'Defines the coordinate system for Point P1')
self.p2_cid_pulldown.setToolTip(
'Defines the coordinate system for Point P2')
self.p3_cid_pulldown.setToolTip(
'Defines the coordinate system for Point P3')
self.zaxis_cid_pulldown.setToolTip(
'Defines the coordinate system for the Z Axis')
self.p1_x_edit = QFloatEdit('')
self.p1_y_edit = QFloatEdit('')
self.p1_z_edit = QFloatEdit('')
self.p2_x_edit = QFloatEdit('')
self.p2_y_edit = QFloatEdit('')
self.p2_z_edit = QFloatEdit('')
self.p3_x_edit = QFloatEdit('')
self.p3_y_edit = QFloatEdit('')
self.p3_z_edit = QFloatEdit('')
self.zaxis_x_edit = QFloatEdit('')
self.zaxis_y_edit = QFloatEdit('')
self.zaxis_z_edit = QFloatEdit('')
self.additional_params_label = QLabel('Plane Parameters:')
self.case_info_label = QLabel('Case Info:')
self.p2_label = QLabel("XZ Plane:")
# Plane Color
self.plane_color_label = QLabel("Plane Color:")
self.plane_color_edit = QPushButtonColor(self.plane_color_int)
self.plane_opacity_label = QLabel("Plane Opacity:")
self.plane_opacity_edit = QDoubleSpinBox()
self.plane_opacity_edit.setRange(0.1, 1.0)
self.plane_opacity_edit.setDecimals(1)
self.plane_opacity_edit.setSingleStep(0.1)
self.plane_opacity_edit.setValue(self.plane_opacity)
self.flip_coord_label = QLabel("Flip Coordinate System:")
self.flip_coord_checkbox = QCheckBox()
#-----------------------------------------------------------------------
self.time_label = QLabel('Time:')
if self.gpforce is None:
times = ['0.', '0.5', '1.', '1.5', '2.']
time = '0.'
else:
times = [func_str(time) for time in self.gpforce._times]
time = times[0]
self.times_pulldown = make_combo_box(times, time)
self.time_label.setEnabled(False)
self.times_pulldown.setEnabled(False)
#self.node_label = QLabel('Nodes:')
#self.node_edit = QNodeEdit(self.win_parent, self.model_name, parent=self.gui,
#pick_style='area', tab_to_next=False)
#self.element_label = QLabel('Elements:')
#self.element_edit = QElementEdit(self.win_parent, self.model_name, parent=self.gui,
#pick_style='area', tab_to_next=False)
#self.node_element_label = QLabel('Nodes/Elements:')
#self.node_element_edit = QLineEdit()
#self.node_element_edit.setReadOnly(True)
self.nplanes_label = QLabel('Num Planes:')
self.nplanes_spinner = QSpinBox()
self.nplanes_spinner.setMinimum(2)
self.nplanes_spinner.setMaximum(500)
self.nplanes_spinner.setValue(20)
#-----------------------------------------------------------------------
self.method_label = QLabel('Method:')
self.plane_label = QLabel('Plane:')
self.location_label = QLabel('Location:')
self.zaxis_method_label = QLabel('Z-Axis Method:')
self.cid_label = QLabel('Coordinate System:')
self.x_label = QLabel('X')
self.y_label = QLabel('Y')
self.z_label = QLabel('Z')
#self.location_label.setAlignment(Qt.AlignCenter)
self.cid_label.setAlignment(Qt.AlignCenter)
self.x_label.setAlignment(Qt.AlignCenter)
self.y_label.setAlignment(Qt.AlignCenter)
self.z_label.setAlignment(Qt.AlignCenter)
self.export_checkbox = QCheckBox()
self.csv_label = QLabel('CSV Filename:')
self.csv_edit = QLineEdit()
self.csv_button = QPushButton('Browse...')
self.csv_label.setEnabled(False)
self.csv_edit.setEnabled(False)
self.csv_button.setEnabled(False)
#-----------------------------------------------------------------------
# nodes
self.add_button = QPushButton('Add')
self.remove_button = QPushButton('Remove')
# elements
self.add2_button = QPushButton('Add')
self.remove2_button = QPushButton('Remove')
#-----------------------------------------------------------------------
# closing
self.apply_button = QPushButton('Apply')
self.cancel_button = QPushButton('Cancel')
self.set_bold_font(self._default_font_size)
@property
def gui(self):
if self.win_parent is None:
return None
return self.win_parent.parent.gui
def create_layout(self):
"""sets up the window"""
grid = self._make_grid_layout()
#hbox_csv = QHBoxLayout()
grid2 = QGridLayout()
#irow = 0
#grid2.addWidget(self.node_label, irow, 0)
#grid2.addWidget(self.node_edit, irow, 1)
#grid2.addWidget(self.add_button, irow, 2)
#grid2.addWidget(self.remove_button, irow, 3)
#irow += 1
#grid2.addWidget(self.element_label, irow, 0)
#grid2.addWidget(self.element_edit, irow, 1)
#grid2.addWidget(self.add2_button, irow, 2)
#grid2.addWidget(self.remove2_button, irow, 3)
#irow += 1
#grid2.addWidget(self.node_element_label, irow, 0)
#grid2.addWidget(self.node_element_edit, irow, 1)
#irow += 1
hbox_csv = QHBoxLayout()
hbox_csv.addWidget(self.export_checkbox)
hbox_csv.addWidget(self.csv_label)
hbox_csv.addWidget(self.csv_edit)
hbox_csv.addWidget(self.csv_button)
#----------------------------------------------
ok_cancel_box = QHBoxLayout()
ok_cancel_box.addWidget(self.apply_button)
ok_cancel_box.addWidget(self.cancel_button)
vbox = QVBoxLayout()
vbox.addLayout(grid)
vbox.addLayout(grid2)
#vbox.addStretch()
vbox.addLayout(hbox_csv)
vbox.addStretch()
#-----------------------
#vbox.addLayout(add_remove_box)
vbox.addLayout(ok_cancel_box)
self.on_method(0)
self.on_zaxis_method(0)
self.setLayout(vbox)
def on_export_checkbox(self):
"""this is called when the checkbox is clicked"""
is_checked = self.export_checkbox.isChecked()
self.csv_label.setEnabled(is_checked)
self.csv_edit.setEnabled(is_checked)
self.csv_button.setEnabled(is_checked)
def on_browse_csv(self):
"""opens a file dialog"""
default_dirname = os.getcwd()
csv_filename, wildcard = save_file_dialog(
self, 'Select the file name for export', default_dirname,
wildcard_csv)
if not csv_filename:
return
self.csv_edit.setText(csv_filename)
def _make_grid_layout(self):
"""builds the QGridLayout"""
grid = QGridLayout()
irow = 0
#-------------------------
grid.addWidget(self.location_label, irow, 0)
grid.addWidget(self.cid_label, irow, 1)
grid.addWidget(self.x_label, irow, 2)
grid.addWidget(self.y_label, irow, 3)
grid.addWidget(self.z_label, irow, 4)
irow += 1
add_row(irow, grid, self.p1_label, self.p1_cid_pulldown,
self.p1_x_edit, self.p1_y_edit, self.p1_z_edit)
irow += 1
add_row(irow, grid, self.p3_label, self.p3_cid_pulldown,
self.p3_x_edit, self.p3_y_edit, self.p3_z_edit)
irow += 1
grid.addWidget(self.plane_label, irow, 0)
irow += 1
grid.addWidget(self.method_label, irow, 0)
grid.addWidget(self.method_pulldown, irow, 1)
irow += 1
grid.addWidget(self.zaxis_method_label, irow, 0)
grid.addWidget(self.zaxis_method_pulldown, irow, 1)
irow += 1
add_row(irow, grid, self.zaxis_label, self.zaxis_cid_pulldown,
self.zaxis_x_edit, self.zaxis_y_edit, self.zaxis_z_edit)
irow += 1
add_row(irow, grid, self.p2_label, self.p2_cid_pulldown,
self.p2_x_edit, self.p2_y_edit, self.p2_z_edit)
irow += 1
#-----------------------------------------
grid.addWidget(self.case_info_label, irow, 0)
irow += 1
grid.addWidget(self.time_label, irow, 0)
grid.addWidget(self.times_pulldown, irow, 1)
irow += 1
grid.addWidget(self.nplanes_label, irow, 0)
grid.addWidget(self.nplanes_spinner, irow, 1)
irow += 1
#-----------------------------------------
grid.addWidget(self.additional_params_label, irow, 0)
irow += 1
grid.addWidget(self.plane_color_label, irow, 0)
grid.addWidget(self.plane_color_edit, irow, 1)
irow += 1
grid.addWidget(self.plane_opacity_label, irow, 0)
grid.addWidget(self.plane_opacity_edit, irow, 1)
irow += 1
#----------------------------------------------
return grid
def set_connections(self):
"""creates the actions for the menu"""
self.method_pulldown.currentIndexChanged.connect(self.on_method)
self.zaxis_method_pulldown.currentIndexChanged.connect(
self.on_zaxis_method)
self.plane_color_edit.clicked.connect(self.on_plane_color)
self.export_checkbox.clicked.connect(self.on_export_checkbox)
self.csv_button.clicked.connect(self.on_browse_csv)
self.apply_button.clicked.connect(self.on_apply)
self.cancel_button.clicked.connect(self.on_cancel)
def on_method(self, method_int=None):
method = get_pulldown_text(method_int, self.methods,
self.method_pulldown)
if method == 'Z-Axis Projection':
is_cord2r = False
elif method == 'CORD2R':
is_cord2r = True
else:
raise NotImplementedError(method)
if is_cord2r:
self._zaxis_method = self.zaxis_method_pulldown.currentIndex()
# set to manual
#self.on_zaxis_method(method_int=2) # manual
self.zaxis_method_pulldown.setCurrentIndex(2)
self.on_zaxis_method() # update
else:
self.zaxis_method_pulldown.setCurrentIndex(self._zaxis_method)
self.on_zaxis_method() # update
# works
self.zaxis_method_pulldown.setEnabled(not is_cord2r)
self.zaxis_method_pulldown.setVisible(not is_cord2r)
self.zaxis_method_label.setEnabled(not is_cord2r)
def on_zaxis_method(self, method_int=None):
method = get_pulldown_text(method_int, self.zaxis_methods,
self.zaxis_method_pulldown)
if method == 'Global Z':
is_visible = False
elif method == 'Camera Normal':
is_visible = False
elif method == 'Manual':
is_visible = True
else:
raise NotImplementedError(method)
self.zaxis_cid_pulldown.setVisible(is_visible)
self.zaxis_x_edit.setVisible(is_visible)
self.zaxis_y_edit.setVisible(is_visible)
self.zaxis_z_edit.setVisible(is_visible)
def on_plane_color(self):
""" Choose a plane color"""
title = "Choose a cutting plane color"
rgb_color_ints = self.plane_color_int
color_edit = self.plane_color_edit
func_name = 'set_plane_color'
passed, rgb_color_ints, rgb_color_floats = self._background_color(
title, color_edit, rgb_color_ints, func_name)
if passed:
self.plane_color_int = rgb_color_ints
self.plane_color_float = rgb_color_floats
def _background_color(self, title, color_edit, rgb_color_ints, func_name):
"""helper method for ``on_background_color`` and ``on_background_color2``"""
passed, rgb_color_ints, rgb_color_floats = self.on_color(
color_edit, rgb_color_ints, title)
if passed and 0:
if self.win_parent is not None:
settings = self.win_parent.settings
func_background_color = getattr(settings, func_name)
func_background_color(rgb_color_floats)
return passed, rgb_color_ints, rgb_color_floats
def on_color(self, color_edit, rgb_color_ints, title):
"""pops a color dialog"""
col = QColorDialog.getColor(QtGui.QColor(*rgb_color_ints), self, title)
if not col.isValid():
return False, rgb_color_ints, None
color_float = col.getRgbF()[:3] # floats
color_int = [int(colori * 255) for colori in color_float]
assert isinstance(color_float[0], float), color_float
assert isinstance(color_int[0], int), color_int
color_edit.setStyleSheet("QPushButton {"
"background-color: rgb(%s, %s, %s);" %
tuple(color_int) +
#"border:1px solid rgb(255, 170, 255); "
"}")
return True, color_int, color_float
#---------------------------------------------------------------------------
def on_validate(self):
p1_cidi = self.p1_cid_pulldown.currentText()
p2_cidi = self.p2_cid_pulldown.currentText()
p3_cidi = self.p3_cid_pulldown.currentText()
zaxis_cidi = self.zaxis_cid_pulldown.currentText()
p1_cid = int(p1_cidi) if 'Global' not in p1_cidi else 0
p2_cid = int(p2_cidi) if 'Global' not in p2_cidi else 0
p3_cid = int(p3_cidi) if 'Global' not in p3_cidi else 0
zaxis_cid = int(zaxis_cidi) if 'Global' not in zaxis_cidi else 0
#print('p1_cidi=%r p2_cidi=%r p3_cidi=%r' % (p1_cidi, p2_cidi, zaxis_cidi))
#print('p2_cid=%r p2_cid=%r p3_cidi=%r' % (p2_cid, p2_cid, zaxis_cid))
p1_x, flag1 = check_float(self.p1_x_edit)
p1_y, flag2 = check_float(self.p1_y_edit)
p1_z, flag3 = check_float(self.p1_z_edit)
p2_x, flag4 = check_float(self.p2_x_edit)
p2_y, flag5 = check_float(self.p2_y_edit)
p2_z, flag6 = check_float(self.p2_z_edit)
p3_x, flag7 = check_float(self.p3_x_edit)
p3_y, flag8 = check_float(self.p3_y_edit)
p3_z, flag9 = check_float(self.p3_z_edit)
p1 = [p1_x, p1_y, p1_z]
p2 = [p2_x, p2_y, p2_z]
p3 = [p3_x, p3_y, p3_z]
flag10, flag11, flag12, zaxis_cid, zaxis = get_zaxis(
self.win_parent, # for camera
self.zaxis_method_pulldown,
self.zaxis_x_edit,
self.zaxis_y_edit,
self.zaxis_z_edit)
method = self.method_pulldown.currentText()
assert method in self.methods, 'method=%r' % method
flag13 = True
plane_opacity = self.plane_opacity_edit.value()
nplanes = self.nplanes_spinner.value()
csv_filename = None
flag14 = True
if self.export_checkbox.isChecked():
csv_filename, flag14 = check_save_path(self.csv_edit)
flags = [
flag1, flag2, flag3, flag4, flag5, flag6, flag7, flag8, flag9,
flag10, flag11, flag12, flag13, flag14
]
if all(flags):
self.out_data['method'] = method
self.out_data['p1'] = [p1_cid, p1]
self.out_data['p2'] = [p2_cid, p2]
self.out_data['p3'] = [p3_cid, p3]
self.out_data['zaxis'] = [zaxis_cid, zaxis]
self.out_data['plane_color'] = self.plane_color_float
self.out_data['plane_opacity'] = plane_opacity
self.out_data['nplanes'] = nplanes
self.out_data['csv_filename'] = csv_filename
self.out_data['clicked_ok'] = True
return True
return False
def on_apply(self):
passed = self.on_validate()
if passed and self.win_parent is not None:
self.win_parent.shear_moment_torque_obj.make_smt_from_data(
self.out_data, show=True)
#self.win_parent.make_smt_from_data(self.out_data)
return passed
def on_cancel(self):
self.out_data['close'] = True
self.close()
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 QtTracksControls(QtLayerControls):
"""Qt view and controls for the Tracks layer.
Parameters
----------
layer : napari.layers.Tracks
An instance of a Tracks layer.
Attributes
----------
grid_layout : qtpy.QtWidgets.QGridLayout
Layout of Qt widget controls for the layer.
layer : layers.Tracks
An instance of a Tracks layer.
"""
layer: 'napari.layers.Tracks'
def __init__(self, layer):
super().__init__(layer)
# NOTE(arl): there are no events fired for changing checkboxes
self.layer.events.tail_width.connect(self._on_tail_width_change)
self.layer.events.tail_length.connect(self._on_tail_length_change)
self.layer.events.head_length.connect(self._on_head_length_change)
self.layer.events.properties.connect(self._on_properties_change)
self.layer.events.colormap.connect(self._on_colormap_change)
self.layer.events.color_by.connect(self._on_color_by_change)
# combo box for track coloring, we can get these from the properties
# keys
self.color_by_combobox = QComboBox()
self.color_by_combobox.addItems(self.layer.properties_to_color_by)
self.colormap_combobox = QComboBox()
for name, colormap in AVAILABLE_COLORMAPS.items():
display_name = colormap._display_name
self.colormap_combobox.addItem(display_name, name)
# slider for track head length
self.head_length_slider = QSlider(Qt.Horizontal)
self.head_length_slider.setFocusPolicy(Qt.NoFocus)
self.head_length_slider.setMinimum(0)
self.head_length_slider.setMaximum(self.layer._max_length)
self.head_length_slider.setSingleStep(1)
# slider for track tail length
self.tail_length_slider = QSlider(Qt.Horizontal)
self.tail_length_slider.setFocusPolicy(Qt.NoFocus)
self.tail_length_slider.setMinimum(1)
self.tail_length_slider.setMaximum(self.layer._max_length)
self.tail_length_slider.setSingleStep(1)
# slider for track edge width
self.tail_width_slider = QSlider(Qt.Horizontal)
self.tail_width_slider.setFocusPolicy(Qt.NoFocus)
self.tail_width_slider.setMinimum(1)
self.tail_width_slider.setMaximum(int(2 * self.layer._max_width))
self.tail_width_slider.setSingleStep(1)
# checkboxes for display
self.id_checkbox = QCheckBox()
self.tail_checkbox = QCheckBox()
self.tail_checkbox.setChecked(True)
self.graph_checkbox = QCheckBox()
self.graph_checkbox.setChecked(True)
self.tail_width_slider.valueChanged.connect(self.change_tail_width)
self.tail_length_slider.valueChanged.connect(self.change_tail_length)
self.head_length_slider.valueChanged.connect(self.change_head_length)
self.tail_checkbox.stateChanged.connect(self.change_display_tail)
self.id_checkbox.stateChanged.connect(self.change_display_id)
self.graph_checkbox.stateChanged.connect(self.change_display_graph)
self.color_by_combobox.currentTextChanged.connect(self.change_color_by)
self.colormap_combobox.currentTextChanged.connect(self.change_colormap)
self.layout().addRow(trans._('color by:'), self.color_by_combobox)
self.layout().addRow(trans._('colormap:'), self.colormap_combobox)
self.layout().addRow(trans._('blending:'), self.blendComboBox)
self.layout().addRow(trans._('opacity:'), self.opacitySlider)
self.layout().addRow(trans._('tail width:'), self.tail_width_slider)
self.layout().addRow(trans._('tail length:'), self.tail_length_slider)
self.layout().addRow(trans._('head length:'), self.head_length_slider)
self.layout().addRow(trans._('tail:'), self.tail_checkbox)
self.layout().addRow(trans._('show ID:'), self.id_checkbox)
self.layout().addRow(trans._('graph:'), self.graph_checkbox)
self._on_tail_length_change()
self._on_tail_width_change()
self._on_colormap_change()
self._on_color_by_change()
def _on_tail_width_change(self):
"""Receive layer model track line width change event and update slider."""
with self.layer.events.tail_width.blocker():
value = int(2 * self.layer.tail_width)
self.tail_width_slider.setValue(value)
def _on_tail_length_change(self):
"""Receive layer model track line width change event and update slider."""
with self.layer.events.tail_length.blocker():
value = self.layer.tail_length
self.tail_length_slider.setValue(value)
def _on_head_length_change(self):
"""Receive layer model track line width change event and update slider."""
with self.layer.events.head_length.blocker():
value = self.layer.head_length
self.head_length_slider.setValue(value)
def _on_properties_change(self):
"""Change the properties that can be used to color the tracks."""
with self.layer.events.properties.blocker():
with qt_signals_blocked(self.color_by_combobox):
self.color_by_combobox.clear()
self.color_by_combobox.addItems(self.layer.properties_to_color_by)
def _on_colormap_change(self):
"""Receive layer model colormap change event and update combobox."""
with self.layer.events.colormap.blocker():
self.colormap_combobox.setCurrentIndex(
self.colormap_combobox.findData(self.layer.colormap))
def _on_color_by_change(self):
"""Receive layer model color_by change event and update combobox."""
with self.layer.events.color_by.blocker():
color_by = self.layer.color_by
idx = self.color_by_combobox.findText(color_by,
Qt.MatchFixedString)
self.color_by_combobox.setCurrentIndex(idx)
def change_tail_width(self, value):
"""Change track line width of shapes on the layer model.
Parameters
----------
value : float
Line width of track tails.
"""
self.layer.tail_width = float(value) / 2.0
def change_tail_length(self, value):
"""Change edge line backward length of shapes on the layer model.
Parameters
----------
value : int
Line length of track tails.
"""
self.layer.tail_length = value
def change_head_length(self, value):
"""Change edge line forward length of shapes on the layer model.
Parameters
----------
value : int
Line length of track tails.
"""
self.layer.head_length = value
def change_display_tail(self, state):
self.layer.display_tail = self.tail_checkbox.isChecked()
def change_display_id(self, state):
self.layer.display_id = self.id_checkbox.isChecked()
def change_display_graph(self, state):
self.layer.display_graph = self.graph_checkbox.isChecked()
def change_color_by(self, value: str):
self.layer.color_by = value
def change_colormap(self, colormap: str):
self.layer.colormap = self.colormap_combobox.currentData()
class SerialDialog(QDialog):
def __init__(self, settings, parent=None):
super().__init__(parent)
self.settings = settings
self.serialports = []
# port
self.portLabel = QLabel(self.tr("COM Port:"))
self.portComboBox = QComboBox()
self.portLabel.setBuddy(self.portComboBox)
self.refresh_comports(self.portComboBox)
# baudrate
self.baudrateLabel = QLabel(self.tr("Baudrate:"))
self.baudrateComboBox = QComboBox()
self.baudrateLabel.setBuddy(self.baudrateComboBox)
for br in BAUDRATES:
self.baudrateComboBox.addItem(str(br), br)
# buttons
self.dlgbuttons = QDialogButtonBox(
QDialogButtonBox.Ok | QDialogButtonBox.Cancel, Qt.Horizontal)
self.dlgbuttons.rejected.connect(self.reject)
self.dlgbuttons.accepted.connect(self.accept)
# layout
layout = QGridLayout()
layout.addWidget(self.portLabel, 0, 0)
layout.addWidget(self.portComboBox, 0, 1)
layout.addWidget(self.baudrateLabel, 1, 0)
layout.addWidget(self.baudrateComboBox, 1, 1)
layout.addWidget(self.dlgbuttons, 2, 0, 1, 2)
self.setLayout(layout)
self.setWindowTitle(self.tr("Serial Settings"))
# settings
defaults = {
PORT_SETTING: "",
BAUDRATE_SETTING: "115200"
}
self.tmp_settings = ConfigManager()
self.tmp_settings.set_defaults(defaults)
self.tmp_settings.set_many(
{key: self.settings.get(key) for key in defaults.keys()}
)
self.tmp_settings.add_handler(PORT_SETTING, self.portComboBox)
self.tmp_settings.add_handler(BAUDRATE_SETTING, self.baudrateComboBox)
def accept(self):
d = self.tmp_settings.as_dict()
self.settings.set_many(d)
super().accept()
def refresh_comports(self, combobox):
self.serialports = serial_ports()
for port in self.serialports:
combobox.addItem(port)
@property
def port(self):
return self.portComboBox.currentText()
@port.setter
def port(self, value):
if value in self.serialports:
self.portComboBox.setCurrentIndex(
self.portComboBox.findText(value))
else:
raise ValueError("serial port '%s' not available" % value)
@property
def baudrate(self):
return self.baudrateComboBox.currentData()
class MixerPanel(QFrame):
'''A color mixer to hook up to an image.
You pass the image you the panel to operate on
and it operates on that image in place. You also
pass a callback to be called to trigger a refresh.
This callback is called every time the mixer modifies
your image.'''
def __init__(self, img):
QFrame.__init__(self)
# self.setFrameStyle(QFrame.Box | QFrame.Sunken)
self.img = img
self.mixer = ColorMixer(self.img)
self.callback = None
#---------------------------------------------------------------
# ComboBox
#---------------------------------------------------------------
self.combo_box_entries = ['RGB Color', 'HSV Color',
'Brightness/Contrast',
'Gamma',
'Gamma (Sigmoidal)']
self.combo_box = QComboBox()
for entry in self.combo_box_entries:
self.combo_box.addItem(entry)
self.combo_box.currentIndexChanged.connect(self.combo_box_changed)
#---------------------------------------------------------------
# RGB color sliders
#---------------------------------------------------------------
# radio buttons
self.rgb_add = QRadioButton('Additive')
self.rgb_mul = QRadioButton('Multiplicative')
self.rgb_mul.toggled.connect(self.rgb_radio_changed)
self.rgb_add.toggled.connect(self.rgb_radio_changed)
# sliders
rs = IntelligentSlider('R', 0.51, -255, self.rgb_changed)
gs = IntelligentSlider('G', 0.51, -255, self.rgb_changed)
bs = IntelligentSlider('B', 0.51, -255, self.rgb_changed)
self.rs = rs
self.gs = gs
self.bs = bs
self.rgb_widget = QWidget()
self.rgb_widget.layout = QGridLayout(self.rgb_widget)
self.rgb_widget.layout.addWidget(self.rgb_add, 0, 0, 1, 3)
self.rgb_widget.layout.addWidget(self.rgb_mul, 1, 0, 1, 3)
self.rgb_widget.layout.addWidget(self.rs, 2, 0)
self.rgb_widget.layout.addWidget(self.gs, 2, 1)
self.rgb_widget.layout.addWidget(self.bs, 2, 2)
#---------------------------------------------------------------
# HSV sliders
#---------------------------------------------------------------
# radio buttons
self.hsv_add = QRadioButton('Additive')
self.hsv_mul = QRadioButton('Multiplicative')
self.hsv_mul.toggled.connect(self.hsv_radio_changed)
self.hsv_mul.toggled.connect(self.hsv_radio_changed)
# sliders
hs = IntelligentSlider('H', 0.36, -180, self.hsv_changed)
ss = IntelligentSlider('S', 0.002, 0, self.hsv_changed)
vs = IntelligentSlider('V', 0.002, 0, self.hsv_changed)
self.hs = hs
self.ss = ss
self.vs = vs
self.hsv_widget = QWidget()
self.hsv_widget.layout = QGridLayout(self.hsv_widget)
self.hsv_widget.layout.addWidget(self.hsv_add, 0, 0, 1, 3)
self.hsv_widget.layout.addWidget(self.hsv_mul, 1, 0, 1, 3)
self.hsv_widget.layout.addWidget(self.hs, 2, 0)
self.hsv_widget.layout.addWidget(self.ss, 2, 1)
self.hsv_widget.layout.addWidget(self.vs, 2, 2)
#---------------------------------------------------------------
# Brightness/Contrast sliders
#---------------------------------------------------------------
# sliders
cont = IntelligentSlider('x', 0.002, 0, self.bright_changed)
bright = IntelligentSlider('+', 0.51, -255, self.bright_changed)
self.cont = cont
self.bright = bright
# layout
self.bright_widget = QWidget()
self.bright_widget.layout = QGridLayout(self.bright_widget)
self.bright_widget.layout.addWidget(self.cont, 0, 0)
self.bright_widget.layout.addWidget(self.bright, 0, 1)
#----------------------------------------------------------------------
# Gamma Slider
#----------------------------------------------------------------------
gamma = IntelligentSlider('gamma', 0.005, 0, self.gamma_changed)
self.gamma = gamma
# layout
self.gamma_widget = QWidget()
self.gamma_widget.layout = QGridLayout(self.gamma_widget)
self.gamma_widget.layout.addWidget(self.gamma, 0, 0)
#---------------------------------------------------------------
# Sigmoid Gamma sliders
#---------------------------------------------------------------
# sliders
alpha = IntelligentSlider('alpha', 0.011, 1, self.sig_gamma_changed)
beta = IntelligentSlider('beta', 0.012, 0, self.sig_gamma_changed)
self.a_gamma = alpha
self.b_gamma = beta
# layout
self.sig_gamma_widget = QWidget()
self.sig_gamma_widget.layout = QGridLayout(self.sig_gamma_widget)
self.sig_gamma_widget.layout.addWidget(self.a_gamma, 0, 0)
self.sig_gamma_widget.layout.addWidget(self.b_gamma, 0, 1)
#---------------------------------------------------------------
# Buttons
#---------------------------------------------------------------
self.commit_button = QPushButton('Commit')
self.commit_button.clicked.connect(self.commit_changes)
self.revert_button = QPushButton('Revert')
self.revert_button.clicked.connect(self.revert_changes)
#---------------------------------------------------------------
# Mixer Layout
#---------------------------------------------------------------
self.sliders = QStackedWidget()
self.sliders.addWidget(self.rgb_widget)
self.sliders.addWidget(self.hsv_widget)
self.sliders.addWidget(self.bright_widget)
self.sliders.addWidget(self.gamma_widget)
self.sliders.addWidget(self.sig_gamma_widget)
self.layout = QGridLayout(self)
self.layout.addWidget(self.combo_box, 0, 0)
self.layout.addWidget(self.sliders, 1, 0)
self.layout.addWidget(self.commit_button, 2, 0)
self.layout.addWidget(self.revert_button, 3, 0)
#---------------------------------------------------------------
# State Initialization
#---------------------------------------------------------------
self.combo_box.setCurrentIndex(0)
self.rgb_mul.setChecked(True)
self.hsv_mul.setChecked(True)
def set_callback(self, callback):
self.callback = callback
def combo_box_changed(self, index):
self.sliders.setCurrentIndex(index)
self.reset()
def rgb_radio_changed(self):
self.reset()
def hsv_radio_changed(self):
self.reset()
def reset(self):
self.reset_sliders()
self.mixer.set_to_stateimg()
if self.callback:
self.callback()
def reset_sliders(self):
# handle changing the conversion factors necessary
if self.rgb_add.isChecked():
self.rs.set_conv_fac(0.51, -255)
self.rs.set_value(0)
self.gs.set_conv_fac(0.51, -255)
self.gs.set_value(0)
self.bs.set_conv_fac(0.51, -255)
self.bs.set_value(0)
else:
self.rs.set_conv_fac(0.002, 0)
self.rs.set_value(1.)
self.gs.set_conv_fac(0.002, 0)
self.gs.set_value(1.)
self.bs.set_conv_fac(0.002, 0)
self.bs.set_value(1.)
self.hs.set_value(0)
if self.hsv_add.isChecked():
self.ss.set_conv_fac(0.002, -1)
self.ss.set_value(0)
self.vs.set_conv_fac(0.002, -1)
self.vs.set_value(0)
else:
self.ss.set_conv_fac(0.002, 0)
self.ss.set_value(1.)
self.vs.set_conv_fac(0.002, 0)
self.vs.set_value(1.)
self.bright.set_value(0)
self.cont.set_value(1.)
self.gamma.set_value(1)
self.a_gamma.set_value(1)
self.b_gamma.set_value(0.5)
def rgb_changed(self, name, val):
if name == 'R':
channel = self.mixer.RED
elif name == 'G':
channel = self.mixer.GREEN
else:
channel = self.mixer.BLUE
if self.rgb_mul.isChecked():
self.mixer.multiply(channel, val)
elif self.rgb_add.isChecked():
self.mixer.add(channel, val)
else:
pass
if self.callback:
self.callback()
def hsv_changed(self, name, val):
h = self.hs.val()
s = self.ss.val()
v = self.vs.val()
if self.hsv_mul.isChecked():
self.mixer.hsv_multiply(h, s, v)
elif self.hsv_add.isChecked():
self.mixer.hsv_add(h, s, v)
else:
pass
if self.callback:
self.callback()
def bright_changed(self, name, val):
b = self.bright.val()
c = self.cont.val()
self.mixer.brightness(c, b)
if self.callback:
self.callback()
def gamma_changed(self, name, val):
self.mixer.gamma(val)
if self.callback:
self.callback()
def sig_gamma_changed(self, name, val):
ag = self.a_gamma.val()
bg = self.b_gamma.val()
self.mixer.sigmoid_gamma(ag, bg)
if self.callback:
self.callback()
def commit_changes(self):
self.mixer.commit_changes()
self.reset_sliders()
def revert_changes(self):
self.mixer.revert()
self.reset_sliders()
if self.callback:
self.callback()
class CalibrationWidget(ParameterWidget):
def __init__(self, parent=None):
ParameterWidget.__init__(self, _Calibration, parent)
def _init_ui(self):
# Widgets
self._combobox = QComboBox()
self._stack = QStackedWidget()
# Layouts
layout = ParameterWidget._init_ui(self)
layout.addRow(self._combobox)
layout.addRow(self._stack)
# Register classes
self._widget_indexes = {}
for entry_point in iter_entry_points('pyhmsa_gui.spec.condition.calibration'):
widget_class = entry_point.load(require=False)
widget = widget_class()
self._combobox.addItem(widget.accessibleName().title())
self._widget_indexes[widget.CLASS] = self._stack.addWidget(widget)
widget.edited.connect(self.edited)
# Signals
self._combobox.currentIndexChanged.connect(self._on_combo_box)
self._combobox.currentIndexChanged.connect(self.edited)
return layout
def _on_combo_box(self):
# Old values
oldwidget = self._stack.currentWidget()
try:
quantity = oldwidget._txt_quantity.text()
except:
quantity = None
try:
unit = oldwidget._txt_unit.text()
except:
unit = None
# Change widget
current_index = self._combobox.currentIndex()
self._stack.setCurrentIndex(current_index)
# Update values
widget = self._stack.currentWidget()
widget._txt_quantity.setText(quantity)
widget._txt_unit.setText(unit)
def parameter(self):
return self._stack.currentWidget().calibration()
def setParameter(self, calibration):
index = self._widget_indexes[type(calibration)]
self._combobox.setCurrentIndex(index)
self._stack.setCurrentIndex(index)
self._stack.currentWidget().setParameter(calibration)
def calibration(self):
return self.parameter()
def setCalibration(self, calibration):
self.setParameter(calibration)
def setReadOnly(self, state):
ParameterWidget.setReadOnly(self, state)
self._combobox.setEnabled(not state)
self._stack.currentWidget().setReadOnly(state)
def isReadOnly(self):
return ParameterWidget.isReadOnly(self) and \
not self._combobox.isEnabled() and \
self._stack.currentWidget().isReadOnly()
def hasAcceptableInput(self):
return ParameterWidget.hasAcceptableInput(self) and \
self._stack.currentWidget().hasAcceptableInput()
def insert_row(self, row=-1,
title='',
sample_runs='',
sample_mass_density='N/A',
sample_chemical_formula='N/A',
packing_fraction='N/A',
align_and_focus_args={},
sample_placzek_arguments={},
normalization_placzek_arguments={}):
self.table_ui.insertRow(row)
self.set_row_height(row, COLUMN_DEFAULT_HEIGHT)
_list_ui_to_unlock = [self.table_ui]
_dimension_widgets = {'label': None, 'value': 'N/A', 'units': None}
_full_dimension_widgets = {'radius': copy.deepcopy(_dimension_widgets),
'radius2': copy.deepcopy(_dimension_widgets),
'height': copy.deepcopy(_dimension_widgets)}
_text_button = {'text': None, 'button': None}
_mass_density_options = {'value': "N/A",
"selected": False}
_mass_density_infos = {'number_density': copy.deepcopy(_mass_density_options),
'mass_density': copy.deepcopy(_mass_density_options),
'mass': copy.deepcopy(_mass_density_options),
'molecular_mass': np.NaN,
'total_number_of_atoms': np.NaN,
}
_material_infos = {'mantid_format': None,
'addie_format': None}
_mass_density_infos['mass_density']["selected"] = True
_master_table_row_ui = {'active': None,
'title': None,
'sample': {'runs': None,
'background': {'runs': None,
'background': None,
},
'material': copy.deepcopy(_text_button),
'material_infos': copy.deepcopy(_material_infos),
'mass_density': copy.deepcopy(_text_button),
'mass_density_infos': copy.deepcopy(_mass_density_infos),
'packing_fraction': None,
'geometry': copy.deepcopy(_full_dimension_widgets),
'shape': None,
'abs_correction': None,
'mult_scat_correction': None,
'inelastic_correction': None,
'placzek_button': None,
'placzek_infos': None,
},
'normalization': {'runs': None,
'background': {'runs': None,
'background': None,
},
'material': copy.deepcopy(_text_button),
'material_infos': copy.deepcopy(_material_infos),
'mass_density': copy.deepcopy(_text_button),
'mass_density_infos': copy.deepcopy(_mass_density_infos),
'packing_fraction': None,
'geometry': copy.deepcopy(_full_dimension_widgets),
'shape': None,
'abs_correction': None,
'mult_scat_correction': None,
'inelastic_correction': None,
'placzek_button': None,
'placzek_infos': None,
},
'align_and_focus_args_button': None,
'align_and_focus_args_infos': {},
}
random_key = self.generate_random_key()
self.key = random_key
# block main table events
self.table_ui.blockSignals(True)
# column 0 (active or not checkBox)
_layout = QHBoxLayout()
_widget = QCheckBox()
_widget.setCheckState(QtCore.Qt.Checked)
_widget.setEnabled(True)
_master_table_row_ui['active'] = _widget
_spacer = QSpacerItem(40, 20,
QSizePolicy.Expanding,
QSizePolicy.Minimum)
_layout.addItem(_spacer)
_layout.addWidget(_widget)
_spacer = QSpacerItem(40, 20,
QSizePolicy.Expanding,
QSizePolicy.Minimum)
_layout.addItem(_spacer)
_layout.addStretch()
_new_widget = QWidget()
_new_widget.setLayout(_layout)
_widget.stateChanged.connect(lambda state=0, key=random_key:
self.main_window.master_table_select_state_changed(state, key))
column = 0
self.table_ui.setCellWidget(row, column, _new_widget)
# sample
column += 1
# column 1 - title
_item = QTableWidgetItem(title)
_master_table_row_ui['title'] = _item
self.table_ui.setItem(row, column, _item)
# column 2 - sample runs
column += 1
_item = QTableWidgetItem(sample_runs)
_master_table_row_ui['sample']['runs'] = _item
self.table_ui.setItem(row, column, _item)
# column 3 - background runs
column += 1
_item = QTableWidgetItem("")
_master_table_row_ui['sample']['background']['runs'] = _item
self.table_ui.setItem(row, column, _item)
# column 4 - background background
column += 1
_item = QTableWidgetItem("")
_master_table_row_ui['sample']['background']['background'] = _item
self.table_ui.setItem(row, column, _item)
# column 5 - material (chemical formula)
column += 1
clean_sample_chemical_formula = format_chemical_formula_equation(sample_chemical_formula)
_material_text = QLineEdit(clean_sample_chemical_formula)
_material_text = QLabel(clean_sample_chemical_formula)
_material_button = QPushButton("...")
_material_button.setFixedHeight(CONFIG_BUTTON_HEIGHT)
_material_button.setFixedWidth(CONFIG_BUTTON_WIDTH)
_material_button.pressed.connect(lambda key=random_key:
self.main_window.master_table_sample_material_button_pressed(key))
_verti_layout = QVBoxLayout()
_verti_layout.addWidget(_material_text)
_verti_layout.addWidget(_material_button)
_material_widget = QWidget()
_material_widget.setLayout(_verti_layout)
self.table_ui.setCellWidget(row, column, _material_widget)
_master_table_row_ui['sample']['material']['text'] = _material_text
_master_table_row_ui['sample']['material']['button'] = _material_button
# column 6 - mass density
column += 1
_mass_text = QLineEdit(sample_mass_density)
_mass_text.returnPressed.connect(lambda key=random_key:
self.main_window.master_table_sample_mass_density_line_edit_entered(key))
_mass_units = QLabel("g/cc")
_top_widget = QWidget()
_top_layout = QHBoxLayout()
_top_layout.addWidget(_mass_text)
_top_layout.addWidget(_mass_units)
_top_widget.setLayout(_top_layout)
_mass_button = QPushButton("...")
_mass_button.setFixedHeight(CONFIG_BUTTON_HEIGHT)
_mass_button.setFixedWidth(CONFIG_BUTTON_WIDTH)
_mass_button.pressed.connect(lambda key=random_key:
self.main_window.master_table_sample_mass_density_button_pressed(key))
_verti_layout = QVBoxLayout()
_verti_layout.addWidget(_top_widget)
_verti_layout.addWidget(_mass_button)
_mass_widget = QWidget()
_mass_widget.setLayout(_verti_layout)
self.table_ui.setCellWidget(row, column, _mass_widget)
_master_table_row_ui['sample']['mass_density']['text'] = _mass_text
_master_table_row_ui['sample']['mass_density']['button'] = _mass_button
# column 7 - packing fraction
column += 1
if packing_fraction == "N/A":
packing_fraction = "{}".format(self.main_window.packing_fraction)
_item = QTableWidgetItem(packing_fraction)
_master_table_row_ui['sample']['packing_fraction'] = _item
self.table_ui.setItem(row, column, _item)
# column 8 - shape (cylindrical or spherical)
column += 1
_layout = QHBoxLayout()
_layout.setContentsMargins(0, 0, 0, 0)
_widget = QComboBox()
_shape_default_index = 0
_widget.currentIndexChanged.connect(lambda index=_shape_default_index,
key=random_key:
self.main_window.master_table_sample_shape_changed(index, key))
_list_ui_to_unlock.append(_widget)
_widget.blockSignals(True)
_widget.addItem("cylindrical")
_widget.addItem("spherical")
_widget.addItem("hollow cylinder")
_master_table_row_ui['sample']['shape'] = _widget
_layout.addWidget(_widget)
_w = QWidget()
_w.setLayout(_layout)
self.table_ui.setCellWidget(row, column, _w)
# column 9 - dimensions
column += 1
# layout 1
_grid_layout = QGridLayout()
_label1 = QLabel("Radius:")
_grid_layout.addWidget(_label1, 1, 0)
_value1 = QLabel("N/A")
_grid_layout.addWidget(_value1, 1, 1)
_dim1 = QLabel("cm")
_grid_layout.addWidget(_dim1, 1, 2)
_label2 = QLabel("Radius:")
_label2.setVisible(False)
_grid_layout.addWidget(_label2, 2, 0)
_value2 = QLabel("N/A")
_value2.setVisible(False)
_grid_layout.addWidget(_value2, 2, 1)
_dim2 = QLabel("cm")
_dim2.setVisible(False)
_grid_layout.addWidget(_dim2, 2, 2)
_label3 = QLabel("Height:")
_grid_layout.addWidget(_label3, 3, 0)
_value3 = QLabel("N/A")
_grid_layout.addWidget(_value3, 3, 1)
_dim3 = QLabel("cm")
_grid_layout.addWidget(_dim3, 3, 2)
_master_table_row_ui['sample']['geometry']['radius']['value'] = _value1
_master_table_row_ui['sample']['geometry']['radius2']['value'] = _value2
_master_table_row_ui['sample']['geometry']['height']['value'] = _value3
_master_table_row_ui['sample']['geometry']['radius']['label'] = _label1
_master_table_row_ui['sample']['geometry']['radius2']['label'] = _label2
_master_table_row_ui['sample']['geometry']['height']['label'] = _label3
_master_table_row_ui['sample']['geometry']['radius']['units'] = _dim1
_master_table_row_ui['sample']['geometry']['radius2']['units'] = _dim2
_master_table_row_ui['sample']['geometry']['height']['units'] = _dim3
_geometry_widget = QWidget()
_geometry_widget.setLayout(_grid_layout)
_set_dimensions_button = QPushButton("...")
_set_dimensions_button.setFixedHeight(CONFIG_BUTTON_HEIGHT)
_set_dimensions_button.setFixedWidth(CONFIG_BUTTON_WIDTH)
_verti_layout = QVBoxLayout()
_verti_layout.addWidget(_geometry_widget)
_verti_layout.addWidget(_set_dimensions_button)
_verti_widget = QWidget()
_verti_widget.setLayout(_verti_layout)
_set_dimensions_button.pressed.connect(lambda key=random_key:
self.main_window.master_table_sample_dimensions_setter_button_pressed(key))
self.table_ui.setCellWidget(row, column, _verti_widget)
# column 10 - abs. correction
column += 1
_layout = QHBoxLayout()
_layout.setContentsMargins(0, 0, 0, 0)
_widget = QComboBox()
_shape_default_value = 0
list_abs_correction = self.get_absorption_correction_list(shape=_shape_default_value)
_widget.currentIndexChanged.connect(lambda value=list_abs_correction[0],
key = random_key:
self.main_window.master_table_sample_abs_correction_changed(value, key))
_widget.blockSignals(True)
_list_ui_to_unlock.append(_widget)
for _item in list_abs_correction:
_widget.addItem(_item)
_master_table_row_ui['sample']['abs_correction'] = _widget
_layout.addWidget(_widget)
_w = QWidget()
_w.setLayout(_layout)
self.table_ui.setCellWidget(row, column, _w)
# column 11 - multi. scattering correction
column += 1
_layout = QHBoxLayout()
_layout.setContentsMargins(0, 0, 0, 0)
_widget = QComboBox()
list_multi_scat_correction = self.get_multi_scat_correction_list(shape=_shape_default_value)
_widget.currentIndexChanged.connect(lambda value=list_multi_scat_correction[0],
key=random_key:
self.main_window.master_table_sample_multi_scattering_correction_changed(value, key))
_widget.blockSignals(True)
_list_ui_to_unlock.append(_widget)
for _item in list_multi_scat_correction:
_widget.addItem(_item)
_master_table_row_ui['sample']['mult_scat_correction'] = _widget
_layout.addWidget(_widget)
_w = QWidget()
_w.setLayout(_layout)
self.table_ui.setCellWidget(row, column, _w)
# column 12 - inelastic correction
column += 1
_layout = QHBoxLayout()
_layout.setContentsMargins(0, 0, 0, 0)
_widget1 = QComboBox()
_widget1.setMinimumHeight(20)
list_inelastic_correction = self.get_inelastic_scattering_list(shape=_shape_default_value)
for _item in list_inelastic_correction:
_widget1.addItem(_item)
_master_table_row_ui['sample']['inelastic_correction'] = _widget1
_button = QPushButton("...")
_button.setFixedHeight(CONFIG_BUTTON_HEIGHT)
_button.setFixedWidth(CONFIG_BUTTON_WIDTH)
_button.pressed.connect(lambda key=random_key:
self.main_window.master_table_sample_placzek_button_pressed(key))
_master_table_row_ui['sample']['placzek_button'] = _button
_button.setVisible(False)
_master_table_row_ui['sample']['placzek_button'] = _button
_layout.addWidget(_widget1)
_layout.addWidget(_button)
_widget = QWidget()
_widget.setLayout(_layout)
_default_value = 'None'
_widget1.currentIndexChanged.connect(lambda value=_default_value,
key=random_key:
self.main_window.master_table_sample_inelastic_correction_changed(value, key))
_widget.blockSignals(True)
_list_ui_to_unlock.append(_widget)
self.table_ui.setCellWidget(row, column, _widget)
# save default placzek settings
_sample_formated_placzek_default = self.formated_placzek_default(sample_placzek_arguments)
_master_table_row_ui['sample']['placzek_infos'] = _sample_formated_placzek_default
## normalization
# column 13 - sample runs
column += 1
_item = QTableWidgetItem("")
self.table_ui.setItem(row, column, _item)
# column 14 - background runs
column += 1
_item = QTableWidgetItem("")
self.table_ui.setItem(row, column, _item)
# column 15 - background background
column += 1
_item = QTableWidgetItem("")
self.table_ui.setItem(row, column, _item)
# column 16 - material (chemical formula)
column += 1
#_material_text = QLineEdit("")
_material_text = QLabel("N/A")
_material_button = QPushButton("...")
_material_button.setFixedHeight(CONFIG_BUTTON_HEIGHT)
_material_button.setFixedWidth(CONFIG_BUTTON_WIDTH)
_material_button.pressed.connect(lambda key=random_key:
self.main_window.master_table_normalization_material_button_pressed(key))
_verti_layout = QVBoxLayout()
_verti_layout.addWidget(_material_text)
_verti_layout.addWidget(_material_button)
_material_widget = QWidget()
_material_widget.setLayout(_verti_layout)
self.table_ui.setCellWidget(row, column, _material_widget)
_master_table_row_ui['normalization']['material']['text'] = _material_text
_master_table_row_ui['normalization']['material']['button'] = _material_button
# column 17 - mass density
column += 1
_mass_text = QLineEdit("N/A")
_mass_text.returnPressed.connect(lambda key=random_key:
self.main_window.master_table_normalization_mass_density_line_edit_entered(key))
_mass_units = QLabel("g/cc")
_top_widget = QWidget()
_top_layout = QHBoxLayout()
_top_layout.addWidget(_mass_text)
_top_layout.addWidget(_mass_units)
_top_widget.setLayout(_top_layout)
_mass_button = QPushButton("...")
_mass_button.setFixedWidth(CONFIG_BUTTON_WIDTH)
_mass_button.setFixedHeight(CONFIG_BUTTON_HEIGHT)
_mass_button.pressed.connect(lambda key=random_key:
self.main_window.master_table_normalization_mass_density_button_pressed(key))
_verti_layout = QVBoxLayout()
_verti_layout.addWidget(_top_widget)
_verti_layout.addWidget(_mass_button)
_mass_widget = QWidget()
_mass_widget.setLayout(_verti_layout)
self.table_ui.setCellWidget(row, column, _mass_widget)
_master_table_row_ui['normalization']['mass_density']['text'] = _mass_text
_master_table_row_ui['normalization']['mass_density']['button'] = _mass_button
# column 18 - packing fraction
column += 1
_item = QTableWidgetItem("")
self.table_ui.setItem(row, column, _item)
# column 19 - shape (cylindrical or spherical)
column += 1
_layout = QHBoxLayout()
_layout.setContentsMargins(0, 0, 0, 0)
_widget = QComboBox()
_widget.currentIndexChanged.connect(lambda value=_shape_default_value,
key=random_key:
self.main_window.master_table_normalization_shape_changed(value, key))
_widget.blockSignals(True)
_list_ui_to_unlock.append(_widget)
_widget.addItem("cylindrical")
_widget.addItem("spherical")
_widget.addItem("hollow cylinder")
_master_table_row_ui['normalization']['shape'] = _widget
_layout.addWidget(_widget)
_w = QWidget()
_w.setLayout(_layout)
self.table_ui.setCellWidget(row, column, _w)
# column 20 - dimensions
column += 1
# layout 1
_grid_layout = QGridLayout()
_label1 = QLabel("Radius:")
_grid_layout.addWidget(_label1, 1, 0)
_value1 = QLabel("N/A")
_grid_layout.addWidget(_value1, 1, 1)
_dim1 = QLabel("cm")
_grid_layout.addWidget(_dim1, 1, 2)
_label2 = QLabel("Radius:")
_label2.setVisible(False)
_grid_layout.addWidget(_label2, 2, 0)
_value2 = QLabel("N/A")
_value2.setVisible(False)
_grid_layout.addWidget(_value2, 2, 1)
_dim2 = QLabel("cm")
_dim2.setVisible(False)
_grid_layout.addWidget(_dim2, 2, 2)
_label3 = QLabel("Height:")
_grid_layout.addWidget(_label3, 3, 0)
_value3 = QLabel("N/A")
_grid_layout.addWidget(_value3, 3, 1)
_dim3 = QLabel("cm")
_grid_layout.addWidget(_dim3, 3, 2)
_master_table_row_ui['normalization']['geometry']['radius']['value'] = _value1
_master_table_row_ui['normalization']['geometry']['radius2']['value'] = _value2
_master_table_row_ui['normalization']['geometry']['height']['value'] = _value3
_master_table_row_ui['normalization']['geometry']['radius']['label'] = _label1
_master_table_row_ui['normalization']['geometry']['radius2']['label'] = _label2
_master_table_row_ui['normalization']['geometry']['height']['label'] = _label3
_master_table_row_ui['normalization']['geometry']['radius']['units'] = _dim1
_master_table_row_ui['normalization']['geometry']['radius2']['units'] = _dim2
_master_table_row_ui['normalization']['geometry']['height']['units'] = _dim3
_geometry_widget = QWidget()
_geometry_widget.setLayout(_grid_layout)
_set_dimensions_button = QPushButton("...")
_set_dimensions_button.setFixedHeight(CONFIG_BUTTON_HEIGHT)
_set_dimensions_button.setFixedWidth(CONFIG_BUTTON_WIDTH)
_verti_layout = QVBoxLayout()
_verti_layout.addWidget(_geometry_widget)
_verti_layout.addWidget(_set_dimensions_button)
_verti_widget = QWidget()
_verti_widget.setLayout(_verti_layout)
_set_dimensions_button.pressed.connect(lambda key=random_key:
self.main_window.master_table_normalization_dimensions_setter_button_pressed(key)) # noqa
self.table_ui.setCellWidget(row, column, _verti_widget)
# column 21 - abs. correction
column += 1
_layout = QHBoxLayout()
_layout.setContentsMargins(0, 0, 0, 0)
_widget = QComboBox()
_widget.currentIndexChanged.connect(lambda value=list_abs_correction[0],
key=random_key:
self.main_window.master_table_normalization_abs_correction_changed(value, key)) # noqa
_widget.blockSignals(True)
_list_ui_to_unlock.append(_widget)
for _item in list_abs_correction:
_widget.addItem(_item)
_widget.setCurrentIndex(0)
_master_table_row_ui['normalization']['abs_correction'] = _widget
_layout.addWidget(_widget)
_w = QWidget()
_w.setLayout(_layout)
self.table_ui.setCellWidget(row, column, _w)
# column 24 - multi. scattering correction
column += 1
_layout = QHBoxLayout()
_layout.setContentsMargins(0, 0, 0, 0)
_widget = QComboBox()
_widget.currentIndexChanged.connect(lambda value=list_multi_scat_correction[0],
key=random_key:
self.main_window.master_table_normalization_multi_scattering_correction_changed(value, key)) # noqa
_widget.blockSignals(True)
_list_ui_to_unlock.append(_widget)
for _item in list_multi_scat_correction:
_widget.addItem(_item)
_widget.setCurrentIndex(0)
_master_table_row_ui['normalization']['mult_scat_correction'] = _widget
_layout.addWidget(_widget)
_w = QWidget()
_w.setLayout(_layout)
self.table_ui.setCellWidget(row, column, _w)
# column 22 - inelastic correction
column += 1
_layout = QHBoxLayout()
_layout.setContentsMargins(0, 0, 0, 0)
_widget1 = QComboBox()
_widget1.setMinimumHeight(20)
list_inelastic_correction = self.get_inelastic_scattering_list(shape=_shape_default_value)
for _item in list_inelastic_correction:
_widget1.addItem(_item)
_widget1.setCurrentIndex(0)
_master_table_row_ui['normalization']['inelastic_correction'] = _widget1
_button = QPushButton("...")
_button.setFixedWidth(CONFIG_BUTTON_WIDTH)
_button.setFixedHeight(CONFIG_BUTTON_HEIGHT)
_button.pressed.connect(lambda key=random_key:
self.main_window.master_table_normalization_placzek_button_pressed(key))
_master_table_row_ui['normalization']['placzek_button'] = _button
_button.setVisible(False)
_layout.addWidget(_widget1)
_layout.addWidget(_button)
_widget = QWidget()
_widget.setLayout(_layout)
_default_value = 'None'
_widget1.currentIndexChanged.connect( lambda value=_default_value,
key=random_key:
self.main_window.master_table_normalization_inelastic_correction_changed(value, key)) # noqa
_widget.blockSignals(True)
_list_ui_to_unlock.append(_widget)
self.table_ui.setCellWidget(row, column, _widget)
# automatically populate placzek infos with default values
_norm_formated_placzek_default = self.formated_placzek_default(normalization_placzek_arguments)
_master_table_row_ui['normalization']['placzek_infos'] = _norm_formated_placzek_default
# column 23 - key/value pair
column += 1
_layout = QHBoxLayout()
_spacer_kv1 = QSpacerItem(40, 20,
QSizePolicy.Expanding,
QSizePolicy.Minimum)
_layout.addItem(_spacer_kv1)
_button = QPushButton("...")
_layout.addWidget(_button)
_button.setFixedWidth(CONFIG_BUTTON_WIDTH)
_button.setFixedHeight(CONFIG_BUTTON_HEIGHT)
_button.pressed.connect(lambda key=random_key:
self.main_window.master_table_keyvalue_button_pressed(key))
_new_widget = QWidget()
_new_widget.setLayout(_layout)
self.table_ui.setCellWidget(row, column, _new_widget)
_master_table_row_ui['align_and_focus_args_button'] = _button
_spacer_kv2 = QSpacerItem(40, 20,
QSizePolicy.Expanding,
QSizePolicy.Minimum)
_layout.addItem(_spacer_kv2)
_layout.addStretch()
_master_table_row_ui['align_and_focus_args_infos'] = align_and_focus_args
## recap
self.main_window.master_table_list_ui[random_key] = _master_table_row_ui
self.unlock_signals_ui(list_ui=_list_ui_to_unlock)
self.main_window.check_status_of_right_click_buttons()
class ConfigDialog(QDialog):
"""
Dialog window for specifying test configuration.
The window contains a combobox with all the frameworks, a line edit box for
specifying the working directory, a button to use a file browser for
selecting the directory, and OK and Cancel buttons. Initially, no framework
is selected and the OK button is disabled. Selecting a framework enables
the OK button.
"""
def __init__(self, frameworks, config, parent=None):
"""
Construct a dialog window.
Parameters
----------
frameworks : dict of (str, type)
Names of all supported frameworks with their associated class
(assumed to be a subclass of RunnerBase)
config : Config
Initial configuration
parent : QWidget
"""
super(ConfigDialog, self).__init__(parent)
self.setWindowTitle(_('Configure tests'))
layout = QVBoxLayout(self)
framework_layout = QHBoxLayout()
framework_label = QLabel(_('Test framework'))
framework_layout.addWidget(framework_label)
self.framework_combobox = QComboBox(self)
for ix, (name, runner) in enumerate(sorted(frameworks.items())):
installed = runner.is_installed()
if installed:
label = name
else:
label = '{} ({})'.format(name, _('not available'))
self.framework_combobox.addItem(label)
self.framework_combobox.model().item(ix).setEnabled(installed)
framework_layout.addWidget(self.framework_combobox)
layout.addLayout(framework_layout)
layout.addSpacing(10)
wdir_label = QLabel(_('Directory from which to run tests'))
layout.addWidget(wdir_label)
wdir_layout = QHBoxLayout()
self.wdir_lineedit = QLineEdit(self)
wdir_layout.addWidget(self.wdir_lineedit)
self.wdir_button = QPushButton(ima.icon('DirOpenIcon'), '', self)
self.wdir_button.setToolTip(_("Select directory"))
self.wdir_button.clicked.connect(lambda: self.select_directory())
wdir_layout.addWidget(self.wdir_button)
layout.addLayout(wdir_layout)
layout.addSpacing(20)
self.buttons = QDialogButtonBox(QDialogButtonBox.Ok |
QDialogButtonBox.Cancel)
layout.addWidget(self.buttons)
self.buttons.accepted.connect(self.accept)
self.buttons.rejected.connect(self.reject)
self.ok_button = self.buttons.button(QDialogButtonBox.Ok)
self.ok_button.setEnabled(False)
self.framework_combobox.currentIndexChanged.connect(
self.framework_changed)
self.framework_combobox.setCurrentIndex(-1)
if config.framework:
index = self.framework_combobox.findText(config.framework)
if index != -1:
self.framework_combobox.setCurrentIndex(index)
self.wdir_lineedit.setText(config.wdir)
@Slot(int)
def framework_changed(self, index):
"""Called when selected framework changes."""
if index != -1:
self.ok_button.setEnabled(True)
def select_directory(self):
"""Display dialog for user to select working directory."""
basedir = to_text_string(self.wdir_lineedit.text())
if not osp.isdir(basedir):
basedir = getcwd()
title = _("Select directory")
directory = getexistingdirectory(self, title, basedir)
if directory:
self.wdir_lineedit.setText(directory)
def get_config(self):
"""
Return the test configuration specified by the user.
Returns
-------
Config
Test configuration
"""
framework = self.framework_combobox.currentText()
if framework == '':
framework = None
return Config(framework=framework, wdir=self.wdir_lineedit.text())
class ClassFunctionDropdown(Panel):
"""
Class and Function/Method Dropdowns Widget.
Parameters
----------
editor : :class:`spyder.plugins.editor.widgets.codeeditor.CodeEditor`
The editor to act on.
"""
def __init__(self, editor):
Panel.__init__(self, editor)
self._editor = editor
self._editor.sig_cursor_position_changed.connect(
self._handle_cursor_position_change_event
)
# The layout
hbox = QHBoxLayout()
self.class_cb = QComboBox()
self.method_cb = QComboBox()
hbox.addWidget(self.class_cb)
hbox.addWidget(self.method_cb)
hbox.setSpacing(0)
hbox.setContentsMargins(0, 0, 0, 0)
self.setLayout(hbox)
# Internal data
self.folds = None
self.parents = None
self.classes = None
self.funcs = None
# Initial data for the dropdowns.
self.class_cb.addItem("<None>", 0)
self.method_cb.addItem("<None>", 0)
# Attach some events.
self.class_cb.activated.connect(self.combobox_activated)
self.method_cb.activated.connect(self.combobox_activated)
def sizeHint(self):
"""Override Qt method."""
return QSize(0, self._getVerticalSize())
def _getVerticalSize(self):
"""Get the default height of a QComboBox."""
return self.class_cb.height()
def _update_data(self):
"""Update the internal data values."""
_old = self.folds
self.folds = _get_fold_levels(self.editor)
# only update our dropdown lists if the folds have changed.
if self.folds != _old:
self.classes, self.funcs = _split_classes_and_methods(self.folds)
self.populate_dropdowns()
def populate_dropdowns(self):
self.class_cb.clear()
self.method_cb.clear()
populate(self.class_cb, self.classes)
populate(self.method_cb, self.funcs)
def combobox_activated(self):
"""Move the cursor to the selected definition."""
sender = self.sender()
data = sender.itemData(sender.currentIndex())
if isinstance(data, FoldScopeHelper):
self.editor.go_to_line(data.line + 1)
def update_selected(self, linenum):
"""Updates the dropdowns to reflect the current class and function."""
self.parents = _get_parents(self.funcs, linenum)
update_selected_cb(self.parents, self.method_cb)
self.parents = _get_parents(self.classes, linenum)
update_selected_cb(self.parents, self.class_cb)
@Slot(int, int)
def _handle_cursor_position_change_event(self, linenum, column):
self._update_data()
self.update_selected(linenum)
class CSVSettingsDialog(QDialog):
def __init__(self, parent=None):
super().__init__(parent)
self.settings = QSettings()
# decimal
self.decimalLabel = QLabel(self.tr("decimal:"))
self.decimalComboBox = QComboBox()
self.decimalLabel.setBuddy(self.decimalComboBox)
self.decimalComboBox.addItems([",", "."])
# separator
self.separatorLabel = QLabel(self.tr("separator:"))
self.separatorComboBox = QComboBox()
self.separatorLabel.setBuddy(self.separatorComboBox)
self.separatorComboBox.addItem("Semicolon ';'", ';')
self.separatorComboBox.addItem("Comma ','", ',')
self.separatorComboBox.addItem("Tabulator '\\t'", '\t')
self.separatorComboBox.addItem("Whitespace ' '", ' ')
# buttons
self.buttons = QDialogButtonBox(
QDialogButtonBox.Ok | QDialogButtonBox.Cancel
)
self.buttons.accepted.connect(self.accept)
self.buttons.rejected.connect(self.reject)
# layout
layout = QGridLayout()
layout.addWidget(self.decimalLabel, 0, 0)
layout.addWidget(self.decimalComboBox, 0, 1)
layout.addWidget(self.separatorLabel, 1, 0)
layout.addWidget(self.separatorComboBox, 1, 1)
layout.addWidget(self.buttons, 2, 0, 1, 2)
self.setLayout(layout)
# settings
self.decimalComboBox.setCurrentIndex(
self.decimalComboBox.findText(
self.settings.value(DECIMAL_SETTING, ","))
)
self.separatorComboBox.setCurrentIndex(
self.separatorComboBox.findData(
self.settings.value(SEPARATOR_SETTING, ";"))
)
self.setWindowTitle(self.tr("record settings"))
def accept(self):
self.settings.setValue(DECIMAL_SETTING, self.decimal)
self.settings.setValue(SEPARATOR_SETTING, self.separator)
super().accept()
# decimal property
@property
def decimal(self):
return self.decimalComboBox.currentText()
# seperator property
@property
def separator(self):
return self.separatorComboBox.itemData(
self.separatorComboBox.currentIndex())
class LSPServerEditor(QDialog):
DEFAULT_HOST = '127.0.0.1'
DEFAULT_PORT = 2084
DEFAULT_CMD = ''
DEFAULT_ARGS = ''
DEFAULT_CONFIGURATION = '{}'
DEFAULT_EXTERNAL = False
HOST_REGEX = re.compile(r'^\w+([.]\w+)*$')
NON_EMPTY_REGEX = re.compile(r'^\S+$')
JSON_VALID = _('JSON valid')
JSON_INVALID = _('JSON invalid')
def __init__(self, parent, language=None, cmd='', host='127.0.0.1',
port=2084, args='', external=False, configurations={},
**kwargs):
super(LSPServerEditor, self).__init__(parent)
self.parent = parent
self.external = external
bbox = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
self.button_ok = bbox.button(QDialogButtonBox.Ok)
self.button_cancel = bbox.button(QDialogButtonBox.Cancel)
self.button_ok.setEnabled(False)
description = _('To create a new configuration, '
'you need to select a programming '
'language, along with a executable '
'name for the server to execute '
'(If the instance is local), '
'and the host and port. Finally, '
'you need to provide the '
'arguments that the server accepts. '
'The placeholders <tt>%(host)s</tt> and '
'<tt>%(port)s</tt> refer to the host '
'and the port, respectively.')
server_settings_description = QLabel(description)
server_settings_description.setWordWrap(True)
lang_label = QLabel(_('Language:'))
self.lang_cb = QComboBox(self)
self.lang_cb.setToolTip(_('Programming language provided '
'by the LSP server'))
self.lang_cb.addItem(_('Select a language'))
self.lang_cb.addItems(LSP_LANGUAGES)
if language is not None:
idx = LSP_LANGUAGES.index(language)
self.lang_cb.setCurrentIndex(idx + 1)
self.button_ok.setEnabled(True)
host_label = QLabel(_('Host:'))
self.host_input = QLineEdit(self)
self.host_input.setToolTip(_('Name of the host that will provide '
'access to the server'))
self.host_input.setText(host)
self.host_input.textChanged.connect(lambda x: self.validate())
port_label = QLabel(_('Port:'))
self.port_spinner = QSpinBox(self)
self.port_spinner.setToolTip(_('TCP port number of the server'))
self.port_spinner.setMinimum(1)
self.port_spinner.setMaximum(60000)
self.port_spinner.setValue(port)
cmd_label = QLabel(_('Command to execute:'))
self.cmd_input = QLineEdit(self)
self.cmd_input.setToolTip(_('Command used to start the '
'LSP server locally'))
self.cmd_input.setText(cmd)
if not external:
self.cmd_input.textChanged.connect(lambda x: self.validate())
args_label = QLabel(_('Server arguments:'))
self.args_input = QLineEdit(self)
self.args_input.setToolTip(_('Additional arguments required to '
'start the server'))
self.args_input.setText(args)
conf_label = QLabel(_('LSP Server Configurations:'))
self.conf_input = CodeEditor(None)
self.conf_input.textChanged.connect(self.validate)
color_scheme = CONF.get('appearance', 'selected')
self.conf_input.setup_editor(
language='JSON',
color_scheme=color_scheme,
wrap=False,
edge_line=True,
highlight_current_line=True,
highlight_current_cell=True,
occurrence_highlighting=True,
auto_unindent=True,
font=get_font(),
filename='config.json')
self.conf_input.setToolTip(_('Additional LSP server configurations '
'set at runtime. JSON required'))
conf_text = '{}'
try:
conf_text = json.dumps(configurations, indent=4, sort_keys=True)
except Exception:
pass
self.conf_input.set_text(conf_text)
self.json_label = QLabel(self.JSON_VALID, self)
self.external_cb = QCheckBox(_('External server'), self)
self.external_cb.setToolTip(_('Check if the server runs '
'on a remote location'))
self.external_cb.setChecked(external)
self.external_cb.stateChanged.connect(self.set_local_options)
hlayout = QHBoxLayout()
general_vlayout = QVBoxLayout()
general_vlayout.addWidget(server_settings_description)
vlayout = QVBoxLayout()
lang_layout = QVBoxLayout()
lang_layout.addWidget(lang_label)
lang_layout.addWidget(self.lang_cb)
# layout2 = QHBoxLayout()
# layout2.addLayout(lang_layout)
lang_layout.addWidget(self.external_cb)
vlayout.addLayout(lang_layout)
host_layout = QVBoxLayout()
host_layout.addWidget(host_label)
host_layout.addWidget(self.host_input)
port_layout = QVBoxLayout()
port_layout.addWidget(port_label)
port_layout.addWidget(self.port_spinner)
conn_info_layout = QHBoxLayout()
conn_info_layout.addLayout(host_layout)
conn_info_layout.addLayout(port_layout)
vlayout.addLayout(conn_info_layout)
cmd_layout = QVBoxLayout()
cmd_layout.addWidget(cmd_label)
cmd_layout.addWidget(self.cmd_input)
vlayout.addLayout(cmd_layout)
args_layout = QVBoxLayout()
args_layout.addWidget(args_label)
args_layout.addWidget(self.args_input)
vlayout.addLayout(args_layout)
conf_layout = QVBoxLayout()
conf_layout.addWidget(conf_label)
conf_layout.addWidget(self.conf_input)
conf_layout.addWidget(self.json_label)
hlayout.addLayout(vlayout)
hlayout.addLayout(conf_layout)
general_vlayout.addLayout(hlayout)
general_vlayout.addWidget(bbox)
self.setLayout(general_vlayout)
bbox.accepted.connect(self.accept)
bbox.rejected.connect(self.reject)
self.lang_cb.currentIndexChanged.connect(
self.lang_selection_changed)
self.form_status(False)
if language is not None:
self.form_status(True)
self.validate()
@Slot()
def validate(self):
host_text = self.host_input.text()
cmd_text = self.cmd_input.text()
if not self.HOST_REGEX.match(host_text):
self.button_ok.setEnabled(False)
self.host_input.setStyleSheet("QLineEdit{border: 1px solid red;}")
self.host_input.setToolTip('Hostname must be valid')
return
else:
self.host_input.setStyleSheet(
"QLineEdit{border: 1px solid green;}")
self.host_input.setToolTip('Hostname is valid')
self.button_ok.setEnabled(True)
if not self.external:
if not self.NON_EMPTY_REGEX.match(cmd_text):
self.button_ok.setEnabled(False)
self.cmd_input.setStyleSheet(
"QLineEdit{border: 1px solid red;}")
self.cmd_input.setToolTip('Command must be non empty')
return
if find_program(cmd_text) is None:
self.button_ok.setEnabled(False)
self.cmd_input.setStyleSheet(
"QLineEdit{border: 1px solid red;}")
self.cmd_input.setToolTip('Program was not found '
'on your system')
return
else:
self.cmd_input.setStyleSheet(
"QLineEdit{border: 1px solid green;}")
self.cmd_input.setToolTip('Program was found on your system')
self.button_ok.setEnabled(True)
try:
json.loads(self.conf_input.toPlainText())
try:
self.json_label.setText(self.JSON_VALID)
except:
pass
except (ValueError, json.decoder.JSONDecodeError):
try:
self.json_label.setText(self.JSON_INVALID)
self.button_ok.setEnabled(False)
except:
pass
def form_status(self, status):
self.host_input.setEnabled(status)
self.port_spinner.setEnabled(status)
self.external_cb.setEnabled(status)
self.cmd_input.setEnabled(status)
self.args_input.setEnabled(status)
self.conf_input.setEnabled(status)
self.json_label.setVisible(status)
@Slot()
def lang_selection_changed(self):
idx = self.lang_cb.currentIndex()
if idx == 0:
self.set_defaults()
self.form_status(False)
self.button_ok.setEnabled(False)
else:
server = self.parent.get_server_by_lang(LSP_LANGUAGES[idx - 1])
self.form_status(True)
if server is not None:
self.host_input.setText(server.host)
self.port_spinner.setValue(server.port)
self.external_cb.setChecked(server.external)
self.cmd_input.setText(server.cmd)
self.args_input.setText(server.args)
self.conf_input.set_text(json.dumps(server.configurations))
self.json_label.setText(self.JSON_VALID)
self.button_ok.setEnabled(True)
else:
self.set_defaults()
def set_defaults(self):
self.cmd_input.setStyleSheet('')
self.host_input.setStyleSheet('')
self.host_input.setText(self.DEFAULT_HOST)
self.port_spinner.setValue(self.DEFAULT_PORT)
self.external_cb.setChecked(self.DEFAULT_EXTERNAL)
self.cmd_input.setText(self.DEFAULT_CMD)
self.args_input.setText(self.DEFAULT_ARGS)
self.conf_input.set_text(self.DEFAULT_CONFIGURATION)
self.json_label.setText(self.JSON_VALID)
@Slot(bool)
@Slot(int)
def set_local_options(self, enabled):
self.external = enabled
self.cmd_input.setEnabled(True)
self.args_input.setEnabled(True)
if enabled:
self.cmd_input.setEnabled(False)
self.cmd_input.setStyleSheet('')
self.args_input.setEnabled(False)
try:
self.validate()
except:
pass
def get_options(self):
language_idx = self.lang_cb.currentIndex()
language = LSP_LANGUAGES[language_idx - 1]
host = self.host_input.text()
port = int(self.port_spinner.value())
external = self.external_cb.isChecked()
args = self.args_input.text()
cmd = self.cmd_input.text()
configurations = json.loads(self.conf_input.toPlainText())
server = LSPServer(language=language.lower(), cmd=cmd, args=args,
host=host, port=port, external=external,
configurations=configurations)
return server
