Ejemplo n.º 1
0
 def __get_bezier_middle(self, bezier: QPainterPath) -> QPointF:
     """
     Get the point in the middle of a bezier curve.
     """
     percent_middle = bezier.percentAtLength(
         bezier.length() / 2)
     return bezier.pointAtPercent(percent_middle)
Ejemplo n.º 2
0
class Window(QDialog):
    def __init__(self):
        super().__init__()
        self.dialog = uic.loadUi("demoAnimation2.ui",
                                 self)  # načtení formuláře
        self.show()
        self.path = QPainterPath()
        self.path.moveTo(30, 30)
        self.path.cubicTo(30, 30, 80, 180, 180, 170)
        self.labelPic.pos = QPointF(20, 20)

    def paintEvent(self, e):
        qp = QPainter()
        qp.begin(self)
        qp.drawPath(self.path)
        qp.end()

    def startAnimation(self):
        self.anim = QPropertyAnimation(
            self.labelPic,
            b"pos")  # vytvoření objektu třídy QPropertyAnimation
        self.anim.setDuration(4000)  # prodlevy při animaci
        self.anim.setStartValue(QPointF(20, 20))
        positionValues = [n / 80 for n in range(0, 50)]

        for i in positionValues:
            self.anim.setKeyValueAt(i, self.path.pointAtPercent(i))
            self.anim.setEndValue(QPointF(160, 150))
            self.anim.start()
Ejemplo n.º 3
0
class MyForm(QDialog):
    def __init__(self):
        super().__init__()
        self.ui=Ui_Dialog()
        self.ui.setupUi(self)
        self.ui.pushButtonMoveCurve.clicked.connect(self.startAnimation)
        self.path = QPainterPath()
        self.path.moveTo(30, 30)
        self.path.cubicTo(30, 30, 80, 180, 180, 170)
        self.ui.labelpic.pos=QPointF(20,20)

    def paintEvent(self, e):
        qp = QPainter()
        qp.begin(self)
        qp.drawPath(self.path)
        qp.end()

    def startAnimation(self):
        self.anim = QPropertyAnimation(self.ui.labelpic, b'geometry')
        self.anim.setDuration(10000)
        self.anim.setStartValue(QPointF(20, 20))
        positionValues = [n / 80 for n in range(0, 50)]
        for i in positionValues:
            self.anim.setKeyValueAt(i, self.path.pointAtPercent(i))
            self.anim.setEndValue(QPointF(160, 150))
            self.anim.start()
Ejemplo n.º 4
0
class RoundAnimation(QPropertyAnimation):

    def __init__(self, target, prop, parent=None):
        super(RoundAnimation, self).__init__(target, prop, parent)

    def updateCurrentTime(self, currentTime):
        self.path = QPainterPath()
        if self.path.isEmpty():
            end = self.endValue()
            start = self.startValue()
            self.path.addEllipse(QRectF(start, end))

        duration = self.duration()

        if duration == 0:
            progress = 1.0
        else:
            progress = (((currentTime - 1) % duration) + 1) / float(duration)

        easedProgress = self.easingCurve().valueForProgress(progress)

        if easedProgress > 1.0:
            easedProgress -= 1.0
        elif easedProgress < 0:
            easedProgress += 1.0

        pt = self.path.pointAtPercent(easedProgress)
        self.updateCurrentValue(pt)
Ejemplo n.º 5
0
 def set_shape(self, width, height):
     ''' Define the symbol shape '''
     circ = min(width, height)
     path = QPainterPath()
     path.addEllipse(0, 0, circ, circ)
     point1 = path.pointAtPercent(0.625)
     point2 = path.pointAtPercent(0.125)
     point3 = path.pointAtPercent(0.875)
     point4 = path.pointAtPercent(0.375)
     path.moveTo(point1)
     path.lineTo(point2)
     path.moveTo(point3)
     path.lineTo(point4)
     self.setPath(path)
     # call Join superclass, otherwise symbol will take Join shape
     super(Join, self).set_shape(circ, circ)
