Kaleido-Desktop/src-tauri/src/mini.rs
Elijah 8ed44c2fe4
All checks were successful
Validate Kaleido Desktop / validate (push) Successful in 1m22s
Release Kaleido Desktop 0.1.0-beta.12
On Windows the miniplayer is now a window of its own (mini.rs, mini.html):
a borderless window owned by the main one that the video moves into
(VideoSurface::set_host swaps composition targets in one commit). Dragging
moves the whole window, so video and controls move together with no edge
flicker; release glides it to the nearest corner or the one it's flicked
towards, remembered, and it follows the main window. Its page mirrors the
player over events (mini:state / mini:action). Shown and hidden natively
without activation, so the main window keeps focus. macOS keeps the
in-page miniplayer.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-04 17:35:08 -07:00

334 lines
13 KiB
Rust

//! The miniplayer as a window of its own (where `platform::SEPARATE_MINI`):
//! a small borderless window owned by the main one, which the video moves
//! into. Dragging moves the whole window, so video and controls move as one;
//! letting go glides it to a corner of the main window. Its page is
//! `mini.html` (src/mini/), which mirrors the player's state from the main
//! window and sends its buttons back (src/player/miniWindow.ts).
//!
//! Positions are physical screen pixels. Never hold `MiniState`'s locks while
//! calling a window getter: off the UI thread those wait for it (player.rs).
use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
use std::time::Duration;
use parking_lot::Mutex;
use tauri::{AppHandle, Manager, PhysicalPosition, PhysicalSize, Runtime, WebviewUrl, WebviewWindow, WebviewWindowBuilder, WindowEvent};
const LABEL: &str = "mini";
/// Logical pixels, as in the page's former in-window miniplayer (player.css).
const MARGIN: f64 = 24.0;
/// Top corners sit below the main window's navigation bar (64px).
const TOP_INSET: f64 = 64.0 + 12.0;
const SNAP: Duration = Duration::from_millis(260);
/// How far a flick carries the box when choosing a corner (ms of travel).
const FLICK_MS: f64 = 220.0;
#[derive(Clone, Copy, PartialEq)]
enum Corner {
TopLeft,
TopRight,
BottomLeft,
BottomRight,
}
impl Corner {
fn parse(s: &str) -> Corner {
match s {
"tl" => Corner::TopLeft,
"tr" => Corner::TopRight,
"bl" => Corner::BottomLeft,
_ => Corner::BottomRight,
}
}
fn name(self) -> &'static str {
match self {
Corner::TopLeft => "tl",
Corner::TopRight => "tr",
Corner::BottomLeft => "bl",
Corner::BottomRight => "br",
}
}
}
/// The main window's client area on screen and the miniplayer's size there.
#[derive(Clone, Copy)]
struct Bounds {
left: i32,
top: i32,
width: i32,
height: i32,
mini_w: i32,
mini_h: i32,
scale: f64,
}
impl Bounds {
fn of<R: Runtime>(main: &WebviewWindow<R>) -> Option<Bounds> {
let pos = main.inner_position().ok()?;
let size = main.inner_size().ok()?;
let scale = main.scale_factor().ok()?;
// As the page sized it: 26% of the window's width, 300 to 440 logical pixels, 16:9.
let w = (size.width as f64 / scale * 0.26).clamp(300.0, 440.0);
Some(Bounds {
left: pos.x,
top: pos.y,
width: size.width as i32,
height: size.height as i32,
mini_w: (w * scale).round() as i32,
mini_h: (w * 9.0 / 16.0 * scale).round() as i32,
scale,
})
}
fn corner(&self, corner: Corner) -> (i32, i32) {
let margin = (MARGIN * self.scale).round() as i32;
let x = match corner {
Corner::TopLeft | Corner::BottomLeft => self.left + margin,
_ => self.left + self.width - self.mini_w - margin,
};
let y = match corner {
Corner::TopLeft | Corner::TopRight => self.top + (TOP_INSET * self.scale).round() as i32,
_ => self.top + self.height - self.mini_h - margin,
};
(x, y)
}
/// Keeps the box inside the main window while it's dragged.
fn clamp(&self, x: i32, y: i32) -> (i32, i32) {
let x = x.clamp(self.left, (self.left + self.width - self.mini_w).max(self.left));
let y = y.clamp(self.top, (self.top + self.height - self.mini_h).max(self.top));
(x, y)
}
}
#[derive(Clone, Copy)]
struct Drag {
/// Where the window's visible area was when the drag began.
start: (i32, i32),
bounds: Bounds,
}
pub struct MiniState {
corner: Mutex<Corner>,
/// From the window's outer position to its visible area: Windows keeps an
/// invisible resize border around shadowed windows. Positions here are of
/// the visible area; `place` converts.
frame: Mutex<(i32, i32)>,
drag: Mutex<Option<Drag>>,
visible: AtomicBool,
/// Dragged or gliding: the main window's moves don't re-place it meanwhile.
busy: AtomicBool,
/// Bumped to stop a glide that's under way.
glide: AtomicU64,
}
impl Default for MiniState {
fn default() -> Self {
MiniState { corner: Mutex::new(Corner::BottomRight), frame: Mutex::new((0, 0)), drag: Mutex::new(None), visible: AtomicBool::new(false), busy: AtomicBool::new(false), glide: AtomicU64::new(0) }
}
}
/// Moves the window so its visible area's top left is at `(x, y)`.
fn place<R: Runtime>(app: &AppHandle<R>, mini: &WebviewWindow<R>, (x, y): (i32, i32)) {
let (fx, fy) = *app.state::<MiniState>().frame.lock();
let _ = mini.set_position(PhysicalPosition::new(x - fx, y - fy));
}
/// Where the visible area is now (outer position plus the frame).
fn visible_position<R: Runtime>(app: &AppHandle<R>, mini: &WebviewWindow<R>) -> Result<(i32, i32), String> {
let pos = mini.outer_position().map_err(|e| e.to_string())?;
let (fx, fy) = *app.state::<MiniState>().frame.lock();
Ok((pos.x + fx, pos.y + fy))
}
fn main_window<R: Runtime>(app: &AppHandle<R>) -> Result<WebviewWindow<R>, String> {
app.get_webview_window("main").ok_or_else(|| "The main window is gone.".to_string())
}
/// The miniplayer window, created hidden the first time (its page is small).
fn window<R: Runtime>(app: &AppHandle<R>) -> Result<WebviewWindow<R>, String> {
if let Some(w) = app.get_webview_window(LABEL) {
return Ok(w);
}
let main = main_window(app)?;
let w = WebviewWindowBuilder::new(app, LABEL, WebviewUrl::App("mini.html".into()))
.title("Kaleido")
.decorations(false)
.transparent(true)
.shadow(true)
.resizable(false)
.skip_taskbar(true)
.focused(false)
.visible(false)
.inner_size(440.0, 247.5)
// Owned by the main window: kept just above it, hidden when it's minimized.
.parent(&main)
.map_err(|e| e.to_string())?
.build()
.map_err(|e| e.to_string())?;
if let Some(hwnd) = crate::platform::host_handle(&w) {
crate::platform::style_mini_window(hwnd);
}
// mpv draws at the window's size; resizing happens off the UI thread (player.rs).
let handle = app.clone();
w.on_window_event(move |event| {
if let WindowEvent::Resized(_) | WindowEvent::ScaleFactorChanged { .. } = event {
let handle = handle.clone();
tauri::async_runtime::spawn_blocking(move || {
if let Some(main) = handle.get_webview_window("main") {
crate::player::on_resize(&main);
}
});
}
});
Ok(w)
}
/// Creates the window ahead of its first use, so going to the miniplayer is instant.
pub fn prepare<R: Runtime>(app: &AppHandle<R>) {
if crate::platform::SEPARATE_MINI {
let _ = window(app);
}
}
fn unsupported() -> Result<(), String> {
Err("The miniplayer window isn't used on this platform.".into())
}
/// Moves the video into the miniplayer window and shows it in `corner`.
#[tauri::command]
pub async fn mini_show<R: Runtime>(app: AppHandle<R>, corner: String) -> Result<(), String> {
if !crate::platform::SEPARATE_MINI {
return unsupported();
}
let state = app.state::<MiniState>();
let corner = Corner::parse(&corner);
*state.corner.lock() = corner;
state.glide.fetch_add(1, Ordering::SeqCst);
state.busy.store(false, Ordering::SeqCst);
let mini = window(&app)?;
let bounds = Bounds::of(&main_window(&app)?).ok_or("The main window has no size.")?;
let _ = mini.set_size(PhysicalSize::new(bounds.mini_w as u32, bounds.mini_h as u32));
if let (Ok(outer), Ok(inner)) = (mini.outer_position(), mini.inner_position()) {
*state.frame.lock() = (inner.x - outer.x, inner.y - outer.y);
}
place(&app, &mini, bounds.corner(corner));
let hwnd = crate::platform::host_handle(&mini).ok_or("The miniplayer window has no handle.")?;
crate::player::set_video_host(&app, Some(hwnd))?;
crate::platform::show_inactive(hwnd);
state.visible.store(true, Ordering::SeqCst);
Ok(())
}
/// Moves the video back to the main window and hides the miniplayer window.
#[tauri::command]
pub async fn mini_hide<R: Runtime>(app: AppHandle<R>) -> Result<(), String> {
if !crate::platform::SEPARATE_MINI {
return unsupported();
}
let state = app.state::<MiniState>();
state.visible.store(false, Ordering::SeqCst);
state.glide.fetch_add(1, Ordering::SeqCst);
*state.drag.lock() = None;
crate::player::set_video_host(&app, None)?;
if let Some(mini) = app.get_webview_window(LABEL) {
// Shown natively (without activation), so hidden natively too.
if let Some(hwnd) = crate::platform::host_handle(&mini) {
crate::platform::hide_window(hwnd);
}
}
Ok(())
}
#[tauri::command]
pub async fn mini_drag_start<R: Runtime>(app: AppHandle<R>) -> Result<(), String> {
let state = app.state::<MiniState>();
state.busy.store(true, Ordering::SeqCst);
state.glide.fetch_add(1, Ordering::SeqCst);
let mini = window(&app)?;
let bounds = Bounds::of(&main_window(&app)?).ok_or("The main window has no size.")?;
let start = visible_position(&app, &mini)?;
*state.drag.lock() = Some(Drag { start, bounds });
Ok(())
}
/// Follows the pointer: `dx`/`dy` are logical pixels moved since the drag began.
#[tauri::command]
pub async fn mini_drag<R: Runtime>(app: AppHandle<R>, dx: f64, dy: f64) -> Result<(), String> {
let Some(drag) = *app.state::<MiniState>().drag.lock() else { return Ok(()) };
let b = drag.bounds;
let to = b.clamp(drag.start.0 + (dx * b.scale).round() as i32, drag.start.1 + (dy * b.scale).round() as i32);
if let Some(mini) = app.get_webview_window(LABEL) {
place(&app, &mini, to);
}
Ok(())
}
/// Ends a drag: glides to the corner nearest where the box is heading (a flick,
/// `vx`/`vy` in logical pixels per millisecond, carries it on) and returns it.
#[tauri::command]
pub async fn mini_snap<R: Runtime>(app: AppHandle<R>, vx: f64, vy: f64) -> Result<String, String> {
let state = app.state::<MiniState>();
let drag = state.drag.lock().take();
let mini = window(&app)?;
let b = match drag {
Some(d) => d.bounds,
None => Bounds::of(&main_window(&app)?).ok_or("The main window has no size.")?,
};
let from = visible_position(&app, &mini)?;
let cx = from.0 as f64 + b.mini_w as f64 / 2.0 + vx * FLICK_MS * b.scale;
let cy = from.1 as f64 + b.mini_h as f64 / 2.0 + vy * FLICK_MS * b.scale;
let left = cx < b.left as f64 + b.width as f64 / 2.0;
let top = cy < b.top as f64 + b.height as f64 / 2.0;
let corner = match (top, left) {
(true, true) => Corner::TopLeft,
(true, false) => Corner::TopRight,
(false, true) => Corner::BottomLeft,
(false, false) => Corner::BottomRight,
};
*state.corner.lock() = corner;
let to = b.corner(corner);
let generation = state.glide.fetch_add(1, Ordering::SeqCst) + 1;
// Ease out over SNAP, a step per display frame; stops if another drag starts.
let handle = app.clone();
std::thread::spawn(move || {
let state = handle.state::<MiniState>();
let steps = (SNAP.as_millis() / 8) as i32;
let start = std::time::Instant::now();
for i in 1..=steps {
if state.glide.load(Ordering::SeqCst) != generation {
return;
}
let t = (start.elapsed().as_secs_f64() / SNAP.as_secs_f64()).min(1.0);
let e = 1.0 - (1.0 - t).powi(3);
let x = from.0 + ((to.0 - from.0) as f64 * e).round() as i32;
let y = from.1 + ((to.1 - from.1) as f64 * e).round() as i32;
place(&handle, &mini, (x, y));
if t >= 1.0 || i == steps {
break;
}
std::thread::sleep(Duration::from_millis(8));
}
place(&handle, &mini, to);
if state.glide.load(Ordering::SeqCst) == generation {
state.busy.store(false, Ordering::SeqCst);
}
});
Ok(corner.name().into())
}
/// Keeps the miniplayer in its corner as the main window moves or resizes.
/// Runs on the UI thread (window events), where window getters answer directly.
pub fn follow_main<R: Runtime>(main: &WebviewWindow<R>) {
let app = main.app_handle();
let Some(state) = app.try_state::<MiniState>() else { return };
if !state.visible.load(Ordering::SeqCst) || state.busy.load(Ordering::SeqCst) {
return;
}
let Some(mini) = app.get_webview_window(LABEL) else { return };
let Some(bounds) = Bounds::of(main) else { return };
let corner = *state.corner.lock();
let _ = mini.set_size(PhysicalSize::new(bounds.mini_w as u32, bounds.mini_h as u32));
place(&app, &mini, bounds.corner(corner));
}