Exemplo n.º 1
0
    def paintEvent(self, event):
        painter = QPainter(self)
        area_color = self.palette().color(QPalette.Active, QPalette.Highlight)

        if self._full_area_drop:
            r = self.rect()
            painter.fillRect(r, QBrush(area_color, Qt.Dense4Pattern))
            painter.setBrush(QBrush(area_color))
            painter.drawRect(r)
            return

        r = self.rect()
        drop_area = self.cursor_location()
        if drop_area == DropArea.TopDropArea:
            r.setHeight(r.height() * 0.5)
        elif drop_area == DropArea.RightDropArea:
            r.setX(r.width() * 0.5)
        elif drop_area == DropArea.BottomDropArea:
            r.setY(r.height() * 0.5)
        elif drop_area == DropArea.LeftDropArea:
            r.setWidth(r.width() * 0.5)
        elif drop_area == DropArea.CenterDropArea:
            r = self.rect()

        if not r.isNull():
            painter.fillRect(r, QBrush(area_color, Qt.Dense4Pattern))
            painter.setBrush(QBrush(area_color))
            painter.drawRect(r)
Exemplo n.º 2
0
    def paintEvent(self, event):
        if self.isVisible() and self.paintLineNum > 0:

            # NOTE 更新绘制
            self.viewport().update()

            block = self.firstVisibleBlock()
            height = self.lineNumberArea.fontMetrics().height()
            number = block.blockNumber()
            painter = QPainter(self.viewport())

            condition = True
            while block.isValid() and condition:
                block_geometry = self.blockBoundingGeometry(block)
                offset = self.contentOffset()
                block_top = block_geometry.translated(offset).top()
                number += 1

                block_rect = QRect(0, block_top, self.width(), height)

                if number == self.paintLineNum:
                    lineColor = QColor(LINE_COLOR).lighter(100)
                    painter.fillRect(block_rect, lineColor)
                    painter.drawRect(block_rect)
                    condition = False

                if block_top > event.rect().bottom():
                    condition = False

                block = block.next()

            painter.end()
        return super(CodeEditor, self).paintEvent(event)
Exemplo n.º 3
0
    def _line_number_paint(self, event):
        paint = QPainter(self._line_numbers)
        if not dcc.is_maya():
            paint.fillRect(event.rect(), Qt.lightGray)
        else:
            paint.fillRect(event.rect(), Qt.black)

        block = self.firstVisibleBlock()
        block_number = block.blockNumber()
        top = int(
            self.blockBoundingGeometry(block).translated(
                self.contentOffset()).top())
        bottom = int(top + self.blockBoundingGeometry(block).height())
        while block.isValid() and top <= event.rect().bottom():
            if block.isVisible() and bottom >= event.rect().top():
                number = block_number + 1
                if dcc.is_maya():
                    paint.setPen(Qt.lightGray)
                else:
                    paint.setPen(Qt.black)
                paint.drawText(0, top, self._line_numbers.width(),
                               self.fontMetrics().height(), Qt.AlignRight,
                               str(number))
            block = block.next()
            top = bottom
            bottom = top + self.blockBoundingRect(block).height()
            block_number += 1
Exemplo n.º 4
0
    def paintEvent(self, event):
        super(DragDoubleSpinBoxLine, self).paintEvent(event)
        p = QPainter()
        p.begin(self)

        try:
            v = float(self.text())
        except Exception:
            v = 0.0000001

        try:
            v /= self._max if v > 0 else (self._min * -1)
        except Exception:
            pass
        if self._sup:
            p.fillRect(QRect(0,
                             self.height() - 4, v * self.width(), 4),
                       self._color)
        else:
            p.fillRect(
                QRect(self.width() * 0.5,
                      self.height() - 4,
                      v * self.width() * 0.5, 4),
                self._color if v > 0 else QColor(255, 0, 0))
        p.end()
