示例#1
0
文件: ui.py 项目: vojtamolda/games
 def paint(self, painter: QPainter, styleOption: QStyleOptionGraphicsItem, widget: QWidget=None):
     pen = QPen()
     pen.setWidthF(0.05)
     pen.setColor(Qt.darkGray)
     painter.setPen(pen)
     brush = QBrush()
     brush.setColor(self.color)
     brush.setStyle(Qt.SolidPattern)
     painter.setBrush(brush)
     topLeft = QPointF(0, 0)
     bottomRight = QPointF(1, 1)
     rectangle = QRectF(topLeft, bottomRight)
     rectangle.translate(-0.5, -0.5)
     painter.drawRect(rectangle)
示例#2
0
    def __init__(self, boxManager):
        super().__init__()
        # Variables
        self.message     = ''
        self.imageData   = None
        self.boxes       = []
        self.drawingRect = None
        self.drawing     = False

        # Objects
        self.image              = None
        self.messageResetTimer  = QTimer()
        self.brush              = QBrush()
        self.pen                = QPen()
        self.font               = QFont('Arial', 8)
        self.boxManager         = boxManager

        # Styling
        self.setMinimumSize(QSize(850, 725))
        self.messageResetTimer.setInterval(3000)
        self.messageResetTimer.setSingleShot(True)
        
        # Connections
        self.messageResetTimer.timeout.connect(self.resetMessage)
示例#3
0
    def paint(self, painter: QPainter, option: QStyleOptionGraphicsItem,
              widget: QWidget) -> None:
        """
		Paints a port. This function is used implicitly by the QGraphicsView to render a port.
		
		:param painter: The painter to paint with.
		:type painter: QPainter
		:param option: provides style options for the item.
		:type option: QStyleOptionGraphicsItem
		:param widget: QWidget
		:type widget: It points to the widget that is being painted on; or make it = None.
		:return: None
		:rtype: NoneType
		"""

        pen = QPen(PortGraphics.PEN_COLOR)
        pen.setWidth(self.borderWidth)
        painter.setPen(pen)

        if type(self._port.getAction()) == ActionWrapper:
            painter.setBrush(PortGraphics.INNER_COLOR)
        else:
            painter.setBrush(PortGraphics.OUTER_COLOR)
        painter.drawPath(self.shape())
示例#4
0
文件: Bar.py 项目: andybaran/pihud
    def __init__(self, parent, config):
        super(Bar_Horizontal, self).__init__(parent)

        self.config = config
        self.value = config["min"]

        self.font = QFont()
        self.note_font = QFont()
        self.color = QColor(config["color"])
        self.red_color = QColor(config["redline_color"])
        self.no_color = QColor()
        self.no_color.setAlpha(0)

        self.brush = QBrush(self.color)
        self.red_brush = QBrush(self.red_color)

        self.pen = QPen(self.color)
        self.red_pen = QPen(self.red_color)
        self.no_pen = QPen(self.no_color)

        self.font.setPixelSize(self.config["font_size"])
        self.note_font.setPixelSize(self.config["note_font_size"])
        self.pen.setWidth(3)
        self.red_pen.setWidth(3)
    def paintEvent(self, event):
        p = QPainter(self)
        p.setPen(QPen(self.pen_color))

        p.drawLine(490, 70, 490, 110)  # 1-2
        p.drawLine(490, 160, 490, 200)  # 2-3
        p.drawLine(490, 250, 490, 290)  # 3-4
        p.drawLine(490, 340, 490, 380)  # 4-5
        p.drawLine(490, 430, 490, 470)  # 5-6

        p.drawLine(590, 405, 630, 405)  # 5-4
        p.drawLine(630, 405, 630, 315)  # 5-4
        p.drawLine(630, 315, 590, 315)  # 5-4

        self.update()
    def test_simple_dashes_offset(self, p, opd):
        pen = QPen()
        pen.setDashPattern([2, 1])
        pen.setDashOffset(1)
        pen.setWidth(5)
        p.setPen(pen)

        path = QPainterPath()
        path.moveTo(0, 0)
        path.lineTo(30, 0)
        p.drawPath(path)

        assert opd.getOutlines() == [
            ((0.0, 0.0, 0.0, 1.0), 0.5, [(0.0, 0.0), (0.5, 0.0)]),
            ((0.0, 0.0, 0.0, 1.0), 0.5, [(1.0, 0.0), (2.0, 0.0)]),
            ((0.0, 0.0, 0.0, 1.0), 0.5, [(2.5, 0.0), (3.0, 0.0)]),
        ]
