您最多选择25个主题
主题必须以中文或者字母或数字开头，可以包含连字符 (-)，并且长度不得超过35个字符
1295 行
47 KiB
1295 行
47 KiB
using System.Collections.Generic;
|
|
using RSG;
|
|
using Unity.UIWidgets.animation;
|
|
using Unity.UIWidgets.foundation;
|
|
using Unity.UIWidgets.gestures;
|
|
using Unity.UIWidgets.painting;
|
|
using Unity.UIWidgets.rendering;
|
|
using Unity.UIWidgets.ui;
|
|
using Unity.UIWidgets.widgets;
|
|
using TextStyle = Unity.UIWidgets.painting.TextStyle;
|
|
|
|
namespace Unity.UIWidgets.material {
|
|
static class TabsUtils {
|
|
public const float _kTabHeight = 46.0f;
|
|
public const float _kTextAndIconTabHeight = 72.0f;
|
|
|
|
public static float _indexChangeProgress(TabController controller) {
|
|
float controllerValue = controller.animation.value;
|
|
float previousIndex = controller.previousIndex;
|
|
float currentIndex = controller.index;
|
|
|
|
if (!controller.indexIsChanging) {
|
|
return (currentIndex - controllerValue).abs().clamp(0.0f, 1.0f);
|
|
}
|
|
|
|
return (controllerValue - currentIndex).abs() / (currentIndex - previousIndex).abs();
|
|
}
|
|
|
|
public static readonly PageScrollPhysics _kTabBarViewPhysics =
|
|
(PageScrollPhysics) new PageScrollPhysics().applyTo(new ClampingScrollPhysics());
|
|
}
|
|
|
|
public enum TabBarIndicatorSize {
|
|
tab,
|
|
label
|
|
}
|
|
|
|
public class Tab : StatelessWidget {
|
|
public Tab(
|
|
Key key = null,
|
|
string text = null,
|
|
Widget icon = null,
|
|
Widget child = null
|
|
) : base(key: key) {
|
|
D.assert(text != null || child != null || icon != null);
|
|
D.assert(!(text != null && child != null));
|
|
this.text = text;
|
|
this.icon = icon;
|
|
this.child = child;
|
|
}
|
|
|
|
public readonly string text;
|
|
|
|
public readonly Widget child;
|
|
|
|
public readonly Widget icon;
|
|
|
|
Widget _buildLabelText() {
|
|
return child ?? new Text(text, softWrap: false, overflow: TextOverflow.fade);
|
|
}
|
|
|
|
public override Widget build(BuildContext context) {
|
|
D.assert(MaterialD.debugCheckHasMaterial(context));
|
|
|
|
float height = 0f;
|
|
Widget label = null;
|
|
|
|
if (icon == null) {
|
|
height = TabsUtils._kTabHeight;
|
|
label = _buildLabelText();
|
|
}
|
|
else if (text == null && child == null) {
|
|
height = TabsUtils._kTabHeight;
|
|
label = icon;
|
|
}
|
|
else {
|
|
height = TabsUtils._kTextAndIconTabHeight;
|
|
label = new Column(
|
|
mainAxisAlignment: MainAxisAlignment.center,
|
|
crossAxisAlignment: CrossAxisAlignment.center,
|
|
children: new List<Widget> {
|
|
new Container(
|
|
child: icon,
|
|
margin: EdgeInsets.only(bottom: 10.0f)
|
|
),
|
|
_buildLabelText()
|
|
}
|
|
);
|
|
}
|
|
|
|
return new SizedBox(
|
|
height: height,
|
|
child: new Center(
|
|
child: label,
|
|
widthFactor: 1.0f)
|
|
);
|
|
}
|
|
|
|
public override void debugFillProperties(DiagnosticPropertiesBuilder properties) {
|
|
base.debugFillProperties(properties);
|
|
properties.add(new StringProperty("text", text, defaultValue: Diagnostics.kNullDefaultValue));
|
|
properties.add(new DiagnosticsProperty<Widget>("icon", icon,
|
|
defaultValue: Diagnostics.kNullDefaultValue));
|
|
}
|
|
}
|
|
|
|
|
|
class _TabStyle : AnimatedWidget {
|
|
public _TabStyle(
|
|
Key key = null,
|
|
Animation<float> animation = null,
|
|
bool? selected = null,
|
|
Color labelColor = null,
|
|
Color unselectedLabelColor = null,
|
|
TextStyle labelStyle = null,
|
|
TextStyle unselectedLabelStyle = null,
|
|
Widget child = null
|
|
) : base(key: key, listenable: animation) {
|
|
D.assert(child != null);
|
|
D.assert(selected != null);
|
|
this.selected = selected.Value;
|
|
this.labelColor = labelColor;
|
|
this.unselectedLabelColor = unselectedLabelColor;
|
|
this.labelStyle = labelStyle;
|
|
this.unselectedLabelStyle = unselectedLabelStyle;
|
|
this.child = child;
|
|
}
|
|
|
|
public readonly TextStyle labelStyle;
|
|
|
|
public readonly TextStyle unselectedLabelStyle;
|
|
|
|
public readonly bool selected;
|
|
|
|
public readonly Color labelColor;
|
|
|
|
public readonly Color unselectedLabelColor;
|
|
|
|
public readonly Widget child;
|
|
|
|
protected internal override Widget build(BuildContext context) {
|
|
ThemeData themeData = Theme.of(context);
|
|
TabBarTheme tabBarTheme = TabBarTheme.of(context);
|
|
Animation<float> animation = (Animation<float>) listenable;
|
|
|
|
TextStyle defaultStyle = (labelStyle
|
|
?? tabBarTheme.labelStyle
|
|
?? themeData.primaryTextTheme.body2).copyWith(inherit: true);
|
|
TextStyle defaultUnselectedStyle = (unselectedLabelStyle
|
|
?? tabBarTheme.unselectedLabelStyle
|
|
?? labelStyle
|
|
?? themeData.primaryTextTheme.body2).copyWith(inherit: true);
|
|
TextStyle textStyle = selected
|
|
? TextStyle.lerp(defaultStyle, defaultUnselectedStyle, animation.value)
|
|
: TextStyle.lerp(defaultUnselectedStyle, defaultStyle, animation.value);
|
|
|
|
Color selectedColor = labelColor ?? tabBarTheme.labelColor ?? themeData.primaryTextTheme.body2.color;
|
|
Color unselectedColor = unselectedLabelColor ??
|
|
tabBarTheme.unselectedLabelColor ?? selectedColor.withAlpha(0xB2);
|
|
Color color = selected
|
|
? Color.lerp(selectedColor, unselectedColor, animation.value)
|
|
: Color.lerp(unselectedColor, selectedColor, animation.value);
|
|
|
|
return new DefaultTextStyle(
|
|
style: textStyle.copyWith(color: color),
|
|
child: IconTheme.merge(
|
|
data: new IconThemeData(
|
|
size: 24.0f,
|
|
color: color),
|
|
child: child
|
|
)
|
|
);
|
|
}
|
|
}
|
|
|
|
delegate void _LayoutCallback(List<float> xOffsets, float width);
|
|
|
|
|
|
class _TabLabelBarRenderer : RenderFlex {
|
|
public _TabLabelBarRenderer(
|
|
List<RenderBox> children = null,
|
|
Axis? direction = null,
|
|
MainAxisSize? mainAxisSize = null,
|
|
MainAxisAlignment? mainAxisAlignment = null,
|
|
CrossAxisAlignment? crossAxisAlignment = null,
|
|
VerticalDirection? verticalDirection = null,
|
|
_LayoutCallback onPerformLayout = null
|
|
) : base(
|
|
children: children,
|
|
direction: direction.Value,
|
|
mainAxisSize: mainAxisSize.Value,
|
|
mainAxisAlignment: mainAxisAlignment.Value,
|
|
crossAxisAlignment: crossAxisAlignment.Value,
|
|
verticalDirection: verticalDirection.Value
|
|
) {
|
|
D.assert(direction != null);
|
|
D.assert(mainAxisSize != null);
|
|
D.assert(mainAxisAlignment != null);
|
|
D.assert(crossAxisAlignment != null);
|
|
D.assert(verticalDirection != null);
|
|
|
|
D.assert(onPerformLayout != null);
|
|
this.onPerformLayout = onPerformLayout;
|
|
}
|
|
|
|
public _LayoutCallback onPerformLayout;
|
|
|
|
protected override void performLayout() {
|
|
base.performLayout();
|
|
|
|
RenderBox child = firstChild;
|
|
List<float> xOffsets = new List<float>();
|
|
|
|
while (child != null) {
|
|
FlexParentData childParentData = (FlexParentData) child.parentData;
|
|
xOffsets.Add(childParentData.offset.dx);
|
|
D.assert(child.parentData == childParentData);
|
|
child = childParentData.nextSibling;
|
|
}
|
|
|
|
xOffsets.Add(size.width);
|
|
onPerformLayout(xOffsets, size.width);
|
|
}
|
|
}
|
|
|
|
|
|
class _TabLabelBar : Flex {
|
|
public _TabLabelBar(
|
|
Key key = null,
|
|
List<Widget> children = null,
|
|
_LayoutCallback onPerformLayout = null
|
|
) : base(
|
|
key: key,
|
|
children: children ?? new List<Widget>(),
|
|
direction: Axis.horizontal,
|
|
mainAxisSize: MainAxisSize.max,
|
|
mainAxisAlignment: MainAxisAlignment.start,
|
|
crossAxisAlignment: CrossAxisAlignment.center,
|
|
verticalDirection: VerticalDirection.down
|
|
) {
|
|
this.onPerformLayout = onPerformLayout;
|
|
}
|
|
|
|
public readonly _LayoutCallback onPerformLayout;
|
|
|
|
public override RenderObject createRenderObject(BuildContext context) {
|
|
return new _TabLabelBarRenderer(
|
|
direction: direction,
|
|
mainAxisAlignment: mainAxisAlignment,
|
|
mainAxisSize: mainAxisSize,
|
|
crossAxisAlignment: crossAxisAlignment,
|
|
verticalDirection: verticalDirection,
|
|
onPerformLayout: onPerformLayout
|
|
);
|
|
}
|
|
|
|
public override void updateRenderObject(BuildContext context, RenderObject renderObject) {
|
|
base.updateRenderObject(context, renderObject);
|
|
_TabLabelBarRenderer _renderObject = (_TabLabelBarRenderer) renderObject;
|
|
_renderObject.onPerformLayout = onPerformLayout;
|
|
}
|
|
}
|
|
|
|
class _IndicatorPainter : AbstractCustomPainter {
|
|
public _IndicatorPainter(
|
|
TabController controller = null,
|
|
Decoration indicator = null,
|
|
TabBarIndicatorSize? indicatorSize = null,
|
|
List<GlobalKey> tabKeys = null,
|
|
_IndicatorPainter old = null
|
|
) : base(repaint: controller.animation) {
|
|
D.assert(controller != null);
|
|
D.assert(indicator != null);
|
|
this.controller = controller;
|
|
this.indicator = indicator;
|
|
this.indicatorSize = indicatorSize;
|
|
this.tabKeys = tabKeys;
|
|
if (old != null) {
|
|
saveTabOffsets(old._currentTabOffsets);
|
|
}
|
|
}
|
|
|
|
public readonly TabController controller;
|
|
|
|
public readonly Decoration indicator;
|
|
|
|
public readonly TabBarIndicatorSize? indicatorSize;
|
|
|
|
public readonly List<GlobalKey> tabKeys;
|
|
|
|
List<float> _currentTabOffsets;
|
|
Rect _currentRect;
|
|
BoxPainter _painter;
|
|
bool _needsPaint = false;
|
|
|
|
void markNeedsPaint() {
|
|
_needsPaint = true;
|
|
}
|
|
|
|
public void dispose() {
|
|
_painter?.Dispose();
|
|
}
|
|
|
|
public void saveTabOffsets(List<float> tabOffsets) {
|
|
_currentTabOffsets = tabOffsets;
|
|
}
|
|
|
|
public int maxTabIndex {
|
|
get { return _currentTabOffsets.Count - 2; }
|
|
}
|
|
|
|
public float centerOf(int tabIndex) {
|
|
D.assert(_currentTabOffsets != null);
|
|
D.assert(_currentTabOffsets.isNotEmpty());
|
|
D.assert(tabIndex >= 0);
|
|
D.assert(tabIndex <= maxTabIndex);
|
|
return (_currentTabOffsets[tabIndex] + _currentTabOffsets[tabIndex + 1]) / 2.0f;
|
|
}
|
|
|
|
public Rect indicatorRect(Size tabBarSize, int tabIndex) {
|
|
D.assert(_currentTabOffsets != null);
|
|
D.assert(_currentTabOffsets.isNotEmpty());
|
|
D.assert(tabIndex >= 0);
|
|
D.assert(tabIndex <= maxTabIndex);
|
|
float tabLeft = _currentTabOffsets[tabIndex];
|
|
float tabRight = _currentTabOffsets[tabIndex + 1];
|
|
|
|
if (indicatorSize == TabBarIndicatorSize.label) {
|
|
float tabWidth = tabKeys[tabIndex].currentContext.size.width;
|
|
float delta = ((tabRight - tabLeft) - tabWidth) / 2.0f;
|
|
tabLeft += delta;
|
|
tabRight -= delta;
|
|
}
|
|
|
|
return Rect.fromLTWH(tabLeft, 0.0f, tabRight - tabLeft, tabBarSize.height);
|
|
}
|
|
|
|
public override void paint(Canvas canvas, Size size) {
|
|
_needsPaint = false;
|
|
_painter = _painter ?? indicator.createBoxPainter(markNeedsPaint);
|
|
|
|
if (controller.indexIsChanging) {
|
|
Rect targetRect = indicatorRect(size, controller.index);
|
|
_currentRect = Rect.lerp(targetRect, _currentRect ?? targetRect,
|
|
TabsUtils._indexChangeProgress(controller));
|
|
}
|
|
else {
|
|
int currentIndex = controller.index;
|
|
Rect previous = currentIndex > 0 ? indicatorRect(size, currentIndex - 1) : null;
|
|
Rect middle = indicatorRect(size, currentIndex);
|
|
Rect next = currentIndex < maxTabIndex ? indicatorRect(size, currentIndex + 1) : null;
|
|
float index = controller.index;
|
|
float value = controller.animation.value;
|
|
if (value == index - 1.0f) {
|
|
_currentRect = previous ?? middle;
|
|
}
|
|
else if (value == index + 1.0f) {
|
|
_currentRect = next ?? middle;
|
|
}
|
|
else if (value == index) {
|
|
_currentRect = middle;
|
|
}
|
|
else if (value < index) {
|
|
_currentRect = previous == null ? middle : Rect.lerp(middle, previous, index - value);
|
|
}
|
|
else {
|
|
_currentRect = next == null ? middle : Rect.lerp(middle, next, value - index);
|
|
}
|
|
}
|
|
|
|
D.assert(_currentRect != null);
|
|
|
|
ImageConfiguration configuration = new ImageConfiguration(
|
|
size: _currentRect.size
|
|
);
|
|
|
|
_painter.paint(canvas, _currentRect.topLeft, configuration);
|
|
}
|
|
|
|
static bool _tabOffsetsEqual(List<float> a, List<float> b) {
|
|
if (a?.Count != b?.Count) {
|
|
return false;
|
|
}
|
|
|
|
for (int i = 0; i < a.Count; i++) {
|
|
if (a[i] != b[i]) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public override bool shouldRepaint(CustomPainter old) {
|
|
_IndicatorPainter _old = (_IndicatorPainter) old;
|
|
return _needsPaint
|
|
|| controller != _old.controller
|
|
|| indicator != _old.indicator
|
|
|| tabKeys.Count != _old.tabKeys.Count
|
|
|| !_tabOffsetsEqual(_currentTabOffsets, _old._currentTabOffsets);
|
|
}
|
|
}
|
|
|
|
class _ChangeAnimation : AnimationWithParentMixin<float, float> {
|
|
public _ChangeAnimation(
|
|
TabController controller) {
|
|
this.controller = controller;
|
|
}
|
|
|
|
public readonly TabController controller;
|
|
|
|
public override Animation<float> parent {
|
|
get { return controller.animation; }
|
|
}
|
|
|
|
public override float value {
|
|
get { return TabsUtils._indexChangeProgress(controller); }
|
|
}
|
|
}
|
|
|
|
|
|
class _DragAnimation : AnimationWithParentMixin<float, float> {
|
|
public _DragAnimation(
|
|
TabController controller,
|
|
int index) {
|
|
this.controller = controller;
|
|
this.index = index;
|
|
}
|
|
|
|
public readonly TabController controller;
|
|
|
|
public readonly int index;
|
|
|
|
public override Animation<float> parent {
|
|
get { return controller.animation; }
|
|
}
|
|
|
|
public override float value {
|
|
get {
|
|
D.assert(!controller.indexIsChanging);
|
|
return (controller.animation.value - index).abs().clamp(0.0f, 1.0f);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
class _TabBarScrollPosition : ScrollPositionWithSingleContext {
|
|
public _TabBarScrollPosition(
|
|
ScrollPhysics physics = null,
|
|
ScrollContext context = null,
|
|
ScrollPosition oldPosition = null,
|
|
_TabBarState tabBar = null
|
|
) : base(
|
|
physics: physics,
|
|
context: context,
|
|
initialPixels: null,
|
|
oldPosition: oldPosition) {
|
|
this.tabBar = tabBar;
|
|
}
|
|
|
|
public readonly _TabBarState tabBar;
|
|
|
|
bool _initialViewportDimensionWasZero;
|
|
|
|
public override bool applyContentDimensions(float minScrollExtent, float maxScrollExtent) {
|
|
bool result = true;
|
|
if (_initialViewportDimensionWasZero != true) {
|
|
_initialViewportDimensionWasZero = viewportDimension != 0.0;
|
|
correctPixels(tabBar._initialScrollOffset(viewportDimension, minScrollExtent,
|
|
maxScrollExtent));
|
|
result = false;
|
|
}
|
|
|
|
return base.applyContentDimensions(minScrollExtent, maxScrollExtent) && result;
|
|
}
|
|
}
|
|
|
|
|
|
class _TabBarScrollController : ScrollController {
|
|
public _TabBarScrollController(_TabBarState tabBar) {
|
|
this.tabBar = tabBar;
|
|
}
|
|
|
|
public readonly _TabBarState tabBar;
|
|
|
|
public override ScrollPosition createScrollPosition(ScrollPhysics physics, ScrollContext context,
|
|
ScrollPosition oldPosition) {
|
|
return new _TabBarScrollPosition(
|
|
physics: physics,
|
|
context: context,
|
|
oldPosition: oldPosition,
|
|
tabBar: tabBar
|
|
);
|
|
}
|
|
}
|
|
|
|
|
|
public class TabBar : PreferredSizeWidget {
|
|
public TabBar(
|
|
Key key = null,
|
|
List<Widget> tabs = null,
|
|
TabController controller = null,
|
|
bool isScrollable = false,
|
|
Color indicatorColor = null,
|
|
float indicatorWeight = 2.0f,
|
|
EdgeInsets indicatorPadding = null,
|
|
Decoration indicator = null,
|
|
TabBarIndicatorSize? indicatorSize = null,
|
|
Color labelColor = null,
|
|
TextStyle labelStyle = null,
|
|
EdgeInsets labelPadding = null,
|
|
Color unselectedLabelColor = null,
|
|
TextStyle unselectedLabelStyle = null,
|
|
DragStartBehavior dragStartBehavior = DragStartBehavior.start,
|
|
ValueChanged<int> onTap = null
|
|
) : base(key: key) {
|
|
indicatorPadding = indicatorPadding ?? EdgeInsets.zero;
|
|
D.assert(tabs != null);
|
|
D.assert(indicator != null || indicatorWeight > 0.0f);
|
|
D.assert(indicator != null || indicatorPadding != null);
|
|
this.tabs = tabs;
|
|
this.controller = controller;
|
|
this.isScrollable = isScrollable;
|
|
this.indicatorColor = indicatorColor;
|
|
this.indicatorWeight = indicatorWeight;
|
|
this.indicatorPadding = indicatorPadding;
|
|
this.indicator = indicator;
|
|
this.indicatorSize = indicatorSize;
|
|
this.labelColor = labelColor;
|
|
this.labelStyle = labelStyle;
|
|
this.labelPadding = labelPadding;
|
|
this.unselectedLabelColor = unselectedLabelColor;
|
|
this.unselectedLabelStyle = unselectedLabelStyle;
|
|
this.dragStartBehavior = dragStartBehavior;
|
|
this.onTap = onTap;
|
|
}
|
|
|
|
public readonly List<Widget> tabs;
|
|
|
|
public readonly TabController controller;
|
|
|
|
public readonly bool isScrollable;
|
|
|
|
public readonly Color indicatorColor;
|
|
|
|
public readonly float indicatorWeight;
|
|
|
|
public readonly EdgeInsets indicatorPadding;
|
|
|
|
public readonly Decoration indicator;
|
|
|
|
public readonly TabBarIndicatorSize? indicatorSize;
|
|
|
|
public readonly Color labelColor;
|
|
|
|
public readonly Color unselectedLabelColor;
|
|
|
|
public readonly TextStyle labelStyle;
|
|
|
|
public readonly EdgeInsets labelPadding;
|
|
|
|
public readonly TextStyle unselectedLabelStyle;
|
|
|
|
public readonly DragStartBehavior dragStartBehavior;
|
|
|
|
public readonly ValueChanged<int> onTap;
|
|
|
|
public override Size preferredSize {
|
|
get {
|
|
foreach (Widget item in tabs) {
|
|
if (item is Tab) {
|
|
Tab tab = (Tab) item;
|
|
if (tab.text != null && tab.icon != null) {
|
|
return Size.fromHeight(TabsUtils._kTextAndIconTabHeight + indicatorWeight);
|
|
}
|
|
}
|
|
}
|
|
|
|
return Size.fromHeight(TabsUtils._kTabHeight + indicatorWeight);
|
|
}
|
|
}
|
|
|
|
|
|
public override State createState() {
|
|
return new _TabBarState();
|
|
}
|
|
}
|
|
|
|
|
|
class _TabBarState : State<TabBar> {
|
|
ScrollController _scrollController;
|
|
TabController _controller;
|
|
_IndicatorPainter _indicatorPainter;
|
|
int _currentIndex;
|
|
List<GlobalKey> _tabKeys;
|
|
|
|
|
|
public override void initState() {
|
|
base.initState();
|
|
_tabKeys = new List<GlobalKey>();
|
|
foreach (Widget tab in widget.tabs) {
|
|
_tabKeys.Add(GlobalKey.key());
|
|
}
|
|
}
|
|
|
|
Decoration _indicator {
|
|
get {
|
|
if (widget.indicator != null) {
|
|
return widget.indicator;
|
|
}
|
|
|
|
TabBarTheme tabBarTheme = TabBarTheme.of(context);
|
|
if (tabBarTheme.indicator != null) {
|
|
return tabBarTheme.indicator;
|
|
}
|
|
|
|
Color color = widget.indicatorColor ?? Theme.of(context).indicatorColor;
|
|
if (color.value == Material.of(context).color?.value) {
|
|
color = Colors.white;
|
|
}
|
|
|
|
return new UnderlineTabIndicator(
|
|
insets: widget.indicatorPadding,
|
|
borderSide: new BorderSide(
|
|
width: widget.indicatorWeight,
|
|
color: color));
|
|
}
|
|
}
|
|
|
|
void _updateTabController() {
|
|
TabController newController = widget.controller ?? DefaultTabController.of(context);
|
|
D.assert(() => {
|
|
if (newController == null) {
|
|
throw new UIWidgetsError(
|
|
"No TabController for " + widget.GetType() + ".\n" +
|
|
"When creating a " + widget.GetType() + ", you must either provide an explicit " +
|
|
"TabController using the \"controller\" property, or you must ensure that there " +
|
|
"is a DefaultTabController above the " + widget.GetType() + ".\n" +
|
|
"In this case, there was neither an explicit controller nor a default controller."
|
|
);
|
|
}
|
|
|
|
return true;
|
|
});
|
|
D.assert(() => {
|
|
if (newController.length != widget.tabs.Count) {
|
|
throw new UIWidgetsError(
|
|
$"Controller's length property {newController.length} does not match the\n" +
|
|
$"number of tab elements {widget.tabs.Count} present in TabBar's tabs property."
|
|
);
|
|
}
|
|
|
|
return true;
|
|
});
|
|
if (newController == _controller) {
|
|
return;
|
|
}
|
|
|
|
if (_controller != null) {
|
|
_controller.animation.removeListener(_handleTabControllerAnimationTick);
|
|
_controller.removeListener(_handleTabControllerTick);
|
|
}
|
|
|
|
_controller = newController;
|
|
if (_controller != null) {
|
|
_controller.animation.addListener(_handleTabControllerAnimationTick);
|
|
_controller.addListener(_handleTabControllerTick);
|
|
_currentIndex = _controller.index;
|
|
}
|
|
}
|
|
|
|
void _initIndicatorPainter() {
|
|
_indicatorPainter = _controller == null
|
|
? null
|
|
: new _IndicatorPainter(
|
|
controller: _controller,
|
|
indicator: _indicator,
|
|
indicatorSize: widget.indicatorSize ?? TabBarTheme.of(context).indicatorSize,
|
|
tabKeys: _tabKeys,
|
|
old: _indicatorPainter
|
|
);
|
|
}
|
|
|
|
public override void didChangeDependencies() {
|
|
base.didChangeDependencies();
|
|
D.assert(MaterialD.debugCheckHasMaterial(context));
|
|
_updateTabController();
|
|
_initIndicatorPainter();
|
|
}
|
|
|
|
public override void didUpdateWidget(StatefulWidget oldWidget) {
|
|
base.didUpdateWidget(oldWidget);
|
|
TabBar _oldWidget = (TabBar) oldWidget;
|
|
if (widget.controller != _oldWidget.controller) {
|
|
_updateTabController();
|
|
_initIndicatorPainter();
|
|
}
|
|
else if (widget.indicatorColor != _oldWidget.indicatorColor ||
|
|
widget.indicatorWeight != _oldWidget.indicatorWeight ||
|
|
widget.indicatorSize != _oldWidget.indicatorSize ||
|
|
widget.indicator != _oldWidget.indicator) {
|
|
_initIndicatorPainter();
|
|
}
|
|
|
|
if (widget.tabs.Count > _oldWidget.tabs.Count) {
|
|
int delta = widget.tabs.Count - _oldWidget.tabs.Count;
|
|
for (int i = 0; i < delta; i++) {
|
|
_tabKeys.Add(GlobalKey.key());
|
|
}
|
|
}
|
|
else if (widget.tabs.Count < _oldWidget.tabs.Count) {
|
|
int delta = _oldWidget.tabs.Count - widget.tabs.Count;
|
|
_tabKeys.RemoveRange(widget.tabs.Count, delta);
|
|
}
|
|
}
|
|
|
|
public override void dispose() {
|
|
_indicatorPainter.dispose();
|
|
if (_controller != null) {
|
|
_controller.animation.removeListener(_handleTabControllerAnimationTick);
|
|
_controller.removeListener(_handleTabControllerTick);
|
|
}
|
|
|
|
base.dispose();
|
|
}
|
|
|
|
public int maxTabIndex {
|
|
get { return _indicatorPainter.maxTabIndex; }
|
|
}
|
|
|
|
float _tabScrollOffset(int index, float viewportWidth, float minExtent, float maxExtent) {
|
|
if (!widget.isScrollable) {
|
|
return 0.0f;
|
|
}
|
|
|
|
float tabCenter = _indicatorPainter.centerOf(index);
|
|
return (tabCenter - viewportWidth / 2.0f).clamp(minExtent, maxExtent);
|
|
}
|
|
|
|
float _tabCenteredScrollOffset(int index) {
|
|
ScrollPosition position = _scrollController.position;
|
|
return _tabScrollOffset(index, position.viewportDimension, position.minScrollExtent,
|
|
position.maxScrollExtent);
|
|
}
|
|
|
|
internal float _initialScrollOffset(float viewportWidth, float minExtent, float maxExtent) {
|
|
return _tabScrollOffset(_currentIndex, viewportWidth, minExtent, maxExtent);
|
|
}
|
|
|
|
void _scrollToCurrentIndex() {
|
|
float offset = _tabCenteredScrollOffset(_currentIndex);
|
|
_scrollController.animateTo(offset, duration: Constants.kTabScrollDuration, curve: Curves.ease);
|
|
}
|
|
|
|
void _scrollToControllerValue() {
|
|
float? leadingPosition = _currentIndex > 0
|
|
? (float?) _tabCenteredScrollOffset(_currentIndex - 1)
|
|
: null;
|
|
float middlePosition = _tabCenteredScrollOffset(_currentIndex);
|
|
float? trailingPosition = _currentIndex < maxTabIndex
|
|
? (float?) _tabCenteredScrollOffset(_currentIndex + 1)
|
|
: null;
|
|
|
|
float index = _controller.index;
|
|
float value = _controller.animation.value;
|
|
float offset = 0.0f;
|
|
if (value == index - 1.0f) {
|
|
offset = leadingPosition ?? middlePosition;
|
|
}
|
|
else if (value == index + 1.0f) {
|
|
offset = trailingPosition ?? middlePosition;
|
|
}
|
|
else if (value == index) {
|
|
offset = middlePosition;
|
|
}
|
|
else if (value < index) {
|
|
offset = leadingPosition == null
|
|
? middlePosition
|
|
: MathUtils.lerpNullableFloat(middlePosition, leadingPosition, index - value).Value;
|
|
}
|
|
else {
|
|
offset = trailingPosition == null
|
|
? middlePosition
|
|
: MathUtils.lerpNullableFloat(middlePosition, trailingPosition, value - index).Value;
|
|
}
|
|
|
|
_scrollController.jumpTo(offset);
|
|
}
|
|
|
|
|
|
void _handleTabControllerAnimationTick() {
|
|
D.assert(mounted);
|
|
if (!_controller.indexIsChanging && widget.isScrollable) {
|
|
_currentIndex = _controller.index;
|
|
_scrollToControllerValue();
|
|
}
|
|
}
|
|
|
|
void _handleTabControllerTick() {
|
|
if (_controller.index != _currentIndex) {
|
|
_currentIndex = _controller.index;
|
|
if (widget.isScrollable) {
|
|
_scrollToCurrentIndex();
|
|
}
|
|
}
|
|
|
|
setState(() => { });
|
|
}
|
|
|
|
void _saveTabOffsets(List<float> tabOffsets, float width) {
|
|
_indicatorPainter?.saveTabOffsets(tabOffsets);
|
|
}
|
|
|
|
void _handleTap(int index) {
|
|
D.assert(index >= 0 && index < widget.tabs.Count);
|
|
_controller.animateTo(index);
|
|
if (widget.onTap != null) {
|
|
widget.onTap(index);
|
|
}
|
|
}
|
|
|
|
Widget _buildStyledTab(Widget child, bool selected, Animation<float> animation) {
|
|
return new _TabStyle(
|
|
animation: animation,
|
|
selected: selected,
|
|
labelColor: widget.labelColor,
|
|
unselectedLabelColor: widget.unselectedLabelColor,
|
|
labelStyle: widget.labelStyle,
|
|
unselectedLabelStyle: widget.unselectedLabelStyle,
|
|
child: child
|
|
);
|
|
}
|
|
|
|
public override Widget build(BuildContext context) {
|
|
D.assert(MaterialD.debugCheckHasMaterialLocalizations(context));
|
|
|
|
if (_controller.length == 0) {
|
|
return new Container(
|
|
height: TabsUtils._kTabHeight + widget.indicatorWeight
|
|
);
|
|
}
|
|
|
|
TabBarTheme tabBarTheme = TabBarTheme.of(context);
|
|
|
|
List<Widget> wrappedTabs = new List<Widget>();
|
|
for (int i = 0; i < widget.tabs.Count; i++) {
|
|
wrappedTabs.Add(new Center(
|
|
heightFactor: 1.0f,
|
|
child: new Padding(
|
|
padding: widget.labelPadding ?? tabBarTheme.labelPadding ?? Constants.kTabLabelPadding,
|
|
child: new KeyedSubtree(
|
|
key: _tabKeys[i],
|
|
child: widget.tabs[i]
|
|
)
|
|
)
|
|
)
|
|
);
|
|
}
|
|
|
|
if (_controller != null) {
|
|
int previousIndex = _controller.previousIndex;
|
|
|
|
if (_controller.indexIsChanging) {
|
|
D.assert(_currentIndex != previousIndex);
|
|
Animation<float> animation = new _ChangeAnimation(_controller);
|
|
wrappedTabs[_currentIndex] =
|
|
_buildStyledTab(wrappedTabs[_currentIndex], true, animation);
|
|
wrappedTabs[previousIndex] = _buildStyledTab(wrappedTabs[previousIndex], false, animation);
|
|
}
|
|
else {
|
|
int tabIndex = _currentIndex;
|
|
Animation<float> centerAnimation = new _DragAnimation(_controller, tabIndex);
|
|
wrappedTabs[tabIndex] = _buildStyledTab(wrappedTabs[tabIndex], true, centerAnimation);
|
|
if (_currentIndex > 0) {
|
|
int previousTabIndex = _currentIndex - 1;
|
|
Animation<float> previousAnimation =
|
|
new ReverseAnimation(new _DragAnimation(_controller, previousTabIndex));
|
|
wrappedTabs[previousTabIndex] =
|
|
_buildStyledTab(wrappedTabs[previousTabIndex], false, previousAnimation);
|
|
}
|
|
|
|
if (_currentIndex < widget.tabs.Count - 1) {
|
|
int nextTabIndex = _currentIndex + 1;
|
|
Animation<float> nextAnimation =
|
|
new ReverseAnimation(new _DragAnimation(_controller, nextTabIndex));
|
|
wrappedTabs[nextTabIndex] =
|
|
_buildStyledTab(wrappedTabs[nextTabIndex], false, nextAnimation);
|
|
}
|
|
}
|
|
}
|
|
|
|
int tabCount = widget.tabs.Count;
|
|
for (int index = 0; index < tabCount; index++) {
|
|
int tabIndex = index;
|
|
wrappedTabs[index] = new InkWell(
|
|
onTap: () => { _handleTap(tabIndex); },
|
|
child: new Padding(
|
|
padding: EdgeInsets.only(bottom: widget.indicatorWeight),
|
|
child: wrappedTabs[index]
|
|
)
|
|
);
|
|
if (!widget.isScrollable) {
|
|
wrappedTabs[index] = new Expanded(
|
|
child: wrappedTabs[index]);
|
|
}
|
|
}
|
|
|
|
Widget tabBar = new CustomPaint(
|
|
painter: _indicatorPainter,
|
|
child: new _TabStyle(
|
|
animation: Animations.kAlwaysDismissedAnimation,
|
|
selected: false,
|
|
labelColor: widget.labelColor,
|
|
unselectedLabelColor: widget.unselectedLabelColor,
|
|
labelStyle: widget.labelStyle,
|
|
unselectedLabelStyle: widget.unselectedLabelStyle,
|
|
child: new _TabLabelBar(
|
|
onPerformLayout: _saveTabOffsets,
|
|
children: wrappedTabs
|
|
)
|
|
)
|
|
);
|
|
|
|
if (widget.isScrollable) {
|
|
_scrollController = _scrollController ?? new _TabBarScrollController(this);
|
|
tabBar = new SingleChildScrollView(
|
|
dragStartBehavior: widget.dragStartBehavior,
|
|
scrollDirection: Axis.horizontal,
|
|
controller: _scrollController,
|
|
child: tabBar);
|
|
}
|
|
|
|
return tabBar;
|
|
}
|
|
}
|
|
|
|
|
|
public class TabBarView : StatefulWidget {
|
|
public TabBarView(
|
|
Key key = null,
|
|
List<Widget> children = null,
|
|
TabController controller = null,
|
|
ScrollPhysics physics = null,
|
|
DragStartBehavior dragStartBehavior = DragStartBehavior.start
|
|
) : base(key: key) {
|
|
D.assert(children != null);
|
|
this.children = children;
|
|
this.controller = controller;
|
|
this.physics = physics;
|
|
this.dragStartBehavior = dragStartBehavior;
|
|
}
|
|
|
|
public readonly TabController controller;
|
|
|
|
public readonly List<Widget> children;
|
|
|
|
public readonly ScrollPhysics physics;
|
|
|
|
public readonly DragStartBehavior dragStartBehavior;
|
|
|
|
public override State createState() {
|
|
return new _TabBarViewState();
|
|
}
|
|
}
|
|
|
|
class _TabBarViewState : State<TabBarView> {
|
|
TabController _controller;
|
|
PageController _pageController;
|
|
List<Widget> _children;
|
|
int? _currentIndex = null;
|
|
int _warpUnderwayCount = 0;
|
|
|
|
void _updateTabController() {
|
|
TabController newController = widget.controller ?? DefaultTabController.of(context);
|
|
D.assert(() => {
|
|
if (newController == null) {
|
|
throw new UIWidgetsError(
|
|
"No TabController for " + widget.GetType() + "\n" +
|
|
"When creating a " + widget.GetType() + ", you must either provide an explicit " +
|
|
"TabController using the \"controller\" property, or you must ensure that there " +
|
|
"is a DefaultTabController above the " + widget.GetType() + ".\n" +
|
|
"In this case, there was neither an explicit controller nor a default controller."
|
|
);
|
|
}
|
|
|
|
return true;
|
|
});
|
|
D.assert(() => {
|
|
if (newController.length != widget.children.Count) {
|
|
throw new UIWidgetsError(
|
|
$"Controller's length property {newController.length} does not match the\n" +
|
|
$"number of elements {widget.children.Count} present in TabBarView's children property."
|
|
);
|
|
}
|
|
|
|
return true;
|
|
});
|
|
if (newController == _controller) {
|
|
return;
|
|
}
|
|
|
|
if (_controller != null) {
|
|
_controller.animation.removeListener(_handleTabControllerAnimationTick);
|
|
}
|
|
|
|
_controller = newController;
|
|
if (_controller != null) {
|
|
_controller.animation.addListener(_handleTabControllerAnimationTick);
|
|
}
|
|
}
|
|
|
|
|
|
public override void initState() {
|
|
base.initState();
|
|
_children = widget.children;
|
|
}
|
|
|
|
public override void didChangeDependencies() {
|
|
base.didChangeDependencies();
|
|
_updateTabController();
|
|
_currentIndex = _controller?.index;
|
|
_pageController = new PageController(initialPage: _currentIndex ?? 0);
|
|
}
|
|
|
|
public override void didUpdateWidget(StatefulWidget oldWidget) {
|
|
base.didUpdateWidget(oldWidget);
|
|
TabBarView _oldWidget = (TabBarView) oldWidget;
|
|
if (widget.controller != _oldWidget.controller) {
|
|
_updateTabController();
|
|
}
|
|
|
|
if (widget.children != _oldWidget.children && _warpUnderwayCount == 0) {
|
|
_children = widget.children;
|
|
}
|
|
}
|
|
|
|
public override void dispose() {
|
|
if (_controller != null) {
|
|
_controller.animation.removeListener(_handleTabControllerAnimationTick);
|
|
}
|
|
|
|
base.dispose();
|
|
}
|
|
|
|
void _handleTabControllerAnimationTick() {
|
|
if (_warpUnderwayCount > 0 || !_controller.indexIsChanging) {
|
|
return;
|
|
}
|
|
|
|
if (_controller.index != _currentIndex) {
|
|
_currentIndex = _controller.index;
|
|
_warpToCurrentIndex();
|
|
}
|
|
}
|
|
|
|
void _warpToCurrentIndex() {
|
|
if (!mounted) {
|
|
return;
|
|
}
|
|
|
|
if (_pageController.page == _currentIndex) {
|
|
return;
|
|
}
|
|
|
|
int previousIndex = _controller.previousIndex;
|
|
if ((_currentIndex.Value - previousIndex).abs() == 1) {
|
|
_pageController.animateToPage(_currentIndex.Value, duration: Constants.kTabScrollDuration,
|
|
curve: Curves.ease);
|
|
return;
|
|
}
|
|
|
|
D.assert((_currentIndex.Value - previousIndex).abs() > 1);
|
|
int initialPage = 0;
|
|
setState(() => {
|
|
_warpUnderwayCount += 1;
|
|
_children = new List<Widget>(widget.children);
|
|
if (_currentIndex > previousIndex) {
|
|
_children[_currentIndex.Value - 1] = _children[previousIndex];
|
|
initialPage = _currentIndex.Value - 1;
|
|
}
|
|
else {
|
|
_children[_currentIndex.Value + 1] = _children[previousIndex];
|
|
initialPage = _currentIndex.Value + 1;
|
|
}
|
|
});
|
|
|
|
_pageController.jumpToPage(initialPage);
|
|
_pageController.animateToPage(_currentIndex.Value, duration: Constants.kTabScrollDuration,
|
|
curve: Curves.ease).Then(() => {
|
|
if (!mounted) {
|
|
return new Promise();
|
|
}
|
|
|
|
setState(() => {
|
|
_warpUnderwayCount -= 1;
|
|
_children = widget.children;
|
|
});
|
|
|
|
return new Promise();
|
|
});
|
|
}
|
|
|
|
bool _handleScrollNotification(ScrollNotification notification) {
|
|
if (_warpUnderwayCount > 0) {
|
|
return false;
|
|
}
|
|
|
|
if (notification.depth != 0) {
|
|
return false;
|
|
}
|
|
|
|
_warpUnderwayCount += 1;
|
|
if (notification is ScrollUpdateNotification && !_controller.indexIsChanging) {
|
|
if ((_pageController.page - _controller.index).abs() > 1.0) {
|
|
_controller.index = _pageController.page.floor();
|
|
_currentIndex = _controller.index;
|
|
}
|
|
|
|
_controller.offset = (_pageController.page - _controller.index).clamp(-1.0f, 1.0f);
|
|
}
|
|
else if (notification is ScrollEndNotification) {
|
|
_controller.index = _pageController.page.round();
|
|
_currentIndex = _controller.index;
|
|
}
|
|
|
|
_warpUnderwayCount -= 1;
|
|
|
|
return false;
|
|
}
|
|
|
|
public override Widget build(BuildContext context) {
|
|
return new NotificationListener<ScrollNotification>(
|
|
onNotification: _handleScrollNotification,
|
|
child: new PageView(
|
|
dragStartBehavior: widget.dragStartBehavior,
|
|
controller: _pageController,
|
|
physics: widget.physics == null
|
|
? TabsUtils._kTabBarViewPhysics
|
|
: TabsUtils._kTabBarViewPhysics.applyTo(widget.physics),
|
|
children: _children
|
|
)
|
|
);
|
|
}
|
|
}
|
|
|
|
|
|
public class TabPageSelectorIndicator : StatelessWidget {
|
|
public TabPageSelectorIndicator(
|
|
Key key = null,
|
|
Color backgroundColor = null,
|
|
Color borderColor = null,
|
|
float? size = null
|
|
) : base(key: key) {
|
|
D.assert(backgroundColor != null);
|
|
D.assert(borderColor != null);
|
|
D.assert(size != null);
|
|
|
|
this.backgroundColor = backgroundColor;
|
|
this.borderColor = borderColor;
|
|
this.size = size.Value;
|
|
}
|
|
|
|
public readonly Color backgroundColor;
|
|
|
|
public readonly Color borderColor;
|
|
|
|
public readonly float size;
|
|
|
|
public override Widget build(BuildContext context) {
|
|
return new Container(
|
|
width: size,
|
|
height: size,
|
|
margin: EdgeInsets.all(4.0f),
|
|
decoration: new BoxDecoration(
|
|
color: backgroundColor,
|
|
border: Border.all(color: borderColor),
|
|
shape: BoxShape.circle
|
|
)
|
|
);
|
|
}
|
|
}
|
|
|
|
|
|
public class TabPageSelector : StatelessWidget {
|
|
public TabPageSelector(
|
|
Key key = null,
|
|
TabController controller = null,
|
|
float indicatorSize = 12.0f,
|
|
Color color = null,
|
|
Color selectedColor = null
|
|
) : base(key: key) {
|
|
D.assert(indicatorSize > 0.0f);
|
|
this.controller = controller;
|
|
this.indicatorSize = indicatorSize;
|
|
this.color = color;
|
|
this.selectedColor = selectedColor;
|
|
}
|
|
|
|
public readonly TabController controller;
|
|
|
|
public readonly float indicatorSize;
|
|
|
|
public readonly Color color;
|
|
|
|
public readonly Color selectedColor;
|
|
|
|
Widget _buildTabIndicator(
|
|
int tabIndex,
|
|
TabController tabController,
|
|
ColorTween selectedColorTween,
|
|
ColorTween previousColorTween) {
|
|
Color background = null;
|
|
if (tabController.indexIsChanging) {
|
|
float t = 1.0f - TabsUtils._indexChangeProgress(tabController);
|
|
if (tabController.index == tabIndex) {
|
|
background = selectedColorTween.lerp(t);
|
|
}
|
|
else if (tabController.previousIndex == tabIndex) {
|
|
background = previousColorTween.lerp(t);
|
|
}
|
|
else {
|
|
background = selectedColorTween.begin;
|
|
}
|
|
}
|
|
else {
|
|
float offset = tabController.offset;
|
|
if (tabController.index == tabIndex) {
|
|
background = selectedColorTween.lerp(1.0f - offset.abs());
|
|
}
|
|
else if (tabController.index == tabIndex - 1 && offset > 0.0) {
|
|
background = selectedColorTween.lerp(offset);
|
|
}
|
|
else if (tabController.index == tabIndex + 1 && offset < 0.0) {
|
|
background = selectedColorTween.lerp(-offset);
|
|
}
|
|
else {
|
|
background = selectedColorTween.begin;
|
|
}
|
|
}
|
|
|
|
return new TabPageSelectorIndicator(
|
|
backgroundColor: background,
|
|
borderColor: selectedColorTween.end,
|
|
size: indicatorSize
|
|
);
|
|
}
|
|
|
|
public override Widget build(BuildContext context) {
|
|
Color fixColor = color ?? Colors.transparent;
|
|
Color fixSelectedColor = selectedColor ?? Theme.of(context).accentColor;
|
|
ColorTween selectedColorTween = new ColorTween(begin: fixColor, end: fixSelectedColor);
|
|
ColorTween previousColorTween = new ColorTween(begin: fixSelectedColor, end: fixColor);
|
|
TabController tabController = controller ?? DefaultTabController.of(context);
|
|
D.assert(() => {
|
|
if (tabController == null) {
|
|
throw new UIWidgetsError(
|
|
"No TabController for " + GetType() + ".\n" +
|
|
"When creating a " + GetType() + ", you must either provide an explicit TabController " +
|
|
"using the \"controller\" property, or you must ensure that there is a " +
|
|
"DefaultTabController above the " + GetType() + ".\n" +
|
|
"In this case, there was neither an explicit controller nor a default controller."
|
|
);
|
|
}
|
|
|
|
return true;
|
|
});
|
|
|
|
Animation<float> animation = new CurvedAnimation(
|
|
parent: tabController.animation,
|
|
curve: Curves.fastOutSlowIn
|
|
);
|
|
|
|
return new AnimatedBuilder(
|
|
animation: animation,
|
|
builder: (BuildContext subContext, Widget child) => {
|
|
List<Widget> children = new List<Widget>();
|
|
|
|
for (int tabIndex = 0; tabIndex < tabController.length; tabIndex++) {
|
|
children.Add(_buildTabIndicator(
|
|
tabIndex,
|
|
tabController,
|
|
selectedColorTween,
|
|
previousColorTween)
|
|
);
|
|
}
|
|
|
|
return new Row(
|
|
mainAxisSize: MainAxisSize.min,
|
|
children: children
|
|
);
|
|
}
|
|
);
|
|
}
|
|
}
|
|
}
|