Exemplo n.º 5
0
    def paintEvent(self, event):

        painter = QPainter(self)

        if self._is_expanded:
            rect2 = event.rect()
            rect2.setX(15)
            rect2.setWidth(1)
            painter.fillRect(rect2, QBrush(QColor(87, 87, 87)))
Exemplo n.º 6
0
    def paintEvent(self, event):
        """
        Overrides base QFrame paintEvent function
        Override to make mouse events work in transparent widgets
        :param event: QPaintEvent
        """

        painter = QPainter(self)
        painter.fillRect(self.rect(), QColor(255, 255, 255, 1))
        painter.end()
Exemplo n.º 7
0
    def renderNow(self) -> None:
        if not self.isExposed():
            return

        rect = QRect(0, 0, self.width(), self.height())
        self.m_backingStore.beginPaint(QRegion(rect))

        device: QPaintDevice = self.m_backingStore.paintDevice()
        painter = QPainter(device)

        painter.fillRect(0, 0, self.width(), self.height(),
                         QGradient.NightFade)
        self.render(painter)
        painter.end()

        self.m_backingStore.endPaint()
        self.m_backingStore.flush(QRegion(rect))
 def cdMapper(self,*args):
     global cdR, cdG, cdB
     
     temp2 = QPixmap(cd_pix2)
     mask = QPixmap(cd_pix2_alpha)
     
     mult = 255
     R = cdR * mult
     G = cdG *mult
     B = cdB * mult
     colour = QColor(R,G,B)
     #print("R:" + str(cdR) + " G:" + str(cdG) + " B:" + str(cdB))
     
     #Paint Lines
     painter2 = QPainter(temp2)
     painter2.setCompositionMode(painter2.CompositionMode_Overlay)
     painter2.fillRect(temp2.rect(), colour)
     painter2.end()
      
     #Update Image
     self.main_widget.lbl_LGTC_PRV.setPixmap(temp2)
Exemplo n.º 9
0
    def paintEvent(self, event):
        if self.isVisible():
            block = self.editor.firstVisibleBlock()
            height = self.fontMetrics().height()
            number = block.blockNumber()
            painter = QPainter(self)
            painter.fillRect(event.rect(), LINEBAR_COLOR)
            painter.drawRect(event.rect().width() - 1, 0,
                             event.rect().width(),
                             event.rect().height() - 1)
            font = painter.font()
            current_block = self.editor.textCursor().block().blockNumber() + 1

            condition = True
            while block.isValid() and condition:
                block_geometry = self.editor.blockBoundingGeometry(block)
                offset = self.editor.contentOffset()
                block_top = block_geometry.translated(offset).top()
                number += 1

                # NOTE set the linebar breakpoint color
                if self.paintLineNum > 0 and number == self.paintLineNum:
                    font.setBold(True)
                    block_rect = QRect(LINE_MARGIN, block_top,
                                       self.width() - LINE_MARGIN * 2, height)
                    painter.fillRect(block_rect, LINEBAR_BP_COLOR)
                # NOTE set the current line color
                elif number == current_block:
                    font.setBold(True)
                    block_rect = QRect(LINE_MARGIN, block_top,
                                       self.width() - LINE_MARGIN * 2, height)
                    painter.fillRect(block_rect, LINEBAR_NUM_COLOR)
                else:
                    font.setBold(False)

                painter.setFont(font)
                rect = QRect(0, block_top, self.width() - 5, height)
                painter.drawText(rect, Qt.AlignRight, '%i' % number)

                if block_top > event.rect().bottom():
                    condition = False

                block = block.next()

            painter.end()
