def resetModes(self):
self.logger().show()
try:
attr = self.getModel()
schema = self.getSchema()
print('%s: resetModes(%s)' % (fun.time2str(), attr))
qm = Qt.QMessageBox(Qt.QMessageBox.Warning, 'Confirmation',
'%s archiving will be stopped' % attr,
Qt.QMessageBox.Ok | Qt.QMessageBox.Cancel)
r = qm.exec_()
if r == Qt.QMessageBox.Ok:
if not self.api:
self.api = pta.api(self.getSchema().lower(),
logger=self.logger())
self.api.log = self.logger()
#self.emit(Qt.SIGNAL('archive'),attr,modes)
Qt.QApplication.instance().setOverrideCursor(
Qt.QCursor(Qt.Qt.WaitCursor))
thr = threading.Thread(target=self.startArchiving,
args=(attr, {}))
QLoggerDialog._threads = filter(Thread.is_alive,
self.threads()) + [thr]
thr.start()
else:
self.logger().hide()
except:
traceback.print_exc()
print('%s: resetModes(...): running!' % (fun.time2str()))
def wrapper(instance, f, *args, **kwargs):
try:
from taurus.qt.qtgui.plot import TaurusPlot
obj = ArchivedTrendLogger(trend=instance)
menu = f(instance)
before = MenuActionAppender.before \
or instance._usePollingBufferAction
menu.insertSeparator(before)
for t in MenuActionAppender.ACTIONS:
if len(t) == 4:
actname, label, method, args = t
else:
actname, label, method = t
args = (instance, )
action = getattr(instance, actname, None)
if not action:
setattr(instance, actname, Qt.QAction(label, None))
action = getattr(instance, actname)
instance.connect(
action, Qt.SIGNAL("triggered()"),
(lambda o=instance, m=method, a=args, l=obj:
(l.warning(','.join(map(str, (o, m, a)))),
(m(o) if fn.isCallable(m) else getattr(
o, m, getattr(l, m, None)))(*a))))
menu.insertAction(before, action)
menu.insertSeparator(before)
return menu
except:
traceback.print_exc()
def __init__(self,parent=None,devices=None):
#print '~'*80
#print 'In AttributesPanel()'
PARENT_KLASS.__init__(self,parent)
self.setSizePolicy(Qt.QSizePolicy(Qt.QSizePolicy.Ignored,Qt.QSizePolicy.Ignored))
self.worker = SingletonWorker(parent=self,cursor=True,sleep=50.,start=True)
#self.worker.log.setLogLevel(self.worker.log.Debug)
self.filters=('','','') #server/device/attribute
self.devices=devices or []
self.setValues(None)
self.models = []
self.current_item = None
#self.connect(self, Qt.SIGNAL('customContextMenuRequested(const QPoint&)'), self.onContextMenu)
self.popMenu = Qt.QMenu(self)
self.actions = {
'TestDevice': self.popMenu.addAction(Qt.QIcon(),"Test Device",self.onTestDevice),
'ShowDeviceInfo': self.popMenu.addAction(Qt.QIcon(),"Show Device Info",self.onShowInfo),
#'ShowDevicePanel': self.popMenu.addAction(Qt.QIcon(),"Show Info",self.onShowPanel),
'ShowArchivingInfo': self.popMenu.addAction(Qt.QIcon(),"Show Archiving Info",self.onShowArchivingModes),
#'Test Device': self.popMenu.addAction(Qt.QIcon(),"Test Device",self.onTestDevice)
}
#if hasattr(self,'setFrameStyle'):
#self.setFrameStyle(self.Box)
try:
import PyTangoArchiving
self.reader = PyTangoArchiving.Reader('*')
#self.hreader = self.reader.configs['hdb']
#self.treader = self.reader.configs.get('tdb',self.hreader)
except:
traceback.print_exc()
def initStyle(self, show=False):
tag, formula = self.tag, self.formula
#tag = getattr(tag,'tag',tag) or self.tag
#formula = formula or getattr(obj,'formula','') or self.formula
self.org_formula = formula
print 'In AlarmPreview.updateStyle(%s,%s)' % (tag, formula)
try:
self.setLayout(Qt.QVBoxLayout())
self.setMinimumSize(500, 500)
self.frame = Qt.QSplitter()
self.frame.setOrientation(Qt.Qt.Vertical)
self.layout().addWidget(self.frame)
self.upperPanel = AlarmFormula(self.tag or formula)
self.lowerPanel = AttributesPreview(
source=self.upperPanel.updateFormula)
self.lowerPanel.setMinimumHeight(250)
self.frame.insertWidget(0, self.upperPanel)
self.frame.insertWidget(1, self.lowerPanel)
self.setWindowTitle("%s Alarm Formula Preview" % (tag or ''))
#Refresh from formula:
#upperPanel.updateFormula(formula)
if self.upperPanel.formula: self.lowerPanel.updateAttributes()
if show: self.show()
print 'AlarmGUI.showAlarmPreview(%s) finished.' % tag
print self.frame.sizes()
except:
print traceback.format_exc()
print 'Unable to showAlarmPreview(%s)' % tag
def setTable(self, multirow=None):
if multirow is not None:
self.multirow = multirow
self.table = Qt.QTableWidget()
self.header = self.table.horizontalHeader()
try:
self.table.verticalHeader().setResizeMode(self.header.Stretch)
self.header.setResizeMode(self.header.Stretch)
except:
pass
if self.multirow:
self.table.setColumnCount(3)
self.table.setRowCount(3)
self.table.setHorizontalHeaderLabels(
['Period', 'Range-', 'Range+'])
self.table.setVerticalHeaderLabels(
['Periodic', 'Relative', 'Absolute'])
else:
self.table.setMaximumHeight(60)
self.table.setColumnCount(6)
self.table.setRowCount(1)
self.table.verticalHeader().hide()
self.table.setHorizontalHeaderLabels([
'Periodic', 'Abs/Rel', 'Polling', 'Range-', 'Range+', 'Select'
])
self.qb = Qt.QCheckBox()
self.table.setCellWidget(0, 5, self.qb)
def addOkCancelButtons(widget, cancel=True):
qb = Qt.QDialogButtonBox(widget)
qb.addButton(qb.Ok)
if cancel: qb.addButton(qb.Cancel)
widget.layout().addWidget(qb)
widget.connect(qb, Qt.SIGNAL("accepted()"), widget.accept)
if cancel: widget.connect(qb, Qt.SIGNAL("rejected()"), widget.reject)
return
def __init__(self, parent=None):
Qt.QScrollArea.__init__(self, parent)
#Qt.QWidget.__init__(self,parent)
self.main = Qt.QWidget(self)
self.main.setLayout(Qt.QVBoxLayout())
#self.setWidget(self.main)
self.resize(500, 600)
self.setWindowTitle('TaurusSingleValue')
self.models = []
self.widgets = []
def onEdit(self,checked=True):
print 'In AlarmFormula.onEdit(%s)'%checked
self.tf.setReadOnly(not checked)
self.tf.setEnabled(checked)
self.editcb.setChecked(checked) #Order is not trivial, to avoid recursion
if self.updateFormula()!=self.org_formula and not checked:
self.undoEdit()
self.savebt.setEnabled(self.updateFormula()!=self.org_formula)
if checked: self.emit(Qt.SIGNAL("onEdit()"))
else: self.emit(Qt.SIGNAL("onReadOnly()"))
def setModel(self, model, refresh=5000):
model = getattr(model, 'view', model)
self.model = model
if not hasattr(self, '_timer'):
self._timer = Qt.QTimer()
self.connect(self._timer, Qt.SIGNAL("timeout()"),
self.valueChanged)
self._timer.start(refresh)
print('AlarmForm._timer(%s)' % refresh)
self.show()
def __init__(self, parent=None):
Qt.QWidget.__init__(self, parent)
self.setLayout(Qt.QVBoxLayout())
self.bar = Qt.QWidget()
self.bar.setLayout(Qt.QHBoxLayout())
self.bar.setMaximumHeight(50)
self.modelline = Qt.QLineEdit()
self.modelbt = Qt.QPushButton('Apply')
map(self.bar.layout().addWidget, (self.modelline, self.modelbt))
self.main = QAlarmPanel(self)
map(self.layout().addWidget, (self.bar, self.main))
def init_timers(self):
#TIMERS (to reload database and refresh alarm list).
self.reloadTimer = Qt.QTimer()
self.refreshTimer = Qt.QTimer()
Qt.QObject.connect(self.refreshTimer, Qt.SIGNAL("timeout()"),
self.onRefresh)
Qt.QObject.connect(self.reloadTimer, Qt.SIGNAL("timeout()"),
self.onReload)
#first fast loading
self.reloadTimer.start(min((5000, self.REFRESH_TIME / 2.)))
self.refreshTimer.start(self.REFRESH_TIME)
def __init__(self, parent=None, trend=None):
Qt.QDialog.__init__(self, parent)
self.setLayout(Qt.QVBoxLayout())
self.panel = Qt.QTextBrowser()
self.layout().addWidget(self.panel)
self.reader = PyTangoArchiving.Reader()
self.trend = trend
self.setModel()
self._bt = Qt.QPushButton('Refresh')
self._bt.connect(self._bt, Qt.SIGNAL('clicked()'), self.setModel)
self.layout().addWidget(self._bt)
def check_values():
di.exec_()
if di.result():
print 'checking result ...'
start, stop = str(begin.text()), str(end.text())
if not all(
re.match(
'[0-9]+-[0-9]+-[0-9]+ [0-9]+:[0-9]+:[0-9]+',
str(s).strip()) for s in (start, stop)):
print 'dates are wrong ...'
Qt.QMessageBox.warning(
None, 'Show archiving',
'Dates seem not in %s format' % (tformat),
Qt.QMessageBox.Ok)
return check_values()
else:
print 'getting values ...'
reader = tdb if str2epoch(start) > (
time.time() - 5 * 24 * 3600.
) and attribute in tdb.get_attributes() else hdb
print 'using %s reader' % reader.schema
values = reader.get_attribute_values(
attribute, str2epoch(start), str2epoch(stop))
if not len(
values
) and reader is tdb and attribute in hdb.get_attributes(
):
print 'tdb failed, retrying with hdb'
values = hdb.get_attribute_values(
attribute, str2epoch(start), str2epoch(stop))
print 'drawing table from %d values' % len(values)
tab = Qt.QTableWidget()
tab.setWindowTitle('%s: %s to %s' %
(attribute, start, stop))
tab.setRowCount(len(values))
tab.setColumnCount(2)
tab.setHorizontalHeaderLabels(['TIME', 'VALUE'])
for i, tup in enumerate(values):
date, value = tup
tab.setItem(i, 0,
Qt.QTableWidgetItem(epoch2str(date)))
tab.setItem(i, 1, Qt.QTableWidgetItem(str(value)))
tab.show()
tab.resizeColumnsToContents()
tab.horizontalHeader().setStretchLastSection(True)
TABS.append(tab)
tab.connect(tab,
Qt.SIGNAL('close()'),
lambda o=tab: TABS.remove(o))
print 'show_history done ...'
return tab
else:
print 'dialog closed'
return None
def AlarmsSelector(alarms,text='Choose alarms to modify',):
qw = Qt.QDialog()
qw.setModal(True)
qw.setLayout(Qt.QVBoxLayout())
qw.layout().addWidget(Qt.QLabel(text))
qw.layout().addWidget(Qt.QLabel())
[qw.layout().addWidget(Qt.QCheckBox(a,qw)) for a in alarms]
addOkCancelButtons(qw)
if qw.exec_():
alarms = [str(c.text()) for c in qw.children() if isinstance(c,Qt.QCheckBox) and c.isChecked()]
else:
alarms = []
return alarms
def __init__(self, parent=None):
Qt.QWidget.__init__(self, parent)
self.setLayout(Qt.QHBoxLayout())
self.model = ''
self.device = ''
self.label = Qt.QLabel()
self.label.setFixedWidth(250)
self.value = Qt.QLabel()
self.value.setFixedWidth(200)
self.units = Qt.QLabel()
self.units.setFixedWidth(50)
self.setWindowTitle('TaurusSingleValue')
map(self.layout().addWidget, (self.label, self.value, self.units))
def setCloserTimer(dialog, parent=None, period=3000):
if not parent: parent = getObjectParent(dialog)
dialog._timer = Qt.QTimer()
dialog._timer.setInterval(period)
def closer(s=dialog, p=parent):
try:
if not p.isVisible():
s.close()
except:
pass
dialog._timer.connect(dialog._timer, Qt.SIGNAL('timeout()'), closer)
dialog._timer.start()
def connectAll(self):
trace('connecting')
#Qt.QObject.connect(self.refreshTimer, Qt.SIGNAL("timeout()"), self.onRefresh)
if self.USE_EVENT_REFRESH:
Qt.QObject.connect(self, Qt.SIGNAL("valueChanged"), self.hurry)
#Qt.QObject.connect(self,
#Qt.SIGNAL('setfontsandcolors'),AlarmRow.setFontsAndColors)
Qt.QObject.connect(self._ui.listWidget,
Qt.SIGNAL("itemSelectionChanged()"),
self.onItemSelected)
Qt.QObject.connect(self._ui.listWidget,
Qt.SIGNAL("itemDoubleClicked(QListWidgetItem *)"),
self.onView) #self.onEdit)
#Qt.QObject.connect(self._ui.listWidget, Qt.SIGNAL("currentRowChanged(int)"), self.setAlarmData)
self.connectContextMenu(self._ui.listWidget)
#Qt.QObject.connect(self._ui.actionExpert,
#Qt.SIGNAL("changed()"),self.setExpertView)
Qt.QObject.connect(self._ui.newButton, Qt.SIGNAL("clicked()"),
self.onNew) # "New"
Qt.QObject.connect(self._ui.deleteButton, Qt.SIGNAL("clicked(bool)"),
self.onDelete) # Delete
Qt.QObject.connect(self._ui.refreshButton, Qt.SIGNAL("clicked()"),
self.onReload) # "Refresh"
Qt.QObject.connect(self._ui.buttonClose, Qt.SIGNAL("clicked()"),
self.close)
Qt.QObject.connect(fandango.qt.getApplication(),
Qt.SIGNAL("aboutToQuit()"), self.exitThreads)
trace('all connected')
def showCurrentAlarmPreview(gui,tag=None,formula=None):
"""It gets current Alarm from GUI and tries to show it up"""
form = AlarmPreview(tag=tag or gui.getCurrentAlarm(),formula=formula or None,parent=gui.parent())
#form.exec_()
form.show()
gui.connect(gui,Qt.SIGNAL('closed()'),form.close)
return form
def initStyle(self):
print 'In AttributesPreview.initStyle()'
try:
self.setLayout(Qt.QGridLayout())
self.redobt = Qt.QPushButton()
self.redobt.setIcon(getThemeIcon('view-refresh'))
self.redobt.setToolTip('Update result')
self.taurusForm=TaurusForm()
self.taurusForm.setWithButtons(False)
self.taurusForm.setWindowTitle('Preview')
self.layout().addWidget(self.redobt,0,6,1,1)
self.layout().addWidget(Qt.QLabel('Values of attributes used in the Alarm formula:'),0,0,1,1)
self.layout().addWidget(self.taurusForm,1,0,1,7)
self.connect(self.redobt,Qt.SIGNAL('pressed()'),self.updateAttributes)
except:
print traceback.format_exc()
def log(self, severity, msg, remote=None):
"""
The remote flag should allow operations done outside of QMainThread to be logged
"""
remote = remote if remote is not None else self.remote
if remote:
self.emit(Qt.SIGNAL('logging'), severity, msg, False)
return
if msg == self.last_msg:
msg = '+1'
else:
self.last_msg = msg
if self.logger:
try:
if severity not in self.log_objs: self.log_objs[severity] = \
getattr(self.logger,severity,(lambda m,s=severity:'%s:%s: %s'%(s.upper(),F.time2str(),m)))
self.log_objs[severity](msg)
except:
pass
if self.dialog():
if msg != '+1':
msg = '%s:%s: %s' % (severity.upper(), F.time2str(), msg)
if self.filters:
msg = (F.filtersmart(msg, self.filters) or [''])[0]
if msg:
self.dialog().append(msg)
def main(args=None):
import sys
#from taurus.qt.qtgui.container import TaurusMainWindow
tmw = Qt.QMainWindow() #TaurusMainWindow()
tmw.setWindowTitle('Tango Attribute Search (%s)'%(os.getenv('TANGO_HOST')))
table = ArchivingBrowser(domains=args,USE_SCROLL=True,USE_TREND=True)
tmw.setCentralWidget(table)
use_toolbar = True
if use_toolbar:
toolbar = QDictToolBar(tmw)
toolbar.set_toolbar([
##('PDFs','icon-all.gif',[
#('Pdf Q1','icon-all.gif',lambda:launch('%s %s'%('kpdf','TC_Q1.pdf'))),
#('Pdf Q2','icon-all.gif',lambda:launch('%s %s'%('kpdf','TC_Q2.pdf'))),
#('Pdf Q3','icon-all.gif',lambda:launch('%s %s'%('kpdf','TC_Q3.pdf'))),
#('Pdf Q4','icon-all.gif',lambda:launch('%s %s'%('kpdf','TC_Q4.pdf'))),
## ]),
#('Archiving Viewer','Mambo-icon.ico', lambda:launch('mambo')),
('Show New Trend','qwtplot.png',table.open_new_trend),
])
toolbar.add_to_main_window(tmw,where=Qt.Qt.BottomToolBarArea)
tmw.show()
opts = dict(a.split('=',1) for a in args if a.startswith('-'))
args = [a for a in args if not a.startswith('-')]
if args:
table.updateSearch(*args)
if '--range' in opts:
print('Setting trend range to %s' % opts['--range'])
table.trend.applyNewDates(opts['--range'].split(','))
return tmw
def get_archive_trend(models=None, length=4 * 3600, show=False):
# This method is to be added to
# PyTangoArchiving.widgets.trend in next releases
#class PressureTrend(TaurusTrend):
#def showEvent(self,event):
#if not getattr(self,'_tuned',False):
#setup_pressure_trend(self)
#setattr(self,'_tuned',True)
#TaurusTrend.showEvent(self,event)
from taurus.external.qt import Qwt5
tt = TaurusTrend()
try:
tt.setXDynScale(True)
tt.setUseArchiving(True)
tt.setModelInConfig(False)
tt.disconnect(tt.axisWidget(tt.xBottom),
Qt.SIGNAL("scaleDivChanged ()"), tt._scaleChangeWarning)
xMax = time.time() #tt.axisScaleDiv(Qwt5.QwtPlot.xBottom).upperBound()
rg = length #abs(self.str2deltatime(str(self.ui.xRangeCB.currentText())))
xMin = xMax - rg
tt.setAxisScale(Qwt5.QwtPlot.xBottom, xMin, xMax)
if models: tt.setModel(models)
if show: tt.show()
tt.setWindowTitle('Trend')
except:
print 'Exception in set_pressure_trend(%s)' % tt
print traceback.format_exc()
return tt
def forceReadings(self, filters='', emit=True):
for n, ts in self.trend.trendSets.iteritems():
model = ts.getModel()
if not filters or fn.clmatch(filters, model):
self.warning('forceReadings(%s)' % model)
ts.forceReading()
if emit:
self.trend.emit(Qt.SIGNAL('refreshData'))
def showArchivingModes(model, parent=None, schemas=('HDB', 'TDB')):
print('onShowArchivingModes(%s)' % model)
#DIALOG MUST BE ALWAYS SHOWN, EVEN FOR NON-ARCHIVED ATTRIBUTES!
#w = Qt.QWidget()
w = Qt.QDialog()
w.setModal(False)
w.setLayout(Qt.QVBoxLayout())
w.setWindowTitle(model)
ws = {}
for s in schemas:
ws[s] = QArchivingMode(w)
ws[s].setSchema(s)
ws[s].setModel(model)
w.layout().addWidget(ws[s])
w.exec_()
#w.show()
return w
def onNew(self):
w = Qt.QDialog(self.Form)
w.setWindowTitle('Add New PyAlarm Device')
w.setLayout(Qt.QGridLayout())
server, device = Qt.QLineEdit(w), Qt.QLineEdit(w)
server.setText('TEST')
device.setText('test/pyalarm/1')
w.layout().addWidget(Qt.QLabel('Server Instance'), 0, 0, 1, 1)
w.layout().addWidget(server, 0, 1, 1, 1)
w.layout().addWidget(Qt.QLabel('Device Name'), 1, 0, 1, 1)
w.layout().addWidget(device, 1, 1, 1, 1)
doit = Qt.QPushButton('Apply')
w.layout().addWidget(doit, 2, 0, 2, 2)
def create(s=server, d=device, p=w):
try:
s, d = str(s.text()), str(d.text())
if '/' not in s: s = 'PyAlarm/%s' % s
import fandango.tango as ft
ft.add_new_device(s, 'PyAlarm', d)
print('%s - %s: created!' % (s, d))
except:
traceback.print_exc()
self.api.load()
p.close()
QtCore.QObject.connect(doit, QtCore.SIGNAL("clicked()"), create)
w.exec_()
self.setDevCombo()
def onClose(self):
print 'In AlarmFormula.onClose()'
if self.obj and self.toPlainText()!=self.org_formula:
v = QtGui.QMessageBox.warning(None,'Pending Changes', \
'%s Formula has been modified, do you want to save your changes?'%self.obj.tag, \
QtGui.QMessageBox.Ok|QtGui.QMessageBox.Cancel);
if v == QtGui.QMessageBox.Cancel: return
self.onSave()
self.emit(Qt.SIGNAL("onClose()"))
def onItemSelected(self):
try:
items = self.getSelectedItems(extend=False)
if len(items) == 1:
a = self.view.get_alarm_from_text(items[0])
tags = a.tag.split('_')
self.emit(Qt.SIGNAL('alarmSelected'), a.tag)
models = self.api.parse_attributes(a.formula)
devices = sorted(
set(
fn.tango.parse_tango_model(m)['device']
for m in models))
print('onItemSelected(%s) devices: %s' %
(a, shortstr(devices)))
self.emit(Qt.SIGNAL('devicesSelected'),
'|'.join(devices + tags))
except:
traceback.print_exc()
def __init__(self, parent=None):
TaurusWidget.__init__(self, parent)
self.setLayout(Qt.QHBoxLayout())
form = LoadForm(self)
form.setModel([
"simumotor/zreszela/1/position", "simumotor/zreszela/2/position",
"simumotor/zreszela/3/position", "simumotor/zreszela/4/position"
])
self.layout().addWidget(form)
def applyModes(self):
self.logger().show()
#Qt.QApplication.instance().setOverrideCursor(Qt.QCursor(Qt.Qt.WaitCursor))
try:
attr = self.getModel()
v = F.check_attribute(attr, brief=True)
if isinstance(v, (type(None), Exception)):
Qt.QMessageBox.warning(
self, "Warning",
"%s is not readable nor archivable" % attr)
self.logger().hide()
return
if fun.isSequence(v) or fun.isString(v):
Qt.QMessageBox.warning(self, "Warning",
"%s array type is not supported" % attr)
self.logger().hide()
return
modes = self.getModes() or {'MODE_P': [60000]}
schema = self.getSchema()
print('%s: applyModes(%s)' % (fun.time2str(), modes))
msg = 'Modes to be applied:\n'
for m, v in modes.items():
msg += '\t%s.%s: %s\n' % (schema, m, v)
qm = Qt.QMessageBox(Qt.QMessageBox.Warning, 'Confirmation', msg,
Qt.QMessageBox.Ok | Qt.QMessageBox.Cancel)
r = qm.exec_()
if r == Qt.QMessageBox.Ok:
if not self.api:
self.api = pta.api(self.getSchema().lower(),
logger=self.logger())
self.api.log = self.logger()
#self.emit(Qt.SIGNAL('archive'),attr,modes)
Qt.QApplication.instance().setOverrideCursor(
Qt.QCursor(Qt.Qt.WaitCursor))
thr = threading.Thread(target=self.startArchiving,
args=(attr, modes))
QLoggerDialog._threads = filter(Thread.is_alive,
self.threads()) + [thr]
thr.start()
else:
self.logger().hide()
except:
self.logger().error(traceback.print_exc())
print('%s: applyModes(...): running!' % (fun.time2str()))
def show_dialog(self, enable=True):
if not self.dialog():
try:
self._dialog = QTextBuffer(title='Archiving Logs', maxlen=1000)
self._trendinfo = QArchivedTrendInfo(trend=self.trend)
self._trendinfobt = Qt.QPushButton('Show Models Info')
self._trendinfobt.connect(self._trendinfobt,
Qt.SIGNAL('clicked()'),
self._trendinfo.show)
self.dialog().layout().addWidget(self._trendinfobt)
self._forcedbt = Qt.QPushButton('Force trend update')
self._forcedbt.connect(
self._forcedbt,
Qt.SIGNAL('clicked()'),
#self.forceReadings)
self.trend.setForcedReadingPeriod)
self.dialog().layout().addWidget(self._forcedbt)
self._reloader = QReloadWidget(parent=self._dialog,
trend=self.trend,
logger=self)
self.dialog().layout().addWidget(self._reloader)
self._showhist = Qt.QPushButton('Show/Save buffers as a Table')
self._showhist.connect(self._showhist, Qt.SIGNAL('clicked()'),
self.showRawValues)
self.dialog().layout().addWidget(self._showhist)
self._clearbutton = Qt.QPushButton('Clear Buffers and Redraw')
self.dialog().layout().addWidget(self._clearbutton)
self._clearbutton.connect(
self._clearbutton, Qt.SIGNAL('clicked()'),
fn.partial(fn.qt.QConfirmAction, self.clearBuffers))
if hasattr(self.trend, 'closeEvent'):
#setDialogCloser(self.dialog(),self.trend)
setCloserTimer(self.dialog(), self.trend)
except:
self.warning(traceback.format_exc())
if self.dialog():
### @TODO
self.dialog().toggle(not enable)
#if not enable:
#print('show_dialog(False): hiding dialog')
#self.dialog().hide()
if enable:
self.dialog().toggle(True)
self.dialog().show()
