def __init__(self, engine=None, parent=None):
        super(DQuickView, self).__init__(engine, parent)
        self.setResizeMode(QtQuick.QQuickView.SizeViewToRootObject)
        self.engine().addImportPath(os.sep.join([get_parent_dir(__file__, 2),
                                                 'qml']))
        if isWebengineUsed:
            # self.initWebengine()
            pass

        format = QSurfaceFormat()
        format.setAlphaBufferSize(8)
        format.setRenderableType(QSurfaceFormat.OpenGL)

        self.setFormat(format)
        self.setColor(QColor(Qt.transparent))
        self.setClearBeforeRendering(True) 

def createPixmapFromNinePatchImage(image, dw, dh):
    w = dw
    h = dh
    if w < image.width() or h < image.height():  # shrink
        w = max(image.width(), w)
        h = max(image.height(), h)
        pm1 = resize9patch(image, w, h)
        if pm1.isNull():
            return QPixmap()
        pm2 = QPixmap(dw, dh)
        pm2.fill(Qt.transparent)
        pr = QPainter(pm2)
        pr.setRenderHint(QPainter.Antialiasing)
        pr.setRenderHint(QPainter.SmoothPixmapTransform)
        pr.drawPixmap(0, 0, dw, dh, pm1, 0, 0, w, h)
        return pm2
    else:
        return resize9patch(image, dw, dh) 

def startDrag(self, supportedActions):
        items = self.selectedItems()
        drag = QDrag(self)
        mimeData = self.mimeData(items)
        # 由于QMimeData只能设置image、urls、str、bytes等等不方便
        # 这里添加一个额外的属性直接把item放进去,后面可以根据item取出数据
        mimeData.setProperty('myItems', items)
        drag.setMimeData(mimeData)
        pixmap = QPixmap(self.viewport().visibleRegion().boundingRect().size())
        pixmap.fill(Qt.transparent)
        painter = QPainter()
        painter.begin(pixmap)
        for item in items:
            rect = self.visualRect(self.indexFromItem(item))
            painter.drawPixmap(rect, self.viewport().grab(rect))
        painter.end()
        drag.setPixmap(pixmap)
        drag.setHotSpot(self.viewport().mapFromGlobal(QCursor.pos()))
        drag.exec_(supportedActions) 

def __init__(self, *args, fillcolor, opacity, parent=None):
        if len(args) == 0:
            super().__init__(parent)
        elif len(args) == 1:
            super().__init__(args[0], parent)
        elif len(args) == 4:
            x0, y0, w, h = args
            super().__init__(x0, y0, w, h, parent)

        self.finished = False
        self.selected_edge = None  # type: int
        self.resizing = False

        self.setBrush(fillcolor)
        self.setPen(QPen(QColor(Qt.transparent), 0))
        self.setOpacity(opacity) 

def paint(self, painter, option, widget):
        if self.scene().mode == 1:
            self.setOpacity(1 if self.model_item.logging_active else 0.3)

        if self.hover_active or self.isSelected():
            painter.setOpacity(settings.SELECTION_OPACITY)
            painter.setBrush(settings.SELECTION_COLOR)
            painter.setPen(QPen(QColor(Qt.transparent), 0))
            painter.drawRect(self.boundingRect())
        elif not self.is_valid():
            painter.setOpacity(settings.SELECTION_OPACITY)
            painter.setBrush(QColor(255, 0, 0, 150))
            painter.setPen(QPen(QColor(Qt.transparent), 0))
            painter.drawRect(self.boundingRect())

        if self.drag_over:
            self.paint_drop_indicator(painter) 

def resetPreviewer(self):
        pix = QPixmap(333, 333)
        pix.fill(Qt.transparent)
        self.preview.setPixmap(pix) 

def __init__(self, *args, **kwargs):
        palette = self.palette()
        if sys.platform == 'linux':
            # KDE use the QPalette.Base as background color
            palette.setColor(QPalette.Active, QPalette.Base, Qt.transparent)
            palette.setColor(QPalette.Inactive, QPalette.Base, Qt.transparent)
            # GNOME use the QPalette.Window as background color
            palette.setColor(QPalette.Active, QPalette.Window, Qt.transparent)
            palette.setColor(QPalette.Inactive, QPalette.Window, Qt.transparent)
        else:
            # macOS use the QPalette.Window as background color
            palette.setColor(QPalette.Active, QPalette.Window, Qt.transparent)
            palette.setColor(QPalette.Inactive, QPalette.Window, Qt.transparent)
        self.setPalette(palette) 

