borders.dart 28 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
import 'dart:math' as math;
6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
import 'dart:ui' as ui show lerpDouble;

import 'package:flutter/foundation.dart';

import 'basic_types.dart';
import 'edge_insets.dart';

/// The style of line to draw for a [BorderSide] in a [Border].
enum BorderStyle {
  /// Skip the border.
  none,

  /// Draw the border as a solid line.
  solid,

  // if you add more, think about how they will lerp
}

/// A side of a border of a box.
///
/// A [Border] consists of four [BorderSide] objects: [Border.top],
/// [Border.left], [Border.right], and [Border.bottom].
///
29 30 31
/// Note that setting [BorderSide.width] to 0.0 will result in hairline
/// rendering. A more involved explanation is present in [BorderSide.width].
///
32
/// {@tool snippet}
33 34 35 36 37 38 39
///
/// This sample shows how [BorderSide] objects can be used in a [Container], via
/// a [BoxDecoration] and a [Border], to decorate some [Text]. In this example,
/// the text has a thick bar above it that is light blue, and a thick bar below
/// it that is a darker shade of blue.
///
/// ```dart
40
/// Container(
41
///   padding: const EdgeInsets.all(8.0),
42 43 44 45
///   decoration: BoxDecoration(
///     border: Border(
///       top: BorderSide(width: 16.0, color: Colors.lightBlue.shade50),
///       bottom: BorderSide(width: 16.0, color: Colors.lightBlue.shade900),
46 47
///     ),
///   ),
48
///   child: const Text('Flutter in the sky', textAlign: TextAlign.center),
49 50
/// )
/// ```
51
/// {@end-tool}
52 53 54 55 56
///
/// See also:
///
///  * [Border], which uses [BorderSide] objects to represent its sides.
///  * [BoxDecoration], which optionally takes a [Border] object.
57
///  * [TableBorder], which is similar to [Border] but has two more sides
58 59 60 61 62 63 64 65
///    ([TableBorder.horizontalInside] and [TableBorder.verticalInside]), both
///    of which are also [BorderSide] objects.
@immutable
class BorderSide {
  /// Creates the side of a border.
  ///
  /// By default, the border is 1.0 logical pixels wide and solid black.
  const BorderSide({
66 67 68
    this.color = const Color(0xFF000000),
    this.width = 1.0,
    this.style = BorderStyle.solid,
69 70 71 72 73 74 75 76 77 78 79
  }) : assert(color != null),
       assert(width != null),
       assert(width >= 0.0),
       assert(style != null);

  /// Creates a [BorderSide] that represents the addition of the two given
  /// [BorderSide]s.
  ///
  /// It is only valid to call this if [canMerge] returns true for the two
  /// sides.
  ///
80 81
  /// If one of the sides is zero-width with [BorderStyle.none], then the other
  /// side is return as-is. If both of the sides are zero-width with
82
  /// [BorderStyle.none], then [BorderSide.none] is returned.
83 84
  ///
  /// The arguments must not be null.
85
  static BorderSide merge(BorderSide a, BorderSide b) {
86 87
    assert(a != null);
    assert(b != null);
88
    assert(canMerge(a, b));
89 90 91 92 93 94 95
    final bool aIsNone = a.style == BorderStyle.none && a.width == 0.0;
    final bool bIsNone = b.style == BorderStyle.none && b.width == 0.0;
    if (aIsNone && bIsNone)
      return BorderSide.none;
    if (aIsNone)
      return b;
    if (bIsNone)
96 97 98
      return a;
    assert(a.color == b.color);
    assert(a.style == b.style);
99
    return BorderSide(
100 101 102 103 104
      color: a.color, // == b.color
      width: a.width + b.width,
      style: a.style, // == b.style
    );
  }
105 106 107 108

  /// The color of this side of the border.
  final Color color;

109 110 111 112 113 114 115 116 117
  /// The width of this side of the border, in logical pixels.
  ///
  /// Setting width to 0.0 will result in a hairline border. This means that
  /// the border will have the width of one physical pixel. Also, hairline
  /// rendering takes shortcuts when the path overlaps a pixel more than once.
  /// This means that it will render faster than otherwise, but it might
  /// double-hit pixels, giving it a slightly darker/lighter result.
  ///
  /// To omit the border entirely, set the [style] to [BorderStyle.none].
118 119 120 121 122 123 124 125 126
  final double width;

