def on_pushButtonAddSysconfig_clicked(self):
dlg = AddSysconfigDialog()
i = 0
topLevelItems = []
while i < self.treeWidgetSysconfig.topLevelItemCount():
# apparently, text() returns a unicode string..? Therefore str()
topLevelItems.append(
str(self.treeWidgetSysconfig.topLevelItem(i).text(0)))
i += 1
for key in self.sysconfigKeys:
if key not in topLevelItems:
dlg.comboBoxNewSysconfig.addItem(key)
if dlg.exec_():
key = dlg.comboBoxNewSysconfig.currentText()
value = dlg.lineEditValue.text()
self.treeWidgetSysconfig.addTopLevelItem(QTreeWidgetItem([key]))
if value:
currentIndex = 0
while currentIndex < self.treeWidgetSysconfig.\
topLevelItemCount():
if self.treeWidgetSysconfig.topLevelItem(
currentIndex).text(0) == key:
self.treeWidgetSysconfig.topLevelItem(
currentIndex).addChild(QTreeWidgetItem([value]))
currentIndex += 1
if self.treeWidgetSysconfig.topLevelItemCount() == len(
self.sysconfigKeys):
self.pushButtonAddSysconfig.setEnabled(False)
self.editedSetup.emit()
def __init__(self, main):
QDialog.__init__(self, main)
DlgUtils.__init__(self, 'Settings')
loadUi(self, 'dialogs/settings.ui')
self.main = main
self.sgroup = main.sgroup
genitem = QTreeWidgetItem(self.settingsTree, ['General'], -2)
QTreeWidgetItem(self.settingsTree, ['Connection presets'], -1)
self.settingsTree.setCurrentItem(genitem)
self.stacker.setCurrentIndex(0)
# general page
self.instrument.setText(main.instrument)
self.confirmExit.setChecked(main.confirmexit)
self.warnWhenAdmin.setChecked(main.warnwhenadmin)
self.showTrayIcon.setChecked(main.showtrayicon)
self.autoReconnect.setChecked(main.autoreconnect)
self.autoSaveLayout.setChecked(main.autosavelayout)
self.manualSaveLayout.setChecked(not main.autosavelayout)
self.allowOutputLineWrap.setChecked(main.allowoutputlinewrap)
# connection data page
self.connpresets = main.connpresets
for setting, cdata in main.connpresets.items():
QListWidgetItem(setting + ' (%s:%s)' % (cdata.host, cdata.port),
self.settinglist).setData(32, setting)
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 _reinit(self):
self.clear()
for devname in self.client.getDeviceList(
only_explicit=self.only_explicit,
special_clause=self.device_clause):
item = QTreeWidgetItem([devname])
# allow expanding interactively, even if we haven't populated
# the parameter children yet
item.setChildIndicatorPolicy(QTreeWidgetItem.ShowIndicator)
if not self.item_callback(item):
continue
self.addTopLevelItem(item)
def updateTree(self):
"""Updates the elements shown in the tree."""
self.clearCacheTree()
filterStr = self.valueFilter.text() or ''
for key in self.client.keys():
if filterStr not in key:
continue
# split the key into parts
parts = key.split('/')
# keys without category need a node too
if len(parts) == 1:
parts = ['<no category>'] + parts
# add a node to the tree for each part of the key except the last
prefix = ''
parent = None
for part in parts[:-1]:
prefix = part if not prefix else prefix + '/' + part
node = self._treeitems.get(prefix)
if not node:
node = QTreeWidgetItem()
node.setText(0, part)
node.setData(0, 32, prefix)
if parent:
parent.addChild(node)
else:
self.treeCache.addTopLevelItem(node)
node.setExpanded(True)
self._treeitems[prefix] = node
parent = node
def newDeviceAddedSlot(self, deviceName, _classString):
setupItem = self.getCurrentSetupItem()
if setupItem.setup.abspath not in self.setupWidgets.keys():
self.loadSetup(setupItem.setup, setupItem.parent().text(0))
uncombinedModule = _classString.split('.')
classname = uncombinedModule.pop()
module = '.'.join(uncombinedModule)
classes = inspect.getmembers(classparser.modules[module],
predicate=inspect.isclass)
_class = [_class[1] for _class in classes if _class[0] == classname][0]
parameters = {
key: ''
for key in _class.parameters.keys()
if _class.parameters[key].mandatory is True
}
device = setupcontroller.Device(deviceName,
_classString,
parameters=parameters)
setupItem.setup.devices[deviceName] = device
deviceWidget = DeviceWidget(self.setupWidgets[setupItem.setup.abspath])
deviceWidget.editedDevice.connect(self.editedSetupSlot)
deviceWidget.loadDevice(device)
self.workarea.addWidget(deviceWidget)
self.deviceWidgets[setupItem.setup.abspath][deviceName] = deviceWidget
deviceItem = QTreeWidgetItem([deviceName], ItemTypes.Device)
deviceItem.setFlags(deviceItem.flags() & ~Qt.ItemIsDropEnabled)
deviceItem.device = setupItem.setup.devices[deviceName]
deviceItem.setIcon(0, QIcon(path.join(getResDir(), 'device.png')))
setupItem.insertChild(0, deviceItem)
self.treeWidget.itemActivated.emit(deviceItem, 0)
if not setupItem.setup.edited:
setupItem.setText(0, '*' + setupItem.text(0))
setupItem.setup.edited = True
def __init__(self, setup, availablesetups, parent=None):
QWidget.__init__(self, parent)
uic.loadUi(path.join(path.dirname(path.abspath(__file__)),
'ui', 'setupwidget.ui'), self)
# keys taken from nicos_demo/skeleton/setups/system.py
self.sysconfigKeys = ['cache',
'instrument',
'experiment',
'datasinks',
'notifiers']
self.lineEditDescription.textEdited.connect(self.editedSetup.emit)
self.treeWidgetSysconfig.editedSetup.connect(self.editedSetup.emit)
self.comboBoxGroup.activated.connect(self.editedSetup.emit)
self.lineEditDescription.setText(setup.description)
self.comboBoxGroup.setCurrentIndex(
self.comboBoxGroup.findText(setup.group))
for includeItem in setup.includes:
self.listWidgetIncludes.addItem(includeItem)
for excludeItem in setup.excludes:
self.listWidgetExcludes.addItem(excludeItem)
for moduleItem in setup.modules:
self.listWidgetModules.addItem(moduleItem)
topLevelItems = []
for key in self.sysconfigKeys:
if key in setup.sysconfig:
topLevelItems.append(QTreeWidgetItem([key]))
self.treeWidgetSysconfig.addTopLevelItems(topLevelItems)
for item in topLevelItems:
if isinstance(setup.sysconfig[item.text(0)], list):
for listItem in setup.sysconfig[item.text(0)]:
item.addChild(QTreeWidgetItem([listItem]))
else:
item.addChild(QTreeWidgetItem(
[setup.sysconfig[item.text(0)]]))
if self.treeWidgetSysconfig.topLevelItemCount() == len(
self.sysconfigKeys): # can't add any unknown keys
self.pushButtonAddSysconfig.setEnabled(False)
else:
self.pushButtonAddSysconfig.setEnabled(True)
self.textEditStartupCode.blockSignals(True)
self.textEditStartupCode.setPlainText(setup.startupcode[1:-1])
self.textEditStartupCode.blockSignals(False)
self.availablesetups = availablesetups
def addValue(self):
dlg = NewValueDialog()
if dlg.exec_():
value = dlg.getValue()
if not value:
QMessageBox.warning(self, 'Error', 'No value entered.')
return
self.currentItem().addChild(QTreeWidgetItem([value]))
self.editedSetup.emit()
def _update(self):
self.preconfTree.clear()
self._preconf_enable = {}
self._preconf_entries = {}
self._user_entries = {}
cf = self.client.eval('session.cache.get_raw("watchdog/configured")',
Ellipsis)
if cf is Ellipsis:
self.showError('Could not query watchdog configuration; '
'are you connected to a daemon?')
return
cf = sorted(cf, key=lambda entry: entry['id'])
for entry in cf:
eid = entry['id']
item = QTreeWidgetItem(self.preconfTree, [
'', entry['message'], entry['condition'], entry['setup'],
str(entry['gracetime']), entry['precondition'],
str(entry['precondtime']), entry['okmessage'],
entry['scriptaction'], entry['action'], entry['okaction']
])
item.setCheckState(0, Qt.Checked if entry['enabled']
else Qt.Unchecked)
self._preconf_enable[eid] = entry['enabled']
self._preconf_entries[eid] = entry
item.setData(0, 32, eid)
def _newSetup(self, instrument=None):
dlg = NewSetupDialog([
item.text(0) for item in self.topLevelItems
if item.type() == ItemTypes.Directory
], instrument)
if dlg.exec_():
fileName = dlg.getValue()
if not fileName:
QMessageBox.warning(self, 'Error', 'No setup name entered.')
return None, None
if not fileName.endswith('.py'):
fileName += '.py'
if dlg.isSpecialSetup():
abspath = path.join(getNicosDir(), 'nicos_mlz',
dlg.currentInstrument(), 'setups',
'special', fileName)
else:
abspath = path.join(getNicosDir(), 'nicos_mlz',
dlg.currentInstrument(), 'setups',
fileName)
if abspath in [
i.abspath for i in setupcontroller.setup_directories[
dlg.currentInstrument()]
]:
QMessageBox.warning(self, 'Error', 'Setup already exists!')
return None, None
try:
open(abspath, 'w', encoding='utf-8').close()
except OSError:
QMessageBox.warning(self, 'Error', 'Could not create new '
'setup!')
return None, None
setupcontroller.addSetup(dlg.currentInstrument(), abspath)
newSetup = None
for setup in setupcontroller.setup_directories[
dlg.currentInstrument()]:
if setup.abspath == abspath:
newSetup = setup
treeWidgetItem = QTreeWidgetItem(['*' + newSetup.name],
ItemTypes.Setup)
treeWidgetItem.setFlags(treeWidgetItem.flags()
& ~Qt.ItemIsDragEnabled)
treeWidgetItem.setIcon(0, QIcon(path.join(getResDir(),
'setup.png')))
treeWidgetItem.setup = newSetup
treeWidgetItem.setup.edited = True
return treeWidgetItem, dlg.currentInstrument()
return None, None
def __init__(self, parent, client, **settings):
QDialog.__init__(self, parent)
loadUi(self, 'tools/calculator.ui')
self.closeBtn.clicked.connect(self.doclose)
self.braggfmlLabel.setPixmap(QPixmap(
path.join(path.dirname(__file__), 'calculator_images',
'braggfml.png')))
for fld in bragg_fields:
getattr(self, 'chk' + fld).toggled.connect(self.gen_checked(fld))
self._miezesettings = settings.get('mieze', [])
if not self._miezesettings:
self.tabWidget.removeTab(1)
else:
self.mzwavelengthInput.textChanged.connect(self.mzcalc)
self.mzdistanceInput.textChanged.connect(self.mzcalc)
self.mzformulaLabel.setPixmap(QPixmap(
path.join(path.dirname(__file__), 'calculator_images',
'miezefml.png')))
self.mztimeTable.setHeaderLabels(['Setting', u'MIEZE time τ'])
for setting in self._miezesettings:
self.mztimeTable.addTopLevelItem(QTreeWidgetItem([setting, '']))
for fld in neutron_fields:
getattr(self, 'prop' + fld).textEdited.connect(self.n_calc)
self.presets = DlgPresets('nicoscalctool', [
(self.tabWidget, 0),
(self.mzwavelengthInput, '10'), (self.mzdistanceInput, '100'),
(self.inputLambda, '4.5'), (self.input2Theta, '0'),
(self.inputD, '10'), (self.inputN, '1'), (self.inputQ, '0'),
(self.chkLambda, 1), (self.chk2Theta, 0), (self.chkN, 1),
(self.chkD, 1), (self.chkQ, 0), (self.chkSampleDet, 1),
(self.inputSampleDet, '0'),
(self.propL, '1.8'), (self.propK, '3.4907'),
(self.propE, '25.2482'), (self.propNy, '6.1050'),
(self.propT, '292.9934'), (self.propV, '2197.80'),
])
self.presets.load()
self.braggcalc()
self.n_calc('')
dblval = DoubleValidator(self)
for fld in bragg_fields:
inputbox = getattr(self, 'input'+fld)
inputbox.textChanged.connect(self.braggcalc)
inputbox.setValidator(dblval)
def dropEvent(self, event):
"""
To satisfy Qt, a call to TreeWidgetContextMenu.dropEvent is neccessary.
Else, the animation would look really gross and suggest the object
might actually not have been copied.
But after the call, the newly appended child item seems to be
completely useless: It carries neither data nor does it emit the
treeWidget's itemActivated signal.
This may be a bug or my inability to find what's wrong.
Because of that, I need to construct my own item, find the old one and
replace it with my new one.
"""
target = self.getSetupOfDropPos(event.pos())
if self.dragItem.device.name in target.setup.devices.keys():
QMessageBox.warning(
self, 'Error', 'The target setup already '
'contains a device with that name!')
self.dragItem = None
event.ignore()
return
count = 0
previousItems = []
while count < target.childCount():
previousItems.append(target.child(count))
count += 1
TreeWidgetContextMenu.dropEvent(self, event)
count = 0
afterDropItems = []
while count < target.childCount():
afterDropItems.append(target.child(count))
count += 1
newItem = None
for child in afterDropItems:
if child not in previousItems:
newItem = child
index = target.indexOfChild(newItem)
target.takeChild(index)
deviceName = self.dragItem.device.name
target.setup.devices[deviceName] = deepcopy(self.dragItem.device)
deviceItem = QTreeWidgetItem([deviceName], ItemTypes.Device)
deviceItem.setFlags(deviceItem.flags() & ~Qt.ItemIsDropEnabled)
deviceItem.device = target.setup.devices[deviceName]
deviceItem.setIcon(0, QIcon(path.join(getResDir(), 'device.png')))
target.insertChild(index, deviceItem)
self.deviceAdded.emit(target, deviceName)
self.itemActivated.emit(deviceItem, 0)
def on_itemExpanded(self, item):
if item.childCount():
return
devname = item.text(0)
if self._showparams:
paraminfo = self.client.getDeviceParamInfo(devname)
for param, value in sorted(
self.client.getDeviceParams(devname).items()):
if not self.param_predicate(param, value,
paraminfo.get(param)):
continue
subitem = QTreeWidgetItem([param])
if not self.item_callback(subitem, item):
continue
item.addChild(subitem)
def on_client_watch(self, data):
values = data
names = set()
for name, val in values.items():
name = name[:name.find(':')]
if name in self.watch_items:
self.watch_items[name].setText(1, str(val))
else:
newitem = QTreeWidgetItem(self.watchView,
[str(name), str(val)])
self.watchView.addTopLevelItem(newitem)
self.watch_items[name] = newitem
names.add(name)
removed = set(self.watch_items) - names
for itemname in removed:
self.watchView.takeTopLevelItem(
self.watchView.indexOfTopLevelItem(
self.watch_items[itemname]))
del self.watch_items[itemname]
def __init__(self, reason, parent=None):
QDialog.__init__(self, parent)
loadUi(self, 'dialogs/instr_select.ui')
icon = QIcon(':/appicon-16')
if reason:
self.reasonLbl.setText(reason)
else:
self.reasonLbl.hide()
self.saveBox.hide()
self.confTree.itemDoubleClicked.connect(self.handleDoubleClick)
for entry in sorted(os.listdir(config.nicos_root)):
full = path.join(config.nicos_root, entry)
if not (entry.startswith('nicos_') and path.isdir(full)):
continue
pkgitem = QTreeWidgetItem(self.confTree, [entry])
pkgitem.setIcon(0, icon)
for subentry in sorted(os.listdir(full)):
configfile = path.join(full, subentry, 'guiconfig.py')
if not path.isfile(configfile):
continue
item = QTreeWidgetItem(pkgitem, [subentry])
item.setData(0, QTreeWidgetItem.UserType, configfile)
def on_client_simresult(self, data):
timing, devinfo, uuid = data
if uuid != self.simuuid:
return
self.simuuid = None
# show timing
if timing < 0:
self.simTotalTime.setText('Error occurred')
self.simFinished.setText('See messages')
else:
self.simTotalTime.setText(formatDuration(timing, precise=False))
self.simFinished.setText(formatEndtime(timing))
# device ranges
for devname, (_dval, dmin, dmax, aliases) in devinfo.items():
if dmin is not None:
aliascol = 'aliases: ' + ', '.join(aliases) if aliases else ''
item = QTreeWidgetItem([devname, dmin, '-', dmax, '', aliascol])
self.simRanges.addTopLevelItem(item)
self.simRanges.sortByColumn(0, Qt.AscendingOrder)
def __init__(self, parent, view, tb):
QDialog.__init__(self, parent)
loadUi(self, 'dialogs/traceback.ui')
self.tb = tb
self.view = view
self.client = parent.client
assert tb.startswith('Traceback')
# split into frames and message
frames = []
message = ''
curframe = []
for line in tb.splitlines():
if line.startswith(' '):
try:
name, v = line.split('=', 1)
except ValueError:
pass # most probably the "^" line of a SyntaxError
else:
if curframe:
curframe[2][name.strip()] = v.strip()
elif line.startswith(' '):
if curframe:
curframe[1] = line.strip()
elif line.startswith(' '):
curframe = [line.strip(), '', {}]
frames.append(curframe)
elif not line.startswith('Traceback'):
message += line
button = QPushButton('To clipboard', self)
self.buttonBox.addButton(button, QDialogButtonBox.ActionRole)
def copy():
QApplication.clipboard().setText(tb+'\n', QClipboard.Selection)
QApplication.clipboard().setText(tb+'\n', QClipboard.Clipboard)
button.clicked.connect(copy)
self.message.setText(message[:200])
self.tree.setFont(view.font())
boldfont = QFont(view.font())
boldfont.setBold(True)
for filename, line, bindings in frames:
item = QTreeWidgetItem(self.tree, [filename])
item.setFirstColumnSpanned(True)
item = QTreeWidgetItem(self.tree, [line])
item.setFirstColumnSpanned(True)
item.setFont(0, boldfont)
for var, value in iteritems(bindings):
QTreeWidgetItem(item, ['', var, value])
def _reinit(self):
classes = self.devinfo.classes
if sip.isdeleted(self.devitem):
# The item we're controlling has been removed from the list (e.g.
# due to client reconnect), get it again.
self.devitem = self.device_panel._devitems.get(
self.devname.lower())
# No such device anymore...
if self.devitem is None:
self.close()
return
self.deviceName.setText('Device: %s' % self.devname)
self.setWindowTitle('Control %s' % self.devname)
self.settingsBtn = self.buttonBox.button(
QDialogButtonBox.RestoreDefaults)
self.settingsBtn.clicked.connect(self.on_settingsBtn_clicked)
# trigger parameter poll
self.client.eval('%s.pollParams()' % self.devname, None)
# now get all cache keys pertaining to the device and set the
# properties we want
params = self.client.getDeviceParams(self.devname)
self.paraminfo = self.client.getDeviceParamInfo(self.devname)
self.paramvalues = dict(params)
# put parameter values in the list widget
self.paramItems.clear()
self.paramList.clear()
for key, value in sorted(iteritems(params)):
if self.paraminfo.get(key):
# normally, show only userparams, except in expert mode
is_userparam = self.paraminfo[key]['userparam']
if is_userparam or self.device_panel._show_lowlevel:
self.paramItems[key] = item = \
QTreeWidgetItem(self.paramList, [key, str(value)])
# display non-userparams in grey italics, like lowlevel
# devices in the device list
if not is_userparam:
item.setFont(0, lowlevelFont[True])
item.setForeground(0, lowlevelBrush[True])
# set description label
if params.get('description'):
self.description.setText(params['description'])
else:
self.description.setVisible(False)
# check how to refer to the device in commands: if it is lowlevel,
# we need to use quotes
self.devrepr = srepr(self.devname) if params.get('lowlevel', True) \
else self.devname
# show "Set alias" group box if it is an alias device
if 'alias' in params:
if params['alias']:
self.deviceName.setText(self.deviceName.text() +
' (alias for %s)' % params['alias'])
alias_config = self.client.eval('session.alias_config', {})
self.aliasTarget = QComboBox(self)
self.aliasTarget.setEditable(True)
if self.devname in alias_config:
items = [t[0] for t in alias_config[self.devname]]
self.aliasTarget.addItems(items)
if params['alias'] in items:
self.aliasTarget.setCurrentIndex(
items.index(params['alias']))
self.targetLayoutAlias.takeAt(1).widget().deleteLater()
self.targetLayoutAlias.insertWidget(1, self.aliasTarget)
if self.client.viewonly:
self.setAliasBtn.setEnabled(False)
else:
self.aliasGroup.setVisible(False)
historyBtn = self.buttonBox.button(QDialogButtonBox.Reset)
# show current value/status if it is readable
if 'nicos.core.device.Readable' not in classes:
self.valueFrame.setVisible(False)
self.buttonBox.removeButton(historyBtn)
else:
self.valuelabel.setText(self.devitem.text(1))
self.statuslabel.setText(self.devitem.text(2))
self.statusimage.setPixmap(self.devitem.icon(0).pixmap(16, 16))
setForegroundBrush(self.statuslabel, self.devitem.foreground(2))
setBackgroundBrush(self.statuslabel, self.devitem.background(2))
# modify history button: add icon and set text
historyBtn.setIcon(QIcon(':/find'))
historyBtn.setText('Plot history...')
historyBtn.clicked.connect(self.on_historyBtn_clicked)
if self.client.viewonly:
self.limitFrame.setVisible(False)
self.targetFrame.setVisible(False)
return
# add a menu for the "More" button
self.moveBtns.clear()
menu = QMenu(self)
if 'nicos.core.mixins.HasLimits' in classes:
menu.addAction(self.actionSetLimits)
if 'nicos.core.mixins.HasOffset' in classes:
menu.addAction(self.actionAdjustOffset)
if 'nicos.devices.abstract.CanReference' in classes:
menu.addAction(self.actionReference)
if 'nicos.devices.abstract.Coder' in classes:
menu.addAction(self.actionSetPosition)
if 'nicos.core.device.Moveable' in classes:
if not menu.isEmpty():
menu.addSeparator()
menu.addAction(self.actionFix)
menu.addAction(self.actionRelease)
if 'nicos.core.mixins.CanDisable' in classes:
if not menu.isEmpty():
menu.addSeparator()
menu.addAction(self.actionEnable)
menu.addAction(self.actionDisable)
if not menu.isEmpty():
menuBtn = QPushButton('More', self)
menuBtn.setMenu(menu)
self.moveBtns.addButton(menuBtn, QDialogButtonBox.ResetRole)
def reset(checked):
self.device_panel.exec_command('reset(%s)' % self.devrepr)
def stop(checked):
self.device_panel.exec_command('stop(%s)' % self.devrepr,
immediate=True)
self.moveBtns.addButton('Reset', QDialogButtonBox.ResetRole)\
.clicked.connect(reset)
if 'nicos.core.device.Moveable' in classes or \
'nicos.core.device.Measurable' in classes:
self.moveBtns.addButton('Stop', QDialogButtonBox.ResetRole)\
.clicked.connect(stop)
# show target and limits if the device is Moveable
if 'nicos.core.device.Moveable' not in classes:
self.limitFrame.setVisible(False)
self.targetFrame.setVisible(False)
else:
if 'nicos.core.mixins.HasLimits' not in classes:
self.limitFrame.setVisible(False)
else:
self.limitMin.setText(str(params['userlimits'][0]))
self.limitMax.setText(str(params['userlimits'][1]))
# insert a widget to enter a new device value
# allowEnter=False because we catch pressing Enter ourselves
self.target = DeviceValueEdit(self,
dev=self.devname,
useButtons=True,
allowEnter=False)
self.target.setClient(self.client)
def btn_callback(target):
self.device_panel.exec_command('move(%s, %s)' %
(self.devrepr, srepr(target)))
self.target.valueChosen.connect(btn_callback)
self.targetFrame.layout().takeAt(1).widget().deleteLater()
self.targetFrame.layout().insertWidget(1, self.target)
def move(checked):
try:
target = self.target.getValue()
except ValueError:
return
self.device_panel.exec_command('move(%s, %s)' %
(self.devrepr, srepr(target)))
if self.target.getValue() is not Ellipsis: # (button widget)
self.moveBtn = self.moveBtns.addButton(
'Move', QDialogButtonBox.AcceptRole)
self.moveBtn.clicked.connect(move)
else:
self.moveBtn = None
if params.get('fixed') and self.moveBtn:
self.moveBtn.setEnabled(False)
self.moveBtn.setText('(fixed)')
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 __init__(self, parent, view, tb):
QDialog.__init__(self, parent)
loadUi(self, 'dialogs/traceback.ui')
self.tb = tb
self.view = view
self.client = parent.client
assert tb.startswith(TB_HEADER)
# split into frames and message
frames = []
message = ''
curframe = []
for line in tb.splitlines():
if line.startswith(' '): # frame local variable
try:
name, v = line.split('=', 1)
except ValueError:
pass # most probably the "^" line of a SyntaxError
else:
if curframe:
curframe[2][name.strip()] = v.strip()
elif line.startswith(' '): # frame source code
if curframe:
curframe[1] = line
elif line.startswith(' '): # frame file/line
curframe = [line.strip(), '', {}, None, None]
frames.append(curframe)
elif line.startswith(TB_CAUSE_MSG):
curframe[-2] = message
elif line.startswith(TB_CONTEXT_MSG):
curframe[-1] = message
elif line.startswith(TB_HEADER):
message = '' # only collect the message of the final exc
else:
message += line
button = QPushButton('To clipboard', self)
self.buttonBox.addButton(button, QDialogButtonBox.ActionRole)
def copy():
QApplication.clipboard().setText(tb+'\n', QClipboard.Selection)
QApplication.clipboard().setText(tb+'\n', QClipboard.Clipboard)
button.clicked.connect(copy)
def line_item(msg):
item = QTreeWidgetItem(self.tree, [msg])
item.setFirstColumnSpanned(True)
return item
self.message.setText(message[:200])
self.tree.setFont(view.font())
boldfont = QFont(view.font())
boldfont.setBold(True)
for filename, line, bindings, cause, context in frames:
line_item(filename)
code_item = line_item(line)
code_item.setFont(0, boldfont)
for var, value in bindings.items():
QTreeWidgetItem(code_item, ['', var, value])
if cause:
line_item(cause)
line_item('')
line_item(TB_CAUSE_MSG).setFont(0, boldfont)
line_item('')
elif context:
line_item(context)
line_item('')
line_item(TB_CONTEXT_MSG).setFont(0, boldfont)
line_item('')
line_item(message)
def __init__(self, setupname, display_order, representative):
QTreeWidgetItem.__init__(self, [setupname, '', ''], SETUP_TYPE)
self.sortkey = (display_order, setupname)
self.representative = representative
def line_item(msg):
item = QTreeWidgetItem(self.tree, [msg])
item.setFirstColumnSpanned(True)
return item
def loadNicosData(self):
while self.topLevelItemCount() > 0:
self.takeTopLevelItem(0)
# list of topLevelItems representing the directories in
# nicos_*: for example instruments, ...
self.topLevelItems = []
for directory in setupcontroller.setup_directories:
self.topLevelItems.append(
QTreeWidgetItem([directory], ItemTypes.Directory))
self.addTopLevelItems(self.topLevelItems)
# ask the controller to return the setups for current directory
# add the setups as childitems
for setup_directory in self.topLevelItems:
# directories can neither be dragged nor have something dropped on
setup_directory.setFlags(setup_directory.flags()
& ~Qt.ItemIsDragEnabled
& ~Qt.ItemIsDropEnabled)
setup_directory.setIcon(
0, QIcon(path.join(getResDir(), 'folder.png')))
for setup in setupcontroller.setup_directories[
setup_directory.text(0)]:
treeWidgetItem = QTreeWidgetItem([setup.name], ItemTypes.Setup)
# scripts cannot be dragged, but they can have
# something dropped on them (a device).
treeWidgetItem.setFlags(treeWidgetItem.flags()
& ~Qt.ItemIsDragEnabled)
treeWidgetItem.setIcon(
0, QIcon(path.join(getResDir(), 'setup.png')))
treeWidgetItem.setup = setup
setup_directory.addChild(treeWidgetItem)
# setup for this directory has been loaded, add the devices.
currentIndex = 0
while currentIndex < setup_directory.childCount():
currentItem = setup_directory.child(currentIndex)
setup = currentItem.setup
devices = setup.devices.keys()
for device in devices:
# read setup and add all the devices as child tree items
deviceItem = QTreeWidgetItem([device], ItemTypes.Device)
# devices can be dragged, but they can't have something
# dropped on them.
deviceItem.setFlags(deviceItem.flags()
& ~Qt.ItemIsDropEnabled)
deviceItem.device = setup.devices[device]
currentItem.addChild(deviceItem)
# icons for all devices
deviceIndex = 0
while deviceIndex < currentItem.childCount():
currentItem.child(deviceIndex).setIcon(
0, QIcon(path.join(getResDir(), 'device.png')))
deviceIndex += 1
currentIndex += 1
self.setSortingEnabled(True)
self.sortByColumn(0, Qt.AscendingOrder)
