A modern terminal with a built-in multiplexer: close it and your sessions keep running. Run shells and tons of AI agents across your machines, then pick them up from desktop, browser, TUI and more. Written in Rust with no UI framework: interface drawn straight on the GPU. No Electron, GPUI or webview.
Rust agentagent-orchestrationaiai-agentsclaude-codecodexcoding-agentlinuxmacosmultiplayermultiplexerrustterminalterminal-emulatorterminal-multiplexertmuxtuiweztermwindows
feat(gui): add editable window-local recording masks
RoversX97331ff71559
diff --git a/docs/thinkterm/recording-overlay.md b/docs/thinkterm/recording-overlay.mdnew file mode 100644index 00000000..96a3b912--- /dev/null+++ b/docs/thinkterm/recording-overlay.md@@ -0,0 +1,22 @@+# Recording masks++Right-click a terminal and choose **Edit Recording Masks…**. If a terminal+application captures the mouse, hold the mouse-reporting bypass modifier+(Shift by default) while right-clicking.++- The floating toolbar starts near the bottom of the window. Drag its top handle+ or the gaps between buttons to move it.+- Drag an empty area to add an opaque black rectangle.+- Drag a rectangle to move it, or drag its lower-right handle to resize it.+- Use **Delete Selected** or Backspace/Delete to remove the selected rectangle.+- Choose **Done** or press Escape to keep the masks and resume normal terminal input.+- Reopen **Edit Recording Masks…** to adjust them, or choose **Clear Recording Masks**+ from the terminal context menu to remove them all.++The canvas is transparent outside the masks. Masks stay at fixed window positions;+they do not follow text when the terminal scrolls. They belong to the current window+and are discarded when it closes. Up to 64 masks can be added.++This is a visual cover for screen recording. Terminal contents, clipboard copies,+logs, and remote clients retain the original text. Check the recording preview+after changing the window layout or scrolling sensitive content.diff --git a/thinkterm-i18n/i18n/de-DE.ftl b/thinkterm-i18n/i18n/de-DE.ftlindex 715dbb81..0a0f2e0a 100644--- a/thinkterm-i18n/i18n/de-DE.ftl+++ b/thinkterm-i18n/i18n/de-DE.ftl@@ -307,6 +307,14 @@ menu-move-tab-right = Tab nach rechts verschiebenmenu-new-terminal-tab-right = Neuer Terminal-Tab rechtsmenu-zoom-pane = Pane vergrößernmenu-copy = Kopieren+menu-edit-recording-overlay = Aufnahme-Masken bearbeiten…+menu-clear-recording-overlay = Aufnahme-Masken löschen+recording-overlay-done = Fertig (Esc)+recording-overlay-delete = Auswahl löschen+recording-overlay-clear = Alle löschen+recording-overlay-hint = Zum Hinzufügen freie Fläche ziehen · Maske ziehen zum Verschieben · Unten rechts Größe ändern+recording-overlay-limit = 64 Masken erreicht · Zum Hinzufügen eine Maske löschen+recording-overlay-drag-toolbar = Leiste am Griff verschiebenmenu-paste = Einfügenmenu-cut = Ausschneidenmenu-delete = Löschendiff --git a/thinkterm-i18n/i18n/en-US.ftl b/thinkterm-i18n/i18n/en-US.ftlindex 36daaa20..acf0a873 100644--- a/thinkterm-i18n/i18n/en-US.ftl+++ b/thinkterm-i18n/i18n/en-US.ftl@@ -307,6 +307,14 @@ menu-move-tab-right = Move Tab Rightmenu-new-terminal-tab-right = New Terminal Tab to Rightmenu-zoom-pane = Zoom Panemenu-copy = Copy+menu-edit-recording-overlay = Edit Recording Masks…+menu-clear-recording-overlay = Clear Recording Masks+recording-overlay-done = Done (Esc)+recording-overlay-delete = Delete Selected+recording-overlay-clear = Clear All+recording-overlay-hint = Drag empty space to add · Drag a mask to move · Drag its lower-right corner to resize+recording-overlay-limit = 64 masks reached · Delete a mask to add another+recording-overlay-drag-toolbar = Drag the handle to move the toolbarmenu-paste = Pastemenu-cut = Cutmenu-delete = Deletediff --git a/thinkterm-i18n/i18n/fr-FR.ftl b/thinkterm-i18n/i18n/fr-FR.ftlindex ca5e9be5..237ce96e 100644--- a/thinkterm-i18n/i18n/fr-FR.ftl+++ b/thinkterm-i18n/i18n/fr-FR.ftl@@ -307,6 +307,14 @@ menu-move-tab-right = Déplacer l’onglet à droitemenu-new-terminal-tab-right = Nouvel onglet de terminal à droitemenu-zoom-pane = Agrandir le voletmenu-copy = Copier+menu-edit-recording-overlay = Modifier les masques d’enregistrement…+menu-clear-recording-overlay = Effacer les masques d’enregistrement+recording-overlay-done = Terminé (Échap)+recording-overlay-delete = Supprimer la sélection+recording-overlay-clear = Tout effacer+recording-overlay-hint = Glisser sur une zone vide pour ajouter · Déplacer un masque · Redimensionner par le coin inférieur droit+recording-overlay-limit = Limite de 64 masques · Supprimez un masque pour en ajouter un+recording-overlay-drag-toolbar = Déplacer la barre par sa poignéemenu-paste = Collermenu-cut = Coupermenu-delete = Supprimerdiff --git a/thinkterm-i18n/i18n/ja-JP.ftl b/thinkterm-i18n/i18n/ja-JP.ftlindex 45a23ec5..3fc16af6 100644--- a/thinkterm-i18n/i18n/ja-JP.ftl+++ b/thinkterm-i18n/i18n/ja-JP.ftl@@ -298,6 +298,14 @@ menu-move-tab-right = タブを右へ移動menu-new-terminal-tab-right = 右側に新しいターミナルタブmenu-zoom-pane = ペインを拡大menu-copy = コピー+menu-edit-recording-overlay = 録画用のマスクを編集…+menu-clear-recording-overlay = 録画用のマスクを消去+recording-overlay-done = 完了(Esc)+recording-overlay-delete = 選択を削除+recording-overlay-clear = すべて消去+recording-overlay-hint = 空白をドラッグして追加 · マスクをドラッグして移動 · 右下をドラッグしてサイズ変更+recording-overlay-limit = 上限の64個に達しました · 追加するにはマスクを削除してください+recording-overlay-drag-toolbar = ハンドルをドラッグしてツールバーを移動menu-paste = ペーストmenu-cut = カットmenu-delete = 削除diff --git a/thinkterm-i18n/i18n/zh-CN.ftl b/thinkterm-i18n/i18n/zh-CN.ftlindex 611a8b22..03bbd1d0 100644--- a/thinkterm-i18n/i18n/zh-CN.ftl+++ b/thinkterm-i18n/i18n/zh-CN.ftl@@ -298,6 +298,14 @@ menu-move-tab-right = 标签页右移menu-new-terminal-tab-right = 在右侧新建终端标签页menu-zoom-pane = 放大窗格menu-copy = 复制+menu-edit-recording-overlay = 编辑录屏遮挡…+menu-clear-recording-overlay = 清除录屏遮挡+recording-overlay-done = 完成(Esc)+recording-overlay-delete = 删除选中+recording-overlay-clear = 全部清除+recording-overlay-hint = 拖动空白处添加 · 拖动遮挡块移动 · 拖动右下角调整大小+recording-overlay-limit = 已达到 64 块上限 · 删除一块后可继续添加+recording-overlay-drag-toolbar = 拖动把手移动工具条menu-paste = 粘贴menu-cut = 剪切menu-delete = 删除diff --git a/wezterm-gui/src/termwindow/keyevent.rs b/wezterm-gui/src/termwindow/keyevent.rsindex 56f310cb..8c1d6d16 100644--- a/wezterm-gui/src/termwindow/keyevent.rs+++ b/wezterm-gui/src/termwindow/keyevent.rs@@ -830,7 +830,7 @@ impl super::TermWindow {// behind it. Placed after the modifier/LED bookkeeping so status-line// state stays current; not marking the event handled lets the cooked// KeyEvent still arrive, where the palette's dispatch consumes it.- if self.command_palette.is_some() {+ if self.command_palette.is_some() || self.recording_overlay.owns_keyboard() {return;}// The Settings-picked palette hotkey must also beat the RAW binding@@ -1029,6 +1029,9 @@ impl super::TermWindow {}pub fn key_event_impl(&mut self, window_key: KeyEvent, context: &dyn WindowOps) {+ if self.recording_overlay_key(&window_key, context) {+ return;+ }// A transition owns the window: what is on screen is a recording, not// anything that can answer. Swallowing here rather than routing to the// terminal is the difference between a keystroke landing in a pane thediff --git a/wezterm-gui/src/termwindow/mod.rs b/wezterm-gui/src/termwindow/mod.rsindex a8b59f67..6d2808b6 100644--- a/wezterm-gui/src/termwindow/mod.rs+++ b/wezterm-gui/src/termwindow/mod.rs@@ -626,6 +626,8 @@ pub(crate) enum NoteEditorCommand {#[derive(Clone, Debug)]pub(crate) enum ContextMenuApplicationAction {Note(NoteEditorCommand),+ EditRecordingOverlay,+ ClearRecordingOverlay,/// One entry of the Remote Hosts page's card menu, carrying the host it/// was raised on. An owned id rather than a list index: the page's/// filtered list can change between building the menu and choosing from@@ -2568,6 +2570,7 @@ pub struct TermWindow {ui_items: Vec<UIItem>,context_menu: Option<ui::context_menu::ContextMenuState>,+ recording_overlay: ui::recording_overlay::RecordingOverlay,command_palette: Option<ui::command_palette::CommandPaletteState>,/// The contrast floor text is held to, or `None` to leave the/// application's colours alone. Resolved from the settings window's@@ -3710,6 +3713,7 @@ impl TermWindow {}if self.focused.is_none() {+ self.recording_overlay.cancel_interaction();self.workspace_sidebar_swipe.cancel_immediately();self.workspace_sidebar_hover.cancel_immediately();self.clear_workspace_space_swipe_frame_transition();@@ -4164,6 +4168,7 @@ impl TermWindow {semantic_zones: HashMap::new(),ui_items: vec![],context_menu: None,+ recording_overlay: Default::default(),command_palette: None,text_min_contrast: crate::native_settings::text_min_contrast_ratio(&config),min_contrast_memo: RefCell::new(HashMap::new()),diff --git a/wezterm-gui/src/termwindow/mouseevent.rs b/wezterm-gui/src/termwindow/mouseevent.rsindex 975156b2..1be0a550 100644--- a/wezterm-gui/src/termwindow/mouseevent.rs+++ b/wezterm-gui/src/termwindow/mouseevent.rs@@ -1826,6 +1826,9 @@ impl super::TermWindow {pub fn mouse_event_impl(&mut self, event: MouseEvent, context: &dyn WindowOps) {log::trace!("{:?}", event);+ if self.recording_overlay_mouse(&event, context) {+ return;+ }// See `key_event_impl`: nothing on screen during a transition is live,// including the card layout a click would be aiming at, which is still// moving.@@ -8141,6 +8144,18 @@ impl super::TermWindow {ContextMenuIcon::Paste,KeyAssignment::PasteFrom(ClipboardPasteSource::Clipboard),),+ self.context_menu_application_item_with_icon(+ crate::i18n::tr("menu-edit-recording-overlay"),+ ContextMenuIcon::Terminal,+ crate::termwindow::ContextMenuApplicationAction::EditRecordingOverlay,+ true,+ ),+ self.context_menu_application_item_with_icon(+ crate::i18n::tr("menu-clear-recording-overlay"),+ ContextMenuIcon::Refresh,+ crate::termwindow::ContextMenuApplicationAction::ClearRecordingOverlay,+ !self.recording_overlay.is_empty(),+ ),ContextMenuItem::Separator,split_item(crate::i18n::tr("menu-split-right"),@@ -8692,11 +8707,16 @@ impl super::TermWindow {}if allow_action- && matches!(event.kind, WMEK::Release(MousePress::Right))- && !pane.is_mouse_grabbed()+ && matches!(event.kind, WMEK::Press(MousePress::Right) | WMEK::Release(MousePress::Right))+ && (!pane.is_mouse_grabbed()+ || event.modifiers.contains(self.config.bypass_mouse_reporting_modifiers)){- let items = self.terminal_context_menu_items();- self.show_term_context_menu(context, event.coords, items);+ // Own both halves of the click so the terminal application never+ // receives a press whose release opens our menu instead.+ if matches!(event.kind, WMEK::Release(MousePress::Right)) {+ let items = self.terminal_context_menu_items();+ self.show_term_context_menu(context, event.coords, items);+ }return;}diff --git a/wezterm-gui/src/termwindow/render/paint.rs b/wezterm-gui/src/termwindow/render/paint.rsindex c6e99d80..028c8f4f 100644--- a/wezterm-gui/src/termwindow/render/paint.rs+++ b/wezterm-gui/src/termwindow/render/paint.rs@@ -4373,6 +4373,11 @@ impl crate::TermWindow {// Last, so the tag sits above every chrome surface it might overhang.self.paint_hover_tooltip().context("paint_hover_tooltip")?;+ // Window-space masks are composited last and never baked into a+ // terminal/overview capture, so content transitions cannot move them.+ self.paint_recording_overlay()+ .context("paint_recording_overlay")?;+Ok(())}}diff --git a/wezterm-gui/src/termwindow/ui/context_menu.rs b/wezterm-gui/src/termwindow/ui/context_menu.rsindex 71af7c59..6c2599df 100644--- a/wezterm-gui/src/termwindow/ui/context_menu.rs+++ b/wezterm-gui/src/termwindow/ui/context_menu.rs@@ -224,6 +224,15 @@ impl crate::TermWindow {return;};match action {+ crate::termwindow::ContextMenuApplicationAction::EditRecordingOverlay => {+ self.start_recording_overlay_edit();+ }+ crate::termwindow::ContextMenuApplicationAction::ClearRecordingOverlay => {+ self.recording_overlay.clear();+ if let Some(window) = &self.window {+ window.invalidate();+ }+ }crate::termwindow::ContextMenuApplicationAction::Note(command) => {self.perform_right_sidebar_note_command(command);}diff --git a/wezterm-gui/src/termwindow/ui/mod.rs b/wezterm-gui/src/termwindow/ui/mod.rsindex 0c5500f2..40add428 100644--- a/wezterm-gui/src/termwindow/ui/mod.rs+++ b/wezterm-gui/src/termwindow/ui/mod.rs@@ -5,6 +5,7 @@ pub mod folder_problem;pub mod icons;pub mod platform_chrome;pub mod right_sidebar;+pub mod recording_overlay;pub mod sidebar;pub mod status_icon;pub mod tokens;diff --git a/wezterm-gui/src/termwindow/ui/recording_overlay.rs b/wezterm-gui/src/termwindow/ui/recording_overlay.rsnew file mode 100644index 00000000..b50c6c2b--- /dev/null+++ b/wezterm-gui/src/termwindow/ui/recording_overlay.rs@@ -0,0 +1,750 @@+//! A window-local recording canvas. Only its opaque rectangles are painted;+//! normal input passes through unless the user explicitly enters edit mode.+use crate::ui::{DrawContext, SvgIcon};+use crate::utilsprites::RenderMetrics;+use window::color::LinearRgba;+use window::{KeyCode, KeyEvent, MouseCursor, MouseEvent, MouseEventKind, MousePress, WindowOps};++const MAX_MASKS: usize = 64;+const MIN_SIZE: f32 = 8.0;+const HANDLE_SIZE: f32 = 16.0;+// Above content transitions, tooltips and the command palette (currently 11).+const OVERLAY_ZINDEX: i8 = 20;++#[derive(Clone, Copy, Debug, Default, PartialEq)]+struct Rect {+ x: f32,+ y: f32,+ w: f32,+ h: f32,+}++impl Rect {+ fn between(a: (f32, f32), b: (f32, f32)) -> Self {+ Self {+ x: a.0.min(b.0),+ y: a.1.min(b.1),+ w: (a.0 - b.0).abs(),+ h: (a.1 - b.1).abs(),+ }+ }++ fn fitted(self, bounds: (f32, f32)) -> Self {+ let w = self.w.min(bounds.0).max(0.0);+ let h = self.h.min(bounds.1).max(0.0);+ Self {+ x: self.x.clamp(0.0, (bounds.0 - w).max(0.0)),+ y: self.y.clamp(0.0, (bounds.1 - h).max(0.0)),+ w,+ h,+ }+ }++ fn contains(self, p: (f32, f32)) -> bool {+ p.0 >= self.x && p.0 <= self.x + self.w && p.1 >= self.y && p.1 <= self.y + self.h+ }++ fn handle(self) -> Self {+ Self {+ x: self.x + self.w - HANDLE_SIZE.min(self.w),+ y: self.y + self.h - HANDLE_SIZE.min(self.h),+ w: HANDLE_SIZE.min(self.w),+ h: HANDLE_SIZE.min(self.h),+ }+ }++ fn pixels(self, scale: f32) -> window::RectF {+ euclid::rect(+ self.x * scale,+ self.y * scale,+ self.w * scale,+ self.h * scale,+ )+ }+}++#[derive(Clone, Copy, Debug)]+enum DragKind {+ Create,+ Move(usize, Rect),+ Resize(usize, Rect),+}++#[derive(Clone, Copy, Debug)]+struct Drag {+ kind: DragKind,+ anchor: (f32, f32),+ preview: Rect,+}++#[derive(Default)]+pub(crate) struct RecordingOverlay {+ // UI coordinates, independent of terminal font size and backing DPI.+ masks: Vec<Rect>,+ pub(crate) editing: bool,+ selected: Option<usize>,+ drag: Option<Drag>,+ buttons: [Option<Rect>; 3],+ toolbar: Option<Rect>,+ toolbar_position: Option<(f32, f32)>,+ toolbar_drag: Option<((f32, f32), Rect)>,+ hovered_button: Option<usize>,+ pressed_button: Option<usize>,+ finish_key: Option<KeyCode>,+}++impl RecordingOverlay {+ pub(crate) fn is_empty(&self) -> bool {+ self.masks.is_empty()+ }+ pub(crate) fn owns_keyboard(&self) -> bool {+ self.editing || self.finish_key.is_some()+ }++ pub(crate) fn clear(&mut self) {+ self.masks.clear();+ self.selected = None;+ self.drag = None;+ }++ pub(crate) fn cancel_interaction(&mut self) {+ self.drag = None;+ self.pressed_button = None;+ self.finish_key = None;+ self.toolbar_drag = None;+ self.hovered_button = None;+ }++ fn finish(&mut self) {+ self.editing = false;+ self.cancel_interaction();+ self.buttons = [None; 3];+ self.toolbar = None;+ }++ fn button_enabled(&self, index: usize) -> bool {+ match index {+ 0 => true,+ 1 => self.selected.is_some(),+ 2 => !self.masks.is_empty(),+ _ => false,+ }+ }++ fn toolbar_rect(&self, size: (f32, f32), bounds: (f32, f32)) -> Rect {+ let w = size.0.min((bounds.0 - 32.0).max(0.0));+ let h = size.1.min(bounds.1);+ let (x, y) = self+ .toolbar_position+ .unwrap_or(((bounds.0 - w) / 2.0, bounds.1 - h - 48.0));+ Rect { x, y, w, h }.fitted(bounds)+ }++ fn move_toolbar(&mut self, point: (f32, f32), bounds: (f32, f32)) {+ if let Some((anchor, original)) = self.toolbar_drag {+ let rect = Rect {+ x: original.x + point.0 - anchor.0,+ y: original.y + point.1 - anchor.1,+ ..original+ }+ .fitted(bounds);+ self.toolbar_position = Some((rect.x, rect.y));+ }+ }++ fn delete_selected(&mut self) {+ self.drag = None;+ if let Some(index) = self.selected.take() {+ self.masks.remove(index);+ }+ }++ fn hit(&self, point: (f32, f32), bounds: (f32, f32)) -> Option<usize> {+ self.masks+ .iter()+ .rposition(|rect| rect.fitted(bounds).contains(point))+ }++ fn begin(&mut self, point: (f32, f32), bounds: (f32, f32)) {+ self.selected = self.hit(point, bounds);+ let kind = match self.selected {+ Some(index) => {+ let rect = self.masks[index].fitted(bounds);+ if rect.handle().contains(point) {+ DragKind::Resize(index, rect)+ } else {+ DragKind::Move(index, rect)+ }+ }+ None if self.masks.len() < MAX_MASKS => DragKind::Create,+ None => return,+ };+ let preview = match kind {+ DragKind::Create => Rect::between(point, point),+ DragKind::Move(_, rect) | DragKind::Resize(_, rect) => rect,+ };+ self.drag = Some(Drag {+ kind,+ anchor: point,+ preview,+ });+ }++ fn update_drag(&mut self, point: (f32, f32), bounds: (f32, f32)) {+ let Some(drag) = &mut self.drag else {+ return;+ };+ let point = (point.0.clamp(0.0, bounds.0), point.1.clamp(0.0, bounds.1));+ drag.preview = match drag.kind {+ DragKind::Create => Rect::between(drag.anchor, point),+ DragKind::Move(_, original) => Rect {+ x: original.x + point.0 - drag.anchor.0,+ y: original.y + point.1 - drag.anchor.1,+ ..original+ }+ .fitted(bounds),+ DragKind::Resize(_, original) => Rect {+ w: (original.w + point.0 - drag.anchor.0)+ .max(MIN_SIZE)+ .min(bounds.0 - original.x),+ h: (original.h + point.1 - drag.anchor.1)+ .max(MIN_SIZE)+ .min(bounds.1 - original.y),+ ..original+ },+ };+ }++ fn commit_drag(&mut self) {+ let Some(drag) = self.drag.take() else {+ return;+ };+ if drag.preview.w < MIN_SIZE || drag.preview.h < MIN_SIZE {+ return;+ }+ match drag.kind {+ DragKind::Create => {+ self.selected = Some(self.masks.len());+ self.masks.push(drag.preview);+ }+ DragKind::Move(index, _) | DragKind::Resize(index, _) => {+ self.masks[index] = drag.preview+ }+ }+ }++ fn displayed(&self, index: usize, bounds: (f32, f32)) -> Rect {+ if let Some(drag) = self.drag {+ match drag.kind {+ DragKind::Move(i, _) | DragKind::Resize(i, _) if i == index => return drag.preview,+ _ => {}+ }+ }+ self.masks[index].fitted(bounds)+ }+}++impl crate::TermWindow {+ pub(crate) fn start_recording_overlay_edit(&mut self) {+ self.recording_overlay.editing = true;+ self.recording_overlay.drag = None;+ self.recording_overlay.pressed_button = None;+ self.context_menu = None;+ self.dragging = None;+ self.current_mouse_capture = None;+ self.current_mouse_buttons.clear();+ if let Some(window) = &self.window {+ window.invalidate();+ }+ }++ pub(crate) fn recording_overlay_key(+ &mut self,+ key: &KeyEvent,+ context: &dyn WindowOps,+ ) -> bool {+ if self.recording_overlay.finish_key.as_ref() == Some(&key.key) {+ if !key.key_is_down {+ self.recording_overlay.finish_key = None;+ }+ return true;+ }+ if !self.recording_overlay.editing {+ return false;+ }+ if key.key_is_down {+ match key.key {+ KeyCode::Char('\u{1b}') | KeyCode::Char('\r') => {+ self.recording_overlay.finish();+ self.recording_overlay.finish_key = Some(key.key.clone());+ }+ KeyCode::Char('\u{7f}') | KeyCode::Char('\u{8}') => {+ self.recording_overlay.delete_selected();+ }+ _ => {}+ }+ context.invalidate();+ }+ true+ }++ pub(crate) fn recording_overlay_mouse(+ &mut self,+ event: &MouseEvent,+ context: &dyn WindowOps,+ ) -> bool {+ if !self.recording_overlay.editing {+ return false;+ }+ let scale = self.ui_f32(1.0).max(0.01);+ let bounds = (+ self.dimensions.pixel_width as f32 / scale,+ self.dimensions.pixel_height as f32 / scale,+ );+ let point = (+ (event.coords.x as f32 / scale).clamp(0.0, bounds.0),+ (event.coords.y as f32 / scale).clamp(0.0, bounds.1),+ );+ let button = self+ .recording_overlay+ .buttons+ .iter()+ .position(|rect| rect.is_some_and(|r| r.contains(point)));+ let over_toolbar = self+ .recording_overlay+ .toolbar+ .is_some_and(|rect| rect.contains(point));+ self.recording_overlay.hovered_button = button;+ match event.kind {+ MouseEventKind::Press(MousePress::Left) => {+ if over_toolbar {+ if let Some(button) = button {+ if self.recording_overlay.button_enabled(button) {+ self.recording_overlay.pressed_button = Some(button);+ }+ } else if let Some(rect) = self.recording_overlay.toolbar {+ self.recording_overlay.toolbar_drag = Some((point, rect));+ }+ } else {+ self.recording_overlay.begin(point, bounds);+ }+ }+ MouseEventKind::Move => {+ self.recording_overlay.move_toolbar(point, bounds);+ self.recording_overlay.update_drag(point, bounds);+ }+ MouseEventKind::Release(MousePress::Left) => {+ if self.recording_overlay.toolbar_drag.is_some() {+ self.recording_overlay.move_toolbar(point, bounds);+ self.recording_overlay.toolbar_drag = None;+ } else if let Some(pressed) = self.recording_overlay.pressed_button.take() {+ if button == Some(pressed) {+ match pressed {+ 0 => self.recording_overlay.finish(),+ 1 => self.recording_overlay.delete_selected(),+ 2 => self.recording_overlay.clear(),+ _ => {}+ }+ }+ } else {+ self.recording_overlay.update_drag(point, bounds);+ self.recording_overlay.commit_drag();+ }+ }+ _ => {}+ }+ let cursor = if !self.recording_overlay.editing {+ MouseCursor::Arrow+ } else if over_toolbar {+ if button.is_none_or(|i| self.recording_overlay.button_enabled(i)) {+ MouseCursor::Hand+ } else {+ MouseCursor::Arrow+ }+ } else if let Some(index) = self.recording_overlay.hit(point, bounds) {+ if self+ .recording_overlay+ .displayed(index, bounds)+ .handle()+ .contains(point)+ {+ MouseCursor::SizeNorthWestSouthEast+ } else {+ MouseCursor::Hand+ }+ } else {+ MouseCursor::Arrow+ };+ context.set_cursor(Some(cursor));+ context.invalidate();+ true+ }++ pub(crate) fn paint_recording_overlay(&mut self) -> anyhow::Result<()> {+ if self.recording_overlay.is_empty() && !self.recording_overlay.editing {+ return Ok(());+ }+ let scale = self.ui_f32(1.0).max(0.01);+ let bounds = (+ self.dimensions.pixel_width as f32 / scale,+ self.dimensions.pixel_height as f32 / scale,+ );+ let gl = self.render_state.as_ref().unwrap();+ let layer = gl.layer_for_zindex(OVERLAY_ZINDEX)?;+ let mut layers = layer.quad_allocator();+ let black = LinearRgba::with_components(0.0, 0.0, 0.0, 1.0);+ let accent = LinearRgba::with_components(0.15, 0.6, 1.0, 1.0);+ for index in 0..self.recording_overlay.masks.len() {+ let rect = self.recording_overlay.displayed(index, bounds);+ self.filled_rectangle(&mut layers, 0, rect.pixels(scale), black)?;+ if self.recording_overlay.editing {+ if self.recording_overlay.selected == Some(index) {+ self.fill_rounded_rectangle_with_border(+ &mut layers,+ 1,+ rect.pixels(scale),+ black,+ accent,+ 0.0,+ 1.0 * scale,+ )?;+ }+ if self.recording_overlay.selected == Some(index) {+ let handle = rect.handle();+ let dot = Rect {+ x: handle.x + handle.w - 7.0,+ y: handle.y + handle.h - 7.0,+ w: 6.0,+ h: 6.0,+ };+ self.fill_rounded_rectangle(+ &mut layers,+ 2,+ dot.pixels(scale),+ accent,+ 2.0 * scale,+ )?;+ }+ }+ }+ if let Some(Drag {+ kind: DragKind::Create,+ preview,+ ..+ }) = self.recording_overlay.drag+ {+ self.filled_rectangle(&mut layers, 0, preview.pixels(scale), black)?;+ }+ if !self.recording_overlay.editing {+ return Ok(());+ }++ let size = (crate::native_settings::home_font_size(&crate::native_settings::load_shared())+ * 0.8)+ .max(10.0);+ let font = self.fonts.title_font_with_size(size)?;+ let metrics = RenderMetrics::with_font_metrics(&font.metrics());+ let ctx = DrawContext::new(gl, self.dimensions, &metrics);+ let palette = self.chrome();+ let text_height = metrics.cell_size.height as f32 / scale;+ let labels = [+ crate::i18n::tr("recording-overlay-done"),+ crate::i18n::tr("recording-overlay-delete"),+ crate::i18n::tr("recording-overlay-clear"),+ ];+ let widths = labels+ .each_ref()+ .map(|label| (ctx.measure_text_width(&font, label) / scale + 36.0).max(136.0));+ let natural_width = widths.iter().sum::<f32>() + 64.0;+ let bar = self+ .recording_overlay+ .toolbar_rect((natural_width, text_height + 96.0), bounds);+ let compression = (bar.w / natural_width).min(1.0);+ self.recording_overlay.toolbar = Some(bar);++ // Small, bounded rounded quads: no blurred framebuffer or animation loop.+ for (spread, offset, alpha) in [(12.0, 8.0, 0.05), (6.0, 5.0, 0.10), (2.0, 3.0, 0.18)] {+ let shadow = Rect {+ x: bar.x - spread,+ y: bar.y - spread + offset,+ w: bar.w + spread * 2.0,+ h: bar.h + spread * 2.0,+ };+ self.fill_rounded_rectangle(+ &mut layers,+ 2,+ shadow.pixels(scale),+ black.mul_alpha(alpha),+ (34.0 + spread) * scale,+ )?;+ }+ self.fill_rounded_rectangle_with_border(+ &mut layers,+ 2,+ bar.pixels(scale),+ palette.control_bg,+ palette.control_border,+ 34.0 * scale,+ scale.max(1.0),+ )?;+ // The whole gap around the buttons is draggable, not just this visual grip.+ self.fill_rounded_rectangle(+ &mut layers,+ 2,+ Rect {+ x: bar.x + (bar.w - 48.0) / 2.0,+ y: bar.y + 12.0,+ w: 48.0,+ h: 5.0,+ }+ .pixels(scale),+ palette.muted_text.mul_alpha(0.45),+ 2.5 * scale,+ )?;+ let mut x = bar.x + 20.0 * compression;+ let mut buttons = [None; 3];+ for i in [1, 2, 0] {+ let width = widths[i] * compression;+ let rect = Rect {+ x,+ y: bar.y + 28.0,+ w: width,+ h: bar.h - 42.0,+ };+ let enabled = self.recording_overlay.button_enabled(i);+ let hovered = self.recording_overlay.hovered_button == Some(i) && enabled;+ let pressed = self.recording_overlay.pressed_button == Some(i) && hovered;+ let bg = if pressed {+ palette.control_pressed_bg+ } else {+ palette.control_hover_bg+ };+ if hovered {+ self.fill_rounded_rectangle(&mut layers, 2, rect.pixels(scale), bg, 18.0 * scale)?;+ }+ let center_x = x + width / 2.0;+ let icon = match i {+ 0 => SvgIcon::Check,+ 1 => SvgIcon::Trash2,+ _ => SvgIcon::RotateCcw,+ };+ let tint = if enabled {+ palette.text+ } else {+ palette.muted_text.mul_alpha(0.4)+ };+ let icon_color = if i == 0 { palette.on_accent } else { tint };+ if i == 0 {+ self.fill_rounded_rectangle(+ &mut layers,+ 2,+ Rect {+ x: center_x - 23.0,+ y: rect.y + 2.0,+ w: 46.0,+ h: 46.0,+ }+ .pixels(scale),+ palette.accent,+ 23.0 * scale,+ )?;+ }+ ctx.draw_svg_icon(+ &mut layers,+ icon,+ (center_x - 16.0) * scale,+ (rect.y + 9.0) * scale,+ 32.0 * scale,+ icon_color,+ )?;+ let max_width = (width - 12.0).max(0.0) * scale;+ let label_width = ctx.measure_text_width(&font, &labels[i]).min(max_width);+ ctx.draw_text_on_layer(+ &mut layers,+ 2,+ &font,+ center_x * scale - label_width / 2.0,+ (rect.y + 56.0) * scale,+ &labels[i],+ tint,+ max_width,+ )?;+ buttons[i] = Some(rect);+ x += width + 12.0 * compression;+ }+ let hint_key = if self.recording_overlay.masks.len() >= MAX_MASKS {+ "recording-overlay-limit"+ } else if self.recording_overlay.toolbar_drag.is_some() {+ "recording-overlay-drag-toolbar"+ } else {+ "recording-overlay-hint"+ };+ let hint = crate::i18n::tr(hint_key);+ let max_width = (bounds.0 - 48.0).max(0.0) * scale;+ let hint_width = ctx.measure_text_width(&font, &hint).min(max_width);+ let hint_x = ((bar.x + bar.w / 2.0) * scale - hint_width / 2.0)+ .clamp(0.0, (bounds.0 * scale - hint_width).max(0.0));+ let hint_y = if bar.y >= text_height + 28.0 {+ bar.y - text_height - 20.0+ } else {+ bar.y + bar.h + 16.0+ };+ if hint_y + text_height <= bounds.1 {+ let hint_bg = euclid::rect(+ hint_x - 10.0 * scale,+ (hint_y - 5.0) * scale,+ hint_width + 20.0 * scale,+ (text_height + 10.0) * scale,+ );+ self.fill_rounded_rectangle(&mut layers, 2, hint_bg, palette.control_bg, 10.0 * scale)?;+ ctx.draw_text_on_layer(+ &mut layers,+ 2,+ &font,+ hint_x,+ hint_y * scale,+ &hint,+ palette.muted_text,+ max_width,+ )?;+ }+ self.recording_overlay.buttons = buttons;+ Ok(())+ }+}++#[cfg(test)]+mod tests {+ use super::*;++ fn with_mask() -> RecordingOverlay {+ let mut state = RecordingOverlay::default();+ state.editing = true;+ state.begin((180.0, 160.0), (500.0, 400.0));+ state.update_drag((100.0, 80.0), (500.0, 400.0));+ state.commit_drag();+ state+ }++ #[test]+ fn reverse_drag_creates_mask_and_finish_keeps_it() {+ let mut state = with_mask();+ assert_eq!(+ state.masks,+ vec![Rect {+ x: 100.0,+ y: 80.0,+ w: 80.0,+ h: 80.0+ }]+ );+ state.finish();+ assert!(!state.owns_keyboard());+ assert_eq!(state.masks.len(), 1);+ }++ #[test]+ fn moving_and_resizing_stay_inside_window() {+ let mut state = with_mask();+ state.begin((110.0, 90.0), (500.0, 400.0));+ state.update_drag((900.0, 900.0), (500.0, 400.0));+ state.commit_drag();+ assert_eq!(+ state.masks[0],+ Rect {+ x: 420.0,+ y: 320.0,+ w: 80.0,+ h: 80.0+ }+ );+ state.begin((495.0, 395.0), (500.0, 400.0));+ state.update_drag((0.0, 0.0), (500.0, 400.0));+ state.commit_drag();+ assert_eq!(state.masks[0].w, MIN_SIZE);+ assert_eq!(state.masks[0].h, MIN_SIZE);+ }++ #[test]+ fn cancelled_drag_and_click_do_not_change_masks() {+ let mut state = with_mask();+ let original = state.masks.clone();+ state.begin((110.0, 90.0), (500.0, 400.0));+ state.update_drag((300.0, 200.0), (500.0, 400.0));+ state.finish();+ assert_eq!(state.masks, original);+ state.begin((10.0, 10.0), (500.0, 400.0));+ state.commit_drag();+ assert_eq!(state.masks, original);+ }++ #[test]+ fn delete_and_limit_are_bounded() {+ let mut state = with_mask();+ state.delete_selected();+ assert!(state.is_empty());+ state.masks = vec![+ Rect {+ x: 100.0,+ y: 100.0,+ w: 10.0,+ h: 10.0+ };+ MAX_MASKS+ ];+ state.begin((1.0, 1.0), (500.0, 400.0));+ assert!(state.drag.is_none());+ state.clear();+ assert!(state.is_empty());+ }++ #[test]+ fn smaller_window_keeps_masks_editable_without_changing_saved_geometry() {+ let state = with_mask();+ let rect = state.displayed(0, (60.0, 50.0));+ assert_eq!(+ rect,+ Rect {+ x: 0.0,+ y: 0.0,+ w: 60.0,+ h: 50.0+ }+ );+ assert_eq!(state.displayed(0, (500.0, 400.0)), state.masks[0]);+ }++ #[test]+ fn floating_toolbar_moves_independently_and_stays_reachable() {+ let mut state = with_mask();+ let original_masks = state.masks.clone();+ let bar = state.toolbar_rect((300.0, 100.0), (800.0, 600.0));+ assert_eq!((bar.x, bar.y), (250.0, 452.0));+ state.toolbar_drag = Some(((bar.x + 20.0, bar.y + 10.0), bar));+ state.move_toolbar((1200.0, -200.0), (800.0, 600.0));+ let moved = state.toolbar_rect((300.0, 100.0), (800.0, 600.0));+ assert_eq!((moved.x, moved.y), (500.0, 0.0));+ let small = state.toolbar_rect((300.0, 100.0), (180.0, 90.0));+ assert!(small.x >= 0.0 && small.y >= 0.0);+ assert!(small.x + small.w <= 180.0 && small.y + small.h <= 90.0);+ state.cancel_interaction();+ assert!(state.toolbar_drag.is_none());+ assert_eq!(state.masks, original_masks);+ }++ #[test]+ fn focus_loss_cancels_interaction_without_removing_masks() {+ let mut state = with_mask();+ let original = state.masks.clone();+ state.begin((110.0, 90.0), (500.0, 400.0));+ state.update_drag((300.0, 200.0), (500.0, 400.0));+ state.pressed_button = Some(2);+ state.finish_key = Some(KeyCode::Char('\u{1b}'));+ state.cancel_interaction();+ state.commit_drag();+ assert_eq!(state.masks, original);+ assert!(state.drag.is_none());+ assert!(state.pressed_button.is_none());+ assert!(state.finish_key.is_none());+ }+}