  /// The style of this side of the border.
  ///
  /// To omit a side, set [style] to [BorderStyle.none]. This skips
  /// painting the border, but the border still has a [width].
  final BorderStyle style;

  /// A hairline black border that is not rendered.
127
  static const BorderSide none = BorderSide(width: 0.0, style: BorderStyle.none);
128 129 130

  /// Creates a copy of this border but with the given fields replaced with the new values.
  BorderSide copyWith({
131 132 133
    Color? color,
    double? width,
    BorderStyle? style,
134
  }) {
135
    assert(width == null || width >= 0.0);
136
    return BorderSide(
137 138
      color: color ?? this.color,
      width: width ?? this.width,
139 140 141 142
      style: style ?? this.style,
    );
  }

143 144 145 146 147
  /// Creates a copy of this border side description but with the width scaled
  /// by the factor `t`.
  ///
  /// The `t` argument represents the multiplicand, or the position on the
  /// timeline for an interpolation from nothing to `this`, with 0.0 meaning
148
  /// that the object returned should be the nil variant of this object, 1.0
149 150 151 152 153 154
  /// meaning that no change should be applied, returning `this` (or something
  /// equivalent to `this`), and other values meaning that the object should be
  /// multiplied by `t`. Negative values are treated like zero.
  ///
  /// Since a zero width is normally painted as a hairline width rather than no
  /// border at all, the zero factor is special-cased to instead change the
155
  /// style to [BorderStyle.none].
156 157 158
  ///
  /// Values for `t` are usually obtained from an [Animation<double>], such as
  /// an [AnimationController].
159 160
  BorderSide scale(double t) {
    assert(t != null);
161
    return BorderSide(
162 163 164
      color: color,
      width: math.max(0.0, width * t),
      style: t <= 0.0 ? BorderStyle.none : style,
165 166 167
    );
  }

168 169 170 171 172 173 174 175 176
  /// Create a [Paint] object that, if used to stroke a line, will draw the line
  /// in this border's style.
  ///
  /// Not all borders use this method to paint their border sides. For example,
  /// non-uniform rectangular [Border]s have beveled edges and so paint their
  /// border sides as filled shapes rather than using a stroke.
  Paint toPaint() {
    switch (style) {
      case BorderStyle.solid:
177
        return Paint()
178 179 180 181
          ..color = color
          ..strokeWidth = width
          ..style = PaintingStyle.stroke;
      case BorderStyle.none:
182
        return Paint()
183 184 185 186 187 188
          ..color = const Color(0x00000000)
          ..strokeWidth = 0.0
          ..style = PaintingStyle.stroke;
    }
  }

189 190
  /// Whether the two given [BorderSide]s can be merged using
  /// [BorderSide.merge].
191
  ///
192 193 194 195
  /// Two sides can be merged if one or both are zero-width with
  /// [BorderStyle.none], or if they both have the same color and style.
  ///
  /// The arguments must not be null.
196
  static bool canMerge(BorderSide a, BorderSide b) {
197 198 199 200
    assert(a != null);
    assert(b != null);
    if ((a.style == BorderStyle.none && a.width == 0.0) ||
        (b.style == BorderStyle.none && b.width == 0.0))
201 202 203 204 205
      return true;
    return a.style == b.style
        && a.color == b.color;
  }

206
  /// Linearly interpolate between two border sides.
207 208
  ///
  /// The arguments must not be null.
209
  ///
210
  /// {@macro dart.ui.shadow.lerp}
211 212 213
  static BorderSide lerp(BorderSide a, BorderSide b, double t) {
    assert(a != null);
    assert(b != null);
214
    assert(t != null);
215 216 217 218
    if (t == 0.0)
      return a;
    if (t == 1.0)
      return b;
219
    final double width = ui.lerpDouble(a.width, b.width, t)!;
Ian Hickson's avatar
Ian Hickson committed
220 221
    if (width < 0.0)
      return BorderSide.none;
222
    if (a.style == b.style) {
223
      return BorderSide(
224
        color: Color.lerp(a.color, b.color, t)!,
Ian Hickson's avatar
Ian Hickson committed
225
        width: width,
226
        style: a.style, // == b.style
227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245
      );
    }
    Color colorA, colorB;
    switch (a.style) {
      case BorderStyle.solid:
        colorA = a.color;
        break;
      case BorderStyle.none:
        colorA = a.color.withAlpha(0x00);
        break;
    }
    switch (b.style) {
      case BorderStyle.solid:
        colorB = b.color;
        break;
      case BorderStyle.none:
        colorB = b.color.withAlpha(0x00);
        break;
    }
246
    return BorderSide(
247
      color: Color.lerp(colorA, colorB, t)!,
Ian Hickson's avatar
Ian Hickson committed
248
      width: width,
249 250 251 252
    );
  }

