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)) + "%")