def createEditor(self, parent, options, index):
self.update = True
node = index.internalPointer()
if isinstance(node, JsonItem):
if node.type in ('float', 'int'):
editor = QDoubleSpinBox(parent)
editor.setSuffix(node.unit or "")
editor.setRange(node.min or -sys.maxsize,
node.max or sys.maxsize)
editor.setGeometry(options.rect)
editor.setDecimals(node.decimals or 0)
editor.show()
return editor
else:
return super().createEditor(parent, options, index)
class ItemPropertyDialog(QDialog):
def __init__(self, jsonitem: JsonItem, parent=None):
super().__init__(parent)
assert jsonitem is not None
self.item = jsonitem
# name
self.nameLabel = QLabel(self.tr("name:"))
self.nameLineEdit = QLineEdit(self.item.name or "")
self.nameLabel.setBuddy(self.nameLineEdit)
# unit
self.unitLabel = QLabel(self.tr("unit:"))
self.unitLineEdit = QLineEdit(self.item.unit or "")
self.unitLabel.setBuddy(self.unitLineEdit)
# type
self.typeLabel = QLabel(self.tr("type:"))
self.typeComboBox = QComboBox()
self.typeComboBox.addItems([k for k, t in VALUETYPES])
self.typeComboBox.setCurrentIndex(
self.typeComboBox.findText(self.item.type))
self.typeComboBox.currentIndexChanged.connect(self.data_changed)
self.typeLabel.setBuddy(self.typeComboBox)
# decimals
self.decimalsLabel = QLabel(self.tr("decimals:"))
self.decimalsSpinBox = QSpinBox()
self.decimalsSpinBox.setRange(0, 10)
self.decimalsSpinBox.setValue(self.item.decimals or 0)
self.decimalsLabel.setBuddy(self.decimalsSpinBox)
self.decimalsSpinBox.valueChanged.connect(self.data_changed)
self.last_decimals = self.decimalsSpinBox.value()
# min
self.minLabel = QLabel(self.tr("minimum:"))
self.minSpinBox =QDoubleSpinBox()
self.minSpinBox.setRange(-sys.maxsize, sys.maxsize)
self.minLabel.setBuddy(self.minSpinBox)
self.minSpinBox.setValue(self.item.min or 0.0)
# max
self.maxLabel = QLabel(self.tr("maximum:"))
self.maxSpinBox = QDoubleSpinBox()
self.maxSpinBox.setRange(-sys.maxsize, sys.maxsize)
self.maxSpinBox.setValue(self.item.max or 100.0)
# numerator
self.scalefactorLabel = QLabel(self.tr("scalefactor:"))
self.scalefactorSpinBox = NoZerosDoubleSpinBox()
self.scalefactorSpinBox.setRange(-sys.maxsize, sys.maxsize)
self.scalefactorSpinBox.setButtonSymbols(QSpinBox.NoButtons)
self.scalefactorSpinBox.setDecimals(10)
self.scalefactorSpinBox.setValue(self.item.scalefactor or 1)
self.scalefactorLabel.setBuddy(self.scalefactorSpinBox)
# readonly
self.readonlyCheckBox = QCheckBox(self.tr("readonly"))
self.readonlyCheckBox.setChecked(Qt.Checked if self.item.readonly
else Qt.Unchecked)
self.readonlyCheckBox.stateChanged.connect(self.data_changed)
# buttons
self.buttons = QDialogButtonBox(
QDialogButtonBox.Ok | QDialogButtonBox.Cancel,
Qt.Horizontal
)
self.buttons.accepted.connect(self.accept)
self.buttons.rejected.connect(self.reject)
# layout
layout = QGridLayout()
layout.addWidget(self.nameLabel, 0, 0)
layout.addWidget(self.nameLineEdit, 0, 1)
layout.addWidget(self.unitLabel, 1, 0)
layout.addWidget(self.unitLineEdit, 1, 1)
layout.addWidget(self.typeLabel, 2, 0)
layout.addWidget(self.typeComboBox, 2, 1)
layout.addWidget(self.decimalsLabel, 3, 0)
layout.addWidget(self.decimalsSpinBox, 3, 1)
layout.addWidget(self.minLabel, 4, 0)
layout.addWidget(self.minSpinBox, 4, 1)
layout.addWidget(self.maxLabel, 5, 0)
layout.addWidget(self.maxSpinBox, 5, 1)
layout.addWidget(self.scalefactorLabel, 6, 0)
layout.addWidget(self.scalefactorSpinBox, 6, 1)
layout.addWidget(self.readonlyCheckBox, 7, 0, 1, 2)
layout.addWidget(self.buttons, 8, 0, 1, 2)
self.setLayout(layout)
# misc
self.setWindowTitle("Edit JsonItem '%s'" % self.item.key)
self.data_changed()
def accept(self):
self.item.name = self.nameLineEdit.text()
self.item.unit = self.unitLineEdit.text()
self.item.decimals = self.decimalsSpinBox.value()
self.item.min = self.minSpinBox.value()
self.item.max = self.maxSpinBox.value()
self.item.scalefactor = self.scalefactorSpinBox.value()
self.item.readonly = self.readonlyCheckBox.checkState() == Qt.Checked
self.item.type = self.typeComboBox.currentText()
return super().accept()
def data_changed(self):
type_numeric = self.typeComboBox.currentText() not in ('bool', 'str')
type_int = self.typeComboBox.currentText() == 'int'
readonly = self.readonlyCheckBox.checkState() == Qt.Checked
# not used properties invisible
self.decimalsSpinBox.setVisible(type_numeric)
self.decimalsLabel.setVisible(type_numeric)
self.scalefactorSpinBox.setVisible(type_numeric)
self.scalefactorLabel.setVisible(type_numeric)
self.minSpinBox.setVisible(type_numeric and not readonly)
self.minLabel.setVisible(type_numeric and not readonly)
self.maxSpinBox.setVisible(type_numeric and not readonly)
self.maxLabel.setVisible(type_numeric and not readonly)
self.unitLineEdit.setVisible(type_numeric)
self.unitLabel.setVisible(type_numeric)
# no decimals for int
self.minSpinBox.setDecimals(self.decimalsSpinBox.value())
self.maxSpinBox.setDecimals(self.decimalsSpinBox.value())
if type_int:
delta = self.decimalsSpinBox.value() - self.last_decimals
self.scalefactorSpinBox.setValue(
self.scalefactorSpinBox.value() / 10**delta
)
self.last_decimals = self.decimalsSpinBox.value()
class DimensionMDE(Dimension):
binningChanged = Signal()
"""
MDEventWorkspace has additional properties for either number_of_bins or thickness
from mantidqt.widgets.sliceviewer.dimensionwidget import DimensionMDE
from qtpy.QtWidgets import QApplication
app = QApplication([])
window = DimensionMDE({'minimum':-1.1, 'number_of_bins':11, 'width':0.2, 'name':'Dim0', 'units':'A'})
window.show()
app.exec_()
"""
def __init__(self, dim_info, number=0, state=State.NONE, parent=None):
# hack in a number_of_bins for MDEventWorkspace
dim_info['number_of_bins'] = 1000
dim_info['width'] = (dim_info['maximum']-dim_info['minimum'])/1000
self.spinBins = QSpinBox()
self.spinBins.setRange(2,9999)
self.spinBins.setValue(100)
self.spinBins.hide()
self.spinBins.setMinimumWidth(110)
self.spinThick = QDoubleSpinBox()
self.spinThick.setRange(0.001,999)
self.spinThick.setValue(0.1)
self.spinThick.setSingleStep(0.1)
self.spinThick.setDecimals(3)
self.spinThick.setMinimumWidth(110)
self.rebinLabel = QLabel("thick")
self.rebinLabel.setMinimumWidth(44)
super(DimensionMDE, self).__init__(dim_info, number, state, parent)
self.spinBins.valueChanged.connect(self.binningChanged)
self.spinThick.valueChanged.connect(self.valueChanged)
self.layout.addWidget(self.spinBins)
self.layout.addWidget(self.spinThick)
self.layout.addWidget(self.rebinLabel)
def get_bins(self):
return int(self.spinBins.value())
def get_thickness(self):
return float(self.spinThick.value())
def set_state(self, state):
super(DimensionMDE, self).set_state(state)
if self.state == State.X:
self.spinBins.show()
self.spinThick.hide()
self.rebinLabel.setText('bins')
elif self.state == State.Y:
self.spinBins.show()
self.spinThick.hide()
self.rebinLabel.setText('bins')
elif self.state == State.NONE:
self.spinBins.hide()
self.spinThick.show()
self.rebinLabel.setText('thick')
else:
self.spinBins.hide()
self.spinThick.hide()
self.rebinLabel.hide()
class Dimension(QWidget):
stateChanged = Signal(int)
valueChanged = Signal()
"""
pass in dimension
state: one of (State.X, State.Y, State.NONE, State.DISBALE)
Can be run independently by:
from mantidqt.widgets.sliceviewer.dimensionwidget import Dimension
from qtpy.QtWidgets import QApplication
app = QApplication([])
window = Dimension({'minimum':-1.1, 'number_of_bins':11, 'width':0.2, 'name':'Dim0', 'units':'A'})
window.show()
app.exec_()
"""
def __init__(self, dim_info, number=0, state=State.NONE, parent=None):
super(Dimension, self).__init__(parent)
self.minimum = dim_info['minimum']
self.nbins = dim_info['number_of_bins']
self.width = dim_info['width']
self.number = number
self.layout = QHBoxLayout(self)
self.name = QLabel(dim_info['name'])
self.units = QLabel(dim_info['units'])
self.x = QPushButton('X')
self.x.setFixedSize(32,32)
self.x.setCheckable(True)
self.x.clicked.connect(self.x_clicked)
self.y = QPushButton('Y')
self.y.setFixedSize(32,32)
self.y.setCheckable(True)
self.y.clicked.connect(self.y_clicked)
self.slider = QSlider(Qt.Horizontal)
self.slider.setRange(0, self.nbins-1)
self.slider.valueChanged.connect(self.slider_changed)
self.spinbox = QDoubleSpinBox()
self.spinbox.setDecimals(3)
self.spinbox.setRange(self.get_bin_center(0), self.get_bin_center(self.nbins-1))
self.spinbox.setSingleStep(self.width)
self.spinbox.valueChanged.connect(self.spinbox_changed)
self.layout.addWidget(self.name)
self.layout.addWidget(self.x)
self.layout.addWidget(self.y)
self.layout.addWidget(self.slider, stretch=1)
self.layout.addStretch(0)
self.layout.addWidget(self.spinbox)
self.layout.addWidget(self.units)
self.set_value(0)
if self.nbins < 2:
state = State.DISABLE
self.set_state(state)
def set_state(self, state):
self.state = state
if self.state == State.X:
self.x.setChecked(True)
self.y.setChecked(False)
self.slider.hide()
self.spinbox.hide()
self.units.hide()
elif self.state == State.Y:
self.x.setChecked(False)
self.y.setChecked(True)
self.slider.hide()
self.spinbox.hide()
self.units.hide()
elif self.state == State.NONE:
self.x.setChecked(False)
self.y.setChecked(False)
self.slider.show()
self.spinbox.show()
self.units.show()
else:
self.x.setChecked(False)
self.x.setDisabled(True)
self.y.setChecked(False)
self.y.setDisabled(True)
self.slider.hide()
self.spinbox.show()
self.spinbox.setDisabled(True)
self.units.show()
def get_state(self):
return self.state
def x_clicked(self):
old_state = self.state
self.set_state(State.X)
if self.state != old_state:
self.stateChanged.emit(self.number)
def y_clicked(self):
old_state = self.state
self.set_state(State.Y)
if self.state != old_state:
self.stateChanged.emit(self.number)
def spinbox_changed(self):
self.value = self.spinbox.value()
self.update_slider()
self.valueChanged.emit()
def slider_changed(self):
self.value = self.get_bin_center(self.slider.value())
self.update_spinbox()
self.valueChanged.emit()
def get_bin_center(self, n):
return (n+0.5)*self.width+self.minimum
def update_slider(self):
i = (self.value-self.minimum)/self.width
self.slider.setValue(int(min(max(i, 0), self.nbins-1)))
def update_spinbox(self):
self.spinbox.setValue(self.value)
def set_value(self, value):
self.value = value
self.update_slider()
self.update_spinbox()
def get_value(self):
return self.value
class OffsetsDialog(QDialog):
def __init__(self, parent=None):
super(OffsetsDialog, self).__init__(parent=parent)
self.info = Info()
self.log = Log
axis_list = self.info.getAxisList()
self.axis_combo = QComboBox()
for axis in axis_list:
self.axis_combo.addItem(axis.upper(), axis)
coords_msg = QLabel("Coordinate relative to workpiece:")
system_msg = QLabel("Coordinate System:")
self.coords_input = QDoubleSpinBox()
self.coords_input.setRange(-999999, 999999)
self.system_combo = QComboBox()
coord_systems = {
"P0": "P0 Current",
"P1": "P1 G54",
"P2": "P2 G55",
"P3": "P3 G56",
"P4": "P4 G57",
"P5": "P5 G58",
"P6": "P6 G59",
"P7": "P7 G59.1",
"P8": "P8 G59.1",
"P9": "P9 G59.3"
}
for key, value in OrderedDict(
sorted(coord_systems.items(), key=lambda t: t[0])).items():
self.system_combo.addItem(value, key)
close_button = QPushButton("Close")
set_button = QPushButton("Set")
main_layout = QVBoxLayout()
button_layout = QHBoxLayout()
button_layout.addWidget(close_button)
button_layout.addWidget(set_button)
main_layout.addWidget(self.axis_combo, alignment=Qt.AlignTop)
main_layout.addWidget(coords_msg, alignment=Qt.AlignLeft | Qt.AlignTop)
main_layout.addWidget(self.coords_input, alignment=Qt.AlignTop)
main_layout.addWidget(system_msg, alignment=Qt.AlignLeft | Qt.AlignTop)
main_layout.addWidget(self.system_combo, alignment=Qt.AlignBottom)
main_layout.addLayout(button_layout)
self.setLayout(main_layout)
self.setWindowTitle("Regular Offsets")
set_button.clicked.connect(self.set_method)
close_button.clicked.connect(self.close_method)
self.setWindowFlags(Qt.Popup)
def set_method(self):
system = self.system_combo.currentData()
axis = self.axis_combo.currentData()
coords = self.coords_input.text()
offset_mdi = "G10 L20 {} {}{}".format(system, axis, coords)
if issue_mdi.ok():
issue_mdi(offset_mdi)
else:
self.log.debug("Error issuing MDI: {}".format(issue_mdi.ok.msg))
def close_method(self):
self.hide()
class HighlightWindow(PyDialog):
"""
+-----------+
| Highlight |
+--------------------------+
| Nodes ______ |
| Elements ______ |
| |
| Highlight Close |
+--------------------------+
"""
def __init__(self, data, win_parent=None):
"""
Saves the data members from data and
performs type checks
"""
PyDialog.__init__(self, data, win_parent)
gui = win_parent
if gui is None: # pragma: no cover
self.highlight_color_float = [0., 0., 0.]
self.highlight_color_int = [0, 0, 0]
self._highlight_opacity = 0.9
else:
self.highlight_color_float = gui.settings.highlight_color
self.highlight_color_int = [int(val) for val in self.highlight_color_float]
#self.highlight_color_int = gui.settings.highlight_color_int
self._highlight_opacity = gui.settings.highlight_opacity
self._updated_highlight = False
self.actors = []
self._default_font_size = data['font_size']
self.model_name = data['model_name']
assert len(self.model_name) > 0, self.model_name
#self._default_annotation_size = data['annotation_size'] # int
#self.default_magnify = data['magnify']
if 'nodes_pound' in data: # testing
nodes_pound = data['nodes_pound']
elements_pound = data['elements_pound']
nodes = np.arange(1, nodes_pound+1)
elements = np.arange(1, elements_pound+1)
else:
# gui
nodes = gui.get_node_ids(model_name=self.model_name)
elements = gui.get_element_ids(model_name=self.model_name)
nodes_pound = nodes.max()
elements_pound = elements.max()
self.nodes = nodes
self.elements = elements
self._nodes_pound = nodes_pound
self._elements_pound = elements_pound
self.setWindowTitle('Highlight')
self.create_widgets()
self.create_layout()
self.set_connections()
self.on_font(self._default_font_size)
#self.show()
def create_widgets(self):
"""creates the display window"""
# Text Size
model_name = self.model_name
self.nodes_label = QLabel("Nodes:")
self.nodes_edit = QNodeEdit(self, model_name, pick_style='area', tab_to_next=False)
self.elements_label = QLabel("Elements:")
self.elements_edit = QElementEdit(self, model_name, pick_style='area', tab_to_next=False)
#-----------------------------------------------------------------------
# Highlight Color
self.highlight_opacity_label = QLabel("Highlight Opacity:")
self.highlight_opacity_edit = QDoubleSpinBox(self)
self.highlight_opacity_edit.setValue(self._highlight_opacity)
self.highlight_opacity_edit.setRange(0.1, 1.0)
self.highlight_opacity_edit.setDecimals(1)
self.highlight_opacity_edit.setSingleStep(0.1)
self.highlight_opacity_button = QPushButton("Default")
# Text Color
self.highlight_color_label = QLabel("Highlight Color:")
self.highlight_color_edit = QPushButtonColor(self.highlight_color_int)
#-----------------------------------------------------------------------
# closing
self.show_button = QPushButton("Show")
self.clear_button = QPushButton("Clear")
self.close_button = QPushButton("Close")
def create_layout(self):
"""displays the menu objects"""
grid = QGridLayout()
irow = 0
grid.addWidget(self.nodes_label, irow, 0)
grid.addWidget(self.nodes_edit, irow, 1)
irow += 1
grid.addWidget(self.elements_label, irow, 0)
grid.addWidget(self.elements_edit, irow, 1)
irow += 1
grid.addWidget(self.highlight_color_label, irow, 0)
grid.addWidget(self.highlight_color_edit, irow, 1)
self.highlight_color_label.setVisible(False)
self.highlight_color_edit.setVisible(False)
irow += 1
grid.addWidget(self.highlight_opacity_label, irow, 0)
grid.addWidget(self.highlight_opacity_edit, irow, 1)
self.highlight_opacity_label.setVisible(False)
self.highlight_opacity_edit.setVisible(False)
irow += 1
#self.create_legend_widgets()
#grid2 = self.create_legend_layout()
ok_cancel_box = QHBoxLayout()
ok_cancel_box.addWidget(self.show_button)
ok_cancel_box.addWidget(self.clear_button)
ok_cancel_box.addWidget(self.close_button)
vbox = QVBoxLayout()
vbox.addLayout(grid)
#vbox.addStretch()
#vbox.addLayout(grid2)
vbox.addStretch()
vbox.addLayout(ok_cancel_box)
self.setLayout(vbox)
def set_connections(self):
"""creates the actions for the menu"""
self.highlight_color_edit.clicked.connect(self.on_highlight_color)
self.highlight_opacity_edit.valueChanged.connect(self.on_highlight_opacity)
self.nodes_edit.textChanged.connect(self.on_validate)
self.elements_edit.textChanged.connect(self.on_validate)
self.show_button.clicked.connect(self.on_show)
self.clear_button.clicked.connect(self.on_remove_actors)
self.close_button.clicked.connect(self.on_close)
# closeEvent
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 on_highlight_color(self):
"""
Choose a highlight color
TODO: not implemented
"""
title = "Choose a highlight color"
rgb_color_ints = self.highlight_color_int
color_edit = self.highlight_color_edit
func_name = 'set_highlight_color'
passed, rgb_color_ints, rgb_color_floats = self._background_color(
title, color_edit, rgb_color_ints, func_name)
if passed:
self.highlight_color_int = rgb_color_ints
self.highlight_color_float = rgb_color_floats
def on_highlight_opacity(self, value=None):
"""
update the highlight opacity
TODO: not implemented
"""
if value is None:
value = self.highlight_opacity_edit.value()
self._highlight_opacity = value
if self.win_parent is not None:
self.win_parent.settings.set_highlight_opacity(value)
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:
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):
"""makes sure that all attributes are valid before doing any actions"""
unused_nodes, flag1 = check_patran_syntax(self.nodes_edit, pound=self._nodes_pound)
unused_elements, flag2 = check_patran_syntax(self.elements_edit, pound=self._elements_pound)
if all([flag1, flag2]):
self.out_data['clicked_ok'] = True
return True
return False
def on_show(self):
"""show the highlight"""
passed = self.on_validate()
self.parent().mouse_actions.get_grid_selected(self.model_name)
if passed and self.win_parent is not None:
nodes, unused_flag1 = check_patran_syntax(self.nodes_edit, pound=self._nodes_pound)
elements, unused_flag2 = check_patran_syntax(
self.elements_edit, pound=self._elements_pound)
if len(nodes) == 0 and len(elements) == 0:
return False
nodes_filtered = np.intersect1d(self.nodes, nodes)
elements_filtered = np.intersect1d(self.elements, elements)
nnodes = len(nodes_filtered)
nelements = len(elements_filtered)
if nnodes == 0 and nelements == 0:
return False
self.on_remove_actors()
gui = self.parent()
mouse_actions = gui.mouse_actions
grid = mouse_actions.get_grid_selected(self.model_name)
actors = create_highlighted_actors(
gui, grid,
all_nodes=self.nodes, nodes=nodes_filtered,
all_elements=self.elements, elements=elements_filtered)
if actors:
add_actors_to_gui(gui, actors, render=True)
self.actors = actors
return passed
def on_remove_actors(self):
"""removes multiple vtk actors"""
gui = self.parent()
if gui is not None:
remove_actors_from_gui(gui, self.actors, render=True)
self.actors = []
def on_close(self):
"""close the window"""
self.on_remove_actors()
self.out_data['close'] = True
self.close()