def pixmap(self, size, mode, state):
        pixmap = QPixmap(size)
        pixmap.fill(Qt.transparent)
        self.paint(QPainter(pixmap), QRect(QPoint(0, 0), size), mode, state)
        return pixmap 

def gradientCirclePixmap(self):
        """白色带阴影
        """
        xy = self.height() / 2
        radius = self.height() * 0.8

        # 绘制普通状态下圆形的滑块
        circleColor = QRadialGradient(xy, xy, radius, xy, xy)
        circleColor.setColorAt(0.5, QColor(254, 254, 254))
        circleColor.setColorAt(0.7, QColor(0, 0, 0, 60))
        circleColor.setColorAt(0.7, QColor(0, 0, 0, 30))
        circleColor.setColorAt(0.9, QColor(0, 0, 0, 0))
        self._imageCircle = QImage(
            self.height(), self.height(), QImage.Format_ARGB32)
        self._imageCircle.fill(Qt.transparent)
        painter = QPainter()
        painter.begin(self._imageCircle)
        painter.setRenderHint(QPainter.Antialiasing, True)
        painter.setRenderHint(QPainter.SmoothPixmapTransform, True)
        painter.setPen(Qt.NoPen)
        painter.setBrush(circleColor)
        painter.drawRoundedRect(0, 0, self.height(), self.height(), xy, xy)
        painter.end()

        # 绘制悬停状态下圆形的滑块
        circleColorHover = QRadialGradient(xy, xy, radius, xy, xy)
        circleColorHover.setColorAt(0.5, QColor(245, 245, 245))
        circleColorHover.setColorAt(0.7, QColor(0, 0, 0, 30))
        circleColorHover.setColorAt(0.9, QColor(0, 0, 0, 0))
        self._imageCircleHover = QImage(
            self.height(), self.height(), QImage.Format_ARGB32)
        self._imageCircleHover.fill(Qt.transparent)
        painter = QPainter()
        painter.begin(self._imageCircleHover)
        painter.setRenderHint(QPainter.Antialiasing, True)
        painter.setRenderHint(QPainter.SmoothPixmapTransform, True)
        painter.setPen(Qt.NoPen)
        painter.setBrush(circleColorHover)
        painter.drawRoundedRect(0, 0, self.height(), self.height(), xy, xy)
        painter.end() 

def _createPointer(self):
        # 绘制一个小圆环
        self._imagePointer = QImage(12, 12, QImage.Format_ARGB32)
        self._imagePointer.fill(Qt.transparent)
        painter = QPainter()
        painter.begin(self._imagePointer)
        painter.setRenderHint(QPainter.Antialiasing, True)
        painter.setRenderHint(QPainter.SmoothPixmapTransform, True)
        painter.setPen(QPen(Qt.white, 2))
        painter.setBrush(Qt.NoBrush)
        path = QPainterPath()
        path.addRoundedRect(0, 0, 12, 12, 6.0, 6.0)
        painter.setClipPath(path)
        painter.drawRoundedRect(0, 0, 12, 12, 6.0, 6.0)
        painter.end() 

def __init__(self, app_window):
        super(ScriptsDialog, self).__init__(app_window)

        self.script = None
        self._app_window = app_window
        self._script_manager = ScriptsManager()
        self._git = Git()

        self.setMinimumWidth(800)

        box = QVBoxLayout()
        self.table = ScriptsTable(self)
        self.table.onScriptSelected.connect(self._item_selected)
        self.table.setMinimumWidth(800)

        # create a centered dot icon
        _section_width = self.table.header().sectionSize(3)
        self._new_pixmap = QPixmap(max(_section_width, 40), 20)
        self._new_pixmap.fill(Qt.transparent)
        painter = QPainter(self._new_pixmap)
        rect = QRect((_section_width * 0.5) - 5, 0, 20, 20)
        painter.setBrush(QColor('#666'))
        painter.setPen(QColor('#666'))
        painter.drawEllipse(rect)
        self._dot_icon = QIcon(self._new_pixmap)

        box.addWidget(self.table)
        lbl = QLabel('OS Support - A: Android I: IOS W: Windows')
        box.addWidget(lbl)
        self.setLayout(box)
        self._init_list() 

