Esempio n. 1
0
    def paintEvent(self, event):
        """
        Render the UI.

        :param event: Qt Paint event.
        """
        if self._mode == self.MODE_OFF:
            return

        painter = QtGui.QPainter()
        painter.begin(self)
        try:
            # set up semi transparent backdrop
            painter.setRenderHint(QtGui.QPainter.Antialiasing)

            # now draw different things depending on mode
            if self._mode == self.MODE_SPIN:

                self._draw_opened_circle(painter, self._spin_angle * 4, 340)

            elif self._mode == self.MODE_PROGRESS:
                self._draw_opened_circle(
                    painter,
                    # Start at noon
                    90,
                    # Go clockwise
                    -self._spin_angle)

                self._draw_heartbeat(painter)

        finally:
            painter.end()
    def paintEvent(self, event):
        """
        Render the UI.
        """
        if self._mode == self.MODE_OFF:
            return

        painter = QtGui.QPainter()
        painter.begin(self)
        try:
            # set up semi transparent backdrop
            overlay_color = QtGui.QColor("#1B1B1B")
            painter.setBrush(QtGui.QBrush(overlay_color))
            painter.setPen(QtGui.QPen(overlay_color))
            painter.drawRect(0, 0, painter.device().width(), painter.device().height())

            if self._mode == self.MODE_INFO_TEXT:
                # show text in the middle
                pen = QtGui.QPen(QtGui.QColor("#888888"))
                painter.setPen(pen)
                text_rect = QtCore.QRect(0, 0, painter.device().width(), painter.device().height())
                text_flags = QtCore.Qt.AlignCenter | QtCore.Qt.AlignVCenter | QtCore.Qt.TextWordWrap
                painter.drawText(text_rect, text_flags, self._message)

            elif self._mode == self.MODE_ERROR:
                # show error text in the center
                pen = QtGui.QPen(QtGui.QColor("#C8534A"))
                painter.setPen(pen)
                text_rect = QtCore.QRect(0, 0, painter.device().width(), painter.device().height())
                text_flags = QtCore.Qt.AlignCenter | QtCore.Qt.AlignVCenter | QtCore.Qt.TextWordWrap
                painter.drawText(text_rect, text_flags, self._message)

            elif self._mode == self.MODE_INFO_PIXMAP:
                # draw image
                painter.translate((painter.device().width() / 2) - (self._message_pixmap.width() / 2),
                                  (painter.device().height() / 2) - (self._message_pixmap.height() / 2))

                painter.drawPixmap(QtCore.QPoint(0, 0), self._message_pixmap)

        finally:
            painter.end()

        return super(ShotgunOverlayWidget, self).paintEvent(event)
Esempio n. 3
0
    def setPixmap(self, pixmap):

        # scale the pixmap down to fit
        if pixmap.height() > 40 or pixmap.width() > 60:
            # scale it down to 120x80
            pixmap = pixmap.scaled(QtCore.QSize(60,
                                                40), QtCore.Qt.KeepAspectRatio,
                                   QtCore.Qt.SmoothTransformation)

        # now slap it on top of a 120x80 transparent canvas
        rendered_pixmap = QtGui.QPixmap(60, 40)
        rendered_pixmap.fill(QtCore.Qt.transparent)

        w_offset = (60 - pixmap.width()) / 2
        h_offset = (40 - pixmap.height()) / 2

        painter = QtGui.QPainter(rendered_pixmap)
        painter.drawPixmap(w_offset, h_offset, pixmap)
        painter.end()

        # and finally assign it
        QtGui.QLabel.setPixmap(self, rendered_pixmap)
    def paintEvent(self, event):
        """
        Render the UI.
        """
        if self._mode == self.MODE_OFF:
            return

        painter = QtGui.QPainter()
        painter.begin(self)
        try:
            # set up semi transparent backdrop
            painter.setRenderHint(QtGui.QPainter.Antialiasing)
            overlay_color = QtGui.QColor("#1B1B1B")
            painter.setBrush(QtGui.QBrush(overlay_color))
            painter.setPen(QtGui.QPen(overlay_color))
            painter.drawRect(0, 0,
                             painter.device().width(),
                             painter.device().height())

            # now draw different things depending on mode
            if self._mode == self.MODE_SPIN:

                # show the spinner
                painter.translate((painter.device().width() / 2) - 40,
                                  (painter.device().height() / 2) - 40)

                pen = QtGui.QPen(QtGui.QColor("#424141"))
                pen.setWidth(3)
                painter.setPen(pen)
                painter.drawPixmap(QtCore.QPoint(8, 24), self._sg_icon)

                r = QtCore.QRectF(0.0, 0.0, 80.0, 80.0)
                start_angle = (0 + self._spin_angle) * 4 * 16
                span_angle = 340 * 16

                painter.drawArc(r, start_angle, span_angle)

            elif self._mode == self.MODE_INFO_TEXT:
                # show text in the middle
                pen = QtGui.QPen(QtGui.QColor("#888888"))
                painter.setPen(pen)
                text_rect = QtCore.QRect(0, 0,
                                         painter.device().width(),
                                         painter.device().height())
                text_flags = QtCore.Qt.AlignCenter | QtCore.Qt.AlignVCenter | QtCore.Qt.TextWordWrap
                painter.drawText(text_rect, text_flags, self._message)

            elif self._mode == self.MODE_ERROR:
                # show error text in the center
                pen = QtGui.QPen(QtGui.QColor("#C8534A"))
                painter.setPen(pen)
                text_rect = QtCore.QRect(0, 0,
                                         painter.device().width(),
                                         painter.device().height())
                text_flags = QtCore.Qt.AlignCenter | QtCore.Qt.AlignVCenter | QtCore.Qt.TextWordWrap
                painter.drawText(text_rect, text_flags, self._message)

            elif self._mode == self.MODE_INFO_PIXMAP:
                # draw image
                painter.translate((painter.device().width() / 2) -
                                  (self._message_pixmap.width() / 2),
                                  (painter.device().height() / 2) -
                                  (self._message_pixmap.height() / 2))

                painter.drawPixmap(QtCore.QPoint(0, 0), self._message_pixmap)

        finally:
            painter.end()
