e4f3ebdcab
Remove the separate minimise control and make the title-bar X hide windows while preserving their state and reachability. Update window behavior documentation and focused tests for chat, terminal, and window layering.
158 lines
4.5 KiB
Dart
158 lines
4.5 KiB
Dart
import 'package:flutter/material.dart';
|
|
|
|
import '../../shell/windows/window_entry.dart';
|
|
import '../../shell/windows/window_kind.dart';
|
|
import '../../shell/windows/window_manager.dart';
|
|
import 'terminal_body.dart';
|
|
import 'terminal_hub.dart';
|
|
import 'terminal_layout.dart';
|
|
import 'terminal_tab_strip.dart';
|
|
|
|
const terminalWindowKind = 'terminal';
|
|
const _terminalContent = 'terminal';
|
|
|
|
/// The terminal's floating mode as a window of the app's window system. The
|
|
/// terminal has one window, for the device (not a server); its tabs and
|
|
/// shells live in the [TerminalHub], so closing the window loses nothing.
|
|
///
|
|
/// [TerminalLayout] stays the terminal's own state (shown, panel or float):
|
|
/// showing it in float mode opens or shows the window, hiding minimises it,
|
|
/// and the window's X (minimise) hides the terminal.
|
|
class TerminalWindows {
|
|
TerminalWindows({
|
|
required this.manager,
|
|
required this.hub,
|
|
required this.layout,
|
|
});
|
|
|
|
final WindowManager manager;
|
|
final TerminalHub hub;
|
|
final TerminalLayout layout;
|
|
late final TerminalWindowKind kind = TerminalWindowKind(hub, layout);
|
|
|
|
bool _started = false;
|
|
bool _ready = false;
|
|
bool _wide = true;
|
|
bool _syncing = false;
|
|
|
|
/// Registers the kind. Call before the manager restores, and [ready]
|
|
/// after it has, so opening the window never races the saved windows.
|
|
void start() {
|
|
if (_started) return;
|
|
_started = true;
|
|
manager.kinds.register(kind);
|
|
layout.addListener(sync);
|
|
manager.addListener(_windowsChanged);
|
|
}
|
|
|
|
/// The manager has restored its saved windows.
|
|
void ready() {
|
|
_ready = true;
|
|
sync();
|
|
}
|
|
|
|
void dispose() {
|
|
if (!_started) return;
|
|
_started = false;
|
|
layout.removeListener(sync);
|
|
manager.removeListener(_windowsChanged);
|
|
manager.kinds.unregister(terminalWindowKind);
|
|
}
|
|
|
|
/// Whether the app is wide enough for the window (a narrow app shows the
|
|
/// terminal as a page instead).
|
|
set wide(bool value) {
|
|
if (_wide == value) return;
|
|
_wide = value;
|
|
sync();
|
|
}
|
|
|
|
WindowEntry? get entry => manager.find(terminalWindowKind, _terminalContent);
|
|
|
|
bool get _wanted =>
|
|
layout.visible && layout.mode == TerminalMode.float && _wide;
|
|
|
|
/// Makes the window follow the layout.
|
|
void sync() {
|
|
if (!_started || !_ready || _syncing) return;
|
|
_syncing = true;
|
|
try {
|
|
final entry = this.entry;
|
|
if (_wanted) {
|
|
if (entry == null) {
|
|
_open();
|
|
} else if (!manager.isVisible(entry) ||
|
|
manager.active?.id != entry.id) {
|
|
manager.show(entry.id);
|
|
}
|
|
} else if (entry != null) {
|
|
if (layout.mode != TerminalMode.float) {
|
|
manager.close(entry.id);
|
|
} else if (manager.isVisible(entry)) {
|
|
manager.setMinimized(entry.id, true);
|
|
}
|
|
}
|
|
} finally {
|
|
_syncing = false;
|
|
}
|
|
}
|
|
|
|
/// The first window takes the frame and maximised state the terminal's own
|
|
/// layout saved before windows existed (`pipelines.terminal-layout.v1`).
|
|
void _open() {
|
|
final legacy =
|
|
manager.lastFrame(terminalWindowKind, _terminalContent) == null;
|
|
final entry = manager.open(
|
|
terminalWindowKind,
|
|
_terminalContent,
|
|
frame: legacy ? layout.floatRect : null,
|
|
);
|
|
if (legacy && layout.maximized) manager.setMaximized(entry.id, true);
|
|
}
|
|
|
|
/// The window's X or Minimise (or the windows' own show and hide)
|
|
/// hides the terminal.
|
|
void _windowsChanged() {
|
|
if (!_started || !_ready || _syncing || !_wanted) return;
|
|
final entry = this.entry;
|
|
if (entry == null || !manager.isVisible(entry)) layout.hide();
|
|
}
|
|
}
|
|
|
|
/// The terminal in a floating window: its tabs and the selected terminal.
|
|
class TerminalWindowKind extends WindowKind {
|
|
TerminalWindowKind(this.hub, this.layout);
|
|
|
|
final TerminalHub hub;
|
|
final TerminalLayout layout;
|
|
|
|
@override
|
|
String get key => terminalWindowKind;
|
|
@override
|
|
bool get serverScoped => false;
|
|
@override
|
|
IconData get icon => Icons.terminal;
|
|
@override
|
|
Size get minSize => terminalFloatMinSize;
|
|
@override
|
|
Rect get defaultFrame => terminalFloatDefaultRect;
|
|
@override
|
|
Listenable get changes => hub;
|
|
|
|
@override
|
|
String title(BuildContext context, WindowEntry entry) =>
|
|
hub.selected?.title ?? 'Terminal';
|
|
|
|
@override
|
|
Widget build(BuildContext context, WindowEntry entry) => ListenableBuilder(
|
|
listenable: Listenable.merge([hub, layout]),
|
|
builder: (context, _) => Column(
|
|
crossAxisAlignment: CrossAxisAlignment.stretch,
|
|
children: [
|
|
TerminalTabStrip(hub: hub, layout: layout),
|
|
Expanded(child: TerminalBody(hub: hub)),
|
|
],
|
|
),
|
|
);
|
|
}
|