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 SliderSpinBox(QWidget):
valueChanged = Signal(float)
def __init__(self, parent=None, value_range=(0, 100), slider_steps=100, spinbox_steps=1000, decimals=None):
QWidget.__init__(self, parent)
layout = QHBoxLayout(self)
self.setLayout(layout)
self.horizontalSlider = QSlider(Qt.Horizontal, self)
self.doubleSpinBox = QDoubleSpinBox(self)
self.decimals = decimals
layout.setMargin(0)
layout.addWidget(self.doubleSpinBox)
layout.addWidget(self.horizontalSlider)
self.doubleSpinBox.valueChanged.connect(self.spinbox_changed)
self.horizontalSlider.valueChanged.connect(self.slider_changed)
self.wt = []
self.changer = None
self.slider_steps = slider_steps
self.horizontalSlider.setMaximum(slider_steps)
self.spinbox_steps = spinbox_steps
self.set_range(value_range)
def set_value(self, value):
self.doubleSpinBox.setValue(value)
value = property(lambda self: self.doubleSpinBox.value(), set_value)
def set_range(self, value_range):
self.changer = "set_range"
spinbox_step_decimal = np.ceil(np.log10(1. / (float(value_range[1] - value_range[0]) / self.spinbox_steps)))
self.slider_decimals = int(np.ceil(np.log10(self.slider_steps) - np.log10(value_range[1] - value_range[0])))
if self.decimals is None:
self.doubleSpinBox.setDecimals(spinbox_step_decimal + 1)
else:
self.doubleSpinBox.setDecimals(self.decimals)
spinbox_step_decimal = min(self.decimals, spinbox_step_decimal)
self.slider_decimals = min(self.decimals, self.slider_decimals)
self.doubleSpinBox.setSingleStep(10 ** -spinbox_step_decimal)
self.value_range = value_range
self.doubleSpinBox.setMinimum(value_range[0])
self.doubleSpinBox.setMaximum(value_range[1])
self.horizontalSlider.setValue(np.floor(value_range[0]))
self.changer = None
self.doubleSpinBox.setValue(value_range[0])
def range(self):
return self.doubleSpinBox.minimum(), self.doubleSpinBox.maximum()
def slider_changed(self, value):
if self.changer is None:
self.changer = 'slider'
value = np.round(value * (self.value_range[1] - self.value_range[0]) / self.slider_steps + self.value_range[0], self.slider_decimals)
self.doubleSpinBox.setValue(value)
self.changer = None
self.value_changed(value)
def spinbox_changed(self, value):
if self.changer is None:
self.changer = 'spinbox'
slider_value = .5 + (value - self.value_range[0]) * self.slider_steps / (self.value_range[1] - self.value_range[0])
self.horizontalSlider.setValue(slider_value)
self.changer = None
self.value_changed(value)
@postpone_until_last_call_finishes
def value_changed(self, value):
self.valueChanged.emit(value)
class EditBoundaryConditions(QDialog):
def __init__(self, data, win_parent=None):
"""
+---------+
| Painter |
+---------+---------+
| Name1 |
| Name2 |
| Name3 |
| Name4 |
| |
| x by cell ___ |
| x by angle ___ |
| |
| box elements |
| |
| Add Remove |
| |
| Apply OK Cancel |
+-------------------+
"""
QDialog.__init__(self, win_parent)
self.setWindowTitle('Edit Boundary Conditions')
#default
self.win_parent = win_parent
self.out_data = data
self.keys = sorted(data.keys())
keys = self.keys
nrows = len(keys)
self.active_key = keys[0]
self._use_old_table = False
items = keys
header_labels = ['Groups']
table_model = Model(items, header_labels, self)
view = SingleChoiceQTableView(self) #Call your custom QTableView here
view.setModel(table_model)
#view.horizontalHeader().setResizeMode(QtGui.QHeaderView.Stretch) #TODO: fixme
self.table = view
actor_obj = data[self.active_key]
name = actor_obj.name
line_width = actor_obj.line_width
point_size = actor_obj.point_size
opacity = actor_obj.opacity
color = actor_obj.color
show = actor_obj.is_visible
self.representation = actor_obj.representation
table = self.table
#headers = [QtCore.QString('Groups')]
header = table.horizontalHeader()
header.setStretchLastSection(True)
self._default_is_apply = False
self.name = QLabel("Name:")
self.name_edit = QLineEdit(str(name))
self.name_edit.setDisabled(True)
self.color = QLabel("Color:")
self.color_edit = QPushButton()
#self.color_edit.setFlat(True)
color = self.out_data[self.active_key].color
qcolor = QtGui.QColor()
qcolor.setRgb(*color)
#print('color =%s' % str(color))
palette = QtGui.QPalette(
self.color_edit.palette()) # make a copy of the palette
#palette.setColor(QtGui.QPalette.Active, QtGui.QPalette.Base, \
#qcolor)
palette.setColor(QtGui.QPalette.Background,
QtGui.QColor('blue')) # ButtonText
self.color_edit.setPalette(palette)
self.color_edit.setStyleSheet("QPushButton {"
"background-color: rgb(%s, %s, %s);" %
tuple(color) +
#"border:1px solid rgb(255, 170, 255); "
"}")
self.opacity = QLabel('Opacity:')
self.opacity_edit = QDoubleSpinBox(self)
self.opacity_edit.setRange(0.1, 1.0)
self.opacity_edit.setDecimals(1)
self.opacity_edit.setSingleStep(0.1)
self.opacity_edit.setValue(opacity)
self.line_width = QLabel('Line Width:')
self.line_width_edit = QSpinBox(self)
self.line_width_edit.setRange(1, 10)
self.line_width_edit.setSingleStep(1)
self.line_width_edit.setValue(line_width)
if self.representation in ['point', 'surface']:
self.line_width.setEnabled(False)
self.line_width_edit.setEnabled(False)
self.point_size = QLabel('Point Size:')
self.point_size_edit = QSpinBox(self)
self.point_size_edit.setRange(1, 10)
self.point_size_edit.setSingleStep(1)
self.point_size_edit.setValue(point_size)
if self.representation in ['wire', 'surface']:
self.point_size.setEnabled(False)
self.point_size_edit.setEnabled(False)
# show/hide
self.checkbox_show = QCheckBox("Show")
self.checkbox_hide = QCheckBox("Hide")
self.checkbox_show.setChecked(show)
self.checkbox_hide.setChecked(not show)
# closing
self.apply_button = QPushButton("Apply")
#if self._default_is_apply:
#self.apply_button.setDisabled(True)
self.ok_button = QPushButton("OK")
self.cancel_button = QPushButton("Cancel")
self.create_layout()
self.set_connections()
def update_active_key(self, index):
old_obj = self.out_data[self.active_key]
old_obj.line_width = self.line_width_edit.value()
old_obj.point_size = self.point_size_edit.value()
old_obj.opacity = self.opacity_edit.value()
old_obj.is_visible = self.checkbox_show.isChecked()
name = index.data()
#i = self.keys.index(self.active_key)
self.active_key = name
self.name_edit.setText(name)
obj = self.out_data[name]
line_width = obj.line_width
point_size = obj.point_size
opacity = obj.opacity
representation = obj.representation
is_visible = obj.is_visible
self.color_edit.setStyleSheet("QPushButton {"
"background-color: rgb(%s, %s, %s);" %
tuple(obj.color) +
#"border:1px solid rgb(255, 170, 255); "
"}")
self.line_width_edit.setValue(line_width)
self.point_size_edit.setValue(point_size)
if self.representation != representation:
self.representation = representation
if self.representation == 'point':
self.point_size.setEnabled(True)
self.point_size_edit.setEnabled(True)
else:
self.point_size.setEnabled(False)
self.point_size_edit.setEnabled(False)
if self.representation == ['wire']:
self.line_width.setEnabled(True)
self.line_width_edit.setEnabled(True)
else:
self.line_width.setEnabled(False)
self.line_width_edit.setEnabled(False)
#if self.representation in ['wire', 'surface']:
self.opacity_edit.setValue(opacity)
self.checkbox_show.setChecked(is_visible)
self.checkbox_hide.setChecked(not is_visible)
#def on_name_select(self):
#print('on_name_select')
#return
def create_layout(self):
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)
grid = QGridLayout()
irow = 0
grid.addWidget(self.name, irow, 0)
grid.addWidget(self.name_edit, irow, 1)
irow += 1
grid.addWidget(self.color, irow, 0)
grid.addWidget(self.color_edit, irow, 1)
irow += 1
grid.addWidget(self.opacity, irow, 0)
grid.addWidget(self.opacity_edit, irow, 1)
irow += 1
grid.addWidget(self.line_width, irow, 0)
grid.addWidget(self.line_width_edit, irow, 1)
irow += 1
grid.addWidget(self.point_size, irow, 0)
grid.addWidget(self.point_size_edit, irow, 1)
irow += 1
checkboxs = QButtonGroup(self)
checkboxs.addButton(self.checkbox_show)
checkboxs.addButton(self.checkbox_hide)
vbox = QVBoxLayout()
vbox.addWidget(self.table)
vbox.addLayout(grid)
if 0:
vbox.addWidget(self.checkbox_show)
vbox.addWidget(self.checkbox_hide)
else:
vbox1 = QVBoxLayout()
vbox1.addWidget(self.checkbox_show)
vbox1.addWidget(self.checkbox_hide)
vbox.addLayout(vbox1)
vbox.addStretch()
#vbox.addWidget(self.check_apply)
vbox.addLayout(ok_cancel_box)
self.setLayout(vbox)
def set_connections(self):
"""creates the actions for the menu"""
self.opacity_edit.valueChanged.connect(self.on_opacity) # clicked?
self.line_width_edit.valueChanged.connect(
self.on_line_width) # clicked?
self.point_size_edit.valueChanged.connect(
self.on_point_size) # clicked?
self.color_edit.clicked.connect(self.on_color)
self.checkbox_show.clicked.connect(self.on_show)
self.checkbox_hide.clicked.connect(self.on_hide)
#self.opacity_edit.clicked.connect(self.on_opacity)
#self.connect(self.opacity_edit, QtCore.SIGNAL('clicked()'), self.on_opacity)
#self.connect(self.line_width, QtCore.SIGNAL('clicked()'), self.on_line_width)
#self.connect(self.point_size, QtCore.SIGNAL('clicked()'), self.on_point_size)
#self.connect(self.color_edit, QtCore.SIGNAL('clicked()'), self.on_color)
#self.connect(self.checkbox_show, QtCore.SIGNAL('clicked()'), self.on_show)
#self.connect(self.checkbox_hide, QtCore.SIGNAL('clicked()'), self.on_hide)
#self.connect(self.check_apply, QtCore.SIGNAL('clicked()'), self.on_check_apply)
self.apply_button.clicked.connect(self.on_apply)
self.ok_button.clicked.connect(self.on_ok)
self.cancel_button.clicked.connect(self.on_cancel)
#self.connect(self.apply_button, QtCore.SIGNAL('clicked()'), self.on_apply)
#self.connect(self.ok_button, QtCore.SIGNAL('clicked()'), self.on_ok)
#self.connect(self.cancel_button, QtCore.SIGNAL('clicked()'), self.on_cancel)
#self.connect(self, QtCore.SIGNAL('triggered()'), self.closeEvent)
def keyPressEvent(self, event):
if event.key() == QtCore.Qt.Key_Escape:
self.close()
def closeEvent(self, event):
self.out_data['close'] = True
event.accept()
def on_color(self):
name = self.active_key
obj = self.out_data[name]
rgb_color_ints = obj.color
msg = name
col = QColorDialog.getColor(QtGui.QColor(*rgb_color_ints), self,
"Choose a %s color" % msg)
if col.isValid():
color = col.getRgbF()[:3]
obj.color = color
#print('new_color =', color)
self.color_edit.setStyleSheet(
"QPushButton {"
"background-color: rgb(%s, %s, %s);" % tuple(obj.color) +
#"border:1px solid rgb(255, 170, 255); "
"}")
def on_show(self):
name = self.active_key
is_checked = self.checkbox_show.isChecked()
self.out_data[name].is_visible = is_checked
def on_hide(self):
name = self.active_key
is_checked = self.checkbox_hide.isChecked()
self.out_data[name].is_visible = not is_checked
def on_line_width(self):
name = self.active_key
line_width = self.line_width_edit.value()
self.out_data[name].line_width = line_width
def on_point_size(self):
name = self.active_key
point_size = self.point_size_edit.value()
self.out_data[name].point_size = point_size
def on_opacity(self):
name = self.active_key
opacity = self.opacity_edit.value()
self.out_data[name].opacity = opacity
#def on_axis(self, text):
##print(self.combo_axis.itemText())
#self._axis = str(text)
#self.plane.setText('Point on %s? Plane:' % self._axis)
#self.point_a.setText('Point on %s Axis:' % self._axis)
#self.point_b.setText('Point on %s%s Plane:' % (self._axis, self._plane))
#def on_plane(self, text):
#self._plane = str(text)
#self.point_b.setText('Point on %s%s Plane:' % (self._axis, self._plane))
def on_check_apply(self):
is_checked = self.check_apply.isChecked()
self.apply_button.setDisabled(is_checked)
def _on_float(self, field):
try:
eval_float_from_string(field.text())
field.setStyleSheet("QLineEdit{background: white;}")
except ValueError:
field.setStyleSheet("QLineEdit{background: red;}")
#def on_default_name(self):
#self.name_edit.setText(str(self._default_name))
#self.name_edit.setStyleSheet("QLineEdit{background: white;}")
#def check_name(self, cell):
#text = str(cell.text()).strip()
#if len(text):
#cell.setStyleSheet("QLineEdit{background: white;}")
#return text, True
#else:
#cell.setStyleSheet("QLineEdit{background: red;}")
#return None, False
def on_validate(self):
self.out_data['clicked_ok'] = True
self.out_data['clicked_cancel'] = False
old_obj = self.out_data[self.active_key]
old_obj.line_width = self.line_width_edit.value()
old_obj.point_size = self.point_size_edit.value()
old_obj.opacity = self.opacity_edit.value()
old_obj.is_visible = self.checkbox_show.isChecked()
return True
#name_value, flag0 = self.check_name(self.name_edit)
#ox_value, flag1 = check_float(self.transparency_edit)
#if flag0 and flag1:
#self.out_data['clicked_ok'] = True
#return True
#return False
def on_apply(self):
passed = self.on_validate()
if passed:
self.win_parent.on_update_geometry_properties(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['clicked_ok'] = False
self.out_data['clicked_cancel'] = True
self.close()