def setData(self, index, qvalue):
taurus_role = index.model().role(index.column())
str_value = Qt.from_qvariant(qvalue, str)
if taurus_role in (ChannelView.Channel, ChannelView.Conditioning,
ChannelView.NXPath, ChannelView.DataType):
data = str_value
elif taurus_role in (ChannelView.Enabled, ChannelView.Output):
data = Qt.from_qvariant(qvalue, bool)
elif taurus_role == ChannelView.PlotType:
data = PlotType[str_value]
elif taurus_role == ChannelView.Normalization:
data = Normalization[str_value]
elif taurus_role == ChannelView.PlotAxes:
data = [a for a in str_value.split('|')]
elif taurus_role == ChannelView.Shape:
s = str_value
try:
data = eval(s, {}, {})
if not isinstance(data, (tuple, list)):
raise ValueError
except:
from taurus.core.util.log import Logger
Logger(self.__class__.__name__).error('Invalid shape %s', s)
data = ()
else:
raise NotImplementedError('Unknown role')
ch_name, ch_data = self.itemData()
key = self.itemdata_keys_map[taurus_role]
ch_data[key] = data
def __init__(self,
parent=None,
name='',
queue=None,
method=None,
cursor=None,
sleep=5000):
"""
Parent most not be None and must be a TaurusGraphicsScene!
"""
Qt.QThread.__init__(self, parent)
self.name = name
self.log = Logger('TaurusEmitterThread(%s)' % self.name)
self.log.setLogLevel(self.log.Info)
self.queue = queue or Queue.Queue()
self.todo = Queue.Queue()
self.method = method
self.cursor = Qt.QCursor(
Qt.Qt.WaitCursor) if cursor is True else cursor
self._cursor = False
self.timewait = sleep
self.emitter = Qt.QObject()
self.emitter.moveToThread(Qt.QApplication.instance().thread())
# Mandatory!!! if parent is set before changing thread it could lead to
# segFaults!
self.emitter.setParent(Qt.QApplication.instance())
self._done = 0
# Moved to the end to prevent segfaults ...
Qt.QObject.connect(self.emitter, Qt.SIGNAL("doSomething"),
self._doSomething)
Qt.QObject.connect(self.emitter, Qt.SIGNAL("somethingDone"), self.next)
def onModuleSelected(self):
modulename = str(self.moduleNameLE.text())
try:
__import__(modulename)
# We use this because __import__('x.y') returns x instead of y !!
self.module = sys.modules[modulename]
self.moduleNameLE.setStyleSheet('QLineEdit {color: green}')
except Exception as e:
Logger().debug(repr(e))
self.moduleNameLE.setStyleSheet('QLineEdit {color: red}')
return
# inspect the module to find the members we want (classes or widgets
# inheriting from QWidget)
members = inspect.getmembers(self.module)
classnames = sorted([
n for n, m in members
if inspect.isclass(m) and issubclass(m, Qt.QWidget)
])
widgetnames = sorted(
[n for n, m in members if isinstance(m, Qt.QWidget)])
self.membersCB.clear()
self.membersCB.addItem(self.CHOOSE_TYPE_TXT)
self.membersCB.addItems(classnames)
if classnames and widgetnames:
self.membersCB.InsertSeparator(self.membersCB.count())
self.membersCB.addItems(classnames)
def fromPanel(panel):
name = str(panel.objectName())
classname = panel.getWidgetClassName()
modulename = panel.getWidgetModuleName()
# in the case of classes known to the TaurusWidgetFactory,
# do not store the modulename
if modulename.startswith('taurus.') and \
classname in TaurusWidgetFactory().getWidgetClassNames():
modulename = None
widgetname = None
floating = panel.isFloating()
sharedDataWrite = None
sharedDataRead = None
model = getattr(panel.widget(), 'model', None)
if model is None or isinstance(model, basestring):
pass
elif hasattr(model, '__iter__'):
# if model is a sequence, convert to space-separated string
try:
model = " ".join(model)
except Exception, e:
msg = ('Cannot convert %s to a space-separated string: %s' %
(model, e))
Logger().debug(msg)
model = None
def parse(filename=None, factory=None):
if filename is None or factory is None:
return
_, p = new_parser()
print " \n\n\n zrobioby nowy parser"
print "1: ", _
print "2: ", p
p.factory = factory
p.modelStack = []
p.modelStack2 = []
res = None
try:
filename = os.path.realpath(filename)
f = open(filename)
#print f.read()
print "\n\n\n otwprzylem plik w try"
res = yacc.parse(f.read()) #nie bylo tracking=True, dodalem
#for i in res:
# print "res i: ", i
print "\n\n SPARSOWALEMW TRY! \n"
print "\n RES: ", res
except:
print "\n\n NIE SPARSOWALEM W TRY"
log = Logger('JDraw Parser')
#print "\n\n LOG1: ", log, "\n\n\n stop"
log.warning("Failed to parse %s" % filename)
#print "\n\n exec info: ?"
log.debug("Details:", exc_info=1)
return res
def main():
from taurus.core.util.log import Logger
from taurus.qt.qtgui.util import TaurusWidgetFactory
Logger.setLogLevel(Logger.Debug)
_log = Logger(__name__)
try:
wf = TaurusWidgetFactory()
klasses = wf.getWidgetClasses()
ok_nb, skipped_nb, e1_nb, e2_nb, e3_nb, e4_nb = 0, 0, 0, 0, 0, 0
for widget_klass in klasses:
name = widget_klass.__name__
#_log.debug("Processing %s" % name)
if name in _SKIP:
#_log.debug("Skipped %s" % name)
skipped_nb += 1
continue
# if getQtDesignerPluginInfo does not exist, returns None or raises
# an exception: forget the widget
cont = False
try:
qt_info = widget_klass.getQtDesignerPluginInfo()
if qt_info is None:
#_log.debug("E1: Canceled %s (getQtDesignerPluginInfo)" % name)
e1_nb += 1
cont = True
except AttributeError:
#_log.debug("E2: Canceled %s (widget doesn't have getQtDesignerPluginInfo())" % name)
e2_nb += 1
cont = True
except Exception, e:
#_log.debug("E3: Canceled %s (%s)" % (name, str(e)))
e3_nb += 1
cont = True
if cont:
continue
for k in ('module', ):
if not qt_info.has_key(k):
#_log.debug("E4: Canceled %s (getQtDesignerPluginInfo doesn't have key %s)" % (name, k))
e4_nb += 1
cont = True
if cont:
continue
plugin_klass = build_qtdesigner_widget_plugin(widget_klass)
plugin_klass_name = plugin_klass.__name__
globals()[plugin_klass_name] = plugin_klass
_plugins[plugin_klass_name] = plugin_klass
ok_nb += 1
#_log.debug("DONE processing %s" % name)
_log.info("Inpected %d widgets. %d (OK), %d (Skipped), %d (E1), %d (E2), %d (E3), %d(E4)" % (
len(klasses), ok_nb, skipped_nb, e1_nb, e2_nb, e3_nb, e4_nb))
_log.info("E1: getQtDesignerPluginInfo() returns None")
_log.info("E2: widget doesn't implement getQtDesignerPluginInfo()")
_log.info("E3: getQtDesignerPluginInfo() throws exception")
_log.info(
"E4: getQtDesignerPluginInfo() returns dictionary with missing key (probably 'module' key)")
def __init__(self, inst, props, *args, **kwargs):
self._inst_name = inst
self._log = Logger("Controller.%s" % inst)
self._log.log_obj.setLevel(getLogLevel())
self._args = args
self._kwargs = kwargs
self._api_version = self._findAPIVersion()
for prop_name, prop_value in list(props.items()):
setattr(self, prop_name, prop_value)
def new_parser(optimize=None, debug=0, outputdir=None):
log = Logger('JDraw Parser')
if optimize is None:
from taurus import tauruscustomsettings
optimize = getattr(tauruscustomsettings, 'PLY_OPTIMIZE', 1)
if outputdir is None:
# use '.taurus' dir in the user "home" dir
outputdir = os.path.join(os.path.expanduser('~'), '.taurus')
# create the output dir if it didn't exist
if not os.path.exists(outputdir):
os.makedirs(outputdir)
debuglog = None
if debug:
debuglog = log
common_kwargs = dict(optimize=optimize,
outputdir=outputdir,
debug=debug,
debuglog=debuglog,
errorlog=log)
# lex/yacc v<3.0 do not accept debuglog or errorlog keyword args
if int(lex.__version__.split('.')[0]) < 3:
common_kwargs.pop('debuglog')
common_kwargs.pop('errorlog')
try:
_path = os.path.join(outputdir, 'jdraw_lextab.py')
jdraw_lextab = imp.load_source('jdraw_lextab', _path)
except:
jdraw_lextab = 'jdraw_lextab'
try:
_path = os.path.join(outputdir, 'jdraw_yacctab.py')
jdraw_yacctab = imp.load_source('jdraw_lextab', _path)
except:
jdraw_yacctab = 'jdraw_yacctab'
# Lexer
l = lex.lex(lextab=jdraw_lextab, **common_kwargs)
# Yacc
try:
p = yacc.yacc(tabmodule=jdraw_yacctab,
debugfile=None,
write_tables=1,
**common_kwargs)
except Exception, e:
msg = (
'Error creating jdraw parser.\n' +
'HINT: Try removing jdraw_lextab.* and jdraw_yacctab.* from %s' %
outputdir)
raise RuntimeError(msg)
def setUp(self):
self.logger = Logger('BaseControllerTestCase')
if self.DEBUG:
self.logger.setLogLevel(Logger.Debug)
if self.KLASS is None:
raise Exception('Ctrl klass has not been defined')
name = 'test_ctrl'
self.ctrl = self.KLASS(name, self.PROPS)
self.pre_AddDevice_hook()
self.ctrl.AddDevice(self.AXIS)
def initializePage(self):
try:
widget = self.wizard().getPanelDescription().getWidget()
except Exception as e:
Logger().debug(repr(e))
widget = None
# prevent the user from changing the model if it was already set
if isinstance(widget,
TaurusBaseComponent) and widget.getModelName() != '':
self.modelLE.setText("(already set by the chosen widget)")
self.modelGB.setEnabled(False)
# try to get the SDM as if we were in a TaurusGui app
try:
if isinstance(Qt.qApp.SDM, SharedDataManager):
sdm = Qt.qApp.SDM
except Exception as e:
Logger().debug(repr(e))
sdm = None
#@todo set selection filter in modelChooser based on the widget's modelclass
self.itemDelegate = CommItemDelegate(widget=widget, sdm=sdm)
self.commLV.setItemDelegate(self.itemDelegate)
def getMemberDescription(self):
try:
membername = str(self.membersCB.currentText())
member = getattr(self.module, membername, None)
result = {'modulename': self.module.__name__}
except Exception as e:
Logger().debug('Cannot get member description: %s', repr(e))
return None
if inspect.isclass(member):
result['classname'] = membername
else:
result['widgetname'] = membername
return result
def new_parser(optimize=None, debug=0, outputdir=None):
log = Logger('JDraw Parser')
if optimize is None:
from taurus import tauruscustomsettings
optimize = getattr(tauruscustomsettings, 'PLY_OPTIMIZE', 1)
if outputdir is None:
outputdir = os.path.dirname(os.path.realpath(__file__))
#print "\n\n\n OUTPUT dir: ", outputdir
debuglog = None
if debug:
debuglog = log
common_kwargs = dict(optimize=optimize,
outputdir=outputdir,
debug=debug,
debuglog=debuglog,
errorlog=log)
# lex/yacc v<3.0 do not accept debuglog or errorlog keyword args
if int(lex.__version__.split('.')[0]) < 3:
common_kwargs.pop('debuglog')
common_kwargs.pop('errorlog')
try:
from . import jdraw_lextab
except ImportError:
jdraw_lextab = 'jdraw_lextab'
try:
from . import jdraw_yacctab
except ImportError:
jdraw_yacctab = 'jdraw_yacctab'
# Lexer
l = lex.lex(lextab=jdraw_lextab, **common_kwargs)
# Yacc
try:
p = yacc.yacc(tabmodule=jdraw_yacctab,
debugfile=None,
write_tables=1,
**common_kwargs)
except Exception, e:
print "\n\n Nie udal sie yacc yaccc"
msg = ('Error while parsing. You may solve it by:\n' + \
' a) removing jdraw_lextab.* and jdraw_yacctab.* from\n' +\
' %s , or...\n' % os.path.dirname(__file__) + \
' b) setting PLY_OPTIMIZE=0 in tauruscustomsettings.py')
raise RuntimeError(msg)
def __init__(self,
parent=None,
name='',
queue=None,
method=None,
cursor=None,
sleep=5000,
polling=0,
loopwait=5):
"""
Parent must be not None and must be a TaurusGraphicsScene!
:param queue: pass an external action queue (optional)
:param method: action processor (e.g. modelSetter)
:param cursor: QCursor during process (optional)
:param sleep: delay in ms before thread start
:param polling: process actions at fix period (milliseconds)
:param loopwait: wait N milliseconds between actions
"""
Qt.QThread.__init__(self, parent)
self.name = name
self.log = Logger('TaurusEmitterThread(%s)' % self.name)
self.log.setLogLevel(self.log.Info)
self.queue = queue or Queue()
self.todo = Queue()
self.method = method
self.cursor = Qt.QCursor(
Qt.Qt.WaitCursor) if cursor is True else cursor
self._cursor = False
self.timewait = int(sleep)
self.polling = int(polling)
self.loopwait = int(loopwait)
if self.polling:
self.refreshTimer = Qt.QTimer()
self.refreshTimer.timeout.connect(self.onRefresh)
else:
self.refreshTimer = None
self.emitter = QEmitter()
self.emitter.moveToThread(Qt.QApplication.instance().thread())
# Mandatory!!! if parent is set before changing thread it could lead to
# segFaults!
self.emitter.setParent(Qt.QApplication.instance())
self._done = 0
# Moved to the end to prevent segfaults ...
self.emitter.doSomething.connect(self._doSomething)
if not self.refreshTimer:
self.emitter.somethingDone.connect(self.next)
def __init__(self, parent=None, name='', queue=None, method=None, cursor=None, sleep=5000, log=Logger.Warning, start=True):
self.name = name
self.log = Logger('SingletonWorker(%s)' % self.name)
self.log.setLogLevel(log)
self.log.info('At SingletonWorker.__init__(%s)' % self.name)
self.parent = parent
self.method = method
self._running = False
if SingletonWorker._thread is None:
SingletonWorker._thread = TaurusEmitterThread(
parent, name='SingletonWorker', cursor=cursor, sleep=sleep)
self.thread = SingletonWorker._thread
self.queue = queue or Queue.Queue()
if start:
self.start()
def fromPanel(panel):
name = str(panel.objectName())
classname = panel.getWidgetClassName()
modulename = panel.getWidgetModuleName()
# in the case of classes known to the TaurusWidgetFactory,
# do not store the modulename
if modulename.startswith('taurus.') and \
classname in TaurusWidgetFactory().getWidgetClassNames():
modulename = None
widgetname = None
floating = panel.isFloating()
sharedDataWrite = None
sharedDataRead = None
model = getattr(panel.widget(), 'model', None)
if model is None or isinstance(model, string_types):
pass
elif hasattr(model, '__iter__'):
# if model is a sequence, convert to space-separated string
try:
model = " ".join(model)
except Exception as e:
msg = ('Cannot convert %s to a space-separated string: %s' %
(model, e))
Logger().debug(msg)
model = None
else:
# ignore other "model" attributes (they are not from Taurus)
model = None
return PanelDescription(name,
classname=classname,
modulename=modulename,
widgetname=widgetname,
floating=floating,
sharedDataWrite=sharedDataWrite,
sharedDataRead=sharedDataRead,
model=model,
icon=panel.icon,
model_in_config=panel.model_in_config,
modifiable_by_user=panel.modifiable_by_user,
widget_formatter=panel.widget_formatter,
widget_properties=panel.widget_properties)
def parse(filename=None, factory=None):
if filename is None or factory is None:
return
_, p = new_parser()
p.factory = factory
p.modelStack = []
p.modelStack2 = []
res = None
try:
filename = os.path.realpath(filename)
f = open(filename)
res = yacc.parse(f.read())
except:
log = Logger('JDraw Parser')
log.warning("Failed to parse %s" % filename)
log.debug("Details:", exc_info=1)
return res
def setData(self, index, qvalue):
ch_name, ch_data = self.itemData()
taurus_role = index.model().role(index.column())
key = self.itemdata_keys_map[taurus_role]
if taurus_role in (ChannelView.Channel, ChannelView.Conditioning,
ChannelView.NXPath, ChannelView.Enabled,
ChannelView.Output, ChannelView.ValueRefEnabled,
ChannelView.ValueRefPattern):
data = qvalue
elif taurus_role == ChannelView.DataType:
if len(qvalue.strip()) == 0:
# empty strings are considered as unspecified data type
try:
ch_data.pop(key)
except KeyError:
pass # data_type key may not be there if not specified
return
else:
data = qvalue
elif taurus_role == ChannelView.PlotType:
data = PlotType[qvalue]
elif taurus_role == ChannelView.Normalization:
data = Normalization[qvalue]
elif taurus_role == ChannelView.PlotAxes:
data = [a for a in qvalue.split('|')]
elif taurus_role == ChannelView.Shape:
s = qvalue
try:
data = eval(s, {}, {})
if not isinstance(data, (tuple, list)):
raise ValueError
except:
from taurus.core.util.log import Logger
Logger(self.__class__.__name__).error('Invalid shape %s', s)
data = ()
else:
raise NotImplementedError('Unknown role')
ch_data[key] = data
from __future__ import print_function
import inspect
from taurus.external.qt import Qt
from taurus.external.qt import QtDesigner
from taurus.core.util.log import Logger
def Q_TYPEID(class_name):
""" Helper function to generate an IID for Qt."""
return "com.trolltech.Qt.Designer.%s" % class_name
designer_logger = Logger("PyQtDesigner")
class TaurusWidgetPlugin(QtDesigner.QPyDesignerCustomWidgetPlugin):
"""TaurusWidgetPlugin"""
def __init__(self, parent=None):
QtDesigner.QPyDesignerCustomWidgetPlugin.__init__(self)
self._log = Logger(self._getWidgetClassName(), designer_logger)
self.initialized = False
def initialize(self, formEditor):
""" Overwrite if necessary. Don't forget to call this method in case you
want the generic taurus extensions in your widget."""
if self.isInitialized():
return
def __init__(self, parent=None):
QtDesigner.QPyDesignerCustomWidgetPlugin.__init__(self)
self._log = Logger(self._getWidgetClassName(), designer_logger)
self.initialized = False
def __init__(self, parent=None, **kwargs):
if Qt.QT_VERSION < 0x050000:
# Workaround for issue when using super with pyqt<5
BaseConfigurableClass.__init__(self)
PlotWidget.__init__(self, parent=parent, **kwargs)
else:
super(TaurusPlot, self).__init__(parent=None, **kwargs)
# Compose with a Logger
self._logger = Logger(name=self.__class__.__name__)
self.debug = self._logger.debug
self.info = self._logger.info
self.warning = self._logger.warning
self.error = self._logger.error
# set up cyclic color generator
self._curveColors = LoopList(CURVE_COLORS)
self._curveColors.setCurrentIndex(-1)
# add save & retrieve configuration actions
menu = self.getPlotItem().getViewBox().menu
saveConfigAction = QtGui.QAction("Save configuration", menu)
saveConfigAction.triggered.connect(self._onSaveConfigAction)
menu.addAction(saveConfigAction)
loadConfigAction = QtGui.QAction("Retrieve saved configuration", menu)
loadConfigAction.triggered.connect(self._onRetrieveConfigAction)
menu.addAction(loadConfigAction)
self.registerConfigProperty(self._getState, self.restoreState, "state")
# add legend tool
legend_tool = PlotLegendTool(self)
legend_tool.attachToPlotItem(self.getPlotItem())
# add model chooser
self._model_chooser_tool = TaurusXYModelChooserTool(self)
self._model_chooser_tool.attachToPlotItem(self.getPlotItem(), self,
self._curveColors)
# add Y2 axis
self._y2 = Y2ViewBox()
self._y2.attachToPlotItem(self.getPlotItem())
# add plot configuration dialog
self._cprop_tool = CurvesPropertiesTool(self)
self._cprop_tool.attachToPlotItem(self.getPlotItem(), y2=self._y2)
# add a data inspector
inspector_tool = DataInspectorTool(self)
inspector_tool.attachToPlotItem(self.getPlotItem())
# enable Autorange
self.getPlotItem().getViewBox().enableAutoRange(True)
self._y2.enableAutoRange(True)
# Register config properties
self.registerConfigDelegate(self._model_chooser_tool, "XYmodelchooser")
self.registerConfigDelegate(self._y2, "Y2Axis")
self.registerConfigDelegate(self._cprop_tool, "CurvePropertiesTool")
self.registerConfigDelegate(legend_tool, "legend")
self.registerConfigDelegate(inspector_tool, "inspector")
servers
It is not a replacement of the Tango Starter Device Server since this is much
more limited in scope.
"""
__docformat__ = 'restructuredtext'
import os
import time
import subprocess
import PyTango
from taurus.core.util.log import Logger
_log = Logger('Starter')
class Starter(object):
'''Abstract class for managing (starting, stopping, registering and
removing) a Tango Device Server.
Derived classes should provide the methods for starting and stopping a
device.
'''
def __init__(self, ds_name):
'''
:param ds_name: (str) Device Server name in the form "server/instance"
'''
self.ds_name = ds_name
self.dserver_name = 'dserver/%s' % ds_name
def log_dependencies():
from taurus.core.util.log import Logger
l = Logger("taurus")
for msg in _check_dependencies(forlog=True):
if msg[0] != -1:
l.info(msg[1])
'getStandardIcon', 'getElementTypeToolTip', 'getElementTypeIconName',
'getElementTypeIcon', 'getElementTypePixmap', 'getElementTypeSize',
'getDevStateToolTip', 'getDevStateIcon', 'getDevStatePixmap',
'getThemeMembers'
]
__docformat__ = 'restructuredtext'
import os
from taurus.external.qt import Qt
from taurus.core.taurusbasetypes import TaurusElementType, TaurusDevState
from taurus.core.util.log import Logger, tep14_deprecation
__LOGGER = Logger(__name__)
ElemType = TaurusElementType
Size = Qt.QSize
__INITIALIZED = False
# Theme capacity was only added in Qt 4.6
__THEME_CAPACITY = hasattr(Qt.QIcon, "fromTheme")
# Uncomment the following line to force NOT to use OS theme.
#__THEME_CAPACITY = False
__THEME_MEMBERS = {}
# Default width, height and QSize constants
__DW = 70
__DH = 24
def _getLogger():
global _LOGGER
if _LOGGER is None:
_LOGGER = Logger('Grabber')
return _LOGGER
def __init__(self, parent=None, **kwargs):
if Qt.QT_VERSION < 0x050000:
# Workaround for issue when using super with pyqt<5
BaseConfigurableClass.__init__(self)
PlotWidget.__init__(self, parent=parent, **kwargs)
else:
super(TaurusTrend, self).__init__(parent=parent, **kwargs)
# Compose with a Logger
self._logger = Logger(name=self.__class__.__name__)
self.debug = self._logger.debug
self.info = self._logger.info
self.warning = self._logger.warning
self.error = self._logger.error
# set up cyclic color generator
self._curveColors = LoopList(CURVE_COLORS)
self._curveColors.setCurrentIndex(-1)
plot_item = self.getPlotItem()
menu = plot_item.getViewBox().menu
# add save & retrieve configuration actions
saveConfigAction = QtGui.QAction("Save configuration", menu)
saveConfigAction.triggered.connect(self.saveConfigFile)
menu.addAction(saveConfigAction)
loadConfigAction = QtGui.QAction("Retrieve saved configuration", menu)
loadConfigAction.triggered.connect(self.loadConfigFile)
menu.addAction(loadConfigAction)
self.registerConfigProperty(self._getState, self.restoreState, "state")
# add legend tool
legend_tool = PlotLegendTool(self)
legend_tool.attachToPlotItem(plot_item)
# add model chooser
self._model_chooser_tool = TaurusXYModelChooserTool(
self, itemClass=TaurusTrendSet, showX=False)
self._model_chooser_tool.attachToPlotItem(self.getPlotItem(), self,
self._curveColors)
# add Y2 axis
self._y2 = Y2ViewBox()
self._y2.attachToPlotItem(plot_item)
# Add time X axis
axis = DateAxisItem(orientation="bottom")
axis.attachToPlotItem(plot_item)
# add plot configuration dialog
self._cprop_tool = CurvesPropertiesTool(self)
self._cprop_tool.attachToPlotItem(plot_item, y2=self._y2)
# add data inspector widget
inspector_tool = DataInspectorTool(self)
inspector_tool.attachToPlotItem(self.getPlotItem())
# add force read tool
self._fr_tool = ForcedReadTool(self)
self._fr_tool.attachToPlotItem(self.getPlotItem())
# Add the auto-pan ("oscilloscope mode") tool
self._autopan = XAutoPanTool()
self._autopan.attachToPlotItem(self.getPlotItem())
# Register config properties
self.registerConfigDelegate(self._model_chooser_tool, "XYmodelchooser")
# self.registerConfigDelegate(self._y2, "Y2Axis")
self.registerConfigDelegate(self._cprop_tool, "CurvePropertiesTool")
self.registerConfigDelegate(legend_tool, "legend")
self.registerConfigDelegate(self._fr_tool, "forceread")
self.registerConfigDelegate(inspector_tool, "inspector")
