long_press.dart 32 KB
Newer Older
Ian Hickson's avatar
Ian Hickson committed
1
// Copyright 2014 The Flutter Authors. All rights reserved.
2 3 4
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

5

6 7
import 'arena.dart';
import 'constants.dart';
8
import 'events.dart';
9
import 'recognizer.dart';
10
import 'velocity_tracker.dart';
11

12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35
/// Callback signature for [LongPressGestureRecognizer.onLongPressDown].
///
/// Called when a pointer that might cause a long-press has contacted the
/// screen. The position at which the pointer contacted the screen is available
/// in the `details`.
///
/// See also:
///
///  * [GestureDetector.onLongPressDown], which matches this signature.
///  * [GestureLongPressStartCallback], the signature that gets called when the
///    pointer has been in contact with the screen long enough to be considered
///    a long-press.
typedef GestureLongPressDownCallback = void Function(LongPressDownDetails details);

/// Callback signature for [LongPressGestureRecognizer.onLongPressCancel].
///
/// Called when the pointer that previously triggered a
/// [GestureLongPressDownCallback] will not end up causing a long-press.
///
/// See also:
///
///  * [GestureDetector.onLongPressCancel], which matches this signature.
typedef GestureLongPressCancelCallback = void Function();

36 37 38
/// Callback signature for [LongPressGestureRecognizer.onLongPress].
///
/// Called when a pointer has remained in contact with the screen at the
39
/// same location for a long period of time.
40 41 42 43 44 45
///
/// See also:
///
///  * [GestureDetector.onLongPress], which matches this signature.
///  * [GestureLongPressStartCallback], which is the same signature but with
///    details of where the long press occurred.
46
typedef GestureLongPressCallback = void Function();
47

48 49 50 51
/// Callback signature for [LongPressGestureRecognizer.onLongPressUp].
///
/// Called when a pointer stops contacting the screen after a long press
/// gesture was detected.
52 53 54 55
///
/// See also:
///
///  * [GestureDetector.onLongPressUp], which matches this signature.
56 57
typedef GestureLongPressUpCallback = void Function();

58 59 60 61 62
/// Callback signature for [LongPressGestureRecognizer.onLongPressStart].
///
/// Called when a pointer has remained in contact with the screen at the
/// same location for a long period of time. Also reports the long press down
/// position.
63 64 65 66 67 68
///
/// See also:
///
///  * [GestureDetector.onLongPressStart], which matches this signature.
///  * [GestureLongPressCallback], which is the same signature without the
///    details.
69 70 71 72 73 74 75
typedef GestureLongPressStartCallback = void Function(LongPressStartDetails details);

/// Callback signature for [LongPressGestureRecognizer.onLongPressMoveUpdate].
///
/// Called when a pointer is moving after being held in contact at the same
/// location for a long period of time. Reports the new position and its offset
/// from the original down position.
76 77 78 79
///
/// See also:
///
///  * [GestureDetector.onLongPressMoveUpdate], which matches this signature.
80 81 82 83 84 85 86
typedef GestureLongPressMoveUpdateCallback = void Function(LongPressMoveUpdateDetails details);

/// Callback signature for [LongPressGestureRecognizer.onLongPressEnd].
///
/// Called when a pointer stops contacting the screen after a long press
/// gesture was detected. Also reports the position where the pointer stopped
/// contacting the screen.
87 88 89 90
///
/// See also:
///
///  * [GestureDetector.onLongPressEnd], which matches this signature.
91 92
typedef GestureLongPressEndCallback = void Function(LongPressEndDetails details);

93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126
/// Details for callbacks that use [GestureLongPressDownCallback].
///
/// See also:
///
///  * [LongPressGestureRecognizer.onLongPressDown], whose callback passes
///    these details.
///  * [LongPressGestureRecognizer.onSecondaryLongPressDown], whose callback
///    passes these details.
///  * [LongPressGestureRecognizer.onTertiaryLongPressDown], whose callback
///    passes these details.
class LongPressDownDetails {
  /// Creates the details for a [GestureLongPressDownCallback].
  ///
  /// The `globalPosition` argument must not be null.
  ///
  /// If the `localPosition` argument is not specified, it will default to the
  /// global position.
  const LongPressDownDetails({
    this.globalPosition = Offset.zero,
    Offset? localPosition,
    this.kind,
  }) : assert(globalPosition != null),
       localPosition = localPosition ?? globalPosition;