示例#7
0
    def toggle_attached(self):
        legend = self.chart.legend()
        if legend.isAttachedToChart():
            legend.detachFromChart()
            legend.setBackgroundVisible(True)
            legend.setBrush(QBrush(QColor(128, 128, 128, 128)))
            legend.setPen(QPen(QColor(192, 192, 192, 192)))

            self.show_legend_spinbox()
            self.update_legend_layout()
        else:
            legend.attachToChart()
            legend.setBackgroundVisible(False)
            self.hideLegendSpinbox()
        self.update()
示例#8
0
    def paint(self, painter, option, widget):
        lod = option.levelOfDetailFromTransform(painter.worldTransform())
        should_highlight = self._should_highlight()

        if should_highlight:
            pen = QPen(QColor(0, 0xfe, 0xfe), 2, self.style)
        else:
            pen = QPen(self.color, 2, self.style)

        painter.setPen(pen)

        painter.drawPath(self.path)

        # arrow
        if lod < 0.3:
            return

        # arrow
        if should_highlight:
            brush = QBrush(QColor(0, 0xfe, 0xfe))
        else:
            brush = QBrush(self.color)
        painter.setBrush(brush)
        painter.drawPolygon(self.arrow)
示例#9
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 paintEvent(self, e):
        painter = QPainter(self)
        painter.setPen(QPen(Qt.black, 2, Qt.DashDotLine))
        painter.setBrush(QBrush(Qt.green, Qt.DiagCrossPattern))

        painter.drawEllipse(100, 100, 400, 200)
        painter.drawRect(200, 150, 400, 200)

        points = QPolygon([
            QPoint(10, 10),
            QPoint(10, 100),
            QPoint(100, 10),
            QPoint(100, 80)
        ])
        painter.drawPolygon(points)
示例#11
0
 def paintWithoutNotation(self, painter):
     brushBackup = painter.brush()
     penBackup = painter.pen()
     localPen = QPen(self._lineColor)
     localPen.setWidth(self._lineWidth)
     painter.setPen(localPen)
     painter.drawEllipse(self._borderOffset, self._borderOffset,
                         self._radius * 2, self._radius * 2)
     if self._scale == 0 or len(self._digitsList) == 0:
         return
     for i in range(1, len(self._digitsList)):
         prevDigit = self._digitsList[i - 1]
         currentDigit = self._digitsList[i]
         self.drawLine(painter, prevDigit, currentDigit)
     if self._cycleFlag:
         firstDigit = self._digitsList[0]
         lastDigit = self._digitsList[-1]
         self.drawLine(painter, lastDigit, firstDigit)
     painter.setBrush(self._dotColor)
     painter.drawEllipse(
         self._radius - self._posX + self._borderOffset - 10 / 2,
         self._radius - self._posY + self._borderOffset - 10 / 2, 10, 10)
     painter.setBrush(brushBackup)
     painter.setPen(penBackup)
示例#12
0
 def paint(self, painter, option, widget=None):
     painter.setBrush(Qt.NoBrush)
     c = ''
     if Design.flow_style == 'dark std':
         c = '#ffffff'
     elif Design.flow_style == 'dark tron':
         if self.parent_port_instance.type_ == 'exec':
             c = '#ffffff'
         elif self.parent_port_instance.type_ == 'data':
             c = self.parent_node_instance.parent_node.color
     pen = QPen(c)
     painter.setPen(pen)
     painter.setFont(self.font)
     painter.drawText(self.boundingRect(), Qt.AlignCenter,
                      self.parent_port_instance.label_str)
