Beispiel #1
0
    def draw_dark_extended_background(self, painter):
        c = self.parent_node.color

        # main rect
        body_gradient = QRadialGradient(self.boundingRect().topLeft(),
                                        pythagoras(self.height, self.width))
        body_gradient.setColorAt(
            0,
            QColor(c.red() / 10 + 100,
                   c.green() / 10 + 100,
                   c.blue() / 10 + 100, 200))
        body_gradient.setColorAt(
            1,
            QColor(c.red() / 10 + 100,
                   c.green() / 10 + 100,
                   c.blue() / 10 + 100, 0))

        painter.setBrush(body_gradient)
        painter.setPen(Qt.NoPen)
        painter.drawRoundedRect(self.boundingRect(), 12, 12)

        header_gradient = QLinearGradient(self.get_header_rect().topRight(),
                                          self.get_header_rect().bottomLeft())
        header_gradient.setColorAt(0, QColor(c.red(), c.green(), c.blue(),
                                             255))
        header_gradient.setColorAt(1, QColor(c.red(), c.green(), c.blue(), 0))
        painter.setBrush(header_gradient)
        painter.setPen(Qt.NoPen)
        painter.drawRoundedRect(self.get_header_rect(), 12, 12)
Beispiel #2
0
    def brushChanged(self):
        style = Qt.BrushStyle(self.brushStyleComboBox.itemData(
                self.brushStyleComboBox.currentIndex(), IdRole))

        if style == Qt.LinearGradientPattern:
            linearGradient = QLinearGradient(0, 0, 100, 100)
            linearGradient.setColorAt(0.0, Qt.white)
            linearGradient.setColorAt(0.2, Qt.green)
            linearGradient.setColorAt(1.0, Qt.black)
            self.renderArea.setBrush(QBrush(linearGradient))
        elif style == Qt.RadialGradientPattern:
            radialGradient = QRadialGradient(50, 50, 50, 70, 70)
            radialGradient.setColorAt(0.0, Qt.white)
            radialGradient.setColorAt(0.2, Qt.green)
            radialGradient.setColorAt(1.0, Qt.black)
            self.renderArea.setBrush(QBrush(radialGradient))
        elif style == Qt.ConicalGradientPattern:
            conicalGradient = QConicalGradient(50, 50, 150)
            conicalGradient.setColorAt(0.0, Qt.white)
            conicalGradient.setColorAt(0.2, Qt.green)
            conicalGradient.setColorAt(1.0, Qt.black)
            self.renderArea.setBrush(QBrush(conicalGradient))
        elif style == Qt.TexturePattern:
            self.renderArea.setBrush(QBrush(QPixmap(':/images/brick.png')))
        else:
            self.renderArea.setBrush(QBrush(Qt.green, style))
Beispiel #3
0
    def _updateSignalColor(self, signalName, newColor):
        chIter = QTreeWidgetItemIterator(self.chSelector,
                                        QTreeWidgetItemIterator.Checked)
        while chIter.value():
            if chIter.value().text(0) == signalName:
                sColor = QColor(newColor)
                sColor.setAlpha(100)
                chIter.value().setBackgroundColor(0, sColor)
            chIter += 1

        sIter = QTreeWidgetItemIterator(self.sSelector)
        while sIter.value():
            if sIter.value().text(0) == signalName:
                sColor = QColor(newColor)
                sColor.setAlpha(100)
                sGradient = QLinearGradient(0, 0, 100, 10)
                sGradient.setColorAt(0, sColor)
                sGradient.setColorAt(1, Qt.white)
                sBrush = QBrush(sGradient)
                sBrush.setStyle(Qt.LinearGradientPattern)
                sBrush.setColor(sColor)
                sIter.value().setBackground(0, sBrush)
                if sIter.value() is self.curSelect:
                    self.prevBackGround = sIter.value().background(0)
            sIter += 1

        self.changeCurrentSelect(self.curSelect)
    def brushChanged(self):
        style = Qt.BrushStyle(
            self.brushStyleComboBox.itemData(
                self.brushStyleComboBox.currentIndex(), IdRole))

        if style == Qt.LinearGradientPattern:
            linearGradient = QLinearGradient(0, 0, 100, 100)
            linearGradient.setColorAt(0.0, Qt.white)
            linearGradient.setColorAt(0.2, Qt.green)
            linearGradient.setColorAt(1.0, Qt.black)
            self.renderArea.setBrush(QBrush(linearGradient))
        elif style == Qt.RadialGradientPattern:
            radialGradient = QRadialGradient(50, 50, 50, 70, 70)
            radialGradient.setColorAt(0.0, Qt.white)
            radialGradient.setColorAt(0.2, Qt.green)
            radialGradient.setColorAt(1.0, Qt.black)
            self.renderArea.setBrush(QBrush(radialGradient))
        elif style == Qt.ConicalGradientPattern:
            conicalGradient = QConicalGradient(50, 50, 150)
            conicalGradient.setColorAt(0.0, Qt.white)
            conicalGradient.setColorAt(0.2, Qt.green)
            conicalGradient.setColorAt(1.0, Qt.black)
            self.renderArea.setBrush(QBrush(conicalGradient))
        elif style == Qt.TexturePattern:
            self.renderArea.setBrush(QBrush(QPixmap(':/images/brick.png')))
        else:
            self.renderArea.setBrush(QBrush(Qt.green, style))
Beispiel #5
0
    def draw_NI_minimalistic(painter, c, w, h, bounding_rect):
        """
        :param painter: painter from paint event
        :param c: color
        :param w: width
        :param h: height
        :param bounding_rect: NodeInstance's bounding rect
        """

        path = QPainterPath()
        path.moveTo(-w / 2, 0)

        path.cubicTo(-w / 2, -h / 2, -w / 2, -h / 2, 0, -h / 2)
        path.cubicTo(+w / 2, -h / 2, +w / 2, -h / 2, +w / 2, 0)
        path.cubicTo(+w / 2, +h / 2, +w / 2, +h / 2, 0, +h / 2)
        path.cubicTo(-w / 2, +h / 2, -w / 2, +h / 2, -w / 2, 0)
        path.closeSubpath()

        body_gradient = QLinearGradient(bounding_rect.bottomLeft(),
                                        bounding_rect.topRight())
        body_gradient.setColorAt(0, QColor(c.red(), c.green(), c.blue(), 150))
        body_gradient.setColorAt(1, QColor(c.red(), c.green(), c.blue(), 80))

        painter.setBrush(body_gradient)
        painter.setPen(QPen(QColor(30, 43, 48)))

        painter.drawPath(path)
Beispiel #6
0
    def draw_dark_minimalistic(self, painter):
        path = QPainterPath()
        path.moveTo(-self.width / 2, 0)

        path.cubicTo(-self.width / 2, -self.height / 2,
                     -self.width / 2, -self.height / 2,
                     0, -self.height / 2)
        path.cubicTo(+self.width / 2, -self.height / 2,
                     +self.width / 2, -self.height / 2,
                     +self.width / 2, 0)
        path.cubicTo(+self.width / 2, +self.height / 2,
                     +self.width / 2, +self.height / 2,
                     0, +self.height / 2)
        path.cubicTo(-self.width / 2, +self.height / 2,
                     -self.width / 2, +self.height / 2,
                     -self.width / 2, 0)
        path.closeSubpath()

        c = self.parent_node.color
        body_gradient = QLinearGradient(self.boundingRect().bottomLeft(),
                                        self.boundingRect().topRight())
        body_gradient.setColorAt(0, QColor(c.red(), c.green(), c.blue(), 150))
        body_gradient.setColorAt(1, QColor(c.red(), c.green(), c.blue(), 80))

        painter.setBrush(body_gradient)
        painter.setPen(QPen(QColor(30, 43, 48)))

        painter.drawPath(path)
Beispiel #7
0
 def _make_legend_gradient(x1, y1, x2, y2):
     gradient = QLinearGradient(x1, y1, x2, y2)
     gradient.setColorAt(0.0, Qt.red)
     gradient.setColorAt(0.4, Qt.yellow)
     gradient.setColorAt(0.6, Qt.green)
     gradient.setColorAt(0.8, Qt.blue)
     gradient.setColorAt(1.0, Qt.darkBlue)
     return gradient
Beispiel #8
0
 def _handle_execution_animation_value_changed(self, step):
     gradient = QLinearGradient(self.src_center, self.dst_center)
     delta = 8 * self.magic_number / QLineF(self.src_center, self.dst_center).length()
     gradient.setColorAt(0, self._color)
     gradient.setColorAt(max(0.0, step - delta), self._color)
     gradient.setColorAt(step, self._exec_color)
     gradient.setColorAt(min(1.0, step + delta), self._color)
     gradient.setColorAt(1.0, self._color)
     self.setBrush(gradient)
Beispiel #9
0
 def _handle_execution_animation_value_changed(self, step):
     gradient = QLinearGradient(self.src_center, self.dst_center)
     yellow = QColor(255, 255, 0, 204)
     red = QColor(255, 0, 0, 204)
     delta = 8 * self.magic_number / QLineF(self.src_center,
                                            self.dst_center).length()
     gradient.setColorAt(0, yellow)
     gradient.setColorAt(max(0.0, step - delta), yellow)
     gradient.setColorAt(step, red)
     gradient.setColorAt(min(1.0, step + delta), yellow)
     gradient.setColorAt(1.0, yellow)
     self.setBrush(gradient)
Beispiel #10
0
    def paintEvent(self, event):
        s = self.size()
        qp = QPainter()
        qp.begin(self)
        qp.setRenderHint(QPainter.Antialiasing, True)
        pen = QPen(Qt.NoPen)
        qp.setPen(pen)
        qp.setBrush(QColor(154, 205, 50))
        if self.__enabled:
            qp.setBrush(QColor(154, 190, 50))
            qp.drawRoundedRect(0, 0, s.width(), s.height(), 10, 10)

            lg = QLinearGradient(0, 25, 70, 0)
            lg.setColorAt(0, QColor(154, 184, 50))
            lg.setColorAt(0.35, QColor(154, 210, 50))
            lg.setColorAt(0.85, QColor(154, 184, 50))
            qp.setBrush(lg)
            qp.drawRoundedRect(1, 1, s.width() - 2, s.height() - 2, 8, 8)
        else:
            qp.setBrush(QColor(150, 150, 150))
            qp.drawRoundedRect(0, 0, s.width(), s.height(), 10, 10)

            lg = QLinearGradient(5, 25, 60, 0)
            lg.setColorAt(0, QColor(190, 190, 190))
            lg.setColorAt(0.35, QColor(230, 230, 230))
            lg.setColorAt(0.85, QColor(190, 190, 190))
            qp.setBrush(lg)
            qp.drawRoundedRect(1, 1, s.width() - 2, s.height() - 2, 8, 8)
        qp.end()