  @override
253
  bool operator ==(Object other) {
254 255
    if (identical(this, other))
      return true;
256
    if (other.runtimeType != runtimeType)
257
      return false;
258 259 260 261
    return other is BorderSide
        && other.color == color
        && other.width == width
        && other.style == style;
262 263 264 265 266 267
  }

  @override
  int get hashCode => hashValues(color, width, style);

  @override
268
  String toString() => '${objectRuntimeType(this, 'BorderSide')}($color, ${width.toStringAsFixed(1)}, $style)';
269 270
}

Ian Hickson's avatar
Ian Hickson committed
271 272
/// Base class for shape outlines.
///
273 274
/// This class handles how to add multiple borders together. Subclasses define
/// various shapes, like circles ([CircleBorder]), rounded rectangles
275 276 277
/// ([RoundedRectangleBorder]), continuous rectangles
/// ([ContinuousRectangleBorder]), or beveled rectangles
/// ([BeveledRectangleBorder]).
278 279 280 281 282 283 284
///
/// See also:
///
///  * [ShapeDecoration], which can be used with [DecoratedBox] to show a shape.
///  * [Material] (and many other widgets in the Material library), which takes
///    a [ShapeBorder] to define its shape.
///  * [NotchedShape], which describes a shape with a hole in it.
Ian Hickson's avatar
Ian Hickson committed
285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306
@immutable
abstract class ShapeBorder {
  /// Abstract const constructor. This constructor enables subclasses to provide
  /// const constructors so that they can be used in const expressions.
  const ShapeBorder();

  /// The widths of the sides of this border represented as an [EdgeInsets].
  ///
  /// Specifically, this is the amount by which a rectangle should be inset so
  /// as to avoid painting over any important part of the border. It is the
  /// amount by which additional borders will be inset before they are drawn.
  ///
  /// This can be used, for example, with a [Padding] widget to inset a box by
  /// the size of these borders.
  ///
  /// Shapes that have a fixed ratio regardless of the area on which they are
  /// painted, or that change their rendering based on the size they are given
  /// when painting (for instance [CircleBorder]), will not return valid
  /// [dimensions] information because they cannot know their eventual size when
  /// computing their [dimensions].
  EdgeInsetsGeometry get dimensions;

307
  /// Attempts to create a new object that represents the amalgamation of `this`
Ian Hickson's avatar
Ian Hickson committed
308 309 310 311 312 313 314 315 316 317
  /// border and the `other` border.
  ///
  /// If the type of the other border isn't known, or the given instance cannot
  /// be reasonably added to this instance, then this should return null.
  ///
  /// This method is used by the [operator +] implementation.
  ///
  /// The `reversed` argument is true if this object was the right operand of
  /// the `+` operator, and false if it was the left operand.
  @protected
318
  ShapeBorder? add(ShapeBorder other, { bool reversed = false }) => null;
Ian Hickson's avatar
Ian Hickson committed
319 320 321 322 323 324 325 326 327 328

