コード例 #1
0
 def paintEvent(self, event):
     a = self.height() / 2 * 0.4
     painter = QPainter(self)
     painter.setOpacity(self.opacity)
     painter.setRenderHint(QPainter.Antialiasing, True)
     painter.setRenderHint(QPainter.SmoothPixmapTransform, True)
     painter.setPen(Qt.NoPen)
     painter.save()
     path = QPainterPath()
     brush = QBrush(self.color1)
     painter.setBrush(brush)
     path.moveTo(self.p1)
     rect = QRectF(self.p1.x() - a, 0, a * 2, self.height())
     path.arcTo(rect, 90, 360)
     painter.drawPath(path)
     painter.restore()
     if self.p1 == self.p2:
         return
     path = QPainterPath()
     brush = QBrush(self.color2)
     painter.setBrush(brush)
     path.moveTo(self.p2)
     rect = QRectF(self.p2.x() - a, 0, a * 2, self.height())
     path.arcTo(rect, 90, 360)
     painter.drawPath(path)
コード例 #2
0
ファイル: StudyPlan.py プロジェクト: louisraccoon/PyStudy
    def itemRegion(self, index):
        if not index.isValid():
            return QRegion()

        if index.column() != 1:
            return QRegion(self.itemRect(index))

        if self.model().data(index) <= 0.0:
            return QRegion()

        startAngle = 0.0
        for row in range(self.model().rowCount(self.rootIndex())):

            sliceIndex = self.model().index(row, 1, self.rootIndex())
            value = self.model().data(sliceIndex)

            if value > 0.0:
                angle = 360*value/self.totalValue

                if sliceIndex == index:
                    slicePath = QPainterPath()
                    slicePath.moveTo(self.totalSize/2, self.totalSize/2)
                    slicePath.arcTo(self.margin, self.margin,
                            self.margin+self.pieSize, self.margin+self.pieSize,
                            startAngle, angle)
                    slicePath.closeSubpath()

                    return QRegion(slicePath.toFillPolygon().toPolygon())

                startAngle += angle

        return QRegion()
コード例 #3
0
ファイル: edges.py プロジェクト: TitoGrossi/bemgui
 def update(self, eventPos, fase, point=None):
     # If user is setting the final point
     if fase == 1:
         if fase == 1:
             path = QPainterPath()
             path.moveTo(self.initialPoint.position)
             path.lineTo(eventPos)
             self.setPath(path)
             if point:
                 self.finalPoint = point
     # If user is finishing the path (setting centerPoint)
     elif fase == 2:
         path = QPainterPath()
         path.moveTo(self.initialPoint.position)
         r = ((eventPos.x() - self.initialPoint.position.x())**2 +
              (eventPos.y() - self.initialPoint.position.y())**2)**(1 / 2)
         x, y, w, h = eventPos.x() - r, eventPos.y() - r, 2 * r, 2 * r
         line1 = QLineF(eventPos, self.initialPoint.position)
         line2 = QLineF(eventPos, self.finalPoint.position)
         startAngle, arcLenghth = line1.angle(), -(line1.angle() -
                                                   line2.angle())
         if arcLenghth == 0:
             arcLenghth = 360
         path.arcTo(x, y, w, h, startAngle, arcLenghth)
         self.setPath(path)
         if point:
             self.centerPoint = point
コード例 #4
0
    def drawBg(self, event, painter):
        painter.save()
        painter.setPen(Qt.NoPen)

        if self.checked:
            painter.setBrush(self.bgColorOn)
        else:
            painter.setBrush(self.bgColorOff)

        rect = QRect(0, 0, self.width(), self.height())
        # 半径为高度的一半
        radius = rect.height() / 2
        # 圆的宽度为高度
        circleWidth = rect.height()

        path = QPainterPath()
        path.moveTo(radius, rect.left())
        path.arcTo(QRectF(rect.left(), rect.top(), circleWidth, circleWidth),
                   90, 180)
        path.lineTo(rect.width() - radius, rect.height())
        path.arcTo(
            QRectF(rect.width() - rect.height(), rect.top(), circleWidth,
                   circleWidth), 270, 180)
        path.lineTo(radius, rect.top())

        painter.drawPath(path)
        painter.restore()
コード例 #5
0
def createRotateArrow():
    arrowHeadPos = 12
    arrowHeadLength = 4.5
    arrowHeadWidth = 5
    bodyWidth = 1.5
    outerArcSize = arrowHeadPos + bodyWidth - arrowHeadLength
    innerArcSize = arrowHeadPos - bodyWidth - arrowHeadLength
    path = QPainterPath()
    path.moveTo(arrowHeadPos, 0)
    path.lineTo(arrowHeadPos + arrowHeadWidth, arrowHeadLength)
    path.lineTo(arrowHeadPos + bodyWidth, arrowHeadLength)
    path.arcTo(QRectF(arrowHeadLength - outerArcSize,
                      arrowHeadLength - outerArcSize,
                      outerArcSize * 2,
                      outerArcSize * 2),
               0, -90)
    path.lineTo(arrowHeadLength, arrowHeadPos + arrowHeadWidth)
    path.lineTo(0, arrowHeadPos)
    path.lineTo(arrowHeadLength, arrowHeadPos - arrowHeadWidth)
    path.lineTo(arrowHeadLength, arrowHeadPos - bodyWidth)
    path.arcTo(QRectF(arrowHeadLength - innerArcSize,
                      arrowHeadLength - innerArcSize,
                      innerArcSize * 2,
                      innerArcSize * 2),
               -90, 90)
    path.lineTo(arrowHeadPos - arrowHeadWidth, arrowHeadLength)
    path.closeSubpath()
    return path
コード例 #6
0
 def get_path(self):
     path = QPainterPath()
     rect = QRectF(self.rect())
     path.arcMoveTo(rect, 0)
     path.arcTo(rect, 0, 360)
     path.closeSubpath()
     return path
コード例 #7
0
ファイル: _CustomWidgets.py プロジェクト: saknayo/sspainter
class ModCrossButton(QPushButton):
    def __init__(self,parent,path=None):
        QPushButton.__init__(self,parent)

        self.parent=parent


        #self.setAttribute(Qt.WA_TranslucentBackground, True)
        self.backgroundColor = QPalette().light().color()
        self.backgroundColor.setRgb(157,157,157) #(220,203,231)
        #self.backgroundColor.setAlpha(100)
        self.brush=QBrush(Qt.SolidPattern)


    def paintEvent(self,event):
        self.wide=self.width()
        self.high=self.height()
        self.xdis=self.wide/7
        self.ydis=self.xdis

        self.path=QPainterPath()
        self.path.setFillRule(Qt.OddEvenFill)

        self.path.moveTo(self.wide/2, self.high/2-self.xdis)
        self.path.arcTo(0,0, self.wide, self.high,0,360)
        #self.path.closeSubpath()

        self.path.moveTo(self.wide/2-self.xdis/2, self.ydis)
        self.path.lineTo(self.wide/2-self.xdis/2, self.high/2-self.xdis/2)
        self.path.lineTo(self.ydis, self.high/2-self.xdis/2)
        self.path.lineTo(self.ydis, self.high/2+self.xdis/2)
        self.path.lineTo(self.wide/2-self.xdis/2, self.high/2+self.xdis/2)
        self.path.lineTo(self.wide/2-self.xdis/2, self.high-self.ydis)
        self.path.lineTo(self.wide/2+self.xdis/2, self.high-self.ydis)
        self.path.lineTo(self.wide/2+self.xdis/2, self.high/2+self.xdis/2)
        self.path.lineTo(self.wide-self.ydis, self.high/2+self.xdis/2)
        self.path.lineTo(self.wide-self.ydis, self.high/2-self.xdis/2)
        self.path.lineTo(self.wide/2+self.xdis/2, self.high/2-self.xdis/2)
        self.path.lineTo(self.wide/2+self.xdis/2, self.ydis)
        self.path.closeSubpath()

        self.brush.setColor(self.backgroundColor)
        self.painter=QPainter(self)
        self.painter.setRenderHint(QPainter.Antialiasing)

        self.painter.setPen(Qt.NoPen)
        self.painter.setBrush(self.brush)
        self.painter.drawPath(self.path)
        self.painter.end()

    #def mousePressEvent(self,ev):
    #    self.parent.close()

    def enterEvent(self,ev):
        self.backgroundColor.setRgb(242,146,52) 
        self.update()
        
    def leaveEvent(self,ev):
        self.backgroundColor.setRgb(157,157,157)
        self.update()
コード例 #8
0
 def drawValue(self, p: QPainter, baseRect: QRectF, value: float, delta: float):
     if value == self.m_min:
         return
     if self.m_barStyle == self.BarStyle.EXPAND:
         p.setBrush(self.palette().highlight())
         p.setPen(QPen(self.palette().shadow().color(), self.m_dataPenWidth))
         radius = (baseRect.height() / 2) / delta
         p.drawEllipse(baseRect.center(), radius, radius)
         return
     if self.m_barStyle == self.BarStyle.LINE:
         p.setPen(QPen(self.palette().highlight().color(), self.m_dataPenWidth))
         p.setBrush(Qt.NoBrush)
         if value == self.m_max:
             p.drawEllipse(baseRect.adjusted(self.m_outlinePenWidth / 2, self.m_outlinePenWidth / 2,
                                             -self.m_outlinePenWidth / 2, -self.m_outlinePenWidth / 2))
         else:
             arcLength = 360 / delta
             p.drawArc(baseRect.adjusted(self.m_outlinePenWidth / 2, self.m_outlinePenWidth / 2,
                                         -self.m_outlinePenWidth / 2, -self.m_outlinePenWidth / 2),
                       int(self.m_nullPosition * 16),
                       int(-arcLength * 16))
         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)
コード例 #9
0
ファイル: XChartMarkers.py プロジェクト: trhallam/trib
 def setPath(self):
     path = QPainterPath()
     path.moveTo(self._wrs * 0.97, self._hrs / 2)
     # artTo (startx, starty, width, height, arcdeg start, arcdeg end)
     path.arcTo(self._wrs * 0.03, self._hrs * 0.03, self._wrs * 0.94,
                self._hrs * 0.94, 0.0, 360.0)
     return path
