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)