  /// Creates a new border consisting of the two borders on either side of the
  /// operator.
  ///
  /// If the borders belong to classes that know how to add themselves, then
  /// this results in a new border that represents the intelligent addition of
  /// those two borders (see [add]). Otherwise, an object is returned that
  /// merely paints the two borders sequentially, with the left hand operand on
  /// the inside and the right hand operand on the outside.
  ShapeBorder operator +(ShapeBorder other) {
329
    return add(other) ?? other.add(this, reversed: true) ?? _CompoundBorder(<ShapeBorder>[other, this]);
Ian Hickson's avatar
Ian Hickson committed
330 331
  }

332 333 334 335 336 337 338 339
  /// Creates a copy of this border, scaled by the factor `t`.
  ///
  /// Typically this means scaling the width of the border's side, but it can
  /// also include scaling other artifacts of the border, e.g. the border radius
  /// of a [RoundedRectangleBorder].
  ///
  /// The `t` argument represents the multiplicand, or the position on the
  /// timeline for an interpolation from nothing to `this`, with 0.0 meaning
340
  /// that the object returned should be the nil variant of this object, 1.0
341 342 343 344 345 346 347 348 349 350 351 352 353
  /// meaning that no change should be applied, returning `this` (or something
  /// equivalent to `this`), and other values meaning that the object should be
  /// multiplied by `t`. Negative values are allowed but may be meaningless
  /// (they correspond to extrapolating the interpolation from this object to
  /// nothing, and going beyond nothing)
  ///
  /// Values for `t` are usually obtained from an [Animation<double>], such as
  /// an [AnimationController].
  ///
  /// See also:
  ///
  ///  * [BorderSide.scale], which most [ShapeBorder] subclasses defer to for
  ///    the actual computation.
Ian Hickson's avatar
Ian Hickson committed
354 355
  ShapeBorder scale(double t);

356 357
  /// Linearly interpolates from another [ShapeBorder] (possibly of another
  /// class) to `this`.
Ian Hickson's avatar
Ian Hickson committed
358 359 360 361 362 363 364 365
  ///
  /// When implementing this method in subclasses, return null if this class
  /// cannot interpolate from `a`. In that case, [lerp] will try `a`'s [lerpTo]
  /// method instead. If `a` is null, this must not return null.
  ///
  /// The base class implementation handles the case of `a` being null by
  /// deferring to [scale].
  ///
366 367 368 369 370 371 372 373 374 375 376 377 378
  /// The `t` argument represents position on the timeline, with 0.0 meaning
  /// that the interpolation has not started, returning `a` (or something
  /// equivalent to `a`), 1.0 meaning that the interpolation has finished,
  /// returning `this` (or something equivalent to `this`), and values in
  /// between meaning that the interpolation is at the relevant point on the
  /// timeline between `a` and `this`. The interpolation can be extrapolated
  /// beyond 0.0 and 1.0, so negative values and values greater than 1.0 are
  /// valid (and can easily be generated by curves such as
  /// [Curves.elasticInOut]).
  ///
  /// Values for `t` are usually obtained from an [Animation<double>], such as
  /// an [AnimationController].
  ///
Ian Hickson's avatar
Ian Hickson committed
379 380
  /// Instead of calling this directly, use [ShapeBorder.lerp].
  @protected
381
  ShapeBorder? lerpFrom(ShapeBorder? a, double t) {
Ian Hickson's avatar
Ian Hickson committed
382 383 384 385 386
    if (a == null)
      return scale(t);
    return null;
  }

387 388
  /// Linearly interpolates from `this` to another [ShapeBorder] (possibly of
  /// another class).
Ian Hickson's avatar
Ian Hickson committed
389 390 391 392 393 394 395 396 397 398
  ///
  /// This is called if `b`'s [lerpTo] did not know how to handle this class.
  ///
  /// When implementing this method in subclasses, return null if this class
  /// cannot interpolate from `b`. In that case, [lerp] will apply a default
  /// behavior instead. If `b` is null, this must not return null.
  ///
  /// The base class implementation handles the case of `b` being null by
  /// deferring to [scale].
  ///
399 400 401 402 403 404 405 406 407 408 409 410
  /// The `t` argument represents position on the timeline, with 0.0 meaning
  /// that the interpolation has not started, returning `this` (or something
  /// equivalent to `this`), 1.0 meaning that the interpolation has finished,
  /// returning `b` (or something equivalent to `b`), and values in between
  /// meaning that the interpolation is at the relevant point on the timeline
  /// between `this` and `b`. The interpolation can be extrapolated beyond 0.0
  /// and 1.0, so negative values and values greater than 1.0 are valid (and can
  /// easily be generated by curves such as [Curves.elasticInOut]).
  ///
  /// Values for `t` are usually obtained from an [Animation<double>], such as
  /// an [AnimationController].
  ///
Ian Hickson's avatar
Ian Hickson committed
411 412
  /// Instead of calling this directly, use [ShapeBorder.lerp].
  @protected
413
  ShapeBorder? lerpTo(ShapeBorder? b, double t) {
Ian Hickson's avatar
Ian Hickson committed
414 415 416 417 418
    if (b == null)
      return scale(1.0 - t);
    return null;
  }

419 420 421 422 423 424 425
  /// Linearly interpolates between two [ShapeBorder]s.
  ///
  /// This defers to `b`'s [lerpTo] function if `b` is not null. If `b` is
  /// null or if its [lerpTo] returns null, it uses `a`'s [lerpFrom]
  /// function instead. If both return null, it returns `a` before `t=0.5`
  /// and `b` after `t=0.5`.
  ///
426
  /// {@macro dart.ui.shadow.lerp}
427
  static ShapeBorder? lerp(ShapeBorder? a, ShapeBorder? b, double t) {
428
    assert(t != null);
429
    ShapeBorder? result;
430 431 432 433 434
    if (b != null)
      result = b.lerpFrom(a, t);
    if (result == null && a != null)
      result = a.lerpTo(b, t);
    return result ?? (t < 0.5 ? a : b);
Ian Hickson's avatar
Ian Hickson committed
435 436 437 438 439 440 441 442 443 444 445 446
  }

