table_border.dart 10 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 8 9 10 11 12 13 14 15 16 17 18 19
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

import 'package:flutter/foundation.dart';
import 'package:flutter/painting.dart' hide Border;

/// Border specification for [Table] widgets.
///
/// This is like [Border], with the addition of two sides: the inner horizontal
/// borders between rows and the inner vertical borders between columns.
///
/// The sides are represented by [BorderSide] objects.
@immutable
class TableBorder {
  /// Creates a border for a table.
  ///
  /// All the sides of the border default to [BorderSide.none].
  const TableBorder({
20 21 22 23 24 25
    this.top = BorderSide.none,
    this.right = BorderSide.none,
    this.bottom = BorderSide.none,
    this.left = BorderSide.none,
    this.horizontalInside = BorderSide.none,
    this.verticalInside = BorderSide.none,
26
    this.borderRadius = BorderRadius.zero,
27 28 29 30 31 32
  });

  /// A uniform border with all sides the same color and width.
  ///
  /// The sides default to black solid borders, one logical pixel wide.
  factory TableBorder.all({
33 34 35
    Color color = const Color(0xFF000000),
    double width = 1.0,
    BorderStyle style = BorderStyle.solid,
36
    BorderRadius borderRadius = BorderRadius.zero,
37
  }) {
38
    final BorderSide side = BorderSide(color: color, width: width, style: style);
39
    return TableBorder(top: side, right: side, bottom: side, left: side, horizontalInside: side, verticalInside: side, borderRadius: borderRadius);
40 41 42 43 44
  }

  /// Creates a border for a table where all the interior sides use the same
  /// styling and all the exterior sides use the same styling.
  factory TableBorder.symmetric({
45 46
    BorderSide inside = BorderSide.none,
    BorderSide outside = BorderSide.none,
47
  }) {
48
    return TableBorder(
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
      top: outside,
      right: outside,
      bottom: outside,
      left: outside,
      horizontalInside: inside,
      verticalInside: inside,
    );
  }

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

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

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

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

  /// The horizontal interior sides of this border.
  final BorderSide horizontalInside;

  /// The vertical interior sides of this border.
  final BorderSide verticalInside;

76 77 78
  /// The [BorderRadius] to use when painting the corners of this border.
  final BorderRadius borderRadius;

79 80 81 82 83
  /// The widths of the sides of this border represented as an [EdgeInsets].
  ///
  /// This can be used, for example, with a [Padding] widget to inset a box by
  /// the size of these borders.
  EdgeInsets get dimensions {
84
    return EdgeInsets.fromLTRB(left.width, top.width, right.width, bottom.width);
85 86
  }

87 88
  /// Whether all the sides of the border (outside and inside) are identical.
  /// Uniform borders are typically more efficient to paint.
89 90 91 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
  bool get isUniform {
    assert(top != null);
    assert(right != null);
    assert(bottom != null);
    assert(left != null);
    assert(horizontalInside != null);
    assert(verticalInside != null);

    final Color topColor = top.color;
    if (right.color != topColor ||
        bottom.color != topColor ||
        left.color != topColor ||
        horizontalInside.color != topColor ||
        verticalInside.color != topColor)
      return false;

    final double topWidth = top.width;
    if (right.width != topWidth ||
        bottom.width != topWidth ||
        left.width != topWidth ||
        horizontalInside.width != topWidth ||
        verticalInside.width != topWidth)
      return false;

    final BorderStyle topStyle = top.style;
    if (right.style != topStyle ||
        bottom.style != topStyle ||
        left.style != topStyle ||
        horizontalInside.style != topStyle ||
        verticalInside.style != topStyle)
      return false;

    return true;
  }

124 125 126 127
  /// Creates a copy of this border but with the widths 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
128
  /// that the object returned should be the nil variant of this object, 1.0
129 130 131 132 133 134 135 136 137 138
  /// 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.
  ///
  /// Values for `t` are usually obtained from an [Animation<double>], such as
  /// an [AnimationController].
  ///
  /// See also:
  ///
  ///  * [BorderSide.scale], which is used to implement this method.
139
  TableBorder scale(double t) {
140
    return TableBorder(
141 142 143 144 145 146
      top: top.scale(t),
      right: right.scale(t),
      bottom: bottom.scale(t),
      left: left.scale(t),
      horizontalInside: horizontalInside.scale(t),
      verticalInside: verticalInside.scale(t),
147 148 149 150 151 152 153
    );
  }

  /// Linearly interpolate between two table borders.
  ///
  /// If a border is null, it is treated as having only [BorderSide.none]
  /// borders.
154
  ///
155
  /// {@macro dart.ui.shadow.lerp}
156
  static TableBorder? lerp(TableBorder? a, TableBorder? b, double t) {
157
    assert(t != null);
158 159 160
    if (a == null && b == null)
      return null;
    if (a == null)
161
      return b!.scale(t);
162 163
    if (b == null)
      return a.scale(1.0 - t);
164
    return TableBorder(
165 166 167 168 169
      top: BorderSide.lerp(a.top, b.top, t),
      right: BorderSide.lerp(a.right, b.right, t),
      bottom: BorderSide.lerp(a.bottom, b.bottom, t),
      left: BorderSide.lerp(a.left, b.left, t),
      horizontalInside: BorderSide.lerp(a.horizontalInside, b.horizontalInside, t),
170
      verticalInside: BorderSide.lerp(a.verticalInside, b.verticalInside, t),
171 172 173 174 175 176 177 178
    );
  }

