d847aca9a7
La app de escritorio es un navegador aparte sin la sesion de Google del usuario. Antes un enlace de docs.google.com se abria en el navegador del sistema y Google pedia Permitir cookies dentro de un marco que nadie podia contestar. Ahora hosts de Google (docs / drive / sheets / accounts / myaccount) se abren como PESTANAS internas del shell, y el WebView2 guarda la sesion de Google como cualquier otra cookie: se inicia sesion UNA vez y las hojas del contador se ven y editan en la pestana Contable. - create_tab acepta URLs con scheme https y host en GOOGLE_HOSTS ademas del origen propio. - La restauracion de sesion respeta el mismo criterio (una pestana de Google guardada reabre como pestana de Google). - El script inyectado detecta docs.google.com/... y hace newTab en vez de openExternal; en paginas de Google solo reporta el titulo (sin tocar clics, atajos ni window.open) para no interferir con el editor de Google. Falta probar el instalador de prueba antes de etiquetar la version. Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
1725 líneas
76 KiB
Rust
1725 líneas
76 KiB
Rust
// Punto de entrada de la app de escritorio de Labstream OS.
|
||
//
|
||
// Ya no es un envoltorio de UNA webview: es un SHELL DE PESTAÑAS (multiwebview de Tauri 2).
|
||
// La ventana "main" contiene:
|
||
// - un webview "chrome" (dist/index.html, local): la barra de pestañas + zoom, con acceso IPC.
|
||
// - N webviews "tab-*" (remotos): cada pestaña carga el servidor (os.labstreamsas.com).
|
||
//
|
||
// Con esto los enlaces internos con target=_blank (documentos, entregables, exportaciones,
|
||
// OnlyOffice…) — que antes MORÍAN en silencio — abren una pestaña dentro de la app, igual que
|
||
// en el navegador. Cmd/Ctrl+clic también abre pestaña. Los enlaces a OTRO origen siguen yendo
|
||
// al navegador del sistema.
|
||
//
|
||
// Comportamiento de cliente nativo que se conserva del envoltorio anterior:
|
||
// - plugin `opener`: enlaces externos al navegador del sistema.
|
||
// - plugin `notification`: la web (window.__TAURI__) muestra avisos nativos.
|
||
// - plugin `autostart`: la app arranca al iniciar sesión.
|
||
// - plugin `updater`: busca versión nueva en los Releases de GitHub y se actualiza sola.
|
||
// - bandeja (tray) + "cerrar = ocultar": sigue corriendo y notificando en segundo plano.
|
||
// Y lo nuevo:
|
||
// - ATRÁS/ADELANTE: botones ← → en la barra, ⌘[ / ⌘] (Alt+←/→ en Windows) y menú
|
||
// Historial (macOS). Antes una página sin menú propio era un callejón sin salida.
|
||
// - «Reabrir pestaña cerrada» (⌘/Ctrl+Shift+T), como en el navegador.
|
||
// - Globo de NO-LEÍDOS en el icono (evento `ls-badge` desde la web app): número en el
|
||
// Dock (macOS), punto rojo en la barra de tareas (Windows) y tooltip de la bandeja.
|
||
// - ZOOM de interfaz (Cmd/Ctrl +/−/0 y Ctrl+rueda) con persistencia entre sesiones.
|
||
// - Sesión restaurada: al reabrir vuelve con las mismas pestañas y tamaño de ventana.
|
||
// - single-instance (solo release): abrir la app de nuevo enfoca la ventana existente.
|
||
// - macOS: clic en el Dock reabre la ventana oculta (RunEvent::Reopen) y menú nativo con
|
||
// atajos de pestañas/zoom (los del teclado los consume el menú; en Windows los maneja JS).
|
||
//
|
||
// La comunicación shell ↔ Rust va por EVENTOS (`__TAURI__.event`), permitidos por
|
||
// `core:default` también para el origen remoto (capabilities/default.json). Así no hace falta
|
||
// declarar comandos propios en el ACL para páginas remotas.
|
||
|
||
mod cache;
|
||
mod tracker;
|
||
|
||
use std::sync::Mutex;
|
||
|
||
use serde::{Deserialize, Serialize};
|
||
use serde_json::json;
|
||
use tauri::{
|
||
menu::{CheckMenuItem, Menu, MenuItem, PredefinedMenuItem, Submenu},
|
||
tray::{MouseButton, MouseButtonState, TrayIconBuilder, TrayIconEvent},
|
||
webview::{DownloadEvent, PageLoadEvent, Webview, WebviewBuilder},
|
||
window::{Window, WindowBuilder},
|
||
AppHandle, Emitter, EventTarget, Listener, LogicalPosition, LogicalSize, Manager, Runtime,
|
||
Url, WebviewUrl, WindowEvent,
|
||
};
|
||
use tauri_plugin_autostart::{MacosLauncher, ManagerExt};
|
||
use tauri_plugin_notification::NotificationExt;
|
||
use tauri_plugin_clipboard_manager::ClipboardExt;
|
||
use tauri_plugin_opener::OpenerExt;
|
||
|
||
const SERVER_URL: &str = "https://os.labstreamsas.com";
|
||
|
||
// Los documentos del contador viven en Google (pestaña Contable). Se abren como PESTANAS
|
||
// de esta app, no en el navegador externo: asi el WebView guarda la sesion de Google del
|
||
// usuario (cookies persistentes) y no hay que iniciar sesion cada vez. La lista es cerrada
|
||
// a proposito: solo hosts propios de Google (docs/drive/sheets y accounts para el login).
|
||
// Todo lo demas sigue yendo al navegador del sistema.
|
||
const GOOGLE_HOSTS: &[&str] = &[
|
||
"docs.google.com",
|
||
"drive.google.com",
|
||
"sheets.google.com",
|
||
"accounts.google.com",
|
||
"myaccount.google.com",
|
||
];
|
||
|
||
fn is_google_host(host: &str) -> bool {
|
||
let h = host.to_ascii_lowercase();
|
||
GOOGLE_HOSTS.iter().any(|d| h == *d || h.ends_with(&format!(".{}", d)))
|
||
}
|
||
|
||
fn es_pestana_interna(target: &Url, server: &Url) -> bool {
|
||
if target.origin() == server.origin() {
|
||
return true;
|
||
}
|
||
if target.scheme() != "https" {
|
||
return false;
|
||
}
|
||
target.host_str().map(is_google_host).unwrap_or(false)
|
||
}
|
||
const TAB_BAR_H: f64 = 40.0; // alto lógico de la barra de pestañas (chrome)
|
||
const CHROME: &str = "chrome";
|
||
// Hueco que ocupan los botones rojo/amarillo/verde en macOS: la barra deja libre ese
|
||
// espacio a la izquierda (lo aplica el CSS de la barra con la bandera `mac` del payload).
|
||
|
||
// Escalones de zoom (como un navegador). 1.0 = 100%.
|
||
const ZOOM_STEPS: &[f64] = &[0.5, 0.67, 0.75, 0.8, 0.9, 1.0, 1.1, 1.25, 1.5, 1.75, 2.0, 2.5];
|
||
const ZOOM_100: usize = 5; // índice de 1.0 en ZOOM_STEPS
|
||
|
||
// ── Estado del shell ──
|
||
|
||
struct TabRec {
|
||
label: String,
|
||
title: String,
|
||
url: String,
|
||
loading: bool, // la barra pinta un giro en el icono mientras carga
|
||
// Color elegido a mano desde el menú de la pestaña (None = sin teñir). Aquí solo vive el
|
||
// NOMBRE; el tono exacto y cómo se pinta son cosa del CSS de la barra.
|
||
color: Option<String>,
|
||
}
|
||
|
||
// Paleta de colores de pestaña, la misma idea que los grupos de Chrome: sirve para agrupar de
|
||
// un vistazo («todo lo de este cliente en verde»). El id viaja en el payload de `ls-tabs`.
|
||
const TAB_COLORS: &[(&str, &str)] = &[
|
||
("gris", "Gris"),
|
||
("azul", "Azul"),
|
||
("rojo", "Rojo"),
|
||
("amarillo", "Amarillo"),
|
||
("verde", "Verde"),
|
||
("rosa", "Rosa"),
|
||
("morado", "Morado"),
|
||
("cian", "Cian"),
|
||
("naranja", "Naranja"),
|
||
];
|
||
|
||
struct Shell {
|
||
tabs: Vec<TabRec>,
|
||
active: usize,
|
||
zoom_idx: usize,
|
||
next_id: u64,
|
||
win: Option<WinRect>,
|
||
autostart: Option<bool>, // elección del usuario en el menú ⋮ (None = por defecto, activado)
|
||
closed: Vec<String>, // URLs de pestañas cerradas (para «Reabrir pestaña cerrada», ⌘⇧T)
|
||
menu_tab: Option<String>, // pestaña sobre la que se abrió el menú de clic derecho
|
||
// Último estado maximizado conocido. Solo sirve para no repintar la barra en CADA
|
||
// evento de redimensión: únicamente cuando el icono ▢/❐ tiene que cambiar.
|
||
maximized: bool,
|
||
// Tema REAL de la app (la clase `dark` de <html>, reportada por el script inyectado).
|
||
// Es global y no por pestaña: todas las pestañas del origen comparten el mismo modo
|
||
// (localStorage). None = ninguna pestaña ha reportado aún → la barra cae al del sistema.
|
||
dark: Option<bool>,
|
||
}
|
||
|
||
impl Default for Shell {
|
||
fn default() -> Self {
|
||
Self { tabs: Vec::new(), active: 0, zoom_idx: ZOOM_100, next_id: 1, win: None, autostart: None, closed: Vec::new(), menu_tab: None, maximized: false, dark: None }
|
||
}
|
||
}
|
||
|
||
type ShellState = Mutex<Shell>;
|
||
|
||
#[derive(Clone, Copy, Serialize, Deserialize)]
|
||
struct WinRect {
|
||
x: f64,
|
||
y: f64,
|
||
w: f64,
|
||
h: f64,
|
||
}
|
||
|
||
// Lo que se guarda en disco entre sesiones (zoom, ventana y pestañas abiertas).
|
||
#[derive(Serialize, Deserialize, Default)]
|
||
struct Persisted {
|
||
#[serde(default)]
|
||
zoom_idx: Option<usize>,
|
||
#[serde(default)]
|
||
win: Option<WinRect>,
|
||
#[serde(default)]
|
||
tabs: Vec<String>,
|
||
// Color de cada pestaña, en el mismo orden que `tabs` ("" = sin teñir). Lista aparte para
|
||
// que un estado.json viejo (sin colores) siga cargando tal cual.
|
||
#[serde(default)]
|
||
colors: Vec<String>,
|
||
#[serde(default)]
|
||
active: usize,
|
||
#[serde(default)]
|
||
autostart: Option<bool>,
|
||
// Último tema conocido de la app: la barra abre ya del color correcto en vez de
|
||
// arrancar con el del sistema y dar un fogonazo al cargar la primera pestaña.
|
||
#[serde(default)]
|
||
dark: Option<bool>,
|
||
}
|
||
|
||
fn state_path<R: Runtime>(app: &AppHandle<R>) -> Option<std::path::PathBuf> {
|
||
app.path().app_config_dir().ok().map(|d| d.join("estado.json"))
|
||
}
|
||
|
||
fn load_persisted<R: Runtime>(app: &AppHandle<R>) -> Persisted {
|
||
state_path(app)
|
||
.and_then(|p| std::fs::read_to_string(p).ok())
|
||
.and_then(|s| serde_json::from_str(&s).ok())
|
||
.unwrap_or_default()
|
||
}
|
||
|
||
fn save_persisted<R: Runtime>(app: &AppHandle<R>) {
|
||
let Some(path) = state_path(app) else { return };
|
||
let data = {
|
||
let shell = app.state::<ShellState>();
|
||
let s = shell.lock().unwrap();
|
||
Persisted {
|
||
zoom_idx: Some(s.zoom_idx),
|
||
win: s.win,
|
||
tabs: s.tabs.iter().map(|t| t.url.clone()).collect(),
|
||
colors: s.tabs.iter().map(|t| t.color.clone().unwrap_or_default()).collect(),
|
||
active: s.active,
|
||
autostart: s.autostart,
|
||
dark: s.dark,
|
||
}
|
||
};
|
||
if let Some(dir) = path.parent() {
|
||
let _ = std::fs::create_dir_all(dir);
|
||
}
|
||
if let Ok(txt) = serde_json::to_string_pretty(&data) {
|
||
let _ = std::fs::write(path, txt);
|
||
}
|
||
}
|
||
|
||
// ── Script inyectado en CADA página de las pestañas (origen remoto) ──
|
||
// - Enlaces a OTRO origen → navegador del sistema (opener), como antes.
|
||
// - target=_blank internos, Cmd/Ctrl+clic y window.open internos → pestaña nueva en la app.
|
||
// - Reporta título/URL a la barra (observer del <title> + pushState del SPA).
|
||
// - Atajos de teclado (en macOS los consume antes el menú nativo; esto cubre Windows y extras)
|
||
// y Ctrl+rueda para zoom.
|
||
// SOLO debe gobernar el documento principal de NUESTRO origen; ver la guarda de abajo.
|
||
const INIT_JS_TPL: &str = r#"
|
||
(function () {
|
||
var ORIGIN = "__ORIGIN__";
|
||
|
||
// ── GUARDA DE MARCO Y ORIGEN ──
|
||
// Antes aquí solo estaba `if (!T || !T.event) return;`, confiando en que __TAURI__ no
|
||
// existiría fuera del origen permitido. Eso es cierto en macOS y FALSO en Windows:
|
||
// · wry inyecta los scripts de inicio en TODOS los marcos e IGNORA for_main_frame_only
|
||
// (wry-0.55.1/src/webview2/mod.rs:492-495, documentado en su lib.rs:990), mientras que
|
||
// WKWebView sí la respeta (wry-0.55.1/src/wkwebview/mod.rs:643-645);
|
||
// · y __TAURI__ viaja con ellos (withGlobalTauri, tauri/src/manager/webview.rs:159-165).
|
||
// Consecuencia real: dentro del iframe del editor de OnlyOffice (docs.labstreamsas.com)
|
||
// este script SÍ corría en Windows, con ORIGIN apuntando todavía a la app. Como allí
|
||
// `location.href` es el del Document Server, abs() resolvía CADA enlace del editor contra
|
||
// docs.* → isExt() cierto → preventDefault() + mandarlo al navegador del sistema (que no
|
||
// tiene la sesión: «no se puede acceder»), y window.open devolvía null. Por eso editar y
|
||
// descargar fallaban solo en la app de Windows, y no en Mac ni en el navegador.
|
||
// En macOS estas dos líneas son un no-op: allí el script nunca ha corrido en subframes.
|
||
try { if (window.top !== window.self) return; } catch (e) { return; }
|
||
// Hosts de Google que la app abre como pestana propia (pestana Contable). En esas
|
||
// paginas solo reportamos titulo a la barra; NO tocamos clics ni window.open para no
|
||
// romper el editor de Google.
|
||
var GOOGLE_RE = /^(?:.*\.)?(?:docs|drive|sheets|accounts|myaccount)\.google\.com$/i;
|
||
var esGoogle = GOOGLE_RE.test(location.hostname);
|
||
if (location.origin !== ORIGIN && !esGoogle) return;
|
||
|
||
if (window.__lsShell) return;
|
||
window.__lsShell = true;
|
||
var T = window.__TAURI__;
|
||
if (!T || !T.event) return;
|
||
var LABEL = "__LABEL__";
|
||
|
||
function abs(h) { try { return new URL(h, location.href); } catch (e) { return null; } }
|
||
function isHttp(u) { return !!u && (u.protocol === 'http:' || u.protocol === 'https:'); }
|
||
function isApp(u) { return isHttp(u) && u.origin === ORIGIN; }
|
||
function isGoogleUrl(u) { return isHttp(u) && GOOGLE_RE.test(u.hostname); }
|
||
function isInterno(u) { return isApp(u) || isGoogleUrl(u); }
|
||
function isExt(u) { return isHttp(u) && !isInterno(u); }
|
||
function emit(name, payload) { try { T.event.emit(name, payload); } catch (e) {} }
|
||
function openExternal(url) {
|
||
try { T.core.invoke('plugin:opener|open_url', { url: url, with: null }); }
|
||
catch (e) { try { T.opener.openUrl(url); } catch (_) {} }
|
||
}
|
||
function newTab(url) { emit('ls-new-tab', { url: url }); }
|
||
|
||
// ── Miniaturas por el CAJÓN de la app (lsthumb://) ──
|
||
// Dentro de la app de escritorio, las miniaturas de la cuadrícula de fotos se piden por el
|
||
// esquema lsthumb:// en vez de directo al servidor. Así las sirve el cajón local (Rust): del
|
||
// disco si ya están —sobreviven a cerrar la app, que es lo que se pedía— y del NAS solo la
|
||
// primera vez. Fuera de la app (navegador normal) este script no corre y todo sigue igual.
|
||
//
|
||
// Se reescribe SOLO la miniatura de 480 px (thumb=1): es la que se repite 500 veces por set y
|
||
// ahoga la cuadrícula. El visor grande (thumb=xl) y la anotación sobre lienzo NO se tocan —
|
||
// cargar la imagen del lienzo por otro esquema lo «ensuciaría» y rompería «guardar el dibujo».
|
||
try {
|
||
function porCajon(src) {
|
||
if (!src || src.lastIndexOf('lsthumb:', 0) === 0) return src; // ya reescrita
|
||
var u = abs(src);
|
||
if (!u || u.origin !== ORIGIN) return src; // solo lo del propio servidor
|
||
if (!/\/api\/files-asset\//.test(u.pathname) || u.searchParams.get('thumb') !== '1') return src;
|
||
return 'lsthumb://c/?u=' + encodeURIComponent(u.href);
|
||
}
|
||
var proto = HTMLImageElement.prototype;
|
||
// 1) La propiedad .src (lo que usa React al asignar la imagen).
|
||
var d = Object.getOwnPropertyDescriptor(proto, 'src');
|
||
if (d && d.get && d.set) {
|
||
Object.defineProperty(proto, 'src', {
|
||
configurable: true, enumerable: d.enumerable,
|
||
get: function () { return d.get.call(this); },
|
||
set: function (v) { d.set.call(this, porCajon(String(v))); },
|
||
});
|
||
}
|
||
// 2) setAttribute('src', …), que no pasa por el setter de la propiedad. Se parchea SOLO en
|
||
// <img> (prototipo de HTMLImageElement), no en todos los elementos.
|
||
var setA = proto.setAttribute;
|
||
proto.setAttribute = function (name, value) {
|
||
if (arguments.length >= 2 && String(name).toLowerCase() === 'src') {
|
||
return setA.call(this, name, porCajon(String(value)));
|
||
}
|
||
return setA.apply(this, arguments);
|
||
};
|
||
// 3) Las que ya vienen en el HTML del servidor (SSR) o llegan luego. porCajon es idempotente
|
||
// (una ya reescrita se devuelve igual), así que barrer no entra en bucle con el observer.
|
||
function barrer(raiz) {
|
||
if (!raiz || !raiz.querySelectorAll) return;
|
||
var imgs = raiz.querySelectorAll('img[src]');
|
||
for (var i = 0; i < imgs.length; i++) {
|
||
var cur = imgs[i].getAttribute('src');
|
||
var nue = porCajon(cur);
|
||
if (nue !== cur) imgs[i].setAttribute('src', nue);
|
||
}
|
||
}
|
||
if (window.MutationObserver) {
|
||
new MutationObserver(function (muts) {
|
||
for (var i = 0; i < muts.length; i++) {
|
||
var m = muts[i];
|
||
if (m.type === 'attributes' && m.target && m.target.tagName === 'IMG') {
|
||
var cur = m.target.getAttribute('src'), nue = porCajon(cur);
|
||
if (nue !== cur) m.target.setAttribute('src', nue);
|
||
}
|
||
for (var j = 0; j < m.addedNodes.length; j++) {
|
||
var n = m.addedNodes[j];
|
||
if (!n || n.nodeType !== 1) continue;
|
||
if (n.tagName === 'IMG') { var c = n.getAttribute('src'), x = porCajon(c); if (x !== c) n.setAttribute('src', x); }
|
||
else barrer(n);
|
||
}
|
||
}
|
||
}).observe(document.documentElement, { childList: true, subtree: true, attributes: true, attributeFilter: ['src'] });
|
||
}
|
||
if (document.readyState === 'loading') document.addEventListener('DOMContentLoaded', function () { barrer(document); });
|
||
else barrer(document);
|
||
} catch (e) { /* si algo falla, las imágenes cargan directo del servidor como siempre */ }
|
||
|
||
// ── ¿La página se VE oscura? ──
|
||
// Señales, de la más directa a la más física: la clase `dark` (next-themes) y, si no
|
||
// está, el color de fondo REALMENTE pintado (luminancia del body) — vale sea cual sea
|
||
// el mecanismo de tema. Devuelve null con el documento a medio crear (los scripts de
|
||
// inicio corren antes de que exista <html>): entonces el campo NO viaja y Rust conserva
|
||
// el último valor bueno. La v1.7.0 leía la clase a secas y sin red: en WebView2 eso
|
||
// podía reventar en frío y dejar `dark` mintiendo en estado.json (barra clara sobre
|
||
// app oscura — el bug al revés).
|
||
function temaOscuro() {
|
||
try {
|
||
var doc = document.documentElement, cuerpo = document.body;
|
||
if (!doc) return null;
|
||
if (doc.classList.contains('dark') || (cuerpo && cuerpo.classList.contains('dark'))) return true;
|
||
if (!cuerpo) return null;
|
||
var fondo = getComputedStyle(cuerpo).backgroundColor || '';
|
||
var m = fondo.match(/rgba?\(\s*([\d.]+)[,\s]+([\d.]+)[,\s]+([\d.]+)(?:[,\s\/]+([\d.]+))?/);
|
||
if (m && (m[4] === undefined || parseFloat(m[4]) > 0.5)) {
|
||
return 0.2126 * m[1] + 0.7152 * m[2] + 0.0722 * m[3] < 128;
|
||
}
|
||
var esquema = getComputedStyle(doc).colorScheme || '';
|
||
if (esquema.indexOf('dark') >= 0 && esquema.indexOf('light') < 0) return true;
|
||
return false;
|
||
} catch (e) { return null; }
|
||
}
|
||
|
||
// Título, URL y TEMA → barra de pestañas (y para restaurar la sesión al reabrir).
|
||
// El tema viaja aquí porque la web decide su modo con su propio botón y NO sigue al
|
||
// sistema: la barra tiene que copiarle a ELLA.
|
||
function report() {
|
||
var carga = { label: LABEL, title: document.title || 'Labstream OS', url: location.href };
|
||
var oscuro = temaOscuro();
|
||
if (oscuro !== null) carga.dark = oscuro;
|
||
emit('ls-title', carga);
|
||
}
|
||
function watchTitle() {
|
||
var el = document.querySelector('title');
|
||
if (el && window.MutationObserver) {
|
||
new MutationObserver(report).observe(el, { childList: true, characterData: true, subtree: true });
|
||
}
|
||
}
|
||
if (document.readyState === 'loading') {
|
||
document.addEventListener('DOMContentLoaded', function () { watchTitle(); report(); });
|
||
} else { watchTitle(); }
|
||
addEventListener('load', report);
|
||
report();
|
||
['pushState', 'replaceState'].forEach(function (k) {
|
||
var o = history[k];
|
||
if (!o) return;
|
||
history[k] = function () { var r = o.apply(this, arguments); setTimeout(report, 0); return r; };
|
||
});
|
||
addEventListener('popstate', function () { setTimeout(report, 0); });
|
||
if (esGoogle) return; // en Google solo miramos el titulo
|
||
// Pulsar la luna cambia clases/estilos sin navegar: se vigilan <html> y <body> (cuando
|
||
// existan — a document-start aún no hay), y tras la carga se re-reporta un par de veces
|
||
// por si el tema aterriza tarde con la hidratación.
|
||
function vigilarTema() {
|
||
if (!window.MutationObserver) return;
|
||
var conf = { attributes: true, attributeFilter: ['class', 'style', 'data-theme'] };
|
||
if (document.documentElement) new MutationObserver(report).observe(document.documentElement, conf);
|
||
if (document.body) new MutationObserver(report).observe(document.body, conf);
|
||
}
|
||
if (document.body) vigilarTema();
|
||
else document.addEventListener('DOMContentLoaded', vigilarTema);
|
||
addEventListener('load', function () { setTimeout(report, 800); setTimeout(report, 2500); });
|
||
|
||
// Clics en enlaces.
|
||
document.addEventListener('click', function (e) {
|
||
if (e.defaultPrevented || e.button !== 0) return;
|
||
var a = e.target && e.target.closest ? e.target.closest('a[href]') : null;
|
||
if (!a) return;
|
||
var u = abs(a.getAttribute('href'));
|
||
if (!u) return;
|
||
if (isExt(u)) { e.preventDefault(); openExternal(u.href); return; }
|
||
var mod = e.metaKey || e.ctrlKey;
|
||
// Enlace a Google (docs, drive, sheets, accounts): SIEMPRE como pestana propia
|
||
// aunque no lleve target=_blank, para que la sesion viva dentro de la app.
|
||
if (isGoogleUrl(u)) { e.preventDefault(); newTab(u.href); return; }
|
||
if (isApp(u) && (mod || a.target === '_blank')) { e.preventDefault(); newTab(u.href); }
|
||
}, true);
|
||
|
||
// Clic con la rueda (botón central) en un enlace interno → pestaña nueva, como en el navegador.
|
||
document.addEventListener('auxclick', function (e) {
|
||
if (e.button !== 1) return;
|
||
var a = e.target && e.target.closest ? e.target.closest('a[href]') : null;
|
||
if (!a) return;
|
||
var u = abs(a.getAttribute('href'));
|
||
if (isExt(u)) { e.preventDefault(); openExternal(u.href); return; }
|
||
if (isInterno(u)) { e.preventDefault(); newTab(u.href); }
|
||
}, true);
|
||
|
||
var _open = window.open;
|
||
window.open = function (url, name, feats) {
|
||
var u = url ? abs(url) : null;
|
||
if (isExt(u)) { openExternal(u.href); return null; }
|
||
if (isInterno(u)) { newTab(u.href); return null; }
|
||
return _open ? _open.call(window, url, name, feats) : null;
|
||
};
|
||
|
||
// Atajos de teclado.
|
||
addEventListener('keydown', function (e) {
|
||
// AltGr enciende ctrlKey en Windows. Sin este filtro, escribir [ o ] con teclado
|
||
// español —que se hacen con AltGr— entraba por aquí y disparaba history.back() /
|
||
// history.forward() en vez de escribir el carácter: en el editor, en el chat, en una
|
||
// nota y en cualquier campo de la app. En macOS no aplica (Option no toca ctrlKey).
|
||
if (e.altKey) return;
|
||
var mod = e.metaKey || e.ctrlKey;
|
||
if (!mod) return;
|
||
var k = e.key;
|
||
if (k === 't' || k === 'T') {
|
||
e.preventDefault();
|
||
if (e.shiftKey) emit('ls-reopen', {}); else newTab(null);
|
||
}
|
||
else if (k === 'w' || k === 'W') { e.preventDefault(); emit('ls-close-tab', { label: LABEL }); }
|
||
else if ((k === 'r' || k === 'R') && !e.shiftKey) { e.preventDefault(); location.reload(); }
|
||
else if (k === '[') { e.preventDefault(); history.back(); }
|
||
else if (k === ']') { e.preventDefault(); history.forward(); }
|
||
else if (k === '=' || k === '+') { e.preventDefault(); emit('ls-zoom', { dir: 1 }); }
|
||
else if (k === '-') { e.preventDefault(); emit('ls-zoom', { dir: -1 }); }
|
||
else if (k === '0') { e.preventDefault(); emit('ls-zoom', { dir: 0 }); }
|
||
else if (k === 'Tab') { e.preventDefault(); emit('ls-cycle', { dir: e.shiftKey ? -1 : 1 }); }
|
||
else if (k >= '1' && k <= '9') { e.preventDefault(); emit('ls-activate-n', { n: +k }); }
|
||
}, true);
|
||
|
||
// Alt+←/→ = atrás/adelante (convención de Windows/Linux; en Mac es ⌘[ / ⌘] y Alt+flecha
|
||
// se respeta para saltar palabras al escribir). Fuera de campos de texto solamente.
|
||
var MAC = /Mac/i.test(navigator.platform || '');
|
||
function editable(el) {
|
||
return !!el && (el.isContentEditable || /^(INPUT|TEXTAREA|SELECT)$/.test(el.tagName || ''));
|
||
}
|
||
addEventListener('keydown', function (e) {
|
||
if (MAC || !e.altKey || e.metaKey || e.ctrlKey || e.shiftKey || editable(e.target)) return;
|
||
if (e.key === 'ArrowLeft') { e.preventDefault(); history.back(); }
|
||
else if (e.key === 'ArrowRight') { e.preventDefault(); history.forward(); }
|
||
}, true);
|
||
|
||
// Ctrl+rueda = zoom (convención de navegador; en Mac también con Ctrl).
|
||
addEventListener('wheel', function (e) {
|
||
if (!e.ctrlKey) return;
|
||
e.preventDefault();
|
||
emit('ls-zoom', { dir: e.deltaY < 0 ? 1 : -1 });
|
||
}, { passive: false, capture: true });
|
||
})();
|
||
"#;
|
||
|
||
// ── Utilidades del shell ──
|
||
|
||
fn main_window<R: Runtime>(app: &AppHandle<R>) -> Option<Window<R>> {
|
||
app.get_window("main")
|
||
}
|
||
|
||
fn get_webview<R: Runtime>(app: &AppHandle<R>, label: &str) -> Option<Webview<R>> {
|
||
main_window(app).and_then(|w| w.webviews().into_iter().find(|v| v.label() == label))
|
||
}
|
||
|
||
// Geometría: barra arriba (alto fijo), contenido debajo ocupando el resto.
|
||
fn layout_all<R: Runtime>(app: &AppHandle<R>) {
|
||
let Some(win) = main_window(app) else { return };
|
||
let scale = win.scale_factor().unwrap_or(1.0);
|
||
let Ok(size) = win.inner_size() else { return };
|
||
let size = size.to_logical::<f64>(scale);
|
||
let content_h = (size.height - TAB_BAR_H).max(0.0);
|
||
for wv in win.webviews() {
|
||
if wv.label() == CHROME {
|
||
let _ = wv.set_position(LogicalPosition::new(0.0, 0.0));
|
||
let _ = wv.set_size(LogicalSize::new(size.width, TAB_BAR_H));
|
||
} else {
|
||
let _ = wv.set_position(LogicalPosition::new(0.0, TAB_BAR_H));
|
||
let _ = wv.set_size(LogicalSize::new(size.width, content_h));
|
||
}
|
||
}
|
||
}
|
||
|
||
fn current_zoom<R: Runtime>(app: &AppHandle<R>) -> f64 {
|
||
let shell = app.state::<ShellState>();
|
||
let s = shell.lock().unwrap();
|
||
ZOOM_STEPS[s.zoom_idx.min(ZOOM_STEPS.len() - 1)]
|
||
}
|
||
|
||
// Manda el estado de pestañas + zoom + versión a la barra (webview "chrome").
|
||
fn broadcast<R: Runtime>(app: &AppHandle<R>) {
|
||
// Se consulta ANTES de tomar el lock del shell: así no se anidan dos cerrojos.
|
||
let maximized = main_window(app).and_then(|w| w.is_maximized().ok()).unwrap_or(false);
|
||
let payload = {
|
||
let shell = app.state::<ShellState>();
|
||
let s = shell.lock().unwrap();
|
||
let tabs: Vec<_> = s
|
||
.tabs
|
||
.iter()
|
||
.enumerate()
|
||
.map(|(i, t)| json!({ "label": t.label, "title": t.title, "url": t.url, "loading": t.loading, "active": i == s.active, "color": t.color }))
|
||
.collect();
|
||
json!({
|
||
"tabs": tabs,
|
||
"zoom": (ZOOM_STEPS[s.zoom_idx.min(ZOOM_STEPS.len()-1)] * 100.0).round() as u32,
|
||
"version": app.package_info().version.to_string(),
|
||
// En macOS la barra ocupa la fila del título (ventana con título en overlay) y
|
||
// debe dejar libre el hueco del semáforo, que lo pinta el sistema.
|
||
"mac": cfg!(target_os = "macos"),
|
||
// En Windows la ventana va SIN decoración: la barra es la fila del título, así
|
||
// que dibuja ella misma los botones minimizar/maximizar/cerrar (no hay nativos).
|
||
"win": cfg!(target_os = "windows"),
|
||
"maximized": maximized,
|
||
// Tema real de la app (null hasta el primer reporte: la barra usa el del sistema).
|
||
"dark": s.dark,
|
||
})
|
||
};
|
||
let _ = app.emit_to(EventTarget::webview(CHROME), "ls-tabs", payload);
|
||
}
|
||
|
||
// Marca una pestaña como «cargando» y refresca la barra (giro en el icono).
|
||
fn set_loading<R: Runtime>(app: &AppHandle<R>, label: &str, loading: bool) {
|
||
{
|
||
let shell = app.state::<ShellState>();
|
||
let mut s = shell.lock().unwrap();
|
||
let Some(t) = s.tabs.iter_mut().find(|t| t.label == label) else { return };
|
||
if t.loading == loading {
|
||
return; // sin cambios: no repintar la barra
|
||
}
|
||
t.loading = loading;
|
||
}
|
||
broadcast(app);
|
||
}
|
||
|
||
// Muestra la pestaña `label` y esconde las demás. Devuelve el foco al contenido.
|
||
fn activate_tab<R: Runtime>(app: &AppHandle<R>, label: &str) {
|
||
{
|
||
let shell = app.state::<ShellState>();
|
||
let mut s = shell.lock().unwrap();
|
||
if let Some(i) = s.tabs.iter().position(|t| t.label == label) {
|
||
s.active = i;
|
||
} else {
|
||
return;
|
||
}
|
||
}
|
||
let Some(win) = main_window(app) else { return };
|
||
for wv in win.webviews() {
|
||
if wv.label() == CHROME {
|
||
continue;
|
||
}
|
||
if wv.label() == label {
|
||
let _ = wv.show();
|
||
let _ = wv.set_focus();
|
||
} else {
|
||
let _ = wv.hide();
|
||
}
|
||
}
|
||
broadcast(app);
|
||
save_persisted(app);
|
||
}
|
||
|
||
// Crea una pestaña nueva cargando `url` (o el servidor si viene vacío).
|
||
fn create_tab<R: Runtime>(app: &AppHandle<R>, url: Option<String>, activate: bool) {
|
||
let target = url.unwrap_or_else(|| SERVER_URL.to_string());
|
||
// Solo el origen de la app puede abrirse en pestaña; cualquier otra cosa va al navegador.
|
||
let Ok(parsed) = Url::parse(&target) else { return };
|
||
let Ok(server) = Url::parse(SERVER_URL) else { return };
|
||
if !es_pestana_interna(&parsed, &server) {
|
||
return;
|
||
}
|
||
|
||
let label = {
|
||
let shell = app.state::<ShellState>();
|
||
let mut s = shell.lock().unwrap();
|
||
let label = format!("tab-{}", s.next_id);
|
||
s.next_id += 1;
|
||
s.tabs.push(TabRec { label: label.clone(), title: "Labstream OS".into(), url: target.clone(), loading: true, color: None });
|
||
label
|
||
};
|
||
|
||
let Some(win) = main_window(app) else { return };
|
||
let scale = win.scale_factor().unwrap_or(1.0);
|
||
let size = win.inner_size().map(|s| s.to_logical::<f64>(scale)).unwrap_or(LogicalSize::new(1400.0, 900.0));
|
||
|
||
let init = INIT_JS_TPL.replace("__LABEL__", &label).replace("__ORIGIN__", SERVER_URL);
|
||
let app_zoom = app.clone();
|
||
let builder = WebviewBuilder::new(&label, WebviewUrl::External(parsed))
|
||
.initialization_script(&init)
|
||
// Deja pasar las descargas (entregables, exportaciones) Y avisa al terminar.
|
||
// El aviso no es un adorno: en WebView2 la interfaz de descargas queda SIEMPRE
|
||
// apagada. wry trae un manejador de descargas por defecto (wry-0.55.1/src/lib.rs:830),
|
||
// asi que DownloadStarting se registra siempre y siempre responde SetHandled(true)
|
||
// (wry-0.55.1/src/webview2/mod.rs:858-861), lo que le dice a WebView2 que del aviso
|
||
// se encarga la app: ni barra de progreso, ni globo de «descarga terminada». El
|
||
// archivo bajaba bien a la carpeta de Descargas, pero NADA lo decia y parecia roto.
|
||
// Quitar este manejador NO devuelve la interfaz nativa: el de wry sigue puesto.
|
||
.on_download(|webview, event| {
|
||
if let DownloadEvent::Finished { path, success, .. } = &event {
|
||
let cuerpo = if !*success {
|
||
"No se pudo completar la descarga.".to_string()
|
||
} else if let Some(p) = path {
|
||
// En macOS `path` llega siempre vacio (limite de WKDownload:
|
||
// wry-0.55.1/src/wkwebview/download.rs:98), asi que en la practica
|
||
// este brazo con nombre de archivo es el de Windows.
|
||
match p.file_name() {
|
||
Some(n) => format!("Descargado: {}", n.to_string_lossy()),
|
||
None => "Descarga terminada.".to_string(),
|
||
}
|
||
} else {
|
||
"Descarga terminada. Esta en tu carpeta de Descargas.".to_string()
|
||
};
|
||
let _ = webview
|
||
.app_handle()
|
||
.notification()
|
||
.builder()
|
||
.title("Labstream OS")
|
||
.body(cuerpo)
|
||
.show();
|
||
}
|
||
true
|
||
})
|
||
// El zoom guardado se re-aplica en cada carga (el factor no siempre sobrevive a la navegación).
|
||
.on_page_load(move |wv, payload| {
|
||
let cargando = matches!(payload.event(), PageLoadEvent::Started);
|
||
if !cargando {
|
||
let _ = wv.set_zoom(current_zoom(&app_zoom));
|
||
}
|
||
set_loading(&app_zoom, wv.label(), cargando);
|
||
});
|
||
|
||
let created = win.add_child(
|
||
builder,
|
||
LogicalPosition::new(0.0, TAB_BAR_H),
|
||
LogicalSize::new(size.width, (size.height - TAB_BAR_H).max(0.0)),
|
||
);
|
||
|
||
match created {
|
||
Ok(_) => {
|
||
if activate {
|
||
activate_tab(app, &label);
|
||
} else {
|
||
broadcast(app);
|
||
save_persisted(app);
|
||
}
|
||
}
|
||
Err(_) => {
|
||
// Revertir el registro si el webview no se pudo crear.
|
||
let shell = app.state::<ShellState>();
|
||
let mut s = shell.lock().unwrap();
|
||
s.tabs.retain(|t| t.label != label);
|
||
}
|
||
}
|
||
}
|
||
|
||
// Cierra una pestaña; si era la activa, activa la vecina. Nunca deja cero pestañas.
|
||
fn close_tab<R: Runtime>(app: &AppHandle<R>, label: &str) {
|
||
let next_active: Option<String> = {
|
||
let shell = app.state::<ShellState>();
|
||
let mut s = shell.lock().unwrap();
|
||
let Some(i) = s.tabs.iter().position(|t| t.label == label) else { return };
|
||
let was_active = i == s.active;
|
||
// Recuerda la URL para «Reabrir pestaña cerrada» (tope de 20, las más recientes).
|
||
let url = s.tabs[i].url.clone();
|
||
s.closed.push(url);
|
||
if s.closed.len() > 20 {
|
||
s.closed.remove(0);
|
||
}
|
||
s.tabs.remove(i);
|
||
if s.tabs.is_empty() {
|
||
s.active = 0;
|
||
None
|
||
} else {
|
||
if s.active >= s.tabs.len() {
|
||
s.active = s.tabs.len() - 1;
|
||
} else if !was_active && i < s.active {
|
||
s.active -= 1;
|
||
}
|
||
was_active.then(|| s.tabs[s.active].label.clone())
|
||
}
|
||
};
|
||
|
||
if let Some(wv) = get_webview(app, label) {
|
||
let _ = wv.close();
|
||
}
|
||
|
||
let is_empty = {
|
||
let shell = app.state::<ShellState>();
|
||
let n = shell.lock().unwrap().tabs.len();
|
||
n == 0
|
||
};
|
||
if is_empty {
|
||
create_tab(app, None, true);
|
||
} else if let Some(next) = next_active {
|
||
activate_tab(app, &next);
|
||
} else {
|
||
broadcast(app);
|
||
save_persisted(app);
|
||
}
|
||
}
|
||
|
||
// Aplica un paso de zoom (+1 / −1 / 0 = restablecer) a TODAS las pestañas y lo persiste.
|
||
fn zoom_step<R: Runtime>(app: &AppHandle<R>, dir: i32) {
|
||
{
|
||
let shell = app.state::<ShellState>();
|
||
let mut s = shell.lock().unwrap();
|
||
s.zoom_idx = match dir {
|
||
0 => ZOOM_100,
|
||
d if d > 0 => (s.zoom_idx + 1).min(ZOOM_STEPS.len() - 1),
|
||
_ => s.zoom_idx.saturating_sub(1),
|
||
};
|
||
}
|
||
let z = current_zoom(app);
|
||
if let Some(win) = main_window(app) {
|
||
for wv in win.webviews() {
|
||
if wv.label() != CHROME {
|
||
let _ = wv.set_zoom(z);
|
||
}
|
||
}
|
||
}
|
||
broadcast(app);
|
||
save_persisted(app);
|
||
}
|
||
|
||
fn active_label<R: Runtime>(app: &AppHandle<R>) -> Option<String> {
|
||
let shell = app.state::<ShellState>();
|
||
let s = shell.lock().unwrap();
|
||
s.tabs.get(s.active).map(|t| t.label.clone())
|
||
}
|
||
|
||
fn reload_tab<R: Runtime>(app: &AppHandle<R>, label: Option<String>) {
|
||
let label = label.or_else(|| active_label(app));
|
||
if let Some(l) = label {
|
||
if let Some(wv) = get_webview(app, &l) {
|
||
let _ = wv.eval("location.reload()");
|
||
}
|
||
}
|
||
}
|
||
|
||
// Rota a la pestaña siguiente/anterior (Ctrl+Tab / Ctrl+Shift+Tab).
|
||
fn cycle_tab<R: Runtime>(app: &AppHandle<R>, dir: i32) {
|
||
let label = {
|
||
let shell = app.state::<ShellState>();
|
||
let s = shell.lock().unwrap();
|
||
if s.tabs.is_empty() {
|
||
return;
|
||
}
|
||
let n = s.tabs.len() as i32;
|
||
let i = ((s.active as i32 + dir) % n + n) % n;
|
||
s.tabs[i as usize].label.clone()
|
||
};
|
||
activate_tab(app, &label);
|
||
}
|
||
|
||
// Activa la pestaña n (1-9; 9 = última, como en los navegadores).
|
||
fn activate_nth<R: Runtime>(app: &AppHandle<R>, n: usize) {
|
||
let label = {
|
||
let shell = app.state::<ShellState>();
|
||
let s = shell.lock().unwrap();
|
||
if s.tabs.is_empty() {
|
||
return;
|
||
}
|
||
let i = if n >= 9 || n > s.tabs.len() { s.tabs.len() - 1 } else { n - 1 };
|
||
s.tabs[i].label.clone()
|
||
};
|
||
activate_tab(app, &label);
|
||
}
|
||
|
||
fn active_url<R: Runtime>(app: &AppHandle<R>) -> Option<String> {
|
||
let shell = app.state::<ShellState>();
|
||
let s = shell.lock().unwrap();
|
||
s.tabs.get(s.active).map(|t| t.url.clone())
|
||
}
|
||
|
||
// Atrás/adelante en el HISTORIAL de la pestaña activa. Antes no existía por ningún lado y
|
||
// una página sin menú propio (p. ej. el portal de revisión) era un callejón sin salida.
|
||
fn nav_tab<R: Runtime>(app: &AppHandle<R>, dir: i32) {
|
||
if let Some(l) = active_label(app) {
|
||
if let Some(wv) = get_webview(app, &l) {
|
||
let _ = wv.eval(if dir < 0 { "history.back()" } else { "history.forward()" });
|
||
}
|
||
}
|
||
}
|
||
|
||
// «Reabrir pestaña cerrada» (⌘/Ctrl+Shift+T): la más reciente primero, como en el navegador.
|
||
fn reopen_tab<R: Runtime>(app: &AppHandle<R>) {
|
||
let url = {
|
||
let shell = app.state::<ShellState>();
|
||
let mut s = shell.lock().unwrap();
|
||
s.closed.pop()
|
||
};
|
||
if let Some(u) = url {
|
||
create_tab(app, Some(u), true);
|
||
}
|
||
}
|
||
|
||
// Punto rojo para el icono de la barra de tareas de Windows (dibujado a mano: sin assets).
|
||
#[cfg(target_os = "windows")]
|
||
fn red_dot() -> tauri::image::Image<'static> {
|
||
const S: usize = 16;
|
||
let mut px = vec![0u8; S * S * 4];
|
||
let c = (S as f64 - 1.0) / 2.0;
|
||
for y in 0..S {
|
||
for x in 0..S {
|
||
let (dx, dy) = (x as f64 - c, y as f64 - c);
|
||
if (dx * dx + dy * dy).sqrt() <= c {
|
||
let i = (y * S + x) * 4;
|
||
px[i] = 225;
|
||
px[i + 1] = 29;
|
||
px[i + 2] = 72;
|
||
px[i + 3] = 255;
|
||
}
|
||
}
|
||
}
|
||
tauri::image::Image::new_owned(px, S as u32, S as u32)
|
||
}
|
||
|
||
// Globo de NO-LEÍDOS en el icono, alimentado por la web app (evento `ls-badge {count}`):
|
||
// macOS = número en el icono del Dock; Windows = punto rojo sobre el icono de la barra de
|
||
// tareas; y en ambos, el tooltip de la bandeja dice cuántos hay.
|
||
fn set_badge<R: Runtime>(app: &AppHandle<R>, count: i64) {
|
||
if let Some(win) = main_window(app) {
|
||
#[cfg(target_os = "macos")]
|
||
let _ = win.set_badge_count(if count > 0 { Some(count) } else { None });
|
||
#[cfg(target_os = "windows")]
|
||
let _ = win.set_overlay_icon(if count > 0 { Some(red_dot()) } else { None });
|
||
#[cfg(not(any(target_os = "macos", target_os = "windows")))]
|
||
let _ = &win;
|
||
}
|
||
if let Some(tray) = app.tray_by_id("main-tray") {
|
||
let tip = if count > 0 { format!("Labstream OS — {count} sin leer") } else { "Labstream OS".to_string() };
|
||
let _ = tray.set_tooltip(Some(tip));
|
||
}
|
||
}
|
||
|
||
// Menú de OPCIONES de la app (botón ⋮ / clic derecho en la barra): un popup NATIVO del sistema,
|
||
// igual en Windows y macOS. Se construye fresco en cada apertura para que el check de
|
||
// "Iniciar con el sistema" y la versión estén siempre al día. Solo opciones del SHELL — la web
|
||
// app no se toca.
|
||
fn show_app_menu<R: Runtime>(app: &AppHandle<R>) {
|
||
let Some(win) = main_window(app) else { return };
|
||
let autostart_on = app.autolaunch().is_enabled().unwrap_or(false);
|
||
let version = format!("Versión {}", app.package_info().version);
|
||
// El cajón dice cuánto ocupa en su propia etiqueta: así vaciarlo es una decisión informada, y
|
||
// de paso es la comprobación más simple de que el caché está funcionando (el número crece al
|
||
// navegar fotos y vuelve a 0 al vaciar).
|
||
let vaciar_txt = format!("Vaciar caché de imágenes ({})", tamano_legible(cache::tamano(app)));
|
||
let build = || -> tauri::Result<Menu<R>> {
|
||
Ok(Menu::with_items(
|
||
app,
|
||
&[
|
||
&MenuItem::with_id(app, "nav-back", "Atrás", true, Some("CmdOrCtrl+["))?,
|
||
&MenuItem::with_id(app, "nav-forward", "Adelante", true, Some("CmdOrCtrl+]"))?,
|
||
&PredefinedMenuItem::separator(app)?,
|
||
&MenuItem::with_id(app, "new-tab", "Nueva pestaña", true, Some("CmdOrCtrl+T"))?,
|
||
&MenuItem::with_id(app, "close-tab", "Cerrar pestaña", true, Some("CmdOrCtrl+W"))?,
|
||
&MenuItem::with_id(app, "reopen-tab", "Reabrir pestaña cerrada", true, Some("CmdOrCtrl+Shift+T"))?,
|
||
&MenuItem::with_id(app, "reload", "Recargar", true, Some("CmdOrCtrl+R"))?,
|
||
&PredefinedMenuItem::separator(app)?,
|
||
&MenuItem::with_id(app, "zoom-in", "Acercar", true, Some("CmdOrCtrl+="))?,
|
||
&MenuItem::with_id(app, "zoom-out", "Alejar", true, Some("CmdOrCtrl+-"))?,
|
||
&MenuItem::with_id(app, "zoom-0", "Tamaño real", true, Some("CmdOrCtrl+0"))?,
|
||
&PredefinedMenuItem::separator(app)?,
|
||
&MenuItem::with_id(app, "open-browser", "Abrir esta página en el navegador", true, None::<&str>)?,
|
||
&MenuItem::with_id(app, "clear-cache", &vaciar_txt, true, None::<&str>)?,
|
||
&CheckMenuItem::with_id(app, "autostart-toggle", "Iniciar con el sistema", true, autostart_on, None::<&str>)?,
|
||
&MenuItem::with_id(app, "check-update", "Buscar actualización…", true, None::<&str>)?,
|
||
&PredefinedMenuItem::separator(app)?,
|
||
&MenuItem::with_id(app, "version", &version, false, None::<&str>)?,
|
||
&MenuItem::with_id(app, "quit-app", "Salir de Labstream OS", true, None::<&str>)?,
|
||
],
|
||
)?)
|
||
};
|
||
if let Ok(menu) = build() {
|
||
let _ = win.popup_menu(&menu);
|
||
}
|
||
}
|
||
|
||
// Bytes → «12 MB» / «340 KB» / «1.2 GB», para la etiqueta del menú.
|
||
fn tamano_legible(bytes: u64) -> String {
|
||
const KB: u64 = 1024;
|
||
const MB: u64 = KB * 1024;
|
||
const GB: u64 = MB * 1024;
|
||
if bytes >= GB {
|
||
format!("{:.1} GB", bytes as f64 / GB as f64)
|
||
} else if bytes >= MB {
|
||
format!("{} MB", bytes / MB)
|
||
} else if bytes >= KB {
|
||
format!("{} KB", bytes / KB)
|
||
} else if bytes == 0 {
|
||
"vacío".to_string()
|
||
} else {
|
||
format!("{bytes} B")
|
||
}
|
||
}
|
||
|
||
// Menú de CLIC DERECHO sobre una pestaña. Nativo (la barra mide 40 px: un menú HTML dentro
|
||
// del webview quedaría recortado). Recuerda en el estado sobre qué pestaña se abrió.
|
||
fn show_tab_menu<R: Runtime>(app: &AppHandle<R>, label: &str) {
|
||
let Some(win) = main_window(app) else { return };
|
||
let (idx, total, actual) = {
|
||
let shell = app.state::<ShellState>();
|
||
let mut s = shell.lock().unwrap();
|
||
let Some(i) = s.tabs.iter().position(|t| t.label == label) else { return };
|
||
s.menu_tab = Some(label.to_string());
|
||
let actual = s.tabs[i].color.clone();
|
||
(i, s.tabs.len(), actual)
|
||
};
|
||
// Los ids se arman fuera del builder para poder pasarlos como &str (igual que el resto
|
||
// del menú) en vez de mezclar String y &str en el mismo constructor.
|
||
let ids: Vec<String> = TAB_COLORS.iter().map(|(id, _)| format!("tab-color-{id}")).collect();
|
||
let build = || -> tauri::Result<Menu<R>> {
|
||
// Submenú de color, con marca en el que tiene puesto ahora.
|
||
let mut colores: Vec<CheckMenuItem<R>> = Vec::with_capacity(TAB_COLORS.len() + 1);
|
||
colores.push(CheckMenuItem::with_id(app, "tab-color-ninguno", "Sin color", true, actual.is_none(), None::<&str>)?);
|
||
for ((cid, nombre), id) in TAB_COLORS.iter().zip(ids.iter()) {
|
||
let marcado = actual.as_deref() == Some(*cid);
|
||
colores.push(CheckMenuItem::with_id(app, id.as_str(), *nombre, true, marcado, None::<&str>)?);
|
||
}
|
||
let refs: Vec<&dyn tauri::menu::IsMenuItem<R>> = colores.iter().map(|c| c as &dyn tauri::menu::IsMenuItem<R>).collect();
|
||
let submenu = Submenu::with_items(app, "Color", true, &refs)?;
|
||
Ok(Menu::with_items(
|
||
app,
|
||
&[
|
||
&MenuItem::with_id(app, "tab-duplicate", "Duplicar pestaña", true, None::<&str>)?,
|
||
&MenuItem::with_id(app, "tab-copy-url", "Copiar enlace", true, None::<&str>)?,
|
||
&PredefinedMenuItem::separator(app)?,
|
||
&submenu,
|
||
&PredefinedMenuItem::separator(app)?,
|
||
&MenuItem::with_id(app, "tab-close", "Cerrar pestaña", true, None::<&str>)?,
|
||
&MenuItem::with_id(app, "tab-close-others", "Cerrar las demás", total > 1, None::<&str>)?,
|
||
&MenuItem::with_id(app, "tab-close-right", "Cerrar las de la derecha", idx + 1 < total, None::<&str>)?,
|
||
],
|
||
)?)
|
||
};
|
||
if let Ok(menu) = build() {
|
||
let _ = win.popup_menu(&menu);
|
||
}
|
||
}
|
||
|
||
// Acciones del menú de pestaña. `menu_tab` guarda sobre cuál se abrió (puede no ser la activa).
|
||
fn tab_menu_action<R: Runtime>(app: &AppHandle<R>, action: &str) {
|
||
let target = {
|
||
let shell = app.state::<ShellState>();
|
||
let s = shell.lock().unwrap();
|
||
s.menu_tab.clone()
|
||
};
|
||
let Some(label) = target else { return };
|
||
// Las que hay que cerrar se calculan ANTES de cerrar nada (los índices se mueven).
|
||
let (url, otras, derecha) = {
|
||
let shell = app.state::<ShellState>();
|
||
let s = shell.lock().unwrap();
|
||
let Some(i) = s.tabs.iter().position(|t| t.label == label) else { return };
|
||
(
|
||
s.tabs[i].url.clone(),
|
||
s.tabs.iter().filter(|t| t.label != label).map(|t| t.label.clone()).collect::<Vec<_>>(),
|
||
s.tabs.iter().skip(i + 1).map(|t| t.label.clone()).collect::<Vec<_>>(),
|
||
)
|
||
};
|
||
match action {
|
||
"tab-duplicate" => create_tab(app, Some(url), true),
|
||
"tab-copy-url" => {
|
||
let _ = app.clipboard().write_text(url);
|
||
}
|
||
"tab-close" => close_tab(app, &label),
|
||
"tab-close-others" => {
|
||
for l in otras {
|
||
close_tab(app, &l);
|
||
}
|
||
}
|
||
"tab-close-right" => {
|
||
for l in derecha {
|
||
close_tab(app, &l);
|
||
}
|
||
}
|
||
// Teñir la pestaña (o quitarle el color). Se valida contra la paleta: un id que no
|
||
// esté en TAB_COLORS deja la pestaña sin color en vez de guardar cualquier cosa.
|
||
a if a.starts_with("tab-color-") => {
|
||
let elegido = &a["tab-color-".len()..];
|
||
let nuevo = TAB_COLORS
|
||
.iter()
|
||
.find(|(id, _)| *id == elegido)
|
||
.map(|(id, _)| (*id).to_string());
|
||
{
|
||
let shell = app.state::<ShellState>();
|
||
let mut s = shell.lock().unwrap();
|
||
if let Some(t) = s.tabs.iter_mut().find(|t| t.label == label) {
|
||
t.color = nuevo;
|
||
}
|
||
}
|
||
broadcast(app);
|
||
save_persisted(app);
|
||
}
|
||
_ => {}
|
||
}
|
||
}
|
||
|
||
// Reordena las pestañas al soltar una en otra posición (arrastrar en la barra). Llega el
|
||
// orden completo de etiquetas; se conserva cuál estaba activa y se guarda la sesión.
|
||
fn reorder_tabs<R: Runtime>(app: &AppHandle<R>, order: Vec<String>) {
|
||
{
|
||
let shell = app.state::<ShellState>();
|
||
let mut s = shell.lock().unwrap();
|
||
// Solo se acepta una permutación EXACTA de las pestañas actuales (nada de perder o
|
||
// duplicar si la barra manda algo raro).
|
||
if order.len() != s.tabs.len() || !order.iter().all(|l| s.tabs.iter().any(|t| &t.label == l)) {
|
||
return;
|
||
}
|
||
let activa = s.tabs.get(s.active).map(|t| t.label.clone());
|
||
let mut nuevas: Vec<TabRec> = Vec::with_capacity(order.len());
|
||
for l in &order {
|
||
if let Some(i) = s.tabs.iter().position(|t| &t.label == l) {
|
||
nuevas.push(s.tabs.remove(i));
|
||
}
|
||
}
|
||
s.tabs = nuevas;
|
||
if let Some(a) = activa {
|
||
s.active = s.tabs.iter().position(|t| t.label == a).unwrap_or(0);
|
||
}
|
||
}
|
||
broadcast(app);
|
||
save_persisted(app);
|
||
}
|
||
|
||
// Activa/desactiva el arranque con el sistema y RECUERDA la elección (si no, el arranque
|
||
// la re-activaba en cada apertura).
|
||
fn toggle_autostart<R: Runtime>(app: &AppHandle<R>) {
|
||
let mgr = app.autolaunch();
|
||
let was_on = mgr.is_enabled().unwrap_or(false);
|
||
let _ = if was_on { mgr.disable() } else { mgr.enable() };
|
||
{
|
||
let shell = app.state::<ShellState>();
|
||
shell.lock().unwrap().autostart = Some(!was_on);
|
||
}
|
||
save_persisted(app);
|
||
let _ = app
|
||
.notification()
|
||
.builder()
|
||
.title("Labstream OS")
|
||
.body(if was_on {
|
||
"Ya no se iniciará con el sistema."
|
||
} else {
|
||
"Se iniciará automáticamente con el sistema."
|
||
})
|
||
.show();
|
||
}
|
||
|
||
// "Buscar actualización…" del menú: como la silenciosa, pero SIEMPRE responde con un aviso
|
||
// (instalando / ya estás al día / sin red).
|
||
#[cfg(desktop)]
|
||
async fn check_update_manual(handle: tauri::AppHandle) {
|
||
use tauri_plugin_updater::UpdaterExt;
|
||
let notify = |body: String| {
|
||
let _ = handle.notification().builder().title("Labstream OS").body(body).show();
|
||
};
|
||
let Ok(updater) = handle.updater() else {
|
||
notify("El actualizador no está disponible en esta instalación.".into());
|
||
return;
|
||
};
|
||
match updater.check().await {
|
||
Ok(Some(update)) => {
|
||
notify(format!("Instalando la versión {}…", update.version));
|
||
if update.download_and_install(|_, _| {}, || {}).await.is_ok() {
|
||
handle.restart();
|
||
} else {
|
||
notify("No se pudo instalar la actualización. Intenta de nuevo más tarde.".into());
|
||
}
|
||
}
|
||
Ok(None) => notify(format!("Estás en la última versión ({}).", handle.package_info().version)),
|
||
Err(_) => notify("No se pudo comprobar la actualización (revisa la red).".into()),
|
||
}
|
||
}
|
||
|
||
// Muestra y enfoca la ventana principal (tray, dock, segunda instancia).
|
||
fn show_main<R: Runtime>(app: &AppHandle<R>) {
|
||
if let Some(w) = main_window(app) {
|
||
let _ = w.show();
|
||
let _ = w.unminimize();
|
||
let _ = w.set_focus();
|
||
}
|
||
}
|
||
|
||
// Busca e instala una actualización en segundo plano. Si instala, avisa y reinicia.
|
||
#[cfg(desktop)]
|
||
async fn check_update(handle: tauri::AppHandle) {
|
||
use tauri_plugin_updater::UpdaterExt;
|
||
let updater = match handle.updater() {
|
||
Ok(u) => u,
|
||
Err(_) => return,
|
||
};
|
||
if let Ok(Some(update)) = updater.check().await {
|
||
if update.download_and_install(|_, _| {}, || {}).await.is_ok() {
|
||
let _ = handle
|
||
.notification()
|
||
.builder()
|
||
.title("Labstream OS")
|
||
.body("Se instaló una actualización. La app se reiniciará.")
|
||
.show();
|
||
handle.restart();
|
||
}
|
||
}
|
||
}
|
||
|
||
// Extrae un campo string del payload JSON de un evento.
|
||
fn field(payload: &str, key: &str) -> Option<String> {
|
||
serde_json::from_str::<serde_json::Value>(payload)
|
||
.ok()?
|
||
.get(key)?
|
||
.as_str()
|
||
.map(|s| s.to_string())
|
||
}
|
||
|
||
fn field_i64(payload: &str, key: &str) -> Option<i64> {
|
||
serde_json::from_str::<serde_json::Value>(payload).ok()?.get(key)?.as_i64()
|
||
}
|
||
|
||
fn field_bool(payload: &str, key: &str) -> Option<bool> {
|
||
serde_json::from_str::<serde_json::Value>(payload).ok()?.get(key)?.as_bool()
|
||
}
|
||
|
||
// ── Esquema lsthumb:// — el cajón de miniaturas ────────────────────────────────
|
||
// La web app, dentro de la app, pide las miniaturas de la cuadrícula como
|
||
// `lsthumb://c/?u=<URL real del servidor, con su token>`. Aquí se contesta: si está en el cajón,
|
||
// del disco; si no, se trae del NAS UNA vez, se guarda y se sirve. Todo el trabajo de red y disco
|
||
// va en un hilo aparte (ureq es bloqueante) para no congelar el webview.
|
||
//
|
||
// El módulo `cache` pone los cerrojos: `permitido` (solo el servidor y su API, nunca un proxy
|
||
// abierto) y `clave_de` (identidad estable sin el token que rota).
|
||
|
||
fn respuesta_bytes(bytes: Vec<u8>) -> tauri::http::Response<Vec<u8>> {
|
||
tauri::http::Response::builder()
|
||
.status(200)
|
||
.header("Content-Type", "image/webp")
|
||
// Privada y de larga vida: quien manda de verdad es el cajón en disco; esto solo evita
|
||
// que el propio webview volviera a pedirla dentro de la misma sesión.
|
||
.header("Cache-Control", "private, max-age=86400")
|
||
.header("Access-Control-Allow-Origin", "*")
|
||
.body(bytes)
|
||
.unwrap()
|
||
}
|
||
|
||
fn respuesta_estado(code: u16) -> tauri::http::Response<Vec<u8>> {
|
||
tauri::http::Response::builder()
|
||
.status(code)
|
||
.header("Access-Control-Allow-Origin", "*")
|
||
.body(Vec::new())
|
||
.unwrap()
|
||
}
|
||
|
||
fn responder_lsthumb<R: Runtime>(
|
||
ctx: tauri::UriSchemeContext<'_, R>,
|
||
req: tauri::http::Request<Vec<u8>>,
|
||
responder: tauri::UriSchemeResponder,
|
||
) {
|
||
let app = ctx.app_handle().clone();
|
||
let objetivo = match cache::url_pedida(&req.uri().to_string()) {
|
||
Some(u) if cache::permitido(&u) => u,
|
||
_ => {
|
||
responder.respond(respuesta_estado(400));
|
||
return;
|
||
}
|
||
};
|
||
let Some(clave) = cache::clave_de(&objetivo) else {
|
||
responder.respond(respuesta_estado(400));
|
||
return;
|
||
};
|
||
|
||
// ¿En el cajón? Del disco, sin tocar la red.
|
||
if let Some(bytes) = cache::leer(&app, &clave) {
|
||
responder.respond(respuesta_bytes(bytes));
|
||
return;
|
||
}
|
||
|
||
// Falta: traerla del NAS y guardarla para la próxima. Va en el POOL de hilos de bloqueo (no un
|
||
// `std::thread::spawn` por petición): al abrir un set de 500 fotos podrían dispararse muchas a
|
||
// la vez, y el pool las acota y reutiliza sus hilos en vez de crear cientos.
|
||
tauri::async_runtime::spawn_blocking(move || match cache::traer(&objetivo) {
|
||
Ok((bytes, es_webp)) => {
|
||
if es_webp {
|
||
cache::escribir(&app, &clave, &bytes);
|
||
}
|
||
responder.respond(respuesta_bytes(bytes));
|
||
}
|
||
Err(code) => responder.respond(respuesta_estado(code)),
|
||
});
|
||
}
|
||
|
||
#[cfg_attr(mobile, tauri::mobile_entry_point)]
|
||
pub fn run() {
|
||
let mut builder = tauri::Builder::default();
|
||
|
||
// Una sola instancia (solo en release: en dev conviviría con la app instalada).
|
||
#[cfg(not(debug_assertions))]
|
||
{
|
||
builder = builder.plugin(tauri_plugin_single_instance::init(|app, _argv, _cwd| {
|
||
show_main(app);
|
||
}));
|
||
}
|
||
|
||
builder = builder
|
||
.plugin(tauri_plugin_opener::init())
|
||
.plugin(tauri_plugin_clipboard_manager::init())
|
||
.plugin(tauri_plugin_notification::init())
|
||
.plugin(tauri_plugin_updater::Builder::new().build())
|
||
.plugin(tauri_plugin_autostart::init(MacosLauncher::LaunchAgent, None))
|
||
// El cajón de miniaturas (ver el módulo `cache` y el handler de arriba). Registrado en el
|
||
// builder para que TODAS las webviews de pestaña puedan usarlo.
|
||
.register_asynchronous_uri_scheme_protocol("lsthumb", responder_lsthumb);
|
||
|
||
let app = builder
|
||
.manage(ShellState::default())
|
||
.setup(|app| {
|
||
let handle = app.handle().clone();
|
||
let saved = load_persisted(&handle);
|
||
|
||
// Arranque automático al iniciar sesión: por defecto activado, pero se respeta
|
||
// lo que el usuario elija en el menú ⋮ ("Iniciar con el sistema").
|
||
match saved.autostart {
|
||
Some(false) => {
|
||
let _ = app.autolaunch().disable();
|
||
}
|
||
_ => {
|
||
let _ = app.autolaunch().enable();
|
||
}
|
||
}
|
||
|
||
// Al abrir, busca una actualización en segundo plano (no bloquea el arranque).
|
||
#[cfg(desktop)]
|
||
{
|
||
let handle = app.handle().clone();
|
||
tauri::async_runtime::spawn(check_update(handle));
|
||
}
|
||
|
||
{
|
||
let shell = handle.state::<ShellState>();
|
||
let mut s = shell.lock().unwrap();
|
||
s.zoom_idx = saved.zoom_idx.unwrap_or(ZOOM_100).min(ZOOM_STEPS.len() - 1);
|
||
s.win = saved.win;
|
||
s.autostart = saved.autostart;
|
||
s.dark = saved.dark;
|
||
}
|
||
|
||
// Ventana principal (contenedora). Tamaño/posición de la sesión anterior si los hay.
|
||
// En AMBOS sistemas la barra de pestañas ocupa la fila del título, como Chrome:
|
||
// no se desperdicia una franja entera en repetir el nombre de la app.
|
||
// - macOS: título en OVERLAY y sin texto; el semáforo lo sigue pintando el sistema
|
||
// encima y la barra le deja su hueco (clase `mac` del CSS).
|
||
// - Windows: ventana SIN decoración; los botones minimizar/maximizar/cerrar los
|
||
// dibuja la propia barra (clase `win`) y actúan por el evento `ls-window`.
|
||
// `resizable(true)` conserva WS_THICKFRAME, así que los bordes siguen
|
||
// redimensionando y Aero Snap (arrastrar a un borde, Win+flechas) sigue vivo.
|
||
let mut wb = WindowBuilder::new(app, "main")
|
||
.title("Labstream OS")
|
||
.resizable(true)
|
||
.min_inner_size(1024.0, 700.0);
|
||
#[cfg(target_os = "macos")]
|
||
{
|
||
wb = wb.title_bar_style(tauri::TitleBarStyle::Overlay).hidden_title(true);
|
||
}
|
||
#[cfg(target_os = "windows")]
|
||
{
|
||
wb = wb.decorations(false);
|
||
}
|
||
match saved.win {
|
||
Some(r) if r.w >= 600.0 && r.h >= 400.0 => {
|
||
wb = wb.inner_size(r.w, r.h).position(r.x, r.y);
|
||
}
|
||
_ => {
|
||
wb = wb.inner_size(1400.0, 900.0).center();
|
||
}
|
||
}
|
||
let win = wb.build()?;
|
||
|
||
// Menú nativo SOLO en macOS: da Cmd+C/V (Edición), y los atajos de pestañas/zoom
|
||
// como aceleradores de menú. En Windows no ponemos menú (los atajos van por JS).
|
||
#[cfg(target_os = "macos")]
|
||
{
|
||
let h = app.handle();
|
||
let app_menu = Submenu::with_items(
|
||
h,
|
||
"Labstream OS",
|
||
true,
|
||
&[
|
||
&MenuItem::with_id(h, "check-update", "Buscar actualización…", true, None::<&str>)?,
|
||
&PredefinedMenuItem::separator(h)?,
|
||
&PredefinedMenuItem::hide(h, Some("Ocultar Labstream OS"))?,
|
||
&PredefinedMenuItem::hide_others(h, Some("Ocultar otros"))?,
|
||
&PredefinedMenuItem::show_all(h, Some("Mostrar todo"))?,
|
||
&PredefinedMenuItem::separator(h)?,
|
||
&PredefinedMenuItem::quit(h, Some("Salir de Labstream OS"))?,
|
||
],
|
||
)?;
|
||
let archivo = Submenu::with_items(
|
||
h,
|
||
"Archivo",
|
||
true,
|
||
&[
|
||
&MenuItem::with_id(h, "new-tab", "Nueva pestaña", true, Some("CmdOrCtrl+T"))?,
|
||
&MenuItem::with_id(h, "close-tab", "Cerrar pestaña", true, Some("CmdOrCtrl+W"))?,
|
||
&MenuItem::with_id(h, "reopen-tab", "Reabrir pestaña cerrada", true, Some("CmdOrCtrl+Shift+T"))?,
|
||
&PredefinedMenuItem::separator(h)?,
|
||
&MenuItem::with_id(h, "open-browser", "Abrir esta página en el navegador", true, None::<&str>)?,
|
||
],
|
||
)?;
|
||
let edicion = Submenu::with_items(
|
||
h,
|
||
"Edición",
|
||
true,
|
||
&[
|
||
&PredefinedMenuItem::undo(h, Some("Deshacer"))?,
|
||
&PredefinedMenuItem::redo(h, Some("Rehacer"))?,
|
||
&PredefinedMenuItem::separator(h)?,
|
||
&PredefinedMenuItem::cut(h, Some("Cortar"))?,
|
||
&PredefinedMenuItem::copy(h, Some("Copiar"))?,
|
||
&PredefinedMenuItem::paste(h, Some("Pegar"))?,
|
||
&PredefinedMenuItem::select_all(h, Some("Seleccionar todo"))?,
|
||
],
|
||
)?;
|
||
let vista = Submenu::with_items(
|
||
h,
|
||
"Vista",
|
||
true,
|
||
&[
|
||
&MenuItem::with_id(h, "reload", "Recargar", true, Some("CmdOrCtrl+R"))?,
|
||
&PredefinedMenuItem::separator(h)?,
|
||
&MenuItem::with_id(h, "zoom-in", "Acercar", true, Some("CmdOrCtrl+="))?,
|
||
&MenuItem::with_id(h, "zoom-out", "Alejar", true, Some("CmdOrCtrl+-"))?,
|
||
&MenuItem::with_id(h, "zoom-0", "Tamaño real", true, Some("CmdOrCtrl+0"))?,
|
||
&PredefinedMenuItem::separator(h)?,
|
||
&PredefinedMenuItem::fullscreen(h, Some("Pantalla completa"))?,
|
||
],
|
||
)?;
|
||
let historial = Submenu::with_items(
|
||
h,
|
||
"Historial",
|
||
true,
|
||
&[
|
||
&MenuItem::with_id(h, "nav-back", "Atrás", true, Some("CmdOrCtrl+["))?,
|
||
&MenuItem::with_id(h, "nav-forward", "Adelante", true, Some("CmdOrCtrl+]"))?,
|
||
],
|
||
)?;
|
||
let ventana = Submenu::with_items(
|
||
h,
|
||
"Ventana",
|
||
true,
|
||
&[
|
||
&PredefinedMenuItem::minimize(h, Some("Minimizar"))?,
|
||
&PredefinedMenuItem::maximize(h, Some("Zoom"))?,
|
||
],
|
||
)?;
|
||
let menu = Menu::with_items(h, &[&app_menu, &archivo, &edicion, &vista, &historial, &ventana])?;
|
||
app.set_menu(menu)?;
|
||
}
|
||
|
||
// Manejador de TODOS los menús (el de macOS y el popup ⋮ de ambas plataformas).
|
||
app.on_menu_event(|app, event| match event.id().as_ref() {
|
||
"nav-back" => nav_tab(app, -1),
|
||
"nav-forward" => nav_tab(app, 1),
|
||
"new-tab" => create_tab(app, None, true),
|
||
"close-tab" => {
|
||
if let Some(l) = active_label(app) {
|
||
close_tab(app, &l);
|
||
}
|
||
}
|
||
"reopen-tab" => reopen_tab(app),
|
||
"reload" => reload_tab(app, None),
|
||
"zoom-in" => zoom_step(app, 1),
|
||
"zoom-out" => zoom_step(app, -1),
|
||
"zoom-0" => zoom_step(app, 0),
|
||
"open-browser" => {
|
||
if let Some(url) = active_url(app) {
|
||
let _ = app.opener().open_url(url, None::<&str>);
|
||
}
|
||
}
|
||
id @ ("tab-duplicate" | "tab-copy-url" | "tab-close" | "tab-close-others" | "tab-close-right") => {
|
||
tab_menu_action(app, id)
|
||
}
|
||
id if id.starts_with("tab-color-") => tab_menu_action(app, id),
|
||
"autostart-toggle" => toggle_autostart(app),
|
||
"clear-cache" => {
|
||
let antes = cache::tamano(app);
|
||
cache::vaciar(app);
|
||
// Un aviso nativo confirma que se hizo (y cuánto se liberó): sin él, «vaciar»
|
||
// no da ninguna señal y parece que no pasó nada.
|
||
let _ = app
|
||
.notification()
|
||
.builder()
|
||
.title("Labstream OS")
|
||
.body(format!("Caché de imágenes vaciado ({} liberados).", tamano_legible(antes)))
|
||
.show();
|
||
}
|
||
"check-update" => {
|
||
#[cfg(desktop)]
|
||
tauri::async_runtime::spawn(check_update_manual(app.clone()));
|
||
}
|
||
"quit-app" => {
|
||
save_persisted(app);
|
||
app.exit(0);
|
||
}
|
||
_ => {}
|
||
});
|
||
|
||
// Barra de pestañas (webview local, arriba).
|
||
let scale = win.scale_factor().unwrap_or(1.0);
|
||
let size = win.inner_size()?.to_logical::<f64>(scale);
|
||
win.add_child(
|
||
WebviewBuilder::new(CHROME, WebviewUrl::App("index.html".into()))
|
||
// Sin esto Tauri instala su manejador de arrastre del SISTEMA en el
|
||
// webview y se traga los eventos HTML5 → no se podrían reordenar las
|
||
// pestañas arrastrando. La barra no recibe archivos, así que sobra.
|
||
.disable_drag_drop_handler(),
|
||
LogicalPosition::new(0.0, 0.0),
|
||
LogicalSize::new(size.width, TAB_BAR_H),
|
||
)?;
|
||
|
||
// Pestañas de la sesión anterior (o una nueva si no hay), cada una con su color.
|
||
// El color se empareja con su URL ANTES de filtrar: el filtro por origen puede
|
||
// descartar entradas y entonces los índices de las dos listas dejarían de casar.
|
||
let restore: Vec<(String, String)> = {
|
||
let server = Url::parse(SERVER_URL).expect("URL del servidor válida");
|
||
saved
|
||
.tabs
|
||
.iter()
|
||
.enumerate()
|
||
.filter(|(_, u)| Url::parse(u).map(|p| es_pestana_interna(&p, &server)).unwrap_or(false))
|
||
.take(12)
|
||
.map(|(i, u)| (u.clone(), saved.colors.get(i).cloned().unwrap_or_default()))
|
||
.collect()
|
||
};
|
||
if restore.is_empty() {
|
||
create_tab(&handle, None, true);
|
||
} else {
|
||
for (url, color) in &restore {
|
||
create_tab(&handle, Some(url.clone()), false);
|
||
if !color.is_empty() {
|
||
// create_tab acaba de empujar su pestaña al final de la lista.
|
||
let shell = handle.state::<ShellState>();
|
||
let mut s = shell.lock().unwrap();
|
||
if let Some(t) = s.tabs.last_mut() {
|
||
if t.url == *url {
|
||
t.color = Some(color.clone());
|
||
}
|
||
}
|
||
}
|
||
}
|
||
let idx = saved.active.min(restore.len() - 1);
|
||
let label = {
|
||
let shell = handle.state::<ShellState>();
|
||
let s = shell.lock().unwrap();
|
||
s.tabs.get(idx).map(|t| t.label.clone())
|
||
};
|
||
if let Some(l) = label {
|
||
activate_tab(&handle, &l);
|
||
}
|
||
}
|
||
|
||
// ── Eventos del shell (desde la barra y desde las pestañas) ──
|
||
let h = handle.clone();
|
||
handle.listen_any("ls-ready", move |_| {
|
||
layout_all(&h);
|
||
broadcast(&h);
|
||
});
|
||
let h = handle.clone();
|
||
handle.listen_any("ls-new-tab", move |e| {
|
||
let url = field(e.payload(), "url");
|
||
create_tab(&h, url, true);
|
||
});
|
||
let h = handle.clone();
|
||
handle.listen_any("ls-activate", move |e| {
|
||
if let Some(l) = field(e.payload(), "label") {
|
||
activate_tab(&h, &l);
|
||
}
|
||
});
|
||
let h = handle.clone();
|
||
handle.listen_any("ls-close-tab", move |e| {
|
||
let label = field(e.payload(), "label").or_else(|| active_label(&h));
|
||
if let Some(l) = label {
|
||
close_tab(&h, &l);
|
||
}
|
||
});
|
||
let h = handle.clone();
|
||
handle.listen_any("ls-reload", move |e| {
|
||
reload_tab(&h, field(e.payload(), "label"));
|
||
});
|
||
let h = handle.clone();
|
||
handle.listen_any("ls-zoom", move |e| {
|
||
let dir = field_i64(e.payload(), "dir").unwrap_or(0) as i32;
|
||
zoom_step(&h, dir);
|
||
});
|
||
let h = handle.clone();
|
||
handle.listen_any("ls-cycle", move |e| {
|
||
let dir = field_i64(e.payload(), "dir").unwrap_or(1) as i32;
|
||
cycle_tab(&h, dir);
|
||
});
|
||
let h = handle.clone();
|
||
handle.listen_any("ls-activate-n", move |e| {
|
||
if let Some(n) = field_i64(e.payload(), "n") {
|
||
activate_nth(&h, n.max(1) as usize);
|
||
}
|
||
});
|
||
let h = handle.clone();
|
||
handle.listen_any("ls-nav", move |e| {
|
||
let dir = field_i64(e.payload(), "dir").unwrap_or(-1) as i32;
|
||
nav_tab(&h, dir);
|
||
});
|
||
let h = handle.clone();
|
||
handle.listen_any("ls-reopen", move |_| {
|
||
reopen_tab(&h);
|
||
});
|
||
// Globo de no-leídos: lo emite la web app cuando cambia el conteo del chat.
|
||
let h = handle.clone();
|
||
handle.listen_any("ls-badge", move |e| {
|
||
let n = field_i64(e.payload(), "count").unwrap_or(0);
|
||
set_badge(&h, n);
|
||
});
|
||
let h = handle.clone();
|
||
let h_tabmenu = handle.clone();
|
||
handle.listen_any("ls-tab-menu", move |e| {
|
||
if let Some(label) = field(e.payload(), "label") {
|
||
show_tab_menu(&h_tabmenu, &label);
|
||
}
|
||
});
|
||
let h_reorder = handle.clone();
|
||
handle.listen_any("ls-reorder", move |e| {
|
||
// `order` llega como lista de etiquetas separadas por coma (el payload de los
|
||
// eventos del shell es plano: strings y números).
|
||
if let Some(orden) = field(e.payload(), "order") {
|
||
let v: Vec<String> = orden.split(',').map(|x| x.trim().to_string()).filter(|x| !x.is_empty()).collect();
|
||
reorder_tabs(&h_reorder, v);
|
||
}
|
||
});
|
||
handle.listen_any("ls-menu", move |_| {
|
||
show_app_menu(&h);
|
||
});
|
||
// Botones de ventana de la barra. Solo se pintan en Windows, donde la ventana va
|
||
// sin decoración y no hay aspa del sistema. «close» pasa por CloseRequested, así
|
||
// que hace lo mismo de siempre: ocultar a la bandeja, no salir de la app.
|
||
let h = handle.clone();
|
||
handle.listen_any("ls-window", move |e| {
|
||
let Some(win) = main_window(&h) else { return };
|
||
match field(e.payload(), "act").as_deref() {
|
||
Some("min") => {
|
||
let _ = win.minimize();
|
||
}
|
||
Some("max") => {
|
||
// El repintado del icono ▢/❐ lo dispara el Resized que viene después.
|
||
if win.is_maximized().unwrap_or(false) {
|
||
let _ = win.unmaximize();
|
||
} else {
|
||
let _ = win.maximize();
|
||
}
|
||
}
|
||
Some("close") => {
|
||
let _ = win.close();
|
||
}
|
||
_ => {}
|
||
}
|
||
});
|
||
// Clic en la etiqueta de versión de la barra → buscar actualización (con aviso).
|
||
let h = handle.clone();
|
||
handle.listen_any("ls-check-update", move |_| {
|
||
#[cfg(desktop)]
|
||
tauri::async_runtime::spawn(check_update_manual(h.clone()));
|
||
});
|
||
let h = handle.clone();
|
||
handle.listen_any("ls-title", move |e| {
|
||
let (label, title, url, dark) = (
|
||
field(e.payload(), "label"),
|
||
field(e.payload(), "title"),
|
||
field(e.payload(), "url"),
|
||
field_bool(e.payload(), "dark"),
|
||
);
|
||
if let Some(label) = label {
|
||
let shell = h.state::<ShellState>();
|
||
let mut s = shell.lock().unwrap();
|
||
if let Some(t) = s.tabs.iter_mut().find(|t| t.label == label) {
|
||
if let Some(title) = title {
|
||
t.title = title;
|
||
}
|
||
if let Some(url) = url {
|
||
t.url = url;
|
||
}
|
||
}
|
||
// El tema es global (todas las pestañas del origen comparten modo): el
|
||
// último reporte manda, venga de la pestaña que venga.
|
||
if let Some(dark) = dark {
|
||
s.dark = Some(dark);
|
||
}
|
||
drop(s);
|
||
broadcast(&h);
|
||
save_persisted(&h);
|
||
}
|
||
});
|
||
|
||
// Icono en la bandeja: Abrir / estado del rastreador + pausa / Salir.
|
||
let abrir = MenuItem::with_id(app, "abrir", "Abrir Labstream", true, None::<&str>)?;
|
||
let salir = MenuItem::with_id(app, "salir", "Salir", true, None::<&str>)?;
|
||
let (trk_estado, trk_toggle) = tracker::armar_menu(app.handle())?;
|
||
let sep1 = PredefinedMenuItem::separator(app)?;
|
||
let sep2 = PredefinedMenuItem::separator(app)?;
|
||
let menu = Menu::with_items(app, &[&abrir, &sep1, &trk_estado, &trk_toggle, &sep2, &salir])?;
|
||
|
||
TrayIconBuilder::with_id("main-tray")
|
||
.icon(app.default_window_icon().unwrap().clone())
|
||
.tooltip("Labstream OS")
|
||
.menu(&menu)
|
||
.show_menu_on_left_click(false)
|
||
.on_menu_event(|app, event| match event.id.as_ref() {
|
||
"abrir" => show_main(app),
|
||
"salir" => {
|
||
save_persisted(app);
|
||
app.exit(0);
|
||
}
|
||
id if tracker::menu_event(app, id) => {}
|
||
_ => {}
|
||
})
|
||
.on_tray_icon_event(|tray, event| {
|
||
// Clic izquierdo en el icono → mostrar la ventana.
|
||
if let TrayIconEvent::Click {
|
||
button: MouseButton::Left,
|
||
button_state: MouseButtonState::Up,
|
||
..
|
||
} = event
|
||
{
|
||
show_main(tray.app_handle());
|
||
}
|
||
})
|
||
.build(app)?;
|
||
|
||
// El sensor del rastreador: listener de vinculación + hilo de medición.
|
||
tracker::iniciar(app.handle());
|
||
|
||
Ok(())
|
||
})
|
||
.on_window_event(|window, event| {
|
||
match event {
|
||
// Cerrar la ventana = ocultarla a la bandeja (la app sigue notificando).
|
||
WindowEvent::CloseRequested { api, .. } => {
|
||
save_persisted(window.app_handle());
|
||
let _ = window.hide();
|
||
api.prevent_close();
|
||
}
|
||
// La barra y las pestañas siguen el tamaño de la ventana.
|
||
WindowEvent::Resized(_) | WindowEvent::ScaleFactorChanged { .. } => {
|
||
let app = window.app_handle();
|
||
layout_all(app);
|
||
// Maximizar/restaurar llega como un Resized más: si el estado cambió, la
|
||
// barra tiene que repintar su icono ▢/❐. Se compara antes de emitir para
|
||
// no repintarla en cada píxel mientras se arrastra un borde.
|
||
let maxi = window.is_maximized().unwrap_or(false);
|
||
let cambio = {
|
||
let shell = app.state::<ShellState>();
|
||
let mut s = shell.lock().unwrap();
|
||
let antes = s.maximized;
|
||
s.maximized = maxi;
|
||
antes != maxi
|
||
};
|
||
if cambio {
|
||
broadcast(app);
|
||
}
|
||
// La geometría MAXIMIZADA no se guarda: al reabrir volvería como ventana
|
||
// normal del tamaño de la pantalla y, sin decoración, taparía la barra de
|
||
// tareas. Se conserva la última geometría restaurada.
|
||
if !maxi {
|
||
if let (Ok(pos), Ok(size)) = (window.outer_position(), window.inner_size()) {
|
||
let scale = window.scale_factor().unwrap_or(1.0);
|
||
let p = pos.to_logical::<f64>(scale);
|
||
let s = size.to_logical::<f64>(scale);
|
||
let shell = app.state::<ShellState>();
|
||
shell.lock().unwrap().win =
|
||
Some(WinRect { x: p.x, y: p.y, w: s.width, h: s.height });
|
||
}
|
||
}
|
||
}
|
||
WindowEvent::Moved(_) => {
|
||
let app = window.app_handle();
|
||
if window.is_maximized().unwrap_or(false) {
|
||
return; // ver arriba: maximizada no se guarda
|
||
}
|
||
if let (Ok(pos), Ok(size)) = (window.outer_position(), window.inner_size()) {
|
||
let scale = window.scale_factor().unwrap_or(1.0);
|
||
let p = pos.to_logical::<f64>(scale);
|
||
let s = size.to_logical::<f64>(scale);
|
||
let shell = app.state::<ShellState>();
|
||
shell.lock().unwrap().win =
|
||
Some(WinRect { x: p.x, y: p.y, w: s.width, h: s.height });
|
||
}
|
||
}
|
||
_ => {}
|
||
}
|
||
})
|
||
.build(tauri::generate_context!())
|
||
.expect("error al arrancar Labstream OS");
|
||
|
||
app.run(|app, event| {
|
||
// macOS: clic en el icono del Dock con la ventana oculta → reabrirla.
|
||
#[cfg(target_os = "macos")]
|
||
if let tauri::RunEvent::Reopen { .. } = event {
|
||
show_main(app);
|
||
}
|
||
// Al salir del todo, guarda el estado (pestañas, zoom, ventana).
|
||
if let tauri::RunEvent::ExitRequested { .. } = event {
|
||
save_persisted(app);
|
||
}
|
||
let _ = app;
|
||
});
|
||
}
|