def paintEvent(self, paintEvent): painter = QPainter(self) painter.setClipRect(paintEvent.rect()) color = self.__editor.palette().text() painter.setPen(QPen(color, self.__lineWidth)) painter.drawRect(self.rect())
def paint(self, painter: QPainter, option: 'QStyleOptionViewItem',
index: QModelIndex) -> None:
painter.setRenderHint(QPainter.Antialiasing, True)
painter_box_rect = option.rect.marginsRemoved(QMargins(1, 1, 1, 1))
painter_pix_rect = option.rect.marginsRemoved(QMargins(10, 10, 10, 10))
try:
painter.save()
try:
painter.setClipRect(painter_box_rect, Qt.IntersectClip)
if option.state & QStyle.State_Selected:
painter.fillRect(painter_box_rect,
option.palette.highlight())
painter.setPen(option.palette.highlight().color())
else:
painter.setPen(option.palette.alternateBase().color())
painter.drawRect(painter_box_rect)
finally:
painter.restore()
try:
pix = self._get_media_pixmap(index.data(), option,
painter_pix_rect.size())
except Exception as ex:
c = option.palette.text().color()
c.setAlphaF(.15)
painter.fillRect(painter_pix_rect,
QBrush(c, Qt.DiagCrossPattern))
if not isinstance(ex, KeyError):
import traceback
traceback.print_exc()
else:
painter.drawPixmap(painter_pix_rect, pix, pix.rect())
except:
import traceback
traceback.print_exc()
def paintEvent(self, event):
"""Paints the board."""
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setPen(QPen(Qt.black, Qt.SolidLine))
painter.setBrush(QBrush(Qt.white, Qt.SolidPattern))
painter.setClipRect(0, 0, self.canvas.width(), self.canvas.height())
# background
painter.drawRect(0, 0, self.canvas.width(), self.canvas.height())
painter.translate(*self.translation)
painter.scale(self.scale, self.scale)
# draw vertexes
for n1 in self.graph.get_nodes():
for n2, weight in n1.get_neighbours().items():
self.draw_vertex(n1, n2, weight, painter)
# draw nodes
for node in self.graph.get_nodes():
self.draw_node(node, painter)
def paintEvent(self, e):
painter = QPainter(self)
# Draw empty button (no label or icon).
buttonStyle = QStyleOptionButton()
self.initStyleOption(buttonStyle)
buttonStyle.text = ''
buttonStyle.icon = QIcon()
buttonStyle.iconSize = QSize(-1, -1)
self.style().drawControl(QStyle.CE_PushButton, buttonStyle, painter, self)
# Get button label style.
labelStyle = QStyleOptionButton()
self.initStyleOption(labelStyle)
labelStyle.rect = self.style().subElementRect(QStyle.SE_PushButtonContents, labelStyle, self)
# Clip everything we paint to label area.
painter.setClipRect(labelStyle.rect)
painter.setClipping(True)
# TODO
painter.translate(-200, 0); # Has to happen after we set clipping.
# Draw label (optionally with icon), similar to how Qt does it (src/widgets/styles/qcommonstyle.cpp in Qt 5.3).
self.style().drawControl(QStyle.CE_PushButtonLabel, labelStyle, painter, self)
def paintEvent(self, event):
p = QPainter(self)
if self.scrollEnabled:
self.buffer.fill(qRgba(0, 0, 0, 0))
pb = QPainter(self.buffer)
pb.setPen(p.pen())
pb.setFont(p.font())
x = min(-self.scrollPos, 0) + self.leftMargin
while x < self.width():
pb.drawStaticText(
QPointF(x,
(self.height() - self.wholeTextSize.height()) / 2)
+ QPoint(2, 2), self.staticText)
x += self.wholeTextSize.width()
#Apply Alpha Channel
pb.setCompositionMode(QPainter.CompositionMode_DestinationIn)
pb.setClipRect(self.width() - 15, 0, 15, self.height())
pb.drawImage(0, 0, self.alphaChannel)
pb.setClipRect(0, 0, 15, self.height())
#initial situation: don't apply alpha channel in the left half of the image at all; apply it more and more until scrollPos gets positive
if self.scrollPos < 0:
pb.setOpacity((max(-8, self.scrollPos) + 8) / 8.0)
pb.drawImage(0, 0, self.alphaChannel)
p.drawImage(0, 0, self.buffer)
else:
x = (self.width() - self.wholeTextSize.width()) / 2
y = (self.height() - self.wholeTextSize.height()) / 2
p.drawStaticText(QPointF(x, y), self.staticText)
def paintEvent(self, ev):
super(TagsLabelWidget, self).paintEvent(ev)
painter = QPainter(self)
painter.save()
try:
painter.setBackground(self.palette().brush(self.backgroundRole()))
painter.eraseRect(ev.rect())
painter.setClipRect(ev.rect())
fm = QFontMetrics(self.font()) # TODO use style
x = self.xmargin
for sz, tag in self._positions(self.tags):
fg, bg = tag_to_colors(tag)
painter.setPen(fg.color())
painter.fillRect(x, self.ymargin,
sz.width() + 2 * self.xpadding, fm.height(),
bg.color())
painter.drawText(x + self.xpadding, self.ymargin + fm.ascent(),
tag)
x += sz.width() + self.xmargin + 2 * self.xpadding
finally:
painter.restore()
def paintEvent(self, event):
content_rect = self.contentsRect()
if self.spinner_size:
size = min(self.spinner_size, content_rect.width(),
content_rect.height())
else:
size = min(content_rect.width(), content_rect.height())
dot_count = 5
dot_size = int(size / dot_count) * 1.5
spinner_rect = QRect(content_rect.left(), content_rect.top(), size,
size)
painter = QPainter(self)
painter.setClipRect(content_rect)
if self.timer_id:
diff_height = content_rect.height() - size
offs_y = 0
if diff_height > 0:
if self.vertical_align == Qt.AlignVCenter:
offs_y = diff_height / 2
elif self.vertical_align == Qt.AlignBottom:
offs_y = diff_height
x_center = spinner_rect.left(
) + spinner_rect.width() / 2 - dot_size / 2
y_center = spinner_rect.top(
) + offs_y + spinner_rect.height() / 2 - dot_size / 2
painter.save()
for i in range(dot_count):
if self.counter % dot_count == i:
painter.setBrush(QBrush(QColor(0, 0, 0)))
d_size = dot_size * 1.1
else:
painter.setBrush(QBrush(QColor(200, 200, 200)))
d_size = dot_size
r = size / 2 - dot_size / 2
x = r * math.cos(2 * math.pi * i / dot_count)
y = r * math.sin(2 * math.pi * i / dot_count)
painter.drawEllipse(x_center + x, y_center + y, d_size, d_size)
painter.restore()
if self.message:
# painter.setPen(QPen(Qt.black))
if self.font_size:
f = painter.font()
f.setPointSize(self.font_size)
painter.setFont(f)
text_rect = QRect(content_rect)
text_rect.translate(
spinner_rect.width() +
SpinnerWidget.SPINNER_TO_TEXT_DISTANCE if self.timer_id else 0,
0)
painter.drawText(text_rect, Qt.AlignLeft | Qt.AlignVCenter,
self.message)
painter.end()
def paintEvent(self, ev):
color = self.palette().color(QPalette.Highlight)
painter = QPainter(self)
# Filled rectangle.
painter.setClipRect(self.rect())
color.setAlpha(50)
painter.fillRect(self.rect().adjusted(2,2,-2,-2), color)
# Thin rectangle outside.
color.setAlpha(150)
painter.setPen(color)
painter.drawRect(self.rect().adjusted(0,0,-1,-1))
# Pseudo-handles at the corners and sides
color.setAlpha(100)
pen = QPen(color)
pen.setWidth(8)
painter.setPen(pen)
painter.setBackgroundMode(Qt.OpaqueMode)
# Clip at 4 corners
region = QRegion(QRect(0,0,20,20))
region += QRect(self.rect().width()-20, 0, 20, 20)
region += QRect(self.rect().width()-20, self.rect().height()-20, 20, 20)
region += QRect(0, self.rect().height()-20, 20, 20)
# Clip middles
region += QRect(0, self.rect().height() // 2 - 10, self.rect().width(), 20)
region += QRect(self.rect().width() // 2 - 10, 0, 20, self.rect().height())
# Draw thicker rectangles, clipped at corners and sides.
painter.setClipRegion(region)
painter.drawRect(self.rect())
def _render_qwebpage_full(self, web_rect, render_rect, canvas_size):
"""Render web page in one step."""
if self._qpainter_needs_tiling(render_rect, canvas_size):
# If this condition is true, this function may get stuck.
raise ValueError("Rendering region is too large to be drawn"
" in one step, use tile-by-tile renderer instead")
canvas = QImage(canvas_size, self.qt_image_format)
if self.is_jpeg():
# White background for JPEG images, same as we have in all browsers.
canvas.fill(Qt.white)
else:
# Preserve old behaviour for PNG format.
canvas.fill(0)
painter = QPainter(canvas)
try:
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setRenderHint(QPainter.TextAntialiasing, True)
painter.setRenderHint(QPainter.SmoothPixmapTransform, True)
painter.setWindow(web_rect)
painter.setViewport(render_rect)
painter.setClipRect(web_rect)
self.web_page.mainFrame().render(painter)
finally:
painter.end()
return WrappedQImage(canvas)
def _render_qwebpage_full(self, web_rect, render_rect, canvas_size):
"""Render web page in one step."""
if self._qpainter_needs_tiling(render_rect, canvas_size):
# If this condition is true, this function may get stuck.
raise ValueError("Rendering region is too large to be drawn"
" in one step, use tile-by-tile renderer instead")
canvas = QImage(canvas_size, self.qt_image_format)
if self.is_jpeg():
# White background for JPEG images, same as we have in all browsers.
canvas.fill(Qt.white)
else:
# Preserve old behaviour for PNG format.
canvas.fill(0)
painter = QPainter(canvas)
try:
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setRenderHint(QPainter.TextAntialiasing, True)
painter.setRenderHint(QPainter.SmoothPixmapTransform, True)
painter.setWindow(web_rect)
painter.setViewport(render_rect)
painter.setClipRect(web_rect)
self.web_page.mainFrame().render(painter)
finally:
painter.end()
return WrappedQImage(canvas)
def paintEvent(self, ev):
### Paint code contributed by Richard Cognot Jun 2012
color = self.palette().color(QPalette.Highlight)
painter = QPainter(self)
# Filled rectangle.
painter.setClipRect(self.rect())
color.setAlpha(50)
painter.fillRect(self.rect().adjusted(2,2,-2,-2), color)
# Thin rectangle outside.
color.setAlpha(150)
painter.setPen(color)
painter.drawRect(self.rect().adjusted(0,0,-1,-1))
# Pseudo-handles at the corners and sides
color.setAlpha(100)
pen = QPen(color)
pen.setWidth(8)
painter.setPen(pen)
painter.setBackgroundMode(Qt.OpaqueMode)
# Clip at 4 corners
region = QRegion(QRect(0,0,20,20))
region += QRect(self.rect().width()-20, 0, 20, 20)
region += QRect(self.rect().width()-20, self.rect().height()-20, 20, 20)
region += QRect(0, self.rect().height()-20, 20, 20)
# Clip middles
region += QRect(0, self.rect().height() // 2 - 10, self.rect().width(), 20)
region += QRect(self.rect().width() // 2 - 10, 0, 20, self.rect().height())
# Draw thicker rectangles, clipped at corners and sides.
painter.setClipRegion(region)
painter.drawRect(self.rect())
def _render_qwebpage_full(
self,
web_rect: QRect,
render_rect: QRect,
canvas_size: QSize,
) -> 'WrappedImage':
""" Render web page in one step. """
if self._qpainter_needs_tiling(render_rect, canvas_size):
# If this condition is true, this function may get stuck.
raise ValueError("Rendering region is too large to be drawn"
" in one step, use tile-by-tile renderer instead")
canvas = self.img_converter.new_qimage(canvas_size)
painter = QPainter(canvas)
try:
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setRenderHint(QPainter.TextAntialiasing, True)
painter.setRenderHint(QPainter.SmoothPixmapTransform, True)
painter.setWindow(web_rect)
painter.setViewport(render_rect)
painter.setClipRect(web_rect)
# self.web_page.mainFrame().render(painter)
self.web_page.view().render(painter)
finally:
painter.end()
return WrappedQImage(canvas)
def paintEvent(self, paintEvent):
painter = QPainter(self)
painter.setClipRect(paintEvent.rect())
color = self.__editor.palette().text()
painter.setPen(QPen(color, self.__lineWidth))
painter.drawRect(self.rect())
def getPixmap(self):
pixmap = QPixmap(self.width * self.pixelRatio,
self.height * self.pixelRatio)
pixmap.setDevicePixelRatio(self.pixelRatio)
pixmap.fill(Qt.transparent)
painter = QPainter(pixmap)
painter.setRenderHint(QPainter.Antialiasing)
painter.translate(0, self.height)
painter.scale(1, -1)
if self.headerAtBottom:
bodyRect = (0, 0, self.width, self.height - self.headerHeight)
headerRect = (0, 0, self.width, self.headerHeight)
else:
bodyRect = (0, 0, self.width, self.height - self.headerHeight)
headerRect = (0, 0, self.width, self.headerHeight)
# background
painter.save()
if self.headerAtBottom:
h = self.height
else:
h = self.height - self.headerHeight
painter.translate(0, h)
painter.scale(1, -1)
self.drawCellBackground(painter, bodyRect)
painter.restore()
# glyph
if self.headerAtBottom:
painter.translate(0, self.headerHeight)
if self.shouldDrawMetrics:
self.drawCellHorizontalMetrics(painter, bodyRect)
self.drawCellVerticalMetrics(painter, bodyRect)
painter.save()
painter.setClipRect(0, 0, self.width, self.height - self.headerHeight)
painter.translate(self.xOffset, self.yOffset)
painter.scale(self.scale, self.scale)
self.drawCellGlyph(painter)
painter.restore()
# foreground
painter.save()
painter.translate(0, self.height - self.headerHeight)
painter.scale(1, -1)
self.drawCellForeground(painter, bodyRect)
painter.restore()
# header
if self.shouldDrawHeader:
painter.save()
if self.headerAtBottom:
h = 0
else:
h = self.height
painter.translate(0, h)
painter.scale(1, -1)
self.drawCellHeaderBackground(painter, headerRect)
self.drawCellHeaderText(painter, headerRect)
painter.restore()
return pixmap
def paintEvent(self, paint_event):
painter = QPainter(self)
if self._page_number == 0:
painter.setClipRect(QRectF(0, 0, self.page.width(), self.page.height()-self._offset_top()))
painter.translate(0, -self._offset_top())
else:
painter.setClipRect(QRectF(0, 0, self.page.width(), self.page.height()))
height = self.page.height()
painter.translate(0, -self._page_number*height)
self._document.drawContents(painter)
def getPixmap(self):
pixmap = QPixmap(self.width * self.pixelRatio, self.height * self.pixelRatio)
pixmap.setDevicePixelRatio(self.pixelRatio)
pixmap.fill(Qt.transparent)
painter = QPainter(pixmap)
painter.setRenderHint(QPainter.Antialiasing)
painter.translate(0, self.height)
painter.scale(1, -1)
if self.headerAtBottom:
bodyRect = (0, 0, self.width, self.height-self.headerHeight)
headerRect = (0, 0, self.width, self.headerHeight)
else:
bodyRect = (0, 0, self.width, self.height-self.headerHeight)
headerRect = (0, 0, self.width, self.headerHeight)
# background
painter.save()
if self.headerAtBottom:
h = self.height
else:
h = self.height - self.headerHeight
painter.translate(0, h)
painter.scale(1, -1)
self.drawCellBackground(painter, bodyRect)
painter.restore()
# glyph
if self.headerAtBottom:
painter.translate(0, self.headerHeight)
if self.shouldDrawMetrics:
self.drawCellHorizontalMetrics(painter, bodyRect)
self.drawCellVerticalMetrics(painter, bodyRect)
painter.save()
painter.setClipRect(0, 0, self.width, self.height-self.headerHeight)
painter.translate(self.xOffset, self.yOffset)
painter.scale(self.scale, self.scale)
self.drawCellGlyph(painter)
painter.restore()
# foreground
painter.save()
painter.translate(0, self.height - self.headerHeight)
painter.scale(1, -1)
self.drawCellForeground(painter, bodyRect)
painter.restore()
# header
if self.shouldDrawHeader:
painter.save()
if self.headerAtBottom:
h = 0
else:
h = self.height
painter.translate(0, h)
painter.scale(1, -1)
self.drawCellHeaderBackground(painter, headerRect)
self.drawCellHeaderText(painter, headerRect)
painter.restore()
return pixmap
def paintEvent(self, event):
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setClipRect(0, 0, self.width(), self.height())
if self.object is None:
return
self.object.draw(painter, self.width(), self.height())
painter.end()
def paintEvent(self, event):
"""
Paint the interpolated pixmap image.
"""
p = QPainter(self)
p.setClipRect(event.rect())
factor = self.blendingFactor_**2
if self.pixmap1 and 1. - factor:
p.setOpacity(1. - factor)
p.drawPixmap(QPoint(0, 0), self.pixmap1)
if self.pixmap2 and factor:
p.setOpacity(factor)
p.drawPixmap(QPoint(0, 0), self.pixmap2)
def paintEvent(self, event):
painter = QPainter(self)
painter.fillRect(event.rect(), Qt.white)
painter.setFont(self.displayFont)
redrawRect = event.rect()
beginRow = redrawRect.top() // self.squareSize
endRow = redrawRect.bottom() // self.squareSize
beginColumn = redrawRect.left() // self.squareSize
endColumn = redrawRect.right() // self.squareSize
painter.setPen(Qt.gray)
for row in range(beginRow, endRow + 1):
for column in range(beginColumn, endColumn + 1):
painter.drawRect(
column * self.squareSize,
row * self.squareSize,
self.squareSize,
self.squareSize,
)
fontMetrics = QFontMetrics(self.displayFont)
painter.setPen(Qt.black)
for row in range(beginRow, endRow + 1):
for column in range(beginColumn, endColumn + 1):
key = row * self.columns + column
painter.setClipRect(
column * self.squareSize,
row * self.squareSize,
self.squareSize,
self.squareSize,
)
if key == self.lastKey:
painter.fillRect(
column * self.squareSize + 1,
row * self.squareSize + 1,
self.squareSize,
self.squareSize,
Qt.red,
)
key_ch = self._chr(key)
painter.drawText(
column * self.squareSize + (self.squareSize / 2) -
fontMetrics.width(key_ch) / 2,
row * self.squareSize + 4 + fontMetrics.ascent(),
key_ch,
)
def paintEvent(self, event: QPaintEvent) -> None:
sz = self.size()
pen_width = int(self.pen_size / self.scaleFactor)
self.pen.setWidth(pen_width)
""" draw backgroud """
static_image = QPixmap(sz)
bpainter = QPainter()
bpainter.begin(static_image)
o = 10
bg = self.palette().brush(QPalette.Window)
bpainter.fillRect(0, 0, o, o, bg)
bpainter.fillRect(self.width() - o, 0, o, o, bg)
bpainter.fillRect(0, self.height() - o, o, o, bg)
bpainter.fillRect(self.width() - o, self.height() - o, o, o, bg)
bpainter.setClipRect(self.rect())
bpainter.setRenderHint(QPainter.Antialiasing)
bpainter.drawTiledPixmap(self.rect(), self.m_tile)
bpainter.end()
bpainter.begin(self)
bpainter.drawPixmap(self.rect(), static_image)
if self.state == self.State.disable:
painter = QPainter()
painter.begin(self)
painter.drawPixmap(0, 0, sz.width(), sz.height(), self.currn_pix)
painter.drawPixmap(0, 0, sz.width(), sz.height(), self.trans_pix)
painter.end()
else:
painter = QPainter()
painter.begin(self.trans_pix)
if self.drawmode == self.DrawMode.line:
painter.setCompositionMode(QPainter.CompositionMode_SourceOver)
elif self.drawmode == self.DrawMode.clear:
painter.setCompositionMode(QPainter.CompositionMode_Clear)
painter.setPen(self.pen)
self.drawingPath.drawPath(painter)
painter.end()
painter2 = QPainter()
painter2.begin(self)
painter2.drawPixmap(0, 0, sz.width(), sz.height(), self.currn_pix)
painter2.drawPixmap(0, 0, sz.width(), sz.height(), self.trans_pix)
if self.mousePressed:
painter2.setPen(QPen(Qt.SolidLine))
painter2.setBrush(
QBrush(QColor(255, 255, 255, 0), Qt.SolidPattern))
painter2.setRenderHint(QPainter.Antialiasing, True)
painter2.drawEllipse(self.cur_point, self.pen_size // 2,
self.pen_size // 2)
painter2.end()
def _paint(self, painter: QtGui.QPainter,
paint_rect: QtCore.QRect) -> None:
p = QtCore.QPoint(self.leftMargin(), 0)
for measure_editor in self.measure_editors():
measure_rect = QtCore.QRect(p.x(), 0, measure_editor.width(),
self.height())
measure_rect = measure_rect.intersected(paint_rect)
if not measure_rect.isEmpty():
painter.save()
try:
painter.setClipRect(measure_rect)
painter.translate(p)
measure_editor.paint(painter, measure_rect.translated(-p))
finally:
painter.restore()
p += QtCore.QPoint(measure_editor.width(), 0)
def paint(self, painter: QPainter, option, index):
# reference following link
# https://stackoverflow.com/questions/53353450/how-to-highlight-a-words-in-qtablewidget-from-a-searchlist
# https://stackoverflow.com/questions/34623036/implementing-a-delegate-for-wordwrap-in-a-qtreeview-qt-pyside-pyqt
painter.save()
doc = QTextDocument(self)
# option.palette.setColor(QPalette.HighlightedText, QColor.fromRgb(30, 136, 200))
# remove dotted border in table
if option.state & QStyle.State_HasFocus:
option.state = option.state ^ QStyle.State_HasFocus
options = QStyleOptionViewItem(option)
self.initStyleOption(options, index)
doc.setPlainText(options.text)
# keyword = index.data(Qt.UserRole)
# if self.keywords:
self.keywordHighlight(doc)
options.text = ""
# print(dir(options.palette))
# print(options.palette.Highlight)
style = QApplication.style() if options.widget is None \
else options.widget.style()
style.drawControl(QStyle.CE_ItemViewItem, options, painter,
options.widget) # for selection highlight
ctx = QAbstractTextDocumentLayout.PaintContext()
if index.data(Qt.UserRole) == 'reserved':
ctx.palette.setColor(QPalette.Text, QColor.fromRgb(100, 100, 100))
doc.setDefaultFont(
QFont(option.font.family(),
option.font.pointSize() * 2 // 3))
else:
ctx.palette.setColor(QPalette.Text, QColor.fromRgb(217, 217, 217))
doc.setDefaultFont(option.font)
textRect = option.rect
# margin = 4
# textRect.setTop(textRect.top() + margin)
textRect.setTop(textRect.top())
painter.translate(textRect.topLeft())
painter.setClipRect(textRect.translated(-textRect.topLeft()))
doc.setTextWidth(option.rect.width())
doc.documentLayout().draw(painter, ctx)
painter.restore()
def _paint(self, painter: QtGui.QPainter,
paint_rect: QtCore.QRect) -> None:
self.renderTimeGrid(painter, paint_rect)
for item in self.__samples:
sample_rect = item.rect().intersected(paint_rect)
if not sample_rect.isEmpty():
painter.save()
try:
painter.setClipRect(sample_rect)
painter.translate(item.pos())
item.paint(painter, sample_rect.translated(-item.pos()))
finally:
painter.restore()
if self.__playback_time is not None:
pos = self.timeToX(self.__playback_time)
painter.fillRect(pos, 0, 2, self.height(), QtGui.QColor(0, 0, 160))
def drawForeground(self, painter: QPainter, rect):
if self.guidesEnabled:
rect = self.chart().plotArea()
text = []
for serie in self.chart().series():
pointer_coords = self.chart().mapToValue(self.coords, serie)
x_y_points = list(
zip(*((e.x(), e.y()) for e in serie.pointsVector())))
point_ind = bisect.bisect_left(x_y_points[0],
pointer_coords.x())
point = serie.at(point_ind - 1 if point_ind else 0)
text.append("%f x %f" % (point.x(), point.y()))
painter.drawText(70, 27, ', '.join(text))
painter.setClipRect(rect)
# painter.setPen(self.guidePen)
painter.drawLine(self.coords.x(), rect.top(), self.coords.x(),
rect.bottom())
def paintEvent(self, event):
painter = QPainter()
painter.begin(self)
painter.fillRect(event.rect(), QBrush(Qt.white))
painter.setRenderHint(QPainter.Antialiasing)
painter.setPen(QPen(QBrush(Qt.red), 1, Qt.DashLine))
painter.drawRect(self.largest_rect)
painter.setPen(QPen(Qt.black))
painter.drawRect(self.clip_rect)
for i in range(4):
painter.drawRect(self.corner(i))
painter.setClipRect(self.clip_rect)
painter.drawPolyline(self.polygon)
painter.setBrush(QBrush(Qt.blue))
painter.drawPath(self.path)
painter.end()
def paintEvent(self, ev):
rect = ev.rect()
s = self._square
rows = range(rect.top() // s, rect.bottom() // s + 1)
cols = range(rect.left() // s, rect.right() // s + 1)
painter = QPainter(self)
painter.setPen(QPen(self.palette().color(QPalette.Window)))
painter.setFont(self._font)
metrics = QFontMetrics(self._font)
# draw characters on white tiles
tile = self.palette().color(QPalette.Base)
selected_tile = self.palette().color(QPalette.Highlight)
selected_tile.setAlpha(96)
selected_box = self.palette().color(QPalette.Highlight)
text_pen = QPen(self.palette().text().color())
disabled_pen = QPen(self.palette().color(QPalette.Disabled,
QPalette.Text))
selection_pen = QPen(selected_box)
for row in rows:
for col in cols:
char = row * self._column_count + col + self._range[0]
if char > self._range[1]:
break
printable = self.isprint(char)
painter.setClipRect(col * s, row * s, s, s)
if char == self._selected:
painter.fillRect(col * s + 1, row * s + 1, s - 2, s - 2,
selected_tile)
painter.setPen(selection_pen)
painter.drawRect(col * s, row * s, s - 1, s - 1)
elif printable:
painter.fillRect(col * s + 1, row * s + 1, s - 2, s - 2,
tile)
painter.setPen(text_pen if printable else disabled_pen)
t = chr(char)
x = col * s + s // 2 - metrics.width(t) // 2
y = row * s + 4 + metrics.ascent()
painter.drawText(x, y, t)
else:
continue
break
def paintEvent(self, ev):
rect = ev.rect()
s = self._square
rows = range(rect.top() // s, rect.bottom() // s + 1)
cols = range(rect.left() // s, rect.right() // s + 1)
painter = QPainter(self)
painter.setPen(QPen(self.palette().color(QPalette.Window)))
painter.setFont(self._font)
metrics = QFontMetrics(self._font)
# draw characters on white tiles
tile = self.palette().color(QPalette.Base)
selected_tile = self.palette().color(QPalette.Highlight)
selected_tile.setAlpha(96)
selected_box = self.palette().color(QPalette.Highlight)
text_pen = QPen(self.palette().text().color())
disabled_pen = QPen(self.palette().color(QPalette.Disabled, QPalette.Text))
selection_pen = QPen(selected_box)
for row in rows:
for col in cols:
char = row * self._column_count + col + self._range[0]
if char > self._range[1]:
break
printable = self.isprint(char)
painter.setClipRect(col * s, row * s, s, s)
if char == self._selected:
painter.fillRect(col * s + 1, row * s + 1, s - 2, s - 2, selected_tile)
painter.setPen(selection_pen)
painter.drawRect(col * s, row * s, s - 1, s - 1)
elif printable:
painter.fillRect(col * s + 1, row * s + 1, s - 2, s - 2, tile)
painter.setPen(text_pen if printable else disabled_pen)
t = chr(char)
x = col * s + s // 2 - metrics.width(t) // 2
y = row * s + 4 + metrics.ascent()
painter.drawText(x, y, t)
else:
continue
break
def paintEvent(self, event):
painter = QPainter(self)
painter.fillRect(event.rect(), Qt.white)
painter.setFont(self.displayFont)
redrawRect = event.rect()
beginRow = redrawRect.top() // self.cellSize
endRow = redrawRect.bottom() // self.cellSize
beginColumn = redrawRect.left() // self.cellSize
endColumn = redrawRect.right() // self.cellSize
# grid
painter.setPen(Qt.gray)
for row in range(beginRow, endRow + 1):
for column in range(beginColumn, endColumn + 1):
painter.drawRect(column * self.cellSize,
row * self.cellSize, self.cellSize,
self.cellSize)
fontMetrics = QFontMetrics(self.displayFont)
painter.setPen(Qt.black)
for row in range(beginRow, endRow + 1):
for column in range(beginColumn, endColumn + 1):
key = row * self.columns + column
painter.setClipRect(column * self.cellSize,
row * self.cellSize, self.cellSize,
self.cellSize)
if key == self.lastKey:
painter.fillRect(column * self.cellSize + 1,
row * self.cellSize + 1, self.cellSize,
self.cellSize, Qt.red)
key_ch = self._chr(key)
painter.drawText(column * self.cellSize + (self.cellSize / 2) - fontMetrics.width(key_ch) / 2,
row * self.cellSize + 4 + fontMetrics.ascent(),
key_ch)
def paint(self, painter: QPainter, option: QStyleOptionViewItem, index: QModelIndex) -> None:
super().paint(painter, option, index)
polygon_id = index.data(BaseColorMappingDialog.PolygonRole)
brushstyle = index.data(BaseColorMappingDialog.BrushStyleRole)
h = option.rect.height()
painter.save()
painter.setRenderHint(QPainter.Antialiasing)
painter.setClipRect(option.rect)
painter.setPen(QPen(Qt.lightGray, h/5.))
if brushstyle is not None:
painter.setBrush(QBrush(Qt.lightGray, brushstyle))
zoom = .9
painter.setTransform(QTransform()
.translate(option.rect.x()+h/2+10, option.rect.y()+h/2)
.rotate(-5.)
.scale(h/100.*zoom, h/100.*zoom))
if polygon_id is None or polygon_id == NodePolygon.Circle:
painter.drawEllipse(QRect(-50, -50, 100, 100))
else:
polygon = NODE_POLYGON_MAP.get(polygon_id, QPolygonF())
painter.drawPolygon(polygon)
painter.restore()
def paintEvent(self, event):
painter = QPainter(self)
metrics = self.fontMetrics()
# tabs
self._closeRects = {}
self._tabsRects = {}
painter.save()
currentTab = self.currentTab()
tabFillColor = QColor(240, 240, 240)
hoverFillColor = QColor(253, 253, 255)
textHeight = metrics.lineSpacing()
left = 0
h = textHeight + topPadding * 2
for index, name in enumerate(self.tabs()):
isHeroFirstTab = not index and self._heroFirstTab
isClosable = not isHeroFirstTab
textWidth = self._textWidth
if not index:
textWidth += self._firstOffset
w = sidePadding * 2 + textWidth
if isClosable:
w += crossMargin + crossSize
self._tabsRects[index] = (left, 0, w, h)
# background
textColor = QColor(72, 72, 72)
if index == currentTab:
fillColor = tabFillColor
elif index == self._hoverTab:
fillColor = hoverFillColor
else:
fillColor = None
if fillColor is not None:
painter.fillRect(0, 0, w, h, fillColor)
# text
painter.save()
painter.translate(sidePadding, metrics.ascent() + topPadding)
painter.setPen(textColor)
painter.setRenderHint(QPainter.Antialiasing)
painter.drawText(
0, 0, metrics.elidedText(name, Qt.ElideRight, textWidth))
# cross
if isClosable:
# 3px padding for click rect
self._closeRects[index] = (left + textWidth + 2 * sidePadding -
3, metrics.ascent() + topPadding -
crossSize - 3, crossSize + 6,
crossSize + 6)
if index == self._hoverClose:
color = QColor(254, 28, 28)
else:
color = QColor(78, 78, 78)
painter.setPen(color)
pen = painter.pen()
pen.setWidthF(1.5)
painter.setPen(pen)
painter.translate(textWidth + sidePadding, -crossSize)
painter.setClipRect(0, 0, crossSize, crossSize)
painter.scale(crossSize / 10, crossSize / 10)
painter.drawPath(cross)
painter.restore()
# shift for the next tab
shift = textWidth + 2 * sidePadding + spacing
if isClosable:
shift += crossMargin + crossSize
painter.translate(shift, 0)
left += shift
painter.restore()
def paintEvent(self, evt):
"""
Protected method handling paint events.
@param evt paint event (QPaintEvent)
"""
if self.__grabbing: # grabWindow() should just get the background
return
painter = QPainter(self)
pal = QPalette(QToolTip.palette())
font = QToolTip.font()
handleColor = pal.color(QPalette.Active, QPalette.Highlight)
handleColor.setAlpha(160)
overlayColor = QColor(0, 0, 0, 160)
textColor = pal.color(QPalette.Active, QPalette.Text)
textBackgroundColor = pal.color(QPalette.Active, QPalette.Base)
painter.drawPixmap(0, 0, self.__pixmap)
painter.setFont(font)
r = QRect(self.__selection)
if not self.__selection.isNull():
grey = QRegion(self.rect())
if self.__mode == SnapshotRegionGrabber.Ellipse:
reg = QRegion(r, QRegion.Ellipse)
else:
reg = QRegion(r)
grey = grey.subtracted(reg)
painter.setClipRegion(grey)
painter.setPen(Qt.NoPen)
painter.setBrush(overlayColor)
painter.drawRect(self.rect())
painter.setClipRect(self.rect())
drawRect(painter, r, handleColor)
if self.__showHelp:
painter.setPen(textColor)
painter.setBrush(textBackgroundColor)
self.__helpTextRect = painter.boundingRect(
self.rect().adjusted(2, 2, -2, -2), Qt.TextWordWrap,
self.__helpText).translated(-self.__desktop.x(),
-self.__desktop.y())
self.__helpTextRect.adjust(-2, -2, 4, 2)
drawRect(painter, self.__helpTextRect, textColor,
textBackgroundColor)
painter.drawText(self.__helpTextRect.adjusted(3, 3, -3, -3),
Qt.TextWordWrap, self.__helpText)
if self.__selection.isNull():
return
# The grabbed region is everything which is covered by the drawn
# rectangles (border included). This means that there is no 0px
# selection, since a 0px wide rectangle will always be drawn as a line.
txt = "{0}, {1} ({2} x {3})".format(
self.__locale.toString(self.__selection.x()),
self.__locale.toString(self.__selection.y()),
self.__locale.toString(self.__selection.width()),
self.__locale.toString(self.__selection.height()))
textRect = painter.boundingRect(self.rect(), Qt.AlignLeft, txt)
boundingRect = textRect.adjusted(-4, 0, 0, 0)
if textRect.width() < r.width() - 2 * self.__handleSize and \
textRect.height() < r.height() - 2 * self.__handleSize and \
r.width() > 100 and \
r.height() > 100:
# center, unsuitable for small selections
boundingRect.moveCenter(r.center())
textRect.moveCenter(r.center())
elif r.y() - 3 > textRect.height() and \
r.x() + textRect.width() < self.rect().width():
# on top, left aligned
boundingRect.moveBottomLeft(QPoint(r.x(), r.y() - 3))
textRect.moveBottomLeft(QPoint(r.x() + 2, r.y() - 3))
elif r.x() - 3 > textRect.width():
# left, top aligned
boundingRect.moveTopRight(QPoint(r.x() - 3, r.y()))
textRect.moveTopRight(QPoint(r.x() - 5, r.y()))
elif r.bottom() + 3 + textRect.height() < self.rect().bottom() and \
r.right() > textRect.width():
# at bottom, right aligned
boundingRect.moveTopRight(QPoint(r.right(), r.bottom() + 3))
textRect.moveTopRight(QPoint(r.right() - 2, r.bottom() + 3))
elif r.right() + textRect.width() + 3 < self.rect().width():
# right, bottom aligned
boundingRect.moveBottomLeft(QPoint(r.right() + 3, r.bottom()))
textRect.moveBottomLeft(QPoint(r.right() + 5, r.bottom()))
# If the above didn't catch it, you are running on a very
# tiny screen...
drawRect(painter, boundingRect, textColor, textBackgroundColor)
painter.drawText(textRect, Qt.AlignHCenter, txt)
if (r.height() > self.__handleSize * 2 and
r.width() > self.__handleSize * 2) or \
not self.__mouseDown:
self.__updateHandles()
painter.setPen(Qt.NoPen)
painter.setBrush(handleColor)
painter.setClipRegion(
self.__handleMask(SnapshotRegionGrabber.StrokeMask))
painter.drawRect(self.rect())
handleColor.setAlpha(60)
painter.setBrush(handleColor)
painter.setClipRegion(
self.__handleMask(SnapshotRegionGrabber.FillMask))
painter.drawRect(self.rect())
def paintEvent(self, event):
# init
menustyle = kikka.core.getGhost(self.gid).getMenuStyle()
self._bg_image = menustyle.bg_image
self._fg_image = menustyle.fg_image
self._side_image = menustyle.side_image
self.updateActionRect()
p = QPainter(self)
# draw background
p.fillRect(QRect(QPoint(), self.size()), self._side_image.pixelColor(0, 0))
vertical = False
y = self.height()
while y > 0:
yy = y - self._bg_image.height()
p.drawImage(0, yy, self._side_image.mirrored(False, vertical))
x = self._side_image.width()
while x < self.width():
p.drawImage(x, yy, self._bg_image.mirrored(False, vertical))
x += self._bg_image.width()
p.drawImage(x, yy, self._bg_image.mirrored(True, vertical))
x += self._bg_image.width() + 1
y -= self._bg_image.height()
vertical = not vertical
# draw item
actioncount = len(self.actions())
for i in range(actioncount):
act = self.actions()[i]
arect = QRect(self._aRect[i])
if event.rect().intersects(arect) is False:
continue
opt = QStyleOptionMenuItem()
self.initStyleOption(opt, act)
opt.rect = arect
if opt.state & QStyle.State_Selected \
and opt.state & QStyle.State_Enabled:
# Selected Item, draw foreground image
p.setClipping(True)
p.setClipRect(arect.x() + self._side_image.width(), arect.y(), self.width() - self._side_image.width(),
arect.height())
p.fillRect(QRect(QPoint(), self.size()), self._fg_image.pixelColor(0, 0))
vertical = False
y = self.height()
while y > 0:
x = self._side_image.width()
while x < self.width():
yy = y - self._fg_image.height()
p.drawImage(x, yy, self._fg_image.mirrored(False, vertical))
x += self._fg_image.width()
p.drawImage(x, yy, self._fg_image.mirrored(True, vertical))
x += self._fg_image.width() + 1
y -= self._fg_image.height()
vertical = not vertical
p.setClipping(False)
if opt.menuItemType == QStyleOptionMenuItem.Separator:
# Separator
p.setPen(menustyle.getPenColor(opt))
y = int(arect.y() + arect.height() / 2)
p.drawLine(self._side_image.width(), y, arect.width(), y)
else:
# MenuItem
self.drawControl(p, opt, arect, act.icon(), menustyle)
pass # exit for
def drawWaveforms(self):
painter = QPainter(self.pixmap)
length = Rhd2000DataBlock.getSamplesPerDataBlock(
) * self.numUsbBlocksToPlot
polyline = [0] * (length + 1)
# Assume all frames are the same size.
yAxisLength = (self.frameList[self.numFramesIndex[self.selectedPort]]
[0].height() - 2) / 2.0
tAxisLength = self.frameList[self.numFramesIndex[
self.selectedPort]][0].width() - 1
for j in range(
len(self.frameList[self.numFramesIndex[self.selectedPort]])):
stream = self.selectedChannelIndex(
j + self.topLeftFrame[self.selectedPort]).boardStream
channel = self.selectedChannelIndex(
j + self.topLeftFrame[self.selectedPort]).chipChannel
stype = self.selectedChannelIndex(
j + self.topLeftFrame[self.selectedPort]).signalType
if self.selectedChannelIndex(
j + self.topLeftFrame[self.selectedPort]).enabled:
xOffset = self.frameList[self.numFramesIndex[
self.selectedPort]][j].left() + 1
xOffset += self.tPosition * tAxisLength / self.tScale
# Set clipping region
adjustedFrame = copy(
self.frameList[self.numFramesIndex[self.selectedPort]][j])
adjustedFrame.adjust(0, 1, 0, 0)
painter.setClipRect(adjustedFrame)
# Erase segment of old wavefrom
eraseBlock = copy(adjustedFrame)
eraseBlock.setLeft(xOffset)
eraseBlock.setRight(
(tAxisLength * (1000.0 / self.sampleRate) / self.tScale) *
(length - 1) + xOffset)
painter.eraseRect(eraseBlock)
# Redraw y = 0 axis
self.drawAxisLines(painter, j)
if stype == constants.AmplifierSignal:
# Plot RHD2000 amplifier waveform
tStepMsec = 1000.0 / self.sampleRate
xScaleFactor = tAxisLength * tStepMsec / self.tScale
yScaleFactor = -yAxisLength / self.yScale
yOffset = self.frameList[self.numFramesIndex[
self.selectedPort]][j].center().y()
# build waveform
for i in range(length):
polyline[i + 1] = QPointF(
xScaleFactor * i + xOffset,
yScaleFactor * self.signalProcessor.
amplifierPostFilter[stream][channel][i] + yOffset)
# join to old waveform
if self.tPosition == 0.0:
polyline[0] = polyline[1]
else:
polyline[0] = QPointF(
xScaleFactor * -1 + xOffset,
yScaleFactor * self.plotDataOld[
j + self.topLeftFrame[self.selectedPort]] +
yOffset)
# save last point in waveform to join to next segment
self.plotDataOld[j + self.topLeftFrame[
self.
selectedPort]] = self.signalProcessor.amplifierPostFilter[
stream][channel][length - 1]
# draw waveform
painter.setPen(Qt.blue)
if self.pointPlotMode:
painter.drawPoints(QPolygonF(polyline))
else:
painter.drawPolyline(QPolygonF(polyline))
elif stype == constants.AuxInputSignal:
# Plot RHD2000 auxiliary input signal
tStepMsec = 1000.0 / (self.sampleRate / 4)
xScaleFactor = tAxisLength * tStepMsec / self.tScale
yScaleFactor = -(2.0 * yAxisLength) / 2.5
yOffset = self.frameList[self.numFramesIndex[
self.selectedPort]][j].bottom()
# build waveform
for i in range(length / 4):
polyline[i + 1] = QPointF(
xScaleFactor * i + xOffset, yScaleFactor *
self.signalProcessor.auxChannel[stream][channel][i]
+ yOffset)
# join to old waveform
if self.tPosition == 0.0:
polyline[0] = polyline[1]
else:
polyline[0] = QPointF(
xScaleFactor * -1 + xOffset,
yScaleFactor * self.plotDataOld[
j + self.topLeftFrame[self.selectedPort]] +
yOffset)
# save last point in waveform to join to next segment
self.plotDataOld[j + self.topLeftFrame[
self.selectedPort]] = self.signalProcessor.auxChannel[
stream][channel][(length / 4) - 1]
# draw waveform
pen = QPen()
pen.setColor(QColor(200, 50, 50))
painter.setPen(pen)
polyline = polyline[:(length // 4) + 1]
if self.pointPlotMode:
painter.drawPoints(QPolygonF(polyline))
else:
painter.drawPolyline(QPolygonF(polyline))
elif stype == constants.SupplyVoltageSignal:
# Plot RHD2000 supply voltage signal
tStepMsec = 1000.0 / (self.sampleRate / 60.0)
xScaleFactor = tAxisLength * tStepMsec / self.tScale
yScaleFactor = -(2.0 * yAxisLength) / 1.5
yOffset = self.frameList[self.numFramesIndex[
self.selectedPort]][j].bottom()
voltageLow = False
voltageOutOfRange = False
# build waveform
for i in range(length / 60):
voltage = self.signalProcessor.supplyVoltage[stream][i]
polyline[i + 1] = QPointF(
xScaleFactor * i + xOffset,
yScaleFactor * (voltage - 2.5) + yOffset)
if voltage < 2.9 or voltage > 3.6:
voltageOutOfRange = True
elif voltage < 3.2:
voltageLow = True
# join to old waveform
if self.tPosition == 0.0:
polyline[0] = polyline[1]
else:
polyline[0] = QPointF(
xScaleFactor * -1 + xOffset,
yScaleFactor *
(self.plotDataOld[j + self.topLeftFrame[
self.selectedPort]] - 2.5) + yOffset)
# save last point in waveform to join to next segment
self.plotDataOld[j + self.topLeftFrame[
self.
selectedPort]] = self.signalProcessor.supplyVoltage[
stream][(length / 60) - 1]
# draw waveform
painter.setPen(Qt.green)
if voltageLow:
painter.setPen(Qt.yellow)
if voltageOutOfRange:
painter.setPen(Qt.red)
polyline = polyline[:(length // 60) + 1]
if self.pointPlotMode:
painter.drawPoints(QPolygonF(polyline))
else:
painter.drawPolyline(QPolygonF(polyline))
elif stype == constants.BoardAdcSignal:
# Plot USB interface board ADC input signal
tStepMsec = 1000.0 / self.sampleRate
xScaleFactor = tAxisLength * tStepMsec / self.tScale
yScaleFactor = -(2.0 * yAxisLength) / 3.3
yOffset = self.frameList[self.numFramesIndex[
self.selectedPort]][j].bottom()
# build waveform
for i in range(length):
polyline[i + 1] = QPointF(
xScaleFactor * i + xOffset, yScaleFactor *
self.signalProcessor.boardAdc[channel][i] +
yOffset)
# join to old waveform
if self.tPosition == 0.0:
polyline[0] = polyline[1]
else:
polyline[0] = QPointF(
xScaleFactor * -1 + xOffset,
yScaleFactor * self.plotDataOld[
j + self.topLeftFrame[self.selectedPort]] +
yOffset)
# save last point in waveform to join to next segment
self.plotDataOld[j + self.topLeftFrame[
self.selectedPort]] = self.signalProcessor.boardAdc[
channel][length - 1]
# draw waveform
painter.setPen(Qt.darkGreen)
if self.pointPlotMode:
painter.drawPoints(QPolygonF(polyline))
else:
painter.drawPolyline(QPolygonF(polyline))
elif stype == constants.BoardDigInSignal:
# Plot USB interface board digital input signal
tStepMsec = 1000.0 / self.sampleRate
xScaleFactor = tAxisLength * tStepMsec / self.tScale
yScaleFactor = -(2.0 * yAxisLength) / 2.0
yOffset = (self.frameList[self.numFramesIndex[
self.selectedPort]][j].bottom() +
self.frameList[self.numFramesIndex[
self.selectedPort]][j].center().y()) / 2.0
# build waveform
for i in range(length):
polyline[i + 1] = QPointF(
xScaleFactor * i + xOffset, yScaleFactor *
self.signalProcessor.boardDigIn[channel][i] +
yOffset)
# join to old waveform
if self.tPosition == 0.0:
polyline[0] = polyline[1]
else:
polyline[0] = QPointF(
xScaleFactor * -1 + xOffset,
yScaleFactor * self.plotDataOld[
j + self.topLeftFrame[self.selectedPort]] +
yOffset)
# save last point in waveform to join to next segment
self.plotDataOld[j + self.topLeftFrame[
self.selectedPort]] = self.signalProcessor.boardDigIn[
channel][length - 1]
# draw waveform
pen = QPen()
pen.setColor(QColor(200, 50, 200))
painter.setPen(pen)
if self.pointPlotMode:
painter.drawPoints(QPolygonF(polyline))
else:
painter.drawPolyline(QPolygonF(polyline))
painter.setClipping(False)
tStepMsec = 1000.0 / self.sampleRate
self.tPosition += length * tStepMsec
if self.tPosition >= self.tScale:
self.tPosition = 0.0
def paintEvent(self, evt):
"""
Protected method handling paint events.
@param evt paint event (QPaintEvent)
"""
if self.__grabbing: # grabWindow() should just get the background
return
painter = QPainter(self)
pal = QPalette(QToolTip.palette())
font = QToolTip.font()
handleColor = pal.color(QPalette.Active, QPalette.Highlight)
handleColor.setAlpha(160)
overlayColor = QColor(0, 0, 0, 160)
textColor = pal.color(QPalette.Active, QPalette.Text)
textBackgroundColor = pal.color(QPalette.Active, QPalette.Base)
painter.drawPixmap(0, 0, self.__pixmap)
painter.setFont(font)
r = QRect(self.__selection)
if not self.__selection.isNull():
grey = QRegion(self.rect())
if self.__mode == SnapshotRegionGrabber.Ellipse:
reg = QRegion(r, QRegion.Ellipse)
else:
reg = QRegion(r)
grey = grey.subtracted(reg)
painter.setClipRegion(grey)
painter.setPen(Qt.NoPen)
painter.setBrush(overlayColor)
painter.drawRect(self.rect())
painter.setClipRect(self.rect())
drawRect(painter, r, handleColor)
if self.__showHelp:
painter.setPen(textColor)
painter.setBrush(textBackgroundColor)
self.__helpTextRect = painter.boundingRect(
self.rect().adjusted(2, 2, -2, -2),
Qt.TextWordWrap, self.__helpText).translated(
-self.__desktop.x(), -self.__desktop.y())
self.__helpTextRect.adjust(-2, -2, 4, 2)
drawRect(painter, self.__helpTextRect, textColor,
textBackgroundColor)
painter.drawText(
self.__helpTextRect.adjusted(3, 3, -3, -3),
Qt.TextWordWrap, self.__helpText)
if self.__selection.isNull():
return
# The grabbed region is everything which is covered by the drawn
# rectangles (border included). This means that there is no 0px
# selection, since a 0px wide rectangle will always be drawn as a line.
txt = "{0:n}, {1:n} ({2:n} x {3:n})".format(
self.__selection.x(), self.__selection.y(),
self.__selection.width(), self.__selection.height())
textRect = painter.boundingRect(self.rect(), Qt.AlignLeft, txt)
boundingRect = textRect.adjusted(-4, 0, 0, 0)
if textRect.width() < r.width() - 2 * self.__handleSize and \
textRect.height() < r.height() - 2 * self.__handleSize and \
r.width() > 100 and \
r.height() > 100:
# center, unsuitable for small selections
boundingRect.moveCenter(r.center())
textRect.moveCenter(r.center())
elif r.y() - 3 > textRect.height() and \
r.x() + textRect.width() < self.rect().width():
# on top, left aligned
boundingRect.moveBottomLeft(QPoint(r.x(), r.y() - 3))
textRect.moveBottomLeft(QPoint(r.x() + 2, r.y() - 3))
elif r.x() - 3 > textRect.width():
# left, top aligned
boundingRect.moveTopRight(QPoint(r.x() - 3, r.y()))
textRect.moveTopRight(QPoint(r.x() - 5, r.y()))
elif r.bottom() + 3 + textRect.height() < self.rect().bottom() and \
r.right() > textRect.width():
# at bottom, right aligned
boundingRect.moveTopRight(QPoint(r.right(), r.bottom() + 3))
textRect.moveTopRight(QPoint(r.right() - 2, r.bottom() + 3))
elif r.right() + textRect.width() + 3 < self.rect().width():
# right, bottom aligned
boundingRect.moveBottomLeft(QPoint(r.right() + 3, r.bottom()))
textRect.moveBottomLeft(QPoint(r.right() + 5, r.bottom()))
# If the above didn't catch it, you are running on a very
# tiny screen...
drawRect(painter, boundingRect, textColor, textBackgroundColor)
painter.drawText(textRect, Qt.AlignHCenter, txt)
if (r.height() > self.__handleSize * 2 and
r.width() > self.__handleSize * 2) or \
not self.__mouseDown:
self.__updateHandles()
painter.setPen(Qt.NoPen)
painter.setBrush(handleColor)
painter.setClipRegion(
self.__handleMask(SnapshotRegionGrabber.StrokeMask))
painter.drawRect(self.rect())
handleColor.setAlpha(60)
painter.setBrush(handleColor)
painter.setClipRegion(
self.__handleMask(SnapshotRegionGrabber.FillMask))
painter.drawRect(self.rect())
def paintMarkedRegions(self, evt):
"""Draw the marked region indicators."""
def f2px(frameNumber):
"""Convert frame number to pixel coordinates."""
return round(frameNumber / self.totalRecordedFrames * (self.uiMarkedRegionVisualization.width()-1))
if not self.totalRecordedFrames:
return
p = QPainter(self.uiMarkedRegionVisualization)
#This causes borders to get merged and generally mis-drawn.
#Could otherwise be used to simplify math when calculating rect position.
#p.setCompositionMode(QPainter.CompositionMode_DestinationOver)
#This causes graphics glitches in 5.7 upon redraw.
#Could otherwise be used to simplify math when calculating rect position.
#p.scale(1,-1)
#p.translate(0, -evt.rect().height()+1)
#Draw the tracks of marked regions.
trackOffset = -1
for track in reversed(self._tracks):
for region in track:
regionRect = QRect(
f2px(region['mark start']),
trackOffset + self.saveRegionBorder,
f2px(region['mark end'] - region['mark start']),
self.saveRegionMarkerHeight,
)
if region['saved'] < 1: #Draw coloured, unsaved marked region.
p.setPen(hsva(
region['hue'],
{-1:150, 0:230, 1:255}[region['highlight']],
{-1:160, 0:190, 1:100}[region['highlight']],
))
p.setBrush(QBrush(hsva(
region['hue'],
{-1:0, 0:153, 1:255}[region['highlight']],
{-1:0, 0:230, 1:255}[region['highlight']],
)))
p.setClipRect(regionRect.adjusted(regionRect.width() * region['saved'],0, 0,0))
p.drawRect(regionRect)
if region['saved'] > 0: #Draw green, saved marked region.
p.setPen(hsva(
120, #green
{-1:150, 0:230, 1:255}[region['highlight']],
{-1:160, 0:190, 1:100}[region['highlight']],
))
p.setBrush(QBrush(hsva(
120,
{-1:0, 0:153, 1:255}[region['highlight']],
{-1:0, 0:230, 1:255}[region['highlight']],
)))
p.setClipRect(regionRect.adjusted(0,0, -regionRect.width() * (1-region['saved']),0))
p.drawRect(regionRect)
trackOffset += self.saveRegionMarkerOffset
def paintEvent(self, event):
unused(event)
compassAIIntrusion = 0
compassHalfSpan = 180
painter = QPainter()
painter.begin(self)
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setRenderHint(QPainter.HighQualityAntialiasing, True)
tapeGaugeWidth = self.tapesGaugeWidthFor(self.width(), self.width())
aiheight = self.height()
aiwidth = self.width() - tapeGaugeWidth * 2
if (aiheight > aiwidth):
aiheight = aiwidth
AIMainArea = QRectF(tapeGaugeWidth, 0, aiwidth, aiheight)
AIPaintArea = QRectF(0, 0, self.width(), self.height())
velocityMeterArea = QRectF(0, 0, tapeGaugeWidth, aiheight)
altimeterArea = QRectF(AIMainArea.right(), 0, tapeGaugeWidth, aiheight)
# calc starts
compassRelativeWidth = 0.75
compassBottomMargin = 0.78
compassSize = compassRelativeWidth * AIMainArea.width(
) # Diameter is this times the width.
compassCenterY = AIMainArea.bottom() + compassSize / 4
if self.height(
) - compassCenterY > AIMainArea.width() / 2 * compassBottomMargin:
compassCenterY = self.height(
) - AIMainArea.width() / 2 * compassBottomMargin
compassCenterY = (compassCenterY * 2 + AIMainArea.bottom() +
compassSize / 4) / 3
compassArea = QRectF(
AIMainArea.x() +
(1 - compassRelativeWidth) / 2 * AIMainArea.width(),
compassCenterY - compassSize / 2, compassSize, compassSize)
if self.height() - compassCenterY < compassSize / 2:
compassHalfSpan = math.acos(
(compassCenterY - self.height()) * 2 /
compassSize) * 180 / math.pi + self.COMPASS_DISK_RESOLUTION
if compassHalfSpan > 180:
compassHalfSpan = 180
compassAIIntrusion = compassSize / 2 + AIMainArea.bottom(
) - compassCenterY
if compassAIIntrusion < 0:
compassAIIntrusion = 0
#calc ends
hadClip = painter.hasClipping()
painter.setClipping(True)
painter.setClipRect(AIPaintArea)
self.drawAIGlobalFeatures(painter, AIMainArea, AIPaintArea)
self.drawAIAttitudeScales(painter, AIMainArea, compassAIIntrusion)
self.drawAIAirframeFixedFeatures(painter, AIMainArea)
self.drawAICompassDisk(painter, compassArea, compassHalfSpan)
painter.setClipping(hadClip)
if self.isGPSAltitudePrimary:
self.drawAltimeter(painter, altimeterArea, self.GPSAltitude,
self.primaryAltitude, self.verticalVelocity)
else:
self.drawAltimeter(painter, altimeterArea, self.primaryAltitude,
self.GPSAltitude, self.verticalVelocity)
if self.isGPSSpeedPrimary:
self.drawVelocityMeter(painter, velocityMeterArea,
self.groundspeed, self.primarySpeed)
else:
self.drawVelocityMeter(painter, velocityMeterArea,
self.primarySpeed, self.groundspeed)
painter.end()
def updateSpikePlot(self, rms):
tScale = 3.0 # time scale = 3.0 ms
colorIndex = 2
if self.maxNumSpikeWaveforms == 10:
colorIndex = 0
elif self.maxNumSpikeWaveforms == 20:
colorIndex = 1
elif self.maxNumSpikeWaveforms == 30:
colorIndex = 2
self.drawAxisLines()
if self.pixmap is None:
painter = QPainter()
else:
painter = QPainter(self.pixmap)
# Vector for waveform plot points
polyline = [0] * self.totalTSteps
yAxisLength = (self.frame.height() - 2) / 2.0
tAxisLength = self.frame.width() - 1
xOffset = self.frame.left() + 1
# Set clipping region for plotting.
adjustedFrame = copy(self.frame)
adjustedFrame.adjust(0, 1, 0, 0)
painter.setClipRect(adjustedFrame)
xScaleFactor = tAxisLength * self.tStepMsec / tScale
yScaleFactor = -yAxisLength / self.yScale
yOffset = self.frame.center().y()
index = self.maxNumSpikeWaveforms - self.numSpikeWaveforms
for j in range(self.spikeWaveformIndex - self.numSpikeWaveforms,
self.spikeWaveformIndex):
# Build waveform
for i in range(self.totalTSteps):
polyline[i] = QPointF(
xScaleFactor * i + xOffset, yScaleFactor *
self.spikeWaveform[(j + 30) % len(self.spikeWaveform)][i] +
yOffset)
# Draw waveform
painter.setPen(self.scopeColors[colorIndex][index])
index += 1
painter.drawPolyline(QPolygonF(polyline))
# If using a voltage threshold trigger, plot a line at the threshold level.
if self.voltageTriggerMode:
painter.setPen(Qt.red)
painter.drawLine(xOffset,
yScaleFactor * self.voltageThreshold + yOffset,
xScaleFactor * (self.totalTSteps - 1) + xOffset,
yScaleFactor * self.voltageThreshold + yOffset)
painter.setClipping(False)
# Don't update the RMS value display every time, or it will change so fast that it
# will be hard to read. Only update once every few times we execute this function.
if self.rmsDisplayPeriod == 0:
self.rmsDisplayPeriod = 5
self.savedRms = rms
else:
self.rmsDisplayPeriod -= 1
# Write RMS value to display.
textBoxWidth = 180
textBoxHeight = painter.fontMetrics().height()
painter.setPen(Qt.darkGreen)
if self.savedRms < 10.0:
precision = "1"
else:
precision = "0"
painter.drawText(
self.frame.left() + 6,
self.frame.top() + 5, textBoxWidth, textBoxHeight,
Qt.AlignLeft | Qt.AlignTop,
"RMS:" + ("%." + precision + "f") % self.savedRms + " " +
constants.QSTRING_MU_SYMBOL + "V")
self.update()
def paintEvent(self, event):
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
redrawRect = event.rect()
beginRow = redrawRect.top() // self.squareSize
endRow = redrawRect.bottom() // self.squareSize
# XXX: do we need to maintain self._column when we have (endColumn -
# beginColumn)?
beginColumn = redrawRect.left() // self.squareSize
endColumn = redrawRect.right() // self.squareSize
gradient = QLinearGradient(0, 0, 0, GlyphCellHeaderHeight)
gradient.setColorAt(0.0, cellHeaderBaseColor)
gradient.setColorAt(1.0, cellHeaderLineColor)
dirtyGradient = QLinearGradient(0, 0, 0, GlyphCellHeaderHeight)
dirtyGradient.setColorAt(0.0, cellHeaderBaseColor.darker(125))
dirtyGradient.setColorAt(1.0, cellHeaderLineColor.darker(125))
markGradient = QLinearGradient(0, 0, 0, self.squareSize-GlyphCellHeaderHeight)
for row in range(beginRow, endRow + 1):
for column in range(beginColumn, endColumn + 1):
key = row * self._columns + column
if key >= len(self._glyphs): break
glyph = self._glyphs[key]
painter.save()
painter.translate(column * self.squareSize, row * self.squareSize)
painter.fillRect(0, 0, self.squareSize, self.squareSize, Qt.white)
# prepare header colors
brushColor = gradient
linesColor = cellHeaderHighlightLineColor
# mark color
if not glyph.template:
if glyph.markColor is not None:
markColor = QColor.fromRgbF(*tuple(glyph.markColor))
markGradient.setColorAt(1.0, markColor)
markGradient.setColorAt(0.0, markColor.lighter(125))
painter.fillRect(0, GlyphCellHeaderHeight, self.squareSize,
self.squareSize - GlyphCellHeaderHeight, QBrush(markGradient))
if glyph.dirty:
brushColor = dirtyGradient
linesColor = cellHeaderHighlightLineColor.darker(110)
# header gradient
painter.fillRect(0, 0, self.squareSize, GlyphCellHeaderHeight,
QBrush(brushColor))
# header lines
painter.setPen(linesColor)
minOffset = painter.pen().width()
# disable antialiasing to avoid lines bleeding over background
painter.setRenderHint(QPainter.Antialiasing, False)
painter.drawLine(0, 0, 0, GlyphCellHeaderHeight - 1)
painter.drawLine(self.squareSize - 2, 0, self.squareSize - 2, GlyphCellHeaderHeight -1)
painter.setPen(QColor(170, 170, 170))
painter.drawLine(0, GlyphCellHeaderHeight, self.squareSize, GlyphCellHeaderHeight)
painter.setRenderHint(QPainter.Antialiasing)
# header text
painter.setFont(headerFont)
painter.setPen(QColor(80, 80, 80))
name = metrics.elidedText(glyph.name, Qt.ElideRight, self.squareSize - 2)
painter.drawText(1, 0, self.squareSize - 2, GlyphCellHeaderHeight - minOffset,
Qt.TextSingleLine | Qt.AlignCenter, name)
painter.restore()
painter.setPen(cellGridColor)
rightEdgeX = column * self.squareSize + self.squareSize
bottomEdgeY = row * self.squareSize + self.squareSize
painter.drawLine(rightEdgeX, row * self.squareSize + 1, rightEdgeX, bottomEdgeY)
painter.drawLine(rightEdgeX, bottomEdgeY, column * self.squareSize + 1, bottomEdgeY)
if self._currentDropIndex is not None:
painter.setPen(Qt.green)
if self._currentDropIndex == key:
painter.drawLine(column * self.squareSize, row * self.squareSize,
column * self.squareSize, bottomEdgeY)
# special-case the end-column
elif column == endColumn and self._currentDropIndex == key+1:
yPos = self.mapFromGlobal(QCursor.pos()).y()
if row == yPos // self.squareSize:
painter.drawLine(rightEdgeX - 1, row * self.squareSize,
rightEdgeX - 1, bottomEdgeY)
# selection code
if key in self._selection:
painter.setRenderHint(QPainter.Antialiasing, False)
painter.fillRect(column * self.squareSize + 1,
row * self.squareSize + 1, self.squareSize - 3,
self.squareSize - 3, cellSelectionColor)
painter.setRenderHint(QPainter.Antialiasing)
if not glyph.template:
font = glyph.getParent()
outline = glyph.getRepresentation("defconQt.QPainterPath")
uPM = font.info.unitsPerEm
if uPM is None or not uPM > 0:
uPM = 1000
descender = font.info.descender
if descender is None or not descender < 0:
descender = -250
factor = (self.squareSize-GlyphCellHeaderHeight) / (uPM*(1+2*GlyphCellBufferHeight))
x_offset = (self.squareSize-glyph.width*factor)/2
# If the glyph overflows horizontally we need to adjust the scaling factor
if x_offset < 0:
factor *= 1+2*x_offset/(glyph.width*factor)
x_offset = 0
# TODO: the * 1.8 below is somewhat artificial
y_offset = descender*factor * 1.8
painter.save()
painter.setClipRect(column * self.squareSize, row * self.squareSize+GlyphCellHeaderHeight,
self.squareSize, self.squareSize-GlyphCellHeaderHeight)
painter.translate(column * self.squareSize + x_offset, row * self.squareSize + self.squareSize + y_offset)
painter.scale(factor, -factor)
painter.fillPath(outline, Qt.black)
painter.restore()
else:
painter.save()
painter.setFont(voidFont)
painter.setPen(QPen(Qt.lightGray))
rect = QRectF(column * self.squareSize, row * self.squareSize+GlyphCellHeaderHeight,
self.squareSize, self.squareSize-GlyphCellHeaderHeight)
# TODO: need to flag template glyphs as to whether they have unicodings or not
if glyph.unicode is not None:
text = chr(glyph.unicode)
else:
text = "✌"
painter.drawText(rect, Qt.AlignCenter, text)
painter.restore()
def paintEvent(self, evt):
"""
Protected method handling paint events.
@param evt paint event (QPaintEvent)
"""
if self.__grabbing: # grabWindow() should just get the background
return
painter = QPainter(self)
pal = QPalette(QToolTip.palette())
font = QToolTip.font()
handleColor = pal.color(QPalette.Active, QPalette.Highlight)
handleColor.setAlpha(160)
overlayColor = QColor(0, 0, 0, 160)
textColor = pal.color(QPalette.Active, QPalette.Text)
textBackgroundColor = pal.color(QPalette.Active, QPalette.Base)
painter.drawPixmap(0, 0, self.__pixmap)
painter.setFont(font)
pol = QPolygon(self.__selection)
if not self.__selection.boundingRect().isNull():
# Draw outline around selection.
# Important: the 1px-wide outline is *also* part of the
# captured free-region
pen = QPen(handleColor, 1, Qt.SolidLine, Qt.SquareCap,
Qt.BevelJoin)
painter.setPen(pen)
painter.drawPolygon(pol)
# Draw the grey area around the selection.
grey = QRegion(self.rect())
grey = grey - QRegion(pol)
painter.setClipRegion(grey)
painter.setPen(Qt.NoPen)
painter.setBrush(overlayColor)
painter.drawRect(self.rect())
painter.setClipRect(self.rect())
drawPolygon(painter, pol, handleColor)
if self.__showHelp:
painter.setPen(textColor)
painter.setBrush(textBackgroundColor)
self.__helpTextRect = painter.boundingRect(
self.rect().adjusted(2, 2, -2, -2),
Qt.TextWordWrap, self.__helpText).translated(
-self.__desktop.x(), -self.__desktop.y())
self.__helpTextRect.adjust(-2, -2, 4, 2)
drawPolygon(painter, self.__helpTextRect, textColor,
textBackgroundColor)
painter.drawText(
self.__helpTextRect.adjusted(3, 3, -3, -3),
Qt.TextWordWrap, self.__helpText)
if self.__selection.isEmpty():
return
# The grabbed region is everything which is covered by the drawn
# rectangles (border included). This means that there is no 0px
# selection, since a 0px wide rectangle will always be drawn as a line.
boundingRect = self.__selection.boundingRect()
txt = "{0}, {1} ({2} x {3})".format(
self.__locale.toString(boundingRect.x()),
self.__locale.toString(boundingRect.y()),
self.__locale.toString(boundingRect.width()),
self.__locale.toString(boundingRect.height())
)
textRect = painter.boundingRect(self.rect(), Qt.AlignLeft, txt)
boundingRect = textRect.adjusted(-4, 0, 0, 0)
polBoundingRect = pol.boundingRect()
if (textRect.width() <
polBoundingRect.width() - 2 * self.__handleSize) and \
(textRect.height() <
polBoundingRect.height() - 2 * self.__handleSize) and \
polBoundingRect.width() > 100 and \
polBoundingRect.height() > 100:
# center, unsuitable for small selections
boundingRect.moveCenter(polBoundingRect.center())
textRect.moveCenter(polBoundingRect.center())
elif polBoundingRect.y() - 3 > textRect.height() and \
polBoundingRect.x() + textRect.width() < self.rect().width():
# on top, left aligned
boundingRect.moveBottomLeft(
QPoint(polBoundingRect.x(), polBoundingRect.y() - 3))
textRect.moveBottomLeft(
QPoint(polBoundingRect.x() + 2, polBoundingRect.y() - 3))
elif polBoundingRect.x() - 3 > textRect.width():
# left, top aligned
boundingRect.moveTopRight(
QPoint(polBoundingRect.x() - 3, polBoundingRect.y()))
textRect.moveTopRight(
QPoint(polBoundingRect.x() - 5, polBoundingRect.y()))
elif (polBoundingRect.bottom() + 3 + textRect.height() <
self.rect().bottom()) and \
polBoundingRect.right() > textRect.width():
# at bottom, right aligned
boundingRect.moveTopRight(
QPoint(polBoundingRect.right(), polBoundingRect.bottom() + 3))
textRect.moveTopRight(
QPoint(polBoundingRect.right() - 2,
polBoundingRect.bottom() + 3))
elif polBoundingRect.right() + textRect.width() + 3 < \
self.rect().width():
# right, bottom aligned
boundingRect.moveBottomLeft(
QPoint(polBoundingRect.right() + 3, polBoundingRect.bottom()))
textRect.moveBottomLeft(
QPoint(polBoundingRect.right() + 5, polBoundingRect.bottom()))
# If the above didn't catch it, you are running on a very
# tiny screen...
drawPolygon(painter, boundingRect, textColor, textBackgroundColor)
painter.drawText(textRect, Qt.AlignHCenter, txt)
if (polBoundingRect.height() > self.__handleSize * 2 and
polBoundingRect.width() > self.__handleSize * 2) or \
not self.__mouseDown:
painter.setBrush(Qt.transparent)
painter.setClipRegion(QRegion(pol))
painter.drawPolygon(QPolygon(self.rect()))