stadium_border.dart 11.7 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 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
// Copyright 2017 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

import 'dart:ui' as ui show lerpDouble;

import 'basic_types.dart';
import 'border_radius.dart';
import 'borders.dart';
import 'circle_border.dart';
import 'edge_insets.dart';
import 'rounded_rectangle_border.dart';

/// A border that fits a stadium-shaped border (a box with semicircles on the ends)
/// within the rectangle of the widget it is applied to.
///
/// Typically used with [ShapeDecoration] to draw a stadium border.
///
/// If the rectangle is taller than it is wide, then the semicircles will be on the
/// top and bottom, and on the left and right otherwise.
///
/// See also:
///
///  * [BorderSide], which is used to describe the border of the stadium.
class StadiumBorder extends ShapeBorder {
  /// Create a stadium border.
  ///
  /// The [side] argument must not be null.
  const StadiumBorder({this.side = BorderSide.none}) : assert(side != null);

  /// The style of this border.
  final BorderSide side;

  @override
  EdgeInsetsGeometry get dimensions {
36
    return EdgeInsets.all(side.width);
37 38 39
  }

  @override
40
  ShapeBorder scale(double t) => StadiumBorder(side: side.scale(t));
41 42 43

  @override
  ShapeBorder lerpFrom(ShapeBorder a, double t) {
44
    assert(t != null);
45
    if (a is StadiumBorder)
46
      return StadiumBorder(side: BorderSide.lerp(a.side, side, t));
47
    if (a is CircleBorder) {
48
      return _StadiumToCircleBorder(
49 50 51 52 53
        side: BorderSide.lerp(a.side, side, t),
        circleness: 1.0 - t,
      );
    }
    if (a is RoundedRectangleBorder) {
54
      return _StadiumToRoundedRectangleBorder(
55 56 57 58 59 60 61 62 63 64
        side: BorderSide.lerp(a.side, side, t),
        borderRadius: a.borderRadius,
        rectness: 1.0 - t,
      );
    }
    return super.lerpFrom(a, t);
  }

  @override
  ShapeBorder lerpTo(ShapeBorder b, double t) {
65
    assert(t != null);
66
    if (b is StadiumBorder)
67
      return StadiumBorder(side: BorderSide.lerp(side, b.side, t));
68
    if (b is CircleBorder) {
69
      return _StadiumToCircleBorder(
70 71 72 73 74
        side: BorderSide.lerp(side, b.side, t),
        circleness: t,
      );
    }
    if (b is RoundedRectangleBorder) {
75
      return _StadiumToRoundedRectangleBorder(
76 77 78 79 80 81 82 83 84 85
        side: BorderSide.lerp(side, b.side, t),
        borderRadius: b.borderRadius,
        rectness: t,
      );
    }
    return super.lerpTo(b, t);
  }

  @override
  Path getInnerPath(Rect rect, { TextDirection textDirection }) {
86 87 88
    final Radius radius = Radius.circular(rect.shortestSide / 2.0);
    return Path()
      ..addRRect(RRect.fromRectAndRadius(rect, radius).deflate(side.width));
89 90 91 92
  }

  @override
  Path getOuterPath(Rect rect, { TextDirection textDirection }) {
93 94 95
    final Radius radius = Radius.circular(rect.shortestSide / 2.0);
    return Path()
      ..addRRect(RRect.fromRectAndRadius(rect, radius));
96 97 98 99 100 101 102 103
  }

  @override
  void paint(Canvas canvas, Rect rect, { TextDirection textDirection }) {
    switch (side.style) {
      case BorderStyle.none:
        break;
      case BorderStyle.solid:
104
        final Radius radius = Radius.circular(rect.shortestSide / 2.0);
105
        canvas.drawRRect(
106
          RRect.fromRectAndRadius(rect, radius).deflate(side.width / 2.0),
107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131
          side.toPaint(),
        );
    }
  }

  @override
  bool operator ==(dynamic other) {
    if (runtimeType != other.runtimeType)
      return false;
    final StadiumBorder typedOther = other;
    return side == typedOther.side;
  }

  @override
  int get hashCode => side.hashCode;

  @override
  String toString() {
    return '$runtimeType($side)';
  }
}

// Class to help with transitioning to/from a CircleBorder.
class _StadiumToCircleBorder extends ShapeBorder {
  const _StadiumToCircleBorder({
132 133
    this.side = BorderSide.none,
    this.circleness = 0.0,
134 135 136 137 138 139 140 141 142
  }) : assert(side != null),
       assert(circleness != null);

  final BorderSide side;

  final double circleness;

  @override
  EdgeInsetsGeometry get dimensions {
143
    return EdgeInsets.all(side.width);
144 145 146 147
  }

  @override
  ShapeBorder scale(double t) {
148
    return _StadiumToCircleBorder(
149 150 151 152 153 154 155
      side: side.scale(t),
      circleness: t,
    );
  }

