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()
