---
title: "down"
description: "Sends a down event for the pointer with the given [pointerId] at [position] on the associated
node. The [position] is in the node's local coordinate system, where (0, 0) is the top left
corner of the node.

If no pointers are down yet, this will start a new gesture. If a gesture is already in progress,
this event is sent with at the same timestamp as the last event. If the given pointer is already
down, an [IllegalArgumentException] will be thrown.

Subsequent events for this or other gestures can be spread out over both this and future
invocations of [performGesture]. An entire gesture starts with a [down][down] event, followed by
several down, move or up events, and ends with an [up][up] or a [cancel][cancel] event. Movement
can be expressed with [moveTo] and [moveBy] to move a single pointer at a time, or
[movePointerTo] and [movePointerBy] to move multiple pointers at a time. The `movePointer[To|By]`
methods do not send the move event directly, use [move] to send the move event. Some other
methods can send a move event as well. All events, regardless the method used, will always
contain the current position of _all_ pointers.

Down and up events are sent at the same time as the previous event, but will send an extra move
event just before the down or up event if [movePointerTo] or [movePointerBy] has been called and
no move event has been sent yet. This does not happen for cancel events, but the cancel event
will contain the up to date position of all pointers. Move and cancel events will advance the
event time by 16 milliseconds.

Because gestures don't have to be defined all in the same [performGesture] block, keep in mind
that while the gesture is not complete, all code you execute in between blocks that progress the
gesture, will be executed while imaginary fingers are actively touching the screen.

In the context of testing, it is not necessary to complete a gesture with an up or cancel event,
if the test ends before it expects the finger to be lifted from the screen."
type: "function"
---

<div class='type'>Function</div>


<a id='references'></a>
<div class='sourceset sourceset-common'>Common</div>


> **Deprecated** Replaced by TouchInjectionScope. Use `performTouchInput` instead of `performGesture`

```kotlin
fun GestureScope.down(pointerId: Int, position: Offset) =
    delegateScope.touch { down(pointerId, position) }
```


Sends a down event for the pointer with the given `pointerId` at `position` on the associated
node. The `position` is in the node's local coordinate system, where (0, 0) is the top left
corner of the node.

If no pointers are down yet, this will start a new gesture. If a gesture is already in progress,
this event is sent with at the same timestamp as the last event. If the given pointer is already
down, an `IllegalArgumentException` will be thrown.

Subsequent events for this or other gestures can be spread out over both this and future
invocations of `performGesture`. An entire gesture starts with a `down` event, followed by
several down, move or up events, and ends with an `up` or a `cancel` event. Movement
can be expressed with `moveTo` and `moveBy` to move a single pointer at a time, or
`movePointerTo` and `movePointerBy` to move multiple pointers at a time. The `movePointer`To|By``
methods do not send the move event directly, use `move` to send the move event. Some other
methods can send a move event as well. All events, regardless the method used, will always
contain the current position of _all_ pointers.

Down and up events are sent at the same time as the previous event, but will send an extra move
event just before the down or up event if `movePointerTo` or `movePointerBy` has been called and
no move event has been sent yet. This does not happen for cancel events, but the cancel event
will contain the up to date position of all pointers. Move and cancel events will advance the
event time by 16 milliseconds.

Because gestures don't have to be defined all in the same `performGesture` block, keep in mind
that while the gesture is not complete, all code you execute in between blocks that progress the
gesture, will be executed while imaginary fingers are actively touching the screen.

In the context of testing, it is not necessary to complete a gesture with an up or cancel event,
if the test ends before it expects the finger to be lifted from the screen.

#### Parameters

| | |
| --- | --- |
| pointerId | The id of the pointer, can be any number not yet in use by another pointer |
| position | The position of the down event, in the node's local coordinate system |




<div class='sourceset sourceset-common'>Common</div>


> **Deprecated** Replaced by TouchInjectionScope. Use `performTouchInput` instead of `performGesture`

```kotlin
fun GestureScope.down(position: Offset) = delegateScope.touch { down(position) }
```


Sends a down event for the default pointer at `position` on the associated node. The `position`
is in the node's local coordinate system, where (0, 0) is the top left corner of the node. The
default pointer has `pointerId = 0`.

If no pointers are down yet, this will start a new gesture. If a gesture is already in progress,
this event is sent with at the same timestamp as the last event. If the default pointer is
already down, an `IllegalArgumentException` will be thrown.

#### Parameters

| | |
| --- | --- |
| position | The position of the down event, in the node's local coordinate system |