  /// The global position at which the pointer contacted the screen.
  final Offset globalPosition;

  /// The kind of the device that initiated the event.
  final PointerDeviceKind? kind;

  /// The local position at which the pointer contacted the screen.
  final Offset localPosition;
}

127 128 129 130 131 132 133 134 135 136 137
/// Details for callbacks that use [GestureLongPressStartCallback].
///
/// See also:
///
///  * [LongPressGestureRecognizer.onLongPressStart], which uses [GestureLongPressStartCallback].
///  * [LongPressMoveUpdateDetails], the details for [GestureLongPressMoveUpdateCallback]
///  * [LongPressEndDetails], the details for [GestureLongPressEndCallback].
class LongPressStartDetails {
  /// Creates the details for a [GestureLongPressStartCallback].
  ///
  /// The [globalPosition] argument must not be null.
138 139
  const LongPressStartDetails({
    this.globalPosition = Offset.zero,
140
    Offset? localPosition,
141 142
  }) : assert(globalPosition != null),
       localPosition = localPosition ?? globalPosition;
143

144
  /// The global position at which the pointer initially contacted the screen.
145
  final Offset globalPosition;
146

147
  /// The local position at which the pointer initially contacted the screen.
148
  final Offset localPosition;
149 150 151 152 153 154 155 156 157 158 159 160 161 162 163
}

/// Details for callbacks that use [GestureLongPressMoveUpdateCallback].
///
/// See also:
///
///  * [LongPressGestureRecognizer.onLongPressMoveUpdate], which uses [GestureLongPressMoveUpdateCallback].
///  * [LongPressEndDetails], the details for [GestureLongPressEndCallback]
///  * [LongPressStartDetails], the details for [GestureLongPressStartCallback].
class LongPressMoveUpdateDetails {
  /// Creates the details for a [GestureLongPressMoveUpdateCallback].
  ///
  /// The [globalPosition] and [offsetFromOrigin] arguments must not be null.
  const LongPressMoveUpdateDetails({
    this.globalPosition = Offset.zero,
164
    Offset? localPosition,
165
    this.offsetFromOrigin = Offset.zero,
166
    Offset? localOffsetFromOrigin,
167
  }) : assert(globalPosition != null),
168 169 170
       assert(offsetFromOrigin != null),
       localPosition = localPosition ?? globalPosition,
       localOffsetFromOrigin = localOffsetFromOrigin ?? offsetFromOrigin;
171 172 173 174

  /// The global position of the pointer when it triggered this update.
  final Offset globalPosition;

175 176 177
  /// The local position of the pointer when it triggered this update.
  final Offset localPosition;

178 179 180 181
  /// A delta offset from the point where the long press drag initially contacted
  /// the screen to the point where the pointer is currently located (the
  /// present [globalPosition]) when this callback is triggered.
  final Offset offsetFromOrigin;
182 183 184 185 186

  /// A local delta offset from the point where the long press drag initially contacted
  /// the screen to the point where the pointer is currently located (the
  /// present [localPosition]) when this callback is triggered.
  final Offset localOffsetFromOrigin;
187 188 189 190 191 192 193
}

/// Details for callbacks that use [GestureLongPressEndCallback].
///
/// See also:
///
///  * [LongPressGestureRecognizer.onLongPressEnd], which uses [GestureLongPressEndCallback].
194
///  * [LongPressMoveUpdateDetails], the details for [GestureLongPressMoveUpdateCallback].
195 196 197 198 199
///  * [LongPressStartDetails], the details for [GestureLongPressStartCallback].
class LongPressEndDetails {
  /// Creates the details for a [GestureLongPressEndCallback].
  ///
  /// The [globalPosition] argument must not be null.
200 201
  const LongPressEndDetails({
    this.globalPosition = Offset.zero,
202
    Offset? localPosition,
203
    this.velocity = Velocity.zero,
204 205
  }) : assert(globalPosition != null),
       localPosition = localPosition ?? globalPosition;
206 207 208

  /// The global position at which the pointer lifted from the screen.
  final Offset globalPosition;
209 210 211

  /// The local position at which the pointer contacted the screen.
  final Offset localPosition;
212 213 214 215 216

  /// The pointer's velocity when it stopped contacting the screen.
  ///
  /// Defaults to zero if not specified in the constructor.
  final Velocity velocity;
217 218
}