Ejemplo n.º 6
0
    def updatePath(self):
        end_hook = self.endSocket()

        if end_hook is None:
            return

        self.prepareGeometryChange()
        end_pos = self.mapFromItem(end_hook, 0.0,
                                   0.0) + end_hook.boundingRect().center()

        if self._curve:
            if not self._keyPoints:
                tangent_length = (abs(end_pos.x()) / 2.0) + (abs(end_pos.y()) /
                                                             4.0)
                tangent_length2 = tangent_length

            else:
                first_pos = self._keyPoints[0]
                tangent_length = (abs(first_pos.x()) /
                                  2.0) + (abs(first_pos.y()) / 4.0)
                last_pos = self._keyPoints[-1]
                last_segment = end_pos - last_pos
                tangent_length2 = (abs(last_segment.x()) /
                                   2.0) + (abs(last_segment.y()) / 4.0)

            spread = 60.0 / 180.0 * pi

            # Find connection index
            index, number_connections = self.startSocket().getIndexInfo(self)

            dev = (index - number_connections / 2.0 + 0.5) * min(
                spread, pi / (number_connections + 2))
            tx = tangent_length * cos(dev)
            ty = tangent_length * sin(dev)

            start_tangent = QPointF(tx, ty)
            end_tangent = QPointF(end_pos.x() - tangent_length2, end_pos.y())

            path = QPainterPath()
            path.cubicTo(start_tangent, end_tangent, end_pos)

        # Dot styles are used for relationships
        else:
            path = QPainterPath()
            path.lineTo(end_pos)

        stroke_width = self._pen.widthF()
        rect = path.boundingRect().adjusted(-stroke_width, -stroke_width,
                                            stroke_width, stroke_width)

        # draw widget
        center_widget = self._centerWidget

        if center_widget is not None:
            center = path.pointAtPercent(0.5)
            center_widget.onUpdated(center, text=str(self.index))

        self._path = path
        self._rect = rect
Ejemplo n.º 7
0
class MyDialog(QDialog):
    def __init__(self):
        super().__init__()
        self.ui = Ui_Dialog()
        self.ui.setupUi(self)
        self.pixmap = QPixmap()
        self.pixmap.load('game_map.png')
        self.item = QGraphicsPixmapItem(self.pixmap)
        self.scene = QGraphicsScene()
        self.scene.addItem(self.item)
        self.ui.graphicsView.setScene(self.scene)
        self.ui.pushButton.clicked.connect(self.startanimation)
        self.path = QPainterPath()
        self.path.moveTo(30,30)
        self.path.cubicTo(30,30,80,180,180,170)
        self.ui.label.pos = QPointF(20,20)
        self.pos1 = [0,0]
        self.pos2 = [0,0]

    def mousePressEvent(self, event):
        if event.buttons() & QtCore.Qt.LeftButton:
            self.pos1[0] = event.x()
            self.pos1[1] = event.y()

    def mouseReleaseEvent(self, event):
        self.pos2[0] = event.x()
        self.pos2[1] = event.y()
        self.update()

    def paintEvent(self, event):
        width = self.pos2[0] - self.pos1[0]
        height = self.pos2[1] - self.pos1[1]
        rect = QRect(self.pos1[0],self.pos1[1],width,height)
        qp = QPainter()
        qp.begin(self)
        pen = QPen(Qt.red,3)
        pen.setStyle(Qt.DotLine)
        qp.setPen(pen)
        qp.drawArc(rect,0,360*16)
        qp.end()



    # def paintEvent(self,e):
    #     qp = QPainter()
    #     qp.begin(self)
    #     qp.drawPath(self.path)
    #     qp.end()

    def startanimation(self):
        self.anim = QPropertyAnimation(self.ui.label, b'pos')
        self.anim.setDuration(4000)
        self.anim.setStartValue(QPointF(20,20))
        pos = [n/80 for n in range(0,50)]
        for i in pos:
            self.anim.setKeyValueAt(i,self.path.pointAtPercent(i))
            self.anim.setEndValue(QPointF(160,150))
        self.anim.start()
