FlexColorScheme.light constructor
FlexColorScheme.light({
- FlexSchemeColor? colors,
- FlexScheme? scheme,
- ColorScheme? colorScheme,
- int usedColors = 6,
- FlexSurfaceMode? surfaceMode,
- int blendLevel = 0,
- FlexFixedColorStyle? fixedColorStyle,
- FlexAppBarStyle? appBarStyle,
- double? appBarOpacity,
- bool transparentStatusBar = true,
- double? appBarElevation,
- double? bottomAppBarElevation,
- FlexTabBarStyle? tabBarStyle,
- Color? primary,
- Color? onPrimary,
- Color? primaryContainer,
- Color? onPrimaryContainer,
- Color? secondary,
- Color? onSecondary,
- Color? secondaryContainer,
- Color? onSecondaryContainer,
- Color? tertiary,
- Color? onTertiary,
- Color? tertiaryContainer,
- Color? onTertiaryContainer,
- Color? error,
- Color? onError,
- Color? errorContainer,
- Color? onErrorContainer,
- Color? surface,
- Color? onSurface,
- Color? scaffoldBackground,
- Color? dialogBackground,
- Color? appBarBackground,
- Color? surfaceTint,
- bool lightIsWhite = false,
- bool swapColors = false,
- bool tooltipsMatchBackground = false,
- FlexSubThemesData? subThemesData,
- FlexKeyColors? keyColors,
- bool useMaterial3ErrorColors = false,
- FlexTones? tones,
- FlexSchemeVariant? variant,
- VisualDensity? visualDensity,
- TextTheme? textTheme,
- TextTheme? primaryTextTheme,
- String? fontFamily,
- List<
String> ? fontFamilyFallback, - String? package,
- MaterialTapTargetSize? materialTapTargetSize,
- PageTransitionsTheme? pageTransitionsTheme,
- InteractiveInkFeatureFactory? splashFactory,
- TargetPlatform? platform,
- Typography? typography,
- bool applyElevationOverlayColor = true,
- NoDefaultCupertinoThemeData? cupertinoOverrideTheme,
- bool useMaterial3 = true,
- bool swapLegacyOnMaterial3 = false,
- Iterable<
ThemeExtension> ? extensions, - @Deprecated('Use surface instead. It is deprecated ' 'because Flutter 3.22 deprecated this ColorScheme color. ' 'It no longer has any function in FCS v8 and will be removed in v9.') Color? background,
- @Deprecated('Use onSurface instead. It is deprecated ' 'because Flutter 3.22 deprecated this ColorScheme color. ' 'It no longer has any function in FCS v8 and will be removed in v9.') Color? onBackground,
Creates a FlexColorScheme for light theme mode.
The factory has no required FlexSchemeColor properties, but typically
a FlexScheme enum scheme value would be provided to use a pre-defined
color scheme.
As a second alternative the FlexSchemeColor class colors property
can be used to define custom scheme colors, that can be created with just
one color property by using the factory FlexSchemeColor.from.
As a third option you can provide a complete ColorScheme in
colorScheme and the custom colors for the theme will be based on that
scheme. Since this is the light theme factory the brightness value in used
colorScheme is ignored and resulting effective theme and color scheme
will always be light. Make sure you use colors in your color scheme that
are actually colors for a light theme.
The factory can produce blended surface colors, and also has other
parameters that may impact the effective color scheme used by final theme,
even when a colorScheme are provided. The FlexColorScheme.toScheme
will give you the effective color scheme that will also be used
when producing ThemeData from FlexColorScheme and its factories
with FlexColorScheme.toTheme.
The factory contains a large number of other properties that can be used to create beautiful themes by just adjusting a few behavior properties.
To activate using opinionated sub themes that further refines the produced
theme, pass in a default FlexSubThemesData to subThemesData, or use
short cut properties to setup additional features in the sub-themes.
Material 3 guide introduces a new color system with key colors and tonal palettes, see https://m3.material.io/styles/color/the-color-system/key-colors-tones.
You can opt-in on using this new M3 color system by creating your tonal
theme colors using the effective primary, secondary and tertiary
colors in the factory, as key colors to create tonal palettes for
these main Material 3 color palettes.
Colors from these key color seed generated palettes will then be used as
color tones for the produce ColorScheme, as defined by the Material 3
design guide. By studying the Flutter SDK ColorScheme.fromSeed factory
you can see which color tone from what key color is used where.
FlexColorScheme uses the same assignments for the tones to the
generated ColorScheme when you opt in using Material 3 tonal palettes.
The FlexColorScheme light and dark factory offer more control over the
seed generation setup. With ColorScheme.fromSeed you can only generate
the ColorScheme from one key color, the primary color. With
FlexColorScheme factories you can use separate key colors for
secondary and tertiary from the primary color, to make their
tonal palettes. The effective colors in your FlexColorScheme for these
color properties are used as key color inputs when you provide a
FlexKeyColors via keyColors and enable it by setting
FlexKeyColors.useKeyColors to true, which it is in its default
constructor, so to enable it you can just pass in a default
FlexKeyColors() to keyColors.
By setting FlexKeyColors.useSecondary or FlexKeyColors.useTertiary to false, the corresponding effective colors in FlexColorScheme will not be used as keys for corresponding TonalPalette. If one is off, its tonal palette will instead be based on the primary color as key. If both are false, the FlexColorScheme.light seeding algorithm becomes the same as using ColorScheme.fromSeed. The primary color is always used as seed color when key color seeding is enabled with FlexKeyColors.useKeyColors set to true.
You can also opt to keep selected effective main colors, primary, secondary, tertiary and their containers, in your FlexColorScheme as their effective color, even when you enable key color based seeded tonal palette based ColorScheme output. You do this by setting FlexKeyColors.keepPrimary, FlexKeyColors.keepSecondary etc to true, for each color property where you want to keep its exact color value as defined, but otherwise may be OK with using key seeded color values.
You can use this feature if you for example want to use an exact predefined primary brand color in light mode, but are OK with all other colors using tones derived from its Material 3 tonal palette.
When you use key color based seeded theme generation, the used key inputs for primary, secondary and tertiary are only used to set and generate the tone of the palette used for each colors tonal palette. You will rarely see the same color on that actual, primary, secondary and tertiary color in the produced ColorScheme, unless you lock them down with the "keep" properties.
The same tonal palette should typically be used for both
light and dark mode colors. Under the hood FlexColorScheme selects the
right color tone from the tonal palette, which is different for light and
dark mode. For a matched light and dark theme, you should use the same
input key color. When you use FlexColorScheme.light and
FlexColorScheme.dark and the FlexScheme enum based scheme property,
to use a built-in color scheme, it automatically uses also its
predefined light theme mode defined colors as the key colors for
primary, secondary and tertiary in dark mode, to ensure that the produced
ColorScheme is using same tonal palette, but only different tones from
it for light and dark mode.
When you use colors, colorScheme or direct override color properties
primary, secondary or tertiary in the factories, these effective
colors are used directly as key color inputs. It is then up to
you to decide and design if you use the same key color for tonal palette
generation in light and dark mode.
If you use colorScheme or pass in primary, secondary or
tertiary, and enable using keyColors the generated scheme will first
use color from passed in direct color properties primary, secondary
or tertiary, as key colors, then the same ones from the passed in
colorScheme when it generates the output ColorScheme using the active
FlexKeyColors setup.
The generated ColorScheme's properties will override all color
properties that were passed in via a colorScheme, except those locked
via the keep properties in FlexKeyColors.
If you assign override colors via direct color properties for the main
colors primary, secondary or tertiary and their containers, they
will also only override the generated resulting ColorScheme if the
the keep properties are set in FlexKeyColors. Other color properties
that exist as both direct color properties and as a color in the
generated resulting ColorScheme, will be overridden by the generated
colors scheme colors.
Normally if you provide an entire colorScheme to FlexColorScheme it
is typically because you already have a scheme that you want to use as is,
then don't enable keyColors or any blends. It is however possible to
apply both blends to passed in colorScheme surfaces or to just use
the primary, secondary or tertiary colors in passed in colorScheme
as keyColors to generate an entirely new ColorScheme from the passed
in colors, using primary, secondary or tertiary as keys.
Implementation
factory FlexColorScheme.light({
/// The [FlexSchemeColor] that will be used to create the light
/// [FlexColorScheme].
///
/// You can use predefined [FlexSchemeColor] values from [FlexColor] or
/// [FlexColor.schemes] map or define your own colors with
/// [FlexSchemeColor] or [FlexSchemeColor.from].
///
/// For using built-in color schemes, the convenience shortcut to select
/// it with the [scheme] property is recommended and leaving [colors]
/// undefined. If both are specified the scheme colors defined by [colors]
/// are used. If both are null then [scheme] defaults to
/// [FlexScheme.material], thus defining the resulting scheme.
final FlexSchemeColor? colors,
/// Use one of the built-in color schemes defined by enum [FlexScheme].
///
/// Give it one of the enum values to use the scheme, like eg.
/// [FlexScheme.mandyRed].
///
/// To create custom color schemes use the [colors] property. If both
/// [colors] and [scheme] are specified, the scheme defined by
/// [colors] is used. If both are null, then [scheme] defaults to
/// [FlexScheme.material] if [useMaterial3] is false, and to
/// [FlexScheme.materialBaseline] [useMaterial3] is true.
final FlexScheme? scheme,
/// The overall [ColorScheme] based colors for the theme.
///
/// This property provides a new way to define custom colors for
/// [FlexColorScheme] and is available from version 4.2.0. It is useful if
/// you already have a custom [ColorScheme] based color definition that
/// you want to use with FlexColorScheme theming and its sub-theming
/// capabilities.
///
/// If you provide both a [ColorScheme] and some individual direct property
/// values that also exist in a [ColorScheme], the individual property
/// values will override the corresponding ones in your [ColorScheme].
///
/// If you do not define a [colorScheme], the used colors will be determined
/// by the [colors] and [scheme] properties. However, when a [colorScheme]
/// is defined it takes precedence. The [brightness] in the provided
/// [colorScheme] is always ignored and set to [Brightness.light] since this
/// is the light theme mode factory. Make sure the colors used in your color
/// scheme are intended for a light theme.
///
/// If you define a [surfaceMode] and set [blendLevel] > 0, then [surface],
/// [surfaceVariant], [background] and [inverseSurface] colors in the
/// provided [colorScheme] will be overridden by the computed color branded
/// surfaces. If your [colorScheme] already contains branded surface colors,
/// then keep [blendLevel] = 0 to continue using them.
///
/// If you use [lightIsWhite] factory feature, it will also override your
/// [colorScheme] based mentioned color properties above and make them
/// 5% lighter.
///
/// If you opt in on using sub themes and have set
/// [subThemesData.blendOnColors] to true and have defined [surfaceMode]
/// and set [blendLevel] > 0, then the effective color scheme based on
/// colors onPrimary, onSecondary, onError, onSurface and onBackground will
/// be changed accordingly too.
///
/// The [colorScheme] colors are also included and affected by factory
/// properties [usedColors] and [swapColors] and included in their behavior.
///
/// The [FlexColorScheme]'s effective [ColorScheme] can be returned with
/// [toScheme]. This will always get you a complete color scheme, including
/// calculated and derived color values, which is particularly useful when
/// using the [FlexColorScheme.light] and [FlexColorScheme.dark] factories
/// to compute color scheme branded surface colors for you. The effective
/// [ColorScheme] for your theme is often needed if you want to create
/// custom sub-themes that should use the colors from the scheme using none
/// default color assignments from the color scheme.
final ColorScheme? colorScheme,
/// The selection of the six main scheme colors to be used when creating
/// effective [ColorScheme].
///
/// This is a convenience property that allows you to vary which colors to
/// use of the primary, secondary and tertiary colors and their container
/// colors when FlexSchemeColor creates its effective [ColorScheme] from
/// the input colors. The integer number corresponds to using:
///
/// * 1 = Only the primary color
/// * 2 = Primary & Secondary colors
/// * 3 = Primary + container & Secondary colors
/// * 4 = Primary + container & Secondary + container
/// * 5 = Primary + container & Secondary + container & tertiary colors
/// * 6 = Primary + container & Secondary + container & tertiary + container
/// * 7 = Primary, Secondary and tertiary, container colors computed.
///
/// By default the value is 6 and all main scheme colors in
/// `FlexSchemeColor` are used.
///
/// The integer value is not a very obvious property to use to configure
/// this feature. Future version may improve it. However, with the Themes
/// Playground you don't have to remember what number does what.
///
/// When the value is 1, the result is the same as if we would have
/// created the colors with [FlexSchemeColor.from] by only giving it the
/// required primary color. With 2, it is equivalent to as if we would have
/// given it only the primary and secondary colors, and so on.
/// This property makes it possible to simulate and change the resulting
/// [FlexColorScheme] to as if you would have specified 1, 2, 3 ... 7 of
/// the color selection. If your used [FlexColorScheme] `colors` was
/// actually created with [FlexSchemeColor.from] with only the primary
/// color defined, then changing the value from 7 ... 3, 2 or 1, will
/// all produce the same effective scheme as the computed values will be
/// the same as the [FlexSchemeColor.from] is using to compute any main
/// missing scheme color values.
final int usedColors = 6,
/// Blends surface tint color into all surface colors and
/// scaffold background color.
///
/// The [surfaceMode] defines the relative strength of the alpha blend
/// value for different surfaces.
///
/// If undefined, defaults to [FlexSurfaceMode.level].
final FlexSurfaceMode? surfaceMode,
/// Sets the blend level strength used by the surface mode.
///
/// The blend level is the integer decimal value of the alpha value
/// used in the alpha blend function. It mixes one color with another
/// by using alpha opacity value in the color of a surface put on top of
/// another surface with opaque color and returns the result as one opaque
/// color.
///
/// Defaults to 0.
final int blendLevel = 0,
/// The style and method used to compute the fixed, fixedDim colors and
/// their on colors in a [ColorScheme] using the palettes provided main
/// light mode color.
///
/// The main color should always be the light theme's [ColorScheme.primary],
/// [ColorScheme.secondary] or [ColorScheme.tertiary]. This means that a
/// dark mode theme needs to know what colors were used for the
/// light mode colors for [ColorScheme.primary], [ColorScheme.secondary] or
/// [ColorScheme.tertiary]. It is not a strict requirement, but necessary
/// if you want the fixed and fixedDim colors to follow the Material-3
/// guide's color system, where these colors are derived from the main light
/// color palette color and have same computed color values in dark mode.
///
/// The two available options, offer different nuances for the fixed color
/// and fixedDim color generation.
///
/// The computed [FlexFixedColorStyle.computed] is made with simpler color
/// math and uses same principles as [FlexSchemeColor.from] does when not
/// using seed generated ColorSchemes and it generates missing colors.
/// This version may fit better with the computed and not seed generated
/// ColorSchemes.
///
/// The [FlexFixedColorStyle.seeded] version is bit more expensive as it
/// requires creating a seeded ColorScheme even when a seed generated
/// ColorScheme is not being used. This version may in some cases produce
/// visually more appealing results.
///
/// If not defined, defaults to [FlexFixedColorStyle.computed].
final FlexFixedColorStyle? fixedColorStyle,
/// Style used to define the themed color of the AppBar background color.
///
/// Defaults to null, which when [useMaterial3] is false results in
/// [FlexAppBarStyle.primary] which produces the same results
/// as a Flutter standard M2 light [ThemeData.from] by tying the app bar
/// color to the primary color. If [useMaterial3] is true it defaults
/// [FlexAppBarStyle.surface] which is the same as M3 default.
///
/// If you enable component themes you can also control the themed
/// [AppBar] by selecting any active [ColorScheme] as its background color.
/// If you do so, the setting applied by this property is ignored.
final FlexAppBarStyle? appBarStyle,
/// Themed [AppBar] opacity.
///
/// The opacity is applied to the effective AppBar color, which may be from
/// used [appBarStyle], that gets its color selection from used [scheme]
/// or [colors]. Or that color may have been overridden by AppBar sub-theme
/// and there selected [SchemeColor] based color.
/// Lastly and with highest priority it may be from here directly supplied
/// [appBarBackground] color.
///
/// A useful opacity range is from 0.85 to 0.95 when using the [Scaffold]
/// property [extendBodyBehindAppBar] set to true, to partially show
/// scrolling content behind the app bar. To use more opacity, in a way
/// that the AppBar does not become too transparent, you also need to blur
/// the background to create a frosted glass effect. This cannot
/// be made with only theming, you need a custom AppBar Widget for that.
/// Frosted glass UI effect is thus beyond the scope of what
/// FlexColorScheme can do alone as it only affects ThemeData.
///
/// If null, defaults to 1, fully opaque, no transparency.
/// If not null, must be from 0 to 1.
final double? appBarOpacity,
/// When set to `true`, it makes the status bar on Android the same color as
/// the rest of the AppBar.
///
/// Defaults to true.
///
/// When true, the AppBar in Android mimics the look of one-toned AppBar's
/// typically used on iOS. Set to `false`, to revert back and use
/// Android's default two-toned look. If true the status bar area is
/// actually also transparent so that if the app bar is also translucent,
/// content that scrolls behind it, is also visible behind the status
/// bar area.
///
/// In default Material-2 this would be false, FCS uses an opinionated
/// style and sets it true. In Material-3 the style you get when setting
/// this to true is used by default. In M3 mode FCS will thus not create
/// an AppBar sub theme to adjust this, if it is true and it is not needed
/// for any other direct AppBar impacting properties in FlexColorScheme
/// constructor. In M2 mode an AppBar theme will always be created, also
/// when not opting in on the actual sub-themes feature, this per its
/// opinionated and legacy styling for M2 mode.
final bool transparentStatusBar = true,
/// The themed elevation for the [AppBar].
///
/// If not defined, defaults to 0 in M2 (FCS opinionated) and to 0 in (M3
/// spec default).
///
/// The FCS 0dp elevation in M2 is an iOS style influenced opinionated
/// choice, it can easily be adjusted for the theme with this property.
final double? appBarElevation,
/// The themed elevation for the [BottomAppBar].
///
/// If undefined (null), defaults to 3 in M3 mode and to 8 in M2 mode,
/// both via the defaults for the respective theme mode from Flutter's
/// default elevation behavior of [BottomAppBar].
final double? bottomAppBarElevation,
/// Select preferred style for the default [TabBarThemeData].
///
/// By default the TabBarThemeData is made to fit with the style of the
/// [AppBar].
/// In Material-2 mode that is done by defaulting to using
/// [FlexTabBarStyle.forAppBar] if not defined. In M3 mode it is done by
/// defaulting to using [FlexTabBarStyle.flutterDefault].
///
/// When setting this to [FlexTabBarStyle.forBackground], it will default
/// to a theme that uses the color scheme and fits on background color,
/// which typically also on works surface and scaffoldBackground color.
/// This TabBarThemeData style is useful if you primarily intended to use
/// the TabBar in a Scaffold, Dialog, Drawer or Side panel on their
/// background colors.
final FlexTabBarStyle? tabBarStyle,
/// The color displayed most frequently across your app’s screens and
/// components.
///
/// When using the factory this is an override color for the color that
/// would be used based on the corresponding color property defined in
/// [FlexSchemeColor] [colors] or for this color defined when using a
/// pre-defined color scheme based on [FlexScheme] [scheme] property, or
/// if a [colorScheme] was provided it will override the same color in it
/// as well.
///
/// You can use this property for convenience if you want to override the
/// color that this scheme color gets via the factory behavior.
///
/// This override color is included and affected by factory
/// properties [usedColors] and [swapColors] and included in their behavior.
///
/// Defaults to null.
final Color? primary,
/// A color that is clearly legible when drawn on [primary] color.
///
/// To ensure that an app is accessible, a contrast ratio of 4.5:1 for
/// [primary] and [onPrimary] is recommended. See
/// <https://www.w3.org/TR/UNDERSTANDING-WCAG20/visual-audio-contrast-contrast.html>.
///
/// When using this factory, this is an override color for the color that
/// would be used based on the corresponding color property defined in
/// [FlexSchemeColor] [colors] property or when using pre-defined color
/// scheme based [FlexScheme] and its [scheme] property, including any
/// used blend logic. If a [colorScheme] was provided with this
/// corresponding color defined, this color property will override the
/// same color in it as well.
///
/// You can use this property for convenience if you want to override the
/// color that this scheme color gets via the factory behavior.
final Color? onPrimary,
/// A color used for elements needing less emphasis than [primary].
///
/// When using the factory this is an override color for the color that
/// would be used based on the corresponding color property defined in
/// [FlexSchemeColor] [colors] or for this color defined when using a
/// pre-defined color scheme based on [FlexScheme] [scheme] property, or
/// if a [colorScheme] was provided it will override the same color in it
/// as well.
///
/// You can use this property for convenience if you want to override the
/// color that this scheme color gets via the factory behavior.
///
/// The override color is included and affected by factory
/// properties [usedColors] and [swapColors] and included in their behavior.
///
/// Defaults to null.
final Color? primaryContainer,
/// A color that's clearly legible when drawn on [primaryContainer].
///
/// To ensure that an app is accessible, a contrast ratio between
/// [primaryContainer] and [onPrimaryContainer] of at least 4.5:1
/// is recommended. See
/// <https://www.w3.org/TR/UNDERSTANDING-WCAG20/visual-audio-contrast-contrast.html>.
///
/// When using this factory, this is an override color for the color that
/// would be used based on the corresponding color property defined in
/// [FlexSchemeColor] [colors] property or when using pre-defined color
/// scheme based [FlexScheme] and its [scheme] property, including any
/// used blend logic. If a [colorScheme] was provided with this
/// corresponding color defined, this color property will override the
/// same color in it as well.
///
/// You can use this property for convenience if you want to override the
/// color that this scheme color gets via the factory behavior.
final Color? onPrimaryContainer,
/// A support color to primary, with less emphasis than primary, often of
/// same hue as primary, but does not have to be.
///
/// When using the factory this is an override color for the color that
/// would be used based on the corresponding color property defined in
/// [FlexSchemeColor] [colors] or for this color defined when using a
/// pre-defined color scheme based on [FlexScheme] [scheme] property, or
/// if a [colorScheme] was provided it will override the same color in it
/// as well.
///
/// You can use this property for convenience if you want to override the
/// color that this scheme color gets via the factory behavior.
///
/// The override color is included and affected by factory properties
/// [usedColors] and [swapColors] and included in their behavior.
///
/// Defaults to null.
final Color? secondary,
/// A color that is clearly legible when drawn on [secondary] color.
///
/// To ensure that an app is accessible, a contrast ratio of 4.5:1 for
/// [secondary] and [onSecondary] is recommended. See
/// <https://www.w3.org/TR/UNDERSTANDING-WCAG20/visual-audio-contrast-contrast.html>.
///
/// When using this factory, this is an override color for the color that
/// would be used based on the corresponding color property defined in
/// [FlexSchemeColor] [colors] property or when using pre-defined color
/// scheme based [FlexScheme] and its [scheme] property, including any
/// used blend logic. If a [colorScheme] was provided with this
/// corresponding color defined, this color property will override the
/// same color in it as well.
///
/// You can use this property for convenience if you want to override the
/// color that this scheme color gets via the factory behavior.
final Color? onSecondary,
/// A color used for elements needing less emphasis than [secondary].
///
/// When using the factory this is an override color for the color that
/// would be used based on the corresponding color property defined in
/// [FlexSchemeColor] [colors] or for this color defined when using a
/// pre-defined color scheme based on [FlexScheme] [scheme] property, or
/// if a [colorScheme] was provided it will override the same color in it
/// as well.
///
/// You can use this property for convenience if you want to override the
/// color that this scheme color gets via the factory behavior.
///
/// The override color is included and affected by factory properties
/// [usedColors] and [swapColors] and included in their behavior.
///
/// Defaults to null.
final Color? secondaryContainer,
/// A color that's clearly legible when drawn on [secondaryContainer].
///
/// To ensure that an app is accessible, a contrast ratio between
/// [secondaryContainer] and [onSecondaryContainer] of at least 4.5:1
/// is recommended. See
/// <https://www.w3.org/TR/UNDERSTANDING-WCAG20/visual-audio-contrast-contrast.html>.
///
/// When using this factory, this is an override color for the color that
/// would be used based on the corresponding color property defined in
/// [FlexSchemeColor] [colors] property or when using pre-defined color
/// scheme based [FlexScheme] and its [scheme] property, including any
/// used blend logic. If a [colorScheme] was provided with this
/// corresponding color defined, this color property will override the
/// same color in it as well.
///
/// You can use this property for convenience if you want to override the
/// color that this scheme color gets via the factory behavior.
final Color? onSecondaryContainer,
/// A color used as a contrasting accent that can balance [primary]
/// and [secondary] colors or bring heightened attention to an element,
/// such as an input field.
///
/// When using the factory this is an override color for the color that
/// would be used based on the corresponding color property defined in
/// [FlexSchemeColor] [colors] or for this color defined when using a
/// pre-defined color scheme based on [FlexScheme] [scheme] property, or
/// if a [colorScheme] was provided it will override the same color in it
/// as well.
///
/// You can use this property for convenience if you want to override the
/// color that this scheme color gets via the factory behavior.
///
/// The override color is included and affected by factory properties
/// [usedColors] and [swapColors] and included in their behavior.
///
/// Defaults to null.
final Color? tertiary,
//// A color that's clearly legible when drawn on [tertiary].
///
/// To ensure that an app is accessible, a contrast ratio of 4.5:1 for
/// [secondary] and [onSecondary] is recommended. See
/// <https://www.w3.org/TR/UNDERSTANDING-WCAG20/visual-audio-contrast-contrast.html>.
///
/// When using this factory, this is an override color for the color that
/// would be used based on the corresponding color property defined in
/// [FlexSchemeColor] [colors] property or when using pre-defined color
/// scheme based [FlexScheme] and its [scheme] property, including any
/// used blend logic. If a [colorScheme] was provided with this
/// corresponding color defined, this color property will override the
/// same color in it as well.
///
/// You can use this property for convenience if you want to override the
/// color that this scheme color gets via the factory behavior.
final Color? onTertiary,
/// A color used for elements needing less emphasis than [tertiary].
///
/// When using the factory this is an override color for the color that
/// would be used based on the corresponding color property defined in
/// [FlexSchemeColor] [colors] or for this color defined when using a
/// pre-defined color scheme based on [FlexScheme] [scheme] property, or
/// if a [colorScheme] was provided it will override the same color in it
/// as well.
///
/// You can use this property for convenience if you want to override the
/// color that this scheme color gets via the factory behavior.
///
/// The override color is included and affected by factory properties
/// [usedColors] and [swapColors] and included in their behavior.
///
/// Defaults to null.
final Color? tertiaryContainer,
/// A color that's clearly legible when drawn on [tertiaryContainer].
///
/// To ensure that an app is accessible, a contrast ratio between
/// [secondaryContainer] and [onSecondaryContainer] of at least 4.5:1
/// is recommended. See
/// <https://www.w3.org/TR/UNDERSTANDING-WCAG20/visual-audio-contrast-contrast.html>.
///
/// When using this factory, this is an override color for the color that
/// would be used based on the corresponding color property defined in
/// [FlexSchemeColor] [colors] property or when using pre-defined color
/// scheme based [FlexScheme] and its [scheme] property, including any
/// used blend logic. If a [colorScheme] was provided with this
/// corresponding color defined, this color property will override the
/// same color in it as well.
///
/// You can use this property for convenience if you want to override the
/// color that this scheme color gets via the factory behavior.
final Color? onTertiaryContainer,
/// The color to use for input validation errors, e.g. for
/// [InputDecoration.errorText].
///
/// When using the factory this is an override color for the color that
/// would be used based on the corresponding color property defined in
/// [FlexSchemeColor] [colors] or for this color defined when using a
/// pre-defined color scheme based on [FlexScheme] [scheme] property, or
/// if a [colorScheme] was provided it will override the same color in it
/// as well.
///
/// You can use this property for convenience if you want to override the
/// color that this scheme color gets via the factory behavior.
final Color? error,
/// A color that is clearly legible when drawn on [error] color.
///
/// To ensure that an app is accessible, a contrast ratio of 4.5:1 for
/// [error] and [onError] is recommended. See
/// <https://www.w3.org/TR/UNDERSTANDING-WCAG20/visual-audio-contrast-contrast.html>.
///
/// When using this factory, this is an override color for the color that
/// would be used based on the corresponding color property defined in
/// [FlexSchemeColor] [colors] property or when using pre-defined color
/// scheme based [FlexScheme] and its [scheme] property, including any
/// used blend logic. If a [colorScheme] was provided with this
/// corresponding color defined, this color property will override the
/// same color in it as well.
///
/// You can use this property for convenience if you want to override the
/// color that this scheme color gets via the factory behavior.
final Color? onError,
/// The color to use for input validation errors with less emphasis than
/// error.
///
/// When using the factory this is an override color for the color that
/// would be used based on the corresponding color property defined in
/// [FlexSchemeColor] [colors] or for this color defined when using a
/// pre-defined color scheme based on [FlexScheme] [scheme] property, or
/// if a [colorScheme] was provided it will override the same color in it
/// as well.
///
/// You can use this property for convenience if you want to override the
/// color that this scheme color gets via the factory behavior.
final Color? errorContainer,
/// A color that is clearly legible when drawn on [errorContainer] color.
///
/// To ensure that an app is accessible, a contrast ratio of 4.5:1 for
/// [error] and [onError] is recommended. See
/// <https://www.w3.org/TR/UNDERSTANDING-WCAG20/visual-audio-contrast-contrast.html>.
///
/// When using this factory, this is an override color for the color that
/// would be used based on the corresponding color property defined in
/// [FlexSchemeColor] [colors] property or when using pre-defined color
/// scheme based [FlexScheme] and its [scheme] property, including any
/// used blend logic. If a [colorScheme] was provided with this
/// corresponding color defined, this color property will override the
/// same color in it as well.
///
/// You can use this property for convenience if you want to override the
/// color that this scheme color gets via the factory behavior.
final Color? onErrorContainer,
/// The surface (background) color for widgets like [Card] and
/// [BottomAppBar].
///
/// The color is applied to [ThemeData.cardColor], [ThemeData.canvasColor]
/// and [ColorScheme.surface] in [ThemeData.colorScheme], it is also used
/// by all [Material] of type [MaterialType.card].
///
/// When using the factory this is an override color for the color that
/// would be used based on mode defined by property
/// [surfaceMode] [FlexSurfaceMode] enum or [surfaceStyle] enum
/// [FlexSurface], or if a [colorScheme] was provided it will override the
/// same color in it as well.
///
/// Defaults to null.
final Color? surface,
/// A color that is clearly legible when drawn on [surface] color.
///
/// To ensure that an app is accessible, a contrast ratio of 4.5:1 for
/// [surface] and [onSurface] is recommended. See
/// <https://www.w3.org/TR/UNDERSTANDING-WCAG20/visual-audio-contrast-contrast.html>.
///
/// When using this factory, this is an override color for the color that
/// would be used based on the corresponding color property defined in
/// [FlexSchemeColor] [colors] property or when using pre-defined color
/// scheme based [FlexScheme] and its [scheme] property, including any
/// used blend logic. If a [colorScheme] was provided with this
/// corresponding color defined, this color property will override the
/// same color in it as well.
///
/// You can use this property for convenience if you want to override the
/// color that this scheme color gets via the factory behavior.
final Color? onSurface,
/// The color of the [Scaffold] background.
///
/// The color is applied to [ThemeData.scaffoldBackgroundColor].
///
/// If [subThemesData.scaffoldBackgroundSchemeColor] is defined, it is used
/// instead of this [scaffoldBackground] color.
///
/// If no value is given, and no
/// [subThemesData.scaffoldBackgroundSchemeColor]
/// is defined, default color is [ColorScheme.surface] in M2 mode and
/// [ColorScheme.surfaceContainerLowest] in M3 mode.
final Color? scaffoldBackground,
/// The background color used by [Dialog]s.
///
/// In FCS versions before 8.2.0 this color is applied to
/// `ThemeData.dialogBackgroundColor`, a color that cannot be
/// controlled separately with only a [ThemeData.from] a [ColorScheme].
///
/// In FCS version 8.2.0 and later this color is no longer applied to
/// `ThemeData.dialogBackgroundColor`, as the property is deprecated in
/// Flutter 3.29.0 and later. To get the selected dialog color sub-themes
/// must now be enabled.
///
/// When using sub-themes,this color is applied to backgroundColor in
/// dialog themes DatePickerThemeData, DialogThemeData and
/// TimePickerThemeData,
/// but only if [subThemesData.dialogBackgroundSchemeColor] has not be
/// defined in [subThemesData].
///
/// If [subThemesData.dialogBackgroundSchemeColor] is defined, it is used
/// instead of this [dialogBackground] color.
///
/// If no value is given, and no [subThemesData.dialogBackgroundSchemeColor]
/// is defined, default color is [ColorScheme.surface] in Material-2 mode
/// and [ColorScheme.surfaceContainerHigh] in Material-3 mode.
final Color? dialogBackground,
/// Background theme color for the [AppBar].
///
/// When using the factory this is an override color for the color that
/// would be used based on the corresponding color property defined in
/// [FlexSchemeColor] [colors] or for this color defined when using a
/// pre-defined color scheme based on [FlexScheme] `scheme` property and
/// the [FlexAppBarStyle] via the [appBarStyle] property.
///
/// Thus custom color will also override any scheme color based selection
/// for the [AppBAr] in active used sub-themes.
final Color? appBarBackground,
/// A custom color used as an overlay on a surface color to indicate a
/// component's elevation and surface color branding or tinting.
///
/// If a [colorScheme] was provided where this corresponding color is
/// defined, this color property will override the same color in it.
///
/// This color is used by Material 3 for colored elevation, it is also used
/// as the blend color for FlexColorScheme surface blends. Additionally
/// this color is if provided used as key color for seeding
/// the neutral color palettes, when seed generated color schemes are used.
/// It is important that all these properties use the same color.
///
/// Typically this color is not customized, most designs use the default
/// where the theme primary color is used for slightly mixing it into the
/// neutral background and surface colors, when seeding is used. As well as
/// using it for the the elevation tint in Material 3, plus for the
/// surface blends that can optionally be added with FlexColorScheme.
///
/// If undefined, [primary] color is used.
final Color? surfaceTint,
/// Makes the light theme backgrounds lighter or even white.
///
/// Scaffold background will become white and is no longer impacted by used
/// [blendLevel]. Other surfaces also become lighter, when using low blend
/// levels they may become fully white too, but are still impacted by the
/// blend level.
final bool lightIsWhite = false,
/// When true, the primary and primaryContainer colors will be swapped with
/// their secondary counterparts.
///
/// Set this flag to true if you want to make a theme where
/// your primary and secondary colors are swapped, compared to how they
/// are defined in the passed in color properties or used pre-defined
/// color scheme.
///
/// This is useful if you want to do this with the pre-defined
/// schemes. If you are explicitly defining all your theme colors you can
/// of course define them in any desired config. Even if you do
/// that, this feature will still swap whatever colors you defined
/// for primary and secondary. You can offer this feature as an easy end
/// user modifiable theme option if you like. One usage possibility is to
/// set `swapColors` to true only for the dark modem and use your color
/// scheme the other way around only in dark mode.
final bool swapColors = false,
/// When set to true, tooltip background color will match the brightness of
/// the theme's background color.
///
/// By default Flutter's Material tooltips use a theme where the tooltip
/// background color brightness is inverted in relation to the overall
/// theme's background color.
///
/// [FlexColorScheme] allows you to use a single toggle to invert this.
/// Light tooltips on light background is e.g. the default style on
/// Windows Desktop toggle. You can use this toggle to use this style,
/// or use it as a means to create a platform adaptive tooltip style, where
/// the Material and Flutter style is used on devices and Web, but the
/// inverted scheme is used on e.g. Windows platform.
///
/// Defaults to false, and uses same background style as Material Design
/// guide and Flutter.
///
/// Additional tooltip styles when NOT opting in on FlexColorScheme sub
/// themes are:
///
/// - tooltipsMatchBackground: false
/// - none
///
/// - tooltipsMatchBackground: true
/// - light theme:
/// - background: Color(0xF0FCFCFC),
/// - text: black
/// - Dark theme:
/// - background: Color(0xED444444),
/// - text: white
/// - Border radius: 4 dp
/// - Border: Yes, dividerColor
/// - Desktop OS (macOS, Linux, Windows)
/// - Font size : 12 dp
/// - Mobile OS (iOS, Android, Fuchsia)
/// - Font size : 14 dp
///
/// Additional styles when opting in on FlexColorScheme sub themes are:
///
/// - Desktop OS (macOS, Linux, Windows)
/// - Font size : 12 dp
/// - Mobile OS (iOS, Android, Fuchsia)
/// - Font size : 14 dp
/// - Border radius: 8 dp
/// - Border: Yes, dividerColor
/// - tooltipsMatchBackground: false
/// - light theme:
/// - background: Color(0xFF111111).blendAlpha(primary, 45%) opacity 95%
/// - text: white
/// - Dark theme:
/// - background: Color(0xFFFFFFFF).blendAlpha(primary, 39%) opacity 95%
/// - text: black
/// - tooltipsMatchBackground: true
/// - light theme:
/// - background: Color(0xFFFFFFFF).blendAlpha(primary, 4%) opacity 95%
/// - text: black
/// - Dark theme:
/// - background: Color(0xFF111111).blendAlpha(primary, 16%) opacity 95%
/// - text: white
///
/// When using additional theming via sub-themes properties, its
/// properties will if used override background color, text color and
/// background opacity as well as border radius.
final bool tooltipsMatchBackground = false,
/// Activate using FlexColorScheme opinionated component sub-themes by
/// passing in a default `FlexSubThemesData()`.
///
/// To further configure the sub-themes, change the simple flat value
/// properties as desired in `FlexSubThemesData()`.
///
/// By default [FlexThemeData.light], [FlexThemeData.dark] and
/// [FlexColorScheme.toTheme], do as little as they need to just
/// provide a consistent Material 2 color schemed theme. The additions they
/// do are described in [FlexColorScheme.toTheme].
///
/// The original purpose of the opinionated sub-themes was to make it easy
/// to add themed corner radius to all Widgets that support it, and to
/// provide a consistent look on all buttons, including [ToggleButtons].
///
/// Therefore the sub themes are a convenient way to opt-in on customized
/// corner radius on Widgets using above themes. By opting in you can set
/// corner radius for all covered Widgets to same corner radius in one go.
/// There are also properties to override the global default for each widget
/// to set different rounding per widget if so desired.
///
/// By default, if a `defaultRadius` is not specified, each widgets corner
/// radius and some other styling take inspiration from the Material 3 (M3)
/// specification https://m3.material.io/ and uses its specifications as
/// defaults when it is possible to do so in Flutter SDK theming when using
/// Material2 mode and via defaults also in Material 3 mode.
///
/// Starting from version 5, by opting in via a default [subThemesData] you
/// get an extensive set of widget component sub themes applied.
/// They can be customized via the [subThemesData] property, that has
/// quick and flat sub theme configuration values in the data class
/// [FlexSubThemesData].
///
/// Customizable sub-themes are available for:
///
/// * [AppBarTheme] for [AppBar] via [FlexSubThemes.appBarTheme].
/// * [BottomAppBarTheme] for [BottomAppBar] via
/// [FlexSubThemes.bottomAppBarTheme].
/// * [BottomNavigationBarThemeData] for [BottomNavigationBar] via
/// [FlexSubThemes.bottomNavigationBar].
/// * [BottomSheetThemeData] for [BottomSheet] via
/// [FlexSubThemes.bottomSheetTheme].
/// * [ButtonThemeData] for old deprecated buttons, via
/// [FlexSubThemes.buttonTheme].
/// * [CardThemeData] for [Card] via [FlexSubThemes.cardTheme].
/// * [CheckboxThemeData] for [Checkbox] via [FlexSubThemes.checkboxTheme].
/// * [ChipThemeData] for [Chip] via [FlexSubThemes.chipTheme].
/// * [DatePickerThemeData] for [DatePicker] via
/// [FlexSubThemes.datePickerTheme].
/// * [DialogThemeData] for [Dialog] via [FlexSubThemes.dialogTheme].
/// * [DrawerThemeData] for [Drawer] via [FlexSubThemes.drawerTheme].
/// * [DropdownMenuThemeData] for [DropDownMenu] via
/// [FlexSubThemes.dropdownMenuTheme].
/// * [ElevatedButtonThemeData] for [ElevatedButton] via
/// [FlexSubThemes.elevatedButtonTheme].
/// * [FilledButtonThemeData] for [FilledButton] via
/// [FlexSubThemes.filledButtonTheme].
/// * [FloatingActionButtonThemeData] for [FloatingActionButton] via
/// [FlexSubThemes.floatingActionButtonTheme].
/// * [IconButtonThemeData] for [IconButton] via
/// [FlexSubThemes.iconButtonTheme].
/// * [InputDecorationThemeData] for [InputDecoration] via
/// [FlexSubThemes.inputDecorationTheme].
/// * [MenuBarThemeData] for [MenuBar] via [FlexSubThemes.menuBarTheme].
/// * [MenuButtonThemeData] for [MenuButton] via
/// [FlexSubThemes.menuButtonTheme].
/// * [MenuThemeData] for [MenuBar], [MenuAnchor] and [DropDownMenu] via
/// [FlexSubThemes.menuTheme].
/// * [ListTileThemeData] for [ListTile] via
/// [FlexSubThemes.listTileTheme].
/// * [NavigationBarThemeData] for [NavigationBar] via
/// [FlexSubThemes.navigationBarTheme].
/// * [NavigationDrawerThemeData] for [NavigationDrawer] via
/// [FlexSubThemes.navigationDrawerTheme].
/// * [NavigationRailThemeData] for [NavigationRail] via
/// [FlexSubThemes.navigationRailTheme].
/// * [OutlinedButtonThemeData] for [OutlinedButton] via
/// [FlexSubThemes.outlinedButtonTheme].
/// * [PopupMenuThemeData] for [PopupMenuButton] via
/// [FlexSubThemes.popupMenuTheme].
/// * [RadioThemeData] for [Radio] via [FlexSubThemes.radioTheme].
/// * [SliderThemeData] for [Slider] via [FlexSubThemes.sliderTheme].
/// * [SnackBarThemeData] for [SnackBar] via [FlexSubThemes.snackBarTheme].
/// * [SwitchThemeData] for [Switch] via [FlexSubThemes.switchTheme].
/// * [TabBarThemeData] for [TabBar] via [FlexSubThemes.tabBarTheme].
/// * [TextButtonThemeData] for [TextButton] via
/// [FlexSubThemes.textButtonTheme].
/// * [TextSelectionThemeData] for [TextField] via
/// [FlexSubThemes.textSelectionTheme].
/// * [TimePickerThemeData] for [TimePickerDialog] via
/// [FlexSubThemes.timePickerTheme].
/// * [ToggleButtonsThemeData] for [ToggleButtons] via
/// [FlexSubThemes.toggleButtonsTheme].
/// * [TooltipThemeData] for [Tooltip] via [FlexSubThemes.tooltipTheme].
///
/// Defaults to null, resulting in FlexColorScheme not using any extra
/// sub-theming in addition to those described in [FlexColorScheme.toTheme].
final FlexSubThemesData? subThemesData,
/// To use and activate Material 3 color system based [ColorScheme]
/// defined via key colors for primary, secondary and tertiary colors and
/// the [TonalPalette] generated by these key color values, pass
/// in a [FlexKeyColors] to [keyColors].
///
/// By default it is not defined (null), and a traditional manually
/// configured color scheme will be created based on input property values
/// or a passed in [colorScheme].
///
/// If a [FlexKeyColors] instance is passed in, the key color seeding
/// behavior depends on properties defined in the [FlexKeyColors]
/// instance. The default constructor makes one where
/// [FlexKyColors.useKeyColors] is true, it will automatically enable usage
/// of the used light scheme's primary color as key color and to seed
/// generated a color scheme. The result will by default be equal to using
/// Flutter SDK `ColorScheme.fromSeed`. With `FlexKeyColors` you can also
/// use `secondary` and `tertiary` colors as key colors. Currently Flutter
/// SDK does not support this.
///
/// For more information on Material 3 color system and usage of key colors
/// to generate tonal palettes and tones, see:
/// https://m3.material.io/styles/color/the-color-system/key-colors-tones
final FlexKeyColors? keyColors,
/// Set to true, to use the new Material 3 error colors.
///
/// If [useMaterial3ErrorColors] is false, the generated [ColorScheme]
/// and [ThemeData] will use Material 2 default error colors or
/// error colors as defined by the built in color schemes. Thus using same
/// error colors as in FlexColorScheme versions before version 5.
///
/// If [useMaterial3ErrorColors] is true, the resulting [ColorScheme]
/// and [ThemeData] will use the Material 3 design guide error colors.
///
/// Key color seed generated [ColorScheme]s always use the Material 3
/// design guide error colors, or error colors from its customized
/// [TonalPalette] generation setup.
final bool useMaterial3ErrorColors = false,
/// A configuration class enabling complete customization of
/// used chroma for [TonalPalette] generation for the used seed [keyColors],
/// as well as changing which tone in the tonal palettes is used
/// for which [ColorScheme] color.
///
/// By default a `FlexTones` configuration `FlexTones.material` that
/// matches what Flutter SDK does with `ColorScheme.fromSeed` is used.
///
/// There are six other built-in definitions that you can use, they can also
/// serve as an example of how you can make custom `FlexTones`
/// configurations.
final FlexTones? tones,
/// An optional way to select the used algorithm for seeded [ColorScheme]
/// generation, can be used instead of a [FlexTones] provided in [tones].
///
/// The [variant] and [tones] are mutually exclusive, only one of them
/// can be used. If both are null, the default from [tones] is used.
///
/// The [variant] selections includes all the Flutter SDK defined options
/// that will be available in the future in Flutter Stable after 3.22.x,
/// that are available in master channel now but did not land in Flutter
/// 3.22. Variant options that are identical to the Flutter SDK options
/// have [FlexSchemeVariant.value], [isFlutterScheme] set to true. These
/// enum options will not respect and use any other seed generation keys
/// than the [primaryKey], as they only support using one seed color.
///
/// The [FlexSchemeVariant] also includes quick selections for all the
/// predefined [FlexTones] configurations. However, with [variant] you can
/// only select one of the predefined configurations, and not make custom
/// configurations like you can with [FlexTones]. Additionally you cannot
/// use the [FlexTones] modifiers [monochromeSurfaces], [onMainsUseBW],
/// [onSurfacesUseBW] and [surfacesUseBW], since the only operate on the
/// [FlexTones] configurations passed in to [tones].
final FlexSchemeVariant? variant,
/// The density value for specifying the compactness of various UI
/// components.
///
/// Consider using [FlexColorScheme.comfortablePlatformDensity],
/// it is similar to [VisualDensity.adaptivePlatformDensity], but the
/// density for desktop and Web is less dense in order to offer a bit larger
/// touch friendly surfaces, but not quite as large as small touch devices.
///
/// This is the same property as in [ThemeData] factory, it is just
/// passed along to it. Included for convenience, to avoid a copyWith
/// to change it.
///
/// Density, in the context of a UI, is the vertical and horizontal
/// "compactness" of the elements in the UI. It is unit less, since it means
/// different things to different UI elements. For buttons, it affects the
/// spacing around the centered label of the button. For lists, it affects
/// the distance between baselines of entries in the list.
///
/// Typically, density values are integral, but any value in range may be
/// used. The range includes values from [VisualDensity.minimumDensity]
/// (which is -4), to [VisualDensity.maximumDensity] (which is 4),
/// inclusive, where negative values indicate a denser, more compact, UI,
/// and positive values indicate a less dense, more expanded, UI. If a
/// component doesn't support the value given, it will clamp to the nearest
/// supported value.
///
/// The default for visual densities is zero for both vertical and
/// horizontal densities, which corresponds to the default visual density of
/// components in the Material Design specification.
///
/// As a rule of thumb, a change of 1 or -1 in density corresponds to 4
/// logical pixels. However, this is not a strict relationship since
/// components interpret the density values appropriately for their needs.
///
/// A larger value translates to a spacing increase (less dense), and a
/// smaller value translates to a spacing decrease (more dense).
///
/// Defaults to [VisualDensity.adaptivePlatformDensity].
final VisualDensity? visualDensity,
/// Text with a color that contrasts with background, surface, card and
/// canvas colors.
///
/// If a default `TextTheme` from package GoogleFonts is passed.
/// FlexColorScheme will detect this and make the color in the passed
/// in `GoogleFonts` null for all its `TextStyle`s so that the correct
/// color for M2/M3 mode and contrast for light/dark mode is used.
final TextTheme? textTheme,
/// A text theme that contrasts with the primary color.
///
/// If a default `TextTheme` from package GoogleFonts is passed.
/// FlexColorScheme will detect this and make the color in the passed
/// in `GoogleFonts` null for all its `TextStyle`s so that the correct
/// color for M2/M3 mode and contrast for primary color is used.
final TextTheme? primaryTextTheme,
/// Name of the font family to use as default font for the text theme in
/// created theme.
///
/// Same feature as in [ThemeData] factory. Used to apply the font family
/// name to default text theme and primary text theme, also passed along
/// to [ThemeData],
final String? fontFamily,
/// Name of the font families to use as fallback to main font family.
///
/// Same feature as in [ThemeData] factory. Used to apply the font family
/// fallback to default text theme and primary text theme, also passed
/// along to [ThemeData],
final List<String>? fontFamilyFallback,
/// Name of the font package to use with font fallback.
///
/// Same feature as in [ThemeData] factory. Used to apply the font package
/// to default text theme and primary text theme, also passed along
/// to [ThemeData],
final String? package,
/// Configures the hit test size of certain Material widgets.
///
/// Defaults to a [platform]-appropriate size: MaterialTapTargetSize.padded
/// on mobile platforms, MaterialTapTargetSize.shrinkWrap on desktop
/// platforms.
final MaterialTapTargetSize? materialTapTargetSize,
/// Default [MaterialPageRoute] transitions per [TargetPlatform].
///
/// [MaterialPageRoute.buildTransitions] delegates to a [platform] specific
/// [PageTransitionsBuilder]. If a matching builder is not found, a builder
/// whose platform is null is used.
///
/// This is convenience pass through in FlexColorScheme to avoid a
/// `copyWith` on `ThemeData` produced by FlexColorScheme.
final PageTransitionsTheme? pageTransitionsTheme,
/// Defines the appearance of ink splashes produces by [InkWell]
/// and [InkResponse].
///
/// Providing a [splashFactory] value will override the default one created
/// by [ThemeData], it will also override any splash settings in
/// [subThemesData].
///
/// See also:
///
/// * [InkSplash.splashFactory], which defines the default splash.
/// * [InkRipple.splashFactory], which defines a splash that spreads out
/// more aggressively than the default.
/// * [InkSparkle.splashFactory], which defines a more aggressive and
/// organic splash with sparkle effects.
final InteractiveInkFeatureFactory? splashFactory,
/// The platform adaptive widgets adapt to defined target and mechanics,
/// like scrolling too.
///
/// Same property as in [ThemeData] factory. Included for convenience to
/// avoid a copyWith to change it.
///
/// Defaults to the current platform, as exposed by [defaultTargetPlatform].
/// This should be used in order to style UI elements according to platform
/// conventions.
///
/// Widgets from the material library should use this getter (via
/// [Theme.of]) to determine the current platform for the purpose of
/// emulating the platform behavior (e.g. scrolling or haptic effects).
/// Widgets and render objects at lower layers that try to emulate the
/// underlying platform platform can depend on [defaultTargetPlatform]
/// directly, or may require that the target platform be provided as an
/// argument. The `dart.io.Platform` object should only be used directly
/// when it's critical to actually know the current platform, without
/// any overrides possible, e.g. when a system API is about to be called.
///
/// In a test environment, the platform returned is [TargetPlatform.android]
/// regardless of the host platform. (Android was chosen because the tests
/// were originally written assuming Android-like behavior, and we added
/// platform adaptations for other platforms later). Tests can check
/// behavior for other platforms by setting the [platform] of the [Theme]
/// explicitly to another [TargetPlatform] value, or by setting
/// [debugDefaultTargetPlatformOverride].
///
/// When developing applications you can use this property to dynamically
/// in the application change the used platform and partially test and see
/// how adaptive widgets and scroll looks and feels on other platforms.
final TargetPlatform? platform,
/// The color and geometry [TextTheme] values used to configure [textTheme].
///
/// Same property as in [ThemeData] factory.
/// Included for convenience to avoid a copyWith if it needs to be changed.
/// Default value deviates from the Flutter standard that uses the old
/// [Typography.material2014], in favor of newer [Typography.material2018]
/// as default typography if one is not provided.
///
/// In M3 mode FCS default to [Typography.material2021] and in M2 mode to
/// older [Typography.material2018], which is correct for M2. Please note
/// that Flutter ThemeData defaults to even older Typography
/// [Typography.material2014] when not using M3. This is done for legacy
/// compatibility reasons, you should use 2018 with M2.
final Typography? typography,
/// Apply a semi-transparent overlay color on Material surfaces to indicate
/// elevation for dark themes.
///
/// Same property as in [ThemeData] factory. Included for convenience to
/// avoid a copyWith change it.
///
/// In FlexColorScheme it defaults to true. In Flutter [ThemeData.from] it
/// also default to true, but in [ThemeData] factory it defaults to false.
///
/// Material drop shadows can be difficult to see in a dark theme, so the
/// elevation of a surface should be portrayed with an "overlay" in addition
/// to the shadow. As the elevation of the component increases, the
/// overlay increases in opacity. The [applyElevationOverlayColor] turns the
/// application of this overlay on or off for dark themes.
///
/// If true and [brightness] is [Brightness.dark], a
/// semi-transparent version of [ColorScheme.onSurface] will be
/// applied on top of [Material] widgets that have a [ColorScheme.surface]
/// color. The level of transparency is based on [Material.elevation] as
/// per the Material Dark theme specification.
///
/// If false the surface color will be used unmodified.
///
/// Defaults to false in order to maintain backwards compatibility with
/// apps that were built before the Material Dark theme specification
/// was published. New apps should set this to true for any themes
/// where [brightness] is [Brightness.dark].
///
/// See also:
///
/// * [Material.elevation], which effects the level of transparency of the
/// overlay color.
/// * [ElevationOverlay.applyOverlay], which is used by [Material] to apply
/// the overlay color to its surface color.
/// * <https://material.io/design/color/dark-theme.html>, which specifies
/// how the overlay should be applied.
///
/// Known limitations:
///
/// Because of how the overlay color application is implemented in Flutter
/// SDK, you will only get overlay color applied in dark mode when this
/// value is true, if the [Material] surface color being elevated is equal
/// to [ThemeData.colorScheme] and its [ColorScheme.surface] color property.
///
/// Thus when using color branded surfaces, if you want all [Material]
/// surfaces in your theme to get an overlay color in dark mode, you must
/// for dark themes only use background colors that are equal to the surface
/// color. This when using [FlexColorScheme.dark] use a [FlexSurfaceMode]
/// that starts with `equal`. That said, if using heavy color branding,
/// some surfaces may not need any overlay color, so the
/// lack of it might not be an issue with other modes in such themes.
/// For more information about this limitation see Flutter SDK issue:
/// https://github.com/flutter/flutter/issues/90353
final bool applyElevationOverlayColor = true,
/// Components of the [CupertinoThemeData] to override from the Material
/// [ThemeData] adaptation.
///
/// By default, [cupertinoOverrideTheme] is null and Cupertino widgets
/// descendant to the Material [Theme] will adhere to a [CupertinoTheme]
/// derived from the Material [ThemeData]. e.g. [ThemeData]'s [ColorScheme]
/// will also inform the [CupertinoThemeData]'s `primaryColor` etc.
///
/// This cascading effect for individual attributes of the
/// [CupertinoThemeData]
/// can be overridden using attributes of this [cupertinoOverrideTheme].
final NoDefaultCupertinoThemeData? cupertinoOverrideTheme,
/// A temporary flag used to disable Material-3 design and use legacy
/// Material-2 design instead. Material-3 design is the default.
/// Material-2 will be deprecated in Flutter.
///
/// Flutter SDK [useMaterial3] documentation:
/// --------------------------------------------------------
/// A temporary flag that can be used to opt-out of Material 3 features.
///
/// This flag is _true_ by default. If false, then components will
/// continue to use the colors, typography and other features of
/// Material 2.
///
/// In the long run this flag will be deprecated and eventually
/// only Material 3 will be supported. We recommend that applications
/// migrate to Material 3 as soon as that's practical. Until that migration
/// is complete, this flag can be set to false.
///
/// ## Defaults
///
/// If a [ThemeData] is _constructed_ with [useMaterial3] set to true, then
/// some properties will get updated defaults. However, the
/// [ThemeData.copyWith] method with [useMaterial3] set to true will _not_
/// change any of these properties in the resulting [ThemeData].
///
/// <style>table,td,th { border-collapse: collapse; padding: 0.45em; } td { border: 1px solid }</style>
///
/// | Property | Material 3 default | Material 2 default |
/// | :-------------- | :--------------------------- | :------------------ |
/// | [colorScheme] | M3 baseline light scheme | M2 baseline light scheme |
/// | [typography] | [Typography.material2021] | [Typography.material2014] |
/// | [splashFactory] | [InkSparkle]* or [InkRipple] | [InkSplash] |
///
/// \* if the target platform is Android and the app is not
/// running on the web, otherwise it will fallback to [InkRipple].
///
/// If [brightness] is [Brightness.dark] then the default color scheme will
/// be either the M3 baseline dark color scheme or the M2 baseline dark
/// color scheme depending on [useMaterial3].
///
/// ## Affected widgets
///
/// This flag affects styles and components.
///
/// ### Styles
/// * Color: [ColorScheme], [Material] (see table above)
/// * Shape: (see components below)
/// * Typography: [Typography] (see table above)
///
/// ### Components
/// * Badges: [Badge]
/// * Bottom app bar: [BottomAppBar]
/// * Bottom sheets: [BottomSheet]
/// * Buttons
/// - Common buttons: [ElevatedButton], [FilledButton],
/// [FilledButton.tonal], [OutlinedButton], [TextButton]
/// - FAB: [FloatingActionButton], [FloatingActionButton.extended]
/// - Icon buttons: [IconButton], [IconButton.filled] (*new*),
/// [IconButton.filledTonal], [IconButton.outlined]
/// - Segmented buttons: [SegmentedButton] (replacing [ToggleButtons])
/// * Cards: [Card]
/// * Checkbox: [Checkbox], [CheckboxListTile]
/// * Chips:
/// - [ActionChip] (used for Assist and Suggestion chips),
/// - [FilterChip], [ChoiceChip] (used for selection filter chips),
/// - [InputChip]
/// * Date pickers: [showDatePicker], [showDateRangePicker],
/// [DatePickerDialog], [DateRangePickerDialog],
/// [InputDatePickerFormField]
/// * Dialogs: [AlertDialog], [Dialog.fullscreen]
/// * Divider: [Divider], [VerticalDivider]
/// * Lists: [ListTile]
/// * Menus: [MenuAnchor], [DropdownMenu], [MenuBar]
/// * Navigation bar: [NavigationBar] (replacing [BottomNavigationBar])
/// * Navigation drawer: [NavigationDrawer] (replacing [Drawer])
/// * Navigation rail: [NavigationRail]
/// * Progress indicators: [CircularProgressIndicator],
/// [LinearProgressIndicator]
/// * Radio button: [Radio], [RadioListTile]
/// * Search: [SearchBar], [SearchAnchor],
/// * Snack bar: [SnackBar]
/// * Slider: [Slider], [RangeSlider]
/// * Switch: [Switch], [SwitchListTile]
/// * Tabs: [TabBar], [TabBar.secondary]
/// * TextFields: [TextField] together with its [InputDecoration]
/// * Time pickers: [showTimePicker], [TimePickerDialog]
/// * Top app bar: [AppBar], [SliverAppBar], [SliverAppBar.medium],
/// [SliverAppBar.large]
///
/// In addition, this flag enables features introduced in Android 12.
/// * Stretch overscroll: [MaterialScrollBehavior]
/// * Ripple: `splashFactory` (see table above)
///
/// See also:
///
/// * [Material 3 specification](https://m3.material.io/).
final bool useMaterial3 = true,
/// Set to true to automatically swap secondary and tertiary colors, on
/// built-in color schemes when [useMaterial3] is true, that benefit
/// from it to better match the Material 3 color system design intent.
///
/// Starting with FlexColorScheme version 6.1.0, built-in color schemes,
/// defined via [FlexSchemeColor], have a flag [swapOnMaterial3]. When
/// defined to be true, the scheme will benefit if the [secondary] and
/// [tertiary] colors, including their containers, are swapped when using
/// Material 3. Most FlexColorScheme color schemes were designed with
/// M2 usage in mind, before M3 existed. They may often have their
/// [swapOnMaterial3] set to true. If this flag is false, it may mean
/// that its `FlexSchemeColor` was designed for M3 or that it won't
/// benefit from swapping its secondary and tertiary colors. In the
/// [Scheme Reference](https://docs.flexcolorscheme.com/scheme_reference),
/// you can see which schemes have the flag defined to true.
///
/// Using a seed-generated color scheme based on built-in FlexSchemeColor
/// colors is another way to make them suitable for the M3 Color system.
/// However, in some cases, the secondary color in their design may not
/// be in-line with the M3 color system design intent, especially if you
/// use the config that also uses the hue from the secondary color to
/// make tonal palettes for it. In some legacy FlexSchemeColor color
/// designs this can be fixed if we swap the secondary and tertiary colors.
///
/// To make FlexSchemeColor designs color designs that benefit from it
/// automatically swap secondary and tertiary colors when [useMaterial3]
/// is set to true, set `swapLegacyOnMaterial3` to true. It defaults to
/// false, for backward compatibility, but it is recommended to turn
/// it on when using Material 3 and its color system. If you use
/// seeded color schemes with Material 2, [useMaterial3] flag is false,
/// then it may be preferable to keep [swapOnMaterial3] false for more
/// prominent colors on secondaries.
///
/// This color swap has higher priority than [swapColor], using it will
/// always happen on the effective result of [swapLegacyOnMaterial3] and
/// [useMaterial3], and value of [swapOnMaterial3] in currently used
/// built-in scheme [FlexSchemeColor].
///
/// If a custom [colorScheme] is passed in, or any of the direct color
/// properties [secondary], [secondaryContainer], [tertiary] or
/// [tertiaryContainer], then it is assumed a custom scheme or overrides,
/// are being used and the [swapLegacyOnMaterial3] setting does nothing.
///
/// The Themes Playground app defaults to setting [swapLegacyOnMaterial3]
/// to ON (true), but allows you to turn it OFF.
///
/// Defaults to false, for backwards compatibility, but prefer setting it
/// to true if you also set [useMaterial3] to true.
final bool swapLegacyOnMaterial3 = false,
/// Arbitrary additions to this theme.
///
/// This is the same property as [extensions] in ThemeData, it is provided
/// as a convenience pass-through to ThemeData.
///
/// To define extensions, pass an [Iterable] containing one or more
/// [ThemeExtension] subclasses to [ThemeData.new] or [copyWith].
///
/// To obtain an extension, use ThemeData.of(context).extension.
final Iterable<ThemeExtension<dynamic>>? extensions,
/// **Deprecated:**
/// A color that typically appears behind scrollable content.
///
/// The color is applied to [ThemeData.canvasColor] and was also before
/// version 8 applied to `ThemeData.backgroundColor`, which was in the past
/// Material-2 used eg by menu [Drawer]. It was then also used by all
/// [Material] of type [MaterialType.canvas].
///
/// When using the factory this was also an override color for the color
/// that would have been used based on mode defined by property
/// `surfaceMode` enum [FlexSurfaceMode] or if a [colorScheme] was provided,
/// it overrode the same color in it as well.
///
/// Defaults to null.
@Deprecated('Use surface instead. It is deprecated '
'because Flutter 3.22 deprecated this ColorScheme color. '
'It no longer has any function in FCS v8 and will be removed in v9.')
final Color? background,
/// **Deprecated:**
/// A color that is clearly legible when drawn on `background` color.
///
/// To ensure that an app is accessible, a contrast ratio of 4.5:1 for
/// `background` and `onBackground` is recommended.
///
/// When using this factory, this was an override color for the color that
/// would be used based on the corresponding color property defined in
/// [FlexColorScheme.light] and [FlexColorScheme.dark], `colors` property
/// or when using pre-defined color scheme based [FlexScheme] and its
/// `scheme` property, including any used blend logic. If a [colorScheme]
/// was provided with this corresponding color defined, this color property
/// also overrode the same color in it as well.
///
/// You used this property for convenience if you want to override the
/// color that this scheme color gets via the factory behavior.
@Deprecated('Use onSurface instead. It is deprecated '
'because Flutter 3.22 deprecated this ColorScheme color. '
'It no longer has any function in FCS v8 and will be removed in v9.')
final Color? onBackground,
}) {
// LIGHT: Check valid inputs
assert(usedColors >= 1 && usedColors <= 7, 'usedColors must be 1 to 7');
assert(appBarOpacity == null || appBarOpacity >= 0 && appBarOpacity <= 1,
'appBarOpacity must be 0 to 1, or null');
assert(
blendLevel >= 0 && blendLevel <= 40,
'Only blend levels from 0 to 40 are allowed. Very high alpha values may '
'not produce results that are visually very appealing or useful.',
);
assert(appBarElevation == null || appBarElevation >= 0.0,
'AppBar elevation must be >= 0 or null.');
assert(bottomAppBarElevation == null || bottomAppBarElevation >= 0.0,
'Bottom AppBar elevation must be null or must be >= 0.');
// Use color seeding based on passed in keyColors or make one where
// it is not used, if one was not defined, since we want that as default
// behavior to match past default behavior.
final FlexKeyColors seed =
keyColors ?? const FlexKeyColors(useKeyColors: false);
// Fallback value for scheme is default material scheme, based on mode.
final FlexScheme flexScheme = scheme ??
(useMaterial3 ? FlexScheme.materialBaseline : FlexScheme.material);
// If colors was null, we used the scheme based value.
final FlexSchemeColor flexColors =
colors ?? FlexColor.schemesWithCustom[flexScheme]!.light;
// Use sub-themes if a none null FlexSubThemesData was provided.
final bool useSubThemes = subThemesData != null;
// Use passed in sub-theme config data, or a default one, if none given.
final FlexSubThemesData subTheme =
subThemesData ?? const FlexSubThemesData();
// If the passed in property values are not null, or there was a colorScheme
// provided, we will override the colors properties with them. Doing it here
// gets also correct effective and swap behavior on directly passed in
// property values or colorScheme based colors too.
final FlexSchemeColor withPassedColors = flexColors.copyWith(
primary: primary ?? colorScheme?.primary,
primaryContainer: primaryContainer ?? colorScheme?.primaryContainer,
secondary: secondary ?? colorScheme?.secondary,
secondaryContainer: secondaryContainer ?? colorScheme?.secondaryContainer,
tertiary: tertiary ?? colorScheme?.tertiary,
tertiaryContainer: tertiaryContainer ?? colorScheme?.tertiaryContainer,
error: error ?? colorScheme?.error,
errorContainer: errorContainer ?? colorScheme?.errorContainer,
);
// Swap legacy secondary and tertiary color if we use Material 3 and
// we have swapping of legacy colors on and if the colors in used built-in
// scheme has flag [swapOnMaterial3] set that tells it benefits from doing
// this. Additionally we should only do this if we have not passed a custom
// ColorScheme, nor secondary or tertiary colors directly.
final bool swapLegacy = useMaterial3 &&
swapLegacyOnMaterial3 &&
flexColors.swapOnMaterial3 &&
secondary == null &&
secondaryContainer == null &&
tertiary == null &&
tertiaryContainer == null &&
colorScheme == null;
// First cut of effective FlexSchemeColor depends on colors, usedColors
// and swapLegacy and swap. When we use Brightness.light, we also guarantee
// that we have colors on effectiveColors.error and errorContainer, they
// are guaranteed to no longer be null after this call.
FlexSchemeColor effectiveColors = FlexSchemeColor.effective(
withPassedColors,
usedColors,
swapLegacy: swapLegacy,
swapColors: swapColors,
brightness: Brightness.light,
);
// ColorScheme to hold our seeded scheme colors, it will be made null
// if we do not use M3 key based seeded tonal palette ColorScheme.
// However, we need to create it even if we do not use a seeded ColorScheme,
// because we need it for the new Flutter 3.22 fixed and FixedDim colors.
// Those colors are hard to compute without using the seed algo and would
// be wrong.
ColorScheme? seedScheme;
// Compute a seeded scheme if we are using it or seeded fixed colors.
if ((fixedColorStyle ?? FlexFixedColorStyle.computed) !=
FlexFixedColorStyle.computed ||
seed.useKeyColors) {
// Create a complete ColorScheme from active and effective seed colors.
// If config is not using key colors, we are only making this seed for
// the fixed and fixedDim colors, they must always use all key colors.
seedScheme = SeedColorScheme.fromSeeds(
brightness: Brightness.light,
primaryKey: !seed.useKeyColors
? effectiveColors.primary
: seed.keyPrimary ?? effectiveColors.primary,
secondaryKey: !seed.useKeyColors
? effectiveColors.secondary
: seed.useSecondary
? seed.keySecondary ?? effectiveColors.secondary
: null,
tertiaryKey: !seed.useKeyColors
? effectiveColors.tertiary
: seed.useTertiary
? seed.keyTertiary ?? effectiveColors.tertiary
: null,
// If use error seed, use it with fromSeeds, otherwise undefined.
errorKey: seed.useError ? seed.keyError ?? effectiveColors.error : null,
// If a custom surface tint is used, use it also as key for neutral and
// neutral variant tonal palette generation.
neutralKey: surfaceTint,
neutralVariantKey: surfaceTint,
surfaceTint: surfaceTint,
// Use provided tones or variant configuration or default one.
// Ensuring that we always used FlexTones.chroma when only
// seeding for fixed and FixedDim colors, it is the one that will fit
// best with none seeded colors.
tones: seed.useKeyColors
? tones
: FlexTones.chroma(Brightness.light).higherContrastFixed(
fixedColorStyle == FlexFixedColorStyle.seededHighContrast),
variant: seed.useKeyColors ? variant : null,
contrastLevel: seed.useKeyColors ? seed.contrastLevel : 0.0,
useExpressiveOnContainerColors:
seed.useExpressiveOnContainerColors ?? false,
respectMonochromeSeed: !(seed.useLegacyMonochromeSeedBehavior ?? false),
);
// Update effective main colors to seed colors, keeping configured
// effective main color values when so defined.
if (seed.useKeyColors) {
effectiveColors = FlexSchemeColor(
primary:
seed.keepPrimary ? effectiveColors.primary : seedScheme.primary,
primaryContainer: seed.keepPrimaryContainer
? effectiveColors.primaryContainer
: seedScheme.primaryContainer,
secondary: seed.keepSecondary
? effectiveColors.secondary
: seedScheme.secondary,
secondaryContainer: seed.keepSecondaryContainer
? effectiveColors.secondaryContainer
: seedScheme.secondaryContainer,
tertiary: seed.keepTertiary
? effectiveColors.tertiary
: seedScheme.tertiary,
tertiaryContainer: seed.keepTertiaryContainer
? effectiveColors.tertiaryContainer
: seedScheme.tertiaryContainer,
appBarColor: effectiveColors.appBarColor,
error: seed.keepError ? effectiveColors.error : seedScheme.error,
errorContainer: seed.keepErrorContainer
? effectiveColors.errorContainer
: seedScheme.errorContainer,
);
}
}
// Store the seedScheme even if we do not use it, as we need it for
// new Flutter 3.22 fixed and FixedDim color. They are hard to
// compute without using seed algo and would be wrong.
final ColorScheme? schemeForFixedColors = seedScheme;
// If we do not use key colors, we do not need the seedScheme, set it
// back to null, as legacy logic expect it to be null when not used.
if (!seed.useKeyColors) {
seedScheme = null;
}
// Get effective surfaceTint color, also used as blend color for surfaces.
final Color blendColor =
surfaceTint ?? colorScheme?.surfaceTint ?? effectiveColors.primary;
// Compute surface blends, they are also be added to seeded surfaces.
final FlexSchemeSurfaceColors surfaceSchemeColors =
FlexSchemeSurfaceColors.blend(
brightness: Brightness.light,
useMaterial3: useMaterial3,
surfaceMode: surfaceMode ?? FlexSurfaceMode.level,
blendLevel: blendLevel,
schemeColors: effectiveColors,
scaffoldBaseColor: subTheme.scaffoldBackgroundBaseColor,
blendColors: FlexSchemeSurfaceColors(
surface: blendColor,
surfaceDim: blendColor,
surfaceBright: blendColor,
surfaceContainerLowest: blendColor,
surfaceContainerLow: blendColor,
surfaceContainer: blendColor,
surfaceContainerHigh: blendColor,
surfaceContainerHighest: blendColor,
inverseSurface: blendColor,
dialogBackground: blendColor,
scaffoldBackground: blendColor,
),
surfaceColors: seed.useKeyColors
// Using seed colors, starting surfaces are given by generated scheme.
? FlexSchemeSurfaceColors(
surface: seedScheme!.surface,
surfaceDim: seedScheme.surfaceDim,
surfaceBright: seedScheme.surfaceBright,
surfaceContainerLowest: seedScheme.surfaceContainerLowest,
surfaceContainerLow: seedScheme.surfaceContainerLow,
surfaceContainer: seedScheme.surfaceContainer,
surfaceContainerHigh: seedScheme.surfaceContainerHigh,
surfaceContainerHighest: seedScheme.surfaceContainerHighest,
inverseSurface: seedScheme.inverseSurface,
dialogBackground: useMaterial3
? seedScheme.surfaceContainerHigh
: seedScheme.surface,
scaffoldBackground: subTheme.scaffoldBackgroundBaseColor?.color(
seedScheme,
useMaterial3: useMaterial3,
) ??
(useMaterial3
? seedScheme.surfaceContainerLowest
: seedScheme.surface),
)
// Colorscheme surfaces are used as starting point for blended ones.
: colorScheme != null
? FlexSchemeSurfaceColors(
surface: colorScheme.surface,
surfaceDim: colorScheme.surfaceDim,
surfaceBright: colorScheme.surfaceBright,
surfaceContainerLowest: colorScheme.surfaceContainerLowest,
surfaceContainerLow: colorScheme.surfaceContainerLow,
surfaceContainer: colorScheme.surfaceContainer,
surfaceContainerHigh: colorScheme.surfaceContainerHigh,
surfaceContainerHighest: colorScheme.surfaceContainerHighest,
inverseSurface: colorScheme.inverseSurface,
dialogBackground: useMaterial3
? colorScheme.surfaceContainerHigh
: colorScheme.surface,
scaffoldBackground:
subTheme.scaffoldBackgroundBaseColor?.color(
colorScheme,
useMaterial3: useMaterial3,
) ??
(useMaterial3
? colorScheme.surfaceContainerLowest
: colorScheme.surface),
)
: null,
);
// Effective blend level for the onColors.
int onBlendLevel = useSubThemes ? (subTheme.blendOnLevel ?? 0) : 0;
assert(
onBlendLevel >= 0 && onBlendLevel <= 40,
'Only onBlendLevel:s from 0 to 40 '
'are allowed. Very high alpha blend levels may not produce results '
'that are visually very appealing or useful.');
// If above happens in none debug mode, use 0, no blends.
if (onBlendLevel < 0 || onBlendLevel > 40) onBlendLevel = 0;
// Get alpha blend values for used mode, on blend level and brightness,
// used for onContainers and onSurface and onBackground.
final FlexAlphaValues alphaOnValue = useSubThemes
? FlexAlphaValues.getAlphas(
surfaceMode ?? FlexSurfaceMode.level, onBlendLevel)
: const FlexAlphaValues();
// Get alpha blend values for used mode, on blend level and brightness,
// used for onPrimary, onSecondary, onTertiary and onError.
final FlexAlphaValues alphaOnMain = useSubThemes && subTheme.blendOnColors
? FlexAlphaValues.getAlphas(
surfaceMode ?? FlexSurfaceMode.level, onBlendLevel)
: const FlexAlphaValues();
// Determine the input surface.
final Color inputSurface = surface ?? surfaceSchemeColors.surface;
final FlexSchemeOnColors onColors = FlexSchemeOnColors.from(
useMaterial3: useMaterial3,
primary: effectiveColors.primary,
primaryContainer: effectiveColors.primaryContainer,
secondary: effectiveColors.secondary,
secondaryContainer: effectiveColors.secondaryContainer,
tertiary: effectiveColors.tertiary,
tertiaryContainer: effectiveColors.tertiaryContainer,
surface: inputSurface,
surfaceTint: blendColor,
inverseSurface: surfaceSchemeColors.inverseSurface,
error: effectiveColors.error!,
errorContainer: effectiveColors.errorContainer,
onPrimary: onPrimary ??
(seed.useKeyColors && seed.keepPrimary
? null
: seedScheme?.onPrimary) ??
colorScheme?.onPrimary,
onPrimaryContainer: onPrimaryContainer ??
(seed.useKeyColors && seed.keepPrimaryContainer
? null
: seedScheme?.onPrimaryContainer) ??
colorScheme?.onPrimaryContainer,
onSecondary: onSecondary ??
(seed.useKeyColors && seed.keepSecondary
? null
: seedScheme?.onSecondary) ??
colorScheme?.onSecondary,
onSecondaryContainer: onSecondaryContainer ??
(seed.useKeyColors && seed.keepSecondaryContainer
? null
: seedScheme?.onSecondaryContainer) ??
colorScheme?.onSecondaryContainer,
onTertiary: onTertiary ??
(seed.useKeyColors && seed.keepTertiary
? null
: seedScheme?.onTertiary) ??
colorScheme?.onTertiary,
onTertiaryContainer: onTertiaryContainer ??
(seed.useKeyColors && seed.keepTertiaryContainer
? null
: seedScheme?.onTertiaryContainer) ??
colorScheme?.onTertiaryContainer,
onError: onError ??
(seed.useKeyColors && seed.keepError ? null : seedScheme?.onError) ??
colorScheme?.onError,
onErrorContainer: onErrorContainer ??
(seed.useKeyColors && seed.keepErrorContainer
? null
: seedScheme?.onErrorContainer) ??
colorScheme?.onErrorContainer,
onSurface: onSurface ?? seedScheme?.onSurface ?? colorScheme?.onSurface,
onSurfaceVariant:
seedScheme?.onSurfaceVariant ?? colorScheme?.onSurfaceVariant,
onInverseSurface:
seedScheme?.onInverseSurface ?? colorScheme?.onInverseSurface,
primaryAlpha: alphaOnMain.primaryAlpha,
primaryContainerAlpha: alphaOnValue.primaryContainerAlpha,
secondaryAlpha: alphaOnMain.secondaryAlpha,
secondaryContainerAlpha: alphaOnValue.secondaryContainerAlpha,
tertiaryAlpha: alphaOnMain.tertiaryAlpha,
tertiaryContainerAlpha: alphaOnValue.tertiaryContainerAlpha,
surfaceAlpha: alphaOnValue.surfaceAlpha,
inverseSurfaceAlpha: alphaOnValue.inverseSurfaceAlpha,
errorAlpha: alphaOnMain.errorAlpha,
errorContainerAlpha: alphaOnValue.errorContainerAlpha,
);
// Determine effective surface color.
// Surface is used e.g. by Card and bottom appbar.
// If light is white, we make a lighter than normal surface. If not
// light is white, we use provided surface color, or computed one.
final Color effectiveSurfaceColor =
lightIsWhite ? inputSurface.lighten(5) : inputSurface;
final Color effectiveSurfaceDimColor = lightIsWhite
? surfaceSchemeColors.surfaceDim.lighten(5)
: surfaceSchemeColors.surfaceDim;
final Color effectiveSurfaceBrightColor = lightIsWhite
? surfaceSchemeColors.surfaceBright.lighten(5)
: surfaceSchemeColors.surfaceBright;
final Color effectiveSurfaceContainerLowestColor = lightIsWhite
? surfaceSchemeColors.surfaceContainerLowest.lighten(5)
: surfaceSchemeColors.surfaceContainerLowest;
final Color effectiveSurfaceContainerLowColor = lightIsWhite
? surfaceSchemeColors.surfaceContainerLow.lighten(5)
: surfaceSchemeColors.surfaceContainerLow;
final Color effectiveSurfaceContainerColor = lightIsWhite
? surfaceSchemeColors.surfaceContainer.lighten(5)
: surfaceSchemeColors.surfaceContainer;
final Color effectiveSurfaceContainerColorHigh = lightIsWhite
? surfaceSchemeColors.surfaceContainerHigh.lighten(5)
: surfaceSchemeColors.surfaceContainerHigh;
final Color effectiveSurfaceContainerColorHighest = lightIsWhite
? surfaceSchemeColors.surfaceContainerHighest.lighten(5)
: surfaceSchemeColors.surfaceContainerHighest;
final Color effectiveInverseSurfaceColor = lightIsWhite
? surfaceSchemeColors.inverseSurface.darken(5)
: surfaceSchemeColors.inverseSurface;
// Determine effective dialog background color.
// If light is white, we use lighter than normal. If not,
// we use dialog provided background color, or computed one.
// The provided dialog background color overrides factory surface behavior,
// but is impacted by plain white for a lighter effect.
final Color effectiveDialogBackground = lightIsWhite
? dialogBackground?.lighten(5) ??
surfaceSchemeColors.dialogBackground.lighten(5)
: dialogBackground ?? surfaceSchemeColors.dialogBackground;
// Get the effective light ref colors.
final Color effectivePrimaryLightRef =
effectiveColors.primaryLightRef ?? effectiveColors.primary;
final Color effectiveSecondaryLightRef =
effectiveColors.secondaryLightRef ?? effectiveColors.secondary;
final Color effectiveTertiaryLightRef =
effectiveColors.tertiaryLightRef ?? effectiveColors.tertiary;
// Compute the effective ColorScheme based on all selection options.
final ColorScheme effectiveColorScheme = seedScheme?.copyWith(
// Add the locked effective colors back to our SeedScheme.
// Fixes: https://github.com/rydmike/flex_color_scheme/issues/198
primary: effectiveColors.primary,
primaryContainer: effectiveColors.primaryContainer,
secondary: effectiveColors.secondary,
secondaryContainer: effectiveColors.secondaryContainer,
tertiary: effectiveColors.tertiary,
tertiaryContainer: effectiveColors.tertiaryContainer,
error: effectiveColors.error,
errorContainer: effectiveColors.errorContainer,
// We made a seeded color scheme, we use it as given but set
// override values for props we have not handled via FCS direct
// props further below.
surfaceDim: effectiveSurfaceDimColor,
surfaceBright: effectiveSurfaceBrightColor,
surfaceContainerLowest: effectiveSurfaceContainerLowestColor,
surfaceContainerLow: effectiveSurfaceContainerLowColor,
surfaceContainer: effectiveSurfaceContainerColor,
surfaceContainerHigh: effectiveSurfaceContainerColorHigh,
surfaceContainerHighest: effectiveSurfaceContainerColorHighest,
inverseSurface: effectiveInverseSurfaceColor,
surfaceTint: surfaceTint,
) ??
// We had a colorScheme passed in, we use as passed in, but set
// override values for props we do not handle via FCS direct
// props further below.
colorScheme?.copyWith(
onSurfaceVariant: onColors.onSurfaceVariant,
inverseSurface: effectiveInverseSurfaceColor,
onInverseSurface: onColors.onInverseSurface,
surfaceTint: surfaceTint,
) ??
// Values that exist as direct properties in FlexColorScheme, are
// used via them further below, but we need this ColorScheme when
// not seeding to provide the color properties we are not handling
// via FCS main constructor.
ColorScheme(
brightness: Brightness.light,
primary: effectiveColors.primary,
onPrimary: onColors.onPrimary,
primaryContainer: effectiveColors.primaryContainer,
onPrimaryContainer: onColors.onPrimaryContainer,
primaryFixed: schemeForFixedColors?.primaryFixed ??
_fixedColor(effectivePrimaryLightRef),
primaryFixedDim: schemeForFixedColors?.primaryFixedDim ??
_fixedDimColor(effectivePrimaryLightRef),
onPrimaryFixed: schemeForFixedColors?.onPrimaryFixed ??
_onFixedColor(effectivePrimaryLightRef),
onPrimaryFixedVariant: schemeForFixedColors?.onPrimaryFixedVariant ??
_onFixedVariantColor(effectivePrimaryLightRef),
secondary: effectiveColors.secondary,
onSecondary: onColors.onSecondary,
secondaryContainer: effectiveColors.secondaryContainer,
onSecondaryContainer: onColors.onSecondaryContainer,
secondaryFixed: schemeForFixedColors?.secondaryFixed ??
_fixedColor(effectiveSecondaryLightRef),
secondaryFixedDim: schemeForFixedColors?.secondaryFixedDim ??
_fixedDimColor(effectiveSecondaryLightRef),
onSecondaryFixed: schemeForFixedColors?.onSecondaryFixed ??
_onFixedColor(effectiveSecondaryLightRef),
onSecondaryFixedVariant:
schemeForFixedColors?.onSecondaryFixedVariant ??
_onFixedVariantColor(effectiveSecondaryLightRef),
tertiary: effectiveColors.tertiary,
onTertiary: onColors.onTertiary,
tertiaryContainer: effectiveColors.tertiaryContainer,
onTertiaryContainer: onColors.onTertiaryContainer,
tertiaryFixed: schemeForFixedColors?.tertiaryFixed ??
_fixedColor(effectiveTertiaryLightRef),
tertiaryFixedDim: schemeForFixedColors?.tertiaryFixedDim ??
_fixedDimColor(effectiveTertiaryLightRef),
onTertiaryFixed: schemeForFixedColors?.onTertiaryFixed ??
_onFixedColor(effectiveTertiaryLightRef),
onTertiaryFixedVariant:
schemeForFixedColors?.onTertiaryFixedVariant ??
_onFixedVariantColor(effectiveTertiaryLightRef),
error: useMaterial3ErrorColors && !seed.useKeyColors
? FlexColor.material3LightError
: effectiveColors.error!,
onError: useMaterial3ErrorColors && !seed.useKeyColors
? FlexColor.material3LightOnError
: onColors.onError,
errorContainer: useMaterial3ErrorColors && !seed.useKeyColors
? FlexColor.material3LightErrorContainer
: effectiveColors.errorContainer!,
onErrorContainer: useMaterial3ErrorColors && !seed.useKeyColors
? FlexColor.material3LightOnErrorContainer
: onColors.onErrorContainer,
surface: effectiveSurfaceColor,
surfaceDim: effectiveSurfaceDimColor,
surfaceBright: effectiveSurfaceBrightColor,
surfaceContainerLowest: effectiveSurfaceContainerLowestColor,
surfaceContainerLow: effectiveSurfaceContainerLowColor,
surfaceContainer: effectiveSurfaceContainerColor,
surfaceContainerHigh: effectiveSurfaceContainerColorHigh,
surfaceContainerHighest: effectiveSurfaceContainerColorHighest,
onSurface: onColors.onSurface,
onSurfaceVariant: onColors.onSurfaceVariant,
//
outline: _outlineColor(
Brightness.light, blendColor, alphaOnValue.surfaceAlpha),
outlineVariant: _outlineVariantColor(
Brightness.light, blendColor, alphaOnValue.surfaceAlpha),
shadow: Colors.black,
scrim: Colors.black,
inverseSurface: effectiveInverseSurfaceColor,
onInverseSurface: onColors.onInverseSurface,
inversePrimary: _inversePrimary(
Brightness.light, effectiveColors.primary, effectiveSurfaceColor),
surfaceTint: surfaceTint ?? effectiveColors.primary,
);
// Determine the effective scaffold background color.
final Color effectiveScaffoldColor = (useSubThemes &&
subTheme.scaffoldBackgroundSchemeColor != null
? FlexSubThemes.schemeColor(
subTheme.scaffoldBackgroundSchemeColor!, effectiveColorScheme)
: null) ??
scaffoldBackground ??
(lightIsWhite ? Colors.white : surfaceSchemeColors.scaffoldBackground);
// Determine the effective AppBar color:
// - First priority, passed in color value.
Color? effectiveAppBarColor = appBarBackground;
// - Second priority, sub-theme based scheme color.
effectiveAppBarColor ??=
useSubThemes && subTheme.appBarBackgroundSchemeColor != null
? FlexSubThemes.schemeColor(
subTheme.appBarBackgroundSchemeColor!, effectiveColorScheme)
: null;
// Third priority [appBarStyle] based.
if (effectiveAppBarColor == null) {
switch (appBarStyle) {
case FlexAppBarStyle.primary:
effectiveAppBarColor = effectiveColors.primary;
case FlexAppBarStyle.material:
effectiveAppBarColor = FlexColor.materialLightSurface;
case FlexAppBarStyle.surface:
effectiveAppBarColor = effectiveSurfaceColor;
case FlexAppBarStyle.background:
effectiveAppBarColor = effectiveSurfaceContainerLowColor;
case FlexAppBarStyle.scaffoldBackground:
effectiveAppBarColor = effectiveScaffoldColor;
case FlexAppBarStyle.custom:
effectiveAppBarColor =
effectiveColors.appBarColor ?? effectiveColors.primary;
case null:
effectiveAppBarColor =
useMaterial3 ? effectiveSurfaceColor : effectiveColors.primary;
}
}
// As last step apply the factory opacity parameter value.
// The resulting effectiveAppBarColor is never null and always passed to the
// raw FlexColorScheme constructor.
if (appBarOpacity != null) {
effectiveAppBarColor =
effectiveAppBarColor.withValues(alpha: appBarOpacity);
}
// The raw FlexColorScheme(), created by above complex .light factory.
return FlexColorScheme(
colorScheme: effectiveColorScheme,
// This is the light theme factory, always brightness light.
brightness: Brightness.light,
// Primary colors for the application
primary: effectiveColors.primary,
onPrimary: onColors.onPrimary,
primaryContainer: effectiveColors.primaryContainer,
onPrimaryContainer: onColors.onPrimaryContainer,
// The secondary colors for the application.
secondary: effectiveColors.secondary,
secondaryContainer: effectiveColors.secondaryContainer,
onSecondaryContainer: onColors.onSecondaryContainer,
onSecondary: onColors.onSecondary,
// The tertiary colors for the application.
tertiary: effectiveColors.tertiary,
onTertiary: onColors.onTertiary,
tertiaryContainer: effectiveColors.tertiaryContainer,
onTertiaryContainer: onColors.onTertiaryContainer,
// Effective error color and null fallback.
error: useMaterial3ErrorColors && !seed.useKeyColors
? FlexColor.material3LightError
: effectiveColors.error ?? FlexColor.materialLightError,
onError: useMaterial3ErrorColors && !seed.useKeyColors
? FlexColor.material3LightOnError
: onColors.onError,
errorContainer: useMaterial3ErrorColors && !seed.useKeyColors
? FlexColor.material3LightErrorContainer
: effectiveColors.errorContainer,
onErrorContainer: useMaterial3ErrorColors && !seed.useKeyColors
? FlexColor.material3LightOnErrorContainer
: onColors.onErrorContainer,
// Surface color with complex custom options applied.
surface: effectiveSurfaceColor,
onSurface: onColors.onSurface,
// Color of the scaffold background, with complex options applied.
scaffoldBackground: effectiveScaffoldColor,
// Color of dialog background elements, with complex options applied.
dialogBackground: effectiveDialogBackground,
// AppBar background color with its complicated custom options applied.
appBarBackground: effectiveAppBarColor,
surfaceTint: surfaceTint,
tabBarStyle: tabBarStyle,
appBarElevation: appBarElevation,
bottomAppBarElevation: bottomAppBarElevation,
tooltipsMatchBackground: tooltipsMatchBackground,
transparentStatusBar: transparentStatusBar,
visualDensity: visualDensity,
textTheme: textTheme,
primaryTextTheme: primaryTextTheme,
fontFamily: fontFamily,
fontFamilyFallback: fontFamilyFallback,
package: package,
materialTapTargetSize: materialTapTargetSize,
pageTransitionsTheme: pageTransitionsTheme,
splashFactory: splashFactory,
platform: platform,
typography: typography,
applyElevationOverlayColor: applyElevationOverlayColor,
cupertinoOverrideTheme: cupertinoOverrideTheme,
subThemesData: subThemesData,
useMaterial3: useMaterial3,
extensions: extensions,
);
}