Files
pipelines/app/lib/ui/adaptive/glass_pill.dart
T
alan eed04eceef Glass: subtler frosted look instead of a metallic sheen
Top highlight, rim and shadow are much fainter in both themes, the
highlight fades out sooner (0.55 -> 0.4), the backdrop saturation boost
drops from 1.6 to 1.25 and the fill opacity rises from 0.78 to 0.82.
One backdrop filter per piece and the solid high-contrast piece stay.
2026-11-03 17:11:09 +00:00

156 lines
5.7 KiB
Dart

import 'package:flutter/cupertino.dart';
import 'package:flutter/material.dart';
import 'glass_surface.dart';
/// A frosted-glass piece floating over content: the content behind is
/// blurred and its colour lifted inside the piece's [shape], under a
/// translucent fill in the host's raised surface role (Material
/// `surfaceContainerHigh`, Cupertino `systemGrey5`), a soft highlight along
/// its top, a faint rim over a hairline border, and a soft shadow
/// outside it ([GlassLook], tuned for light and dark fills).
///
/// Under the system's high-contrast setting the fill is solid, nothing is
/// blurred and only the hairline border is drawn. The Cupertino piece uses
/// no Material widget; the Material piece is a transparent [Material] so ink
/// responses inside it show.
///
/// Shared by the segmented top bar and any floating bar (a tab bar) that
/// wants the same pieces.
class GlassPill extends StatelessWidget {
const GlassPill({
super.key,
required this.cupertino,
required this.child,
this.shape = const StadiumBorder(),
this.fill,
});
final bool cupertino;
final Widget child;
final OutlinedBorder shape;
/// Overrides the fill (a dark viewer's pieces); used as given.
final Color? fill;
/// Blur radius of the content behind a piece.
///
/// Under the [fillOpacity] fill, 4 looks the same as a larger radius (the
/// content behind is already an indistinct tint) and stays on the
/// renderer's direct blur path: above about 4, Skia (CanvasKit) downscales,
/// blurs and upscales every piece on every frame content scrolls behind it.
static const double blurSigma = 4;
/// How much of the fill covers the blurred content.
static const double fillOpacity = 0.82;
@override
Widget build(BuildContext context) {
final reveal = GlassReveal.maybeOf(context);
if (reveal == null) return _build(context, 1, child);
// The fill, edge and blur fade in together, and the content with them:
// an opacity layer over the whole piece would hide the content behind
// it from the blur until the fade ends, and the blur would snap on.
final content = FadeTransition(
opacity: reveal,
alwaysIncludeSemantics: true,
child: child,
);
return AnimatedBuilder(
animation: reveal,
builder: (context, _) =>
_build(context, reveal.value.clamp(0.0, 1.0), content),
);
}
Widget _build(BuildContext context, double reveal, Widget child) {
final solid = MediaQuery.maybeHighContrastOf(context) ?? false;
final textDirection = Directionality.maybeOf(context);
final Color base;
final Color edge;
if (cupertino) {
// Grey 5 stays visibly raised over both the black dark canvas and the
// white light canvas; Grey 6 disappears into either one when blurred.
base = CupertinoColors.systemGrey5.resolveFrom(context);
edge = CupertinoColors.separator.resolveFrom(context);
} else {
final scheme = Theme.of(context).colorScheme;
base = scheme.surfaceContainerHigh;
edge = scheme.outlineVariant;
}
final opaque = fill ?? (solid ? base : base.withValues(alpha: fillOpacity));
final color = opaque.withValues(alpha: opaque.a * reveal);
final look = GlassLook.forFill(opaque);
Color faded(Color c, [double by = 1]) =>
c.withValues(alpha: c.a * by * reveal);
final border = shape.copyWith(
side: BorderSide(color: faded(edge, solid ? 1 : 0.6), width: 0.5),
);
Widget content = cupertino
? child
: Material(type: MaterialType.transparency, child: child);
if (!solid) {
// The highlight lies on the fill under the content; the rim is drawn
// over the content (and its ink) so the edge stays clean.
content = CustomPaint(
painter: GlassHighlightPainter(
shape: shape,
color: faded(look.highlight),
textDirection: textDirection,
),
foregroundPainter: GlassRimPainter(
shape: shape,
top: faded(look.rimTop),
bottom: faded(look.rimBottom),
textDirection: textDirection,
),
child: content,
);
}
Widget surface = DecoratedBox(
decoration: ShapeDecoration(color: color, shape: border),
child: content,
);
if (!solid) {
// One filter per piece, clipped to it: the blur and the saturation
// boost are composed into one backdrop read. Pieces under a common
// [BackdropGroup] (a bar's row) share one read of the content behind
// them where the engine supports it (Impeller) instead of one each.
surface = BackdropFilter.grouped(
filter: GlassLook.backdrop(blurSigma * reveal),
child: surface,
);
}
surface = ClipPath(
clipper: ShapeBorderClipper(shape: shape, textDirection: textDirection),
child: surface,
);
if (solid) return surface;
// The shadow falls outside the clip, so it is painted beside it.
return CustomPaint(
painter: GlassShadowPainter(
shape: shape,
color: faded(look.shadow),
textDirection: textDirection,
),
child: surface,
);
}
}
/// Fades in every [GlassPill] below it by [opacity]: its fill, hairline,
/// blur and content together. A piece entering the screen uses it instead of
/// an opacity layer, under which the blur would read nothing behind it.
class GlassReveal extends InheritedWidget {
const GlassReveal({super.key, required this.opacity, required super.child});
final Animation<double> opacity;
static Animation<double>? maybeOf(BuildContext context) =>
context.dependOnInheritedWidgetOfExactType<GlassReveal>()?.opacity;
@override
bool updateShouldNotify(GlassReveal oldWidget) =>
opacity != oldWidget.opacity;
}