Python QStyleOption.initFrom方法代码示例

# 需要导入模块: from PyQt5.QtWidgets import QStyleOption [as 别名]
# 或者: from PyQt5.QtWidgets.QStyleOption import initFrom [as 别名]
    def paintEvent(self, event):
        # Draw backgrounds according to css
        styleOpt = QStyleOption()
        styleOpt.initFrom(self)
        p = QPainter(self)
        p.setRenderHint(QPainter.Antialiasing)
        self.style().drawPrimitive(QStyle.PE_Widget, styleOpt, p, self)

        if self.values == None or len(self.values) == 0: return

        # print(len(self.values))

        r = self.rect()
        dx = r.width() / float(self.datapoints - 1)

        # Build a path from the readings
        path = QPainterPath()
        path.moveTo(r.bottomRight())
        i = 0
        for reading in reversed(self.values):
            pt = QPointF(r.width() - i*dx, (1.0 - reading) * r.height())
            path.lineTo(pt)
            i = i + 1
        path.lineTo(path.currentPosition().x(), r.height())
        path.closeSubpath()

        # Use foreground color for graph
        gcolor = styleOpt.palette.color(QPalette.Text)
        p.setBrush(gcolor)
        p.setPen(gcolor)
        p.drawPath(path)

# 需要导入模块: from PyQt5.QtWidgets import QStyleOption [as 别名]
# 或者: from PyQt5.QtWidgets.QStyleOption import initFrom [as 别名]
    def paintEvent(self, event):
        option=QStyleOption()
        option.initFrom(self)

        h=option.rect.height()
        w=option.rect.width()
        if self.m_shape in (QLed.Triangle, QLed.Round):
            aspect=(4/3.0) if self.m_shape==QLed.Triangle else 2.0
            ah=w/aspect
            aw=w
            if ah>h:
                ah=h
                aw=h*aspect
            x=abs(aw-w)/2.0
            y=abs(ah-h)/2.0
            bounds=QRectF(x,y,aw,ah)
        else:
            size=min(w,h)
            x=abs(size-w)/2.0
            y=abs(size-h)/2.0
            bounds=QRectF(x,y,size,size)

        painter=QPainter(self);
        painter.setRenderHint(QPainter.Antialiasing, True);

        (dark_r,dark_g,dark_b)=self.colours[self.m_onColour if self.m_value else self.m_offColour]

        dark_str="rgb(%d,%d,%d)" % (dark_r,dark_g,dark_b)
        light_str="rgb(%d,%d,%d)" % self.adjust(dark_r,dark_g,dark_b)

        shape = self.shapes[self.m_shape] % (dark_str, light_str)
        shape = shape.encode('utf-8')
        self.renderer.load(QByteArray(shape))
        self.renderer.render(painter, bounds)

# 需要导入模块: from PyQt5.QtWidgets import QStyleOption [as 别名]
# 或者: from PyQt5.QtWidgets.QStyleOption import initFrom [as 别名]
 def paintEvent(self, event):
     """由于继承的问题会导致子控件QWidget无法通过QSS设置样式,需要重写该方法"""
     option = QStyleOption()
     option.initFrom(self)
     painter = QPainter(self)
     self.style().drawPrimitive(QStyle.PE_Widget, option, painter, self)
     QWidget.paintEvent(self, event)
     # super(BaseWidget, self).paintEvent(event)

# 需要导入模块: from PyQt5.QtWidgets import QStyleOption [as 别名]
# 或者: from PyQt5.QtWidgets.QStyleOption import initFrom [as 别名]
 def getSyleOptions(self):
     options = QStyleOption()
     options.initFrom(self.clazz)
     size = options.rect.size()
     size.transpose()
     options.rect.setSize(size)
     options.features = QStyleOption.SO_Default
     return options