def draw_line_numbers(self, event):
        painter = QPainter(self.ui_line_numbers)
        # background
        painter.fillRect(event.rect(), Qt.transparent)

        # linenums
        current_block = self.firstVisibleBlock()
        block_num = current_block.blockNumber()

        top = self.blockBoundingGeometry(current_block).translated(
            self.contentOffset()).top()
        bottom = top + self.blockBoundingRect(current_block).height()

        while current_block.isValid() and (top <= event.rect().bottom()):
            if current_block.isVisible() and (bottom >= event.rect().top()):
                s = ("{0}".format(block_num + 1))
                painter.setPen(QColor('#636d83'))
                painter.setFont(self.font())
                painter.drawText(0, top,
                                 self.calculated_linenum_width() - 5,
                                 self.fontMetrics().height(),
                                 Qt.AlignRight | Qt.AlignVCenter, s)

            current_block = current_block.next()
            top = bottom
            bottom = top + self.blockBoundingRect(current_block).height()
            block_num += 1 

def __init__(self, *args, antialiasing=True, **kwargs):
        super(Label, self).__init__(*args, **kwargs)
        self.Antialiasing = antialiasing
        self.setMaximumSize(200, 200)
        self.setMinimumSize(200, 200)
        self.radius = 100

        #####################核心实现#########################
        self.target = QPixmap(self.size())  # 大小和控件一样
        self.target.fill(Qt.transparent)  # 填充背景为透明

        p = QPixmap("Data/Images/head.jpg").scaled(  # 加载图片并缩放和控件一样大
            200, 200, Qt.KeepAspectRatioByExpanding, Qt.SmoothTransformation)

        painter = QPainter(self.target)
        if self.Antialiasing:
            # 抗锯齿
            painter.setRenderHint(QPainter.Antialiasing, True)
            painter.setRenderHint(QPainter.HighQualityAntialiasing, True)
            painter.setRenderHint(QPainter.SmoothPixmapTransform, True)

        #         painter.setPen(# 测试圆圈
        #             QPen(Qt.red, 5, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin))
        path = QPainterPath()
        path.addRoundedRect(
            0, 0, self.width(), self.height(), self.radius, self.radius)
        # **** 切割为圆形 ****#
        painter.setClipPath(path)
        #         painter.drawPath(path)  # 测试圆圈

        painter.drawPixmap(0, 0, p)
        self.setPixmap(self.target)
        #####################核心实现######################### 

def clearChart(self):
        self.color = QColor(Qt.transparent)
        self.update()

        self.chartCleared.emit()  # 发射信号 

def onScreenShot1(self):
        # 截图方式1
        page = self.webView.page()
        oldSize = self.webView.size()
        self.webView.resize(page.contentsSize().toSize())

        def doScreenShot():
            rect = self.webView.contentsRect()
            size = rect.size()
            image = QImage(size, QImage.Format_ARGB32_Premultiplied)
            image.fill(Qt.transparent)

            painter = QPainter()
            painter.begin(image)
            painter.setRenderHint(QPainter.Antialiasing, True)
            painter.setRenderHint(QPainter.TextAntialiasing, True)
            painter.setRenderHint(QPainter.SmoothPixmapTransform, True)

            self.webView.render(painter)
            painter.end()
            self.webView.resize(oldSize)

            # 添加到左侧list中
            item = QListWidgetItem(self.widgetRight)
            image = QPixmap.fromImage(image)
            item.setIcon(QIcon(image))
            item.setData(Qt.UserRole + 1, image)

        # 先等一下再截图吧
        QTimer.singleShot(2000, doScreenShot) 