コード例 #10
0
ファイル: Doraemon.py プロジェクト: bigdot123456/PyQTDemo
    def drawFace(self, qp):
        #画脸外轮廓
        path = QPainterPath()
        outdiameter = 376.0
        outre = QRectF(261.0, 30.0, outdiameter, outdiameter)
        outre_right_x = 261 + outdiameter / 2 + outdiameter / 2 / math.sqrt(2)
        outre_right_y = 30 + outdiameter / 2 + outdiameter / 2 / math.sqrt(2)
        path.moveTo(outre_right_x, outre_right_y)
        # 将painter路径的起始位置迁移到我们指定的坐标。
        path.arcTo(outre, -45, 270)
        # arcTo()创建一个占据给定矩形的弧,从指定的startAngle(-45度)开始并逆时针延伸sweepLength(270度)
        path.closeSubpath()
        # 通过在子路径的开头绘制一条线来关闭当前子路径,自动启动一个新路径
        qp.setBrush(QColor(156, 214, 239))
        # 给这个图形填充我们设置的颜色
        qp.drawPath(path)
        # 画出我们刚才设置的图形

        #画脸内轮廓
        path2 = QPainterPath()
        indiameter = 311.0
        inre = QRectF(301.0, 86.0, indiameter, indiameter)
        # 画矩形
        inre_right_x = 301 + indiameter / 2 + indiameter / 2 / math.sqrt(2)
        inre_right_y = 86 + indiameter / 2 + indiameter / 2 / math.sqrt(2)
        path2.moveTo(inre_right_x, inre_right_y)
        path2.arcTo(inre, -45, 270)
        path2.closeSubpath()
        qp.setBrush(Qt.white)
        qp.drawPath(path2)
コード例 #11
0
ファイル: bar.py プロジェクト: sdouglas/lr-notebook
 def updateAngle(self, startAngle, spanAngle):
     self._startAngle = startAngle
     self._spanAngle = spanAngle
     path = QPainterPath()
     path.arcMoveTo(self._parent._rect, startAngle)
     path.arcTo(self._parent._rect, startAngle, spanAngle)
     self.setPath(path)
コード例 #12
0
    def itemRegion(self, index):
        if not index.isValid():
            return QRegion()

        if index.column() != 1:
            return QRegion(self.itemRect(index))

        if self.model().data(index) <= 0.0:
            return QRegion()

        startAngle = 0.0
        for row in range(self.model().rowCount(self.rootIndex())):

            sliceIndex = self.model().index(row, 1, self.rootIndex())
            value = self.model().data(sliceIndex)

            if value > 0.0:
                angle = 360 * value / self.totalValue

                if sliceIndex == index:
                    slicePath = QPainterPath()
                    slicePath.moveTo(self.totalSize / 2, self.totalSize / 2)
                    slicePath.arcTo(self.margin, self.margin,
                                    self.margin + self.pieSize,
                                    self.margin + self.pieSize, startAngle,
                                    angle)
                    slicePath.closeSubpath()

                    return QRegion(slicePath.toFillPolygon().toPolygon())

                startAngle += angle

        return QRegion()
コード例 #13
0
ファイル: Utils.py プロジェクト: yiyexingyu/RoadExtraction
def get_circle_path(center_pos: list, radius: int):
    rect = QRectF(center_pos[0] - radius, center_pos[1] - radius, radius * 2,
                  radius * 2)
    seed_path = QPainterPath()
    seed_path.arcMoveTo(rect, 0)
    seed_path.arcTo(rect, 0, 360)
    seed_path.closeSubpath()
    return seed_path
コード例 #14
0
ファイル: Utils.py プロジェクト: yiyexingyu/RoadExtraction
def create_circle_path(x_center: int, y_center: int,
                       radius: int) -> QPainterPath:
    rect = QRectF(x_center - radius, y_center - radius, radius * 2, radius * 2)
    circle_path = QPainterPath()
    circle_path.arcMoveTo(rect, 0)
    circle_path.arcTo(rect, 0, 360)
    circle_path.closeSubpath()
    return circle_path
コード例 #15
0
ファイル: utils.py プロジェクト: Kammann123/sae_fend
def draw_circular_bar(
        painter: QPainter,
        radius: int,
        angle: int,
        span: int,
        width: int,
        fill_brush: QBrush,
        line_brush: QBrush,
        line_width: int
):
    """
    Draw a circular bar using the QPainter handler given by the outer caller.
    :param painter: Painter handler
    :param radius:  Circular radius
    :param angle:   Starting angle
    :param span:    Span angle
    :param width:   Width between circular
    :param fill_brush:  Color pattern used to fill the path
    :param line_brush:  Color pattern used to draw lines
    :param line_width:  Line width
    """
    painter.save()
    path = QPainterPath()
    path.moveTo(
        QPointF(
            (radius - width / 2) * cos(radians(angle)) + radius,
            -(radius - width / 2) * sin(radians(angle)) + radius
        )
    )
    path.lineTo(
        QPointF(
            radius * cos(radians(angle)) + radius,
            -radius * sin(radians(angle)) + radius
        )
    )
    path.arcTo(QRectF(0, 0, radius * 2, radius * 2), angle, span)
    path.lineTo(
        QPointF(
            (radius - width / 2) * cos(radians(angle + span)) + radius,
            -(radius - width / 2) * sin(radians(angle + span)) + radius
        )
    )
    path.arcTo(
        QRectF(
            width // 2, width // 2,
            radius * 2 - width, radius * 2 - width
        ),
        angle + span,
        -span
    )

    pen = QPen(line_brush, line_width)
    pen.setJoinStyle(Qt.RoundJoin)

    painter.setPen(pen)
    painter.fillPath(path, fill_brush)
    painter.drawPath(path)
    painter.restore()
コード例 #16
0
ファイル: Utils.py プロジェクト: yiyexingyu/RoadExtraction
def get_circle_seed_path(circle_seed) -> QPainterPath:
    rect = QRectF(circle_seed.position.x() - circle_seed.radius,
                  circle_seed.position.y() - circle_seed.radius,
                  circle_seed.radius * 2, circle_seed.radius * 2)
    seed_path = QPainterPath()
    seed_path.arcMoveTo(rect, 0)
    seed_path.arcTo(rect, 0, 360)
    seed_path.closeSubpath()
    return seed_path
コード例 #17
0
ファイル: Doraemon.py プロジェクト: bigdot123456/PyQTDemo
    def drawBody(self, qp):
        #画身体
        path4 = QPainterPath()
        body_polygon = QPolygonF()
        body_polygon << QPointF(316.0, 349.0) << QPointF(
            580.0, 349.0) << QPointF(577.0, 496.0) << QPointF(319.0, 496.0)
        # 绘制一个多边形
        path4.addPolygon(body_polygon)
        path4.closeSubpath()
        qp.setBrush(QColor(156, 214, 239))
        qp.drawPath(path4)

        #画肚子
        path5 = QPainterPath()
        belly_width = 180.0
        belly_length = 235.0
        bellyre = QRectF(365.0, 240.0, belly_width, belly_length)
        belly_center_x = 365.0 + belly_width / 2
        belly_center_y = 240.0 + belly_length / 2
        path5.moveTo(belly_center_x, belly_center_y)
        path5.arcTo(bellyre, 180, 180)
        path5.closeSubpath()
        qp.setBrush(Qt.white)
        qp.drawPath(path5)

        #画围兜
        path6 = QPainterPath()
        scarf_polygon = QPolygonF()
        scarf_polygon << QPointF(316.0, 349.0) << QPointF(
            580.0, 349.0) << QPointF(450.0, 379.0) << QPointF(319.0, 349.0)
        path6.addPolygon(scarf_polygon)
        path6.closeSubpath()
        qp.setBrush(Qt.red)
        qp.drawPath(path6)

        #画铃铛
        bell_re = QRectF(442.0, 364.0, 30, 30)
        qp.setBrush(QColor(250, 221, 81))
        qp.drawEllipse(bell_re)
        qp.drawLine(455, 370, 465, 380)
        qp.drawLine(465, 380, 455, 385)

        #画口袋
        path7 = QPainterPath()
        pocket_width = 112.0
        pocket_length = 104.0
        pocketre = QRectF(400.0, 352.0, pocket_width, pocket_length)
        pocket_center_x = 412.0 + pocket_width / 2
        pocket_center_y = 352.0 + pocket_length / 2
        path7.moveTo(pocket_center_x, pocket_center_y)
        path7.arcTo(pocketre, 180, 180)
        path7.closeSubpath()
        qp.setBrush(Qt.white)
        qp.drawPath(path7)
コード例 #18
0
ファイル: Doraemon.py プロジェクト: bigdot123456/PyQTDemo
 def drawMouth(self, qp):
     #画嘴巴
     path3 = QPainterPath()
     mouth_diameter = 203.0
     mouthre = QRectF(352.0, 129.0, mouth_diameter, mouth_diameter)
     mouth_center_x = 352.0 + mouth_diameter / 2
     mouth_center_y = 129.0 + mouth_diameter / 2
     path3.moveTo(mouth_center_x, mouth_center_y)
     path3.arcTo(mouthre, 180, 180)
     path3.closeSubpath()
     qp.setBrush(QColor(219, 36, 28))
     qp.drawPath(path3)
コード例 #19
0
ファイル: iwidget.py プロジェクト: yuanjq/idoui
 def _getRightTopCornerPath(self):
     width = self.width()
     borderRadius = self.borderRadius
     shadowMargin = self.shadowMargin
     shadowRadius = self.shadowRadius
     
     path = QPainterPath()
     path.moveTo(width - shadowRadius, 0)
     path.arcTo(width - 2 * shadowRadius, 0, 2 * shadowRadius, 2 * shadowRadius, 90, -90)
     path.lineTo(width - shadowMargin, shadowRadius)
     path.arcTo(width - shadowRadius - borderRadius, shadowMargin, 2 * borderRadius, 2 * borderRadius, 0, 90)
     path.lineTo(width - shadowRadius, 0)
     return path
