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

import 'dart:math' as math;

import 'package:flutter/rendering.dart';
8
import 'package:flutter/gestures.dart' show DragStartBehavior;
9 10 11

import 'basic.dart';
import 'framework.dart';
12
import 'primary_scroll_controller.dart';
13 14
import 'scroll_controller.dart';
import 'scroll_physics.dart';
15 16
import 'scrollable.dart';

17 18 19 20 21 22 23 24 25 26
/// A box in which a single widget can be scrolled.
///
/// This widget is useful when you have a single box that will normally be
/// entirely visible, for example a clock face in a time picker, but you need to
/// make sure it can be scrolled if the container gets too small in one axis
/// (the scroll direction).
///
/// It is also useful if you need to shrink-wrap in both axes (the main
/// scrolling direction as well as the cross axis), as one might see in a dialog
/// or pop-up menu. In that case, you might pair the [SingleChildScrollView]
27
/// with a [ListBody] child.
28 29 30 31
///
/// When you have a list of children and do not require cross-axis
/// shrink-wrapping behavior, for example a scrolling list that is always the
/// width of the screen, consider [ListView], which is vastly more efficient
32
/// that a [SingleChildScrollView] containing a [ListBody] or [Column] with
33 34
/// many children.
///
35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82
/// ## Sample code: Using [SingleChildScrollView] with a [Column]
///
/// Sometimes a layout is designed around the flexible properties of a
/// [Column], but there is the concern that in some cases, there might not
/// be enough room to see the entire contents. This could be because some
/// devices have unusually small screens, or because the application can
/// be used in landscape mode where the aspect ratio isn't what was
/// originally envisioned, or because the application is being shown in a
/// small window in split-screen mode. In any case, as a result, it might
/// make sense to wrap the layout in a [SingleChildScrollView].
///
/// Simply doing so, however, usually results in a conflict between the [Column],
/// which typically tries to grow as big as it can, and the [SingleChildScrollView],
/// which provides its children with an infinite amount of space.
///
/// To resolve this apparent conflict, there are a couple of techniques, as
/// discussed below. These techniques should only be used when the content is
/// normally expected to fit on the screen, so that the lazy instantiation of
/// a sliver-based [ListView] or [CustomScrollView] is not expected to provide
/// any performance benefit. If the viewport is expected to usually contain
/// content beyond the dimensions of the screen, then [SingleChildScrollView]
/// would be very expensive.
///
/// ### Centering, spacing, or aligning fixed-height content
///
/// If the content has fixed (or intrinsic) dimensions but needs to be spaced out,
/// centered, or otherwise positioned using the [Flex] layout model of a [Column],
/// the following technique can be used to provide the [Column] with a minimum
/// dimension while allowing it to shrink-wrap the contents when there isn't enough
/// room to apply these spacing or alignment needs.
///
/// A [LayoutBuilder] is used to obtain the size of the viewport (implicitly via
/// the constraints that the [SingleChildScrollView] sees, since viewports
/// typically grow to fit their maximum height constraint). Then, inside the
/// scroll view, a [ConstrainedBox] is used to set the minimum height of the
/// [Column].
///
/// The [Column] has no [Expanded] children, so rather than take on the infinite
/// height from its [BoxConstraints.maxHeight], (the viewport provides no maximum height
/// constraint), it automatically tries to shrink to fit its children. It cannot
/// be smaller than its [BoxConstraints.minHeight], though, and It therefore
/// becomes the bigger of the minimum height provided by the
/// [ConstrainedBox] and the sum of the heights of the children.
///
/// If the children aren't enough to fit that minimum size, the [Column] ends up
/// with some remaining space to allocate as specified by its
/// [Column.mainAxisAlignment] argument.
///
83
/// {@tool dartpad --template=stateless_widget_material}
84 85
/// In this example, the children are spaced out equally, unless there's no more
/// room, in which case they stack vertically and scroll.
86 87 88 89 90
///
/// When using this technique, [Expanded] and [Flexible] are not useful, because
/// in both cases the "available space" is infinite (since this is in a viewport).
/// The next section describes a technique for providing a maximum height constraint.
///
91
/// ```dart
92 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 127
///  Widget build(BuildContext context) {
///    return DefaultTextStyle(
///      style: Theme.of(context).textTheme.bodyText2,
///      child: LayoutBuilder(
///        builder: (BuildContext context, BoxConstraints viewportConstraints) {
///          return SingleChildScrollView(
///            child: ConstrainedBox(
///              constraints: BoxConstraints(
///                minHeight: viewportConstraints.maxHeight,
///              ),
///              child: Column(
///                mainAxisSize: MainAxisSize.min,
///                mainAxisAlignment: MainAxisAlignment.spaceAround,
///                children: <Widget>[
///                  Container(
///                    // A fixed-height child.
///                    color: const Color(0xffeeee00), // Yellow
///                    height: 120.0,
///                    alignment: Alignment.center,
///                    child: const Text('Fixed Height Content'),
///                  ),
///                  Container(
///                    // Another fixed-height child.
///                    color: const Color(0xff008000), // Green
///                    height: 120.0,
///                    alignment: Alignment.center,
///                    child: const Text('Fixed Height Content'),
///                  ),
///                ],
///              ),
///            ),
///          );
///        },
///      ),
///    );
///  }
128 129 130
/// ```
/// {@end-tool}
///
131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156
/// ### Expanding content to fit the viewport
///
/// The following example builds on the previous one. In addition to providing a
/// minimum dimension for the child [Column], an [IntrinsicHeight] widget is used
/// to force the column to be exactly as big as its contents. This constraint
/// combines with the [ConstrainedBox] constraints discussed previously to ensure
/// that the column becomes either as big as viewport, or as big as the contents,
/// whichever is biggest.
///
/// Both constraints must be used to get the desired effect. If only the
/// [IntrinsicHeight] was specified, then the column would not grow to fit the
/// entire viewport when its children were smaller than the whole screen. If only
/// the size of the viewport was used, then the [Column] would overflow if the
/// children were bigger than the viewport.
///
/// The widget that is to grow to fit the remaining space so provided is wrapped
/// in an [Expanded] widget.
///
/// This technique is quite expensive, as it more or less requires that the contents
/// of the viewport be laid out twice (once to find their intrinsic dimensions, and
/// once to actually lay them out). The number of widgets within the column should
/// therefore be kept small. Alternatively, subsets of the children that have known
/// dimensions can be wrapped in a [SizedBox] that has tight vertical constraints,
/// so that the intrinsic sizing algorithm can short-circuit the computation when it
/// reaches those parts of the subtree.
///
157
/// {@tool dartpad --template=stateless_widget_material}
158 159 160 161
/// In this example, the column becomes either as big as viewport, or as big as
/// the contents, whichever is biggest.
///
/// ```dart
162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200
///  Widget build(BuildContext context) {
///    return DefaultTextStyle(
///      style: Theme.of(context).textTheme.bodyText2,
///      child: LayoutBuilder(
///        builder: (BuildContext context, BoxConstraints viewportConstraints) {
///          return SingleChildScrollView(
///            child: ConstrainedBox(
///              constraints: BoxConstraints(
///                minHeight: viewportConstraints.maxHeight,
///              ),
///              child: IntrinsicHeight(
///                child: Column(
///                  children: <Widget>[
///                    Container(
///                      // A fixed-height child.
///                      color: const Color(0xffeeee00), // Yellow
///                      height: 120.0,
///                      alignment: Alignment.center,
///                      child: const Text('Fixed Height Content'),
///                    ),
///                    Expanded(
///                      // A flexible child that will grow to fit the viewport but
///                      // still be at least as big as necessary to fit its contents.
///                      child: Container(
///                        color: const Color(0xffee0000), // Red
///                        height: 120.0,
///                        alignment: Alignment.center,
///                        child: const Text('Flexible Content'),
///                      ),
///                    ),
///                  ],
///                ),
///              ),
///            ),
///          );
///        },
///      ),
///    );
///  }
201 202 203
/// ```
/// {@end-tool}
///
204 205
/// See also:
///
206 207 208 209
///  * [ListView], which handles multiple children in a scrolling list.
///  * [GridView], which handles multiple children in a scrolling grid.
///  * [PageView], for a scrollable that works page by page.
///  * [Scrollable], which handles arbitrary scrolling effects.
210
class SingleChildScrollView extends StatelessWidget {
211
  /// Creates a box in which a single widget can be scrolled.
212
  const SingleChildScrollView({
213
    Key? key,
214 215
    this.scrollDirection = Axis.vertical,
    this.reverse = false,
216
    this.padding,
217
    bool? primary,
218 219
    this.physics,
    this.controller,
220
    this.child,
221
    this.dragStartBehavior = DragStartBehavior.start,
222
    this.clipBehavior = Clip.hardEdge,
223
    this.restorationId,
224
  }) : assert(scrollDirection != null),
225
       assert(dragStartBehavior != null),
226
       assert(clipBehavior != null),
227 228 229 230
       assert(!(controller != null && primary == true),
          'Primary ScrollViews obtain their ScrollController via inheritance from a PrimaryScrollController widget. '
          'You cannot both set primary to true and pass an explicit controller.'
       ),
231
       primary = primary ?? controller == null && identical(scrollDirection, Axis.vertical),
232
       super(key: key);
233

234 235 236
  /// The axis along which the scroll view scrolls.
  ///
  /// Defaults to [Axis.vertical].
237 238
  final Axis scrollDirection;

239 240 241 242 243 244 245
  /// Whether the scroll view scrolls in the reading direction.
  ///
  /// For example, if the reading direction is left-to-right and
  /// [scrollDirection] is [Axis.horizontal], then the scroll view scrolls from
  /// left to right when [reverse] is false and from right to left when
  /// [reverse] is true.
  ///
246
  /// Similarly, if [scrollDirection] is [Axis.vertical], then the scroll view
247 248 249 250
  /// scrolls from top to bottom when [reverse] is false and from bottom to top
  /// when [reverse] is true.
  ///
  /// Defaults to false.
251 252
  final bool reverse;

253
  /// The amount of space by which to inset the child.
254
  final EdgeInsetsGeometry? padding;
255

256 257 258 259
  /// An object that can be used to control the position to which this scroll
  /// view is scrolled.
  ///
  /// Must be null if [primary] is true.
260 261 262 263 264 265 266 267
  ///
  /// A [ScrollController] serves several purposes. It can be used to control
  /// the initial scroll position (see [ScrollController.initialScrollOffset]).
  /// It can be used to control whether the scroll view should automatically
  /// save and restore its scroll position in the [PageStorage] (see
  /// [ScrollController.keepScrollOffset]). It can be used to read the current
  /// scroll position (see [ScrollController.offset]), or change it (see
  /// [ScrollController.animateTo]).
268
  final ScrollController? controller;
269

270 271 272 273 274 275
  /// Whether this is the primary scroll view associated with the parent
  /// [PrimaryScrollController].
  ///
  /// On iOS, this identifies the scroll view that will scroll to top in
  /// response to a tap in the status bar.
  ///
276
  /// Defaults to true when [scrollDirection] is vertical and [controller] is
277
  /// not specified.
278 279
  final bool primary;

280 281 282 283 284 285
  /// How the scroll view should respond to user input.
  ///
  /// For example, determines how the scroll view continues to animate after the
  /// user stops dragging the scroll view.
  ///
  /// Defaults to matching platform conventions.
286
  final ScrollPhysics? physics;
287

288
  /// The widget that scrolls.
289 290
  ///
  /// {@macro flutter.widgets.child}
291
  final Widget? child;
292

293 294 295
  /// {@macro flutter.widgets.scrollable.dragStartBehavior}
  final DragStartBehavior dragStartBehavior;

296 297 298 299 300
  /// {@macro flutter.widgets.Clip}
  ///
  /// Defaults to [Clip.hardEdge].
  final Clip clipBehavior;

301
  /// {@macro flutter.widgets.scrollable.restorationId}
302
  final String? restorationId;
303

304
  AxisDirection _getDirection(BuildContext context) {
305
    return getAxisDirectionFromAxisReverseAndDirectionality(context, scrollDirection, reverse);
306 307 308 309
  }

