|
92
|
1 """
|
|
|
2 Contains all blocks that can be used to build models.
|
|
|
3 """
|
|
|
4
|
|
390
|
5 import sys
|
|
|
6 import json
|
|
|
7 import base64
|
|
|
8 import os
|
|
|
9
|
|
|
10 sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', 'ide'))
|
|
|
11
|
|
|
12 from qtwrapper import QtGui, QtCore, QtWidgets, pyqtSignal, get_icon
|
|
|
13 from qtwrapper import abspath, Qt
|
|
|
14
|
|
88
|
15
|
|
91
|
16 def uniqify(name, names):
|
|
390
|
17 newname, i = name, 1
|
|
|
18 while newname in names: newname, i = name + str(i), i + 1
|
|
|
19 return newname
|
|
|
20
|
|
91
|
21
|
|
88
|
22 def enum(**enums):
|
|
390
|
23 return type('Enum', (), enums)
|
|
|
24
|
|
88
|
25
|
|
|
26 Position = enum(TOP=0, TOP_RIGHT=1, RIGHT=2, BOTTOM_RIGHT=3, BOTTOM=4, BOTTOM_LEFT=5, LEFT=6, TOP_LEFT=7)
|
|
|
27
|
|
390
|
28
|
|
88
|
29 def buildPath(pts):
|
|
390
|
30 path = QtGui.QPainterPath(pts[0])
|
|
|
31 for pt in pts[1:]: path.lineTo(pt)
|
|
|
32 return path
|
|
88
|
33
|
|
|
34 def equalSpace(n, l, offset=15):
|
|
390
|
35 if n == 1:
|
|
|
36 return [l / 2]
|
|
|
37 elif n > 1:
|
|
|
38 return [offset + (l - offset*2)/(n - 1)*i for i in range(n)]
|
|
|
39 return []
|
|
88
|
40
|
|
390
|
41
|
|
|
42 class Connection(QtWidgets.QGraphicsPathItem):
|
|
92
|
43 """ A connection between blocks """
|
|
88
|
44 def __init__(self, fromPort=None, toPort=None):
|
|
392
|
45 super(Connection, self).__init__()
|
|
|
46 self.pos2 = self.fromPort = self.toPort = None
|
|
|
47 self.setFlags(self.ItemIsSelectable | self.ItemClipsToShape)
|
|
|
48 pen = QtGui.QPen(Qt.blue, 2, cap=Qt.RoundCap)
|
|
|
49 self.setPen(pen)
|
|
|
50 self.arrowhead = QtWidgets.QGraphicsPathItem(self)
|
|
|
51 self.arrowhead.setPath(buildPath([QtCore.QPointF(0.0, 0.0),
|
|
|
52 QtCore.QPointF(-6.0, 10.0),
|
|
|
53 QtCore.QPointF(6.0, 10.0),
|
|
|
54 QtCore.QPointF(0.0, 0.0)]))
|
|
|
55 self.arrowhead.setPen(pen)
|
|
|
56 self.arrowhead.setBrush(QtGui.QBrush(pen.color()))
|
|
|
57 self.vias = []
|
|
|
58 self.setFromPort(fromPort)
|
|
|
59 self.setToPort(toPort)
|
|
|
60
|
|
88
|
61 def getDict(self):
|
|
|
62 d = {}
|
|
|
63 d['fromBlock'] = self.fromPort.block.name
|
|
|
64 d['fromPort'] = self.fromPort.name
|
|
|
65 d['toBlock'] = self.toPort.block.name
|
|
|
66 d['toPort'] = self.toPort.name
|
|
|
67 return d
|
|
|
68 Dict = property(getDict)
|
|
|
69 def myDelete(self):
|
|
|
70 scene = self.scene()
|
|
|
71 if scene:
|
|
|
72 self.setFromPort(None)
|
|
|
73 self.setToPort(None)
|
|
|
74 scene.removeItem(self)
|
|
|
75 def setFromPort(self, fromPort):
|
|
|
76 if self.fromPort:
|
|
|
77 self.fromPort.posCallbacks.remove(self.setBeginPos)
|
|
|
78 self.fromPort.connection = None
|
|
|
79 self.fromPort = fromPort
|
|
|
80 if self.fromPort:
|
|
|
81 self.fromPort.connection = self
|
|
|
82 self.updateLineStukken()
|
|
|
83 self.fromPort.posCallbacks.append(self.setBeginPos)
|
|
|
84 def setToPort(self, toPort):
|
|
|
85 if self.toPort:
|
|
|
86 self.toPort.posCallbacks.remove(self.setEndPos)
|
|
|
87 self.toPort.connection = None
|
|
|
88 self.toPort = toPort
|
|
|
89 if self.toPort:
|
|
|
90 self.setEndPos(toPort.scenePos())
|
|
|
91 self.toPort.connection = self
|
|
|
92 self.toPort.posCallbacks.append(self.setEndPos)
|
|
|
93 def getPos1(self):
|
|
|
94 if self.fromPort:
|
|
|
95 return self.fromPort.scenePos()
|
|
|
96 def setBeginPos(self, pos1): self.updateLineStukken()
|
|
|
97 def setEndPos(self, endpos):
|
|
392
|
98 self.pos2 = endpos
|
|
|
99 self.updateLineStukken()
|
|
88
|
100 def itemChange(self, change, value):
|
|
392
|
101 if change == self.ItemSelectedHasChanged:
|
|
|
102 for via in self.vias:
|
|
|
103 via.setVisible(value)
|
|
|
104 return super(Connection, self).itemChange(change, value)
|
|
|
105
|
|
|
106 def shape(self):
|
|
|
107 return self.myshape
|
|
|
108
|
|
88
|
109 def updateLineStukken(self):
|
|
|
110 """
|
|
|
111 This algorithm determines the optimal routing of all signals.
|
|
|
112 TODO: implement nice automatic line router
|
|
|
113 """
|
|
|
114 pos1 = self.getPos1()
|
|
|
115 pos2 = self.pos2
|
|
|
116 if pos1 is None or pos2 is None:
|
|
|
117 return
|
|
|
118 scene = self.scene()
|
|
392
|
119 vias = [pos1 + QtCore.QPointF(20, 0)] + self.vias + [pos2 + QtCore.QPointF(-20, 0)]
|
|
88
|
120 if scene:
|
|
392
|
121 litem = QtWidgets.QGraphicsLineItem()
|
|
88
|
122 litem.setFlags(self.ItemIsSelectable)
|
|
|
123 scene.addItem(litem)
|
|
|
124 for p1, p2 in zip(vias[:-1], vias[1:]):
|
|
392
|
125 line = QtCore.QLineF(p1, p2)
|
|
88
|
126 litem.setLine(line)
|
|
|
127 citems = scene.collidingItems(litem)
|
|
89
|
128 citems = [i for i in citems if type(i) is Block]
|
|
88
|
129 scene.removeItem(litem)
|
|
|
130 pts = [pos1] + vias + [pos2]
|
|
|
131 self.arrowhead.setPos(pos2)
|
|
|
132 self.arrowhead.setRotation(90)
|
|
|
133 p = buildPath(pts)
|
|
|
134 self.setPath(p)
|
|
|
135 """ Create a shape outline using the path stroker """
|
|
|
136 s = super(Connection, self).shape()
|
|
390
|
137 pps = QtGui.QPainterPathStroker()
|
|
88
|
138 pps.setWidth(10)
|
|
|
139 self.myshape = pps.createStroke(s).simplified()
|
|
|
140
|
|
390
|
141 class PortItem(QtWidgets.QGraphicsPathItem):
|
|
88
|
142 """ Represents a port to a subsystem """
|
|
|
143 def __init__(self, name, block):
|
|
|
144 super(PortItem, self).__init__(block)
|
|
392
|
145 self.textItem = QtWidgets.QGraphicsTextItem(self)
|
|
88
|
146 self.connection = None
|
|
|
147 self.block = block
|
|
390
|
148 self.setCursor(QtGui.QCursor(Qt.CrossCursor))
|
|
|
149 self.setPen(QtGui.QPen(Qt.blue, 2, cap=Qt.RoundCap))
|
|
88
|
150 self.name = name
|
|
|
151 self.posCallbacks = []
|
|
|
152 self.setFlag(self.ItemSendsScenePositionChanges, True)
|
|
|
153 def getName(self): return self.textItem.toPlainText()
|
|
|
154 def setName(self, name):
|
|
|
155 self.textItem.setPlainText(name)
|
|
|
156 rect = self.textItem.boundingRect()
|
|
|
157 lw, lh = rect.width(), rect.height()
|
|
|
158 lx = 3 if type(self) is InputPort else -3 - lw
|
|
|
159 self.textItem.setPos(lx, -lh / 2)
|
|
|
160 name = property(getName, setName)
|
|
91
|
161 def getDict(self):
|
|
|
162 return {'name': self.name}
|
|
88
|
163 Dict = property(getDict)
|
|
|
164 def itemChange(self, change, value):
|
|
|
165 if change == self.ItemScenePositionHasChanged:
|
|
|
166 for cb in self.posCallbacks: cb(value)
|
|
|
167 return value
|
|
|
168 return super(PortItem, self).itemChange(change, value)
|
|
|
169
|
|
392
|
170
|
|
88
|
171 class OutputPort(PortItem):
|
|
392
|
172 def __init__(self, name, block, d=10.0):
|
|
|
173 super().__init__(name, block)
|
|
|
174 self.setPath(buildPath([QtCore.QPointF(0.0, -d), QtCore.QPointF(d, 0),
|
|
|
175 QtCore.QPointF(0.0, d)]))
|
|
|
176
|
|
|
177 def mousePressEvent(self, event):
|
|
|
178 self.scene().startConnection(self)
|
|
|
179
|
|
88
|
180
|
|
|
181 class InputPort(PortItem):
|
|
392
|
182 def __init__(self, name, block, d=10.0):
|
|
|
183 super().__init__(name, block)
|
|
|
184 self.setPath(buildPath([QtCore.QPointF(-d, -d), QtCore.QPointF(0, 0),
|
|
|
185 QtCore.QPointF(-d, d)]))
|
|
88
|
186
|
|
390
|
187 class Handle(QtWidgets.QGraphicsEllipseItem):
|
|
88
|
188 """ A handle that can be moved by the mouse """
|
|
89
|
189 def __init__(self, dx=10.0, parent=None):
|
|
390
|
190 super(Handle, self).__init__(QtCore.QRectF(-0.5*dx,-0.5*dx,dx,dx), parent)
|
|
|
191 self.setBrush(QtGui.QBrush(Qt.white))
|
|
90
|
192 self.setFlags(self.ItemIsMovable)
|
|
|
193 self.setZValue(1)
|
|
88
|
194 self.setVisible(False)
|
|
390
|
195 self.setCursor(QtGui.QCursor(Qt.SizeFDiagCursor))
|
|
88
|
196 def mouseMoveEvent(self, event):
|
|
|
197 """ Move function without moving the other selected elements """
|
|
|
198 p = self.mapToParent(event.pos())
|
|
|
199 self.setPos(p)
|
|
|
200
|
|
392
|
201
|
|
88
|
202 class ResizeSelectionHandle(Handle):
|
|
392
|
203 def __init__(self, position, block):
|
|
|
204 super(ResizeSelectionHandle, self).__init__(dx=12, parent=block)
|
|
|
205 self.position = position
|
|
|
206 self.block = block
|
|
|
207 if position in [Position.TOP_LEFT, Position.BOTTOM_RIGHT]:
|
|
|
208 self.setCursor(QtGui.QCursor(Qt.SizeFDiagCursor))
|
|
|
209 elif position in [Position.TOP_RIGHT, Position.BOTTOM_LEFT]:
|
|
|
210 self.setCursor(QtGui.QCursor(Qt.SizeBDiagCursor))
|
|
|
211 elif position in [Position.TOP, Position.BOTTOM]:
|
|
|
212 self.setCursor(QtGui.QCursor(Qt.SizeVerCursor))
|
|
|
213 elif position in [Position.LEFT, Position.RIGHT]:
|
|
|
214 self.setCursor(QtGui.QCursor(Qt.SizeHorCursor))
|
|
|
215
|
|
|
216 def mouseMoveEvent(self, event):
|
|
|
217 self.block.sizerMoveEvent(self, event.scenePos())
|
|
|
218
|
|
88
|
219
|
|
390
|
220 class Block(QtWidgets.QGraphicsRectItem):
|
|
92
|
221 """ Represents a block in the diagram. """
|
|
88
|
222 def __init__(self, name='Untitled', parent=None):
|
|
89
|
223 super(Block, self).__init__(parent)
|
|
90
|
224 self.selectionHandles = [ResizeSelectionHandle(i, self) for i in range(8)]
|
|
88
|
225 # Properties of the rectangle:
|
|
390
|
226 self.setPen(QtGui.QPen(Qt.blue, 2))
|
|
|
227 self.setBrush(QtGui.QBrush(Qt.lightGray))
|
|
88
|
228 self.setFlags(self.ItemIsSelectable | self.ItemIsMovable | self.ItemSendsScenePositionChanges)
|
|
390
|
229 self.setCursor(QtGui.QCursor(Qt.PointingHandCursor))
|
|
92
|
230 self.setAcceptHoverEvents(True)
|
|
390
|
231 self.label = QtWidgets.QGraphicsTextItem(name, self)
|
|
88
|
232 self.name = name
|
|
|
233 # Create corner for resize:
|
|
390
|
234 button = QtWidgets.QPushButton('+in')
|
|
88
|
235 button.clicked.connect(self.newInputPort)
|
|
390
|
236 self.buttonItemAddInput = QtWidgets.QGraphicsProxyWidget(self)
|
|
88
|
237 self.buttonItemAddInput.setWidget(button)
|
|
|
238 self.buttonItemAddInput.setVisible(False)
|
|
390
|
239 button = QtWidgets.QPushButton('+out')
|
|
88
|
240 button.clicked.connect(self.newOutputPort)
|
|
390
|
241 self.buttonItemAddOutput = QtWidgets.QGraphicsProxyWidget(self)
|
|
88
|
242 self.buttonItemAddOutput.setWidget(button)
|
|
|
243 self.buttonItemAddOutput.setVisible(False)
|
|
|
244 # Inputs and outputs of the block:
|
|
|
245 self.inputs = []
|
|
|
246 self.outputs = []
|
|
91
|
247 self.changeSize(2,2)
|
|
392
|
248
|
|
88
|
249 def editParameters(self):
|
|
392
|
250 pd = ParameterDialog(self, self.window())
|
|
|
251 pd.exec_()
|
|
|
252
|
|
88
|
253 def newInputPort(self):
|
|
392
|
254 names = [i.name for i in self.inputs + self.outputs]
|
|
|
255 self.addInput(InputPort(uniqify('in', names), self))
|
|
|
256
|
|
88
|
257 def newOutputPort(self):
|
|
392
|
258 names = [i.name for i in self.inputs + self.outputs]
|
|
|
259 self.addOutput(OutputPort(uniqify('out', names), self))
|
|
|
260
|
|
88
|
261 def setName(self, name): self.label.setPlainText(name)
|
|
392
|
262
|
|
88
|
263 def getName(self): return self.label.toPlainText()
|
|
392
|
264
|
|
88
|
265 name = property(getName, setName)
|
|
|
266 def getDict(self):
|
|
|
267 d = {'x': self.scenePos().x(), 'y': self.scenePos().y()}
|
|
|
268 rect = self.rect()
|
|
|
269 d.update({'width': rect.width(), 'height': rect.height()})
|
|
91
|
270 d['name'] = self.name
|
|
88
|
271 d['inputs'] = [inp.Dict for inp in self.inputs]
|
|
|
272 d['outputs'] = [outp.Dict for outp in self.outputs]
|
|
|
273 return d
|
|
|
274 def setDict(self, d):
|
|
|
275 self.name = d['name']
|
|
|
276 self.setPos(d['x'], d['y'])
|
|
|
277 self.changeSize(d['width'], d['height'])
|
|
92
|
278 for inp in d['inputs']:
|
|
|
279 self.addInput(InputPort(inp['name'], self))
|
|
|
280 for outp in d['outputs']:
|
|
|
281 self.addOutput(OutputPort(outp['name'], self))
|
|
88
|
282 Dict = property(getDict, setDict)
|
|
392
|
283
|
|
88
|
284 def addInput(self, i):
|
|
392
|
285 self.inputs.append(i)
|
|
|
286 self.updateSize()
|
|
|
287
|
|
88
|
288 def addOutput(self, o):
|
|
392
|
289 self.outputs.append(o)
|
|
|
290 self.updateSize()
|
|
|
291
|
|
88
|
292 def contextMenuEvent(self, event):
|
|
392
|
293 menu = QtWidgets.QMenu()
|
|
88
|
294 pa = menu.addAction('Parameters')
|
|
|
295 pa.triggered.connect(self.editParameters)
|
|
|
296 menu.exec_(event.screenPos())
|
|
|
297 def itemChange(self, change, value):
|
|
|
298 if change == self.ItemSelectedHasChanged:
|
|
|
299 for child in [self.buttonItemAddInput, self.buttonItemAddOutput]:
|
|
|
300 child.setVisible(value)
|
|
90
|
301 if value:
|
|
|
302 self.repositionAndShowHandles()
|
|
|
303 else:
|
|
|
304 [h.setVisible(False) for h in self.selectionHandles]
|
|
|
305
|
|
89
|
306 return super(Block, self).itemChange(change, value)
|
|
91
|
307 def hoverEnterEvent(self, event):
|
|
392
|
308 if not self.isSelected():
|
|
|
309 self.repositionAndShowHandles()
|
|
|
310 super().hoverEnterEvent(event)
|
|
91
|
311 def hoverLeaveEvent(self, event):
|
|
392
|
312 if not self.isSelected():
|
|
|
313 [h.setVisible(False) for h in self.selectionHandles]
|
|
|
314 super().hoverLeaveEvent(event)
|
|
88
|
315 def myDelete(self):
|
|
|
316 for p in self.inputs + self.outputs:
|
|
|
317 if p.connection: p.connection.myDelete()
|
|
|
318 self.scene().removeItem(self)
|
|
90
|
319 def repositionAndShowHandles(self):
|
|
|
320 r = self.rect()
|
|
|
321 self.selectionHandles[Position.TOP_LEFT].setPos(r.topLeft())
|
|
|
322 self.selectionHandles[Position.TOP].setPos(r.center().x(), r.top())
|
|
|
323 self.selectionHandles[Position.TOP_RIGHT].setPos(r.topRight())
|
|
|
324 self.selectionHandles[Position.RIGHT].setPos(r.right(), r.center().y())
|
|
|
325 self.selectionHandles[Position.BOTTOM_RIGHT].setPos(r.bottomRight())
|
|
|
326 self.selectionHandles[Position.BOTTOM].setPos(r.center().x(), r.bottom())
|
|
|
327 self.selectionHandles[Position.BOTTOM_LEFT].setPos(r.bottomLeft())
|
|
|
328 self.selectionHandles[Position.LEFT].setPos(r.left(), r.center().y())
|
|
|
329 for h in self.selectionHandles:
|
|
|
330 h.setVisible(True)
|
|
|
331 def sizerMoveEvent(self, handle, pos):
|
|
|
332 r = self.rect().translated(self.pos())
|
|
|
333 if handle.position == Position.TOP_LEFT: r.setTopLeft(pos)
|
|
|
334 elif handle.position == Position.TOP: r.setTop(pos.y())
|
|
|
335 elif handle.position == Position.TOP_RIGHT: r.setTopRight(pos)
|
|
|
336 elif handle.position == Position.RIGHT: r.setRight(pos.x())
|
|
|
337 elif handle.position == Position.BOTTOM_RIGHT: r.setBottomRight(pos)
|
|
|
338 elif handle.position == Position.BOTTOM: r.setBottom(pos.y())
|
|
|
339 elif handle.position == Position.BOTTOM_LEFT: r.setBottomLeft(pos)
|
|
|
340 elif handle.position == Position.LEFT: r.setLeft(pos.x())
|
|
|
341 else:
|
|
|
342 print('invalid position')
|
|
|
343 self.setCenterAndSize(r.center(), r.size())
|
|
|
344 self.repositionAndShowHandles()
|
|
88
|
345 def updateSize(self):
|
|
|
346 rect = self.rect()
|
|
|
347 h, w = rect.height(), rect.width()
|
|
|
348 self.buttonItemAddInput.setPos(0, h + 4)
|
|
|
349 self.buttonItemAddOutput.setPos(w+10, h+4)
|
|
|
350 for inp, y in zip(self.inputs, equalSpace(len(self.inputs), h)):
|
|
|
351 inp.setPos(0.0, y)
|
|
|
352 for outp, y in zip(self.outputs, equalSpace(len(self.outputs), h)):
|
|
|
353 outp.setPos(w, y)
|
|
|
354 def setCenterAndSize(self, center, size):
|
|
392
|
355 self.changeSize(size.width(), size.height())
|
|
|
356 p = QtCore.QPointF(size.width(), size.height())
|
|
|
357 self.setPos(center - p / 2)
|
|
88
|
358 def changeSize(self, w, h):
|
|
392
|
359 minw = 150
|
|
|
360 minh = 50
|
|
|
361 h = minh if h < minh else h
|
|
|
362 w = minw if w < minw else w
|
|
|
363 self.setRect(0.0, 0.0, w, h)
|
|
|
364 rect = self.label.boundingRect()
|
|
|
365 self.label.setPos((w - rect.width()) / 2, (h - rect.height()) / 2)
|
|
|
366 self.updateSize()
|
|
88
|
367
|
|
390
|
368
|
|
90
|
369 class CodeBlock(Block):
|
|
390
|
370 def __init__(self, name='Untitled', parent=None):
|
|
|
371 super(CodeBlock, self).__init__(name, parent)
|
|
|
372 self.code = ''
|
|
|
373
|
|
|
374 def setDict(self, d):
|
|
|
375 super(CodeBlock, self).setDict(d)
|
|
|
376 self.code = d['code']
|
|
|
377
|
|
|
378 def getDict(self):
|
|
|
379 d = super(CodeBlock, self).getDict()
|
|
|
380 d['code'] = self.code
|
|
|
381 return d
|
|
|
382
|
|
|
383 def gencode(self):
|
|
90
|
384 c = ['def {0}():'.format(self.name)]
|
|
|
385 if self.code:
|
|
|
386 c += indent(self.code.split('\n'))
|
|
|
387 else:
|
|
|
388 c += indent(['pass'])
|
|
|
389 return c
|
|
|
390
|
|
390
|
391
|
|
90
|
392 class DiagramBlock(Block):
|
|
390
|
393 def __init__(self, name='Untitled', parent=None):
|
|
392
|
394 super(DiagramBlock, self).__init__(name, parent)
|
|
|
395 self.subModel = DiagramScene()
|
|
|
396 self.subModel.containingBlock = self
|
|
390
|
397
|
|
|
398 def setDict(self, d):
|
|
|
399 self.subModel.Dict = d['submodel']
|
|
|
400
|
|
|
401 def mouseDoubleClickEvent(self, event):
|
|
392
|
402 # descent into child diagram
|
|
|
403 #self.editParameters()
|
|
|
404 print('descent')
|
|
|
405 scene = self.scene()
|
|
|
406 if scene:
|
|
|
407 for view in scene.views():
|
|
|
408 view.diagram = self.subModel
|
|
|
409 view.zoomAll()
|
|
90
|
410
|
|
390
|
411
|
|
|
412 class DiagramScene(QtWidgets.QGraphicsScene):
|
|
92
|
413 """ A diagram scene consisting of blocks and connections """
|
|
93
|
414 structureChanged = pyqtSignal()
|
|
88
|
415 def __init__(self):
|
|
|
416 super(DiagramScene, self).__init__()
|
|
|
417 self.startedConnection = None
|
|
|
418
|
|
92
|
419 blocks = property(lambda sel: [i for i in sel.items() if isinstance(i, Block)])
|
|
88
|
420 connections = property(lambda sel: [i for i in sel.items() if type(i) is Connection])
|
|
93
|
421 def addItem(self, item):
|
|
|
422 super(DiagramScene, self).addItem(item)
|
|
|
423 if isinstance(item, Block):
|
|
|
424 self.structureChanged.emit()
|
|
|
425 def removeItem(self, item):
|
|
|
426 super(DiagramScene, self).removeItem(item)
|
|
|
427 if isinstance(item, Block):
|
|
|
428 self.structureChanged.emit()
|
|
88
|
429 def setDict(self, d):
|
|
|
430 for block in d['blocks']:
|
|
89
|
431 b = Block()
|
|
88
|
432 self.addItem(b)
|
|
|
433 b.Dict = block
|
|
|
434 for con in d['connections']:
|
|
|
435 fromPort = self.findPort(con['fromBlock'], con['fromPort'])
|
|
|
436 toPort = self.findPort(con['toBlock'], con['toPort'])
|
|
|
437 self.addItem(Connection(fromPort, toPort))
|
|
|
438 def getDict(self):
|
|
|
439 return {'blocks': [b.Dict for b in self.blocks], 'connections': [c.Dict for c in self.connections]}
|
|
|
440 Dict = property(getDict, setDict)
|
|
|
441 def gencode(self):
|
|
|
442 c = []
|
|
|
443 for b in self.blocks:
|
|
|
444 c += b.gencode()
|
|
|
445 for b in self.blocks:
|
|
|
446 c.append('{0}()'.format(b.name))
|
|
|
447 return c
|
|
|
448 def findPort(self, blockname, portname):
|
|
|
449 block = self.findBlock(blockname)
|
|
|
450 if block:
|
|
|
451 for port in block.inputs + block.outputs:
|
|
|
452 if port.name == portname: return port
|
|
|
453 def findBlock(self, blockname):
|
|
|
454 for block in self.blocks:
|
|
|
455 if block.name == blockname: return block
|
|
91
|
456 def uniqify(self, name):
|
|
88
|
457 blocknames = [item.name for item in self.blocks]
|
|
91
|
458 return uniqify(name, blocknames)
|
|
88
|
459 def mouseMoveEvent(self, event):
|
|
|
460 if self.startedConnection:
|
|
|
461 pos = event.scenePos()
|
|
|
462 self.startedConnection.setEndPos(pos)
|
|
|
463 super(DiagramScene, self).mouseMoveEvent(event)
|
|
|
464 def mouseReleaseEvent(self, event):
|
|
|
465 if self.startedConnection:
|
|
|
466 for item in self.items(event.scenePos()):
|
|
|
467 if type(item) is InputPort and item.connection == None:
|
|
|
468 self.startedConnection.setToPort(item)
|
|
|
469 self.startedConnection = None
|
|
|
470 return
|
|
|
471 self.startedConnection.myDelete()
|
|
|
472 self.startedConnection = None
|
|
|
473 super(DiagramScene, self).mouseReleaseEvent(event)
|
|
|
474 def startConnection(self, port):
|
|
|
475 self.startedConnection = Connection(port, None)
|
|
|
476 pos = port.scenePos()
|
|
|
477 self.startedConnection.setEndPos(pos)
|
|
|
478 self.addItem(self.startedConnection)
|
|
|
479 def deleteItems(self):
|
|
|
480 for item in list(self.selectedItems()): item.myDelete()
|
|
89
|
481
|