  /// Paints the border around the given [Rect] on the given [Canvas], with the
  /// given rows and columns.
  ///
  /// Uniform borders are more efficient to paint than more complex borders.
  ///
179 180 181 182 183
  /// The `rows` argument specifies the vertical positions between the rows,
  /// relative to the given rectangle. For example, if the table contained two
  /// rows of height 100.0 each, then `rows` would contain a single value,
  /// 100.0, which is the vertical position between the two rows (relative to
  /// the top edge of `rect`).
184
  ///
185 186 187 188 189
  /// The `columns` argument specifies the horizontal positions between the
  /// columns, relative to the given rectangle. For example, if the table
  /// contained two columns of height 100.0 each, then `columns` would contain a
  /// single value, 100.0, which is the vertical position between the two
  /// columns (relative to the left edge of `rect`).
190
  ///
191 192 193
  /// The [verticalInside] border is only drawn if there are at least two
  /// columns. The [horizontalInside] border is only drawn if there are at least
  /// two rows. The horizontal borders are drawn after the vertical borders.
194 195
  ///
  /// The outer borders (in the order [top], [right], [bottom], [left], with
196
  /// [left] above the others) are painted after the inner borders.
197 198 199
  ///
  /// The paint order is particularly notable in the case of
  /// partially-transparent borders.
200 201 202
  void paint(
    Canvas canvas,
    Rect rect, {
203 204
    required Iterable<double> rows,
    required Iterable<double> columns,
205 206 207 208 209 210 211 212 213 214 215 216 217
  }) {
    // properties can't be null
    assert(top != null);
    assert(right != null);
    assert(bottom != null);
    assert(left != null);
    assert(horizontalInside != null);
    assert(verticalInside != null);

    // arguments can't be null
    assert(canvas != null);
    assert(rect != null);
    assert(rows != null);
218
    assert(rows.isEmpty || (rows.first >= 0.0 && rows.last <= rect.height));
219
    assert(columns != null);
220
    assert(columns.isEmpty || (columns.first >= 0.0 && columns.last <= rect.width));
221

222
    if (columns.isNotEmpty || rows.isNotEmpty) {
223 224
      final Paint paint = Paint();
      final Path path = Path();
225

226 227 228 229 230 231 232 233
      if (columns.isNotEmpty) {
        switch (verticalInside.style) {
          case BorderStyle.solid:
            paint
              ..color = verticalInside.color
              ..strokeWidth = verticalInside.width
              ..style = PaintingStyle.stroke;
            path.reset();
234
            for (final double x in columns) {
235 236 237 238 239 240 241
              path.moveTo(rect.left + x, rect.top);
              path.lineTo(rect.left + x, rect.bottom);
            }
            canvas.drawPath(path, paint);
            break;
          case BorderStyle.none:
            break;
242
        }
243
      }
244

245 246 247 248 249 250 251 252
      if (rows.isNotEmpty) {
        switch (horizontalInside.style) {
          case BorderStyle.solid:
            paint
              ..color = horizontalInside.color
              ..strokeWidth = horizontalInside.width
              ..style = PaintingStyle.stroke;
            path.reset();
253
            for (final double y in rows) {
254 255 256 257 258 259 260
              path.moveTo(rect.left, rect.top + y);
              path.lineTo(rect.right, rect.top + y);
            }
            canvas.drawPath(path, paint);
            break;
          case BorderStyle.none:
            break;
261
        }
262
      }
263
    }
264 265 266 267 268 269 270 271
    if(!isUniform || borderRadius == BorderRadius.zero)
      paintBorder(canvas, rect, top: top, right: right, bottom: bottom, left: left);
    else {
      final RRect outer = borderRadius.toRRect(rect);
      final RRect inner = outer.deflate(top.width);
      final Paint paint = Paint()..color = top.color;
      canvas.drawDRRect(outer, inner, paint);
    }
272 273 274
  }

  @override
275
  bool operator ==(Object other) {
276 277
    if (identical(this, other))
      return true;
278
    if (other.runtimeType != runtimeType)
279
      return false;
280 281 282 283 284 285
    return other is TableBorder
        && other.top == top
        && other.right == right
        && other.bottom == bottom
        && other.left == left
        && other.horizontalInside == horizontalInside
286 287
        && other.verticalInside == verticalInside
        && other.borderRadius == borderRadius;
288 289 290
  }

  @override
291
  int get hashCode => Object.hash(top, right, bottom, left, horizontalInside, verticalInside, borderRadius);
292 293

  @override
294
  String toString() => 'TableBorder($top, $right, $bottom, $left, $horizontalInside, $verticalInside, $borderRadius)';
295
}