from . import BoolParameterItem, SimpleParameter
from .basetypes import GroupParameterItem, GroupParameter, WidgetParameterItem
from .list import ListParameter
from .slider import Emitter
from ..ParameterItem import ParameterItem
from ... import functions as fn
from ...Qt import QtWidgets
[docs]class ChecklistParameterItem(GroupParameterItem):
"""
Wraps a :class:`GroupParameterItem` to manage ``bool`` parameter children. Also provides convenience buttons to
select or clear all values at once. Note these conveniences are disabled when ``exclusive`` is *True*.
"""
def __init__(self, param, depth):
self.btnGrp = QtWidgets.QButtonGroup()
self.btnGrp.setExclusive(False)
self._constructMetaBtns()
super().__init__(param, depth)
def _constructMetaBtns(self):
self.metaBtnWidget = QtWidgets.QWidget()
self.metaBtnLayout = lay = QtWidgets.QHBoxLayout(self.metaBtnWidget)
lay.setContentsMargins(0, 0, 0, 0)
lay.setSpacing(2)
self.metaBtns = {}
lay.addStretch(0)
for title in 'Clear', 'Select':
self.metaBtns[title] = btn = QtWidgets.QPushButton(f'{title} All')
self.metaBtnLayout.addWidget(btn)
btn.clicked.connect(getattr(self, f'{title.lower()}AllClicked'))
self.metaBtns['default'] = WidgetParameterItem.makeDefaultButton(self)
self.metaBtnLayout.addWidget(self.metaBtns['default'])
def defaultClicked(self):
self.param.setToDefault()
def treeWidgetChanged(self):
ParameterItem.treeWidgetChanged(self)
tw = self.treeWidget()
if tw is None:
return
tw.setItemWidget(self, 1, self.metaBtnWidget)
def selectAllClicked(self):
self.param.setValue(self.param.reverse[0])
def clearAllClicked(self):
self.param.setValue([])
def insertChild(self, pos, item):
ret = super().insertChild(pos, item)
self.btnGrp.addButton(item.widget)
return ret
def addChild(self, item):
ret = super().addChild(item)
self.btnGrp.addButton(item.widget)
return ret
def takeChild(self, i):
child = super().takeChild(i)
self.btnGrp.removeButton(child.widget)
def optsChanged(self, param, opts):
if 'expanded' in opts:
for btn in self.metaBtns.values():
btn.setVisible(opts['expanded'])
exclusive = opts.get('exclusive', param.opts['exclusive'])
enabled = opts.get('enabled', param.opts['enabled'])
for btn in self.metaBtns.values():
btn.setDisabled(exclusive or (not enabled))
self.btnGrp.setExclusive(exclusive)
def expandedChangedEvent(self, expanded):
for btn in self.metaBtns.values():
btn.setVisible(expanded)
class RadioParameterItem(BoolParameterItem):
"""
Allows radio buttons to function as booleans when `exclusive` is *True*
"""
def __init__(self, param, depth):
self.emitter = Emitter()
super().__init__(param, depth)
def makeWidget(self):
w = QtWidgets.QRadioButton()
w.value = w.isChecked
# Since these are only used during exclusive operations, only fire a signal when "True"
# to avoid a double-fire
w.setValue = w.setChecked
w.sigChanged = self.emitter.sigChanged
w.toggled.connect(self.maybeSigChanged)
self.hideWidget = False
return w
def maybeSigChanged(self, val):
"""
Make sure to only activate on a "true" value, since an exclusive button group fires once to deactivate
the old option and once to activate the new selection
"""
if not val:
return
self.emitter.sigChanged.emit(self, val)
# Proxy around radio/bool type so the correct item class gets instantiated
class BoolOrRadioParameter(SimpleParameter):
def __init__(self, **kargs):
if kargs.get('type') == 'bool':
self.itemClass = BoolParameterItem
else:
self.itemClass = RadioParameterItem
super().__init__(**kargs)
[docs]class ChecklistParameter(GroupParameter):
"""
Can be set just like a :class:`ListParameter`, but allows for multiple values to be selected simultaneously.
============== ========================================================
**Options**
exclusive When *False*, any number of options can be selected. The resulting ``value()`` is a list of
all checked values. When *True*, it behaves like a ``list`` type -- only one value can be selected.
If no values are selected and ``exclusive`` is set to *True*, the first available limit is selected.
The return value of an ``exclusive`` checklist is a single value rather than a list with one element.
============== ========================================================
"""
itemClass = ChecklistParameterItem
def __init__(self, **opts):
self.targetValue = None
limits = opts.setdefault('limits', [])
self.forward, self.reverse = ListParameter.mapping(limits)
value = opts.setdefault('value', limits)
opts.setdefault('exclusive', False)
super().__init__(**opts)
# Force 'exclusive' to trigger by making sure value is not the same
self.sigLimitsChanged.connect(self.updateLimits)
self.sigOptionsChanged.connect(self.optsChanged)
if len(limits):
# Since update signal wasn't hooked up until after parameter construction, need to fire manually
self.updateLimits(self, limits)
# Also, value calculation will be incorrect until children are added, so make sure to recompute
self.setValue(value)
def updateLimits(self, _param, limits):
oldOpts = self.names
val = self.opts['value']
# Make sure adding and removing children don't cause tree state changes
self.blockTreeChangeSignal()
self.clearChildren()
self.forward, self.reverse = ListParameter.mapping(limits)
if self.opts.get('exclusive'):
typ = 'radio'
else:
typ = 'bool'
for chName in self.forward:
# Recycle old values if they match the new limits
newVal = bool(oldOpts.get(chName, False))
child = BoolOrRadioParameter(type=typ, name=chName, value=newVal, default=None)
self.addChild(child)
# Prevent child from broadcasting tree state changes, since this is handled by self
child.blockTreeChangeSignal()
child.sigValueChanged.connect(self._onSubParamChange)
# Purge child changes before unblocking
self.treeStateChanges.clear()
self.unblockTreeChangeSignal()
self.setValue(val)
def _onSubParamChange(self, param, value):
if self.opts['exclusive']:
val = self.reverse[0][self.reverse[1].index(param.name())]
return self.setValue(val)
# Interpret value, fire sigValueChanged
return self.setValue(self.value())
def optsChanged(self, param, opts):
if 'exclusive' in opts:
# Force set value to ensure updates
# self.opts['value'] = self._VALUE_UNSET
self.updateLimits(None, self.opts.get('limits', []))
def value(self):
vals = [self.forward[p.name()] for p in self.children() if p.value()]
exclusive = self.opts['exclusive']
if not vals and exclusive:
return None
elif exclusive:
return vals[0]
else:
return vals
def setValue(self, value, blockSignal=None):
self.targetValue = value
exclusive = self.opts['exclusive']
# Will emit at the end, so no problem discarding existing changes
cmpVals = value if isinstance(value, list) else [value]
for ii in range(len(cmpVals)-1, -1, -1):
exists = any(fn.eq(cmpVals[ii], lim) for lim in self.reverse[0])
if not exists:
del cmpVals[ii]
names = [self.reverse[1][self.reverse[0].index(val)] for val in cmpVals]
if exclusive and len(names) > 1:
names = [names[0]]
elif exclusive and not len(names) and len(self.forward):
# An option is required during exclusivity
names = [self.reverse[1][0]]
for chParam in self:
checked = chParam.name() in names
chParam.setValue(checked, self._onSubParamChange)
super().setValue(self.value(), blockSignal)