Esempio n. 5
0
    def _set_window_mask(self):
        """ set the window mask when pinned to the systray """
        if self.state == self.STATE_WINDOWED:
            self.__content_layout.setContentsMargins(0, 0, 0, 0)
            self.clearMask()
            return

        # temp bitmap to store the mask
        bmp = QtGui.QBitmap(self.size())

        # create and configure the painter
        self.painter = QtGui.QPainter(bmp)
        self.painter.setRenderHint(QtGui.QPainter.HighQualityAntialiasing,
                                   True)

        # figure out what side to draw the anchor on
        side = self._guess_toolbar_side()

        # mask out from the top margin of the border_layout
        rect = self.rect()

        # make sure there is room to draw the anchor
        anchor_height = self.__bottom_anchor.height()
        if self.__content_layout is not None:
            if side == self.DOCK_TOP:
                mask = rect.adjusted(0, anchor_height, 0, 0)
                self.__content_layout.setContentsMargins(
                    0, anchor_height, 0, 0)
            elif side == self.DOCK_LEFT:
                mask = rect.adjusted(anchor_height, 0, 0, 0)
                self.__content_layout.setContentsMargins(
                    anchor_height, 0, 0, 0)
            elif side == self.DOCK_RIGHT:
                mask = rect.adjusted(0, 0, -anchor_height, 0)
                self.__content_layout.setContentsMargins(
                    0, 0, -anchor_height, 0)
            elif side == self.DOCK_BOTTOM:
                mask = rect.adjusted(0, 0, 0, -anchor_height)
                self.__content_layout.setContentsMargins(
                    0, 0, 0, anchor_height)
            else:
                raise ValueError("Unknown value for side: %s" % side)

        self.painter.fillRect(rect, QtCore.Qt.white)
        self.painter.setBrush(QtCore.Qt.black)
        self.painter.drawRoundedRect(mask, self.__corner_radius,
                                     self.__corner_radius)

        if self.state == self.STATE_PINNED:
            # add back in the anchor triangle
            points = []
            mask_center = mask.center()
            if side == self.DOCK_TOP:
                anchor_pixmap = self.__top_anchor
                anchor_center = anchor_pixmap.rect().center()
                points.append(QtCore.QPoint(mask_center.x(), rect.top()))
                points.append(
                    QtCore.QPoint(mask_center.x() - anchor_height, mask.top()))
                points.append(
                    QtCore.QPoint(mask_center.x() + anchor_height, mask.top()))
            elif side == self.DOCK_LEFT:
                anchor_pixmap = self.__left_anchor
                anchor_center = anchor_pixmap.rect().center()
                points.append(QtCore.QPoint(rect.left(), mask_center.y()))
                points.append(
                    QtCore.QPoint(mask.left(),
                                  mask_center.y() - anchor_center.y()))
                points.append(
                    QtCore.QPoint(mask.left(),
                                  mask_center.y() + anchor_center.y()))
            elif side == self.DOCK_RIGHT:
                anchor_pixmap = self.__right_anchor
                anchor_center = anchor_pixmap.rect().center()
                points.append(
                    QtCore.QPoint(mask.right(),
                                  mask_center.y() + anchor_center.y()))
                points.append(
                    QtCore.QPoint(mask.right(),
                                  mask_center.y() - anchor_center.y()))
                points.append(QtCore.QPoint(rect.right(), mask_center.y()))
            elif side == self.DOCK_BOTTOM:
                anchor_pixmap = self.__bottom_anchor
                anchor_center = anchor_pixmap.rect().center()
                points.append(
                    QtCore.QPoint(mask_center.x() - anchor_height,
                                  mask.bottom()))
                points.append(
                    QtCore.QPoint(mask_center.x() + anchor_height,
                                  mask.bottom()))
                points.append(QtCore.QPoint(mask_center.x(), rect.bottom()))
            else:
                raise ValueError("Unknown value for side: %s" % side)

            self.painter.drawPolygon(points)

        # need to end the painter to make sure that its resources get
        # garbage collected before the bitmap to avoid a crash
        self.painter.end()

        # finally set the window mask to the bitmap
        self.setMask(bmp)
        self.__anchor_side = side