def drawScaleContents(self, painter, center, radius):
        dir = 90#360 - int(roud(self.origin() - self.value()))
        arc = 90 #+ int(round(self.gradient * 90))
        skyColor = QColor(38, 151, 221)
        painter.save()
        painter.setBrush(skyColor)
        painter.drawChord(
            self.scaleContentsRect(), (dir - arc)*16, 2*arc*16)
        direction1 = self.value() * M_PI / 180.0 
        direction2 = self.value() * M_PI / 180.0 +M_PI_2

        triangleSize = qRound(radius * 0.15)
        p0 = (QPoint(center.x() + 0, center.y() + 0))
        p1 = qwtPolar2Pos(p0, 2, direction2)
        pa = QPolygon(3)
        pa.setPoint(0, qwtPolar2Pos(p1, 2 * triangleSize, direction2))
        pa.setPoint(1, qwtPolar2Pos(p1, triangleSize, direction2 + M_PI_2))
        pa.setPoint(2, qwtPolar2Pos(p1, triangleSize, direction2 - M_PI_2))
        color = self.palette().color(QPalette.Text)
        painter.setBrush(color)
        painter.drawPolygon(pa)

        p0 = (QPoint(center.x() + 0, center.y() + 0))
        color = self.palette().color(QPalette.Text)
        painter.setBrush(color)
        painter.setPen(QPen(color, 3))
        painter.drawLine(qwtPolar2Pos(p0, radius - 3, direction1), qwtPolar2Pos(p0, radius - 3, direction1 - M_PI))

        painter.restore()
    def drawScaleContents(self, painter, center, radius):
        dir = 90  #360 - int(roud(self.origin() - self.value()))
        arc = 90  #+ int(round(self.gradient * 90))
        skyColor = QColor(38, 151, 221)
        painter.save()
        painter.setBrush(skyColor)
        painter.drawChord(self.scaleContentsRect(), (dir - arc) * 16,
                          2 * arc * 16)
        direction1 = self.value() * M_PI / 180.0
        direction2 = self.value() * M_PI / 180.0 + M_PI_2

        triangleSize = qRound(radius * 0.15)
        p0 = (QPoint(center.x() + 0, center.y() + 0))
        p1 = qwtPolar2Pos(p0, 2, direction2)
        pa = QPolygon(3)
        pa.setPoint(0, qwtPolar2Pos(p1, 2 * triangleSize, direction2))
        pa.setPoint(1, qwtPolar2Pos(p1, triangleSize, direction2 + M_PI_2))
        pa.setPoint(2, qwtPolar2Pos(p1, triangleSize, direction2 - M_PI_2))
        color = self.palette().color(QPalette.Text)
        painter.setBrush(color)
        painter.drawPolygon(pa)

        p0 = (QPoint(center.x() + 0, center.y() + 0))
        color = self.palette().color(QPalette.Text)
        painter.setBrush(color)
        painter.setPen(QPen(color, 3))
        painter.drawLine(qwtPolar2Pos(p0, radius - 3, direction1),
                         qwtPolar2Pos(p0, radius - 3, direction1 - M_PI))

        painter.restore()
