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):
""" Поскольку это полностью прозрачное фоновое окно, жесткая для поиска
граница с прозрачностью 1 рисуется в событии перерисовывания, чтобы отрегулировать размер окна. """
super(FramelessWindow, self).paintEvent(event)
painter = QPainter(self)
painter.setPen(QPen(QColor(255, 255, 255, 1), 2 * self.Margins))
painter.drawRect(self.rect())
def paintEvent(self, event):
size = self.size()
# draw background
painter = QPainter()
painter.begin(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.setPen(QColor(255, 255, 255, 255))
painter.setBrush(self.fill_color)
painter.drawRect(0, 0, size.width(), size.height())
painter.end()
def shape_to_pixelmap(item_type, pen, brush, shape) -> QPixmap:
pixmap = QPixmap(50, 50)
pixmap.fill(Qt.transparent)
painter = QPainter(pixmap)
painter.setRenderHint(QPainter.Antialiasing)
painter.setPen(pen)
painter.setBrush(brush)
if item_type == QGraphicsRectItem.type(QGraphicsRectItem()):
painter.drawRect(QRect(10, 15, 30, 20))
elif item_type == QGraphicsEllipseItem.type(QGraphicsEllipseItem()):
painter.drawEllipse(QRect(10, 10, 30, 30))
elif item_type == QGraphicsPolygonItem.type(QGraphicsPolygonItem()):
if shape.polygon().size() == 3:
painter.drawPolygon(QPolygon([QPoint(10, 40), QPoint(40, 40), QPoint(25, 10)]))
else:
painter.drawPolygon(QPolygon([QPoint(12, 40), QPoint(23, 36),
QPoint(37, 24), QPoint(23, 12), QPoint(7, 16)]))
elif item_type == QGraphicsLineItem.type(QGraphicsLineItem()):
painter.drawLine(QLine(10, 40, 40, 10))
return pixmap
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.transform().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.horizontalAdvance(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)
class ScreenSelection(QtWidgets.QGroupBox):
def __init__(self, parent: DisplayCalibration):
QtWidgets.QGroupBox.__init__(self,
'Fullscreen selection (double click)')
self.main = parent
self.setSizePolicy(QtWidgets.QSizePolicy.Policy.Expanding,
QtWidgets.QSizePolicy.Policy.Expanding)
self.painter = QPainter()
def mouseDoubleClickEvent(self, ev, *args, **kwargs):
for screen_id, screen_coords in enumerate(
self._get_widget_screen_coords()):
rect = QtCore.QRectF(*screen_coords)
if not rect.contains(QtCore.QPoint(ev.pos().x(), ev.pos().y())):
continue
print(f'Set display to fullscreen on screen {screen_id}')
screen = access.application.screens()[screen_id]
px_ratio = screen.devicePixelRatio()
self.main.global_settings.screen_id.set_value(screen_id)
self.main.global_settings.win_x_pos.set_value(
screen.geometry().x())
self.main.global_settings.win_y_pos.set_value(
screen.geometry().y())
self.main.global_settings.win_width.set_value(
int(screen.geometry().width() * px_ratio))
self.main.global_settings.win_height.set_value(
int(screen.geometry().height() * px_ratio))
access.application.processEvents()
@staticmethod
def _get_norm_screen_coords() -> np.ndarray:
# Get connected screens
avail_screens = access.application.screens()
# Calculate total display area bounding box
area = [[
s.geometry().width() * s.devicePixelRatio(),
s.geometry().height() * s.devicePixelRatio()
] for s in avail_screens]
area = np.sum(area, axis=0)
xmin = np.min([s.geometry().x() for s in avail_screens])
ymin = np.min([s.geometry().y() for s in avail_screens])
# Define normalization functions
xnorm = lambda x: (x - xmin) / area[0]
ynorm = lambda y: (y - ymin) / area[1]
# Add screen dimensions
screens = []
for s in avail_screens:
g = s.geometry()
screens.append([
xnorm(g.x() * s.devicePixelRatio()), # x
ynorm(g.y() * s.devicePixelRatio()), # y
xnorm(g.width() * s.devicePixelRatio()), # width
ynorm(g.height() * s.devicePixelRatio())
]) # height
return np.array(screens)
def _get_widget_screen_coords(self):
s = self._get_norm_screen_coords()
s[:, 0] *= self.size().width()
s[:, 1] *= self.size().height()
s[:, 2] *= self.size().width()
s[:, 3] *= self.size().height()
return s.astype(int)
def paintEvent(self, QPaintEvent):
for i, screen in enumerate(self._get_widget_screen_coords()):
rect = QtCore.QRect(*screen)
self.painter.begin(self)
self.painter.setBrush(QtCore.Qt.BrushStyle.Dense4Pattern)
self.painter.drawRect(rect)
self.painter.setPen(QColor(168, 34, 3))
self.painter.setFont(QFont('Decorative', 30))
self.painter.drawText(rect, QtCore.Qt.AlignmentFlag.AlignCenter,
str(i))
self.painter.end()
def paintEvent(self, event):
p = QPainter(self.viewport())
render = self.createRenderContext()
render.init(p)
charWidth = render.getFontWidth()
charHeight = render.getFontHeight()
# Compute range that needs to be updated
topY = event.rect().y()
botY = topY + event.rect().height()
topY = (topY - 2) // charHeight
botY = ((botY - 2) // charHeight) + 1
# Compute selection range
selection = False
selStart, selEnd = self.getSelectionOffsets()
if selStart != selEnd:
selection = True
# Draw selection
if selection:
startY = None
endY = None
startX = None
endX = None
for i in range(0, len(self.lines)):
if selStart >= self.lines[i].address:
startY = i - self.topLine
startX = selStart - self.lines[i].address
if startX > self.cols:
startX = self.cols
if selEnd >= self.lines[i].address:
endY = i - self.topLine
endX = selEnd - self.lines[i].address
if endX > self.cols:
endX = self.cols
if startY is not None and endY is not None:
p.setPen(binaryninjaui.getThemeColor(
ThemeColor.SelectionColor))
p.setBrush(
binaryninjaui.getThemeColor(ThemeColor.SelectionColor))
if startY == endY:
p.drawRect(2 + (self.addrWidth + 2 + startX) * charWidth,
2 + startY * charHeight,
(endX - startX) * charWidth, charHeight + 1)
else:
p.drawRect(2 + (self.addrWidth + 2 + startX) * charWidth,
2 + startY * charHeight,
(self.cols - startX) * charWidth,
charHeight + 1)
if endX > 0:
p.drawRect(2 + (self.addrWidth + 2) * charWidth,
2 + endY * charHeight, endX * charWidth,
charHeight + 1)
if (endY - startY) > 1:
p.drawRect(2 + (self.addrWidth + 2) * charWidth,
2 + (startY + 1) * charHeight,
self.cols * charWidth,
((endY - startY) - 1) * charHeight + 1)
# Paint each line
color = self.palette().color(QPalette.WindowText)
for y in range(topY, botY):
if (y + self.topLine) < 0:
continue
if (y + self.topLine) >= len(self.lines):
break
if self.lines[y + self.topLine].separator:
render.drawLinearDisassemblyLineBackground(
p,
LinearDisassemblyLineType.NonContiguousSeparatorLineType,
QRect(0, 2 + y * charHeight,
event.rect().width(), charHeight), 0)
continue
lineStartAddr = self.lines[y + self.topLine].address
addrStr = "%.8x" % lineStartAddr
length = self.lines[y + self.topLine].length
text = self.lines[y + self.topLine].text
cursorCol = None
if (((self.cursorAddr >= lineStartAddr) and
(self.cursorAddr < (lineStartAddr + length)))
or (((y + self.topLine + 1) >= len(self.lines)) and
(self.cursorAddr == (lineStartAddr + length)))):
cursorCol = self.cursorAddr - lineStartAddr
render.drawText(
p, 2, 2 + y * charHeight,
binaryninjaui.getThemeColor(ThemeColor.AddressColor), addrStr)
render.drawText(p, 2 + (self.addrWidth + 2) * charWidth,
2 + y * charHeight, color, text)
if self.caretVisible and self.caretBlink and not selection and cursorCol is not None:
p.setPen(Qt.NoPen)
p.setBrush(self.palette().color(QPalette.WindowText))
p.drawRect(2 + (self.addrWidth + 2 + cursorCol) * charWidth,
2 + y * charHeight, charWidth, charHeight + 1)
caretTextColor = self.palette().color(QPalette.Base)
byteValue = self.data.read(lineStartAddr + cursorCol, 1)
if len(byteValue) == 1:
byteStr = self.byte_mapping[byteValue[0]]
render.drawText(
p, 2 + (self.addrWidth + 2 + cursorCol) * charWidth,
2 + y * charHeight, caretTextColor, byteStr)
def paintEvent(self, ev):
p = QPainter(self)
p.setFont(self.font)
#p.fillRect(self.rect(), QBrush(Qt.blue))
length = len(self.display_data)
# Reduce to the number of lines that are available in the data
num_rows = length // self.bytes_per_line
if length % self.bytes_per_line > 0:
num_rows += 1
for l in range(num_rows):
p.setPen(self.label_color)
# Draw address label
# self.instance.get_local_label(self.start_offset + l * self.bytes_per_line)
position_string = self.display_labels[l]
p.drawText(QPoint(self.label_offset_x, (l + 1) * self.line_height),
position_string)
for i in range(
0,
min(self.bytes_per_line,
length - self.bytes_per_line * l)):
#virtual_address = self.start_offset + l*self.bytes_per_line + i
p.setPen(self.byte_color)
current_byte = self.display_data[i + l * self.bytes_per_line]
if current_byte.background is not None:
p.setBackground(current_byte.background)
p.setBackgroundMode(Qt.OpaqueMode)
p.drawText(
QPoint(self.label_length + i * self.byte_width,
(l + 1) * self.line_height), current_byte.text)
p.setBackgroundMode(Qt.TransparentMode)
# Draw selection rects
if current_byte.is_selected:
p.setPen(self.selection_color)
p.drawRect(
# TODO make these offsets configurable/dependent on font?
self.label_length + i * self.byte_width - 3,
(l) * self.line_height + 3,
self.byte_width,
self.line_height)
# Draw annotation underlines
if len(current_byte.annotations) > 0:
y_offset = 0
for annotation in current_byte.annotations:
self.annotation_pen.setColor(annotation.color)
p.setPen(self.annotation_pen)
x = self.label_length + i * self.byte_width
y = (l + 1) * self.line_height + y_offset + 2
p.drawLine(x, y, x + self.byte_width, y)
y_offset += 2
# Draw constraint pipes
if len(current_byte.constraints) > 0:
enabled = False
for constraint in current_byte.constraints:
if constraint.enabled:
enabled = True
break
if enabled:
p.setPen(self.enabled_constraint_pen)
else:
p.setPen(self.disabled_constraint_pen)
x = self.label_length + i * self.byte_width - 2
y = (l) * self.line_height + 3
p.drawLine(x, y, x, y + self.line_height)
def paintEvent(self, pe) -> None:
mainradius, fontsizefactor, center_x, center_y_pp, width = self.computeCenter(
)
painter = QPainter(self)
# So that we can use the background color
painter.setBackgroundMode(Qt.OpaqueMode)
# Smooth out the circle
painter.setRenderHint(QPainter.Antialiasing)
# Use background color
textBgColor = QColor(painter.background().color())
# print("bgcolor = ", bgColor)
bgColor = QColor("transparent")
pointColor = QColor(painter.pen().color())
self.pointColor = pointColor
self.bgColor = textBgColor
alpha = 150
if self.parent().displayPp == 'all' or self.parent(
).displayPp == self.io:
pointColor.setAlpha(255)
else:
pointColor.setAlpha(alpha)
# draw text
if not self._hasFixedFontSize:
fontsize = mainradius * fontsizefactor
else:
fontsize = self._fixedFontSize
self.fontsize = fontsize
textRect_ = QtCore.QRectF(0, center_y_pp - mainradius - 2 * fontsize,
width, 2 * fontsize)
f = painter.font()
f.setPointSizeF(fontsize)
# self._io = 'in'
if self.io == 'out':
fm = QFontMetrics(f).boundingRect(self._text)
# print("fm = ", fm)
painter.setBrush(pointColor)
painter.setPen(QPen(pointColor))
painter.drawRect(
QtCore.QRectF(center_x - fm.width() / 2,
center_y_pp - mainradius - 2 * fontsize,
fm.width(), fm.height()))
painter.setPen(QPen(textBgColor))
painter.setFont(f)
painter.setBackgroundMode(Qt.TransparentMode)
painter.drawText(textRect_, Qt.AlignHCenter | Qt.AlignTop, self._text)
# draw hexagon
painter.setBrush(bgColor)
painter.setPen(pointColor)
painter.drawPolygon(
self.createPoly(6, mainradius, center_x, center_y_pp))
# draw outer circle
radius_outer = mainradius * .8
if self.title not in implementedPatchPoints:
painter.setBrush(QtGui.QBrush(QtGui.QColor(int("0x999999", 0))))
painter.drawEllipse(QtCore.QPointF(center_x, center_y_pp),
radius_outer, radius_outer)
# draw inner circle
radius_inner = mainradius * .5
# painter.setBrush(QBrush(pointColor))
painter.setBrush(QColor(self._ppColor))
painter.drawEllipse(QtCore.QPointF(center_x, center_y_pp),
radius_inner, radius_inner)
def paintEvent(self, event):
p = QPainter(self)
p.drawImage(self.rect(), self.image)
p.drawRect(self.rect())