button_style_button.dart 18.7 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
// Copyright 2014 The Flutter 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:math' as math;

import 'package:flutter/foundation.dart';
import 'package:flutter/rendering.dart';
import 'package:flutter/widgets.dart';

import 'button_style.dart';
import 'colors.dart';
import 'constants.dart';
import 'ink_well.dart';
import 'material.dart';
import 'material_state.dart';
17
import 'material_state_mixin.dart';
18 19 20 21 22 23 24 25 26
import 'theme_data.dart';

/// The base [StatefulWidget] class for buttons whose style is defined by a [ButtonStyle] object.
///
/// Concrete subclasses must override [defaultStyleOf] and [themeStyleOf].
///
/// See also:
///
///  * [TextButton], a simple ButtonStyleButton without a shadow.
27
///  * [ElevatedButton], a filled ButtonStyleButton whose material elevates when pressed.
28 29
///  * [OutlinedButton], similar to [TextButton], but with an outline.
abstract class ButtonStyleButton extends StatefulWidget {
30 31
  /// Abstract const constructor. This constructor enables subclasses to provide
  /// const constructors so that they can be used in const expressions.
32
  const ButtonStyleButton({
33 34 35 36 37 38 39 40
    Key? key,
    required this.onPressed,
    required this.onLongPress,
    required this.style,
    required this.focusNode,
    required this.autofocus,
    required this.clipBehavior,
    required this.child,
41 42 43 44 45 46 47 48 49 50 51
  }) : assert(autofocus != null),
       assert(clipBehavior != null),
       super(key: key);

  /// Called when the button is tapped or otherwise activated.
  ///
  /// If this callback and [onLongPress] are null, then the button will be disabled.
  ///
  /// See also:
  ///
  ///  * [enabled], which is true if the button is enabled.
52
  final VoidCallback? onPressed;
53 54 55 56 57 58 59 60

  /// Called when the button is long-pressed.
  ///
  /// If this callback and [onPressed] are null, then the button will be disabled.
  ///
  /// See also:
  ///
  ///  * [enabled], which is true if the button is enabled.
61
  final VoidCallback? onLongPress;
62 63 64 65 66 67 68 69 70

  /// Customizes this button's appearance.
  ///
  /// Non-null properties of this style override the corresponding
  /// properties in [themeStyleOf] and [defaultStyleOf]. [MaterialStateProperty]s
  /// that resolve to non-null values will similarly override the corresponding
  /// [MaterialStateProperty]s in [themeStyleOf] and [defaultStyleOf].
  ///
  /// Null by default.
71
  final ButtonStyle? style;
72

73
  /// {@macro flutter.material.Material.clipBehavior}
74 75 76 77 78
  ///
  /// Defaults to [Clip.none], and must not be null.
  final Clip clipBehavior;

  /// {@macro flutter.widgets.Focus.focusNode}
79
  final FocusNode? focusNode;
80 81 82 83 84

  /// {@macro flutter.widgets.Focus.autofocus}
  final bool autofocus;

  /// Typically the button's label.
85
  final Widget? child;
86 87 88 89

  /// Returns a non-null [ButtonStyle] that's based primarily on the [Theme]'s
  /// [ThemeData.textTheme] and [ThemeData.colorScheme].
  ///
90
  /// The returned style can be overridden by the [style] parameter and
91
  /// by the style returned by [themeStyleOf]. For example the default
92
  /// style of the [TextButton] subclass can be overridden with its
93 94 95 96 97 98 99 100 101 102 103 104 105 106 107
  /// [TextButton.style] constructor parameter, or with a
  /// [TextButtonTheme].
  ///
  /// Concrete button subclasses should return a ButtonStyle that
  /// has no null properties, and where all of the [MaterialStateProperty]
  /// properties resolve to non-null values.
  ///
  /// See also:
  ///
  ///  * [themeStyleOf], Returns the ButtonStyle of this button's component theme.
  @protected
  ButtonStyle defaultStyleOf(BuildContext context);

  /// Returns the ButtonStyle that belongs to the button's component theme.
  ///
108
  /// The returned style can be overridden by the [style] parameter.
109 110 111 112 113 114 115 116 117
  ///
  /// Concrete button subclasses should return the ButtonStyle for the
  /// nearest subclass-specific inherited theme, and if no such theme
  /// exists, then the same value from the overall [Theme].
  ///
  /// See also:
  ///
  ///  * [defaultStyleOf], Returns the default [ButtonStyle] for this button.
  @protected
118
  ButtonStyle? themeStyleOf(BuildContext context);
119 120 121 122 123 124 125 126

