def addNodes(self):
node1 = Node(self.scene,
"My Awesome Node 1",
inputs=[0, 0, 0],
outputs=[1])
node2 = Node(self.scene,
"My Awesome Node 2",
inputs=[3, 3, 3],
outputs=[1])
node3 = Node(self.scene,
"My Awesome Node 3",
inputs=[2, 2, 2],
outputs=[1])
node1.setPos(-350, -250)
node2.setPos(-75, 0)
node3.setPos(200, -150)
edge1 = Edge(self.scene,
node1.outputs[0],
node2.inputs[0],
edge_type=EDGE_TYPE_BEZIER)
edge2 = Edge(self.scene,
node2.outputs[0],
node3.inputs[0],
edge_type=EDGE_TYPE_BEZIER)
self.scene.history.storeInitialHistoryStamp()
def addNodes(self):
"""Testing method to create 3 `Nodes` with 3 `Edges` connecting them"""
node1 = Node(self.scene,
"My Awesome Node 1",
inputs=[0, 0, 0],
outputs=[1, 5])
node2 = Node(self.scene,
"My Awesome Node 2",
inputs=[3, 3, 3],
outputs=[1])
node3 = Node(self.scene,
"My Awesome Node 3",
inputs=[2, 2, 2],
outputs=[1])
node1.setPos(-350, -250)
node2.setPos(-75, 0)
node3.setPos(200, -200)
edge1 = Edge(self.scene,
node1.outputs[0],
node2.inputs[0],
edge_type=EDGE_TYPE_BEZIER)
edge2 = Edge(self.scene,
node2.outputs[0],
node3.inputs[0],
edge_type=EDGE_TYPE_BEZIER)
edge3 = Edge(self.scene,
node1.outputs[0],
node3.inputs[2],
edge_type=EDGE_TYPE_BEZIER)
self.scene.history.storeInitialHistoryStamp()
def edgeDragStart(self, item):
if DEBUG: print('View::edgeDragStart - Start dragging edge')
if DEBUG: print('View::edgeDragStart - Assign Start Socket to:', item.socket)
#self.previousEdge = item.socket.edge
self.drag_start_socket = item.socket
self.drag_edge = Edge(self.grScene.scene, item.socket, None, EDGE_TYPE_BEZIER)
if DEBUG: print('View::edgeDragStart - dragEdge:', self.drag_edge)
def addNodes(self):
node1 = Node(self.scene,
"My Awesome Node 1",
inputs=[0, 2, 3],
outputs=[1])
node2 = Node(self.scene,
"My Awesome Node 2",
inputs=[1, 4, 5],
outputs=[1])
node3 = Node(self.scene,
"My Awesome Node 3",
inputs=[4, 0, 2],
outputs=[1])
node1.setPos(-350, -250)
node2.setPos(-75, 0)
node3.setPos(200, -150)
edge1 = Edge(self.scene,
node1.outputs[0],
node2.inputs[0],
edge_type=EDGE_TYPE_BEZIER)
edge2 = Edge(self.scene,
node2.outputs[0],
node3.inputs[1],
edge_type=EDGE_TYPE_BEZIER)
def edgeDragStart(self, item):
try:
if DEBUG: print('View::edgeDragStart ~ Start dragging edge')
if DEBUG: print('View::edgeDragStart ~ assign Start Socket to:', item.socket)
self.drag_start_socket = item.socket
self.drag_edge = Edge(self.grScene.scene, item.socket, None, EDGE_TYPE_BEZIER)
if DEBUG: print('View::edgeDragStart ~ dragEdge:', self.drag_edge)
except Exception as e: dumpException(e)
def edgeDragStart(self, item):
try:
logging.debug('View::edgeDragStart ~ Start dragging edge')
logging.debug(
'View::edgeDragStart ~ assign Start Socket to: {item.socket}'
)
self.drag_start_socket = item.socket
self.drag_edge = Edge(self.grScene.scene, item.socket, None,
EDGE_TYPE_BEZIER)
logging.debug(
f'View::edgeDragStart ~ dragEdge: {self.drag_edge}')
except Exception as e:
dumpException(e)
def edgeDragStart(self, item: 'QGraphicsItem'):
"""Code handling the start of dragging an `Edge` operation"""
try:
if DEBUG: print('View::edgeDragStart ~ Start dragging edge')
if DEBUG:
print('View::edgeDragStart ~ assign Start Socket to:',
item.socket)
self.drag_start_socket = item.socket
self.drag_edge = Edge(self.grScene.scene, item.socket, None,
EDGE_TYPE_BEZIER)
if DEBUG:
print('View::edgeDragStart ~ dragEdge:', self.drag_edge)
except Exception as e:
dumpException(e)
def deserializeFromClipboard(self, data: dict):
"""
Deserializes data from Clipboard.
:param data: ``dict`` data for deserialization to the :class:`nodeeditor.node_scene.Scene`.
:type data: ``dict``
"""
hashmap = {}
# calculate mouse pointer - scene position
view = self.scene.getView()
mouse_scene_pos = view.last_scene_mouse_position
# calculate selected objects bbox and center
minx, maxx, miny, maxy = 0, 0, 0, 0
for node_data in data['nodes']:
x, y = node_data['pos_x'], node_data['pos_y']
if x < minx: minx = x
if x > maxx: maxx = x
if y < miny: miny = y
if y > maxy: maxy = y
bbox_center_x = (minx + maxx) / 2
bbox_center_y = (miny + maxy) / 2
# center = view.mapToScene(view.rect().center())
# calculate tehe offset of the newly creating nodes
offset_x = mouse_scene_pos.x() - bbox_center_x
offset_y = mouse_scene_pos.y() - bbox_center_y
# create each node
for node_data in data['nodes']:
new_node = self.scene.getNodeClassFromData(node_data)(self.scene)
new_node.deserialize(node_data, hashmap, restore_id=False)
# readjust the new node's position
pos = new_node.pos
new_node.setPos(pos.x() + offset_x, pos.y() + offset_y)
# create each edge
if 'edges' in data:
for edge_data in data['edges']:
new_edge = Edge(self.scene)
new_edge.deserialize(edge_data, hashmap, restore_id=False)
# store history
self.scene.history.storeHistory("Pasted elements in scene",
setModified=True)
def edgeDragEnd(self, item):
""" return True if skip the rest of the code """
self.mode = MODE_NOOP
if DEBUG: print('View::edgeDragEnd ~ End dragging edge')
self.drag_edge.remove()
self.drag_edge = None
if type(item) is QDMGraphicsSocket:
if item.socket != self.drag_start_socket:
# if we released dragging on a socket (other then the beginning socket)
# we wanna keep all the edges comming from target socket
if not item.socket.is_multi_edges:
item.socket.removeAllEdges()
# we wanna keep all the edges comming from start socket
if not self.drag_start_socket.is_multi_edges:
self.drag_start_socket.removeAllEdges()
new_edge = Edge(self.grScene.scene,
self.drag_start_socket,
item.socket,
edge_type=EDGE_TYPE_BEZIER)
if DEBUG:
print("View::edgeDragEnd ~ created new edge:", new_edge,
"connecting", new_edge.start_socket, "<-->",
new_edge.end_socket)
self.grScene.scene.history.storeHistory(
"Created new edge by dragging", setModified=True)
return True
if DEBUG: print('View::edgeDragEnd ~ everything done.')
return False
def dropNode(self, node: "Node", scene_pos_x: float, scene_pos_y: float):
"""
Code handling the dropping of a node on an existing edge.
:param scene_pos_x: scene position x
:type scene_pos_x: `float`
:param scene_pos_y: scene position y
:type scene_pos_y: `float`
"""
node_box = self.hotZoneRect(node)
# check if the node is dropped on an existing edge
edge = self.intersect(node_box)
if edge is None: return
if self.isConnected(node): return
# determine the order of start and end
if edge.start_socket.is_output:
socket_start = edge.start_socket
socket_end = edge.end_socket
else:
socket_start = edge.end_socket
socket_end = edge.start_socket
# The new edges will have the same edge_type as the intersected edge
edge_type = edge.edge_type
edge.remove()
self.grView.grScene.scene.history.storeHistory('Delete existing edge',
setModified=True)
new_node_socket_in = node.inputs[0]
Edge(self.grScene.scene,
socket_start,
new_node_socket_in,
edge_type=edge_type)
new_node_socket_out = node.outputs[0]
Edge(self.grScene.scene,
new_node_socket_out,
socket_end,
edge_type=edge_type)
self.grView.grScene.scene.history.storeHistory(
'Created new edges by dropping node', setModified=True)
def deserializeFromClipboard(self, data):
hashmap = {}
# calculate mouse pointer - scene position
view = self.scene.grScene.views()[0]
mouse_scene_pos = view.last_scene_mouse_position
# calculate selected objects bbox and center
minx, maxx, miny, maxy = 0, 0, 0, 0
for node_data in data['nodes']:
x, y = node_data['pos_x'], node_data['pos_y']
if x < minx: minx = x
if x > maxx: maxx = x
if y < miny: miny = y
if y > maxy: maxy = y
bbox_center_x = (minx + maxx) / 2
bbox_center_y = (miny + maxy) / 2
#center = view.mapToScene(view.rect().center())
# calculate the offset of the newly creating nodes
offset_x = mouse_scene_pos.x() - bbox_center_x
offset_y = mouse_scene_pos.y() - bbox_center_y
# create each node
for node_data in data['nodes']:
new_node = Node(self.scene)
new_node.deserialize(node_data, hashmap, restore_id=False)
# readjust the new node's position
pos = new_node.pos
new_node.setPos(pos.x() + offset_x, pos.y() + offset_y)
# create each edge
if 'edges' in data:
for edge_data in data['edges']:
new_edge = Edge(self.scene)
new_edge.deserialize(edge_data, hashmap, restore_id=False)
# store history
self.scene.history.storeHistory("Pasted elements in scene")
def edgeDragEnd(self, item):
# return true if to skip the rest of the code
self.mode = NODE_NOOP
if DEBUG: print("View::edgeDragEnd - End dragging edge")
self.drag_edge.remove()
self.drag_edge = None
if type(item) is QDMGraphicsSocket:
if item.socket != self.drag_start_socket:
# If we released draging on a socket (other than the beginning socket)
# if DEBUG: print('View::edgeDragEnd - previous edge', self.previousEdge)
# if item.socket.hasEdge():
# item.socket.edges.remove()
# for edge in item.socket.edges:
# if DEBUG: print("View::edgeDragEnd - cleanup edges IN target", edge)
# edge.remove()
# if DEBUG: print("View::edgeDragEnd - cleanup edges IN target", edge, "removed")
# we wanna keep all the edges coming from target socket
if not item.socket.is_multi_edges:
item.socket.removeAllEdges()
# we wanna keep all the edges coming from start socket
if not self.drag_start_socket.is_multi_edges:
self.drag_start_socket.removeAllEdges()
# if DEBUG: print("View::edgeDragEnd - assign End Socket", item.socket)
# if self.previousEdge is not None: self.previousEdge.remove()
# if DEBUG: print('View::edgeDragEnd - previous edge remove')
# self.drag_edge.start_socket = self.drag_last_start_socket
# self.drag_edge.end_socket = item.socket
# self.drag_edge.start_socket.addEdge(self.drag_edge)
# self.drag_edge.end_socket.addEdge(self.drag_edge)
# if DEBUG: print('View:: edgeDragEnd - assigned start & end sockets to drag edge')
# self.drag_edge.updatePositions()
new_edge = Edge(self.grScene.scene, self.drag_start_socket, item.socket, EDGE_TYPE_BEZIER)
if DEBUG: print("View::edgeDragEnd - created new edge:", new_edge, "connecting", new_edge.start_socket, "<--->", new_edge.end_socket)
self.grScene.scene.history.storeHistory("Created new edge by dragging")
return True
# if DEBUG: print('View::edgeDragEnd - about to set socket to previous edge:', self.previousEdge)
# if self.previousEdge is not None:
# self.previousEdge.start_socket.edge = self.previousEdge
if DEBUG: print('View::edgeDragEnd - everything done.')
return False
def edgeDragEnd(self, item: 'QGraphicsItem'):
"""Code handling the end of dragging an `Edge` operation. In this code return True if skip the
rest of the mouse event processing
:param item: Item in the `Graphics Scene` where we ended dragging an `Edge`
:type item: ``QGraphicsItem``
"""
self.mode = MODE_NOOP
if DEBUG: print('View::edgeDragEnd ~ End dragging edge')
self.drag_edge.remove(
silent=True) # don't notify sockets about removing drag_edge
self.drag_edge = None
try:
if isinstance(item, QDMGraphicsSocket):
if item.socket != self.drag_start_socket:
# if we released dragging on a socket (other then the beginning socket)
# we wanna keep all the edges comming from target socket
if not item.socket.is_multi_edges:
item.socket.removeAllEdges()
# we wanna keep all the edges comming from start socket
if not self.drag_start_socket.is_multi_edges:
self.drag_start_socket.removeAllEdges()
## Create new Edge
new_edge = Edge(self.grScene.scene,
self.drag_start_socket,
item.socket,
edge_type=EDGE_TYPE_BEZIER)
if DEBUG:
print("View::edgeDragEnd ~ created new edge:",
new_edge, "connecting", new_edge.start_socket,
"<-->", new_edge.end_socket)
## Send notifications for the new edge
for socket in [self.drag_start_socket, item.socket]:
# @TODO: Add possibility (ie when an input edge was replaced) to be silent and don't trigger change
socket.node.onEdgeConnectionChanged(new_edge)
if socket.is_input: socket.node.onInputChanged(socket)
self.grScene.scene.history.storeHistory(
"Created new edge by dragging", setModified=True)
return True
except Exception as e:
dumpException(e)
if DEBUG: print('View::edgeDragEnd ~ everything done.')
return False
def deserialize(self, data, hashmap={}, restore_id=True):
self.clear()
hashmap = {}
if restore_id: self.id = data['id']
# create nodes
for node_data in data['nodes']:
Node(self).deserialize(node_data, hashmap, restore_id)
# create edges
for edge_data in data['edges']:
Edge(self).deserialize(edge_data, hashmap, restore_id)
return True
def deserialize(self,
data: dict,
hashmap: dict = {},
restore_id: bool = True) -> bool:
self.clear()
hashmap = {}
if restore_id: self.id = data['id']
# create nodes
for node_data in data['nodes']:
self.getNodeClassFromData(node_data)(self).deserialize(
node_data, hashmap, restore_id)
# create edges
for edge_data in data['edges']:
Edge(self).deserialize(edge_data, hashmap, restore_id)
return True
def edgeDragEnd(self, item):
""" return True if skip the rest of the code """
self.mode = MODE_NOOP
logging.debug('View::edgeDragEnd ~ End dragging edge')
self.drag_edge.remove()
self.drag_edge = None
try:
if type(item) is QDMGraphicsSocket:
if item.socket != self.drag_start_socket:
# if we released dragging on a socket (other then the beginning socket)
# we wanna keep all the edges comming from target socket
if not item.socket.is_multi_edges:
item.socket.removeAllEdges()
# we wanna keep all the edges comming from start socket
if not self.drag_start_socket.is_multi_edges:
self.drag_start_socket.removeAllEdges()
new_edge = Edge(self.grScene.scene,
self.drag_start_socket,
item.socket,
edge_type=EDGE_TYPE_BEZIER)
logging.debug(
f"View::edgeDragEnd ~ created new edge: {new_edge}, "
f"connecting {new_edge.start_socket} <--> {new_edge.end_socket}"
)
for socket in [self.drag_start_socket, item.socket]:
socket.node.onEdgeConnectionChanged(new_edge)
if socket.is_input:
socket.node.onInputChanged(new_edge)
self.grScene.scene.history.storeHistory(
"Created new edge by dragging", setModified=True)
return True
except Exception as e:
dumpException(e)
logging.debug('View::edgeDragEnd ~ everything done.')
return False
def deserialize(self, data, hashmap={}, restore_id=True):
self.clear()
hashmap = {}
if restore_id: self.id = data['id']
# create nodes
for node_data in data['nodes']:
#classtype = self.getNodeClassFromData(node_data)
#c = classtype(self)
#c.deserialize(node_data, hashmap, restore_id)
#self.addNode(c)
try:
self.getNodeClassFromData(node_data)(self).deserialize(node_data, hashmap, restore_id)
except Exception as e:
logging.error(e)
traceback.print_tb(e.__traceback__)
# create edges
for edge_data in data['edges']:
Edge(self).deserialize(edge_data, hashmap, restore_id)
return True
class QDMGraphicsView(QGraphicsView):
scenePosChanged = pyqtSignal(int, int)
def __init__(self, grScene, parent=None):
super().__init__(parent)
self.grScene = grScene
self.initUI()
self.setScene(self.grScene)
self.mode = MODE_NOOP
self.editingFlag = False
self.rubberBandDraggingRectangle = False
self.zoomInFactor = 1.25 # 放大系数
self.zoomClamp = True # 变焦
self.zoom = 10
self.zoomStep = 1
self.zoomRange = [0, 10]
# cutline 切割线/剪切线
self.cutline = QDMCutLine()
self.grScene.addItem(self.cutline)
# listeners
self._drag_enter_listeners = []
self._drop_listeners = []
def initUI(self):
self.setRenderHints(QPainter.Antialiasing
| QPainter.HighQualityAntialiasing
| QPainter.TextAntialiasing
| QPainter.SmoothPixmapTransform)
self.setViewportUpdateMode(QGraphicsView.FullViewportUpdate)
self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setTransformationAnchor(QGraphicsView.AnchorUnderMouse)
self.setDragMode(QGraphicsView.RubberBandDrag)
# enable dropping
self.setAcceptDrops(True)
def dragEnterEvent(self, event):
for callback in self._drag_enter_listeners:
callback(event)
def dropEvent(self, event):
for callback in self._drop_listeners:
callback(event)
def addDragEnterListener(self, callback):
self._drag_enter_listeners.append(callback)
def addDropListener(self, callback):
self._drop_listeners.append(callback)
def mousePressEvent(self, event):
if event.button() == Qt.MiddleButton:
self.middleMouseButtonPress(event)
elif event.button() == Qt.LeftButton:
self.leftMouseButtonPress(event)
elif event.button() == Qt.RightButton:
self.rightMouseButtonPress(event)
else:
super().mousePressEvent(event)
def mouseReleaseEvent(self, event):
if event.button() == Qt.MiddleButton:
self.middleMouseButtonRelease(event)
elif event.button() == Qt.LeftButton:
self.leftMouseButtonRelease(event)
elif event.button() == Qt.RightButton:
self.rightMouseButtonRelease(event)
else:
super().mouseReleaseEvent(event)
def middleMouseButtonPress(self, event):
releaseEvent = QMouseEvent(QEvent.MouseButtonRelease, event.localPos(),
event.screenPos(), Qt.LeftButton,
Qt.NoButton, event.modifiers())
super().mouseReleaseEvent(releaseEvent)
self.setDragMode(QGraphicsView.ScrollHandDrag)
fakeEvent = QMouseEvent(event.type(), event.localPos(),
event.screenPos(), Qt.LeftButton,
event.buttons() | Qt.LeftButton,
event.modifiers())
super().mousePressEvent(fakeEvent)
def middleMouseButtonRelease(self, event):
fakeEvent = QMouseEvent(event.type(), event.localPos(),
event.screenPos(), Qt.LeftButton,
event.buttons() & ~Qt.LeftButton,
event.modifiers())
super().mouseReleaseEvent(fakeEvent)
self.setDragMode(QGraphicsView.RubberBandDrag)
def leftMouseButtonPress(self, event):
# get item which we clicked on
item = self.getItemAtClick(event)
# we store the position of last LMB click
self.last_lmb_click_scene_pos = self.mapToScene(event.pos())
# if DEBUG: print("LMB Click on", item, self.debug_modifiers(event))
# logic
if hasattr(item, "node") or isinstance(
item, QDMGraphicsEdge) or item is None:
if event.modifiers() & Qt.ShiftModifier:
event.ignore()
fakeEvent = QMouseEvent(QEvent.MouseButtonPress,
event.localPos(), event.screenPos(),
Qt.LeftButton,
event.buttons() | Qt.LeftButton,
event.modifiers() | Qt.ControlModifier)
super().mousePressEvent(fakeEvent)
return
if type(item) is QDMGraphicsSocket:
if self.mode == MODE_NOOP:
self.mode = MODE_EDGE_DRAG
self.edgeDragStart(item)
return
if self.mode == MODE_EDGE_DRAG:
res = self.edgeDragEnd(item)
if res: return
if item is None:
if event.modifiers() & Qt.ControlModifier:
self.mode = MODE_EDGE_CUT
fakeEvent = QMouseEvent(QEvent.MouseButtonRelease,
event.localPos(), event.screenPos(),
Qt.LeftButton, Qt.NoButton,
event.modifiers())
super().mouseReleaseEvent(fakeEvent)
QApplication.setOverrideCursor(Qt.CrossCursor)
return
else:
self.rubberBandDraggingRectangle = True
super().mousePressEvent(event)
def leftMouseButtonRelease(self, event):
# get item which we release mouse button on
item = self.getItemAtClick(event)
# logic
if hasattr(item, "node") or isinstance(
item, QDMGraphicsEdge) or item is None:
if event.modifiers() & Qt.ShiftModifier:
event.ignore()
fakeEvent = QMouseEvent(event.type(), event.localPos(),
event.screenPos(), Qt.LeftButton,
Qt.NoButton,
event.modifiers() | Qt.ControlModifier)
super().mouseReleaseEvent(fakeEvent)
return
if self.mode == MODE_EDGE_DRAG:
if self.distanceBetweenClickAndReleaseIsOff(event):
res = self.edgeDragEnd(item)
if res: return
if self.mode == MODE_EDGE_CUT:
self.cutIntersectingEdges()
self.cutline.line_points = []
self.cutline.update()
QApplication.setOverrideCursor(Qt.ArrowCursor)
self.mode = MODE_NOOP
return
if self.rubberBandDraggingRectangle:
self.rubberBandDraggingRectangle = False
current_selected_items = self.grScene.selectedItems()
if current_selected_items != self.grScene.scene._last_selected_items:
if current_selected_items == []:
self.grScene.itemsDeselected.emit()
else:
self.grScene.itemSelected.emit()
self.grScene.scene._last_selected_items = current_selected_items
return
# otherwise deselect everything
if item is None:
self.grScene.itemsDeselected.emit()
super().mouseReleaseEvent(event)
def rightMouseButtonPress(self, event):
super().mousePressEvent(event)
item = self.getItemAtClick(event)
if DEBUG:
if isinstance(item, QDMGraphicsEdge):
print('RMB DEBUG:', item.edge, ' connecting sockets:',
item.edge.start_socket, '<-->', item.edge.end_socket)
if type(item) is QDMGraphicsSocket:
print('RMB DEBUG:', item.socket, 'has edges:',
item.socket.edges)
if item is None:
print('SCENE:')
print(' Nodes:')
for node in self.grScene.scene.nodes:
print(' ', node)
print(' Edges:')
for edge in self.grScene.scene.edges:
print(' ', edge)
def rightMouseButtonRelease(self, event):
super().mouseReleaseEvent(event)
def mouseMoveEvent(self, event):
if self.mode == MODE_EDGE_DRAG:
pos = self.mapToScene(event.pos())
self.drag_edge.grEdge.setDestination(pos.x(), pos.y())
self.drag_edge.grEdge.update()
if self.mode == MODE_EDGE_CUT:
pos = self.mapToScene(event.pos())
self.cutline.line_points.append(pos)
self.cutline.update()
self.last_scene_mouse_position = self.mapToScene(event.pos())
self.scenePosChanged.emit(int(self.last_scene_mouse_position.x()),
int(self.last_scene_mouse_position.y()))
super().mouseMoveEvent(event)
def keyPressEvent(self, event):
# Use this code below if you wanna have shortcuts in this widget.
# You want to use this, when you don't have a window which handles these shortcuts for you
# if event.key() == Qt.Key_Delete:
# if not self.editingFlag:
# self.deleteSelected()
# else:
# super().keyPressEvent(event)
# elif event.key() == Qt.Key_S and event.modifiers() & Qt.ControlModifier:
# self.grScene.scene.saveToFile("graph.json")
# elif event.key() == Qt.Key_L and event.modifiers() & Qt.ControlModifier:
# self.grScene.scene.loadFromFile("graph.json")
# elif event.key() == Qt.Key_Z and event.modifiers() & Qt.ControlModifier and not event.modifiers() & Qt.ShiftModifier:
# self.grScene.scene.history.undo()
# elif event.key() == Qt.Key_Z and event.modifiers() & Qt.ControlModifier and event.modifiers() & Qt.ShiftModifier:
# self.grScene.scene.history.redo()
# elif event.key() == Qt.Key_H:
# print("HISTORY: len(%d)" % len(self.grScene.scene.history.history_stack),
# " -- current_step", self.grScene.scene.history.history_current_step)
# ix = 0
# for item in self.grScene.scene.history.history_stack:
# print("#", ix, "--", item['desc'])
# ix += 1
# else:
super().keyPressEvent(event)
def cutIntersectingEdges(self):
for ix in range(len(self.cutline.line_points) - 1):
p1 = self.cutline.line_points[ix]
p2 = self.cutline.line_points[ix + 1]
for edge in self.grScene.scene.edges:
if edge.grEdge.intersectsWith(p1, p2):
edge.remove()
self.grScene.scene.history.storeHistory("Delete cutted edges",
setModified=True)
def deleteSelected(self):
for item in self.grScene.selectedItems():
if isinstance(item, QDMGraphicsEdge):
item.edge.remove()
elif hasattr(item, 'node'):
item.node.remove()
self.grScene.scene.history.storeHistory("Delete selected",
setModified=True)
def debug_modifiers(self, event):
out = "MODS: "
if event.modifiers() & Qt.ShiftModifier: out += "SHIFT "
if event.modifiers() & Qt.ControlModifier: out += "CTRL "
if event.modifiers() & Qt.AltModifier: out += "ALT "
return out
def getItemAtClick(self, event):
""" return the object on which we've clicked/release mouse button """
pos = event.pos()
obj = self.itemAt(pos)
return obj
def edgeDragStart(self, item):
if DEBUG: print('View::edgeDragStart ~ Start dragging edge')
if DEBUG:
print('View::edgeDragStart ~ assign Start Socket to:',
item.socket)
self.drag_start_socket = item.socket
self.drag_edge = Edge(self.grScene.scene, item.socket, None,
EDGE_TYPE_BEZIER)
if DEBUG: print('View::edgeDragStart ~ dragEdge:', self.drag_edge)
def edgeDragEnd(self, item):
""" return True if skip the rest of the code """
self.mode = MODE_NOOP
if DEBUG: print('View::edgeDragEnd ~ End dragging edge')
self.drag_edge.remove()
self.drag_edge = None
if type(item) is QDMGraphicsSocket:
if item.socket != self.drag_start_socket:
# if we released dragging on a socket (other then the beginning socket)
# we wanna keep all the edges comming from target socket
if not item.socket.is_multi_edges:
item.socket.removeAllEdges()
# we wanna keep all the edges comming from start socket
if not self.drag_start_socket.is_multi_edges:
self.drag_start_socket.removeAllEdges()
new_edge = Edge(self.grScene.scene,
self.drag_start_socket,
item.socket,
edge_type=EDGE_TYPE_BEZIER)
if DEBUG:
print("View::edgeDragEnd ~ created new edge:", new_edge,
"connecting", new_edge.start_socket, "<-->",
new_edge.end_socket)
self.grScene.scene.history.storeHistory(
"Created new edge by dragging", setModified=True)
return True
if DEBUG: print('View::edgeDragEnd ~ everything done.')
return False
def distanceBetweenClickAndReleaseIsOff(self, event):
""" measures if we are too far from the last LMB click scene position """
new_lmb_release_scene_pos = self.mapToScene(event.pos())
dist_scene = new_lmb_release_scene_pos - self.last_lmb_click_scene_pos
edge_drag_threshold_sq = EDGE_DRAG_START_THRESHOLD * EDGE_DRAG_START_THRESHOLD
return (dist_scene.x() * dist_scene.x() +
dist_scene.y() * dist_scene.y()) > edge_drag_threshold_sq
def wheelEvent(self, event):
# calculate our zoom Factor
zoomOutFactor = 1 / self.zoomInFactor
# calculate zoom
if event.angleDelta().y() > 0:
zoomFactor = self.zoomInFactor
self.zoom += self.zoomStep
else:
zoomFactor = zoomOutFactor
self.zoom -= self.zoomStep
clamped = False
if self.zoom < self.zoomRange[0]:
self.zoom, clamped = self.zoomRange[0], True
if self.zoom > self.zoomRange[1]:
self.zoom, clamped = self.zoomRange[1], True
# set scene scale
if not clamped or self.zoomClamp is False:
self.scale(zoomFactor, zoomFactor)
class QDMGraphicsView(QGraphicsView):
"""Class representing NodeEditor's `Graphics View`"""
#: pyqtSignal emitted when cursor position on the `Scene` has changed
scenePosChanged = pyqtSignal(int, int)
def __init__(self, grScene: 'QDMGraphicsScene', parent: 'QWidget' = None):
"""
:param grScene: reference to the :class:`~nodeeditor.node_graphics_scene.QDMGraphicsScene`
:type grScene: :class:`~nodeeditor.node_graphics_scene.QDMGraphicsScene`
:param parent: parent widget
:type parent: ``QWidget``
:Instance Attributes:
- **grScene** - reference to the :class:`~nodeeditor.node_graphics_scene.QDMGraphicsScene`
- **mode** - state of the `Graphics View`
- **zoomInFactor**- ``float`` - zoom step scaling, default 1.25
- **zoomClamp** - ``bool`` - do we clamp zooming or is it infinite?
- **zoom** - current zoom step
- **zoomStep** - ``int`` - the relative zoom step when zooming in/out
- **zoomRange** - ``[min, max]``
"""
super().__init__(parent)
self.grScene = grScene
self.initUI()
self.setScene(self.grScene)
self.mode = MODE_NOOP
self.editingFlag = False
self.rubberBandDraggingRectangle = False
self.zoomInFactor = 1.25
self.zoomClamp = True
self.zoom = 10
self.zoomStep = 1
self.zoomRange = [0, 10]
# cutline
self.cutline = QDMCutLine()
self.grScene.addItem(self.cutline)
# listeners
self._drag_enter_listeners = []
self._drop_listeners = []
def initUI(self):
"""Set up this ``QGraphicsView``"""
self.setRenderHints(QPainter.Antialiasing
| QPainter.HighQualityAntialiasing
| QPainter.TextAntialiasing
| QPainter.SmoothPixmapTransform)
self.setViewportUpdateMode(QGraphicsView.FullViewportUpdate)
self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setTransformationAnchor(QGraphicsView.AnchorUnderMouse)
self.setDragMode(QGraphicsView.RubberBandDrag)
# enable dropping
self.setAcceptDrops(True)
def dragEnterEvent(self, event: QDragEnterEvent):
"""Trigger our registered `Drag Enter` events"""
for callback in self._drag_enter_listeners:
callback(event)
def dropEvent(self, event: QDropEvent):
"""Trigger our registered `Drop` events"""
for callback in self._drop_listeners:
callback(event)
def addDragEnterListener(self, callback: 'function'):
"""
Register callback for `Drag Enter` event
:param callback: callback function
"""
self._drag_enter_listeners.append(callback)
def addDropListener(self, callback: 'function'):
"""
Register callback for `Drop` event
:param callback: callback function
"""
self._drop_listeners.append(callback)
def mousePressEvent(self, event: QMouseEvent):
"""Dispatch Qt's mousePress event to corresponding function below"""
if event.button() == Qt.MiddleButton:
self.middleMouseButtonPress(event)
elif event.button() == Qt.LeftButton:
self.leftMouseButtonPress(event)
elif event.button() == Qt.RightButton:
self.rightMouseButtonPress(event)
else:
super().mousePressEvent(event)
def mouseReleaseEvent(self, event: QMouseEvent):
"""Dispatch Qt's mouseRelease event to corresponding function below"""
if event.button() == Qt.MiddleButton:
self.middleMouseButtonRelease(event)
elif event.button() == Qt.LeftButton:
self.leftMouseButtonRelease(event)
elif event.button() == Qt.RightButton:
self.rightMouseButtonRelease(event)
else:
super().mouseReleaseEvent(event)
def middleMouseButtonPress(self, event: QMouseEvent):
"""When Middle mouse button was pressed"""
item = self.getItemAtClick(event)
# debug print out
if DEBUG:
if isinstance(item, QDMGraphicsEdge):
print('RMB DEBUG:', item.edge, ' connecting sockets:',
item.edge.start_socket, '<-->', item.edge.end_socket)
if type(item) is QDMGraphicsSocket:
print('RMB DEBUG:', item.socket, 'has edges:',
item.socket.edges)
if item is None:
print('SCENE:')
print(' Nodes:')
for node in self.grScene.scene.nodes:
print(' ', node)
print(' Edges:')
for edge in self.grScene.scene.edges:
print(' ', edge)
# faking events for enable MMB dragging the scene
releaseEvent = QMouseEvent(QEvent.MouseButtonRelease, event.localPos(),
event.screenPos(), Qt.LeftButton,
Qt.NoButton, event.modifiers())
super().mouseReleaseEvent(releaseEvent)
self.setDragMode(QGraphicsView.ScrollHandDrag)
fakeEvent = QMouseEvent(event.type(), event.localPos(),
event.screenPos(), Qt.LeftButton,
event.buttons() | Qt.LeftButton,
event.modifiers())
super().mousePressEvent(fakeEvent)
def middleMouseButtonRelease(self, event: QMouseEvent):
"""When Middle mouse button was released"""
fakeEvent = QMouseEvent(event.type(), event.localPos(),
event.screenPos(), Qt.LeftButton,
event.buttons() & ~Qt.LeftButton,
event.modifiers())
super().mouseReleaseEvent(fakeEvent)
self.setDragMode(QGraphicsView.RubberBandDrag)
def leftMouseButtonPress(self, event: QMouseEvent):
"""When Left mouse button was pressed"""
# get item which we clicked on
item = self.getItemAtClick(event)
# we store the position of last LMB click
self.last_lmb_click_scene_pos = self.mapToScene(event.pos())
# if DEBUG: print("LMB Click on", item, self.debug_modifiers(event))
# logic
if hasattr(item, "node") or isinstance(
item, QDMGraphicsEdge) or item is None:
if event.modifiers() & Qt.ShiftModifier:
event.ignore()
fakeEvent = QMouseEvent(QEvent.MouseButtonPress,
event.localPos(), event.screenPos(),
Qt.LeftButton,
event.buttons() | Qt.LeftButton,
event.modifiers() | Qt.ControlModifier)
super().mousePressEvent(fakeEvent)
return
if type(item) is QDMGraphicsSocket:
if self.mode == MODE_NOOP:
self.mode = MODE_EDGE_DRAG
self.edgeDragStart(item)
return
if self.mode == MODE_EDGE_DRAG:
res = self.edgeDragEnd(item)
if res: return
if item is None:
if event.modifiers() & Qt.ControlModifier:
self.mode = MODE_EDGE_CUT
fakeEvent = QMouseEvent(QEvent.MouseButtonRelease,
event.localPos(), event.screenPos(),
Qt.LeftButton, Qt.NoButton,
event.modifiers())
super().mouseReleaseEvent(fakeEvent)
QApplication.setOverrideCursor(Qt.CrossCursor)
return
else:
self.rubberBandDraggingRectangle = True
super().mousePressEvent(event)
def leftMouseButtonRelease(self, event: QMouseEvent):
"""When Left mouse button was released"""
# get item which we release mouse button on
item = self.getItemAtClick(event)
# logic
if hasattr(item, "node") or isinstance(
item, QDMGraphicsEdge) or item is None:
if event.modifiers() & Qt.ShiftModifier:
event.ignore()
fakeEvent = QMouseEvent(event.type(), event.localPos(),
event.screenPos(), Qt.LeftButton,
Qt.NoButton,
event.modifiers() | Qt.ControlModifier)
super().mouseReleaseEvent(fakeEvent)
return
if self.mode == MODE_EDGE_DRAG:
if self.distanceBetweenClickAndReleaseIsOff(event):
res = self.edgeDragEnd(item)
if res: return
if self.mode == MODE_EDGE_CUT:
self.cutIntersectingEdges()
self.cutline.line_points = []
self.cutline.update()
QApplication.setOverrideCursor(Qt.ArrowCursor)
self.mode = MODE_NOOP
return
if self.rubberBandDraggingRectangle:
self.rubberBandDraggingRectangle = False
current_selected_items = self.grScene.selectedItems()
if current_selected_items != self.grScene.scene._last_selected_items:
if current_selected_items == []:
self.grScene.itemsDeselected.emit()
else:
self.grScene.itemSelected.emit()
self.grScene.scene._last_selected_items = current_selected_items
return
# otherwise deselect everything
if item is None:
self.grScene.itemsDeselected.emit()
super().mouseReleaseEvent(event)
def rightMouseButtonPress(self, event: QMouseEvent):
"""When Right mouse button was pressed"""
super().mousePressEvent(event)
def rightMouseButtonRelease(self, event: QMouseEvent):
"""When Right mouse button was release"""
super().mouseReleaseEvent(event)
def mouseMoveEvent(self, event: QMouseEvent):
"""Overriden Qt's ``mouseMoveEvent`` handling Scene/View logic"""
if self.mode == MODE_EDGE_DRAG:
pos = self.mapToScene(event.pos())
self.drag_edge.grEdge.setDestination(pos.x(), pos.y())
self.drag_edge.grEdge.update()
if self.mode == MODE_EDGE_CUT:
pos = self.mapToScene(event.pos())
self.cutline.line_points.append(pos)
self.cutline.update()
self.last_scene_mouse_position = self.mapToScene(event.pos())
self.scenePosChanged.emit(int(self.last_scene_mouse_position.x()),
int(self.last_scene_mouse_position.y()))
super().mouseMoveEvent(event)
def keyPressEvent(self, event: QKeyEvent):
"""
.. note::
This overriden Qt's method was used for handling key shortcuts, before we implemented propper
``QWindow`` with Actions and Menu. Still the commented code serves as an example how to handle
key presses without Qt's framework for Actions and shortcuts. There can be also found an example
how to solve the problem when Node does contain Text/LineEdit and we press `Delete`
key (also serving to delete `Node`)
:param event: Qt's Key event
:type event: ``QKeyEvent``
:return:
"""
# Use this code below if you wanna have shortcuts in this widget.
# You want to use this, when you don't have a window which handles these shortcuts for you
# if event.key() == Qt.Key_Delete:
# if not self.editingFlag:
# self.deleteSelected()
# else:
# super().keyPressEvent(event)
# elif event.key() == Qt.Key_S and event.modifiers() & Qt.ControlModifier:
# self.grScene.scene.saveToFile("graph.json")
# elif event.key() == Qt.Key_L and event.modifiers() & Qt.ControlModifier:
# self.grScene.scene.loadFromFile("graph.json")
# elif event.key() == Qt.Key_Z and event.modifiers() & Qt.ControlModifier and not event.modifiers() & Qt.ShiftModifier:
# self.grScene.scene.history.undo()
# elif event.key() == Qt.Key_Z and event.modifiers() & Qt.ControlModifier and event.modifiers() & Qt.ShiftModifier:
# self.grScene.scene.history.redo()
# elif event.key() == Qt.Key_H:
# print("HISTORY: len(%d)" % len(self.grScene.scene.history.history_stack),
# " -- current_step", self.grScene.scene.history.history_current_step)
# ix = 0
# for item in self.grScene.scene.history.history_stack:
# print("#", ix, "--", item['desc'])
# ix += 1
# else:
super().keyPressEvent(event)
def cutIntersectingEdges(self):
"""Compare which `Edges` intersect with current `Cut line` and delete them safely"""
for ix in range(len(self.cutline.line_points) - 1):
p1 = self.cutline.line_points[ix]
p2 = self.cutline.line_points[ix + 1]
for edge in self.grScene.scene.edges:
if edge.grEdge.intersectsWith(p1, p2):
edge.remove()
self.grScene.scene.history.storeHistory("Delete cutted edges",
setModified=True)
def deleteSelected(self):
"""Shortcut for safe deleting every object selected in the `Scene`."""
for item in self.grScene.selectedItems():
if isinstance(item, QDMGraphicsEdge):
item.edge.remove()
elif hasattr(item, 'node'):
item.node.remove()
self.grScene.scene.history.storeHistory("Delete selected",
setModified=True)
def debug_modifiers(self, event):
"""Helper function get string if we hold Ctrl, Shift or Alt modifier keys"""
out = "MODS: "
if event.modifiers() & Qt.ShiftModifier: out += "SHIFT "
if event.modifiers() & Qt.ControlModifier: out += "CTRL "
if event.modifiers() & Qt.AltModifier: out += "ALT "
return out
def getItemAtClick(self, event: QEvent) -> 'QGraphicsItem':
"""Return the object on which we've clicked/release mouse button
:param event: Qt's mouse or key event
:type event: ``QEvent``
:return: ``QGraphicsItem`` which the mouse event happened or ``None``
"""
pos = event.pos()
obj = self.itemAt(pos)
return obj
def edgeDragStart(self, item: 'QGraphicsItem'):
"""Code handling the start of dragging an `Edge` operation"""
try:
if DEBUG: print('View::edgeDragStart ~ Start dragging edge')
if DEBUG:
print('View::edgeDragStart ~ assign Start Socket to:',
item.socket)
self.drag_start_socket = item.socket
self.drag_edge = Edge(self.grScene.scene, item.socket, None,
EDGE_TYPE_BEZIER)
if DEBUG:
print('View::edgeDragStart ~ dragEdge:', self.drag_edge)
except Exception as e:
dumpException(e)
def edgeDragEnd(self, item: 'QGraphicsItem'):
"""Code handling the end of dragging an `Edge` operation. In this code return True if skip the
rest of the mouse event processing
:param item: Item in the `Graphics Scene` where we ended dragging an `Edge`
:type item: ``QGraphicsItem``
"""
self.mode = MODE_NOOP
if DEBUG: print('View::edgeDragEnd ~ End dragging edge')
self.drag_edge.remove()
self.drag_edge = None
try:
if type(item) is QDMGraphicsSocket:
if item.socket != self.drag_start_socket:
# if we released dragging on a socket (other then the beginning socket)
# we wanna keep all the edges comming from target socket
if not item.socket.is_multi_edges:
item.socket.removeAllEdges()
# we wanna keep all the edges comming from start socket
if not self.drag_start_socket.is_multi_edges:
self.drag_start_socket.removeAllEdges()
new_edge = Edge(self.grScene.scene,
self.drag_start_socket,
item.socket,
edge_type=EDGE_TYPE_BEZIER)
if DEBUG:
print("View::edgeDragEnd ~ created new edge:",
new_edge, "connecting", new_edge.start_socket,
"<-->", new_edge.end_socket)
for socket in [self.drag_start_socket, item.socket]:
socket.node.onEdgeConnectionChanged(new_edge)
if socket.is_input:
socket.node.onInputChanged(new_edge)
self.grScene.scene.history.storeHistory(
"Created new edge by dragging", setModified=True)
return True
except Exception as e:
dumpException(e)
if DEBUG: print('View::edgeDragEnd ~ everything done.')
return False
def distanceBetweenClickAndReleaseIsOff(self, event: QMouseEvent) -> bool:
""" Measures if we are too far from the last Mouse button click scene position.
This is used for detection if we release too far after we clicked on a `Socket`
:param event: Qt's mouse event
:type event: ``QMouseEvent``
:return: ``True`` if we released too far from where we clicked before
"""
new_lmb_release_scene_pos = self.mapToScene(event.pos())
dist_scene = new_lmb_release_scene_pos - self.last_lmb_click_scene_pos
edge_drag_threshold_sq = EDGE_DRAG_START_THRESHOLD * EDGE_DRAG_START_THRESHOLD
return (dist_scene.x() * dist_scene.x() +
dist_scene.y() * dist_scene.y()) > edge_drag_threshold_sq
def wheelEvent(self, event: QWheelEvent):
"""overriden Qt's ``wheelEvent``. This handles zooming"""
# calculate our zoom Factor
zoomOutFactor = 1 / self.zoomInFactor
# calculate zoom
if event.angleDelta().y() > 0:
zoomFactor = self.zoomInFactor
self.zoom += self.zoomStep
else:
zoomFactor = zoomOutFactor
self.zoom -= self.zoomStep
clamped = False
if self.zoom < self.zoomRange[0]:
self.zoom, clamped = self.zoomRange[0], True
if self.zoom > self.zoomRange[1]:
self.zoom, clamped = self.zoomRange[1], True
# set scene scale
if not clamped or self.zoomClamp is False:
self.scale(zoomFactor, zoomFactor)
def deserializeFromClipboard(self, data:dict, *args, **kwargs):
"""
Deserializes data from Clipboard.
:param data: ``dict`` data for deserialization to the :class:`nodeeditor.node_scene.Scene`.
:type data: ``dict``
"""
hashmap = {}
# calculate mouse pointer - scene position
view = self.scene.getView()
mouse_scene_pos = view.last_scene_mouse_position
# calculate selected objects bbox and center
minx, maxx, miny, maxy = 10000000,-10000000, 10000000,-10000000
for node_data in data['nodes']:
x, y = node_data['pos_x'], node_data['pos_y']
if x < minx: minx = x
if x > maxx: maxx = x
if y < miny: miny = y
if y > maxy: maxy = y
# add width and height of a node
maxx -= 180
maxy += 100
relbboxcenterx = (minx + maxx) / 2 - minx
relbboxcentery = (miny + maxy) / 2 - miny
if DEBUG_PASTING:
print (" *** PASTA:")
print("Copied boudaries:\n\tX:", minx, maxx, " Y:", miny, maxy)
print("\tbbox_center:", relbboxcenterx, relbboxcentery)
# calculate the offset of the newly creating nodes
mousex, mousey = mouse_scene_pos.x(), mouse_scene_pos.y()
# create each node
created_nodes = []
self.scene.setSilentSelectionEvents()
self.scene.doDeselectItems()
for node_data in data['nodes']:
new_node = self.scene.getNodeClassFromData(node_data)(self.scene)
new_node.deserialize(node_data, hashmap, restore_id=False, *args, **kwargs)
created_nodes.append(new_node)
# readjust the new nodeeditor's position
# new node's current position
posx, posy = new_node.pos.x(), new_node.pos.y()
newx, newy = mousex + posx - minx, mousey + posy - miny
new_node.setPos(newx, newy)
new_node.doSelect()
if DEBUG_PASTING:
print("** PASTA SUM:")
print("\tMouse pos:", mousex, mousey)
print("\tnew node pos:", posx, posy)
print("\tFINAL:", newx, newy)
# create each edge
if 'edges' in data:
for edge_data in data['edges']:
new_edge = Edge(self.scene)
new_edge.deserialize(edge_data, hashmap, restore_id=False, *args, **kwargs)
self.scene.setSilentSelectionEvents(False)
# store history
self.scene.history.storeHistory("Pasted elements in scene", setModified=True)
return created_nodes
def deserialize(self,
data: dict,
hashmap: dict = {},
restore_id: bool = True,
*args,
**kwargs) -> bool:
hashmap = {}
if restore_id: self.id = data['id']
# -- deserialize NODES
## Instead of recreating all the nodes, reuse existing ones...
# get list of all current nodes:
all_nodes = self.nodes.copy()
# go through deserialized nodes:
for node_data in data['nodes']:
# can we find this node in the scene?
found = False
for node in all_nodes:
if node.id == node_data['id']:
found = node
break
if not found:
try:
new_node = self.getNodeClassFromData(node_data)(self)
new_node.deserialize(node_data, hashmap, restore_id, *args,
**kwargs)
new_node.onDeserialized(node_data)
# print("New node for", node_data['title'])
except:
dumpException()
else:
try:
found.deserialize(node_data, hashmap, restore_id, *args,
**kwargs)
found.onDeserialized(node_data)
all_nodes.remove(found)
# print("Reused", node_data['title'])
except:
dumpException()
# remove nodes which are left in the scene and were NOT in the serialized data!
# that means they were not in the graph before...
while all_nodes != []:
node = all_nodes.pop()
node.remove()
# -- deserialize EDGES
## Instead of recreating all the edges, reuse existing ones...
# get list of all current edges:
all_edges = self.edges.copy()
# go through deserialized edges:
for edge_data in data['edges']:
# can we find this node in the scene?
found = False
for edge in all_edges:
if edge.id == edge_data['id']:
found = edge
break
if not found:
new_edge = Edge(self).deserialize(edge_data, hashmap,
restore_id, *args, **kwargs)
# print("New edge for", edge_data)
else:
found.deserialize(edge_data, hashmap, restore_id, *args,
**kwargs)
all_edges.remove(found)
# remove nodes which are left in the scene and were NOT in the serialized data!
# that means they were not in the graph before...
while all_edges != []:
edge = all_edges.pop()
edge.remove()
return True
from nodeeditor.utils import loadStylesheets from nodeeditor.node_editor_window import NodeEditorWindow from kelebek_sub_window import KelebekSubWindow # from kelebek_drag_listbox import QDMDragListbox from kelebek_treeview import KelebekTreeView from kelebek_node_factory import FactoryView from kelebek_conf import * from nodeeditor.utils import dumpException, pp # Enabling edge validators from nodeeditor.node_edge import Edge from nodeeditor.node_edge_validators import * # Edge.registerEdgeValidator(edge_validator_debug) Edge.registerEdgeValidator(edge_cannot_connect_two_outputs_or_two_inputs) Edge.registerEdgeValidator(edge_cannot_connect_input_and_output_of_same_node) # images for the dark skin import qss.nodeeditor_dark_resources DEBUG = False # TODO increase the zoom in factor # TODO People should be able to make their own nodes and dashboard components. Ex: in-house vs custom. connect to # external .py files # TODO Chat # TODO Integrated Dashboard, maybe can integrate qt with local host server to utilise JS/Django shit. # TODO https://stackoverflow.com/questions/3770084/efficiently-updating-a-qtableview-at-high-speed?rq=1 # https://dribbble.com/shots/15266170-Bitoket-cryptocurrency-UI-and-UX-Design-Darkmode/attachments/7017779?mode=media # https://dribbble.com/shots/7797656-Tree-View/attachments/458993?mode=media # https://dribbble.com/shots/13964955-Bitoket-cryptocurrency-Dashboard-UI-and-UX-Design
