def paintEvent(self, event): 'Paint semi-transparent background, animated pattern, background text' QWidget.paintEvent(self, event) # make a painter p = QPainter(self) p.setRenderHint(QPainter.TextAntialiasing) p.setRenderHint(QPainter.HighQualityAntialiasing) # fill a rectangle with transparent painting p.fillRect(event.rect(), Qt.transparent) # animated random dots background pattern for i in range(4096): x = randint(9, self.size().width() - 9) y = randint(9, self.size().height() - 9) p.setPen(QPen(QColor(randint(200, 255), randint(200, 255), 255), 1)) p.drawPoint(x, y) # set pen to use white color p.setPen(QPen(QColor(randint(9, 255), randint(9, 255), 255), 1)) # Rotate painter 45 Degree p.rotate(35) # Set painter Font for text p.setFont(QFont('Ubuntu', 300)) # draw the background text, with antialiasing p.drawText(99, 199, "Radio") # Rotate -45 the QPen back ! p.rotate(-35) # set the pen to no pen p.setPen(Qt.NoPen) # Background Color p.setBrush(QColor(0, 0, 0)) # Background Opacity p.setOpacity(0.75) # Background Rounded Borders p.drawRoundedRect(self.rect(), 50, 50) # finalize the painter p.end()
def paintEvent(self, event): QWidget.paintEvent(self, event) painter = QPainter(self) painter.setBrush(QBrush(QColor(Qt.black))) painter.setPen(QPen()) painter.setOpacity(self.value) painter.drawRect(self.rect())
def updateFilledCircle(self, s): size = s * self.zoom pixmap = QPixmap(self.width(), self.height()) pixmap.fill(Qt.transparent) #painter filled ellipse p = QPalette() painter = QPainter() painter.begin(pixmap) painter.setRenderHint(QPainter.Antialiasing) brush = QBrush(p.link().color()) painter.setBrush(brush) painter.setOpacity(0.4) painter.drawEllipse( QRect(self.width() / 2 - size / 2, self.height() / 2 - size / 2, size, size)) painter.end() #painter ellipse 2 painter2 = QPainter() painter2.begin(pixmap) painter2.setRenderHint(QPainter.Antialiasing) pen2 = QPen(Qt.green) pen2.setWidth(1) painter2.setPen(pen2) painter2.drawEllipse( QRect(self.width() / 2 - size / 2, self.height() / 2 - size / 2, size, size)) painter2.end() self.ellipseLabel.setPixmap(QPixmap(pixmap)) self.lastSize = s
def paintEvent(self, event): painter = QPainter() painter.begin(self) painter.setOpacity(self.pixmap_opacity) painter.drawPixmap(0, 0, self.old_pixmap) painter.end()
def paintEvent( self, event ): """ Das automatisch ausgelöste paintEvent, das das Widget bei jeder Fensterveränderung neu zeichnet. """ if self.__maximum > 0: frameWidth = 1 separatorWidth = 1 # Damit der Rahmen nicht irgendwie abgeschnitten wird, muß das Quadrat entsprechend kleiner sein. squareSideLength = 10 framePen = QPen( frameWidth ) framePen.setColor( self.__colorFrame ) squareSideLengthPlus = squareSideLength + 2 * frameWidth painter = QPainter( self ) windowWidth = self.width() / min( self.__maximum, self.__columnMax ) windowHeight = self.__maximum / self.__columnMax windowHeight = math.ceil( windowHeight ) windowHeight = self.height() / windowHeight side = min( windowWidth, windowHeight ) painter.setRenderHint( QPainter.Antialiasing ) # Wenn das Widget disabled ist, muß ich den Alphakanal meiner Farben verändern. if ( not self.isEnabled() ): painter.setOpacity( .5 ) #painter.translate( float( windowWidth ), float( windowHeight ) ) painter.scale( side / squareSideLengthPlus, side / squareSideLengthPlus ) painter.setPen( framePen ) painter.setBrush( self.__colorEmpty ) painter.save() squareColumnIter = 0 squareLineIter = 0 squareCount = 0 for squareCount in range(self.__maximum): square = QRect( ( squareSideLength + separatorWidth ) * squareColumnIter + frameWidth * ( squareColumnIter + 1 ), ( squareSideLength + separatorWidth ) * squareLineIter + frameWidth * ( squareLineIter + 1 ), squareSideLength, squareSideLength ) painter.drawRect( square ) # Wir zeichnen die ausgekreuzten Quadrate if (self.__value > (self.__columnMax * squareLineIter + squareColumnIter)): painter.drawLine(square.bottomLeft(), square.topRight()) painter.drawLine(square.topLeft(), square.bottomRight()) squareColumnIter += 1 if ( squareColumnIter >= self.__columnMax ): squareColumnIter = 0 squareLineIter += 1 painter.restore()
def updateFilledCircle(self, s): size = s * self.zoom pixmap = QPixmap(self.width(), self.height()) pixmap.fill(Qt.transparent) #painter filled ellipse p = QPalette() painter = QPainter() painter.begin(pixmap) painter.setRenderHint(QPainter.Antialiasing) brush = QBrush(p.link().color()) painter.setBrush(brush) painter.setOpacity(0.4) painter.drawEllipse(QRect(self.width()/2 - size/2, self.height()/2 - size/2, size, size)) painter.end() #painter ellipse 2 painter2 = QPainter() painter2.begin(pixmap) painter2.setRenderHint(QPainter.Antialiasing) pen2 = QPen(Qt.green) pen2.setWidth(1) painter2.setPen(pen2) painter2.drawEllipse(QRect(self.width()/2 - size/2, self.height()/2 - size/2, size, size)) painter2.end() self.ellipseLabel.setPixmap(QPixmap(pixmap)) self.lastSize = s
def _blendTile(self, stack_id, tile_nr): """ Blend all of the QImage layers of the patch specified by (stack_id, tile_nr) into a single QImage. """ qimg = None p = None for i, (visible, layerOpacity, layerImageSource) in enumerate(reversed(self._sims)): image_type = layerImageSource.image_type() if issubclass(image_type, QGraphicsItem): with self._cache: patch = self._cache.layer(stack_id, layerImageSource, tile_nr) if patch is not None: assert isinstance(patch, image_type), \ "This ImageSource is producing a type of image that is not consistent with it's declared image_type()" # This is a QGraphicsItem, so we don't blend it into the final tile. # (The ImageScene will just draw it on top of everything.) # But this is a convenient place to update the opacity/visible state. if patch.opacity() != layerOpacity or patch.isVisible( ) != visible: patch.setOpacity(layerOpacity) patch.setVisible(visible) patch.setZValue( i ) # The sims ("stacked image sources") are ordered from # top-to-bottom (see imagepump.py), but in Qt, # higher Z-values are shown on top. # Note that the current loop is iterating in reverse order. continue # No need to fetch non-visible image tiles. if not visible or layerOpacity == 0.0: continue with self._cache: patch = self._cache.layer(stack_id, layerImageSource, tile_nr) # patch might be a QGraphicsItem instead of QImage, # in which case it is handled separately, # not composited into the tile. if patch is not None: assert isinstance(patch, QImage), \ "Unknown tile layer type: {}. Expected QImage or QGraphicsItem".format(type(patch)) if qimg is None: qimg = QImage(self.tiling.imageRects[tile_nr].size(), QImage.Format_ARGB32_Premultiplied) qimg.fill(0xffffffff) # Use a hex constant instead. p = QPainter(qimg) p.setOpacity(layerOpacity) p.drawImage(0, 0, patch) if p is not None: p.end() return qimg
def paintEvent(self, event): QWidget.paintEvent(self, event) if self._timeline.state() == QTimeLine.NotRunning: # nothing to do return p = QPainter(self) p.setRenderHint(QPainter.SmoothPixmapTransform, True) p.drawPixmap(QPoint(0, 0), self._prev_pixmap) p.setOpacity(self._blending_factor) p.drawPixmap(QPoint(0, 0), self._next_pixmap)
def paintEvent(self, event): ' Paint semi-transparent background ' painter = QPainter(self) painter.fillRect(event.rect(), Qt.transparent) painter.setPen(Qt.NoPen) painter.setBrush(QColor(0, 0, 0)) painter.setOpacity(0.75) painter.drawRoundedRect(self.rect(), 75, 50) painter.end()
def _runImpl(self): processed = set() self._dataPending.wait() if self._numLayers == 0: return bbox = QRect() toUpdate = numpy.zeros((len(self._tiling),), dtype=numpy.uint8) while len(self._queue) > 0: self._dataPending.clear() layerNr, patchNr, image, tiling, numLayers = self._queue.popleft() if tiling != self._tiling or numLayers != self._numLayers: continue if (layerNr, patchNr) in processed: continue processed.add((layerNr, patchNr)) rect = self._tiling._imageRect[patchNr] bbox = bbox.united(rect) self._imageLayersNext[layerNr,patchNr] = image toUpdate[patchNr] = 1 firstOpaqueLayer = 1000000000000000000 for i, (visible, layerOpacity, layerImageSource) in enumerate(self._stackedIms): if visible and layerOpacity == 1.0 and layerImageSource.isOpaque(): firstOpaqueLayer = i break for patchNr in toUpdate.nonzero()[0]: self._compositeNext[patchNr] = QImage(self._tiling._imageRect[patchNr].size(), QImage.Format_ARGB32_Premultiplied) self._compositeNext[patchNr].fill(Qt.white) p = QPainter(self._compositeNext[patchNr]) for i, v in enumerate(reversed(self._stackedIms)): visible, layerOpacity, layerImageSource = v if not visible: continue layerNr = len(self._stackedIms) - i - 1 if layerNr > firstOpaqueLayer: continue patch = self._imageLayersNext[layerNr, patchNr] p.setOpacity(layerOpacity) if patch is not None: p.drawImage(0,0, patch) p.end() w = numpy.equal(self._compositeNext, None) self._compositeCurrent = numpy.where(numpy.equal(self._compositeNext, None), self._compositeCurrent, self._compositeNext) self._compositeNext[:] = None self.patchAvailable.emit(bbox)
def _blendTile( self, stack_id, tile_nr): """ Blend all of the QImage layers of the patch specified by (stack_id, tile_nr) into a single QImage. """ qimg = None p = None for i, (visible, layerOpacity, layerImageSource) in enumerate(reversed(self._sims)): image_type = layerImageSource.image_type() if issubclass(image_type, QGraphicsItem): with self._cache: patch = self._cache.layer(stack_id, layerImageSource, tile_nr ) if patch is not None: assert isinstance(patch, image_type), \ "This ImageSource is producing a type of image that is not consistent with it's declared image_type()" # This is a QGraphicsItem, so we don't blend it into the final tile. # (The ImageScene will just draw it on top of everything.) # But this is a convenient place to update the opacity/visible state. if patch.opacity() != layerOpacity or patch.isVisible() != visible: patch.setOpacity(layerOpacity) patch.setVisible(visible) patch.setZValue(i) # The sims ("stacked image sources") are ordered from # top-to-bottom (see imagepump.py), but in Qt, # higher Z-values are shown on top. # Note that the current loop is iterating in reverse order. continue # No need to fetch non-visible image tiles. if not visible or layerOpacity == 0.0: continue with self._cache: patch = self._cache.layer(stack_id, layerImageSource, tile_nr ) # patch might be a QGraphicsItem instead of QImage, # in which case it is handled separately, # not composited into the tile. if patch is not None: assert isinstance(patch, QImage), \ "Unknown tile layer type: {}. Expected QImage or QGraphicsItem".format(type(patch)) if qimg is None: qimg = QImage(self.tiling.imageRects[tile_nr].size(), QImage.Format_ARGB32_Premultiplied) qimg.fill(0xffffffff) # Use a hex constant instead. p = QPainter(qimg) p.setOpacity(layerOpacity) p.drawImage(0,0, patch) if p is not None: p.end() return qimg
def _dialog_paintEvent(self, d, event): QDialog.paintEvent(d, event) pen = QPen() pen.setWidth(2) pen.setColor(QColor(200, 200, 200)) rect = d.rect() rect = rect.adjusted(0, 0, -1, -1) painter = QPainter(d) painter.setRenderHint(QPainter.Antialiasing, True) painter.setPen(pen) painter.setOpacity(0.8) painter.setBrush(QBrush(QColor(Qt.white))) painter.drawRoundedRect(rect, 15, 15)
def paintEvent(self, event): """ Paint the interpolated pixmap image. """ p = QPainter(self) p.setClipRect(event.rect()) factor = self.blendingFactor_ ** 2 if self.pixmap1 and 1. - factor: p.setOpacity(1. - factor) p.drawPixmap(QPoint(0, 0), self.pixmap1) if self.pixmap2 and factor: p.setOpacity(factor) p.drawPixmap(QPoint(0, 0), self.pixmap2)
def paintEvent(self, event): QWidget.paintEvent(self, event) painter = QPainter(self) painter.setRenderHint(QPainter.Antialiasing) cor = self._servico.getStatus().corStatus() if self._servico.estaConectado() else Status(Status.OFFLINE).corStatus() painter.setOpacity(0.7) painter.setBrush(cor) painter.drawEllipse(self.rect().adjusted(7,5,-7,-5)) painter.drawPixmap(self.rect(), QPixmap('images/conexao.png')) painter.end()
def updatePixmap(self, alpha): """ Update the pixmap for the current transition. This method first clears the output pixmap. It then draws the starting pixmap followed by the ending pixmap. Each pixmap is drawn with complementary alpha values. """ out = self.outPixmap() painter = QPainter(out) painter.eraseRect(0, 0, out.width(), out.height()) painter.setOpacity(1.0 - alpha) painter.drawPixmap(QPoint(0, 0), self.startPixmap()) painter.setOpacity(alpha) painter.drawPixmap(QPoint(0, 0), self.endPixmap())
def _renderTile( self, stack_id, tile_nr ): qimg = QImage(self.tiling.imageRects[tile_nr].size(), QImage.Format_ARGB32_Premultiplied) qimg.fill(Qt.white) p = QPainter(qimg) for i, v in enumerate(reversed(self._sims)): visible, layerOpacity, layerImageSource = v if not visible: continue patch = self._cache.layer(stack_id, layerImageSource, tile_nr ) if patch is not None: p.setOpacity(layerOpacity) p.drawImage(0,0, patch) p.end() return qimg
def setMaximizeIcon(self, opacity=0.6): self.buttonStyle = "max" self.setToolTip("Maximize") pixmap = QPixmap(250, 250) pixmap.fill(self.backgroundColor) painter = QPainter() painter.begin(pixmap) painter.setRenderHint(QPainter.Antialiasing) painter.setOpacity(opacity) pen = QPen(self.foregroundColor) pen.setWidth(30) painter.setPen(pen) painter.drawRect(50.0, 50.0, 150.0, 150.0) painter.end() pixmap = pixmap.scaled(QSize(self.pixmapWidth, self.pixmapHeight),Qt.KeepAspectRatio, Qt.SmoothTransformation) self.setPixmap(pixmap)
def doubleCacheImage(self, idx, force=None): self.cacheImage(idx, force) # now we want to add another image to the same layer self.cacheImage(idx+1, force) painter = QPainter() painter.begin(self.pdfImages[idx]) painter.setOpacity(0.5) image2 = self.getImage(idx+1).copy() mask = image2.createMaskFromColor(image2.pixel(0, 0), 1) image2.setAlphaChannel(mask) painter.drawImage(0, 0, image2, sw = self.pdfImages[idx].width()/2, sh = self.pdfImages[idx].height()/2) painter.end()
def add_item(self, thumbnail_image, date, info, day_index=-1, archive_path=None): """ @param thumbnail_image: Image to be used in thumbnail @param date: Date of image @param info: Copyright info for image @param day_index: Day index of image @param archive_path: Path to the local file, or None if image source is the RSS feed. @type thumbnail_image: QImage @type date: QDate @type info: str @type day_index: int @type archive_path: unicode or None """ if date.year() == QDate.currentDate().year(): date_label = str(date.toString('dddd dd MMMM')) else: date_label = str(date.toString('dddd dd MMMM, yyyy')) if date_label in self.added_dates: # This date has already been added. Don't bother adding it again. print 'Ignored', date_label return if archive_path: pixmap = QPixmap.fromImage(thumbnail_image) painter = QPainter(pixmap) painter.setRenderHint(QPainter.Antialiasing) circle_area = QRect(pixmap.width() - 35, pixmap.height() - 35, 25, 25) painter.setOpacity(0.7) painter.setPen(Qt.lightGray) painter.setBrush(Qt.lightGray) painter.drawEllipse(circle_area) painter.drawPixmap(circle_area.topLeft(), self.pixmap_hd) painter.end() else: pixmap = QPixmap.fromImage( thumbnail_image.scaled(QSize(200, 125), Qt.IgnoreAspectRatio, Qt.SmoothTransformation)) icon = QIcon(pixmap) widget_item = ListWidgetItem(icon, date_label, self) widget_item.setToolTip(info) widget_item.image_day_index = day_index widget_item.archive_path = archive_path widget_item.image_date = date self.added_dates.add(date_label)
def basefinished(self): if self.basereply.error() != QNetworkReply.NoError: return self.basepixmap = QPixmap() self.basepixmap.loadFromData(self.basereply.readAll()) if self.basepixmap.size() != self.rect.size(): self.basepixmap = self.basepixmap.scaled(self.rect.size(), Qt.KeepAspectRatio, Qt.SmoothTransformation) if Config.satellite: p = QPixmap(self.basepixmap.size()) p.fill(Qt.transparent) painter = QPainter() painter.begin(p) painter.setOpacity(0.6) painter.drawPixmap(0,0,self.basepixmap) painter.end() self.basepixmap = p self.wwx.setPixmap(self.basepixmap) else: self.setPixmap(self.basepixmap)
def paintEvent(self, event): QWidget.paintEvent(self, event) pen = QPen() pen.setWidth(2) pen.setColor(QColor(200, 200, 200)) rect = self.rect() rect = rect.adjusted(0, 0, -1, -1) painter = QPainter(self) painter.setRenderHint(QPainter.Antialiasing, True) painter.setPen(pen) painter.setOpacity(0.5) painter.setBrush(QBrush(QColor(Qt.white))) painter.drawRoundedRect(rect, 15, 15) painter.setOpacity(1) pen.setColor(Qt.black) painter.setPen(pen) text = self.name + "\n" + self.description painter.drawText(self.rect(), Qt.AlignHCenter | Qt.AlignVCenter, text)
def paintEvent(self, event): QFrame.paintEvent(self, event) factorForWidth = self.width() / 40 factorForHeight = self.height() / 30 row = 1 column = 1 painter = QPainter(self) painter.setOpacity(0.9) pen = QPen() pen.setColor(Qt.white) painter.setPen(pen) while factorForWidth * column < self.width(): painter.drawLine(factorForWidth * column, 0, factorForWidth * column, self.height()) column += 1 while factorForHeight * row < self.height(): painter.drawLine(0, factorForHeight * row, self.width(), factorForHeight * row) row += 1
def setUndockIcon(self, opacity=0.6): self.buttonStyle = "undock" self.setToolTip("Undock") pixmap = QPixmap(250, 250) pixmap.fill(self.backgroundColor) painter = QPainter() painter.begin(pixmap) painter.setRenderHint(QPainter.Antialiasing) painter.setOpacity(opacity) pen = QPen(self.foregroundColor) pen.setWidth(30) painter.setPen(pen) painter.drawLine(70.0, 170.0, 190.0, 60.0) painter.drawLine(200.0, 140.0, 200.0, 50.0) painter.drawLine(110.0, 50.0, 200.0, 50.0) painter.end() pixmap = pixmap.scaled(QSize(self.pixmapWidth, self.pixmapHeight),Qt.KeepAspectRatio, Qt.SmoothTransformation) self.setPixmap(pixmap)
def createAxisLabelPixmap(self, opacity=0.6): pixmap = QPixmap(250, 250) pixmap.fill(self.backgroundColor) painter = QPainter() painter.begin(pixmap) painter.setOpacity(opacity) font = QFont() font.setBold(True) font.setPixelSize(250-30) path = QPainterPath() path.addText(QPointF(50, 250-50), font, self.axis) brush = QBrush(self.foregroundColor) painter.setBrush(brush) painter.drawPath(path) painter.setFont(font) painter.end() pixmap = pixmap.scaled(QSize(self.labelsWidth,self.labelsheight),Qt.KeepAspectRatio, Qt.SmoothTransformation) return pixmap
def paintEvent(self, event): painter = QPainter(self) event.accept() if not self.isEnabled(): painter.save() painter.setOpacity(0.2) painter.drawPixmap(self.fPixmapRect, self.fPixmapNormal, self.fPixmapRect) painter.restore() elif self.isChecked() or self.isDown(): painter.drawPixmap(self.fPixmapRect, self.fPixmapDown, self.fPixmapRect) elif self.fIsHovered: painter.drawPixmap(self.fPixmapRect, self.fPixmapHover, self.fPixmapRect) else: painter.drawPixmap(self.fPixmapRect, self.fPixmapNormal, self.fPixmapRect)
def _renderTile( self, stack_id, tile_nr ): qimg = QImage(self.tiling.imageRects[tile_nr].size(), QImage.Format_ARGB32_Premultiplied) #qimg.fill(Qt.white) # Apparently, some difference between Qt 4.7 and 4.8 causes # QImage.fill(Qt.white) to do the wrong thing here. It might be a Qt bug. qimg.fill(0xffffffff) # Use a hex constant instead. p = QPainter(qimg) for i, v in enumerate(reversed(self._sims)): visible, layerOpacity, layerImageSource = v if not visible: continue patch = self._cache.layer(stack_id, layerImageSource, tile_nr ) if patch is not None: p.setOpacity(layerOpacity) p.drawImage(0,0, patch) p.end() return qimg
def updatePixmap(self, alpha): """ Update the pixmap for the current transition. This method first clears the output pixmap. It then draws a pixmap using the given alpha value. An alpha value less than zero indicates that the starting pixmap should be drawn. A value greater than or equal to zero indicates the ending pixmap should be drawn. """ out = self.outPixmap() painter = QPainter(out) painter.eraseRect(0, 0, out.width(), out.height()) if alpha < 0.0: alpha = -1.0 * alpha source = self.startPixmap() else: source = self.endPixmap() painter.setOpacity(alpha) painter.drawPixmap(QPoint(0, 0), source)
def basefinished(self): if self.basereply.error() != QNetworkReply.NoError: return self.basepixmap = QPixmap() self.basepixmap.loadFromData(self.basereply.readAll()) if self.basepixmap.size() != self.rect.size(): self.basepixmap = self.basepixmap.scaled(self.rect.size(), Qt.KeepAspectRatio, Qt.SmoothTransformation) if self.satellite: p = QPixmap(self.basepixmap.size()) p.fill(Qt.transparent) painter = QPainter() painter.begin(p) painter.setOpacity(0.6) painter.drawPixmap(0, 0, self.basepixmap) painter.end() self.basepixmap = p self.wwx.setPixmap(self.basepixmap) else: self.setPixmap(self.basepixmap)
def _renderTile( self, stack_id, tile_nr): qimg = None p = None for i, v in enumerate(reversed(self._sims)): visible, layerOpacity, layerImageSource = v if not visible: continue patch = self._cache.layer(stack_id, layerImageSource, tile_nr ) if patch is not None: if qimg is None: qimg = QImage(self.tiling.imageRects[tile_nr].size(), QImage.Format_ARGB32_Premultiplied) qimg.fill(0xffffffff) # Use a hex constant instead. p = QPainter(qimg) p.setOpacity(layerOpacity) p.drawImage(0,0, patch) if p is not None: p.end() return qimg
def setSpinBoxDownIcon(self, opacity=0.6): self.buttonStyle = "spinDown" self.setToolTip("- 1") pixmap = QPixmap(250, 250) pixmap.fill(self.backgroundColor) painter = QPainter() painter.begin(pixmap) painter.setRenderHint(QPainter.Antialiasing) painter.setOpacity(opacity) brush = QBrush(self.foregroundColor) painter.setBrush(brush) pen = QPen(self.foregroundColor) painter.setPen(pen) points = QPolygonF() points.append(QPointF(125.0, 200.0)) points.append(QPointF(200.0, 70.0)) points.append(QPointF(50.0, 70.0)) painter.drawPolygon(points) painter.end() pixmap = pixmap.scaled(QSize(self.pixmapWidth, self.pixmapHeight),Qt.KeepAspectRatio, Qt.SmoothTransformation) self.setPixmap(pixmap)
def synchronousRequestPatch(self, patchNr): numLayers = len(self._imagePatches[patchNr])-1 temp = [] rect = self._imagePatches[patchNr][0].rect for layerNr, (opacity, visible, imageSource) in enumerate(self._stackedIms): if self._stackedIms[layerNr].visible: request = imageSource.request(rect) temp.append((request, layerNr)) compositePatch = self._imagePatches[patchNr][numLayers] p = QPainter(compositePatch.image) r = compositePatch.rect p.fillRect(0,0,r.width(), r.height(), Qt.white) for req,layerNr in temp: img = req.wait() p.setOpacity(self._stackedIms[layerNr].opacity) p.drawImage(0,0, img) p.end() return compositePatch.image
def _renderTile( self, stack_id, tile_nr): qimg = None p = None for i, v in enumerate(reversed(self._sims)): visible, layerOpacity, layerImageSource = v if not visible: continue with self._cache: patch = self._cache.layer(stack_id, layerImageSource, tile_nr ) if patch is not None: if qimg is None: qimg = QImage(self.tiling.imageRects[tile_nr].size(), QImage.Format_ARGB32_Premultiplied) qimg.fill(0xffffffff) # Use a hex constant instead. p = QPainter(qimg) p.setOpacity(layerOpacity) p.drawImage(0,0, patch) if p is not None: p.end() return qimg
def paintEvent(self,event): painter = QPainter(self) btnRect = self.geometry() color = QColor(Qt.black) if self.hovered: color = self.color if self.pressed: color = self.color.darker(120) painter.setBrush(QBrush(color)) painter_path = QPainterPath() painter_path.addRoundedRect(1, 1, btnRect.width() - 2, btnRect.height() - 2, 0, 0) if self.hovered: painter.setPen(QPen(color,2)) outline = QPainterPath() outline.addRoundedRect(0, 0, btnRect.width(), btnRect.height(), 0, 0) painter.setOpacity(1) painter.drawPath(outline) painter.setClipPath(painter_path) painter.drawRoundedRect(1, 1, btnRect.width() - 2, btnRect.height() - 2, 0, 0) iconWidth = self.iconSize().width()*3/5 iconHeight = self.iconSize().height()*3/5 iconX = (btnRect.width()-iconWidth)/2 iconY = (btnRect.height()-iconHeight)/2 if self.pressed: iconX += 2 iconY += 2 iconPos = QRect() iconPos.setX(iconX) iconPos.setY(iconY) iconPos.setWidth(iconWidth) iconPos.setHeight(iconHeight) painter.drawPixmap(iconPos, QPixmap(self.icon().pixmap(self.iconSize())))
def paintEvent( self, event ): # Wenn das Widget disabled ist, muß ich den Alphakanal meiner Farben verändern. frameWidth = 16 dotCenter = QPoint( 0, 0 ) color = self.__colorEmpty if self.__value: color = self.__colorFull # Damit der Rahmen nicht irgendwie abgeschnitten wird, muß der Kreis entsprechend kleiner sein. dotRadius = 100 framePen = QPen( frameWidth ) framePen.setColor( self.__colorFrame ) dotDiameter = 2 * dotRadius + frameWidth painter = QPainter( self ) windowWidth = self.width() windowHeight = float( self.height() ) side = min( windowWidth, windowHeight ) painter.setRenderHint( QPainter.Antialiasing ) if ( not self.isEnabled() ): painter.setOpacity( .5 ) painter.translate( side / 2, self.height() / 2 ) painter.scale( side / dotDiameter, side / dotDiameter ) painter.setPen( framePen ) painter.setBrush( color ) painter.save() painter.drawEllipse( dotCenter, dotRadius, dotRadius ) painter.restore()
def paintEvent(self, event): """Paint semi-transparent background,animated pattern,background text""" if not A11Y: p = QPainter(self) p.setRenderHint(QPainter.Antialiasing) p.setRenderHint(QPainter.TextAntialiasing) p.setRenderHint(QPainter.HighQualityAntialiasing) p.fillRect(event.rect(), Qt.transparent) # animated random dots background pattern for i in range(4096): x = randint(25, self.size().width() - 25) y = randint(25, self.size().height() - 25) # p.setPen(QPen(QColor(randint(9, 255), 255, 255), 1)) p.drawPoint(x, y) p.setPen(QPen(Qt.white, 1)) p.rotate(40) p.setFont(QFont('Ubuntu', 250)) p.drawText(200, 99, "Nuitka") p.rotate(-40) p.setPen(Qt.NoPen) p.setBrush(QColor(0, 0, 0)) p.setOpacity(0.8) p.drawRoundedRect(self.rect(), 9, 9) p.end()
def paintEvent(self, event): painter = QPainter(self) btnRect = self.geometry() iconRect = self.iconSize() color = QColor(Qt.black) if self.hovered: color = self.color if self.pressed: color = self.color.darker(120) painter.setPen(QPen(QColor(Qt.lightGray), 2)) outline = QPainterPath() outline.addRoundedRect(0, 0, btnRect.width(), btnRect.height(), 0, 0) painter.setOpacity(1) painter.drawPath(outline) painter.setBrush(QBrush(color)) painter.setOpacity(self.opacity) painter_path = QPainterPath() painter_path.addRoundedRect(1, 1, btnRect.width() - 2, btnRect.height() - 2, 0, 0) if self.hovered: painter.setClipPath(painter_path) painter.drawRoundedRect(1, 1, btnRect.width() - 2, btnRect.height() - 2, 0, 0) painter.setOpacity(1) iconPos, textPos = self.calIconTextPos(btnRect, iconRect) # 重画文本 if not self.text().isNull(): painter.setFont(self.font()) painter.setPen(QPen(QColor(Qt.black), 2)) painter.drawText(textPos.x(), textPos.y(), textPos.width(), textPos.height(), Qt.AlignCenter, self.text()) # 重画图标 if not self.icon().isNull(): painter.drawPixmap(iconPos, QPixmap(self.icon().pixmap(self.iconSize())))
def paintEvent(self, event): # Wenn das Widget disabled ist, muß ich den Alphakanal meiner Farben verändern. frameWidth = 16 dotCenter = QPoint(0, 0) shiftCenter = dotCenter # Damit der Rahmen nicht irgendwie abgeschnitten wird, muß der Kreis entsprechend kleiner sein. dotRadius = 100 framePen = QPen() framePen.setWidth(frameWidth) framePen.setColor(self._colorFrame) dotDiameter = 2 * dotRadius + frameWidth painter = QPainter(self) windowWidth = self.width() // self.__maximum windowHeight = float(self.height()) side = min(windowWidth, windowHeight) painter.setRenderHint(QPainter.Antialiasing) if (not self.isEnabled()): painter.setOpacity(.5) painter.translate(side / 2, self.height() / 2) painter.scale(side / dotDiameter, side / dotDiameter) painter.setPen(framePen) painter.setBrush(self._colorFull) painter.save() for i in range(self.__value): shiftCenter = dotCenter + QPoint(0 + dotDiameter * i, 0) painter.drawEllipse(shiftCenter, dotRadius, dotRadius) ## if (v_forbiddenValues.contains(i+1)){ ## painter.drawEllipse(shiftCenter, dotRadius/2, dotRadius/2); painter.restore() painter.setBrush(self._colorEmpty) painter.save() for i in range(self.__value, self.__maximum): shiftCenter = dotCenter + QPoint(0 + dotDiameter * i, 0) painter.drawEllipse(shiftCenter, dotRadius, dotRadius) j = i + 1 if (j in self.__forbiddenValues): dotRadiusHalf = dotRadius / 2 painter.drawLine(shiftCenter.x() - dotRadiusHalf, shiftCenter.y() - dotRadiusHalf, shiftCenter.x() + dotRadiusHalf, shiftCenter.y() + dotRadiusHalf) painter.drawLine(shiftCenter.x() - dotRadiusHalf, shiftCenter.y() + dotRadiusHalf, shiftCenter.x() + dotRadiusHalf, shiftCenter.y() - dotRadiusHalf) ## for (int i = 0; i < v_forbiddenValues.count(); ++i) { ## shiftCenter = dotCenter + QPoint( 0 + dotDiameter * (v_forbiddenValues.at(i) - 1), 0 ); ## ## painter.drawLine(shiftCenter.x()-dotDiameter/2, shiftCenter.y()-dotDiameter/2, shiftCenter.x()+dotDiameter/2, shiftCenter.y()+dotDiameter/2); ## ## painter.drawLine(shiftCenter.x()+dotDiameter/2, shiftCenter.y()-dotDiameter/2, shiftCenter.x()-dotDiameter/2, shiftCenter.y()+dotDiameter/2); ## painter.drawEllipse(shiftCenter, dotRadius/2, dotRadius/2); ## } painter.restore()
def paintEvent(self, event): QWidget.paintEvent(self, event) width, height = self.width(), self.height() polygon = QPolygon() for i, rate in enumerate(self.loads): x = width - i * self.pointDistance y = height - rate * height if x < self.boxWidth: break polygon.append(QPoint(x, y)) painter = QPainter(self) pen = QPen() pen.setColor(Qt.darkGreen) painter.setPen(pen) painter.setRenderHint(QPainter.Antialiasing, True) #画网格 painter.setOpacity(0.5) gridSize = self.pointDistance * 4 deltaX = (width - self.boxWidth) % gridSize + self.boxWidth deltaY = height % gridSize for i in range(int(width / gridSize)): x = deltaX + gridSize * i painter.drawLine(x, 0, x, height) for j in range(int(height / gridSize)): y = j * gridSize + deltaY painter.drawLine(self.boxWidth, y, width, y) #画折线 pen.setColor(Qt.darkCyan) pen.setWidth(2) painter.setPen(pen) painter.setOpacity(1) painter.drawPolyline(polygon) #画展示框 if len(self.loads) > 0: rate = self.loads[0] else: rate = 1.0 rect1 = QRect(4, height * 0.05, self.boxWidth - 9, height * 0.7) rect2 = QRect(4, height * 0.8, self.boxWidth - 9, height * 0.2) centerX = int(rect1.width() / 2) + 1 pen.setWidth(1) for i in range(rect1.height()): if i % 4 == 0: continue if (rect1.height() - i) / rect1.height() > rate: pen.setColor(Qt.darkGreen) else: pen.setColor(Qt.green) painter.setPen(pen) for j in range(rect1.width()): if centerX - 1 <= j <= centerX + 1: continue painter.drawPoint(rect1.x() + j, rect1.y() + i) pen.setColor(Qt.black) painter.setPen(pen) painter.drawText(rect2, Qt.AlignHCenter | Qt.AlignVCenter, str(int(rate * 100)) + "%")