                 
             } else if let drawConnectionInfo = currentDrawingConnection {
                 
-                var connectorEnds: (ConnectorLabel, ConstraintView, ConnectorPort)?
+                var connectionMade = false
                 
                 switch drawConnectionInfo {
                 case let .FromConnector(connectorLabel):
                     if let (constraintView, connectorPort) = connectorPortAtLocation(point) {
-                        connectorEnds = (connectorLabel, constraintView, connectorPort)
+                        self.connect(connectorLabel, constraintView: constraintView, connectorPort: connectorPort)
+                        connectionMade = true
                     }
                 case let .FromConnectorPort(constraintView, connectorPort):
                     if let connectorLabel = connectorLabelAtPoint(point) {
-                        connectorEnds = (connectorLabel, constraintView, connectorPort)
+                        self.connect(connectorLabel, constraintView: constraintView, connectorPort: connectorPort)
+                        connectionMade = true
+                        
                     } else if let (secondConstraintView, secondConnectorPort) = connectorPortAtLocation(point) {
-                        // We are dragging from one constraint directly to another constraint. To accomodate, we create a connector in-between and make two connections
-                        let midPoint = (constraintView.center + secondConstraintView.center) / 2.0
-                        
-                        let newConnector = Connector()
-                        let newLabel = ConnectorLabel(connector: newConnector)
-                        newLabel.sizeToFit()
-                        newLabel.center = midPoint
-                        self.addConnectorLabel(newLabel, topPriority: false)
-                        
-                        // We make this connection now, and let the second connection be made by the common code further down
-                        secondConstraintView.connectPort(secondConnectorPort, connector: newConnector)
-                        
-                        connectorEnds = (newLabel, constraintView, connectorPort)
-                    }
-                }
-                
-                if let (connectorLabel, constraintView, connectorPort) = connectorEnds {
-                    let savedValue = self.lastValueForConnector(connectorLabel.connector)
-                    constraintView.connectPort(connectorPort, connector: connectorLabel.connector)
-                    updateDisplay(needsSolving: true, needsLayout: true)
-                    
+                        self.connectConstraintViews(constraintView, firstConnectorPort: connectorPort, secondConstraintView: secondConstraintView, secondConnectorPort: secondConnectorPort)
+                        
+                        connectionMade = true
+                    }
+                }
+                
+                if connectionMade {
                     // Clear any information about the last drawn constraint or connector
                     self.lastDrawnConstraint = nil
                     self.lastDrawnConnector = nil
+                    
+                    self.updateDisplay()
                 }
                 
                 if let dragLine = currentDrawConnectionLine {

                        let newView = MultiplierView(multiplier: newMultiplier)
                        newView.layoutWithConnectorPositions([:])
                        newView.center = centerPoint
                        if combinedLabels == "x" {
                            let inputs = newView.inputConnectorPorts()
                            self.addConstraintView(newView, firstInputPort: inputs[0], secondInputPort: inputs[1])
                        } else if combinedLabels == "/" {
                            self.addConstraintView(newView, firstInputPort: newView.outputConnectorPorts()[0], secondInputPort: newView.inputConnectorPorts()[0])
                        } else {
                            self.addConstraintView(newView, firstInputPort: nil, secondInputPort: nil)
                        }
                        recognized = true
                        

                        let newView = AdderView(adder: newAdder)
                        newView.layoutWithConnectorPositions([:])
                        newView.center = centerPoint
                        let inputs = newView.inputConnectorPorts()
                        let outputs = newView.outputConnectorPorts()
                        if combinedLabels == "+" || combinedLabels == "1-" {
                            let inputs = newView.inputConnectorPorts()
                            self.addConstraintView(newView, firstInputPort: inputs[0], secondInputPort: inputs[1], outputPort: outputs[0])
                        } else if combinedLabels == "-" {
                            self.addConstraintView(newView, firstInputPort: outputs[0], secondInputPort: inputs[0], outputPort: inputs[1])
                        } else {
                            self.addConstraintView(newView, firstInputPort: nil, secondInputPort: nil, outputPort: nil)
                        }
                        recognized = true
                        
                    } else if combinedLabels == "^" {
                        let newExponent = Exponent()
                        let newView = ExponentView(exponent: newExponent)
                        newView.layoutWithConnectorPositions([:])
                        newView.center = centerPoint
                        
                        self.addConstraintView(newView, firstInputPort: newView.basePort, secondInputPort: newView.exponentPort, outputPort: newView.resultPort)
                        recognized = true
                        
                    } else {
                        println("Unable to parse written text: \(combinedLabels)")
                    }
