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):
painter = QPainter()
painter.begin(self)
painter.setOpacity(self.pixmap_opacity)
painter.drawPixmap(0, 0, self.old_pixmap)
painter.end()
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)) + "%")
