aoi-hosizora / flutter_ahlib Goto Github PK

      int totalSize;
      http.head(url, headers: {
        'Accept': '*/*',
        'Accept-Encoding': '',
      }).then((data) {
        totalSize = int.tryParse(data.headers['content-length']);
      });

enum _AppendIndicatorMode {
  drag, // start to show
  armed, // drag far enough
  append, // run the append callback
  done_before, // before append callback is done
  done, // append callback is done
  canceled, // canceled by no arming
}

  static const _kScaleSlowDuration = Duration(milliseconds: 400);
  static const _kScaleFastDuration = Duration(milliseconds: 100);
  static const _kProgressFadeDuration = Duration(milliseconds: 100);
  static const _kProgressIncrDuration = Duration(milliseconds: 150);
  static const _kProgressFinalDuration = Duration(milliseconds: 150);

  AnimationController _progressController;
  Animation<double> _progressAnimation;

  void initState() {
    super.initState();
    _sizeController = AnimationController(vsync: this);
    _sizeFactor = _sizeController.drive(Tween(begin: 0.0, end: 1.0));
    _progressController = AnimationController(vsync: this);
    _progressAnimation = _progressController.drive(Tween(begin: 0.0, end: 1.0));
  }

  void _start() {
    _sizeController.value = 0.0;
    _progressController.value = 0.0;
    _dragOffset = 0;
  }

  /// Show animation with "-> fade -> increasing -> shrink" or "-> shrink".
  void _dismiss(_AppendIndicatorMode newMode) async {
    if (newMode == _AppendIndicatorMode.canceled) {
      // -> cancel
      _mode = _AppendIndicatorMode.canceled;
      if (mounted) setState(() {});
    } else if (newMode == _AppendIndicatorMode.done) {
      // -> done_before
      _mode = _AppendIndicatorMode.done_before;
      if (mounted) setState(() {});
      await Future.delayed(_kProgressFadeDuration); // fade
      await _progressController.animateTo(1.0, duration: _kProgressIncrDuration); // increasing
      await Future.delayed(_kProgressFinalDuration);
      // -> done
      _mode = _AppendIndicatorMode.done;
      if (mounted) setState(() {});
    }
    await _sizeController.animateTo(0.0, duration: _kScaleSlowDuration, curve: Curves.easeOutCubic); // shrink

    // -> null
    _mode = null;
    if (mounted) setState(() {});
  }

SizeTransition(
  sizeFactor: _sizeFactor,
  axis: Axis.horizontal,
  child: AnimatedCrossFade(
    duration: _kProgressFadeDuration,
    crossFadeState: _mode == _AppendIndicatorMode.done_before || _mode == _AppendIndicatorMode.done ? CrossFadeState.showSecond : CrossFadeState.showFirst,
    firstChild: LinearProgressIndicator(
      value: _mode == _AppendIndicatorMode.append || _mode == _AppendIndicatorMode.done_before || _mode == _AppendIndicatorMode.done ? null : 0,
      minHeight: widget.minHeight,
      backgroundColor: widget.backgroundColor,
      valueColor: widget.valueColor,
    ),
    secondChild: AnimatedBuilder(
      animation: _progressAnimation,
      builder: (_, __) => LinearProgressIndicator(
        value: _progressAnimation.value,
        minHeight: widget.minHeight,
        backgroundColor: widget.backgroundColor,
        valueColor: widget.valueColor,
      ),
    ),
  ),
),

PageController _controller;
_controller.animateToPage(index, duration: kTabScrollDuration, curve: Curves.easeOutQuad);

/// An [Icon] with a line from left top to bottom right, which is rendered by [CustomPaint].
class BannedIcon extends StatelessWidget {
  const BannedIcon({
    Key key,
    @required this.icon,
    this.banned = true,
    @required this.color,
    @required this.backgroundColor,
    this.offset = 3.0,
    this.lineWidth = 3.0,
    this.blinkLineWidth = 2.0,
    this.size = Size.zero,
  })  : assert(icon != null),
        assert(banned != null),
        assert(offset != null),
        assert(color != null),
        assert(backgroundColor != null),
        assert(lineWidth != null),
        assert(blinkLineWidth != null),
        assert(size != null),
        super(key: key);

  /// Content icon, the shape of line depends on this widget's size.
  final Widget icon;

  /// Paint the line or not.
  final bool banned;

  /// Color of line, need to be the same as icon's color.
  final Color color;

  /// Color of background, used to paint the blink line.
  final Color backgroundColor;

  /// Line position offset from the icon size, default is 3.0.
  final double offset;

  /// Line width, default is 3.0.
  final double lineWidth;

  /// Blink link width, default is 2.0, recommend to set a value that close to [lineWidth].
  final double blinkLineWidth;

  /// Icon size, default is [Size.zero] which depends on the child or parent.
  final Size size;

  @override
  Widget build(BuildContext context) {
    return Center(
      child: CustomPaint(
        foregroundPainter: !banned
            ? null
            : FunctionPainter(
                onPaint: (canvas, size) {
                  // line
                  canvas.drawLine(
                    Offset(offset, offset),
                    Offset(size.width - offset, size.height - offset),
                    Paint()
                      ..color = color
                      ..strokeWidth = lineWidth,
                  );
                  // blink line
                  canvas.drawLine(
                    Offset(offset, offset - blinkLineWidth),
                    Offset(size.width - offset + blinkLineWidth, size.height - offset),
                    Paint()
                      ..color = backgroundColor
                      ..strokeWidth = blinkLineWidth,
                  );
                },
              ),
        child: icon,
        size: size,
        willChange: banned ? true : false,
      ),
    );
  }
}