コード例 #20
0
ファイル: iwidget.py プロジェクト: yuanjq/idoui
 def _getLeftBottomCornerPath(self):
     height = self.height()
     borderRadius = self.borderRadius
     shadowMargin = self.shadowMargin
     shadowRadius = self.shadowRadius
     
     path = QPainterPath()
     path.moveTo(0, height - shadowRadius)
     path.arcTo(0, height - 2 * shadowRadius, 2 * shadowRadius, 2 * shadowRadius, 180, 90)
     path.lineTo(shadowRadius, height - shadowMargin)
     path.arcTo(shadowMargin, height - shadowRadius - borderRadius, 2 * borderRadius, 2 * borderRadius, 270, -90)
     path.lineTo(0, height - shadowRadius)
     return path
コード例 #21
0
    def paintArc(self, st, p, coord, color):
        r1 = self.grid_size // 2 - self.radius
        r2 = self.grid_size // 2 + self.radius
        if st == 0:
            ang1 = 0
            ang2 = -90
            span = -90
            rect1 = QRectF(coord[0] - r1, coord[1] - r1, 2 * r1, 2 * r1)
            rect2 = QRectF(coord[0] - r2, coord[1] - r2, 2 * r2, 2 * r2)
            kp = QPoint(coord[0] + r2, coord[1])
        if st == 1:
            ang1 = -90
            ang2 = -180
            span = -90
            rect1 = QRectF(coord[0] + self.grid_size - r1, coord[1] - r1,
                           2 * r1, 2 * r1)
            rect2 = QRectF(coord[0] + self.grid_size - r2, coord[1] - r2,
                           2 * r2, 2 * r2)
            kp = QPoint(coord[0] + self.grid_size, coord[1] + r2)
        if st == 2:
            ang1 = 90
            ang2 = 180
            span = 90
            rect1 = QRectF(coord[0] + self.grid_size - r1,
                           coord[1] + self.grid_size - r1, 2 * r1, 2 * r1)
            rect2 = QRectF(coord[0] + self.grid_size - r2,
                           coord[1] + self.grid_size - r2, 2 * r2, 2 * r2)
            kp = QPoint(coord[0] + self.grid_size,
                        coord[1] + self.grid_size + r2)
        if st == 3:
            ang1 = 0
            ang2 = 90
            span = 90
            rect1 = QRectF(coord[0] - r1, coord[1] + self.grid_size - r1,
                           2 * r1, 2 * r1)
            rect2 = QRectF(coord[0] - r2, coord[1] + self.grid_size - r2,
                           2 * r2, 2 * r2)
            kp = QPoint(coord[0] + r2, coord[1] + self.grid_size)

        path = QPainterPath()
        path.moveTo(kp)
        path.arcTo(rect1, ang1, span)
        path.arcTo(rect2, ang2, -span)

        brush = QBrush()
        brush.setColor(color)
        brush.setStyle(Qt.SolidPattern)

        p.drawArc(rect1, ang1 * 16, span * 16)
        p.drawArc(rect2, ang2 * 16, -span * 16)
        p.fillPath(path, brush)
コード例 #22
0
ファイル: iwidget.py プロジェクト: yuanjq/idoui
 def _getRightBottomCornerPath(self):
     width = self.width()
     height = self.height()
     borderRadius = self.borderRadius
     shadowMargin = self.shadowMargin
     shadowRadius = self.shadowRadius
     
     path = QPainterPath()
     path.moveTo(width - shadowRadius, height)
     path.arcTo(width - 2 * shadowRadius, height - 2 * shadowRadius, 2 * shadowRadius, 2 * shadowRadius, 270, 90)
     path.lineTo(width - shadowMargin, height - shadowRadius)
     path.arcTo(width - shadowRadius - borderRadius, height - shadowRadius - borderRadius, 2 * borderRadius, 2 * borderRadius, 0, -90)
     path.lineTo(width - shadowRadius, height)
     return path
コード例 #23
0
ファイル: line.py プロジェクト: rnk-industries/Chemical-PFD
    def paint(self, painter, option, widget):
        color = Qt.red if self.isSelected() else Qt.black
        painter.setPen(QPen(color, 2, Qt.SolidLine))
        path = QPainterPath(self.startPoint) # start path
        # iterating over all points of line
        for i in range(len(self.points) - 1):
            x1, y1 = self.points[i].x(), self.points[i].y()
            x2, y2 = self.points[i + 1].x(), self.points[i + 1].y()
            for point in sorted(self.commonPathsCenters, key=lambda x: x.x() + x.y(), reverse=x2 < x1 or y2 < y1):
                x, y = point.x(), point.y()
                if x == x1 == x2:
                    # vertical
                    if min(y1, y2) + 8 <= y < max(y1, y2) - 8:
                        if y2 > y1:
                            path.lineTo(point - QPointF(0, 8))
                            path.arcTo(QRectF(x - 8, y - 8, 16, 16), 90, -180)
                            path.moveTo(point + QPointF(0, 8))
                        else:
                            path.lineTo(point + QPointF(0, 8))
                            path.arcTo(QRectF(x - 8, y - 8, 16, 16), -90, 180)
                            path.moveTo(point - QPointF(0, 8))
                elif y == y1 == y2:
                    # horizontal
                    if min(x1, x2) + 8 <= x < max(x1, x2) - 8:
                        if x2 > x1:
                            path.lineTo(point - QPointF(8, 0))
                            path.arcTo(QRectF(x - 8, y - 8, 16, 16), 180, 180)
                            path.moveTo(point + QPointF(8, 0))
                        else:
                            path.lineTo(point + QPointF(8, 0))
                            path.arcTo(QRectF(x - 8, y - 8, 16, 16), 0, -180)
                            path.lineTo(point - QPointF(8, 0))
            path.lineTo(self.points[i + 1])
            # draw arrow in last segment
            if i == len(self.points) - 2:
                arrow_size = 20.0
                line = QLineF(self.points[i], self.points[i + 1])
                if line.length() < 20:
                    continue
                angle = math.acos(line.dx() / line.length())

                if line.dy() >= 0:
                    angle = (math.pi * 2) - angle

                arrow_p1 = line.p2() - QPointF(math.sin(angle + math.pi / 2.5) * arrow_size,
                                               math.cos(angle + math.pi / 2.5) * arrow_size)

                arrow_p2 = line.p2() - QPointF(math.sin(angle + math.pi - math.pi / 2.5) * arrow_size,
                                               math.cos(angle + math.pi - math.pi / 2.5) * arrow_size)

                arrowHead = QPolygonF()
                arrowHead.append(line.p2())
                arrowHead.append(arrow_p1)
                arrowHead.append(arrow_p2)
                painter.save()
                painter.setBrush(Qt.black)
                painter.drawPolygon(arrowHead)
                painter.restore()

        painter.drawPath(path) # draw final path
コード例 #24
0
ファイル: iwidget.py プロジェクト: yuanjq/idoui
 def _getLeftTopCornerPath(self):
     borderRadius = self.borderRadius
     shadowMargin = self.shadowMargin
     shadowRadius = self.shadowRadius
     
     path = QPainterPath()
     path.moveTo(self.shadowRadius, 0)
     path.arcTo(0, 0, 2 * shadowRadius, 2 * shadowRadius, 90, 90)
     path.lineTo(shadowMargin, shadowRadius)
     path.arcTo(shadowMargin, shadowMargin, 
                2 * borderRadius, 2 * borderRadius, 
                180, -90)
     path.lineTo(shadowRadius, 0)
     return path
コード例 #25
0
ファイル: sdlSymbols.py プロジェクト: examon/opengeode
 def set_shape(self, width, height):
     ''' ANSWER has round, disjoint sides - does not fit in a polygon '''
     self.width, self.height = width, height
     point = 20 #width / 2.85
     path = QPainterPath()
     left = QRect(0, 0, point, height)
     right = QRect(width - point, 0, point, height)
     path.arcMoveTo(left, 125)
     path.arcTo(left, 125, 110)
     path.arcMoveTo(right, -55)
     path.arcTo(right, -55, 110)
     path.moveTo(width, height)
     self.setPath(path)
     super(DecisionAnswer, self).set_shape(width, height)
コード例 #26
0
ファイル: _CustomWidgets.py プロジェクト: saknayo/sspainter
class ModCloseButton(QPushButton):
    def __init__(self,parent,wide,high,ppath=None):
        QPushButton.__init__(self,parent)

        self.parent=parent
        self.wide=wide
        self.high=high
        self.resize(self.wide,self.high)
        self.xdis=self.wide/10

        #self.setAttribute(Qt.WA_TranslucentBackground, True)
        self.backgroundColor = QPalette().light().color()
        self.backgroundColor.setRgb(157,157,157) #(220,203,231)
        #self.backgroundColor.setAlpha(100)
        self.brush=QBrush(Qt.SolidPattern)

        if ppath :
            self.path=ppath
        else :
            self.path=QPainterPath()

            self.path.moveTo(self.wide/2, self.high/2-self.xdis)
            self.path.arcTo(0,0, self.wide-2*self.xdis, self.high-2*self.xdis,45,90)
            self.path.closeSubpath()

            self.path.moveTo(self.wide/2-self.xdis, self.high/2)
            self.path.arcTo(0,0,self.wide-2*self.xdis,self.high-2*self.xdis,135,90)
            self.path.closeSubpath()

            self.path.moveTo(self.wide/2, self.high/2+self.xdis)
            self.path.arcTo(0,0,self.wide-2*self.xdis, self.high-2*self.xdis,225,90)
            self.path.closeSubpath()

            self.path.moveTo(self.wide/2+self.xdis, self.high/2)
            self.path.arcTo(0,0,self.wide-2*self.xdis, self.high-2*self.xdis,315,90)
            self.path.closeSubpath()

    def paintEvent(self,event):
        self.brush.setColor(self.backgroundColor)
        self.painter=QPainter(self)
        self.painter.setRenderHint(QPainter.Antialiasing)

        self.painter.setPen(Qt.NoPen)
        self.painter.setBrush(self.brush)
        self.painter.drawPath(self.path)
        self.painter.end()

    def mousePressEvent(self,ev):
        self.parent.close()

    def enterEvent(self,ev):
        self.backgroundColor.setRgb(234,39,13) 
        self.update()
        
    def leaveEvent(self,ev):
        self.backgroundColor.setRgb(157,157,157)
        self.update()