Exemplo n.º 10
0
 def paintEvent(self, event):
     painter = QPainter()
     painter.begin(self)
     painter.setRenderHint(painter.Antialiasing)
     font = painter.font()
     font.setBold(True)
     painter.setFont(font)
     x = self.rect().x()
     y = self.rect().y()
     w = self.rect().width() - 1
     h = self.rect().height() - 1
     _rect = 8
     if self._rolloutStyle == ExpanderStyles.Rounded:
         painter.drawText(x + 33, y + 3, w, 16, Qt.AlignLeft | Qt.AlignTop, self.title())
         self.__drawTriangle(painter, x, y)
         pen = QPen(self.palette().color(QPalette.Light))
         pen.setWidthF(0.6)
         painter.setPen(pen)
         painter.drawRoundedRect(x + 1, y + 1, w - 1, h - 1, _rect, _rect)
         pen.setColor(self.palette().color(QPalette.Shadow))
         painter.setPen(pen)
         painter.drawRoundedRect(x, y, w - 1, h - 1, _rect, _rect)
     if self._rolloutStyle == ExpanderStyles.Square:
         painter.drawText(x + 33, y + 3, w, 16, Qt.AlignLeft | Qt.AlignTop, self.title())
         self.__drawTriangle(painter, x, y)
         pen = QPen(self.palette().color(QPalette.Light))
         pen.setWidthF(0.2)
         painter.setPen(pen)
         painter.drawRect(x + 1, y + 1, w - 1, h - 1)
         pen.setColor(self.palette().color(QPalette.Shadow))
         painter.setPen(pen)
         painter.drawRect(x, y, w - 1, h - 1)
     if self._rolloutStyle == ExpanderStyles.Maya:
         painter.drawText(
             x + (45 if self.dragDropMode() == ExpanderDragDropModes.InternalMove else 25),
             y + 3, w, 16, Qt.AlignLeft | Qt.AlignTop, self.title())
         painter.setRenderHint(QPainter.Antialiasing, False)
         self.__drawTriangle(painter, x, y)
         header_height = 20
         header_rect = QRect(x + 1, y + 1, w - 1, header_height)
         header_rect_shadow = QRect(x - 1, y - 1, w + 1, header_height + 2)
         pen = QPen(self.palette().color(QPalette.Light))
         pen.setWidthF(0.4)
         # painter.setPen(pen)
         painter.setPen(Qt.NoPen)
         painter.drawRect(header_rect)
         painter.fillRect(header_rect, QColor(255, 255, 255, 18))
         pen.setColor(self.palette().color(QPalette.Dark))
         painter.setPen(pen)
         painter.drawRect(header_rect_shadow)
         if not self.isCollapsed():
             # pen = QPen(self.palette().color(QPalette.Background))
             # painter.setPen(pen)
             offset = header_height + 3
             body_rect = QRect(x, y + offset, w, h - offset)
             # body_rect_shadow = QRect(x + 1, y + offSet, w + 1, h - offSet + 1)
             painter.drawRect(body_rect)
             # pen.setColor(self.palette().color(QPalette.Foreground))
             # pen.setWidthF(0.4)
             # painter.setPen(pen)
             # painter.drawRect(body_rect_shadow)
     elif self._rolloutStyle == ExpanderStyles.Boxed:
         if self.isCollapsed():
             arect = QRect(x + 1, y + 9, w - 1, 4)
             brect = QRect(x, y + 8, w - 1, 4)
             text = '+'
         else:
             arect = QRect(x + 1, y + 9, w - 1, h - 9)
             brect = QRect(x, y + 8, w - 1, h - 9)
             text = '-'
         pen = QPen(self.palette().color(QPalette.Light))
         pen.setWidthF(0.6)
         painter.setPen(pen)
         painter.drawRect(arect)
         pen.setColor(self.palette().color(QPalette.Shadow))
         painter.setPen(pen)
         painter.drawRect(brect)
         painter.setRenderHint(painter.Antialiasing, False)
         painter.setBrush(self.palette().color(QPalette.Window).darker(120))
         painter.drawRect(x + 10, y + 1, w - 20, 16)
         painter.drawText(x + 16, y + 1, w - 32, 16, Qt.AlignLeft | Qt.AlignVCenter, text)
         painter.drawText(x + 10, y + 1, w - 20, 16, Qt.AlignCenter, self.title())
     if self.dragDropMode():
         rect = self.dragDropRect()
         _layout = rect.left()
         _rect = rect.right()
         center_y = rect.center().y()
         pen = QPen(self.palette().color(self.isCollapsed() and QPalette.Shadow or QPalette.Mid))
         painter.setPen(pen)
         for y in (center_y - 3, center_y, center_y + 3):
             painter.drawLine(_layout, y, _rect, y)
     painter.end()
