How to reproduce this Xcode blue drag line

Question

I'd like to reproduce the Xcode blue drag line in my app. Do you know a way to code this ? I know how to draw a line using Core Graphics ... But this line has to be over the top of all other items (on the screen).

Accepted Answer

I'm posting this after you've posted your own answer, so this is probably a huge waste of time. But your answer only covers drawing a really bare-bones line on the screen and doesn't cover a bunch of other interesting stuff that you need to take care of to really replicate Xcode's behavior and even go beyond it:

- drawing a nice connection line like Xcode's (with a shadow, an outline, and big rounded ends),

- drawing the line across multiple screens,

- using Cocoa drag and drop to find the drag target and to support spring-loading.

Here's a demo of what I'm going to explain in this answer:

In this github repo, you can find an Xcode project containing all the code in this answer plus the remaining glue code necessary to run a demo app.

Drawing a nice connection line like Xcode's

Xcode's connection line looks like an old-timey barbell. It has a straight bar of arbitrary length, with a circular bell at each end:

What do we know about that shape? The user provides the start and end points (the centers of the bells) by dragging the mouse, and our user interface designer specifies the radius of the bells and the thickness of the bar:

The length of the bar is the distance from `startPoint` to `endPoint`: `length = hypot(endPoint.x - startPoint.x, endPoint.y - startPoint.y)`.

To simplify the process of creating a path for this shape, let's draw it in a standard pose, with the left bell at the origin and the bar parallel to the x axis. In this pose, here's what we know:

We can create this shape as a path by making a circular arc centered at the origin, connected to another (mirror image) circular arc centered at `(length, 0)`. To create these arcs, we need this `mysteryAngle`:

We can figure out `mysteryAngle` if we can find any of the arc endpoints where the bell meets the bar. Specifically, we'll find the coordinates of this point:

What do we know about that `mysteryPoint`? We know it's at the intersection of the bell and the top of the bar. So we know it's at distance `bellRadius` from the origin, and at distance `barThickness / 2` from the x axis:

So immediately we know that `mysteryPoint.y = barThickness / 2`, and we can use the Pythagorean theorem to compute `mysteryPoint.x = sqrt(bellRadius² - mysteryPoint.y²)`.

With `mysteryPoint` located, we can compute `mysteryAngle` using our choice of inverse trigonometry function. Arcsine, I choose you! `mysteryAngle = asin(mysteryPoint.y / bellRadius)`.

We now know everything we need to create the path in the standard pose. To move it from the standard pose to the desired pose (which goes from `startPoint` to `endPoint`, remember?), we'll apply an affine transform. The transform will translate (move) the path so the left bell is centered at `startPoint` and rotate the path so the right bell ends up at `endPoint`.

In writing the code to create the path, we want to be careful of a few things:

What if the length is so short that the bells overlap? We should handle that gracefully by adjusting `mysteryAngle` so the bells connect seamlessly with no weird “negative bar” between them.

What if `bellRadius` is smaller than `barThickness / 2`? We should handle that gracefully by forcing `bellRadius` to be at least `barThickness / 2`.

What if `length` is zero? We need to avoid division by zero.

Here's my code to create the path, handling all those cases:

```
extension CGPath {
    class func barbell(from start: CGPoint, to end: CGPoint, barThickness proposedBarThickness: CGFloat, bellRadius proposedBellRadius: CGFloat) -> CGPath {
        let barThickness = max(0, proposedBarThickness)
        let bellRadius = max(barThickness / 2, proposedBellRadius)

let vector = CGPoint(x: end.x - start.x, y: end.y - start.y)
        let length = hypot(vector.x, vector.y)

if length == 0 {
            return CGPath(ellipseIn: CGRect(origin: start, size: .zero).insetBy(dx: -bellRadius, dy: -bellRadius), transform: nil)
        }

var yOffset = barThickness / 2
        var xOffset = sqrt(bellRadius * bellRadius - yOffset * yOffset)
        let halfLength = length / 2
        if xOffset > halfLength {
            xOffset = halfLength
            yOffset = sqrt(bellRadius * bellRadius - xOffset * xOffset)
        }

let jointRadians = asin(yOffset / bellRadius)
        let path = CGMutablePath()
        path.addArc(center: .zero, radius: bellRadius, startAngle: jointRadians, endAngle: -jointRadians, clockwise: false)
        path.addArc(center: CGPoint(x: length, y: 0), radius: bellRadius, startAngle: .pi + jointRadians, endAngle: .pi - jointRadians, clockwise: false)
        path.closeSubpath()

let unitVector = CGPoint(x: vector.x / length, y: vector.y / length)
        var transform = CGAffineTransform(a: unitVector.x, b: unitVector.y, c: -unitVector.y, d: unitVector.x, tx: start.x, ty: start.y)
        return path.copy(using: &transform)!
    }
}
```

Once we have the path, we need to fill it with the correct color, stroke it with t…

How to reproduce this Xcode blue drag line

Solution

Problem