def setTextColor(self, color):
"""set the text paint color"""
if isinstance(color, tuple) and len(color) == 3:
color = QColor(color[0], color[1], color[2])
elif isinstance(color, int):
color = QColor(color, color, color)
setattr(self, '__textColor', color)
def __init__(self, parent=None, toolbar=None):
super().__init__(parent)
layout = QHBoxLayout()
self.setLayout(layout)
self.graphic_widget = LiveDataPanel(parent, parent.client, {})
self.graphic_widget.hide()
self.log_widget = ConsolePanel(parent, parent.client, {})
self.log_widget.hide()
self.widgets = QStackedWidget(parent)
self.widgets.addWidget(self.graphic_widget)
self.widgets.addWidget(self.log_widget)
layout.addWidget(self.widgets)
self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
if toolbar:
self.resize(parent.size() - toolbar.size())
else:
self.resize(parent.size())
# make the window frameless
self.setWindowFlags(Qt.FramelessWindowHint)
self.setAttribute(Qt.WA_TranslucentBackground)
self.fillColor = QColor(30, 30, 30, 120)
self.penColor = QColor("#333333")
self.SIGNALS = TranslucentWidgetSignals()
self.raise_()
def loadUserStyle(window, settings):
window.user_font = QFont(settings.value('font', QFont('Monospace')))
color = QColor(settings.value('color'))
if color.isValid():
window.user_color = color
else:
window.user_color = QColor(Qt.white)
def __init__(self, parent=None, toolbar=None):
super(TranslucentWidget, self).__init__(parent)
# loadUi(self, 'overlay.ui', '%s/windows'%uipath)
layout = QHBoxLayout()
self.setLayout(layout)
self.graphic_widget = LiveDataPanel(parent, parent.client, {})
self.graphic_widget.hide()
self.log_widget = ConsolePanel(parent, parent.client, {})
self.log_widget.hide()
self.widgets = QStackedWidget(parent)
self.widgets.addWidget(self.graphic_widget)
self.widgets.addWidget(self.log_widget)
#
#
# for panel in parent.panels:
# try:
# print('%s - %s'%(panel.panelName, panel.__class__.__name__))
# except:
# pass
#
# if not self.graphic_widget and panel.__class__.__name__ == \
# 'LiveDataPanel':
# print(panel.panelName)
# self.graphic_widget = panel
# self.widgets.addWidget(self.graphic_widget)
# if not self.log_widget and panel.__class__.__name__ == \
# 'ConsolePanel':
# print(panel.panelName)
# self.log_widget = panel
# self.widgets.addWidget(self.log_widget)
layout.addWidget(self.widgets)
self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
if toolbar:
self.resize(parent.size() - toolbar.size())
else:
self.resize(parent.size())
# make the window frameless
self.setWindowFlags(Qt.FramelessWindowHint)
self.setAttribute(Qt.WA_TranslucentBackground)
self.fillColor = QColor(30, 30, 30, 120)
self.penColor = QColor("#333333")
# self.popup_fillColor = QColor(240, 240, 240, 255)
# self.popup_penColor = QColor(200, 200, 200, 255)
self.SIGNALS = TranslucentWidgetSignals()
self.raise_()
def __init__(self, x, y, size=20, parent=None, scene=None):
TableBase.__init__(self, x, y, size, parent, scene)
self._halowidth = max(size / 4, 10)
self._halo = Halo(x, y, size, self._halowidth, self, scene)
self._tuberadius = size / 5
p = QPointF(self._tuberadius, self._tuberadius)
s = QSizeF(2 * self._tuberadius, 2 * self._tuberadius)
self._tube = QGraphicsEllipseItem(QRectF(-p, s), self)
self._tube.setPen(QPen(QColor('black'), 3))
self._tube.setBrush(QBrush(QColor('white')))
self._tube.setZValue(20)
def __init__(self, fromObj, toObj, parent=None, scene=None):
self._start = fromObj
self._end = toObj
QGraphicsLineItem.__init__(self, parent)
self.setPen(QPen(QColor('white'), 4))
self._beam = QGraphicsLineItem(parent)
self._beam.setPen(QPen(QColor('blue'), 1))
if not parent and scene:
scene.addItem(self)
scene.addItem(self._beam)
self.update()
self.setZValue(50)
self._beam.setZValue(51)
def __init__(self, parent, history=None):
QLineEdit.__init__(self, parent)
self.run_color = QColor('#ffdddd')
self.idle_color = self.palette().color(QPalette.Base)
self.active_fgcolor = QColor('#000000')
self.inactive_fgcolor = QColor('#c9c9c9')
self.error_fgcolor = QColor("#ff0000")
self.history = history or []
self.scrollWidget = None
self.completion_callback = lambda text: []
self._start_text = ''
self._current = -1
self._completer = QCompleter([], self)
self.setCompleter(self._completer)
def _add_time_point(self, center_x, center_y, time_point):
"""Add a single time point item."""
x = center_x - (self.TIMEPOINT_DIAMETER / 2)
y = center_y - (self.TIMEPOINT_DIAMETER / 2)
# Create the acutal time point item
time_point_item = QGraphicsEllipseItem(0, 0, self.TIMEPOINT_DIAMETER,
self.TIMEPOINT_DIAMETER)
# The used color is the strongest one of the FRM II colors.
time_point_item.setBrush(QBrush(QColor(0x00, 0x71, 0xbb)))
time_point_item.setPen(QPen(0))
self.scene().addItem(time_point_item)
time_point_item.setPos(x, y)
# place the time point item above the timeline and the selection item
time_point_item.setZValue(2)
# Create the label of the time point showing the time in the
# defined strftime format on the right side of the time point item.
label = QGraphicsTextItem(time_point.strftime(self.STRFTIME_FMT))
label.setFont(QFont('Monospace'))
label_height = label.boundingRect().height()
# minor height adjustment
label_y = y - label_height / 6
self.scene().addItem(label)
label.setPos(x + self.SELECTION_DIAMETER + self.LABEL_SPACING, label_y)
# store references to the item and the timepoint in the same dict
# to be able to use it for forward and reverse lookup
self._time_point_items[time_point] = time_point_item
self._time_point_items[time_point_item] = time_point
def createEditor(self):
if has_scintilla:
editor = QsciScintillaCustom(self)
lexer = QsciLexerPython(editor)
editor.setUtf8(True)
editor.setLexer(lexer)
editor.setAutoIndent(True)
editor.setEolMode(QsciScintilla.EolUnix)
editor.setIndentationsUseTabs(False)
editor.setIndentationGuides(True)
editor.setTabIndents(True)
editor.setBackspaceUnindents(True)
editor.setTabWidth(4)
editor.setIndentationWidth(0)
editor.setBraceMatching(QsciScintilla.SloppyBraceMatch)
editor.setFolding(QsciScintilla.PlainFoldStyle)
editor.setIndentationGuidesForegroundColor(QColor("#CCC"))
editor.setWrapMode(QsciScintilla.WrapCharacter)
editor.setMarginLineNumbers(1, True)
editor.setMarginWidth(
1, 5 + 4 * QFontMetrics(editor.font()).averageCharWidth())
else:
editor = QScintillaCompatible(self)
# editor.setFrameStyle(0)
editor.modificationChanged.connect(
lambda dirty: self.setDirty(editor, dirty))
self._updateStyle(editor)
return editor
def _select_item(self, item):
"""Select the given item by drawing a colored circle beneath the
selected item (so it looks like a ring around it.
Also emits the timepointSelected signal."""
# The selection_item used to signal the selection of a timepoint
# is always the same and is only moved.
if self._selection_item is None:
self._selection_item = QGraphicsEllipseItem(
0, 0, self.SELECTION_DIAMETER, self.SELECTION_DIAMETER)
# The used color is a cubical to the time point color
self._selection_item.setBrush(QBrush(QColor(0x70, 0xbb, 0x00)))
self._selection_item.setPen(QPen(0))
self.scene().addItem(self._selection_item)
# center position of the timepoint circle
center_x = item.pos().x() + self.TIMEPOINT_DIAMETER / 2
center_y = item.pos().y() + self.TIMEPOINT_DIAMETER / 2
# move selection item
self._selection_item.setPos(center_x - self.SELECTION_DIAMETER / 2,
center_y - self.SELECTION_DIAMETER / 2)
# store the selection_item like a timepoint item (using the timepoint
# of the selected item)
self._time_point_items[self._selection_item] = \
self._time_point_items[item]
# emit signal at the end to ensure a valid internal state before
# anything can react to it
self.timepointSelected.emit(self._time_point_items[item])
def _add_timeline(self):
"""Draw the timeline."""
# height is either the necessary space to display all items or the
# maximal available display size, so it's looks nicely in larger
# windows and enables scrolling in smaller ones.
height = self.TIMEPOINT_DIAMETER * len(self._time_points)
height += self.TIMEPOINT_SPACING * len(self._time_points)
height = max(height, self.viewport().height())
# draw the timeline left aligned with enough space to draw the items
# and the selection ring.
x = self.MARGIN_HORIZONTAL + (self.SELECTION_DIAMETER / 2)
# position the line on the left side of the item
item = QGraphicsLineItem(0, 0, 0, height)
# The used color for the timeline is the lightest one of the FRM II
# colors
item.setPen(QPen(QBrush(QColor(0xa3, 0xc1, 0xe7)),
self.TIMELINE_WIDTH))
self.scene().addItem(item)
# move the whole item to the desired timeline position
item.setPos(x, 0)
return item
def paintEvent(self, event):
w, h = self.width * self._scale, self.height * self._scale
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.setPen(QColor('black'))
painter.setBrush(_white)
painter.drawRect(1, 1, w, h)
# determine positions
beam = QPolygonF([QPointF(4, 5)])
i = 0
for k in [
'nok0', 'shutter_gamma', 'nok2', 'nok3', 'nok4', 'nok5a',
'nok5b', 'nok6', 'nok7', 'nok8'
]:
v = self.values[k]
if isinstance(v, (tuple, readonlylist)):
x, y = v # pylint: disable=W0633
elif isinstance(v, int):
x, y = 0, v
else:
raise Exception('%r' % type(v))
p = self._calculatePoint(i, x, y)
beam.append(QPointF(p[0], p[1]))
i += 1
x, y = self.values['nok8']
p = self._calculatePoint(i + 1, x, y)
painter.setPen(beambackgroundpen)
painter.drawPolyline(beam)
# draw beam
painter.setPen(beampen)
painter.drawPolyline(beam)
def __init__(self, x, y, r, start, span, parent=None):
self.circle = QRectF(x - r, y - r, 2 * r, 2 * r)
self.startAngle = start
self.spanAngle = span
w = 10
self.boundingRectTemp = self.circle.adjusted(-w, -w, w, w)
QGraphicsItem.__init__(self)
self._color = QColor('blue')
def __init__(self, x, y, size=10, parent=None, scene=None):
TableBase.__init__(self, x, y, size, parent, scene)
sz = size / 2
self._crystal = QGraphicsLineItem(-sz, 0, sz, 0, self)
if not self._pencolor:
self._pencolor = QColor('black')
self._crystal.setPen(QPen(self._pencolor, 3))
self._crystal.setZValue(100)
class Detector(TableBase):
_color = QColor('grey')
def __init__(self, size, radius, parent=None, scene=None):
TableBase.__init__(self, 0, 0, size, parent, scene)
self.setPos(-radius, -size)
self.setTransformOriginPoint(radius, 0)
def __init__(self, parent=None, scene=None):
QGraphicsRectItem.__init__(self, 0, 0, 10, 45, parent)
transform = QTransform()
transform.translate(0, 5)
self.setTransform(transform)
self.setBrush(QBrush(QColor('#00FF00')))
if not parent and scene:
scene.addItem(self)
self._halo = DetectorHalo(5, self, scene)
class SampleTable(TableBase):
"""Class to display the sample table including sample and help lines."""
_color = QColor('#66ff66')
def __init__(self, x, y, size=20, parent=None, scene=None):
TableBase.__init__(self, x, y, size, parent, scene)
self._halowidth = max(size / 10, 10)
self._halo = Halo(x, y, size, self._halowidth, self, scene)
self._sample = Sample(0, 0, size, self, scene)
def __init__(self, parent, client, options):
Panel.__init__(self, parent, client, options)
loadUi(self, findResource('nicos_mlz/pgaa/gui/panels/tomography.ui'))
self.current_status = None
self.run_color = QColor('#ffdddd')
self.idle_color = parent.user_color
client.connected.connect(self.on_client_connected)
client.message.connect(self.on_client_message)
client.status.connect(self.on_client_initstatus)
client.mode.connect(self.on_client_mode)
def __init__(self, x, y, size=40, parent=None, scene=None):
self._origin = QPoint(x, y)
self._size = size
self._radius = size / 2
if not self._color:
self._color = QColor('white')
QGraphicsEllipseItem.__init__(self, QRectF(-QPoint(size, size),
QSizeF(2 * size, 2 * size)), parent)
if not parent and scene:
scene.addItem(self)
self.setPos(x, y)
self.setBrush(QBrush(self._color))
class MonoTable(TableBase):
"""Class to display the monochromator including shielding and crystal."""
_color = QColor('#6666ff')
def __init__(self, x, y, size=40, parent=None, scene=None):
TableBase.__init__(self, x, y, size, parent, scene)
self._halowidth = max(size / 10, 10)
self._halo = Halo(x, y, size, self._halowidth, self, scene)
self._crystal = Crystal(0, 0, size / 2, self, scene)
def rect(self):
return self._halo.rect()
def __init__(self, parent, client, options):
Panel.__init__(self, parent, client, options)
loadUi(self, findResource('nicos_demo/demo/gui/sanspanel.ui'))
self.current_status = None
self._idle = QColor('#99FF99')
self._busy = QColor(Qt.yellow)
self.statusBar = QStatusBar(self)
policy = self.statusBar.sizePolicy()
policy.setVerticalPolicy(QSizePolicy.Fixed)
self.statusBar.setSizePolicy(policy)
self.statusBar.setSizeGripEnabled(False)
self.layout().addWidget(self.statusBar)
client.cache.connect(self.on_client_cache)
run = self.buttonBox.button(QDialogButtonBox.Yes)
run.setText('Run')
run.setIcon(QIcon(':/continue'))
self.buttonBox.accepted.connect(self.on_start_clicked)
def highlightCurrentLine(self):
extraSelections = []
if not self.isReadOnly():
selection = QTextEdit.ExtraSelection()
lineColor = QColor(Qt.yellow).lighter(160)
selection.format.setBackground(lineColor)
selection.format.setProperty(QTextFormat.FullWidthSelection, True)
selection.cursor = self.textCursor()
selection.cursor.clearSelection()
extraSelections.append(selection)
self.setExtraSelections(extraSelections)
class DetTable(TableBase):
"""Class to display the detector including shielding and detector tube."""
_color = QColor('#ff66ff')
def __init__(self, x, y, size=20, parent=None, scene=None):
TableBase.__init__(self, x, y, size, parent, scene)
self._halowidth = max(size / 4, 10)
self._halo = Halo(x, y, size, self._halowidth, self, scene)
self._tuberadius = size / 5
p = QPointF(self._tuberadius, self._tuberadius)
s = QSizeF(2 * self._tuberadius, 2 * self._tuberadius)
self._tube = QGraphicsEllipseItem(QRectF(-p, s), self)
self._tube.setPen(QPen(QColor('black'), 3))
self._tube.setBrush(QBrush(QColor('white')))
self._tube.setZValue(20)
def __init__(self, x, y, size=20, parent=None, scene=None):
if parent:
self._color = parent._color
TableBase.__init__(self, x, y, size, parent, scene)
if not self._pencolor:
self._pencolor = QColor('#666666')
self._pen = QPen(self._pencolor, 1)
self._pen.setBrush(QBrush(self._pencolor))
sz = size / 3
self._polygon = QGraphicsRectItem(
QRectF(-QPointF(sz, sz), QPointF(sz, sz)), self)
self._polygon.setBrush(QBrush(self._pencolor))
self._l1 = QGraphicsLineItem(-size, 0, size, 0, self)
self._l1.setPen(self._pen)
self._l2 = QGraphicsLineItem(0, -size, 0, size, self)
self._l2.setPen(self._pen)
def __init__(self, parent):
QWidget.__init__(self, parent)
NicosWidget.__init__(self)
self.p_black = QPen(QColor('black'))
self.p_red = QPen(QColor('red'))
self.br_back = QBrush(QColor(190, 190, 190))
self.br_empty = QBrush(QColor(255, 255, 255))
self.col_led = [QColor(0, 0, 255), QColor(255, 255, 0)]
self.br_led = [QBrush(self.col_led[0]), QBrush(self.col_led[1])]
self.br_seg = QBrush(QColor(211, 211, 211))
self.devs = ['diagnostics/value', 'diag_switches/value',
'mb_arm_raw/value', 'mtt_raw/value', 'n_blocks_cw/value']
self.values = [0, 0, 0, 0, 0]
def formatPage(self, painter, drawing, area, pagenr):
QsciPrinter.formatPage(self, painter, drawing, area, pagenr)
fn = self.docName()
header = 'File: %s page %s %s' % \
(fn, pagenr, time.strftime('%Y-%m-%d %H:%M'))
painter.save()
pen = QPen(QColor(30, 30, 30))
pen.setWidth(1)
painter.setPen(pen)
newTop = area.top() + painter.fontMetrics().height() + 15
area.setLeft(area.left() + 30)
if drawing:
painter.drawText(area.left(),
area.top() + painter.fontMetrics().ascent(),
header)
painter.drawLine(area.left() - 2, newTop - 12,
area.right() + 2, newTop - 12)
area.setTop(newTop)
painter.restore()
def __init__(self, parent=None):
scene = QGraphicsScene()
QGraphicsView.__init__(self, scene)
self.setRenderHints(QPainter.Antialiasing)
self._tube = Tube(scene=scene)
self._tube.setRotation(1)
self._yoke = Yoke(scene=scene)
t1 = QTransform()
t1.translate(500, 0)
self._yoke.setTransform(t1)
self._pivotline = QGraphicsLineItem(-200, 0, 700, 0)
scene.addItem(self._pivotline)
self._pivot = QGraphicsRectItem(0, 0, 6, 10)
t2 = QTransform()
t2.translate(-3, -10)
self._pivot.setTransform(t2)
self._pivot.setBrush(QBrush(QColor('#1F1F1F')))
scene.addItem(self._pivot)
for i in range(13):
txt = '%d' % (i + 1)
self.t = QGraphicsTextItem(txt)
bw = self.t.boundingRect().size().width()
chrwidth = bw / (len(txt) + 1)
x = (i - 9) * self.pivotdist - chrwidth / 2 + bw / len(txt)
self.t.setX(x)
scene.addItem(self.t)
self._det = Detector(parent=self._tube, scene=scene)
self.values = {
'tubeangle': -1.0,
'pivot': 1,
'detpos': 620,
}
self.targets = self.values.copy()
self.status = {
'tubeangle': status.OK,
'pivot': status.OK,
'detpos': status.OK,
}
#
# *****************************************************************************
"""NICOS GUI command input widgets."""
from __future__ import absolute_import, division, print_function
from nicos.clients.gui.utils import loadUi
from nicos.guisupport.qt import QAbstractSpinBox, QColor, Qt, QWidget, \
pyqtSignal
from nicos.guisupport.typedvalue import DeviceParamEdit
from nicos.guisupport.utils import DoubleValidator, setBackgroundColor
from nicos.pycompat import srepr
from nicos.utils import findResource, formatDuration
invalid = QColor('#ffcccc')
def isFloat(ctl, minval=None, maxval=None, conv=float):
try:
v = conv(ctl.text())
except ValueError:
return False
if minval is not None and v < minval:
return False
if maxval is not None and v > maxval:
return False
return True
def isInt(ctl, minval=None, maxval=None):
def __init__(self):
loadUi(self, 'panels/history.ui')
self.user_color = Qt.white
self.user_font = QFont('Monospace')
self.views = []
# stack of views to display
self.viewStack = []
# maps watched keys to their views
self.keyviews = {}
# current plot object
self.currentPlot = None
self.fitclass = LinearFitter
self.fitfuncmap = {}
self.enablePlotActions(False)
self.presetmenu = QMenu('&Presets', self)
for (name, view) in self.last_views:
item = QListWidgetItem(name, self.viewList)
item.setForeground(QBrush(QColor('#aaaaaa')))
item.setData(Qt.UserRole, view)
self.menus = None
self.bar = None
# NOTE: for this class, automatic connections don't work on PyQt4 >=
# 4.12 since this class is not derived from QObject. But on older PyQt4
# and PyQt5, they do work, so we change use the usual naming scheme
# slightly to avoid double connections.
self.viewList.currentItemChanged.connect(
self.on__viewList_currentItemChanged)
self.viewList.itemClicked.connect(self.on__viewList_itemClicked)
self.viewList.itemDoubleClicked.connect(
self.on__viewList_itemDoubleClicked)
self.actionNew.triggered.connect(self.on__actionNew_triggered)
self.actionEditView.triggered.connect(
self.on__actionEditView_triggered)
self.actionCloseView.triggered.connect(
self.on__actionCloseView_triggered)
self.actionResetView.triggered.connect(
self.on__actionResetView_triggered)
self.actionDeleteView.triggered.connect(
self.on__actionDeleteView_triggered)
self.actionSavePlot.triggered.connect(
self.on__actionSavePlot_triggered)
self.actionPrint.triggered.connect(self.on__actionPrint_triggered)
self.actionUnzoom.triggered.connect(self.on__actionUnzoom_triggered)
self.actionLogScale.toggled.connect(self.on__actionLogScale_toggled)
self.actionAutoScale.toggled.connect(self.on__actionAutoScale_toggled)
self.actionScaleX.toggled.connect(self.on__actionScaleX_toggled)
self.actionScaleY.toggled.connect(self.on__actionScaleY_toggled)
self.actionLegend.toggled.connect(self.on__actionLegend_toggled)
self.actionSymbols.toggled.connect(self.on__actionSymbols_toggled)
self.actionLines.toggled.connect(self.on__actionLines_toggled)
self.actionSaveData.triggered.connect(
self.on__actionSaveData_triggered)
self.actionFitPeak.triggered.connect(self.on__actionFitPeak_triggered)
self.actionFitArby.triggered.connect(self.on__actionFitArby_triggered)
self.actionFitPeakGaussian.triggered.connect(
self.on__actionFitPeakGaussian_triggered)
self.actionFitPeakLorentzian.triggered.connect(
self.on__actionFitPeakLorentzian_triggered)
self.actionFitPeakPV.triggered.connect(
self.on__actionFitPeakPV_triggered)
self.actionFitPeakPVII.triggered.connect(
self.on__actionFitPeakPVII_triggered)
self.actionFitTc.triggered.connect(self.on__actionFitTc_triggered)
self.actionFitCosine.triggered.connect(
self.on__actionFitCosine_triggered)
self.actionFitSigmoid.triggered.connect(
self.on__actionFitSigmoid_triggered)
self.actionFitLinear.triggered.connect(
self.on__actionFitLinear_triggered)
self.actionFitExponential.triggered.connect(
self.on__actionFitExponential_triggered)
def paintEvent(self, event):
painter = QPainter(self)
painter.setBrush(QBrush(self.color))
painter.setRenderHint(QPainter.Antialiasing)
fontscale = float(self._scale)
h = self.props['height'] * fontscale
w = self.props['width'] * fontscale
posscale = (w - 100) / self.props['posscale']
# Draw name above tube
if self.props['name']:
painter.setFont(self.font())
painter.drawText(5, 0, w, fontscale * 2.5, Qt.AlignCenter,
self.props['name'])
yoff = fontscale * 2.5
elif self.props['smalldet']:
yoff = 50
else:
yoff = 0
# Draw tube
painter.setPen(self.color)
painter.drawEllipse(5, 5 + yoff, 50, h)
painter.drawRect(30, 5 + yoff, w - 50, h)
painter.setPen(QColor('black'))
painter.drawArc(5, 5 + yoff, 50, h, 1440, 2880)
painter.drawLine(30, 5 + yoff, w - 25, 5 + yoff)
painter.drawLine(30, 5 + yoff + h, w - 25, 5 + yoff + h)
painter.drawEllipse(w - 45, 5 + yoff, 50, h)
if self.props['smalldet']:
sw = 20
sx = 30 + self.props['smalldet'] * posscale
painter.setPen(self.color)
painter.drawRect(sx - sw, 2, 2 * sw, yoff + 10)
painter.setPen(QColor('black'))
painter.drawLine(sx - sw, 5 + yoff, sx - sw, 2)
painter.drawLine(sx - sw, 2, sx + sw, 2)
painter.drawLine(sx + sw, 2, sx + sw, 5 + yoff)
# draw detector
pos_val = self._curval[0]
if pos_val is not None:
pos_status = self._curstatus[0]
pos_str = self._curstr[0]
x_val = self._curval[1]
x_status = self._curstatus[1]
x_str = '%.1f x' % x_val
y_val = self._curval[2]
y_status = self._curstatus[2]
y_str = '%.1f y' % y_val
stat = max(pos_status, x_status, y_status)
painter.setBrush(statusbrush[stat])
painter.setFont(self.valueFont)
painter.resetTransform()
# Translate to detector position
xp = 30 + pos_val * posscale
painter.translate(xp + fontscale / 2., 15 + yoff + (h - 20) / 2.)
painter.drawRect(-fontscale / 2., -(h - 20) / 2., fontscale,
h - 20)
painter.resetTransform()
# Put X/Y values left or right of detector depending on position
if pos_val < 14:
xoff = 2 * fontscale
else:
xoff = -8.5 * fontscale
# X translation
painter.drawText(xp + xoff, yoff + 2 * fontscale, 7 * fontscale,
2 * fontscale, Qt.AlignRight, x_str)
# Y translation
painter.drawText(xp + xoff, yoff + 3.5 * fontscale, 7 * fontscale,
2 * fontscale, Qt.AlignRight, y_str)
# Z position
minx = max(0, xp + 5 - 4 * fontscale)
painter.drawText(minx, h + 10 + yoff, 8 * fontscale, 30,
Qt.AlignCenter, pos_str)
# draw beamstop
if self.props['beamstop']:
painter.setPen(QPen(_blue.color()))
painter.drawRect(xp - 8,
yoff + 15 + posscale / 350 * (1100 - y_val),
2, 10)
# draw small detector
if self.props['smalldet'] and self._curval[4] is not None:
x_status = self._curstatus[3]
x_str = '%4.1f x' % self._curval[3]
y_status = self._curstatus[4]
y_val = self._curval[4]
y_str = '%4.0f y' % y_val
stat = max(x_status, y_status)
painter.setBrush(statusbrush[stat])
painter.setPen(QPen(_black.color()))
painter.setFont(self.valueFont)
sy = 10 + y_val * posscale / 250
painter.drawRect(sx - fontscale / 2., sy, fontscale, 30)
painter.drawText(sx - 10.5 * fontscale, sy, 8 * fontscale,
2 * fontscale, Qt.AlignRight, x_str)
painter.drawText(sx - 10.5 * fontscale, sy + 1.5 * fontscale,
8 * fontscale, 2 * fontscale, Qt.AlignRight,
y_str)
