root/gaphor/tags/gaphor-0.12.0/gaphor/adapters/connectors.py

"""
Adapters
"""

from zope import interface, component

from gaphas.item import NW, NE, SW, SE
from gaphas.canvas import CanvasProjection
from gaphas.matrix import Matrix
from gaphas import geometry
from gaphas import constraint
from gaphor import UML
from gaphor.core import inject
from gaphor.diagram.interfaces import IConnect
from gaphor.diagram import items
from gaphor.misc.ipair import ipair

class AbstractConnect(object):
    """
    Connection adapter for Gaphor diagram items.

    Line item ``line`` connects with a handle to a connectable item ``element``.

    Line constraint is created between ``line`` handle and two handles of ``element``
    (called segment, see ``AbstractConnect._get_segment`` method).

    Attributes:

    - line: connecting item
    - element: connectable item
    - _canvas: canvas reference
    - _matrix_e2l: element to line matrix
    - _matrix_l2e: line to element matrix
    """
    interface.implements(IConnect)

    def __init__(self, element, line):
        self.element = element
        self.line = line
        canvas = self._canvas = element.canvas

        i2c = canvas.get_matrix_i2c
        c2i = canvas.get_matrix_c2i
        self._matrix_e2l = i2c(element) * c2i(line)
        self._matrix_l2e = i2c(line) * c2i(element)

        # code below returns None from transform_point... why?
        # self._matrix_l2e = Matrix(*self._matrix_e2l)
        # self._matrix_l2e.invert()


    def glue(self, handle):
        """
        Return the point the handle could connect to. None if no connection
        is allowed.
        """
        raise NotImplemented, 'Implement glue() in the subclass'

    def connect(self, handle):
        """
        Connect to an element. Note that at this point the line may
        be connected to some other, or the same element by means of the
        handle.connected_to property. Also the connection at UML level
        still exists.
        
        Returns True if a connection is established.
        """
        element = self.element
        canvas = element.canvas
        solver = canvas.solver

        # Disconnect old model connection
        if handle.connected_to and handle.connected_to is not self.element:
            handle.disconnect()
 
        # Save guard: only connect if it's permitted by glue()
        #   -> glue() does not return None
        if not self.glue(handle):
            return False

        self.connect_constraints(handle)

        # Set disconnect handler in the adapter, so it will also wotk if
        # connections are created programmatically.
        def _disconnect():
            self.disconnect(handle)
            handle.disconnect = lambda: 0
        handle.disconnect = _disconnect

        return True

    def disconnect(self, handle):
        """
        Do a full disconnect, also disconnect at UML model level.
        Subclasses should disconnect model-level connections.
        """
        self.disconnect_constraints(handle)
        handle.connected_to = None


    def connect_constraints(self, handle):
        """
        Create the actual constraint. The handle should be moved into connection
        position before this method is called.
        """
        h1, h2 = self._get_segment(handle)

        element = self.element
        line = self.line

        lc = constraint.LineConstraint(line=(CanvasProjection(h1.pos, element),
                                             CanvasProjection(h2.pos, element)),
                                       point=CanvasProjection(handle.pos, line))
        handle._connect_constraint = lc
        element.canvas.solver.add_constraint(lc)

        handle.connected_to = element


    def disconnect_constraints(self, handle):
        """
        Disconnect() takes care of disconnecting the handle from the
        element it's attached to, by removing the constraints.
        """
        try:
            if handle._connect_constraint:
                self.line.canvas.solver.remove_constraint(handle._connect_constraint)
        except AttributeError:
            pass # No _connect_constraint property yet
        handle._connect_constraint = None


    def _get_segment(self, handle):
        """
        Get line segment, to which handle should connect to. Line segment is defined by two handles.
        Examples of line segmets
        - side of element item like class, action, etc.
        - line segment of association
        - lifeline's lifetime
        """
        raise NotImplemented()



class ElementConnect(AbstractConnect):
    """
    Base class for connecting a line to an ElementItem class.
    """

    def _get_segment(self, handle):
        """
        Determine the side on which the handle is connecting.
        This is done by determining the proximity to the nearest edge.

        Handles of one of the sides is returned.
        """
        handles = self.element.handles()
        l2e = self._matrix_l2e
        hx, hy = l2e.transform_point(*handle.pos)
        ax, ay = handles[NW].x, handles[NW].y
        bx, by = handles[SE].x, handles[SE].y

        if abs(hx - ax) < 0.01:
            return handles[NW], handles[SW]
        elif abs(hy - ay) < 0.01:
            return handles[NW], handles[NE]
        elif abs(hx - bx) < 0.01:
            return handles[NE], handles[SE]
        else:
            return handles[SW], handles[SE]
        assert False


    def bounds(self, element):
        """
        Returns bounds of the element that we're connecting to.
        """
        h = element.handles()
        return map(float, (h[NW].pos + h[SE].pos))


    def glue(self, handle):
        """
        Return the point the handle could connect to. None if no connection
        is allowed.
        """
        l2e = self._matrix_l2e
        e2l = self._matrix_e2l

        pos = l2e.transform_point(*handle.pos)
        bounds = self.bounds(self.element)

        pos = geometry.point_on_rectangle(bounds, pos, border=True)
        pos = e2l.transform_point(*pos)
        return pos



