def shape(self):
"""Defines a 4-gon for mouse selection/hovering, larger than the drawn fixture"""
# FIXME: Coordinate scale doesn't work
# width, height = (self.canvas.coordinate_scale * self.width, self.canvas.coordinate_scale * self.height)
width, height = (self.width, self.height)
path = QtGui.QPainterPath()
line = QtCore.QLineF(0, 0, width, height)
offset1 = line.normalVector().unitVector()
if self.isSelected():
offset1.setLength(11)
else:
offset1.setLength(9)
ol1 = QtCore.QLineF(0, 0, width, height)
ol1.translate(offset1.dx(), offset1.dy())
ol2 = QtCore.QLineF(0, 0, width, height)
ol2.translate(-offset1.dx(), -offset1.dy())
p = QtGui.QPolygonF([
QtCore.QPoint(ol1.x1(), ol1.y1()),
QtCore.QPoint(ol1.x2(), ol1.y2()),
QtCore.QPoint(ol2.x2(), ol2.y2()),
QtCore.QPoint(ol2.x1(), ol2.y1())
])
path.addPolygon(p)
path.closeSubpath()
return path
def adjust(self):
"""
Recompute where the line is pointing.
"""
if not self.source:
return
if self.dest:
line = QtCore.QLineF(self.mapFromItem(self.source, self.source.width, 0), self.mapFromItem(self.dest, 0, 0))
else:
line = QtCore.QLineF(self.mapFromItem(self.source, self.source.width, 0), self.floatingDestinationPoint)
length = line.length()
if length == 0.0:
return
radius = 5
sourceOffset = (self.sourcePort * 10) + (self.sourcePort * 10) + 35 + radius
destOffset = (self.destPort * 10) + (self.destPort * 10) + 35 + radius
self.prepareGeometryChange()
self.sourcePoint = line.p1() + QtCore.QPointF(radius, sourceOffset)
if self.dest:
self.destPoint = line.p2() + QtCore.QPointF(-radius, destOffset)
else:
self.destPoint = line.p2()
def paint(self, painter, option, widget=None):
"""Paints the node connection.
@todo: get rid of arrow size, put it in model
"""
arrow_size = 10.0
self.get_painter(painter)
p1 = self.get_center_point(self.end)
p2 = self.get_center_point(self.start)
line = QtCore.QLineF(p1, p2)
line.setLength(line.length() - self.start.sceneBoundingRect().width() / 2)
p1 = line.p2()
p2 = line.p1()
line = QtCore.QLineF(p1, p2)
line.setLength(line.length() - self.end.sceneBoundingRect().width() / 2)
p1 = line.p2()
p2 = line.p1()
line = QtCore.QLineF(p1, p2)
self.setLine(line)
angle = 0
if self.line().length() != 0:
angle = math.acos(self.line().dx() / self.line().length())
if self.line().dy() >= 0:
angle = (math.pi * 2.0) - angle
arrowP1 = self.line().p1() + QtCore.QPointF(math.sin(angle + math.pi / 3.0) * arrow_size,
math.cos(angle + math.pi / 3.0) * arrow_size)
arrowP2 = self.line().p1() + QtCore.QPointF(math.sin(angle + math.pi - math.pi / 3.0) * arrow_size,
math.cos(angle + math.pi - math.pi / 3.0) * arrow_size)
self.arrowHead.clear()
for point in [self.line().p1(), arrowP1, arrowP2]:
self.arrowHead.append(point)
painter.drawLine(self.line())
painter.drawPolygon(self.arrowHead)
def adjust(self):
"""
Recompute where the line is pointing.
"""
if not self.source:
return
if self.dest:
line = QtCore.QLineF(self.mapFromItem(self.source, 0, 0),
self.mapFromItem(self.dest, 0, 0))
else:
line = QtCore.QLineF(self.mapFromItem(self.source, 0, 0),
self.floatingDestinationPoint)
length = line.length()
if length == 0.0:
return
self.prepareGeometryChange()
self.sourcePoint = line.p1() + QtCore.QPointF(
0, (self.sourceDrawNode().height / 2) + 1)
if self.dest:
self.destPoint = line.p2() - QtCore.QPointF(
0,
self.destDrawNode().height / 2)
self.destPoint += QtCore.QPointF(self.horizontalConnectionOffset,
0.0)
else:
self.destPoint = line.p2()
def __init__(self, line_or_point, follows=None):
super(GuideLine, self).__init__(follows)
if isinstance(line_or_point, QtCore.QLineF):
self.line = line_or_point
elif follows is not None:
self.line = QtCore.QLineF(self.prevGuide.endPos(), line_or_point)
else:
self.line = QtCore.QLineF(QtCore.QPointF(0, 0), line_or_point)
def timerEvent(self):
# Don't move too far away.
lineToCenter = QtCore.QLineF(QtCore.QPointF(0, 0), self.mapFromScene(0, 0))
if lineToCenter.length() > 150:
angleToCenter = math.acos(lineToCenter.dx() / lineToCenter.length())
if lineToCenter.dy() < 0:
angleToCenter = Mouse.TwoPi - angleToCenter;
angleToCenter = Mouse.normalizeAngle((Mouse.Pi - angleToCenter) + Mouse.Pi / 2)
if angleToCenter < Mouse.Pi and angleToCenter > Mouse.Pi / 4:
# Rotate left.
self.angle += [-0.25, 0.25][self.angle < -Mouse.Pi / 2]
elif angleToCenter >= Mouse.Pi and angleToCenter < (Mouse.Pi + Mouse.Pi / 2 + Mouse.Pi / 4):
# Rotate right.
self.angle += [-0.25, 0.25][self.angle < Mouse.Pi / 2]
elif math.sin(self.angle) < 0:
self.angle += 0.25
elif math.sin(self.angle) > 0:
self.angle -= 0.25
# Try not to crash with any other mice.
dangerMice = self.scene().items(QtGui.QPolygonF([self.mapToScene(0, 0),
self.mapToScene(-30, -50),
self.mapToScene(30, -50)]))
for item in dangerMice:
if item is self:
continue
lineToMouse = QtCore.QLineF(QtCore.QPointF(0, 0), self.mapFromItem(item, 0, 0))
angleToMouse = math.acos(lineToMouse.dx() / lineToMouse.length())
if lineToMouse.dy() < 0:
angleToMouse = Mouse.TwoPi - angleToMouse
angleToMouse = Mouse.normalizeAngle((Mouse.Pi - angleToMouse) + Mouse.Pi / 2)
if angleToMouse >= 0 and angleToMouse < Mouse.Pi / 2:
# Rotate right.
self.angle += 0.5
elif angleToMouse <= Mouse.TwoPi and angleToMouse > (Mouse.TwoPi - Mouse.Pi / 2):
# Rotate left.
self.angle -= 0.5
# Add some random movement.
if len(dangerMice) > 1 and (QtCore.qrand() % 10) == 0:
if QtCore.qrand() % 1:
self.angle += (QtCore.qrand() % 100) / 500.0
else:
self.angle -= (QtCore.qrand() % 100) / 500.0
self.speed += (-50 + QtCore.qrand() % 100) / 100.0
dx = math.sin(self.angle) * 10
self.mouseEyeDirection = [dx / 5, 0.0][QtCore.qAbs(dx / 5) < 1]
self.rotate(dx)
self.setPos(self.mapToParent(0, -(3 + math.sin(self.speed) * 3)))
def handleMoved(self, handle, position):
position = self.cropBox.view.transform().map(position)
line = self.line()
p1 = line.p1()
p2 = line.p2()
if handle is self.handle1:
self.setLine(QtCore.QLineF(position, p2))
elif handle is self.handle2:
self.setLine(QtCore.QLineF(p1, position))
else:
raise Exception('unknown handle %s' % handle)
def paint(self, painter, option, widget=None):
if (self.myStartItem.collidesWithItem(self.myEndItem)):
return
myStartItem = self.myStartItem
myEndItem = self.myEndItem
myColor = self.myColor
myPen = self.pen()
myPen.setColor(self.myColor)
arrowSize = 20.0
painter.setPen(myPen)
painter.setBrush(self.myColor)
centerLine = QtCore.QLineF(myStartItem.pos(), myEndItem.pos())
endPolygon = myEndItem.polygon()
p1 = endPolygon.at(0) + myEndItem.pos()
intersectPoint = QtCore.QPointF()
for i in endPolygon:
p2 = i + myEndItem.pos()
polyLine = QtCore.QLineF(p1, p2)
intersectType, intersectPoint = polyLine.intersect(centerLine)
if intersectType == QtCore.QLineF.BoundedIntersection:
break
p1 = p2
self.setLine(QtCore.QLineF(intersectPoint, myStartItem.pos()))
line = self.line()
angle = math.acos(line.dx() / line.length())
if line.dy() >= 0:
angle = (math.pi * 2.0) - angle
arrowP1 = line.p1() + QtCore.QPointF(math.sin(angle + math.pi / 3.0) * arrowSize,
math.cos(angle + math.pi / 3) * arrowSize)
arrowP2 = line.p1() + QtCore.QPointF(math.sin(angle + math.pi - math.pi / 3.0) * arrowSize,
math.cos(angle + math.pi - math.pi / 3.0) * arrowSize)
self.arrowHead.clear()
for point in [line.p1(), arrowP1, arrowP2]:
self.arrowHead.append(point)
painter.drawLine(line)
painter.drawPolygon(self.arrowHead)
if self.isSelected():
painter.setPen(QtGui.QPen(myColor, 1, QtCore.Qt.DashLine))
myLine = QtCore.QLineF(line)
myLine.translate(0, 4.0)
painter.drawLine(myLine)
myLine.translate(0,-8.0)
painter.drawLine(myLine)
def _draw_grid(self, painter, rect, pen, grid_size):
lines = []
left = int(rect.left()) - (int(rect.left()) % grid_size)
top = int(rect.top()) - (int(rect.top()) % grid_size)
x = left
while x < rect.right():
x += grid_size
lines.append(QtCore.QLineF(x, rect.top(), x, rect.bottom()))
y = top
while y < rect.bottom():
y += grid_size
lines.append(QtCore.QLineF(rect.left(), y, rect.right(), y))
painter.setPen(pen)
painter.drawLines(lines)
def drawBackground(self, painter, rect):
oldTransform = painter.transform()
painter.fillRect(rect, self._backgroundColor)
left = int(rect.left()) - (int(rect.left()) % self._gridSizeFine)
top = int(rect.top()) - (int(rect.top()) % self._gridSizeFine)
# Draw horizontal fine lines
gridLines = []
painter.setPen(self._gridPenS)
y = float(top)
while y < float(rect.bottom()):
gridLines.append(QtCore.QLineF(rect.left(), y, rect.right(), y))
y += self._gridSizeFine
painter.drawLines(gridLines)
# Draw vertical fine lines
gridLines = []
painter.setPen(self._gridPenS)
x = float(left)
while x < float(rect.right()):
gridLines.append(QtCore.QLineF(x, rect.top(), x, rect.bottom()))
x += self._gridSizeFine
painter.drawLines(gridLines)
# Draw thick grid
left = int(rect.left()) - (int(rect.left()) % self._gridSizeCourse)
top = int(rect.top()) - (int(rect.top()) % self._gridSizeCourse)
# Draw vertical thick lines
gridLines = []
painter.setPen(self._gridPenL)
x = left
while x < rect.right():
gridLines.append(QtCore.QLineF(x, rect.top(), x, rect.bottom()))
x += self._gridSizeCourse
painter.drawLines(gridLines)
# Draw horizontal thick lines
gridLines = []
painter.setPen(self._gridPenL)
y = top
while y < rect.bottom():
gridLines.append(QtCore.QLineF(rect.left(), y, rect.right(), y))
y += self._gridSizeCourse
painter.drawLines(gridLines)
return super(GraphView, self).drawBackground(painter, rect)
def paint(self, painter, option, widget):
if not self.source() or not self.dest():
return
# Draw the line itself.
line = QtCore.QLineF(self.sourcePoint, self.destPoint)
if line.length() == 0.0:
return
painter.setPen(QtGui.QPen(QtCore.Qt.black, 1, QtCore.Qt.SolidLine, QtCore.Qt.RoundCap, QtCore.Qt.RoundJoin))
painter.drawLine(line)
# Draw the arrows if there's enough room.
angle = math.acos(line.dx() / line.length())
if line.dy() >= 0:
angle = Edge.TwoPi - angle
sourceArrowP1 = self.sourcePoint + QtCore.QPointF(math.sin(angle + Edge.Pi / 3) * self.arrowSize,
math.cos(angle + Edge.Pi / 3) * self.arrowSize)
sourceArrowP2 = self.sourcePoint + QtCore.QPointF(math.sin(angle + Edge.Pi - Edge.Pi / 3) * self.arrowSize,
math.cos(angle + Edge.Pi - Edge.Pi / 3) * self.arrowSize);
destArrowP1 = self.destPoint + QtCore.QPointF(math.sin(angle - Edge.Pi / 3) * self.arrowSize,
math.cos(angle - Edge.Pi / 3) * self.arrowSize)
destArrowP2 = self.destPoint + QtCore.QPointF(math.sin(angle - Edge.Pi + Edge.Pi / 3) * self.arrowSize,
math.cos(angle - Edge.Pi + Edge.Pi / 3) * self.arrowSize)
painter.setBrush(QtCore.Qt.black)
painter.drawPolygon(QtGui.QPolygonF([line.p1(), sourceArrowP1, sourceArrowP2]))
painter.drawPolygon(QtGui.QPolygonF([line.p2(), destArrowP1, destArrowP2]))
def mouseMoveEvent(self, event):
if self._connectLine:
newLine = QtCore.QLineF(self._connectLine.line().p1(),
self.mapToScene(event.pos()))
self._connectLine.setLine(newLine)
else:
QtGui.QGraphicsView.mouseMoveEvent(self, event)
def paint(self, painter, option, widget):
"""
Draw a line with an arrow at the end.
"""
if not self.source: # or not self.dest:
return
# Draw the line
line = QtCore.QLineF(self.sourcePoint, self.destPoint)
if line.length() == 0.0:
return
painter.setPen(
QtGui.QPen(QtCore.Qt.white, 1, QtCore.Qt.SolidLine,
QtCore.Qt.RoundCap, QtCore.Qt.RoundJoin))
painter.drawLine(line)
# Draw the arrows if there's enough room.
angle = math.acos(line.dx() / line.length())
if line.dy() >= 0:
angle = DrawEdge.TwoPi - angle
destArrowP1 = self.destPoint + QtCore.QPointF(
math.sin(angle - math.pi / 3) * self.arrowSize,
math.cos(angle - math.pi / 3) * self.arrowSize)
destArrowP2 = self.destPoint + QtCore.QPointF(
math.sin(angle - math.pi + math.pi / 3) * self.arrowSize,
math.cos(angle - math.pi + math.pi / 3) * self.arrowSize)
painter.setBrush(QtCore.Qt.white)
painter.drawPolygon(
QtGui.QPolygonF([line.p2(), destArrowP1, destArrowP2]))
def mousePressEvent(self, mouseEvent):
if (mouseEvent.button() != QtCore.Qt.LeftButton):
return
if self.myMode == self.InsertItem:
item = DiagramItem(self.myItemType, self.myItemMenu)
item.setBrush(self.myItemColor)
self.addItem(item)
item.setPos(mouseEvent.scenePos())
self.itemInserted.emit(item)
elif self.myMode == self.InsertLine:
self.line = QtGui.QGraphicsLineItem(QtCore.QLineF(mouseEvent.scenePos(),
mouseEvent.scenePos()))
self.line.setPen(QtGui.QPen(self.myLineColor, 2))
self.addItem(self.line)
elif self.myMode == self.InsertText:
textItem = DiagramTextItem()
textItem.setFont(self.myFont)
textItem.setTextInteractionFlags(QtCore.Qt.TextEditorInteraction)
textItem.setZValue(1000.0)
textItem.lostFocus.connect(self.editorLostFocus)
textItem.selectedChange.connect(self.itemSelected)
self.addItem(textItem)
textItem.setDefaultTextColor(self.myTextColor)
textItem.setPos(mouseEvent.scenePos())
self.textInserted.emit(textItem)
super(DiagramScene, self).mousePressEvent(mouseEvent)
def drawArcTo(self, center, endPoint):
"""
En cours de tracé, on recalcule les différents angles utiles.
Pas mal de cas à gérer, et la complication du passage brutal de 0 à 360.
Ensuite on trace l'arc.
"""
self.state['lastPoint'] = QtCore.QPointF(endPoint)
rayon = QtCore.QLineF(center, endPoint)
self.path = QtGui.QPainterPath()
angle = rayon.angle()
if angle - self.lastAngle > 300:
self.minAngle = self.minAngle + 360.0
self.maxAngle = self.maxAngle + 360.0
if angle - self.lastAngle < -300:
self.minAngle = self.minAngle - 360.0
self.maxAngle = self.maxAngle - 360.0
if angle < self.minAngle:
self.minAngle = angle
self.startPoint = self.state['lastPoint']
if angle > self.maxAngle:
self.maxAngle = angle
endAngle = self.maxAngle - self.minAngle
self.path.moveTo(self.startPoint)
self.path.arcTo(self.rectangle, self.minAngle, endAngle)
self.pathItem.setPath(self.path)
self.lastAngle = angle
return self.pathItem
def mouseMoveEvent(self, event):
if QtCore.QLineF(QtCore.QPointF(event.screenPos()), QtCore.QPointF(event.buttonDownScreenPos(QtCore.Qt.LeftButton))).length() < QtGui.QApplication.startDragDistance():
return
drag = QtGui.QDrag(event.widget())
mime = QtCore.QMimeData()
drag.setMimeData(mime)
ColorItem.n += 1
if ColorItem.n > 2 and QtCore.qrand() % 3 == 0:
image = QtGui.QImage(':/images/head.png')
mime.setImageData(image)
drag.setPixmap(QtGui.QPixmap.fromImage(image).scaled(30,40))
drag.setHotSpot(QtCore.QPoint(15, 30))
else:
mime.setColorData(self.color)
mime.setText("#%02x%02x%02x" % (self.color.red(), self.color.green(), self.color.blue()))
pixmap = QtGui.QPixmap(34, 34)
pixmap.fill(QtCore.Qt.white)
painter = QtGui.QPainter(pixmap)
painter.translate(15, 15)
painter.setRenderHint(QtGui.QPainter.Antialiasing)
self.paint(painter, None, None)
painter.end()
pixmap.setMask(pixmap.createHeuristicMask())
drag.setPixmap(pixmap)
drag.setHotSpot(QtCore.QPoint(15, 20))
drag.exec_()
self.setCursor(QtCore.Qt.OpenHandCursor)
def setupGuides(self):
x = 0
y = 20
self.qtGuide1 = GuideCircle(QtCore.QRectF(x, y, 260, 260), -36, 342)
GuideLine(QtCore.QPointF(x + 240, y + 268), self.qtGuide1)
GuideLine(QtCore.QPointF(x + 265, y + 246), self.qtGuide1)
GuideLine(QtCore.QPointF(x + 158, y + 134), self.qtGuide1)
GuideLine(QtCore.QPointF(x + 184, y + 109), self.qtGuide1)
GuideLine(QtCore.QPointF(x + 160, y + 82), self.qtGuide1)
GuideLine(QtCore.QPointF(x + 77, y + 163), self.qtGuide1)
GuideLine(QtCore.QPointF(x + 100, y + 190), self.qtGuide1)
GuideLine(QtCore.QPointF(x + 132, y + 159), self.qtGuide1)
GuideLine(QtCore.QPointF(x + 188, y + 211), self.qtGuide1)
GuideCircle(QtCore.QRectF(x + 30, y + 30, 200, 200), -30, 336, GuideCircle.CW, self.qtGuide1)
GuideLine(QtCore.QPointF(x + 238, y + 201), self.qtGuide1)
y = 30
self.qtGuide2 = GuideCircle(QtCore.QRectF(x + 30, y + 30, 200, 200), 135, 270, GuideCircle.CCW)
GuideLine(QtCore.QPointF(x + 222, y + 38), self.qtGuide2)
GuideCircle(QtCore.QRectF(x, y, 260, 260), 135, 270, GuideCircle.CW, self.qtGuide2)
GuideLine(QtCore.QPointF(x + 59, y + 59), self.qtGuide2)
x = 115
y = 10
self.qtGuide3 = GuideLine(QtCore.QLineF(x, y, x + 30, y))
GuideLine(QtCore.QPointF(x + 30, y + 170), self.qtGuide3)
GuideLine(QtCore.QPointF(x, y + 170), self.qtGuide3)
GuideLine(QtCore.QPointF(x, y), self.qtGuide3)
self.qtGuide1.setFence(QtCore.QRectF(0, 0, 800, 600))
self.qtGuide2.setFence(QtCore.QRectF(0, 0, 800, 600))
self.qtGuide3.setFence(QtCore.QRectF(0, 0, 800, 600))
def adjust(self):
if not self.source() or not self.dest():
return
line = QtCore.QLineF(self.mapFromItem(self.source(), 0, 0), self.mapFromItem(self.dest(), 0, 0))
self.sourcePoint = line.p1() #+ edgeOffset
self.destPoint = line.p2() #- edgeOffset
def move(self, item, dest, moveSpeed):
walkLine = QtCore.QLineF(item.getGuidedPos(), dest)
if moveSpeed >= 0 and walkLine.length() > moveSpeed:
# The item is too far away from it's destination point so we move
# it towards it instead.
dx = walkLine.dx()
dy = walkLine.dy()
if abs(dx) > abs(dy):
# Walk along x-axis.
if dx != 0:
d = moveSpeed * dy / abs(dx)
if dx > 0:
s = moveSpeed
else:
s = -moveSpeed
dest.setX(item.getGuidedPos().x() + s)
dest.setY(item.getGuidedPos().y() + d)
else:
# Walk along y-axis.
if dy != 0:
d = moveSpeed * dx / abs(dy)
if dy > 0:
s = moveSpeed
else:
s = -moveSpeed
dest.setX(item.getGuidedPos().x() + d)
dest.setY(item.getGuidedPos().y() + s)
item.setGuidedPos(dest)
def mouseMoveEvent(self, event):
if self.rectangleFlag == True or self.ellipseFlag == True:
self.movePointX = event.x() - self.pointX
self.movePointY = event.y() - self.pointY
if self.lineFlag[0] == True and self.lineFlag[1] == True:
newLine = QtCore.QLineF(self.line.line().p1(), event.pos())
self.line.setLine(newLine)
super(ScreenCutView, self).mouseMoveEvent(event)
def refresh(self):
"""Update location of edge (start and end points)"""
node1, node2 = self.edge
pos1 = self.mapFromScene(node1.schematic_item.scenePos())
pos2 = self.mapFromScene(node2.schematic_item.scenePos())
centre = (pos1 + pos2) / 2
self.toward_point = (pos2 + centre) / 2
self.setLine(QtCore.QLineF(pos1, pos2))
def update_position(self):
"""Updates the line when the position of the start and end node
are changed.
@todo: rename to update_line
@todo: implement model
"""
line = QtCore.QLineF(self.get_pos(self.start), self.get_pos(self.end))
self.setLine(line)
def __init__(self, parent):
QtGui.QGraphicsItem.__init__(self, parent=parent)
self.p1 = QtCore.QPointF()
self.p2 = QtCore.QPointF()
self.line = QtCore.QLineF(self.p1, self.p2)
self.setOrientation(0., 0.)
self.setZValue(10000)
def paint(self, painter, option, widget):
if not self.source() or not self.dest():
return
# Draw the line itself.
if self.ColorOnlySelectedNodesFlag:
if not(self.ColorEdgesFlag):
return
line = QtCore.QLineF(self.sourcePoint, self.destPoint)
# Should FIX the thickness values!!! fix me
painter.save()
"""
Painting the edge colors based on various factors
Not painting the edges if they are below certain threshold
Painting the edges to be black or just based on their colors
Painting highlighted colormaps
edge Thickness is a function of the weight of the edges
drawing z values so that they do not overalpp with others
"""
if self.ForCommunities:
painter.setPen(QtGui.QPen(self.communtiyColor1 ,self.communityWeight , QtCore.Qt.SolidLine, QtCore.Qt.RoundCap, QtCore.Qt.RoundJoin))
painter.drawLine(line)
else:
if self.ColorMap:
if self.EdgeThreshold < self.weight:
if not(self.ColorEdgesFlag):
self.setZValue(1)
self.EdgeColor.setAlpha(70)
painter.setPen(QtGui.QPen(self.EdgeColor ,self.edgeThickness , QtCore.Qt.SolidLine, QtCore.Qt.RoundCap, QtCore.Qt.RoundJoin))
painter.drawLine(line)
else:
self.setZValue(2)
if not(self.HighlightedColorMap):
# pointer to green
painter.setPen(QtGui.QPen(QtCore.Qt.darkGreen, self.edgeThickness , QtCore.Qt.SolidLine, QtCore.Qt.RoundCap, QtCore.Qt.RoundJoin))
else:
self.EdgeColor.setAlpha(255)
painter.setPen(QtGui.QPen(self.EdgeColor, self.thickHighlightedEdges , QtCore.Qt.SolidLine, QtCore.Qt.RoundCap, QtCore.Qt.RoundJoin))
painter.drawLine(line)
else:
if self.EdgeThreshold < self.weight:
if not(self.ColorEdgesFlag):
self.setZValue(1)
painter.setPen(QtGui.QPen(self.EdgeColor ,self.edgeThickness , QtCore.Qt.SolidLine, QtCore.Qt.RoundCap, QtCore.Qt.RoundJoin))
painter.drawLine(line)
else:
self.setZValue(2)
if not(self.HighlightedColorMap):
painter.setPen(QtGui.QPen(QtCore.Qt.darkGreen, self.edgeThickness , QtCore.Qt.SolidLine, QtCore.Qt.RoundCap, QtCore.Qt.RoundJoin))
else:
painter.setPen(QtGui.QPen(self.EdgeColor, self.thickHighlightedEdges , QtCore.Qt.SolidLine, QtCore.Qt.RoundCap, QtCore.Qt.RoundJoin))
painter.drawLine(line)
painter.restore()
def updateDisplay(self, x, y, w, time):
"""docstring for updateDisplay"""
self.current_time = time
x_, y_ = self.robot_position
self.robot_position = (x*100.0, y*100.0)
self.robot_rotation = degrees(w)
if x_ != x*100.0 and y_ != y*100.0:
self.lines.append(QtCore.QLineF(x_, y_, x*100.0, y*100.0))
self.update()
def animate(self):
if not self.targetPos.isNull():
displacement = QtCore.QLineF(self.pos, self.targetPos)
newPosition = displacement.pointAt(0.25)
if displacement.length() <= 1.0:
self.pos = self.targetPos
self.targetPos = QtCore.QPointF()
else:
self.pos = newPosition
return True
return False
def mousePressEvent(self, event):
item = self.scene().itemAt(self.mapToScene(event.pos()))
if event.button() == QtCore.Qt.RightButton:
event.ignore()
elif item and item.type() == StepPort.Type:
centre = item.boundingRect().center()
self._connectSourceNode = item
self._connectLine = ArrowLine(
QtCore.QLineF(item.mapToScene(centre),
self.mapToScene(event.pos())))
self.scene().addItem(self._connectLine)
else:
QtGui.QGraphicsView.mousePressEvent(self, event)
self._selectionStartPos = event.pos()
def paint(self, painter, option, widget):
midPoint = (self._destPoint + self._sourcePoint) / 2
# Draw the line itself.
line = QtCore.QLineF(self._sourcePoint, self._destPoint)
if line.length() == 0.0:
return
painter.setPen(
QtGui.QPen(QtCore.Qt.black, 1, QtCore.Qt.DashLine,
QtCore.Qt.RoundCap, QtCore.Qt.RoundJoin))
painter.drawLine(line)
painter.drawPixmap(midPoint.x() - 8, midPoint.y() - 8, self._pixmap)
def generate_bezier_points(self):
x_distance = self.end_point.x() - self.start_point.x()
length = QtCore.QLineF(self.start_point, self.end_point).length()
offset = math.copysign(length, x_distance) / 3.0
bezier_points = [
QtCore.QPointF(self.start_point),
QtCore.QPointF(self.start_point.x() + offset,
self.start_point.y()),
QtCore.QPointF(self.end_point.x() - offset, self.end_point.y()),
QtCore.QPointF(self.end_point)
]
return bezier_points
def adjust(self): if not self.source() or not self.dest(): return line = QtCore.QLineF(self.mapFromItem(self.source(), 0, 0), self.mapFromItem(self.dest(), 0, 0)) length = line.length() if length == 0.0: return edgeOffset = QtCore.QPointF((line.dx() * 10) / length, (line.dy() * 10) / length) self.prepareGeometryChange() self.sourcePoint = line.p1() + edgeOffset self.destPoint = line.p2() - edgeOffset