Ejemplo n.º 8
0
class Animation(QPropertyAnimation):
    '''
    动画类
    '''
    def __init__(self, target, prop):
        '''
        target, prop这个两个参数分别对应:动画的产生对象和setter
        '''
        super(Animation, self).__init__(target, prop)

    def updateCurrentTime(self, currentTime):
        '''
        currentTime(此属性保存动画的当前时间和进度)总是在变化的。
        每次动画的currentTime更改时,都会调用updateCurrentTime()函数
        '''
        self.m_path = QPainterPath()
        if self.m_path.isEmpty():
            end = self.endValue()
            start = self.startValue()
            # endValue()、startValue()分别表示动画的结束值和起始值
            self.m_path.addEllipse(QRectF(start, end))
            # 在指定的boundingRectangle内创建一个椭圆,这里是QRectF(start, end),并将其作为封闭的子路径添加到painter路径中。

        dura = self.duration()
        progress = (((currentTime - 1) % dura) + 1) / float(dura)
        # duration()此属性保存动画的持续时间(以毫秒为单位)。 默认持续时间为250毫秒。progress则描绘了当前的完成比率。

        easedProgress = self.easingCurve().valueForProgress(progress)
        if easedProgress > 1.0:
            easedProgress -= 1.0
        elif easedProgress < 0:
            easedProgress += 1.0
        # 返回进度缓和曲线的有效进度。 进度必须介于0和1之间,而返回的有效进度可能超出这些范围。大于1就减1,小于0就加1。

        pt = self.m_path.pointAtPercent(easedProgress)
        # 返回当前路径的百分比easedProgress处的点。
        # 参数easedProgress必须介于0和1之间。当存在曲线时,百分比参数被映射到贝塞尔方程的t参数。

        self.updateCurrentValue(pt)
        # 每次动画的当前值更改时,都会调用updateCurrentValue()。pt参数是新的当前值。没有这个函数动画动不了。

        self.valueChanged.emit(pt)

    def startAnimation(self, startx, starty, endx, endy, duration):
        '''
        setStartValue()、setEndValue()分别表示设置动画的起止位置,setDuration()设置动画的运行时间。
        '''
        self.setStartValue(QPointF(startx, starty))
        self.setEndValue(QPointF(endx, endy))
        self.setDuration(duration)
        self.setLoopCount(-1)
        # 值为-1时,动画将永远循环直至停止

        self.start()
Ejemplo n.º 9
0
class _MoveAnimation(QPropertyAnimation):
    '''move animation'''

    MOVE1 = 1
    MOVE2 = 2
    MOVE3 = 3

    def __init__(self, target, parent, easing = QEasingCurve.Custom):
        super(_MoveAnimation, self).__init__(target, b"pos")
        self.parent = parent
        self.easing = easing
        if easing != -1:
            self.setEasingCurve(easing)
        self.m_path = QPainterPath()

    def setMoveType(self, _type):
        self._type = _type

    def updateCurrentTime(self, currentTime):
        if self.m_path.isEmpty():
            # end = self.endValue()
            start = self.startValue()
            if self._type == self.MOVE1:
                end = QPoint(self.parent.width() / 4.0, 0)
            elif self._type == self.MOVE2:
                end = QPoint((self.parent.width() / 4.0) * 3.0, 0)
                if not start:
                    start = QPoint(self.parent.width() / 4.0, 0)
                    # 第二个移动没有设置开始坐标,这里以第一个移动结束为开始
            elif self._type == self.MOVE3:
                if not start:
                    start = QPoint((self.parent.width() / 4.0) * 3.0, 0)
                    # 第三个移动没有设置开始坐标,这里以第二个移动结束为开始
                end = QPoint(self.parent.width(), 0)
            self.m_path.moveTo(start)
            self.m_path.addEllipse(QRectF(start, end))

        dura = self.duration()
        if dura == 0:
            progress = 1.0
        else:
            progress = (((currentTime - 1) % dura) + 1) / float(dura)

        easedProgress = self.easingCurve().valueForProgress(progress)
        if easedProgress > 1.0:
            easedProgress -= 1.0
        elif easedProgress < 0:
            easedProgress += 1.0

        pt = self.m_path.pointAtPercent(easedProgress)
        self.updateCurrentValue(pt)
        self.valueChanged.emit(pt)
        super(_MoveAnimation, self).updateCurrentTime(currentTime)