class LineConnect(AbstractConnect):
    """
    Base class for connecting two lines to each other.
    The line that is conencted to is called 'element', as in ElementConnect.

    Once a line has been connected at both ends, and a model element is
    assigned to it, all items connectedt to this line (e.g. Comments)
    receive a connect() call. This allows already connected lines to set
    up relationships at model level too.
    """

    def _get_segment_data(self, handle):
        """
        Get segment data
        - pos: position on a segment
        - h1: handle starting segment
        - h2: handle ending segment
        """
        dlp = geometry.distance_line_point

        handles = self.element.handles()

        def segment(h1, h2, pos):
            d, pos = dlp(h1.pos, h2.pos, pos)
            return d, pos, h1, h2

        pos = self._matrix_l2e.transform_point(*handle.pos)

        # find the nearest segment from handle
        data = (segment(h1, h2, pos) for h1, h2 in ipair(handles))
        # No key needed, distance is first
        d, pos, h1, h2 = min(data) #, key=lambda s: s[0])
        return pos, h1, h2


    def _get_segment(self, handle):
        """
        Return diagram line segment closest to a handle.
        """
        _, h1, h2 = self._get_segment_data(handle)
        return h1, h2


    def glue(self, handle):
        """
        Return a point on a connectable element closest to a handle.
        """
        pos, _, _ = self._get_segment_data(handle)
        return self._matrix_e2l.transform_point(*pos)



class CommentLineElementConnect(ElementConnect):
    """
    Connect a comment line to any element item.
    """
    component.adapts(items.ElementItem, items.CommentLineItem)

    def glue(self, handle):
        """
        In addition to the normal check, both line ends may not be connected
        to the same element. Same goes for subjects.
        One of the ends should be connected to a UML.Comment element.
        """
        opposite = self.line.opposite(handle)
        element = self.element
        connected_to = opposite.connected_to
        if connected_to is element:
            return None

        # Same goes for subjects:
        if connected_to and \
                (not (connected_to.subject or element.subject)) \
                 and connected_to.subject is element.subject:
            #print 'Subjects none or match:', connected_to.subject, element.subject
            return None

        # One end should be connected to a CommentItem:
        cls = items.CommentItem
        glue_ok = isinstance(connected_to, cls) ^ isinstance(self.element, cls)
        if connected_to and not glue_ok:
            return None

        return super(CommentLineElementConnect, self).glue(handle)

    def connect(self, handle):
        if super(CommentLineElementConnect, self).connect(handle):
            opposite = self.line.opposite(handle)
            if opposite.connected_to:
                if isinstance(opposite.connected_to.subject, UML.Comment):
                    opposite.connected_to.subject.annotatedElement = self.element.subject
                else:
                    self.element.subject.annotatedElement = opposite.connected_to.subject

    def disconnect(self, handle):
        opposite = self.line.opposite(handle)
        if handle.connected_to and opposite.connected_to:
            if isinstance(opposite.connected_to.subject, UML.Comment):
                del opposite.connected_to.subject.annotatedElement[handle.connected_to.subject]
            else:
                del handle.connected_to.subject.annotatedElement[opposite.connected_to.subject]
        super(CommentLineElementConnect, self).disconnect(handle)

component.provideAdapter(CommentLineElementConnect)


class CommentLineLineConnect(LineConnect):
    """
    Connect a comment line to any diagram line.
    """
    component.adapts(items.DiagramLine, items.CommentLineItem)

    def glue(self, handle):
        """
        In addition to the normal check, both line ends may not be connected
        to the same element. Same goes for subjects.
        One of the ends should be connected to a UML.Comment element.
        """
        opposite = self.line.opposite(handle)
        element = self.element
        connected_to = opposite.connected_to

        # do not connect to the same item nor connect to other comment line
        if connected_to is element or isinstance(element, items.CommentLineItem):
            return None

        # Same goes for subjects:
        if connected_to and \
                (not (connected_to.subject or element.subject)) \
                 and connected_to.subject is element.subject:
            return None

        # One end should be connected to a CommentItem:
        cls = items.CommentItem
        glue_ok = isinstance(connected_to, cls) ^ isinstance(self.element, cls)
        if connected_to and not glue_ok:
            return None

        return super(CommentLineLineConnect, self).glue(handle)

    def connect(self, handle):
        if super(CommentLineLineConnect, self).connect(handle):
            opposite = self.line.opposite(handle)
            if opposite.connected_to and self.element.subject:
                if isinstance(opposite.connected_to.subject, UML.Comment):
                    opposite.connected_to.subject.annotatedElement = self.element.subject
                else:
                    self.element.subject.annotatedElement = opposite.connected_to.subject

    def disconnect(self, handle):
        opposite = self.line.opposite(handle)
        if handle.connected_to and opposite.connected_to:
            if isinstance(handle.connected_to.subject, UML.Comment):
                del handle.connected_to.subject.annotatedElement[opposite.connected_to.subject]
            elif opposite.connected_to.subject:
                del opposite.connected_to.subject.annotatedElement[handle.connected_to.subject]
        super(CommentLineLineConnect, self).disconnect(handle)