# 需要导入模块: from PyQt5.QtWidgets import QStyleOption [as 别名]
# 或者: from PyQt5.QtWidgets.QStyleOption import initFrom [as 别名]
 def paintEvent(self, paintEvent):
     """
     This is needed for the widget to pick the stylesheet.
     :type paintEvent: QPaintEvent
     """
     option = QStyleOption()
     option.initFrom(self)
     painter = QPainter(self)
     style = self.style()
     style.drawPrimitive(QStyle.PE_Widget, option, painter, self)

# 需要导入模块: from PyQt5.QtWidgets import QStyleOption [as 别名]
# 或者: from PyQt5.QtWidgets.QStyleOption import initFrom [as 别名]
 def paintEvent(self, QPaintEvent):
     """
     self is derived from QWidget, Stylesheets don't work unless \
     paintEvent is reimplemented.y
     at the same time, if self is derived from QFrame, this isn't needed.
     """
     option = QStyleOption()
     option.initFrom(self)
     painter = QPainter(self)
     style = self.style()
     style.drawPrimitive(QStyle.PE_Widget, option, painter, self)

# 需要导入模块: from PyQt5.QtWidgets import QStyleOption [as 别名]
# 或者: from PyQt5.QtWidgets.QStyleOption import initFrom [as 别名]
 def paintEvent(self, event):
     QToolButton.paintEvent(self, event)
     painter = QPainter(self)
     opt = QStyleOption()
     opt.initFrom(self)
     opt.rect = QRect(6, self.rect().center().y() - 3, 8, 8)
     opt.rect.translate(0, -3)
     style = self.style()
     style.drawPrimitive(QStyle.PE_IndicatorArrowUp, opt, painter, self)
     opt.rect.translate(0, 6)
     style.drawPrimitive(QStyle.PE_IndicatorArrowDown, opt, painter, self)

# 需要导入模块: from PyQt5.QtWidgets import QStyleOption [as 别名]
# 或者: from PyQt5.QtWidgets.QStyleOption import initFrom [as 别名]
    def paintEvent(self, _event):
        """Paint the arrow.

        Args:
            _paint: The QPaintEvent (unused).
        """
        opt = QStyleOption()
        opt.initFrom(self)
        painter = QPainter(self)
        if self._folded:
            elem = QStyle.PE_IndicatorArrowRight
        else:
            elem = QStyle.PE_IndicatorArrowDown
        self.style().drawPrimitive(elem, opt, painter, self)

# 需要导入模块: from PyQt5.QtWidgets import QStyleOption [as 别名]
# 或者: from PyQt5.QtWidgets.QStyleOption import initFrom [as 别名]
 def paintEvent(self, event):
     """Paint the widget."""
     opt = QStyleOption()
     opt.initFrom(self)
     painter = QPainter(self)
     if self._direction == QArrow.UP:
         primitive = QStyle.PE_IndicatorArrowUp
     elif self._direction == QArrow.DOWN:
         primitive = QStyle.PE_IndicatorArrowDown
     elif self._direction == QArrow.LEFT:
         primitive = QStyle.PE_IndicatorArrowLeft
     else:
         primitive = QStyle.PE_IndicatorArrowRight
     painter.setViewTransformEnabled(True)
     self.style().drawPrimitive(primitive, opt, painter, self)

# 需要导入模块: from PyQt5.QtWidgets import QStyleOption [as 别名]
# 或者: from PyQt5.QtWidgets.QStyleOption import initFrom [as 别名]
    def paint_drop_indicator(self, painter):
        if self.drag_active:
            opt = QStyleOption()
            opt.initFrom(self)
            opt.rect = self.drop_indicator_rect
            rect = opt.rect

            brush = QBrush(QColor(Qt.darkRed))

            if rect.height() == 0:
                pen = QPen(brush, 2, Qt.SolidLine)
                painter.setPen(pen)
                painter.drawLine(rect.topLeft(), rect.topRight())
            else:
                pen = QPen(brush, 2, Qt.SolidLine)
                painter.setPen(pen)
                painter.drawRect(rect)

