To capture touch events, we'll need to override touchesBegan.

This method is one you UI view inherits from its parent class UI responder.

So below drawrect, start typing out touchesBegan

to auto complete, touchesBegan takes two parameters.

A set of UITouches as you can see here, and a UIEvent object.

touchesBegan is called whenever a new touch event occurs within the bounds

of the UIView, which implements it.

In this case, our target view object.

The call receives a set of UI touches.

Since the relatively large fingers of users.

As compared to the size of the capacitive

sensors in the display can generate multiple touch positions.

We have a set of touches here, but we're interested and only need just one.

So we'll take the first touch from that set.

Now remember sets are an unordered collection type.

So taking the first is really the same as choosing any one at random.

So in here we'll say if let touche = touches.first.

Using the UI touches location in view method.

We convert the touch event into a CG point within the bounds of the view

passed as an argument.

So we can say let cross hair Position

equal touch.locationInView.

And we'll say self to get the location in the target view.

Now we can actually long this.

So we'll say print touch position.

And then we can say crosshair Position.x.

And similarly, we can get the y position, as well.

Keep in mind the actual touch event was registered by the hardware device,

the touch screen.

Thankfully, location in view does the job of converting that point

through all the frame transforms in the view hierarchy.

To give us a position that is meaningful in our local frame of reference.

That is, within the bounds of the target view instance.

We use this locally meaningful coordinate to then reposition the crosshairs layer.

So now that we have a position.

We know where we touched.

We can reposition the crosshair by saying

self.crosshairslayer.position equal crosshairs position.

Let's give this a try.

So stop and run the app.

And now, if you touch somewhere on the screen in the Muppets image.

You'll see that the crosshair or or the red square for now moves over to it.

And since we're longing the position.

You should get that as well.

The changes to the state of the layer are automatically animated.

As you can see it slides over instead of just disappearing and reappearing.

And this is one of the benefits of using a CA layer.

The timing and many other aspects of the animations are fully configurable.

But the layer gives a usable animation by default.

More information about what is possible using core animation layers in available

in the teacher's notes.

Now at the end of this method we need to call setNeedsDisplay.

So we'll say self.setNeedsDisplay.

It's not strictly necessary yet.

But once we have a busier path drawing code.

We'll want to make sure draw rect is called again

after each time that we reposition the layer.

One detail to know is that a dragging gesture

does not generate an additional call to touches begin.

UI responder implements another method touchesMoved,

which receives these separate events, these dragging events.

If we wanted the user to be able to drag the layer.

We also need to override this method.

It's worth knowing that touch of events may also be managed at a slightly

higher level of abstraction by using UI gesture recognizers on the view.

Rather than directly overriding the UI responder's touch methods.