component.provideAdapter(CommentLineLineConnect)


class RelationshipConnect(ElementConnect):
    """
    Base class for relationship connections, such as associations,
    dependencies and implementations.

    This class introduces a new method: relationship() which is used to
    find an existing relationship in the model that does not yet exist
    on the canvas.
    """

    element_factory = inject('element_factory')

    def relationship(self, required_type, head, tail):
        """
        Find an existing relationship in the model that meets the
        required type and is connected to the same model element the head
        and tail of the line are conncted to.

        type - the type of relationship we're looking for
        head - tuple (association name on line, association name on element)
        tail - tuple (association name on line, association name on element)
        """
        line = self.line

        head_subject = line.head.connected_to.subject
        tail_subject = line.tail.connected_to.subject

        edge_head_name = head[0]
        node_head_name = head[1]
        edge_tail_name = tail[0]
        node_tail_name = tail[1]

        # First check if the right subject is already connected:
        if line.subject \
           and getattr(line.subject, edge_head_name) is head_subject \
           and getattr(line.subject, edge_tail_name) is tail_subject:
            return line.subject

        # This is the type of the relationship we're looking for
        #required_type = getattr(type(tail_subject), node_tail_name).type

        # Try to find a relationship, that is already created, but not
        # yet displayed in the diagram.
        for gen in getattr(tail_subject, node_tail_name):
            if not isinstance(gen, required_type):
                continue
                
            gen_head = getattr(gen, edge_head_name)
            try:
                if not head_subject in gen_head:
                    continue
            except TypeError:
                if not gen_head is head_subject:
                    continue

            # check for this entry on line.canvas
            for item in gen.presentation:
                # Allow line to be returned. Avoids strange
                # behaviour during loading
                if item.canvas is line.canvas and item is not line:
                    break
            else:
                return gen
        return None

    def relationship_or_new(self, type, head, tail):
        """
        Like relation(), but create a new instance of none was found.
        """
        relation = self.relationship(type, head, tail)
        if not relation:
            line = self.line
            relation = self.element_factory.create(type)
            setattr(relation, head[0], line.head.connected_to.subject)
            setattr(relation, tail[0], line.tail.connected_to.subject)
        return relation

    def connect_connected_items(self, connected_items=None):
        """
        Cause items connected to ``line`` to reconnect, allowing them to
        establish or destroy relationships at model level.
        """
        line = self.line
        canvas = line.canvas
        solver = canvas.solver

        # First make sure coordinates match
        solver.solve()
        for item, handle in connected_items or line.canvas.get_connected_items(line):
            adapter = component.queryMultiAdapter((line, item), IConnect)
            assert adapter
            adapter.connect(handle)
        
    def disconnect_connected_items(self):
        """
        Cause items connected to @line to be disconnected.
        This is nessesary if the subject of the @line is to be removed.

        Returns a list of (item, handle) pairs that were connected (this
        list can be used to connect items again with connect_connected_items()).
        """
        line = self.line
        canvas = line.canvas
        solver = canvas.solver

        # First make sure coordinates match
        solver.solve()
        connected_items = list(line.canvas.get_connected_items(line))
        for item, handle in connected_items:
            adapter = component.queryMultiAdapter((line, item), IConnect)
            assert adapter
            adapter.disconnect(handle)
        return connected_items

    def connect_subject(self, handle):
        """
        Establish the relationship at model level.
        """
        raise NotImplemented, 'Implement connect_subject() in a subclass'

    def disconnect_subject(self, handle):
        """
        Disconnect the diagram item from its model element. If there are
        no more presentations(diagram items) connected to the model element,
        unlink() it too.
        """
        line = self.line
        old = line.subject
        del line.subject
        if old and len(old.presentation) == 0:
            old.unlink()

    def connect(self, handle):
        """
        Connect the items to each other. The model level relationship
        is created by create_subject()
        """
        if super(RelationshipConnect, self).connect(handle):
            opposite = self.line.opposite(handle)
            if opposite.connected_to:
                self.connect_subject(handle)
                line = self.line
                if line.subject:
                    self.connect_connected_items()

    def disconnect(self, handle):
        """
        Disconnect model element.
        """
        line = self.line
        opposite = line.opposite(handle)
        if handle.connected_to and opposite.connected_to:
            old = line.subject
             
            connected_items = self.disconnect_connected_items()
            
            self.disconnect_subject(handle)
            if old:
                self.connect_connected_items(connected_items)

        super(RelationshipConnect, self).disconnect(handle)