  @override
  ShapeBorder lerpFrom(ShapeBorder a, double t) {
156
    assert(t != null);
157
    if (a is StadiumBorder) {
158
      return _StadiumToCircleBorder(
159 160 161 162 163
        side: BorderSide.lerp(a.side, side, t),
        circleness: circleness * t,
      );
    }
    if (a is CircleBorder) {
164
      return _StadiumToCircleBorder(
165 166 167 168 169
        side: BorderSide.lerp(a.side, side, t),
        circleness: circleness + (1.0 - circleness) * (1.0 - t),
      );
    }
    if (a is _StadiumToCircleBorder) {
170
      return _StadiumToCircleBorder(
171 172 173 174 175 176 177 178 179
        side: BorderSide.lerp(a.side, side, t),
        circleness: ui.lerpDouble(a.circleness, circleness, t),
      );
    }
    return super.lerpFrom(a, t);
  }

  @override
  ShapeBorder lerpTo(ShapeBorder b, double t) {
180
    assert(t != null);
181
    if (b is StadiumBorder) {
182
      return _StadiumToCircleBorder(
183 184 185 186 187
        side: BorderSide.lerp(side, b.side, t),
        circleness: circleness * (1.0 - t),
      );
    }
    if (b is CircleBorder) {
188
      return _StadiumToCircleBorder(
189 190 191 192 193
        side: BorderSide.lerp(side, b.side, t),
        circleness: circleness + (1.0 - circleness) * t,
      );
    }
    if (b is _StadiumToCircleBorder) {
194
      return _StadiumToCircleBorder(
195 196 197 198 199 200 201 202 203 204 205 206
        side: BorderSide.lerp(side, b.side, t),
        circleness: ui.lerpDouble(circleness, b.circleness, t),
      );
    }
    return super.lerpTo(b, t);
  }

  Rect _adjustRect(Rect rect) {
    if (circleness == 0.0 || rect.width == rect.height)
      return rect;
    if (rect.width < rect.height) {
      final double delta = circleness * (rect.height - rect.width) / 2.0;
207
      return Rect.fromLTRB(
208 209 210 211 212 213 214
        rect.left,
        rect.top + delta,
        rect.right,
        rect.bottom - delta,
      );
    } else {
      final double delta = circleness * (rect.width - rect.height) / 2.0;
215
      return Rect.fromLTRB(
216 217 218 219 220 221 222 223 224
        rect.left + delta,
        rect.top,
        rect.right - delta,
        rect.bottom,
      );
    }
  }

  BorderRadius _adjustBorderRadius(Rect rect) {
225
    return BorderRadius.circular(rect.shortestSide / 2.0);
226 227 228 229
  }

  @override
  Path getInnerPath(Rect rect, { TextDirection textDirection }) {
230
    return Path()
231 232 233 234 235
      ..addRRect(_adjustBorderRadius(rect).toRRect(_adjustRect(rect)).deflate(side.width));
  }

  @override
  Path getOuterPath(Rect rect, { TextDirection textDirection }) {
236
    return Path()
237 238 239 240 241 242 243 244 245 246 247 248 249 250 251
      ..addRRect(_adjustBorderRadius(rect).toRRect(_adjustRect(rect)));
  }

  @override
  void paint(Canvas canvas, Rect rect, { TextDirection textDirection }) {
    switch (side.style) {
      case BorderStyle.none:
        break;
      case BorderStyle.solid:
        final double width = side.width;
        if (width == 0.0) {
          canvas.drawRRect(_adjustBorderRadius(rect).toRRect(_adjustRect(rect)), side.toPaint());
        } else {
          final RRect outer = _adjustBorderRadius(rect).toRRect(_adjustRect(rect));
          final RRect inner = outer.deflate(width);
252
          final Paint paint = Paint()
253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280
            ..color = side.color;
          canvas.drawDRRect(outer, inner, paint);
        }
    }
  }

  @override
  bool operator ==(dynamic other) {
    if (runtimeType != other.runtimeType)
      return false;
    final _StadiumToCircleBorder typedOther = other;
    return side == typedOther.side
        && circleness == typedOther.circleness;
  }

  @override
  int get hashCode => hashValues(side, circleness);

  @override
  String toString() {
    return 'StadiumBorder($side, ${(circleness * 100).toStringAsFixed(1)}% '
           'of the way to being a CircleBorder)';
  }
}

// Class to help with transitioning to/from a RoundedRectBorder.
class _StadiumToRoundedRectangleBorder extends ShapeBorder {
  const _StadiumToRoundedRectangleBorder({
281 282 283
    this.side = BorderSide.none,
    this.borderRadius = BorderRadius.zero,
    this.rectness = 0.0,
284 285 286 287 288 289 290 291 292 293 294 295
  }) : assert(side != null),
       assert(borderRadius != null),
       assert(rectness != null);