def __init__(self, *args, **kwargs):
        super(Window, self).__init__(*args, **kwargs)

        self.setAttribute(Qt.WA_TranslucentBackground, True)  # 设置父控件Widget背景透明
        self.setWindowFlags(Qt.FramelessWindowHint)  # 去掉边框
        palette = self.palette()
        palette.setBrush(QPalette.Base, Qt.transparent)  # 父控件背景透明
        self.setPalette(palette)

        layout = QVBoxLayout(self)
        layout.setContentsMargins(0, 0, 0, 0)

        #         QWebSettings.globalSettings().setAttribute(
        #             QWebSettings.DeveloperExtrasEnabled, True)# web开发者工具

        self.webView = QWebView(self)  # 网页控件
        layout.addWidget(self.webView)
        self.webView.setContextMenuPolicy(Qt.NoContextMenu)  # 去掉右键菜单
        self.mainFrame = self.webView.page().mainFrame()

        self.mainFrame.setScrollBarPolicy(
            Qt.Vertical, Qt.ScrollBarAlwaysOff)  # 去掉滑动条
        self.mainFrame.setScrollBarPolicy(Qt.Horizontal, Qt.ScrollBarAlwaysOff)

        # 最大化
        rect = app.desktop().availableGeometry()
        self.resize(rect.size())
        self.webView.resize(rect.size()) 

def __init__(self, project_manager, modulated_data, modulation_msg_indices=None, continuous_send_mode=False,
                 parent=None, testing_mode=False):
        super().__init__(project_manager, is_tx=True, continuous_send_mode=continuous_send_mode,
                         parent=parent, testing_mode=testing_mode)

        self.graphics_view = self.ui.graphicsViewSend
        self.ui.stackedWidget.setCurrentWidget(self.ui.page_send)
        self.hide_receive_ui_items()

        self.ui.btnStart.setIcon(QIcon.fromTheme("media-playback-start"))
        self.setWindowTitle("Send Signal")
        self.setWindowIcon(QIcon.fromTheme("media-playback-start"))
        self.ui.btnStart.setToolTip("Send data")
        self.ui.btnStop.setToolTip("Stop sending")
        self.device_is_sending = False
        self.modulation_msg_indices = modulation_msg_indices

        if self.modulation_msg_indices is not None:
            self.ui.progressBarMessage.setMaximum(len(self.modulation_msg_indices))
        else:
            self.ui.progressBarMessage.hide()
            self.ui.labelCurrentMessage.hide()

        if modulated_data is not None:
            assert isinstance(modulated_data, IQArray)
            # modulated_data is none in continuous send mode
            self.ui.progressBarSample.setMaximum(len(modulated_data))
            samp_rate = self.device_settings_widget.ui.spinBoxSampleRate.value()
            signal = Signal("", "Modulated Preview", sample_rate=samp_rate)
            signal.iq_array = modulated_data
            self.scene_manager = SignalSceneManager(signal, parent=self)
            self.send_indicator = self.scene_manager.scene.addRect(0, -2, 0, 4,
                                                                   QPen(QColor(Qt.transparent), 0),
                                                                   QBrush(settings.SEND_INDICATOR_COLOR))
            self.send_indicator.stackBefore(self.scene_manager.scene.selection_area)
            self.scene_manager.init_scene()
            self.graphics_view.set_signal(signal)
            self.graphics_view.sample_rate = samp_rate

            self.create_connects()
            self.device_settings_widget.update_for_new_device(overwrite_settings=False) 

def dialog_ui(self) -> QDialog:
        if self.__dialog_ui is None:
            dir_name = os.path.dirname(os.readlink(__file__)) if os.path.islink(__file__) else os.path.dirname(__file__)

            logging.getLogger().setLevel(logging.WARNING)
            self.__dialog_ui = uic.loadUi(os.path.realpath(os.path.join(dir_name, "insert_sine_dialog.ui")))
            logging.getLogger().setLevel(logger.level)

            self.__dialog_ui.setAttribute(Qt.WA_DeleteOnClose)
            self.__dialog_ui.setModal(True)
            self.__dialog_ui.doubleSpinBoxAmplitude.setValue(self.__amplitude)
            self.__dialog_ui.doubleSpinBoxFrequency.setValue(self.__frequency)
            self.__dialog_ui.doubleSpinBoxPhase.setValue(self.__phase)
            self.__dialog_ui.doubleSpinBoxSampleRate.setValue(self.__sample_rate)
            self.__dialog_ui.doubleSpinBoxNSamples.setValue(self.__num_samples)
            self.__dialog_ui.lineEditTime.setValidator(
                QRegExpValidator(QRegExp(r"[0-9]+([nmµ]?|([\.,][0-9]{1,3}[nmµ]?))?$"))
            )

            scene_manager = SceneManager(self.dialog_ui.graphicsViewSineWave)
            self.__dialog_ui.graphicsViewSineWave.scene_manager = scene_manager
            self.insert_indicator = scene_manager.scene.addRect(0, -2, 0, 4,
                                                                QPen(QColor(Qt.transparent), 0),
                                                                QBrush(self.INSERT_INDICATOR_COLOR))
            self.insert_indicator.stackBefore(scene_manager.scene.selection_area)

            self.set_time()

        return self.__dialog_ui 