  @override
  Widget build(BuildContext context) {
310
    final AxisDirection axisDirection = _getDirection(context);
311
    Widget? contents = child;
312
    if (padding != null)
313 314
      contents = Padding(padding: padding!, child: contents);
    final ScrollController? scrollController = primary
315 316
        ? PrimaryScrollController.of(context)
        : controller;
317
    final Scrollable scrollable = Scrollable(
318
      dragStartBehavior: dragStartBehavior,
319
      axisDirection: axisDirection,
320
      controller: scrollController,
321
      physics: physics,
322
      restorationId: restorationId,
323
      viewportBuilder: (BuildContext context, ViewportOffset offset) {
324
        return _SingleChildViewport(
325 326
          axisDirection: axisDirection,
          offset: offset,
327
          child: contents,
328
          clipBehavior: clipBehavior,
329 330
        );
      },
331
    );
332
    return primary && scrollController != null
333
      ? PrimaryScrollController.none(child: scrollable)
334
      : scrollable;
335 336 337 338
  }
}

class _SingleChildViewport extends SingleChildRenderObjectWidget {
339
  const _SingleChildViewport({
340
    Key? key,
341
    this.axisDirection = AxisDirection.down,
342 343 344
    required this.offset,
    Widget? child,
    required this.clipBehavior,
345
  }) : assert(axisDirection != null),
346
       assert(clipBehavior != null),
347
       super(key: key, child: child);
348 349 350

