// 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 'dart:ui' show lerpDouble; import 'package:flutter/foundation.dart'; import 'package:flutter/gestures.dart' show DragStartBehavior; import 'package:flutter/rendering.dart'; import 'package:flutter/widgets.dart'; import 'app_bar.dart'; import 'color_scheme.dart'; import 'colors.dart'; import 'constants.dart'; import 'debug.dart'; import 'ink_well.dart'; import 'material.dart'; import 'material_localizations.dart'; import 'material_state.dart'; import 'tab_bar_theme.dart'; import 'tab_controller.dart'; import 'tab_indicator.dart'; import 'text_theme.dart'; import 'theme.dart'; const double _kTabHeight = 46.0; const double _kTextAndIconTabHeight = 72.0; /// Defines how the bounds of the selected tab indicator are computed. /// /// See also: /// /// * [TabBar], which displays a row of tabs. /// * [TabBarView], which displays a widget for the currently selected tab. /// * [TabBar.indicator], which defines the appearance of the selected tab /// indicator relative to the tab's bounds. enum TabBarIndicatorSize { /// The tab indicator's bounds are as wide as the space occupied by the tab /// in the tab bar: from the right edge of the previous tab to the left edge /// of the next tab. tab, /// The tab's bounds are only as wide as the (centered) tab widget itself. /// /// This value is used to align the tab's label, typically a [Tab] /// widget's text or icon, with the selected tab indicator. label, } /// A Material Design [TabBar] tab. /// /// If both [icon] and [text] are provided, the text is displayed below /// the icon. /// /// See also: /// /// * [TabBar], which displays a row of tabs. /// * [TabBarView], which displays a widget for the currently selected tab. /// * [TabController], which coordinates tab selection between a [TabBar] and a [TabBarView]. /// * <https://material.io/design/components/tabs.html> class Tab extends StatelessWidget implements PreferredSizeWidget { /// Creates a Material Design [TabBar] tab. /// /// At least one of [text], [icon], and [child] must be non-null. The [text] /// and [child] arguments must not be used at the same time. The /// [iconMargin] is only useful when [icon] and either one of [text] or /// [child] is non-null. const Tab({ super.key, this.text, this.icon, this.iconMargin = const EdgeInsets.only(bottom: 10.0), this.height, this.child, }) : assert(text != null || child != null || icon != null), assert(text == null || child == null); /// The text to display as the tab's label. /// /// Must not be used in combination with [child]. final String? text; /// The widget to be used as the tab's label. /// /// Usually a [Text] widget, possibly wrapped in a [Semantics] widget. /// /// Must not be used in combination with [text]. final Widget? child; /// An icon to display as the tab's label. final Widget? icon; /// The margin added around the tab's icon. /// /// Only useful when used in combination with [icon], and either one of /// [text] or [child] is non-null. final EdgeInsetsGeometry iconMargin; /// The height of the [Tab]. /// /// If null, the height will be calculated based on the content of the [Tab]. When `icon` is not /// null along with `child` or `text`, the default height is 72.0 pixels. Without an `icon`, the /// height is 46.0 pixels. final double? height; Widget _buildLabelText() { return child ?? Text(text!, softWrap: false, overflow: TextOverflow.fade); } @override Widget build(BuildContext context) { assert(debugCheckHasMaterial(context)); final double calculatedHeight; final Widget label; if (icon == null) { calculatedHeight = _kTabHeight; label = _buildLabelText(); } else if (text == null && child == null) { calculatedHeight = _kTabHeight; label = icon!; } else { calculatedHeight = _kTextAndIconTabHeight; label = Column( mainAxisAlignment: MainAxisAlignment.center, children: <Widget>[ Container( margin: iconMargin, child: icon, ), _buildLabelText(), ], ); } return SizedBox( height: height ?? calculatedHeight, child: Center( widthFactor: 1.0, child: label, ), ); } @override void debugFillProperties(DiagnosticPropertiesBuilder properties) { super.debugFillProperties(properties); properties.add(StringProperty('text', text, defaultValue: null)); properties.add(DiagnosticsProperty<Widget>('icon', icon, defaultValue: null)); } @override Size get preferredSize { if (height != null) { return Size.fromHeight(height!); } else if ((text != null || child != null) && icon != null) { return const Size.fromHeight(_kTextAndIconTabHeight); } else { return const Size.fromHeight(_kTabHeight); } } } class _TabStyle extends AnimatedWidget { const _TabStyle({ required Animation<double> animation, required this.isSelected, required this.isPrimary, required this.labelColor, required this.unselectedLabelColor, required this.labelStyle, required this.unselectedLabelStyle, required this.defaults, required this.child, }) : super(listenable: animation); final TextStyle? labelStyle; final TextStyle? unselectedLabelStyle; final bool isSelected; final bool isPrimary; final Color? labelColor; final Color? unselectedLabelColor; final TabBarTheme defaults; final Widget child; MaterialStateColor _resolveWithLabelColor(BuildContext context) { final ThemeData themeData = Theme.of(context); final TabBarTheme tabBarTheme = TabBarTheme.of(context); final Animation<double> animation = listenable as Animation<double>; // labelStyle.color (and tabBarTheme.labelStyle.color) is not considered // as it'll be a breaking change without a possible migration plan. for // details: https://github.com/flutter/flutter/pull/109541#issuecomment-1294241417 Color selectedColor = labelColor ?? tabBarTheme.labelColor ?? defaults.labelColor!; final Color unselectedColor; if (selectedColor is MaterialStateColor) { unselectedColor = selectedColor.resolve(const <MaterialState>{}); selectedColor = selectedColor.resolve(const <MaterialState>{MaterialState.selected}); } else { // unselectedLabelColor and tabBarTheme.unselectedLabelColor are ignored // when labelColor is a MaterialStateColor. unselectedColor = unselectedLabelColor ?? tabBarTheme.unselectedLabelColor ?? (themeData.useMaterial3 ? defaults.unselectedLabelColor! : selectedColor.withAlpha(0xB2)); // 70% alpha } return MaterialStateColor.resolveWith((Set<MaterialState> states) { if (states.contains(MaterialState.selected)) { return Color.lerp(selectedColor, unselectedColor, animation.value)!; } return Color.lerp(unselectedColor, selectedColor, animation.value)!; }); } @override Widget build(BuildContext context) { final TabBarTheme tabBarTheme = TabBarTheme.of(context); final Animation<double> animation = listenable as Animation<double>; final Set<MaterialState> states = isSelected ? const <MaterialState>{MaterialState.selected} : const <MaterialState>{}; // To enable TextStyle.lerp(style1, style2, value), both styles must have // the same value of inherit. Force that to be inherit=true here. final TextStyle defaultStyle = (labelStyle ?? tabBarTheme.labelStyle ?? defaults.labelStyle! ).copyWith(inherit: true); final TextStyle defaultUnselectedStyle = (unselectedLabelStyle ?? tabBarTheme.unselectedLabelStyle ?? labelStyle ?? defaults.unselectedLabelStyle! ).copyWith(inherit: true); final TextStyle textStyle = isSelected ? TextStyle.lerp(defaultStyle, defaultUnselectedStyle, animation.value)! : TextStyle.lerp(defaultUnselectedStyle, defaultStyle, animation.value)!; final Color color = _resolveWithLabelColor(context).resolve(states); return DefaultTextStyle( style: textStyle.copyWith(color: color), child: IconTheme.merge( data: IconThemeData( size: 24.0, color: color, ), child: child, ), ); } } typedef _LayoutCallback = void Function(List<double> xOffsets, TextDirection textDirection, double width); class _TabLabelBarRenderer extends RenderFlex { _TabLabelBarRenderer({ required super.direction, required super.mainAxisSize, required super.mainAxisAlignment, required super.crossAxisAlignment, required TextDirection super.textDirection, required super.verticalDirection, required this.onPerformLayout, }); _LayoutCallback onPerformLayout; @override void performLayout() { super.performLayout(); // xOffsets will contain childCount+1 values, giving the offsets of the // leading edge of the first tab as the first value, of the leading edge of // the each subsequent tab as each subsequent value, and of the trailing // edge of the last tab as the last value. RenderBox? child = firstChild; final List<double> xOffsets = <double>[]; while (child != null) { final FlexParentData childParentData = child.parentData! as FlexParentData; xOffsets.add(childParentData.offset.dx); assert(child.parentData == childParentData); child = childParentData.nextSibling; } assert(textDirection != null); switch (textDirection!) { case TextDirection.rtl: xOffsets.insert(0, size.width); case TextDirection.ltr: xOffsets.add(size.width); } onPerformLayout(xOffsets, textDirection!, size.width); } } // This class and its renderer class only exist to report the widths of the tabs // upon layout. The tab widths are only used at paint time (see _IndicatorPainter) // or in response to input. class _TabLabelBar extends Flex { const _TabLabelBar({ super.children, required this.onPerformLayout, }) : super( direction: Axis.horizontal, mainAxisSize: MainAxisSize.max, mainAxisAlignment: MainAxisAlignment.start, crossAxisAlignment: CrossAxisAlignment.center, verticalDirection: VerticalDirection.down, ); final _LayoutCallback onPerformLayout; @override RenderFlex createRenderObject(BuildContext context) { return _TabLabelBarRenderer( direction: direction, mainAxisAlignment: mainAxisAlignment, mainAxisSize: mainAxisSize, crossAxisAlignment: crossAxisAlignment, textDirection: getEffectiveTextDirection(context)!, verticalDirection: verticalDirection, onPerformLayout: onPerformLayout, ); } @override void updateRenderObject(BuildContext context, _TabLabelBarRenderer renderObject) { super.updateRenderObject(context, renderObject); renderObject.onPerformLayout = onPerformLayout; } } double _indexChangeProgress(TabController controller) { final double controllerValue = controller.animation!.value; final double previousIndex = controller.previousIndex.toDouble(); final double currentIndex = controller.index.toDouble(); // The controller's offset is changing because the user is dragging the // TabBarView's PageView to the left or right. if (!controller.indexIsChanging) { return clampDouble((currentIndex - controllerValue).abs(), 0.0, 1.0); } // The TabController animation's value is changing from previousIndex to currentIndex. return (controllerValue - currentIndex).abs() / (currentIndex - previousIndex).abs(); } class _IndicatorPainter extends CustomPainter { _IndicatorPainter({ required this.controller, required this.indicator, required this.indicatorSize, required this.tabKeys, required _IndicatorPainter? old, required this.indicatorPadding, required this.labelPaddings, this.dividerColor, }) : super(repaint: controller.animation) { if (old != null) { saveTabOffsets(old._currentTabOffsets, old._currentTextDirection); } } final TabController controller; final Decoration indicator; final TabBarIndicatorSize? indicatorSize; final EdgeInsetsGeometry indicatorPadding; final List<GlobalKey> tabKeys; final Color? dividerColor; final List<EdgeInsetsGeometry> labelPaddings; // _currentTabOffsets and _currentTextDirection are set each time TabBar // layout is completed. These values can be null when TabBar contains no // tabs, since there are nothing to lay out. List<double>? _currentTabOffsets; TextDirection? _currentTextDirection; Rect? _currentRect; BoxPainter? _painter; bool _needsPaint = false; void markNeedsPaint() { _needsPaint = true; } void dispose() { _painter?.dispose(); } void saveTabOffsets(List<double>? tabOffsets, TextDirection? textDirection) { _currentTabOffsets = tabOffsets; _currentTextDirection = textDirection; } // _currentTabOffsets[index] is the offset of the start edge of the tab at index, and // _currentTabOffsets[_currentTabOffsets.length] is the end edge of the last tab. int get maxTabIndex => _currentTabOffsets!.length - 2; double centerOf(int tabIndex) { assert(_currentTabOffsets != null); assert(_currentTabOffsets!.isNotEmpty); assert(tabIndex >= 0); assert(tabIndex <= maxTabIndex); return (_currentTabOffsets![tabIndex] + _currentTabOffsets![tabIndex + 1]) / 2.0; } Rect indicatorRect(Size tabBarSize, int tabIndex) { assert(_currentTabOffsets != null); assert(_currentTextDirection != null); assert(_currentTabOffsets!.isNotEmpty); assert(tabIndex >= 0); assert(tabIndex <= maxTabIndex); double tabLeft, tabRight; switch (_currentTextDirection!) { case TextDirection.rtl: tabLeft = _currentTabOffsets![tabIndex + 1]; tabRight = _currentTabOffsets![tabIndex]; case TextDirection.ltr: tabLeft = _currentTabOffsets![tabIndex]; tabRight = _currentTabOffsets![tabIndex + 1]; } if (indicatorSize == TabBarIndicatorSize.label) { final double tabWidth = tabKeys[tabIndex].currentContext!.size!.width; final EdgeInsetsGeometry labelPadding = labelPaddings[tabIndex]; final EdgeInsets insets = labelPadding.resolve(_currentTextDirection); final double delta = ((tabRight - tabLeft) - (tabWidth + insets.horizontal)) / 2.0; tabLeft += delta + insets.left; tabRight = tabLeft + tabWidth; } final EdgeInsets insets = indicatorPadding.resolve(_currentTextDirection); final Rect rect = Rect.fromLTWH(tabLeft, 0.0, tabRight - tabLeft, tabBarSize.height); if (!(rect.size >= insets.collapsedSize)) { throw FlutterError( 'indicatorPadding insets should be less than Tab Size\n' 'Rect Size : ${rect.size}, Insets: $insets', ); } return insets.deflateRect(rect); } @override void paint(Canvas canvas, Size size) { _needsPaint = false; _painter ??= indicator.createBoxPainter(markNeedsPaint); final double index = controller.index.toDouble(); final double value = controller.animation!.value; final bool ltr = index > value; final int from = (ltr ? value.floor() : value.ceil()).clamp(0, maxTabIndex); // ignore_clamp_double_lint final int to = (ltr ? from + 1 : from - 1).clamp(0, maxTabIndex); // ignore_clamp_double_lint final Rect fromRect = indicatorRect(size, from); final Rect toRect = indicatorRect(size, to); _currentRect = Rect.lerp(fromRect, toRect, (value - from).abs()); assert(_currentRect != null); final ImageConfiguration configuration = ImageConfiguration( size: _currentRect!.size, textDirection: _currentTextDirection, ); if (dividerColor != null) { final Paint dividerPaint = Paint()..color = dividerColor!..strokeWidth = 1; canvas.drawLine(Offset(0, size.height), Offset(size.width, size.height), dividerPaint); } _painter!.paint(canvas, _currentRect!.topLeft, configuration); } @override bool shouldRepaint(_IndicatorPainter old) { return _needsPaint || controller != old.controller || indicator != old.indicator || tabKeys.length != old.tabKeys.length || (!listEquals(_currentTabOffsets, old._currentTabOffsets)) || _currentTextDirection != old._currentTextDirection; } } class _ChangeAnimation extends Animation<double> with AnimationWithParentMixin<double> { _ChangeAnimation(this.controller); final TabController controller; @override Animation<double> get parent => controller.animation!; @override void removeStatusListener(AnimationStatusListener listener) { if (controller.animation != null) { super.removeStatusListener(listener); } } @override void removeListener(VoidCallback listener) { if (controller.animation != null) { super.removeListener(listener); } } @override double get value => _indexChangeProgress(controller); } class _DragAnimation extends Animation<double> with AnimationWithParentMixin<double> { _DragAnimation(this.controller, this.index); final TabController controller; final int index; @override Animation<double> get parent => controller.animation!; @override void removeStatusListener(AnimationStatusListener listener) { if (controller.animation != null) { super.removeStatusListener(listener); } } @override void removeListener(VoidCallback listener) { if (controller.animation != null) { super.removeListener(listener); } } @override double get value { assert(!controller.indexIsChanging); final double controllerMaxValue = (controller.length - 1).toDouble(); final double controllerValue = clampDouble(controller.animation!.value, 0.0, controllerMaxValue); return clampDouble((controllerValue - index.toDouble()).abs(), 0.0, 1.0); } } // This class, and TabBarScrollController, only exist to handle the case // where a scrollable TabBar has a non-zero initialIndex. In that case we can // only compute the scroll position's initial scroll offset (the "correct" // pixels value) after the TabBar viewport width and scroll limits are known. class _TabBarScrollPosition extends ScrollPositionWithSingleContext { _TabBarScrollPosition({ required super.physics, required super.context, required super.oldPosition, required this.tabBar, }) : super( initialPixels: null, ); final _TabBarState tabBar; bool _viewportDimensionWasNonZero = false; // The scroll position should be adjusted at least once. bool _needsPixelsCorrection = true; @override bool applyContentDimensions(double minScrollExtent, double maxScrollExtent) { bool result = true; if (!_viewportDimensionWasNonZero) { _viewportDimensionWasNonZero = viewportDimension != 0.0; } // If the viewport never had a non-zero dimension, we just want to jump // to the initial scroll position to avoid strange scrolling effects in // release mode: the viewport temporarily may have a dimension of zero // before the actual dimension is calculated. In that scenario, setting // the actual dimension would cause a strange scroll effect without this // guard because the super call below would start a ballistic scroll activity. if (!_viewportDimensionWasNonZero || _needsPixelsCorrection) { _needsPixelsCorrection = false; correctPixels(tabBar._initialScrollOffset(viewportDimension, minScrollExtent, maxScrollExtent)); result = false; } return super.applyContentDimensions(minScrollExtent, maxScrollExtent) && result; } void markNeedsPixelsCorrection() { _needsPixelsCorrection = true; } } // This class, and TabBarScrollPosition, only exist to handle the case // where a scrollable TabBar has a non-zero initialIndex. class _TabBarScrollController extends ScrollController { _TabBarScrollController(this.tabBar); final _TabBarState tabBar; @override ScrollPosition createScrollPosition(ScrollPhysics physics, ScrollContext context, ScrollPosition? oldPosition) { return _TabBarScrollPosition( physics: physics, context: context, oldPosition: oldPosition, tabBar: tabBar, ); } } /// A Material Design primary tab bar. /// /// Primary tabs are placed at the top of the content pane under a top app bar. /// They display the main content destinations. /// /// Typically created as the [AppBar.bottom] part of an [AppBar] and in /// conjunction with a [TabBarView]. /// /// {@youtube 560 315 https://www.youtube.com/watch?v=POtoEH-5l40} /// /// If a [TabController] is not provided, then a [DefaultTabController] ancestor /// must be provided instead. The tab controller's [TabController.length] must /// equal the length of the [tabs] list and the length of the /// [TabBarView.children] list. /// /// Requires one of its ancestors to be a [Material] widget. /// /// Uses values from [TabBarTheme] if it is set in the current context. /// /// {@tool dartpad} /// This sample shows the implementation of [TabBar] and [TabBarView] using a [DefaultTabController]. /// Each [Tab] corresponds to a child of the [TabBarView] in the order they are written. /// /// ** See code in examples/api/lib/material/tabs/tab_bar.0.dart ** /// {@end-tool} /// /// {@tool dartpad} /// [TabBar] can also be implemented by using a [TabController] which provides more options /// to control the behavior of the [TabBar] and [TabBarView]. This can be used instead of /// a [DefaultTabController], demonstrated below. /// /// ** See code in examples/api/lib/material/tabs/tab_bar.1.dart ** /// {@end-tool} /// /// {@tool dartpad} /// This sample showcases nested Material 3 [TabBar]s. It consists of a primary /// [TabBar] with nested a secondary [TabBar]. The primary [TabBar] uses a /// [DefaultTabController] while the secondary [TabBar] uses a [TabController]. /// /// ** See code in examples/api/lib/material/tabs/tab_bar.2.dart ** /// {@end-tool} /// /// See also: /// /// * [TabBar.secondary], for a secondary tab bar. /// * [TabBarView], which displays page views that correspond to each tab. /// * [TabController], which coordinates tab selection between a [TabBar] and a [TabBarView]. /// * https://m3.material.io/components/tab-bar/overview, the Material 3 /// tab bar specification. class TabBar extends StatefulWidget implements PreferredSizeWidget { /// Creates a Material Design primary tab bar. /// /// The [tabs] argument must not be null and its length must match the [controller]'s /// [TabController.length]. /// /// If a [TabController] is not provided, then there must be a /// [DefaultTabController] ancestor. /// /// The [indicatorWeight] parameter defaults to 2, and must not be null. /// /// The [indicatorPadding] parameter defaults to [EdgeInsets.zero], and must not be null. /// /// If [indicator] is not null or provided from [TabBarTheme], /// then [indicatorWeight] and [indicatorColor] are ignored. const TabBar({ super.key, required this.tabs, this.controller, this.isScrollable = false, this.padding, this.indicatorColor, this.automaticIndicatorColorAdjustment = true, this.indicatorWeight = 2.0, this.indicatorPadding = EdgeInsets.zero, this.indicator, this.indicatorSize, this.dividerColor, this.labelColor, this.labelStyle, this.labelPadding, this.unselectedLabelColor, this.unselectedLabelStyle, this.dragStartBehavior = DragStartBehavior.start, this.overlayColor, this.mouseCursor, this.enableFeedback, this.onTap, this.physics, this.splashFactory, this.splashBorderRadius, }) : _isPrimary = true, assert(indicator != null || (indicatorWeight > 0.0)); /// Creates a Material Design secondary tab bar. /// /// Secondary tabs are used within a content area to further separate related /// content and establish hierarchy. /// /// {@tool dartpad} /// This sample showcases nested Material 3 [TabBar]s. It consists of a primary /// [TabBar] with nested a secondary [TabBar]. The primary [TabBar] uses a /// [DefaultTabController] while the secondary [TabBar] uses a [TabController]. /// /// ** See code in examples/api/lib/material/tabs/tab_bar.2.dart ** /// {@end-tool} /// /// See also: /// /// * [TabBar], for a primary tab bar. /// * [TabBarView], which displays page views that correspond to each tab. /// * [TabController], which coordinates tab selection between a [TabBar] and a [TabBarView]. /// * https://m3.material.io/components/tab-bar/overview, the Material 3 /// tab bar specification. const TabBar.secondary({ super.key, required this.tabs, this.controller, this.isScrollable = false, this.padding, this.indicatorColor, this.automaticIndicatorColorAdjustment = true, this.indicatorWeight = 2.0, this.indicatorPadding = EdgeInsets.zero, this.indicator, this.indicatorSize, this.dividerColor, this.labelColor, this.labelStyle, this.labelPadding, this.unselectedLabelColor, this.unselectedLabelStyle, this.dragStartBehavior = DragStartBehavior.start, this.overlayColor, this.mouseCursor, this.enableFeedback, this.onTap, this.physics, this.splashFactory, this.splashBorderRadius, }) : _isPrimary = false, assert(indicator != null || (indicatorWeight > 0.0)); /// Typically a list of two or more [Tab] widgets. /// /// The length of this list must match the [controller]'s [TabController.length] /// and the length of the [TabBarView.children] list. final List<Widget> tabs; /// This widget's selection and animation state. /// /// If [TabController] is not provided, then the value of [DefaultTabController.of] /// will be used. final TabController? controller; /// Whether this tab bar can be scrolled horizontally. /// /// If [isScrollable] is true, then each tab is as wide as needed for its label /// and the entire [TabBar] is scrollable. Otherwise each tab gets an equal /// share of the available space. final bool isScrollable; /// The amount of space by which to inset the tab bar. /// /// When [isScrollable] is false, this will yield the same result as if [TabBar] was wrapped /// in a [Padding] widget. When [isScrollable] is true, the scrollable itself is inset, /// allowing the padding to scroll with the tab bar, rather than enclosing it. final EdgeInsetsGeometry? padding; /// The color of the line that appears below the selected tab. /// /// If this parameter is null, then the value of the Theme's indicatorColor /// property is used. /// /// If [indicator] is specified or provided from [TabBarTheme], /// this property is ignored. final Color? indicatorColor; /// The thickness of the line that appears below the selected tab. /// /// The value of this parameter must be greater than zero and its default /// value is 2.0. /// /// If [indicator] is specified or provided from [TabBarTheme], /// this property is ignored. final double indicatorWeight; /// The padding for the indicator. /// /// The default value of this property is [EdgeInsets.zero]. /// /// For [isScrollable] tab bars, specifying [kTabLabelPadding] will align /// the indicator with the tab's text for [Tab] widgets and all but the /// shortest [Tab.text] values. final EdgeInsetsGeometry indicatorPadding; /// Defines the appearance of the selected tab indicator. /// /// If [indicator] is specified or provided from [TabBarTheme], /// the [indicatorColor] and [indicatorWeight] properties are ignored. /// /// The default, underline-style, selected tab indicator can be defined with /// [UnderlineTabIndicator]. /// /// The indicator's size is based on the tab's bounds. If [indicatorSize] /// is [TabBarIndicatorSize.tab] the tab's bounds are as wide as the space /// occupied by the tab in the tab bar. If [indicatorSize] is /// [TabBarIndicatorSize.label], then the tab's bounds are only as wide as /// the tab widget itself. /// /// See also: /// /// * [splashBorderRadius], which defines the clipping radius of the splash /// and is generally used with [BoxDecoration.borderRadius]. final Decoration? indicator; /// Whether this tab bar should automatically adjust the [indicatorColor]. /// /// The default value of this property is true. /// /// If [automaticIndicatorColorAdjustment] is true, /// then the [indicatorColor] will be automatically adjusted to [Colors.white] /// when the [indicatorColor] is same as [Material.color] of the [Material] /// parent widget. final bool automaticIndicatorColorAdjustment; /// Defines how the selected tab indicator's size is computed. /// /// The size of the selected tab indicator is defined relative to the /// tab's overall bounds if [indicatorSize] is [TabBarIndicatorSize.tab] /// (the default) or relative to the bounds of the tab's widget if /// [indicatorSize] is [TabBarIndicatorSize.label]. /// /// The selected tab's location appearance can be refined further with /// the [indicatorColor], [indicatorWeight], [indicatorPadding], and /// [indicator] properties. final TabBarIndicatorSize? indicatorSize; /// The color of the divider. /// /// If null and [ThemeData.useMaterial3] is true, [TabBarTheme.dividerColor] /// color is used. If that is null and [ThemeData.useMaterial3] is true, /// [ColorScheme.surfaceVariant] will be used, otherwise divider will not be drawn. final Color? dividerColor; /// The color of selected tab labels. /// /// If null, then [TabBarTheme.labelColor] is used. If that is also null and /// [ThemeData.useMaterial3] is true, [ColorScheme.primary] will be used, /// otherwise the color of the [ThemeData.primaryTextTheme]'s /// [TextTheme.bodyLarge] text color is used. /// /// If [labelColor] (or, if null, [TabBarTheme.labelColor]) is a /// [MaterialStateColor], then the effective tab color will depend on the /// [MaterialState.selected] state, i.e. if the [Tab] is selected or not, /// ignoring [unselectedLabelColor] even if it's non-null. /// /// The color specified in the [labelStyle] and the [TabBarTheme.labelStyle] /// do not affect the effective [labelColor]. /// /// See also: /// /// * [unselectedLabelColor], for color of unselected tab labels. final Color? labelColor; /// The color of unselected tab labels. /// /// If [labelColor] (or, if null, [TabBarTheme.labelColor]) is a /// [MaterialStateColor], then the unselected tabs are rendered with /// that [MaterialStateColor]'s resolved color for unselected state, even if /// [unselectedLabelColor] is non-null. /// /// If null, then [TabBarTheme.unselectedLabelColor] is used. If that is also /// null and [ThemeData.useMaterial3] is true, [ColorScheme.onSurfaceVariant] /// will be used, otherwise unselected tab labels are rendered with /// [labelColor] at 70% opacity. /// /// The color specified in the [unselectedLabelStyle] and the /// [TabBarTheme.unselectedLabelStyle] are ignored in [unselectedLabelColor]'s /// precedence calculation. /// /// See also: /// /// * [labelColor], for color of selected tab labels. final Color? unselectedLabelColor; /// The text style of the selected tab labels. /// /// This does not influence color of the tab labels even if [TextStyle.color] /// is non-null. Refer [labelColor] to color selected tab labels instead. /// /// If [unselectedLabelStyle] is null, then this text style will be used for /// both selected and unselected label styles. /// /// If this property is null and [ThemeData.useMaterial3] is true, [TextTheme.titleSmall] /// will be used, otherwise the text style of the [ThemeData.primaryTextTheme]'s /// [TextTheme.bodyLarge] definition is used. final TextStyle? labelStyle; /// The text style of the unselected tab labels. /// /// This does not influence color of the tab labels even if [TextStyle.color] /// is non-null. Refer [unselectedLabelColor] to color unselected tab labels /// instead. /// /// If this property is null and [ThemeData.useMaterial3] is true, /// [TextTheme.titleSmall] will be used, otherwise then the [labelStyle] value /// is used. If [labelStyle] is null, the text style of the /// [ThemeData.primaryTextTheme]'s [TextTheme.bodyLarge] definition is used. final TextStyle? unselectedLabelStyle; /// The padding added to each of the tab labels. /// /// If there are few tabs with both icon and text and few /// tabs with only icon or text, this padding is vertically /// adjusted to provide uniform padding to all tabs. /// /// If this property is null, then kTabLabelPadding is used. final EdgeInsetsGeometry? labelPadding; /// Defines the ink response focus, hover, and splash colors. /// /// If non-null, it is resolved against one of [MaterialState.focused], /// [MaterialState.hovered], and [MaterialState.pressed]. /// /// [MaterialState.pressed] triggers a ripple (an ink splash), per /// the current Material Design spec. /// /// If the overlay color is null or resolves to null, then the default values /// for [InkResponse.focusColor], [InkResponse.hoverColor], [InkResponse.splashColor], /// and [InkResponse.highlightColor] will be used instead. final MaterialStateProperty<Color?>? overlayColor; /// {@macro flutter.widgets.scrollable.dragStartBehavior} final DragStartBehavior dragStartBehavior; /// {@template flutter.material.tabs.mouseCursor} /// The cursor for a mouse pointer when it enters or is hovering over the /// individual tab widgets. /// /// If [mouseCursor] is a [MaterialStateProperty<MouseCursor>], /// [MaterialStateProperty.resolve] is used for the following [MaterialState]s: /// /// * [MaterialState.selected]. /// {@endtemplate} /// /// If null, then the value of [TabBarTheme.mouseCursor] is used. If /// that is also null, then [MaterialStateMouseCursor.clickable] is used. /// /// See also: /// /// * [MaterialStateMouseCursor], which can be used to create a [MouseCursor] /// that is also a [MaterialStateProperty<MouseCursor>]. final MouseCursor? mouseCursor; /// Whether detected gestures should provide acoustic and/or haptic feedback. /// /// For example, on Android a tap will produce a clicking sound and a long-press /// will produce a short vibration, when feedback is enabled. /// /// Defaults to true. final bool? enableFeedback; /// An optional callback that's called when the [TabBar] is tapped. /// /// The callback is applied to the index of the tab where the tap occurred. /// /// This callback has no effect on the default handling of taps. It's for /// applications that want to do a little extra work when a tab is tapped, /// even if the tap doesn't change the TabController's index. TabBar [onTap] /// callbacks should not make changes to the TabController since that would /// interfere with the default tap handler. final ValueChanged<int>? onTap; /// How the [TabBar]'s scroll view should respond to user input. /// /// For example, determines how the scroll view continues to animate after the /// user stops dragging the scroll view. /// /// Defaults to matching platform conventions. final ScrollPhysics? physics; /// Creates the tab bar's [InkWell] splash factory, which defines /// the appearance of "ink" splashes that occur in response to taps. /// /// Use [NoSplash.splashFactory] to defeat ink splash rendering. For example /// to defeat both the splash and the hover/pressed overlay, but not the /// keyboard focused overlay: /// /// ```dart /// TabBar( /// splashFactory: NoSplash.splashFactory, /// overlayColor: MaterialStateProperty.resolveWith<Color?>( /// (Set<MaterialState> states) { /// return states.contains(MaterialState.focused) ? null : Colors.transparent; /// }, /// ), /// tabs: const <Widget>[ /// // ... /// ], /// ) /// ``` final InteractiveInkFeatureFactory? splashFactory; /// Defines the clipping radius of splashes that extend outside the bounds of the tab. /// /// This can be useful to match the [BoxDecoration.borderRadius] provided as [indicator]. /// /// ```dart /// TabBar( /// indicator: BoxDecoration( /// borderRadius: BorderRadius.circular(40), /// ), /// splashBorderRadius: BorderRadius.circular(40), /// tabs: const <Widget>[ /// // ... /// ], /// ) /// ``` /// /// If this property is null, it is interpreted as [BorderRadius.zero]. final BorderRadius? splashBorderRadius; /// A size whose height depends on if the tabs have both icons and text. /// /// [AppBar] uses this size to compute its own preferred size. @override Size get preferredSize { double maxHeight = _kTabHeight; for (final Widget item in tabs) { if (item is PreferredSizeWidget) { final double itemHeight = item.preferredSize.height; maxHeight = math.max(itemHeight, maxHeight); } } return Size.fromHeight(maxHeight + indicatorWeight); } /// Returns whether the [TabBar] contains a tab with both text and icon. /// /// [TabBar] uses this to give uniform padding to all tabs in cases where /// there are some tabs with both text and icon and some which contain only /// text or icon. bool get tabHasTextAndIcon { for (final Widget item in tabs) { if (item is PreferredSizeWidget) { if (item.preferredSize.height == _kTextAndIconTabHeight) { return true; } } } return false; } /// Whether this tab bar is a primary tab bar. /// /// Otherwise, it is a secondary tab bar. final bool _isPrimary; @override State<TabBar> createState() => _TabBarState(); } class _TabBarState extends State<TabBar> { ScrollController? _scrollController; TabController? _controller; _IndicatorPainter? _indicatorPainter; int? _currentIndex; late double _tabStripWidth; late List<GlobalKey> _tabKeys; late List<EdgeInsetsGeometry> _labelPaddings; bool _debugHasScheduledValidTabsCountCheck = false; @override void initState() { super.initState(); // If indicatorSize is TabIndicatorSize.label, _tabKeys[i] is used to find // the width of tab widget i. See _IndicatorPainter.indicatorRect(). _tabKeys = widget.tabs.map((Widget tab) => GlobalKey()).toList(); _labelPaddings = List<EdgeInsetsGeometry>.filled(widget.tabs.length, EdgeInsets.zero, growable: true); } TabBarTheme get _defaults { if (Theme.of(context).useMaterial3) { return widget._isPrimary ? _TabsPrimaryDefaultsM3(context) : _TabsSecondaryDefaultsM3(context); } else { return _TabsDefaultsM2(context); } } Decoration _getIndicator() { final ThemeData theme = Theme.of(context); final TabBarTheme tabBarTheme = TabBarTheme.of(context); if (widget.indicator != null) { return widget.indicator!; } if (tabBarTheme.indicator != null) { return tabBarTheme.indicator!; } Color color = widget.indicatorColor ?? (theme.useMaterial3 ? tabBarTheme.indicatorColor ?? _defaults.indicatorColor! : Theme.of(context).indicatorColor); // ThemeData tries to avoid this by having indicatorColor avoid being the // primaryColor. However, it's possible that the tab bar is on a // Material that isn't the primaryColor. In that case, if the indicator // color ends up matching the material's color, then this overrides it. // When that happens, automatic transitions of the theme will likely look // ugly as the indicator color suddenly snaps to white at one end, but it's // not clear how to avoid that any further. // // The material's color might be null (if it's a transparency). In that case // there's no good way for us to find out what the color is so we don't. // // TODO(xu-baolin): Remove automatic adjustment to white color indicator // with a better long-term solution. // https://github.com/flutter/flutter/pull/68171#pullrequestreview-517753917 if (widget.automaticIndicatorColorAdjustment && color.value == Material.maybeOf(context)?.color?.value) { color = Colors.white; } return UnderlineTabIndicator( borderRadius: theme.useMaterial3 && widget._isPrimary // TODO(tahatesser): Make sure this value matches Material 3 Tabs spec // when `preferredSize`and `indicatorWeight` are updated to support Material 3 // https://m3.material.io/components/tabs/specs#149a189f-9039-4195-99da-15c205d20e30, // https://github.com/flutter/flutter/issues/116136 ? const BorderRadius.only( topLeft: Radius.circular(3.0), topRight: Radius.circular(3.0), ) : null, borderSide: BorderSide( width: widget.indicatorWeight, color: color, ), ); } // If the TabBar is rebuilt with a new tab controller, the caller should // dispose the old one. In that case the old controller's animation will be // null and should not be accessed. bool get _controllerIsValid => _controller?.animation != null; void _updateTabController() { final TabController? newController = widget.controller ?? DefaultTabController.maybeOf(context); assert(() { if (newController == null) { throw FlutterError( 'No TabController for ${widget.runtimeType}.\n' 'When creating a ${widget.runtimeType}, you must either provide an explicit ' 'TabController using the "controller" property, or you must ensure that there ' 'is a DefaultTabController above the ${widget.runtimeType}.\n' 'In this case, there was neither an explicit controller nor a default controller.', ); } return true; }()); if (newController == _controller) { return; } if (_controllerIsValid) { _controller!.animation!.removeListener(_handleTabControllerAnimationTick); _controller!.removeListener(_handleTabControllerTick); } _controller = newController; if (_controller != null) { _controller!.animation!.addListener(_handleTabControllerAnimationTick); _controller!.addListener(_handleTabControllerTick); _currentIndex = _controller!.index; } } void _initIndicatorPainter() { final ThemeData theme = Theme.of(context); final TabBarTheme tabBarTheme = TabBarTheme.of(context); _indicatorPainter = !_controllerIsValid ? null : _IndicatorPainter( controller: _controller!, indicator: _getIndicator(), indicatorSize: widget.indicatorSize ?? tabBarTheme.indicatorSize ?? _defaults.indicatorSize!, indicatorPadding: widget.indicatorPadding, tabKeys: _tabKeys, old: _indicatorPainter, dividerColor: theme.useMaterial3 ? widget.dividerColor ?? tabBarTheme.dividerColor ?? _defaults.dividerColor : null, labelPaddings: _labelPaddings, ); } @override void didChangeDependencies() { super.didChangeDependencies(); assert(debugCheckHasMaterial(context)); _updateTabController(); _initIndicatorPainter(); } @override void didUpdateWidget(TabBar oldWidget) { super.didUpdateWidget(oldWidget); if (widget.controller != oldWidget.controller) { _updateTabController(); _initIndicatorPainter(); // Adjust scroll position. if (_scrollController != null && _scrollController!.hasClients) { final ScrollPosition position = _scrollController!.position; if (position is _TabBarScrollPosition) { position.markNeedsPixelsCorrection(); } } } else if (widget.indicatorColor != oldWidget.indicatorColor || widget.indicatorWeight != oldWidget.indicatorWeight || widget.indicatorSize != oldWidget.indicatorSize || widget.indicatorPadding != oldWidget.indicatorPadding || widget.indicator != oldWidget.indicator) { _initIndicatorPainter(); } if (widget.tabs.length > _tabKeys.length) { final int delta = widget.tabs.length - _tabKeys.length; _tabKeys.addAll(List<GlobalKey>.generate(delta, (int n) => GlobalKey())); _labelPaddings.addAll(List<EdgeInsetsGeometry>.filled(delta, EdgeInsets.zero)); } else if (widget.tabs.length < _tabKeys.length) { _tabKeys.removeRange(widget.tabs.length, _tabKeys.length); _labelPaddings.removeRange(widget.tabs.length, _tabKeys.length); } } @override void dispose() { _indicatorPainter!.dispose(); if (_controllerIsValid) { _controller!.animation!.removeListener(_handleTabControllerAnimationTick); _controller!.removeListener(_handleTabControllerTick); } _controller = null; // We don't own the _controller Animation, so it's not disposed here. super.dispose(); } int get maxTabIndex => _indicatorPainter!.maxTabIndex; double _tabScrollOffset(int index, double viewportWidth, double minExtent, double maxExtent) { if (!widget.isScrollable) { return 0.0; } double tabCenter = _indicatorPainter!.centerOf(index); double paddingStart; switch (Directionality.of(context)) { case TextDirection.rtl: paddingStart = widget.padding?.resolve(TextDirection.rtl).right ?? 0; tabCenter = _tabStripWidth - tabCenter; case TextDirection.ltr: paddingStart = widget.padding?.resolve(TextDirection.ltr).left ?? 0; } return clampDouble(tabCenter + paddingStart - viewportWidth / 2.0, minExtent, maxExtent); } double _tabCenteredScrollOffset(int index) { final ScrollPosition position = _scrollController!.position; return _tabScrollOffset(index, position.viewportDimension, position.minScrollExtent, position.maxScrollExtent); } double _initialScrollOffset(double viewportWidth, double minExtent, double maxExtent) { return _tabScrollOffset(_currentIndex!, viewportWidth, minExtent, maxExtent); } void _scrollToCurrentIndex() { final double offset = _tabCenteredScrollOffset(_currentIndex!); _scrollController!.animateTo(offset, duration: kTabScrollDuration, curve: Curves.ease); } void _scrollToControllerValue() { final double? leadingPosition = _currentIndex! > 0 ? _tabCenteredScrollOffset(_currentIndex! - 1) : null; final double middlePosition = _tabCenteredScrollOffset(_currentIndex!); final double? trailingPosition = _currentIndex! < maxTabIndex ? _tabCenteredScrollOffset(_currentIndex! + 1) : null; final double index = _controller!.index.toDouble(); final double value = _controller!.animation!.value; final double offset; if (value == index - 1.0) { offset = leadingPosition ?? middlePosition; } else if (value == index + 1.0) { offset = trailingPosition ?? middlePosition; } else if (value == index) { offset = middlePosition; } else if (value < index) { offset = leadingPosition == null ? middlePosition : lerpDouble(middlePosition, leadingPosition, index - value)!; } else { offset = trailingPosition == null ? middlePosition : lerpDouble(middlePosition, trailingPosition, value - index)!; } _scrollController!.jumpTo(offset); } void _handleTabControllerAnimationTick() { assert(mounted); if (!_controller!.indexIsChanging && widget.isScrollable) { // Sync the TabBar's scroll position with the TabBarView's PageView. _currentIndex = _controller!.index; _scrollToControllerValue(); } } void _handleTabControllerTick() { if (_controller!.index != _currentIndex) { _currentIndex = _controller!.index; if (widget.isScrollable) { _scrollToCurrentIndex(); } } setState(() { // Rebuild the tabs after a (potentially animated) index change // has completed. }); } // Called each time layout completes. void _saveTabOffsets(List<double> tabOffsets, TextDirection textDirection, double width) { _tabStripWidth = width; _indicatorPainter?.saveTabOffsets(tabOffsets, textDirection); } void _handleTap(int index) { assert(index >= 0 && index < widget.tabs.length); _controller!.animateTo(index); widget.onTap?.call(index); } Widget _buildStyledTab(Widget child, bool isSelected, Animation<double> animation, TabBarTheme defaults) { return _TabStyle( animation: animation, isSelected: isSelected, isPrimary: widget._isPrimary, labelColor: widget.labelColor, unselectedLabelColor: widget.unselectedLabelColor, labelStyle: widget.labelStyle, unselectedLabelStyle: widget.unselectedLabelStyle, defaults: defaults, child: child, ); } bool _debugScheduleCheckHasValidTabsCount() { if (_debugHasScheduledValidTabsCountCheck) { return true; } WidgetsBinding.instance.addPostFrameCallback((Duration duration) { _debugHasScheduledValidTabsCountCheck = false; if (!mounted) { return; } assert(() { if (_controller!.length != widget.tabs.length) { throw FlutterError( "Controller's length property (${_controller!.length}) does not match the " "number of tabs (${widget.tabs.length}) present in TabBar's tabs property.", ); } return true; }()); }); _debugHasScheduledValidTabsCountCheck = true; return true; } @override Widget build(BuildContext context) { assert(debugCheckHasMaterialLocalizations(context)); assert(_debugScheduleCheckHasValidTabsCount()); final MaterialLocalizations localizations = MaterialLocalizations.of(context); if (_controller!.length == 0) { return Container( height: _kTabHeight + widget.indicatorWeight, ); } final TabBarTheme tabBarTheme = TabBarTheme.of(context); final List<Widget> wrappedTabs = List<Widget>.generate(widget.tabs.length, (int index) { const double verticalAdjustment = (_kTextAndIconTabHeight - _kTabHeight)/2.0; EdgeInsetsGeometry? adjustedPadding; if (widget.tabs[index] is PreferredSizeWidget) { final PreferredSizeWidget tab = widget.tabs[index] as PreferredSizeWidget; if (widget.tabHasTextAndIcon && tab.preferredSize.height == _kTabHeight) { if (widget.labelPadding != null || tabBarTheme.labelPadding != null) { adjustedPadding = (widget.labelPadding ?? tabBarTheme.labelPadding!).add(const EdgeInsets.symmetric(vertical: verticalAdjustment)); } else { adjustedPadding = const EdgeInsets.symmetric(vertical: verticalAdjustment, horizontal: 16.0); } } } _labelPaddings[index] = adjustedPadding ?? widget.labelPadding ?? tabBarTheme.labelPadding ?? kTabLabelPadding; return Center( heightFactor: 1.0, child: Padding( padding: _labelPaddings[index], child: KeyedSubtree( key: _tabKeys[index], child: widget.tabs[index], ), ), ); }); // If the controller was provided by DefaultTabController and we're part // of a Hero (typically the AppBar), then we will not be able to find the // controller during a Hero transition. See https://github.com/flutter/flutter/issues/213. if (_controller != null) { final int previousIndex = _controller!.previousIndex; if (_controller!.indexIsChanging) { // The user tapped on a tab, the tab controller's animation is running. assert(_currentIndex != previousIndex); final Animation<double> animation = _ChangeAnimation(_controller!); wrappedTabs[_currentIndex!] = _buildStyledTab(wrappedTabs[_currentIndex!], true, animation, _defaults); wrappedTabs[previousIndex] = _buildStyledTab(wrappedTabs[previousIndex], false, animation, _defaults); } else { // The user is dragging the TabBarView's PageView left or right. final int tabIndex = _currentIndex!; final Animation<double> centerAnimation = _DragAnimation(_controller!, tabIndex); wrappedTabs[tabIndex] = _buildStyledTab(wrappedTabs[tabIndex], true, centerAnimation, _defaults); if (_currentIndex! > 0) { final int tabIndex = _currentIndex! - 1; final Animation<double> previousAnimation = ReverseAnimation(_DragAnimation(_controller!, tabIndex)); wrappedTabs[tabIndex] = _buildStyledTab(wrappedTabs[tabIndex], false, previousAnimation, _defaults); } if (_currentIndex! < widget.tabs.length - 1) { final int tabIndex = _currentIndex! + 1; final Animation<double> nextAnimation = ReverseAnimation(_DragAnimation(_controller!, tabIndex)); wrappedTabs[tabIndex] = _buildStyledTab(wrappedTabs[tabIndex], false, nextAnimation, _defaults); } } } // Add the tap handler to each tab. If the tab bar is not scrollable, // then give all of the tabs equal flexibility so that they each occupy // the same share of the tab bar's overall width. final int tabCount = widget.tabs.length; for (int index = 0; index < tabCount; index += 1) { final Set<MaterialState> selectedState = <MaterialState>{ if (index == _currentIndex) MaterialState.selected, }; final MouseCursor effectiveMouseCursor = MaterialStateProperty.resolveAs<MouseCursor?>(widget.mouseCursor, selectedState) ?? tabBarTheme.mouseCursor?.resolve(selectedState) ?? MaterialStateMouseCursor.clickable.resolve(selectedState); final MaterialStateProperty<Color?> defaultOverlay = MaterialStateProperty.resolveWith<Color?>( (Set<MaterialState> states) { final Set<MaterialState> effectiveStates = selectedState..addAll(states); return _defaults.overlayColor?.resolve(effectiveStates); }, ); wrappedTabs[index] = InkWell( mouseCursor: effectiveMouseCursor, onTap: () { _handleTap(index); }, enableFeedback: widget.enableFeedback ?? true, overlayColor: widget.overlayColor ?? tabBarTheme.overlayColor ?? defaultOverlay, splashFactory: widget.splashFactory ?? tabBarTheme.splashFactory ?? _defaults.splashFactory, borderRadius: widget.splashBorderRadius, child: Padding( padding: EdgeInsets.only(bottom: widget.indicatorWeight), child: Stack( children: <Widget>[ wrappedTabs[index], Semantics( selected: index == _currentIndex, label: localizations.tabLabel(tabIndex: index + 1, tabCount: tabCount), ), ], ), ), ); if (!widget.isScrollable) { wrappedTabs[index] = Expanded(child: wrappedTabs[index]); } } Widget tabBar = CustomPaint( painter: _indicatorPainter, child: _TabStyle( animation: kAlwaysDismissedAnimation, isSelected: false, isPrimary: widget._isPrimary, labelColor: widget.labelColor, unselectedLabelColor: widget.unselectedLabelColor, labelStyle: widget.labelStyle, unselectedLabelStyle: widget.unselectedLabelStyle, defaults: _defaults, child: _TabLabelBar( onPerformLayout: _saveTabOffsets, children: wrappedTabs, ), ), ); if (widget.isScrollable) { _scrollController ??= _TabBarScrollController(this); tabBar = ScrollConfiguration( // The scrolling tabs should not show an overscroll indicator. behavior: ScrollConfiguration.of(context).copyWith(overscroll: false), child: SingleChildScrollView( dragStartBehavior: widget.dragStartBehavior, scrollDirection: Axis.horizontal, controller: _scrollController, padding: widget.padding, physics: widget.physics, child: tabBar, ), ); } else if (widget.padding != null) { tabBar = Padding( padding: widget.padding!, child: tabBar, ); } return tabBar; } } /// A page view that displays the widget which corresponds to the currently /// selected tab. /// /// This widget is typically used in conjunction with a [TabBar]. /// /// {@youtube 560 315 https://www.youtube.com/watch?v=POtoEH-5l40} /// /// If a [TabController] is not provided, then there must be a [DefaultTabController] /// ancestor. /// /// The tab controller's [TabController.length] must equal the length of the /// [children] list and the length of the [TabBar.tabs] list. /// /// To see a sample implementation, visit the [TabController] documentation. class TabBarView extends StatefulWidget { /// Creates a page view with one child per tab. /// /// The length of [children] must be the same as the [controller]'s length. const TabBarView({ super.key, required this.children, this.controller, this.physics, this.dragStartBehavior = DragStartBehavior.start, this.viewportFraction = 1.0, this.clipBehavior = Clip.hardEdge, }); /// This widget's selection and animation state. /// /// If [TabController] is not provided, then the value of [DefaultTabController.of] /// will be used. final TabController? controller; /// One widget per tab. /// /// Its length must match the length of the [TabBar.tabs] /// list, as well as the [controller]'s [TabController.length]. final List<Widget> children; /// How the page view should respond to user input. /// /// For example, determines how the page view continues to animate after the /// user stops dragging the page view. /// /// The physics are modified to snap to page boundaries using /// [PageScrollPhysics] prior to being used. /// /// Defaults to matching platform conventions. final ScrollPhysics? physics; /// {@macro flutter.widgets.scrollable.dragStartBehavior} final DragStartBehavior dragStartBehavior; /// {@macro flutter.widgets.pageview.viewportFraction} final double viewportFraction; /// {@macro flutter.material.Material.clipBehavior} /// /// Defaults to [Clip.hardEdge]. final Clip clipBehavior; @override State<TabBarView> createState() => _TabBarViewState(); } class _TabBarViewState extends State<TabBarView> { TabController? _controller; late PageController _pageController; late List<Widget> _childrenWithKey; int? _currentIndex; int _warpUnderwayCount = 0; int _scrollUnderwayCount = 0; bool _debugHasScheduledValidChildrenCountCheck = false; // If the TabBarView is rebuilt with a new tab controller, the caller should // dispose the old one. In that case the old controller's animation will be // null and should not be accessed. bool get _controllerIsValid => _controller?.animation != null; void _updateTabController() { final TabController? newController = widget.controller ?? DefaultTabController.maybeOf(context); assert(() { if (newController == null) { throw FlutterError( 'No TabController for ${widget.runtimeType}.\n' 'When creating a ${widget.runtimeType}, you must either provide an explicit ' 'TabController using the "controller" property, or you must ensure that there ' 'is a DefaultTabController above the ${widget.runtimeType}.\n' 'In this case, there was neither an explicit controller nor a default controller.', ); } return true; }()); if (newController == _controller) { return; } if (_controllerIsValid) { _controller!.animation!.removeListener(_handleTabControllerAnimationTick); } _controller = newController; if (_controller != null) { _controller!.animation!.addListener(_handleTabControllerAnimationTick); } } void _jumpToPage(int page) { _warpUnderwayCount += 1; _pageController.jumpToPage(page); _warpUnderwayCount -= 1; } Future<void> _animateToPage( int page, { required Duration duration, required Curve curve, }) async { _warpUnderwayCount += 1; await _pageController.animateToPage(page, duration: duration, curve: curve); _warpUnderwayCount -= 1; } @override void initState() { super.initState(); _updateChildren(); } @override void didChangeDependencies() { super.didChangeDependencies(); _updateTabController(); _currentIndex = _controller!.index; _pageController = PageController( initialPage: _currentIndex!, viewportFraction: widget.viewportFraction, ); } @override void didUpdateWidget(TabBarView oldWidget) { super.didUpdateWidget(oldWidget); if (widget.controller != oldWidget.controller) { _updateTabController(); _currentIndex = _controller!.index; _jumpToPage(_currentIndex!); } // While a warp is under way, we stop updating the tab page contents. // This is tracked in https://github.com/flutter/flutter/issues/31269. if (widget.children != oldWidget.children && _warpUnderwayCount == 0) { _updateChildren(); } } @override void dispose() { if (_controllerIsValid) { _controller!.animation!.removeListener(_handleTabControllerAnimationTick); } _controller = null; // We don't own the _controller Animation, so it's not disposed here. super.dispose(); } void _updateChildren() { _childrenWithKey = KeyedSubtree.ensureUniqueKeysForList(widget.children); } void _handleTabControllerAnimationTick() { if (_scrollUnderwayCount > 0 || !_controller!.indexIsChanging) { return; } // This widget is driving the controller's animation. if (_controller!.index != _currentIndex) { _currentIndex = _controller!.index; _warpToCurrentIndex(); } } void _warpToCurrentIndex() { if (!mounted || _pageController.page == _currentIndex!.toDouble()) { return; } final bool adjacentDestination = (_currentIndex! - _controller!.previousIndex).abs() == 1; if (adjacentDestination) { _warpToAdjacentTab(_controller!.animationDuration); } else { _warpToNonAdjacentTab(_controller!.animationDuration); } } Future<void> _warpToAdjacentTab(Duration duration) async { if (duration == Duration.zero) { _jumpToPage(_currentIndex!); } else { await _animateToPage(_currentIndex!, duration: duration, curve: Curves.ease); } if (mounted) { setState(() { _updateChildren(); }); } return Future<void>.value(); } Future<void> _warpToNonAdjacentTab(Duration duration) async { final int previousIndex = _controller!.previousIndex; assert((_currentIndex! - previousIndex).abs() > 1); // initialPage defines which page is shown when starting the animation. // This page is adjacent to the destination page. final int initialPage = _currentIndex! > previousIndex ? _currentIndex! - 1 : _currentIndex! + 1; setState(() { // Needed for `RenderSliverMultiBoxAdaptor.move` and kept alive children. // For motivation, see https://github.com/flutter/flutter/pull/29188 and // https://github.com/flutter/flutter/issues/27010#issuecomment-486475152. _childrenWithKey = List<Widget>.of(_childrenWithKey, growable: false); final Widget temp = _childrenWithKey[initialPage]; _childrenWithKey[initialPage] = _childrenWithKey[previousIndex]; _childrenWithKey[previousIndex] = temp; }); // Make a first jump to the adjacent page. _jumpToPage(initialPage); // Jump or animate to the destination page. if (duration == Duration.zero) { _jumpToPage(_currentIndex!); } else { await _animateToPage(_currentIndex!, duration: duration, curve: Curves.ease); } if (mounted) { setState(() { _updateChildren(); }); } } void _syncControllerOffset() { _controller!.offset = clampDouble(_pageController.page! - _controller!.index, -1.0, 1.0); } // Called when the PageView scrolls bool _handleScrollNotification(ScrollNotification notification) { if (_warpUnderwayCount > 0 || _scrollUnderwayCount > 0) { return false; } if (notification.depth != 0) { return false; } _scrollUnderwayCount += 1; if (notification is ScrollUpdateNotification && !_controller!.indexIsChanging) { final bool pageChanged = (_pageController.page! - _controller!.index).abs() > 1.0; if (pageChanged) { _controller!.index = _pageController.page!.round(); _currentIndex =_controller!.index; } _syncControllerOffset(); } else if (notification is ScrollEndNotification) { _controller!.index = _pageController.page!.round(); _currentIndex = _controller!.index; if (!_controller!.indexIsChanging) { _syncControllerOffset(); } } _scrollUnderwayCount -= 1; return false; } bool _debugScheduleCheckHasValidChildrenCount() { if (_debugHasScheduledValidChildrenCountCheck) { return true; } WidgetsBinding.instance.addPostFrameCallback((Duration duration) { _debugHasScheduledValidChildrenCountCheck = false; if (!mounted) { return; } assert(() { if (_controller!.length != widget.children.length) { throw FlutterError( "Controller's length property (${_controller!.length}) does not match the " "number of children (${widget.children.length}) present in TabBarView's children property.", ); } return true; }()); }); _debugHasScheduledValidChildrenCountCheck = true; return true; } @override Widget build(BuildContext context) { assert(_debugScheduleCheckHasValidChildrenCount()); return NotificationListener<ScrollNotification>( onNotification: _handleScrollNotification, child: PageView( dragStartBehavior: widget.dragStartBehavior, clipBehavior: widget.clipBehavior, controller: _pageController, physics: widget.physics == null ? const PageScrollPhysics().applyTo(const ClampingScrollPhysics()) : const PageScrollPhysics().applyTo(widget.physics), children: _childrenWithKey, ), ); } } /// Displays a single circle with the specified size, border style, border color /// and background colors. /// /// Used by [TabPageSelector] to indicate the selected page. class TabPageSelectorIndicator extends StatelessWidget { /// Creates an indicator used by [TabPageSelector]. /// /// The [backgroundColor], [borderColor], and [size] parameters must not be null. const TabPageSelectorIndicator({ super.key, required this.backgroundColor, required this.borderColor, required this.size, this.borderStyle = BorderStyle.solid, }); /// The indicator circle's background color. final Color backgroundColor; /// The indicator circle's border color. final Color borderColor; /// The indicator circle's diameter. final double size; /// The indicator circle's border style. /// /// Defaults to [BorderStyle.solid] if value is not specified. final BorderStyle borderStyle; @override Widget build(BuildContext context) { return Container( width: size, height: size, margin: const EdgeInsets.all(4.0), decoration: BoxDecoration( color: backgroundColor, border: Border.all(color: borderColor, style: borderStyle), shape: BoxShape.circle, ), ); } } /// Uses [TabPageSelectorIndicator] to display a row of small circular /// indicators, one per tab. /// /// {@youtube 560 315 https://www.youtube.com/watch?v=Q628ue9Cq7U} /// /// The selected tab's indicator is highlighted. Often used in conjunction with /// a [TabBarView]. /// /// If a [TabController] is not provided, then there must be a /// [DefaultTabController] ancestor. class TabPageSelector extends StatelessWidget { /// Creates a compact widget that indicates which tab has been selected. const TabPageSelector({ super.key, this.controller, this.indicatorSize = 12.0, this.color, this.selectedColor, this.borderStyle, }) : assert(indicatorSize > 0.0); /// This widget's selection and animation state. /// /// If [TabController] is not provided, then the value of /// [DefaultTabController.of] will be used. final TabController? controller; /// The indicator circle's diameter (the default value is 12.0). final double indicatorSize; /// The indicator circle's fill color for unselected pages. /// /// If this parameter is null, then the indicator is filled with [Colors.transparent]. final Color? color; /// The indicator circle's fill color for selected pages and border color /// for all indicator circles. /// /// If this parameter is null, then the indicator is filled with the theme's /// [ColorScheme.secondary]. final Color? selectedColor; /// The indicator circle's border style. /// /// Defaults to [BorderStyle.solid] if value is not specified. final BorderStyle? borderStyle; Widget _buildTabIndicator( int tabIndex, TabController tabController, ColorTween selectedColorTween, ColorTween previousColorTween, ) { final Color background; if (tabController.indexIsChanging) { // The selection's animation is animating from previousValue to value. final double t = 1.0 - _indexChangeProgress(tabController); if (tabController.index == tabIndex) { background = selectedColorTween.lerp(t)!; } else if (tabController.previousIndex == tabIndex) { background = previousColorTween.lerp(t)!; } else { background = selectedColorTween.begin!; } } else { // The selection's offset reflects how far the TabBarView has / been dragged // to the previous page (-1.0 to 0.0) or the next page (0.0 to 1.0). final double offset = tabController.offset; if (tabController.index == tabIndex) { background = selectedColorTween.lerp(1.0 - 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 TabPageSelectorIndicator( backgroundColor: background, borderColor: selectedColorTween.end!, size: indicatorSize, borderStyle: borderStyle ?? BorderStyle.solid, ); } @override Widget build(BuildContext context) { final Color fixColor = color ?? Colors.transparent; final Color fixSelectedColor = selectedColor ?? Theme.of(context).colorScheme.secondary; final ColorTween selectedColorTween = ColorTween(begin: fixColor, end: fixSelectedColor); final ColorTween previousColorTween = ColorTween(begin: fixSelectedColor, end: fixColor); final TabController? tabController = controller ?? DefaultTabController.maybeOf(context); final MaterialLocalizations localizations = MaterialLocalizations.of(context); assert(() { if (tabController == null) { throw FlutterError( 'No TabController for $runtimeType.\n' 'When creating a $runtimeType, you must either provide an explicit TabController ' 'using the "controller" property, or you must ensure that there is a ' 'DefaultTabController above the $runtimeType.\n' 'In this case, there was neither an explicit controller nor a default controller.', ); } return true; }()); final Animation<double> animation = CurvedAnimation( parent: tabController!.animation!, curve: Curves.fastOutSlowIn, ); return AnimatedBuilder( animation: animation, builder: (BuildContext context, Widget? child) { return Semantics( label: localizations.tabLabel(tabIndex: tabController.index + 1, tabCount: tabController.length), child: Row( mainAxisSize: MainAxisSize.min, children: List<Widget>.generate(tabController.length, (int tabIndex) { return _buildTabIndicator(tabIndex, tabController, selectedColorTween, previousColorTween); }).toList(), ), ); }, ); } } // Hand coded defaults based on Material Design 2. class _TabsDefaultsM2 extends TabBarTheme { const _TabsDefaultsM2(this.context) : super(indicatorSize: TabBarIndicatorSize.tab); final BuildContext context; @override Color? get indicatorColor => Theme.of(context).indicatorColor; @override Color? get labelColor => Theme.of(context).primaryTextTheme.bodyLarge!.color!; @override TextStyle? get labelStyle => Theme.of(context).primaryTextTheme.bodyLarge; @override TextStyle? get unselectedLabelStyle => Theme.of(context).primaryTextTheme.bodyLarge; @override InteractiveInkFeatureFactory? get splashFactory => Theme.of(context).splashFactory; } // BEGIN GENERATED TOKEN PROPERTIES - Tabs // Do not edit by hand. The code between the "BEGIN GENERATED" and // "END GENERATED" comments are generated from data in the Material // Design token database by the script: // dev/tools/gen_defaults/bin/gen_defaults.dart. // Token database version: v0_162 class _TabsPrimaryDefaultsM3 extends TabBarTheme { _TabsPrimaryDefaultsM3(this.context) : super(indicatorSize: TabBarIndicatorSize.label); final BuildContext context; late final ColorScheme _colors = Theme.of(context).colorScheme; late final TextTheme _textTheme = Theme.of(context).textTheme; @override Color? get dividerColor => _colors.surfaceVariant; @override Color? get indicatorColor => _colors.primary; @override Color? get labelColor => _colors.primary; @override TextStyle? get labelStyle => _textTheme.titleSmall; @override Color? get unselectedLabelColor => _colors.onSurfaceVariant; @override TextStyle? get unselectedLabelStyle => _textTheme.titleSmall; @override MaterialStateProperty<Color?> get overlayColor { return MaterialStateProperty.resolveWith((Set<MaterialState> states) { if (states.contains(MaterialState.selected)) { if (states.contains(MaterialState.hovered)) { return _colors.primary.withOpacity(0.08); } if (states.contains(MaterialState.focused)) { return _colors.primary.withOpacity(0.12); } if (states.contains(MaterialState.pressed)) { return _colors.primary.withOpacity(0.12); } return null; } if (states.contains(MaterialState.hovered)) { return _colors.onSurface.withOpacity(0.08); } if (states.contains(MaterialState.focused)) { return _colors.onSurface.withOpacity(0.12); } if (states.contains(MaterialState.pressed)) { return _colors.primary.withOpacity(0.12); } return null; }); } @override InteractiveInkFeatureFactory? get splashFactory => Theme.of(context).splashFactory; } class _TabsSecondaryDefaultsM3 extends TabBarTheme { _TabsSecondaryDefaultsM3(this.context) : super(indicatorSize: TabBarIndicatorSize.tab); final BuildContext context; late final ColorScheme _colors = Theme.of(context).colorScheme; late final TextTheme _textTheme = Theme.of(context).textTheme; @override Color? get dividerColor => _colors.surfaceVariant; @override Color? get indicatorColor => _colors.primary; @override Color? get labelColor => _colors.onSurface; @override TextStyle? get labelStyle => _textTheme.titleSmall; @override Color? get unselectedLabelColor => _colors.onSurfaceVariant; @override TextStyle? get unselectedLabelStyle => _textTheme.titleSmall; @override MaterialStateProperty<Color?> get overlayColor { return MaterialStateProperty.resolveWith((Set<MaterialState> states) { if (states.contains(MaterialState.selected)) { if (states.contains(MaterialState.hovered)) { return _colors.onSurface.withOpacity(0.08); } if (states.contains(MaterialState.focused)) { return _colors.onSurface.withOpacity(0.12); } if (states.contains(MaterialState.pressed)) { return _colors.onSurface.withOpacity(0.12); } return null; } if (states.contains(MaterialState.hovered)) { return _colors.onSurface.withOpacity(0.08); } if (states.contains(MaterialState.focused)) { return _colors.onSurface.withOpacity(0.12); } if (states.contains(MaterialState.pressed)) { return _colors.onSurface.withOpacity(0.12); } return null; }); } @override InteractiveInkFeatureFactory? get splashFactory => Theme.of(context).splashFactory; } // END GENERATED TOKEN PROPERTIES - Tabs