Beispiel #11
0
    def draw_NI_extended_background(painter, c, w, h, bounding_rect,
                                    title_rect):
        """
        :param painter: painter from paint event
        :param c: NodeInstance's theme color
        :param w: width
        :param h: height
        :param bounding_rect: NodeInstance's bounding rect
        :param title_rect: NI's title label's bounding rect
        """

        background_color = QColor('#212429')
        header_color = c

        rel_header_height = NIPainter.get_header_rect(w, h,
                                                      title_rect).height() / h
        gradient = QLinearGradient(bounding_rect.topLeft(),
                                   bounding_rect.bottomLeft())
        gradient.setColorAt(0, header_color)
        gradient.setColorAt(rel_header_height, header_color)
        gradient.setColorAt(rel_header_height + 0.0001, background_color)
        gradient.setColorAt(1, background_color)

        painter.setBrush(gradient)
        painter.setPen(Qt.NoPen)  #QPen(c.darker()))
        painter.drawRoundedRect(bounding_rect, 9, 9)
 def _draw_bar_background(self, p: QPainter):
     """
     绘制导航栏的背景
     :param p: 画刷
     :return: None
     """
     p.save()
     p.setPen(Qt.NoPen)
     lgt = QLinearGradient(QPointF(0, 0), QPointF(0, self.height()))
     lgt.setColorAt(0.0, self._m_bar_start_color)
     lgt.setColorAt(1.0, self._m_bar_end_color)
     p.setBrush(lgt)
     p.drawRoundedRect(self.rect(), self._m_bar_radius, self._m_bar_radius)
     p.restore()
    def _draw_item_background(self, p: QPainter):
        """
        绘制项目的背景
        :param p: 画刷
        :return: None
        """
        if self._m_start_rect.isNull():
            return

        p.save()
        lgt = QLinearGradient(self._m_start_rect.topLeft(), self._m_start_rect.bottomRight())
        lgt.setColorAt(0.0, self._m_item_start_color)
        lgt.setColorAt(1.0, self._m_item_end_color)
        p.setPen(Qt.NoPen)
        p.setBrush(lgt)
        p.drawRoundedRect(self._m_start_rect, self._m_item_radius, self._m_item_radius)

        # 绘制 hover 状态下的item
        if self._m_current_hover_index != -1:
            hover_rect = QRectF(self._m_item_maps[self._m_current_hover_index][1])
            lgt = QLinearGradient(hover_rect.topLeft(), hover_rect.bottomRight())
            lgt.setColorAt(0.0, self._m_item_hover_start_color)
            lgt.setColorAt(1.0, self._m_item_hover_end_color)
            p.setPen(Qt.NoPen)
            p.setBrush(lgt)
            p.drawRoundedRect(hover_rect, self._m_item_radius, self._m_item_radius)
        p.restore()
    def __init__(self, parent, scene: QGraphicsScene):
        super().__init__(parent)
        self.setRenderHints(QPainter.Antialiasing)
        self.setViewportUpdateMode(QGraphicsView.FullViewportUpdate)
        self.setCacheMode(QGraphicsView.CacheBackground)
        self.setTransformationAnchor(QGraphicsView.AnchorUnderMouse)

        gradient = QLinearGradient(self.rect().topLeft(),
                                   self.rect().bottomRight())
        gradient.setColorAt(0, Qt.white)
        gradient.setColorAt(1, Qt.lightGray)

        self.setCursor(Qt.CrossCursor)  # 设置鼠标
        self.setMouseTracking(True)
        self.setDragMode(QGraphicsView.RubberBandDrag)

        self.setBackgroundBrush(gradient)
        self.setScene(scene)
        self.setAttribute(Qt.WA_DeleteOnClose)
Beispiel #15
0
    def paint(self,
              painter=QPainter,
              option=QStyleOptionGraphicsItem,
              widget=QWidget):
        corners = 5
        body = self.boundingRect()
        height = body.height()
        width = body.width()
        percentage = height / 10
        painter.setRenderHint(QPainter.Antialiasing)

        path = QPainterPath()
        path.addRoundedRect(body, corners, corners)
        pen = QPen(QColor(255, 255, 255, 100),
                   3) if self.hover and not self.isPressed else QPen(
                       Qt.black, 0.1)
        pen.setJoinStyle(Qt.RoundJoin)
        pen.setCosmetic(True)
        painter.setPen(pen)
        painter.fillPath(path, self._model["bgColor"])
        painter.drawPath(path)
        if not self.isPressed:
            grad = QLinearGradient(0, height, 0, height - percentage)
            grad.setColorAt(0, QColor(175, 175, 175, 255))
            grad.setColorAt(1, QColor(175, 175, 175, 0))
            path = QPainterPath()
            path.addRoundedRect(body, corners, corners)
            painter.setCompositionMode(QPainter.CompositionMode_Multiply)
            painter.setPen(Qt.NoPen)
            painter.fillPath(path, grad)
            painter.drawPath(path)

            grad = QLinearGradient(0, percentage, 0, 0)
            grad.setColorAt(1, QColor(255, 255, 255, 255))
            grad.setColorAt(0, QColor(255, 255, 255, 0))
            path = QPainterPath()
            path.addRoundedRect(body, corners, corners)
            painter.setCompositionMode(QPainter.CompositionMode_Overlay)
            painter.setPen(Qt.NoPen)
            painter.fillPath(path, grad)
            painter.drawPath(path)
            painter.setCompositionMode(QPainter.CompositionMode_Source)
        else:
            path = QPainterPath()
            path.addRoundedRect(body, corners, corners)
            painter.setCompositionMode(QPainter.CompositionMode_Overlay)
            painter.setPen(Qt.NoPen)
            painter.fillPath(path, QColor(255, 255, 255))
            painter.drawPath(path)
            painter.setCompositionMode(QPainter.CompositionMode_Source)
        super(ButtonNode, self).paint(painter, option, widget)
    def draw_tron_extended_background(self, painter, c, w, h, bounding_rect):
        """
        :param painter: painter from paint event
        :param c: NodeInstance's theme color
        :param w: width
        :param h: height
        :param bounding_rect: NodeInstance's bounding rect
        """

        # main rect
        background_color = QColor('#212224')
        painter.setBrush(background_color)
        pen = QPen(c)
        pen.setWidth(2)
        painter.setPen(pen)
        body_path = self.get_extended_body_path_TRON_DESIGN(10, w, h)
        painter.drawPath(body_path)

        header_gradient = QLinearGradient(
            self.get_header_rect(w, h).topRight(),
            self.get_header_rect(w, h).bottomLeft())
        header_gradient.setColorAt(0, QColor(c.red(), c.green(), c.blue(),
                                             255))
        header_gradient.setColorAt(0.5,
                                   QColor(c.red(), c.green(), c.blue(), 100))
        header_gradient.setColorAt(1, QColor(c.red(), c.green(), c.blue(), 0))
        painter.setBrush(header_gradient)
        header_path = self.get_extended_header_path_TRON_DESIGN(10, w, h)
        painter.drawPath(header_path)
Beispiel #17
0
    def draw_NI_extended_background(painter, c, w, h, bounding_rect,
                                    title_rect):
        """
        :param painter: painter from paint event
        :param c: NodeInstance's theme color
        :param w: width
        :param h: height
        :param bounding_rect: NodeInstance's bounding rect
        :param title_rect: NI's title label's bounding rect
        """

        background_color = QColor('#212224')
        painter.setBrush(background_color)
        pen = QPen(c)
        pen.setWidth(2)
        painter.setPen(pen)
        body_path = NIPainter_DarkTron.get_extended_body_path(w, h)
        painter.drawPath(body_path)

        header_gradient = QLinearGradient(
            NIPainter_DarkTron.get_header_rect(w, h, title_rect).topRight(),
            NIPainter_DarkTron.get_header_rect(w, h, title_rect).bottomLeft())
        header_gradient.setColorAt(0, QColor(c.red(), c.green(), c.blue(),
                                             255))
        header_gradient.setColorAt(0.5,
                                   QColor(c.red(), c.green(), c.blue(), 100))
        header_gradient.setColorAt(1, QColor(c.red(), c.green(), c.blue(), 0))
        painter.setBrush(header_gradient)
        header_path = NIPainter_DarkTron.get_extended_header_path(
            w, h, title_rect)
        painter.drawPath(header_path)
Beispiel #18
0
    def draw_NI_extended_background(painter, c, w, h, bounding_rect,
                                    title_rect):
        """
        :param painter: painter from paint event
        :param c: NodeInstance's theme color
        :param w: width
        :param h: height
        :param bounding_rect: NodeInstance's bounding rect
        :param title_rect: NI's title label's bounding rect
        """

        # main rect
        body_gradient = QRadialGradient(bounding_rect.topLeft(),
                                        pythagoras(h, w))
        body_gradient.setColorAt(
            0,
            QColor(c.red() / 10 + 100,
                   c.green() / 10 + 100,
                   c.blue() / 10 + 100, 200))
        body_gradient.setColorAt(
            1,
            QColor(c.red() / 10 + 100,
                   c.green() / 10 + 100,
                   c.blue() / 10 + 100, 0))

        painter.setBrush(body_gradient)
        painter.setPen(Qt.NoPen)
        painter.drawRoundedRect(bounding_rect, 12, 12)

        header_gradient = QLinearGradient(
            NIPainter_DarkStd.get_header_rect(w, h, title_rect).topRight(),
            NIPainter_DarkStd.get_header_rect(w, h, title_rect).bottomLeft())
        header_gradient.setColorAt(0, QColor(c.red(), c.green(), c.blue(),
                                             255))
        header_gradient.setColorAt(1, QColor(c.red(), c.green(), c.blue(), 0))
        painter.setBrush(header_gradient)
        painter.setPen(Qt.NoPen)
        painter.drawRoundedRect(
            NIPainter_DarkStd.get_header_rect(w, h, title_rect), 12, 12)
Beispiel #19
0
    def drawGradient(self, qp):
        gradient = QLinearGradient(QPointF(200,15), QPointF(600,60))
        gradient.setColorAt(0,Qt.blue)
        gradient.setColorAt(0.25,Qt.cyan)
        gradient.setColorAt(0.5,Qt.green)
        gradient.setColorAt(0.75,Qt.yellow)
        gradient.setColorAt(1,Qt.red)
        qp.setBrush(gradient)
        qp.drawRect(200, 15, 600, 60)

        qp.setFont(QFont('Arial', 8))
        qp.setBrush(Qt.black)
        qp.drawText(200, 0, 205, 15, Qt.AlignLeft, "0")
        qp.drawText(395, 0, 405, 15, Qt.AlignLeft, "0.5")
        qp.drawText(595, 0, 600, 15, Qt.AlignLeft, "1")
Beispiel #20
0
    def paintEvent(self, a0: QtGui.QPaintEvent) -> None:
        """
        重载paintEvent函数
        :param a0:
        :return:
        """
        p = QPainter(self)
        p.setRenderHint(QPainter.Antialiasing)
        p.save()
        p.setPen(Qt.NoPen)

        lgt = QLinearGradient(QPointF(0, 0), QPointF(self.width(), 0))
        lgt.setColorAt(0.0, QColor('#511235'))
        lgt.setColorAt(1.0, QColor('red'))
        p.setBrush(lgt)
        p.drawRect(QRectF(0, 0, self.width(), self._m_title_height))
        p.drawRect(
            QRectF(0,
                   self.height() - self._m_status_label.height(),
                   self.rect().width(), self._m_status_label.height()))
        line_pen = QPen()
        line_pen.setColor(QColor(30, 144, 255, 30))
        line_pen.setWidth(1)
        p.setPen(line_pen)
        p.drawLine(0,
                   self.rect().height() - self._m_status_label.height(),
                   self.rect().width(),
                   self.rect().height() - self._m_status_label.height())

        # 在窗口左上角画图标

        if self._m_icon_path:
            imx = QPixmap(self._m_icon_path)
            p.drawPixmap(5, (self._m_title_label.height() - imx.height()) / 2,
                         imx)

        p.restore()
    def paint(self, painter: QPainter, option: QStyleOptionGraphicsItem, widget: QWidget = None):
        # setup border pen
        pen = painter.pen()
        pen.setWidthF(self.monitor_border_width)
        pen.setCapStyle(Qt.FlatCap)
        painter.setPen(pen)

        # create monitor_rect
        rect_monitor = QRectF(0, 0,
                              self.monitor.screen_width, self.monitor.screen_height)

        # Draw gradient in the background
        gradient = QLinearGradient(rect_monitor.topRight(), rect_monitor.bottomLeft())
        gradient.setColorAt(0.0, self.monitor_color_gradient_top)
        gradient.setColorAt(1.0, self.monitor_color_gradient_bottom)
        painter.fillRect(rect_monitor, gradient)

        # draw monitor label
        self.draw_monitor_label(painter, rect_monitor, self.index)

        # draw borders inside monitor_rect
        border_offset = painter.pen().widthF() / 2
        border_rect = rect_monitor.adjusted(border_offset, border_offset, -border_offset, border_offset)
        painter.drawRect(border_rect)
    def draw_blender_extended_background(self, painter, c, w, h,
                                         bounding_rect):
        """
        :param painter: painter from paint event
        :param c: NodeInstance's theme color
        :param w: width
        :param h: height
        :param bounding_rect: NodeInstance's bounding rect
        """
        background_color = QColor(100, 100, 100, 150)
        header_color = QColor(c.red(), c.green(), c.blue(), 180)

        rel_header_height = self.get_header_rect(w, h).height() / h
        gradient = QLinearGradient(bounding_rect.topLeft(),
                                   bounding_rect.bottomLeft())
        gradient.setColorAt(0, header_color)
        gradient.setColorAt(rel_header_height, header_color)
        gradient.setColorAt(rel_header_height + 0.0001, background_color)
        gradient.setColorAt(1, background_color)

        painter.setBrush(gradient)
        painter.setPen(QPen(c.darker()))
        painter.drawRoundedRect(bounding_rect, 7, 7)
