                 // We are drawing
                 currentStroke.addPoint(point)
                 
-            } else if let dragStart = makeConnectionDragStart {
+            } else if let drawConnectionInfo = currentDrawingConnection {
                 // We are dragging between connectors
-                let targetConnector = connectorPortForDragAtLocation(point)?.ConnectorPort
                 
                 if let oldDragLine = currentDrawConnectionLine {
                     oldDragLine.removeFromSuperlayer()
                 }
-                let labelPoint = closestPointOnRectPerimeter(point, CGRectInset(dragStart.frame, 1, 1))
-                let dragLine = createConnectionLayer(labelPoint, endPoint: point, color: targetConnector?.color)
+                var dragLine: CAShapeLayer?
+                switch drawConnectionInfo {
+                case let .FromConnector(connectorLabel):
+                    let targetPort = connectorPortAtLocation(point)?.ConnectorPort
+                    let labelPoint = closestPointOnRectPerimeter(point, CGRectInset(connectorLabel.frame, 1, 1))
+                    dragLine = createConnectionLayer(labelPoint, endPoint: point, color: targetPort?.color)
+                case let .FromConnectorPort(constraintView, connectorPort):
+                    let startPoint = self.scrollView.convertPoint(connectorPort.center, fromView: constraintView)
+                    var endPoint = point
+                    if let targetConnector = connectorLabelAtPoint(point) {
+                        endPoint = closestPointOnRectPerimeter(startPoint, targetConnector.frame)
+                    }
+                    dragLine = createConnectionLayer(startPoint, endPoint: endPoint, color: connectorPort.color)
+                }
+                
                 self.scrollView.layer.addSublayer(dragLine)
                 self.currentDrawConnectionLine = dragLine
             }

        
        switch recognizer.state {
        case .Began:
            for connectorLabel in self.connectorLabels {
                if CGRectContainsPoint(connectorLabel.frame, point) {
                    // We are dragging from a label
                    makeConnectionDragStart = connectorLabel
                    return
                }
            }
            
            self.processStrokesCounter += 1

                unprocessedStrokes.append(currentStroke)
                self.currentStroke = nil
                
            } else if let drawConnectionInfo = currentDrawingConnection {
                
                var connectorEnds: (ConnectorLabel, ConstraintView, ConnectorPort)?
                
                switch drawConnectionInfo {
                case let .FromConnector(connectorLabel):
                    if let (constraintView, connectorPort) = connectorPortAtLocation(point) {
                        connectorEnds = (connectorLabel, constraintView, connectorPort)
                    }
                case let .FromConnectorPort(constraintView, connectorPort):
                    if let connectorLabel = connectorLabelAtPoint(point) {
                        connectorEnds = (connectorLabel, constraintView, connectorPort)
                    }
                }
                
                if let (connectorLabel, constraintView, connectorPort) = connectorEnds {
                    let savedValue = connectorLabel.connector.value
                    connectorLabel.connector.forgetValue()
                    moveConnectorToTopPriority(connectorLabel) // Is this actually a good idea? When you drag a connector to a constraint, do you expect that connector to influence the constraint, or the other way around?
                    constraintView.connectPort(connectorPort, connector: connectorLabel.connector)
                    if let savedValue = savedValue {
                        runSolver([connectorLabel.connector : savedValue])
                    } else {
                        runSolver([:])
                    }
                    rebuildAllConnectionLayers()
                }
                
                if let dragLine = currentDrawConnectionLine {
                    dragLine.removeFromSuperlayer()
                    self.currentDrawConnectionLine = nil
                }
                currentDrawingConnection = nil
                
            }
            
        case .Possible:
