def pixmap(name, size, mode, state): """Returns a (possibly cached) pixmap of the name and size with the default text color. The state argument is ignored for now. """ if mode == QIcon.Selected: color = QApplication.palette().highlightedText().color() else: color = QApplication.palette().text().color() key = (name, size.width(), size.height(), color.rgb(), mode) try: return _pixmaps[key] except KeyError: i = QImage(size, QImage.Format_ARGB32_Premultiplied) i.fill(0) painter = QPainter(i) # render SVG symbol QSvgRenderer(os.path.join(__path__[0], name + ".svg")).render(painter) # recolor to text color painter.setCompositionMode(QPainter.CompositionMode_SourceIn) painter.fillRect(i.rect(), color) painter.end() # let style alter the drawing based on mode, and create QPixmap pixmap = QApplication.style().generatedIconPixmap(mode, QPixmap.fromImage(i), QStyleOption()) _pixmaps[key] = pixmap return pixmap
def draw_indicator(indicator: int): pixmap = QPixmap(24, 24) painter = QPainter(pixmap) w, h = pixmap.width(), pixmap.height() painter.fillRect(0, 0, w, h, QBrush((QColor(0, 0, 200, 255)))) pen = QPen(QColor("white")) pen.setWidth(2) painter.setPen(pen) font = util.get_monospace_font() font.setBold(True) font.setPixelSize(16) painter.setFont(font) f = QFontMetrics(painter.font()) indicator_str = str(indicator) if indicator < 10 else "+" fw = f.width(indicator_str) fh = f.height() painter.drawText(math.ceil(w / 2 - fw / 2), math.ceil(h / 2 + fh / 4), indicator_str) painter.end() return QIcon(pixmap)
def paintEvent(self, ev): if self.min is not None and self.max is not None: opt = QStyleOptionSlider() self.initStyleOption(opt) opt.subControls = QStyle.SC_SliderGroove | QStyle.SC_SliderHandle if self.tickPosition() != self.NoTicks: opt.subControls |= QStyle.SC_SliderTickmarks groove_rect = self.style().subControlRect( QStyle.CC_Slider, opt, QStyle.SC_SliderGroove, self ) rect = QRect( groove_rect.left() + self.min * groove_rect.width(), groove_rect.top(), (self.max-self.min) * groove_rect.width(), groove_rect.height() ) painter = QPainter(self) painter.fillRect(rect, QBrush(Qt.red)) super(ColorRangeSlider, self).paintEvent(ev)
def paintEvent(self, event): """QWidget.paintEvent() implementation """ painter = QPainter(self) painter.fillRect(event.rect(), self.palette().color(QPalette.Window)) painter.setPen(Qt.black) block = self._qpart.firstVisibleBlock() blockNumber = block.blockNumber() top = int(self._qpart.blockBoundingGeometry(block).translated(self._qpart.contentOffset()).top()) bottom = top + int(self._qpart.blockBoundingRect(block).height()) singleBlockHeight = self._qpart.cursorRect().height() boundingRect = self._qpart.blockBoundingRect(block) while block.isValid() and top <= event.rect().bottom(): if block.isVisible() and bottom >= event.rect().top(): number = str(blockNumber + 1) painter.drawText(0, top, self.__width - self._RIGHT_MARGIN - self._LEFT_MARGIN, self._qpart.fontMetrics().height(), Qt.AlignRight, number) if boundingRect.height() >= singleBlockHeight * 2: # wrapped block painter.fillRect(1, top + singleBlockHeight, self.__width - 2, boundingRect.height() - singleBlockHeight - 2, Qt.darkGreen) block = block.next() boundingRect = self._qpart.blockBoundingRect(block) top = bottom bottom = top + int(boundingRect.height()) blockNumber += 1
def lineNumberAreaPaintEvent(self, event): painter = QPainter(self.lineNumbers) painter.fillRect(event.rect(), QColor(230, 230, 230)) d = event.rect().topRight() a = event.rect().bottomRight() painter.setPen(Qt.darkGray) painter.drawLine(d.x(), d.y(), a.x(), a.y()) painter.setPen(QColor(100, 100, 100)) painter.setFont(self.font()) block = self.firstVisibleBlock() blockNumber = block.blockNumber() top = int( self.blockBoundingGeometry(block).translated( self.contentOffset()).top()) bottom = top + int(self.blockBoundingRect(block).height()) while block.isValid() and top <= event.rect().bottom(): if block.isVisible() and bottom >= event.rect().top(): number = str(blockNumber + 1) painter.drawText(4, top, self.lineNumbers.width() - 8, self.fontMetrics().height(), Qt.AlignRight, number) block = block.next() top = bottom bottom = top + int(self.blockBoundingRect(block).height()) blockNumber += 1
def mousePressEvent(self, event): child = self.childAt(event.pos()) if not child: return pixmap = QPixmap(child.pixmap()) itemData = QByteArray() dataStream = QDataStream(itemData, QIODevice.WriteOnly) dataStream << pixmap << QPoint(event.pos() - child.pos()) mimeData = QMimeData() mimeData.setData('application/x-dnditemdata', itemData) drag = QDrag(self) drag.setMimeData(mimeData) drag.setPixmap(pixmap) drag.setHotSpot(event.pos() - child.pos()) tempPixmap = QPixmap(pixmap) painter = QPainter() painter.begin(tempPixmap) painter.fillRect(pixmap.rect(), QColor(127, 127, 127, 127)) painter.end() child.setPixmap(tempPixmap) if drag.exec_(Qt.CopyAction | Qt.MoveAction, Qt.CopyAction) == Qt.MoveAction: child.close() else: child.show() child.setPixmap(pixmap)
def paintEvent(self, event): """QWidget.paintEvent() implementation Draw markers """ painter = QPainter(self) painter.fillRect(event.rect(), self.palette().color(QPalette.Window)) block = self._qpart.firstVisibleBlock() blockBoundingGeometry = self._qpart.blockBoundingGeometry(block).translated(self._qpart.contentOffset()) top = blockBoundingGeometry.top() bottom = top + blockBoundingGeometry.height() for block in qutepart.iterateBlocksFrom(block): height = self._qpart.blockBoundingGeometry(block).height() if top > event.rect().bottom(): break if block.isVisible() and \ bottom >= event.rect().top(): if block.blockNumber() in self._qpart.lintMarks: msgType, msgText = self._qpart.lintMarks[block.blockNumber()] pixMap = self._lintPixmaps[msgType] yPos = top + ((height - pixMap.height()) / 2) # centered painter.drawPixmap(0, yPos, pixMap) if self.isBlockMarked(block): yPos = top + ((height - self._bookmarkPixmap.height()) / 2) # centered painter.drawPixmap(0, yPos, self._bookmarkPixmap) top += height
def paintEvent(self, event): background = QRadialGradient(QPointF(self.rect().topLeft()), 500, QPointF(self.rect().bottomRight())) background.setColorAt(0, self.backgroundColor1) background.setColorAt(1, self.backgroundColor2) painter = QPainter() painter.begin(self) painter.setRenderHint(QPainter.Antialiasing) painter.fillRect(event.rect(), QBrush(background)) painter.setPen(self.pen) for bubble in self.bubbles: if QRectF(bubble.position - QPointF(bubble.radius, bubble.radius), QSizeF(2*bubble.radius, 2*bubble.radius)).intersects(QRectF(event.rect())): bubble.drawBubble(painter) if self.newBubble: self.newBubble.drawBubble(painter) painter.end()
def lineNumberAreaPaintEvent(self, event): # When text zoomed line number not zoomed """Painting line number area""" painter = QPainter(self.lineNumberArea) painter.fillRect(event.rect(), Qt.lightGray) block = self.firstVisibleBlock() blockNumber = block.blockNumber() top = int(self.blockBoundingGeometry(block).translated(self.contentOffset()).top()) bottom = top + int(self.blockBoundingRect(block).height()) # font_height = self.fontMetrics().height() while block.isValid() and top <= event.rect().bottom(): if block.isVisible() and bottom >= event.rect().top(): font_original = self.document().defaultFont() size = font_original.pointSize() font = painter.font() font.setPointSize(size) painter.setFont(font) number = str(blockNumber + 1) painter.setPen(Qt.black) painter.drawText(0, top, self.lineNumberArea.width(), self.fontMetrics().height(), Qt.AlignRight, number) block = block.next() top = bottom bottom = top + int(self.blockBoundingRect(block).height()) blockNumber += 1
def createListWidget(self): listWidget = QListWidget() w, h = self.ITEM_SIZE scroll_size = 16 listWidget.setFixedWidth(w + scroll_size) listWidget.setAttribute(Qt.WA_MacShowFocusRect, False) for x in xrange(self._min_size, self._max_size): h = max(x + self.MARGIN * 2.0, h) pixmap = QPixmap(w, h) pixmap.fill(Qt.transparent) painter = QPainter(pixmap) center = h / 2.0 painter.fillRect(QRectF(self.MARGIN, center - x / 2.0, w - self.MARGIN * 2.0, x), Qt.black) painter.end() label = QLabel() label.setPixmap(pixmap) item = QListWidgetItem(listWidget) item.setSizeHint(QSize(w, h)) item.setData(Qt.UserRole, x) listWidget.addItem(item) listWidget.setItemWidget(item, label) if self._size == x: listWidget.setCurrentItem(item) return listWidget
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): painter = QPainter(self) painter.setRenderHint(QPainter.Antialiasing) if self.hovered: color = QColor(0, 0, 0, 90) painter.fillRect(0, 0, self.width(), self.height(), color) super(UnLockWindow, self).paintEvent(event)
def paintEvent(self, event): super().paintEvent(event) painter = QPainter(self) for top, _, block in self._neditor.visible_blocks: if not self.is_foldable_block(block): continue branch_rect = QRect(0, top, self.sizeHint().width(), self.sizeHint().height()) opt = QStyleOptionViewItem() opt.rect = branch_rect opt.state = (QStyle.State_Active | QStyle.State_Item | QStyle.State_Children) folded = self.user_data(block).get("folded", default=False) if not folded: opt.state |= QStyle.State_Open # Draw item self.style().drawPrimitive(QStyle.PE_IndicatorBranch, opt, painter, self) # Draw folded region background if block == self.__mouse_over and not self.__timer.isActive(): fm_height = self._neditor.fontMetrics().height() rect_height = 0 color = self.palette().highlight().color() color.setAlpha(100) if not folded: foldable_blocks = self.code_folding.foldable_blocks(block) rect_height = (len(list(foldable_blocks))) * fm_height painter.fillRect(QRect( 0, top, self.sizeHint().width(), rect_height + fm_height), color)
def paintEvent(self, event): if self.isVisible(): background_color = QColor( resources.COLOR_SCHEME.get("editor.sidebar.background")) # resources.get_color('SidebarBackground')) painter = QPainter(self) painter.fillRect(event.rect(), background_color)
def paintEvent(self, ev): color = self.palette().color(QPalette.Highlight) painter = QPainter(self) # Filled rectangle. painter.setClipRect(self.rect()) color.setAlpha(50) painter.fillRect(self.rect().adjusted(2,2,-2,-2), color) # Thin rectangle outside. color.setAlpha(150) painter.setPen(color) painter.drawRect(self.rect().adjusted(0,0,-1,-1)) # Pseudo-handles at the corners and sides color.setAlpha(100) pen = QPen(color) pen.setWidth(8) painter.setPen(pen) painter.setBackgroundMode(Qt.OpaqueMode) # Clip at 4 corners region = QRegion(QRect(0,0,20,20)) region += QRect(self.rect().width()-20, 0, 20, 20) region += QRect(self.rect().width()-20, self.rect().height()-20, 20, 20) region += QRect(0, self.rect().height()-20, 20, 20) # Clip middles region += QRect(0, self.rect().height() // 2 - 10, self.rect().width(), 20) region += QRect(self.rect().width() // 2 - 10, 0, 20, self.rect().height()) # Draw thicker rectangles, clipped at corners and sides. painter.setClipRegion(region) painter.drawRect(self.rect())
def paintEvent(self, e): painter = QPainter(self) w = self.width() h = self.height() painter.fillRect(0, 0, w, h, QBrush(QColor(255, 255, 255))) self.drawCoordLines(painter, w, h) self.drawModel(painter, w, h)
def paintEvent(self, event): super().paintEvent(event) painter = QPainter(self) width = self.width() - self.RIGHT_MARGIN - self.LEFT_MARGIN height = self._neditor.fontMetrics().height() font = self._neditor.font() font_bold = self._neditor.font() font_bold.setBold(True) pen = QPen(self._color_unselected) painter.setPen(pen) painter.setFont(font) sel_start, sel_end = self._neditor.selection_range() has_sel = sel_start != sel_end current_line, _ = self._neditor.cursor_position # Draw visible blocks for top, line, block in self._neditor.visible_blocks: # Set bold to current line and selected lines if ((has_sel and sel_start <= line <= sel_end) or (not has_sel and current_line == line)): painter.fillRect( QRect(0, top, self.width(), height), self._color_selected) else: painter.setPen(pen) painter.setFont(font) painter.drawText(self.LEFT_MARGIN, top, width, height, Qt.AlignRight, str(line + 1))
def paintEvent(self, event): """This method draws a left sidebar :param event: QEvent """ painter = QPainter(self) painter.fillRect(event.rect(), Qt.white) width = self.width() - 8 height = self.editor.fontMetrics().height() font = self.editor.font() font_bold = self.editor.font() font_bold.setBold(True) painter.setFont(font) pen = QPen(Qt.gray) painter.setPen(QPen(QColor("#e9e9e9"))) painter.drawLine(width + 7, 0, width + 7, event.rect().height()) painter.setPen(pen) current_line = self.editor.textCursor().blockNumber() for top, line, block in self.editor.visible_blocks: if current_line == line: painter.setFont(font_bold) else: painter.setFont(font) painter.drawText(5, top, width, height, Qt.AlignRight, str(line + 1))
def createEditor(self, parent: QWidget, option: QStyleOptionViewItem, index: QModelIndex): editor = QComboBox(parent) if sys.platform == "win32": # Ensure text entries are visible with windows combo boxes editor.setMinimumHeight(self.sizeHint(option, index).height() + 10) editor.addItems(self.items) if self.is_editable: editor.setEditable(True) editor.setInsertPolicy(QComboBox.NoInsert) if self.current_edit_text: editor.setEditText(self.current_edit_text) if self.colors: img = QImage(16, 16, QImage.Format_RGB32) painter = QPainter(img) painter.fillRect(img.rect(), Qt.black) rect = img.rect().adjusted(1, 1, -1, -1) for i, item in enumerate(self.items): color = self.colors[i] painter.fillRect(rect, QColor(color.red(), color.green(), color.blue(), 255)) editor.setItemData(i, QPixmap.fromImage(img), Qt.DecorationRole) del painter editor.currentIndexChanged.connect(self.currentIndexChanged) editor.editTextChanged.connect(self.on_edit_text_changed) return editor
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, event): painter = QPainter(self) rect = event.rect() rect.setWidth(self.__width()) painter.fillRect(rect, self._background_color) painter.setPen(Qt.white) font = self._console_widget.font() painter.setFont(font) width = self.__width() height = self._console_widget.fontMetrics().height() for top, line, block in self._console_widget.visible_blocks: data = self.user_data(block) prompt = data.get("prompt") text = self.PROMPT_IN color = Qt.white if prompt is not None: if prompt == self.PROMPT_INCOMPLETE: text = self.PROMPT_INCOMPLETE color = Qt.yellow else: text = self.PROMPT_OUT color = Qt.gray painter.setPen(color) painter.drawText(0, top, width, height, Qt.AlignCenter, text)
def paintEvent(self, event): painter = QPainter() painter.begin(self) painter.setRenderHint(QPainter.Antialiasing) painter.fillRect(event.rect(), QBrush(QColor(255, 255, 255, 127))) painter.setPen(QPen(Qt.NoPen)) for i in range(6): x_pos = self.width() / 2 + 30 * \ math.cos(2 * math.pi * i / 6.0) - 10 y_pos = self.height() / 2 + 30 * \ math.sin(2 * math.pi * i / 6.0) - 10 if (self.counter / 5) % 6 == i: linear_gradient = QLinearGradient( x_pos + 10, x_pos, y_pos + 10, y_pos) linear_gradient.setColorAt(0, QColor(135, 206, 250)) linear_gradient.setColorAt(1, QColor(0, 0, 128)) painter.setBrush(QBrush(linear_gradient)) else: linear_gradient = QLinearGradient( x_pos - 10, x_pos, y_pos + 10, y_pos) linear_gradient.setColorAt(0, QColor(105, 105, 105)) linear_gradient.setColorAt(1, QColor(0, 0, 0)) painter.setBrush(QBrush(linear_gradient)) painter.drawEllipse( x_pos, y_pos, 20, 20) painter.end()
def paintEvent(self, event): if not globalSettings.lineNumbersEnabled: return QWidget.paintEvent(self, event) painter = QPainter(self) painter.fillRect(event.rect(), colorValues['lineNumberArea']) painter.setPen(colorValues['lineNumberAreaText']) cursor = self.editor.cursorForPosition(QPoint(0, 0)) atEnd = False fontHeight = self.fontMetrics().height() height = self.editor.height() if globalSettings.relativeLineNumbers: relativeTo = self.editor.textCursor().blockNumber() else: relativeTo = -1 while not atEnd: rect = self.editor.cursorRect(cursor) if rect.top() >= height: break number = str(cursor.blockNumber() - relativeTo).replace('-', '−') painter.drawText(0, rect.top(), self.width() - 2, fontHeight, Qt.AlignRight, number) cursor.movePosition(QTextCursor.EndOfBlock) atEnd = cursor.atEnd() if not atEnd: cursor.movePosition(QTextCursor.NextBlock)
def paintEvent(self, event): QWidget.paintEvent(self, event) self.update_cache() if not self.cache: return rect = self._nscrollbar.overlay_rect() sb_range = self._nscrollbar.get_scrollbar_range() sb_range = max(self.visible_range, sb_range) # horizontal_margin = 3 # result_width = rect.width() - 2 * horizontal_margin + 1 result_width = rect.width() / 3 result_height = min(rect.height() / sb_range + 1, 4) # x = rect.left() + horizontal_margin x = rect.center().x() - 1 offset = rect.height() / sb_range * self.range_offset vertical_margin = ((rect.height() / sb_range) - result_height) / 2 painter = QPainter(self) for lineno in self.cache.keys(): marker = self.cache[lineno] top = rect.top() + offset + vertical_margin + \ marker.position / sb_range * rect.height() # bottom = top + result_height painter.fillRect( x, top, result_width, 4, QColor(marker.color))
def numPaintEvent(self, event): """ Paint the editor :param event: :return: """ painter = QPainter(self.numArea) painter.fillRect(event.rect(), Qt.lightGray) block = self.firstVisibleBlock() block_num = block.blockNumber() top = self.blockBoundingGeometry(block).translated(self.contentOffset()).top() bottom = top + self.blockBoundingRect(block).height() while block.isValid() and top <= event.rect().bottom(): if block.isVisible() and bottom >= event.rect().top(): number = block_num + 1 painter.setPen(Qt.darkRed) painter.drawText(0, top, self.numArea.width(), self.fontMetrics().height(), Qt.AlignRight, ' %s ' % str(number)) # padding block = block.next() top = bottom bottom = top + self.blockBoundingRect(block).height() block_num += 1
def paintGL(self): from PyQt5.QtGui import QBrush, QPen, QColor, QPainter from PyQt5.QtCore import QPointF painter = QPainter(self) painter.setPen(QPen(QColor(0, 0, 0, 0), 0)) painter.fillRect(0, 0, self.width(), self.height(), QColor(0, 0, 0)) for strand_id, strand in self.scene.strands.items(): if strand is None: continue spacing = 4 if self._blur else 1 instructions = list(zip(self.locations[strand_id][::spacing], strand.all_contents[::spacing])) if self._blur: for (x, y), (r, g, b) in instructions: painter.setBrush(QColor(r, g, b, 50)) painter.drawEllipse(QPointF(x, y), 16, 16) for (x, y), (r, g, b) in instructions: painter.setBrush(QColor(r, g, b, 50)) painter.drawEllipse(QPointF(x, y), 6, 6) painter.setBrush(QColor(r, g, b, 255)) painter.drawEllipse(QPointF(x, y), 3, 3)
def __paintRectangular(self): """ Private method to paint a rectangular raised LED. """ # Initialize coordinates, width and height of the LED width = self.height() * self.__rectRatio left = max(0, int((self.width() - width) / 2) - 1) right = min(int((self.width() + width) / 2), self.width()) height = self.height() # now do the drawing painter = QPainter(self) painter.setRenderHint(QPainter.Antialiasing, True) color = self.__led_on and self.__led_color or self.__offcolor painter.setPen(color.lighter(200)) painter.drawLine(left, 0, left, height - 1) painter.drawLine(left + 1, 0, right - 1, 0) if self.__framedLed: painter.setPen(self.palette().color(QPalette.Dark)) else: painter.setPen(color.darker()) painter.drawLine(left + 1, height - 1, right - 1, height - 1) painter.drawLine(right - 1, 1, right - 1, height - 1) painter.fillRect(left + 1, 1, right - 2, height - 2, QBrush(color)) painter.end()
def createImage(self, transform): original = QImage(self.image) if original.isNull(): return original size = transform.map(QPoint(self.maxWidth, self.maxHeight)) w = size.x() h = size.y() # Optimization: if image is smaller than maximum allowed size, just # return the loaded image. if original.size().height() <= h and original.size().width() <= w and not self.adjustSize and self.scale == 1: return original # Calculate what the size of the final image will be. w = min(w, float(original.size().width()) * self.scale) h = min(h, float(original.size().height()) * self.scale) adjustx = 1.0 adjusty = 1.0 if self.adjustSize: adjustx = min(transform.m11(), transform.m22()) adjusty = max(transform.m22(), adjustx) w *= adjustx h *= adjusty # Create a new image with correct size, and draw original on it. image = QImage(int(w + 2), int(h + 2), QImage.Format_ARGB32_Premultiplied) image.fill(QColor(0, 0, 0, 0).rgba()) painter = QPainter(image) painter.setRenderHints(QPainter.Antialiasing | QPainter.SmoothPixmapTransform) if self.adjustSize: painter.scale(adjustx, adjusty) if self.scale != 1: painter.scale(self.scale, self.scale) painter.drawImage(0, 0, original) if not self.adjustSize: # Blur out edges. blur = 30 if h < original.height(): brush1 = QLinearGradient(0, h - blur, 0, h) brush1.setSpread(QLinearGradient.PadSpread) brush1.setColorAt(0.0, QColor(0, 0, 0, 0)) brush1.setColorAt(1.0, Colors.sceneBg1) painter.fillRect(0, int(h) - blur, original.width(), int(h), brush1) if w < original.width(): brush2 = QLinearGradient(w - blur, 0, w, 0) brush2.setSpread(QLinearGradient.PadSpread) brush2.setColorAt(0.0, QColor(0, 0, 0, 0)) brush2.setColorAt(1.0, Colors.sceneBg1) painter.fillRect(int(w) - blur, 0, int(w), original.height(), brush2) return image
def createColorIcon(self, color): pixmap = QPixmap(20, 20) painter = QPainter(pixmap) painter.setPen(Qt.NoPen) painter.fillRect(QRect(0, 0, 20, 20), color) painter.end() return QIcon(pixmap)
def paintEvent(self,event): super().paintEvent(event) painter = QPainter(self) painter.fillRect(4,4,frameWidth,frameHeight,self.backBrush) painter.drawPixmap(4+(frameWidth-self.pixMap.width())//2,4+(frameHeight-self.pixMap.height())//2,self.pixMap) if self.isChecked(): painter.setPen(self.checkedPen) painter.drawRect(3,3,self.width()-6,self.height()-6)
def checkerBoardBrush(size=32): """Return a checker board brush""" tmpPixmap = QPixmap(size,size) tmpPixmap.fill(QColor(255,255,255)) brush = QBrush(QColor(220,220,220)) canvas = QPainter() canvas.begin(tmpPixmap) canvas.setPen(Qt.NoPen) s1 = size>>1 s2 = size - s1 canvas.setRenderHint(QPainter.Antialiasing, False) canvas.fillRect(QRect(0, 0, s1, s1), brush) canvas.fillRect(QRect(s1, s1, s2, s2), brush) canvas.end() return QBrush(tmpPixmap)
def _validateImage(self): if (self._sharedImage.transform != DemoItem._transform and not Colors.noRescale) or (self._sharedImage.image is None and self._sharedImage.pixmap is None): # (Re)create image according to new transform. self._sharedImage.image = None self._sharedImage.pixmap = None self._sharedImage.transform = DemoItem._transform # Let subclass create and draw a new image according to the new # transform. if Colors.noRescale: transform = QTransform() else: transform = DemoItem._transform image = self.createImage(transform) if image is not None: if Colors.showBoundingRect: # Draw red transparent rect. painter = QPainter(image) painter.fillRect(image.rect(), QColor(255, 0, 0, 50)) painter.end() self._sharedImage.unscaledBoundingRect = self._sharedImage.transform.inverted( )[0].mapRect(QRectF(image.rect())) if Colors.usePixmaps: if image.isNull(): self._sharedImage.pixmap = QPixmap(1, 1) else: self._sharedImage.pixmap = QPixmap(image.size()) self._sharedImage.pixmap.fill(QColor(0, 0, 0, 0)) painter = QPainter(self._sharedImage.pixmap) painter.drawImage(0, 0, image) else: self._sharedImage.image = image return True else: return False return True
def paintEvent(self, _): opt = QStyleOption() opt.initFrom(self) painter = QPainter(self) self.style().drawPrimitive(QStyle.PE_Widget, opt, painter, self) if self.show_pieces: piece_width = self.width() / float(len(self.pieces)) for i in xrange(len(self.pieces)): if self.pieces[i]: painter.fillRect( QRect( float(i) * piece_width, 0, math.ceil(piece_width), self.height()), QColor(230, 115, 0)) else: painter.fillRect( QRect(0, 0, self.width() * self.fraction, self.height()), QColor(230, 115, 0))
def _drawGridRanges(self, painter: QPainter): """отрисовка области рабочего диапазона""" # logger.debug(self._drawGridRanges.__doc__) self._calculateRanges() # расчёт раб.диапазона x_0 = int(self._margins[0] + self._range_pixels[0]) x_1 = int(self._margins[0] + self._range_pixels[1]) x_2 = int(self._margins[0] + self._range_pixels[2]) y_0 = int(self._margins[1]) y_1 = int(self.getDrawArea().height() + y_0) # отрисовка раб.диапазона pen = painter.pen() painter.setPen(self._style['grid']['border']) painter.fillRect(x_0, y_0, x_2 - x_0, y_1 - y_0, self._style['grid']['ranges']) painter.drawLine(x_0, y_0, x_0, y_1) painter.drawLine(x_1, y_0, x_1, y_1) painter.drawLine(x_2, y_0, x_2, y_1) painter.setPen(pen)
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() 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 paintEvent(self, event): if self._drawingCommands is None: return painter = QPainter(self) rect = event.rect() target = self.rect().size() size = self._drawingCommands[0] if not size.isNull() and ( size.width() < target.width() or size.height() < target.height() ): dx = dy = 0 if size.width() < target.width(): dx = int(0.5 * (target.width() - size.width())) if size.height() < target.height(): dy = int(0.5 * (target.height() - size.height())) painter.translate(dx, dy) isDown = self.isDown() and self._isDownColor is not None if isDown and self._isDownColor.isValid(): painter.fillRect(rect, self._isDownColor) isDown = False if self._isFlipped: painter.translate(0, target.height()) painter.scale(1, -1) for path, cmd, color in self._drawingCommands[1:]: if cmd == "f": if isDown: color = color.darker(120) painter.save() painter.setRenderHint(QPainter.Antialiasing) painter.fillPath(path, color) painter.restore() else: if isDown: color = color.darker(150) painter.save() if cmd[-1] == "a": painter.setRenderHint(QPainter.Antialiasing) pen = painter.pen() pen.setColor(color) pen.setWidth(int(cmd[0])) painter.setPen(pen) painter.drawPath(path) painter.restore()
def drawPixmapFor2d(self): self.pixmap2d = QPixmap(self.itemWidth, self.itemHeight) self.pixmap2d.fill(Qt.transparent) painter = QPainter() painter.begin(self.pixmap2d) painter.setRenderHint(QPainter.Antialiasing) pen = QPen() pen.setWidth(2) painter.setPen(pen) painter.drawRect(QRect(5, 5, self.itemWidth - 10, self.itemHeight - 10)) painter.fillRect( QRect(5, 5, self.itemWidth - 10, self.itemHeight - 10), QColor(0, 250, 154)) painter.drawText( QRect(5, 5, self.itemWidth - 10, self.itemHeight - 10), Qt.AlignCenter, "2D") painter.end()
def paintEvent(self, event): painter = QPainter(self) if self.isEnabled() and not self.isDown() and not self.isChecked(): painter.save() hover_color = QColor("#424242") faded_hover_color = QColor(hover_color) faded_hover_color.setAlpha(int(self._fader * hover_color.alpha())) painter.fillRect(event.rect(), faded_hover_color) painter.restore() elif self.isDown() or self.isChecked(): painter.save() selected_color = QColor("#161719") painter.fillRect(event.rect(), selected_color) painter.restore() is_titled = bool(self.defaultAction().property("titled")) icon_rect = QRect(0, 0, 32, 32) icon_rect.moveCenter(event.rect().center()) if is_titled: font = painter.font() center_rect = event.rect() font.setPointSizeF(6) fm = QFontMetrics(font) line_height = fm.height() text_flags = Qt.AlignHCenter | Qt.AlignTop project_name = self.defaultAction().property("heading") if project_name is not None: center_rect.adjust(0, line_height, 0, 0) icon_rect.moveTop(center_rect.top()) else: icon_rect.moveCenter(center_rect.center()) self.icon().paint(painter, icon_rect, Qt.AlignCenter) painter.setFont(font) r = QRect(0, 5, self.rect().width(), line_height) painter.setPen(Qt.white) margin = 5 available_width = r.width() - margin ellided_project_name = fm.elidedText(project_name, Qt.ElideMiddle, available_width) painter.drawText(r, text_flags, ellided_project_name) else: self.icon().paint(painter, icon_rect, Qt.AlignCenter)
def paintEvent(self, event): painter = QPainter() painter.begin(self) painter.setRenderHint(QPainter.Antialiasing) painter.fillRect(event.rect(), QBrush(QColor(255, 255, 255, 127))) painter.setPen(QPen(Qt.NoPen)) for i in range(6): if self.counter % 6 == i: painter.setBrush(QBrush(QColor(0, 0, 0))) else: painter.setBrush(QBrush(QColor(200, 200, 200))) painter.drawEllipse( self.width() / 2 + 30 * math.cos(2 * math.pi * i / 6.0) - 10, self.height() / 2 + 30 * math.sin(2 * math.pi * i / 6.0) - 10, 20, 20) painter.end()
def paintEvent(self, event): painter = QPainter(self) painter.setFont(UIFont) painter.setRenderHint(QPainter.Antialiasing) rect = self.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)] 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)) self.drawBackground(painter) for glyph, layerName in layers: self.drawGlyphLayer(painter, glyph, layerName) self.drawForeground(painter) painter.restore()
def paintEvent(self, event): p = QPainter() color = QStyleParser.getColor(self.styleSheet(), 'color: rgb') pen = QPen(color.lighter(75)) rect = self.geometry() p.begin(self) # if log type fillbar if self._logarithmic: self._intFullscale = self._fullscale_dB if self._level != 0: self._intLevel = self._intFullscale - 20 * math.log10( (self._max - self._min) / self._level) else: self._intLevel = 0 else: self._intFullscale = self._max - self._min self._intLevel = self._level # calc and draw respect orientation if self._orientation == Qt.Horizontal: _width = self._intLevel * (rect.width() / self._intFullscale) _height = rect.height() p.fillRect(0, 0, _width, _height, color) else: _width = rect.width() - 1 _height = self._intLevel * (rect.height() / self._intFullscale) p.fillRect(0, (rect.height() - _height) + 1, _width, _height, color) # draw border if self._border: p.setPen(pen) p.drawRect(QRect(0, 0, rect.width() - 1, rect.height() - 1)) # draw markers if self._markers: self._paintMarkers(rect, p) p.end()
def paintEvent(self, e): qp = QPainter() qp.begin(self) fr = self.frameRect() b = self.lineWidth() fr.adjust(b, b, -b, -b) qp.fillRect(fr, QColor(255, 255, 255)) def bzsez(): g = 100 pen = QPen(QColor(255, 0, 0, 255 - g)) qp.setPen(pen) font = QFont(qp.font()) font.setPixelSize(self.width() / 10) qp.setFont(font) qp.drawText(fr, Qt.AlignCenter, "Bitte zeichnen Sie\neine Zahl von 0-9!") #bzsez() for i, p in enumerate(reversed(self.paths)): if i > 0: pen = QPen(QColor(0, 0, 0, 20 - 20 * i / self.max_paths)) else: pen = QPen(Qt.black) pen.setWidth(self.width() / 32.0) pen.setJoinStyle(Qt.RoundJoin) pen.setCapStyle(Qt.RoundCap) qp.setPen(pen) qp.drawPath(p) if self.recreatePath: bzsez() qp.end() super().paintEvent(e)
def paintEvent(self, e): p = QPainter(self) # Paint border bar_rect = self.rect().adjusted(0, 15, 0, -1) if self._background is not None: p.drawTiledPixmap(bar_rect, self._background) pen = QPen() pen.setColor(Qt.black) pen.setWidth(1) p.setPen(pen) bar_rect.adjust(0, 0, -1, 0) p.drawRect(bar_rect) p.setPen(Qt.white) # Paint Spectrum bar_rect.adjust(1, 1, 0, 0) p.fillRect(bar_rect, QBrush(self._gradient)) # Paint Picker p.drawPixmap(self._pickRect, self._pickerPixmap) # Draw Label label_rect = QRect(200, 1, 20, 15) p.drawText(label_rect, Qt.AlignRight, str(self._value)) if len(self._label) > 0: label_rect.adjust(-200, 0, 0, 0) p.drawText(label_rect, Qt.AlignLeft, self._label)
def paintEvent(self, event): p = QPainter() color = QStyleParser.getColor(self.styleSheet(), 'color: rgb') rect = self.geometry() # calc and draw respect orientation fullscale = self._max - self._min slider_size = self._slider_size p.begin(self) # calc slider respect orientation if self._orientation == Qt.Horizontal: posX = self._level * (rect.width() / fullscale) posY = rect.height() / 2 else: posX = rect.width() / 2 posY = rect.height() - ((self._level * rect.height()) / fullscale) # calc coordinates respect orientation rect_0, rect_1, color_0, color_1 = self._calcCoordinates(posX, posY, slider_size) # draw seekbar p.fillRect(rect_0, color_0) p.setPen(color_0) p.drawRect(rect_0) p.fillRect(rect_1, color_1) p.setPen(color_1) p.drawRect(rect_1) # draw slider for i in range(min(slider_size.width(), slider_size.height())): p.setPen(self._slider_color.lighter(100 + (i * 10))) p.drawRect(posX - (slider_size.width() - i) // 2, posY - (slider_size.height() - i) // 2, slider_size.width() - i, slider_size.height() - i) p.end()
def paintEvent(self, event): if not globalSettings.lineNumbersEnabled: return QWidget.paintEvent(self, event) painter = QPainter(self) painter.fillRect(event.rect(), colorValues['lineNumberArea']) cursor = QTextCursor(self.editor.document()) cursor.movePosition(QTextCursor.Start) atEnd = False while not atEnd: rect = self.editor.cursorRect(cursor) block = cursor.block() if block.isVisible(): number = str(cursor.blockNumber() + 1) painter.setPen(colorValues['lineNumberAreaText']) painter.drawText(0, rect.top(), self.width() - 2, self.fontMetrics().height(), Qt.AlignRight, number) cursor.movePosition(QTextCursor.EndOfBlock) atEnd = cursor.atEnd() if not atEnd: cursor.movePosition(QTextCursor.NextBlock)
def paintEvent(self, event): painter = QPainter(self) painter.fillRect(event.rect(), self.numberBarColor) block = self.editor.firstVisibleBlock() while block.isValid(): blockNumber = block.blockNumber() block_top = self.editor.blockBoundingGeometry( block).translated(self.editor.contentOffset()).top() if blockNumber == self.editor.textCursor().blockNumber(): self.font.setBold(True) painter.setPen(QColor("#000000")) else: self.font.setBold(False) painter.setPen(QColor("#717171")) paint_rect = QRect(0, block_top, self.width(), self.editor.fontMetrics().height()) painter.drawText(paint_rect, Qt.AlignCenter, str(blockNumber + 1)) block = block.next()
def createReflectedImage(self): self.refImage = QImage(self.iw, self.ih, QImage.Format_ARGB32) painter = QPainter() painter.begin(self.refImage) painter.drawImage(0, 0, self.img) mode = QPainter.CompositionMode_DestinationIn painter.setCompositionMode(mode) gradient = QLinearGradient(self.iw / 2, 0, self.iw / 2, self.ih) gradient.setColorAt(1, QColor(0, 0, 0)) gradient.setColorAt(0, Qt.transparent) painter.fillRect(0, 0, self.iw, self.ih, gradient) painter.end()
def paintEvent(self, event): painter = QPainter(self) painter.setFont(self.font) painter.fillRect(0, 0, self.width(), self.height(), QColor(self.theme[1])) dev = (self.width()/300)*2 for i in range(0, 3): pos = 5+i*self.height()*dev+2*(i*2) if(i != self.sellected): painter.setPen(QColor(self.backgrounds[i])) painter.drawRect(pos, 5, self.height()*dev, self.height()-10) painter.drawText(pos + (self.height() * dev) * 0.5 - QFontMetrics(self.font).width(self.texts[i])*0.5, self.height()*0.5+self.font.pointSize()*0.5, self.texts[i]) else: painter.fillRect(pos, 5, self.height()*dev, self.height()-10, QColor(self.theme[4])) painter.setPen(QColor(self.backgrounds[i])) painter.drawRect(pos, 5, self.height()*dev, self.height()-10) painter.setPen(QColor(self.theme[5])) painter.drawText(pos + (self.height() * dev) * 0.5 - QFontMetrics(self.font).width(self.texts[i])*0.5, self.height()*0.5+self.font.pointSize()*0.5, self.texts[i])
def paintEvent(self, event): edit = self.edit font_metrics = edit.fontMetrics() block = edit.firstVisibleBlock() count = block.blockNumber() painter = QPainter(self) painter.fillRect(event.rect(), edit.palette().base()) first = True while block.isValid(): count += 1 block_top = edit.blockBoundingGeometry(block).translated( edit.contentOffset()).top() if not block.isVisible() or block_top > event.rect().bottom(): break rect = QRect(0, block_top, self.width(), font_metrics.height()) self.draw_block(painter, rect, block, first) first = False block = block.next() painter.end() super().paintEvent(event)
def repaint_line_number_area(self, event): painter = QPainter(self.line_number_area) painter.fillRect(event.rect(), Qt.lightGray) block = self.firstVisibleBlock() block_number = block.blockNumber() top = int( self.blockBoundingGeometry(block).translated( self.contentOffset()).top()) bottom = top + int(self.blockBoundingGeometry(block).height()) while block.isValid() and top <= event.rect().bottom(): if block.isVisible() and bottom >= event.rect().top(): number = str(block_number + 1) painter.setPen(Qt.black) painter.drawText(-2, top, self.line_number_area.width(), self.fontMetrics().height(), Qt.AlignRight, number) block = block.next() top = bottom bottom = top + int(self.blockBoundingGeometry(block).height()) block_number += 1
def paintEvent(self, event): painter = QPainter(self) painter.setRenderHint(QPainter.Antialiasing) rectangle = event.rect() if self.isHead: color = Qt.darkYellow elif self.isSnake: color = Qt.darkGreen elif self.isApple: color = Qt.darkRed else: color = Qt.lightGray painter.fillRect(rectangle, QBrush(color)) pen = QPen(color) pen.setWidth(1) painter.setPen(pen) painter.drawRect(rectangle)
def lineNumberAreaPaintEvent(self, event): painter = QPainter(self.lineNumberArea) painter.fillRect(event.rect(), Qt.cyan) cursor = QTextCursor(self.document()) cursor.movePosition(QTextCursor.Start) atEnd = False while not atEnd: rect = self.cursorRect(cursor) block = cursor.block() if block.isVisible(): number = str(cursor.blockNumber() + 1) painter.setPen(Qt.darkCyan) painter.drawText(0, rect.top(), self.lineNumberArea.width() - 2, self.fontMetrics().height(), Qt.AlignRight, number) cursor.movePosition(QTextCursor.EndOfBlock) atEnd = cursor.atEnd() if not atEnd: cursor.movePosition(QTextCursor.NextBlock)
def lineNumberAreaPaintEvent(self, event): """This method draws the current lineNumberArea for while""" painter = QPainter(self.lineNumberArea) painter.fillRect(event.rect(), QColor(Qt.lightGray).darker(300)) block = self.firstVisibleBlock() blockNumber = block.blockNumber() top = int(self.blockBoundingGeometry(block).translated(self.contentOffset()).top()) bottom = top + int(self.blockBoundingRect(block).height()) while block.isValid() and top <= event.rect().bottom(): if block.isVisible() and bottom >= event.rect().top(): number = str(blockNumber + 1) painter.setPen(QColor(Qt.lightGray)) painter.drawText(0, top, self.lineNumberArea.width(), self.fontMetrics().height(), Qt.AlignRight, number) block = block.next() top = bottom bottom = top + int(self.blockBoundingRect(block).height()) blockNumber += 1
def drawWidget(self, qp: QPainter): colors = [ QColor(0xff, 0xff, 0xff), # 0x00 bg QColor(0xc0, 0xa0, 0xa0), # 1 QColor(0xc0, 0x00, 0x60), # 2 QColor(0xc0, 0x60, 0x00), # 3 QColor(0xa0, 0xc0, 0x20), # 4 QColor(0x00, 0xc0, 0x80), # 5 QColor(0x40, 0x80, 0x80), # 6 QColor(0x80, 0x40, 0xc0), # 7 QColor(0x40, 0x40, 0xc0), # 8 QColor(0x40, 0xa0, 0xc0), # 9 QColor(0x40, 0x40, 0x40), # -2 sel QColor(0x00, 0x00, 0x00), ] # -1 border for i in range(0, self.hanoi.rows): for j in range(0, self.hanoi.cols): h = self.hanoi.M[i, j] qp.fillRect(j * self.xrate, i * self.yrate, self.xrate, self.yrate, colors[h])
def drawCropBox(self): pm = self.pm_tmp.copy() pm_box = pm.copy(self.p1.x(), self.p1.y(), self.p2.x() - self.p1.x(), self.p2.y() - self.p1.y()) painter = QPainter(pm) painter.fillRect(0, 0, pm.width(), pm.height(), QColor(127, 127, 127, 127)) painter.drawPixmap(self.p1.x(), self.p1.y(), pm_box) painter.drawRect(self.p1.x(), self.p1.y(), self.p2.x() - self.p1.x(), self.p2.y() - self.p1.y()) painter.drawRect(self.p1.x(), self.p1.y(), 59, 59) painter.drawRect(self.p2.x(), self.p2.y(), -59, -59) painter.setPen(Qt.white) painter.drawRect(self.p1.x() + 1, self.p1.y() + 1, 57, 57) painter.drawRect(self.p2.x() - 1, self.p2.y() - 1, -57, -57) painter.end() self.setPixmap(pm) self.imageUpdated.emit()
def paintGame(painter: QPainter): painter.fillRect(0, 0, 300, 300, Qt.white) pen = painter.pen() pen.setWidth(3) painter.setPen(pen) painter.drawLine(0, 100, 300, 100) painter.drawLine(0, 200, 300, 200) painter.drawLine(100, 0, 100, 300) painter.drawLine(200, 0, 200, 300) font = painter.font() font.setPixelSize(80) painter.setFont(font) for i in range(3): for j in range(3): if board[i][j] != '_': painter.drawText(i * 100, j * 100, 100, 100, Qt.AlignCenter, board[i][j])
def showNextPiece(self): if self.nextPieceLabel is None: return dx = self.nextPiece.maxX() - self.nextPiece.minX() + 1 dy = self.nextPiece.maxY() - self.nextPiece.minY() + 1 pixmap = QPixmap(dx * self.squareWidth(), dy * self.squareHeight()) painter = QPainter(pixmap) painter.fillRect(pixmap.rect(), self.nextPieceLabel.palette().window()) for i in range(4): x = self.nextPiece.x(i) - self.nextPiece.minX() y = self.nextPiece.y(i) - self.nextPiece.minY() self.drawSquare(painter, x * self.squareWidth(), y * self.squareHeight(), self.nextPiece.shape()) painter.end() self.nextPieceLabel.setPixmap(pixmap)
def paintEvent(self, event): if self.image.isNull(): return painter = QPainter(self) painter.setRenderHint(QPainter.Antialiasing) rect = QRect(-self.origin / self.zoom, self.size() / self.zoom) cropped = self.image.copy(rect) image = cropped.scaled(self.size(), Qt.KeepAspectRatio, Qt.SmoothTransformation) painter.drawImage(0, 0, image) if self.pressedPoint is not None and not self.moving: painter.setPen(QPen(QColor(255, 255, 255, 128), 3.0)) painter.drawEllipse(self.pressedPoint, self.triggerDistance, self.triggerDistance) if self.currentColor is not None: painter.fillRect(0, 0, self.size().width(), 20, self.currentColor)
def paintEvent(self, event): painter = QPainter() painter.begin(self) painter.setRenderHint(QPainter.Antialiasing) painter.fillRect(event.rect(), QBrush(QColor(255, 255, 255, 127))) painter.setPen(QPen(Qt.NoPen)) for i in range(1, 7): if self.position_index == i: painter.setBrush(QBrush(QColor(255, 165, 0))) else: painter.setBrush(QBrush(QColor(127, 127, 127))) painter.drawEllipse( self.width() / 2 + 30 * numpy.cos(2 * numpy.pi * i / 6.0) - 10, self.height() / 2 + 30 * numpy.sin(2 * numpy.pi * i / 6.0) - 10, 20, 20) time.sleep(0.005) painter.end()
def paint(self, painter: QtGui.QPainter, option: 'QStyleOptionGraphicsItem', widget: QWidget = None): print(option.levelOfDetailFromTransform(painter.worldTransform())) painter.save() pen = QPen(Qt.red) pen.setWidth(0) painter.setPen(pen) brush = pen.brush() for i in range(200 - 1): height = data['high'][i] - data['low'][i] painter.fillRect( QRectF(i * 3, data['high'][i] - data['high'].min(), 1, height), brush) painter.fillRect(QRectF(100, 100, 100, -100), Qt.blue) painter.restore()