Exemplo n.º 11
0
    def create_drop_indicator_pixmap(palette, size, drop_area):
        border_color = palette.color(QPalette.Active, QPalette.Highlight)
        background_color = palette.color(QPalette.Active, QPalette.Base)
        area_background_color = palette.color(QPalette.Active,
                                              QPalette.Highlight).lighter(150)

        pm = QPixmap(size.width(), size.height())
        pm.fill(QColor(0, 0, 0, 0))

        painter = QPainter(pm)
        pen = painter.pen()
        base_rect = QRectF(pm.rect())

        painter.fillRect(base_rect, background_color)

        painter.save()
        area_rect = QRectF()
        area_line = QLineF()
        gradient = QLinearGradient()
        if drop_area == DropArea.TopDropArea:
            area_rect = QRectF(base_rect.x(), base_rect.y(), base_rect.width(),
                               base_rect.height() * 0.5)
            area_line = QLineF(area_rect.bottomLeft(), area_rect.bottomRight())
            gradient.setStart(area_rect.topLeft())
            gradient.setFinalStop(area_rect.bottomLeft())
            gradient.setColorAt(0, area_background_color)
            gradient.setColorAt(1, area_background_color.lighter(120))
        elif drop_area == DropArea.RightDropArea:
            area_rect = QRectF(base_rect.width() * 0.5, base_rect.y(),
                               base_rect.width() * 0.5, base_rect.height())
            area_line = QLineF(area_rect.topLeft(), area_rect.bottomLeft())
            gradient.setStart(area_rect.topLeft())
            gradient.setFinalStop(area_rect.topRight())
            gradient.setColorAt(0, area_background_color.lighter(120))
            gradient.setColorAt(1, area_background_color)
        elif drop_area == DropArea.BottomDropArea:
            area_rect = QRectF(base_rect.x(),
                               base_rect.height() * 0.5, base_rect.width(),
                               base_rect.height() * 0.5)
            area_line = QLineF(area_rect.topLeft(), area_rect.topRight())
            gradient.setStart(area_rect.topLeft())
            gradient.setFinalStop(area_rect.bottomLeft())
            gradient.setColorAt(0, area_background_color.lighter(120))
            gradient.setColorAt(1, area_background_color)
        elif drop_area == DropArea.LeftDropArea:
            area_rect = QRectF(base_rect.x(), base_rect.y(),
                               base_rect.width() * 0.5, base_rect.height())
            area_line = QLineF(area_rect.topRight(), area_rect.bottomRight())
            gradient.setStart(area_rect.topLeft())
            gradient.setFinalStop(area_rect.topRight())
            gradient.setColorAt(0, area_background_color)
            gradient.setColorAt(1, area_background_color.lighter(120))

        if area_rect.isValid():
            painter.fillRect(area_rect, gradient)
            pen = painter.pen()
            pen.setColor(border_color)
            pen.setStyle(Qt.DashLine)
            painter.setPen(pen)
            painter.drawLine(area_line)

        painter.restore()

        painter.save()
        pen = painter.pen()
        pen.setColor(border_color)
        pen.setWidth(1)

        painter.setPen(pen)
        painter.drawRect(base_rect.adjusted(0, 0, -pen.width(), -pen.width()))
        painter.restore()

        return pm