示例#13
0
    def __init__(self,
                 name,
                 flow_conn_exec_color,
                 flow_conn_exec_width,
                 flow_conn_exec_pen_style,
                 flow_conn_data_color,
                 flow_conn_data_width,
                 flow_conn_data_pen_style,
                 node_instance_painter,
                 flow_background_color=QColor('#333333')):
        self.name = name
        self.node_inst_painter = node_instance_painter

        self.flow_conn_exec_pen = QPen(flow_conn_exec_color,
                                       flow_conn_exec_width)
        self.flow_conn_exec_pen.setStyle(flow_conn_exec_pen_style)
        self.flow_conn_exec_pen.setCapStyle(Qt.RoundCap)

        self.flow_conn_data_pen = QPen(flow_conn_data_color,
                                       flow_conn_data_width)
        self.flow_conn_data_pen.setStyle(flow_conn_data_pen_style)
        self.flow_conn_data_pen.setCapStyle(Qt.RoundCap)

        self.flow_background_color = flow_background_color
示例#14
0
    def paintEvent(self, e):
        painter = QPainter(self)
        painter.setPen(QPen(Qt.blue, 7, Qt.DashDotLine))
        painter.setBrush(QBrush(Qt.green, Qt.SolidPattern))

        painter.drawEllipse(100, 100, 400, 200)

        points = QPolygon([
            QPoint(10, 10),
            QPoint(10, 100),
            QPoint(100, 100),
            QPoint(100, 10),
        ])

        painter.drawPolygon(points)
    def paintEvent(self, event):
        self.points = []

        painter = QtGui.QPainter(self)

        painter.fillRect(self.rect(), QColor(80, 80, 80))

        painter.setRenderHint(QtGui.QPainter.Antialiasing, True)
        self.pathtracer.paint(painter)

        txt = "max bounces: {} | scatter per bounce: {}".format(
            self.pathtracer.max_bounces, self.pathtracer.scatter_per_bounce)
        painter.fillRect(10, 10, 220, 15, QColor(150, 150, 150))
        painter.setPen(QPen())
        painter.drawText(20, 20, txt)
示例#16
0
    def paintEvent(self, QPaintEvent):
        painter = QPainter()
        painter.begin(self)
        painter.setPen(Qt.NoPen)
        painter.fillRect(self.rect(), QColor(190, 190, 190, 255))

        if self.label_img:
            if self.mouse_press_flag and self.mouse_pos:
                pp = QPainter(self.mask_img)
                if self.eraser_painting_model:
                    pp.setPen(
                        QPen(self.eraser_color, self.eraser_pixle_size,
                             Qt.SolidLine, Qt.RoundCap, Qt.BevelJoin))
                else:
                    pp.setPen(
                        QPen(self.brush_color, self.brush_pixle_size,
                             Qt.SolidLine, Qt.RoundCap, Qt.BevelJoin))

                pp.drawPoint(self.mouse_pos - self.img_rect.topLeft())

            result_pixmap = self.join_pixmap(self.label_img, self.mask_img)
            painter.drawPixmap(self.img_rect, result_pixmap)

        painter.end()
示例#17
0
    def paintEvent(self, event):
        painter = QPainter()
        painter.setRenderHint(painter.Antialiasing)
        #  painter.setRenderHint(painter.HighQualityAnti)

        painter.begin(self)

        print 'paint something', event
        #  path = QPainterPath()
        painter.setPen(QPen(Qt.yellow, 5))
        painter.drawEllipse(50, 50, 50, 50)



        painter.end()