# 需要导入模块: from PyQt5.QtWidgets import QStyleOption [as 别名]
# 或者: from PyQt5.QtWidgets.QStyleOption import initFrom [as 别名]
    def paintEvent(self, event):
        # Draw backgrounds according to css
        styleOpt = QStyleOption()
        styleOpt.initFrom(self)
        p = QPainter(self)
        p.setRenderHint(QPainter.Antialiasing)
        self.style().drawPrimitive(QStyle.PE_Widget, styleOpt, p, self)

        if self.values == None or len(self.values) == 0: return

        r = self.rect()

        gcolor = styleOpt.palette.color(QPalette.Text)
        p.setBrush(gcolor)
        p.setPen(gcolor)

        for i in range(len(self.values)):
            spacing = 4
            thickness = (r.height() - spacing*(len(self.values)-1)) / len(self.values)
            p.drawRect(QRectF(0, (thickness+spacing) * i, self.values[i]*r.width(), thickness))

# 需要导入模块: from PyQt5.QtWidgets import QStyleOption [as 别名]
# 或者: from PyQt5.QtWidgets.QStyleOption import initFrom [as 别名]
    def paintEvent(self, event):
        option = QStyleOption()
        option.initFrom(self)

        contents_rect = self.style().subElementRect(QStyle.SE_FrameContents, option, self) or self.contentsRect()  # the SE_FrameContents rect is Null unless the stylesheet defines decorations

        if self.graphStyle == self.BarStyle:
            graph_width = self.__dict__['graph_width'] = int(ceil(float(contents_rect.width()) / self.horizontalPixelsPerUnit))
        else:
            graph_width = self.__dict__['graph_width'] = int(ceil(float(contents_rect.width() - 1) / self.horizontalPixelsPerUnit) + 1)

        max_value = self.__dict__['max_value'] = max(chain([0], *(islice(reversed(graph.data), graph_width) for graph in self.graphs if graph.enabled)))

        if self.graphHeight == self.AutomaticHeight or self.graphHeight < 0:
            graph_height = self.__dict__['graph_height'] = max(self.scaler.get_height(max_value), self.minHeight)
        else:
            graph_height = self.__dict__['graph_height'] = max(self.graphHeight, self.minHeight)

        if self.graphStyle == self.BarStyle:
            height_scaling = float(contents_rect.height()) / graph_height
        else:
            height_scaling = float(contents_rect.height() - self.lineThickness) / graph_height

        painter = QStylePainter(self)
        painter.drawPrimitive(QStyle.PE_Widget, option)

        painter.setClipRect(contents_rect)

        painter.save()
        painter.translate(contents_rect.x() + contents_rect.width() - 1, contents_rect.y() + contents_rect.height() - 1)
        painter.scale(-1, -1)

        painter.setRenderHint(QStylePainter.Antialiasing, self.graphStyle != self.BarStyle)

        for graph in (graph for graph in self.graphs if graph.enabled and graph.data):
            if self.boundary is not None and 0 < self.boundary < graph_height:
                boundary_width = min(5.0/height_scaling, self.boundary-0, graph_height-self.boundary)
                pen_color = QLinearGradient(0, (self.boundary - boundary_width) * height_scaling, 0, (self.boundary + boundary_width) * height_scaling)
                pen_color.setColorAt(0, graph.color)
                pen_color.setColorAt(1, graph.over_boundary_color)
                brush_color = QLinearGradient(0, (self.boundary - boundary_width) * height_scaling, 0, (self.boundary + boundary_width) * height_scaling)
                brush_color.setColorAt(0, self.color_with_alpha(graph.color, self.fillTransparency))
                brush_color.setColorAt(1, self.color_with_alpha(graph.over_boundary_color, self.fillTransparency))
            else:
                pen_color = graph.color
                brush_color = self.color_with_alpha(graph.color, self.fillTransparency)
            dataset = islice(reversed(graph.data), graph_width)
            if self.graphStyle == self.BarStyle:
                lines = [QLineF(x*self.horizontalPixelsPerUnit, 0, x*self.horizontalPixelsPerUnit, y*height_scaling) for x, y in enumerate(dataset)]
                painter.setPen(QPen(pen_color, self.lineThickness))
                painter.drawLines(lines)
            else:
                painter.translate(0, +self.lineThickness/2 - 1)

                if self.smoothEnvelope and self.smoothFactor > 0:
                    min_value = 0
                    max_value = graph_height * height_scaling
                    cx_offset = self.horizontalPixelsPerUnit / 3.0
                    smoothness = self.smoothFactor

                    last_values = deque(3*[next(dataset) * height_scaling], maxlen=3)  # last 3 values: 0 last, 1 previous, 2 previous previous

                    envelope = QPainterPath()
                    envelope.moveTo(0, last_values[0])
                    for x, y in enumerate(dataset, 1):
                        x = x * self.horizontalPixelsPerUnit
                        y = y * height_scaling * (1 - smoothness) + last_values[0] * smoothness
                        last_values.appendleft(y)
                        c1x = x - cx_offset * 2
                        c2x = x - cx_offset
                        c1y = limit((1 + smoothness) * last_values[1] - smoothness * last_values[2], min_value, max_value)  # same gradient as previous previous value to previous value
                        c2y = limit((1 - smoothness) * last_values[0] + smoothness * last_values[1], min_value, max_value)  # same gradient as previous value to last value
                        envelope.cubicTo(c1x, c1y, c2x, c2y, x, y)
                else:
                    envelope = QPainterPath()
                    envelope.addPolygon(QPolygonF([QPointF(x*self.horizontalPixelsPerUnit, y*height_scaling) for x, y in enumerate(dataset)]))

                if self.fillEnvelope or graph.fill_envelope:
                    first_element = envelope.elementAt(0)
                    last_element = envelope.elementAt(envelope.elementCount() - 1)
                    fill_path = QPainterPath()
                    fill_path.moveTo(last_element.x, last_element.y)
                    fill_path.lineTo(last_element.x + 1, last_element.y)
                    fill_path.lineTo(last_element.x + 1, -self.lineThickness)
                    fill_path.lineTo(-self.lineThickness, -self.lineThickness)
                    fill_path.lineTo(-self.lineThickness, first_element.y)
                    fill_path.connectPath(envelope)
                    painter.fillPath(fill_path, brush_color)

                painter.strokePath(envelope, QPen(pen_color, self.lineThickness, join=Qt.RoundJoin))

                painter.translate(0, -self.lineThickness/2 + 1)

        if self.boundary is not None and self.boundaryColor:
            painter.setRenderHint(QStylePainter.Antialiasing, False)
            painter.setPen(QPen(self.boundaryColor, 1.0))
            painter.drawLine(0, self.boundary*height_scaling, contents_rect.width(), self.boundary*height_scaling)

        painter.restore()