Beispiel #23
0
    def draw_tron_extended_background(self, painter):
        # main rect
        c = QColor('#212224')
        painter.setBrush(c)
        pen = QPen(self.parent_node.color)
        pen.setWidth(2)
        painter.setPen(pen)
        body_path = self.get_extended_body_path_TRON_DESIGN(10)
        painter.drawPath(body_path)
        # painter.drawRoundedRect(self.boundingRect(), 12, 12)

        c = self.parent_node.color
        header_gradient = QLinearGradient(self.get_header_rect().topRight(), self.get_header_rect().bottomLeft())
        header_gradient.setColorAt(0, QColor(c.red(), c.green(), c.blue(), 255))
        header_gradient.setColorAt(0.5, QColor(c.red(), c.green(), c.blue(), 100))
        header_gradient.setColorAt(1, QColor(c.red(), c.green(), c.blue(), 0))
        painter.setBrush(header_gradient)
        header_path = self.get_extended_header_path_TRON_DESIGN(10)
        painter.drawPath(header_path)
Beispiel #24
0
    def __init__(self,
                 parent,
                 capacity,
                 color,
                 gradient_start=None,
                 gradient_end=None,
                 speeds=(),
                 is_upload=False,
                 dp=1,
                 max_speed=0):
        self._parent = parent
        self._capacity = capacity
        self._color = color
        self._gradient_start = gradient_start if gradient_start \
            else self._color
        self._gradient_end = gradient_end if gradient_end \
            else self._color.lighter()
        self._last_max_speed = max_speed

        self._chart = QtCharts.QChart()

        self._line_series = QtCharts.QLineSeries()
        self._lower_series = QtCharts.QLineSeries()
        if len(speeds) > self._capacity:
            speeds = speeds[len(speeds) - self._capacity:]
        for i, speed in enumerate(speeds):
            self._line_series.append(i, speed)
            self._lower_series.append(i, 0)
        self._last_index = len(speeds)

        self._series = QtCharts.QAreaSeries(self._line_series,
                                            self._lower_series)
        pen = QPen(self._color)
        pen.setWidth(1)
        self._series.setPen(pen)

        self._series.lowerSeries().setColor(self._gradient_end)

        gradient = QLinearGradient(QPointF(0, 0), QPointF(0, 1))
        gradient.setColorAt(0.0, self._gradient_start)
        gradient.setColorAt(1.0, self._gradient_end)
        gradient.setCoordinateMode(QGradient.ObjectBoundingMode)
        self._series.setBrush(gradient)

        self._chart.addSeries(self._series)
        self._chart.layout().setContentsMargins(0, 0, 0, 0)
        # make chart look bigger
        margins = [-35, -25, -35, -37]
        self._chart.setContentsMargins(*margins)
        self._chart.setBackgroundRoundness(0)

        grid_pen = QPen(QColor("#EFEFF4"))
        grid_pen.setWidth(1)

        self._chart.createDefaultAxes()
        self._chart.axisX().setLabelsVisible(False)
        # self._chart.axisY().setLabelsVisible(False)
        self._chart.axisX().setTitleVisible(False)
        # self._chart.axisY().setTitleVisible(False)
        self._chart.axisX().setGridLineVisible(True)
        self._chart.axisX().setGridLinePen(grid_pen)
        # self._chart.axisY().setGridLineVisible(False)
        # self._chart.axisY().setGridLinePen(grid_pen)
        self._chart.axisX().setLineVisible(False)
        self._chart.axisY().setLineVisible(False)
        self._chart.axisX().setRange(self._last_index - self._capacity,
                                     self._last_index - 1)
        self._set_y_range()
        self._chart.axisY().hide()
        # self._chart.setBackgroundBrush(QBrush(QColor("#EFEFF4")))

        self._view = QtCharts.QChartView(self._chart, self._parent)
        self._view.setRenderHint(QPainter.Antialiasing)
        self._view.setFixedSize(self._parent.size())
        self._view.chart().legend().hide()
        self._chart.resize(self._view.width(), self._view.height())

        text_start = ""
        self._scale_line = ScaleLine(self._chart,
                                     QColor("#777777"),
                                     QColor("black"),
                                     text_start=text_start,
                                     margins=margins,
                                     dp=dp,
                                     is_upload=is_upload)
        self._scale_line.set_line(self._last_max_speed, resize=True)
