Files
alan 8361322fe2 Keep floating window moves pixel-stable
Round fitted window frames to whole logical pixels and accumulate drag deltas from the gesture start. This prevents floating-point size noise from rebuilding window content while preserving fractional pointer movement and resizing behavior.
2026-11-11 03:28:34 +00:00

167 lines
5.2 KiB
Dart

import 'dart:ui';
/// Margin a maximised window keeps from the edges of the window area.
const double windowMaximizedMargin = 8;
/// One floating window: what it shows and where. Immutable; the
/// `WindowManager` replaces an entry to change it.
class WindowEntry {
const WindowEntry({
required this.id,
required this.kind,
required this.contentId,
required this.frame,
this.serverKey,
String? groupId,
this.minimized = false,
this.maximized = false,
this.data = const {},
}) : groupId = groupId ?? kind;
/// Unique among all windows on this device.
final String id;
/// The registered `WindowKind.key` that builds this window.
final String kind;
/// What the kind shows: a chat session id, a run id, `terminal`.
final String contentId;
/// The server this window belongs to, or null for a device-wide window
/// (the terminal).
final String? serverKey;
/// Windows shown and hidden together (by a chord); the kind by default.
final String groupId;
/// The saved frame; it is drawn fitted inside the window area.
final Rect frame;
/// Hidden by its minimise button; still listed and shown again with its
/// group.
final bool minimized;
final bool maximized;
/// The kind's own JSON state (see `WindowKind.decodeData`).
final Map<String, Object?> data;
WindowEntry copyWith({
String? contentId,
Rect? frame,
bool? minimized,
bool? maximized,
Map<String, Object?>? data,
}) => WindowEntry(
id: id,
kind: kind,
contentId: contentId ?? this.contentId,
serverKey: serverKey,
groupId: groupId,
frame: frame ?? this.frame,
minimized: minimized ?? this.minimized,
maximized: maximized ?? this.maximized,
data: data ?? this.data,
);
@override
String toString() =>
'WindowEntry($id, $kind:$contentId, server: $serverKey, $frame'
'${minimized ? ', minimized' : ''}${maximized ? ', maximized' : ''})';
}
/// The key a window's frame is remembered under after it closes, so the same
/// content re-opens where it was.
String windowFrameKey(String kind, String? serverKey, String contentId) =>
'$kind\n${serverKey ?? ''}\n$contentId';
/// [rect] moved and shrunk to fit inside [bounds], at least [minSize] where
/// the bounds allow it, on whole logical pixels.
///
/// Whole pixels keep a moved window exactly its size from frame to frame: a
/// `Rect` stores left, top, right and bottom, so shifting a frame by a
/// fractional delta makes its width differ in its last bits, and every widget
/// that reads the window's size (its `MediaQuery`) rebuilds and lays out
/// again on every pointer event.
Rect fitWindowFrame(Rect rect, Size bounds, Size minSize) {
final width = _wholePixel(
rect.width.clamp(minSize.width, double.infinity).clamp(0.0, bounds.width),
minSize.width,
bounds.width,
);
final height = _wholePixel(
rect.height
.clamp(minSize.height, double.infinity)
.clamp(0.0, bounds.height),
minSize.height,
bounds.height,
);
return Rect.fromLTWH(
_wholePixel(
rect.left.clamp(0.0, bounds.width - width),
0,
bounds.width - width,
),
_wholePixel(
rect.top.clamp(0.0, bounds.height - height),
0,
bounds.height - height,
),
width,
height,
);
}
/// [value] rounded to a whole logical pixel and kept within
/// `[minimum, limit]`.
///
/// A fractional [minimum] rounds up, so the whole-pixel size never drops below
/// the minimum the caller asked for; when the limit is too small to hold that,
/// the limit wins.
double _wholePixel(double value, double minimum, double limit) {
final max = limit.floorToDouble();
final min = minimum.ceilToDouble().clamp(0.0, max);
return value.roundToDouble().clamp(min, max);
}
/// Where [entry] is drawn inside [bounds]: fitted, or filling the area less
/// a margin when maximised.
Rect drawnWindowFrame(WindowEntry entry, Size bounds, Size minSize) =>
entry.maximized
? (Offset.zero & bounds).deflate(
windowMaximizedMargin.clamp(0.0, bounds.shortestSide / 2),
)
: fitWindowFrame(entry.frame, bounds, minSize);
/// Where a dragged window snaps when its title is dropped at an edge.
enum WindowSnap { left, right, maximize }
/// How close to an edge of the window area the pointer must be to snap.
const double windowSnapDistance = 6;
/// The snap for a title dropped with the pointer at [pointer] inside
/// [bounds], or null away from the edges.
WindowSnap? windowSnapFor(Offset pointer, Size bounds) {
if (pointer.dy <= windowSnapDistance) return WindowSnap.maximize;
if (pointer.dx <= windowSnapDistance) return WindowSnap.left;
if (pointer.dx >= bounds.width - windowSnapDistance) return WindowSnap.right;
return null;
}
/// The frame of a window snapped to a half of [bounds].
Rect windowSnapRect(WindowSnap snap, Size bounds) {
final area = (Offset.zero & bounds).deflate(
windowMaximizedMargin.clamp(0.0, bounds.shortestSide / 2),
);
final half = (area.width - windowMaximizedMargin) / 2;
return switch (snap) {
WindowSnap.left => Rect.fromLTWH(area.left, area.top, half, area.height),
WindowSnap.right => Rect.fromLTWH(
area.right - half,
area.top,
half,
area.height,
),
WindowSnap.maximize => area,
};
}