  /// Create a [Path] that describes the outer edge of the border.
  ///
  /// This path must not cross the path given by [getInnerPath] for the same
  /// [Rect].
  ///
  /// To obtain a [Path] that describes the area of the border itself, set the
  /// [Path.fillType] of the returned object to [PathFillType.evenOdd], and add
  /// to this object the path returned from [getInnerPath] (using
  /// [Path.addPath]).
  ///
447
  /// The `textDirection` argument must be provided non-null if the border
Ian Hickson's avatar
Ian Hickson committed
448 449 450 451 452 453 454 455
  /// has a text direction dependency (for example if it is expressed in terms
  /// of "start" and "end" instead of "left" and "right"). It may be null if
  /// the border will not need the text direction to paint itself.
  ///
  /// See also:
  ///
  ///  * [getInnerPath], which creates the path for the inner edge.
  ///  * [Path.contains], which can tell if an [Offset] is within a [Path].
456
  Path getOuterPath(Rect rect, { TextDirection? textDirection });
Ian Hickson's avatar
Ian Hickson committed
457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476

  /// Create a [Path] that describes the inner edge of the border.
  ///
  /// This path must not cross the path given by [getOuterPath] for the same
  /// [Rect].
  ///
  /// To obtain a [Path] that describes the area of the border itself, set the
  /// [Path.fillType] of the returned object to [PathFillType.evenOdd], and add
  /// to this object the path returned from [getOuterPath] (using
  /// [Path.addPath]).
  ///
  /// The `textDirection` argument must be provided and non-null if the border
  /// has a text direction dependency (for example if it is expressed in terms
  /// of "start" and "end" instead of "left" and "right"). It may be null if
  /// the border will not need the text direction to paint itself.
  ///
  /// See also:
  ///
  ///  * [getOuterPath], which creates the path for the outer edge.
  ///  * [Path.contains], which can tell if an [Offset] is within a [Path].
477
  Path getInnerPath(Rect rect, { TextDirection? textDirection });
Ian Hickson's avatar
Ian Hickson committed
478 479 480 481 482 483 484

  /// Paints the border within the given [Rect] on the given [Canvas].
  ///
  /// The `textDirection` argument must be provided and non-null if the border
  /// has a text direction dependency (for example if it is expressed in terms
  /// of "start" and "end" instead of "left" and "right"). It may be null if
  /// the border will not need the text direction to paint itself.
485
  void paint(Canvas canvas, Rect rect, { TextDirection? textDirection });
Ian Hickson's avatar
Ian Hickson committed
486 487 488

