Release Kaleido Desktop 0.1.0-beta.12
All checks were successful
Validate Kaleido Desktop / validate (push) Successful in 1m22s
All checks were successful
Validate Kaleido Desktop / validate (push) Successful in 1m22s
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>
This commit is contained in:
parent
c3d2f4b6a7
commit
8ed44c2fe4
22 changed files with 871 additions and 26 deletions
153
src/mini/main.tsx
Normal file
153
src/mini/main.tsx
Normal file
|
|
@ -0,0 +1,153 @@
|
|||
/**
|
||||
* The miniplayer window's page (mini.html; src-tauri/src/mini.rs). The video
|
||||
* is drawn beneath this transparent page by the native side; this page draws
|
||||
* the controls, mirrors the main window's player (src/player/miniWindow.ts)
|
||||
* and sends its buttons back. Dragging moves the whole window natively.
|
||||
*/
|
||||
import { StrictMode, useEffect, useState, type PointerEvent as ReactPointerEvent } from 'react';
|
||||
import { createRoot } from 'react-dom/client';
|
||||
import { invoke } from '@tauri-apps/api/core';
|
||||
import { emitTo, listen } from '@tauri-apps/api/event';
|
||||
import '@fontsource-variable/inter';
|
||||
import '../styles/base.css';
|
||||
import '../styles/ui.css';
|
||||
import '../styles/player.css';
|
||||
import './mini.css';
|
||||
import { Icon } from '../ui/Icon';
|
||||
import { MINI_CORNER_KEY, type MiniAction, type MiniState } from './types';
|
||||
|
||||
const send = (type: MiniAction) => emitTo('main', 'mini:action', { type }).catch(() => {});
|
||||
|
||||
window.addEventListener('contextmenu', (e) => e.preventDefault());
|
||||
|
||||
/**
|
||||
* Drags the window: moves go to the native side one at a time, latest first
|
||||
* (each is relative to where the drag began), and letting go glides it to a
|
||||
* corner. A drag that ends over a button doesn't press it.
|
||||
*/
|
||||
function startDrag(e: ReactPointerEvent<HTMLElement>) {
|
||||
if (e.button !== 0) return;
|
||||
const el = e.currentTarget;
|
||||
const pointer = e.pointerId;
|
||||
const origin = { x: e.screenX, y: e.screenY };
|
||||
const trail: { t: number; x: number; y: number }[] = [];
|
||||
let dragging = false;
|
||||
let started: Promise<unknown> | null = null;
|
||||
let inFlight: Promise<unknown> | null = null;
|
||||
let latest: { dx: number; dy: number } | null = null;
|
||||
|
||||
const pump = () => {
|
||||
if (inFlight || !latest || !started) return;
|
||||
const next = latest;
|
||||
latest = null;
|
||||
inFlight = started
|
||||
.then(() => invoke('mini_drag', next))
|
||||
.catch(() => {})
|
||||
.finally(() => {
|
||||
inFlight = null;
|
||||
pump();
|
||||
});
|
||||
};
|
||||
|
||||
const move = (ev: PointerEvent) => {
|
||||
const dx = ev.screenX - origin.x;
|
||||
const dy = ev.screenY - origin.y;
|
||||
trail.push({ t: ev.timeStamp, x: ev.screenX, y: ev.screenY });
|
||||
while (trail.length > 2 && ev.timeStamp - trail[0].t > 100) trail.shift();
|
||||
if (!dragging) {
|
||||
if (Math.hypot(dx, dy) < 4) return;
|
||||
dragging = true;
|
||||
document.documentElement.classList.add('dragging');
|
||||
el.setPointerCapture(pointer);
|
||||
started = invoke('mini_drag_start').catch(() => {});
|
||||
}
|
||||
latest = { dx, dy };
|
||||
pump();
|
||||
};
|
||||
|
||||
const up = async () => {
|
||||
window.removeEventListener('pointermove', move);
|
||||
window.removeEventListener('pointerup', up);
|
||||
window.removeEventListener('pointercancel', up);
|
||||
if (!dragging) return;
|
||||
document.documentElement.classList.remove('dragging');
|
||||
const swallow = (c: MouseEvent) => {
|
||||
c.stopPropagation();
|
||||
c.preventDefault();
|
||||
};
|
||||
window.addEventListener('click', swallow, { capture: true, once: true });
|
||||
setTimeout(() => window.removeEventListener('click', swallow, { capture: true }), 0);
|
||||
|
||||
const first = trail[0];
|
||||
const last = trail[trail.length - 1];
|
||||
const dt = first && last ? Math.max(1, last.t - first.t) : 1;
|
||||
const vx = first && last ? (last.x - first.x) / dt : 0;
|
||||
const vy = first && last ? (last.y - first.y) / dt : 0;
|
||||
// The last move lands before the glide begins.
|
||||
while (inFlight || latest) await (inFlight ?? Promise.resolve(pump()));
|
||||
const corner = await invoke<string>('mini_snap', { vx, vy }).catch(() => '');
|
||||
if (corner) localStorage.setItem(MINI_CORNER_KEY, corner);
|
||||
};
|
||||
|
||||
window.addEventListener('pointermove', move);
|
||||
window.addEventListener('pointerup', up);
|
||||
window.addEventListener('pointercancel', up);
|
||||
}
|
||||
|
||||
function Mini() {
|
||||
const [s, setS] = useState<MiniState | null>(null);
|
||||
|
||||
useEffect(() => {
|
||||
const unlisten = listen<MiniState>('mini:state', (e) => setS(e.payload));
|
||||
unlisten.then(() => send('ready'));
|
||||
return () => void unlisten.then((f) => f());
|
||||
}, []);
|
||||
|
||||
if (!s) return <div className="mini-player loading" />;
|
||||
const pct = s.duration ? Math.min(100, (s.position / s.duration) * 100) : 0;
|
||||
return (
|
||||
<div className={`mini-player${s.loading || s.error ? ' loading' : ''}`} onPointerDown={startDrag} onDoubleClick={() => send('expand')}>
|
||||
<div className="mini-scrim" />
|
||||
<div className="mini-top">
|
||||
<button className="mini-icon" aria-label="Back to full screen player" title="Expand" onClick={() => send('expand')}>
|
||||
<Icon name="expand" size={17} />
|
||||
</button>
|
||||
<button className="mini-icon" aria-label="Stop playback" title="Close" onClick={() => send('close')}>
|
||||
<Icon name="x" size={18} />
|
||||
</button>
|
||||
</div>
|
||||
<div className="mini-center">
|
||||
{(s.loading || s.buffering) && !s.error ? (
|
||||
<span className="spinner" style={{ width: 30, height: 30 }} aria-label="Loading" />
|
||||
) : s.error ? (
|
||||
<span className="mini-error">Playback stopped</span>
|
||||
) : (
|
||||
<>
|
||||
<button className="mini-icon" aria-label="Back 10 seconds" onClick={() => send('back')}>
|
||||
<Icon name="replay10" size={22} />
|
||||
</button>
|
||||
<button className="mini-icon big" aria-label={s.paused ? 'Play' : 'Pause'} onClick={() => send('toggle')}>
|
||||
<Icon name={s.paused || s.ended ? 'play' : 'pause'} size={26} />
|
||||
</button>
|
||||
<button className="mini-icon" aria-label="Forward 10 seconds" onClick={() => send('forward')}>
|
||||
<Icon name="forward10" size={22} />
|
||||
</button>
|
||||
</>
|
||||
)}
|
||||
</div>
|
||||
<div className="mini-caption">
|
||||
<b>{s.title}</b>
|
||||
{s.subtitle && <span>{s.subtitle}</span>}
|
||||
</div>
|
||||
<div className="mini-progress">
|
||||
<i style={{ width: `${pct}%` }} />
|
||||
</div>
|
||||
</div>
|
||||
);
|
||||
}
|
||||
|
||||
createRoot(document.getElementById('root')!).render(
|
||||
<StrictMode>
|
||||
<Mini />
|
||||
</StrictMode>,
|
||||
);
|
||||
32
src/mini/mini.css
Normal file
32
src/mini/mini.css
Normal file
|
|
@ -0,0 +1,32 @@
|
|||
/* The miniplayer window (mini.html): the page is transparent over the video
|
||||
and the box fills the window, whose corners Windows rounds. */
|
||||
html.mini-window,
|
||||
html.mini-window body,
|
||||
html.mini-window #root {
|
||||
height: 100%;
|
||||
margin: 0;
|
||||
overflow: hidden;
|
||||
background: transparent;
|
||||
}
|
||||
html.mini-window .mini-player {
|
||||
position: absolute;
|
||||
inset: 0;
|
||||
width: auto;
|
||||
height: auto;
|
||||
border-radius: 0;
|
||||
box-shadow: none;
|
||||
animation: none;
|
||||
cursor: default;
|
||||
}
|
||||
html.mini-window.dragging .mini-player {
|
||||
cursor: grabbing;
|
||||
}
|
||||
/* While dragged, the title stays and the buttons step back. */
|
||||
html.mini-window.dragging .mini-scrim,
|
||||
html.mini-window.dragging .mini-caption {
|
||||
opacity: 1;
|
||||
}
|
||||
html.mini-window.dragging .mini-top,
|
||||
html.mini-window.dragging .mini-center {
|
||||
opacity: 0;
|
||||
}
|
||||
17
src/mini/types.ts
Normal file
17
src/mini/types.ts
Normal file
|
|
@ -0,0 +1,17 @@
|
|||
/** What the miniplayer window shows, sent from the main window (src/player/miniWindow.ts). */
|
||||
export interface MiniState {
|
||||
title: string;
|
||||
subtitle: string;
|
||||
paused: boolean;
|
||||
ended: boolean;
|
||||
position: number;
|
||||
duration: number;
|
||||
loading: boolean;
|
||||
buffering: boolean;
|
||||
error: boolean;
|
||||
}
|
||||
|
||||
/** Buttons and gestures in the miniplayer window, carried out by the main window's player. */
|
||||
export type MiniAction = 'ready' | 'toggle' | 'back' | 'forward' | 'expand' | 'close';
|
||||
|
||||
export const MINI_CORNER_KEY = 'kaleido.miniCorner';
|
||||
|
|
@ -10,6 +10,7 @@ import { win, isNative } from '../platform/native';
|
|||
import { WindowControls } from '../app/TopBar';
|
||||
import { navigate } from '../app/router';
|
||||
import { mpv } from './engine';
|
||||
import { separateMini } from './miniWindow';
|
||||
import { PREPARING_NOTICE_MS, UPSCALING_ORDER, hasFailed, readDiagnostics, requestEnhancement, tierAvailable, toggleBypass, type Diagnostics } from './enhance';
|
||||
import { toast } from '../ui/overlays';
|
||||
import type { Item } from '../plex/types';
|
||||
|
|
@ -887,7 +888,8 @@ export function PlayerOverlay() {
|
|||
}, [chromeHidden]);
|
||||
|
||||
if (!st.open || !st.item) return null;
|
||||
if (st.mini) return <MiniPlayer />;
|
||||
// On Windows the miniplayer is a window of its own (miniWindow.ts).
|
||||
if (st.mini) return separateMini ? null : <MiniPlayer />;
|
||||
const item = st.item;
|
||||
const loading = !st.firstFrame && !st.error;
|
||||
const art = item.type === 'episode' ? item.grandparentArt || item.art : item.art;
|
||||
|
|
|
|||
97
src/player/miniWindow.ts
Normal file
97
src/player/miniWindow.ts
Normal file
|
|
@ -0,0 +1,97 @@
|
|||
/**
|
||||
* The miniplayer as a window of its own (Windows, src-tauri/src/mini.rs): the
|
||||
* video moves into it, so it drags as one piece. This side keeps its page
|
||||
* (src/mini/) up to date and carries out its buttons; macOS keeps the
|
||||
* in-page miniplayer (PlayerOverlay).
|
||||
*/
|
||||
import { hostOS, invoke, isNative, listen } from '../platform/native';
|
||||
import { episodeLabel } from '../app/format';
|
||||
import { MINI_CORNER_KEY, type MiniAction, type MiniState } from '../mini/types';
|
||||
import type { Item } from '../plex/types';
|
||||
|
||||
export const separateMini = isNative && hostOS === 'windows';
|
||||
|
||||
export async function showMiniWindow() {
|
||||
await invoke('mini_show', { corner: localStorage.getItem(MINI_CORNER_KEY) ?? 'br' });
|
||||
}
|
||||
|
||||
/** Moves the video back to the main window; harmless when already there. */
|
||||
export async function hideMiniWindow() {
|
||||
await invoke('mini_hide').catch(() => {});
|
||||
}
|
||||
|
||||
interface PlayerView {
|
||||
open: boolean;
|
||||
mini: boolean;
|
||||
item: Item | null;
|
||||
paused: boolean;
|
||||
ended: boolean;
|
||||
position: number;
|
||||
duration: number;
|
||||
firstFrame: boolean;
|
||||
buffering: boolean;
|
||||
error: string;
|
||||
}
|
||||
|
||||
interface PlayerActions {
|
||||
togglePause(): void;
|
||||
seekBy(delta: number): void;
|
||||
expand(): void;
|
||||
close(): Promise<void>;
|
||||
}
|
||||
|
||||
function view(st: PlayerView): MiniState {
|
||||
const item = st.item;
|
||||
return {
|
||||
title: item ? (item.type === 'episode' ? item.grandparentTitle : item.title) : '',
|
||||
subtitle: item?.type === 'episode' ? `${episodeLabel(item)} · ${item.title}` : '',
|
||||
paused: st.paused,
|
||||
ended: st.ended,
|
||||
position: st.position,
|
||||
duration: st.duration,
|
||||
loading: !st.firstFrame && !st.error,
|
||||
buffering: st.buffering,
|
||||
error: !!st.error,
|
||||
};
|
||||
}
|
||||
|
||||
/** Mirrors the player into the miniplayer window and listens for its buttons. */
|
||||
export function bridgeMiniWindow(store: { getState(): PlayerView & PlayerActions; subscribe(listener: (st: PlayerView, prev: PlayerView) => void): () => void }) {
|
||||
if (!separateMini) return;
|
||||
let lastSent = 0;
|
||||
let pending: ReturnType<typeof setTimeout> | null = null;
|
||||
|
||||
const send = async () => {
|
||||
pending = null;
|
||||
lastSent = Date.now();
|
||||
const st = store.getState();
|
||||
if (!st.open) return;
|
||||
const { emitTo } = await import('@tauri-apps/api/event');
|
||||
emitTo('mini', 'mini:state', view(st)).catch(() => {});
|
||||
};
|
||||
|
||||
store.subscribe((st, prev) => {
|
||||
if (!st.open || !st.mini) return;
|
||||
// Everything but the position goes straight away; the position a few times a second.
|
||||
const a = view(st);
|
||||
const b = view(prev);
|
||||
const only = (Object.keys(a) as (keyof MiniState)[]).every((k) => k === 'position' || a[k] === b[k]);
|
||||
if (!only || st.mini !== prev.mini) {
|
||||
if (pending) clearTimeout(pending);
|
||||
send();
|
||||
} else if (!pending) {
|
||||
pending = setTimeout(send, Math.max(0, 250 - (Date.now() - lastSent)));
|
||||
}
|
||||
});
|
||||
|
||||
listen<{ type: MiniAction }>('mini:action', ({ type }) => {
|
||||
const st = store.getState();
|
||||
if (type === 'ready') return send();
|
||||
if (!st.open) return;
|
||||
if (type === 'toggle') st.togglePause();
|
||||
else if (type === 'back') st.seekBy(-10);
|
||||
else if (type === 'forward') st.seekBy(10);
|
||||
else if (type === 'expand') st.expand();
|
||||
else if (type === 'close') st.close();
|
||||
});
|
||||
}
|
||||
|
|
@ -11,6 +11,7 @@ import { keepAwake, isNative, win } from '../platform/native';
|
|||
import { mpv, type MpvEvent, type MpvTrack } from './engine';
|
||||
import { toast } from '../ui/overlays';
|
||||
import { stopThemeMusic } from './theme';
|
||||
import { bridgeMiniWindow, hideMiniWindow, separateMini, showMiniWindow } from './miniWindow';
|
||||
|
||||
export interface Track {
|
||||
key: string; // stable UI key
|
||||
|
|
@ -700,6 +701,8 @@ export const usePlayer = create<PlayerState>((set, get) => ({
|
|||
keepAwake(false);
|
||||
watchPerformance(false);
|
||||
if (isNative) {
|
||||
// From the miniplayer window, the video goes home first (and stays hidden).
|
||||
if (separateMini && st.mini) await hideMiniWindow();
|
||||
await mpv.command('stop').catch(() => {});
|
||||
await mpv.show(false).catch(() => {});
|
||||
}
|
||||
|
|
@ -767,10 +770,19 @@ export const usePlayer = create<PlayerState>((set, get) => ({
|
|||
await win.setFullscreen(false).catch(() => {});
|
||||
set({ fullscreen: false });
|
||||
}
|
||||
if (separateMini) {
|
||||
// Once the page is opaque again (no video in it), the video moves into
|
||||
// the miniplayer's own window (miniWindow.ts).
|
||||
await new Promise((r) => requestAnimationFrame(() => requestAnimationFrame(r)));
|
||||
if (get().open && get().mini) await showMiniWindow().catch((e) => console.warn('[mini]', e));
|
||||
}
|
||||
},
|
||||
|
||||
expand() {
|
||||
if (get().mini) set({ mini: false });
|
||||
if (!get().mini) return;
|
||||
// The video comes back behind the still-opaque page before it turns transparent.
|
||||
if (separateMini) hideMiniWindow().finally(() => set({ mini: false }));
|
||||
else set({ mini: false });
|
||||
},
|
||||
|
||||
async selectAudio(key) {
|
||||
|
|
@ -854,15 +866,21 @@ export const usePlayer = create<PlayerState>((set, get) => ({
|
|||
usePlayer.subscribe((st, prev) => {
|
||||
if (st.firstFrame !== prev.firstFrame || st.open !== prev.open || st.error !== prev.error || st.mini !== prev.mini) {
|
||||
const html = document.documentElement.classList;
|
||||
html.toggle('video-active', st.open && st.firstFrame && !st.error);
|
||||
// With a miniplayer window, the video has left this page entirely.
|
||||
html.toggle('video-active', st.open && st.firstFrame && !st.error && !(st.mini && separateMini));
|
||||
html.toggle('player-open', st.open && !st.mini);
|
||||
html.toggle('player-mini', st.open && st.mini);
|
||||
}
|
||||
// However the miniplayer is left (expanding, playing another title, closing),
|
||||
// the video returns to the whole window.
|
||||
if (prev.mini && !st.mini && isNative) mpv.rect(null).catch(() => {});
|
||||
if (prev.mini && !st.mini && isNative) {
|
||||
if (separateMini) hideMiniWindow();
|
||||
else mpv.rect(null).catch(() => {});
|
||||
}
|
||||
});
|
||||
|
||||
bridgeMiniWindow(usePlayer);
|
||||
|
||||
/** Subtitle look changes apply to the playing video straight away. */
|
||||
const SUBTITLE_PREFS = ['subtitleScale', 'subtitleColor', 'subtitleEdge', 'subtitleBox', 'subtitleBold', 'subtitlePosition'] as const;
|
||||
useSettings.subscribe((prefs, prev) => {
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue