def __init__(self, parent=None, designMode=False):
TaurusWidget.__init__(self, parent, designMode)
self.setLayout(Qt.QVBoxLayout())
self._splitter = Qt.QSplitter()
self._splitter.setOrientation(Qt.Qt.Vertical)
self.layout().addWidget(self._splitter)
self._frame = TaurusWidget(self)
self._frame.setLayout(Qt.QGridLayout())
self._scrollArea = TaurusScrollArea(self)
self._scrollArea.setWidget(self._frame)
self._scrollArea.setWidgetResizable(True)
self._splitter.addWidget(self._scrollArea)
self._outputTE = Qt.QTextEdit()
self._outputTE.setReadOnly(True)
self._splitter.addWidget(self._outputTE)
#self._splitter.moveSplitter(self._splitter.getRange(0)[-1], 0)
self._cmdWidgets = []
self._paramWidgets = []
self._viewFilters = []
self._defaultParameters = []
self._sortKey = lambda x: x.cmd_name
self._operatorViewFilter = lambda x: x.disp_level == PyTango.DispLevel.OPERATOR
# self.setLayout(Qt.QGridLayout())
self.modelChanged.connect(self._updateCommandWidgets)
def __init__(self, parent=None, designMode=False):
TaurusWidget.__init__(self, parent, designMode=designMode)
self.loadUi(filename="computeu.ui")
self.connect(self._ui.ComputeButton, Qt.SIGNAL(
"clicked()"), self.compute_u)
def __init__(self, parent=None, designMode=False):
TaurusWidget.__init__(self, parent=parent, designMode=designMode)
self._xAttr = None
self._yAttr = None
self._arrayEditor = ArrayEditor()
self.fromFileBT = Qt.QPushButton('Read From File')
self.toFileBT = Qt.QPushButton('Write To File')
self.fromAttrBT = Qt.QPushButton('Read From Device')
self.toAttrBT = Qt.QPushButton('Write To Device')
self.fromAttrBT.setEnabled(False)
self.toAttrBT.setEnabled(False)
layout = Qt.QGridLayout(self)
layout.addWidget(self._arrayEditor, 0, 0, 1, 4)
layout.addWidget(self.fromFileBT, 1, 0)
layout.addWidget(self.toFileBT, 1, 1)
layout.addWidget(self.fromAttrBT, 1, 2)
layout.addWidget(self.toAttrBT, 1, 3)
self.fromFileBT.clicked[()].connect(self.onFromFile)
self.toFileBT.clicked[()].connect(self.onToFile)
self.fromAttrBT.clicked[()].connect(self.onFromAttr)
self.toAttrBT.clicked[()].connect(self.onToAttr)
def setModel(self, model):
'''
reimplemented from :class:`TaurusWidget`. A door device name is
expected as the model
'''
TaurusWidget.setModel(self, model)
if self.door is not None:
self.disconnect(self.door, Qt.SIGNAL('macroStatusUpdated'), self._statusUpdated)
self.disconnect(self.door, Qt.SIGNAL('resultUpdated'), self._resultUpdated)
# disable management of Door Tango States
self.door.getAttribute('State').removeListener(self.door_state_listener)
self.disconnect(self.door_state_listener, Qt.SIGNAL('doorStateChanged'), self._doorStateChanged)
self.door_state_listener = None
try: self.door = taurus.Device(model)
except: return
self.connect(self.door, Qt.SIGNAL('macroStatusUpdated'), self._statusUpdated)
self.connect(self.door, Qt.SIGNAL('resultUpdated'), self._resultUpdated)
# Manage Door Tango States
self.door_state_listener = DoorStateListener()
self.connect(self.door_state_listener, Qt.SIGNAL('doorStateChanged'), self._doorStateChanged)
self.door.getAttribute('State').addListener(self.door_state_listener)
def setModel(self, model):
oldModelObj = self.getModelObj()
if oldModelObj is not None:
self.disconnect(oldModelObj, Qt.SIGNAL("macrosUpdated"), self.macroComboBox.onMacrosUpdated)
TaurusWidget.setModel(self, model)
newModelObj = self.getModelObj()
self.connect(newModelObj, Qt.SIGNAL("macrosUpdated"), self.macroComboBox.onMacrosUpdated)
def __init__(self, parent=None, selectables=None, buttonsPos=None, designMode=None):
TaurusWidget.__init__(self, parent)
if selectables is None:
selectables = [taurus.core.taurusbasetypes.TaurusElementType.Attribute, taurus.core.taurusbasetypes.TaurusElementType.Member,
taurus.core.taurusbasetypes.TaurusElementType.Device]
self._selectables = selectables
# tree
self._deviceTree = TaurusDbTreeWidget(
perspective=taurus.core.taurusbasetypes.TaurusElementType.Device)
self._deviceTree.getQModel().setSelectables(self._selectables)
self._deviceTree.setUseParentModel(True)
# toolbar
self._toolbar = Qt.QToolBar("TangoSelector toolbar")
self._toolbar.setIconSize(Qt.QSize(16, 16))
self._toolbar.setFloatable(False)
self._addSelectedAction = self._toolbar.addAction(
Qt.QIcon.fromTheme("list-add"), "Add selected", self.onAddSelected)
# defines the layout
self.setButtonsPos(buttonsPos)
self._deviceTree.recheckTaurusParent() # NOT WORKING????
# @todo: This is Workaround because UseSetParentModel is giving trouble again!
self.modelChanged.connect(self._deviceTree.setModel)
def __init__(self, parent=None, designMode=False):
TaurusWidget.__init__(self, parent, designMode=designMode)
self.loadUi(filename="reflectionseditor.ui")
self._ui.ApplyButton.clicked.connect(self.apply)
self._ui.ClearButton.clicked.connect(self.clear)
def setModel(self, model):
oldModelObj = self.getModelObj()
if oldModelObj is not None:
oldModelObj.macrosUpdated.disconnect(
self.macroComboBox.onMacrosUpdated)
TaurusWidget.setModel(self, model)
newModelObj = self.getModelObj()
newModelObj.macrosUpdated.connect(self.macroComboBox.onMacrosUpdated)
def setModel(self, model):
'''This implementation propagates the model to the read and write widgets.
You may reimplement it to do things like passing different models to each.
'''
if self.readWidget is not None:
self.readWidget.setModel(model)
if self.writeWidget is not None:
self.writeWidget.setModel(model)
TaurusWidget.setModel(self, model)
def setModel(self, model):
oldModelObj = self.getModelObj()
if oldModelObj is not None:
# TODO: check if macrosUpdated signal exists
oldModelObj.macrosUpdated.disconnect(
self.macroComboBox.onMacrosUpdated)
TaurusWidget.setModel(self, model)
newModelObj = self.getModelObj()
newModelObj.macrosUpdated.connect(
self.macroComboBox.onMacrosUpdated)
def applyConfig(self, configdict, **kwargs):
"""extending :meth:`TaurusBaseWidget.applyConfig` to restore the splitter config
:param configdict: (dict)
.. seealso:: :meth:`TaurusBaseWidget.applyConfig`, :meth:`createConfig`
"""
# first do the basic stuff...
TaurusWidget.applyConfig(self, configdict, **kwargs)
# restore the splitter config
self._splitter.restoreState(
Qt.QByteArray(configdict['splitter/state']))
def __init__(self, parent=None, designMode=False):
TaurusWidget.__init__(self, parent, designMode=designMode)
self.loadUi(filename="ubmatrix.ui")
self._ui.UpdateButton.clicked.connect(self.update_values)
self._ui.ComputeUButton.clicked.connect(self.compute_ub)
self._ui.ReflectionsListButton.clicked.connect(
self.reflections_list_window)
self._ui.EditReflectionsButton.clicked.connect(
self.edit_reflections_window)
self._ui.AffineButton.clicked.connect(self.affine)
self._ui.AddCrystalButton.clicked.connect(self.add_select_crystal)
def __init__(self, parent=None, designMode=False):
TaurusWidget.__init__(self, parent, designMode=designMode)
self.loadUi(filename="hklscan.ui")
self._ui.hklStartScanButton.clicked.connect(self.start_hklscan)
self._ui.hklStopScanButton.clicked.connect(self.stop_hklscan)
self._ui.hklDisplayAnglesButton.clicked.connect(self.display_angles)
self._ui.MacroServerConnectionButton.clicked.connect(
self.open_macroserver_connection_panel)
# Create a global SharedDataManager
Qt.qApp.SDM = SharedDataManager(self)
def __init__(self, parent=None, designMode=False):
TaurusWidget.__init__(self, parent, designMode)
self.loadUi()
self.door = None
self.door_state_listener = None
self.macro_name = ''
self.macro_args = []
self.macro_id = None
self.running_macro = None
self.ui.progress.setValue(0)
self.ui.button.setCheckable(True)
self.ui.button.clicked.connect(self._onButtonClicked)
def __init__(self, parent=None, selectables=None, host=None, designMode=None, singleModel=False):
'''Creator of TaurusModelChooser
:param parent: (QObject) parent for the dialog
:param selectables: (list<TaurusElementType>) if passed, only elements of the tree whose
type is in the list will be selectable.
:param host: (QObject) Tango host to be explored by the chooser
:param designMode: (bool) needed for taurusdesigner but ignored here
:param singleModel: (bool) If True, the selection will be of just one
model. Otherwise (default) a list of models can be selected
'''
TaurusWidget.__init__(self, parent)
if host is None:
host = taurus.Authority().getNormalName()
self._allowDuplicates = False
self.setLayout(Qt.QVBoxLayout())
self.tree = TaurusModelSelectorTree(
selectables=selectables, buttonsPos=Qt.Qt.BottomToolBarArea)
self.tree.setModel(host)
self.list = TaurusModelList()
self.list.setSelectionMode(Qt.QAbstractItemView.ExtendedSelection)
applyBT = Qt.QToolButton()
applyBT.setToolButtonStyle(Qt.Qt.ToolButtonTextBesideIcon)
applyBT.setText('Apply')
applyBT.setIcon(Qt.QIcon("status:available.svg"))
self.setSingleModelMode(singleModel)
# toolbar
self._toolbar = self.tree._toolbar
self._toolbar.addAction(self.list.removeSelectedAction)
self._toolbar.addAction(self.list.removeAllAction)
self._toolbar.addAction(self.list.moveUpAction)
self._toolbar.addAction(self.list.moveDownAction)
self._toolbar.addSeparator()
self._toolbar.addWidget(applyBT)
self.layout().addWidget(self.tree)
self.layout().addWidget(self.list)
# self.tree.setUseParentModel(True) #It does not work!!!!
# @todo: This is Workaround because UseSetParentModel is giving trouble again!
self.modelChanged.connect(self.tree.setModel)
# connections:
self.tree.addModels.connect(self.addModels)
applyBT.clicked.connect(self._onUpdateModels)
def __init__(self, parent=None, designMode=False):
TaurusWidget.__init__(self, parent, designMode)
self._viewFilters = []
self._operatorViewFilter = lambda x: x.disp_level == PyTango.DispLevel.OPERATOR
self.setLayout(Qt.QVBoxLayout())
self._form = TaurusForm(parent=self)
self.layout().addWidget(self._form)
self.registerConfigDelegate(self._form)
self.modelChanged.connect(self._updateAttrWidgets)
self._sortKey = lambda x: x.name
def __init__(self, *args, **kwargs):
TaurusWidget.__init__(self, *args)
fileModel = kwargs.get("fileModel", None)
if fileModel is None:
fileModel = HDF5Widget.FileModel()
self.__fileModel = fileModel
self.treeWidget = HDF5Widget.HDF5Widget(self.__fileModel)
self.treeWidget.setSizePolicy(Qt.QSizePolicy(Qt.QSizePolicy.Expanding, Qt.QSizePolicy.Expanding))
# self.infoWidget = HDF5Info.HDF5InfoWidget()
self.__previewStack = Qt.QStackedWidget()
self.__currentPreview = None
# layout
self.__splitter = Qt.QSplitter()
self.__splitter.setOrientation(Qt.Qt.Vertical)
self.__splitter.addWidget(self.treeWidget)
# self.__splitter.addWidget(self.infoWidget)
self.__splitter.addWidget(self.__previewStack)
self.setLayout(Qt.QVBoxLayout())
self.layout().addWidget(self.__splitter)
# Actions
self.setContextMenuPolicy(Qt.Qt.ActionsContextMenu)
self.openFileAction = Qt.QAction(Qt.QIcon.fromTheme("document-open"), "Open Data File...", self)
self.togglePreviewAction = Qt.QAction(Qt.QIcon("actions:view.svg"), "Show/Hide preview", self)
self.togglePreviewAction.setCheckable(True)
self.togglePreviewAction.setChecked(True)
self.addActions([self.openFileAction, self.togglePreviewAction])
# Toolbar
self._toolbar = Qt.QToolBar("NeXus browser toolbar")
self._toolbar.setIconSize(Qt.QSize(16, 16))
self._toolbar.setFloatable(False)
self._toolbar.addActions([self.openFileAction, self.togglePreviewAction])
self.layout().setMenuBar(self._toolbar)
# connections
self.__fileModel.sigFileAppended.connect(self.treeWidget.fileAppended)
self.treeWidget.sigHDF5WidgetSignal.connect(self.onHDF5WidgetSignal)
self.openFileAction.triggered[()].connect(self.openFile)
self.togglePreviewAction.toggled.connect(self.__previewStack.setVisible)
# configuration
self.registerConfigProperty(
self.togglePreviewAction.isChecked, self.togglePreviewAction.setChecked, "showPreview"
)
def getQtDesignerPluginInfo(cls):
ret = TaurusWidget.getQtDesignerPluginInfo()
ret['module'] = 'linacstartupsynoptic'
ret['group'] = 'Taurus Linac Main'
ret['icon'] = ':/designer/tabwidget.png'
ret['container'] = False
return ret
def getQtDesignerPluginInfo(cls):
ret = TaurusWidget.getQtDesignerPluginInfo()
ret['module'] = 'widgets.TaurusDevCombo'
ret['group'] = 'Taurus Views'
ret['container'] = ':/designer/frame.png'
ret['container'] = False
return ret
def getQtDesignerPluginInfo(cls):
ret = TaurusWidget.getQtDesignerPluginInfo()
ret['module'] = 'taurus.qt.qtgui.panel'
ret['icon'] = "designer:listview.png"
ret['container'] = False
ret['group'] = 'Taurus Views'
return ret
def getQtDesignerPluginInfo(cls):
ret = TaurusWidget.getQtDesignerPluginInfo()
ret['module'] = 'taurus.qt.qtgui.panel'
ret['icon'] = ":/designer/listview.png"
ret['container'] = False
ret['group'] = 'Taurus Views'
return ret
def getQtDesignerPluginInfo(cls):
ret = TaurusWidget.getQtDesignerPluginInfo()
ret['module'] = 'computeu'
ret['group'] = 'Taurus Containers'
ret['container'] = ':/designer/frame.png'
ret['container'] = False
return ret
def getQtDesignerPluginInfo(cls):
ret = TaurusWidget.getQtDesignerPluginInfo()
ret['module'] = 'hklscan'
ret['group'] = 'Taurus Containers'
ret['container'] = ':/designer/frame.png'
ret['container'] = True
return ret
def getQtDesignerPluginInfo(cls):
ret = TaurusWidget.getQtDesignerPluginInfo()
ret['module'] = 'egunlv'
ret['group'] = 'Taurus Linac Widgets'
ret['icon'] = ':/designer/widgetstack.png'
ret['container'] = False
return ret
def getQtDesignerPluginInfo(cls):
ret = TaurusWidget.getQtDesignerPluginInfo()
ret['module'] = 'linacplcwidget'
ret['group'] = 'Taurus Linac Widgets'
ret['icon'] = ':/designer/groupbox.png'
ret['container'] = False
return ret
def __init__(self, parent=None, designMode=False):
TaurusWidget.__init__(self, parent, designMode=designMode)
self.loadUi(filename="selectsignal.ui")
self.signalComboBox = SignalComboBox(self)
self.signalComboBox.setGeometry(QtCore.QRect(70, 50, 161, 27))
self.signalComboBox.setObjectName("SignalcomboBox")
self.connect(self.signalComboBox, Qt.SIGNAL(
"currentIndexChanged(QString)"), self.onSignalChanged)
self.doorName = None
self.door_device = None
registerExtensions()
def loadConfigFile(self, ifile=None):
self.info('In TaurusDevicePanel.loadConfigFile(%s)' % ifile)
if isinstance(ifile, file) or isinstance(ifile, str) and not ifile.endswith('.py'):
TaurusWidget.loadConfigFile(self, ifile)
else:
from imp import load_source
config_file = load_source('config_file', ifile)
af, cf, im = [getattr(config_file, x, None) for x in (
'AttributeFilters', 'CommandFilters', 'IconMap')]
if af is not None:
self.setAttributeFilters(af)
if cf is not None:
self.setCommandFilters(cf)
if im is not None:
self.setIconMap(im)
self.debug('AttributeFilters are:\n%s' % self.getAttributeFilters())
def getQtDesignerPluginInfo(cls):
ret = TaurusWidget.getQtDesignerPluginInfo()
ret['module'] = 'displayscanangles'
ret['group'] = 'Taurus Containers'
ret['container'] = 'y'
ret['container'] = False
return ret
def getQtDesignerPluginInfo(cls):
ret = TaurusWidget.getQtDesignerPluginInfo()
ret['module'] = 'diffractometeralignment'
ret['group'] = 'Taurus Containers'
ret['container'] = ':/designer/frame.png'
ret['container'] = False
return ret
def getQtDesignerPluginInfo(cls):
ret = TaurusWidget.getQtDesignerPluginInfo()
ret['module'] = 'deviceevents'
ret['group'] = 'Taurus Linac Widgets'
ret['container'] = ':/designer/frame.png'
ret['container'] = False
return ret
def getQtDesignerPluginInfo(cls):
ret = TaurusWidget.getQtDesignerPluginInfo()
ret['module'] = 'magnetsnapshot'
ret['group'] = 'Taurus Linac Snapshot'
ret['container'] = ':/designer/frame.png'
ret['container'] = False
return ret
def getQtDesignerPluginInfo(cls):
ret = TaurusWidget.getQtDesignerPluginInfo()
ret['module'] = 'computeu'
ret['group'] = 'Taurus Containers'
ret['container'] = ':/designer/frame.png'
ret['container'] = False
return ret
def getQtDesignerPluginInfo(cls):
ret = TaurusWidget.getQtDesignerPluginInfo()
ret["module"] = "taurus.qt.qtgui.extra_nexus"
ret["icon"] = "designer:listview.png"
ret["container"] = False
ret["group"] = "Taurus Views"
return ret
def __init__(self, parent=None, designMode=False):
TaurusWidget.__init__(self, parent, designMode=designMode)
self.loadUi(filename="selectsignal.ui")
self.signalComboBox = SignalComboBox(self)
self.signalComboBox.setGeometry(QtCore.QRect(70, 50, 161, 27))
self.signalComboBox.setObjectName("SignalcomboBox")
self.connect(self.signalComboBox,
Qt.SIGNAL("currentIndexChanged(QString)"),
self.onSignalChanged)
self.doorName = None
self.door_device = None
registerExtensions()
def setModel(self, device):
print self.__class__.__name__, "setModel", device
TaurusWidget.setModel(self, device)
self.device_and_state.setModel(device)
self.status_area.setModel(device)
if device:
self.form.setModel(
["%s/%s" % (device, attribute) for attribute in self.attrs])
attrname = "%s/%s" % (device, "Current")
self.valuebar.setModel(attrname)
# self.state_button.setModel(device)
attr = Attribute(attrname)
self.current_label.setText("%s [%s]" % (attr.label, attr.unit))
else:
self.form.setModel(None)
self.valuebar.setModel(None)
def __init__(self, *args):
TaurusWidget.__init__(self, *args)
self.setLayout(QtGui.QHBoxLayout())
self.layout().setMargin(0)
self.moveInButton = TaurusCommandButton(self)
self.moveInButton.setUseParentModel(True)
self.moveInButton.setCommand('MoveIn')
self.moveInButton.setCustomText('Move In')
self.moveOutButton = TaurusCommandButton(self)
self.moveOutButton.setUseParentModel(True)
self.moveOutButton.setCommand('MoveOut')
self.moveOutButton.setCustomText('Move Out')
self.layout().addWidget(self.moveInButton)
self.layout().addWidget(self.moveOutButton)
def __init__(self, parent=None, designMode=False):
TaurusWidget.__init__(self, parent, designMode)
self.loadUi()
self.ioreg_dev = None
self.alias_label = TaurusLabel()
self.alias_label.setBgRole('state')
self.value_label = PoolIORegisterReadWidget()
self.button_value_dict = {}
policy = self.value_label.sizePolicy()
policy.setHorizontalPolicy(Qt.QSizePolicy.Expanding)
self.value_label.setSizePolicy(policy)
self.ui.lo_state_read.addWidget(self.alias_label)
self.ui.lo_state_read.addWidget(self.value_label)
def __init__(self, parent=None, designMode=False,
readWClass=None, writeWClass=None,
enterEditTriggers=None, exitEditTriggers=None):
TaurusWidget.__init__(self, parent=parent, designMode=designMode)
self.setFocusPolicy(Qt.Qt.StrongFocus)
self.setLayout(Qt.QStackedLayout())
self.readWidget = None
self.writeWidget = None
# Use parameters from constructor args or defaults from class
self.readWClass = readWClass or self.readWClass
self.writeWClass = writeWClass or self.writeWClass
self.enterEditTriggers = enterEditTriggers or self.enterEditTriggers
self.exitEditTriggers = exitEditTriggers or self.exitEditTriggers
# classify the triggers
sc, et, sig = self._classifyTriggers(self.enterEditTriggers)
self.enterEditShortCuts = sc
self.enterEditEventTypes = et
self.enterEditSignals = sig
sc, et, sig = self._classifyTriggers(self.exitEditTriggers)
self.exitEditShortCuts = sc
self.exitEditEventTypes = et
self.exitEditSignals = sig
# Actions for entering and exiting the edit
self.enterEditAction = Qt.QAction("Start Editing", self)
self.enterEditAction.setShortcuts(self.enterEditShortCuts)
self.enterEditAction.setShortcutContext(
Qt.Qt.WidgetWithChildrenShortcut)
self.addAction(self.enterEditAction)
self.exitEditAction = Qt.QAction("Abort Editing", self)
self.exitEditAction.setShortcuts(self.exitEditShortCuts)
self.exitEditAction.setShortcutContext(
Qt.Qt.WidgetWithChildrenShortcut)
self.addAction(self.exitEditAction)
self.enterEditAction.triggered[()].connect(self._onEnterEditActionTriggered)
self.exitEditAction.triggered[()].connect(self._onExitEditActionTriggered)
# add read and write widgets
if self.readWClass is not None:
self.setReadWidget(self.readWClass())
if self.writeWClass is not None:
self.setWriteWidget(self.writeWClass())
def __init__(self, *args):
TaurusWidget.__init__(self, *args)
self.setLayout(QtGui.QHBoxLayout())
self.layout().setMargin(0)
self.layout().setSpacing(0)
self.led = TaurusLed(self)
self.led.setUseParentModel(True)
self.led.setModel('/State')
self.led.getFormatedToolTip = self.getFormatedToolTip
self.led.setSizePolicy(Qt.QSizePolicy.Fixed, Qt.QSizePolicy.Fixed)
self.label = ExpandingLabel()
self.label.setUseParentModel(True)
self.layout().addWidget(self.led)
self.layout().addWidget(self.label)
def __init__(self, parent=None, designMode=False):
TaurusWidget.__init__(self, parent, designMode=designMode)
self.loadUi(filename="hklscan.ui")
self.connect(self._ui.hklStartScanButton, Qt.SIGNAL("clicked()"),
self.start_hklscan)
self.connect(self._ui.hklStopScanButton, Qt.SIGNAL("clicked()"),
self.stop_hklscan)
self.connect(self._ui.hklDisplayAnglesButton, Qt.SIGNAL("clicked()"),
self.display_angles)
self.connect(self._ui.MacroServerConnectionButton,
Qt.SIGNAL("clicked()"),
self.open_macroserver_connection_panel)
# Create a global SharedDataManager
Qt.qApp.SDM = SharedDataManager(self)
def __init__(self, parent=None, designMode=False):
TaurusWidget.__init__(self, parent, designMode=designMode)
self.loadUi(filename="ubmatrix.ui")
self.connect(self._ui.UpdateButton, Qt.SIGNAL("clicked()"),
self.update_values)
self.connect(self._ui.ComputeUButton, Qt.SIGNAL("clicked()"),
self.compute_ub)
self.connect(self._ui.ReflectionsListButton, Qt.SIGNAL("clicked()"),
self.reflections_list_window)
self.connect(self._ui.EditReflectionsButton, Qt.SIGNAL("clicked()"),
self.edit_reflections_window)
self.connect(self._ui.AffineButton, Qt.SIGNAL("clicked()"),
self.affine)
self.connect(self._ui.AddCrystalButton, Qt.SIGNAL("clicked()"),
self.add_select_crystal)
def fillWithChildren(self):
frame = TaurusWidget()
frame.setLayout(Qt.QGridLayout())
frame.layout().addItem(Qt.QSpacerItem(
0, 0, Qt.QSizePolicy.Minimum, Qt.QSizePolicy.MinimumExpanding))
parent_name = None
if self.getUseParentModel():
parent_model = self.getParentModelObj()
if parent_model:
parent_name = parent_model.getFullName()
for i, model in enumerate(self.getModel()):
if not model:
continue
if parent_name:
# @todo: Change this (it assumes tango model naming!)
model = "%s/%s" % (parent_name, model)
klass, args, kwargs = self.getFormWidget(model=model)
widget = klass(frame, *args, **kwargs)
# @todo UGLY... See if this can be done in other ways... (this causes trouble with widget that need more vertical space , like PoolMotorTV)
widget.setMinimumHeight(20)
try:
widget.setCompact(self.isCompact())
widget.setModel(model)
widget.setParent(frame)
except:
# raise
self.warning(
'an error occurred while adding the child "%s". Skipping' % model)
self.traceback(level=taurus.Debug)
try:
widget.setModifiableByUser(self.isModifiableByUser())
except:
pass
try:
widget.setFormat(self.getFormat())
except Exception:
self.debug('Cannot set format %s to child %s',
self.getFormat(), model)
widget.setObjectName("__item%i" % i)
self.registerConfigDelegate(widget)
self._children.append(widget)
frame.layout().addItem(Qt.QSpacerItem(
0, 0, Qt.QSizePolicy.Minimum, Qt.QSizePolicy.MinimumExpanding))
self.scrollArea.setWidget(frame)
# self.scrollArea.setWidgetResizable(True)
self.scrollArea.setMinimumWidth(frame.layout().sizeHint().width() + 20)
def __init__(self, parent=None, designMode=False):
TaurusWidget.__init__(self, parent=parent, designMode=designMode)
self.setLayout(Qt.QVBoxLayout())
self.tree = QConfigEditorModel()
self.treeview = Qt.QTreeView()
self.tree.setHorizontalHeaderLabels(
['Configuration key', 'type', 'value'])
self.layout().addWidget(self.treeview)
self._toolbar = Qt.QToolBar("QConfigViewer Main toolBar")
self._toolbar.addAction(Qt.QIcon.fromTheme(
"document-open"), "Open File", self.loadFile)
self._toolbar.addAction(Qt.QIcon.fromTheme(
"document-save"), "Save File", self.saveFile)
self._toolbar.addAction(Qt.QIcon.fromTheme(
"edit-undo"), "Reload from file", self.restoreOriginal)
self.layout().setMenuBar(self._toolbar)
self.setWindowTitle('TaurusConfigEditor')
self.tree.showError.connect(self._showError)
def loadConfigFile(self, ifile=None):
self.debug('In TaurusDevicePanel.loadConfigFile(%s)' % ifile)
if isinstance(ifile, string_types) and ifile.endswith('.py'):
from imp import load_source
config_file = load_source('config_file', ifile)
af, cf, im = [
getattr(config_file, x, None)
for x in ('AttributeFilters', 'CommandFilters', 'IconMap')
]
if af is not None:
self.setAttributeFilters(af)
if cf is not None:
self.setCommandFilters(cf)
if im is not None:
self.setIconMap(im)
else:
TaurusWidget.loadConfigFile(self, ifile)
self.debug('AttributeFilters are:\n%s' % self.getAttributeFilters())
def __init__(self, preffix='', suffix='', labels=False, parent=None):
TaurusWidget.__init__(self, parent)
self.preffix = preffix
self.suffix = suffix
self.labels = labels
if preffix or suffix:
self.setWindowTitle('%s ... %s' % (preffix, suffix))
self.setLayout(Qt.QVBoxLayout())
self.bar = Qt.QWidget(self)
self.search = Qt.QLineEdit()
self.button = Qt.QPushButton('Load')
self.connect(self.button, Qt.SIGNAL("pressed()"), self.apply_search)
self.bar.setLayout(Qt.QHBoxLayout())
self.bar.layout().addWidget(self.search)
self.bar.layout().addWidget(self.button)
self.layout().addWidget(self.bar)
self.form = TaurusForm(self)
self.layout().addWidget(self.form)
def __init__(self, parent=None, designMode=False):
TaurusWidget.__init__(self, parent, designMode)
self.ioreg_dev = None
self.setLayout(Qt.QHBoxLayout())
self.layout().setContentsMargins(0, 0, 0, 0)
self.layout().setSpacing(0)
self.alias_label = TaurusLabel()
self.alias_label.setBgRole('state')
self.layout().addWidget(self.alias_label)
self.read_widget = PoolIORegisterReadWidget()
self.layout().addWidget(self.read_widget)
self.write_widget = PoolIORegisterWriteWidget()
self.layout().addWidget(self.write_widget)
def setModel(self, model):
'''Reimplemented from :meth:`TaurusWidget.setModel`'''
TaurusWidget.setModel(self, model)
model_obj = self.getModelObj()
if model_obj.isWritable() and self.defaultWriteMode != "r":
self._writeMode = True
else:
self.defaultWriteMode = "r"
if model_obj is not None:
self._tableView._attr = model_obj
if model_obj.type in [DataType.Integer, DataType.Float]:
if self._writeMode:
try:
default_unit = str(model_obj.wvalue.units)
except AttributeError:
default_unit = ''
else:
default_unit = str(model_obj.rvalue.units)
# TODO: fill the combobox with the compatible units
self._units.addItem("%s" % default_unit)
self._units.setCurrentIndex(self._units.findText(default_unit))
self._units.setEnabled(False)
else:
self._units.setVisible(False)
raiseException = False
if model_obj.data_format == DataFormat._2D:
try:
dim_x, dim_y = numpy.shape(model_obj.rvalue)
except ValueError:
raiseException = True
elif model_obj.data_format == DataFormat._1D:
try:
dim_x, dim_y = len(model_obj.rvalue), 1
except ValueError:
raiseException = True
else:
raiseException = True
if raiseException:
raise Exception('rvalue is invalid')
self._tableView.setModel([dim_x, dim_y])
self.setWriteMode(self._writeMode)
self._label.setModel(model)
def __init__(self, parent=None):
TaurusWidget.__init__(self, parent)
self.loadUi()
self.statusLabel.setUseParentModel(True)
self.statusLabel.setModel('/Status')
self.modeCB.setUseParentModel(True)
self.modeCB.setModel('/Mode')
self.type_attribute = None
self.mode_attribute = None
self.type_value = None
self.mode_value = None
self.modelChanged.connect(self.onModelChanged)
self.modeChanged.connect(self.onModeChanged)
self.typeChanged.connect(self.onTypeChanged)
def onSetFormatter(self):
"""Reimplemented from TaurusBaseWidget"""
# Form delegates se to the taurusvalues
format = TaurusWidget.onSetFormatter(self)
if format is not None:
for item in self.getItems():
rw = item.readWidget(followCompact=True)
if hasattr(rw, 'setFormat'):
rw.setFormat(format)
return format
def __init__(self, parent=None, designMode=False):
TaurusWidget.__init__(self, parent, designMode=designMode)
self.loadUi(filename="diffractometeralignment.ui")
self.selectsignal = SelectSignal()
self._ui.AlignmentStopButton.clicked.connect(self.stop_movements)
self._ui.AlignmentStoreReflectionButton.clicked.connect(
self.store_reflection)
self._ui.MacroServerConnectionButton.clicked.connect(
self.open_macroserver_connection_panel)
self._ui.SelectSignalButton.clicked.connect(
self.open_selectsignal_panel)
# Create a global SharedDataManager
Qt.qApp.SDM = SharedDataManager(self)
def getQtDesignerPluginInfo(cls):
ret = TaurusWidget.getQtDesignerPluginInfo()
ret['module'] = 'taurus.qt.qtgui.compact'
ret['group'] = 'Taurus R+W'
ret['icon'] = "designer:frame.png"
if (cls.readWClass or cls.readWClass) is None:
ret['container'] = True # for base classes
else:
# for classes which already define the subwidgets
ret['container'] = False
return ret
def setModifiableByUser(self, modifiable):
'''
sets whether the user can change the contents of the form
(e.g., via Modify Contents in the context menu)
Reimplemented from :meth:`TaurusWidget.setModifiableByUser`
:param modifiable: (bool)
.. seealso:: :meth:`TaurusWidget.setModifiableByUser`
'''
TaurusWidget.setModifiableByUser(self, modifiable)
self.chooseModelsAction.setEnabled(modifiable)
self.showButtonsAction.setEnabled(modifiable)
self.changeLabelsAction.setEnabled(modifiable)
self.compactModeAction.setEnabled(modifiable)
for item in self.getItems():
try:
item.setModifiableByUser(modifiable)
except:
pass
def getQtDesignerPluginInfo(cls):
"""Returns pertinent information in order to be able to build a valid
QtDesigner widget plugin
:return: (dict) a map with pertinent designer information"""
ret = TaurusWidget.getQtDesignerPluginInfo()
ret['module'] = 'taurus.qt.qtgui.plot'
ret['group'] = 'Taurus Input'
ret['icon'] = 'designer:arrayedit.png'
ret['container'] = False
return ret
def __init__(self, parent=None, designMode=False):
TaurusWidget.__init__(self, parent)
self.setLayout(Qt.QHBoxLayout())
# put a widget with a TaurusValue
w = Qt.QWidget()
w.setLayout(Qt.QGridLayout())
self._TaurusValue = TaurusValue(parent=w, designMode=designMode)
self._TaurusValue.setLabelWidgetClass(
LabelWidgetDragsDeviceAndAttribute)
self._TaurusValue.setLabelConfig('<dev_alias>')
self.layout().addWidget(w)
#...and a dev button next to the widget
self._devButton = TaurusDevButton(parent=self, designMode=designMode)
self._devButton.setText('')
self.layout().addWidget(self._devButton)
self.modelChanged.connect(self._updateTaurusValue)
def setModel(self, attrs):
if not attrs:
for att, col in zip(self.attributes, self._columns):
att and att.removeListener(col.event_received)
else:
try:
TaurusWidget.setModel(self, attrs[0].rsplit("/", 1)[0])
self.attributes = [Attribute(a) for a in attrs]
self.table.setColumnCount(len(attrs))
fmt = "%s [%s]"
labels = []
for a in self.attributes:
config = a.getConfig()
label = fmt % (config.getLabel(), config.getUnit())
labels.append(label)
self.table.setHorizontalHeaderLabels(labels)
header = self.table.horizontalHeader()
header.setResizeMode(QtGui.QHeaderView.Stretch)
# Check if there are any columns at all
row_lengths = [len(a.read().value) for a in self.attributes
if a.read().quality == PyTango.AttrQuality.ATTR_VALID]
if not any(row_lengths):
return None
self.table.setRowCount(max(row_lengths))
self._values = {}
self._config = {}
self._columns = []
for i, att in enumerate(self.attributes):
# JFF: this is a workaround for a behavior in Taurus. Just
# adding a new listener to each attribute does not work, the
# previous ones get removed for some reason.
col = AttributeColumn(self, i)
self._columns.append(col) # keep reference to prevent GC
att.addListener(col.event_received)
except PyTango.DevFailed:
pass
def __init__(self, parent=None, designMode=False, defaultWriteMode=None):
TaurusWidget.__init__(self, parent=parent, designMode=designMode)
self._tableView = TaurusValuesIOTable(self)
l = Qt.QGridLayout()
l.addWidget(self._tableView, 1, 0)
self._tableView.itemDelegate().editorCreated.connect(
self._onEditorCreated)
if defaultWriteMode is None:
self.defaultWriteMode = "rw"
else:
self.defaultWriteMode = defaultWriteMode
self._label = TaurusLabel()
self._label.setBgRole('quality')
self._label.setFgRole('quality')
self._units = Qt.QComboBox()
self._applyBT = Qt.QPushButton('Apply')
self._cancelBT = Qt.QPushButton('Cancel')
self._applyBT.clicked.connect(self.okClicked)
self._cancelBT.clicked.connect(self.cancelClicked)
self._rwModeCB = Qt.QCheckBox()
self._rwModeCB.setText('Write mode')
self._rwModeCB.toggled.connect(self.setWriteMode)
lv = Qt.QHBoxLayout()
lv.addWidget(self._label)
lv.addWidget(self._units)
l.addLayout(lv, 2, 0)
l.addWidget(self._rwModeCB, 0, 0)
lv = Qt.QHBoxLayout()
lv.addWidget(self._applyBT)
lv.addWidget(self._cancelBT)
l.addLayout(lv, 3, 0)
self._writeMode = False
self.setLayout(l)
self._initActions()
def __init__(self, parent=None):
TaurusWidget.__init__(self, parent=parent)
self.plot = ArchivingPlot(self)
self.legend = ArchivingLegend(self.plot)
self.modelchooser = None
self.plot.updateSig[bool, bool].connect(self.updateAll)
self.t0, self.t1 = 0, 0
msi = self.modelchooser
if msi:
# Connect button
msi.modelsAdded.connect(onAddXYModel)
self.pb = Qt.QProgressBar()
self.pb.setGeometry(0, 0, 300, 25)
self.info('building layout')
self.setLayout(Qt.QVBoxLayout())
self.tc = TangoArchivingTimeSelector()
l1 = Qt.QSplitter()
l1.addWidget(self.plot)
self.plot.setTimeChooser(self.tc)
l1.addWidget(self.legend)
l0 = Qt.QWidget()
l0.setLayout(Qt.QHBoxLayout())
l0.layout().addWidget(self.tc)
self.refresh = Qt.QPushButton(Qt.QIcon.fromTheme("view-refresh"),
"refresh tgarch curves")
self.refresh.clicked.connect(self.onRefresh)
self.layout().addWidget(l0)
l0.layout().addWidget(self.refresh)
self.layout().addWidget(l1, 10)
self.layout().addWidget(self.pb)
self.updateProgressBar()
self.addXYModelsSig.connect(self.addXYModels)
class Bug169_Test(BaseWidgetTestCase, unittest.TestCase):
'''
Test bug169:
AttributeError: type object 'TaurusConfigurationProxy' has no attribute
'buildModelName'.
See: http://sf.net/p/tauruslib/tickets/65/
.. seealso: :class:`taurus.qt.qtgui.test.base.BaseWidgetTestCase`
'''
_klass = TaurusLabel
def setUp(self):
BaseWidgetTestCase.setUp(self)
self._widget.setModel('sys/tg_test/1/double_scalar#label')
self._expectedModelClass = self._widget.getModelClass()
self._parent = TaurusWidget()
self._parent.setModel('sys/tg_test/1')
self._widget.setUseParentModel(True)
self._widget.setParent(self._parent)
def test_bug169(self):
'''Check if setModel works when using parent model'''
self._widget.setModel('/double_scalar#label')
self.assertMaxDeprecations(0)
def test_relativemodelclass(self):
'''Check consistency in modelClass when using parent model (re: bug169)
'''
try:
self._widget.setModel('/double_scalar#label')
finally:
mc = self._widget.getModelClass()
msg = ('getModelClass() inconsistency:\n expected: %s\n got: %s' %
(self._expectedModelClass, mc))
self.assertEqual(self._expectedModelClass, mc, msg)
self.assertMaxDeprecations(0)
def setModel(self, circuit):
print "----------------- MagnetListPanel setModel", circuit
TaurusWidget.setModel(self, circuit)
db = PyTango.Database()
print('------------- 1 ------------')
if circuit:
print('------------- 1 ------------')
magnets = db.get_device_property(circuit,
"MagnetProxies")["MagnetProxies"]
print('------------- 1 ------------', magnets)
test_iko = False
if test_iko:
if "SQF" in magnets[0]:
self.table.setModel(
magnets,
["State", "TemperatureInterlock", "shuntResistance"])
else:
self.table.setModel(magnets,
["State", "TemperatureInterlock"])
else:
self.table.setModel(circuit)
self.table.setModel("%s/%s" % (circuit, 'long_scalar'))
else:
self.table.setModel(None)
def createConfig(self, allowUnpickable=False):
'''
extending :meth:`TaurusBaseWidget.createConfig`
:param alllowUnpickable: (bool)
:return: (dict<str,object>) configurations (which can be loaded with :meth:`applyConfig`).
.. seealso: :meth:`TaurusBaseWidget.createConfig`, :meth:`applyConfig`
'''
# get the basic config
configdict = TaurusWidget.createConfig(
self, allowUnpickable=allowUnpickable)
# store the splitter config
configdict['splitter/state'] = self._splitter.saveState().data()
return configdict