  @override
  String toString() {
489
    return '${objectRuntimeType(this, 'ShapeBorder')}()';
Ian Hickson's avatar
Ian Hickson committed
490 491 492
  }
}

493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510
/// A ShapeBorder that draws an outline with the width and color specified
/// by [side].
@immutable
abstract class OutlinedBorder extends ShapeBorder {
  /// Abstract const constructor. This constructor enables subclasses to provide
  /// const constructors so that they can be used in const expressions.
  ///
  /// The value of [side] must not be null.
  const OutlinedBorder({ this.side = BorderSide.none }) : assert(side != null);

  /// The border outline's color and weight.
  ///
  /// If [side] is [BorderSide.none], which is the default, an outline is not drawn.
  /// Otherwise the outline is centered over the shape's boundary.
  final BorderSide side;

  /// Returns a copy of this OutlinedBorder that draws its outline with the
  /// specified [side], if [side] is non-null.
511
  OutlinedBorder copyWith({ BorderSide? side });
512 513
}

Ian Hickson's avatar
Ian Hickson committed
514 515 516 517
/// Represents the addition of two otherwise-incompatible borders.
///
/// The borders are listed from the outside to the inside.
class _CompoundBorder extends ShapeBorder {
518 519 520 521
  _CompoundBorder(this.borders)
    : assert(borders != null),
      assert(borders.length >= 2),
      assert(!borders.any((ShapeBorder border) => border is _CompoundBorder));
Ian Hickson's avatar
Ian Hickson committed
522 523 524 525 526 527 528 529 530 531 532 533 534 535

  final List<ShapeBorder> borders;

  @override
  EdgeInsetsGeometry get dimensions {
    return borders.fold<EdgeInsetsGeometry>(
      EdgeInsets.zero,
      (EdgeInsetsGeometry previousValue, ShapeBorder border) {
        return previousValue.add(border.dimensions);
      },
    );
  }

  @override
536
  ShapeBorder add(ShapeBorder other, { bool reversed = false }) {
Ian Hickson's avatar
Ian Hickson committed
537 538 539 540 541 542 543 544 545 546
    // This wraps the list of borders with "other", or, if "reversed" is true,
    // wraps "other" with the list of borders.
    // If "reversed" is false, "other" should end up being at the start of the
    // list, otherwise, if "reversed" is true, it should end up at the end.
    // First, see if we can merge the new adjacent borders.
    if (other is! _CompoundBorder) {
      // Here, "ours" is the border at the side where we're adding the new
      // border, and "merged" is the result of attempting to merge it with the
      // new border. If it's null, it couldn't be merged.
      final ShapeBorder ours = reversed ? borders.last : borders.first;
547
      final ShapeBorder? merged = ours.add(other, reversed: reversed)
Ian Hickson's avatar
Ian Hickson committed
548 549
                             ?? other.add(ours, reversed: !reversed);
      if (merged != null) {
550
        final List<ShapeBorder> result = <ShapeBorder>[...borders];
Ian Hickson's avatar
Ian Hickson committed
551
        result[reversed ? result.length - 1 : 0] = merged;
552
        return _CompoundBorder(result);
Ian Hickson's avatar
Ian Hickson committed
553 554 555
      }
    }
    // We can't, so fall back to just adding the new border to the list.
556 557 558 559 560 561
    final List<ShapeBorder> mergedBorders = <ShapeBorder>[
      if (reversed) ...borders,
      if (other is _CompoundBorder) ...other.borders
      else other,
      if (!reversed) ...borders,
    ];
562
    return _CompoundBorder(mergedBorders);
Ian Hickson's avatar
Ian Hickson committed
563 564 565 566
  }

  @override
  ShapeBorder scale(double t) {
567
    return _CompoundBorder(
568
      borders.map<ShapeBorder>((ShapeBorder border) => border.scale(t)).toList(),
Ian Hickson's avatar
Ian Hickson committed
569 570 571 572
    );
  }