Beispiel #25
0
    def setupUi(self, DsManager):
        if not DsManager.objectName():
            DsManager.setObjectName(u"DsManager")
        DsManager.setWindowModality(Qt.WindowModal)
        DsManager.resize(1156, 934)
        sizePolicy = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
        sizePolicy.setHorizontalStretch(0)
        sizePolicy.setVerticalStretch(0)
        sizePolicy.setHeightForWidth(
            DsManager.sizePolicy().hasHeightForWidth())
        DsManager.setSizePolicy(sizePolicy)
        DsManager.setMinimumSize(QSize(0, 800))
        font = QFont()
        font.setFamily(u"Arial Narrow")
        font.setPointSize(11)
        font.setBold(False)
        font.setItalic(False)
        font.setWeight(50)
        DsManager.setFont(font)
        icon = QIcon()
        icon.addFile(u"inc/icon.ico", QSize(), QIcon.Normal, QIcon.Off)
        DsManager.setWindowIcon(icon)
        DsManager.setStyleSheet(
            u"QMainWindow{\n"
            "background-image:url(:/images/background.jpg);\n"
            "background-repeat:none;\n"
            "}\n"
            "QPushButton {\n"
            "	border: 2px solid rgb(52, 59, 72);\n"
            "	border-radius: 5px;	\n"
            "	background-color: rgb(199, 200, 255);\n"
            "	padding: 5px\n"
            "}\n"
            "QPushButton:hover {\n"
            "	border: 2px solid rgb(61, 70, 86);\n"
            "}\n"
            "QPushButton:pressed {	\n"
            "	background-color: rgb(35, 40, 49);\n"
            "	border: 2px solid rgb(43, 50, 61);\n"
            "}")
        DsManager.setToolButtonStyle(Qt.ToolButtonIconOnly)
        DsManager.setAnimated(True)
        DsManager.setDocumentMode(False)
        DsManager.setDockNestingEnabled(True)
        self.actionAbut_DS_Manager = QAction(DsManager)
        self.actionAbut_DS_Manager.setObjectName(u"actionAbut_DS_Manager")
        icon1 = QIcon()
        icon1.addFile(u":/icons/icon.png", QSize(), QIcon.Normal, QIcon.Off)
        self.actionAbut_DS_Manager.setIcon(icon1)
        self.actionAbut_DS_Manager.setShortcutContext(Qt.WidgetShortcut)
        self.actionAbut_DS_Manager.setMenuRole(QAction.TextHeuristicRole)
        self.actionBackup_Database = QAction(DsManager)
        self.actionBackup_Database.setObjectName(u"actionBackup_Database")
        font1 = QFont()
        font1.setFamily(u"Microsoft YaHei UI")
        font1.setPointSize(8)
        self.actionBackup_Database.setFont(font1)
        self.actionRestore_Database = QAction(DsManager)
        self.actionRestore_Database.setObjectName(u"actionRestore_Database")
        self.centralwidget = QWidget(DsManager)
        self.centralwidget.setObjectName(u"centralwidget")
        sizePolicy.setHeightForWidth(
            self.centralwidget.sizePolicy().hasHeightForWidth())
        self.centralwidget.setSizePolicy(sizePolicy)
        self.verticalLayout_2 = QVBoxLayout(self.centralwidget)
        self.verticalLayout_2.setObjectName(u"verticalLayout_2")
        self.horizontalLayout = QHBoxLayout()
        self.horizontalLayout.setObjectName(u"horizontalLayout")
        self.horizontalSpacer_3 = QSpacerItem(250, 20, QSizePolicy.Expanding,
                                              QSizePolicy.Minimum)

        self.horizontalLayout.addItem(self.horizontalSpacer_3)

        self.label = QLabel(self.centralwidget)
        self.label.setObjectName(u"label")
        sizePolicy1 = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
        sizePolicy1.setHorizontalStretch(0)
        sizePolicy1.setVerticalStretch(0)
        sizePolicy1.setHeightForWidth(
            self.label.sizePolicy().hasHeightForWidth())
        self.label.setSizePolicy(sizePolicy1)
        self.label.setMaximumSize(QSize(164, 164))
        self.label.setStyleSheet(u"")
        self.label.setTextFormat(Qt.PlainText)
        self.label.setPixmap(QPixmap(u":/icons/home_logo.png"))
        self.label.setScaledContents(True)
        self.label.setAlignment(Qt.AlignLeading | Qt.AlignLeft
                                | Qt.AlignVCenter)

        self.horizontalLayout.addWidget(self.label)

        self.horizontalSpacer = QSpacerItem(150, 20, QSizePolicy.Expanding,
                                            QSizePolicy.Minimum)

        self.horizontalLayout.addItem(self.horizontalSpacer)

        self.label_11 = QLabel(self.centralwidget)
        self.label_11.setObjectName(u"label_11")
        sizePolicy2 = QSizePolicy(QSizePolicy.Maximum, QSizePolicy.Maximum)
        sizePolicy2.setHorizontalStretch(0)
        sizePolicy2.setVerticalStretch(0)
        sizePolicy2.setHeightForWidth(
            self.label_11.sizePolicy().hasHeightForWidth())
        self.label_11.setSizePolicy(sizePolicy2)
        font2 = QFont()
        font2.setFamily(u"Tahoma")
        font2.setPointSize(14)
        font2.setBold(True)
        font2.setItalic(False)
        font2.setWeight(75)
        font2.setStyleStrategy(QFont.PreferAntialias)
        self.label_11.setFont(font2)
        self.label_11.setLayoutDirection(Qt.RightToLeft)
        self.label_11.setStyleSheet(u"color: white;\n"
                                    "padding:10px;\n"
                                    "text-align:left;")
        self.label_11.setAlignment(Qt.AlignHCenter | Qt.AlignTop)
        self.label_11.setWordWrap(False)
        self.label_11.setMargin(10)
        self.label_11.setOpenExternalLinks(False)

        self.horizontalLayout.addWidget(self.label_11)

        self.horizontalSpacer_2 = QSpacerItem(250, 20, QSizePolicy.Expanding,
                                              QSizePolicy.Minimum)

        self.horizontalLayout.addItem(self.horizontalSpacer_2)

        self.verticalLayout_2.addLayout(self.horizontalLayout)

        self.verticalLayout = QVBoxLayout()
        self.verticalLayout.setSpacing(0)
        self.verticalLayout.setObjectName(u"verticalLayout")
        self.verticalLayout.setContentsMargins(60, 10, 30, 25)
        self.tabWidget = QTabWidget(self.centralwidget)
        self.tabWidget.setObjectName(u"tabWidget")
        self.tabWidget.setEnabled(True)
        sizePolicy.setHeightForWidth(
            self.tabWidget.sizePolicy().hasHeightForWidth())
        self.tabWidget.setSizePolicy(sizePolicy)
        self.tabWidget.setMaximumSize(QSize(1500, 16777215))
        font3 = QFont()
        font3.setFamily(u"Microsoft YaHei UI")
        font3.setPointSize(9)
        font3.setBold(True)
        font3.setItalic(False)
        font3.setWeight(75)
        self.tabWidget.setFont(font3)
        self.tabWidget.setAcceptDrops(False)
        self.tabWidget.setToolTipDuration(-1)
        # if QT_CONFIG(accessibility)
        self.tabWidget.setAccessibleDescription(u"")
        # endif // QT_CONFIG(accessibility)
        self.tabWidget.setLayoutDirection(Qt.LeftToRight)
        self.tabWidget.setAutoFillBackground(False)
        self.tabWidget.setStyleSheet(
            u"QWidget{\n"
            "	background-color:qlineargradient(spread:pad, x1:0.532552, y1:0, x2:0.522, y2:0.926136, stop:0.0199005 rgba(173, 224, 209, 207), stop:0.965174 rgba(165, 218, 214, 170));\n"
            "	border:0px;\n"
            "	height:30%;\n"
            "}\n"
            "\n"
            "QTabWidget::pane {\n"
            "	border: 0;\n"
            "	background-color:rgb(220, 255, 247);\n"
            "	border-radius: 10px;\n"
            "}\n"
            "\n"
            "QCalendarWidget QToolButton{\n"
            "  	color: black;\n"
            "  	background-color:rgb(156, 255, 231);\n"
            "}\n"
            "\n"
            " \n"
            "\n"
            "QCalendarWidget QAbstractItemView:enabled \n"
            "  {\n"
            "  \n"
            "  	color: black;  \n"
            "  	background-color: rgb(198, 255, 232);  \n"
            "  	selection-background-color: rgb(64, 64, 64); \n"
            "  	selection-color: rgb(0, 255, 0); \n"
            "  }\n"
            "\n"
            "QTabBar::tab {\n"
            "	width: 200;\n"
            "	background: gray;\n"
            "	color: white;\n"
            "	padding: 10px; \n"
            "	border-radius: 40px;\n"
            "}\n"
            "\n"
            "QTabBar::tab:selected {\n"
            "	background: qlineargradient(spread:pad, x1:0.532552, y1:0, x2:0.522, y2:0.926136, stop:0.0199005 rgba(173, 224, 209, 207), stop:0.965174 rgba(165, 218,"
            " 214, 170));\n"
            "	color: rgb(9, 0, 79);\n"
            "	padding: 10px; \n"
            "	border-radius: 40px;\n"
            "}")
        self.tabWidget.setTabPosition(QTabWidget.North)
        self.tabWidget.setTabShape(QTabWidget.Rounded)
        self.tabWidget.setIconSize(QSize(0, 0))
        self.tabWidget.setElideMode(Qt.ElideNone)
        self.tabWidget.setDocumentMode(False)
        self.tabWidget.setTabsClosable(False)
        self.tabWidget.setMovable(True)
        self.tabWidget.setTabBarAutoHide(False)
        self.data_entry_tab = QWidget()
        self.data_entry_tab.setObjectName(u"data_entry_tab")
        font4 = QFont()
        font4.setBold(False)
        font4.setWeight(50)
        self.data_entry_tab.setFont(font4)
        self.gridLayout = QGridLayout(self.data_entry_tab)
        self.gridLayout.setObjectName(u"gridLayout")
        self.gridLayout.setSizeConstraint(QLayout.SetDefaultConstraint)
        self.gridLayout.setHorizontalSpacing(10)
        self.gridLayout.setVerticalSpacing(30)
        self.gridLayout.setContentsMargins(80, 40, 20, 10)
        self.label_13 = QLabel(self.data_entry_tab)
        self.label_13.setObjectName(u"label_13")
        sizePolicy2.setHeightForWidth(
            self.label_13.sizePolicy().hasHeightForWidth())
        self.label_13.setSizePolicy(sizePolicy2)
        font5 = QFont()
        font5.setFamily(u"Microsoft YaHei UI")
        font5.setPointSize(11)
        font5.setBold(False)
        font5.setWeight(50)
        font5.setStyleStrategy(QFont.PreferAntialias)
        self.label_13.setFont(font5)

        self.gridLayout.addWidget(self.label_13, 8, 1, 1, 1)

        self.label_10 = QLabel(self.data_entry_tab)
        self.label_10.setObjectName(u"label_10")
        sizePolicy2.setHeightForWidth(
            self.label_10.sizePolicy().hasHeightForWidth())
        self.label_10.setSizePolicy(sizePolicy2)
        font6 = QFont()
        font6.setFamily(u"Microsoft YaHei UI")
        font6.setPointSize(11)
        font6.setBold(False)
        font6.setItalic(False)
        font6.setWeight(50)
        font6.setStrikeOut(False)
        font6.setStyleStrategy(QFont.PreferAntialias)
        self.label_10.setFont(font6)
        self.label_10.setStyleSheet(u"")

        self.gridLayout.addWidget(self.label_10, 5, 1, 1, 1)

        self.clear_entry_button = QPushButton(self.data_entry_tab)
        self.clear_entry_button.setObjectName(u"clear_entry_button")
        sizePolicy3 = QSizePolicy(QSizePolicy.Maximum, QSizePolicy.Fixed)
        sizePolicy3.setHorizontalStretch(0)
        sizePolicy3.setVerticalStretch(0)
        sizePolicy3.setHeightForWidth(
            self.clear_entry_button.sizePolicy().hasHeightForWidth())
        self.clear_entry_button.setSizePolicy(sizePolicy3)
        font7 = QFont()
        font7.setFamily(u"Microsoft YaHei UI")
        font7.setPointSize(11)
        font7.setBold(True)
        font7.setItalic(False)
        font7.setWeight(75)
        font7.setKerning(True)
        self.clear_entry_button.setFont(font7)
        self.clear_entry_button.setStyleSheet(
            u"QPushButton{\n"
            "background-color:qlineargradient(spread:pad, x1:0.532552, y1:0, x2:0.522, y2:0.926136, stop:0.0547264 rgba(10, 103, 95, 209), stop:1 rgba(13, 136, 125, 209));\n"
            "width:110%;\n"
            "height:40%;\n"
            "color:white;\n"
            "border-radius:8px;\n"
            "}\n"
            "\n"
            "\n"
            "  QPushButton:hover:!pressed\n"
            "{\n"
            "  border: 2px solid rgb(41, 135, 140);\n"
            "background-color:rgb(199, 248, 255);\n"
            "color:black;\n"
            "\n"
            "}")
        self.clear_entry_button.setIconSize(QSize(40, 40))

        self.gridLayout.addWidget(self.clear_entry_button, 12, 2, 1, 1)

        self.enter_data_button = QPushButton(self.data_entry_tab)
        self.enter_data_button.setObjectName(u"enter_data_button")
        sizePolicy3.setHeightForWidth(
            self.enter_data_button.sizePolicy().hasHeightForWidth())
        self.enter_data_button.setSizePolicy(sizePolicy3)
        font8 = QFont()
        font8.setFamily(u"Microsoft YaHei UI")
        font8.setPointSize(11)
        font8.setBold(True)
        font8.setItalic(False)
        font8.setWeight(75)
        self.enter_data_button.setFont(font8)
        self.enter_data_button.setStyleSheet(
            u"QPushButton{\n"
            "background-color:qlineargradient(spread:pad, x1:0.532552, y1:0, x2:0.522, y2:0.926136, stop:0.0547264 rgba(10, 103, 95, 209), stop:1 rgba(13, 136, 125, 209));\n"
            "width:110%;\n"
            "height:40%;\n"
            "color:white;\n"
            "border-radius:8px;\n"
            "}\n"
            "\n"
            "\n"
            "  QPushButton:hover:!pressed\n"
            "{\n"
            "  border: 2px solid rgb(41, 135, 140);\n"
            "background-color:rgb(199, 248, 255);\n"
            "color:black;\n"
            "\n"
            "}")

        self.gridLayout.addWidget(self.enter_data_button, 12, 4, 1, 1)

        self.label_3 = QLabel(self.data_entry_tab)
        self.label_3.setObjectName(u"label_3")
        sizePolicy4 = QSizePolicy(QSizePolicy.Maximum, QSizePolicy.Preferred)
        sizePolicy4.setHorizontalStretch(0)
        sizePolicy4.setVerticalStretch(0)
        sizePolicy4.setHeightForWidth(
            self.label_3.sizePolicy().hasHeightForWidth())
        self.label_3.setSizePolicy(sizePolicy4)
        self.label_3.setFont(font6)

        self.gridLayout.addWidget(self.label_3, 2, 1, 1, 1)

        self.more_trans_detail = QLineEdit(self.data_entry_tab)
        self.more_trans_detail.setObjectName(u"more_trans_detail")
        sizePolicy5 = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Maximum)
        sizePolicy5.setHorizontalStretch(0)
        sizePolicy5.setVerticalStretch(0)
        sizePolicy5.setHeightForWidth(
            self.more_trans_detail.sizePolicy().hasHeightForWidth())
        self.more_trans_detail.setSizePolicy(sizePolicy5)
        self.more_trans_detail.setMaximumSize(QSize(300, 16777215))
        font9 = QFont()
        font9.setFamily(u"Microsoft YaHei UI")
        font9.setPointSize(11)
        font9.setBold(False)
        font9.setItalic(False)
        font9.setWeight(50)
        self.more_trans_detail.setFont(font9)
        self.more_trans_detail.setStyleSheet(
            u"QLineEdit {\n"
            "	border-radius: 5px;\n"
            "	border: 2px solid rgb(27, 29, 35);\n"
            "	padding-left: 10px;\n"
            "}\n"
            "QLineEdit:hover {\n"
            "	border: 2px solid rgb(64, 71, 88);\n"
            "}\n"
            "QLineEdit:focus {\n"
            "	border: 2px solid rgb(91, 101, 124);\n"
            "}")
        self.more_trans_detail.setCursorMoveStyle(Qt.VisualMoveStyle)
        self.more_trans_detail.setClearButtonEnabled(True)

        self.gridLayout.addWidget(self.more_trans_detail, 3, 7, 1, 1)

        self.method_of_trans = QComboBox(self.data_entry_tab)
        self.method_of_trans.setObjectName(u"method_of_trans")
        sizePolicy6 = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
        sizePolicy6.setHorizontalStretch(0)
        sizePolicy6.setVerticalStretch(0)
        sizePolicy6.setHeightForWidth(
            self.method_of_trans.sizePolicy().hasHeightForWidth())
        self.method_of_trans.setSizePolicy(sizePolicy6)
        self.method_of_trans.setMaximumSize(QSize(300, 16777215))
        palette = QPalette()
        gradient = QLinearGradient(0.532552, 0, 0.522, 0.926136)
        gradient.setSpread(QGradient.PadSpread)
        gradient.setCoordinateMode(QGradient.ObjectBoundingMode)
        gradient.setColorAt(0.0199005, QColor(50, 186, 144, 52))
        gradient.setColorAt(0.482587, QColor(65, 156, 128, 54))
        gradient.setColorAt(0.975124, QColor(75, 164, 181, 80))
        brush = QBrush(gradient)
        palette.setBrush(QPalette.Active, QPalette.Button, brush)
        gradient1 = QLinearGradient(0.532552, 0, 0.522, 0.926136)
        gradient1.setSpread(QGradient.PadSpread)
        gradient1.setCoordinateMode(QGradient.ObjectBoundingMode)
        gradient1.setColorAt(0.0199005, QColor(50, 186, 144, 52))
        gradient1.setColorAt(0.482587, QColor(65, 156, 128, 54))
        gradient1.setColorAt(0.975124, QColor(75, 164, 181, 80))
        brush1 = QBrush(gradient1)
        palette.setBrush(QPalette.Active, QPalette.Base, brush1)
        gradient2 = QLinearGradient(0.532552, 0, 0.522, 0.926136)
        gradient2.setSpread(QGradient.PadSpread)
        gradient2.setCoordinateMode(QGradient.ObjectBoundingMode)
        gradient2.setColorAt(0.0199005, QColor(50, 186, 144, 52))
        gradient2.setColorAt(0.482587, QColor(65, 156, 128, 54))
        gradient2.setColorAt(0.975124, QColor(75, 164, 181, 80))
        brush2 = QBrush(gradient2)
        palette.setBrush(QPalette.Active, QPalette.Window, brush2)
        gradient3 = QLinearGradient(0.532552, 0, 0.522, 0.926136)
        gradient3.setSpread(QGradient.PadSpread)
        gradient3.setCoordinateMode(QGradient.ObjectBoundingMode)
        gradient3.setColorAt(0.0199005, QColor(50, 186, 144, 52))
        gradient3.setColorAt(0.482587, QColor(65, 156, 128, 54))
        gradient3.setColorAt(0.975124, QColor(75, 164, 181, 80))
        brush3 = QBrush(gradient3)
        palette.setBrush(QPalette.Inactive, QPalette.Button, brush3)
        gradient4 = QLinearGradient(0.532552, 0, 0.522, 0.926136)
        gradient4.setSpread(QGradient.PadSpread)
        gradient4.setCoordinateMode(QGradient.ObjectBoundingMode)
        gradient4.setColorAt(0.0199005, QColor(50, 186, 144, 52))
        gradient4.setColorAt(0.482587, QColor(65, 156, 128, 54))
        gradient4.setColorAt(0.975124, QColor(75, 164, 181, 80))
        brush4 = QBrush(gradient4)
        palette.setBrush(QPalette.Inactive, QPalette.Base, brush4)
        gradient5 = QLinearGradient(0.532552, 0, 0.522, 0.926136)
        gradient5.setSpread(QGradient.PadSpread)
        gradient5.setCoordinateMode(QGradient.ObjectBoundingMode)
        gradient5.setColorAt(0.0199005, QColor(50, 186, 144, 52))
        gradient5.setColorAt(0.482587, QColor(65, 156, 128, 54))
        gradient5.setColorAt(0.975124, QColor(75, 164, 181, 80))
        brush5 = QBrush(gradient5)
        palette.setBrush(QPalette.Inactive, QPalette.Window, brush5)
        gradient6 = QLinearGradient(0.532552, 0, 0.522, 0.926136)
        gradient6.setSpread(QGradient.PadSpread)
        gradient6.setCoordinateMode(QGradient.ObjectBoundingMode)
        gradient6.setColorAt(0.0199005, QColor(50, 186, 144, 52))
        gradient6.setColorAt(0.482587, QColor(65, 156, 128, 54))
        gradient6.setColorAt(0.975124, QColor(75, 164, 181, 80))
        brush6 = QBrush(gradient6)
        palette.setBrush(QPalette.Disabled, QPalette.Button, brush6)
        gradient7 = QLinearGradient(0.532552, 0, 0.522, 0.926136)
        gradient7.setSpread(QGradient.PadSpread)
        gradient7.setCoordinateMode(QGradient.ObjectBoundingMode)
        gradient7.setColorAt(0.0199005, QColor(50, 186, 144, 52))
        gradient7.setColorAt(0.482587, QColor(65, 156, 128, 54))
        gradient7.setColorAt(0.975124, QColor(75, 164, 181, 80))
        brush7 = QBrush(gradient7)
        palette.setBrush(QPalette.Disabled, QPalette.Base, brush7)
        gradient8 = QLinearGradient(0.532552, 0, 0.522, 0.926136)
        gradient8.setSpread(QGradient.PadSpread)
        gradient8.setCoordinateMode(QGradient.ObjectBoundingMode)
        gradient8.setColorAt(0.0199005, QColor(50, 186, 144, 52))
        gradient8.setColorAt(0.482587, QColor(65, 156, 128, 54))
        gradient8.setColorAt(0.975124, QColor(75, 164, 181, 80))
        brush8 = QBrush(gradient8)
        palette.setBrush(QPalette.Disabled, QPalette.Window, brush8)
        self.method_of_trans.setPalette(palette)
        font10 = QFont()
        font10.setFamily(u"Microsoft YaHei UI")
        font10.setPointSize(12)
        font10.setBold(False)
        font10.setItalic(False)
        font10.setWeight(50)
        self.method_of_trans.setFont(font10)
        self.method_of_trans.setStyleSheet(
            u"QComboBox{\n"
            "	 background-color:qlineargradient(spread:pad, x1:0.532552, y1:0, x2:0.522, y2:0.926136, stop:0.0199005 rgba(50, 186, 144, 52), stop:0.482587 rgba(65, 156, 128, 54), stop:0.975124 rgba(75, 164, 181, 80));\n"
            "}\n"
            "QComboBox:hover{\n"
            "	border: 2px solid rgb(64, 71, 88);\n"
            "   \n"
            "}\n"
            "QComboBox QAbstractItemView {\n"
            "	padding: 10px;\n"
            "\n"
            "	background-color:rgb(170, 255, 230)\n"
            "	\n"
            " \n"
            "}\n"
            "\n"
            "QComboBox QAbstractItemView{border-radius: 5px;\n"
            "	border: 2px ;\n"
            "	padding: 5px;\n"
            "	padding-left: 10px;\n"
            "    }")

        self.gridLayout.addWidget(self.method_of_trans, 2, 7, 1, 1)

        self.horizontalLayout_2 = QHBoxLayout()
        self.horizontalLayout_2.setObjectName(u"horizontalLayout_2")
        self.cash_radio = QRadioButton(self.data_entry_tab)
        self.cash_radio.setObjectName(u"cash_radio")
        sizePolicy7 = QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
        sizePolicy7.setHorizontalStretch(0)
        sizePolicy7.setVerticalStretch(0)
        sizePolicy7.setHeightForWidth(
            self.cash_radio.sizePolicy().hasHeightForWidth())
        self.cash_radio.setSizePolicy(sizePolicy7)
        self.cash_radio.setMinimumSize(QSize(80, 0))
        self.cash_radio.setFont(font9)

        self.horizontalLayout_2.addWidget(self.cash_radio)

        self.main_radio = QRadioButton(self.data_entry_tab)
        self.main_radio.setObjectName(u"main_radio")
        self.main_radio.setMinimumSize(QSize(150, 0))
        self.main_radio.setFont(font9)

        self.horizontalLayout_2.addWidget(self.main_radio)

        self.building_radio = QRadioButton(self.data_entry_tab)
        self.building_radio.setObjectName(u"building_radio")
        self.building_radio.setMinimumSize(QSize(175, 0))
        font11 = QFont()
        font11.setFamily(u"Microsoft YaHei UI")
        font11.setPointSize(11)
        self.building_radio.setFont(font11)

        self.horizontalLayout_2.addWidget(self.building_radio)

        self.gridLayout.addLayout(self.horizontalLayout_2, 5, 7, 1, 1)

        self.label_9 = QLabel(self.data_entry_tab)
        self.label_9.setObjectName(u"label_9")
        sizePolicy2.setHeightForWidth(
            self.label_9.sizePolicy().hasHeightForWidth())
        self.label_9.setSizePolicy(sizePolicy2)
        self.label_9.setFont(font6)

        self.gridLayout.addWidget(self.label_9, 3, 1, 1, 4)

        self.label_4 = QLabel(self.data_entry_tab)
        self.label_4.setObjectName(u"label_4")
        sizePolicy2.setHeightForWidth(
            self.label_4.sizePolicy().hasHeightForWidth())
        self.label_4.setSizePolicy(sizePolicy2)
        self.label_4.setFont(font6)
        self.label_4.setStyleSheet(u"")

        self.gridLayout.addWidget(self.label_4, 4, 1, 1, 1)

        self.label_5 = QLabel(self.data_entry_tab)
        self.label_5.setObjectName(u"label_5")
        sizePolicy4.setHeightForWidth(
            self.label_5.sizePolicy().hasHeightForWidth())
        self.label_5.setSizePolicy(sizePolicy4)
        self.label_5.setFont(font6)

        self.gridLayout.addWidget(self.label_5, 7, 1, 1, 1)

        self.horizontalSpacer_9 = QSpacerItem(100, 20, QSizePolicy.Expanding,
                                              QSizePolicy.Minimum)

        self.gridLayout.addItem(self.horizontalSpacer_9, 12, 3, 1, 1)

        self.horizontalSpacer_8 = QSpacerItem(100, 20, QSizePolicy.Expanding,
                                              QSizePolicy.Minimum)

        self.gridLayout.addItem(self.horizontalSpacer_8, 12, 7, 1, 1)

        self.horizontalLayout_4 = QHBoxLayout()
        self.horizontalLayout_4.setObjectName(u"horizontalLayout_4")
        self.reversed_entry_increase = QCheckBox(self.data_entry_tab)
        self.reversed_entry_increase.setObjectName(u"reversed_entry_increase")
        self.reversed_entry_increase.setFont(font11)

        self.horizontalLayout_4.addWidget(self.reversed_entry_increase)

        self.reversed_entry_decrease = QCheckBox(self.data_entry_tab)
        self.reversed_entry_decrease.setObjectName(u"reversed_entry_decrease")
        self.reversed_entry_decrease.setFont(font11)

        self.horizontalLayout_4.addWidget(self.reversed_entry_decrease)

        self.gridLayout.addLayout(self.horizontalLayout_4, 8, 7, 1, 1)

        self.date_of_entry = QDateEdit(self.data_entry_tab)
        self.date_of_entry.setObjectName(u"date_of_entry")
        sizePolicy6.setHeightForWidth(
            self.date_of_entry.sizePolicy().hasHeightForWidth())
        self.date_of_entry.setSizePolicy(sizePolicy6)
        self.date_of_entry.setMaximumSize(QSize(150, 16777215))
        self.date_of_entry.setFont(font9)
        self.date_of_entry.setStyleSheet(
            u"QDateEdit{\n"
            "	border-radius: 5px;\n"
            "	border: 2px solid rgb(27, 29, 35);\n"
            "	padding: 5px;\n"
            "	padding-left: 10px;\n"
            "\n"
            "   background-color:qlineargradient(spread:pad, x1:0.532552, y1:0, x2:0.522, y2:0.926136, stop:0.0199005 rgba(50, 186, 144, 52), stop:0.482587 rgba(65, 156, 128, 54), stop:0.975124 rgba(75, 164, 181, 80));\n"
            "		\n"
            "		\n"
            "}\n"
            "QDateEdit:hover{\n"
            "	border: 2px solid rgb(64, 71, 88);\n"
            "   \n"
            "	\n"
            "		\n"
            "  \n"
            "}\n"
            "\n"
            "QCalendarWidget QToolButton{\n"
            "\n"
            "  	color: black;\n"
            "  	background-color:rgb(156, 255, 231);}\n"
            "\n"
            " \n"
            "\n"
            "QCalendarWidget QAbstractItemView:enabled \n"
            "  {\n"
            "  \n"
            "  	color: black;  \n"
            "  	background-color: rgb(198, 255, 232);  \n"
            "  	selection-background-color: rgb(64, 64, 64); \n"
            "  	selection-color: rgb(0, 255, 0); \n"
            "  }")
        self.date_of_entry.setMinimumDateTime(
            QDateTime(QDate(1767, 9, 14), QTime(0, 0, 0)))
        self.date_of_entry.setCalendarPopup(True)

        self.gridLayout.addWidget(self.date_of_entry, 4, 7, 1, 1)

        self.money = QLineEdit(self.data_entry_tab)
        self.money.setObjectName(u"money")
        sizePolicy6.setHeightForWidth(
            self.money.sizePolicy().hasHeightForWidth())
        self.money.setSizePolicy(sizePolicy6)
        self.money.setMaximumSize(QSize(200, 16777215))
        self.money.setFont(font9)
        self.money.setStyleSheet(u"QLineEdit {\n"
                                 "	border-radius: 5px;\n"
                                 "	border: 2px solid rgb(27, 29, 35);\n"
                                 "	padding-left: 10px;\n"
                                 "}\n"
                                 "QLineEdit:hover {\n"
                                 "	border: 2px solid rgb(64, 71, 88);\n"
                                 "}\n"
                                 "QLineEdit:focus {\n"
                                 "	border: 2px solid rgb(91, 101, 124);\n"
                                 "}")
        self.money.setInputMethodHints(Qt.ImhDigitsOnly)
        self.money.setText(u"")
        self.money.setFrame(True)
        self.money.setClearButtonEnabled(True)

        self.gridLayout.addWidget(self.money, 7, 7, 1, 1)

        self.label_2 = QLabel(self.data_entry_tab)
        self.label_2.setObjectName(u"label_2")
        sizePolicy2.setHeightForWidth(
            self.label_2.sizePolicy().hasHeightForWidth())
        self.label_2.setSizePolicy(sizePolicy2)
        self.label_2.setFont(font6)

        self.gridLayout.addWidget(self.label_2, 1, 1, 1, 1)

        self.trans_type = QComboBox(self.data_entry_tab)
        self.trans_type.addItem(u"Income")
        self.trans_type.addItem("")
        self.trans_type.addItem("")
        self.trans_type.addItem("")
        self.trans_type.setObjectName(u"trans_type")
        sizePolicy6.setHeightForWidth(
            self.trans_type.sizePolicy().hasHeightForWidth())
        self.trans_type.setSizePolicy(sizePolicy6)
        self.trans_type.setMaximumSize(QSize(300, 16777215))
        self.trans_type.setFont(font9)
        self.trans_type.setStyleSheet(
            u"QComboBox{\n"
            "	 background-color:qlineargradient(spread:pad, x1:0.532552, y1:0, x2:0.522, y2:0.926136, stop:0.0199005 rgba(50, 186, 144, 52), stop:0.482587 rgba(65, 156, 128, 54), stop:0.975124 rgba(75, 164, 181, 80));\n"
            "	\n"
            "		\n"
            "	\n"
            "\n"
            "	\n"
            "\n"
            "    \n"
            "}\n"
            "QComboBox:hover{\n"
            "	border: 2px solid rgb(64, 71, 88);\n"
            "   \n"
            "	\n"
            "}\n"
            "QComboBox QAbstractItemView {\n"
            "	padding: 10px;\n"
            "\n"
            "	background-color:rgb(170, 255, 230)\n"
            "	\n"
            " \n"
            "}\n"
            "\n"
            "QComboBox QAbstractItemView{border-radius: 5px;\n"
            "	border: 2px ;\n"
            "	padding: 5px;\n"
            "	padding-left: 10px;\n"
            "    }")
        self.trans_type.setSizeAdjustPolicy(QComboBox.AdjustToContents)
        self.trans_type.setFrame(True)

        self.gridLayout.addWidget(self.trans_type, 1, 7, 1, 1)

        self.cheque_label = QLabel(self.data_entry_tab)
        self.cheque_label.setObjectName(u"cheque_label")
        self.cheque_label.setFont(font11)

        self.gridLayout.addWidget(self.cheque_label, 6, 1, 1, 1)

        self.cheque_number = QLineEdit(self.data_entry_tab)
        self.cheque_number.setObjectName(u"cheque_number")
        sizePolicy6.setHeightForWidth(
            self.cheque_number.sizePolicy().hasHeightForWidth())
        self.cheque_number.setSizePolicy(sizePolicy6)
        self.cheque_number.setMaximumSize(QSize(200, 16777215))
        self.cheque_number.setFont(font11)
        self.cheque_number.setStyleSheet(
            u"QLineEdit {\n"
            "	border-radius: 5px;\n"
            "	border: 2px solid rgb(27, 29, 35);\n"
            "	padding-left: 10px;\n"
            "}\n"
            "QLineEdit:hover {\n"
            "	border: 2px solid rgb(64, 71, 88);\n"
            "}\n"
            "QLineEdit:focus {\n"
            "	border: 2px solid rgb(91, 101, 124);\n"
            "}")

        self.gridLayout.addWidget(self.cheque_number, 6, 7, 1, 1)

        self.tabWidget.addTab(self.data_entry_tab, "")
        self.report_gen_tab = QWidget()
        self.report_gen_tab.setObjectName(u"report_gen_tab")
        self.gridLayout_2 = QGridLayout(self.report_gen_tab)
        self.gridLayout_2.setObjectName(u"gridLayout_2")
        self.gridLayout_2.setHorizontalSpacing(10)
        self.gridLayout_2.setVerticalSpacing(20)
        self.gridLayout_2.setContentsMargins(80, 20, 20, 10)
        self.label_6 = QLabel(self.report_gen_tab)
        self.label_6.setObjectName(u"label_6")
        sizePolicy2.setHeightForWidth(
            self.label_6.sizePolicy().hasHeightForWidth())
        self.label_6.setSizePolicy(sizePolicy2)
        self.label_6.setFont(font9)

        self.gridLayout_2.addWidget(self.label_6, 3, 0, 1, 1)

        self.report_date_from = QDateEdit(self.report_gen_tab)
        self.report_date_from.setObjectName(u"report_date_from")
        sizePolicy3.setHeightForWidth(
            self.report_date_from.sizePolicy().hasHeightForWidth())
        self.report_date_from.setSizePolicy(sizePolicy3)
        font12 = QFont()
        font12.setFamily(u"Microsoft YaHei UI")
        font12.setPointSize(11)
        font12.setBold(False)
        font12.setItalic(False)
        font12.setUnderline(False)
        font12.setWeight(50)
        self.report_date_from.setFont(font12)
        self.report_date_from.setStyleSheet(
            u"QDateEdit{\n"
            "	border-radius: 5px;\n"
            "	border: 2px solid rgb(27, 29, 35);\n"
            "	padding: 5px;\n"
            "	padding-left: 10px;\n"
            "\n"
            "   background-color:qlineargradient(spread:pad, x1:0.532552, y1:0, x2:0.522, y2:0.926136, stop:0.0199005 rgba(50, 186, 144, 52), stop:0.482587 rgba(65, 156, 128, 54), stop:0.975124 rgba(75, 164, 181, 80));\n"
            "		\n"
            "		\n"
            "}\n"
            "QDateEdit:hover{\n"
            "	border: 2px solid rgb(64, 71, 88);\n"
            "   \n"
            "	\n"
            "		\n"
            "  \n"
            "}\n"
            "\n"
            "QCalendarWidget QToolButton{\n"
            "\n"
            "  	color: black;\n"
            "  	background-color:rgb(156, 255, 231);}\n"
            "\n"
            " \n"
            "\n"
            "QCalendarWidget QAbstractItemView:enabled \n"
            "  {\n"
            "  \n"
            "  	color: black;  \n"
            "  	background-color: rgb(198, 255, 232);  \n"
            "  	selection-background-color: rgb(64, 64, 64); \n"
            "  	selection-color: rgb(0, 255, 0); \n"
            "  }")
        self.report_date_from.setDateTime(
            QDateTime(QDate(2020, 1, 1), QTime(0, 0, 0)))
        self.report_date_from.setMinimumDateTime(
            QDateTime(QDate(2010, 9, 14), QTime(0, 0, 0)))
        self.report_date_from.setMaximumDate(QDate(9999, 11, 30))
        self.report_date_from.setCalendarPopup(True)
        self.report_date_from.setDate(QDate(2020, 1, 1))

        self.gridLayout_2.addWidget(self.report_date_from, 3, 4, 1, 1)

        self.label_7 = QLabel(self.report_gen_tab)
        self.label_7.setObjectName(u"label_7")
        sizePolicy2.setHeightForWidth(
            self.label_7.sizePolicy().hasHeightForWidth())
        self.label_7.setSizePolicy(sizePolicy2)
        self.label_7.setFont(font9)

        self.gridLayout_2.addWidget(self.label_7, 4, 0, 1, 1)

        self.report_date_to = QDateEdit(self.report_gen_tab)
        self.report_date_to.setObjectName(u"report_date_to")
        sizePolicy3.setHeightForWidth(
            self.report_date_to.sizePolicy().hasHeightForWidth())
        self.report_date_to.setSizePolicy(sizePolicy3)
        self.report_date_to.setFont(font12)
        self.report_date_to.setStyleSheet(
            u"QDateEdit{\n"
            "	border-radius: 5px;\n"
            "	border: 2px solid rgb(27, 29, 35);\n"
            "	padding: 5px;\n"
            "	padding-left: 10px;\n"
            "\n"
            "   background-color:qlineargradient(spread:pad, x1:0.532552, y1:0, x2:0.522, y2:0.926136, stop:0.0199005 rgba(50, 186, 144, 52), stop:0.482587 rgba(65, 156, 128, 54), stop:0.975124 rgba(75, 164, 181, 80));\n"
            "		\n"
            "		\n"
            "}\n"
            "QDateEdit:hover{\n"
            "	border: 2px solid rgb(64, 71, 88);\n"
            "   \n"
            "	\n"
            "		\n"
            "  \n"
            "}\n"
            "\n"
            "QCalendarWidget QToolButton{\n"
            "\n"
            "  	color: black;\n"
            "  	background-color:rgb(156, 255, 231);}\n"
            "\n"
            " \n"
            "\n"
            "QCalendarWidget QAbstractItemView:enabled \n"
            "  {\n"
            "  \n"
            "  	color: black;  \n"
            "  	background-color: rgb(198, 255, 232);  \n"
            "  	selection-background-color: rgb(64, 64, 64); \n"
            "  	selection-color: rgb(0, 255, 0); \n"
            "  }")
        self.report_date_to.setWrapping(False)
        self.report_date_to.setReadOnly(False)
        self.report_date_to.setProperty("showGroupSeparator", False)
        self.report_date_to.setDateTime(
            QDateTime(QDate(2020, 1, 1), QTime(0, 0, 0)))
        self.report_date_to.setMinimumDateTime(
            QDateTime(QDate(2010, 9, 14), QTime(0, 0, 0)))
        self.report_date_to.setCurrentSection(QDateTimeEdit.DaySection)
        self.report_date_to.setCalendarPopup(True)
        self.report_date_to.setTimeSpec(Qt.TimeZone)

        self.gridLayout_2.addWidget(self.report_date_to, 4, 4, 1, 1)

        self.label_12 = QLabel(self.report_gen_tab)
        self.label_12.setObjectName(u"label_12")
        sizePolicy2.setHeightForWidth(
            self.label_12.sizePolicy().hasHeightForWidth())
        self.label_12.setSizePolicy(sizePolicy2)
        font13 = QFont()
        font13.setFamily(u"Microsoft YaHei UI")
        font13.setPointSize(11)
        font13.setBold(False)
        font13.setWeight(50)
        self.label_12.setFont(font13)

        self.gridLayout_2.addWidget(self.label_12, 6, 0, 1, 1)

        self.comboBox = QComboBox(self.report_gen_tab)
        self.comboBox.addItem("")
        self.comboBox.addItem("")
        self.comboBox.setObjectName(u"comboBox")
        sizePolicy3.setHeightForWidth(
            self.comboBox.sizePolicy().hasHeightForWidth())
        self.comboBox.setSizePolicy(sizePolicy3)
        self.comboBox.setMinimumSize(QSize(70, 0))
        self.comboBox.setFont(font13)
        self.comboBox.setStyleSheet(u"QComboBox{\n"
                                    "	border-radius: 5px;\n"
                                    "	border: 2px solid rgb(27, 29, 35);\n"
                                    "	padding: 5px;\n"
                                    "	padding-left: 10px;\n"
                                    "}\n"
                                    "QComboBox:hover{\n"
                                    "	border: 2px solid rgb(64, 71, 88);\n"
                                    "}\n"
                                    "QComboBox QAbstractItemView {\n"
                                    "	padding: 10px;\n"
                                    "}")

        self.gridLayout_2.addWidget(self.comboBox, 6, 4, 1, 1)

        self.preview_report_button = QPushButton(self.report_gen_tab)
        self.preview_report_button.setObjectName(u"preview_report_button")
        sizePolicy3.setHeightForWidth(
            self.preview_report_button.sizePolicy().hasHeightForWidth())
        self.preview_report_button.setSizePolicy(sizePolicy3)
        self.preview_report_button.setMinimumSize(QSize(157, 0))
        self.preview_report_button.setFont(font8)
        self.preview_report_button.setStyleSheet(
            u"QPushButton{\n"
            "background-color:qlineargradient(spread:pad, x1:0.532552, y1:0, x2:0.522, y2:0.926136, stop:0.0547264 rgba(10, 103, 95, 209), stop:1 rgba(13, 136, 125, 209));\n"
            "width:130%;\n"
            "height:40%;\n"
            "color:white;\n"
            "border-radius:8px;\n"
            "}\n"
            "\n"
            "QPushButton:hover:!pressed\n"
            "{\n"
            "  border: 2px solid rgb(41, 135, 140);\n"
            "background-color:rgb(199, 248, 255);\n"
            "color:black;\n"
            "}")

        self.gridLayout_2.addWidget(self.preview_report_button, 7, 2, 1, 1)

        self.export_pdf_button = QPushButton(self.report_gen_tab)
        self.export_pdf_button.setObjectName(u"export_pdf_button")
        sizePolicy3.setHeightForWidth(
            self.export_pdf_button.sizePolicy().hasHeightForWidth())
        self.export_pdf_button.setSizePolicy(sizePolicy3)
        self.export_pdf_button.setMinimumSize(QSize(208, 0))
        self.export_pdf_button.setFont(font8)
        self.export_pdf_button.setLayoutDirection(Qt.LeftToRight)
        self.export_pdf_button.setStyleSheet(
            u"QPushButton{\n"
            "background-color:qlineargradient(spread:pad, x1:0.532552, y1:0, x2:0.522, y2:0.926136, stop:0.0547264 rgba(10, 103, 95, 209), stop:1 rgba(13, 136, 125, 209));\n"
            "width:170%;\n"
            "height:40%;\n"
            "color:white;\n"
            "border-radius:8px;\n"
            "}\n"
            "\n"
            "QPushButton:hover:!pressed\n"
            "{\n"
            "  border: 2px solid rgb(41, 135, 140);\n"
            "background-color:rgb(199, 248, 255);\n"
            "color:black;\n"
            "}")
        self.export_pdf_button.setFlat(False)

        self.gridLayout_2.addWidget(self.export_pdf_button, 7, 3, 1, 1)

        self.label_8 = QLabel(self.report_gen_tab)
        self.label_8.setObjectName(u"label_8")
        sizePolicy7.setHeightForWidth(
            self.label_8.sizePolicy().hasHeightForWidth())
        self.label_8.setSizePolicy(sizePolicy7)
        font14 = QFont()
        font14.setFamily(u"Microsoft YaHei UI")
        font14.setPointSize(15)
        font14.setBold(False)
        font14.setItalic(False)
        font14.setWeight(50)
        self.label_8.setFont(font14)
        self.label_8.setStyleSheet(u"background-color:rgba(0,0,0,0%);\n"
                                   "color:rgb(35, 93, 74)")
        self.label_8.setAlignment(Qt.AlignCenter)
        self.label_8.setMargin(10)

        self.gridLayout_2.addWidget(self.label_8, 0, 1, 1, 3)

        self.print_report_button = QPushButton(self.report_gen_tab)
        self.print_report_button.setObjectName(u"print_report_button")
        sizePolicy3.setHeightForWidth(
            self.print_report_button.sizePolicy().hasHeightForWidth())
        self.print_report_button.setSizePolicy(sizePolicy3)
        self.print_report_button.setMinimumSize(QSize(140, 0))
        self.print_report_button.setFont(font8)
        self.print_report_button.setStyleSheet(
            u"QPushButton{\n"
            "background-color:qlineargradient(spread:pad, x1:0.532552, y1:0, x2:0.522, y2:0.926136, stop:0.0547264 rgba(10, 103, 95, 209), stop:1 rgba(13, 136, 125, 209));\n"
            "width:100%;\n"
            "height:40%;\n"
            "color:white;\n"
            "border-radius:8px;\n"
            "}\n"
            "\n"
            "QPushButton:hover:!pressed\n"
            "{\n"
            "  border: 2px solid rgb(41, 135, 140);\n"
            "background-color:rgb(199, 248, 255);\n"
            "color:black;\n"
            "}")

        self.gridLayout_2.addWidget(self.print_report_button, 7, 1, 1, 1)

        self.tabWidget.addTab(self.report_gen_tab, "")

        self.verticalLayout.addWidget(self.tabWidget)

        self.verticalLayout_2.addLayout(self.verticalLayout)

        DsManager.setCentralWidget(self.centralwidget)
        self.menubar = QMenuBar(DsManager)
        self.menubar.setObjectName(u"menubar")
        self.menubar.setGeometry(QRect(0, 0, 1156, 24))
        font15 = QFont()
        font15.setFamily(u"Candara")
        font15.setBold(True)
        font15.setWeight(75)
        self.menubar.setFont(font15)
        self.menubar.setStyleSheet(u"QMenuBar{\n"
                                   "background-color:rgb(122, 224, 210);\n"
                                   "}\n"
                                   "\n"
                                   "QMenu:!pressed\n"
                                   "{\n"
                                   "	selection-color: rgb(85, 0, 127);\n"
                                   "	background-color:rgb(139, 234, 255);\n"
                                   "}")
        self.menuAbout = QMenu(self.menubar)
        self.menuAbout.setObjectName(u"menuAbout")
        self.menuFile = QMenu(self.menubar)
        self.menuFile.setObjectName(u"menuFile")
        DsManager.setMenuBar(self.menubar)
        self.statusbar = QStatusBar(DsManager)
        self.statusbar.setObjectName(u"statusbar")
        DsManager.setStatusBar(self.statusbar)

        self.menubar.addAction(self.menuFile.menuAction())
        self.menubar.addAction(self.menuAbout.menuAction())
        self.menuAbout.addAction(self.actionAbut_DS_Manager)
        self.menuFile.addAction(self.actionBackup_Database)
        self.menuFile.addAction(self.actionRestore_Database)

        self.retranslateUi(DsManager)

        self.tabWidget.setCurrentIndex(0)

        QMetaObject.connectSlotsByName(DsManager)