Exemplo n.º 12
0
    def paintEvent(self, event):
        painter = QPainter()
        painter.begin(self)
        painter.setRenderHint(painter.Antialiasing)
        font = painter.font()
        font.setBold(True)
        painter.setFont(font)

        x = self.rect().x()
        y = self.rect().y()
        w = self.rect().width() - 1
        h = self.rect().height() - 1
        _rect = 8

        if self.rollout_style == AccordionStyle.ROUNDED:
            painter.drawText(x + 33 if not self._icon else 40, y + 3, w, 16,
                             Qt.AlignLeft | Qt.AlignTop, self.title())
            self._draw_triangle(painter, x, y)
            self._draw_icon(painter, x + 22, y + 3)
            pen = QPen(self.palette().color(QPalette.Light))
            pen.setWidthF(0.6)
            painter.setPen(pen)
            painter.drawRoundedRect(x + 1, y + 1, w - 1, h - 1, _rect, _rect)
            pen.setColor(self.palette().color(QPalette.Shadow))
            painter.setPen(pen)
            painter.drawRoundedRect(x, y, w - 1, h - 1, _rect, _rect)
        elif self.rollout_style == AccordionStyle.SQUARE:
            painter.drawText(x + 33 if not self._icon else 40, y + 3, w, 16,
                             Qt.AlignLeft | Qt.AlignTop, self.title())
            self._draw_triangle(painter, x, y)
            self._draw_icon(painter, x + 22, y + 3)
            pen = QPen(self.palette().color(QPalette.Light))
            pen.setWidthF(0.3)
            painter.setPen(pen)
            painter.drawRect(x + 1, y + 1, w - 1, h - 1)
            pen.setColor(self.palette().color(QPalette.Shadow))
            painter.setPen(pen)
        elif self.rollout_style == AccordionStyle.MAYA:
            painter.drawText(x + 33 if not self._icon else 40, y + 3, w, 16,
                             Qt.AlignLeft | Qt.AlignTop, self.title())
            painter.setRenderHint(QPainter.Antialiasing, False)
            self._draw_triangle(painter, x, y)
            self._draw_icon(painter, x + 22, y + 3)
            header_height = 20
            header_rect = QRect(x + 1, y + 1, w - 1, header_height)
            header_rect_shadow = QRect(x - 1, y - 1, w + 1, header_height + 2)
            pen = QPen(self.palette().color(QPalette.Light))
            pen.setWidthF(0.4)
            painter.setPen(pen)
            painter.drawRect(header_rect)
            painter.fillRect(header_rect, QColor(255, 255, 255, 18))
            pen.setColor(self.palette().color(QPalette.Dark))
            painter.setPen(pen)
            painter.drawRect(header_rect_shadow)
            if not self.is_collapsed():
                pen = QPen(self.palette().color(QPalette.Dark))
                pen.setWidthF(0.8)
                painter.setPen(pen)
                offset = header_height + 3
                body_rect = QRect(x, y + offset, w, h - offset)
                body_rect_shadow = QRect(x + 1, y + offset, w + 1,
                                         h - offset + 1)
                painter.drawRect(body_rect)
                pen.setColor(self.palette().color(QPalette.Light))
                pen.setWidth(0.4)
                painter.setPen(pen)
                painter.drawRect(body_rect_shadow)
        elif self.rollout_style == AccordionStyle.BOXED:
            if self.is_collapsed():
                a_rect = QRect(x + 1, y + 9, w - 1, 4)
                b_rect = QRect(x, y + 8, w - 1, 4)
                text = '+'
            else:
                a_rect = QRect(x + 1, y + 9, w - 1, h - 9)
                b_rect = QRect(x, y + 8, w - 1, h - 9)
                text = '-'

            pen = QPen(self.palette().color(QPalette.Light))
            pen.setWidthF(0.6)
            painter.setPen(pen)
            painter.drawRect(a_rect)
            pen.setColor(self.palette().color(QPalette.Shadow))
            painter.setPen(pen)
            painter.drawRect(b_rect)
            painter.setRenderHint(painter.Antialiasing, False)
            painter.setBrush(self.palette().color(QPalette.Window).darker(120))
            painter.drawRect(x + 10, y + 1, w - 20, 16)
            painter.drawText(x + 16, y + 1, w - 32, 16,
                             Qt.AlignLeft | Qt.AlignVCenter, text)
            painter.drawText(x + 10, y + 1, w - 20, 16, Qt.AlignCenter,
                             self.title())

        if self.drag_drop_mode:
            rect = self.get_drag_drop_rect()
            _layout = rect.left()
            _rect = rect.right()
            center_y = rect.center().y()
            for y in (center_y - 3, center_y, center_y + 3):
                painter.drawLine(_layout, y, _rect, y)

        painter.end()