  @override
573
  ShapeBorder? lerpFrom(ShapeBorder? a, double t) {
Ian Hickson's avatar
Ian Hickson committed
574 575 576 577
    return _CompoundBorder.lerp(a, this, t);
  }

  @override
578
  ShapeBorder? lerpTo(ShapeBorder? b, double t) {
Ian Hickson's avatar
Ian Hickson committed
579 580 581
    return _CompoundBorder.lerp(this, b, t);
  }

582
  static _CompoundBorder lerp(ShapeBorder? a, ShapeBorder? b, double t) {
583
    assert(t != null);
Ian Hickson's avatar
Ian Hickson committed
584
    assert(a is _CompoundBorder || b is _CompoundBorder); // Not really necessary, but all call sites currently intend this.
585 586
    final List<ShapeBorder?> aList = a is _CompoundBorder ? a.borders : <ShapeBorder?>[a];
    final List<ShapeBorder?> bList = b is _CompoundBorder ? b.borders : <ShapeBorder?>[b];
Ian Hickson's avatar
Ian Hickson committed
587 588 589
    final List<ShapeBorder> results = <ShapeBorder>[];
    final int length = math.max(aList.length, bList.length);
    for (int index = 0; index < length; index += 1) {
590 591
      final ShapeBorder? localA = index < aList.length ? aList[index] : null;
      final ShapeBorder? localB = index < bList.length ? bList[index] : null;
Ian Hickson's avatar
Ian Hickson committed
592
      if (localA != null && localB != null) {
593
        final ShapeBorder? localResult = localA.lerpTo(localB, t) ?? localB.lerpFrom(localA, t);
Ian Hickson's avatar
Ian Hickson committed
594 595 596 597 598 599 600 601 602 603 604 605 606 607
        if (localResult != null) {
          results.add(localResult);
          continue;
        }
      }
      // If we're changing from one shape to another, make sure the shape that is coming in
      // is inserted before the shape that is going away, so that the outer path changes to
      // the new border earlier rather than later. (This affects, among other things, where
      // the ShapeDecoration class puts its background.)
      if (localB != null)
        results.add(localB.scale(t));
      if (localA != null)
        results.add(localA.scale(1.0 - t));
    }
608
    return _CompoundBorder(results);
Ian Hickson's avatar
Ian Hickson committed
609 610 611
  }

  @override
612
  Path getInnerPath(Rect rect, { TextDirection? textDirection }) {
Ian Hickson's avatar
Ian Hickson committed
613 614
    for (int index = 0; index < borders.length - 1; index += 1)
      rect = borders[index].dimensions.resolve(textDirection).deflateRect(rect);
615
    return borders.last.getInnerPath(rect, textDirection: textDirection);
Ian Hickson's avatar
Ian Hickson committed
616 617 618
  }

  @override
619
  Path getOuterPath(Rect rect, { TextDirection? textDirection }) {
620
    return borders.first.getOuterPath(rect, textDirection: textDirection);
Ian Hickson's avatar
Ian Hickson committed
621 622 623
  }

  @override
624
  void paint(Canvas canvas, Rect rect, { TextDirection? textDirection }) {
625
    for (final ShapeBorder border in borders) {
Ian Hickson's avatar
Ian Hickson committed
626 627 628 629 630 631
      border.paint(canvas, rect, textDirection: textDirection);
      rect = border.dimensions.resolve(textDirection).deflateRect(rect);
    }
  }

  @override
632
  bool operator ==(Object other) {
Ian Hickson's avatar
Ian Hickson committed
633 634
    if (identical(this, other))
      return true;
635
    if (other.runtimeType != runtimeType)
Ian Hickson's avatar
Ian Hickson committed
636
      return false;
637 638
    return other is _CompoundBorder
        && listEquals<ShapeBorder>(other.borders, borders);
Ian Hickson's avatar
Ian Hickson committed
639 640 641 642 643 644 645 646 647 648 649 650 651 652 653
  }

  @override
  int get hashCode => hashList(borders);