#.........这里部分代码省略.........

# 需要导入模块: from PyQt5.QtWidgets import QStyleOption [as 别名]
# 或者: from PyQt5.QtWidgets.QStyleOption import initFrom [as 别名]
 def paintEvent(self, event):
     option = QStyleOption()
     option.initFrom(self)
     painter = QStylePainter(self)
     painter.setRenderHint(QStylePainter.Antialiasing, True)
     painter.drawPrimitive(QStyle.PE_Widget if self.testAttribute(Qt.WA_NoSystemBackground) else QStyle.PE_Frame, option)

# 需要导入模块: from PyQt5.QtWidgets import QStyleOption [as 别名]
# 或者: from PyQt5.QtWidgets.QStyleOption import initFrom [as 别名]
 def paintEvent(self, pe):
     opt = QStyleOption()
     opt.initFrom(self)
     p = QPainter(self)
     s = self.style()
     s.drawPrimitive(QStyle.PE_Widget, opt, p, self)

# 需要导入模块: from PyQt5.QtWidgets import QStyleOption [as 别名]
# 或者: from PyQt5.QtWidgets.QStyleOption import initFrom [as 别名]
 def paintEvent(self, _):
     opt = QStyleOption()
     opt.initFrom(self)
     painter = QPainter(self)
     self.style().drawPrimitive(QStyle.PE_Widget, opt, painter, self)