Ejemplo n.º 10
0
class _MoveAnimation(QPropertyAnimation):
    '''move animation'''

    MOVE1 = 1
    MOVE2 = 2
    MOVE3 = 3

    def __init__(self, target, parent, easing=QEasingCurve.Custom):
        super(_MoveAnimation, self).__init__(target, b"pos")
        self.parent = parent
        self.easing = easing
        if easing != -1:
            self.setEasingCurve(easing)
        self.m_path = QPainterPath()

    def setMoveType(self, _type):
        self._type = _type

    def updateCurrentTime(self, currentTime):
        if self.m_path.isEmpty():
            # end = self.endValue()
            start = self.startValue()
            if self._type == self.MOVE1:
                end = QPoint(self.parent.width() / 4.0, 0)
            elif self._type == self.MOVE2:
                end = QPoint((self.parent.width() / 4.0) * 3.0, 0)
                if not start:
                    start = QPoint(self.parent.width() / 4.0, 0)
                    # 第二个移动没有设置开始坐标,这里以第一个移动结束为开始
            elif self._type == self.MOVE3:
                if not start:
                    start = QPoint((self.parent.width() / 4.0) * 3.0, 0)
                    # 第三个移动没有设置开始坐标,这里以第二个移动结束为开始
                end = QPoint(self.parent.width(), 0)
            self.m_path.moveTo(start)
            self.m_path.addEllipse(QRectF(start, end))

        dura = self.duration()
        if dura == 0:
            progress = 1.0
        else:
            progress = (((currentTime - 1) % dura) + 1) / float(dura)

        easedProgress = self.easingCurve().valueForProgress(progress)
        if easedProgress > 1.0:
            easedProgress -= 1.0
        elif easedProgress < 0:
            easedProgress += 1.0

        pt = self.m_path.pointAtPercent(easedProgress)
        self.updateCurrentValue(pt)
        self.valueChanged.emit(pt)
        super(_MoveAnimation, self).updateCurrentTime(currentTime)
Ejemplo n.º 11
0
 def reshape(self):
     ''' Update the connection or arrow shape '''
     shape = QPainterPath()
     shape.moveTo(self.start_point)
     for point in self.middle_points:
         shape.lineTo(point)
     shape.lineTo(self.end_point)
     # If required draw an arrow head (e.g. in SDL NEXTSTATE and JOIN)
     if self.child.arrow_head:
         self.draw_arrow_head(shape, origin='head',
                              kind=self.child.arrow_head)
     if self.child.arrow_tail:
         shape.moveTo(shape.pointAtPercent(0))
         self.draw_arrow_head(shape, origin='tail',
                              kind=self.child.arrow_head)
     self.setPath(shape)
Ejemplo n.º 12
0
class Example(QWidget):
    
    def __init__(self):
        super().__init__()

        self.initView()
        self.initAnimation()
        
        
    def initView(self):    
        
        self.path = QPainterPath()
        self.path.moveTo(30, 30)
        self.path.cubicTo(30, 30, 200, 350, 350, 30)        
        
        self.ball = Ball(self)

        self.ball.pos = QPointF(30, 30)
        
        self.setWindowTitle("Animation along curve")
        self.setGeometry(300, 300, 400, 300)
        self.show()
        
        
    def paintEvent(self, e):    
        
        qp = QPainter()
        qp.begin(self)
        qp.setRenderHint(QPainter.Antialiasing)   
        qp.drawPath(self.path)
        qp.end()             

        
    def initAnimation(self):
        
        self.anim = QPropertyAnimation(self.ball, b'pos')
        self.anim.setDuration(7000)
        
        self.anim.setStartValue(QPointF(30, 30))
        
        vals = [p/100 for p in range(0, 101)]

        for i in vals:
            self.anim.setKeyValueAt(i, self.path.pointAtPercent(i))  
                
        self.anim.setEndValue(QPointF(350, 30))        
        self.anim.start()
Ejemplo n.º 13
0
class _MpcbAnimation(QPropertyAnimation):

    def __init__(self, parent, target, index, easing = QEasingCurve.InQuad):
        super(_MpcbAnimation, self).__init__(target, b"pos")
        self.parent = parent
        self.m_pathType = 1
        self.easing = easing
        self.createAnimation(target, index)

    def createAnimation(self, target, index):
        '''创建动画'''
        self.m_path = QPainterPath()
        if self.easing != -1:
            self.setEasingCurve(self.easing)
        self.setStartValue(QPointF(0, 0))
        self.setEndValue(QPointF(90, 90))
        self.setDuration(2000)
        self.setLoopCount(-1)

    def updateCurrentTime(self, currentTime):
        if self.m_pathType:
            if self.m_path.isEmpty():
                end = self.endValue()
                start = self.startValue()
                self.m_path.moveTo(start)
                self.m_path.addEllipse(QRectF(start, end))

            dura = self.duration()
            if dura == 0:
                progress = 1.0
            else:
                progress = (((currentTime - 1) % dura) + 1) / float(dura)

            easedProgress = self.easingCurve().valueForProgress(progress)
            if easedProgress > 1.0:
                easedProgress -= 1.0
            elif easedProgress < 0:
                easedProgress += 1.0

            pt = self.m_path.pointAtPercent(easedProgress)
            self.updateCurrentValue(pt)
            self.valueChanged.emit(pt)
        else:
            super(_MpcbAnimation, self).updateCurrentTime(currentTime)
