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): """ Overloads the paint event to handle painting pointers for the popup \ mode. :param event | <QPaintEvent> """ # use the base technique for the dialog mode if self.currentMode() == XPopupWidget.Mode.Dialog: super(XPopupWidget, self).paintEvent(event) return # setup the coloring options palette = self.palette() painter = QPainter() painter.begin(self) pen = QPen(palette.color(palette.Window).darker(130)) pen.setWidthF(1.75) painter.setPen(pen) painter.setRenderHint(painter.Antialiasing) painter.setBrush(palette.color(palette.Window)) painter.drawPath(self.borderPath()) painter.end()
def __init__(self, radiusOut, raiusIn, angle, arcLen, parent=None): QGraphicsPathItem.__init__(self, parent=parent) self._radiusOut = radiusOut self._raiusIn = raiusIn self._angle = angle self._arcLen = arcLen self._pen = QPen(QColor('#000000')) self._pen.setWidth(1) self.setPen(self._pen) self._hoverPen = QPen(QColor('#000000')) self._hoverPen.setWidth(2) brush = QBrush(QColor('#FF9966')) self.setBrush(brush) rectOut = QRectF(-radiusOut, -radiusOut, radiusOut*2.0, radiusOut*2.0) rectIn = QRectF(-raiusIn, -raiusIn, raiusIn*2.0, raiusIn*2.0) startAngle = angle - arcLen/2.0 endAngle = angle + arcLen/2.0 path = QPainterPath() path.arcMoveTo(rectIn, startAngle) path.arcTo(rectOut, startAngle, arcLen) path.arcTo(rectIn, endAngle, 0) path.arcTo(rectIn, endAngle, -arcLen) self.setPath(path) self._isHover = False self._ioDragFirstPos = None
def create_multicut_edge_layer(self): ActionInfo = ShortcutManager.ActionInfo op = self.__topLevelOperatorView if not op.Output.ready(): return None # Final segmentation -- Edges default_pen = QPen(SegmentationEdgesLayer.DEFAULT_PEN) default_pen.setColor(Qt.blue) layer = SegmentationEdgesLayer(LazyflowSource(op.Output), default_pen) layer.name = "Multicut Edges" layer.visible = False # Off by default... layer.opacity = 1.0 layer.shortcutRegistration = ( "m", ActionInfo( "Multicut", "MulticutEdgesVisibility", "Show/Hide Multicut Edges", layer.toggleVisible, self.viewerControlWidget(), layer, ), ) return layer
def __init__(self, scene, axis, posModel): QGraphicsItem.__init__(self, scene=scene) self.setFlag(QGraphicsItem.ItemHasNoContents); self.axis = axis self.posModel = posModel self._width = 0 self._height = 0 self.thick_penX = QPen(Qt.red, self.thick_width) self.thick_penX.setCosmetic(True) self.thick_penY = QPen(Qt.green, self.thick_width) self.thick_penY.setCosmetic(True) self.thin_penX = QPen(Qt.red, self.thin_width) self.thin_penX.setCosmetic(True) self.thin_penY = QPen(Qt.green, self.thin_width) self.thin_penY.setCosmetic(True) self.x = 0 self.y = 0 # These child items do most of the work. self._horizontal_marker = SliceMarkerLine(self, 'horizontal') self._vertical_marker = SliceMarkerLine(self, 'vertical') # We self._horizontal_marker = SliceMarkerLine(self, 'horizontal') self._vertical_marker = SliceMarkerLine(self, 'vertical')
def __init__(self, scene, axis, posModel): """ scene: Must be an ImageScene2D instance. We manipulate the scene.allow_brushing flag. """ QGraphicsItem.__init__(self, scene=scene) self.setFlag(QGraphicsItem.ItemHasNoContents); self.axis = axis self.posModel = posModel self._width = 0 self._height = 0 self.thick_penX = QPen(Qt.red, self.thick_width) self.thick_penX.setCosmetic(True) self.thick_penY = QPen(Qt.green, self.thick_width) self.thick_penY.setCosmetic(True) self.thin_penX = QPen(Qt.red, self.thin_width) self.thin_penX.setCosmetic(True) self.thin_penY = QPen(Qt.green, self.thin_width) self.thin_penY.setCosmetic(True) self.x = 0 self.y = 0 # These child items do most of the work. self._horizontal_marker = SliceMarkerLine(self, 'horizontal') self._vertical_marker = SliceMarkerLine(self, 'vertical')
def mouseMoveEvent(self, event): if event.buttons() & Qt.LeftButton: downPos = event.buttonDownPos(Qt.LeftButton) if not self.__tmpLine and self.__dragStartItem and \ (downPos - event.pos()).manhattanLength() > \ QApplication.instance().startDragDistance(): # Start a line drag line = QGraphicsLineItem(self) start = self.__dragStartItem.boundingRect().center() start = self.mapFromItem(self.__dragStartItem, start) line.setLine(start.x(), start.y(), event.pos().x(), event.pos().y()) pen = QPen(Qt.black, 4) pen.setCapStyle(Qt.RoundCap) line.setPen(pen) line.show() self.__tmpLine = line if self.__tmpLine: # Update the temp line line = self.__tmpLine.line() line.setP2(event.pos()) self.__tmpLine.setLine(line) QGraphicsWidget.mouseMoveEvent(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 drawForeground(self, painter, rect): QGraphicsView.drawForeground(self, painter, rect) if self._sel_accepted: painter.save() painter.resetTransform() rect = self._sel_rect viewport = self.viewport() option = QStyleOptionRubberBand() option.initFrom(viewport) option.rect = self._sel_rect option.shape = QRubberBand.Rectangle mask = QStyleHintReturnMask() self.style().drawControl(QStyle.CE_RubberBand, option, painter, viewport); painter.restore() elif self._div_accepted: painter.save() painter.resetTransform() line = self._div_line viewport = self.viewport() palette = viewport.palette() pen = QPen(Qt.DashDotLine) pen.setWidth(2) pen.setColor(Qt.red) painter.setPen(pen) painter.drawLine(self._div_line) painter.restore()
def drawForeground(self, painter, rect): if self._tiling is None: return tile_nos = self._tiling.intersected(rect) for tileId in tile_nos: p = self._brushingLayer[tileId] if p.dataVer == p.imgVer: continue p.paint(painter) #access to the underlying image patch is serialized ## draw tile outlines if self._showTileOutlines: # Dashed black line pen = QPen() pen.setDashPattern([5,5]) painter.setPen(pen) painter.drawRect(self._tiling.imageRects[tileId]) # Dashed white line # (offset to occupy the spaces in the dashed black line) pen = QPen() pen.setDashPattern([5,5]) pen.setDashOffset(5) pen.setColor(QColor(Qt.white)) painter.setPen(pen) painter.drawRect(self._tiling.imageRects[tileId])
def updateFilledCircle(self, s): size = s * self.zoom pixmap = QPixmap(self.width(), self.height()) pixmap.fill(Qt.transparent) #painter filled ellipse p = QPalette() painter = QPainter() painter.begin(pixmap) painter.setRenderHint(QPainter.Antialiasing) brush = QBrush(p.link().color()) painter.setBrush(brush) painter.setOpacity(0.4) painter.drawEllipse(QRect(self.width()/2 - size/2, self.height()/2 - size/2, size, size)) painter.end() #painter ellipse 2 painter2 = QPainter() painter2.begin(pixmap) painter2.setRenderHint(QPainter.Antialiasing) pen2 = QPen(Qt.green) pen2.setWidth(1) painter2.setPen(pen2) painter2.drawEllipse(QRect(self.width()/2 - size/2, self.height()/2 - size/2, size, size)) painter2.end() self.ellipseLabel.setPixmap(QPixmap(pixmap)) self.lastSize = s
def paintEvent(self, e): super().paintEvent(e) painter = QPainter() painter.begin(self) pen = QPen() pen.setWidth(2) painter.setPen(pen) right_as_line = False ral_place = [] if self.previous_commit != None and '\\' in self.previous_commit[-1]: right_as_line = True for f in range(len(self.previous_commit[-1])): if self.previous_commit[-1][f] == '\\': ral_place.append(f) i = 0 for j in range(len(self.commit[0])): if self.commit[0][j] == '*': painter.drawImage(QPoint(i,0), self.commit_image()) elif self.commit[0][j] == '|': x = 30/len(self.commit) if len(self.commit) > 1 and len(self.commit[1]) > j+1 and self.commit[1][j+1] == '\\': x = 15 painter.drawLine(i+15, 0, i+15, x) elif self.commit[0][j] == '\\': if right_as_line == True and j-1 in ral_place: painter.drawLine(i+15, 0, i+15, 15) else: painter.drawLine(i+15, 15, i+30, 15+(15/len(self.commit))) elif self.commit[0][j] == '/': painter.drawImage(QPoint(i,0), QImage(dirname(__file__)+'/icons/right.png')) elif self.commit[0][j] == '_': painter.drawImage(QPoint(i,0), QImage(dirname(__file__)+'/icons/line-flipped.png')) i += self.char_size down = 0 up = 0 left = False for j in range(1, len(self.commit)): i = 0 for k in range(len(self.commit[j])): if self.commit[j][k] == '|': x = (30/len(self.commit))*j if len(self.commit[0]) > k and self.commit[0][k] == '*': x += 15 if len(self.commit[j-1]) > k and self.commit[j-1][k-1] == '\\': x += (30/len(self.commit))/2 painter.drawLine(i+15, x, i+15, (30/len(self.commit))*(j+1)) elif self.commit[j][k] == '\\': painter.drawLine(i+1, 15, i+29, 15+(15/len(self.commit))*(j+1)) down = 5 up = 2 left = True elif self.commit[j][k] == '/': if left == True: painter.drawLine(i+2, 15+(13/len(self.commit))*(j+1), i+29, 15+(15/len(self.commit))*j) else: painter.drawLine(i+1, (30/len(self.commit))*(j+1)-up, i+27, down+(30/len(self.commit))*j) elif self.commit[j][k] == '_': painter.drawLine(i, 15+(15/len(self.commit))*j, i+30, 15+(15/len(self.commit))*j) i += self.char_size painter.end()
def setRectanglePen( self ): " Sets the diagram pen " pen = QPen( QColor( 0, 0, 0) ) pen.setWidth( 2 ) pen.setJoinStyle( Qt.RoundJoin ) self.setPen( pen ) return
class CoreItem(QGraphicsEllipseItem): def __init__(self, radius, parent=None): QGraphicsEllipseItem.__init__(self, QRectF(-radius, -radius, radius*2.0, radius*2.0), parent=parent) self._pen = QPen(QColor('#000000')) self._pen.setWidth(1) self.setPen(self._pen) self._hoverPen = QPen(QColor('#000000')) self._hoverPen.setWidth(2) brush = QBrush(QColor('#FF9966')) self.setBrush(brush) self._isSelected = False self._isHover = False self.setAcceptHoverEvents(True) def setIsHover(self, isHover): self._isHover = isHover pen = self._hoverPen if isHover else self._pen self.setPen(pen) self.update() def hoverEnterEvent(self, event): QGraphicsEllipseItem.hoverEnterEvent(self, event) event.accept() self.setIsHover(True) def hoverLeaveEvent(self, event): QGraphicsEllipseItem.hoverLeaveEvent(self, event) event.accept() self.setIsHover(False)
def __init__(self, source, dest): super().__init__() self.setAcceptedMouseButtons(Qt.LeftButton) self.setCacheMode(self.DeviceCoordinateCache) # Without this, burn thy CPU self.setZValue(1) pen = QPen(Edge.Color.DEFAULT[0], 1) pen.setJoinStyle(Qt.MiterJoin) self.setPen(pen) self.arrowHead = QtGui.QPolygonF() self._selected = False self._weights = [] self._labels = [] self.squares = GroupOfSquares(self) self.source = source self.dest = dest if source is dest: source.edges.append(self) else: source.edges.insert(0, self) dest.edges.insert(0, self) # Add text labels label = self.label = TextItem('', self) label.setFont(Edge.Font.DEFAULT) label.setZValue(3) self.adjust()
def paintEvent(self, event): """ custom paint event to draw vertical text """ painter = QPainter(self) # draw box around arc_size, line_width=10, 1 pen = QPen(QtCore.Qt.gray) pen.setWidth(line_width) painter.setPen(pen) painter.drawLine(arc_size,0, self.width(), 0) painter.drawLine(0, arc_size,0, self.height()-arc_size) painter.drawLine(arc_size-5,self.height()-1,self.width(), self.height()-1) painter.drawArc(0,0, arc_size*2, arc_size*2, 180*16, -90*16) painter.drawArc(0,self.height()-arc_size*2, arc_size*2, arc_size*2, 180*16, 90*16) # draw box around #if (self.isEnabled()): if self.selected: painter.setPen(QtCore.Qt.black) else: painter.setPen(QtCore.Qt.gray) painter.translate(self.width(), self.height()) painter.rotate(270) painter.drawText(QtCore.QPointF(10,- self.width()/3), self.text()) # destroy del painter
def paintEvent(self, ev): color = self.palette().color(QPalette.Highlight) painter = QPainter(self) # Filled rectangle. painter.setClipRect(self.rect()) color.setAlpha(50) painter.fillRect(self.rect().adjusted(2,2,-2,-2), color) # Thin rectangle outside. color.setAlpha(150) painter.setPen(color) painter.drawRect(self.rect().adjusted(0,0,-1,-1)) # Pseudo-handles at the corners and sides color.setAlpha(100) pen = QPen(color) pen.setWidth(8) painter.setPen(pen) painter.setBackgroundMode(Qt.OpaqueMode) # Clip at 4 corners region = QRegion(QRect(0,0,20,20)) region += QRect(self.rect().width()-20, 0, 20, 20) region += QRect(self.rect().width()-20, self.rect().height()-20, 20, 20) region += QRect(0, self.rect().height()-20, 20, 20) # Clip middles region += QRect(0, self.rect().height()/2-10, self.rect().width(), 20) region += QRect(self.rect().width()/2-10, 0, 20, self.rect().height()) # Draw thicker rectangles, clipped at corners and sides. painter.setClipRegion(region) painter.drawRect(self.rect())
def draw(self): """ Draws connection. """ self.calculateRoute() if not self.routeIsValid(): return painter = QPainter(self) #logging.debug(self.__class__.__name__ +": draw()") if self._selectedFlag: # Selected framePen = QPen(self.SELECT_COLOR) framePen.setWidth(self.SELECTED_FRAME_WIDTH) else: #self.select(False) framePen = QPen(Qt.NoPen) #if hasattr(QPainter, 'Antialiasing'): if self.zoom() > 30: painter.setRenderHint(QPainter.Antialiasing) # painter.setPen(Qt.black) # for thisP in self._route: # painter.drawEllipse(self.mapFromParent(thisP), self.CONNECTION_THICKNESS * self.zoomFactor(), self.CONNECTION_THICKNESS* self.zoomFactor()) painter.setPen(framePen) for i in range(0, len(self._route) -1): #self.drawLineSection(painter, route[i], route[i + 1], self._cornerTypes[i], self._cornerTypes[i + 1]) self.drawSection(painter, i)
def draw_arrow(self, line, width, color): (x1, y1), (x2, y2) = line # compute points line = QLineF(x1, y1, x2, y2) # If the line is very small, we make our arrowhead smaller arrowsize = min(14, line.length()) lineangle = radians(line.angle()) arrowpt1 = line.p2() + QPointF(sin(lineangle - (pi/3)) * arrowsize, cos(lineangle - (pi/3)) * arrowsize) arrowpt2 = line.p2() + QPointF(sin(lineangle - pi + (pi/3)) * arrowsize, cos(lineangle - pi + (pi/3)) * arrowsize) head = QPolygonF([line.p2(), arrowpt1, arrowpt2]) # We have to draw the actual line a little short for the tip of the arrowhead not to be too wide adjustedLine = QLineF(line) adjustedLine.setLength(line.length() - arrowsize/2) # draw line painter = self.current_painter color = COLORS[color] painter.save() pen = QPen(painter.pen()) pen.setColor(color) pen.setWidthF(width) painter.setPen(pen) painter.drawLine(adjustedLine) # draw arrowhead painter.setPen(Qt.NoPen) brush = painter.brush() brush.setColor(color) brush.setStyle(Qt.SolidPattern) painter.setBrush(brush) painter.drawPolygon(head) painter.restore()
def addRectIndependencePearson(self, rect, x, y, w, h, xAttr_xVal, yAttr_yVal, actual, sum, width): xAttr, xVal = xAttr_xVal yAttr, yVal = yAttr_yVal expected = float(xVal*yVal)/float(sum) pearson = (actual - expected) / sqrt(expected) if pearson > 0: # if there are more examples that we would expect under the null hypothesis intPearson = floor(pearson) pen = QPen(QColor(0,0,255), width); rect.setPen(pen) b = 255 r = g = 255 - intPearson*20 r = g = max(r, 55) # elif pearson < 0: intPearson = ceil(pearson) pen = QPen(QColor(255,0,0), width) rect.setPen(pen) r = 255 b = g = 255 + intPearson*20 b = g = max(b, 55) else: pen = QPen(QColor(255,255,255), width) r = g = b = 255 # white color = QColor(r,g,b) brush = QBrush(color) rect.setBrush(brush) if pearson > 0: pearson = min(pearson, 10) kvoc = 1 - 0.08 * pearson # if pearson in [0..10] --> kvoc in [1..0.2] else: pearson = max(pearson, -10) kvoc = 1 - 0.4*pearson pen.setWidth(1) self.addLines(x,y,w,h, kvoc, pen)
def paintEvent( self, event ): """ Overloads the paint event to draw rounded edges on this widget. :param event | <QPaintEvent> """ super(XRolloutItem, self).paintEvent(event) painter = QPainter() painter.begin(self) w = self.width() - 3 h = self.height() - 3 color = self.palette().color(QPalette.Midlight) color = color.darker(180) pen = QPen(color) pen.setWidthF(0.5) painter.setPen(pen) painter.setBrush(self.palette().color(QPalette.Midlight)) painter.setRenderHint(QPainter.Antialiasing) painter.drawRoundedRect(1, 1, w, h, 10, 10) painter.end()
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 minorGridPen(): """ Reasonable default for minor grid pen. @return QPen instance """ pen = QPen(QColor(210, 210, 210)) pen.setStyle(Qt.DotLine) return pen
def paint(self, painter, option, widget): params = parameters.instance col = QColor(params.arrow_color) pen = QPen(col) pen.setWidth(params.arrow_line_size) painter.setPen(pen) painter.setBrush(col) painter.drawPath(self.path)
def paint(self, painter, option, widget=None): with painter_context(painter): pen = QPen(painter.pen()) pen.setWidth(10.0) pen.setColor( QColor(255,0,0) ) painter.setPen(pen) shrunken_rectf = self.rectf.adjusted(10,10,-10,-10) painter.drawRoundedRect(shrunken_rectf, 50, 50, Qt.RelativeSize)
def majorGridPen(): """ Reasonable default for major grid pen. @return QPen instance """ pen = QPen(QColor(170, 170, 170)) pen.setStyle(Qt.DashLine) return pen
class BaseConnectorItem(QGraphicsPathItem): IOTypeIn = 1 IOTypeOut = 1 << 1 def __init__(self, radiusOut, raiusIn, angle, arcLen, parent=None): QGraphicsPathItem.__init__(self, parent=parent) self._radiusOut = radiusOut self._raiusIn = raiusIn self._angle = angle self._arcLen = arcLen self._pen = QPen(QColor('#000000')) self._pen.setWidth(1) self.setPen(self._pen) self._hoverPen = QPen(QColor('#000000')) self._hoverPen.setWidth(2) brush = QBrush(QColor('#FF9966')) self.setBrush(brush) rectOut = QRectF(-radiusOut, -radiusOut, radiusOut*2.0, radiusOut*2.0) rectIn = QRectF(-raiusIn, -raiusIn, raiusIn*2.0, raiusIn*2.0) startAngle = angle - arcLen/2.0 endAngle = angle + arcLen/2.0 path = QPainterPath() path.arcMoveTo(rectIn, startAngle) path.arcTo(rectOut, startAngle, arcLen) path.arcTo(rectIn, endAngle, 0) path.arcTo(rectIn, endAngle, -arcLen) self.setPath(path) self._isHover = False self._ioDragFirstPos = None def ioType(self): return self._ioType def setIsHover(self, isHover): self._isHover = isHover pen = self._hoverPen if isHover else self._pen self.setPen(pen) self.update() def hoverEnterEvent(self, event): event.accept() self.setIsHover(True) QGraphicsPathItem.hoverEnterEvent(self, event) def hoverLeaveEvent(self, event): event.accept() self.setIsHover(False) QGraphicsPathItem.hoverLeaveEvent(self, event)
def __gradient(self): left = QPointF(self.contentsRect().topLeft()) right = QPointF(self.contentsRect().topRight()) gradient = QLinearGradient(left, right) gradient.setColorAt(0.9, self.palette().color(QPalette.WindowText)) gradient.setColorAt(1.0, self.palette().color(QPalette.Window)) pen = QPen() pen.setBrush(QBrush(gradient)) return pen
def paint(self, QPainter, QStyleOptionGraphicsItem, QWidget_widget=None): # setPen pen = QPen() pen.setWidth(5) pen.setJoinStyle(Qt.MiterJoin) #让箭头变尖 QPainter.setPen(pen) # draw line QPainter.drawLine(self.line)
def penForID(self, penId): if penId == PenID.Bar: return self.linePen elif penId == PenID.TodayLine: pen = QPen(self.linePen) pen.setColor(Qt.red) return pen else: return GraphView.penForID(self, penId)
def imprimer(self): self.liste_action() printer = QtGui.QPrinter() printer.setOutputFileName("listingAction.pdf") painter = QtGui.QPainter() painter.begin(printer) pen = QPen(Qt.black, 1, Qt.SolidLine) painter.setPen(pen) marge = 20 col1 = 100 posCol2 = marge + col1 col2 = 250 posCol3 = posCol2 + col2 col3 = 250 posCol4 = posCol3 + col3 col4 = 100 fin = posCol4 + col4 pasY = 20 line = 0 posY = line * pasY painter.drawLine(marge, posY,fin, posY) painter.setFont(QtGui.QFont('Decorative', 10)) painter.drawText(marge + 5, posY + 15, 'Num semaine') painter.drawText(posCol2 + 5, posY + 15, 'Planche') painter.drawText(posCol3 + 5, posY + 15, 'Action') painter.drawText(posCol4 + 5, posY + 15, 'Retrait') for id in self.tableAction: posY = (line + 1) * pasY painter.drawLine(marge, posY,fin, posY) painter.setFont(QtGui.QFont('Decorative', 10)) painter.drawText(marge + 5, posY + 15, str(self.tableAction[line][0])) painter.drawText(posCol2 + 5, posY + 15, str(self.tableAction[line][1])) painter.drawText(posCol3 + 5, posY + 15, str(self.tableAction[line][2])) painter.drawText(posCol4 + 5, posY + 15, str(self.tableAction[line][3])) line = line + 1 painter.drawLine(marge, 0,marge, (line + 1) * pasY) painter.drawLine(posCol2, 0,posCol2, (line + 1) * pasY) painter.drawLine(posCol3, 0,posCol3, (line + 1) * pasY) painter.drawLine(posCol4, 0,posCol4, (line + 1) * pasY) painter.drawLine(fin, 0,fin, (line + 1) * pasY) painter.drawLine(marge, (line + 1) * pasY,fin, (line + 1) * pasY) painter.end()
def draw_big_scaled_markter(self): my_painter = QPainter(self) my_painter.setRenderHint(QPainter.Antialiasing) # Koordinatenursprung in die Mitte der Flaeche legen my_painter.translate(self.width() / 2, self.height() / 2) # my_painter.setPen(Qt.NoPen) self.pen = QPen(QColor(0, 0, 0, 255)) self.pen.setWidth(2) # # if outline_pen_with > 0: my_painter.setPen(self.pen) my_painter.rotate(self.scale_angle_start_value - self.angle_offset) steps_size = (float(self.scale_angle_size) / float(self.scala_main_count)) scale_line_outer_start = self.widget_diameter/2 scale_line_lenght = (self.widget_diameter / 2) - (self.widget_diameter / 20) # print(stepszize) for i in range(self.scala_main_count+1): my_painter.drawLine(scale_line_lenght, 0, scale_line_outer_start, 0) my_painter.rotate(steps_size)
def __init__(self, canvas, parent=None): super(ScaleBarItem, self).__init__(parent) self.canvas = canvas self.realsize = 100 black = QColor(Qt.black) black.setAlpha(150) white = QColor(Qt.white) white.setAlpha(150) blackpen = QPen(black, 4) whitepen = QPen(white, 8) self.pens = [whitepen, blackpen] self.whitepen = QPen(white, 1) self.blackbrush = QBrush(black) self.ticksize = 10 self.fontsize = 15 self.font = QFont() self.font.setPointSize(self.fontsize) self.font.setStyleHint(QFont.Times, QFont.PreferAntialias) self.font.setBold(True) self.metrics = QFontMetrics(self.font)
def paint(self, painter, option, widget): gradient = QRadialGradient(-3, -3, 10) if option.state & QStyle.State_Sunken: gradient.setCenter(3, 3) gradient.setFocalPoint(3, 3) gradient.setColorAt(0, QColor(Qt.yellow).light(120)) else: gradient.setColorAt(0, QColor(Qt.yellow).light(120)) painter.setBrush(gradient) painter.setPen(QPen(Qt.black, 0)) painter.drawRoundedRect(self.boundingRect(), 3, 3)
def __init__(self, parent=None, text=""): super(QGraphicsPathItem, self).__init__(parent) self.setAcceptHoverEvents(True) self.setPen(QPen(Qt.NoPen)) self.text = QGraphicsTextItem(self) layout = self.text.document().documentLayout() layout.documentSizeChanged.connect(self._onLayoutChanged) self._text = "" self._anchor = QPointF()
def __init__(self, pen=QPen(Qt.black), brush=QBrush(Qt.white), xData=[], yData=[], tooltip=None): OWCurve.__init__(self, xData, yData, tooltip=tooltip) self._data_polygon = self.polygon_from_data(xData, yData) self._polygon_item = QGraphicsPolygonItem(self) self.set_pen(pen) self.set_brush(brush)
def drawAsciiDump(self, painter, offset, row, size, row_data) : ascii_dump_left = self.asciiDumpLeft() #// i is the byte index chars_per_row = self.bytesPerRow() for i in range(0,chars_per_row) : index = offset + i if(index < size) : ch = row_data[i] drawLeft = ascii_dump_left + i * self.font_width printable = self.is_printable(ch) #// drawing a selected character if(self.isSelected(index)) : painter.fillRect( drawLeft, row, self.font_width, self.font_height, self.palette().highlight() ) painter.setPen(QPen(self.palette().highlightedText().color())) else : if printable: painter.setPen(QPen(self.palette().text().color())) else: painter.setPen(QPen(self.non_printable_text)) if printable: byteBuffer = str(ch) else: byteBuffer = str(self.unprintable_char) painter.drawText( drawLeft, row, self.font_width, self.font_height, Qt.AlignTop, byteBuffer ) else : break return
def paint(self, painter, option, index): filePath = self.model.filePath(index) fileName = self.model.fileName(index) r = option.rect img = QPixmap(filePath) if img.isNull(): # If not image file, try to load icon with QFileIconProvider # according to file type (extension name). # Currently not work as intended. fileInfo = self.model.fileInfo(index) icon = QFileIconProvider().icon(fileInfo) img = icon.pixmap(QSize(32, 32)) # Scale to height, align center horizontally, align bottom vertically. if img.height() > self.thumbHeight: img = img.scaledToHeight(self.thumbHeight, Qt.SmoothTransformation) if img.width() > self.thumbHeight: img = img.scaledToWidth(self.thumbHeight, Qt.SmoothTransformation) imgLeft = (self.width - img.width()) / 2 imgTop = self.thumbHeight - img.height() painter.drawPixmap(r.left() + imgLeft, r.top() + imgTop, img) rect = QRect(r.left(), r.top() + self.thumbHeight, self.width, self.nameHeight) flag = Qt.AlignHCenter | Qt.TextWrapAnywhere # get the bounding rectangle of the fileName bdRect = painter.boundingRect(rect, flag, fileName) if bdRect.height() < rect.height(): rect = bdRect if option.state & QStyle.State_Selected: painter.setBrush(self.parent().palette().highlight()) painter.drawRoundedRect(rect, 5, 5) pen = QPen(self.parent().palette().highlightedText(), 1, Qt.SolidLine) else: pen = QPen(self.parent().palette().text(), 1, Qt.SolidLine) painter.setPen(pen) painter.drawText(rect, flag, fileName)
def __updateStyleState(self): """ Update the arrows' brush, pen, ... based on it's state """ if self.isSelected(): color = self.__color.darker(150) pen = QPen(QColor(96, 158, 215), Qt.DashDotLine) pen.setWidthF(1.25) pen.setCosmetic(True) self.__shadow.setColor(pen.color().darker(150)) else: color = self.__color pen = QPen(Qt.NoPen) self.__shadow.setColor(QColor(63, 63, 63, 180)) self.__arrowItem.setBrush(color) self.__arrowItem.setPen(pen)
def addRectIndependencePearson(self, rect, x, y, w, h, xAttr_xVal, yAttr_yVal, actual, sum): xAttr, xVal = xAttr_xVal yAttr, yVal = yAttr_yVal expected = float(xVal*yVal)/float(sum) pearson = (actual - expected) / sqrt(expected) if pearson > 0: # if there are more examples that we would expect under the null hypothesis intPearson = floor(pearson) pen = QPen(QColor(0,0,255), 1); rect.setPen(pen) b = 255 r = g = 255 - intPearson*20 r = g = max(r, 55) # elif pearson < 0: intPearson = ceil(pearson) pen = QPen(QColor(255,0,0), 1) rect.setPen(pen) r = 255 b = g = 255 + intPearson*20 b = g = max(b, 55) else: pen = QPen(QColor(255,255,255), 1) r = g = b = 255 # white color = QColor(r,g,b) brush = QBrush(color); rect.setBrush(brush) if self.showCases and w > 6 and h > 6: if self.showInColor: if pearson > 0: c = QColor(0,0,255) else: c = QColor(255, 0,0) else: c = Qt.black for i in range(int(actual)): OWCanvasEllipse(self.canvas, random.randint(x+1, x + w-4), random.randint(y+1, y + h-4), 3, 3, penColor = c, brushColor = c, z = 100) if pearson > 0: pearson = min(pearson, 10) kvoc = 1 - 0.08 * pearson # if pearson in [0..10] --> kvoc in [1..0.2] else: pearson = max(pearson, -10) kvoc = 1 - 0.4*pearson self.addLines(x,y,w,h, kvoc, pen)
def updateColor(self): iconSize = self.iconSize() width = iconSize.width() height = iconSize.height() pixmap = QPixmap(iconSize) pixmap.fill(self._color) painter = QPainter() painter.begin(pixmap) painter.setPen(QPen(QColor("#777777"))) painter.drawRect(QRect(0, 0, width - 1, height - 1)) painter.end() self.setIcon(QIcon(pixmap))
def addCurve(self, curveId, curveName): curveId = str(curveId) if self.curves.get(curveId): return curveObject = Qwt.QwtPlotCurve(curveName) curveObject.attach(self) curveObject.setPen(QPen(self.colors[len(self.curves.keys()) % len(self.colors)])) self.curves[curveId] = { 'name': curveName, 'data': zeros(self.dataNumValuesSaved), 'object': curveObject, }
def paintEvent(self, event): """Paint over the widget to overlay its content.""" if not ACTIVATE_OPACITY: painter = QPainter() painter.begin(self) painter.setRenderHint(QPainter.TextAntialiasing, True) painter.setRenderHint(QPainter.Antialiasing, True) painter.fillRect(event.rect(), QBrush(QColor(226, 0, 0, 80))) painter.setPen(QPen(Qt.NoPen)) painter.end() super(SliderArea, self).paintEvent(event)
def __init__(self, edge_count=3, radius=20): super(PolygonItem, self).__init__() # edge_count çokgenin kaç kenarı olduğunu # radius ise çokgenin herhangi bir köşesinin # merkeze olan mesafesini belirliyor. # bir önceki görseldeki 'r' değeri self.edge_count = edge_count self.radius = radius self.polygon = self.calculate_polygon_points() self._pen = QPen(Qt.black) self._brush = QBrush(Qt.NoBrush)
def paintEvent(self, e): super(QFrame, self).paintEvent(e) p = QPainter(self) p.fillRect(self.contentsRect(), self.palette().button()) r = self.rect() offset = 1 if self.frameShadow() == self.Sunken else 0 pen = QPen(self.palette().buttonText(), 1) p.setPen(pen) p.drawRect(r.center().x() + offset - 4, r.center().y() + offset, 1, 1) p.drawRect(r.center().x() + offset, r.center().y() + offset, 1, 1) p.drawRect(r.center().x() + offset + 4, r.center().y() + offset, 1, 1) if self.hasFocus(): p.setPen(QPen(Qt.black, 0, Qt.SolidLine)) p.drawRect(0, 0, self.width() - 1, self.height() - 1) p.end()
def draw_needle(self): painter = QPainter(self) # painter.setRenderHint(QtGui.QPainter.HighQualityAntialiasing) painter.setRenderHint(QPainter.Antialiasing) # Koordinatenursprung in die Mitte der Flaeche legen painter.translate(self.width() / 2, self.height() / 2) painter.setPen(QPen(Qt.black, 2, Qt.SolidLine)) painter.setBrush(self.NeedleColor) painter.rotate(((self.value - self.value_offset - self.value_min) * self.scale_angle_size / (self.value_max - self.value_min)) + 90 + self.scale_angle_start_value) painter.drawConvexPolygon(self.value_needle[0])
def paint(self, p: QPainter): if not self.n1.parent.isVisible() or (self.n2 is not None and not self.n2.parent.isVisible()): return if self.__path is None: self.compute_path() c = Block.border_color if self.selected: c = c.lighter().lighter() if not self.__status: c = QColor(255, 100, 100, 180) p.setPen(QPen(c, 4)) p.drawPath(self.__path)
def __init__(self, start, end, pen=QPen(QColor(0, 0, 0, 255))): self.pen = pen QGraphicsItem.__init__(self) self.starting_line = QLineF(start, end) self.bounds = QRectF(start - (end - start), end + (end - start)) self.steps = 4 self.smooth = 50 self.dampen = 100 self.update_lines()
def __init__(self, x1, y1, x2, y2, parent=None, scene=None): QGraphicsItem.__init__(self, x1, y1, x2, y2, parent=parent, scene=scene) self.selec = False self.ctrlPressed = False self.selectWidth = 2.5 self.id = None self.parentSelected = False self.parentList = [] self.allItems = [] self.backupPen = self.pen() self.select_pen = QPen(QtCore.Qt.gray) self.select_pen.setStyle(QtCore.Qt.DotLine) self.select_pen.setWidthF(self.selectWidth)
def chart(self, v1, v2): self.data1.pop(0) self.data2.pop(0) self.data1.append(v1) self.data2.append(v2) self.scene1 = QGraphicsScene() self.scene2 = QGraphicsScene() self.setup_scene(self.scene1) self.setup_scene(self.scene2) path = QPainterPath() path.moveTo(0, -self.data1[0] / 6) for i in xrange(1, 100): path.lineTo(2 * (i + 1), -self.data1[i] / 6) self.scene1.addPath(path, QPen(QColor(0, 0, 255), 3)) path = QPainterPath() path.moveTo(0, -self.data2[0] / 6) for i in xrange(1, 100): path.lineTo(2 * (i + 1), -self.data2[i] / 6) self.scene2.addPath(path, QPen(QColor(0, 0, 255), 3)) self.ui.chart1.setScene(self.scene1) self.ui.chart2.setScene(self.scene2)
def __highlight(self, positions, color=None, cancel=False): cursor = QTextCursor(self.document()) modified = self.document().isModified() for position in positions: if position > self.get_position('eof'): return cursor.setPosition(position) cursor.movePosition(QTextCursor.NextCharacter, QTextCursor.KeepAnchor) charformat = cursor.charFormat() pen = QPen(Qt.NoPen) if cancel else QPen(color) charformat.setTextOutline(pen) cursor.setCharFormat(charformat) if cancel: charformat = QTextCharFormat() cursor.movePosition(QTextCursor.NextCharacter, QTextCursor.KeepAnchor) cursor.setCharFormat(charformat) cursor.clearSelection() self.setCurrentCharFormat(charformat) self.document().setModified(modified)
def paint(self, painter, option, index): painter.setFont(option.font) painter.setBrush(QBrush(Qt.black)) if option.state & QStyle.State_Selected: painter.setPen(QPen(Qt.white)) rect = QRect(option.rect) rect.setLeft(rect.left() + 4) rect.setTop(rect.top() + 4) rect.setWidth(rect.width() - 8) rect.setHeight(rect.height() - 8) painter.drawText(rect, Qt.Horizontal | Qt.TextWordWrap, forceString(index.data()))
def __init__(self): super().__init__() self.results = None self.classifier_names = [] self.colors = [] self._curve_data = {} box = gui.widgetBox(self.controlArea, "Plot") tbox = gui.widgetBox(box, "Target Class") tbox.setFlat(True) self.target_cb = gui.comboBox( tbox, self, "target_index", callback=self._on_target_changed, contentsLength=8) cbox = gui.widgetBox(box, "Classifiers") cbox.setFlat(True) self.classifiers_list_box = gui.listBox( cbox, self, "selected_classifiers", "classifier_names", selectionMode=QtGui.QListView.MultiSelection, callback=self._on_classifiers_changed) gui.checkBox(box, self, "display_convex_hull", "Show lift convex hull", callback=self._replot) self.plotview = pg.GraphicsView(background="w") self.plotview.setFrameStyle(QtGui.QFrame.StyledPanel) self.plot = pg.PlotItem() self.plot.getViewBox().setMenuEnabled(False) pen = QPen(self.palette().color(QtGui.QPalette.Text)) tickfont = QtGui.QFont(self.font()) tickfont.setPixelSize(max(int(tickfont.pixelSize() * 2 // 3), 11)) axis = self.plot.getAxis("bottom") axis.setTickFont(tickfont) axis.setPen(pen) axis.setLabel("P Rate") axis = self.plot.getAxis("left") axis.setTickFont(tickfont) axis.setPen(pen) axis.setLabel("TP Rate") self.plot.showGrid(True, True, alpha=0.1) self.plot.setRange(xRange=(0.0, 1.0), yRange=(0.0, 1.0)) self.plotview.setCentralItem(self.plot) self.mainArea.layout().addWidget(self.plotview) self.graphButton.clicked.connect(self.save_graph)
def loadItemPen(self, item): """ Creates a pen from saved settings. @param item ControlTreeItem instance @return QPen instance """ pen = self.settings.value('%s/pen' % self.itemName(item)) if pen.isValid(): pen = QPen(pen) else: pen = defaults.itemPen(item.name()) return pen
def __init__(self, parent): QGraphicsPathItem.__init__(self, parent) if not isinstance(parent, LinkItem): raise TypeError("'LinkItem' expected") self.setAcceptedMouseButtons(Qt.NoButton) self.__canvasLink = parent self.setAcceptHoverEvents(True) self.shadow = QGraphicsDropShadowEffect( blurRadius=5, color=QColor(SHADOW_COLOR), offset=QPointF(0, 0) ) self.normalPen = QPen(QBrush(QColor("#9CACB4")), 2.0) self.hoverPen = QPen(QBrush(QColor("#7D7D7D")), 2.1) self.setPen(self.normalPen) self.setGraphicsEffect(self.shadow) self.shadow.setEnabled(False) self.__hover = False
def _drawIcon(self, color=Qt.black): self.setForeground(QBrush(color)) if self.isRootNode: pixmap = QPixmap(20, 20) pixmap.fill(Qt.transparent) painter = QPainter() painter.begin(pixmap) pen = QPen(color) pen.setWidth(1) painter.setPen(pen) painter.setBrush(color) painter.setRenderHint(QPainter.Antialiasing) if not self.isExpanded: arrowRightPolygon = [QPoint(6,6), QPoint(6,14), QPoint(14, 10)] painter.drawPolygon(QPolygon(arrowRightPolygon)) else: arrowDownPolygon = [QPoint(6,6), QPoint(15,6), QPoint(10, 14)] painter.drawPolygon(QPolygon(arrowDownPolygon)) painter.end() self.setIcon(QIcon(pixmap))
def addLink(self, output, input): """ Add a link between `output` (:class:`OutputSignal`) and `input` (:class:`InputSignal`). """ if not compatible_channels(output, input): return if output not in self.source.output_channels(): raise ValueError("%r is not an output channel of %r" % \ (output, self.source)) if input not in self.sink.input_channels(): raise ValueError("%r is not an input channel of %r" % \ (input, self.sink)) if input.single: # Remove existing link if it exists. for s1, s2, _ in self.__links: if s2 == input: self.removeLink(s1, s2) line = QGraphicsLineItem(self) source_anchor = self.sourceNodeWidget.anchor(output) sink_anchor = self.sinkNodeWidget.anchor(input) source_pos = source_anchor.boundingRect().center() source_pos = self.mapFromItem(source_anchor, source_pos) sink_pos = sink_anchor.boundingRect().center() sink_pos = self.mapFromItem(sink_anchor, sink_pos) line.setLine(source_pos.x(), source_pos.y(), sink_pos.x(), sink_pos.y()) pen = QPen(Qt.black, 4) pen.setCapStyle(Qt.RoundCap) line.setPen(pen) self.__links.append(_Link(output, input, line))
def paintEvent(self, event): """ Draw the QImage on screen. """ textPosX,textPosY = 10,200 painter = QPainter(self) painter.drawImage(painter.viewport(), self._image) innerFont = QFont() innerFont.setPointSize(12) painter.setFont(innerFont) painter.setPen(QColor(QtCore.Qt.white)) painter.drawText(10,180,'Current Action:') painter.drawText(10,200,self._currentMovement) self.drawMoreText(painter,10,300,['Control Buttons:', 'w,s - Walking Forwards/Backwards', 'q,e - Walking Left/Right', 'a,d - Turning Left/Right', 'x - stopping', 'Space - standing up', 'Ctrl - crouch', 'Escape,Enter - restMode, wakeUp', '1 - Grabbing small', '2 - Grabbing large', '3 - Grabbing Kuscheltier', '4 - Grabbing bottle']) self.drawMoreText(painter,self.width()-300-25,300,['Dialog Control:({})'.format(self._attitude), 'u - Introduction', 'i - Ask for object', 'h - Object is Somat', 'j - Object is Muesli', 'k - Object is Bottle', 'l - Object is Kuscheltier', 'n - Wertstoff', 'm - Altpapier', 'o - Ask for help', 'z - Ask proband to repeat sentence', 'p - Repeat task', '0(Null) - construct initial state', 't - Goodbye', 'b - thanks', '# - Start free Speech(PopUp)']) self.drawMoreText(painter,100,50,['Movement Speeds','Forward: {}'.format(self._currentSpeeds['Forward']),'Leftward: {}'.format(self._currentSpeeds['Leftward']),'CounterClockwise: {}'.format(self._currentSpeeds['CounterClockwise'])]) pen = QPen() pen.setColor(QColor(QtCore.Qt.red)) pen.setWidth(5) painter.setPen(pen) painter.drawEllipse(20,15,60,30) pen.setColor(QColor(QtCore.Qt.blue)) painter.setPen(pen) painter.drawPolygon(self.rotatePolygon(arrowPolygon,math.degrees(self._motionProxy.getAngles('HeadYaw',True)[0]),[30,20]))
def draw(self): """ Draws connection. """ self.calculateRoute() if not self.routeIsValid(): return painter = QPainter(self) #logging.debug(self.__class__.__name__ +": draw()") if self._selectedFlag: # Selected framePen = QPen(self.SELECT_COLOR) framePen.setWidth(self.SELECTED_FRAME_WIDTH) else: #self.select(False) framePen = QPen(Qt.NoPen) #if hasattr(QPainter, 'Antialiasing'): if self.zoom() > 30: painter.setRenderHint(QPainter.Antialiasing) # painter.setPen(Qt.black) # for thisP in self._route: # painter.drawEllipse(self.mapFromParent(thisP), self.CONNECTION_THICKNESS * self.zoomFactor(), self.CONNECTION_THICKNESS* self.zoomFactor()) painter.setPen(framePen) for i in range(0, len(self._route) - 1): #self.drawLineSection(painter, route[i], route[i + 1], self._cornerTypes[i], self._cornerTypes[i + 1]) self.drawSection(painter, i)
def drawForeground(self, painter, rect): QGraphicsView.drawForeground(self, painter, rect) if self._sel_accepted: painter.save() painter.resetTransform() rect = self._sel_rect viewport = self.viewport() option = QStyleOptionRubberBand() option.initFrom(viewport) option.rect = self._sel_rect option.shape = QRubberBand.Rectangle mask = QStyleHintReturnMask() self.style().drawControl(QStyle.CE_RubberBand, option, painter, viewport) painter.restore() elif self._div_accepted: painter.save() painter.resetTransform() line = self._div_line viewport = self.viewport() palette = viewport.palette() pen = QPen(Qt.DashDotLine) pen.setWidth(2) pen.setColor(Qt.red) painter.setPen(pen) painter.drawLine(self._div_line) painter.restore()