169 lines
5.3 KiB
Dart
169 lines
5.3 KiB
Dart
import 'package:flutter/cupertino.dart';
|
|
import 'package:flutter/material.dart';
|
|
|
|
import '../core/api_gateway.dart';
|
|
import '../features/templates/screen.dart';
|
|
import '../features/templates/ui/template_detail.dart'
|
|
show templateDetailBackKey;
|
|
import '../shell/destination.dart';
|
|
import '../shell/shell_bar.dart';
|
|
import '../ui/adaptive/host.dart';
|
|
import '../ui/adaptive/floating_bar_layout.dart';
|
|
import '../ui/adaptive/segmented_bar.dart';
|
|
import '../ui/adaptive/top_bar_notices.dart';
|
|
import '../ui/theme/app_theme.dart';
|
|
import 'app_session.dart';
|
|
import 'connection_status.dart';
|
|
import 'server_endpoint.dart';
|
|
|
|
/// The Back control of the app-level Templates page.
|
|
const templatesPageBackKey = ValueKey<String>('templates-page-back');
|
|
|
|
/// The Templates destination: the landed gallery over the app's shared gateway.
|
|
///
|
|
/// The gallery is rendered in embedded mode and publishes its controls to
|
|
/// this page's one segmented bar (through a [ShellBarScope] the page owns):
|
|
/// the round Back closes the page from the gallery and returns to the gallery
|
|
/// from an open template, and Refresh sits in the actions pill. The same
|
|
/// honest connection states as the other destinations. No socket is opened
|
|
/// here: [session] owns the only connection, and a template read, validate or
|
|
/// create request travels over it.
|
|
///
|
|
/// [onCreated] forwards the server-confirmed detail once, so the caller can
|
|
/// invalidate the Pipelines list. This screen never inserts a row itself.
|
|
class TemplatesDestination extends StatefulWidget {
|
|
const TemplatesDestination({
|
|
super.key,
|
|
required this.session,
|
|
required this.server,
|
|
required this.onBack,
|
|
this.onCreated,
|
|
this.initialKey,
|
|
});
|
|
|
|
final AppSession session;
|
|
final ServerEndpoint server;
|
|
|
|
/// Closes this page and restores the Settings destination underneath.
|
|
final VoidCallback onBack;
|
|
final ValueChanged<JsonMap>? onCreated;
|
|
|
|
/// The template detail the route names, or null for the gallery.
|
|
final String? initialKey;
|
|
|
|
@override
|
|
State<TemplatesDestination> createState() => _TemplatesDestinationState();
|
|
}
|
|
|
|
class _TemplatesDestinationState extends State<TemplatesDestination> {
|
|
final ShellBarRegistry _bar = ShellBarRegistry();
|
|
|
|
@override
|
|
void dispose() {
|
|
_bar.dispose();
|
|
super.dispose();
|
|
}
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
final cupertino = usesCupertinoHost(context);
|
|
final body = ShellBarScope(
|
|
registry: _bar,
|
|
destination: AppDestination.settings,
|
|
child: AnimatedBuilder(
|
|
animation: widget.session,
|
|
builder: (context, _) => _body(cupertino),
|
|
),
|
|
);
|
|
final bar = ListenableBuilder(
|
|
listenable: _bar,
|
|
builder: (context, _) => _segmentedBar(cupertino),
|
|
);
|
|
// The page reaches its top edge: the gallery and an open template scroll
|
|
// behind the bar and pad their own content by its height.
|
|
final page = SafeArea(top: false, bottom: false, child: body);
|
|
if (cupertino) {
|
|
// Plain list rows on the page background, like the other lists; the
|
|
// bar's scrim takes the same colour.
|
|
return CupertinoPageScaffold(
|
|
backgroundColor: AppColors.background,
|
|
navigationBar: _BarSlot(cupertino: true, child: bar),
|
|
child: page,
|
|
);
|
|
}
|
|
return Scaffold(
|
|
extendBodyBehindAppBar: true,
|
|
appBar: _BarSlot(cupertino: false, child: bar),
|
|
body: page,
|
|
);
|
|
}
|
|
|
|
SegmentedBar _segmentedBar(bool cupertino) {
|
|
final spec = _bar.specFor(AppDestination.settings);
|
|
final onDetailBack = spec?.onBack;
|
|
return SegmentedBar(
|
|
cupertino: cupertino,
|
|
leading: onDetailBack != null
|
|
? SegmentedBackButton(
|
|
key: templateDetailBackKey,
|
|
cupertino: cupertino,
|
|
onPressed: onDetailBack,
|
|
)
|
|
: SegmentedBackButton(
|
|
key: templatesPageBackKey,
|
|
cupertino: cupertino,
|
|
onPressed: widget.onBack,
|
|
),
|
|
title: spec?.title ?? 'Templates',
|
|
subtitle: spec?.subtitle,
|
|
actions: spec?.actions ?? const [],
|
|
);
|
|
}
|
|
|
|
Widget _body(bool cupertino) {
|
|
final session = widget.session;
|
|
if (!session.everConnected) {
|
|
return BelowTopBar(
|
|
child: ConnectionGate(
|
|
session: session,
|
|
server: widget.server,
|
|
cupertino: cupertino,
|
|
),
|
|
);
|
|
}
|
|
// A connection banner stays below the bar; the gallery keeps its place.
|
|
return TopBarNotices(
|
|
notices: [
|
|
if (!session.connected)
|
|
ConnectionBanner(session: session, cupertino: cupertino),
|
|
],
|
|
child: TemplatesScreen(
|
|
gateway: session.gateway,
|
|
embedded: true,
|
|
onCreated: widget.onCreated,
|
|
initialKey: widget.initialKey,
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
/// Gives the scaffold a [SegmentedBar]'s size and obstruction while the bar
|
|
/// itself is rebuilt from the published controls.
|
|
class _BarSlot extends StatelessWidget
|
|
implements ObstructingPreferredSizeWidget {
|
|
const _BarSlot({required this.cupertino, required this.child});
|
|
|
|
final bool cupertino;
|
|
final Widget child;
|
|
|
|
@override
|
|
Size get preferredSize =>
|
|
SegmentedBar(cupertino: cupertino, title: '').preferredSize;
|
|
|
|
@override
|
|
bool shouldFullyObstruct(BuildContext context) => false;
|
|
|
|
@override
|
|
Widget build(BuildContext context) => child;
|
|
}
|