def paintEvent(self, a0: QPaintEvent) -> None:
super().paintEvent(a0)
painter = QPainter(self)
painter.save()
painter.setRenderHint(QPainter.Antialiasing)
rect = QRectF(self.margin, self.margin,
self.width() - self.margin * 2,
self.height() - 2 * self.margin)
painter.setBrush(Qt.white)
painter.setPen(Qt.white)
painter.drawEllipse(rect)
painter.restore()
painter.save()
painter.setRenderHint(QPainter.Antialiasing)
pen = QPen()
pen.setWidth(2)
painter.setPen(pen)
mid_point = QPointF(a0.rect().width() / 2, a0.rect().height() / 2)
radius = min(a0.rect().height(), a0.rect().width()) / 3
rays_num = 10
for i in range(rays_num):
point = QPointF(
math.sin(math.pi / (rays_num / 2) * i) * radius,
math.cos(math.pi / (rays_num / 2) * i) * radius)
painter.drawLine(mid_point + (point * 0.4), mid_point + point)
painter.restore()
def paintEvent(self, event):
"""
Paint events are sent to widgets that need to update themselves,
for instance when part of a widget is exposed because a covering
widget was moved.
This method handles the painting with parameters from the stylesheet,
configures the brush, pen and calls ```draw_icon``` so the specifics
can be performed for each of the drawing classes.
Parameters
----------
event : QPaintEvent
"""
opt = QStyleOption()
opt.initFrom(self)
painter = QPainter(self)
painter.setClipping(True)
self.style().drawPrimitive(QStyle.PE_Widget, opt, painter, self)
painter.setRenderHint(QPainter.Antialiasing)
w = self.width()
h = self.height()
painter.translate(w / 2.0, h / 2.0)
painter.rotate(self._rotation)
painter.translate(-w / 2.0, -h / 2.0)
painter.translate(self._pen_width / 2.0, self._pen_width / 2.0)
painter.scale(w - self._pen_width, h - self._pen_width)
painter.translate(0, 0)
painter.setBrush(self._brush)
painter.setPen(self._pen)
self.draw_icon(painter)
QWidget.paintEvent(self, event)
def paintEvent(self, e):
if self.points is None:
return
painter = QPainter(self)
pen = QPen() # creates a default pen
pen.setWidth(2)
pen.setCapStyle(Qt.RoundCap)
pen.setJoinStyle(Qt.RoundJoin)
painter.setPen(pen)
painter.setRenderHint(QPainter.Antialiasing)
# to avoid zero division
m = max(max(self.points), 10)
for i, v in enumerate(self.points):
pen.setBrush(self.colors[min(v * len(self.colors) // m,
len(self.colors) - 1)])
painter.setPen(pen)
painter.drawLine(
40 + 5 * i,
self.height() // 2 - min(v, self.height()) // 2,
40 + 5 * i,
self.height() // 2 + min(v, self.height()) // 2,
)
painter.end()
def paintEvent(self, event):
"""Override Qt method"""
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
# Decoration
painter.fillPath(self.path_current, QBrush(self.color))
painter.strokePath(self.path_decoration, QPen(self.color_decoration, self.stroke_decoration))
def legendIcon(self, index, size):
"""
:param int index: Index of the legend entry (ignored as there is only one)
:param QSizeF size: Icon size
:return: Icon representing the marker on the legend
.. seealso::
:py:meth:`qwt.plot.QwtPlotItem.setLegendIconSize()`,
:py:meth:`qwt.plot.QwtPlotItem.legendData()`
"""
if size.isEmpty():
return QwtGraphic()
icon = QwtGraphic()
icon.setDefaultSize(size)
icon.setRenderHint(QwtGraphic.RenderPensUnscaled, True)
painter = QPainter(icon)
painter.setRenderHint(
QPainter.Antialiasing, self.testRenderHint(QwtPlotItem.RenderAntialiased)
)
if self.__data.style != QwtPlotMarker.NoLine:
painter.setPen(self.__data.pen)
if self.__data.style in (QwtPlotMarker.HLine, QwtPlotMarker.Cross):
y = 0.5 * size.height()
painter.drawLine(0.0, y, size.width(), y)
if self.__data.style in (QwtPlotMarker.VLine, QwtPlotMarker.Cross):
x = 0.5 * size.width()
painter.drawLine(x, 0.0, x, size.height())
if self.__data.symbol:
r = QRect(0, 0, size.width(), size.height())
self.__data.symbol.drawSymbol(painter, r)
return icon
def paintEvent(self, QPaintEvent):
self.updatePosition()
painter = QPainter(self)
painter.fillRect(self.rect(), Qt.transparent)
painter.setRenderHint(QPainter.Antialiasing, True)
if self._currentCounter >= self._numberOfLines:
self._currentCounter = 0
painter.setPen(Qt.NoPen)
for i in range(self._numberOfLines):
painter.save()
painter.translate(self._innerRadius + self._lineLength,
self._innerRadius + self._lineLength)
rotateAngle = float(360 * i) / float(self._numberOfLines)
painter.rotate(rotateAngle)
painter.translate(self._innerRadius, 0)
distance = self.lineCountDistanceFromPrimary(
i, self._currentCounter, self._numberOfLines)
color = self.currentLineColor(distance, self._numberOfLines,
self._trailFadePercentage,
self._minimumTrailOpacity,
self._color)
painter.setBrush(color)
painter.drawRoundedRect(
QRectF(0, -self._lineWidth / 2, self._lineLength,
self._lineWidth), self._roundness, self._roundness,
Qt.RelativeSize)
painter.restore()
def paintEvent(self, a0: QPaintEvent) -> None:
super().paintEvent(a0)
painter = QPainter(self)
painter.save()
painter.setRenderHint(QPainter.Antialiasing)
pen2 = QPen()
rect = QRectF(self.margin,
self.height() / 2,
self.width() - self.margin * 2,
self.height() / 2 - self.margin)
rect2 = QRectF(3 * self.margin, 2 * self.margin,
self.width() - self.margin * 6, self.height())
pen2.setWidth(6)
painter.setPen(pen2)
painter.drawArc(rect2, 0, 180 * 16)
pen2.setWidth(3)
pen2.setColor(Qt.white)
painter.setPen(pen2)
painter.drawArc(rect2, 0, 180 * 16)
painter.fillRect(rect, Qt.white)
pen2.setWidth(2)
pen2.setColor(Qt.black)
painter.setPen(pen2)
painter.drawRect(rect)
painter.restore()
def paintEvent(self, a0: QPaintEvent) -> None:
super().paintEvent(a0)
painter = QPainter(self)
painter.save()
painter.setRenderHint(QPainter.Antialiasing)
rect = QRectF(self.margin, self.margin,
self.width() - self.margin * 2,
self.height() - 2 * self.margin)
painter.setBrush(Qt.white)
painter.setPen(Qt.white)
painter.drawRect(rect)
painter.restore()
painter.save()
painter.setRenderHint(QPainter.Antialiasing)
pen = QPen()
pen.setWidth(3)
painter.setPen(pen)
path = QPainterPath()
height, width = rect.height() + self.margin, rect.width() + self.margin
path.moveTo(self.margin, height)
path.cubicTo(height * 0.5, width * 0.9, height * 0.9, width * 0.5,
height, self.margin)
painter.drawPath(path)
painter.restore()
class PyDMBitIndicator(QWidget):
"""
A QWidget which draws a colored circle or rectangle
Parameters
----------
parent : QWidget
The parent widget for the Label
"""
def __init__(self, parent=None, circle=False):
super(PyDMBitIndicator, self).__init__(parent)
self.setAutoFillBackground(True)
self.circle = circle
self._painter = QPainter()
self._brush = QBrush(Qt.SolidPattern)
self._pen = QPen(Qt.SolidLine)
def paintEvent(self, event):
"""
Paint events are sent to widgets that need to update themselves,
for instance when part of a widget is exposed because a covering
widget was moved.
Parameters
----------
event : QPaintEvent
"""
self._painter.begin(self)
opt = QStyleOption()
opt.initFrom(self)
self.style().drawPrimitive(QStyle.PE_Widget, opt, self._painter, self)
self._painter.setRenderHint(QPainter.Antialiasing)
self._painter.setBrush(self._brush)
self._painter.setPen(self._pen)
if self.circle:
rect = self.rect()
w = rect.width()
h = rect.height()
r = min(w, h) / 2.0 - 2.0 * max(self._pen.widthF(), 1.0)
self._painter.drawEllipse(QPoint(w / 2.0, h / 2.0), r, r)
else:
self._painter.drawRect(self.rect())
self._painter.end()
def setColor(self, color):
"""
Property for the color to be used when drawing
Parameters
----------
QColor
"""
self._brush.setColor(color)
self.update()
def minimumSizeHint(self):
fm = QFontMetrics(self.font())
return QSize(fm.height(), fm.height())
class PyDMBitIndicator(QWidget):
"""
A QWidget which draws a colored circle or rectangle
Parameters
----------
parent : QWidget
The parent widget for the Label
"""
def __init__(self, parent=None, circle=False):
super(PyDMBitIndicator, self).__init__(parent)
self.setAutoFillBackground(True)
self.circle = circle
self._painter = QPainter()
self._brush = QBrush(Qt.SolidPattern)
self._pen = QPen(Qt.SolidLine)
def paintEvent(self, event):
"""
Paint events are sent to widgets that need to update themselves,
for instance when part of a widget is exposed because a covering
widget was moved.
Parameters
----------
event : QPaintEvent
"""
self._painter.begin(self)
opt = QStyleOption()
opt.initFrom(self)
self.style().drawPrimitive(QStyle.PE_Widget, opt, self._painter, self)
self._painter.setRenderHint(QPainter.Antialiasing)
self._painter.setBrush(self._brush)
self._painter.setPen(self._pen)
if self.circle:
rect = event.rect()
w = rect.width()
h = rect.height()
r = min(w, h) / 2.0 - 2.0 * max(self._pen.widthF(), 1.0)
self._painter.drawEllipse(QPoint(w / 2.0, h / 2.0), r, r)
else:
self._painter.drawRect(event.rect())
self._painter.end()
def setColor(self, color):
"""
Property for the color to be used when drawing
Parameters
----------
QColor
"""
self._brush.setColor(color)
self.update()
def minimumSizeHint(self):
fm = QFontMetrics(self.font())
return QSize(fm.height(), fm.height())
def mouseReleaseEvent(self, event):
if self.m_lastPos != QPoint(-1, -1):
p = QPainter(self.m_image)
p.setRenderHint(QPainter.Antialiasing)
p.drawLine(self.m_lastPos, event.pos())
self.m_lastPos = QPoint(-1, -1)
self.scheduleRender()
def paintEvent(self, event):
"""Override Qt method"""
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
# Decoration
painter.fillPath(self.path_current, QBrush(self.color))
painter.strokePath(self.path_decoration,
QPen(self.color_decoration, self.stroke_decoration))
def paint(self, painter: QtGui.QPainter, option: 'QStyleOptionViewItem',
index: QtCore.QModelIndex) -> None:
viewOption = QStyleOptionViewItem(option)
self.initStyleOption(viewOption, index)
QStyledItemDelegate.paint(self, painter, viewOption, index)
item = index.model().data(index, Qt.UserRole)
if isinstance(item, QVariant):
return
value = item['value']
type = item['type']
if type == 'checkbox':
# 数据转换
value = True if value == 1 else 0
# 绘制单选框
checkBoxStyle = QStyleOptionButton()
checkBoxStyle.state = QStyle.State_On if value else QStyle.State_Off
checkBoxStyle.state |= QStyle.State_Enabled
# 计算位置
size = item['size']
rect = calculate_middle_rect(option.rect, size, size)
checkBoxStyle.rect = rect
checkBox = QCheckBox()
QApplication.style().drawPrimitive(QStyle.PE_IndicatorCheckBox,
checkBoxStyle, painter,
checkBox)
if type == 'tag':
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setRenderHints(QPainter.SmoothPixmapTransform)
path = QPainterPath()
# 绘制文本
self.font = ResourceLoader().qt_font_text_tag
text_color = item['text_color']
border_color = item['border_color']
text = value
padding_v = 2
padding_h = 4
border_radius = 2
border_width = 1
painter.setFont(item['font'])
painter.setPen(text_color)
fm = QFontMetrics(painter.font())
w = fm.width(text)
h = fm.height()
# 计算位置
rect = calculate_middle_rect(option.rect, w + padding_h * 2,
h + padding_v * 2)
rectf = QRectF(rect.x(), rect.y(), rect.width(), rect.height())
painter.drawText(
QRect(rectf.x() + padding_h,
rectf.y() + padding_v, w, h), Qt.TextWordWrap, text)
# 绘制边框
path.addRoundedRect(rectf, border_radius, border_radius)
painter.strokePath(path, QPen(border_color, border_width))
def paintEvent(self, event: QEvent) -> None:
color = self.colors[self._state]
color = QColor(*(color.value))
painter = QPainter(self)
painter.setRenderHint(QPainter.HighQualityAntialiasing)
painter.setPen(QPen(color, 2))
painter.drawPolyline(self.coords)
event.accept()
def paintEvent(self, event):
""" """
self.build_paths()
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.fillPath(self.round_rect_path, self.color_back)
painter.fillPath(self.top_rect_path, self.color_top)
painter.strokePath(self.round_rect_path, QPen(Qt.gray, 1))
def paintEvent(self, event):
""" """
self.build_paths()
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.fillPath(self.round_rect_path, self.color_back)
painter.fillPath(self.top_rect_path, self.color_top)
painter.strokePath(self.round_rect_path, QPen(Qt.gray, 1))
def render_to_svggen(scene, svg_gen):
svg_gen.setSize(QSize(scene.width(), scene.height()))
svg_gen.setViewBox(QRect(0, 0, scene.width(), scene.height()))
svg_gen.setTitle("Hierarchic Component Drawing")
svg_gen.setDescription("A Hierarchic Component Drawing created by "
"Hildegard.")
painter = QPainter()
painter.begin(svg_gen)
painter.setRenderHint(QPainter.Antialiasing)
scene.render(painter)
painter.end()
def get_painter(surface):
# QImage is not hashable
if not isinstance(surface, QImage):
if surface in _painters:
return _painters[surface]
painter = QPainter(surface)
painter.setRenderHint(QPainter.Antialiasing)
painter.setRenderHint(QPainter.TextAntialiasing)
if not isinstance(surface, QImage):
_painters[surface] = painter
return painter
def setData(self, x: np.ndarray = None, y: np.ndarray = None, z: np.ndarray = None):
self.x, self.y, self.z = validate(x, y, z)
shapeChanged = False
if self.qpicture is None:
shapeChanged = True
elif (x is None) and (y is None) and (z is not None):
if (z.shape[0] != self.x[:, 1][-1]) or (z.shape[1] != self.y[0][-1]):
shapeChanged = True
elif (x is not None) and (y is not None) and (z is not None):
if np.any(self.x != x) or np.any(self.y != y):
shapeChanged = True
# initialize painting
self.qpicture = QPicture()
p = QPainter(self.qpicture)
p.setPen(
mkPen(
self.edgecolors if self.edgecolors is not None else QColor(0, 0, 0, 0)
)
)
if self.antialiasing:
p.setRenderHint(QPainter.HighQualityAntialiasing)
# transform
self.z = np.ma.masked_array(self.z, mask=~np.isfinite(self.z))
norm = self.z - self.z.min()
norm /= norm.max()
norm *= len(self.lut) - 1
norm = norm.astype(int)
# plot
for yi in range(norm.shape[0]):
for xi in range(norm.shape[1]):
if norm.mask[yi, xi]:
continue # TODO: support bad colors
c = self.lut[norm[yi, xi]]
p.setBrush(mkBrush(c))
rect = QRectF(
QPointF(self.x[yi + 1, xi + 1], self.y[yi + 1, xi + 1]),
QPointF(self.x[yi, xi], self.y[yi, xi]),
)
p.drawRect(rect)
# finish painting
p.end()
self.update()
self.prepareGeometryChange()
if shapeChanged:
self.informViewBoundsChanged()
def paintEvent(self, event):
"""Handle appearence of the widget on state updates."""
self.style().unpolish(self)
self.style().polish(self)
option = QStyleOption()
option.initFrom(self)
h = option.rect.height()
w = option.rect.width()
if self.m_shape in (self.ShapeMap.Triangle, self.ShapeMap.Round):
aspect = (4 /
3.0) if self.m_shape == self.ShapeMap.Triangle else 2.0
ah = w / aspect
aw = w
if ah > h:
ah = h
aw = h * aspect
x = abs(aw - w) / 2.0
y = abs(ah - h) / 2.0
bounds = QRectF(x, y, aw, ah)
else:
size = min(w, h)
x = abs(size - w) / 2.0
y = abs(size - h) / 2.0
bounds = QRectF(x, y, size, size)
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing, True)
ind = self.m_state % len(self.m_stateColors)
dark_r, dark_g, dark_b = self.getRGBfromQColor(self.m_stateColors[ind])
if not self.isEnabled():
dark_r, dark_g, dark_b = self.getRGBfromQColor(self.m_dsblColor)
sel1_r, sel1_g, sel1_b = self.getRGBfromQColor(self.SelColor)
sel2_r, sel2_g, sel2_b = self.getRGBfromQColor(self.SelColor)
opc = '1.000'
if not self.isSelected():
sel1_r, sel1_g, sel1_b = self.getRGBfromQColor(self.NotSelColor1)
sel2_r, sel2_g, sel2_b = self.getRGBfromQColor(self.NotSelColor2)
opc = '0.145'
dark_str = "rgb(%d,%d,%d)" % (dark_r, dark_g, dark_b)
light_str = "rgb(%d,%d,%d)" % self.adjust(dark_r, dark_g, dark_b)
sel1_str = "rgb(%d,%d,%d)" % (sel1_r, sel1_g, sel1_b)
sel2_str = "rgb(%d,%d,%d)" % (sel2_r, sel2_g, sel2_b)
shape_bytes = bytes(
self.shapesdict[self.m_shape] %
(sel1_str, opc, sel2_str, dark_str, light_str), 'utf-8')
self.renderer.load(QByteArray(shape_bytes))
self.renderer.render(painter, bounds)
def paintEvent(self, event):
painter = QPainter()
x = 0
y = 0
if self._alignment & Qt.AlignLeft:
x = 0
elif self._alignment & Qt.AlignRight:
x = self.width() - self._diameter
elif self._alignment & Qt.AlignHCenter:
x = (self.width() - self._diameter) / 2
elif self._alignment & Qt.AlignJustify:
x = 0
if self._alignment & Qt.AlignTop:
y = 0
elif self._alignment & Qt.AlignBottom:
y = self.height() - self._diameter
elif self._alignment & Qt.AlignVCenter:
y = (self.height() - self._diameter) / 2
gradient = QRadialGradient(x + self._diameter / 2,
y + self._diameter / 2,
self._diameter * 0.3, self._diameter * 0.1,
self._diameter * 0.1)
gradient.setColorAt(0, Qt.white)
# ensure the border/halo is same color as gradient
draw_color = QColor(self._color)
if not self._state:
# cut to black @ 70% for darker effect
draw_color = QColor(Qt.black)
if not self.isEnabled():
draw_color.setAlpha(30)
pen_color = draw_color
gradient.setColorAt(0.7, draw_color)
painter.begin(self)
brush = QBrush(gradient)
painter.setPen(pen_color)
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setBrush(brush)
painter.drawEllipse(x + 1, y + 1, self._diameter - 2,
self._diameter - 2)
if self._flashRate > 0 and self._flashing:
self._timer.start(self._flashRate)
else:
self._timer.stop()
painter.end()
def paintEvent(self, event):
painter = QPainter()
x = 0
y = 0
if self._alignment & Qt.AlignLeft:
x = 0
elif self._alignment & Qt.AlignRight:
x = self.width() - self._diameter
elif self._alignment & Qt.AlignHCenter:
x = (self.width() - self._diameter) / 2
elif self._alignment & Qt.AlignJustify:
x = 0
if self._alignment & Qt.AlignTop:
y = 0
elif self._alignment & Qt.AlignBottom:
y = self.height() - self._diameter
elif self._alignment & Qt.AlignVCenter:
y = (self.height() - self._diameter) / 2
# get the fill draw color set from QTDesigner
draw_color = QColor(self._color)
# set the pen color, we want to use this even if the state is OFF
pen_color = draw_color
if not self._state:
# LED state is OFF, set fill
draw_color = QColor(Qt.black)
# dim if control is not enabled
if not self.isEnabled():
draw_color.setAlpha(30)
# Start actual painting process
painter.begin(self)
brush = QBrush(draw_color)
painter.setPen(pen_color)
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setBrush(brush)
painter.drawEllipse(x + 1, y + 1, self._diameter - 2,
self._diameter - 2)
# Does flashing make sense for Monokrom style?
if self._flashRate > 0 and self._flashing:
self._timer.start(self._flashRate)
else:
self._timer.stop()
painter.end()
def paintEvent(self, event):
side = min(self.width(), self.height())
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.translate(self.width() / 2,
self.height() / 2) # painter坐标系原点移至widget中央
painter.scale(side / 200,
side / 200) # 缩放painterwidget坐标系，使绘制的时钟位于widge中央,即钟表支持缩放
self.draw_panel(painter) # 画外框表盘
self.draw_scale_num(painter) # 画刻度数字
self.draw_scale_line(painter) # 画刻度线
self.drawTitle(painter) # 画标题备注
self.drawValue(painter) # 画数显
self.drawIndicator(painter) # 画指针
def legendIcon(self, index, size):
"""
:param int index: Index of the legend entry (ignored as there is only one)
:param QSizeF size: Icon size
:return: Icon representing the curve on the legend
.. seealso::
:py:meth:`qwt.plot.QwtPlotItem.setLegendIconSize()`,
:py:meth:`qwt.plot.QwtPlotItem.legendData()`
"""
if size.isEmpty():
return QwtGraphic()
graphic = QwtGraphic()
graphic.setDefaultSize(size)
graphic.setRenderHint(QwtGraphic.RenderPensUnscaled, True)
painter = QPainter(graphic)
painter.setRenderHint(
QPainter.Antialiasing,
self.testRenderHint(QwtPlotItem.RenderAntialiased))
if self.__data.legendAttributes == 0 or (
self.__data.legendAttributes & QwtPlotCurve.LegendShowBrush):
brush = self.__data.brush
if brush.style(
) == Qt.NoBrush and self.__data.legendAttributes == 0:
if self.style() != QwtPlotCurve.NoCurve:
brush = QBrush(self.pen().color())
elif (self.__data.symbol
and self.__data.symbol.style() != QwtSymbol.NoSymbol):
brush = QBrush(self.__data.symbol.pen().color())
if brush.style() != Qt.NoBrush:
r = QRectF(0, 0, size.width(), size.height())
painter.fillRect(r, brush)
if self.__data.legendAttributes & QwtPlotCurve.LegendShowLine:
if self.pen() != Qt.NoPen:
pn = self.pen()
# pn.setCapStyle(Qt.FlatCap)
painter.setPen(pn)
y = 0.5 * size.height()
painter.drawLine(0.0, y, size.width(), y)
if self.__data.legendAttributes & QwtPlotCurve.LegendShowSymbol:
if self.__data.symbol:
r = QRectF(0, 0, size.width(), size.height())
self.__data.symbol.drawSymbol(painter, r)
return graphic
def drawline(self, p1, p2, angle, tip=False):
painter = QPainter()
painter.begin(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.setPen(Qt.blue)
pen = painter.pen()
pen.setWidth(2)
painter.setPen(pen)
painter.setBrush(Qt.blue)
painter.translate(p1)
painter.rotate(angle)
pt = (p2 - p1)
if tip:
pt /= (pt.x()**2 + pt.y()**2)**0.5 / 10
# painter.scale(scale, scale)
# painter.drawLine(QPoint(0, 0), (p2-p1)*scale)
painter.drawLine(QPoint(0, 0), pt)
return painter
def paintEvent(self, evt):
"""
Paint events are sent to widgets that need to update themselves,
for instance when part of a widget is exposed because a covering
widget was moved.
This method handles the painting with parameters from the stylesheet.
Parameters
----------
evt : QPaintEvent
"""
painter = QPainter(self)
opt = QStyleOption()
opt.initFrom(self)
self.style().drawPrimitive(QStyle.PE_Widget, opt, painter, self)
painter.setRenderHint(QPainter.Antialiasing)
super(PCDSSymbolBase, self).paintEvent(evt)
def paintEvent(self, event):
bw = float(self._border_width)
br = self._border_radius
val = self.value()
if self.orientation() == Qt.Horizontal:
w = QStyle.sliderPositionFromValue(self.minimum(), self.maximum(),
val, self.width())
h = self.height()
rect = QRectF(bw / 2, bw / 2, w - bw, h - bw)
else:
w = self.width()
h = self.height() - QStyle.sliderPositionFromValue(
self.minimum(), self.maximum(), val, self.height())
rect = QRectF(bw / 2, h - bw / 2, w - bw, self.height() - bw)
p = QPainter(self)
p.setRenderHint(QPainter.Antialiasing)
# draw the load meter value bar
p.setPen(Qt.transparent)
p.setBrush(self.gradient)
p.drawRoundedRect(rect, br, br)
# draw the border
p.setBrush(Qt.transparent)
border_pen = QPen()
border_pen.setWidth(bw)
border_pen.setColor(self._border_color)
p.setPen(border_pen)
rect = QRectF(bw / 2, bw / 2, self.width() - bw, self.height() - bw)
p.drawRoundedRect(rect, br, br)
# draw the load percentage text
p.setPen(self._text_color)
if self.orientation() == Qt.Vertical:
p.rotate(-90)
p.drawText(-self.height(), 0, self.height(), self.width(),
Qt.AlignCenter, self.text())
else:
p.drawText(0, 0, self.width(), self.height(), Qt.AlignCenter,
self.text())
def paintEvent(self, _):
"""
Paint events are sent to widgets that need to update themselves,
for instance when part of a widget is exposed because a covering
widget was moved.
At PyDMDrawing this method handles the alarm painting with parameters
from the stylesheet, configures the brush, pen and calls ```draw_item```
so the specifics can be performed for each of the drawing classes.
Parameters
----------
event : QPaintEvent
"""
painter = QPainter(self)
opt = QStyleOption()
opt.initFrom(self)
self.style().drawPrimitive(QStyle.PE_Widget, opt, painter, self)
painter.setRenderHint(QPainter.Antialiasing)
def paintEvent(self, event):
painter = QPainter()
painter.begin(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.fillRect(event.rect(), QBrush(QColor(255, 255, 255, 127)))
painter.setPen(QPen(QtCore.Qt.NoPen))
for i in range(6):
if (self.counter / 5) % 6 == i:
painter.setBrush(QBrush(QColor(127 + (self.counter % 5) * 32, 127, 127)))
else:
painter.setBrush(QBrush(QColor(127, 127, 127)))
painter.drawEllipse(
self.width() / 2 + 30 * np.cos(2 * np.pi * i / 6.0) - 10,
self.height() / 2 + 30 * np.sin(2 * np.pi * i / 6.0) - 10,
20, 20
)
painter.end()
def paintEvent(self, QPaintEvent):
if not self._isSpinning:
return
self.updatePosition()
painter = QPainter(self)
painter.fillRect(self.rect(), Qt.transparent)
painter.setRenderHint(QPainter.Antialiasing, True)
if self._currentCounter >= self._numberOfLines:
self._currentCounter = 0
painter.setPen(Qt.NoPen)
for i in range(0, self._numberOfLines):
painter.save()
painter.translate(self._innerRadius + self._lineLength,
self._innerRadius + self._lineLength)
rotateAngle = float(360 * i) / float(self._numberOfLines)
painter.rotate(rotateAngle)
painter.translate(self._innerRadius, 0)
distance = self.lineCountDistanceFromPrimary(
i, self._currentCounter, self._numberOfLines)
color = self.currentLineColor(distance, self._numberOfLines,
self._trailFadePercentage,
self._minimumTrailOpacity,
self._color)
# Compute the scaling factor to apply to the size and thickness
# of the lines in the trail.
if self._trailSizeDecreasing:
sf = (self._numberOfLines - distance) / self._numberOfLines
else:
sf = 1
painter.setBrush(color)
rect = QRect(0, round(-self._lineWidth / 2),
round(sf * self._lineLength),
round(sf * self._lineWidth))
painter.drawRoundedRect(rect, self._roundness, self._roundness,
Qt.RelativeSize)
painter.restore()
def paintEvent(self, event: QPaintEvent):
outerRadius = min(self.width(), self.height())
baseRect = QRectF(1, 1, outerRadius - 2, outerRadius - 2)
buffer = QImage(outerRadius, outerRadius, QImage.Format_ARGB32_Premultiplied)
p = QPainter(buffer)
p.setRenderHint(QPainter.Antialiasing)
self.rebuildDataBrushIfNeeded()
self.drawBackground(p, buffer.rect())
self.drawBase(p, baseRect)
if self.m_value > 0:
delta = (self.m_max - self.m_min) / (self.m_value - self.m_min)
else:
delta = 0
self.drawValue(p, baseRect, self.m_value, delta)
innerRect, innerRadius = self.calculateInnerRect(outerRadius)
self.drawInnerBackground(p, innerRect)
self.drawText(p, innerRect, innerRadius, self.m_value)
p.end()
painter = QPainter(self)
painter.fillRect(baseRect, self.palette().window())
painter.drawImage(0, 0, buffer)
def paintEvent(self, event):
"""Treat appearence changes based on connection state and value."""
self.style().unpolish(self)
self.style().polish(self)
if not self.isEnabled():
state = 'Disconnected'
elif self._bit_val == self._on:
state = 'On'
elif self._bit_val == self._off:
state = 'Off'
else:
state = 'Disconnected'
if self.shape == 0:
shape_dict = PyDMStateButton.squaredbuttonstatesdict
elif self.shape == 1:
shape_dict = PyDMStateButton.roundedbuttonstatesdict
option = QStyleOption()
option.initFrom(self)
h = option.rect.height()
w = option.rect.width()
aspect = 2.0
ah = w/aspect
aw = w
if ah > h:
ah = h
aw = h*aspect
x = abs(aw-w)/2.0
y = abs(ah-h)/2.0
bounds = QRectF(x, y, aw, ah)
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing, True)
shape_str = shape_dict[state]
buttonstate_bytearray = bytes(shape_str, 'utf-8')
self.renderer.load(QByteArray(buttonstate_bytearray))
self.renderer.render(painter, bounds)
class QScale(QFrame):
"""
A bar-shaped indicator for scalar value.
Configurable features include indicator type (bar/pointer), scale tick
marks and orientation (horizontal/vertical).
Parameters
----------
parent : QWidget
The parent widget for the Scale
"""
def __init__(self, parent=None):
super(QScale, self).__init__(parent)
self._value = 1
self._lower_limit = -5
self._upper_limit = 5
self.position = None # unit: pixel
self._bg_color = QColor('darkgray')
self._bg_size_rate = 0.8 # from 0 to 1
self._indicator_color = QColor('black')
self._pointer_width_rate = 0.05
self._barIndicator = False
self._num_divisions = 10
self._show_ticks = True
self._tick_pen = QPen()
self._tick_color = QColor('black')
self._tick_width = 0
self._tick_size_rate = 0.1 # from 0 to 1
self._painter = QPainter()
self._painter_rotation = None
self._painter_translation_y = None
self._painter_translation_x = None
self._painter_scale_x = None
self._flip_traslation_y = None
self._flip_scale_y = None
self._widget_width = self.width()
self._widget_height = self.height()
self._orientation = Qt.Horizontal
self._inverted_appearance = False
self._flip_scale = False
self._scale_height = 35
self._origin_at_zero = False
self._origin_position = 0
self.set_position()
def adjust_transformation(self):
"""
This method sets parameters for the widget transformations (needed to for
orientation, flipping and appearance inversion).
"""
self.setMaximumSize(QWIDGETSIZE_MAX,
QWIDGETSIZE_MAX) # Unset fixed size
if self._orientation == Qt.Horizontal:
self._widget_width = self.width()
self._widget_height = self.height()
self._painter_translation_y = 0
self._painter_rotation = 0
self.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
self.setFixedHeight(self._scale_height)
elif self._orientation == Qt.Vertical:
# Invert dimensions for paintEvent()
self._widget_width = self.height()
self._widget_height = self.width()
self._painter_translation_y = self._widget_width
self._painter_rotation = -90
self.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Expanding)
self.setFixedWidth(self._scale_height)
if self._inverted_appearance:
self._painter_translation_x = self._widget_width
self._painter_scale_x = -1
else:
self._painter_translation_x = 0
self._painter_scale_x = 1
if self._flip_scale:
self._flip_traslation_y = self._widget_height
self._flip_scale_y = -1
else:
self._flip_traslation_y = 0
self._flip_scale_y = 1
def set_tick_pen(self):
"""
Define pen style for drawing scale tick marks.
"""
self._tick_pen.setColor(self._tick_color)
self._tick_pen.setWidth(self._tick_width)
def draw_ticks(self):
"""
Draw tick marks on the scale.
"""
if not self._show_ticks:
return
self.set_tick_pen()
self._painter.setPen(self._tick_pen)
division_size = self._widget_width / self._num_divisions
tick_y0 = self._widget_height
tick_yf = (1 - self._tick_size_rate) * self._widget_height
for i in range(self._num_divisions + 1):
x = i * division_size
self._painter.drawLine(x, tick_y0, x, tick_yf) # x1, y1, x2, y2
def draw_bar(self):
"""
Draw a bar as indicator of current value.
"""
self.set_origin()
self.set_position()
if self.position < 0 or self.position > self._widget_width:
return
self._painter.setPen(Qt.transparent)
self._painter.setBrush(self._indicator_color)
bar_width = self.position - self._origin_position
bar_height = self._bg_size_rate * self._widget_height
self._painter.drawRect(self._origin_position, 0, bar_width, bar_height)
def draw_pointer(self):
"""
Draw a pointer as indicator of current value.
"""
self.set_position()
if self.position < 0 or self.position > self._widget_width:
return
self._painter.setPen(Qt.transparent)
self._painter.setBrush(self._indicator_color)
pointer_width = self._pointer_width_rate * self._widget_width
pointer_height = self._bg_size_rate * self._widget_height
points = [
QPoint(self.position, 0),
QPoint(self.position + 0.5 * pointer_width, 0.5 * pointer_height),
QPoint(self.position, pointer_height),
QPoint(self.position - 0.5 * pointer_width, 0.5 * pointer_height)
]
self._painter.drawPolygon(QPolygon(points))
def draw_indicator(self):
"""
Draw the selected indicator for current value.
"""
if self._barIndicator:
self.draw_bar()
else:
self.draw_pointer()
def draw_background(self):
"""
Draw the background of the scale.
"""
self._painter.setPen(Qt.transparent)
self._painter.setBrush(self._bg_color)
bg_width = self._widget_width
bg_height = self._bg_size_rate * self._widget_height
self._painter.drawRect(0, 0, bg_width, bg_height)
def paintEvent(self, event):
"""
Paint events are sent to widgets that need to update themselves,
for instance when part of a widget is exposed because a covering
widget was moved.
Parameters
----------
event : QPaintEvent
"""
self.adjust_transformation()
self._painter.begin(self)
self._painter.translate(
0, self._painter_translation_y) # Draw vertically if needed
self._painter.rotate(self._painter_rotation)
self._painter.translate(self._painter_translation_x,
0) # Invert appearance if needed
self._painter.scale(self._painter_scale_x, 1)
self._painter.translate(
0, self._flip_traslation_y) # Invert scale if needed
self._painter.scale(1, self._flip_scale_y)
self._painter.setRenderHint(QPainter.Antialiasing)
self.draw_background()
self.draw_ticks()
self.draw_indicator()
self._painter.end()
def calculate_position_for_value(self, value):
"""
Calculate the position (pixel) in which the pointer should be drawn for a given value.
"""
if value is None or value < self._lower_limit or value > self._upper_limit or \
self._upper_limit - self._lower_limit == 0:
proportion = -1 # Invalid
else:
proportion = (value - self._lower_limit) / (self._upper_limit -
self._lower_limit)
position = int(proportion * self._widget_width)
return position
def set_origin(self):
"""
Set the position (pixel) in which the origin should be drawn.
"""
if self._origin_at_zero:
self._origin_position = self.calculate_position_for_value(0)
else:
self._origin_position = 0
def set_position(self):
"""
Set the position (pixel) in which the pointer should be drawn.
"""
self.position = self.calculate_position_for_value(self._value)
def update_indicator(self):
"""
Update the position and the drawing of indicator.
"""
self.set_position()
self.repaint()
def set_value(self, value):
"""
Set a new current value for the indicator.
"""
self._value = value
self.update_indicator()
def set_upper_limit(self, new_limit):
"""
Set the scale upper limit.
Parameters
----------
new_limit : float
The upper limit of the scale.
"""
self._upper_limit = new_limit
def set_lower_limit(self, new_limit):
"""
Set the scale lower limit.
Parameters
----------
new_limit : float
The lower limit of the scale.
"""
self._lower_limit = new_limit
def get_show_ticks(self):
return self._show_ticks
def set_show_ticks(self, checked):
if self._show_ticks != bool(checked):
self._show_ticks = checked
self.repaint()
def get_orientation(self):
return self._orientation
def set_orientation(self, orientation):
self._orientation = orientation
self.adjust_transformation()
self.repaint()
def get_flip_scale(self):
return self._flip_scale
def set_flip_scale(self, checked):
self._flip_scale = bool(checked)
self.adjust_transformation()
self.repaint()
def get_inverted_appearance(self):
return self._inverted_appearance
def set_inverted_appearance(self, inverted):
self._inverted_appearance = inverted
self.adjust_transformation()
self.repaint()
def get_bar_indicator(self):
return self._barIndicator
def set_bar_indicator(self, checked):
if self._barIndicator != bool(checked):
self._barIndicator = checked
self.repaint()
def get_background_color(self):
return self._bg_color
def set_background_color(self, color):
self._bg_color = color
self.repaint()
def get_indicator_color(self):
return self._indicator_color
def set_indicator_color(self, color):
self._indicator_color = color
self.repaint()
def get_tick_color(self):
return self._tick_color
def set_tick_color(self, color):
self._tick_color = color
self.repaint()
def get_background_size_rate(self):
return self._bg_size_rate
def set_background_size_rate(self, rate):
if rate >= 0 and rate <= 1 and self._bg_size_rate != rate:
self._bg_size_rate = rate
self.repaint()
def get_tick_size_rate(self):
return self._tick_size_rate
def set_tick_size_rate(self, rate):
if rate >= 0 and rate <= 1 and self._tick_size_rate != rate:
self._tick_size_rate = rate
self.repaint()
def get_num_divisions(self):
return self._num_divisions
def set_num_divisions(self, divisions):
if isinstance(
divisions,
int) and divisions > 0 and self._num_divisions != divisions:
self._num_divisions = divisions
self.repaint()
def get_scale_height(self):
return self._scale_height
def set_scale_height(self, value):
self._scale_height = int(value)
self.adjust_transformation()
self.repaint()
def get_origin_at_zero(self):
return self._origin_at_zero
def set_origin_at_zero(self, checked):
if self._origin_at_zero != bool(checked):
self._origin_at_zero = checked
self.repaint()
class QScale(QFrame):
"""
A bar-shaped indicator for scalar value.
Configurable features include indicator type (bar/pointer), scale tick
marks and orientation (horizontal/vertical).
Parameters
----------
parent : QWidget
The parent widget for the Scale
"""
def __init__(self, parent=None):
super(QScale, self).__init__(parent)
self._value = 1
self._lower_limit = -5
self._upper_limit = 5
self.position = None # unit: pixel
self._bg_color = QColor('darkgray')
self._bg_size_rate = 0.8 # from 0 to 1
self._indicator_color = QColor('black')
self._pointer_width_rate = 0.05
self._barIndicator = False
self._num_divisions = 10
self._show_ticks = True
self._tick_pen = QPen()
self._tick_color = QColor('black')
self._tick_width = 0
self._tick_size_rate = 0.1 # from 0 to 1
self._painter = QPainter()
self._painter_rotation = None
self._painter_translation_y = None
self._painter_translation_x = None
self._painter_scale_x = None
self._flip_traslation_y = None
self._flip_scale_y = None
self._widget_width = self.width()
self._widget_height = self.height()
self._orientation = Qt.Horizontal
self._inverted_appearance = False
self._flip_scale = False
self._scale_height = 35
self._origin_at_zero = False
self._origin_position = 0
self.set_position()
def adjust_transformation(self):
"""
This method sets parameters for the widget transformations (needed to for
orientation, flipping and appearance inversion).
"""
self.setMaximumSize(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX) # Unset fixed size
if self._orientation == Qt.Horizontal:
self._widget_width = self.width()
self._widget_height = self.height()
self._painter_translation_y = 0
self._painter_rotation = 0
self.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
self.setFixedHeight(self._scale_height)
elif self._orientation == Qt.Vertical:
# Invert dimensions for paintEvent()
self._widget_width = self.height()
self._widget_height = self.width()
self._painter_translation_y = self._widget_width
self._painter_rotation = -90
self.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Expanding)
self.setFixedWidth(self._scale_height)
if self._inverted_appearance:
self._painter_translation_x = self._widget_width
self._painter_scale_x = -1
else:
self._painter_translation_x = 0
self._painter_scale_x = 1
if self._flip_scale:
self._flip_traslation_y = self._widget_height
self._flip_scale_y = -1
else:
self._flip_traslation_y = 0
self._flip_scale_y = 1
def set_tick_pen(self):
"""
Define pen style for drawing scale tick marks.
"""
self._tick_pen.setColor(self._tick_color)
self._tick_pen.setWidth(self._tick_width)
def draw_ticks(self):
"""
Draw tick marks on the scale.
"""
if not self._show_ticks:
return
self.set_tick_pen()
self._painter.setPen(self._tick_pen)
division_size = self._widget_width / self._num_divisions
tick_y0 = self._widget_height
tick_yf = (1 - self._tick_size_rate)*self._widget_height
for i in range(self._num_divisions+1):
x = i*division_size
self._painter.drawLine(x, tick_y0, x, tick_yf) # x1, y1, x2, y2
def draw_bar(self):
"""
Draw a bar as indicator of current value.
"""
self.set_origin()
self.set_position()
if self.position < 0 or self.position > self._widget_width:
return
self._painter.setPen(Qt.transparent)
self._painter.setBrush(self._indicator_color)
bar_width = self.position - self._origin_position
bar_height = self._bg_size_rate * self._widget_height
self._painter.drawRect(self._origin_position, 0, bar_width, bar_height)
def draw_pointer(self):
"""
Draw a pointer as indicator of current value.
"""
self.set_position()
if self.position < 0 or self.position > self._widget_width:
return
self._painter.setPen(Qt.transparent)
self._painter.setBrush(self._indicator_color)
pointer_width = self._pointer_width_rate * self._widget_width
pointer_height = self._bg_size_rate * self._widget_height
points = [
QPoint(self.position, 0),
QPoint(self.position + 0.5*pointer_width, 0.5*pointer_height),
QPoint(self.position, pointer_height),
QPoint(self.position - 0.5*pointer_width, 0.5*pointer_height)
]
self._painter.drawPolygon(QPolygon(points))
def draw_indicator(self):
"""
Draw the selected indicator for current value.
"""
if self._barIndicator:
self.draw_bar()
else:
self.draw_pointer()
def draw_background(self):
"""
Draw the background of the scale.
"""
self._painter.setPen(Qt.transparent)
self._painter.setBrush(self._bg_color)
bg_width = self._widget_width
bg_height = self._bg_size_rate * self._widget_height
self._painter.drawRect(0, 0, bg_width, bg_height)
def paintEvent(self, event):
"""
Paint events are sent to widgets that need to update themselves,
for instance when part of a widget is exposed because a covering
widget was moved.
Parameters
----------
event : QPaintEvent
"""
self.adjust_transformation()
self._painter.begin(self)
self._painter.translate(0, self._painter_translation_y) # Draw vertically if needed
self._painter.rotate(self._painter_rotation)
self._painter.translate(self._painter_translation_x, 0) # Invert appearance if needed
self._painter.scale(self._painter_scale_x, 1)
self._painter.translate(0, self._flip_traslation_y) # Invert scale if needed
self._painter.scale(1, self._flip_scale_y)
self._painter.setRenderHint(QPainter.Antialiasing)
self.draw_background()
self.draw_ticks()
self.draw_indicator()
self._painter.end()
def calculate_position_for_value(self, value):
"""
Calculate the position (pixel) in which the pointer should be drawn for a given value.
"""
if value < self._lower_limit or value > self._upper_limit or \
self._upper_limit - self._lower_limit == 0:
proportion = -1 # Invalid
else:
proportion = (value - self._lower_limit) / (self._upper_limit - self._lower_limit)
position = int(proportion * self._widget_width)
return position
def set_origin(self):
"""
Set the position (pixel) in which the origin should be drawn.
"""
if self._origin_at_zero:
self._origin_position = self.calculate_position_for_value(0)
else:
self._origin_position = 0
def set_position(self):
"""
Set the position (pixel) in which the pointer should be drawn.
"""
self.position = self.calculate_position_for_value(self._value)
def update_indicator(self):
"""
Update the position and the drawing of indicator.
"""
self.set_position()
self.repaint()
def set_value(self, value):
"""
Set a new current value for the indicator.
"""
self._value = value
self.update_indicator()
def set_upper_limit(self, new_limit):
"""
Set the scale upper limit.
Parameters
----------
new_limit : float
The upper limit of the scale.
"""
self._upper_limit = new_limit
def set_lower_limit(self, new_limit):
"""
Set the scale lower limit.
Parameters
----------
new_limit : float
The lower limit of the scale.
"""
self._lower_limit = new_limit
def get_show_ticks(self):
return self._show_ticks
def set_show_ticks(self, checked):
if self._show_ticks != bool(checked):
self._show_ticks = checked
self.repaint()
def get_orientation(self):
return self._orientation
def set_orientation(self, orientation):
self._orientation = orientation
self.adjust_transformation()
self.repaint()
def get_flip_scale(self):
return self._flip_scale
def set_flip_scale(self, checked):
self._flip_scale = bool(checked)
self.adjust_transformation()
self.repaint()
def get_inverted_appearance(self):
return self._inverted_appearance
def set_inverted_appearance(self, inverted):
self._inverted_appearance = inverted
self.adjust_transformation()
self.repaint()
def get_bar_indicator(self):
return self._barIndicator
def set_bar_indicator(self, checked):
if self._barIndicator != bool(checked):
self._barIndicator = checked
self.repaint()
def get_background_color(self):
return self._bg_color
def set_background_color(self, color):
self._bg_color = color
self.repaint()
def get_indicator_color(self):
return self._indicator_color
def set_indicator_color(self, color):
self._indicator_color = color
self.repaint()
def get_tick_color(self):
return self._tick_color
def set_tick_color(self, color):
self._tick_color = color
self.repaint()
def get_background_size_rate(self):
return self._bg_size_rate
def set_background_size_rate(self, rate):
if rate >= 0 and rate <=1 and self._bg_size_rate != rate:
self._bg_size_rate = rate
self.repaint()
def get_tick_size_rate(self):
return self._tick_size_rate
def set_tick_size_rate(self, rate):
if rate >= 0 and rate <=1 and self._tick_size_rate != rate:
self._tick_size_rate = rate
self.repaint()
def get_num_divisions(self):
return self._num_divisions
def set_num_divisions(self, divisions):
if isinstance(divisions, int) and divisions > 0 and self._num_divisions != divisions:
self._num_divisions = divisions
self.repaint()
def get_scale_height(self):
return self._scale_height
def set_scale_height(self, value):
self._scale_height = int(value)
self.adjust_transformation()
self.repaint()
def get_origin_at_zero(self):
return self._origin_at_zero
def set_origin_at_zero(self, checked):
if self._origin_at_zero != bool(checked):
self._origin_at_zero = checked
self.repaint()
