#!/usr/bin/env python
#############################################################################
##
## This file is part of Taurus
##
## http://taurus-scada.org
##
## Copyright 2011 CELLS / ALBA Synchrotron, Bellaterra, Spain
##
## Taurus is free software: you can redistribute it and/or modify
## it under the terms of the GNU Lesser General Public License as published by
## the Free Software Foundation, either version 3 of the License, or
## (at your option) any later version.
##
## Taurus is distributed in the hope that it will be useful,
## but WITHOUT ANY WARRANTY; without even the implied warranty of
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
## GNU Lesser General Public License for more details.
##
## You should have received a copy of the GNU Lesser General Public License
## along with Taurus. If not, see <http://www.gnu.org/licenses/>.
##
#############################################################################
"""This module provides a set of basic Taurus widgets based on QLabel"""
__all__ = ["TaurusStateLabel", "TaurusValueLabel"]
__docformat__ = 'restructuredtext'
from taurus.external.qt import Qt
import taurus.core
from taurus.qt.qtgui.util import QT_ATTRIBUTE_QUALITY_PALETTE, QT_DEVICE_STATE_PALETTE
from taurus.qt.qtgui.base import TaurusBaseWidget
[docs]class TaurusValueLabel(Qt.QLabel, TaurusBaseWidget):
"""
A widget that represents the read value of an attribute.
.. deprecated::
Use :class:`taurus.qt.qtgui.display.TaurusLabel` instead.
The following features are present:
* The background color changes with the attribute quality according to the :ref:`color-guide`
* The attribute value is displayed according to the attribute format
* Supports all data types and formats (although it is designed mainly for SCALAR format)
* A tooltip is automatically generated displaying additional attribute information
* If the size of the widget is too small to display the entire value, the text changes to
a symbolic link that opens a dialog with the attribute value when clicked
This widget emits the following signals (excluding signals of the super classes):
**modelChanged**:
- *Signature*: ``modelChanged(const QString &) -> None``
- *Description*: the signal is emmited when the model for this widget
changes either by direct model manipulation, change of the useParentModel
and change of the parent model (if useParentModel is set to True)
Example::
import sys
from taurus.external.qt import Qt
from taurus.qt.qtgui.display import TaurusValueLabel
app = Qt.QApplication(sys.argv)
w = TaurusValueLabel()
w.model = 'sys/taurustest/1/position'
w.setVisible(True)
sys.exit(app.exec_())
.. image:: /_static/label01.png
:align: center
"""
__pyqtSignals__ = ("modelChanged(const QString &)",)
def __init__(self, parent = None, designMode = False, background = 'quality'):
name = self.__class__.__name__
self.call__init__wo_kw(Qt.QLabel, parent)
self.call__init__(TaurusBaseWidget, name, designMode=designMode)
self.setSizePolicy(Qt.QSizePolicy.Expanding, Qt.QSizePolicy.Preferred)
self.setTextInteractionFlags (Qt.Qt.TextSelectableByMouse|Qt.Qt.LinksAccessibleByMouse)
self.setAlignment(Qt.Qt.AlignRight|Qt.Qt.AlignTrailing|Qt.Qt.AlignVCenter)
self._charWidth = self.font().pointSize()
self._showState = False
self._showValueStateAsBackground = False
self.defineBackground(background)
self.connect(self, Qt.SIGNAL("linkActivated (const QString&)"), self.showFullValueDialog)
self._text = ''
[docs] def defineBackground(self, background):
background = str(background).lower()
self.setShowQuality(background == 'quality')
self.setShowState(background == 'state')
self.setShowValueStateAsBackground(background == 'value_state')
self.__background = background;
# The minimum size of the widget (a limit for the user)
[docs] def minimumSizeHint(self):
return Qt.QSize(20, 20)
# # The default size of the widget
# def sizeHint(self):
# return Qt.QSize(60, 22)
# #return Qt.QSize(Qt.QLabel.sizeHint(self).width(), 24)
def _stateListener(self, s, t, v):
# this method exists to force state to have at least one listener
# when showState is set to True
pass
@Qt.pyqtSignature("setShowState(bool)")
[docs] def setShowState(self, showState):
'''Whether or not to show the device state as background color.
Note: obviously, setShowState(True) forces setShowQuality(False) !'''
if showState == self._showState:
return
if showState and self.getShowQuality():
self.setShowQuality(False)
self._showState = showState
modelObj = self.getModelObj()
if modelObj is not None:
s = modelObj.getParent().getStateObj()
if showState:
s.addListener(self._stateListener)
else:
s.removeListener(self._stateListener)
self.updateStyle()
[docs] def getShowState(self):
"""either or not to show the state as a background color"""
return self._showState
[docs] def resetShowState(self):
self.setShowState(False)
@Qt.pyqtSignature("setShowValueStateAsBackground(bool)")
[docs] def setShowValueStateAsBackground(self, showState):
'''Whether or not to show the value as background color.
The attribute value must be a state!
Note: obviously, forces setShowState(False) and setShowQuality(False)
'''
if showState:
self.setShowQuality(False)
self.setShowState(False)
self._showValueStateAsBackground = showState
[docs] def getShowValueStateAsBackground(self):
"""either or not to show the state as a background color"""
return self._showValueStateAsBackground
[docs] def resetShowValueStateAsBackground(self):
self.setShowValueStateAsBackground(False)
#-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-
# TaurusBaseWidget overwriting
#-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-
[docs] def getModelClass(self):
return taurus.core.taurusattribute.TaurusAttribute
[docs] def isReadOnly(self):
return True
[docs] def updateStyle(self, extra=''):
if self.getShowQuality():
quality = getattr(self.getModelValueObj(), 'quality', None)
ss = QT_ATTRIBUTE_QUALITY_PALETTE.qtStyleSheet(quality)
elif self.getShowState():
try: state = self.getModelObj().getParent().getState()
except Exception:
state = None
ss = QT_DEVICE_STATE_PALETTE.qtStyleSheet(state)
elif self.getShowValueStateAsBackground():
value = getattr(self.getModelValueObj(), 'value', None)
ss = QT_DEVICE_STATE_PALETTE.qtStyleSheet(value)
else:
ss = "background-color: transparent; color:black;"
ss = """TaurusValueLabel {
border-style: outset;
border-width: 2px;
border-color: rgba(255,255,255,128);
%s %s}""" % (ss, extra)
self.setStyleSheet(ss)
TaurusBaseWidget.updateStyle(self)
[docs] def validateDisplay(self):
'''Checks that the display fits in the widget and sets it to "..." if it does not'''
trimmedtext = "<a href='...'>...</a>"
self._text = self.text()
if Qt.QLabel.sizeHint(self).width() > self.size().width():
self.setToolTip(self.getFormatedToolTip(showValue=True) )
self._setText(trimmedtext)
self.updateStyle()
return False
return True
[docs] def showFullValueDialog(self,*args):
Qt.QMessageBox.about(self, "Full text", self._text)
[docs] def handleEvent(self, evt_src, evt_type, evt_value):
'''reimplemented to check that the display fits the size each time that the value changes'''
TaurusBaseWidget.handleEvent(self, evt_src, evt_type, evt_value)
self.validateDisplay()
[docs] def resizeEvent(self,event):
#We recheck the Display every time we resize
self.updateStyle()
self.setText(self._text) #We set the original (untrimmed) text to force a validation from scratch.
self.validateDisplay()
Qt.QLabel.resizeEvent(self,event)
[docs] def setModel(self, m):
oldModelObj = self.getModelObj()
TaurusBaseWidget.setModel(self, m)
newModelObj = self.getModelObj()
if self.getShowState():
if oldModelObj is not None:
s = oldModelObj.getParent().getStateObj()
s.removeListener(self._stateListener)
if newModelObj is not None:
s = newModelObj.getParent().getStateObj()
s.addListener(self._stateListener)
@classmethod
[docs] def getQtDesignerPluginInfo(cls):
return None
# ret = TaurusBaseWidget.getQtDesignerPluginInfo()
# ret['module'] = 'taurus.qt.qtgui.display'
# ret['group'] = 'Taurus Widgets [Old]'
# ret['icon'] = ":/designer/label.png"
# return ret
#-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-
# QT property definition
#-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-
#: This property holds the unique URI string representing the model name
#: with which this widget will get its data from. The convention used for
#: the string can be found :ref:`here <model-concept>`.
#:
#: In case the property :attr:`useParentModel` is set to True, the model
#: text must start with a '/' followed by the attribute name.
#:
#: **Access functions:**
#:
#: * :meth:`TaurusBaseWidget.getModel`
#: * :meth:`TaurusValueLabel.setModel`
#: * :meth:`TaurusBaseWidget.resetModel`
#:
#: .. seealso:: :ref:`model-concept`
model = Qt.pyqtProperty("QString", TaurusBaseWidget.getModel,setModel,
TaurusBaseWidget.resetModel)
#: This property holds whether or not this widget should search in the
#: widget hierarchy for a model prefix in a parent widget.
#:
#: **Access functions:**
#:
#: * :meth:`TaurusBaseWidget.getUseParentModel`
#: * :meth:`TaurusBaseWidget.setUseParentModel`
#: * :meth:`TaurusBaseWidget.resetUseParentModel`
#:
#: .. seealso:: :ref:`model-concept`
useParentModel = Qt.pyqtProperty("bool", TaurusBaseWidget.getUseParentModel,
TaurusBaseWidget.setUseParentModel,
TaurusBaseWidget.resetUseParentModel)
#: This property holds whether or not this widget should fill the background
#: with the attribute quality/device state according to the
#: :ref:`color-guide`
#:
#: **Access functions:**
#:
#: * :meth:`TaurusBaseWidget.getShowQuality`
#: * :meth:`TaurusBaseWidget.setShowQuality`
#: * :meth:`TaurusBaseWidget.resetShowQuality`
#:
#: .. seealso:: :ref:`color-guide`
showQuality = Qt.pyqtProperty("bool", TaurusBaseWidget.getShowQuality,
TaurusBaseWidget.setShowQuality,
TaurusBaseWidget.resetShowQuality)
#: This property holds whether or not this widget should display the current
#: value of the model as text. Setting this to False is useful when you just
#: want to represent the quality/state as background color in a small space
#:
#: **Access functions:**
#:
#: * :meth:`TaurusBaseWidget.getShowText`
#: * :meth:`TaurusBaseWidget.setShowText`
#: * :meth:`TaurusBaseWidget.resetShowText`
showText = Qt.pyqtProperty("bool", TaurusBaseWidget.getShowText,
TaurusBaseWidget.setShowText,
TaurusBaseWidget.resetShowText)
#: This property holds the contents of a the popup menu as an XML string.
#:
#: **Access functions:**
#:
#: * :meth:`TaurusBaseWidget.getTaurusPopupMenu`
#: * :meth:`TaurusBaseWidget.setTaurusPopupMenu`
#: * :meth:`TaurusBaseWidget.resetTaurusPopupMenu`
#:
#: .. seealso:: :ref:`popupmenu-tutorial`
taurusPopupMenu = Qt.pyqtProperty("QString", TaurusBaseWidget.getTaurusPopupMenu,
TaurusBaseWidget.setTaurusPopupMenu,
TaurusBaseWidget.resetTaurusPopupMenu)
[docs]class TaurusStateLabel(TaurusValueLabel):
'''
.. deprecated::
Use :class:`taurus.qt.qtgui.display.TaurusLabel` instead.
'''
def __init__(self, parent = None, designMode = False):
self.call__init__(TaurusValueLabel, parent=parent, designMode=designMode, background = 'value_state')
self.setAlignment(Qt.Qt.AlignCenter)
@Qt.pyqtSignature("setModel(QString)")
[docs] def setModel(self,model):
""" Added to allow setModel(device_name); assuming that State attribute
is the desired model. To inherit the parent model but with a non
'State' named attribute, use slash: '/TheAttribute'
"""
try:
if str(model).count('/')<3 and str(model)[0]!='/':
model = str(model)+'/State'
except Exception:
pass
TaurusBaseWidget.setModel(self,model)
@classmethod
[docs] def getQtDesignerPluginInfo(cls):
return None
# ret = TaurusValueLabel.getQtDesignerPluginInfo()
# ret['icon'] = ":/designer/state.png"
# return ret
#-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-
# QT properties
#-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-
model = Qt.pyqtProperty("QString", TaurusBaseWidget.getModel, setModel,
TaurusBaseWidget.resetModel)
def main():
"""hello"""
import sys
import taurus.qt.qtgui.application
Application = taurus.qt.qtgui.application.TaurusApplication
app = Application.instance()
owns_app = app is None
if owns_app:
import taurus.core.util.argparse
parser = taurus.core.util.argparse.get_taurus_parser()
parser.usage = "%prog [options] <full_attribute_name(s)>"
app = Application(sys.argv, cmd_line_parser=parser)
args = app.get_command_line_args()
if len(args) > 0:
models = map(str.lower, args)
else:
models = [ 'sys/tg_test/1/%s' % a for a in ('state', 'status', 'double_scalar' ) ]
w = Qt.QWidget()
layout = Qt.QGridLayout()
w.setLayout(layout)
for model in models:
if model.endswith('state'):
label = TaurusStateLabel()
else:
label = TaurusValueLabel()
label.model = model
layout.addWidget(label)
w.show()
if owns_app:
sys.exit(app.exec_())
else:
return w
if __name__ == '__main__':
main()