def createThemePreview(theme, screenRect, size=QSize(200, 120)):
if type(theme) == str and os.path.exists(theme):
# Theme is the path to an ini file
themeDatas = loadThemeDatas(theme)
else:
themeDatas = theme
pixmap = generateTheme(themeDatas, screenRect)
addThemePreviewText(pixmap, themeDatas, screenRect)
px = QPixmap(pixmap).scaled(size, Qt.KeepAspectRatio)
w = px.width() / 10
h = px.height() / 10
r = themeTextRect(themeDatas, screenRect)
painter = QPainter(px)
painter.drawPixmap(QRect(w, h, w * 4, h * 5), pixmap,
QRect(r.topLeft() - QPoint(w / 3, h / 3), QSize(w * 4, h * 5)))
painter.setPen(Qt.white)
painter.drawRect(QRect(w, h, w * 4, h * 5))
painter.end()
return px
def getCombinedIcon(keys, cache=pixCache):
"""
Module function to retrieve a symbolic link icon.
@param keys list of names of icons (string)
@param cache reference to the pixmap cache object (PixmapCache)
@return the requested icon (QIcon)
"""
height = width = 0
pixmaps = []
for key in keys:
pix = cache.getPixmap(key)
if not pix.isNull():
height = max(height, pix.height())
width = max(width, pix.width())
pixmaps.append(pix)
if pixmaps:
pix = QPixmap(len(pixmaps) * width, height)
pix.fill(Qt.transparent)
painter = QPainter(pix)
x = 0
for pixmap in pixmaps:
painter.drawPixmap(x, 0, pixmap.scaled(QSize(width, height)))
x += width
painter.end()
icon = QIcon(pix)
else:
icon = QIcon()
return icon
def paintEvent(self, event):
pix = self.pixmap_hover if self.underMouse() else self.pixmap
if self.isDown():
pix = self.pixmap_pressed
painter = QPainter(self)
painter.drawPixmap(event.rect(), pix)
def paintEvent(self, event):
# Check whether this orb is enhanced
if type(self.parent) == Board:
enh = self.parent.enhanced[self.position]
else:
enh = False
painter = QPainter(self)
painter.drawPixmap(event.rect().adjusted(2,2,-2,-2), self.pixmap())
w = event.rect().width()
if enh:
path = QPainterPath()
pen = QPen()
pen.setWidth(1);
pen.setBrush(Qt.white)
brush = QBrush(Qt.yellow)
font = QFont()
font.setPointSize(20)
font.setWeight(QFont.Black)
path.addText(event.rect().x()+w-15,event.rect().y()+w-5,font,'+')
painter.setPen(pen)
painter.setBrush(brush)
painter.setFont(font)
painter.drawPath(path)
def paintEvent(self, event):
painter = QPainter(self)
if self.pixmap:
size = self.pixmap.size()
aspect = float(size.width()) / size.height()
if aspect > 1:
# Image is wider than it is tall - centre vertically
left = 0
width = self.width()
height = self.height() / aspect
top = (self.height() - height) / 2
else:
# Image is taller than it is wide - centre horizontally
top = 0
height = self.height()
width = self.width() * aspect
left = (self.width() - width) / 2
painter.drawPixmap(QRect(left, top, width, height), self.pixmap)
if self.focus:
# self.focus contains coords between 0 and 1 - translate these
# to pixels
pixels = QRectF(left + self.focus.left() * width,
top + self.focus.top() * height,
self.focus.width() * width,
self.focus.height() * height)
# Outer box in white
painter.setPen(QPen(Qt.white, 1, Qt.SolidLine))
painter.drawRect(pixels)
# Inner box in black
painter.setPen(QPen(Qt.black, 1, Qt.SolidLine))
painter.drawRect(pixels.adjusted(1, 1, -1, -1))
def paintEvent(self, event):
painter = QPainter(self)
icon = self.icon_pressed if self.isDown() else self.icon
if icon is not None:
x = (self.width() - icon.width()) / 2
y = (self.height() - icon.height()) / 2
painter.drawPixmap(x, y, icon)
else:
width = self.width()
height = self.height()
padding = width / 5
radius = width - 2*padding
palette = self.palette()
# Mid is darker than Dark. Go figure... -Dan
bg_color = palette.color(QPalette.Mid) if self.isDown() else palette.color(QPalette.Dark)
fg_color = palette.color(QPalette.Window) # or QPalette.Base for white
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setBrush(bg_color)
painter.setPen(bg_color)
painter.drawEllipse(padding, padding, radius, radius)
padding = padding * 2
painter.setPen(fg_color)
painter.drawLine(padding, padding, width-padding, height-padding)
painter.drawLine(padding, height-padding, width-padding, padding)
def paintEvent(self,event=None):
painter = QPainter(self)
pixmap=QPixmap(":/images/wheelfinal.png")
#painter.begin(self)
#painter.drawPixmap(QtCore.QRect(self.left, self.top, self.width, self.height), self.pixmap)
painter.drawPixmap(self.rect(), pixmap)
self.resize(pixmap.width(),pixmap.height())
pen = QPen(Qt.red, 3)
painter.setPen(pen)
painter.drawArc (self.disc_center-int(self.distance_from_center(self.points[0])) ,
self.disc_center - int(self.distance_from_center (self.points[0])) ,
2*int(self.distance_from_center(self.points[0])) ,
2*int(self.distance_from_center(self.points[0])) ,
int(16*self.hue_min) ,
int(16*(self.hue_max-self.hue_min)))#arc joining point 0 and point 1
painter.drawLine(int(self.points[0][0]),int(self.points[0][1]),int(self.points[3][0]),int(self.points[3][1]))#line joining point 0 and point 3
painter.drawArc(self.disc_center-int(self.distance_from_center(self.points[2])) ,
self.disc_center - int(self.distance_from_center (self.points[2])) ,
2*int(self.distance_from_center(self.points[2])) ,
2*int(self.distance_from_center(self.points[2])) ,
int(16*self.hue_min) ,
int(16*(self.hue_max-self.hue_min)))#arc joining point 2 and 3
painter.drawLine(int(self.points[1][0]),int(self.points[1][1]),int(self.points[2][0]),int(self.points[2][1]))#line joining point 1 and 2
self.update()
def paintEvent(self, event):
painter = QPainter(self)
event.accept()
self._loadPixmapNow()
painter.drawPixmap(self.fPixmapRect, self.fPixmap, self.fPixmapRect)
def paintEvent(self, event):
currentFrame = self.movie.currentPixmap()
frameRect = currentFrame.rect()
frameRect.moveCenter(self.rect().center())
if frameRect.intersects(event.rect()):
painter = QPainter(self)
painter.drawPixmap(frameRect.left(), frameRect.top(), currentFrame)
def paintEvent(self, event):
"""Qt method override to paint a custom image on the Widget."""
super(FigureCanvas, self).paintEvent(event)
qp = QPainter()
qp.begin(self)
# Prepare paint rect :
fw = self.frameWidth()
rect = QRect(0 + fw, 0 + fw,
self.size().width() - 2 * fw,
self.size().height() - 2 * fw)
# Check/update image buffer :
qpix2print = None
for qpix in self.qpix_buff:
if qpix.size().width() == rect.width():
qpix2print = qpix
break
if qpix2print is None:
qpix2print = self.img.scaledToWidth(
rect.width(), mode=Qt.SmoothTransformation)
self.qpix_buff.append(qpix2print)
# Draw pixmap :
# qp.setRenderHint(QPainter.Antialiasing, True)
qp.drawPixmap(rect, qpix2print)
qp.end()
def paintEvent(self, event):
if not hasattr(self, "_currentImage"):
return super(Lolita, self).paintEvent(event)
if isinstance(self._currentImage, QMovie): # 动画
return super(Lolita, self).paintEvent(event)
painter = QPainter(self)
painter.drawPixmap(0, 0, self._currentImage)
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,
"PyQt by\nRiverbank Computing")
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):
"""QWidget.paintEvent() implementation
Draw markers
"""
painter = QPainter(self)
painter.fillRect(event.rect(), self.palette().color(QPalette.Window))
block = self._qpart.firstVisibleBlock()
blockBoundingGeometry = self._qpart.blockBoundingGeometry(block).translated(self._qpart.contentOffset())
top = blockBoundingGeometry.top()
bottom = top + blockBoundingGeometry.height()
for block in qutepart.iterateBlocksFrom(block):
height = self._qpart.blockBoundingGeometry(block).height()
if top > event.rect().bottom():
break
if block.isVisible() and \
bottom >= event.rect().top():
if block.blockNumber() in self._qpart.lintMarks:
msgType, msgText = self._qpart.lintMarks[block.blockNumber()]
pixMap = self._lintPixmaps[msgType]
yPos = top + ((height - pixMap.height()) / 2) # centered
painter.drawPixmap(0, yPos, pixMap)
if self.isBlockMarked(block):
yPos = top + ((height - self._bookmarkPixmap.height()) / 2) # centered
painter.drawPixmap(0, yPos, self._bookmarkPixmap)
top += height
def __grabRegion(self):
"""
Private method to grab the selected region (i.e. do the snapshot).
"""
pol = QPolygon(self.__selection)
if not pol.isEmpty():
self.__grabbing = True
xOffset = self.__pixmap.rect().x() - pol.boundingRect().x()
yOffset = self.__pixmap.rect().y() - pol.boundingRect().y()
translatedPol = pol.translated(xOffset, yOffset)
pixmap2 = QPixmap(pol.boundingRect().size())
pixmap2.fill(Qt.transparent)
pt = QPainter()
pt.begin(pixmap2)
if pt.paintEngine().hasFeature(QPaintEngine.PorterDuff):
pt.setRenderHints(
QPainter.Antialiasing |
QPainter.HighQualityAntialiasing |
QPainter.SmoothPixmapTransform,
True)
pt.setBrush(Qt.black)
pt.setPen(QPen(QBrush(Qt.black), 0.5))
pt.drawPolygon(translatedPol)
pt.setCompositionMode(QPainter.CompositionMode_SourceIn)
else:
pt.setClipRegion(QRegion(translatedPol))
pt.setCompositionMode(QPainter.CompositionMode_Source)
pt.drawPixmap(pixmap2.rect(), self.__pixmap, pol.boundingRect())
pt.end()
self.grabbed.emit(pixmap2)
def paint_thumbnail(self, painter: QPainter) -> None:
thumbnail = self.thumbnail
if thumbnail.status == ThumbnailStatus.INITIAL:
self.paint_icon(painter, self.icon)
elif thumbnail.status == ThumbnailStatus.LOADING:
self.paint_icon(painter, self.icon)
elif thumbnail.status == ThumbnailStatus.THUMBNAIL_UNAVAILABLE:
self.paint_icon(painter, self.icon)
elif thumbnail.status == ThumbnailStatus.THUMBNAIL_ERROR:
self.paint_icon(painter, self.icon)
elif thumbnail.status == ThumbnailStatus.THUMBNAIL_READY:
pixmap = thumbnail.get_pixmap()
assert pixmap is not None
if not self.crop_thumbnails:
rect = make_scaled_rect(pixmap.width(), pixmap.height(),
self.thumbnail_rect.width(), self.thumbnail_rect.width())
painter.drawPixmap(rect, pixmap)
else:
srcrect = make_cropped_rect(pixmap.width(), pixmap.height(),
self.thumbnail_rect.width(), self.thumbnail_rect.width())
painter.drawPixmap(self.thumbnail_rect, pixmap, srcrect)
if (self.fileinfo.is_archive() or self.fileinfo.isdir()) and not self.hovering:
self.paint_icon(painter, self.icon)
def paintEvent(self, event):
# the original code tried to be clever about painting an caching. it
# only painted the screen if it was dirty. for the redraws when the
# dirty flag was not set it relyed on the OS not the clear the cash.
# but this does not work (at least on macOS). instead of caching in
# the OS cache the screen in a pixmap to have full control over it
if self._pixmap == None or self.size() != self._pixmap.size():
self._pixmap = QPixmap(self.size())
self._dirty = True
if self._dirty:
self._dirty = False
pixmap_painter = QPainter(self._pixmap)
pixmap_painter.setFont(self.font())
self._paint_screen(pixmap_painter)
painter = QPainter(self)
painter.drawPixmap(0, 0, self._pixmap)
# We don't use the blinky cursor for now
# if self._cursor_rect is not None and self._selection is None:
# self._paint_cursor(painter)
if self._selection:
self._paint_selection(painter)
self._dirty = True
def paintEvent(self, event):
super(BackgroundFrame, self).paintEvent(event)
painter = QPainter(self)
if self.backgroundColor:
painter.fillRect(self.rect(), QColor(self.backgroundColor))
if self.scaled_pixmap is not None:
painter.drawPixmap(self.image_position, self.scaled_pixmap)
painter.end()
def paintEvent(self, QPaintEvent):
pm = QPixmap("gimp_gimp.png")
qp = QPainter()
qp.begin(self)
qp.setPen(Qt.red)
for e in self.prost:
qp.drawPixmap(e[0], e[1], 1, 1, pm)
qp.end()
def paintEvent(self,event): super().paintEvent(event) painter = QPainter(self) painter.fillRect(4,4,frameWidth,frameHeight,self.backBrush) painter.drawPixmap(4+(frameWidth-self.pixMap.width())//2,4+(frameHeight-self.pixMap.height())//2,self.pixMap) if self.isChecked(): painter.setPen(self.checkedPen) painter.drawRect(3,3,self.width()-6,self.height()-6)
def paintEvent(self,event): pp = QPainter( self.pix) # 根据鼠标指针前后两个位置绘制直线 pp.drawLine( self.lastPoint, self.endPoint) # 让前一个坐标值等于后一个坐标值， # 这样就能实现画出连续的线 self.lastPoint = self.endPoint painter = QPainter(self) painter.drawPixmap(0, 0, self.pix)
def paintEvent(self, e):
p = QPainter()
p.begin(self)
# self.drawFrame(p) # Frame direkt malen (ohne paint_image)
p.drawPixmap(0, 0, self.paint_image)
p.end()
def print_(self):
dialog = QPrintDialog(self.printer, self)
if dialog.exec_():
painter = QPainter(self.printer)
rect = painter.viewport()
size = self.imageLabel.pixmap().size()
size.scale(rect.size(), Qt.KeepAspectRatio)
painter.setViewport(rect.x(), rect.y(), size.width(), size.height())
painter.setWindow(self.imageLabel.pixmap().rect())
painter.drawPixmap(0, 0, self.imageLabel.pixmap())
def paintEvent(self,event): painter = QPainter(self) x = self.lastPoint.x() y = self.lastPoint.y() w = self.endPoint.x() - x h = self.endPoint.y() - y pp = QPainter(self.pix) pp.drawRect(x, y, w, h) painter.drawPixmap(0, 0, self.pix)
def paintEvent(self, event):
if self.tower.level == 2:
pix = self.upgraded
else:
pix = self.pixmap
painter = QPainter()
painter.begin(self)
painter.drawPixmap(event.rect(), pix)
def paintEvent(self, event):
painter = QPainter(self)
self.painter = painter
painter.drawPixmap(QPoint(0, 0), self.pixmap)
for eye in self.eyes:
eye.render(self)
self.painter = None
def paintEvent(self, event):
painter = QPainter(self)
bg_color = darker(self.theme_manager.current_theme.background, a=200)
if self.player_pixmap is not None:
pixmap = self.player_pixmap.scaled(
self.size(),
Qt.KeepAspectRatioByExpanding,
Qt.SmoothTransformation)
painter.drawPixmap(0, 0, pixmap)
painter.fillRect(self.rect(), bg_color)
def createColorToolButtonIcon(self, imageFile, color):
pixmap = QPixmap(50, 80)
pixmap.fill(Qt.transparent)
painter = QPainter(pixmap)
image = QPixmap(imageFile)
target = QRect(0, 0, 50, 60)
source = QRect(0, 0, 42, 42)
painter.fillRect(QRect(0, 60, 50, 80), color)
painter.drawPixmap(target, image, source)
painter.end()
return QIcon(pixmap)
def paintEvent(self, paint_event):
"""
:param paint_event:
:return:
"""
painter = QPainter(self)
if self.image:
# scale image to fit on widget
scaled = self.image.scaled(self.width(), self.height(), Qt.KeepAspectRatio, Qt.SmoothTransformation)
d_x = (self.width() - scaled.width()) / 2
d_y = (self.height() - scaled.height()) / 2
painter.drawPixmap(d_x, d_y, scaled)
def print_img(self):
dialog = QPrintDialog(self.printer, self)
if dialog.exec_():
painter = QPainter(self.printer)
rect = painter.viewport()
if self.pixmap.width() > self.pixmap.height():
self.pixmap = self.pixmap.transformed(QTransform().rotate(90))
size = self.pixmap.size()
size.scale(rect.size(), Qt.KeepAspectRatio)
painter.setViewport(rect.x(), rect.y(), size.width(), size.height())
painter.setWindow(self.pixmap.rect())
painter.drawPixmap(0, 0, self.pixmap)
def paintEvent(self, event):
#get the "paint" region"
#paint is the body image of the widget
#it is called again and again (who calls it?)
#This just put the pixmap on the "paint"
#perhaps the thread calls it.
#It is called even when the image is just scrolled..... Redundant.
#No it is required. Otherwise image disappears during scrolling.
painter = QPainter(self)
#Always resize. Is it ok here? NO
#self.resize(self.pixmap.size())
painter.drawPixmap(QPoint(), self.pixmap)
def paint(self, painter: QtGui.QPainter, option: 'QStyleOptionViewItem',
index: QtCore.QModelIndex) -> None:
"""
Paints the message on the screen
:param painter: Controls actual painting
:param option: Options for painting
:param index: Index of item
:return:
"""
if not index.isValid():
return
painter.save(
) # Save current state, before altering for custom painting
painter.setRenderHints(QPainter.Antialiasing)
context = index.model().chat_message_contexts()[index.row()]
message_text = index.data(Qt.DisplayRole)
profile_pix: QPixmap = index.data(Qt.DecorationRole)
# Determine message rect
message_font = QApplication.font()
message_fm = QFontMetrics(message_font)
if context.is_sender:
# Paint text with 10 pixel padding
message_rect = message_fm.boundingRect(
option.rect.left(),
option.rect.top() + MessageItemDelegate.profile_padding / 2,
option.rect.width() - MessageItemDelegate.total_pfp_width, 0,
Qt.AlignRight | Qt.AlignTop | Qt.TextWordWrap, message_text)
# Draw bubble rect
bubble_rect = QRect(
message_rect.left() - MessageItemDelegate.profile_padding / 2,
message_rect.top() - MessageItemDelegate.profile_padding / 2,
message_rect.width() + MessageItemDelegate.profile_padding,
message_rect.height() + MessageItemDelegate.profile_padding)
blue = QColor(35, 57, 93)
painter.setBrush(blue)
painter.setPen(blue)
painter.drawRoundedRect(bubble_rect, 5, 5)
painter.setPen(Qt.white)
painter.setFont(message_font)
painter.drawText(message_rect,
Qt.AlignLeft | Qt.AlignTop | Qt.TextWordWrap,
message_text)
# Paint icon
profile_rect = QRect(
message_rect.right() + MessageItemDelegate.profile_padding,
option.rect.top(), MessageItemDelegate.icon_radius,
MessageItemDelegate.icon_radius)
painter.drawPixmap(profile_rect, profile_pix)
else:
# Paint icon
profile_rect = QRect(option.rect.left(), option.rect.top(),
MessageItemDelegate.icon_radius,
MessageItemDelegate.icon_radius)
painter.drawPixmap(profile_rect, profile_pix)
# Paint text with 10 pixel padding
message_rect = message_fm.boundingRect(
profile_rect.right() + MessageItemDelegate.profile_padding,
option.rect.top() + MessageItemDelegate.profile_padding / 2,
option.rect.width() - MessageItemDelegate.total_pfp_width, 0,
Qt.AlignLeft | Qt.AlignTop | Qt.TextWordWrap, message_text)
# Draw bubble rect
bubble_rect = QRect(
message_rect.left() - MessageItemDelegate.profile_padding / 2,
message_rect.top() - MessageItemDelegate.profile_padding / 2,
message_rect.width() + MessageItemDelegate.profile_padding,
message_rect.height() + MessageItemDelegate.profile_padding)
gray = QColor(105, 105, 105)
painter.setBrush(gray)
painter.setPen(gray)
painter.drawRoundedRect(bubble_rect, 5, 5)
painter.setPen(Qt.white)
painter.setFont(message_font)
painter.drawText(message_rect,
Qt.AlignLeft | Qt.AlignTop | Qt.TextWordWrap,
message_text)
painter.restore() # Reset to state before changes
def paintEvent(self, paint_event):
painter = QPainter(self)
painter.drawPixmap(self.rect(), self.im)
self.update()
def paintEvent(self, event):
painter = QPainter(self)
painter.drawPixmap(
QRect(0, 0, self.pixmap.width(), self.pixmap.height()), self.pixmap
)
def compose_map():
painter = QPainter(self.window)
painter.drawPixmap(rect, self.map)
def stamp_mousePressEvent(self, e):
p = QPainter(self.pixmap())
stamp = self.current_stamp
p.drawPixmap(e.x() - stamp.width() // 2,
e.y() - stamp.height() // 2, stamp)
self.update()
def paintEvent(self, event):
paint = QPainter(self)
paint.drawPixmap(0, 0, self.width(), self.height(),
self.__pic) #这个地方四个参数分别是x, y, width, height
super().paintEvent(event)
def paintEvent(self, e):
super().paintEvent(e)
painter = QPainter(self)
rect = QRect(min(self.parent.x0, self.parent.x1),
min(self.parent.y0, self.parent.y1),
abs(self.parent.x1 - self.parent.x0),
abs(self.parent.y1 - self.parent.y0))
painter.setPen(QPen(Qt.red, 3, Qt.SolidLine))
painter.drawRect(rect) # 画框选区
painter.drawRect(0, 0, self.width(), self.height()) # 画边界框
painter.setPen(QPen(Qt.red, 10, Qt.SolidLine))
# 画选框上的八个点移动点
painter.drawPoint(
QPoint(
self.parent.x0,
min(self.parent.y1, self.parent.y0) +
abs(self.parent.y1 - self.parent.y0) // 2))
painter.drawPoint(
QPoint(
min(self.parent.x1, self.parent.x0) +
abs(self.parent.x1 - self.parent.x0) // 2, self.parent.y0))
painter.drawPoint(
QPoint(
self.parent.x1,
min(self.parent.y1, self.parent.y0) +
abs(self.parent.y1 - self.parent.y0) // 2))
painter.drawPoint(
QPoint(
min(self.parent.x1, self.parent.x0) +
abs(self.parent.x1 - self.parent.x0) // 2, self.parent.y1))
painter.drawPoint(QPoint(self.parent.x0, self.parent.y0))
painter.drawPoint(QPoint(self.parent.x0, self.parent.y1))
painter.drawPoint(QPoint(self.parent.x1, self.parent.y0))
painter.drawPoint(QPoint(self.parent.x1, self.parent.y1))
x = y = 100
if self.parent.x1 > self.parent.x0:
x = self.parent.x0 + 5
else:
x = self.parent.x0 - 72
if self.parent.y1 > self.parent.y0:
y = self.parent.y0 + 15
else:
y = self.parent.y0 - 5
# 画分辨率
painter.drawText(
x, y, '{}x{}'.format(abs(self.parent.x1 - self.parent.x0),
abs(self.parent.y1 - self.parent.y0)))
painter.setPen(Qt.NoPen)
# 填充阴影遮罩
painter.setBrush(QColor(0, 0, 0, 120))
painter.drawRect(0, 0, self.width(), min(self.parent.y1,
self.parent.y0))
painter.drawRect(0, min(self.parent.y1, self.parent.y0),
min(self.parent.x1, self.parent.x0),
self.height() - min(self.parent.y1, self.parent.y0))
painter.drawRect(max(self.parent.x1, self.parent.x0),
min(self.parent.y1, self.parent.y0),
self.width() - max(self.parent.x1, self.parent.x0),
self.height() - min(self.parent.y1, self.parent.y0))
painter.drawRect(
min(self.parent.x1, self.parent.x0),
max(self.parent.y1, self.parent.y0),
max(self.parent.x1, self.parent.x0) -
min(self.parent.x1, self.parent.x0),
self.height() - max(self.parent.y1, self.parent.y0))
# 画放大镜区
if not (self.parent.painter_tools['drawcircle_on']
or self.parent.painter_tools['drawrect_bs_on']
or self.parent.painter_tools['pen_on']
or self.parent.painter_tools['eraser_on']
or self.parent.painter_tools['drawtext_on']
or self.parent.painter_tools['backgrounderaser_on']
or self.parent.painter_tools['drawpix_bs_on']
or self.parent.move_rect):
painter.setPen(QPen(Qt.red, 2, Qt.SolidLine))
if self.parent.mouse_posx > self.width() - 140:
enlarge_box_x = self.parent.mouse_posx - 140
else:
enlarge_box_x = self.parent.mouse_posx + 20
if self.parent.mouse_posy > self.height() - 140:
enlarge_box_y = self.parent.mouse_posy - 120
else:
enlarge_box_y = self.parent.mouse_posy + 20
enlarge_rect = QRect(enlarge_box_x, enlarge_box_y, 120, 120)
painter.drawRect(enlarge_rect)
painter.drawText(
enlarge_box_x, enlarge_box_y - 8,
'({0}x{1})'.format(self.parent.mouse_posx,
self.parent.mouse_posy))
try:
painter.setCompositionMode(QPainter.CompositionMode_Source)
p = self.parent.pixmap()
larger_pix = p.copy(self.parent.mouse_posx - 60,
self.parent.mouse_posy - 60, 120,
120).scaled(
120 + self.parent.tool_width * 10,
120 + self.parent.tool_width * 10)
pix = larger_pix.copy(larger_pix.width() / 2 - 60,
larger_pix.height() / 2 - 60, 120, 120)
painter.drawPixmap(enlarge_box_x, enlarge_box_y, pix)
painter.setPen(QPen(Qt.white, 1, Qt.SolidLine))
painter.drawLine(enlarge_box_x, enlarge_box_y + 60,
enlarge_box_x + 120, enlarge_box_y + 60)
painter.drawLine(enlarge_box_x + 60, enlarge_box_y,
enlarge_box_x + 60, enlarge_box_y + 120)
except:
print('draw_enlarge_box fail')
painter.end()
def paintEvent(self, event):
painter = QPainter(self)
# todo: retain aspect ratio
target = QRect(0, 0, self.width(), self.height())
source = QRect(0, 0, self.image.width(), self.image.height())
painter.drawPixmap(target, self.image, source)
class EndGameWinWidget(QWidget):
"""Виджет, в случае выигрыша"""
def __init__(self, main_window, menu_widget, score, lvl):
super().__init__()
self.buttons = [
MenuButton(199, 624, "resources/menu_text.png", self.back)
]
self.lvl = lvl
self.name = "Convert"
self.menu_widget = menu_widget
self.main_window = main_window
self.score = score
self.timer = QTimer()
self.timer.timeout.connect(self.handle_timer)
self.timer.start(40)
self.label = QLabel()
self.layout = QVBoxLayout()
self.setLayout(self.layout)
self.layout.addWidget(self.label)
tracker = MouseTracker(self.label)
tracker.positionChanged.connect(self.on_position_changed)
def handle_timer(self):
self.label.setPixmap(QPixmap(800, 800))
self.qp = QPainter(self.label.pixmap())
self.qp.setFont(QFont("arial", 55))
self.qp.setPen(QColor("blue"))
self.qp.drawPixmap(0, 0, 800, 800, QPixmap("resources/game_end.png"))
self.qp.drawPixmap(150, 100, 500, 150,
QPixmap("resources/pobeda_text.png"))
self.qp.drawPixmap(100, 300, 500, 150,
QPixmap("resources/you_get_score.png"))
self.qp.drawPixmap(600, 300, 200, 150, QPixmap("resources/table.png"))
self.qp.drawText(650, 400, str(self.score))
self.qp.drawPixmap(250, 500, 450, 150, QPixmap("resources/table.png"))
self.qp.drawText(250, 600, str(self.name))
self.qp.drawPixmap(0, 500, 200, 150,
QPixmap("resources/paste_nick.png"))
self.paint_buttons()
self.qp.end()
self.update()
def paint_buttons(self):
for i in self.buttons:
x, y, w, h = i.get_geometry()
self.qp.drawPixmap(x, y, w, h, QPixmap(i.get_pixmap()))
self.qp.drawPixmap(x, y, w, h, QPixmap(i.text_resource))
def back(self):
print(self.main_window, self.menu_widget)
self.close()
self.menu_widget.set_result([self.lvl, [self.name, self.score]])
self.main_window.setCentralWidget(
type(self.menu_widget)(self.main_window))
def mousePressEvent(self, a0):
for i in self.buttons:
if i.is_pressed:
i.on_click()
def add_name_symbol(self, symbol):
if len(self.name) > 10:
return
self.name += symbol
def remove_name_symbol(self):
if len(self.name) > 0:
self.name = self.name[0:-1]
@pyqtSlot(QPoint)
def on_position_changed(self, pos):
for i in self.buttons:
x, y, w, h = i.get_geometry()
if (pos.x() > x and pos.x() < x + w and pos.y() > y
and pos.y() < y + h):
i.is_pressed = True
else:
i.is_pressed = False
def paintEvent(self, event):
if not self.p.isNull():
painter = QPainter(self)
painter.setRenderHint(QPainter.SmoothPixmapTransform)
painter.drawPixmap(self.rect(), self.p)
def data(self, index, role=Qt.DisplayRole):
if not index.isValid():
return
node = self.index2node(index)
legend_node = self.index2legendNode(index)
if legend_node and role == Qt.DecorationRole:
pixmap = pixmapForLegendNode(legend_node)
if pixmap:
return pixmap
if not node:
return super().data(index, role)
if role == Qt.FontRole:
f = iface.layerTreeView().font()
if node.customProperty("plugins/customTreeIcon/font"):
f.fromString(node.customProperty("plugins/customTreeIcon/font"))
elif QgsLayerTree.isLayer(node):
f = self.layerTreeNodeFont(QgsLayerTree.NodeLayer)
elif QgsLayerTree.isGroup(node):
f = self.layerTreeNodeFont(QgsLayerTree.NodeGroup)
if index == self.currentIndex():
f.setUnderline(not f.underline())
if QgsLayerTree.isLayer(node):
_, _, scale = self.legendMapViewData()
layer = node.layer()
if (not node.isVisible() and (not layer or layer.isSpatial())) or (
layer and not layer.isInScaleRange(scale)
):
f.setItalic(not f.italic())
return f
if role == Qt.ForegroundRole:
color = None
if node.customProperty("plugins/customTreeIcon/textColor"):
color = QColor(node.customProperty("plugins/customTreeIcon/textColor"))
elif QgsLayerTree.isGroup(node):
if self.settings.value("group_text_color"):
color = QColor(self.settings.value("group_text_color"))
else:
if self.settings.value("layer_text_color"):
color = QColor(self.settings.value("layer_text_color"))
if color:
if QgsLayerTree.isLayer(node):
_, _, scale = self.legendMapViewData()
layer = node.layer()
if (not node.isVisible() and (not layer or layer.isSpatial())) or (
layer and not layer.isInScaleRange(scale)
):
color.setAlpha(128)
return color
if role == Qt.BackgroundRole:
if node.customProperty("plugins/customTreeIcon/backgroundColor"):
return QColor(
node.customProperty("plugins/customTreeIcon/backgroundColor")
)
elif QgsLayerTree.isGroup(node):
if self.settings.value("group_background_color"):
return QColor(self.settings.value("group_background_color"))
else:
if self.settings.value("layer_background_color"):
return QColor(self.settings.value("layer_background_color"))
# Override data for DecorationRole (Icon)
if role == Qt.DecorationRole and index.column() == 0:
icon = None
pixmap = None
# If a custom icon was set for this node
if node.customProperty("plugins/customTreeIcon/icon"):
icon = QIcon(node.customProperty("plugins/customTreeIcon/icon"))
# If an icon was set for the node type
elif QgsLayerTree.isGroup(node):
if self.settings.value("defaulticons/group", ""):
icon = QIcon(self.settings.value("defaulticons/group"))
else:
icon = QIcon(":/images/themes/default/mActionFolder.svg")
elif QgsLayerTree.isLayer(node):
layer = node.layer()
if not layer:
return super().data(index, role)
if layer.type() == QgsMapLayer.RasterLayer:
if self.settings.value("defaulticons/raster", ""):
icon = QIcon(self.settings.value("defaulticons/raster"))
else:
icon = QIcon(":/images/themes/default/mIconRaster.svg")
if layer.type() == QgsMapLayer.VectorLayer:
if self.testFlag(
QgsLayerTreeModel.ShowLegend
) and self.legendEmbeddedInParent(node):
size = iface.layerTreeView().iconSize()
legend_node = self.legendNodeEmbeddedInParent(node)
pixmap = pixmapForLegendNode(legend_node)
else:
if layer.geometryType() == QgsWkbTypes.PointGeometry:
if self.settings.value("defaulticons/point", ""):
icon = QIcon(self.settings.value("defaulticons/point"))
else:
icon = QIcon(
":/images/themes/default/mIconPointLayer.svg"
)
elif layer.geometryType() == QgsWkbTypes.LineGeometry:
if self.settings.value("defaulticons/line", ""):
icon = QIcon(self.settings.value("defaulticons/line"))
else:
icon = QIcon(
":/images/themes/default/mIconLineLayer.svg"
)
elif layer.geometryType() == QgsWkbTypes.PolygonGeometry:
if self.settings.value("defaulticons/polygon", ""):
icon = QIcon(
self.settings.value("defaulticons/polygon")
)
else:
icon = QIcon(
":/images/themes/default/mIconPolygonLayer.svg"
)
elif layer.geometryType() == QgsWkbTypes.NullGeometry:
if self.settings.value("defaulticons/nogeometry", ""):
icon = QIcon(
self.settings.value("defaulticons/nogeometry")
)
else:
icon = QIcon(
":/images/themes/default/mIconTableLayer.svg"
)
try:
if layer.type() == QgsMapLayer.MeshLayer:
if self.settings.value("defaulticons/mesh", ""):
icon = QIcon(self.settings.value("defaulticons/mesh"))
else:
icon = QIcon(":/images/themes/default/mIconMeshLayer.svg")
except AttributeError:
pass
# Special case: In-edition vector layer. Draw an editing icon over
# the custom icon. Adapted from QGIS source code (qgslayertreemodel.cpp)
if (pixmap or icon) and QgsLayerTree.isLayer(node):
layer = node.layer()
if layer and isinstance(layer, QgsVectorLayer) and layer.isEditable():
icon_size = iface.layerTreeView().iconSize().width()
if icon_size == -1:
icon_size = 16
if not pixmap and icon:
pixmap = QPixmap(icon.pixmap(icon_size, icon_size))
painter = QPainter(pixmap)
painter.drawPixmap(
0,
0,
icon_size,
icon_size,
QgsApplication.getThemeIcon(
("/mIconEditableEdits.svg")
if layer.isModified()
else ("/mActionToggleEditing.svg")
).pixmap(icon_size, icon_size),
)
painter.end()
del painter
if pixmap:
return pixmap
if icon:
return icon
# call QgsLayerTreeModel implementation
return super().data(index, role)
def paintEvent(self, event):
painter = QPainter(self)
pixmap = QPixmap('./config_images/first_edition.jpg')
painter.drawPixmap(self.rect(), pixmap)
def data(self, index=QModelIndex(), role=Qt.DisplayRole):
if role not in [Qt.DisplayRole, Qt.DecorationRole, Qt.EditRole]:
return QVariant()
style = self._styles[index.row()]
fore = QColor(*style.fore)
back = QColor(*style.back)
border_color = QColor(*style.color)
if role == Qt.EditRole:
if index.column() == 0:
if style.isFilled():
return 0 # solid special case
return style.pattern
elif index.column() == 1:
return fore
elif index.column() == 2:
return back
elif index.column() == 3:
if style.style == -4105:
return 0 # Auto special case
elif style.style == -4142:
return 9 # None special case
return style.dash # see also MsoLineDashStyle
elif index.column() == 4:
return border_color
elif index.column() == 5:
if style.weight == -4138:
return 3 # Medium special case
return style.weight # see also XlBorderWeight
else:
return QVariant()
elif role == Qt.DecorationRole:
# Pattern
if index.column() == 0:
img = None
if style.isFilled():
img = QPixmap(48, 48)
img.fill(Qt.black)
else:
img = self.patternImage.copy(48 * (style.pattern - 1), 0,
48, 48)
foreMask = img.createMaskFromColor(QColor(Qt.white))
backMask = img.createMaskFromColor(QColor(Qt.black))
p = QPainter(img)
p.setPen(fore)
p.drawPixmap(img.rect(), foreMask, foreMask.rect())
p.setPen(back)
p.drawPixmap(img.rect(), backMask, backMask.rect())
p.end()
return img
elif role == Qt.DisplayRole:
# Line style
if index.column() == 3:
value = self.data(index, role=Qt.EditRole)
if value not in range(10):
return self.tr("Unknown")
return {
0: self.tr("Auto"),
1: self.tr("Solid"),
2: self.tr("SquareDot"),
3: self.tr("RoundDot"),
4: self.tr("LineDash"),
5: self.tr("DashDot"),
6: self.tr("DashDotDot"),
7: self.tr("LongDash"),
8: self.tr("LongDashDot"),
9: self.tr("None"),
}[value]
elif index.column() == 5:
return {
1: self.tr("Hairline"),
2: self.tr("Thin"),
3: self.tr("Medium"),
4: self.tr("Thick"),
}[self.data(index, role=Qt.EditRole)]
# Fore
if index.column() == 1:
return fore
# Back
elif index.column() == 2:
return back
# border color
elif index.column() == 4:
return border_color
return QVariant()
def getBalloonImage(self, size: QSize, flip=False, soul_id=-1):
if self._balloon is None:
logging.warning("getBalloonImage: balloon is None")
return kikka.helper.getDefaultImage()
drect = []
# calculate destination rect
if len(self._balloon.clipW) == 3:
dw = [
self._balloon.clipW[0],
size.width() - self._balloon.clipW[0] - self._balloon.clipW[2],
self._balloon.clipW[2]
]
elif len(self._balloon.clipW) == 5:
sw = size.width() - self._balloon.clipW[0] - self._balloon.clipW[
2] - self._balloon.clipW[4]
dw = [
self._balloon.clipW[0], sw // 2, self._balloon.clipW[2],
sw - sw // 2, self._balloon.clipW[4]
]
else:
sw = size.width() // 3
dw = [sw, size.width() - sw * 2, sw]
if len(self._balloon.clipH) == 3:
dh = [
self._balloon.clipH[0],
size.height() - self._balloon.clipH[0] -
self._balloon.clipH[2], self._balloon.clipH[2]
]
elif len(self._balloon.clipH) == 5:
sh = size.height() - self._balloon.clipH[0] - self._balloon.clipH[
2] - self._balloon.clipH[4]
dh = [
self._balloon.clipH[0], sh // 2, self._balloon.clipH[2],
sh - sh // 2, self._balloon.clipH[4]
]
else:
sh = size.height() // 3
dh = [sh, size.height() - sh * 2, sh]
for y in range(len(self._balloon.clipH)):
dr = []
for x in range(len(self._balloon.clipW)):
pt = QPoint(0, 0)
if x > 0: pt.setX(dr[x - 1].x() + dw[x - 1])
if y > 0: pt.setY(drect[y - 1][0].y() + dh[y - 1])
sz = QSize(dw[x], dh[y])
dr.append(QRect(pt, sz))
drect.append(dr)
pass # exit for
# paint balloon image
img = QImage(size, QImage.Format_ARGB32)
pixmap = QPixmap().fromImage(self._balloon_image_cache, Qt.AutoColor)
painter = QPainter(img)
painter.setCompositionMode(QPainter.CompositionMode_Source)
for y in range(len(self._balloon.clipH)):
for x in range(len(self._balloon.clipW)):
painter.drawPixmap(drect[y][x], pixmap,
self._balloon.bgRect[y][x])
painter.end()
# flip or not
if self._balloon.flipBackground is True and flip is True:
img = img.mirrored(True, False)
if self._balloon.noFlipCenter is True and len(
self._balloon.clipW) == 5 and len(
self._balloon.clipH) == 5:
painter = QPainter(img)
painter.setCompositionMode(QPainter.CompositionMode_Source)
painter.drawPixmap(drect[2][2], pixmap,
self._balloon.bgRect[2][2])
painter.end()
# debug draw
if kikka.shell.isDebug is True:
painter = QPainter(img)
painter.fillRect(QRect(0, 0, 200, 64), QColor(0, 0, 0, 64))
painter.setPen(Qt.red)
for y in range(len(self._balloon.clipH)):
for x in range(len(self._balloon.clipW)):
if x in (0, 2, 4) and y in (0, 2, 4):
continue
rectf = QRect(drect[y][x])
text = "(%d, %d)\n%d x %d" % (
rectf.x(), rectf.y(), rectf.width(), rectf.height())
painter.drawText(rectf, Qt.AlignCenter, text)
if y > 0:
painter.drawLine(drect[y][0].x(), drect[y][0].y(),
drect[y][0].x() + img.width(),
drect[y][0].y())
for x in range(1, len(self._balloon.clipW)):
painter.drawLine(drect[0][x].x(), drect[0][x].y(),
drect[0][x].x(),
drect[0][x].y() + img.height())
painter.setPen(Qt.green)
painter.drawRect(QRect(0, 0, img.width() - 1, img.height() - 1))
painter.drawText(3, 12, "DialogWindow")
painter.drawText(3, 24, "Ghost: %d" % self.ID)
painter.drawText(3, 36, "Name: %s" % self.name)
painter.drawText(3, 48, "soul_id: %d" % soul_id)
return img
def paintEvent(self, event):
painter = QPainter(self)
painter.drawPixmap(0, 0, self.width(), self.height(),
QPixmap("./images/boy.png"))
def paintEvent(self, event):
painter = QPainter(self)
# 在指定区域直接绘制窗口背景
painter.drawPixmap(0, 0, self.pix.width(), self.pix.height(),
QPixmap("./images/screen1.jpg"))
def paintEvent(self, QPaintEvent):
painter = QPainter(self)
painter.drawRect(self.rect())
pixmap = QPixmap("..//gesmuse_resources//image//chidback.jpg")
painter.drawPixmap(self.rect(), pixmap)
class RenderWindow(QWidget):
def __init__(self):
#loadSettings from json file
windowSettings = self.loadSettings()
self.width = windowSettings["ImageWidth"]
self.height = windowSettings["ImageHeight"]
#-------ui initialization-------
super().__init__()
self.setFixedSize(self.width, self.height)
self.move(50, 50)
self.setWindowTitle('PyTracer')
self.showBuckets = True #show bucket switch
#-----initialize a QImage, so we can maniputalte the pixels
self.bgImage = QImage(self.width, self.height, 4) #QImage.Format_RGB32
self.bgImage.fill(QColor(0, 0,
0)) # important, give canvas a default color
self.bucketLocator = QImage("bucketLocator.png") #Bucket Locator Image
self.graphic = QGraphicsScene(0, 0, self.width, self.height, self)
#Canvas-----
self.canvasPixmap = QPixmap().fromImage(self.bgImage)
self.canvasPainter = QPainter(self.canvasPixmap)
#Render image pixmap and painter
self.renderImagePixmap = QPixmap().fromImage(self.bgImage)
self.renderImagePainter = QPainter(self.renderImagePixmap)
#BuckerLocators pixmap and painter
self.locatorPixmap = QPixmap().fromImage(self.bgImage)
self.locatorPainter = QPainter(self.locatorPixmap)
self.graphicItem = self.graphic.addPixmap(self.canvasPixmap)
self.graphicView = QGraphicsView(self.graphic, self)
self.show()
def loadSettings(self):
with open("RenderSettings.json") as settingsData:
renderSettings = json.load(settingsData)
return renderSettings["RenderWindow"]
def keyPressEvent(self, event):
if event.key() == Qt.Key_S:
self.saveImage()
elif event.key() == Qt.Key_H:
if self.showBuckets:
self.showBuckets = False
print("Hide Buckets")
else:
self.showBuckets = True
print("Show Buckets")
self.refreshCanvas()
def startRender(self, scene, cam):
#start render in a new thread
self.renderTask = RenderThread(self.width, self.height, scene, cam)
self.renderTask.finished.connect(self.saveImage)
self.renderTask.finished.connect(self.cleanBucketLocators)
self.renderTask.updateImgSignal.connect(self.updateRenderImage)
self.renderTask.bucketProgressSignal.connect(self.showBucketProgess)
self.renderTask.start()
def cleanBucketLocators(self):
self.locatorPainter.drawImage(0, 0, self.bgImage)
self.refreshCanvas()
def showBucketProgess(self, bucketProgressPos):
bucketSize = bucketProgressPos[2]
if len(bucketProgressPos) > 3:
blackPatch = QImage(bucketSize, bucketSize, 4)
blackPatch.fill(0)
self.locatorPainter.drawImage(bucketProgressPos[3],
bucketProgressPos[4], blackPatch)
bucketLocImg = self.bucketLocator.scaled(bucketSize, bucketSize)
self.locatorPainter.drawImage(bucketProgressPos[0],
bucketProgressPos[1], bucketLocImg)
self.refreshCanvas()
def updateRenderImage(self, bucketDataList):
#update the render view, note the render is in another thread]
#use QPainter to stamp the image to canvas
self.renderImagePainter.drawImage(bucketDataList[0], bucketDataList[1],
bucketDataList[2])
self.refreshCanvas()
#print("Bucket "+ str(bucketDataList[0]) +":"+ str(bucketDataList[1])+" Updated")
def refreshCanvas(self):
self.canvasPainter.drawPixmap(0, 0, self.renderImagePixmap)
if self.showBuckets:
self.canvasPainter.setCompositionMode(
12) #plus locator layer on top
self.canvasPainter.drawPixmap(0, 0, self.locatorPixmap)
self.canvasPainter.setCompositionMode(
0) #set comp mode back to over
self.graphicItem.setPixmap(self.canvasPixmap)
def saveImage(self):
self.canvasPixmap.save("test.png")
print("Image Saved")
class MainWindow(QMainWindow):
""" Class
Main window class.
"""
_CHESSBOARD_SIZE = [633, 633]
_STATUS_BAR_LEN = 25
_BORDER_LEN = 11
_FRAME_LEN = 3
_GRID_SIZE = [(_CHESSBOARD_SIZE[0] - _FRAME_LEN * 9 - _BORDER_LEN * 2) / 8,
(_CHESSBOARD_SIZE[1] - _FRAME_LEN * 9 - _BORDER_LEN * 2) / 8]
_CHESS_SIZE = 34
_DIRECTION = [[1, 0], [0, 1], [1, 1], [1, -1]]
PATH_WINDOW_ICON = r'conf/chess_black.png'
PATH_CHESSBOARD = r'conf/chessboard.jpg'
PATH_BLACK_CHESS = r'conf/chess_black.png'
PATH_WHITE_CHESS = r'conf/chess_white.png'
PATH_HIGHLIGHT_BEIGE = r'conf/highlight_grid_beige.jpg'
PATH_HIGHLIGHT_BROWN = r'conf/highlight_grid_brown.jpg'
# Singal. Call `setAvailableMovement` function.
signal_set_available_movement = pyqtSignal([int, int])
# Sigbal. Call `aiTurnMonteCarloTreeSearch` function.
signal_ai_turn = pyqtSignal()
def setupUi(self, main_window):
"""
Setup GUI.
"""
self.setWindowTitle("Lines of action")
self.setWindowIcon(QIcon(MainWindow.PATH_WINDOW_ICON))
# Fixed-size window.
self.setFixedSize(MainWindow._CHESSBOARD_SIZE[0], \
MainWindow._CHESSBOARD_SIZE[1] + MainWindow._STATUS_BAR_LEN)
self.pos_x = 1000
self.pos_y = 1000
# Check if it's user's turn now.
self.is_user_turn = True
self.current_step = 0
self.lasting_time = 0
self.statusbar_msg = ''
self.check_exchange_turn = False
self._available_movement = []
# Clicked grid.
self.from_grid = []
self.ai_move = []
# Chess images.
self.black_chess = QPixmap(MainWindow.PATH_BLACK_CHESS)
self.white_chess = QPixmap(MainWindow.PATH_WHITE_CHESS)
self.highlight_beige = QPixmap(MainWindow.PATH_HIGHLIGHT_BEIGE)
self.highlight_brown = QPixmap(MainWindow.PATH_HIGHLIGHT_BROWN)
# Change the cursor to hand-like icon.
self.setCursor(Qt.PointingHandCursor)
# Cursor.
self.cursor = LabelChess(self)
# Always on the top.
self.cursor.raise_()
# The labels of the grids on the chessboard to store chess images.
self.chess_labels = [[LabelChess(self) for i in range(8)]
for j in range(8)]
for y in self.chess_labels:
for x in y:
x.setVisible(True)
x.setScaledContents(True)
# Chessboard.
self.chessboard = Chessboard()
# Set the starting chess.
self.resetChess()
# Timer.
self.timer = QTimer(self)
self.timer.timeout.connect(self.timerRun)
# Setup signals.
self.signal_set_available_movement[int, int].connect(
main_window.setAvailableMovement)
self.signal_ai_turn.connect(main_window.aiTurnMonteCarloTreeSearch)
self.setMouseTracking(True)
self.show()
rules = '1. Players alternate moves, with Black having the first move.\n'
rules += '2. Checkers move horizontally, vertically, or diagonally.\n'
rules += '3. A checker moves exactly as many spaces as there are checkers (both friendly and enemy) on the line in which it is moving.\n'
rules += '4. A checker may jump over friendly checkers, but not over an enemy checker.\n'
rules += '5. If a checker moves to an enemy checker, then remove the enemy checker, and move the checker to the space.\n'
rules += '6. If a player has some checker to move, then the player cannot abstain.\n'
rules += '7. If a player does not move a checker for one minute, then the player loses the game.'
QMessageBox.information(self, 'Rules', rules, \
QMessageBox.Yes, QMessageBox.Yes)
goals = '1. Bring all of one\'s checkers together into a contiguous body'
goals += 'so that they are connected vertically, horizontally or diagonally'
goals += ' (8-connectivity). \n'
goals += '2. If one\'s enemy only has one checker, then the player wins the game.'
reply = QMessageBox.information(self, 'Goals', goals, \
QMessageBox.Yes, QMessageBox.Yes)
# The timer starts after the user close the info windows.
if reply == QMessageBox.Yes:
# 1 second.
self.timer.start(1000)
self.past_time = 0
def setStatusbur(self, message):
"""
Setup Statusbar.
"""
self.statusBar().showMessage(message)
def checkChessMove(self, from_grid, from_chess, to_grid):
"""
Check if the chess movement is legal.
"""
if from_chess != State.BLACK or not self.is_user_turn:
return False
elif to_grid not in self._available_movement:
return False
else:
return True
def setAvailableMovement(self, available_movement):
"""
Setup `self._available_movement`.
"""
self._available_movement = available_movement
def paintEvent(self, event):
""" Slot function.
While painting again, this function is called.
"""
self.painter = QPainter()
self.painter.begin(self)
self.painter.setPen(QPen(Qt.NoPen))
self.painter.drawPixmap(0, 0, MainWindow._CHESSBOARD_SIZE[0], \
MainWindow._CHESSBOARD_SIZE[1], \
QPixmap(MainWindow.PATH_CHESSBOARD))
self.painter.end()
def mousePressEvent(self, event):
""" Slot function
While mouse is pressed, this function is called, and while the chess is
right-clicked, it's cleared first and the legal movements are
highlighted. If the mouse is right-clicked, the user can decide to
restart the game.
"""
if self.check_exchange_turn:
self.check_exchange_turn = False
self.is_user_turn = True
# User moves black chess.
if event.buttons() == Qt.LeftButton and self.is_user_turn:
grid_x, grid_y = self.coordinate2ChessboardGrid(
event.x(), event.y())
if grid_x != -1 and grid_y != -1:
if self.is_user_turn:
cleared_chess = self.clearChess(grid_x, grid_y)
self.from_grid = [grid_x, grid_y, cleared_chess]
if self.chessboard.getCoordinateState(
grid_x, grid_y) == State.BLACK:
self.signal_set_available_movement.emit(grid_x, grid_y)
self.highlight_grid()
else:
pass
# Restart the game.
elif event.buttons() == Qt.RightButton:
self.timer.stop()
reply = QMessageBox.question(self, 'Restart', 'Are you sure?', \
QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
if reply == QMessageBox.Yes:
self.chessboard.resetChessboard()
self.resetChess()
self.update()
self.current_step = 0
self.past_time = 0
self.is_user_turn = True
else:
self.timer.start(1000)
def mouseReleaseEvent(self, event):
""" Slot function
While mouse is pressed, this function is called, and while the mouse is
released, check if it's legal first and clear the highlighted movements.
"""
if self.check_exchange_turn:
self.check_exchange_turn = False
self.is_user_turn = True
# User moves black chess, and check the legality.
if event.button() == Qt.LeftButton and self.is_user_turn:
grid_x, grid_y = self.coordinate2ChessboardGrid(
event.x(), event.y())
if grid_x != -1 and grid_y != -1:
if self.checkChessMove(self.from_grid[0:2], self.from_grid[2],
[grid_x, grid_y]):
self.chessboard.setCoordinateState(self.from_grid[0],
self.from_grid[1],
State.EMPTY)
self.chessboard.setCoordinateState(grid_x, grid_y,
State.BLACK)
self.drawChess(grid_x, grid_y, State.BLACK)
self.is_user_turn = False
self.current_step += 1
self.signal_ai_turn.emit()
self.statusbar_msg = 'Steps: {}. Black: ({}, {}) -> ({}, {}); White: ({}, {}) -> ({}, {}). Computed time: {}s.'.format( \
self.current_step, self.from_grid[0] + 1, self.from_grid[1] + 1, grid_x + 1, grid_y + 1, self.ai_move[0][0] + 1, self.ai_move[0][1] + 1, self.ai_move[1][0] + 1, self.ai_move[1][1] + 1, self.lasting_time)
self.past_time = 0
else:
if self.from_grid[2] != State.EMPTY:
self.drawChess(self.from_grid[0], self.from_grid[1],
self.from_grid[2])
self.chessboard.setCoordinateState(self.from_grid[0],
self.from_grid[1],
self.from_grid[2])
self.from_grid.clear()
# Clear highlighted grids.
if [grid_x, grid_y] in self._available_movement:
self._available_movement.remove([grid_x, grid_y])
for i in self._available_movement:
self.clearChess(i[0], i[1])
chess = self.chessboard.getCoordinateState(i[0], i[1])
if chess != State.EMPTY:
self.drawChess(i[0], i[1], chess)
def highlight_grid(self):
"""
Hightligth legal movements grids.
"""
for grid in self._available_movement:
if (grid[0] + grid[1]) % 2 == 0:
self.chess_labels[grid[0]][grid[1]].setPixmap(
self.highlight_beige)
else:
self.chess_labels[grid[0]][grid[1]].setPixmap(
self.highlight_brown)
pos_x, pos_y = self.coordinate2ChessboardCoordinate(
grid[0], grid[1])
# TODO: pos_x, pos_y.
self.chess_labels[grid[0]][grid[1]].setGeometry(
pos_x - 19.5, pos_y - 19.5, MainWindow._GRID_SIZE[1],
MainWindow._GRID_SIZE[0])
def drawChess(self, grid_x, grid_y, chess):
"""
Draw the chess image.
"""
pos_x, pos_y = self.coordinate2ChessboardCoordinate(grid_x, grid_y)
self.chess_labels[grid_x][grid_y].clear()
if chess == State.BLACK:
self.chess_labels[grid_x][grid_y].setPixmap(self.black_chess)
elif chess == State.WHITE:
self.chess_labels[grid_x][grid_y].setPixmap(self.white_chess)
self.chessboard.setCoordinateState(grid_x, grid_y, chess)
self.chess_labels[grid_x][grid_y].setGeometry(pos_x, pos_y,
MainWindow._CHESS_SIZE,
MainWindow._CHESS_SIZE)
def clearChess(self, grid_x, grid_y):
"""
Clear the chess image.
"""
cleared_chess = self.chessboard.getCoordinateState(grid_x, grid_y)
self.chess_labels[grid_x][grid_y].clear()
return cleared_chess
def coordinate2ChessboardGrid(self, pos_x, pos_y):
"""
Compute the grid position on the chessboard from the chessboard
coordinates.
"""
if pos_x <= MainWindow._BORDER_LEN or pos_y <= MainWindow._BORDER_LEN or pos_x >= MainWindow._CHESSBOARD_SIZE[
1] - MainWindow._BORDER_LEN or pos_y >= MainWindow._CHESSBOARD_SIZE[
0] - MainWindow._BORDER_LEN:
return -1, -1
else:
grid_x = floor(
(pos_x - MainWindow._BORDER_LEN - MainWindow._FRAME_LEN) /
(MainWindow._GRID_SIZE[1] + MainWindow._FRAME_LEN))
grid_y = floor(
(pos_y - MainWindow._BORDER_LEN - MainWindow._FRAME_LEN) /
(MainWindow._GRID_SIZE[0] + MainWindow._FRAME_LEN))
return grid_x, grid_y
def coordinate2ChessboardCoordinate(self, grid_x, grid_y):
"""
Compute the chessboard coordinates from original coordinates.
"""
coordinate_x = MainWindow._BORDER_LEN + MainWindow._FRAME_LEN * (
grid_x + 1) + grid_x * MainWindow._GRID_SIZE[1] + (
MainWindow._GRID_SIZE[1] - MainWindow._CHESS_SIZE) / 2
coordinate_y = MainWindow._BORDER_LEN + MainWindow._FRAME_LEN * (
grid_y + 1) + grid_y * MainWindow._GRID_SIZE[0] + (
MainWindow._GRID_SIZE[0] - MainWindow._CHESS_SIZE) / 2
return coordinate_x, coordinate_y
def gameEnd(self, winner):
"""
After the game ends, show pop-up window to check if the user wants to
play again.
"""
self.timer.stop()
if winner == State.BLACK:
reply = QMessageBox.question(self, 'Restart', 'Congrats! You win this game.\nPlay again?', \
QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
elif winner == State.WHITE:
reply = QMessageBox.question(self, 'Restart', 'Sorry. You lose this game.\nPlay again?', \
QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
if reply == QMessageBox.Yes:
self.chessboard.resetChessboard()
self.resetChess()
self.update()
self.current_step = 0
self.past_time = 0
self.is_user_turn = True
self.timer.start(1000)
else:
self.close()
def resetChess(self):
"""
Reset the chessboard to the beginning.
"""
for i in range(8):
for j in range(8):
self.clearChess(i, j)
for i in range(1, 7):
self.drawChess(0, i, State.WHITE)
self.drawChess(7, i, State.WHITE)
self.drawChess(i, 0, State.BLACK)
self.drawChess(i, 7, State.BLACK)
def closeEvent(self, event):
""" Slot function.
While the closed button is clicked, this function is called to
double-check the operation.
"""
# Stop the timer.
self.timer.stop()
reply = QMessageBox.question(self, 'Quit', 'Are you sure?', \
QMessageBox.Yes | QMessageBox.No, QMessageBox.Yes)
if reply == QMessageBox.Yes:
event.accept()
else:
self.timer.start(1000)
event.ignore()
def timerRun(self):
if self.past_time == 60:
self.gameEnd(State.WHITE)
else:
statusbar_msg = 'Past time: %s. ' % self.past_time + self.statusbar_msg
self.setStatusbur(statusbar_msg)
self.past_time += 1
def paintEvent(self, e):
super().paintEvent(e)
# 画鼠标位置处的圆
if 1 in self.parent.painter_tools.values():
painter = QPainter(self)
painter.setPen(QPen(self.parent.pencolor, 1, Qt.SolidLine))
rect = QRectF(self.px - self.parent.tool_width // 2,
self.py - self.parent.tool_width // 2,
self.parent.tool_width, self.parent.tool_width)
painter.drawEllipse(rect)
painter.end()
if self.startpaint:
while len(self.parent.eraser_pointlist): # 画橡皮擦
self.pixPainter = QPainter(self.pixmap())
self.pixPainter.setRenderHint(QPainter.Antialiasing)
self.pixPainter.setBrush(QColor(0, 0, 0, 0))
self.pixPainter.setPen(Qt.NoPen)
self.pixPainter.setCompositionMode(
QPainter.CompositionMode_Clear)
new_pen_point = self.parent.eraser_pointlist.pop(0)
if self.parent.old_pen[0] != -2 and new_pen_point[0] != -2:
self.pixPainter.drawEllipse(
new_pen_point[0] - self.parent.tool_width / 2,
new_pen_point[1] - self.parent.tool_width / 2,
self.parent.tool_width, self.parent.tool_width)
self.parent.old_pen = new_pen_point
self.pixPainter.end()
while len(self.parent.pen_pointlist): # 画笔功能
self.pixPainter = QPainter(self.pixmap())
self.pixPainter.setRenderHint(QPainter.Antialiasing)
self.pixPainter.setBrush(self.parent.pencolor)
self.pixPainter.setPen(
QPen(self.parent.pencolor, self.parent.tool_width,
Qt.SolidLine))
new_pen_point = self.parent.pen_pointlist.pop(0)
if self.parent.old_pen[0] != -2 and new_pen_point[0] != -2:
path = QPainterPath(
QPoint(self.parent.old_pen[0], self.parent.old_pen[1]))
path.quadTo(
QPoint(
(new_pen_point[0] + self.parent.old_pen[0]) / 2,
(new_pen_point[1] + self.parent.old_pen[1]) / 2),
QPoint(new_pen_point[0], new_pen_point[1]))
self.pixPainter.drawPath(path)
self.parent.old_pen = new_pen_point
self.pixPainter.end()
while len(self.parent.drawpix_pointlist): # 画马赛克/材质贴图功能
self.pixPainter = QPainter(self.pixmap())
self.pixPainter.setRenderHint(QPainter.Antialiasing)
brush = QBrush(self.parent.pencolor)
brush.setTexture(QPixmap(self.pixpng))
self.pixPainter.setBrush(brush)
self.pixPainter.setPen(Qt.NoPen)
new_pen_point = self.parent.drawpix_pointlist.pop(0)
if self.parent.old_pen[0] != -2 and new_pen_point[0] != -2:
self.pixPainter.drawEllipse(
new_pen_point[0] - self.parent.tool_width / 2,
new_pen_point[1] - self.parent.tool_width / 2,
self.parent.tool_width, self.parent.tool_width)
self.parent.old_pen = new_pen_point
self.pixPainter.end()
if self.parent.drawrect_pointlist[0][
0] != -2 and self.parent.drawrect_pointlist[1][
0] != -2: # 画方形
self.pixPainter = QPainter(self.pixmap())
self.pixPainter.setRenderHint(QPainter.Antialiasing)
temppainter = QPainter(self)
temppainter.setPen(QPen(self.parent.pencolor, 3, Qt.SolidLine))
poitlist = self.parent.drawrect_pointlist
temppainter.drawRect(min(poitlist[0][0], poitlist[1][0]),
min(poitlist[0][1], poitlist[1][1]),
abs(poitlist[0][0] - poitlist[1][0]),
abs(poitlist[0][1] - poitlist[1][1]))
temppainter.end()
if self.parent.drawrect_pointlist[2] == 1:
self.pixPainter.setPen(
QPen(self.parent.pencolor, 3, Qt.SolidLine))
self.pixPainter.drawRect(
min(poitlist[0][0], poitlist[1][0]),
min(poitlist[0][1], poitlist[1][1]),
abs(poitlist[0][0] - poitlist[1][0]),
abs(poitlist[0][1] - poitlist[1][1]))
self.parent.drawrect_pointlist = [[-2, -2], [-2, -2], 0]
self.pixPainter.end()
if self.parent.drawcircle_pointlist[0][
0] != -2 and self.parent.drawcircle_pointlist[1][
0] != -2: # 画圆
self.pixPainter = QPainter(self.pixmap())
self.pixPainter.setRenderHint(QPainter.Antialiasing)
temppainter = QPainter(self)
temppainter.setPen(QPen(self.parent.pencolor, 3, Qt.SolidLine))
poitlist = self.parent.drawcircle_pointlist
temppainter.drawEllipse(min(poitlist[0][0], poitlist[1][0]),
min(poitlist[0][1], poitlist[1][1]),
abs(poitlist[0][0] - poitlist[1][0]),
abs(poitlist[0][1] - poitlist[1][1]))
temppainter.end()
if self.parent.drawcircle_pointlist[2] == 1:
self.pixPainter.setPen(
QPen(self.parent.pencolor, 3, Qt.SolidLine))
self.pixPainter.drawEllipse(
min(poitlist[0][0], poitlist[1][0]),
min(poitlist[0][1], poitlist[1][1]),
abs(poitlist[0][0] - poitlist[1][0]),
abs(poitlist[0][1] - poitlist[1][1]))
self.parent.drawcircle_pointlist = [[-2, -2], [-2, -2], 0]
self.pixPainter.end()
if self.parent.drawarrow_pointlist[0][
0] != -2 and self.parent.drawarrow_pointlist[1][
0] != -2: # 画箭头
self.pixPainter = QPainter(self.pixmap())
self.pixPainter.setRenderHint(QPainter.Antialiasing)
temppainter = QPainter(self)
poitlist = self.parent.drawarrow_pointlist
temppainter.translate(poitlist[0][0], poitlist[0][1])
degree = math.degrees(
math.atan2(poitlist[1][1] - poitlist[0][1],
poitlist[1][0] - poitlist[0][0]))
temppainter.rotate(degree)
dx = math.sqrt((poitlist[1][1] - poitlist[0][1])**2 +
(poitlist[1][0] - poitlist[0][0])**2)
dy = 30
temppainter.drawPixmap(0, -dy / 2,
QPixmap(':/arrow.png').scaled(dx, dy))
temppainter.end()
if self.parent.drawarrow_pointlist[2] == 1:
self.pixPainter.translate(poitlist[0][0], poitlist[0][1])
degree = math.degrees(
math.atan2(poitlist[1][1] - poitlist[0][1],
poitlist[1][0] - poitlist[0][0]))
self.pixPainter.rotate(degree)
dx = math.sqrt((poitlist[1][1] - poitlist[0][1])**2 +
(poitlist[1][0] - poitlist[0][0])**2)
dy = 30
self.pixPainter.drawPixmap(
0, -dy / 2,
QPixmap(':/arrow.png').scaled(dx, dy))
self.parent.drawarrow_pointlist = [[-2, -2], [-2, -2], 0]
# self.parent.drawarrow_pointlist[0] = [-2, -2]
self.pixPainter.end()
if len(self.parent.drawtext_pointlist
) > 1 or self.parent.text_box.paint: # 画文字
self.pixPainter = QPainter(self.pixmap())
self.pixPainter.setRenderHint(QPainter.Antialiasing)
self.parent.text_box.paint = False
# print(self.parent.drawtext_pointlist)
text = self.parent.text_box.toPlainText()
self.parent.text_box.clear()
pos = self.parent.drawtext_pointlist.pop(0)
if text:
self.pixPainter.setFont(
QFont('微软雅黑', self.parent.tool_width))
self.pixPainter.setPen(
QPen(self.parent.pencolor, 3, Qt.SolidLine))
self.pixPainter.drawText(
pos[0] +
self.parent.text_box.document.size().height() / 8,
pos[1] +
self.parent.text_box.document.size().height() * 32 /
41, text)
self.pixPainter.end()
else:
self.startpaint = 1
def paintEvent(self, e) -> None:
if self.inter == cv2.INTER_NEAREST:
inter_method = 'Nearest'
elif self.inter == cv2.INTER_LINEAR:
inter_method = 'Bilinear'
elif self.inter == cv2.INTER_CUBIC:
inter_method = 'Bicubic'
self.setWindowTitle('Interpolation: {} / backend: {}'.format(
inter_method, self.backend))
qimg = QImage(
self.img,
self.img_w,
self.img_h,
3 * self.img_w,
QImage.Format_RGB888,
)
qpix = QPixmap(qimg)
qp = QPainter()
qp.begin(self)
qp.drawPixmap(self.margin, self.margin, self.img_w, self.img_h, qpix)
m = self.get_matrix()
y_min, x_min, h_new, w_new = self.get_dimension(m)
mc = np.array([[1, 0, -x_min], [0, 1, -y_min], [0, 0, 1]])
m = np.matmul(mc, m)
if self.backend == 'opencv':
warp = cv2.warpPerspective(
self.img,
m,
(w_new, h_new),
flags=self.inter,
)
elif self.backend == 'core':
warp = core_warp.warp(self.img_tensor,
torch.Tensor(m),
sizes=(h_new, w_new),
kernel=inter_method.lower(),
fill_value=0.5)
warp = utils.tensor2np(warp)
qimg_warp = QImage(warp, w_new, h_new, 3 * w_new, QImage.Format_RGB888)
qpix_warp = QPixmap(qimg_warp)
qp.drawPixmap(
self.offset_w + x_min,
self.offset_h + y_min,
w_new,
h_new,
qpix_warp,
)
'''
for i, pos in enumerate(self.line_order):
j = (i + 1) % 4
y, x = self.cps[pos]
y = y + self.offset_h
x = x + self.offset_w
y_next, x_next = self.cps[self.line_order[j]]
y_next = y_next + self.offset_h
x_next = x_next + self.offset_w
qp.drawLine(x, y, x_next, y_next)
'''
center_y = self.offset_h + self.img_h // 2
center_x = self.offset_w + self.img_w // 2
pen_blue = QPen(Qt.blue, 5)
pen_white = QPen(Qt.white, 10)
text_size = 20
#brush = QBrush(Qt.red, Qt.SolidPattern)
#qp.setBrush(brush)
for key, val in self.cps.items():
y, x = val
y = y + self.offset_h
x = x + self.offset_w
qp.setPen(pen_blue)
#qp.drawEllipse(x, y, 3, 3)
qp.drawPoint(x, y)
qp.setPen(pen_white)
dy = y - center_y
dx = x - center_x
dl = math.sqrt(dy**2 + dx**2) / 10
qp.drawText(
x + (dx / dl) - text_size // 2,
y + (dy / dl) - text_size // 2,
text_size,
text_size,
int(Qt.AlignCenter),
key,
)
qp.end()
return
def paintEvent(self, e):
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.drawPixmap(0, 0, self.width(), self.height(), self.pix)
def paintEvent(self, event):
painter = QPainter(self)
if not self.estado_botao:
painter.drawPixmap(event.rect(), self.pixmap)
else:
painter.drawPixmap(event.rect(), self.hover_pixmap)
def draw_icon(icon, rect, painter, icon_mode, shadow=False):
cache = icon.pixmap(rect.size())
dip_offset = QPoint(1, -2)
cache = QPixmap()
pixname = "icon {0} {1} {2}".format(icon.cacheKey(), icon_mode,
rect.height())
if QPixmapCache.find(pixname) is None:
pix = icon.pixmap(rect.size())
device_pixel_ratio = pix.devicePixelRatio()
radius = 3 * device_pixel_ratio
offset = dip_offset * device_pixel_ratio
cache = QPixmap(pix.size() + QSize(radius * 2, radius * 2))
cache.fill(Qt.transparent)
cache_painter = QPainter(cache)
if icon_mode == QIcon.Disabled:
im = pix.toImage().convertToFormat(QImage.Format_ARGB32)
for y in range(0, im.height()):
scanline = im.scanLine(y)
for x in range(0, im.width()):
pixel = scanline
intensity = qGray(pixel)
scanline = qRgba(intensity, intensity, intensity,
qAlpha(pixel))
scanline += 1
pix = QPixmap.fromImage(im)
# Draw shadow
tmp = QImage(pix.size() + QSize(radius * 2, radius * 2),
QImage.Format_ARGB32_Premultiplied)
tmp.fill(Qt.transparent)
tmp_painter = QPainter(tmp)
tmp_painter.setCompositionMode(QPainter.CompositionMode_Source)
tmp_painter.drawPixmap(
QRect(radius, radius, pix.width(), pix.height()), pix)
tmp_painter.end()
# Blur the alpha channel
blurred = QImage(tmp.size(), QImage.Format_ARGB32_Premultiplied)
blur_painter = QPainter(blurred)
blur_painter.end()
# tmp = blurred
tmp_painter.begin(tmp)
tmp_painter.setCompositionMode(QPainter.CompositionMode_SourceIn)
tmp_painter.fillRect(tmp.rect(), QColor(0, 0, 0, 150))
tmp_painter.end()
tmp_painter.begin(tmp)
tmp_painter.setCompositionMode(QPainter.CompositionMode_SourceIn)
tmp_painter.fillRect(tmp.rect(), QColor(0, 0, 0, 150))
tmp_painter.end()
# Draw the blurred drop shadow
cache_painter.drawImage(
QRect(0, 0,
cache.rect().width(),
cache.rect().height()), tmp)
# Draw the actual pixmap
cache_painter.drawPixmap(
QRect(
QPoint(radius, radius) + offset,
QSize(pix.width(), pix.height())), pix)
cache_painter.end()
cache.setDevicePixelRatio(device_pixel_ratio)
QPixmapCache.insert(pixname, cache)
target_rect = cache.rect()
target_rect.setSize(target_rect.size() / cache.devicePixelRatio())
target_rect.moveCenter(rect.center() - dip_offset)
painter.drawPixmap(target_rect, cache)
def paintEvent(self, event):
painter = QPainter(self)
# 在指定区域直接绘制窗口背景
painter.drawPixmap(
0, 0, self.pix.width(), self.pix.height(),
QPixmap("06_图形和特效/示例内容/sources/python-color-128.png"))
def paintEvent(self, event):
painter = QPainter(self)
painter.setOpacity(self.pixmap_opacity)
painter.drawPixmap(0, 0, self.old_pixmap)
def compose_overlay():
painter = QPainter(self.map)
painter.drawPixmap(rect, self.overlay)
def paintEvent(self, event):
# Init painter.
painter = QPainter(self)
painter.save()
# Draw background.
background_color = self.background_color
if self.inverted_mode: # change color of background if inverted mode is enable
background_color = QColor(20, 20, 20, 255)
painter.setBrush(background_color)
painter.setPen(background_color)
painter.drawRect(0, 0, self.rect().width(), self.rect().height())
# Get start/last render index.
start_page_index = self.get_start_page_index()
last_page_index = self.get_last_page_index()
# Translate painter at y coordinate.
translate_y = (start_page_index * self.scale *
self.page_height) - self.scroll_offset
painter.translate(0, translate_y)
# Render pages in visible area.
for index in list(range(start_page_index, last_page_index)):
if index < self.page_total_number:
# Get page image.
qpixmap = self.get_page_pixmap(index, self.scale)
# Init render rect.
render_width = self.page_width * self.scale
render_height = self.page_height * self.scale
render_x = (self.rect().width() - render_width) / 2
render_y = (index -
start_page_index) * self.scale * self.page_height
# Add padding between pages.
if (index - start_page_index) > 0:
painter.translate(0, self.page_padding)
# Draw page image.
painter.drawPixmap(
QRect(render_x, render_y, render_width, render_height),
qpixmap)
# Clean unused pixmap cache that avoid use too much memory.
self.clean_unused_page_cache_pixmap()
painter.restore()
# Render current page.
painter.setFont(self.font)
if self.inverted_mode:
painter.setPen(self.page_annotate_dark_color)
else:
painter.setPen(self.page_annotate_light_color)
painter.drawText(
QRect(
self.rect().x(),
self.rect().y() + self.rect().height() -
self.page_annotate_height - self.page_annotate_padding_bottom,
self.rect().width() - self.page_annotate_padding_right,
self.page_annotate_height), Qt.AlignRight,
"{0}% ({1}/{2})".format(
int((start_page_index + 1) * 100 / self.page_total_number),
start_page_index + 1, self.page_total_number))
def paintEvent(self, event):
painter = QPainter(self)
pixmap = QPixmap("607.jpg")
painter.setOpacity(0.60)
painter.drawPixmap(self.rect(), pixmap)
def paintEvent(self, event):
# Initializing QPainter
qp = QPainter()
qp.begin(self)
qp.setRenderHint(QPainter.Antialiasing)
button_rect = self.geometry()
# Check if hovered or pressed
color_outline = self.color_outline_normal
color_border = self.color_border_normal
color_shadow = self.color_shadow_normal
color_glass = self.color_glass_normal
if self.isEnabled():
if self.hovered:
color_outline = self.color_outline_highlight
color_border = self.color_border_highlight
color_shadow = self.color_shadow_highlight
color_glass = self.color_glass_highlight
if self.pressed:
color_outline = self.color_outline_pressed
color_border = self.color_border_pressed
color_shadow = self.color_shadow_pressed
color_glass = self.color_glass_pressed
else:
color_border = QColor(50, 50, 50)
color_shadow = QColor(50, 50, 50)
color_glass = QColor(0, 0, 0, 0)
# Button outline
qp.setPen(QPen(QBrush(color_outline), 2.0))
outline = QPainterPath()
outline.addRoundedRect(0, 0, button_rect.width(
), button_rect.height(), self.roundness, self.roundness)
qp.setOpacity(self.opacity)
qp.drawPath(outline)
# Gradient
gradient = QLinearGradient(0, 0, 0, button_rect.height())
gradient.setColorAt(0.0, color_border)
gradient.setColorAt(0.4, color_shadow)
gradient.setColorAt(0.6, color_shadow)
gradient.setColorAt(1.0, color_border)
qp.setBrush(QBrush(gradient))
qp.setPen(QPen(QBrush(color_border), 2.0))
# Main button
qppath = QPainterPath()
qppath.addRoundedRect(1, 1, button_rect.width(
) - 2, button_rect.height() - 2, self.roundness, self.roundness)
qp.setClipPath(qppath)
qp.setOpacity(self.opacity)
qp.drawRoundedRect(1, 1, button_rect.width(
) - 2, button_rect.height() - 2, self.roundness, self.roundness)
# Glass highlight
qp.setBrush(QBrush(color_glass))
qp.setPen(QPen(QBrush(color_glass), 0.01))
qp.setOpacity(1)
qp.drawRect(1, 1, button_rect.width() - 2,
(button_rect.height() / 2) - 2)
# Text
if self.text():
qp.setFont(self.font())
qp.setPen(self.color_text)
qp.setOpacity(1.0)
qp.drawText(QRect(0, 0, button_rect.width(),
button_rect.height()), self.textAlign, self.text())
# Icon
if self.icon():
qp.setOpacity(1.0)
qp.drawPixmap(self.iconPosition(), QPixmap(
self.icon().pixmap(self.iconSize())))
qp.end()
