FThemeData.lerp constructor

FThemeData.lerp(FThemeData a, FThemeData b, double t)

Creates a linear interpolation between two FThemeData using the given factor t.

Implementation

factory FThemeData.lerp(FThemeData a, FThemeData b, double t) => .new(
  debugLabel: t < 0.5 ? a.debugLabel : b.debugLabel,
  breakpoints: t < 0.5 ? a.breakpoints : b.breakpoints,
  colors: .lerp(a.colors, b.colors, t),
  typography: .lerp(a.typography, b.typography, t),
  style: a.style.lerp(b.style, t),
  accordionStyle: a.accordionStyle.lerp(b.accordionStyle, t),
  autocompleteStyle: a.autocompleteStyle.lerp(b.autocompleteStyle, t),
  alertStyles: FVariants.lerpWhereUsing(
    a.alertStyles,
    b.alertStyles,
    t,
    (a, b, t) => a!.lerp(b!, t),
    (base, variants) => FAlertStyles(.raw(base, variants)),
  ),
  avatarStyle: a.avatarStyle.lerp(b.avatarStyle, t),
  badgeStyles: FVariants.lerpWhereUsing(
    a.badgeStyles,
    b.badgeStyles,
    t,
    (a, b, t) => a!.lerp(b!, t),
    (base, variants) => FBadgeStyles(.raw(base, variants)),
  ),
  bottomNavigationBarStyle: a.bottomNavigationBarStyle.lerp(b.bottomNavigationBarStyle, t),
  breadcrumbStyle: a.breadcrumbStyle.lerp(b.breadcrumbStyle, t),
  buttonStyles: FVariants.lerpWhereUsing(a.buttonStyles, b.buttonStyles, t, (a, b, t) {
    if (a == null) {
      return b;
    }

    if (b == null) {
      return a;
    }

    return FButtonSizeStyles(
      FVariants.lerpWhere(a, b, t, (a, b, t) {
        if (a == null) {
          return b;
        }

        if (b == null) {
          return a;
        }

        return a.lerp(b, t);
      }),
    );
  }, (base, variants) => FButtonStyles(.raw(base, variants))),

  calendarStyle: a.calendarStyle.lerp(b.calendarStyle, t),

  cardStyle: a.cardStyle.lerp(b.cardStyle, t),

  checkboxStyle: a.checkboxStyle.lerp(b.checkboxStyle, t),

  circularProgressStyle: a.circularProgressStyle.lerp(b.circularProgressStyle, t),

  dateFieldStyle: a.dateFieldStyle.lerp(b.dateFieldStyle, t),

  determinateProgressStyle: a.determinateProgressStyle.lerp(b.determinateProgressStyle, t),

  dialogRouteStyle: a.dialogRouteStyle.lerp(b.dialogRouteStyle, t),

  dialogStyle: a.dialogStyle.lerp(b.dialogStyle, t),

  dividerStyles: FVariants.lerpWhereUsing(
    a.dividerStyles,
    b.dividerStyles,
    t,
    (a, b, t) => a!.lerp(b!, t),
    (base, variants) => FDividerStyles(.raw(base, variants)),
  ),
  headerStyles: FVariants.lerpWhereUsing(
    a.headerStyles,
    b.headerStyles,
    t,
    (a, b, t) => a!.lerp(b!, t),
    (base, variants) => FHeaderStyles(.raw(base, variants)),
  ),
  itemStyles: FVariants.lerpWhereUsing(
    a.itemStyles,
    b.itemStyles,
    t,
    (a, b, t) => a!.lerp(b!, t),
    (base, variants) => FItemStyles(.raw(base, variants)),
  ),
  itemGroupStyle: a.itemGroupStyle.lerp(b.itemGroupStyle, t),
  labelStyles: a.labelStyles.lerp(b.labelStyles, t),
  lineCalendarStyle: a.lineCalendarStyle.lerp(b.lineCalendarStyle, t),
  multiSelectStyle: a.multiSelectStyle.lerp(b.multiSelectStyle, t),
  modalSheetStyle: a.modalSheetStyle.lerp(b.modalSheetStyle, t),
  paginationStyle: a.paginationStyle.lerp(b.paginationStyle, t),
  persistentSheetStyle: a.persistentSheetStyle.lerp(b.persistentSheetStyle, t),
  pickerStyle: a.pickerStyle.lerp(b.pickerStyle, t),
  popoverStyle: a.popoverStyle.lerp(b.popoverStyle, t),
  popoverMenuStyle: a.popoverMenuStyle.lerp(b.popoverMenuStyle, t),
  progressStyle: a.progressStyle.lerp(b.progressStyle, t),
  radioStyle: a.radioStyle.lerp(b.radioStyle, t),
  resizableStyles: FVariants.lerpWhereUsing(
    a.resizableStyles,
    b.resizableStyles,
    t,
    (a, b, t) => a!.lerp(b!, t),
    (base, variants) => FResizableStyles(.raw(base, variants)),
  ),
  scaffoldStyle: a.scaffoldStyle.lerp(b.scaffoldStyle, t),
  selectStyle: a.selectStyle.lerp(b.selectStyle, t),
  selectGroupStyle: a.selectGroupStyle.lerp(b.selectGroupStyle, t),
  selectMenuTileStyle: a.selectMenuTileStyle.lerp(b.selectMenuTileStyle, t),
  sidebarStyle: a.sidebarStyle.lerp(b.sidebarStyle, t),
  sliderStyles: FVariants.lerpWhereUsing(
    a.sliderStyles,
    b.sliderStyles,
    t,
    (a, b, t) => a!.lerp(b!, t),
    (base, variants) => FSliderStyles(.raw(base, variants)),
  ),
  toasterStyle: a.toasterStyle.lerp(b.toasterStyle, t),
  switchStyle: a.switchStyle.lerp(b.switchStyle, t),
  tabsStyle: a.tabsStyle.lerp(b.tabsStyle, t),
  tappableStyle: a.tappableStyle.lerp(b.tappableStyle, t),
  textFieldStyle: a.textFieldStyle.lerp(b.textFieldStyle, t),
  tileStyles: FVariants.lerpWhereUsing(
    a.tileStyles,
    b.tileStyles,
    t,
    (a, b, t) => a!.lerp(b!, t),
    (base, variants) => FTileStyles(.raw(base, variants)),
  ),
  tileGroupStyle: a.tileGroupStyle.lerp(b.tileGroupStyle, t),
  timeFieldStyle: a.timeFieldStyle.lerp(b.timeFieldStyle, t),
  timePickerStyle: a.timePickerStyle.lerp(b.timePickerStyle, t),
  tooltipStyle: a.tooltipStyle.lerp(b.tooltipStyle, t),
  // Copied from Flutter's [ThemeData].
  extensions: (a._extensions.map(
    (id, extensionA) => MapEntry(id, extensionA.lerp(b._extensions[id], t)),
  )..addEntries(b._extensions.entries.where((entry) => !a._extensions.containsKey(entry.key)))).values,
);