示例#18
0
    def paint(self, painter, option, widget): #pylint: disable=unused-argument
        """
        Paint a state block on the scene.

        :param painter:
        :return: None
        """

        painter.setFont(Conf.symexec_font)
        normal_background = QColor(0xfa, 0xfa, 0xfa)
        selected_background = QColor(0xcc, 0xcc, 0xcc)

        # The node background
        if self.selected:
            painter.setBrush(selected_background)
        else:
            painter.setBrush(normal_background)
        painter.setPen(QPen(QColor(0xf0, 0xf0, 0xf0), 1.5))
        painter.drawRect(0, 0, self.width, self.height)

        x = 0
        y = 0

        x += self.HORIZONTAL_PADDING
        y += self.VERTICAL_PADDING

        # definition
        painter.setPen(Qt.darkBlue)
        painter.drawText(x, y + self._config.symexec_font_ascent, self._definition_str)
        y += self._config.symexec_font_height + self.LINE_MARGIN

        # The instruction
        x = 0
        addr_label_x = x + self.HORIZONTAL_PADDING
        painter.setPen(Qt.black)
        painter.drawText(addr_label_x, y + self._config.symexec_font_ascent, self._instruction_str)
        x = addr_label_x + self._config.symexec_font_metrics.width(self._instruction_str)

        # The text
        if self._text:
            x += 10
            text_label_x = x
            painter.setPen(Qt.gray)
            painter.drawText(text_label_x, y + self._config.symexec_font_ascent, self._text)

        painter.setPen(Qt.black)
        y += self._config.symexec_font_height + self.LINE_MARGIN
        x = 0
示例#19
0
    def paintEvent(self, e):
        """ Draws the color bar and arrow """
        if self.item():
            painter = QPainter(self)

            # Draws the color bar
            painter.setPen(Qt.NoPen)
            rect = QRect(0, 0, self.COLOR_BAR_WIDTH, self.COLOR_BAR_HEIGHT)
            painter.fillRect(rect,
                             self.item().data(renderSetupRoles.NODE_COLOR_BAR))
            oldBrush = painter.brush()

            if self.item().type(
            ) == renderSetup.RENDER_OVERRIDE_TYPE and self.item(
            ).isLocalRender():
                diameter = rect.width() - 2
                rect2 = QRect(rect.x() + 1,
                              rect.y() + (rect.height() - diameter) / 2,
                              diameter, diameter)
                brush = painter.brush()
                pen = painter.pen()
                hints = painter.renderHints()

                painter.setRenderHint(QPainter.Antialiasing, on=True)
                painter.setPen(Qt.NoPen)
                painter.setBrush(
                    QBrush(QColor(67, 79, 70), style=Qt.SolidPattern))
                painter.drawEllipse(rect2)

                painter.setRenderHints(hints)
                painter.setPen(pen)
                painter.setBrush(brush)

            # Draws the arrow
            painter.setBrush(self.ARROW_COLOR)
            if self.arrowPoints == BaseDelegate.EXPANDED_ARROW:
                painter.translate(self.EXPANDED_ARROW_OFFSET, 0.0)
            else:
                painter.translate(self.COLLAPSED_ARROW_OFFSET, 0.0)
            painter.drawPolygon(self.arrowPoints)
            painter.setBrush(oldBrush)

            # Draws the node type text
            painter.setPen(QPen(self.item().data(Qt.TextColorRole)))
            text = self.item().data(renderSetupRoles.NODE_TYPE_STR)
            painter.setFont(self.item().data(Qt.FontRole))
            painter.drawText(self.NODE_TYPE_TEXT_RECT, text,
                             QTextOption(Qt.AlignLeft | Qt.AlignVCenter))