  final BorderSide side;

  final BorderRadius borderRadius;

  final double rectness;

  @override
  EdgeInsetsGeometry get dimensions {
296
    return EdgeInsets.all(side.width);
297 298 299 300
  }

  @override
  ShapeBorder scale(double t) {
301
    return _StadiumToRoundedRectangleBorder(
302 303 304 305 306 307 308 309
      side: side.scale(t),
      borderRadius: borderRadius * t,
      rectness: t,
    );
  }

  @override
  ShapeBorder lerpFrom(ShapeBorder a, double t) {
310
    assert(t != null);
311
    if (a is StadiumBorder) {
312
      return _StadiumToRoundedRectangleBorder(
313 314 315 316 317 318
        side: BorderSide.lerp(a.side, side, t),
        borderRadius: borderRadius,
        rectness: rectness * t,
      );
    }
    if (a is RoundedRectangleBorder) {
319
      return _StadiumToRoundedRectangleBorder(
320 321 322 323 324 325
        side: BorderSide.lerp(a.side, side, t),
        borderRadius: borderRadius,
        rectness: rectness + (1.0 - rectness) * (1.0 - t),
      );
    }
    if (a is _StadiumToRoundedRectangleBorder) {
326
      return _StadiumToRoundedRectangleBorder(
327 328 329 330 331 332 333 334 335 336
        side: BorderSide.lerp(a.side, side, t),
        borderRadius: BorderRadius.lerp(a.borderRadius, borderRadius, t),
        rectness: ui.lerpDouble(a.rectness, rectness, t),
      );
    }
    return super.lerpFrom(a, t);
  }

  @override
  ShapeBorder lerpTo(ShapeBorder b, double t) {
337
    assert(t != null);
338
    if (b is StadiumBorder) {
339
      return _StadiumToRoundedRectangleBorder(
340 341 342 343 344 345
        side: BorderSide.lerp(side, b.side, t),
        borderRadius: borderRadius,
        rectness: rectness * (1.0 - t),
      );
    }
    if (b is RoundedRectangleBorder) {
346
      return _StadiumToRoundedRectangleBorder(
347 348 349 350 351 352
        side: BorderSide.lerp(side, b.side, t),
        borderRadius: borderRadius,
        rectness: rectness + (1.0 - rectness) * t,
      );
    }
    if (b is _StadiumToRoundedRectangleBorder) {
353
      return _StadiumToRoundedRectangleBorder(
354 355 356 357 358 359 360 361 362 363 364
        side: BorderSide.lerp(side, b.side, t),
        borderRadius: BorderRadius.lerp(borderRadius, b.borderRadius, t),
        rectness: ui.lerpDouble(rectness, b.rectness, t),
      );
    }
    return super.lerpTo(b, t);
  }

  BorderRadius _adjustBorderRadius(Rect rect) {
    return BorderRadius.lerp(
      borderRadius,
365
      BorderRadius.all(Radius.circular(rect.shortestSide / 2.0)),
366
      1.0 - rectness,
367 368 369 370 371
    );
  }

  @override
  Path getInnerPath(Rect rect, { TextDirection textDirection }) {
372
    return Path()
373 374 375 376 377
      ..addRRect(_adjustBorderRadius(rect).toRRect(rect).deflate(side.width));
  }

  @override
  Path getOuterPath(Rect rect, { TextDirection textDirection }) {
378
    return Path()
379 380 381 382 383 384 385 386 387 388 389 390 391 392 393
      ..addRRect(_adjustBorderRadius(rect).toRRect(rect));
  }

  @override
  void paint(Canvas canvas, Rect rect, { TextDirection textDirection }) {
    switch (side.style) {
      case BorderStyle.none:
        break;
      case BorderStyle.solid:
        final double width = side.width;
        if (width == 0.0) {
          canvas.drawRRect(_adjustBorderRadius(rect).toRRect(rect), side.toPaint());
        } else {
          final RRect outer = _adjustBorderRadius(rect).toRRect(rect);
          final RRect inner = outer.deflate(width);
394
          final Paint paint = Paint()
395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420
            ..color = side.color;
          canvas.drawDRRect(outer, inner, paint);
        }
    }
  }

  @override
  bool operator ==(dynamic other) {
    if (runtimeType != other.runtimeType)
      return false;
    final _StadiumToRoundedRectangleBorder typedOther = other;
    return side == typedOther.side
        && borderRadius == typedOther.borderRadius
        && rectness == typedOther.rectness;
  }

  @override
  int get hashCode => hashValues(side, borderRadius, rectness);

  @override
  String toString() {
    return 'StadiumBorder($side, $borderRadius, '
           '${(rectness * 100).toStringAsFixed(1)}% of the way to being a '
           'RoundedRectangleBorder)';
  }
}