def paintEvent(self, event):
rect = QRect(10, 20, 80, 60)
path = QPainterPath()
path.moveTo(20, 80)
path.lineTo(20, 30)
path.cubicTo(80, 0, 50, 50, 80, 80)
startAngle = 30 * 16
arcLength = 120 * 16
painter = QPainter(self)
painter.setPen(self.pen)
painter.setBrush(self.brush)
if self.antialiased:
painter.setRenderHint(QPainter.Antialiasing)
for x in range(0, self.width(), 100):
for y in range(0, self.height(), 100):
painter.save()
painter.translate(x, y)
if self.transformed:
painter.translate(50, 50)
painter.rotate(60.0)
painter.scale(0.6, 0.9)
painter.translate(-50, -50)
if self.shape == RenderArea.Line:
painter.drawLine(rect.bottomLeft(), rect.topRight())
elif self.shape == RenderArea.Points:
painter.drawPoints(RenderArea.points)
elif self.shape == RenderArea.Polyline:
painter.drawPolyline(RenderArea.points)
elif self.shape == RenderArea.Polygon:
painter.drawPolygon(RenderArea.points)
elif self.shape == RenderArea.Rect:
painter.drawRect(rect)
elif self.shape == RenderArea.RoundedRect:
painter.drawRoundedRect(rect, 25, 25, Qt.RelativeSize)
elif self.shape == RenderArea.Ellipse:
painter.drawEllipse(rect)
elif self.shape == RenderArea.Arc:
painter.drawArc(rect, startAngle, arcLength)
elif self.shape == RenderArea.Chord:
painter.drawChord(rect, startAngle, arcLength)
elif self.shape == RenderArea.Pie:
painter.drawPie(rect, startAngle, arcLength)
elif self.shape == RenderArea.Path:
painter.drawPath(path)
elif self.shape == RenderArea.Text:
painter.drawText(rect, Qt.AlignCenter,
"PySide 2\nQt %s" % qVersion())
elif self.shape == RenderArea.Pixmap:
painter.drawPixmap(10, 10, self.pixmap)
painter.restore()
painter.setPen(self.palette().dark().color())
painter.setBrush(Qt.NoBrush)
painter.drawRect(QRect(0, 0, self.width() - 1, self.height() - 1))
def paintEvent(self, event):
contents_y = self.edit.verticalScrollBar().value()
page_bottom = contents_y + self.edit.viewport().height()
font_metrics = self.fontMetrics()
current_block = self.edit.document().findBlock(self.edit.textCursor().position())
painter = QPainter(self)
line_count = 0
block = self.edit.document().begin()
while block.isValid():
line_count += 1
position = self.edit.document().documentLayout().blockBoundingRect(block).topLeft()
if position.y() > page_bottom:
break
bold = False
if block == current_block:
bold = True
font = painter.font()
font.setBold(True)
painter.setFont(font)
self.current = line_count
painter.drawText(self.width() - font_metrics.width(str(line_count)) - 10,
round(position.y()) - contents_y + font_metrics.ascent(),
str(line_count))
if bold:
font = painter.font()
font.setBold(False)
painter.setFont(font)
block = block.next()
self.highest_line = line_count
painter.end()
QWidget.paintEvent(self, event)
def lineNumberAreaPaintEvent(self, e):
self.verticalScrollBar().setSliderPosition(self.verticalScrollBar().sliderPosition())
painter = QPainter(self.lineNumberArea)
# draw the background
background = self.lineNumberArea.palette().color(self.lineNumberArea.backgroundRole())
painter.fillRect(e.rect(), background)
currentBlockNumber = self.textCursor().blockNumber()
blockNumber = self.getFirstVisibleBlockId()
block = self.document().findBlockByNumber(blockNumber)
prev_block = self.document().findBlockByNumber(blockNumber - 1) if blockNumber > 0 else block
translate_y = - self.verticalScrollBar().sliderPosition() if blockNumber > 0 else 0
# Adjust text position according to the previous "non entirely visible" block if applicable
# Also takes in consideration the document's margin offset.
if blockNumber == 0:
# Simply adjust to document's margin
additional_margin = self.document().documentMargin() - 1 - self.verticalScrollBar().sliderPosition()
else:
# Getting the height of the visible part of the previous "non entirely visible" block
# additional_margin = self.document().documentLayout().blockBoundingRect(prev_block).translated(
# 0, translate_y).intersect(self.viewport().geometry().height())
additional_margin = self.document().documentLayout().blockBoundingRect(prev_block).translated(
0, translate_y).intersected(self.viewport().geometry()).height()
# Shift the starting point
top = self.viewport().geometry().top() + additional_margin
bottom = top + self.document().documentLayout().blockBoundingRect(block).height()
col_1 = QColor(90, 255, 30) # Current line (custom green)
col_0 = QColor(120, 120, 120) # Other lines (custom darkgrey)
# Draw the numbers (displaying the current line number in green)
while block.isValid() and top <= e.rect().bottom():
if block.isVisible() and bottom >= e.rect().top():
number = str(int(blockNumber + 1))
painter.setPen(col_1 if currentBlockNumber == blockNumber else col_0)
painter.drawText(0,
top,
self.lineNumberArea.width() - self.lineNumberArea.rightMargin,
self.fontMetrics().height(),
Qt.AlignRight,
number)
block = block.next()
top = bottom
bottom = top + self.document().documentLayout().blockBoundingRect(block).height()
blockNumber += 1
def draw(cls, x, y, self: PreparedText, painter: QPainter):
font = QFont(self.fontName)
if self.fontSize:
font.setPointSizeF(self.fontSize)
if self.fontBold:
font.setBold(True)
if self.fontItalic:
font.setItalic(True)
brushStyle = self.brushStyle or Qt.BrushStyle.SolidPattern
w = self.width
h = self.height
tx = self.left + x
ty = self.top + y
if self.border:
w -= self.border.width
h -= self.border.width * 2
tx += self.border.width
ty += self.border.width
rect = QRectF(tx, ty, w, h)
if self.backColor:
painter.setBrush(brush_style_map[brushStyle])
painter.fillRect(rect, QColor('#' + hex(self.backColor)[2:]))
if self.allowTags:
doc = QTextDocument()
doc.setDefaultFont(font)
doc.setHtml(self.text)
doc.setDocumentMargin(0)
painter.save()
painter.translate(tx + 2, ty + 1)
doc.drawContents(painter, QRectF(0, 0, self.width, self.height))
painter.restore()
else:
painter.save()
painter.setFont(font)
flags = cls.textFlags(self)
rect.setX(rect.x() + 2)
rect.setY(rect.y() + 1)
painter.drawText(rect, flags, self.text)
painter.restore()
if self.border and self.border.color is not None:
old_pen = painter.pen()
pen = QPen(
QColor(self.border.color), self.border.width,
pen_style_map.get(self.border.style, Qt.PenStyle.SolidLine))
painter.setPen(pen)
painter.drawLines(
cls.getLines(self, self.left + x, self.top + y,
self.left + self.width + x,
self.top + y + self.height))
painter.setPen(old_pen)
def paintEvent(self, event):
side = min(self.width(), self.height())
curr_time = self._time
painter = QPainter()
painter.begin(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.translate(self.width() / 2, self.height() / 2)
# draw clock frame
painter.setBrush(QBrush(self.background_color))
r = side / 2
painter.drawEllipse(QPoint(0, 0), side / 2, side / 2)
for i in range(0, 12):
x, y = self.rotate_point(0, -r * 0.95, i * 360 / 12)
painter.drawEllipse(x - 3, y - 3, 6, 6)
painter.setPen(self.text_color)
for i in range(0, 12):
x, y = self.rotate_point(0, -r * 0.85, i * 360 / 12)
painter.drawText(QRect(x - 10, y - 10, 20, 20), Qt.AlignCenter,
"%d" % i)
painter.setPen(self.background_color)
painter.setBrush(QBrush(self.min_pin_color))
for j in range(0, 60):
if j % 5 != 0:
x, y = self.rotate_point(0, -r * 0.95, j * 360 / 60)
painter.drawEllipse(x - 1, y - 1, 2, 2)
painter.setClipping(False)
# draw hands
painter.setBrush(QBrush(self.hour_pin_color))
painter.save()
self.hour_pin[2] = QPoint(0, int(-r * 0.6))
painter.rotate(30.0 * (curr_time.hour() + curr_time.minute() / 60.0))
painter.drawConvexPolygon(self.hour_pin)
painter.restore()
painter.setBrush(QBrush(self.min_pin_color))
painter.save()
self.minute_pin[2] = QPoint(0, int(-r * 0.9))
painter.rotate(6.0 * (curr_time.minute() + curr_time.second() / 60.0))
painter.drawConvexPolygon(self.minute_pin)
painter.restore()
painter.end()
def drawText(self, painter: QPainter) -> None:
""" """
painter.save()
textFont: QFont = QFont()
textFont.setBold(True)
painter.setFont(textFont)
count: int = len(self.__listItem)
self.__initLen = 0
# 横向导航时，字符区域取条目元素中最长的字符宽度
longText: str = ""
for item in self.__items.split("|"):
if len(item) > len(longText):
longText = item
if self.horizontal:
textLen: Decimal = Decimal(painter.fontMetrics().width(longText))
else:
textLen: Decimal = Decimal(painter.fontMetrics().height())
# 逐个绘制元素列表中的文字及文字背景
for i in range(count):
strText: str = self.__listItem[i][0]
left: QPointF = QPointF(self.__initLen, 0)
right: QPointF = QPointF(self.__initLen + textLen + self.__space,
self.height())
if not self.horizontal:
left = QPointF(0, self.__initLen)
right = QPointF(self.width(),
self.__initLen + textLen + self.__space)
textRect: QRectF = QRectF(left, right)
self.__listItem[i][1] = textRect
if self.__isVirgin:
self.__barRect = textRect
self.__isVirgin = False
# 当前选中区域的文字显示选中文字颜色
if textRect == self.__listItem[self.__currentIndex][1]:
painter.setPen(self.__textSelectColor)
else:
painter.setPen(self.__textNormalColor)
painter.drawText(textRect, Qt.AlignCenter, strText)
self.__initLen += textLen + self.__space
painter.restore()
def paintEvent(self, event): # pylint: disable=invalid-name, unused-argument
p = QPainter(self)
p.setRenderHint(QPainter.Antialiasing, True)
p.setPen(Qt.NoPen)
track_opacity = self._track_opacity
thumb_opacity = 1.0
text_opacity = 1.0
if self.isEnabled():
track_brush = self._track_color[self.isChecked()]
thumb_brush = self._thumb_color[self.isChecked()]
text_color = self._text_color[self.isChecked()]
else:
track_opacity *= 0.8
track_brush = self.palette().shadow()
thumb_brush = self.palette().mid()
text_color = self.palette().shadow().color()
p.setBrush(track_brush)
p.setOpacity(track_opacity)
p.drawRoundedRect(
self._margin,
self._margin,
self.width() - 2 * self._margin,
self.height() - 2 * self._margin,
self._track_radius,
self._track_radius,
)
p.setBrush(thumb_brush)
p.setOpacity(thumb_opacity)
p.drawEllipse(
self.offset - self._thumb_radius,
self._base_offset - self._thumb_radius,
2 * self._thumb_radius,
2 * self._thumb_radius,
)
p.setPen(text_color)
p.setOpacity(text_opacity)
font = p.font()
font.setPixelSize(1.5 * self._thumb_radius)
p.setFont(font)
p.drawText(
QRectF(
self.offset - self._thumb_radius,
self._base_offset - self._thumb_radius,
2 * self._thumb_radius,
2 * self._thumb_radius,
),
Qt.AlignCenter,
self._thumb_text[self.isChecked()],
)
def paint(self, painter: QPainter, option: QStyleOptionGraphicsItem,
index: QWidget) -> None:
"""
Paint the graphics of the action wrapper including action name, number, and ports.
:param painter: This draws the widget.
:type painter: QPainter
:param option: Option for the style of graphic.
:type option: QStyleOptionGraphicsItem
:param index: Index for the painted graphic.
:type index: QWidget
:return: None
:rtype: NoneType
"""
ActionGraphics.paint(self, painter, option, index)
# Get dimensions of the action
x, y, width, height = self.getActionRect(self._action.getInputPorts(),
self._action.getOutputPorts())
# Draw the number tag.
number = str(
self._action.getParent().getActions().index(self._action) + 1)
offset = 5
radius = 15
size = ActionGraphics.H_SPACE / 2 - offset * 2
painter.setBrush(QColor(29, 110, 37))
painter.drawRoundedRect(QRectF(x + offset, y + offset, size, size),
radius, radius)
painter.setPen(ActionWrapperGraphics.TAG_TEXT_COLOR)
painter.setBrush(ActionWrapperGraphics.TAG_TEXT_COLOR)
painter.setFont(ActionWrapperGraphics.TAG_FONT)
fm = QFontMetricsF(ActionWrapperGraphics.TAG_FONT)
pixelsWide = fm.width(number)
pixelsHigh = fm.height()
# TODO: fix text positioning - font metrics aren't working well
painter.drawText(x + offset + size / 2 - pixelsWide,
y + offset + size / 2 + pixelsHigh / 2, number)
# Draw the name of the action
painter.setPen(ActionWrapperGraphics.NAME_TEXT_COLOR)
painter.setBrush(ActionWrapperGraphics.NAME_TEXT_COLOR)
painter.setFont(ActionWrapperGraphics.NAME_FONT)
fm = QFontMetricsF(ActionWrapperGraphics.NAME_FONT)
br = fm.boundingRect(self._action.getName())
# TODO: fix text positioning - font metrics aren't working well
t = fm.elidedText(self._action.getName(), Qt.ElideRight,
self._width - offset * 2)
painter.drawText(x + offset, br.height(), t)
def paint(self, painter: QPainter, option: QStyleOptionViewItem,
index: QModelIndex):
"""Paint a cell according index and option
Args:
painter (QPainter)
option (QStyleOptionViewItem)
index (QModelIndex)
"""
# Draw background selections
if option.state & QStyle.State_Selected:
select_color = option.palette.color(QPalette.Normal,
QPalette.Highlight)
text_color = option.palette.color(QPalette.Normal,
QPalette.BrightText)
painter.fillRect(option.rect, select_color)
else:
text_color = option.palette.color(QPalette.Normal, QPalette.Text)
# get icon and color background
icon = index.data(Qt.DecorationRole)
icon_color = index.data(Qt.BackgroundColorRole)
# draw icon background
area = QRect(option.rect.x(), option.rect.y(), option.rect.height(),
option.rect.height())
painter.setPen(Qt.NoPen)
painter.setBrush(QColor(icon_color))
painter.drawRect(area)
# Draw icon
if icon:
icon_area = area.adjusted(3, 3, -3, -3)
painter.drawPixmap(icon_area, icon.pixmap(icon_area.size()))
# Draw text
text_rect = option.rect
text_rect.setLeft(option.rect.height() + 3)
light_font = QFont()
dark_font = QFont()
word = index.data(Qt.DisplayRole)
font = QFont("monospace")
painter.setFont(font)
painter.setPen(QPen(text_color))
painter.drawText(text_rect, Qt.AlignLeft | Qt.AlignVCenter, word)
def drawCurrentBg_ZFB(self, painter: QPainter) -> None:
painter.save()
# 圆半径为高度一定比例,计算宽度,将宽度等分
width: int = self.width() // self.__maxStep
height: int = self.height() // 3
radius: int = height // 3
initX: int = width // 2
initY: int = self.height() // 2
# 绘制当前圆
painter.setPen(Qt.NoPen)
painter.setBrush(self.__currentBackground)
for i in range(self.__currentStep - 1):
initX += width
painter.drawEllipse(QPoint(initX, initY), radius, radius)
initX = initX - width // 4
initY = 0
height = self.height() // 4
# 绘制当前上部提示信息背景
bgRect: QRect = QRect(initX, initY, width // 2, height)
painter.setBrush(self.__currentBackground)
painter.drawRoundedRect(bgRect, height / 2, height / 2)
# 绘制当前上部提示信息
font: QFont = QFont()
font.setPixelSize(height / 1.9)
font.setBold(True)
painter.setFont(font)
painter.setPen(self.__currentForeground)
painter.drawText(bgRect, Qt.AlignCenter,
self.__topInfo[self.__currentStep - 1])
# 绘制倒三角
centerX: int = initX + width // 4
offset: int = 10
pts: QPolygon = QPolygon()
pts.append(QPoint(centerX - offset, height))
pts.append(QPoint(centerX + offset, height))
pts.append(QPoint(centerX, height + offset))
painter.setPen(Qt.NoPen)
painter.drawPolygon(pts)
painter.restore()
def paintEvent(self, e):
""" Draws the color bar and arrow """
if self.item():
painter = QPainter(self)
# Draws the color bar
painter.setPen(Qt.NoPen)
rect = QRect(0, 0, self.COLOR_BAR_WIDTH, self.COLOR_BAR_HEIGHT)
painter.fillRect(rect,
self.item().data(renderSetupRoles.NODE_COLOR_BAR))
oldBrush = painter.brush()
if self.item().type(
) == renderSetup.RENDER_OVERRIDE_TYPE and self.item(
).isLocalRender():
diameter = rect.width() - 2
rect2 = QRect(rect.x() + 1,
rect.y() + (rect.height() - diameter) / 2,
diameter, diameter)
brush = painter.brush()
pen = painter.pen()
hints = painter.renderHints()
painter.setRenderHint(QPainter.Antialiasing, on=True)
painter.setPen(Qt.NoPen)
painter.setBrush(
QBrush(QColor(67, 79, 70), style=Qt.SolidPattern))
painter.drawEllipse(rect2)
painter.setRenderHints(hints)
painter.setPen(pen)
painter.setBrush(brush)
# Draws the arrow
painter.setBrush(self.ARROW_COLOR)
if self.arrowPoints == BaseDelegate.EXPANDED_ARROW:
painter.translate(self.EXPANDED_ARROW_OFFSET, 0.0)
else:
painter.translate(self.COLLAPSED_ARROW_OFFSET, 0.0)
painter.drawPolygon(self.arrowPoints)
painter.setBrush(oldBrush)
# Draws the node type text
painter.setPen(QPen(self.item().data(Qt.TextColorRole)))
text = self.item().data(renderSetupRoles.NODE_TYPE_STR)
painter.setFont(self.item().data(Qt.FontRole))
painter.drawText(self.NODE_TYPE_TEXT_RECT, text,
QTextOption(Qt.AlignLeft | Qt.AlignVCenter))
def paintEvent(self, ev):
"""
Manually implemented paint event
:param ev: the QT paint event
:return:
"""
h = self.height()
w = self.width()
p = QPainter(self)
p.setClipRect(ev.region().boundingRect())
pen = QPen(QColor(0, 0, 0))
pen.setWidth(4)
ls = QFontMetricsF(p.font()).lineSpacing()
for idx, t in enumerate(sorted(list(self._loadData.keys()))):
y = 10 + idx * ls
pen.setColor(ThreadToColor.singleton.get(t))
p.setPen(pen)
p.drawLine(QLineF(15, y, 15 + 15, y))
pen.setColor(QColor(0, 0, 0))
p.setPen(pen)
p.drawText(QPointF(35, y), t)
if len(self._loadData) > 0:
right = max([
polygon[polygon.count() - 1].x()
for _, polygon in self._loadData.items()
])
else:
right = 0.0
p.translate(w - 10 - right * 20, h - 10)
p.scale(
20, -(h - 20)
) # x direction: 20 pixels per second, y direction: spread between 10 and h-10
topleft = p.transform().inverted()[0].map(QPointF(10, 10))
pen.setWidthF(0)
pen.setCosmetic(True)
left = topleft.x()
p.setRenderHint(QPainter.Antialiasing, True)
p.setPen(pen)
p.drawLine(QLineF(left, 0, right, 0))
p.drawLine(QLineF(left, 0, left, 1))
idx = 0
for t, polygon in self._loadData.items():
pen.setColor(ThreadToColor.singleton.get(t))
p.setPen(pen)
p.drawPolyline(polygon)
p.end()
def createDropTextPixmap(self):
pixmap = QPixmap(481, 300)
pixmap.fill(QColor("#333333"))
painter = QPainter(pixmap)
font = QFont("Arial")
font.setPixelSize(28)
font.setBold(True)
fm = QFontMetrics(font)
painter.setFont(font)
painter.setPen(QPen(QColor("#888888"), 1))
text = "Drop the tileset image here"
x = (pixmap.width()-fm.width(text))/2
y = (pixmap.height()+fm.height())/2
painter.drawText(x, y, text)
del painter
return pixmap
def draw_monitor_label(self, painter: QPainter, rect: QRectF, txt: str):
painter.save()
font = self.monitor_label_font
font_metrics = QFontMetrics(font, painter.device())
bounding_rect = font_metrics.boundingRect(rect.toRect(), 0, txt)
x_factor = rect.width() / bounding_rect.width()
y_factor = rect.height() / bounding_rect.height()
factor = min(x_factor, y_factor)
font.setPointSizeF(font.pointSizeF() * factor)
painter.setFont(font)
painter.setPen(self.monitor_label_font_color)
painter.drawText(rect, Qt.AlignCenter, txt)
painter.restore()
def paintEvent(self, event: QPaintEvent):
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
# Draw background
painter.setBrush(QBrush(self._bg_colors[self._state.mode]))
painter.drawRect(event.rect())
# Draw digit
font = QFontDatabase.systemFont(QFontDatabase.FixedFont)
font.setPixelSize(int(self.width() * 6 / 7))
digit = str(self._state.digit) if self._state.digit != 0 else ' '
painter.setPen(self._fg_color)
painter.setFont(font)
flags = Qt.AlignCenter | Qt.TextJustificationForced
painter.drawText(event.rect(), flags, digit)
def textComponent(self):
if self.rpb_textActive:
textPainter = QPainter(self)
penText = QPen()
penText.setColor(
QColor(self.rpb_textColor[0], self.rpb_textColor[1],
self.rpb_textColor[2]))
textPainter.setPen(penText)
fontText = QFont()
fontText.setFamily(self.rpb_textFont)
fontText.setPointSize(self.rpb_textWidth)
textPainter.setFont(fontText)
textPainter.drawText(self.positionX + self.textFactorX,
self.positionY + self.textFactorY,
self.rpb_textValue)
textPainter.end()
def drawBg_TB(self, painter: QPainter) -> None:
painter.save()
# 圆半径为高度一定比例,计算宽度,将宽度等分
width: int = self.width() // self.__maxStep
height: int = self.height() // 3
radius: int = height // 2
initX: int = width // 2
initY: int = self.height() // 2
# 逐个绘制连接线条
pen: QPen = QPen()
pen.setWidthF(radius / 4)
pen.setCapStyle(Qt.RoundCap)
pen.setColor(self.__background)
painter.setPen(pen)
painter.setBrush(Qt.NoBrush)
for i in range(self.__maxStep - 1):
painter.drawLine(QPoint(initX, initY),
QPoint(initX + width, initY))
initX += width
# 逐个绘制圆
initX: int = width // 2
painter.setPen(Qt.NoPen)
painter.setBrush(self.__background)
for i in range(self.__maxStep):
painter.drawEllipse(QPoint(initX, initY), radius, radius)
initX += width
# 逐个绘制圆中的数字
initX = width // 2
font: QFont = QFont()
font.setPixelSize(radius)
painter.setFont(font)
painter.setPen(self.__foreground)
painter.setBrush(Qt.NoBrush)
for i in range(self.__maxStep):
textRect: QRect = QRect(initX - radius, initY - radius, radius * 2,
radius * 2)
painter.drawText(textRect, Qt.AlignCenter, str(i + 1))
initX += width
painter.restore()
def paintEvent(self, event):
p = QPainter()
p.begin(self)
self._normalMap.render(p, event.rect())
p.setPen(Qt.black)
p.drawText(
self.rect(), Qt.AlignBottom | Qt.TextWordWrap,
"GridCal, Map data CCBYSA 2009 "
"OpenStreetMap.org contributors")
p.end()
if self.invert:
p = QPainter(self)
p.setCompositionMode(QPainter.CompositionMode_Difference)
p.fillRect(event.rect(), Qt.white)
p.end()
def draw_text(painter: QPainter, x: float, y: float, flags, text: str):
# Originally from
# https://stackoverflow.com/questions/24831484/how-to-align-qpainter-drawtext-around-a-point-not-a-rectangle
size = 32767.0
corner = QPointF(x, y - size)
if flags & Qt.AlignHCenter:
corner.setX(corner.x() - size / 2.0)
elif flags & Qt.AlignRight:
corner.setX(corner.x() - size)
if flags & Qt.AlignVCenter:
corner.setY(corner.y() + size / 2.0)
elif flags & Qt.AlignTop:
corner.setY(corner.y() + size)
else:
flags |= Qt.AlignBottom
rect = QRectF(corner.x(), corner.y(), size, size)
painter.drawText(rect, int(flags), text)
class QPainterDrawText(unittest.TestCase):
def setUp(self):
self.painter = QPainter()
self.text = "teste!"
def tearDown(self):
del self.text
del self.painter
def testDrawText(self):
# bug #254
rect = self.painter.drawText(100, 100, 100, 100, Qt.AlignCenter | Qt.TextWordWrap, self.text)
self.assert_(isinstance(rect, QRect))
def testDrawTextWithRect(self):
# bug #225
rect = QRect(100, 100, 100, 100)
newRect = self.painter.drawText(rect, Qt.AlignCenter | Qt.TextWordWrap, self.text)
self.assert_(isinstance(newRect, QRect))
def testDrawTextWithRectF(self):
"""QPainter.drawText(QRectF, ... ,QRectF*) inject code"""
rect = QRectF(100, 52.3, 100, 100)
newRect = self.painter.drawText(rect, Qt.AlignCenter | Qt.TextWordWrap, self.text)
self.assert_(isinstance(newRect, QRectF))
def testDrawOverloads(self):
"""Calls QPainter.drawLines overloads, if something is
wrong Exception and chaos ensues. Bug #395"""
self.painter.drawLines([QLine(QPoint(0, 0), QPoint(1, 1))])
self.painter.drawLines([QPoint(0, 0), QPoint(1, 1)])
self.painter.drawLines([QPointF(0, 0), QPointF(1, 1)])
self.painter.drawLines([QLineF(QPointF(0, 0), QPointF(1, 1))])
self.painter.drawPoints([QPoint(0, 0), QPoint(1, 1)])
self.painter.drawPoints([QPointF(0, 0), QPointF(1, 1)])
self.painter.drawConvexPolygon(
[QPointF(10.0, 80.0), QPointF(20.0, 10.0), QPointF(80.0, 30.0), QPointF(90.0, 70.0)]
)
self.painter.drawConvexPolygon([QPoint(10.0, 80.0), QPoint(20.0, 10.0), QPoint(80.0, 30.0), QPoint(90.0, 70.0)])
self.painter.drawPolygon([QPointF(10.0, 80.0), QPointF(20.0, 10.0), QPointF(80.0, 30.0), QPointF(90.0, 70.0)])
self.painter.drawPolygon([QPoint(10.0, 80.0), QPoint(20.0, 10.0), QPoint(80.0, 30.0), QPoint(90.0, 70.0)])
self.painter.drawPolyline([QPointF(10.0, 80.0), QPointF(20.0, 10.0), QPointF(80.0, 30.0), QPointF(90.0, 70.0)])
self.painter.drawPolyline([QPoint(10.0, 80.0), QPoint(20.0, 10.0), QPoint(80.0, 30.0), QPoint(90.0, 70.0)])
def paintEvent(self, event):
painter = QPainter(self)
if self.frame_nub == 1:
painter.setPen(QPen(self.line_color['1'], 3))
painter.drawLine(QLine(37, 30, 37, 106))
painter.setPen(QPen(self.line_color['2'], 3))
painter.drawLine(QLine(37, 106, 37, 161))
painter.setPen(QPen(self.line_color['3'], 3))
painter.drawLine(QLine(37, 161, 37, 295))
painter.setPen(QPen(self.line_color['4'], 3))
painter.drawLine(QLine(37, 295, 37, 493))
elif self.frame_nub == 2:
painter.setPen(QPen(self.line_color['1'], 3))
painter.drawLine(QLine(37, 30, 37, 106))
painter.setPen(QPen(self.line_color['2'], 3))
painter.drawLine(QLine(37, 106, 37, 161 + 280))
# 표가 그려지는 부분 -------------------------------------------------
painter.setPen(QPen(self.line_color['3'], 2))
table_counter = 0
for i in range(0, 200, 40):
for j in range(0, 450, 150):
rect = QRect(70 + j, 200 + i, 150, 40)
# 특정 제한치 이상부터 경고 색으로 바뀜 -----------------------
if table_counter in [5, 8, 11, 14]:
if table_counter == 5:
if int(self.step_info['2'][2.5][table_counter]) >= 160:
painter.fillRect(rect, QColor(250, 142, 145))
else:
painter.fillRect(rect, QColor(234, 234, 234))
else:
if int(self.step_info['2'][2.5][table_counter]) >= 50:
painter.fillRect(rect, QColor(250, 142, 145))
else:
painter.fillRect(rect, QColor(234, 234, 234))
else:
painter.fillRect(rect, QColor(234, 234, 234))
# ---------------------------------------------------------
painter.drawRect(rect)
painter.drawText(rect, Qt.AlignCenter,
self.step_info['2'][2.5][table_counter])
table_counter += 1
# ------------------------------------------------------------------
self.update()
def drawValue(self, painter: QPainter) -> None:
if not self.__showValue: return
radius: int = 100
painter.save()
painter.setPen(self.__textColor)
font: QFont = QFont()
font.setPixelSize(radius - 50 if self.__showPointer else radius - 15)
font.setBold(True)
painter.setFont(font)
textRect: QRectF = QRectF(-radius, -radius, radius * 2, radius * 2)
value = round(self.__value, self.__precision)
strValue: str = str(
int(value)) if self.__precision is 0 else str(value)
painter.drawText(textRect, Qt.AlignCenter, strValue)
painter.restore()
def paintEvent(self, event): # pylint: disable=unused-argument
painter = QPainter(self)
if self.highlight is not None:
# TODO use config colors
painter.fillRect(
0,
5 + 20*self.highlight,
self.width(),
20,
QBrush(QColor(0xc0, 0xc0, 0xc0, 0xff))
)
painter.setFont(Conf.disasm_font)
y = 20
for line in self.lines:
painter.drawText(0, y, line)
y += 20
def paint(
self,
painter: QtGui.QPainter,
option: QtWidgets.QStyleOptionGraphicsItem,
widget: QtWidgets.QWidget = None,
):
view = next(iter(self.scene().views()))
painter.setRenderHint(QtGui.QPainter.Antialiasing)
painter.setFont(self.font)
painter.setPen(self.pen)
fm = painter.fontMetrics()
painter.drawLine(self.line)
if not self.line.p1().isNull():
pen = QtGui.QPen(self.pen)
pen.setWidth(10)
painter.setPen(pen)
painter.drawPoints([self.line.p1(), self.line.p2()])
painter.setPen(self.pen)
if view is not None and self.text != "":
angle = self.line.angle()
if 90 < angle < 270:
angle -= 180
center = view.mapFromScene(self.line.center())
length = (
view.mapFromScene(QtCore.QRectF(0, 0, self.line.length(), 1))
.boundingRect()
.width()
)
width = fm.boundingRect(self.text).width()
if width < length * 0.9:
painter.save()
painter.resetTransform()
transform = QtGui.QTransform()
transform.translate(center.x(), center.y())
transform.rotate(-angle)
painter.setTransform(transform)
painter.drawText(-width / 2.0, -fm.descent(), self.text)
painter.restore()
def drawBaseImage(self, backgroundFile, titleText, titleFont, fontSize, alignment,\
xOffset, yOffset, textColor, visColor):
if backgroundFile == '':
im = Image.new("RGB", (1280, 720), "black")
else:
im = Image.open(backgroundFile)
if self._image == None or not self.lastBackgroundImage == backgroundFile:
self.lastBackgroundImage = backgroundFile
# resize if necessary
if not im.size == (1280, 720):
im = im.resize((1280, 720), Image.ANTIALIAS)
self._image = ImageQt(im)
self._image1 = QtGui.QImage(self._image)
painter = QPainter(self._image1)
font = titleFont
font.setPixelSize(fontSize)
painter.setFont(font)
painter.setPen(QColor(*textColor))
yPosition = yOffset
fm = QtGui.QFontMetrics(font)
if alignment == 0: #Left
xPosition = xOffset
if alignment == 1: #Middle
xPosition = xOffset - fm.width(titleText) / 2
if alignment == 2: #Right
xPosition = xOffset - fm.width(titleText)
painter.drawText(xPosition, yPosition, titleText)
painter.end()
buffer = QtCore.QBuffer()
buffer.open(QtCore.QIODevice.ReadWrite)
self._image1.save(buffer, "PNG")
strio = io.BytesIO()
strio.write(buffer.data())
buffer.close()
strio.seek(0)
return Image.open(strio)
def paintEvent(self, event):
# Set checked depending on state
self.image.setFileName(ThemeManager.CHECKED_PATH if self.
enabled else ThemeManager.UNCHECKED_PATH)
# Init painter and draw image at correct location
painter = QPainter(self)
pixmap = QPixmap.fromImageReader(self.image)
painter.setRenderHint(QPainter.HighQualityAntialiasing, True)
painter.drawPixmap(0, (self.height() - pixmap.height()) / 2, pixmap)
# Style font and draw text at correct location
painter.setFont(self.font)
pen = QPen()
pen.setColor(ThemeManager.LABEL_QC if any([self.hovered, self.enabled])
else ThemeManager.LABEL_LOW_OPACITY_QC)
painter.setPen(pen)
painter.drawText(pixmap.width() + self.padding,
self.height() / 2 + self.nameHeight / 4, self.name)
def paint(self, painter: QPainter, option: QStyleOptionViewItem,
index: QModelIndex):
# Change table item foreground (pen color) to red color if it's highlighted
highlighted_palette = False
if option.state & QStyle.State_Selected:
if option.state & QStyle.State_Active:
painter.fillRect(option.rect, option.palette.highlight())
highlighted_palette = True
elif not (option.state & QStyle.State_HasFocus):
painter.fillRect(option.rect, option.palette.background())
if index.data(TableItemDataRole.HIGHLIGHT):
painter.setPen(
QColor(255, 128, 128) if highlighted_palette else Qt.red)
else:
painter.setPen(Qt.black)
painter.drawText(option.rect, Qt.AlignCenter, index.data())
def draw_cursor_rect(self, pos: Tuple[int, int], brush, addr):
painter = QPainter(self.cursors_pixmap)
cursor_rect = QRect(self.byte_rect)
h = cursor_rect.height()
i, j = pos
cursor_rect.moveTopLeft(QPoint(i * self.byte_advance, j * h))
painter.setPen(Qt.NoPen)
painter.setBrush(brush)
painter.drawRect(cursor_rect)
painter.setFont(self.font)
txt = self.bytes_field[addr][0]
painter.setPen(PEN_BCK)
painter.drawText(cursor_rect, Qt.AlignCenter, f'{txt}')
painter.end()
def paintEvent(self, event: QPaintEvent):
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.eraseRect(event.rect())
painter.setBrush(QBrush(self._bg))
painter.drawRect(event.rect())
if self.mode == 'revealed':
self.setFrameStyle(QFrame.Panel | QFrame.Plain)
self.setLineWidth(0)
self.setMidLineWidth(0)
if self.content in self.content_colors.keys():
font = QFontDatabase.systemFont(QFontDatabase.FixedFont)
font.setPixelSize(int(self.width() * 5 / 6))
painter.setPen(self.content_colors[self.content])
painter.setFont(font)
flags = Qt.AlignCenter | Qt.TextJustificationForced
painter.drawText(event.rect(), flags, self.content)
if self.content == 'bomb':
loc = 'exploded_bomb' if self.was_clicked_bomb else 'bomb'
painter.drawImage(event.rect(),
QImage(self.image_locations[loc]))
if self.mode == 'hidden':
self.setFrameStyle(QFrame.Panel | QFrame.Raised)
self.setLineWidth(3)
self.setMidLineWidth(2)
if self.mode == 'false_bomb':
painter.drawImage(event.rect(),
QImage(self.image_locations['false_bomb']))
if self.mode == 'flag':
self.setFrameStyle(QFrame.Panel | QFrame.Raised)
self.setLineWidth(3)
self.setMidLineWidth(2)
painter.drawImage(event.rect(),
QImage(self.image_locations['flag']))
super(CellWidget, self).paintEvent(event)
def drawCurrentText_JD(self, painter: QPainter) -> None:
width: int = self.width() // self.__maxStep
height: int = self.height() // 2
initX: int = 0
initY: int = height
painter.save()
font: QFont = QFont()
font.setPixelSize(height / 3)
painter.setFont(font)
painter.setPen(self.__currentBackground)
painter.setBrush(Qt.NoBrush)
for i in range(self.__currentStep):
textRect: QRect = QRect(initX, initY, width, height)
painter.drawText(textRect, Qt.AlignCenter, self.__topInfo[i])
initX += width
painter.restore()
def paintEvent(self, _: QPaintEvent) -> None:
"""Qt Paint Event: ensures the title-bar text is elided properly and stays centered"""
painter = QPainter()
painter.begin(self)
painter.setPen(self.__font_pen)
# bold font for macOS window titles
font = self.font()
if sys.platform in ["darwin", "linux"]:
font.setBold(True)
font_metrics = QFontMetrics(font)
# calculate text properties
text_width: int = self.width(
) - self.__button_bar_width - self.__margin
text: str = font_metrics.elidedText(self.__original_text,
Qt.ElideRight, text_width)
# calculate height
br: QRect = font_metrics.boundingRect(text)
if br.height() > 0:
self.__br_height = br.height()
py = self.__ofs_y - self.__br_height / 2.0
br_width = br.width()
# calculate width
px = (self.width() - br_width - WIDTH_PADDING_PX) / 2.0
if px < self.__button_bar_width:
if self.__window_buttons_position == WINDOW_BUTTONS_RIGHT:
if text != self.__original_text:
px = self.__margin
else:
px = px - (self.__button_bar_width - px)
else:
px = self.__button_bar_width
# draw title
rect = QRectF(px, py, br_width + WIDTH_PADDING_PX, self.__br_height)
painter.setFont(font)
if DEBUG:
painter.setBrush(QBrush(QColor('#ff0000')))
painter.drawRect(rect)
painter.drawText(rect, Qt.AlignLeft, text)
class SzumWidget(QWidget):
def __init__(self, parent=None):
super(SzumWidget, self).__init__(parent)
self.setFixedSize(50, 50)
self._ertek = 0
self._p_id = 0
self.painter = QPainter()
def _set_p_id(self, number):
self._p_id = number
self.update()
def _set_ertek(self, number):
self._ertek = number
self.update()
def _get_p_id(self):
return self._p_id
def _get_ertek(self):
return self._ertek
def paintEvent(self, event):
self.painter.begin(self)
pen0 = QPen()
pen0.setWidth(0)
pen_def = self.painter.pen()
pen_white = QPen(QColor(255, 255, 255))
pen_black = QPen(QColor(0, 0, 0))
pen_blue = QPen(QColor(0, 0, 255))
pen_red = QPen(QColor(255, 0, 0))
brush_black = QBrush(QColor(0, 0, 0))
brush_ready = QBrush(QColor(170, 255, 255))
brush_csak1 = QBrush(QColor(255, 255, 255))
self.painter.setBrush(brush_csak1)
self.painter.setPen(pen0)
self.painter.drawRect(0, 0, 49, 49)
self.painter.setPen(pen_black)
self.painter.drawText(25, 30, str(self._ertek))
self.painter.end()
def paintEvent(self, event):
sineTable = [
0, 38, 71, 92, 100, 92, 71, 38, 0, -38, -71, -92, -100, -92, -71,
-38
]
metrics = QFontMetrics(self.font())
x = (self.width() - metrics.horizontalAdvance(self.text)) / 2
y = (self.height() + metrics.ascent() - metrics.descent()) / 2
color = QColor()
painter = QPainter(self)
for i in range(len(self.text)):
index = (self.step + i) % 16
color.setHsv((15 - index) * 16, 255, 191)
painter.setPen(color)
painter.drawText(x,
y - ((sineTable[index] * metrics.height()) / 400),
str(self.text[i]))
x += metrics.horizontalAdvance(self.text[i])
def paintEvent(self, event):
if self.address is None:
return
MARGIN_LEFT = 5
MARGIN_TOP = 5
LINE_MARGIN = 3
painter = QPainter(self)
painter.setPen(QPen(Qt.black, 1))
painter.setFont(Conf.symexec_font)
x = MARGIN_LEFT
y = MARGIN_TOP
for obj in self._objects:
obj_type = type(obj)
if obj_type is NewLinePiece:
# carriage return
x = MARGIN_LEFT
y += Conf.symexec_font_height + LINE_MARGIN
elif obj_type is AddressPiece:
# address
addr_str = "%08x" % obj.address
painter.drawText(x, y + Conf.symexec_font_ascent, addr_str)
x += Conf.symexec_font_width * len(addr_str)
x += 7
elif obj_type is QASTViewer:
# AST viewer
obj.x = x
obj.y = y
obj.paint(painter)
x += obj.width + 2
else:
raise TypeError('paintEvent(): Unsupported object type %s.' %
obj_type)
def paintEvent(self, event):
painter = QPainter(self)
painter.fillRect(self.rect(), Qt.black)
if self.pixmap.isNull():
painter.setPen(Qt.white)
painter.drawText(self.rect(), Qt.AlignCenter,
"Rendering initial image, please wait...")
return
if self.curScale == self.pixmapScale:
painter.drawPixmap(self.pixmapOffset, self.pixmap)
else:
scaleFactor = self.pixmapScale / self.curScale
newWidth = int(self.pixmap.width() * scaleFactor)
newHeight = int(self.pixmap.height() * scaleFactor)
newX = self.pixmapOffset.x() + (self.pixmap.width() - newWidth) / 2
newY = self.pixmapOffset.y() + (self.pixmap.height() - newHeight) / 2
painter.save()
painter.translate(newX, newY)
painter.scale(scaleFactor, scaleFactor)
exposed, _ = painter.matrix().inverted()
exposed = exposed.mapRect(self.rect()).adjusted(-1, -1, 1, 1)
painter.drawPixmap(exposed, self.pixmap, exposed)
painter.restore()
text = "Use mouse wheel or the '+' and '-' keys to zoom. Press and " \
"hold left mouse button to scroll."
metrics = painter.fontMetrics()
textWidth = metrics.width(text)
painter.setPen(Qt.NoPen)
painter.setBrush(QColor(0, 0, 0, 127))
painter.drawRect((self.width() - textWidth) / 2 - 5, 0, textWidth + 10,
metrics.lineSpacing() + 5)
painter.setPen(Qt.white)
painter.drawText((self.width() - textWidth) / 2,
metrics.leading() + metrics.ascent(), text)
