def testUndoOnDeletedElement(self):
b1 = Box()
b2 = Box()
line = Line()
canvas = Canvas()
canvas.add(b1)
self.assertEqual(2, len(canvas.solver.constraints))
canvas.add(b2)
self.assertEqual(4, len(canvas.solver.constraints))
canvas.add(line)
sink = ConnectionSink(b1, b1.ports()[0])
connector = Connector(line, line.handles()[0])
connector.connect(sink)
sink = ConnectionSink(b2, b2.ports()[0])
connector = Connector(line, line.handles()[-1])
connector.connect(sink)
self.assertEqual(6, len(canvas.solver.constraints))
self.assertEqual(2, len(list(canvas.get_connections(item=line))))
del undo_list[:]
# Here disconnect is not invoked!
canvas.remove(b2)
self.assertEqual(3, len(canvas.solver.constraints))
self.assertEqual(1, len(list(canvas.get_connections(item=line))))
cinfo = canvas.get_connection(line.handles()[0])
self.assertEqual(b1, cinfo.connected)
cinfo = canvas.get_connection(line.handles()[-1])
self.assertEqual(None, cinfo)
self.assertEqual([],
list(
canvas.solver.constraints_with_variable(
line.handles()[-1].pos.x)))
self.assertEqual([],
list(
canvas.solver.constraints_with_variable(
line.handles()[-1].pos.y)))
undo()
self.assertEqual(6, len(canvas.solver.constraints))
self.assertEqual(2, len(list(canvas.get_connections(item=line))))
cinfo = canvas.get_connection(line.handles()[0])
self.assertEqual(b1, cinfo.connected)
cinfo = canvas.get_connection(line.handles()[-1])
self.assertEqual(b2, cinfo.connected)
def find_port(line, handle, item):
#port = None
#max_dist = sys.maxint
canvas = item.canvas
ix, iy = canvas.get_matrix_i2i(line, item).transform_point(*handle.pos)
# find the port using item's coordinates
sink = ConnectionSink(item, None)
return sink.find_port((ix, iy))
def find_port(line, handle, item):
# port = None
# max_dist = sys.maxint
canvas = item.canvas
ix, iy = canvas.get_matrix_i2i(line, item).transform_point(*handle.pos)
# find the port using item's coordinates
sink = ConnectionSink(item, None)
return sink.find_port((ix, iy))
def test_undo_on_delete_element(revert_undo, undo_fixture):
b1 = Box()
b2 = Box()
line = Line()
canvas = Canvas()
canvas.add(b1)
assert 2 == len(canvas.solver.constraints)
canvas.add(b2)
assert 4 == len(canvas.solver.constraints)
canvas.add(line)
sink = ConnectionSink(b1, b1.ports()[0])
connector = Connector(line, line.handles()[0])
connector.connect(sink)
sink = ConnectionSink(b2, b2.ports()[0])
connector = Connector(line, line.handles()[-1])
connector.connect(sink)
assert 6 == len(canvas.solver.constraints)
assert 2 == len(list(canvas.get_connections(item=line)))
del undo_fixture[2][:] # Clear undo_list
# Here disconnect is not invoked!
canvas.remove(b2)
assert 3 == len(canvas.solver.constraints)
assert 1 == len(list(canvas.get_connections(item=line)))
cinfo = canvas.get_connection(line.handles()[0])
assert b1 == cinfo.connected
cinfo = canvas.get_connection(line.handles()[-1])
assert cinfo is None
assert [] == list(
canvas.solver.constraints_with_variable(line.handles()[-1].pos.x))
assert [] == list(
canvas.solver.constraints_with_variable(line.handles()[-1].pos.y))
undo_fixture[0]() # Call undo
assert 6 == len(canvas.solver.constraints)
assert 2 == len(list(canvas.get_connections(item=line)))
cinfo = canvas.get_connection(line.handles()[0])
assert b1 == cinfo.connected
cinfo = canvas.get_connection(line.handles()[-1])
assert b2 == cinfo.connected
def test_connect(diagram, comment, commentline):
sink = ConnectionSink(comment, comment.ports()[0])
aspect = Connector(commentline, commentline.handles()[0])
aspect.connect(sink)
canvas = diagram.canvas
cinfo = canvas.get_connection(commentline.handles()[0])
assert cinfo, cinfo
def test_allow(commentline, comment):
aspect = Connector(commentline, commentline.handles()[0])
assert aspect.item is commentline
assert aspect.handle is commentline.handles()[0]
sink = ConnectionSink(comment, comment.ports()[0])
assert aspect.allow(sink)
def test_allow(self):
aspect = Connector(self.commentline, self.commentline.handles()[0])
assert aspect.item is self.commentline
assert aspect.handle is self.commentline.handles()[0]
sink = ConnectionSink(self.comment, self.comment.ports()[0])
assert aspect.allow(sink)
def test_connect(self):
sink = ConnectionSink(self.comment, self.comment.ports()[0])
aspect = Connector(self.commentline, self.commentline.handles()[0])
aspect.connect(sink)
canvas = self.diagram.canvas
cinfo = canvas.get_connection(self.commentline.handles()[0])
assert cinfo, cinfo
def on_button_release(self, event):
"""
This handles and 'drag' part of any connection, after the
on_button_press of this tool returns a True (i.e by clicking on an
Line Handle) the on_button_release is triggered on mouse button release.
Note that this handles both the new connections and modified
connections.
Hint:
ConnectorTool is a child of this class.
Uncommenting all the print statements should give a fair idea how this
tool works.
"""
line = self.grabbed_item
handle = self.grabbed_handle
glueitem, glueport, gluepos = self.view.get_port_at_point(
(event.x, event.y), distance=10, exclude=[line])
line = self.grabbed_item
handle = self.grabbed_handle
try:
if glueport and hasattr(glueport, "point"):
#print 'READY_CONNECTION_CHECK_PASSED_1'
conn = Connector(line, handle)
sink = ConnectionSink(glueitem, glueport)
conn.connect_port(sink)
self.ungrab_handle()
#print 'READY_CONNECTION_CHECK_PASSED_2'
except Exception as e:
print 'Connection Failed, Disconnect/Connect the last Connection again: /n', e
finally:
self.toggle_highlight_ports()
return super(BlockConnectTool, self).on_button_release(event)
def test_remove_connected_item():
"""Test adding canvas constraint.
"""
canvas = Canvas()
from gaphas.aspect import Connector, ConnectionSink
l1 = Line()
canvas.add(l1)
b1 = Box()
canvas.add(b1)
number_cons1 = len(canvas.solver.constraints)
b2 = Box()
canvas.add(b2)
number_cons2 = len(canvas.solver.constraints)
conn = Connector(l1, l1.handles()[0])
sink = ConnectionSink(b1, b1.ports()[0])
conn.connect(sink)
assert canvas.get_connection(l1.handles()[0])
conn = Connector(l1, l1.handles()[1])
sink = ConnectionSink(b2, b2.ports()[0])
conn.connect(sink)
assert canvas.get_connection(l1.handles()[1])
assert number_cons2 + 2 == len(canvas.solver.constraints)
canvas.remove(b1)
# Expecting a class + line connected at one end only
assert number_cons1 + 1 == len(canvas.solver.constraints)
def glue(self, pos, distance=None):
"""
Glue to an item near a specific point.
Returns a ConnectionSink or None.
"""
item = self.item
handle = self.handle
view = self.view
if distance is None:
distance = self.GLUE_DISTANCE
if not handle.connectable:
return None
state_v, port, glue_pos = view.get_port_at_point(
pos,
distance=distance,
exclude=(item, ),
exclude_port_fun=self._exclude_port)
# check if item and found item can be connected on closest port
if port is not None:
assert state_v is not None
connector = Connector(self.item, self.handle)
sink = ConnectionSink(state_v, port)
if connector.allow(sink):
# transform coordinates from view space to the item space and
# update position of item's handle
v2i = view.get_matrix_v2i(item).transform_point
handle.pos = v2i(*glue_pos)
return sink
state_l = view.get_state_at_point(pos, distance=distance)
state_v = state_l
if state_v is not None and not state_v.model.state.is_root_state:
return ConnectionSink(state_v, None)
return None
def _get_sink(item, handle, target):
assert item.canvas
hpos = item.canvas.get_matrix_i2i(item, target).transform_point(*handle.pos)
port = None
dist = 10e6
for p in target.ports():
pos, d = p.glue(hpos)
if not port or d < dist:
port = p
dist = d
return ConnectionSink(target, port)
def connect(self, line, handle, item, port=None):
"""
Connect line's handle to an item.
If port is not provided, then first port is used.
"""
canvas = line.canvas
if port is None and len(item.ports()) > 0:
port = item.ports()[0]
sink = ConnectionSink(item, port)
connector = Connector(line, handle)
connector.connect(sink)
def connect(line, handle, item, port=None):
"""Connect line's handle to an item.
If port is not provided, then first port is used.
"""
canvas = line.canvas
assert canvas is item.canvas
if port is None and len(item.ports()) > 0:
port = item.ports()[0]
sink = ConnectionSink(item, port)
connector = Connector(line, handle)
connector.connect(sink)
cinfo = canvas.get_connection(handle)
assert cinfo.connected is item
assert cinfo.port is port
def on_button_press(self, event):
glueitem, glueport, gluepos = self.view.get_port_at_point(
(event.x, event.y), distance=10, exclude=[])
line, handle = self.view.get_handle_at_point((event.x, event.y))
try:
if glueport and hasattr(glueport, "point"):
self.toggle_highlight_ports(glueport.portinstance)
self.line = self._create_line((event.x, event.y))
self._new_item = self.line
h_glue = self.line.handles()[self._handle_index_glued]
conn = Connector(self.line, h_glue)
sink = ConnectionSink(glueitem, glueport)
conn.connect_port(sink)
h_drag = self.line.handles()[self._handle_index_dragged]
self.grab_handle(self.line, h_drag)
return True
except Exception as e:
print 'Connection Failed, Disconnect/Connect the last Connection again: /n', e
def _get_sink(self, handle, item):
"""
Instant port finder.
This is not the nicest place for such method.
TODO: figure out if part of this functionality can be provided by
the storage code.
"""
from gaphas.aspect import ConnectionSink
hpos = self.canvas.get_matrix_i2i(self, item).transform_point(*handle.pos)
port = None
dist = 10e6
for p in item.ports():
pos, d = p.glue(hpos)
if not port or d < dist:
port = p
dist = d
return ConnectionSink(item, port)