Beispiel #26
0
    def _updateAll(self, newGroup=None):
        try:
            self.chSelector.itemChanged.disconnect(self.itemChanged)
            self.sSelector.itemChanged.disconnect(self.itemChanged)
        except:
            pass
        if newGroup == '':
            return
        
        chStruct = self.chartData[newGroup]
        sStruct = self.chartData[newGroup].getColStructure()
        
        self.chSelector.clear()
        for ws in chStruct:
            gparent = QTreeWidgetItem(self.chSelector)
            gparent.setText(0, ws)
            gparent.setBackgroundColor(0, Qt.white)
            gparent.setFlags(Qt.ItemIsEnabled)
            for key in chStruct[ws]:
                parent = QTreeWidgetItem(gparent)
                parent.setText(0, key)
                if chStruct[ws][key][0] == True:
                    dataNames = chStruct[ws][key][3]
                    sColor = QColor(chStruct[ws][key][4])
                    sColor.setAlpha(100)
                    parent.setBackgroundColor(0, sColor)
                else:
                    dataNames = ','.join(chStruct[ws][key][2])
                    sColor = QColor(chStruct[ws][key][3])
                    sColor.setAlpha(100)
                    parent.setBackgroundColor(0, sColor)
                    
                parent.setText(1, dataNames)
                if chStruct[ws][key][1] == True:
                    parent.setCheckState(0, Qt.Checked)
                else:
                    parent.setCheckState(0, Qt.Unchecked)
                parent.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)
        
        self.sSelector.clear()
        self.gSelector.clear()
        for ws in sStruct:
            firstChannel = sStruct[ws][0]
            isOneSignal = self.chartData[newGroup][firstChannel][ws][0]
            if isOneSignal:
                gparent = QTreeWidgetItem(self.sSelector)
                gparent.setText(0, ws)
                gparent.setFlags(Qt.ItemIsEnabled | Qt.ItemIsDragEnabled
                                 | Qt.ItemIsSelectable | Qt.ItemIsUserCheckable)
                if True:
