fde086cc4a
Review findings F12, F13, F25 and F1 for viewers: the artifact viewer's actions/pager and the Changes pager float as glass pills over content, file facts move to the top bar, graph overlay controls are one glass pill (duplicate fullscreen glyph removed), the image viewer is immersive, and diff/artifact/graph views let content pass behind the bar. Implemented by pipeline run #204 (Terra); its Review stopped after three rejections, the last being an empty glass bar for a single unresolved artifact, which the manager fixed here with a regression test.
330 lines
12 KiB
Dart
330 lines
12 KiB
Dart
import '../../../ui/adaptive/segmented_bar.dart';
|
|
import '../../../ui/input/arrow_key_pager.dart';
|
|
import 'dart:async';
|
|
|
|
import 'package:flutter/cupertino.dart';
|
|
import 'package:flutter/material.dart';
|
|
import 'package:flutter/services.dart';
|
|
|
|
import '../../../ui/navigation/chevron_pager.dart';
|
|
import '../../../ui/adaptive/floating_bar_layout.dart';
|
|
import '../../../ui/adaptive/glass_pill.dart';
|
|
import '../domain/change_kind.dart';
|
|
import '../domain/change_wording.dart';
|
|
import '../domain/file_change.dart';
|
|
import '../domain/unified_patch.dart';
|
|
import 'change_style.dart';
|
|
import 'patch_view.dart';
|
|
import 'raw_patch_view.dart';
|
|
|
|
/// The reusable viewer for one recorded file change: its kind, path, stat,
|
|
/// tags, the rendered or raw unified patch, Copy patch (the server's exact
|
|
/// bytes) and Close. Binary/truncated/mode-only/no-patch entries show an honest
|
|
/// reason instead of a fabricated diff.
|
|
class FileDiffViewer extends StatefulWidget {
|
|
const FileDiffViewer({
|
|
super.key,
|
|
required this.file,
|
|
this.onClose,
|
|
this.floatBehindTopBar = false,
|
|
});
|
|
|
|
final FileChange file;
|
|
|
|
/// Called by the Close control. Defaults to popping the enclosing route.
|
|
final VoidCallback? onClose;
|
|
|
|
/// The full-page presentation clears its floating navigation bar while the
|
|
/// diff content still occupies the page edge behind it.
|
|
final bool floatBehindTopBar;
|
|
|
|
@override
|
|
State<FileDiffViewer> createState() => _FileDiffViewerState();
|
|
}
|
|
|
|
class _FileDiffViewerState extends State<FileDiffViewer> {
|
|
DiffForm _form = DiffForm.rendered;
|
|
bool _copied = false;
|
|
Timer? _copyTimer;
|
|
|
|
@override
|
|
void dispose() {
|
|
_copyTimer?.cancel();
|
|
super.dispose();
|
|
}
|
|
|
|
void _selectForm(DiffForm value) => setState(() => _form = value);
|
|
|
|
Future<void> _copy() async {
|
|
final patch = widget.file.patch;
|
|
if (patch == null) return;
|
|
await Clipboard.setData(ClipboardData(text: patch));
|
|
if (!mounted) return;
|
|
setState(() => _copied = true);
|
|
_copyTimer?.cancel();
|
|
_copyTimer = Timer(const Duration(seconds: 2), () {
|
|
if (mounted) setState(() => _copied = false);
|
|
});
|
|
}
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
final file = widget.file;
|
|
final cupertino = usesCupertino(context);
|
|
final base = DefaultTextStyle.of(context).style;
|
|
final mono = nativeDiffText(base);
|
|
final stat = changeStat(file.added, file.removed);
|
|
final tags = changeEntryTags(file);
|
|
return ConstrainedBox(
|
|
key: const ValueKey('file-diff-viewer'),
|
|
constraints: BoxConstraints(
|
|
maxWidth: 900,
|
|
maxHeight: MediaQuery.sizeOf(context).height * 0.85,
|
|
),
|
|
child: Column(
|
|
mainAxisSize: MainAxisSize.min,
|
|
crossAxisAlignment: CrossAxisAlignment.stretch,
|
|
children: [
|
|
Padding(
|
|
padding: widget.floatBehindTopBar
|
|
? withTopBarClearance(
|
|
context,
|
|
const EdgeInsets.fromLTRB(16, 12, 16, 8),
|
|
)
|
|
: const EdgeInsets.fromLTRB(16, 12, 16, 8),
|
|
child: Row(
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: [
|
|
Expanded(
|
|
child: Semantics(
|
|
container: true,
|
|
header: true,
|
|
excludeSemantics: true,
|
|
label: [
|
|
changeKindTitle(file.kind),
|
|
if (stat.isNotEmpty) stat,
|
|
if (tags.isNotEmpty) tags.join(' · '),
|
|
'for ${file.path}',
|
|
if (file.steps.isNotEmpty)
|
|
'changed by ${file.steps.join(' → ')}',
|
|
if (file.modeChanged && !file.binary)
|
|
'mode ${file.beforeMode ?? ''}→'
|
|
'${file.afterMode ?? ''}',
|
|
].join(', '),
|
|
child: Column(
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: [
|
|
Wrap(
|
|
spacing: 12,
|
|
runSpacing: 4,
|
|
crossAxisAlignment: WrapCrossAlignment.center,
|
|
children: [
|
|
Text(
|
|
changeKindTitle(file.kind),
|
|
style: Theme.of(context).textTheme.titleMedium,
|
|
),
|
|
if (stat.isNotEmpty)
|
|
ChangeStatText(stat, style: mono),
|
|
if (tags.isNotEmpty)
|
|
Text(
|
|
tags.join(' · '),
|
|
style: Theme.of(context).textTheme.bodySmall,
|
|
),
|
|
],
|
|
),
|
|
const SizedBox(height: 4),
|
|
Text(file.path, style: mono),
|
|
if (file.steps.isNotEmpty)
|
|
Text(
|
|
'changed by ${file.steps.join(' → ')}',
|
|
style: Theme.of(context).textTheme.bodySmall,
|
|
),
|
|
if (file.modeChanged && !file.binary)
|
|
Text(
|
|
'mode ${file.beforeMode ?? ''}→'
|
|
'${file.afterMode ?? ''}',
|
|
style: Theme.of(context).textTheme.bodySmall,
|
|
),
|
|
],
|
|
),
|
|
),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
Padding(
|
|
padding: const EdgeInsets.symmetric(horizontal: 16),
|
|
child: Wrap(
|
|
spacing: 8,
|
|
runSpacing: 8,
|
|
crossAxisAlignment: WrapCrossAlignment.center,
|
|
children: [
|
|
if (file.hasPatch)
|
|
LayoutBuilder(
|
|
builder: (context, constraints) {
|
|
// Two native segmented-control segments cannot show both
|
|
// fixed words at 2x text on a narrow host; their menu
|
|
// shows the same labels whole, one per row.
|
|
final control =
|
|
diffFormSegmentsFit(context, constraints.maxWidth)
|
|
? diffFormControl(
|
|
context,
|
|
form: _form,
|
|
onChanged: _selectForm,
|
|
)
|
|
: diffFormMenu(
|
|
context,
|
|
form: _form,
|
|
onChanged: _selectForm,
|
|
);
|
|
return control;
|
|
},
|
|
),
|
|
_scrollsWhenTooWide(
|
|
copyPatchControl(
|
|
context,
|
|
enabled: file.hasPatch,
|
|
copied: _copied,
|
|
onPressed: _copy,
|
|
),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
Divider(
|
|
height: 16,
|
|
color: cupertino
|
|
? CupertinoColors.separator.resolveFrom(context)
|
|
: Theme.of(context).dividerColor,
|
|
),
|
|
Flexible(child: _body(context, mono)),
|
|
],
|
|
),
|
|
);
|
|
}
|
|
|
|
Widget _body(BuildContext context, TextStyle mono) {
|
|
final file = widget.file;
|
|
if (file.binary) return _message(context, binaryDiffMessage);
|
|
if (!file.hasPatch) {
|
|
return _message(context, patchUnavailableReason(file));
|
|
}
|
|
if (_form == DiffForm.raw) {
|
|
return Semantics(
|
|
container: true,
|
|
label: 'Raw patch for ${file.path}',
|
|
value: file.patch,
|
|
child: RawPatchView(patch: file.patch!, style: mono),
|
|
);
|
|
}
|
|
return SingleChildScrollView(
|
|
padding: const EdgeInsets.only(bottom: 16),
|
|
child: PatchView(file: file),
|
|
);
|
|
}
|
|
|
|
Widget _message(BuildContext context, String text) {
|
|
return SingleChildScrollView(
|
|
padding: const EdgeInsets.fromLTRB(16, 8, 16, 16),
|
|
child: Text(text),
|
|
);
|
|
}
|
|
}
|
|
|
|
/// Gives a native control its intrinsic width and lets it scroll sideways when
|
|
/// the dialog is narrower than the control, instead of letting the control clip
|
|
/// or break one of its fixed labels.
|
|
///
|
|
/// The scroll view shrink-wraps when the control already fits, so the action
|
|
/// keeps its usual layout until scaled text or a narrow phone demands more room.
|
|
Widget _scrollsWhenTooWide(Widget control) =>
|
|
SingleChildScrollView(scrollDirection: Axis.horizontal, child: control);
|
|
|
|
/// Open [file] on its own page, as the browser's file view. [files] is the
|
|
/// list it was picked from (the visit's shown files); the page steps through
|
|
/// them with previous/next chevrons at its bottom right.
|
|
Future<void> showFileDiffViewer(
|
|
BuildContext context,
|
|
FileChange file, {
|
|
List<FileChange>? files,
|
|
}) {
|
|
final list = files == null || !files.contains(file) ? [file] : files;
|
|
final page = FileDiffPage(files: list, initialIndex: list.indexOf(file));
|
|
return Navigator.of(context).push<void>(
|
|
usesCupertino(context)
|
|
? CupertinoPageRoute<void>(builder: (_) => page)
|
|
: MaterialPageRoute<void>(builder: (_) => page),
|
|
);
|
|
}
|
|
|
|
/// One recorded file's diff as a page, with the previous and next file of the
|
|
/// list it came from.
|
|
class FileDiffPage extends StatefulWidget {
|
|
const FileDiffPage({super.key, required this.files, this.initialIndex = 0});
|
|
|
|
final List<FileChange> files;
|
|
final int initialIndex;
|
|
|
|
@override
|
|
State<FileDiffPage> createState() => _FileDiffPageState();
|
|
}
|
|
|
|
class _FileDiffPageState extends State<FileDiffPage> {
|
|
late int _index = widget.initialIndex.clamp(0, widget.files.length - 1);
|
|
|
|
void _step(int delta) => setState(() => _index += delta);
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
final cupertino = usesCupertino(context);
|
|
final file = widget.files[_index];
|
|
final name = file.path.split('/').last;
|
|
final count = widget.files.length;
|
|
final viewer = FileDiffViewer(
|
|
key: ValueKey<String>('file-diff-${file.path}'),
|
|
file: file,
|
|
floatBehindTopBar: true,
|
|
);
|
|
final pager = count < 2
|
|
? null
|
|
: ChevronPager(
|
|
key: const ValueKey('file-diff-pager'),
|
|
index: _index,
|
|
count: count,
|
|
previousLabel: 'Previous file',
|
|
nextLabel: 'Next file',
|
|
onPrevious: _index > 0 ? () => _step(-1) : null,
|
|
onNext: _index < count - 1 ? () => _step(1) : null,
|
|
);
|
|
// Left/right arrows step between changed files, like the chevrons.
|
|
final body = ArrowKeyPager(
|
|
onPrevious: _index > 0 ? () => _step(-1) : null,
|
|
onNext: _index < count - 1 ? () => _step(1) : null,
|
|
child: FloatingBarOverlay(
|
|
bar: pager == null
|
|
? const SizedBox.shrink()
|
|
: Align(
|
|
alignment: AlignmentDirectional.centerEnd,
|
|
heightFactor: 1,
|
|
child: Padding(
|
|
padding: const EdgeInsets.all(8),
|
|
child: GlassPill(cupertino: cupertino, child: pager),
|
|
),
|
|
),
|
|
child: viewer,
|
|
),
|
|
);
|
|
if (cupertino) {
|
|
return CupertinoPageScaffold(
|
|
navigationBar: SegmentedBar(cupertino: true, title: name),
|
|
child: Theme(data: hostTextTheme(context), child: body),
|
|
);
|
|
}
|
|
return Scaffold(
|
|
extendBodyBehindAppBar: true,
|
|
appBar: SegmentedBar(cupertino: false, title: name),
|
|
body: body,
|
|
);
|
|
}
|
|
}
|