def paint(self, painter: QPainter, option: QStyleOptionViewItem, index: QModelIndex) -> None:
        r = option.rect
        pencolor = Qt.white if self.theme == 'dark' else Qt.black
        if self.parent.isEnabled():
            if option.state & QStyle.State_Selected:
                painter.setBrush(QColor(150, 190, 78, 150))
            elif option.state & QStyle.State_MouseOver:
                painter.setBrush(QColor(227, 212, 232))
                pencolor = Qt.black
            else:
                brushcolor = QColor(79, 85, 87, 175) if self.theme == 'dark' else QColor('#EFF0F1')
                painter.setBrush(Qt.transparent if index.row() % 2 == 0 else brushcolor)
        painter.setPen(Qt.NoPen)
        painter.drawRect(r)
        thumbicon = QIcon(index.data(Qt.DecorationRole + 1))
        starttime = index.data(Qt.DisplayRole + 1)
        endtime = index.data(Qt.UserRole + 1)
        externalPath = index.data(Qt.UserRole + 2)
        chapterName = index.data(Qt.UserRole + 3)
        painter.setPen(QPen(pencolor, 1, Qt.SolidLine))
        if len(chapterName):
            offset = 20
            r = option.rect.adjusted(5, 5, 0, 0)
            cfont = QFont('Futura LT', -1, QFont.Medium)
            cfont.setPointSizeF(12.25 if sys.platform == 'darwin' else 10.25)
            painter.setFont(cfont)
            painter.drawText(r, Qt.AlignLeft, self.clipText(chapterName, painter, True))
            r = option.rect.adjusted(5, offset, 0, 0)
        else:
            offset = 0
            r = option.rect.adjusted(5, 0, 0, 0)
        thumbicon.paint(painter, r, Qt.AlignVCenter | Qt.AlignLeft)
        r = option.rect.adjusted(110, 10 + offset, 0, 0)
        painter.setFont(QFont('Noto Sans', 11 if sys.platform == 'darwin' else 9, QFont.Bold))
        painter.drawText(r, Qt.AlignLeft, 'FILENAME' if len(externalPath) else 'START')
        r = option.rect.adjusted(110, 23 + offset, 0, 0)
        painter.setFont(QFont('Noto Sans', 11 if sys.platform == 'darwin' else 9, QFont.Normal))
        if len(externalPath):
            painter.drawText(r, Qt.AlignLeft, self.clipText(os.path.basename(externalPath), painter))
        else:
            painter.drawText(r, Qt.AlignLeft, starttime)
        if len(endtime) > 0:
            r = option.rect.adjusted(110, 48 + offset, 0, 0)
            painter.setFont(QFont('Noto Sans', 11 if sys.platform == 'darwin' else 9, QFont.Bold))
            painter.drawText(r, Qt.AlignLeft, 'RUNTIME' if len(externalPath) else 'END')
            r = option.rect.adjusted(110, 60 + offset, 0, 0)
            painter.setFont(QFont('Noto Sans', 11 if sys.platform == 'darwin' else 9, QFont.Normal))
            painter.drawText(r, Qt.AlignLeft, endtime) 

