def slot_canvasSaveImage(self):
newPath = QFileDialog.getSaveFileName(self, self.tr("Save Image"), filter=self.tr("PNG Image (*.png);;JPEG Image (*.jpg)"))
newPath = newPath[0]
if not newPath:
return
self.scene.clearSelection()
if newPath.lower().endswith(".jpg"):
imgFormat = "JPG"
elif newPath.lower().endswith(".png"):
imgFormat = "PNG"
else:
# File-dialog may not auto-add the extension
imgFormat = "PNG"
newPath += ".png"
self.fExportImage = QImage(self.scene.sceneRect().width(), self.scene.sceneRect().height(), QImage.Format_RGB32)
painter = QPainter(self.fExportImage)
painter.save()
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setRenderHint(QPainter.TextAntialiasing, True)
self.scene.render(painter)
self.fExportImage.save(newPath, imgFormat, 100)
painter.restore()
def paintEvent(self, event):
painter = QPainter(self)
event.accept()
if not self.isEnabled():
painter.save()
painter.setOpacity(0.2)
painter.drawPixmap(self.fPixmapRect, self.fPixmapNormal, self.fPixmapRect)
painter.restore()
elif self.isChecked() or self.isDown():
painter.drawPixmap(self.fPixmapRect, self.fPixmapDown, self.fPixmapRect)
elif self.fIsHovered:
painter.drawPixmap(self.fPixmapRect, self.fPixmapHover, self.fPixmapRect)
else:
painter.drawPixmap(self.fPixmapRect, self.fPixmapNormal, self.fPixmapRect)
if not self.fTopText:
return
painter.save()
painter.setPen(self.fTopTextColor)
painter.setBrush(self.fTopTextColor)
painter.setFont(self.fTopTextFont)
painter.drawText(QPointF(10, 16), self.fTopText)
painter.restore()
def paintEvent(self, event):
if not self.isDisplayedWhenStopped() and not self.isRunning():
return
width = min(self.width(), self.height())
p = QPainter(self)
p.setRenderHint(QPainter.Antialiasing)
outerRadius = (width-1) * 0.5
innerRadius = (width-1) * 0.5 * 0.38
capsuleHeight = outerRadius - innerRadius
capsuleWidth = capsuleHeight * 0.23 if width > 32 else capsuleHeight * 0.35
capsuleRadius = capsuleWidth / 2
for i in range(12):
color = QColor(self.color)
color.setAlphaF(float(1.0 - float(i / 12.0)))
p.setPen(Qt.NoPen)
p.setBrush(color)
p.save()
p.translate(self.rect().center())
p.rotate(self._angle - float(i * 30.0))
p.drawRoundedRect(-capsuleWidth * 0.5,
-(innerRadius + capsuleHeight),
capsuleWidth,
capsuleHeight,
capsuleRadius,
capsuleRadius)
p.restore()
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 render(self, painter: QPainter) -> None:
if self._item_style == FileItemStyle.SMALLICON:
self.paint_smallicon_view(painter)
elif self._item_style == FileItemStyle.DETAIL:
self.paint_detail_view(painter)
else:
self.paint(painter)
if self.is_selected:
painter.save()
painter.setCompositionMode(QPainter.CompositionMode_SourceOver)
painter.setOpacity(0.5)
painter.fillRect(self.tile_rect, QColor(127, 192, 255))
painter.setCompositionMode(QPainter.CompositionMode_SourceOver)
painter.setOpacity(1.0)
painter.setPen(QColor(96, 127, 255))
painter.setBrush(Qt.NoBrush)
painter.drawRect(self.tile_rect)
painter.restore()
if self.is_cursor:
painter.setOpacity(1.0)
painter.setPen(QColor(0, 0, 0))
painter.setBrush(QColor(255, 255, 255, 96))
painter.drawRect(self.tile_rect)
def paintEvent(self, ev):
layout_pos = self.layoutPosition()
painter = QPainter(self.viewport())
# pages to paint
ev_rect = ev.rect().translated(-layout_pos)
pages_to_paint = set(self._pageLayout.pagesAt(ev_rect))
# paint the pages
for p in pages_to_paint:
rect = (p.rect() & ev_rect).translated(-p.pos())
painter.save()
painter.translate(p.pos() + layout_pos)
p.paint(painter, rect, self.repaintPage)
painter.restore()
# TODO paint highlighting
# remove pending render jobs for pages that were visible, but are not
# visible now
margin = 50
rect = ev_rect.adjusted(-margin, -margin, margin, margin)
for page in self._prev_pages_to_paint - pages_to_paint:
if page.renderer and not rect.intersects(page.rect()):
page.renderer.unschedule(page, self.repaintPage)
self._prev_pages_to_paint = pages_to_paint
def paintEvent(self, event):
# TODO: maybe use self.upm*(1+2*BufferHeight) for the denominator as in
# fontView
scale = self.height() / (self.upm * 1.2)
x_offset = \
(self.width() - self.maxWidth * scale - self.padding * 2) / 2
if x_offset < 0:
scale *= 1 + 2 * x_offset / (self.maxWidth * scale)
x_offset = 0
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.translate(self.padding, self.padding +
(self.ascender * 1.2) * scale)
painter.scale(scale, -scale)
col = QColor(Qt.black)
col.setAlphaF(.2)
for glyph in self.glyphs:
if self.alignRight:
dist = self.maxWidth - glyph.width
else:
dist = 0
glyphPath = glyph.getRepresentation("defconQt.QPainterPath")
painter.save()
painter.translate(x_offset + dist, 0)
painter.fillPath(glyphPath, col)
painter.restore()
def paintEvent(self, QPaintEvent):
self.updatePosition()
painter = QPainter(self)
painter.fillRect(self.rect(), Qt.transparent)
painter.setRenderHint(QPainter.Antialiasing, True)
if self._currentCounter >= self._numberOfLines:
self._currentCounter = 0
painter.setPen(Qt.NoPen)
for i in range(0, self._numberOfLines):
painter.save()
painter.translate(self._innerRadius + self._lineLength,
self._innerRadius + self._lineLength)
rotateAngle = float(360 * i) / float(self._numberOfLines)
painter.rotate(rotateAngle)
painter.translate(self._innerRadius, 0)
distance = self.lineCountDistanceFromPrimary(
i, self._currentCounter, self._numberOfLines)
color = self.currentLineColor(distance, self._numberOfLines,
self._trailFadePercentage,
self._minimumTrailOpacity,
self._color)
painter.setBrush(color)
rect = QRect(0, -self._lineWidth/2,
self._lineLength, self._lineWidth)
painter.drawRoundedRect(
rect, self._roundness, self._roundness, Qt.RelativeSize)
painter.restore()
def render(self, size):
image = QImage(size, QImage.Format_ARGB32_Premultiplied)
if (self.mIncludeBackgroundColor):
if (self.mMap.backgroundColor().isValid()):
image.fill(self.mMap.backgroundColor())
else:
image.fill(Qt.gray)
else :
image.fill(Qt.transparent)
mapSize = self.mRenderer.mapSize()
margins = self.mRenderer.map().drawMargins()
mapSize.setWidth(mapSize.width() + margins.left() + margins.right())
mapSize.setHeight(mapSize.height() + margins.top() + margins.bottom())
scale = min(size.width() / mapSize.width(), size.height() / mapSize.height())
scaledSize = mapSize * scale
painter = QPainter(image)
# Center the thumbnail in the requested size
painter.translate((size.width() - scaledSize.width()) / 2,
(size.height() - scaledSize.height()) / 2)
# Scale the map and translate it to adjust for its margins
painter.scale(scale, scale)
painter.translate(margins.left() + (size.width() - scaledSize.width()) / 2,
margins.top() + (size.height() - scaledSize.height()) / 2)
if (smoothTransform(scale)):
painter.setRenderHints(QPainter.SmoothPixmapTransform)
self.mRenderer.setPainterScale(scale)
for layer in self.mMap.layers():
if (self.mVisibleLayersOnly and not layer.isVisible()):
continue
painter.setOpacity(layer.opacity())
tileLayer = dynamic_cast(layer, TileLayer)
objGroup = dynamic_cast(layer, ObjectGroup)
imageLayer = dynamic_cast(layer, ImageLayer)
if (tileLayer):
self.mRenderer.drawTileLayer(painter, tileLayer)
elif (objGroup):
objects = objGroup.objects()
if (objGroup.drawOrder() == ObjectGroup.TopDownOrder):
objects = QList(sorted(objects, key=lambda x:x.y(), reverse=True))
for object in objects:
if (object.isVisible()):
if object.rotation() != 0.0:
origin = self.mRenderer.pixelToScreenCoords(object.position())
painter.save()
painter.translate(origin)
painter.rotate(object.rotation())
painter.translate(-origin)
color = MapObjectItem.objectColor(object)
self.mRenderer.drawMapObject(painter, object, color)
if (object.rotation() != 0):
painter.restore()
elif (imageLayer):
self.mRenderer.drawImageLayer(painter, imageLayer)
return image
def paintEvent(self, ev):
layout_pos = self.layoutPosition()
painter = QPainter(self.viewport())
# paint the pages
ev_rect = ev.rect().translated(-layout_pos)
for p in self._pageLayout.pagesAt(ev_rect):
rect = (p.rect() & ev_rect).translated(-p.pos())
painter.save()
painter.translate(p.pos() + layout_pos)
p.paint(painter, rect, self.repaintPage)
painter.restore()
def paintEvent(self, event):
# Init painter.
painter = QPainter(self)
painter.save()
# Draw background.
painter.setBrush(self.background_color)
painter.setPen(self.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)
painter.setPen(self.page_annotate_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)
painter.setRenderHint(QPainter.Antialiasing)
painter.fillRect(event.rect(), QBrush(Qt.white))
painter.translate(66, 66)
painter.save()
self.transformPainter(painter)
self.drawShape(painter)
painter.restore()
self.drawOutline(painter)
self.transformPainter(painter)
self.drawCoordinates(painter)
def getPixmap(self):
pixmap = QPixmap(self.width * self.pixelRatio, self.height * self.pixelRatio)
pixmap.setDevicePixelRatio(self.pixelRatio)
pixmap.fill(Qt.transparent)
painter = QPainter(pixmap)
painter.setRenderHint(QPainter.Antialiasing)
painter.translate(0, self.height)
painter.scale(1, -1)
if self.headerAtBottom:
bodyRect = (0, 0, self.width, self.height-self.headerHeight)
headerRect = (0, 0, self.width, self.headerHeight)
else:
bodyRect = (0, 0, self.width, self.height-self.headerHeight)
headerRect = (0, 0, self.width, self.headerHeight)
# background
painter.save()
if self.headerAtBottom:
h = self.height
else:
h = self.height - self.headerHeight
painter.translate(0, h)
painter.scale(1, -1)
self.drawCellBackground(painter, bodyRect)
painter.restore()
# glyph
if self.headerAtBottom:
painter.translate(0, self.headerHeight)
if self.shouldDrawMetrics:
self.drawCellHorizontalMetrics(painter, bodyRect)
self.drawCellVerticalMetrics(painter, bodyRect)
painter.save()
painter.setClipRect(0, 0, self.width, self.height-self.headerHeight)
painter.translate(self.xOffset, self.yOffset)
painter.scale(self.scale, self.scale)
self.drawCellGlyph(painter)
painter.restore()
# foreground
painter.save()
painter.translate(0, self.height - self.headerHeight)
painter.scale(1, -1)
self.drawCellForeground(painter, bodyRect)
painter.restore()
# header
if self.shouldDrawHeader:
painter.save()
if self.headerAtBottom:
h = 0
else:
h = self.height
painter.translate(0, h)
painter.scale(1, -1)
self.drawCellHeaderBackground(painter, headerRect)
self.drawCellHeaderText(painter, headerRect)
painter.restore()
return pixmap
def paintEvent(self, event):
painter = QPainter(self)
if self.isEnabled() and not self.isDown() and not self.isChecked():
painter.save()
hover_color = QColor("#424242")
faded_hover_color = QColor(hover_color)
faded_hover_color.setAlpha(int(self._fader * hover_color.alpha()))
painter.fillRect(event.rect(), faded_hover_color)
painter.restore()
elif self.isDown() or self.isChecked():
painter.save()
selected_color = QColor("#161719")
painter.fillRect(event.rect(), selected_color)
painter.restore()
is_titled = bool(self.defaultAction().property("titled"))
icon_rect = QRect(0, 0, 32, 32)
icon_rect.moveCenter(event.rect().center())
if is_titled:
font = painter.font()
center_rect = event.rect()
font.setPointSizeF(6)
fm = QFontMetrics(font)
line_height = fm.height()
text_flags = Qt.AlignHCenter | Qt.AlignTop
project_name = self.defaultAction().property("heading")
if project_name is not None:
center_rect.adjust(0, line_height, 0, 0)
icon_rect.moveTop(center_rect.top())
else:
icon_rect.moveCenter(center_rect.center())
self.icon().paint(painter, icon_rect, Qt.AlignCenter)
painter.setFont(font)
r = QRect(0, 5, self.rect().width(), line_height)
painter.setPen(Qt.white)
margin = 5
available_width = r.width() - margin
ellided_project_name = fm.elidedText(
project_name, Qt.ElideMiddle, available_width)
painter.drawText(r, text_flags, ellided_project_name)
else:
self.icon().paint(painter, icon_rect, Qt.AlignCenter)
def paintEvent(self, event):
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
self._optionsRects = {}
w, h = self.width(), self.height()
metrics = self.fontMetrics()
hphp = 2 * _hPad
painter.save()
path = QPainterPath()
path.addRoundedRect(.5, .5, w - 1, h - 1, 4, 4)
painter.fillPath(path, QColor(250, 250, 250))
x = 0
linePath = QPainterPath()
for text in self._options[:-1]:
x += hphp + metrics.width(text)
linePath.moveTo(x, 0)
linePath.lineTo(x, h)
pen = painter.pen()
pen.setColor(QColor(218, 218, 218))
pen.setWidth(0)
painter.setPen(pen)
painter.drawPath(path)
painter.setRenderHint(QPainter.Antialiasing, False)
painter.drawPath(linePath)
painter.restore()
painter.translate(_hPad, _vPad + metrics.ascent())
left = 0
for index, text in enumerate(self._options):
if index in self._selection:
color = QColor(20, 146, 230)
else:
color = QColor(63, 63, 63)
painter.setPen(color)
painter.drawText(0, 0, text)
textWidth = metrics.width(text)
rectWidth = textWidth + hphp
rect = (left, 0, rectWidth, h)
self._optionsRects[index] = rect
painter.translate(rectWidth, 0)
left += rectWidth
def paintEvent(self, event):
side = min(self.width(), self.height())
time = QTime.currentTime()
time = time.addSecs(self.timeZoneOffset * 3600)
painter = QPainter()
painter.begin(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.translate(self.width() / 2, self.height() / 2)
painter.scale(side / 200.0, side / 200.0)
painter.setPen(Qt.NoPen)
painter.setBrush(QBrush(self.hourColor))
painter.save()
painter.rotate(30.0 * ((time.hour() + time.minute() / 60.0)))
painter.drawConvexPolygon(self.hourHand)
painter.restore()
painter.setPen(self.hourColor)
for i in range(0, 12):
painter.drawLine(88, 0, 96, 0)
painter.rotate(30.0)
painter.setPen(Qt.NoPen)
painter.setBrush(QBrush(self.minuteColor))
painter.save()
painter.rotate(6.0 * (time.minute() + time.second() / 60.0))
painter.drawConvexPolygon(self.minuteHand)
painter.restore()
painter.setPen(QPen(self.minuteColor))
for j in range(0, 60):
if (j % 5) != 0:
painter.drawLine(92, 0, 96, 0)
painter.rotate(6.0)
painter.end()
def paintEvent(self, ev):
painter = QPainter(self)
# calc bar offset
y_offset = (self.height() - self._barHeight()) // 2
## prevent negative offset
y_offset = 0 if y_offset < 0 else y_offset
# frame around fraction indicator
painter.setBrush(self.palette().dark())
painter.save()
## no fill color
b = painter.brush()
b.setStyle(Qt.NoBrush)
painter.setBrush(b)
painter.drawRect(QRect(QPoint(0, y_offset), QSize(self._barWidth(), self._barHeight())))
painter.restore()
# fraction indicator
painter.drawRect(QRect(QPoint(0, y_offset), QSize(self._barWidth() * self._fraction, self._barHeight())))
def paintEvent(self, ev):
"""Called when paint is needed, finds out which page to magnify."""
view = self.parent().parent()
layout = view.pageLayout()
scale = max(min(self._scale, view.MAX_ZOOM * self.MAX_EXTRA_ZOOM / layout.zoomFactor), view.MIN_ZOOM / layout.zoomFactor)
# the position of our center on the layout
c = self.rect().center() + self.pos() - view.layoutPosition()
# make a region scaling back to the view scale
rect = QRect(0, 0, self.width() / scale, self.height() / scale)
rect.moveCenter(c)
region = QRegion(rect, QRegion.Ellipse) # touches the Pages we need to draw
# our rect on the enlarged pages
our_rect = self.rect()
our_rect.moveCenter(QPoint(c.x() * scale, c.y() * scale))
# the virtual position of the whole scaled-up layout
ev_rect = ev.rect().translated(our_rect.topLeft())
painter = QPainter(self)
for p in layout.pagesAt(region):
# reuse the copy of the page if still existing
try:
page = self._pages[p]
except KeyError:
page = self._pages[p] = p.copy()
page.x = p.x * scale
page.y = p.y * scale
page.width = p.width * scale
page.height = p.height * scale
# now paint it
rect = (page.rect() & ev_rect).translated(-page.pos())
painter.save()
painter.translate(page.pos() - our_rect.topLeft())
page.paint(painter, rect, self.repaintPage)
painter.restore()
self.drawBorder(painter)
def paint(self, painter: QPainter, option: QStyleOptionViewItem,
index: QModelIndex) -> None:
painter.save()
x = option.rect.x()
y = option.rect.y()
width = option.rect.width()
view_type = index.data(Qt.DisplayRole) # type: ViewRowType
if view_type == ViewRowType.header:
display_name, icon = index.data(Roles.device_details)
self.deviceDisplay.paint_header(
painter=painter,
x=x,
y=y,
width=width,
icon=icon,
display_name=display_name,
)
else:
assert view_type == ViewRowType.content
data = index.data(Roles.storage) # type: BackupVolumeUse
details = make_body_details(
bytes_total=data.bytes_total,
bytes_free=data.bytes_free,
files_to_display=data.backup_type,
marked=data.marked,
photos_size_to_download=data.photos_size_to_download,
videos_size_to_download=data.videos_size_to_download,
)
self.deviceDisplay.paint_body(painter=painter,
x=x,
y=y,
width=width,
details=details)
painter.restore()
def paintEvent(self, event):
painter = QPainter(self)
painter.fillRect(self.rect(), Qt.black)
if self.pixmap.isNull():
painter.setPen(Qt.white)
painter.drawText(self.rect(), Qt.AlignCenter,
"Rendering initial image, please wait...")
return
if self.curScale == self.pixmapScale:
painter.drawPixmap(self.pixmapOffset, self.pixmap)
else:
scaleFactor = self.pixmapScale / self.curScale
newWidth = int(self.pixmap.width() * scaleFactor)
newHeight = int(self.pixmap.height() * scaleFactor)
newX = self.pixmapOffset.x() + (self.pixmap.width() - newWidth) / 2
newY = self.pixmapOffset.y() + (self.pixmap.height() -
newHeight) / 2
painter.save()
painter.translate(newX, newY)
painter.scale(scaleFactor, scaleFactor)
exposed, _ = painter.matrix().inverted()
exposed = exposed.mapRect(self.rect()).adjusted(-1, -1, 1, 1)
painter.drawPixmap(exposed, self.pixmap, exposed)
painter.restore()
text = "Use mouse wheel or the '+' and '-' keys to zoom. Press and " \
"hold left mouse button to scroll."
metrics = painter.fontMetrics()
textWidth = metrics.width(text)
painter.setPen(Qt.NoPen)
painter.setBrush(QColor(0, 0, 0, 127))
painter.drawRect((self.width() - textWidth) / 2 - 5, 0, textWidth + 10,
metrics.lineSpacing() + 5)
painter.setPen(Qt.white)
painter.drawText((self.width() - textWidth) / 2,
metrics.leading() + metrics.ascent(), text)
def paintEvent(self, event):
painter = QPainter(self)
painter.save()
painter.setRenderHint(QPainter.HighQualityAntialiasing)
if self.qimg is not None:
# painter.drawImage(QRectF(0., 0., self.width(), self.height()), self.qimg)
painter.drawImage(QRectF(0., 0., self.width(), self.height()), self.qimg,
QRectF(0, 0, self.qimg.width(), self.qimg.height()))
while len(self.lineQueue) > 0:
l = self.lineQueue.pop()
painter.setPen(QPen(QBrush(l.color), l.width))
painter.drawLine(l.line)
pen = painter.pen()
# penwidth = pen.width()
while len(self.squareQueue) > 0:
r = self.squareQueue.pop()
if r.fill is True:
painter.setBrush(r.color)
else:
painter.setBrush(Qt.transparent)
pen.setColor(r.color)
pen.setWidth(r.width)
painter.setPen(pen)
if fabs(r.ang) > 0.01:
center = r.rect.center()
painter.translate(center)
painter.rotate(r.ang)
painter.drawRoundedRect(QRect(r.rect.topLeft() - center, r.rect.size()), 40, 40)
painter.rotate(-r.ang)
painter.translate(-center)
else:
painter.drawRect(r.rect)
if r.id >= 0:
painter.drawText(QPointF(r.rect.x(), r.rect.y()), s.setNum(r.id))
painter.restore()
super(ImgViewer, self).paintEvent(event)
def paintEvent(self, event):
painter = QPainter(self)
painter.setFont(UIFont)
painter.setRenderHint(QPainter.Antialiasing)
rect = event.rect()
# draw the background
painter.fillRect(rect, self._backgroundColor)
if self._glyph is None:
return
# apply the overall scale
painter.save()
# + translate and flip
painter.translate(0, self.height())
painter.scale(self._scale, -self._scale)
# move into position
xOffsetInv, yOffsetInv, _, _ = self._drawingRect
painter.translate(-xOffsetInv, -yOffsetInv)
# gather the layers
layerSet = self._glyph.layerSet
if layerSet is None:
layers = [(self._glyph, None, True)]
else:
glyphName = self._glyph.name
layers = []
for layerName in reversed(layerSet.layerOrder):
layer = layerSet[layerName]
if glyphName not in layer:
continue
glyph = layer[glyphName]
layers.append((glyph, layerName, layer == layerSet.defaultLayer))
self.drawBackground(painter)
for glyph, layerName, default in layers:
self.drawGlyphLayer(painter, glyph, layerName, default)
self.drawForeground(painter)
painter.restore()
def draw_arrow(
painter: QPainter,
up: bool,
x: int,
y: int,
width: int,
height: int,
brush: QBrush
):
width_factor = 0.2
height_factor = 0.33
height_line = height * height_factor * 2
width_line = width * width_factor
painter.save()
if up:
painter.translate(x, y + height)
painter.scale(1.0, -1.0)
pen = QPen()
pen.setBrush(brush)
painter.setBrush(brush)
painter.setPen(pen)
path = QPainterPath()
path.moveTo(width // 2 - width_line // 2, 0)
path.lineTo(width // 2 + width_line // 2, 0)
path.lineTo(width // 2 + width_line // 2, height_line)
path.lineTo(width, height_line)
path.lineTo(width // 2, height)
path.lineTo(0, height_line)
path.lineTo(width // 2 - width_line // 2, height_line)
path.lineTo(width // 2 - width_line // 2, 0)
painter.fillPath(path, brush)
painter.drawPath(path)
painter.restore()
def paint(self,
painter: QtGui.QPainter,
option: 'QStyleOptionGraphicsItem',
widget: typing.Optional[QWidget] = ...):
if not self.path.length():
path = QPainterPath()
path.moveTo(0, 0)
rand = np.random.rand(self.data_size) * 100
for i in np.arange(self.data_size):
path.lineTo(i, rand[i])
self.path = path
painter.save()
pen = QPen()
pen.setCosmetic(True)
pen.setColor(Qt.darkBlue)
painter.setPen(pen)
painter.drawPath(self.path)
painter.restore()
def paintEvent(self, event):
if not self._waiting:
# 交给原来的绘制
super(ProgressButton, self).paintEvent(event)
return
# 自定义绘制
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.setRenderHint(QPainter.SmoothPixmapTransform)
painter.setPen(Qt.NoPen)
for item, _ in self._items:
painter.save()
color = self._circleColor.toRgb()
color.setAlphaF(item.opacity)
painter.setBrush(color)
diameter = 2 * self._circleRadius
painter.drawRoundedRect(
QRectF(item.x / 100 * self.width() - diameter,
(self.height() - self._circleRadius) / 2, diameter,
diameter), self._circleRadius, self._circleRadius)
painter.restore()
def _draw(self, painter: QPainter, width: int, height: int):
painter.setBrush(QBrush(Color.brown))
# main branch
painter.drawPolygon(QPointF(-self.base_width(width) * smoothen_curve(self.age), 0),
QPointF(self.base_width(width) * smoothen_curve(self.age), 0),
QPointF(0, self.base_height(height) * smoothen_curve(self.age)))
# other branches
for h, rotation in self.branches:
painter.save()
# translate/rotate to the position from which the branches grow
painter.translate(0, self.base_height(height * h * smoothen_curve(self.age)))
painter.rotate(degrees(rotation))
painter.drawPolygon(
QPointF(-self.branch_width(width) * smoothen_curve(self.get_adjusted_age()) * (1 - h), 0),
QPointF(self.branch_width(width) * smoothen_curve(self.get_adjusted_age()) * (1 - h), 0),
QPointF(0, self.branch_height(height) * smoothen_curve(self.get_adjusted_age()) * (1 - h)))
painter.restore()
def _draw(self, painter: QPainter, width: int, height: int):
self.x = self.flower_center_x(width) * smoothen_curve(self.age)
self.y = self.flower_center_y(height) * smoothen_curve(self.age)
painter.setPen(QPen(Color.green, self.stem_width * smoothen_curve(self.age)))
# 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.age) ** 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 paint(
self, painter: QPainter, option: QStyleOptionViewItem, index: QModelIndex
) -> None:
"""
Paint a checkbox without a label
"""
checked = index.data(Qt.CheckStateRole) == Qt.Checked
enabled = int(index.flags() & Qt.ItemIsEditable) > 0
if not checked and not enabled:
return
painter.save()
checkboxStyleOption = QStyleOptionButton()
if checked:
checkboxStyleOption.state |= QStyle.State_On
else:
checkboxStyleOption.state |= QStyle.State_Off
if enabled:
checkboxStyleOption.state |= QStyle.State_Enabled
checkboxStyleOption.state &= ~QStyle.State_ReadOnly
else:
checkboxStyleOption.state &= ~QStyle.State_Enabled
checkboxStyleOption.state |= QStyle.State_ReadOnly
color = checkboxStyleOption.palette.color(QPalette.Window).darker(130)
checkboxStyleOption.palette.setColor(QPalette.Text, color)
checkboxStyleOption.rect = option.rect
checkboxStyleOption.rect.setX(
option.rect.x() + round(option.rect.width() / 2) - self.checkboxHalfWidth
)
QApplication.style().drawControl(
QStyle.CE_CheckBox, checkboxStyleOption, painter
)
painter.restore()
def paintEvent(self, event):
painter = QPainter(self)
if self.isEnabled() and not self.isDown() and not self.isChecked():
painter.save()
hover_color = QColor("#424242")
faded_hover_color = QColor(hover_color)
faded_hover_color.setAlpha(int(self._fader * hover_color.alpha()))
painter.fillRect(event.rect(), faded_hover_color)
painter.restore()
elif self.isDown() or self.isChecked():
painter.save()
selected_color = QColor("#090909")
painter.fillRect(event.rect(), selected_color)
painter.restore()
# fm = QFontMetrics(painter.font())
# rect = QRect(-3, 2, self.rect().width(), fm.height())
rect = event.rect()
icon_rect = QRect(0, 0, 22, 22)
self.icon().paint(painter, icon_rect, Qt.AlignVCenter)
painter.drawText(
rect.adjusted(0, 0, -3, 0),
Qt.AlignRight | Qt.AlignVCenter, self.text())
def paint(self,
painter: QtGui.QPainter,
option: 'QStyleOptionGraphicsItem',
widget=None):
view = self.scene().views()[0]
painter.save()
pen = QPen(Qt.white)
pen.setCosmetic(True)
if self.mouse_over:
view.setCursor(Qt.PointingHandCursor)
else:
view.setCursor(Qt.ArrowCursor)
painter.setPen(pen)
transform = QTransform()
transform.scale(1 + self.data_range_x_pix / 1000, 1)
painter.setTransform(transform)
painter.drawPath(self.path)
painter.restore()
def generateTheme(themeDatas, screenRect):
# Window Background
px = QPixmap(screenRect.size())
px.fill(QColor(themeDatas["Background/Color"]))
painter = QPainter(px)
if themeDatas["Background/ImageFile"]:
path = findBackground(themeDatas["Background/ImageFile"])
_type = themeDatas["Background/Type"]
if path and _type > 0:
if _type == 1: # Tiled
painter.fillRect(screenRect, QBrush(QImage(path)))
else:
img = QImage(path)
scaled = img.size()
if _type == 3: # Stretched
scaled.scale(screenRect.size(), Qt.IgnoreAspectRatio)
elif _type == 4: # Scaled
scaled.scale(screenRect.size(), Qt.KeepAspectRatio)
elif _type == 5: # Zoomed
scaled.scale(screenRect.size(), Qt.KeepAspectRatioByExpanding)
painter.drawImage((screenRect.width() - scaled.width()) / 2,
(screenRect.height() - scaled.height()) / 2, img.scaled(scaled))
# Text Background
textRect = themeTextRect(themeDatas, screenRect)
painter.save()
color = QColor(themeDatas["Foreground/Color"])
color.setAlpha(themeDatas["Foreground/Opacity"] * 255 / 100)
painter.setBrush(color)
painter.setPen(Qt.NoPen)
r = themeDatas["Foreground/Rounding"]
painter.drawRoundedRect(textRect, r, r)
painter.restore()
painter.end()
return px
def paintEvent(self, event):
painter = QPainter(self)
painter.setOpacity(self._opacity)
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setRenderHint(QPainter.SmoothPixmapTransform, True)
painter.save()
pen = QPen(Qt.DashLine)
pen.setWidthF(0.5)
pen.setColor(Qt.white)
painter.setPen(pen)
c = QPoint(self.off, self.height() * 0.6)
painter.drawPolyline(self._sw1.p1, c)
painter.drawPolyline(self._sw1.p3, c)
painter.drawPolyline(c, self._sw2.p8)
painter.restore()
pen = QPen(Qt.SolidLine)
pen.setWidthF(0.5)
pen.setColor(Qt.white)
painter.setPen(pen)
painter.drawPolyline(self._sw1.p2, self._sw1.p8)
painter.drawPolyline(self._sw1.p7, self._sw1.p8)
painter.drawPolyline(self._sw1.p8, self._sw1.p9)
def paintEvent(self, event):
side = min(self.width(), self.height())
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.translate(self.width() / 2, self.height() / 2)
painter.scale(side / 200.0, side / 200.0)
painter.setPen(Qt.NoPen)
painter.setBrush(AnalogPosition.positionHandColor)
painter.save()
painter.rotate(self.angle)
painter.drawConvexPolygon(AnalogPosition.positionHand)
painter.restore()
painter.setPen(AnalogPosition.positionHandColor)
for j in range(32):
painter.drawLine(92, 0, 96, 0)
painter.rotate(11.25)
def paintEvent(self, QPaintEvent):
painter = QPainter(self)
painter.save()
metrics = QFontMetrics(self.getQFont())
path = QPainterPath()
pen = QPen(QColor(0, 0, 0, 230))
painter.setRenderHint(QPainter.Antialiasing)
penwidth = 4
pen.setWidth(penwidth)
len = metrics.width(self.__Dtext)
w = self.width()
px = (len - w) / 2
if px < 0:
px = -px
py = (self.height() - metrics.height()) / 2 + metrics.ascent()
if py < 0:
py = -py
path.addText(px + 2, py + 2, self.getQFont(), self.__Dtext)
painter.strokePath(path, pen)
painter.drawPath(path)
painter.fillPath(path, QBrush(self.getQColor()))
painter.restore()
def paintEvent(self, event):
side = min(self.width(), self.height())
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.translate(self.width() / 2, self.height() / 2)
painter.scale(side / 200.0, side / 200.0)
painter.setPen(Qt.NoPen)
painter.setBrush(AnalogPosition.positionHandColor)
painter.save()
painter.rotate(self.angle)
painter.drawConvexPolygon(AnalogPosition.positionHand)
painter.restore()
painter.setPen(AnalogPosition.positionHandColor)
for j in range(32):
painter.drawLine(92, 0, 96, 0)
painter.rotate(11.25)
def paintEvent(self, event):
painter = QPainter(self)
painter.fillRect(self.rect(), Qt.black)
if self.pixmap.isNull():
painter.setPen(Qt.white)
painter.drawText(self.rect(), Qt.AlignCenter,
"Rendering initial image, please wait...")
return
if self.curScale == self.pixmapScale:
painter.drawPixmap(self.pixmapOffset, self.pixmap)
else:
scaleFactor = self.pixmapScale / self.curScale
newWidth = int(self.pixmap.width() * scaleFactor)
newHeight = int(self.pixmap.height() * scaleFactor)
newX = self.pixmapOffset.x() + (self.pixmap.width() - newWidth) / 2
newY = self.pixmapOffset.y() + (self.pixmap.height() - newHeight) / 2
painter.save()
painter.translate(newX, newY)
painter.scale(scaleFactor, scaleFactor)
exposed, _ = painter.matrix().inverted()
exposed = exposed.mapRect(self.rect()).adjusted(-1, -1, 1, 1)
painter.drawPixmap(exposed, self.pixmap, exposed)
painter.restore()
text = "Use mouse wheel or the '+' and '-' keys to zoom. Press and " \
"hold left mouse button to scroll."
metrics = painter.fontMetrics()
textWidth = metrics.width(text)
painter.setPen(Qt.NoPen)
painter.setBrush(QColor(0, 0, 0, 127))
painter.drawRect((self.width() - textWidth) / 2 - 5, 0, textWidth + 10,
metrics.lineSpacing() + 5)
painter.setPen(Qt.white)
painter.drawText((self.width() - textWidth) / 2,
metrics.leading() + metrics.ascent(), text)
def paintEvent(self, event):
super(CColorControl, self).paintEvent(event)
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setRenderHint(QPainter.SmoothPixmapTransform, True)
painter.setPen(Qt.NoPen)
# 变换圆心
painter.translate(self.rect().center())
# 画背景方格图
painter.save()
# 保证方格在前景圆内部
diameter = min(self.width(), self.height()) - 8
radius = diameter / 2
path = QPainterPath()
path.addRoundedRect(-radius, -radius, diameter, diameter, radius,
radius)
painter.setClipPath(path)
pixSize = 5
for x in range(int(self.width() / pixSize)):
for y in range(int(self.height() / pixSize)):
_x, _y = x * pixSize, y * pixSize
painter.fillRect(_x - radius, _y - radius, pixSize, pixSize,
Qt.white if x % 2 != y % 2 else Qt.darkGray)
painter.restore()
# 画前景颜色
diameter = min(self.width(), self.height()) - 4
radius = diameter / 2
path = QPainterPath()
path.addRoundedRect(-radius, -radius, diameter, diameter, radius,
radius)
painter.setClipPath(path)
painter.setBrush(self._color)
painter.drawRoundedRect(-radius, -radius, diameter, diameter, radius,
radius)
def drawBg(self, painter: QPainter):
painter.save()
painter.setPen(Qt.NoPen)
if self.Checked:
painter.setBrush(self.bgColorOn)
else:
painter.setBrush(self.bgColorOff)
rect = QRect(0, 0, self.width(), self.height())
radius = rect.height() / 2
circleWidth = rect.height()
path = QPainterPath()
path.moveTo(radius, rect.left())
path.arcTo(QRectF(rect.left(), rect.top(), circleWidth, circleWidth),
90, 180)
path.lineTo(rect.width() - radius, rect.height())
path.arcTo(
QRectF(rect.width() - rect.height(), rect.top(), circleWidth,
circleWidth), 270, 180)
path.lineTo(radius, rect.top())
painter.drawPath(path)
painter.restore()
def generateTheme(themeDatas, screenRect):
# Window Background
px = QPixmap(screenRect.size())
px.fill(QColor(themeDatas["Background/Color"]))
painter = QPainter(px)
if themeDatas["Background/ImageFile"]:
path = findBackground(themeDatas["Background/ImageFile"])
_type = themeDatas["Background/Type"]
if path and _type > 0:
if _type == 1: # Tiled
painter.fillRect(screenRect, QBrush(QImage(path)))
else:
img = QImage(path)
scaled = img.size()
if _type == 3: # Stretched
scaled.scale(screenRect.size(), Qt.IgnoreAspectRatio)
elif _type == 4: # Scaled
scaled.scale(screenRect.size(), Qt.KeepAspectRatio)
elif _type == 5: # Zoomed
scaled.scale(screenRect.size(), Qt.KeepAspectRatioByExpanding)
painter.drawImage((screenRect.width() - scaled.width()) / 2,
(screenRect.height() - scaled.height()) / 2, img.scaled(scaled))
# Text Background
textRect = themeTextRect(themeDatas, screenRect)
painter.save()
color = QColor(themeDatas["Foreground/Color"])
color.setAlpha(themeDatas["Foreground/Opacity"] * 255 / 100)
painter.setBrush(color)
painter.setPen(Qt.NoPen)
r = themeDatas["Foreground/Rounding"]
painter.drawRoundedRect(textRect, r, r)
painter.restore()
painter.end()
return px
def paintEvent(self, event):
locker = QMutexLocker(self.thread.mutex)
img = self.thread.image
dst = self.imgRect()
qp = QPainter()
qp.begin(self)
# draw background
brush = QBrush(Qt.SolidPattern)
# brush.setColor(Qt.white)
brush.setColor(Qt.black)
qp.setBrush(brush)
qp.drawRect(QRect(0,0,self.width(),self.height()))
qp.save()
qp.translate(dst.x()+dst.width()/2, dst.y()+dst.height()/2)
qp.scale(dst.width()/img.width(), dst.width()/img.width())
qp.translate(-img.width()/2, -img.height()/2)
qp.drawImage(0,0,img)
qp.restore()
# draw orientation lines
qp.setPen(QColor(255,255,255,150))
qp.drawLine(dst.x()+dst.width()/3,dst.y()+0,
dst.x()+dst.width()/3,dst.y()+dst.height())
qp.drawLine(dst.x()+dst.width()/2,dst.y()+0,
dst.x()+dst.width()/2,dst.y()+dst.height())
qp.drawLine(dst.x()+dst.width()*2/3,dst.y()+0,
dst.x()+dst.width()*2/3,dst.y()+dst.height())
qp.drawLine(dst.x()+0,dst.y()+dst.height()/3,
dst.x()+dst.width(),dst.y()+dst.height()/3)
qp.drawLine(dst.x()+0,dst.y()+dst.height()/2,
dst.x()+dst.width(),dst.y()+dst.height()/2)
qp.drawLine(dst.x()+0,dst.y()+dst.height()*2/3,
dst.x()+dst.width(),dst.y()+dst.height()*2/3)
qp.end()
def paintEvent(self, event):
global real_time, minotaur_standard_time
side = min(self.width(), self.height())
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.translate(self.width() / 2, self.height() / 2)
painter.scale(side / 200.0, side / 200.0)
painter.setPen(Qt.NoPen)
painter.setBrush(MSTAnalogClock.hourColor)
painter.save()
hour_adjust = 30.0 * ((int(minotaur_standard_time.hour) +
int(minotaur_standard_time.minute) / 60.0))
hour = math.floor(hour_adjust / 30.0)
painter.rotate(hour_adjust)
painter.drawConvexPolygon(MSTAnalogClock.hourHand)
painter.restore()
painter.setPen(MSTAnalogClock.hourColor)
for i in range(12):
painter.drawLine(88, 0, 96, 0)
painter.rotate(30.0)
painter.setPen(Qt.NoPen)
painter.setBrush(MSTAnalogClock.minuteColor)
painter.save()
minute_adjust = 6.0 * ((int(minotaur_standard_time.minute) +
int(minotaur_standard_time.second) / 60.0))
if minute_adjust < 0:
minute_adjust += 360
minute = math.floor(minute_adjust / 6.0)
painter.rotate(minute_adjust)
painter.drawConvexPolygon(MSTAnalogClock.minuteHand)
painter.restore()
painter.setPen(Qt.NoPen)
painter.setBrush(MSTAnalogClock.secondColor)
painter.save()
second_adjust = 6.0 * int(minotaur_standard_time.second)
if second_adjust < 0:
second_adjust += 360
second = math.floor(second_adjust / 6.0)
painter.rotate(second_adjust)
painter.drawConvexPolygon(MSTAnalogClock.secondHand)
painter.restore()
painter.setPen(MSTAnalogClock.minuteColor)
for j in range(60):
if (j % 5) != 0:
painter.drawLine(92, 0, 96, 0)
painter.rotate(6.0)
def paintEvent(self, event):
side = min(self.width(), self.height())
time = QTime.currentTime()
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.translate(self.width() / 2, self.height() / 2)
painter.scale(side / 200.0, side / 200.0)
painter.setPen(Qt.NoPen)
painter.setBrush(ShapedClock.hourColor)
painter.save()
painter.rotate(30.0 * ((time.hour() + time.minute() / 60.0)))
painter.drawConvexPolygon(ShapedClock.hourHand)
painter.restore()
painter.setPen(ShapedClock.hourColor)
for i in range(12):
painter.drawLine(88, 0, 96, 0)
painter.rotate(30.0)
painter.setPen(Qt.NoPen)
painter.setBrush(ShapedClock.minuteColor)
painter.save()
painter.rotate(6.0 * (time.minute() + time.second() / 60.0))
painter.drawConvexPolygon(ShapedClock.minuteHand)
painter.restore()
painter.setPen(ShapedClock.minuteColor)
for j in range(60):
if (j % 5) != 0:
painter.drawLine(92, 0, 96, 0)
painter.rotate(6.0)
def draw_labeled_value(
painter: QPainter,
label: str,
value: int,
label_font: QFont,
value_font: QFont,
center_x: int,
center_y: int,
color: QBrush = QBrush(QColor(255, 255, 255, 255))
):
value_str = "{}".format(value)
label_str = "{}".format(label)
value_metrics = QFontMetrics(value_font)
label_metrics = QFontMetrics(label_font)
painter.save()
center_y += abs(value_metrics.height() - label_metrics.height()) // 2
draw_adjusted_text(
painter,
value_str,
value_font,
center_x,
center_y - value_metrics.height() // 2,
color
)
draw_adjusted_text(
painter,
label_str,
label_font,
center_x,
center_y + label_metrics.height() // 2,
color
)
painter.restore()
def draw_adjusted_text(
painter: QPainter,
label: str,
font: QFont,
center_x: int,
center_y: int,
color: QBrush = QBrush(QColor(0, 0, 0, 255))
):
"""
Draw a string text with a particular format in the screen
:param painter:
:param label:
:param font:
:param center_x:
:param center_y:
:param color:
"""
painter.save()
painter.setRenderHints(QPainter.TextAntialiasing)
painter.setFont(font)
pen = QPen()
pen.setBrush(color)
painter.setPen(pen)
metrics = QFontMetrics(font)
label_width = metrics.boundingRect(label).width()
label_height = metrics.boundingRect(label).height()
painter.drawText(
QRectF(
center_x - label_width / 2,
center_y - label_height / 2,
label_width,
label_height
),
Qt.AlignHCenter,
label
)
painter.restore()
def paint(self, painter: QPainter, option: QStyleOptionViewItem, index: QModelIndex) -> None:
super().paint(painter, option, index)
polygon_id = index.data(BaseColorMappingDialog.PolygonRole)
brushstyle = index.data(BaseColorMappingDialog.BrushStyleRole)
h = option.rect.height()
painter.save()
painter.setRenderHint(QPainter.Antialiasing)
painter.setClipRect(option.rect)
painter.setPen(QPen(Qt.lightGray, h/5.))
if brushstyle is not None:
painter.setBrush(QBrush(Qt.lightGray, brushstyle))
zoom = .9
painter.setTransform(QTransform()
.translate(option.rect.x()+h/2+10, option.rect.y()+h/2)
.rotate(-5.)
.scale(h/100.*zoom, h/100.*zoom))
if polygon_id is None or polygon_id == NodePolygon.Circle:
painter.drawEllipse(QRect(-50, -50, 100, 100))
else:
polygon = NODE_POLYGON_MAP.get(polygon_id, QPolygonF())
painter.drawPolygon(polygon)
painter.restore()
def paintEvent(self, event):
super(MetroLineProgress, self).paintEvent(event)
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.fillRect(self.rect(), self.BackgroundColor)
painter.setPen(Qt.NoPen)
for item, _ in self._items:
painter.save()
color = self.Color.toRgb()
color.setAlphaF(item.opacity)
painter.setBrush(color)
# 5<= radius <=10
radius = qBound(self.Radius, self.Radius / 200 *
self.height(), 2 * self.Radius)
diameter = 2 * radius
painter.drawRoundedRect(
QRectF(
item.x / 100 * self.width() - diameter,
(self.height() - radius) / 2,
diameter, diameter
), radius, radius)
painter.restore()
def draw(self, painter: QPainter):
count = self.primary.count * self.secondary.count * self.tertiary.count
da = (self.angle.max - self.angle.min) / count
dv = (self.label.max - self.label.min) / count
painter.save()
painter.setRenderHint(QPainter.Antialiasing)
painter.translate(self.center)
painter.rotate(-self.angle.min)
for i in range(count + 1):
if self.is_primary(i):
self.draw_primary(painter)
v = self.label.min + i * dv
a = self.angle.min + da * i
self.draw_label(painter, v, a)
elif self.is_secondary(i):
self.draw_secondary(painter)
else:
self.draw_tertiary(painter)
painter.rotate(-da)
painter.restore()
def draw_on_canvas(self):
painter = QPainter(self.canvas)
painter.setPen(
QPen(QColor(Qt.green), 5, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin))
# draw select rectangle
painter.save()
# find the left top corner
self.select_min_x = min(self.select_rec_start_pos[0], self.mouse_x)
self.select_max_x = max(self.select_rec_start_pos[0], self.mouse_x)
self.select_min_y = min(self.select_rec_start_pos[1], self.mouse_y)
self.select_max_y = max(self.select_rec_start_pos[1], self.mouse_y)
painter.drawRect(
self.select_min_x, self.select_min_y,
geometry_utils.two_points_distances(self.select_min_x,
self.select_max_x),
geometry_utils.two_points_distances(self.select_min_y,
self.select_max_y))
painter.restore()
painter.end()
def paintEvent(self, e):
# myDebug(self.__class__.__name__, get_current_function_name())
if self.mImage is not None:
painter = QPainter(self)
painter.save()
painter.setRenderHint(QPainter.Antialiasing, True)
image_height = (self.width() -
4) * self.mImage.height() / self.mImage.width()
painter.drawPixmap(2,
self.height() / 2 - image_height / 2,
self.width() - 4, image_height,
QtGui.QPixmap.fromImage(self.mImage))
painter.restore()
else:
painter = QPainter(self)
painter.save()
painter.setRenderHint(QPainter.Antialiasing, True)
image_height = (self.width() - 4) * self.mBackImage.height(
) / self.mBackImage.width()
painter.drawPixmap(2,
self.height() / 2 - image_height / 2,
self.width() - 4, image_height, self.mBackImage)
painter.restore()
def paintEvent(self, e):
"""
draw pixmap as a the background with a dark overlay
HELP: currently, this cost much CPU
"""
painter = QPainter(self)
painter.setPen(Qt.NoPen)
painter.setRenderHint(QPainter.Antialiasing)
painter.setRenderHint(QPainter.SmoothPixmapTransform)
# calculate available size
draw_width = self.width()
draw_height = 10 # spacing defined in table container
draw_height += self.bottom_panel.height()
if self.table_container.meta_widget.isVisible():
draw_height += self.table_container.meta_widget.height()
extra = self.table_container.current_extra
if extra is not None and extra.isVisible():
draw_height += extra.height()
if self.table_container.toolbar.isVisible():
draw_height += self.table_container.toolbar.height()
scrolled = self.scrollarea.verticalScrollBar().value()
max_scroll_height = draw_height - self.bottom_panel.height()
if scrolled >= max_scroll_height:
painter.save()
painter.setBrush(self.palette().brush(QPalette.Window))
painter.drawRect(self.bottom_panel.rect())
painter.restore()
return
if self._pixmap is not None:
self._draw_pixmap(painter, draw_width, draw_height, scrolled)
self._draw_pixmap_overlay(painter, draw_width, draw_height,
scrolled)
else:
# draw gradient for widgets(bottom panel + meta_widget + ...) above table
self._draw_overlay(painter, draw_width, draw_height, scrolled)
# if scrolled height > 30, draw background to seperate bottom_panel and body
if scrolled >= 30:
painter.save()
painter.setBrush(self.palette().brush(QPalette.Window))
painter.drawRect(self.bottom_panel.rect())
painter.restore()
return
# since the body's background color is palette(base), we use
# the color to draw background for remain empty area
painter.save()
painter.setBrush(self.palette().brush(QPalette.Base))
painter.drawRect(0, draw_height, draw_width,
self.height() - draw_height)
painter.restore()
painter.end()
def paint(self, painter: QPainter, option, index):
# reference following link
# https://stackoverflow.com/questions/53353450/how-to-highlight-a-words-in-qtablewidget-from-a-searchlist
# https://stackoverflow.com/questions/34623036/implementing-a-delegate-for-wordwrap-in-a-qtreeview-qt-pyside-pyqt
painter.save()
doc = QTextDocument(self)
options = QStyleOptionViewItem(option)
self.initStyleOption(options, index)
doc.setPlainText(options.text)
# keyword = index.data(Qt.UserRole)
# if self.keywords:
self.keywordHighlight(doc)
options.text = ""
style = QApplication.style()
style.drawControl(QStyle.CE_ItemViewItem, options,
painter) # for selection highlight
ctx = QAbstractTextDocumentLayout.PaintContext()
if index.data(Qt.UserRole) == 'reserved':
ctx.palette.setColor(QPalette.Text, QColor.fromRgb(204, 204, 204))
doc.setDefaultFont(
QFont(option.font.family(),
option.font.pointSize() * 2 // 3))
else:
doc.setDefaultFont(option.font)
textRect = option.rect
# margin = 4
# textRect.setTop(textRect.top() + margin)
textRect.setTop(textRect.top())
painter.translate(textRect.topLeft())
painter.setClipRect(textRect.translated(-textRect.topLeft()))
doc.setTextWidth(option.rect.width())
doc.documentLayout().draw(painter, ctx)
painter.restore()
def paintEvent(self, event):
if (not self.m_displayedWhenStopped) and (not self.isAnimated()):
return
width = min(self.width(), self.height())
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
outerRadius = (width - 1) * 0.5
innerRadius = (width - 1) * 0.5 * 0.5
capsuleHeight = outerRadius - innerRadius
capsuleWidth = max(1.2, 1.0 + capsuleHeight * 0.19,
0.35 + capsuleHeight * 0.28)
capsuleRadius = capsuleWidth / 2
for i in range(0, 12):
color = QtGui.QColor(self.m_color)
if self.isAnimated():
color.setAlphaF(1.0 - (i / 12.0))
else:
color.setAlphaF(0.2)
painter.setPen(Qt.NoPen)
painter.setBrush(color)
painter.save()
painter.translate(self.rect().center())
painter.rotate(self.m_angle - (i * 30.0))
painter.drawRoundedRect(capsuleWidth * -0.5,
(innerRadius + capsuleHeight) * -1,
capsuleWidth, capsuleHeight, capsuleRadius,
capsuleRadius)
painter.restore()
def paintEvent(self, event):
side = 0.8 * min(self.width(), self.height())
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.translate(self.width() / 2, self.height() / 2 / 0.95)
painter.scale(side / 200.0 * 0.95, side / 200.0 * 0.95)
painter.setPen(Qt.NoPen)
painter.setBrush(self.ref_color)
painter.save()
painter.rotate(self.refValue)
painter.drawConvexPolygon(self.hand)
painter.restore()
painter.setBrush(self.color)
painter.save()
painter.rotate(self.value - self.refValue)
painter.drawConvexPolygon(self.hand)
painter.restore()
painter.save()
painter.setPen(QColor(0, 0, 0))
for i in range(27):
painter.drawLine(88, 0, 92, 0)
painter.rotate(15)
painter.restore()
painter.save()
painter.setPen(QColor(0, 0, 0))
painter.rotate(0.0)
for i in range(9):
painter.drawLine(88, 0, 96, 0)
painter.rotate(45.0)
painter.restore()
painter.setPen(QColor(0, 0, 0))
font = painter.font()
font.setPointSize(font.pointSize() * 1.2)
painter.setFont(font)
painter.drawText(QRectF(-7.5, 100, 30, 20), '180°')
painter.drawText(QRectF(-5, -110, 35, 20), '0°')
painter.drawText(QRectF(-125, -5, 30, 20), '270°')
painter.drawText(QRectF(105, -5, 35, 20), '90°')
def paintEvent(self, e):
time = QTime.currentTime()
qp = QPainter()
qp.begin(self)
#qp.setRenderHint(QPainter.Antialiasing) # 开启这个抗锯齿,会很占cpu的!
qp.translate(self.width() / 2, self.height() / 2)
qp.scale(self.side / 200.0, self.side / 200.0)
qp.setPen(QtCore.Qt.NoPen)
qp.setBrush(self.hourColor)
qp.save()
qp.rotate(30.0 * ((time.hour() + time.minute()/ 60.0)))
qp.drawConvexPolygon(self.hourHand)
qp.restore()
qp.setPen(self.minuteColor)
qp.drawText(0,0,"Testdddddddddddddd")
for i in range(12):
qp.drawLine(88, 0, 96, 0)
qp.rotate(30.0)
qp.setPen(QtCore.Qt.NoPen)
qp.setBrush(self.minuteColor)
qp.save()
qp.rotate(6.0 * ((time.minute() + (time.second()+time.msec()/1000.0) / 60.0)))
qp.drawConvexPolygon(self.minuteHand)
qp.restore()
qp.setPen(self.minuteColor)
for i in range(60):
if (i % 5) is not 0:
qp.drawLine(92, 0, 96, 0)
qp.rotate(6.0)
qp.setPen(QtCore.Qt.NoPen)
qp.setBrush(self.secondColor)
qp.save()
qp.rotate(6.0*(time.second()+time.msec()/1000.0))
qp.drawConvexPolygon(self.secondHand)
qp.restore()
qp.end()
def paintEvent(self, event):
linePen = QPen(Qt.black)
linePen.setWidth(3)
width = self.width() / self.scale
def paintLineMarks(painter):
painter.save()
painter.scale(self.scale, yDirection * self.scale)
painter.setPen(linePen)
painter.drawLine(0, self.ascender, width, self.ascender)
painter.drawLine(0, 0, width, 0)
painter.drawLine(0, self.descender, width, self.descender)
painter.restore()
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.fillRect(0, 0, self.width(), self.height(), Qt.white)
if self._verticalFlip:
baselineShift = -self.descender
yDirection = 1
else:
baselineShift = self.ascender
yDirection = -1
painter.translate(self.padding, self.padding +
baselineShift * self.scale * self._lineHeight)
# TODO: scale painter here to avoid g*scale everywhere below
cur_width = 0
if self._showMetrics:
paintLineMarks(painter)
for index, glyph in enumerate(self.glyphs):
# line wrapping
gWidth = glyph.width * self.scale
doKern = index > 0 and self._showKerning and cur_width > 0
if doKern:
kern = self.lookupKerningValue(
self.glyphs[index - 1].name, glyph.name) * self.scale
else:
kern = 0
if (self._wrapLines and cur_width + gWidth + kern +
2 * self.padding > self.width()) or glyph.unicode == 2029:
painter.translate(-cur_width, self.ptSize * self._lineHeight)
if self._showMetrics:
paintLineMarks(painter)
cur_width = gWidth
else:
if doKern:
painter.translate(kern, 0)
cur_width += gWidth + kern
glyphPath = glyph.getRepresentation("defconQt.QPainterPath")
painter.save()
painter.scale(self.scale, yDirection * self.scale)
if self._showMetrics:
halfDescent = self.descender / 2
painter.drawLine(0, 0, 0, halfDescent)
painter.drawLine(glyph.width, 0, glyph.width, halfDescent)
if self._selected is not None and index == self._selected:
painter.fillRect(0, self.descender, glyph.width,
self.upm, glyphSelectionColor)
painter.fillPath(glyphPath, Qt.black)
painter.restore()
painter.translate(gWidth, 0)
def paintEvent(self, event): painter = QPainter(self) painter.setPen(self.pen) painter.setBrush(self.brush) if self.antialiased: painter.setRenderHint(QPainter.Antialiasing) angle_step = 360 / self.n_states painter.save() #Save_1. Save the state of the system (push matrix) painter.translate(self.dist_center.x(), self.dist_center.y()) # go to the center of the render area painter.rotate(-180) #to start painting from the left side of the circle (clockwise) #center of the circumference where through we are going to paint our states x = self.dist_radius * math.cos(0) y = self.dist_radius * math.sin(0) for h in range(self.n_states): rot = angle_step * h # each state is equidistant from the others. We paint them in circles painter.save() #Save_2 painter.rotate(rot) #now our system is pointing to the next state to be drawn painter.translate(x,y) #now our origin is in the center of the next state to be drawn #if the state is active, fill it green if self.machine.getState(h).isActive(): painter.setBrush(self.greenGradientBrush) painter.drawEllipse(QPoint(0,0), self.state_radius, self.state_radius) #draw the new state #global position of transformed coordinates (before any transformation, origin at top-left corner) gx = painter.worldTransform().map(QPoint(0,0)).x() gy = painter.worldTransform().map(QPoint(0,0)).y() self.machine.getState(h).setPos(gx, gy) #store the center of the state without any transformation applied # text transformation. Our origin is still in the center of the current state painter.save() #Save_3 painter.rotate(180) #making the text go vertical painter.rotate(-rot) #undoing the rotation made for painting the state. No the text is horizontal font = painter.font(); font.setPixelSize(self.state_radius*.4); painter.setFont(font); rect = QRect(-self.state_radius, -self.state_radius, self.state_radius*2, self.state_radius*2) painter.drawText(rect, Qt.AlignCenter, self.machine.getState(h).getName()); painter.restore() #Restore_3 #end text transformation painter.restore() #Restore_2 painter.restore() #Restore_1. Restore the state of the system (pop matrix) #drawing transitions. Line between states painter.save() # Save_4 pptv = QTransform() #Define a new transformation. Needed to rotate the system along other axis than Z pptv.translate(0, self.height()) #We are now at the bottom-left corner of the screen pptv.rotate(-180, Qt.XAxis) #Rotate along the X-axis so now we are in a typical cartesian system. painter.setTransform(pptv) #Apply the transformation states = self.machine.getStates() for state in states: transitions = state.getTransitions() for transition in transitions: #get the center of the origin and destination states in our current system state orig = QPoint(state.getPos()[0], state.getPos()[1]) end = QPoint(self.machine.getState(transition.getStateEnd()).getPos()[0], self.machine.getState(transition.getStateEnd()).getPos()[1]) # get those coordinates without transformation orig2 = QPoint(painter.worldTransform().map(orig)) end2 = QPoint(painter.worldTransform().map(end)) #get the angle between states centers and the horizon angle = math.atan2(end2.y() - orig2.y(), end2.x() - orig2.x()) #get the coordinates of the starting point of the transition (it starts in the bound of the state, not in the center) newX = self.state_radius * math.cos(angle) + orig2.x() newY = self.state_radius * math.sin(angle) + orig2.y() #now the transition starts at the border, not in the center orig2.setX(newX) orig2.setY(newY) #same for the destination state angle2 = math.atan2(orig2.y() - end2.y(), orig2.x() - end2.x()) newX2 = self.state_radius * math.cos(angle2) + end2.x() newY2 = self.state_radius * math.sin(angle2) + end2.y() end2.setX(newX2) end2.setY(newY2) #draw the line between the origin and destination states painter.drawLine(orig2, end2) #get the start and the end of the transition untransformed init = QPoint(painter.worldTransform().map(orig2)) end = QPoint(painter.worldTransform().map(end2)) #store that info transition.setOrig(init.x(), init.y()) transition.setDest(end.x(), end.y()) transition.setAngle(angle) painter.restore() #Restore_4 #Appliying style to the transitions painter.setPen(QPen(QColor(Qt.gray), 3)) for state in self.machine.getStates(): for transition in state.getTransitions(): #get the start and end coordinates of the transition i = QPoint(transition.getOrig()[0], transition.getOrig()[1]) o = QPoint(transition.getDest()[0], transition.getDest()[1]) painter.drawPolyline(i, o) #Drawing the arrow at the end of the transition painter.save() #Save_5 painter.setPen(QPen(QColor(Qt.gray), 2)) painter.translate(transition.getDest()[0],transition.getDest()[1]) #Go to the end of the transition painter.rotate(90 - transition.getAngle()*180/math.pi) #Rotate to point in the direction of the transition #coordinates of the arrow (triangle) a = QPoint(0,0) b = QPoint(-5,10) c = QPoint(5,10) #coordinates of the arrow untransformed a1 = painter.worldTransform().map(a) b1 = painter.worldTransform().map(b) c1 = painter.worldTransform().map(c) #Drawin the actual arrow pointer = QPolygon([a,b,c]) painter.drawPolygon(pointer) painter.restore() #Restore_5 #For the animation of the transition painter.save() #Save_6 if transition.isActive(): #if the current transition is the active one the wave function will be running, so it's updating the canvas painter.setPen(QPen(QColor(Qt.green), 3)) painter.drawPolyline(i,o) painter.setPen(QPen(QColor(Qt.gray), 3)) painter.drawPolyline(self.poly(self.pts)) #Draw the arrow in the active state (red arrow) painter.setBrush(QBrush(QColor(255, 0, 0))) painter.setPen(QPen(QColor(Qt.red), 2)) pointer = QPolygon([a1,b1,c1]) painter.drawPolygon(pointer) #Ball that follows the line animation for x, y in self.pts: painter.drawEllipse(QRectF(self.pts[0][0] - 4, self.pts[0][1] - 4, 8, 8)) painter.restore() #Restore_6 #Painting the text of the transition painter.save() #Save_7 pptv = QTransform() painter.setPen(QPen(QColor(Qt.black), 3)) #get the middle point of the transition middleX = (transition.getOrig()[0] + transition.getDest()[0]) /2 middleY = (transition.getOrig()[1] + transition.getDest()[1]) /2 pptv.translate(middleX, middleY) #translate to that point painter.setTransform(pptv) #apply the transformation font = painter.font(); font.setPixelSize(self.state_radius*.2); painter.setFont(font); rect = QRect(-self.state_radius, -self.state_radius, self.state_radius*2, self.state_radius*2) name = str(transition.getId())+ '. ' + transition.getName() painter.drawText(rect, Qt.AlignCenter, name) painter.restore() #Restore_7 #paint the actual canvas 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):
painter = QPainter(self)
painter.setFont(headerFont)
painter.setRenderHint(QPainter.Antialiasing)
rect = self.rect()
# draw the background
painter.fillRect(rect, Qt.white)
if self._glyph is None:
return
# apply the overall scale
painter.save()
# + translate and flip
painter.translate(0, self.height())
painter.scale(self._scale, -self._scale)
# move into position
widgetWidth = self.width()
width = self._glyph.width * self._scale
diff = widgetWidth - width
xOffset = round((diff / 2) * self._inverseScale)
yOffset = self._verticalCenterYBuffer * self._inverseScale
yOffset -= self._descender
painter.translate(xOffset, yOffset)
# store the current drawing rect
w, h = self.width(), self.height()
w *= self._inverseScale
h *= self._inverseScale
self._drawingRect = (-xOffset, -yOffset, w, h)
# gather the layers
layerSet = self._glyph.layerSet
if layerSet is None:
layers = [(self._glyph, None)]
else:
glyphName = self._glyph.name
layers = []
for layerName in reversed(layerSet.layerOrder):
layer = layerSet[layerName]
if glyphName not in layer:
continue
glyph = layer[glyphName]
if glyph == self._glyph:
layerName = None
layers.append((glyph, layerName))
for glyph, layerName in layers:
# draw the image
if self.drawingAttribute("showGlyphImage", layerName):
self.drawImage(painter, glyph, layerName)
# draw the blues
if layerName is None and self.drawingAttribute(
"showFontPostscriptBlues", None):
self.drawBlues(painter, glyph, layerName)
if layerName is None and self.drawingAttribute(
"showFontPostscriptFamilyBlues", None):
self.drawFamilyBlues(painter, glyph, layerName)
# draw the margins
if self.drawingAttribute("showGlyphMargins", layerName):
self.drawMargins(painter, glyph, layerName)
# draw the vertical metrics
if layerName is None and self.drawingAttribute(
"showFontVerticalMetrics", None):
self.drawVerticalMetrics(painter, glyph, layerName)
# draw the glyph
if self.drawingAttribute("showGlyphFill", layerName) or \
self.drawingAttribute("showGlyphStroke", layerName):
self.drawFillAndStroke(painter, glyph, layerName)
if self.drawingAttribute("showGlyphOnCurvePoints", layerName) or \
self.drawingAttribute("showGlyphOffCurvePoints",
layerName):
self.drawPoints(painter, glyph, layerName)
if self.drawingAttribute("showGlyphAnchors", layerName):
self.drawAnchors(painter, glyph, layerName)
self._currentTool.paint(painter)
painter.restore()
def paintEvent(self, event):
selections = self.selectionModel()
option = self.viewOptions()
state = option.state
background = option.palette.base()
foreground = QPen(option.palette.color(QPalette.WindowText))
textPen = QPen(option.palette.color(QPalette.Text))
highlightedPen = QPen(option.palette.color(QPalette.HighlightedText))
painter = QPainter(self.viewport())
painter.setRenderHint(QPainter.Antialiasing)
painter.fillRect(event.rect(), background)
painter.setPen(foreground)
# Viewport rectangles
pieRect = QRect(self.margin, self.margin, self.pieSize,
self.pieSize)
keyPoint = QPoint(self.totalSize - self.horizontalScrollBar().value(),
self.margin - self.verticalScrollBar().value())
if self.validItems > 0:
painter.save()
painter.translate(pieRect.x() - self.horizontalScrollBar().value(),
pieRect.y() - self.verticalScrollBar().value())
painter.drawEllipse(0, 0, self.pieSize, self.pieSize)
startAngle = 0.0
for row in range(self.model().rowCount(self.rootIndex())):
index = self.model().index(row, 1, self.rootIndex())
value = self.model().data(index)
if value > 0.0:
angle = 360*value/self.totalValue
colorIndex = self.model().index(row, 0, self.rootIndex())
color = self.model().data(colorIndex, Qt.DecorationRole)
if self.currentIndex() == index:
painter.setBrush(QBrush(color, Qt.Dense4Pattern))
elif selections.isSelected(index):
painter.setBrush(QBrush(color, Qt.Dense3Pattern))
else:
painter.setBrush(QBrush(color))
painter.drawPie(0, 0, self.pieSize, self.pieSize,
int(startAngle*16), int(angle*16))
startAngle += angle
painter.restore()
keyNumber = 0
for row in range(self.model().rowCount(self.rootIndex())):
index = self.model().index(row, 1, self.rootIndex())
value = self.model().data(index)
if value > 0.0:
labelIndex = self.model().index(row, 0, self.rootIndex())
option = self.viewOptions()
option.rect = self.visualRect(labelIndex)
if selections.isSelected(labelIndex):
option.state |= QStyle.State_Selected
if self.currentIndex() == labelIndex:
option.state |= QStyle.State_HasFocus
self.itemDelegate().paint(painter, option, labelIndex)
keyNumber += 1
def paintEvent(self, event):
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
redrawRect = event.rect()
beginRow = redrawRect.top() // self.squareSize
endRow = redrawRect.bottom() // self.squareSize
# XXX: do we need to maintain self._column when we have (endColumn -
# beginColumn)?
beginColumn = redrawRect.left() // self.squareSize
endColumn = redrawRect.right() // self.squareSize
gradient = QLinearGradient(0, 0, 0, GlyphCellHeaderHeight)
gradient.setColorAt(0.0, cellHeaderBaseColor)
gradient.setColorAt(1.0, cellHeaderLineColor)
dirtyGradient = QLinearGradient(0, 0, 0, GlyphCellHeaderHeight)
dirtyGradient.setColorAt(0.0, cellHeaderBaseColor.darker(125))
dirtyGradient.setColorAt(1.0, cellHeaderLineColor.darker(125))
markGradient = QLinearGradient(0, 0, 0, self.squareSize-GlyphCellHeaderHeight)
for row in range(beginRow, endRow + 1):
for column in range(beginColumn, endColumn + 1):
key = row * self._columns + column
if key >= len(self._glyphs): break
glyph = self._glyphs[key]
painter.save()
painter.translate(column * self.squareSize, row * self.squareSize)
painter.fillRect(0, 0, self.squareSize, self.squareSize, Qt.white)
# prepare header colors
brushColor = gradient
linesColor = cellHeaderHighlightLineColor
# mark color
if not glyph.template:
if glyph.markColor is not None:
markColor = QColor.fromRgbF(*tuple(glyph.markColor))
markGradient.setColorAt(1.0, markColor)
markGradient.setColorAt(0.0, markColor.lighter(125))
painter.fillRect(0, GlyphCellHeaderHeight, self.squareSize,
self.squareSize - GlyphCellHeaderHeight, QBrush(markGradient))
if glyph.dirty:
brushColor = dirtyGradient
linesColor = cellHeaderHighlightLineColor.darker(110)
# header gradient
painter.fillRect(0, 0, self.squareSize, GlyphCellHeaderHeight,
QBrush(brushColor))
# header lines
painter.setPen(linesColor)
minOffset = painter.pen().width()
# disable antialiasing to avoid lines bleeding over background
painter.setRenderHint(QPainter.Antialiasing, False)
painter.drawLine(0, 0, 0, GlyphCellHeaderHeight - 1)
painter.drawLine(self.squareSize - 2, 0, self.squareSize - 2, GlyphCellHeaderHeight -1)
painter.setPen(QColor(170, 170, 170))
painter.drawLine(0, GlyphCellHeaderHeight, self.squareSize, GlyphCellHeaderHeight)
painter.setRenderHint(QPainter.Antialiasing)
# header text
painter.setFont(headerFont)
painter.setPen(QColor(80, 80, 80))
name = metrics.elidedText(glyph.name, Qt.ElideRight, self.squareSize - 2)
painter.drawText(1, 0, self.squareSize - 2, GlyphCellHeaderHeight - minOffset,
Qt.TextSingleLine | Qt.AlignCenter, name)
painter.restore()
painter.setPen(cellGridColor)
rightEdgeX = column * self.squareSize + self.squareSize
bottomEdgeY = row * self.squareSize + self.squareSize
painter.drawLine(rightEdgeX, row * self.squareSize + 1, rightEdgeX, bottomEdgeY)
painter.drawLine(rightEdgeX, bottomEdgeY, column * self.squareSize + 1, bottomEdgeY)
if self._currentDropIndex is not None:
painter.setPen(Qt.green)
if self._currentDropIndex == key:
painter.drawLine(column * self.squareSize, row * self.squareSize,
column * self.squareSize, bottomEdgeY)
# special-case the end-column
elif column == endColumn and self._currentDropIndex == key+1:
yPos = self.mapFromGlobal(QCursor.pos()).y()
if row == yPos // self.squareSize:
painter.drawLine(rightEdgeX - 1, row * self.squareSize,
rightEdgeX - 1, bottomEdgeY)
# selection code
if key in self._selection:
painter.setRenderHint(QPainter.Antialiasing, False)
painter.fillRect(column * self.squareSize + 1,
row * self.squareSize + 1, self.squareSize - 3,
self.squareSize - 3, cellSelectionColor)
painter.setRenderHint(QPainter.Antialiasing)
if not glyph.template:
font = glyph.getParent()
outline = glyph.getRepresentation("defconQt.QPainterPath")
uPM = font.info.unitsPerEm
if uPM is None or not uPM > 0:
uPM = 1000
descender = font.info.descender
if descender is None or not descender < 0:
descender = -250
factor = (self.squareSize-GlyphCellHeaderHeight) / (uPM*(1+2*GlyphCellBufferHeight))
x_offset = (self.squareSize-glyph.width*factor)/2
# If the glyph overflows horizontally we need to adjust the scaling factor
if x_offset < 0:
factor *= 1+2*x_offset/(glyph.width*factor)
x_offset = 0
# TODO: the * 1.8 below is somewhat artificial
y_offset = descender*factor * 1.8
painter.save()
painter.setClipRect(column * self.squareSize, row * self.squareSize+GlyphCellHeaderHeight,
self.squareSize, self.squareSize-GlyphCellHeaderHeight)
painter.translate(column * self.squareSize + x_offset, row * self.squareSize + self.squareSize + y_offset)
painter.scale(factor, -factor)
painter.fillPath(outline, Qt.black)
painter.restore()
else:
painter.save()
painter.setFont(voidFont)
painter.setPen(QPen(Qt.lightGray))
rect = QRectF(column * self.squareSize, row * self.squareSize+GlyphCellHeaderHeight,
self.squareSize, self.squareSize-GlyphCellHeaderHeight)
# TODO: need to flag template glyphs as to whether they have unicodings or not
if glyph.unicode is not None:
text = chr(glyph.unicode)
else:
text = "✌"
painter.drawText(rect, Qt.AlignCenter, text)
painter.restore()
def paintEvent(self, event):
painter = QPainter(self)
event.accept()
painter.save()
painter.setRenderHint(QPainter.Antialiasing, True)
if self.fLabel:
if self.fCustomPaintMode == self.CUSTOM_PAINT_MODE_NULL:
painter.setPen(self.fLabelGradientColor2)
painter.setBrush(self.fLabelGradient)
painter.drawRect(self.fLabelGradientRect)
painter.setFont(self.fLabelFont)
painter.setPen(self.fLabelGradientColorT[0 if self.isEnabled() else 1])
painter.drawText(self.fLabelPos, self.fLabel)
if self.isEnabled():
normValue = float(self.fRealValue - self.fMinimum) / float(self.fMaximum - self.fMinimum)
target = QRectF(0.0, 0.0, self.fPixmapBaseSize, self.fPixmapBaseSize)
curLayer = int((self.fPixmapLayersCount - 1) * normValue)
if self.fPixmapOrientation == self.HORIZONTAL:
xpos = self.fPixmapBaseSize * curLayer
ypos = 0.0
else:
xpos = 0.0
ypos = self.fPixmapBaseSize * curLayer
source = QRectF(xpos, ypos, self.fPixmapBaseSize, self.fPixmapBaseSize)
painter.drawPixmap(target, self.fPixmap, source)
# Custom knobs (Dry/Wet and Volume)
if self.fCustomPaintMode in (self.CUSTOM_PAINT_MODE_CARLA_WET, self.CUSTOM_PAINT_MODE_CARLA_VOL):
# knob color
colorGreen = QColor(0x5D, 0xE7, 0x3D).lighter(100 + self.fHoverStep*6)
colorBlue = QColor(0x3E, 0xB8, 0xBE).lighter(100 + self.fHoverStep*6)
# draw small circle
ballRect = QRectF(8.0, 8.0, 15.0, 15.0)
ballPath = QPainterPath()
ballPath.addEllipse(ballRect)
#painter.drawRect(ballRect)
tmpValue = (0.375 + 0.75*normValue)
ballValue = tmpValue - floor(tmpValue)
ballPoint = ballPath.pointAtPercent(ballValue)
# draw arc
startAngle = 216*16
spanAngle = -252*16*normValue
if self.fCustomPaintMode == self.CUSTOM_PAINT_MODE_CARLA_WET:
painter.setBrush(colorBlue)
painter.setPen(QPen(colorBlue, 0))
painter.drawEllipse(QRectF(ballPoint.x(), ballPoint.y(), 2.2, 2.2))
gradient = QConicalGradient(15.5, 15.5, -45)
gradient.setColorAt(0.0, colorBlue)
gradient.setColorAt(0.125, colorBlue)
gradient.setColorAt(0.625, colorGreen)
gradient.setColorAt(0.75, colorGreen)
gradient.setColorAt(0.76, colorGreen)
gradient.setColorAt(1.0, colorGreen)
painter.setBrush(gradient)
painter.setPen(QPen(gradient, 3))
else:
painter.setBrush(colorBlue)
painter.setPen(QPen(colorBlue, 0))
painter.drawEllipse(QRectF(ballPoint.x(), ballPoint.y(), 2.2, 2.2))
painter.setBrush(colorBlue)
painter.setPen(QPen(colorBlue, 3))
painter.drawArc(4.0, 4.0, 26.0, 26.0, startAngle, spanAngle)
# Custom knobs (L and R)
elif self.fCustomPaintMode in (self.CUSTOM_PAINT_MODE_CARLA_L, self.CUSTOM_PAINT_MODE_CARLA_R):
# knob color
color = QColor(0xAD, 0xD5, 0x48).lighter(100 + self.fHoverStep*6)
# draw small circle
ballRect = QRectF(7.0, 8.0, 11.0, 12.0)
ballPath = QPainterPath()
ballPath.addEllipse(ballRect)
#painter.drawRect(ballRect)
tmpValue = (0.375 + 0.75*normValue)
ballValue = tmpValue - floor(tmpValue)
ballPoint = ballPath.pointAtPercent(ballValue)
painter.setBrush(color)
painter.setPen(QPen(color, 0))
painter.drawEllipse(QRectF(ballPoint.x(), ballPoint.y(), 2.0, 2.0))
# draw arc
if self.fCustomPaintMode == self.CUSTOM_PAINT_MODE_CARLA_L:
startAngle = 216*16
spanAngle = -252.0*16*normValue
else:
startAngle = 324.0*16
spanAngle = 252.0*16*(1.0-normValue)
painter.setPen(QPen(color, 2))
painter.drawArc(3.5, 4.5, 22.0, 22.0, startAngle, spanAngle)
# Custom knobs (Color)
elif self.fCustomPaintMode == self.CUSTOM_PAINT_MODE_COLOR:
# knob color
color = self.fCustomPaintColor.lighter(100 + self.fHoverStep*6)
# draw small circle
ballRect = QRectF(8.0, 8.0, 15.0, 15.0)
ballPath = QPainterPath()
ballPath.addEllipse(ballRect)
tmpValue = (0.375 + 0.75*normValue)
ballValue = tmpValue - floor(tmpValue)
ballPoint = ballPath.pointAtPercent(ballValue)
# draw arc
startAngle = 216*16
spanAngle = -252*16*normValue
painter.setBrush(color)
painter.setPen(QPen(color, 0))
painter.drawEllipse(QRectF(ballPoint.x(), ballPoint.y(), 2.2, 2.2))
painter.setBrush(color)
painter.setPen(QPen(color, 3))
painter.drawArc(4.0, 4.0, 26.0, 26.0, startAngle, spanAngle)
# Custom knobs (Zita)
elif self.fCustomPaintMode == self.CUSTOM_PAINT_MODE_ZITA:
a = normValue * pi * 1.5 - 2.35
r = 10.0
x = 10.5
y = 10.5
x += r * sin(a)
y -= r * cos(a)
painter.setBrush(Qt.black)
painter.setPen(QPen(Qt.black, 2))
painter.drawLine(QPointF(11.0, 11.0), QPointF(x, y))
# Custom knobs
else:
painter.restore()
return
if self.HOVER_MIN < self.fHoverStep < self.HOVER_MAX:
self.fHoverStep += 1 if self.fIsHovered else -1
QTimer.singleShot(20, self.update)
else: # isEnabled()
target = QRectF(0.0, 0.0, self.fPixmapBaseSize, self.fPixmapBaseSize)
painter.drawPixmap(target, self.fPixmap, target)
painter.restore()