context menu option + improve algorithm

Author: Brendonovich

apps/desktop/src-tauri/src/lib.rs

@@ -32,7 +32,9 @@ use cap_media::platform::Bounds;
 use cap_media::{feeds::CameraFeed, sources::ScreenCaptureTarget};
 use cap_project::RecordingMetaInner;
 use cap_project::XY;
-use cap_project::{ProjectConfiguration, RecordingMeta, SharingMeta, StudioRecordingMeta};
+use cap_project::{
+    ProjectConfiguration, RecordingMeta, SharingMeta, StudioRecordingMeta, ZoomSegment,
+};
 use cap_rendering::ProjectRecordingsMeta;
 use clipboard_rs::common::RustImage;
 use clipboard_rs::{Clipboard, ClipboardContext};
@@ -1058,6 +1060,19 @@ async fn set_project_config(
     Ok(())
 }
 
+#[tauri::command]
+#[specta::specta]
+async fn generate_zoom_segments_from_clicks(
+    editor_instance: WindowEditorInstance,
+) -> Result<Vec<ZoomSegment>, String> {
+    let meta = editor_instance.meta();
+    let recordings = &editor_instance.recordings;
+
+    let zoom_segments = recording::generate_zoom_segments_for_project(meta, recordings);
+
+    Ok(zoom_segments)
+}
+
 #[tauri::command]
 #[specta::specta]
 async fn list_audio_devices() -> Result<Vec<String>, ()> {
@@ -1905,6 +1920,7 @@ pub async fn run(recording_logging_handle: LoggingHandle) {
             stop_playback,
             set_playhead_position,
             set_project_config,
+            generate_zoom_segments_from_clicks,
             permissions::open_permission_settings,
             permissions::do_permissions_check,
             permissions::request_permission,

apps/desktop/src-tauri/src/recording.rs

@@ -23,9 +23,9 @@ use cap_media::{
     sources::{CaptureScreen, CaptureWindow},
 };
 use cap_project::{
-    Platform, ProjectConfiguration, RecordingMeta, RecordingMetaInner, SharingMeta,
-    StudioRecordingMeta, TimelineConfiguration, TimelineSegment, ZoomMode, ZoomSegment,
-    cursor::CursorEvents,
+    CursorClickEvent, Platform, ProjectConfiguration, RecordingMeta, RecordingMetaInner,
+    SharingMeta, StudioRecordingMeta, TimelineConfiguration, TimelineSegment, ZoomMode,
+    ZoomSegment, cursor::CursorEvents,
 };
 use cap_recording::{
     CompletedStudioRecording, RecordingError, RecordingMode, StudioRecordingHandle,
@@ -831,48 +831,22 @@ async fn handle_recording_finish(
     Ok(())
 }
 
-/// Generates zoom segments based on mouse click events during recording.
+/// Core logic for generating zoom segments based on mouse click events.
 /// This is an experimental feature that automatically creates zoom effects
 /// around user interactions to highlight important moments.
-fn generate_zoom_segments_from_clicks(
-    recording: &CompletedStudioRecording,
+fn generate_zoom_segments_from_clicks_impl(
+    mut clicks: Vec<CursorClickEvent>,
     recordings: &ProjectRecordingsMeta,
 ) -> Vec<ZoomSegment> {
     const ZOOM_SEGMENT_AFTER_CLICK_PADDING: f64 = 1.5;
+    const ZOOM_SEGMENT_BEFORE_CLICK_PADDING: f64 = 0.8;
     const ZOOM_DURATION: f64 = 1.0;
     const CLICK_GROUP_THRESHOLD: f64 = 0.6; // seconds
+    const MIN_SEGMENT_PADDING: f64 = 2.0; // minimum gap between segments
 
     let max_duration = recordings.duration();
 
-    // Build a temporary RecordingMeta so we can load cursor events from disk
-    let recording_meta = RecordingMeta {
-        platform: None,
-        project_path: recording.project_path.clone(),
-        pretty_name: String::new(),
-        sharing: None,
-        inner: RecordingMetaInner::Studio(recording.meta.clone()),
-    };
-
-    let mut all_events = CursorEvents::default();
-
-    match &recording.meta {
-        StudioRecordingMeta::SingleSegment { segment } => {
-            if let Some(cursor_path) = &segment.cursor {
-                if let Ok(mut ev) = CursorEvents::load_from_file(&recording_meta.path(cursor_path))
-                {
-                    all_events.clicks.append(&mut ev.clicks);
-                }
-            }
-        }
-        StudioRecordingMeta::MultipleSegments { inner, .. } => {
-            for seg in &inner.segments {
-                let mut ev = seg.cursor_events(&recording_meta);
-                all_events.clicks.append(&mut ev.clicks);
-            }
-        }
-    }
-
-    all_events.clicks.sort_by(|a, b| {
+    clicks.sort_by(|a, b| {
         a.time_ms
             .partial_cmp(&b.time_ms)
             .unwrap_or(std::cmp::Ordering::Equal)
@@ -881,24 +855,30 @@ fn generate_zoom_segments_from_clicks(
     let mut segments = Vec::<ZoomSegment>::new();
 
     // Generate segments around mouse clicks
-    for click in &all_events.clicks {
+    for click in &clicks {
         if !click.down {
             continue;
         }
 
         let time = click.time_ms / 1000.0;
 
+        let proposed_start = (time - ZOOM_SEGMENT_BEFORE_CLICK_PADDING).max(0.0);
+        let proposed_end = (time + ZOOM_SEGMENT_AFTER_CLICK_PADDING).min(max_duration);
+
         if let Some(last) = segments.last_mut() {
-            if time <= last.end + CLICK_GROUP_THRESHOLD {
-                last.end = (time + ZOOM_SEGMENT_AFTER_CLICK_PADDING).min(max_duration);
+            // Merge if within group threshold OR if segments would be too close together
+            if time <= last.end + CLICK_GROUP_THRESHOLD
+                || proposed_start <= last.end + MIN_SEGMENT_PADDING
+            {
+                last.end = proposed_end;
                 continue;
             }
         }
 
         if time < max_duration - ZOOM_DURATION {
             segments.push(ZoomSegment {
-                start: (time - 0.8).max(0.0),
-                end: (time + ZOOM_SEGMENT_AFTER_CLICK_PADDING).min(max_duration),
+                start: proposed_start,
+                end: proposed_end,
                 amount: 2.0,
                 mode: ZoomMode::Auto,
             });
@@ -908,6 +888,54 @@ fn generate_zoom_segments_from_clicks(
     segments
 }
 
+/// Generates zoom segments based on mouse click events during recording.
+/// Used during the recording completion process.
+pub fn generate_zoom_segments_from_clicks(
+    recording: &CompletedStudioRecording,
+    recordings: &ProjectRecordingsMeta,
+) -> Vec<ZoomSegment> {
+    // Build a temporary RecordingMeta so we can use the common implementation
+    let recording_meta = RecordingMeta {
+        platform: None,
+        project_path: recording.project_path.clone(),
+        pretty_name: String::new(),
+        sharing: None,
+        inner: RecordingMetaInner::Studio(recording.meta.clone()),
+    };
+
+    generate_zoom_segments_for_project(&recording_meta, recordings)
+}
+
+/// Generates zoom segments from clicks for an existing project.
+/// Used in the editor context where we have RecordingMeta.
+pub fn generate_zoom_segments_for_project(
+    recording_meta: &RecordingMeta,
+    recordings: &ProjectRecordingsMeta,
+) -> Vec<ZoomSegment> {
+    let RecordingMetaInner::Studio(studio_meta) = &recording_meta.inner else {
+        return Vec::new();
+    };
+
+    let all_events = match studio_meta {
+        StudioRecordingMeta::SingleSegment { segment } => {
+            if let Some(cursor_path) = &segment.cursor {
+                CursorEvents::load_from_file(&recording_meta.path(cursor_path))
+                    .unwrap_or_default()
+                    .clicks
+            } else {
+                vec![]
+            }
+        }
+        StudioRecordingMeta::MultipleSegments { inner, .. } => inner
+            .segments
+            .iter()
+            .flat_map(|s| s.cursor_events(recording_meta).clicks)
+            .collect(),
+    };
+
+    generate_zoom_segments_from_clicks_impl(all_events, recordings)
+}
+
 fn project_config_from_recording(
     app: &AppHandle,
     completed_recording: &CompletedStudioRecording,
@@ -940,3 +968,9 @@ fn project_config_from_recording(
         ..default_config.unwrap_or_default()
     }
 }
+
+#[cfg(test)]
+mod test {
+    #[test]
+    fn zoom_segment_gaps() {}
+}

apps/desktop/src/routes/editor/Timeline/ZoomTrack.tsx

@@ -11,6 +11,7 @@ import {
   createSignal,
 } from "solid-js";
 import { produce } from "solid-js/store";
+import { Menu } from "@tauri-apps/api/menu";
 
 import { useEditorContext } from "../context";
 import {
@@ -20,6 +21,7 @@ import {
 } from "./context";
 import { SegmentContent, SegmentHandle, SegmentRoot, TrackRoot } from "./Track";
 import { cx } from "cva";
+import { commands } from "~/utils/tauri";
 
 export type ZoomSegmentDragState =
   | { type: "idle" }
@@ -38,8 +40,33 @@ export function ZoomTrack(props: {
   const [hoveringSegment, setHoveringSegment] = createSignal(false);
   const [hoveredTime, setHoveredTime] = createSignal<number>();
 
+  const handleGenerateZoomSegments = async () => {
+    try {
+      const zoomSegments = await commands.generateZoomSegmentsFromClicks();
+      setProject("timeline", "zoomSegments", zoomSegments);
+    } catch (error) {
+      console.error("Failed to generate zoom segments:", error);
+    }
+  };
+
   return (
     <TrackRoot
+      onContextMenu={async (e) => {
+        if (!import.meta.env.DEV) return;
+
+        e.preventDefault();
+        const menu = await Menu.new({
+          id: "zoom-track-options",
+          items: [
+            {
+              id: "generateZoomSegments",
+              text: "Generate zoom segments from clicks",
+              action: handleGenerateZoomSegments,
+            },
+          ],
+        });
+        menu.popup();
+      }}
       onMouseMove={(e) => {
         if (hoveringSegment()) {
           setHoveredTime(undefined);

apps/desktop/src/utils/tauri.ts

@@ -101,6 +101,9 @@ async setPlayheadPosition(frameNumber: number) : Promise<null> {
 async setProjectConfig(config: ProjectConfiguration) : Promise<null> {
     return await TAURI_INVOKE("set_project_config", { config });
 },
+async generateZoomSegmentsFromClicks() : Promise<ZoomSegment[]> {
+    return await TAURI_INVOKE("generate_zoom_segments_from_clicks");
+},
 async openPermissionSettings(permission: OSPermission) : Promise<void> {
     await TAURI_INVOKE("open_permission_settings", { permission });
 },