  /// Whether the button is enabled or disabled.
  ///
  /// Buttons are disabled by default. To enable a button, set its [onPressed]
  /// or [onLongPress] properties to a non-null value.
  bool get enabled => onPressed != null || onLongPress != null;

  @override
127
  State<ButtonStyleButton> createState() => _ButtonStyleState();
128 129 130 131 132 133 134 135 136 137 138 139

  @override
  void debugFillProperties(DiagnosticPropertiesBuilder properties) {
    super.debugFillProperties(properties);
    properties.add(FlagProperty('enabled', value: enabled, ifFalse: 'disabled'));
    properties.add(DiagnosticsProperty<ButtonStyle>('style', style, defaultValue: null));
    properties.add(DiagnosticsProperty<FocusNode>('focusNode', focusNode, defaultValue: null));
  }

  /// Returns null if [value] is null, otherwise `MaterialStateProperty.all<T>(value)`.
  ///
  /// A convenience method for subclasses.
140
  static MaterialStateProperty<T>? allOrNull<T>(T? value) => value == null ? null : MaterialStateProperty.all<T>(value);
141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165

  /// Returns an interpolated value based on the [textScaleFactor] parameter:
  ///
  ///  * 0 - 1 [geometry1x]
  ///  * 1 - 2 lerp([geometry1x], [geometry2x], [textScaleFactor] - 1)
  ///  * 2 - 3 lerp([geometry2x], [geometry3x], [textScaleFactor] - 2)
  ///  * otherwise [geometry3x]
  ///
  /// A convenience method for subclasses.
  static EdgeInsetsGeometry scaledPadding(
    EdgeInsetsGeometry geometry1x,
    EdgeInsetsGeometry geometry2x,
    EdgeInsetsGeometry geometry3x,
    double textScaleFactor,
  ) {
    assert(geometry1x != null);
    assert(geometry2x != null);
    assert(geometry3x != null);
    assert(textScaleFactor != null);

    if (textScaleFactor <= 1) {
      return geometry1x;
    } else if (textScaleFactor >= 3) {
      return geometry3x;
    } else if (textScaleFactor <= 2) {
166
      return EdgeInsetsGeometry.lerp(geometry1x, geometry2x, textScaleFactor - 1)!;
167
    }
168
    return EdgeInsetsGeometry.lerp(geometry2x, geometry3x, textScaleFactor - 2)!;
169 170 171 172 173 174 175 176 177
  }
}

/// The base [State] class for buttons whose style is defined by a [ButtonStyle] object.
///
/// See also:
///
///  * [ButtonStyleButton], the [StatefulWidget] subclass for which this class is the [State].
///  * [TextButton], a simple button without a shadow.
178
///  * [ElevatedButton], a filled button whose material elevates when pressed.
179
///  * [OutlinedButton], similar to [TextButton], but with an outline.
180
class _ButtonStyleState extends State<ButtonStyleButton> with MaterialStateMixin, TickerProviderStateMixin {
181 182 183
  AnimationController? _controller;
  double? _elevation;
  Color? _backgroundColor;
184 185 186 187

  @override
  void initState() {
    super.initState();
188
    setMaterialState(MaterialState.disabled, !widget.enabled);
189 190
  }

191 192 193 194 195 196
  @override
  void dispose() {
    _controller?.dispose();
    super.dispose();
  }

197 198 199
  @override
  void didUpdateWidget(ButtonStyleButton oldWidget) {
    super.didUpdateWidget(oldWidget);
200
    setMaterialState(MaterialState.disabled, !widget.enabled);
201 202 203 204
    // If the button is disabled while a press gesture is currently ongoing,
    // InkWell makes a call to handleHighlightChanged. This causes an exception
    // because it calls setState in the middle of a build. To preempt this, we
    // manually update pressed to false when this situation occurs.
205 206
    if (isDisabled && isPressed) {
      removeMaterialState(MaterialState.pressed);
207 208 209 210 211
    }
  }