  final AxisDirection axisDirection;
  final ViewportOffset offset;
351
  final Clip clipBehavior;
352 353 354

  @override
  _RenderSingleChildViewport createRenderObject(BuildContext context) {
355
    return _RenderSingleChildViewport(
356 357
      axisDirection: axisDirection,
      offset: offset,
358
      clipBehavior: clipBehavior,
359 360 361 362 363 364 365 366
    );
  }

  @override
  void updateRenderObject(BuildContext context, _RenderSingleChildViewport renderObject) {
    // Order dependency: The offset setter reads the axis direction.
    renderObject
      ..axisDirection = axisDirection
367 368
      ..offset = offset
      ..clipBehavior = clipBehavior;
369 370 371
  }
}

372
class _RenderSingleChildViewport extends RenderBox with RenderObjectWithChildMixin<RenderBox> implements RenderAbstractViewport {
373
  _RenderSingleChildViewport({
374
    AxisDirection axisDirection = AxisDirection.down,
375
    required ViewportOffset offset,
376
    double cacheExtent = RenderAbstractViewport.defaultCacheExtent,
377 378
    RenderBox? child,
    required Clip clipBehavior,
379 380
  }) : assert(axisDirection != null),
       assert(offset != null),
381
       assert(cacheExtent != null),
382
       assert(clipBehavior != null),
383
       _axisDirection = axisDirection,
384
       _offset = offset,
385 386
       _cacheExtent = cacheExtent,
       _clipBehavior = clipBehavior {
387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408
    this.child = child;
  }

