def rebuild(self, gridRect):
"""
Rebuilds the tracker item.
"""
scene = self.scene()
if (not scene):
return
self.setVisible(gridRect.contains(self.pos()))
self.setZValue(100)
path = QPainterPath()
path.moveTo(0, 0)
path.lineTo(0, gridRect.height())
tip = ''
tip_point = None
self._ellipses = []
items = scene.collidingItems(self)
self._basePath = QPainterPath(path)
for item in items:
item_path = item.path()
found = None
for y in range(int(gridRect.top()), int(gridRect.bottom())):
point = QPointF(self.pos().x(), y)
if (item_path.contains(point)):
found = QPointF(0, y - self.pos().y())
break
if (found):
path.addEllipse(found, 6, 6)
self._ellipses.append(found)
# update the value information
value = scene.valueAt(self.mapToScene(found))
tip_point = self.mapToScene(found)
hruler = scene.horizontalRuler()
vruler = scene.verticalRuler()
x_value = hruler.formatValue(value[0])
y_value = vruler.formatValue(value[1])
tip = '<b>x:</b> %s<br/><b>y:</b> %s' % (x_value, y_value)
self.setPath(path)
self.setVisible(True)
# show the popup widget
if (tip):
anchor = XPopupWidget.Anchor.RightCenter
widget = self.scene().chartWidget()
tip_point = widget.mapToGlobal(widget.mapFromScene(tip_point))
XPopupWidget.showToolTip(tip,
anchor=anchor,
parent=widget,
point=tip_point,
foreground=QColor('blue'),
background=QColor(148, 148, 255))
def rebuild( self, gridRect ):
"""
Rebuilds the tracker item.
"""
scene = self.scene()
if ( not scene ):
return
self.setVisible(gridRect.contains(self.pos()))
self.setZValue(100)
path = QPainterPath()
path.moveTo(0, 0)
path.lineTo(0, gridRect.height())
tip = ''
tip_point = None
self._ellipses = []
items = scene.collidingItems(self)
self._basePath = QPainterPath(path)
for item in items:
item_path = item.path()
found = None
for y in range(int(gridRect.top()), int(gridRect.bottom())):
point = QPointF(self.pos().x(), y)
if ( item_path.contains(point) ):
found = QPointF(0, y - self.pos().y())
break
if ( found ):
path.addEllipse(found, 6, 6)
self._ellipses.append(found)
# update the value information
value = scene.valueAt(self.mapToScene(found))
tip_point = self.mapToScene(found)
hruler = scene.horizontalRuler()
vruler = scene.verticalRuler()
x_value = hruler.formatValue(value[0])
y_value = vruler.formatValue(value[1])
tip = '<b>x:</b> %s<br/><b>y:</b> %s' % (x_value, y_value)
self.setPath(path)
self.setVisible(True)
# show the popup widget
if ( tip ):
anchor = XPopupWidget.Anchor.RightCenter
widget = self.scene().chartWidget()
tip_point = widget.mapToGlobal(widget.mapFromScene(tip_point))
XPopupWidget.showToolTip(tip,
anchor = anchor,
parent = widget,
point = tip_point,
foreground = QColor('blue'),
background = QColor(148, 148, 255))
def setShapeRect(self, rect):
"""
Set the item's shape `rect`. The item should be confined within
this rect.
"""
path = QPainterPath()
path.addEllipse(rect)
self.setPath(path)
self.__shapeRect = rect
def setShapeRect(self, rect):
"""
Set the item's shape `rect`. The item should be confined within
this rect.
"""
path = QPainterPath()
path.addEllipse(rect)
self.setPath(path)
self.__shapeRect = rect
def shape(self):
"""
Returns the shape of this item as a QPainterPath in local coordinates.
"""
path = QPainterPath()
path.addRect(self.rect())
if self.isSelected():
for shape in self.handles.values():
path.addEllipse(shape)
return path
def paintEvent(self, QPaintEvent):
p = QPainter(self.viewport())
clipPath = QPainterPath()
clipPath.addEllipse(0, 0, 100, 100)
p.setRenderHint(QPainter.Antialiasing)
p.setClipPath(clipPath)
p.setClipping(False)
p.setPen(Qt.gray)
p.drawPath(clipPath)
self.update()
def test_graphicspathobject(self):
obj = GraphicsPathObject()
path = QPainterPath()
obj.setFlag(GraphicsPathObject.ItemIsMovable)
path.addEllipse(20, 20, 50, 50)
obj.setPath(path)
self.assertEqual(obj.path(), path)
self.assertTrue(obj.path() is not path,
msg="setPath stores the path not a copy")
brect = obj.boundingRect()
self.assertTrue(area(brect) == 50 ** 2)
with self.assertRaises(TypeError):
obj.setPath("This is not a path")
brush = QBrush(QColor("#ffbb11"))
obj.setBrush(brush)
self.assertEqual(obj.brush(), brush)
self.assertTrue(obj.brush() is not brush,
"setBrush stores the brush not a copy")
pen = QPen(QColor("#FFFFFF"), 1.4)
obj.setPen(pen)
self.assertEqual(obj.pen(), pen)
self.assertTrue(obj.pen() is not pen,
"setPen stores the pen not a copy")
brect = obj.boundingRect()
self.assertGreaterEqual(area(brect), (50 + 1.4 * 2) ** 2)
self.assertIsInstance(obj.shape(), QPainterPath)
positions = []
obj.positionChanged[QPointF].connect(positions.append)
pos = QPointF(10, 10)
obj.setPos(pos)
self.assertEqual(positions, [pos])
self.scene.addItem(obj)
self.view.show()
self.app.exec_()
def test_layout(self):
file_desc, disc_desc, bayes_desc = self.widget_desc()
file_item = NodeItem()
file_item.setWidgetDescription(file_desc)
file_item.setPos(0, 150)
self.scene.add_node_item(file_item)
bayes_item = NodeItem()
bayes_item.setWidgetDescription(bayes_desc)
bayes_item.setPos(200, 0)
self.scene.add_node_item(bayes_item)
disc_item = NodeItem()
disc_item.setWidgetDescription(disc_desc)
disc_item.setPos(200, 300)
self.scene.add_node_item(disc_item)
link = LinkItem()
link.setSourceItem(file_item)
link.setSinkItem(disc_item)
self.scene.add_link_item(link)
link = LinkItem()
link.setSourceItem(file_item)
link.setSinkItem(bayes_item)
self.scene.add_link_item(link)
layout = AnchorLayout()
self.scene.addItem(layout)
self.scene.set_anchor_layout(layout)
layout.invalidateNode(file_item)
layout.activate()
p1, p2 = file_item.outputAnchorItem.anchorPositions()
self.assertGreater(p1, p2)
self.scene.node_item_position_changed.connect(layout.invalidateNode)
path = QPainterPath()
path.addEllipse(125, 0, 50, 300)
def advance():
t = time.clock()
bayes_item.setPos(path.pointAtPercent(t % 1.0))
disc_item.setPos(path.pointAtPercent((t + 0.5) % 1.0))
self.singleShot(20, advance)
advance()
self.app.exec_()
def test_graphicspathobject(self):
obj = GraphicsPathObject()
path = QPainterPath()
obj.setFlag(GraphicsPathObject.ItemIsMovable)
path.addEllipse(20, 20, 50, 50)
obj.setPath(path)
self.assertEqual(obj.path(), path)
self.assertTrue(obj.path() is not path,
msg="setPath stores the path not a copy")
brect = obj.boundingRect()
self.assertTrue(area(brect) == 50**2)
with self.assertRaises(TypeError):
obj.setPath("This is not a path")
brush = QBrush(QColor("#ffbb11"))
obj.setBrush(brush)
self.assertEqual(obj.brush(), brush)
self.assertTrue(obj.brush() is not brush,
"setBrush stores the brush not a copy")
pen = QPen(QColor("#FFFFFF"), 1.4)
obj.setPen(pen)
self.assertEqual(obj.pen(), pen)
self.assertTrue(obj.pen() is not pen,
"setPen stores the pen not a copy")
brect = obj.boundingRect()
self.assertGreaterEqual(area(brect), (50 + 1.4 * 2)**2)
self.assertIsInstance(obj.shape(), QPainterPath)
positions = []
obj.positionChanged[QPointF].connect(positions.append)
pos = QPointF(10, 10)
obj.setPos(pos)
self.assertEqual(positions, [pos])
self.scene.addItem(obj)
self.view.show()
self.app.exec_()
def test_layout(self):
file_desc, disc_desc, bayes_desc = self.widget_desc()
file_item = NodeItem()
file_item.setWidgetDescription(file_desc)
file_item.setPos(0, 150)
self.scene.add_node_item(file_item)
bayes_item = NodeItem()
bayes_item.setWidgetDescription(bayes_desc)
bayes_item.setPos(200, 0)
self.scene.add_node_item(bayes_item)
disc_item = NodeItem()
disc_item.setWidgetDescription(disc_desc)
disc_item.setPos(200, 300)
self.scene.add_node_item(disc_item)
link = LinkItem()
link.setSourceItem(file_item)
link.setSinkItem(disc_item)
self.scene.add_link_item(link)
link = LinkItem()
link.setSourceItem(file_item)
link.setSinkItem(bayes_item)
self.scene.add_link_item(link)
layout = AnchorLayout()
self.scene.addItem(layout)
self.scene.set_anchor_layout(layout)
layout.invalidateNode(file_item)
layout.activate()
p1, p2 = file_item.outputAnchorItem.anchorPositions()
self.assertTrue(p1 > p2)
self.scene.node_item_position_changed.connect(layout.invalidateNode)
path = QPainterPath()
path.addEllipse(125, 0, 50, 300)
def advance():
t = time.clock()
bayes_item.setPos(path.pointAtPercent(t % 1.0))
disc_item.setPos(path.pointAtPercent((t + 0.5) % 1.0))
self.singleShot(20, advance)
advance()
self.app.exec_()
def button_at(self, mouse_pos):
white_button = QPainterPath()
white_button.addEllipse(
QPointF(self.contentsRect().width() - 50,
self.contentsRect().height() - 50), 35, 35)
if white_button.contains(mouse_pos):
return True, "W"
black_button = QPainterPath()
black_button.addEllipse(QPointF(self.contentsRect().width() - 50, 50),
35, 35)
if black_button.contains(mouse_pos):
return True, "B"
return False, ""
def drawValue(self, p, baseRect, value, delta):
if value == self.m_min:
return
dataPath = QPainterPath()
dataPath.setFillRule(Qt.WindingFill)
if value == self.m_max:
dataPath.addEllipse(baseRect)
else:
arcLength = 360 / delta
dataPath.moveTo(baseRect.center())
dataPath.arcTo(baseRect, self.m_nullPosition, -arcLength)
dataPath.lineTo(baseRect.center())
p.setBrush(self.palette().highlight())
p.setPen(QPen(self.palette().shadow().color(), self.m_dataPenWidth))
p.drawPath(dataPath)
def ellipse_path(center, a, b, rotation=0):
if not isinstance(center, QPointF):
center = QPointF(*center)
brect = QRectF(-a, -b, 2 * a, 2 * b)
path = QPainterPath()
path.addEllipse(brect)
if rotation != 0:
transform = QTransform().rotate(rotation)
path = transform.map(path)
path.translate(center)
return path
def ellipse_path(center, a, b, rotation=0):
if not isinstance(center, QPointF):
center = QPointF(*center)
brect = QRectF(-a, -b, 2 * a, 2 * b)
path = QPainterPath()
path.addEllipse(brect)
if rotation != 0:
transform = QTransform().rotate(rotation)
path = transform.map(path)
path.translate(center)
return path
def __init__(self, parent=None, anchor=0, **kwargs):
GraphicsPathObject.__init__(self, parent, **kwargs)
self.setFlag(QGraphicsItem.ItemSendsGeometryChanges, False)
self.setAcceptedMouseButtons(Qt.LeftButton)
self.__constraint = 0
self.__constraintFunc = None
self.__anchor = 0
self.__initialPosition = None
self.setAnchor(anchor)
path = QPainterPath()
path.addEllipse(QRectF(-4, -4, 8, 8))
self.setPath(path)
self.setBrush(QBrush(Qt.lightGray, Qt.SolidPattern))
def updatePixmap(self, rect):
""" Update the pixmap for the current transition.
This method sets a radial clipping region on the output pixmap
and draws in the relevant portion of the ending pixamp.
"""
x = rect.x()
y = rect.y()
rx = rect.width()
ry = rect.height()
path = QPainterPath()
path.addEllipse(QPointF(x, y), float(rx), float(ry))
painter = QPainter(self.outPixmap())
painter.setClipPath(path)
painter.drawPixmap(QPoint(0, 0), self.endPixmap())
def _define_symbols():
"""
Add symbol ? to ScatterPlotItemSymbols,
reflect the triangle to point upwards
"""
symbols = pyqtgraph.graphicsItems.ScatterPlotItem.Symbols
path = QPainterPath()
path.addEllipse(QRectF(-0.35, -0.35, 0.7, 0.7))
path.moveTo(-0.5, 0.5)
path.lineTo(0.5, -0.5)
path.moveTo(-0.5, -0.5)
path.lineTo(0.5, 0.5)
symbols["?"] = path
tr = QTransform()
tr.rotate(180)
symbols['t'] = tr.map(symbols['t'])
def path_from_graphics(graphics):
"""
Return a constructed `QPainterPath` for a KEGG pathway graphics element.
"""
path = QPainterPath()
x, y, w, h = [int(graphics.get(c, 0)) for c in
["x", "y", "width", "height"]]
type = graphics.get("type", "rectangle")
if type == "rectangle":
path.addRect(QRectF(x - w / 2, y - h / 2, w, h))
elif type == "roundrectangle":
path.addRoundedRect(QRectF(x - w / 2, y - h / 2, w, h), 10, 10)
elif type == "circle":
path.addEllipse(QRectF(x - w / 2, y - h / 2, w, h))
else:
ValueError("Unknown graphics type %r." % type)
return path
def path_from_graphics(graphics):
"""
Return a constructed `QPainterPath` for a KEGG pathway graphics element.
"""
path = QPainterPath()
x, y, w, h = [int(graphics.get(c, 0)) for c in
["x", "y", "width", "height"]]
type = graphics.get("type", "rectangle")
if type == "rectangle":
path.addRect(QRectF(x - w / 2, y - h / 2, w, h))
elif type == "roundrectangle":
path.addRoundedRect(QRectF(x - w / 2, y - h / 2, w, h), 10, 10)
elif type == "circle":
path.addEllipse(QRectF(x - w / 2, y - h / 2, w, h))
else:
ValueError("Unknown graphics type %r." % type)
return path
def _define_symbols():
"""
Add symbol ? to ScatterPlotItemSymbols,
reflect the triangle to point upwards
"""
symbols = pyqtgraph.graphicsItems.ScatterPlotItem.Symbols
path = QPainterPath()
path.addEllipse(QRectF(-0.35, -0.35, 0.7, 0.7))
path.moveTo(-0.5, 0.5)
path.lineTo(0.5, -0.5)
path.moveTo(-0.5, -0.5)
path.lineTo(0.5, 0.5)
symbols["?"] = path
tr = QTransform()
tr.rotate(180)
symbols['t'] = tr.map(symbols['t'])
def test_anchoritem(self):
anchoritem = NodeAnchorItem(None)
self.scene.addItem(anchoritem)
path = QPainterPath()
path.addEllipse(0, 0, 100, 100)
anchoritem.setAnchorPath(path)
anchor = AnchorPoint()
anchoritem.addAnchor(anchor)
ellipse1 = QGraphicsEllipseItem(-3, -3, 6, 6)
ellipse2 = QGraphicsEllipseItem(-3, -3, 6, 6)
self.scene.addItem(ellipse1)
self.scene.addItem(ellipse2)
anchor.scenePositionChanged.connect(ellipse1.setPos)
with self.assertRaises(ValueError):
anchoritem.addAnchor(anchor)
anchor1 = AnchorPoint()
anchoritem.addAnchor(anchor1)
anchor1.scenePositionChanged.connect(ellipse2.setPos)
self.assertSequenceEqual(anchoritem.anchorPoints(), [anchor, anchor1])
self.assertSequenceEqual(anchoritem.anchorPositions(), [0.5, 0.5])
anchoritem.setAnchorPositions([0.5, 0.0])
self.assertSequenceEqual(anchoritem.anchorPositions(), [0.5, 0.0])
def advance():
t = anchoritem.anchorPositions()
t = map(lambda t: (t + 0.05) % 1.0, t)
anchoritem.setAnchorPositions(t)
self.singleShot(20, advance)
advance()
self.app.exec_()
def test_anchoritem(self):
anchoritem = NodeAnchorItem(None)
self.scene.addItem(anchoritem)
path = QPainterPath()
path.addEllipse(0, 0, 100, 100)
anchoritem.setAnchorPath(path)
anchor = AnchorPoint()
anchoritem.addAnchor(anchor)
ellipse1 = QGraphicsEllipseItem(-3, -3, 6, 6)
ellipse2 = QGraphicsEllipseItem(-3, -3, 6, 6)
self.scene.addItem(ellipse1)
self.scene.addItem(ellipse2)
anchor.scenePositionChanged.connect(ellipse1.setPos)
with self.assertRaises(ValueError):
anchoritem.addAnchor(anchor)
anchor1 = AnchorPoint()
anchoritem.addAnchor(anchor1)
anchor1.scenePositionChanged.connect(ellipse2.setPos)
self.assertSequenceEqual(anchoritem.anchorPoints(), [anchor, anchor1])
self.assertSequenceEqual(anchoritem.anchorPositions(), [0.5, 0.5])
anchoritem.setAnchorPositions([0.5, 0.0])
self.assertSequenceEqual(anchoritem.anchorPositions(), [0.5, 0.0])
def advance():
t = anchoritem.anchorPositions()
t = [(t + 0.05) % 1.0 for t in t]
anchoritem.setAnchorPositions(t)
self.singleShot(20, advance)
advance()
self.app.exec_()
def paint (self, painter, style, widget=None):
assert isinstance(painter, QPainter)
if self.isSelected():
brush = QBrush(Qt.green)
else:
brush = QBrush(Qt.white)
pen = QPen(Qt.black)
circle_path = QPainterPath()
circle_path.addEllipse(self.boundingRect())
painter.fillPath(circle_path, brush)
painter.strokePath(circle_path, pen)
text_path = QPainterPath()
text_path.addText(0, 0, QFont(), str(self.node))
box = text_path.boundingRect()
text_path.translate(-box.center())
painter.fillPath(text_path, QBrush(Qt.black))
def overlay_for(pt1, pt2, frequency):
# Construct the line-geometry, we'll use this to construct the ellipsoid
line = QLineF(pt1, pt2)
# Determine the radius for the ellipsoid
radius = fresnel_radius(line.length(), frequency)
# Draw the ellipsoid
zone = QPainterPath()
zone.addEllipse(QPointF(0., 0.), line.length() / 2, radius)
# Rotate the ellipsoid - same angle as the line
transform = QTransform()
transform.rotate(-line.angle())
zone = transform.map(zone)
# Center the zone over the line
lc = QRectF(pt1, pt2).center()
zc = zone.boundingRect().center()
zone.translate(lc.x() - zc.x(), lc.y() - zc.y())
return line, zone
def _updatePP(self):
"""Create the neck geometry updating this item's QPainterPath.
Return None.
"""
self.prepareGeometryChange()
pp = QPainterPath()
stringSpan = (self.nStrings - 1) * self.stringSpacing
nutWidth = stringSpan + self.stringEdgeOffset * 2
# frets
scaleLen = 25.5
offset = 0.0 # previous fret x coordinate
self.fretXs = [0.0]
for n in range(self.nFrets):
pos = offset + (scaleLen - offset) / 17.817
self.fretXs.append(pos)
pp.moveTo(pos, nutWidth)
pp.lineTo(pos, 0.0)
offset = pos
# marker dots
y = nutWidth / 2.0
for n in [3, 5, 7, 9, 12, 15, 17, 19, 21, 24]:
if n > self.nFrets:
break
fretX1 = self.fretXs[n-1]
fretX2 = self.fretXs[n]
x = fretX1 + (fretX2 - fretX1) / 2.0
d = self.markerDia
r = d / 2.0
dy = nutWidth / 4.0
if n % 12 == 0:
pp.addEllipse(x-r, y-r-dy, d, d)
pp.addEllipse(x-r, y-r+dy, d, d)
else:
pp.addEllipse(x-r, y-r, d, d)
# strings
self.stringYs = []
endX = self.fretXs[-1]
for n in range(self.nStrings):
y = self.stringEdgeOffset + self.stringSpacing * n
self.stringYs.append(y)
pp.moveTo(-self.nutThickness - self.fretXs[1] / 2.0, y)
pp.lineTo(endX, y)
# outline
pp.addRect(0, 0, self.fretXs[-1], nutWidth)
# nut
pp.addRect(-self.nutThickness, 0, self.nutThickness, nutWidth)
# partial headstock, to allow room for open note display
# upper curve
r = 2.0
d = self.fretXs[1] / 2.0
rectL = -self.nutThickness - r
rect = QRectF(rectL, -r*2.0, r*2.0, r*2.0)
ra = asin(d / r)
da = degrees(ra)
pp.arcMoveTo(rect, 270.0)
pp.arcTo(rect, 270.0, -da)
# lower curve
rect = QRectF(rectL, nutWidth, r*2.0, r*2.0)
pp.arcMoveTo(rect, 90.0)
pp.arcTo(rect, 90.0, da)
# x coordinate of open string note markers
self.openX = (-self.nutThickness - sin(ra) * r) / 2.0
self.setPath(pp)
def shape(self):
path = QPainterPath()
path.addEllipse(self.rect)
return path
def paintEvent(self, event):
event.accept()
painter = QPainter(self)
painter.save()
painter.setRenderHint(QPainter.Antialiasing, True)
if self.fLabel:
if self.fCustomPaint == self.CUSTOM_PAINT_NULL:
painter.setPen(self.fColor2)
painter.setBrush(self.fLabelGradient)
painter.drawRect(self.fLabelGradientRect)
painter.setFont(self.fLabelFont)
painter.setPen(self.fColorT[0 if self.isEnabled() else 1])
painter.drawText(self.fLabelPos, self.fLabel)
if self.isEnabled():
current = float(self.value() - self.minimum())
divider = float(self.maximum() - self.minimum())
if divider == 0.0:
return
value = current / divider
target = QRectF(0.0, 0.0, self.fSize, self.fSize)
per = int((self.fCount - 1) * value)
if self.fOrientation == self.HORIZONTAL:
xpos = self.fSize * per
ypos = 0.0
else:
xpos = 0.0
ypos = self.fSize * per
source = QRectF(xpos, ypos, self.fSize, self.fSize)
painter.drawPixmap(target, self.fPixmap, source)
# Custom knobs (Dry/Wet and Volume)
if self.fCustomPaint in (self.CUSTOM_PAINT_CARLA_WET, self.CUSTOM_PAINT_CARLA_VOL):
# knob color
colorGreen = QColor(0x5D, 0xE7, 0x3D, 191 + self.fHoverStep*7)
colorBlue = QColor(0x3E, 0xB8, 0xBE, 191 + self.fHoverStep*7)
# 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*value)
ballValue = tmpValue - floor(tmpValue)
ballPoint = ballPath.pointAtPercent(ballValue)
# draw arc
startAngle = 216*16
spanAngle = -252*16*value
if self.fCustomPaint == self.CUSTOM_PAINT_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.fCustomPaint in (self.CUSTOM_PAINT_CARLA_L, self.CUSTOM_PAINT_CARLA_R):
# knob color
color = QColor(0xAD + self.fHoverStep*5, 0xD5 + self.fHoverStep*4, 0x4B + self.fHoverStep*5)
# 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*value)
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.fCustomPaint == self.CUSTOM_PAINT_CARLA_L:
startAngle = 216*16
spanAngle = -252.0*16*value
elif self.fCustomPaint == self.CUSTOM_PAINT_CARLA_R:
startAngle = 324.0*16
spanAngle = 252.0*16*(1.0-value)
else:
return
painter.setPen(QPen(color, 2))
painter.drawArc(3.5, 4.5, 22.0, 22.0, startAngle, spanAngle)
if self.HOVER_MIN < self.fHoverStep < self.HOVER_MAX:
self.fHoverStep += 1 if self.fHovered else -1
QTimer.singleShot(20, self, SLOT("update()"))
else: # isEnabled()
target = QRectF(0.0, 0.0, self.fSize, self.fSize)
painter.drawPixmap(target, self.fPixmap, target)
painter.restore()
def shape(self):
shape = QPainterPath()
shape.addEllipse(self.sensitive_rect)
return shape
def paintEvent(self, event):
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing, True)
if self.m_label:
painter.setPen(self.m_color2)
painter.setBrush(self.m_label_gradient)
painter.drawRect(self.m_label_gradient_rect)
painter.setPen(self.m_colorT[0] if self.isEnabled() else self.m_colorT[1])
painter.drawText(self.m_label_pos, self.m_label)
if self.isEnabled():
current = float(self.value() - self.minimum())
divider = float(self.maximum() - self.minimum())
if divider == 0.0:
return
target = QRectF(0.0, 0.0, self.p_size, self.p_size)
value = (current / divider)
## Regular knobs
#else:
per = int((self.p_count - 1) * (current / divider))
if self.m_orientation == self.HORIZONTAL:
xpos = self.p_size * per
ypos = 0.0
else:
xpos = 0.0
ypos = self.p_size * per
source = QRectF(xpos, ypos, self.p_size, self.p_size)
painter.drawPixmap(target, self.m_pixmap, source)
# Custom knobs (Dry/Wet and Volume)
if self.m_custom_paint in (self.CUSTOM_PAINT_CARLA_WET, self.CUSTOM_PAINT_CARLA_VOL):
# knob color
colorGreen = QColor(0x5D, 0xE7, 0x3D, 191 + self.m_hover_step*7)
colorBlue = QColor(0x3E, 0xB8, 0xBE, 191 + self.m_hover_step*7)
#colorGreen = QColor(0x5D + self.m_hover_step*6, 0xE7 + self.m_hover_step*1, 0x3D + self.m_hover_step*5)
#colorBlue = QColor(0x52 + self.m_hover_step*8, 0xEE + self.m_hover_step*1, 0xF8 + self.m_hover_step/2)
# draw small circle
ballPath = QPainterPath()
ballRect = QRectF(8.0, 8.0, 15.0, 15.0)
ballPath.addEllipse(ballRect)
#painter.drawRect(ballRect)
ballValue = (0.375 + 0.75*value) % 1.0
ballPoint = ballPath.pointAtPercent(ballValue)
# draw arc
startAngle = 216*16
spanAngle = -252.0*16*value
if self.m_custom_paint == self.CUSTOM_PAINT_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.m_custom_paint in (self.CUSTOM_PAINT_CARLA_L, self.CUSTOM_PAINT_CARLA_R):
# knob color
color = QColor(0xAD + self.m_hover_step*5, 0xD5 + self.m_hover_step*4, 0x4B + self.m_hover_step*5)
# draw small circle
ballPath = QPainterPath()
ballRect = QRectF(7.0, 8.0, 11.0, 12.0)
ballPath.addEllipse(ballRect)
#painter.drawRect(ballRect)
ballValue = (0.375 + 0.75*value) % 1.0
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.m_custom_paint == self.CUSTOM_PAINT_CARLA_L:
startAngle = 216*16
spanAngle = -252.0*16*value
elif self.m_custom_paint == self.CUSTOM_PAINT_CARLA_R:
startAngle = 324.0*16
spanAngle = 252.0*16*(1.0-value)
else:
return
painter.setPen(QPen(color, 2))
painter.drawArc(3.5, 4.5, 22.0, 22.0, startAngle, spanAngle)
if self.HOVER_MIN < self.m_hover_step < self.HOVER_MAX:
self.m_hover_step += 1 if self.m_hovered else -1
QTimer.singleShot(20, self, SLOT("update()"))
elif not self.m_custom_paint:
target = QRectF(0.0, 0.0, self.p_size, self.p_size)
source = target
painter.drawPixmap(target, self.m_pixmap, source)
def shape(self):
shape = QPainterPath()
shape.addEllipse(self.sensitive_rect)
return shape
def shape(self):
path = QPainterPath()
path.addEllipse(self.rect)
return path
def shape(self):
path = QPainterPath()
path.addEllipse(TdPCavallo.Rect)
return path
def shape(self):
path = QPainterPath()
path.addEllipse(TdPCavallo.Rect)
return path
def getSymbolFromCmnd(self, symbol):
'''
Returns a SymbolPath of the specified symbol.
Recognized symbols are:
'.' (period): filled circle
'o' (lowercase oh): unfilled circle
'+': plus mark
'x' (lowercase ex): x mark
'*': asterisk
'^': triangle
"#": square
The path is drawn for a 100 x 100 unit square where
the origin is in the center of the square.
'''
# check if this symbol has already been created
try:
sympath = self.__symbolpaths[symbol]
return sympath
except KeyError:
pass
# new symbol - create a SymbolPath for it
if symbol == '.':
path = QPainterPath()
path.addEllipse(-10.0, -10.0, 20.0, 20.0)
sympath = SymbolPath(path, True)
elif symbol == 'o':
path = QPainterPath()
path.addEllipse(-40.0, -40.0, 80.0, 80.0)
sympath = SymbolPath(path, False)
elif symbol == 'x':
path = QPainterPath(QPointF(-30.0, -30.0))
path.lineTo(30.0, 30.0)
path.moveTo(-30.0, 30.0)
path.lineTo(30.0, -30.0)
sympath = SymbolPath(path, False)
elif symbol == '+':
path = QPainterPath(QPointF(0.0, -40.0))
path.lineTo(0.0, 40.0)
path.moveTo(-40.0, 0.0)
path.lineTo(40.0, 0.0)
sympath = SymbolPath(path, False)
elif symbol == '*':
path = QPainterPath(QPointF(0.0, -40.0))
path.lineTo(0.0, 40.0)
path.moveTo(-34.641, -20.0)
path.lineTo(34.641, 20.0)
path.moveTo(-34.641, 20.0)
path.lineTo(34.641, -20.0)
sympath = SymbolPath(path, False)
elif symbol == '^':
path = QPainterPath(QPointF(-40.0, 30.0))
path.lineTo(0.0, -39.282)
path.lineTo(40.0, 30.0)
path.closeSubpath()
sympath = SymbolPath(path, False)
elif symbol == '#':
path = QPainterPath()
path.addRect(-35.0, -35.0, 70.0, 70.0)
sympath = SymbolPath(path, False)
else:
raise ValueError("Unrecognized symbol '%s'" % str(symbol))
# save and return the SymbolPath
self.__symbolpaths[symbol] = sympath
return sympath
def piece_circle_path(self, tile):
path = QPainterPath()
path.moveTo(tile.pos)
path.addEllipse(tile.pos, 0.75 * self.r_hex, 0.75 * self.r_hex)
path.closeSubpath()
return path
def fillEllipse(self, painter, x, y, size, brush):
path = QPainterPath()
path.addEllipse(x, y, size, size)
painter.fillPath(path, brush)
