def mouseMoveEvent(self, event):
if self.dragEnable == True:
rf = self.getR(event.scenePos())
self.translateR(rf)
self._r = rf
else:
QGraphicsItemGroup.mouseMoveEvent(self, event)
def __init__(self, parent, pos, angle, pit=False):
QGraphicsItemGroup.__init__(self, parent)
AbstractSector.__init__(self, pos, angle)
self.setZValue(3)
self.black = QGraphicsPathItem(self)
self.white = QGraphicsPathItem(self)
start = 3 * (_trackWidth / 2)
end = -start - abs(_pitDistance if pit else 0)
rowdelta = _trackWidth / 4
for item, y in [(self.black, -rowdelta),
(self.white, rowdelta)]:
item.setCacheMode(QGraphicsPathItem.DeviceCoordinateCache)
self.addToGroup(item)
path = QPainterPath()
path.moveTo(start, y)
path.lineTo(end, y)
path.moveTo(end, -y)
path.lineTo(start, -y)
item.setPath(path)
pen = QPen(Qt.black, _trackWidth / 2)
pen.setCapStyle(Qt.FlatCap)
pen.setDashPattern([1, 1])
self.black.setPen(QPen(pen))
pen.setColor(Qt.white)
self.white.setPen(pen)
def __init__(self, **kwarg):
QGraphicsItemGroup.__init__(self)
if kwarg.has_key('movable'):
self.setFlag(QGraphicsItem.ItemIsMovable, kwarg['movable'])
del kwarg['movable']
if kwarg.has_key('toolTip'):
self.setToolTip(kwarg['toolTip'])
del kwarg['toolTip']
self._setup(**kwarg)
def __init__(self, sectors, colorfunc):
QGraphicsItemGroup.__init__(self)
self.setHandlesChildEvents(False)
sectors = self._sectorsToItems(sectors, colorfunc)
self.__sectors = []
self.__totalLength = 0
for s in sectors:
self.addToGroup(s)
if isinstance(s, FinishLine):
self.__offset = self.__totalLength
elif s.length() > 0:
s.setSectorId(len(self.__sectors))
self.__sectors.append(s)
self.__totalLength += s.length()
def __init__(self, parent, sectype, *args):
QGraphicsItemGroup.__init__(self, parent)
self.setHandlesChildEvents(False)
self.setZValue(2)
self.pit = sectype(self, *args, pit=True)
self.regular = sectype(self, *args, pit=False)
self.addToGroup(self.pit)
self.addToGroup(self.regular)
# act as a proxy for almost all methods
self.enableHoverEffect = self.regular.enableHoverEffect
self.finalLocation = self.regular.finalLocation
self.length = self.regular.length
self.sectorId = self.regular.sectorId
self.setColor = self.regular.setColor
self.setSectorId = self.regular.setSectorId
self.setToolTip = self.regular.setToolTip
def mousePressEvent(self, event):
if event.button() != Qt.LeftButton:
QGraphicsItemGroup.mousePressEvent(self, event)
else:
self.dragEnable = True
self.selectionbox.resetTransform()
# this code block is a HACK to update the boundingbox of the group
if self.childItems()[0] != None:
item = self.childItems()[0]
self.removeFromGroup(item)
item.restoreParent()
self.addToGroup(item)
self.selectionbox.setRect(self.boundingRect())
self.selectionbox.drawMe = True
self._r0 = self.getR(event.scenePos())
self._r = self._r0
self.scene().views()[0].addToPressList(self)
def itemChange(self, change, value):
"""docstring for itemChange"""
if change == QGraphicsItem.ItemSelectedHasChanged:
if value == False:
# self.drawMe = False
self.selectionbox.drawMe = False
self.selectionbox.resetTransform()
self.removeSelectedItems()
self.parentItem().selectionLock = None
# end if
else:
pass
self.update(self.boundingRect())
return QGraphicsItemGroup.itemChange(self, change, value)
def mouseReleaseEvent(self, event):
""" Deal with mouse release events after a previous
mousePressEvent. Mostly, we just have to revert
the cursor back.
"""
if self.scene().settings.snapPatternRepeatToGrid.value == Qt.Checked:
self._snap_to_grid()
if self._position != self.pos():
self.scene().canvas_item_position_changed(self, self._position,
self.pos())
QApplication.restoreOverrideCursor()
return QGraphicsItemGroup.mouseReleaseEvent(self, event)
def mouseReleaseEvent(self, event):
""" Deal with mouse release events after a previous
mousePressEvent. Mostly, we just have to revert
the cursor back.
"""
if self.scene().settings.snapPatternRepeatToGrid.value == Qt.Checked:
self._snap_to_grid()
if self._position != self.pos():
self.scene().canvas_item_position_changed(self, self._position,
self.pos())
QApplication.restoreOverrideCursor()
return QGraphicsItemGroup.mouseReleaseEvent(self, event)
def __init__(self, ENodeHandle):
ENode.__init__(self, ENodeHandle)
self.__polygon = QPolygonF(QRectF(-50, -15, 100, 30))
self.__updateShape()
self.__attributes = {}
self.__hiddenAttributes = {}
self.__group = QGraphicsItemGroup()
self.__group.addToGroup(QGraphicsPolygonItem(self.__polygon))
self.__buildAttributes(self.Handle.lsInputAttributes())
self.__buildAttributes(self.Handle.lsOutputAttributes(), True)
self.__muted = None
def mousePressEvent(self, event):
""" Deal with mouse press events on the area spanned
by a PatternRepeatItem.
We only accept mouse press events with Control key
pressed to allow the motion of the item across the
canvas.
NOTE: We also change the cursor type to make the
motion of pattern repeat items a bit more visible.
"""
self._position = self.pos()
if (event.modifiers() & Qt.ControlModifier):
QApplication.setOverrideCursor(QCursor(Qt.SizeAllCursor))
else:
event.ignore()
return QGraphicsItemGroup.mousePressEvent(self, event)
def mousePressEvent(self, event):
""" Deal with mouse press events on the area spanned
by a PatternRepeatItem.
We only accept mouse press events with Control key
pressed to allow the motion of the item across the
canvas.
NOTE: We also change the cursor type to make the
motion of pattern repeat items a bit more visible.
"""
self._position = self.pos()
if (event.modifiers() & Qt.ControlModifier):
QApplication.setOverrideCursor(QCursor(Qt.SizeAllCursor))
else:
event.ignore()
return QGraphicsItemGroup.mousePressEvent(self, event)
class EPoint(ENode):
def __init__(self, ENodeHandle):
ENode.__init__(self, ENodeHandle)
self.__polygon = QPolygonF(QRectF(-50, -15, 100, 30))
self.__updateShape()
self.__attributes = {}
self.__hiddenAttributes = {}
self.__group = QGraphicsItemGroup()
self.__group.addToGroup(QGraphicsPolygonItem(self.__polygon))
self.__buildAttributes(self.Handle.lsInputAttributes())
self.__buildAttributes(self.Handle.lsOutputAttributes(), True)
self.__muted = None
def __updateShape(self):
fBBox = QFontMetrics(self.Font).boundingRect(self.Name)
if self.__polygon.boundingRect().width() < fBBox.width():
self.__polygon = QPolygonF(QRectF(fBBox).normalized().adjusted(-fBBox.width() / 4,
-fBBox.height() / 4,
fBBox.height(),
fBBox.height() / 2))
def __buildAttributes(self, attributes, opposite=False):
rotation = 90
for index, point in enumerate(self.getPoints(len(attributes), opposite)):
switch = {0: point.y() - (8 + self.pen().width()), 1: point.y() + (5 + self.pen().width())}
connSlot = EDraw.Circle(8, 3, rotation).translated(QPointF(point.x(), switch[opposite]))
self.__group.addToGroup(QGraphicsPolygonItem(connSlot))
self.__attributes[connSlot] = dict({self.kGuiAttributeId: attributes[index].Id,
self.kGuiAttributeType: attributes[index].Type,
self.kGuiAttributeParent: self,
self.kGuiAttributePlug: self.Polygon.boundingRect().center(),
self.kGuiAttributeLongName: attributes[index].Name})
return
@property
def Polygon(self):
return self.__polygon
@property
def BoundPolygon(self):
return self.__polygon.boundingRect()
def mute(self, uuid):
self.__muted = uuid
def togglePlug(self, plugId):
hiddenId = self.mapFromId(plugId)[ENode.kGuiAttributeId]
if self.__hiddenAttributes.has_key(hiddenId):
self.__hiddenAttributes.pop(hiddenId, None)
return
self.__hiddenAttributes[self.mapFromId(plugId)[ENode.kGuiAttributeId]] = []
def mapFromPoint(self, QPoint):
for attrRect, attrValues in self.__attributes.iteritems():
if attrRect.boundingRect().contains(self.mapFromScene(QPoint)):
return attrValues[self.kGuiAttributeId], self.scenePos()
return self.Handle.Id, None
def mapFromId(self, attrId):
for attrValue in self.__attributes.itervalues():
if attrValue[self.kGuiAttributeId] == attrId:
return attrValue
return None
def boundingRect(self):
extra = self.pen().width()
return self.__group.boundingRect().normalized().adjusted(-extra, -extra, extra, extra)
def shape(self):
return QGraphicsItem.shape(self)
def getLines(self, count, opposite=False):
angleOffset = 25
inputLines = []
startAngle = QLineF(QPointF(0.0, 0.0), self.boundingRect().topRight()).angle() + angleOffset
endAngle = QLineF(QPointF(0.0, 0.0), self.boundingRect().topLeft()).angle() - angleOffset
if opposite:
startAngle = QLineF(QPointF(0.0, 0.0), self.boundingRect().bottomLeft()).angle() + angleOffset
endAngle = QLineF(QPointF(0.0, 0.0), self.boundingRect().bottomRight()).angle() - angleOffset
step = (endAngle - startAngle) / (count - 1)
for x in range(0, count):
tLine = QLineF(QPointF(0.0, 0.0), QPointF(0, 100))
tLine.setAngle(startAngle)
inputLines.append(tLine)
startAngle += step
return inputLines
def getPoints(self, count, opposite=False):
result = []
line = QLineF(self.__polygon.boundingRect().topLeft(), self.__polygon.boundingRect().topRight())
if opposite:
line = QLineF(self.__polygon.boundingRect().bottomLeft(), self.__polygon.boundingRect().bottomRight())
step = 1.0 / (count + 1)
currentStep = step
for x in range(0, count):
result.append(line.pointAt(currentStep))
currentStep += step
return result
def paint(self, painter, option, widget=None):
painter.setPen(self.pen())
painter.setBrush(EDraw.EColor.DefaultTitleColor)
painter.drawRoundedRect(self.__polygon.boundingRect(), 3, 3)
painter.setPen(EDraw.EColor.DefaultTitleTextColor)
painter.drawText(self.__polygon.boundingRect(), Qt.AlignCenter, self.Name)
for connSlot, connData in self.__attributes.iteritems():
if connData[self.kGuiAttributeId] != self.__muted and connData[self.kGuiAttributeId] not in self.__hiddenAttributes.keys():
painter.drawPolygon(connSlot)
painter.setBrush(Qt.NoBrush)