219 220
/// Recognizes when the user has pressed down at the same location for a long
/// period of time.
221 222 223 224 225
///
/// The gesture must not deviate in position from its touch down point for 500ms
/// until it's recognized. Once the gesture is accepted, the finger can be
/// moved, triggering [onLongPressMoveUpdate] callbacks, unless the
/// [postAcceptSlopTolerance] constructor argument is specified.
226
///
227
/// [LongPressGestureRecognizer] may compete on pointer events of
228 229
/// [kPrimaryButton], [kSecondaryButton], and/or [kTertiaryButton] if at least
/// one corresponding callback is non-null. If it has no callbacks, it is a no-op.
230
class LongPressGestureRecognizer extends PrimaryPointerGestureRecognizer {
231 232
  /// Creates a long-press gesture recognizer.
  ///
233 234 235 236 237 238 239 240 241
  /// Consider assigning the [onLongPressStart] callback after creating this
  /// object.
  ///
  /// The [postAcceptSlopTolerance] argument can be used to specify a maximum
  /// allowed distance for the gesture to deviate from the starting point once
  /// the long press has triggered. If the gesture deviates past that point,
  /// subsequent callbacks ([onLongPressMoveUpdate], [onLongPressUp],
  /// [onLongPressEnd]) will stop. Defaults to null, which means the gesture
  /// can be moved without limit once the long press is accepted.
242 243 244
  ///
  /// The [duration] argument can be used to overwrite the default duration
  /// after which the long press will be recognized.
245 246
  ///
  /// {@macro flutter.gestures.GestureRecognizer.supportedDevices}
247
  LongPressGestureRecognizer({
248 249
    Duration? duration,
    double? postAcceptSlopTolerance,
250 251 252 253
    @Deprecated(
      'Migrate to supportedDevices. '
      'This feature was deprecated after v2.3.0-1.0.pre.',
    )
254
    PointerDeviceKind? kind,
255
    Set<PointerDeviceKind>? supportedDevices,
256
    Object? debugOwner,
257
  }) : super(
258 259 260 261 262 263
         deadline: duration ?? kLongPressTimeout,
         postAcceptSlopTolerance: postAcceptSlopTolerance,
         kind: kind,
         supportedDevices: supportedDevices,
         debugOwner: debugOwner,
       );
264 265

  bool _longPressAccepted = false;
266
  OffsetPair? _longPressOrigin;
267 268
  // The buttons sent by `PointerDownEvent`. If a `PointerMoveEvent` comes with a
  // different set of buttons, the gesture is canceled.
269
  int? _initialButtons;
270

271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305
  /// Called when a pointer has contacted the screen at a particular location
  /// with a primary button, which might be the start of a long-press.
  ///
  /// This triggers after the pointer down event.
  ///
  /// If this recognizer doesn't win the arena, [onLongPressCancel] is called
  /// next. Otherwise, [onLongPressStart] is called next.
  ///
  /// See also:
  ///
  ///  * [kPrimaryButton], the button this callback responds to.
  ///  * [onSecondaryLongPressDown], a similar callback but for a secondary button.
  ///  * [onTertiaryLongPressDown], a similar callback but for a tertiary button.
  ///  * [LongPressDownDetails], which is passed as an argument to this callback.
  ///  * [GestureDetector.onLongPressDown], which exposes this callback in a widget.
  GestureLongPressDownCallback? onLongPressDown;

