class _BoundaryWidget(qt.QWidget):
"""Widget to edit a boundary of the colormap (vmin, vmax)"""
sigValueChanged = qt.Signal(object)
"""Signal emitted when value is changed"""
def __init__(self, parent=None, value=0.0):
qt.QWidget.__init__(self, parent=None)
self.setLayout(qt.QHBoxLayout())
self.layout().setContentsMargins(0, 0, 0, 0)
self._numVal = FloatEdit(parent=self, value=value)
self.layout().addWidget(self._numVal)
self._autoCB = qt.QCheckBox('auto', parent=self)
self.layout().addWidget(self._autoCB)
self._autoCB.setChecked(False)
self._autoCB.toggled.connect(self._autoToggled)
self.sigValueChanged = self._autoCB.toggled
self.textEdited = self._numVal.textEdited
self.editingFinished = self._numVal.editingFinished
self._dataValue = None
def isAutoChecked(self):
return self._autoCB.isChecked()
def getValue(self):
return None if self._autoCB.isChecked() else self._numVal.value()
def getFiniteValue(self):
if not self._autoCB.isChecked():
return self._numVal.value()
elif self._dataValue is None:
return self._numVal.value()
else:
return self._dataValue
def _autoToggled(self, enabled):
self._numVal.setEnabled(not enabled)
self._updateDisplayedText()
def _updateDisplayedText(self):
# if dataValue is finite
if self._autoCB.isChecked() and self._dataValue is not None:
old = self._numVal.blockSignals(True)
self._numVal.setValue(self._dataValue)
self._numVal.blockSignals(old)
def setDataValue(self, dataValue):
self._dataValue = dataValue
self._updateDisplayedText()
def setFiniteValue(self, value):
assert (value is not None)
old = self._numVal.blockSignals(True)
self._numVal.setValue(value)
self._numVal.blockSignals(old)
def setValue(self, value, isAuto=False):
self._autoCB.setChecked(isAuto or value is None)
if value is not None:
self._numVal.setValue(value)
self._updateDisplayedText()
class _AmplitudeRangeDialog(qt.QDialog):
"""QDialog asking for the amplitude range to display."""
sigRangeChanged = qt.Signal(tuple)
"""Signal emitted when the range has changed.
It provides the new range as a 2-tuple: (max, delta)
"""
def __init__(self,
parent=None,
amplitudeRange=None,
displayedRange=(None, 2)):
super(_AmplitudeRangeDialog, self).__init__(parent)
self.setWindowTitle('Set Displayed Amplitude Range')
if amplitudeRange is not None:
amplitudeRange = min(amplitudeRange), max(amplitudeRange)
self._amplitudeRange = amplitudeRange
self._defaultDisplayedRange = displayedRange
layout = qt.QFormLayout()
self.setLayout(layout)
if self._amplitudeRange is not None:
min_, max_ = self._amplitudeRange
layout.addRow(
qt.QLabel('Data Amplitude Range: [%g, %g]' % (min_, max_)))
self._maxLineEdit = FloatEdit(parent=self)
self._maxLineEdit.validator().setBottom(0.)
self._maxLineEdit.setAlignment(qt.Qt.AlignRight)
self._maxLineEdit.editingFinished.connect(self._rangeUpdated)
layout.addRow('Displayed Max.:', self._maxLineEdit)
self._autoscale = qt.QCheckBox('autoscale')
self._autoscale.toggled.connect(self._autoscaleCheckBoxToggled)
layout.addRow('', self._autoscale)
self._deltaLineEdit = FloatEdit(parent=self)
self._deltaLineEdit.validator().setBottom(1.)
self._deltaLineEdit.setAlignment(qt.Qt.AlignRight)
self._deltaLineEdit.editingFinished.connect(self._rangeUpdated)
layout.addRow('Displayed delta (log10 unit):', self._deltaLineEdit)
buttons = qt.QDialogButtonBox(self)
buttons.addButton(qt.QDialogButtonBox.Ok)
buttons.addButton(qt.QDialogButtonBox.Cancel)
buttons.accepted.connect(self.accept)
buttons.rejected.connect(self.reject)
layout.addRow(buttons)
# Set dialog from default values
self._resetDialogToDefault()
self.rejected.connect(self._handleRejected)
def _resetDialogToDefault(self):
"""Set Widgets of the dialog from range information
"""
max_, delta = self._defaultDisplayedRange
if max_ is not None: # Not in autoscale
displayedMax = max_
elif self._amplitudeRange is not None: # Autoscale with data
displayedMax = self._amplitudeRange[1]
else: # Autoscale without data
displayedMax = ''
if displayedMax == "":
self._maxLineEdit.setText("")
else:
self._maxLineEdit.setValue(displayedMax)
self._maxLineEdit.setEnabled(max_ is not None)
self._deltaLineEdit.setValue(delta)
self._autoscale.setChecked(self._defaultDisplayedRange[0] is None)
def getRangeInfo(self):
"""Returns the current range as a 2-tuple (max, delta (in log10))"""
if self._autoscale.isChecked():
max_ = None
else:
maxStr = self._maxLineEdit.text()
max_ = self._maxLineEdit.value() if maxStr else None
return max_, self._deltaLineEdit.value() if self._deltaLineEdit.text() else 2
def _handleRejected(self):
"""Reset range info to default when rejected"""
self._resetDialogToDefault()
self._rangeUpdated()
def _rangeUpdated(self):
"""Handle QLineEdit editing finised"""
self.sigRangeChanged.emit(self.getRangeInfo())
def _autoscaleCheckBoxToggled(self, checked):
"""Handle autoscale checkbox state changes"""
if checked: # Use default values
if self._amplitudeRange is None:
max_ = ''
else:
max_ = self._amplitudeRange[1]
if max_ == "":
self._maxLineEdit.setText("")
else:
self._maxLineEdit.setValue(max_)
self._maxLineEdit.setEnabled(not checked)
self._rangeUpdated()
class ColormapDialog(qt.QDialog):
"""A QDialog widget to set the colormap.
:param parent: See :class:`QDialog`
:param str title: The QDialog title
"""
sigColormapChanged = qt.Signal(Colormap)
"""Signal triggered when the colormap is changed.
It provides a dict describing the colormap to the slot.
This dict can be used with :class:`Plot`.
"""
def __init__(self, parent=None, title="Colormap Dialog"):
qt.QDialog.__init__(self, parent)
self.setWindowTitle(title)
self._histogramData = None
self._dataRange = None
self._minMaxWasEdited = False
colormaps = [
'gray', 'reversed gray', 'temperature', 'red', 'green', 'blue',
'jet', 'viridis', 'magma', 'inferno', 'plasma'
]
if 'hsv' in Colormap.getSupportedColormaps():
colormaps.append('hsv')
self._colormapList = tuple(colormaps)
# Make the GUI
vLayout = qt.QVBoxLayout(self)
formWidget = qt.QWidget()
vLayout.addWidget(formWidget)
formLayout = qt.QFormLayout(formWidget)
formLayout.setContentsMargins(10, 10, 10, 10)
formLayout.setSpacing(0)
# Colormap row
self._comboBoxColormap = qt.QComboBox()
for cmap in self._colormapList:
# Capitalize first letters
cmap = ' '.join(w[0].upper() + w[1:] for w in cmap.split())
self._comboBoxColormap.addItem(cmap)
self._comboBoxColormap.activated[int].connect(self._notify)
formLayout.addRow('Colormap:', self._comboBoxColormap)
# Normalization row
self._normButtonLinear = qt.QRadioButton('Linear')
self._normButtonLinear.setChecked(True)
self._normButtonLog = qt.QRadioButton('Log')
normButtonGroup = qt.QButtonGroup(self)
normButtonGroup.setExclusive(True)
normButtonGroup.addButton(self._normButtonLinear)
normButtonGroup.addButton(self._normButtonLog)
normButtonGroup.buttonClicked[int].connect(self._notify)
normLayout = qt.QHBoxLayout()
normLayout.setContentsMargins(0, 0, 0, 0)
normLayout.setSpacing(10)
normLayout.addWidget(self._normButtonLinear)
normLayout.addWidget(self._normButtonLog)
formLayout.addRow('Normalization:', normLayout)
# Range row
self._rangeAutoscaleButton = qt.QCheckBox('Autoscale')
self._rangeAutoscaleButton.setChecked(True)
self._rangeAutoscaleButton.toggled.connect(self._autoscaleToggled)
self._rangeAutoscaleButton.clicked.connect(self._notify)
formLayout.addRow('Range:', self._rangeAutoscaleButton)
# Min row
self._minValue = FloatEdit(parent=self, value=1.)
self._minValue.setEnabled(False)
self._minValue.textEdited.connect(self._minMaxTextEdited)
self._minValue.editingFinished.connect(self._minEditingFinished)
formLayout.addRow('\tMin:', self._minValue)
# Max row
self._maxValue = FloatEdit(parent=self, value=10.)
self._maxValue.setEnabled(False)
self._maxValue.textEdited.connect(self._minMaxTextEdited)
self._maxValue.editingFinished.connect(self._maxEditingFinished)
formLayout.addRow('\tMax:', self._maxValue)
# Add plot for histogram
self._plotInit()
vLayout.addWidget(self._plot)
# Close button
buttonsWidget = qt.QWidget()
vLayout.addWidget(buttonsWidget)
buttonsLayout = qt.QHBoxLayout(buttonsWidget)
okButton = qt.QPushButton('OK')
okButton.clicked.connect(self.accept)
buttonsLayout.addWidget(okButton)
cancelButton = qt.QPushButton('Cancel')
cancelButton.clicked.connect(self.reject)
buttonsLayout.addWidget(cancelButton)
# colormap window can not be resized
self.setFixedSize(vLayout.minimumSize())
# Set the colormap to default values
self.setColormap(name='gray',
normalization='linear',
autoscale=True,
vmin=1.,
vmax=10.)
def _plotInit(self):
"""Init the plot to display the range and the values"""
self._plot = PlotWidget()
self._plot.setDataMargins(yMinMargin=0.125, yMaxMargin=0.125)
self._plot.getXAxis().setLabel("Data Values")
self._plot.getYAxis().setLabel("")
self._plot.setInteractiveMode('select', zoomOnWheel=False)
self._plot.setActiveCurveHandling(False)
self._plot.setMinimumSize(qt.QSize(250, 200))
self._plot.sigPlotSignal.connect(self._plotSlot)
self._plot.hide()
self._plotUpdate()
def _plotUpdate(self, updateMarkers=True):
"""Update the plot content
:param bool updateMarkers: True to update markers, False otherwith
"""
dataRange = self.getDataRange()
if dataRange is None:
if self._plot.isVisibleTo(self):
self._plot.setVisible(False)
self.setFixedSize(self.layout().minimumSize())
return
if not self._plot.isVisibleTo(self):
self._plot.setVisible(True)
self.setFixedSize(self.layout().minimumSize())
dataMin, dataMax = dataRange
marge = (abs(dataMax) + abs(dataMin)) / 6.0
minmd = dataMin - marge
maxpd = dataMax + marge
start, end = self._minValue.value(), self._maxValue.value()
if start <= end:
x = [minmd, start, end, maxpd]
y = [0, 0, 1, 1]
else:
x = [minmd, end, start, maxpd]
y = [1, 1, 0, 0]
# Display the colormap on the side
# colormap = {'name': self.getColormap()['name'],
# 'normalization': self.getColormap()['normalization'],
# 'autoscale': True, 'vmin': 1., 'vmax': 256.}
# self._plot.addImage((1 + numpy.arange(256)).reshape(256, -1),
# xScale=(minmd - marge, marge),
# yScale=(1., 2./256.),
# legend='colormap',
# colormap=colormap)
self._plot.addCurve(x,
y,
legend="ConstrainedCurve",
color='black',
symbol='o',
linestyle='-',
resetzoom=False)
draggable = not self._rangeAutoscaleButton.isChecked()
if updateMarkers:
self._plot.addXMarker(self._minValue.value(),
legend='Min',
text='Min',
draggable=draggable,
color='blue',
constraint=self._plotMinMarkerConstraint)
self._plot.addXMarker(self._maxValue.value(),
legend='Max',
text='Max',
draggable=draggable,
color='blue',
constraint=self._plotMaxMarkerConstraint)
self._plot.resetZoom()
def _plotMinMarkerConstraint(self, x, y):
"""Constraint of the min marker"""
return min(x, self._maxValue.value()), y
def _plotMaxMarkerConstraint(self, x, y):
"""Constraint of the max marker"""
return max(x, self._minValue.value()), y
def _plotSlot(self, event):
"""Handle events from the plot"""
if event['event'] in ('markerMoving', 'markerMoved'):
value = float(str(event['xdata']))
if event['label'] == 'Min':
self._minValue.setValue(value)
elif event['label'] == 'Max':
self._maxValue.setValue(value)
# This will recreate the markers while interacting...
# It might break if marker interaction is changed
if event['event'] == 'markerMoved':
self._notify()
else:
self._plotUpdate(updateMarkers=False)
def getHistogram(self):
"""Returns the counts and bin edges of the displayed histogram.
:return: (hist, bin_edges)
:rtype: 2-tuple of numpy arrays"""
if self._histogramData is None:
return None
else:
bins, counts = self._histogramData
return numpy.array(bins, copy=True), numpy.array(counts, copy=True)
def setHistogram(self, hist=None, bin_edges=None):
"""Set the histogram to display.
This update the data range with the bounds of the bins.
See :meth:`setDataRange`.
:param hist: array-like of counts or None to hide histogram
:param bin_edges: array-like of bins edges or None to hide histogram
"""
if hist is None or bin_edges is None:
self._histogramData = None
self._plot.remove(legend='Histogram', kind='curve')
self.setDataRange() # Remove data range
else:
hist = numpy.array(hist, copy=True)
bin_edges = numpy.array(bin_edges, copy=True)
self._histogramData = hist, bin_edges
# For now, draw the histogram as a curve
# using bin centers and normalised counts
bins_center = 0.5 * (bin_edges[:-1] + bin_edges[1:])
norm_hist = hist / max(hist)
self._plot.addCurve(bins_center,
norm_hist,
legend="Histogram",
color='gray',
symbol='',
linestyle='-',
fill=True)
# Update the data range
self.setDataRange(bin_edges[0], bin_edges[-1])
def getDataRange(self):
"""Returns the data range used for the histogram area.
:return: (dataMin, dataMax) or None if no data range is set
:rtype: 2-tuple of float
"""
return self._dataRange
def setDataRange(self, min_=None, max_=None):
"""Set the range of data to use for the range of the histogram area.
:param float min_: The min of the data or None to disable range.
:param float max_: The max of the data or None to disable range.
"""
if min_ is None or max_ is None:
self._dataRange = None
self._plotUpdate()
else:
min_, max_ = float(min_), float(max_)
assert min_ <= max_
self._dataRange = min_, max_
if self._rangeAutoscaleButton.isChecked():
self._minValue.setValue(min_)
self._maxValue.setValue(max_)
self._notify()
else:
self._plotUpdate()
def getColormap(self):
"""Return the colormap description as a :class:`.Colormap`.
"""
isNormLinear = self._normButtonLinear.isChecked()
if self._rangeAutoscaleButton.isChecked():
vmin = None
vmax = None
else:
vmin = self._minValue.value()
vmax = self._maxValue.value()
norm = Colormap.LINEAR if isNormLinear else Colormap.LOGARITHM
colormap = Colormap(name=str(
self._comboBoxColormap.currentText()).lower(),
normalization=norm,
vmin=vmin,
vmax=vmax)
return colormap
def setColormap(self,
name=None,
normalization=None,
autoscale=None,
vmin=None,
vmax=None,
colors=None):
"""Set the colormap description
If some arguments are not provided, the current values are used.
:param str name: The name of the colormap
:param str normalization: 'linear' or 'log'
:param bool autoscale: Toggle colormap range autoscale
:param float vmin: The min value, ignored if autoscale is True
:param float vmax: The max value, ignored if autoscale is True
"""
if name is not None:
assert name in self._colormapList
index = self._colormapList.index(name)
self._comboBoxColormap.setCurrentIndex(index)
if normalization is not None:
assert normalization in Colormap.NORMALIZATIONS
self._normButtonLinear.setChecked(normalization == Colormap.LINEAR)
self._normButtonLog.setChecked(normalization == Colormap.LOGARITHM)
if vmin is not None:
self._minValue.setValue(vmin)
if vmax is not None:
self._maxValue.setValue(vmax)
if autoscale is not None:
self._rangeAutoscaleButton.setChecked(autoscale)
if autoscale:
dataRange = self.getDataRange()
if dataRange is not None:
self._minValue.setValue(dataRange[0])
self._maxValue.setValue(dataRange[1])
# Do it once for all the changes
self._notify()
def _notify(self, *args, **kwargs):
"""Emit the signal for colormap change"""
self._plotUpdate()
self.sigColormapChanged.emit(self.getColormap())
def _autoscaleToggled(self, checked):
"""Handle autoscale changes by enabling/disabling min/max fields"""
self._minValue.setEnabled(not checked)
self._maxValue.setEnabled(not checked)
if checked:
dataRange = self.getDataRange()
if dataRange is not None:
self._minValue.setValue(dataRange[0])
self._maxValue.setValue(dataRange[1])
def _minMaxTextEdited(self, text):
"""Handle _minValue and _maxValue textEdited signal"""
self._minMaxWasEdited = True
def _minEditingFinished(self):
"""Handle _minValue editingFinished signal
Together with :meth:`_minMaxTextEdited`, this avoids to notify
colormap change when the min and max value where not edited.
"""
if self._minMaxWasEdited:
self._minMaxWasEdited = False
# Fix start value
if self._minValue.value() > self._maxValue.value():
self._minValue.setValue(self._maxValue.value())
self._notify()
def _maxEditingFinished(self):
"""Handle _maxValue editingFinished signal
Together with :meth:`_minMaxTextEdited`, this avoids to notify
colormap change when the min and max value where not edited.
"""
if self._minMaxWasEdited:
self._minMaxWasEdited = False
# Fix end value
if self._minValue.value() > self._maxValue.value():
self._maxValue.setValue(self._minValue.value())
self._notify()
def keyPressEvent(self, event):
"""Override key handling.
It disables leaving the dialog when editing a text field.
"""
if event.key() == qt.Qt.Key_Enter and (self._minValue.hasFocus()
or self._maxValue.hasFocus()):
# Bypass QDialog keyPressEvent
# To avoid leaving the dialog when pressing enter on a text field
super(qt.QDialog, self).keyPressEvent(event)
else:
# Use QDialog keyPressEvent
super(ColormapDialog, self).keyPressEvent(event)
class LimitsToolBar(qt.QToolBar):
"""QToolBar displaying and controlling the limits of a :class:`PlotWidget`.
To run the following sample code, a QApplication must be initialized.
First, create a PlotWindow:
>>> from silx.gui.plot import PlotWindow
>>> plot = PlotWindow() # Create a PlotWindow to add the toolbar to
Then, create the LimitsToolBar and add it to the PlotWindow.
>>> from silx.gui import qt
>>> from silx.gui.plot.PlotTools import LimitsToolBar
>>> toolbar = LimitsToolBar(plot=plot) # Create the toolbar
>>> plot.addToolBar(qt.Qt.BottomToolBarArea, toolbar) # Add it to the plot
>>> plot.show() # To display the PlotWindow with the limits toolbar
:param parent: See :class:`QToolBar`.
:param plot: :class:`PlotWidget` instance on which to operate.
:param str title: See :class:`QToolBar`.
"""
def __init__(self, parent=None, plot=None, title='Limits'):
super(LimitsToolBar, self).__init__(title, parent)
assert plot is not None
self._plot = plot
self._plot.sigPlotSignal.connect(self._plotWidgetSlot)
self._initWidgets()
@property
def plot(self):
"""The :class:`PlotWidget` the toolbar is attached to."""
return self._plot
def _initWidgets(self):
"""Create and init Toolbar widgets."""
xMin, xMax = self.plot.getXAxis().getLimits()
yMin, yMax = self.plot.getYAxis().getLimits()
self.addWidget(qt.QLabel('Limits: '))
self.addWidget(qt.QLabel(' X: '))
self._xMinFloatEdit = FloatEdit(self, xMin)
self._xMinFloatEdit.editingFinished[()].connect(
self._xFloatEditChanged)
self.addWidget(self._xMinFloatEdit)
self._xMaxFloatEdit = FloatEdit(self, xMax)
self._xMaxFloatEdit.editingFinished[()].connect(
self._xFloatEditChanged)
self.addWidget(self._xMaxFloatEdit)
self.addWidget(qt.QLabel(' Y: '))
self._yMinFloatEdit = FloatEdit(self, yMin)
self._yMinFloatEdit.editingFinished[()].connect(
self._yFloatEditChanged)
self.addWidget(self._yMinFloatEdit)
self._yMaxFloatEdit = FloatEdit(self, yMax)
self._yMaxFloatEdit.editingFinished[()].connect(
self._yFloatEditChanged)
self.addWidget(self._yMaxFloatEdit)
def _plotWidgetSlot(self, event):
"""Listen to :class:`PlotWidget` events."""
if event['event'] not in ('limitsChanged', ):
return
xMin, xMax = self.plot.getXAxis().getLimits()
yMin, yMax = self.plot.getYAxis().getLimits()
self._xMinFloatEdit.setValue(xMin)
self._xMaxFloatEdit.setValue(xMax)
self._yMinFloatEdit.setValue(yMin)
self._yMaxFloatEdit.setValue(yMax)
def _xFloatEditChanged(self):
"""Handle X limits changed from the GUI."""
xMin, xMax = self._xMinFloatEdit.value(), self._xMaxFloatEdit.value()
if xMax < xMin:
xMin, xMax = xMax, xMin
self.plot.getXAxis().setLimits(xMin, xMax)
def _yFloatEditChanged(self):
"""Handle Y limits changed from the GUI."""
yMin, yMax = self._yMinFloatEdit.value(), self._yMaxFloatEdit.value()
if yMax < yMin:
yMin, yMax = yMax, yMin
self.plot.getYAxis().setLimits(yMin, yMax)
class _BoundaryWidget(qt.QWidget):
"""Widget to edit a boundary of the colormap (vmin, vmax)"""
sigValueChanged = qt.Signal(object)
"""Signal emitted when value is changed"""
def __init__(self, parent=None, value=0.0):
qt.QWidget.__init__(self, parent=None)
self.setLayout(qt.QHBoxLayout())
self.layout().setContentsMargins(0, 0, 0, 0)
self._numVal = FloatEdit(parent=self, value=value)
self.layout().addWidget(self._numVal)
self._autoCB = qt.QCheckBox('auto', parent=self)
self.layout().addWidget(self._autoCB)
self._autoCB.setChecked(False)
self._autoCB.toggled.connect(self._autoToggled)
self.sigValueChanged = self._autoCB.toggled
self.textEdited = self._numVal.textEdited
self.editingFinished = self._numVal.editingFinished
self._dataValue = None
def isAutoChecked(self):
return self._autoCB.isChecked()
def getValue(self):
return None if self._autoCB.isChecked() else self._numVal.value()
def getFiniteValue(self):
if not self._autoCB.isChecked():
return self._numVal.value()
elif self._dataValue is None:
return self._numVal.value()
else:
return self._dataValue
def _autoToggled(self, enabled):
self._numVal.setEnabled(not enabled)
self._updateDisplayedText()
def _updateDisplayedText(self):
# if dataValue is finite
if self._autoCB.isChecked() and self._dataValue is not None:
old = self._numVal.blockSignals(True)
self._numVal.setValue(self._dataValue)
self._numVal.blockSignals(old)
def setDataValue(self, dataValue):
self._dataValue = dataValue
self._updateDisplayedText()
def setFiniteValue(self, value):
assert(value is not None)
old = self._numVal.blockSignals(True)
self._numVal.setValue(value)
self._numVal.blockSignals(old)
def setValue(self, value, isAuto=False):
self._autoCB.setChecked(isAuto or value is None)
if value is not None:
self._numVal.setValue(value)
self._updateDisplayedText()
class _AmplitudeRangeDialog(qt.QDialog):
"""QDialog asking for the amplitude range to display."""
sigRangeChanged = qt.Signal(tuple)
"""Signal emitted when the range has changed.
It provides the new range as a 2-tuple: (max, delta)
"""
def __init__(self,
parent=None,
amplitudeRange=None,
displayedRange=(None, 2)):
super(_AmplitudeRangeDialog, self).__init__(parent)
self.setWindowTitle('Set Displayed Amplitude Range')
if amplitudeRange is not None:
amplitudeRange = min(amplitudeRange), max(amplitudeRange)
self._amplitudeRange = amplitudeRange
self._defaultDisplayedRange = displayedRange
layout = qt.QFormLayout()
self.setLayout(layout)
if self._amplitudeRange is not None:
min_, max_ = self._amplitudeRange
layout.addRow(
qt.QLabel('Data Amplitude Range: [%g, %g]' % (min_, max_)))
self._maxLineEdit = FloatEdit(parent=self)
self._maxLineEdit.validator().setBottom(0.)
self._maxLineEdit.setAlignment(qt.Qt.AlignRight)
self._maxLineEdit.editingFinished.connect(self._rangeUpdated)
layout.addRow('Displayed Max.:', self._maxLineEdit)
self._autoscale = qt.QCheckBox('autoscale')
self._autoscale.toggled.connect(self._autoscaleCheckBoxToggled)
layout.addRow('', self._autoscale)
self._deltaLineEdit = FloatEdit(parent=self)
self._deltaLineEdit.validator().setBottom(1.)
self._deltaLineEdit.setAlignment(qt.Qt.AlignRight)
self._deltaLineEdit.editingFinished.connect(self._rangeUpdated)
layout.addRow('Displayed delta (log10 unit):', self._deltaLineEdit)
buttons = qt.QDialogButtonBox(self)
buttons.addButton(qt.QDialogButtonBox.Ok)
buttons.addButton(qt.QDialogButtonBox.Cancel)
buttons.accepted.connect(self.accept)
buttons.rejected.connect(self.reject)
layout.addRow(buttons)
# Set dialog from default values
self._resetDialogToDefault()
self.rejected.connect(self._handleRejected)
def _resetDialogToDefault(self):
"""Set Widgets of the dialog from range information
"""
max_, delta = self._defaultDisplayedRange
if max_ is not None: # Not in autoscale
displayedMax = max_
elif self._amplitudeRange is not None: # Autoscale with data
displayedMax = self._amplitudeRange[1]
else: # Autoscale without data
displayedMax = ''
if displayedMax == "":
self._maxLineEdit.setText("")
else:
self._maxLineEdit.setValue(displayedMax)
self._maxLineEdit.setEnabled(max_ is not None)
self._deltaLineEdit.setValue(delta)
self._autoscale.setChecked(self._defaultDisplayedRange[0] is None)
def getRangeInfo(self):
"""Returns the current range as a 2-tuple (max, delta (in log10))"""
if self._autoscale.isChecked():
max_ = None
else:
maxStr = self._maxLineEdit.text()
max_ = self._maxLineEdit.value() if maxStr else None
return max_, self._deltaLineEdit.value() if self._deltaLineEdit.text() else 2
def _handleRejected(self):
"""Reset range info to default when rejected"""
self._resetDialogToDefault()
self._rangeUpdated()
def _rangeUpdated(self):
"""Handle QLineEdit editing finised"""
self.sigRangeChanged.emit(self.getRangeInfo())
def _autoscaleCheckBoxToggled(self, checked):
"""Handle autoscale checkbox state changes"""
if checked: # Use default values
if self._amplitudeRange is None:
max_ = ''
else:
max_ = self._amplitudeRange[1]
if max_ == "":
self._maxLineEdit.setText("")
else:
self._maxLineEdit.setValue(max_)
self._maxLineEdit.setEnabled(not checked)
self._rangeUpdated()