def paintEvent(self, ev): p = QPainter(self) c = color('tab tree background', None) if c: p.fillRect(ev.rect(), QColor(c)) p.end() QWidget.paintEvent(self, ev)
def paintEvent(self, e): qp = QPainter() qp.begin(self) qp.setRenderHint(QPainter.RenderHints.Antialiasing) self.drawBezierCurve(qp) qp.end()
def paintEvent(self, ev): painter = QPainter(self) painter.setRenderHint(QPainter.RenderHint.TextAntialiasing) f = painter.font() f.setBold(True) f.setPixelSize(self.height() - 1) painter.setFont(f) painter.setPen(QColor('red' if self.is_enabled else 'green')) painter.drawText(self.rect(), Qt.AlignmentFlag.AlignCenter, 'Z') painter.end()
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 # Iterate over all text blocks in the document. # block = self.edit.document().begin() while block.isValid(): line_count += 1 # The top left position of the block in the document. # position = self.edit.document().documentLayout().blockBoundingRect(block).topLeft() # Check if the position of the block is out side of the visible # area. # if position.y() > page_bottom: break # We want the line number for the selected line to be bold. # bold = False if block == current_block: bold = True font = painter.font() font.setBold(True) painter.setFont(font) # Draw the line number right justified at the y position of the # line. 3 is a magic padding number. drawText(x, y, text). # painter.drawText(self.width() - len(str(line_count)) * font_metrics.averageCharWidth() - 5, round(position.y()) - contents_y + font_metrics.ascent(), str(line_count)) # Remove the bold style if it was set previously. # 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 paintEvent(self, ev): painter = QPainter(self) painter.setRenderHint(QPainter.RenderHint.Antialiasing, True) painter.setRenderHint(QPainter.RenderHint.SmoothPixmapTransform, True) try: self.paint_background(painter) except Exception: pass finally: painter.end() QWidget.paintEvent(self, ev)
def rotated_by(self, pixmap, angle): ans = pixmap.copy() ans.fill(Qt.GlobalColor.transparent) p = QPainter(ans) p.setRenderHint(QPainter.RenderHint.SmoothPixmapTransform) p.setRenderHint(QPainter.RenderHint.Antialiasing) sz = ans.size().width() / ans.devicePixelRatio() p.translate(sz // 2, sz // 2) p.rotate(angle) p.translate(-sz // 2, -sz // 2) p.drawPixmap(0, 0, pixmap) p.end() return ans
def missing_icon(): global _missing_icon if _missing_icon is None: p = QPixmap(ICON_SIZE, ICON_SIZE) p.fill(Qt.GlobalColor.transparent) painter = QPainter(p) pal = QApplication.instance().palette() painter.setPen( QPen(pal.color(QPalette.ColorRole.Text), 0, Qt.PenStyle.DashLine)) margin = 3 r = p.rect().adjusted(margin, margin, -margin, -margin) painter.drawRect(r) painter.end() _missing_icon = QIcon(p) return _missing_icon
def mouseMoveEvent(self, event): if self.xCache == None: self.xCache = event.position().x() self.yCache = event.position().y() else: painter = QPainter(self.canvas) pen = painter.pen() pen.setWidth(self.strokeWidth) pen.setColor(QColor(*self.color)) pen.setStyle(self.strokeStyle) painter.setPen(pen) painter.drawLine(self.xCache, self.yCache, event.position().x(), event.position().y()) painter.end() self.setPixmap(self.canvas) self.xCache = event.position().x() self.yCache = event.position().y()
def paintEvent(self, ev): if not self.static_text or not self.static_text.text(): return p = QPainter(self) p.setRenderHint(QPainter.RenderHint.TextAntialiasing) # If text is too long too fit, fade it out at the end self.static_text.setTextWidth(self.rect().width()) sz = self.static_text.size() r = self.rect() p.drawStaticText(0, int(r.height() - sz.height()) // 2, self.static_text) if sz.width() > r.width(): g = QLinearGradient(QPointF(self.rect().topLeft()), QPointF(self.rect().topRight())) c = QColor(self.sb_background) c.setAlpha(0) g.setColorAt(0, c) g.setColorAt(0.8, c) g.setColorAt(1.0, self.sb_background) p.fillRect(self.rect(), QBrush(g)) p.end()
def test_sanity(tmp_path): # Segfault test app = QApplication([]) ex = Example() assert app # Silence warning assert ex # Silence warning for mode in ("1", "RGB", "RGBA", "L", "P"): # to QPixmap im = hopper(mode) data = ImageQt.toqpixmap(im) assert isinstance(data, QPixmap) assert not data.isNull() # Test saving the file tempfile = str(tmp_path / f"temp_{mode}.png") data.save(tempfile) # Render the image qimage = ImageQt.ImageQt(im) data = QPixmap.fromImage(qimage) qt_format = QImage.Format if ImageQt.qt_version == "6" else QImage qimage = QImage(128, 128, qt_format.Format_ARGB32) painter = QPainter(qimage) image_label = QLabel() image_label.setPixmap(data) image_label.render(painter, QPoint(0, 0), QRegion(0, 0, 128, 128)) painter.end() rendered_tempfile = str(tmp_path / f"temp_rendered_{mode}.png") qimage.save(rendered_tempfile) assert_image_equal_tofile(im.convert("RGBA"), rendered_tempfile) # from QPixmap roundtrip(hopper(mode)) app.quit() app = None
def paintEvent(self, a0: QtGui.QPaintEvent) -> None: super().paintEvent(a0) qp = QPainter() qp.begin(self) qp.setRenderHint(QPainter.RenderHint.Antialiasing) # Hintergrund malen pen = QPen(Qt.GlobalColor.gray, 1, Qt.PenStyle.SolidLine) qp.setPen(pen) qp.setBrush(Qt.GlobalColor.gray) qp.drawRect(0, 0, self.width(), self.height()) # Sample malen pen.setColor(Qt.GlobalColor.white) qp.setPen(pen) qp.setBrush(Qt.GlobalColor.white) qp.drawRect(*self.norm_to_pixel_coord_int(-self.margin, -self.margin), self.norm_to_pixel_rel_int(self.x_range + 2 * self.margin), self.norm_to_pixel_rel_int(self.x_range + 2 * self.margin)) qp.end()
def paintEvent(self, e): qp = QPainter() qp.begin(self) self.drawLines(qp) qp.end()
def paintEvent(self, e): qp = QPainter() qp.begin(self) self.drawRectangles(qp) qp.end()
def paintEvent(self, event): painter = QPainter() painter.begin(self) painter.setOpacity(self.pixmap_opacity) painter.drawPixmap(0, 0, self.old_pixmap) painter.end()
class MazeView(QWidget): __painter: QPainter __maze: MazeProtocol __keepAspectRatio: bool __solverState: Optional[MazeSolverState] = None onMazeSolverAgentUpdate = pyqtSignal(MazeSolverState) def __init__( self, minimumSize: QSize, maze: MazeProtocol, parent: Optional[QWidget] = None, keepAspectRatio: bool = True, *args: Tuple[Any, Any], **kwargs: Tuple[Any, Any], ): super().__init__(parent=parent, *args, **kwargs) self.__keepAspectRatio = keepAspectRatio self.__maze = maze self.setContentsMargins(0, 0, 0, 0) self.setMinimumSize(minimumSize) # connect the onMazeSolverAgentUpdate signal with our internal method self.onMazeSolverAgentUpdate.connect(self.__onMazeSolverAgentUpdate) def __onMazeSolverAgentUpdate(self, newState: MazeSolverState) -> None: self.__solverState = newState self.update() # self.__drawAgent(self.__solverState) def resizeEvent(self, a0: QResizeEvent) -> None: if self.__keepAspectRatio: # Force the widget to rezise with a 1:1 aspect ratio # first calculate the smallest size axis: smallestAxisSize = min(a0.size().width(), a0.size().height()) # set a newSize var with this as both the axes sizes newSize = QSize(smallestAxisSize, smallestAxisSize) # resize with this new 1:1 size self.resize(newSize) # force resizeEvent of super with implicitly modified resize return super().resizeEvent(a0) def paintEvent(self, a0: QPaintEvent) -> None: # Initialise a painter to paint on this widget self.__painter = QPainter(self) # only draw the agent if the solverState is bound # if self.__solverState is not None: # it is a bound variable so draw it if self.__solverState is not None: agent = self.__drawAgent(self.__solverState) self.__painter.drawPath(agent) mazePath = self.__createMazePath() self.__painter.drawPath(mazePath) self.__painter.end() def __drawAgent( self, solverState: MazeSolverState, ) -> QPainterPath: # solverAgentPainter = QPainter(self) # Calculate size of each cell to be able to draw to proper scale cellSize = ( self.width() / self.__maze.size.x, self.height() / self.__maze.size.y, ) solverAgent = QPainterPath() # draw the agent shape currentPosition = ( solverState.currentCell.x * cellSize[0], solverState.currentCell.y * cellSize[1], ) solverAgent.addEllipse( currentPosition[0], currentPosition[1], cellSize[0], cellSize[1], ) ### ### Draw the direction arrow of the solver ### # get the facing direction of the solver direction = solverState.facingDirection # calculte middle of agent solver sprite to draw from middleOfCircle = ( currentPosition[0] + cellSize[0] * 0.5, currentPosition[1] + cellSize[1] * 0.5, ) # calculate the XY of the edge of the circle that we want to move to (to the facing direction) # start by getting the middle of the circle and then changing it accordingly edgeOfCircle = [ middleOfCircle[0], middleOfCircle[1], ] if direction == AbsoluteDirection.north: # north, so take away half the circle size in the Y direction edgeOfCircle[1] -= cellSize[1] * 0.5 elif direction == AbsoluteDirection.south: # south, so add half the circle size in the Y direction edgeOfCircle[1] += cellSize[1] * 0.5 elif direction == AbsoluteDirection.west: # west, so take away half the circle size in the X direction edgeOfCircle[0] -= cellSize[0] * 0.5 elif direction == AbsoluteDirection.east: # east, so add half the circle size in the X direction edgeOfCircle[0] += cellSize[0] * 0.5 # move to the center of the circle solverAgent.moveTo( middleOfCircle[0], middleOfCircle[1], ) # draw a line from the center of the circle to the facing direction edge of the circle solverAgent.lineTo( edgeOfCircle[0], edgeOfCircle[1], ) return solverAgent def __createMazePath(self) -> QPainterPath: cellSize = ( self.width() / self.__maze.size.x, self.height() / self.__maze.size.y, ) path = QPainterPath(QPointF(0, 0)) # draw outline of maze path.addRect( 0, 0, self.width() - 1, self.height() - 1, ) for y in range(self.__maze.size.y): currentY = y * cellSize[1] for x in range(self.__maze.size.x): currentX = x * cellSize[0] # get the list of walls surrounding this cell thisCellsWalls: Set[ AbsoluteDirection] = self.__maze.getWallsOfCellAtCoordinate( XY(x, y)) # draw north and west walls only, because the next iterations will draw the south and east walls for us (don't wanna waste paint /s) if AbsoluteDirection.west in thisCellsWalls: path.moveTo(currentX, currentY) path.lineTo(currentX, currentY + cellSize[1]) if AbsoluteDirection.north in thisCellsWalls: path.moveTo(currentX, currentY) path.lineTo(currentX + cellSize[0], currentY) return path
def paintEvent(self, event): qp = QPainter() qp.begin(self) self.drawText(event, qp) qp.end()
def get_masked_image(path, size=64, overlay_text=""): """ Returns a pixmap from an image file masked with a smooth circle. The returned pixmap will have a size of *size* × *size* pixels. :param str path: Path to image file. :param int size: Target size. Will be the diameter of the masked image. :param str overlay_text: Overlay text. This will be shown in white sans-serif on top of the image. :return: Masked image with overlay text. :rtype: QPixmap """ with open(path, "rb") as f: imgdata = f.read() imgtype = path.split(".")[-1] # Load image and convert to 32-bit ARGB (adds an alpha channel): image = QImage.fromData(imgdata, imgtype) image.convertToFormat(QImage.Format.Format_ARGB32) # Crop image to a square: imgsize = min(image.width(), image.height()) width = (image.width() - imgsize) / 2 height = (image.height() - imgsize) / 2 rect = QRect( round(width), round(height), imgsize, imgsize, ) image = image.copy(rect) # Create the output image with the same dimensions and an alpha channel # and make it completely transparent: out_img = QImage(imgsize, imgsize, QImage.Format.Format_ARGB32) out_img.fill(Qt.GlobalColor.transparent) # Create a texture brush and paint a circle with the original image onto # the output image: brush = QBrush(image) # Create texture brush painter = QPainter(out_img) # Paint the output image painter.setBrush(brush) # Use the image texture brush painter.setPen(Qt.PenStyle.NoPen) # Don't draw an outline painter.setRenderHint(QPainter.RenderHint.Antialiasing, True) # Use AA painter.drawEllipse(0, 0, imgsize, imgsize) # Actually draw the circle if overlay_text: # draw text font = QtGui.QFont("Arial Rounded MT Bold") font.setPointSize(imgsize * 0.4) painter.setFont(font) painter.setPen(Qt.GlobalColor.white) painter.drawText(QRect(0, 0, imgsize, imgsize), Qt.AlignmentFlag.AlignCenter, overlay_text) painter.end() # We are done (segfault if you forget this) # Convert the image to a pixmap and rescale it. Take pixel ratio into # account to get a sharp image on retina displays: pr = QtWidgets.QApplication.instance().devicePixelRatio() pm = QPixmap.fromImage(out_img) pm.setDevicePixelRatio(pr) size = int(pr * size) pm = pm.scaled( size, size, Qt.AspectRatioMode.KeepAspectRatio, Qt.TransformationMode.SmoothTransformation, ) return pm
def paintEvent(self, e): qp = QPainter() qp.begin(self) self.drawWidget(qp) qp.end()