Exemplo n.º 13
0
    def paintEvent( self, event ):
        painter = QPainter()
        painter.begin(self)
        painter.setRenderHint(painter.Antialiasing)
        font = painter.font()
        font.setBold(True)
        painter.setFont(font)

        x = self.rect().x()
        y = self.rect().y()
        w = self.rect().width() - 1
        h = self.rect().height() - 1
        r = 8

        # draw a rounded style
        if self._rolloutStyle == 2:
            # draw the text
            painter.drawText(x + 33, y + 3, w, 16, Qt.AlignLeft | Qt.AlignTop, self.title())

            # draw the triangle
            self.__drawTriangle(painter, x, y)

            # draw the borders
            pen = QPen(self.palette().color(QPalette.Light))
            pen.setWidthF(0.6)
            painter.setPen(pen)

            painter.drawRoundedRect(x + 1, y + 1, w - 1, h - 1, r, r)

            pen.setColor(self.palette().color(QPalette.Shadow))
            painter.setPen(pen)

            painter.drawRoundedRect(x, y, w - 1, h - 1, r, r)

        # draw a square style
        if self._rolloutStyle == 3:
            # draw the text
            painter.drawText(x + 33, y + 3, w, 16, Qt.AlignLeft | Qt.AlignTop, self.title())

            self.__drawTriangle(painter, x, y)

            # draw the borders
            pen = QPen(self.palette().color(QPalette.Light))
            pen.setWidthF(0.6)
            painter.setPen(pen)

            painter.drawRect(x + 1, y + 1, w - 1, h - 1)

            pen.setColor(self.palette().color(QPalette.Shadow))
            painter.setPen(pen)

            painter.drawRect(x, y, w - 1, h - 1)

        # draw a Maya style
        if self._rolloutStyle == 4:
            # draw the text
            painter.drawText(x + 33, y + 3, w, 16, Qt.AlignLeft | Qt.AlignTop, self.title())

            painter.setRenderHint(QPainter.Antialiasing, False)

            self.__drawTriangle(painter, x, y)

            # draw the borders - top
            headerHeight = 20

            headerRect = QRect(x + 1, y + 1, w - 1, headerHeight)
            headerRectShadow = QRect(x - 1, y - 1, w + 1, headerHeight + 2)

            # Highlight
            pen = QPen(self.palette().color(QPalette.Light))
            pen.setWidthF(0.4)
            painter.setPen(pen)

            painter.drawRect(headerRect)
            painter.fillRect(headerRect, QColor(255, 255, 255, 18))

            # Shadow
            pen.setColor(self.palette().color(QPalette.Dark))
            painter.setPen(pen)
            painter.drawRect(headerRectShadow)

            if not self.isCollapsed():
                # draw the lover border
                pen = QPen(self.palette().color(QPalette.Dark))
                pen.setWidthF(0.8)
                painter.setPen(pen)

                offSet = headerHeight + 3
                bodyRect = QRect(x, y + offSet, w, h - offSet)
                bodyRectShadow = QRect(x + 1, y + offSet, w + 1, h - offSet + 1)
                painter.drawRect(bodyRect)

                pen.setColor(self.palette().color(QPalette.Light))
                pen.setWidthF(0.4)
                painter.setPen(pen)

                painter.drawRect(bodyRectShadow)

        # draw a boxed style
        elif self._rolloutStyle == 1:
            if self.isCollapsed():
                arect = QRect(x + 1, y + 9, w - 1, 4)
                brect = QRect(x, y + 8, w - 1, 4)
                text = '+'
            else:
                arect = QRect(x + 1, y + 9, w - 1, h - 9)
                brect = QRect(x, y + 8, w - 1, h - 9)
                text = '-'

            # draw the borders
            pen = QPen(self.palette().color(QPalette.Light))
            pen.setWidthF(0.6)
            painter.setPen(pen)

            painter.drawRect(arect)

            pen.setColor(self.palette().color(QPalette.Shadow))
            painter.setPen(pen)

            painter.drawRect(brect)

            painter.setRenderHint(painter.Antialiasing, False)
            painter.setBrush(self.palette().color(QPalette.Window).darker(120))
            painter.drawRect(x + 10, y + 1, w - 20, 16)
            painter.drawText(x + 16, y + 1, w - 32, 16, Qt.AlignLeft | Qt.AlignVCenter, text)
            painter.drawText(x + 10, y + 1, w - 20, 16, Qt.AlignCenter, self.title())

        if self.dragDropMode():
            rect = self.dragDropRect()

            # draw the lines
            l = rect.left()
            r = rect.right()
            cy = rect.center().y()

            for y in (cy - 3, cy, cy + 3):
                painter.drawLine(l, y, r, y)

        painter.end()
