def paintEvent(self, event):
qp = QPainter()
qp.begin(self)
self.drawWidget(qp)
qp.end()
def paintEvent(self, e):
qp = QPainter()
qp.begin(self)
self.drawPoints(qp)
qp.end()
def relationship_pixmap(self, str_object_class_name_list):
"""A pixmap for the given object_class name list,
created by rendering several object pixmaps next to each other."""
if not str_object_class_name_list:
engine = CharIconEngine("\uf1b3", 0)
return engine.pixmap(self.ICON_SIZE)
object_class_name_list = tuple(str_object_class_name_list.split(","))
if object_class_name_list in self.rel_cls_pixmap_cache:
return self.rel_cls_pixmap_cache[object_class_name_list]
scene = QGraphicsScene()
x = 0
for j, object_class_name in enumerate(object_class_name_list):
pixmap = self.object_pixmap(object_class_name)
pixmap_item = scene.addPixmap(pixmap)
if j % 2 == 0:
y = 0
else:
y = -0.875 * 0.75 * pixmap_item.boundingRect().height()
pixmap_item.setZValue(-1)
pixmap_item.setPos(x, y)
x += 0.875 * 0.5 * pixmap_item.boundingRect().width()
pixmap = QPixmap(scene.itemsBoundingRect().toRect().size())
pixmap.fill(Qt.transparent)
painter = QPainter(pixmap)
painter.setRenderHint(QPainter.Antialiasing, True)
scene.render(painter)
painter.end()
self.rel_cls_pixmap_cache[object_class_name_list] = pixmap
return pixmap
def paintEvent(self, event):
contents_y = self.edit.verticalScrollBar().value()
page_bottom = contents_y + self.edit.viewport().height()
font_metrics = self.fontMetrics()
current_block = self.edit.document().findBlock(self.edit.textCursor().position())
painter = QPainter(self)
line_count = 0
block = self.edit.document().begin()
while block.isValid():
line_count += 1
position = self.edit.document().documentLayout().blockBoundingRect(block).topLeft()
if position.y() > page_bottom:
break
bold = False
if block == current_block:
bold = True
font = painter.font()
font.setBold(True)
painter.setFont(font)
self.current = line_count
painter.drawText(self.width() - font_metrics.width(str(line_count)) - 10,
round(position.y()) - contents_y + font_metrics.ascent(),
str(line_count))
if bold:
font = painter.font()
font.setBold(False)
painter.setFont(font)
block = block.next()
self.highest_line = line_count
painter.end()
QWidget.paintEvent(self, event)
def group_object_pixmap(self, object_class_name):
if object_class_name in self.group_obj_pixmap_cache:
return self.group_obj_pixmap_cache[object_class_name]
object_pixmap = self.object_pixmap(object_class_name)
size = object_pixmap.size()
width, height = size.width(), size.height()
radius = width / 8
pen_width = width / 32
margin = width / 16
pen = QPen(QApplication.palette().shadow().color())
pen.setWidth(pen_width)
path = QPainterPath()
path.addRoundedRect(0, 0, width, height, radius, radius)
pixmap = QPixmap(size)
pixmap.fill(Qt.transparent)
painter = QPainter(pixmap)
painter.setRenderHint(QPainter.Antialiasing, True)
painter.fillPath(path, QApplication.palette().window())
painter.setPen(pen)
painter.drawRoundedRect(pixmap.rect().adjusted(pen_width, pen_width, -pen_width, -pen_width), radius, radius)
painter.drawPixmap(
pixmap.rect().adjusted(margin, margin, -width / 2, -height / 2), object_pixmap, object_pixmap.rect()
)
painter.drawPixmap(
pixmap.rect().adjusted(width / 2, margin, -margin, -height / 2), object_pixmap, object_pixmap.rect()
)
painter.drawPixmap(
pixmap.rect().adjusted(width / 2, height / 2, -margin, -margin), object_pixmap, object_pixmap.rect()
)
painter.drawPixmap(
pixmap.rect().adjusted(margin, height / 2, -width / 2, -margin), object_pixmap, object_pixmap.rect()
)
painter.end()
self.group_obj_pixmap_cache[object_class_name] = pixmap
return pixmap
def drawElts(self,elt_list,colorElt,colotTxt):
for elt in elt_list :
l_pp = self.getRealFromUiCoord(elt.getX(),elt.getY())
eltP = QPainter()
eltP.begin(self)
eltP.setBrush(QBrush(QColor(colorElt)))
myPen = QPen()
myPen.setBrush(QBrush(QColor(colotTxt)))
if 'rect' in elt.getID() :
l_pw = elt.getWidth()/self.scaleFactor
l_pl = elt.getLength()/self.scaleFactor
eltP.drawRect(l_pp.getX()-(l_pw/2),l_pp.getY()-(l_pl/2),l_pw,l_pl)
eltP.setPen(myPen)
eltP.drawText(l_pp.getX()-(l_pw/4),l_pp.getY(),l_pw,l_pl,1,elt.getID())
elif 'circle' in elt.getID() :
l_pr = elt.getRayon()/self.scaleFactor
eltP.drawEllipse(l_pp.getX()-(l_pr/2),l_pp.getY()-(l_pr/2),l_pr,l_pr)
eltP.setPen(myPen)
eltP.drawText(l_pp.getX()-l_pr/3,l_pp.getY(),l_pr,l_pr,1,elt.getID())
else :
pass
eltP.end()
def save_image_to(self, path):
TOP_MARGIN = 50
LEFT_MARGIN = 50
# Determine the size of the entire graph
graph_size = self._graph_size()
image_size = QSize(graph_size.width() + LEFT_MARGIN * 2,
graph_size.height() + TOP_MARGIN * 2
)
image = QImage(image_size, QImage.Format_ARGB32)
image.fill(Qt.white) # white background
painter = QPainter(image)
painter.translate(TOP_MARGIN, LEFT_MARGIN)
painter.setRenderHint(QPainter.TextAntialiasing)
self._paint(painter,
QPoint(-TOP_MARGIN, -LEFT_MARGIN),
QPoint(image_size.width(), image_size.height())
)
painter.end()
image.save(path)
def paintEvent(self, arg__1: QPaintEvent):
# super(Push, self).paintEvent(arg__1)
# lightgrey
painter = QPainter()
painter.begin(self)
pen = QPen(QColor(162, 181, 205), 2, Qt.SolidLine)
painter.setBrush(QBrush(QColor(255, 255, 255)))
painter.setPen(pen)
painter.setRenderHint(QPainter.Antialiasing, True)
rect = QRect()
rect.moveTo(1, 10)
rect.setWidth(140)
rect.setHeight(140)
painter.drawRoundedRect(rect, 5, 5)
painter.drawConvexPolygon(
[QPoint(60, 10), QPoint(80, 10),
QPoint(70, 1)])
pen.setColor(QColor(255, 255, 255))
painter.setPen(pen)
painter.drawLine(63, 10, 77, 10)
pen.setWidth(1)
painter.setPen(pen)
painter.drawPoints([QPoint(61, 10), QPoint(78, 10)])
painter.end()
def paintEvent(self, event):
qp = QPainter()
qp.begin(self)
try:
self.paintMap(qp)
finally:
qp.end()
def export_to_pdf(self: 'BaseWidget', filename: Path):
width_a4 = 730
height_a4 = 1060
is_landscape = self.width() > self.height()
if is_landscape:
self.resize(height_a4, width_a4) # landscape
else:
self.resize(width_a4, height_a4) # portrait
# render widget to picture
picture = QPicture()
painter = QPainter(picture)
self.render(painter, QPoint(0, 0))
painter.end()
# set up PDF printer
printer = QPrinter()
printer.setOutputFormat(QPrinter.PdfFormat)
printer.setOutputFileName(str(filename))
if is_landscape:
printer.setOrientation(QPrinter.Landscape)
# draw picture on printer
painter = QPainter()
ok = painter.begin(printer)
if ok:
painter.drawPicture(0, 0, picture)
ok = painter.end()
return ok
def mousePressEvent(self, event):
self._mouseLastPos = self.getLocalMousePos()
if event.button() == Qt.LeftButton:
self._mousePressed = MouseButton.LEFT
elif event.button() == Qt.RightButton:
self._mousePressed = MouseButton.RIGHT
if self._drawMode == DrawingMode.PEN:
if self._mousePressed == MouseButton.LEFT:
self.doDraw(event.localPos(), True)
elif self._drawMode == DrawingMode.DOTTED:
if self._mousePressed == MouseButton.LEFT:
self.doDraw(event.localPos(), True)
elif self._mousePressed == MouseButton.RIGHT:
self.doDraw(event.localPos(), False)
elif self._drawMode == DrawingMode.ERASE:
if self._mousePressed == MouseButton.LEFT:
self.doDraw(event.localPos(), False)
elif self._drawMode == DrawingMode.LINE:
if self._mousePressed == MouseButton.LEFT:
self._lineState = [event.localPos(), event.localPos()]
painter = QPainter(self._scratch)
painter.setPen(Qt.black)
painter.drawLine(self._lineState[0], self._lineState[1])
painter.end()
self.update(self.rect())
elif self._drawMode == DrawingMode.ATTR:
if self._mousePressed == MouseButton.LEFT:
self.doDrawAttr(event.localPos())
def export_to_picture(self: 'BaseWidget', filename: Path):
picture = QPixmap(self.width(), self.height())
painter = QPainter(picture)
self.render(painter, QPoint(0, 0))
painter.end()
return picture.save(str(filename))
class ImageViewer(QWidget):
def __init__(self):
super(ImageViewer, self).__init__()
self.painter = QPainter()
self.my_pen = QPen(QColor("red"))
self.my_pen.setWidth(5)
self.my_brush = QBrush(QColor("#123456"))
self.photo = QPixmap()
self.photo_rect = QRect()
def set_pixmap(self, image_path):
self.photo.load(image_path)
self.repaint()
def paintEvent(self, event):
self.painter.begin(self)
self.draw()
self.painter.end()
def draw(self):
rect = self.rect()
self.painter.setPen(self.my_pen)
self.painter.setBrush(self.my_brush)
photo = self.photo.scaled(QSize(rect.width(), rect.height()), Qt.KeepAspectRatio, Qt.SmoothTransformation)
self.photo_rect.setRect(rect.x(), rect.y(), photo.width(), photo.height())
self.photo_rect.moveCenter(rect.center())
self.painter.drawPixmap(self.photo_rect, photo)
def paintEvent(self, event):
painter = QPainter(self)
painter.begin(self)
painter.setPen(QPen(QColor(Qt.black), self.thickness, self.penStyle))
painter.drawLine(20, self.height / 2, self.width, self.height / 2)
painter.end()
self.update()
def paintEvent(self, event):
"""
Redraw application.
"""
super(TileSelector, self).paintEvent(event)
painter = QPainter(self)
painter.setPen(QColor(127, 127, 127))
painter.drawPixmap(0, 0,
self.pixmap.size().width() * self.scale,
self.pixmap.size().height() * self.scale,
self.pixmap)
for y in range(0, self.pixmap.size().height(), self.tile_size[1]):
for x in range(0, self.pixmap.size().width(), self.tile_size[0]):
painter.drawRect(x * self.scale, y * self.scale,
self.tile_size[0] * self.scale,
self.tile_size[1] * self.scale)
x, y = self.get_tile_map_coords(self.main.tile)
painter.setPen(QColor(200, 0, 0))
painter.drawRect(x * self.scale, y * self.scale,
self.tile_size[0] * self.scale,
self.tile_size[1] * self.scale)
painter.end()
def draw_grid(self):
"""
Dessine la grille de jeu en juxtaposant les images contenant chaque case. Chaque image est redimensionnée et ajustée à la taille de la grille.
"""
painter = QPainter(self.label.pixmap())
names = [
"Empty", "N", "E", "EN", "S", "NS", "ES", "ENS", "W", "NW", "EW",
"ENW", "SW", "NSW", "ESW", "ENSW"
]
images = [
QPixmap(IMAGES_PATH + name + ".bmp", format="bmp")
for name in names
]
for x in range(0, self.game.board.width):
for y in range(0, self.game.board.height):
painter.drawPixmap(
QPoint(self.DIMENSION / self.game.board.height * y,
self.DIMENSION / self.game.board.width * x),
images[int(str(self.game.board.grid[x][y]))].scaled(
self.DIMENSION / self.game.board.width,
self.DIMENSION / self.game.board.height))
self.update()
painter.end()
def printImage(self): #Ok
"""Imprimir Imagem
"""
printer = QPrinter()
printer.setOutputFormat(QPrinter.NativeFormat)
prnt_dlg = QPrintDialog(printer)
if (prnt_dlg.exec_() == QPrintDialog.Accepted):
painter = QPainter()
painter.begin(printer)
rect = QRect(painter.viewport())
size = QSize(self.img_lbl.pixmap().size())
size.scale(rect.size(), Qt.KeepAspectRatio)
painter.setViewport(rect.x(), rect.y(), size.width(),
size.height())
painter.setWindow(self.img_lbl.pixmap().rect())
painter.drawPixmap(0, 0, self.img_lbl.pixmap())
painter.end()
def draw_robots_and_goal(self):
self.draw_grid()
painter = QPainter(self.label.pixmap())
goal_img_name = ICON_PATH + "/goal_" + str(
self.game.goal.color) + ".png"
painter.drawPixmap(
QPoint(
self.DIMENSION / self.game.board.height *
self.game.goal.position[1], self.DIMENSION /
self.game.board.width * self.game.goal.position[0]),
QPixmap(goal_img_name, format="png").scaled(
self.DIMENSION / self.game.board.width * 0.9,
self.DIMENSION / self.game.board.height * 0.9))
images = [
QPixmap(ICON_PATH + "robot_" + str(color) + ".png", format="png")
for color in self.game.color_keys
]
for i, robot in enumerate(self.game.robots):
painter.drawPixmap(
QPoint(
self.DIMENSION / self.game.board.height *
self.game.robots[robot].position[1],
self.DIMENSION / self.game.board.width *
self.game.robots[robot].position[0]),
images[i].scaled(self.DIMENSION / self.game.board.width * 0.8,
self.DIMENSION / self.game.board.height))
self.update()
painter.end()
def paintEvent(self, event):
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing, on=True)
self.drawScale(painter)
self.drawBall(painter)
painter.end()
def paintEvent(self, event):
s = self.size()
qp = QPainter()
qp.begin(self)
qp.setRenderHint(QPainter.Antialiasing, True)
qp.setPen(Qt.NoPen)
qp.setBrush(QColor(120, 120, 120))
qp.drawEllipse(0, 0, 20, 20)
rg = QRadialGradient(int(self.width() / 2), int(self.height() / 2), 12)
rg.setColorAt(0, QColor(255, 255, 255))
rg.setColorAt(0.6, QColor(255, 255, 255))
rg.setColorAt(1, QColor(205, 205, 205))
qp.setBrush(QBrush(rg))
qp.drawEllipse(1, 1, 18, 18)
qp.setBrush(QColor(210, 210, 210))
qp.drawEllipse(2, 2, 16, 16)
if self.__enabled:
lg = QLinearGradient(3, 18, 20, 4)
lg.setColorAt(0, QColor(255, 255, 255, 255))
lg.setColorAt(0.55, QColor(230, 230, 230, 255))
lg.setColorAt(0.72, QColor(255, 255, 255, 255))
lg.setColorAt(1, QColor(255, 255, 255, 255))
qp.setBrush(lg)
qp.drawEllipse(3, 3, 14, 14)
else:
lg = QLinearGradient(3, 18, 20, 4)
lg.setColorAt(0, QColor(230, 230, 230))
lg.setColorAt(0.55, QColor(210, 210, 210))
lg.setColorAt(0.72, QColor(230, 230, 230))
lg.setColorAt(1, QColor(230, 230, 230))
qp.setBrush(lg)
qp.drawEllipse(3, 3, 14, 14)
qp.end()
def paintEvent(self, event):
"""overrides paint event to handle text"""
qp = QPainter()
qp.begin(self)
if self.main.drawValues():
self.drawText(event, qp)
qp.end()
def paintEvent(self, event):
s = self.size()
qp = QPainter()
qp.begin(self)
qp.setRenderHint(QPainter.Antialiasing, True)
pen = QPen(Qt.NoPen)
qp.setPen(pen)
qp.setBrush(QColor(154, 205, 50))
if self.__enabled:
qp.setBrush(QColor(154, 190, 50))
qp.drawRoundedRect(0, 0, s.width(), s.height(), 10, 10)
lg = QLinearGradient(0, 25, 70, 0)
lg.setColorAt(0, QColor(154, 184, 50))
lg.setColorAt(0.35, QColor(154, 210, 50))
lg.setColorAt(0.85, QColor(154, 184, 50))
qp.setBrush(lg)
qp.drawRoundedRect(1, 1, s.width() - 2, s.height() - 2, 8, 8)
else:
qp.setBrush(QColor(150, 150, 150))
qp.drawRoundedRect(0, 0, s.width(), s.height(), 10, 10)
lg = QLinearGradient(5, 25, 60, 0)
lg.setColorAt(0, QColor(190, 190, 190))
lg.setColorAt(0.35, QColor(230, 230, 230))
lg.setColorAt(0.85, QColor(190, 190, 190))
qp.setBrush(lg)
qp.drawRoundedRect(1, 1, s.width() - 2, s.height() - 2, 8, 8)
qp.end()
def event(self, event):
if event.type() == QEvent.TouchBegin or event.type(
) == QEvent.TouchUpdate or event.type() == QEvent.TouchEnd:
touchPoints = event.touchPoints()
for touchPoint in touchPoints:
if touchPoint.state() == Qt.TouchPointStationary:
continue
else:
rect = touchPoint.rect()
if rect.isEmpty():
diameter = 50 * touchPoint.pressure()
rect.setSize(QSizeF(diameter, diameter))
painter = QPainter(self.image)
painter.setPen(Qt.NoPen)
painter.setBrush(self.myPenColors[touchPoint.id() %
len(self.myPenColors)])
painter.drawEllipse(rect)
painter.end()
self.modified = True
rad = 2
self.update(rect.toRect().adjusted(-rad, -rad, +rad, +rad))
else:
return super(ScribbleArea, self).event(event)
return True
def paintEvent(self, event):
contents_y = self.edit.verticalScrollBar().value()
page_bottom = contents_y + self.edit.viewport().height()
font_metrics = self.fontMetrics()
current_block = self.edit.document().findBlock(
self.edit.textCursor().position())
painter = QPainter(self)
line_count = 0
block = self.edit.document().begin()
while block.isValid():
line_count += 1
position = self.edit.document().documentLayout().blockBoundingRect(
block).topLeft()
if position.y() > page_bottom:
break
bold = False
if block == current_block:
bold = True
font = painter.font()
font.setBold(True)
painter.setFont(font)
self.current = line_count
painter.drawText(
self.width() - font_metrics.width(str(line_count)) - 10,
round(position.y()) - contents_y + font_metrics.ascent(),
str(line_count))
if bold:
font = painter.font()
font.setBold(False)
painter.setFont(font)
block = block.next()
self.highest_line = line_count
painter.end()
QWidget.paintEvent(self, event)
def run(self):
image = QImage()
image.load(str(self.filename))
mask = QImage(image.size(), QImage.Format_RGB32)
mask.fill(Qt.black)
maskfile = self.filename.parent / (self.filename.stem + ".mask")
if maskfile.exists():
bitmap = QImage(str(maskfile))
if bitmap.size() != image.size():
raise Exception("Mask %s doesn't match image size" % maskfile)
mask.fill(QColor.fromRgbF(1.0, 0.0, 1.0))
p = QPainter(mask)
p.setCompositionMode(QPainter.CompositionMode_Multiply)
p.drawImage(mask.rect(), bitmap)
p.end()
self.view.imagefile = self.filename
self.view.image = image
self.view.mask = mask
self.view.maskfile = maskfile
self.view.path = list()
self.view.changed = False
self.view.update()
def paintEvent(self, event):
"""
custom paint event to draw horizontal line and handles at current y level
"""
super().paintEvent(event)
painter = QPainter(self)
#painter.beginNativePainting()
#painter.setRenderHint(QPainter.Antialiasing)
x1,y1,x2,y2 = self.rect().getCoords()
#painter.setPen(QPen(Qt.gray, 1))
#painter.drawRect(self.rect())
painter.setPen(QPen(COLOR, 1))
painter.drawLine(QPoint(x1, y1+(y2-y1)/2), QPoint(x2, y1+(y2-y1)/2))
path = QPainterPath()
path.moveTo(x1, y1)
path.lineTo(x1, y1 + y2)
path.lineTo(10, y1 + y2/2)
path.lineTo(x1, y1)
painter.fillPath(path, QBrush(COLOR))
path = QPainterPath()
path.moveTo(x2+1, y1)
path.lineTo(x2+1, y1 + y2)
path.lineTo(x2 - 9, y1 + y2/2)
path.lineTo(x2+1, y1)
painter.fillPath(path, QBrush(COLOR))
#painter.endNativePainting()
painter.end()
def paintEvent(self, event):
s = self.size()
qp = QPainter()
qp.begin(self)
qp.setRenderHint(QPainter.Antialiasing, True)
qp.setPen(self.penColor)
qp.setBrush(self.fillColor)
qp.drawRect(0, 0, s.width(), s.height())
if self.drawDrag:
pen = QPen(Qt.white, 5)
pen.setCapStyle(Qt.RoundCap)
qp.setPen(pen)
qp.setBrush(self.fillColor)
outerWidth = s.width() - 60
outerHeight = s.height() - 60
ow = int(s.width() / 2 - outerWidth / 2)
oh = int(s.height() / 2 - outerHeight / 2)
qp.drawRoundedRect(ow, oh, outerWidth, outerHeight, 5, 5)
qp.setBrush(Qt.white)
thickness = 12
length = 50
roundness = thickness / 2
vS = int(s.width() / 2 - thickness / 2)
vE = int(s.height() / 2 - length / 2)
qp.drawRoundedRect(vS, vE, thickness, length, roundness, roundness)
hS = int(s.width() / 2 - length / 2)
hE = int(s.height() / 2 - thickness / 2)
qp.drawRoundedRect(hS, hE, length, thickness, roundness, roundness)
qp.end()
def render_empty_bytes_to_pixmap(self, address=0, count=4096):
pixmap_painter = QPainter(self.bytes_pixmap)
pixmap_painter.setFont(self.font)
self.print_to_pixmap(pixmap_painter, address, "00" * count, PEN_EMPTY)
pixmap_painter.end()
def save_image_to(self,
path,
top_margin=50,
bottom_margin=50,
left_margin=50,
right_margin=50):
margins = QMarginsF(left_margin, top_margin, right_margin,
bottom_margin)
oldRect = self.scene().sceneRect()
minRect = self.scene().itemsBoundingRect()
imgRect = minRect.marginsAdded(margins)
image = QImage(imgRect.size().toSize(), QImage.Format_ARGB32)
image.fill(Qt.white)
painter = QPainter(image)
painter.setRenderHints(QPainter.Antialiasing
| QPainter.SmoothPixmapTransform
| QPainter.HighQualityAntialiasing)
# draw the image
self.scene().setSceneRect(imgRect)
self.scene().render(painter)
image.save(path)
# cleanup
painter.end()
# restore the old scene rect
self.scene().setSceneRect(oldRect)
def paintEvent(self, event):
outerRadius = min(self.width(), self.height())
baseRect = QRectF(1, 1, outerRadius - 2, outerRadius - 2)
buffer = QImage(outerRadius, outerRadius, QImage.Format_ARGB32)
buffer.fill(0)
p = QPainter(buffer)
p.setRenderHint(QPainter.Antialiasing)
# data brush
self.rebuildDataBrushIfNeeded()
# background
self.drawBackground(p, buffer.rect())
# base circle
self.drawBase(p, baseRect)
# data circle
arcStep = 360.0 / (self.max - self.min) * self.value
self.drawValue(p, baseRect, self.value, arcStep)
# center circle
innerRect, innerRadius = self.calculateInnerRect(baseRect, outerRadius)
self.drawInnerBackground(p, innerRect)
# text
self.drawText(p, innerRect, innerRadius, self.value)
# finally draw the bar
p.end()
painter = QPainter(self)
painter.drawImage(0, 0, buffer)
def findIcons(self):
if hou.applicationVersion()[0] < 15:
for category in os.listdir(self.path):
for ico in os.listdir(os.path.join(self.path, category)):
iconPath = os.path.join(
os.path.join(self.path, category, ico))
iconName = '_'.join([category, os.path.splitext(ico)[0]])
self.icons[iconName] = QPixmap(iconPath)
else:
zf = zipfile.ZipFile(self.path, 'r')
for f in zf.namelist():
if f.startswith('old'): continue
if os.path.splitext(f)[-1] == '.svg':
svg = QSvgRenderer(QByteArray(zf.read(f)))
if not svg.isValid():
continue
pixmap = QPixmap(iconSize, iconSize)
painter = QPainter()
painter.begin(pixmap)
pixmap.fill(QColor(Qt.black))
svg.render(painter)
painter.end()
category, ico = f.split('/')
iconName = '_'.join([category, os.path.splitext(ico)[0]])
self.icons[iconName] = pixmap
zf.close()
def testFromData(self):
picture = QPicture()
painter = QPainter()
painter.begin(picture)
painter.drawEllipse(10, 20, 80, 70)
painter.end()
data = picture.data()
picture2 = QPicture()
picture2.setData(data)
self.assertEqual(picture2.data(), picture.data())
w = MyWidget()
w._picture = picture2
w._app = self.app
QTimer.singleShot(300, w.show)
self.app.exec_()
