def paint(self,
painter: QPainter,
option: 'QStyleOptionGraphicsItem',
widget: Optional[QWidget] = ...) -> None:
# content
rect = self.rect()
path_content = QPainterPath()
path_content.setFillRule(Qt.WindingFill)
path_content.addRoundedRect(rect, self.edge_roundness,
self.edge_roundness)
painter.setPen(Qt.NoPen)
painter.setBrush(self._brush_background)
painter.drawPath(path_content.simplified())
# outline
path_outline = QPainterPath()
path_outline.addRoundedRect(rect, self.edge_roundness,
self.edge_roundness)
painter.setPen(
self._pen_default if not self.isSelected() else self._pen_selected)
painter.setBrush(Qt.NoBrush)
painter.drawPath(path_outline.simplified())
for handle in self.handles.values():
path_handle = QPainterPath()
path_handle.addRect(handle)
painter.drawPath(path_handle)
def drawValue(self, p: QPainter, baseRect: QRectF, value: float, delta: float):
if value == self.m_min:
return
if self.m_barStyle == self.BarStyle.EXPAND:
p.setBrush(self.palette().highlight())
p.setPen(QPen(self.palette().shadow().color(), self.m_dataPenWidth))
radius = (baseRect.height() / 2) / delta
p.drawEllipse(baseRect.center(), radius, radius)
return
if self.m_barStyle == self.BarStyle.LINE:
p.setPen(QPen(self.palette().highlight().color(), self.m_dataPenWidth))
p.setBrush(Qt.NoBrush)
if value == self.m_max:
p.drawEllipse(baseRect.adjusted(self.m_outlinePenWidth / 2, self.m_outlinePenWidth / 2,
-self.m_outlinePenWidth / 2, -self.m_outlinePenWidth / 2))
else:
arcLength = 360 / delta
p.drawArc(baseRect.adjusted(self.m_outlinePenWidth / 2, self.m_outlinePenWidth / 2,
-self.m_outlinePenWidth / 2, -self.m_outlinePenWidth / 2),
int(self.m_nullPosition * 16),
int(-arcLength * 16))
return
dataPath = QPainterPath()
dataPath.setFillRule(Qt.WindingFill)
if value == self.m_max:
dataPath.addEllipse(baseRect)
else:
arcLength = 360 / delta
dataPath.moveTo(baseRect.center())
dataPath.arcTo(baseRect, self.m_nullPosition, -arcLength)
dataPath.lineTo(baseRect.center())
p.setBrush(self.palette().highlight())
p.setPen(QPen(self.palette().shadow().color(), self.m_dataPenWidth))
p.drawPath(dataPath)
def shape(self, object):
path = QPainterPath()
if (not object.cell().isEmpty()):
path.addRect(self.boundingRect(object))
else:
x = object.shape()
if x == MapObject.Rectangle:
bounds = object.bounds()
if (bounds.isNull()):
path.addEllipse(bounds.topLeft(), 20, 20)
else:
path.addRoundedRect(bounds, 10, 10)
elif x == MapObject.Polygon or x == MapObject.Polyline:
pos = object.position()
polygon = object.polygon().translated(pos)
screenPolygon = self.pixelToScreenCoords_(polygon)
if (object.shape() == MapObject.Polygon):
path.addPolygon(screenPolygon)
else:
for i in range(1, screenPolygon.size()):
path.addPolygon(
self.lineToPolygon(screenPolygon[i - 1],
screenPolygon[i]))
path.setFillRule(Qt.WindingFill)
elif x == MapObject.Ellipse:
bounds = object.bounds()
if (bounds.isNull()):
path.addEllipse(bounds.topLeft(), 20, 20)
else:
path.addEllipse(bounds)
return path
def paint(self, painter, option, widget=None):
# title
path_title = QPainterPath()
path_title.setFillRule(Qt.WindingFill)
path_title.addRoundedRect(0, 0, self.width, self.title_height, self.edge_size, self.edge_size)
path_title.addRect(0, self.title_height - self.edge_size, self.edge_size, self.edge_size)
path_title.addRect(self.width - self.edge_size, self.title_height - self.edge_size,
self.edge_size, self.edge_size)
painter.setPen(Qt.NoPen)
painter.setBrush(self._title_brush)
painter.drawPath(path_title.simplified())
# content
path_content = QPainterPath()
path_content.setFillRule(Qt.WindingFill)
path_content.addRoundedRect(0, self.title_height, self.width, self.height - self.title_height,
self.edge_size, self.edge_size)
path_content.addRect(0, self.title_height, self.edge_size, self.edge_size)
path_content.addRect(self.width - self.edge_size, self.title_height, self.edge_size, self.edge_size)
painter.setPen(Qt.NoPen)
painter.setBrush(self._background_brush)
painter.drawPath(path_content.simplified())
# outline
path_outline = QPainterPath()
path_outline.addRoundedRect(0, 0, self.width, self.height, self.edge_size, self.edge_size)
painter.setPen(self._pen_default if not self.isSelected() else self._pen_selected)
painter.setBrush(Qt.NoBrush)
painter.drawPath(path_outline.simplified())
def drawGlyph(self,
scene,
glyph,
offsetX=0,
offsetY=0,
color=(255, 255, 255)):
path = QPainterPath()
path.setFillRule(Qt.WindingFill)
for c in self.decomposedPaths(glyph):
segs = c.segments
path.moveTo(segs[-1].points[-1].x, segs[-1].points[-1].y)
for seg in segs:
tuples = [(a.x, a.y) for a in seg.points]
flattuples = list(sum(tuples, ()))
if len(tuples) == 2:
path.quadTo(*flattuples)
elif len(tuples) == 3:
path.cubicTo(*flattuples)
else:
path.lineTo(*flattuples)
line = QGraphicsPathItem()
line.setBrush(QColor(*color))
p = QPen()
p.setStyle(Qt.NoPen)
line.setPen(p)
line.setPath(path)
reflect = QTransform(1, 0, 0, -1, 0, 0)
reflect.translate(offsetX, offsetY)
# print(f"Drawing {glyph} at offset {offsetX} {offsetY}")
line.setTransform(reflect)
scene.addItem(line)
class ModCrossButton(QPushButton):
def __init__(self,parent,path=None):
QPushButton.__init__(self,parent)
self.parent=parent
#self.setAttribute(Qt.WA_TranslucentBackground, True)
self.backgroundColor = QPalette().light().color()
self.backgroundColor.setRgb(157,157,157) #(220,203,231)
#self.backgroundColor.setAlpha(100)
self.brush=QBrush(Qt.SolidPattern)
def paintEvent(self,event):
self.wide=self.width()
self.high=self.height()
self.xdis=self.wide/7
self.ydis=self.xdis
self.path=QPainterPath()
self.path.setFillRule(Qt.OddEvenFill)
self.path.moveTo(self.wide/2, self.high/2-self.xdis)
self.path.arcTo(0,0, self.wide, self.high,0,360)
#self.path.closeSubpath()
self.path.moveTo(self.wide/2-self.xdis/2, self.ydis)
self.path.lineTo(self.wide/2-self.xdis/2, self.high/2-self.xdis/2)
self.path.lineTo(self.ydis, self.high/2-self.xdis/2)
self.path.lineTo(self.ydis, self.high/2+self.xdis/2)
self.path.lineTo(self.wide/2-self.xdis/2, self.high/2+self.xdis/2)
self.path.lineTo(self.wide/2-self.xdis/2, self.high-self.ydis)
self.path.lineTo(self.wide/2+self.xdis/2, self.high-self.ydis)
self.path.lineTo(self.wide/2+self.xdis/2, self.high/2+self.xdis/2)
self.path.lineTo(self.wide-self.ydis, self.high/2+self.xdis/2)
self.path.lineTo(self.wide-self.ydis, self.high/2-self.xdis/2)
self.path.lineTo(self.wide/2+self.xdis/2, self.high/2-self.xdis/2)
self.path.lineTo(self.wide/2+self.xdis/2, self.ydis)
self.path.closeSubpath()
self.brush.setColor(self.backgroundColor)
self.painter=QPainter(self)
self.painter.setRenderHint(QPainter.Antialiasing)
self.painter.setPen(Qt.NoPen)
self.painter.setBrush(self.brush)
self.painter.drawPath(self.path)
self.painter.end()
#def mousePressEvent(self,ev):
# self.parent.close()
def enterEvent(self,ev):
self.backgroundColor.setRgb(242,146,52)
self.update()
def leaveEvent(self,ev):
self.backgroundColor.setRgb(157,157,157)
self.update()
def shape(self, object):
path = QPainterPath()
if (not object.cell().isEmpty()):
path.addRect(self.boundingRect(object))
else:
x = object.shape()
if x==MapObject.Rectangle:
bounds = object.bounds()
if (bounds.isNull()):
path.addEllipse(bounds.topLeft(), 20, 20)
else:
path.addRoundedRect(bounds, 10, 10)
elif x==MapObject.Polygon or x==MapObject.Polyline:
pos = object.position()
polygon = object.polygon().translated(pos)
screenPolygon = self.pixelToScreenCoords_(polygon)
if (object.shape() == MapObject.Polygon):
path.addPolygon(screenPolygon)
else:
for i in range(1, screenPolygon.size()):
path.addPolygon(self.lineToPolygon(screenPolygon[i - 1],
screenPolygon[i]))
path.setFillRule(Qt.WindingFill)
elif x==MapObject.Ellipse:
bounds = object.bounds()
if (bounds.isNull()):
path.addEllipse(bounds.topLeft(), 20, 20)
else:
path.addEllipse(bounds)
return path
def paintEvent(self, event):
super(FramelessWindow, self).paintEvent(event)
m = 9
path = QPainterPath()
path.setFillRule(Qt.WindingFill)
path.addRect(m, m, self.width() - m * 2, self.height() - m * 2)
painter = QPainter(self)
painter.fillPath(path, QBrush(Qt.white))
color = QColor(100, 100, 100, 100)
for i in range(m):
path = QPainterPath()
path.setFillRule(Qt.WindingFill)
path.addRoundedRect(m - i, m - i,
self.width() - (m - i) * 2,
self.height() - (m - i) * 2, 1, 1)
color.setAlpha(100 - 10 * i)
painter.setPen(QPen(color, 1, Qt.SolidLine))
painter.drawRoundedRect(
QRect(m - i, m - i,
self.width() - (m - i) * 2,
self.height() - (m - i) * 2), 0, 0)
def getRoundedRectPath(self, i, yTranslation, side):
rect = QRect(self.ioList[i][0], self.ioList[i][1] + yTranslation,
self.ioWidth, self.ioHeight, 2, 2)
path = QPainterPath()
path.setFillRule(Qt.WindingFill)
path.addRoundedRect(self.ioList[i][0],
self.ioList[i][1] + yTranslation, self.ioWidth,
self.ioHeight, 2, 2)
#Remove rounded edges on left or right side
if side == 'left':
path.addRect(self.ioList[i][0], self.ioList[i][1] + yTranslation,
2, 2)
path.addRect(self.ioList[i][0],
self.ioList[i][1] + yTranslation + self.ioHeight - 2,
2, 2)
else:
path.addRect(self.ioList[i][0] + self.ioWidth - 2,
self.ioList[i][1] + yTranslation, 2, 2)
path.addRect(self.ioList[i][0] + self.ioWidth - 2,
self.ioList[i][1] + yTranslation + self.ioHeight - 2,
2, 2)
return path
def paintEvent(self, event):
# 设置阴影
painter_path = QPainterPath()
painter_path.setFillRule(Qt.WindingFill)
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.fillPath(painter_path, QBrush(Qt.white))
# 阴影颜色
color = QColor(0, 250, 255, 50)
for i in range(10):
i_path = QPainterPath()
i_path.setFillRule(Qt.WindingFill)
ref = QRectF(10 - i, 10 - i,
self.width() - (10 - i) * 2,
self.height() - (10 - i) * 2)
i_path.addRoundedRect(ref, 20, 20)
color.setAlpha(150 - i**0.5 * 50.0)
painter.setPen(color)
painter.drawPath(i_path)
# 圆角
painter_rect = QPainter(self)
painter_rect.setRenderHint(QPainter.Antialiasing) # 抗锯齿
color_bg = QColor(170, 248, 248, 240) # 设置背警色
painter_rect.setBrush(color_bg)
painter_rect.setPen(Qt.transparent)
self._rect = self.rect()
self._rect.setLeft(15)
self._rect.setTop(15)
self._rect.setWidth(self._rect.width() - 15)
self._rect.setHeight(self._rect.height() - 15)
painter_rect.drawRoundedRect(self._rect, 15, 15)
def fancyPath(self,pline,thickness): fancyLine = pline.fancy_curve(samples_per=24, thicknesses=thickness) fancyPath = QPainterPath() fancyPath.setFillRule(1) # fancyPath.moveTo(float(fancyLine.vertices[0][0]), float(fancyLine.vertices[0][1])) for i in fancyLine.vertices[1:]: fancyPath.lineTo(float(i[0]),float(i[1])) return fancyPath
class TaxiRouteItem(QGraphicsItem): ''' Draws a set of edges that turn on/off together, each possibly labelled. Call prepareGeometryChange after building to initialise correctly. ''' def __init__(self, parentItem, segments, colour): QGraphicsItem.__init__(self, parent=parentItem) self.colour_name = colour self.shape = QPainterPath() self.labels = QGraphicsItemGroup(self) self.bbox = QRectF(0, 0, 0, 0) for (p1, p2), label in segments: lvect = QVector2D(p2 - p1) lpath = QPainterPath() m = TWY_line_margin l = lvect.length() plst = [QPointF(-m, 0), QPointF(-m/3, -m), QPointF(l + m/3, -m), QPointF(l + m, 0), QPointF(l + m/3, m), QPointF(-m/3, m)] lpath.addPolygon(QPolygonF(plst)) lrot = QTransform() lrot.rotateRadians(atan2(lvect.y(), lvect.x())) lpath = lrot.map(lpath) lpath.translate(p1) self.shape.addPath(lpath) rect = QRectF(p1, p2).normalized() if label != None: self.labels.addToGroup(TaxiwayLabelItem(label, rect.center(), self)) self.bbox |= rect self.shape.setFillRule(Qt.WindingFill) self.mouse_highlight = False self.labels.setVisible(False) def hoverEnterEvent(self, event): self.mouse_highlight = self.scene().mouseover_highlights_groundnet_edges if self.mouse_highlight and not self.labels.isVisible(): self.labels.setVisible(True) self.setVisible(False) self.setVisible(True) def hoverLeaveEvent(self, event): self.mouse_highlight = False self.labels.setVisible(self.scene().show_taxiway_names) self.setVisible(False) self.setVisible(True) def boundingRect(self): return withMargins(self.bbox, TWY_line_margin) def shape(self): return self.shape def paint(self, painter, option, widget): if self.mouse_highlight or self.scene().show_ground_networks: painter.setPen(QPen(Qt.NoPen)) brushcol = settings.colour(self.colour_name) brushcol.setAlpha(96 if self.mouse_highlight else 64) painter.setBrush(QBrush(brushcol)) painter.drawPath(self.shape)
def triangle_pellet(self, painter: QPainter, pellet_size: float):
"""A pellet that is pointy and triangular (1st in logo)"""
pellet_size *= 1.5
pellet = QPainterPath()
pellet.setFillRule(Qt.WindingFill)
pellet.quadTo(0.9 * pellet_size, 0.5 * pellet_size, 0, pellet_size)
pellet.quadTo(-0.5 * pellet_size, 0.4 * pellet_size, 0, 0)
painter.drawPath(pellet)
def paint(self, painter, index):
widget = self.parent()
if index != widget.activeIndex():
return
scale = widget.inverseScale()
# metrics
if self._rulerObject is not None:
line, a = self._rulerObject
origin = line.p1()
cursor = line.p2()
size = 8 * scale
halfSize = 4 * scale
color = QColor(255, 85, 127, 170)
# line
painter.save()
painter.setPen(color)
drawing.drawLine(painter, origin.x(), origin.y(), cursor.x(),
cursor.y(), scale)
# ellipses
ellipses = [
(origin.x(), origin.y()),
(cursor.x(), cursor.y()),
]
path = QPainterPath()
path.setFillRule(Qt.WindingFill)
for x, y in itertools.chain(self._rulerPts.values(), ellipses):
x -= halfSize
y -= halfSize
path.addEllipse(x, y, size, size)
painter.fillPath(path, color)
painter.restore()
# text
line = QLineF(line)
xAlign = yAlign = "center"
ellipses.pop(0)
rp = self._rulerPts
# XXX: sort shouldn't be performed in paintEvent
for pt in itertools.chain((rp[k] for k in sorted(rp)), ellipses):
p = QPointF(*pt)
line.setP2(p)
if line.length():
d = str(round(line.length(), 1))
pos = (line.p1() + line.p2()) / 2
drawing.drawTextAtPoint(painter, d, pos.x(), pos.y(),
scale, xAlign, yAlign)
line.setP1(p)
xAlign, yAlign = "left", "top"
dx = cursor.x() - origin.x()
px = size
if dx < 0:
xAlign = "right"
px = -px
drawing.drawTextAtPoint(painter, a,
cursor.x() + px,
cursor.y() + size, scale, xAlign, yAlign)
def updateShape(self):
# Create the bezier curve path
srcX, srcY = self.srcSocket.linkConnectionPos()
dstX, dstY = self.dstSocket.linkConnectionPos()
linkPath = QPainterPath()
linkPath.setFillRule(Qt.WindingFill)
linkPath.moveTo(srcX, srcY)
linkPath.cubicTo(srcX + 100, srcY, dstX - 100, dstY, dstX, dstY)
self.setPath(linkPath)
def dip_pellet(self, painter: QPainter, pellet_size):
"""A pellet that has a dip in the middle (4th in the logo)."""
pellet_size *= 1.2
pellet = QPainterPath()
pellet.setFillRule(Qt.WindingFill)
for c in [1, -1]:
pellet.quadTo(c * pellet_size, pellet_size * 1.4, 0, pellet_size if c != -1 else 0)
painter.drawPath(pellet)
def g_start(self, M_start):
elements.regions.Polycurve.start(self.e, M_start)
path = QPainterPath()
path.setFillRule(Qt.WindingFill)
# set starting point
# Qt paths are relative to the first point of the region
path.moveTo(0, 0)
self.setPath(path)
# about to move the _G item
self.reset_move()
self.setPos(M_start.x, M_start.y)
def round_pellet(self, painter: QPainter, pellet_size):
"""A pellet that is round but not a circle (3rd in the logo)."""
pellet_size *= 1.3
pellet = QPainterPath()
pellet.setFillRule(Qt.WindingFill)
for c in [1, -1]:
pellet.quadTo(c * pellet_size * 0.8, pellet_size * 0.9, 0, pellet_size if c != -1 else 0)
painter.drawPath(pellet)
def _dbgRingShape(self, p):
r, R, = self.boundings()
opath = QPainterPath()
opath.setFillRule(Qt.WindingFill)
opath.addEllipse(-R, -R, 2*R, 2*R)
ipath = QPainterPath()
ipath.setFillRule(Qt.WindingFill)
ipath.addEllipse(-r, -r, 2*r, 2*r)
p.fillPath(opath.subtracted(ipath), QColor(255, 255, 0, 50))
p.strokePath(opath.simplified(), QPen(Qt.black, 3))
p.strokePath(ipath, QPen(Qt.black, 1))
def setupShapes(self):
truck = QPainterPath()
truck.setFillRule(Qt.WindingFill)
truck.moveTo(0.0, 87.0)
truck.lineTo(0.0, 60.0)
truck.lineTo(10.0, 60.0)
truck.lineTo(35.0, 35.0)
truck.lineTo(100.0, 35.0)
truck.lineTo(100.0, 87.0)
truck.lineTo(0.0, 87.0)
truck.moveTo(17.0, 60.0)
truck.lineTo(55.0, 60.0)
truck.lineTo(55.0, 40.0)
truck.lineTo(37.0, 40.0)
truck.lineTo(17.0, 60.0)
truck.addEllipse(17.0, 75.0, 25.0, 25.0)
truck.addEllipse(63.0, 75.0, 25.0, 25.0)
clock = QPainterPath()
clock.addEllipse(-50.0, -50.0, 100.0, 100.0)
clock.addEllipse(-48.0, -48.0, 96.0, 96.0)
clock.moveTo(0.0, 0.0)
clock.lineTo(-2.0, -2.0)
clock.lineTo(0.0, -42.0)
clock.lineTo(2.0, -2.0)
clock.lineTo(0.0, 0.0)
clock.moveTo(0.0, 0.0)
clock.lineTo(2.732, -0.732)
clock.lineTo(24.495, 14.142)
clock.lineTo(0.732, 2.732)
clock.lineTo(0.0, 0.0)
house = QPainterPath()
house.moveTo(-45.0, -20.0)
house.lineTo(0.0, -45.0)
house.lineTo(45.0, -20.0)
house.lineTo(45.0, 45.0)
house.lineTo(-45.0, 45.0)
house.lineTo(-45.0, -20.0)
house.addRect(15.0, 5.0, 20.0, 35.0)
house.addRect(-35.0, -15.0, 25.0, 25.0)
text = QPainterPath()
font = QFont()
font.setPixelSize(50)
fontBoundingRect = QFontMetrics(font).boundingRect("Qt")
text.addText(-QPointF(fontBoundingRect.center()), font, "Qt")
self.shapes = (clock, house, text, truck)
self.shapeComboBox.activated.connect(self.shapeSelected)
def setupShapes(self):
truck = QPainterPath()
truck.setFillRule(Qt.WindingFill)
truck.moveTo(0.0, 87.0)
truck.lineTo(0.0, 60.0)
truck.lineTo(10.0, 60.0)
truck.lineTo(35.0, 35.0)
truck.lineTo(100.0, 35.0)
truck.lineTo(100.0, 87.0)
truck.lineTo(0.0, 87.0)
truck.moveTo(17.0, 60.0)
truck.lineTo(55.0, 60.0)
truck.lineTo(55.0, 40.0)
truck.lineTo(37.0, 40.0)
truck.lineTo(17.0, 60.0)
truck.addEllipse(17.0, 75.0, 25.0, 25.0)
truck.addEllipse(63.0, 75.0, 25.0, 25.0)
clock = QPainterPath()
clock.addEllipse(-50.0, -50.0, 100.0, 100.0)
clock.addEllipse(-48.0, -48.0, 96.0, 96.0)
clock.moveTo(0.0, 0.0)
clock.lineTo(-2.0, -2.0)
clock.lineTo(0.0, -42.0)
clock.lineTo(2.0, -2.0)
clock.lineTo(0.0, 0.0)
clock.moveTo(0.0, 0.0)
clock.lineTo(2.732, -0.732)
clock.lineTo(24.495, 14.142)
clock.lineTo(0.732, 2.732)
clock.lineTo(0.0, 0.0)
house = QPainterPath()
house.moveTo(-45.0, -20.0)
house.lineTo(0.0, -45.0)
house.lineTo(45.0, -20.0)
house.lineTo(45.0, 45.0)
house.lineTo(-45.0, 45.0)
house.lineTo(-45.0, -20.0)
house.addRect(15.0, 5.0, 20.0, 35.0)
house.addRect(-35.0, -15.0, 25.0, 25.0)
text = QPainterPath()
font = QFont()
font.setPixelSize(50)
fontBoundingRect = QFontMetrics(font).boundingRect("Qt")
text.addText(-QPointF(fontBoundingRect.center()), font, "Qt")
self.shapes = (clock, house, text, truck)
self.shapeComboBox.activated.connect(self.shapeSelected)
def paint(self,
painter: QPainter,
option: 'QStyleOptionGraphicsItem',
widget: Optional[QWidget] = ...) -> None:
x = y = 0
path_title = QPainterPath()
path_title.setFillRule(Qt.WindingFill)
# Rectangle for title
path_title.addRoundedRect(x, y, self.width, self.title_height,
self.edge_roundness, self.edge_roundness)
path_title.addRect(x, y + self.title_height - self.edge_roundness,
self.edge_roundness, self.edge_roundness)
path_title.addRect(x + self.width - self.edge_roundness,
y + self.title_height - self.edge_roundness,
self.edge_roundness, self.edge_roundness)
painter.setPen(Qt.NoPen)
painter.setBrush(self._brush_title)
painter.drawPath(path_title.simplified())
# content
path_content = QPainterPath()
path_content.setFillRule(Qt.WindingFill)
path_content.addRoundedRect(x, y + self.title_height, self.width,
self.height - self.title_height,
self.edge_roundness, self.edge_roundness)
path_content.addRect(x, y + self.title_height, self.edge_roundness,
self.edge_roundness)
path_content.addRect(x + self.width - self.edge_roundness,
y + self.title_height, self.edge_roundness,
self.edge_roundness)
painter.setPen(Qt.NoPen)
painter.setBrush(self._brush_background)
painter.drawPath(path_content.simplified())
# outline
path_outline = QPainterPath()
path_outline.addRoundedRect(x, y, self.width, self.height,
self.edge_roundness, self.edge_roundness)
painter.setBrush(Qt.NoBrush)
if self._hovered:
painter.setPen(self._pen_hovered)
painter.drawPath(path_outline.simplified())
painter.setPen(self._pen_default)
painter.drawPath(path_outline.simplified())
else:
painter.setPen(self._pen_default
if not self.isSelected() else self._pen_selected)
painter.drawPath(path_outline.simplified())
def getRoundedRectPath(self, i, yTranslation, side):
path = QPainterPath();
path.setFillRule(Qt.WindingFill);
path.addRoundedRect(self.ioList[i][0], self.ioList[i][1] + yTranslation, self.ioWidth, self.ioHeight, 2, 2)
#Remove rounded edges on left or right side
if side == 'left':
path.addRect(self.ioList[i][0], self.ioList[i][1] + yTranslation, 2, 2)
path.addRect(self.ioList[i][0], self.ioList[i][1] + yTranslation + self.ioHeight - 2, 2, 2)
else:
path.addRect(self.ioList[i][0] + self.ioWidth - 2, self.ioList[i][1] + yTranslation, 2, 2)
path.addRect(self.ioList[i][0] + self.ioWidth - 2, self.ioList[i][1] + yTranslation + self.ioHeight - 2, 2, 2)
return path
def paint(self, painter, option, widget=None):
# content
path_content = QPainterPath()
path_content.setFillRule(Qt.WindingFill)
path_content.addEllipse(0, 0, self.width, self.height)
painter.setPen(Qt.NoPen)
brush = self._background_brush if self.has_input(
) or not self.node.is_linked() else self._disconnected_brush
painter.setBrush(brush)
painter.drawPath(path_content.simplified())
# outline
path_outline = QPainterPath()
path_outline.addEllipse(0, 0, self.width, self.height)
painter.setPen(
self._pen_default if not self.isSelected() else self._pen_selected)
painter.setBrush(Qt.NoBrush)
painter.drawPath(path_outline.simplified())
def _draw(self, painter: QPainter, width: int, height: int):
self.x = self.flower_center_x(width) * smoothen_curve(
self.get_age_coefficient())
self.y = self.flower_center_y(height) * smoothen_curve(
self.get_age_coefficient())
painter.setPen(
QPen(Color.green,
self.stem_width * smoothen_curve(self.get_age_coefficient())))
# draw the stem
path = QPainterPath()
path.quadTo(0, self.y * 0.6, self.x, self.y)
painter.drawPath(path)
# draw the leaves
for position, coefficient, rotation in self.leafs:
painter.save()
# find the point on the stem and rotate the leaf accordingly
painter.translate(path.pointAtPercent(position))
painter.rotate(degrees(rotation))
# rotate according to where the flower is leaning towards
if self.y != 0:
painter.rotate(-degrees(sin(self.x / self.y)))
# make it so both leaves are facing the same direction
if rotation < 0:
painter.scale(-1, 1)
painter.setBrush(QBrush(Color.green))
painter.setPen(QPen(0))
# draw the leaf
leaf = QPainterPath()
leaf.setFillRule(Qt.WindingFill)
ls = self.leaf_size(width) * smoothen_curve(
self.get_age_coefficient())**2 * coefficient
leaf.quadTo(0.4 * ls, 0.5 * ls, 0, ls)
leaf.cubicTo(0, 0.5 * ls, -0.4 * ls, 0.4 * ls, 0, 0)
painter.drawPath(leaf)
painter.restore()
def paintEvent(self, event):
painter = QPainter(self)
if self.rectArea.isNull():
# 窗口背景全部半透明颜色
return painter.fillRect(self.rect(), QColor(0, 0, 0, 50))
# 画外围背景,去掉中间绘制的矩形框
path = QPainterPath()
path.setFillRule(Qt.OddEvenFill)
path.addRect(QRectF(self.rect()))
path.addRect(QRectF(self.rectArea))
painter.fillPath(path, QColor(0, 0, 0, 50))
# 画矩形
painter.save()
painter.setPen(self.rectPen)
painter.drawRect(self.rectArea) # 画矩形框
# 背景用白色透明遮住,防止鼠标穿透到桌面
painter.fillRect(self.rectArea, QColor(255, 255, 255, 1))
painter.restore()
def drawObject(self, painter: 'QPainter', rect: QtCore.QRectF, doc: 'QTextDocument', pos_in_document: int,
format_: 'QTextFormat') -> None:
painter.setRenderHint(QPainter.Antialiasing, True)
c = QColor(255, 80, 0, 160)
painter.setBrush(QBrush(c, Qt.SolidPattern))
painter.setPen(QPen(QtCore.Qt.white, 2, QtCore.Qt.SolidLine))
tag_kind: TagKind = format_.property(TagTextObject.kind_propid)
top = rect.top()
left = rect.left()
width = rect.width()
height = rect.height()
square_size = rect.height() / 2
if tag_kind == TagKind.START:
path = QPainterPath()
path.setFillRule(Qt.WindingFill)
path.addRoundedRect(rect, 10, 10)
# QRectF(aleft: float, atop: float, awidth: float, aheight: float)
bottom_left_rect = QRectF(left, top + height - square_size, square_size, square_size)
path.addRoundedRect(bottom_left_rect, 2, 2) # Bottom left
top_left_rect = QRectF(left, top, square_size, square_size)
path.addRoundedRect(top_left_rect, 2, 2) # Top left
painter.drawPath(path.simplified())
elif tag_kind == TagKind.END:
path = QPainterPath()
path.setFillRule(Qt.WindingFill)
path.addRoundedRect(rect, 10, 10)
top_right_rect = QRectF((left + width) - square_size, top, square_size, square_size)
path.addRoundedRect(top_right_rect, 2, 2) # Top right
bottom_right_rect = QRectF((left + width) - square_size, top + height - square_size, square_size,
square_size)
path.addRoundedRect(bottom_right_rect, 2, 2) # Bottom right
painter.drawPath(path.simplified())
else:
painter.drawRoundedRect(rect, 4, 4)
tag_name = format_.property(TagTextObject.name_propid)
painter.drawText(rect, QtCore.Qt.AlignHCenter | QtCore.Qt.AlignCenter, tag_name)
def mouseMoveEvent(self, event):
super(GraphicsScene, self).mousePressEvent(event)
pos = event.scenePos()
if self.draw_switch == True \
and pos.x()>=0 \
and pos.x()<self.pixmapunderground.width() \
and pos.y()>=0 \
and pos.y()<self.pixmapunderground.height():
if self.lastpos is not None:
# show trace on the screen
path = QPainterPath()
path.setFillRule(Qt.WindingFill)
path.moveTo(self.lastpos)
path.lineTo(pos)
self.pathset.append(self.addPath(path, pen=QPen(Qt.white)))
self.poly.append(pos) # keep vertex for label generation later
self.lastpos = pos # update
def test_hash_path():
path_1 = QPainterPath()
path_1.lineTo(100, 200)
hash_1 = hashing.hash_path(path_1)
# Identical paths hash identically
path_2 = QPainterPath()
path_2.lineTo(100, 200)
hash_2 = hashing.hash_path(path_2)
assert hash_1 == hash_2
# Paths with different fill rules hash differently
path_3 = QPainterPath()
path_3.setFillRule(1) # WindingFill
path_3.lineTo(100, 200)
hash_3 = hashing.hash_path(path_3)
assert hash_1 != hash_3
# Paths with different elements hash differently
path_4 = QPainterPath()
path_4.lineTo(100, 200)
path_4.lineTo(123, 123)
hash_4 = hashing.hash_path(path_4)
assert hash_4 != hash_1
def paint(self, painter, option, widget=None):
# content
path_content = QPainterPath()
path_content.setFillRule(Qt.WindingFill)
polygon = QPolygonF()
polygon.append(QPoint(self.width * 0.5, 2))
polygon.append(QPoint(self.width - 2, self.height * 0.5))
polygon.append(QPoint(self.width * 0.5, self.height - 2))
polygon.append(QPoint(2, self.height * 0.5))
polygon.append(QPoint(self.width * 0.5, 2))
path_content.addPolygon(polygon)
painter.setPen(Qt.NoPen)
painter.setBrush(self._background_brush)
painter.drawPath(path_content.simplified())
# outline
path_outline = QPainterPath()
path_outline.addPolygon(polygon)
painter.setPen(
self._pen_default if not self.isSelected() else self._pen_selected)
painter.setBrush(Qt.NoBrush)
painter.drawPath(path_outline.simplified())
def paintEvent(self, event):
"""
重写paintEvent，实现边框阴影
:param event:
:return:
"""
path = QPainterPath()
path.setFillRule(Qt.WindingFill)
path.addRect(10, 10, self.width() - 20, self.height() - 20)
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing, True)
painter.fillPath(path, QBrush(Qt.white))
color = QColor(0, 0, 0, 50)
for i in range(0, 10):
path = QPainterPath()
path.setFillRule(Qt.WindingFill)
path.addRect(10 - i, 10 - i,
self.width() - (10 - i) * 2,
self.height() - (10 - i) * 2)
color.setAlpha(150 - math.sqrt(i) * 50)
painter.setPen(color)
painter.drawPath(path)
def paint(self, painter, QStyleOptionGraphicsItem, widget=None):
"""Overloaded QWidget paint method.
Draws the GUIFeedbackPopup on the scene.
Args:
painter: QWidget painter class.
QStyleOptionGraphicsItem: ??? (not used).
widget: The parent widget if there is one(not used).
Todo:
* Find out what QStyleOptionGraphicsItem is for.
"""
# content
path_content = QPainterPath()
path_content.setFillRule(Qt.WindingFill)
path_content.addRoundedRect(0, 0, self.__width, self.__height,
self.__edge_roundness,
self.__edge_roundness)
painter.setPen(Qt.NoPen)
painter.setBrush(self.__brush_background)
painter.drawPath(path_content.simplified())
# outline
path_outline = QPainterPath()
path_outline.addRoundedRect(0, 0, self.__width, self.__height,
self.__edge_roundness,
self.__edge_roundness)
# 9pt = 9px
# px max of 188 (188 - padding[8] = 180)
painter.setBrush(Qt.NoBrush)
painter.setPen(self.__pen_default)
painter.drawPath(path_outline.simplified())
# paint icon
painter.drawPixmap(QRectF(-12.5, -12.5, 24.0, 24.0), self.__icons,
QRectF(self.__icon_offset, 0, 24.0, 24.0))
def paint(self,
painter: QPainter,
option: 'QStyleOptionGraphicsItem',
widget: Optional[QWidget] = ...) -> None:
"""Paint the node as filled circle of radius equal to heigth / 2
Parameters
----------
painter : QPainter
option : QStyleOptionGraphicsItem
widget : QWidget
Returns
-------
None
"""
path_content = QPainterPath()
path_content.setFillRule(Qt.WindingFill)
painter.setPen(Qt.NoPen)
painter.setBrush(self._brush_background)
path_content.addEllipse(0, 0, 2 * self.radius, 2 * self.radius)
painter.drawPath(path_content)
# outline
path_outline = QPainterPath()
path_outline.addEllipse(0, 0, 2 * self.radius, 2 * self.radius)
painter.setBrush(Qt.NoBrush)
if self._hovered:
painter.setPen(self._pen_hovered)
painter.drawPath(path_outline.simplified())
painter.setPen(self._pen_default)
painter.drawPath(path_outline.simplified())
else:
painter.setPen(self._pen_default
if not self.isSelected() else self._pen_selected)
painter.drawPath(path_outline.simplified())
def paintEvent(self, event):
# 阴影
path = QPainterPath()
path.setFillRule(Qt.WindingFill)
pat = QPainter(self)
pat.setRenderHint(pat.Antialiasing)
pat.fillPath(path, QBrush(Qt.white))
color = QColor(0, 0, 0, 60)
for i in range(10):
i_path = QPainterPath()
i_path.setFillRule(Qt.WindingFill)
ref = QRectF(10 - i, 10 - i,
self.width() - (10 - i) * 2,
self.height() - (10 - i) * 2)
# i_path.addRect(ref)
i_path.addRoundedRect(ref, self.border_width, self.border_width)
color.setAlpha(150 - i**0.5 * 50)
pat.setPen(color)
pat.drawPath(i_path)
# 圆角
pat2 = QPainter(self)
pat2.setRenderHint(pat2.Antialiasing) # 抗锯齿
pat2.setBrush(Qt.white)
pat2.setPen(Qt.transparent)
rect = self.rect()
rect.setLeft(1)
rect.setTop(1)
rect.setRight(1)
rect.setBottom(1)
rect.setWidth(rect.width() - 2)
rect.setHeight(rect.height() - 2)
pat2.drawRoundedRect(rect, 4, 4)
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()
brush = QBrush(self.color1)
painter.setBrush(brush)
path = QPainterPath()
path.setFillRule(Qt.OddEvenFill)
path.moveTo(self.p1)
rect = QRectF(0, 0, a * 2, self.height())
path.arcTo(rect, 90, 180)
path.lineTo(self.p2)
path.lineTo(self.p3)
path.lineTo(self.p4)
path.moveTo(self.p5)
rect = QRectF(self.p5.x() - a, 0, a * 2, self.height())
path.arcTo(rect, 90, 180)
painter.drawPath(path)
painter.restore()
if self.p5 == self.p9:
return
brush = QBrush(self.color2)
painter.setBrush(brush)
path = QPainterPath()
path.setFillRule(Qt.OddEvenFill)
path.moveTo(self.p5)
rect = QRectF(self.p5.x() - a, 0, a * 2, self.height())
path.arcTo(rect, 90, 180)
path.lineTo(self.p6)
path.lineTo(self.p7)
path.lineTo(self.p8)
path.moveTo(self.p9)
rect = QRectF(self.p9.x() - a, 0, a * 2, self.height())
path.arcTo(rect, 90, 180)
painter.drawPath(path)
path = QPainterPath()
path.setFillRule(Qt.OddEvenFill)
path.moveTo(self.p1)
def paintEvent(self, event):
painter = QPainter(self)
visibleRect = event.rect()
columnCount = self._columnCount
extra = self._cellWidthExtra
cellWidth, cellHeight = self._cellWidth + 2 * extra, self._cellHeight
glyphCount = len(self._glyphs)
if columnCount:
paintWidth = min(glyphCount, columnCount) * cellWidth
else:
paintWidth = 0
left = 0
top = cellHeight
painter.fillRect(visibleRect, Qt.white)
for index, glyph in enumerate(self._glyphs):
t = top - cellHeight
rect = (left, t, cellWidth, cellHeight)
if visibleRect.intersects(visibleRect.__class__(*rect)):
if index in self._selection:
palette = self.palette()
active = palette.currentColorGroup() != QPalette.Inactive
opacityMultiplier = platformSpecific.colorOpacityMultiplier()
selectionColor = palette.color(QPalette.Highlight)
# TODO: alpha values somewhat arbitrary (here and in
# glyphLineView)
selectionColor.setAlphaF(
.2 * opacityMultiplier if active else .7)
painter.fillRect(QRectF(
left, t, cellWidth, cellHeight),
selectionColor)
pixmap = self._getCurrentRepresentation(glyph)
painter.drawPixmap(left, t, pixmap)
# XXX: this hacks around the repr internals
if index in self._selection and \
cellHeight >= GlyphCellMinHeightForHeader:
painter.fillRect(QRectF(
left, t + cellHeight - GlyphCellHeaderHeight,
cellWidth, GlyphCellHeaderHeight),
selectionColor)
left += cellWidth
if left + cellWidth > paintWidth:
left = 0
top += cellHeight
# drop insertion position
dropIndex = self._currentDropIndex
if dropIndex is not None:
if columnCount:
x = (dropIndex % columnCount) * cellWidth
y = (dropIndex // columnCount) * cellHeight
# special-case the end-column
if dropIndex == glyphCount and \
glyphCount < self.width() // self._cellWidth or \
self.mapFromGlobal(QCursor.pos()).y() < y:
x = columnCount * cellWidth
y -= cellHeight
else:
x = y = 0
path = QPainterPath()
path.addRect(x - 2, y, 3, cellHeight)
path.addEllipse(x - 5, y - 5, 9, 9)
path.addEllipse(x - 5, y + cellHeight - 5, 9, 9)
path.setFillRule(Qt.WindingFill)
pen = painter.pen()
pen.setColor(Qt.white)
pen.setWidth(2)
painter.setPen(pen)
painter.setRenderHint(QPainter.Antialiasing)
painter.drawPath(path)
painter.fillPath(path, insertionPositionColor)
def paint(self, painter, option, index):
assert isinstance(painter, QPainter)
if index.data(Qt.UserRole+1):
if app_constants.HIGH_QUALITY_THUMBS:
painter.setRenderHint(QPainter.SmoothPixmapTransform)
painter.setRenderHint(QPainter.Antialiasing)
gallery = index.data(Qt.UserRole+1)
title = gallery.title
artist = gallery.artist
title_color = app_constants.GRID_VIEW_TITLE_COLOR
artist_color = app_constants.GRID_VIEW_ARTIST_COLOR
label_color = app_constants.GRID_VIEW_LABEL_COLOR
# Enable this to see the defining box
#painter.drawRect(option.rect)
# define font size
if 20 > len(title) > 15:
title_size = "font-size:{}px;".format(self.font_size)
elif 30 > len(title) > 20:
title_size = "font-size:{}px;".format(self.font_size-1)
elif 40 > len(title) >= 30:
title_size = "font-size:{}px;".format(self.font_size-2)
elif 50 > len(title) >= 40:
title_size = "font-size:{}px;".format(self.font_size-3)
elif len(title) >= 50:
title_size = "font-size:{}px;".format(self.font_size-4)
else:
title_size = "font-size:{}px;".format(self.font_size)
if 30 > len(artist) > 20:
artist_size = "font-size:{}px;".format(self.font_size)
elif 40 > len(artist) >= 30:
artist_size = "font-size:{}px;".format(self.font_size-1)
elif len(artist) >= 40:
artist_size = "font-size:{}px;".format(self.font_size-2)
else:
artist_size = "font-size:{}px;".format(self.font_size)
#painter.setPen(QPen(Qt.NoPen))
#option.rect = option.rect.adjusted(11, 10, 0, 0)
option.rect.setWidth(self.W)
option.rect.setHeight(self.H)
rec = option.rect.getRect()
x = rec[0]
y = rec[1]
w = rec[2]
h = rec[3]
text_area = QTextDocument()
text_area.setDefaultFont(option.font)
text_area.setHtml("""
<head>
<style>
#area
{{
display:flex;
width:140px;
height:10px
}}
#title {{
position:absolute;
color: {4};
font-weight:bold;
{0}
}}
#artist {{
position:absolute;
color: {5};
top:20px;
right:0;
{1}
}}
</style>
</head>
<body>
<div id="area">
<center>
<div id="title">{2}
</div>
<div id="artist">{3}
</div>
</div>
</center>
</body>
""".format(title_size, artist_size, title, artist, title_color, artist_color))
text_area.setTextWidth(w)
#chapter_area = QTextDocument()
#chapter_area.setDefaultFont(option.font)
#chapter_area.setHtml("""
#<font color="black">{}</font>
#""".format("chapter"))
#chapter_area.setTextWidth(w)
def center_img(width):
new_x = x
if width < w:
diff = w - width
offset = diff//2
new_x += offset
return new_x
# if we can't find a cached image
pix_cache = QPixmapCache.find(self.key(gallery.profile))
if isinstance(pix_cache, QPixmap):
self.image = pix_cache
img_x = center_img(self.image.width())
if self.image.height() < self.image.width(): #to keep aspect ratio
painter.drawPixmap(QPoint(img_x,y),
self.image)
else:
painter.drawPixmap(QPoint(img_x,y),
self.image)
else:
self.image = QPixmap(gallery.profile)
img_x = center_img(self.image.width())
QPixmapCache.insert(self.key(gallery.profile), self.image)
if self.image.height() < self.image.width(): #to keep aspect ratio
painter.drawPixmap(QPoint(img_x,y),
self.image)
else:
painter.drawPixmap(QPoint(img_x,y),
self.image)
# draw star if it's favorited
if gallery.fav == 1:
painter.drawPixmap(QPointF(x,y), QPixmap(app_constants.STAR_PATH))
if app_constants._REFRESH_EXTERNAL_VIEWER:
if app_constants.USE_EXTERNAL_VIEWER:
self.external_icon = self.file_icons.get_external_file_icon()
else:
self.external_icon = self.file_icons.get_default_file_icon()
if gallery.state == self.G_DOWNLOAD:
painter.save()
dl_box = QRect(x, y, w, 20)
painter.setBrush(QBrush(QColor(0,0,0,123)))
painter.setPen(QColor('white'))
painter.drawRect(dl_box)
painter.drawText(dl_box, Qt.AlignCenter, 'Downloading...')
painter.restore()
else:
if app_constants.DISPLAY_GALLERY_TYPE:
self.type_icon = self.file_icons.get_file_icon(gallery.path)
if self.type_icon and not self.type_icon.isNull():
self.type_icon.paint(painter, QRect(x+2, y+app_constants.THUMB_H_SIZE-16, 16, 16))
if app_constants.USE_EXTERNAL_PROG_ICO:
if self.external_icon and not self.external_icon.isNull():
self.external_icon.paint(painter, QRect(x+w-30, y+app_constants.THUMB_H_SIZE-28, 28, 28))
def draw_text_label(lbl_h):
#draw the label for text
painter.save()
painter.translate(x, y+app_constants.THUMB_H_SIZE)
box_color = QBrush(QColor(label_color))#QColor(0,0,0,123))
painter.setBrush(box_color)
rect = QRect(0, 0, w, lbl_h) #x, y, width, height
painter.fillRect(rect, box_color)
painter.restore()
return rect
if option.state & QStyle.State_MouseOver or\
option.state & QStyle.State_Selected:
title_layout = self.text_layout(title, w, self.title_font, self.title_font_m)
artist_layout = self.text_layout(artist, w, self.artist_font, self.artist_font_m)
t_h = title_layout.boundingRect().height()
a_h = artist_layout.boundingRect().height()
if app_constants.GALLERY_FONT_ELIDE:
lbl_rect = draw_text_label(min(t_h+a_h+3, app_constants.GRIDBOX_LBL_H))
else:
lbl_rect = draw_text_label(app_constants.GRIDBOX_LBL_H)
clipping = QRectF(x, y+app_constants.THUMB_H_SIZE, w, app_constants.GRIDBOX_LBL_H - 10)
title_layout.draw(painter, QPointF(x, y+app_constants.THUMB_H_SIZE),
clip=clipping)
artist_layout.draw(painter, QPointF(x, y+app_constants.THUMB_H_SIZE+t_h),
clip=clipping)
#painter.fillRect(option.rect, QColor)
else:
if app_constants.GALLERY_FONT_ELIDE:
lbl_rect = draw_text_label(self.text_label_h)
else:
lbl_rect = draw_text_label(app_constants.GRIDBOX_LBL_H)
# draw text
painter.save()
alignment = QTextOption(Qt.AlignCenter)
alignment.setUseDesignMetrics(True)
title_rect = QRectF(0,0,w, self.title_font_m.height())
artist_rect = QRectF(0,self.artist_font_m.height(),w,
self.artist_font_m.height())
painter.translate(x, y+app_constants.THUMB_H_SIZE)
if app_constants.GALLERY_FONT_ELIDE:
painter.setFont(self.title_font)
painter.setPen(QColor(title_color))
painter.drawText(title_rect,
self.title_font_m.elidedText(title, Qt.ElideRight, w-10),
alignment)
painter.setPen(QColor(artist_color))
painter.setFont(self.artist_font)
alignment.setWrapMode(QTextOption.NoWrap)
painter.drawText(artist_rect,
self.title_font_m.elidedText(artist, Qt.ElideRight, w-10),
alignment)
else:
text_area.setDefaultFont(QFont(self.font_name))
text_area.drawContents(painter)
##painter.resetTransform()
painter.restore()
if option.state & QStyle.State_Selected:
painter.save()
selected_rect = QRectF(x, y, w, lbl_rect.height()+app_constants.THUMB_H_SIZE)
painter.setPen(Qt.NoPen)
painter.setBrush(QBrush(QColor(164,164,164,120)))
p_path = QPainterPath()
p_path.setFillRule(Qt.WindingFill)
p_path.addRoundedRect(selected_rect, 5,5)
p_path.addRect(x,y, 20, 20)
p_path.addRect(x+w-20,y, 20, 20)
painter.drawPath(p_path.simplified())
#painter.fillRect(selected_rect, QColor(164,164,164,120))
painter.restore()
#if option.state & QStyle.State_Selected:
# painter.setPen(QPen(option.palette.highlightedText().color()))
else:
super().paint(painter, option, index)
def paint(self, painter, option, index):
assert isinstance(painter, QPainter)
if index.data(Qt.UserRole+1):
if app_constants.HIGH_QUALITY_THUMBS:
painter.setRenderHint(QPainter.SmoothPixmapTransform)
painter.setRenderHint(QPainter.Antialiasing)
gallery = index.data(Qt.UserRole+1)
title = gallery.title
artist = gallery.artist
title_color = app_constants.GRID_VIEW_TITLE_COLOR
artist_color = app_constants.GRID_VIEW_ARTIST_COLOR
label_color = app_constants.GRID_VIEW_LABEL_COLOR
# Enable this to see the defining box
#painter.drawRect(option.rect)
# define font size
if 20 > len(title) > 15:
title_size = "font-size:{}px;".format(self.font_size)
elif 30 > len(title) > 20:
title_size = "font-size:{}px;".format(self.font_size-1)
elif 40 > len(title) >= 30:
title_size = "font-size:{}px;".format(self.font_size-2)
elif 50 > len(title) >= 40:
title_size = "font-size:{}px;".format(self.font_size-3)
elif len(title) >= 50:
title_size = "font-size:{}px;".format(self.font_size-4)
else:
title_size = "font-size:{}px;".format(self.font_size)
if 30 > len(artist) > 20:
artist_size = "font-size:{}px;".format(self.font_size)
elif 40 > len(artist) >= 30:
artist_size = "font-size:{}px;".format(self.font_size-1)
elif len(artist) >= 40:
artist_size = "font-size:{}px;".format(self.font_size-2)
else:
artist_size = "font-size:{}px;".format(self.font_size)
#painter.setPen(QPen(Qt.NoPen))
#option.rect = option.rect.adjusted(11, 10, 0, 0)
option.rect.setWidth(self.W)
option.rect.setHeight(self.H)
rec = option.rect.getRect()
x = rec[0]
y = rec[1]
w = rec[2]
h = rec[3]
text_area = QTextDocument()
text_area.setDefaultFont(option.font)
text_area.setHtml("""
<head>
<style>
#area
{{
display:flex;
width:{6}px;
height:{7}px
}}
#title {{
position:absolute;
color: {4};
font-weight:bold;
{0}
}}
#artist {{
position:absolute;
color: {5};
top:20px;
right:0;
{1}
}}
</style>
</head>
<body>
<div id="area">
<center>
<div id="title">{2}
</div>
<div id="artist">{3}
</div>
</div>
</center>
</body>
""".format(title_size, artist_size, title, artist, title_color, artist_color,
130+app_constants.SIZE_FACTOR, 1+app_constants.SIZE_FACTOR))
text_area.setTextWidth(w)
#chapter_area = QTextDocument()
#chapter_area.setDefaultFont(option.font)
#chapter_area.setHtml("""
#<font color="black">{}</font>
#""".format("chapter"))
#chapter_area.setTextWidth(w)
def center_img(width):
new_x = x
if width < w:
diff = w - width
offset = diff//2
new_x += offset
return new_x
def img_too_big(start_x):
txt_layout = misc.text_layout("Image is too big!", w, self.title_font, self.title_font_m)
clipping = QRectF(x, y+h//4, w, app_constants.GRIDBOX_LBL_H - 10)
txt_layout.draw(painter, QPointF(x, y+h//4),
clip=clipping)
# if we can't find a cached image
pix_cache = QPixmapCache.find(self.key(gallery.profile))
if isinstance(pix_cache, QPixmap):
self.image = pix_cache
img_x = center_img(self.image.width())
if self.image.width() > w or self.image.height() > h:
img_too_big(img_x)
else:
if self.image.height() < self.image.width(): #to keep aspect ratio
painter.drawPixmap(QPoint(img_x,y),
self.image)
else:
painter.drawPixmap(QPoint(img_x,y),
self.image)
else:
self.image = QPixmap(gallery.profile)
img_x = center_img(self.image.width())
QPixmapCache.insert(self.key(gallery.profile), self.image)
if self.image.width() > w or self.image.height() > h:
img_too_big(img_x)
else:
if self.image.height() < self.image.width(): #to keep aspect ratio
painter.drawPixmap(QPoint(img_x,y),
self.image)
else:
painter.drawPixmap(QPoint(img_x,y),
self.image)
# draw ribbon type
painter.save()
painter.setPen(Qt.NoPen)
if app_constants.DISPLAY_GALLERY_RIBBON:
type_ribbon_w = type_ribbon_l = w*0.11
rib_top_1 = QPointF(x+w-type_ribbon_l-type_ribbon_w, y)
rib_top_2 = QPointF(x+w-type_ribbon_l, y)
rib_side_1 = QPointF(x+w, y+type_ribbon_l)
rib_side_2 = QPointF(x+w, y+type_ribbon_l+type_ribbon_w)
ribbon_polygon = QPolygonF([rib_top_1, rib_top_2, rib_side_1, rib_side_2])
ribbon_path = QPainterPath()
ribbon_path.setFillRule(Qt.WindingFill)
ribbon_path.addPolygon(ribbon_polygon)
ribbon_path.closeSubpath()
painter.setBrush(QBrush(QColor(self._ribbon_color(gallery.type))))
painter.drawPath(ribbon_path)
# draw if favourited
if gallery.fav == 1:
star_ribbon_w = star_ribbon_l = w*0.08
rib_top_1 = QPointF(x+star_ribbon_l, y)
rib_side_1 = QPointF(x, y+star_ribbon_l)
rib_top_2 = QPointF(x+star_ribbon_l+star_ribbon_w, y)
rib_side_2 = QPointF(x, y+star_ribbon_l+star_ribbon_w)
rib_star_mid_1 = QPointF((rib_top_1.x()+rib_side_1.x())/2, (rib_top_1.y()+rib_side_1.y())/2)
rib_star_factor = star_ribbon_l/4
rib_star_p1_1 = rib_star_mid_1 + QPointF(rib_star_factor, -rib_star_factor)
rib_star_p1_2 = rib_star_p1_1 + QPointF(-rib_star_factor, -rib_star_factor)
rib_star_p1_3 = rib_star_mid_1 + QPointF(-rib_star_factor, rib_star_factor)
rib_star_p1_4 = rib_star_p1_3 + QPointF(-rib_star_factor, -rib_star_factor)
crown_1 = QPolygonF([rib_star_p1_1, rib_star_p1_2, rib_star_mid_1, rib_star_p1_4, rib_star_p1_3])
painter.setBrush(QBrush(QColor("yellow")))
painter.drawPolygon(crown_1)
ribbon_polygon = QPolygonF([rib_top_1, rib_side_1, rib_side_2, rib_top_2])
ribbon_path = QPainterPath()
ribbon_path.setFillRule(Qt.WindingFill)
ribbon_path.addPolygon(ribbon_polygon)
ribbon_path.closeSubpath()
painter.drawPath(ribbon_path)
#painter.setPen(QColor("#d35400"))
#painter.drawPolyline(rib_top_1, rib_star_p1_1, rib_star_p1_2, rib_star_mid_1, rib_star_p1_4, rib_star_p1_3, rib_side_1)
#painter.drawLine(rib_top_1, rib_top_2)
#painter.drawLine(rib_top_2, rib_side_2)
#painter.drawLine(rib_side_1, rib_side_2)
painter.restore()
if app_constants._REFRESH_EXTERNAL_VIEWER:
if app_constants.USE_EXTERNAL_VIEWER:
self.external_icon = self.file_icons.get_external_file_icon()
else:
self.external_icon = self.file_icons.get_default_file_icon()
if gallery.state == self.G_DOWNLOAD:
painter.save()
dl_box = QRect(x, y, w, 20)
painter.setBrush(QBrush(QColor(0,0,0,123)))
painter.setPen(QColor('white'))
painter.drawRect(dl_box)
painter.drawText(dl_box, Qt.AlignCenter, 'Downloading...')
painter.restore()
else:
if app_constants.DISPLAY_GALLERY_TYPE:
self.type_icon = self.file_icons.get_file_icon(gallery.path)
if self.type_icon and not self.type_icon.isNull():
self.type_icon.paint(painter, QRect(x+2, y+app_constants.THUMB_H_SIZE-16, 16, 16))
if app_constants.USE_EXTERNAL_PROG_ICO:
if self.external_icon and not self.external_icon.isNull():
self.external_icon.paint(painter, QRect(x+w-30, y+app_constants.THUMB_H_SIZE-28, 28, 28))
def draw_text_label(lbl_h):
#draw the label for text
painter.save()
painter.translate(x, y+app_constants.THUMB_H_SIZE)
box_color = QBrush(QColor(label_color))#QColor(0,0,0,123))
painter.setBrush(box_color)
rect = QRect(0, 0, w, lbl_h) #x, y, width, height
painter.fillRect(rect, box_color)
painter.restore()
return rect
if option.state & QStyle.State_MouseOver or\
option.state & QStyle.State_Selected:
title_layout = misc.text_layout(title, w, self.title_font, self.title_font_m)
artist_layout = misc.text_layout(artist, w, self.artist_font, self.artist_font_m)
t_h = title_layout.boundingRect().height()
a_h = artist_layout.boundingRect().height()
if app_constants.GALLERY_FONT_ELIDE:
lbl_rect = draw_text_label(min(t_h+a_h+3, app_constants.GRIDBOX_LBL_H))
else:
lbl_rect = draw_text_label(app_constants.GRIDBOX_LBL_H)
clipping = QRectF(x, y+app_constants.THUMB_H_SIZE, w, app_constants.GRIDBOX_LBL_H - 10)
painter.setPen(QColor(title_color))
title_layout.draw(painter, QPointF(x, y+app_constants.THUMB_H_SIZE),
clip=clipping)
painter.setPen(QColor(artist_color))
artist_layout.draw(painter, QPointF(x, y+app_constants.THUMB_H_SIZE+t_h),
clip=clipping)
#painter.fillRect(option.rect, QColor)
else:
if app_constants.GALLERY_FONT_ELIDE:
lbl_rect = draw_text_label(self.text_label_h)
else:
lbl_rect = draw_text_label(app_constants.GRIDBOX_LBL_H)
# draw text
painter.save()
alignment = QTextOption(Qt.AlignCenter)
alignment.setUseDesignMetrics(True)
title_rect = QRectF(0,0,w, self.title_font_m.height())
artist_rect = QRectF(0,self.artist_font_m.height(),w,
self.artist_font_m.height())
painter.translate(x, y+app_constants.THUMB_H_SIZE)
if app_constants.GALLERY_FONT_ELIDE:
painter.setFont(self.title_font)
painter.setPen(QColor(title_color))
painter.drawText(title_rect,
self.title_font_m.elidedText(title, Qt.ElideRight, w-10),
alignment)
painter.setPen(QColor(artist_color))
painter.setFont(self.artist_font)
alignment.setWrapMode(QTextOption.NoWrap)
painter.drawText(artist_rect,
self.title_font_m.elidedText(artist, Qt.ElideRight, w-10),
alignment)
else:
text_area.setDefaultFont(QFont(self.font_name))
text_area.drawContents(painter)
##painter.resetTransform()
painter.restore()
if option.state & QStyle.State_Selected:
painter.save()
selected_rect = QRectF(x, y, w, lbl_rect.height()+app_constants.THUMB_H_SIZE)
painter.setPen(Qt.NoPen)
painter.setBrush(QBrush(QColor(164,164,164,120)))
painter.drawRoundedRect(selected_rect, 5, 5)
#painter.fillRect(selected_rect, QColor(164,164,164,120))
painter.restore()
if gallery.dead_link:
painter.save()
selected_rect = QRectF(x, y, w, lbl_rect.height()+app_constants.THUMB_H_SIZE)
painter.setPen(Qt.NoPen)
painter.setBrush(QBrush(QColor(255,0,0,120)))
p_path = QPainterPath()
p_path.setFillRule(Qt.WindingFill)
p_path.addRoundedRect(selected_rect, 5,5)
p_path.addRect(x,y, 20, 20)
p_path.addRect(x+w-20,y, 20, 20)
painter.drawPath(p_path.simplified())
painter.setPen(QColor("white"))
txt_layout = misc.text_layout("Cannot find gallery source!", w, self.title_font, self.title_font_m)
txt_layout.draw(painter, QPointF(x, y+h*0.3))
painter.restore()
if app_constants.DEBUG:
painter.save()
painter.setBrush(QBrush(QColor("red")))
painter.setPen(QColor("white"))
txt_l = self.title_font_m.width(str(gallery.id))
painter.drawRect(x, y+40, txt_l*2, self.title_font_m.height())
painter.drawText(x+1, y+51, str(gallery.id))
painter.restore()
if option.state & QStyle.State_Selected:
painter.setPen(QPen(option.palette.highlightedText().color()))
else:
super().paint(painter, option, index)