Exemplo n.º 14
0
    def paintEvent(self, event: QPaintEvent) -> None:
        p = QPainter(self)
        self.m_normalMap.render(p, event.rect())
        p.setPen(Qt.black)
        p.drawText(
            self.rect(),
            Qt.AlignBottom | Qt.TextWordWrap,
            "Map data CCBYSA 2009 OpenStreetMap.org contributors",
        )
        p.end()

        if self.zoomed:
            dim = min(self.width(), self.height())
            magnifierSize = min(MAX_MAGNIFIER, dim * 2 / 3)
            radius = magnifierSize / 2
            ring = radius - 15
            box = QSize(magnifierSize, magnifierSize)

            if self.maskPixmap.size() != box:
                self.maskPixmap = QPixmap(box)
                self.maskPixmap.fill(Qt.transparent)

                g = QRadialGradient()
                g.setCenter(radius, radius)
                g.setFocalPoint(radius, radius)
                g.setRadius(radius)
                g.setColorAt(1.0, QColor(255, 255, 255, 0))
                g.setColorAt(0.5, QColor(128, 128, 128, 255))

                mask = QPainter(self.maskPixmap)
                mask.setRenderHint(QPainter.Antialiasing)
                mask.setCompositionMode(QPainter.CompositionMode_Source)
                mask.setBrush(g)
                mask.setPen(Qt.NoPen)
                mask.drawRect(self.maskPixmap.rect())
                mask.setBrush(QColor(Qt.transparent))
                mask.drawEllipse(g.center(), ring, ring)
                mask.end()

            center = self.dragPos - QPoint(0, radius)
            center = center + QPoint(0, radius / 2)
            corner = center - QPoint(radius, radius)

            xy = center * 2 - QPoint(radius, radius)

            # only set the dimension to the magnified portion
            if self.zoomPixmap.size() != box:
                zoomPixmap = QPixmap(box)
                zoomPixmap.fill(Qt.lightGray)

            if True:
                p = QPainter(zoomPixmap)
                p.translate(-xy)
                self.m_largeMap.render(p, QRect(xy, box))
                p.end()

            clipPath = QPainterPath()
            clipPath.addEllipse(center, ring, ring)

            p = QPainter(self)
            p.setRenderHint(QPainter.Antialiasing)
            p.setClipPath(clipPath)
            p.drawPixmap(corner, zoomPixmap)
            p.setClipping(False)
            p.drawPixmap(corner, self.maskPixmap)
            p.setPen(Qt.gray)
            p.drawPath(clipPath)
        if self.invert:
            p = QPainter(self)
            p.setCompositionMode(QPainter.CompositionMode_Difference)
            p.fillRect(event.rect(), Qt.white)
            p.end()