  @override
  Widget build(BuildContext context) {
212 213
    final ButtonStyle? widgetStyle = widget.style;
    final ButtonStyle? themeStyle = widget.themeStyleOf(context);
214 215 216
    final ButtonStyle defaultStyle = widget.defaultStyleOf(context);
    assert(defaultStyle != null);

217 218 219 220
    T? effectiveValue<T>(T? Function(ButtonStyle? style) getProperty) {
      final T? widgetValue  = getProperty(widgetStyle);
      final T? themeValue   = getProperty(themeStyle);
      final T? defaultValue = getProperty(defaultStyle);
221 222 223
      return widgetValue ?? themeValue ?? defaultValue;
    }

224
    T? resolve<T>(MaterialStateProperty<T>? Function(ButtonStyle? style) getProperty) {
225
      return effectiveValue(
226
        (ButtonStyle? style) => getProperty(style)?.resolve(materialStates),
227 228 229
      );
    }

230 231 232 233 234 235 236
    final double? resolvedElevation = resolve<double?>((ButtonStyle? style) => style?.elevation);
    final TextStyle? resolvedTextStyle = resolve<TextStyle?>((ButtonStyle? style) => style?.textStyle);
    Color? resolvedBackgroundColor = resolve<Color?>((ButtonStyle? style) => style?.backgroundColor);
    final Color? resolvedForegroundColor = resolve<Color?>((ButtonStyle? style) => style?.foregroundColor);
    final Color? resolvedShadowColor = resolve<Color?>((ButtonStyle? style) => style?.shadowColor);
    final EdgeInsetsGeometry? resolvedPadding = resolve<EdgeInsetsGeometry?>((ButtonStyle? style) => style?.padding);
    final Size? resolvedMinimumSize = resolve<Size?>((ButtonStyle? style) => style?.minimumSize);
237
    final Size? resolvedFixedSize = resolve<Size?>((ButtonStyle? style) => style?.fixedSize);
238
    final Size? resolvedMaximumSize = resolve<Size?>((ButtonStyle? style) => style?.maximumSize);
239 240
    final BorderSide? resolvedSide = resolve<BorderSide?>((ButtonStyle? style) => style?.side);
    final OutlinedBorder? resolvedShape = resolve<OutlinedBorder?>((ButtonStyle? style) => style?.shape);
241 242

    final MaterialStateMouseCursor resolvedMouseCursor = _MouseCursor(
243
      (Set<MaterialState> states) => effectiveValue((ButtonStyle? style) => style?.mouseCursor?.resolve(states)),
244 245
    );

246
    final MaterialStateProperty<Color?> overlayColor = MaterialStateProperty.resolveWith<Color?>(
247
      (Set<MaterialState> states) => effectiveValue((ButtonStyle? style) => style?.overlayColor?.resolve(states)),
248 249
    );

250 251 252 253
    final VisualDensity? resolvedVisualDensity = effectiveValue((ButtonStyle? style) => style?.visualDensity);
    final MaterialTapTargetSize? resolvedTapTargetSize = effectiveValue((ButtonStyle? style) => style?.tapTargetSize);
    final Duration? resolvedAnimationDuration = effectiveValue((ButtonStyle? style) => style?.animationDuration);
    final bool? resolvedEnableFeedback = effectiveValue((ButtonStyle? style) => style?.enableFeedback);
254
    final AlignmentGeometry? resolvedAlignment = effectiveValue((ButtonStyle? style) => style?.alignment);
255
    final Offset densityAdjustment = resolvedVisualDensity!.baseSizeAdjustment;
256
    final InteractiveInkFeatureFactory? resolvedSplashFactory = effectiveValue((ButtonStyle? style) => style?.splashFactory);
257 258

    BoxConstraints effectiveConstraints = resolvedVisualDensity.effectiveConstraints(
259
      BoxConstraints(
260
        minWidth: resolvedMinimumSize!.width,
261
        minHeight: resolvedMinimumSize.height,
262 263
        maxWidth: resolvedMaximumSize!.width,
        maxHeight: resolvedMaximumSize.height,
264 265
      ),
    );
266 267 268 269 270 271 272 273 274 275 276
    if (resolvedFixedSize != null) {
      final Size size = effectiveConstraints.constrain(resolvedFixedSize);
      if (size.width.isFinite) {
        effectiveConstraints = effectiveConstraints.copyWith(
          minWidth: size.width,
          maxWidth: size.width,
        );
      }
      if (size.height.isFinite) {
        effectiveConstraints = effectiveConstraints.copyWith(
          minHeight: size.height,
277
          maxHeight: size.height,
278 279 280 281
        );
      }
    }

282 283 284 285 286 287 288 289 290
    // Per the Material Design team: don't allow the VisualDensity
    // adjustment to reduce the width of the left/right padding. If we
    // did, VisualDensity.compact, the default for desktop/web, would
    // reduce the horizontal padding to zero.
    final double dy = densityAdjustment.dy;
    final double dx = math.max(0, densityAdjustment.dx);
    final EdgeInsetsGeometry padding = resolvedPadding!
      .add(EdgeInsets.fromLTRB(dx, dy, dx, dy))
      .clamp(EdgeInsets.zero, EdgeInsetsGeometry.infinity);
291

292 293 294 295
    // If an opaque button's background is becoming translucent while its
    // elevation is changing, change the elevation first. Material implicitly
    // animates its elevation but not its color. SKIA renders non-zero
    // elevations as a shadow colored fill behind the Material's background.
296
    if (resolvedAnimationDuration! > Duration.zero
297 298 299
        && _elevation != null
        && _backgroundColor != null
        && _elevation != resolvedElevation
300 301
        && _backgroundColor!.value != resolvedBackgroundColor!.value
        && _backgroundColor!.opacity == 1
302 303 304 305 306 307 308 309 310 311 312 313 314 315 316
        && resolvedBackgroundColor.opacity < 1
        && resolvedElevation == 0) {
      if (_controller?.duration != resolvedAnimationDuration) {
        _controller?.dispose();
        _controller = AnimationController(
          duration: resolvedAnimationDuration,
          vsync: this,
        )
        ..addStatusListener((AnimationStatus status) {
          if (status == AnimationStatus.completed) {
            setState(() { }); // Rebuild with the final background color.
          }
        });
      }
      resolvedBackgroundColor = _backgroundColor; // Defer changing the background color.
317 318
      _controller!.value = 0;
      _controller!.forward();
319 320 321 322
    }
    _elevation = resolvedElevation;
    _backgroundColor = resolvedBackgroundColor;

323 324 325
    final Widget result = ConstrainedBox(
      constraints: effectiveConstraints,
      child: Material(
326
        elevation: resolvedElevation!,
327
        textStyle: resolvedTextStyle?.copyWith(color: resolvedForegroundColor),
328
        shape: resolvedShape!.copyWith(side: resolvedSide),
329 330 331 332 333 334 335 336
        color: resolvedBackgroundColor,
        shadowColor: resolvedShadowColor,
        type: resolvedBackgroundColor == null ? MaterialType.transparency : MaterialType.button,
        animationDuration: resolvedAnimationDuration,
        clipBehavior: widget.clipBehavior,
        child: InkWell(
          onTap: widget.onPressed,
          onLongPress: widget.onLongPress,
337 338
          onHighlightChanged: updateMaterialState(MaterialState.pressed),
          onHover: updateMaterialState(MaterialState.hovered),
339 340 341 342
          mouseCursor: resolvedMouseCursor,
          enableFeedback: resolvedEnableFeedback,
          focusNode: widget.focusNode,
          canRequestFocus: widget.enabled,
343
          onFocusChange: updateMaterialState(MaterialState.focused),
344
          autofocus: widget.autofocus,
345
          splashFactory: resolvedSplashFactory,
346 347 348 349 350 351 352
          overlayColor: overlayColor,
          highlightColor: Colors.transparent,
          customBorder: resolvedShape,
          child: IconTheme.merge(
            data: IconThemeData(color: resolvedForegroundColor),
            child: Padding(
              padding: padding,
353 354
              child: Align(
                alignment: resolvedAlignment!,
355 356 357 358 359 360 361 362 363 364
                widthFactor: 1.0,
                heightFactor: 1.0,
                child: widget.child,
              ),
            ),
          ),
        ),
      ),
    );

365
    final Size minSize;
366
    switch (resolvedTapTargetSize!) {
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
      case MaterialTapTargetSize.padded:
        minSize = Size(
          kMinInteractiveDimension + densityAdjustment.dx,
          kMinInteractiveDimension + densityAdjustment.dy,
        );
        assert(minSize.width >= 0.0);
        assert(minSize.height >= 0.0);
        break;
      case MaterialTapTargetSize.shrinkWrap:
        minSize = Size.zero;
        break;
    }

    return Semantics(
      container: true,
      button: true,
      enabled: widget.enabled,
      child: _InputPadding(
        minSize: minSize,
        child: result,
      ),
    );
  }
}