示例#20
0
 def draw(cls, x, y, self: PreparedLine, painter: QPainter):
     old_pen = painter.pen()
     pen = QPen(QColor(0))
     pen.setWidth(self.size)
     pen.setStyle(Qt.PenStyle.SolidLine)
     painter.setPen(pen)
     tx = self.left + x
     ty = self.top + y
     painter.drawLine(QLine(tx, ty, tx + self.width, ty + self.height))
     painter.setPen(old_pen)
    def selectTile(self, x, y):
        pen = QPen()
        pen.setColor(QColor(0x00, 0x32, 0x32, 0x60))
        pen.setWidth(4)
        new_x, new_y = self.findTilePos(x, y)
        selection_rect = QRect(new_x, new_y, self._tile_w, self._tile_h)

        if self._selection_rect is not None:
            self._scene.removeItem(self._selection_rect)
        self._selection_rect = self._scene.addRect(selection_rect, pen)
    def paint_labels(self, painter, x0, y0, radius, labels):
        steps = len(labels)

        radius = radius + 0.11

        for n in range(steps):
            phi = 2.0 * self.pi * n / steps + 0.5 * 2.0 * self.pi / steps

            x1 = x0 + radius * numpy.cos(phi) - 0.09
            y1 = y0 + radius * numpy.sin(phi) + 0.05

            xt, yt = self.convert_position(x1, y1)

            text = str(labels[n])
            painter.setPen(QPen(self.text_color, 2, Qt.SolidLine))
            painter.drawText(xt, yt, text)
示例#23
0
    def show_points(self, points):
        painter = QPainter(self.label.pixmap())
        painter.setRenderHint(QPainter.Antialiasing)

        painter.setPen(Qt.NoPen)
        painter.setBrush(QColor('#0C1C23'))
        painter.drawRect(self.rect())

        pen = QPen(QColor('#ffffff'))
        painter.setPen(pen)
        painter.setBrush(QBrush(QColor('#ffffff')))

        for p in points:
            painter.drawEllipse(p[0]*self.label.pixmap().width(), p[1]*self.label.pixmap().height(), 2, 2)

        self.repaint()
示例#24
0
    def update_text(self):
        self.key = self.keys[self.index]
        if not self.text_over_mouse:
            return
        color = self.colors[self.index]
        line_color = QColor(color[0], color[1], color[2], color[3])
        face_color = QColor(color[0], color[1], color[2], int(color[3] * 0.3))
        pen = QPen(line_color, 0.5, Qt.SolidLine, Qt.FlatCap, Qt.MiterJoin)
        brush = QBrush(face_color)
        if self.text is None:
            self.text = QtWidgets.QGraphicsSimpleTextItem(self.key)
            self.scene.addItem(self.text)

        self.text.setText(self.key)
        self.text.setBrush(brush)
        self.text.setPen(pen)
示例#25
0
    def __init__(self, element, path):
        super().__init__(element)
        self.path = path

        self.setPen(QPen(Qt.black, 2))
        self.setBrush(Qt.white)
        self.setRect(QRectF(QPoint(), self._SIZE))

        self.setFlag(QGraphicsItem.ItemIsSelectable)

        def _update_pin():
            lit = element.simulator.get_pin_value(path) > 0
            self.setBrush(Qt.green if lit else Qt.white)
            self.update()

        element.simulator.observe(path, _update_pin)
示例#26
0
    def paint(self, painter: QPainter, option: QStyleOptionGraphicsItem, widget=None):
        painter.setPen(QPen(Qt.black, self.model.common_model.line_thickness))

        monitor = self.model.monitor

        painter.drawLine(0, self._glob_h_over_mid_line,
                         self._h_line_length, self._glob_h_over_mid_line)
        painter.drawLine(monitor.screen_width, self._glob_h_over_mid_line,
                         monitor.screen_width - self._h_line_length, self._glob_h_over_mid_line)

        painter.drawLine(0, self._glob_h_mid_line,
                         monitor.screen_width, self._glob_h_mid_line)
        painter.drawLine(0, self._glob_h_under_mid_line,
                         self._h_line_length, self._glob_h_under_mid_line)
        painter.drawLine(monitor.screen_width, self._glob_h_under_mid_line,
                         monitor.screen_width - self._h_line_length, self._glob_h_under_mid_line)
示例#27
0
 def drawEllipse(self, x1, x2, y1, y2, result):
     rect = self.selected_area.normalized()
     tmpRect = QRect(QPoint(x1, x2), QPoint(y1, y2)).normalized()
     resultRect = rect & tmpRect
     tmp = [
         ACTION_ELLIPSE,
         resultRect.topLeft().x(),
         resultRect.topLeft().y(),
         resultRect.bottomRight().x(),
         resultRect.bottomRight().y(),
         QPen(QColor(self.penColorNow), int(self.penSizeNow))
     ]
     if result:
         self.drawListResult.append(tmp)
     else:
         self.drawListProcess = tmp