Ejemplo n.º 14
0
    def _draw(self, painter: QPainter, width: int, height: int):
        self.x = self.flower_center_x(width) * smoothen_curve(
            self.get_age_coefficient())
        self.y = self.flower_center_y(height) * smoothen_curve(
            self.get_age_coefficient())

        painter.setPen(
            QPen(Color.green,
                 self.stem_width * smoothen_curve(self.get_age_coefficient())))

        # draw the stem
        path = QPainterPath()
        path.quadTo(0, self.y * 0.6, self.x, self.y)
        painter.drawPath(path)

        # draw the leaves
        for position, coefficient, rotation in self.leafs:
            painter.save()

            # find the point on the stem and rotate the leaf accordingly
            painter.translate(path.pointAtPercent(position))
            painter.rotate(degrees(rotation))

            # rotate according to where the flower is leaning towards
            if self.y != 0:
                painter.rotate(-degrees(sin(self.x / self.y)))

            # make it so both leaves are facing the same direction
            if rotation < 0:
                painter.scale(-1, 1)

            painter.setBrush(QBrush(Color.green))
            painter.setPen(QPen(0))

            # draw the leaf
            leaf = QPainterPath()
            leaf.setFillRule(Qt.WindingFill)
            ls = self.leaf_size(width) * smoothen_curve(
                self.get_age_coefficient())**2 * coefficient
            leaf.quadTo(0.4 * ls, 0.5 * ls, 0, ls)
            leaf.cubicTo(0, 0.5 * ls, -0.4 * ls, 0.4 * ls, 0, 0)
            painter.drawPath(leaf)

            painter.restore()
Ejemplo n.º 15
0
class _MpcbAnimation(QPropertyAnimation):
    def __init__(self, parent, target, index, easing=QEasingCurve.InQuad):
        super(_MpcbAnimation, self).__init__(target, b"pos")
        self.parent = parent
        self.m_pathType = 1
        self.easing = easing
        self.createAnimation(target, index)

    def createAnimation(self, target, index):
        '''创建动画'''
        self.m_path = QPainterPath()
        if self.easing != -1:
            self.setEasingCurve(self.easing)
        self.setStartValue(QPointF(0, 0))
        self.setEndValue(QPointF(90, 90))
        self.setDuration(2000)
        self.setLoopCount(-1)

    def updateCurrentTime(self, currentTime):
        if self.m_pathType:
            if self.m_path.isEmpty():
                end = self.endValue()
                start = self.startValue()
                self.m_path.moveTo(start)
                self.m_path.addEllipse(QRectF(start, end))

            dura = self.duration()
            if dura == 0:
                progress = 1.0
            else:
                progress = (((currentTime - 1) % dura) + 1) / float(dura)

            easedProgress = self.easingCurve().valueForProgress(progress)
            if easedProgress > 1.0:
                easedProgress -= 1.0
            elif easedProgress < 0:
                easedProgress += 1.0

            pt = self.m_path.pointAtPercent(easedProgress)
            self.updateCurrentValue(pt)
            self.valueChanged.emit(pt)
        else:
            super(_MpcbAnimation, self).updateCurrentTime(currentTime)
 def goOn(self):
     self.anim = QPropertyAnimation(self.mascot, b"pos")
     self.mascotFlip.hide()
     self.mascotGif.start()
     self.mascot.show()
     path = QPainterPath()
     path.moveTo(-70, 410)
     for i in range(self.step):
         path.quadTo(
             QPointF(
                 self.xRange / self.step * i - 70 +
                 (self.xRange / self.step / 2), 410),
             QPointF((self.xRange / self.step) * i - 70 +
                     (self.xRange / self.step), 430))
     vals = [p / 100 for p in range(0, 101)]
     self.anim.setDuration(self.duration)
     for i in vals:
         self.anim.setKeyValueAt(i, path.pointAtPercent(i))
     self.anim.start()
     self.anim.finished.connect(self.goFlip)