コード例 #27
0
ファイル: items.py プロジェクト: amerlyq/piony
    def updatePath(self, margin=2):
        r, R, a, A = self.boundings()
        sgm = SegmentShapeEngine(r, a, R-r, A-a)

        pts = tuple(map(lambda p: (p[0], -p[1]), sgm.points_ra(margin)))
        (r, al), (_, aL), (R, AL), (_, Al) = sgm.points_RA(margin)

        p = QPainterPath()
        p.moveTo(*pts[0])
        p.lineTo(*pts[1])
        # p.lineTo(*pts[2])
        p.arcTo(QRectF(-R, -R, 2*R, 2*R), aL, AL-aL)
        p.lineTo(*pts[3])
        # p.lineTo(*pts[0])
        p.arcTo(QRectF(-r, -r, 2*r, 2*r), Al, -(Al-al))
        self._path = p
        self._text_rf = QRectF(*sgm.text_bbox_SCR())
コード例 #28
0
 def drawSupport(self, p: QPainter, dir=0):
     # 0 down, 1 left, 2 up, 3 right
     p.save()
     #p.setTransform(QTransform().translate(self.x, self.y).rotate(90*dir))
     # p.rotate(90*dir)
     p.translate(self.x, self.y)
     p.rotate(90 * dir)
     path = QPainterPath()
     path.moveTo(self.radius, 0)
     path.lineTo(self.radius, -self.radius)
     path.lineTo(-self.radius, -self.radius)
     path.lineTo(-self.radius, 0)
     # path.cubicTo(self.x+self.radius, self.y+self.radius*, self.x -
     #             self.radius, self.y+self.radius*math.sqrt(2), self.x-self.radius, self.y)
     path.arcTo(-self.radius, -self.radius, self.radius * 2,
                self.radius * 2, 180, 180)
     path.closeSubpath()
     p.drawPath(path)
     p.restore()
コード例 #29
0
    def paintEvent(self, event: QtGui.QPaintEvent) -> None:
        super().paintEvent(event)
        painter = QPainter(self)
        painter.setRenderHint(QPainter.Antialiasing, True)
        pen = QPen(Qt.red)
        pen.setWidth(2)
        painter.setPen(pen)
        if self._bezier_path is None and self._init_line:
            painter.drawLine(self._init_line[0], self._init_line[1])
        if self._bezier_path is not None:
            self._bezier_path.paint(painter)

        p = QPainterPath()
        p.arcMoveTo(100, 100, 100, 50, 30)
        p.arcTo(100, 100, 100, 50, 30, 120)

        n = QPainterPath()
        n.moveTo(100, 110)
        n.lineTo(200, 110)
コード例 #30
0
ファイル: edges.py プロジェクト: TitoGrossi/bemgui
 def shape(self):
     # print(2)
     if self.centerPoint:
         r = ((self.centerPoint.x() - self.initialPoint.position.x())**2 +
              (self.centerPoint.y() - self.initialPoint.position.y())**2)**(
                  1 / 2)
         w, h = 2 * r, 2 * r
         pf = self.path().pointAtPercent(1 - 4 / self.path().length())
         pi = self.path().pointAtPercent(4 / self.path().length())
         line1 = QLineF(self.centerPoint.position, pi)
         line2 = QLineF(self.centerPoint.position, pf)
         startAngle, arcLength = line1.angle(), -(line1.angle() -
                                                  line2.angle())
         if arcLength == 0:
             arcLength = 360
         path = QPainterPath()
         path.moveTo(pi)
         path.arcTo(self.path().boundingRect(), startAngle, arcLength)
         path.arcTo(self.path().boundingRect(), line2.angle(), -arcLength)
         return path
     else:
         return super(arcEdge, self).shape()
コード例 #31
0
def createRotateArrow():
    arrowHeadPos = 12
    arrowHeadLength = 4.5
    arrowHeadWidth = 5
    bodyWidth = 1.5
    outerArcSize = arrowHeadPos + bodyWidth - arrowHeadLength
    innerArcSize = arrowHeadPos - bodyWidth - arrowHeadLength
    path = QPainterPath()
    path.moveTo(arrowHeadPos, 0)
    path.lineTo(arrowHeadPos + arrowHeadWidth, arrowHeadLength)
    path.lineTo(arrowHeadPos + bodyWidth, arrowHeadLength)
    path.arcTo(
        QRectF(arrowHeadLength - outerArcSize, arrowHeadLength - outerArcSize,
               outerArcSize * 2, outerArcSize * 2), 0, -90)
    path.lineTo(arrowHeadLength, arrowHeadPos + arrowHeadWidth)
    path.lineTo(0, arrowHeadPos)
    path.lineTo(arrowHeadLength, arrowHeadPos - arrowHeadWidth)
    path.lineTo(arrowHeadLength, arrowHeadPos - bodyWidth)
    path.arcTo(
        QRectF(arrowHeadLength - innerArcSize, arrowHeadLength - innerArcSize,
               innerArcSize * 2, innerArcSize * 2), -90, 90)
    path.lineTo(arrowHeadPos - arrowHeadWidth, arrowHeadLength)
    path.closeSubpath()
    return path
コード例 #32
0
    def _drawAutoencoder(self, painter: QPainter, rect: QRect) -> None:
        """Draw a given portion of this widget.

        Parameters
        ----------
        painter:
        rect:
        """
        pen = QPen(Qt.red)
        penWidth = 1
        pen.setWidth(penWidth)
        painter.setPen(pen)

        painter.drawLine(rect.topLeft(), rect.bottomRight())

        path = QPainterPath()
        path.moveTo(rect.topLeft())
        centerRect = QRectF(rect.left() + (rect.width() *.3),
                            rect.top() + (rect.height() *.4),
                            rect.width() *.2, rect.height() *.2)
        # path.lineTo(rect.left() + (rect.width() / 2),
        #             rect.top() + (rect.height() / 2))
        path.arcTo(centerRect, 45, -90)
        path.lineTo(rect.bottomLeft())
        path.lineTo(rect.topLeft())
        path.closeSubpath()
        painter.fillPath(path, QBrush(QColor("blue")))

        path = QPainterPath()
        path.moveTo(rect.topRight())
        path.lineTo(rect.left() + (rect.width() / 2),
                    rect.top() + (rect.height() / 2))
        path.lineTo(rect.bottomRight())
        path.lineTo(rect.bottomRight())
        path.closeSubpath()
        painter.fillPath(path, QBrush(QColor("blue")))
コード例 #33
0
 def paintEvent(self, event):
     a = self.height() / 2 * 0.4
     painter = QPainter(self)
     painter.setOpacity(self.opacity)
     painter.setRenderHint(QPainter.Antialiasing, True)
     painter.setRenderHint(QPainter.SmoothPixmapTransform, True)
     painter.setPen(Qt.NoPen)
     painter.save()
     brush = QBrush(self.color1)
     painter.setBrush(brush)
     path = QPainterPath()
     path.setFillRule(Qt.OddEvenFill)
     path.moveTo(self.p1)
     rect = QRectF(0, 0, a * 2, self.height())
     path.arcTo(rect, 90, 180)
     path.lineTo(self.p2)
     path.lineTo(self.p3)
     path.lineTo(self.p4)
     path.moveTo(self.p5)
     rect = QRectF(self.p5.x() - a, 0, a * 2, self.height())
     path.arcTo(rect, 90, 180)
     painter.drawPath(path)
     painter.restore()
     if self.p5 == self.p9:
         return
     brush = QBrush(self.color2)
     painter.setBrush(brush)
     path = QPainterPath()
     path.setFillRule(Qt.OddEvenFill)
     path.moveTo(self.p5)
     rect = QRectF(self.p5.x() - a, 0, a * 2, self.height())
     path.arcTo(rect, 90, 180)
     path.lineTo(self.p6)
     path.lineTo(self.p7)
     path.lineTo(self.p8)
     path.moveTo(self.p9)
     rect = QRectF(self.p9.x() - a, 0, a * 2, self.height())
     path.arcTo(rect, 90, 180)
     painter.drawPath(path)
     path = QPainterPath()
     path.setFillRule(Qt.OddEvenFill)
     path.moveTo(self.p1)
コード例 #34
0
    def __init__(self, diagramType, contextMenu, parent=None):
        super(DiagramItem, self).__init__(parent)

        self.arrows = []

        self.diagramType = diagramType
        self.contextMenu = contextMenu

        path = QPainterPath()
        if self.diagramType == self.StartEnd:
            path.moveTo(200, 50)
            path.arcTo(150, 0, 50, 50, 0, 90)
            path.arcTo(50, 0, 50, 50, 90, 90)
            path.arcTo(50, 50, 50, 50, 180, 90)
            path.arcTo(150, 50, 50, 50, 270, 90)
            path.lineTo(200, 25)
            self.myPolygon = path.toFillPolygon()
        elif self.diagramType == self.Conditional:
            self.myPolygon = QPolygonF(
                [
                    QPointF(-100, 0),
                    QPointF(0, 100),
                    QPointF(100, 0),
                    QPointF(0, -100),
                    QPointF(-100, 0),
                ]
            )
        elif self.diagramType == self.Step:
            self.myPolygon = QPolygonF(
                [
                    QPointF(-100, -100),
                    QPointF(100, -100),
                    QPointF(100, 100),
                    QPointF(-100, 100),
                    QPointF(-100, -100),
                ]
            )
        else:
            self.myPolygon = QPolygonF(
                [
                    QPointF(-120, -80),
                    QPointF(-70, 80),
                    QPointF(120, 80),
                    QPointF(70, -80),
                    QPointF(-120, -80),
                ]
            )

        self.setPolygon(self.myPolygon)
        self.setFlag(QGraphicsItem.ItemIsMovable, True)
        self.setFlag(QGraphicsItem.ItemIsSelectable, True)