class _MouseCursor extends MaterialStateMouseCursor {
  const _MouseCursor(this.resolveCallback);

395
  final MaterialPropertyResolver<MouseCursor?> resolveCallback;
396 397

  @override
398
  MouseCursor resolve(Set<MaterialState> states) => resolveCallback(states)!;
399 400 401 402 403 404 405 406 407 408 409 410

  @override
  String get debugDescription => 'ButtonStyleButton_MouseCursor';
}

/// A widget to pad the area around a [MaterialButton]'s inner [Material].
///
/// Redirect taps that occur in the padded area around the child to the center
/// of the child. This increases the size of the button and the button's
/// "tap target", but not its material or its ink splashes.
class _InputPadding extends SingleChildRenderObjectWidget {
  const _InputPadding({
411 412 413
    Key? key,
    Widget? child,
    required this.minSize,
414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429
  }) : super(key: key, child: child);

  final Size minSize;

  @override
  RenderObject createRenderObject(BuildContext context) {
    return _RenderInputPadding(minSize);
  }

  @override
  void updateRenderObject(BuildContext context, covariant _RenderInputPadding renderObject) {
    renderObject.minSize = minSize;
  }
}

class _RenderInputPadding extends RenderShiftedBox {
430
  _RenderInputPadding(this._minSize, [RenderBox? child]) : super(child);
431 432 433 434 435 436 437 438 439 440 441 442 443