Example #3
0
    def _paint_icon(self, iconic, painter, rect, mode, state, options):
        """Paint a single icon."""
        painter.save()
        color = options['color']
        char = options['char']

        color_options = {
            QIcon.On: {
                QIcon.Normal: (options['color_on'], options['on']),
                QIcon.Disabled: (options['color_on_disabled'],
                                 options['on_disabled']),
                QIcon.Active: (options['color_on_active'],
                               options['on_active']),
                QIcon.Selected: (options['color_on_selected'],
                                 options['on_selected']) 
            },

            QIcon.Off: {
                QIcon.Normal: (options['color_off'], options['off']),
                QIcon.Disabled: (options['color_off_disabled'],
                                 options['off_disabled']),
                QIcon.Active: (options['color_off_active'],
                               options['off_active']),
                QIcon.Selected: (options['color_off_selected'],
                                 options['off_selected']) 
            }
        }

        color, char = color_options[state][mode]

        painter.setPen(QColor(color))

        # A 16 pixel-high icon yields a font size of 14, which is pixel perfect
        # for font-awesome. 16 * 0.875 = 14
        # The reason why the glyph size is smaller than the icon size is to
        # account for font bearing.

        draw_size = 0.875 * qRound(rect.height() * options['scale_factor'])
        prefix = options['prefix']

        # Animation setup hook
        animation = options.get('animation')
        if animation is not None:
            animation.setup(self, painter, rect)

        painter.setFont(iconic.font(prefix, draw_size))
        if 'offset' in options:
            rect = QRect(rect)
            rect.translate(options['offset'][0] * rect.width(),
                           options['offset'][1] * rect.height())

        painter.setOpacity(options.get('opacity', 1.0))

        painter.drawText(rect, Qt.AlignCenter | Qt.AlignVCenter, char)
        painter.restore()
 def drawScale(self, painter, center, radius, origin, minArc, maxArc):
     direction1 = M_PI_2
     triangleSize = qRound(radius * 0.15)
     p0 = (QPoint(center.x() + 0, center.y() + 0))
     p1 = qwtPolar2Pos(p0, radius - 2 * triangleSize + 20, direction1)
     pa = QPolygon(3)
     pa.setPoint(0, qwtPolar2Pos(p1, -1.6 * triangleSize, direction1))
     pa.setPoint(1, qwtPolar2Pos(p1, triangleSize, direction1 + M_PI_2))
     pa.setPoint(2, qwtPolar2Pos(p1, triangleSize, direction1 - M_PI_2))
     color = self.palette().color(QPalette.Text)
     painter.setBrush(color)
     painter.drawPolygon(pa)
 def drawScale(self, painter, center, radius, origin, minArc, maxArc):
     direction1 = M_PI_2
     triangleSize = qRound(radius * 0.15)
     p0 = (QPoint(center.x() + 0, center.y() + 0))
     p1 = qwtPolar2Pos(p0, radius - 2 * triangleSize +20 , direction1)
     pa = QPolygon(3)
     pa.setPoint(0, qwtPolar2Pos(p1, -1.6 * triangleSize,direction1))
     pa.setPoint(1, qwtPolar2Pos(p1, triangleSize, direction1 + M_PI_2))
     pa.setPoint(2, qwtPolar2Pos(p1, triangleSize, direction1 - M_PI_2))
     color = self.palette().color(QPalette.Text)
     painter.setBrush(color)
     painter.drawPolygon(pa)
 def draw(self, painter, center, length, direction, cg):
     direction1 = direction * M_PI / 180.0
     triangleSize = qRound(length * 0.1)
     painter.save()
     p0 = (QPoint(center.x() + 0, center.y() + 0))
     p1 = qwtPolar2Pos(p0, length - 2 * triangleSize - 2, direction1)
     pa = QPolygon(3)
     pa.setPoint(0, qwtPolar2Pos(p1, 2 * triangleSize, direction1))
     pa.setPoint(1, qwtPolar2Pos(p1, triangleSize, direction1 + M_PI_2))
     pa.setPoint(2, qwtPolar2Pos(p1, triangleSize, direction1 - M_PI_2))
     color = self.palette().color(cg, QPalette.Text)
     painter.setBrush(color)
     painter.drawPolygon(pa)
     painter.setPen(QPen(color, 3))
     painter.drawLine(qwtPolar2Pos(p0, length - 2, direction1 + M_PI_2), qwtPolar2Pos(p0, length - 2, direction1 - M_PI_2))
     painter.restore()
 def draw(self, painter, center, length, direction, cg):
     direction1 = direction * M_PI / 180.0
     triangleSize = qRound(length * 0.1)
     painter.save()
     p0 = (QPoint(center.x() + 0, center.y() + 0))
     p1 = qwtPolar2Pos(p0, length - 2 * triangleSize - 2, direction1)
     pa = QPolygon(3)
     pa.setPoint(0, qwtPolar2Pos(p1, 2 * triangleSize, direction1))
     pa.setPoint(1, qwtPolar2Pos(p1, triangleSize, direction1 + M_PI_2))
     pa.setPoint(2, qwtPolar2Pos(p1, triangleSize, direction1 - M_PI_2))
     color = self.palette().color(cg, QPalette.Text)
     painter.setBrush(color)
     painter.drawPolygon(pa)
     painter.setPen(QPen(color, 3))
     painter.drawLine(qwtPolar2Pos(p0, length - 2, direction1 + M_PI_2),
                      qwtPolar2Pos(p0, length - 2, direction1 - M_PI_2))
     painter.restore()
Example #8
0
    def rgb(self, interval, value):
        if (qIsNaN(value)):
            return 0

        width = interval.width()
        if (width <= 0):
            return 0

        if (value <= interval.minValue()):
            return self.d_rgbMin

        if (value >= interval.maxValue()):
            return self.d_rgbMax

        ratio = (value - interval.minValue()) / width
        hue = self.d_hue1 + qRound(ratio * (self.d_hue2 - self.d_hue1))

        if (hue >= 360):
            hue -= 360
            if (hue >= 360):
                hue = hue % 360
        return self.d_rgbTable[hue]