Exemplo n.º 15
0
    def paint(self, p: QtGui.QPainter, option: QtWidgets.QGraphicsItem.ItemIsSelectable,
              widget: QtWidgets.QWidget): # pylint: disable=unused-argument

        # Set color when selected
        if option.state & QtWidgets.QStyle.State_Selected:
            fillColor = self.color.darker(150)
        else:
            fillColor = self.color

        # Lighten if mouse over
        if option.state & QtWidgets.QStyle.State_MouseOver:
            fillColor = fillColor.lighter(125)

        # Calculate level of detail
        lod = option.levelOfDetailFromTransform(p.worldTransform())
        if lod < 0.125:
            p.fillRect(QtCore.QRectF(0, 0, 110, 70), fillColor)
            return
        if lod < 0.2:
            oldBrush = p.brush()
            p.setBrush(fillColor)
            p.drawRect(13, 13, 97, 57)
            p.setBrush(oldBrush)
            return

        oldPen = p.pen()
        oldBrush = p.brush()

        # Use a copy of the old pen
        pen = QtGui.QPen(oldPen)
        if option.state & QtWidgets.QStyle.State_Selected:
            pen.setWidth(2)
        else:
            pen.setWidth(0)
        p.setPen(pen)

        # Draw the inside of the chip
        if option.state & QtWidgets.QStyle.State_Sunken:
            p.setBrush(QtGui.QBrush(fillColor.darker(120)))
        else:
            p.setBrush(QtGui.QBrush(fillColor.darker(100)))
        p.drawRect(QtCore.QRect(14, 14, 79, 39))
        p.setBrush(oldBrush)

        if lod >= 1:
            p.setPen(QtGui.QPen(QtCore.Qt.gray, 1))
            p.drawLine(15, 54, 94, 54)
            p.drawLine(94, 53, 94, 15)
            p.setPen(QtGui.QPen(QtCore.Qt.black, 0))

        if lod >= 2:
            font = QtGui.QFont("Times", 10)
            font.setStyleStrategy(QtGui.QFont.ForceOutline)
            p.setFont(font)
            p.save()
            p.scale(0.1, 0.1)
            p.drawText(170, 180, f"Model: VSC-2000 (Very Small Chip) at {self.x}x{self.y}")
            p.drawText(170, 200, "Serial number: DLWR-WEER-123L-ZZ33-SDSJ")
            p.drawText(170, 220, "Manufacturer: Chip Manufacturer")
            p.restore()

        lines = []
        if lod >= 0.5:
            for i in range(0, 11, 1 if lod > 0.5 else 2):
                lines.append(QtCore.QLineF(18 + 7*i, 13, 18 + 7*i, 5))
                lines.append(QtCore.QLineF(18 + 7*i, 54, 18 + 7*i, 62))
            for i in range(0, 7, 1 if lod > 0.5 else 2):
                lines.append(QtCore.QLineF(5, 18 + i*5, 13, 18 + i*5))
                lines.append(QtCore.QLineF(94, 18 + i*5, 102, 18 + i*5))
        if lod >= 0.4:
            lines.append(QtCore.QLineF(25, 35, 35, 35))
            lines.append(QtCore.QLineF(35, 30, 35, 40))
            lines.append(QtCore.QLineF(35, 30, 45, 35))
            lines.append(QtCore.QLineF(35, 40, 45, 35))
            lines.append(QtCore.QLineF(45, 30, 45, 40))
            lines.append(QtCore.QLineF(45, 35, 55, 35))
        p.drawLines(lines)

        # Draw red ink
        if self.stuff:
            p.setPen(QtGui.QPen(QtCore.Qt.red, 1, QtCore.Qt.SolidLine,
                                QtCore.Qt.RoundCap, QtCore.Qt.RoundJoin))
            p.setBrush(QtCore.Qt.NoBrush)
            path = QtGui.QPainterPath()
            path.moveTo(self.stuff[0])
            for point in self.stuff[1:]:
                path.lineTo(point)
            p.drawPath(path)

        p.setPen(oldPen)
        p.setBrush(oldBrush)