  AxisDirection get axisDirection => _axisDirection;
  AxisDirection _axisDirection;
  set axisDirection(AxisDirection value) {
    assert(value != null);
    if (value == _axisDirection)
      return;
    _axisDirection = value;
    markNeedsLayout();
  }

  Axis get axis => axisDirectionToAxis(axisDirection);

  ViewportOffset get offset => _offset;
  ViewportOffset _offset;
  set offset(ViewportOffset value) {
    assert(value != null);
    if (value == _offset)
      return;
    if (attached)
409
      _offset.removeListener(_hasScrolled);
410 411
    _offset = value;
    if (attached)
412
      _offset.addListener(_hasScrolled);
413
    markNeedsLayout();
414 415
  }

416 417 418 419 420 421 422 423 424 425 426
  /// {@macro flutter.rendering.viewport.cacheExtent}
  double get cacheExtent => _cacheExtent;
  double _cacheExtent;
  set cacheExtent(double value) {
    assert(value != null);
    if (value == _cacheExtent)
      return;
    _cacheExtent = value;
    markNeedsLayout();
  }

427 428 429 430 431 432 433 434 435 436 437 438 439 440
  /// {@macro flutter.widgets.Clip}
  ///
  /// Defaults to [Clip.none], and must not be null.
  Clip get clipBehavior => _clipBehavior;
  Clip _clipBehavior = Clip.none;
  set clipBehavior(Clip value) {
    assert(value != null);
    if (value != _clipBehavior) {
      _clipBehavior = value;
      markNeedsPaint();
      markNeedsSemanticsUpdate();
    }
  }

441 442 443 444 445
  void _hasScrolled() {
    markNeedsPaint();
    markNeedsSemanticsUpdate();
  }

446 447 448 449 450
  @override
  void setupParentData(RenderObject child) {
    // We don't actually use the offset argument in BoxParentData, so let's
    // avoid allocating it at all.
    if (child.parentData is! ParentData)
451
      child.parentData = ParentData();
452 453 454 455 456
  }

