8361322fe2
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.
167 lines
5.2 KiB
Dart
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,
|
|
};
|
|
}
|