コード例 #35
0
class ControlButton(QWidget):
    def __init__(self, index, name, func, parent):
        super().__init__(parent)
        self.index = index
        self.name = name
        self.function = func
        self.resize(TILE_WIDTH << 2, TILE_HEIGHT << 2)
        self.show()
        self.opacity = None
        self.setMouseTracking(True)
        self.color = QColor(50 * self.index, 255, 255 - 10 * self.index)
        self.gradient = QRadialGradient(
            50 + 10 * self.index, 50 - 10 * self.index, 500 - 50 * self.index,
            50 + 10 * self.index, 100 - 10 * self.index)
        self.gradient.setColorAt(0, QColor(200, 200, 200))
        self.gradient.setColorAt(0.5, QColor(50 * self.index, 255, 255 - 10 * self.index))
        self.gradient.setColorAt(1, QColor(200, 200, 200))
        self.brush = QBrush(self.gradient)
        self.path = QPainterPath()
        rect = QRectF(TILE_WIDTH * 1.5, TILE_HEIGHT * 1.5, TILE_WIDTH * 1.5, TILE_HEIGHT * 1.5)
        total = self.parent().total - 1
        if total < 3:
            total = 3
        if self.index == 0:
            self.path.arcMoveTo(rect, 90)
            self.path.arcTo(rect, 90, 360)
        else:
            self.path.arcMoveTo(QRectF(self.rect()), 90 + self.index * 360 // total)
            self.path.arcTo(QRectF(self.rect()), 90 + self.index * 360 // total,  360 // total)
            self.path.arcTo(rect, 90 + self.index * 360 // total + 360 // total, -360 // total)
            self.path.arcTo(QRectF(self.rect()), 90 + self.index * 360 // total,  0)

    def paintEvent(self, event):
        painter = QPainter(self)
        painter.setBrush(self.brush)
        if self.opacity is None or self.parent().vanishing:
            painter.setOpacity(self.parent().opacity / 255)
        else:
            painter.setOpacity(self.opacity / 255)
        pen = QPen(QColor(100, 100, 100, 150))
        pen.setWidth(10)
        painter.setPen(pen)
        painter.drawPath(self.path)
        painter.setPen(QColor(0, 0, 0))
        painter.drawText(self.path.controlPointRect(), Qt.AlignCenter, self.name)
コード例 #36
0
ファイル: diagramscene.py プロジェクト: Axel-Erfurt/pyqt5
    def __init__(self, diagramType, contextMenu, parent=None):
        super(DiagramItem, self).__init__(parent)

        self.arrows = []

        self.diagramType = diagramType
        self.contextMenu = contextMenu

        path = QPainterPath()
        if self.diagramType == self.StartEnd:
            path.moveTo(200, 50)
            path.arcTo(150, 0, 50, 50, 0, 90)
            path.arcTo(50, 0, 50, 50, 90, 90)
            path.arcTo(50, 50, 50, 50, 180, 90)
            path.arcTo(150, 50, 50, 50, 270, 90)
            path.lineTo(200, 25)
            self.myPolygon = path.toFillPolygon()
        elif self.diagramType == self.Conditional:
            self.myPolygon = QPolygonF([
                    QPointF(-100, 0), QPointF(0, 100),
                    QPointF(100, 0), QPointF(0, -100),
                    QPointF(-100, 0)])
        elif self.diagramType == self.Step:
            self.myPolygon = QPolygonF([
                    QPointF(-100, -100), QPointF(100, -100),
                    QPointF(100, 100), QPointF(-100, 100),
                    QPointF(-100, -100)])
        else:
            self.myPolygon = QPolygonF([
                    QPointF(-120, -80), QPointF(-70, 80),
                    QPointF(120, 80), QPointF(70, -80),
                    QPointF(-120, -80)])

        self.setPolygon(self.myPolygon)
        self.setFlag(QGraphicsItem.ItemIsMovable, True)
        self.setFlag(QGraphicsItem.ItemIsSelectable, True)
コード例 #37
0
    def paintEvent(self, evt):
        x1 = QPoint(0, -70)
        x2 = QPoint(0, -90)
        x3 = QPoint(-90, 0)
        x4 = QPoint(-70, 0)
        extRect = QRectF(-90, -90, 180, 180)
        intRect = QRectF(-70, -70, 140, 140)
        midRect = QRectF(-44, -80, 160, 160)
        unitRect = QRectF(-50, 60, 110, 50)

        speedInt = self.speed
        #speedDec = (self.speed * 10.0) - (speedInt * 10)
        s_SpeedInt = speedInt.__str__()[0:4]

        powerAngle = self.power * 270.0 / 100.0

        dummyPath = QPainterPath()
        dummyPath.moveTo(x1)
        dummyPath.arcMoveTo(intRect, 90 - powerAngle)
        powerPath = QPainterPath()
        powerPath.moveTo(x1)
        powerPath.lineTo(x2)
        powerPath.arcTo(extRect, 90, -1 * powerAngle)
        powerPath.lineTo(dummyPath.currentPosition())
        powerPath.arcTo(intRect, 90 - powerAngle, powerAngle)

        painter = QPainter(self)
        painter.setRenderHint(QPainter.Antialiasing)
        painter.translate(self.width() / 2, self.height() / 2)
        side = min(self.width(), self.height())
        painter.scale(side / 200.0, side / 200.0)

        painter.save()
        painter.rotate(-135)

        if self.displayPowerPath:
            externalPath = QPainterPath()
            externalPath.moveTo(x1)
            externalPath.lineTo(x2)
            externalPath.arcTo(extRect, 90, -270)
            externalPath.lineTo(x4)
            externalPath.arcTo(intRect, 180, 270)

            painter.setPen(self.powerPathColor)
            painter.drawPath(externalPath)

        painter.setBrush(self.powerGradient)
        painter.setPen(Qt.NoPen)
        painter.drawPath(powerPath)
        painter.restore()
        painter.save()

        painter.translate(QPointF(0, -50))

        painter.setPen(self.unitTextColor)
        fontFamily = self.font().family()
        unitFont = QFont(fontFamily, 9)
        painter.setFont(unitFont)
        painter.drawText(unitRect, Qt.AlignCenter, "{}".format(self.unit))

        painter.restore()

        painter.setPen(self.unitTextColor)
        fontFamily = self.font().family()
        unitFont = QFont(fontFamily, 12)
        painter.setFont(unitFont)
        painter.drawText(unitRect, Qt.AlignCenter, "{}".format(self.title))

        speedColor = QColor(0, 0, 0)
        speedFont = QFont(fontFamily, 30)
        fm1 = QFontMetrics(speedFont)
        speedWidth = fm1.width(s_SpeedInt)

        #speedDecFont = QFont(fontFamily, 23)
        #fm2 = QFontMetrics(speedDecFont)
        #speedDecWidth = fm2.width(s_SpeedDec)

        leftPos = -1 * speedWidth + 40
        leftDecPos = leftPos + speedWidth
        topPos = 10
        topDecPos = 10
        painter.setPen(self.speedTextColor)
        painter.setFont(speedFont)
        painter.drawText(leftPos, topPos, s_SpeedInt)
コード例 #38
0
ファイル: iwidget.py プロジェクト: yuanjq/idoui
    def _drawGradientShadow(self, painter, width, height):
        shadowRadius = self.shadowRadius
        shadowMargin = self.shadowMargin
        borderRadius = self.borderRadius
        
        painter.setPen(Qt.NoPen)
        # Draw top left radius
        radial = self._createRadialGradient(shadowRadius, shadowRadius, shadowRadius)
        painter.setBrush(radial)
        path = QPainterPath()
        path.moveTo(shadowRadius, 0)
        path.arcTo(0, 0, 2 * shadowRadius, 2 * shadowRadius, 90, 90)
        path.lineTo(shadowMargin, shadowRadius)
        path.arcTo(shadowMargin, shadowMargin, 2 * borderRadius, 2 * borderRadius, 180, -90)
        path.lineTo(shadowRadius, 0)
        painter.drawPath(path)

        # Draw top right radius
        path = QPainterPath()
        radial = self._createRadialGradient(width - shadowRadius, shadowRadius, shadowRadius)
        painter.setBrush(radial)
        path.moveTo(width - shadowRadius, 0)
        path.arcTo(width - 2 * shadowRadius, 0, 2 * shadowRadius, 2 * shadowRadius, 90, -90)
        path.lineTo(width - shadowMargin, shadowRadius)
        path.arcTo(width - shadowRadius - borderRadius, shadowMargin, 2 * borderRadius, 2 * borderRadius, 0, 90)
        path.lineTo(width - shadowRadius, 0)
        painter.drawPath(path)

        # Draw bottom left radius
        path = QPainterPath()
        radial = self._createRadialGradient(shadowRadius, height - shadowRadius, shadowRadius)
        painter.setBrush(radial)
        path.moveTo(0, height - shadowRadius)
        path.arcTo(0, height - 2 * shadowRadius, 2 * shadowRadius, 2 * shadowRadius, 180, 90)
        path.lineTo(shadowRadius, height - shadowMargin)
        path.arcTo(shadowMargin, height - shadowRadius - borderRadius, 2 * borderRadius, 2 * borderRadius, 270, -90)
        path.lineTo(0, height - shadowRadius)
        painter.drawPath(path)
        
        # Draw bottom right radius
        path = QPainterPath()
        radial = self._createRadialGradient(width - shadowRadius, height - shadowRadius, shadowRadius)
        painter.setBrush(radial)
        path.moveTo(width - shadowRadius, height)
        path.arcTo(width - 2 * shadowRadius, height - 2 * shadowRadius, 2 * shadowRadius, 2 * shadowRadius, 270, 90)
        path.lineTo(width - shadowMargin, height - shadowRadius)
        path.arcTo(width - shadowRadius - borderRadius, height - shadowRadius - borderRadius, 2 * borderRadius, 2 * borderRadius, 0, -90)
        path.lineTo(width - shadowRadius, height)
        painter.drawPath(path)
        
        # Draw left margin
        linear = self._createLinearGradient(shadowRadius, shadowRadius, 0, shadowRadius)
        painter.setBrush(linear)
        painter.drawRect(0, shadowRadius, shadowMargin, height - 2 * shadowRadius)
        
        # Draw right margin
        linear = self._createLinearGradient(width - shadowRadius, shadowRadius, width, shadowRadius)
        painter.setBrush(linear)
        painter.drawRect(width - shadowMargin, shadowRadius, shadowMargin, height - 2 * shadowRadius)
        
        # Draw top margin
        linear = self._createLinearGradient(shadowRadius, shadowRadius, shadowRadius, 0)
        painter.setBrush(linear)
        painter.drawRect(shadowRadius, 0, width - 2 * shadowRadius, shadowMargin)
        
        # Draw bottom margin
        linear = self._createLinearGradient(shadowRadius, height - shadowRadius, shadowRadius, height)
        painter.setBrush(linear)
        painter.drawRect(shadowRadius, height - shadowMargin, width - 2 * shadowRadius, shadowMargin)
コード例 #39
0
ファイル: drawing.py プロジェクト: anthrotype/trufont
def drawGlyphPoints(
        painter, glyph, scale, rect,
        drawStartPoints=True, drawOnCurves=True, drawOffCurves=True,
        drawCoordinates=False, drawSelection=True, onCurveColor=None,
        otherColor=None, backgroundColor=None):
    if onCurveColor is None:
        layer = glyph.layer
        if layer is not None and layer.color is not None:
            onCurveColor = colorToQColor(layer.color)
        else:
            onCurveColor = defaultColor("glyphOnCurvePoints")
    if otherColor is None:
        otherColor = defaultColor("glyphOtherPoints")
    if backgroundColor is None:
        backgroundColor = defaultColor("background")
    # get the outline data
    outlineData = glyph.getRepresentation("defconQt.OutlineInformation")
    points = []
    # start points
    if drawStartPoints and outlineData["startPoints"]:
        startWidth = startHeight = 15 * scale
        startHalf = startWidth / 2.0
        path = QPainterPath()
        for point, angle in outlineData["startPoints"]:
            x, y = point
            if angle is not None:
                path.moveTo(x, y)
                path.arcTo(x - startHalf, y - startHalf, startWidth,
                           startHeight, 180 - angle, 180)
                path.closeSubpath()
            else:
                path.addEllipse(
                    x - startHalf, y - startHalf, startWidth, startHeight)
        startPointColor = QColor(otherColor)
        aF = startPointColor.alphaF()
        startPointColor.setAlphaF(aF * .3)
        painter.fillPath(path, startPointColor)
    # handles
    if drawOffCurves and outlineData["offCurvePoints"]:
        painter.save()
        painter.setPen(otherColor)
        for pt1, pt2 in outlineData["bezierHandles"]:
            x1, y1 = pt1
            x2, y2 = pt2
            # TODO: should lineWidth account scale by default
            drawLine(painter, x1, y1, x2, y2, 1.0 * scale)
        painter.restore()
    # on curve
    if drawOnCurves and outlineData["onCurvePoints"]:
        width = 7 * scale
        half = width / 2.0
        smoothWidth = 8 * scale
        smoothHalf = smoothWidth / 2.0
        painter.save()
        path = QPainterPath()
        selectedPath = QPainterPath()
        for point in outlineData["onCurvePoints"]:
            x, y = point["point"]
            points.append((x, y))
            pointPath = QPainterPath()
            if point["smooth"]:
                x -= smoothHalf
                y -= smoothHalf
                pointPath.addEllipse(x, y, smoothWidth, smoothWidth)
            else:
                x -= half
                y -= half
                pointPath.addRect(x, y, width, width)
            if drawSelection and point["selected"]:
                selectedPath.addPath(pointPath)
            path.addPath(pointPath)
        pen = QPen(onCurveColor)
        pen.setWidthF(1.5 * scale)
        painter.setPen(pen)
        painter.fillPath(selectedPath, onCurveColor)
        painter.drawPath(path)
        painter.restore()
    # off curve
    if drawOffCurves and outlineData["offCurvePoints"]:
        # lines
        # points
        offWidth = 5 * scale
        offHalf = offWidth / 2.0
        path = QPainterPath()
        selectedPath = QPainterPath()
        for point in outlineData["offCurvePoints"]:
            x, y = point["point"]
            points.append((x, y))
            pointPath = QPainterPath()
            x -= offHalf
            y -= offHalf
            pointPath.addEllipse(x, y, offWidth, offWidth)
            if drawSelection and point["selected"]:
                selectedPath.addPath(pointPath)
            else:
                path.addPath(pointPath)
        pen = QPen(otherColor)
        pen.setWidthF(3.0 * scale)
        painter.save()
        painter.setPen(pen)
        painter.drawPath(path)
        painter.fillPath(path, QBrush(backgroundColor))
        painter.drawPath(selectedPath)
        painter.fillPath(selectedPath, QBrush(otherColor))
        painter.restore()
    # coordinates
    if drawCoordinates:
        otherColor = QColor(otherColor)
        otherColor.setAlphaF(otherColor.alphaF() * .6)
        painter.save()
        painter.setPen(otherColor)
        # TODO: decision + color
        font = painter.font()
        font.setPointSize(7)
        painter.setFont(font)
        for x, y in points:
            posX = x
            # TODO: We use + here because we align on top. Consider abstracting
            # yOffset.
            posY = y + 3
            x = round(x, 1)
            if int(x) == x:
                x = int(x)
            y = round(y, 1)
            if int(y) == y:
                y = int(y)
            text = "%d  %d" % (x, y)
            drawTextAtPoint(painter, text, posX, posY, scale,
                            xAlign="center", yAlign="top")
        painter.restore()
コード例 #40
0
def drawGlyphPoints(painter,
                    glyph,
                    scale,
                    rect,
                    drawStartPoints=True,
                    drawOnCurves=True,
                    drawOffCurves=True,
                    drawCoordinates=True,
                    onCurveColor=None,
                    otherColor=None,
                    backgroundColor=None):
    layer = glyph.layer
    onCurveColor = None
    if layer is not None:
        if layer.color is not None:
            onCurveColor = colorToQColor(layer.color)
    if onCurveColor is None:
        onCurveColor = defaultColor("glyphOnCurvePoints")
    if otherColor is None:
        otherColor = defaultColor("glyphOtherPoints")
    if backgroundColor is None:
        backgroundColor = defaultColor("background")
    # get the outline data
    outlineData = glyph.getRepresentation("defconQt.OutlineInformation")
    points = []
    # start points
    if drawStartPoints and outlineData["startPoints"]:
        startWidth = startHeight = 15 * scale
        startHalf = startWidth / 2.0
        path = QPainterPath()
        for point, angle in outlineData["startPoints"]:
            x, y = point
            if angle is not None:
                path.moveTo(x, y)
                path.arcTo(x - startHalf, y - startHalf, startWidth,
                           startHeight, 180 - angle, 180)
                path.closeSubpath()
            else:
                path.addEllipse(x - startHalf, y - startHalf, startWidth,
                                startHeight)
        startPointColor = QColor(otherColor)
        aF = startPointColor.alphaF()
        startPointColor.setAlphaF(aF * .3)
        painter.fillPath(path, startPointColor)
    # off curve
    if drawOffCurves and outlineData["offCurvePoints"]:
        # lines
        painter.save()
        painter.setPen(otherColor)
        for pt1, pt2 in outlineData["bezierHandles"]:
            x1, y1 = pt1
            x2, y2 = pt2
            # TODO: should lineWidth account scale by default
            drawLine(painter, x1, y1, x2, y2, 1.0 * scale)
        # points
        offWidth = 5 * scale
        offHalf = offWidth / 2.0
        path = QPainterPath()
        selectedPath = QPainterPath()
        for point in outlineData["offCurvePoints"]:
            x, y = point["point"]
            points.append((x, y))
            pointPath = QPainterPath()
            x -= offHalf
            y -= offHalf
            pointPath.addEllipse(x, y, offWidth, offWidth)
            if point["selected"]:
                selectedPath.addPath(pointPath)
            else:
                path.addPath(pointPath)
        pen = QPen(otherColor)
        pen.setWidthF(3.0 * scale)
        painter.setPen(pen)
        painter.drawPath(path)
        painter.fillPath(path, QBrush(backgroundColor))
        painter.drawPath(selectedPath)
        painter.fillPath(selectedPath, QBrush(otherColor))
        painter.restore()
    # on curve
    if drawOnCurves and outlineData["onCurvePoints"]:
        width = 7 * scale
        half = width / 2.0
        smoothWidth = 8 * scale
        smoothHalf = smoothWidth / 2.0
        painter.save()
        path = QPainterPath()
        selectedPath = QPainterPath()
        for point in outlineData["onCurvePoints"]:
            x, y = point["point"]
            points.append((x, y))
            pointPath = QPainterPath()
            if point["smooth"]:
                x -= smoothHalf
                y -= smoothHalf
                pointPath.addEllipse(x, y, smoothWidth, smoothWidth)
            else:
                x -= half
                y -= half
                pointPath.addRect(x, y, width, width)
            if point["selected"]:
                selectedPath.addPath(pointPath)
            path.addPath(pointPath)
        pen = QPen(onCurveColor)
        pen.setWidthF(1.5 * scale)
        painter.setPen(pen)
        painter.fillPath(selectedPath, onCurveColor)
        painter.drawPath(path)
        painter.restore()
    # coordinates
    if drawCoordinates:
        otherColor = QColor(otherColor)
        otherColor.setAlphaF(otherColor.alphaF() * .6)
        painter.save()
        painter.setPen(otherColor)
        for x, y in points:
            posX = x
            # TODO: We use + here because we align on top. Consider abstracting
            # yOffset.
            posY = y + 3
            x = round(x, 1)
            if int(x) == x:
                x = int(x)
            y = round(y, 1)
            if int(y) == y:
                y = int(y)
            text = "%d  %d" % (x, y)
            drawTextAtPoint(painter,
                            text,
                            posX,
                            posY,
                            scale,
                            xAlign="center",
                            yAlign="top")
        painter.restore()
コード例 #41
0
ファイル: Keyboard.py プロジェクト: umilab/ubiquity
    def paintEvent(self, pe):
        p = QPainter(self)
        p.setRenderHint(QPainter.Antialiasing)

        pen = QPen()
        pen.setWidth(1)
        pen.setColor(QColor(0x8c, 0xa3, 0xb0))
        p.setPen(pen)

        p.setBrush(QColor(0xe4, 0xec, 0xf4))

        rx = 6

        space = self.space
        w = self.usable_width
        kw = self.key_w

        def drawRow(row, sx, sy, last_end=False):
            x = sx
            y = sy
            keys = row
            rw = w - sx
            i = 0
            for k in keys:
                rect = QRectF(x, y, kw, kw)

                if i == len(keys) - 1 and last_end:
                    rect.setWidth(rw)

                p.drawRoundedRect(rect, rx, rx)
                p.setPen(Qt.black)

                rect.adjust(5, 1, 0, 0)

                p.setFont(self.lowerFont)
                p.drawText(
                    rect, Qt.AlignLeft | Qt.AlignBottom, self.regular_text(k))

                p.setFont(self.upperFont)
                p.drawText(
                    rect, Qt.AlignLeft | Qt.AlignTop, self.shift_text(k))

                rw = rw - space - kw
                x = x + space + kw
                i = i + 1

                p.setPen(pen)
            return (x, rw)

        x = .5
        y = .5

        keys = self.kb["keys"]
        ext_return = self.kb["extended_return"]

        first_key_w = 0

        rows = 4
        remaining_x = [0, 0, 0, 0]
        remaining_widths = [0, 0, 0, 0]

        for i in range(0, rows):
            if first_key_w > 0:
                first_key_w = first_key_w * 1.375

                if self.kb == self.kb_105 and i == 3:
                    first_key_w = kw * 1.275

                rect = QRectF(x, y, first_key_w, kw)
                p.drawRoundedRect(rect, rx, rx)
                x = x + first_key_w + space
            else:
                first_key_w = kw

            x, rw = drawRow(keys[i], x, y, i == 1 and not ext_return)

            remaining_x[i] = x
            remaining_widths[i] = rw

            if i != 1 and i != 2:
                rect = QRectF(x, y, rw, kw)
                p.drawRoundedRect(rect, rx, rx)

            x = .5
            y = y + space + kw

        if ext_return:
            rx = rx * 2
            x1 = remaining_x[1]
            y1 = .5 + kw * 1 + space * 1
            w1 = remaining_widths[1]
            x2 = remaining_x[2]
            y2 = .5 + kw * 2 + space * 2

            # this is some serious crap... but it has to be so
            # maybe one day keyboards won't look like this...
            # one can only hope
            pp = QPainterPath()
            pp.moveTo(x1, y1 + rx)
            pp.arcTo(x1, y1, rx, rx, 180, -90)
            pp.lineTo(x1 + w1 - rx, y1)
            pp.arcTo(x1 + w1 - rx, y1, rx, rx, 90, -90)
            pp.lineTo(x1 + w1, y2 + kw - rx)
            pp.arcTo(x1 + w1 - rx, y2 + kw - rx, rx, rx, 0, -90)
            pp.lineTo(x2 + rx, y2 + kw)
            pp.arcTo(x2, y2 + kw - rx, rx, rx, -90, -90)
            pp.lineTo(x2, y1 + kw)
            pp.lineTo(x1 + rx, y1 + kw)
            pp.arcTo(x1, y1 + kw - rx, rx, rx, -90, -90)
            pp.closeSubpath()

            p.drawPath(pp)
        else:
            x = remaining_x[2]
            y = .5 + kw * 2 + space * 2
            rect = QRectF(x, y, remaining_widths[2], kw)
            p.drawRoundedRect(rect, rx, rx)

        QWidget.paintEvent(self, pe)
コード例 #42
0
ファイル: painterpaths.py プロジェクト: death-finger/Scripts
    def __init__(self):
        super(Window, self).__init__()

        rectPath = QPainterPath()
        rectPath.moveTo(20.0, 30.0)
        rectPath.lineTo(80.0, 30.0)
        rectPath.lineTo(80.0, 70.0)
        rectPath.lineTo(20.0, 70.0)
        rectPath.closeSubpath()

        roundRectPath = QPainterPath()
        roundRectPath.moveTo(80.0, 35.0)
        roundRectPath.arcTo(70.0, 30.0, 10.0, 10.0, 0.0, 90.0)
        roundRectPath.lineTo(25.0, 30.0)
        roundRectPath.arcTo(20.0, 30.0, 10.0, 10.0, 90.0, 90.0)
        roundRectPath.lineTo(20.0, 65.0)
        roundRectPath.arcTo(20.0, 60.0, 10.0, 10.0, 180.0, 90.0)
        roundRectPath.lineTo(75.0, 70.0)
        roundRectPath.arcTo(70.0, 60.0, 10.0, 10.0, 270.0, 90.0)
        roundRectPath.closeSubpath()

        ellipsePath = QPainterPath()
        ellipsePath.moveTo(80.0, 50.0)
        ellipsePath.arcTo(20.0, 30.0, 60.0, 40.0, 0.0, 360.0)

        piePath = QPainterPath()
        piePath.moveTo(50.0, 50.0)
        piePath.lineTo(65.0, 32.6795)
        piePath.arcTo(20.0, 30.0, 60.0, 40.0, 60.0, 240.0)
        piePath.closeSubpath()

        polygonPath = QPainterPath()
        polygonPath.moveTo(10.0, 80.0)
        polygonPath.lineTo(20.0, 10.0)
        polygonPath.lineTo(80.0, 30.0)
        polygonPath.lineTo(90.0, 70.0)
        polygonPath.closeSubpath()

        groupPath = QPainterPath()
        groupPath.moveTo(60.0, 40.0)
        groupPath.arcTo(20.0, 20.0, 40.0, 40.0, 0.0, 360.0)
        groupPath.moveTo(40.0, 40.0)
        groupPath.lineTo(40.0, 80.0)
        groupPath.lineTo(80.0, 80.0)
        groupPath.lineTo(80.0, 40.0)
        groupPath.closeSubpath()

        textPath = QPainterPath()
        timesFont = QFont('Times', 50)
        timesFont.setStyleStrategy(QFont.ForceOutline)
        textPath.addText(10, 70, timesFont, "Qt")

        bezierPath = QPainterPath()
        bezierPath.moveTo(20, 30)
        bezierPath.cubicTo(80, 0, 50, 50, 80, 80)

        starPath = QPainterPath()
        starPath.moveTo(90, 50)
        for i in range(1, 5):
            starPath.lineTo(50 + 40 * cos(0.8 * i * pi),
                    50 + 40 * sin(0.8 * i * pi))
        starPath.closeSubpath()

        self.renderAreas = [RenderArea(rectPath), RenderArea(roundRectPath),
                RenderArea(ellipsePath), RenderArea(piePath),
                RenderArea(polygonPath), RenderArea(groupPath),
                RenderArea(textPath), RenderArea(bezierPath),
                RenderArea(starPath)]
        assert len(self.renderAreas) == 9

        self.fillRuleComboBox = QComboBox()
        self.fillRuleComboBox.addItem("Odd Even", Qt.OddEvenFill)
        self.fillRuleComboBox.addItem("Winding", Qt.WindingFill)

        fillRuleLabel = QLabel("Fill &Rule:")
        fillRuleLabel.setBuddy(self.fillRuleComboBox)

        self.fillColor1ComboBox = QComboBox()
        self.populateWithColors(self.fillColor1ComboBox)
        self.fillColor1ComboBox.setCurrentIndex(
                self.fillColor1ComboBox.findText("mediumslateblue"))

        self.fillColor2ComboBox = QComboBox()
        self.populateWithColors(self.fillColor2ComboBox)
        self.fillColor2ComboBox.setCurrentIndex(
                self.fillColor2ComboBox.findText("cornsilk"))

        fillGradientLabel = QLabel("&Fill Gradient:")
        fillGradientLabel.setBuddy(self.fillColor1ComboBox)

        fillToLabel = QLabel("to")
        fillToLabel.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)

        self.penWidthSpinBox = QSpinBox()
        self.penWidthSpinBox.setRange(0, 20)

        penWidthLabel = QLabel("&Pen Width:")
        penWidthLabel.setBuddy(self.penWidthSpinBox)

        self.penColorComboBox = QComboBox()
        self.populateWithColors(self.penColorComboBox)
        self.penColorComboBox.setCurrentIndex(
                self.penColorComboBox.findText('darkslateblue'))

        penColorLabel = QLabel("Pen &Color:")
        penColorLabel.setBuddy(self.penColorComboBox)

        self.rotationAngleSpinBox = QSpinBox()
        self.rotationAngleSpinBox.setRange(0, 359)
        self.rotationAngleSpinBox.setWrapping(True)
        self.rotationAngleSpinBox.setSuffix(u'\N{DEGREE SIGN}')

        rotationAngleLabel = QLabel("&Rotation Angle:")
        rotationAngleLabel.setBuddy(self.rotationAngleSpinBox)

        self.fillRuleComboBox.activated.connect(self.fillRuleChanged)
        self.fillColor1ComboBox.activated.connect(self.fillGradientChanged)
        self.fillColor2ComboBox.activated.connect(self.fillGradientChanged)
        self.penColorComboBox.activated.connect(self.penColorChanged)

        for i in range(Window.NumRenderAreas):
            self.penWidthSpinBox.valueChanged.connect(self.renderAreas[i].setPenWidth)
            self.rotationAngleSpinBox.valueChanged.connect(self.renderAreas[i].setRotationAngle)

        topLayout = QGridLayout()
        for i in range(Window.NumRenderAreas):
            topLayout.addWidget(self.renderAreas[i], i / 3, i % 3)

        mainLayout = QGridLayout()
        mainLayout.addLayout(topLayout, 0, 0, 1, 4)
        mainLayout.addWidget(fillRuleLabel, 1, 0)
        mainLayout.addWidget(self.fillRuleComboBox, 1, 1, 1, 3)
        mainLayout.addWidget(fillGradientLabel, 2, 0)
        mainLayout.addWidget(self.fillColor1ComboBox, 2, 1)
        mainLayout.addWidget(fillToLabel, 2, 2)
        mainLayout.addWidget(self.fillColor2ComboBox, 2, 3)
        mainLayout.addWidget(penWidthLabel, 3, 0)
        mainLayout.addWidget(self.penWidthSpinBox, 3, 1, 1, 3)
        mainLayout.addWidget(penColorLabel, 4, 0)
        mainLayout.addWidget(self.penColorComboBox, 4, 1, 1, 3)
        mainLayout.addWidget(rotationAngleLabel, 5, 0)
        mainLayout.addWidget(self.rotationAngleSpinBox, 5, 1, 1, 3)
        self.setLayout(mainLayout)

        self.fillRuleChanged()
        self.fillGradientChanged()
        self.penColorChanged()
        self.penWidthSpinBox.setValue(2)

        self.setWindowTitle("Painter Paths")
コード例 #43
0
class RCircleSegment(QObject):
    def __init__(self,
                 radius: float,
                 center_x: float,
                 center_y: float,
                 start_angle: float,
                 end_angle: float,
                 clockwise,
                 line_width: float,
                 line_color=Qt.black,
                 fill_color=Qt.transparent):
        super().__init__()
        # The supporting rectangle
        if end_angle < start_angle:
            end_angle += 2 * math.pi
        start_angle = -start_angle
        end_angle = -end_angle
        shift = end_angle - start_angle
        if clockwise:
            shift = -shift - 2 * math.pi
        x, y = center_x - radius, center_y - radius
        self.rect = QRectF(x, y, 2 * radius, 2 * radius)
        # The underlying QGraphicsPathItem
        self.painter_path = QPainterPath(
            QPointF(center_x + math.cos(start_angle) * radius,
                    center_y - math.sin(start_angle) * radius))
        self.painter_path.arcTo(self.rect, math.degrees(start_angle),
                                math.degrees(shift))
        self.path = QGraphicsPathItem(self.painter_path)
        self.path.setBrush(QtGui.QBrush(fill_color))
        pen = QPen()
        pen.setWidthF(line_width)
        pen.setColor(line_color)
        self.path.setPen(pen)
        self._visible = 1

    # def x(self):
    #     return self._pos.x()
    #
    # def y(self):
    #     return self._pos.y()
    #
    # # The following functions are for animation support
    #
    # @pyqtProperty(QPointF)
    # def pos(self):
    #     return self._pos
    #
    # @pos.setter
    # def pos(self, value):
    #     self.rect = QRectF(value.x() - self._radius, value.y() - self._radius, 2 * self._radius, 2 * self._radius)
    #     self.path.setRect(self.rect)
    #     self._pos = value
    #
    @pyqtProperty(int)
    def visible(self):
        return self._visible

    @visible.setter
    def visible(self, value):
        if (value > 0):
            self.path.show()
        else:
            self.path.hide()
        self._visible = value
コード例 #44
0
ファイル: pyqt_backend.py プロジェクト: hh-wu/ezdxf
 def draw(self, path: qg.QPainterPath):
     path.arcTo(self.rect, self.start_angle, self.span_angle)
コード例 #45
0
    def __init__(self):
        super(Window, self).__init__()

        rectPath = QPainterPath()
        rectPath.moveTo(20.0, 30.0)
        rectPath.lineTo(80.0, 30.0)
        rectPath.lineTo(80.0, 70.0)
        rectPath.lineTo(20.0, 70.0)
        rectPath.closeSubpath()

        roundRectPath = QPainterPath()
        roundRectPath.moveTo(80.0, 35.0)
        roundRectPath.arcTo(70.0, 30.0, 10.0, 10.0, 0.0, 90.0)
        roundRectPath.lineTo(25.0, 30.0)
        roundRectPath.arcTo(20.0, 30.0, 10.0, 10.0, 90.0, 90.0)
        roundRectPath.lineTo(20.0, 65.0)
        roundRectPath.arcTo(20.0, 60.0, 10.0, 10.0, 180.0, 90.0)
        roundRectPath.lineTo(75.0, 70.0)
        roundRectPath.arcTo(70.0, 60.0, 10.0, 10.0, 270.0, 90.0)
        roundRectPath.closeSubpath()

        ellipsePath = QPainterPath()
        ellipsePath.moveTo(80.0, 50.0)
        ellipsePath.arcTo(20.0, 30.0, 60.0, 40.0, 0.0, 360.0)

        piePath = QPainterPath()
        piePath.moveTo(50.0, 50.0)
        piePath.lineTo(65.0, 32.6795)
        piePath.arcTo(20.0, 30.0, 60.0, 40.0, 60.0, 240.0)
        piePath.closeSubpath()

        polygonPath = QPainterPath()
        polygonPath.moveTo(10.0, 80.0)
        polygonPath.lineTo(20.0, 10.0)
        polygonPath.lineTo(80.0, 30.0)
        polygonPath.lineTo(90.0, 70.0)
        polygonPath.closeSubpath()

        groupPath = QPainterPath()
        groupPath.moveTo(60.0, 40.0)
        groupPath.arcTo(20.0, 20.0, 40.0, 40.0, 0.0, 360.0)
        groupPath.moveTo(40.0, 40.0)
        groupPath.lineTo(40.0, 80.0)
        groupPath.lineTo(80.0, 80.0)
        groupPath.lineTo(80.0, 40.0)
        groupPath.closeSubpath()

        textPath = QPainterPath()
        timesFont = QFont('Times', 50)
        timesFont.setStyleStrategy(QFont.ForceOutline)
        textPath.addText(10, 70, timesFont, "Qt")

        bezierPath = QPainterPath()
        bezierPath.moveTo(20, 30)
        bezierPath.cubicTo(80, 0, 50, 50, 80, 80)

        starPath = QPainterPath()
        starPath.moveTo(90, 50)
        for i in range(1, 5):
            starPath.lineTo(50 + 40 * cos(0.8 * i * pi),
                            50 + 40 * sin(0.8 * i * pi))
        starPath.closeSubpath()

        self.renderAreas = [
            RenderArea(rectPath),
            RenderArea(roundRectPath),
            RenderArea(ellipsePath),
            RenderArea(piePath),
            RenderArea(polygonPath),
            RenderArea(groupPath),
            RenderArea(textPath),
            RenderArea(bezierPath),
            RenderArea(starPath)
        ]
        assert len(self.renderAreas) == 9

        self.fillRuleComboBox = QComboBox()
        self.fillRuleComboBox.addItem("Odd Even", Qt.OddEvenFill)
        self.fillRuleComboBox.addItem("Winding", Qt.WindingFill)

        fillRuleLabel = QLabel("Fill &Rule:")
        fillRuleLabel.setBuddy(self.fillRuleComboBox)

        self.fillColor1ComboBox = QComboBox()
        self.populateWithColors(self.fillColor1ComboBox)
        self.fillColor1ComboBox.setCurrentIndex(
            self.fillColor1ComboBox.findText("mediumslateblue"))

        self.fillColor2ComboBox = QComboBox()
        self.populateWithColors(self.fillColor2ComboBox)
        self.fillColor2ComboBox.setCurrentIndex(
            self.fillColor2ComboBox.findText("cornsilk"))

        fillGradientLabel = QLabel("&Fill Gradient:")
        fillGradientLabel.setBuddy(self.fillColor1ComboBox)

        fillToLabel = QLabel("to")
        fillToLabel.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)

        self.penWidthSpinBox = QSpinBox()
        self.penWidthSpinBox.setRange(0, 20)

        penWidthLabel = QLabel("&Pen Width:")
        penWidthLabel.setBuddy(self.penWidthSpinBox)

        self.penColorComboBox = QComboBox()
        self.populateWithColors(self.penColorComboBox)
        self.penColorComboBox.setCurrentIndex(
            self.penColorComboBox.findText('darkslateblue'))

        penColorLabel = QLabel("Pen &Color:")
        penColorLabel.setBuddy(self.penColorComboBox)

        self.rotationAngleSpinBox = QSpinBox()
        self.rotationAngleSpinBox.setRange(0, 359)
        self.rotationAngleSpinBox.setWrapping(True)
        self.rotationAngleSpinBox.setSuffix(u'\N{DEGREE SIGN}')

        rotationAngleLabel = QLabel("&Rotation Angle:")
        rotationAngleLabel.setBuddy(self.rotationAngleSpinBox)

        self.fillRuleComboBox.activated.connect(self.fillRuleChanged)
        self.fillColor1ComboBox.activated.connect(self.fillGradientChanged)
        self.fillColor2ComboBox.activated.connect(self.fillGradientChanged)
        self.penColorComboBox.activated.connect(self.penColorChanged)

        for i in range(Window.NumRenderAreas):
            self.penWidthSpinBox.valueChanged.connect(
                self.renderAreas[i].setPenWidth)
            self.rotationAngleSpinBox.valueChanged.connect(
                self.renderAreas[i].setRotationAngle)

        topLayout = QGridLayout()
        for i in range(Window.NumRenderAreas):
            topLayout.addWidget(self.renderAreas[i], i / 3, i % 3)

        mainLayout = QGridLayout()
        mainLayout.addLayout(topLayout, 0, 0, 1, 4)
        mainLayout.addWidget(fillRuleLabel, 1, 0)
        mainLayout.addWidget(self.fillRuleComboBox, 1, 1, 1, 3)
        mainLayout.addWidget(fillGradientLabel, 2, 0)
        mainLayout.addWidget(self.fillColor1ComboBox, 2, 1)
        mainLayout.addWidget(fillToLabel, 2, 2)
        mainLayout.addWidget(self.fillColor2ComboBox, 2, 3)
        mainLayout.addWidget(penWidthLabel, 3, 0)
        mainLayout.addWidget(self.penWidthSpinBox, 3, 1, 1, 3)
        mainLayout.addWidget(penColorLabel, 4, 0)
        mainLayout.addWidget(self.penColorComboBox, 4, 1, 1, 3)
        mainLayout.addWidget(rotationAngleLabel, 5, 0)
        mainLayout.addWidget(self.rotationAngleSpinBox, 5, 1, 1, 3)
        self.setLayout(mainLayout)

        self.fillRuleChanged()
        self.fillGradientChanged()
        self.penColorChanged()
        self.penWidthSpinBox.setValue(2)

        self.setWindowTitle("Painter Paths")