  /// Called when a pointer that previously triggered [onLongPressDown] will
  /// not end up causing a long-press.
  ///
  /// This triggers once the gesture loses the arena if [onLongPressDown] has
  /// previously been triggered.
  ///
  /// If this recognizer wins the arena, [onLongPressStart] and [onLongPress]
  /// are called instead.
  ///
  /// If the gesture is deactivated due to [postAcceptSlopTolerance] having
  /// been exceeded, this callback will not be called, since the gesture will
  /// have already won the arena at that point.
  ///
  /// See also:
  ///
  ///  * [kPrimaryButton], the button this callback responds to.
  GestureLongPressCancelCallback? onLongPressCancel;

306
  /// Called when a long press gesture by a primary button has been recognized.
307
  ///
308 309 310 311 312
  /// This is equivalent to (and is called immediately after) [onLongPressStart].
  /// The only difference between the two is that this callback does not
  /// contain details of the position at which the pointer initially contacted
  /// the screen.
  ///
313 314
  /// See also:
  ///
315
  ///  * [kPrimaryButton], the button this callback responds to.
316
  GestureLongPressCallback? onLongPress;
317

318
  /// Called when a long press gesture by a primary button has been recognized.
319
  ///
320 321 322 323 324
  /// This is equivalent to (and is called immediately before) [onLongPress].
  /// The only difference between the two is that this callback contains
  /// details of the position at which the pointer initially contacted the
  /// screen, whereas [onLongPress] does not.
  ///
325 326
  /// See also:
  ///
327 328
  ///  * [kPrimaryButton], the button this callback responds to.
  ///  * [LongPressStartDetails], which is passed as an argument to this callback.
329
  GestureLongPressStartCallback? onLongPressStart;
330

331 332 333 334 335 336 337
  /// Called when moving after the long press by a primary button is recognized.
  ///
  /// See also:
  ///
  ///  * [kPrimaryButton], the button this callback responds to.
  ///  * [LongPressMoveUpdateDetails], which is passed as an argument to this
  ///    callback.
338
  GestureLongPressMoveUpdateCallback? onLongPressMoveUpdate;
339

340 341
  /// Called when the pointer stops contacting the screen after a long-press
  /// by a primary button.
342
  ///
343 344 345 346 347
  /// This is equivalent to (and is called immediately after) [onLongPressEnd].
  /// The only difference between the two is that this callback does not
  /// contain details of the state of the pointer when it stopped contacting
  /// the screen.
  ///
348 349
  /// See also:
  ///
350
  ///  * [kPrimaryButton], the button this callback responds to.
351
  GestureLongPressUpCallback? onLongPressUp;
352

353 354
  /// Called when the pointer stops contacting the screen after a long-press
  /// by a primary button.
355
  ///
356 357 358 359 360
  /// This is equivalent to (and is called immediately before) [onLongPressUp].
  /// The only difference between the two is that this callback contains
  /// details of the state of the pointer when it stopped contacting the
  /// screen, whereas [onLongPressUp] does not.
  ///
361 362
  /// See also:
  ///
363 364 365
  ///  * [kPrimaryButton], the button this callback responds to.
  ///  * [LongPressEndDetails], which is passed as an argument to this
  ///    callback.
366
  GestureLongPressEndCallback? onLongPressEnd;
367

368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403
  /// Called when a pointer has contacted the screen at a particular location
  /// with a secondary button, which might be the start of a long-press.
  ///
  /// This triggers after the pointer down event.
  ///
  /// If this recognizer doesn't win the arena, [onSecondaryLongPressCancel] is
  /// called next. Otherwise, [onSecondaryLongPressStart] is called next.
  ///
  /// See also:
  ///
  ///  * [kSecondaryButton], the button this callback responds to.
  ///  * [onLongPressDown], a similar callback but for a primary button.
  ///  * [onTertiaryLongPressDown], a similar callback but for a tertiary button.
  ///  * [LongPressDownDetails], which is passed as an argument to this callback.
  ///  * [GestureDetector.onSecondaryLongPressDown], which exposes this callback
  ///    in a widget.
  GestureLongPressDownCallback? onSecondaryLongPressDown;

  /// Called when a pointer that previously triggered [onSecondaryLongPressDown]
  /// will not end up causing a long-press.
  ///
  /// This triggers once the gesture loses the arena if
  /// [onSecondaryLongPressDown] has previously been triggered.
  ///
  /// If this recognizer wins the arena, [onSecondaryLongPressStart] and
  /// [onSecondaryLongPress] are called instead.
  ///
  /// If the gesture is deactivated due to [postAcceptSlopTolerance] having
  /// been exceeded, this callback will not be called, since the gesture will
  /// have already won the arena at that point.
  ///
  /// See also:
  ///
  ///  * [kSecondaryButton], the button this callback responds to.
  GestureLongPressCancelCallback? onSecondaryLongPressCancel;

404 405 406
  /// Called when a long press gesture by a secondary button has been
  /// recognized.
  ///
407 408 409 410 411
  /// This is equivalent to (and is called immediately after)
  /// [onSecondaryLongPressStart]. The only difference between the two is that
  /// this callback does not contain details of the position at which the
  /// pointer initially contacted the screen.
  ///
412 413 414
  /// See also:
  ///
  ///  * [kSecondaryButton], the button this callback responds to.
415
  GestureLongPressCallback? onSecondaryLongPress;
416 417 418