##                if chStruct['CH1'][ws][5] == True:
                    gparent.setCheckState(0, Qt.Checked) 
                else:
                    gparent.setCheckState(0, Qt.Unchecked)
                    
                for key in sStruct[ws]:
                    parent = QTreeWidgetItem(gparent)
                    parent.setText(0, key)
                    if chStruct[key][ws][2] == True:
                        parent.setCheckState(0, Qt.Checked)
                    else:
                        parent.setCheckState(0, Qt.Unchecked)
                    parent.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)
                    sColor = QColor(chStruct[key][ws][4])
                    sColor.setAlpha(100)
                    sGradient = QLinearGradient(0, 0, 100, 10)
                    sGradient.setColorAt(0, sColor)
                    sGradient.setColorAt(1, Qt.white)
                    sBrush = QBrush(sGradient)
                    sBrush.setStyle(Qt.LinearGradientPattern)
                    sBrush.setColor(sColor)
                    gparent.setBackground(0, sBrush)
                    
            else:
                gparent = QTreeWidgetItem(self.gSelector)
                gparent.setText(0, ws)
                gparent.setFlags(Qt.ItemIsEnabled | Qt.ItemIsDropEnabled
                                 | Qt.ItemIsUserCheckable)
                if chStruct['CH1'][ws][5] == True:
                    gparent.setCheckState(0, Qt.Checked)
                else:
                    gparent.setCheckState(0, Qt.Unchecked)
                
                signalNames = chStruct[key][ws][2]
                sColor = QColor(chStruct[key][ws][3])
                sColor.setAlpha(100)
                gparent.setBackgroundColor(0, sColor)
                for signal in signalNames:
                    parent = QTreeWidgetItem(gparent)
                    parent.setText(0, signal)
                    parent.setFlags(Qt.ItemIsEnabled)

                    for key in sStruct[signal]:
                        sColor = QColor(chStruct[key][signal][4])
                        sColor.setAlpha(100)
                        parent.setBackgroundColor(0, sColor)
                        break                   
            
        self.chSelector.itemChanged.connect(self.itemChanged)
        self.sSelector.itemChanged.connect(self.itemChanged)
        self.curSelect = None