Ejemplo n.º 17
0
class Animation(QPropertyAnimation):
    LinearPath, CirclePath = range(2)

    def __init__(self, target, prop):
        super(Animation, self).__init__(target, prop)

        self.setPathType(Animation.LinearPath)

    def setPathType(self, pathType):
        self.m_pathType = pathType
        self.m_path = QPainterPath()

    def updateCurrentTime(self, currentTime):
        if self.m_pathType == Animation.CirclePath:
            if self.m_path.isEmpty():
                end = self.endValue()
                start = self.startValue()
                self.m_path.moveTo(start)
                self.m_path.addEllipse(QRectF(start, end))

            dura = self.duration()
            if dura == 0:
                progress = 1.0
            else:
                progress = (((currentTime - 1) % dura) + 1) / float(dura)

            easedProgress = self.easingCurve().valueForProgress(progress)
            if easedProgress > 1.0:
                easedProgress -= 1.0
            elif easedProgress < 0:
                easedProgress += 1.0

            pt = self.m_path.pointAtPercent(easedProgress)
            self.updateCurrentValue(pt)
            self.valueChanged.emit(pt)
        else:
            super(Animation, self).updateCurrentTime(currentTime)
Ejemplo n.º 18
0
class Animation(QPropertyAnimation):
    LinearPath, CirclePath = range(2)

    def __init__(self, target, prop):
        super(Animation, self).__init__(target, prop)

        self.setPathType(Animation.LinearPath)

    def setPathType(self, pathType):
        self.m_pathType = pathType
        self.m_path = QPainterPath()

    def updateCurrentTime(self, currentTime):
        if self.m_pathType == Animation.CirclePath:
            if self.m_path.isEmpty():
                end = self.endValue()
                start = self.startValue()
                self.m_path.moveTo(start)
                self.m_path.addEllipse(QRectF(start, end))

            dura = self.duration()
            if dura == 0:
                progress = 1.0
            else:
                progress = (((currentTime - 1) % dura) + 1) / float(dura)

            easedProgress = self.easingCurve().valueForProgress(progress)
            if easedProgress > 1.0:
                easedProgress -= 1.0
            elif easedProgress < 0:
                easedProgress += 1.0

            pt = self.m_path.pointAtPercent(easedProgress)
            self.updateCurrentValue(pt)
            self.valueChanged.emit(pt)
        else:
            super(Animation, self).updateCurrentTime(currentTime)