  /// Called when a long press gesture by a secondary button has been recognized.
  ///
419 420 421 422 423
  /// This is equivalent to (and is called immediately before)
  /// [onSecondaryLongPress]. The only difference between the two is that this
  /// callback contains details of the position at which the pointer initially
  /// contacted the screen, whereas [onSecondaryLongPress] does not.
  ///
424 425 426 427 428
  /// See also:
  ///
  ///  * [kSecondaryButton], the button this callback responds to.
  ///  * [LongPressStartDetails], which is passed as an argument to this
  ///    callback.
429
  GestureLongPressStartCallback? onSecondaryLongPressStart;
430 431 432 433 434 435 436 437 438

  /// Called when moving after the long press by a secondary button is
  /// recognized.
  ///
  /// See also:
  ///
  ///  * [kSecondaryButton], the button this callback responds to.
  ///  * [LongPressMoveUpdateDetails], which is passed as an argument to this
  ///    callback.
439
  GestureLongPressMoveUpdateCallback? onSecondaryLongPressMoveUpdate;
440 441 442 443

  /// Called when the pointer stops contacting the screen after a long-press by
  /// a secondary button.
  ///
444 445 446 447 448
  /// This is equivalent to (and is called immediately after)
  /// [onSecondaryLongPressEnd]. The only difference between the two is that
  /// this callback does not contain details of the state of the pointer when
  /// it stopped contacting the screen.
  ///
449 450 451
  /// See also:
  ///
  ///  * [kSecondaryButton], the button this callback responds to.
452
  GestureLongPressUpCallback? onSecondaryLongPressUp;
453 454 455 456

  /// Called when the pointer stops contacting the screen after a long-press by
  /// a secondary button.
  ///
457 458 459 460 461
  /// This is equivalent to (and is called immediately before)
  /// [onSecondaryLongPressUp]. The only difference between the two is that
  /// this callback contains details of the state of the pointer when it
  /// stopped contacting the screen, whereas [onSecondaryLongPressUp] does not.
  ///
462 463 464 465
  /// See also:
  ///
  ///  * [kSecondaryButton], the button this callback responds to.
  ///  * [LongPressEndDetails], which is passed as an argument to this callback.
466
  GestureLongPressEndCallback? onSecondaryLongPressEnd;
467

468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503
  /// Called when a pointer has contacted the screen at a particular location
  /// with a tertiary button, which might be the start of a long-press.
  ///
  /// This triggers after the pointer down event.
  ///
  /// If this recognizer doesn't win the arena, [onTertiaryLongPressCancel] is
  /// called next. Otherwise, [onTertiaryLongPressStart] is called next.
  ///
  /// See also:
  ///
  ///  * [kTertiaryButton], the button this callback responds to.
  ///  * [onLongPressDown], a similar callback but for a primary button.
  ///  * [onSecondaryLongPressDown], a similar callback but for a secondary button.
  ///  * [LongPressDownDetails], which is passed as an argument to this callback.
  ///  * [GestureDetector.onTertiaryLongPressDown], which exposes this callback
  ///    in a widget.
  GestureLongPressDownCallback? onTertiaryLongPressDown;

  /// Called when a pointer that previously triggered [onTertiaryLongPressDown]
  /// will not end up causing a long-press.
  ///
  /// This triggers once the gesture loses the arena if
  /// [onTertiaryLongPressDown] has previously been triggered.
  ///
  /// If this recognizer wins the arena, [onTertiaryLongPressStart] and
  /// [onTertiaryLongPress] are called instead.
  ///
  /// If the gesture is deactivated due to [postAcceptSlopTolerance] having
  /// been exceeded, this callback will not be called, since the gesture will
  /// have already won the arena at that point.
  ///
  /// See also:
  ///
  ///  * [kTertiaryButton], the button this callback responds to.
  GestureLongPressCancelCallback? onTertiaryLongPressCancel;

504 505 506
  /// Called when a long press gesture by a tertiary button has been
  /// recognized.
  ///
507 508 509 510 511
  /// This is equivalent to (and is called immediately after)
  /// [onTertiaryLongPressStart]. The only difference between the two is that
  /// this callback does not contain details of the position at which the
  /// pointer initially contacted the screen.
  ///
512 513 514 515 516 517 518
  /// See also:
  ///
  ///  * [kTertiaryButton], the button this callback responds to.
  GestureLongPressCallback? onTertiaryLongPress;