Beispiel #27
0
    def __init__(self):
        global pixmapDict, specialDescriptionDict
        super(MainWindow, self).__init__()
        self.ui = Ui_pipboy()
        self.ui.setupUi(self)

        self.ui.chartContainer.setContentsMargins(0, 0, 0, 0)

        self.anim = QTimeLine(20000, self)
        self.anim.setFrameRange(0, 500)
        self.anim.setLoopCount(0)
        self.anim.setUpdateInterval(16)
        self.anim.frameChanged[int].connect(
            self.ui.perks_description.verticalScrollBar().setValue)
        self.anim.frameChanged[int].connect(
            self.ui.aid_effect_label.verticalScrollBar().setValue)
        self.anim.frameChanged[int].connect(
            self.ui.data_description.verticalScrollBar().setValue)

        #self.anim2 = QPropertyAnimation(self.ui.main_tab, b"pos")
        #self.anim2.setEasingCurve(QEasingCurve.OutBounce)
        #self.anim2.setDuration(2000)
        #self.anim2.setStartValue(QPoint(10, -400))
        #self.anim2.setEndValue(QPoint(10, 0))
        #self.anim2.start()

        self.random = QRandomGenerator.global_()

        self.ui.stat_tab.setFocus()
        self.ui.stat_tab.currentChanged.connect(self.shift)
        self.ui.stat_tab.installEventFilter(self)
        self.ui.inv_tab.installEventFilter(self)

        self.ui.special_list.installEventFilter(self)
        self.ui.perks_list.installEventFilter(self)
        self.ui.test_list.installEventFilter(self)
        self.ui.apparel_list.installEventFilter(self)
        self.ui.aid_list.installEventFilter(self)
        self.ui.ammo_list.installEventFilter(self)
        self.ui.data_list.installEventFilter(self)
        self.ui.radio_list.installEventFilter(self)

        self.ui.main_img.setPixmap(description.main_img_pixmap)

        self.ui.special_image.setPixmap(description.pixmapDict.get(0))
        self.ui.perks_image.setPixmap(description.pixmatPerksDict.get(0))
        self.ui.weapon_image.setPixmap(description.pixmapWeaponDict.get(0))
        self.ui.apparel_image.setPixmap(description.pixmapWeaponDict.get(0))
        self.ui.aid_image.setPixmap(description.pixmapAidDict.get(0))
        self.ui.ammo_image.setPixmap(description.pixmapAmmoDict.get(0))

        lay = QVBoxLayout(self.ui.chartContainer)
        lay.setContentsMargins(0, 0, 0, 0)

        self.chartview = QtCharts.QChartView()
        self.chartview.setContentsMargins(0, 0, 0, 0)
        lay.addWidget(self.chartview)

        self.chart = QtCharts.QChart()
        self.chart.legend().hide()
        self.chart.setAnimationOptions(QtCharts.QChart.SeriesAnimations)

        self.series = QtCharts.QLineSeries()
        self.pen = QPen(QColor(119, 251, 81, 255))
        self.pen.setWidth(3)
        self.pen.setJoinStyle(Qt.RoundJoin)
        self.series.setPen(self.pen)

        backgroundGradient = QLinearGradient(QPointF(100, 100),
                                             QPointF(200, 200))

        backgroundGradient.setColorAt(0, QColor(0, 0, 0, 255))
        backgroundGradient.setColorAt(1, QColor(0, 0, 0, 255))
        self.chart.setBackgroundBrush(backgroundGradient)
        self.chart.setPlotAreaBackgroundBrush(backgroundGradient)

        self.chart.addSeries(self.series)

        self.chart.createDefaultAxes()

        self.chart.axisX(self.series).setVisible(False)
        self.chart.axisY(self.series).setVisible(False)
        self.chart.axisY(self.series).setRange(0, 100)
        self.chartview.setChart(self.chart)

        self.play = False
        self.player = QMediaPlayer()

        self.playlistFalloutNewVegas = QMediaPlaylist(self.player)
        self.playlistFalloutNewVegas.addMedia(
            QMediaContent(description.falooutNewVegas))
        self.playlistFalloutNewVegas.setCurrentIndex(1)

        self.playListMohaveMusic = QMediaPlaylist(self.player)

        for url in description.mohaveMusic:
            self.playListMohaveMusic.addMedia(QMediaContent(url))

        self.playListMohaveMusic.setCurrentIndex(1)

        self.playlisNewVegas = QMediaPlaylist(self.player)

        for url in description.newVegas:
            self.playlisNewVegas.addMedia(QMediaContent(url))

        self.playlisNewVegas.setCurrentIndex(1)

        self.playlistDict = {
            0: self.playlistFalloutNewVegas,
            1: self.playListMohaveMusic,
            2: self.playlisNewVegas
        }