  @override
  String toString() {
    // We list them in reverse order because when adding two borders they end up
    // in the list in the opposite order of what the source looks like: a + b =>
    // [b, a]. We do this to make the painting code more optimal, and most of
    // the rest of the code doesn't care, except toString() (for debugging).
    return borders.reversed.map<String>((ShapeBorder border) => border.toString()).join(' + ');
  }
}

654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670
/// Paints a border around the given rectangle on the canvas.
///
/// The four sides can be independently specified. They are painted in the order
/// top, right, bottom, left. This is only notable if the widths of the borders
/// and the size of the given rectangle are such that the border sides will
/// overlap each other. No effort is made to optimize the rendering of uniform
/// borders (where all the borders have the same configuration); to render a
/// uniform border, consider using [Canvas.drawRect] directly.
///
/// The arguments must not be null.
///
/// See also:
///
///  * [paintImage], which paints an image in a rectangle on a canvas.
///  * [Border], which uses this function to paint its border when the border is
///    not uniform.
///  * [BoxDecoration], which describes its border using the [Border] class.
671 672 673
void paintBorder(
  Canvas canvas,
  Rect rect, {
674 675 676 677
  BorderSide top = BorderSide.none,
  BorderSide right = BorderSide.none,
  BorderSide bottom = BorderSide.none,
  BorderSide left = BorderSide.none,
678 679 680 681 682 683 684 685 686 687 688
}) {
  assert(canvas != null);
  assert(rect != null);
  assert(top != null);
  assert(right != null);
  assert(bottom != null);
  assert(left != null);

  // We draw the borders as filled shapes, unless the borders are hairline
  // borders, in which case we use PaintingStyle.stroke, with the stroke width
  // specified here.
689
  final Paint paint = Paint()
690 691
    ..strokeWidth = 0.0;

692
  final Path path = Path();
693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768

  switch (top.style) {
    case BorderStyle.solid:
      paint.color = top.color;
      path.reset();
      path.moveTo(rect.left, rect.top);
      path.lineTo(rect.right, rect.top);
      if (top.width == 0.0) {
        paint.style = PaintingStyle.stroke;
      } else {
        paint.style = PaintingStyle.fill;
        path.lineTo(rect.right - right.width, rect.top + top.width);
        path.lineTo(rect.left + left.width, rect.top + top.width);
      }
      canvas.drawPath(path, paint);
      break;
    case BorderStyle.none:
      break;
  }

  switch (right.style) {
    case BorderStyle.solid:
      paint.color = right.color;
      path.reset();
      path.moveTo(rect.right, rect.top);
      path.lineTo(rect.right, rect.bottom);
      if (right.width == 0.0) {
        paint.style = PaintingStyle.stroke;
      } else {
        paint.style = PaintingStyle.fill;
        path.lineTo(rect.right - right.width, rect.bottom - bottom.width);
        path.lineTo(rect.right - right.width, rect.top + top.width);
      }
      canvas.drawPath(path, paint);
      break;
    case BorderStyle.none:
      break;
  }

  switch (bottom.style) {
    case BorderStyle.solid:
      paint.color = bottom.color;
      path.reset();
      path.moveTo(rect.right, rect.bottom);
      path.lineTo(rect.left, rect.bottom);
      if (bottom.width == 0.0) {
        paint.style = PaintingStyle.stroke;
      } else {
        paint.style = PaintingStyle.fill;
        path.lineTo(rect.left + left.width, rect.bottom - bottom.width);
        path.lineTo(rect.right - right.width, rect.bottom - bottom.width);
      }
      canvas.drawPath(path, paint);
      break;
    case BorderStyle.none:
      break;
  }

  switch (left.style) {
    case BorderStyle.solid:
      paint.color = left.color;
      path.reset();
      path.moveTo(rect.left, rect.bottom);
      path.lineTo(rect.left, rect.top);
      if (left.width == 0.0) {
        paint.style = PaintingStyle.stroke;
      } else {
        paint.style = PaintingStyle.fill;
        path.lineTo(rect.left + left.width, rect.top + top.width);
        path.lineTo(rect.left + left.width, rect.bottom - bottom.width);
      }
      canvas.drawPath(path, paint);
      break;
    case BorderStyle.none:
      break;
  }
769
}