  /// Called when a long press gesture by a tertiary button has been recognized.
  ///
519 520 521 522 523
  /// This is equivalent to (and is called immediately before)
  /// [onTertiaryLongPress]. The only difference between the two is that this
  /// callback contains details of the position at which the pointer initially
  /// contacted the screen, whereas [onTertiaryLongPress] does not.
  ///
524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543
  /// See also:
  ///
  ///  * [kTertiaryButton], the button this callback responds to.
  ///  * [LongPressStartDetails], which is passed as an argument to this
  ///    callback.
  GestureLongPressStartCallback? onTertiaryLongPressStart;

  /// Called when moving after the long press by a tertiary button is
  /// recognized.
  ///
  /// See also:
  ///
  ///  * [kTertiaryButton], the button this callback responds to.
  ///  * [LongPressMoveUpdateDetails], which is passed as an argument to this
  ///    callback.
  GestureLongPressMoveUpdateCallback? onTertiaryLongPressMoveUpdate;

  /// Called when the pointer stops contacting the screen after a long-press by
  /// a tertiary button.
  ///
544 545 546 547 548
  /// This is equivalent to (and is called immediately after)
  /// [onTertiaryLongPressEnd]. The only difference between the two is that
  /// this callback does not contain details of the state of the pointer when
  /// it stopped contacting the screen.
  ///
549 550 551 552 553 554 555 556
  /// See also:
  ///
  ///  * [kTertiaryButton], the button this callback responds to.
  GestureLongPressUpCallback? onTertiaryLongPressUp;

  /// Called when the pointer stops contacting the screen after a long-press by
  /// a tertiary button.
  ///
557 558 559 560 561
  /// This is equivalent to (and is called immediately before)
  /// [onTertiaryLongPressUp]. The only difference between the two is that
  /// this callback contains details of the state of the pointer when it
  /// stopped contacting the screen, whereas [onTertiaryLongPressUp] does not.
  ///
562 563 564 565 566 567
  /// See also:
  ///
  ///  * [kTertiaryButton], the button this callback responds to.
  ///  * [LongPressEndDetails], which is passed as an argument to this callback.
  GestureLongPressEndCallback? onTertiaryLongPressEnd;

568
  VelocityTracker? _velocityTracker;
569

570 571 572 573
  @override
  bool isPointerAllowed(PointerDownEvent event) {
    switch (event.buttons) {
      case kPrimaryButton:
574 575 576
        if (onLongPressDown == null &&
            onLongPressCancel == null &&
            onLongPressStart == null &&
577 578 579 580 581 582
            onLongPress == null &&
            onLongPressMoveUpdate == null &&
            onLongPressEnd == null &&
            onLongPressUp == null)
          return false;
        break;
583
      case kSecondaryButton:
584 585 586
        if (onSecondaryLongPressDown == null &&
            onSecondaryLongPressCancel == null &&
            onSecondaryLongPressStart == null &&
587 588 589 590 591 592
            onSecondaryLongPress == null &&
            onSecondaryLongPressMoveUpdate == null &&
            onSecondaryLongPressEnd == null &&
            onSecondaryLongPressUp == null)
          return false;
        break;
593
      case kTertiaryButton:
594 595 596
        if (onTertiaryLongPressDown == null &&
            onTertiaryLongPressCancel == null &&
            onTertiaryLongPressStart == null &&
597 598 599 600 601 602
            onTertiaryLongPress == null &&
            onTertiaryLongPressMoveUpdate == null &&
            onTertiaryLongPressEnd == null &&
            onTertiaryLongPressUp == null)
          return false;
        break;
603 604 605 606 607 608
      default:
        return false;
    }
    return super.isPointerAllowed(event);
  }

609
  @override
610
  void didExceedDeadline() {
611
    // Exceeding the deadline puts the gesture in the accepted state.
612
    resolve(GestureDisposition.accepted);
613
    _longPressAccepted = true;
614
    super.acceptGesture(primaryPointer!);
615
    _checkLongPressStart();
616 617
  }

618
  @override
Ian Hickson's avatar
Ian Hickson committed
619
  void handlePrimaryPointer(PointerEvent event) {
620 621
    if (!event.synthesized) {
      if (event is PointerDownEvent) {
622
        _velocityTracker = VelocityTracker.withKind(event.kind);
623
        _velocityTracker!.addPosition(event.timeStamp, event.localPosition);
624 625 626
      }
      if (event is PointerMoveEvent) {
        assert(_velocityTracker != null);
627
        _velocityTracker!.addPosition(event.timeStamp, event.localPosition);
628 629 630
      }
    }

631
    if (event is PointerUpEvent) {
632
      if (_longPressAccepted == true) {
633
        _checkLongPressEnd(event);
634
      } else {
635
        // Pointer is lifted before timeout.
636 637
        resolve(GestureDisposition.rejected);
      }
638 639
      _reset();
    } else if (event is PointerCancelEvent) {
640
      _checkLongPressCancel();
641 642
      _reset();
    } else if (event is PointerDownEvent) {
643
      // The first touch.
644
      _longPressOrigin = OffsetPair.fromEventPosition(event);
645
      _initialButtons = event.buttons;
646
      _checkLongPressDown(event);
647 648 649
    } else if (event is PointerMoveEvent) {
      if (event.buttons != _initialButtons) {
        resolve(GestureDisposition.rejected);
650
        stopTrackingPointer(primaryPointer!);
651 652 653 654 655 656
      } else if (_longPressAccepted) {
        _checkLongPressMoveUpdate(event);
      }
    }
  }

657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702
  void _checkLongPressDown(PointerDownEvent event) {
    assert(_longPressOrigin != null);
    final LongPressDownDetails details = LongPressDownDetails(
      globalPosition: _longPressOrigin!.global,
      localPosition: _longPressOrigin!.local,
      kind: getKindForPointer(event.pointer),
    );
    switch (_initialButtons) {
      case kPrimaryButton:
        if (onLongPressDown != null)
          invokeCallback<void>('onLongPressDown', () => onLongPressDown!(details));
        break;
      case kSecondaryButton:
        if (onSecondaryLongPressDown != null)
          invokeCallback<void>('onSecondaryLongPressDown', () => onSecondaryLongPressDown!(details));
        break;
      case kTertiaryButton:
        if (onTertiaryLongPressDown != null)
          invokeCallback<void>('onTertiaryLongPressDown', () => onTertiaryLongPressDown!(details));
        break;
      default:
        assert(false, 'Unhandled button $_initialButtons');
    }
  }