def gradientPixmap(self, types, color):
        """生成渐变图片
        """
        pixSize = 5
        if types == self.TypeAlpha:
            # 生成黑边相间的模拟透明背景
            if not self._imageAlphaTmp:
                self._imageAlphaTmp = QImage(
                    self.width(), self.height(), QImage.Format_ARGB32)
                painter = QPainter()
                painter.begin(self._imageAlphaTmp)
                painter.setRenderHint(QPainter.Antialiasing, True)
                painter.setRenderHint(QPainter.SmoothPixmapTransform, True)
                for x in range(int(self.width() / pixSize)):
                    for y in range(int(self.height() / pixSize)):
                        _x, _y = x * pixSize, y * pixSize
                        painter.fillRect(_x, _y, pixSize, pixSize,
                                         Qt.white if x % 2 != y % 2 else Qt.darkGray)
                painter.end()
            # 绘制透明渐变
            gradient = QLinearGradient(0, 0, self.width(), 0)
            gradient.setColorAt(0, QColor(0, 0, 0, 0))
            gradient.setColorAt(1, color)
            # 只画渐变颜色
            self._imageAlphaColor = QImage(
                self.width(), self.height(), QImage.Format_ARGB32)
            self._imageAlphaColor.fill(Qt.transparent)
            painter = QPainter()
            painter.begin(self._imageAlphaColor)
            painter.setRenderHint(QPainter.Antialiasing, True)
            painter.setRenderHint(QPainter.SmoothPixmapTransform, True)
            painter.fillRect(0, 0, self.width(), self.height(), gradient)
            painter.end()
            # 合并方格图
            self._imageAlpha = self._imageAlphaColor.copy()
            painter = QPainter()
            painter.begin(self._imageAlpha)
            painter.setRenderHint(QPainter.Antialiasing, True)
            painter.setRenderHint(QPainter.SmoothPixmapTransform, True)
            painter.drawImage(0, 0, self._imageAlphaTmp)
            painter.fillRect(0, 0, self.width(), self.height(), gradient)
            painter.end()
        else:
            gradient = QLinearGradient(0, 0, self.width(), 0)
            gradient.setColorAt(0, QColor('#ff0000'))
            gradient.setColorAt(0.17, QColor('#ffff00'))
            gradient.setColorAt(0.33, QColor('#00ff00'))
            gradient.setColorAt(0.5, QColor('#00ffff'))
            gradient.setColorAt(0.67, QColor('#0000ff'))
            gradient.setColorAt(0.83, QColor('#ff00ff'))
            gradient.setColorAt(1, QColor('#ff0000'))
            self._imageRainbow = QImage(
                self.width(), self.height(), QImage.Format_ARGB32)
            painter = QPainter()
            painter.begin(self._imageRainbow)
            painter.setRenderHint(QPainter.Antialiasing, True)
            painter.setRenderHint(QPainter.SmoothPixmapTransform, True)
            painter.fillRect(0, 0, self.width(), self.height(), gradient)
            painter.end() 

def paintEvent(self, event):  # noqa: N802
        """Called when the widget is being painted."""
        # Adjust the buffer size according to the pixel ratio
        dpr = self.devicePixelRatioF()
        buffer = QPixmap(self.width() * dpr, self.height() * dpr)
        buffer.setDevicePixelRatio(dpr)
        buffer.fill(Qt.transparent)

        painter = QPainter(buffer)

        # Paint the server text widget
        region = QRegion(
            QRect(QPoint(0, 0), self._servers_text_widget.sizeHint())
        )
        self._servers_text_widget.render(painter, QPoint(0, 0), region)
        # Paint the server icon widget
        region = QRegion(
            QRect(QPoint(0, 0), self._servers_icon_widget.sizeHint())
        )
        x = self._servers_text_widget.sizeHint().width() + 3
        self._servers_icon_widget.render(painter, QPoint(x, 0), region)
        # Paint the invites text widget
        region = QRegion(
            QRect(QPoint(0, 0), self._invites_text_widget.sizeHint())
        )
        x += self._servers_icon_widget.sizeHint().width() + 3
        self._invites_text_widget.render(painter, QPoint(x, 0), region)
        # Paint the invites icon widget
        region = QRegion(
            QRect(QPoint(0, 0), self._invites_icon_widget.sizeHint())
        )
        x += self._invites_text_widget.sizeHint().width() + 3
        self._invites_icon_widget.render(painter, QPoint(x, 0), region)
        # Paint the users text widget
        region = QRegion(
            QRect(QPoint(0, 0), self._users_text_widget.sizeHint())
        )
        x += self._invites_icon_widget.sizeHint().width() + 3
        self._users_text_widget.render(painter, QPoint(x, 0), region)
        # Paint the users icon widget
        region = QRegion(
            QRect(QPoint(0, 0), self._users_icon_widget.sizeHint())
        )
        x += self._users_text_widget.sizeHint().width() + 3
        self._users_icon_widget.render(painter, QPoint(x, 0), region)
        painter.end()

        painter = QPainter(self)
        painter.drawPixmap(event.rect(), buffer, buffer.rect())
        painter.end()