def brushChanged(self): style = Qt.BrushStyle(self.brushStyleComboBox.itemData( self.brushStyleComboBox.currentIndex(), IdRole)) if style == Qt.LinearGradientPattern: linearGradient = QLinearGradient(0, 0, 100, 100) linearGradient.setColorAt(0.0, Qt.white) linearGradient.setColorAt(0.2, Qt.green) linearGradient.setColorAt(1.0, Qt.black) self.renderArea.setBrush(QBrush(linearGradient)) elif style == Qt.RadialGradientPattern: radialGradient = QRadialGradient(50, 50, 50, 70, 70) radialGradient.setColorAt(0.0, Qt.white) radialGradient.setColorAt(0.2, Qt.green) radialGradient.setColorAt(1.0, Qt.black) self.renderArea.setBrush(QBrush(radialGradient)) elif style == Qt.ConicalGradientPattern: conicalGradient = QConicalGradient(50, 50, 150) conicalGradient.setColorAt(0.0, Qt.white) conicalGradient.setColorAt(0.2, Qt.green) conicalGradient.setColorAt(1.0, Qt.black) self.renderArea.setBrush(QBrush(conicalGradient)) elif style == Qt.TexturePattern: self.renderArea.setBrush(QBrush(QPixmap(':/images/brick.png'))) else: self.renderArea.setBrush(QBrush(Qt.green, style))
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 setupScene(self): self.m_scene.setSceneRect(-300, -200, 600, 460) linearGrad = QLinearGradient(QPointF(-100, -100), QPointF(100, 100)) linearGrad.setColorAt(0, Qt.darkGreen)#QColor(255, 255, 255)) linearGrad.setColorAt(1, Qt.green)#QQColor(192, 192, 255)) self.setBackgroundBrush(linearGrad) radialGrad = QRadialGradient(30, 30, 30) radialGrad.setColorAt(0, Qt.yellow) radialGrad.setColorAt(0.2, Qt.yellow) radialGrad.setColorAt(1, Qt.transparent) pixmap = QPixmap(60, 60) pixmap.fill(Qt.transparent) painter = QPainter(pixmap) painter.setPen(Qt.NoPen) painter.setBrush(radialGrad) painter.drawEllipse(0, 0, 60, 60) painter.end() self.m_lightSource = self.m_scene.addPixmap(pixmap) self.m_lightSource.setZValue(2) self.proto = ProtoObj(0, 0, 50, 50, self) self.proto.initObj() #self.m_items.append(self.proto.getObj()[0]) self.m_scene.addItem(self.proto.getObj()[0])
def setup_scene(self): self.m_scene.setSceneRect(0, 0, MAP_WIDTH, MAP_HEIGHT) linear_grad = QLinearGradient(QPointF(-100, -100), QPointF(100, 100)) linear_grad.setColorAt(0, QColor(255, 255, 255)) linear_grad.setColorAt(1, QColor(192, 192, 255)) self.setBackgroundBrush(linear_grad)
def drawBackground(self, painter, rect): # Shadow. sceneRect = self.sceneRect() rightShadow = QRectF(sceneRect.right(), sceneRect.top() + 5, 5, sceneRect.height()) bottomShadow = QRectF(sceneRect.left() + 5, sceneRect.bottom(), sceneRect.width(), 5) if rightShadow.intersects(rect) or rightShadow.contains(rect): painter.fillRect(rightShadow, Qt.darkGray) if bottomShadow.intersects(rect) or bottomShadow.contains(rect): painter.fillRect(bottomShadow, Qt.darkGray) # Fill. gradient = QLinearGradient(sceneRect.topLeft(), sceneRect.bottomRight()) gradient.setColorAt(0, Qt.white) gradient.setColorAt(1, Qt.lightGray) painter.fillRect(rect.intersected(sceneRect), QBrush(gradient)) painter.setBrush(Qt.NoBrush) painter.drawRect(sceneRect) # Text. textRect = QRectF(sceneRect.left() + 4, sceneRect.top() + 4, sceneRect.width() - 4, sceneRect.height() - 4) message = "Click and drag the nodes around, and zoom with the " \ "mouse wheel or the '+' and '-' keys" font = painter.font() font.setBold(True) font.setPointSize(14) painter.setFont(font) painter.setPen(Qt.lightGray) painter.drawText(textRect.translated(2, 2), message) painter.setPen(Qt.black) painter.drawText(textRect, message)
def __init__(self, parent = None): super().__init__(parent) self.monitorWin = parent if self.monitorWin: self.monitorWin.sigTaskUpdating.connect(self.slotTaskUpdate) self.scene = QGraphicsScene(self) self.scene.setSceneRect(0, 0, self.SIZE[0], self.SIZE[1]) self.setScene(self.scene) self._speedsPen = QPen(Qt.white) gradient = QLinearGradient(0, 0, self.SIZE[0], self.SIZE[1]) gradient.setColorAt(0.0, Qt.darkGreen) gradient.setColorAt(1.0, Qt.yellow) self._speedsBrush = QBrush(gradient) # add elements to the scene self._speedsPolygon = self.scene.addPolygon(QPolygonF(), self._speedsPen, self._speedsBrush) self._progressText = self.scene.addText("") self._progressText.setPos(10, 0) self.setupDropSupport()
def initData(self): self._hovered = False self.linear_gradient = QLinearGradient() self.linear_gradient.setStart(0, 10) self.linear_gradient.setFinalStop(0, 40) self.linear_gradient.setColorAt(0.1, QColor(14, 179, 255)); self.linear_gradient.setColorAt(0.5, QColor(114, 232, 255)); self.linear_gradient.setColorAt(1, QColor(14, 179, 255)); self.mask_linear_gradient = QLinearGradient() self.mask_linear_gradient.setStart(0, 10) self.mask_linear_gradient.setFinalStop(0, 40) self.mask_linear_gradient.setColorAt(0.1, QColor(0, 100, 40)) self.mask_linear_gradient.setColorAt(0.5, QColor(0, 72, 16)) self.mask_linear_gradient.setColorAt(1, QColor(0, 255, 40)) self.text = "" self.percentage = 0 self.lyric_id = 0 self.line1_text = '' self.line1_percentage = 0 self.line2_text = '' self.line2_percentage = 0 self.lrcfont = QFont() self.lrcfont.setPixelSize(30) self.setFont(self.lrcfont) self._lineMode = 1
def drawSpan(self, painter, rect): opt = QStyleOptionSlider() QSlider.initStyleOption(self, opt) # area groove = self.style().subControlRect(QStyle.CC_Slider, opt, QStyle.SC_SliderGroove, self) if opt.orientation == QtCore.Qt.Horizontal: groove.adjust(0, 0, -1, 0) else: groove.adjust(0, 0, 0, -1) # pen & brush painter.setPen(QPen(self.gradientLeftColor, 0)) if opt.orientation == QtCore.Qt.Horizontal: self.setupPainter(painter, opt.orientation, groove.center().x(), groove.top(), groove.center().x(), groove.bottom()) else: self.setupPainter(painter, opt.orientation, groove.left(), groove.center().y(), groove.right(), groove.center().y()) # draw groove intersected = QtCore.QRectF(rect.intersected(groove)) gradient = QLinearGradient(intersected.topLeft(), intersected.topRight()) gradient.setColorAt(0, self.gradientLeft) gradient.setColorAt(1, self.gradientRight) painter.fillRect(intersected, gradient)
def get_linear_gradient(self): fontHeight = self.fontMetrics().height() startPoint = QPoint(self.rect().x(), self.rect().y() + 0.5 * (self.rect().height() - fontHeight)) endPoint = QPoint(startPoint.x(), startPoint.y() + fontHeight) linear = QLinearGradient(startPoint, endPoint) colorCounts = len(self.colors) for i in range(colorCounts): linear.setColorAt(0.2 + i / colorCounts, self.colors[i]) return linear
def setupPainter(self, painter, orientation, x1, y1, x2, y2): highlight = self.palette().color(QPalette.Highlight) gradient = QLinearGradient(x1, y1, x2, y2) gradient.setColorAt(0, highlight.darker(120)) gradient.setColorAt(1, highlight.lighter(108)) painter.setBrush(gradient) if orientation == Qt.Horizontal: painter.setPen(QPen(highlight.darker(130), 0)) else: painter.setPen(QPen(highlight.darker(150), 0))
def paintEvent(self, event): painter = QPainter(self) font_metrics = QFontMetrics(self.font()) if font_metrics.width(self.text()) > self.contentsRect().width(): label_width = self.size().width() fade_start = 1 - 50.0/label_width if label_width > 50 else 0.0 gradient = QLinearGradient(0, 0, label_width, 0) gradient.setColorAt(fade_start, self.palette().color(self.foregroundRole())) gradient.setColorAt(1.0, Qt.transparent) painter.setPen(QPen(QBrush(gradient), 1.0)) painter.drawText(self.contentsRect(), Qt.TextSingleLine | int(self.alignment()), self.text())
def __init__(self): gradient = QLinearGradient(QPointF(50, -20), QPointF(80, 20)) gradient.setColorAt(0.0, Qt.white) gradient.setColorAt(1.0, QColor(0xa6, 0xce, 0x39)) self.background = QBrush(QColor(64, 32, 64)) self.circleBrush = QBrush(gradient) self.circlePen = QPen(Qt.black) self.circlePen.setWidth(1) self.textPen = QPen(Qt.white) self.textFont = QFont() self.textFont.setPixelSize(50)
def paintEvent(self, _event): qp = QPainter(self) g = QLinearGradient(0.0, 0.0, 0.0, self.height()) g.setColorAt(0, Qt.white) g.setColorAt(1, Qt.black) y = self.height() - self.reflectivity * self.height() / 4095.0 qp.fillRect(0, 0, self.width(), self.height(), g) qp.setPen(Qt.red) qp.drawLine(0, y, self.width(), y)
def setup_scene(self): self.m_scene.setSceneRect(0, 0, WINDOW_WIDTH, WINDOW_HEIGHT) self.centerOn(WINDOW_WIDTH/2, WINDOW_HEIGHT/2) linear_grad = QLinearGradient(QPointF(-100, -100), QPointF(100, 100)) linear_grad.setColorAt(0, QColor(255, 255, 255)) linear_grad.setColorAt(1, QColor(192, 192, 255)) self.setBackgroundBrush(linear_grad) link = Link(parent=self) link.move_sprite([WINDOW_WIDTH/2, WINDOW_HEIGHT/2]) self.m_sprites.append(link)
def __init__(self, parent): QWidget.__init__(self, parent) self.setAttribute(Qt.WA_OpaquePaintEvent) # defaults are VERTICAL, COLOR_GREEN, STYLE_DEFAULT self.fChannelCount = 0 self.fChannelData = [] self.fLastChannelData = [] self.fMeterColor = self.COLOR_GREEN self.fMeterColorBase = QColor(93, 231, 61) self.fMeterColorBaseAlt = QColor(15, 110, 15, 100) self.fMeterLinesEnabled = True self.fMeterOrientation = self.VERTICAL self.fMeterStyle = self.STYLE_DEFAULT self.fMeterBackground = QColor("#070707") self.fMeterGradient = QLinearGradient(0, 0, 0, 0) self.fMeterPixmaps = () self.fSmoothMultiplier = 2 self.updateGrandient()
def setOrientation(self, orientation): self.fOrientation = orientation self.fGradientMeter = QLinearGradient(0, 0, 1, 1) if self.fMeterStyle == self.STYLE_OPENAV: self.fGradientMeter.setColorAt(0.0, self.fColorBase) self.fGradientMeter.setColorAt(1.0, self.fColorBase) elif self.fOrientation == self.HORIZONTAL: self.fGradientMeter.setColorAt(0.0, self.fColorBase) self.fGradientMeter.setColorAt(0.2, self.fColorBase) self.fGradientMeter.setColorAt(0.4, self.fColorBase) self.fGradientMeter.setColorAt(0.6, self.fColorBase) self.fGradientMeter.setColorAt(0.8, Qt.yellow) self.fGradientMeter.setColorAt(1.0, Qt.red) elif self.fOrientation == self.VERTICAL: self.fGradientMeter.setColorAt(0.0, Qt.red) self.fGradientMeter.setColorAt(0.2, Qt.yellow) self.fGradientMeter.setColorAt(0.4, self.fColorBase) self.fGradientMeter.setColorAt(0.6, self.fColorBase) self.fGradientMeter.setColorAt(0.8, self.fColorBase) self.fGradientMeter.setColorAt(1.0, self.fColorBase) else: return qCritical("DigitalPeakMeter::setOrientation(%i) - invalid orientation" % orientation) self.updateSizes()
def paintEvent(self, event): painter = QPainter(self) painter.setRenderHint(QPainter.Antialiasing) painter.scale(self.width() / 100.0, self.height() / 100.0) painter.translate(50.0, 50.0) painter.rotate(-self.rotationAngle) painter.translate(-50.0, -50.0) painter.setPen( QPen(self.penColor, self.penWidth, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin)) gradient = QLinearGradient(0, 0, 0, 100) gradient.setColorAt(0.0, self.fillColor1) gradient.setColorAt(1.0, self.fillColor2) painter.setBrush(QBrush(gradient)) painter.drawPath(self.path)
def createImage(self, transform): scaledRect = transform.mapRect(QRect(0, 0, 25, 25)) image = QImage(scaledRect.width(), scaledRect.height(), QImage.Format_ARGB32_Premultiplied) image.fill(0) painter = QPainter(image) painter.scale(transform.m11(), transform.m22()) painter.setRenderHints(QPainter.TextAntialiasing | QPainter.Antialiasing | QPainter.SmoothPixmapTransform) painter.setPen(Qt.NoPen) if Colors.useEightBitPalette: painter.setBrush(QColor(102, 175, 54)) painter.drawEllipse(0, 0, 25, 25) painter.setFont(Colors.tickerFont()) painter.setPen(QColor(255, 255, 255)) painter.drawText(10, 15, self.letter) else: brush = QLinearGradient(0, 0, 0, 25) brush.setSpread(QLinearGradient.PadSpread) brush.setColorAt(0.0, QColor(102, 175, 54, 200)) brush.setColorAt(1.0, QColor(102, 175, 54, 60)) painter.setBrush(brush) painter.drawEllipse(0, 0, 25, 25) painter.setFont(Colors.tickerFont()) painter.setPen(QColor(255, 255, 255, 255)) painter.drawText(10, 15, self.letter) return image
def __init__(self): super(DQuickWidget, self).__init__() self.resize(1000, 100) self.setMinimumSize(100, 80) self.linear_gradient = QLinearGradient() self.linear_gradient.setStart(0, 10) self.linear_gradient.setFinalStop(0, 40) self.linear_gradient.setColorAt(0.1, QColor(14, 179, 255)); self.linear_gradient.setColorAt(0.5, QColor(114, 232, 255)); self.linear_gradient.setColorAt(0.9, QColor(14, 179, 255)); self.mask_linear_gradient = QLinearGradient() self.mask_linear_gradient.setStart(0, 10) self.mask_linear_gradient.setFinalStop(0, 40) self.mask_linear_gradient.setColorAt(0.1, QColor(222, 54, 4)) self.mask_linear_gradient.setColorAt(0.5, QColor(255, 72, 16)) self.mask_linear_gradient.setColorAt(0.9, QColor(222, 54, 4)) self.text = "PyQt 5.2版本最新发布了,Qt 库的Python绑定" self.font = QFont() self.font.setFamily("Times New Roman") self.font.setBold(True) self.font.setPixelSize(30) self.setFont(self.font) self.timer = QTimer(self) self.timer.setInterval(100) self.timer.timeout.connect(self.update) self.timer.start() self.textWidth = self.fontMetrics().width(self.text) self.textHeight = self.fontMetrics().height() self.p = 0.1 self.button = QPushButton('1111', self) self.button.move(100, 0) self.button.resize(40, 40) self.toolBarHeight = 50
def __init__(self, parent): super().__init__(parent) self.grad = QLinearGradient() self.grad.setColorAt(0, QColor(0, 255, 0)) # Green self.grad.setColorAt(0.5, QColor(255, 255, 0)) # Yellow self.grad.setColorAt(1, QColor(255, 0, 0)) # Red self.reset()
def __init__(self, parent, index=0): QDial.__init__(self, parent) self.fMinimum = 0.0 self.fMaximum = 1.0 self.fRealValue = 0.0 self.fIsHovered = False self.fHoverStep = self.HOVER_MIN self.fIndex = index self.fPixmap = QPixmap(":/bitmaps/dial_01d.png") self.fPixmapNum = "01" if self.fPixmap.width() > self.fPixmap.height(): self.fPixmapOrientation = self.HORIZONTAL else: self.fPixmapOrientation = self.VERTICAL self.fLabel = "" self.fLabelPos = QPointF(0.0, 0.0) self.fLabelFont = QFont(self.font()) self.fLabelFont.setPointSize(6) self.fLabelWidth = 0 self.fLabelHeight = 0 if self.palette().window().color().lightness() > 100: # Light background c = self.palette().dark().color() self.fLabelGradientColor1 = c self.fLabelGradientColor2 = QColor(c.red(), c.green(), c.blue(), 0) self.fLabelGradientColorT = [self.palette().buttonText().color(), self.palette().mid().color()] else: # Dark background self.fLabelGradientColor1 = QColor(0, 0, 0, 255) self.fLabelGradientColor2 = QColor(0, 0, 0, 0) self.fLabelGradientColorT = [Qt.white, Qt.darkGray] self.fLabelGradient = QLinearGradient(0, 0, 0, 1) self.fLabelGradient.setColorAt(0.0, self.fLabelGradientColor1) self.fLabelGradient.setColorAt(0.6, self.fLabelGradientColor1) self.fLabelGradient.setColorAt(1.0, self.fLabelGradientColor2) self.fLabelGradientRect = QRectF(0.0, 0.0, 0.0, 0.0) self.fCustomPaintMode = self.CUSTOM_PAINT_MODE_NULL self.fCustomPaintColor = QColor(0xff, 0xff, 0xff) self.updateSizes() # Fake internal value, 10'000 precision QDial.setMinimum(self, 0) QDial.setMaximum(self, 10000) QDial.setValue(self, 0) self.valueChanged.connect(self.slot_valueChanged)
def paintEvent(self, evt): """ Protected method handling a paint event. @param evt reference to the paint event (QPaintEvent) """ if self.__privateMode: backgroundColor = QColor(220, 220, 220) # light gray foregroundColor = Qt.black else: backgroundColor = QApplication.palette().color(QPalette.Base) foregroundColor = QApplication.palette().color(QPalette.Text) if self.__browser is not None: p = self.palette() progress = self.__browser.progress() if progress == 0 or progress == 100: if self.__browser.url().scheme() == "https": if QSslCertificate is not None: if self.__browser.page().hasValidSslInfo(): backgroundColor = Preferences.getHelp( "SaveUrlColor") else: backgroundColor = Preferences.getHelp("SaveUrlColor") p.setBrush(QPalette.Base, backgroundColor) p.setBrush(QPalette.Text, foregroundColor) else: if self.__browser.url().scheme() == "https": if QSslCertificate is not None: if self.__browser.page().hasValidSslInfo(): backgroundColor = Preferences.getHelp( "SaveUrlColor") else: backgroundColor = Preferences.getHelp("SaveUrlColor") highlight = QApplication.palette().color(QPalette.Highlight) r = (highlight.red() + 2 * backgroundColor.red()) // 3 g = (highlight.green() + 2 * backgroundColor.green()) // 3 b = (highlight.blue() + 2 * backgroundColor.blue()) // 3 loadingColor = QColor(r, g, b) if abs(loadingColor.lightness() - backgroundColor.lightness()) < 20: # special handling for special color schemes (e.g Gaia) r = (2 * highlight.red() + backgroundColor.red()) // 3 g = (2 * highlight.green() + backgroundColor.green()) // 3 b = (2 * highlight.blue() + backgroundColor.blue()) // 3 loadingColor = QColor(r, g, b) gradient = QLinearGradient( QPointF(0, 0), QPointF(self.width(), 0)) gradient.setColorAt(0, loadingColor) gradient.setColorAt(progress / 100.0 - 0.000001, loadingColor) gradient.setColorAt(progress / 100.0, backgroundColor) p.setBrush(QPalette.Base, gradient) self.setPalette(p) E5LineEdit.paintEvent(self, evt)
def setupScene(self): self.m_scene.setSceneRect(-300, -200, 600, 460) linearGrad = QLinearGradient(QPointF(-100, -100), QPointF(100, 100)) linearGrad.setColorAt(0, QColor(255, 255, 255)) linearGrad.setColorAt(1, QColor(192, 192, 255)) self.setBackgroundBrush(linearGrad) radialGrad = QRadialGradient(30, 30, 30) radialGrad.setColorAt(0, Qt.yellow) radialGrad.setColorAt(0.2, Qt.yellow) radialGrad.setColorAt(1, Qt.transparent) pixmap = QPixmap(60, 60) pixmap.fill(Qt.transparent) painter = QPainter(pixmap) painter.setPen(Qt.NoPen) painter.setBrush(radialGrad) painter.drawEllipse(0, 0, 60, 60) painter.end() self.m_lightSource = self.m_scene.addPixmap(pixmap) self.m_lightSource.setZValue(2) for i in range(-2, 3): for j in range(-2, 3): if (i + j) & 1: item = QGraphicsEllipseItem(0, 0, 50, 50) else: item = QGraphicsRectItem(0, 0, 50, 50) item.setPen(QPen(Qt.black, 1)) item.setBrush(QBrush(Qt.white)) effect = QGraphicsDropShadowEffect(self) effect.setBlurRadius(8) item.setGraphicsEffect(effect) item.setZValue(1) item.setPos(i * 80, j * 80) self.m_scene.addItem(item) self.m_items.append(item)
def paint(self, painter, option, widget): down = option.state & QStyle.State_Sunken r = self.boundingRect() grad = QLinearGradient(r.topLeft(), r.bottomRight()) if option.state & QStyle.State_MouseOver: color_0 = Qt.white else: color_0 = Qt.lightGray color_1 = Qt.darkGray if down: color_0, color_1 = color_1, color_0 grad.setColorAt(0, color_0) grad.setColorAt(1, color_1) painter.setPen(Qt.darkGray) painter.setBrush(grad) painter.drawEllipse(r) color_0 = Qt.darkGray color_1 = Qt.lightGray if down: color_0, color_1 = color_1, color_0 grad.setColorAt(0, color_0) grad.setColorAt(1, color_1) painter.setPen(Qt.NoPen) painter.setBrush(grad) if down: painter.translate(2, 2) painter.drawEllipse(r.adjusted(5, 5, -5, -5)) painter.drawPixmap(-self._pix.width() / 2, -self._pix.height() / 2, self._pix)
class RoundRectItem(QGraphicsObject): def __init__(self, bounds, color, parent=None): super(RoundRectItem, self).__init__(parent) self.fillRect = False self.bounds = QRectF(bounds) self.pix = QPixmap() self.gradient = QLinearGradient() self.gradient.setStart(self.bounds.topLeft()) self.gradient.setFinalStop(self.bounds.bottomRight()) self.gradient.setColorAt(0, color) self.gradient.setColorAt(1, color.darker(200)) self.setCacheMode(QGraphicsItem.ItemCoordinateCache) def setFill(self, fill): self.fillRect = fill self.update() def fill(self): return self.fillRect fill = pyqtProperty(bool, fill, setFill) def paint(self, painter, option, widget): painter.setPen(Qt.NoPen) painter.setBrush(QColor(0, 0, 0, 64)) painter.drawRoundedRect(self.bounds.translated(2, 2), 25.0, 25.0) if self.fillRect: painter.setBrush(QApplication.palette().brush(QPalette.Window)) else: painter.setBrush(self.gradient) painter.setPen(QPen(Qt.black, 1)) painter.drawRoundedRect(self.bounds, 25.0, 25.0) if not self.pix.isNull(): painter.scale(1.95, 1.95) painter.drawPixmap(-self.pix.width() / 2, -self.pix.height() / 2, self.pix) def boundingRect(self): return self.bounds.adjusted(0, 0, 2, 2) def pixmap(self): return QPixmap(self.pix) def setPixmap(self, pixmap): self.pix = QPixmap(pixmap) self.update()
def __init__(self, parent): QWidget.__init__(self, parent) self.fChannels = 0 self.fDrawLines = True self.fOrientation = self.VERTICAL self.fSmoothMultiplier = 1 self.fColorBackground = QColor("#111111") self.fGradientMeter = QLinearGradient(0, 0, 1, 1) self.setChannels(0) self.setColor(self.GREEN)
def updateGrandient(self): self.fMeterGradient = QLinearGradient(0, 0, 1, 1) if self.fMeterStyle == self.STYLE_DEFAULT: if self.fMeterOrientation == self.HORIZONTAL: self.fMeterGradient.setColorAt(0.0, self.fMeterColorBase) self.fMeterGradient.setColorAt(0.2, self.fMeterColorBase) self.fMeterGradient.setColorAt(0.4, self.fMeterColorBase) self.fMeterGradient.setColorAt(0.6, self.fMeterColorBase) self.fMeterGradient.setColorAt(0.8, Qt.yellow) self.fMeterGradient.setColorAt(1.0, Qt.red) elif self.fMeterOrientation == self.VERTICAL: self.fMeterGradient.setColorAt(0.0, Qt.red) self.fMeterGradient.setColorAt(0.2, Qt.yellow) self.fMeterGradient.setColorAt(0.4, self.fMeterColorBase) self.fMeterGradient.setColorAt(0.6, self.fMeterColorBase) self.fMeterGradient.setColorAt(0.8, self.fMeterColorBase) self.fMeterGradient.setColorAt(1.0, self.fMeterColorBase) elif self.fMeterStyle == self.STYLE_RNCBC: if self.fMeterColor == self.COLOR_BLUE: c1 = QColor(40, 160, 160) c2 = QColor(60, 220, 160) elif self.fMeterColor == self.COLOR_GREEN: c1 = QColor(40, 160, 40) c2 = QColor(160, 220, 20) if self.fMeterOrientation == self.HORIZONTAL: self.fMeterGradient.setColorAt(0.0, c1) self.fMeterGradient.setColorAt(0.2, c1) self.fMeterGradient.setColorAt(0.6, c2) self.fMeterGradient.setColorAt(0.7, QColor(220, 220, 20)) self.fMeterGradient.setColorAt(0.8, QColor(240, 160, 20)) self.fMeterGradient.setColorAt(0.9, QColor(240, 0, 20)) self.fMeterGradient.setColorAt(1.0, QColor(240, 0, 20)) elif self.fMeterOrientation == self.VERTICAL: self.fMeterGradient.setColorAt(0.0, QColor(240, 0, 20)) self.fMeterGradient.setColorAt(0.1, QColor(240, 0, 20)) self.fMeterGradient.setColorAt(0.2, QColor(240, 160, 20)) self.fMeterGradient.setColorAt(0.3, QColor(220, 220, 20)) self.fMeterGradient.setColorAt(0.4, c2) self.fMeterGradient.setColorAt(0.8, c1) self.fMeterGradient.setColorAt(1.0, c1) elif self.fMeterStyle in (self.STYLE_OPENAV, self.STYLE_CALF): self.fMeterGradient.setColorAt(0.0, self.fMeterColorBase) self.fMeterGradient.setColorAt(1.0, self.fMeterColorBase) self.updateGrandientFinalStop()
def paintEvent(self, event): color = self.state_colors[self.state] painter = QPainter(self) painter.setRenderHint(QPainter.Antialiasing, True) painter.setCompositionMode(QPainter.CompositionMode_SourceOver) gradient = QLinearGradient(0, 0, self.width(), 0) gradient.setColorAt(0.0, Qt.transparent) gradient.setColorAt(1.0, color) painter.setBrush(QBrush(gradient)) gradient.setColorAt(1.0, color.stroke) painter.setPen(QPen(QBrush(gradient), 1)) painter.drawRoundedRect(-4, 0, self.width()+4, self.height(), 3.7, 3.7)
class TuningThermo(QWidget): def __init__(self, *args): super().__init__(*args) self.bar_width = 200 # px self.bar_height = 10 # px self.border = 3 # px self.value = 0 self.max_value = 1000 self.min_value = 300 self.setFixedWidth(self.border + self.bar_width + self.border) self.setFixedHeight(self.border + self.bar_height + self.border) self.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum) self.gradient = QLinearGradient(0, 0, self.bar_width, 0) self.gradient.setColorAt(0, Qt.green) self.gradient.setColorAt(1, Qt.red) def paintEvent(self, event): painter = QPainter(self) width = self.width() height = self.height() painter.fillRect(0, 0, width, height, QColor(245, 245, 245)) painter.setPen(QColor(190, 190, 190)) painter.drawRect(0, 0, width - 1, height - 1) filled_bar_width = int(round(float(width - self.border * 2 - 1) * self.value / self.max_value + 1)) painter.fillRect(self.border, self.border, filled_bar_width, height - self.border * 2, self.gradient) def set_value(self, value): value = value - self.min_value self.value = min(max(value, 0), self.max_value-self.min_value) self.update()
def __init__(self, bounds, color, parent=None): super(RoundRectItem, self).__init__(parent) self.fillRect = False self.bounds = QRectF(bounds) self.pix = QPixmap() self.gradient = QLinearGradient() self.gradient.setStart(self.bounds.topLeft()) self.gradient.setFinalStop(self.bounds.bottomRight()) self.gradient.setColorAt(0, color) self.gradient.setColorAt(1, color.darker(200)) self.setCacheMode(QGraphicsItem.ItemCoordinateCache)
def paintEvent(self, event): option = QStyleOption() option.initFrom(self) contents_rect = self.style().subElementRect( QStyle.SE_FrameContents, option, self ) or self.contentsRect( ) # the SE_FrameContents rect is Null unless the stylesheet defines decorations if self.graphStyle == self.BarStyle: graph_width = self.__dict__['graph_width'] = int( ceil( float(contents_rect.width()) / self.horizontalPixelsPerUnit)) else: graph_width = self.__dict__['graph_width'] = int( ceil( float(contents_rect.width() - 1) / self.horizontalPixelsPerUnit) + 1) max_value = self.__dict__['max_value'] = max( chain([0], *(islice(reversed(graph.data), graph_width) for graph in self.graphs if graph.enabled))) if self.graphHeight == self.AutomaticHeight or self.graphHeight < 0: graph_height = self.__dict__['graph_height'] = max( self.scaler.get_height(max_value), self.minHeight) else: graph_height = self.__dict__['graph_height'] = max( self.graphHeight, self.minHeight) if self.graphStyle == self.BarStyle: height_scaling = float(contents_rect.height()) / graph_height else: height_scaling = float(contents_rect.height() - self.lineThickness) / graph_height painter = QStylePainter(self) painter.drawPrimitive(QStyle.PE_Widget, option) painter.setClipRect(contents_rect) painter.save() painter.translate(contents_rect.x() + contents_rect.width() - 1, contents_rect.y() + contents_rect.height() - 1) painter.scale(-1, -1) painter.setRenderHint(QStylePainter.Antialiasing, self.graphStyle != self.BarStyle) for graph in (graph for graph in self.graphs if graph.enabled and graph.data): if self.boundary is not None and 0 < self.boundary < graph_height: boundary_width = min(5.0 / height_scaling, self.boundary - 0, graph_height - self.boundary) pen_color = QLinearGradient( 0, (self.boundary - boundary_width) * height_scaling, 0, (self.boundary + boundary_width) * height_scaling) pen_color.setColorAt(0, graph.color) pen_color.setColorAt(1, graph.over_boundary_color) brush_color = QLinearGradient( 0, (self.boundary - boundary_width) * height_scaling, 0, (self.boundary + boundary_width) * height_scaling) brush_color.setColorAt( 0, self.color_with_alpha(graph.color, self.fillTransparency)) brush_color.setColorAt( 1, self.color_with_alpha(graph.over_boundary_color, self.fillTransparency)) else: pen_color = graph.color brush_color = self.color_with_alpha(graph.color, self.fillTransparency) dataset = islice(reversed(graph.data), graph_width) if self.graphStyle == self.BarStyle: lines = [ QLineF(x * self.horizontalPixelsPerUnit, 0, x * self.horizontalPixelsPerUnit, y * height_scaling) for x, y in enumerate(dataset) ] painter.setPen(QPen(pen_color, self.lineThickness)) painter.drawLines(lines) else: painter.translate(0, +self.lineThickness / 2 - 1) if self.smoothEnvelope and self.smoothFactor > 0: min_value = 0 max_value = graph_height * height_scaling cx_offset = self.horizontalPixelsPerUnit / 3.0 smoothness = self.smoothFactor last_values = deque( 3 * [next(dataset) * height_scaling], maxlen=3 ) # last 3 values: 0 last, 1 previous, 2 previous previous envelope = QPainterPath() envelope.moveTo(0, last_values[0]) for x, y in enumerate(dataset, 1): x = x * self.horizontalPixelsPerUnit y = y * height_scaling * ( 1 - smoothness) + last_values[0] * smoothness last_values.appendleft(y) c1x = x - cx_offset * 2 c2x = x - cx_offset c1y = limit( (1 + smoothness) * last_values[1] - smoothness * last_values[2], min_value, max_value ) # same gradient as previous previous value to previous value c2y = limit( (1 - smoothness) * last_values[0] + smoothness * last_values[1], min_value, max_value ) # same gradient as previous value to last value envelope.cubicTo(c1x, c1y, c2x, c2y, x, y) else: envelope = QPainterPath() envelope.addPolygon( QPolygonF([ QPointF(x * self.horizontalPixelsPerUnit, y * height_scaling) for x, y in enumerate(dataset) ])) if self.fillEnvelope or graph.fill_envelope: first_element = envelope.elementAt(0) last_element = envelope.elementAt(envelope.elementCount() - 1) fill_path = QPainterPath() fill_path.moveTo(last_element.x, last_element.y) fill_path.lineTo(last_element.x + 1, last_element.y) fill_path.lineTo(last_element.x + 1, -self.lineThickness) fill_path.lineTo(-self.lineThickness, -self.lineThickness) fill_path.lineTo(-self.lineThickness, first_element.y) fill_path.connectPath(envelope) painter.fillPath(fill_path, brush_color) painter.strokePath( envelope, QPen(pen_color, self.lineThickness, join=Qt.RoundJoin)) painter.translate(0, -self.lineThickness / 2 + 1) if self.boundary is not None and self.boundaryColor: painter.setRenderHint(QStylePainter.Antialiasing, False) painter.setPen(QPen(self.boundaryColor, 1.0)) painter.drawLine(0, self.boundary * height_scaling, contents_rect.width(), self.boundary * height_scaling) painter.restore() # queue the 'updated' signal to be emitted after returning to the main loop QMetaObject.invokeMethod(self, 'updated', Qt.QueuedConnection)
def paint(self, painter, option, widget): if canvas.scene.loading_items: return painter.save() painter.setRenderHint(QPainter.Antialiasing, bool(options.antialiasing == ANTIALIASING_FULL)) selected = self.isSelected() theme = canvas.theme if self.m_port_type == PORT_TYPE_AUDIO_JACK: if self.m_is_alternate: poly_color = theme.port_cv_jack_bg_sel if selected else theme.port_cv_jack_bg poly_pen = theme.port_cv_jack_pen_sel if selected else theme.port_cv_jack_pen else: poly_color = theme.port_audio_jack_bg_sel if selected else theme.port_audio_jack_bg poly_pen = theme.port_audio_jack_pen_sel if selected else theme.port_audio_jack_pen text_pen = theme.port_audio_jack_text_sel if selected else theme.port_audio_jack_text conn_pen = QPen(theme.port_audio_jack_pen_sel) elif self.m_port_type == PORT_TYPE_MIDI_JACK: poly_color = theme.port_midi_jack_bg_sel if selected else theme.port_midi_jack_bg poly_pen = theme.port_midi_jack_pen_sel if selected else theme.port_midi_jack_pen text_pen = theme.port_midi_jack_text_sel if selected else theme.port_midi_jack_text conn_pen = QPen(theme.port_midi_jack_pen_sel) elif self.m_port_type == PORT_TYPE_MIDI_ALSA: poly_color = theme.port_midi_alsa_bg_sel if selected else theme.port_midi_alsa_bg poly_pen = theme.port_midi_alsa_pen_sel if selected else theme.port_midi_alsa_pen text_pen = theme.port_midi_alsa_text_sel if selected else theme.port_midi_alsa_text conn_pen = QPen(theme.port_midi_alsa_pen_sel) elif self.m_port_type == PORT_TYPE_PARAMETER: poly_color = theme.port_parameter_bg_sel if selected else theme.port_parameter_bg poly_pen = theme.port_parameter_pen_sel if selected else theme.port_parameter_pen text_pen = theme.port_parameter_text_sel if selected else theme.port_parameter_text conn_pen = QPen(theme.port_parameter_pen_sel) else: qCritical( "PatchCanvas::CanvasPort.paint() - invalid port type '%s'" % port_type2str(self.m_port_type)) return # To prevent quality worsening poly_pen = QPen(poly_pen) poly_pen.setWidthF(poly_pen.widthF() + 0.00001) lineHinting = poly_pen.widthF() / 2 poly_locx = [0, 0, 0, 0, 0, 0] poly_corner_xhinting = ((float(canvas.theme.port_height) / 2) % floor(float(canvas.theme.port_height) / 2)) if poly_corner_xhinting == 0: poly_corner_xhinting = 0.5 * ( 1 - 7 / (float(canvas.theme.port_height) / 2)) is_cv_port = bool(self.m_port_type == PORT_TYPE_AUDIO_JACK and self.m_is_alternate) if self.m_port_mode == PORT_MODE_INPUT: text_pos = QPointF(3, canvas.theme.port_text_ypos) if canvas.theme.port_mode == Theme.THEME_PORT_POLYGON and not is_cv_port: poly_locx[0] = lineHinting poly_locx[1] = self.m_port_width + 5 - lineHinting poly_locx[2] = self.m_port_width + 12 - poly_corner_xhinting poly_locx[3] = self.m_port_width + 5 - lineHinting poly_locx[4] = lineHinting poly_locx[5] = self.m_port_width elif canvas.theme.port_mode == Theme.THEME_PORT_SQUARE or is_cv_port: poly_locx[0] = lineHinting poly_locx[1] = self.m_port_width + 5 - lineHinting poly_locx[2] = self.m_port_width + 5 - lineHinting poly_locx[3] = self.m_port_width + 5 - lineHinting poly_locx[4] = lineHinting poly_locx[5] = self.m_port_width else: qCritical( "PatchCanvas::CanvasPort.paint() - invalid theme port mode '%s'" % canvas.theme.port_mode) return elif self.m_port_mode == PORT_MODE_OUTPUT: text_pos = QPointF(9, canvas.theme.port_text_ypos) if canvas.theme.port_mode == Theme.THEME_PORT_POLYGON and not is_cv_port: poly_locx[0] = self.m_port_width + 12 - lineHinting poly_locx[1] = 7 + lineHinting poly_locx[2] = 0 + poly_corner_xhinting poly_locx[3] = 7 + lineHinting poly_locx[4] = self.m_port_width + 12 - lineHinting poly_locx[5] = 12 - lineHinting elif canvas.theme.port_mode == Theme.THEME_PORT_SQUARE or is_cv_port: poly_locx[0] = self.m_port_width + 12 - lineHinting poly_locx[1] = 5 + lineHinting poly_locx[2] = 5 + lineHinting poly_locx[3] = 5 + lineHinting poly_locx[4] = self.m_port_width + 12 - lineHinting poly_locx[5] = 12 - lineHinting else: qCritical( "PatchCanvas::CanvasPort.paint() - invalid theme port mode '%s'" % canvas.theme.port_mode) return else: qCritical( "PatchCanvas::CanvasPort.paint() - invalid port mode '%s'" % port_mode2str(self.m_port_mode)) return polygon = QPolygonF() if self.m_portgrp_id: first_of_portgrp = False last_of_portgrp = False # look in portgroup if port is the first, # the last, or not. for portgrp in canvas.portgrp_list: if portgrp.portgrp_id == self.m_portgrp_id: if self.m_port_id == portgrp.port_id_list[0]: first_of_portgrp = True if self.m_port_id == portgrp.port_id_list[-1]: last_of_portgrp = True break if first_of_portgrp: polygon += QPointF(poly_locx[0], lineHinting) polygon += QPointF(poly_locx[5], lineHinting) else: polygon += QPointF(poly_locx[0], 0) polygon += QPointF(poly_locx[5], 0) if last_of_portgrp: polygon += QPointF(poly_locx[5], canvas.theme.port_height - lineHinting) polygon += QPointF(poly_locx[0], canvas.theme.port_height - lineHinting) else: polygon += QPointF(poly_locx[5], canvas.theme.port_height) polygon += QPointF(poly_locx[0], canvas.theme.port_height) else: polygon += QPointF(poly_locx[0], lineHinting) polygon += QPointF(poly_locx[1], lineHinting) polygon += QPointF(poly_locx[2], float(canvas.theme.port_height) / 2) polygon += QPointF(poly_locx[3], canvas.theme.port_height - lineHinting) polygon += QPointF(poly_locx[4], canvas.theme.port_height - lineHinting) polygon += QPointF(poly_locx[0], lineHinting) if canvas.theme.port_bg_pixmap: portRect = polygon.boundingRect().adjusted(-lineHinting + 1, -lineHinting + 1, lineHinting - 1, lineHinting - 1) portPos = portRect.topLeft() painter.drawTiledPixmap(portRect, canvas.theme.port_bg_pixmap, portPos) else: port_gradient = QLinearGradient(0, 0, 0, self.m_port_height) dark_color = poly_color.darker(112) light_color = poly_color.lighter(111) if poly_color.lightness() > 127: port_gradient.setColorAt(0, dark_color) port_gradient.setColorAt(0.5, light_color) port_gradient.setColorAt(1, dark_color) else: port_gradient.setColorAt(0, light_color) port_gradient.setColorAt(0.5, dark_color) port_gradient.setColorAt(1, light_color) painter.setBrush(port_gradient) painter.setPen(poly_pen) painter.drawPolygon(polygon) if self.m_is_alternate and not self.m_portgrp_id: if is_cv_port: poly_pen.setWidthF(2.000001) painter.setPen(poly_pen) y_line = canvas.theme.port_height / 2.0 if self.m_port_mode == PORT_MODE_OUTPUT: painter.drawLine(QPointF(0.0, y_line), QPointF(float(poly_locx[1]), y_line)) elif self.m_port_mode == PORT_MODE_INPUT: painter.drawLine(QPointF(self.m_port_width + 5.0, y_line), QPointF(self.m_port_width + 12.0, y_line)) else: # draw the little circle for a2j (or MidiBridge) port poly_pen.setWidthF(1.000001) painter.setBrush(canvas.theme.box_bg_1) ellipse_x = poly_locx[1] if self.m_port_mode == PORT_MODE_OUTPUT: ellipse_x -= 2 elif self.m_port_mode == PORT_MODE_INPUT: ellipse_x += 2 painter.drawEllipse( QPointF(ellipse_x, canvas.theme.port_height / 2.0), 2, 2) painter.setPen(text_pen) painter.setFont(self.m_port_font) sizer = QFontMetrics(self.m_port_font) sep_width = sizer.width(self.m_trunck_sep) if self.m_portgrp_id: print_name_size = self.get_text_width() if self.m_port_mode == PORT_MODE_OUTPUT: text_pos = QPointF(self.m_port_width + 9 - print_name_size, canvas.theme.port_text_ypos) if print_name_size > (self.m_port_width - 4): painter.setPen(QPen(port_gradient, 3)) painter.drawLine( QPointF(float(poly_locx[5]), 3.0), QPointF(float(poly_locx[5]), canvas.theme.port_height - 3.0)) painter.setPen(text_pen) painter.setFont(self.m_port_font) painter.drawText(text_pos, self.m_print_name) if self.m_name_truncked: sep_x = text_pos.x() + sizer.width(self.m_print_name) painter.drawText(QPointF(sep_x + sep_width, text_pos.y()), self.m_print_name_right) painter.setPen(poly_pen) painter.drawText(QPointF(sep_x, text_pos.y() + 1), self.m_trunck_sep) if canvas.theme.idx == Theme.THEME_OOSTUDIO and canvas.theme.port_bg_pixmap: painter.setPen(Qt.NoPen) painter.setBrush(conn_pen.brush()) if self.m_port_mode == PORT_MODE_INPUT: connRect = QRectF(portRect.topLeft(), QSizeF(2, portRect.height())) else: connRect = QRectF( QPointF(portRect.right() - 2, portRect.top()), QSizeF(2, portRect.height())) painter.drawRect(connRect) painter.restore()
def gradientFromColor(color): gradient = QLinearGradient(0, 0, 0, 1) gradient.setCoordinateMode(QLinearGradient.ObjectBoundingMode) gradient.setColorAt(0, color) gradient.setColorAt(1, color.lighter()) return gradient
def drawAIGlobalFeatures(self, painter, mainArea, paintArea): painter.resetTransform() painter.translate(mainArea.center()) pitchPixels = self.pitchAngleToTranslation(mainArea.height(), self.pitch) gradientEnd = self.pitchAngleToTranslation(mainArea.height(), 60) if math.isnan(self.roll) == False: # check for NaN painter.rotate(-self.roll) painter.translate(0, pitchPixels) # Calculate the radius of area we need to paint to cover all. rtx = painter.transform().inverted()[0] topLeft = rtx.map(paintArea.topLeft()) topRight = rtx.map(paintArea.topRight()) bottomLeft = rtx.map(paintArea.bottomLeft()) bottomRight = rtx.map(paintArea.bottomRight()) # Just KISS... make a rectangluar basis. minx = self.min4(topLeft.x(), topRight.x(), bottomLeft.x(), bottomRight.x()) maxx = self.max4(topLeft.x(), topRight.x(), bottomLeft.x(), bottomRight.x()) miny = self.min4(topLeft.y(), topRight.y(), bottomLeft.y(), bottomRight.y()) maxy = self.max4(topLeft.y(), topRight.y(), bottomLeft.y(), bottomRight.y()) hzonLeft = QPoint(minx, 0) hzonRight = QPoint(maxx, 0) skyPath = QPainterPath(hzonLeft) skyPath.lineTo(QPointF(minx, miny)) skyPath.lineTo(QPointF(maxx, miny)) skyPath.lineTo(hzonRight) skyPath.closeSubpath() # TODO: The gradient is wrong now. skyGradient = QLinearGradient(0, -gradientEnd, 0, 0) skyGradient.setColorAt(0, QColor.fromHsvF(0.6, 1.0, 0.7)) skyGradient.setColorAt(1, QColor.fromHsvF(0.6, 0.25, 0.9)) skyBrush = QBrush(skyGradient) painter.fillPath(skyPath, skyBrush) groundPath = QPainterPath(hzonRight) groundPath.lineTo(maxx, maxy) groundPath.lineTo(minx, maxy) groundPath.lineTo(hzonLeft) groundPath.closeSubpath() groundGradient = QLinearGradient(0, gradientEnd, 0, 0) groundGradient.setColorAt(0, QColor.fromHsvF(0.25, 1, 0.5)) groundGradient.setColorAt(1, QColor.fromHsvF(0.25, 0.25, 0.5)) groundBrush = QBrush(groundGradient) painter.fillPath(groundPath, groundBrush) pen = QPen() pen.setWidthF(self.lineWidth) pen.setColor(QColor(0, 255, 0)) painter.setPen(pen) start = QPointF(-mainArea.width(), 0) end = QPoint(mainArea.width(), 0) painter.drawLine(start, end)
def create_gradient(color, darker=300): gradient = QLinearGradient(0, 0, 0, 100) gradient.setColorAt(0.0, color) gradient.setColorAt(1.0, color.darker(darker)) return gradient
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 drawPrimitive(self, element, opt, painter, widget): if not self.__panel_widget(widget): return QProxyStyle.drawPrimitive(self, element, opt, painter, widget) if element == QStyle.PE_PanelButtonTool: flat = theme.flag("FlatComboBox") pressed = (opt.state & STATE_SUNKEN or opt.state & STATE_ON) hovered = opt.state & STATE_ENABLED and opt.state & STATE_MOUSEOVER button_color = theme.get_color('ToolButtonColor') if not flat and widget.property("gradient"): base = QColor(theme.get_color('Window')) button_color = QLinearGradient(opt.rect.topRight(), opt.rect.bottomRight()) button_color.setColorAt(0.2, base.lighter(150)) button_color.setColorAt(0.9, base.darker(135)) if pressed: button_color = theme.get_color('ToolButtonSelected') elif hovered: if not flat and widget.property("gradient"): button_color.setColorAt(0.2, base.lighter(160)) button_color.setColorAt(0.9, base.darker(100)) else: button_color = theme.get_color('ToolButtonHover') if widget.property("border_bottom"): painter.setPen(theme.get_color('Border')) painter.drawLine(opt.rect.bottomLeft(), opt.rect.bottomRight()) painter.fillRect(opt.rect.adjusted(1, 1, -1, -1), button_color) # elif not opt.state & STATE_ENABLED: # color = _PALETTE['ButtonDisabled'] # painter.fillRect(opt.rect, color) # TODO: keyboard focus change state # elif element == QStyle.PE_PanelButtonCommand: # Draw a flat push button # is_down = opt.state & STATE_SUNKEN or opt.state & STATE_ON # is_enabled = opt.state & STATE_ENABLED # is_hover = is_enabled and opt.state & STATE_MOUSEOVER # FIXME: has_focus state # FIXME: from theme # color = QColor("#444a58") # if is_down: # color = color.darker(130) # elif is_hover: # color = color.lighter(110) # painter.fillRect(opt.rect, color) elif element == QStyle.PE_PanelLineEdit: painter.save() # Fill background rect = opt.rect enabled = False if opt.state & STATE_ENABLED: enabled = True if not enabled: painter.setOpacity(0.55) painter.fillRect(rect, theme.get_color('LineEditBackground')) has_focus = False if opt.state & QStyle.State_HasFocus: has_focus = True if enabled and (has_focus or opt.state & STATE_MOUSEOVER): # FIXME: color from theme # hover = QColor("#6a6ea9") # if has_focus: # alpha = 200 # else: # alpha = 55 # hover.setAlpha(alpha) # painter.setPen(QPen(hover, 2, Qt.SolidLine, # Qt.SquareCap, Qt.RoundJoin)) # painter.drawRect(rect.adjusted(0, 0, 0, 0)) pass painter.restore() elif element == QStyle.PE_IndicatorToolBarSeparator: rect = opt.rect painter.setPen(theme.get_color('SeparatorColor')) border_rect = QRectF(rect).adjusted(0.5, 0.5, -0.5, -0.5) if opt.state & QStyle.State_Horizontal: border_rect.setWidth(1) painter.drawLine(border_rect.topRight() + QPointF(0, 3), border_rect.bottomRight() - QPointF(0, 3)) else: border_rect.setHeight(1) painter.drawLine(border_rect.topLeft() + QPointF(3, 0), border_rect.topRight() - QPointF(3, 0)) elif element == QStyle.PE_IndicatorToolBarHandle: # FIXME: draw a fancy handler QProxyStyle.drawPrimitive(self, element, opt, painter, widget) else: QProxyStyle.drawPrimitive(self, element, opt, painter, widget)
def __init__(self, scatter): super(ScatterDataModifier, self).__init__() mesh_dir = QFileInfo(__file__).absolutePath() + '/Data/mesh' self.m_graph = scatter # Q3DScatter 对象实例 self.m_rotationTimer = QTimer() self.m_fieldLines = 12 # 初始磁场线数量 self.m_arrowsPerLine = 16 # 初始箭头数 self.m_magneticField = QScatter3DSeries() # 磁场线三维散点图 self.m_sun = QScatter3DSeries() # 太阳三维散点图 self.m_angleOffset = 0.0 # 角度偏移 self.m_angleStep = self.doublePi / self.m_arrowsPerLine / self.animationFrames # 设置阴影质量 self.m_graph.setShadowQuality(QAbstract3DGraph.ShadowQualityNone) # 设置当前场景中的激活的相机预设值 self.m_graph.scene().activeCamera().setCameraPreset( Q3DCamera.CameraPresetFront) # Magnetic field lines use custom narrow arrow. # 磁力线使用自定义窄箭头。 self.m_magneticField.setItemSize(0.2) self.m_magneticField.setMesh(QAbstract3DSeries.MeshUserDefined) self.m_magneticField.setUserDefinedMesh(mesh_dir + '/narrowarrow.obj') # 设置渐变颜色 fieldGradient = QLinearGradient(0, 0, 16, 1024) fieldGradient.setColorAt(0.0, Qt.black) fieldGradient.setColorAt(1.0, Qt.white) self.m_magneticField.setBaseGradient(fieldGradient) self.m_magneticField.setColorStyle(Q3DTheme.ColorStyleRangeGradient) # For 'sun' we use a custom large sphere. # 使用一个自定义的球体代表太阳 self.m_sun.setItemSize(0.2) self.m_sun.setName("Sun") self.m_sun.setItemLabelFormat("@seriesName") self.m_sun.setMesh(QAbstract3DSeries.MeshUserDefined) self.m_sun.setUserDefinedMesh(mesh_dir + '/largesphere.obj') self.m_sun.setBaseColor(QColor(0xff, 0xbb, 0x00)) self.m_sun.dataProxy().addItem(QScatterDataItem(QVector3D())) self.m_graph.addSeries(self.m_magneticField) self.m_graph.addSeries(self.m_sun) # Configure the axes according to the data. # 设置x轴的范围值 self.m_graph.axisX().setRange(-self.horizontalRange, self.horizontalRange) # 设置y轴的范围值 self.m_graph.axisY().setRange(-self.verticalRange, self.verticalRange) # 设置z轴的范围值 self.m_graph.axisZ().setRange(-self.horizontalRange, self.horizontalRange) # x和z轴上的段数 # 这表明绘制了多少标签。要绘制的网格线的数量使用公式计算:segments * subsegments + 1。预设默认值为5。该值不能低于1。 self.m_graph.axisX().setSegmentCount(self.horizontalRange) self.m_graph.axisZ().setSegmentCount(self.horizontalRange) self.m_rotationTimer.timeout.connect(self.triggerRotation) self.toggleRotation() self.generateData()
def initChart(self): series = QLineSeries() data = [ QPoint(0, 4), QPoint(3, 2), QPoint(7, 7), QPoint(9, 10), QPoint(12, 17), QPoint(17, 9), QPoint(20, 22), QPoint(22, 2), QPoint(28, 13) ] series.append(data) # creating chart object chart = QChart() chart.legend().hide() chart.addSeries(series) pen = QPen(QColor(0, 0, 128)) pen.setWidth(3) series.setPen(pen) font = QFont("Open Sans") font.setPixelSize(40) font.setBold(True) chart.setTitleFont(font) chart.setTitleBrush(QBrush(Qt.yellow)) chart.setTitle("Custom Chart Demo") backgroundGradient = QLinearGradient() backgroundGradient.setStart(QPoint(0, 0)) backgroundGradient.setFinalStop(QPoint(0, 1)) backgroundGradient.setColorAt(0.0, QColor(175, 201, 182)) backgroundGradient.setColorAt(1.0, QColor(51, 105, 66)) backgroundGradient.setCoordinateMode(QGradient.ObjectBoundingMode) chart.setBackgroundBrush(backgroundGradient) plotAreaGraident = QLinearGradient() plotAreaGraident.setStart(QPoint(0, 1)) plotAreaGraident.setFinalStop(QPoint(1, 0)) plotAreaGraident.setColorAt(0.0, QColor(222, 222, 222)) plotAreaGraident.setColorAt(1.0, QColor(51, 105, 66)) plotAreaGraident.setCoordinateMode(QGradient.ObjectBoundingMode) chart.setPlotAreaBackgroundBrush(plotAreaGraident) chart.setPlotAreaBackgroundVisible(True) # customize axis axisX = QCategoryAxis() axisY = QCategoryAxis() labelFont = QFont("Open Sans") labelFont.setPixelSize(25) axisX.setLabelsFont(labelFont) axisY.setLabelsFont(labelFont) axisPen = QPen(Qt.white) axisPen.setWidth(2) axisX.setLinePen(axisPen) axisY.setLinePen(axisPen) axisBrush = QBrush(Qt.white) axisX.setLabelsBrush(axisBrush) axisY.setLabelsBrush(axisBrush) axisX.setRange(0, 30) axisX.append("low", 10) axisX.append("medium", 20) axisX.append("high", 30) axisY.setRange(0, 30) axisY.append("slow", 10) axisY.append("average", 20) axisY.append("fast", 30) axisX.setGridLineVisible(False) axisY.setGridLineVisible(False) chart.addAxis(axisX, Qt.AlignBottom) chart.addAxis(axisY, Qt.AlignLeft) series.attachAxis(axisX) series.attachAxis(axisY) self.chartView = QChartView(chart) self.chartView.setRenderHint(QPainter.Antialiasing)
class PixmapDial(QDial): # enum CustomPaintMode CUSTOM_PAINT_MODE_NULL = 0 # default (NOTE: only this mode has label gradient) CUSTOM_PAINT_MODE_CARLA_WET = 1 # color blue-green gradient (reserved #3) CUSTOM_PAINT_MODE_CARLA_VOL = 2 # color blue (reserved #3) CUSTOM_PAINT_MODE_CARLA_L = 3 # color yellow (reserved #4) CUSTOM_PAINT_MODE_CARLA_R = 4 # color yellow (reserved #4) CUSTOM_PAINT_MODE_CARLA_PAN = 5 # color yellow (reserved #3) CUSTOM_PAINT_MODE_COLOR = 6 # color, selectable (reserved #3) CUSTOM_PAINT_MODE_ZITA = 7 # custom zita knob (reserved #6) CUSTOM_PAINT_MODE_NO_GRADIENT = 8 # skip label gradient # enum Orientation HORIZONTAL = 0 VERTICAL = 1 HOVER_MIN = 0 HOVER_MAX = 9 # signals realValueChanged = pyqtSignal(float) def __init__(self, parent, index=0): QDial.__init__(self, parent) self.fMinimum = 0.0 self.fMaximum = 1.0 self.fRealValue = 0.0 self.fIsHovered = False self.fHoverStep = self.HOVER_MIN self.fIndex = index self.fPixmap = QPixmap(":/bitmaps/dial_01d.png") self.fPixmapNum = "01" if self.fPixmap.width() > self.fPixmap.height(): self.fPixmapOrientation = self.HORIZONTAL else: self.fPixmapOrientation = self.VERTICAL self.fLabel = "" self.fLabelPos = QPointF(0.0, 0.0) self.fLabelFont = QFont(self.font()) self.fLabelFont.setPixelSize(8) self.fLabelWidth = 0 self.fLabelHeight = 0 if self.palette().window().color().lightness() > 100: # Light background c = self.palette().dark().color() self.fLabelGradientColor1 = c self.fLabelGradientColor2 = QColor(c.red(), c.green(), c.blue(), 0) self.fLabelGradientColorT = [self.palette().buttonText().color(), self.palette().mid().color()] else: # Dark background self.fLabelGradientColor1 = QColor(0, 0, 0, 255) self.fLabelGradientColor2 = QColor(0, 0, 0, 0) self.fLabelGradientColorT = [Qt.white, Qt.darkGray] self.fLabelGradient = QLinearGradient(0, 0, 0, 1) self.fLabelGradient.setColorAt(0.0, self.fLabelGradientColor1) self.fLabelGradient.setColorAt(0.6, self.fLabelGradientColor1) self.fLabelGradient.setColorAt(1.0, self.fLabelGradientColor2) self.fLabelGradientRect = QRectF(0.0, 0.0, 0.0, 0.0) self.fCustomPaintMode = self.CUSTOM_PAINT_MODE_NULL self.fCustomPaintColor = QColor(0xff, 0xff, 0xff) self.updateSizes() # Fake internal value, 10'000 precision QDial.setMinimum(self, 0) QDial.setMaximum(self, 10000) QDial.setValue(self, 0) self.valueChanged.connect(self.slot_valueChanged) def getIndex(self): return self.fIndex def getBaseSize(self): return self.fPixmapBaseSize def forceWhiteLabelGradientText(self): self.fLabelGradientColor1 = QColor(0, 0, 0, 255) self.fLabelGradientColor2 = QColor(0, 0, 0, 0) self.fLabelGradientColorT = [Qt.white, Qt.darkGray] def updateSizes(self): self.fPixmapWidth = self.fPixmap.width() self.fPixmapHeight = self.fPixmap.height() if self.fPixmapWidth < 1: self.fPixmapWidth = 1 if self.fPixmapHeight < 1: self.fPixmapHeight = 1 if self.fPixmapOrientation == self.HORIZONTAL: self.fPixmapBaseSize = self.fPixmapHeight self.fPixmapLayersCount = self.fPixmapWidth / self.fPixmapHeight else: self.fPixmapBaseSize = self.fPixmapWidth self.fPixmapLayersCount = self.fPixmapHeight / self.fPixmapWidth self.setMinimumSize(self.fPixmapBaseSize, self.fPixmapBaseSize + self.fLabelHeight + 5) self.setMaximumSize(self.fPixmapBaseSize, self.fPixmapBaseSize + self.fLabelHeight + 5) if not self.fLabel: self.fLabelHeight = 0 self.fLabelWidth = 0 return self.fLabelWidth = QFontMetrics(self.fLabelFont).width(self.fLabel) self.fLabelHeight = QFontMetrics(self.fLabelFont).height() self.fLabelPos.setX(float(self.fPixmapBaseSize)/2.0 - float(self.fLabelWidth)/2.0) if self.fPixmapNum in ("01", "02", "07", "08", "09", "10"): self.fLabelPos.setY(self.fPixmapBaseSize + self.fLabelHeight) elif self.fPixmapNum in ("11",): self.fLabelPos.setY(self.fPixmapBaseSize + self.fLabelHeight*2/3) else: self.fLabelPos.setY(self.fPixmapBaseSize + self.fLabelHeight/2) self.fLabelGradient.setStart(0, float(self.fPixmapBaseSize)/2.0) self.fLabelGradient.setFinalStop(0, self.fPixmapBaseSize + self.fLabelHeight + 5) self.fLabelGradientRect = QRectF(float(self.fPixmapBaseSize)/8.0, float(self.fPixmapBaseSize)/2.0, float(self.fPixmapBaseSize*3)/4.0, self.fPixmapBaseSize+self.fLabelHeight+5) def setCustomPaintMode(self, paintMode): if self.fCustomPaintMode == paintMode: return self.fCustomPaintMode = paintMode self.update() def setCustomPaintColor(self, color): if self.fCustomPaintColor == color: return self.fCustomPaintColor = color self.update() def setLabel(self, label): if self.fLabel == label: return self.fLabel = label self.updateSizes() self.update() def setIndex(self, index): self.fIndex = index def setPixmap(self, pixmapId): self.fPixmapNum = "%02i" % pixmapId self.fPixmap.load(":/bitmaps/dial_%s%s.png" % (self.fPixmapNum, "" if self.isEnabled() else "d")) if self.fPixmap.width() > self.fPixmap.height(): self.fPixmapOrientation = self.HORIZONTAL else: self.fPixmapOrientation = self.VERTICAL # special pixmaps if self.fCustomPaintMode == self.CUSTOM_PAINT_MODE_NULL: # reserved for carla-wet, carla-vol, carla-pan and color if self.fPixmapNum == "03": self.fCustomPaintMode = self.CUSTOM_PAINT_MODE_COLOR # reserved for carla-L and carla-R elif self.fPixmapNum == "04": self.fCustomPaintMode = self.CUSTOM_PAINT_MODE_CARLA_L # reserved for zita elif self.fPixmapNum == "06": self.fCustomPaintMode = self.CUSTOM_PAINT_MODE_ZITA self.updateSizes() self.update() def setMinimum(self, value): self.fMinimum = value def setMaximum(self, value): self.fMaximum = value def setValue(self, value): if self.fRealValue == value: return self.fRealValue = value normValue = float(value - self.fMinimum) / float(self.fMaximum - self.fMinimum) QDial.setValue(self, int(normValue * 10000)) @pyqtSlot(int) def slot_valueChanged(self, value): self.fRealValue = float(value)/10000.0 * (self.fMaximum - self.fMinimum) + self.fMinimum self.realValueChanged.emit(self.fRealValue) @pyqtSlot() def slot_updatePixmap(self): self.setPixmap(int(self.fPixmapNum)) def minimumSizeHint(self): return QSize(self.fPixmapBaseSize, self.fPixmapBaseSize) def sizeHint(self): return QSize(self.fPixmapBaseSize, self.fPixmapBaseSize) def changeEvent(self, event): QDial.changeEvent(self, event) # Force pixmap update if enabled state changes if event.type() == QEvent.EnabledChange: self.setPixmap(int(self.fPixmapNum)) def enterEvent(self, event): self.fIsHovered = True if self.fHoverStep == self.HOVER_MIN: self.fHoverStep = self.HOVER_MIN + 1 QDial.enterEvent(self, event) def leaveEvent(self, event): self.fIsHovered = False if self.fHoverStep == self.HOVER_MAX: self.fHoverStep = self.HOVER_MAX - 1 QDial.leaveEvent(self, event) 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 resizeEvent(self, event): QDial.resizeEvent(self, event) self.updateSizes()
def toGradient(cls, data): """把字典转成渐变 :param cls: :param data: 字典数据 """ gtype = data.get('type', -1) if gtype == QGradient.LinearGradient: gradient = QLinearGradient() elif gtype == QGradient.RadialGradient: gradient = QRadialGradient() elif gtype == QGradient.ConicalGradient: gradient = QConicalGradient() else: gradient = QLinearGradient() gradient.setSpread(data.get('spread', QGradient.PadSpread)) gradient.setStart(data.get('start', QPointF(0, 0))) gradient.setFinalStop(data.get('finalStop', QPointF(1, 1))) stops = data.get('stops', None) if stops: gradient.setStops(stops) return gradient
def paint(self, painter, option, widget): painter.save() painter.setRenderHint(QPainter.Antialiasing, bool(options.antialiasing == ANTIALIASING_FULL)) rect = QRectF(0, 0, self.p_width, self.p_height) # Draw rectangle pen = QPen(canvas.theme.box_pen_sel if self.isSelected() else canvas. theme.box_pen) pen.setWidthF(pen.widthF() + 0.00001) painter.setPen(pen) lineHinting = pen.widthF() / 2 if canvas.theme.box_bg_type == Theme.THEME_BG_GRADIENT: box_gradient = QLinearGradient(0, 0, 0, self.p_height) box_gradient.setColorAt(0, canvas.theme.box_bg_1) box_gradient.setColorAt(1, canvas.theme.box_bg_2) painter.setBrush(box_gradient) else: painter.setBrush(canvas.theme.box_bg_1) rect.adjust(lineHinting, lineHinting, -lineHinting, -lineHinting) painter.drawRect(rect) # Draw plugin inline display if supported self.paintInlineDisplay(painter) # Draw pixmap header rect.setHeight(canvas.theme.box_header_height) if canvas.theme.box_header_pixmap: painter.setPen(Qt.NoPen) painter.setBrush(canvas.theme.box_bg_2) # outline rect.adjust(lineHinting, lineHinting, -lineHinting, -lineHinting) painter.drawRect(rect) rect.adjust(1, 1, -1, 0) painter.drawTiledPixmap(rect, canvas.theme.box_header_pixmap, rect.topLeft()) # Draw text painter.setFont(self.m_font_name) if self.isSelected(): painter.setPen(canvas.theme.box_text_sel) else: painter.setPen(canvas.theme.box_text) if canvas.theme.box_use_icon: textPos = QPointF(25, canvas.theme.box_text_ypos) else: appNameSize = fontHorizontalAdvance(self.m_font_name, self.m_group_name) rem = self.p_width - appNameSize textPos = QPointF(rem / 2, canvas.theme.box_text_ypos) painter.drawText(textPos, self.m_group_name) self.repaintLines() painter.restore()
def paintEvent(self, event): page_bottom = self.edit.viewport().height() font_metrics = QFontMetrics(self.edit.document().defaultFont()) current_block = self.edit.document().findBlock( self.edit.textCursor().position()) pattern = self.pat if self.edit.lang == "python" else self.patNotPython painter = QPainter(self) background = resources.CUSTOM_SCHEME.get( 'sidebar-background', resources.COLOR_SCHEME['sidebar-background']) foreground = resources.CUSTOM_SCHEME.get( 'sidebar-foreground', resources.COLOR_SCHEME['sidebar-foreground']) background_selected = resources.CUSTOM_SCHEME.get( 'sidebar-selected-background', resources.COLOR_SCHEME['sidebar-selected-background']) foreground_selected = resources.CUSTOM_SCHEME.get( 'sidebar-selected-foreground', resources.COLOR_SCHEME['sidebar-selected-foreground']) painter.fillRect(self.rect(), QColor(background)) block = self.edit.firstVisibleBlock() viewport_offset = self.edit.contentOffset() line_count = block.blockNumber() painter.setFont(self.edit.document().defaultFont()) xofs = self.width() - self.foldArea painter.fillRect( xofs, 0, self.foldArea, self.height(), QColor( resources.CUSTOM_SCHEME.get( 'fold-area', resources.COLOR_SCHEME['fold-area']))) while block.isValid(): line_count += 1 # The top left position of the block in the document position = self.edit.blockBoundingGeometry(block).topLeft() + \ viewport_offset # Check if the position of the block is outside of the visible area if position.y() > page_bottom: break # Set the Painter Pen depending on special lines painter.setPen(QColor(foreground)) error = False checkers = self._neditable.sorted_checkers for items in checkers: checker, color, _ = items if (line_count - 1) in checker.checks: painter.setPen(QColor(color)) font = painter.font() font.setItalic(True) font.setUnderline(True) painter.setFont(font) error = True break # We want the line number for the selected line to be bold. bold = False if block == current_block: painter.fillRect( 0, round(position.y()) + font_metrics.descent(), self.width(), font_metrics.ascent() + font_metrics.descent(), QColor(background_selected)) bold = True font = painter.font() font.setBold(True) if not error: painter.setPen(QColor(foreground_selected)) 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). if block.isVisible(): painter.drawText( self.width() - self.foldArea - font_metrics.width(str(line_count)) - 3, round(position.y()) + font_metrics.ascent() + font_metrics.descent() - 1, str(line_count)) # Remove the bold style if it was set previously. if bold: font = painter.font() font.setBold(False) painter.setFont(font) if error: font = painter.font() font.setItalic(False) font.setUnderline(False) painter.setFont(font) block = block.next() self.highest_line = line_count #Code Folding if self.foldArea != self.rightArrowIcon.width(): polygon = QPolygonF() self.rightArrowIcon = QPixmap(self.foldArea, self.foldArea) self.rightArrowIcon.fill(Qt.transparent) self.downArrowIcon = QPixmap(self.foldArea, self.foldArea) self.downArrowIcon.fill(Qt.transparent) polygon.append(QPointF(self.foldArea * 0.4, self.foldArea * 0.25)) polygon.append(QPointF(self.foldArea * 0.4, self.foldArea * 0.75)) polygon.append(QPointF(self.foldArea * 0.8, self.foldArea * 0.5)) iconPainter = QPainter(self.rightArrowIcon) iconPainter.setRenderHint(QPainter.Antialiasing) iconPainter.setPen(Qt.NoPen) iconPainter.setBrush( QColor( resources.CUSTOM_SCHEME.get( 'fold-arrow', resources.COLOR_SCHEME['fold-arrow']))) iconPainter.drawPolygon(polygon) polygon.clear() polygon.append(QPointF(self.foldArea * 0.25, self.foldArea * 0.4)) polygon.append(QPointF(self.foldArea * 0.75, self.foldArea * 0.4)) polygon.append(QPointF(self.foldArea * 0.5, self.foldArea * 0.8)) iconPainter = QPainter(self.downArrowIcon) iconPainter.setRenderHint(QPainter.Antialiasing) iconPainter.setPen(Qt.NoPen) iconPainter.setBrush( QColor( resources.CUSTOM_SCHEME.get( 'fold-arrow', resources.COLOR_SCHEME['fold-arrow']))) iconPainter.drawPolygon(polygon) self.calculate_docstring_block_fold() block = self.edit.firstVisibleBlock() while block.isValid(): position = self.edit.blockBoundingGeometry( block).topLeft() + viewport_offset #Check if the position of the block is outside of the visible area if position.y() > page_bottom: break if pattern.match(block.text()) and block.isVisible(): can_fold = True if self.patComment.match(block.text()) and \ (block.blockNumber() in self._endDocstringBlocks): can_fold = False if can_fold: if block.blockNumber() in self.foldedBlocks: painter.drawPixmap(xofs, round(position.y()), self.rightArrowIcon) else: painter.drawPixmap(xofs, round(position.y()), self.downArrowIcon) #Add Bookmarks and Breakpoint if block.blockNumber() in self.breakpoints: linear_gradient = QLinearGradient( xofs, round(position.y()), xofs + self.foldArea, round(position.y()) + self.foldArea) linear_gradient.setColorAt(0, QColor(255, 11, 11)) linear_gradient.setColorAt(1, QColor(147, 9, 9)) painter.setRenderHints(QPainter.Antialiasing, True) painter.setPen(Qt.NoPen) painter.setBrush(QBrush(linear_gradient)) painter.drawEllipse(xofs + 1, round(position.y()) + 6, self.foldArea - 1, self.foldArea - 1) elif block.blockNumber() in self.bookmarks: linear_gradient = QLinearGradient( xofs, round(position.y()), xofs + self.foldArea, round(position.y()) + self.foldArea) linear_gradient.setColorAt(0, QColor(13, 62, 243)) linear_gradient.setColorAt(1, QColor(5, 27, 106)) painter.setRenderHints(QPainter.Antialiasing, True) painter.setPen(Qt.NoPen) painter.setBrush(QBrush(linear_gradient)) painter.drawRoundedRect(xofs + 1, round(position.y()) + 6, self.foldArea - 2, self.foldArea - 1, 3, 3) block = block.next() painter.end() super(SidebarWidget, self).paintEvent(event)
class DigitalPeakMeter(QWidget): # enum Orientation HORIZONTAL = 1 VERTICAL = 2 # enum Color GREEN = 1 BLUE = 2 # enum Style STYLE_DEFAULT = 0 STYLE_OPENAV = 1 def __init__(self, parent): QWidget.__init__(self, parent) self.fChannels = 0 self.fDrawLines = True self.fOrientation = self.VERTICAL self.fSmoothMultiplier = 1 self.fColorBackground = QColor("#111111") self.fGradientMeter = QLinearGradient(0, 0, 1, 1) self.fMeterStyle = self.STYLE_DEFAULT self.setChannels(0) self.setColor(self.GREEN) def displayMeter(self, meter, level, forced = False): if meter <= 0 or meter > self.fChannels: return qCritical("DigitalPeakMeter::displayMeter(%i, %f) - invalid meter number" % (meter, level)) if not isinstance(level, float): return qCritical("DigitalPeakMeter::displayMeter(%i, %f) - meter value must be float" % (meter, level)) i = meter - 1 if self.fSmoothMultiplier > 0 and not forced: level = (self.fLastValueData[i] * self.fSmoothMultiplier + level) / float(self.fSmoothMultiplier + 1) if level < 0.001: level = 0.0 elif level > 0.999: level = 1.0 if self.fChannelsData[i] != level: self.fChannelsData[i] = level self.update() self.fLastValueData[i] = level def setChannels(self, channels): if channels < 0: return qCritical("DigitalPeakMeter::setChannels(%i) - 'channels' must be a positive integer" % channels) self.fChannels = channels self.fChannelsData = [] self.fLastValueData = [] for x in range(channels): self.fChannelsData.append(0.0) self.fLastValueData.append(0.0) def setColor(self, color): if color == self.GREEN: self.fColorBase = QColor(93, 231, 61) self.fColorBaseAlt = QColor(15, 110, 15, 100) elif color == self.BLUE: self.fColorBase = QColor(82, 238, 248) self.fColorBaseAlt = QColor(15, 15, 110, 100) else: return qCritical("DigitalPeakMeter::setColor(%i) - invalid color" % color) self.setOrientation(self.fOrientation) def setMeterStyle(self, style): self.fMeterStyle = style self.setOrientation(self.fOrientation) def setLinesEnabled(self, yesNo): self.fDrawLines = yesNo def setOrientation(self, orientation): self.fOrientation = orientation self.fGradientMeter = QLinearGradient(0, 0, 1, 1) if self.fMeterStyle == self.STYLE_OPENAV: self.fGradientMeter.setColorAt(0.0, self.fColorBase) self.fGradientMeter.setColorAt(1.0, self.fColorBase) elif self.fOrientation == self.HORIZONTAL: self.fGradientMeter.setColorAt(0.0, self.fColorBase) self.fGradientMeter.setColorAt(0.2, self.fColorBase) self.fGradientMeter.setColorAt(0.4, self.fColorBase) self.fGradientMeter.setColorAt(0.6, self.fColorBase) self.fGradientMeter.setColorAt(0.8, Qt.yellow) self.fGradientMeter.setColorAt(1.0, Qt.red) elif self.fOrientation == self.VERTICAL: self.fGradientMeter.setColorAt(0.0, Qt.red) self.fGradientMeter.setColorAt(0.2, Qt.yellow) self.fGradientMeter.setColorAt(0.4, self.fColorBase) self.fGradientMeter.setColorAt(0.6, self.fColorBase) self.fGradientMeter.setColorAt(0.8, self.fColorBase) self.fGradientMeter.setColorAt(1.0, self.fColorBase) else: return qCritical("DigitalPeakMeter::setOrientation(%i) - invalid orientation" % orientation) self.updateSizes() def setSmoothRelease(self, value): if value < 0: value = 0 elif value > 5: value = 5 self.fSmoothMultiplier = value def minimumSizeHint(self): return QSize(10, 10) def sizeHint(self): return QSize(self.fWidth, self.fHeight) def updateSizes(self): self.fWidth = self.width() self.fHeight = self.height() self.fSizeMeter = 0 if self.fOrientation == self.HORIZONTAL: self.fGradientMeter.setFinalStop(self.fWidth, 0) if self.fChannels > 0: self.fSizeMeter = self.fHeight / self.fChannels elif self.fOrientation == self.VERTICAL: self.fGradientMeter.setFinalStop(0, self.fHeight) if self.fChannels > 0: self.fSizeMeter = self.fWidth / self.fChannels def paintEvent(self, event): painter = QPainter(self) event.accept() if self.fMeterStyle == self.STYLE_OPENAV: painter.setPen(QColor("#1A1A1A")) painter.setBrush(QColor("#1A1A1A")) else: painter.setPen(Qt.black) painter.setBrush(Qt.black) painter.drawRect(0, 0, self.fWidth, self.fHeight) meterX = 0 startX = -1 if self.fMeterStyle == self.STYLE_OPENAV else 0 padding = 2 if self.fMeterStyle == self.STYLE_OPENAV else 0 painter.setPen(self.fColorBackground) painter.setBrush(self.fGradientMeter) if self.fMeterStyle == self.STYLE_OPENAV: color = self.fGradientMeter.stops()[0][1] painter.setPen(color) color.setAlphaF(0.5) painter.setBrush(color) del color for i in range(self.fChannels): level = self.fChannelsData[i] if self.fOrientation == self.HORIZONTAL: value = level * float(self.fWidth) elif self.fOrientation == self.VERTICAL: value = float(self.fHeight) - (level * float(self.fHeight)) else: value = 0.0 if self.fOrientation == self.HORIZONTAL: painter.drawRect(startX, meterX+padding, int(value), self.fSizeMeter-padding*(1 if self.fChannels > 1 else 2)) elif self.fOrientation == self.VERTICAL: painter.drawRect(meterX, int(value), self.fSizeMeter, self.fHeight) meterX += self.fSizeMeter if not self.fDrawLines: return painter.setBrush(Qt.black) if self.fOrientation == self.HORIZONTAL: # Variables lsmall = float(self.fWidth) lfull = float(self.fHeight - 1) if self.fMeterStyle == self.STYLE_OPENAV: painter.setPen(QColor(37, 37, 37, 100)) painter.drawLine(lsmall * 0.25, 2, lsmall * 0.25, lfull-2.0) painter.drawLine(lsmall * 0.50, 2, lsmall * 0.50, lfull-2.0) painter.drawLine(lsmall * 0.75, 2, lsmall * 0.75, lfull-2.0) if self.fChannels > 1: painter.drawLine(1, lfull/2, lsmall-1, lfull/2) else: # Base painter.setPen(self.fColorBaseAlt) painter.drawLine(lsmall * 0.25, 2, lsmall * 0.25, lfull-2.0) painter.drawLine(lsmall * 0.50, 2, lsmall * 0.50, lfull-2.0) # Yellow painter.setPen(QColor(110, 110, 15, 100)) painter.drawLine(lsmall * 0.70, 2, lsmall * 0.70, lfull-2.0) painter.drawLine(lsmall * 0.83, 2, lsmall * 0.83, lfull-2.0) # Orange painter.setPen(QColor(180, 110, 15, 100)) painter.drawLine(lsmall * 0.90, 2, lsmall * 0.90, lfull-2.0) # Red painter.setPen(QColor(110, 15, 15, 100)) painter.drawLine(lsmall * 0.96, 2, lsmall * 0.96, lfull-2.0) elif self.fOrientation == self.VERTICAL: # Variables lsmall = float(self.fHeight) lfull = float(self.fWidth - 1) if self.fMeterStyle == self.STYLE_OPENAV: # TODO pass else: # Base painter.setPen(self.fColorBaseAlt) painter.drawLine(2, lsmall - (lsmall * 0.25), lfull-2.0, lsmall - (lsmall * 0.25)) painter.drawLine(2, lsmall - (lsmall * 0.50), lfull-2.0, lsmall - (lsmall * 0.50)) # Yellow painter.setPen(QColor(110, 110, 15, 100)) painter.drawLine(2, lsmall - (lsmall * 0.70), lfull-2.0, lsmall - (lsmall * 0.70)) painter.drawLine(2, lsmall - (lsmall * 0.82), lfull-2.0, lsmall - (lsmall * 0.82)) # Orange painter.setPen(QColor(180, 110, 15, 100)) painter.drawLine(2, lsmall - (lsmall * 0.90), lfull-2.0, lsmall - (lsmall * 0.90)) # Red painter.setPen(QColor(110, 15, 15, 100)) painter.drawLine(2, lsmall - (lsmall * 0.96), lfull-2.0, lsmall - (lsmall * 0.96)) def resizeEvent(self, event): self.updateSizes() QWidget.resizeEvent(self, event)
def drawToolButtonBezel(self, painter, rect, color, hoover=False, has_focus=False): painter.setRenderHint(QPainter.Antialiasing, True) painter.setPen(Qt.NoPen) glow_rect = rect shadow_rect = rect.adjusted(1, 1, -1, -1) border_rect = rect.adjusted(2, 2, -2, -2) content_rect = rect.adjusted(3, 3, -3, -3) focus_color = QColor('#3aa7dd') hoover_color = QColor('#6ed6ff') shadow_color = ColorScheme.shade(self.background_bottom_color(color), ColorScheme.ShadowShade, 0.0) border_color_top = ColorScheme.shade(self.background_top_color(color), ColorScheme.LightShade, 0.0) border_color_bottom = ColorScheme.shade( self.background_bottom_color(color), ColorScheme.MidlightShade, 0.5) # glow painter.setCompositionMode(QPainter.CompositionMode_SourceOver) blend = QLinearGradient(glow_rect.topLeft(), glow_rect.bottomLeft()) if hoover: blend.setColorAt(0.0, self.color_with_alpha(hoover_color, 0x45)) blend.setColorAt(0.9, self.color_with_alpha(hoover_color, 0x45)) blend.setColorAt( 1.0, self.color_with_alpha( ColorUtils.mix(hoover_color, shadow_color, 0.4), 0x55)) elif has_focus: blend.setColorAt(0.0, self.color_with_alpha(focus_color, 0x45)) blend.setColorAt(0.9, self.color_with_alpha(focus_color, 0x45)) blend.setColorAt( 1.0, self.color_with_alpha( ColorUtils.mix(focus_color, shadow_color, 0.4), 0x55)) else: blend.setColorAt(0.0, Qt.transparent) # or @0.5 blend.setColorAt(0.9, self.color_with_alpha(shadow_color, 0x10)) # blend.setColorAt(1-4.0/glow_rect.height(), self.color_with_alpha(shadow_color, 0x10)) # this is for exactly 4 pixels from bottom blend.setColorAt(1.0, self.color_with_alpha(shadow_color, 0x30)) # 0x25, 0x30 or 0x35 painter.setBrush(blend) painter.drawRoundedRect(glow_rect, 5, 5) # 5 or 6 # shadow painter.setCompositionMode(QPainter.CompositionMode_SourceOver) if hoover: painter.setBrush(hoover_color) elif has_focus: painter.setBrush(focus_color) else: blend = QLinearGradient(shadow_rect.topLeft(), shadow_rect.bottomLeft()) blend.setColorAt(0.00, self.color_with_alpha(shadow_color, 0x10)) blend.setColorAt(1.00, self.color_with_alpha(shadow_color, 0x80)) painter.setBrush(blend) painter.drawRoundedRect(shadow_rect, 4, 4) # 4 or 5 # border painter.setCompositionMode(QPainter.CompositionMode_Source) blend = QLinearGradient(border_rect.topLeft(), border_rect.bottomLeft()) blend.setColorAt(0.0, border_color_top) blend.setColorAt(1.0, border_color_bottom) painter.setBrush(blend) painter.drawRoundedRect(border_rect, 4, 4) # content painter.setCompositionMode(QPainter.CompositionMode_Source) grad = QLinearGradient(content_rect.topLeft(), content_rect.bottomLeft()) grad.setColorAt(0.0, self.background_top_color(color)) grad.setColorAt(1.0, self.background_bottom_color(color)) painter.setBrush(QBrush(grad)) painter.drawRoundedRect(content_rect, 4, 4)
def draw_tracker_pixmap(self, cursor_pos): tracker_pixmap = QPixmap(self.parent.size()) tracker_pixmap.fill(QColor(255, 255, 255, 0)) qpainter = QPainter() qpainter.begin(tracker_pixmap) origin = self.calc_gui_point([0, 0]) axis_origin = [ max(min(origin[0], self.parent.width() - self.axis_margin[0]), self.axis_margin[0]), max(min(origin[1], self.parent.height() - self.axis_margin[1]), self.axis_margin[1]) ] qpainter.setPen(self.axis_pen) pnt = self.calc_val_point([cursor_pos.x(), cursor_pos.y()]) x_label = str(round(pnt[0], 2)) y_label = str(round(pnt[1], 2)) str_rect = QRect(cursor_pos.x() + 5, axis_origin[1], qpainter.fontMetrics().width(x_label), 25) g_rect = QRect(str_rect.x() - 30, str_rect.y(), 30, str_rect.height()) gradient = QLinearGradient(QPoint(g_rect.right(), g_rect.center().y()), QPoint(g_rect.left(), g_rect.center().y())) gradient.setColorAt(0, QColor(255, 255, 255)) gradient.setColorAt(1, QColor(255, 255, 255, 0)) qpainter.fillRect(g_rect, gradient) g_rect = QRect(str_rect.right(), str_rect.y(), 30, str_rect.height()) gradient = QLinearGradient(QPoint(g_rect.left(), g_rect.center().y()), QPoint(g_rect.right(), g_rect.center().y())) gradient.setColorAt(0, QColor(255, 255, 255)) gradient.setColorAt(1, QColor(255, 255, 255, 0)) qpainter.fillRect(g_rect, gradient) qpainter.fillRect(str_rect, QColor(255, 255, 255)) qpainter.drawText(str_rect, Qt.AlignLeft | Qt.AlignCenter, x_label) qpainter.drawLine(cursor_pos.x(), axis_origin[1], cursor_pos.x(), axis_origin[1] + 10) label_width = qpainter.fontMetrics().width(y_label) str_rect = QRect(axis_origin[0] - label_width - 1, cursor_pos.y() + 1, label_width, 15) g_rect = QRect(str_rect.x(), str_rect.y() - 10, str_rect.width(), 10) gradient = QLinearGradient( QPoint(g_rect.center().x(), g_rect.bottom()), QPoint(g_rect.center().x(), g_rect.top())) gradient.setColorAt(0, QColor(255, 255, 255)) gradient.setColorAt(1, QColor(255, 255, 255, 0)) qpainter.fillRect(g_rect, gradient) g_rect = QRect(str_rect.x(), str_rect.bottom(), str_rect.width(), 10) gradient = QLinearGradient( QPoint(g_rect.center().x(), g_rect.top()), QPoint(g_rect.center().x(), g_rect.bottom())) gradient.setColorAt(0, QColor(255, 255, 255)) gradient.setColorAt(1, QColor(255, 255, 255, 0)) qpainter.fillRect(g_rect, gradient) qpainter.fillRect(str_rect, QColor(255, 255, 255)) qpainter.drawText(str_rect, Qt.AlignRight | Qt.AlignCenter, y_label) qpainter.drawLine(axis_origin[0], cursor_pos.y(), axis_origin[0] - 10, cursor_pos.y()) qpainter.end() return tracker_pixmap
def paintEvent(self, event): painter = QPainter(self) painter.setPen(QPen(Qt.black, 5, Qt.SolidLine)) grad = QLinearGradient(80, 40, 30, 10) painter.setBrush(QBrush(grad)) painter.drawRect(10, 10, 200, 200)
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 drawControl(self, element, opt, painter, widget): """elif element == QStyle.CE_PushButtonBevel: # States is_down = (opt.state & STATE_SUNKEN) | (opt.state & STATE_ON) hovered = opt.state & STATE_ENABLED and opt.state & STATE_MOUSEOVER has_focus = opt.state & STATE_HASFOCUS rect = opt.rect btn_color = opt.palette.button().color() painter.setPen(btn_color) painter.setRenderHint(QPainter.Antialiasing) path = QPainterPath() path.addRoundedRect(QRectF(rect), 3, 3) if is_down: painter.setBrush(btn_color.darker(115)) elif has_focus: painter.setBrush(btn_color.lighter(130)) elif hovered: grad = QLinearGradient(rect.topLeft(), rect.bottomLeft()) grad.setColorAt(0.6, btn_color) grad.setColorAt(1, btn_color.lighter(120)) painter.setBrush(grad) else: painter.setBrush(btn_color) painter.drawPath(path)""" if element == QStyle.CE_ComboBoxLabel: cb = opt painter.save() edit_rect = self.subControlRect(QStyle.CC_ComboBox, cb, QStyle.SC_ComboBoxEditField, widget) # Draw icon if not cb.currentIcon.isNull(): if cb.state & STATE_ENABLED: mode = QIcon.Normal else: mode = QIcon.Disabled pixmap = cb.currentIcon.pixmap(cb.iconSize, mode) icon_rect = QRect(cb.rect) icon_rect.setWidth(cb.iconSize.width() + 4) # icon_rect = self.alignedRect(opt.direction, # Qt.AlignLeft | Qt.AlignVCenter, # icon_rect.size(), edit_rect) self.drawItemPixmap(painter, icon_rect, Qt.AlignCenter, pixmap) # Space between text if cb.direction == Qt.RightToLeft: edit_rect.translate(-4, -cb.iconSize.width(), 0) else: edit_rect.translate(cb.iconSize.width() + 4, 0) edit_rect.adjusted(0, 0, -13, 0) # Draw text elide_width = edit_rect.width() - opt.fontMetrics.width('**') text = opt.fontMetrics.elidedText(cb.currentText, Qt.ElideRight, elide_width) # FIXME: states painter.setPen(theme.get_color('ComboBoxTextColor')) painter.drawText(edit_rect.adjusted(1, 0, -1, 0), Qt.AlignLeft | Qt.AlignVCenter, text) painter.restore() # TODO: tab with flat style # elif element == QStyle.CE_TabBarTabShape: # pass elif element == QStyle.CE_ToolBar: rect = opt.rect color = theme.get_color('ToolButtonColor') if widget.property('gradient') and not theme.flag("FlatComboBox"): base = QColor(theme.get_color('Window')) color = QLinearGradient(opt.rect.topRight(), opt.rect.bottomRight()) color.setColorAt(0.2, base.lighter(150)) color.setColorAt(0.9, base.darker(135)) # print(widget.property("border"), widget) painter.fillRect(rect, color) if widget.property("border"): # painter.setPen(opt.palette.light().color().lighter(150)) painter.setPen(theme.get_color('Border')) painter.drawLine(rect.topRight(), rect.bottomRight()) # painter.setPen(theme.get_color(Border']) # painter.drawLine(opt.rect.topRight(), opt.rect.bottomRight()) elif element == QStyle.CE_MenuItem: painter.save() enabled = opt.state & STATE_ENABLED item = opt item.rect = opt.rect pal = opt.palette if enabled: color = theme.get_color('MenuItemEnabled') else: color = theme.get_color('MenuItemDisabled') item.palette = pal pal.setBrush(QPalette.Text, color) QProxyStyle.drawControl(self, element, opt, painter, widget) painter.restore() elif element == QStyle.CE_MenuBarEmptyArea: painter.fillRect(opt.rect, theme.get_color('MenuBar')) # Draw border painter.save() # FIXME: color from theme painter.setPen(theme.get_color('MenuBarBorderColor')) painter.drawLine(opt.rect.bottomLeft() + QPointF(.5, .5), opt.rect.bottomRight() + QPointF(.5, .5)) painter.restore() # elif element == QStyle.CE_PushButtonBevel: # painter.setPen(Qt.red) # painter.fillRect(opt.rect, QColor("red")) elif element == QStyle.CE_MenuBarItem: painter.save() act = opt.state & (STATE_SUNKEN | QStyle.State_Selected) dis = not (opt.state & STATE_ENABLED) painter.fillRect(opt.rect, theme.get_color('MenuBar')) pal = opt.palette item = opt item.rect = opt.rect if dis: color = theme.get_color('MenuBarItemDisabled') else: color = theme.get_color('MenuBarItemEnabled') pal.setBrush(QPalette.ButtonText, color) item.palette = pal QCommonStyle.drawControl(self, element, item, painter, widget) if act: pal = opt.palette color = theme.get_color('MenuBarHover') painter.fillRect(opt.rect, color) align = (Qt.AlignCenter | Qt.TextShowMnemonic | Qt.TextDontClip | Qt.TextSingleLine) if not self.styleHint(QStyle.SH_UnderlineShortcut, opt, widget): align |= Qt.TextHideMnemonic # FIXME: if dis: co = theme.get_color('IconDisabledColor') else: co = theme.get_color('MenuBarTextHover') painter.setPen(Qt.NoPen) pal.setBrush(QPalette.Text, co) self.drawItemText(painter, item.rect, align, pal, not dis, opt.text, QPalette.Text) painter.restore() else: QProxyStyle.drawControl(self, element, opt, painter, widget)
def createCurveIcons(self): pix = QPixmap(self.m_iconSize) painter = QPainter() gradient = QLinearGradient(0, 0, 0, self.m_iconSize.height()) gradient.setColorAt(0.0, QColor(240, 240, 240)) gradient.setColorAt(1.0, QColor(224, 224, 224)) brush = QBrush(gradient) # The original C++ code uses undocumented calls to get the names of the # different curve types. We do the Python equivalant (but without # cheating). curve_types = [ (n, c) for n, c in QEasingCurve.__dict__.items() if isinstance(c, QEasingCurve.Type) and c != QEasingCurve.Custom ] curve_types.sort(key=lambda ct: ct[1]) painter.begin(pix) for curve_name, curve_type in curve_types: painter.fillRect(QRect(QPoint(0, 0), self.m_iconSize), brush) curve = QEasingCurve(curve_type) if curve_type == QEasingCurve.BezierSpline: curve.addCubicBezierSegment(QPointF(0.4, 0.1), QPointF(0.6, 0.9), QPointF(1.0, 1.0)) elif curve_type == QEasingCurve.TCBSpline: curve.addTCBSegment(QPointF(0.0, 0.0), 0, 0, 0) curve.addTCBSegment(QPointF(0.3, 0.4), 0.2, 1, -0.2) curve.addTCBSegment(QPointF(0.7, 0.6), -0.2, 1, 0.2) curve.addTCBSegment(QPointF(1.0, 1.0), 0, 0, 0) painter.setPen(QColor(0, 0, 255, 64)) xAxis = self.m_iconSize.height() / 1.5 yAxis = self.m_iconSize.width() / 3.0 painter.drawLine(0, xAxis, self.m_iconSize.width(), xAxis) painter.drawLine(yAxis, 0, yAxis, self.m_iconSize.height()) curveScale = self.m_iconSize.height() / 2.0 painter.setPen(Qt.NoPen) # Start point. painter.setBrush(Qt.red) start = QPoint(yAxis, xAxis - curveScale * curve.valueForProgress(0)) painter.drawRect(start.x() - 1, start.y() - 1, 3, 3) # End point. painter.setBrush(Qt.blue) end = QPoint(yAxis + curveScale, xAxis - curveScale * curve.valueForProgress(1)) painter.drawRect(end.x() - 1, end.y() - 1, 3, 3) curvePath = QPainterPath() curvePath.moveTo(QPointF(start)) t = 0.0 while t <= 1.0: to = QPointF(yAxis + curveScale * t, xAxis - curveScale * curve.valueForProgress(t)) curvePath.lineTo(to) t += 1.0 / curveScale painter.setRenderHint(QPainter.Antialiasing, True) painter.strokePath(curvePath, QColor(32, 32, 32)) painter.setRenderHint(QPainter.Antialiasing, False) item = QListWidgetItem() item.setIcon(QIcon(pix)) item.setText(curve_name) self.m_ui.easingCurvePicker.addItem(item) painter.end()
def paintGraph(self, graph, painter): brush = QBrush(Qt.SolidPattern) pen = QPen() brush.setColor(Qt.white) for i, edge in enumerate(graph.edges): if ("color" in edge.kwargs.keys()): pen.setColor(QColor(edge.kwargs["color"])) else: pen.setColor(QColor("black")) if ("width" in edge.kwargs.keys()): pen.setWidth(int(edge.kwargs["width"])) else: pen.setWidth(1) painter.setPen(pen) painter.setBrush(brush) if (edge.source.parent_graph != graph and not self.show_subgraphs): gspos = edge.source.parent_graph.global_pos else: gspos = edge.source.global_pos if (edge.dest.parent_graph != graph and not self.show_subgraphs): gspos = edge.dest.parent_graph.global_pos else: gdpos = edge.dest.global_pos nb_next = 0 for j in range(i, len(graph.edges)): if (graph.edges[j].source == edge.source and graph.edges[j].dest == edge.dest): nb_next += 1 offset = [0, 0] if (nb_next % 2 == 1): offset[0] = 20 * (nb_next / 2) else: offset[0] = -20 * (nb_next / 2) path = QPainterPath() path.moveTo(gspos[0], gspos[1]) path.cubicTo(gspos[0], gspos[1], offset[0] + (gspos[0] + gdpos[0]) / 2, (gspos[1] + gdpos[1]) / 2, gdpos[0], gdpos[1]) painter.strokePath(path, pen) """ painter.drawLine(gspos[0],gspos[1], gdpos[0], gdpos[1]) """ if (self.show_subgraphs): for node in graph.nodes: if type(node) == Graph: subgraph = node self.paintSubgraph(subgraph, painter, pen, brush) # TODO : add more painting parameters for node in graph.nodes: if type(node) != Graph: if ("color" in node.kwargs.keys()): pen.setColor(QColor(node.kwargs["color"])) else: pen.setColor(QColor("black")) if ("fillcolor" in node.kwargs.keys()): if (":" in node.kwargs["fillcolor"]): gradient = QLinearGradient( node.pos[0] - node.size[0] / 2, node.pos[1], node.pos[0] + node.size[0] / 2, node.pos[1]) c = node.kwargs["fillcolor"].split(":") for i, col in enumerate(c): stop = i / (len(c) - 1) gradient.setColorAt(stop, QColor(col)) brush = QBrush(gradient) else: brush = QBrush(QColor(node.kwargs["fillcolor"])) else: brush = QBrush(QColor("white")) if ("width" in node.kwargs.keys()): pen.setWidth(int(node.kwargs["width"])) else: pen.setWidth(1) gpos = node.global_pos painter.setPen(pen) painter.setBrush(brush) if ("shape" in node.kwargs.keys()): if (node.kwargs["shape"] == "box"): painter.drawRect(gpos[0] - node.size[0] / 2, gpos[1] - node.size[1] / 2, node.size[0], node.size[1]) elif (node.kwargs["shape"] == "circle"): painter.drawEllipse(gpos[0] - node.size[0] / 2, gpos[1] - node.size[1] / 2, node.size[0], node.size[1]) elif (node.kwargs["shape"] == "triangle"): rect = QRect(gpos[0] - node.size[0] / 2, gpos[1] - 2 * node.size[1] / 3, node.size[0], node.size[1]) path = QPainterPath() path.moveTo(rect.left() + (rect.width() / 2), rect.top()) path.lineTo(rect.bottomLeft()) path.lineTo(rect.bottomRight()) path.lineTo(rect.left() + (rect.width() / 2), rect.top()) painter.fillPath(path, brush) painter.drawPath(path) elif (node.kwargs["shape"] == "polygon"): rect = QRect(gpos[0] - node.size[0] / 2, gpos[1] - node.size[1] / 2, node.size[0], node.size[1]) path = QPainterPath() path.moveTo(rect.left() + (rect.width() / 4), rect.top()) path.lineTo(rect.left() + 3 * rect.width() / 4, rect.top()) path.lineTo(rect.left() + rect.width(), rect.top() + rect.height() / 2) path.lineTo(rect.left() + 3 * rect.width() / 4, rect.top() + rect.height()) path.lineTo(rect.left() + rect.width() / 4, rect.top() + rect.height()) path.lineTo(rect.left(), rect.top() + rect.height() / 2) path.lineTo(rect.left() + (rect.width() / 4), rect.top()) painter.fillPath(path, brush) painter.drawPath(path) elif (node.kwargs["shape"] == "diamond"): rect = QRect(gpos[0] - node.size[0] / 2, gpos[1] - node.size[1] / 2, node.size[0], node.size[1]) path = QPainterPath() path.moveTo(rect.left() + (rect.width() / 2), rect.top()) path.lineTo(rect.left() + rect.width(), rect.top() + rect.height() / 2) path.lineTo(rect.left() + rect.width() / 2, rect.top() + rect.height()) path.lineTo(rect.left(), rect.top() + rect.height() / 2) path.lineTo(rect.left() + (rect.width() / 2), rect.top()) painter.fillPath(path, brush) painter.drawPath(path) # Image as a node, this implementation checks to see if a # file path was provided in the shape parameter if (os.path.isfile(node.kwargs["shape"])): img_path = node.kwargs["shape"] painter.drawImage( QRect(gpos[0] - node.size[0] / 2, gpos[1] - node.size[1] / 2, node.size[0], node.size[1]), QImage(img_path)) else: painter.drawEllipse(gpos[0] - node.size[0] / 2, gpos[1] - node.size[1] / 2, node.size[0], node.size[1]) if ("label" in node.kwargs.keys()): painter.drawText(gpos[0] - node.size[0] / 2, gpos[1] - node.size[1] / 2, node.size[0], node.size[1], Qt.AlignCenter | Qt.AlignTop, node.kwargs["label"]) else: if (self.show_subgraphs): self.paintGraph(subgraph, painter) else: subgraph = node self.paintSubgraph(subgraph, painter, pen, brush)
def _draw_pixmap_overlay(self, painter, draw_width, draw_height, scrolled): painter.save() rect = QRect(0, 0, draw_width, draw_height) painter.translate(0, -scrolled) gradient = QLinearGradient(rect.topLeft(), rect.bottomLeft()) color = self.palette().color(QPalette.Base) if draw_height == self.height(): gradient.setColorAt(0, add_alpha(color, 180)) gradient.setColorAt(1, add_alpha(color, 230)) else: if self._app.theme_mgr.theme == Light: gradient.setColorAt(0, add_alpha(color, 220)) gradient.setColorAt(0.1, add_alpha(color, 180)) gradient.setColorAt(0.2, add_alpha(color, 140)) gradient.setColorAt(0.6, add_alpha(color, 140)) gradient.setColorAt(0.8, add_alpha(color, 200)) gradient.setColorAt(0.9, add_alpha(color, 240)) gradient.setColorAt(1, color) else: gradient.setColorAt(0, add_alpha(color, 50)) gradient.setColorAt(0.6, add_alpha(color, 100)) gradient.setColorAt(0.8, add_alpha(color, 200)) gradient.setColorAt(0.9, add_alpha(color, 240)) gradient.setColorAt(1, color) painter.setBrush(gradient) painter.drawRect(rect) painter.restore()
def paint(self, painter): # use antialiasing for both text and box painter.setRenderHint(QPainter.Antialiasing, True) painter.setRenderHint(QPainter.TextAntialiasing, True) # get the opacity of the node item, layers with the include.phase parameter have a different opacity opacity = Constants.itemOpacityInPhase if not self.__nodeItem.getNodeEditor().isCurrentPhase( self.__nodeItem.getPhase()): opacity = Constants.itemOpacityNotInPhase # draw a outer 'glow' around the node item if the node is selected if self.__nodeItem.isSelected(): selectedColor = Constants.selectedColor selectedColor.setAlpha(opacity) painter.setPen(QPen(selectedColor, Constants.nodeItemSelectionSize)) painter.drawRect(self.__rectAllSelected) painter.fillRect(self.__rectAllSelected, QBrush(selectedColor)) # get the type color for the header (name and type) typeColor = LayerColorDefinitions.getTypeColor( self.__nodeItem.getType()) typeColor.setRgb(typeColor.red(), typeColor.green(), typeColor.blue(), opacity) # get background color backgroundColor = Constants.itemBackgroundColorLight backgroundColor.setAlpha(opacity) # set a linear gradient for the header (type color -> background color) gradient = QLinearGradient(0, self.__rectHead.top(), 0, self.__rectHead.bottom()) gradient.setColorAt(0, typeColor) gradient.setColorAt(0.5, backgroundColor) # draw background and border for the header painter.fillRect(self.__rectHead, QBrush(gradient)) # draw background for the blob area painter.fillRect(self.__rectBlobArea, QBrush(backgroundColor)) borderColor = Constants.itemBorderColor if self.__nodeItem.getIsInPlace(): borderColor = Constants.itemInPlaceColor borderColor.setAlpha(opacity) painter.setPen(QPen(borderColor, Constants.nodeItemBorderSize)) # draw outer border around the node painter.drawRect(self.__rectAll) # draw a line to separate header and connectors borSize = Constants.nodeItemBorderSize painter.setPen(QPen(borderColor, borSize)) painter.drawLine(self.__rectHead.left() + borSize / 2, self.__rectHead.bottom() - borSize / 2, self.__rectHead.right() - borSize / 2, self.__rectHead.bottom() - borSize / 2) painter.setPen(QPen(QColor(0, 0, 0, opacity))) # draw text of header if len(self.__headRects) > 1: # align the first head text at the bottom to provide some space at the top painter.setFont(self.__headRects[0].font) painter.drawText(self.__headRects[0].rect, Qt.AlignHCenter | Qt.AlignBottom, self.__headRects[0].text) # align other head texts at the center for i in range(1, len(self.__headRects) - 1): painter.setFont(self.__headRects[i].font) painter.drawText(self.__headRects[i].rect, Qt.AlignCenter, self.__headRects[i].text) # align the last head text at the top to provide some space at the bottom painter.setFont(self.__headRects[-1].font) painter.drawText(self.__headRects[-1].rect, Qt.AlignHCenter | Qt.AlignTop, self.__headRects[-1].text) # there is only one head text, so align it at the center elif len(self.__headRects) == 1: painter.setFont(self.__headRects[0].font) painter.drawText(self.__headRects[0].rect, Qt.AlignHCenter | Qt.AlignCenter, self.__headRects[0].text) # draw blob names painter.setFont(Constants.nodeItemFontBlob) for item in self.__blobBottomNameRects: painter.drawText(item.rect, Qt.AlignVCenter | Qt.AlignLeft, item.text) for item in self.__blobTopNameRects: painter.drawText(item.rect, Qt.AlignVCenter | Qt.AlignRight, item.text)
def paint(self, painter, option, index): dlg = index.model().data(index, Qt.DisplayRole) painter.setRenderHint(QPainter.Antialiasing) color = QColor(Qt.white) if option.state & QStyle.State_MouseOver: color = QColor(variables.HIGHLIGHT_COLOR) painter.setPen(QPen(color)) painter.setBrush(QBrush(color)) painter.drawRect(option.rect) painter.setPen(Qt.black) painter.setBrush(Qt.NoBrush) painter.drawLine(option.rect.bottomLeft(), option.rect.bottomRight()) doc = QTextDocument(dlg.ip) doc.setDocumentMargin(0) doc.setDefaultFont(variables.font) textrect = QRect(option.rect) textrect = textrect.marginsRemoved(variables.IP_PADDING) textrect.setHeight(int(doc.size().height())) textrect.setWidth(int(doc.size().width())) offset = textrect.marginsAdded(variables.IP_PADDING).height() painter.setPen(Qt.black) painter.setFont(variables.font) painter.translate(textrect.x(), textrect.y()) textrectf = QRectF(textrect) textrectf.moveTo(0, 0) doc.drawContents(painter, textrectf) painter.translate(-textrect.x(), -textrect.y()) string = "" if dlg.user == variables.USER_ME: string += "You: " print(dlg.msg) string += dlg.msg fm = QFontMetrics(variables.font_small) textrect = QRect(option.rect) textrect.moveTop(textrect.y() + offset) textrect = textrect.marginsRemoved(variables.MSG_PADDING) textrect.setHeight(fm.lineSpacing()) spainter = QStylePainter(painter.device(), QWidget()) spainter.setRenderHint(QPainter.Antialiasing) if fm.horizontalAdvance(string) > textrect.width(): fade = QLinearGradient(variables.MSG_PADDING.left() + textrect.width()* 0.9, 0, variables.MSG_PADDING.left() + textrect.width(), 0) fade.setSpread(QGradient.PadSpread) fade.setColorAt(0, Qt.darkGray) fade.setColorAt(1, color) pal = QPalette() pal.setBrush(QPalette.Text, QBrush(fade)) spainter.setFont(variables.font_small) spainter.drawItemText(textrect, Qt.TextSingleLine, pal, True, string, QPalette.Text) else: spainter.setPen(Qt.darkGray) spainter.setFont(variables.font_small) spainter.drawText(textrect, Qt.TextSingleLine, string) p1 = textrect.bottomRight() + QPoint(36, -int(textrect.height() / 2)) if dlg.status == variables.STATUS_UNREAD: spainter.setPen(Qt.NoPen) spainter.setBrush(QColor(variables.STATUS_COLOR)) spainter.drawEllipse(p1, 7, 7) elif dlg.status == variables.STATUS_UNDELIVERED: pen = QPen(QColor(variables.STATUS_COLOR)) pen.setWidth(2) spainter.setPen(pen) spainter.setBrush(Qt.NoBrush) spainter.drawEllipse(p1, 7, 7) spainter.drawLine(p1, p1 + QPoint(0, -5)) spainter.drawLine(p1, p1 + QPoint(3, 0)) elif dlg.status == variables.STATUS_NEW: pen = QPen(QColor(variables.STATUS_NEW_COLOR)) pen.setWidth(5) spainter.setPen(pen) spainter.setBrush(Qt.NoBrush) spainter.drawEllipse(p1, 7, 7) #painter.translate(-textrect.x(), -textrect.y()) '''doc = QTextDocument(str)
def paintEvent(self, event: QPaintEvent): _start = perf_counter() num = self.num_tabs selected = self.selected arrow_width = self._arrow_width height = self.height() width = self._button_width first_width = self._first_button_width button = self._button_path button_box = QRect(0, 0, width + arrow_width, height) first_box = QRect(0, 0, first_width + arrow_width, height) icon_area = QRect(arrow_width + 10, 0, max(48, width / 2), height) text_box = QRect(arrow_width, 0, width - arrow_width, height) text_flags = Qt.AlignCenter | Qt.AlignVCenter states = self.states painter = QPainter(self) region = event.region() painter.setClipRegion(region) #torender = self._tabs_within(event.region()) #print("regions:") #for rect in event.region().rects(): # print(" - ", rect) #painter.setPen(Qt.NoPen) painter.setPen( QPen(Qt.black, 2, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin)) titleFont = painter.font() titleFont.setPointSizeF(14) titleFont.setBold(True) painter.setFont(titleFont) painter.translate(num * width + first_width, 0) if region.intersects(painter.transform().mapRect(button_box)): painter.setBrush(states[num].get_color(num == selected)) painter.drawPath(self._last_button_path) for i in reversed(range(num)): painter.translate(-width, 0) if not region.intersects(painter.transform().mapRect(button_box)): continue painter.setBrush(states[i].get_color(i == selected)) painter.drawPath(button) if states[i].state == State.ACTIVE: painter.save() painter.setPen(Qt.NoPen) gw = (width + self._arrow_width) * 2 gradient = QLinearGradient(0, 0, gw, 0) value = self._working_anim.value gradient.setColorAt(max(0.0, value - 0.2), QColor(255, 255, 255, 0)) gradient.setColorAt(value, QColor(255, 255, 255, 180)) gradient.setColorAt(min(1.0, value + 0.2), QColor(255, 255, 255, 0)) brush = QBrush(gradient) brush.setTransform(brush.transform().translate(-gw / 4, 0)) gradient_height = int(height * 0.2) painter.setBrush(brush) #painter.setClipRect(0, 0, width+self._arrow_width, gradient_height) #painter.drawPath(button) #painter.setClipRect(0, height-gradient_height, width+self._arrow_width, gradient_height) painter.drawPath(button) self._active_box = painter.transform().mapRect(button_box) painter.restore() #if states[i].icon: # states[i].icon.paint(painter, icon_area) text = states[i].text if text: _, _, short = text.rpartition('-') painter.drawText(text_box, text_flags, short.capitalize()) if region.intersects(first_box): painter.resetTransform() painter.setBrush(State.UNKNOWN.get_color(-1 == selected)) painter.drawPath(self._first_button_path) if self.is_running: icon = self.style().standardIcon(QStyle.SP_MediaStop) else: icon = self.style().standardIcon(QStyle.SP_MediaPlay) size = min(self._first_button_width, self.height()) * 0.8 painter.translate(5, (self.height() - size) / 2) icon.paint(painter, QRect(0, 0, size, size)) _end = perf_counter() if not self._paint_times: self._paint_times = times = [] else: times = self._paint_times times.append(_end - _start) if len(times) > 60: avg = sum(times) / len(times) * 1000000 print("Average render time %.2fns" % (avg, )) self._paint_times = None
def createImage(self, color, alpha=255): self._color = QColor(color) self._color.setAlpha(255) self._image = QImage(self.size(), QImage.Format_ARGB32) painter = QPainter() painter.begin(self._image) painter.setRenderHint(QPainter.Antialiasing, True) painter.setRenderHint(QPainter.SmoothPixmapTransform, True) # 背景色 painter.fillRect(self.rect(), color) # 白色渐变 gradient = QLinearGradient(0, 0, self.width(), 0) gradient.setColorAt(0, Qt.white) gradient.setColorAt(1, QColor.fromHslF(0.055, 0.42, 0.65, 0)) painter.fillRect(self.rect(), gradient) # 黑色渐变 gradient = QLinearGradient(0, self.height(), 0, 0) gradient.setColorAt(1, QColor.fromHslF(0.055, 0.42, 0.65, 0)) gradient.setColorAt(0, Qt.black) painter.fillRect(self.rect(), gradient) painter.end() self.update() if self._image and self._pointerPos: self.colorChanged.emit( self._image.pixelColor( max(min(self._pointerPos.x(), self.width() - 1), 0), max(min(self._pointerPos.y(), self.height() - 1), 0)))
def __init__(self, machine, parent=None): super(RenderArea, self).__init__(parent) self.pen = QPen() self.brush = QBrush() self.antialiased = True self.setBackgroundRole(QPalette.Base) self.setAutoFillBackground(True) self.machine = machine self.dist_radius = min(self.width() / 4, self.height() / 4) * 1.5 self.dist_center = QPoint(self.width() / 2.0, self.height() / 2.0) self.n_states = len(self.machine.getStates()) self.state_radius = self.funcc(self.dist_radius, self.n_states) self.active = -1 self.t_active = -1 self.pts = [] #Brushes linearGradient = QLinearGradient(-self.state_radius, -self.state_radius, self.state_radius, self.state_radius) linearGradient.setColorAt(0.0, Qt.darkGreen) linearGradient.setColorAt(0.7, Qt.green) linearGradient.setColorAt(0.3, Qt.green) linearGradient.setColorAt(1.0, Qt.white) self.greenGradientBrush = QBrush(linearGradient) linearGradient = QLinearGradient(-self.state_radius, -self.state_radius, self.state_radius, self.state_radius) linearGradient.setColorAt(0.0, Qt.darkGray) linearGradient.setColorAt(0.7, Qt.lightGray) linearGradient.setColorAt(0.3, Qt.gray) linearGradient.setColorAt(1.0, Qt.white) self.grayGradientBrush = QBrush(linearGradient) self.setBrush(self.grayGradientBrush)
def paintEvent(self, e): """ draw pixmap as a the background with a dark overlay HELP: currently, this cost much CPU """ if self._pixmap is None: return painter = QPainter(self) painter.setPen(Qt.NoPen) painter.setRenderHint(QPainter.Antialiasing) painter.setRenderHint(QPainter.SmoothPixmapTransform) # calculate available size draw_width = self.width() draw_height = self.bottom_panel.height() if self.table_container.meta_widget.isVisible(): draw_height += self.table_container.meta_widget.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.rect()) painter.restore() return # scale pixmap scaled_pixmap = self._pixmap.scaledToWidth( draw_width, mode=Qt.SmoothTransformation) pixmap_size = scaled_pixmap.size() # draw the center part of the pixmap on available rect painter.save() brush = QBrush(scaled_pixmap) painter.setBrush(brush) # note: in practice, most of the time, we can't show the # whole artist pixmap, as a result, the artist head will be cut, # which causes bad visual effect. So we render the top-center part # of the pixmap here. y = (pixmap_size.height() - draw_height) // 3 painter.translate(0, -y - scrolled) rect = QRect(0, y, draw_width, draw_height) painter.drawRect(rect) # draw overlay gradient = QLinearGradient(rect.topLeft(), rect.bottomLeft()) color = self.palette().color(QPalette.Base) if draw_height == self.height(): gradient.setColorAt(0, add_alpha(color, 180)) gradient.setColorAt(1, add_alpha(color, 230)) else: gradient.setColorAt(0, add_alpha(color, 50)) gradient.setColorAt(0.6, add_alpha(color, 100)) gradient.setColorAt(0.8, add_alpha(color, 200)) gradient.setColorAt(0.9, add_alpha(color, 240)) gradient.setColorAt(1, color) painter.setBrush(gradient) painter.drawRect(rect) painter.restore() painter.end()
def gradientPixmap(self, types, color): """生成渐变图片 """ pixSize = 5 if types == self.TypeAlpha: # 生成黑边相间的模拟透明背景 if not self._imageAlphaTmp: self._imageAlphaTmp = QImage(self.width(), self.height(), QImage.Format_ARGB32) painter = QPainter() painter.begin(self._imageAlphaTmp) painter.setRenderHint(QPainter.Antialiasing, True) painter.setRenderHint(QPainter.SmoothPixmapTransform, True) for x in range(int(self.width() / pixSize)): for y in range(int(self.height() / pixSize)): _x, _y = x * pixSize, y * pixSize painter.fillRect( _x, _y, pixSize, pixSize, Qt.white if x % 2 != y % 2 else Qt.darkGray) painter.end() # 绘制透明渐变 gradient = QLinearGradient(0, 0, self.width(), 0) gradient.setColorAt(0, QColor(0, 0, 0, 0)) gradient.setColorAt(1, color) # 只画渐变颜色 self._imageAlphaColor = QImage(self.width(), self.height(), QImage.Format_ARGB32) self._imageAlphaColor.fill(Qt.transparent) painter = QPainter() painter.begin(self._imageAlphaColor) painter.setRenderHint(QPainter.Antialiasing, True) painter.setRenderHint(QPainter.SmoothPixmapTransform, True) painter.fillRect(0, 0, self.width(), self.height(), gradient) painter.end() # 合并方格图 self._imageAlpha = self._imageAlphaColor.copy() painter = QPainter() painter.begin(self._imageAlpha) painter.setRenderHint(QPainter.Antialiasing, True) painter.setRenderHint(QPainter.SmoothPixmapTransform, True) painter.drawImage(0, 0, self._imageAlphaTmp) painter.fillRect(0, 0, self.width(), self.height(), gradient) painter.end() else: gradient = QLinearGradient(0, 0, self.width(), 0) gradient.setColorAt(0, QColor('#ff0000')) gradient.setColorAt(0.17, QColor('#ffff00')) gradient.setColorAt(0.33, QColor('#00ff00')) gradient.setColorAt(0.5, QColor('#00ffff')) gradient.setColorAt(0.67, QColor('#0000ff')) gradient.setColorAt(0.83, QColor('#ff00ff')) gradient.setColorAt(1, QColor('#ff0000')) self._imageRainbow = QImage(self.width(), self.height(), QImage.Format_ARGB32) painter = QPainter() painter.begin(self._imageRainbow) painter.setRenderHint(QPainter.Antialiasing, True) painter.setRenderHint(QPainter.SmoothPixmapTransform, True) painter.fillRect(0, 0, self.width(), self.height(), gradient) painter.end()
class SwitchPrivate(QObject): def __init__(self, q, parent=None): QObject.__init__(self, parent=parent) self.mPointer = q self.mPosition = 0.0 self.mGradient = QLinearGradient() self.mGradient.setSpread(QGradient.PadSpread) self.animation = QPropertyAnimation(self) self.animation.setTargetObject(self) self.animation.setPropertyName(b'position') self.animation.setStartValue(0.0) self.animation.setEndValue(1.0) self.animation.setDuration(200) self.animation.setEasingCurve(QEasingCurve.InOutExpo) self.animation.finished.connect(self.mPointer.update) @pyqtProperty(float) def position(self): return self.mPosition @position.setter def position(self, value): self.mPosition = value self.mPointer.update() def draw(self, painter): r = self.mPointer.rect() margin = r.height() / 10 shadow = self.mPointer.palette().color(QPalette.Dark) light = self.mPointer.palette().color(QPalette.Light) button = self.mPointer.palette().color(QPalette.Button) painter.setPen(Qt.NoPen) self.mGradient.setColorAt(0, shadow.darker(130)) self.mGradient.setColorAt(1, light.darker(130)) self.mGradient.setStart(0, r.height()) self.mGradient.setFinalStop(0, 0) painter.setBrush(self.mGradient) painter.drawRoundedRect(r, r.height() / 2, r.height() / 2) self.mGradient.setColorAt(0, shadow.darker(140)) self.mGradient.setColorAt(1, light.darker(160)) self.mGradient.setStart(0, 0) self.mGradient.setFinalStop(0, r.height()) painter.setBrush(self.mGradient) painter.drawRoundedRect(r.adjusted(margin, margin, -margin, -margin), r.height() / 2, r.height() / 2) self.mGradient.setColorAt(0, button.darker(130)) self.mGradient.setColorAt(1, button) painter.setBrush(self.mGradient) x = r.height() / 2.0 + self.mPosition * (r.width() - r.height()) ''' document = QTextDocument() rect2 = QRectF(0, 0, 250, 250) document.setTextWidth(rect2.width()) document.setHtml("<b align=right>OFF</b>") document.drawContents(painter, rect2) rect3 = QRectF(0, 0, 250, 250) document.setTextWidth(rect3.width()) document.setHtml("<p align=right>ON</p>") document.drawContents(painter, rect3)''' painter.drawEllipse(QPointF(x, r.height() / 2), r.height() / 2 - margin, r.height() / 2 - margin) @pyqtSlot(bool, name='animate') def animate(self, checked): self.animation.setDirection(QPropertyAnimation.Forward if checked else QPropertyAnimation.Backward) self.animation.start()