  @override
  void attach(PipelineOwner owner) {
    super.attach(owner);
457
    _offset.addListener(_hasScrolled);
458 459 460 461
  }

  @override
  void detach() {
462
    _offset.removeListener(_hasScrolled);
463 464 465 466 467 468
    super.detach();
  }

  @override
  bool get isRepaintBoundary => true;

469
  double get _viewportExtent {
470 471 472 473
    assert(hasSize);
    switch (axis) {
      case Axis.horizontal:
        return size.width;
474 475
      case Axis.vertical:
        return size.height;
476 477 478 479 480 481 482 483 484 485 486 487
    }
  }

  double get _minScrollExtent {
    assert(hasSize);
    return 0.0;
  }

  double get _maxScrollExtent {
    assert(hasSize);
    if (child == null)
      return 0.0;
488 489
    switch (axis) {
      case Axis.horizontal:
490
        return math.max(0.0, child!.size.width - size.width);
491
      case Axis.vertical:
492
        return math.max(0.0, child!.size.height - size.height);
493
    }
494 495 496 497 498 499 500 501 502 503 504 505 506 507
  }

  BoxConstraints _getInnerConstraints(BoxConstraints constraints) {
    switch (axis) {
      case Axis.horizontal:
        return constraints.heightConstraints();
      case Axis.vertical:
        return constraints.widthConstraints();
    }
  }

  @override
  double computeMinIntrinsicWidth(double height) {
    if (child != null)
508
      return child!.getMinIntrinsicWidth(height);
509 510 511 512 513 514
    return 0.0;
  }

  @override
  double computeMaxIntrinsicWidth(double height) {
    if (child != null)
515
      return child!.getMaxIntrinsicWidth(height);
516 517 518 519 520 521
    return 0.0;
  }

  @override
  double computeMinIntrinsicHeight(double width) {
    if (child != null)
522
      return child!.getMinIntrinsicHeight(width);
523 524 525 526 527 528
    return 0.0;
  }

  @override
  double computeMaxIntrinsicHeight(double width) {
    if (child != null)
529
      return child!.getMaxIntrinsicHeight(width);
530 531 532 533 534 535 536 537 538 539
    return 0.0;
  }

  // We don't override computeDistanceToActualBaseline(), because we
  // want the default behavior (returning null). Otherwise, as you
  // scroll, it would shift in its parent if the parent was baseline-aligned,
  // which makes no sense.

  @override
  void performLayout() {
540
    final BoxConstraints constraints = this.constraints;
541 542 543
    if (child == null) {
      size = constraints.smallest;
    } else {
544 545
      child!.layout(_getInnerConstraints(constraints), parentUsesSize: true);
      size = constraints.constrain(child!.size);
546 547
    }

548
    offset.applyViewportDimension(_viewportExtent);
549 550 551
    offset.applyContentDimensions(_minScrollExtent, _maxScrollExtent);
  }

552 553 554
  Offset get _paintOffset => _paintOffsetForPosition(offset.pixels);

  Offset _paintOffsetForPosition(double position) {
555 556 557
    assert(axisDirection != null);
    switch (axisDirection) {
      case AxisDirection.up:
558
        return Offset(0.0, position - child!.size.height + size.height);
559
      case AxisDirection.down:
560
        return Offset(0.0, -position);
561
      case AxisDirection.left:
562
        return Offset(position - child!.size.width + size.width, 0.0);
563
      case AxisDirection.right:
564
        return Offset(-position, 0.0);
565 566 567 568 569
    }
  }

  bool _shouldClipAtPaintOffset(Offset paintOffset) {
    assert(child != null);
570
    return paintOffset.dx < 0 ||
571
      paintOffset.dy < 0 ||
572 573
      paintOffset.dx + child!.size.width > size.width ||
      paintOffset.dy + child!.size.height > size.height;
574 575 576 577 578
  }

  @override
  void paint(PaintingContext context, Offset offset) {
    if (child != null) {
579
      final Offset paintOffset = _paintOffset;
580 581

      void paintContents(PaintingContext context, Offset offset) {
582
        context.paintChild(child!, offset + paintOffset);
583 584
      }

585 586
      if (_shouldClipAtPaintOffset(paintOffset) && clipBehavior != Clip.none) {
        context.pushClipRect(needsCompositing, offset, Offset.zero & size, paintContents, clipBehavior: clipBehavior);
587 588 589 590 591 592 593 594
      } else {
        paintContents(context, offset);
      }
    }
  }