示例#28
0
    def drawCircle(self, point):
        painter = QPainter(self.image)
        painter.setCompositionMode(QPainter.CompositionMode_Source)
        painter.setRenderHint(QPainter.Antialiasing)

        brush = QBrush(QColor(0, 0, 255, 255), Qt.SolidPattern)
        pen = QPen(brush, 0.2 * self.myPenWidth / self.scaleFactor,
                   Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin)
        painter.setPen(pen)
        radius = 1.5 * self.myPenWidth / self.scaleFactor
        rectangle = QRectF((point.x() / self.scaleFactor) - (radius / 2),
                           (point.y() / self.scaleFactor) - (radius / 2),
                           radius, radius)
        painter.drawEllipse(rectangle)

        self.update()
示例#29
0
    def __init__(self, data):
        super().__init__()
        self.data = data

        # Init all dictionnary
        self.curves = dict()
        self.curves["nb_lo"] = 0
        self.curves["nb_gaus"] = 0
        self.curves["nb_l"] = 0
        self.curves["nb_exp"] = 0
        self.curves["y_tot"] = np.asarray([0 for _ in range(len(data["x"]))])

        self.pen_tot = QPen(Qt.red, 0.01)

        self.set_ui()
        self.show()
示例#30
0
    def movePerson(self, elipse, pos, size=100):
        #elipse.setPos(pos[0], pos[1])
        pos = [pos[0], pos[2]] if len(pos) > 2 else pos
        color = elipse.pen().color()
        self.scene.addEllipse(pos[0] - size // 2,
                              pos[1] - size // 2,
                              size,
                              size,
                              pen=QPen(QColor(color), 20),
                              brush=QBrush(color=QColor(color)))
        # pixmap
        self.persons[elipse].setPos(pos[0] - self.pixmapSize[0],
                                    pos[1] - self.pixmapSize[1])

        # change rotation value when provided
        self.persons[elipse].setRotation(180)
    def drawBg_TB(self, painter: QPainter) -> None:
        painter.save()

        # 圆半径为高度一定比例,计算宽度,将宽度等分
        width: int = self.width() // self.__maxStep
        height: int = self.height() // 3
        radius: int = height // 2
        initX: int = width // 2
        initY: int = self.height() // 2

        # 逐个绘制连接线条
        pen: QPen = QPen()
        pen.setWidthF(radius / 4)
        pen.setCapStyle(Qt.RoundCap)
        pen.setColor(self.__background)
        painter.setPen(pen)
        painter.setBrush(Qt.NoBrush)

        for i in range(self.__maxStep - 1):
            painter.drawLine(QPoint(initX, initY),
                             QPoint(initX + width, initY))
            initX += width

        # 逐个绘制圆
        initX: int = width // 2
        painter.setPen(Qt.NoPen)
        painter.setBrush(self.__background)

        for i in range(self.__maxStep):
            painter.drawEllipse(QPoint(initX, initY), radius, radius)
            initX += width

        # 逐个绘制圆中的数字
        initX = width // 2
        font: QFont = QFont()
        font.setPixelSize(radius)
        painter.setFont(font)
        painter.setPen(self.__foreground)
        painter.setBrush(Qt.NoBrush)

        for i in range(self.__maxStep):
            textRect: QRect = QRect(initX - radius, initY - radius, radius * 2,
                                    radius * 2)
            painter.drawText(textRect, Qt.AlignCenter, str(i + 1))
            initX += width

        painter.restore()