Ejemplo n.º 19
0
class NodeAnchorItem(GraphicsPathObject):
    """
    The left/right widget input/output anchors.
    """

    def __init__(self, parent, *args):
        self.__boundingRect = None
        GraphicsPathObject.__init__(self, parent, *args)
        self.setAcceptHoverEvents(True)
        self.setPen(QPen(Qt.NoPen))
        self.normalBrush = QBrush(QColor("#CDD5D9"))
        self.connectedBrush = QBrush(QColor("#9CACB4"))
        self.setBrush(self.normalBrush)

        self.shadow = QGraphicsDropShadowEffect(
            blurRadius=10,
            color=QColor(SHADOW_COLOR),
            offset=QPointF(0, 0)
        )

        self.setGraphicsEffect(self.shadow)
        self.shadow.setEnabled(False)

        # Does this item have any anchored links.
        self.anchored = False

        if isinstance(parent, NodeItem):
            self.__parentNodeItem = parent
        else:
            self.__parentNodeItem = None

        self.__anchorPath = QPainterPath()
        self.__points = []
        self.__pointPositions = []

        self.__fullStroke = None
        self.__dottedStroke = None
        self.__shape = None

        self.prepareGeometryChange()
        self.__boundingRect = None

    def parentNodeItem(self):
        """
        Return a parent :class:`NodeItem` or ``None`` if this anchor's
        parent is not a :class:`NodeItem` instance.

        """
        return self.__parentNodeItem

    def setAnchorPath(self, path):
        """
        Set the anchor's curve path as a :class:`QPainterPath`.
        """
        self.prepareGeometryChange()
        self.__boundingRect = None

        self.__anchorPath = path
        # Create a stroke of the path.
        stroke_path = QPainterPathStroker()
        stroke_path.setCapStyle(Qt.RoundCap)

        # Shape is wider (bigger mouse hit area - should be settable)
        stroke_path.setWidth(12)
        self.__shape = stroke_path.createStroke(path)

        # The full stroke
        stroke_path.setWidth(3)
        self.__fullStroke = stroke_path.createStroke(path)

        # The dotted stroke (when not connected to anything)
        stroke_path.setDashPattern(Qt.DotLine)
        self.__dottedStroke = stroke_path.createStroke(path)

        if self.anchored:
            self.setPath(self.__fullStroke)
            self.setBrush(self.connectedBrush)
        else:
            self.setPath(self.__dottedStroke)
            self.setBrush(self.normalBrush)

    def anchorPath(self):
        """
        Return the anchor path (:class:`QPainterPath`). This is a curve on
        which the anchor points lie.

        """
        return self.__anchorPath

    def setAnchored(self, anchored):
        """
        Set the items anchored state. When ``False`` the item draws it self
        with a dotted stroke.

        """
        self.anchored = anchored
        if anchored:
            self.setPath(self.__fullStroke)
            self.setBrush(self.connectedBrush)
        else:
            self.setPath(self.__dottedStroke)
            self.setBrush(self.normalBrush)

    def setConnectionHint(self, hint=None):
        """
        Set the connection hint. This can be used to indicate if
        a connection can be made or not.

        """
        raise NotImplementedError

    def count(self):
        """
        Return the number of anchor points.
        """
        return len(self.__points)

    def addAnchor(self, anchor, position=0.5):
        """
        Add a new :class:`AnchorPoint` to this item and return it's index.

        The `position` specifies where along the `anchorPath` is the new
        point inserted.

        """
        return self.insertAnchor(self.count(), anchor, position)

    def insertAnchor(self, index, anchor, position=0.5):
        """
        Insert a new :class:`AnchorPoint` at `index`.

        See also
        --------
        NodeAnchorItem.addAnchor

        """
        if anchor in self.__points:
            raise ValueError("%s already added." % anchor)

        self.__points.insert(index, anchor)
        self.__pointPositions.insert(index, position)

        anchor.setParentItem(self)
        anchor.setPos(self.__anchorPath.pointAtPercent(position))
        anchor.destroyed.connect(self.__onAnchorDestroyed)

        self.__updatePositions()

        self.setAnchored(bool(self.__points))

        return index

    def removeAnchor(self, anchor):
        """
        Remove and delete the anchor point.
        """
        anchor = self.takeAnchor(anchor)

        anchor.hide()
        anchor.setParentItem(None)
        anchor.deleteLater()

    def takeAnchor(self, anchor):
        """
        Remove the anchor but don't delete it.
        """
        index = self.__points.index(anchor)

        del self.__points[index]
        del self.__pointPositions[index]

        anchor.destroyed.disconnect(self.__onAnchorDestroyed)

        self.__updatePositions()

        self.setAnchored(bool(self.__points))

        return anchor

    def __onAnchorDestroyed(self, anchor):
        try:
            index = self.__points.index(anchor)
        except ValueError:
            return

        del self.__points[index]
        del self.__pointPositions[index]

    def anchorPoints(self):
        """
        Return a list of anchor points.
        """
        return list(self.__points)

    def anchorPoint(self, index):
        """
        Return the anchor point at `index`.
        """
        return self.__points[index]

    def setAnchorPositions(self, positions):
        """
        Set the anchor positions in percentages (0..1) along the path curve.
        """
        if self.__pointPositions != positions:
            self.__pointPositions = list(positions)

            self.__updatePositions()

    def anchorPositions(self):
        """
        Return the positions of anchor points as a list of floats where
        each float is between 0 and 1 and specifies where along the anchor
        path does the point lie (0 is at start 1 is at the end).

        """
        return list(self.__pointPositions)

    def shape(self):
        if self.__shape is not None:
            return self.__shape
        else:
            return GraphicsPathObject.shape(self)

    def boundingRect(self):
        if self.__boundingRect is None:
            self.__boundingRect = super(NodeAnchorItem, self).boundingRect() \
                                  .adjusted(-5, -5, 5, 5)
        return self.__boundingRect

    def hoverEnterEvent(self, event):
        self.prepareGeometryChange()
        self.__boundingRect = None
        self.shadow.setEnabled(True)
        return GraphicsPathObject.hoverEnterEvent(self, event)

    def hoverLeaveEvent(self, event):
        self.prepareGeometryChange()
        self.__boundingRect = None
        self.shadow.setEnabled(False)
        return GraphicsPathObject.hoverLeaveEvent(self, event)

    def __updatePositions(self):
        """Update anchor points positions.
        """
        self.prepareGeometryChange()
        self.__boundingRect = None
        for point, t in zip(self.__points, self.__pointPositions):
            pos = self.__anchorPath.pointAtPercent(t)
            point.setPos(pos)
