def paintEvent(self, event): """ Render the UI. """ # first render the label QtGui.QLabel.paintEvent(self, event) if self.playable and self.interactive: # now render a pixmap on top painter = QtGui.QPainter() painter.begin(self) try: # set up semi transparent backdrop painter.setRenderHint(QtGui.QPainter.Antialiasing) # draw image painter.translate((painter.device().width() / 2) - (self._play_icon.width()/2), (painter.device().height() / 2) - (self._play_icon.height()/2) ) if self._hover: painter.drawPixmap( QtCore.QPoint(0, 0), self._play_icon) else: painter.drawPixmap( QtCore.QPoint(0, 0), self._play_icon_inactive) finally: painter.end()
def paintEvent(self, paint_event): """ Paint Event override """ # paint multiple values indicator if self._multiple_values == True: p = QtGui.QPainter(self) p.drawPixmap( 0, 0, self.width(), self.height(), self._no_thumb_pixmap, 0, 0, self._no_thumb_pixmap.width(), self._no_thumb_pixmap.height(), ) p.fillRect(0, 0, self.width(), self.height(), QtGui.QColor(42, 42, 42, 237)) p.setFont(QtGui.QFont("Arial", 15, QtGui.QFont.Bold)) pen = QtGui.QPen(QtGui.QColor("#18A7E3")) p.setPen(pen) p.drawText(self.rect(), QtCore.Qt.AlignCenter, "Multiple Values") else: # paint thumbnail QtGui.QLabel.paintEvent(self, paint_event)
def paintEvent(self, event): """ Paint the widget :param event: The QPaintEvent event """ # call the base paint event: QtGui.QWidget.paintEvent(self, event) painter = QtGui.QPainter() painter.begin(self) try: painter.setRenderHint(QtGui.QPainter.Antialiasing) # use the foreground colour to paint with: fg_col = self.palette().color(self.foregroundRole()) pen = QtGui.QPen(fg_col) pen.setWidth(self.line_width) painter.setPen(pen) border = self.border + int(math.ceil(self.line_width / 2.0)) r = QtCore.QRect(0, 0, self.width(), self.height()) r.adjust(border, border, -border, -border) # draw the arc: painter.drawArc(r, -self._start_angle * 16, self.arc_length * 16) r = None finally: painter.end() painter = None
def create_round_thumbnail(image): """ Create a 200 px wide circle thumbnail :param image: QImage representing a thumbnail :returns: Round QPixmap """ CANVAS_SIZE = 200 # get the 512 base image base_image = QtGui.QPixmap(CANVAS_SIZE, CANVAS_SIZE) base_image.fill(QtCore.Qt.transparent) # now attempt to load the image # pixmap will be a null pixmap if load fails thumb = QtGui.QPixmap.fromImage(image) if not thumb.isNull(): # scale it down to fit inside a frame of maximum 512x512 thumb_scaled = thumb.scaled(CANVAS_SIZE, CANVAS_SIZE, QtCore.Qt.KeepAspectRatioByExpanding, QtCore.Qt.SmoothTransformation) # now composite the thumbnail on top of the base image # bottom align it to make it look nice thumb_img = thumb_scaled.toImage() brush = QtGui.QBrush(thumb_img) painter = QtGui.QPainter(base_image) painter.setRenderHint(QtGui.QPainter.Antialiasing) painter.setBrush(brush) painter.drawEllipse(0, 0, CANVAS_SIZE, CANVAS_SIZE) painter.end() return base_image
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(30, 30, 30, 100) painter.setBrush( QtGui.QBrush(overlay_color)) painter.setPen(QtGui.QPen(overlay_color)) painter.drawRect(0, 0, painter.device().width(), painter.device().height()) # show the spinner painter.translate((painter.device().width() / 2) - 10, (painter.device().height() / 2) - 10) pen = QtGui.QPen(QtGui.QColor(self._bundle.style_constants["SG_HIGHLIGHT_COLOR"])) pen.setWidth(1) painter.setPen(pen) r = QtCore.QRectF(0.0, 0.0, 20.0, 20.0) start_angle = (0 + self._spin_angle) * 4 * 16 span_angle = 340 * 16 painter.drawArc(r, start_angle, span_angle) finally: painter.end()
def _get_default_thumbnail(self, sg_entity): """ Get the default icon for the specified entity. :param sg_entity: A Shotgun entity dictionary for the entity to get the icon for. :returns: A QIcon for the entity if available. For Step entities, a swatch representing the step colour is returned. If no icon is available for the entity type then the default icon is returned """ if sg_entity.get("type") == "Step": # special case handling for steps to return a colour swatch: step_id = sg_entity.get("id") if step_id != None: # get the colour from the cache: if step_id not in ShotgunEntityModel._SG_STEP_COLOURS: ShotgunEntityModel._SG_STEP_COLOURS[step_id] = None # refresh cache: bundle = sgtk.platform.current_bundle() try: sg_steps = bundle.shotgun.find("Step", [], ["color"]) for sg_step in sg_steps: colour = None try: colour = tuple([ int(c) for c in sg_step.get("color").split(",") ]) except: pass ShotgunEntityModel._SG_STEP_COLOURS[ sg_step["id"]] = colour except: pass colour = ShotgunEntityModel._SG_STEP_COLOURS[step_id] if colour and isinstance(colour, tuple) and len(colour) == 3: # get the icon for this colour from the cache: if colour not in self._step_swatch_icons: # build icon and add to cache: pm = QtGui.QPixmap(16, 16) pm.fill(QtCore.Qt.transparent) painter = QtGui.QPainter(pm) try: painter.setBrush( QtGui.QBrush( QtGui.QColor(colour[0], colour[1], colour[2]))) painter.setPen(QtCore.Qt.black) painter.drawRect(2, 2, 12, 12) finally: painter.end() self._step_swatch_icons[colour] = QtGui.QIcon(pm) # return the icon: return self._step_swatch_icons[colour] # just return the entity icon or the default icon if there is no entity icon: return self.get_entity_icon( sg_entity.get("type")) or self._default_icon
def paintEvent(self, event): """ Handles painting the text fade overlay. Overrides the same method from ``QtGui.QWidget`` """ painter = QtGui.QPainter(self) # calculate the rectangle to paint the overlay. # it should only be gradient_rect = QtCore.QRect( 60, # stay to the right of the thumbnail event.rect().bottom() - 8, # only 8 pixels high from the bottom event.rect().right() + 1, # ensure covers full width event.rect().bottom(), ) # vertical gradient gradient = QtGui.QLinearGradient(gradient_rect.topLeft(), gradient_rect.bottomLeft()) # transparent -> base color, in first 15% of height of rect gradient.setColorAt(0, QtGui.QColor(0, 0, 0, 0)) gradient.setColorAt(0.15, self.palette().base().color()) # paint it painter.fillRect(gradient_rect, gradient) painter.end()
def paintEvent(self, pe): opt = QtGui.QStyleOption() opt.initFrom(self) p = QtGui.QPainter(self) s = self.style() s.drawPrimitive(QtGui.QStyle.PE_Widget, opt, p, self)
def create_overlayed_publish_thumbnail(image): """ Given a shotgun thumbnail, create a publish icon with the thumbnail composited onto a centered otherwise empty canvas. This will return a 512x400 pixmap object. :param image: QImage containing a thumbnail :returns: QPixmap with a 512x400 px image """ CANVAS_WIDTH = 512 CANVAS_HEIGHT = 400 CORNER_RADIUS = 10 # get the 512 base image base_image = QtGui.QPixmap(CANVAS_WIDTH, CANVAS_HEIGHT) base_image.fill(QtCore.Qt.transparent) # now attempt to load the image # pixmap will be a null pixmap if load fails thumb = QtGui.QPixmap.fromImage(image) if not thumb.isNull(): # scale it down to fit inside a frame of maximum 512x512 thumb_scaled = thumb.scaled(CANVAS_WIDTH, CANVAS_HEIGHT, QtCore.Qt.KeepAspectRatio, QtCore.Qt.SmoothTransformation) # now composite the thumbnail on top of the base image # bottom align it to make it look nice thumb_img = thumb_scaled.toImage() brush = QtGui.QBrush(thumb_img) painter = QtGui.QPainter(base_image) painter.setRenderHint(QtGui.QPainter.Antialiasing) painter.setBrush(brush) # figure out the offsets in order to center the thumb height_difference = CANVAS_HEIGHT - thumb_scaled.height() width_difference = CANVAS_WIDTH - thumb_scaled.width() # center it horizontally inlay_offset_w = (width_difference / 2) + (CORNER_RADIUS / 2) # center it vertically inlay_offset_h = (height_difference / 2) + (CORNER_RADIUS / 2) # note how we have to compensate for the corner radius painter.translate(inlay_offset_w, inlay_offset_h) painter.drawRoundedRect(0, 0, thumb_scaled.width() - CORNER_RADIUS, thumb_scaled.height() - CORNER_RADIUS, CORNER_RADIUS, CORNER_RADIUS) painter.end() return base_image
def paintEvent(self, event): QtGui.QPushButton.paintEvent(self, event) if self.version: painter = QtGui.QPainter(self) painter.setPen(QtGui.QPen(QtGui.QColor(255, 255, 255, 255))) painter.drawText(self.rect().adjusted(3, 0, 0, 0), QtCore.Qt.AlignLeft | QtCore.Qt.AlignVCenter, str(self.version))
def create_rectangular_thumbnail(thumb): """ Scale a given pixmap down to a given resolution :param thumb: pixmap to scale :returns: scaled thumbnail """ # TODO: this would be great to add to the qtwidgets framework CANVAS_WIDTH = 48 CANVAS_HEIGHT = 38 if thumb.isNull(): # to be safe, if thumb is null, use the empty/default thumbnail thumb = QtGui.QPixmap( ":/tk_framework_qtwidgets.global_search_widget/no_thumbnail.png" ) # get the 512 base image base_image = QtGui.QPixmap(CANVAS_WIDTH, CANVAS_HEIGHT) base_image.fill(QtCore.Qt.transparent) # scale it down to fit inside a frame of maximum 512x400 thumb_scaled = thumb.scaled( CANVAS_WIDTH, CANVAS_HEIGHT, QtCore.Qt.KeepAspectRatioByExpanding, QtCore.Qt.SmoothTransformation, ) # now composite the thumbnail on top of the base image # bottom align it to make it look nice thumb_img = thumb_scaled.toImage() brush = QtGui.QBrush(thumb_img) painter = QtGui.QPainter(base_image) painter.setRenderHint(QtGui.QPainter.Antialiasing) painter.setBrush(brush) # figure out the offset height wise in order to center the thumb height_difference = CANVAS_HEIGHT - thumb_scaled.height() width_difference = CANVAS_WIDTH - thumb_scaled.width() # center it with wise inlay_offset_w = width_difference / 2 # bottom height wise # inlay_offset_h = height_difference+CORNER_RADIUS inlay_offset_h = height_difference / 2 # note how we have to compensate for the corner radius painter.translate(inlay_offset_w, inlay_offset_h) painter.drawRect(0, 0, thumb_scaled.width(), thumb_scaled.height()) painter.end() return base_image
def print_(self): dialog = QtGui.QPrintDialog(self.printer, self) if dialog.exec_(): painter = QtGui.QPainter(self.printer) rect = painter.viewport() size = self.imageLabel.pixmap().size() size.scale(rect.size(), QtCore.Qt.KeepAspectRatio) painter.setViewport(rect.x(), rect.y(), size.width(), size.height()) painter.setWindow(self.imageLabel.pixmap().rect()) painter.drawPixmap(0, 0, self.imageLabel.pixmap())
def resizeImage(self, image, newSize): if image.size() == newSize: return newImage = QtGui.QImage(newSize, QtGui.QImage.Format_RGB32) newImage.fill(QtGui.qRgb(255, 255, 255)) painter = QtGui.QPainter(newImage) painter.drawImage(QtCore.QPoint(0, 0), image) self.image = newImage
def drawLineTo(self, endPoint): painter = QtGui.QPainter(self.image) painter.setPen( QtGui.QPen(self.myPenColor, self.myPenWidth, QtCore.Qt.SolidLine, QtCore.Qt.RoundCap, QtCore.Qt.RoundJoin)) painter.drawLine(self.lastPoint, endPoint) self.modified = True rad = self.myPenWidth / 2 + 2 self.update( QtCore.QRect(self.lastPoint, endPoint).normalized().adjusted( -rad, -rad, +rad, +rad)) self.lastPoint = QtCore.QPoint(endPoint)
def print_(self): printer = QtGui.QPrinter(QtGui.QPrinter.HighResolution) printDialog = QtGui.QPrintDialog(printer, self) if printDialog.exec_() == QtGui.QDialog.Accepted: painter = QtGui.QPainter(printer) rect = painter.viewport() size = self.image.size() size.scale(rect.size(), QtCore.Qt.KeepAspectRatio) painter.setViewport(rect.x(), rect.y(), size.width(), size.height()) painter.setWindow(self.image.rect()) painter.drawImage(0, 0, self.image) painter.end()
def create_rectangular_512x400_thumbnail(image): """ Given a QImage shotgun thumbnail, create a rectangular icon with the thumbnail composited onto a centered otherwise empty canvas. This will return a 512x400 pixmap object. :param image: QImage source image :returns: QPixmap rectangular thumbnail on a 512x400 rect backdrop """ CANVAS_WIDTH = 512 CANVAS_HEIGHT = 400 CORNER_RADIUS = 10 # get the 512 base image base_image = QtGui.QPixmap(CANVAS_WIDTH, CANVAS_HEIGHT) base_image.fill(QtCore.Qt.transparent) # now attempt to load the image # pixmap will be a null pixmap if load fails thumb = QtGui.QPixmap.fromImage(image) if not thumb.isNull(): # scale it down to fit inside a frame of maximum 512x512 thumb_scaled = thumb.scaled( CANVAS_WIDTH, CANVAS_HEIGHT, QtCore.Qt.KeepAspectRatioByExpanding, QtCore.Qt.SmoothTransformation, ) # now composite the thumbnail on top of the base image # bottom align it to make it look nice thumb_img = thumb_scaled.toImage() brush = QtGui.QBrush(thumb_img) painter = QtGui.QPainter(base_image) painter.setRenderHint(QtGui.QPainter.Antialiasing) painter.setBrush(brush) painter.setPen(QtGui.QPen()) painter.drawRoundedRect( 0, 0, CANVAS_WIDTH, CANVAS_HEIGHT, CORNER_RADIUS, CORNER_RADIUS ) painter.end() return base_image
def paint_line_numbers(self, event): """Paint the line numbers for the input widget. :param event: paint event object. """ if not self._show_line_numbers: return # paint on the line number area painter = QtGui.QPainter(self._line_number_area) line_num_rect = event.rect() # fill it with the line number base color painter.fillRect(line_num_rect, self._line_number_area_base_color()) painter.setPen(self.palette().base().color()) painter.drawLine(line_num_rect.topLeft(), line_num_rect.bottomLeft()) painter.drawLine(line_num_rect.topLeft(), line_num_rect.topRight()) painter.drawLine(line_num_rect.bottomLeft(), line_num_rect.bottomRight()) # ---- process the visible blocks block = self.firstVisibleBlock() block_num = block.blockNumber() top = int( self.blockBoundingGeometry(block).translated( self.contentOffset()).top()) bottom = top + int(self.blockBoundingRect(block).height()) while block.isValid() and top <= line_num_rect.bottom(): if block.isVisible() and bottom >= line_num_rect.top(): num = str(block_num + 1) painter.setPen(self._line_number_color()) painter.drawText(-2, top, self._line_number_area.width(), self.fontMetrics().height(), QtCore.Qt.AlignRight, num) block = block.next() top = bottom bottom = top + int(self.blockBoundingRect(block).height()) block_num += 1
def __create_rounded_rect_thumbnail(image, canvas_width, canvas_height, radius): """ Given a qimage shotgun thumbnail, create a publish icon with the thumbnail composited onto a centered otherwise empty canvas. The thumbnail will be taking up all the space in the image. :param image: QImage to load thumbnail from :param canvas_width: Width of image to generate, in pixels :param canvas_height: Heiht of image to generate, in pixels :param radius: Corner radius of image to generate, in pixels :returns: QPixmap object """ # get the base image base_image = QtGui.QPixmap(canvas_width, canvas_height) base_image.fill(QtCore.Qt.transparent) # now attempt to load the image # pixmap will be a null pixmap if load fails thumb = QtGui.QPixmap.fromImage(image) if not thumb.isNull(): # scale it down to fit inside a frame thumb_scaled = thumb.scaled( canvas_width, canvas_height, QtCore.Qt.KeepAspectRatioByExpanding, QtCore.Qt.SmoothTransformation, ) # now composite the thumbnail on top of the base image # bottom align it to make it look nice thumb_img = thumb_scaled.toImage() brush = QtGui.QBrush(thumb_img) painter = QtGui.QPainter(base_image) painter.setRenderHint(QtGui.QPainter.Antialiasing) painter.setBrush(brush) painter.setPen(QtGui.QPen()) painter.drawRoundedRect(0, 0, canvas_width, canvas_height, radius, radius) painter.end() return base_image
def create_overlayed_user_publish_thumbnail(publish_pixmap, user_pixmap): """ Creates a sqaure 75x75 thumbnail with an optional overlayed pixmap. """ # create a 100x100 base image base_image = QtGui.QPixmap(75, 75) base_image.fill(QtCore.Qt.transparent) painter = QtGui.QPainter(base_image) painter.setRenderHint(QtGui.QPainter.Antialiasing) # scale down the thumb if not publish_pixmap.isNull(): thumb_scaled = publish_pixmap.scaled( 75, 75, QtCore.Qt.KeepAspectRatioByExpanding, QtCore.Qt.SmoothTransformation) # now composite the thumbnail on top of the base image # bottom align it to make it look nice thumb_img = thumb_scaled.toImage() brush = QtGui.QBrush(thumb_img) painter.save() painter.setBrush(brush) painter.setPen(QtGui.QPen(QtCore.Qt.NoPen)) painter.drawRect(0, 0, 75, 75) painter.restore() if user_pixmap and not user_pixmap.isNull(): # overlay the user picture on top of the thumbnail user_scaled = user_pixmap.scaled( 30, 30, QtCore.Qt.KeepAspectRatioByExpanding, QtCore.Qt.SmoothTransformation) user_img = user_scaled.toImage() user_brush = QtGui.QBrush(user_img) painter.save() painter.translate(42, 42) painter.setBrush(user_brush) painter.setPen(QtGui.QPen(QtCore.Qt.NoPen)) painter.drawRect(0, 0, 30, 30) painter.restore() painter.end() return base_image
def __format_thumbnail(self, pixmap_obj): """ Given a screengrab, create a thumbnail object, scaled to 96x75 px and with a subtle rounded frame. :param pixmap_obj: input screenshot :returns: 96x75px pixmap """ CANVAS_WIDTH = 96 CANVAS_HEIGHT = 75 CORNER_RADIUS = 6 # get the 512 base image base_image = QtGui.QPixmap(CANVAS_WIDTH, CANVAS_HEIGHT) base_image.fill(QtCore.Qt.transparent) # scale it down to fit inside a frame of maximum 512x512 thumb_scaled = pixmap_obj.scaled(CANVAS_WIDTH, CANVAS_HEIGHT, QtCore.Qt.KeepAspectRatioByExpanding, QtCore.Qt.SmoothTransformation) # now composite the thumbnail on top of the base image # bottom align it to make it look nice thumb_img = thumb_scaled.toImage() brush = QtGui.QBrush(thumb_img) painter = QtGui.QPainter(base_image) painter.setRenderHint(QtGui.QPainter.Antialiasing) painter.setBrush(brush) pen = QtGui.QPen(QtGui.QColor("#2C93E2")) pen.setWidth(3) painter.setPen(pen) # note how we have to compensate for the corner radius painter.drawRoundedRect(0, 0, CANVAS_WIDTH, CANVAS_HEIGHT, CORNER_RADIUS, CORNER_RADIUS) painter.end() return base_image
def paintEvent(self, paint_event): """ Paints the line plain text editor and adds a placeholder on bottom right corner when multiple values are detected. """ # If the box does not have focus, draw <multiple values> placeholder when self._show_placeholder is true, even if the widget has text if not self.hasFocus() and self._show_placeholder == True: p = QtGui.QPainter(self.viewport()) # right placeholder note in blue col = QtGui.QColor(24,167,227) # blue p.setPen(QtGui.QPen(col)) p.setBrush(QtGui.QBrush(col)) p.drawText(self.rect(),QtCore.Qt.AlignTop | QtCore.Qt.AlignLeft, self._placeholder_text) else: QtGui.QPlainTextEdit.paintEvent(self, paint_event)
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(30, 30, 30, 160) painter.setBrush( QtGui.QBrush(overlay_color)) painter.setPen(QtGui.QPen(overlay_color)) painter.drawRect(0, 0, painter.device().width(), painter.device().height()) finally: painter.end()
def paintEvent(self, event): """ Paint event """ # Convert click and current mouse positions to local space. mouse_pos = self.mapFromGlobal(QtGui.QCursor.pos()) click_pos = None if self._click_pos is not None: click_pos = self.mapFromGlobal(self._click_pos) painter = QtGui.QPainter(self) # Draw background. Aside from aesthetics, this makes the full # tool region accept mouse events. painter.setBrush(QtGui.QColor(0, 0, 0, self._opacity)) painter.setPen(QtCore.Qt.NoPen) painter.drawRect(event.rect()) # Clear the capture area if click_pos is not None: capture_rect = QtCore.QRect(click_pos, mouse_pos) painter.setCompositionMode(QtGui.QPainter.CompositionMode_Clear) painter.drawRect(capture_rect) painter.setCompositionMode(QtGui.QPainter.CompositionMode_SourceOver) pen = QtGui.QPen(QtGui.QColor(255, 255, 255, 64), 1, QtCore.Qt.DotLine) painter.setPen(pen) # Draw cropping markers at click position if click_pos is not None: painter.drawLine( event.rect().left(), click_pos.y(), event.rect().right(), click_pos.y() ) painter.drawLine( click_pos.x(), event.rect().top(), click_pos.x(), event.rect().bottom() ) # Draw cropping markers at current mouse position painter.drawLine( event.rect().left(), mouse_pos.y(), event.rect().right(), mouse_pos.y() ) painter.drawLine( mouse_pos.x(), event.rect().top(), mouse_pos.x(), event.rect().bottom() )
def paintEvent(self, paint_event): """ Paints the line plain text editor and adds a placeholder on bottom right corner when multiple values are detected. """ super(PublishDescriptionEditQt4, self).paintEvent(paint_event) if self.placeholderVisible(): painter = QtGui.QPainter(self.viewport()) colour = self.palette().text().color() colour.setAlpha(128) painter.setPen(colour) painter.setClipRect(self.rect()) margin = self.document().documentMargin() textRect = self.viewport().rect().adjusted(margin, margin, 0, 0) painter.drawText( textRect, QtCore.Qt.AlignTop | QtCore.Qt.TextWordWrap, self.placeholderText(), )
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, paint_event): """ Paints the line plain text editor and adds a placeholder on bottom right corner when multiple values are detected. """ # If the box does not have focus, draw <multiple values> placeholder when self._show_placeholder is true, even if the widget has text if not self.hasFocus() and self._show_multiple_values is True: p = QtGui.QPainter(self.viewport()) # right placeholder note in blue col = QtGui.QColor(self._highlight) # blue p.setPen(QtGui.QPen(col)) p.setBrush(QtGui.QBrush(col)) p.drawText( self.rect(), QtCore.Qt.AlignTop | QtCore.Qt.AlignLeft, self._multiple_values_text, ) else: super(PublishDescriptionEditBase, self).paintEvent(paint_event)
def generate_badge_pixmap(self, badge_color): """ Generate a badge QPixmap from a QColor. This hook method is used to generate a badge image when a badge hook returns a QColor. Thus, by overloading this method, it's possible to customize what the generated badges will look like when get_work_file_badge or get_publish_badge return a QColor. :param QColor badge_color: The color of the badge to generate a pixmap for. :returns: A QPixmap of the badge to be used. """ # We want to multiply the color onto the (white) badge_default dot to # generate a nice looking badge. badge = QtGui.QPixmap(":/tk-multi-workfiles2/badge_default.png") painter = QtGui.QPainter() painter.begin(badge) try: painter.setCompositionMode(QtGui.QPainter.CompositionMode_SourceIn) painter.fillRect(badge.rect(), badge_color) finally: painter.end() return badge
def createOverlayPixmap(self, alpha=45): px = float(self.attachmentPixmap.width()) / 3.0 py = float(self.attachmentPixmap.height()) / 3.0 pf = px if px > py: pf = py overPix = QtGui.QPixmap(self.overImagePath).scaled( pf, pf, QtCore.Qt.KeepAspectRatio) self.resultPix = QtGui.QPixmap(self.attachmentPixmap.width(), self.attachmentPixmap.height()) self.resultPix.fill(QtCore.Qt.transparent) painter = QtGui.QPainter(self.resultPix) painter.drawPixmap(0, 0, self.attachmentPixmap) painter.fillRect(0, 0, self.attachmentPixmap.width(), self.attachmentPixmap.height(), QtGui.QColor(0, 0, 0, alpha)) painter.drawPixmap(px, py, overPix) del painter
def paintEvent(self, event): """ Override the Qt method. Highlight the background color on mouse hover. """ super(ChoicesFilterItemWidget, self).paintEvent(event) option = QtGui.QStyleOption() option.initFrom(self) painter = QtGui.QPainter() painter.begin(self) try: if option.state & QtGui.QStyle.State_MouseOver: painter.setRenderHint(QtGui.QPainter.Antialiasing) hover_color = option.palette.highlight().color() painter.setBrush(QtGui.QBrush(hover_color)) painter.setPen(QtGui.QPen(hover_color)) painter.drawRect( 0, 0, painter.device().width(), painter.device().height() ) finally: painter.end()
def paintEvent(self, event): """ Overriden base method that gets called whenever the view needs repainting. :param event: The QPaintEvent containing information about the event """ if not self.model(): return # make sure item rects are up to date: self._update_item_info() row_count = self.model().rowCount() if row_count != len(self._item_info): # this shouldn't ever happen but just incase it does then # we shouldn't paint anything as we'll probably get exceptions! bundle = sgtk.platform.current_bundle() bundle.log_warning( "Unable to paint the Grouped List View as the internal cache is out of sync!" ) return # build lookups for the group widgets: group_widgets_by_row = {} for widget, row in self._group_widget_rows.items(): if row < row_count: group_widgets_by_row[row] = widget unused_group_widgets = [] for widget in self._group_widgets: if widget not in group_widgets_by_row.values(): unused_group_widgets.append(widget) next_unused_group_widget_idx = 0 self._group_widget_rows = {} group_widgets_to_resize = [] # pull out the viewport size and offsets: update_rect = event.rect() viewport_rect = self.viewport().rect() viewport_offset = (-self.horizontalOffset(), -self.verticalOffset()) # start painting: painter = QtGui.QPainter(self.viewport()) try: painter.setRenderHints(QtGui.QPainter.Antialiasing | QtGui.QPainter.TextAntialiasing) # keep track of the y-offset as we go: y_offset = self._border.height() for row, item_info in enumerate(self._item_info): # get valid model index: index = self.model().index(row, 0, self.rootIndex()) # get the rectangle and translate into the correct relative location: rect = item_info.rect.translated(viewport_offset[0], viewport_offset[1] + y_offset) # test to see if the rectangle exists within the viewport: grp_widget = group_widgets_by_row.get(row) if rect.isValid and rect.intersects(viewport_rect): # the group widget is visible: if not grp_widget: if next_unused_group_widget_idx < len( unused_group_widgets): grp_widget = unused_group_widgets[ next_unused_group_widget_idx] next_unused_group_widget_idx += 1 else: # need to create a new group widget and hook up the signals: if hasattr(self.itemDelegate(), "create_group_widget"): grp_widget = self.itemDelegate( ).create_group_widget(self.viewport()) if grp_widget: self._group_widgets.append(grp_widget) grp_widget.toggle_expanded.connect( self._on_group_expanded_toggled) if grp_widget: if grp_widget.geometry() != rect: # add widget to list to be resized later: group_widgets_to_resize.append((grp_widget, rect)) # set up this widget for this index: grp_widget.set_expanded(not item_info.collapsed) grp_widget.set_item(index) grp_widget.show() self._group_widget_rows[grp_widget] = row elif grp_widget: # group widget is hidden! unused_group_widgets.append(grp_widget) # add the group rectangle height to the y-offset y_offset += rect.height() if not item_info.collapsed: # draw any children: num_child_rows = self.model().rowCount(index) if len(item_info.child_info) == num_child_rows: # draw all children for child_row, (_, _, child_rect) in enumerate( item_info.child_info): # figure out index and update rect: child_index = self.model().index( child_row, 0, index) child_rect = child_rect.translated( viewport_offset[0], viewport_offset[1] + y_offset) if not child_rect.isValid or not child_rect.intersects( update_rect): # no need to draw! continue # set up the rendering options: # option = self.viewOptions()) # (AD) - using self.viewOptions() to get the view style options seems # to return an invalid item in some versions of PySide/PyQt! I think # it's returning a QtGui.QStyleOptionViewItem even though the # underlying C++ object is a QtGui.QStyleOptionViewItemV2 or higher. # # This would result in option.rect being corrupt immediately after it # was set below! # # creating the object directly and then using initFrom seems to work # though. option = QtGui.QStyleOptionViewItem() option.initFrom(self) option.rect = child_rect if self.selectionModel().isSelected(child_index): option.state |= QtGui.QStyle.State_Selected if child_index == self.currentIndex(): option.state |= QtGui.QStyle.State_HasFocus # draw the widget using the item delegate self.itemDelegate().paint(painter, option, child_index) # update the y-offset to include the child area: y_offset += item_info.child_area_rect.height( ) + self._group_spacing else: y_offset += self._item_spacing.height() # hide any group widgets that were not used: for w in unused_group_widgets[next_unused_group_widget_idx:]: if w.isVisible(): w.hide() finally: painter.end() # update geometry for any group widgets that need updating # Note, this has to be done after painting has finished otherwise # the resize event gets blocked! for widget, rect in group_widgets_to_resize: widget.setGeometry(rect) # call the base implementation: QtGui.QAbstractItemView.paintEvent(self, event)