class GenericPanel(Panel):
"""Provides a generic implementation of Panel to display any ``.ui`` file.
The ``.ui`` file may also use NICOS GUI widgets (see :ref:`gui-widgets`).
Options:
* ``uifile`` -- the path to the UI file to display
* ``showmsg`` -- if set to `True` a dialog window pops up in case of an
error or warning inside the daemon and displays the corresponding
message. If the dialog is already open, a new line with the error or
warning message will be added to the open dialog.
"""
panelName = 'Generic' # XXX this is not unique
def __init__(self, parent, client, options):
Panel.__init__(self, parent, client, options)
self._error_window = None
if 'uifile' not in options:
raise ConfigurationError('GenericPanels require at least an'
' `uifile` option.')
loadUi(self, findResource(options['uifile']))
if options.get('showmsg'):
self.client.message.connect(self.on_client_message)
if client.isconnected:
self.on_client_connected()
client.connected.connect(self.on_client_connected)
def on_client_connected(self):
for ch in self.findChildren(NicosWidget):
ch.setClient(self.client)
def on_client_message(self, message):
# show warnings and errors emitted by the current command in a window
if len(message) < 6 or message[5] != self.client.last_reqid or \
message[2] < WARNING:
return
msg = '%s: %s' % (message[0], message[3].strip())
if self._error_window is None:
def reset_errorwindow():
self._error_window = None
self._error_window = ErrorDialog(self)
self._error_window.accepted.connect(reset_errorwindow)
self._error_window.addMessage(msg)
self._error_window.show()
else:
self._error_window.addMessage(msg)
self._error_window.activateWindow()
class DevicesPanel(Panel):
"""Provides a graphical list of NICOS devices and their current values.
The user can operate basic device functions (move, stop, reset) by
selecting an item from the list, which opens a control dialog.
Options:
* ``useicons`` (default True) -- if set to False, the list widget does not
display status icons for the devices.
* ``param_display`` (default {}) -- a dictionary containing the device name
as key and a parameter name or a list of the parameter names which should
be displayed in the device tree as subitems of the device item, for
example::
param_display = {
'tas': 'scanmode',
'Exp': ['lastpoint', 'lastscan']
}
* ``filters`` (default []) -- a list of tuples containing the name of the
filter and the regular expression to filter out the devices.
example::
filters = [
('All', ''),
('Default', 'T|UBahn'),
('Foo', 'bar$'),
]
"""
panelName = 'Devices'
ui = 'panels/devices.ui'
@classmethod
def _createIcons(cls):
# hack to make non-Qt usage as in checksetups work
if not hasattr(cls, 'statusIcon'):
cls.statusIcon = {
OK: QIcon(':/leds/status_green'),
WARN: QIcon(':/leds/status_warn'),
BUSY: QIcon(':/leds/status_yellow'),
NOTREACHED: QIcon(':/leds/status_red'),
DISABLED: QIcon(':/leds/status_white'),
ERROR: QIcon(':/leds/status_red'),
UNKNOWN: QIcon(':/leds/status_unknown'),
}
@property
def groupIcon(self):
return QIcon(':/setup')
def __init__(self, parent, client, options):
DevicesPanel._createIcons()
Panel.__init__(self, parent, client, options)
loadUi(self, self.ui)
self.useicons = bool(options.get('icons', True))
self.param_display = {}
param_display = options.get('param_display', {})
for (key, value) in param_display.items():
value = [value] if isinstance(value, string_types) else list(value)
self.param_display[key.lower()] = value
self.tree.header().restoreState(self._headerstate)
self.clear()
self.devmenu = QMenu(self)
self.devmenu.addAction(self.actionMove)
self.devmenu.addAction(self.actionStop)
self.devmenu.addAction(self.actionReset)
self.devmenu.addSeparator()
self.devmenu.addAction(self.actionFix)
self.devmenu.addAction(self.actionRelease)
self.devmenu.addSeparator()
if self.mainwindow.history_wintype is not None:
self.devmenu.addAction(self.actionPlotHistory)
self.devmenu.addSeparator()
self.devmenu.addAction(self.actionShutDown)
self.devmenu.addAction(self.actionHelp)
self.devmenu_ro = QMenu(self)
self.devmenu_ro.addAction(self.actionMove)
self.devmenu_ro.addAction(self.actionReset)
self.devmenu_ro.addSeparator()
if self.mainwindow.history_wintype is not None:
self.devmenu_ro.addAction(self.actionPlotHistory)
self.devmenu_ro.addSeparator()
self.devmenu_ro.addAction(self.actionShutDown)
self.devmenu_ro.addAction(self.actionHelp)
self._menu_dev = None # device for which context menu is shown
self._dev2setup = {}
self._setupinfo = {}
self._control_dialogs = {}
self._show_lowlevel = self.mainwindow.expertmode
# daemon request ID of last command executed from this panel
# (used to display messages from this command)
self._current_status = 'idle'
self._exec_reqid = None
self._error_window = None
client.connected.connect(self.on_client_connected)
client.disconnected.connect(self.on_client_disconnected)
client.cache.connect(self.on_client_cache)
client.device.connect(self.on_client_device)
client.setup.connect(self.on_client_setup)
client.message.connect(self.on_client_message)
self.filters = options.get('filters', [])
self.filter.addItem('')
for text, rx in self.filters:
self.filter.addItem('Filter: %s' % text, rx)
self.filter.lineEdit().setPlaceholderText('Enter search expression')
def updateStatus(self, status, exception=False):
self._current_status = status
def saveSettings(self, settings):
settings.setValue('headers', self.tree.header().saveState())
def loadSettings(self, settings):
self._headerstate = settings.value('headers', '', QByteArray)
def _update_view(self):
with self.sgroup as settings:
for i in range(self.tree.topLevelItemCount()):
v = settings.value(
'%s/expanded' % self.tree.topLevelItem(i).text(0), True,
bool)
self.tree.topLevelItem(i).setExpanded(v)
def _store_view(self):
with self.sgroup as settings:
for i in range(self.tree.topLevelItemCount()):
settings.setValue(
'%s/expanded' % self.tree.topLevelItem(i).text(0),
self.tree.topLevelItem(i).isExpanded())
def hideTitle(self):
self.titleLbl.setVisible(False)
def setExpertMode(self, expert):
self._show_lowlevel = expert
self.on_client_connected()
def clear(self):
if self.tree:
self._store_view()
self._catitems = {}
# map lowercased devname -> tree widget item
self._devitems = {}
self._devparamitems = {}
# map lowercased devname -> DevInfo instance
self._devinfo = {}
self.tree.clear()
def on_client_connected(self):
self.clear()
state = self.client.ask('getstatus')
if not state:
return
devlist = state['devices']
self._read_setup_info(state['setups'])
for devname in devlist:
self._create_device_item(devname)
# close all control dialogs for now nonexisting devices
for ldevname in list(self._control_dialogs):
if ldevname not in self._devitems:
self._control_dialogs[ldevname].close()
# add all toplevel items to the tree, sorted
for cat in self._catitems:
self.tree.addTopLevelItem(self._catitems[cat])
self._catitems[cat].setExpanded(True)
for devitem in itervalues(self._devitems):
devitem.setExpanded(True)
self.tree.sortItems(0, Qt.AscendingOrder)
self._update_view()
def on_client_disconnected(self):
self.clear()
def on_client_message(self, message):
# show warnings and errors emitted by the current command in a window
if message[5] != self._exec_reqid or message[2] < WARNING:
return
msg = '%s: %s' % (message[0], message[3].strip())
if self._error_window is None:
def reset_errorwindow():
self._error_window = None
self._error_window = ErrorDialog(self)
self._error_window.accepted.connect(reset_errorwindow)
self._error_window.addMessage(msg)
self._error_window.show()
else:
self._error_window.addMessage(msg)
self._error_window.activateWindow()
def _read_setup_info(self, setuplists=None):
if setuplists is None:
allstatus = self.client.ask('getstatus')
if allstatus is None:
return
setuplists = allstatus['setups']
loaded_setups = set(setuplists[0])
self._dev2setup = {}
self._setupinfo = self.client.eval('session.getSetupInfo()', {})
if self._setupinfo is None:
self.log.warning('session.getSetupInfo() returned None instead '
'of {}')
return
for setupname, info in iteritems(self._setupinfo):
if info is None:
continue
if setupname not in loaded_setups:
continue
for devname in info['devices']:
self._dev2setup[devname] = setupname
def _create_device_item(self, devname, add_cat=False):
ldevname = devname.lower()
# get all cache keys pertaining to the device
params = self.client.getDeviceParams(devname)
if not params:
return
lowlevel_device = params.get('lowlevel') or False
if lowlevel_device and not self._show_lowlevel:
return
if 'nicos.core.data.sink.DataSink' in params.get('classes', []) and \
not self._show_lowlevel:
return
# remove still-existing previous item for the same device name
if ldevname in self._devitems:
self.on_client_device(('destroy', [devname]))
cat = self._dev2setup.get(devname)
if cat is None: # device is not in any setup? reread setup info
self._read_setup_info()
cat = self._dev2setup.get(devname)
if cat is None: # still not there -> give up
return
if cat not in self._catitems:
display_order = self._setupinfo[cat].get('display_order', 50)
representative = self._setupinfo[cat].get('extended', {}).get(
'representative', '').lower()
catitem = SetupTreeWidgetItem(cat, display_order, representative)
catitem.setToolTip(0, self._setupinfo[cat].get('description', ''))
f = catitem.font(0)
f.setBold(True)
catitem.setFont(0, f)
catitem.setIcon(0, self.groupIcon)
self._catitems[cat] = catitem
if add_cat:
self.tree.addTopLevelItem(catitem)
catitem.setExpanded(True)
else:
catitem = self._catitems[cat]
# create a tree node for the device
devitem = QTreeWidgetItem(catitem, [devname, '', ''], DEVICE_TYPE)
devitem.setForeground(0, lowlevelBrush[lowlevel_device])
devitem.setFont(0, lowlevelFont[lowlevel_device])
if self.useicons:
devitem.setIcon(0, self.statusIcon[OK])
devitem.setToolTip(0, params.get('description', ''))
self._devitems[ldevname] = devitem
# fill the device info with dummy values, will be populated below
self._devinfo[ldevname] = DevInfo(devname)
# let the cache handler process all properties
for key, value in iteritems(params):
self.on_client_cache(
(0, ldevname + '/' + key, OP_TELL, cache_dump(value)))
def on_client_setup(self, setuplists):
# update setup tooltips
self._read_setup_info(setuplists)
for i in range(self.tree.topLevelItemCount()):
catitem = self.tree.topLevelItem(i)
cat = catitem.text(0)
catitem.setToolTip(0, self._setupinfo[cat].get('description', ''))
def on_client_device(self, data):
(action, devlist) = data
if not devlist:
return
if action == 'create':
for devname in devlist:
self._create_device_item(devname, add_cat=True)
self.tree.sortItems(0, Qt.AscendingOrder)
self._update_view()
elif action == 'destroy':
self._store_view()
for devname in devlist:
ldevname = devname.lower()
if ldevname in self._devitems:
# remove device item and cached info...
item = self._devitems[ldevname]
del self._devitems[ldevname]
del self._devinfo[ldevname]
self._devparamitems.pop(ldevname, None)
try:
catitem = item.parent()
except RuntimeError:
# Qt object has already been destroyed
pass
else:
catitem.removeChild(item)
# remove category item if it has no further children
if catitem.childCount() == 0:
self.tree.takeTopLevelItem(
self.tree.indexOfTopLevelItem(catitem))
del self._catitems[catitem.text(0)]
self._update_view()
def on_client_cache(self, data):
(time, key, op, value) = data
if '/' not in key:
return
ldevname, subkey = key.rsplit('/', 1)
if ldevname not in self._devinfo:
return
if ldevname in self._control_dialogs:
self._control_dialogs[ldevname].on_cache(subkey, value)
devitem = self._devitems[ldevname]
devinfo = self._devinfo[ldevname]
if subkey == 'value':
if time < devinfo.valtime:
return
if not value:
fvalue = ''
else:
fvalue = cache_load(value)
if isinstance(fvalue, list):
fvalue = tuple(fvalue)
devinfo.value = fvalue
devinfo.expired = op != OP_TELL
devinfo.valtime = time
fmted = devinfo.fmtValUnit()
devitem.setText(1, fmted)
if ldevname in self._control_dialogs:
self._control_dialogs[ldevname].valuelabel.setText(fmted)
devitem.setForeground(1, valueBrush[devinfo.expired,
devinfo.fixed])
if not devitem.parent().isExpanded():
if ldevname == devitem.parent().representative:
devitem.parent().setText(1, fmted)
elif subkey == 'status':
if time < devinfo.stattime:
return
if not value:
status = (UNKNOWN, '?')
else:
status = cache_load(value)
devinfo.status = status
devinfo.stattime = time
devitem.setText(2, str(status[1]))
if status[0] not in self.statusIcon:
# old or wrong status constant
return
if self.useicons:
devitem.setIcon(0, self.statusIcon[status[0]])
devitem.setForeground(2, foregroundBrush[status[0]])
devitem.setBackground(2, backgroundBrush[status[0]])
else:
devitem.setForeground(0, foregroundBrush[BUSY])
devitem.setBackground(0, backgroundBrush[status[0]])
if not devitem.parent().isExpanded():
item = devitem.parent()
item.setBackground(
0, backgroundBrush[self._getHighestStatus(item)])
else:
devitem.parent().setBackground(0, backgroundBrush[OK])
if ldevname in self._control_dialogs:
dlg = self._control_dialogs[ldevname]
dlg.statuslabel.setText(status[1])
dlg.statusimage.setPixmap(self.statusIcon[status[0]].pixmap(
16, 16))
setForegroundBrush(dlg.statuslabel, foregroundBrush[status[0]])
setBackgroundBrush(dlg.statuslabel, backgroundBrush[status[0]])
elif subkey == 'fmtstr':
if not value:
return
devinfo.fmtstr = cache_load(value)
devitem.setText(1, devinfo.fmtValUnit())
elif subkey == 'unit':
if not value:
value = "''"
devinfo.unit = cache_load(value)
devitem.setText(1, devinfo.fmtValUnit())
elif subkey == 'fixed':
if not value:
value = "''"
devinfo.fixed = bool(cache_load(value))
devitem.setForeground(1, valueBrush[devinfo.expired,
devinfo.fixed])
if ldevname in self._control_dialogs:
dlg = self._control_dialogs[ldevname]
if dlg.moveBtn:
dlg.moveBtn.setEnabled(not devinfo.fixed)
dlg.moveBtn.setText(devinfo.fixed and '(fixed)' or 'Move')
elif subkey == 'userlimits':
if not value:
return
value = cache_load(value)
if ldevname in self._control_dialogs:
dlg = self._control_dialogs[ldevname]
dlg.limitMin.setText(str(value[0]))
dlg.limitMax.setText(str(value[1]))
elif subkey == 'classes':
if not value:
value = "[]"
devinfo.classes = set(cache_load(value))
elif subkey == 'alias':
if not value:
return
if ldevname in self._control_dialogs:
dlg = self._control_dialogs[ldevname]
dlg._reinit()
elif subkey == 'description':
devitem.setToolTip(0, cache_load(value or "''"))
if subkey in self.param_display.get(ldevname, ()):
if not devinfo.params:
devinfo.params = self.client.getDeviceParamInfo(devinfo.name)
value = devinfo.fmtParam(subkey, cache_load(value))
if subkey not in self._devparamitems.setdefault(ldevname, {}):
devitem = self._devitems[ldevname]
self._devparamitems[ldevname][subkey] = \
QTreeWidgetItem(devitem, [subkey, value, ''], PARAM_TYPE)
devitem.setExpanded(True)
else:
self._devparamitems[ldevname][subkey].setText(1, value)
def on_tree_itemExpanded(self, item):
if item.type() == SETUP_TYPE:
item.setText(1, '')
item.setBackground(0, backgroundBrush[OK])
def _getHighestStatus(self, item):
retval = OK
for i in range(item.childCount()):
lstatus = self._devinfo[item.child(i).text(0).lower()].status[0]
if retval < lstatus:
retval = lstatus
return retval
def on_tree_itemCollapsed(self, item):
if item.type() == SETUP_TYPE:
item.setBackground(0,
backgroundBrush[self._getHighestStatus(item)])
if item.representative:
item.setText(1, self._devitems[item.representative].text(1))
def on_tree_customContextMenuRequested(self, point):
item = self.tree.itemAt(point)
if item is None:
return
if item.type() == DEVICE_TYPE:
self._menu_dev = item.text(0)
ldevname = self._menu_dev.lower()
if 'nicos.core.device.Moveable' in self._devinfo[ldevname].classes and \
not self.client.viewonly:
self.devmenu.popup(self.tree.viewport().mapToGlobal(point))
elif 'nicos.core.device.Readable' in self._devinfo[
ldevname].classes:
self.devmenu_ro.popup(self.tree.viewport().mapToGlobal(point))
def on_filter_editTextChanged(self, text):
for i in range(self.filter.count()):
if text == self.filter.itemText(i):
rx = QRegExp(self.filter.itemData(i))
break
else:
rx = QRegExp(text)
for i in range(self.tree.topLevelItemCount()):
setupitem = self.tree.topLevelItem(i)
all_children_hidden = True
for j in range(setupitem.childCount()):
devitem = setupitem.child(j)
if rx.indexIn(devitem.text(0)) == -1:
devitem.setHidden(True)
else:
devitem.setHidden(False)
all_children_hidden = False
setupitem.setHidden(all_children_hidden)
@pyqtSlot()
def on_actionShutDown_triggered(self):
if self._menu_dev:
if self.askQuestion('This will unload the device until the setup '
'is loaded again. Proceed?'):
self.exec_command('RemoveDevice(%s)' % srepr(self._menu_dev),
ask_queue=False)
@pyqtSlot()
def on_actionReset_triggered(self):
if self._menu_dev:
self.exec_command('reset(%s)' % srepr(self._menu_dev))
@pyqtSlot()
def on_actionFix_triggered(self):
if self._menu_dev:
reason, ok = QInputDialog.getText(
self, 'Fix',
'Please enter the reason for fixing %s:' % self._menu_dev)
if not ok:
return
self.exec_command('fix(%s, %r)' % (srepr(self._menu_dev), reason))
@pyqtSlot()
def on_actionRelease_triggered(self):
if self._menu_dev:
self.exec_command('release(%s)' % srepr(self._menu_dev))
@pyqtSlot()
def on_actionStop_triggered(self):
if self._menu_dev:
self.exec_command('stop(%s)' % srepr(self._menu_dev),
immediate=True)
@pyqtSlot()
def on_actionMove_triggered(self):
if self._menu_dev:
self._open_control_dialog(self._menu_dev)
@pyqtSlot()
def on_actionHelp_triggered(self):
if self._menu_dev:
self.client.eval('session.showHelp(session.devices[%r])' %
self._menu_dev)
@pyqtSlot()
def on_actionPlotHistory_triggered(self):
if self._menu_dev:
self.plot_history(self._menu_dev)
def on_tree_itemActivated(self, item, column):
if item.type() == DEVICE_TYPE:
devname = item.text(0)
self._open_control_dialog(devname)
elif item.type() == PARAM_TYPE:
devname = item.parent().text(0)
dlg = self._open_control_dialog(devname)
dlg.editParam(item.text(0))
def _open_control_dialog(self, devname):
ldevname = devname.lower()
if ldevname in self._control_dialogs:
dlg = self._control_dialogs[ldevname]
if dlg.isVisible():
dlg.activateWindow()
return dlg
devinfo = self._devinfo[ldevname]
item = self._devitems[ldevname]
dlg = ControlDialog(self, devname, devinfo, item, self.log,
self._show_lowlevel)
dlg.closed.connect(self._control_dialog_closed)
dlg.rejected.connect(dlg.close)
self._control_dialogs[ldevname] = dlg
dlg.show()
return dlg
def _control_dialog_closed(self, ldevname):
dlg = self._control_dialogs.pop(ldevname, None)
if dlg:
dlg.deleteLater()
# API shared with ControlDialog
def exec_command(self, command, ask_queue=True, immediate=False):
if ask_queue and not immediate and self._current_status != 'idle':
qwindow = ScriptExecQuestion()
result = qwindow.exec_()
if result == QMessageBox.Cancel:
return
elif result == QMessageBox.Apply:
immediate = True
if immediate:
self.client.tell('exec', command)
self._exec_reqid = None # no request assigned to this command
else:
self._exec_reqid = self.client.run(command)
def plot_history(self, dev):
if self.mainwindow.history_wintype is not None:
win = self.mainwindow.createWindow(self.mainwindow.history_wintype)
if win:
panel = win.getPanel('History viewer')
panel.newView(dev)
showPanel(panel)
class AmorControlPanel(GenericPanel):
def __init__(self, parent, client, options):
GenericPanel.__init__(self, parent, client, options)
for ch in self.findChildren(NicosWidget):
ch.setClient(client)
# daemon request ID of last command executed from this panel
# (used to display messages from this command)
self._current_status = 'idle'
self._exec_reqid = None
self._error_window = None
self.motor_widgets = {
'som': self.somEdit,
's2t': self.s2tEdit,
'soz': self.sozEdit,
'stz': self.stzEdit
}
self.slit_widgets = {
'slit1_opening': self.slit1Edit,
'slit2_opening': self.slit2Edit,
'slit3_opening': self.slit3Edit,
'slit4_opening': self.slit4Edit,
'd5v': self.slit5Edit,
}
self.magnet_widgets = {'hsy': self.hsyEdit}
# Initialise the widgets
self._reinit()
# Set the validator for monitor preset edit
# Regular expression for scientific notation: [\d.]+(?:e\d+)?
self.monitorPresetBox.setValidator(
QRegExpValidator(QRegExp(r"[\d.]+(?:e\d+)?"), self))
self.setMonitorPreset(True)
self.setSampleMove(True)
self.opMonitor.toggled.connect(self.setMonitorPreset)
self.opTime.toggled.connect(self.setTimePreset)
self.opSampleMove.toggled.connect(self.setSampleMove)
self.opSampleSetPosition.toggled.connect(self.setSampleSetPosition)
client.message.connect(self.on_client_message)
client.setup.connect(self.on_client_setup)
def updateStatus(self, status, exception=False):
self._current_status = status
def _reinit(self):
widgets_dict = {}
widgets_dict.update(self.motor_widgets)
widgets_dict.update(self.slit_widgets)
widgets_dict.update(self.magnet_widgets)
for n, w in widgets_dict.items():
currval = self.client.getDeviceParam(n, 'value')
w._reinit(currval)
def on_client_setup(self):
self._reinit()
def on_client_message(self, message):
# show warnings and errors emitted by the current command in a window
if message[5] != self._exec_reqid or message[2] < WARNING:
return
msg = '%s: %s' % (message[0], message[3].strip())
if self._error_window is None:
def reset_errorwindow():
self._error_window = None
self._error_window = ErrorDialog(self)
self._error_window.accepted.connect(reset_errorwindow)
self._error_window.addMessage(msg)
self._error_window.show()
else:
self._error_window.addMessage(msg)
self._error_window.activateWindow()
self._reinit()
def setMonitorPreset(self, checked):
self.timePresetWidget.setVisible(not checked)
self.monitorPresetWidget.setVisible(checked)
def setTimePreset(self, checked):
self.monitorPresetWidget.setVisible(not checked)
self.timePresetWidget.setVisible(checked)
def setSampleMove(self, checked):
self.sampleSetPositionButtonWidget.setVisible(not checked)
self.motor_widgets['s2t'].setEnabled(checked)
self.sampleMoveButtonWidget.setVisible(checked)
self._reinit()
def setSampleSetPosition(self, checked):
self.motor_widgets['s2t'].setEnabled(not checked)
self.sampleMoveButtonWidget.setVisible(not checked)
self.sampleSetPositionButtonWidget.setVisible(checked)
self._reinit()
def exec_command(self, command, ask_queue=True, immediate=False):
if ask_queue and not immediate and self._current_status != 'idle':
qwindow = ScriptExecQuestion()
result = qwindow.exec_()
if result == QMessageBox.Cancel:
return
elif result == QMessageBox.Apply:
immediate = True
if immediate:
self.client.tell('exec', command)
self._exec_reqid = None # no request assigned to this command
else:
self._exec_reqid = self.client.run(command)
@pyqtSlot()
def on_countStartButton_clicked(self):
if self.opTime.isChecked():
value = float(self.timePresetBox.text())
preset = 't'
else:
try:
value = float(self.monitorPresetBox.text())
preset = 'm'
except ValueError:
self.log.exception('invalid value for monitor preset')
QMessageBox.warning(self, 'Error', 'Invalid monitor preset')
return
args = '%s=%r' % (preset, int(value))
code = 'count(%s)' % args
self.exec_command(code)
@pyqtSlot()
def on_sampleMoveButton_clicked(self):
self._devsMoveButton(self.motor_widgets, 'move')
@pyqtSlot()
def on_sampleMoveAndWaitButton_clicked(self):
self._devsMoveButton(self.motor_widgets, 'maw')
@pyqtSlot()
def on_sampleSetPositionButton_clicked(self):
self._devsMoveButton(self.motor_widgets, 'adjust', True)
@pyqtSlot()
def on_slitMoveButton_clicked(self):
self._devsMoveButton(self.slit_widgets, 'move')
@pyqtSlot()
def on_slitMoveAndWaitButton_clicked(self):
self._devsMoveButton(self.slit_widgets, 'maw')
@pyqtSlot()
def on_hsyToggleButton_clicked(self):
switchedOn = self.client.eval('hsy_switch.isEnabled', None)
if switchedOn is None:
self.showError('Cannot check the status of magnets!')
newstate = 'off' if switchedOn else 'on'
code = 'hsy_switch.move(%r)' % newstate
self.exec_command(code)
@pyqtSlot()
def on_hsyMoveButton_clicked(self):
self._devsMoveButton(self.magnet_widgets, 'move')
def _devsMoveButton(self, dic, cmd='move', issue_separate=False):
dev_to_widget = {
n: w
for n, w in dic.items() if not isinstance(w._inner, MissingWidget)
}
targets = []
try:
targets = [edit.getValue() for edit in dev_to_widget.values()]
except ValueError:
self.log.exception('invalid value for typed value')
# shouldn't happen, but if it does, at least gives indication that
# something went wrong
QMessageBox.warning(self, 'Error', 'Some entered value is invalid')
return
# Check which motors to move
expr = ', '.join([
n + '.isAtTarget(target=%r)' % v
for n, v in zip(dev_to_widget, targets)
])
on_targ = self.client.eval(expr, None)
if on_targ is None:
self.showError('Cannot check the status! Cannot move!')
return
if not isinstance(on_targ, tuple):
on_targ = [on_targ]
move = {
n: v
for n, v, t in zip(dev_to_widget, targets, on_targ) if not t
}
if not move:
return
if issue_separate:
code = '\n'.join(
('%s(%s, %r)' % (cmd, n, v) for n, v in move.items()))
else:
code = '%s(%s)' % (cmd, ', '.join(
('%s, %r' % (n, v) for n, v in move.items())))
self.exec_command(code)