Ejemplo n.º 20
0
    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)
            curLayer = int((self.fImageLayersCount - 1) * normValue)

            if self.fImageOrientation == self.HORIZONTAL:
                xpos = self.fImageBaseSize * curLayer
                ypos = 0.0
            else:
                xpos = 0.0
                ypos = self.fImageBaseSize * curLayer

            source = QRectF(xpos, ypos, self.fImageBaseSize,
                            self.fImageBaseSize)

            if isinstance(self.fImage, QPixmap):
                target = QRectF(0.0, 0.0, self.fImageBaseSize,
                                self.fImageBaseSize)
                painter.drawPixmap(target, self.fImage, source)
            else:
                self.fImage.renderer().render(painter, 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 = 218 * 16
                spanAngle = -255 * 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 = 218 * 16
                    spanAngle = -255 * 16 * normValue
                else:
                    startAngle = 322.0 * 16
                    spanAngle = 255.0 * 16 * (1.0 - normValue)

                painter.setPen(QPen(color, 2.5))
                painter.drawArc(3.5, 3.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 = 218 * 16
                spanAngle = -255 * 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.8, 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.fImageBaseSize, self.fImageBaseSize)
            if isinstance(self.fImage, QPixmap):
                painter.drawPixmap(target, self.fImage, target)
            else:
                self.fImage.renderer().render(painter, target)

        painter.restore()
Ejemplo n.º 21
0
    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()
Ejemplo n.º 22
0
    def getPointOnEdge(self, t):
        edgePath = QPainterPath(self.beginPoint)
        edgePath.cubicTo(self.curvePoint1, self.curvePoint2, self.endPoint)

        return QPointF(edgePath.pointAtPercent(t))
Ejemplo n.º 23
0
    def getPointOnEdge(self, t):
        edgePath = QPainterPath(self.beginPoint)
        edgePath.cubicTo(self.curvePoint1, self.curvePoint2, self.endPoint)

        return QPointF(edgePath.pointAtPercent(t))
Ejemplo n.º 24
0
 def distance_to_path(point: QPointF,
                      path: QPainterPath,
                      percent: float = 0.0):
     bp = path.pointAtPercent(percent)
     return ((bp.x() - point.x())**2.0 + (bp.y() - point.y())**2.0)**0.5
Ejemplo n.º 25
0
    def drawTextAlongCubic(self, lay, painter, filename, msg):

        fs = lay["defaultFontSize"]
        font = QFont('Right Chalk', fs)

        defaultMessage = msg

        if len(msg) == 0:
            return

        c1 = QPointF(lay["x1"], lay["y1"])
        c2 = QPointF(lay["x2"], lay["y2"])
        c3 = QPointF(lay["x3"], lay["y3"])
        c4 = QPointF(lay["x4"], lay["y4"])
        path = QPainterPath(c1)
        path.cubicTo(c2, c3, c4)
        # painter.drawPath(path)

        pathLength = path.length()
        textMetricLength = QFontMetrics(font).width(defaultMessage)

        fsn = int(fs * pathLength / (textMetricLength) * .95)
        if fsn > 70:
            fsn = 70
        font = QFont('Right Chalk', fsn)

        textMetricLength = QFontMetrics(font).width(defaultMessage)

        messageSpacing = []
        defaultMessageM = []
        sumMessageSpacing = 0.0

        for i in range(len(defaultMessage)):
            messageSpacing.append(QFontMetrics(font).width(defaultMessage[i]))
            sumMessageSpacing += messageSpacing[i]

        for i in range(len(defaultMessage)):
            messageSpacing[i] = messageSpacing[i] / sumMessageSpacing

        steps = 0
        painter.setFont(font)

        for i in range(len(defaultMessage)):

            steps += messageSpacing[i] / 2
            point = QPointF(path.pointAtPercent(steps))
            angle = path.angleAtPercent(steps)

            painter.save()
            painter.translate(point)
            painter.rotate(-angle)
            x = -QFontMetrics(font).width(defaultMessage[i]) / 2
            y = -QFontMetrics(font).height() / 2
            w = QFontMetrics(font).width(defaultMessage[i])
            h = QFontMetrics(font).height()

            r = QRectF(x, y, w, h)
            painter.setPen(QPen(Qt.white, 2))
            painter.drawText(r, defaultMessage[i])
            if i % 2 == 0:
                painter.setPen(QPen(Qt.red, 2))
            else:
                painter.setPen(QPen(Qt.green, 2))
            # painter.drawRect(r)

            painter.restore()
            steps += messageSpacing[i] / 2