def paintEvent(self, e):
#define the painter
painter = QPainter(self)
#define a brush for the background of the axis area
brush = QtGui.QBrush()
brush.setColor(QtGui.QColor('black'))
brush.setStyle(Qt.SolidPattern)
#define a rectangle to fill the axis area background
rect = QtCore.QRect(0, 0,
painter.device().width(),
painter.device().height())
painter.fillRect(rect, brush)
#define width and height for centering
w = self.width()
h = self.height()
title = QtGui.QPen()
title.setColor(QtGui.QColor('white'))
painter.setPen(title)
painter.setOpacity(1)
font = QtGui.QFont()
#set up the text labels
font.setBold(True)
font.setPointSize(18)
painter.setFont(font)
painter.drawText(QRect(0, 0, w, h), Qt.AlignCenter | Qt.AlignCenter,
self.plotTitle)
def updateFilledCircle(self, s):
size = s * self.zoom
pixmap = QPixmap(self.width(), self.height())
pixmap.fill(Qt.transparent)
#painter filled ellipse
p = QPalette()
painter = QPainter()
painter.begin(pixmap)
painter.setRenderHint(QPainter.Antialiasing)
brush = QBrush(p.link().color())
painter.setBrush(brush)
painter.setOpacity(0.4)
painter.drawEllipse(
QRect(
old_div(self.width(), 2) - old_div(size, 2),
old_div(self.height(), 2) - old_div(size, 2), size, size))
painter.end()
#painter ellipse 2
painter2 = QPainter()
painter2.begin(pixmap)
painter2.setRenderHint(QPainter.Antialiasing)
pen2 = QPen(Qt.green)
pen2.setWidth(1)
painter2.setPen(pen2)
painter2.drawEllipse(
QRect(
old_div(self.width(), 2) - old_div(size, 2),
old_div(self.height(), 2) - old_div(size, 2), size, size))
painter2.end()
self.ellipseLabel.setPixmap(QPixmap(pixmap))
self.lastSize = s
def updateFilledCircle(self, s):
size = s * self.zoom
pixmap = QPixmap(self.width(), self.height())
pixmap.fill(Qt.transparent)
#painter filled ellipse
p = QPalette()
painter = QPainter()
painter.begin(pixmap)
painter.setRenderHint(QPainter.Antialiasing)
brush = QBrush(p.link().color())
painter.setBrush(brush)
painter.setOpacity(0.4)
painter.drawEllipse(QRect(old_div(self.width(),2) - old_div(size,2), old_div(self.height(),2) - old_div(size,2), size, size))
painter.end()
#painter ellipse 2
painter2 = QPainter()
painter2.begin(pixmap)
painter2.setRenderHint(QPainter.Antialiasing)
pen2 = QPen(Qt.green)
pen2.setWidth(1)
painter2.setPen(pen2)
painter2.drawEllipse(QRect(old_div(self.width(),2) - old_div(size,2), old_div(self.height(),2) - old_div(size,2), size, size))
painter2.end()
self.ellipseLabel.setPixmap(QPixmap(pixmap))
self.lastSize = s
def paintEvent(self, event=None):
painter = QPainter(self)
painter.setOpacity(0.4)
painter.setBrush(Qt.white)
painter.setPen(QPen(Qt.white))
painter.drawRect(self.rect())
def paintEvent(self, event):
radius = 50
treeSize = QSizeF(2 * radius, 2 * radius)
bounds = QRectF( (self.width() - treeSize.height()) / 2,
(self.height() - treeSize.width()) / 2,
treeSize.width(),
treeSize.height())
painter = QPainter(self)
# draw the shadow
painter.setBrush(Qt.black)
painter.setPen(Qt.NoPen)
painter.setOpacity(0.5)
xrad = 95
yrad = self.shadowLength * 20
rect = QRectF(-xrad, -yrad, xrad, yrad)
painter.translate(self.width() / 2, self.height() / 2)
painter.rotate(self.angle)
painter.translate(xrad/2, yrad/2)
painter.drawChord(rect, 0, 180*16)
painter.resetTransform()
# draw the tree
painter.setOpacity(1)
self.tree.render(painter, bounds)
# draw the compass
bounds = QRectF( 10, 10, 50, 50)
self.compass.render(painter, bounds)
def paintEvent(self, event):
_size = self.size() - QSize(2, 2)
if (_size.isEmpty()):
return
origX = (_size.width() - self.mNewSize.width() * self.mScale) / 2 + 0.5
origY = (_size.height() -
self.mNewSize.height() * self.mScale) / 2 + 0.5
oldRect = QRect(self.mOffset, self.mOldSize)
painter = QPainter(self)
painter.translate(origX, origY)
painter.scale(self.mScale, self.mScale)
pen = QPen(Qt.black)
pen.setCosmetic(True)
painter.setPen(pen)
painter.drawRect(QRect(QPoint(0, 0), self.mNewSize))
pen.setColor(Qt.white)
painter.setPen(pen)
painter.setBrush(Qt.white)
painter.setOpacity(0.5)
painter.drawRect(oldRect)
pen.setColor(Qt.black)
pen.setStyle(Qt.DashLine)
painter.setOpacity(1.0)
painter.setBrush(Qt.NoBrush)
painter.setPen(pen)
painter.drawRect(oldRect)
painter.end()
def paintEvent(self, event):
painter = QPainter(self)
event.accept()
if not self.isEnabled():
painter.save()
painter.setOpacity(0.2)
painter.drawPixmap(self.fPixmapRect, self.fPixmapNormal, self.fPixmapRect)
painter.restore()
elif self.isChecked() or self.isDown():
painter.drawPixmap(self.fPixmapRect, self.fPixmapDown, self.fPixmapRect)
elif self.fIsHovered:
painter.drawPixmap(self.fPixmapRect, self.fPixmapHover, self.fPixmapRect)
else:
painter.drawPixmap(self.fPixmapRect, self.fPixmapNormal, self.fPixmapRect)
if not self.fTopText:
return
painter.save()
painter.setPen(self.fTopTextColor)
painter.setBrush(self.fTopTextColor)
painter.setFont(self.fTopTextFont)
painter.drawText(QPointF(10, 16), self.fTopText)
painter.restore()
def paintEvent(self, event):
if self.btn_update:
qp = QPainter()
self.iconPix.fill(Qt.transparent)
qp.begin(self.iconPix)
self.text.setStyleSheet("#text { background: none; } ")
self.text.setStyleSheet(
"#text { background: rgba(155,150,100, 0); text-align: center; border-radius: 5px;} "
)
if self.select:
qp.setOpacity(.1)
qp.setPen(Qt.NoPen)
self.text.setStyleSheet(
"#text { background: rgba(155,100,255, 0.5); text-align: center; border-radius: 5px;} "
)
qp.setOpacity(self.opacity)
self.drawIcon(event, qp)
self.icon.setPixmap(self.iconPix)
qp.end()
QF = QFont()
QFM = QFontMetrics(QF)
bound = QFM.boundingRect(0, 0, 100, 1000,
Qt.TextWordWrap | Qt.AlignCenter,
self.text.text())
self.text.setFixedHeight(bound.height())
self.btn_update = False
def paintEvent(self, e):
""" 绘制图标 """
iconPixmap = self.iconPixmap
px, py = self._pixPos_list[0]
painter = QPainter(self)
painter.setRenderHints(QPainter.Antialiasing
| QPainter.SmoothPixmapTransform)
painter.setPen(Qt.NoPen)
# 鼠标按下时绘制圆形背景，pressed的优先级比hover的优先级高
if self.isPressed:
# brush = QBrush(QColor(162, 162, 162, 120))
brush = QBrush(QColor(255, 255, 255, 70))
painter.setBrush(brush)
painter.drawEllipse(0, 0, self.iconWidth, self.iconHeight)
iconPixmap = self.iconPixmap.scaled(
self.iconPixmap.width() - 4,
self.iconPixmap.height() - 4,
Qt.KeepAspectRatio,
Qt.SmoothTransformation,
)
px, py = self._pixPos_list[1]
# 鼠标进入时更换图标透明度
elif self.isEnter:
painter.setOpacity(0.5)
# 绘制图标
painter.drawPixmap(px, py, iconPixmap.width(), iconPixmap.height(),
iconPixmap)
def draw_pointer_indicator_r(self, painter: QtGui.QPainter):
""" 绘制指示器, 样式indicator_r """
radius = 62
offset = 8
painter.save()
painter.setOpacity(0.6)
# QPolygon 类提供了一个使用整数精度的点向量，QPoint的集合
pts = QtGui.QPolygon()
pts.setPoints(3, -offset, 0, offset, 0, 0, radius)
painter.rotate(self.start_angle)
deg_rotate = (360 - self.start_angle - self.end_angle) / (
self.max_value - self.min_value) * (self.value - self.min_value)
painter.rotate(deg_rotate)
color = self.percent_color
if self.double_percent:
center = (self.value == (self.max_value - self.min_value) / 2 +
self.min_value)
color = self.border_color if center else self.percent_color
pen = QtGui.QPen()
pen.setColor(pen)
painter.setPen(pen)
painter.setBrush(color)
painter.drawConvexPolygon(pts)
# 增加绘制圆角直线，与之前三角形重叠，形成圆角指针
pen.setCapStyle(QtCore.Qt.RoundCap)
pen.setWidth(offset - 1)
painter.setPen(pen)
painter.drawLine(0, 0, 0, radius)
painter.restore()
def draw_pointer_indicator(self, painter: QtGui.QPainter):
""" 绘制指示器, 样式indicator """
radius = 62
offset = 8
painter.save()
painter.setOpacity(0.8)
# QPolygon 类提供了一个使用整数精度的点向量，QPoint的集合
pts = QtGui.QPolygon()
pts.setPoints(3, -offset, 0, offset, 0, 0, radius)
painter.rotate(self.start_angle)
deg_rotate = (360 - self.start_angle - self.end_angle) / (
self.max_value - self.min_value) * (self.value - self.min_value)
painter.rotate(deg_rotate)
color = self.percent_color
if self.double_percent:
center = (self.value == (self.max_value - self.min_value) / 2 +
self.min_value)
color = self.border_color if center else self.percent_color
painter.setPen(color)
painter.setBrush(color)
painter.drawConvexPolygon(pts)
painter.restore()
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, event=None):
painter = QPainter(self)
painter.setOpacity(0.7)
painter.setBrush(Qt.black)
painter.setPen(QPen(Qt.black))
painter.drawRect(self.rect())
def paintEvent(self, event):
QWidget.paintEvent(self, event)
painter = QPainter(self)
painter.setBrush(QBrush(QColor(Qt.black)))
painter.setPen(QPen())
painter.setOpacity(self.value)
painter.drawRect(self.rect())
def set_button_image(self, button, filename, opacity=1):
'''
- wenn kein Dateiname, dann Knopf verstecken
- Setze Bild fuer Knopf/Anpassen der Groesse
- anzeigen
'''
if not filename:
button.hide()
else:
button.show()
button.setText("")
if opacity < 1:
orgPix = QPixmap(filename)
transparent = QPixmap(orgPix.size())
transparent.fill(Qt.transparent)
painter = QPainter(transparent)
painter.setOpacity(opacity)
painter.drawPixmap(0, 0, orgPix)
painter.end()
icon = QIcon(transparent)
else:
icon = QIcon(filename)
button.setIcon(icon)
self.resize_button_icon(button)
# 10% vom Rand platz
button.show()
def paintEvent(self, event):
radius = 50
treeSize = QSizeF(2 * radius, 2 * radius)
bounds = QRectF((self.width() - treeSize.height()) / 2,
(self.height() - treeSize.width()) / 2,
treeSize.width(), treeSize.height())
painter = QPainter(self)
# draw the shadow
painter.setBrush(Qt.black)
painter.setPen(Qt.NoPen)
painter.setOpacity(0.5)
xrad = 95
yrad = self.shadowLength * 20
rect = QRectF(-xrad, -yrad, xrad, yrad)
painter.translate(self.width() / 2, self.height() / 2)
painter.rotate(self.angle)
painter.translate(xrad / 2, yrad / 2)
painter.drawChord(rect, 0, 180 * 16)
painter.resetTransform()
# draw the tree
painter.setOpacity(1)
self.tree.render(painter, bounds)
# draw the compass
bounds = QRectF(10, 10, 50, 50)
self.compass.render(painter, bounds)
def paintEvent(self, event=None):
painter = QPainter(self)
painter.setOpacity(0.1) ######### j: replace number with var
painter.setBrush(Qt.white)
painter.setPen(QPen(Qt.white))
painter.drawRect(self.rect())
def paint(self,
painter: QtGui.QPainter,
option: QtWidgets.QStyleOptionGraphicsItem,
widget: Optional[QtWidgets.QWidget] = None) -> None:
size = min(self.__size.width(), self.__size.height())
size = int(size - 0.4 * max(0, size - 50))
if size < 10:
return
pixmap_size = QtCore.QSize(size, size)
if self.__pixmap is None or self.__pixmap.size() != pixmap_size:
self.__pixmap = QtGui.QPixmap(pixmap_size)
self.__pixmap.fill(QtGui.QColor(0, 0, 0, 0))
pixmap_painter = QtGui.QPainter(self.__pixmap)
try:
self.__icon.render(pixmap_painter,
QtCore.QRectF(0, 0, size, size))
finally:
pixmap_painter.end()
painter.setOpacity(min(0.8, max(0.2, 0.8 - (size - 30) / 100)))
painter.drawPixmap(int((self.__size.width() - size) / 2),
int((self.__size.height() - size) / 2),
self.__pixmap)
def fillOpacityModel(self):
self.brushOpacityModel.clear()
self.brushFlowModel.clear()
for s in range(len(self.opacityList)):
# we're gonna itterate over our list, and make a new item for each entry.
item = QStandardItem()
item.setCheckable(False)
item.setEditable(False)
item.setDragEnabled(False)
item.setText(str(self.opacityList[s]) + " %")
brushImage = QPixmap(64, 64)
img = QImage(64, 64, QImage.Format_RGBA8888)
circlePainter = QPainter()
img.fill(Qt.transparent)
circlePainter.begin(img)
brush = QBrush(Qt.SolidPattern)
brush.setColor(self.brushSizeTableView.palette().color(
QPalette.Text))
circlePainter.setBrush(brush)
circlePainter.setPen(QPen(QBrush(Qt.transparent), 0))
circlePainter.setOpacity(float(self.opacityList[s]) / 100.0)
circlePainter.drawEllipse(QPointF(32, 32), 32, 32)
circlePainter.end()
brushImage = QPixmap.fromImage(img)
item.setIcon(QIcon(brushImage))
# the flow and opacity models will use virtually the same items, but Qt would like us to make sure we understand
# these are not really the same items, so hence the clone.
itemFlow = item.clone()
self.brushOpacityModel.appendRow(item)
self.brushFlowModel.appendRow(itemFlow)
self.brushOpacityTableView.setModel(self.brushOpacityModel)
self.brushFlowTableView.setModel(self.brushFlowModel)
def draw(self, painter: QPainter):
assert self.crop, 'crop must be set'
# Compute painter regions for the crop and the blur
all_region = QRegion(painter.viewport())
crop_region = QRegion(self.crop)
blur_region = all_region.subtracted(crop_region)
# Let the QGraphicsBlurEffect only paint in blur_region
painter.setClipRegion(blur_region)
# Fill with black and set opacity so that the blurred region is drawn darker
if self.BLUR_DARKEN > 0.0:
painter.fillRect(painter.viewport(), Qt.black)
painter.setOpacity(1 - self.BLUR_DARKEN)
# Draw the blur effect
super().draw(painter)
# Restore clipping and opacity
painter.setClipping(False)
painter.setOpacity(1.0)
# Get the source pixmap
pixmap, offset = self.sourcePixmap(Qt.DeviceCoordinates, QGraphicsEffect.NoPad)
painter.setWorldTransform(QTransform())
# Get the source by adding the offset to the crop location
source = self.crop
if self.CROP_OFFSET_ENABLED:
source = source.translated(self.CROP_OFFSET)
painter.drawPixmap(self.crop.topLeft() + offset, pixmap, source)
def flood(self, e):
image = self.pixmap().toImage()
b = image.bits()
b.setsize(512 * 512 * 4)
arr = np.frombuffer(b, np.uint8).reshape((512, 512, 4))
arr = arr.astype(np.int32)
arr = np.flip(arr, axis=2)
i = self.color_index + 1
arr_test = arr[:,:,i]-((arr[:,:,1]+ arr[:,:,2]+ arr[:,:,3])/3)
#arr test is not greyscale
i = 2 - self.color_index
#painted_arr is BGRA
painted_arr = np.zeros_like(arr,dtype=np.uint8)
painted_arr[:,:,i][arr_test!=0] = 255
#this makes the drawn images the same as pen color
painted_arr[:,:,i] = 255*flood(painted_arr[:,:,i],(e.y(),e.x()))
#sets alpha from ith channel
painted_arr[:,:,3] = painted_arr[:,:,i]
#BGRA
qi = QImage(painted_arr.data, painted_arr.shape[1], painted_arr.shape[0], 4*painted_arr.shape[1], QImage.Format_ARGB32_Premultiplied)
pixmap = QPixmap(qi)
painter = QPainter(self.pixmap())
painter.setOpacity(0.5)
painter.drawPixmap(0,0,pixmap)
painter.end()
self.update()
#self.array saves RGB values
self.array += np.flip(painted_arr[:,:,:3], axis=2)
def initUI(self):
self.setStyleSheet("background: transparent")
self.scene.setSceneRect(0, 0, 1000, 223)
tempImg = QPixmap('PNG/9c49087c09fd07a10ae3887a7825f389.jpg')
tempImg = tempImg.scaled(self.scene.width(), self.scene.height())
new_pix = QPixmap(tempImg.size())
new_pix.fill(Qt.darkGray)
painter = QPainter(new_pix)
painter.setOpacity(0.35)
painter.drawPixmap(QPoint(), tempImg)
painter.end()
self.graphicsPixmapItem = QGraphicsPixmapItem(new_pix)
self.scene.addItem(self.graphicsPixmapItem)
self.label.setStyleSheet(
'color: white; font-weight: bold; background: transparent;')
self.hbox = QHBoxLayout()
self.hbox.addWidget(self.label)
self.scene.addWidget(self.label)
self.setFrameShape(QFrame.NoFrame)
self.setLayout(self.hbox)
self.setScene(self.scene)
def paintEvent(self, event):
painter = QPainter(self)
event.accept()
if not self.isEnabled():
painter.save()
painter.setOpacity(0.2)
painter.drawPixmap(self.fPixmapRect, self.fPixmapNormal,
self.fPixmapRect)
painter.restore()
elif self.isChecked() or self.isDown():
painter.drawPixmap(self.fPixmapRect, self.fPixmapDown,
self.fPixmapRect)
elif self.fIsHovered:
painter.drawPixmap(self.fPixmapRect, self.fPixmapHover,
self.fPixmapRect)
else:
painter.drawPixmap(self.fPixmapRect, self.fPixmapNormal,
self.fPixmapRect)
if not self.fTopText:
return
painter.save()
painter.setPen(self.fTopTextColor)
painter.setBrush(self.fTopTextColor)
painter.setFont(self.fTopTextFont)
painter.drawText(QPointF(10, 16), self.fTopText)
painter.restore()
def paintEvent(self, e):
""" 绘制背景 """
iconPixmap = self.iconPixmap
px, py = self._pixPos_list[0]
painter = QPainter(self)
painter.setRenderHints(QPainter.Antialiasing
| QPainter.SmoothPixmapTransform)
painter.setPen(Qt.NoPen)
if self.isPressed:
if not self.isSelected:
brush = QBrush(QColor(162, 162, 162, 120))
pen = Qt.NoPen
else:
brush = QBrush(QColor(110, 110, 110, 100))
pen = QPen(QColor(255, 255, 255, 160))
pen.setWidthF(1.5)
# 绘制圆环和背景色
self.__drawCircle(painter, pen, brush)
# 更新图标大小和位置
iconPixmap = self.iconPixmap.scaled(self.iconPixmap.width() - 4,
self.iconPixmap.height() - 4,
Qt.KeepAspectRatio,
Qt.SmoothTransformation)
px, py = self._pixPos_list[1]
else:
if self.isSelected:
pen = QPen(QColor(255, 255, 255, 100))
pen.setWidthF(1.4)
self.__drawCircle(painter, pen, QBrush(QColor(0, 0, 0, 60)))
# 鼠标进入时更换图标透明度
elif self.isEnter:
painter.setOpacity(0.5)
# 绘制图标
painter.drawPixmap(px, py, iconPixmap.width(), iconPixmap.height(),
iconPixmap)
def paintEvent(self, event):
_size = self.size() - QSize(2, 2)
if (_size.isEmpty()):
return
origX = (_size.width() - self.mNewSize.width() * self.mScale) / 2 + 0.5
origY = (_size.height() - self.mNewSize.height() * self.mScale) / 2 + 0.5
oldRect = QRect(self.mOffset, self.mOldSize)
painter = QPainter(self)
painter.translate(origX, origY)
painter.scale(self.mScale, self.mScale)
pen = QPen(Qt.black)
pen.setCosmetic(True)
painter.setPen(pen)
painter.drawRect(QRect(QPoint(0, 0), self.mNewSize))
pen.setColor(Qt.white)
painter.setPen(pen)
painter.setBrush(Qt.white)
painter.setOpacity(0.5)
painter.drawRect(oldRect)
pen.setColor(Qt.black)
pen.setStyle(Qt.DashLine)
painter.setOpacity(1.0)
painter.setBrush(Qt.NoBrush)
painter.setPen(pen)
painter.drawRect(oldRect)
painter.end()
def paintEvent(self, event):
a = self.height() / 2 * 0.4
painter = QPainter(self)
painter.setOpacity(self.opacity)
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setRenderHint(QPainter.SmoothPixmapTransform, True)
painter.setPen(Qt.NoPen)
painter.save()
path = QPainterPath()
brush = QBrush(self.color1)
painter.setBrush(brush)
path.moveTo(self.p1)
rect = QRectF(self.p1.x() - a, 0, a * 2, self.height())
path.arcTo(rect, 90, 360)
painter.drawPath(path)
painter.restore()
if self.p1 == self.p2:
return
path = QPainterPath()
brush = QBrush(self.color2)
painter.setBrush(brush)
path.moveTo(self.p2)
rect = QRectF(self.p2.x() - a, 0, a * 2, self.height())
path.arcTo(rect, 90, 360)
painter.drawPath(path)
def paintEvent(self, event):
painter = QPainter()
painter.begin(self)
painter.setOpacity(self.pixmap_opacity)
painter.drawPixmap(0, 0, self.old_pixmap)
painter.end()
def drawOverlayImage(self, rect):
if self.pixmapitem is not None:
W = self.pixmap.width()
H = self.pixmap.height()
self.HIGHLIGHT_RECT_WIDTH = rect.width() * W
self.HIGHLIGHT_RECT_HEIGHT = rect.height() * H
self.HIGHLIGHT_RECT_POSX = rect.left() * W
self.HIGHLIGHT_RECT_POSY = rect.top() * H
self.overlay_image = QImage(self.HIGHLIGHT_RECT_WIDTH,
self.HIGHLIGHT_RECT_HEIGHT,
QImage.Format_ARGB32)
self.overlay_image.fill(self.HIGHLIGHT_COLOR)
if self.overlay_image.width() > 1:
pxmap = self.pixmap.copy()
p = QPainter()
p.begin(pxmap)
p.setOpacity(self.opacity)
p.drawImage(self.HIGHLIGHT_RECT_POSX, self.HIGHLIGHT_RECT_POSY,
self.overlay_image)
p.end()
self.pixmapitem.setPixmap(pxmap)
def __init__(self):
"""
init
"""
super(PseudocodeHighlightAnimation, self).__init__()
# empty init
self.table_pseudocode = QTableWidget(self)
self.table_pseudocode.setColumnCount(1)
self.table_pseudocode.horizontalHeader().hide()
self.table_pseudocode.verticalHeader().hide()
self.table_pseudocode.setFixedWidth(200)
self.table_pseudocode.setColumnWidth(0, 200)
self.table_pseudocode.setShowGrid(False)
# transparent label
self.label_highlight = QLabel('', self)
self.label_highlight_pixmap = QPixmap(200, 25)
self.label_highlight_pixmap.fill(Qt.yellow)
self.label_highlight.setPixmap(self.label_highlight_pixmap)
self.label_highlight_trasparent_pixmap = QPixmap(
self.label_highlight_pixmap.size())
self.label_highlight_trasparent_pixmap.fill(Qt.transparent)
# make it transparent (magic)
painter = QPainter(self.label_highlight_trasparent_pixmap)
painter.setOpacity(0.5)
painter.drawPixmap(QPoint(), self.label_highlight_pixmap)
painter.end()
self.label_highlight.setPixmap(self.label_highlight_trasparent_pixmap)
# actual animation
self.y = 0
self.label_highlight_animation = QPropertyAnimation(
self.label_highlight, b'pos')
self.label_highlight_animation.setDuration(100)
def drawPixmap(self):
painter = QPainter()
painter.begin(self.map)
painter.setOpacity(0.20)
painter.setPen(QColor(0, 0, 0))
painter.setBrush(QColor(0, 0, 0))
for i in range(len(self.df)):
self.drawPoint(painter, 2, self.df.iloc[i, 2], self.df.iloc[i, 3])
def drawBackground(self, painter: QtGui.QPainter,
rect: QtCore.QRectF) -> None:
ret = super(WGraphicsScene, self).drawBackground(painter, rect)
painter.setOpacity(0.2)
# axis = [QtCore.QLineF(self.sceneRect().x(), 0, self.sceneRect().width(), 0),
# QtCore.QLineF(0, self.sceneRect().y(), 0, self.sceneRect().height())]
# painter.drawLines(axis)
return ret
def on_change(self):
new_pix = QPixmap(self.pixmap.size())
new_pix.fill(QtCore.Qt.transparent)
painter = QPainter(new_pix)
painter.setOpacity(self.opacity.value() * 0.01)
painter.drawPixmap(QtCore.QPoint(), self.pixmap)
painter.end()
self.image.setPixmap(new_pix)
def render(self, size):
image = QImage(size, QImage.Format_ARGB32_Premultiplied)
if (self.mIncludeBackgroundColor):
if (self.mMap.backgroundColor().isValid()):
image.fill(self.mMap.backgroundColor())
else:
image.fill(Qt.gray)
else :
image.fill(Qt.transparent)
mapSize = self.mRenderer.mapSize()
margins = self.mRenderer.map().drawMargins()
mapSize.setWidth(mapSize.width() + margins.left() + margins.right())
mapSize.setHeight(mapSize.height() + margins.top() + margins.bottom())
scale = min(size.width() / mapSize.width(), size.height() / mapSize.height())
scaledSize = mapSize * scale
painter = QPainter(image)
# Center the thumbnail in the requested size
painter.translate((size.width() - scaledSize.width()) / 2,
(size.height() - scaledSize.height()) / 2)
# Scale the map and translate it to adjust for its margins
painter.scale(scale, scale)
painter.translate(margins.left() + (size.width() - scaledSize.width()) / 2,
margins.top() + (size.height() - scaledSize.height()) / 2)
if (smoothTransform(scale)):
painter.setRenderHints(QPainter.SmoothPixmapTransform)
self.mRenderer.setPainterScale(scale)
for layer in self.mMap.layers():
if (self.mVisibleLayersOnly and not layer.isVisible()):
continue
painter.setOpacity(layer.opacity())
tileLayer = dynamic_cast(layer, TileLayer)
objGroup = dynamic_cast(layer, ObjectGroup)
imageLayer = dynamic_cast(layer, ImageLayer)
if (tileLayer):
self.mRenderer.drawTileLayer(painter, tileLayer)
elif (objGroup):
objects = objGroup.objects()
if (objGroup.drawOrder() == ObjectGroup.TopDownOrder):
objects = QList(sorted(objects, key=lambda x:x.y(), reverse=True))
for object in objects:
if (object.isVisible()):
if object.rotation() != 0.0:
origin = self.mRenderer.pixelToScreenCoords(object.position())
painter.save()
painter.translate(origin)
painter.rotate(object.rotation())
painter.translate(-origin)
color = MapObjectItem.objectColor(object)
self.mRenderer.drawMapObject(painter, object, color)
if (object.rotation() != 0):
painter.restore()
elif (imageLayer):
self.mRenderer.drawImageLayer(painter, imageLayer)
return image
def _blendTile(self, stack_id, tile_nr):
"""
Blend all of the QImage layers of the patch
specified by (stack_id, tile_nr) into a single QImage.
"""
qimg = None
p = None
for i, (visible, layerOpacity,
layerImageSource) in enumerate(reversed(self._sims)):
image_type = layerImageSource.image_type()
if issubclass(image_type, QGraphicsItem):
with self._cache:
patch = self._cache.layer(stack_id, layerImageSource,
tile_nr)
if patch is not None:
assert isinstance(patch, image_type), \
"This ImageSource is producing a type of image that is not consistent with it's declared image_type()"
# This is a QGraphicsItem, so we don't blend it into the final tile.
# (The ImageScene will just draw it on top of everything.)
# But this is a convenient place to update the opacity/visible state.
if patch.opacity() != layerOpacity or patch.isVisible(
) != visible:
patch.setOpacity(layerOpacity)
patch.setVisible(visible)
patch.setZValue(
i
) # The sims ("stacked image sources") are ordered from
# top-to-bottom (see imagepump.py), but in Qt,
# higher Z-values are shown on top.
# Note that the current loop is iterating in reverse order.
continue
# No need to fetch non-visible image tiles.
if not visible or layerOpacity == 0.0:
continue
with self._cache:
patch = self._cache.layer(stack_id, layerImageSource, tile_nr)
# patch might be a QGraphicsItem instead of QImage,
# in which case it is handled separately,
# not composited into the tile.
if patch is not None:
assert isinstance(patch, QImage), \
"Unknown tile layer type: {}. Expected QImage or QGraphicsItem".format(type(patch))
if qimg is None:
qimg = QImage(self.tiling.imageRects[tile_nr].size(),
QImage.Format_ARGB32_Premultiplied)
qimg.fill(0xffffffff) # Use a hex constant instead.
p = QPainter(qimg)
p.setOpacity(layerOpacity)
p.drawImage(0, 0, patch)
if p is not None:
p.end()
return qimg
def paintTab(self, painter: QPainter, index: int):
if not self.isValidIndex(index):
return
painter.save()
tab = self._tabs[index]
rect = self._tabRect(index)
selected = index == self._currentIndex
enabled = self._enabled and tab.enabled
if selected:
painter.fillRect(rect, FancyToolButtonSelectedColor)
tabText = tab.text
tabTextRect = QRect(rect)
drawIcon = rect.height() > 36
tabIconRect = QRect(rect)
tabTextRect.translate(0, -2 if drawIcon else 1)
boldFont = QFont(painter.font())
boldFont.setPointSizeF(SIDEBAR_FONT_SIZE)
boldFont.setBold(True)
painter.setFont(boldFont)
#painter.setPen(QColor(255, 255, 255, 160) if selected else QColor(0, 0, 0, 110))
textFlags = Qt.AlignCenter | (Qt.AlignBottom if drawIcon else
Qt.AlignVCenter) | Qt.TextWordWrap
fader = tab.fader
if fader > 0 and not selected and enabled:
painter.save()
painter.setOpacity(fader)
painter.fillRect(rect, FancyToolButtonHoverColor)
painter.restore()
if not enabled:
painter.setOpacity(0.7)
if drawIcon:
textHeight = (painter.fontMetrics().boundingRect(
QRect(0, 0, self.width(), self.height()), Qt.TextWordWrap,
tabText).height())
tabIconRect.adjust(0, 4, 0, -textHeight - 4)
iconMode = (QIcon.Active if selected else
QIcon.Normal) if enabled else QIcon.Disabled
iconRect = QRect(0, 0, MODEBAR_ICON_SIZE, MODEBAR_ICON_SIZE)
iconRect.moveCenter(tabIconRect.center())
iconRect = iconRect.intersected(tabIconRect)
drawIconWithShadow(tab.icon, iconRect, painter, iconMode)
if enabled:
penColor = FancyTabWidgetEnabledSelectedTextColor if selected else FancyTabWidgetEnabledUnselectedTextColor
else:
penColor = FancyTabWidgetDisabledSelectedTextColor if selected else FancyTabWidgetDisabledUnselectedTextColor
painter.setPen(penColor)
painter.translate(0, -1)
painter.drawText(tabTextRect, textFlags, tabText)
painter.restore()
def paintEvent(self, event):
QWidget.paintEvent(self, event)
width, height = self.width(), self.height()
polygon = QPolygon()
for i, rate in enumerate(self.loads):
x = width - i * self.pointDistance
y = height - rate * height
if x < self.boxWidth:
break
polygon.append(QPoint(x, y))
painter = QPainter(self)
pen = QPen()
pen.setColor(Qt.darkGreen)
painter.setPen(pen)
painter.setRenderHint(QPainter.Antialiasing, True)
#画网格
painter.setOpacity(0.5)
gridSize = self.pointDistance * 4
deltaX = (width - self.boxWidth) % gridSize + self.boxWidth
deltaY = height % gridSize
for i in range(int(width / gridSize)):
x = deltaX + gridSize * i
painter.drawLine(x, 0, x, height)
for j in range(int(height / gridSize)):
y = j * gridSize + deltaY
painter.drawLine(self.boxWidth, y, width, y)
#画折线
pen.setColor(Qt.darkCyan)
pen.setWidth(2)
painter.setPen(pen)
painter.setOpacity(1)
painter.drawPolyline(polygon)
#画展示框
if len(self.loads) > 0:
rate = self.loads[0]
else:
rate = 1.0
rect1 = QRect(4, height * 0.05, self.boxWidth - 9, height * 0.7)
rect2 = QRect(4, height * 0.8, self.boxWidth - 9, height * 0.2)
centerX = int(rect1.width() / 2) + 1
pen.setWidth(1)
for i in range(rect1.height()):
if i % 4 == 0:
continue
if (rect1.height() - i) / rect1.height() > rate:
pen.setColor(Qt.darkGreen)
else:
pen.setColor(Qt.green)
painter.setPen(pen)
for j in range(rect1.width()):
if centerX - 1 <= j <= centerX + 1:
continue
painter.drawPoint(rect1.x() + j, rect1.y() + i)
pen.setColor(Qt.black)
painter.setPen(pen)
painter.drawText(rect2, Qt.AlignHCenter | Qt.AlignVCenter, str(int(rate * 100)) + "%")
def paintEvent(self, event):
"""Paint cards"""
painter = QPainter()
painter.begin(self)
for n, (card, rect, image) in enumerate(self._cards):
if self._allowed_cards and card not in self._allowed_cards:
painter.setOpacity(0.8)
else:
painter.setOpacity(1)
_draw_image(painter, rect, image, n == self._selected_card_n)
painter.end()
def _blendTile(self, stack_id, tile_nr):
"""
Blend all of the QImage layers of the patch
specified by (stack_id, tile_nr) into a single QImage.
"""
qimg = None
p = None
for i, (visible, layerOpacity, layerImageSource) in enumerate(reversed(self._sims)):
image_type = layerImageSource.image_type()
if issubclass(image_type, QGraphicsItem):
with self._cache:
patch = self._cache.layer(stack_id, layerImageSource, tile_nr)
if patch is not None:
assert isinstance(
patch, image_type
), "This ImageSource is producing a type of image that is not consistent with it's declared image_type()"
# This is a QGraphicsItem, so we don't blend it into the final tile.
# (The ImageScene will just draw it on top of everything.)
# But this is a convenient place to update the opacity/visible state.
if patch.opacity() != layerOpacity or patch.isVisible() != visible:
patch.setOpacity(layerOpacity)
patch.setVisible(visible)
patch.setZValue(i) # The sims ("stacked image sources") are ordered from
# top-to-bottom (see imagepump.py), but in Qt,
# higher Z-values are shown on top.
# Note that the current loop is iterating in reverse order.
continue
# No need to fetch non-visible image tiles.
if not visible or layerOpacity == 0.0:
continue
with self._cache:
patch = self._cache.layer(stack_id, layerImageSource, tile_nr)
# patch might be a QGraphicsItem instead of QImage,
# in which case it is handled separately,
# not composited into the tile.
if patch is not None:
assert isinstance(
patch, QImage
), "Unknown tile layer type: {}. Expected QImage or QGraphicsItem".format(type(patch))
if qimg is None:
qimg = QImage(self.tiling.imageRects[tile_nr].size(), QImage.Format_ARGB32_Premultiplied)
qimg.fill(0xFFFFFFFF) # Use a hex constant instead.
p = QPainter(qimg)
p.setOpacity(layerOpacity)
p.drawImage(0, 0, patch)
if p is not None:
p.end()
return qimg
def _dialog_paintEvent(self, d, event):
QDialog.paintEvent(d, event)
pen = QPen()
pen.setWidth(2)
pen.setColor(QColor(200, 200, 200))
rect = d.rect()
rect = rect.adjusted(0, 0, -1, -1)
painter = QPainter(d)
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setPen(pen)
painter.setOpacity(0.8)
painter.setBrush(QBrush(QColor(Qt.white)))
painter.drawRoundedRect(rect, 15, 15)
def paintEvent(self, event):
painter = QPainter(self)
painter.setBrush(self.brush)
if self.opacity is None or self.parent().vanishing:
painter.setOpacity(self.parent().opacity / 255)
else:
painter.setOpacity(self.opacity / 255)
pen = QPen(QColor(100, 100, 100, 150))
pen.setWidth(10)
painter.setPen(pen)
painter.drawPath(self.path)
painter.setPen(QColor(0, 0, 0))
painter.drawText(self.path.controlPointRect(), Qt.AlignCenter, self.name)
def shaded(pixmap, opacity=0.25):
"""
Constructs a copy of the given pixmap using the specified opacity.
:type pixmap: QPixmap
:type opacity: T <= int | float
:rtype: QPixmap
"""
o = QPixmap(pixmap.size())
o.fill(Qt.transparent)
p = QPainter(o)
p.setOpacity(clamp(opacity, 0.0, 1.0))
p.drawPixmap(0, 0, pixmap)
p.end()
return o
def paint(self, painter: QPainter) -> None:
self.paint_text_items(painter)
self.paint_thumbnail(painter)
if self.hovering and self.animation_timer is None:
if not self.fileinfo.isdir() and not self.fileinfo.is_archive():
painter.setCompositionMode(QPainter.CompositionMode_Overlay)
painter.setOpacity(0.75)
self.paint_thumbnail(painter)
painter.setOpacity(1.0)
painter.setCompositionMode(QPainter.CompositionMode_SourceOver)
if self.level_of_detail > 1:
self.paint_metadata(painter)
self.paint_overlay(painter)
def paint_metadata(self, painter: QPainter) -> None:
font = self.style.font
fm = self.style.fm
painter.setFont(font)
if self.new:
painter.drawPixmap(QRect(2, 2, 24, 24),
self.style.shared_pixmaps.new)
if "type" in self.fileinfo.metadata() and self.fileinfo.metadata()["type"] == "error":
painter.drawPixmap(QRect(2, 2, 24, 24),
self.style.shared_pixmaps.error)
top_left_text, top_right_text, bottom_left_text, bottom_right = self.make_text()
if top_left_text:
w = fm.width(top_left_text)
painter.setPen(Qt.NoPen)
painter.setBrush(QColor(255, 255, 255, 160))
painter.drawRect(0, 0, w + 4, 16)
painter.setPen(QColor(0, 0, 0))
painter.drawText(2, 12, top_left_text)
if top_right_text:
w = fm.width(top_right_text)
painter.setPen(Qt.NoPen)
painter.setBrush(QColor(255, 255, 255, 160))
painter.drawRect(self.thumbnail_rect.width() - w - 4, 0, w + 4, 16)
painter.setPen(QColor(0, 0, 0))
painter.drawText(self.thumbnail_rect.width() - w - 2, 12, top_right_text)
if bottom_left_text:
w = fm.width(bottom_left_text)
painter.setPen(Qt.NoPen)
painter.setBrush(QColor(255, 255, 255, 160))
painter.drawRect(0, self.thumbnail_rect.height() - 16, w + 4, 16)
painter.setPen(QColor(0, 0, 0))
painter.drawText(2, self.thumbnail_rect.height() - 4, bottom_left_text)
if self.fileinfo.is_video():
painter.setOpacity(0.5)
# painter.setCompositionMode(QPainter.CompositionMode_Plus)
painter.drawPixmap(QRect(self.thumbnail_rect.width() - 24 - 2,
self.thumbnail_rect.height() - 24 - 2,
24, 24),
self.style.shared_pixmaps.video)
painter.setOpacity(1.0)
elif self.fileinfo.is_image():
painter.setOpacity(0.5)
# painter.setCompositionMode(QPainter.CompositionMode_Plus)
painter.drawPixmap(QRect(self.thumbnail_rect.width() - 24 - 2,
self.thumbnail_rect.height() - 24 - 2,
24, 24),
self.style.shared_pixmaps.image)
painter.setOpacity(1.0)
def paintEvent(self, event):
QWidget.paintEvent(self, event)
pen = QPen()
pen.setWidth(2)
pen.setColor(QColor(200, 200, 200))
rect = self.rect()
rect = rect.adjusted(0, 0, -1, -1)
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setPen(pen)
painter.setOpacity(0.5)
painter.setBrush(QBrush(QColor(Qt.white)))
painter.drawRoundedRect(rect, 15, 15)
painter.setOpacity(1)
pen.setColor(Qt.black)
painter.setPen(pen)
text = self.name + "\n" + self.description
painter.drawText(self.rect(), Qt.AlignHCenter | Qt.AlignVCenter, text)
def paintEvent(self, event):
QFrame.paintEvent(self, event)
factorForWidth = self.width() / 40
factorForHeight = self.height() / 30
row = 1
column = 1
painter = QPainter(self)
painter.setOpacity(0.9)
pen = QPen()
pen.setColor(Qt.white)
painter.setPen(pen)
while factorForWidth * column < self.width():
painter.drawLine(factorForWidth * column, 0, factorForWidth * column, self.height())
column += 1
while factorForHeight * row < self.height():
painter.drawLine(0, factorForHeight * row, self.width(), factorForHeight * row)
row += 1
def paintEvent(self, event):
"""Paint transparent background,animated pattern,background text."""
painter, font = QPainter(self), self.font()
painter.fillRect(event.rect(), Qt.transparent) # fill transparent rect
painter.setPen(QPen(QColor(randint(9, 255), randint(9, 255), 255)))
painter.rotate(30) # Rotate painter ~30 Degree
font.setBold(True) # Set painter Font for text
font.setPixelSize(100)
painter.setFont(font)
painter.drawText(99, 99, "Python Qt") # draw the background text
painter.rotate(-30) # Rotate -30 the QPen back
painter.setPen(Qt.NoPen) # set the pen to no pen
painter.setBrush(QColor("black")) # Background Color
painter.setOpacity(0.9) # Background Opacity
painter.drawRoundedRect(self.rect(), 25, 25) # Back Rounded Borders
for i in range(2048): # animated random dots background pattern
x = randint(10, self.size().width() - 10)
y = randint(10, self.size().height() - 10)
painter.setPen(QPen(QColor(randint(9, 255), randint(9, 255), 255)))
painter.drawPoint(x, y)
QMainWindow.paintEvent(self, event)
def render(self, painter: QPainter) -> None:
if self._item_style == FileItemStyle.SMALLICON:
self.paint_smallicon_view(painter)
elif self._item_style == FileItemStyle.DETAIL:
self.paint_detail_view(painter)
else:
self.paint(painter)
if self.is_selected:
painter.save()
painter.setCompositionMode(QPainter.CompositionMode_SourceOver)
painter.setOpacity(0.5)
painter.fillRect(self.tile_rect, QColor(127, 192, 255))
painter.setCompositionMode(QPainter.CompositionMode_SourceOver)
painter.setOpacity(1.0)
painter.setPen(QColor(96, 127, 255))
painter.setBrush(Qt.NoBrush)
painter.drawRect(self.tile_rect)
painter.restore()
if self.is_cursor:
painter.setOpacity(1.0)
painter.setPen(QColor(0, 0, 0))
painter.setBrush(QColor(255, 255, 255, 96))
painter.drawRect(self.tile_rect)
def paint_overlay(self, painter: QPainter) -> None:
if self.fileinfo.have_access() is False:
painter.setOpacity(0.5)
m = int(self.thumbnail_rect.width() * 0.125)
painter.drawPixmap(self.thumbnail_rect.marginsRemoved(QMargins(m, m, m, m)),
self.style.shared_pixmaps.locked)
painter.setOpacity(1.0)
thumbnail = self.thumbnail
if thumbnail.status == ThumbnailStatus.LOADING or thumbnail.status == ThumbnailStatus.INITIAL:
painter.setOpacity(0.5)
painter.drawPixmap(QRect(self.thumbnail_rect.width() - 32,
2,
32, 32),
self.style.shared_pixmaps.loading)
painter.setOpacity(1.0)
elif thumbnail.status == ThumbnailStatus.THUMBNAIL_ERROR:
self.paint_icon(painter, self.style.shared_icons.image_error)
def render(self, mapFileName, imageFileName):
map = None
renderer = None
reader = MapReader()
map = reader.readMap(mapFileName)
if (not map):
qWarning("Error while reading " + mapFileName + ":\n" + reader.errorString())
return 1
x = map.orientation()
if x==Map.Orientation.Isometric:
renderer = IsometricRenderer(map)
elif x==Map.Orientation.Staggered:
renderer = StaggeredRenderer(map)
elif x==Map.Orientation.Hexagonal:
renderer = HexagonalRenderer(map)
else:
renderer = OrthogonalRenderer(map)
if (self.mTileSize > 0):
xScale = self.mTileSize / map.tileWidth()
yScale = self.mTileSize / map.tileHeight()
else:
xScale = yScale = self.mScale
mapSize = renderer.mapSize()
margins = map.computeLayerOffsetMargins()
mapSize.setWidth(mapSize.width() + margins.left() + margins.right())
mapSize.setHeight(mapSize.height() + margins.top() + margins.bottom())
mapSize.setWidth(mapSize.width()*xScale)
mapSize.setHeight(mapSize.height()*yScale)
image = QImage(mapSize, QImage.Format_ARGB32)
image.fill(Qt.transparent)
painter = QPainter(image)
if (xScale != 1.0 or yScale != 1.0):
if (self.mUseAntiAliasing):
painter.setRenderHints(QPainter.SmoothPixmapTransform |
QPainter.Antialiasing)
painter.setTransform(QTransform.fromScale(xScale, yScale))
painter.translate(margins.left(), margins.top())
# Perform a similar rendering than found in exportasimagedialog.py
for layer in map.layers():
if (not self.shouldDrawLayer(layer)):
continue
painter.setOpacity(layer.opacity())
painter.translate(layer.offset())
tileLayer = layer
imageLayer = layer
tp = type(layer)
if tp == TileLayer:
renderer.drawTileLayer(painter, tileLayer)
elif tp == ImageLayer:
renderer.drawImageLayer(painter, imageLayer)
painter.translate(-layer.offset())
painter.end()
# Save image
imageWriter = QImageWriter(imageFileName)
if (not imageWriter.write(image)):
qWarning("Error while writing " + imageFileName + ": " + imageWriter.errorString())
return 1
return 0
def renderMapToImage(self):
if (not self.mMapDocument):
self.mMapImage = QImage()
return
renderer = self.mMapDocument.renderer()
r = self.contentsRect()
mapSize = renderer.mapSize()
if (mapSize.isEmpty()):
self.mMapImage = QImage()
return
margins = self.mMapDocument.map().computeLayerOffsetMargins()
mapSize.setWidth(mapSize.width() + margins.left() + margins.right())
mapSize.setHeight(mapSize.height() + margins.top() + margins.bottom())
# Determine the largest possible scale
scale = min( r.width() / mapSize.width(), r.height() / mapSize.height())
# Allocate a new image when the size changed
imageSize = mapSize * scale
if (self.mMapImage.size() != imageSize):
self.mMapImage = QImage(imageSize, QImage.Format_ARGB32_Premultiplied)
self.updateImageRect()
if (imageSize.isEmpty()):
return
drawObjects = bool(self.mRenderFlags & MiniMapRenderFlag.DrawObjects)
drawTiles = bool(self.mRenderFlags & MiniMapRenderFlag.DrawTiles)
drawImages = bool(self.mRenderFlags & MiniMapRenderFlag.DrawImages)
drawTileGrid = bool(self.mRenderFlags & MiniMapRenderFlag.DrawGrid)
visibleLayersOnly = bool(self.mRenderFlags & MiniMapRenderFlag.IgnoreInvisibleLayer)
# Remember the current render flags
renderFlags = renderer.flags()
renderer.setFlag(RenderFlag.ShowTileObjectOutlines, False)
self.mMapImage.fill(Qt.transparent)
painter = QPainter(self.mMapImage)
painter.setRenderHints(QPainter.SmoothPixmapTransform)
painter.setTransform(QTransform.fromScale(scale, scale))
painter.translate(margins.left(), margins.top())
renderer.setPainterScale(scale)
for layer in self.mMapDocument.map().layers():
if (visibleLayersOnly and not layer.isVisible()):
continue
painter.setOpacity(layer.opacity())
painter.translate(layer.offset())
tileLayer = layer
objGroup = layer
imageLayer = layer
tp = type(layer)
if (tp==TileLayer and drawTiles):
renderer.drawTileLayer(painter, tileLayer)
elif (tp==ObjectGroup and drawObjects):
objects = objGroup.objects()
if (objGroup.drawOrder() == ObjectGroup.DrawOrder.TopDownOrder):
objects = QList(sorted(objects, key=lambda x:x.y(), reverse=True))
for object in objects:
if (object.isVisible()):
if (object.rotation() != 0.0):
origin = renderer.pixelToScreenCoords_(object.position())
painter.save()
painter.translate(origin)
painter.rotate(object.rotation())
painter.translate(-origin)
color = MapObjectItem.objectColor(object)
renderer.drawMapObject(painter, object, color)
if (object.rotation() != 0.0):
painter.restore()
elif (tp==ImageLayer and drawImages):
renderer.drawImageLayer(painter, imageLayer)
painter.translate(-layer.offset())
if (drawTileGrid):
prefs = preferences.Preferences.instance()
renderer.drawGrid(painter, QRectF(QPointF(), renderer.mapSize()),
prefs.gridColor())
painter.end()
renderer.setFlags(renderFlags)
def paint_tiny_icon(self, painter: QPainter, icon: QIcon) -> None:
painter.setOpacity(0.5)
icon.paint(painter, QRect(self.tile_rect.width() - 48, 0, 48, 48))
def paintEvent(self, event):
painter = QPainter()
painter.begin(self)
painter.setOpacity(self.pixmap_opacity)
painter.drawPixmap(0, 0, self.old_pixmap)
painter.end()
def paintEvent(self, e):
if not self.visibleRegion().isEmpty():
# Stretch factor
mul = (self.height() - 4)
mul /= (self.DB_MAX - self.DB_MIN)
peaks = []
for n, peak in enumerate(self.peaks):
if peak > self.DB_CLIP:
self.clipping[n] = True
if peak < self.DB_MIN:
peak = self.DB_MIN
elif peak > self.DB_MAX:
peak = self.DB_MAX
peaks.append(round((peak - self.DB_MIN) * mul))
rmss = []
for n, rms in enumerate(self.rmss):
if rms < self.DB_MIN:
rms = self.DB_MIN
elif rms > self.DB_MAX:
rms = self.DB_MAX
rmss.append(round((rms - self.DB_MIN) * mul))
decPeaks = []
for decPeak in self.decPeak:
if decPeak < self.DB_MIN:
decPeak = self.DB_MIN
elif decPeak > self.DB_MAX:
decPeak = self.DB_MAX
decPeaks.append(round((decPeak - self.DB_MIN) * mul))
qp = QPainter()
qp.begin(self)
qp.setBrush(QColor(0, 0, 0, 0))
xpos = 0
xdim = self.width() / len(peaks)
for n in range(len(peaks)):
peak = peaks[n]
rms = rmss[n]
decPeak = decPeaks[n]
# Maximum "peak-rect" size
maxRect = QtCore.QRect(xpos,
self.height() - 2,
xdim - 2,
2 - self.height())
# Set QLinearGradient start and final-stop position
self.grad.setStart(maxRect.topLeft())
self.grad.setFinalStop(maxRect.bottomRight())
# Draw peak (audio peak in dB)
rect = QtCore.QRect(xpos, self.height() - 2, xdim - 2, -peak)
qp.setOpacity(0.6)
qp.fillRect(rect, self.grad)
qp.setOpacity(1.0)
# Draw rms (in db)
rect = QtCore.QRect(xpos, self.height() - 2, xdim - 2, -rms)
qp.fillRect(rect, self.grad)
# Draw decay peak
decRect = QtCore.QRect(xpos, (self.height() - 3) - decPeak,
xdim - 2, 2)
qp.fillRect(decRect, self.grad)
# Draw Borders
if self.clipping.get(n, False):
qp.setPen(QColor(200, 0, 0))
else:
qp.setPen(QColor(100, 100, 100))
qp.drawRect(maxRect)
xpos += xdim
qp.end()
def paintEvent(self, event):
"""Overloaded paintEvent to set opacity and pic."""
painter = QPainter(self)
painter.setOpacity(self.opacity)
if self.old_pic:
painter.drawPixmap(0, 0, self.old_pic)