  void _checkLongPressCancel() {
    if (state == GestureRecognizerState.possible) {
      switch (_initialButtons) {
        case kPrimaryButton:
          if (onLongPressCancel != null)
            invokeCallback<void>('onLongPressCancel', onLongPressCancel!);
          break;
        case kSecondaryButton:
          if (onSecondaryLongPressCancel != null)
            invokeCallback<void>('onSecondaryLongPressCancel', onSecondaryLongPressCancel!);
          break;
        case kTertiaryButton:
          if (onTertiaryLongPressCancel != null)
            invokeCallback<void>('onTertiaryLongPressCancel', onTertiaryLongPressCancel!);
          break;
        default:
          assert(false, 'Unhandled button $_initialButtons');
      }
    }
  }

703
  void _checkLongPressStart() {
704 705 706 707
    switch (_initialButtons) {
      case kPrimaryButton:
        if (onLongPressStart != null) {
          final LongPressStartDetails details = LongPressStartDetails(
708 709
            globalPosition: _longPressOrigin!.global,
            localPosition: _longPressOrigin!.local,
710
          );
711
          invokeCallback<void>('onLongPressStart', () => onLongPressStart!(details));
712 713
        }
        if (onLongPress != null) {
714
          invokeCallback<void>('onLongPress', onLongPress!);
715 716 717 718 719
        }
        break;
      case kSecondaryButton:
        if (onSecondaryLongPressStart != null) {
          final LongPressStartDetails details = LongPressStartDetails(
720 721
            globalPosition: _longPressOrigin!.global,
            localPosition: _longPressOrigin!.local,
722
          );
723
          invokeCallback<void>('onSecondaryLongPressStart', () => onSecondaryLongPressStart!(details));
724 725
        }
        if (onSecondaryLongPress != null) {
726
          invokeCallback<void>('onSecondaryLongPress', onSecondaryLongPress!);
727 728
        }
        break;
729 730 731 732 733 734
      case kTertiaryButton:
        if (onTertiaryLongPressStart != null) {
          final LongPressStartDetails details = LongPressStartDetails(
            globalPosition: _longPressOrigin!.global,
            localPosition: _longPressOrigin!.local,
          );
735
          invokeCallback<void>('onTertiaryLongPressStart', () => onTertiaryLongPressStart!(details));
736 737 738 739 740
        }
        if (onTertiaryLongPress != null) {
          invokeCallback<void>('onTertiaryLongPress', onTertiaryLongPress!);
        }
        break;
741 742
      default:
        assert(false, 'Unhandled button $_initialButtons');
743
    }
744 745 746 747 748
  }