Beispiel #28
0
x = [x for x in range(1, 3, 1)]
y1 = [5, 7]
y2 = [3, 4]

for i in range(len(x)):
    upperSeries.append(x[i], y1[i])
    lowerSeries.append(x[i], y2[i])

series = QtCharts.QAreaSeries(upperSeries, lowerSeries)

pen = QPen(Qt.red)
pen.setWidth(3)
series.setPen(pen)

gradient = QLinearGradient(QPointF(0, 0), QPointF(0, 1))
gradient.setColorAt(0.0, QColor(255, 255, 255))
gradient.setColorAt(1.0, QColor(0, 255, 0))
gradient.setCoordinateMode(QGradient.ObjectBoundingMode)
series.setBrush(gradient)

chart = QtCharts.QChart()
chart.addSeries(series)
chart.setTitle('Simple Area Chart')
chart.legend().hide()
chart.createDefaultAxes()
chart.axes(Qt.Horizontal)[0].setRange(0, 3)
chart.axes(Qt.Vertical)[0].setRange(0, 10)

chartView = QtCharts.QChartView(chart)
chartView.setWindowTitle('Area Chart')
chartView.resize(800, 600)
Beispiel #29
0
    xaxis.grid().setSubGridPen(QPen(QColor(80, 80, 80), 1, Qt.DotLine))
    yaxis.grid().setSubGridPen(QPen(QColor(80, 80, 80), 1, Qt.DotLine))
    xaxis.grid().setSubGridVisible(True)
    yaxis.grid().setSubGridVisible(True)
    xaxis.grid().setZeroLinePen(Qt.NoPen)
    yaxis.grid().setZeroLinePen(Qt.NoPen)

    lineEnd = QCPLineEnding.esSpikeArrow
    lineEnd2 = QCPLineEnding(QCPLineEnding.esSpikeArrow)
    xaxis.setUpperEnding(lineEnd2)
    yaxis.setUpperEnding(lineEnd2)

    plotGradient = QLinearGradient()
    plotGradient.setStart(0, 0)
    plotGradient.setFinalStop(0, 350)
    plotGradient.setColorAt(0, QColor(80, 80, 80))
    plotGradient.setColorAt(1, QColor(50, 50, 50))
    customPlot.setBackground(plotGradient)

    axisRectGradient = QLinearGradient()
    axisRectGradient.setStart(0, 0)
    axisRectGradient.setFinalStop(0, 350)
    axisRectGradient.setColorAt(0, QColor(80, 80, 80))
    axisRectGradient.setColorAt(1, QColor(30, 30, 30))
    customPlot.axisRect().setBackground(axisRectGradient)

    font = QtGui.QFont()
    font.setPointSize(12)
    color = QColor(Qt.white)

    textGradient = QLinearGradient()
Beispiel #30
0
class ColorTransferFunctionIntervalView(QGraphicsRectItem):
    def __init__(self,
                 viewer: ColorTransferFunctionViewer,
                 begin_point: ColorTransferFunctionPoint,
                 end_point: ColorTransferFunctionPoint,
                 parent: QGraphicsItem = None):
        super().__init__(parent)

        self.viewer = viewer
        self._begin_point = None
        self._end_point = None
        self.chart = self.viewer.chart

        self.brush_gradient = QLinearGradient()
        self.brush_gradient.setStart(QPointF(0, 0))
        self.brush_gradient.setFinalStop(QPointF(1, 0))
        self.brush_gradient.setCoordinateMode(QGradient.ObjectMode)

        self.setPen(QColor('#404040'))

        self.begin_point = begin_point
        self.end_point = end_point

    @property
    def begin_point(self):
        return self._begin_point

    @begin_point.setter
    def begin_point(self, value):
        if self._begin_point != value:
            self._begin_point = value
            self._begin_point.x_changed.connect(self._on_point_x_changed)
            self._begin_point.color_array_changed.connect(
                self._on_begin_point_color_array_changed)
            self._update_begin_brush()

    @property
    def end_point(self):
        return self._end_point

    @end_point.setter
    def end_point(self, value):
        if self._end_point != value:
            self._end_point = value
            self._end_point.x_changed.connect(self._on_point_x_changed)
            self._end_point.color_array_changed.connect(
                self._on_end_point_color_array_changed)
            self._update_end_brush()

    def _on_point_x_changed(self, x: float):
        self.update()

    def _on_begin_point_color_array_changed(self, color_array: np.ndarray):
        self._update_begin_brush()

    def _on_end_point_color_array_changed(self, color_array: np.ndarray):
        self._update_end_brush()

    def _update_begin_brush(self):
        self.brush_gradient.setColorAt(0, self.begin_point.color)
        self.setBrush(self.brush_gradient)

    def _update_end_brush(self):
        self.brush_gradient.setColorAt(1, self.end_point.color)
        self.setBrush(self.brush_gradient)

    def update(self, rect: QRectF = QRectF()):
        super().update(rect)

        top_left_interval_pos = self.chart.mapToPosition(
            QPointF(self.begin_point.x, 1))
        bottom_right_interval_pos = self.chart.mapToPosition(
            QPointF(self.end_point.x, 0))
        self.setRect(QRectF(top_left_interval_pos, bottom_right_interval_pos))

    def __lt__(self, other):
        return self.begin_point.x < other.begin_point.x
def createAreaChart(data):
    """
    axisX = QtCharts.QDateTimeAxis();
    # axisX.setTickCount(10);
    
    axisX.setFormat("yyyy");
    #axisX.setFormat("yyyy/MM/dd hh:mm:ss:zzz");
    #axisX.setFormat("hh:mm:ss:zzz");
    
    axisX.setTitleText("Time");
    chart.addAxis(axisX, Qt.AlignBottom);

    axisY = QtCharts.QValueAxis();
    # axisY.setLabelFormat("%.2f");
    axisY.setTitleText("%");
    chart.addAxis(axisY, Qt.AlignLeft);

    # chart.axes(Qt.Vertical)[0].setRange(0, 100)
    # chart.axes(Qt.Vertical)[0].setRange(0, 3)
    """

    series0 = QtCharts.QSplineSeries()

    series0.append(QPointF(1, 5))
    series0.append(QPointF(3, 7))
    series0.append(QPointF(7, 6))
    series0.append(QPointF(9, 7))
    series0.append(QPointF(12, 6))
    series0.append(QPointF(16, 7))
    series0.append(QPointF(18, 5))

    series1 = QtCharts.QSplineSeries()

    series1.append(QPointF(1, 3))
    series1.append(QPointF(3, 4))
    series1.append(QPointF(7, 3))
    series1.append(QPointF(8, 2))
    series1.append(QPointF(12, 3))
    series1.append(QPointF(16, 4))
    series1.append(QPointF(18, 3))
    """    

    # seriesFilter = [0, 3, 4, 6]
    # seriesFilter = [0]
    seriesFilter = [0]

    valuesToDraw = [data[1][i] for i in seriesFilter]
    namesToDraw = [data[2][i] for i in seriesFilter]
  

    i = 0

    values = valuesToDraw[i]
    name = namesToDraw[i]

    topLineSeries = QtCharts.QLineSeries()    

    n = len(values)

    print(values)

     # конвертируем столбец time в float, чтобы можно было использовать его как значения оси x
    for j in range(n):
        # print(x)
        time = data[0][j]                
        topLineSeries.append(float(time.toMSecsSinceEpoch()), values[j])

    """

    #areaSeries = QtCharts.QAreaSeries(topLineSeries);
    areaSeries = QtCharts.QAreaSeries(series0, series1)
    #areaSeries.setName(name);
    areaSeries.setName("name4535343534")

    pen = QPen(0x059605)
    pen.setWidth(3)
    areaSeries.setPen(pen)

    gradient = QLinearGradient(QPointF(0, 0), QPointF(0, 1))
    gradient.setColorAt(0.0, 0x3cc63c)
    gradient.setColorAt(1.0, 0x26f626)
    gradient.setCoordinateMode(QGradient.ObjectBoundingMode)
    areaSeries.setBrush(gradient)

    chart = QtCharts.QChart()
    chart.addSeries(areaSeries)
    # chart.legend().hide()
    chart.setTitle("Area chart (population by continents)")
    chart.createDefaultAxes()
    chart.axes(Qt.Horizontal)[0].setRange(0, 20)
    chart.axes(Qt.Vertical)[0].setRange(0, 10)

    chartView = QtCharts.QChartView(chart)
    chartView.setRenderHint(QPainter.Antialiasing)

    # areaSeries.attachAxis(axisX);
    # areaSeries.attachAxis(axisY);
    """
    for i in range(len(seriesFilter)):

        values = valuesToDraw[i]
        name = namesToDraw[i]
    
        series = QtCharts.QSplineSeries()
        series.setName(name)

        n = len(values)

        # print(values)

         # конвертируем столбец time в float, чтобы можно было использовать его как значения оси x
        for j in range(n):
            # print(x)
            time = data[0][j]                
            series.append(float(time.toMSecsSinceEpoch()), values[j])

        chart.addSeries(series)

        series.attachAxis(axisX);        
        series.attachAxis(axisY);
    
    
    
    """

    return chartView