diff --git a/i18n/en/Archive.resx b/i18n/en/Archive.resx
index 3c1d2424..951c7220 100644
--- a/i18n/en/Archive.resx
+++ b/i18n/en/Archive.resx
@@ -4,16 +4,37 @@
2.0
System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
+ {0:N0} sequence changed
+ {0:N0} sequences changed
+ offline
+ online
+ read-only
+ The archive must be online and writable.long
+ By camera
+ By format
{0} · {1} · {2}invariant
+ Photos per month
{0:N0} other
{0:N0} others
Other
{0} · {1} · {2}invariant
+ Storage by year
Unknown camera
{0} · {1} · {2}invariant
+ Keep row
+ Remove row
+ Remove {0} from the index?long
+ Its sidecar is gone. Only the index row is removed; no file is deleted.long
+ Cancel
{0:N0} copy
{0:N0} copies
+ Folder
+ {0:N0} group
+ {0:N0} groups
+ Mark copies
+ Open
{0} · {1}invariant
+ Duplicates
No archive yet
Another Titano ({0}) is writing here. Try again shortly.long: error sentence
The copy of {0} does not match the original.long: error sentence
@@ -24,11 +45,19 @@
{0} changed after the plan was made.long: error sentence
The card or folder {0} is no longer available.long: error sentence
The archive changed after this plan was made.long: error sentence
+ None found
+ Find
+ Searching…
Every sequence verified
Every sequence analysed
{0} missing · {1} damaged
{0:N0} duplicate frame
{0:N0} duplicate frames
+ Analyse
+ Show
+ Find
+ Build
+ Verify
No missing frames
No duplicate frames
{0:N0} sequence lacks proxies
@@ -36,8 +65,10 @@
{0:N0} sequence not analysed
{0:N0} sequences not analysed
Every sequence has proxies
+ Index health
{0:N0} sequence unverified
{0:N0} sequences unverified
+ Last scan {0} · {1}long
Dry run: nothing was changed.long: job log line
Not indexed: {0} ({1})long: job log line
Changed: {0}long: job log line
@@ -51,16 +82,71 @@
{0} folders, {1} indexed, {2} adopted, {3} removedlong: job log line
Sequence not found: {0}long: job log line
{0} photos checked, {1} intact, {2} hashed, {3} with problemslong: job log line
+ Dry run
+ Rebuild proxies
+ Relink moved archive…
+ Run maintenance
+ {0:N0} issue
+ {0:N0} issues
+ The orphan search stoppedlong
+ Reconcile
+ Remove row
+ Scan
+ Index
+ The fix did not completelong
+ Files missing
+ Row without sidecar
+ Folder not indexed
+ Photos not listed
{0:N0} file missing
{0:N0} files missing
Not indexed yet
No sidecar in {0}long
+ Orphans
{0:N0} photo not in sidecar
{0:N0} photos not in sidecar
+ Archive
+ Counting…
+ Rebuild index
+ Indexed now
+ Without sidecar
+ Folder
+ Sidecars
+ Rebuild
+ State
+ History
{0} · {1}invariant
+ Recent maintenance
+ {0} relinkedlong
+ The archive could not be relinkedlong
+ Folder of the moved archive
+ Apply
+ {0} of {1}
+ Rename {0:N0} sequence
+ Rename {0:N0} sequences
+ Move {0:N0} sequence
+ Move {0:N0} sequences
+ Changes
{0:N0} of {1:N0} changes
{0:N0} of {1:N0} change
+ Template
+ Add tags
+ Apply
+ Tags of {0:N0} sequence
+ Tags of {0:N0} sequences
Each tag has 1 to {0} characters.long
+ Remove tags
+ {0:N0} sequence · all
+ {0:N0} sequences · all
+ Analyse
+ Export CSV
+ Selected set
+ Move…
+ Proxies
+ Rename…
+ Retag…
+ Thumbnails
+ Verify
camera
cameras
{0:N0} format
@@ -72,5 +158,17 @@
sequence
sequences
{0} – {1}invariant
+ Adopt folder…
+ Archive
+ Duplicates
+ Maintenance
+ Orphans
+ Rebuild index…
+ Scan
+ Verify
+ Archive tree
Undated
+ Maintenance
+ View
+ Overview
diff --git a/i18n/en/Import.resx b/i18n/en/Import.resx
index 6443da66..1b9a34e4 100644
--- a/i18n/en/Import.resx
+++ b/i18n/en/Import.resx
@@ -8,29 +8,79 @@
Copy
Already in archive
Imported before
+ Deep analysis
+ Delete imported
+ Eject
+ Format card
+ Keep card
+ Available once the card is remembered.long
Formatting needs a complete import with verified copies.long
+ Create or adopt an archive first (Library or Settings).long
Only for a remembered card that is inserted.long
Check the card first: every file and its copy are hashed again.long
+ Wait for the plan of the card.long
+ Sign in to a Titano Server first.long
Some photos on the card have no verified copy; formatting would lose them.long
Only imports into this PC's archive can be checked against the card.long
+ Insert the card first.long
+ Only removable cards can be ejected.long
Nothing from this card has been imported yet.long
+ Every photo is already imported or in the archive.long
No photo on the card matches a verified copy.long
+ Not enough free space at the destination.long
+ Fix the name templates first.long
+ Delete
+ Delete {0:N0} photo from the card?long
+ Delete {0:N0} photos from the card?long
+ Each one was hashed again on the card and in the archive just now. Files changed since are kept.long
+ Forget
+ Forget {0}?long
+ Its nickname, settings and import history are removed. Photos on the card and in the archive stay.long
+ Format
+ Format {0}?long
+ {0:N0} photo was copied and verified. Formatting removes everything on the card.long
+ {0:N0} photos were copied and verified. Formatting removes everything on the card.long
+ Keep card
+ Keep
+ Type the card name to confirmlong
+ Archive
+ Choose folder
+ Folder
+ Folder path
+ Not connected
+ Server
+ Close
+ Action
+ Destination
+ On the card
copy {0} ({1})
{0:N0} file
{0:N0} files
Session {0} · {1}long
+ Plan
Cannot read {0}: {1}long
{0} · not insertedlong
{0} #{1}invariant
- {0} · {1} · {2} used
- {0} · no DCIM · {1} free
+ {0} · {1} used
+ last import {0}
+ no DCIM · {0} free
serial {0}
Known card, not inserted
Drive without DCIM
Folder
Known card
New card
+ Import automatically
+ Folder…
+ Refresh devices
+ Devices
+ Import again
+ Skip
Insert a card or pick a folder
+ Checking {0:N0} photo
+ Checking {0:N0} photos
+ Delete {0:N0} photo…
+ Delete {0:N0} photos…
{0:N0} kept
{0:N0} kept
{0} · {1}invariant
@@ -41,6 +91,18 @@
no longer on the card
{0:N0} verified on the card
{0:N0} verified on the card
+ Retry
+ Import into folder
+ Import from folder
+ After import
+ Destination
+ Duplicates
+ Names
+ Scan
+ File template
+ Folder template
+ → {0}invariant
+ Template tokens
about {0}
{0:N0} duplicate
{0:N0} duplicates
@@ -49,13 +111,100 @@
{0:N0} imported before
{0:N0} session
{0:N0} sessions
+ Show plan
{0} missing
+ Plan
+ Copy settings from
+ Edit
+ Forget card…
+ Card nickname
+ Rename
+ {0} of {1}
+ Cancel
+ {0} of {1}
+ Starting…
+ {0:N0} already there
+ {0:N0} already there
+ Check card
+ {0:N0} copied
+ {0:N0} copied
+ Eject
+ {0} · {1}invariant
+ Failed photos
+ Format card…
+ Open in Library
+ New import
No archive copy after the import; see the job log.long
+ {0} copied · {1} failedlong
+ {0:N0} skipped
+ {0:N0} skipped
+ {0:N0} copied and verified
+ {0:N0} copied and verified
+ frames
+ gap
+ Session gap in minutes
+ min
+ Minimum frames per session
+ min
+ Sessions
+ Subfolders
+ Verify hashes
Adds to · {0}long
+ adds
+ Camera
+ Frames · interval
+ Sequence
+ Session
+ Size
{0} · {1}invariant
New · {0}long
+ new
Server
{0} · {1} → {2}invariant
Import {0:N0} photo
Import {0:N0} photos
+ Import
+ Import cancelled
+ Choose a card or a folder.long
+ Insert this card to plan its import.long
+ The card could not be read: {0}long
+ Reading the card…
+ {0:N0} photo read
+ {0:N0} photos read
+ Importing with its saved settingslong
+ Cancel
+ The card check stoppedlong
+ Deleting from the card stoppedlong
+ {0:N0} photo deleted from the cardlong
+ {0:N0} photos deleted from the cardlong
+ {0} importedlong
+ {0} can be removedlong
+ {0} could not be ejectedlong
+ {0} is in use; close its files and retrylong
+ Format of {0} cancelledlong
+ {0} was not formattedlong
+ {0} formattedlong
+ Import
+ {0} insertedlong
+ Resume
+ The interrupted import can continuelong
+ Importing {0}long
+ Aperture
+ Camera name
+ Capture date
+ Day of the month
+ Original extension
+ Hour and minute
+ ISO
+ Lens
+ Month
+ Frame number
+ Original name
+ Frame number in session
+ Session number
+ Session start time
+ Shutter speed
+ Capture time
+ Sequence title
+ Capture year
diff --git a/i18n/en/Tooltips.resx b/i18n/en/Tooltips.resx
index 7ca6cbe4..460744d5 100644
--- a/i18n/en/Tooltips.resx
+++ b/i18n/en/Tooltips.resx
@@ -12,9 +12,120 @@
Open the public releases page in the browser
Every language but English is machine-translated; propose a better wording on the public issue tracker
Titano uses no third-party code: everything beyond .NET and Windows is written in-house
+ Index an existing folder tree in place; nothing is moved or renamed
+ The archive folder cannot be reached; the index stays as last seen
+ The archive folder is reachable and writable
+ Readable but not writable: browse only
+ Photos per camera; the smallest are grouped
+ Close without changing anything · Esc
+ Hide the sequences of this year
+ Show the folder of the first copy in Explorer
+ Open the sequence of the first copy in the editor
+ Find identical photos across sequences by hash · reads the index only
+ Show the sequences of this year
+ Queue the light analysis of these sequences
+ Find the duplicate groups
+ Find files and rows that do not match
+ Queue proxy generation for these sequences
+ Re-hash the originals of these sequences
+ Folder template; the title token is the new title · checked as you type
+ Photos per file format
+ Nothing to fix
+ Needs attention; the button fixes it
+ Open the job history
+ Keep the index row
+ Last incremental scan: when it finished and how long it took
+ Leases, temporary files, thumbnail packs and duplicate flags; relink a moved archive
+ List what maintenance would change, without changing it
+ Rebuild every proxy of the archive · runs in the background
+ Clean stale leases and temporary files, compact thumbnail packs, mark duplicates · originals untouched
+ Index health, duplicates, orphans and recent maintenance
+ Flag every copy after the first so renders skip it · runs maintenance
+ Photos per month by first capture
+ Find photos not in a sidecar, frames without a file and folders not indexed · reads the archive
+ Mark the missing files in the sidecar and the index
+ Remove the index row; no file is deleted
+ Scan the archive to index this folder
+ Add these photos to the sequence's sidecar and index
+ Tree, figures and charts
+ Choose which archive to manage
+ Choose which archive to manage · {0}
+ Rebuild the index from the sidecars; falls back to a full metadata scan; never deletes originals
+ Queue the rebuild · the archive stays usable meanwhile
+ Choose the new folder of an archive you moved; its sequences follow
+ Make exactly these changes to folders, sidecars and index · resumes after a crash
+ Change the tags of these sequences in sidecars and index
+ Incremental scan: new, changed and removed files by modification time and size
+ The selected years and sequences; nothing selected means all
+ Run the deep analysis on every sequence in the set
+ Export the set as CSV: one row per sequence
+ Move the set into a new folder layout · dry run first
+ Generate or refresh proxies
+ Rename the titles of the set with a template · dry run first
+ Add or remove tags on the whole set
+ Generate or refresh thumbnails
+ Re-hash the originals of the set
+ Bytes of originals per capture year
+ Tags to add, separated by commas
+ Tags to remove, separated by commas
+ Title template; the title token is the current title · checked as you type
+ Re-hash every original and report bit rot · reads the whole archive
Dismiss
Open the folder with the log files
Return to the advisor's value
+ Import photos already in the archive again; nothing is overwritten
+ Copy into this PC's archive with the naming templates · {0}
+ Start the import with this card's settings as soon as it is inserted; a toast lets you cancel
+ Stop copying; verified copies stay and the import can resume
+ Do not import this card now
+ Hash every imported file on the card and its archive copy again · reads both
+ Choose the destination folder
+ Close the plan
+ Resolved or reported by the plan before copying
+ Use another card's saved settings
+ Queue the deep analysis of every imported sequence (runs in the background)
+ Delete from the card only the photos verified just now; asks first
+ After the import, offer to delete only the files whose copy was verified
+ Photos already in the archive (same hash)
+ Rename this card, copy settings from another card, or forget it
+ Safely eject the card
+ Safely eject the card when done
+ The import stopped; verified copies were kept
+ File template; the extension is kept · checked as you type
+ Import from any folder on this PC or on the network
+ Copy into a folder of your choice; not indexed unless you adopt it later
+ Folder used when the destination is Folder
+ Folder template · checked as you type
+ Remove this card's nickname, settings and history; photos stay
+ Open the Windows format dialog after a typed confirmation
+ After the import, offer the Windows format dialog once every copy is verified
+ Open the Windows format dialog
+ Minutes without photos that start a new session
+ Photos imported from this card before (same name, size and time)
+ Leave the card untouched
+ Keep every photo on the card
+ Keep this card remembered
+ This photo stays on the card
+ Show the imported sequences in the Library
+ Groups smaller than this join the previous session
+ Plan this card again
+ Name of this card in Titano · Enter saves
+ Open Import with this card selected
+ Look again for cards and folders with a DCIM tree
+ Change the nickname of this card
+ Copies hashed while copying and read back from the destination
+ Continue the interrupted import where it stopped
+ Continue the import where it stopped
+ Stream the frames to the server; each one counts once the server confirms its hash
+ Sequence title · empty keeps the folder name · Enter saves
+ Split the card into sessions when the gap between two photos exceeds the limit
+ Show every file, where it goes and what the plan resolved
+ Leave photos already in the archive (same hash) on the card
+ Free space at the destination after the import; on a server, what your quota leaves
+ Copy with verification; the card is only touched after every hash matches · Ctrl+Enter
+ Look inside every subfolder of the source
+ Insert a token into the template used last
+ Hash while copying and read the destination back before the source is touched
Stop this job; Retry continues later from its last checkpoint
Hide finished jobs from the list; they stay in the history
Every job
diff --git a/i18n/it/Archive.it.resx b/i18n/it/Archive.it.resx
index 3c0c36a7..8689b0be 100644
--- a/i18n/it/Archive.it.resx
+++ b/i18n/it/Archive.it.resx
@@ -4,12 +4,33 @@
2.0
System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
+ {0:N0} sequenza modificata
+ {0:N0} sequenze modificate
+ offline
+ online
+ sola lettura
+ L'archivio deve essere raggiungibile e scrivibile.
+ Per fotocamera
+ Per formato
+ Foto al mese
{0:N0} altra
{0:N0} altre
Altro
+ Spazio per anno
Fotocamera ignota
+ Mantieni riga
+ Rimuovi riga
+ Rimuovere {0} dall'indice?
+ Il suo sidecar non c'è più. Viene rimossa solo la riga dell'indice; nessun file viene eliminato.
+ Annulla
{0:N0} copia
{0:N0} copie
+ Cartella
+ {0:N0} gruppo
+ {0:N0} gruppi
+ Segna copie
+ Apri
+ Doppioni
Nessun archivio
Un altro Titano ({0}) sta scrivendo qui. Riprova tra poco.
La copia di {0} non corrisponde all'originale.
@@ -20,11 +41,19 @@
{0} è cambiato dopo la creazione del piano.
La scheda o cartella {0} non è più disponibile.
L'archivio è cambiato dopo la creazione del piano.
+ Nessuno trovato
+ Cerca
+ Ricerca…
Tutte le sequenze verificate
Tutte le sequenze analizzate
{0} mancanti · {1} danneggiati
{0:N0} fotogramma doppio
{0:N0} fotogrammi doppi
+ Analizza
+ Mostra
+ Cerca
+ Crea
+ Verifica
Nessun fotogramma mancante
Nessun fotogramma doppio
{0:N0} sequenza senza proxy
@@ -32,8 +61,10 @@
{0:N0} sequenza non analizzata
{0:N0} sequenze non analizzate
Proxy pronti per tutte
+ Stato dell'indice
{0:N0} sequenza non verificata
{0:N0} sequenze non verificate
+ Ultima scansione {0} · {1}
Prova: nulla è stato modificato.
Non indicizzata: {0} ({1})
Modificato: {0}
@@ -47,15 +78,70 @@
{0} cartelle, {1} indicizzate, {2} adottate, {3} rimosse
Sequenza non trovata: {0}
{0} foto controllate, {1} integre, {2} con impronta nuova, {3} con problemi
+ Simulazione
+ Ricrea proxy
+ Ricollega archivio spostato…
+ Esegui manutenzione
+ {0:N0} problema
+ {0:N0} problemi
+ Ricerca degli orfani interrotta
+ Riallinea
+ Rimuovi riga
+ Scansiona
+ Indicizza
+ La correzione non è stata completata
+ File mancanti
+ Riga senza sidecar
+ Cartella non indicizzata
+ Foto non elencate
{0:N0} file mancante
{0:N0} file mancanti
Non ancora indicizzata
Nessun sidecar in {0}
+ Orfani
{0:N0} foto fuori dal sidecar
{0:N0} foto fuori dal sidecar
+ Archivio
+ Conteggio…
+ Ricostruisci indice
+ Ora nell'indice
+ Senza sidecar
+ Cartella
+ Sidecar
+ Ricostruisci
+ Stato
+ Cronologia
+ Manutenzione recente
+ {0} ricollegato
+ Impossibile ricollegare l'archivio
+ Nuova cartella dell'archivio
+ Applica
+ {0} di {1}
+ Rinomina {0:N0} sequenza
+ Rinomina {0:N0} sequenze
+ Sposta {0:N0} sequenza
+ Sposta {0:N0} sequenze
+ Modifiche
{0:N0} di {1:N0} cambia
{0:N0} di {1:N0} cambiano
+ Modello
+ Aggiungi tag
+ Applica
+ Tag di {0:N0} sequenza
+ Tag di {0:N0} sequenze
Ogni tag ha da 1 a {0} caratteri.
+ Rimuovi tag
+ {0:N0} sequenza · tutte
+ {0:N0} sequenze · tutte
+ Analizza
+ Esporta CSV
+ Insieme scelto
+ Sposta…
+ Proxy
+ Rinomina…
+ Tag…
+ Miniature
+ Verifica
fotocamera
fotocamere
{0:N0} formato
@@ -66,5 +152,17 @@
foto
sequenza
sequenze
+ Adotta cartella…
+ Archivio
+ Doppioni
+ Manutenzione
+ Orfani
+ Ricostruisci indice…
+ Scansiona
+ Verifica
+ Albero dell'archivio
Senza data
+ Manutenzione
+ Vista
+ Panoramica
diff --git a/i18n/it/Import.it.resx b/i18n/it/Import.it.resx
index eec667fb..02ead40b 100644
--- a/i18n/it/Import.it.resx
+++ b/i18n/it/Import.it.resx
@@ -8,28 +8,78 @@
Copia
Già in archivio
Già importata
+ Analisi profonda
+ Elimina importate
+ Espelli
+ Formatta scheda
+ Mantieni scheda
+ Disponibile quando la scheda è memorizzata.
Per formattare serve un'importazione completa con copie verificate.
+ Crea o adotta prima un archivio (Libreria o Impostazioni).
Solo per una scheda nota e inserita.
Controlla prima la scheda: ogni file e la sua copia vengono verificati di nuovo.
+ Attendi il piano della scheda.
+ Accedi prima a un Titano Server.
Alcune foto della scheda non hanno una copia verificata: formattando andrebbero perse.
Solo le importazioni nell'archivio di questo PC si possono confrontare con la scheda.
+ Inserisci prima la scheda.
+ Si possono espellere solo schede rimovibili.
Da questa scheda non è ancora stato importato nulla.
+ Ogni foto è già importata o in archivio.
Nessuna foto della scheda corrisponde a una copia verificata.
+ Spazio libero insufficiente nella destinazione.
+ Correggi prima i modelli dei nomi.
+ Elimina
+ Eliminare {0:N0} foto dalla scheda?
+ Eliminare {0:N0} foto dalla scheda?
+ Ognuna è stata appena verificata di nuovo sulla scheda e in archivio. I file modificati da allora vengono mantenuti.
+ Dimentica
+ Dimenticare {0}?
+ Soprannome, impostazioni e cronologia delle importazioni vengono rimossi. Le foto sulla scheda e in archivio restano.
+ Formatta
+ Formattare {0}?
+ {0:N0} foto è stata copiata e verificata. La formattazione cancella tutto il contenuto della scheda.
+ {0:N0} foto sono state copiate e verificate. La formattazione cancella tutto il contenuto della scheda.
+ Mantieni scheda
+ Mantieni
+ Scrivi il nome della scheda per confermare
+ Archivio
+ Scegli cartella
+ Cartella
+ Percorso cartella
+ Non connesso
+ Server
+ Chiudi
+ Azione
+ Destinazione
+ Sulla scheda
copia {0} ({1})
{0:N0} file
{0:N0} file
Sessione {0} · {1}
+ Piano
Impossibile leggere {0}: {1}
{0} · non inserita
- {0} · {1} · {2} occupati
- {0} · senza DCIM · {1} liberi
+ {0} · {1} occupati
+ ultima importazione {0}
+ senza DCIM · {0} liberi
seriale {0}
Scheda nota, non inserita
Unità senza DCIM
Cartella
Scheda nota
Nuova scheda
+ Importa automaticamente
+ Cartella…
+ Aggiorna dispositivi
+ Dispositivi
+ Importa di nuovo
+ Salta
Inserisci una scheda o una cartella
+ Verifica di {0:N0} foto
+ Verifica di {0:N0} foto
+ Elimina {0:N0} foto…
+ Elimina {0:N0} foto…
{0:N0} conservata
{0:N0} conservate
la copia in archivio è diversa
@@ -39,6 +89,17 @@
non più sulla scheda
{0:N0} verificata sulla scheda
{0:N0} verificate sulla scheda
+ Riprova
+ Importa nella cartella
+ Importa dalla cartella
+ Dopo l'importazione
+ Destinazione
+ Doppioni
+ Nomi
+ Scansione
+ Modello file
+ Modello cartella
+ Segnaposto
circa {0}
{0:N0} doppione
{0:N0} doppioni
@@ -47,11 +108,97 @@
{0:N0} già importate
{0:N0} sessione
{0:N0} sessioni
+ Mostra piano
mancano {0}
+ Piano
+ Copia impostazioni da
+ Modifica
+ Dimentica scheda…
+ Nome della scheda
+ Rinomina
+ {0} di {1}
+ Annulla
+ {0} di {1}
+ Avvio…
+ {0:N0} già presente
+ {0:N0} già presenti
+ Controlla scheda
+ {0:N0} copiata
+ {0:N0} copiate
+ Espelli
+ Foto non riuscite
+ Formatta scheda…
+ Apri nella Libreria
+ Nuova importazione
Nessuna copia in archivio dopo l'importazione: vedi il registro dell'attività.
+ {0} copiate · {1} non riuscite
+ {0:N0} saltata
+ {0:N0} saltate
+ {0:N0} copiata e verificata
+ {0:N0} copiate e verificate
+ fotogrammi
+ pausa
+ Pausa tra sessioni (min)
+ minimo
+ Minimo fotogrammi a sessione
+ min
+ Sessioni
+ Sottocartelle
+ Verifica hash
Si aggiunge a · {0}
+ aggiunge
+ Fotocamera
+ Fotogrammi · intervallo
+ Sequenza
+ Sessione
+ Dimensione
Nuova · {0}
+ nuova
Server
Importa {0:N0} foto
Importa {0:N0} foto
+ Importa
+ Importazione annullata
+ Scegli una scheda o una cartella.
+ Inserisci questa scheda per pianificarne l'importazione.
+ Impossibile leggere la scheda: {0}
+ Lettura della scheda…
+ {0:N0} foto letta
+ {0:N0} foto lette
+ Importazione con le impostazioni salvate
+ Annulla
+ Controllo della scheda interrotto
+ Eliminazione dalla scheda interrotta
+ {0:N0} foto eliminata dalla scheda
+ {0:N0} foto eliminate dalla scheda
+ Importazione di {0} completata
+ {0} può essere rimossa
+ Impossibile espellere {0}
+ {0} è in uso: chiudi i suoi file e riprova
+ Formattazione di {0} annullata
+ {0} non è stata formattata
+ {0} formattata
+ Importa
+ {0} inserita
+ Riprendi
+ L'importazione interrotta può continuare
+ Importazione di {0}
+ Diaframma
+ Nome fotocamera
+ Data di scatto
+ Giorno del mese
+ Estensione originale
+ Ora e minuti
+ ISO
+ Obiettivo
+ Mese
+ Numero fotogramma
+ Nome originale
+ Numero nella sessione
+ Numero di sessione
+ Inizio della sessione
+ Tempo di posa
+ Ora di scatto
+ Titolo della sequenza
+ Anno di scatto
diff --git a/i18n/it/Tooltips.it.resx b/i18n/it/Tooltips.it.resx
index c81ad08f..ea3bf870 100644
--- a/i18n/it/Tooltips.it.resx
+++ b/i18n/it/Tooltips.it.resx
@@ -12,9 +12,120 @@
Apri la pagina pubblica delle versioni nel browser
Tutte le lingue tranne l'inglese sono tradotte automaticamente; proponi una formulazione migliore nel tracker pubblico
Titano non usa codice di terze parti: tutto ciò che va oltre .NET e Windows è scritto internamente
+ Indicizza sul posto una cartella esistente; nulla viene spostato o rinominato
+ La cartella dell'archivio non è raggiungibile; l'indice resta com'era
+ La cartella dell'archivio è raggiungibile e scrivibile
+ Leggibile ma non scrivibile: solo consultazione
+ Foto per fotocamera; le minori sono raggruppate
+ Chiudi senza modificare nulla · Esc
+ Nascondi le sequenze di quest'anno
+ Mostra in Esplora risorse la cartella della prima copia
+ Apri nell'editor la sequenza della prima copia
+ Trova foto identiche tra le sequenze tramite hash · legge solo l'indice
+ Mostra le sequenze di quest'anno
+ Metti in coda l'analisi rapida di queste sequenze
+ Trova i gruppi di doppioni
+ Trova file e righe che non corrispondono
+ Metti in coda la creazione dei proxy per queste sequenze
+ Ricalcola l'hash degli originali di queste sequenze
+ Modello della cartella; il segnaposto title è il nuovo titolo · controllato mentre scrivi
+ Foto per formato di file
+ Nulla da correggere
+ Richiede attenzione; il pulsante lo risolve
+ Apri la cronologia delle attività
+ Mantieni la riga dell'indice
+ Ultima scansione incrementale: quando è finita e quanto è durata
+ Lease, file temporanei, pacchetti di miniature e segni dei doppioni; ricollega un archivio spostato
+ Elenca cosa cambierebbe la manutenzione, senza cambiarlo
+ Ricrea tutti i proxy dell'archivio · in background
+ Pulisce lease scaduti e file temporanei, compatta le miniature, segna i doppioni · originali intatti
+ Stato dell'indice, doppioni, orfani e manutenzione recente
+ Segna ogni copia dopo la prima perché i render la saltino · esegue la manutenzione
+ Foto al mese per data del primo scatto
+ Trova foto fuori dai sidecar, fotogrammi senza file e cartelle non indicizzate · legge l'archivio
+ Segna i file mancanti nel sidecar e nell'indice
+ Rimuove la riga dell'indice; nessun file viene eliminato
+ Scansiona l'archivio per indicizzare questa cartella
+ Aggiunge queste foto al sidecar e all'indice della sequenza
+ Albero, cifre e grafici
+ Scegli quale archivio gestire
+ Scegli quale archivio gestire · {0}
+ Ricostruisce l'indice dai sidecar; se mancano legge i metadati; non elimina mai gli originali
+ Metti in coda la ricostruzione · l'archivio resta utilizzabile
+ Scegli la nuova cartella di un archivio spostato; le sequenze lo seguono
+ Applica esattamente queste modifiche a cartelle, sidecar e indice · riprende dopo un arresto
+ Cambia i tag di queste sequenze in sidecar e indice
+ Scansione incrementale: file nuovi, modificati e rimossi per data e dimensione
+ Anni e sequenze selezionati; senza selezione, tutte
+ Esegui l'analisi profonda su ogni sequenza dell'insieme
+ Esporta l'insieme in CSV: una riga per sequenza
+ Sposta l'insieme in una nuova struttura di cartelle · prima la prova
+ Crea o aggiorna i proxy
+ Rinomina i titoli dell'insieme con un modello · prima la prova
+ Aggiungi o rimuovi tag su tutto l'insieme
+ Crea o aggiorna le miniature
+ Ricalcola l'hash degli originali dell'insieme
+ Spazio degli originali per anno di scatto
+ Tag da aggiungere, separati da virgole
+ Tag da rimuovere, separati da virgole
+ Modello del titolo; il segnaposto title è il titolo attuale · controllato mentre scrivi
+ Ricalcola l'hash di ogni originale e segnala i danni · legge tutto l'archivio
Chiudi
Apri la cartella dei file di log
Torna al valore consigliato
+ Importa di nuovo le foto già in archivio; nulla viene sovrascritto
+ Copia nell'archivio di questo PC con i modelli dei nomi · {0}
+ Avvia l'importazione con le impostazioni della scheda appena viene inserita; un avviso permette di annullare
+ Ferma la copia; le copie verificate restano e l'importazione può riprendere
+ Non importare ora questa scheda
+ Ricalcola l'hash di ogni file importato sulla scheda e della sua copia · legge entrambi
+ Scegli la cartella di destinazione
+ Chiudi il piano
+ Risolto o segnalato dal piano prima della copia
+ Usa le impostazioni salvate di un'altra scheda
+ Metti in coda l'analisi profonda di ogni sequenza importata (in background)
+ Elimina dalla scheda solo le foto appena verificate; chiede conferma
+ Dopo l'importazione, proponi di eliminare solo i file con copia verificata
+ Foto già in archivio (stesso hash)
+ Rinomina la scheda, copia le impostazioni da un'altra o dimenticala
+ Espelli la scheda in sicurezza
+ Espelli la scheda in sicurezza al termine
+ L'importazione si è fermata; le copie verificate sono state mantenute
+ Modello del file; l'estensione resta · controllato mentre scrivi
+ Importa da una cartella di questo PC o della rete
+ Copia in una cartella a scelta; non indicizzata finché non la adotti
+ Cartella usata quando la destinazione è Cartella
+ Modello della cartella · controllato mentre scrivi
+ Rimuovi soprannome, impostazioni e cronologia della scheda; le foto restano
+ Apri la formattazione di Windows dopo una conferma scritta
+ Dopo l'importazione, proponi la formattazione di Windows quando ogni copia è verificata
+ Apri la formattazione di Windows
+ Minuti senza foto che avviano una nuova sessione
+ Foto già importate da questa scheda (stesso nome, dimensione e data)
+ Lascia intatta la scheda
+ Mantieni tutte le foto sulla scheda
+ Mantieni la scheda in memoria
+ Questa foto resta sulla scheda
+ Mostra le sequenze importate nella Libreria
+ I gruppi più piccoli si uniscono alla sessione precedente
+ Pianifica di nuovo questa scheda
+ Nome della scheda in Titano · Invio salva
+ Apri Importa con questa scheda selezionata
+ Cerca di nuovo schede e cartelle con DCIM
+ Cambia il nome della scheda
+ Copie verificate con hash durante la copia e rilette dalla destinazione
+ Continua l'importazione interrotta da dove si è fermata
+ Continua l'importazione da dove si è fermata
+ Invia i fotogrammi al server; ognuno conta quando il server ne conferma l'hash
+ Titolo della sequenza · vuoto mantiene il nome della cartella · Invio salva
+ Dividi la scheda in sessioni quando la pausa tra due foto supera il limite
+ Mostra ogni file, dove andrà e cosa ha risolto il piano
+ Lascia sulla scheda le foto già in archivio (stesso hash)
+ Spazio libero nella destinazione dopo l'importazione; su un server, quanto resta della tua quota
+ Copia con verifica; la scheda si tocca solo dopo che ogni hash coincide · Ctrl+Invio
+ Cerca in ogni sottocartella della sorgente
+ Inserisci un segnaposto nell'ultimo modello usato
+ Calcola l'hash durante la copia e rileggi la destinazione prima di toccare la sorgente
Ferma questa attività; Riprova la continua più tardi dall'ultimo punto di ripresa
Nasconde le attività concluse dall'elenco; restano nella cronologia
Tutte le attività
diff --git a/src/Titano.App/Archive/ArchiveDialogViewModels.cs b/src/Titano.App/Archive/ArchiveDialogViewModels.cs
new file mode 100644
index 00000000..fe43b98c
--- /dev/null
+++ b/src/Titano.App/Archive/ArchiveDialogViewModels.cs
@@ -0,0 +1,289 @@
+using System.IO;
+using System.Windows.Input;
+using System.Windows.Threading;
+using Titano.App.Infrastructure;
+using Titano.App.Settings;
+using Titano.Core.Archiving;
+using Titano.Core.Diagnostics;
+using Titano.Core.Localization;
+using Titano.Core.Model;
+using Titano.Data;
+using Titano.Data.Archiving;
+using Titano.Ui.Mvvm;
+
+namespace Titano.App.Archiving;
+
+/// An in-window dialog of the Archive screen: one primary action, one way out.
+public abstract class ArchiveDialogViewModel(Action close) : LocalizedViewModel
+{
+ private bool _isBusy;
+ private string? _busyText;
+
+ public ICommand CloseCommand { get; } = new RelayCommand(close);
+
+ public bool IsBusy
+ {
+ get => _isBusy;
+ protected set
+ {
+ if (Set(ref _isBusy, value)) CommandManager.InvalidateRequerySuggested();
+ }
+ }
+
+ public string? BusyText { get => _busyText; protected set => Set(ref _busyText, value); }
+
+ protected void Close() => CloseCommand.Execute(null);
+}
+
+/// A fact of the rebuild dialog ("Sidecars · 412").
+public sealed record DialogFact(string Label, string Value);
+
+///
+/// "Rebuild index" (BRIEF §12.5): what the rebuild reads — the sidecars on disk, then a full metadata scan of folders
+/// without one — next to what the index holds now. Originals are never touched; the rebuild runs as a job.
+///
+public sealed class RebuildDialogViewModel : ArchiveDialogViewModel
+{
+ private readonly Func _rebuild;
+ private IReadOnlyList _facts;
+
+ public RebuildDialogViewModel(Core.Model.Archive archive, ArchiveAvailability availability, int indexed, Func rebuild, Action close)
+ : base(close)
+ {
+ _rebuild = rebuild;
+ Archive = archive;
+ Availability = availability;
+ Indexed = indexed;
+ _facts = Facts(null);
+ RebuildCommand = new AsyncRelayCommand(RebuildAsync, () => !IsBusy && availability == ArchiveAvailability.Online);
+ }
+
+ public Core.Model.Archive Archive { get; }
+ public ArchiveAvailability Availability { get; }
+ public int Indexed { get; }
+
+ public IReadOnlyList FactRows { get => _facts; private set => Set(ref _facts, value); }
+
+ public ICommand RebuildCommand { get; }
+
+ public string RebuildToolTip => Availability == ArchiveAvailability.Online ? Loc.L("Tooltips.Archive.RebuildStart") : Loc.L("Archive.Blocked.NotOnline");
+
+ /// Counts sequence folders with and without a sidecar (a walk of the archive tree, off the UI thread).
+ public async Task CountAsync()
+ {
+ if (Availability == ArchiveAvailability.Offline) return;
+ BusyText = Loc.L("Archive.Rebuild.Counting");
+ try
+ {
+ var root = Archive.RootPath;
+ var folders = await Task.Run(() => ArchiveScanner.FindSequenceFolders(new ArchivePaths(root)));
+ FactRows = Facts(folders);
+ }
+ catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
+ {
+ Log.Warning("archive", "Counting sidecars failed", ex);
+ }
+ finally
+ {
+ BusyText = null;
+ }
+ }
+
+ /// Shows counts computed elsewhere (capture).
+ public void ShowFolders(IReadOnlyList folders) => FactRows = Facts(folders);
+
+ private IReadOnlyList Facts(IReadOnlyList? folders)
+ {
+ var waiting = Loc.L("Archive.Rebuild.Counting");
+ return
+ [
+ new(Loc.L("Archive.Rebuild.Archive"), Archive.Name),
+ new(Loc.L("Archive.Rebuild.Root"), Archive.RootPath),
+ new(Loc.L("Archive.Rebuild.State"), Loc.L("Archive.Availability." + Availability)),
+ new(Loc.L("Archive.Rebuild.Indexed"), Loc.Plural("Shell.Status.Sequences", Indexed)),
+ new(Loc.L("Archive.Rebuild.Sidecars"), folders is null ? waiting : Formatting.Count(folders.Count(f => f.Sidecar is not null))),
+ new(Loc.L("Archive.Rebuild.Metadata"), folders is null ? waiting : Formatting.Count(folders.Count(f => f.Sidecar is null))),
+ ];
+ }
+
+ private async Task RebuildAsync()
+ {
+ IsBusy = true;
+ try
+ {
+ await _rebuild();
+ Close();
+ }
+ finally
+ {
+ IsBusy = false;
+ }
+ }
+}
+
+///
+/// Mass rename (titles) or move (folder layout) of a set (BRIEF §7, §12.5): the template is checked as it is typed,
+/// the dry run lists every change, and Apply makes exactly those changes (journaled, so a crash resumes it).
+///
+public sealed class RenameDialogViewModel : ArchiveDialogViewModel
+{
+ private readonly ArchiveService _archives;
+ private readonly Core.Model.Archive _archive;
+ private readonly IReadOnlyList _set;
+ private readonly Func _applied;
+ private readonly DispatcherTimer _delay = new() { Interval = TimeSpan.FromMilliseconds(400) };
+ private RenamePlan? _plan;
+ private IReadOnlyList _rows = [];
+ private CancellationTokenSource? _planning;
+
+ public RenameDialogViewModel(RenameMode mode, ArchiveService archives, Core.Model.Archive archive, IReadOnlyList set, Func applied,
+ Action close)
+ : base(close)
+ {
+ Mode = mode;
+ _archives = archives;
+ _archive = archive;
+ _set = set;
+ _applied = applied;
+ var initial = mode == RenameMode.Folders ? archive.FolderTemplate : "{title}";
+ Template = new EditableField(initial, t => MassRename.Validate(mode, t), committed => _ = PlanAsync(),
+ () => Loc.L(mode == RenameMode.Folders ? "Tooltips.Archive.FolderTemplate" : "Tooltips.Archive.TitleTemplate"));
+ Template.PropertyChanged += (_, e) =>
+ {
+ if (e.PropertyName != nameof(EditableField.Text)) return;
+ _delay.Stop();
+ _delay.Start();
+ };
+ _delay.Tick += (_, _) =>
+ {
+ _delay.Stop();
+ _ = PlanAsync();
+ };
+ ApplyCommand = new AsyncRelayCommand(ApplyAsync, () => !IsBusy && _plan is { Steps.Count: > 0 } && !Template.HasErrors);
+ }
+
+ public RenameMode Mode { get; }
+
+ public string Heading => Loc.Plural(Mode == RenameMode.Folders ? "Archive.Rename.MoveHeading" : "Archive.Rename.Heading", _set.Count);
+
+ public EditableField Template { get; }
+
+ public IReadOnlyList Rows { get => _rows; private set => Set(ref _rows, value); }
+
+ public string SummaryText => _plan is null ? string.Empty : MassRename.Summary(_plan, _set.Count);
+
+ public ICommand ApplyCommand { get; }
+
+ /// The dry run of the current template (the engine's plan; nothing changes on disk).
+ public async Task PlanAsync()
+ {
+ _planning?.Cancel();
+ _plan = null;
+ Rows = [];
+ OnPropertyChanged(nameof(SummaryText));
+ if (Template.HasErrors) return;
+ var cts = _planning = new CancellationTokenSource();
+ var template = Template.Text;
+ var ids = _set.Select(s => s.Id).ToList();
+ try
+ {
+ var plan = await Task.Run(() => _archives.PlanRenameAsync(_archive.Id, ids, Mode == RenameMode.Folders ? template : null,
+ Mode == RenameMode.Titles ? template : null, cts.Token), cts.Token);
+ if (cts.IsCancellationRequested) return;
+ _plan = plan;
+ Rows = MassRename.Rows(plan, Mode);
+ OnPropertyChanged(nameof(SummaryText));
+ CommandManager.InvalidateRequerySuggested();
+ }
+ catch (OperationCanceledException) when (cts.IsCancellationRequested)
+ {
+ }
+ catch (Exception ex) when (ex is ArgumentException or DatabaseException or FormatException)
+ {
+ Log.Warning("archive", "Rename plan failed", ex);
+ BusyText = ex.Message;
+ }
+ }
+
+ private async Task ApplyAsync()
+ {
+ if (_plan is not { } plan) return;
+ IsBusy = true;
+ var progress = new Progress(n => BusyText = Loc.L("Archive.Rename.Applying", Formatting.Count(n), Formatting.Count(plan.Steps.Count)));
+ try
+ {
+ await Task.Run(() => _archives.ApplyRenameAsync(plan, progress));
+ await _applied(plan.Steps.Count);
+ Close();
+ }
+ catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or StaleRenamePlanException or ArchiveOfflineException)
+ {
+ Log.Warning("archive", "Rename failed", ex);
+ BusyText = ex.Message;
+ }
+ finally
+ {
+ IsBusy = false;
+ }
+ }
+}
+
+/// Add and remove tags on a set (BRIEF §12.5 Retag): the dry run counts the sequences that change.
+public sealed class RetagDialogViewModel : ArchiveDialogViewModel
+{
+ private readonly ArchiveService _archives;
+ private readonly IReadOnlyList _set;
+ private readonly Func _applied;
+
+ public RetagDialogViewModel(ArchiveService archives, IReadOnlyList set, Func applied, Action close)
+ : base(close)
+ {
+ _archives = archives;
+ _set = set;
+ _applied = applied;
+ Add = new EditableField(string.Empty, Retag.Validate, _ => OnPropertyChanged(nameof(SummaryText)), () => Loc.L("Tooltips.Archive.TagsAdd"));
+ Remove = new EditableField(string.Empty, Retag.Validate, _ => OnPropertyChanged(nameof(SummaryText)), () => Loc.L("Tooltips.Archive.TagsRemove"));
+ Add.PropertyChanged += (_, _) => OnPropertyChanged(nameof(SummaryText));
+ Remove.PropertyChanged += (_, _) => OnPropertyChanged(nameof(SummaryText));
+ ApplyCommand = new AsyncRelayCommand(ApplyAsync, () => !IsBusy && Changes().Count > 0);
+ }
+
+ public string Heading => Loc.Plural("Archive.Retag.Heading", _set.Count);
+
+ public EditableField Add { get; }
+ public EditableField Remove { get; }
+
+ /// "12 of 36 change".
+ public string SummaryText => Loc.Plural("Archive.Rename.Summary", Changes().Count, _set.Count);
+
+ public ICommand ApplyCommand { get; }
+
+ private IReadOnlyList<(Sequence Sequence, IReadOnlyList Tags)> Changes() =>
+ Add.HasErrors || Remove.HasErrors ? [] : Retag.Changes(_set, Retag.Parse(Add.Text), Retag.Parse(Remove.Text));
+
+ private async Task ApplyAsync()
+ {
+ var changes = Changes();
+ IsBusy = true;
+ try
+ {
+ for (var i = 0; i < changes.Count; i++)
+ {
+ var (s, tags) = changes[i];
+ BusyText = Loc.L("Archive.Rename.Applying", Formatting.Count(i + 1), Formatting.Count(changes.Count));
+ await Task.Run(() => _archives.SetSequenceInfoAsync(s.Id, s.Title, tags, s.Rating, s.Notes));
+ }
+ await _applied(changes.Count);
+ Close();
+ }
+ catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or ArgumentException or DatabaseException or ArchiveOfflineException)
+ {
+ Log.Warning("archive", "Retag failed", ex);
+ BusyText = ex.Message;
+ }
+ finally
+ {
+ IsBusy = false;
+ }
+ }
+}
diff --git a/src/Titano.App/Archive/ArchiveRowViewModels.cs b/src/Titano.App/Archive/ArchiveRowViewModels.cs
new file mode 100644
index 00000000..b386232e
--- /dev/null
+++ b/src/Titano.App/Archive/ArchiveRowViewModels.cs
@@ -0,0 +1,73 @@
+using System.Windows.Input;
+using Titano.Core.Archiving;
+using Titano.Core.Localization;
+using Titano.Ui.Controls;
+using Titano.Ui.Mvvm;
+
+namespace Titano.App.Archiving;
+
+/// A visible row of the archive tree: indentation, expander, title, figures and availability.
+public sealed class ArchiveTreeRowViewModel(ArchiveTreeNode node, ArchiveAvailability availability, Action toggle) : ObservableObject
+{
+ public ArchiveTreeNode Node { get; } = node;
+
+ public string Title => Node.Title;
+ public string Detail => Node.Detail;
+
+ /// 16 px per level.
+ public System.Windows.Thickness IndentMargin => new(Node.Depth * 16, 0, 0, 0);
+
+ public bool HasChildren => Node.HasChildren;
+ public bool IsExpanded => Node.IsExpanded;
+ public bool IsArchive => Node.Kind == TreeNodeKind.Archive;
+ public bool IsYear => Node.Kind == TreeNodeKind.Year;
+
+ public string ToggleToolTip => Loc.L(Node.IsExpanded ? "Tooltips.Archive.Collapse" : "Tooltips.Archive.Expand");
+
+ public ICommand ToggleCommand { get; } = new RelayCommand(() => toggle(node));
+
+ /// The archive's availability (BRIEF §7: online, read-only, offline) on the archive row.
+ public StatusKind AvailabilityKind => availability switch
+ {
+ ArchiveAvailability.Online => StatusKind.Online,
+ ArchiveAvailability.ReadOnly => StatusKind.Warning,
+ _ => StatusKind.Offline,
+ };
+
+ public string AvailabilityText => Loc.L("Archive.Availability." + availability);
+
+ public string AvailabilityToolTip => Loc.L("Tooltips.Archive.Availability." + availability);
+}
+
+/// A line of "Index health" with its fix.
+public sealed class HealthLineViewModel(HealthLine line, ICommand? fix) : ObservableObject
+{
+ public HealthLine Line { get; } = line;
+ public string Text => Line.Text;
+ public StatusKind Kind => Line.IsOk ? StatusKind.Done : StatusKind.Warning;
+ public string KindToolTip => Loc.L(Line.IsOk ? "Tooltips.Archive.HealthOk" : "Tooltips.Archive.HealthWarning");
+ public bool HasFix => FixCommand is not null && Line.Action != HealthAction.None;
+ public ICommand? FixCommand { get; } = fix;
+ public string FixText => HasFix ? Loc.L("Archive.Health.Fix." + Line.Action) : string.Empty;
+ public string FixToolTip => HasFix ? Loc.L("Tooltips.Archive.Fix." + Line.Action) : string.Empty;
+}
+
+/// A duplicate group with its safe actions: open the first copy's sequence, show its folder.
+public sealed class DuplicateRowViewModel(DuplicateRow row, ICommand open, ICommand reveal) : ObservableObject
+{
+ public DuplicateRow Row { get; } = row;
+ public string Places => string.Join(" · ", Row.Places);
+ public ICommand OpenCommand { get; } = open;
+ public ICommand RevealCommand { get; } = reveal;
+}
+
+/// An orphan line with its fix (index, reconcile, remove the row, scan).
+public sealed class OrphanRowViewModel(OrphanRow row, ICommand fix) : ObservableObject
+{
+ public OrphanRow Row { get; } = row;
+ public StatusKind Kind => Row.Kind is OrphanKind.MissingFiles or OrphanKind.MissingSequence ? StatusKind.Warning : StatusKind.Queued;
+ public string KindText => Loc.L("Archive.Orphans.Kind." + Row.Kind);
+ public ICommand FixCommand { get; } = fix;
+ public string FixText => Loc.L("Archive.Orphans.Fix." + Row.Kind);
+ public string FixToolTip => Loc.L("Tooltips.Archive.Orphans." + Row.Kind);
+}
diff --git a/src/Titano.App/Archive/ArchiveScenes.cs b/src/Titano.App/Archive/ArchiveScenes.cs
new file mode 100644
index 00000000..f9572fc8
--- /dev/null
+++ b/src/Titano.App/Archive/ArchiveScenes.cs
@@ -0,0 +1,39 @@
+using Titano.App.Shell;
+
+namespace Titano.App.Archiving;
+
+///
+/// The Archive views that --capture renders (archive-<view>-<theme>.png) and the screen smoke
+/// tests check, on the sample archive: the tree with figures and charts, the maintenance view with its reports, and
+/// the rebuild dialog.
+///
+public static class ArchiveScenes
+{
+ public static readonly IReadOnlyList Views = ["overview", "maintenance", "rebuild"];
+
+ public static async Task ShowAsync(ShellViewModel shell, string view)
+ {
+ var archive = shell.Archive;
+ shell.Navigate(SectionKey.Archive);
+ archive.Dialog?.CloseCommand.Execute(null);
+ await archive.LoadAsync();
+ var db = shell.Services.Database ?? throw new InvalidOperationException("The sample index is not open.");
+ var locations = archive.SelectedArchive is { } selected ? await db.Sequences.ListLocationsAsync(selected.Id) : [];
+ switch (view)
+ {
+ case "overview":
+ archive.ViewIndex = 0;
+ break;
+ case "maintenance":
+ archive.ViewIndex = 1;
+ archive.ShowReports(SampleReports.Duplicates(locations), SampleReports.Orphans(locations), locations);
+ break;
+ case "rebuild":
+ archive.ViewIndex = 0;
+ (await archive.OpenRebuildDialogAsync())?.ShowFolders(SampleReports.Folders(locations));
+ break;
+ default:
+ throw new ArgumentOutOfRangeException(nameof(view), view, "Unknown Archive view.");
+ }
+ }
+}
diff --git a/src/Titano.App/Archive/CurrentArchive.cs b/src/Titano.App/Archive/CurrentArchive.cs
new file mode 100644
index 00000000..b4357c93
--- /dev/null
+++ b/src/Titano.App/Archive/CurrentArchive.cs
@@ -0,0 +1,31 @@
+using System.IO;
+using Titano.Data;
+
+namespace Titano.App.Archiving;
+
+/// The archive the Import and Archive screens work on: the one at the remembered root, else the first indexed.
+public static class CurrentArchive
+{
+ public static Core.Model.Archive? Pick(IReadOnlyList archives, string? lastRoot)
+ {
+ if (archives.Count == 0) return null;
+ if (string.IsNullOrWhiteSpace(lastRoot)) return archives[0];
+ var wanted = Normalize(lastRoot);
+ return archives.FirstOrDefault(a => string.Equals(Normalize(a.RootPath), wanted, StringComparison.OrdinalIgnoreCase)) ?? archives[0];
+ }
+
+ public static async Task FindAsync(TitanoDatabase db, string? lastRoot, CancellationToken cancellationToken = default) =>
+ Pick(await db.Archives.ListAsync(cancellationToken).ConfigureAwait(false), lastRoot);
+
+ private static string Normalize(string path)
+ {
+ try
+ {
+ return Path.TrimEndingDirectorySeparator(Path.GetFullPath(path));
+ }
+ catch (Exception ex) when (ex is ArgumentException or NotSupportedException or PathTooLongException)
+ {
+ return path;
+ }
+ }
+}
diff --git a/src/Titano.App/Archive/SampleReports.cs b/src/Titano.App/Archive/SampleReports.cs
new file mode 100644
index 00000000..3aed3f79
--- /dev/null
+++ b/src/Titano.App/Archive/SampleReports.cs
@@ -0,0 +1,40 @@
+using Titano.Core.Archiving;
+using Titano.Data.Archiving;
+using Titano.Data.Repositories;
+
+namespace Titano.App.Archiving;
+
+///
+/// Capture and smoke-test data ONLY: maintenance reports and rebuild counts over the sample archive's sequences
+/// (the sample index has no sidecars on disk, so the real searches would find nothing to show).
+///
+public static class SampleReports
+{
+ private const string Sha = "9f2c41d07be8a6c3e15f0d2b84a97c6e3d1f50a28b9e7c4d6a0f3e2b1c8d9a47";
+
+ /// One photo stored twice: a frame of the first sequence copied into the second.
+ public static IReadOnlyList Duplicates(IReadOnlyList sequences) =>
+ sequences.Count < 2
+ ? []
+ :
+ [
+ new DuplicateGroup(Sha,
+ [
+ new DuplicateFrame(Sha, Guid.CreateVersion7(), sequences[0].Id, 0, sequences[0].Folder + "/IMG_0001.CR2"),
+ new DuplicateFrame(Sha, Guid.CreateVersion7(), sequences[1].Id, 12, sequences[1].Folder + "/IMG_0001.CR2"),
+ ]),
+ ];
+
+ /// Two photos missing from a sidecar, a row whose sidecar is gone and a folder not indexed yet.
+ public static OrphanReport Orphans(IReadOnlyList sequences) =>
+ sequences.Count < 4
+ ? new OrphanReport([], [], [])
+ : new OrphanReport([new SequenceOrphans(sequences[2].Folder, ["IMG_0412.CR2", "IMG_0413.CR2"], [])], [sequences[3]], ["2024/2024-12-31 Unsorted"]);
+
+ /// What the rebuild dialog counts: a sidecar in every sequence folder but the last two, read by metadata instead.
+ public static IReadOnlyList Folders(IReadOnlyList sequences)
+ {
+ var stamp = new FileStamp(4_096, DateTime.UtcNow);
+ return [.. sequences.Select((s, i) => new SequenceFolder(s.Folder, i < sequences.Count - 2 ? stamp : null, stamp))];
+ }
+}
diff --git a/src/Titano.App/DesignTime/SampleData.cs b/src/Titano.App/DesignTime/SampleData.cs
index 105b4f1a..e7a06635 100644
--- a/src/Titano.App/DesignTime/SampleData.cs
+++ b/src/Titano.App/DesignTime/SampleData.cs
@@ -1,9 +1,11 @@
using System.IO;
using System.Net;
using Titano.App.About;
+using Titano.App.Import;
using Titano.App.Infrastructure;
using Titano.App.Server;
using Titano.App.Settings;
+using Titano.Core.Archiving;
using Titano.Core.Codecs.Jpeg;
using Titano.Core.Imaging;
using Titano.Core.Model;
@@ -38,6 +40,8 @@ public sealed class SampleData
services.Server = new ServerSession(settings, services.SaveSettings, new SampleServerApiFactory(), new PlainTokenProtector());
services.Encoders = new SampleEncoders();
services.CheckForUpdateAsync = _ => Task.FromResult(null);
+ services.Devices.Dispose();
+ services.Devices = new SampleDeviceMonitor();
return new SampleData(services);
}
@@ -57,6 +61,9 @@ public sealed class SampleData
Directory.CreateDirectory(root);
var archive = new Archive { Id = Guid.CreateVersion7(), Name = "TitanoArchive", RootPath = root, Created = DateTimeOffset.UtcNow.AddYears(-2) };
await db.Archives.UpsertAsync(archive);
+ var paths = new ArchivePaths(root);
+ Directory.CreateDirectory(paths.MetaDirectory);
+ ManifestStore.WriteArchive(paths.ManifestPath, new ArchiveManifest { Id = archive.Id, Name = archive.Name, Created = archive.Created });
var sequences = Sequences(archive.Id).ToList();
foreach (var (sequence, colours, raw) in sequences)
@@ -68,6 +75,7 @@ public sealed class SampleData
await db.Sequences.SetTagsAsync(sequences[9].Sequence.Id, ["holy grail"]);
foreach (var job in Jobs(sequences.Select(s => s.Sequence).ToList(), archive.Id)) await db.Jobs.EnqueueAsync(job);
+ await SampleCards.InsertAsync(db, (SampleDeviceMonitor)_services.Devices, _services.Environment.DataDirectory);
settings.LastArchivePath = @"D:\TitanoArchive";
settings.ServerUrl = "https://nas.local:8443";
diff --git a/src/Titano.App/Import/CardPool.cs b/src/Titano.App/Import/CardPool.cs
index 1c0b13f3..8882011f 100644
--- a/src/Titano.App/Import/CardPool.cs
+++ b/src/Titano.App/Import/CardPool.cs
@@ -36,12 +36,12 @@ public sealed record ImportSource(string Key, SourceKind Kind, CardDevice? Devic
: Device is { Label.Length: > 0 } labelled ? labelled.Label
: Device?.Root ?? FolderPath ?? Card?.Label ?? string.Empty;
- /// "E:\ · 128 GB · 96.2 GB used", "no DCIM · 1.8 TB free", "Canon EOS R5 · not inserted".
+ /// "128 GB · 96.2 GB used", "no DCIM · 1.8 TB free", "Canon EOS R5 · not inserted".
public string Subtitle => Kind switch
{
SourceKind.Folder => FolderPath ?? string.Empty,
- SourceKind.Drive => Loc.L("Import.Device.NoDcim", Device!.Root, Formatting.Bytes(Device.FreeBytes)),
- _ when Device is not null => Loc.L("Import.Device.Card", Device.Root, Formatting.Bytes(Device.TotalBytes), Formatting.Bytes(Device.UsedBytes)),
+ SourceKind.Drive => Loc.L("Import.Device.NoDcim", Formatting.Bytes(Device!.FreeBytes)),
+ _ when Device is not null => Loc.L("Import.Device.Card", Formatting.Bytes(Device.TotalBytes), Formatting.Bytes(Device.UsedBytes)),
_ => Loc.L("Import.Device.Away", CameraText(Card) is { Length: > 0 } camera ? camera : Formatting.Bytes(Card!.Capacity)),
};
@@ -61,7 +61,6 @@ public sealed record ImportSource(string Key, SourceKind Kind, CardDevice? Devic
get
{
var parts = new List();
- if (Device is not null) parts.Add(Device.Root);
var capacity = Device?.TotalBytes ?? Card?.Capacity ?? 0;
if (capacity > 0) parts.Add(Formatting.Bytes(capacity));
var serial = Device?.SerialNumber ?? Card?.VolumeSerial;
diff --git a/src/Titano.App/Import/ImportDestinations.cs b/src/Titano.App/Import/ImportDestinations.cs
index f97e9fc6..a24f7a59 100644
--- a/src/Titano.App/Import/ImportDestinations.cs
+++ b/src/Titano.App/Import/ImportDestinations.cs
@@ -35,12 +35,17 @@ public sealed class UnindexedDestination(ImportDestinationKind kind, string root
/// The folder, or the local staging folder of server uploads.
public string Root { get; } = root;
- public Task PlanAsync(string sourceRoot, ImportOptions options, Guid? cardId, IProgress? progress, CancellationToken cancellationToken)
+ /// Room left on the server (the user's quota); null when unlimited or unknown. A folder reports its volume's space.
+ public long? ServerSpace { get; init; }
+
+ public async Task PlanAsync(string sourceRoot, ImportOptions options, Guid? cardId, IProgress? progress, CancellationToken cancellationToken)
{
var problems = new List();
var files = CardScanner.Find(sourceRoot, options.IncludeSubfolders, cancellationToken);
var photos = CardScanner.ReadMetadata(sourceRoot, files, problems, progress, cancellationToken);
- return ImportPlanner.PlanAsync(sourceRoot, Root, photos, problems, options, NoIndex.Instance, cancellationToken);
+ var plan = await ImportPlanner.PlanAsync(sourceRoot, Root, photos, problems, options, NoIndex.Instance, cancellationToken).ConfigureAwait(false);
+ // Staging only ever holds one batch; the space that matters for a server import is the quota.
+ return Kind == ImportDestinationKind.Server ? plan with { AvailableBytes = ServerSpace } : plan;
}
/// No history and no index; folders are reused so a repeated import lands next to the first one.
diff --git a/src/Titano.App/Import/ImportResultViewModel.cs b/src/Titano.App/Import/ImportResultViewModel.cs
new file mode 100644
index 00000000..42bde730
--- /dev/null
+++ b/src/Titano.App/Import/ImportResultViewModel.cs
@@ -0,0 +1,249 @@
+using System.IO;
+using System.Windows.Input;
+using Titano.App.Infrastructure;
+using Titano.App.Shell;
+using Titano.Core.Diagnostics;
+using Titano.Core.Import;
+using Titano.Core.Localization;
+using Titano.Core.Model;
+using Titano.Data;
+using Titano.Data.Archiving;
+using Titano.Ui.Controls;
+using Titano.Ui.Mvvm;
+
+namespace Titano.App.Import;
+
+///
+/// The end of an import (BRIEF §12.4, §13): the verification result and the after-import actions — check the card
+/// (dry run: every card file and its archive copy hashed again), delete the verified photos or format the card
+/// (each after a confirmation, never by default), eject, open in the Library. decides
+/// what is allowed and why not.
+///
+public sealed class ImportResultViewModel : LocalizedViewModel
+{
+ private const int ListedFailures = 100;
+
+ private readonly ShellViewModel _shell;
+ private readonly ImportPlan _plan;
+ private readonly ImportChoices _choices;
+ private readonly Core.Model.Archive? _archive;
+ private readonly MediaCard? _card;
+ private CardDevice? _device;
+ private CardActions _actions;
+ private bool _isBusy;
+ private string? _busyText;
+
+ public ImportResultViewModel(ShellViewModel shell, ImportPlan plan, ImportOutcome outcome, ImportChoices choices, Core.Model.Archive? archive,
+ MediaCard? card, CardDevice? device)
+ {
+ _shell = shell;
+ _plan = plan;
+ _choices = choices;
+ _archive = archive;
+ _card = card;
+ _device = device;
+ Outcome = outcome;
+ _actions = new CardActions(choices.Destination, card is not null, device is not null, device?.IsRemovable == true, outcome, null,
+ plan.FileCount + plan.Problems.Count);
+ Failures = [.. outcome.Failures.Take(ListedFailures).Select(f => Loc.L("Import.Result.Failure", f.SourcePath, f.Message))];
+ CheckCommand = new AsyncRelayCommand(CheckAsync, () => _actions.CanCheck && !_isBusy);
+ DeleteCommand = new AsyncRelayCommand(DeleteAsync, () => _actions.CanDelete && !_isBusy);
+ FormatCommand = new RelayCommand(Format, () => _actions.CanFormat && !_isBusy);
+ EjectCommand = new AsyncRelayCommand(EjectAsync, () => _actions.CanEject && !_isBusy);
+ OpenLibraryCommand = new AsyncRelayCommand(async () =>
+ {
+ await _shell.Library.RefreshAsync();
+ _shell.Navigate(SectionKey.Library);
+ });
+ }
+
+ public ImportOutcome Outcome { get; }
+
+ public CardActions Actions
+ {
+ get => _actions;
+ private set
+ {
+ _actions = value;
+ OnAllPropertiesChanged();
+ CommandManager.InvalidateRequerySuggested();
+ }
+ }
+
+ public ICommand CheckCommand { get; }
+ public ICommand DeleteCommand { get; }
+ public ICommand FormatCommand { get; }
+ public ICommand EjectCommand { get; }
+ public ICommand OpenLibraryCommand { get; }
+
+ /// "4,812 copied and verified", "4,800 copied · 12 failed".
+ public string ResultText => Outcome.IsComplete
+ ? Loc.Plural(Outcome.Verified ? "Import.Result.Verified" : "Import.Result.Copied", Outcome.Imported)
+ : Loc.L("Import.Result.Partial", Formatting.Count(Outcome.Imported), Formatting.Count(Outcome.Failures.Count));
+
+ /// "12 skipped · 3 already there", or empty.
+ public string DetailText => string.Join(" · ", new[]
+ {
+ Outcome.Skipped > 0 ? Loc.Plural("Import.Result.Skipped", Outcome.Skipped) : string.Empty,
+ Outcome.Duplicates > 0 ? Loc.Plural("Import.Result.AlreadyThere", Outcome.Duplicates) : string.Empty,
+ }.Where(t => t.Length > 0));
+
+ public bool IsComplete => Outcome.IsComplete;
+
+ public StatusKind ResultKind => Outcome.IsComplete ? StatusKind.Done : StatusKind.Warning;
+
+ public IReadOnlyList Failures { get; }
+
+ public bool HasFailures => Failures.Count > 0;
+
+ /// The profile chose "Delete imported": the dry run and the delete button are offered.
+ public bool OffersDelete => _choices.AfterImport == AfterImport.DeleteImported;
+
+ /// The profile chose "Format card".
+ public bool OffersFormat => _choices.AfterImport == AfterImport.FormatCard;
+
+ public bool OffersCheck => OffersDelete || OffersFormat;
+
+ public bool IsBusy
+ {
+ get => _isBusy;
+ private set
+ {
+ if (Set(ref _isBusy, value)) CommandManager.InvalidateRequerySuggested();
+ }
+ }
+
+ /// "Checking 1,240 photos" while the dry run hashes.
+ public string? BusyText { get => _busyText; private set => Set(ref _busyText, value); }
+
+ public string EraseText => _actions.EraseText;
+
+ public IReadOnlyList KeptReasons => _actions.KeptReasons;
+
+ public string CheckToolTip => _actions.CheckBlocker ?? Loc.L("Tooltips.Import.Check");
+
+ /// "Delete 4,812 photos…".
+ public string DeleteText => Loc.Plural("Import.Erase.Delete", _actions.DeleteCount);
+
+ public string DeleteToolTip => _actions.DeleteBlocker ?? Loc.L("Tooltips.Import.Delete");
+
+ public string FormatToolTip => _actions.FormatBlocker ?? Loc.L("Tooltips.Import.Format");
+
+ public string EjectToolTip => _actions.CanEject ? Loc.L("Tooltips.Import.Eject") : Loc.L("Import.Blocked.NotRemovable");
+
+ /// The card left or came back (Devices list); actions follow.
+ public void SetDevice(CardDevice? device)
+ {
+ _device = device;
+ Actions = _actions with { IsInserted = device is not null, IsRemovable = device?.IsRemovable == true };
+ }
+
+ /// Shows a dry run computed elsewhere (capture, tests).
+ public void ShowErase(ErasePlan erase, int cardPhotos) => Actions = _actions with { Erase = erase, CardPhotos = cardPhotos };
+
+ /// Ejects when the profile asks for it and nothing more is to be done on the card.
+ public async Task AutoEjectAsync()
+ {
+ if (_choices.Eject && _choices.AfterImport == AfterImport.Keep && Outcome.IsComplete && _actions.CanEject) await EjectAsync();
+ }
+
+ private async Task CheckAsync()
+ {
+ if (_shell.Services.Archives is not { } archives || _archive is null || _card is null || _device is null) return;
+ var root = _device.Root;
+ IsBusy = true;
+ try
+ {
+ var progress = new Progress(n => BusyText = Loc.Plural("Import.Erase.Checking", n));
+ var (erase, photos) = await Task.Run(async () =>
+ {
+ var plan = await archives.PlanCardEraseAsync(_archive.Id, _card.Id, root, progress).ConfigureAwait(false);
+ return (plan, CardScanner.Find(root, includeSubfolders: true).Count);
+ });
+ ShowErase(erase, photos);
+ }
+ catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or DatabaseException)
+ {
+ Log.Warning("import", "Card check failed", ex);
+ _shell.Notify(Loc.L("Import.Toast.CheckFailed"), ex.Message);
+ }
+ finally
+ {
+ BusyText = null;
+ IsBusy = false;
+ }
+ }
+
+ private async Task DeleteAsync()
+ {
+ if (_actions.Erase is not { } erase) return;
+ var confirmed = _shell.Services.Dialogs.Confirm(new ConfirmRequest
+ {
+ Heading = Loc.Plural("Import.Confirm.DeleteHeading", _actions.DeleteCount),
+ Message = Loc.L("Import.Confirm.DeleteMessage"),
+ SafeText = Loc.L("Import.Confirm.Keep"),
+ SafeToolTip = Loc.L("Tooltips.Import.KeepCard"),
+ ActionText = Loc.L("Import.Confirm.Delete"),
+ ActionToolTip = Loc.L("Tooltips.Import.Delete"),
+ IsDestructive = true,
+ });
+ if (!confirmed) return;
+ IsBusy = true;
+ try
+ {
+ var result = await Task.Run(() => CardEraser.Execute(erase));
+ _shell.Notify(Loc.Plural("Import.Toast.Deleted", result.Deleted),
+ result.Kept.Count > 0 ? Loc.Plural("Import.Erase.Kept", result.Kept.Count) : null);
+ // The card changed: a new dry run is needed before anything else is deleted.
+ Actions = _actions with { Erase = null };
+ }
+ catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
+ {
+ Log.Warning("import", "Deleting imported photos failed", ex);
+ _shell.Notify(Loc.L("Import.Toast.DeleteFailed"), ex.Message);
+ }
+ finally
+ {
+ IsBusy = false;
+ }
+ if (_choices.Eject && _actions.CanEject) await EjectAsync();
+ }
+
+ private void Format()
+ {
+ if (_device is not { } device) return;
+ var name = _card?.Nickname ?? device.Label;
+ var confirmed = _shell.Services.Dialogs.Confirm(new ConfirmRequest
+ {
+ Heading = Loc.L("Import.Confirm.FormatHeading", name),
+ Message = Loc.Plural("Import.Confirm.FormatMessage", _actions.DeleteCount),
+ SafeText = Loc.L("Import.Confirm.Keep"),
+ SafeToolTip = Loc.L("Tooltips.Import.KeepCard"),
+ ActionText = Loc.L("Import.Confirm.Format"),
+ ActionToolTip = Loc.L("Tooltips.Import.FormatConfirm"),
+ IsDestructive = true,
+ TypedConfirmation = name,
+ TypedPrompt = Loc.L("Import.Confirm.TypeName"),
+ });
+ if (!confirmed) return;
+ var outcome = _shell.Services.Devices.Format(device);
+ if (outcome == FormatOutcome.Formatted) Actions = _actions with { Erase = null };
+ if (outcome != FormatOutcome.Cancelled) _shell.Notify(Loc.L("Import.Toast.Format." + outcome, name));
+ }
+
+ private async Task EjectAsync()
+ {
+ if (_device is not { } device) return;
+ IsBusy = true;
+ try
+ {
+ var outcome = await Task.Run(() => _shell.Services.Devices.Eject(device));
+ _shell.Notify(Loc.L("Import.Toast.Eject." + outcome, _card?.Nickname ?? device.Label));
+ if (outcome == EjectOutcome.Ejected) SetDevice(null);
+ }
+ finally
+ {
+ IsBusy = false;
+ }
+ }
+}
diff --git a/src/Titano.App/Import/ImportScenes.cs b/src/Titano.App/Import/ImportScenes.cs
new file mode 100644
index 00000000..c4bd9741
--- /dev/null
+++ b/src/Titano.App/Import/ImportScenes.cs
@@ -0,0 +1,49 @@
+using Titano.App.Shell;
+
+namespace Titano.App.Import;
+
+///
+/// The Import states that --capture renders (import-<state>-<theme>.png) and the screen smoke
+/// tests check, on the card of : the card just inserted with its plan and sessions (and the
+/// insertion toast), "Show plan", and the verification result with the after-import actions.
+///
+public static class ImportScenes
+{
+ public static readonly IReadOnlyList States = ["plan", "showplan", "done"];
+
+ public static async Task ShowAsync(ShellViewModel shell, string state)
+ {
+ var import = shell.Import;
+ shell.Navigate(SectionKey.Import);
+ switch (state)
+ {
+ case "plan":
+ var card = SampleCards.Card(shell.Services.Environment.DataDirectory);
+ if (import.Result is not null) import.NewImportCommand.Execute(null);
+ import.CloseDetailsCommand.Execute(null);
+ await import.RefreshSourcesAsync();
+ import.SelectSource(card.Identity);
+ import.KeepCard = true;
+ await import.WaitForPlanAsync();
+ if (import.Sessions.Count > 0)
+ {
+ var sunset = import.Sessions[^1].Title;
+ sunset.Text = "Harbour sunset";
+ sunset.Commit();
+ }
+ await import.CardInsertedAsync(card);
+ break;
+ case "showplan":
+ import.ShowPlanCommand.Execute(null);
+ break;
+ case "done":
+ import.CloseDetailsCommand.Execute(null);
+ import.DeleteImported = true;
+ var plan = import.Plan ?? throw new InvalidOperationException("The sample card has no plan.");
+ import.ShowResult(SampleCards.Outcome(plan)).ShowErase(SampleCards.Erase(plan), plan.FileCount);
+ break;
+ default:
+ throw new ArgumentOutOfRangeException(nameof(state), state, "Unknown Import state.");
+ }
+ }
+}
diff --git a/src/Titano.App/Import/ImportSessionRowViewModel.cs b/src/Titano.App/Import/ImportSessionRowViewModel.cs
new file mode 100644
index 00000000..cb533025
--- /dev/null
+++ b/src/Titano.App/Import/ImportSessionRowViewModel.cs
@@ -0,0 +1,21 @@
+using Titano.App.Settings;
+using Titano.Core.Localization;
+using Titano.Ui.Mvvm;
+
+namespace Titano.App.Import;
+
+/// A session of the plan with its editable title (the sequence title; empty keeps the folder name).
+public sealed class ImportSessionRowViewModel : ObservableObject
+{
+ public ImportSessionRowViewModel(PlanSessionRow row, Action titleChanged)
+ {
+ Row = row;
+ Title = new EditableField(row.Title ?? string.Empty, _ => null, text => titleChanged(row.SessionKey, text), () => Loc.L("Tooltips.Import.SessionTitle"));
+ }
+
+ public PlanSessionRow Row { get; }
+
+ public EditableField Title { get; }
+
+ public string Placeholder => Row.DefaultTitle;
+}
diff --git a/src/Titano.App/Import/SampleCards.cs b/src/Titano.App/Import/SampleCards.cs
new file mode 100644
index 00000000..d514eb96
--- /dev/null
+++ b/src/Titano.App/Import/SampleCards.cs
@@ -0,0 +1,173 @@
+using System.IO;
+using Titano.Core.Archiving;
+using Titano.Core.Codecs.Jpeg;
+using Titano.Core.Imaging;
+using Titano.Core.Import;
+using Titano.Core.Metadata;
+using Titano.Core.Model;
+using Titano.Data;
+using Titano.Data.Repositories;
+
+namespace Titano.App.Import;
+
+///
+/// Capture and smoke-test data ONLY (--capture, never the user's data): a simulated Canon EOS R5 card in the
+/// capture folder — a night, a dawn and a sunset session of small JPEGs with Exif — remembered as "EOS R5 · card A",
+/// a second remembered card that is not inserted, a USB drive without DCIM, and the import result shown afterwards.
+///
+public static class SampleCards
+{
+ private const uint Serial = 0x3F2A9C11;
+ private static readonly DateTimeOffset LastImport = new(2026, 9, 21, 19, 40, 0, TimeSpan.Zero);
+
+ /// Night, dawn and sunset: start, photos, seconds between photos.
+ private static readonly (DateTime Start, int Photos, int Interval)[] Sessions =
+ [
+ (new DateTime(2026, 9, 26, 21, 10, 0), 10, 120),
+ (new DateTime(2026, 9, 27, 5, 41, 0), 16, 4),
+ (new DateTime(2026, 9, 28, 18, 2, 11), 24, 2),
+ ];
+
+ /// The inserted card: its root is a folder of the capture environment.
+ public static CardDevice Card(string dataDirectory) =>
+ new(Path.Combine(dataDirectory, "card") + Path.DirectorySeparatorChar, "EOS_DIGITAL", Serial, 127_865_454_592, 31_665_454_592, IsRemovable: true,
+ HasDcim: true);
+
+ /// Writes the card's photos, remembers both cards (the inserted one with its last import) and inserts the card and a USB drive.
+ public static async Task InsertAsync(TitanoDatabase db, SampleDeviceMonitor devices, string dataDirectory)
+ {
+ var card = Card(dataDirectory);
+ WritePhotos(card.Root);
+ var known = new MediaCard
+ {
+ Id = Guid.CreateVersion7(),
+ Identity = card.Identity,
+ VolumeSerial = card.SerialNumber,
+ Label = card.Label,
+ Capacity = card.TotalBytes,
+ Nickname = "EOS R5 · card A",
+ CameraMake = "Canon",
+ CameraModel = "Canon EOS R5",
+ CameraSerial = "0431",
+ FirstSeen = LastImport.AddMonths(-7),
+ LastSeen = DateTimeOffset.UtcNow,
+ };
+ await db.MediaCards.UpsertAsync(known);
+ await db.MediaCards.RecordImportsAsync([new ImportRecord(known.Id, new ImportKey("DCIM/100CANON/IMG_9001.CR2", 24_000_000, LastImport), null, null, null,
+ LastImport)]);
+ await db.MediaCards.UpsertAsync(new MediaCard
+ {
+ Id = Guid.CreateVersion7(),
+ Identity = "7C1D0E42-GOPRO-63864569856",
+ VolumeSerial = 0x7C1D0E42,
+ Label = "GOPRO",
+ Capacity = 63_864_569_856,
+ Nickname = "GoPro 12",
+ CameraMake = "GoPro",
+ CameraModel = "HERO12 Black",
+ FirstSeen = LastImport.AddMonths(-3),
+ LastSeen = LastImport.AddDays(-6),
+ });
+ devices.Insert(card);
+ devices.Insert(new CardDevice(@"F:\", "USB DRIVE", 0x51E02B44, 2_000_398_934_016, 1_800_000_000_000, IsRemovable: true, HasDcim: false));
+ }
+
+ /// What the import of reports: every planned copy committed and read back.
+ public static ImportOutcome Outcome(ImportPlan plan) => new(plan.CopyCount, 0, plan.FileCount - plan.CopyCount, [], Verified: true);
+
+ /// The dry run of "Delete imported" after that import: every copy matches except the last photo, touched since.
+ public static ErasePlan Erase(ImportPlan plan)
+ {
+ var copied = plan.Sessions.SelectMany(s => s.Items.Where(i => i.Action == ImportAction.Copy).Select(i => (Session: s, Item: i))).ToList();
+ return new ErasePlan(plan.SourceRoot,
+ [
+ .. copied.Select((c, n) => new EraseItem(
+ new EraseCandidate(c.Item.SourcePath, c.Item.Size, string.Empty,
+ Path.Combine(plan.DestinationRoot, c.Session.Folder, ArchiveLayout.OriginalsFolder, c.Item.FileName)),
+ n == copied.Count - 1 ? EraseVerdict.SourceChanged : EraseVerdict.Delete, c.Item.ModifiedUtc)),
+ ]);
+ }
+
+ private static void WritePhotos(string root)
+ {
+ var folder = Path.Combine(root, "DCIM", "100CANON");
+ if (Directory.Exists(folder)) return;
+ Directory.CreateDirectory(folder);
+ var n = 1;
+ foreach (var (start, photos, interval) in Sessions)
+ {
+ for (var i = 0; i < photos; i++, n++)
+ {
+ var captured = start.AddSeconds(i * interval);
+ var path = Path.Combine(folder, $"IMG_{n:0000}.JPG");
+ File.WriteAllBytes(path, Photo(captured, n));
+ File.SetLastWriteTime(path, captured);
+ }
+ }
+ }
+
+ /// A small sky gradient with grain (distinct bytes per photo) and the camera's Exif.
+ private static byte[] Photo(DateTime captured, int seed)
+ {
+ const int Width = 96, Height = 64;
+ using var image = new ImageBuffer(Width, Height, 3, clear: false);
+ var random = new Random(seed);
+ var dusk = captured.Hour is >= 18 or < 6 ? 0.15f : 0.6f;
+ for (var y = 0; y < Height; y++)
+ {
+ for (var x = 0; x < Width; x++)
+ {
+ var sky = dusk * (1 - y / (float)Height) + 0.05f;
+ var grain = (float)random.NextDouble() * 0.04f;
+ image.Plane(0)[y * Width + x] = sky * 1.2f + grain;
+ image.Plane(1)[y * Width + x] = sky * 0.8f + grain;
+ image.Plane(2)[y * Width + x] = sky * 0.6f + grain;
+ }
+ }
+ var exif = ExifWriter.BuildJpegApp1(new FrameMetadata
+ {
+ Make = "Canon",
+ Model = "Canon EOS R5",
+ BodySerial = "0431",
+ CapturedAt = captured,
+ Iso = 100,
+ ExposureTime = 1.0 / 250,
+ FNumber = 8,
+ });
+ return JpegEncoder.Encode(image, new JpegEncodeOptions { Quality = 85, App1Segments = [exif[4..]] });
+ }
+}
+
+/// The capture's device monitor: lists the sample volumes; it raises no events and never ejects or formats.
+public sealed class SampleDeviceMonitor : IDeviceMonitor
+{
+ private readonly List _devices = [];
+
+ public event Action? Arrived
+ {
+ add { }
+ remove { }
+ }
+
+ public event Action? Removed
+ {
+ add { }
+ remove { }
+ }
+
+ public IReadOnlyList Devices => [.. _devices];
+
+ public void Insert(CardDevice device) => _devices.Add(device);
+
+ public void Start()
+ {
+ }
+
+ public EjectOutcome Eject(CardDevice device) => EjectOutcome.Failed;
+
+ public FormatOutcome Format(CardDevice device) => FormatOutcome.Cancelled;
+
+ public void Dispose()
+ {
+ }
+}
diff --git a/src/Titano.App/Infrastructure/AppServices.cs b/src/Titano.App/Infrastructure/AppServices.cs
index 5ed5098f..5fb742a9 100644
--- a/src/Titano.App/Infrastructure/AppServices.cs
+++ b/src/Titano.App/Infrastructure/AppServices.cs
@@ -3,6 +3,7 @@ using System.IO;
using System.Net.Http;
using System.Reflection;
using Titano.App.About;
+using Titano.App.Import;
using Titano.App.Jobs;
using Titano.App.Library;
using Titano.App.Server;
@@ -86,6 +87,9 @@ public sealed class AppServices : IAsyncDisposable
public IEncoderInventory Encoders { get; set; }
+ /// Card detection, eject and format (BRIEF §13); started with the index, replaced by a fake in capture.
+ public IDeviceMonitor Devices { get; set; } = new WindowsDeviceMonitor();
+
/// Latest public release (GitHub Releases API of the releases repository, BRIEF §18).
public Func> CheckForUpdateAsync { get; set; }
@@ -155,6 +159,7 @@ public sealed class AppServices : IAsyncDisposable
}
await StartJobsAsync(Database, startEngine: true, ct);
Thumbnails = new ThumbnailService(Database, Settings.ThumbnailMemoryItems);
+ Devices.Start();
if (Settings.LastArchivePath is { Length: > 0 } root) _polling = PollAsync(root, _stopping.Token);
}
@@ -177,6 +182,7 @@ public sealed class AppServices : IAsyncDisposable
(Jobs as IDisposable)?.Dispose();
if (Engine is not null) await Engine.DisposeAsync();
Thumbnails?.Dispose();
+ Devices.Dispose();
Server.Dispose();
if (Database is not null) await Database.DisposeAsync();
}
diff --git a/src/Titano.App/Infrastructure/IAppDialogs.cs b/src/Titano.App/Infrastructure/IAppDialogs.cs
index 892964e2..e6fbc7d4 100644
--- a/src/Titano.App/Infrastructure/IAppDialogs.cs
+++ b/src/Titano.App/Infrastructure/IAppDialogs.cs
@@ -17,6 +17,12 @@ public sealed record ConfirmRequest
/// Warning-outlined action (never a primary) for data-destroying choices.
public bool IsDestructive { get; init; }
+
+ /// Text the user must type before the action enables (formatting a card: its name); null asks no typing.
+ public string? TypedConfirmation { get; init; }
+
+ /// Label of the typing field ("Type the card name to confirm").
+ public string? TypedPrompt { get; init; }
}
/// Modal questions and OS pickers the view models ask for (BRIEF §12.1: modals only for confirmations and login).
diff --git a/src/Titano.App/Infrastructure/WindowsDeviceMonitor.cs b/src/Titano.App/Infrastructure/WindowsDeviceMonitor.cs
new file mode 100644
index 00000000..6b6a0a04
--- /dev/null
+++ b/src/Titano.App/Infrastructure/WindowsDeviceMonitor.cs
@@ -0,0 +1,74 @@
+using System.ComponentModel;
+using System.Windows;
+using System.Windows.Interop;
+using Titano.App.Import;
+using Titano.Core.Diagnostics;
+using Titano.Core.Windows.Devices;
+
+namespace Titano.App.Infrastructure;
+
+///
+/// Card detection on this PC (BRIEF §13): (WM_DEVICECHANGE plus a 3-second poll),
+/// safe removal through and formatting only through the Windows format dialog
+/// (, BRIEF §8.6).
+///
+public sealed class WindowsDeviceMonitor : IDeviceMonitor
+{
+ private RemovableVolumeWatcher? _watcher;
+
+ public event Action? Arrived;
+
+ public event Action? Removed;
+
+ public IReadOnlyList Devices => _watcher is { } watcher ? [.. watcher.Volumes.Select(Map)] : [];
+
+ public void Start()
+ {
+ if (_watcher is not null) return;
+ var watcher = new RemovableVolumeWatcher();
+ watcher.VolumeArrived += (_, e) => Arrived?.Invoke(Map(e.Volume));
+ watcher.VolumeRemoved += (_, e) => Removed?.Invoke(Map(e.Volume));
+ try
+ {
+ watcher.Start();
+ _watcher = watcher;
+ }
+ catch (Win32Exception ex)
+ {
+ // Without the watcher cards are still listed by "Folder…"; nothing else depends on it.
+ Log.Warning("devices", "Card detection is unavailable", ex);
+ watcher.Dispose();
+ }
+ }
+
+ public EjectOutcome Eject(CardDevice device) => VolumeEjector.Eject(device.Root[0]) switch
+ {
+ EjectResult.Ejected => EjectOutcome.Ejected,
+ EjectResult.InUse => EjectOutcome.InUse,
+ _ => EjectOutcome.Failed,
+ };
+
+ public FormatOutcome Format(CardDevice device)
+ {
+ var owner = Application.Current?.MainWindow is { } window ? new WindowInteropHelper(window).Handle : 0;
+ try
+ {
+ return FormatDialog.Show(owner, device.Root[0]) switch
+ {
+ FormatDialogResult.Formatted => FormatOutcome.Formatted,
+ FormatDialogResult.Cancelled => FormatOutcome.Cancelled,
+ _ => FormatOutcome.Failed,
+ };
+ }
+ catch (Exception ex) when (ex is ArgumentException or InvalidOperationException)
+ {
+ Log.Warning("devices", $"The format dialog cannot open for {device.Root}", ex);
+ return FormatOutcome.Failed;
+ }
+ }
+
+ public void Dispose() => _watcher?.Dispose();
+
+ private static CardDevice Map(VolumeInfo v) =>
+ new(v.RootPath, v.Label, v.SerialNumber, v.TotalBytes, v.FreeBytes, v.DriveType == VolumeDriveType.Removable, v.HasDcim);
+}
diff --git a/src/Titano.App/Sections/ArchiveView.xaml b/src/Titano.App/Sections/ArchiveView.xaml
index 1141aff3..8a8753e8 100644
--- a/src/Titano.App/Sections/ArchiveView.xaml
+++ b/src/Titano.App/Sections/ArchiveView.xaml
@@ -2,8 +2,466 @@
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:ui="clr-namespace:Titano.Ui.Controls;assembly=Titano.Ui"
- xmlns:l="clr-namespace:Titano.Ui.Localization;assembly=Titano.Ui">
-
-
+ xmlns:v="clr-namespace:Titano.Ui.Visuals;assembly=Titano.Ui"
+ xmlns:l="clr-namespace:Titano.Ui.Localization;assembly=Titano.Ui"
+ xmlns:ar="clr-namespace:Titano.App.Archiving"
+ xmlns:shell="clr-namespace:Titano.App.Shell">
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/Titano.App/Sections/ArchiveView.xaml.cs b/src/Titano.App/Sections/ArchiveView.xaml.cs
index 1701705a..c835b08c 100644
--- a/src/Titano.App/Sections/ArchiveView.xaml.cs
+++ b/src/Titano.App/Sections/ArchiveView.xaml.cs
@@ -1,8 +1,27 @@
+using System.Windows;
using System.Windows.Controls;
+using System.Windows.Controls.Primitives;
+using Titano.App.Archiving;
namespace Titano.App.Sections;
public partial class ArchiveView : UserControl
{
public ArchiveView() => InitializeComponent();
+
+ /// "Maintenance ▾" opens its menu under itself.
+ private void OnOpenMenu(object sender, RoutedEventArgs e)
+ {
+ if (sender is not Button { ContextMenu: { } menu } button) return;
+ menu.DataContext = DataContext;
+ menu.PlacementTarget = button;
+ menu.Placement = PlacementMode.Bottom;
+ menu.IsOpen = true;
+ }
+
+ /// The selected tree rows are the set the mass operations act on.
+ private void OnTreeSelectionChanged(object sender, SelectionChangedEventArgs e)
+ {
+ if (DataContext is ArchiveViewModel model) model.SetSelection(Tree.SelectedItems.OfType());
+ }
}
diff --git a/src/Titano.App/Sections/ArchiveViewModel.cs b/src/Titano.App/Sections/ArchiveViewModel.cs
index db07e50b..7027baf4 100644
--- a/src/Titano.App/Sections/ArchiveViewModel.cs
+++ b/src/Titano.App/Sections/ArchiveViewModel.cs
@@ -1,9 +1,621 @@
+using System.Collections.ObjectModel;
+using System.IO;
+using System.Windows.Input;
+using Titano.App.Archiving;
+using Titano.App.Infrastructure;
+using Titano.App.Jobs;
using Titano.App.Shell;
+using Titano.Core.Archiving;
+using Titano.Core.Diagnostics;
+using Titano.Core.IO;
+using Titano.Core.Localization;
+using Titano.Core.Model;
+using Titano.Data;
+using Titano.Data.Archiving;
+using Titano.Data.Archiving.Jobs;
+using Titano.Data.Processing;
+using Titano.Data.Repositories;
+using Titano.Ui.Mvvm;
+using Titano.Ui.Visuals;
namespace Titano.App.Sections;
-/// Archive manager (BRIEF §12.5).
-public sealed class ArchiveViewModel(ShellViewModel shell) : SectionViewModel(SectionKey.Archive, "Icon.Archive")
+///
+/// Archive manager (BRIEF §12.5, Archive.html): the archive's tree (years, sequences) with its availability, its
+/// figures and charts, mass operations on the selected set (analyse, proxies, thumbnails, verify, rename, move,
+/// retag, CSV), and the operations on the whole archive as jobs (scan, rebuild with its dialog, verify,
+/// maintenance), plus the maintenance view: index health, duplicates and orphans with safe fixes, recent runs.
+///
+public sealed class ArchiveViewModel : SectionViewModel
{
- public ShellViewModel Shell { get; } = shell;
+ private const int RecentCount = 6;
+ private const int PageSize = 1000;
+
+ private readonly HashSet _selection = [];
+ private IReadOnlyList _archives = [];
+ private Core.Model.Archive? _archive;
+ private ArchiveAvailability _availability = ArchiveAvailability.Offline;
+ private ArchiveStats? _stats;
+ private ArchiveTree? _tree;
+ private int _viewIndex;
+ private bool _loaded;
+ private Task _load = Task.CompletedTask;
+ private bool _jobEvents;
+ private string _lastScanText = string.Empty;
+ private ArchiveDialogViewModel? _dialog;
+ private IReadOnlyList _tiles = [];
+ private IReadOnlyList _months = [];
+ private IReadOnlyList _storage = [];
+ private IReadOnlyList _cameras = [];
+ private IReadOnlyList _formats = [];
+ private IReadOnlyList _health = [];
+ private IReadOnlyList _recent = [];
+ private IReadOnlyList? _duplicates;
+ private IReadOnlyList? _orphans;
+ private bool _findingDuplicates;
+ private bool _findingOrphans;
+
+ public ArchiveViewModel(ShellViewModel shell)
+ : base(SectionKey.Archive, "Icon.Archive")
+ {
+ Shell = shell;
+ ScanCommand = new AsyncRelayCommand(() => QueueAsync(a => ArchiveJobs.Scan(a)), IsOnline);
+ RebuildCommand = new AsyncRelayCommand(() => OpenRebuildDialogAsync(), () => _archive is not null);
+ VerifyCommand = new AsyncRelayCommand(() => QueueAsync(a => ArchiveJobs.Verify(a)), IsOnline);
+ AdoptCommand = new AsyncRelayCommand(AdoptAsync);
+ MaintenanceCommand = new AsyncRelayCommand(() => QueueAsync(a => ArchiveJobs.Maintenance(a)), IsOnline);
+ MaintenanceDryRunCommand = new AsyncRelayCommand(() => QueueAsync(a => ArchiveJobs.Maintenance(a, dryRun: true)), () => _archive is not null);
+ RebuildProxiesCommand = new AsyncRelayCommand(() => QueueSetAsync(ids => ArchiveJobs.Proxies(ids, SetLabel(), force: true), All()), IsOnline);
+ RelinkCommand = new AsyncRelayCommand(RelinkAsync);
+ HistoryCommand = new RelayCommand(() => Shell.Navigate(SectionKey.Jobs));
+
+ AnalyseSetCommand = new AsyncRelayCommand(() => QueueSetAsync(ids => ProcessingJobs.DeepAnalysis(ids, SetLabel()), Set()), HasSet);
+ ProxiesSetCommand = new AsyncRelayCommand(() => QueueSetAsync(ids => ArchiveJobs.Proxies(ids, SetLabel()), Set()), HasSet);
+ ThumbnailsSetCommand = new AsyncRelayCommand(() => QueueSetAsync(ids => ArchiveJobs.Thumbnails(ids, SetLabel()), Set()), HasSet);
+ VerifySetCommand = new AsyncRelayCommand(() => QueueSetAsync(ids => ArchiveJobs.Verify(_archive!, ids), Set()), HasSet);
+ RenameSetCommand = new RelayCommand(() => OpenRename(RenameMode.Titles), () => HasSet() && IsOnline());
+ MoveSetCommand = new RelayCommand(() => OpenRename(RenameMode.Folders), () => HasSet() && IsOnline());
+ RetagSetCommand = new RelayCommand(OpenRetag, () => HasSet() && IsOnline());
+ ExportSetCommand = new AsyncRelayCommand(ExportAsync, HasSet);
+
+ FindDuplicatesCommand = new AsyncRelayCommand(FindDuplicatesAsync, () => _archive is not null && !_findingDuplicates);
+ FindOrphansCommand = new AsyncRelayCommand(FindOrphansAsync, () => IsOnline() && !_findingOrphans);
+ MarkDuplicatesCommand = new AsyncRelayCommand(() => QueueAsync(a => ArchiveJobs.Maintenance(a)), IsOnline);
+ }
+
+ public ShellViewModel Shell { get; }
+
+ private AppServices Services => Shell.Services;
+
+ // ---------------- Toolbar ----------------
+
+ public IReadOnlyList Archives { get => _archives; private set => Set(ref _archives, value); }
+
+ public Core.Model.Archive? SelectedArchive
+ {
+ get => _archive;
+ set
+ {
+ if (value is null || value == _archive) return;
+ _archive = value;
+ _duplicates = null;
+ _orphans = null;
+ _ = LoadAsync();
+ }
+ }
+
+ public bool HasArchive => _archive is not null;
+
+ public string ArchiveToolTip => _archive is null ? Loc.L("Tooltips.Archive.Pick") : Loc.L("Tooltips.Archive.PickRoot", _archive.RootPath);
+
+ /// 0 = overview (tree and figures), 1 = maintenance.
+ public int ViewIndex
+ {
+ get => _viewIndex;
+ set
+ {
+ if (!Set(ref _viewIndex, value)) return;
+ OnPropertyChanged(nameof(IsOverview));
+ OnPropertyChanged(nameof(IsMaintenance));
+ }
+ }
+
+ public bool IsOverview => HasArchive && _viewIndex == 0;
+ public bool IsMaintenance => HasArchive && _viewIndex == 1;
+
+ /// "Last scan 29/09/2026 07:12 · 14 min".
+ public string LastScanText { get => _lastScanText; private set => Set(ref _lastScanText, value); }
+
+ public ICommand ScanCommand { get; }
+ public ICommand RebuildCommand { get; }
+ public ICommand VerifyCommand { get; }
+ public ICommand AdoptCommand { get; }
+ public ICommand MaintenanceCommand { get; }
+ public ICommand MaintenanceDryRunCommand { get; }
+ public ICommand RebuildProxiesCommand { get; }
+ public ICommand RelinkCommand { get; }
+ public ICommand HistoryCommand { get; }
+
+ // ---------------- Overview ----------------
+
+ public ObservableCollection TreeRows { get; } = [];
+
+ public IReadOnlyList Tiles { get => _tiles; private set => Set(ref _tiles, value); }
+ public IReadOnlyList MonthRows { get => _months; private set => Set(ref _months, value); }
+ public IReadOnlyList MonthLabels => ArchiveFigures.MonthLabels();
+ public IReadOnlyList StorageBars { get => _storage; private set => Set(ref _storage, value); }
+ public IReadOnlyList CameraBars { get => _cameras; private set => Set(ref _cameras, value); }
+ public IReadOnlyList FormatBars { get => _formats; private set => Set(ref _formats, value); }
+
+ /// Photos per month in the culture's digits.
+ public Func CountFormatter { get; } = v => Formatting.Count((long)v);
+
+ /// "412 sequences · all", "36 sequences · 2025", "Harbour sunset".
+ public string SetText
+ {
+ get
+ {
+ var set = Set();
+ if (_selection.Count == 0 || _selection.Any(n => n.Kind == TreeNodeKind.Archive)) return Loc.Plural("Archive.Set.All", set.Count);
+ return set.Count == 1 ? set[0].DisplayTitle : Loc.Plural("Shell.Status.Sequences", set.Count);
+ }
+ }
+
+ public ICommand AnalyseSetCommand { get; }
+ public ICommand ProxiesSetCommand { get; }
+ public ICommand ThumbnailsSetCommand { get; }
+ public ICommand VerifySetCommand { get; }
+ public ICommand RenameSetCommand { get; }
+ public ICommand MoveSetCommand { get; }
+ public ICommand RetagSetCommand { get; }
+ public ICommand ExportSetCommand { get; }
+
+ /// The view reports the selected tree rows.
+ public void SetSelection(IEnumerable rows)
+ {
+ _selection.Clear();
+ foreach (var row in rows) _selection.Add(row.Node);
+ OnPropertyChanged(nameof(SetText));
+ CommandManager.InvalidateRequerySuggested();
+ }
+
+ // ---------------- Maintenance view ----------------
+
+ public IReadOnlyList Health { get => _health; private set => Set(ref _health, value); }
+ public IReadOnlyList Recent { get => _recent; private set => Set(ref _recent, value); }
+
+ public IReadOnlyList? Duplicates
+ {
+ get => _duplicates;
+ private set
+ {
+ if (Set(ref _duplicates, value)) OnPropertyChanged(nameof(DuplicatesText));
+ }
+ }
+
+ public IReadOnlyList? Orphans
+ {
+ get => _orphans;
+ private set
+ {
+ if (Set(ref _orphans, value)) OnPropertyChanged(nameof(OrphansText));
+ }
+ }
+
+ /// "3 groups", "None found", or empty before the first search.
+ public string DuplicatesText => _findingDuplicates ? Loc.L("Archive.Find.Searching")
+ : _duplicates is null ? string.Empty
+ : _duplicates.Count == 0 ? Loc.L("Archive.Find.None")
+ : Loc.Plural("Archive.Duplicates.Groups", _duplicates.Count);
+
+ public string OrphansText => _findingOrphans ? Loc.L("Archive.Find.Searching")
+ : _orphans is null ? string.Empty
+ : _orphans.Count == 0 ? Loc.L("Archive.Find.None")
+ : Loc.Plural("Archive.Orphans.Count", _orphans.Count);
+
+ public ICommand FindDuplicatesCommand { get; }
+ public ICommand FindOrphansCommand { get; }
+ public ICommand MarkDuplicatesCommand { get; }
+
+ // ---------------- Dialogs ----------------
+
+ /// The open in-window dialog (rebuild, rename, retag); null when none.
+ public ArchiveDialogViewModel? Dialog
+ {
+ get => _dialog;
+ private set
+ {
+ if (Set(ref _dialog, value)) OnPropertyChanged(nameof(IsDialogOpen));
+ }
+ }
+
+ public bool IsDialogOpen => _dialog is not null;
+
+ public bool IsEmpty => _loaded && _archive is null;
+
+ // ---------------- Lifecycle ----------------
+
+ protected override void OnActivated()
+ {
+ if (_loaded) return;
+ _ = LoadAsync();
+ }
+
+ /// Reads archives, figures, tree, health and recent maintenance of the selected archive; joins a read in progress.
+ public Task LoadAsync() => _load.IsCompleted ? _load = ReadAsync() : _load;
+
+ private async Task ReadAsync()
+ {
+ if (Services.Database is not { } db) return;
+ try
+ {
+ AttachJobEvents();
+ Archives = await db.Archives.ListAsync();
+ _archive = _archive is { } current ? Archives.FirstOrDefault(a => a.Id == current.Id) : null;
+ _archive ??= CurrentArchive.Pick(Archives, Services.Settings.LastArchivePath);
+ if (_archive is not { } archive) return;
+ var root = archive.RootPath;
+ _availability = await Task.Run(() => ArchiveVolume.Probe(new ArchivePaths(root)));
+ _stats = await db.Sequences.GetStatsAsync(archive.Id);
+ var sequences = await ListSequencesAsync(db, archive.Id);
+ var withoutProxies = await db.Sequences.CountAsync(new SequenceQuery { ArchiveId = archive.Id, WithoutStatus = SequenceStatus.ProxiesBuilt });
+ ShowFigures(_stats, withoutProxies);
+ ShowTree(ArchiveTree.Build(archive, _availability, sequences));
+ await LoadRecentAsync(db, archive);
+ }
+ catch (DatabaseException ex)
+ {
+ Log.Warning("archive", "Archive figures unavailable", ex);
+ }
+ finally
+ {
+ _loaded = true;
+ OnPropertyChanged(string.Empty);
+ CommandManager.InvalidateRequerySuggested();
+ }
+ }
+
+ /// Opens the rebuild dialog (BRIEF §12.5) and counts, off the UI thread, the sidecars the rebuild will read.
+ public async Task OpenRebuildDialogAsync()
+ {
+ if (_archive is not { } archive || Services.Engine is not { } engine) return null;
+ var dialog = new RebuildDialogViewModel(archive, _availability, _stats?.Sequences ?? 0, async () =>
+ {
+ var request = ArchiveJobs.Rebuild(archive);
+ await engine.EnqueueAsync(request);
+ Queued(request.Kind, archive.Name);
+ }, CloseDialog);
+ Dialog = dialog;
+ await dialog.CountAsync();
+ return dialog;
+ }
+
+ /// Shows reports computed elsewhere (capture).
+ public void ShowReports(IReadOnlyList duplicates, OrphanReport orphans, IReadOnlyList locations)
+ {
+ Duplicates = DuplicateRows(duplicates, locations);
+ Orphans = OrphanRows(orphans, locations);
+ }
+
+ public override void Dispose()
+ {
+ if (_jobEvents && Services.Jobs is { } jobs) jobs.JobChanged -= OnJobChanged;
+ _dialog?.Dispose();
+ base.Dispose();
+ }
+
+ private static async Task> ListSequencesAsync(TitanoDatabase db, Guid archiveId)
+ {
+ var all = new List();
+ string? cursor = null;
+ do
+ {
+ var page = await db.Sequences.ListAsync(new SequenceQuery { ArchiveId = archiveId, Sort = SequenceSort.Newest, Limit = PageSize, Cursor = cursor });
+ all.AddRange(page.Items);
+ cursor = page.NextCursor;
+ }
+ while (cursor is not null);
+ return all;
+ }
+
+ private void ShowFigures(ArchiveStats stats, int withoutProxies)
+ {
+ Tiles = ArchiveFigures.Tiles(stats);
+ MonthRows = [.. ArchiveFigures.PhotosPerMonth(stats, DateTime.Today).Select(r => new ChartRow(r.Label, r.Values, r.ToolTips))];
+ StorageBars = Bars(ArchiveFigures.StorageByYear(stats));
+ CameraBars = Bars(ArchiveFigures.ByCamera(stats));
+ FormatBars = Bars(ArchiveFigures.ByFormat(stats));
+ Health =
+ [
+ .. ArchiveFigures.Health(stats, withoutProxies).Select(line => new HealthLineViewModel(line, line.Action switch
+ {
+ HealthAction.Verify => new AsyncRelayCommand(() => QueueStatusAsync(SequenceStatus.Verified, ids => ArchiveJobs.Verify(_archive!, ids))),
+ HealthAction.Proxies => new AsyncRelayCommand(() => QueueStatusAsync(SequenceStatus.ProxiesBuilt, ids => ArchiveJobs.Proxies(ids, CountLabel(ids)))),
+ HealthAction.Analyse => new AsyncRelayCommand(() => QueueStatusAsync(SequenceStatus.AnalyzedLight, ids => ProcessingJobs.LightAnalysis(ids, CountLabel(ids)))),
+ HealthAction.Duplicates => FindDuplicatesCommand,
+ HealthAction.Orphans => FindOrphansCommand,
+ _ => null,
+ })),
+ ];
+ }
+
+ private static IReadOnlyList Bars(IReadOnlyList values) =>
+ [.. values.Select(v => new ChartItem(v.Label, v.Value, v.ValueText, v.ToolTip))];
+
+ private void ShowTree(ArchiveTree tree)
+ {
+ var expanded = _tree?.ExpandedKeys();
+ if (expanded is not null) tree.Expand(expanded);
+ else if (tree.Root.Children.Count > 0) tree.Root.Children[0].IsExpanded = true;
+ _tree = tree;
+ _selection.Clear();
+ RebuildRows();
+ }
+
+ private void RebuildRows()
+ {
+ TreeRows.Clear();
+ if (_tree is null) return;
+ foreach (var node in _tree.Visible()) TreeRows.Add(new ArchiveTreeRowViewModel(node, _tree.Availability, Toggle));
+ OnPropertyChanged(nameof(SetText));
+ }
+
+ private void Toggle(ArchiveTreeNode node)
+ {
+ if (node.Kind == TreeNodeKind.Archive) return;
+ node.IsExpanded = !node.IsExpanded;
+ RebuildRows();
+ }
+
+ private async Task LoadRecentAsync(TitanoDatabase db, Core.Model.Archive archive)
+ {
+ var jobs = new List();
+ foreach (var kind in MaintenanceReports.MaintenanceKinds)
+ jobs.AddRange((await db.Jobs.ListAsync(null, kind, RecentCount)).Items.Where(j => j.TargetIds.Contains(archive.Id)));
+ Recent = MaintenanceReports.Recent(jobs, RecentCount);
+ var scan = jobs.Where(j => j.Kind == JobKind.Scan && j is { State: JobState.Done, Finished: not null, Started: not null })
+ .MaxBy(j => j.Finished);
+ LastScanText = scan is { Started: { } started, Finished: { } finished }
+ ? Loc.L("Archive.LastScan", Formatting.Date(finished) + " " + Formatting.TimeOfDay(finished), Formatting.Duration(finished - started))
+ : string.Empty;
+ }
+
+ private void AttachJobEvents()
+ {
+ if (_jobEvents || Services.Jobs is not { } jobs) return;
+ jobs.JobChanged += OnJobChanged;
+ _jobEvents = true;
+ }
+
+ /// A finished archive job changes the figures: read them again.
+ private void OnJobChanged(Job job)
+ {
+ if (job.State is not (JobState.Done or JobState.Failed) || _archive is null) return;
+ if (job.Kind is not (JobKind.Scan or JobKind.Rebuild or JobKind.Verify or JobKind.Maintenance or JobKind.Import or JobKind.Proxies or JobKind.Thumbs
+ or JobKind.LightAnalyse or JobKind.DeepAnalyse)) return;
+ System.Windows.Application.Current?.Dispatcher.BeginInvoke(() =>
+ {
+ if (IsSelected) _ = LoadAsync();
+ else _loaded = false;
+ });
+ }
+
+ // ---------------- Actions ----------------
+
+ private bool IsOnline() => _archive is not null && _availability == ArchiveAvailability.Online;
+
+ private bool HasSet() => _archive is not null && _tree is not null && Set().Count > 0;
+
+ private IReadOnlyList Set() => _tree is null ? [] : ArchiveTree.SetOf(_tree, _selection);
+
+ private IReadOnlyList All() => _tree is null ? [] : ArchiveTree.SetOf(_tree, []);
+
+ private string SetLabel() => SetText;
+
+ private async Task QueueAsync(Func build)
+ {
+ if (Services.Engine is not { } engine || _archive is not { } archive) return;
+ var request = build(archive);
+ await engine.EnqueueAsync(request);
+ Queued(request.Kind, request.Label ?? archive.Name);
+ }
+
+ private async Task QueueSetAsync(Func, ArchiveJobRequest> build, IReadOnlyList set)
+ {
+ if (Services.Engine is not { } engine || set.Count == 0) return;
+ var request = build([.. set.Select(s => s.Id)]);
+ await engine.EnqueueAsync(request);
+ Queued(request.Kind, request.Label ?? SetLabel());
+ }
+
+ /// Health fixes act on the sequences that miss a status (never verified, no proxies).
+ private async Task QueueStatusAsync(SequenceStatus missing, Func, ArchiveJobRequest> build)
+ {
+ if (Services.Database is not { } db || _archive is not { } archive) return;
+ var page = await db.Sequences.ListAsync(new SequenceQuery { ArchiveId = archive.Id, WithoutStatus = missing, Limit = PageSize });
+ await QueueSetAsync(build, page.Items);
+ }
+
+ private static string CountLabel(IReadOnlyList ids) => Loc.Plural("Shell.Status.Sequences", ids.Count);
+
+ private void Queued(JobKind kind, string label) =>
+ Shell.Notify(Loc.L("Library.Queued", JobText.Kind(kind), label), actionText: Loc.L("Shell.Nav.Jobs"), actionToolTip: Loc.L("Tooltips.Nav.Jobs"),
+ action: () => Shell.Navigate(SectionKey.Jobs));
+
+ private void OpenRename(RenameMode mode)
+ {
+ if (Services.Archives is not { } archives || _archive is not { } archive) return;
+ var dialog = new RenameDialogViewModel(mode, archives, archive, Set(), Applied, CloseDialog);
+ Dialog = dialog;
+ _ = dialog.PlanAsync();
+ }
+
+ private void OpenRetag()
+ {
+ if (Services.Archives is not { } archives) return;
+ Dialog = new RetagDialogViewModel(archives, Set(), Applied, CloseDialog);
+ }
+
+ private async Task Applied(int changed)
+ {
+ Shell.Notify(Loc.Plural("Archive.Applied", changed));
+ await LoadAsync();
+ await Shell.Library.RefreshAsync();
+ }
+
+ private void CloseDialog()
+ {
+ _dialog?.Dispose();
+ Dialog = null;
+ }
+
+ private async Task AdoptAsync()
+ {
+ var folder = Services.Dialogs.PickFolder(Loc.L("Library.Adopt.Title"));
+ if (folder is null) return;
+ if (await ArchiveActions.TryAsync(Shell, s => s.AdoptAsync(folder)))
+ {
+ _archive = null;
+ await LoadAsync();
+ }
+ }
+
+ /// A moved archive keeps its id: opening it at the new root relinks every sequence (BRIEF §12.5 Move archive).
+ private async Task RelinkAsync()
+ {
+ if (Services.Archives is not { } archives) return;
+ var folder = Services.Dialogs.PickFolder(Loc.L("Archive.Relink.Title"));
+ if (folder is null) return;
+ try
+ {
+ var archive = await Task.Run(() => archives.OpenAsync(folder));
+ Services.Settings.LastArchivePath = archive.RootPath;
+ Services.SaveSettings();
+ _archive = archive;
+ await Services.QueueScanAsync(archive, full: false);
+ Shell.Notify(Loc.L("Archive.Relink.Done", archive.Name), archive.RootPath);
+ await LoadAsync();
+ }
+ catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or InvalidDataException or DatabaseException)
+ {
+ Log.Warning("archive", $"Relinking {folder} failed", ex);
+ Shell.Notify(Loc.L("Archive.Relink.Failed"), ex.Message);
+ }
+ }
+
+ private async Task ExportAsync()
+ {
+ var set = Set();
+ var folder = Services.Dialogs.PickFolder(Loc.L("Library.Export.Title"));
+ if (folder is null || set.Count == 0) return;
+ var path = Path.Combine(folder, $"Titano sequences {DateTime.Now:yyyy-MM-dd HHmm}.csv");
+ var csv = LibraryViewModel.Csv(set);
+ await Task.Run(() => AtomicFile.WriteAllText(path, csv));
+ Shell.Notify(Loc.L("Library.Export.Done"), Path.GetFileName(path), Loc.L("Library.Export.Show"), Loc.L("Tooltips.Library.ShowExport"),
+ () => ShellActions.Reveal(path));
+ }
+
+ private async Task FindDuplicatesAsync()
+ {
+ if (Services.Archives is not { } archives || Services.Database is not { } db || _archive is not { } archive) return;
+ ViewIndex = 1;
+ _findingDuplicates = true;
+ OnPropertyChanged(nameof(DuplicatesText));
+ try
+ {
+ var groups = await Task.Run(() => archives.FindDuplicatesAsync(archive.Id));
+ Duplicates = DuplicateRows(groups, await db.Sequences.ListLocationsAsync(archive.Id));
+ }
+ catch (DatabaseException ex)
+ {
+ Shell.ReportError(ex);
+ }
+ finally
+ {
+ _findingDuplicates = false;
+ OnPropertyChanged(nameof(DuplicatesText));
+ CommandManager.InvalidateRequerySuggested();
+ }
+ }
+
+ private async Task FindOrphansAsync()
+ {
+ if (Services.Archives is not { } archives || Services.Database is not { } db || _archive is not { } archive) return;
+ ViewIndex = 1;
+ _findingOrphans = true;
+ OnPropertyChanged(nameof(OrphansText));
+ try
+ {
+ var report = await Task.Run(() => archives.FindOrphansAsync(archive.Id));
+ Orphans = OrphanRows(report, await db.Sequences.ListLocationsAsync(archive.Id));
+ }
+ catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or InvalidDataException or ArchiveOfflineException or DatabaseException)
+ {
+ Log.Warning("archive", "Orphan search failed", ex);
+ Shell.Notify(Loc.L("Archive.Orphans.Failed"), ex.Message);
+ }
+ finally
+ {
+ _findingOrphans = false;
+ OnPropertyChanged(nameof(OrphansText));
+ CommandManager.InvalidateRequerySuggested();
+ }
+ }
+
+ private IReadOnlyList DuplicateRows(IReadOnlyList groups, IReadOnlyList locations) =>
+ [
+ .. MaintenanceReports.Duplicates(groups, locations).Select(row => new DuplicateRowViewModel(row,
+ new RelayCommand(() => Shell.OpenSequence(row.SequenceId)),
+ new RelayCommand(() =>
+ {
+ if (_archive is { } archive && locations.FirstOrDefault(l => l.Id == row.SequenceId) is { } location)
+ ShellActions.Reveal(new ArchivePaths(archive.RootPath).Sequence(location.Folder).Folder);
+ }))),
+ ];
+
+ private IReadOnlyList OrphanRows(OrphanReport report, IReadOnlyList locations) =>
+ [.. MaintenanceReports.Orphans(report, locations).Select(row => new OrphanRowViewModel(row, new AsyncRelayCommand(() => FixAsync(row))))];
+
+ /// The safe fix of an orphan line; removing an index row asks first (its sidecar is gone, its files are not touched).
+ private async Task FixAsync(OrphanRow row)
+ {
+ if (Services.Archives is not { } archives || _archive is not { } archive) return;
+ try
+ {
+ switch (row.Kind)
+ {
+ case OrphanKind.UnlistedFiles or OrphanKind.MissingFiles when row.SequenceId is { } id:
+ await Task.Run(() => archives.ReconcileAsync(id));
+ break;
+ case OrphanKind.MissingSequence when row.SequenceId is { } id:
+ var confirmed = Services.Dialogs.Confirm(new ConfirmRequest
+ {
+ Heading = Loc.L("Archive.Confirm.RemoveHeading", row.Title),
+ Message = Loc.L("Archive.Confirm.RemoveMessage"),
+ SafeText = Loc.L("Archive.Confirm.Keep"),
+ SafeToolTip = Loc.L("Tooltips.Archive.KeepRow"),
+ ActionText = Loc.L("Archive.Confirm.Remove"),
+ ActionToolTip = Loc.L("Tooltips.Archive.Orphans.MissingSequence"),
+ IsDestructive = true,
+ });
+ if (!confirmed) return;
+ await Task.Run(() => archives.RemoveMissingSequencesAsync(archive.Id, [id]));
+ break;
+ case OrphanKind.NewFolder:
+ await Services.QueueScanAsync(archive, full: false);
+ Queued(JobKind.Scan, archive.Name);
+ return;
+ default:
+ return;
+ }
+ Orphans = Orphans?.Where(o => o.Row != row).ToList();
+ await LoadAsync();
+ }
+ catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or InvalidDataException or ArchiveOfflineException or DatabaseException
+ or ArgumentException)
+ {
+ Log.Warning("archive", $"Fixing {row.Title} failed", ex);
+ Shell.Notify(Loc.L("Archive.Orphans.FixFailed"), ex.Message);
+ }
+ }
}
diff --git a/src/Titano.App/Sections/ImportView.xaml b/src/Titano.App/Sections/ImportView.xaml
index 2f96195b..79761f8b 100644
--- a/src/Titano.App/Sections/ImportView.xaml
+++ b/src/Titano.App/Sections/ImportView.xaml
@@ -2,8 +2,524 @@
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:ui="clr-namespace:Titano.Ui.Controls;assembly=Titano.Ui"
- xmlns:l="clr-namespace:Titano.Ui.Localization;assembly=Titano.Ui">
-
-
+ xmlns:l="clr-namespace:Titano.Ui.Localization;assembly=Titano.Ui"
+ xmlns:imp="clr-namespace:Titano.App.Import"
+ xmlns:shell="clr-namespace:Titano.App.Shell">
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/Titano.App/Sections/ImportView.xaml.cs b/src/Titano.App/Sections/ImportView.xaml.cs
index e056a040..99e1dab4 100644
--- a/src/Titano.App/Sections/ImportView.xaml.cs
+++ b/src/Titano.App/Sections/ImportView.xaml.cs
@@ -1,8 +1,28 @@
+using System.Windows;
using System.Windows.Controls;
+using System.Windows.Controls.Primitives;
+using System.Windows.Input;
namespace Titano.App.Sections;
public partial class ImportView : UserControl
{
public ImportView() => InitializeComponent();
+
+ private ImportViewModel? Model => DataContext as ImportViewModel;
+
+ /// "Edit ▾" and "{ }" open their menu under themselves.
+ private void OnOpenMenu(object sender, RoutedEventArgs e)
+ {
+ if (sender is not Button { ContextMenu: { } menu } button) return;
+ menu.DataContext = DataContext;
+ menu.PlacementTarget = button;
+ menu.Placement = PlacementMode.Bottom;
+ menu.IsOpen = true;
+ }
+
+ /// The "{ }" menu writes into the template field used last.
+ private void OnFolderTemplateFocus(object sender, KeyboardFocusChangedEventArgs e) => Model?.SetActiveTemplate(folder: true);
+
+ private void OnFileTemplateFocus(object sender, KeyboardFocusChangedEventArgs e) => Model?.SetActiveTemplate(folder: false);
}
diff --git a/src/Titano.App/Sections/ImportViewModel.cs b/src/Titano.App/Sections/ImportViewModel.cs
index 929ec114..471a453c 100644
--- a/src/Titano.App/Sections/ImportViewModel.cs
+++ b/src/Titano.App/Sections/ImportViewModel.cs
@@ -1,9 +1,1081 @@
+using System.Collections.ObjectModel;
+using System.Globalization;
+using System.IO;
+using System.Net.Http;
+using System.Windows.Input;
+using System.Windows.Threading;
+using Titano.App.Archiving;
+using Titano.App.Import;
+using Titano.App.Infrastructure;
+using Titano.App.Settings;
using Titano.App.Shell;
+using Titano.Core.Diagnostics;
+using Titano.Core.Import;
+using Titano.Core.Localization;
+using Titano.Core.Model;
+using Titano.Core.Naming;
+using Titano.Data;
+using Titano.Data.Archiving;
+using Titano.Data.Jobs;
+using Titano.Data.Processing;
+using Titano.Protocol.Client;
+using Titano.Ui.Controls;
+using Titano.Ui.Mvvm;
namespace Titano.App.Sections;
-/// Card and folder import (BRIEF §12.4).
-public sealed class ImportViewModel(ShellViewModel shell) : SectionViewModel(SectionKey.Import, "Icon.Import")
+/// Where the Plan panel is: nothing to import, reading the card, a plan, copying, finished, or failed.
+public enum ImportPhase
{
- public ShellViewModel Shell { get; } = shell;
+ NoSource,
+ Planning,
+ Ready,
+ Running,
+ Done,
+ Failed,
+}
+
+/// A template token offered by the "{ }" menu.
+public sealed record TokenItem(string Text, string ToolTip);
+
+/// Another card whose remembered settings can be copied ("Copy settings from").
+public sealed record ProfileSource(string Name, ICommand Command);
+
+///
+/// Card and folder import (BRIEF §12.4, §13, Import.html): the card pool, the remembered profile of the selected
+/// card, the destination (this PC's archive, a folder, or the signed-in server), the plan before anything is
+/// copied (sessions with editable titles, duplicates, space, "Show plan"), the hash-verified import itself (a job
+/// for the archive, run here for a folder or the server), its verification result and the after-import actions.
+/// Inserted cards raise a toast; a known card with automatic import starts with its profile.
+///
+public sealed class ImportViewModel : SectionViewModel
+{
+ private static readonly TimeSpan PlanDelay = TimeSpan.FromMilliseconds(350);
+
+ private readonly DispatcherTimer _planDelay;
+ private readonly Dictionary _titles = new(StringComparer.Ordinal);
+ private IReadOnlyList _cards = [];
+ private ImportSource? _selected;
+ private string? _folderSource;
+ private Core.Model.Archive? _archive;
+ private ImportChoices _choices = new();
+ private ImportPhase _phase;
+ private string? _statusText;
+ private ImportPlan? _rawPlan;
+ private ImportPlan? _plan;
+ private PlanTotals? _totals;
+ private IReadOnlySet _existingFolders = new HashSet();
+ private CancellationTokenSource? _planCts;
+ private CancellationTokenSource? _runCts;
+ private Task _planning = Task.CompletedTask;
+ private PlanDetails? _details;
+ private bool _isRenaming;
+ private double _progress;
+ private string? _progressText;
+ private ImportResultViewModel? _result;
+ private string? _errorText;
+ private Guid? _jobId;
+ private string? _jobSourceKey;
+ private bool _jobEventsAttached;
+ private bool _loaded;
+ private string? _autoStartKey;
+ private bool _activeTemplateIsFolder;
+ private bool _refreshing;
+
+ public ImportViewModel(ShellViewModel shell)
+ : base(SectionKey.Import, "Icon.Import")
+ {
+ Shell = shell;
+ _planDelay = new DispatcherTimer { Interval = PlanDelay };
+ _planDelay.Tick += (_, _) =>
+ {
+ _planDelay.Stop();
+ Replan();
+ };
+ Nickname = new EditableField(string.Empty, _ => null, text => _ = SaveCardAsync(text, null), () => Loc.L("Tooltips.Import.Nickname"));
+ FolderPath = new EditableField(string.Empty, ArchiveLocations.Validate, text => Choices = _choices with { FolderPath = text },
+ () => Loc.L("Tooltips.Import.FolderPath"));
+ GapMinutes = NumberField(1, 24 * 60, () => _choices.GapMinutes, n => Choices = _choices with { GapMinutes = n }, "Tooltips.Import.Gap");
+ MinimumFrames = NumberField(1, 1000, () => _choices.MinimumFrames, n => Choices = _choices with { MinimumFrames = n }, "Tooltips.Import.MinimumFrames");
+ FolderTemplate = new EditableField(_choices.FolderTemplate, t => NamingPreview.Validate(t, isFolder: true),
+ t => Choices = _choices with { FolderTemplate = t }, () => Loc.L("Tooltips.Import.FolderTemplate"));
+ FileTemplate = new EditableField(_choices.FileTemplate, t => NamingPreview.Validate(t, isFolder: false),
+ t => Choices = _choices with { FileTemplate = t }, () => Loc.L("Tooltips.Import.FileTemplate"));
+ Tokens = [.. PathTemplate.Tokens.Select(t => new TokenItem("{" + t + "}", Loc.L("Import.Token." + t)))];
+
+ RefreshCommand = new AsyncRelayCommand(RefreshSourcesAsync);
+ PickFolderCommand = new RelayCommand(PickSourceFolder);
+ ChooseDestinationCommand = new RelayCommand(ChooseDestinationFolder);
+ InsertTokenCommand = new RelayCommand(p =>
+ {
+ if (p is not TokenItem token) return;
+ var field = _activeTemplateIsFolder ? FolderTemplate : FileTemplate;
+ field.Text += token.Text;
+ field.Commit();
+ });
+ RenameCommand = new RelayCommand(() => IsRenaming = true, () => _selected?.Card is not null);
+ ForgetCommand = new AsyncRelayCommand(ForgetCardAsync, () => _selected?.Card is not null);
+ ShowPlanCommand = new RelayCommand(() => Details = _plan is null ? null : ImportPlans.Details(_plan, _choices.Destination, _choices.VerifyCopies),
+ () => _plan is not null);
+ CloseDetailsCommand = new RelayCommand(() => Details = null);
+ StartCommand = new AsyncRelayCommand(StartAsync, () => StartBlocker is null);
+ CancelCommand = new AsyncRelayCommand(CancelAsync, () => _phase == ImportPhase.Running);
+ NewImportCommand = new RelayCommand(() =>
+ {
+ Result = null;
+ Replan();
+ });
+ RetryCommand = new AsyncRelayCommand(RetryAsync, () => _phase == ImportPhase.Failed);
+
+ shell.Services.Devices.Arrived += device => Dispatch(() => _ = CardInsertedAsync(device));
+ shell.Services.Devices.Removed += device => Dispatch(() => _ = OnRemovedAsync(device));
+ shell.Services.Server.PropertyChanged += (_, _) => Dispatch(() => OnPropertyChanged(string.Empty));
+ }
+
+ public ShellViewModel Shell { get; }
+
+ private AppServices Services => Shell.Services;
+
+ // ---------------- Sources ----------------
+
+ public ObservableCollection Sources { get; } = [];
+
+ public ImportSource? SelectedSource
+ {
+ get => _selected;
+ set
+ {
+ // Rebuilding the list clears the list box's selection for a moment; that is not the user's choice.
+ if (_refreshing || value is null || Equals(_selected, value)) return;
+ _selected = value;
+ OnSourceChanged();
+ }
+ }
+
+ public ICommand RefreshCommand { get; }
+ public ICommand PickFolderCommand { get; }
+
+ /// Start the import with the card's profile as soon as this card is inserted (per card, BRIEF §12.4).
+ public bool AutoImport
+ {
+ get => _selected?.Card?.AutoImport == true;
+ set
+ {
+ if (_selected?.Card is null || value == AutoImport) return;
+ _ = SaveCardAsync(null, value);
+ }
+ }
+
+ public bool CanAutoImport => _selected?.Card is not null;
+
+ public string AutoImportToolTip => CanAutoImport ? Loc.L("Tooltips.Import.Auto") : Loc.L("Import.Blocked.AutoNeedsCard");
+
+ // ---------------- Profile header ----------------
+
+ public bool HasSource => _selected is not null;
+
+ public string SourceTitle => _selected?.Title ?? string.Empty;
+
+ /// "SD 128 GB · serial 3F2A-9C11 · Canon EOS R5 #0431 · last import 21/09/2026".
+ public string IdentityText { get; private set; } = string.Empty;
+
+ /// A card seen for the first time: one field asks for its nickname (BRIEF §12.4).
+ public bool IsNicknameOpen => _selected is { Kind: SourceKind.Card, Card: { } card } && (card.Nickname is null || _isRenaming);
+
+ public bool IsRenaming
+ {
+ get => _isRenaming;
+ set
+ {
+ if (Set(ref _isRenaming, value)) OnPropertyChanged(nameof(IsNicknameOpen));
+ }
+ }
+
+ public EditableField Nickname { get; }
+
+ public bool CanEditProfile => _selected?.Card is not null;
+
+ public IReadOnlyList OtherCards =>
+ [
+ .. _cards.Where(c => c.Id != _selected?.Card?.Id)
+ .Select(c => new ProfileSource(c.Nickname ?? c.Label ?? c.Identity, new RelayCommand(() => LoadChoices(ImportService.ProfileOf(c))))),
+ ];
+
+ public ICommand RenameCommand { get; }
+ public ICommand ForgetCommand { get; }
+
+ // ---------------- Form ----------------
+
+ public ImportChoices Choices
+ {
+ get => _choices;
+ private set
+ {
+ var previous = _choices;
+ if (previous == value) return;
+ _choices = value;
+ OnPropertyChanged(string.Empty);
+ if (value.NeedsNewPlan(previous) || (value.TitlesChangeNames != previous.TitlesChangeNames && _titles.Count > 0)) SchedulePlan();
+ else ApplyPlan();
+ }
+ }
+
+ public bool IsArchiveDestination
+ {
+ get => _choices.Destination == ImportDestinationKind.Archive;
+ set
+ {
+ if (value) Choices = _choices with { Destination = ImportDestinationKind.Archive };
+ }
+ }
+
+ public bool IsFolderDestination
+ {
+ get => _choices.Destination == ImportDestinationKind.Folder;
+ set
+ {
+ if (value) Choices = _choices with { Destination = ImportDestinationKind.Folder };
+ }
+ }
+
+ public bool IsServerDestination
+ {
+ get => _choices.Destination == ImportDestinationKind.Server;
+ set
+ {
+ if (value) Choices = _choices with { Destination = ImportDestinationKind.Server };
+ }
+ }
+
+ public bool CanUseArchive => _archive is not null && Services.Archives is not null;
+
+ public string ArchiveToolTip => CanUseArchive ? Loc.L("Tooltips.Import.Archive", _archive!.RootPath) : Loc.L("Import.Blocked.NoArchive");
+
+ public bool CanUseServer => Services.Server.IsConnected;
+
+ public string ServerName => Services.Server.ServerName ?? Loc.L("Import.Destination.NotConnected");
+
+ public string ServerToolTip => CanUseServer ? Loc.L("Tooltips.Import.Server") : Loc.L("Import.Blocked.NoServer");
+
+ public EditableField FolderPath { get; }
+
+ public ICommand ChooseDestinationCommand { get; }
+
+ public bool IncludeSubfolders
+ {
+ get => _choices.IncludeSubfolders;
+ set => Choices = _choices with { IncludeSubfolders = value };
+ }
+
+ public bool SplitSessions
+ {
+ get => _choices.SplitSessions;
+ set => Choices = _choices with { SplitSessions = value };
+ }
+
+ public EditableField GapMinutes { get; }
+ public EditableField MinimumFrames { get; }
+
+ public bool VerifyCopies
+ {
+ get => _choices.VerifyCopies;
+ set => Choices = _choices with { VerifyCopies = value };
+ }
+
+ public EditableField FolderTemplate { get; }
+ public EditableField FileTemplate { get; }
+ public IReadOnlyList Tokens { get; }
+ public ICommand InsertTokenCommand { get; }
+
+ /// The view tells which template field the "{ }" menu writes into.
+ public void SetActiveTemplate(bool folder) => _activeTemplateIsFolder = folder;
+
+ /// "→ 2026/2026-09-28 Canon EOS R5/2026-09-28_18-02-11_0001.CR2".
+ public string NamePreview
+ {
+ get
+ {
+ var first = _plan is null ? null : ImportPlans.FirstDestination(_plan, _choices.Destination);
+ first ??= NamingPreview.FirstNames(_choices.FolderTemplate, _choices.FileTemplate).FirstOrDefault();
+ return first is null ? string.Empty : Loc.L("Import.Names.Preview", first);
+ }
+ }
+
+ public bool SkipDuplicates
+ {
+ get => _choices.Duplicates == DuplicatePolicy.Skip;
+ set
+ {
+ if (value) Choices = _choices with { Duplicates = DuplicatePolicy.Skip };
+ }
+ }
+
+ public bool ImportDuplicatesAgain
+ {
+ get => _choices.Duplicates == DuplicatePolicy.ImportAgain;
+ set
+ {
+ if (value) Choices = _choices with { Duplicates = DuplicatePolicy.ImportAgain };
+ }
+ }
+
+ public bool KeepCard
+ {
+ get => _choices.AfterImport == AfterImport.Keep;
+ set
+ {
+ if (value) Choices = _choices with { AfterImport = AfterImport.Keep };
+ }
+ }
+
+ public bool DeleteImported
+ {
+ get => _choices.AfterImport == AfterImport.DeleteImported;
+ set
+ {
+ if (value) Choices = _choices with { AfterImport = AfterImport.DeleteImported };
+ }
+ }
+
+ public bool FormatCard
+ {
+ get => _choices.AfterImport == AfterImport.FormatCard;
+ set
+ {
+ if (value) Choices = _choices with { AfterImport = AfterImport.FormatCard };
+ }
+ }
+
+ public bool Eject
+ {
+ get => _choices.Eject;
+ set => Choices = _choices with { Eject = value };
+ }
+
+ public bool DeepAnalysis
+ {
+ get => _choices.DeepAnalysis;
+ set => Choices = _choices with { DeepAnalysis = value };
+ }
+
+ /// Card actions only exist for a card imported into this PC's archive.
+ public bool CardActionsApply => _choices.Destination == ImportDestinationKind.Archive && _selected?.Kind == SourceKind.Card;
+
+ // ---------------- Plan ----------------
+
+ public ImportPhase Phase
+ {
+ get => _phase;
+ private set
+ {
+ if (!Set(ref _phase, value)) return;
+ OnPropertyChanged(string.Empty);
+ CommandManager.InvalidateRequerySuggested();
+ }
+ }
+
+ /// The plan the Import button runs (duplicate choice and typed titles applied); null until the card is read.
+ public ImportPlan? Plan => _plan;
+
+ public bool IsBusyPlanning => _phase == ImportPhase.Planning;
+ public bool IsFormEnabled => _phase != ImportPhase.Running;
+ public bool HasPlan => _plan is not null && _phase is ImportPhase.Ready or ImportPhase.Running;
+ public bool IsRunning => _phase == ImportPhase.Running;
+ public bool IsDone => _phase == ImportPhase.Done;
+ public bool IsFailed => _phase == ImportPhase.Failed;
+ public bool ShowsStatus => _phase is ImportPhase.NoSource or ImportPhase.Planning;
+
+ /// "Reading 1,240 photos", "Choose a card or a folder", or why nothing can be planned.
+ public string? StatusText => _statusText;
+
+ public string TotalsText => _totals?.Text ?? string.Empty;
+ public string DuplicatesText => _totals?.DuplicatesText ?? string.Empty;
+ public bool HasDuplicates => _totals?.Duplicates > 0;
+ public StatusKind DuplicatesKind => HasDuplicates ? StatusKind.Warning : StatusKind.Done;
+ public string ImportedBeforeText => _totals?.ImportedBeforeText ?? string.Empty;
+ public string SpaceText => _totals?.SpaceText ?? string.Empty;
+ public bool IsSpaceShort => _totals is { HasEnoughSpace: false };
+
+ public ObservableCollection Sessions { get; } = [];
+
+ /// "Show plan": every file to its destination; null while closed.
+ public PlanDetails? Details
+ {
+ get => _details;
+ private set
+ {
+ if (Set(ref _details, value)) OnPropertyChanged(nameof(IsDetailsOpen));
+ }
+ }
+
+ public bool IsDetailsOpen => _details is not null;
+
+ public ICommand ShowPlanCommand { get; }
+ public ICommand CloseDetailsCommand { get; }
+
+ // ---------------- Start, progress, result ----------------
+
+ public ICommand StartCommand { get; }
+ public ICommand CancelCommand { get; }
+ public ICommand NewImportCommand { get; }
+ public ICommand RetryCommand { get; }
+
+ public string StartText => _totals?.ImportText ?? Loc.L("Import.StartPlain");
+
+ public string StartToolTip => StartBlocker ?? Loc.L("Tooltips.Import.Start");
+
+ /// Why the import cannot start; null when it can.
+ public string? StartBlocker =>
+ _phase != ImportPhase.Ready || _plan is null ? Loc.L("Import.Blocked.NoPlan")
+ : _selected is not { IsInserted: true } ? Loc.L("Import.Blocked.NotInserted")
+ : DestinationBlocker() is { } blocked ? blocked
+ : FolderTemplate.HasErrors || FileTemplate.HasErrors ? Loc.L("Import.Blocked.Template")
+ : _plan.CopyCount == 0 ? Loc.L("Import.Blocked.NothingToCopy")
+ : _totals is { HasEnoughSpace: false } ? Loc.L("Import.Blocked.Space")
+ : null;
+
+ public double Progress { get => _progress; private set => Set(ref _progress, value); }
+
+ /// "1,240 of 4,812 · 3 min left".
+ public string? ProgressText { get => _progressText; private set => Set(ref _progressText, value); }
+
+ /// The verification result and after-import actions; null until an import finished.
+ public ImportResultViewModel? Result
+ {
+ get => _result;
+ private set
+ {
+ if (!Set(ref _result, value)) return;
+ if (value is null && _phase == ImportPhase.Done) Phase = ImportPhase.Ready;
+ }
+ }
+
+ public string? ErrorText { get => _errorText; private set => Set(ref _errorText, value); }
+
+ // ---------------- Lifecycle ----------------
+
+ protected override void OnActivated()
+ {
+ if (_loaded) return;
+ _loaded = true;
+ _ = RefreshSourcesAsync();
+ }
+
+ /// Lists the devices and remembered cards again, keeping the selection.
+ public async Task RefreshSourcesAsync()
+ {
+ try
+ {
+ if (Services.Database is { } db)
+ {
+ _cards = await db.MediaCards.ListAsync();
+ _archive = await CurrentArchive.FindAsync(db, Services.Settings.LastArchivePath);
+ }
+ }
+ catch (DatabaseException ex)
+ {
+ Log.Warning("import", "Card list unavailable", ex);
+ }
+ var key = _selected?.Key;
+ var pool = Rebuild();
+ var again = pool.FirstOrDefault(s => s.Key == key) ?? pool.FirstOrDefault(s => s.IsInserted && s.Kind == SourceKind.Card);
+ if (!Equals(again, _selected))
+ {
+ _selected = again;
+ OnSourceChanged();
+ }
+ else
+ {
+ OnPropertyChanged(string.Empty);
+ }
+ }
+
+ /// Lists inserted devices, remembered cards and the picked folder again.
+ private IReadOnlyList Rebuild()
+ {
+ var pool = CardPool.Build(Services.Devices.Devices, _cards, _folderSource);
+ _refreshing = true;
+ try
+ {
+ Sources.Clear();
+ foreach (var source in pool) Sources.Add(source);
+ }
+ finally
+ {
+ _refreshing = false;
+ }
+ return pool;
+ }
+
+ /// Selects a source by card identity or folder path.
+ public void SelectSource(string key)
+ {
+ if (Sources.FirstOrDefault(s => s.Key == key) is { } source) SelectedSource = source;
+ }
+
+ /// Completes when the plan in progress is ready (capture, tests).
+ public Task WaitForPlanAsync() => _planning;
+
+ /// Shows a finished import's result without running it (capture).
+ public ImportResultViewModel ShowResult(ImportOutcome outcome)
+ {
+ var plan = _plan ?? throw new InvalidOperationException("No plan to show a result for.");
+ Finish(plan, outcome);
+ return _result!;
+ }
+
+ public override void Dispose()
+ {
+ _planDelay.Stop();
+ _planCts?.Cancel();
+ _runCts?.Cancel();
+ if (_jobEventsAttached && Services.Jobs is { } jobs)
+ {
+ jobs.JobChanged -= OnJobChanged;
+ jobs.Progress -= OnJobProgress;
+ }
+ _result?.Dispose();
+ base.Dispose();
+ }
+
+ // ---------------- Selection and profile ----------------
+
+ private void OnSourceChanged()
+ {
+ _isRenaming = false;
+ _titles.Clear();
+ Details = null;
+ Result = null;
+ Nickname.Load(_selected?.Card?.Nickname ?? string.Empty);
+ var profile = _selected?.Card is { } card ? ImportService.ProfileOf(card) : DefaultProfile();
+ LoadChoices(profile);
+ _ = LoadIdentityAsync();
+ OnPropertyChanged(string.Empty);
+ Replan();
+ }
+
+ /// A new card starts from the archive's templates and the brief's defaults.
+ private CardProfile DefaultProfile() => new()
+ {
+ FolderTemplate = _archive?.FolderTemplate ?? Services.Settings.FolderTemplate,
+ FileTemplate = _archive?.FileTemplate ?? Services.Settings.FileTemplate,
+ };
+
+ private void LoadChoices(CardProfile profile)
+ {
+ var destination = _choices.Destination == ImportDestinationKind.Server && !CanUseServer ? ImportDestinationKind.Archive : _choices.Destination;
+ if (destination == ImportDestinationKind.Archive && !CanUseArchive) destination = ImportDestinationKind.Folder;
+ var loaded = ImportChoices.FromProfile(profile) with { Destination = destination, FolderPath = _choices.FolderPath };
+ GapMinutes.Load(loaded.GapMinutes.ToString(Loc.Culture));
+ MinimumFrames.Load(loaded.MinimumFrames.ToString(Loc.Culture));
+ FolderTemplate.Load(loaded.FolderTemplate);
+ FileTemplate.Load(loaded.FileTemplate);
+ Choices = loaded;
+ }
+
+ private async Task LoadIdentityAsync()
+ {
+ var text = _selected?.IdentityText ?? string.Empty;
+ if (_selected?.Card is { } card && Services.Database is { } db)
+ {
+ try
+ {
+ if ((await db.MediaCards.ListImportsAsync(card.Id, 1)).FirstOrDefault() is { } last)
+ text = string.Join(" · ", new[] { text, Loc.L("Import.Device.LastImport", Formatting.Date(last.ImportedAt)) }.Where(t => t.Length > 0));
+ }
+ catch (DatabaseException ex)
+ {
+ Log.Warning("import", "Card history unavailable", ex);
+ }
+ }
+ IdentityText = text;
+ OnPropertyChanged(nameof(IdentityText));
+ }
+
+ /// Stores the nickname and/or the automatic-import choice of the selected card.
+ private async Task SaveCardAsync(string? nickname, bool? autoImport)
+ {
+ if (_selected?.Card is not { } card || Services.Archives is not { } archives) return;
+ try
+ {
+ var saved = await archives.Imports.SaveCardAsync(card.Id, nickname ?? card.Nickname, ImportService.ProfileOf(card), autoImport ?? card.AutoImport);
+ IsRenaming = false;
+ await ReplaceCardAsync(saved);
+ }
+ catch (DatabaseException ex)
+ {
+ Shell.ReportError(ex);
+ }
+ }
+
+ private async Task ReplaceCardAsync(MediaCard card)
+ {
+ _cards = [.. _cards.Where(c => c.Id != card.Id), card];
+ var key = _selected?.Key;
+ _selected = Rebuild().FirstOrDefault(s => s.Key == key);
+ await LoadIdentityAsync();
+ OnPropertyChanged(string.Empty);
+ }
+
+ private async Task ForgetCardAsync()
+ {
+ if (_selected?.Card is not { } card || Services.Database is not { } db) return;
+ var confirmed = Services.Dialogs.Confirm(new ConfirmRequest
+ {
+ Heading = Loc.L("Import.Confirm.ForgetHeading", _selected.Title),
+ Message = Loc.L("Import.Confirm.ForgetMessage"),
+ SafeText = Loc.L("Import.Confirm.KeepProfile"),
+ SafeToolTip = Loc.L("Tooltips.Import.KeepProfile"),
+ ActionText = Loc.L("Import.Confirm.Forget"),
+ ActionToolTip = Loc.L("Tooltips.Import.Forget"),
+ IsDestructive = true,
+ });
+ if (!confirmed) return;
+ await db.MediaCards.DeleteAsync(card.Id);
+ _cards = [.. _cards.Where(c => c.Id != card.Id)];
+ await RefreshSourcesAsync();
+ }
+
+ private void PickSourceFolder()
+ {
+ if (Services.Dialogs.PickFolder(Loc.L("Import.Folder.PickSource")) is not { } folder) return;
+ _folderSource = folder;
+ _ = RefreshAndSelectAsync(folder);
+ }
+
+ private async Task RefreshAndSelectAsync(string key)
+ {
+ await RefreshSourcesAsync();
+ SelectSource(key);
+ }
+
+ private void ChooseDestinationFolder()
+ {
+ if (Services.Dialogs.PickFolder(Loc.L("Import.Folder.PickDestination"), FolderPath.Value) is not { } folder) return;
+ FolderPath.Load(folder);
+ Choices = _choices with { FolderPath = folder, Destination = ImportDestinationKind.Folder };
+ }
+
+ // ---------------- Planning ----------------
+
+ private void SchedulePlan()
+ {
+ _planDelay.Stop();
+ _planDelay.Start();
+ }
+
+ private void Replan()
+ {
+ _planDelay.Stop();
+ _planning = PlanAsync();
+ }
+
+ private string? DestinationBlocker() => _choices.Destination switch
+ {
+ ImportDestinationKind.Archive when !CanUseArchive => Loc.L("Import.Blocked.NoArchive"),
+ ImportDestinationKind.Folder when ArchiveLocations.Validate(_choices.FolderPath) is { } problem => problem,
+ ImportDestinationKind.Server when !CanUseServer => Loc.L("Import.Blocked.NoServer"),
+ _ => null,
+ };
+
+ private IImportDestination? Destination() => DestinationBlocker() is not null ? null : _choices.Destination switch
+ {
+ ImportDestinationKind.Archive => new ArchiveDestination(Services.Archives!, _archive!),
+ ImportDestinationKind.Folder => new UnindexedDestination(ImportDestinationKind.Folder, _choices.FolderPath!),
+ _ => new UnindexedDestination(ImportDestinationKind.Server, ServerStagingRoot) { ServerSpace = ServerSpace() },
+ };
+
+ /// What the signed-in user may still store on the server; null without a quota.
+ private long? ServerSpace() => Services.Server.User is { QuotaBytes: > 0 } user ? System.Math.Max(0, user.QuotaBytes - user.UsedBytes) : null;
+
+ private string ServerStagingRoot => Path.Combine(CacheStore.Folder(Services.Environment, Services.Settings), "server-import");
+
+ private async Task PlanAsync()
+ {
+ _planCts?.Cancel();
+ if (_phase is ImportPhase.Running) return;
+ var cts = _planCts = new CancellationTokenSource();
+ _rawPlan = null;
+ _plan = null;
+ _totals = null;
+ Sessions.Clear();
+ if (_selected?.Root is not { } root)
+ {
+ SetStatus(ImportPhase.NoSource, Loc.L(_selected is null ? "Import.Status.Choose" : "Import.Status.NotInserted"));
+ return;
+ }
+ if (Destination() is not { } destination)
+ {
+ SetStatus(ImportPhase.NoSource, DestinationBlocker());
+ return;
+ }
+ SetStatus(ImportPhase.Planning, Loc.L("Import.Status.Reading"));
+ var progress = new Progress(n =>
+ {
+ if (!cts.IsCancellationRequested) SetStatus(ImportPhase.Planning, Loc.Plural("Import.Status.ReadingCount", n));
+ });
+ var options = _choices.ToOptions(_titles);
+ var cardId = _selected.Kind == SourceKind.Card ? await RegisteredCardIdAsync() : null;
+ try
+ {
+ var plan = await Task.Run(() => destination.PlanAsync(root, options, cardId, progress, cts.Token), cts.Token);
+ var folders = destination is ArchiveDestination archive && Services.Database is { } db
+ ? (await db.Sequences.ListLocationsAsync(archive.Archive.Id, cts.Token)).Select(l => l.Folder).ToHashSet(StringComparer.OrdinalIgnoreCase)
+ : new HashSet(StringComparer.OrdinalIgnoreCase);
+ if (cts.IsCancellationRequested) return;
+ _existingFolders = folders;
+ _rawPlan = plan;
+ ApplyPlan();
+ SetStatus(ImportPhase.Ready, null);
+ if (_autoStartKey is { } key && key == _selected?.Key)
+ {
+ _autoStartKey = null;
+ if (StartBlocker is null) await StartAsync();
+ }
+ }
+ catch (OperationCanceledException) when (cts.IsCancellationRequested)
+ {
+ }
+ catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or DatabaseException or ArgumentException or InvalidOperationException)
+ {
+ Log.Warning("import", $"Planning the import of {root} failed", ex);
+ SetStatus(ImportPhase.NoSource, Loc.L("Import.Status.PlanFailed", ex.Message));
+ }
+ }
+
+ /// The selected card's id, registering an inserted card on first sight.
+ private async Task RegisteredCardIdAsync()
+ {
+ if (_selected?.Card is { } known) return known.Id;
+ if (_selected?.Device is not { } device || Services.Archives is not { } archives) return null;
+ try
+ {
+ var card = await archives.Imports.RegisterCardAsync(device.ToVolume());
+ await ReplaceCardAsync(card);
+ OnPropertyChanged(nameof(IsNicknameOpen));
+ return card.Id;
+ }
+ catch (DatabaseException ex)
+ {
+ Log.Warning("import", "The card could not be remembered", ex);
+ return null;
+ }
+ }
+
+ /// Applies the duplicate choice and the typed titles to the planned photos and refreshes the panel.
+ private void ApplyPlan()
+ {
+ if (_rawPlan is null) return;
+ var plan = ImportPlans.WithDuplicates(_rawPlan, _choices.Duplicates);
+ _plan = _choices.TitlesChangeNames ? plan : ImportPlans.WithTitles(plan, _titles);
+ _totals = ImportPlans.Totals(_plan, _choices.VerifyCopies);
+ var rows = ImportPlans.Sessions(_plan, _choices.Destination, _existingFolders);
+ if (!rows.Select(r => r.SessionKey).SequenceEqual(Sessions.Select(s => s.Row.SessionKey)))
+ {
+ Sessions.Clear();
+ foreach (var row in rows) Sessions.Add(new ImportSessionRowViewModel(row, OnTitleChanged));
+ }
+ OnPropertyChanged(string.Empty);
+ CommandManager.InvalidateRequerySuggested();
+ }
+
+ private void OnTitleChanged(string sessionKey, string title)
+ {
+ if (string.IsNullOrWhiteSpace(title)) _titles.Remove(sessionKey);
+ else _titles[sessionKey] = title.Trim();
+ if (_choices.TitlesChangeNames) SchedulePlan();
+ else ApplyPlan();
+ }
+
+ private void SetStatus(ImportPhase phase, string? text)
+ {
+ _statusText = text;
+ Phase = phase;
+ OnPropertyChanged(nameof(StatusText));
+ }
+
+ // ---------------- Running ----------------
+
+ private async Task StartAsync()
+ {
+ if (_plan is not { } plan || _selected is not { Root: { } root } source) return;
+ var choices = _choices;
+ if (source.Card is { } card && Services.Archives is { } archives)
+ {
+ try
+ {
+ await archives.Imports.SaveCardAsync(card.Id, card.Nickname, choices.ToProfile(), card.AutoImport);
+ }
+ catch (DatabaseException ex)
+ {
+ Log.Warning("import", "The card profile was not saved", ex);
+ }
+ }
+ Details = null;
+ ErrorText = null;
+ Progress = 0;
+ ProgressText = Loc.L("Import.Progress.Starting");
+ _jobSourceKey = source.Key;
+ Phase = ImportPhase.Running;
+ if (choices.Destination == ImportDestinationKind.Archive)
+ {
+ await StartJobAsync(plan, choices, source);
+ return;
+ }
+ var cts = _runCts = new CancellationTokenSource();
+ var progress = new Progress(ShowProgress);
+ try
+ {
+ var outcome = choices.Destination == ImportDestinationKind.Folder
+ ? await Task.Run(() => LocalImport.RunAsync(plan, new FolderImportSink(choices.FolderPath!), choices.VerifyCopies, progress, cts.Token), cts.Token)
+ : await RunServerAsync(plan, choices, progress, cts.Token);
+ Finish(plan, outcome);
+ }
+ catch (OperationCanceledException) when (cts.IsCancellationRequested)
+ {
+ Fail(Loc.L("Import.Status.Cancelled"));
+ }
+ catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or TitanoApiException or HttpRequestException or UntrustedCertificateException)
+ {
+ Log.Warning("import", $"Import of {root} failed", ex);
+ Fail(ex.Message);
+ }
+ }
+
+ private async Task RunServerAsync(ImportPlan plan, ImportChoices choices, IProgress progress, CancellationToken ct)
+ {
+ var flow = Services.Server.Flow;
+ if (flow.Address is not { } address || flow.Token is not { } token) throw new InvalidOperationException(Loc.L("Import.Blocked.NoServer"));
+ var staging = Path.Combine(ServerStagingRoot, plan.Id.ToString("N"));
+ using var client = new TitanoClient(address, new CertificatePinning(Services.Server.Fingerprints), $"Titano ({Environment.MachineName})") { Token = token };
+ try
+ {
+ return await Task.Run(() => LocalImport.RunAsync(plan, new ServerImportSink(client, staging), choices.VerifyCopies, progress, ct), ct);
+ }
+ finally
+ {
+ // Our own staging folder: verified copies not uploaded yet stay on the card.
+ if (Directory.Exists(staging)) Directory.Delete(staging, recursive: true);
+ }
+ }
+
+ private async Task StartJobAsync(ImportPlan plan, ImportChoices choices, ImportSource source)
+ {
+ if (Services.Engine is not { } engine || _archive is not { } archive)
+ {
+ Fail(Loc.L("Import.Blocked.NoArchive"));
+ return;
+ }
+ AttachJobEvents();
+ var cardId = source.Kind == SourceKind.Card ? source.Card?.Id ?? await RegisteredCardIdAsync() : null;
+ var job = await engine.EnqueueAsync(ArchiveJobs.Import(archive, plan, cardId, choices.VerifyCopies));
+ _jobId = job.Id;
+ Shell.Notify(Loc.L("Import.Toast.Started", source.Title), plan.CopyCount > 0 ? _totals?.Text : null, Loc.L("Shell.Nav.Jobs"),
+ Loc.L("Tooltips.Nav.Jobs"), () => Shell.Navigate(SectionKey.Jobs));
+ }
+
+ private void AttachJobEvents()
+ {
+ if (_jobEventsAttached || Services.Jobs is not { } jobs) return;
+ jobs.JobChanged += OnJobChanged;
+ jobs.Progress += OnJobProgress;
+ _jobEventsAttached = true;
+ }
+
+ private void OnJobProgress(JobProgressInfo p)
+ {
+ if (p.JobId != _jobId) return;
+ Dispatch(() =>
+ {
+ if (p.JobId == _jobId && _phase == ImportPhase.Running) ShowProgress(p.Done, p.Total, p.Eta);
+ });
+ }
+
+ private void OnJobChanged(Job job)
+ {
+ if (job.Id != _jobId) return;
+ Dispatch(() => _ = OnImportJobChangedAsync(job));
+ }
+
+ private async Task OnImportJobChangedAsync(Job job)
+ {
+ if (job.Id != _jobId || _plan is not { } plan) return;
+ switch (job.State)
+ {
+ case JobState.Done:
+ _jobId = null;
+ var outcome = await VerifyAsync(plan, job);
+ Finish(plan, outcome);
+ await QueueDeepAnalysisAsync(plan);
+ break;
+ case JobState.Failed:
+ Fail(job.Error ?? Loc.L("Jobs.State.Failed"));
+ break;
+ case JobState.Cancelled:
+ _jobId = null;
+ Fail(Loc.L("Import.Status.Cancelled"));
+ break;
+ case JobState.Paused:
+ ProgressText = Loc.L("Jobs.State.Paused");
+ break;
+ }
+ }
+
+ /// Every planned copy must be a frame of the archive now (BRIEF §12.4 verification result).
+ private async Task VerifyAsync(ImportPlan plan, Job job)
+ {
+ if (Services.Database is not { } db || _archive is not { } archive) return new ImportOutcome(0, 0, 0, [], false);
+ var verify = _choices.VerifyCopies;
+ return await Task.Run(() => ImportOutcome.CheckAsync(plan, verify,
+ async (item, ct) => (await db.Frames.FindBySizeAndCaptureAsync(archive.Id, item.Size, item.CapturedAt, ct).ConfigureAwait(false)).Count > 0,
+ CancellationToken.None));
+ }
+
+ ///
+ /// "Deep analysis" after import (BRIEF §13: default on, background, low priority) for every sequence the import
+ /// filled; the engine queues only the light analysis by itself.
+ ///
+ private async Task QueueDeepAnalysisAsync(ImportPlan plan)
+ {
+ if (!_choices.DeepAnalysis || Services.Database is not { } db || Services.Engine is not { } engine || _archive is not { } archive) return;
+ try
+ {
+ var ids = new List();
+ foreach (var session in plan.Sessions)
+ {
+ if (await db.Sequences.FindBySessionKeyAsync(archive.Id, session.SessionKey) is { } id) ids.Add(id);
+ }
+ if (ids.Count > 0)
+ await engine.EnqueueAsync(ProcessingJobs.DeepAnalysis(ids, Loc.Plural("Shell.Status.Sequences", ids.Count)) with { Priority = JobPriority.Background });
+ }
+ catch (DatabaseException ex)
+ {
+ Log.Warning("import", "Deep analysis was not queued", ex);
+ }
+ }
+
+ private void ShowProgress(ImportProgress p) => ShowProgress(p.BytesDone, p.BytesTotal, null, p.ItemsDone, p.ItemsTotal);
+
+ private void ShowProgress(long done, long total, TimeSpan? eta, int? items = null, int? itemsTotal = null)
+ {
+ Progress = total > 0 ? System.Math.Clamp(done / (double)total, 0, 1) : 0;
+ var parts = new List
+ {
+ items is { } n && itemsTotal is { } of
+ ? Loc.L("Import.Progress.Items", Formatting.Count(n), Formatting.Count(of))
+ : Loc.L("Import.Progress.Bytes", Formatting.Bytes(done), Formatting.Bytes(total)),
+ };
+ if (eta is { } left) parts.Add(Loc.L("Jobs.Bar.Left", Formatting.Duration(left)));
+ ProgressText = string.Join(" · ", parts);
+ }
+
+ private void Finish(ImportPlan plan, ImportOutcome outcome)
+ {
+ _runCts = null;
+ _result?.Dispose();
+ var device = _selected?.Device is { } d && Services.Devices.Devices.Any(x => x.Identity == d.Identity) ? d : null;
+ var card = _selected?.Card ?? _cards.FirstOrDefault(c => c.Identity == _selected?.Key);
+ Result = new ImportResultViewModel(Shell, plan, outcome, _choices, _choices.Destination == ImportDestinationKind.Archive ? _archive : null, card, device);
+ Phase = ImportPhase.Done;
+ Shell.Notify(Loc.L("Import.Toast.Done", _selected?.Title ?? string.Empty), Result.ResultText, Loc.L("Shell.Nav.Import"), Loc.L("Tooltips.Nav.Import"),
+ () => Shell.Navigate(SectionKey.Import));
+ _ = Result.AutoEjectAsync();
+ }
+
+ private void Fail(string message)
+ {
+ _runCts = null;
+ ErrorText = message;
+ Phase = ImportPhase.Failed;
+ }
+
+ private async Task CancelAsync()
+ {
+ if (_jobId is { } id && Services.Jobs is { } jobs) await jobs.CancelAsync(id);
+ _runCts?.Cancel();
+ }
+
+ /// A failed archive import resumes from its checkpoint (card re-inserted); others plan again.
+ private async Task RetryAsync()
+ {
+ if (_jobId is { } id && Services.Jobs is { } jobs)
+ {
+ ErrorText = null;
+ Phase = ImportPhase.Running;
+ await jobs.ResumeAsync(id);
+ return;
+ }
+ Replan();
+ }
+
+ // ---------------- Card insertion ----------------
+
+ ///
+ /// A card was inserted (BRIEF §12.4, §13): it joins the Devices list; an interrupted import of it may resume, a
+ /// known card with automatic import starts with its profile into the archive (a toast lets the user cancel),
+ /// any other card is offered in a toast.
+ ///
+ public async Task CardInsertedAsync(CardDevice device)
+ {
+ await RefreshSourcesAsync();
+ var source = Sources.FirstOrDefault(s => s.Key == device.Identity);
+ if (source is null || source.Kind == SourceKind.Drive) return;
+ if (_phase == ImportPhase.Failed && _jobId is not null && _jobSourceKey == device.Identity)
+ {
+ Shell.Notify(Loc.L("Import.Toast.Inserted", source.Title), Loc.L("Import.Toast.ResumeMessage"), Loc.L("Import.Toast.Resume"),
+ Loc.L("Tooltips.Import.Resume"), () => RetryCommand.Execute(null));
+ return;
+ }
+ if (_phase == ImportPhase.Running) return;
+ if (source.Card is { AutoImport: true } && CanUseArchive)
+ {
+ _autoStartKey = device.Identity;
+ // Automatic imports always go to this PC's archive; the plan starts the import once it is ready.
+ _choices = _choices with { Destination = ImportDestinationKind.Archive };
+ if (Equals(_selected, source)) Replan();
+ else SelectedSource = source;
+ Shell.Notify(Loc.L("Import.Toast.Inserted", source.Title), Loc.L("Import.Toast.AutoMessage"), Loc.L("Import.Toast.Cancel"),
+ Loc.L("Tooltips.Import.CancelAuto"), () => _ = CancelAutoAsync(device.Identity));
+ return;
+ }
+ Shell.ShowToast(new Toast
+ {
+ Title = Loc.L("Import.Toast.Inserted", source.Title),
+ Message = source.Subtitle,
+ ActionText = Loc.L("Import.Toast.Import"),
+ ActionToolTip = Loc.L("Tooltips.Import.OpenCard"),
+ ActionCommand = new RelayCommand(() =>
+ {
+ SelectSource(device.Identity);
+ Shell.Navigate(SectionKey.Import);
+ }),
+ });
+ }
+
+ private async Task CancelAutoAsync(string identity)
+ {
+ if (_autoStartKey == identity) _autoStartKey = null;
+ if (_phase == ImportPhase.Running && _jobSourceKey == identity) await CancelAsync();
+ }
+
+ private async Task OnRemovedAsync(CardDevice device)
+ {
+ await RefreshSourcesAsync();
+ _result?.SetDevice(Services.Devices.Devices.FirstOrDefault(d => d.Identity == _selected?.Device?.Identity));
+ }
+
+ private static void Dispatch(Action action)
+ {
+ var dispatcher = System.Windows.Application.Current?.Dispatcher;
+ if (dispatcher is null || dispatcher.CheckAccess()) action();
+ else dispatcher.BeginInvoke(action);
+ }
+
+ private static EditableField NumberField(int min, int max, Func current, Action commit, string toolTipKey) =>
+ new(current().ToString(Loc.Culture),
+ text => int.TryParse(text.Trim(), NumberStyles.Integer, Loc.Culture, out var n) && n >= min && n <= max
+ ? null
+ : Loc.L("Errors.Number.Range", min.ToString("N0", Loc.Culture), max.ToString("N0", Loc.Culture)),
+ text => commit(int.Parse(text.Trim(), NumberStyles.Integer, Loc.Culture)),
+ () => Loc.L(toolTipKey));
}
diff --git a/src/Titano.App/Shell/ConfirmDialog.xaml b/src/Titano.App/Shell/ConfirmDialog.xaml
index 46b41013..934a8896 100644
--- a/src/Titano.App/Shell/ConfirmDialog.xaml
+++ b/src/Titano.App/Shell/ConfirmDialog.xaml
@@ -14,6 +14,11 @@
Visibility="{Binding Detail, Converter={x:Static ui:NullToCollapsedConverter.Instance}}">
+
+
+
+
diff --git a/src/Titano.App/Shell/ConfirmDialog.xaml.cs b/src/Titano.App/Shell/ConfirmDialog.xaml.cs
index 06af3cd7..a4297376 100644
--- a/src/Titano.App/Shell/ConfirmDialog.xaml.cs
+++ b/src/Titano.App/Shell/ConfirmDialog.xaml.cs
@@ -12,6 +12,10 @@ public sealed partial class ConfirmDialog : TitanoWindow
DataContext = request;
InitializeComponent();
Action.SetResourceReference(StyleProperty, request.IsDestructive ? "Button.Destructive" : "Button.Primary");
+ if (request.TypedConfirmation is null) return;
+ Typing.Visibility = Visibility.Visible;
+ Action.IsEnabled = false;
+ Loaded += (_, _) => Typed.Focus();
}
/// True when the user chose the action.
@@ -26,4 +30,7 @@ public sealed partial class ConfirmDialog : TitanoWindow
private void OnSafe(object sender, RoutedEventArgs e) => DialogResult = false;
private void OnAction(object sender, RoutedEventArgs e) => DialogResult = true;
+
+ private void OnTyped(object sender, System.Windows.Controls.TextChangedEventArgs e) =>
+ Action.IsEnabled = string.Equals(Typed.Text.Trim(), ((ConfirmRequest)DataContext).TypedConfirmation, StringComparison.CurrentCultureIgnoreCase);
}
diff --git a/src/Titano.App/Shell/ScreenCapture.cs b/src/Titano.App/Shell/ScreenCapture.cs
index 6a406d5a..effc0803 100644
--- a/src/Titano.App/Shell/ScreenCapture.cs
+++ b/src/Titano.App/Shell/ScreenCapture.cs
@@ -3,7 +3,9 @@ using System.Windows;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Threading;
+using Titano.App.Archiving;
using Titano.App.DesignTime;
+using Titano.App.Import;
using Titano.App.Settings;
using Titano.Core.Diagnostics;
using Titano.Ui.Theming;
@@ -91,10 +93,20 @@ public static class ScreenCapture
shell.Navigate(SectionKey.About);
written += await SaveAsync(window, directory, "about", theme);
- foreach (var key in new[] { SectionKey.Import, SectionKey.Sequence, SectionKey.Archive })
+ shell.Navigate(SectionKey.Sequence);
+ written += await SaveAsync(window, directory, "sequence", theme);
+
+ DismissToasts(window);
+ foreach (var state in ImportScenes.States)
{
- shell.Navigate(key);
- written += await SaveAsync(window, directory, key.ToString().ToLowerInvariant(), theme);
+ await ImportScenes.ShowAsync(shell, state);
+ written += await SaveAsync(window, directory, "import-" + state, theme);
+ }
+ DismissToasts(window);
+ foreach (var view in ArchiveScenes.Views)
+ {
+ await ArchiveScenes.ShowAsync(shell, view);
+ written += await SaveAsync(window, directory, "archive-" + view, theme);
}
}
Log.Info("capture", $"{written} screenshot(s) written to {Path.GetFullPath(directory)}");
@@ -111,6 +123,12 @@ public static class ScreenCapture
}
}
+ /// Toasts of one screen's scene stay out of the next screen's picture.
+ private static void DismissToasts(MainWindow window)
+ {
+ foreach (var toast in window.Toasts.Toasts.ToList()) window.Toasts.Dismiss(toast);
+ }
+
private static async Task SaveAsync(Window window, string directory, string screen, AppTheme theme, ShellViewModel? waitForThumbnails = null)
{
await Settle(window);
diff --git a/tests/Titano.App.Tests/Import/CardPoolTests.cs b/tests/Titano.App.Tests/Import/CardPoolTests.cs
index 80dfd284..ac41e553 100644
--- a/tests/Titano.App.Tests/Import/CardPoolTests.cs
+++ b/tests/Titano.App.Tests/Import/CardPoolTests.cs
@@ -42,10 +42,10 @@ public sealed class CardPoolTests
Assert.Equal("New card", pool[0].StateText);
Assert.Equal("EOS R5 · card A", pool[1].Title);
Assert.Equal("Known card", pool[1].StateText);
- Assert.Equal(@"F:\ · 128 GB · 96.2 GB used", pool[1].Subtitle);
- Assert.Equal(@"F:\ · 128 GB · serial 3F2A-9C11 · Canon EOS R5 #0431", pool[1].IdentityText);
+ Assert.Equal("128 GB · 96.2 GB used", pool[1].Subtitle);
+ Assert.Equal("128 GB · serial 3F2A-9C11 · Canon EOS R5 #0431", pool[1].IdentityText);
Assert.Equal(SourceKind.Drive, pool[2].Kind);
- Assert.Equal(@"G:\ · no DCIM · 1.8 TB free", pool[2].Subtitle);
+ Assert.Equal("no DCIM · 1.8 TB free", pool[2].Subtitle);
Assert.False(pool[3].IsInserted);
Assert.Null(pool[3].Root);
Assert.Equal("Canon EOS R5 · not inserted", pool[3].Subtitle);