def generateCustomDataSeriesWidgets(self, ps, groupName):
"""Overrides :meth:`.PlotControlPanel.generateDataSeriesWidgets`.
Adds some widgets for controlling :class:`.PowerSpectrumSeries`
instances.
"""
widgetList = self.getWidgetList()
allWidgets = []
varNorm = props.makeWidget(widgetList, ps, 'varNorm')
widgetList.AddWidget(varNorm,
displayName=strings.properties[ps, 'varNorm'],
tooltip=strings.properties[ps, 'varNorm'],
groupName=groupName)
allWidgets.append(varNorm)
if isinstance(ps, powerspectrumseries.ComplexPowerSpectrumSeries):
for propName in ['zeroOrderPhaseCorrection',
'firstOrderPhaseCorrection',
'plotReal', 'plotImaginary',
'plotMagnitude', 'plotPhase']:
widg = props.makeWidget(widgetList, ps, propName)
widgetList.AddWidget(
widg,
displayName=strings.properties[ps, propName],
tooltip=fsltooltips.properties[ps, propName],
groupName=groupName)
allWidgets.append(widg)
return allWidgets
def __init__(self, lutPanel, lut, label):
"""Create a ``LabelWidget``.
:arg lutPanel: The :class:`LookupTablePanel` that is displaying this
``LabelWidget``.
:arg lut: The :class:`.LookupTable` currently being displayed.
:arg label: The :class:`.LutLabel` that this ``LabelWidget`` is
associated with.
"""
wx.Panel.__init__(self, lutPanel)
self.__lutPanel = lutPanel
self.__lut = lut
self.__label = label
self.__name = props.makeWidget(self, label, 'name')
self.__enable = props.makeWidget(self, label, 'enabled')
self.__colour = props.makeWidget(self, label, 'colour')
self.__sizer = wx.BoxSizer(wx.HORIZONTAL)
self.SetSizer(self.__sizer)
self.__sizer.Add(self.__enable, flag=wx.ALIGN_CENTRE)
self.__sizer.Add(self.__colour, flag=wx.ALIGN_CENTRE)
self.__sizer.Add(self.__name, flag=wx.EXPAND)
def _test_widget_boolean(parent):
trueicon = op.join(datadir, 'true.png')
falseicon = op.join(datadir, 'false.png')
obj = MyObj()
# ch
myboolcb = props.makeWidget(parent, obj, 'mybool')
mybooltog = props.makeWidget(parent,
obj,
'mybool',
icon=[trueicon, falseicon])
myboolrad = props.makeWidget(parent,
obj,
'mybool',
icon=[trueicon, falseicon],
toggle=False)
assert isinstance(myboolcb, wx.CheckBox)
assert isinstance(mybooltog, bmptoggle.BitmapToggleButton)
assert isinstance(myboolrad, bmpradio.BitmapRadioBox)
addall(parent, (myboolcb, mybooltog, myboolrad))
obj.mybool = False
assert not myboolcb.GetValue()
assert not mybooltog.GetValue()
assert myboolrad.GetSelection() == 1
obj.mybool = True
assert myboolcb.GetValue()
assert mybooltog.GetValue()
assert myboolrad.GetSelection() == 0
myboolcb.SetValue(False)
wx.PostEvent(myboolcb, wx.CommandEvent(wx.EVT_CHECKBOX.evtType[0]))
realYield()
assert not obj.mybool
assert not myboolcb.GetValue()
assert not mybooltog.GetValue()
assert myboolrad.GetSelection() == 1
myboolcb.SetValue(True)
wx.PostEvent(myboolcb, wx.CommandEvent(wx.EVT_CHECKBOX.evtType[0]))
realYield()
assert obj.mybool
assert myboolcb.GetValue()
assert mybooltog.GetValue()
assert myboolrad.GetSelection() == 0
def _test_widget_point(parent):
sim = wx.UIActionSimulator()
obj = MyObj()
obj.mypointi.setLimits(0, 0, 100)
obj.mypointi.setLimits(1, 0, 100)
obj.mypointf.setLimits(0, 0, 100)
obj.mypointf.setLimits(1, 0, 100)
obj.mypointi.x = 25
obj.mypointi.y = 75
obj.mypointf.x = 20
obj.mypointf.y = 80
mypointi = props.makeWidget(parent, obj, 'mypointi', showLimits=False)
mypointf = props.makeWidget(parent, obj, 'mypointf', showLimits=False)
xi, yi = mypointi.GetChildren()
xf, yf = mypointf.GetChildren()
for s in [xi, yi, xf, yf]:
assert isinstance(s, floatslider.SliderSpinPanel)
assert xi.GetValue() == 25
assert yi.GetValue() == 75
assert xf.GetValue() == 20
assert yf.GetValue() == 80
addall(parent, [mypointi, mypointf])
tests = [
(xi, 'mypointi', 'x'),
(yi, 'mypointi', 'y'),
(xf, 'mypointf', 'x'),
(yf, 'mypointf', 'y')]
for widget, prop, att in tests:
val = np.random.randint(0, 100)
setattr(getattr(obj, prop), att, val)
realYield(2)
assert np.isclose(widget.GetValue(), val)
val = np.random.randint(0, 100)
simclick(sim, widget.slider, pos=(val / 100.0, 0.5))
assert abs(getattr(getattr(obj, prop), att) - val) < 10
def _test_widget_boolean(parent):
trueicon = op.join(datadir, 'true.png')
falseicon = op.join(datadir, 'false.png')
sim = wx.UIActionSimulator()
obj = MyObj()
# ch
myboolcb = props.makeWidget(parent, obj, 'mybool')
mybooltog = props.makeWidget(parent,
obj,
'mybool',
icon=[trueicon, falseicon])
myboolrad = props.makeWidget(parent,
obj,
'mybool',
icon=[trueicon, falseicon],
toggle=False)
assert isinstance(myboolcb, wx.CheckBox)
assert isinstance(mybooltog, bmptoggle.BitmapToggleButton)
assert isinstance(myboolrad, bmpradio.BitmapRadioBox)
addall(parent, (myboolcb, mybooltog, myboolrad))
obj.mybool = False
assert not myboolcb.GetValue()
assert not mybooltog.GetValue()
assert myboolrad.GetSelection() == 1
obj.mybool = True
assert myboolcb.GetValue()
assert mybooltog.GetValue()
assert myboolrad.GetSelection() == 0
simclick(sim, myboolcb)
assert not obj.mybool
assert not myboolcb.GetValue()
assert not mybooltog.GetValue()
assert myboolrad.GetSelection() == 1
simclick(sim, mybooltog)
assert obj.mybool
assert myboolcb.GetValue()
assert mybooltog.GetValue()
assert myboolrad.GetSelection() == 0
def generateDataSeriesWidgets(self, ds, groupName):
"""Adds a collection of widgets to the given :class:`.WidgetList`,
allowing the properties of the given :class:`.DataSeries` instance
to be changed. This method may be overridden by sub-classes which
need to customise the list of widgets.
:arg ds: The :class:`.DataSeries` instance.
:arg groupName: The :class:`.WidgetList` group name.
:returns: A list of the widgets that were created, and should be
included in keyboard navigation (see
:meth:`.FSLeyesPanel.setNavOrder`).
"""
widgetList = self.getWidgetList()
colour = props.makeWidget(widgetList, ds, 'colour')
alpha = props.makeWidget(widgetList, ds, 'alpha',
showLimits=False, spin=False)
lineWidth = props.makeWidget(widgetList, ds, 'lineWidth')
lineStyle = props.makeWidget(
widgetList,
ds,
'lineStyle',
labels=strings.choices[ds, 'lineStyle'])
widgetList.AddWidget(
colour,
displayName=strings.properties[ds, 'colour'],
tooltip=fsltooltips.properties[ds, 'colour'],
groupName=groupName)
widgetList.AddWidget(
alpha,
displayName=strings.properties[ds, 'alpha'],
tooltip=fsltooltips.properties[ds, 'alpha'],
groupName=groupName)
widgetList.AddWidget(
lineWidth,
displayName=strings.properties[ds, 'lineWidth'],
tooltip=fsltooltips.properties[ds, 'lineWidth'],
groupName=groupName)
widgetList.AddWidget(
lineStyle,
displayName=strings.properties[ds, 'lineStyle'],
tooltip=fsltooltips.properties[ds, 'lineStyle'],
groupName=groupName)
return [colour, alpha, lineWidth, lineStyle]
def generateCustomPlotPanelWidgets(self, groupName):
"""Overrides :meth:`.PlotControlPanel.generateCustomPlotPanelWidgets`.
Adds some widgets for controlling some properties of the
:class:`.TimeSeriesPanel`.
"""
widgetList = self.getWidgetList()
allWidgets = []
tsPanel = self.getPlotPanel()
tsProps = ['plotMode', 'usePixdim', 'plotMelodicICs']
for prop in tsProps:
kwargs = {}
if prop == 'plotMode':
kwargs['labels'] = strings.choices[tsPanel, 'plotMode']
widget = props.makeWidget(widgetList, tsPanel, prop, **kwargs)
allWidgets.append(widget)
widgetList.AddWidget(widget,
displayName=strings.properties[tsPanel, prop],
tooltip=fsltooltips.properties[tsPanel, prop],
groupName=groupName)
return allWidgets
def generateCustomPlotPanelWidgets(self, groupName):
"""Overrides :meth:`.PlotControlPanel.generateCustomPlotPanelWidgets`.
Adds some widgets to control properties of the
:class:`.HistogramPanel`.
"""
hsPanel = self.getPlotPanel()
widgetList = self.getWidgetList()
allWidgets = []
histProps = ['histType', 'plotType']
for prop in histProps:
kwargs = {}
kwargs['labels'] = strings.choices[hsPanel, prop]
widget = props.makeWidget(widgetList, hsPanel, prop, **kwargs)
allWidgets.append(widget)
widgetList.AddWidget(widget,
displayName=strings.properties[hsPanel, prop],
tooltip=fsltooltips.properties[hsPanel, prop],
groupName=groupName)
return allWidgets
def generateCustomPlotPanelWidgets(self, groupName):
"""Overrides :meth:`.PlotControlPanel.generateCustomPlotPanelWidgets`.
Adds some widgets for controlling the :class:`.PowerSpectrumPanel`.
"""
psPanel = self.getPlotPanel()
widgetList = self.getWidgetList()
allWidgets = []
psProps = ['plotFrequencies',
'plotMelodicICs']
for prop in psProps:
kwargs = {}
widget = props.makeWidget(widgetList, psPanel, prop, **kwargs)
allWidgets.append(widget)
widgetList.AddWidget(
widget,
displayName=strings.properties[psPanel, prop],
tooltip=fsltooltips.properties[psPanel, prop],
groupName=groupName)
return allWidgets
def _test_widget_number(parent):
obj = MyObj()
myinto = props.makeWidget(parent, obj, 'myinto')
myrealo = props.makeWidget(parent, obj, 'myrealo')
myintc = props.makeWidget(parent, obj, 'myintc')
myrealc = props.makeWidget(parent, obj, 'myrealc', slider=True, spin=False)
assert isinstance(myinto, floatspin.FloatSpinCtrl)
assert isinstance(myrealo, floatspin.FloatSpinCtrl)
assert isinstance(myintc, floatslider.SliderSpinPanel)
assert isinstance(myrealc, floatslider.FloatSlider)
addall(parent, [myinto, myrealo, myintc, myrealc])
obj.myinto = 50
obj.myrealo = 10
obj.myintc = 25
obj.myrealc = 0.5
assert myinto .GetValue() == 50
assert myrealo.GetValue() == 10
assert myintc .GetValue() == 25
assert np.isclose(myrealc.GetValue(), 0.5)
# I used to use wx.UIActionSimulator, but
# it is too flaky. So am now simulating
# user events by directly calling value
# setters/event handlers
myinto .textCtrl.SetValue('10')
myinto._FloatSpinCtrl__onText(None)
myrealo .textCtrl.SetValue('243.56')
myrealo._FloatSpinCtrl__onText(None)
myintc .spinCtrl.textCtrl.SetValue('99')
myintc .spinCtrl._FloatSpinCtrl__onText(None)
ev = MockMouseEvent(myrealc, (0.75, 0.5))
myrealc._FloatSlider__onMouseDown(ev)
myrealc._FloatSlider__onMouseUp( ev)
realYield()
assert obj.myinto == 10
assert np.isclose(obj.myrealo, 243.56)
assert obj.myintc == 99
assert abs(obj.myrealc - 0.75) <= 0.05
def _test_widget_number(parent):
sim = wx.UIActionSimulator()
obj = MyObj()
myinto = props.makeWidget(parent, obj, 'myinto')
myrealo = props.makeWidget(parent, obj, 'myrealo')
myintc = props.makeWidget(parent, obj, 'myintc')
myrealc = props.makeWidget(parent, obj, 'myrealc', slider=True, spin=False)
assert isinstance(myinto, floatspin.FloatSpinCtrl)
assert isinstance(myrealo, floatspin.FloatSpinCtrl)
assert isinstance(myintc, floatslider.SliderSpinPanel)
assert isinstance(myrealc, floatslider.FloatSlider)
addall(parent, [myinto, myrealo, myintc, myrealc])
obj.myinto = 50
obj.myrealo = 10
obj.myintc = 25
obj.myrealc = 0.5
assert myinto .GetValue() == 50
assert myrealo.GetValue() == 10
assert myintc .GetValue() == 25
assert np.isclose(myrealc.GetValue(), 0.5)
simtext( sim, myinto .textCtrl, '10')
simtext( sim, myrealo.textCtrl, '243.56')
simtext( sim, myintc.spinCtrl.textCtrl, '99')
simclick(sim, myrealc, pos=(0.75, 0.5))
assert obj.myinto == 10
assert np.isclose(obj.myrealo, 243.56)
assert obj.myintc == 99
assert abs(obj.myrealc - 0.75) <= 0.05
def __init__(self, parent, dataSeries):
"""Create a ``DataSeriesWidget``.
:arg parent: The :mod:`wx` parent object.
:arg dataSeries: The :class:`.DataSeries` instance.
"""
wx.Panel.__init__(self, parent)
self.__enabled = props.makeWidget(self, dataSeries, 'enabled')
self.__colour = props.makeWidget(self, dataSeries, 'colour')
self.__lineWidth = props.makeWidget(self, dataSeries, 'lineWidth')
self.__lineStyle = props.makeWidget(
self,
dataSeries,
'lineStyle',
labels=strings.choices['DataSeries.lineStyle'])
self.__enabled.SetToolTip(
wx.ToolTip(fsltooltips.properties[dataSeries, 'enabled']))
self.__colour.SetToolTip(
wx.ToolTip(fsltooltips.properties[dataSeries, 'colour']))
self.__lineWidth.SetToolTip(
wx.ToolTip(fsltooltips.properties[dataSeries, 'lineWidth']))
self.__lineStyle.SetToolTip(
wx.ToolTip(fsltooltips.properties[dataSeries, 'lineStyle']))
self.__sizer = wx.BoxSizer(wx.HORIZONTAL)
self.SetSizer(self.__sizer)
self.__sizer.Add(self.__enabled)
self.__sizer.Add(self.__colour)
self.__sizer.Add(self.__lineWidth)
self.__sizer.Add(self.__lineStyle)
self.Layout()
def generateDataSeriesWidgets(self, ps, groupName):
"""Overrides :meth:`.PlotControlPanel.generateDataSeriesWidgets`.
Adds some widgets for controlling :class:`.PowerSpectrumSeries`
instances.
"""
allWidgets = plotcontrol.PlotControlPanel.generateDataSeriesWidgets(
self, ps, groupName)
if not isinstance(ps, powerspectrumseries.PowerSpectrumSeries):
return
widgetList = self.getWidgetList()
varNorm = props.makeWidget(widgetList, ps, 'varNorm')
widgetList.AddWidget(varNorm,
displayName=strings.properties[ps, 'varNorm'],
tooltip=strings.properties[ps, 'varNorm'],
groupName=groupName)
return allWidgets + [varNorm]
def __generateComplexWidgets(self, ts, groupName):
"""Called by :meth:`generateCustomDataSeriesWidgets`. Generates
widgets for :class:`.ComplexTimeSeries` options, and adds them
to the widget list.
"""
widgetList = self.getWidgetList()
allWidgets = []
if isinstance(ts, timeseries.ComplexTimeSeries):
for propName in [
'plotReal', 'plotImaginary', 'plotMagnitude', 'plotPhase'
]:
widg = props.makeWidget(widgetList, ts, propName)
widgetList.AddWidget(widg,
displayName=strings.properties[ts,
propName],
tooltip=fsltooltips.properties[ts,
propName],
groupName=groupName)
allWidgets.append(widg)
return allWidgets
def generateCustomDataSeriesWidgets(self, hs, groupName):
"""Overrides :meth:`.PlotControlPanel.generateCustomDataSeriesWidgets`.
Adds some widgets to control properties of the
:class:`.HistogramSeries`.
"""
isimage = isinstance(hs, hseries.ImageHistogramSeries)
widgetList = self.getWidgetList()
allWidgets = []
autoBin = props.Widget('autoBin')
nbins = props.Widget('nbins',
enabledWhen=lambda i: not i.autoBin,
showLimits=False)
autoBin = props.buildGUI(widgetList, hs, autoBin)
nbins = props.buildGUI(widgetList, hs, nbins)
dataRange = props.makeWidget(
widgetList,
hs,
'dataRange',
labels=[
strings.choices['HistogramPanel.dataRange.min'],
strings.choices['HistogramPanel.dataRange.max']
],
showLimits=False)
ignoreZeros = props.makeWidget(widgetList, hs, 'ignoreZeros')
includeOutliers = props.makeWidget(widgetList, hs, 'includeOutliers')
widgetList.AddWidget(ignoreZeros,
groupName=groupName,
displayName=strings.properties[hs, 'ignoreZeros'],
tooltip=fsltooltips.properties[hs, 'ignoreZeros'])
allWidgets.append(ignoreZeros)
if isimage:
showOverlay = props.makeWidget(widgetList, hs, 'showOverlay')
widgetList.AddWidget(showOverlay,
groupName=groupName,
displayName=strings.properties[hs,
'showOverlay'],
tooltip=fsltooltips.properties[hs,
'showOverlay'])
allWidgets.append(showOverlay)
widgetList.AddWidget(includeOutliers,
groupName=groupName,
displayName=strings.properties[hs,
'includeOutliers'],
tooltip=fsltooltips.properties[hs,
'includeOutliers'])
widgetList.AddWidget(autoBin,
groupName=groupName,
displayName=strings.properties[hs, 'autoBin'],
tooltip=fsltooltips.properties[hs, 'autoBin'])
widgetList.AddWidget(nbins,
groupName=groupName,
displayName=strings.properties[hs, 'nbins'],
tooltip=fsltooltips.properties[hs, 'nbins'])
widgetList.AddWidget(dataRange,
groupName=groupName,
displayName=strings.properties[hs, 'dataRange'],
tooltip=fsltooltips.properties[hs, 'dataRange'])
allWidgets.append(includeOutliers)
allWidgets.append(autoBin)
allWidgets.append(nbins)
allWidgets.append(dataRange)
if isinstance(hs, hseries.ComplexHistogramSeries):
for propName in [
'plotReal', 'plotImaginary', 'plotMagnitude', 'plotPhase'
]:
widget = props.makeWidget(widgetList, hs, propName)
widgetList.AddWidget(widget,
groupName=groupName,
displayName=strings.properties[hs,
propName],
tooltip=fsltooltips.properties[hs,
propName])
allWidgets.append(widget)
return allWidgets
def generateCustomDataSeriesWidgets(self, hs, groupName):
"""Overrides :meth:`.PlotControlPanel.generateCustomDataSeriesWidgets`.
Adds some widgets to control properties of the
:class:`.HistogramSeries`.
"""
isimage = isinstance(hs, hseries.ImageHistogramSeries)
widgetList = self.getWidgetList()
autoBin = props.Widget('autoBin')
nbins = props.Widget('nbins',
enabledWhen=lambda i: not i.autoBin,
showLimits=False)
autoBin = props.buildGUI(widgetList, hs, autoBin)
nbins = props.buildGUI(widgetList, hs, nbins)
dataRange = props.makeWidget(
widgetList,
hs,
'dataRange',
labels=[
strings.choices['HistogramPanel.dataRange.min'],
strings.choices['HistogramPanel.dataRange.max']
],
showLimits=False)
ignoreZeros = props.makeWidget(widgetList, hs, 'ignoreZeros')
includeOutliers = props.makeWidget(widgetList, hs, 'includeOutliers')
if isimage:
showOverlay = props.makeWidget(widgetList, hs, 'showOverlay')
widgetList.AddWidget(ignoreZeros,
groupName=groupName,
displayName=strings.properties[hs, 'ignoreZeros'],
tooltip=fsltooltips.properties[hs, 'ignoreZeros'])
if isimage:
widgetList.AddWidget(showOverlay,
groupName=groupName,
displayName=strings.properties[hs,
'showOverlay'],
tooltip=fsltooltips.properties[hs,
'showOverlay'])
widgetList.AddWidget(includeOutliers,
groupName=groupName,
displayName=strings.properties[hs,
'includeOutliers'],
tooltip=fsltooltips.properties[hs,
'includeOutliers'])
widgetList.AddWidget(autoBin,
groupName=groupName,
displayName=strings.properties[hs, 'autoBin'],
tooltip=fsltooltips.properties[hs, 'autoBin'])
widgetList.AddWidget(nbins,
groupName=groupName,
displayName=strings.properties[hs, 'nbins'],
tooltip=fsltooltips.properties[hs, 'nbins'])
widgetList.AddWidget(dataRange,
groupName=groupName,
displayName=strings.properties[hs, 'dataRange'],
tooltip=fsltooltips.properties[hs, 'dataRange'])
if isimage:
return [
ignoreZeros, showOverlay, includeOutliers, autoBin, nbins,
dataRange
]
else:
return [ignoreZeros, includeOutliers, autoBin, nbins, dataRange]
def __generateFeatWidgets(self, ts, groupName):
"""Called by :meth:`generateCustomDataSeriesWidgets`. Generates
widgets for :class:`.FEATTimeSeries` options, and adds them
to the widget list.
"""
overlay = ts.overlay
widgetList = self.getWidgetList()
allWidgets = []
full = props.makeWidget(widgetList, ts, 'plotFullModelFit')
res = props.makeWidget(widgetList, ts, 'plotResiduals')
evs = props.makeListWidgets(widgetList, ts, 'plotEVs')
pes = props.makeListWidgets(widgetList, ts, 'plotPEFits')
copes = props.makeListWidgets(widgetList, ts, 'plotCOPEFits')
partial = props.makeWidget(widgetList, ts, 'plotPartial')
data = props.makeWidget(widgetList, ts, 'plotData')
allWidgets.append(full)
allWidgets.append(res)
allWidgets.extend(evs)
allWidgets.extend(pes)
allWidgets.extend(copes)
allWidgets.append(partial)
allWidgets.append(data)
widgetList.AddWidget(data,
displayName=strings.properties[ts, 'plotData'],
tooltip=fsltooltips.properties[ts, 'plotData'],
groupName=groupName)
widgetList.AddWidget(
full,
displayName=strings.properties[ts, 'plotFullModelFit'],
tooltip=fsltooltips.properties[ts, 'plotFullModelFit'],
groupName=groupName)
widgetList.AddWidget(res,
displayName=strings.properties[ts,
'plotResiduals'],
tooltip=fsltooltips.properties[ts,
'plotResiduals'],
groupName=groupName)
widgetList.AddWidget(partial,
displayName=strings.properties[ts, 'plotPartial'],
tooltip=fsltooltips.properties[ts, 'plotPartial'],
groupName=groupName)
widgetList.AddSpace(groupName=groupName)
for i, ev in enumerate(evs):
evName = overlay.evNames()[i]
widgetList.AddWidget(
ev,
displayName=strings.properties[ts, 'plotEVs'].format(
i + 1, evName),
tooltip=fsltooltips.properties[ts, 'plotEVs'],
groupName=groupName)
widgetList.AddSpace(groupName=groupName)
for i, pe in enumerate(pes):
evName = overlay.evNames()[i]
widgetList.AddWidget(
pe,
displayName=strings.properties[ts, 'plotPEFits'].format(
i + 1, evName),
tooltip=fsltooltips.properties[ts, 'plotPEFits'],
groupName=groupName)
widgetList.AddSpace(groupName=groupName)
copeNames = overlay.contrastNames()
for i, (cope, name) in enumerate(zip(copes, copeNames)):
widgetList.AddWidget(
cope,
displayName=strings.properties[ts, 'plotCOPEFits'].format(
i + 1, name),
tooltip=fsltooltips.properties[ts, 'plotCOPEFits'],
groupName=groupName)
return allWidgets
def __init__(self, parent, overlayList, displayCtx, frame, ortho):
"""Create a ``CropImagePanel``.
:arg parent: The :mod:`wx` parent object.
:arg overlayList: The :class:`.OverlayList` instance.
:arg displayCtx: The :class:`.DisplayContext` instance.
:arg frame: The :class:`.FSLeyesFrame` instance.
:arg ortho: The :class:`.OrthoPanel` instance.
"""
ctrlpanel.ControlPanel.__init__(
self, parent, overlayList, displayCtx, frame)
profile = ortho.getCurrentProfile()
self.__ortho = ortho
self.__profile = profile
self.__overlay = None
self.__cropBoxWidget = props.makeWidget(
self,
profile,
'cropBox',
showLimits=False,
labels=['xmin', 'xmax', 'ymin', 'ymax', 'zmin', 'zmax'])
self.__volumeWidget = rslider.RangeSliderSpinPanel(
self,
minValue=0,
maxValue=1,
minDistance=1,
lowLabel='tmin',
highLabel='tmax',
style=rslider.RSSP_INTEGER)
self.__dsWarning = dswarning.DisplaySpaceWarning(
self,
overlayList,
displayCtx,
frame,
strings.messages[self, 'dsWarning'],
'not like overlay',
'overlay')
self.__cropLabel = wx.StaticText(self)
self.__sizeLabel = wx.StaticText(self)
self.__cropButton = wx.Button( self, id=wx.ID_OK)
self.__robustFovButton = wx.Button( self)
self.__loadButton = wx.Button( self)
self.__saveButton = wx.Button( self)
self.__cancelButton = wx.Button( self, id=wx.ID_CANCEL)
self.__cropButton .SetLabel(strings.labels[self, 'crop'])
self.__robustFovButton.SetLabel(strings.labels[self, 'robustFov'])
self.__loadButton .SetLabel(strings.labels[self, 'load'])
self.__saveButton .SetLabel(strings.labels[self, 'save'])
self.__cancelButton .SetLabel(strings.labels[self, 'cancel'])
self.__sizer = wx.BoxSizer(wx.VERTICAL)
self.__btnSizer = wx.BoxSizer(wx.HORIZONTAL)
self.__sizer.Add((1, 10))
self.__sizer.Add(self.__cropLabel, flag=wx.CENTRE)
self.__sizer.Add((1, 10))
self.__sizer.Add(self.__dsWarning, flag=wx.CENTRE)
self.__sizer.Add((1, 10), proportion=1)
self.__sizer.Add(self.__cropBoxWidget, flag=wx.EXPAND)
self.__sizer.Add(self.__volumeWidget, flag=wx.EXPAND)
self.__sizer.Add((1, 10))
self.__sizer.Add(self.__sizeLabel, flag=wx.CENTRE, proportion=1)
self.__sizer.Add((1, 10))
self.__sizer.Add(self.__btnSizer, flag=wx.CENTRE)
self.__sizer.Add((1, 10))
self.__btnSizer.Add((10, 1), flag=wx.EXPAND,
proportion=1)
self.__btnSizer.Add(self.__cropButton, flag=wx.EXPAND)
self.__btnSizer.Add((10, 1), flag=wx.EXPAND)
self.__btnSizer.Add(self.__robustFovButton, flag=wx.EXPAND)
self.__btnSizer.Add((10, 1), flag=wx.EXPAND)
self.__btnSizer.Add(self.__loadButton, flag=wx.EXPAND)
self.__btnSizer.Add((10, 1), flag=wx.EXPAND)
self.__btnSizer.Add(self.__saveButton, flag=wx.EXPAND)
self.__btnSizer.Add((10, 1), flag=wx.EXPAND)
self.__btnSizer.Add(self.__cancelButton, flag=wx.EXPAND)
self.__btnSizer.Add((10, 1), flag=wx.EXPAND,
proportion=1)
self.SetSizer(self.__sizer)
self.SetMinSize(self.__sizer.GetMinSize())
self.__cropButton.SetDefault()
self.__cropButton .Bind(wx.EVT_BUTTON, self.__onCrop)
self.__loadButton .Bind(wx.EVT_BUTTON, self.__onLoad)
self.__saveButton .Bind(wx.EVT_BUTTON, self.__onSave)
self.__cancelButton.Bind(wx.EVT_BUTTON, self.__onCancel)
self.__volumeWidget.Bind(rslider.EVT_RANGE, self.__onVolume)
self.__volumeWidget.Bind(rslider.EVT_LOW_RANGE, self.__onVolume)
self.__volumeWidget.Bind(rslider.EVT_HIGH_RANGE, self.__onVolume)
profile.robustfov.bindToWidget(self,
wx.EVT_BUTTON,
self.__robustFovButton)
displayCtx .addListener('selectedOverlay',
self.name,
self.__selectedOverlayChanged)
overlayList.addListener('overlays',
self.name,
self.__selectedOverlayChanged)
profile .addListener('cropBox',
self.name,
self.__cropBoxChanged)
self.__selectedOverlayChanged()
self.__cropBoxChanged()
def generatePlotPanelWidgets(self, groupName):
"""Adds a collection of widgets to the given :class:`.WidgetList`,
allowing the properties of the given :class:`.PlotPanel` instance
to be changed.
This method may be overridden by sub-classes to change/add to the
list of properties that are added by default.
:arg groupName: The :class:`.WidgetList` group name.
:returns: A list of the widgets that were created, and should be
included in keyboard navigation (see
:meth:`.FSLeyesPanel.setNavOrder`).
"""
widgetList = self.getWidgetList()
plotPanel = self.__plotPanel
allWidgets = []
plotProps = [
'smooth', 'legend', 'ticks', 'grid', 'gridColour', 'bgColour'
]
for prop in plotProps:
widget = props.makeWidget(widgetList, plotPanel, prop)
allWidgets.append(widget)
widgetList.AddWidget(widget,
displayName=strings.properties[plotPanel,
prop],
tooltip=fsltooltips.properties[plotPanel,
prop],
groupName=groupName)
limits = props.makeListWidgets(widgetList, plotPanel, 'limits')
xlogscale = props.makeWidget(widgetList, plotPanel, 'xLogScale')
ylogscale = props.makeWidget(widgetList, plotPanel, 'yLogScale')
xinvert = props.makeWidget(widgetList, plotPanel, 'invertX')
yinvert = props.makeWidget(widgetList, plotPanel, 'invertY')
xscale = props.makeWidget(widgetList, plotPanel, 'xScale')
yscale = props.makeWidget(widgetList, plotPanel, 'yScale')
xoffset = props.makeWidget(widgetList, plotPanel, 'xOffset')
yoffset = props.makeWidget(widgetList, plotPanel, 'yOffset')
xautoscale = props.makeWidget(widgetList, plotPanel, 'xAutoScale')
yautoscale = props.makeWidget(widgetList, plotPanel, 'yAutoScale')
xlabel = props.makeWidget(widgetList, plotPanel, 'xlabel')
ylabel = props.makeWidget(widgetList, plotPanel, 'ylabel')
allWidgets.extend(limits)
allWidgets.extend([
xlogscale, ylogscale, xinvert, yinvert, xautoscale, yautoscale,
xscale, yscale, xoffset, yoffset, xlabel, ylabel
])
pairs = [('logscale', xlogscale, ylogscale),
('invert', xinvert, yinvert),
('autoscale', xautoscale, yautoscale),
('scale', xscale, yscale), ('offset', xoffset, yoffset),
('labels', xlabel, ylabel)]
for key, xwidget, ywidget in pairs:
sizer = wx.BoxSizer(wx.HORIZONTAL)
sizer.Add(
wx.StaticText(widgetList, label=strings.labels[self,
'xlabel']))
sizer.Add(xwidget, flag=wx.EXPAND, proportion=1)
sizer.Add(
wx.StaticText(widgetList, label=strings.labels[self,
'ylabel']))
sizer.Add(ywidget, flag=wx.EXPAND, proportion=1)
widgetList.AddWidget(sizer,
displayName=strings.labels[self, key],
tooltip=fsltooltips.misc[self, key],
groupName=groupName)
# Store refs to the limit widgets
# so they can be enabled/disabled
# when xAutoScale/yAutoScale
# changes.
self.__xLimitWidgets = [limits[0], limits[1]]
self.__yLimitWidgets = [limits[2], limits[3]]
xlims = wx.BoxSizer(wx.HORIZONTAL)
ylims = wx.BoxSizer(wx.HORIZONTAL)
xlims.Add(limits[0], flag=wx.EXPAND, proportion=1)
xlims.Add(limits[1], flag=wx.EXPAND, proportion=1)
ylims.Add(limits[2], flag=wx.EXPAND, proportion=1)
ylims.Add(limits[3], flag=wx.EXPAND, proportion=1)
widgetList.AddWidget(xlims,
displayName=strings.labels[self, 'xlim'],
tooltip=fsltooltips.misc[self, 'xlim'],
groupName=groupName)
widgetList.AddWidget(ylims,
displayName=strings.labels[self, 'ylim'],
tooltip=fsltooltips.misc[self, 'ylim'],
groupName=groupName)
return allWidgets
def generateCustomDataSeriesWidgets(self, ts, groupName):
"""Overrides :meth:`.PlotControlPanel.generateCustomDataSeriesWidgets`.
If the given :class:`.TimeSeries` is a :class:`.FEATTimeSeries`
instance, this method adds some widgets for controlling the
FEAT-related settings of the instance.
"""
overlay = ts.overlay
widgetList = self.getWidgetList()
allWidgets = []
if not (isinstance(overlay, fslfeatimage.FEATImage) and isinstance(
ts, timeseries.FEATTimeSeries) and overlay.hasStats()):
return allWidgets
full = props.makeWidget(widgetList, ts, 'plotFullModelFit')
res = props.makeWidget(widgetList, ts, 'plotResiduals')
evs = props.makeListWidgets(widgetList, ts, 'plotEVs')
pes = props.makeListWidgets(widgetList, ts, 'plotPEFits')
copes = props.makeListWidgets(widgetList, ts, 'plotCOPEFits')
partial = props.makeWidget(widgetList, ts, 'plotPartial')
data = props.makeWidget(widgetList, ts, 'plotData')
allWidgets.append(full)
allWidgets.append(res)
allWidgets.extend(evs)
allWidgets.extend(pes)
allWidgets.extend(copes)
allWidgets.append(partial)
allWidgets.append(data)
widgetList.AddWidget(data,
displayName=strings.properties[ts, 'plotData'],
tooltip=fsltooltips.properties[ts, 'plotData'],
groupName=groupName)
widgetList.AddWidget(
full,
displayName=strings.properties[ts, 'plotFullModelFit'],
tooltip=fsltooltips.properties[ts, 'plotFullModelFit'],
groupName=groupName)
widgetList.AddWidget(res,
displayName=strings.properties[ts,
'plotResiduals'],
tooltip=fsltooltips.properties[ts,
'plotResiduals'],
groupName=groupName)
widgetList.AddWidget(partial,
displayName=strings.properties[ts, 'plotPartial'],
tooltip=fsltooltips.properties[ts, 'plotPartial'],
groupName=groupName)
widgetList.AddSpace(groupName=groupName)
for i, ev in enumerate(evs):
evName = overlay.evNames()[i]
widgetList.AddWidget(
ev,
displayName=strings.properties[ts, 'plotEVs'].format(
i + 1, evName),
tooltip=fsltooltips.properties[ts, 'plotEVs'],
groupName=groupName)
widgetList.AddSpace(groupName=groupName)
for i, pe in enumerate(pes):
evName = overlay.evNames()[i]
widgetList.AddWidget(
pe,
displayName=strings.properties[ts, 'plotPEFits'].format(
i + 1, evName),
tooltip=fsltooltips.properties[ts, 'plotPEFits'],
groupName=groupName)
widgetList.AddSpace(groupName=groupName)
copeNames = overlay.contrastNames()
for i, (cope, name) in enumerate(zip(copes, copeNames)):
widgetList.AddWidget(
cope,
displayName=strings.properties[ts, 'plotCOPEFits'].format(
i + 1, name),
tooltip=fsltooltips.properties[ts, 'plotCOPEFits'],
groupName=groupName)
return allWidgets