示例#32
0
文件: ui.py 项目: vojtamolda/games
        def __init__(self, tetris: Tetris):
            super(QTetris.QScene, self).__init__()
            self.tetris = tetris

            pen = QPen()
            pen.setWidthF(0.05)
            pen.setColor(Qt.lightGray)
            brush = QBrush(Qt.NoBrush)
            rect = QRectF(0, 0, tetris.num_rows, tetris.num_columns)
            rect.translate(-0.5, -0.5)
            self.setSceneRect(rect)
            self.addRect(rect, pen, brush)
            self.setBackgroundBrush(self.palette().window())

            for column in range(0, tetris.num_columns, 2):
                pen = QPen(Qt.NoPen)
                brush = QBrush(Qt.SolidPattern)
                brush.setColor(Qt.lightGray)
                topLeft = QPointF(0, column)
                bottomRight = QPointF(tetris.num_rows, column + 1)
                rectangle = QRectF(topLeft, bottomRight)
                rectangle.translate(-0.5, -0.5)
                self.addRect(rectangle, pen, brush)
示例#33
0
文件: ui.py 项目: vojtamolda/games
        def paintEvent(self, paintEvent: QPaintEvent):
            painter = QPainter(self)
            painter.setBackgroundMode(Qt.TransparentMode)
            painter.setRenderHint(QPainter.Antialiasing)
            brush = QBrush()
            brush.setStyle(Qt.SolidPattern)
            pen = QPen()
            pen.setJoinStyle(Qt.RoundJoin)
            pen.setCapStyle(Qt.RoundCap)

            center = QPoint(self.width() // 2, self.height() // 2)
            radius = 0.45 * min(self.width(), self.height())

            pen.setColor(self.palette().color(self.color[0]))
            brush.setColor(self.palette().color(self.color[1]))
            if self.highlight is True:
                pen.setColor(self.palette().color(QPalette.Highlight))
            pen.setWidth(round(0.15 * radius))
            painter.setBrush(brush)
            painter.setPen(pen)
            painter.drawEllipse(center, radius, radius)

            if self.checked is True:
                brush.setColor(self.palette().color(QPalette.Background))
                pen.setColor(self.palette().color(QPalette.Background))
                painter.setPen(pen)
                painter.setBrush(brush)
                painter.drawEllipse(center, 0.40 * radius, 0.40 * radius)
            del painter, brush, pen
示例#34
0
文件: maze.py 项目: vojtamolda/games
    def paintEvent(self, paintEvent: QPaintEvent):
        pen = QPen()
        pen.setJoinStyle(Qt.RoundJoin)
        pen.setCapStyle(Qt.RoundCap)
        painter = QPainter(self)
        painter.translate(self.paintOffset)
        painter.setBackgroundMode(Qt.TransparentMode)
        painter.setRenderHint(QPainter.Antialiasing)

        if self.nodes is not None:
            painted = set()

            def paintNode(node):
                nonlocal painter, painted
                if node in painted:
                    return
                painted.add(node)
                for link in node.links:
                    if link not in painted:
                        painter.drawLine(node.point, link.point)
                        paintNode(link)

            color = self.palette().color(QPalette.Dark)
            pen.setColor(color)
            pen.setWidth(0.50 * self.paintStep)
            painter.setPen(pen)
            for node in self.nodes.values():
                if paintEvent.region().contains(node.point):
                    paintNode(node)

        if self.startNode is not None:
            color = self.palette().color(QPalette.Dark)
            pen.setColor(color)
            pen.setWidth(0.75 * self.paintStep)
            painter.setPen(pen)
            if paintEvent.region().contains(self.startNode.point):
                painter.drawPoint(self.startNode.point)

        if self.finishNode is not None and paintEvent.region().contains(self.finishNode.point):
            color = self.palette().color(QPalette.Dark).darker(120)
            pen.setColor(color)
            pen.setWidth(0.75 * self.paintStep)
            painter.setPen(pen)
            painter.drawPoint(self.finishNode.point)

        if self.player is not None:
            color = self.palette().color(QPalette.Highlight)
            color.setAlpha(196)
            pen.setColor(color)
            pen.setWidth(0.90 * self.paintStep)
            painter.setPen(pen)
            painter.drawPoint(self.player)

        del painter, pen