Files
alan ef1c120f57 Add the Windows menu, window cycling, edge snapping and size per kind
Phase 4 of docs/plans/floating-windows.md. A bar button lists the app's
windows on every tab (show one, Show all, Minimise all, Close all). Alt+`
and Alt+Shift+` bring the next or previous window to the front. Dropping a
title at the left or right edge fills that half, at the top it maximises.
A new window of a kind opens at the size that kind was last given.
2026-11-11 00:05:16 +00:00

199 lines
6.0 KiB
Dart

import 'dart:convert';
import 'dart:ui';
import 'package:shared_preferences/shared_preferences.dart';
import 'window_entry.dart';
import 'window_kind.dart';
const windowsPreferenceKey = 'pipelines.windows.v1';
/// The most windows and remembered frames saved (and restored).
const int windowStoreMaxWindows = 48;
const int windowStoreMaxFrames = 256;
/// The windows as saved on this device, for every server: the open windows
/// bottom to top, the groups hidden by their chord, and the frames of closed
/// windows by [windowFrameKey]. Identities and geometry only.
class WindowsRecord {
const WindowsRecord({
this.windows = const [],
this.hiddenGroups = const {},
this.frames = const {},
this.sizes = const {},
});
final List<WindowEntry> windows;
final Set<String> hiddenGroups;
final Map<String, Rect> frames;
/// The last size given to a window of each kind.
final Map<String, Size> sizes;
String encode(WindowKinds kinds) => jsonEncode({
'version': 1,
'windows': [
for (final w in windows)
{
'id': w.id,
'kind': w.kind,
'content': w.contentId,
if (w.serverKey != null) 'server': w.serverKey,
'group': w.groupId,
'frame': _encodeRect(w.frame),
if (w.minimized) 'minimized': true,
if (w.maximized) 'maximized': true,
'data': ?kinds[w.kind]?.encodeData(w),
},
],
'hidden_groups': hiddenGroups.toList()..sort(),
'frames': {
for (final MapEntry(:key, :value) in frames.entries)
key: _encodeRect(value),
},
'sizes': {
for (final MapEntry(:key, :value) in sizes.entries)
key: [value.width, value.height],
},
});
/// Null when [source] is not a record. A window of an unregistered kind,
/// or whose kind rejects its data, is dropped; the rest are kept.
static WindowsRecord? decode(String source, WindowKinds kinds) {
if (source.length > 262144) return null;
try {
final data = jsonDecode(source);
if (data is! Map || data['version'] != 1) return null;
final rawWindows = data['windows'];
final rawHidden = data['hidden_groups'] ?? const [];
final rawFrames = data['frames'] ?? const {};
if (rawWindows is! List || rawHidden is! List || rawFrames is! Map) {
return null;
}
if (rawWindows.length > windowStoreMaxWindows ||
rawFrames.length > windowStoreMaxFrames) {
return null;
}
final windows = <WindowEntry>[];
for (final raw in rawWindows) {
final window = _window(raw, kinds);
if (window == null || windows.any((w) => w.id == window.id)) continue;
windows.add(window);
}
final frames = <String, Rect>{};
for (final MapEntry(:key, :value) in rawFrames.entries) {
final rect = _rect(value);
if (key is String && key.length <= 1024 && rect != null) {
frames[key] = rect;
}
}
return WindowsRecord(
windows: windows,
hiddenGroups: {
for (final g in rawHidden)
if (_identity(g, 256)) g as String,
},
frames: frames,
sizes: {
if (data['sizes'] case final Map raw)
for (final MapEntry(:key, :value) in raw.entries)
if (key is String && _identity(key, 64))
if (value case [
final num w,
final num h,
] when w.isFinite && h.isFinite && w > 0 && h > 0)
key: Size(w.toDouble(), h.toDouble()),
},
);
} on Object {
return null;
}
}
static WindowEntry? _window(Object? raw, WindowKinds kinds) {
if (raw is! Map) return null;
final id = raw['id'], kindKey = raw['kind'], content = raw['content'];
final server = raw['server'], group = raw['group'];
final frame = _rect(raw['frame']);
if (!_identity(id, 256) ||
!_identity(kindKey, 64) ||
!_identity(content, 512) ||
(server != null && !_identity(server, 512)) ||
(group != null && !_identity(group, 256)) ||
frame == null) {
return null;
}
final kind = kinds[kindKey as String];
if (kind == null || kind.serverScoped != (server != null)) return null;
final data = kind.decodeData(raw['data']);
if (data == null) return null;
return WindowEntry(
id: id as String,
kind: kindKey,
contentId: content as String,
serverKey: server as String?,
groupId: group as String?,
frame: frame,
minimized: raw['minimized'] == true,
maximized: raw['maximized'] == true,
data: data,
);
}
static List<double> _encodeRect(Rect r) => [r.left, r.top, r.width, r.height];
static Rect? _rect(Object? values) {
if (values is! List ||
values.length != 4 ||
values.any((v) => v is! num || !v.isFinite)) {
return null;
}
final [left, top, width, height] = [
for (final v in values) (v as num).toDouble(),
];
if (width <= 0 || height <= 0) return null;
return Rect.fromLTWH(left, top, width, height);
}
}
bool _identity(Object? value, int limit) =>
value is String &&
value.isNotEmpty &&
value.length <= limit &&
value.trim() == value &&
!value.contains(RegExp(r'[\x00-\x1f\x7f]'));
/// Where the windows are kept. Device-local: one record for every server,
/// each server-scoped window carrying its server's key.
abstract interface class WindowStore {
Future<String?> read();
Future<bool> write(String record);
}
class SharedPreferencesWindowStore implements WindowStore {
const SharedPreferencesWindowStore();
@override
Future<String?> read() async {
try {
return (await SharedPreferences.getInstance()).getString(
windowsPreferenceKey,
);
} on Object {
return null;
}
}
@override
Future<bool> write(String record) async {
try {
return await (await SharedPreferences.getInstance()).setString(
windowsPreferenceKey,
record,
);
} on Object {
return false;
}
}
}