def paintEvent(self, paintEvent):
painter = QPainter(self)
painter.setPen(QPen(Qt.white))
painter.drawText(QPointF(14, self.height()-16), str(self.message))
painter.setPen(QPen(QBrush(QColor(58, 93, 208)), 8))
if self.progress > 0.0:
painter.drawLine(0, self.height()-4, self.progress * self.width(), self.height()-4)
def _drawMonthFrame(self):
self.initMonthInfo()
wi = self.month_info
painter = QPainter(self)
pen = painter.pen()
pen.setWidth(Var.line_width)
painter.setPen(pen)
for coord in wi.paint_base_lines:
painter.drawLine(*coord)
# Draw selections
for selection in wi.selections():
painter.fillRect(*selection)
# Draw dates
font = painter.font()
font.setPointSize(wi.cell_height/8)
painter.setFont(font)
for cell_id in range(42):
x, y = wi.getCoordinate(cell_id)
x += wi.cell_width * 74/100
y += wi.cell_height/7
day = wi.getDay(cell_id)
painter.drawText(QPointF(x, y), QString(str(day)))
def draw_centering_guides(image, target_x, target_y, target_w, guide_h):
left_x = target_x - (target_w / 2.0)
right_x = left_x + target_w
top_y = target_y
bottom_y = top_y + guide_h
new_img = image.copy()
if not new_img.format() is QImage.Format_ARGB32_Premultiplied:
new_img = new_img.convertToFormat(QImage.Format_ARGB32_Premultiplied)
painter = QPainter(new_img)
pen = painter.pen()
pen.setColor(QColor(255, 0, 0))
painter.setPen(pen)
painter.drawLine(left_x, top_y, left_x, bottom_y)
painter.drawLine(right_x, top_y, right_x, bottom_y)
painter.end()
return new_img
def paintEvent(self, e):
painter = QPainter(self)
brush = QBrush(painter.brush())
self.bgcolor.setAlpha(20)
painter.setBrush(self.bgcolor)
painter.drawRect(0, 0, self.width(), self.height())
self.bgcolor.setAlpha(15)
painter.setBrush(self.bgcolor)
painter.drawRect(0, 20, self.width(), self.height()-40)
painter.setBrush(brush)
frame = self.clock.last_beat_frame
x = self.x_for_frametime(frame)
while x < self.width():
x = self.x_for_frametime(frame)
painter.drawLine(x, 0, x, 15)
painter.drawLine(x, self.height(), x, self.height() - 15)
#painter.drawText(QPoint(x+5, 13), str(frame))
frame += self.clock.frames_per_beat()
self.items = [i for i in self.items if i.endtime > self.frametime]
for item in self.items:
x = self.x_for_frametime(item.starttime)
w = self.x_for_frametime(item.endtime) - x
color = QColor(item.color)
color.setAlpha(150)
painter.setPen(color)
pen = painter.pen()
pen.setWidth(3)
painter.setPen(pen)
color.setAlpha(100)
painter.setBrush(color)
painter.drawRect(x, 0, w, self.height())
def paintEvent(self, e):
Part.paintEvent(self, e)
painter = QPainter(self)
color = QColor(self._base.dark(150))
color.setAlpha(150)
painter.setPen(color)
painter.pen().setWidth(2)
painter.drawPolyline(*tuple(self._SYNTH_POINTS))
if not self.songpart is None and self.activeLED.isHidden():
color = QColor('black')
color.setAlpha(200)
painter.setPen(color)
rect = QRect(0, 5, self.width() - 5, self.height() - 5)
painter.drawText(rect,
Qt.AlignRight | Qt.AlignTop,
'[%s]' % self.songpart)
painter.setPen(self._base.light(150))
painter.pen().setWidth(self.margin)
y = self.height() - self.margin
synth = self.data
for start, stop in self.paintNotes:
ratio = 1 - ((stop - synth.localclock.time()) / (stop - start))
if ratio > 0 and ratio <= 1:
width = (self.width() - self.margin * 2) * ratio
painter.drawLine(self.margin, y, width, y)
y -= (self.margin + 3)
painter = None
self.drawText()
def drawLineTo( self, newPos ): p = QPainter( self.image ) pen = QPen(QtCore.Qt.black, 4, QtCore.Qt.SolidLine, QtCore.Qt.RoundCap) p.setPen(pen) p.drawLine( self.currentPos, newPos ) self.currentPos = newPos self.update()
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 paintEvent(self, event):
if not self.text().isEmpty():
painter = QPainter()
painter.begin(self)
painter.setRenderHint(QPainter.Antialiasing)
color = self.palette().color(QPalette.Highlight)
color.setAlpha(127)
painter.setBrush(QBrush(color))
color = self.palette().color(QPalette.HighlightedText)
color.setAlpha(127)
painter.setPen(QPen(color))
size = self.height() / 2.0
left = self.width() - 4
painter.drawRect(left - size, size * 0.5, size, size)
painter.drawLine(left - size * 0.75, size * 0.75,
left - size * 0.25, size * 1.25)
painter.drawLine(left - size * 0.25, size * 0.75,
left - size * 0.75, size * 1.25)
painter.end()
QLabel.paintEvent(self, event)
def draw_image(name, q): image = QSvgGenerator() image.setSize(QSize(IMAGE_SIZE, IMAGE_SIZE)) image.setFileName(name + ".svg") painter = QPainter() painter.begin(image) painter.setBrush(Qt.white) painter.setPen(Qt.NoPen) painter.drawEllipse(QPointF(IMAGE_SIZE/2, IMAGE_SIZE/2), IMAGE_SIZE/2, IMAGE_SIZE/2) painter.setBrush(QBrush()) painter.setPen(QPen()) draw_defect(painter, q) draw_circle(painter, q) pen = QPen() pen.setWidth(7) pen.setColor(Qt.red) painter.setPen(pen) painter.drawLine(IMAGE_SIZE/2 - ARROW_SIZE, IMAGE_SIZE/2, IMAGE_SIZE/2 + ARROW_SIZE, IMAGE_SIZE/2) painter.drawLine(IMAGE_SIZE/2 + ARROW_SIZE, IMAGE_SIZE/2, IMAGE_SIZE/2 + ARROW_SIZE - 30, IMAGE_SIZE/2 + 20) painter.drawLine(IMAGE_SIZE/2 + ARROW_SIZE, IMAGE_SIZE/2, IMAGE_SIZE/2 + ARROW_SIZE - 30, IMAGE_SIZE/2 - 20) font = painter.font() font.setPixelSize(40) font.setBold(True) painter.setFont(font) painter.drawText(QPointF(IMAGE_SIZE/2 + ARROW_SIZE - 30, IMAGE_SIZE/2 - 30), "E") painter.end()
def paintEvent(self, event):
painter = QPainter(self)
icon = self.icon_pressed if self.isDown() else self.icon
if icon is not None:
x = (self.width() - icon.width()) / 2
y = (self.height() - icon.height()) / 2
painter.drawPixmap(x, y, icon)
else:
width = self.width()
height = self.height()
padding = width / 5
radius = width - 2*padding
palette = self.palette()
# Mid is darker than Dark. Go figure... -Dan
bg_color = palette.color(QPalette.Mid) if self.isDown() else palette.color(QPalette.Dark)
fg_color = palette.color(QPalette.Window) # or QPalette.Base for white
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setBrush(bg_color)
painter.setPen(bg_color)
painter.drawEllipse(padding, padding, radius, radius)
padding = padding * 2
painter.setPen(fg_color)
painter.drawLine(padding, padding, width-padding, height-padding)
painter.drawLine(padding, height-padding, width-padding, padding)
def draw_line_to(self, end_point):
painter = QPainter(self.image)
painter.setPen(QPen(self.pen_color, self.pen_width, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin))
painter.drawLine(self.last_point/5, end_point/5)
self.update()
self.last_point = QPoint(end_point)
def paintEvent(self, event): """ Reimplements the :meth:`QWidget.paintEvent` method. :param event: Event. :type event: QEvent """ def __setBold(state): """ Sets the current painter font bold state. :return: Definiton success. :rtype: bool """ font = painter.font() font.setBold(state) painter.setFont(font) return True painter = QPainter(self) painter.fillRect(event.rect(), self.__backgroundColor) pen = QPen(QBrush(), self.__separatorWidth) pen.setColor(self.__separatorColor) painter.setPen(pen) topRightCorner = event.rect().topRight() bottomRightCorner = event.rect().bottomRight() painter.drawLine(topRightCorner.x(), topRightCorner.y(), bottomRightCorner.x(), bottomRightCorner.y()) painter.setPen(self.__color) viewportHeight = self.__editor.viewport().height() metrics = QFontMetrics(self.__editor.document().defaultFont()) currentBlock = self.__editor.document().findBlock( self.__editor.textCursor().position()) block = self.__editor.firstVisibleBlock() blockNumber = block.blockNumber() painter.setFont(self.__editor.document().defaultFont()) while block.isValid(): blockNumber += 1 position = self.__editor.blockBoundingGeometry(block).topLeft() + self.__editor.contentOffset() if position.y() > viewportHeight: break if not block.isVisible(): continue block == currentBlock and __setBold(True) or __setBold(False) painter.drawText(self.width() - metrics.width(foundations.strings.toString(blockNumber)) - self.__margin / 3, round(position.y() + metrics.ascent() + metrics.descent() - \ (self.__editor.blockBoundingRect(block).height() * 8.0 / 100)), foundations.strings.toString(blockNumber)) block = block.next() painter.end() QWidget.paintEvent(self, event)
def draw_line_to(self, end_point):
painter = QPainter(self.image)
painter.setPen(QPen(Qt.white if self.scribbling == 1 else Qt.black,
self.pen_width, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin))
painter.drawLine(self.last_point/5, end_point/5)
self.update()
self.last_point = QPoint(end_point)
def paintEvent(self, event):
super(Editor, self).paintEvent(event)
if settings.SHOW_MARGIN_LINE:
painter = QPainter()
painter.begin(self.viewport())
painter.setPen(QColor("#FE9E9A"))
offset = self.contentOffset()
painter.drawLine(self.pos_margin + offset.x(), 0, self.pos_margin + offset.x(), self.viewport().height())
painter.end()
def paintEvent(self, paint_event):
# nastavíme pero na červenou barvu se šířkou 3px
pen = QPen(QColor("red"))
pen.setWidth(3)
painter = QPainter(self)
painter.setPen(pen)
# drawLine(x1, y1, x2, y2)
painter.drawLine(0, 0, 100, 100)
def paintEvent(self, event):
qp = QPainter(self)
if self.pressed:
qp.setBrush(QBrush(Qt.red))
else:
qp.setBrush(Qt.NoBrush)
qp.setPen(Qt.red)
qp.drawLine(110, 10, 110, 210)
qp.drawLine(10, 110, 210, 110)
qp.drawEllipse(self.x-5, self.y-5, 10, 10)
def paintEvent(self, event):
qp = QPainter()
qp.begin(self)
qp.setBrush(self.gradient)
qp.setPen(Qt.transparent)
qp.drawRect(0, 0, self.SIZE_X, self.SIZE_Y)
qp.setBrush(QBrush(Qt.red))
qp.setPen(Qt.red)
qp.drawLine(0, self.reflectivity, self.SIZE_X, self.reflectivity)
qp.end()
def paintEvent(self, event=None):
font = QFont(self.font())
font.setPointSize(font.pointSize() - 1)
fm = QFontMetricsF(font)
fracWidth = fm.width(FractionSlider.WSTRING)
indent = fm.boundingRect("9").width() / 2.0
if not X11:
fracWidth *= 1.5
span = self.width() - (FractionSlider.XMARGIN * 2)
value = self.__numerator / float(self.__denominator)
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.setRenderHint(QPainter.TextAntialiasing)
painter.setPen(self.palette().color(QPalette.Mid))
painter.setBrush(self.palette().brush(
QPalette.AlternateBase))
painter.drawRect(self.rect())
segColor = QColor(Qt.green).dark(120)
segLineColor = segColor.dark()
painter.setPen(segLineColor)
painter.setBrush(segColor)
painter.drawRect(FractionSlider.XMARGIN,
FractionSlider.YMARGIN, span, fm.height())
textColor = self.palette().color(QPalette.Text)
segWidth = span / self.__denominator
segHeight = fm.height() * 2
nRect = fm.boundingRect(FractionSlider.WSTRING)
x = FractionSlider.XMARGIN
yOffset = segHeight + fm.height()
for i in range(self.__denominator + 1):
painter.setPen(segLineColor)
painter.drawLine(x, FractionSlider.YMARGIN, x, segHeight)
painter.setPen(textColor)
y = segHeight
rect = QRectF(nRect)
rect.moveCenter(QPointF(x, y + fm.height() / 2.0))
painter.drawText(rect, Qt.AlignCenter,
QString.number(i))
y = yOffset
rect.moveCenter(QPointF(x, y + fm.height() / 2.0))
painter.drawText(rect, Qt.AlignCenter,
QString.number(self.__denominator))
painter.drawLine(QPointF(rect.left() + indent, y),
QPointF(rect.right() - indent, y))
x += segWidth
span = int(span)
y = FractionSlider.YMARGIN - 0.5
triangle = [QPointF(value * span, y),
QPointF((value * span) +
(2 * FractionSlider.XMARGIN), y),
QPointF((value * span) +
FractionSlider.XMARGIN, fm.height())]
painter.setPen(Qt.yellow)
painter.setBrush(Qt.darkYellow)
painter.drawPolygon(QPolygonF(triangle))
def paintEvent(self, e):
painter = QPainter(self)
painter.setPen(QColor('black'))
painter.setBrush(QColor('black'))
painter.drawRect(0, 0, self.width(), self.height())
painter.setPen(self.line_brush)
painter.setBrush(self.line_brush.dark(150))
painter.drawLine(self.x, 0, self.x, self.height())
painter.drawLine(0, self.y, self.width(), self.y)
def paintEvent(self, e):
QPlainTextEdit.paintEvent(self, e)
if self._margin:
qp = QPainter()
qp.begin(self.viewport())
qp.setPen(self._margin.color)
offset = self.contentOffset()
qp.drawLine(self.position_margin + offset.x(), 0,
self.position_margin + offset.x(),
self.viewport().height())
qp.end()
def paintEvent(self, e):
qp = QPainter()
qp.begin(self)
qp.setPen(self.black_pen)
qp.drawLine(10, 10, 10, self.vu_height - self.vu_len)
qp.setPen(self.green_pen)
qp.drawLine(10, self.vu_height - self.vu_len, 10, self.vu_height)
qp.end()
def paintEvent(self, event):
super(Editor, self).paintEvent(event)
if settings.SHOW_MARGIN_LINE:
painter = QPainter()
painter.begin(self.viewport())
painter.setPen(QColor('#FE9E9A'))
posX = QFontMetricsF(self.document().defaultFont()).width(' ') \
* settings.MARGIN_LINE
offset = self.contentOffset()
painter.drawLine(posX + offset.x(), 0, \
posX + offset.x(), self.viewport().height())
painter.end()
def paintEvent(self, event):
painter = QPainter(self.viewport())
if self.highlight_line:
r = self.cursorRect()
r.setX(0)
r.setWidth(self.viewport().width())
painter.fillRect(r, self.highlight_brush)
if self.draw_line:
painter.setPen(self.line_pen)
painter.drawLine(self.line)
painter.end()
QPlainTextEdit.paintEvent(self, event)
def paintEvent(self, event):
qp = QPainter(self)
g = QLinearGradient(0.0, 0.0, 0.0, self.height())
g.setColorAt(0, Qt.white)
g.setColorAt(1, Qt.black)
y = self.height() - self.reflectivity * self.height() / 4095.0
qp.fillRect(0, 0, self.width(), self.height(), g)
qp.setPen(Qt.red)
qp.drawLine(0, y, self.width(), y)
def _paint_title(self, p: QPainter):
p.drawLine(Block.padding, 35 + Block.padding, self.width() - Block.padding, 35 + Block.padding)
p.setPen(self._fg_color)
f = p.font()
f.setPointSize(10)
f.setBold(True)
p.setFont(f)
p.drawText(QRectF(4 + Block.padding, Block.padding + 2, self.width() - 12, 25),
str(self.settings["Name"].value()))
f.setBold(False)
f.setPointSize(8)
p.setPen(QColor(self._fg_color.red(), self._fg_color.green(), self._fg_color.blue(), 100))
p.setFont(f)
p.drawText(QRectF(4 + Block.padding, 18 + Block.padding, self.width() - 12, 15), str(self.__type_name))
def paintEvent(self,event): QPlainTextEdit.paintEvent(self,event) for aaa in self.foldedLines: tmp=True for bbb in self.foldedLines: if bbb != aaa and bbb < aaa and self.foldedLines[bbb]>self.foldedLines[aaa]: tmp=False if tmp: bottom = int(self.blockBoundingGeometry(self.document().findBlockByNumber(aaa+1)).top()+self.blockBoundingGeometry(self.document().findBlockByNumber(self.foldedLines[aaa]).next()).height()) paint = QPainter() paint.begin(self.viewport()) paint.setPen(QPen(Qt.black, 1, Qt.DashLine)) paint.drawLine(0,bottom,self.width(),bottom) paint.end()
def on_menuSelections_paint(self, event):
QMenu.paintEvent(self.menuSelections, event)
if self.seldrag_target:
# Paint line where selection will be dropped
p = QPainter()
color = QPalette().color(self.menuSelections.foregroundRole())
pen = QPen(color, 2, Qt.SolidLine)
p.begin(self.menuSelections)
p.setPen(pen)
rect = self.menuSelections.actionGeometry(self.seldrag_target)
if self.seldrag_target_upper:
p.drawLine(rect.topLeft(), rect.topRight())
else:
p.drawLine(rect.bottomLeft(), rect.bottomRight())
p.end()
def drawPixmapForCkecked(self):
self.pixmapCkecked = QPixmap(self.itemWidth, self.itemHeight)
self.pixmapCkecked.fill(Qt.transparent)
painter = QPainter()
painter.begin(self.pixmapCkecked)
painter.setRenderHint(QPainter.Antialiasing)
pen = QPen()
pen.setWidth(2)
painter.setPen(pen)
painter.drawRect(QRect(5,5,self.itemWidth-10, self.itemHeight-10))
pen.setWidth(4)
painter.setPen(pen)
painter.drawLine(self.itemWidth/2-5, self.itemHeight/2, self.itemWidth/2, self.itemHeight-9)
painter.drawLine(self.itemWidth/2, self.itemHeight-9, self.itemWidth/2+10, 2)
painter.end()
def previewPixmap(self, size, vMin, vMax):
pix = QPixmap(size)
pix.fill(Qt.white)
p = QPainter(pix)
if self.item_count() == 0:
p.drawLine(0,0,size.width()-1,size.height()-1)
p.drawLine(0,size.height()-1,size.width()-1,0)
else:
for i in xrange(size.width()):
v = vMin + (vMax-vMin) * i / (size.width()-1)
p.setPen(rgb2qcolor(self.value(v)))
p.drawLine(i,0,i,size.height()-1)
p.end()
return pix
def paintEvent(self, event):
font = QFont(self.font())
font.setPointSize(font.pointSize() - 1)
fm = QFontMetricsF(font)
fractWidth = fm.width(FractionSlider.WSTRING)
indent = fm.boundingRect("9").width() / 2.0
if not X11:
fractWidth *= 1.5
span = self.width() - (FractionSlider.XMARGIN * 2)
value = self.__numerator / float(self.__denominator)
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.setRenderHint(QPainter.TextAntialiasing)
painter.setPen(self.palette().color(QPalette.Mid))
painter.setBrush(self.palette().brush(QPalette.AlternateBase))
painter.drawRect(self.rect())
segColor = QColor(Qt.green).dark(120)
segLineColor = segColor.dark()
painter.setPen(segLineColor)
painter.setBrush(segColor)
painter.drawRect(FractionSlider.XMARGIN, FractionSlider.YMARGIN, span,
fm.height())
textColor = self.palette().color(QPalette.Text)
segWidth = span / self.__denominator
segHeight = fm.height() * 2
nRect = fm.boundingRect(FractionSlider.WSTRING)
x = FractionSlider.XMARGIN
yOffset = segHeight + fm.height()
for i in range(self.__denominator + 1):
painter.setPen(segLineColor)
painter.drawLine(x, FractionSlider.YMARGIN, x, segHeight)
painter.setPen(textColor)
y = segHeight
rect = QRectF(nRect)
rect.moveCenter(QPointF(x, y + fm.height() / 2.0))
painter.drawText(rect, Qt.AlignCenter, QString.number(i))
y = yOffset
rect.moveCenter(QPointF(x, y + fm.height() / 2.0))
painter.drawText(rect, Qt.AlignCenter,
QString.number(self.__denominator))
painter.drawLine(QPointF(rect.left() + indent, y),
QPointF(rect.right() - indent, y))
x += segWidth
span = int(span)
y = FractionSlider.YMARGIN - 0.5
triangle = [
QPointF(value * span, y),
QPointF((value * span) + (2 * FractionSlider.XMARGIN), y),
QPointF((value * span) + FractionSlider.XMARGIN, fm.height())
]
painter.setPen(Qt.yellow)
painter.setBrush(Qt.darkYellow)
painter.drawPolygon(QPolygonF(triangle))
def paintEvent(self, event):
if self.schedule:
paint = QPainter()
paint.begin(self)
paint.setPen(self.colors["axis"])
paint.setFont(QtGui.QFont('Decorative', 9 * self.scale))
procX = {}
# Draw processor names and axis
for i in range(self.proc):
paint.drawImage(
QRect(15 * self.scale, (10 + i * 20) * self.scale,
24 * self.scale, 24 * self.scale), self.procicon)
paint.drawText(40 * self.scale, (25 + i * 20) * self.scale,
str(self.schedule.processors[i].reserves))
plus = QRect(5 * self.scale, (10 + i * 20) * self.scale,
10 * self.scale, 10 * self.scale)
paint.drawImage(plus, self.addicon)
meenoos = QRect(5 * self.scale, (20 + i * 20) * self.scale,
10 * self.scale, 10 * self.scale)
paint.drawImage(meenoos, self.delicon)
self.procrects[self.schedule.processors[i]] = [plus, meenoos]
paint.drawLine(50 * self.scale, (20 + i * 20) * self.scale,
(50 + self.time * 10) * self.scale,
(20 + i * 20) * self.scale)
procX[self.schedule.processors[i].number] = 20 + i * 20
# Draw timeline
tdir = self.method.system.tdir
paint.drawLine(50 * self.scale,
self.height() - 15, (50 + tdir * 10) * self.scale,
self.height() - 15)
paint.drawLine(50 * self.scale, 10 * self.scale, 50 * self.scale,
self.height() - 10)
t = 0
paint.setFont(QtGui.QFont('Decorative', 8))
while t < tdir + 10:
paint.drawLine((50 + t * 10) * self.scale,
self.height() - 20, (50 + t * 10) * self.scale,
self.height() - 10)
paint.drawText((50 + t * 10 + 1) * self.scale,
self.height() - 5, str(t))
t += 10
paint.setPen(self.colors["select"])
paint.drawLine((50 + tdir * 10) * self.scale, 10 * self.scale,
(50 + tdir * 10) * self.scale,
self.height() - 10)
if self.selectedTask:
t = self.selectedTask
start = self.method.interpreter.executionTimes[t][0]
finish = self.method.interpreter.executionTimes[t][1]
paint.drawText((50 + start * 10) * self.scale,
self.height() - 16, str(start))
paint.drawText((50 + finish * 10) * self.scale,
self.height() - 16, str(finish))
# Draw tasks
paint.setPen(self.colors["task"])
paint.setFont(QtGui.QFont('Decorative', 9 * self.scale))
self.vertices = {}
self.positions = {}
for m in self.schedule.vertices.keys():
i = 0
prev = None
for t in self.schedule.vertices[m]:
start = self.method.interpreter.executionTimes[t][0]
finish = self.method.interpreter.executionTimes[t][1]
task = QtCore.QRect((50 + start * 10) * self.scale,
(procX[t.m.number] - 5) * self.scale,
(finish - start) * 10 * self.scale,
10 * self.scale)
# TODO: calculate once!
self.vertices[t] = task
if i == 0:
self.positions[(m, i)] = QtCore.QRect(
QPoint(50 * self.scale, task.y()),
task.bottomLeft())
else:
self.positions[(m, i)] = QtCore.QRect(
prev.topRight(), task.bottomLeft())
if t != self.selectedTask:
paint.fillRect(task, self.colors["task"])
else:
paint.fillRect(task, self.colors["select"])
if self.schedule.CanAddVersions(t):
self.addrect = QRect(task.topLeft().x(),
task.topLeft().y(),
10 * self.scale,
10 * self.scale)
paint.drawImage(self.addrect, self.addicon)
if self.schedule.CanDeleteVersions(t):
self.delrect = QRect(
task.topRight().x() - 10 * self.scale,
task.topRight().y(), 10 * self.scale,
10 * self.scale)
paint.drawImage(self.delrect, self.delicon)
paint.setPen(self.colors["axis"])
paint.drawRect(task)
paint.setPen(self.colors["task"])
prev = task
i += 1
self.positions[(m, i)] = QtCore.QRect(
prev.topRight(),
QPoint(prev.topRight().x() + 100,
prev.bottomRight().y()))
if self.targetPos:
width = min(self.selectedTask.v.time * 10 * self.scale,
self.positions[self.targetPos].width())
rect = QtCore.QRect(self.positions[self.targetPos])
rect.setWidth(width)
paint.fillRect(rect, self.colors["select"])
# Draw deliveries
paint.setPen(QPen(self.colors["delivery"], 2))
for d in self.method.interpreter.deliveryTimes:
self.drawArrow(paint, (50 + d[2] * 10) * self.scale,
procX[d[0].number] * self.scale,
(50 + d[3] * 10) * self.scale,
procX[d[1].number] * self.scale)
# Draw captions
paint.setPen(self.colors["axis"])
for m in self.schedule.vertices.keys():
for t in self.schedule.vertices[m]:
start = self.method.interpreter.executionTimes[t][0]
finish = self.method.interpreter.executionTimes[t][1]
s = str(t.v.number)
if t.k.number > 1:
s += " v" + str(t.k.number)
paint.drawText((10 + finish + start - int(len(s) / 2)) *
5 * self.scale,
(procX[t.m.number] + 5) * self.scale, s)
paint.end()
def paintEvent(self, event):
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
width = self.width()
height = self.height()
if self.dynamic_resize:
knob_radius = self.dynamic_knob_radius
else:
knob_radius = self.knob_radius
# ensure that the center point is in the middle of a pixel to ensure
# that exact vertial and horizantal ticks are drawn exactly 1px wide
x = math.floor(width / 2.0) + 0.5
y = math.floor(height / 2.0) + 0.5
if DEBUG:
painter.fillRect(0, 0, width, height, Qt.yellow)
painter.translate(x, y)
if self.knob_style == KnobWidget.STYLE_NEEDLE:
r = min(x, y) - 1
painter.setPen(Qt.white)
painter.setBrush(Qt.white)
painter.drawEllipse(QPoint(0, 0), r, r)
angle = self.value_factor * self.total_angle - (self.total_angle / 2.0)
# draw base knob or needle spike
if self.knob_style == KnobWidget.STYLE_ROUND:
painter.setPen(self.border_color)
if self.pressed:
gradient = QRadialGradient(0, 0, knob_radius)
gradient.setColorAt(0, self.base_color_pressed)
gradient.setColorAt(0.85, self.base_color)
gradient.setColorAt(1, self.base_color)
painter.setBrush(gradient)
else:
painter.setBrush(self.base_color)
painter.drawEllipse(QPoint(0, 0), knob_radius, knob_radius)
elif self.knob_style == KnobWidget.STYLE_NEEDLE:
painter.save()
painter.rotate(angle)
painter.setPen(self.needle_color)
painter.setBrush(self.needle_color)
needle = QPolygonF()
needle.append(QPointF(self.needle_base_radius * 0.6, 0))
needle.append(QPointF(0, -knob_radius))
needle.append(QPointF(-self.needle_base_radius * 0.6, 0))
painter.drawPolygon(needle)
painter.restore()
# draw knob mark or needle base
if self.knob_style == KnobWidget.STYLE_ROUND:
painter.save()
painter.rotate(angle)
painter.setPen(QPen(self.mark_color, 2))
painter.drawLine(0, -knob_radius * 0.4, 0, -knob_radius * 0.8)
painter.restore()
elif self.knob_style == KnobWidget.STYLE_NEEDLE:
painter.setPen(self.border_color)
painter.setBrush(self.base_color)
painter.drawEllipse(QPoint(0, 0), self.needle_base_radius, self.needle_base_radius)
if self.scale_visible:
painter.setPen(Qt.black)
# draw scale arc
if self.scale_arc_visible:
painter.drawArc(-knob_radius - self.knob_to_scale,
-knob_radius - self.knob_to_scale,
knob_radius * 2 + self.knob_to_scale * 2,
knob_radius * 2 + self.knob_to_scale * 2,
(90 + self.total_angle / 2) * 16, -self.total_angle * 16)
# draw scale ticks
def value_to_angle(value):
return (float(value - self.minimum_value) / self.value_range) * self.total_angle - (self.total_angle / 2.0)
value = self.minimum_value
while value <= self.maximum_value:
angle = value_to_angle(value)
painter.save()
painter.rotate(value_to_angle(value))
painter.drawLine(0, -knob_radius - self.knob_to_scale,
0, -knob_radius - self.knob_to_scale - self.tick_size_large)
if self.scale_text_visible:
p = painter.worldTransform().map(QPoint(0, -knob_radius - \
self.knob_to_scale - \
self.tick_size_large - \
self.tick_to_text - \
self.text_radius))
painter.restore()
if self.scale_text_visible:
if DEBUG:
painter.save()
painter.setPen(QColor(255, 0, 0, 50))
painter.setBrush(QColor(255, 0, 0, 50))
painter.drawEllipse(QPoint(p.x() - x, p.y() - y),
self.text_radius, self.text_radius)
painter.restore()
painter.drawText(p.x() - x - 30, p.y() - y - 30, 60, 60,
Qt.TextDontClip | Qt.AlignHCenter | Qt.AlignVCenter,
str(value))
for i in range(1, self.scale_step_divisions):
sub_value = value + (float(self.scale_step_size) * i) / self.scale_step_divisions
if sub_value > self.maximum_value:
break
painter.save()
painter.rotate(value_to_angle(sub_value))
painter.drawLine(0, -knob_radius - self.knob_to_scale,
0, -knob_radius - self.knob_to_scale - self.tick_size_small)
painter.restore()
value += self.scale_step_size
if self.title_text != None:
painter.drawText(-knob_radius, knob_radius - 30,
knob_radius * 2, 60,
Qt.TextDontClip | Qt.AlignHCenter | Qt.AlignVCenter,
self.title_text)
def paintEvent(self, event):
"""Adapted from http://doc.qt.io/qt-5/qtwidgets-widgets-analogclock-example.html"""
HOURHAND = QPolygon([QPoint(7, 8), QPoint(-7, 8), QPoint(0, -55)])
MINUTEHAND = QPolygon([QPoint(7, 8), QPoint(-7, 8), QPoint(0, -87)])
HOURCOLOR = QColor(Qt.black)
MINUTECOLOR = QColor(0x11, 0x11, 0x11, 0xAA)
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.translate(self.width() / 2, self.height() / 2)
SIDE = 200
side = min(self.width(), self.height())
painter.scale(side / SIDE, side / SIDE)
# Background (night/day)
if self._time_to is not None:
time = self._time_to.time()
hour_offset = time.hour() + time.minute() / 60
DAY, NIGHT = QColor(Qt.white), QColor('#5555ff')
if 7 <= hour_offset <= 19:
background = DAY
elif 6 <= hour_offset <= 7:
palette = GradientPaletteGenerator(NIGHT, DAY)
background = palette[(hour_offset - 6) / (7 - 6)]
elif 19 <= hour_offset <= 20:
palette = GradientPaletteGenerator(DAY, NIGHT)
background = palette[(hour_offset - 19) / (20 - 19)]
else:
assert hour_offset < 7 or hour_offset > 20
background = NIGHT
painter.setBrush(QBrush(background))
painter.setPen(HOURCOLOR)
painter.drawEllipse(-SIDE / 2, -SIDE / 2, SIDE, SIDE)
# Minute tickmarks
painter.save()
painter.setPen(MINUTECOLOR)
for j in range(60):
painter.drawLine(94, 0, 97, 0)
painter.rotate(6)
painter.restore()
# Hour tickmarks
painter.save()
painter.setPen(HOURCOLOR)
for _ in range(12):
painter.drawLine(88, 0, 98, 0)
painter.rotate(30)
painter.restore()
# Hour span
if self._time_from is not None:
time_from = self._time_from.time()
time_to = self._time_to.time()
if time_from.secsTo(
time_to) / 3600 > .2: # Don't draw really small intervals
hour_from = (time_from.hour() +
time_from.minute() / 60) % 12 - 3
hour_to = (time_to.hour() + time_to.minute() / 60) % 12 - 3
startAngle = -hour_to * 30 * 16
spanAngle = -hour_from * 30 * 16 - startAngle
color = QColor(0xFF, 0xFF, 0, 0xAA)
painter.save()
painter.setBrush(QBrush(color, Qt.DiagCrossPattern))
painter.setPen(color.darker(180))
painter.drawPie(-SIDE / 2, -SIDE / 2, SIDE, SIDE, startAngle,
spanAngle)
painter.restore()
# Hour and minute hand
if self._time_to is not None:
time = self._time_to.time()
painter.setPen(Qt.NoPen)
painter.save()
painter.setBrush(HOURCOLOR)
painter.rotate(30 * (time.hour() + time.minute() / 60))
painter.drawConvexPolygon(HOURHAND)
painter.restore()
painter.save()
painter.setBrush(MINUTECOLOR)
painter.rotate(6 * (time.minute() + time.second() / 60))
painter.drawConvexPolygon(MINUTEHAND)
painter.restore()
def punchcard(ui, repo, *pats, **opts):
"""Generate a "punch card" graph of commit times.
For drawing the graph, either PyQt4 or matplotlib can be used. The default
is PyQt4, unless the --mpl option is given.
Normally, all commits are registered in local time, so that commits at 10 AM
local time in Europe and the USA show up on the same punch card entry. If
--utc is given, all commit times are converted to UTC before registered.
"""
if pats:
raise util.Abort('no argument allowed')
filename = opts['filename']
if opts['datemin']:
datemin = datetime.strptime(opts['datemin'], '%Y-%m-%d')
else:
datemin = None
if opts['datemax']:
datemax = datetime.strptime(opts['datemax'], '%Y-%m-%d')
else:
datemax = None
users_include = set(opts['user'])
users_exclude = set(opts['notuser'])
user_filter = bool(users_include or users_exclude)
title = opts.get('title')
font = opts.get('font') or 'Arial'
utc = opts.get('utc')
data = [[0] * 24 for i in range(7)]
cl = repo.changelog
n = 0
ui.status('filtering changesets\n')
for i in xrange(len(cl)):
node = cl.read(cl.node(i))
# node[2] is a tuple of the date in UTC and the timezone offset.
# If --utc is given, the offset can be ignored; otherwise
if utc:
date = datetime.utcfromtimestamp(node[2][0])
else:
date = datetime.utcfromtimestamp(node[2][0] - node[2][1])
if (datemin and date < datemin) or (datemax and date > datemax):
continue
if user_filter:
user = node[1]
if users_include and user not in users_include:
continue
if user in users_exclude:
continue
day = (int(date.strftime('%w')) - 1) % 7
data[day][date.hour] += 1
n += 1
if n == 0:
raise util.Abort('no matching changesets found')
else:
ui.status('punched %d changesets\n' % n)
maxvalue = max(max(i) for i in data) or 1
xs, ys, rs, ss = [], [], [], []
for y, d in enumerate(data):
for x, n in enumerate(d):
xs.append(x)
ys.append(y)
rs.append(13. * n / maxvalue)
ss.append(4. * n**2 / maxvalue)
try:
if opts.get('mpl') or opts.get('svg'):
raise ImportError
from PyQt4.QtCore import Qt, QPointF, QRectF
from PyQt4.QtGui import QApplication, QColor, QFont, QImage, QLabel, \
QMainWindow, QPainter, QPixmap
except ImportError:
try:
if opts.get('svg'):
raise ImportError
from matplotlib import pyplot
except ImportError:
if not opts.get('svg'):
ui.status('Writing as SVG since neither PyQt4 nor '
'matplotlib is available\n')
if filename.endswith('.png'):
filename = filename[:-4] + '.svg'
f = open(filename, 'w')
f.write('<?xml version="1.0" standalone="no"?>\n')
f.write('<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" '
'"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">\n')
o = title and 30 or 0 # y coordinate offset
f.write('<svg width="800" height="{0}" version="1.1" '
'xmlns="http://www.w3.org/2000/svg">\n'.format(300 + o))
f.write('<style type="text/css"> circle {{fill: black;}} '
'text {{font-family:{0};font-size:12;}} '
'.label{{font-size:12px;}}</style>\n'.format(font))
f.write('<rect x="0" y="0" width="800" height="{0}" '
'style="fill:#efefef;"/>\n'.format(300 + o))
f.write('<line x1="35.5" y1="{0}" x2="{1}" y2="{0}" '
'style="stroke:black;stroke-width:2"/>\n'.format(
264.5 + o, 45.5 + 24 * 31))
f.write('<line x1="35.5" y1="{0}" x2="35.5" y2="{1}" '
'style="stroke:black;stroke-width:2"/>\n'.format(
14.5 + o, 264.5 + o))
for i, text in enumerate(days):
f.write(
'<text class="label" x="7.5" y="{0}">{1}</text>\n'.format(
34.5 + i * 34 + o, text))
for i in range(24):
f.write('<text class="label" x="{0}" y="{1}">{2:02}</text>\n'.
format(53.5 + i * 31, 280.5 + o, i))
for x, y, r in zip(xs, ys, rs):
f.write('<circle cx="{0}" cy="{1}" r="{2}" fill="black"/>\n'.
format(58.5 + x * 31, 30.5 + y * 34 + o, r))
if title:
f.write('<text x="400" y="20" style="text-anchor:middle;">'
'{0}</text>\n'.format(title))
f.write('</svg>')
f.close()
ui.status('created punch card in %s\n' % filename)
else:
pyplot.rc('font', family=font)
# create a figure an axes with the same background color
fig = pyplot.figure(figsize=(8, title and 3 or 2.5),
facecolor='#efefef')
ax = fig.add_subplot('111', axisbg='#efefef')
# make the figure margins smaller
if title:
fig.subplots_adjust(left=0.06,
bottom=0.04,
right=0.98,
top=0.95)
ax.set_title(title, y=0.96).set_color('#333333')
else:
fig.subplots_adjust(left=0.06,
bottom=0.08,
right=0.98,
top=0.99)
# don't display the axes frame
ax.set_frame_on(False)
# plot the punch card data
ax.scatter(xs, ys[::-1], s=ss, c='#333333', edgecolor='#333333')
# hide the tick lines
for line in ax.get_xticklines() + ax.get_yticklines():
line.set_alpha(0.0)
# draw x and y lines (instead of axes frame)
dist = -0.8
ax.plot([dist, 23.5], [dist, dist], c='#555555')
ax.plot([dist, dist], [dist, 6.4], c='#555555')
# select new axis limits
ax.set_xlim(-1, 24)
ax.set_ylim(-0.9, 6.9)
# set tick labels and draw them smaller than normal
ax.set_yticks(range(7))
for tx in ax.set_yticklabels(days[::-1]):
tx.set_color('#555555')
tx.set_size('x-small')
ax.set_xticks(range(24))
for tx in ax.set_xticklabels(['%02d' % x for x in range(24)]):
tx.set_color('#555555')
tx.set_size('x-small')
# get equal spacing for days and hours
ax.set_aspect('equal')
fig.savefig(filename)
ui.status('created punch card in %s\n' % filename)
if opts.get('display'):
pyplot.show()
else:
app = QApplication([])
o = title and 30 or 0 # y coordinate offset
image = QImage(800, 300 + o, QImage.Format_RGB32)
painter = QPainter(image)
painter.setRenderHints(QPainter.Antialiasing)
painter.fillRect(0, 0, 800, 300 + o, QColor('#efefef'))
painter.setPen(QColor('#555555'))
painter.drawLine(QPointF(35.5, 264.5 + o),
QPointF(45.5 + 24 * 31, 264.5 + o))
painter.drawLine(QPointF(35.5, 14.5 + o), QPointF(35.5, 264.5 + o))
painter.setFont(QFont(font, 8))
for i, text in enumerate(days):
painter.drawText(QPointF(7.5, 34.5 + i * 34 + o), text)
for i in range(24):
text = '%02d' % i
painter.drawText(QPointF(53.5 + i * 31, 280.5 + o), text)
painter.setBrush(QColor('#333333'))
painter.setPen(QColor('#333333'))
for x, y, r in zip(xs, ys, rs):
painter.drawEllipse(QPointF(58.5 + x * 31, 30.5 + y * 34 + o), r,
r)
if title:
painter.setFont(QFont(font, 12))
painter.drawText(QRectF(0, 15, 800, 20), Qt.AlignCenter, title)
painter.end()
image.save(filename)
ui.status('created punch card in %s\n' % filename)
if opts.get('display'):
win = QMainWindow()
win.setWindowTitle('punchcard display')
win.resize(800, 300 + o)
lbl = QLabel(win)
lbl.resize(800, 300 + o)
lbl.setPixmap(QPixmap.fromImage(image))
win.show()
app.exec_()
def paintEvent(self, event):
painter = QPainter(self)
width = self.width()
height = self.height()
if self.scales_visible:
curve_width = width - self.y_scale.total_width - self.curve_to_scale - self.curve_outer_border
curve_height = height - self.y_scale_height_offset - self.x_scale.total_height - self.curve_to_scale
else:
curve_width = width - self.curve_outer_border - self.curve_outer_border
curve_height = height - self.curve_outer_border - self.curve_outer_border
if DEBUG:
painter.fillRect(0, 0, width, height, Qt.green)
# fill canvas
if self.scales_visible:
canvas_x = self.y_scale.total_width + self.curve_to_scale - self.curve_outer_border
canvas_y = self.y_scale_height_offset - self.curve_outer_border
else:
canvas_x = 0
canvas_y = 0
canvas_width = self.curve_outer_border + curve_width + self.curve_outer_border
canvas_height = self.curve_outer_border + curve_height + self.curve_outer_border
painter.fillRect(canvas_x, canvas_y, canvas_width, canvas_height,
self.canvas_color)
# draw cross hair at cursor position
if self.cross_hair_visible:
p = self.mapFromGlobal(QCursor.pos())
p_x = p.x()
p_y = p.y()
if p_x >= canvas_x and p_x < canvas_x + canvas_width and \
p_y >= canvas_y and p_y < canvas_y + canvas_height:
painter.setPen(QPen(QColor(190, 190, 190), 1, Qt.DashLine))
painter.drawLine(canvas_x, p_y, canvas_x + canvas_width - 1,
p_y)
painter.drawLine(p_x, canvas_y, p_x,
canvas_y + canvas_height - 1)
# draw canvas border
if self.curve_outer_border > 0:
painter.setPen(QColor(190, 190, 190))
painter.drawRect(
canvas_x, canvas_y, canvas_width - 1, canvas_height -
1) # -1 to accommodate the 1px width of the border
painter.setPen(Qt.black)
if DEBUG:
painter.fillRect(canvas_x + self.curve_outer_border,
canvas_y + self.curve_outer_border, curve_width,
curve_height, Qt.cyan)
# draw scales
y_min_scale = self.y_scale.value_min
y_max_scale = self.y_scale.value_max
factor_x = float(curve_width) / self.history_length_x
factor_y = float(curve_height - 1) / max(
y_max_scale - y_min_scale,
EPSILON) # -1 to accommodate the 1px width of the curve
if self.scales_visible:
self.draw_x_scale(painter, factor_x)
self.draw_y_scale(painter, curve_height, factor_y)
# draw curves
if self.x_min != None and self.x_max != None:
x_min = self.x_min
x_max = self.x_max
if self.scales_visible:
curve_x_offset = 0
else:
curve_x_offset = round(
(self.history_length_x - (x_max - x_min)) * factor_x)
painter.save()
painter.translate(
canvas_x + self.curve_outer_border + curve_x_offset,
canvas_y + self.curve_outer_border + curve_height - 1 +
self.curve_y_offset
) # -1 to accommodate the 1px width of the curve
painter.scale(factor_x, -factor_y)
painter.translate(-x_min, -y_min_scale)
for c in range(len(self.curves_x)):
if not self.curves_visible[c]:
continue
curve_x = self.curves_x[c]
curve_y = self.curves_y[c]
path = QPainterPath()
lineTo = path.lineTo
path.moveTo(curve_x[0], curve_y[0])
for i in xrange(1, len(curve_x)):
lineTo(curve_x[i], curve_y[i])
painter.setPen(self.plots[c][1])
painter.drawPath(path)
painter.restore()
class QtRenderer(Renderer):
"""An implementation of :class:`~renderer.Renderer` for PyQt4.
This renderer will draw on any `QPaintDevice`
"""
def __init__(self, paint_device):
"""Creates a new renderer based on a QPaintDevice pd"""
self._grid_pen = QPen(QColor(0x808080))
self._grid_pen.setStyle(Qt.DashLine)
self._painter = None
Renderer.__init__(self, paint_device)
def set_canvas(self, canvas):
"""Tell the renderer to draw on canvas
The type of canvas is implementation-dependent"""
if self._painter is not None:
self._painter.restore()
self._painter.restore()
self._painter.end()
self._paintdevice = canvas
self._painter = QPainter(canvas)
self._painter.setRenderHint(QPainter.Antialiasing)
# invert the y axis
self._painter.scale(1, -1)
self._painter.translate(0, -canvas.height())
Renderer.set_canvas(self, canvas)
def _get_canvas_size(self, pd):
"""Get the canvas size tuple (width,height)"""
return (pd.width(), pd.height())
def push_state(self):
"""Store the current state on the stack.
Current state includes default pose, pen and brush"""
### FIXME store things
self._painter.save()
def pop_state(self):
"""Restore the last saved state from the stack
The state includes default pose, pen and brush"""
### FIXME store things
self._painter.restore()
def _calculate_bounds(self):
transform = self._painter.worldTransform().inverted()[0]
xs, ys = zip(transform.map(0.0, 0.0),
transform.map(0.0, float(self.size[1])),
transform.map(float(self.size[0]), float(self.size[1])),
transform.map(float(self.size[0]), 0.0))
self._bounds = (min(xs), min(ys), max(xs), max(ys))
def _draw_grid(self):
self.reset_pose()
self._painter.setPen(self._grid_pen)
xmin, ymin, xmax, ymax = self._bounds
# Determine min/max x & y line indices:
x_ticks = (int(xmin // self._grid_spacing),
int(xmax // self._grid_spacing + 1))
y_ticks = (int(ymin // self._grid_spacing),
int(ymax // self._grid_spacing + 1))
self._painter.drawLines([
QLineF(xmin, i * self._grid_spacing, xmax, i * self._grid_spacing)
for i in range(*y_ticks)
])
self._painter.drawLines([
QLineF(i * self._grid_spacing, ymin, i * self._grid_spacing, ymax)
for i in range(*x_ticks)
])
def scale(self, factor):
"""Scale drawing operations by factor
To be implemented in subclasses."""
self._painter.scale(factor, factor)
def rotate(self, angle):
"""Rotate canvas by angle (in radians)
To be implemented in subclasses."""
self._painter.rotate(degrees(angle))
def translate(self, dx, dy):
"""Translate canvas by dx, dy
To be implemented in subclasses."""
self._painter.translate(dx, dy)
def clear_screen(self):
"""Erases the current screen with a white brush"""
self._painter.save()
self._painter.resetTransform()
self.set_pen(0xFFFFFF)
self.set_brush(0xFFFFFF)
self.draw_rectangle(0, 0, self.size[0], self.size[1])
self._painter.restore()
Renderer.clear_screen(self)
@staticmethod
def __qcolor(color):
"""Returns qcolor for a given ARGB color"""
c = QColor(color)
if color > 0xFFFFFF:
c.setAlpha((color >> 24) & 0xFF)
return c
def set_pen(self, color=0, thickness=0):
"""Sets the line color and thickness.
Color is interpreted as 0xAARRGGBB."""
if color is None:
self._painter.setPen(Qt.NoPen)
else:
self._painter.setPen(QPen(self.__qcolor(color), thickness))
def set_brush(self, color):
"""Sets the fill color.
Color is interpreted as 0xAARRGGBB."""
if color is None:
self._painter.setBrush(Qt.NoBrush)
else:
self._painter.setBrush(self.__qcolor(color))
def draw_polygon(self, points):
"""Draws a polygon.
Expects a list of points as a list of tuples or as a numpy array."""
self._painter.drawPolygon(
QPolygonF([QPointF(*point[:2]) for point in points]))
def draw_ellipse(self, cx, cy, ra, rb=None):
"""Draws an ellipse."""
if rb is None:
rb = ra
self._painter.drawEllipse(QRectF(cx - ra, cy - ra, 2 * ra, 2 * rb))
def draw_rectangle(self, x, y, w, h):
"""Draws a rectangle."""
self._painter.drawRect(QRectF(x, y, w, h))
def draw_text(self, text, x, y, bgcolor=0):
"""Draws a text string at the defined position."""
pass
def draw_line(self, x1, y1, x2, y2):
"""Draws a line using the current pen from (x1,y1) to (x2,y2)"""
self._painter.drawLine(QLineF(x1, y1, x2, y2))
class Meter(QtGui.QWidget):
"""
a PyQt instance of QtMeter from Qt example code
"""
def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent)
self.value = 0
self.minValue = 0
self.maxValue = 100
self.logo = "CPU"
self.scaleMajor = 10
self.scaleMijor = 10
self.startAngle = 60
self.endAngle = 60
self.crownColor = Qt.blue
self.foreground = Qt.green
self.background = Qt.black
self.timer = QTimer()
self.timer.timeout.connect(self.update)
self.timer.start(200)
self.resize(200, 200)
def updateValue(self):
pass
def paintEvent(self, QPaintEvent):
self.updateValue()
self.side = min(self.width(), self.height())
self.painter = QPainter()
self.painter.begin(self)
self.painter.setRenderHint(QPainter.Antialiasing)
self.painter.translate(self.width() / 2, self.height() / 2)
self.painter.scale(self.side / 200.0, self.side / 200.0)
self.painter.setPen(Qt.NoPen)
self.drawCrown()
self.drawBackgroud()
self.drawLogo()
self.drawScale()
self.drawScaleNum()
self.drawNumbericValue()
self.drawPointer()
self.painter.end()
def setValue(self, updatefun):
self.value = updatefun()
def setLogo(self, logo):
self.logo = logo
def drawCrown(self):
self.painter.save()
self.painter.setPen(QtGui.QPen(self.crownColor, 3))
self.painter.drawEllipse(-92, -92, 184, 184)
self.painter.restore()
def drawBackgroud(self):
self.painter.save()
self.painter.setBrush(self.background)
self.painter.drawEllipse(-92, -92, 184, 184)
self.painter.restore()
def drawScale(self):
self.painter.save()
self.painter.rotate(self.startAngle)
self.painter.setPen(self.foreground)
steps = self.scaleMajor * self.scaleMijor
angleStep = (360.0 - self.startAngle - self.endAngle) / steps
pen = QtGui.QPen(self.painter.pen())
for i in xrange(steps + 1):
if i % self.scaleMajor == 0:
pen.setWidth(1)
self.painter.setPen(pen)
self.painter.drawLine(0, 62, 0, 72)
else:
pen.setWidth(0)
self.painter.setPen(pen)
self.painter.drawLine(0, 62, 0, 65)
self.painter.rotate(angleStep)
self.painter.restore()
def drawScaleNum(self):
self.painter.save()
self.painter.setPen(self.foreground)
startRad = (360 - self.startAngle - 90) * (3.14 / 180)
deltaRad = (360 - self.startAngle -
self.endAngle) * (3.14 / 180) / self.scaleMajor
fm = QtGui.QFontMetricsF(self.font())
for i in xrange(self.scaleMajor + 1):
sina = sin(startRad - i * deltaRad)
cosa = cos(startRad - i * deltaRad)
tmpVal = 1.0 * i * ((self.maxValue - self.minValue) /
self.scaleMajor) + self.minValue
numstr = QString("%1").arg(tmpVal)
w = fm.size(Qt.TextSingleLine, numstr).width()
h = fm.size(Qt.TextSingleLine, numstr).height()
x = 82 * cosa - w / 2
y = -82 * sina + h / 4
self.painter.drawText(x, y, numstr)
self.painter.restore()
def drawLogo(self):
self.painter.save()
self.painter.setPen(self.foreground)
self.painter.setBrush(self.foreground)
logostr = QString(self.logo)
fm = QtGui.QFontMetricsF(self.font())
w = fm.size(Qt.TextSingleLine, logostr).width()
self.painter.drawText(-w / 2, -30, logostr)
self.painter.restore()
def drawNumbericValue(self):
self.painter.save()
color = QtGui.QColor(150, 150, 200)
pen = self.painter.pen()
pen.setWidth(3)
self.painter.setPen(pen)
self.painter.setPen(color)
self.painter.drawRect(-30, 30, 60, 14)
cpustr = QString("%1").arg(self.value)
fm = QtGui.QFontMetricsF(self.font())
w = fm.size(Qt.TextSingleLine, cpustr).width()
self.painter.setPen(self.foreground)
self.painter.drawText(-w / 2, 42, cpustr)
self.painter.restore()
def drawPointer(self):
self.painter.save()
self.pointerHand = QPolygon([-2, 0, 2, 0, 0, 60])
self.pointerColor = QColor(127, 0, 127)
self.painter.setBrush(self.pointerColor)
self.painter.rotate(self.startAngle)
degRotate = (360.0 - self.startAngle - self.endAngle) / (
self.maxValue - self.minValue) * (self.value - self.minValue)
self.painter.rotate(degRotate)
self.painter.drawConvexPolygon(self.pointerHand)
self.painter.restore()
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(QColor(Config.COLOR_BONUS))
painter.save()
for i in range(self.value, self.value + self.__bonusValue):
shiftCenter = dotCenter + QPoint(0 + dotDiameter * i, 0)
painter.drawEllipse(shiftCenter, dotRadius, dotRadius)
painter.restore()
painter.setBrush(self._colorEmpty)
painter.save()
for i in range(self.value + self.__bonusValue, 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)
painter.restore()
def paintEvent(self, event):
painter = QPainter(self)
width = self.width()
height = self.height()
if DEBUG:
painter.fillRect(0, 0, width, height, Qt.blue)
else:
painter.fillRect(event.rect(), self.plot.canvas_color)
y_min_scale = self.plot.y_scale.value_min
y_max_scale = self.plot.y_scale.value_max
factor_x = float(width) / self.plot.x_diff
factor_y = float(height - 1) / max(
y_max_scale - y_min_scale,
EPSILON) # -1 to accommodate the 1px width of the curve
if self.plot.x_min != None and self.plot.x_max != None:
x_min = self.plot.x_min
x_max = self.plot.x_max
if self.plot.curve_start == 'left':
curve_x_offset = 0
else:
curve_x_offset = round(
(self.plot.x_diff - (x_max - x_min)) * factor_x)
transform = QTransform()
transform.translate(
curve_x_offset, height - 1 + self.plot.curve_y_offset
) # -1 to accommodate the 1px width of the curve
transform.scale(factor_x, -factor_y)
transform.translate(-x_min, -y_min_scale)
if self.plot.curve_motion_granularity > 1:
self.plot.partial_update_width = math.ceil(
transform.map(QLineF(0, 0, 1.5, 0)).length())
inverted_event_rect = transform.inverted()[0].mapRect(
QRectF(event.rect()))
painter.save()
painter.setTransform(transform)
if False and self.plot.curves_visible[0]:
# Currently unused support for bar graphs.
# If we need this later on we should add an option to the
# PlotWidget for it.
# I tested this for the Sound Pressure Level Bricklet and it works,
# but it didnt't look good.
curve_x = self.plot.curves_x[0]
curve_y = self.plot.curves_y[0]
t = time.time()
if self.max_points == None:
self.max_points = []
for y in curve_y:
self.max_points.append((t, y))
else:
for i in range(len(curve_y)):
if (curve_y[i] > self.max_points[i][1]) or (
(t - self.max_points[i][0]) > 5):
self.max_points[i] = (t, curve_y[i])
for i in range(len(self.plot.curves_x[0])):
painter.setPen(self.plot.curve_configs[0].color)
painter.drawLine(QPoint(curve_x[i], 0),
QPoint(curve_x[i], curve_y[i]))
painter.setPen(Qt.white)
painter.drawLine(QPoint(curve_x[i], curve_y[i]),
QPoint(curve_x[i], y_max_scale))
painter.setPen(Qt.darkGreen)
painter.drawPoint(QPoint(curve_x[i],
self.max_points[i][1]))
else:
for c in range(len(self.plot.curves_x)):
if not self.plot.curves_visible[c]:
continue
curve_x = self.plot.curves_x[c]
curve_y = self.plot.curves_y[c]
path = QPainterPath()
lineTo = path.lineTo
if self.plot.curve_motion_granularity > 1:
start = max(
min(
bisect.bisect_left(curve_x,
inverted_event_rect.left()),
len(curve_x) - 1) - 1, 0)
else:
start = 0
path.moveTo(curve_x[start], curve_y[start])
for i in xrange(start + 1, len(curve_x)):
lineTo(curve_x[i], curve_y[i])
painter.setPen(self.plot.curve_configs[c].color)
painter.drawPath(path)
painter.restore()
def paintEvent(self, event):
# Initialize QPainter properties
painter = QPainter()
painter.begin(self)
painter.setRenderHint(QPainter.Antialiasing)
if self.height() <= self.width() / self.ref_aspect_ratio:
v_scale = self.height()
h_scale = v_scale * self.ref_aspect_ratio
else:
h_scale = self.width()
v_scale = h_scale / self.ref_aspect_ratio
# Scale all objects proportionate to window size
painter.scale(h_scale / self.width_ref, v_scale / self.height_ref)
painter.setClipPath(self.dial) # Don't allow objects or text to extend outside of main dial shape
painter.save()
# First draw main gauge background
pen = QPen(painter.pen())
pen.setWidth(1)
pen.setColor(Qt.black)
painter.setPen(pen)
painter.setBrush(QColor(100, 100, 100, 255)) # self.dial_bg)
painter.drawPath(self.dial)
# Add Minor and Major Alarm limit bars
pen.setWidth(16)
pen.setCapStyle(Qt.FlatCap)
pen.setJoinStyle(Qt.BevelJoin)
pen.setColor(Qt.yellow)
painter.setPen(pen)
painter.setBrush(Qt.NoBrush)
painter.drawPath(self.low_arc)
painter.drawPath(self.high_arc)
pen.setColor(Qt.red)
painter.setPen(pen)
painter.drawPath(self.lolo_arc)
painter.drawPath(self.hihi_arc)
painter.restore()
# Display PV current value
painter.save()
font = QFont()
font.setPixelSize(45)
painter.setFont(font)
sevr = self.channel.sevr.lower()
if sevr == 'major':
color = Qt.red
elif sevr == 'minor':
color = Qt.yellow
elif sevr == 'invalid':
color = Qt.magenta
else:
color = Qt.green
pen.setColor(color)
painter.setPen(pen)
font_metric = QFontMetrics(font)
painter.translate(self.dial_width / 2, self.dial_height / 2)
label = self.format_label(self.channel_value)
painter.drawText(QPointF(0.0 - font_metric.width(label) / 2.0, font_metric.height() / 2.0),
label)
# Display PV name
painter.setFont(self.pv_label_font)
pen.setColor(Qt.black) # Qt.darkCyan)
pen.setWidth(1)
painter.setPen(pen)
# brush = QBrush(Qt.darkCyan)
# painter.setBrush(brush)
font_metric = QFontMetrics(self.pv_label_font)
pv_label = self.channel.egu # self.channel.name + ' (' + self.channel.egu + ')'
painter.drawText(QPointF(0.0 - font_metric.width(pv_label) / 2.0,
(self.dial_height / 2.0) + (font_metric.height() * 1.5)),
pv_label)
# painter.drawPath(self.pv_label_path)
painter.restore()
# Next add division markers
painter.save()
painter.translate(self.dial_width / 2, self.dial_height * 0.98)
pen.setColor(Qt.black) # Qt.cyan)
pen.setWidth(2)
painter.setPen(pen)
for i in range(0, 31):
if (i % 5) != 0:
painter.drawLine(-self.dial_width / 2.1, 0.0, -self.dial_width / 2.2, 0.0)
else:
painter.drawLine(-self.dial_width / 2.1, 0.0, -self.dial_width / 2.3, 0.0)
painter.rotate(6.0)
painter.restore()
# Layout division text labels
painter.save()
painter.translate(self.dial_width / 2, self.dial_height * 0.98)
pen.setColor(Qt.black) # Qt.cyan)
painter.setPen(pen)
font = QFont()
font.setPixelSize(18)
painter.setFont(font)
font_metric = QFontMetrics(font)
labels = linspace(self.lim_low, self.lim_hi, 7)
painter.rotate(-90)
for i in range(0, 7):
label = self.format_label(labels[i])
painter.drawText(QPointF(0.0 - font_metric.width(label) / 2.0, -self.dial_height * 0.75), label)
painter.rotate(30)
painter.restore()
# Draw needle at appropriate angle for data
painter.save()
painter.translate(self.dial_width / 2, self.dial_height * 0.98)
painter.rotate(-180 * (1.0 - self.percentage))
pen.setColor(QColor(self.needle_color).darker(200))
pen.setWidth(1)
painter.setPen(pen)
painter.setBrush(self.needle_color)
painter.drawPolygon(self.needle)
painter.restore()
# if self.percentage <= 0.5:
# shadow = max(490 * self.percentage, 127)
# needle_left_color = QColor(0, shadow, shadow) # Qt.darkCyan # QColor(80,80,80,255)
# needle_right_color = Qt.cyan # QColor(230,230,230,255)
# else:
# shadow = max(125 / self.percentage, 127)
# needle_left_color = Qt.cyan # QColor(230,230,230,255)
# needle_right_color = QColor(0, shadow, shadow) # Qt.darkCyan # QColor(80,80,80,255)
#
# # Draw Highlight side of needle
# pen.setWidth(1)
# pen.setColor(Qt.gray) # needle_left_color)
# painter.setPen(pen)
# painter.setBrush(Qt.gray) # needle_left_color)
# painter.drawPolygon(self.needle_left)
#
# # Draw shadow side of needle
# pen.setColor(Qt.gray) # needle_right_color)
# painter.setPen(pen)
# painter.setBrush(Qt.gray) # needle_right_color)
# painter.drawPolygon(self.needle_right)
# painter.restore()
# Draw needle axel pin
painter.save()
pen.setWidth(1)
pen.setColor(Qt.black)
painter.setPen(pen)
painter.setBrush(QColor(50, 50, 50, 255)) # self.pin_bg)
painter.translate(self.dial_width / 2, self.dial_height * 0.98)
painter.drawEllipse(self.pin_rect)
painter.restore()
# Draw glass reflection and shadow effects
# painter.save()
# painter.translate(self.dial_width / 2.0, self.dial_height / 2.0)
# painter.setPen(Qt.NoPen)
# painter.setBrush(QColor(0, 0, 0, 20))
# painter.drawEllipse(self.shadow_rect)
# painter.setBrush(self.gloss_gradient)
# painter.drawEllipse(self.gloss_rect)
# painter.restore()
painter.end()
def _drawStyledBar(self, painter, option):
rect = option.rect
key = "fancy styledbar %d %d %d" % (rect.width(), rect.height(),
theme.baseColor.rgb())
pixmap = QPixmap()
p = painter
if theme.usePixmapCache() and not QPixmapCache.find(key, pixmap):
pixmap = QPixmap(rect.size())
p = QPainter(pixmap)
rect = QRect(0, 0, rect.width(), rect.height())
horizontal = option.state & QStyle.State_Horizontal
offset = self.window().mapToGlobal(
option.rect.topLeft()) - self.mapToGlobal(option.rect.topLeft())
gradientSpan = QRect(offset, self.window().size())
if horizontal:
theme.horizontalGradient(p, gradientSpan, rect)
else:
theme.verticalGradient(p, gradientSpan, rect)
painter.setPen(theme.borderColor)
if horizontal:
lighter = QColor(255, 255, 255, 40)
if self._topBorder:
p.drawLine(rect.topLeft(), rect.topRight())
p.setPen(lighter)
p.drawLine(rect.topLeft() + QPoint(0, 1),
rect.topRight() + QPoint(0, 1))
else:
p.drawLine(rect.bottomLeft(), rect.bottomRight())
p.setPen(lighter)
p.drawLine(rect.topLeft(), rect.topRight())
else:
p.drawLine(rect.topLeft(), rect.bottomLeft())
p.drawLine(rect.topRight(), rect.bottomRight())
if theme.usePixmapCache() and not QPixmapCache.find(key, pixmap):
painter.drawPixmap(rect.topLeft(), pixmap)
p.end()
del p
QPixmapCache.insert(key, pixmap)
def paintEvent(self, event):
painter = QPainter()
painter.begin(self)
painter.setRenderHint(painter.Antialiasing)
font = painter.font()
font.setBold(True)
painter.setFont(font)
x = self.rect().x()
y = self.rect().y()
w = self.rect().width() - 1
h = self.rect().height() - 1
r = 8
# draw a rounded style
if self._rolloutStyle == 2:
# draw the text
painter.drawText(x + 33, y + 3, w, 16, Qt.AlignLeft | Qt.AlignTop,
self.title())
# draw the triangle
self.__drawTriangle(painter, x, y)
# draw the borders
pen = QPen(self.palette().color(QPalette.Light))
pen.setWidthF(0.6)
painter.setPen(pen)
painter.drawRoundedRect(x + 1, y + 1, w - 1, h - 1, r, r)
pen.setColor(self.palette().color(QPalette.Shadow))
painter.setPen(pen)
painter.drawRoundedRect(x, y, w - 1, h - 1, r, r)
# draw a square style
if self._rolloutStyle == 3:
# draw the text
painter.drawText(x + 33, y + 3, w, 16, Qt.AlignLeft | Qt.AlignTop,
self.title())
self.__drawTriangle(painter, x, y)
# draw the borders
pen = QPen(self.palette().color(QPalette.Light))
pen.setWidthF(0.6)
painter.setPen(pen)
painter.drawRect(x + 1, y + 1, w - 1, h - 1)
pen.setColor(self.palette().color(QPalette.Shadow))
painter.setPen(pen)
painter.drawRect(x, y, w - 1, h - 1)
# draw a Maya style
if self._rolloutStyle == 4:
# draw the text
painter.drawText(x + 33, y + 3, w, 16, Qt.AlignLeft | Qt.AlignTop,
self.title())
painter.setRenderHint(QPainter.Antialiasing, False)
self.__drawTriangle(painter, x, y)
# draw the borders - top
headerHeight = 20
headerRect = QRect(x + 1, y + 1, w - 1, headerHeight)
headerRectShadow = QRect(x - 1, y - 1, w + 1, headerHeight + 2)
# Highlight
pen = QPen(self.palette().color(QPalette.Light))
pen.setWidthF(0.4)
painter.setPen(pen)
painter.drawRect(headerRect)
painter.fillRect(headerRect, QColor(255, 255, 255, 18))
# Shadow
pen.setColor(self.palette().color(QPalette.Dark))
painter.setPen(pen)
painter.drawRect(headerRectShadow)
if not self.isCollapsed():
# draw the lover border
pen = QPen(self.palette().color(QPalette.Dark))
pen.setWidthF(0.8)
painter.setPen(pen)
offSet = headerHeight + 3
bodyRect = QRect(x, y + offSet, w, h - offSet)
bodyRectShadow = QRect(x + 1, y + offSet, w + 1,
h - offSet + 1)
painter.drawRect(bodyRect)
pen.setColor(self.palette().color(QPalette.Light))
pen.setWidthF(0.4)
painter.setPen(pen)
painter.drawRect(bodyRectShadow)
# draw a boxed style
elif self._rolloutStyle == 1:
if self.isCollapsed():
arect = QRect(x + 1, y + 9, w - 1, 4)
brect = QRect(x, y + 8, w - 1, 4)
text = '+'
else:
arect = QRect(x + 1, y + 9, w - 1, h - 9)
brect = QRect(x, y + 8, w - 1, h - 9)
text = '-'
# draw the borders
pen = QPen(self.palette().color(QPalette.Light))
pen.setWidthF(0.6)
painter.setPen(pen)
painter.drawRect(arect)
pen.setColor(self.palette().color(QPalette.Shadow))
painter.setPen(pen)
painter.drawRect(brect)
painter.setRenderHint(painter.Antialiasing, False)
painter.setBrush(self.palette().color(QPalette.Window).darker(120))
painter.drawRect(x + 10, y + 1, w - 20, 16)
painter.drawText(x + 16, y + 1, w - 32, 16,
Qt.AlignLeft | Qt.AlignVCenter, text)
painter.drawText(x + 10, y + 1, w - 20, 16, Qt.AlignCenter,
self.title())
if self.dragDropMode():
rect = self.dragDropRect()
# draw the lines
l = rect.left()
r = rect.right()
cy = rect.center().y()
for y in (cy - 3, cy, cy + 3):
painter.drawLine(l, y, r, y)
painter.end()
class IconWidget(QWidget):
QT_BLACK = Qt.color1
QT_WHITE = Qt.color0
updated = pyqtSignal()
def __init__(self, parent=None, size=(8, 8), zoom=8):
QWidget.__init__(self, parent)
self.setAttribute(Qt.WA_StaticContents)
self.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
self.curColor = Qt.color0
self.zoom = zoom
self.size = QSize(*size)
self.newCleanImage()
def penColor(self):
return self.curColor
def setPenColor(self, penColor):
self.curColor = penColor
def newCleanImage(self, size=None):
if size:
self.size = QSize(*size)
self.image = QImage(self.size, QImage.Format_Mono)
self.clearIconImage()
def iconImage(self):
return self.image
def setIconImage(self, new_image):
if new_image != self.image:
self.image = new_image
self.update()
self.updateGeometry()
def clearIconImage(self):
self.image.fill(1)
self.update()
self.updateGeometry()
def zoomFactor(self):
return self.zoom
def setZoomFactor(self, zoomFactor):
self.zoom = zoomFactor
# Qt Designer attributes
penColor = pyqtProperty("QColor", penColor, setPenColor)
iconImage = pyqtProperty("QImage", iconImage, setIconImage)
zoomFactor = pyqtProperty("int", zoomFactor, setZoomFactor)
def sizeHint(self):
size = self.zoom * self.image.size()
if self.zoom >= 3:
size += QSize(1, 1)
return size
def getIconData(self):
width = self.image.width()
height = self.image.height()
matrix = list()
for y in range(height):
row = list()
for x in range(width):
opaque = 1 if QColor.fromRgba(
self.image.pixel(QPoint(x, y))).red() != 255 else 0
row.append(opaque)
matrix.append(row)
return np.array(matrix)
def mousePressEvent(self, event):
if event.button() == Qt.LeftButton:
self.setImagePixel(event.pos(), True)
elif event.button() == Qt.RightButton:
self.setImagePixel(event.pos(), False)
elif event.button() == Qt.MiddleButton:
# self.image.fill(0)
self.clearIconImage()
def mouseReleaseEvent(self, event):
self.updated.emit()
def mouseMoveEvent(self, event):
if event.buttons() == Qt.LeftButton:
self.setImagePixel(event.pos(), True)
elif event.buttons() == Qt.RightButton:
self.setImagePixel(event.pos(), False)
elif event.buttons() == Qt.MiddleButton:
self.clearIconImage()
def setImagePixel(self, pos, opaque):
i = pos.x() / self.zoom
j = pos.y() / self.zoom
if self.image.rect().contains(i, j):
self.image.setPixel(i, j, 0)
self.update(self.pixelRect(i, j))
def paintEvent(self, event):
self.painter = QPainter()
self.painter.begin(self)
if self.zoom >= 3:
self.painter.setPen(QPalette().foreground().color())
# draw horizontal lines
for i in range(self.image.width() + 1):
self.painter.drawLine(self.zoom * i,
0,
self.zoom * i,
self.zoom * self.image.height())
# draw vertical lines
for j in range(self.image.height() + 1):
self.painter.drawLine(0,
self.zoom * j,
self.zoom * self.image.width(),
self.zoom * j)
for i in range(self.image.width()):
for j in range(self.image.height()):
rect = self.pixelRect(i, j)
if not event.region().intersected(rect).isEmpty():
color = QColor.fromRgba(self.image.pixel(QPoint(i, j)))
if color.red() < 255:
self.painter.fillRect(rect, self.QT_WHITE)
self.painter.fillRect(rect, color)
self.painter.end()
def pixelRect(self, i, j):
if self.zoom >= 3:
return QRect(self.zoom * i + 1, self.zoom * j + 1,
self.zoom - 1, self.zoom - 1)
else:
return QRect(self.zoom * i, self.zoom * j,
self.zoom, self.zoom)
def getImageData(self):
pass
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)) + "%")
