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 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):
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):
# 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 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 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, event):
rect = QRect(10, 20, 80, 60)
path = QPainterPath()
path.moveTo(20, 80)
path.lineTo(20, 30)
path.cubicTo(80, 0, 50, 50, 80, 80)
startAngle = 30 * 16
arcLength = 120 * 16
painter = QPainter(self)
painter.setPen(self.pen)
painter.setBrush(self.brush)
if self.antialiased:
painter.setRenderHint(QPainter.Antialiasing)
for x in range(0, self.width(), 100):
for y in range(0, self.height(), 100):
painter.save()
painter.translate(x, y)
if self.transformed:
painter.translate(50, 50)
painter.rotate(60.0)
painter.scale(0.6, 0.9)
painter.translate(-50, -50)
if self.shape == RenderArea.Line:
painter.drawLine(rect.bottomLeft(), rect.topRight())
elif self.shape == RenderArea.Points:
painter.drawPoints(RenderArea.points)
elif self.shape == RenderArea.Polyline:
painter.drawPolyline(RenderArea.points)
elif self.shape == RenderArea.Polygon:
painter.drawPolygon(RenderArea.points)
elif self.shape == RenderArea.Rect:
painter.drawRect(rect)
elif self.shape == RenderArea.RoundedRect:
painter.drawRoundedRect(rect, 25, 25, Qt.RelativeSize)
elif self.shape == RenderArea.Ellipse:
painter.drawEllipse(rect)
elif self.shape == RenderArea.Arc:
painter.drawArc(rect, startAngle, arcLength)
elif self.shape == RenderArea.Chord:
painter.drawChord(rect, startAngle, arcLength)
elif self.shape == RenderArea.Pie:
painter.drawPie(rect, startAngle, arcLength)
elif self.shape == RenderArea.Path:
painter.drawPath(path)
elif self.shape == RenderArea.Text:
painter.drawText(rect, Qt.AlignCenter,
"PyQt by\nRiverbank Computing")
elif self.shape == RenderArea.Pixmap:
painter.drawPixmap(10, 10, self.pixmap)
painter.restore()
painter.setPen(self.palette().dark().color())
painter.setBrush(Qt.NoBrush)
painter.drawRect(QRect(0, 0, self.width() - 1, self.height() - 1))
def paintEvent(self, event):
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 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, e):
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
self.drawBg(painter)
painter.save()
x_delta = (self._width - self._inner_height) // 2
y_delta = (self._height - self._inner_height) // 2
painter.translate(x_delta, y_delta)
self.drawInner(painter)
painter.restore()
self.drawStatus(painter)
def paintEvent(self, event):
super(FlipWidget, self).paintEvent(event)
if hasattr(self, 'image1') and hasattr(self,
'image2') and self.isVisible():
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setRenderHint(QPainter.SmoothPixmapTransform, True)
# 变换
transform = QTransform()
# 把圆心设置为矩形中心
transform.translate(self.width() / 2, self.height() / 2)
if self._angle >= -90 and self._angle <= 90:
# 当翻转角度在90范围内显示第一张图，且从大图缩放到小图的过程
painter.save()
# 设置翻转角度
transform.rotate(self._angle, Qt.YAxis)
painter.setTransform(transform)
# 缩放图片高度
width = self.image1.width() / 2
height = int(self.image1.height() *
(1 - abs(self._angle / self.Scale) / 100))
image = self.image1.scaled(self.image1.width(), height,
Qt.IgnoreAspectRatio,
Qt.SmoothTransformation)
painter.drawPixmap(QPointF(-width, -height / 2), image)
painter.restore()
else:
# 当翻转角度在90范围内显示第二张图，且从小图缩放到原图的过程
painter.save()
if self._angle > 0:
angle = 180 + self._angle
else:
angle = self._angle - 180
# 设置翻转角度， 注意这里角度有差异
transform.rotate(angle, Qt.YAxis)
painter.setTransform(transform)
# 缩放图片高度
width = self.image2.width() / 2
height = int(self.image2.height() *
(1 - ((360 - abs(angle)) / self.Scale / 100)))
image = self.image2.scaled(self.image2.width(), height,
Qt.IgnoreAspectRatio,
Qt.SmoothTransformation)
painter.drawPixmap(QPointF(-width, -height / 2), image)
painter.restore()
def paintEvent(self, event):
super(FramelessWindow, self).paintEvent(event)
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing, True)
color1 = QColor(255, 255, 255, 2)
color2 = QColor(0, 0, 0, 4)
if not self.isMaximized():
# 上
painter.save()
linearGradient = QLinearGradient(0, 0, 0, self.margin)
linearGradient.setColorAt(0, color1)
linearGradient.setColorAt(1, color2)
painter.setBrush(linearGradient)
painter.setPen(Qt.transparent)
painter.drawRect(0, 0, self.width() - self.margin, self.margin)
painter.restore()
# 下
painter.save()
linearGradient = QLinearGradient(0, self.height() - self.margin, 0, self.height())
linearGradient.setColorAt(0, color2)
linearGradient.setColorAt(1, color1)
painter.setBrush(linearGradient)
painter.setPen(Qt.transparent)
painter.drawRect(0, self.height() - self.margin, self.width(), self.height())
painter.restore()
# 左
painter.save()
linearGradient = QLinearGradient(0, 0, self.margin, 0)
linearGradient.setColorAt(0, color1)
linearGradient.setColorAt(1, color2)
painter.setBrush(linearGradient)
painter.setPen(Qt.transparent)
painter.drawRect(0, 0, self.margin, self.height())
painter.restore()
# 右
painter.save()
linearGradient = QLinearGradient(self.width() - self.margin, 0, self.width(), 0)
linearGradient.setColorAt(0, color2)
linearGradient.setColorAt(1, color1)
painter.setBrush(linearGradient)
painter.setPen(Qt.transparent)
painter.drawRect(self.width() - self.margin, 0, self.width(), self.height())
painter.restore()
# 绘制1像素黑边
painter.save()
painter.setPen(QPen(QColor(131, 131, 131), 1))
painter.drawRect(self.margin, self.margin, self.width() - 2 * self.margin,
self.height() - 2 * self.margin)
painter.restore()
def paintCell(self, painter: QtGui.QPainter, rect: QtCore.QRect,
date: typing.Union[QtCore.QDate, datetime.date]) -> None:
painter.save()
with open(get_resource("config.json")) as file:
if date.toPyDate().strftime("%Y-%m-%d") in json.loads(
file.read())["favorites"]:
painter.fillRect(rect, QtGui.QColor.fromRgb(255, 255, 0))
if (date.month() != self.monthShown()):
painter.setPen(QtGui.QColor("#888888"))
elif date.dayOfWeek() == 6 or date.dayOfWeek() == 7:
painter.setPen(QtGui.QColor("red"))
tags = self.get_tags_from_date_file(date.toPyDate())
rect.adjust(0, 0, -1, -1)
pen = painter.pen()
pen.setColor(
QtGui.QColor.fromHsl(pen.color().hue(),
pen.color().saturation(),
pen.color().lightness(), 150))
painter.setPen(pen)
painter.drawRect(rect)
pen.setColor(
QtGui.QColor.fromHsl(pen.color().hue(),
pen.color().saturation(),
pen.color().lightness(), 255))
painter.setPen(pen)
painter.drawText(rect, QtCore.Qt.AlignTop, str(date.day()))
text = ""
try:
for tag in tags[:5]:
if len(tag) > 12:
tag = str(tag[:12]) + "..."
text += f" {tag} \n"
except TypeError:
text = ""
font = QtGui.QFont()
font.setPixelSize(10)
painter.setFont(font)
brush = painter.background()
random.seed(date)
brush.setColor(QtGui.QColor().fromHsl(randint(0, 255), randint(0, 255),
randint(200, 255)))
painter.setPen(QtGui.QColor("black"))
painter.setBackground(brush)
painter.setBackgroundMode(QtCore.Qt.OpaqueMode)
painter.drawText(rect, QtCore.Qt.AlignBottom | QtCore.Qt.AlignHCenter,
text)
painter.restore()
def drawNeedle(self):
side = min(self.width(), self.height())
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.translate(self.width() / 2, self.height() / 2)
painter.scale(side / 256.0, side / 256.0)
painter.save()
painter.rotate(self.value2angle(self.currValue))
painter.setBrush(Qt.red)
painter.drawConvexPolygon(QPointF(0, -2), QPointF(100, 0),
QPointF(0, 2), QPointF(-30, 5),
QPointF(-30, -5))
painter.setBrush(Qt.black)
painter.drawEllipse(QPoint(0, 0), 5, 5)
painter.restore()
def paint(self, painter: QPainter, options, widget=None):
painter.save()
painter.setWorldMatrixEnabled(False)
painter.setPen(Qt.NoPen)
painter.setBrush(QBrush(QColor("#aa555555")))
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setRenderHint(QPainter.TextAntialiasing, True)
painter.setPen(QPen(QColor("#e5c15f")))
font = painter.font()
font.setPointSize(10)
painter.setWorldMatrixEnabled(True)
painter.restore()
def paintEvent(self, e):
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.setPen(Qt.NoPen)
painter.setBrush(self.palette().color(QPalette.Window))
painter.drawRoundedRect(self.rect(), self._border_radius,
self._border_radius)
painter.save()
painter.setPen(QColor('white'))
option = QTextOption()
option.setAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
rect = QRect(self.mapToParent(self._size_grip.pos()),
self._size_grip.size())
painter.drawText(QRectF(rect), '●', option)
painter.restore()
def paintSection(self, painter: QtGui.QPainter, rect: QtCore.QRect,
logicalIndex: int):
painter.save()
super().paintSection(painter, rect, logicalIndex)
painter.restore()
_y_offset = (rect.height() - self._height) // 2
option = self.checkBoxes[logicalIndex]
option.rect = QtCore.QRect(
rect.x() + rect.width() - self._width - self._x_offset,
rect.y() + _y_offset, self._width, self._height)
painter.save()
self.style().drawControl(QtWidgets.QStyle.CE_CheckBox, option, painter)
painter.restore()
def paintEvent(self, event):
painter = QPainter(self)
painter.fillRect(self.rect(), Qt.transparent)
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setPen(Qt.NoPen)
for i in range(self.numberOfDots):
painter.save()
painter.translate(0, 0)
position = (self.dotPosition[i][0], self.dotPosition[i][1])
color = self.dotColor
painter.setBrush(QBrush(color, Qt.SolidPattern))
painter.drawEllipse(position[0], position[1], self.dotRadius,
self.dotRadius)
painter.restore()
def render_seamless_wrap_paper(self, vertical, horizon, high, line_w,
interval_w, offset, s2b_angle, b_angle):
render_stripe(vertical, horizon, high, line_w, interval_w, offset,
s2b_angle, b_angle)
renderer = QSvgRenderer('./.tmp/output_render_wrap.svg')
w, h = renderer.defaultSize().width() * 4 / \
5, renderer.defaultSize().height() * 4 / 5
self.w_pixmap = QImage(QSize(w, h), QImage.Format_ARGB32_Premultiplied)
b_color = QColor(parameters.background_color)
self.w_pixmap.fill(b_color)
painter = QPainter(self.w_pixmap)
painter.restore()
renderer.render(painter)
self.w_lbl.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.w_lbl.setPixmap(QPixmap.fromImage(self.w_pixmap))
def PrintPreview(self, printer: QPrinter):
"""PrintPreview方法会自动接收一个参数 ，参数为QPrinter对象"""
self.Printer = printer
printer.Unit = QPrinter.Millimeter
painter = QPainter(printer)
painter.restore()
_jpPrintItem.TotalPagesCalculated = False
# 第一遍打印用于计算总页数，其后打印进行实际绘制
self.__PrintOrCalcOneCopy(painter)
self.__ExecNewPageTimes = 0
_jpPrintItem.TotalPagesCalculated = True
for i in range(self.Copys):
self._CurrentPage = 0
self._CurrentCopys += 1
self.__PrintOrCalcOneCopy(painter)
def paintEvent(self, event):
# Init painter.
painter = QPainter(self)
painter.save()
# Draw background.
painter.setBrush(self.background_color)
painter.drawRect(0, 0, self.rect().width(), self.rect().height())
# Get start/last render index.
start_page_index = int(self.scroll_offset * 1.0 / self.scale /
self.page_height)
last_page_index = int((self.scroll_offset + self.rect().height()) *
1.0 / self.scale / self.page_height)
# 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 + 1)):
if index < self.page_total_number:
# Get page image.
page = self.document[index]
trans = fitz.Matrix(self.scale, self.scale)
pixmap = page.getPixmap(matrix=trans, alpha=False)
img = QImage(pixmap.samples, pixmap.width, pixmap.height,
pixmap.stride, QImage.Format_RGB888)
qpixmap = QPixmap.fromImage(img)
# 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)
painter.restore()
def _draw_spectrogram(self, painter: QPainter) -> None:
pixels = self._pixels.transpose()
zero_column = np.zeros([pixels.shape[1]], dtype=np.uint8)
try:
delay = self._api.audio.current_stream.delay
sample_rate = self._api.audio.current_stream.sample_rate
except ResourceUnavailable:
delay = 0
sample_rate = 0
cached_blocks = (list(self._spectrum_worker.cache.keys())
if self._spectrum_worker else [])
min_pts = self.pts_from_x(0)
max_pts = self.pts_from_x(self.width() - 1)
min_pts -= delay
max_pts -= delay
pts_range = np.linspace(min_pts, max_pts, self.width())
block_idx_range = np.round(pts_range * sample_rate / 1000.0).astype(
dtype=np.int32) // (2**DERIVATION_DISTANCE)
for x, block_idx in enumerate(block_idx_range):
column = zero_column
column = self._spectrum_worker.cache.get(block_idx, zero_column)
if cached_blocks and column is zero_column:
tmp = bisect.bisect_left(cached_blocks, block_idx)
if tmp == len(cached_blocks):
tmp -= 1
nearest_block_idx = cached_blocks[tmp]
column = self._spectrum_worker.cache[nearest_block_idx]
pixels[x] = column
image = QImage(
self._pixels.data,
self._pixels.shape[1],
self._pixels.shape[0],
self._pixels.strides[0], # pylint: disable=unsubscriptable-object
QImage.Format_Indexed8,
)
image.setColorTable(self._color_table)
painter.save()
painter.scale(1, painter.viewport().height() / (pixels.shape[1] - 1))
painter.drawPixmap(0, 0, QPixmap.fromImage(image))
painter.restore()
def sketch_on_canvas(self):
painter = QPainter(self.canvas)
painter.setPen(
QPen(QColor(Qt.green), 5, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin))
current_pos = QPoint(self.mouse_x, self.mouse_y)
self.contour.append([self.mouse_x, self.mouse_y])
# draw select rectangle
painter.save()
painter.drawLine(self.last_pos, current_pos)
painter.restore()
painter.end()
self.last_pos = QPoint(self.mouse_x, self.mouse_y)
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 draw_center_circle(self, painter: QtGui.QPainter):
""" 绘制中心圆 """
radius = 15
painter.save()
color = self.percent_color
if self.double_percent:
center = (self.value == (self.max_value - self.min_value) / 2 +
self.min_value)
color = self.border_color if center else self.percent_color
painter.setPen(QtCore.Qt.NoPen)
painter.setBrush(color)
painter.drawEllipse(-radius, -radius, radius * 2, radius * 2)
painter.restore()
def _paint(self, painter: QtGui.QPainter,
paint_rect: QtCore.QRect) -> None:
p = QtCore.QPoint(self.leftMargin(), 0)
for measure_editor in self.measure_editors():
measure_rect = QtCore.QRect(p.x(), 0, measure_editor.width(),
self.height())
measure_rect = measure_rect.intersected(paint_rect)
if not measure_rect.isEmpty():
painter.save()
try:
painter.setClipRect(measure_rect)
painter.translate(p)
measure_editor.paint(painter, measure_rect.translated(-p))
finally:
painter.restore()
p += QtCore.QPoint(measure_editor.width(), 0)
def render(self, painter: QPainter):
if painter is None:
return
if self._background_rect is not None:
painter.save()
self.set_boundary(painter)
self.set_filling(painter, self._background_color, Qt.SolidPattern)
painter.drawRect(self._background_rect)
painter.restore()
painter.save()
painter.setPen(self.property().color)
painter.setFont(QFont('Helvetica', self.text_size, QFont.Bold))
painter.drawText(self.geometry().data(),
Qt.AlignVCenter | Qt.AlignHCenter, self.text)
painter.restore()
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 paintEvent(self, event):
'绘制界面'
self.cx = self.width()
self.cy = self.height()
painter = QPainter(self)
painter.save()
self.drawMap(painter)
try:
self.drawMap(painter)
self.drawLog(painter)
except Exception as e:
painter.setPen(QColor( 255,0,0 ))
painter.drawText( QRect( self.map_topleft[0] , self.map_topleft[1] , 400,300 ) , Qt.AlignCenter,
"paintEvent met exception:\n" + repr(e) + str(e) )
painter.restore()
def draw_players(self):
painter = QPainter(self)
index = 0
for player in self.players:
painter.save()
tex = self.players_tex[index]
trans = QTransform()
(x, y) = player.get_position()
size = tex.width() * self.tex_scale
trans.translate(self.ox + x * self.len, (self.oy + y * self.len))
trans.rotate(-player.get_rotation() / 2)
trans.translate(0 - size / 2, 0 - size / 2)
painter.setTransform(trans)
painter.drawImage(0, 0, tex.scaled(size, size))
painter.restore()
index += 1
def _paint(startx, starty, dragtox, dragtoy, p: QPainter):
p.save()
p.setPen(Dragger.pen)
p.drawLine(startx, starty, dragtox, dragtoy)
p.setPen(QPen(QColor(0,0,0,0)))
p.setBrush(QColor(100, 120, 120, 128))
offset = 4
size = Dragger.Size + offset
p.drawEllipse(startx - size / 2, starty - size / 2, size, size)
p.drawEllipse(dragtox - size / 2, dragtoy - size / 2, size, size)
p.setBrush(QColor(100, 120, 120))
p.drawEllipse(startx - Dragger.Size / 2, starty - Dragger.Size / 2, Dragger.Size, Dragger.Size)
p.drawEllipse(dragtox - Dragger.Size / 2, dragtoy - Dragger.Size / 2, Dragger.Size, Dragger.Size)
p.restore()
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)
# option.palette.setColor(QPalette.HighlightedText, QColor.fromRgb(30, 136, 200))
# remove dotted border in table
if option.state & QStyle.State_HasFocus:
option.state = option.state ^ QStyle.State_HasFocus
options = QStyleOptionViewItem(option)
self.initStyleOption(options, index)
doc.setPlainText(options.text)
# keyword = index.data(Qt.UserRole)
# if self.keywords:
self.keywordHighlight(doc)
options.text = ""
# print(dir(options.palette))
# print(options.palette.Highlight)
style = QApplication.style() if options.widget is None \
else options.widget.style()
style.drawControl(QStyle.CE_ItemViewItem, options, painter,
options.widget) # for selection highlight
ctx = QAbstractTextDocumentLayout.PaintContext()
if index.data(Qt.UserRole) == 'reserved':
ctx.palette.setColor(QPalette.Text, QColor.fromRgb(100, 100, 100))
doc.setDefaultFont(
QFont(option.font.family(),
option.font.pointSize() * 2 // 3))
else:
ctx.palette.setColor(QPalette.Text, QColor.fromRgb(217, 217, 217))
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 export_browser_graph(graph_filename, scene):
# define the bounding rectangle for pixmap for painter to paint in
w = int(scene.width()) + 20
if w < 840:
# adjust for when zoomed small
w = 840
h = int(scene.height()) + 30
pixmap = QPixmap(w, h)
painter = QPainter(pixmap)
painter.fillRect(0, 0, w, h, QColor("#f0f0f0"))
# get a default option object. It is neither a QStyleOptionViewItem
# nor a QStyleOptionGraphicsItem and we don't use it, but we need something.
option = QStyleOptionViewItem()
# paint the annotation
painter.translate(20, 10)
scene.g_annotation.paint(painter, option, None)
# paint the graph
painter.translate(65, 0)
# SD nodes, edges, and axis
for edge in scene.g_sd_edges:
edge.paint(painter, option, None)
for node in scene.g_sd_nodes:
painter.save()
painter.translate(node.pos())
node.paint(painter, option, None)
painter.restore()
painter.save()
painter.translate(scene.g_sd_axis.pos())
scene.g_sd_axis.paint(painter, option, None)
painter.restore()
painter.end()
# export
try:
pixmap.save(graph_filename)
except Exception as e:
status = "Error exporting browser graph image file '%s': %s" % (
graph_filename, str(e))
def paint(self, painter: QPainter, option: 'QStyleOptionViewItem', index: QModelIndex) -> None:
"""
Paint the playlist on the screen
:param painter: Controls actual painting
:param option: Options for painting
:param index: Index of item
"""
playlist = index.model().at(index.row())
if not index.isValid():
return
painter.save() # Save current state, before altering for custom painting
painter.setRenderHints(QPainter.Antialiasing, True)
painter.setRenderHints(QPainter.HighQualityAntialiasing, True)
painter.setRenderHints(QPainter.SmoothPixmapTransform, True)
playlist_pix: QPixmap = index.data(Qt.DecorationRole) # Tiled pixmap
title_font = QApplication.font()
title_font.setPixelSize(15)
title_fm = QFontMetrics(title_font)
icon_rect = QRect(option.rect.left() + PlaylistDelegate.pad_horizontal,
option.rect.top(),
PlaylistDelegate.icon_diameter,
PlaylistDelegate.icon_diameter)
title_rect = title_fm.boundingRect(option.rect.left() + PlaylistDelegate.pad_horizontal,
icon_rect.bottom() + PlaylistDelegate.pad_vertical,
icon_rect.width(),
0,
Qt.AlignHCenter | Qt.AlignTop | Qt.TextWordWrap,
playlist.name)
# Draw icon
painter.drawPixmap(icon_rect, playlist_pix)
# Draw title
painter.setFont(title_font)
painter.setPen(Qt.white)
painter.drawText(title_rect, Qt.AlignHCenter | Qt.AlignTop | Qt.TextWordWrap, playlist.name)
painter.restore()
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)
matrix = QTransform().scale(scale, scale)
# the position of our center on the layout
c = self.geometry().center() - view.layoutPosition()
# make a region scaling back to the view scale
rect = matrix.inverted()[0].mapRect(self.rect())
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(matrix.map(c))
# the virtual position of the whole scaled-up layout
ev_rect = ev.rect().translated(our_rect.topLeft())
# draw shadow border?
shadow = False
if hasattr(view, "drawDropShadow") and view.dropShadowEnabled:
shadow = True
shadow_width = layout.spacing * scale // 2
painter = QPainter(self)
for p in layout.pagesAt(region.boundingRect()):
# get a (reused) the copy of the page
page = p.copy(self, matrix)
# now paint it
rect = (page.geometry() & ev_rect).translated(-page.pos())
painter.save()
painter.translate(page.pos() - our_rect.topLeft())
if shadow:
view.drawDropShadow(page, painter, shadow_width)
page.paint(painter, rect, self.repaintPage)
painter.restore()
self.drawBorder(painter)
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 paint(self, p: QPainter, o: QStyleOptionGraphicsItem, w: QWidget): ref = self.scene()._page._subRef p.setPen(ref._pen) p.save() if self.isSelected(): if ref._pen.color() == PFSElement.SELECTED_PEN: p.setPen(PFSElement.SELECTED_PEN_ALT) else: p.setPen(PFSElement.SELECTED_PEN) h = (self._h -self._space*(ref._outputNum-1))/ref._outputNum p.translate(self.x(), self.y()) for i in range(ref._outputNum): p.drawLine(0, 0, -6, 0) p.drawLine(0, h, -6, h) p.drawLine(0, 0, 0, h) p.translate(0, h + self._space) p.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:
self._draw_overlay(painter, draw_width, draw_height, scrolled)
if scrolled >= 30:
painter.save()
painter.setBrush(self.palette().brush(QPalette.Window))
painter.drawRect(self.bottom_panel.rect())
painter.restore()
return
painter.end()
def paint(
self,
painter: QtGui.QPainter,
option: QtWidgets.QStyleOptionViewItem,
index: QtCore.QModelIndex,
) -> None:
model = self.parent().model()
text = self._process_text(model.data(index, QtCore.Qt.DisplayRole))
alignment = model.data(index, QtCore.Qt.TextAlignmentRole)
background = model.data(index, QtCore.Qt.BackgroundRole)
painter.save()
if option.state & QtWidgets.QStyle.State_Selected:
self._paint_selected(painter, option, text, alignment)
else:
self._paint_regular(painter, option, text, alignment, background)
painter.restore()
def draw_hex(painter: QPainter, size: int, color: QColor):
r, g, b, _ = color.getRgb()
value = ''.join(f'{x:02X}' for x in [r, g, b])
text_color = get_good_text_foreground_color(color)
x, y, w_hex, h_hex = size * 0.05, size * 0.1, size * 0.9, size * 0.25
font = get_optimal_font(FAMILY_FONT, w_hex, h_hex, text='FFFFFF')
painter.save()
painter.setPen(text_color)
painter.setFont(font)
painter.drawText(x, y, w_hex, h_hex, Qt.AlignCenter, value)
painter.restore()
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):
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, 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, 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 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 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 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):
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, 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):
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):
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):
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)
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()
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.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()