  void _checkLongPressMoveUpdate(PointerEvent event) {
    final LongPressMoveUpdateDetails details = LongPressMoveUpdateDetails(
      globalPosition: event.position,
749
      localPosition: event.localPosition,
750 751
      offsetFromOrigin: event.position - _longPressOrigin!.global,
      localOffsetFromOrigin: event.localPosition - _longPressOrigin!.local,
752
    );
753 754 755
    switch (_initialButtons) {
      case kPrimaryButton:
        if (onLongPressMoveUpdate != null) {
756
          invokeCallback<void>('onLongPressMoveUpdate', () => onLongPressMoveUpdate!(details));
757 758 759 760
        }
        break;
      case kSecondaryButton:
        if (onSecondaryLongPressMoveUpdate != null) {
761
          invokeCallback<void>('onSecondaryLongPressMoveUpdate', () => onSecondaryLongPressMoveUpdate!(details));
762 763
        }
        break;
764 765
      case kTertiaryButton:
        if (onTertiaryLongPressMoveUpdate != null) {
766
          invokeCallback<void>('onTertiaryLongPressMoveUpdate', () => onTertiaryLongPressMoveUpdate!(details));
767 768
        }
        break;
769 770 771
      default:
        assert(false, 'Unhandled button $_initialButtons');
    }
772 773 774
  }

  void _checkLongPressEnd(PointerEvent event) {
775
    final VelocityEstimate? estimate = _velocityTracker!.getVelocityEstimate();
776 777 778
    final Velocity velocity = estimate == null
        ? Velocity.zero
        : Velocity(pixelsPerSecond: estimate.pixelsPerSecond);
779 780
    final LongPressEndDetails details = LongPressEndDetails(
      globalPosition: event.position,
781
      localPosition: event.localPosition,
782
      velocity: velocity,
783
    );
784 785

    _velocityTracker = null;
786 787 788
    switch (_initialButtons) {
      case kPrimaryButton:
        if (onLongPressEnd != null) {
789
          invokeCallback<void>('onLongPressEnd', () => onLongPressEnd!(details));
790 791
        }
        if (onLongPressUp != null) {
792
          invokeCallback<void>('onLongPressUp', onLongPressUp!);
793 794 795 796
        }
        break;
      case kSecondaryButton:
        if (onSecondaryLongPressEnd != null) {
797
          invokeCallback<void>('onSecondaryLongPressEnd', () => onSecondaryLongPressEnd!(details));
798 799
        }
        if (onSecondaryLongPressUp != null) {
800
          invokeCallback<void>('onSecondaryLongPressUp', onSecondaryLongPressUp!);
801 802
        }
        break;
803 804 805 806 807 808 809 810
      case kTertiaryButton:
        if (onTertiaryLongPressEnd != null) {
          invokeCallback<void>('onTertiaryLongPressEnd', () => onTertiaryLongPressEnd!(details));
        }
        if (onTertiaryLongPressUp != null) {
          invokeCallback<void>('onTertiaryLongPressUp', onTertiaryLongPressUp!);
        }
        break;
811 812 813
      default:
        assert(false, 'Unhandled button $_initialButtons');
    }
814 815 816 817 818 819
  }

  void _reset() {
    _longPressAccepted = false;
    _longPressOrigin = null;
    _initialButtons = null;
820
    _velocityTracker = null;
821 822 823 824
  }

  @override
  void resolve(GestureDisposition disposition) {
825 826 827 828 829 830 831 832
    if (disposition == GestureDisposition.rejected) {
      if (_longPressAccepted) {
        // This can happen if the gesture has been canceled. For example when
        // the buttons have changed.
        _reset();
      } else {
        _checkLongPressCancel();
      }
833
    }
834
    super.resolve(disposition);
835
  }
836

837 838 839 840 841 842
  @override
  void acceptGesture(int pointer) {
    // Winning the arena isn't important here since it may happen from a sweep.
    // Explicitly exceeding the deadline puts the gesture in accepted state.
  }

843
  @override
844
  String get debugDescription => 'long press';
845
}