  Size get minSize => _minSize;
  Size _minSize;
  set minSize(Size value) {
    if (_minSize == value)
      return;
    _minSize = value;
    markNeedsLayout();
  }

  @override
  double computeMinIntrinsicWidth(double height) {
    if (child != null)
444
      return math.max(child!.getMinIntrinsicWidth(height), minSize.width);
445 446 447 448 449 450
    return 0.0;
  }

  @override
  double computeMinIntrinsicHeight(double width) {
    if (child != null)
451
      return math.max(child!.getMinIntrinsicHeight(width), minSize.height);
452 453 454 455 456 457
    return 0.0;
  }

  @override
  double computeMaxIntrinsicWidth(double height) {
    if (child != null)
458
      return math.max(child!.getMaxIntrinsicWidth(height), minSize.width);
459 460 461 462 463 464
    return 0.0;
  }

  @override
  double computeMaxIntrinsicHeight(double width) {
    if (child != null)
465
      return math.max(child!.getMaxIntrinsicHeight(width), minSize.height);
466 467 468
    return 0.0;
  }

469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486
  Size _computeSize({required BoxConstraints constraints, required ChildLayouter layoutChild}) {
    if (child != null) {
      final Size childSize = layoutChild(child!, constraints);
      final double height = math.max(childSize.width, minSize.width);
      final double width = math.max(childSize.height, minSize.height);
      return constraints.constrain(Size(height, width));
    }
    return Size.zero;
  }

  @override
  Size computeDryLayout(BoxConstraints constraints) {
    return _computeSize(
      constraints: constraints,
      layoutChild: ChildLayoutHelper.dryLayoutChild,
    );
  }

487 488
  @override
  void performLayout() {
489 490 491 492
    size = _computeSize(
      constraints: constraints,
      layoutChild: ChildLayoutHelper.layoutChild,
    );
493
    if (child != null) {
494
      final BoxParentData childParentData = child!.parentData! as BoxParentData;
495
      childParentData.offset = Alignment.center.alongOffset(size - child!.size as Offset);
496 497 498 499
    }
  }

  @override
500
  bool hitTest(BoxHitTestResult result, { required Offset position }) {
501 502 503
    if (super.hitTest(result, position: position)) {
      return true;
    }
504
    final Offset center = child!.size.center(Offset.zero);
505 506 507
    return result.addWithRawTransform(
      transform: MatrixUtils.forceToPoint(center),
      position: center,
508
      hitTest: (BoxHitTestResult result, Offset? position) {
509
        assert(position == center);
510
        return child!.hitTest(result, position: center);
511 512 513 514
      },
    );
  }
}