  @override
  void applyPaintTransform(RenderBox child, Matrix4 transform) {
595
    final Offset paintOffset = _paintOffset;
596 597 598 599
    transform.translate(paintOffset.dx, paintOffset.dy);
  }

  @override
600
  Rect? describeApproximatePaintClip(RenderObject? child) {
601
    if (child != null && _shouldClipAtPaintOffset(_paintOffset))
602
      return Offset.zero & size;
603 604 605 606
    return null;
  }

  @override
607
  bool hitTestChildren(BoxHitTestResult result, { required Offset position }) {
608
    if (child != null) {
609 610 611
      return result.addWithPaintOffset(
        offset: _paintOffset,
        position: position,
612
        hitTest: (BoxHitTestResult result, Offset? transformed) {
613
          assert(transformed == position + -_paintOffset);
614
          return child!.hitTest(result, position: transformed!);
615 616
        },
      );
617 618 619
    }
    return false;
  }
620 621

  @override
622
  RevealedOffset getOffsetToReveal(RenderObject target, double alignment, { Rect? rect }) {
623
    rect ??= target.paintBounds;
624
    if (target is! RenderBox)
625
      return RevealedOffset(offset: offset.pixels, rect: rect);
626

627
    final RenderBox targetBox = target;
628
    final Matrix4 transform = targetBox.getTransformTo(child);
629
    final Rect bounds = MatrixUtils.transformRect(transform, rect);
630
    final Size contentSize = child!.size;
631

632 633 634
    double leadingScrollOffset;
    double targetMainAxisExtent;
    double mainAxisExtent;
635 636 637 638

    assert(axisDirection != null);
    switch (axisDirection) {
      case AxisDirection.up:
639 640 641
        mainAxisExtent = size.height;
        leadingScrollOffset = contentSize.height - bounds.bottom;
        targetMainAxisExtent = bounds.height;
642 643
        break;
      case AxisDirection.right:
644 645 646
        mainAxisExtent = size.width;
        leadingScrollOffset = bounds.left;
        targetMainAxisExtent = bounds.width;
647 648
        break;
      case AxisDirection.down:
649 650 651
        mainAxisExtent = size.height;
        leadingScrollOffset = bounds.top;
        targetMainAxisExtent = bounds.height;
652 653
        break;
      case AxisDirection.left:
654 655 656
        mainAxisExtent = size.width;
        leadingScrollOffset = contentSize.width - bounds.right;
        targetMainAxisExtent = bounds.width;
657 658 659
        break;
    }

660 661
    final double targetOffset = leadingScrollOffset - (mainAxisExtent - targetMainAxisExtent) * alignment;
    final Rect targetRect = bounds.shift(_paintOffsetForPosition(targetOffset));
662
    return RevealedOffset(offset: targetOffset, rect: targetRect);
663
  }
664 665

  @override
666
  void showOnScreen({
667 668
    RenderObject? descendant,
    Rect? rect,
669 670 671
    Duration duration = Duration.zero,
    Curve curve = Curves.ease,
  }) {
672 673 674 675 676 677 678 679 680
    if (!offset.allowImplicitScrolling) {
      return super.showOnScreen(
        descendant: descendant,
        rect: rect,
        duration: duration,
        curve: curve,
      );
    }

681
    final Rect? newRect = RenderViewportBase.showInViewport(
682 683 684 685 686 687 688 689 690 691 692 693
      descendant: descendant,
      viewport: this,
      offset: offset,
      rect: rect,
      duration: duration,
      curve: curve,
    );
    super.showOnScreen(
      rect: newRect,
      duration: duration,
      curve: curve,
    );
694
  }
695 696 697 698 699 700

  @override
  Rect describeSemanticsClip(RenderObject child) {
    assert(axis != null);
    switch (axis) {
      case Axis.vertical:
701
        return Rect.fromLTRB(
702 703 704 705 706 707
          semanticBounds.left,
          semanticBounds.top - cacheExtent,
          semanticBounds.right,
          semanticBounds.bottom + cacheExtent,
        );
      case Axis.horizontal:
708
        return Rect.fromLTRB(
709 710 711 712 713 714 715
          semanticBounds.left - cacheExtent,
          semanticBounds.top,
          semanticBounds.right + cacheExtent,
          semanticBounds.bottom,
        );
    }
  }
716
}