feat: owner review 2 phase 4b: mass conversion after import #13

Merged
Alby96 merged 82 commits from claude/owner-review-2-p4b-rc7 into main 2026-11-03 10:41:59 +01:00
354 changed files with 24530 additions and 843 deletions

No files matched your search

+27 -18
View File
@@ -8,7 +8,7 @@ Companion to `docs/BRIEF.md` (scope, behaviour) and `docs/ui/DESIGN.md` (looks).
| Project | TFM | Purpose |
|---|---|---|
| `src/Chronos.Core` | net10.0 | Engine shared by every program: metadata, codecs, imaging, analysis, advisor, motion, render, video containers and managed encoders, archive format, naming, import planning, packaging, localization runtime, diagnostics, brand mark |
| `src/Chronos.Core.Windows` | net10.0-windows | WIC decoders and codec inventory, Media Foundation encoders, DXGI adapters, removable devices, DPAPI, shell launcher, window chrome, power (P/Invoke/COM only) |
| `src/Chronos.Core.Windows` | net10.0-windows | WIC decoders and codec inventory, Media Foundation encoders, DXGI adapters, removable devices and volume free space, DPAPI, shell launcher, window chrome, power (P/Invoke/COM only) |
| `src/Chronos.Data` | net10.0 | `IDatabase`, SQLite binding, PostgreSQL wire client, migrations, repositories, the job engine, the archive engine (`Archiving`), the analysis/render engine (`Processing`) and the client sync engine (`Sync`) |
| `src/Chronos.Protocol` | net10.0 | API v1 DTOs, source-generated JSON context, typed `ChronosClient` with certificate pinning and bandwidth limiting |
| `src/Chronos.Server` | net10.0 (Web SDK) | ASP.NET Core minimal API, auth, uploads, sync, jobs, render nodes, events, embedded admin panel, Windows service host |
@@ -29,9 +29,9 @@ Dependencies point one way: `Core` ← `Core.Windows`, `Data`, `Protocol` ← `S
| Folder / namespace | Content |
|---|---|
| `Imaging` (+ `Decoders`, `Geometry`, `Thumbnails`) | `ImageBuffer` (planar float, linear light), `IImageDecoderProvider`, `DecoderFactory` (decode tiers: native → embedded preview; `ImageDecoder.Probe` names a file's tier without decoding it; `DecodeRequest.PreferPreview` takes an adequate RAW preview by choice for analyses and previews, `DecodedImage.ByChoice`), `ManagedDecoderProvider`, `FrameWindow` (read-ahead, memory budget, float32 spill), resampler, thumbnail cache |
| `Metadata` (+ `Tiff`, `Jpeg`, `Bmff`, `Raf`, `Riff`, `Png`, `Xmp`, `MakerNotes`) | Signature sniffing, Exif/GPS/XMP/MakerNotes, ISO-BMFF (HEIF, CR3), `MetadataReader`, `MetadataBuilder` (all fallback chains), `ExifWriter` |
| `Codecs` (`Jpeg`, `Png`, `Tiff`, `Dng`, `Raw`, `Gif`, `Apng`, `Ico`) | Pure managed codecs; native RAW development (DNG, CR2, NEF, ARW, PEF, RAF) |
| `Imaging` (+ `Decoders`, `Geometry`, `Thumbnails`) | `ImageBuffer` (planar float, linear light), `IImageDecoderProvider` (`DevelopsRawAt8Bits`: true for WIC's Raw Image Extension, which a conversion's 16-bit targets never read RAWs through), `DecoderFactory` (decode tiers: native → embedded preview; `ImageDecoder.Probe` names a file's tier without decoding it; `DecodeRequest.PreferPreview` takes an adequate RAW preview by choice for analyses and previews, `DecodedImage.ByChoice`), `ManagedDecoderProvider` (`ReadsHeaders`: a conversion's probes read JPEG, PNG and TIFF headers and refuse what the decoders would), `FrameWindow` (read-ahead, memory budget, float32 spill), resampler, thumbnail cache |
| `Metadata` (+ `Tiff`, `Jpeg`, `Bmff`, `Raf`, `Riff`, `Png`, `Xmp`, `MakerNotes`) | Signature sniffing, Exif/GPS/XMP/MakerNotes, ISO-BMFF (HEIF, CR3), `MetadataReader`, `MetadataBuilder` (all fallback chains), `ExifWriter` (proxies, exports and converted photos; exposure program, metering mode, flash and white balance when known) |
| `Codecs` (`Jpeg`, `Png`, `Tiff`, `Dng`, `Raw`, `Gif`, `Apng`, `Ico`, `Icc`) | Pure managed codecs; native RAW development (DNG, CR2, NEF, ARW, PEF, RAF); header reads that refuse what a decode would (`JpegDecoder.ReadDecodableInfo`, `PngDecoder.MaxPixels`, `TiffImageReader.ReadInfo`; the TIFF reader refuses CMYK, CIELab, palette and other samples it does not render); ICC profiles written into JPEG (APP2) and TIFF (tag 34675); `LinearDngWriter` (exports: clipped linear sRGB; `LinearDngOptions.SceneReferred` for a conversion: linear ProPhoto primaries, up to `MaxHeadroomStops` (4) of headroom in BaselineExposure, matrices that read back as written); `Icc` (`IccProfile`: ICC parser and writer, matrix/TRC and gray curves, sRGB told by the numbers (by the name only without colorant tags), `IsSrgbFor` (the values a DNG takes), `WithSrgbCurve` and `GrayAsRgb` (the profiles a conversion makes), colorants that convert nothing dropped, the in-house Adobe RGB (1998)-compatible and Display P3 profiles; `SourceColor`: the colour space a photo's headers record and whether its samples are linear) |
| `Analysis` (+ `Deep`) | Luminance statistics, deflicker, regions, holy grail, white balance, colour temperature, light analysis, streaming deep analysis with checkpoints |
| `Advice` | `Advisor`: recommendations with localisable reasons, apply/optimise, sequence presets |
| `Motion` | FFT, phase correlation, pyramids, optical flow, motion blur, stabiliser, virtual camera, interpolation, stacking |
@@ -42,7 +42,8 @@ Dependencies point one way: `Core` ← `Core.Windows`, `Data`, `Protocol` ← `S
| `Video` (+ `Mp4`, `Avi`, `Bitstream`, `Yuv`, `Managed`) | `IVideoEncoderProvider`, MP4 muxer and inspector, AVI-MJPEG, NV12/P010, managed encoders (MJPEG-AVI, GIF, APNG, image sequences) |
| `Archiving` | Archive layout and paths, sidecars (`sequence.json`, `project.json`), scanner, index snapshot, leases, thumbnail packs, verify, adopt, rename plans (`RenamePlanner`: folder, title and file templates, `RenameTemplates`, the plan's fingerprint, which pins every file rename by its digest and not the frames version; `FileRenames`: a sequence's new file names; `FileRenameJournal`: two-phase renames through temporary names, `.chronos/rename-files.json`, a recovery safe to run again from wherever it stopped, a new name taken meanwhile sending that photo and its companions back together to their old names or a free `_2`, those that took their new names already with them; `FrameCompanions`: the XMP files that follow a photo, one rule for the trash and Reorganize, matched whatever their case and each folder listed once by `FrameCompanions.Index`) |
| `Import` | Card scan, session detection, import plan (photos named through `FrameNaming` with the camera and lens of their session's first photo), hash-verified copy, card eraser (re-hash before delete) |
| `Naming` | Folder/file templates and tokens (folder levels scans skip escaped with `_`; `ExpandText` for titles; `ExpandFile` shortens a long file name before its `.{ext}`); `FrameNaming` (the naming context and unique file name of a frame, shared by import, upload and Reorganize: the sequence's camera and lens, the first frame for folders; `UniqueNames`: `_2`, `_3`… in linear time); `TemplateRules` (what every place a template is typed or sent refuses, the archive engine's new or changed templates included: a folder scans skip, a lost extension, names that repeat) |
| `Conversion` | Mass conversion after import (owner review 2, R7): `ConvertOptions` (target JPEG 4:4:4 / TIFF-16 / linear DNG, the archival one, `ConvertMode` Replace or New sequence, JPEG quality and the quality that counts, the converted name: the archive's file template with the frame's `FrameNaming` context in its sequence, as filing names it, `{ext}` the target's), `FrameConverter` (`Decoders`: the conversion's chain, the managed provider first with its header probes, WIC after it, no RAW at 8 bits for a 16-bit target; native-tier decode only; `Treatment`: what Chronos reads never changes, so the colour space is carried (code values), described by a profile made for the values written (`Describe`: float values as sRGB codes, a gray curve as RGB) or refused (a DNG takes sRGB's values only); pixels that are not numbers fail as damaged; in-house encoders, Exif from the sidecar and the original via `ExifWriter`, hashed as made, written atomically, verified: read back, metadata again, decoded by the server's decoders; `ConversionException` and its `ConversionFailure`, `FailureText`: the job log's sentence by cause), `ConvertPlanner` (per sequence the frames converted and skipped with `ConvertSkip`, each file probed with the conversion's decoders whatever tier was recorded, 8 at a time; `TooLarge`: what the target holds and the server's decoders read back, without overflow; a frame another host flagged undecodable asked again where other decoders (WIC) read it; size estimates per pixel; `ConvertSequencePlan.Digest`, the photos converted with their content; `ConvertPlan` with its space and fingerprint) |
| `Naming` | Folder/file templates and tokens (folder levels scans skip escaped with `_`; `ExpandText` for titles; `ExpandFile` shortens a long file name before its `.{ext}`); `FrameNaming` (the naming context and unique file name of a frame, shared by import, upload, Reorganize and conversion: the sequence's camera and lens, the first frame for folders; `UniqueNames`: `_2`, `_3`… in linear time); `TemplateRules` (what every place a template is typed or sent refuses, the archive engine's new or changed templates included: a folder scans skip, a lost extension, names that repeat) |
| `Model` | Domain entities and enums (§5) shared by Data, Server and clients |
| `Packaging` | TPK1 installer payload writer/reader, staged install transaction |
| `Diagnostics` | `Log` (never throws: a line its sink cannot write is dropped), `FileLogSink` with `LogFileOptions` (level, daily or hourly files, numbered parts past a size, pruning by age and by the total size, never the file being written), synthetic sequences, `SecretScrubber`, `DiagnosticsArchive` (scrubbed diagnostics zip) |
@@ -54,13 +55,13 @@ Dependencies point one way: `Core` ← `Core.Windows`, `Data`, `Protocol` ← `S
|---|---|
| `Sqlite`, `Postgres` | SQLite P/Invoke binding (winsqlite3 / libsqlite3), in-house PostgreSQL wire protocol v3 client with pool and LISTEN |
| `Migrations/{sqlite,postgres}/NNNN_name.sql` | Embedded, applied in one transaction at open (`MigrationRunner`) |
| `Repositories` | `ChronosDatabase` facade: archives, sequences, frames, tags, renders, jobs, cards, users, tokens, uploads, render nodes, settings, audit, schedules (`ScheduleRepository`: system rows seeded without overwriting edits and never deleted, the compare-and-set claim of a run), tombstones of removed photos (`FrameRemovalRepository`, `frame_removals`, written from the sidecar's `removed` list), `SequenceRepository.GetStampAsync` (a digest of what a Reorganize plans from in the index), `RenderRepository.RebaseFolderAsync` (the export paths that follow a moved folder); `DatabaseBackups` (`VACUUM INTO` copies of an SQLite index into `backups` next to it, every copy keeping as many as the backup schedules keep (`KeptAsync`), the newest copy that seeds the `index-backup` schedule (`Newest`, `SystemSchedule.LastDone`), restore staged for the next start and carried out before the index opens, so it also recovers one that no longer opens) |
| `Repositories` | `ChronosDatabase` facade: archives, sequences, frames, tags, renders, jobs, cards, users, tokens, uploads, render nodes, settings, audit, schedules (`ScheduleRepository`: system rows seeded without overwriting edits and never deleted, the compare-and-set claim of a run), tombstones of removed photos (`FrameRemovalRepository`, `frame_removals`, written from the sidecar's `removed` list), `SequenceRepository.GetStampAsync` (a digest of what a Reorganize plans from in the index) and `GetConvertStampAsync` (with what a conversion plans from: its photos' count, sizes, formats, pixel sizes and the flags that decide), `JobRepository.ListPendingTargetsAsync` (the targets of pending jobs of a kind, also of those created before a time), `RenderRepository.RebaseFolderAsync` (the export paths that follow a moved folder); `DatabaseBackups` (`VACUUM INTO` copies of an SQLite index into `backups` next to it, every copy keeping as many as the backup schedules keep (`KeptAsync`), the newest copy that seeds the `index-backup` schedule (`Newest`, `SystemSchedule.LastDone`), restore staged for the next start and carried out before the index opens, so it also recovers one that no longer opens) |
| `Jobs` | `JobEngine` (one job at a time; reviews the priority queue and makes a lower running job yield, requeued with its checkpoint; no history purge, the housekeeping schedule's clean-up does it), `JobPriorityQueue` (a level per job kind, the claim order, settings round trip), `IJobHandler`, `IJobHandlerProvider`, `JobContext` (progress, checkpoints, follow-up jobs that never interrupt their parent), `JobThroughput`/`JobEta` (rate and bounded time left) |
| `Scheduling` | `Scheduler` (one per host: seeds the host's system schedules, claims due runs by compare-and-set, catch-up, clock changes, create/edit/reset/delete/run now as API v1 DTOs), `ScheduleRecurrence` (the in-house `every:`/`daily:`/`weekly:`/`monthly:` form, wall-clock times across DST), `ScheduleActions` (action names, parameters, availability, the archive jobs a run queues), `IScheduleHost` and `SystemSchedule` (what the server and the desktop supply), `ScheduleOutcome`, `ScheduleMapping` (model ↔ DTO) |
| `Housekeeping` | `BackupJobHandler`, `CleanupJobHandler`, `ICleanupStep` with the shared steps (`CleanupSteps`: job history, audit log, trash report that never deletes); hosts add their own steps through `ArchiveServiceOptions.CleanupSteps` |
| `Archiving` | `ArchiveService` (create/adopt/open, archive settings written to `archive.json` then the index, `ArchiveSettings.CheckTemplates` and `TemplateRuleException` holding a template given anew to the template rules; `UnderLeaseAsync`: a write under a sequence's lease with its row read under it), `ArchiveIndexer` (scan, rebuild; a sequence found in another folder takes its exports' paths along), `ArchiveIngest` (uploads and imports, named through `FrameNaming`), `ImportService`, `ArchiveVerifier`, `ArchiveImages` (thumbnail and proxy passes, several photos at once through `OrderedWork`, which hands results back in frame order), `FrameTiers` (decode tier, `PreviewOnly`/`Undecodable` flags and preview size of frames, written to sidecar and index by the light analysis, deep analysis, renders and image passes), `GprCompanions` (the JPEG of each GoPro GPR, found in the index when an import kept it in another sequence), `ArchiveMaintenance`, `MassRenamer` (mass rename and Reorganize: the dry run reads each sidecar for a file template; each step checked under its leases before anything of it moves (where its sequences are, what is inside and at its new folder, a sidecar of a newer format, the title it was planned from when it changes it or names the folder or files after it), then the folder, with the sequences of the plan an earlier step left as they were inside it (taken along, their title and file names kept), every index row (the frame paths and render paths of the exports inside it, a file or an image-sequence folder, its own unless the export is still at the old place and another sequence's when it moved with it, follow it in one transaction; a sidecar that cannot be read or written then still has its row follow, and fails the step), then the files under the plan's journal in `journal/` (a sequence whose photos changed since, such as one still receiving them, or whose files are found changed or in use or have their new names taken keeps its file names, the renames being pinned by digest, and the step and the plan go on); the journal keeps the tally of the whole plan, and a plan its job held (paused, cancelled or failed) is left to that job, only its half-done file renames completed at an archive open, which completes any other plan an interruption left and tells each sequence changed; the file renames of a step: sidecar, a sequence whose sidecar cannot be read staying as it is with every folder around it, index (`FrameRepository.RenameFilesAsync`) and the sequence's journal), `SequenceFolders` (`Holds`: the folder the index has for a sequence is there and its sidecar names no other sequence; every writer into a sequence's folder asks it), `SequenceTrash` (delete into the archive's hidden trash with a dry run, restore; the folder moves back when the index step fails; lists sequence and photo entries; `SequenceTrash.Empty`: the emptying's dry run, fingerprint and erase, each entry checked against its fingerprint again under its lease), `FrameTrash` (photos of a sequence into `trash/photos` with a dry run, a journal that undoes an interrupted deletion whose entry stays unlisted until its sidecar is written, tombstones (a photo never hashed is hashed as it goes; one whose original is missing goes without a file or tombstone; a frame that stays and may be a twin is hashed, its hash kept), positions parked and placed back, proxies and thumbnails moved to follow their frames; `FrameTrash.Restore`: restore re-hashes each file and says why each kept photo stayed (`KeptReason`), under a journal of its own into the sequence that another writer settles only under the entry's lease, into a new sequence through the ingest when theirs is gone, each original staged inside its own entry and the record rewritten after each photo filed), job handlers |
| `Archiving` | `ArchiveService` (create/adopt/open, archive settings written to `archive.json` then the index, `ArchiveSettings.CheckTemplates` and `TemplateRuleException` holding a template given anew to the template rules; `UnderLeaseAsync`: a write under a sequence's lease with its row read under it), `ArchiveIndexer` (scan, rebuild; a sequence found in another folder takes its exports' paths along), `ArchiveIngest` (uploads and imports, named through `FrameNaming`; content a conversion replaced is a duplicate of the frame holding its conversion; a restore or a replacement not settled yet refuses the batch), `ImportService`, `ArchiveVerifier`, `ArchiveImages` (thumbnail and proxy passes, several photos at once through `OrderedWork`, which hands results back in frame order), `FrameTiers` (decode tier, `PreviewOnly`/`Undecodable` flags and preview size of frames, written to sidecar and index by the light analysis, deep analysis, renders and image passes), `GprCompanions` (the JPEG of each GoPro GPR, found in the index when an import kept it in another sequence), `ArchiveMaintenance` (also a conversion job's staging and journals, by the job's state; those of a job this index does not know go together, by age), `MassRenamer` (mass rename and Reorganize: the dry run reads each sidecar for a file template; each step checked under its leases before anything of it moves (where its sequences are, what is inside and at its new folder, a sidecar of a newer format, the title it was planned from when it changes it or names the folder or files after it), then the folder, with the sequences of the plan an earlier step left as they were inside it (taken along, their title and file names kept), every index row (the frame paths and render paths of the exports inside it, a file or an image-sequence folder, its own unless the export is still at the old place and another sequence's when it moved with it, follow it in one transaction; a sidecar that cannot be read or written then still has its row follow, and fails the step), then the files under the plan's journal in `journal/` (a sequence whose photos changed since, such as one still receiving them, or whose files are found changed or in use or have their new names taken keeps its file names, the renames being pinned by digest, and the step and the plan go on); the journal keeps the tally of the whole plan, and a plan its job held (paused, cancelled or failed) is left to that job, only its half-done file renames completed at an archive open, which completes any other plan an interruption left and tells each sequence changed; the file renames of a step: sidecar, a sequence whose sidecar cannot be read staying as it is with every folder around it, index (`FrameRepository.RenameFilesAsync`) and the sequence's journal), `SequenceFolders` (`Holds`: the folder the index has for a sequence is there and its sidecar names no other sequence; every writer into a sequence's folder asks it), `SequenceTrash` (delete into the archive's hidden trash with a dry run, restore; the folder moves back when the index step fails; lists sequence and photo entries; `SequenceTrash.Empty`: the emptying's dry run, fingerprint and erase, each entry checked against its fingerprint again under its lease, `TrashKept` with its `TrashKeptReason` for each entry kept; `SequenceTrash.Replaced`: where a replaced entry's conversions are, read from the archive's sidecars (in the index's or the entry's folder, in the trash, else by one `SidecarWalk` of the archive per dry run or emptying) through their replaced tombstones, a conversion deleted only on the archive's word (a tombstone, the trash, or an `ErasureRecord` in `trash/.erased/`, written when an emptying erases a deleted sequence a replaced entry still needs), `TrashEntry.ConversionDeleted` in the dry run and its fingerprint, the erase weighed under the entry's and the sequence's leases once the sequence is settled; `BusyAsync`: what running and paused jobs hold, but the job asking, from `JobRepository.ListHoldsAsync`), `FrameTrash` (photos of a sequence into `trash/photos` with a dry run, a journal that undoes an interrupted deletion whose entry stays unlisted until its sidecar is written, tombstones (a photo never hashed is hashed as it goes; one whose original is missing goes without a file or tombstone; a frame that stays and may be a twin is hashed, its hash kept), positions parked and placed back, proxies and thumbnails moved to follow their frames; `FrameTrash.Restore`: restore re-hashes each file and says why each kept photo stayed (`KeptReason`), under a journal of its own into the sequence that another writer settles only under the entry's lease, into a new sequence through the ingest when theirs is gone, each original staged inside its own entry and the record rewritten after each photo filed; a replaced entry swaps back while its converted frames are unchanged (`SwapBackAsync`); `FrameTrash.Replace`: the files of frames swapped in place, same iLine truncated
| `Processing` | `ProcessingService`, `SequenceAnalyser`, `DeepReports` (a saved deep report while it still describes the frames), `SequenceRender`, `ProjectStore`, `ProjectBundles` (a `.chronos` file for a sequence, and the sequence a file names), `RenderNodeClient`, job handlers |
| `Sync` | `SyncService` (sync table of one server: compare, link by content, settle conflicts, enqueue transfers), `SyncRules` (status, settings merge and differences, no I/O), `SyncTombstones` (photos either side removed are not offered back, a replaced photo counts as its replacement), `SyncPositions` (the settings' frame positions translated by photo to the frames of the copy they go to), `SyncLinkStore` (`sync_links`, `sync_state`), `SyncTransfers` and `SyncJobHandler` (resumable, hash-verified uploads and downloads as jobs; downloads commit through the archive ingest), `SyncAgent` (background comparison, server events, backoff, offline proxies), `ProxyCache` and `RemoteSequence` (server sequences opened with proxies), `ISyncRemote` (the server calls; `ChronosSyncRemote` over `ChronosClient`) |
| `Sync` | `SyncService` (sync table of one server: compare, link by content through the aliases, settle conflicts, enqueue transfers), `SyncRules` (status, settings merge and differences, the proxies this PC can send, aliases followed; no I/O), `SyncTombstones` (photos either side removed are not offered back; the replaced tombstones of both sides join the encodings of one photo, union-find, each compared as the smallest SHA-256 among them, a deletion covering them all; immutable once made), `SyncPositions` (the settings' frame positions translated by photo to the frames of the copy they go to), `SyncLinkStore` (`sync_links`, `sync_state`), `SyncTransfers` and `SyncJobHandler` (resumable, hash-verified uploads and downloads as jobs; downloads commit through the archive ingest, and a frame missing here whose photo the server holds in another encoding takes that file through `FrameTrash.ReplaceMissingAsync`; job log lines from the catalog), `SyncAgent` (background comparison, server events, backoff, offline proxies), `ProxyCache` and `RemoteSequence` (server sequences opened with proxies), `ISyncRemote` (the server calls; `ChronosSyncRemote` over `ChronosClient`) |
### 2.3 Chronos.App areas
@@ -68,13 +69,13 @@ Dependencies point one way: `Core` ← `Core.Windows`, `Data`, `Protocol` ← `S
|---|---|
| `Shell` | `MainWindow` (rail and its shortcuts, taskbar progress), `ShellViewModel` (rail, sections, first run), `OsNotifications` (toasts as Windows notifications while the window is minimised or in the background), dialogs, `ErrorText` (the sentence of an error toast), `ScreenCapture` (`--capture` scenes), `SectionTemplates.xaml` (view model → view) |
| `Sections` | One `XxxView.xaml` + `XxxViewModel` per screen: Welcome, Library, Sequence (the Edit section: the editor, and `SequencePickerView` choosing the sequence in place), Import, Archive, Jobs (two tabs, Queue and Scheduled: `SchedulesView` shows `Jobs/SchedulesViewModel`), Server, Settings (its last page is About) |
| `Library` | Filter, facets, pager, timeline, saved views, quick and mass actions, remote cards and thumbnails, thumbnail cache, list export |
| `Library` | Filter, facets, pager, timeline, saved views, quick and mass actions (`MassActions`: Reorganize and Convert for the sequences of one archive), remote cards and thumbnails, thumbnail cache, list export |
| `Editor` | `EditorSession` (project, undo/redo, saving, merges), `ISequenceSource` (`LocalSequenceSource`, `RemoteSequenceSource`), the steps of the Edit path (`EditPath`: their order, each step's state, the step of each finding, the memory of the step shown; tabs Analysis, Frames, Exposure, Motion, Camera, Time, Stack, Export), `PreviewRenderer`, `ExportPlanner`, `ExportSync`, `SavedCopies`, `SequenceJobs`, `ProjectFiles` (save and open `.chronos` project files) |
| `Import` | `CardPool` (inserted cards, remembered cards, folders), camera profiles, plans and choices, destinations (archive, folder, server through `ServerImportSink`), card actions (verified delete, format, eject) |
| `Archive` | `CurrentArchive`, `ArchiveTree`, figures for the charts, maintenance reports, Reorganize (`ReorganizeDialogViewModel`: folder, file and title templates each with its switch, the dry run, Apply queues the `move` job of that plan; `ReorganizePlans`: each template's check, the plan as rows and a summary; `ReorganizeOffer`: per archive, the templates Settings › Archive's toast offers, joined while that archive's toast is up), retag, delete and trash dialogs (`SequenceDeletion`, `DeletePlans`, `TrashEmptyPlans`: Empty… behind a dry run and a typed confirmation), `ArchiveFailures` |
| `Archive` | `CurrentArchive`, `ArchiveTree`, figures for the charts, maintenance reports, Reorganize (`ReorganizeDialogViewModel`: folder, file and title templates each with its switch, the dry run, Apply queues the `move` job of that plan; `ReorganizePlans`: each template's check, the plan as rows and a summary; `ReorganizeOffer`: per archive, the templates Settings › Archive's toast offers, joined while that archive's toast is up), Convert (`ConvertDialogViewModel`: format, JPEG quality and a mode chosen at every run, the dry run made once per format and quality, Apply behind the mode's confirmation queues the `convert` job of that plan through `MassConverter.QueueAsync`; `ConvertPlans`: the plan as rows in the mode's words, a summary, the space line, the Replace confirmation that types the number of photos and the New sequence one that counts the photos not copied; `ConvertUndo`: the Undo the Jobs screen's toast offers when Replace conversions end, which restores the `Replaced` trash entries their jobs made, by the job's id), retag, delete and trash dialogs (`SequenceDeletion`, `DeletePlans`, `TrashEmptyPlans`: Empty… behind a dry run and a typed confirmation, every entry whose conversion was deleted named first), `ArchiveFailures` |
| `Server` | `ServerSession`, `ConnectFlow` (trust on first use), `SyncHost` (sync engine, agent, metered hold, editor connections, Export Sync), sync table, `RemoteSequenceApi` |
| `Jobs`, `Settings`, `About` | Job list and buffering, `JobNotices` (which job endings raise a toast; `JobEndings` lets a batch speak once); the schedules of Jobs › Scheduled (`DesktopScheduleHost`: the desktop's `IScheduleHost` and its system schedules `archive-scan`, `index-backup`, `housekeeping`; `CacheTrimStep`, the host's clean-up step; `SchedulesViewModel`, `ScheduleRowViewModel`, `ScheduleEditorViewModel` and `ScheduleDialogs.xaml`, the in-window editor; `ScheduleText`); settings rows (`LogSettingsRows`: Advanced's log rows), encoder and format inventories, `ProcessingTuning` (Settings › Rendering and Analysis applied to each job: parallelism, memory budget, quality), `InterfacePriority`, language catalog, naming preview; `AboutViewModel` (owned by the shell, not a section: Settings › About, the update notice of Settings › Updates and the update check on start), update check and download |
| `Infrastructure` | `AppServices` (composition root; `SequenceReorganized`, raised after each Reorganize step, reloads an editor open on that sequence), `AppSettings`, `AppLogging` (Settings › Advanced › Logs applied to the log files from their first line, a launch that only hands over included, and at every save), `AppEnvironment` (installed or portable), `AppClock` (today's date, frozen by `--capture`), `StartWithWindows` (this copy's sign-in entry), `UiLanguage`, `LiveRegion`, `RenderNodeHost`, `DiagnosticsBundle`, `ShellActions` (BRIEF §8.6), `SingleInstance` (one Chronos per data folder; a later launch hands its file over a named pipe, or waits for a closing one to exit and starts in its place), device monitor |
| `Jobs`, `Settings`, `About` | Job list and buffering, `JobNotices` (which job endings raise a toast, conversions among them; `JobEndings` lets a batch speak once); the schedules of Jobs › Scheduled (`DesktopScheduleHost`: the desktop's `IScheduleHost` and its system schedules `archive-scan`, `index-backup`, `housekeeping`; `CacheTrimStep`, the host's clean-up step; `SchedulesViewModel`, `ScheduleRowViewModel`, `ScheduleEditorViewModel` and `ScheduleDialogs.xaml`, the in-window editor; `ScheduleText`); settings rows (`LogSettingsRows`: Advanced's log rows), encoder and format inventories, `ProcessingTuning` (Settings › Rendering and Analysis applied to each job: parallelism, memory budget, quality), `InterfacePriority`, language catalog, naming preview; `AboutViewModel` (owned by the shell, not a section: Settings › About, the update notice of Settings › Updates and the update check on start), update check and download |
| `Infrastructure` | `AppServices` (composition root; `SequenceReorganized`, raised after each Reorganize step and each sequence a conversion replaced or made, reloads an editor open on that sequence; the archive engine's free space from `VolumeInfo.FreeBytesAt`), `AppSettings`, `AppLogging` (Settings › Advanced › Logs applied to the log files from their first line, a launch that only hands over included, and at every save), `AppEnvironment` (installed or portable), `AppClock` (today's date, frozen by `--capture`), `StartWithWindows` (this copy's sign-in entry), `UiLanguage`, `LiveRegion`, `RenderNodeHost`, `DiagnosticsBundle`, `ShellActions` (BRIEF §8.6), `SingleInstance` (one Chronos per data folder; a later launch hands its file over a named pipe, or waits for a closing one to exit and starts in its place), device monitor |
| `DesignTime` | `SampleData`: the archive, jobs and server the screenshots and smoke tests run on, dated from the fixed `SampleData.Now` |
### 2.4 Chronos.Ui and Chronos.Server
@@ -85,17 +86,17 @@ Dependencies point one way: `Core` ← `Core.Windows`, `Data`, `Protocol` ← `S
| `Ui/Controls` | `ChronosWindow` (chrome, language direction), `NavRail`, `JobBar`, `ToastHost` (`Toast.Closed` once a toast leaves the screen), `Field` (placeholder, icon, error), `Chip`, `AutoSlider`, `StatusGlyph`, `EmptyState`, `Icon`, `Bidi` (right-to-left rules), `Motion` (animations off for screenshots) |
| `Ui/Interop` | DWM calls of the window chrome; `TrayIcon` (`Shell_NotifyIconW`: the Uploader's tray, the client's Windows notifications) |
| `Ui/Visuals` | `DrawingElement` (hover readout, item keyboard and activation) and its charts (`BarChart`, `SeriesChart`, `StackedBar`, `HeatmapStrip`, `TimelineBands`), `Filmstrip`, `PreviewViewport`, `CurveEditor`, `SequenceCard`, `VirtualizingWrapPanel`, `SegmentedControl`, `SplitButton` |
| `Server/Api`, `Server/Events` | Endpoint groups (`XxxEndpoints.Map`; `ScheduleEndpoints`: `/api/v1/schedules`; `LibraryEndpoints`: the Library filters' facets, sequence thumbnail, photo delete, bulk delete/retag/jobs; `TrashEndpoints`: list, restore, empty; `ArchiveEndpoints`: settings, statistics, scan jobs, Reorganize's dry run and `move` job, with `ReorganizePlanCache`: a dry run's plan, made apart from its request, kept a few minutes while what it reads from the index stays, for the same dry run and its confirmation), API errors, the WebSocket `EventHub` |
| `Server/Api`, `Server/Events` | Endpoint groups (`XxxEndpoints.Map`; `ScheduleEndpoints`: `/api/v1/schedules`; `LibraryEndpoints`: the Library filters' facets, sequence thumbnail, photo delete, bulk delete/retag/jobs; `TrashEndpoints`: list, restore, empty (`conversionDeleted` in its dry run); `ArchiveEndpoints`: settings, statistics, scan jobs, Reorganize's dry run and `move` job, Convert's dry run and `convert` job, both through `PlanCache`: a dry run's plan, made apart from its request, a few at once across both kinds, kept a few minutes while what it reads from the index stays (typed keys `PlanKey<TPlan>`: `ReorganizePlanKey`, `ConvertPlanKey` from `GetConvertStampAsync`, the selection and the target with the quality that counts, not the mode), for the same dry run and its confirmation; a conversion's confirmation takes only a kept plan (`Kept`), its busy sequences and free space taken again), API errors, the WebSocket `EventHub` |
| `Server/Security` | Accounts, password hashing, tokens, session cookies, login guard, access rules, audit log |
| `Server/Storage`, `Server/Jobs` | Archive and processing modules (the archive module's `SequenceChanged` publishes `sequenceChanged` `reorganized`), uploads (`UploadMaintenance`: recovery at start, and the sweep that is the `uploads` clean-up step; `UploadService.ReceiveAgainAsync`: a verified upload whose filing was refused for now goes back to receiving, 503), render store (files a render under the sequence's lease, where the index has the folder then; `FolderMovedException`, 503 `folder_moved`, when the sequence is not in it); `JobEngineHost`, `SchedulerHost` (the `Scheduler` on the engine, started after it; archive.json read every 10 minutes whatever the scan schedule does; every schedule change and run published as a `scheduleChanged` event) and `ServerScheduleHost` (time zone, archive refreshed from archive.json, system schedules), render node service, monitor and availability |
| `Server/Hosting`, `Server/Admin/web` | `ServerHost`, `ServerLogging` (console and file levels the logging filters read at every line, the file sink's limits, the engine's level; applied again when Settings › Logs is saved), certificates, discovery beacon, embedded static files (`EmbeddedStaticFiles`: `no-cache` and a content ETag, so an upgrade never mixes old and new modules), Windows service (start and stop failures in the Application event log); the admin panel (ES modules, one per page; `schedules.js` is the Jobs page's Scheduled tab; the Library's views in `pages/library/`: `sequence.js` a sequence and its photo viewer, `trash.js` the archive's trash, `shared.js` cards, selection, grid keyboard and the retry of thumbnails a finished job may have built; `upload.js` the upload dialog the Library opens on demand, hashing in the module worker `hash-worker.js` with the in-house incremental SHA-256 of `sha256.js`, self-tested before its first use, and sending the capture time `capture-time.js` reads: the Exif DateTimeOriginal of a JPEG or TIFF-based file, else the file's time; `reorganize.js` the Reorganize dialog of the Library's selection and of the Archive page's save toast: template switches and fields, a live dry run of `POST /archive/reorganize` one request at a time, Apply that sends the shown plan's fingerprint back) |
| `Server/Storage`, `Server/Jobs` | Archive and processing modules (the archive module's `SequenceChanged` publishes `sequenceChanged` `reorganized`, `converted` and `created`; its `FreeSpace` is `VolumeSpace.WritableFree`, the tighter of the space path's volume and the folder's own), uploads (`UploadMaintenance`: recovery at start, and the sweep that is the `uploads` clean-up step; `UploadService.ReceiveAgainAsync`: a verified upload whose filing was refused for now goes back to receiving, 503), render store (files a render under the sequence's lease, where the index has the folder then; `FolderMovedException`, 503 `folder_moved`, when the sequence is not in it); `JobEngineHost`, `SchedulerHost` (the `Scheduler` on the engine, started after it; archive.json read every 10 minutes whatever the scan schedule does; every schedule change and run published as a `scheduleChanged` event) and `ServerScheduleHost` (time zone, archive refreshed from archive.json, system schedules), render node service, monitor and availability |
| `Server/Hosting`, `Server/Admin/web` | `ServerHost`, `ServerLogging` (console and file levels the logging filters read at every line, the file sink's limits, the engine's level; applied again when Settings › Logs is saved), certificates, discovery beacon, embedded static files (`EmbeddedStaticFiles`: `no-cache` and a content ETag, so an upgrade never mixes old and new modules), Windows service (start and stop failures in the Application event log); the admin panel (ES modules, one per page; `schedules.js` is the Jobs page's Scheduled tab; the Library's views in `pages/library/`: `sequence.js` a sequence and its photo viewer, `trash.js` the archive's trash, `shared.js` cards, selection, grid keyboard and the retry of thumbnails a finished job may have built; `upload.js` the upload dialog the Library opens on demand, hashing in the module worker `hash-worker.js` with the in-house incremental SHA-256 of `sha256.js`, self-tested before its first use, and sending the capture time `capture-time.js` reads: the Exif DateTimeOriginal of a JPEG or TIFF-based file, else the file's time; `reorganize.js` the Reorganize dialog of the Library's selection and of the Archive page's save toast: template switches and fields, a live dry run of `POST /archive/reorganize` one request at a time, Apply that sends the shown plan's fingerprint back; `convert.js` the Convert dialog of the Library's selection (`planTarget` in `library.js`, shared with Reorganize: the ids, at most 1,000, or `all`): format, JPEG quality and a mode chosen at every run (Replace or New sequence, never preselected), a debounced dry run of `POST /archive/convert` one request at a time, asked in Replace's words until a mode is chosen and again while the server is still making it (a proxy's cut-off, `plan_dropped`), per sequence photos converted, left as they are or not copied and why, blocked, size before and after, the space line; Apply that confirms Replace by a typed word and New sequence with the photos not copied, asks the dry run again and sends the shown plan's fingerprint back, never twice after no answer; `pages/library/trash.js` gives replaced entries their own Restore and lists those whose conversion was deleted first; `audit.js` reads `archive_converted` as a sentence) |
### 2.5 Hosts
| Host | Composition root | What it runs |
|---|---|---|
| Chronos (desktop) | `App/Infrastructure/AppServices` | SQLite index in `%LOCALAPPDATA%\Chronos` (or `.\data` when portable, unless the copy is in a OneDrive folder); `ArchiveService` with WIC first, then managed decoders; `ProcessingService` with Media Foundation, then managed encoders; one `JobEngine` with the handlers of both; thumbnails; `ServerSession`; `SyncHost` while signed in (sync engine and agent, upload and download handlers, metered hold, editors of server sequences); the render node while opted in and signed in; update check and download (`About/UpdateCheck`, `About/UpdateDownload`, `About/UpdateFlow`: the setup, or the portable zip for a portable copy, verified against `SHA256SUMS`, resumable, cancellable, failing after 60 s without data); diagnostics bundle; the `Scheduler` on `DesktopScheduleHost`, started once the archive was reopened (an unplugged one is looked for every minute), which then runs the archive scan once (again when an unplugged archive is back), and whose system schedules replaced the rescan timer, the daily backup loop and the job-history purge (scans follow Settings › Analysis › After a scan at every run); the restore staged in Settings › Advanced (`DatabaseBackups`) |
| Chronos Server | `Server/Hosting/ServerHost.Build` | Options from `server.json` + `CHRONOS_*`; PostgreSQL (or SQLite on Windows); `ArchiveModule` then `ProcessingModule` register job handler providers; `JobEngineHost` (renders only managed formats and MP4 jobs no render node can take, BRIEF §14.7); `RenderNodeService`/`RenderNodeMonitor`; `UploadService`; `VolumeSpace` (free space of the archive, the space path and `/data`, file system and mount from `/proc/self/mountinfo`; tests replace it); `EventHub` (WebSocket); embedded admin panel; LAN discovery beacon; Windows service host; `SchedulerHost` with the system schedules `archive-scan` (every 10 minutes, also once at start), `upload-cleanup` (every 6 hours), `index-backup` (SQLite only, 03:00), `housekeeping` (job history, 04:00) and `audit-cleanup` (04:30; Settings › Logs shows and sets its age limit, 0 while it is off; seeded and reset from `AuditRetentionDays`, 0 by default: off, the audit log kept; `CHRONOS_AUDIT_RETENTION_DAYS` fixes it before the first pass), no other timer queues work (a 10-minute timer only reads archive.json again) |
| Chronos (desktop) | `App/Infrastructure/AppServices` | SQLite index in `%LOCALAPPDATA%\Chronos` (or `.\data` when portable, unless the copy is in a OneDrive folder); `ArchiveService` with WIC first, then managed decoders (a conversion orders its own chain, the managed decoders first), its free space measured by Windows (`VolumeInfo.FreeBytesAt`, UNC shares included); `ProcessingService` with Media Foundation, then managed encoders; one `JobEngine` with the handlers of both; thumbnails; `ServerSession`; `SyncHost` while signed in (sync engine and agent, upload and download handlers, metered hold, editors of server sequences); the render node while opted in and signed in; update check and download (`About/UpdateCheck`, `About/UpdateDownload`, `About/UpdateFlow`: the setup, or the portable zip for a portable copy, verified against `SHA256SUMS`, resumable, cancellable, failing after 60 s without data); diagnostics bundle; the `Scheduler` on `DesktopScheduleHost`, started once the archive was reopened (an unplugged one is looked for every minute), which then runs the archive scan once (again when an unplugged archive is back), and whose system schedules replaced the rescan timer, the daily backup loop and the job-history purge (scans follow Settings › Analysis › After a scan at every run); the restore staged in Settings › Advanced (`DatabaseBackups`) |
| Chronos Server | `Server/Hosting/ServerHost.Build` | Options from `server.json` + `CHRONOS_*`; PostgreSQL (or SQLite on Windows); `ArchiveModule` then `ProcessingModule` register job handler providers; `JobEngineHost` (renders only managed formats and MP4 jobs no render node can take, BRIEF §14.7); `RenderNodeService`/`RenderNodeMonitor`; `UploadService`; `VolumeSpace` (free space of the archive, the space path and `/data`, file system and mount from `/proc/self/mountinfo`; `WritableFree`, what a conversion counts on; tests replace it); `EventHub` (WebSocket); embedded admin panel; LAN discovery beacon; Windows service host; `SchedulerHost` with the system schedules `archive-scan` (every 10 minutes, also once at start), `upload-cleanup` (every 6 hours), `index-backup` (SQLite only, 03:00), `housekeeping` (job history, 04:00) and `audit-cleanup` (04:30; Settings › Logs shows and sets its age limit, 0 while it is off; seeded and reset from `AuditRetentionDays`, 0 by default: off, the audit log kept; `CHRONOS_AUDIT_RETENTION_DAYS` fixes it before the first pass), no other timer queues work (a 10-minute timer only reads archive.json again) |
| Chronos Uploader | `Uploader/App.xaml.cs` | `ChronosClient`, persisted queue, watch folders; no database |
| Chronos Setup | `Setup/Program` | TPK1 payload extraction, registry, shortcuts, file types named in setup's language, silent mode, uninstaller; only what starts a program its log or payload lists is changed: Windows services of those programs stopped once the programs have closed, started again (also after a failure) or deleted through the Service Control Manager (an elevated `/SERVICES … /NAMES` step when needed), sign-in entries of those programs moved to the program an upgrade renamed or removed, shared shortcuts handed to the product that keeps the program; the Server only for all users inside Program Files; "Remove my data" limited to the programs no other installed product uses |
@@ -116,6 +117,7 @@ Dependencies point one way: `Core` ← `Core.Windows`, `Data`, `Protocol` ← `S
| `Cleanup` | `Housekeeping/CleanupJobHandler` (shared steps, plus the host's from `ArchiveServiceOptions.CleanupSteps`) | yes | yes |
| `EmptyTrash` | `Archiving/Jobs/EmptyTrashJobHandler` (erases exactly a confirmed plan's trash entries; refuses a stale fingerprint) | yes | yes |
| `Move` | `Archiving/Jobs/MoveJobHandler` (Reorganize, `MoveJobParameters`: the templates, the sequences and the confirmed fingerprint; plans again from the templates, applies the plan only while it is the one confirmed, holds it when paused, cancelled or failed, keeps it while the archive is offline, tells each sequence changed as its step completes) | yes | yes |
| `Convert` | `Archiving/Jobs/ConvertJobHandler` (mass conversion through `MassConverter`, `ConvertJobParameters`: the target, quality and mode, the sequences with their frames version and the digest of the photos confirmed, whose ids wait in `journal/convert-<job>.photos`, and the fingerprint; targets are the sequences; settles what a crash left, refuses short space, converts each sequence all or nothing, the confirmed photos alone, resumes from its journal, tells each sequence `converted` or `created` and queues the passes it needs as it completes) | yes | yes (formats and files the server cannot decode natively are skipped: convert on a PC) |
| `Adopt` | none: done synchronously (`ArchiveService` actions) | — | — |
A job engine claims only kinds it has handlers for. Light analysis is queued by the engine (`JobContext` follow-up)
@@ -161,6 +163,13 @@ folder gone or holding another sequence (`SequenceFolders.Holds`; the server's r
upload), and a deep analysis that loses it records nothing. A render whose folder another index moves while it runs is
not stopped: its output can land in a folder created again at the old place, where its row keeps finding it.
A conversion (`MassConverter`) adds no writer of its own to a sequence's folder: it stages the files it makes in the
archive's `staging/convert-<job>/`, then files them through the archive ingest (New sequence) or swaps them in through
`FrameTrash.ReplaceAsync` (Replace), each under the sequence's lease, with the folder read from the index under it and
its sidecar the sequence's (`SequenceFolders.Holds`, `SequenceWriter.ReadLocked`); the originals a Replace takes out go
into the trash, never away. Its journals in `journal/` (`convert-<job>.json`, `.staged`, `.pins`, `.photos`) tell a resume, and
another host's maintenance, what the job did.
Sync (desktop ↔ server, BRIEF §14.5) reuses the same paths: `SyncService` compares the local index with the server's
listing (settings and tags carry version counters), uploads go through the chunked protocol into the server's
`ArchiveIngest`, downloaded originals are verified and committed through the local `ArchiveIngest`, and proxies land
@@ -172,7 +181,7 @@ run as server jobs whose progress comes from the events.
| To add | Implement / register |
|---|---|
| An image format or decoder | `IImageDecoderProvider` (managed in `Core/Imaging/Decoders` or `Codecs`, WIC in `Core.Windows`: a RAW only through the Raw Image Extension, checked per file); chained by `DecoderFactory` |
| An image format or decoder | `IImageDecoderProvider` (managed in `Core/Imaging/Decoders` or `Codecs`, WIC in `Core.Windows`: a RAW only through the Raw Image Extension, checked per file; `DevelopsRawAt8Bits` when its RAWs come out at 8 bits); chained by `DecoderFactory`, and for a conversion by `FrameConverter.Decoders` |
| A video encoder | `IVideoEncoderProvider` (`Core/Video/Managed`, `Core.Windows/MediaFoundation`); list it in the host's `ProcessingOptions.Encoders` |
| A background operation | a `JobKind`, an `IJobHandler` (in `Data/Archiving/Jobs` or `Data/Processing/Jobs`) returned by the service's `CreateJobHandlers`; the job engine, Jobs screen, admin and API pick it up |
| A server feature | a static `XxxEndpoints.Map(api)` in `Server/Api` with `.Requires(Permissions…)`, called from `ServerHost.ConfigurePipeline`; DTOs in `Chronos.Protocol` with the JSON context |
+368 -41
View File
@@ -310,10 +310,12 @@ Primary entities (identical concepts in SQLite and PostgreSQL; ids are UUIDv7 st
entries of a confirmed plan, erases nothing when the trash changed since, and is never
scheduled: amended 2026-10-26, R6; move, stored as 14, a Reorganize that applies exactly a
confirmed plan of new folders, titles and file names to sequences of the archive, its target,
and holds the rest of it when paused, cancelled or failed: amended 2026-10-26, R7), target
ids, state (queued, running, paused, done, failed, cancelled), progress (done/total, fps,
eta), log tail, created by, node id, attempts, error, schedule id (the schedule that queued
it; amended 2026-10-26, R10).
and holds the rest of it when paused, cancelled or failed: amended 2026-10-26, R7; convert,
stored as 19, a conversion of exactly the photos a confirmed plan lists, its targets the
sequences, each converted all or nothing into its own frames or a new sequence: amended
2026-10-26, R7), target ids, state (queued, running, paused, done, failed, cancelled),
progress (done/total, fps, eta), log tail, created by, node id, attempts, error, schedule id
(the schedule that queued it; amended 2026-10-26, R10).
- **Schedule** (amended 2026-10-26, R10) — id, system key (set, and unique, on a host's
system schedules, §14.6), name, action (scan, verify, thumbnails, proxies, analysis,
maintenance, backup, cleanup, duplicates, orphans), target (`current`: the host's
@@ -424,8 +426,9 @@ The archive is the source of truth; the database is an index that can be rebuilt
│ ├── archive.json { id, name, schemaVersion, created, layoutTemplates, proxyPolicy }
│ ├── index-snapshot.bin optional accelerator for rebuild (all sidecars concatenated + hash); ignored if stale
│ ├── locks/ lease files for concurrent writers (server + client on same share)
│ ├── journal/ rename-<plan>.json: a mass rename or Reorganize being applied (below; amended 2026-10-26, R7)
│ └── trash/ deleted sequences and photos, kept until Empty (below; amended 2026-10-26, R6)
│ ├── journal/ rename-<plan>.json: a mass rename or Reorganize being applied; convert-<job>.json, .staged, .pins, .photos: a conversion (below; amended 2026-10-26, R7)
│ ├── staging/ copies an import is filing; convert-<job>/<sequence>/: the files a conversion made, until they take their place (below; amended 2026-10-26, R7)
│ └── trash/ deleted sequences and photos, and originals a conversion replaced, kept until Empty; .erased/: what Empty erased that a replaced entry needs (below; amended 2026-10-26, R6, R7)
├── 2026/
│ └── 2026-09-28 Canon EOS R5 - Harbour sunset/ folder = expanded FolderTemplate
│ ├── originals/ IMG_0001.CR2 … names = expanded FileTemplate
@@ -437,7 +440,7 @@ The archive is the source of truth; the database is an index that can be rebuilt
│ ├── project.json render settings (the "project")
│ ├── thumbs.pack packed thumbnails (one file per sequence, indexed; avoids 100k tiny files on SMB)
│ ├── rename-files.json the file renames of a Reorganize a crash interrupted (below; amended 2026-10-26, R7)
│ └── *.pending.json journals of an ingest, a photo deletion or a restore a crash interrupted (below)
│ └── *.pending.json journals of an ingest, a photo deletion, a frame replacement (replace.pending.json, a conversion or its undo; amended 2026-10-26, R7) or a restore a crash interrupted (below)
```
`sequence.json` (canonical, versioned, written atomically):
@@ -447,8 +450,9 @@ tags, rating, notes, status, versions, createdBy, updatedAt, removed? }`. Amende
R6: `removed: [{ sha256, replacement?, reason: Deleted | Replaced, at }]` holds the tombstones
of the photos removed from the sequence (§5 FrameRemoval), left out when there are none;
`frames[].source: { sha256, format, file, size }` names the file a converted frame was made
from, reserved for R7 (read and written, nothing acts on it yet). A build that does not know
either field keeps it and writes it back unchanged.
from: a conversion's Replace writes it, and its undo and a conversion job that resumes read it
(amended 2026-10-26, R7). A build that does not know either field keeps it and writes it back
unchanged.
Trash (amended 2026-10-26, R6). Nothing in it is erased except by *Empty* (§12.5, §14.8):
- `trash/<id>[-<time>[-n]]/` with `<name>.json` beside it: a deleted sequence folder, whole
@@ -458,10 +462,17 @@ Trash (amended 2026-10-26, R6). Nothing in it is erased except by *Empty* (§12.
from sequence `<id>`, each original with its XMP companion when no photo that stays shares
it, and the record: each photo's frame record, each file's former place, size and SHA-256,
the sequence's title and folder, who deleted them, when, and the kind (photos, or replaced
for originals a conversion replaced, R7). A photo never hashed is hashed as it goes; one
whose original was already missing goes with its record alone.
for originals a conversion replaced, R7: such an entry also keeps each photo's replacement
SHA-256, a copy of the sequence's `analysis.json` and the job that made it). A photo never
hashed is hashed as it goes; one whose original was already missing goes with its record
alone.
- `trash/.erasing/`: entries moved aside by Empty before they are deleted, so a listing never
sees half an entry; leftovers are deleted by the next Empty.
- `trash/.erased/<sequence id>.json` (amended 2026-10-26, R7): the record that Empty erased a
deleted sequence (its id, title, entry, when and by whom), written before the folder goes
while a replaced entry of that sequence stays in the trash, and never while the sequence also
lives (this index has it, or a folder's sidecar names it). Each Empty deletes the records no
listed replaced entry needs. The trash never lists them.
- In a sequence's `.chronos/`, `remove.pending.json` is written before a photo deletion's
first move and `restore.pending.json` before a restore's; until the sidecar is written the
entry's record is `<name>.json.pending`, which the trash never lists, restores or empties.
@@ -471,6 +482,22 @@ Trash (amended 2026-10-26, R6). Nothing in it is erased except by *Empty* (§12.
the entry, or the record without the photos the sidecar lists again). A restore into a new
sequence stages each original in `<entry>/.restoring/` (never the archive's staging) and
puts it back on any failure.
- A replaced entry (amended 2026-10-26, R7) goes back by a swap: while every converted frame
still holds its conversion (re-hashed) and names the original as its `source`, the originals
take their frames' place again as a Replace does (below), the converted files going into a
replaced entry in turn and the entry's `analysis.json` back into the sequence; otherwise the
originals come back as a new sequence. *Empty* erases it only while each conversion of its
originals still hashes to its SHA-256 where the archive shows it now; of a conversion deleted
since, every copy the trash still holds must hash to it, and with none left nothing keeps the
entry. The archive is asked, never this host's index alone: the sequence's sidecar where the
index or the entry says it is, in the trash, or found by walking the archive's folders (once
per dry run or Empty, again only for a sequence no longer where the walk found it), followed
through its replaced tombstones. A conversion counts as deleted only on the archive's own
word: a deleted tombstone ending its chain in the sequence's sidecar, the sequence in the
trash, or the trash's record of erasing the sequence (`.erased/`), which outweighs a stale
row of this index but not a live sidecar. Anything else keeps the entry: a sidecar that holds
none of the conversion and no tombstone of it (one rebuilt by adoption), a sequence found
nowhere with no erasure record (the walk may have skipped its folder), a frame never hashed.
Deleting photos writes the sidecar without them (frames version + 1) and with a tombstone of
each SHA-256 no photo that stays holds, and clears what covered the frames (light and deep
@@ -516,7 +543,60 @@ step being one sequence and the sequences nested in a folder that moves with it:
- Proxies (named by frame index), thumbnails (by index and content hash), tombstones and trash
records need nothing; a photo restored from the trash comes back under the name it had.
Rules: originals are immutable (never rewritten; edits are settings); every write of a
Conversion (amended 2026-10-26, R7; §8.7, §12.5, §14.8) writes over no original: Replace
moves each original into the trash, New sequence leaves it where it is.
- The photos a confirmation lists are written whole, before its job is queued, into
`journal/convert-<job>.photos` (one line per sequence, each frame id in plan order); the job
record keeps each sequence's digest alone, so it grows with the sequences, not the photos.
Without that file the job holds each sequence to its whole plan made again (the same digest).
- A `convert` job takes one sequence at a time. Under the sequence's lease, its sidecar settled
where the index has it then, it plans the sequence again and goes on only while the photos the
confirmed plan listed are there with the content confirmed; it pins them in
`journal/convert-<job>.pins` and from then on, a retry included, converts those alone, so
photos received or verified since stay as they are. A sequence another index moved away (its
folder gone, or holding another sequence) is left for the retry after this index's scan.
- Stage A, without the lease: each original is re-hashed against its record, converted and
verified (§8.7) into `staging/convert-<job>/<sequence>/`, several at once, and each staged file
is appended to `journal/convert-<job>.staged`; `journal/convert-<job>.json` records what each
sequence came to and whether the passes it needs were queued. Before each photo the free space
must hold it and every photo started whose converted file has not landed yet (a file lands
whole, by a rename, before it is verified). A resumed or retried job keeps the staged files
whose SHA-256 still verifies, settles a replacement a crash left half-way, and takes a
sequence it had replaced already as converted.
- Stage B, under the lease and while every photo pinned still holds its content, all or
nothing: Replace swaps the files of the frames (next point); New sequence files the converted
copies into a new sequence through the archive ingest (§12.5), and the journal names that copy
as soon as its photos are filed. A retry or resume finishes the copy it named (or finds by its
session key) once that copy holds every pinned photo, whatever changed in the source since; it
never remakes a copy deleted since (the sequence is then changed: plan again). A source that
another conversion copied in the same format after this one was confirmed gets no copy
(outcome superseded, in the job's log) once that conversion is done; while it is not, the
sequence is left for the retry.
- A Replace, and the undo of one, writes `replace.pending.json` in the sequence's `.chronos/`
first. Each swapped frame's original and its XMP companions go into one trash entry of kind
replaced; each converted file comes in under the name filing gives a photo of the sequence
(§7.1, with the target's extension), never onto a file there, those leaving included (`_2`…).
The frames keep their ids and indices; each record takes the converted file's size, SHA-256,
format, upright size and full-resolution tier, orientation 1, no preview, the flags of that
file and those the user set, and a `source` naming the original. The sidecar (its frames
version one higher, analyses, thumbnails and proxies cleared) gains a replaced tombstone per
original naming its replacement, and content that comes back loses its tombstone; then the
index follows, the proxies of the swapped frames are deleted and the passes the frames need
are queued. The journal records its phase (moving, written, undoing) and each frame's new
name: the next writer of the sequence completes a replacement whose sidecar lists a new name
and undoes any other, and an undo that fails stops that writer, as a deletion's recovery
does. Every writer that changes the frames (an ingest, a deletion, a restore, a Reorganize
step, a sequence deletion) settles it first, or waits while it cannot be settled yet (the
trash entry an undo takes its files from is busy); a scan settles it too, and reconciles
nothing in the folder while it stays.
- The job's journals and staging go once every sequence is final. Maintenance keeps a job's
staging while the job is queued, running or paused, removes it at once when the job is done
and otherwise once its files are a day idle, and removes the journal when the job is done. A
job this index does not know (another host's on a shared archive) keeps both while any of
their files was written within 90 days, then both go.
Rules: originals are immutable (never rewritten; edits are settings; a conversion takes an
original out of its sequence only into the trash, amended 2026-10-26, R7); every write of a
sidecar goes to a temp file, `fsync`, rename; the folder name is derived from templates at
import time and never auto-renamed afterwards: only Reorganize, an explicit user action
behind a dry run, moves and renames what is filed, updating sidecars and DB together
@@ -569,7 +649,7 @@ One naming rule for import, upload and Reorganize (amended 2026-10-26, R7):
|---|---|---|---|---|
| JPEG | jpg jpeg jpe jfif | APP1 Exif/XMP, MPF | WIC or managed | managed (baseline + progressive) |
| PNG | png | eXIf, iTXt XMP | WIC or managed | managed |
| TIFF | tif tiff | IFDs | WIC or managed | managed (strips/tiles; none/PackBits/LZW/Deflate/JPEG) |
| TIFF | tif tiff | IFDs | WIC or managed (never WIC for a compression it does not decode, a floating-point predictor or 32-bit integer samples, which it reads as black or noise; amended 2026-10-26, R7) | managed (strips/tiles; none/PackBits/LZW/Deflate/JPEG; gray, RGB and linear RAW samples only: a CMYK, CIELab or palette TIFF is unavailable, never read as gray; amended 2026-10-26, R7) |
| DNG (smartphones: Apple ProRAW, Android, Samsung; DJI; Insta360; Leica; Pentax; Ricoh; GoPro files converted by Adobe software) | dng | IFDs, MakerNote | managed full decode (amended 2026-10-16, R4) | managed full decode |
| Canon | cr2 cr3 | cr2: TIFF; cr3: ISO-BMFF `CMT1..4` | WIC (Raw ext.) → managed CR2 (P1) → embedded preview | managed CR2 (P1) → embedded full-size JPEG (CR3 track 1) |
| Nikon | nef nrw | TIFF | WIC → managed NEF (P1) → preview | managed NEF (P1) → preview |
@@ -617,11 +697,19 @@ dims, delta), `WhiteLevel`, `AsShotNeutral`/`AsShotWhiteXY`, `ColorMatrix1/2` +
- `JpegDecoder` (baseline, progressive, restart intervals, 4:4:4/4:2:2/4:2:0/4:1:1/gray,
12-bit optional, ICC ignored), `JpegEncoder` (baseline, quality 1–100, subsampling
choice, optimised Huffman tables optional, Exif/XMP APP1 embedding).
choice, optimised Huffman tables optional, Exif/XMP APP1 embedding, an ICC profile in APP2
chunks: amended 2026-10-26, R7).
- `PngDecoder`/`PngEncoder` (all colour types, 8/16-bit, Adam7 decode, filters, zlib via
`System.IO.Compression.ZLibStream`).
- `TiffReader`/`TiffWriter` (as prototype: 16-bit TIFF, linear DNG writer with
`PhotometricInterpretation=34892`).
- `TiffReader`/`TiffWriter` (as prototype: 16-bit TIFF, an ICC profile in tag 34675, linear DNG
writer with `PhotometricInterpretation=34892`, scene-referred for a conversion, §8.7: amended
2026-10-26, R7).
- `IccProfile` (amended 2026-10-26, R7): ICC profiles read and written (matrix/TRC and gray,
`curv`/`para` curves, `desc`/`mluc` text), an in-house Adobe RGB (1998)-compatible and a
Display P3 profile, the profiles a conversion makes for the values it writes (a profile's
colorants with the sRGB curve, a gray curve as RGB), and what a photo's headers say of its
colour space (JPEG APP2, PNG iCCP/sRGB, TIFF tag 34675, HEIF/AVIF `colr`, WebP ICCP, Exif
ColorSpace and Interop).
- `GifEncoder` (animated; median-cut palette + Floyd–Steinberg; frame differencing).
- `ApngEncoder`.
- `AviMjpegWriter` (RIFF AVI with `MJPG`, OpenDML index for > 2 GB).
@@ -650,6 +738,70 @@ size and budget, never by sequence length; the self-tests assert this.
`SHFormatDrive` (format card), `ShellExecute("open", url)` (links, Store pages),
`ShellExecute("explore", folder)` (reveal in Explorer). Nothing else.
### 8.7 Conversion (amended 2026-10-26, R7; §7, §12.5)
A conversion makes each photo a JPEG (baseline, 4:4:4, optimised Huffman tables, 8-bit,
quality 1–100, default 95), a 16-bit TIFF (RGB, Deflate with the predictor) or a linear DNG
(16-bit LinearRaw, lossless JPEG tiles), the archival choice.
- Decoding: at full resolution only, never from an embedded preview, upright. The managed
decoders come first for every format they read natively (a RAW developed in-house at float
precision, the same on every host), WIC only for what they do not read. A 16-bit target never
takes a RAW through a decoder that develops it at 8 bits (WIC's Raw Image Extension): such a
RAW converts to JPEG only. The server decodes with the managed decoders alone, so it converts
no CR3, HEIC or RAW body its developer does not support, nor a CMYK, CIELab or palette TIFF,
an unsupported compression or a file past their size limits: its dry run says to convert those
photos on a PC, which reads them through WIC. A photo another host flagged unreadable is asked
again where the conversion has other decoders (WIC on a PC) and planned when they decode it at
full resolution; a corrupt one stays out everywhere. WIC is never used for a TIFF whose
compression is not 1–5, 7, 8, 32773 or 32946, whose predictor is other than none or the
horizontal one on integer samples, or whose integer samples exceed 16 bits (WIC gives black or
noise for them without an error), in conversions and in every other desktop decode: the
managed reader takes it, or it is unavailable. A conversion's WIC probe reads the file's headers (the decoder, the
first frame's upright size, the pixel format), so the size bounds apply to what only WIC
reads; a file it cannot open is missing or held, never unreadable.
- A linear DNG keeps what a RAW develops: the values are stored in linear ProPhoto primaries
(colours outside sRGB stay positive), divided by the power of two, at most 2^4, that brings
their peak under white, which BaselineExposure gives back; ColorMatrix1 and ForwardMatrix1
describe that space (illuminant D65, AsShotNeutral 1/1/1). The as-shot white balance is baked
in and values below black are clipped. An export's DNG stays clipped linear sRGB (§11.3).
- Colour: what Chronos reads from a photo never changes. Its decoders read no profile: they take
code values through the sRGB curve and a float TIFF's values as they are. A converted file
holds the values they read from the original, as they read them back, within what the target
holds (a JPEG or TIFF-16 holds 0..1 and clips beyond; a DNG up to 4 stops above white), and
says truthfully what those values are:
- A JPEG or TIFF-16 keeps the codes of an RGB profile's code values and carries that profile.
Float values are written as sRGB codes with a profile made for them: the original's
colorants and media white with the sRGB curve ("<description> (sRGB curve)"). A lookup-table
profile named sRGB is carried; other float values in a lookup-table profile are refused. A
gray profile's codes are kept, its curve carried as an RGB profile with sRGB's colorants
("<description> (RGB)"); linear gray needs no profile.
- A linear DNG, whose matrices Chronos develops it with too, takes only values that are sRGB's
as read: no profile, an sRGB profile, float values in sRGB's primaries whatever the curve,
linear gray, gray codes on the sRGB curve. Any other profile (Adobe RGB, Display P3,
ProPhoto, a gamma-1.0 profile's code values) is refused as `color_profile`; TIFF-16 and JPEG
convert those photos with their profile.
- A matrix/TRC profile is sRGB by its numbers (its matrix within 2e-3 of sRGB's, its curves
within 2e-3 of the sRGB curve), by its name only when it has no colorant tags at all; one
whose colorants convert nothing, or that has no curves, is never sRGB.
- Exif Adobe RGB (uncalibrated with Interop R03) and a HEIF nclx box with P3 primaries get the
in-house profiles. Refused for every target: CMYK, Lab and other non-RGB profiles, Exif
uncalibrated without R03, other nclx primaries or an HDR transfer, a profile that does not
parse. A photo that records no colour space is sRGB.
- Damaged values: a photo whose decoded pixels hold NaN or infinite values fails as damaged
data, and nothing is written.
- Metadata: capture time (to the tick), offset, exposure, f-number, ISO, focal length, bias and
white balance from the sidecar; camera, serial, lens, 35 mm focal length, exposure program,
metering mode, flash, GPS, artist and copyright from the original, the sequence's camera and
lens where it names none. MakerNote and XMP are not carried; the orientation is 1.
- Size: a photo is not converted when the target cannot hold it (a JPEG side above 65535) or
the server's decoders could not read it back (a JPEG above 2^28 pixels; a TIFF-16 or DNG
above 2^29 samples, about 179 MP). Sizes are weighed without overflow, so a damaged header's
absurd size is too large, never a wrapped number.
- Each converted file is hashed as it is made and written atomically, then read back (the same
size and SHA-256), its metadata read again (format, capture time and offset) and decoded by
the server's decoders at full resolution and size; a file that fails any of these is deleted
and its photo fails.
---
## 9. Metadata model and parsers (`Chronos.Core/Metadata`)
@@ -669,7 +821,9 @@ WhiteBalance mode + Kelvin if present, Flash, Orientation, dimensions, Make/Mode
Lens, GPS (lat/lon/alt), Artist/Copyright, Rating/Label from XMP, `Software`. All parsers
are fuzz-safe (no exception escapes; malformed input yields partial metadata + a warning).
`ExifWriter` (prototype) is kept for proxies/exports: writes a minimal, valid Exif block.
`ExifWriter` (prototype) is kept for proxies, exports and converted photos: writes a minimal,
valid Exif block, with the exposure program, metering mode, flash and white balance when known
(amended 2026-10-26, R7).
---
@@ -864,9 +1018,10 @@ player smoke test on Windows CI.
status chips: `✓` analysed, `▣` proxies, `▶n` renders, `☁` synced/origin, `!` warnings.
Hover reveals quick actions: Open, Analyse, Render preset, Sync.
- Multi-select → mass actions bar (Analyse, Build proxies, Verify, Tag, Rate,
Reorganize…, Upload, Download, Delete, Export list as CSV). Reorganize… (amended
2026-10-26, R7; formerly Move) takes the selected sequences of one archive, never a
server-only one, into the dialog of §12.5.
Reorganize…, Convert…, Upload, Download, Delete, Export list as CSV). Reorganize… (amended
2026-10-26, R7; formerly Move) and Convert… (amended 2026-10-26, R7) take the selected
sequences of one archive, never a server-only one, into their dialogs of §12.5; a selection
of two archives is refused with the reason.
- Filters are chips; saved views (e.g. "Night, 4K, not rendered"); search is instant
(indexed columns); everything virtualized (in-house `VirtualizingWrapPanel`).
- Photos deleted from a sequence (amended 2026-10-26, R6; on the admin panel, §14.8, or by
@@ -938,7 +1093,7 @@ player smoke test on Windows CI.
│ ● SD 128 GB EOS R5 card A ▲ │ Destination (•) Archive ( ) Folder [D:\Shoots …] ( ) Server ☁ "Studio NAS" │
│ ● microSD 64 GB GoPro 12 │ Scan [✓] Subfolders Sessions [✓] gap [45] min · min [8] frames [✓] Verify hashes │
│ ○ E:\ no DCIM │ Names {year}/{date} {camera} / {date}_{time}_{n:0000} → 2026/2026-09-28 Canon EOS R5/2026-09-28_18-02-11_0001.CR2 │
│ ○ Folder… │ On existing (•) Skip ( ) Rename ( ) Overwrite Convert (•) Copy ( ) TIFF-16 ( ) Linear DNG ( ) JPEG │
│ ○ Folder… │ On existing (•) Skip ( ) Rename ( ) Overwrite │
│ │ After import (•) Keep card ( ) Delete imported ( ) Format card [✓] Eject [✓] Deep analysis │
│ [✓] Import automatically when │ Plan 3 sessions · 4,812 photos · 96.2 GB · 12 min [Show plan] [ Import ▶ ] │
│ a known card is inserted │ │
@@ -963,6 +1118,11 @@ player smoke test on Windows CI.
panel have no Group choice.
- Copy with hash while streaming; verify by re-reading destination; only then delete or
format (OS dialog); eject via `IOCTL_STORAGE_EJECT_MEDIA` after `FSCTL_LOCK_VOLUME`.
- Import copies every photo byte for byte and converts nothing (amended 2026-10-26, R7; the
sketch's former *Convert* row is gone): deleting imported photos and formatting the card
need archived copies that re-hash to the card's files, which a converted file never does,
and originals are immutable. Converting is a separate, explicit step after import, behind a
dry run (*Convert…*, §12.5, §14.8); a photo converted since keeps its card copy (§13).
- Destination "Server" streams frames through the client to the server (§14.4); the
server confirms each hash before the client counts it as imported.
- Auto-import on insertion (per card), with the OS toast "Card X detected — Import".
@@ -977,7 +1137,7 @@ player smoke test on Windows CI.
│ Index health: ✓ sidecars 412/412 · ⚠ 3 sequences without proxies · ⚠ 1 unverified since 90 days │
│ Recent maintenance: 2026-09-20 verify ✓ · 2026-09-01 vacuum ✓ │
├──────────────────────────────────────────────────────────────────────────────────────────────────────┤
│ Mass operations on filtered set (412): [Analyse] [Proxies] [Thumbnails] [Verify] [Reorganize…] [Retag] [Export CSV] [Delete] │
│ Mass operations on filtered set (412): [Analyse] [Proxies] [Thumbnails] [Verify] [Reorganize…] [Convert…] [Retag] [Export CSV] [Delete] │
```
Operations: **Scan** (incremental, mtime/size), **Rebuild index** (from sidecars; falls
@@ -1008,6 +1168,19 @@ those entries and nothing when the trash changed since; an entry that changes wh
is kept, and the job then fails after erasing the others. It is the only way the product
erases trash entries; no schedule runs it (§14.6).
Originals a conversion replaced (amended 2026-10-26, R7; §7) are listed as *Replaced
originals*. *Restore* swaps them back into their sequence while its converted frames are
unchanged, the conversions going to the trash in turn, and otherwise brings them back as a
new sequence. *Empty…*'s list names first, wherever the trash lists them, the entries whose
conversion the archive itself shows deleted since (§7; *conversion deleted*: they may hold the
last copy of their photos), the others filling its six lines and the rest counted. The job
keeps, each logged with why and what settles it, an entry changed since the plan, one whose
sequence is busy, one whose conversion no longer matches, one with a photo never verified
(verify the sequence), one where a sidecar that may hold the sequence is missing or
unreadable (scan the archive), one whose sequence the index lists but the archive no longer
holds (rebuild the index), and one whose conversion's fate the archive does not show (restore
it to keep its photos; a frame missing or corrupt, which no verify hashes, counts here).
*Reorganize…* (amended 2026-10-26, R7; it replaces Rename… and Move…) applies new templates
to sequences already filed: the set (online), the Library's selection (§12.2), or every
sequence of the archive from the toast of Settings › Archive (§12.8). The admin panel offers
@@ -1052,6 +1225,59 @@ the same (§14.8), through the same engine and job.
Archive and Library screens read the archive again when it ends; an editor open on a
sequence it changed reloads where the sequence is now after that sequence's step.
*Convert…* (amended 2026-10-26, R7; §7, §8.7) converts the photos of sequences already filed
to JPEG, 16-bit TIFF or linear DNG: the set (online), or the Library's selection (§12.2). The
admin panel offers the same (§14.8), through the same engine and job.
- An in-window dialog: Format (JPEG, TIFF 16-bit, Linear DNG; Linear DNG, the archival choice,
chosen first), Quality (JPEG only, 1–100, 95) and Mode, *Replace* (the converted files take
the photos' place in their sequences; the originals go to the archive's trash, restorable
until it is emptied) or *New sequence* (converted copies in a new sequence beside each source;
the originals stay as they are). The mode is chosen at every run: it starts unchosen at every
open and is never remembered. Each choice's tooltip says what becomes of the originals.
- The dry run (nothing touched) follows the choices (400 ms after typing the quality; Enter at
once) and lists each sequence that converts, skips photos or stays whole: its photos and size
before → after (an estimate), the photos that stay as they are and why (already in that
format; a format this computer cannot read at full resolution; read only from an embedded
preview; a RAW developed here at 8 bits only, for a 16-bit format; a colour profile the format
cannot keep, for a linear DNG any but sRGB (§8.7); larger than the format holds or Chronos
reads back; unreadable; missing; never verified; held open by another program or not
openable), or why the whole sequence stays (a job works on it, or a conversion of it waits;
the archive offline or read-only; its sequence file unreadable). With New sequence, the photos
a copied sequence skips are *not copied* into its new one. A summary ("12 of 36 change · 3,600
photos · 41 GB → 32 GB · 20 skipped") and the space line follow ("Needs 12 GB, free 340 GB":
the estimate with a 15 % margin and a 512 MiB reserve, against the free space where the
conversion writes); a volume without the space blocks Apply. The mode does not change what
converts, so choosing it plans nothing again.
- *Apply* (enabled for the dry run of the choices on screen when it converts something and the
space is there, once a mode is chosen, which is asked last) asks a Replace to type the number
of photos it replaces, and confirms a New sequence with how many photos the new sequences
lack; it then queues the *Convert* job of exactly that plan at user priority, and the dialog
closes. A conversion of one of its sequences already queued or running refuses it: the dry
run is made again and shows those sequences busy. Cancel is the default button.
- The job (desktop and server) converts one sequence at a time, all or nothing: the photos the
dry run listed alone, each only while it holds the content confirmed; photos received since
stay as they are. It checks the free space before it starts, before each sequence and before
each photo (counting every photo still being written), and stops before the volume fills.
Paused, resumed or retried in Jobs, it keeps what it converted. A sequence whose confirmed
photos changed is left as it is, and a retry leaves it too (plan again); one busy, moved away
by another program or with a photo held open waits for the retry; one with a photo that cannot
be converted is left as it was, what it converted kept for the retry. The job's log says each,
and the job fails at the end saying how many.
- New sequence: titled "title (JPEG|TIFF|DNG)", in a folder from the archive's template, its
photos named as filing names them, owned as its source is, with its source's tags, rating,
notes and project (the positions on photos it lacks wait as pending frames). It holds the
converted copies alone; the job log says how many photos stayed in the source alone. A retry
finishes the copy the job made and never makes a second; a source another conversion copied
in the same format since this one was confirmed gets no copy (the job log says so), and waits
for the retry while that conversion has not finished.
- When a Replace job ends, its toast offers *Undo* (once, never from the Windows notification):
the replaced entries that job made go back (swapped back, or as a new sequence for one that
changed since). Later, *Trash…* › *Restore* does the same, and the admin panel's trash view
for a conversion the server ran.
- A running or paused conversion makes its sequences busy. The Library and Archive screens read
the sequences again when it ends (a failed one converted the others); an editor open on a
converted sequence reloads.
### 12.6 Jobs
Two tabs, a *Queue | Scheduled* segmented control first in the toolbar (amended 2026-10-26,
@@ -1170,6 +1396,9 @@ update check on start (§18) runs whatever screen is open.
its sequence carries, as Reorganize names it (amended 2026-10-26, R7).
- Post-actions: keep / delete imported files (only those verified) / format card (OS
dialog) / eject; run deep analysis automatically (default on, background, low priority).
A photo whose archived frame a conversion replaced since no longer matches its card file,
so a delete keeps it on the card and a format is refused while it is there (amended
2026-10-26, R7).
- Failure handling: card removed mid-copy → partial files deleted, plan resumable on
re-insert; errors listed per file, never a modal per error.
@@ -1255,6 +1484,7 @@ POST /api/v1/nodes/register · POST /nodes/{id}/heartbeat · POST /nodes/{id}/
GET/PUT /api/v1/archive/settings · POST /archive/scan · /rebuild · /verify · GET /archive/stats · POST /archive/maintenance (admin)
POST /api/v1/archive/reorganize {sequenceIds|all, folderTemplate?, fileTemplate?, titleTemplate?, dryRun, fingerprint?} → plan | 202 move job (admin)
POST /api/v1/archive/convert {sequenceIds|all, target, quality?, mode, dryRun, fingerprint?} → plan | 202 convert job (admin)
GET /api/v1/archive/trash · POST /archive/trash/{name}/restore · POST /archive/trash/empty {names?, dryRun, fingerprint} (admin)
GET /api/v1/i18n/{culture} strings for the web admin
```
@@ -1297,14 +1527,18 @@ Library and trash (amended 2026-10-26, R6):
another's), `folder_in_use`; 422 `trash_mismatch` (no file matches its record any more, or a
deleted sequence's own sidecar no longer names it); 503 `archive_offline`. Audited
`trash_restored`; publishes `sequenceChanged` `created` (a sequence, or a new one) or
`frames`.
`frames`. A replaced entry (amended 2026-10-26, R7) answers kind `replaced`, with
`newSequence` false once its originals swapped back in place of their conversions, true when
they came back as a new sequence.
- Empty: a dry run answers the entries measured on disk, their photos, files and bytes, the
plan's `fingerprint` and the names asked for that the trash does not hold (`unknown`); the
erase sends the fingerprint back and answers 202 with the `empty-trash` job. Errors: 400
`bad_request` (`names`, `fingerprint`); 409 `trash_changed` (details: the fingerprint now),
`job_unavailable`; 503 `archive_offline` (offline, and for the erase also read-only; the
listing answers it too, offline). The request is audited `trash_empty_requested`; what the
job erased is in its log.
plan's `fingerprint` and the names asked for that the trash does not hold (`unknown`); a
replaced entry whose conversion the archive shows deleted carries `conversionDeleted: true`,
which the fingerprint covers (amended 2026-10-26, R7). The erase sends the fingerprint back
and answers 202 with the `empty-trash` job. Errors: 400 `bad_request` (`names`,
`fingerprint`); 409 `trash_changed` (details: the fingerprint now), `job_unavailable`; 503
`archive_offline` (offline, and for the erase also read-only; the listing answers it too,
offline). The request is audited `trash_empty_requested`; what the job erased, and why it
kept an entry, is in its log.
- The manifest gains `removed: [{sha256, replacement, reason: deleted|replaced, at}]` (null
when there are none; covered by its ETag, since a deletion moves the frames version).
@@ -1337,10 +1571,11 @@ Reorganize (amended 2026-10-26, R7; ManageArchive; §7, §12.5, §14.8):
photo count, frames version and how many of their photos are hashed; the title of the others
inside their folders. The same dry run again, and its confirmation, take the kept plan. A
plan is made apart from its request (one a proxy cuts off leaves it to be made, and asking
again waits for it), at most 2 at once and 8 kept or being made; one still being made 15
minutes after it was asked, let go for newer ones, or when the server stops is stopped, and
its requests answer 503 `plan_dropped`. A change made on disk alone is not in the stamp: the
confirmation then answers 202, and the job, which plans again, fails without changing anything.
again waits for it), at most 2 at once and 8 kept or being made (Convert's dry runs counted,
R7); one still being made 15 minutes after it was asked, let go for newer ones, or when the
server stops is stopped, and its requests answer 503 `plan_dropped`. A change made on disk
alone is not in the stamp: the confirmation then answers 202, and the job, which plans again,
fails without changing anything.
- `invalid_template`, here and from `PUT /archive/settings`: the details name the field and,
after a colon, the rule a template that parses breaks (`folderTemplate:reserved_folder`,
`fileTemplate:file_separator`, `fileTemplate:extension`, `fileTemplate:not_unique`), the
@@ -1358,12 +1593,53 @@ Reorganize (amended 2026-10-26, R7; ManageArchive; §7, §12.5, §14.8):
answers 503 `sequence_busy` while the sequence is held, 404 `frame` when the sequence or its
folder is gone, or the folder is another sequence's.
Convert (amended 2026-10-26, R7; ManageArchive; §7, §8.7, §12.5, §14.8):
- The request names exactly one of `sequenceIds` (1–1,000) and `all`, a `target` (`jpeg`,
`tiff16`, `linear-dng`), a `quality` (1–100, default 95; it counts for a JPEG only) and a
`mode` (`replace` or `new-sequence`). A dry run answers `{target, quality, mode, steps,
sequences, photos, skipped, bytesBefore, bytesAfter, space, fingerprint}` and changes nothing:
a step per sequence asked, in order, `{sequenceId, title, folder, framesVersion, photos,
bytesBefore, bytesAfter (an estimate), skipped: [{reason: same_format|convert_on_pc|
undecodable|missing|unhashed|eight_bit|color_profile|too_large|inaccessible, photos,
message}], blocked: [{reason: busy|offline|unreadable, message}]}`, each message in the
request's language. `convert_on_pc` is a format or file the server cannot read at full
resolution ("convert these photos on a PC"); of a sequence `new-sequence` copies, a message
says the new sequence lacks those photos. `space` is `{required, free, enough, message}`:
the estimate × 1.15 plus 512 MiB, counted in both modes, against the free space where the
conversion writes (the tighter of the space path's volume and the archive's own, §14.9).
- The change sends the dry run's fingerprint back and answers 202 with the `convert` job, whose
parameters name each sequence's digest (its photos are kept beside the job's journal, §7).
Errors: 400 `bad_request` (`sequenceIds`, `target`, `quality`, `mode`, `fingerprint`); 404
`not_found` (`sequence`); 409 `plan_changed` (details: the fingerprint now; none when a
conversion of these sequences was queued meanwhile), `nothing_to_convert`, `not_enough_space`
(details: the bytes needed), `job_unavailable`; 503 `archive_offline`, `plan_dropped`. Audited
`archive_converted` (sequences · photos · target · mode). The job publishes `sequenceChanged`
`converted` for each sequence whose frames it replaced and `created` for each new sequence, as
each one completes.
- The fingerprint is a SHA-256 of the options, the mode, and each sequence with its frames
version, its photos' count and bytes, their digest (each frame id with the SHA-256 of its
content), what it skips and what blocks it.
- The server keeps a dry run as it keeps Reorganize's, in one cache for both (2 made at once,
8 kept, 5 minutes, stopped after 15 with `plan_dropped`), keyed by the archive, the selection,
the target with the quality that counts (none for a lossless target) and a stamp of the index:
Reorganize's, and of the planned sequences' photos their count, sizes, formats, pixel sizes
and how many are flagged missing, corrupt, preview-only or undecodable. Not the mode, which is
set on the kept plan, nor the busy sequences and the free space, measured again at every
request. A plan made while the archive was offline is not kept. A confirmation takes only the
plan kept for the index as it is now and never plans inside its own request: with none kept
it answers 503 `plan_dropped` (ask the dry run again), with a kept plan that differs 409
`plan_changed`. A change made on disk alone is found by the job, which converts the photos
confirmed only while each holds the content confirmed.
Uploads (amended 2026-10-26, R3, R6): `server/info` lists `extensions`, the photo file
extensions the archive files (lower case, no dot), which the admin panel's dialog keeps to. A
frame upload whose file name starts with `.` is 400 `invalid_file_name`. A start whose
SHA-256 the target sequence tombstoned (and none of its frames holds) answers 200
`alreadyExists` without a `frameId`, unless `restore` is true; the completion checks again
unless `?restore=true` and answers 409 `photo_removed`, the upload cancelled (§14.4).
unless `?restore=true` and answers 409 `photo_removed`, the upload cancelled (§14.4). An
original a conversion replaced in the target sequence is tombstoned too; sent with `restore`,
it files nothing and its completion answers the frame that holds its conversion (amended
2026-10-26, R7).
Schedules (amended 2026-10-26, R10; ManageArchive, every change audited): `PUT` and
`PATCH` change the fields given; an invalid field is 400 `invalid_schedule` with the field
@@ -1411,6 +1687,14 @@ whose file name starts with `.` (the AppleDouble `._` files a Mac leaves on card
files) is refused for every client (400 `invalid_file_name`), as the archive scanner leaves
such files out.
Replaced photos (amended 2026-10-26, R7): a photo a conversion replaced in a sequence is in it
as its conversion. The ingest answers its original (a card or a folder imported again, a
download, an upload sent with `restore`) as a duplicate of the frame that holds the conversion,
followed through later conversions, and keeps the tombstone that makes sync count both as one
photo; once no such frame is intact, the original is filed again. A batch files nothing into a
sequence while a restore from the trash or a frame replacement of it is not settled (its trash
entry busy): an upload's completion answers 503 and the client tries again.
The admin panel uploads through the same path (amended 2026-10-26, R3; the dialog, §14.8):
- It hashes each photo in the browser with an in-house incremental SHA-256 (FIPS 180-4,
`sha256.js`) in a same-origin module worker (`hash-worker.js`, under the panel's
@@ -1456,17 +1740,29 @@ Removed photos (amended 2026-10-26, R6). A photo deleted on one side leaves a to
no upload of a photo the server deleted, no download of one this PC deleted; sync never
deletes local files either way. A tombstone leaves a photo out only while its own side holds
no matching photo (by hash, or by size and capture time while unhashed), so a duplicate that
stays or a file put back by hand still syncs. A photo replaced by a converted file (R7)
counts as its replacement on both sides, an alias followed up to 8 steps, for the
comparison, the transfers and the frame positions. Content known only once hashed is checked
then: a download skips an unhashed server frame this PC deleted (or holds as its
replacement), and an upload skips an unhashed local frame the server deleted and then runs
the archive verify, so the index gets the hashes and the next comparison leaves it out.
stays or a file put back by hand still syncs. A photo replaced by a converted file (R7) is
the same photo as its replacement on both sides, for the comparison, the transfers and the
frame positions (below). Content known only once hashed is checked then: a download skips an
unhashed server frame this PC deleted (or holds as its replacement), and an upload skips an
unhashed local frame the server deleted and then runs the archive verify, so the index gets
the hashes and the next comparison leaves it out.
Known limitations: until the server verifies such a frame, the sync table still counts it as
missing here and *Download* fetches and drops it each time; a photo never hashed whose
original was already missing when it was deleted leaves no tombstone, so a copy elsewhere
(another PC, a card) is not known to be deleted and can come back.
Converted photos (amended 2026-10-26, R7). Every replaced tombstone of either side links two
encodings of one photo, and the encodings these links join (a conversion, a conversion of it,
its undo, each side converting its own copy) compare, transfer and translate as one photo,
under the smallest of their SHA-256s; a deletion on either side covers every encoding. Linking
a local sequence to a server one by content and the proxies this PC sends follow them (a frame
this PC converted makes the proxy of the server's original). A download for a frame flagged
missing here whose photo the server holds only in another encoding puts that file in the
frame's place (the same id, nothing to the trash, a replaced tombstone linking the two), after
the transfers and only in the folder the index has for the sequence, and queues the passes the
swap cleared even when the job is stopped meanwhile; a frame that changed meanwhile keeps its
place and the copy is dropped.
Folders moved by another program (amended 2026-10-26, R7). When a desktop and a server share
an archive, a Reorganize by one index (or a folder moved by hand) is found by the other's next
scan, which moves the sequence's row, its frames and the paths of the exports that moved with
@@ -1705,6 +2001,35 @@ Reorganize (amended 2026-10-26, R7), the panel's way to the Reorganize of §12.5
audit log and the Dashboard read "… reorganized the archive · N sequences · M files renamed
· templates".
Convert (amended 2026-10-26, R7), the panel's way to the Convert of §12.5 through
`POST /archive/convert` (§14.3):
- The Library's selection bar has *Convert…*, after *Reorganize…*, for the same selection: up
to 1,000 sequences, or every sequence after *Select all* without a filter (one plan, one job).
- The dialog: Format (JPEG, TIFF-16, Linear DNG, the archival choice, chosen first), Quality
(JPEG only, 1–100, 95) and Mode (Replace or New sequence), never preselected; each choice's
tooltip says what becomes of the originals. Each change asks the server for a dry run, one at
a time (400 ms after typing the quality). Until a mode is chosen it is asked in Replace's
words; New sequence asks again, answered from the plan the server keeps. The table shows each
sequence, 200 at a time: photos converted, those left as they are with why (what blocks the
whole sequence first; *Not copied* with New sequence) and the size before → after; then the
totals and the server's space line. A dry run a proxy cut off is asked again every 2 s for up
to 16 minutes, the totals saying how long it takes.
- The dialog's *Convert…* (enabled while the table is the plan of the fields, converts
something, has the space and a mode is chosen; its tooltip says what is missing) asks a
Replace to type the word "replace" in the panel's language, and confirms a New sequence with
how many photos the new sequences lack, each sequence listed with its own count. It then
asks the dry run again (Close stays: nothing is sent yet) and sends that plan's fingerprint
only while it is the one confirmed; the toast offers *Open job*. `plan_changed`,
`plan_dropped`, `not_enough_space` and `nothing_to_convert` show the new plan and the button
waits; a request that got no answer is not sent again, as its job may be queued (the Jobs
page says).
- The trash view lists replaced originals as *Replaced*, whose *Restore* swaps the originals
back in place of their conversions while those are unchanged, else restores them into a new
sequence. *Empty…* lists first the entries whose conversion the archive shows deleted, each
saying so.
- The audit log and the Dashboard read "… queued a conversion · N sequences · M photos ·
format · mode".
Upload (amended 2026-10-26, R3): Library › *Upload* (no sequence) and a sequence's *Add
photos* open the upload dialog (§14.4), a module the pages import only on demand.
- Target: the given sequence, or a choice between an existing sequence (a search box, then a
@@ -1743,7 +2068,8 @@ at first login), `CHRONOS_ARCHIVE_PATH=/archive`, `CHRONOS_DATA_PATH=/data`,
`CHRONOS_SPACE_PATH` (`SpacePath` in `server.json`; optional: a folder, e.g. `/space`, whose
volume's free space the admin panel shows instead of the archive's; one that cannot be
measured falls back to the archive's with one warning, logged at start and again only once
it has worked in between; uploads always check the archive's own volume, §14.4),
it has worked in between; uploads always check the archive's own volume, §14.4, and a
conversion the tighter of the two, §14.3: amended 2026-10-26, R7),
`CHRONOS_DB=postgres|sqlite` (Linux: postgres only), `CHRONOS_DB_HOST`, `CHRONOS_DB_PORT=5432`,
`CHRONOS_DB_NAME`, `CHRONOS_DB_USER`, `CHRONOS_DB_PASSWORD`, `CHRONOS_DB_SSLMODE=prefer`,
`CHRONOS_HTTP_PORT=8080`, `CHRONOS_HTTPS_PORT=8443`, `CHRONOS_TLS_MODE=auto|pem|proxy`,
@@ -2209,6 +2535,7 @@ questions asked and the answers; DECISIONS rows give the reasons.
| 2026-10-26 | Owner review 2, R3 | §14.3, §14.4, §14.8 | Upload from the admin panel into an existing or a new sequence (file picker, drag and drop, no folders), hashed in the browser by a self-tested in-house SHA-256 in a module worker, the capture time read from Exif, sent in resumable chunks through the upload API and verified by the server; `server/info` lists the photo extensions; hidden dot files are refused for every client. |
| 2026-10-26 | Owner review 2, R7 (Reorganize) | §5, §7, §12.2, §12.5, §12.8, §14.3, §14.5, §14.8 | Reorganize on the desktop (Archive manager, Library, the toast of Settings › Archive) and the admin panel (Library, the toast of Archive): folder, file and title templates applied to sequences already filed, behind a dry run that lists each sequence's changes, the photos that keep their names and why (in place outside `originals/`, never hashed, missing) and the sequences that stay whole (unreadable sidecar); applied by the `move` job of exactly the confirmed plan (fingerprint), which holds the rest when paused, cancelled or failed and lets a sequence still receiving photos keep its file names; crash-safe plan and file journals (two-phase renames through hidden temporary names, recovery by the next writer); a sequence of the plan left as it was inside a moving folder goes with it; the index, frames and exports follow a moved folder in one transaction, on this index and at another index's next scan; writers take the folder under the lease, never create a left one again and never write into a folder another sequence took; `POST /api/v1/archive/reorganize` with a kept, bounded plan cache and `sequenceChanged` `reorganized`; Rename… and Move… replaced. |
| 2026-10-26 | Owner review 2, R7 (naming) | §7.1, §13, §14.3 | One naming rule for import, upload and Reorganize: the sequence's camera and lens, `{n}` its place, a frame without a time at the sequence's start; template rules everywhere a template is typed or sent (no folder level scans skip, one a value such as a title gives escaped with `_`; a file template keeps the extension, tells photos apart, holds no slash; long names shortened before `.{ext}`; titles as text), held to a template only when it is given anew; `invalid_template` names the rule. |
| 2026-10-26 | Owner review 2, R7 (conversion) | §5, §7, §8.1, §8.3, §8.7, §9, §12.2, §12.4, §12.5, §13, §14.3, §14.4, §14.5, §14.8, §14.9 | Convert after import on the desktop (the Archive manager's set, the Library's selection) and the admin panel (the Library's selection): JPEG with a quality, TIFF-16 or linear DNG (the archival choice, scene-referred so a RAW's highlights above white and colours outside sRGB survive), Replace or New sequence chosen at every run and never remembered, behind a dry run that lists each sequence's photos, sizes and the photos that stay as they are with why, and the free space where the conversion writes; Replace confirmed by typing; the `convert` job (stored as 19) converts exactly the photos confirmed, one sequence at a time and all or nothing, resumable through its journals and staging, never twice at once; full-resolution decodes only (the managed decoders first, never a 16-bit file from an 8-bit RAW development; the server leaves what it cannot read to a PC), what Chronos reads from a photo never changed (profiles carried, a linear DNG of sRGB values only), Exif carried, every file verified by the server's decoders; Replace swaps the files of the frames in place under a crash-safe journal, the originals going into a replaced trash entry that Undo or Restore swaps back and that Empty erases only while the archive on disk shows each conversion intact, or deleted on its own word (a tombstone, the trash, an erasure record); import still copies byte for byte and the card keeps a converted photo's copy; sync and the ingest count every encoding of a photo as one; `POST /api/v1/archive/convert` with the plan cache it shares with Reorganize, `sequenceChanged` `converted` and `created`, the audit `archive_converted`. |
## Appendix A — `CLAUDE.md` content (create verbatim in Phase 0, keep updated)
+110
View File
@@ -5,6 +5,116 @@ commits follow Conventional Commits (release notes are generated from them by `C
## [Unreleased]
## [0.1.0-rc.7] — 2026-11-02
### Added
- **Convert** on the desktop and the admin panel (owner review 2, R7): convert the photos of sequences already in the
archive to JPEG (with a quality), 16-bit TIFF or linear DNG, the archival choice. At every run you choose what
becomes of the originals: *Replace* (the converted files become the sequence's photos, the same frames, and the
originals go to the archive's trash, from which *Undo* or *Restore* brings them back until the trash is emptied) or
*New sequence* (converted copies in a new sequence beside each one, titled "… (DNG)", with its tags, rating, notes
and project; the originals stay as they are). No mode is preselected and none is remembered.
- A dry run first, following your choices: per sequence the photos converted, their size before and the estimate
after, the photos that stay as they are and why (already in that format, a format this computer cannot read at full
resolution, which the server answers with "convert these photos on a PC", read only from a preview, a RAW this
computer develops at 8 bits only, a colour profile the format cannot keep, too large, unreadable, missing, never
verified, held open by another program), the sequences left as they are (busy, offline, unreadable) and the free
space the conversion needs. A PC asks its own decoders again about a photo the server found unreadable (a CMYK
TIFF), so it converts what it reads. With New sequence it says which photos each new sequence lacks. Replace asks
you to type the number of photos (desktop) or the word "replace" (admin panel); New sequence asks a confirmation
that counts the photos not copied.
- A *Convert* job then converts exactly the photos the dry run listed, one sequence at a time and all or nothing:
photos uploaded meanwhile stay as they are, and a sequence whose photos changed since is left as it is and named in
the job's log. Pause, resume and retry it in Jobs: it keeps what it converted, resumes after a crash, checks the
free space as it goes (counting every photo still being written) and stops before the volume fills. A second
conversion of the same sequences is refused while the first waits or runs. A retried New sequence conversion
finishes the copy it already made and never makes a second one; a source another conversion copied in the same
format since this one was confirmed gets no copy (the job's log says so), and while that other conversion has not
finished, the source waits for its retry.
- Every photo is decoded at full resolution only, never from an embedded preview, by Chronos' own decoders wherever
they read it (RAWs developed at full precision, the same on every computer), and keeps its metadata (capture time
to the tick, camera, lens, exposure, GPS); every converted file is read back and decoded by the server's decoders
before it is kept. A linear DNG keeps a RAW's highlights above white (up to 4 stops, in BaselineExposure) and its
colours outside sRGB (ProPhoto primaries).
- A conversion never changes what Chronos shows of a photo: the converted file decodes to the values the original
decoded to, within what the format holds. A JPEG or TIFF-16 keeps the photo's values and carries its colour profile; a float TIFF's values get a
profile made for them, with the original's primaries, and a gray profile's tones are kept. A linear DNG takes only
photos whose values are sRGB as Chronos reads them (RAWs, photos without a profile, sRGB): photos in Adobe RGB
(camera JPEGs tagged so included), Display P3 (HEIC), ProPhoto or a gamma-1.0 profile stay as they are, with "a
colour profile the format cannot keep"; TIFF-16 and JPEG convert them with their profile. A file whose pixels hold
values that are not numbers fails as damaged and nothing is written.
- Desktop: *Convert…* in the Archive manager's set bar and in the Library's mass bar (the sequences of one archive).
When a Replace job ends, its toast offers *Undo*, which brings back the originals that job replaced.
- Admin panel: *Convert…* in the Library's selection bar (up to 1,000 sequences, or every sequence after *Select all*
without a filter), and a toast that opens the job. A dry run that takes longer than a proxy lets a request last is
asked again until it is ready.
- The archive's trash lists the originals a conversion replaced as their own kind: *Restore* puts them back in place
of their conversions while those are unchanged (the conversions then go to the trash), otherwise as a new sequence.
*Empty…* erases them only while each conversion still matches where the archive holds it now. A conversion counts
as deleted only when the archive says so (a deletion recorded in its sequence's sidecar, the sequence in the trash,
or the trash's record of erasing that sequence); such originals are named first in its confirmation ("conversion
deleted"), since they may be the last copy of their photos. Whatever the archive cannot tell keeps the entry.
- API v1: `POST /api/v1/archive/convert` (archive administrators): a dry run with the plan, its space line and its
fingerprint, then the `convert` job (202) of exactly that plan; 409 `plan_changed`, `nothing_to_convert`,
`not_enough_space`; 503 `plan_dropped` when the server let the plan go. The server keeps a dry run a few minutes,
in the plan cache Reorganize uses. `sequenceChanged` with the changes `converted` and `created`; trash entries of
kind `replaced`, and `conversionDeleted` in an emptying's dry run; the audit log and the Dashboard name
conversions.
- Known limitations: a photo that cannot be converted although the dry run listed it (a damaged RAW whose headers read
well) leaves its whole sequence as it was, while the other sequences convert, and the job's retry fails the same
way; a decode larger than the computer's memory stops the job itself at every retry, before the sequences after it
(converted photos are capped at 268 MP for JPEG and about 179 MP for TIFF-16 and DNG, which makes it rare); a
damaged file that still decodes (a truncated TIFF strip, a corrupt JPEG scan) converts as the partial picture its
decoder gives; a read error while the dry run reads the headers of a TIFF, a DNG or a TIFF-based RAW lists that
photo as needing a PC, preview-only or unreadable rather than held open (it stays as it is); JPEG and TIFF-16 clip a
float TIFF's values above white and below black; a PNG's gamma and primaries without an embedded profile, JPEG XL,
JPEG XR, BMP and GIF, and Exif colour spaces other than sRGB, Adobe RGB and uncalibrated are taken as sRGB; a linear
DNG keeps the as-shot white balance baked in and clips noise below black; MakerNote and XMP are not carried; the
server's kept dry run does not see a change made on disk alone (a photo another program held stays listed as held
for up to 5 minutes, unless the index changes), and the job then converts only the photos the dry run listed, each
only while it holds the content confirmed; a conversion of every sequence of an archive that keeps receiving uploads
may never be confirmed, as each upload changes the plan; of two confirmations of the same sequences at once the
second is refused with `plan_changed`; an emptying's dry run lists as erasable an entry the job then keeps (its
conversion changed, never verified or not located, its sequence busy), and the job says why and fails at the end;
erasing replaced originals holds their sequence while every conversion is re-hashed; the desktop's *Undo* lives in
the toast of the job's end only: later, after a restart, or for a conversion the server ran, *Restore* in the trash
brings the originals back.
### Changed
- Import still copies every photo byte for byte and converts nothing. Deleting imported photos from a card keeps, and
formatting the card refuses, a photo converted since: its archived file no longer matches the card.
- Sync and imports count a photo and its conversion as one photo: a photo converted on either side, or on both,
compares as one; importing a card or a folder again, or downloading an original, files nothing for a photo
converted since; an upload of such an original into its sequence is answered `alreadyExists`; *Download originals*
puts the server's conversion in place of a photo missing here, instead of adding a frame.
- Exif written by Chronos (proxies, exports, converted photos) includes the exposure program, metering mode, flash
and white balance when known.
- Server: Reorganize's and Convert's dry runs share one plan cache, two made at once and eight kept across both.
- Emptying the trash says in its job log why it kept each entry and what settles it: changed after the plan, its
sequence busy, a conversion that no longer matches, a photo never verified (verify the sequence), a sidecar missing
or unreadable (scan the archive), an index row the archive does not bear out (rebuild the index), or a conversion
whose fate the archive does not show (restore the entry to keep its photos).
- Desktop: a confirmation with a long list scrolls it, so its buttons stay on screen; Tab reaches the list, which
then scrolls with the arrow, page and Home/End keys.
- **Upgrade:** there is no migration: the index stays at schema 8, and earlier versions keep the sidecar fields
conversions write (`frames[].source`, tombstones of reason `replaced`). Undo conversions before going back to an
older version: it cannot swap replaced originals back (its *Restore* keeps them in the trash) nor settle a
replacement a crash interrupted.
### Fixed
- The managed TIFF decoder (the server's, and the desktop's after WIC) read CMYK, CIELab and palette TIFFs as the gray
of their first channel; it now leaves them unreadable (a PC reads them through WIC). A TIFF with an impossible
number of strips or tiles is refused as unreadable too, so a PC asks WIC, instead of failing with an arithmetic
error.
- Sync's job log lines (a photo missing, changed, deleted on this PC or on the server, frames without a proxy or
thumbnail on the server) are in your language; they were English in every language.
- On a PC, TIFFs that WIC decodes wrongly without an error (a compression it does not know, such as ZSTD or JPEG
2000, which came out black; Photoshop's 32-bit files with a floating-point predictor and 32-bit integer samples,
which came out as noise) are left to Chronos's own TIFF reader, or are unreadable, in renders, thumbnails and
analyses as in conversions.
- Edit: the picker no longer spins a processor core and stops responding when the list is loading a page as it
looks for the sequence edited last.
## [0.1.0-rc.6] — 2026-10-27
### Added
+47 -4
View File
@@ -148,7 +148,7 @@ One line per decision: date · decision · alternative · reason.
| 2026-10-03 | Editor 1:1 and wheel zoom render at the source's long edge, Fit at the view's size; labelled preview tools (icon + text) with full screen, play and the crop view icon-only; the shot-data pill moves above the tools when they do not fit at 1200 px. | Render only the visible region | Decoders decode whole frames; simplest correct option. |
| 2026-10-03 | Export tab: preset grid columns = width / 200 px; Output label column fixed at 96 px with ellipsis and tooltip; Optimise all skips Stack; render follow-ups are a toast with Show in folder plus the history line's show-file link. User presets ("Customise") are not built; the Export "Sync" box is (2026-10-06: ExportSettings.SyncToServer, off by default). | Fixed 4 columns / placeholder controls | The fixed grid clipped at 1200 px; user presets need a preset store and render-path resolution. |
| 2026-10-03 | Exposure measuring tool switches Luminance / Flicker (frame-to-frame log-luminance change before and after correction) / Waveform (luma per column band of the corrected preview); the Time tab shows a plan chart beside the remap curve; the Camera free crop is four margin sliders (≤ 45 % each, ≥ 10 % of the frame left). | One chart per tab | §12.3 measuring needs and Editor.html. |
| 2026-10-03 | Import omits the Convert row and the profile "New" button: card profiles are born on first insertion and shared through camera profiles (settings row followed by the cards of that camera; a card without settings joins automatically). | Conversion at import / card-less profiles | A converted file breaks the hash-verified erase/format gate and immutable originals; a profile needs a card identity (§13 "rules shared by all cards of that camera"). |
| 2026-10-03 | (Partly superseded by the 2026-10-26 conversion after import row: import still copies byte for byte and has no Convert row; converting is a separate, explicit step after import, which keeps the erase gate and the originals.) Import omits the Convert row and the profile "New" button: card profiles are born on first insertion and shared through camera profiles (settings row followed by the cards of that camera; a card without settings joins automatically). | Conversion at import / card-less profiles | A converted file breaks the hash-verified erase/format gate and immutable originals; a profile needs a card identity (§13 "rules shared by all cards of that camera"). |
| 2026-10-03 | Import sessions merge in the session table and split per photo in Show plan (merges only into the earlier session of the same body and format). Folder and Server destinations run in the screen with a partial result on failure; a server 4xx (not 401/403) fails only that file. Automatic import always goes to this PC's archive. | New job kinds / abort on any error | No job handlers exist for those destinations; §13 lists errors per file; the archive is the gated destination for erase/format. |
| 2026-10-03 | Format gate: every photo on the card must be verified by the job's own import records; non-photo files are listed in the typed confirmation, not blocking; the card is re-listed right before SHFormatDrive, behind a typed confirmation of the card name; a card that leaves needs a new check. | Count only DCIM photos / block on any file | Sony and Canon cards always carry camera files; §8.6 and DESIGN §4. |
| 2026-10-03 | (Partly superseded by the 2026-10-26 Reorganize job row: a plan its job paused, cancelled or failed is left to that job, not completed at the next open.) Archive manager: Overview (tree, tiles, charts, mass operations on the tree selection narrowed by a Camera/Status/Tag filter) and Maintenance (health with one fix per line, recent runs, duplicates, orphans); duplicates/orphans searches and retag run in-screen, cancellable and logged; rename apply is journaled and completed at the next open; Maintenance adds a database backup. No Merge/split yet (Delete… and Trash… exist since 2026-10-06, through the engine's trash). | Engine jobs for every action / Archive.html's single page | No result store for read-only reports; deleting or moving frames needs engine operations (the trash lives in the server). |
@@ -480,12 +480,12 @@ One line per decision: date · decision · alternative · reason.
| 2026-10-26 | Tombstones are the sidecar's `removed` list (left out when empty, kept by older builds), copied into `frame_removals` (migration 0008) at every index sync without the content a frame of the sidecar holds again, and gone with the sequence row. A deletion writes one only for a SHA-256 no photo that stays holds. They outlive emptying the trash; a deleted sequence's record keeps them for a restore whose folder lost its sidecar, and a sidecar rebuilt from the photos takes the index's back. Filing that content into the sequence again (an import, a restore, an explicit upload again) drops its tombstone. (Owner review 2, R6.) | Tombstones in the index only, or in the trash records | A rebuild from the sidecars keeps them; a duplicate that stays was not removed; an emptied trash must not let sync bring the photo back. |
| 2026-10-26 | Photos never hashed are hashed as they go, for their tombstone. Frames that stay are looked at only when never hashed and of a deleted photo's size: a SHA-256 of their first and last 64 KiB is compared first, the whole file is read only when those match, and the full hash is kept in the sidecar and the index. A dry run blocks a never-hashed original that is on disk but cannot be read (409 `photo_unreadable`; it opens at most 256 of them, and the deletion's own hashing refuses one past those as `folder_in_use`, nothing moved). Known limitation: a never-hashed photo whose original is already missing is deleted without a file and without a tombstone (its record stays, a restore reports `no_file`, Empty erases it), so a copy elsewhere can come back; the edge prints are not stored, so N such originals of one size cost 128 KiB × N reads per deletion until a verify hashes them. (Owner review 2, R6.) | Refuse to delete a photo without a hash; hash every frame that stays | A file that is gone has no content to name, and blocking it would make it undeletable; reading only likely twins keeps a deletion among raw files quick. |
| 2026-10-26 | When indexed frames vanish from a sidecar (a deletion here, or by another process sharing the archive), `ProjectPositions` translates the project's positions by photo: those on the photos that went wait as pending frames and come back with a restore, the others follow their photos, and the settings version stays; a hero frame id whose frame is gone is cleared. A deletion or restore clears light and deep analysis, thumbnails and proxies in the sidecar and the row and queues them again: light analysis always, deep analysis at background priority when the sequence had one, thumbnails and proxies always on the server and on the desktop when it had them. Proxies are renamed and `thumbs.pack` re-keyed (`ThumbPackWriter.Rekey`, skipped while a thumbnail pass holds the pack) to follow their frames, and the server's thumbnail locator checks the fingerprint of never-hashed frames too. (Owner review 2, R6.) | Keep positions as they were (the earlier rule); rebuild every proxy and thumbnail | Exclusions, the hero and keyframes must not slide onto other photos; proxies and thumbnails are keyed by index, so moving them lets the passes reuse them and never shows a neighbour's thumbnail. |
| 2026-10-26 | Emptying the trash is only an explicit job behind a dry run and a fingerprint. The dry run measures each entry on disk; the fingerprint is the SHA-256 of `kind\|name\|files\|bytes\|deletedAt ticks` per entry, in name order. The `EmptyTrash` job (stored as 18, user priority, normal level in the priority queue) keeps each entry's name and fingerprint: at its start any change of the plan erases nothing, a resumed job checks each remaining entry alone, and under its lease each entry is read and measured again and kept if it changed; an entry moves into `trash/.erasing` and is then deleted, leftovers going at the next emptying; a `replaced` entry goes only while its replacements still match their SHA-256 (re-hashed); a kept entry fails the job at the end. No schedule and no clean-up step empties the trash. The desktop asks for the number of entries to be typed, the panel for the word "empty" in its language. (Owner review 2, R6; BRIEF §0.2 rule 8.) | Erase in the request; a scheduled or age-based emptying | The only erase of user files must be an explicit, confirmed, verified and resumable action that erases exactly what the user saw. |
| 2026-10-26 | (Partly superseded by the 2026-10-26 replaced entries emptying row: a `replaced` entry is weighed against the archive on disk, a conversion deleted since is said in the dry run and its fingerprint, and a kept entry is logged with why.) Emptying the trash is only an explicit job behind a dry run and a fingerprint. The dry run measures each entry on disk; the fingerprint is the SHA-256 of `kind\|name\|files\|bytes\|deletedAt ticks` per entry, in name order. The `EmptyTrash` job (stored as 18, user priority, normal level in the priority queue) keeps each entry's name and fingerprint: at its start any change of the plan erases nothing, a resumed job checks each remaining entry alone, and under its lease each entry is read and measured again and kept if it changed; an entry moves into `trash/.erasing` and is then deleted, leftovers going at the next emptying; a `replaced` entry goes only while its replacements still match their SHA-256 (re-hashed); a kept entry fails the job at the end. No schedule and no clean-up step empties the trash. The desktop asks for the number of entries to be typed, the panel for the word "empty" in its language. (Owner review 2, R6; BRIEF §0.2 rule 8.) | Erase in the request; a scheduled or age-based emptying | The only erase of user files must be an explicit, confirmed, verified and resumable action that erases exactly what the user saw. |
| 2026-10-26 | Trash API under ManageArchive. Entry names are `<id>[-<time>[-n]]` (a sequence) or `photos-<id>-<time>[-n]`, and the API takes only that shape, never a path. Offline, the listing and the emptying answer 503 `archive_offline` (the erase also when read-only). 422 `trash_mismatch` is for an entry none of whose files matches its record, or a sequence entry whose own sidecar no longer names it; 409 `sidecar_mismatch` for a damaged or foreign sidecar of the sequence the photos return to (also on `frames/delete`, and on sequence deletes that settle a journal first). The emptying request is audited `trash_empty_requested` (entries, bytes, names, the job); what was erased is in the job's log. (Owner review 2, R6.) | Names with `/`; an empty listing when offline; audit `trash_emptied` at the request, or from the job | A single URL segment rules out path traversal; an unreachable archive is not an empty trash; an audit entry must not claim an erase the job may still refuse, and the job has no hook into the server's audit. |
| 2026-10-26 | `POST /sequences/{id}/frames/delete` needs the Delete permission and the owner or an admin, like `DELETE /sequences/{id}`; each block has its code (`frames_conflict`, with the frames version now, only for changed frames; `sequence_busy`, `would_empty`, `photo_unreadable`, `archive_offline`), and it takes 1–100,000 ids under its own body limit (`FrameDeleteBodyLimit`, 100,000 × 48 + 4096 bytes, about 4.8 MB) set as routing metadata like the proxy route's: a third exception to the 2026-10-02 1 MiB rule, after chunks and proxies. (Owner review 2, R6.) | Lower the id limit to about 20,000 | A sequence of 100,000 photos must be able to lose most of them in one request; the 1 MiB limit stopped at about 26,900 ids. |
| 2026-10-26 | Bulk routes take 1–1,000 distinct ids per request and answer each id in order, `ok` or `skipped` with the code and its sentence: delete moves each sequence whole as `DELETE /sequences/{id}` does (another user's is `forbidden` unless the caller is an admin), retag is the PATCH tag edit with up to 3 attempts on a conflict, and jobs queue one job at user priority. A verify of sequences targets their archive with the sequences in its parameters (`ArchiveJobs.Verify`), which also fixes `POST /jobs` with `verify`, whose job failed at once. The panel sends 1,000 ids a request (one job per 1,000 sequences, the toast counting them), lists every page of a filter for *Select all*, and refreshes every loaded row 1,000 a request. (Owner review 2, R6.) | No limit; a server-side "all of the filter" selection | Bounded requests and answers; the same rules as the single-sequence endpoints. |
| 2026-10-26 | Uploads keep deleted photos out: a start whose SHA-256 the target sequence tombstoned answers `alreadyExists` without a frame id, unless a frame of the target still holds that content (a stale tombstone refuses no repair); the completion checks again after the upload stops receiving, and the ingest a third time under the sequence's lease, which a deletion takes (`IngestRequest.RefuseRemoved`), answering 409 `photo_removed` with the upload cancelled and its files deleted (`ChronosClient` returns null for it). Only an explicit user action brings such a photo back: `StartUploadRequest.Restore` and `complete?restore=true` (a query, so the uploads table needs no migration), sent by the panel's *Upload again* on a *Deleted before* row between runs, never by sync, the Uploader or a card import; with it no stand-in in another sequence counts, and filing the photo drops its tombstone, also after Empty. The desktop has no such path. (Owner review 2, R3, R6.) | Check at start only; store the flag on the upload; only a restore from the trash brings a photo back | An old client syncing a copy, or a watch folder, must not undo a deletion, and no deletion may land between the last check and the commit; a user who uploads a photo again on purpose means it, also once the trash is emptied. |
| 2026-10-26 | Sync tombstones: a `deleted` tombstone keeps the photo from being offered to the side that deleted it (no upload of what the server deleted, no download of what this PC deleted); a `replaced` one is an alias, followed up to 8 steps, compared, transferred and translated as the replacement. A tombstone leaves a photo out only while its side holds no matching photo (by hash, or by size and capture time while unhashed). An unhashed server frame is fetched, hashed and dropped when this PC deleted it; an unhashed local frame the server deleted is not sent, and the archive verify then runs so the next comparison leaves it out. Positions parked for a photo the other copy deleted stay pending; sync never deletes local files. Known limitation: until the server verifies such a frame, the row counts it as missing here and *Download* fetches and drops it each time (fixing it needs size and capture time in the tombstones). (Owner review 2, R6.) | Drop parked positions; delete the local copy; tombstones by size and time now | A deletion on one side is not undone by the other, neither side loses a file, and a restore places the parked positions again. |
| 2026-10-26 | (Partly superseded by the 2026-10-26 sync aliases row: `replaced` tombstones of both sides join encodings of one photo, compared as the smallest SHA-256 among them, with no step limit.) Sync tombstones: a `deleted` tombstone keeps the photo from being offered to the side that deleted it (no upload of what the server deleted, no download of what this PC deleted); a `replaced` one is an alias, followed up to 8 steps, compared, transferred and translated as the replacement. A tombstone leaves a photo out only while its side holds no matching photo (by hash, or by size and capture time while unhashed). An unhashed server frame is fetched, hashed and dropped when this PC deleted it; an unhashed local frame the server deleted is not sent, and the archive verify then runs so the next comparison leaves it out. Positions parked for a photo the other copy deleted stay pending; sync never deletes local files. Known limitation: until the server verifies such a frame, the row counts it as missing here and *Download* fetches and drops it each time (fixing it needs size and capture time in the tombstones). (Owner review 2, R6.) | Drop parked positions; delete the local copy; tombstones by size and time now | A deletion on one side is not undone by the other, neither side loses a file, and a restore places the parked positions again. |
| 2026-10-26 | The server refuses frame uploads whose file name starts with `.` (400 `invalid_file_name`) from every client, and the panel's dialog counts such files as not photos. (Owner review 2, R3.) | Leave them to each client | The archive scanner leaves hidden files out, so an upload must not file what an import of the same folder would not; the AppleDouble `._` files a Mac leaves on cards were filed through the server import before. |
| 2026-10-26 | The panel's Library is the second sidebar entry, with the Image icon (the Dashboard keeps the four tiles of the mockup). The trash is a view of the Library (`#/library?view=trash`, `pages/library/trash.js`) that Archive opens with a *Trash* button. The upload dialog is a module the Library and a sequence import on demand (`import("../upload.js")`, exporting `openUpload({ api, sequence, onDone })`); a test checks that nothing imports it statically and, lexing every admin module, that each top-level function that uses `api` takes it. (Owner review 2, R6, R3.) | A Trash panel inside Archive; static imports | One route and module reachable from both places, beside the deletions that fill it; other pages never load the upload code; CI has no JavaScript engine, so a structural check catches an out-of-scope `api` like the one that broke every web upload during this phase. |
| 2026-10-26 | New `GET /api/v1/sequences/facets` (years newest first, camera models most used first with `PathTemplate.CameraName` as their label, tags by key with their first spelling, each with its count, from the server archive's rows) and `rendered=true\|false` on `GET /sequences`. Covers come from `GET /sequences/{id}/thumb` (the hero's thumbnail, else the first frame's; `private, max-age=3600`, ETag) at `?v=<hero>-<framesVersion>`. (Owner review 2, R6.) | Menus built from the loaded page; no cover endpoint | The menus must offer exactly the values the filters take without reading every sequence; a new cover or other photos change the address, while edits of title, tags or rating keep the cached image. |
@@ -518,7 +518,50 @@ One line per decision: date · decision · alternative · reason.
| 2026-10-26 | A sequence keeps its folder when it already is what the template gives, or that name with the " (n)" filing or an earlier Reorganize gave it, in the template's case; a change of case only is planned while no other folder holds that exact name (another sequence's, or on a case-sensitive file system a folder on disk beside the sequence's own: `RenamePlanner.ExistsExactly` compares every level exactly) and moves through a temporary name. No two sequences of a plan get folders that differ only in case. Under the step's leases a case-only target that now exists beside the sequence's own folder refuses the step (dropped when resuming), as `MoveFolder` would; a change of case in an outer level moves on every file system. (Owner review 2, R7.) | Compare folder names without case; make every target unique again | A second Reorganize must plan nothing (a folder flipped between " (2)" and " (3)" before); NTFS ignores case and Linux does not; a plan that fails at every archive open must never be journaled. |
| 2026-10-26 | Template rules (`TemplateRules`, checked on three sample photos two seconds apart): a folder template may not write a level scans never enter (`ReservedFolder`: starting with `.`, or `originals`, `proxies`, `exports`, `.chronos`); a file template may hold no slash (`FileSeparator`), must keep the photo's extension (`Extension`: `PathTemplate.KeepsExtension`, the extension appended or after `.{ext}`) and must give a session's photos different names (`NotUnique`). What a template does not write itself is made safe instead: a folder level a title gives that scans skip gets a leading `_` (`ExpandFolder`, for import, upload and Reorganize alike), a file name over 200 characters is shortened before its `.{ext}` without splitting a surrogate pair, and a title template expands as text (`ExpandText`: control characters as spaces, at most 200 characters, no file-name sanitizing). Each rule has its sentence (`Errors.Template.<Rule>`). (Owner review 2, R7.) | Check only that a template parses | `{n}{ext}` drops the dot, and with it the extension every decoder goes by; a folder scans skip vanishes from a rebuilt index; repeating names fill a session with `_2`, `_3`; titles became `Paris_ night`. |
| 2026-10-26 | The rules hold wherever a template is typed or sent: the desktop's Settings › Archive, Import and Reorganize fields (`NamingPreview`), the server's Reorganize and `PUT /archive/settings`, and the archive engine (`ArchiveSettings.Problem`, `CheckTemplates`). A template `archive.json` already holds (saved by 0.1.0-rc.5 or earlier) is held to them only when an edit changes it: the engine's `UpdateSettingsAsync` and the server's PUT check the rules only for templates that differ from the stored ones, every template still having to be non-blank, valid and expandable (the PUT compares with the archive as the server last read `archive.json`; when that file changed since, a desktop's edit say, and the engine refuses a template the form still sends, the answer is still `invalid_template` with the rule, never 409 `archive_policy`); `CreateAsync`, and so adopting a new folder, holds both to every rule (this PC's templates saved by an older version then refuse Welcome › Create, the toast naming the rule, fixed in Settings › Archive). A broken rule is a `TemplateRuleException` (an `ArgumentException` naming the field, with the rule), whose sentence the desktop's toasts show; the API's `invalid_template` details are `<field>:<rule>` (`fileTemplate:extension`) with that sentence in the request's language, a blank or invalid template keeping the bare field and the generic message. (Owner review 2, R7.) | Refuse every save while a stored template breaks a rule; check the rules in the user interfaces only | A pre-rules template must not block an edit of the name, the proxy size or the other template, on the desktop or the panel; neither the engine nor the server accepts from another client what the fields refuse. |
| 2026-10-26 | The server keeps Reorganize dry runs (`ReorganizePlanCache`), keyed by the archive, the selection (all, or the ids in their order), the templates and `SequenceRepository.GetStampAsync`: a SHA-256 of what the planner reads from the index (every row's id and folder; for the planned rows their title, first capture, camera make and model, lens, photo count, frames version and how many of their photos are hashed; for others inside a planned folder their title). Uploads into other sequences, ingest status writes, verifies of other sequences and tag or note edits keep a plan; a verify that hashed planned photos plans again. A plan, or a refusal (`nested_target`, `not_found`), is kept 5 minutes from when it was made (a timer per plan, checked again on access); failures and stopped plans are not. Plans are made apart from the request (a request cut off only stops waiting), once per key, at most 2 at once (`Concurrency`) and 8 kept or being made (`Capacity`: a new one lets go the kept plan asked for first, else the one being made asked for first, which stops); one still being made 15 minutes after it was asked (`PlanTimeout`, the wait for a turn included), let go, or running when the server stops is cancelled and answered 503 `plan_dropped`. The confirmation forgets its key once the job is queued. (Owner review 2, R7.) | Plan again at every request; plan in a background job with progress | An `all` dry run reads every sidecar and photo folder, minutes over SMB, and behind a proxy's timeout it was never shown; the job plans again and compares fingerprints, so a kept plan that is stale can only fail, never change what the dry run did not show (a change made on disk alone answers 202, then the job fails changing nothing). |
| 2026-10-26 | (Partly superseded by the 2026-10-26 conversion plan cache row: `ReorganizePlanCache` is `PlanCache`, shared with Convert, its 2 at once and 8 kept counting both kinds.) The server keeps Reorganize dry runs (`ReorganizePlanCache`), keyed by the archive, the selection (all, or the ids in their order), the templates and `SequenceRepository.GetStampAsync`: a SHA-256 of what the planner reads from the index (every row's id and folder; for the planned rows their title, first capture, camera make and model, lens, photo count, frames version and how many of their photos are hashed; for others inside a planned folder their title). Uploads into other sequences, ingest status writes, verifies of other sequences and tag or note edits keep a plan; a verify that hashed planned photos plans again. A plan, or a refusal (`nested_target`, `not_found`), is kept 5 minutes from when it was made (a timer per plan, checked again on access); failures and stopped plans are not. Plans are made apart from the request (a request cut off only stops waiting), once per key, at most 2 at once (`Concurrency`) and 8 kept or being made (`Capacity`: a new one lets go the kept plan asked for first, else the one being made asked for first, which stops); one still being made 15 minutes after it was asked (`PlanTimeout`, the wait for a turn included), let go, or running when the server stops is cancelled and answered 503 `plan_dropped`. The confirmation forgets its key once the job is queued. (Owner review 2, R7.) | Plan again at every request; plan in a background job with progress | An `all` dry run reads every sidecar and photo folder, minutes over SMB, and behind a proxy's timeout it was never shown; the job plans again and compares fingerprints, so a kept plan that is stale can only fail, never change what the dry run did not show (a change made on disk alone answers 202, then the job fails changing nothing). |
| 2026-10-26 | `POST /api/v1/archive/reorganize` (ManageArchive): exactly one of `sequenceIds` (1–1,000) and `all`, a null template kept, at least one given; a dry run answers the plan (`ReorganizePlanDto`: steps with folders, titles, carried, frames version, file count, up to 3 samples and what stays, its reason in snake case with a sentence in the request's language; totals; fingerprint); the change answers 202 with the `move` job. 400 `bad_request` (`sequenceIds`, `templates`, `fingerprint`), `invalid_template`; 404 `not_found` (`sequence`); 409 `nested_target` (details: the folder), `plan_changed` (details: the fingerprint now), `job_unavailable`; 503 `archive_offline`, `plan_dropped`. Audited `archive_reorganized` ("sequences · files · folder, file and title templates"), which the panel's audit log and Dashboard show as a sentence. (Owner review 2, R7.) | Separate rename and move endpoints; every planned name in the answer | One request carries the three templates as both programs do; a dry run of 100,000 photos answers counts and samples, not every name. |
| 2026-10-26 | Panel: the Library's *Reorganize…* sends the selected ids, up to 1,000, and `all: true` only above that while the selection is exactly *Select all* without a filter and the total has not changed; any other larger selection is refused with a toast, never split into several plans or jobs. The dialog's switches start on for the parts with a template (Titles off and empty, the archive having no title template; from the Archive page's toast only the changed parts), templates are sent trimmed, a dry run runs 400 ms after typing (Enter at once) with one request in flight and a change meanwhile planned right after, an older request's refusal is not shown, and Apply runs only while the shown plan is the fields' and changes a sequence. The confirmation has two buttons and asks for nothing typed (nothing is deleted); a different plan answered during it is shown, not applied. `toast(message, isError, action)` takes an optional link or button; such toasts stay 15 s and pause under the pointer or the keyboard focus. (Owner review 2, R7.) | Split a large selection into several jobs; a typed confirmation | One dialog is one plan and one job, and separate plans could give two sequences one destination; a typed word is for what cannot be undone. |
| 2026-10-26 | Desktop: one *Reorganize…* dialog replaces Rename… and Move… of the Archive manager and Move… of the Library, for the sequences of one archive as Move was: Folders and File names on with the archive's templates (read again from the index when it opens), Titles off with `{title}`; the dry run follows the typing (400 ms; Enter or leaving a field plans at once unless that dry run is on screen or under way, so a click on Apply is never turned off under it), and only the latest dry run publishes its result. After Settings › Archive saves a new folder or file template into an archive with sequences, a toast offers *Reorganize…* for every sequence with the changed parts on, one offer per archive, a change made while its toast is up (8 s) joining it (`ReorganizeOffer`, `Toast.Closed`); on the Archive screen an open dialog is never replaced: Reorganize waits, says so, and opens when it closes. The old Rename and Move keys were pruned from every language (`i18n prune`); the capture scene is `archive-reorganize-*`. (Owner review 2, R7.) | Keep Rename (titles) beside Reorganize; a modal question or an automatic Reorganize after a template change | One concept and one button for how filed sequences are named, with the same three templates as the panel; templates only name what is filed next, so a toast offers without interrupting and nothing moves without the dry run; a new key shows as untranslated instead of 36 languages keeping "Move". |
| 2026-10-26 | Conversion after import: import still copies every photo byte for byte and has no Convert row (the 2026-10-03 row stands for import). Converting is *Convert…*, an explicit step after import, on the desktop (the Archive manager's set, the Library's selection of one archive) and the admin panel (the Library's selection: up to 1,000 sequences, or every sequence after *Select all* without a filter), through one engine (`MassConverter`) and one job, behind a dry run. Replace only moves originals into the archive's trash and New sequence leaves them where they are: nothing rewrites an original. The card erase gate still re-hashes the card file and the archived copy against the import hash, so a converted photo keeps its card copy (`CopyMismatch`) and a format is refused while it is on the card. (Owner review 2, R7.) | Convert at import (the sketch's row); convert originals in place | The owner asked for conversion after import as well; the hash-verified erase and format gate and immutable originals hold because no original is rewritten and a card is never erased against a converted file. |
| 2026-10-26 | Replace or New sequence is chosen at every run and never remembered: both dialogs open with no mode and Apply waits for one, asked last, after what converts and the space; Format starts on Linear DNG (`ConvertOptions.ArchivalTarget`) and Quality on 95, nothing kept in settings. What converts does not depend on the mode, so the desktop plans once per format and quality and sets the mode on that plan, and the panel asks its preview in Replace's words (`mode: replace`) and asks again for New sequence, answered from the plan the server keeps; the fingerprint names the mode. A Replace is typed: the desktop asks for the number of photos it replaces (as Delete and Empty ask for a count), the panel for the localised word "replace" (as Empty asks for "empty"); New sequence asks a plain confirmation that says how many photos the new sequences lack. (Owner review 2, R7.) | Remember the last format and mode; default to Replace; a typed confirmation for both modes | The owner's answer: a choice at every run; a remembered Replace would be one Enter away; each program keeps its own typed confirmation for what moves originals into the trash, and New sequence changes no original. |
| 2026-10-26 | Targets: JPEG baseline 4:4:4 with optimised Huffman tables, 8-bit, quality 1–100 (default 95); TIFF 16-bit RGB with Deflate and the horizontal predictor; linear DNG (16-bit LinearRaw, lossless JPEG tiles, UniqueCameraModel "Chronos"), the archival default. A conversion's DNG is scene-referred (`LinearDngOptions.SceneReferred`): the pixels are stored in linear ProPhoto (ROMM) primaries, divided by the smallest power of two that brings their peak under 0.998 of white, at most 2^4 (`LinearDngWriter.MaxHeadroomStops`), BaselineExposure giving those stops back; ColorMatrix1 and ForwardMatrix1 describe ProPhoto with illuminant D65 and AsShotNeutral 1/1/1, and the encode matrix is the inverse of the in-house reader's solve of the rationals written, so a file reads back as written to the 16-bit step. The as-shot white balance is baked in and values below 0 are clipped. Exports keep the clipped linear-sRGB DNG. (Owner review 2, R7.) | A float DNG; a fixed 4× headroom; the export's clipped linear sRGB for conversions too | Once the trash is emptied a Replace's file is the photo: the highlights a RAW develops above white (about a stop on a partly clipped sky) and its colours outside sRGB (negative in sRGB primaries) must survive; 16-bit integers are what every raw editor reads, and a power of two keeps the steps exact; an export is a rendered picture whose highlights the render decided, and its files stay as earlier builds made them. |
| 2026-10-26 | A conversion decodes at full resolution only (`AllowPreview: false`, upright) through its own chain (`FrameConverter.Decoders`): the managed provider first, so every format it reads natively is developed in-house at float precision, as on the server, and the host's others (WIC) after it for what it cannot read (a CR3, a HEIC, a CMYK TIFF). For TIFF-16 and linear DNG a RAW never goes through a provider that develops at 8 bits (`IImageDecoderProvider.DevelopsRawAt8Bits`, true for WIC's Raw Image Extension): such a RAW is planned out as `eight_bit`, refused at conversion (`ConversionFailure.EightBit`) and converts to JPEG only. The conversion's managed provider reads JPEG, PNG and TIFF headers when it probes (`ManagedDecoderProvider.ReadsHeaders`): what its decoders refuse there (a compression, sample format or photometric they lack, more than `MaxSamples` or `MaxPixels`, arithmetic coding, a JPEG or PNG larger than one array) is asked of WIC on a PC and is `convert_on_pc` on the server. The archive engine's other decodes keep WIC first on the desktop. (Owner review 2, R7.) | The archive engine's order (WIC first); develop RAWs at 8 bits for every target | The Raw Image Extension gives 24bppRGB, too few bits for a 16-bit archival file, and the in-house developer gives the same pixels on every host; the dry run must promise only what the decoders it uses take. |
| 2026-10-26 | The managed TIFF reader refuses, before reading pixels, samples it does not render (`TiffImageReader.Renders`): CMYK (5), CIELab (8), palette (3), LogL/LogLuv, RGB of fewer than three samples and float min-is-white, for every managed decode; strip and tile counts are counted in 64 bits and impossible ones refused as data (`InvalidDataException`), and `ReadInfo` refuses what a decode would. On the server such a frame is unavailable instead of the gray of its first plane; a conversion on a PC reads it through WIC. (Owner review 2, R7.) | Decode them as gray, as before | With the managed decoders first, a Replace would have put a gray or black picture in the archive and the original into the trash; an `OverflowException` escaped the decoder chain, which then never asked WIC. |
| 2026-10-26 | (Partly superseded by the 2026-11-03 conversion colour and sRGB by name rows: float values are written as sRGB codes with a profile made for them, a linear DNG takes only values that are sRGB's as read and refuses other profiles, a gray profile's codes are kept with its curve as an RGB profile, and a name decides sRGB only for a profile without colorant tags.) Colour profiles: `SourceColor` reads what a photo's headers record (JPEG APP2 chunks, PNG iCCP or sRGB, TIFF tag 34675 from the image the decoders read, then IFD0, then Exif, HEIF/AVIF `colr` prof, rICC or nclx, WebP ICCP, Exif ColorSpace with Interop) and whether its samples are linear (a float or LinearRaw TIFF), and `FrameConverter.Treatment` keeps that space. JPEG and TIFF-16 carry the ICC profile (APP2 chunks, tag 34675) with code values unchanged, linear values coded with the profile's own curves; linear DNG takes the values converted to linear Rec.709 through a matrix/TRC profile (linear values through the matrix alone, unclipped); an sRGB profile, told by its numbers for matrix/TRC (matrix within 2e-3 of identity, curves within 2e-3 of the sRGB curve) and by its name only for a lookup-table profile, needs nothing in a DNG; a gray profile converts to sRGB. Exif uncalibrated with Interop R03 (or ColorSpace 2) gets an in-house v2.1 "Compatible with Adobe RGB (1998)" profile, a HEIF nclx box with P3 primaries "Display P3". Refused as `color_profile`: CMYK, Lab and other non-RGB profiles, a lookup-table profile into a DNG or holding linear values, curves that cannot be inverted, uncalibrated without R03, other nclx primaries or an HDR transfer, a profile that does not parse; colorants that convert nothing (no positive Bradford cone response, a non-finite or singular matrix) are dropped when parsed, so such a profile is carried into JPEG or TIFF and refused for DNG. PNG gAMA/cHRM without iCCP, JPEG XL, JPEG XR, BMP, GIF and other Exif ColorSpace values are read as sRGB. (Owner review 2, R7.) | Drop profiles and write the values as sRGB (the first version); convert everything to sRGB; refuse every photo that is not sRGB | A Replace makes the converted file the photo: a Display P3 HEIC or an Adobe RGB JPEG must keep its colours; carrying the profile keeps a JPEG's or TIFF's values exact, and a DNG's colour is its matrices, so it takes converted values. |
| 2026-10-26 | A converted file's Exif (`FrameConverter.Metadata`, `ExifWriter`): from the sidecar the capture time to the tick, offset, exposure, f-number, ISO, focal length, bias and white balance; from the original the make, model, serial, lens, 35 mm focal length, exposure program, metering mode, flash, GPS, artist and copyright, the sequence's camera and lens where the original names none; a frame without a capture time keeps the original's Exif or XMP time, never one from the file system; orientation 1 (the pixels are upright), Software "Chronos"; no MakerNote or XMP. `ExifWriter` now writes ExposureProgram, MeteringMode, Flash and WhiteBalance, for proxies and exports too. (Owner review 2, R7.) | Copy the original's Exif block whole | The sidecar's times are the archive's, and the verify checks them to the tick; MakerNote offsets do not survive a new layout; an upright picture written with its old orientation would turn twice. |
| 2026-10-26 | (Partly superseded by the 2026-11-03 flagged frames and size bounds rows: a frame another host flagged undecodable is asked again where the conversion has other decoders, and sizes are weighed without overflow.) The dry run promises only what the job does (`ConvertPlanner.Skip`): every frame is asked with the conversion's decoders whatever tier was recorded (unknown before the light analysis, another host's, a preview), headers only, 8 files at a time per sequence, and its colour headers are read. Skip reasons: `SameFormat` (the target's format already: any TIFF for TIFF-16, any DNG for linear DNG), `Missing`, `Unhashed`, `Undecodable` (flagged, or a file shorter than its own headers), `TooLarge`, `NoNativeDecoder` and `PreviewOnly` (both `convert_on_pc` on the server), `EightBit`, `ColorProfile` and `Inaccessible` (an I/O error or denied access other than not found: a file another program holds without sharing). `TooLarge` is a bound, never an estimate: a JPEG side above 65535, more than the server's decoders read back (a JPEG of 2^28 pixels, a TIFF-16 or DNG of 2^29 samples), or an incompressible worst case (51 bits per pixel, plus 1 %, plus 8 MiB for a profile and headers) above one array; a `MemoryStream` overflow while encoding is `TooLarge` too. (Owner review 2, R7.) | Probe only frames recorded below native tier (the first version); count a held file as missing | A conversion the dry run promised that then failed made its whole sequence fail at every retry; a lock released before the job ran let it convert, with Replace, a photo the confirmed plan said stays. |
| 2026-10-26 | (Partly superseded by the 2026-11-03 confirmed photos file and New sequence retries rows: the frame ids live in `journal/convert-<job>.photos`, not in the parameters, and a retry finishes a copy already filed instead of reporting its sequence changed.) A `convert` job converts exactly the photos its confirmed plan listed: each `ConvertSequence` of its parameters carries the frames version, the digest of the photos converted (`ConvertSequencePlan.Digest`: a SHA-256 over `{frameId:N}\|{sha256}` per photo, in sidecar order) and their frame ids (`Photos`, 16 bytes each in base64), and the plan's fingerprint covers the digests. Under the sequence's lease, its sidecar settled where the index has it then, the job plans it again and takes the confirmed photos from that plan, going on only while they have the digest confirmed; it then pins them (`journal/convert-<job>.pins`, `PinLog`) and from then on, a retry included, converts those alone, stage B checking under the lease that every pinned photo still holds its content, not the frames version. Photos uploaded or verified after the confirmation stay as they are. A confirmed photo that changed, went or no longer converts leaves the sequence as it is (`Changed`: its retry leaves it too, and the log says to plan again); one another program holds leaves it for the retry (`Blocked`), and a held photo the job does not convert hides no real change. A job an earlier build queued without photos checks the whole plan's digest, or the frames version. (Owner review 2, R7.) | Plan again and convert what the job finds (the first version); hold the frames version; store the whole plan in the job | The change made is the one shown and typed (BRIEF §0.2 rule 8); a time-lapse still receiving uploads must not make its sequence unconvertible at every retry; 16 bytes a photo keep a whole-archive job row small. |
| 2026-10-26 | The job takes one sequence at a time, its stage A then its stage B. Stage A runs without the lease: each original is re-hashed against its record (a mismatch fails the photo: verify the sequence), converted and verified into `.chronos/staging/convert-<job>/<sequence>/`, as many at once as `DecodeBudget` allows for the parallelism and memory, each staged file appended to `journal/convert-<job>.staged` (one JSON line, flushed). Stage B is all or nothing under the sequence's lease. `journal/convert-<job>.json` records each sequence's outcome, the statuses its passes follow from and whether they were queued: the passes are queued as soon as a sequence is journaled, and a resume queues those a pause, a yield or a crash lost. A resumed job first settles the crash journals of the sequences still to do, and takes one its replacement already completed (by the pins, or without them by the frames' `source` against the digest) as converted. A photo that fails fails its sequence, whose staged files stay for the retry, which verifies and takes them; the other sequences go on, and the job fails at the end. A sequence another index moved away (`SequenceFolders.Holds`) is left blocked with `Errors.Archive.FolderMoved`; New sequence reads the source's project under the source's lease and writes the copy's under the copy's, only into a folder that holds it. A sequence's staging goes once it is final or changed, the job's journals and staging once every sequence is final. (Owner review 2, R7.) | All of stage A first, then all of stage B; one JSON journal rewritten per photo; delete the staging of a sequence that failed | Results appear earlier and less is staged at once; appending keeps journaling linear on an 80,000-frame sequence, where a rewritten journal is quadratic; a retry keeps the work done. |
| 2026-10-26 | Maintenance (`ArchiveMaintenance.PurgeTemporaryFilesAsync`) keeps a `convert-<job>` staging folder while its job is queued, running or paused, whatever its age, removes it at once when the job is done, and otherwise once its files are a day idle; a conversion's journal files go when its job is done. A job this index does not know (another host's on a shared archive, or one its history forgot) keeps its staging and journal together while any of their files was written within `CleanupSteps.DefaultHistoryDays` (90), then both go; staging without a journal goes after a day idle. (Owner review 2, R7.) | Purge staging by age alone (24 h) | A stage A longer than a day lost its staged files, and another host's paused or failed job would have converted everything again; nothing this purges is an original. |
| 2026-10-26 | (Partly superseded by the 2026-11-03 stage A space row: before each photo the job counts that photo and every photo still being written.) Free space is measured where a conversion writes: `ArchiveServiceOptions.FreeSpace` for the archive root and for its staging folder, the tighter kept. The server takes `VolumeSpace.WritableFree`, the tighter of the space path's volume (R2) and the folder's own (on Unraid the cache, until the mover runs); the desktop asks Windows (`VolumeInfo.FreeBytesAt`, `GetDiskFreeSpaceEx`), which measures UNC archives too. A conversion needs its estimate × 1.15 plus a 512 MiB reserve, counted in both modes (Replace keeps the originals in the trash), estimated from the Export tab's bits per pixel (JPEG by quality × 1.25 for 4:4:4, TIFF-16 30, linear DNG 26; 24 MP when the size is unknown). The job checks at its start, before each sequence (every estimate not staged yet) and before each photo (that photo and those after it that may convert at once, fewer near the end), its estimates scaled by how far the files staged in this run came out above theirs; short, it stops with `Archive.Error.ConvertSpace` (in GB, or MB below one), its journal and staging kept for the retry. The server measures again at every dry run and confirmation. (Owner review 2, R7.) | The space volume alone, as the panel shows it; one check per job | On Unraid every staged and filed byte lands on the cache; the noise of a 14-bit RAW outgrows the estimate; a job must stop before the volume fills, not after; reserving a whole batch near the end stopped jobs that fitted. |
| 2026-10-26 | No conversion of the same sequences twice: `MassConverter.QueueAsync` checks the queued, running and paused `convert` jobs and queues under one lock of the process, calling the host's enqueue in the caller's context (the desktop's speaks on its UI thread); a sequence another conversion holds refuses the plan (`ConversionQueuedException`, `Archive.Convert.AlreadyQueued`): 409 `plan_changed` without details on the server, and the desktop plans again, showing those sequences busy. A dry run counts every pending conversion's sequences as busy; a job's own re-plan counts only those of conversions created before it (`JobRepository.ListPendingTargetsAsync(kind, createdBefore)`). (Owner review 2, R7.) | Let the second job find the first | Two dialogs or tabs, a lost answer and Apply again, or a dry run made before the first job was queued would make two new sequences or convert twice. |
| 2026-10-26 | New sequence: the copies are filed through the archive ingest under the session key `convert:<job>:<source>` (a resume finds the same sequence), titled "<title> (JPEG\|TIFF\|DNG)", in a folder from the archive's template, named as the ingest names every photo (`StagedFrame.NamedAs`: `{name}` the card name, `{ext}` the target's), with the source frames' capture time, offset, time source and intervalometer flag; the source's tags, rating, notes and project (positions translated by photo) follow, and its owner is the source's, else the requesting user's id. It holds the converted copies alone: the photos a sequence it copies skips are not in it (their positions wait as pending frames); the dry run says *not copied* for them (`Archive.Convert.NotCopied.*`, `Server.Convert.OnPcNew`; a sequence that converts nothing gets no copy and keeps "stay as they are"), the panel's totals and confirmation and the desktop's summary and New sequence confirmation count them, and the job log says how many stayed in the source alone (`Archive.Log.ConvertLeftOut`). A copy no longer staged at stage B fails the sequence before anything is filed. (Owner review 2, R7.) | File the photos that do not convert byte for byte into the copy; leave the skipped photos unsaid | A copy of mixed formats would be neither a conversion nor the original and would double the bytes of photos that did not change; saying before the confirmation what a copy lacks keeps it from being found missing later. |
| 2026-10-26 | Replace swaps the files of frames in place (`FrameTrash.ReplaceAsync`): the same ids and indices, so the project's positions stay (translated by the sidecar's own photo for every frame still there, also when the index was stale). Each converted file is named as filing names a photo of the sequence (`ConvertOptions.FileName`: the archive's file template, the frame's `FrameNaming` context, `{ext}` the target's in lower case, a long name shortened before its extension), unique among every file present and every name the sidecar held, those leaving included, so nothing is moved onto a file (a stray `Roof_01.dng` keeps its bytes, the conversion becomes `Roof_01_2.dng`); a sequence named by an older template takes the current one's names. Each original and its XMP companions go into one replaced trash entry per sequence and run, whose record holds the old frame records, each replacement's SHA-256, a copy of `analysis.json` and the job's id. The new record keeps the flags the user and the capture set and takes the file's own (missing, corrupt, duplicate, preview-only, undecodable) from the conversion, with a `source` naming the original; the sidecar clears the statuses the frames covered and gains a replaced tombstone per original. The proxies of the swapped frames are deleted and normal passes queued (light analysis, a background deep analysis when it had one, thumbnails, proxies). (Owner review 2, R7.) | Give the converted files the old names; one trash entry per photo; force the proxy pass | Every reference to a frame stays valid and the undo is exact; a crash between two moves is undone without doubt when no incoming file took a leaving one's place; a proxy is reused by capture time, which a conversion keeps, so stale proxies must go, and forcing would remake frames that were not converted. |
| 2026-10-26 | A replacement's journal, `.chronos/replace.pending.json`, is written under the sequence's lease before the first move, the new entry's record staying pending until the sidecar is written; it records a phase (`Moving`, `Written`, `Undoing`) and each swapped frame's new name. The next writer (`SequenceWriter.ReadLocked`) completes a replacement that is `Written`, or `Moving` with the sidecar listing a new name (by content, never by the frames version, which any writer moves), and undoes any other, which stays `Undoing`; a failed inline rollback marks `Undoing` and rethrows, and an undo that fails during recovery stops the writer, as a photo deletion's recovery does. Every writer that changes frames settles it first (`FrameTrash.EnsureReplaced`: the ingest, deletions, restores, Reorganize steps, sequence deletion, which wait while it cannot settle yet), and a scan settles it and reconciles nothing in the folder while it stays. A journal without names, from an earlier build, still decides by the frames version. (Owner review 2, R7.) | Decide by the frames version (the first version) | An upload landing after a failed undo could make the recovery complete a swap that never happened; what the sidecar lists tells whether it was written. |
| 2026-10-26 | Undo is restoring the replaced entry. While every converted frame still holds its conversion (re-hashed) and names the original as its `source`, the originals swap back through `FrameTrash.ReplaceAsync` (same ids; the converted files into a replaced entry in turn, without a job id; the entry's copy of `analysis.json` back into the sequence); otherwise they come back as a new sequence, and an entry left without photos drops its analysis copy. The desktop's toast of a finished Replace (all its endings Replace conversions, none failed) offers *Undo*, once and never from the Windows notification, which restores exactly the replaced entries that job made (`PhotoTrashRecord.JobId`, `TrashEntry.JobId`), oldest first; a failed Replace keeps its Retry; later, after a restart and on the panel, the trash's *Restore* does the same. (Owner review 2, R7.) | Refuse the restore when frames changed; find the job's entries by time window (the first version); record the entries in the job | Nothing is ever lost and the API stays one call; the job's id is exact where a time window could take the entry of converted files a restore made meanwhile; a failed conversion usually needs its retry. |
| 2026-10-26 | (Partly superseded by the 2026-11-03 deleted on the archive's word, erasure record, kept reasons and sidecar walk rows: a conversion is deleted only on a tombstone, the trash or an erasure record, never inferred from absence; more kept reasons, each with its advice; one walk per dry run or emptying.) Replaced entries emptying: an emptying weighs a replaced entry against the archive on disk, never this host's index alone (`SequenceTrash.Replaced`). Its sequence is found by its sidecar (in the folder the index has, in the one the entry recorded, in its deleted folders in the trash, else by walking the archive's folders; each sidecar indexed once per survey) and followed through its replaced tombstones (up to 8 links), and each conversion must still hash to its SHA-256 where it is. A conversion counts as deleted only when the sidecar shows it (a deleted tombstone at the end of the chain, or the frame gone while every frame is hashed and no photo of the folder is unlisted), when the sequence is in the trash, or when no sidecar of it exists and the index has no row; the dry run then marks the entry `ConversionDeleted` (part of its fingerprint), every copy the trash still holds must hash to the conversion, and with none left the confirmed emptying erases it. The erase holds the entry's lease and the sequence's: it settles the sequence first (an undo waiting for the entry completes), reads, measures and fingerprints the entry again, then surveys and re-hashes. Kept, each with its log line (`TrashKeptReason`): changed after the plan, its sequence busy, a conversion that no longer matches (also a frame whose file changed since), a conversion the archive cannot locate (scan the archive). (Owner review 2, R7.) | Decide from this index (fix round 1); keep such entries for ever (the first version) | A conversion another host made, or one this index had not read yet, would be taken for deleted and its originals erased without re-hashing it; when a conversion really is gone, the originals may be the last copy and must be erasable on purpose, never by mistake. |
| 2026-10-26 | Every entry that may hold the last copy of its photos is shown with why before the typed confirmation: the desktop's *Empty…* names every `ConversionDeleted` entry first ("conversion deleted"), wherever the newest-first trash lists it, the others filling the six lines and the rest counted, and a confirmation's detail scrolls past 288 px; the panel lists those entries first, each saying so. (Owner review 2, R7.) | The six newest entries, as for every other confirmation | The number typed must follow a look at what may be lost for good, however old the conversion is. |
| 2026-10-26 | Sync aliases: `SyncTombstones` takes every replaced tombstone of either side as a link between two encodings of one photo and joins them (union-find); each SHA-256 compares as the ordinal-smallest of its photo's, whatever the order of the links, so a conversion, a conversion of it, its undo and each side converting its own copy stay one photo; a deletion on either side covers every encoding. It is immutable once made, so parallel transfers share it. (Owner review 2, R7.) | One alias per original, followed up to 8 steps (R6) | Converting on both sides made duplicate frames on both. |
| 2026-10-26 | Linking by content (`SyncService.SameOriginalsAsync`), the proxies this PC can send (`SyncRules.ProxiesToSend`, `SyncTransfers.SendProxiesAsync`: a frame this PC converted makes the proxy of the server's original) and downloads follow the aliases. A download for a frame flagged missing here whose photo the server holds only in another encoding (neither its own encoding there nor an intact frame of it here) puts the verified copy in that frame's place (`FrameTrash.ReplaceMissingAsync`: the same id, nothing to the trash, the record read from the file with the old one as its `source`, a replaced tombstone), after the transfers and only once the sequence is in the folder the index has, else the copies stay staged and the job fails with the folder-moved error; each swap queues the passes it cleared, those already queued skipped; a frame that changed meanwhile keeps its place, and the copy is dropped and logged. The job log lines of uploads and downloads are resources. (Owner review 2, R7.) | File the other encoding as a frame of its own | No photo is doubled and none stays missing. |
| 2026-10-26 | The ingest answers content a replaced tombstone of the sequence names, followed through later conversions to an intact frame, as a duplicate of that frame and keeps the tombstone: a card or a folder imported again, a download of the original, an upload sent with `restore`; once no replacement is intact, the original is filed again. An upload without `restore` is still answered as deleted (R6). The ingest settles a restore and a replacement of the sequence first and files nothing while one cannot settle (`LeaseUnavailableException`; an upload's client tries again). The card erase still keeps the card copy, the bytes differing. (Owner review 2, R7.) | File the original again beside its conversion, as before | Importing a card again would double every converted photo and drop the link that makes sync count both as one; frames must not be filed beside a swap no writer has settled. |
| 2026-10-26 | Conversion plan cache: `ReorganizePlanCache` becomes `PlanCache`, one singleton for Reorganize and Convert with typed keys (`PlanKey<TPlan>`: `ReorganizePlanKey`, `ConvertPlanKey`, each naming the exceptions that are refusals, `ArgumentException` for Convert): 2 plans made at once and 8 kept across both kinds, 15 minutes to make one, 5 minutes kept, else 503 `plan_dropped`. `ConvertPlanKey` is the archive, `SequenceRepository.GetConvertStampAsync` (the Reorganize stamp and, per planned sequence, its photos' count and sums of sizes, formats, widths and heights, with how many are flagged missing, corrupt, preview-only or undecodable), the sequences (`*`, or the ids in order) and the target with its effective quality (0 for a lossless target); not the mode, which the request sets on the kept plan with its options. The busy sequences and the free space are taken again at every request; a plan made while the archive was offline is not kept (503 `archive_offline`). A confirmation takes only the plan kept for the index as it is now (`PlanCache.Kept`), else answers 503 `plan_dropped` at once, never planning inside its own request; `plan_changed` means the kept plan differs (a job made a sequence busy or free, or a conversion was queued). The panel asks a cut-off dry run again (504 or 524, or no answer or 502 after 20 s) every 2 s for up to 16 minutes and a dropped one once; its Apply asks the dry run again first (Close and Esc stay), confirms only the same fingerprint and retries `plan_dropped` once; an apply with no answer is never sent again. (Owner review 2, R7.) | Plan inside every request (the first version); plan inside a confirmation that finds no kept plan | Behind a proxy a conversion of every sequence could get past neither its dry run nor its apply; a confirmation cut off after its job was queued would invite a second job. |
| 2026-10-26 | `POST /api/v1/archive/convert` (ManageArchive): exactly one of `sequenceIds` (1–1,000) and `all`; `target` `jpeg`, `tiff16` or `linear-dng` (any case); `quality` 1–100 (default 95, checked for every target, counted for a JPEG; the panel sends null for the others); `mode` `replace` or `new-sequence`; `dryRun`; and the `fingerprint` that confirms. A dry run answers `ConvertPlanDto` (target, quality and mode; a step per sequence asked with its photos, bytes before and after, skips with their wire reason and sentence, and blocks; the totals; the space with its line; the fingerprint), `NoNativeDecoder` and `PreviewOnly` sharing the wire name `convert_on_pc`. The change answers 202 with the job, labelled with its sequence's title when it converts one, else with the archive's name. 400 `bad_request` (`sequenceIds`, `target`, `quality`, `mode`, `fingerprint`); 404 `not_found` (`sequence`); 409 `plan_changed`, `nothing_to_convert`, `not_enough_space` (details: the bytes needed), `job_unavailable`; 503 `archive_offline`, `plan_dropped`. Audited `archive_converted` ("sequences · photos · target · mode"), which the panel's log and Dashboard show as a sentence. Trash entries of kind `replaced`, and `TrashEntryDto.conversionDeleted` in an emptying's dry run. (Owner review 2, R7.) | One endpoint per mode; every photo of the plan in its answer | One request carries the choices both programs make, as Reorganize's does; a dry run of 100,000 photos answers counts and reasons, not every photo. |
| 2026-10-26 | Mass conversion is a job on both hosts: `JobKind.Convert` (stored 19, wire `convert`, labelled *Convert*), user priority, the normal level in the priority queue (listed on both hosts), its targets the sequences (deletions and other writers see them busy while it runs or is paused, and an archive-wide job, a paused Reorganize among them, holds it back), handled by `ConvertJobHandler` through `ArchiveService.CreateJobHandlers`; progress counts photos and the checkpoint only marks a resume (the journal says where). Each sequence is told as it completes, `sequenceChanged` `converted` (frames replaced) or `created` (the new sequence), and a desktop editor open on it reloads; the desktop announces its end (`JobNotices`), and the Library reads the sequences again once it ends done or failed. (Owner review 2, R7.) | Target the archive; reuse the `move` kind | Only the sequences converted wait; a failed conversion converted the others; a job is paused, resumed after a restart and followed in Jobs on both hosts. |
| 2026-10-26 | Conversion failures read as one catalog sentence by cause (BRIEF §0.2 rule 6): `ConversionException` carries a `ConversionFailure` (`NoDecoder`, `PreviewOnly`, `EightBit`, `ColorProfile`, `TooLarge`, `NotVerified`, `Changed`), which `FrameConverter.FailureText` turns into `Archive.Convert.Failed.<reason>`, as it turns a full disk (Windows HResults, ENOSPC on Linux), a denied access, undecodable data, other I/O and anything else into theirs. The job log reads "Left as it was: <title>. <file> could not be converted. <reason>" (`Archive.Log.ConvertFailed`, `Archive.Convert.PhotoFailed`), a stage B failure `Archive.Convert.NotPlaced`, a blocked sequence its reason (folder moved, photo held, sidecar unreadable, access, lease busy); the exception's English text goes to the diagnostics log only. (Owner review 2, R7.) | The exception's text in the job log (the first version) | Every string the user reads is a resource, and the technical text names internals the user cannot act on. |
| 2026-11-03 | Conversion colour: a conversion never changes what Chronos reads from a photo. Chronos's decoders (managed and WIC) never read a profile: code values go through the sRGB curve, float and LinearRaw samples are taken as they are. Every converted file holds the values they read from the original, as they read them back, within what the target holds (JPEG and TIFF-16 0..1 at 8 or 16 bits, clipped beyond; a DNG 16-bit linear values up to 4 stops above white), and says truthfully what they are (`FrameConverter.Treatment`: `None`, `Carry`, `Describe`, `Refuse`). JPEG and TIFF-16: an RGB profile's code values keep their codes and carry the profile; float values are written as sRGB codes with a profile made for them, the source's colorants and media white (to the bit) with the sRGB curve (`IccProfile.WithSrgbCurve`, version 2.1, "<description> (sRGB curve)"); a lookup-table profile named sRGB is carried, other float values in a lookup-table profile are refused; a gray profile's codes are kept and carry the gray curve on three channels with sRGB's D50 colorants (`IccProfile.GrayAsRgb`, "<description> (RGB)"); linear gray needs no profile. Synthesized descriptions are ASCII, at most 200 characters. Linear DNG holds the values as decoded and takes only values that are sRGB's as read (`IccProfile.IsSrgbFor`): untagged, an sRGB profile, float values in sRGB's primaries whatever the curve, linear gray, gray codes on the sRGB curve. Every other profile (Adobe RGB, camera JPEGs tagged Exif R03 included, Display P3 (HEIC), ProPhoto, a gamma-1.0 profile's code values) is refused as `color_profile`; TIFF-16 and JPEG convert those photos with their profile. RAWs, untagged and sRGB photos are unaffected. (Owner review 2, R7, fix round 3.) | Code float values with the profile's own curves, convert a DNG's values through the profile's matrix and a gray profile to sRGB (round 2) | Chronos reads no profile, so round 2 changed what a Replace showed: an Adobe RGB, ProPhoto or gamma-1.0 float TIFF rendered up to 2.7 EV darker or with lifted shadows, a gray photo changed tones, and a non-sRGB photo in a DNG showed more saturated (a sequence mixing converted and unconverted frames would flicker in colour). Renders, thumbnails, analyses and deflicker must see the same pixels after a Replace; a DNG's matrices are its colour, so values in another space can be neither converted nor left mislabelled. |
| 2026-11-03 | sRGB by name: `IccProfile.IsSrgb` takes a profile's name into account only when it has no rXYZ, gXYZ or bXYZ tag at all. A profile whose colorants were dropped as converting nothing, or that has no curves, is never sRGB: it is carried with code values and refused where its colorants are needed (float values into JPEG or TIFF, anything into a DNG). A lookup-table profile named sRGB is still sRGB. (Owner review 2, R7, fix round 3.) | Trust any profile named sRGB | A degenerate profile named "sRGB-elle-V4-g10" holds gamma-1.0 values, not sRGB's. |
| 2026-11-03 | Damaged values: decoded pixels holding NaN or infinite values (`FrameConverter.AllFinite`) fail the photo as `ConversionFailure.Damaged` (`Archive.Convert.Failed.Damaged`), in every target, tagged or untagged, and nothing is written; like any failed photo, its sequence stays as it was (all or nothing). (Owner review 2, R7, fix round 3.) | Write them as black | A damaged float file turned black, and in a DNG spent the headroom; with Replace it would have taken the original's place. |
| 2026-11-03 | Size bounds: `ConvertPlanner.TooLarge` compares W·H with `MaxSamples`/3 without multiplying past a long; `WorstBytes` and `EstimateBytes` saturate at `long.MaxValue`. So damaged header sizes (sides up to int.MaxValue) are `too_large` for every target. The too_large sentences say "larger than this format holds or Chronos reads back" (en, it). (Owner review 2, R7, fix round 3.) | Multiply as before | A product that wrapped around let an absurd size pass as a small one. |
| 2026-11-03 | Flagged frames: in `ConvertPlanner.Skip` a frame flagged `Corrupt` is undecodable everywhere, and one flagged `Undecodable` only where the conversion's decoders have no native provider besides the managed one for its format. Where they do (WIC on a PC), it is planned when its header probe is native and a 64-px decode by those decoders gives native pixels, else it stays undecodable; a read error during that decode is `Inaccessible`. The tier recorded is unchanged: the server still flags CMYK and CIELab TIFFs, which keeps them out of its renders and out of a PC's renders too; only the conversion asks again. (Owner review 2, R7, fix round 3.) | Trust another host's flag | The server flags a CMYK TIFF its reader refuses; a PC reads it through WIC and must be able to convert it. |
| 2026-11-03 | WIC TIFF refusal: `WicDecoderProvider` reads a TIFF's first IFD (WIC's frame 0) and refuses it when its compression is not 1, 2, 3, 4, 5, 7, 8, 32773 or 32946, its predictor is other than 1, or 2 on integer samples, or its integer samples exceed 16 bits. `Decode` then returns null in every desktop decode (renders, thumbnails, analyses, conversions), so the managed reader decodes it or it is unavailable. Checked on Windows 11: WIC decodes the compressions listed; others (ZSTD, JPEG 2000, LERC, LZMA, WebP, unknown codes) come out as zeros without an error, and 6, 34661, 34676 and 34677 raise one; it undoes only predictor 2 on integer samples (Photoshop's floating-point predictor 3 gives NaN or noise) and reads 32-bit integer samples as floats. (Owner review 2, R7, fix round 3.) | Trust what WIC returns | WIC returns a picture without an error for what it does not decode: the desktop showed black or noise, and a Replace would have converted it so. |
| 2026-11-03 | Header probes: `IImageDecoderProvider.WithHeaderProbes()` (the provider itself by default; the managed provider's `ReadsHeaders` twin; WIC's a twin on the same codec snapshot) gives a conversion's decoders probes that open the file. WIC's reads the decoder WIC picks (the Raw Image Extension for a RAW), applies the TIFF refusal, reads the first frame's upright size and checks that its pixel format converts; anything else WIC answers is unavailable, with a reason. An error opening the file propagates: not found is missing, a sharing violation or denied access is inaccessible. Imports and analyses keep the probes that open nothing. (Owner review 2, R7, fix round 3.) | WIC's probe by codec alone | A file only WIC reads, whose size the index did not know, was found too large only when it converted; a held file must not be planned as unreadable. |
| 2026-11-03 | Stage A space: before each photo the job reserves that photo and every photo handed to the work whose converted file has not landed yet (converting or waiting for a slot, up to twice the parallelism), scaled by how far this run's staged files came out above their estimates, with the 15 % margin and the 512 MiB reserve (`MassConverter.SpaceWatch`: `Start`, `Writing`, `Ended`, the free space injected). A photo stops counting once its target file appears, or replaces the file there when it started (by size and write time). (Owner review 2, R7, fix round 3.) | That photo and those after it that may convert at once (round 2); each photo until its work ends | Near the end of a sequence round 2 counted one photo while up to twice the parallelism were still converting, so a volume filling meanwhile could go into the reserve. A file lands whole, by a rename, before it is verified: counting it until its verify ends would count it twice. |
| 2026-11-03 | Confirmed photos file: the confirmed frame ids live in `.chronos/journal/convert-<job>.photos` (`ConfirmedPhotos`: JSON lines, one per sequence, the ids in plan order, 16 bytes each in base64), written whole by `MassConverter.QueueAsync` before the job is queued, under an id chosen first (`ArchiveJobRequest.Id`, `JobEngine.EnqueueAsync(Guid id, …)`), and deleted if the enqueue throws. The job row keeps each sequence's id, frames version and digest (`ConvertSequence`), so it grows with the sequences, not the photos. Without the file (not writable, or a job a round 2 build queued with `photos` in its parameters, now ignored) the job holds each sequence to its whole plan made again. The file goes with the journal (`ConvertJournal.Files`) and maintenance treats it as one of its files. What reads job rows: the busy check (`SequenceTrash.BusyAsync`) only ids, kinds, targets and a Verify's parameters (`JobRepository.ListHoldsAsync`), the asking job excluded in SQL; a conversion's re-plan only its own creation time (`GetCreatedAsync`); the server's job list, the admin dashboard and the engine's claim and review peeks rows without parameters (`ListBriefAsync`, `ListQueuedBriefAsync`). The desktop Jobs page still reads whole rows. (Owner review 2, R7, fix round 3.) | Keep the ids in the job's parameters (round 2) | About 21 MB of ids for a million photos was read by every dry run's busy check, by each sequence turn of the conversion and by the job lists; the reads grew with the square of a job's size. |
| 2026-11-03 | New sequence retries: the journal names the copy as soon as its photos are filed (`ConvertJournal.Made`; a later note keeps it). A retry or resume that finds the job's own copy (by the journal, else by its session key) holding the converted file of every pinned photo finishes it (`FinishCopyAsync`: the source's tags, rating, notes and project, follow-ups, outcome `Created`), whatever changed in the source since. A copy the job made and that was deleted since is not remade (`Changed`: plan again). The retry's opening space check does not count photos already filed into its copy. (Owner review 2, R7, fix round 3.) | Report the sequence changed and plan again (round 2) | The copy was left orphaned and the new plan made a second one. |
| 2026-11-03 | Superseded copies: new outcome `ConvertOutcome.Superseded`. A New sequence job makes no copy of a source when another conversion job (session key `convert:<other>:<source>`) made a copy holding frames of this job's format after this job was confirmed (the copy's sidecar `Created` against the job's creation time, `ConvertRequester.Confirmed`) and that job is `Done`; the log says so (`Archive.Log.ConvertSuperseded`), and the job ends Done if the rest converted. While the other job is not done (it failed while filing its copy, or still runs), the sequence is `Blocked` with `Archive.Convert.CopyUnfinished`: no second copy, and not done with. A conversion confirmed after a copy already existed makes its own (the user asked again); a copy in another format does not count. (Owner review 2, R7, fix round 3.) | Copy again; let any later copy supersede, whatever its job's state | Job A failed, job B copied the same source, and retrying A made a duplicate; a copy whose job has not finished may be partial and cannot stand for this one. |
| 2026-11-03 | Deleted on the archive's word: an emptying calls a replaced entry's conversion deleted only on positive evidence: a `Deleted` tombstone ending its chain in the sequence's sidecar, the sequence in the trash, or the trash's erasure record of the sequence. `SequenceHoldings.Classify` no longer infers it from "every frame hashed, none holds it", and a sequence with no sidecar anywhere and no row in this index is no longer gone. A sidecar that holds none of the conversion and no tombstone of it (one rebuilt by adoption keeps only this index's ids and tombstones), or a sequence found nowhere without an erasure record (the walk may have skipped its folder: photos without a sidecar, or a folder it cannot enter), keeps the entry, and a kept entry is never flagged `ConversionDeleted`. The erasure record outweighs a stale row of this index; a live sidecar found anywhere outweighs the record. (Owner review 2, R7, fix round 3.) | Infer deletion from absence (round 2) | After a routine verify of a rebuilt sidecar, a damaged conversion still in its folder counted as deleted: the dry run called the originals the last copy and the emptying erased them. |
| 2026-11-03 | Erasure record: `.chronos/trash/.erased/<sequence id N>.json` (`ErasureRecord`: sequence id, title, entry, erased at, erased by). An emptying writes it before a deleted sequence's folder goes, only while a replaced entry of that sequence is listed, and never while the sequence also lives (this index has a row of it in this archive, or the walk finds a folder whose sidecar names it: a folder copied back and adopted, a second deletion of the same id). Each emptying ends by deleting the records no listed replaced entry needs. The trash listings never see the folder. A sequence entry erased by an earlier build leaves no record, so its replaced originals stay until restored (phase 4b is unreleased). (Owner review 2, R7, fix round 3.) | Nothing on disk; take a missing sequence as gone | Once the folder is gone, only the archive can tell a later emptying, or another host, that the conversions went with the sequence; a record beside a live copy would outlive what it says and let a walk that misses that folder erase originals whose conversion is still there. |
| 2026-11-03 | Kept reasons: `TrashKeptReason` gains `Unhashed` (`Archive.Log.TrashKeptUnhashed`: a frame that may hold the conversion was never verified; verify the sequence), `Unreadable` (`TrashKeptUnreadable`: a sidecar of a folder that may hold the sequence is missing or unreadable; scan the archive) and `StaleIndex` (`TrashKeptStaleIndex`: the index lists a sequence the archive no longer holds and nothing records erasing it; rebuild the index); `Unknown` now says "restore it to keep them". A frame flagged missing or corrupt and never hashed counts as `Unknown`, not `Unhashed`: no verify hashes it (a verify does not hash a file whose size differs from its record). A rebuild drops only the row: without an erasure record the entry then shows `Unknown`, and its restore brings the originals back as a new sequence. (Owner review 2, R7, fix round 3.) | One line for a conversion that cannot be located (round 2) | Each kept entry must name the step that settles it, never one that cannot. |
| 2026-11-03 | Sidecar walk: a dry run or an emptying walks the archive's sidecars at most once (`SidecarWalk`: sequence id to folders, the first unreadable sidecar kept). An emptying shares one walk between its plan and every erase, so nothing walks the archive under a lease, and walks again once per lookup only when a folder it found no longer holds the sequence; still moving after that, the entry is kept as Busy. A stale walk can only keep an entry, never erase one. (Owner review 2, R7, fix round 3.) | A survey per entry (round 2) | Each erase walked the whole archive again while holding the entry's and the sequence's leases. |
| 2026-11-03 | Download follow-ups: `SyncTransfers.QueuePassesAsync` queues every pass a download needs, a frame swap's included, with `CancellationToken.None` through the new `JobContext.EnqueueFollowUpAsync(…, CancellationToken)`, as `FrameTrash.RestoreAsync` does. (Owner review 2, R7, fix round 3.) | The job's own token | A Stop right after a swap dropped the passes it cleared, leaving frames without thumbnails, proxies or analyses. |
| 2026-11-03 | Confirmation detail keyboard: the desktop confirmation's detail (`DetailScroll`) is focusable and a Tab stop, through a style trigger, only while its vertical scroll bar shows (a detail longer than its 288 px), with the focus ring, the detail's tooltip and accessible name; the arrow, page and Home/End keys scroll it. (Owner review 2, R7, fix round 3.) | Always a Tab stop; the mouse only | A long list of entries that may hold the last copy of their photos must be readable from the keyboard; a detail that fits needs no stop. |
+16 -13
View File
@@ -16,7 +16,7 @@ by its `windows` job once a Windows runner is registered (`WINDOWS_RUNNER`), and
| 8 Release readiness | Release pipeline end to end (installers, portable and server zips, SHA256SUMS, release notes, optional signing, server image in the Gitea container registry, optional separate releases repository), update check with verified download, scrubbed diagnostics bundles (desktop and server), performance gates, 38 cultures (`en`, `it` and 36 machine translations with glossaries and independent reviews), RTL pass (`ar`, `he`: mirrored windows, left-to-right islands for media, charts, numbers and paths; any right-to-left culture added later follows), accessibility pass (names, live regions, keyboard paths for charts and the curve editor). The installer test (silent install of the packed installers, run, upgrade in place, uninstall: files, Add/Remove Programs, shortcuts, file type, user data kept, exit codes) runs in CI's `windows` job on a Windows runner. Pending: the interactive install on a real PC, Unraid template validation on a real server. |
| 8.1 Owner review 1 | In progress (request, answers and plan: `docs/requests/2026-10-15-owner-review-1.md`). Phase 1 done: stalled thumbnail and proxy jobs no longer fail and stay Running (frame-counted progress, bounded time left, final state always written); the editor's cancelled decodes stay in their tasks (no debugger stops in `WicDecoderProvider.cs`); WIC decodes RAW only through the Raw Image Extension and never DNG; GoPro DNGs converted by Adobe software are DNGs, developed natively for videos, read through their embedded preview for analyses and previews, and reclassified in existing archives by the next light analysis. Phase 2 done: jobs run one at a time on the desktop and the server; Parallelism is how many photos the running job processes at once (thumbnail and proxy passes, tier probes, deep analysis, render decodes); pausing the running job starts the next; an optional priority queue by job kind (Settings › Rendering, admin panel › Settings › Jobs, `CHRONOS_PRIORITY_QUEUE`) pauses lower jobs and resumes them by themselves; `CHRONOS_PARALLELISM` replaces `CHRONOS_WORKERS`. Phase 3a done: the rail is 200 px and collapses to icons with ≡ or Ctrl+B (tooltips then name the sections, the choice saved at once); the admin panel's sidebar is 256 px and collapses the same way. Phase 3b done: the Sequence section is now Edit, one sequence at a time chosen in a picker inside the section (Change sequence, Ctrl+O; the sequence edited last selected first), and the editor's tabs are the steps of a guided, freely navigable path from a new Analysis step (every finding with the step that deals with it) to Export, each step showing where it stands, with Previous and Next. Next, after owner review 2 (the owner's order): phase 4, the visual crop locked to the output's proportions (R5) and mirroring, 90° rotations, straightening and colour filters (R6). |
| 8.2 Chronos on Gitea | Done (request: `docs/requests/2026-10-23-chronos-gitea.md`): Titano renamed Chronos everywhere, translations' grammar included; repository, update check, links, issue forms and registry moved to the self-hosted Gitea; Gitea Actions CI, release, nightly image and performance workflows for the Linux runner, with the Windows programs cross-compiled and checked (`pe-check`); new `Chronos.Tools` commands `zip`, `gitea-release`, `postgres-ci`, `pe-check`. Pre-releases `v0.1.0-rc.1` and `v0.1.0-rc.2` (the update check builds its links from `ChronosReleasesUrl`, since Gitea's use its LAN ROOT_URL) published; `REGISTRY_TOKEN` is set and the `v0.1.0-rc.2` server image is in the registry. |
| 8.3 Owner review 2 | In progress (request, answers and plan: `docs/requests/2026-10-26-owner-review-2.md`). Phase 1 done and released as `v0.1.0-rc.3` (one adversarial review round, 19 findings fixed; strings in all 38 languages): `:latest` follows the highest stable release, or the highest pre-release while none is stable (`Chronos.Tools release-channels`), `:nightly` stays the nightly build of `main` (R1); `CHRONOS_SPACE_PATH` and the Unraid template's *Array view* (`/mnt/user0/<share>` read-only at `/space`) make the admin panel show the array's free space, the cache apart as *Write volume*, the file system in the tooltip, and completing an upload checks the archive volume first (507, resumable) (R2); the Settings icon is a toothed gear and the admin panel docks Settings at the foot of its sidebar (R4); About is the last page of Settings on the desktop and the last group of Settings on the admin panel (R5); Import › Folder… › *Whole folder* imports a folder as one sequence per format, titled after the folder (R9). Phase 2 done and released as `v0.1.0-rc.4` (one adversarial review round, 35 findings fixed; strings in all 38 languages): scheduled jobs (R10) — schedules (migration 0007) with an in-house recurrence form, one scheduler per host claiming runs by compare-and-set with catch-up, and Jobs › Scheduled on the desktop and the admin panel (`/api/v1/schedules`, `scheduleChanged`); every timer that queued work is a visible system schedule (server: archive scan, upload clean-up every 6 h, index backup at 03:00, job history and audit log clean-ups; desktop: archive scan, daily index backup, housekeeping with cache trim), the archive still scanned at start; new Backup and Clean-up jobs, duplicates and orphans reports as jobs, one backup retention, the trash only reported; log settings (R11) — file and console levels, retention, file and total size limits, daily or hourly rotation, audit retention (the audit clean-up schedule's) and the diagnostics share in the admin panel's Settings › Logs (`CHRONOS_LOG_*`, `lockedBy`) and the desktop's Settings › Advanced; the server's files take Debug and Trace again, and logging never fails a job. Phase 3 done and released as `v0.1.0-rc.5` (one adversarial review round and two fix rounds, 40 findings fixed; strings in all 38 languages; Library, photo delete and restore and the web upload tried by hand): the admin panel manages and never edits (R6) — a Library page (facets filters, cards or list, keyboard selection, mass Analyse, Proxies, Thumbnails, Verify, Tags, Export CSV and Delete, 1,000 sequences a request), a sequence's page (inline title, tags, rating, notes, photo viewer, cover, downloads, photo delete) and the trash view (Restore, Empty… behind a dry run, the typed word and a fingerprint); photos deleted into `trash/photos` under crash-safe journals with tombstones in the sidecar and `frame_removals` (migration 0008), so sync and uploads never bring them back unless restored or uploaded again on purpose; trash kinds, restore reasons and the `EmptyTrash` job on the desktop's Trash… too (typed entry count); the panel's files revalidated (`no-cache`, ETag); upload from the panel (R3) — file picker or drop, no folders, a self-tested in-house SHA-256 in a module worker, Exif capture time, resumable chunks. Known limitations: a never-hashed photo whose file was already missing is deleted without a tombstone; an unhashed server frame of a photo deleted on a PC stays *missing here* until the server verifies it; `jobState` carries no kind, so panel pages refresh after any job. Phase 4a done and released as `v0.1.0-rc.6` (one adversarial review round and six fix rounds; strings in all 38 languages): Reorganize after import (R7) on the desktop (Archive manager, Library, the toast after Settings › Archive templates change; it replaces Rename… and Move…) and the admin panel (Library, the *Saved* toast of Archive) — folder, file and title templates applied to filed sequences behind a dry run that lists every change, the photos that keep their names and why (in place, never verified, missing) and the sequences that stay whole (unreadable sidecar), applied by the `move` job of exactly the confirmed plan (fingerprint, `POST /api/v1/archive/reorganize`, plans kept a few minutes on the server), which holds the rest when paused, cancelled or failed (also while the archive is offline), lets a sequence still receiving photos keep its file names and takes along a sequence left as it was inside a folder that moves; files renamed in two phases under `.chronos/rename-files.json`, completed after a crash by the next writer; the index, frames and exports follow a moved folder in one transaction, here and at another index's next scan, and writers never create a folder a Reorganize left nor write into one another sequence took; import, upload and Reorganize name photos by one rule (the sequence's camera and lens), and templates follow one set of rules everLine truncated
| 8.3 Owner review 2 | In progress (request, answers and plan: `docs/requests/2026-10-26-owner-review-2.md`). Phase 1 done and released as `v0.1.0-rc.3` (one adversarial review round, 19 findings fixed; strings in all 38 languages): `:latest` follows the highest stable release, or the highest pre-release while none is stable (`Chronos.Tools release-channels`), `:nightly` stays the nightly build of `main` (R1); `CHRONOS_SPACE_PATH` and the Unraid template's *Array view* (`/mnt/user0/<share>` read-only at `/space`) make the admin panel show the array's free space, the cache apart as *Write volume*, the file system in the tooltip, and completing an upload checks the archive volume first (507, resumable) (R2); the Settings icon is a toothed gear and the admin panel docks Settings at the foot of its sidebar (R4); About is the last page of Settings on the desktop and the last group of Settings on the admin panel (R5); Import › Folder… › *Whole folder* imports a folder as one sequence per format, titled after the folder (R9). Phase 2 done and released as `v0.1.0-rc.4` (one adversarial review round, 35 findings fixed; strings in all 38 languages): scheduled jobs (R10) — schedules (migration 0007) with an in-house recurrence form, one scheduler per host claiming runs by compare-and-set with catch-up, and Jobs › Scheduled on the desktop and the admin panel (`/api/v1/schedules`, `scheduleChanged`); every timer that queued work is a visible system schedule (server: archive scan, upload clean-up every 6 h, index backup at 03:00, job history and audit log clean-ups; desktop: archive scan, daily index backup, housekeeping with cache trim), the archive still scanned at start; new Backup and Clean-up jobs, duplicates and orphans reports as jobs, one backup retention, the trash only reported; log settings (R11) — file and console levels, retention, file and total size limits, daily or hourly rotation, audit retention (the audit clean-up schedule's) and the diagnostics share in the admin panel's Settings › Logs (`CHRONOS_LOG_*`, `lockedBy`) and the desktop's Settings › Advanced; the server's files take Debug and Trace again, and logging never fails a job. Phase 3 done and released as `v0.1.0-rc.5` (one adversarial review round and two fix rounds, 40 findings fixed; strings in all 38 languages; Library, photo delete and restore and the web upload tried by hand): the admin panel manages and never edits (R6) — a Library page (facets filters, cards or list, keyboard selection, mass Analyse, Proxies, Thumbnails, Verify, Tags, Export CSV and Delete, 1,000 sequences a request), a sequence's page (inline title, tags, rating, notes, photo viewer, cover, downloads, photo delete) and the trash view (Restore, Empty… behind a dry run, the typed word and a fingerprint); photos deleted into `trash/photos` under crash-safe journals with tombstones in the sidecar and `frame_removals` (migration 0008), so sync and uploads never bring them back unless restored or uploaded again on purpose; trash kinds, restore reasons and the `EmptyTrash` job on the desktop's Trash… too (typed entry count); the panel's files revalidated (`no-cache`, ETag); upload from the panel (R3) — file picker or drop, no folders, a self-tested in-house SHA-256 in a module worker, Exif capture time, resumable chunks. Known limitations: a never-hashed photo whose file was already missing is deleted without a tombstone; an unhashed server frame of a photo deleted on a PC stays *missing here* until the server verifies it; `jobState` carries no kind, so panel pages refresh after any job. Phase 4a done and released as `v0.1.0-rc.6` (one adversarial review round and six fix rounds; strings in all 38 languages): Reorganize after import (R7) on the desktop (Archive manager, Library, the toast after Settings › Archive templates change; it replaces Rename… and Move…) and the admin panel (Library, the *Saved* toast of Archive) — folder, file and title templates applied to filed sequences behind a dry run that lists every change, the photos that keep their names and why (in place, never verified, missing) and the sequences that stay whole (unreadable sidecar), applied by the `move` job of exactly the confirmed plan (fingerprint, `POST /api/v1/archive/reorganize`, plans kept a few minutes on the server), which holds the rest when paused, cancelled or failed (also while the archive is offline), lets a sequence still receiving photos keep its file names and takes along a sequence left as it was inside a folder that moves; files renamed in two phases under `.chronos/rename-files.json`, completed after a crash by the next writer; the index, frames and exports follow a moved folder in one transaction, here and at another index's next scan, and writers never create a folder a Reorganize left nor write into one another sequence took; import, upload and Reorganize name photos by one rule (the sequence's camera and lens), and templates follow one set of rules everLine truncated
| 9 Monetization | Not started: requires explicit approval (§22). |
## Verification (2026-10-12)
@@ -91,6 +91,10 @@ src/Chronos.App/bin/Release/net10.0-windows/Chronos.exe --capture out/screenshot
change, and *Apply* queues the *Reorganize* job (pause and resume it in Jobs).
Admin panel: Library › select sequences › *Reorganize…* › *Apply…* › *Reorganize* › *Open job*; or Archive › change
the file template › *Save* › *Reorganize…* in the toast.
- Convert: desktop Archive › select a year › *Convert…* › Linear DNG, *Replace* › *Apply* › type the number of photos ›
*Replace*; when the job ends, *Undo* in its toast brings the originals back (later: Maintenance › *Trash…*).
Admin panel: Library › select sequences › *Convert…* › JPEG, *New sequence* › *Convert…* › *Convert* › *Open job*:
the copies appear as "… (JPEG)"; with *Replace*, type "replace", and the trash's *Restore* swaps the originals back.
- Project files: Export › *Save project file* writes a `.chronos` file; opening it (double-click or `Chronos.exe <file>`)
opens the sequence with those settings in the running Chronos.
- Notifications: minimise Chronos and insert a card or finish a job: a Windows notification appears; Ctrl+1…6 and
@@ -104,27 +108,26 @@ src/Chronos.App/bin/Release/net10.0-windows/Chronos.exe --capture out/screenshot
Owner reviews, in the owner's order (owner review 2 first, then the rest of owner review 1); each phase ends with a
release (owner review 2, R12):
1. Owner review 2, phase 4b: R7 mass conversion.
2. Owner review 2, phase 5a: R8 workspace and projects with a local home (migration 0009).
3. Owner review 2, phase 5b: R8 server home.
4. Owner review 2, phase 5c: R8 originals, local render, clean-up, Workspace settings.
5. Owner review 1, phase 4: R5 visual crop locked to the output's proportions, R6 mirroring, 90° rotations,
1. Owner review 2, phase 5a: R8 workspace and projects with a local home (migration 0009).
2. Owner review 2, phase 5b: R8 server home.
3. Owner review 2, phase 5c: R8 originals, local render, clean-up, Workspace settings.
4. Owner review 1, phase 4: R5 visual crop locked to the output's proportions, R6 mirroring, 90° rotations,
straightening and colour filters (project settings in the workspace).
6. Owner review 1, phase 5: R3 export panel and Render menu, R8 export options, R9 videos library.
7. Owner review 1, phase 6: Docker, Unraid and deploy docs, BRIEF §24 amendments, full verification.
5. Owner review 1, phase 5: R3 export panel and Render menu, R8 export options, R9 videos library.
6. Owner review 1, phase 6: Docker, Unraid and deploy docs, BRIEF §24 amendments, full verification.
Phase 8 gate:
8. Visibility: make the `BalboSoft` organisation (and its packages) public, or publish to a public `RELEASES_REPO`, so
7. Visibility: make the `BalboSoft` organisation (and its packages) public, or publish to a public `RELEASES_REPO`, so
that people without an account can download releases, get update notices and pull the image.
9. Windows runner: register an act_runner in host mode on a Windows PC (.NET SDK, Git for Windows, PowerShell 7) and
8. Windows runner: register an act_runner in host mode on a Windows PC (.NET SDK, Git for Windows, PowerShell 7) and
set the repository variable `WINDOWS_RUNNER` to its label. Then arm the screenshot diff: from the `ci-screenshots`
commit of the first green `windows` job of a pull request, run `dotnet run --project src/Chronos.Tools --
screenshots accept <dir>` and commit the PNGs to `tests/visual/baselines` (its README says how). From then on a
visual change, or a screen without a baseline, fails the `windows` job.
10. On Windows: install the latest pre-release's setup, upgrade over the previous version, uninstall (with and without
9. On Windows: install the latest pre-release's setup, upgrade over the previous version, uninstall (with and without
user data), silent mode.
11. Unraid: install the template as a user template (README › Server image, Compose and Unraid) with the official
10. Unraid: install the template as a user template (README › Server image, Compose and Unraid) with the official
PostgreSQL template, check that its icon (the SVG of `branding/`) shows, reach the WebUI, and that the Dashboard
shows the array's free space through *Array view*.
12. Native-speaker review of the machine translations where users report wording (`i18n export` per language).
11. Native-speaker review of the machine translations where users report wording (`i18n export` per language).
+2 -2
View File
@@ -72,8 +72,8 @@
| 1 | R1 `:latest`, R2 array space, R4 gear and Settings at the bottom, R5 About inside Settings, R9 whole-folder import | done 2026-10-26, released as `v0.1.0-rc.3`: BRIEF §12.1, §12.4, §12.8, §12.9, §13, §14.4, §14.8, §14.9, §19.3, §19.5, §19.6, §24; 12 DECISIONS rows dated 2026-10-26 (R1 `:latest` and `release-channels`; R2 space path, mountinfo file system, fall-back warning, write volume, 507 at completion, `VolumeSpace`; R4/R5 admin menu and About group; R4 gear icon and `icons.py` generating `icons.js`; R5 desktop About page; R9 whole-folder grouping and its session key); CHANGELOG [Unreleased]; STATUS 8.3. `:latest` appears with the next pre-release: re-publishing `v0.1.0-rc.2` builds the tag's `Chronos.Tools`, which lacks `release-channels` | `1f089888` |
| 2 | R11 log settings, R10 scheduled jobs (migration 0007) | done 2026-10-27, released as `v0.1.0-rc.4` (one adversarial review round, 35 findings fixed; strings in all 38 languages): BRIEF §5, §6.2, §7, §12.5, §12.6, §12.8, §14.1, §14.3, §14.6, §14.8, §14.9, §19.6, §24; 30 DECISIONS rows dated 2026-10-26 (R10 text recurrence form instead of cron, compare-and-set claim, system schedules seeded once, the timers they replace, catch-up, live services that are not schedules, the trash only reported, history and audit purges in clean-ups, one audit retention, scan at start, deep analysis read at run time, 6-hour upload sweep, Scheduled as a Jobs tab, Backup and Cleanup job kinds, 500 sequences per job, index backups and one backup retention, the archive.json timer, schedule API and audit, `scheduleChanged`, time zone, cache trim, desktop toasts, texts and archive reopening; R11 log defaults, rotation and pruning, the Debug/Trace fix, `CHRONOS_LOG_LEVEL` locking both levels, the log settings DTO and desktop rows, logging that never fails a job), six earlier rows marked superseded; CHANGELOG [Unreleased] with the `CHRONOS_LOG_LEVEL` and migration 0007 upgrade notes; STATUS 8.3 | `af9eeaab` |
| 3 | R6 library on the panel, photo delete and trash (migration 0008), R3 web upload | done 2026-10-27, released as `v0.1.0-rc.5` (one adversarial review round and two fix rounds, 40 findings fixed; strings in all 38 languages; tried by hand in a browser): BRIEF §5, §7, §12.2, §12.5, §14.3, §14.4, §14.5, §14.8, §24; 24 DECISIONS rows dated 2026-10-26 (R6 photo trash layout, deletion journal and hidden pending record, restore journal and `.restoring` staging under the entry lease, restore rules and kept reasons, tombstones in sidecar and index, never-hashed photos hashed at deletion with the missing ones left without a tombstone as a known limitation, positions and follow-ups, Empty only as an explicit job with a fingerprint and never scheduled, trash API and audit, photo-delete permission and body limit, bulk limits of 1,000 a request and the verify fix, the upload tombstone checks and the explicit restore flag, sync tombstones and aliases, hidden dot files refused, Library navigation and the on-demand upload module, facets and covers, panel confirmations, CSV and grids, live refresh without job kinds, static files `no-cache` with ETag; R3 in-house SHA-256 worker, fail-closed self-test, no folder upload and `server/info` extensions, upload pacing and capture time, Cancel deletes and Close keeps); CHANGELOG [Unreleased] with the migration 0008 upgrade note and the known limitations; STATUS 8.3 | `9aa818ed` |
| 4a | R7 Reorganize after import | done 2026-10-27, released as `v0.1.0-rc.6` (one adversarial review round and six fix rounds; strings in all 38 languages): BRIEF §5, §7, §7.1, §12.2, §12.5, §12.8, §13, §14.3, §14.5, §14.8, §24; 25 DECISIONS rows dated 2026-10-26 (R7 one naming rule `FrameNaming` for import, upload and Reorganize; what Reorganize renames and what stays whole; unique names in index order and XMP companions; the two-phase file journal; step order and checks under the leases; the fingerprint pinning file renames by digest; sequences still receiving photos; a sequence left inside a moving folder taken along; Reorganize as the `move` job with held plans; the whole-plan tally and errors; `sequenceChanged` `reorganized` and the editor reload; exports rebased with their folder; the rows of a sequence that took the old folder never follow; writers under the lease and render filing's 503; a folder another sequence holds refused by every writer; proxy lease batches; case-only and stable folders; template rules; rules held only to templates given anew; the server's plan cache; the reorganize API; panel selection and dialog; the desktop dialog and the Settings toast; render leftovers removed only where the sequence is; originals restored only where the sequence is), three earlier rows marked superseded; CHANGELOG [0.1.0-rc.6] with the template upgrade note and the known limitations; STATUS 8.3 | |
| 4b | R7 mass conversion | todo | |
| 4a | R7 Reorganize after import | done 2026-10-27, released as `v0.1.0-rc.6` (one adversarial review round and six fix rounds; strings in all 38 languages): BRIEF §5, §7, §7.1, §12.2, §12.5, §12.8, §13, §14.3, §14.5, §14.8, §24; 25 DECISIONS rows dated 2026-10-26 (R7 one naming rule `FrameNaming` for import, upload and Reorganize; what Reorganize renames and what stays whole; unique names in index order and XMP companions; the two-phase file journal; step order and checks under the leases; the fingerprint pinning file renames by digest; sequences still receiving photos; a sequence left inside a moving folder taken along; Reorganize as the `move` job with held plans; the whole-plan tally and errors; `sequenceChanged` `reorganized` and the editor reload; exports rebased with their folder; the rows of a sequence that took the old folder never follow; writers under the lease and render filing's 503; a folder another sequence holds refused by every writer; proxy lease batches; case-only and stable folders; template rules; rules held only to templates given anew; the server's plan cache; the reorganize API; panel selection and dialog; the desktop dialog and the Settings toast; render leftovers removed only where the sequence is; originals restored only where the sequence is), three earlier rows marked superseded; CHANGELOG [0.1.0-rc.6] with the template upgrade note and the known limitations; STATUS 8.3 | `7e4a3b48` |
| 4b | R7 mass conversion | done 2026-11-02, released as `v0.1.0-rc.7` (one adversarial review round, 42 findings, and two fix rounds; strings in all 38 languages): BRIEF §5, §7, §8.1, §8.3, §8.7, §9, §12.2, §12.4, §12.5, §13, §14.3, §14.4, §14.5, §14.8, §14.9, §24; 26 DECISIONS rows dated 2026-10-26 (R7 conversion after import, import still byte for byte; Replace or New sequence at every run, never remembered; targets and the scene-referred archival DNG; the conversion's decoder order, managed first and no 16-bit file from an 8-bit RAW development; the TIFF reader's refusals; colour profiles carried, converted or refused; the converted files' Exif; a dry run that probes what it promises; exactly the confirmed photos, by digest and ids; the two-stage, resumable job; the purge of staging and journals; free space measured where the conversion writes; no conversion of the same sequences twice; New sequence holding the converted copies alone, saying what it lacks; the Replace swap; the replace journal decided by content; Undo by the job's own entries; replaced entries weighed against the archive on disk; every last copy named before the typed confirmation; sync aliases as equivalence classes; link by content, proxies and downloads following them; the ingest taking a replaced original as present; the plan cache shared with Reorganize; the convert API; the `convert` job kind; failure sentences by cause), four earlier rows marked superseded in part; CHANGELOG [0.1.0-rc.7] with the upgrade note and the known limitations; STATUS 8.3 | |
| 5a | R8 workspace and projects with a local home (migration 0009) | todo | |
| 5b | R8 server home | todo | |
| 5c | R8 originals, local render, clean-up, Workspace settings | todo | |
+81
View File
@@ -9,6 +9,7 @@
<data name="Admin.About.Title" xml:space="preserve"><value>خادم Chronos</value></data>
<data name="Admin.About.Uptime" xml:space="preserve"><value>مدة التشغيل</value></data>
<data name="Admin.About.Version" xml:space="preserve"><value>الإصدار</value></data>
<data name="Admin.Activity.ArchiveConverted" xml:space="preserve"><value>أضاف {0} عملية تحويل إلى قائمة الانتظار · {1}</value></data>
<data name="Admin.Activity.ArchiveReorganized" xml:space="preserve"><value>أعاد {0} تنظيم الأرشيف · {1}</value></data>
<data name="Admin.Activity.ArchiveSettings" xml:space="preserve"><value>غيّر {0} تنظيم الأرشيف</value></data>
<data name="Admin.Activity.FramesDeleted" xml:space="preserve"><value>حذف {0} {1}</value></data>
@@ -85,6 +86,78 @@
<data name="Admin.Common.TypeToConfirm.Tip" xml:space="preserve"><value>اكتب الاسم تمامًا كما يظهر للتأكيد</value></data>
<data name="Admin.Common.TypeWord.Tip" xml:space="preserve"><value>اكتب الكلمة تمامًا كما تظهر؛ دون التمييز بين الأحرف الكبيرة والصغيرة</value></data>
<data name="Admin.Common.TypeWordFirst.Tip" xml:space="preserve"><value>اكتب الكلمة أعلاه أولًا</value></data>
<data name="Admin.Convert.Action" xml:space="preserve"><value>تحويل…</value></data>
<data name="Admin.Convert.Action.Tip" xml:space="preserve"><value>تحويل صور التسلسلات المحددة إلى JPEG أو TIFF-16 أو DNG خطي؛ وتعرض المعاينة كل تسلسل أولًا</value></data>
<data name="Admin.Convert.Apply" xml:space="preserve"><value>تحويل…</value></data>
<data name="Admin.Convert.Apply.Tip" xml:space="preserve"><value>التحويل كما تعرض المعاينة؛ ويُطلب التأكيد أولًا</value></data>
<data name="Admin.Convert.Cancel.Tip" xml:space="preserve"><value>الإغلاق دون تحويل أي شيء</value></data>
<data name="Admin.Convert.ChooseMode" xml:space="preserve"><value>اختر «استبدال» أو «تسلسل جديد» للتحويل.</value></data>
<data name="Admin.Convert.ChooseMode.Tip" xml:space="preserve"><value>اختر «استبدال» أو «تسلسل جديد» أولًا</value></data>
<data name="Admin.Convert.Column.Converted" xml:space="preserve"><value>المحوّلة</value></data>
<data name="Admin.Convert.Column.NotCopied" xml:space="preserve"><value>غير المنسوخة</value></data>
<data name="Admin.Convert.Column.Sequence" xml:space="preserve"><value>التسلسل</value></data>
<data name="Admin.Convert.Column.Size" xml:space="preserve"><value>الحجم</value></data>
<data name="Admin.Convert.Column.Unchanged" xml:space="preserve"><value>دون تغيير</value></data>
<data name="Admin.Convert.Confirm.New" xml:space="preserve"><value>تحويل</value></data>
<data name="Admin.Convert.Confirm.New.Tip" xml:space="preserve"><value>إضافة مهمة إلى قائمة الانتظار تحوّل الصور إلى تسلسلات جديدة وتتحقق من كل تحويل؛ ولا تُمس الملفات الأصلية</value></data>
<data name="Admin.Convert.Confirm.Replace" xml:space="preserve"><value>استبدال</value></data>
<data name="Admin.Convert.Confirm.Replace.Tip" xml:space="preserve"><value>إضافة مهمة إلى قائمة الانتظار تحوّل الصور وتتحقق من كل تحويل وتنقل الملفات الأصلية إلى سلة المحذوفات</value></data>
<data name="Admin.Convert.ConfirmNew.few" xml:space="preserve"><value>تُحوَّل {0} صور إلى نسخ في تسلسل جديد بجوار كل تسلسل مصدر؛ وتبقى الملفات الأصلية كما هي.</value></data>
<data name="Admin.Convert.ConfirmNew.many" xml:space="preserve"><value>تُحوَّل {0} صورة إلى نسخ في تسلسل جديد بجوار كل تسلسل مصدر؛ وتبقى الملفات الأصلية كما هي.</value></data>
<data name="Admin.Convert.ConfirmNew.one" xml:space="preserve"><value>تُحوَّل صورة واحدة إلى نسخة في تسلسل جديد؛ ويبقى الملف الأصلي كما هو.</value></data>
<data name="Admin.Convert.ConfirmNew.other" xml:space="preserve"><value>تُحوَّل {0} صورة إلى نسخ في تسلسل جديد بجوار كل تسلسل مصدر؛ وتبقى الملفات الأصلية كما هي.</value></data>
<data name="Admin.Convert.ConfirmNewNotCopied.few" xml:space="preserve"><value>لا تُنسخ {0} صور إلى التسلسلات الجديدة، للأسباب التي تبيّنها المعاينة.</value></data>
<data name="Admin.Convert.ConfirmNewNotCopied.many" xml:space="preserve"><value>لا تُنسخ {0} صورة إلى التسلسلات الجديدة، للأسباب التي تبيّنها المعاينة.</value></data>
<data name="Admin.Convert.ConfirmNewNotCopied.one" xml:space="preserve"><value>لا تُنسخ صورة واحدة إلى التسلسل الجديد، للسبب الذي تبيّنه المعاينة.</value></data>
<data name="Admin.Convert.ConfirmNewNotCopied.other" xml:space="preserve"><value>لا تُنسخ {0} صورة إلى التسلسلات الجديدة، للأسباب التي تبيّنها المعاينة.</value></data>
<data name="Admin.Convert.ConfirmNewTitle" xml:space="preserve"><value>التحويل إلى {0} في تسلسلات جديدة؟</value></data>
<data name="Admin.Convert.ConfirmReplace.few" xml:space="preserve"><value>تُستبدل {0} صور في {1} بنسخها المحوّلة؛ وتُنقل الملفات الأصلية إلى سلة المحذوفات، ويمكن استعادتها إلى أن تُفرَغ سلة المحذوفات.</value></data>
<data name="Admin.Convert.ConfirmReplace.many" xml:space="preserve"><value>تُستبدل {0} صورة في {1} بنسخها المحوّلة؛ وتُنقل الملفات الأصلية إلى سلة المحذوفات، ويمكن استعادتها إلى أن تُفرَغ سلة المحذوفات.</value></data>
<data name="Admin.Convert.ConfirmReplace.one" xml:space="preserve"><value>تُستبدل صورة واحدة في {1} بنسختها المحوّلة؛ ويُنقل الملف الأصلي إلى سلة المحذوفات، ويمكن استعادته إلى أن تُفرَغ سلة المحذوفات.</value></data>
<data name="Admin.Convert.ConfirmReplace.other" xml:space="preserve"><value>تُستبدل {0} صورة في {1} بنسخها المحوّلة؛ وتُنقل الملفات الأصلية إلى سلة المحذوفات، ويمكن استعادتها إلى أن تُفرَغ سلة المحذوفات.</value></data>
<data name="Admin.Convert.ConfirmReplaceTitle" xml:space="preserve"><value>استبدال الملفات الأصلية بنسخ {0}؟</value></data>
<data name="Admin.Convert.Format" xml:space="preserve"><value>التنسيق</value></data>
<data name="Admin.Convert.Format.Jpeg.Tip" xml:space="preserve"><value>JPEG بعمق 8 بت بألوان كاملة الدقة وبالجودة المحددة بجانبه: أصغر الملفات، وتفتحه كل البرامج</value></data>
<data name="Admin.Convert.Format.LinearDng" xml:space="preserve"><value>DNG خطي</value></data>
<data name="Admin.Convert.Format.LinearDng.Tip" xml:space="preserve"><value>DNG خطي بعمق 16 بت مضغوط بلا فقدان: الخيار الأنسب للأرشفة، وتفتحه برامج تحرير RAW</value></data>
<data name="Admin.Convert.Format.Tiff16.Tip" xml:space="preserve"><value>TIFF بعمق 16 بت بمساحة ألوان sRGB مضغوط بلا فقدان: ملفات كبيرة تحتفظ بكل درجة لونية للتحرير</value></data>
<data name="Admin.Convert.Gone" xml:space="preserve"><value>لم يعد أحد التسلسلات المحددة موجودًا في الأرشيف؛ أغلق وحدّد مجددًا.</value></data>
<data name="Admin.Convert.Mode" xml:space="preserve"><value>الوضع</value></data>
<data name="Admin.Convert.Mode.NewSequence" xml:space="preserve"><value>تسلسل جديد</value></data>
<data name="Admin.Convert.Mode.NewSequence.Tip" xml:space="preserve"><value>توضع النسخ المحوّلة في تسلسل جديد بجوار كل تسلسل؛ وتبقى الملفات الأصلية وتسلسلها كما هي تمامًا</value></data>
<data name="Admin.Convert.Mode.Replace" xml:space="preserve"><value>استبدال</value></data>
<data name="Admin.Convert.Mode.Replace.Tip" xml:space="preserve"><value>تصبح الملفات المحوّلة صور التسلسل؛ وتُنقل الملفات الأصلية إلى سلة محذوفات الأرشيف، ويمكن استعادتها إلى أن تُفرَغ</value></data>
<data name="Admin.Convert.NoAnswer" xml:space="preserve"><value>لم يستجب الخادم: تحقق في صفحة «المهام» مما إذا كان التحويل قد أُضيف إلى قائمة الانتظار قبل أن تحوّل مجددًا.</value></data>
<data name="Admin.Convert.NoSpace.Tip" xml:space="preserve"><value>حرّر بعض المساحة على وحدة تخزين الأرشيف أولًا</value></data>
<data name="Admin.Convert.NotCopiedCount.few" xml:space="preserve"><value>لم تُنسخ {0} صور</value></data>
<data name="Admin.Convert.NotCopiedCount.many" xml:space="preserve"><value>لم تُنسخ {0} صورة</value></data>
<data name="Admin.Convert.NotCopiedCount.one" xml:space="preserve"><value>لم تُنسخ صورة واحدة</value></data>
<data name="Admin.Convert.NotCopiedCount.other" xml:space="preserve"><value>لم تُنسخ {0} صورة</value></data>
<data name="Admin.Convert.Nothing.Tip" xml:space="preserve"><value>لا يوجد في المعاينة ما يُحوَّل</value></data>
<data name="Admin.Convert.NothingToConvert" xml:space="preserve"><value>لا شيء للتحويل: تبقى كل صورة كما هي، للأسباب المعروضة.</value></data>
<data name="Admin.Convert.OpenJob" xml:space="preserve"><value>فتح المهمة</value></data>
<data name="Admin.Convert.OpenJob.Tip" xml:space="preserve"><value>إظهار المهمة وسجلها في صفحة «المهام»</value></data>
<data name="Admin.Convert.PlanChanged" xml:space="preserve"><value>تغيّر الأرشيف منذ المعاينة؛ راجع المعاينة الجديدة وطبّق مجددًا.</value></data>
<data name="Admin.Convert.Planning" xml:space="preserve"><value>جارٍ إعداد الخطة…</value></data>
<data name="Admin.Convert.Planning.Tip" xml:space="preserve"><value>يقرأ الخادم كل مجلد صور في التحديد: يستغرق ذلك دقائق في الأرشيف الكبير، وتظهر المعاينة عند الانتهاء</value></data>
<data name="Admin.Convert.PlanningFor" xml:space="preserve"><value>جارٍ إعداد الخطة… {0}</value></data>
<data name="Admin.Convert.Preview" xml:space="preserve"><value>معاينة</value></data>
<data name="Admin.Convert.Preview.Tip" xml:space="preserve"><value>ما سيحوّله كل تسلسل وما سيتركه كما هو، مع الحجم قبل التحويل وبعده (تقديريًا)؛ لم يتغير شيء بعد</value></data>
<data name="Admin.Convert.Quality" xml:space="preserve"><value>الجودة</value></data>
<data name="Admin.Convert.Quality.Tip" xml:space="preserve"><value>جودة JPEG من 1 إلى 100؛ القيمة 95 تحتفظ بالتفاصيل الدقيقة، والقيم الأدنى تنتج ملفات أصغر</value></data>
<data name="Admin.Convert.QualityRange" xml:space="preserve"><value>اكتب عددًا صحيحًا من 1 إلى 100.</value></data>
<data name="Admin.Convert.Queued" xml:space="preserve"><value>أُضيف التحويل إلى قائمة الانتظار.</value></data>
<data name="Admin.Convert.ReplaceWord" xml:space="preserve"><value>استبدال</value></data>
<data name="Admin.Convert.Size.Tip" xml:space="preserve"><value>الحجم الحالي للصور التي ستُحوَّل، ثم الحجم المقدّر بعد التحويل</value></data>
<data name="Admin.Convert.SkippedPhotos" xml:space="preserve"><value>{0}: {1}</value></data>
<data name="Admin.Convert.Title.few" xml:space="preserve"><value>تحويل {0} تسلسلات</value></data>
<data name="Admin.Convert.Title.many" xml:space="preserve"><value>تحويل {0} تسلسلًا</value></data>
<data name="Admin.Convert.Title.one" xml:space="preserve"><value>تحويل تسلسل واحد</value></data>
<data name="Admin.Convert.Title.other" xml:space="preserve"><value>تحويل {0} تسلسل</value></data>
<data name="Admin.Convert.TitleAll" xml:space="preserve"><value>تحويل كل التسلسلات</value></data>
<data name="Admin.Convert.TooMany" xml:space="preserve"><value>يعمل التحويل على {0} من التسلسلات كحد أقصى في المرة الواحدة، أو على كل التسلسلات: امسح عوامل التصفية وحدد الكل.</value></data>
<data name="Admin.Convert.Totals" xml:space="preserve"><value>التسلسلات المحوّلة: {0} · الصور: {1} · دون تغيير: {2} · الحجم: {3} ← {4}</value></data>
<data name="Admin.Convert.TotalsNew" xml:space="preserve"><value>التسلسلات المحوّلة: {0} · الصور: {1} · غير المنسوخة: {2} · الحجم: {3} ← {4}</value></data>
<data name="Admin.Dashboard.Activity" xml:space="preserve"><value>النشاط الأخير</value></data>
<data name="Admin.Dashboard.AllLogs" xml:space="preserve"><value>كل السجلات</value></data>
<data name="Admin.Dashboard.AllLogs.Tip" xml:space="preserve"><value>فتح سجل التدقيق</value></data>
@@ -151,6 +224,7 @@
<data name="Admin.Job.Kind.Adopt" xml:space="preserve"><value>ضم</value></data>
<data name="Admin.Job.Kind.Backup" xml:space="preserve"><value>نسخ احتياطي</value></data>
<data name="Admin.Job.Kind.Cleanup" xml:space="preserve"><value>تنظيف</value></data>
<data name="Admin.Job.Kind.Convert" xml:space="preserve"><value>تحويل</value></data>
<data name="Admin.Job.Kind.DeepAnalyse" xml:space="preserve"><value>تحليل معمّق</value></data>
<data name="Admin.Job.Kind.Duplicates" xml:space="preserve"><value>التكرارات</value></data>
<data name="Admin.Job.Kind.EmptyTrash" xml:space="preserve"><value>إفراغ سلة المحذوفات</value></data>
@@ -392,6 +466,7 @@
<data name="Admin.Login.SignIn.Tip" xml:space="preserve"><value>تسجيل الدخول لإدارة هذا الخادم</value></data>
<data name="Admin.Login.User" xml:space="preserve"><value>المستخدم</value></data>
<data name="Admin.Login.User.Tip" xml:space="preserve"><value>اسم المستخدم الخاص بك على هذا الخادم</value></data>
<data name="Admin.Logs.Action.ArchiveConverted" xml:space="preserve"><value>تحويل صور</value></data>
<data name="Admin.Logs.Action.ArchiveReorganized" xml:space="preserve"><value>إعادة تنظيم الأرشيف</value></data>
<data name="Admin.Logs.Action.ArchiveSettings" xml:space="preserve"><value>تنظيم الأرشيف</value></data>
<data name="Admin.Logs.Action.FramesDeleted" xml:space="preserve"><value>حذف صور</value></data>
@@ -873,6 +948,7 @@
<data name="Admin.Theme.Tip" xml:space="preserve"><value>التبديل بين السمة الفاتحة والداكنة</value></data>
<data name="Admin.Trash.Back" xml:space="preserve"><value>المكتبة</value></data>
<data name="Admin.Trash.Back.Tip" xml:space="preserve"><value>العودة إلى المكتبة</value></data>
<data name="Admin.Trash.ConversionDeleted" xml:space="preserve"><value>حُذفت النسخة المحوّلة</value></data>
<data name="Admin.Trash.DeletedAt" xml:space="preserve"><value>تاريخ الحذف</value></data>
<data name="Admin.Trash.DeletedBy" xml:space="preserve"><value>حُذف بواسطة</value></data>
<data name="Admin.Trash.Emptied" xml:space="preserve"><value>تم إفراغ سلة المحذوفات.</value></data>
@@ -903,11 +979,16 @@
<data name="Admin.Trash.Photos" xml:space="preserve"><value>الصور</value></data>
<data name="Admin.Trash.Restore" xml:space="preserve"><value>استعادة</value></data>
<data name="Admin.Trash.RestorePhotos.Tip" xml:space="preserve"><value>إعادة الصور إلى تسلسلها (أو إلى تسلسل جديد إن لم يعد موجودًا)؛ ويُتحقق أولًا من كل صورة مقابل قيمة SHA-256 الخاصة بها</value></data>
<data name="Admin.Trash.RestoreReplaced.Tip" xml:space="preserve"><value>إعادة الملفات الأصلية إلى مكان نسخها المحوّلة ما دامت هذه لم تتغير (وتُنقل النسخ المحوّلة إلى سلة المحذوفات)، وإلا فإلى تسلسل جديد؛ ويُتحقق أولًا من كل ملف مقابل قيمة SHA-256 الخاصة به</value></data>
<data name="Admin.Trash.RestoreSequence.Tip" xml:space="preserve"><value>إعادة مجلد التسلسل إلى المكتبة كما هو (بجوار مكانه القديم إن كان مشغولًا)؛ ولا يُتحقق من تجزئة صوره: فهذا ما يفعله «تحقق»</value></data>
<data name="Admin.Trash.RestoredNew.few" xml:space="preserve"><value>تمت استعادة {0} صور إلى تسلسل جديد.</value></data>
<data name="Admin.Trash.RestoredNew.many" xml:space="preserve"><value>تمت استعادة {0} صورة إلى تسلسل جديد.</value></data>
<data name="Admin.Trash.RestoredNew.one" xml:space="preserve"><value>تمت استعادة صورة واحدة إلى تسلسل جديد.</value></data>
<data name="Admin.Trash.RestoredNew.other" xml:space="preserve"><value>تمت استعادة {0} صورة إلى تسلسل جديد.</value></data>
<data name="Admin.Trash.RestoredOriginals.few" xml:space="preserve"><value>عادت {0} ملفات أصلية إلى {1}؛ ونسخها المحوّلة في سلة المحذوفات.</value></data>
<data name="Admin.Trash.RestoredOriginals.many" xml:space="preserve"><value>عاد {0} ملفًا أصليًا إلى {1}؛ ونسخها المحوّلة في سلة المحذوفات.</value></data>
<data name="Admin.Trash.RestoredOriginals.one" xml:space="preserve"><value>عاد ملف أصلي واحد إلى {1}؛ ونسخته المحوّلة في سلة المحذوفات.</value></data>
<data name="Admin.Trash.RestoredOriginals.other" xml:space="preserve"><value>عاد {0} ملف أصلي إلى {1}؛ ونسخها المحوّلة في سلة المحذوفات.</value></data>
<data name="Admin.Trash.RestoredPhotos.few" xml:space="preserve"><value>عادت {0} صور إلى {1}.</value></data>
<data name="Admin.Trash.RestoredPhotos.many" xml:space="preserve"><value>عادت {0} صورة إلى {1}.</value></data>
<data name="Admin.Trash.RestoredPhotos.one" xml:space="preserve"><value>عادت صورة واحدة إلى {1}.</value></data>
+132 -5
View File
@@ -17,8 +17,10 @@
<data name="Archive.Blocked.Applying" xml:space="preserve"><value>انتظر حتى تُطبَّق التغييرات.</value></data>
<data name="Archive.Blocked.EmptySet" xml:space="preserve"><value>المجموعة فارغة: غيّر التحديد أو عامل التصفية.</value></data>
<data name="Archive.Blocked.NoChanges" xml:space="preserve"><value>لن يتغير شيء.</value></data>
<data name="Archive.Blocked.NoMode" xml:space="preserve"><value>اختر «استبدال» أو «تسلسل جديد».</value></data>
<data name="Archive.Blocked.NoTemplate" xml:space="preserve"><value>شغّل قالبًا واحدًا على الأقل.</value></data>
<data name="Archive.Blocked.NotOnline" xml:space="preserve"><value>يجب أن يكون الأرشيف متصلًا وقابلًا للكتابة.</value></data>
<data name="Archive.Blocked.NothingToConvert" xml:space="preserve"><value>لا شيء للتحويل: كل الصور متخطاة أو كل التسلسلات محظورة.</value></data>
<data name="Archive.Blocked.Planning" xml:space="preserve"><value>انتظر انتهاء التشغيل التجريبي.</value></data>
<data name="Archive.Blocked.Reading" xml:space="preserve"><value>انتظر حتى تتم قراءة الأرشيف.</value></data>
<data name="Archive.Blocked.Searching" xml:space="preserve"><value>يجري بحث الآن؛ ألغِه أو انتظر.</value></data>
@@ -36,6 +38,100 @@
<data name="Archive.Confirm.Remove" xml:space="preserve"><value>إزالة الصف</value></data>
<data name="Archive.Confirm.RemoveHeading" xml:space="preserve"><value>إزالة {0} من الفهرس؟</value></data>
<data name="Archive.Confirm.RemoveMessage" xml:space="preserve"><value>لم يعد ملفه المرافق موجودًا. يُزال صف الفهرس فقط، ولا يُحذف أي ملف.</value></data>
<data name="Archive.Convert.AlreadyQueued" xml:space="preserve"><value>يوجد بالفعل تحويل لهذه التسلسلات في الانتظار أو قيد التشغيل؛ تابعه في «المهام».</value></data>
<data name="Archive.Convert.Blocked.Busy" xml:space="preserve"><value>تعمل مهمة على هذا التسلسل؛ حوّله بعد انتهاء المهمة.</value></data>
<data name="Archive.Convert.Blocked.FramesChanged" xml:space="preserve"><value>تغيّر التسلسل بعد إعداد الخطة؛ راجع الخطة مجددًا.</value></data>
<data name="Archive.Convert.Blocked.Offline" xml:space="preserve"><value>الأرشيف غير متصل أو للقراءة فقط.</value></data>
<data name="Archive.Convert.Blocked.Unreadable" xml:space="preserve"><value>تتعذر قراءة ملف التسلسل.</value></data>
<data name="Archive.Convert.Confirm" xml:space="preserve"><value>تحويل</value></data>
<data name="Archive.Convert.CopyUnfinished" xml:space="preserve"><value>أنشأت عملية تحويل أخرى نسخة منه بهذا التنسيق ولم تنتهِ بعد؛ أكملها أو أعد محاولتها أولًا.</value></data>
<data name="Archive.Convert.Done.few" xml:space="preserve"><value>تم تحويل {0:N0} تسلسلات</value></data>
<data name="Archive.Convert.Done.many" xml:space="preserve"><value>تم تحويل {0:N0} تسلسلًا</value></data>
<data name="Archive.Convert.Done.one" xml:space="preserve"><value>تم تحويل تسلسل واحد</value></data>
<data name="Archive.Convert.Done.other" xml:space="preserve"><value>تم تحويل {0:N0} تسلسل</value></data>
<data name="Archive.Convert.Failed.Changed" xml:space="preserve"><value>لم تعد الصورة تطابق النسخة التي أُرشفت؛ تحقق من التسلسل.</value></data>
<data name="Archive.Convert.Failed.ColorProfile" xml:space="preserve"><value>لا يمكن في هذا التنسيق الاحتفاظ بملف تعريف ألوانها ولا تحويله.</value></data>
<data name="Archive.Convert.Failed.Damaged" xml:space="preserve"><value>تحتوي وحدات البكسل فيها على قيم ليست أرقامًا: الملف تالف.</value></data>
<data name="Archive.Convert.Failed.EightBit" xml:space="preserve"><value>يعالج هذا الكمبيوتر ملف RAW هذا بعمق 8 بت فقط، وهو أقل مما يلزم لملف بعمق 16 بت؛ ويمكن تحويله إلى JPEG.</value></data>
<data name="Archive.Convert.Failed.Full" xml:space="preserve"><value>قرص الأرشيف ممتلئ.</value></data>
<data name="Archive.Convert.Failed.NoDecoder" xml:space="preserve"><value>لا توجد على هذا الكمبيوتر أداة فك ترميز تقرؤها بكامل الدقة.</value></data>
<data name="Archive.Convert.Failed.NotVerified" xml:space="preserve"><value>لم يطابق الملف المحوّل عند إعادة قراءته ما كُتب.</value></data>
<data name="Archive.Convert.Failed.Other" xml:space="preserve"><value>تعذّر إنشاء الملف المحوّل.</value></data>
<data name="Archive.Convert.Failed.PreviewOnly" xml:space="preserve"><value>لا يقرؤها هذا الكمبيوتر إلا من معاينتها المضمّنة: حوّلها على كمبيوتر يقرؤها بكامل الدقة.</value></data>
<data name="Archive.Convert.Failed.TooLarge" xml:space="preserve"><value>إنها أكبر مما يتسع له هذا التنسيق، أو مما يستطيع Chronos إعادة قراءته، أو مما تتسع له الذاكرة المخصصة لصورة واحدة.</value></data>
<data name="Archive.Convert.Failed.Unreadable" xml:space="preserve"><value>تعذّر فك ترميز الصورة.</value></data>
<data name="Archive.Convert.Format" xml:space="preserve"><value>التنسيق</value></data>
<data name="Archive.Convert.Heading.few" xml:space="preserve"><value>تحويل {0:N0} تسلسلات</value></data>
<data name="Archive.Convert.Heading.many" xml:space="preserve"><value>تحويل {0:N0} تسلسلًا</value></data>
<data name="Archive.Convert.Heading.one" xml:space="preserve"><value>تحويل تسلسل واحد</value></data>
<data name="Archive.Convert.Heading.other" xml:space="preserve"><value>تحويل {0:N0} تسلسل</value></data>
<data name="Archive.Convert.HeadingAll" xml:space="preserve"><value>تحويل {0}</value></data>
<data name="Archive.Convert.Mode" xml:space="preserve"><value>الوضع</value></data>
<data name="Archive.Convert.NewHeading.few" xml:space="preserve"><value>تحويل {0:N0} تسلسلات إلى تسلسلات جديدة؟</value></data>
<data name="Archive.Convert.NewHeading.many" xml:space="preserve"><value>تحويل {0:N0} تسلسلًا إلى تسلسلات جديدة؟</value></data>
<data name="Archive.Convert.NewHeading.one" xml:space="preserve"><value>تحويل تسلسل واحد إلى تسلسل جديد؟</value></data>
<data name="Archive.Convert.NewHeading.other" xml:space="preserve"><value>تحويل {0:N0} تسلسل إلى تسلسلات جديدة؟</value></data>
<data name="Archive.Convert.NewLeftOut.few" xml:space="preserve"><value>لا تُنسخ {0:N0} صور: فهي تبقى في مصدرها فقط، للأسباب التي تبيّنها الخطة.</value></data>
<data name="Archive.Convert.NewLeftOut.many" xml:space="preserve"><value>لا تُنسخ {0:N0} صورة: فهي تبقى في مصدرها فقط، للأسباب التي تبيّنها الخطة.</value></data>
<data name="Archive.Convert.NewLeftOut.one" xml:space="preserve"><value>لا تُنسخ صورة واحدة: فهي تبقى في مصدرها فقط، للسبب الذي تبيّنه الخطة.</value></data>
<data name="Archive.Convert.NewLeftOut.other" xml:space="preserve"><value>لا تُنسخ {0:N0} صورة: فهي تبقى في مصدرها فقط، للأسباب التي تبيّنها الخطة.</value></data>
<data name="Archive.Convert.NewMessage" xml:space="preserve"><value>تُحوَّل {0} ({1}) إلى {2} في تسلسل جديد بجوار كل مصدر؛ وتبقى الملفات الأصلية كما هي.</value></data>
<data name="Archive.Convert.NewSequence" xml:space="preserve"><value>تسلسل جديد</value></data>
<data name="Archive.Convert.NotCopied.ColorProfile" xml:space="preserve"><value>لا تُنسخ إلى التسلسل الجديد الصور التي لا يستطيع هذا التنسيق الاحتفاظ بملف تعريف ألوانها ولا تحويله.</value></data>
<data name="Archive.Convert.NotCopied.EightBit" xml:space="preserve"><value>لا تُنسخ إلى التسلسل الجديد صور RAW التي يعالجها هذا الكمبيوتر بعمق 8 بت فقط؛ ويمكن تحويلها إلى JPEG.</value></data>
<data name="Archive.Convert.NotCopied.Inaccessible" xml:space="preserve"><value>لا تُنسخ إلى التسلسل الجديد الصور المفتوحة في برنامج آخر أو التي يتعذر فتحها؛ أعد إعداد الخطة عندما تصبح متاحة.</value></data>
<data name="Archive.Convert.NotCopied.Missing" xml:space="preserve"><value>لا تُنسخ الصور المفقودة إلى التسلسل الجديد.</value></data>
<data name="Archive.Convert.NotCopied.NoNativeDecoder" xml:space="preserve"><value>لا تُنسخ إلى التسلسل الجديد صور التنسيقات التي لا يستطيع هذا الكمبيوتر قراءتها بكامل الدقة.</value></data>
<data name="Archive.Convert.NotCopied.PreviewOnly" xml:space="preserve"><value>لا تُنسخ إلى التسلسل الجديد الصور التي لا تُقرأ هنا إلا من معاينتها المضمّنة.</value></data>
<data name="Archive.Convert.NotCopied.SameFormat" xml:space="preserve"><value>لا تُنسخ إلى التسلسل الجديد الصور الموجودة بهذا التنسيق بالفعل.</value></data>
<data name="Archive.Convert.NotCopied.TooLarge" xml:space="preserve"><value>لا تُنسخ إلى التسلسل الجديد الصور الأكبر مما يتسع له هذا التنسيق أو مما يستطيع Chronos إعادة قراءته.</value></data>
<data name="Archive.Convert.NotCopied.Undecodable" xml:space="preserve"><value>لا تُنسخ الصور غير القابلة للقراءة إلى التسلسل الجديد.</value></data>
<data name="Archive.Convert.NotCopied.Unhashed" xml:space="preserve"><value>لا تُنسخ إلى التسلسل الجديد الصور التي لم يُتحقق منها قط؛ تحقق من التسلسل أولًا.</value></data>
<data name="Archive.Convert.NotCopiedPhotos.few" xml:space="preserve"><value>لم تُنسخ {0:N0} صور</value></data>
<data name="Archive.Convert.NotCopiedPhotos.many" xml:space="preserve"><value>لم تُنسخ {0:N0} صورة</value></data>
<data name="Archive.Convert.NotCopiedPhotos.one" xml:space="preserve"><value>لم تُنسخ صورة واحدة</value></data>
<data name="Archive.Convert.NotCopiedPhotos.other" xml:space="preserve"><value>لم تُنسخ {0:N0} صورة</value></data>
<data name="Archive.Convert.NotPlaced" xml:space="preserve"><value>تعذّر وضع الصور المحوّلة في مكانها. {0}</value></data>
<data name="Archive.Convert.PhotoFailed" xml:space="preserve"><value>تعذّر تحويل {0}. {1}</value></data>
<data name="Archive.Convert.PhotoHeld" xml:space="preserve"><value>إحدى صوره مفتوحة في برنامج آخر أو يتعذر فتحها؛ أعد المحاولة عندما تصبح متاحة.</value></data>
<data name="Archive.Convert.Quality" xml:space="preserve"><value>الجودة</value></data>
<data name="Archive.Convert.Replace" xml:space="preserve"><value>استبدال</value></data>
<data name="Archive.Convert.ReplaceHeading.few" xml:space="preserve"><value>استبدال صور {0:N0} تسلسلات؟</value></data>
<data name="Archive.Convert.ReplaceHeading.many" xml:space="preserve"><value>استبدال صور {0:N0} تسلسلًا؟</value></data>
<data name="Archive.Convert.ReplaceHeading.one" xml:space="preserve"><value>استبدال صور تسلسل واحد؟</value></data>
<data name="Archive.Convert.ReplaceHeading.other" xml:space="preserve"><value>استبدال صور {0:N0} تسلسل؟</value></data>
<data name="Archive.Convert.ReplaceMessage" xml:space="preserve"><value>تُستبدل {0} ({1}) بتحويلها إلى {2}؛ وتنتقل الملفات الأصلية إلى سلة محذوفات الأرشيف، ويمكن استعادتها إلى أن تُفرَغ.</value></data>
<data name="Archive.Convert.Sizes" xml:space="preserve"><value>{0} ← {1}</value></data>
<data name="Archive.Convert.Skipped.ColorProfile" xml:space="preserve"><value>تبقى كما هي الصور التي لا يستطيع هذا التنسيق الاحتفاظ بملف تعريف ألوانها ولا تحويله.</value></data>
<data name="Archive.Convert.Skipped.EightBit" xml:space="preserve"><value>تبقى كما هي صور RAW التي يعالجها هذا الكمبيوتر بعمق 8 بت فقط؛ ويمكن تحويلها إلى JPEG.</value></data>
<data name="Archive.Convert.Skipped.Inaccessible" xml:space="preserve"><value>تبقى كما هي الصور المفتوحة في برنامج آخر أو التي يتعذر فتحها؛ أعد إعداد الخطة عندما تصبح متاحة.</value></data>
<data name="Archive.Convert.Skipped.Missing" xml:space="preserve"><value>تبقى الصور المفقودة كما هي.</value></data>
<data name="Archive.Convert.Skipped.NoNativeDecoder" xml:space="preserve"><value>تبقى كما هي صور التنسيقات التي لا يستطيع هذا الكمبيوتر قراءتها بكامل الدقة.</value></data>
<data name="Archive.Convert.Skipped.PreviewOnly" xml:space="preserve"><value>تبقى كما هي الصور التي لا تُقرأ هنا إلا من معاينتها المضمّنة.</value></data>
<data name="Archive.Convert.Skipped.SameFormat" xml:space="preserve"><value>تبقى كما هي الصور الموجودة بهذا التنسيق بالفعل.</value></data>
<data name="Archive.Convert.Skipped.TooLarge" xml:space="preserve"><value>تبقى كما هي الصور الأكبر مما يتسع له هذا التنسيق أو مما يستطيع Chronos إعادة قراءته.</value></data>
<data name="Archive.Convert.Skipped.Undecodable" xml:space="preserve"><value>تبقى الصور غير القابلة للقراءة كما هي.</value></data>
<data name="Archive.Convert.Skipped.Unhashed" xml:space="preserve"><value>تبقى الصور التي لم يُتحقق منها قط كما هي؛ تحقق من التسلسل أولًا.</value></data>
<data name="Archive.Convert.SkippedPhotos.few" xml:space="preserve"><value>تم تخطي {0:N0} صور</value></data>
<data name="Archive.Convert.SkippedPhotos.many" xml:space="preserve"><value>تم تخطي {0:N0} صورة</value></data>
<data name="Archive.Convert.SkippedPhotos.one" xml:space="preserve"><value>تم تخطي صورة واحدة</value></data>
<data name="Archive.Convert.SkippedPhotos.other" xml:space="preserve"><value>تم تخطي {0:N0} صورة</value></data>
<data name="Archive.Convert.Space" xml:space="preserve"><value>المطلوب {0}، والمتاح {1}</value></data>
<data name="Archive.Convert.SpaceShort" xml:space="preserve"><value>المطلوب {0}، والمتاح {1} فقط: حرّر بعض المساحة أولًا.</value></data>
<data name="Archive.Convert.SpaceUnknown" xml:space="preserve"><value>المطلوب {0}؛ ويتعذر قياس المساحة المتاحة.</value></data>
<data name="Archive.Convert.Target.LinearDng" xml:space="preserve"><value>DNG خطي</value></data>
<data name="Archive.Convert.Target.Tiff16" xml:space="preserve"><value>TIFF بعمق 16 بت</value></data>
<data name="Archive.Convert.UndoFailed" xml:space="preserve"><value>تعذّرت إعادة الملفات الأصلية</value></data>
<data name="Archive.Convert.UndoNothing" xml:space="preserve"><value>لم تعد الملفات الأصلية المستبدلة في سلة المحذوفات.</value></data>
<data name="Archive.Convert.Undone.few" xml:space="preserve"><value>عادت الملفات الأصلية إلى {0:N0} تسلسلات</value></data>
<data name="Archive.Convert.Undone.many" xml:space="preserve"><value>عادت الملفات الأصلية إلى {0:N0} تسلسلًا</value></data>
<data name="Archive.Convert.Undone.one" xml:space="preserve"><value>عادت الملفات الأصلية إلى تسلسل واحد</value></data>
<data name="Archive.Convert.Undone.other" xml:space="preserve"><value>عادت الملفات الأصلية إلى {0:N0} تسلسل</value></data>
<data name="Archive.Convert.UndoneNew.few" xml:space="preserve"><value>تغيّرت {0:N0} تسلسلات منذ التحويل: فعادت ملفاتها الأصلية كتسلسلات جديدة.</value></data>
<data name="Archive.Convert.UndoneNew.many" xml:space="preserve"><value>تغيّر {0:N0} تسلسلًا منذ التحويل: فعادت ملفاتها الأصلية كتسلسلات جديدة.</value></data>
<data name="Archive.Convert.UndoneNew.one" xml:space="preserve"><value>تغيّر تسلسل واحد منذ التحويل: فعادت ملفاته الأصلية كتسلسل جديد.</value></data>
<data name="Archive.Convert.UndoneNew.other" xml:space="preserve"><value>تغيّر {0:N0} تسلسل منذ التحويل: فعادت ملفاتها الأصلية كتسلسلات جديدة.</value></data>
<data name="Archive.Convert.Unstaged" xml:space="preserve"><value>لم يعد تحويل {0} بين الملفات المجهّزة؛ وستحوّله إعادة المحاولة مجددًا.</value></data>
<data name="Archive.Copy.Title" xml:space="preserve"><value>المجلد المراد نسخه إلى الأرشيف</value></data>
<data name="Archive.Delete.Action" xml:space="preserve"><value>نقل إلى سلة المحذوفات</value></data>
<data name="Archive.Delete.Blocked" xml:space="preserve"><value>لم يُنقل: {0} · {1}</value></data>
@@ -95,6 +191,11 @@
<data name="Archive.Duplicates.Title" xml:space="preserve"><value>التكرارات</value></data>
<data name="Archive.Empty" xml:space="preserve"><value>لا يوجد أرشيف بعد</value></data>
<data name="Archive.Error.Busy" xml:space="preserve"><value>نسخة أخرى من Chronos ({0}) تكتب هنا. حاول مرة أخرى بعد قليل.</value></data>
<data name="Archive.Error.ConvertKept.few" xml:space="preserve"><value>لم تُحوَّل {0:N0} تسلسلات كما هو مخطط؛ ويوضح سجل المهمة السبب.</value></data>
<data name="Archive.Error.ConvertKept.many" xml:space="preserve"><value>لم يُحوَّل {0:N0} تسلسلًا كما هو مخطط؛ ويوضح سجل المهمة السبب.</value></data>
<data name="Archive.Error.ConvertKept.one" xml:space="preserve"><value>لم يُحوَّل تسلسل واحد كما هو مخطط؛ ويوضح سجل المهمة السبب.</value></data>
<data name="Archive.Error.ConvertKept.other" xml:space="preserve"><value>لم يُحوَّل {0:N0} تسلسل كما هو مخطط؛ ويوضح سجل المهمة السبب.</value></data>
<data name="Archive.Error.ConvertSpace" xml:space="preserve"><value>يحتاج التحويل إلى {0} من المساحة المتاحة على وحدة تخزين الأرشيف، والمتاح {1}.</value></data>
<data name="Archive.Error.CopyMismatch" xml:space="preserve"><value>نسخة {0} لا تطابق الأصل.</value></data>
<data name="Archive.Error.DuplicateLost" xml:space="preserve"><value>تعذّرت إضافة {0} إلى التسلسل.</value></data>
<data name="Archive.Error.InLibrary" xml:space="preserve"><value>التسلسل {0} موجود بالفعل في المكتبة.</value></data>
@@ -118,10 +219,10 @@
<data name="Archive.Error.SourceGone" xml:space="preserve"><value>البطاقة أو المجلد {0} لم يعد متاحًا.</value></data>
<data name="Archive.Error.StalePlan" xml:space="preserve"><value>تغيّر الأرشيف بعد إعداد هذه الخطة.</value></data>
<data name="Archive.Error.TrashChanged" xml:space="preserve"><value>تغيّرت سلة المحذوفات بعد فحصها؛ ولم يُمحَ أي شيء.</value></data>
<data name="Archive.Error.TrashKept.few" xml:space="preserve"><value>احتُفظ بـ {0:N0} إدخالات في سلة المحذوفات: فقد تغيّرت، أو لم يعد أحد الملفات البديلة مطابقًا.</value></data>
<data name="Archive.Error.TrashKept.many" xml:space="preserve"><value>احتُفظ بـ {0:N0} إدخالًا في سلة المحذوفات: فقد تغيّرت، أو لم يعد أحد الملفات البديلة مطابقًا.</value></data>
<data name="Archive.Error.TrashKept.one" xml:space="preserve"><value>احتُفظ بإدخال واحد في سلة المحذوفات: فقد تغيّر، أو لم يعد أحد الملفات البديلة مطابقًا.</value></data>
<data name="Archive.Error.TrashKept.other" xml:space="preserve"><value>احتُفظ بـ {0:N0} إدخال في سلة المحذوفات: فقد تغيّرت، أو لم يعد أحد الملفات البديلة مطابقًا.</value></data>
<data name="Archive.Error.TrashKept.few" xml:space="preserve"><value>احتُفظ بـ {0:N0} إدخالات في سلة المحذوفات؛ ويوضح سجل المهمة السبب.</value></data>
<data name="Archive.Error.TrashKept.many" xml:space="preserve"><value>احتُفظ بـ {0:N0} إدخالًا في سلة المحذوفات؛ ويوضح سجل المهمة السبب.</value></data>
<data name="Archive.Error.TrashKept.one" xml:space="preserve"><value>احتُفظ بإدخال واحد في سلة المحذوفات؛ ويوضح سجل المهمة السبب.</value></data>
<data name="Archive.Error.TrashKept.other" xml:space="preserve"><value>احتُفظ بـ {0:N0} إدخال في سلة المحذوفات؛ ويوضح سجل المهمة السبب.</value></data>
<data name="Archive.Error.TrashMismatch" xml:space="preserve"><value>لم يعد أي ملف من ملفات هذا الإدخال في سلة المحذوفات يطابق سجله؛ لذا يبقى في سلة المحذوفات.</value></data>
<data name="Archive.Failed.Access" xml:space="preserve"><value>رُفض وصول Chronos إلى الأرشيف.</value></data>
<data name="Archive.Failed.Files" xml:space="preserve"><value>تعذّرت قراءة أحد ملفات الأرشيف أو الكتابة فيه.</value></data>
@@ -170,6 +271,15 @@
<data name="Archive.Log.AuditKept" xml:space="preserve"><value>احتُفظ بسجل التدقيق كاملًا</value></data>
<data name="Archive.Log.AuditPurged" xml:space="preserve"><value>إدخالات التدقيق المُزالة: {0}</value></data>
<data name="Archive.Log.BackupDone" xml:space="preserve"><value>نُسخ الفهرس إلى {0} ({1})؛ النسخ المحتفظ بها: {2}</value></data>
<data name="Archive.Log.ConvertBlocked" xml:space="preserve"><value>تُرك كما كان، إذ كان مشغولًا أو تتعذر قراءته: {0}</value></data>
<data name="Archive.Log.ConvertChanged" xml:space="preserve"><value>تُرك كما كان، إذ تغيّر بعد إعداد الخطة: {0}. ستتركه إعادة المحاولة كما هو: حوّله مجددًا وفق خطة جديدة.</value></data>
<data name="Archive.Log.ConvertDone" xml:space="preserve"><value>التسلسلات المحوّلة: {0}، التسلسلات الجديدة: {1}، الصور: {2}</value></data>
<data name="Archive.Log.ConvertFailed" xml:space="preserve"><value>تُرك كما كان: {0}. {1}</value></data>
<data name="Archive.Log.ConvertLeftOut" xml:space="preserve"><value>{0}: صور لم تُحوَّل وبقيت في المصدر فقط: {1}</value></data>
<data name="Archive.Log.ConvertNothing" xml:space="preserve"><value>لا شيء للتحويل: {0}</value></data>
<data name="Archive.Log.ConvertSuperseded" xml:space="preserve"><value>{0}: أنشأت عملية تحويل أخرى نسختها بهذا التنسيق منذ تأكيد هذه العملية؛ لن تُنشأ نسخة ثانية.</value></data>
<data name="Archive.Log.Converted" xml:space="preserve"><value>{0}: صور استُبدلت بتحويلها: {1}</value></data>
<data name="Archive.Log.ConvertedNew" xml:space="preserve"><value>{0}: صور حُوّلت إلى تسلسل جديد: {1}</value></data>
<data name="Archive.Log.DryRun" xml:space="preserve"><value>تشغيل تجريبي: لم يُغيَّر شيء.</value></data>
<data name="Archive.Log.DuplicateGroup" xml:space="preserve"><value>النسخ الإضافية من {0}: {1}</value></data>
<data name="Archive.Log.DuplicatesDone" xml:space="preserve"><value>مجموعات التكرار: {0}، النسخ الإضافية: {1}</value></data>
@@ -204,9 +314,24 @@
<data name="Archive.Log.SequenceMissing" xml:space="preserve"><value>لم يُعثر على التسلسل: {0}</value></data>
<data name="Archive.Log.StepFailed" xml:space="preserve"><value>فشلت خطوة التنظيف {0}: {1}</value></data>
<data name="Archive.Log.StepUnknown" xml:space="preserve"><value>خطوة تنظيف غير معروفة هنا: {0}</value></data>
<data name="Archive.Log.SyncChanged" xml:space="preserve"><value>{0}: تغيّر منذ أرشفته، ولم يُرفع</value></data>
<data name="Archive.Log.SyncDeletedHere" xml:space="preserve"><value>{0}: حُذف على هذا الكمبيوتر، ولم يُنزَّل</value></data>
<data name="Archive.Log.SyncDeletedThere" xml:space="preserve"><value>{0}: حُذف على الخادم، ولم يُرفع</value></data>
<data name="Archive.Log.SyncFrameChanged" xml:space="preserve"><value>{0}: تغيّر إطاره هنا في هذه الأثناء، ولم يُنزَّل</value></data>
<data name="Archive.Log.SyncMissing" xml:space="preserve"><value>{0}: مفقود، ولم يُرفع</value></data>
<data name="Archive.Log.SyncNoPreview.few" xml:space="preserve"><value>ليس لـ {0:N0} إطارات نسخة وكيلة ولا صورة مصغرة على الخادم</value></data>
<data name="Archive.Log.SyncNoPreview.many" xml:space="preserve"><value>ليس لـ {0:N0} إطارًا نسخة وكيلة ولا صورة مصغرة على الخادم</value></data>
<data name="Archive.Log.SyncNoPreview.one" xml:space="preserve"><value>ليس لإطار واحد نسخة وكيلة ولا صورة مصغرة على الخادم</value></data>
<data name="Archive.Log.SyncNoPreview.other" xml:space="preserve"><value>ليس لـ {0:N0} إطار نسخة وكيلة ولا صورة مصغرة على الخادم</value></data>
<data name="Archive.Log.TrashEmptied" xml:space="preserve"><value>الإدخالات الممحوة: {0}، الحجم: {1}</value></data>
<data name="Archive.Log.TrashEntry" xml:space="preserve"><value>في سلة المحذوفات منذ {0}: {1} ({2})</value></data>
<data name="Archive.Log.TrashKept" xml:space="preserve"><value>بقي في سلة المحذوفات: {0}</value></data>
<data name="Archive.Log.TrashKept" xml:space="preserve"><value>بقي في سلة المحذوفات، إذ تغيّر بعد إعداد الخطة: {0}</value></data>
<data name="Archive.Log.TrashKeptBusy" xml:space="preserve"><value>بقي في سلة المحذوفات، إذ كان تسلسله مشغولًا: {0}</value></data>
<data name="Archive.Log.TrashKeptMismatch" xml:space="preserve"><value>بقي في سلة المحذوفات، إذ لم تعد إحدى النسخ المحوّلة من ملفاته الأصلية مطابقة: {0}</value></data>
<data name="Archive.Log.TrashKeptStaleIndex" xml:space="preserve"><value>بقي في سلة المحذوفات، إذ يُدرج الفهرس تسلسله الذي لم يعد الأرشيف يحتويه؛ أعد بناء الفهرس: {0}</value></data>
<data name="Archive.Log.TrashKeptUnhashed" xml:space="preserve"><value>بقي في سلة المحذوفات، إذ لم يُتحقق قط من إحدى صور تسلسله؛ تحقق من التسلسل: {0}</value></data>
<data name="Archive.Log.TrashKeptUnknown" xml:space="preserve"><value>بقي في سلة المحذوفات، إذ لا يُظهر الأرشيف ما آل إليه تحويل ملفاته الأصلية؛ استعده للاحتفاظ بها: {0}</value></data>
<data name="Archive.Log.TrashKeptUnreadable" xml:space="preserve"><value>بقي في سلة المحذوفات، إذ إن الملف المرافق لمجلد قد يحتوي تسلسله مفقود أو تتعذر قراءته؛ افحص الأرشيف: {0}</value></data>
<data name="Archive.Log.TrashOffline" xml:space="preserve"><value>لم تُفحص سلة المحذوفات: تعذّر الوصول إلى الأرشيف</value></data>
<data name="Archive.Log.TrashReport" xml:space="preserve"><value>الإدخالات القديمة في سلة المحذوفات: {0}، الحجم: {1}؛ لم يُحذف شيء</value></data>
<data name="Archive.Log.VerifyDone" xml:space="preserve"><value>الصور المفحوصة: {0}، السليمة: {1}، حُسبت تجزئتها: {2}، بها مشكلات: {3}</value></data>
@@ -305,6 +430,7 @@
<data name="Archive.Set.All.other" xml:space="preserve"><value>{0:N0} تسلسل · الكل</value></data>
<data name="Archive.Set.Analyse" xml:space="preserve"><value>تحليل</value></data>
<data name="Archive.Set.ClearFilter" xml:space="preserve"><value>مسح عامل التصفية</value></data>
<data name="Archive.Set.Convert" xml:space="preserve"><value>تحويل…</value></data>
<data name="Archive.Set.Delete" xml:space="preserve"><value>حذف…</value></data>
<data name="Archive.Set.Export" xml:space="preserve"><value>تصدير CSV</value></data>
<data name="Archive.Set.Filter" xml:space="preserve"><value>تصفية المجموعة</value></data>
@@ -342,6 +468,7 @@
<data name="Archive.Toolbar.Scan" xml:space="preserve"><value>فحص</value></data>
<data name="Archive.Toolbar.Verify" xml:space="preserve"><value>تحقق</value></data>
<data name="Archive.Trash.Checking" xml:space="preserve"><value>جارٍ فحص سلة المحذوفات…</value></data>
<data name="Archive.Trash.ConversionDeleted" xml:space="preserve"><value>حُذفت النسخة المحوّلة</value></data>
<data name="Archive.Trash.Deleted" xml:space="preserve"><value>حُذف في {0}</value></data>
<data name="Archive.Trash.Empty" xml:space="preserve"><value>سلة المحذوفات فارغة</value></data>
<data name="Archive.Trash.EmptyAction" xml:space="preserve"><value>إفراغ…</value></data>
+1
View File
@@ -71,6 +71,7 @@
<data name="Jobs.Kind.Adopt" xml:space="preserve"><value>ضم مجلد</value></data>
<data name="Jobs.Kind.Backup" xml:space="preserve"><value>نسخ احتياطي للفهرس</value></data>
<data name="Jobs.Kind.Cleanup" xml:space="preserve"><value>تنظيف</value></data>
<data name="Jobs.Kind.Convert" xml:space="preserve"><value>تحويل</value></data>
<data name="Jobs.Kind.DeepAnalyse" xml:space="preserve"><value>تحليل معمّق</value></data>
<data name="Jobs.Kind.Download" xml:space="preserve"><value>تنزيل</value></data>
<data name="Jobs.Kind.Duplicates" xml:space="preserve"><value>التكرارات</value></data>
+2
View File
@@ -6,6 +6,7 @@
<resheader name="writer"><value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader>
<data name="Library.Action.Analyse" xml:space="preserve"><value>تحليل</value></data>
<data name="Library.Action.ClearSelection" xml:space="preserve"><value>مسح التحديد</value></data>
<data name="Library.Action.Convert" xml:space="preserve"><value>تحويل…</value></data>
<data name="Library.Action.Delete" xml:space="preserve"><value>حذف…</value></data>
<data name="Library.Action.Download" xml:space="preserve"><value>تنزيل</value></data>
<data name="Library.Action.ExportList" xml:space="preserve"><value>تصدير القائمة</value></data>
@@ -32,6 +33,7 @@
<data name="Library.Blocked.NothingToDownload" xml:space="preserve"><value>لا يوجد ما يُجلب من الخادم للتسلسلات المحددة.</value></data>
<data name="Library.Blocked.NothingToUpload" xml:space="preserve"><value>لدى الخادم بالفعل كل ما تحتويه التسلسلات المحددة.</value></data>
<data name="Library.Blocked.OneArchive" xml:space="preserve"><value>تعمل إعادة التنظيم على تسلسلات أرشيف واحد في كل مرة.</value></data>
<data name="Library.Blocked.OneArchiveConvert" xml:space="preserve"><value>يعمل التحويل على تسلسلات أرشيف واحد في كل مرة.</value></data>
<data name="Library.Blocked.ServerOnly" xml:space="preserve"><value>للتسلسلات الموجودة على هذا الكمبيوتر فقط؛ والتسلسلات المحددة موجودة على الخادم فقط.</value></data>
<data name="Library.Blocked.Transferring" xml:space="preserve"><value>تجري بالفعل عملية نقل لهذا التسلسل.</value></data>
<data name="Library.ClearFilters" xml:space="preserve"><value>مسح عوامل التصفية</value></data>
+4
View File
@@ -21,6 +21,8 @@
<data name="Server.Conflict.TakeServer.Message" xml:space="preserve"><value>ستُستبدل إعدادات {0} على هذا الكمبيوتر بنسخة الخادم.</value></data>
<data name="Server.Conflict.TakeServer.Title" xml:space="preserve"><value>اعتماد إعدادات الخادم؟</value></data>
<data name="Server.Connect" xml:space="preserve"><value>اتصال</value></data>
<data name="Server.Convert.OnPc" xml:space="preserve"><value>حوّل هذه الصور على كمبيوتر: لا يستطيع الخادم قراءتها بكامل الدقة.</value></data>
<data name="Server.Convert.OnPcNew" xml:space="preserve"><value>لا تُنسخ إلى التسلسل الجديد: لا يستطيع الخادم قراءة هذه الصور بكامل الدقة؛ حوّلها على كمبيوتر.</value></data>
<data name="Server.Disconnect" xml:space="preserve"><value>قطع الاتصال</value></data>
<data name="Server.Empty" xml:space="preserve"><value>غير متصل بخادم</value></data>
<data name="Server.Error.AccountLocked" xml:space="preserve"><value>محاولات تسجيل دخول فاشلة كثيرة جدًا؛ الحساب مقفل لبعض الوقت.</value></data>
@@ -71,7 +73,9 @@
<data name="Server.Error.MethodNotAllowed" xml:space="preserve"><value>هذا الأسلوب غير مسموح به هنا.</value></data>
<data name="Server.Error.NestedTarget" xml:space="preserve"><value>سيقع مجلد جديد داخل مجلد تسلسل آخر.</value></data>
<data name="Server.Error.NotChronos" xml:space="preserve"><value>هذا العنوان ليس خادم Chronos.</value></data>
<data name="Server.Error.NotEnoughSpace" xml:space="preserve"><value>لا تتوفر على وحدة تخزين الأرشيف المساحة التي يحتاجها التحويل.</value></data>
<data name="Server.Error.NotFound" xml:space="preserve"><value>غير موجود.</value></data>
<data name="Server.Error.NothingToConvert" xml:space="preserve"><value>لا تحوّل الخطة شيئًا: كل الصور متخطاة أو كل التسلسلات محظورة.</value></data>
<data name="Server.Error.PasswordChangeRequired" xml:space="preserve"><value>غيّر كلمة المرور أولًا.</value></data>
<data name="Server.Error.PhotoRemoved" xml:space="preserve"><value>حُذفت الصورة من التسلسل أثناء رفعها، لذا لم تُضَف.</value></data>
<data name="Server.Error.PhotoUnreadable" xml:space="preserve"><value>تتعذر قراءة {0}، ودون تجزئته لن تعرف النسخ الأخرى أنه حُذف؛ أغلق البرنامج الذي يستخدمه أو تحقق من أذوناته، ثم حاول مرة أخرى.</value></data>
+23 -1
View File
@@ -27,6 +27,23 @@
<data name="Tooltips.Archive.ClearFilter" xml:space="preserve"><value>إظهار كل تسلسلات التحديد مجددًا</value></data>
<data name="Tooltips.Archive.CloseDialog" xml:space="preserve"><value>الإغلاق دون تغيير أي شيء · Esc</value></data>
<data name="Tooltips.Archive.Collapse" xml:space="preserve"><value>إخفاء تسلسلات هذه السنة</value></data>
<data name="Tooltips.Archive.ConvertApplyNew" xml:space="preserve"><value>التأكيد، ثم إضافة مهمة إلى قائمة الانتظار تحوّل نسخًا إلى تسلسلات جديدة · يمكنك إيقافها مؤقتًا واستئنافها في «المهام»</value></data>
<data name="Tooltips.Archive.ConvertApplyReplace" xml:space="preserve"><value>كتابة عدد الصور للتأكيد، ثم إضافة مهمة إلى قائمة الانتظار تستبدلها بتحويلها · يمكنك إيقافها مؤقتًا واستئنافها في «المهام»</value></data>
<data name="Tooltips.Archive.ConvertBack" xml:space="preserve"><value>العودة إلى الخطة؛ لا يُحوَّل شيء</value></data>
<data name="Tooltips.Archive.ConvertDng" xml:space="preserve"><value>DNG خطي بعمق 16 بت وبلا فقدان · تقرؤه كل برامج تحرير RAW؛ الخيار الأنسب للأرشفة</value></data>
<data name="Tooltips.Archive.ConvertJpeg" xml:space="preserve"><value>JPEG بعمق 8 بت بالجودة المحددة أدناه · أصغر الملفات؛ مع فقدان بعض التفاصيل</value></data>
<data name="Tooltips.Archive.ConvertModeNew" xml:space="preserve"><value>توضع النسخ المحوّلة في تسلسل جديد بجوار كل تسلسل؛ وتبقى الملفات الأصلية كما هي</value></data>
<data name="Tooltips.Archive.ConvertModeReplace" xml:space="preserve"><value>تحل الملفات المحوّلة محل الصور في تسلسلاتها؛ وتُنقل الملفات الأصلية إلى سلة محذوفات الأرشيف، ويمكن استعادتها إلى أن تُفرَغ</value></data>
<data name="Tooltips.Archive.ConvertNew" xml:space="preserve"><value>إضافة مهمة إلى قائمة الانتظار تحوّل الصور إلى تسلسلات جديدة وتتحقق من كل تحويل؛ ولا تُمس الملفات الأصلية</value></data>
<data name="Tooltips.Archive.ConvertPlan" xml:space="preserve"><value>التسلسلات التي تُستبدل صورها</value></data>
<data name="Tooltips.Archive.ConvertPlanNew" xml:space="preserve"><value>التسلسلات المنسوخة إلى تسلسلات جديدة، والصور التي يستبعدها كل منها</value></data>
<data name="Tooltips.Archive.ConvertQuality" xml:space="preserve"><value>جودة JPEG من 1 إلى 100 · القيمة 95 تحتفظ بالتفاصيل الدقيقة؛ والقيم الأدنى تنتج ملفات أصغر</value></data>
<data name="Tooltips.Archive.ConvertReplace.few" xml:space="preserve"><value>استبدال {0:N0} صور بنسخها المحوّلة؛ اكتب العدد أعلاه أولًا</value></data>
<data name="Tooltips.Archive.ConvertReplace.many" xml:space="preserve"><value>استبدال {0:N0} صورة بنسخها المحوّلة؛ اكتب العدد أعلاه أولًا</value></data>
<data name="Tooltips.Archive.ConvertReplace.one" xml:space="preserve"><value>استبدال صورة واحدة بنسختها المحوّلة؛ اكتب العدد أعلاه أولًا</value></data>
<data name="Tooltips.Archive.ConvertReplace.other" xml:space="preserve"><value>استبدال {0:N0} صورة بنسخها المحوّلة؛ اكتب العدد أعلاه أولًا</value></data>
<data name="Tooltips.Archive.ConvertTiff" xml:space="preserve"><value>TIFF بعمق 16 بت مضغوط بلا فقدان · ملفات كبيرة يفتحها كل برنامج تحرير</value></data>
<data name="Tooltips.Archive.ConvertUndo" xml:space="preserve"><value>إعادة الملفات الأصلية من سلة المحذوفات إلى مكان نسخها المحوّلة</value></data>
<data name="Tooltips.Archive.DeleteAction.few" xml:space="preserve"><value>نقل {0:N0} تسلسلات إلى سلة المحذوفات؛ اكتب العدد أعلاه أولًا</value></data>
<data name="Tooltips.Archive.DeleteAction.many" xml:space="preserve"><value>نقل {0:N0} تسلسلًا إلى سلة المحذوفات؛ اكتب العدد أعلاه أولًا</value></data>
<data name="Tooltips.Archive.DeleteAction.one" xml:space="preserve"><value>نقل تسلسل واحد إلى سلة المحذوفات؛ اكتب العدد أعلاه أولًا</value></data>
@@ -84,6 +101,7 @@
<data name="Tooltips.Archive.Scan" xml:space="preserve"><value>فحص تزايدي: الملفات الجديدة والمتغيرة والمزالة حسب وقت التعديل والحجم</value></data>
<data name="Tooltips.Archive.Set" xml:space="preserve"><value>السنوات والتسلسلات المحددة (أو الكل عند عدم تحديد شيء)، مع تضييقها حسب الكاميرا أو الحالة أو الوسم</value></data>
<data name="Tooltips.Archive.SetAnalyse" xml:space="preserve"><value>تشغيل التحليل المعمّق على كل تسلسل في المجموعة</value></data>
<data name="Tooltips.Archive.SetConvert" xml:space="preserve"><value>تحويل صور المجموعة إلى JPEG أو TIFF أو DNG · بتشغيل تجريبي أولًا، ثم عبر مهمة</value></data>
<data name="Tooltips.Archive.SetDelete" xml:space="preserve"><value>نقل المجموعة إلى سلة محذوفات الأرشيف · يعرض التشغيل التجريبي، ثم يطلب منك الكتابة للتأكيد</value></data>
<data name="Tooltips.Archive.SetExport" xml:space="preserve"><value>تصدير المجموعة كملف CSV: صف واحد لكل تسلسل</value></data>
<data name="Tooltips.Archive.SetProxies" xml:space="preserve"><value>إنشاء النسخ الوكيلة أو تحديثها</value></data>
@@ -98,7 +116,7 @@
<data name="Tooltips.Archive.TitleTemplate" xml:space="preserve"><value>قالب العنوان؛ رمز العنوان هو العنوان الحالي · يُتحقق منه أثناء الكتابة</value></data>
<data name="Tooltips.Archive.Trash" xml:space="preserve"><value>التسلسلات والصور المحذوفة من هذا الأرشيف، ويمكن استعادة كل منها</value></data>
<data name="Tooltips.Archive.TrashEmpty" xml:space="preserve"><value>محو إدخالات سلة المحذوفات هذه نهائيًا، بعد فحص محتواها وتأكيد بالكتابة</value></data>
<data name="Tooltips.Archive.TrashEmptyPlan" xml:space="preserve"><value>ما سيُمحى من الأرشيف نهائيًا</value></data>
<data name="Tooltips.Archive.TrashEmptyPlan" xml:space="preserve"><value>ما سيُمحى من الأرشيف نهائيًا؛ وقد تكون الملفات الأصلية التي حُذفت نسخها المحوّلة آخر نسخة من صورها</value></data>
<data name="Tooltips.Archive.TrashErase.few" xml:space="preserve"><value>محو {0:N0} إدخالات نهائيًا؛ اكتب العدد أعلاه أولًا</value></data>
<data name="Tooltips.Archive.TrashErase.many" xml:space="preserve"><value>محو {0:N0} إدخالًا نهائيًا؛ اكتب العدد أعلاه أولًا</value></data>
<data name="Tooltips.Archive.TrashErase.one" xml:space="preserve"><value>محو إدخال واحد نهائيًا؛ اكتب العدد أعلاه أولًا</value></data>
@@ -476,6 +494,10 @@
<data name="Tooltips.Library.Mass.Analyse.many" xml:space="preserve"><value>تحليل معمّق لـ {0:N0} تسلسلًا على هذا الكمبيوتر · يعمل كمهمة واحدة</value></data>
<data name="Tooltips.Library.Mass.Analyse.one" xml:space="preserve"><value>تحليل معمّق لتسلسل واحد على هذا الكمبيوتر · يعمل كمهمة واحدة</value></data>
<data name="Tooltips.Library.Mass.Analyse.other" xml:space="preserve"><value>تحليل معمّق لـ {0:N0} تسلسل على هذا الكمبيوتر · يعمل كمهمة واحدة</value></data>
<data name="Tooltips.Library.Mass.Convert.few" xml:space="preserve"><value>تحويل صور {0:N0} تسلسلات في أرشيفها إلى JPEG أو TIFF أو DNG · بتشغيل تجريبي أولًا، ثم عبر مهمة</value></data>
<data name="Tooltips.Library.Mass.Convert.many" xml:space="preserve"><value>تحويل صور {0:N0} تسلسلًا في أرشيفها إلى JPEG أو TIFF أو DNG · بتشغيل تجريبي أولًا، ثم عبر مهمة</value></data>
<data name="Tooltips.Library.Mass.Convert.one" xml:space="preserve"><value>تحويل صور تسلسل واحد إلى JPEG أو TIFF أو DNG · بتشغيل تجريبي أولًا، ثم عبر مهمة</value></data>
<data name="Tooltips.Library.Mass.Convert.other" xml:space="preserve"><value>تحويل صور {0:N0} تسلسل في أرشيفها إلى JPEG أو TIFF أو DNG · بتشغيل تجريبي أولًا، ثم عبر مهمة</value></data>
<data name="Tooltips.Library.Mass.Delete.few" xml:space="preserve"><value>نقل {0:N0} تسلسلات إلى سلة محذوفات أرشيفها · يعرض التشغيل التجريبي، ثم يطلب منك الكتابة للتأكيد</value></data>
<data name="Tooltips.Library.Mass.Delete.many" xml:space="preserve"><value>نقل {0:N0} تسلسلًا إلى سلة محذوفات أرشيفها · يعرض التشغيل التجريبي، ثم يطلب منك الكتابة للتأكيد</value></data>
<data name="Tooltips.Library.Mass.Delete.one" xml:space="preserve"><value>نقل تسلسل واحد إلى سلة محذوفات أرشيفه · يعرض التشغيل التجريبي، ثم يطلب منك الكتابة للتأكيد</value></data>
+69
View File
@@ -9,6 +9,7 @@
<data name="Admin.About.Title" xml:space="preserve"><value>Chronos Server</value></data>
<data name="Admin.About.Uptime" xml:space="preserve"><value>Време на работа</value></data>
<data name="Admin.About.Version" xml:space="preserve"><value>Версия</value></data>
<data name="Admin.Activity.ArchiveConverted" xml:space="preserve"><value>{0} постави на опашка конвертиране · {1}</value></data>
<data name="Admin.Activity.ArchiveReorganized" xml:space="preserve"><value>{0} реорганизира архива · {1}</value></data>
<data name="Admin.Activity.ArchiveSettings" xml:space="preserve"><value>{0} промени структурата на архива</value></data>
<data name="Admin.Activity.FramesDeleted" xml:space="preserve"><value>{0} изтри {1}</value></data>
@@ -83,6 +84,68 @@
<data name="Admin.Common.TypeToConfirm.Tip" xml:space="preserve"><value>Въведете името точно както е показано, за да потвърдите</value></data>
<data name="Admin.Common.TypeWord.Tip" xml:space="preserve"><value>Въведете думата точно както е показана; главните и малките букви нямат значение</value></data>
<data name="Admin.Common.TypeWordFirst.Tip" xml:space="preserve"><value>Първо въведете думата по-горе</value></data>
<data name="Admin.Convert.Action" xml:space="preserve"><value>Конвертиране…</value></data>
<data name="Admin.Convert.Action.Tip" xml:space="preserve"><value>Конвертира снимките на избраните серии в JPEG, TIFF-16 или линеен DNG; визуализацията първо показва всяка серия</value></data>
<data name="Admin.Convert.Apply" xml:space="preserve"><value>Конвертиране…</value></data>
<data name="Admin.Convert.Apply.Tip" xml:space="preserve"><value>Конвертира според визуализацията; първо се иска потвърждение</value></data>
<data name="Admin.Convert.Cancel.Tip" xml:space="preserve"><value>Затваря, без да конвертира нищо</value></data>
<data name="Admin.Convert.ChooseMode" xml:space="preserve"><value>Изберете „Замяна“ или „Нова серия“, за да конвертирате.</value></data>
<data name="Admin.Convert.ChooseMode.Tip" xml:space="preserve"><value>Първо изберете „Замяна“ или „Нова серия“</value></data>
<data name="Admin.Convert.Column.Converted" xml:space="preserve"><value>Конвертирани</value></data>
<data name="Admin.Convert.Column.NotCopied" xml:space="preserve"><value>Некопирани</value></data>
<data name="Admin.Convert.Column.Sequence" xml:space="preserve"><value>Серия</value></data>
<data name="Admin.Convert.Column.Size" xml:space="preserve"><value>Размер</value></data>
<data name="Admin.Convert.Column.Unchanged" xml:space="preserve"><value>Непроменени</value></data>
<data name="Admin.Convert.Confirm.New" xml:space="preserve"><value>Конвертиране</value></data>
<data name="Admin.Convert.Confirm.New.Tip" xml:space="preserve"><value>Поставя на опашка задачата, която конвертира снимките в нови серии и проверява всяко конвертиране; оригиналите остават непокътнати</value></data>
<data name="Admin.Convert.Confirm.Replace" xml:space="preserve"><value>Замяна</value></data>
<data name="Admin.Convert.Confirm.Replace.Tip" xml:space="preserve"><value>Поставя на опашка задачата, която конвертира снимките, проверява всяко конвертиране и премества оригиналите в кошчето</value></data>
<data name="Admin.Convert.ConfirmNew.one" xml:space="preserve"><value>{0} снимка се конвертира в копие в нова серия; оригиналът остава непроменен.</value></data>
<data name="Admin.Convert.ConfirmNew.other" xml:space="preserve"><value>{0} снимки се конвертират в копия в нова серия до всяка изходна серия; оригиналите остават непроменени.</value></data>
<data name="Admin.Convert.ConfirmNewNotCopied.one" xml:space="preserve"><value>{0} снимка не се копира в новата серия по причината, посочена във визуализацията.</value></data>
<data name="Admin.Convert.ConfirmNewNotCopied.other" xml:space="preserve"><value>{0} снимки не се копират в новите серии по причините, посочени във визуализацията.</value></data>
<data name="Admin.Convert.ConfirmNewTitle" xml:space="preserve"><value>Да се конвертира ли в {0} в нови серии?</value></data>
<data name="Admin.Convert.ConfirmReplace.one" xml:space="preserve"><value>{0} снимка в {1} се заменя с конвертираната си версия; оригиналът отива в кошчето и може да бъде възстановен, докато кошчето не бъде изпразнено.</value></data>
<data name="Admin.Convert.ConfirmReplace.other" xml:space="preserve"><value>{0} снимки в {1} се заменят с конвертираните си версии; оригиналите отиват в кошчето и могат да бъдат възстановени, докато кошчето не бъде изпразнено.</value></data>
<data name="Admin.Convert.ConfirmReplaceTitle" xml:space="preserve"><value>Да се заменят ли оригиналите с {0}?</value></data>
<data name="Admin.Convert.Format" xml:space="preserve"><value>Формат</value></data>
<data name="Admin.Convert.Format.Jpeg.Tip" xml:space="preserve"><value>8-битов JPEG с цвят в пълна резолюция и с качеството, зададено до него: най-малките файлове, които всяка програма отваря</value></data>
<data name="Admin.Convert.Format.LinearDng" xml:space="preserve"><value>Линеен DNG</value></data>
<data name="Admin.Convert.Format.LinearDng.Tip" xml:space="preserve"><value>16-битов линеен DNG, компресиран без загуби: изборът за дългосрочно съхранение, отваря се от програмите за обработка на RAW</value></data>
<data name="Admin.Convert.Format.Tiff16.Tip" xml:space="preserve"><value>16-битов sRGB TIFF, компресиран без загуби: големи файлове, които запазват всеки тон за редактиране</value></data>
<data name="Admin.Convert.Gone" xml:space="preserve"><value>Една от избраните серии вече не е в архива; затворете и изберете отново.</value></data>
<data name="Admin.Convert.Mode" xml:space="preserve"><value>Режим</value></data>
<data name="Admin.Convert.Mode.NewSequence" xml:space="preserve"><value>Нова серия</value></data>
<data name="Admin.Convert.Mode.NewSequence.Tip" xml:space="preserve"><value>Конвертираните копия отиват в нова серия до всяка изходна; оригиналите и тяхната серия остават точно такива, каквито са</value></data>
<data name="Admin.Convert.Mode.Replace" xml:space="preserve"><value>Замяна</value></data>
<data name="Admin.Convert.Mode.Replace.Tip" xml:space="preserve"><value>Конвертираните файлове стават снимките на серията; оригиналите отиват в кошчето на архива и могат да бъдат възстановени, докато то не бъде изпразнено</value></data>
<data name="Admin.Convert.NoAnswer" xml:space="preserve"><value>Сървърът не отговори: преди да конвертирате отново, проверете на страницата „Задачи“ дали конвертирането е поставено на опашка.</value></data>
<data name="Admin.Convert.NoSpace.Tip" xml:space="preserve"><value>Първо освободете място в тома на архива</value></data>
<data name="Admin.Convert.NotCopiedCount.one" xml:space="preserve"><value>{0} некопирана</value></data>
<data name="Admin.Convert.NotCopiedCount.other" xml:space="preserve"><value>{0} некопирани</value></data>
<data name="Admin.Convert.Nothing.Tip" xml:space="preserve"><value>Във визуализацията няма нищо за конвертиране</value></data>
<data name="Admin.Convert.NothingToConvert" xml:space="preserve"><value>Няма какво да се конвертира: всяка снимка остава такава, каквато е, по посочените причини.</value></data>
<data name="Admin.Convert.OpenJob" xml:space="preserve"><value>Отваряне на задачата</value></data>
<data name="Admin.Convert.OpenJob.Tip" xml:space="preserve"><value>Показва задачата и журнала ѝ на страницата „Задачи“</value></data>
<data name="Admin.Convert.PlanChanged" xml:space="preserve"><value>Архивът се промени след визуализацията; проверете новата и приложете отново.</value></data>
<data name="Admin.Convert.Planning" xml:space="preserve"><value>Планиране…</value></data>
<data name="Admin.Convert.Planning.Tip" xml:space="preserve"><value>Сървърът прочита всяка папка със снимки от избраното: при голям архив това отнема минути, а визуализацията се появява, когато приключи</value></data>
<data name="Admin.Convert.PlanningFor" xml:space="preserve"><value>Планиране… {0}</value></data>
<data name="Admin.Convert.Preview" xml:space="preserve"><value>Визуализация</value></data>
<data name="Admin.Convert.Preview.Tip" xml:space="preserve"><value>Какво конвертира и какво оставя непроменено всяка серия, с размера преди и след (прогнозен); още нищо не е променено</value></data>
<data name="Admin.Convert.Quality" xml:space="preserve"><value>Качество</value></data>
<data name="Admin.Convert.Quality.Tip" xml:space="preserve"><value>Качество на JPEG от 1 до 100; 95 запазва фините детайли, по-ниските стойности дават по-малки файлове</value></data>
<data name="Admin.Convert.QualityRange" xml:space="preserve"><value>Въведете цяло число от 1 до 100.</value></data>
<data name="Admin.Convert.Queued" xml:space="preserve"><value>Конвертирането е на опашка.</value></data>
<data name="Admin.Convert.ReplaceWord" xml:space="preserve"><value>замяна</value></data>
<data name="Admin.Convert.Size.Tip" xml:space="preserve"><value>Текущият размер на снимките за конвертиране, след това прогнозният размер след конвертирането</value></data>
<data name="Admin.Convert.SkippedPhotos" xml:space="preserve"><value>{0}: {1}</value></data>
<data name="Admin.Convert.Title.one" xml:space="preserve"><value>Конвертиране на {0} серия</value></data>
<data name="Admin.Convert.Title.other" xml:space="preserve"><value>Конвертиране на {0} серии</value></data>
<data name="Admin.Convert.TitleAll" xml:space="preserve"><value>Конвертиране на всички серии</value></data>
<data name="Admin.Convert.TooMany" xml:space="preserve"><value>Конвертирането обработва най-много {0} серии наведнъж или всички серии: изчистете филтрите и изберете всички.</value></data>
<data name="Admin.Convert.Totals" xml:space="preserve"><value>Конвертирани серии: {0} · снимки: {1} · непроменени: {2} · размер: {3} → {4}</value></data>
<data name="Admin.Convert.TotalsNew" xml:space="preserve"><value>Конвертирани серии: {0} · снимки: {1} · некопирани: {2} · размер: {3} → {4}</value></data>
<data name="Admin.Dashboard.Activity" xml:space="preserve"><value>Скорошна активност</value></data>
<data name="Admin.Dashboard.AllLogs" xml:space="preserve"><value>Всички журнали</value></data>
<data name="Admin.Dashboard.AllLogs.Tip" xml:space="preserve"><value>Отваря журнала за одит</value></data>
@@ -133,6 +196,7 @@
<data name="Admin.Job.Kind.Adopt" xml:space="preserve"><value>Присъединяване</value></data>
<data name="Admin.Job.Kind.Backup" xml:space="preserve"><value>Резервно копие</value></data>
<data name="Admin.Job.Kind.Cleanup" xml:space="preserve"><value>Почистване</value></data>
<data name="Admin.Job.Kind.Convert" xml:space="preserve"><value>Конвертиране</value></data>
<data name="Admin.Job.Kind.DeepAnalyse" xml:space="preserve"><value>Задълбочен анализ</value></data>
<data name="Admin.Job.Kind.Duplicates" xml:space="preserve"><value>Дубликати</value></data>
<data name="Admin.Job.Kind.EmptyTrash" xml:space="preserve"><value>Изпразване на кошчето</value></data>
@@ -344,6 +408,7 @@
<data name="Admin.Login.SignIn.Tip" xml:space="preserve"><value>Влизане за администриране на този сървър</value></data>
<data name="Admin.Login.User" xml:space="preserve"><value>Потребител</value></data>
<data name="Admin.Login.User.Tip" xml:space="preserve"><value>Вашето потребителско име на този сървър</value></data>
<data name="Admin.Logs.Action.ArchiveConverted" xml:space="preserve"><value>Конвертирани снимки</value></data>
<data name="Admin.Logs.Action.ArchiveReorganized" xml:space="preserve"><value>Реорганизиран архив</value></data>
<data name="Admin.Logs.Action.ArchiveSettings" xml:space="preserve"><value>Структура на архива</value></data>
<data name="Admin.Logs.Action.FramesDeleted" xml:space="preserve"><value>Изтрити снимки</value></data>
@@ -793,6 +858,7 @@
<data name="Admin.Theme.Tip" xml:space="preserve"><value>Превключва между светла и тъмна тема</value></data>
<data name="Admin.Trash.Back" xml:space="preserve"><value>Библиотека</value></data>
<data name="Admin.Trash.Back.Tip" xml:space="preserve"><value>Връща към Библиотеката</value></data>
<data name="Admin.Trash.ConversionDeleted" xml:space="preserve"><value>конвертираната версия е изтрита</value></data>
<data name="Admin.Trash.DeletedAt" xml:space="preserve"><value>Дата на изтриване</value></data>
<data name="Admin.Trash.DeletedBy" xml:space="preserve"><value>Изтрит от</value></data>
<data name="Admin.Trash.Emptied" xml:space="preserve"><value>Кошчето е изпразнено.</value></data>
@@ -819,9 +885,12 @@
<data name="Admin.Trash.Photos" xml:space="preserve"><value>Снимки</value></data>
<data name="Admin.Trash.Restore" xml:space="preserve"><value>Възстановяване</value></data>
<data name="Admin.Trash.RestorePhotos.Tip" xml:space="preserve"><value>Връща снимките в тяхната серия (в нова, ако тя вече не съществува); всяка първо се проверява спрямо своя SHA-256</value></data>
<data name="Admin.Trash.RestoreReplaced.Tip" xml:space="preserve"><value>Връща оригиналите на мястото на конвертираните им версии, ако те не са променени (конвертираните версии отиват в кошчето), иначе – в нова серия; всеки първо се проверява спрямо своя SHA-256</value></data>
<data name="Admin.Trash.RestoreSequence.Tip" xml:space="preserve"><value>Връща папката на серията в библиотеката такава, каквато е (до старото ѝ място, ако то е заето); снимките ѝ не се проверяват по хеш: това прави „Проверка“</value></data>
<data name="Admin.Trash.RestoredNew.one" xml:space="preserve"><value>{0} снимка е възстановена в нова серия.</value></data>
<data name="Admin.Trash.RestoredNew.other" xml:space="preserve"><value>{0} снимки са възстановени в нова серия.</value></data>
<data name="Admin.Trash.RestoredOriginals.one" xml:space="preserve"><value>{0} оригинал отново е в серията {1}; конвертираната му версия е в кошчето.</value></data>
<data name="Admin.Trash.RestoredOriginals.other" xml:space="preserve"><value>{0} оригинала отново са в серията {1}; конвертираните им версии са в кошчето.</value></data>
<data name="Admin.Trash.RestoredPhotos.one" xml:space="preserve"><value>{0} снимка отново е в серията {1}.</value></data>
<data name="Admin.Trash.RestoredPhotos.other" xml:space="preserve"><value>{0} снимки отново са в серията {1}.</value></data>
<data name="Admin.Trash.RestoredSequence" xml:space="preserve"><value>Серията {0} отново е в библиотеката.</value></data>
+108 -3
View File
@@ -15,8 +15,10 @@
<data name="Archive.Blocked.Applying" xml:space="preserve"><value>Изчакайте промените да бъдат приложени.</value></data>
<data name="Archive.Blocked.EmptySet" xml:space="preserve"><value>Наборът е празен: променете избора или филтъра.</value></data>
<data name="Archive.Blocked.NoChanges" xml:space="preserve"><value>Нищо няма да се промени.</value></data>
<data name="Archive.Blocked.NoMode" xml:space="preserve"><value>Изберете „Замяна“ или „Нова серия“.</value></data>
<data name="Archive.Blocked.NoTemplate" xml:space="preserve"><value>Включете поне един шаблон.</value></data>
<data name="Archive.Blocked.NotOnline" xml:space="preserve"><value>Архивът трябва да е онлайн и да позволява запис.</value></data>
<data name="Archive.Blocked.NothingToConvert" xml:space="preserve"><value>Няма какво да се конвертира: всички снимки се пропускат или всички серии са блокирани.</value></data>
<data name="Archive.Blocked.Planning" xml:space="preserve"><value>Изчакайте пробното изпълнение.</value></data>
<data name="Archive.Blocked.Reading" xml:space="preserve"><value>Изчакайте архивът да бъде прочетен.</value></data>
<data name="Archive.Blocked.Searching" xml:space="preserve"><value>Тече търсене; отменете го или изчакайте.</value></data>
@@ -32,6 +34,82 @@
<data name="Archive.Confirm.Remove" xml:space="preserve"><value>Премахване на реда</value></data>
<data name="Archive.Confirm.RemoveHeading" xml:space="preserve"><value>Да се премахне ли {0} от индекса?</value></data>
<data name="Archive.Confirm.RemoveMessage" xml:space="preserve"><value>Sidecar файлът ѝ вече липсва. Премахва се само редът в индекса; никой файл не се изтрива.</value></data>
<data name="Archive.Convert.AlreadyQueued" xml:space="preserve"><value>Конвертиране на тези серии вече чака или се изпълнява; следете го в „Задачи“.</value></data>
<data name="Archive.Convert.Blocked.Busy" xml:space="preserve"><value>Задача работи върху тази серия; конвертирайте я, когато задачата приключи.</value></data>
<data name="Archive.Convert.Blocked.FramesChanged" xml:space="preserve"><value>Серията се промени след създаването на плана; прегледайте плана отново.</value></data>
<data name="Archive.Convert.Blocked.Offline" xml:space="preserve"><value>Архивът е офлайн или само за четене.</value></data>
<data name="Archive.Convert.Blocked.Unreadable" xml:space="preserve"><value>Файлът на серията не може да бъде прочетен.</value></data>
<data name="Archive.Convert.Confirm" xml:space="preserve"><value>Конвертиране</value></data>
<data name="Archive.Convert.CopyUnfinished" xml:space="preserve"><value>Друго конвертиране вече е създало копие на серията в този формат и не е завършило; първо го завършете или опитайте отново.</value></data>
<data name="Archive.Convert.Done.one" xml:space="preserve"><value>{0:N0} серия е конвертирана</value></data>
<data name="Archive.Convert.Done.other" xml:space="preserve"><value>{0:N0} серии са конвертирани</value></data>
<data name="Archive.Convert.Failed.Changed" xml:space="preserve"><value>Снимката вече не съвпада с копието, записано в архива; проверете серията.</value></data>
<data name="Archive.Convert.Failed.ColorProfile" xml:space="preserve"><value>Цветовият ѝ профил не може нито да бъде запазен, нито конвертиран в този формат.</value></data>
<data name="Archive.Convert.Failed.Damaged" xml:space="preserve"><value>Пикселите ѝ съдържат стойности, които не са числа: файлът е повреден.</value></data>
<data name="Archive.Convert.Failed.EightBit" xml:space="preserve"><value>Този компютър проявява този RAW файл само с 8 бита, твърде малко за 16-битов файл; в JPEG може да бъде конвертиран.</value></data>
<data name="Archive.Convert.Failed.Full" xml:space="preserve"><value>Дискът на архива е пълен.</value></data>
<data name="Archive.Convert.Failed.NoDecoder" xml:space="preserve"><value>Нито един декодер на този компютър не я чете в пълна резолюция.</value></data>
<data name="Archive.Convert.Failed.NotVerified" xml:space="preserve"><value>Конвертираният файл не се прочете обратно такъв, какъвто е бил записан.</value></data>
<data name="Archive.Convert.Failed.Other" xml:space="preserve"><value>Конвертираният файл не можа да бъде създаден.</value></data>
<data name="Archive.Convert.Failed.PreviewOnly" xml:space="preserve"><value>Този компютър я чете само от вградената ѝ визуализация: конвертирайте я на компютър, който я чете в пълна резолюция.</value></data>
<data name="Archive.Convert.Failed.TooLarge" xml:space="preserve"><value>По-голяма е от това, което този формат побира, което Chronos може да прочете обратно или което паметта за една снимка може да побере.</value></data>
<data name="Archive.Convert.Failed.Unreadable" xml:space="preserve"><value>Снимката не можа да бъде декодирана.</value></data>
<data name="Archive.Convert.Format" xml:space="preserve"><value>Формат</value></data>
<data name="Archive.Convert.Heading.one" xml:space="preserve"><value>Конвертиране на {0:N0} серия</value></data>
<data name="Archive.Convert.Heading.other" xml:space="preserve"><value>Конвертиране на {0:N0} серии</value></data>
<data name="Archive.Convert.HeadingAll" xml:space="preserve"><value>Конвертиране на {0}</value></data>
<data name="Archive.Convert.Mode" xml:space="preserve"><value>Режим</value></data>
<data name="Archive.Convert.NewHeading.one" xml:space="preserve"><value>Да се конвертира ли {0:N0} серия в нова?</value></data>
<data name="Archive.Convert.NewHeading.other" xml:space="preserve"><value>Да се конвертират ли {0:N0} серии в нови?</value></data>
<data name="Archive.Convert.NewLeftOut.one" xml:space="preserve"><value>{0:N0} снимка не се копира: остава само в изходната си серия по причината, посочена в плана.</value></data>
<data name="Archive.Convert.NewLeftOut.other" xml:space="preserve"><value>{0:N0} снимки не се копират: остават само в изходната си серия по причините, посочени в плана.</value></data>
<data name="Archive.Convert.NewMessage" xml:space="preserve"><value>Конвертиране в {2}: {0} ({1}) в нова серия до всяка изходна; оригиналите остават непроменени.</value></data>
<data name="Archive.Convert.NewSequence" xml:space="preserve"><value>Нова серия</value></data>
<data name="Archive.Convert.NotCopied.ColorProfile" xml:space="preserve"><value>Снимките, чийто цветови профил този формат не може нито да запази, нито да конвертира, не се копират в новата серия.</value></data>
<data name="Archive.Convert.NotCopied.EightBit" xml:space="preserve"><value>RAW снимките, които този компютър проявява само с 8 бита, не се копират в новата серия; в JPEG могат да бъдат конвертирани.</value></data>
<data name="Archive.Convert.NotCopied.Inaccessible" xml:space="preserve"><value>Снимките, които друга програма държи отворени или които не могат да бъдат отворени, не се копират в новата серия; планирайте отново, когато се освободят.</value></data>
<data name="Archive.Convert.NotCopied.Missing" xml:space="preserve"><value>Липсващите снимки не се копират в новата серия.</value></data>
<data name="Archive.Convert.NotCopied.NoNativeDecoder" xml:space="preserve"><value>Снимките във формат, който този компютър не може да прочете в пълна резолюция, не се копират в новата серия.</value></data>
<data name="Archive.Convert.NotCopied.PreviewOnly" xml:space="preserve"><value>Снимките, които тук се четат само от вградената си визуализация, не се копират в новата серия.</value></data>
<data name="Archive.Convert.NotCopied.SameFormat" xml:space="preserve"><value>Снимките, които вече са в този формат, не се копират в новата серия.</value></data>
<data name="Archive.Convert.NotCopied.TooLarge" xml:space="preserve"><value>Снимките, по-големи от това, което този формат побира или Chronos може да прочете обратно, не се копират в новата серия.</value></data>
<data name="Archive.Convert.NotCopied.Undecodable" xml:space="preserve"><value>Нечетимите снимки не се копират в новата серия.</value></data>
<data name="Archive.Convert.NotCopied.Unhashed" xml:space="preserve"><value>Снимките, които никога не са проверявани, не се копират в новата серия; първо проверете серията.</value></data>
<data name="Archive.Convert.NotCopiedPhotos.one" xml:space="preserve"><value>{0:N0} некопирана</value></data>
<data name="Archive.Convert.NotCopiedPhotos.other" xml:space="preserve"><value>{0:N0} некопирани</value></data>
<data name="Archive.Convert.NotPlaced" xml:space="preserve"><value>Конвертираните снимки не можаха да заемат мястото си. {0}</value></data>
<data name="Archive.Convert.PhotoFailed" xml:space="preserve"><value>Файлът {0} не можа да бъде конвертиран. {1}</value></data>
<data name="Archive.Convert.PhotoHeld" xml:space="preserve"><value>Снимка от серията е отворена от друга програма или не може да бъде отворена; опитайте отново, когато се освободи.</value></data>
<data name="Archive.Convert.Quality" xml:space="preserve"><value>Качество</value></data>
<data name="Archive.Convert.Replace" xml:space="preserve"><value>Замяна</value></data>
<data name="Archive.Convert.ReplaceHeading.one" xml:space="preserve"><value>Да се заменят ли снимките на {0:N0} серия?</value></data>
<data name="Archive.Convert.ReplaceHeading.other" xml:space="preserve"><value>Да се заменят ли снимките на {0:N0} серии?</value></data>
<data name="Archive.Convert.ReplaceMessage" xml:space="preserve"><value>Замяна с конвертиране в {2}: {0} ({1}); оригиналите се преместват в кошчето на архива и могат да бъдат възстановени, докато то не бъде изпразнено.</value></data>
<data name="Archive.Convert.Sizes" xml:space="preserve"><value>{0} → {1}</value></data>
<data name="Archive.Convert.Skipped.ColorProfile" xml:space="preserve"><value>Снимките, чийто цветови профил този формат не може нито да запази, нито да конвертира, остават непроменени.</value></data>
<data name="Archive.Convert.Skipped.EightBit" xml:space="preserve"><value>RAW снимките, които този компютър проявява само с 8 бита, остават непроменени; в JPEG могат да бъдат конвертирани.</value></data>
<data name="Archive.Convert.Skipped.Inaccessible" xml:space="preserve"><value>Снимките, които друга програма държи отворени или които не могат да бъдат отворени, остават непроменени; планирайте отново, когато се освободят.</value></data>
<data name="Archive.Convert.Skipped.Missing" xml:space="preserve"><value>Липсващите снимки остават непроменени.</value></data>
<data name="Archive.Convert.Skipped.NoNativeDecoder" xml:space="preserve"><value>Снимките във формат, който този компютър не може да прочете в пълна резолюция, остават непроменени.</value></data>
<data name="Archive.Convert.Skipped.PreviewOnly" xml:space="preserve"><value>Снимките, които тук се четат само от вградената си визуализация, остават непроменени.</value></data>
<data name="Archive.Convert.Skipped.SameFormat" xml:space="preserve"><value>Снимките, които вече са в този формат, остават непроменени.</value></data>
<data name="Archive.Convert.Skipped.TooLarge" xml:space="preserve"><value>Снимките, по-големи от това, което този формат побира или Chronos може да прочете обратно, остават непроменени.</value></data>
<data name="Archive.Convert.Skipped.Undecodable" xml:space="preserve"><value>Нечетимите снимки остават непроменени.</value></data>
<data name="Archive.Convert.Skipped.Unhashed" xml:space="preserve"><value>Снимките, които никога не са проверявани, остават непроменени; първо проверете серията.</value></data>
<data name="Archive.Convert.SkippedPhotos.one" xml:space="preserve"><value>{0:N0} пропусната</value></data>
<data name="Archive.Convert.SkippedPhotos.other" xml:space="preserve"><value>{0:N0} пропуснати</value></data>
<data name="Archive.Convert.Space" xml:space="preserve"><value>Нужни: {0}, свободни: {1}</value></data>
<data name="Archive.Convert.SpaceShort" xml:space="preserve"><value>Нужни: {0}, свободни са само {1}; първо освободете място.</value></data>
<data name="Archive.Convert.SpaceUnknown" xml:space="preserve"><value>Нужни: {0}; свободното място не може да бъде измерено.</value></data>
<data name="Archive.Convert.Target.LinearDng" xml:space="preserve"><value>Линеен DNG</value></data>
<data name="Archive.Convert.Target.Tiff16" xml:space="preserve"><value>TIFF 16 бита</value></data>
<data name="Archive.Convert.UndoFailed" xml:space="preserve"><value>Оригиналите не можаха да бъдат върнати</value></data>
<data name="Archive.Convert.UndoNothing" xml:space="preserve"><value>Заменените оригинали вече не са в кошчето.</value></data>
<data name="Archive.Convert.Undone.one" xml:space="preserve"><value>Оригиналите са върнати в {0:N0} серия</value></data>
<data name="Archive.Convert.Undone.other" xml:space="preserve"><value>Оригиналите са върнати в {0:N0} серии</value></data>
<data name="Archive.Convert.UndoneNew.one" xml:space="preserve"><value>{0:N0} серия се е променила междувременно: оригиналите ѝ са върнати като нова серия.</value></data>
<data name="Archive.Convert.UndoneNew.other" xml:space="preserve"><value>{0:N0} серии са се променили междувременно: оригиналите им са върнати като нови серии.</value></data>
<data name="Archive.Convert.Unstaged" xml:space="preserve"><value>Конвертираната версия на {0} вече не е сред подготвените файлове; повторният опит ще конвертира снимката отново.</value></data>
<data name="Archive.Copy.Title" xml:space="preserve"><value>Папка за копиране в архива</value></data>
<data name="Archive.Delete.Action" xml:space="preserve"><value>Преместване в кошчето</value></data>
<data name="Archive.Delete.Blocked" xml:space="preserve"><value>Не е преместена: {0} · {1}</value></data>
@@ -75,6 +153,9 @@
<data name="Archive.Duplicates.Title" xml:space="preserve"><value>Дубликати</value></data>
<data name="Archive.Empty" xml:space="preserve"><value>Още няма архив</value></data>
<data name="Archive.Error.Busy" xml:space="preserve"><value>Друг Chronos ({0}) записва тук. Опитайте отново след малко.</value></data>
<data name="Archive.Error.ConvertKept.one" xml:space="preserve"><value>{0:N0} серия не беше конвертирана според плана; причината е в журнала на задачата.</value></data>
<data name="Archive.Error.ConvertKept.other" xml:space="preserve"><value>{0:N0} серии не бяха конвертирани според плана; причината е в журнала на задачата.</value></data>
<data name="Archive.Error.ConvertSpace" xml:space="preserve"><value>Конвертирането изисква {0} свободно място в тома на архива, а свободни са {1}.</value></data>
<data name="Archive.Error.CopyMismatch" xml:space="preserve"><value>Копието на {0} не съвпада с оригинала.</value></data>
<data name="Archive.Error.DuplicateLost" xml:space="preserve"><value>{0} не можа да бъде добавен към серията.</value></data>
<data name="Archive.Error.InLibrary" xml:space="preserve"><value>{0} вече е в библиотеката.</value></data>
@@ -92,8 +173,8 @@
<data name="Archive.Error.SourceGone" xml:space="preserve"><value>Картата или папката {0} вече не е достъпна.</value></data>
<data name="Archive.Error.StalePlan" xml:space="preserve"><value>Архивът се промени след създаването на този план.</value></data>
<data name="Archive.Error.TrashChanged" xml:space="preserve"><value>Кошчето се промени след проверката; нищо не е изтрито.</value></data>
<data name="Archive.Error.TrashKept.one" xml:space="preserve"><value>{0:N0} запис в кошчето е запазен: променил се е или заменящият файл вече не съвпада.</value></data>
<data name="Archive.Error.TrashKept.other" xml:space="preserve"><value>{0:N0} записа в кошчето са запазени: променили са се или заменящ файл вече не съвпада.</value></data>
<data name="Archive.Error.TrashKept.one" xml:space="preserve"><value>{0:N0} запис в кошчето е запазен; причината е в журнала на задачата.</value></data>
<data name="Archive.Error.TrashKept.other" xml:space="preserve"><value>{0:N0} записа в кошчето са запазени; причината е в журнала на задачата.</value></data>
<data name="Archive.Error.TrashMismatch" xml:space="preserve"><value>Нито един файл от този запис в кошчето вече не съответства на записаните за него данни; записът остава в кошчето.</value></data>
<data name="Archive.Failed.Access" xml:space="preserve"><value>На Chronos беше отказан достъп до архива.</value></data>
<data name="Archive.Failed.Files" xml:space="preserve"><value>Файл от архива не можа да бъде прочетен или записан.</value></data>
@@ -132,6 +213,15 @@
<data name="Archive.Log.AuditKept" xml:space="preserve"><value>Журналът за одит е запазен изцяло</value></data>
<data name="Archive.Log.AuditPurged" xml:space="preserve"><value>Премахнати записи от одита: {0}</value></data>
<data name="Archive.Log.BackupDone" xml:space="preserve"><value>Индексът е копиран в {0} ({1}); запазени копия: {2}</value></data>
<data name="Archive.Log.ConvertBlocked" xml:space="preserve"><value>Оставена както беше, заета или нечетима: {0}</value></data>
<data name="Archive.Log.ConvertChanged" xml:space="preserve"><value>Оставена както беше, променена след създаването на плана: {0}. Повторният опит я оставя такава, каквато е: конвертирайте я отново по нов план.</value></data>
<data name="Archive.Log.ConvertDone" xml:space="preserve"><value>Конвертирани серии: {0}, нови серии: {1}, снимки: {2}</value></data>
<data name="Archive.Log.ConvertFailed" xml:space="preserve"><value>Оставена както беше: {0}. {1}</value></data>
<data name="Archive.Log.ConvertLeftOut" xml:space="preserve"><value>{0}: неконвертирани снимки, останали само в изходната серия: {1}</value></data>
<data name="Archive.Log.ConvertNothing" xml:space="preserve"><value>Няма какво да се конвертира: {0}</value></data>
<data name="Archive.Log.ConvertSuperseded" xml:space="preserve"><value>{0}: след потвърждаването на това конвертиране друго вече е създало копието в този формат; второ копие не се създава.</value></data>
<data name="Archive.Log.Converted" xml:space="preserve"><value>{0}: снимки, заменени с конвертираните си версии: {1}</value></data>
<data name="Archive.Log.ConvertedNew" xml:space="preserve"><value>{0}: снимки, конвертирани в нова серия: {1}</value></data>
<data name="Archive.Log.DryRun" xml:space="preserve"><value>Пробно изпълнение: нищо не е променено.</value></data>
<data name="Archive.Log.DuplicateGroup" xml:space="preserve"><value>Допълнителни копия на {0}: {1}</value></data>
<data name="Archive.Log.DuplicatesDone" xml:space="preserve"><value>Групи дубликати: {0}, допълнителни копия: {1}</value></data>
@@ -166,9 +256,22 @@
<data name="Archive.Log.SequenceMissing" xml:space="preserve"><value>Серията не е намерена: {0}</value></data>
<data name="Archive.Log.StepFailed" xml:space="preserve"><value>Стъпката на почистването {0} е неуспешна: {1}</value></data>
<data name="Archive.Log.StepUnknown" xml:space="preserve"><value>Непозната тук стъпка на почистването: {0}</value></data>
<data name="Archive.Log.SyncChanged" xml:space="preserve"><value>{0}: променен, откакто е в архива, не е качен</value></data>
<data name="Archive.Log.SyncDeletedHere" xml:space="preserve"><value>{0}: изтрит на този компютър, не е изтеглен</value></data>
<data name="Archive.Log.SyncDeletedThere" xml:space="preserve"><value>{0}: изтрит на сървъра, не е качен</value></data>
<data name="Archive.Log.SyncFrameChanged" xml:space="preserve"><value>{0}: кадърът му тук междувременно се е променил, не е изтеглен</value></data>
<data name="Archive.Log.SyncMissing" xml:space="preserve"><value>{0}: липсва, не е качен</value></data>
<data name="Archive.Log.SyncNoPreview.one" xml:space="preserve"><value>{0:N0} кадър няма нито прокси, нито миниатюра на сървъра</value></data>
<data name="Archive.Log.SyncNoPreview.other" xml:space="preserve"><value>{0:N0} кадъра нямат нито прокси, нито миниатюра на сървъра</value></data>
<data name="Archive.Log.TrashEmptied" xml:space="preserve"><value>Изтрити записи: {0}, размер: {1}</value></data>
<data name="Archive.Log.TrashEntry" xml:space="preserve"><value>В кошчето от {0}: {1} ({2})</value></data>
<data name="Archive.Log.TrashKept" xml:space="preserve"><value>Остава в кошчето: {0}</value></data>
<data name="Archive.Log.TrashKept" xml:space="preserve"><value>Остава в кошчето, променен след създаването на плана: {0}</value></data>
<data name="Archive.Log.TrashKeptBusy" xml:space="preserve"><value>Остава в кошчето, серията му беше заета: {0}</value></data>
<data name="Archive.Log.TrashKeptMismatch" xml:space="preserve"><value>Остава в кошчето, конвертирана версия на оригиналите му вече не съвпада: {0}</value></data>
<data name="Archive.Log.TrashKeptStaleIndex" xml:space="preserve"><value>Остава в кошчето, индексът изброява серията му, която архивът вече не съдържа; преизградете индекса: {0}</value></data>
<data name="Archive.Log.TrashKeptUnhashed" xml:space="preserve"><value>Остава в кошчето, снимка от серията му никога не е проверявана; проверете серията: {0}</value></data>
<data name="Archive.Log.TrashKeptUnknown" xml:space="preserve"><value>Остава в кошчето, архивът не показва какво е станало с конвертирането на оригиналите му; възстановете го, за да ги запазите: {0}</value></data>
<data name="Archive.Log.TrashKeptUnreadable" xml:space="preserve"><value>Остава в кошчето, sidecar файлът на папка, която може да съдържа серията му, липсва или не може да бъде прочетен; сканирайте архива: {0}</value></data>
<data name="Archive.Log.TrashOffline" xml:space="preserve"><value>Кошчето не е проверено: архивът е недостъпен</value></data>
<data name="Archive.Log.TrashReport" xml:space="preserve"><value>Стари записи в кошчето: {0}, размер: {1}; нищо не е изтрито</value></data>
<data name="Archive.Log.VerifyDone" xml:space="preserve"><value>Проверени снимки: {0}, непокътнати: {1}, хеширани: {2}, с проблеми: {3}</value></data>
@@ -249,6 +352,7 @@
<data name="Archive.Set.All.other" xml:space="preserve"><value>{0:N0} серии · всички</value></data>
<data name="Archive.Set.Analyse" xml:space="preserve"><value>Анализиране</value></data>
<data name="Archive.Set.ClearFilter" xml:space="preserve"><value>Изчистване на филтъра</value></data>
<data name="Archive.Set.Convert" xml:space="preserve"><value>Конвертиране…</value></data>
<data name="Archive.Set.Delete" xml:space="preserve"><value>Изтриване…</value></data>
<data name="Archive.Set.Export" xml:space="preserve"><value>Експортиране в CSV</value></data>
<data name="Archive.Set.Filter" xml:space="preserve"><value>Филтър на набора</value></data>
@@ -278,6 +382,7 @@
<data name="Archive.Toolbar.Scan" xml:space="preserve"><value>Сканиране</value></data>
<data name="Archive.Toolbar.Verify" xml:space="preserve"><value>Проверка</value></data>
<data name="Archive.Trash.Checking" xml:space="preserve"><value>Проверка на кошчето…</value></data>
<data name="Archive.Trash.ConversionDeleted" xml:space="preserve"><value>конвертираната версия е изтрита</value></data>
<data name="Archive.Trash.Deleted" xml:space="preserve"><value>Изтрита на {0}</value></data>
<data name="Archive.Trash.Empty" xml:space="preserve"><value>Кошчето е празно</value></data>
<data name="Archive.Trash.EmptyAction" xml:space="preserve"><value>Изпразване…</value></data>
+1
View File
@@ -69,6 +69,7 @@
<data name="Jobs.Kind.Adopt" xml:space="preserve"><value>Присъединяване на папка</value></data>
<data name="Jobs.Kind.Backup" xml:space="preserve"><value>Резервно копие на индекса</value></data>
<data name="Jobs.Kind.Cleanup" xml:space="preserve"><value>Почистване</value></data>
<data name="Jobs.Kind.Convert" xml:space="preserve"><value>Конвертиране</value></data>
<data name="Jobs.Kind.DeepAnalyse" xml:space="preserve"><value>Задълбочен анализ</value></data>
<data name="Jobs.Kind.Download" xml:space="preserve"><value>Изтегляне</value></data>
<data name="Jobs.Kind.Duplicates" xml:space="preserve"><value>Дубликати</value></data>
+2
View File
@@ -6,6 +6,7 @@
<resheader name="writer"><value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader>
<data name="Library.Action.Analyse" xml:space="preserve"><value>Анализиране</value></data>
<data name="Library.Action.ClearSelection" xml:space="preserve"><value>Изчистване на избора</value></data>
<data name="Library.Action.Convert" xml:space="preserve"><value>Конвертиране…</value></data>
<data name="Library.Action.Delete" xml:space="preserve"><value>Изтриване…</value></data>
<data name="Library.Action.Download" xml:space="preserve"><value>Изтегляне</value></data>
<data name="Library.Action.ExportList" xml:space="preserve"><value>Експортиране на списъка</value></data>
@@ -32,6 +33,7 @@
<data name="Library.Blocked.NothingToDownload" xml:space="preserve"><value>Избраните серии нямат какво да изтеглят от сървъра.</value></data>
<data name="Library.Blocked.NothingToUpload" xml:space="preserve"><value>Сървърът вече има всичко, което съдържат избраните серии.</value></data>
<data name="Library.Blocked.OneArchive" xml:space="preserve"><value>Реорганизирането работи със сериите на един архив наведнъж.</value></data>
<data name="Library.Blocked.OneArchiveConvert" xml:space="preserve"><value>Конвертирането работи със сериите на един архив наведнъж.</value></data>
<data name="Library.Blocked.ServerOnly" xml:space="preserve"><value>Само за серии на този компютър; избраното се намира на сървъра.</value></data>
<data name="Library.Blocked.Transferring" xml:space="preserve"><value>Вече тече трансфер на тази серия.</value></data>
<data name="Library.ClearFilters" xml:space="preserve"><value>Изчистване на филтрите</value></data>
+4
View File
@@ -21,6 +21,8 @@
<data name="Server.Conflict.TakeServer.Message" xml:space="preserve"><value>Настройките на {0} на този компютър ще бъдат заменени с копието от сървъра.</value></data>
<data name="Server.Conflict.TakeServer.Title" xml:space="preserve"><value>Да се вземат ли настройките на сървъра?</value></data>
<data name="Server.Connect" xml:space="preserve"><value>Свързване</value></data>
<data name="Server.Convert.OnPc" xml:space="preserve"><value>Конвертирайте тези снимки на компютър: сървърът не може да ги прочете в пълна резолюция.</value></data>
<data name="Server.Convert.OnPcNew" xml:space="preserve"><value>Не се копират в новата серия: сървърът не може да прочете тези снимки в пълна резолюция; конвертирайте ги на компютър.</value></data>
<data name="Server.Disconnect" xml:space="preserve"><value>Прекъсване на връзката</value></data>
<data name="Server.Empty" xml:space="preserve"><value>Няма връзка със сървър</value></data>
<data name="Server.Error.AccountLocked" xml:space="preserve"><value>Твърде много неуспешни опити за влизане; акаунтът е заключен за известно време.</value></data>
@@ -71,7 +73,9 @@
<data name="Server.Error.MethodNotAllowed" xml:space="preserve"><value>Този метод не е разрешен тук.</value></data>
<data name="Server.Error.NestedTarget" xml:space="preserve"><value>Нова папка ще се окаже в папката на друга серия.</value></data>
<data name="Server.Error.NotChronos" xml:space="preserve"><value>Този адрес не е на Chronos Server.</value></data>
<data name="Server.Error.NotEnoughSpace" xml:space="preserve"><value>В тома на архива няма мястото, необходимо за конвертирането.</value></data>
<data name="Server.Error.NotFound" xml:space="preserve"><value>Не е намерено.</value></data>
<data name="Server.Error.NothingToConvert" xml:space="preserve"><value>Планът не конвертира нищо: всички снимки се пропускат или всички серии са блокирани.</value></data>
<data name="Server.Error.PasswordChangeRequired" xml:space="preserve"><value>Първо сменете паролата си.</value></data>
<data name="Server.Error.PhotoRemoved" xml:space="preserve"><value>Снимката е изтрита от серията, докато се е качвала, затова не е добавена.</value></data>
<data name="Server.Error.PhotoUnreadable" xml:space="preserve"><value>Файлът {0} не може да бъде прочетен, а без хеша му другите копия няма да разберат, че е изтрит; затворете програмата, която го използва, или проверете разрешенията му, след което опитайте отново.</value></data>
+19 -1
View File
@@ -27,6 +27,21 @@
<data name="Tooltips.Archive.ClearFilter" xml:space="preserve"><value>Показва отново всички серии от избора</value></data>
<data name="Tooltips.Archive.CloseDialog" xml:space="preserve"><value>Затваря, без да променя нищо · Esc</value></data>
<data name="Tooltips.Archive.Collapse" xml:space="preserve"><value>Скрива сериите от тази година</value></data>
<data name="Tooltips.Archive.ConvertApplyNew" xml:space="preserve"><value>Иска потвърждение, след което поставя на опашка задача, която конвертира копия в нови серии · можете да я поставите на пауза и да я възобновите в „Задачи“</value></data>
<data name="Tooltips.Archive.ConvertApplyReplace" xml:space="preserve"><value>Иска въвеждане на броя снимки за потвърждение, след което поставя на опашка задача, която ги заменя с конвертираните им версии · можете да я поставите на пауза и да я възобновите в „Задачи“</value></data>
<data name="Tooltips.Archive.ConvertBack" xml:space="preserve"><value>Връща към плана; нищо не се конвертира</value></data>
<data name="Tooltips.Archive.ConvertDng" xml:space="preserve"><value>Линеен DNG, 16 бита, без загуби · чете се от всяка програма за обработка на RAW; изборът за дългосрочно съхранение</value></data>
<data name="Tooltips.Archive.ConvertJpeg" xml:space="preserve"><value>8-битов JPEG с качеството по-долу · най-малките файлове; губят се някои детайли</value></data>
<data name="Tooltips.Archive.ConvertModeNew" xml:space="preserve"><value>Конвертираните копия отиват в нова серия до всяка изходна; оригиналите остават непроменени</value></data>
<data name="Tooltips.Archive.ConvertModeReplace" xml:space="preserve"><value>Конвертираните файлове заемат мястото на снимките в сериите им; оригиналите отиват в кошчето на архива и могат да бъдат възстановени, докато то не бъде изпразнено</value></data>
<data name="Tooltips.Archive.ConvertNew" xml:space="preserve"><value>Поставя на опашка задачата, която конвертира снимките в нови серии и проверява всяко конвертиране; оригиналите остават непокътнати</value></data>
<data name="Tooltips.Archive.ConvertPlan" xml:space="preserve"><value>Сериите, чиито снимки се заменят</value></data>
<data name="Tooltips.Archive.ConvertPlanNew" xml:space="preserve"><value>Сериите, копирани в нови, и снимките, които всяка от тях пропуска</value></data>
<data name="Tooltips.Archive.ConvertQuality" xml:space="preserve"><value>Качество на JPEG от 1 до 100 · 95 запазва фините детайли; по-ниското дава по-малки файлове</value></data>
<data name="Tooltips.Archive.ConvertReplace.one" xml:space="preserve"><value>Заменя {0:N0} снимка с конвертираната ѝ версия; първо въведете числото по-горе</value></data>
<data name="Tooltips.Archive.ConvertReplace.other" xml:space="preserve"><value>Заменя {0:N0} снимки с конвертираните им версии; първо въведете числото по-горе</value></data>
<data name="Tooltips.Archive.ConvertTiff" xml:space="preserve"><value>16-битов TIFF, компресиран без загуби · големи файлове, които всяка програма за редактиране отваря</value></data>
<data name="Tooltips.Archive.ConvertUndo" xml:space="preserve"><value>Връща оригиналите от кошчето на мястото на конвертираните им версии</value></data>
<data name="Tooltips.Archive.DeleteAction.one" xml:space="preserve"><value>Премества {0:N0} серия в кошчето; първо въведете числото по-горе</value></data>
<data name="Tooltips.Archive.DeleteAction.other" xml:space="preserve"><value>Премества {0:N0} серии в кошчето; първо въведете числото по-горе</value></data>
<data name="Tooltips.Archive.DeleteKeep" xml:space="preserve"><value>Не променя нищо</value></data>
@@ -82,6 +97,7 @@
<data name="Tooltips.Archive.Scan" xml:space="preserve"><value>Инкрементално сканиране: нови, променени и премахнати файлове по час на промяна и размер</value></data>
<data name="Tooltips.Archive.Set" xml:space="preserve"><value>Избраните години и серии (всички, ако нищо не е избрано), стеснени по фотоапарат, състояние или етикет</value></data>
<data name="Tooltips.Archive.SetAnalyse" xml:space="preserve"><value>Изпълнява задълбочения анализ за всяка серия в набора</value></data>
<data name="Tooltips.Archive.SetConvert" xml:space="preserve"><value>Конвертира снимките от набора в JPEG, TIFF или DNG · първо пробно изпълнение, след това задача</value></data>
<data name="Tooltips.Archive.SetDelete" xml:space="preserve"><value>Премества набора в кошчето на архива · показва пробното изпълнение, след което ви моли да потвърдите чрез въвеждане</value></data>
<data name="Tooltips.Archive.SetExport" xml:space="preserve"><value>Експортира набора като CSV: по един ред на серия</value></data>
<data name="Tooltips.Archive.SetProxies" xml:space="preserve"><value>Създава или обновява прокси</value></data>
@@ -96,7 +112,7 @@
<data name="Tooltips.Archive.TitleTemplate" xml:space="preserve"><value>Шаблон за заглавия; полето title е текущото заглавие · проверява се, докато пишете</value></data>
<data name="Tooltips.Archive.Trash" xml:space="preserve"><value>Сериите и снимките, изтрити от този архив; всяка от тях може да бъде възстановена</value></data>
<data name="Tooltips.Archive.TrashEmpty" xml:space="preserve"><value>Изтрива окончателно записите в това кошче след проверка на съдържанието им и потвърждение чрез въвеждане</value></data>
<data name="Tooltips.Archive.TrashEmptyPlan" xml:space="preserve"><value>Какво се изтрива окончателно от архива</value></data>
<data name="Tooltips.Archive.TrashEmptyPlan" xml:space="preserve"><value>Какво се изтрива окончателно от архива; оригиналите, чиято конвертирана версия е изтрита, може да са последното копие на снимките си</value></data>
<data name="Tooltips.Archive.TrashErase.one" xml:space="preserve"><value>Изтрива окончателно {0:N0} запис; първо въведете числото по-горе</value></data>
<data name="Tooltips.Archive.TrashErase.other" xml:space="preserve"><value>Изтрива окончателно {0:N0} записа; първо въведете числото по-горе</value></data>
<data name="Tooltips.Archive.TrashRestore" xml:space="preserve"><value>Връща този запис: серия – в папката ѝ и в библиотеката, снимки – в серията им след проверка по хеш</value></data>
@@ -468,6 +484,8 @@
<data name="Tooltips.Library.List" xml:space="preserve"><value>Таблица с колони за сортиране</value></data>
<data name="Tooltips.Library.Mass.Analyse.one" xml:space="preserve"><value>Задълбочен анализ на {0:N0} серия на този компютър · изпълнява се като една задача</value></data>
<data name="Tooltips.Library.Mass.Analyse.other" xml:space="preserve"><value>Задълбочен анализ на {0:N0} серии на този компютър · изпълнява се като една задача</value></data>
<data name="Tooltips.Library.Mass.Convert.one" xml:space="preserve"><value>Конвертира снимките на {0:N0} серия в JPEG, TIFF или DNG · първо пробно изпълнение, след това задача</value></data>
<data name="Tooltips.Library.Mass.Convert.other" xml:space="preserve"><value>Конвертира снимките на {0:N0} серии от техния архив в JPEG, TIFF или DNG · първо пробно изпълнение, след това задача</value></data>
<data name="Tooltips.Library.Mass.Delete.one" xml:space="preserve"><value>Премества {0:N0} серия в кошчето на нейния архив · показва пробното изпълнение, след което ви моли да потвърдите чрез въвеждане</value></data>
<data name="Tooltips.Library.Mass.Delete.other" xml:space="preserve"><value>Премества {0:N0} серии в кошчето на съответния архив · показва пробното изпълнение, след което ви моли да потвърдите чрез въвеждане</value></data>
<data name="Tooltips.Library.Mass.Download.one" xml:space="preserve"><value>Изтегля от сървъра това, което липсва тук на {0:N0} серия (оригинали или рендери) · изпълнява се като задача за трансфер</value></data>
+75
View File
@@ -9,6 +9,7 @@
<data name="Admin.About.Title" xml:space="preserve"><value>Chronos Server</value></data>
<data name="Admin.About.Uptime" xml:space="preserve"><value>Doba provozu</value></data>
<data name="Admin.About.Version" xml:space="preserve"><value>Verze</value></data>
<data name="Admin.Activity.ArchiveConverted" xml:space="preserve"><value>Uživatel {0} zařadil do fronty konverzi · {1}</value></data>
<data name="Admin.Activity.ArchiveReorganized" xml:space="preserve"><value>Uživatel {0} reorganizoval archiv · {1}</value></data>
<data name="Admin.Activity.ArchiveSettings" xml:space="preserve"><value>Uživatel {0} změnil uspořádání archivu</value></data>
<data name="Admin.Activity.FramesDeleted" xml:space="preserve"><value>Uživatel {0} odstranil {1}</value></data>
@@ -84,6 +85,73 @@
<data name="Admin.Common.TypeToConfirm.Tip" xml:space="preserve"><value>Pro potvrzení zadejte název přesně tak, jak je zobrazen</value></data>
<data name="Admin.Common.TypeWord.Tip" xml:space="preserve"><value>Zadejte slovo přesně tak, jak je zobrazeno; na velikosti písmen nezáleží</value></data>
<data name="Admin.Common.TypeWordFirst.Tip" xml:space="preserve"><value>Nejprve zadejte výše uvedené slovo</value></data>
<data name="Admin.Convert.Action" xml:space="preserve"><value>Konvertovat…</value></data>
<data name="Admin.Convert.Action.Tip" xml:space="preserve"><value>Zkonvertuje fotografie vybraných sekvencí do formátu JPEG, TIFF-16 nebo lineární DNG; náhled nejprve zobrazí každou sekvenci</value></data>
<data name="Admin.Convert.Apply" xml:space="preserve"><value>Konvertovat…</value></data>
<data name="Admin.Convert.Apply.Tip" xml:space="preserve"><value>Zkonvertuje podle náhledu; nejprve požádá o potvrzení</value></data>
<data name="Admin.Convert.Cancel.Tip" xml:space="preserve"><value>Zavře dialog bez konverze</value></data>
<data name="Admin.Convert.ChooseMode" xml:space="preserve"><value>Pro konverzi zvolte režim Nahradit nebo Nová sekvence.</value></data>
<data name="Admin.Convert.ChooseMode.Tip" xml:space="preserve"><value>Nejprve zvolte režim Nahradit nebo Nová sekvence</value></data>
<data name="Admin.Convert.Column.Converted" xml:space="preserve"><value>Zkonvertováno</value></data>
<data name="Admin.Convert.Column.NotCopied" xml:space="preserve"><value>Nezkopírováno</value></data>
<data name="Admin.Convert.Column.Sequence" xml:space="preserve"><value>Sekvence</value></data>
<data name="Admin.Convert.Column.Size" xml:space="preserve"><value>Velikost</value></data>
<data name="Admin.Convert.Column.Unchanged" xml:space="preserve"><value>Beze změny</value></data>
<data name="Admin.Convert.Confirm.New" xml:space="preserve"><value>Konvertovat</value></data>
<data name="Admin.Convert.Confirm.New.Tip" xml:space="preserve"><value>Zařadí do fronty úlohu, která zkonvertuje fotografie do nových sekvencí a každou konverzi ověří; originálů se nedotkne</value></data>
<data name="Admin.Convert.Confirm.Replace" xml:space="preserve"><value>Nahradit</value></data>
<data name="Admin.Convert.Confirm.Replace.Tip" xml:space="preserve"><value>Zařadí do fronty úlohu, která zkonvertuje fotografie, každou konverzi ověří a originály přesune do koše</value></data>
<data name="Admin.Convert.ConfirmNew.few" xml:space="preserve"><value>{0} fotografie se zkonvertují jako kopie do nové sekvence vedle každé zdrojové; originály zůstanou, jak jsou.</value></data>
<data name="Admin.Convert.ConfirmNew.one" xml:space="preserve"><value>{0} fotografie se zkonvertuje jako kopie do nové sekvence; originál zůstane, jak je.</value></data>
<data name="Admin.Convert.ConfirmNew.other" xml:space="preserve"><value>{0} fotografií se zkonvertuje jako kopie do nové sekvence vedle každé zdrojové; originály zůstanou, jak jsou.</value></data>
<data name="Admin.Convert.ConfirmNewNotCopied.few" xml:space="preserve"><value>{0} fotografie se do nových sekvencí nezkopírují, z důvodů uvedených v náhledu.</value></data>
<data name="Admin.Convert.ConfirmNewNotCopied.one" xml:space="preserve"><value>{0} fotografie se do nové sekvence nezkopíruje, z důvodu uvedeného v náhledu.</value></data>
<data name="Admin.Convert.ConfirmNewNotCopied.other" xml:space="preserve"><value>{0} fotografií se do nových sekvencí nezkopíruje, z důvodů uvedených v náhledu.</value></data>
<data name="Admin.Convert.ConfirmNewTitle" xml:space="preserve"><value>Konvertovat do formátu {0} v nových sekvencích?</value></data>
<data name="Admin.Convert.ConfirmReplace.few" xml:space="preserve"><value>{1}: {0} fotografie se nahradí svými zkonvertovanými verzemi; originály se přesunou do koše, kde je lze obnovit, dokud se koš nevysype.</value></data>
<data name="Admin.Convert.ConfirmReplace.one" xml:space="preserve"><value>{1}: {0} fotografie se nahradí svou zkonvertovanou verzí; originál se přesune do koše, kde ho lze obnovit, dokud se koš nevysype.</value></data>
<data name="Admin.Convert.ConfirmReplace.other" xml:space="preserve"><value>{1}: {0} fotografií se nahradí svými zkonvertovanými verzemi; originály se přesunou do koše, kde je lze obnovit, dokud se koš nevysype.</value></data>
<data name="Admin.Convert.ConfirmReplaceTitle" xml:space="preserve"><value>Nahradit originály soubory ve formátu {0}?</value></data>
<data name="Admin.Convert.Format" xml:space="preserve"><value>Formát</value></data>
<data name="Admin.Convert.Format.Jpeg.Tip" xml:space="preserve"><value>8bitový JPEG s barvou v plném rozlišení a s kvalitou nastavenou vedle: nejmenší soubory, které otevře každý program</value></data>
<data name="Admin.Convert.Format.LinearDng" xml:space="preserve"><value>Lineární DNG</value></data>
<data name="Admin.Convert.Format.LinearDng.Tip" xml:space="preserve"><value>16bitový lineární DNG s bezeztrátovou kompresí: volba pro archivaci, otevřou ho editory RAW</value></data>
<data name="Admin.Convert.Format.Tiff16.Tip" xml:space="preserve"><value>16bitový TIFF sRGB s bezeztrátovou kompresí: velké soubory, které pro úpravy zachovají každý tón</value></data>
<data name="Admin.Convert.Gone" xml:space="preserve"><value>Vybraná sekvence už v archivu není; zavřete dialog a vyberte znovu.</value></data>
<data name="Admin.Convert.Mode" xml:space="preserve"><value>Režim</value></data>
<data name="Admin.Convert.Mode.NewSequence" xml:space="preserve"><value>Nová sekvence</value></data>
<data name="Admin.Convert.Mode.NewSequence.Tip" xml:space="preserve"><value>Zkonvertované kopie se uloží do nové sekvence vedle každé zdrojové; originály i jejich sekvence zůstanou přesně tak, jak jsou</value></data>
<data name="Admin.Convert.Mode.Replace" xml:space="preserve"><value>Nahradit</value></data>
<data name="Admin.Convert.Mode.Replace.Tip" xml:space="preserve"><value>Zkonvertované soubory se stanou fotografiemi sekvence; originály se přesunou do koše archivu, kde je lze obnovit, dokud se koš nevysype</value></data>
<data name="Admin.Convert.NoAnswer" xml:space="preserve"><value>Server neodpověděl: než budete konvertovat znovu, zkontrolujte na stránce Úlohy, zda byla konverze zařazena do fronty.</value></data>
<data name="Admin.Convert.NoSpace.Tip" xml:space="preserve"><value>Nejprve uvolněte místo na svazku archivu</value></data>
<data name="Admin.Convert.NotCopiedCount.few" xml:space="preserve"><value>{0} nezkopírovány</value></data>
<data name="Admin.Convert.NotCopiedCount.one" xml:space="preserve"><value>{0} nezkopírována</value></data>
<data name="Admin.Convert.NotCopiedCount.other" xml:space="preserve"><value>{0} nezkopírováno</value></data>
<data name="Admin.Convert.Nothing.Tip" xml:space="preserve"><value>V náhledu není nic ke konverzi</value></data>
<data name="Admin.Convert.NothingToConvert" xml:space="preserve"><value>Není co konvertovat: všechny fotografie zůstanou, jak jsou, z uvedených důvodů.</value></data>
<data name="Admin.Convert.OpenJob" xml:space="preserve"><value>Otevřít úlohu</value></data>
<data name="Admin.Convert.OpenJob.Tip" xml:space="preserve"><value>Zobrazí úlohu a její protokol na stránce Úlohy</value></data>
<data name="Admin.Convert.PlanChanged" xml:space="preserve"><value>Archiv se od zobrazení náhledu změnil; zkontrolujte nový náhled a použijte změny znovu.</value></data>
<data name="Admin.Convert.Planning" xml:space="preserve"><value>Plánování…</value></data>
<data name="Admin.Convert.Planning.Tip" xml:space="preserve"><value>Server čte všechny složky s fotografiemi ve výběru: u velkého archivu to trvá minuty a náhled se zobrazí, až skončí</value></data>
<data name="Admin.Convert.PlanningFor" xml:space="preserve"><value>Plánování… {0}</value></data>
<data name="Admin.Convert.Preview" xml:space="preserve"><value>Náhled</value></data>
<data name="Admin.Convert.Preview.Tip" xml:space="preserve"><value>Co každá sekvence zkonvertuje a co ponechá, jak je, s velikostí před konverzí a po ní (odhad); zatím se nic nezměnilo</value></data>
<data name="Admin.Convert.Quality" xml:space="preserve"><value>Kvalita</value></data>
<data name="Admin.Convert.Quality.Tip" xml:space="preserve"><value>Kvalita JPEG od 1 do 100; 95 zachová jemné detaily, nižší hodnoty dávají menší soubory</value></data>
<data name="Admin.Convert.QualityRange" xml:space="preserve"><value>Zadejte celé číslo od 1 do 100.</value></data>
<data name="Admin.Convert.Queued" xml:space="preserve"><value>Konverze je ve frontě.</value></data>
<data name="Admin.Convert.ReplaceWord" xml:space="preserve"><value>nahradit</value></data>
<data name="Admin.Convert.Size.Tip" xml:space="preserve"><value>Současná velikost fotografií ke konverzi, za ní odhadovaná velikost po konverzi</value></data>
<data name="Admin.Convert.SkippedPhotos" xml:space="preserve"><value>{0}: {1}</value></data>
<data name="Admin.Convert.Title.few" xml:space="preserve"><value>Konvertovat {0} sekvence</value></data>
<data name="Admin.Convert.Title.one" xml:space="preserve"><value>Konvertovat {0} sekvenci</value></data>
<data name="Admin.Convert.Title.other" xml:space="preserve"><value>Konvertovat {0} sekvencí</value></data>
<data name="Admin.Convert.TitleAll" xml:space="preserve"><value>Konvertovat všechny sekvence</value></data>
<data name="Admin.Convert.TooMany" xml:space="preserve"><value>Konverze zpracuje najednou nejvýše {0} sekvencí, nebo všechny sekvence: zrušte filtry a vyberte vše.</value></data>
<data name="Admin.Convert.Totals" xml:space="preserve"><value>Zkonvertované sekvence: {0} · fotografie: {1} · beze změny: {2} · velikost: {3} → {4}</value></data>
<data name="Admin.Convert.TotalsNew" xml:space="preserve"><value>Zkonvertované sekvence: {0} · fotografie: {1} · nezkopírované: {2} · velikost: {3} → {4}</value></data>
<data name="Admin.Dashboard.Activity" xml:space="preserve"><value>Nedávná aktivita</value></data>
<data name="Admin.Dashboard.AllLogs" xml:space="preserve"><value>Všechny protokoly</value></data>
<data name="Admin.Dashboard.AllLogs.Tip" xml:space="preserve"><value>Otevře protokol auditu</value></data>
@@ -142,6 +210,7 @@
<data name="Admin.Job.Kind.Adopt" xml:space="preserve"><value>Převzetí</value></data>
<data name="Admin.Job.Kind.Backup" xml:space="preserve"><value>Záloha indexu</value></data>
<data name="Admin.Job.Kind.Cleanup" xml:space="preserve"><value>Čištění</value></data>
<data name="Admin.Job.Kind.Convert" xml:space="preserve"><value>Konverze</value></data>
<data name="Admin.Job.Kind.DeepAnalyse" xml:space="preserve"><value>Hloubková analýza</value></data>
<data name="Admin.Job.Kind.Duplicates" xml:space="preserve"><value>Duplikáty</value></data>
<data name="Admin.Job.Kind.EmptyTrash" xml:space="preserve"><value>Vysypání koše</value></data>
@@ -368,6 +437,7 @@
<data name="Admin.Login.SignIn.Tip" xml:space="preserve"><value>Přihlásí vás ke správě tohoto serveru</value></data>
<data name="Admin.Login.User" xml:space="preserve"><value>Uživatel</value></data>
<data name="Admin.Login.User.Tip" xml:space="preserve"><value>Vaše uživatelské jméno na tomto serveru</value></data>
<data name="Admin.Logs.Action.ArchiveConverted" xml:space="preserve"><value>Konverze fotografií</value></data>
<data name="Admin.Logs.Action.ArchiveReorganized" xml:space="preserve"><value>Reorganizace archivu</value></data>
<data name="Admin.Logs.Action.ArchiveSettings" xml:space="preserve"><value>Uspořádání archivu</value></data>
<data name="Admin.Logs.Action.FramesDeleted" xml:space="preserve"><value>Odstranění fotografií</value></data>
@@ -833,6 +903,7 @@
<data name="Admin.Theme.Tip" xml:space="preserve"><value>Přepne mezi světlým a tmavým motivem</value></data>
<data name="Admin.Trash.Back" xml:space="preserve"><value>Knihovna</value></data>
<data name="Admin.Trash.Back.Tip" xml:space="preserve"><value>Vrátí se do knihovny</value></data>
<data name="Admin.Trash.ConversionDeleted" xml:space="preserve"><value>zkonvertovaná verze odstraněna</value></data>
<data name="Admin.Trash.DeletedAt" xml:space="preserve"><value>Odstraněno</value></data>
<data name="Admin.Trash.DeletedBy" xml:space="preserve"><value>Odstraněno uživatelem</value></data>
<data name="Admin.Trash.Emptied" xml:space="preserve"><value>Koš byl vysypán.</value></data>
@@ -861,10 +932,14 @@
<data name="Admin.Trash.Photos" xml:space="preserve"><value>Fotografie</value></data>
<data name="Admin.Trash.Restore" xml:space="preserve"><value>Obnovit</value></data>
<data name="Admin.Trash.RestorePhotos.Tip" xml:space="preserve"><value>Vrátí fotografie do jejich sekvence (do nové, pokud už neexistuje); každá se nejprve zkontroluje podle svého SHA-256</value></data>
<data name="Admin.Trash.RestoreReplaced.Tip" xml:space="preserve"><value>Vrátí originály na místo jejich zkonvertovaných verzí, pokud se tyto verze nezměnily (zkonvertované verze se přesunou do koše), jinak do nové sekvence; každý se nejprve zkontroluje podle svého SHA-256</value></data>
<data name="Admin.Trash.RestoreSequence.Tip" xml:space="preserve"><value>Vrátí složku sekvence beze změny zpět do knihovny (vedle původního místa, pokud je obsazené); hash jejích fotografií se nekontroluje: to provede ověření</value></data>
<data name="Admin.Trash.RestoredNew.few" xml:space="preserve"><value>{0} fotografie obnoveny do nové sekvence.</value></data>
<data name="Admin.Trash.RestoredNew.one" xml:space="preserve"><value>{0} fotografie obnovena do nové sekvence.</value></data>
<data name="Admin.Trash.RestoredNew.other" xml:space="preserve"><value>{0} fotografií obnoveno do nové sekvence.</value></data>
<data name="Admin.Trash.RestoredOriginals.few" xml:space="preserve"><value>{0} originály jsou zpět v sekvenci {1}; jejich zkonvertované verze jsou v koši.</value></data>
<data name="Admin.Trash.RestoredOriginals.one" xml:space="preserve"><value>{0} originál je zpět v sekvenci {1}; jeho zkonvertovaná verze je v koši.</value></data>
<data name="Admin.Trash.RestoredOriginals.other" xml:space="preserve"><value>{0} originálů je zpět v sekvenci {1}; jejich zkonvertované verze jsou v koši.</value></data>
<data name="Admin.Trash.RestoredPhotos.few" xml:space="preserve"><value>{0} fotografie jsou zpět v sekvenci {1}.</value></data>
<data name="Admin.Trash.RestoredPhotos.one" xml:space="preserve"><value>{0} fotografie je zpět v sekvenci {1}.</value></data>
<data name="Admin.Trash.RestoredPhotos.other" xml:space="preserve"><value>{0} fotografií je zpět v sekvenci {1}.</value></data>
+120 -4
View File
@@ -16,8 +16,10 @@
<data name="Archive.Blocked.Applying" xml:space="preserve"><value>Počkejte, až se změny použijí.</value></data>
<data name="Archive.Blocked.EmptySet" xml:space="preserve"><value>Sada je prázdná: změňte výběr nebo filtr.</value></data>
<data name="Archive.Blocked.NoChanges" xml:space="preserve"><value>Nic by se nezměnilo.</value></data>
<data name="Archive.Blocked.NoMode" xml:space="preserve"><value>Zvolte režim Nahradit nebo Nová sekvence.</value></data>
<data name="Archive.Blocked.NoTemplate" xml:space="preserve"><value>Zapněte alespoň jednu šablonu.</value></data>
<data name="Archive.Blocked.NotOnline" xml:space="preserve"><value>Archiv musí být online a zapisovatelný.</value></data>
<data name="Archive.Blocked.NothingToConvert" xml:space="preserve"><value>Není co konvertovat: všechny fotografie se přeskočí, nebo jsou všechny sekvence blokované.</value></data>
<data name="Archive.Blocked.Planning" xml:space="preserve"><value>Počkejte na zkušební běh.</value></data>
<data name="Archive.Blocked.Reading" xml:space="preserve"><value>Počkejte, až se archiv načte.</value></data>
<data name="Archive.Blocked.Searching" xml:space="preserve"><value>Probíhá hledání; zrušte ho nebo počkejte.</value></data>
@@ -34,6 +36,91 @@
<data name="Archive.Confirm.Remove" xml:space="preserve"><value>Odebrat řádek</value></data>
<data name="Archive.Confirm.RemoveHeading" xml:space="preserve"><value>Odebrat {0} z indexu?</value></data>
<data name="Archive.Confirm.RemoveMessage" xml:space="preserve"><value>Doprovodný soubor chybí. Odebere se jen řádek indexu; žádný soubor se neodstraní.</value></data>
<data name="Archive.Convert.AlreadyQueued" xml:space="preserve"><value>Konverze těchto sekvencí už čeká nebo běží; sledujte ji v části Úlohy.</value></data>
<data name="Archive.Convert.Blocked.Busy" xml:space="preserve"><value>Na této sekvenci pracuje úloha; zkonvertujte ji, až úloha skončí.</value></data>
<data name="Archive.Convert.Blocked.FramesChanged" xml:space="preserve"><value>Sekvence se po vytvoření plánu změnila; zkontrolujte plán znovu.</value></data>
<data name="Archive.Convert.Blocked.Offline" xml:space="preserve"><value>Archiv je offline nebo jen pro čtení.</value></data>
<data name="Archive.Convert.Blocked.Unreadable" xml:space="preserve"><value>Soubor sekvence nelze přečíst.</value></data>
<data name="Archive.Convert.Confirm" xml:space="preserve"><value>Konvertovat</value></data>
<data name="Archive.Convert.CopyUnfinished" xml:space="preserve"><value>Jiná konverze už z ní vytvořila kopii v tomto formátu a nebyla dokončena; nejprve ji dokončete nebo zopakujte.</value></data>
<data name="Archive.Convert.Done.few" xml:space="preserve"><value>{0:N0} sekvence zkonvertovány</value></data>
<data name="Archive.Convert.Done.one" xml:space="preserve"><value>{0:N0} sekvence zkonvertována</value></data>
<data name="Archive.Convert.Done.other" xml:space="preserve"><value>{0:N0} sekvencí zkonvertováno</value></data>
<data name="Archive.Convert.Failed.Changed" xml:space="preserve"><value>Fotografie už neodpovídá archivované kopii; ověřte sekvenci.</value></data>
<data name="Archive.Convert.Failed.ColorProfile" xml:space="preserve"><value>Její barevný profil v tomto formátu nelze zachovat ani převést.</value></data>
<data name="Archive.Convert.Failed.Damaged" xml:space="preserve"><value>Její pixely obsahují hodnoty, které nejsou čísla: soubor je poškozený.</value></data>
<data name="Archive.Convert.Failed.EightBit" xml:space="preserve"><value>Tento počítač vyvolá tento RAW jen v 8 bitech, což je pro 16bitový soubor příliš málo; do JPEG ho zkonvertovat lze.</value></data>
<data name="Archive.Convert.Failed.Full" xml:space="preserve"><value>Disk archivu je plný.</value></data>
<data name="Archive.Convert.Failed.NoDecoder" xml:space="preserve"><value>Žádný dekodér v tomto počítači ji nepřečte v plném rozlišení.</value></data>
<data name="Archive.Convert.Failed.NotVerified" xml:space="preserve"><value>Zkonvertovaný soubor se při zpětném čtení neshodoval s tím, co bylo zapsáno.</value></data>
<data name="Archive.Convert.Failed.Other" xml:space="preserve"><value>Zkonvertovaný soubor nebylo možné vytvořit.</value></data>
<data name="Archive.Convert.Failed.PreviewOnly" xml:space="preserve"><value>Tento počítač ji čte jen z vloženého náhledu: zkonvertujte ji v počítači, který ji přečte v plném rozlišení.</value></data>
<data name="Archive.Convert.Failed.TooLarge" xml:space="preserve"><value>Je větší, než tento formát pojme, než Chronos dokáže zpětně přečíst nebo než pojme paměť pro jednu fotografii.</value></data>
<data name="Archive.Convert.Failed.Unreadable" xml:space="preserve"><value>Fotografii nebylo možné dekódovat.</value></data>
<data name="Archive.Convert.Format" xml:space="preserve"><value>Formát</value></data>
<data name="Archive.Convert.Heading.few" xml:space="preserve"><value>Konvertovat {0:N0} sekvence</value></data>
<data name="Archive.Convert.Heading.one" xml:space="preserve"><value>Konvertovat {0:N0} sekvenci</value></data>
<data name="Archive.Convert.Heading.other" xml:space="preserve"><value>Konvertovat {0:N0} sekvencí</value></data>
<data name="Archive.Convert.HeadingAll" xml:space="preserve"><value>Konvertovat archiv {0}</value></data>
<data name="Archive.Convert.Mode" xml:space="preserve"><value>Režim</value></data>
<data name="Archive.Convert.NewHeading.few" xml:space="preserve"><value>Konvertovat {0:N0} sekvence do nových?</value></data>
<data name="Archive.Convert.NewHeading.one" xml:space="preserve"><value>Konvertovat {0:N0} sekvenci do nové?</value></data>
<data name="Archive.Convert.NewHeading.other" xml:space="preserve"><value>Konvertovat {0:N0} sekvencí do nových?</value></data>
<data name="Archive.Convert.NewLeftOut.few" xml:space="preserve"><value>{0:N0} fotografie se nezkopírují: zůstanou jen ve své zdrojové sekvenci, z důvodů uvedených v plánu.</value></data>
<data name="Archive.Convert.NewLeftOut.one" xml:space="preserve"><value>{0:N0} fotografie se nezkopíruje: zůstane jen ve své zdrojové sekvenci, z důvodu uvedeného v plánu.</value></data>
<data name="Archive.Convert.NewLeftOut.other" xml:space="preserve"><value>{0:N0} fotografií se nezkopíruje: zůstanou jen ve své zdrojové sekvenci, z důvodů uvedených v plánu.</value></data>
<data name="Archive.Convert.NewMessage" xml:space="preserve"><value>Do formátu {2} se zkonvertuje: {0} ({1}), vždy do nové sekvence vedle zdrojové; originály zůstanou, jak jsou.</value></data>
<data name="Archive.Convert.NewSequence" xml:space="preserve"><value>Nová sekvence</value></data>
<data name="Archive.Convert.NotCopied.ColorProfile" xml:space="preserve"><value>Fotografie, jejichž barevný profil tento formát nedokáže zachovat ani převést, se do nové sekvence nezkopírují.</value></data>
<data name="Archive.Convert.NotCopied.EightBit" xml:space="preserve"><value>Fotografie RAW, které tento počítač vyvolá jen v 8 bitech, se do nové sekvence nezkopírují; do JPEG je zkonvertovat lze.</value></data>
<data name="Archive.Convert.NotCopied.Inaccessible" xml:space="preserve"><value>Fotografie, které drží otevřené jiný program nebo které nelze otevřít, se do nové sekvence nezkopírují; až budou volné, naplánujte to znovu.</value></data>
<data name="Archive.Convert.NotCopied.Missing" xml:space="preserve"><value>Chybějící fotografie se do nové sekvence nezkopírují.</value></data>
<data name="Archive.Convert.NotCopied.NoNativeDecoder" xml:space="preserve"><value>Fotografie ve formátu, který tento počítač nepřečte v plném rozlišení, se do nové sekvence nezkopírují.</value></data>
<data name="Archive.Convert.NotCopied.PreviewOnly" xml:space="preserve"><value>Fotografie, které se zde čtou jen z vloženého náhledu, se do nové sekvence nezkopírují.</value></data>
<data name="Archive.Convert.NotCopied.SameFormat" xml:space="preserve"><value>Fotografie, které už jsou v tomto formátu, se do nové sekvence nezkopírují.</value></data>
<data name="Archive.Convert.NotCopied.TooLarge" xml:space="preserve"><value>Fotografie větší, než tento formát pojme nebo Chronos dokáže zpětně přečíst, se do nové sekvence nezkopírují.</value></data>
<data name="Archive.Convert.NotCopied.Undecodable" xml:space="preserve"><value>Nečitelné fotografie se do nové sekvence nezkopírují.</value></data>
<data name="Archive.Convert.NotCopied.Unhashed" xml:space="preserve"><value>Fotografie, které nikdy nebyly ověřeny, se do nové sekvence nezkopírují; nejprve sekvenci ověřte.</value></data>
<data name="Archive.Convert.NotCopiedPhotos.few" xml:space="preserve"><value>{0:N0} nezkopírovány</value></data>
<data name="Archive.Convert.NotCopiedPhotos.one" xml:space="preserve"><value>{0:N0} nezkopírována</value></data>
<data name="Archive.Convert.NotCopiedPhotos.other" xml:space="preserve"><value>{0:N0} nezkopírováno</value></data>
<data name="Archive.Convert.NotPlaced" xml:space="preserve"><value>Zkonvertované fotografie nemohly zaujmout své místo. {0}</value></data>
<data name="Archive.Convert.PhotoFailed" xml:space="preserve"><value>Soubor {0} nebylo možné zkonvertovat. {1}</value></data>
<data name="Archive.Convert.PhotoHeld" xml:space="preserve"><value>Některou její fotografii drží otevřenou jiný program nebo ji nelze otevřít; až bude volná, zkuste to znovu.</value></data>
<data name="Archive.Convert.Quality" xml:space="preserve"><value>Kvalita</value></data>
<data name="Archive.Convert.Replace" xml:space="preserve"><value>Nahradit</value></data>
<data name="Archive.Convert.ReplaceHeading.few" xml:space="preserve"><value>Nahradit fotografie {0:N0} sekvencí?</value></data>
<data name="Archive.Convert.ReplaceHeading.one" xml:space="preserve"><value>Nahradit fotografie {0:N0} sekvence?</value></data>
<data name="Archive.Convert.ReplaceHeading.other" xml:space="preserve"><value>Nahradit fotografie {0:N0} sekvencí?</value></data>
<data name="Archive.Convert.ReplaceMessage" xml:space="preserve"><value>Zkonvertovanou verzí ve formátu {2} se nahradí: {0} ({1}); originály se přesunou do koše archivu a lze je obnovit, dokud se koš nevysype.</value></data>
<data name="Archive.Convert.Sizes" xml:space="preserve"><value>{0} → {1}</value></data>
<data name="Archive.Convert.Skipped.ColorProfile" xml:space="preserve"><value>Fotografie, jejichž barevný profil tento formát nedokáže zachovat ani převést, zůstanou, jak jsou.</value></data>
<data name="Archive.Convert.Skipped.EightBit" xml:space="preserve"><value>Fotografie RAW, které tento počítač vyvolá jen v 8 bitech, zůstanou, jak jsou; do JPEG je zkonvertovat lze.</value></data>
<data name="Archive.Convert.Skipped.Inaccessible" xml:space="preserve"><value>Fotografie, které drží otevřené jiný program nebo které nelze otevřít, zůstanou, jak jsou; až budou volné, naplánujte to znovu.</value></data>
<data name="Archive.Convert.Skipped.Missing" xml:space="preserve"><value>Chybějící fotografie zůstanou, jak jsou.</value></data>
<data name="Archive.Convert.Skipped.NoNativeDecoder" xml:space="preserve"><value>Fotografie ve formátu, který tento počítač nepřečte v plném rozlišení, zůstanou, jak jsou.</value></data>
<data name="Archive.Convert.Skipped.PreviewOnly" xml:space="preserve"><value>Fotografie, které se zde čtou jen z vloženého náhledu, zůstanou, jak jsou.</value></data>
<data name="Archive.Convert.Skipped.SameFormat" xml:space="preserve"><value>Fotografie, které už jsou v tomto formátu, zůstanou, jak jsou.</value></data>
<data name="Archive.Convert.Skipped.TooLarge" xml:space="preserve"><value>Fotografie větší, než tento formát pojme nebo Chronos dokáže zpětně přečíst, zůstanou, jak jsou.</value></data>
<data name="Archive.Convert.Skipped.Undecodable" xml:space="preserve"><value>Nečitelné fotografie zůstanou, jak jsou.</value></data>
<data name="Archive.Convert.Skipped.Unhashed" xml:space="preserve"><value>Fotografie, které nikdy nebyly ověřeny, zůstanou, jak jsou; nejprve sekvenci ověřte.</value></data>
<data name="Archive.Convert.SkippedPhotos.few" xml:space="preserve"><value>{0:N0} přeskočeny</value></data>
<data name="Archive.Convert.SkippedPhotos.one" xml:space="preserve"><value>{0:N0} přeskočena</value></data>
<data name="Archive.Convert.SkippedPhotos.other" xml:space="preserve"><value>{0:N0} přeskočeno</value></data>
<data name="Archive.Convert.Space" xml:space="preserve"><value>Potřeba: {0}, volné: {1}</value></data>
<data name="Archive.Convert.SpaceShort" xml:space="preserve"><value>Potřeba: {0}, volné jen {1}; nejprve uvolněte místo.</value></data>
<data name="Archive.Convert.SpaceUnknown" xml:space="preserve"><value>Potřeba: {0}; volné místo nelze změřit.</value></data>
<data name="Archive.Convert.Target.LinearDng" xml:space="preserve"><value>Lineární DNG</value></data>
<data name="Archive.Convert.Target.Tiff16" xml:space="preserve"><value>TIFF 16 bitů</value></data>
<data name="Archive.Convert.UndoFailed" xml:space="preserve"><value>Originály se nepodařilo vrátit</value></data>
<data name="Archive.Convert.UndoNothing" xml:space="preserve"><value>Nahrazené originály už v koši nejsou.</value></data>
<data name="Archive.Convert.Undone.few" xml:space="preserve"><value>Originály jsou zpět v {0:N0} sekvencích</value></data>
<data name="Archive.Convert.Undone.one" xml:space="preserve"><value>Originály jsou zpět v {0:N0} sekvenci</value></data>
<data name="Archive.Convert.Undone.other" xml:space="preserve"><value>Originály jsou zpět v {0:N0} sekvencích</value></data>
<data name="Archive.Convert.UndoneNew.few" xml:space="preserve"><value>{0:N0} sekvence se mezitím změnily: jejich originály se vrátily jako nové sekvence.</value></data>
<data name="Archive.Convert.UndoneNew.one" xml:space="preserve"><value>{0:N0} sekvence se mezitím změnila: její originály se vrátily jako nová sekvence.</value></data>
<data name="Archive.Convert.UndoneNew.other" xml:space="preserve"><value>{0:N0} sekvencí se mezitím změnilo: jejich originály se vrátily jako nové sekvence.</value></data>
<data name="Archive.Convert.Unstaged" xml:space="preserve"><value>Zkonvertovaná verze souboru {0} už mezi připravenými soubory není; nový pokus ho zkonvertuje znovu.</value></data>
<data name="Archive.Copy.Title" xml:space="preserve"><value>Složka ke zkopírování do archivu</value></data>
<data name="Archive.Delete.Action" xml:space="preserve"><value>Přesunout do koše</value></data>
<data name="Archive.Delete.Blocked" xml:space="preserve"><value>Nepřesunuto: {0} · {1}</value></data>
@@ -85,6 +172,10 @@
<data name="Archive.Duplicates.Title" xml:space="preserve"><value>Duplikáty</value></data>
<data name="Archive.Empty" xml:space="preserve"><value>Zatím žádný archiv</value></data>
<data name="Archive.Error.Busy" xml:space="preserve"><value>Sem zapisuje jiná instance Chronos ({0}). Zkuste to za chvíli znovu.</value></data>
<data name="Archive.Error.ConvertKept.few" xml:space="preserve"><value>{0:N0} sekvence nebyly zkonvertovány podle plánu; důvod uvádí protokol úlohy.</value></data>
<data name="Archive.Error.ConvertKept.one" xml:space="preserve"><value>{0:N0} sekvence nebyla zkonvertována podle plánu; důvod uvádí protokol úlohy.</value></data>
<data name="Archive.Error.ConvertKept.other" xml:space="preserve"><value>{0:N0} sekvencí nebylo zkonvertováno podle plánu; důvod uvádí protokol úlohy.</value></data>
<data name="Archive.Error.ConvertSpace" xml:space="preserve"><value>Konverze potřebuje na svazku archivu {0} volného místa, volných je {1}.</value></data>
<data name="Archive.Error.CopyMismatch" xml:space="preserve"><value>Kopie souboru {0} neodpovídá originálu.</value></data>
<data name="Archive.Error.DuplicateLost" xml:space="preserve"><value>Soubor {0} nebylo možné přidat do sekvence.</value></data>
<data name="Archive.Error.InLibrary" xml:space="preserve"><value>Sekvence {0} už je v knihovně.</value></data>
@@ -105,9 +196,9 @@
<data name="Archive.Error.SourceGone" xml:space="preserve"><value>Karta nebo složka {0} už není k dispozici.</value></data>
<data name="Archive.Error.StalePlan" xml:space="preserve"><value>Archiv se po vytvoření tohoto plánu změnil.</value></data>
<data name="Archive.Error.TrashChanged" xml:space="preserve"><value>Koš se po kontrole změnil; nic nebylo trvale odstraněno.</value></data>
<data name="Archive.Error.TrashKept.few" xml:space="preserve"><value>{0:N0} položky koše byly ponechány: změnily se, nebo už neodpovídá náhrada.</value></data>
<data name="Archive.Error.TrashKept.one" xml:space="preserve"><value>{0:N0} položka koše byla ponechána: změnila se, nebo už neodpovídá náhrada.</value></data>
<data name="Archive.Error.TrashKept.other" xml:space="preserve"><value>{0:N0} položek koše bylo ponecháno: změnily se, nebo už neodpovídá náhrada.</value></data>
<data name="Archive.Error.TrashKept.few" xml:space="preserve"><value>{0:N0} položky koše byly ponechány; důvod uvádí protokol úlohy.</value></data>
<data name="Archive.Error.TrashKept.one" xml:space="preserve"><value>{0:N0} položka koše byla ponechána; důvod uvádí protokol úlohy.</value></data>
<data name="Archive.Error.TrashKept.other" xml:space="preserve"><value>{0:N0} položek koše bylo ponecháno; důvod uvádí protokol úlohy.</value></data>
<data name="Archive.Error.TrashMismatch" xml:space="preserve"><value>Žádný soubor této položky koše už neodpovídá jejímu záznamu; položka zůstává v koši.</value></data>
<data name="Archive.Failed.Access" xml:space="preserve"><value>Aplikaci Chronos byl odepřen přístup k archivu.</value></data>
<data name="Archive.Failed.Files" xml:space="preserve"><value>Soubor archivu nebylo možné přečíst nebo zapsat.</value></data>
@@ -151,6 +242,15 @@
<data name="Archive.Log.AuditKept" xml:space="preserve"><value>Protokol auditu uchován celý</value></data>
<data name="Archive.Log.AuditPurged" xml:space="preserve"><value>Odebrané záznamy auditu: {0}</value></data>
<data name="Archive.Log.BackupDone" xml:space="preserve"><value>Index zkopírován do {0} ({1}); uchované kopie: {2}</value></data>
<data name="Archive.Log.ConvertBlocked" xml:space="preserve"><value>Ponecháno, jak bylo, sekvence byla obsazená nebo nečitelná: {0}</value></data>
<data name="Archive.Log.ConvertChanged" xml:space="preserve"><value>Ponecháno, jak bylo, po vytvoření plánu se změnilo: {0}. Nový pokus sekvenci ponechá, jak je: zkonvertujte ji znovu podle nového plánu.</value></data>
<data name="Archive.Log.ConvertDone" xml:space="preserve"><value>Zkonvertované sekvence: {0}, nové sekvence: {1}, fotografie: {2}</value></data>
<data name="Archive.Log.ConvertFailed" xml:space="preserve"><value>Ponecháno, jak bylo: {0}. {1}</value></data>
<data name="Archive.Log.ConvertLeftOut" xml:space="preserve"><value>{0}: nezkonvertované fotografie, které zůstaly jen ve zdroji: {1}</value></data>
<data name="Archive.Log.ConvertNothing" xml:space="preserve"><value>Není co konvertovat: {0}</value></data>
<data name="Archive.Log.ConvertSuperseded" xml:space="preserve"><value>{0}: od potvrzení této konverze vytvořila kopii v tomto formátu už jiná konverze; druhá kopie se nevytvoří.</value></data>
<data name="Archive.Log.Converted" xml:space="preserve"><value>{0}: fotografie nahrazené svou zkonvertovanou verzí: {1}</value></data>
<data name="Archive.Log.ConvertedNew" xml:space="preserve"><value>{0}: fotografie zkonvertované do nové sekvence: {1}</value></data>
<data name="Archive.Log.DryRun" xml:space="preserve"><value>Zkušební běh: nic nebylo změněno.</value></data>
<data name="Archive.Log.DuplicateGroup" xml:space="preserve"><value>Nadbytečné kopie souboru {0}: {1}</value></data>
<data name="Archive.Log.DuplicatesDone" xml:space="preserve"><value>Skupiny duplikátů: {0}, nadbytečné kopie: {1}</value></data>
@@ -185,9 +285,23 @@
<data name="Archive.Log.SequenceMissing" xml:space="preserve"><value>Sekvence nenalezena: {0}</value></data>
<data name="Archive.Log.StepFailed" xml:space="preserve"><value>Krok čištění {0} selhal: {1}</value></data>
<data name="Archive.Log.StepUnknown" xml:space="preserve"><value>Krok čištění zde není znám: {0}</value></data>
<data name="Archive.Log.SyncChanged" xml:space="preserve"><value>{0}: od archivace změněno, nenahráno</value></data>
<data name="Archive.Log.SyncDeletedHere" xml:space="preserve"><value>{0}: odstraněno v tomto počítači, nestaženo</value></data>
<data name="Archive.Log.SyncDeletedThere" xml:space="preserve"><value>{0}: odstraněno na serveru, nenahráno</value></data>
<data name="Archive.Log.SyncFrameChanged" xml:space="preserve"><value>{0}: jeho snímek se zde mezitím změnil, nestaženo</value></data>
<data name="Archive.Log.SyncMissing" xml:space="preserve"><value>{0}: chybí, nenahráno</value></data>
<data name="Archive.Log.SyncNoPreview.few" xml:space="preserve"><value>{0:N0} snímky nemají na serveru proxy ani miniaturu</value></data>
<data name="Archive.Log.SyncNoPreview.one" xml:space="preserve"><value>{0:N0} snímek nemá na serveru proxy ani miniaturu</value></data>
<data name="Archive.Log.SyncNoPreview.other" xml:space="preserve"><value>{0:N0} snímků nemá na serveru proxy ani miniaturu</value></data>
<data name="Archive.Log.TrashEmptied" xml:space="preserve"><value>Trvale odstraněné položky: {0}, velikost: {1}</value></data>
<data name="Archive.Log.TrashEntry" xml:space="preserve"><value>V koši od {0}: {1} ({2})</value></data>
<data name="Archive.Log.TrashKept" xml:space="preserve"><value>Ponecháno v koši: {0}</value></data>
<data name="Archive.Log.TrashKept" xml:space="preserve"><value>Ponecháno v koši, po vytvoření plánu se změnilo: {0}</value></data>
<data name="Archive.Log.TrashKeptBusy" xml:space="preserve"><value>Ponecháno v koši, sekvence položky byla obsazená: {0}</value></data>
<data name="Archive.Log.TrashKeptMismatch" xml:space="preserve"><value>Ponecháno v koši, některá zkonvertovaná verze originálů už neodpovídá: {0}</value></data>
<data name="Archive.Log.TrashKeptStaleIndex" xml:space="preserve"><value>Ponecháno v koši, index uvádí sekvenci položky, kterou archiv už neobsahuje; znovu sestavte index: {0}</value></data>
<data name="Archive.Log.TrashKeptUnhashed" xml:space="preserve"><value>Ponecháno v koši, některá fotografie sekvence položky nebyla nikdy ověřena; ověřte sekvenci: {0}</value></data>
<data name="Archive.Log.TrashKeptUnknown" xml:space="preserve"><value>Ponecháno v koši, archiv neukazuje, co se stalo s konverzí originálů položky; chcete-li je zachovat, položku obnovte: {0}</value></data>
<data name="Archive.Log.TrashKeptUnreadable" xml:space="preserve"><value>Ponecháno v koši, doprovodný soubor složky, která může obsahovat sekvenci položky, chybí nebo je nečitelný; prohledejte archiv: {0}</value></data>
<data name="Archive.Log.TrashOffline" xml:space="preserve"><value>Koš nebyl zkontrolován: archiv není dostupný</value></data>
<data name="Archive.Log.TrashReport" xml:space="preserve"><value>Staré položky koše: {0}, velikost: {1}; nic nebylo odstraněno</value></data>
<data name="Archive.Log.VerifyDone" xml:space="preserve"><value>Zkontrolované fotografie: {0}, neporušené: {1}, s novým hashem: {2}, s problémy: {3}</value></data>
@@ -277,6 +391,7 @@
<data name="Archive.Set.All.other" xml:space="preserve"><value>{0:N0} sekvencí · všechny</value></data>
<data name="Archive.Set.Analyse" xml:space="preserve"><value>Analyzovat</value></data>
<data name="Archive.Set.ClearFilter" xml:space="preserve"><value>Zrušit filtr</value></data>
<data name="Archive.Set.Convert" xml:space="preserve"><value>Konvertovat…</value></data>
<data name="Archive.Set.Delete" xml:space="preserve"><value>Odstranit…</value></data>
<data name="Archive.Set.Export" xml:space="preserve"><value>Exportovat CSV</value></data>
<data name="Archive.Set.Filter" xml:space="preserve"><value>Filtr sady</value></data>
@@ -310,6 +425,7 @@
<data name="Archive.Toolbar.Scan" xml:space="preserve"><value>Prohledat</value></data>
<data name="Archive.Toolbar.Verify" xml:space="preserve"><value>Ověřit</value></data>
<data name="Archive.Trash.Checking" xml:space="preserve"><value>Kontrola koše…</value></data>
<data name="Archive.Trash.ConversionDeleted" xml:space="preserve"><value>zkonvertovaná verze odstraněna</value></data>
<data name="Archive.Trash.Deleted" xml:space="preserve"><value>Odstraněno {0}</value></data>
<data name="Archive.Trash.Empty" xml:space="preserve"><value>Koš je prázdný</value></data>
<data name="Archive.Trash.EmptyAction" xml:space="preserve"><value>Vysypat…</value></data>
+1
View File
@@ -70,6 +70,7 @@
<data name="Jobs.Kind.Adopt" xml:space="preserve"><value>Převzetí složky</value></data>
<data name="Jobs.Kind.Backup" xml:space="preserve"><value>Záloha indexu</value></data>
<data name="Jobs.Kind.Cleanup" xml:space="preserve"><value>Čištění</value></data>
<data name="Jobs.Kind.Convert" xml:space="preserve"><value>Konverze</value></data>
<data name="Jobs.Kind.DeepAnalyse" xml:space="preserve"><value>Hloubková analýza</value></data>
<data name="Jobs.Kind.Download" xml:space="preserve"><value>Stažení</value></data>
<data name="Jobs.Kind.Duplicates" xml:space="preserve"><value>Duplikáty</value></data>
+2
View File
@@ -6,6 +6,7 @@
<resheader name="writer"><value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader>
<data name="Library.Action.Analyse" xml:space="preserve"><value>Analyzovat</value></data>
<data name="Library.Action.ClearSelection" xml:space="preserve"><value>Zrušit výběr</value></data>
<data name="Library.Action.Convert" xml:space="preserve"><value>Konvertovat…</value></data>
<data name="Library.Action.Delete" xml:space="preserve"><value>Odstranit…</value></data>
<data name="Library.Action.Download" xml:space="preserve"><value>Stáhnout</value></data>
<data name="Library.Action.ExportList" xml:space="preserve"><value>Exportovat seznam</value></data>
@@ -32,6 +33,7 @@
<data name="Library.Blocked.NothingToDownload" xml:space="preserve"><value>Vybrané sekvence nemají ze serveru co stáhnout.</value></data>
<data name="Library.Blocked.NothingToUpload" xml:space="preserve"><value>Server už má vše, co vybrané sekvence obsahují.</value></data>
<data name="Library.Blocked.OneArchive" xml:space="preserve"><value>Reorganizace pracuje vždy jen se sekvencemi jednoho archivu.</value></data>
<data name="Library.Blocked.OneArchiveConvert" xml:space="preserve"><value>Konverze pracuje vždy jen se sekvencemi jednoho archivu.</value></data>
<data name="Library.Blocked.ServerOnly" xml:space="preserve"><value>Jen pro sekvence v tomto počítači; vybrané sekvence jsou na serveru.</value></data>
<data name="Library.Blocked.Transferring" xml:space="preserve"><value>Přenos této sekvence už probíhá.</value></data>
<data name="Library.ClearFilters" xml:space="preserve"><value>Vymazat filtry</value></data>
+4
View File
@@ -21,6 +21,8 @@
<data name="Server.Conflict.TakeServer.Message" xml:space="preserve"><value>Nastavení sekvence {0} v tomto počítači bude nahrazeno kopií ze serveru.</value></data>
<data name="Server.Conflict.TakeServer.Title" xml:space="preserve"><value>Převzít nastavení ze serveru?</value></data>
<data name="Server.Connect" xml:space="preserve"><value>Připojit</value></data>
<data name="Server.Convert.OnPc" xml:space="preserve"><value>Tyto fotografie zkonvertujte v počítači: server je nedokáže přečíst v plném rozlišení.</value></data>
<data name="Server.Convert.OnPcNew" xml:space="preserve"><value>Nezkopírují se do nové sekvence: server tyto fotografie nedokáže přečíst v plném rozlišení; zkonvertujte je v počítači.</value></data>
<data name="Server.Disconnect" xml:space="preserve"><value>Odpojit</value></data>
<data name="Server.Empty" xml:space="preserve"><value>Nepřipojeno k serveru</value></data>
<data name="Server.Error.AccountLocked" xml:space="preserve"><value>Příliš mnoho neúspěšných přihlášení; účet je dočasně uzamčen.</value></data>
@@ -71,7 +73,9 @@
<data name="Server.Error.MethodNotAllowed" xml:space="preserve"><value>Tato metoda zde není povolena.</value></data>
<data name="Server.Error.NestedTarget" xml:space="preserve"><value>Nová složka by ležela uvnitř složky jiné sekvence.</value></data>
<data name="Server.Error.NotChronos" xml:space="preserve"><value>Na této adrese není Chronos Server.</value></data>
<data name="Server.Error.NotEnoughSpace" xml:space="preserve"><value>Na svazku archivu chybí místo, které konverze potřebuje.</value></data>
<data name="Server.Error.NotFound" xml:space="preserve"><value>Nenalezeno.</value></data>
<data name="Server.Error.NothingToConvert" xml:space="preserve"><value>Plán nic nezkonvertuje: všechny fotografie se přeskočí, nebo jsou všechny sekvence blokované.</value></data>
<data name="Server.Error.PasswordChangeRequired" xml:space="preserve"><value>Nejprve si změňte heslo.</value></data>
<data name="Server.Error.PhotoRemoved" xml:space="preserve"><value>Fotografie byla během nahrávání odstraněna ze sekvence, proto nebyla přidána.</value></data>
<data name="Server.Error.PhotoUnreadable" xml:space="preserve"><value>Soubor {0} nelze přečíst a bez jeho hashe by se ostatní kopie nedozvěděly, že byl odstraněn; zavřete program, který ho používá, nebo zkontrolujte jeho oprávnění a zkuste to znovu.</value></data>
+21 -1
View File
@@ -27,6 +27,22 @@
<data name="Tooltips.Archive.ClearFilter" xml:space="preserve"><value>Znovu zobrazí všechny sekvence výběru</value></data>
<data name="Tooltips.Archive.CloseDialog" xml:space="preserve"><value>Zavře dialog beze změn · Esc</value></data>
<data name="Tooltips.Archive.Collapse" xml:space="preserve"><value>Skryje sekvence tohoto roku</value></data>
<data name="Tooltips.Archive.ConvertApplyNew" xml:space="preserve"><value>Po potvrzení zařadí do fronty úlohu, která zkonvertuje kopie do nových sekvencí · pozastavíte a obnovíte ji v části Úlohy</value></data>
<data name="Tooltips.Archive.ConvertApplyReplace" xml:space="preserve"><value>Po potvrzení zadáním počtu fotografií zařadí do fronty úlohu, která je nahradí jejich zkonvertovanou verzí · pozastavíte a obnovíte ji v části Úlohy</value></data>
<data name="Tooltips.Archive.ConvertBack" xml:space="preserve"><value>Vrátí se k plánu; nic se nezkonvertuje</value></data>
<data name="Tooltips.Archive.ConvertDng" xml:space="preserve"><value>Lineární DNG, 16bitový a bezeztrátový · přečte ho každý editor RAW; volba pro archivaci</value></data>
<data name="Tooltips.Archive.ConvertJpeg" xml:space="preserve"><value>8bitový JPEG v kvalitě nastavené níže · nejmenší soubory; část detailů se ztratí</value></data>
<data name="Tooltips.Archive.ConvertModeNew" xml:space="preserve"><value>Zkonvertované kopie se uloží do nové sekvence vedle každé zdrojové; originály zůstanou, jak jsou</value></data>
<data name="Tooltips.Archive.ConvertModeReplace" xml:space="preserve"><value>Zkonvertované soubory nahradí fotografie v jejich sekvencích; originály se přesunou do koše archivu, kde je lze obnovit, dokud se koš nevysype</value></data>
<data name="Tooltips.Archive.ConvertNew" xml:space="preserve"><value>Zařadí do fronty úlohu, která zkonvertuje fotografie do nových sekvencí a každou konverzi ověří; originálů se nedotkne</value></data>
<data name="Tooltips.Archive.ConvertPlan" xml:space="preserve"><value>Sekvence, jejichž fotografie se nahradí</value></data>
<data name="Tooltips.Archive.ConvertPlanNew" xml:space="preserve"><value>Sekvence zkopírované do nových a fotografie, které každá vynechá</value></data>
<data name="Tooltips.Archive.ConvertQuality" xml:space="preserve"><value>Kvalita JPEG od 1 do 100 · 95 zachová jemné detaily; nižší hodnota dává menší soubory</value></data>
<data name="Tooltips.Archive.ConvertReplace.few" xml:space="preserve"><value>Nahradí {0:N0} fotografie jejich zkonvertovanými verzemi; nejprve zadejte výše uvedený počet</value></data>
<data name="Tooltips.Archive.ConvertReplace.one" xml:space="preserve"><value>Nahradí {0:N0} fotografii její zkonvertovanou verzí; nejprve zadejte výše uvedený počet</value></data>
<data name="Tooltips.Archive.ConvertReplace.other" xml:space="preserve"><value>Nahradí {0:N0} fotografií jejich zkonvertovanými verzemi; nejprve zadejte výše uvedený počet</value></data>
<data name="Tooltips.Archive.ConvertTiff" xml:space="preserve"><value>16bitový TIFF s bezeztrátovou kompresí · velké soubory, které otevře každý editor</value></data>
<data name="Tooltips.Archive.ConvertUndo" xml:space="preserve"><value>Vrátí originály z koše na místo jejich zkonvertovaných verzí</value></data>
<data name="Tooltips.Archive.DeleteAction.few" xml:space="preserve"><value>Přesune {0:N0} sekvence do koše; nejprve zadejte výše uvedený počet</value></data>
<data name="Tooltips.Archive.DeleteAction.one" xml:space="preserve"><value>Přesune {0:N0} sekvenci do koše; nejprve zadejte výše uvedený počet</value></data>
<data name="Tooltips.Archive.DeleteAction.other" xml:space="preserve"><value>Přesune {0:N0} sekvencí do koše; nejprve zadejte výše uvedený počet</value></data>
@@ -83,6 +99,7 @@
<data name="Tooltips.Archive.Scan" xml:space="preserve"><value>Přírůstkové prohledání: nové, změněné a odebrané soubory podle času změny a velikosti</value></data>
<data name="Tooltips.Archive.Set" xml:space="preserve"><value>Vybrané roky a sekvence (všechny, pokud není nic vybráno), zúžené podle fotoaparátu, stavu nebo značky</value></data>
<data name="Tooltips.Archive.SetAnalyse" xml:space="preserve"><value>Spustí hloubkovou analýzu všech sekvencí v sadě</value></data>
<data name="Tooltips.Archive.SetConvert" xml:space="preserve"><value>Zkonvertuje fotografie sady do formátu JPEG, TIFF nebo DNG · nejprve zkušební běh, pak úloha</value></data>
<data name="Tooltips.Archive.SetDelete" xml:space="preserve"><value>Přesune sadu do koše archivu · zobrazí zkušební běh a pak požádá o potvrzení zadáním počtu</value></data>
<data name="Tooltips.Archive.SetExport" xml:space="preserve"><value>Exportuje sadu jako CSV: jeden řádek na sekvenci</value></data>
<data name="Tooltips.Archive.SetProxies" xml:space="preserve"><value>Vytvoří nebo aktualizuje proxy</value></data>
@@ -97,7 +114,7 @@
<data name="Tooltips.Archive.TitleTemplate" xml:space="preserve"><value>Šablona názvu; zástupný symbol „title“ je aktuální název · kontroluje se během psaní</value></data>
<data name="Tooltips.Archive.Trash" xml:space="preserve"><value>Sekvence a fotografie odstraněné z tohoto archivu; každou lze obnovit</value></data>
<data name="Tooltips.Archive.TrashEmpty" xml:space="preserve"><value>Trvale odstraní položky tohoto koše po kontrole jejich obsahu a potvrzení zadáním počtu</value></data>
<data name="Tooltips.Archive.TrashEmptyPlan" xml:space="preserve"><value>Co se trvale odstraní z archivu</value></data>
<data name="Tooltips.Archive.TrashEmptyPlan" xml:space="preserve"><value>Co se trvale odstraní z archivu; originály, jejichž zkonvertovaná verze byla odstraněna, mohou být poslední kopií svých fotografií</value></data>
<data name="Tooltips.Archive.TrashErase.few" xml:space="preserve"><value>Trvale odstraní {0:N0} položky; nejprve zadejte výše uvedený počet</value></data>
<data name="Tooltips.Archive.TrashErase.one" xml:space="preserve"><value>Trvale odstraní {0:N0} položku; nejprve zadejte výše uvedený počet</value></data>
<data name="Tooltips.Archive.TrashErase.other" xml:space="preserve"><value>Trvale odstraní {0:N0} položek; nejprve zadejte výše uvedený počet</value></data>
@@ -472,6 +489,9 @@
<data name="Tooltips.Library.Mass.Analyse.few" xml:space="preserve"><value>Hloubková analýza {0:N0} sekvencí v tomto počítači · běží jako jedna úloha</value></data>
<data name="Tooltips.Library.Mass.Analyse.one" xml:space="preserve"><value>Hloubková analýza {0:N0} sekvence v tomto počítači · běží jako jedna úloha</value></data>
<data name="Tooltips.Library.Mass.Analyse.other" xml:space="preserve"><value>Hloubková analýza {0:N0} sekvencí v tomto počítači · běží jako jedna úloha</value></data>
<data name="Tooltips.Library.Mass.Convert.few" xml:space="preserve"><value>Zkonvertuje fotografie {0:N0} sekvencí jejich archivu do formátu JPEG, TIFF nebo DNG · nejprve zkušební běh, pak úloha</value></data>
<data name="Tooltips.Library.Mass.Convert.one" xml:space="preserve"><value>Zkonvertuje fotografie {0:N0} sekvence do formátu JPEG, TIFF nebo DNG · nejprve zkušební běh, pak úloha</value></data>
<data name="Tooltips.Library.Mass.Convert.other" xml:space="preserve"><value>Zkonvertuje fotografie {0:N0} sekvencí jejich archivu do formátu JPEG, TIFF nebo DNG · nejprve zkušební běh, pak úloha</value></data>
<data name="Tooltips.Library.Mass.Delete.few" xml:space="preserve"><value>Přesune {0:N0} sekvence do koše jejich archivu · zobrazí zkušební běh a pak požádá o potvrzení zadáním počtu</value></data>
<data name="Tooltips.Library.Mass.Delete.one" xml:space="preserve"><value>Přesune {0:N0} sekvenci do koše jejího archivu · zobrazí zkušební běh a pak požádá o potvrzení zadáním počtu</value></data>
<data name="Tooltips.Library.Mass.Delete.other" xml:space="preserve"><value>Přesune {0:N0} sekvencí do koše jejich archivu · zobrazí zkušební běh a pak požádá o potvrzení zadáním počtu</value></data>
+69
View File
@@ -9,6 +9,7 @@
<data name="Admin.About.Title" xml:space="preserve"><value>Chronos Server</value></data>
<data name="Admin.About.Uptime" xml:space="preserve"><value>Oppetid</value></data>
<data name="Admin.About.Version" xml:space="preserve"><value>Version</value></data>
<data name="Admin.Activity.ArchiveConverted" xml:space="preserve"><value>{0} satte en konvertering i kø · {1}</value></data>
<data name="Admin.Activity.ArchiveReorganized" xml:space="preserve"><value>{0} omorganiserede arkivet · {1}</value></data>
<data name="Admin.Activity.ArchiveSettings" xml:space="preserve"><value>{0} ændrede arkivets struktur</value></data>
<data name="Admin.Activity.FramesDeleted" xml:space="preserve"><value>{0} slettede {1}</value></data>
@@ -83,6 +84,68 @@
<data name="Admin.Common.TypeToConfirm.Tip" xml:space="preserve"><value>Skriv navnet præcis som vist for at bekræfte</value></data>
<data name="Admin.Common.TypeWord.Tip" xml:space="preserve"><value>Skriv ordet præcis som vist; der skelnes ikke mellem store og små bogstaver</value></data>
<data name="Admin.Common.TypeWordFirst.Tip" xml:space="preserve"><value>Skriv først ordet ovenfor</value></data>
<data name="Admin.Convert.Action" xml:space="preserve"><value>Konvertér…</value></data>
<data name="Admin.Convert.Action.Tip" xml:space="preserve"><value>Konvertér fotoene i de valgte sekvenser til JPEG, TIFF-16 eller lineær DNG; en forhåndsvisning viser først hver sekvens</value></data>
<data name="Admin.Convert.Apply" xml:space="preserve"><value>Konvertér…</value></data>
<data name="Admin.Convert.Apply.Tip" xml:space="preserve"><value>Konvertér som vist i forhåndsvisningen; først kommer en bekræftelse</value></data>
<data name="Admin.Convert.Cancel.Tip" xml:space="preserve"><value>Luk uden at konvertere noget</value></data>
<data name="Admin.Convert.ChooseMode" xml:space="preserve"><value>Vælg Erstat eller Ny sekvens for at konvertere.</value></data>
<data name="Admin.Convert.ChooseMode.Tip" xml:space="preserve"><value>Vælg først Erstat eller Ny sekvens</value></data>
<data name="Admin.Convert.Column.Converted" xml:space="preserve"><value>Konverteret</value></data>
<data name="Admin.Convert.Column.NotCopied" xml:space="preserve"><value>Ikke kopieret</value></data>
<data name="Admin.Convert.Column.Sequence" xml:space="preserve"><value>Sekvens</value></data>
<data name="Admin.Convert.Column.Size" xml:space="preserve"><value>Størrelse</value></data>
<data name="Admin.Convert.Column.Unchanged" xml:space="preserve"><value>Uændret</value></data>
<data name="Admin.Convert.Confirm.New" xml:space="preserve"><value>Konvertér</value></data>
<data name="Admin.Convert.Confirm.New.Tip" xml:space="preserve"><value>Sæt det job i kø, der konverterer fotoene til nye sekvenser og verificerer hver konvertering; originalerne røres ikke</value></data>
<data name="Admin.Convert.Confirm.Replace" xml:space="preserve"><value>Erstat</value></data>
<data name="Admin.Convert.Confirm.Replace.Tip" xml:space="preserve"><value>Sæt det job i kø, der konverterer fotoene, verificerer hver konvertering og flytter originalerne til papirkurven</value></data>
<data name="Admin.Convert.ConfirmNew.one" xml:space="preserve"><value>{0} foto konverteres til en kopi i en ny sekvens; originalen forbliver, som den er.</value></data>
<data name="Admin.Convert.ConfirmNew.other" xml:space="preserve"><value>{0} fotos konverteres til kopier i en ny sekvens ved siden af hver enkelt; originalerne forbliver, som de er.</value></data>
<data name="Admin.Convert.ConfirmNewNotCopied.one" xml:space="preserve"><value>{0} foto kopieres ikke til den nye sekvens af den årsag, forhåndsvisningen angiver.</value></data>
<data name="Admin.Convert.ConfirmNewNotCopied.other" xml:space="preserve"><value>{0} fotos kopieres ikke til de nye sekvenser af de årsager, forhåndsvisningen angiver.</value></data>
<data name="Admin.Convert.ConfirmNewTitle" xml:space="preserve"><value>Konvertér til {0} i nye sekvenser?</value></data>
<data name="Admin.Convert.ConfirmReplace.one" xml:space="preserve"><value>{0} foto i {1} erstattes af sin konverterede version; originalen flyttes til papirkurven og kan gendannes, indtil den tømmes.</value></data>
<data name="Admin.Convert.ConfirmReplace.other" xml:space="preserve"><value>{0} fotos i {1} erstattes af deres konverterede versioner; originalerne flyttes til papirkurven og kan gendannes, indtil den tømmes.</value></data>
<data name="Admin.Convert.ConfirmReplaceTitle" xml:space="preserve"><value>Erstat originalerne med {0}?</value></data>
<data name="Admin.Convert.Format" xml:space="preserve"><value>Format</value></data>
<data name="Admin.Convert.Format.Jpeg.Tip" xml:space="preserve"><value>8-bit JPEG med farver i fuld opløsning i den kvalitet, der er angivet ved siden af: de mindste filer, som alle programmer kan åbne</value></data>
<data name="Admin.Convert.Format.LinearDng" xml:space="preserve"><value>Lineær DNG</value></data>
<data name="Admin.Convert.Format.LinearDng.Tip" xml:space="preserve"><value>16-bit lineær DNG komprimeret uden tab: valget til arkivering, som RAW-redigeringsprogrammer kan åbne</value></data>
<data name="Admin.Convert.Format.Tiff16.Tip" xml:space="preserve"><value>16-bit sRGB TIFF komprimeret uden tab: store filer, der bevarer alle toner til redigering</value></data>
<data name="Admin.Convert.Gone" xml:space="preserve"><value>En valgt sekvens er ikke længere i arkivet; luk og vælg igen.</value></data>
<data name="Admin.Convert.Mode" xml:space="preserve"><value>Tilstand</value></data>
<data name="Admin.Convert.Mode.NewSequence" xml:space="preserve"><value>Ny sekvens</value></data>
<data name="Admin.Convert.Mode.NewSequence.Tip" xml:space="preserve"><value>De konverterede kopier lægges i en ny sekvens ved siden af hver enkelt; originalerne og deres sekvens forbliver præcis, som de er</value></data>
<data name="Admin.Convert.Mode.Replace" xml:space="preserve"><value>Erstat</value></data>
<data name="Admin.Convert.Mode.Replace.Tip" xml:space="preserve"><value>De konverterede filer bliver sekvensens fotos; originalerne flyttes til arkivets papirkurv og kan gendannes, indtil den tømmes</value></data>
<data name="Admin.Convert.NoAnswer" xml:space="preserve"><value>Serveren svarede ikke: kontrollér på siden Job, om konverteringen blev sat i kø, før du konverterer igen.</value></data>
<data name="Admin.Convert.NoSpace.Tip" xml:space="preserve"><value>Frigør først plads på arkivets diskenhed</value></data>
<data name="Admin.Convert.NotCopiedCount.one" xml:space="preserve"><value>{0} ikke kopieret</value></data>
<data name="Admin.Convert.NotCopiedCount.other" xml:space="preserve"><value>{0} ikke kopieret</value></data>
<data name="Admin.Convert.Nothing.Tip" xml:space="preserve"><value>Intet i forhåndsvisningen konverteres</value></data>
<data name="Admin.Convert.NothingToConvert" xml:space="preserve"><value>Intet at konvertere: alle fotos forbliver, som de er, af de viste årsager.</value></data>
<data name="Admin.Convert.OpenJob" xml:space="preserve"><value>Åbn job</value></data>
<data name="Admin.Convert.OpenJob.Tip" xml:space="preserve"><value>Vis jobbet og dets log på siden Job</value></data>
<data name="Admin.Convert.PlanChanged" xml:space="preserve"><value>Arkivet er ændret siden forhåndsvisningen; kontrollér den nye, og anvend igen.</value></data>
<data name="Admin.Convert.Planning" xml:space="preserve"><value>Planlægger…</value></data>
<data name="Admin.Convert.Planning.Tip" xml:space="preserve"><value>Serveren læser alle fotomapper i markeringen: et stort arkiv tager minutter, og forhåndsvisningen vises, når den er færdig</value></data>
<data name="Admin.Convert.PlanningFor" xml:space="preserve"><value>Planlægger… {0}</value></data>
<data name="Admin.Convert.Preview" xml:space="preserve"><value>Forhåndsvisning</value></data>
<data name="Admin.Convert.Preview.Tip" xml:space="preserve"><value>Hvad hver sekvens konverterer og lader være, som det er, med størrelsen før og efter (et skøn); intet er ændret endnu</value></data>
<data name="Admin.Convert.Quality" xml:space="preserve"><value>Kvalitet</value></data>
<data name="Admin.Convert.Quality.Tip" xml:space="preserve"><value>JPEG-kvalitet fra 1 til 100; 95 bevarer fine detaljer, lavere værdier giver mindre filer</value></data>
<data name="Admin.Convert.QualityRange" xml:space="preserve"><value>Skriv et heltal fra 1 til 100.</value></data>
<data name="Admin.Convert.Queued" xml:space="preserve"><value>Konvertering sat i kø.</value></data>
<data name="Admin.Convert.ReplaceWord" xml:space="preserve"><value>erstat</value></data>
<data name="Admin.Convert.Size.Tip" xml:space="preserve"><value>Den nuværende størrelse af de fotos, der konverteres, og derefter den anslåede størrelse bagefter</value></data>
<data name="Admin.Convert.SkippedPhotos" xml:space="preserve"><value>{0}: {1}</value></data>
<data name="Admin.Convert.Title.one" xml:space="preserve"><value>Konvertér {0} sekvens</value></data>
<data name="Admin.Convert.Title.other" xml:space="preserve"><value>Konvertér {0} sekvenser</value></data>
<data name="Admin.Convert.TitleAll" xml:space="preserve"><value>Konvertér alle sekvenser</value></data>
<data name="Admin.Convert.TooMany" xml:space="preserve"><value>Konvertering tager højst {0} sekvenser ad gangen eller alle sekvenser: ryd filtrene, og vælg alle.</value></data>
<data name="Admin.Convert.Totals" xml:space="preserve"><value>Sekvenser konverteret: {0} · fotos: {1} · uændrede: {2} · størrelse: {3} → {4}</value></data>
<data name="Admin.Convert.TotalsNew" xml:space="preserve"><value>Sekvenser konverteret: {0} · fotos: {1} · ikke kopieret: {2} · størrelse: {3} → {4}</value></data>
<data name="Admin.Dashboard.Activity" xml:space="preserve"><value>Seneste aktivitet</value></data>
<data name="Admin.Dashboard.AllLogs" xml:space="preserve"><value>Alle logge</value></data>
<data name="Admin.Dashboard.AllLogs.Tip" xml:space="preserve"><value>Åbn revisionsloggen</value></data>
@@ -133,6 +196,7 @@
<data name="Admin.Job.Kind.Adopt" xml:space="preserve"><value>Overtagelse</value></data>
<data name="Admin.Job.Kind.Backup" xml:space="preserve"><value>Sikkerhedskopi</value></data>
<data name="Admin.Job.Kind.Cleanup" xml:space="preserve"><value>Oprydning</value></data>
<data name="Admin.Job.Kind.Convert" xml:space="preserve"><value>Konvertering</value></data>
<data name="Admin.Job.Kind.DeepAnalyse" xml:space="preserve"><value>Dybdeanalyse</value></data>
<data name="Admin.Job.Kind.Duplicates" xml:space="preserve"><value>Dubletter</value></data>
<data name="Admin.Job.Kind.EmptyTrash" xml:space="preserve"><value>Tømning af papirkurv</value></data>
@@ -344,6 +408,7 @@
<data name="Admin.Login.SignIn.Tip" xml:space="preserve"><value>Log på for at administrere denne server</value></data>
<data name="Admin.Login.User" xml:space="preserve"><value>Bruger</value></data>
<data name="Admin.Login.User.Tip" xml:space="preserve"><value>Dit brugernavn på denne server</value></data>
<data name="Admin.Logs.Action.ArchiveConverted" xml:space="preserve"><value>Fotos konverteret</value></data>
<data name="Admin.Logs.Action.ArchiveReorganized" xml:space="preserve"><value>Arkiv omorganiseret</value></data>
<data name="Admin.Logs.Action.ArchiveSettings" xml:space="preserve"><value>Arkivstruktur</value></data>
<data name="Admin.Logs.Action.FramesDeleted" xml:space="preserve"><value>Fotos slettet</value></data>
@@ -793,6 +858,7 @@
<data name="Admin.Theme.Tip" xml:space="preserve"><value>Skift mellem lyst og mørkt tema</value></data>
<data name="Admin.Trash.Back" xml:space="preserve"><value>Bibliotek</value></data>
<data name="Admin.Trash.Back.Tip" xml:space="preserve"><value>Tilbage til biblioteket</value></data>
<data name="Admin.Trash.ConversionDeleted" xml:space="preserve"><value>konverteret version slettet</value></data>
<data name="Admin.Trash.DeletedAt" xml:space="preserve"><value>Slettet</value></data>
<data name="Admin.Trash.DeletedBy" xml:space="preserve"><value>Slettet af</value></data>
<data name="Admin.Trash.Emptied" xml:space="preserve"><value>Papirkurven er tømt.</value></data>
@@ -819,9 +885,12 @@
<data name="Admin.Trash.Photos" xml:space="preserve"><value>Fotos</value></data>
<data name="Admin.Trash.Restore" xml:space="preserve"><value>Gendan</value></data>
<data name="Admin.Trash.RestorePhotos.Tip" xml:space="preserve"><value>Læg fotoene tilbage i deres sekvens (en ny, hvis den ikke findes længere); hvert foto kontrolleres først mod sin SHA-256</value></data>
<data name="Admin.Trash.RestoreReplaced.Tip" xml:space="preserve"><value>Læg originalerne tilbage i stedet for deres konverterede versioner, så længe disse er uændrede (de konverterede versioner flyttes til papirkurven), ellers i en ny sekvens; hver enkelt kontrolleres først mod sin SHA-256</value></data>
<data name="Admin.Trash.RestoreSequence.Tip" xml:space="preserve"><value>Flyt sekvensens mappe tilbage til biblioteket, som den er (ved siden af dens gamle plads, hvis den er optaget); dens fotos kontrolleres ikke via hash: det gør Verificer</value></data>
<data name="Admin.Trash.RestoredNew.one" xml:space="preserve"><value>{0} foto gendannet i en ny sekvens.</value></data>
<data name="Admin.Trash.RestoredNew.other" xml:space="preserve"><value>{0} fotos gendannet i en ny sekvens.</value></data>
<data name="Admin.Trash.RestoredOriginals.one" xml:space="preserve"><value>{0} original er tilbage i {1}; dens konverterede version er i papirkurven.</value></data>
<data name="Admin.Trash.RestoredOriginals.other" xml:space="preserve"><value>{0} originaler er tilbage i {1}; deres konverterede versioner er i papirkurven.</value></data>
<data name="Admin.Trash.RestoredPhotos.one" xml:space="preserve"><value>{0} foto er tilbage i {1}.</value></data>
<data name="Admin.Trash.RestoredPhotos.other" xml:space="preserve"><value>{0} fotos er tilbage i {1}.</value></data>
<data name="Admin.Trash.RestoredSequence" xml:space="preserve"><value>{0} er tilbage i biblioteket.</value></data>
+108 -3
View File
@@ -15,8 +15,10 @@
<data name="Archive.Blocked.Applying" xml:space="preserve"><value>Vent, til ændringerne er anvendt.</value></data>
<data name="Archive.Blocked.EmptySet" xml:space="preserve"><value>Udvalget er tomt: skift markeringen eller filteret.</value></data>
<data name="Archive.Blocked.NoChanges" xml:space="preserve"><value>Intet ville blive ændret.</value></data>
<data name="Archive.Blocked.NoMode" xml:space="preserve"><value>Vælg Erstat eller Ny sekvens.</value></data>
<data name="Archive.Blocked.NoTemplate" xml:space="preserve"><value>Slå mindst én skabelon til.</value></data>
<data name="Archive.Blocked.NotOnline" xml:space="preserve"><value>Arkivet skal være online og skrivbart.</value></data>
<data name="Archive.Blocked.NothingToConvert" xml:space="preserve"><value>Intet at konvertere: alle fotos springes over, eller alle sekvenser er blokeret.</value></data>
<data name="Archive.Blocked.Planning" xml:space="preserve"><value>Vent på prøvekørslen.</value></data>
<data name="Archive.Blocked.Reading" xml:space="preserve"><value>Vent, til arkivet er læst.</value></data>
<data name="Archive.Blocked.Searching" xml:space="preserve"><value>En søgning kører; annuller den, eller vent.</value></data>
@@ -32,6 +34,82 @@
<data name="Archive.Confirm.Remove" xml:space="preserve"><value>Fjern række</value></data>
<data name="Archive.Confirm.RemoveHeading" xml:space="preserve"><value>Fjern {0} fra indekset?</value></data>
<data name="Archive.Confirm.RemoveMessage" xml:space="preserve"><value>Sekvensens sidecar-fil mangler. Kun rækken i indekset fjernes; ingen fil slettes.</value></data>
<data name="Archive.Convert.AlreadyQueued" xml:space="preserve"><value>En konvertering af disse sekvenser venter eller kører allerede; følg den under Job.</value></data>
<data name="Archive.Convert.Blocked.Busy" xml:space="preserve"><value>Et job arbejder på denne sekvens; konvertér den, når jobbet er færdigt.</value></data>
<data name="Archive.Convert.Blocked.FramesChanged" xml:space="preserve"><value>Sekvensen er ændret efter planen; gennemgå planen igen.</value></data>
<data name="Archive.Convert.Blocked.Offline" xml:space="preserve"><value>Arkivet er offline eller skrivebeskyttet.</value></data>
<data name="Archive.Convert.Blocked.Unreadable" xml:space="preserve"><value>Sekvensfilen kan ikke læses.</value></data>
<data name="Archive.Convert.Confirm" xml:space="preserve"><value>Konvertér</value></data>
<data name="Archive.Convert.CopyUnfinished" xml:space="preserve"><value>En anden konvertering har lavet en kopi af den i dette format og er ikke færdig; afslut den, eller prøv den igen først.</value></data>
<data name="Archive.Convert.Done.one" xml:space="preserve"><value>{0:N0} sekvens konverteret</value></data>
<data name="Archive.Convert.Done.other" xml:space="preserve"><value>{0:N0} sekvenser konverteret</value></data>
<data name="Archive.Convert.Failed.Changed" xml:space="preserve"><value>Fotoet svarer ikke længere til den kopi, der blev arkiveret; verificer sekvensen.</value></data>
<data name="Archive.Convert.Failed.ColorProfile" xml:space="preserve"><value>Dets farveprofil kan hverken bevares eller konverteres i dette format.</value></data>
<data name="Archive.Convert.Failed.Damaged" xml:space="preserve"><value>Dets pixels indeholder værdier, der ikke er tal: filen er beskadiget.</value></data>
<data name="Archive.Convert.Failed.EightBit" xml:space="preserve"><value>Denne computer fremkalder kun denne RAW-fil i 8 bit, hvilket er for lidt til en 16-bit-fil; JPEG kan konvertere den.</value></data>
<data name="Archive.Convert.Failed.Full" xml:space="preserve"><value>Arkivets disk er fuld.</value></data>
<data name="Archive.Convert.Failed.NoDecoder" xml:space="preserve"><value>Ingen dekoder på denne computer kan læse det i fuld opløsning.</value></data>
<data name="Archive.Convert.Failed.NotVerified" xml:space="preserve"><value>Den konverterede fil kunne ikke læses tilbage, som den blev skrevet.</value></data>
<data name="Archive.Convert.Failed.Other" xml:space="preserve"><value>Den konverterede fil kunne ikke oprettes.</value></data>
<data name="Archive.Convert.Failed.PreviewOnly" xml:space="preserve"><value>Denne computer kan kun læse det fra dets indlejrede forhåndsvisning: konvertér det på en pc, der kan læse det i fuld opløsning.</value></data>
<data name="Archive.Convert.Failed.TooLarge" xml:space="preserve"><value>Det er større, end dette format kan rumme, end Chronos kan læse tilbage, eller end hukommelsen til ét foto kan rumme.</value></data>
<data name="Archive.Convert.Failed.Unreadable" xml:space="preserve"><value>Fotoet kunne ikke afkodes.</value></data>
<data name="Archive.Convert.Format" xml:space="preserve"><value>Format</value></data>
<data name="Archive.Convert.Heading.one" xml:space="preserve"><value>Konvertér {0:N0} sekvens</value></data>
<data name="Archive.Convert.Heading.other" xml:space="preserve"><value>Konvertér {0:N0} sekvenser</value></data>
<data name="Archive.Convert.HeadingAll" xml:space="preserve"><value>Konvertér {0}</value></data>
<data name="Archive.Convert.Mode" xml:space="preserve"><value>Tilstand</value></data>
<data name="Archive.Convert.NewHeading.one" xml:space="preserve"><value>Konvertér {0:N0} sekvens til en ny?</value></data>
<data name="Archive.Convert.NewHeading.other" xml:space="preserve"><value>Konvertér {0:N0} sekvenser til nye?</value></data>
<data name="Archive.Convert.NewLeftOut.one" xml:space="preserve"><value>{0:N0} foto kopieres ikke: det bliver kun i sin kildesekvens af den årsag, planen angiver.</value></data>
<data name="Archive.Convert.NewLeftOut.other" xml:space="preserve"><value>{0:N0} fotos kopieres ikke: de bliver kun i deres kildesekvens af de årsager, planen angiver.</value></data>
<data name="Archive.Convert.NewMessage" xml:space="preserve"><value>{0} ({1}) konverteres til {2} i en ny sekvens ved siden af hver kilde; originalerne forbliver, som de er.</value></data>
<data name="Archive.Convert.NewSequence" xml:space="preserve"><value>Ny sekvens</value></data>
<data name="Archive.Convert.NotCopied.ColorProfile" xml:space="preserve"><value>Fotos, hvis farveprofil dette format hverken kan bevare eller konvertere, kopieres ikke til den nye sekvens.</value></data>
<data name="Archive.Convert.NotCopied.EightBit" xml:space="preserve"><value>RAW-fotos, som denne computer kun fremkalder i 8 bit, kopieres ikke til den nye sekvens; JPEG kan konvertere dem.</value></data>
<data name="Archive.Convert.NotCopied.Inaccessible" xml:space="preserve"><value>Fotos, som et andet program holder åbne, eller som ikke kan åbnes, kopieres ikke til den nye sekvens; planlæg igen, når de er ledige.</value></data>
<data name="Archive.Convert.NotCopied.Missing" xml:space="preserve"><value>Manglende fotos kopieres ikke til den nye sekvens.</value></data>
<data name="Archive.Convert.NotCopied.NoNativeDecoder" xml:space="preserve"><value>Fotos i et format, som denne computer ikke kan læse i fuld opløsning, kopieres ikke til den nye sekvens.</value></data>
<data name="Archive.Convert.NotCopied.PreviewOnly" xml:space="preserve"><value>Fotos, der her kun kan læses fra deres indlejrede forhåndsvisning, kopieres ikke til den nye sekvens.</value></data>
<data name="Archive.Convert.NotCopied.SameFormat" xml:space="preserve"><value>Fotos, der allerede er i dette format, kopieres ikke til den nye sekvens.</value></data>
<data name="Archive.Convert.NotCopied.TooLarge" xml:space="preserve"><value>Fotos, der er større, end dette format kan rumme eller Chronos kan læse tilbage, kopieres ikke til den nye sekvens.</value></data>
<data name="Archive.Convert.NotCopied.Undecodable" xml:space="preserve"><value>Ulæselige fotos kopieres ikke til den nye sekvens.</value></data>
<data name="Archive.Convert.NotCopied.Unhashed" xml:space="preserve"><value>Fotos, der aldrig er verificeret, kopieres ikke til den nye sekvens; verificer sekvensen først.</value></data>
<data name="Archive.Convert.NotCopiedPhotos.one" xml:space="preserve"><value>{0:N0} ikke kopieret</value></data>
<data name="Archive.Convert.NotCopiedPhotos.other" xml:space="preserve"><value>{0:N0} ikke kopieret</value></data>
<data name="Archive.Convert.NotPlaced" xml:space="preserve"><value>De konverterede fotos kunne ikke indtage deres plads. {0}</value></data>
<data name="Archive.Convert.PhotoFailed" xml:space="preserve"><value>{0} kunne ikke konverteres. {1}</value></data>
<data name="Archive.Convert.PhotoHeld" xml:space="preserve"><value>Et af dens fotos holdes åbent af et andet program eller kan ikke åbnes; prøv igen, når det er ledigt.</value></data>
<data name="Archive.Convert.Quality" xml:space="preserve"><value>Kvalitet</value></data>
<data name="Archive.Convert.Replace" xml:space="preserve"><value>Erstat</value></data>
<data name="Archive.Convert.ReplaceHeading.one" xml:space="preserve"><value>Erstat fotoene i {0:N0} sekvens?</value></data>
<data name="Archive.Convert.ReplaceHeading.other" xml:space="preserve"><value>Erstat fotoene i {0:N0} sekvenser?</value></data>
<data name="Archive.Convert.ReplaceMessage" xml:space="preserve"><value>{0} ({1}) erstattes ved konvertering til {2}; originalerne flyttes til arkivets papirkurv og kan gendannes, indtil den tømmes.</value></data>
<data name="Archive.Convert.Sizes" xml:space="preserve"><value>{0} → {1}</value></data>
<data name="Archive.Convert.Skipped.ColorProfile" xml:space="preserve"><value>Fotos, hvis farveprofil dette format hverken kan bevare eller konvertere, forbliver, som de er.</value></data>
<data name="Archive.Convert.Skipped.EightBit" xml:space="preserve"><value>RAW-fotos, som denne computer kun fremkalder i 8 bit, forbliver, som de er; JPEG kan konvertere dem.</value></data>
<data name="Archive.Convert.Skipped.Inaccessible" xml:space="preserve"><value>Fotos, som et andet program holder åbne, eller som ikke kan åbnes, forbliver, som de er; planlæg igen, når de er ledige.</value></data>
<data name="Archive.Convert.Skipped.Missing" xml:space="preserve"><value>Manglende fotos forbliver, som de er.</value></data>
<data name="Archive.Convert.Skipped.NoNativeDecoder" xml:space="preserve"><value>Fotos i et format, som denne computer ikke kan læse i fuld opløsning, forbliver, som de er.</value></data>
<data name="Archive.Convert.Skipped.PreviewOnly" xml:space="preserve"><value>Fotos, der her kun kan læses fra deres indlejrede forhåndsvisning, forbliver, som de er.</value></data>
<data name="Archive.Convert.Skipped.SameFormat" xml:space="preserve"><value>Fotos, der allerede er i dette format, forbliver, som de er.</value></data>
<data name="Archive.Convert.Skipped.TooLarge" xml:space="preserve"><value>Fotos, der er større, end dette format kan rumme eller Chronos kan læse tilbage, forbliver, som de er.</value></data>
<data name="Archive.Convert.Skipped.Undecodable" xml:space="preserve"><value>Ulæselige fotos forbliver, som de er.</value></data>
<data name="Archive.Convert.Skipped.Unhashed" xml:space="preserve"><value>Fotos, der aldrig er verificeret, forbliver, som de er; verificer sekvensen først.</value></data>
<data name="Archive.Convert.SkippedPhotos.one" xml:space="preserve"><value>{0:N0} sprunget over</value></data>
<data name="Archive.Convert.SkippedPhotos.other" xml:space="preserve"><value>{0:N0} sprunget over</value></data>
<data name="Archive.Convert.Space" xml:space="preserve"><value>Kræver {0}, ledig {1}</value></data>
<data name="Archive.Convert.SpaceShort" xml:space="preserve"><value>Kræver {0}, kun {1} ledig: frigør først plads.</value></data>
<data name="Archive.Convert.SpaceUnknown" xml:space="preserve"><value>Kræver {0}; den ledige plads kan ikke måles.</value></data>
<data name="Archive.Convert.Target.LinearDng" xml:space="preserve"><value>Lineær DNG</value></data>
<data name="Archive.Convert.Target.Tiff16" xml:space="preserve"><value>TIFF 16-bit</value></data>
<data name="Archive.Convert.UndoFailed" xml:space="preserve"><value>Originalerne kunne ikke komme tilbage</value></data>
<data name="Archive.Convert.UndoNothing" xml:space="preserve"><value>De erstattede originaler er ikke længere i papirkurven.</value></data>
<data name="Archive.Convert.Undone.one" xml:space="preserve"><value>Originaler tilbage i {0:N0} sekvens</value></data>
<data name="Archive.Convert.Undone.other" xml:space="preserve"><value>Originaler tilbage i {0:N0} sekvenser</value></data>
<data name="Archive.Convert.UndoneNew.one" xml:space="preserve"><value>{0:N0} sekvens var ændret i mellemtiden: dens originaler kom tilbage som en ny sekvens.</value></data>
<data name="Archive.Convert.UndoneNew.other" xml:space="preserve"><value>{0:N0} sekvenser var ændret i mellemtiden: deres originaler kom tilbage som nye sekvenser.</value></data>
<data name="Archive.Convert.Unstaged" xml:space="preserve"><value>Den konverterede version af {0} er ikke længere blandt de klargjorte filer; et nyt forsøg konverterer fotoet igen.</value></data>
<data name="Archive.Copy.Title" xml:space="preserve"><value>Mappe, der skal kopieres ind i arkivet</value></data>
<data name="Archive.Delete.Action" xml:space="preserve"><value>Flyt til papirkurv</value></data>
<data name="Archive.Delete.Blocked" xml:space="preserve"><value>Ikke flyttet: {0} · {1}</value></data>
@@ -75,6 +153,9 @@
<data name="Archive.Duplicates.Title" xml:space="preserve"><value>Dubletter</value></data>
<data name="Archive.Empty" xml:space="preserve"><value>Intet arkiv endnu</value></data>
<data name="Archive.Error.Busy" xml:space="preserve"><value>En anden Chronos ({0}) skriver her. Prøv igen om lidt.</value></data>
<data name="Archive.Error.ConvertKept.one" xml:space="preserve"><value>{0:N0} sekvens blev ikke konverteret som planlagt; jobbets log viser hvorfor.</value></data>
<data name="Archive.Error.ConvertKept.other" xml:space="preserve"><value>{0:N0} sekvenser blev ikke konverteret som planlagt; jobbets log viser hvorfor.</value></data>
<data name="Archive.Error.ConvertSpace" xml:space="preserve"><value>Konverteringen kræver {0} ledig plads på arkivets diskenhed, og der er {1} ledig.</value></data>
<data name="Archive.Error.CopyMismatch" xml:space="preserve"><value>Kopien af {0} svarer ikke til originalen.</value></data>
<data name="Archive.Error.DuplicateLost" xml:space="preserve"><value>{0} kunne ikke føjes til sekvensen.</value></data>
<data name="Archive.Error.InLibrary" xml:space="preserve"><value>{0} er allerede i biblioteket.</value></data>
@@ -92,8 +173,8 @@
<data name="Archive.Error.SourceGone" xml:space="preserve"><value>Kortet eller mappen {0} er ikke længere tilgængelig.</value></data>
<data name="Archive.Error.StalePlan" xml:space="preserve"><value>Arkivet er ændret, efter at denne plan blev lavet.</value></data>
<data name="Archive.Error.TrashChanged" xml:space="preserve"><value>Papirkurven blev ændret, efter at den blev kontrolleret; intet blev slettet.</value></data>
<data name="Archive.Error.TrashKept.one" xml:space="preserve"><value>{0:N0} post i papirkurven blev bevaret: den er ændret, eller en erstatning stemmer ikke længere overens.</value></data>
<data name="Archive.Error.TrashKept.other" xml:space="preserve"><value>{0:N0} poster i papirkurven blev bevaret: de er ændret, eller en erstatning stemmer ikke længere overens.</value></data>
<data name="Archive.Error.TrashKept.one" xml:space="preserve"><value>{0:N0} post i papirkurven blev bevaret; jobbets log viser hvorfor.</value></data>
<data name="Archive.Error.TrashKept.other" xml:space="preserve"><value>{0:N0} poster i papirkurven blev bevaret; jobbets log viser hvorfor.</value></data>
<data name="Archive.Error.TrashMismatch" xml:space="preserve"><value>Ingen af filerne i denne post i papirkurven stemmer længere overens med dens registrering; posten bliver i papirkurven.</value></data>
<data name="Archive.Failed.Access" xml:space="preserve"><value>Chronos fik ikke adgang til arkivet.</value></data>
<data name="Archive.Failed.Files" xml:space="preserve"><value>En fil i arkivet kunne ikke læses eller skrives.</value></data>
@@ -132,6 +213,15 @@
<data name="Archive.Log.AuditKept" xml:space="preserve"><value>Revisionsloggen bevares fuldt ud</value></data>
<data name="Archive.Log.AuditPurged" xml:space="preserve"><value>Revisionsposter fjernet: {0}</value></data>
<data name="Archive.Log.BackupDone" xml:space="preserve"><value>Indeks kopieret til {0} ({1}); bevarede kopier: {2}</value></data>
<data name="Archive.Log.ConvertBlocked" xml:space="preserve"><value>Ladt urørt, optaget eller ulæselig: {0}</value></data>
<data name="Archive.Log.ConvertChanged" xml:space="preserve"><value>Ladt urørt, ændret efter planen: {0}. Et nyt forsøg lader den være, som den er: konvertér den igen ud fra en ny plan.</value></data>
<data name="Archive.Log.ConvertDone" xml:space="preserve"><value>Sekvenser konverteret: {0}, nye sekvenser: {1}, fotos: {2}</value></data>
<data name="Archive.Log.ConvertFailed" xml:space="preserve"><value>Ladt urørt: {0}. {1}</value></data>
<data name="Archive.Log.ConvertLeftOut" xml:space="preserve"><value>{0}: fotos ikke konverteret, kun efterladt i kilden: {1}</value></data>
<data name="Archive.Log.ConvertNothing" xml:space="preserve"><value>Intet at konvertere: {0}</value></data>
<data name="Archive.Log.ConvertSuperseded" xml:space="preserve"><value>{0}: en anden konvertering har lavet sin kopi i dette format, siden denne blev bekræftet; der laves ikke en kopi mere.</value></data>
<data name="Archive.Log.Converted" xml:space="preserve"><value>{0}: fotos erstattet af deres konverterede versioner: {1}</value></data>
<data name="Archive.Log.ConvertedNew" xml:space="preserve"><value>{0}: fotos konverteret til en ny sekvens: {1}</value></data>
<data name="Archive.Log.DryRun" xml:space="preserve"><value>Prøvekørsel: intet blev ændret.</value></data>
<data name="Archive.Log.DuplicateGroup" xml:space="preserve"><value>Ekstra kopier af {0}: {1}</value></data>
<data name="Archive.Log.DuplicatesDone" xml:space="preserve"><value>Dubletgrupper: {0}, ekstra kopier: {1}</value></data>
@@ -166,9 +256,22 @@
<data name="Archive.Log.SequenceMissing" xml:space="preserve"><value>Sekvens ikke fundet: {0}</value></data>
<data name="Archive.Log.StepFailed" xml:space="preserve"><value>Oprydningstrinnet {0} mislykkedes: {1}</value></data>
<data name="Archive.Log.StepUnknown" xml:space="preserve"><value>Oprydningstrin ukendt her: {0}</value></data>
<data name="Archive.Log.SyncChanged" xml:space="preserve"><value>{0}: ændret siden arkiveringen, ikke uploadet</value></data>
<data name="Archive.Log.SyncDeletedHere" xml:space="preserve"><value>{0}: slettet på denne pc, ikke downloadet</value></data>
<data name="Archive.Log.SyncDeletedThere" xml:space="preserve"><value>{0}: slettet på serveren, ikke uploadet</value></data>
<data name="Archive.Log.SyncFrameChanged" xml:space="preserve"><value>{0}: dens billede her er ændret i mellemtiden, ikke downloadet</value></data>
<data name="Archive.Log.SyncMissing" xml:space="preserve"><value>{0}: mangler, ikke uploadet</value></data>
<data name="Archive.Log.SyncNoPreview.one" xml:space="preserve"><value>{0:N0} billede har hverken proxy eller miniature på serveren</value></data>
<data name="Archive.Log.SyncNoPreview.other" xml:space="preserve"><value>{0:N0} billeder har hverken proxy eller miniature på serveren</value></data>
<data name="Archive.Log.TrashEmptied" xml:space="preserve"><value>Poster slettet: {0}, størrelse: {1}</value></data>
<data name="Archive.Log.TrashEntry" xml:space="preserve"><value>I papirkurven siden {0}: {1} ({2})</value></data>
<data name="Archive.Log.TrashKept" xml:space="preserve"><value>Bevaret i papirkurven: {0}</value></data>
<data name="Archive.Log.TrashKept" xml:space="preserve"><value>Bevaret i papirkurven, ændret efter planen: {0}</value></data>
<data name="Archive.Log.TrashKeptBusy" xml:space="preserve"><value>Bevaret i papirkurven, dens sekvens var optaget: {0}</value></data>
<data name="Archive.Log.TrashKeptMismatch" xml:space="preserve"><value>Bevaret i papirkurven, en konverteret version af dens originaler stemmer ikke længere: {0}</value></data>
<data name="Archive.Log.TrashKeptStaleIndex" xml:space="preserve"><value>Bevaret i papirkurven, indekset viser dens sekvens, som arkivet ikke længere indeholder; genopbyg indekset: {0}</value></data>
<data name="Archive.Log.TrashKeptUnhashed" xml:space="preserve"><value>Bevaret i papirkurven, et foto i dens sekvens blev aldrig verificeret; verificer sekvensen: {0}</value></data>
<data name="Archive.Log.TrashKeptUnknown" xml:space="preserve"><value>Bevaret i papirkurven, arkivet viser ikke, hvad der blev af konverteringen af dens originaler; gendan den for at beholde dem: {0}</value></data>
<data name="Archive.Log.TrashKeptUnreadable" xml:space="preserve"><value>Bevaret i papirkurven, sidecar-filen i en mappe, der kan indeholde dens sekvens, mangler eller kan ikke læses; scan arkivet: {0}</value></data>
<data name="Archive.Log.TrashOffline" xml:space="preserve"><value>Papirkurven blev ikke kontrolleret: arkivet kan ikke nås</value></data>
<data name="Archive.Log.TrashReport" xml:space="preserve"><value>Gamle poster i papirkurven: {0}, størrelse: {1}; intet blev slettet</value></data>
<data name="Archive.Log.VerifyDone" xml:space="preserve"><value>Fotos kontrolleret: {0}, intakte: {1}, hashet: {2}, med problemer: {3}</value></data>
@@ -249,6 +352,7 @@
<data name="Archive.Set.All.other" xml:space="preserve"><value>{0:N0} sekvenser · alle</value></data>
<data name="Archive.Set.Analyse" xml:space="preserve"><value>Analysér</value></data>
<data name="Archive.Set.ClearFilter" xml:space="preserve"><value>Ryd filter</value></data>
<data name="Archive.Set.Convert" xml:space="preserve"><value>Konvertér…</value></data>
<data name="Archive.Set.Delete" xml:space="preserve"><value>Slet…</value></data>
<data name="Archive.Set.Export" xml:space="preserve"><value>Eksporter CSV</value></data>
<data name="Archive.Set.Filter" xml:space="preserve"><value>Udvalgsfilter</value></data>
@@ -278,6 +382,7 @@
<data name="Archive.Toolbar.Scan" xml:space="preserve"><value>Scan</value></data>
<data name="Archive.Toolbar.Verify" xml:space="preserve"><value>Verificer</value></data>
<data name="Archive.Trash.Checking" xml:space="preserve"><value>Kontrollerer papirkurven…</value></data>
<data name="Archive.Trash.ConversionDeleted" xml:space="preserve"><value>konverteret version slettet</value></data>
<data name="Archive.Trash.Deleted" xml:space="preserve"><value>Slettet {0}</value></data>
<data name="Archive.Trash.Empty" xml:space="preserve"><value>Papirkurven er tom</value></data>
<data name="Archive.Trash.EmptyAction" xml:space="preserve"><value>Tøm…</value></data>
+1
View File
@@ -69,6 +69,7 @@
<data name="Jobs.Kind.Adopt" xml:space="preserve"><value>Mappeovertagelse</value></data>
<data name="Jobs.Kind.Backup" xml:space="preserve"><value>Sikkerhedskopi af indeks</value></data>
<data name="Jobs.Kind.Cleanup" xml:space="preserve"><value>Oprydning</value></data>
<data name="Jobs.Kind.Convert" xml:space="preserve"><value>Konvertering</value></data>
<data name="Jobs.Kind.DeepAnalyse" xml:space="preserve"><value>Dybdeanalyse</value></data>
<data name="Jobs.Kind.Download" xml:space="preserve"><value>Download</value></data>
<data name="Jobs.Kind.Duplicates" xml:space="preserve"><value>Dubletter</value></data>
+2
View File
@@ -6,6 +6,7 @@
<resheader name="writer"><value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader>
<data name="Library.Action.Analyse" xml:space="preserve"><value>Analysér</value></data>
<data name="Library.Action.ClearSelection" xml:space="preserve"><value>Ryd markering</value></data>
<data name="Library.Action.Convert" xml:space="preserve"><value>Konvertér…</value></data>
<data name="Library.Action.Delete" xml:space="preserve"><value>Slet…</value></data>
<data name="Library.Action.Download" xml:space="preserve"><value>Download</value></data>
<data name="Library.Action.ExportList" xml:space="preserve"><value>Eksporter liste</value></data>
@@ -32,6 +33,7 @@
<data name="Library.Blocked.NothingToDownload" xml:space="preserve"><value>De valgte sekvenser har intet at hente fra serveren.</value></data>
<data name="Library.Blocked.NothingToUpload" xml:space="preserve"><value>Serveren har allerede det, som de valgte sekvenser indeholder.</value></data>
<data name="Library.Blocked.OneArchive" xml:space="preserve"><value>Omorganisering arbejder med sekvenserne i ét arkiv ad gangen.</value></data>
<data name="Library.Blocked.OneArchiveConvert" xml:space="preserve"><value>Konvertering arbejder med sekvenserne i ét arkiv ad gangen.</value></data>
<data name="Library.Blocked.ServerOnly" xml:space="preserve"><value>Kun for sekvenser på denne pc; markeringen ligger på serveren.</value></data>
<data name="Library.Blocked.Transferring" xml:space="preserve"><value>En overførsel af denne sekvens er allerede i gang.</value></data>
<data name="Library.ClearFilters" xml:space="preserve"><value>Ryd filtre</value></data>
+4
View File
@@ -21,6 +21,8 @@
<data name="Server.Conflict.TakeServer.Message" xml:space="preserve"><value>Indstillingerne for {0} på denne pc erstattes af serverens kopi.</value></data>
<data name="Server.Conflict.TakeServer.Title" xml:space="preserve"><value>Brug serverens indstillinger?</value></data>
<data name="Server.Connect" xml:space="preserve"><value>Opret forbindelse</value></data>
<data name="Server.Convert.OnPc" xml:space="preserve"><value>Konvertér disse fotos på en pc: serveren kan ikke læse dem i fuld opløsning.</value></data>
<data name="Server.Convert.OnPcNew" xml:space="preserve"><value>Kopieres ikke til den nye sekvens: serveren kan ikke læse disse fotos i fuld opløsning; konvertér dem på en pc.</value></data>
<data name="Server.Disconnect" xml:space="preserve"><value>Afbryd forbindelse</value></data>
<data name="Server.Empty" xml:space="preserve"><value>Ikke tilsluttet en server</value></data>
<data name="Server.Error.AccountLocked" xml:space="preserve"><value>For mange mislykkede loginforsøg; kontoen er låst et stykke tid.</value></data>
@@ -71,7 +73,9 @@
<data name="Server.Error.MethodNotAllowed" xml:space="preserve"><value>Denne metode er ikke tilladt her.</value></data>
<data name="Server.Error.NestedTarget" xml:space="preserve"><value>En ny mappe ville ligge inde i mappen for en anden sekvens.</value></data>
<data name="Server.Error.NotChronos" xml:space="preserve"><value>Den adresse er ikke en Chronos Server.</value></data>
<data name="Server.Error.NotEnoughSpace" xml:space="preserve"><value>Arkivets diskenhed mangler den plads, som konverteringen kræver.</value></data>
<data name="Server.Error.NotFound" xml:space="preserve"><value>Ikke fundet.</value></data>
<data name="Server.Error.NothingToConvert" xml:space="preserve"><value>Planen konverterer intet: alle fotos springes over, eller alle sekvenser er blokeret.</value></data>
<data name="Server.Error.PasswordChangeRequired" xml:space="preserve"><value>Skift din adgangskode først.</value></data>
<data name="Server.Error.PhotoRemoved" xml:space="preserve"><value>Fotoet blev slettet fra sekvensen, mens det blev uploadet, så det blev ikke tilføjet.</value></data>
<data name="Server.Error.PhotoUnreadable" xml:space="preserve"><value>{0} kan ikke læses, og uden dens hash ville andre kopier ikke få at vide, at den blev slettet; luk det program, der bruger den, eller kontrollér dens tilladelser, og prøv derefter igen.</value></data>
+19 -1
View File
@@ -27,6 +27,21 @@
<data name="Tooltips.Archive.ClearFilter" xml:space="preserve"><value>Vis alle sekvenser i markeringen igen</value></data>
<data name="Tooltips.Archive.CloseDialog" xml:space="preserve"><value>Luk uden at ændre noget · Esc</value></data>
<data name="Tooltips.Archive.Collapse" xml:space="preserve"><value>Skjul sekvenserne fra dette år</value></data>
<data name="Tooltips.Archive.ConvertApplyNew" xml:space="preserve"><value>Bekræft, og sæt derefter et job i kø, der konverterer kopier til nye sekvenser · sæt det på pause, og genoptag det under Job</value></data>
<data name="Tooltips.Archive.ConvertApplyReplace" xml:space="preserve"><value>Skriv antallet af fotos for at bekræfte, og sæt derefter et job i kø, der erstatter dem med deres konverterede versioner · sæt det på pause, og genoptag det under Job</value></data>
<data name="Tooltips.Archive.ConvertBack" xml:space="preserve"><value>Tilbage til planen; intet konverteres</value></data>
<data name="Tooltips.Archive.ConvertDng" xml:space="preserve"><value>Lineær DNG, 16-bit og tabsfri · kan læses af alle RAW-redigeringsprogrammer; valget til arkivering</value></data>
<data name="Tooltips.Archive.ConvertJpeg" xml:space="preserve"><value>8-bit JPEG i kvaliteten nedenfor · de mindste filer; nogle detaljer går tabt</value></data>
<data name="Tooltips.Archive.ConvertModeNew" xml:space="preserve"><value>De konverterede kopier lægges i en ny sekvens ved siden af hver enkelt; originalerne forbliver, som de er</value></data>
<data name="Tooltips.Archive.ConvertModeReplace" xml:space="preserve"><value>De konverterede filer overtager fotoenes plads i deres sekvenser; originalerne flyttes til arkivets papirkurv og kan gendannes, indtil den tømmes</value></data>
<data name="Tooltips.Archive.ConvertNew" xml:space="preserve"><value>Sæt det job i kø, der konverterer fotoene til nye sekvenser og verificerer hver konvertering; originalerne røres ikke</value></data>
<data name="Tooltips.Archive.ConvertPlan" xml:space="preserve"><value>De sekvenser, hvis fotos erstattes</value></data>
<data name="Tooltips.Archive.ConvertPlanNew" xml:space="preserve"><value>De sekvenser, der kopieres til nye, og de fotos, hver enkelt udelader</value></data>
<data name="Tooltips.Archive.ConvertQuality" xml:space="preserve"><value>JPEG-kvalitet fra 1 til 100 · 95 bevarer fine detaljer; lavere giver mindre filer</value></data>
<data name="Tooltips.Archive.ConvertReplace.one" xml:space="preserve"><value>Erstat {0:N0} foto med dets konverterede version; skriv først antallet ovenfor</value></data>
<data name="Tooltips.Archive.ConvertReplace.other" xml:space="preserve"><value>Erstat {0:N0} fotos med deres konverterede versioner; skriv først antallet ovenfor</value></data>
<data name="Tooltips.Archive.ConvertTiff" xml:space="preserve"><value>16-bit TIFF komprimeret uden tab · store filer, som alle redigeringsprogrammer kan åbne</value></data>
<data name="Tooltips.Archive.ConvertUndo" xml:space="preserve"><value>Læg originalerne tilbage fra papirkurven i stedet for deres konverterede versioner</value></data>
<data name="Tooltips.Archive.DeleteAction.one" xml:space="preserve"><value>Flyt {0:N0} sekvens til papirkurven; skriv først antallet ovenfor</value></data>
<data name="Tooltips.Archive.DeleteAction.other" xml:space="preserve"><value>Flyt {0:N0} sekvenser til papirkurven; skriv først antallet ovenfor</value></data>
<data name="Tooltips.Archive.DeleteKeep" xml:space="preserve"><value>Lad alt være, som det er</value></data>
@@ -82,6 +97,7 @@
<data name="Tooltips.Archive.Scan" xml:space="preserve"><value>Trinvis scanning: nye, ændrede og fjernede filer efter ændringstidspunkt og størrelse</value></data>
<data name="Tooltips.Archive.Set" xml:space="preserve"><value>De valgte år og sekvenser (alle, når intet er valgt), indsnævret efter kamera, status eller tag</value></data>
<data name="Tooltips.Archive.SetAnalyse" xml:space="preserve"><value>Kør dybdeanalysen på alle sekvenser i udvalget</value></data>
<data name="Tooltips.Archive.SetConvert" xml:space="preserve"><value>Konvertér fotoene i udvalget til JPEG, TIFF eller DNG · først en prøvekørsel, derefter et job</value></data>
<data name="Tooltips.Archive.SetDelete" xml:space="preserve"><value>Flyt udvalget til arkivets papirkurv · viser prøvekørslen og beder dig derefter skrive for at bekræfte</value></data>
<data name="Tooltips.Archive.SetExport" xml:space="preserve"><value>Eksporter udvalget som CSV: én række pr. sekvens</value></data>
<data name="Tooltips.Archive.SetProxies" xml:space="preserve"><value>Generér eller opdater proxyer</value></data>
@@ -96,7 +112,7 @@
<data name="Tooltips.Archive.TitleTemplate" xml:space="preserve"><value>Titelskabelon; titeltokenet er den nuværende titel · kontrolleres, mens du skriver</value></data>
<data name="Tooltips.Archive.Trash" xml:space="preserve"><value>De sekvenser og fotos, der er slettet fra dette arkiv; hver enkelt kan gendannes</value></data>
<data name="Tooltips.Archive.TrashEmpty" xml:space="preserve"><value>Slet posterne i denne papirkurv endeligt efter en kontrol af, hvad de indeholder, og en skrevet bekræftelse</value></data>
<data name="Tooltips.Archive.TrashEmptyPlan" xml:space="preserve"><value>Hvad der slettes endeligt fra arkivet</value></data>
<data name="Tooltips.Archive.TrashEmptyPlan" xml:space="preserve"><value>Hvad der slettes endeligt fra arkivet; originaler, hvis konverterede version er slettet, kan være den sidste kopi af deres fotos</value></data>
<data name="Tooltips.Archive.TrashErase.one" xml:space="preserve"><value>Slet {0:N0} post endeligt; skriv først antallet ovenfor</value></data>
<data name="Tooltips.Archive.TrashErase.other" xml:space="preserve"><value>Slet {0:N0} poster endeligt; skriv først antallet ovenfor</value></data>
<data name="Tooltips.Archive.TrashRestore" xml:space="preserve"><value>Flyt denne post tilbage: en sekvens til dens mappe og biblioteket, fotos til deres sekvens efter en hashkontrol</value></data>
@@ -468,6 +484,8 @@
<data name="Tooltips.Library.List" xml:space="preserve"><value>Tabel med sorterbare kolonner</value></data>
<data name="Tooltips.Library.Mass.Analyse.one" xml:space="preserve"><value>Dybdeanalyse af {0:N0} sekvens på denne pc · kører som ét job</value></data>
<data name="Tooltips.Library.Mass.Analyse.other" xml:space="preserve"><value>Dybdeanalyse af {0:N0} sekvenser på denne pc · kører som ét job</value></data>
<data name="Tooltips.Library.Mass.Convert.one" xml:space="preserve"><value>Konvertér fotoene i {0:N0} sekvens til JPEG, TIFF eller DNG · først en prøvekørsel, derefter et job</value></data>
<data name="Tooltips.Library.Mass.Convert.other" xml:space="preserve"><value>Konvertér fotoene i {0:N0} sekvenser i deres arkiv til JPEG, TIFF eller DNG · først en prøvekørsel, derefter et job</value></data>
<data name="Tooltips.Library.Mass.Delete.one" xml:space="preserve"><value>Flyt {0:N0} sekvens til dens arkivs papirkurv · viser prøvekørslen og beder dig derefter skrive for at bekræfte</value></data>
<data name="Tooltips.Library.Mass.Delete.other" xml:space="preserve"><value>Flyt {0:N0} sekvenser til deres arkivs papirkurv · viser prøvekørslen og beder dig derefter skrive for at bekræfte</value></data>
<data name="Tooltips.Library.Mass.Download.one" xml:space="preserve"><value>Hent det, som {0:N0} sekvens mangler her (originaler eller renderinger), fra serveren · kører som et overførselsjob</value></data>
+69
View File
@@ -9,6 +9,7 @@
<data name="Admin.About.Title" xml:space="preserve"><value>Chronos Server</value></data>
<data name="Admin.About.Uptime" xml:space="preserve"><value>Läuft seit</value></data>
<data name="Admin.About.Version" xml:space="preserve"><value>Version</value></data>
<data name="Admin.Activity.ArchiveConverted" xml:space="preserve"><value>{0} hat eine Konvertierung eingereiht · {1}</value></data>
<data name="Admin.Activity.ArchiveReorganized" xml:space="preserve"><value>{0} hat das Archiv neu geordnet · {1}</value></data>
<data name="Admin.Activity.ArchiveSettings" xml:space="preserve"><value>{0} hat die Archivstruktur geändert</value></data>
<data name="Admin.Activity.FramesDeleted" xml:space="preserve"><value>{0} hat {1} gelöscht</value></data>
@@ -83,6 +84,68 @@
<data name="Admin.Common.TypeToConfirm.Tip" xml:space="preserve"><value>Geben Sie den Namen zur Bestätigung genau wie angezeigt ein</value></data>
<data name="Admin.Common.TypeWord.Tip" xml:space="preserve"><value>Geben Sie das Wort genau wie angezeigt ein; Groß- und Kleinschreibung spielt keine Rolle</value></data>
<data name="Admin.Common.TypeWordFirst.Tip" xml:space="preserve"><value>Geben Sie zuerst oben das Wort ein</value></data>
<data name="Admin.Convert.Action" xml:space="preserve"><value>Konvertieren…</value></data>
<data name="Admin.Convert.Action.Tip" xml:space="preserve"><value>Die Fotos der ausgewählten Sequenzen in JPEG, TIFF-16 oder lineares DNG konvertieren; eine Vorschau zeigt zuerst jede Sequenz</value></data>
<data name="Admin.Convert.Apply" xml:space="preserve"><value>Konvertieren…</value></data>
<data name="Admin.Convert.Apply.Tip" xml:space="preserve"><value>Wie in der Vorschau gezeigt konvertieren; vorher wird um Bestätigung gebeten</value></data>
<data name="Admin.Convert.Cancel.Tip" xml:space="preserve"><value>Schließen, ohne etwas zu konvertieren</value></data>
<data name="Admin.Convert.ChooseMode" xml:space="preserve"><value>Wählen Sie „Ersetzen“ oder „Neue Sequenz“, um zu konvertieren.</value></data>
<data name="Admin.Convert.ChooseMode.Tip" xml:space="preserve"><value>Wählen Sie zuerst „Ersetzen“ oder „Neue Sequenz“</value></data>
<data name="Admin.Convert.Column.Converted" xml:space="preserve"><value>Konvertiert</value></data>
<data name="Admin.Convert.Column.NotCopied" xml:space="preserve"><value>Nicht kopiert</value></data>
<data name="Admin.Convert.Column.Sequence" xml:space="preserve"><value>Sequenz</value></data>
<data name="Admin.Convert.Column.Size" xml:space="preserve"><value>Größe</value></data>
<data name="Admin.Convert.Column.Unchanged" xml:space="preserve"><value>Unverändert</value></data>
<data name="Admin.Convert.Confirm.New" xml:space="preserve"><value>Konvertieren</value></data>
<data name="Admin.Convert.Confirm.New.Tip" xml:space="preserve"><value>Den Auftrag einreihen, der die Fotos in neue Sequenzen konvertiert und jede Konvertierung prüft; die Originale bleiben unberührt</value></data>
<data name="Admin.Convert.Confirm.Replace" xml:space="preserve"><value>Ersetzen</value></data>
<data name="Admin.Convert.Confirm.Replace.Tip" xml:space="preserve"><value>Den Auftrag einreihen, der die Fotos konvertiert, jede Konvertierung prüft und die Originale in den Papierkorb verschiebt</value></data>
<data name="Admin.Convert.ConfirmNew.one" xml:space="preserve"><value>{0} Foto wird in eine Kopie in einer neuen Sequenz konvertiert; das Original bleibt unverändert.</value></data>
<data name="Admin.Convert.ConfirmNew.other" xml:space="preserve"><value>{0} Fotos werden in Kopien konvertiert, jeweils in einer neuen Sequenz neben der ursprünglichen; die Originale bleiben unverändert.</value></data>
<data name="Admin.Convert.ConfirmNewNotCopied.one" xml:space="preserve"><value>{0} Foto wird nicht in die neue Sequenz kopiert, aus dem Grund, den die Vorschau nennt.</value></data>
<data name="Admin.Convert.ConfirmNewNotCopied.other" xml:space="preserve"><value>{0} Fotos werden nicht in die neuen Sequenzen kopiert, aus den Gründen, die die Vorschau nennt.</value></data>
<data name="Admin.Convert.ConfirmNewTitle" xml:space="preserve"><value>Als neue Sequenzen in {0} konvertieren?</value></data>
<data name="Admin.Convert.ConfirmReplace.one" xml:space="preserve"><value>{0} Foto in {1} wird durch seine konvertierte Fassung ersetzt; das Original kommt in den Papierkorb und lässt sich wiederherstellen, bis dieser geleert wird.</value></data>
<data name="Admin.Convert.ConfirmReplace.other" xml:space="preserve"><value>{0} Fotos in {1} werden durch ihre konvertierten Fassungen ersetzt; die Originale kommen in den Papierkorb und lassen sich wiederherstellen, bis dieser geleert wird.</value></data>
<data name="Admin.Convert.ConfirmReplaceTitle" xml:space="preserve"><value>Originale durch {0} ersetzen?</value></data>
<data name="Admin.Convert.Format" xml:space="preserve"><value>Format</value></data>
<data name="Admin.Convert.Format.Jpeg.Tip" xml:space="preserve"><value>8-Bit-JPEG mit voller Farbauflösung in der daneben eingestellten Qualität: die kleinsten Dateien, die jedes Programm öffnet</value></data>
<data name="Admin.Convert.Format.LinearDng" xml:space="preserve"><value>Lineares DNG</value></data>
<data name="Admin.Convert.Format.LinearDng.Tip" xml:space="preserve"><value>Lineares 16-Bit-DNG, verlustfrei komprimiert: die Wahl für die Archivierung, lesbar in RAW-Editoren</value></data>
<data name="Admin.Convert.Format.Tiff16.Tip" xml:space="preserve"><value>16-Bit-sRGB-TIFF, verlustfrei komprimiert: große Dateien, die für die Bearbeitung jeden Tonwert erhalten</value></data>
<data name="Admin.Convert.Gone" xml:space="preserve"><value>Eine ausgewählte Sequenz ist nicht mehr im Archiv; schließen Sie das Fenster und wählen Sie erneut aus.</value></data>
<data name="Admin.Convert.Mode" xml:space="preserve"><value>Modus</value></data>
<data name="Admin.Convert.Mode.NewSequence" xml:space="preserve"><value>Neue Sequenz</value></data>
<data name="Admin.Convert.Mode.NewSequence.Tip" xml:space="preserve"><value>Die konvertierten Kopien kommen jeweils in eine neue Sequenz neben der ursprünglichen; die Originale und ihre Sequenz bleiben genau so, wie sie sind</value></data>
<data name="Admin.Convert.Mode.Replace" xml:space="preserve"><value>Ersetzen</value></data>
<data name="Admin.Convert.Mode.Replace.Tip" xml:space="preserve"><value>Die konvertierten Dateien werden zu den Fotos der Sequenz; die Originale kommen in den Papierkorb des Archivs und lassen sich wiederherstellen, bis dieser geleert wird</value></data>
<data name="Admin.Convert.NoAnswer" xml:space="preserve"><value>Der Server hat nicht geantwortet: Prüfen Sie auf der Seite „Aufträge“, ob die Konvertierung eingereiht wurde, bevor Sie erneut konvertieren.</value></data>
<data name="Admin.Convert.NoSpace.Tip" xml:space="preserve"><value>Geben Sie zuerst Speicherplatz auf dem Volume des Archivs frei</value></data>
<data name="Admin.Convert.NotCopiedCount.one" xml:space="preserve"><value>{0} nicht kopiert</value></data>
<data name="Admin.Convert.NotCopiedCount.other" xml:space="preserve"><value>{0} nicht kopiert</value></data>
<data name="Admin.Convert.Nothing.Tip" xml:space="preserve"><value>In der Vorschau wird nichts konvertiert</value></data>
<data name="Admin.Convert.NothingToConvert" xml:space="preserve"><value>Nichts zu konvertieren: Jedes Foto bleibt unverändert, aus den angezeigten Gründen.</value></data>
<data name="Admin.Convert.OpenJob" xml:space="preserve"><value>Auftrag öffnen</value></data>
<data name="Admin.Convert.OpenJob.Tip" xml:space="preserve"><value>Den Auftrag und sein Protokoll auf der Seite „Aufträge“ anzeigen</value></data>
<data name="Admin.Convert.PlanChanged" xml:space="preserve"><value>Das Archiv hat sich seit der Vorschau geändert; prüfen Sie die neue Vorschau und wenden Sie sie erneut an.</value></data>
<data name="Admin.Convert.Planning" xml:space="preserve"><value>Wird geplant…</value></data>
<data name="Admin.Convert.Planning.Tip" xml:space="preserve"><value>Der Server liest jeden Fotoordner der Auswahl: Bei einem großen Archiv dauert das einige Minuten, und die Vorschau erscheint, sobald er fertig ist</value></data>
<data name="Admin.Convert.PlanningFor" xml:space="preserve"><value>Wird geplant… {0}</value></data>
<data name="Admin.Convert.Preview" xml:space="preserve"><value>Vorschau</value></data>
<data name="Admin.Convert.Preview.Tip" xml:space="preserve"><value>Was jede Sequenz konvertiert und unverändert lässt, mit der Größe vorher und nachher (geschätzt); noch hat sich nichts geändert</value></data>
<data name="Admin.Convert.Quality" xml:space="preserve"><value>Qualität</value></data>
<data name="Admin.Convert.Quality.Tip" xml:space="preserve"><value>JPEG-Qualität von 1 bis 100; 95 erhält feine Details, niedrigere Werte ergeben kleinere Dateien</value></data>
<data name="Admin.Convert.QualityRange" xml:space="preserve"><value>Geben Sie eine ganze Zahl von 1 bis 100 ein.</value></data>
<data name="Admin.Convert.Queued" xml:space="preserve"><value>Konvertierung eingereiht.</value></data>
<data name="Admin.Convert.ReplaceWord" xml:space="preserve"><value>ersetzen</value></data>
<data name="Admin.Convert.Size.Tip" xml:space="preserve"><value>Aktuelle Größe der zu konvertierenden Fotos, dann die geschätzte Größe danach</value></data>
<data name="Admin.Convert.SkippedPhotos" xml:space="preserve"><value>{0}: {1}</value></data>
<data name="Admin.Convert.Title.one" xml:space="preserve"><value>{0} Sequenz konvertieren</value></data>
<data name="Admin.Convert.Title.other" xml:space="preserve"><value>{0} Sequenzen konvertieren</value></data>
<data name="Admin.Convert.TitleAll" xml:space="preserve"><value>Alle Sequenzen konvertieren</value></data>
<data name="Admin.Convert.TooMany" xml:space="preserve"><value>„Konvertieren“ verarbeitet höchstens {0} Sequenzen auf einmal oder alle Sequenzen: Setzen Sie die Filter zurück und wählen Sie alle aus.</value></data>
<data name="Admin.Convert.Totals" xml:space="preserve"><value>Konvertierte Sequenzen: {0} · Fotos: {1} · unverändert: {2} · Größe: {3} → {4}</value></data>
<data name="Admin.Convert.TotalsNew" xml:space="preserve"><value>Konvertierte Sequenzen: {0} · Fotos: {1} · nicht kopiert: {2} · Größe: {3} → {4}</value></data>
<data name="Admin.Dashboard.Activity" xml:space="preserve"><value>Letzte Aktivität</value></data>
<data name="Admin.Dashboard.AllLogs" xml:space="preserve"><value>Alle Protokolle</value></data>
<data name="Admin.Dashboard.AllLogs.Tip" xml:space="preserve"><value>Audit-Protokoll öffnen</value></data>
@@ -133,6 +196,7 @@
<data name="Admin.Job.Kind.Adopt" xml:space="preserve"><value>Einbindung</value></data>
<data name="Admin.Job.Kind.Backup" xml:space="preserve"><value>Sicherung</value></data>
<data name="Admin.Job.Kind.Cleanup" xml:space="preserve"><value>Bereinigung</value></data>
<data name="Admin.Job.Kind.Convert" xml:space="preserve"><value>Konvertierung</value></data>
<data name="Admin.Job.Kind.DeepAnalyse" xml:space="preserve"><value>Tiefenanalyse</value></data>
<data name="Admin.Job.Kind.Duplicates" xml:space="preserve"><value>Duplikate</value></data>
<data name="Admin.Job.Kind.EmptyTrash" xml:space="preserve"><value>Papierkorb leeren</value></data>
@@ -344,6 +408,7 @@
<data name="Admin.Login.SignIn.Tip" xml:space="preserve"><value>Anmelden, um diesen Server zu verwalten</value></data>
<data name="Admin.Login.User" xml:space="preserve"><value>Benutzer</value></data>
<data name="Admin.Login.User.Tip" xml:space="preserve"><value>Ihr Benutzername auf diesem Server</value></data>
<data name="Admin.Logs.Action.ArchiveConverted" xml:space="preserve"><value>Fotos konvertiert</value></data>
<data name="Admin.Logs.Action.ArchiveReorganized" xml:space="preserve"><value>Archiv neu geordnet</value></data>
<data name="Admin.Logs.Action.ArchiveSettings" xml:space="preserve"><value>Archivstruktur</value></data>
<data name="Admin.Logs.Action.FramesDeleted" xml:space="preserve"><value>Fotos gelöscht</value></data>
@@ -793,6 +858,7 @@
<data name="Admin.Theme.Tip" xml:space="preserve"><value>Zwischen hellem und dunklem Design wechseln</value></data>
<data name="Admin.Trash.Back" xml:space="preserve"><value>Bibliothek</value></data>
<data name="Admin.Trash.Back.Tip" xml:space="preserve"><value>Zurück zur Bibliothek</value></data>
<data name="Admin.Trash.ConversionDeleted" xml:space="preserve"><value>konvertierte Fassung gelöscht</value></data>
<data name="Admin.Trash.DeletedAt" xml:space="preserve"><value>Gelöscht</value></data>
<data name="Admin.Trash.DeletedBy" xml:space="preserve"><value>Gelöscht von</value></data>
<data name="Admin.Trash.Emptied" xml:space="preserve"><value>Papierkorb geleert.</value></data>
@@ -819,9 +885,12 @@
<data name="Admin.Trash.Photos" xml:space="preserve"><value>Fotos</value></data>
<data name="Admin.Trash.Restore" xml:space="preserve"><value>Wiederherstellen</value></data>
<data name="Admin.Trash.RestorePhotos.Tip" xml:space="preserve"><value>Die Fotos in ihre Sequenz zurücklegen (in eine neue, wenn es sie nicht mehr gibt); jedes wird zuerst mit seiner SHA-256-Prüfsumme verglichen</value></data>
<data name="Admin.Trash.RestoreReplaced.Tip" xml:space="preserve"><value>Die Originale wieder an die Stelle ihrer konvertierten Fassungen setzen, solange diese unverändert sind (die konvertierten Fassungen kommen in den Papierkorb), sonst in eine neue Sequenz; jedes wird zuerst mit seiner SHA-256-Prüfsumme verglichen</value></data>
<data name="Admin.Trash.RestoreSequence.Tip" xml:space="preserve"><value>Den Ordner der Sequenz unverändert in die Bibliothek zurückverschieben (neben seinen alten Platz, wenn dieser belegt ist); seine Fotos werden nicht per Prüfsumme geprüft: Das übernimmt „Prüfen“</value></data>
<data name="Admin.Trash.RestoredNew.one" xml:space="preserve"><value>{0} Foto in einer neuen Sequenz wiederhergestellt.</value></data>
<data name="Admin.Trash.RestoredNew.other" xml:space="preserve"><value>{0} Fotos in einer neuen Sequenz wiederhergestellt.</value></data>
<data name="Admin.Trash.RestoredOriginals.one" xml:space="preserve"><value>{0} Original ist wieder in {1}; seine konvertierte Fassung liegt im Papierkorb.</value></data>
<data name="Admin.Trash.RestoredOriginals.other" xml:space="preserve"><value>{0} Originale sind wieder in {1}; ihre konvertierten Fassungen liegen im Papierkorb.</value></data>
<data name="Admin.Trash.RestoredPhotos.one" xml:space="preserve"><value>{0} Foto ist wieder in {1}.</value></data>
<data name="Admin.Trash.RestoredPhotos.other" xml:space="preserve"><value>{0} Fotos sind wieder in {1}.</value></data>
<data name="Admin.Trash.RestoredSequence" xml:space="preserve"><value>{0} ist wieder in der Bibliothek.</value></data>
+108 -3
View File
@@ -15,8 +15,10 @@
<data name="Archive.Blocked.Applying" xml:space="preserve"><value>Warten Sie, bis die Änderungen übernommen sind.</value></data>
<data name="Archive.Blocked.EmptySet" xml:space="preserve"><value>Die gefilterte Auswahl ist leer: Ändern Sie die Auswahl im Baum oder den Filter.</value></data>
<data name="Archive.Blocked.NoChanges" xml:space="preserve"><value>Es würde sich nichts ändern.</value></data>
<data name="Archive.Blocked.NoMode" xml:space="preserve"><value>Wählen Sie „Ersetzen“ oder „Neue Sequenz“.</value></data>
<data name="Archive.Blocked.NoTemplate" xml:space="preserve"><value>Aktivieren Sie mindestens eine Vorlage.</value></data>
<data name="Archive.Blocked.NotOnline" xml:space="preserve"><value>Das Archiv muss online und beschreibbar sein.</value></data>
<data name="Archive.Blocked.NothingToConvert" xml:space="preserve"><value>Nichts zu konvertieren: Alle Fotos werden übersprungen oder alle Sequenzen sind blockiert.</value></data>
<data name="Archive.Blocked.Planning" xml:space="preserve"><value>Warten Sie auf den Probelauf.</value></data>
<data name="Archive.Blocked.Reading" xml:space="preserve"><value>Warten Sie, bis das Archiv gelesen ist.</value></data>
<data name="Archive.Blocked.Searching" xml:space="preserve"><value>Eine Suche läuft; brechen Sie sie ab oder warten Sie.</value></data>
@@ -32,6 +34,82 @@
<data name="Archive.Confirm.Remove" xml:space="preserve"><value>Eintrag entfernen</value></data>
<data name="Archive.Confirm.RemoveHeading" xml:space="preserve"><value>{0} aus dem Index entfernen?</value></data>
<data name="Archive.Confirm.RemoveMessage" xml:space="preserve"><value>Die Sidecar-Datei fehlt. Nur der Indexeintrag wird entfernt; keine Datei wird gelöscht.</value></data>
<data name="Archive.Convert.AlreadyQueued" xml:space="preserve"><value>Eine Konvertierung dieser Sequenzen wartet bereits oder läuft; verfolgen Sie sie unter „Aufträge“.</value></data>
<data name="Archive.Convert.Blocked.Busy" xml:space="preserve"><value>Ein Auftrag bearbeitet diese Sequenz; konvertieren Sie sie, sobald der Auftrag fertig ist.</value></data>
<data name="Archive.Convert.Blocked.FramesChanged" xml:space="preserve"><value>Die Sequenz hat sich nach dem Plan geändert; prüfen Sie den Plan erneut.</value></data>
<data name="Archive.Convert.Blocked.Offline" xml:space="preserve"><value>Das Archiv ist offline oder schreibgeschützt.</value></data>
<data name="Archive.Convert.Blocked.Unreadable" xml:space="preserve"><value>Die Sequenzdatei kann nicht gelesen werden.</value></data>
<data name="Archive.Convert.Confirm" xml:space="preserve"><value>Konvertieren</value></data>
<data name="Archive.Convert.CopyUnfinished" xml:space="preserve"><value>Eine andere Konvertierung hat eine Kopie davon in diesem Format erstellt und ist noch nicht abgeschlossen; schließen Sie zuerst diese ab oder wiederholen Sie sie.</value></data>
<data name="Archive.Convert.Done.one" xml:space="preserve"><value>{0:N0} Sequenz konvertiert</value></data>
<data name="Archive.Convert.Done.other" xml:space="preserve"><value>{0:N0} Sequenzen konvertiert</value></data>
<data name="Archive.Convert.Failed.Changed" xml:space="preserve"><value>Das Foto stimmt nicht mehr mit der archivierten Kopie überein; prüfen Sie die Sequenz.</value></data>
<data name="Archive.Convert.Failed.ColorProfile" xml:space="preserve"><value>Sein Farbprofil lässt sich in diesem Format weder beibehalten noch konvertieren.</value></data>
<data name="Archive.Convert.Failed.Damaged" xml:space="preserve"><value>Seine Pixel enthalten Werte, die keine Zahlen sind: Die Datei ist beschädigt.</value></data>
<data name="Archive.Convert.Failed.EightBit" xml:space="preserve"><value>Dieser Computer entwickelt dieses RAW nur mit 8 Bit, zu wenig für eine 16-Bit-Datei; in JPEG lässt es sich konvertieren.</value></data>
<data name="Archive.Convert.Failed.Full" xml:space="preserve"><value>Der Datenträger des Archivs ist voll.</value></data>
<data name="Archive.Convert.Failed.NoDecoder" xml:space="preserve"><value>Kein Decoder auf diesem Computer liest es in voller Auflösung.</value></data>
<data name="Archive.Convert.Failed.NotVerified" xml:space="preserve"><value>Die konvertierte Datei ließ sich nicht so zurücklesen, wie sie geschrieben wurde.</value></data>
<data name="Archive.Convert.Failed.Other" xml:space="preserve"><value>Die konvertierte Datei konnte nicht erstellt werden.</value></data>
<data name="Archive.Convert.Failed.PreviewOnly" xml:space="preserve"><value>Dieser Computer liest es nur aus seiner eingebetteten Vorschau: Konvertieren Sie es auf einem PC, der es in voller Auflösung liest.</value></data>
<data name="Archive.Convert.Failed.TooLarge" xml:space="preserve"><value>Es ist größer, als dieses Format fassen, Chronos zurücklesen oder der Speicher für ein Foto aufnehmen kann.</value></data>
<data name="Archive.Convert.Failed.Unreadable" xml:space="preserve"><value>Das Foto konnte nicht dekodiert werden.</value></data>
<data name="Archive.Convert.Format" xml:space="preserve"><value>Format</value></data>
<data name="Archive.Convert.Heading.one" xml:space="preserve"><value>{0:N0} Sequenz konvertieren</value></data>
<data name="Archive.Convert.Heading.other" xml:space="preserve"><value>{0:N0} Sequenzen konvertieren</value></data>
<data name="Archive.Convert.HeadingAll" xml:space="preserve"><value>{0} konvertieren</value></data>
<data name="Archive.Convert.Mode" xml:space="preserve"><value>Modus</value></data>
<data name="Archive.Convert.NewHeading.one" xml:space="preserve"><value>{0:N0} Sequenz in eine neue konvertieren?</value></data>
<data name="Archive.Convert.NewHeading.other" xml:space="preserve"><value>{0:N0} Sequenzen in neue konvertieren?</value></data>
<data name="Archive.Convert.NewLeftOut.one" xml:space="preserve"><value>{0:N0} Foto wird nicht kopiert: Es bleibt nur in seiner Quellsequenz, aus dem Grund, den der Plan nennt.</value></data>
<data name="Archive.Convert.NewLeftOut.other" xml:space="preserve"><value>{0:N0} Fotos werden nicht kopiert: Sie bleiben nur in ihrer Quellsequenz, aus den Gründen, die der Plan nennt.</value></data>
<data name="Archive.Convert.NewMessage" xml:space="preserve"><value>{0} ({1}) werden in {2} konvertiert, jeweils in eine neue Sequenz neben der Quellsequenz; die Originale bleiben unverändert.</value></data>
<data name="Archive.Convert.NewSequence" xml:space="preserve"><value>Neue Sequenz</value></data>
<data name="Archive.Convert.NotCopied.ColorProfile" xml:space="preserve"><value>Fotos, deren Farbprofil dieses Format weder beibehalten noch konvertieren kann, werden nicht in die neue Sequenz kopiert.</value></data>
<data name="Archive.Convert.NotCopied.EightBit" xml:space="preserve"><value>RAW-Fotos, die dieser Computer nur mit 8 Bit entwickelt, werden nicht in die neue Sequenz kopiert; in JPEG lassen sie sich konvertieren.</value></data>
<data name="Archive.Convert.NotCopied.Inaccessible" xml:space="preserve"><value>Fotos, die ein anderes Programm offen hält oder die sich nicht öffnen lassen, werden nicht in die neue Sequenz kopiert; planen Sie erneut, sobald sie frei sind.</value></data>
<data name="Archive.Convert.NotCopied.Missing" xml:space="preserve"><value>Fehlende Fotos werden nicht in die neue Sequenz kopiert.</value></data>
<data name="Archive.Convert.NotCopied.NoNativeDecoder" xml:space="preserve"><value>Fotos in einem Format, das dieser Computer nicht in voller Auflösung lesen kann, werden nicht in die neue Sequenz kopiert.</value></data>
<data name="Archive.Convert.NotCopied.PreviewOnly" xml:space="preserve"><value>Fotos, die hier nur aus ihrer eingebetteten Vorschau gelesen werden, werden nicht in die neue Sequenz kopiert.</value></data>
<data name="Archive.Convert.NotCopied.SameFormat" xml:space="preserve"><value>Fotos, die bereits in diesem Format vorliegen, werden nicht in die neue Sequenz kopiert.</value></data>
<data name="Archive.Convert.NotCopied.TooLarge" xml:space="preserve"><value>Fotos, die größer sind, als dieses Format fassen oder Chronos zurücklesen kann, werden nicht in die neue Sequenz kopiert.</value></data>
<data name="Archive.Convert.NotCopied.Undecodable" xml:space="preserve"><value>Unlesbare Fotos werden nicht in die neue Sequenz kopiert.</value></data>
<data name="Archive.Convert.NotCopied.Unhashed" xml:space="preserve"><value>Nie geprüfte Fotos werden nicht in die neue Sequenz kopiert; prüfen Sie zuerst die Sequenz.</value></data>
<data name="Archive.Convert.NotCopiedPhotos.one" xml:space="preserve"><value>{0:N0} nicht kopiert</value></data>
<data name="Archive.Convert.NotCopiedPhotos.other" xml:space="preserve"><value>{0:N0} nicht kopiert</value></data>
<data name="Archive.Convert.NotPlaced" xml:space="preserve"><value>Die konvertierten Fotos konnten nicht an die Stelle der Originale treten. {0}</value></data>
<data name="Archive.Convert.PhotoFailed" xml:space="preserve"><value>{0} konnte nicht konvertiert werden. {1}</value></data>
<data name="Archive.Convert.PhotoHeld" xml:space="preserve"><value>Ein Foto der Sequenz wird von einem anderen Programm offen gehalten oder lässt sich nicht öffnen; wiederholen Sie den Auftrag, sobald es frei ist.</value></data>
<data name="Archive.Convert.Quality" xml:space="preserve"><value>Qualität</value></data>
<data name="Archive.Convert.Replace" xml:space="preserve"><value>Ersetzen</value></data>
<data name="Archive.Convert.ReplaceHeading.one" xml:space="preserve"><value>Die Fotos von {0:N0} Sequenz ersetzen?</value></data>
<data name="Archive.Convert.ReplaceHeading.other" xml:space="preserve"><value>Die Fotos von {0:N0} Sequenzen ersetzen?</value></data>
<data name="Archive.Convert.ReplaceMessage" xml:space="preserve"><value>{0} ({1}) werden durch ihre in {2} konvertierten Fassungen ersetzt; die Originale werden in den Papierkorb des Archivs verschoben und lassen sich wiederherstellen, bis dieser geleert wird.</value></data>
<data name="Archive.Convert.Sizes" xml:space="preserve"><value>{0} → {1}</value></data>
<data name="Archive.Convert.Skipped.ColorProfile" xml:space="preserve"><value>Fotos, deren Farbprofil dieses Format weder beibehalten noch konvertieren kann, bleiben unverändert.</value></data>
<data name="Archive.Convert.Skipped.EightBit" xml:space="preserve"><value>RAW-Fotos, die dieser Computer nur mit 8 Bit entwickelt, bleiben unverändert; in JPEG lassen sie sich konvertieren.</value></data>
<data name="Archive.Convert.Skipped.Inaccessible" xml:space="preserve"><value>Fotos, die ein anderes Programm offen hält oder die sich nicht öffnen lassen, bleiben unverändert; planen Sie erneut, sobald sie frei sind.</value></data>
<data name="Archive.Convert.Skipped.Missing" xml:space="preserve"><value>Fehlende Fotos bleiben unverändert.</value></data>
<data name="Archive.Convert.Skipped.NoNativeDecoder" xml:space="preserve"><value>Fotos in einem Format, das dieser Computer nicht in voller Auflösung lesen kann, bleiben unverändert.</value></data>
<data name="Archive.Convert.Skipped.PreviewOnly" xml:space="preserve"><value>Fotos, die hier nur aus ihrer eingebetteten Vorschau gelesen werden, bleiben unverändert.</value></data>
<data name="Archive.Convert.Skipped.SameFormat" xml:space="preserve"><value>Fotos, die bereits in diesem Format vorliegen, bleiben unverändert.</value></data>
<data name="Archive.Convert.Skipped.TooLarge" xml:space="preserve"><value>Fotos, die größer sind, als dieses Format fassen oder Chronos zurücklesen kann, bleiben unverändert.</value></data>
<data name="Archive.Convert.Skipped.Undecodable" xml:space="preserve"><value>Unlesbare Fotos bleiben unverändert.</value></data>
<data name="Archive.Convert.Skipped.Unhashed" xml:space="preserve"><value>Nie geprüfte Fotos bleiben unverändert; prüfen Sie zuerst die Sequenz.</value></data>
<data name="Archive.Convert.SkippedPhotos.one" xml:space="preserve"><value>{0:N0} übersprungen</value></data>
<data name="Archive.Convert.SkippedPhotos.other" xml:space="preserve"><value>{0:N0} übersprungen</value></data>
<data name="Archive.Convert.Space" xml:space="preserve"><value>Benötigt {0}, frei {1}</value></data>
<data name="Archive.Convert.SpaceShort" xml:space="preserve"><value>Benötigt {0}, nur {1} frei: Geben Sie zuerst Speicherplatz frei.</value></data>
<data name="Archive.Convert.SpaceUnknown" xml:space="preserve"><value>Benötigt {0}; der freie Speicherplatz lässt sich nicht ermitteln.</value></data>
<data name="Archive.Convert.Target.LinearDng" xml:space="preserve"><value>Lineares DNG</value></data>
<data name="Archive.Convert.Target.Tiff16" xml:space="preserve"><value>TIFF 16 Bit</value></data>
<data name="Archive.Convert.UndoFailed" xml:space="preserve"><value>Die Originale konnten nicht wiederhergestellt werden</value></data>
<data name="Archive.Convert.UndoNothing" xml:space="preserve"><value>Die ersetzten Originale sind nicht mehr im Papierkorb.</value></data>
<data name="Archive.Convert.Undone.one" xml:space="preserve"><value>Originale in {0:N0} Sequenz wiederhergestellt</value></data>
<data name="Archive.Convert.Undone.other" xml:space="preserve"><value>Originale in {0:N0} Sequenzen wiederhergestellt</value></data>
<data name="Archive.Convert.UndoneNew.one" xml:space="preserve"><value>{0:N0} Sequenz hatte sich inzwischen geändert: Ihre Originale sind als neue Sequenz zurückgekehrt.</value></data>
<data name="Archive.Convert.UndoneNew.other" xml:space="preserve"><value>{0:N0} Sequenzen hatten sich inzwischen geändert: Ihre Originale sind als neue Sequenzen zurückgekehrt.</value></data>
<data name="Archive.Convert.Unstaged" xml:space="preserve"><value>Die Konvertierung von {0} ist nicht mehr unter den bereitgestellten Dateien; beim Wiederholen wird die Datei erneut konvertiert.</value></data>
<data name="Archive.Copy.Title" xml:space="preserve"><value>Ordner zum Kopieren ins Archiv</value></data>
<data name="Archive.Delete.Action" xml:space="preserve"><value>In den Papierkorb verschieben</value></data>
<data name="Archive.Delete.Blocked" xml:space="preserve"><value>Nicht verschoben: {0} · {1}</value></data>
@@ -75,6 +153,9 @@
<data name="Archive.Duplicates.Title" xml:space="preserve"><value>Duplikate</value></data>
<data name="Archive.Empty" xml:space="preserve"><value>Noch kein Archiv</value></data>
<data name="Archive.Error.Busy" xml:space="preserve"><value>Eine andere Chronos-Instanz ({0}) schreibt gerade hier. Versuchen Sie es gleich noch einmal.</value></data>
<data name="Archive.Error.ConvertKept.one" xml:space="preserve"><value>{0:N0} Sequenz wurde nicht wie geplant konvertiert; das Protokoll des Auftrags nennt den Grund.</value></data>
<data name="Archive.Error.ConvertKept.other" xml:space="preserve"><value>{0:N0} Sequenzen wurden nicht wie geplant konvertiert; das Protokoll des Auftrags nennt den Grund.</value></data>
<data name="Archive.Error.ConvertSpace" xml:space="preserve"><value>Die Konvertierung benötigt {0} freien Speicherplatz auf dem Volume des Archivs; frei sind {1}.</value></data>
<data name="Archive.Error.CopyMismatch" xml:space="preserve"><value>Die Kopie von {0} stimmt nicht mit dem Original überein.</value></data>
<data name="Archive.Error.DuplicateLost" xml:space="preserve"><value>{0} konnte der Sequenz nicht hinzugefügt werden.</value></data>
<data name="Archive.Error.InLibrary" xml:space="preserve"><value>{0} ist bereits in der Bibliothek.</value></data>
@@ -92,8 +173,8 @@
<data name="Archive.Error.SourceGone" xml:space="preserve"><value>Die Karte oder der Ordner {0} ist nicht mehr verfügbar.</value></data>
<data name="Archive.Error.StalePlan" xml:space="preserve"><value>Das Archiv hat sich geändert, nachdem dieser Plan erstellt wurde.</value></data>
<data name="Archive.Error.TrashChanged" xml:space="preserve"><value>Der Papierkorb hat sich nach der Prüfung geändert; es wurde nichts gelöscht.</value></data>
<data name="Archive.Error.TrashKept.one" xml:space="preserve"><value>{0:N0} Papierkorbeintrag wurde behalten: Er hat sich geändert, oder eine Ersatzdatei stimmt nicht mehr überein.</value></data>
<data name="Archive.Error.TrashKept.other" xml:space="preserve"><value>{0:N0} Papierkorbeinträge wurden behalten: Sie haben sich geändert, oder eine Ersatzdatei stimmt nicht mehr überein.</value></data>
<data name="Archive.Error.TrashKept.one" xml:space="preserve"><value>{0:N0} Papierkorbeintrag wurde behalten; das Protokoll des Auftrags nennt den Grund.</value></data>
<data name="Archive.Error.TrashKept.other" xml:space="preserve"><value>{0:N0} Papierkorbeinträge wurden behalten; das Protokoll des Auftrags nennt den Grund.</value></data>
<data name="Archive.Error.TrashMismatch" xml:space="preserve"><value>Keine Datei dieses Papierkorbeintrags stimmt mehr mit den gespeicherten Angaben überein; der Eintrag bleibt im Papierkorb.</value></data>
<data name="Archive.Failed.Access" xml:space="preserve"><value>Chronos wurde der Zugriff auf das Archiv verweigert.</value></data>
<data name="Archive.Failed.Files" xml:space="preserve"><value>Eine Datei des Archivs konnte nicht gelesen oder geschrieben werden.</value></data>
@@ -132,6 +213,15 @@
<data name="Archive.Log.AuditKept" xml:space="preserve"><value>Audit-Protokoll vollständig behalten</value></data>
<data name="Archive.Log.AuditPurged" xml:space="preserve"><value>Audit-Einträge entfernt: {0}</value></data>
<data name="Archive.Log.BackupDone" xml:space="preserve"><value>Index nach {0} kopiert ({1}); aufbewahrte Kopien: {2}</value></data>
<data name="Archive.Log.ConvertBlocked" xml:space="preserve"><value>Unverändert gelassen, in Bearbeitung oder unlesbar: {0}</value></data>
<data name="Archive.Log.ConvertChanged" xml:space="preserve"><value>Unverändert gelassen, nach dem Plan geändert: {0}. Eine Wiederholung lässt sie unverändert: Konvertieren Sie sie erneut mit einem neuen Plan.</value></data>
<data name="Archive.Log.ConvertDone" xml:space="preserve"><value>Konvertierte Sequenzen: {0}, neue Sequenzen: {1}, Fotos: {2}</value></data>
<data name="Archive.Log.ConvertFailed" xml:space="preserve"><value>Unverändert gelassen: {0}. {1}</value></data>
<data name="Archive.Log.ConvertLeftOut" xml:space="preserve"><value>{0}: nicht konvertierte Fotos, nur in der Quellsequenz verblieben: {1}</value></data>
<data name="Archive.Log.ConvertNothing" xml:space="preserve"><value>Nichts zu konvertieren: {0}</value></data>
<data name="Archive.Log.ConvertSuperseded" xml:space="preserve"><value>{0}: Seit diese Konvertierung bestätigt wurde, hat eine andere ihre Kopie in diesem Format erstellt; eine zweite Kopie wird nicht erstellt.</value></data>
<data name="Archive.Log.Converted" xml:space="preserve"><value>{0}: durch ihre konvertierte Fassung ersetzte Fotos: {1}</value></data>
<data name="Archive.Log.ConvertedNew" xml:space="preserve"><value>{0}: in eine neue Sequenz konvertierte Fotos: {1}</value></data>
<data name="Archive.Log.DryRun" xml:space="preserve"><value>Probelauf: Es wurde nichts geändert.</value></data>
<data name="Archive.Log.DuplicateGroup" xml:space="preserve"><value>Zusätzliche Kopien von {0}: {1}</value></data>
<data name="Archive.Log.DuplicatesDone" xml:space="preserve"><value>Duplikatgruppen: {0}, zusätzliche Kopien: {1}</value></data>
@@ -166,9 +256,22 @@
<data name="Archive.Log.SequenceMissing" xml:space="preserve"><value>Sequenz nicht gefunden: {0}</value></data>
<data name="Archive.Log.StepFailed" xml:space="preserve"><value>Bereinigungsschritt {0} fehlgeschlagen: {1}</value></data>
<data name="Archive.Log.StepUnknown" xml:space="preserve"><value>Bereinigungsschritt hier unbekannt: {0}</value></data>
<data name="Archive.Log.SyncChanged" xml:space="preserve"><value>{0}: seit der Archivierung geändert, nicht hochgeladen</value></data>
<data name="Archive.Log.SyncDeletedHere" xml:space="preserve"><value>{0}: auf diesem PC gelöscht, nicht heruntergeladen</value></data>
<data name="Archive.Log.SyncDeletedThere" xml:space="preserve"><value>{0}: auf dem Server gelöscht, nicht hochgeladen</value></data>
<data name="Archive.Log.SyncFrameChanged" xml:space="preserve"><value>{0}: sein Frame hier hat sich inzwischen geändert, nicht heruntergeladen</value></data>
<data name="Archive.Log.SyncMissing" xml:space="preserve"><value>{0}: fehlt, nicht hochgeladen</value></data>
<data name="Archive.Log.SyncNoPreview.one" xml:space="preserve"><value>{0:N0} Frame hat auf dem Server weder Proxy noch Miniaturansicht</value></data>
<data name="Archive.Log.SyncNoPreview.other" xml:space="preserve"><value>{0:N0} Frames haben auf dem Server weder Proxy noch Miniaturansicht</value></data>
<data name="Archive.Log.TrashEmptied" xml:space="preserve"><value>Endgültig gelöschte Einträge: {0}, Größe: {1}</value></data>
<data name="Archive.Log.TrashEntry" xml:space="preserve"><value>Seit {0} im Papierkorb: {1} ({2})</value></data>
<data name="Archive.Log.TrashKept" xml:space="preserve"><value>Im Papierkorb behalten: {0}</value></data>
<data name="Archive.Log.TrashKept" xml:space="preserve"><value>Im Papierkorb behalten, nach dem Plan geändert: {0}</value></data>
<data name="Archive.Log.TrashKeptBusy" xml:space="preserve"><value>Im Papierkorb behalten, seine Sequenz war in Bearbeitung: {0}</value></data>
<data name="Archive.Log.TrashKeptMismatch" xml:space="preserve"><value>Im Papierkorb behalten, eine konvertierte Fassung seiner Originale stimmt nicht mehr überein: {0}</value></data>
<data name="Archive.Log.TrashKeptStaleIndex" xml:space="preserve"><value>Im Papierkorb behalten, der Index führt seine Sequenz, die das Archiv nicht mehr enthält; bauen Sie den Index neu auf: {0}</value></data>
<data name="Archive.Log.TrashKeptUnhashed" xml:space="preserve"><value>Im Papierkorb behalten, ein Foto seiner Sequenz wurde nie geprüft; prüfen Sie die Sequenz: {0}</value></data>
<data name="Archive.Log.TrashKeptUnknown" xml:space="preserve"><value>Im Papierkorb behalten, das Archiv zeigt nicht, was aus der Konvertierung seiner Originale geworden ist; stellen Sie den Eintrag wieder her, um sie zu behalten: {0}</value></data>
<data name="Archive.Log.TrashKeptUnreadable" xml:space="preserve"><value>Im Papierkorb behalten, die Sidecar-Datei eines Ordners, der seine Sequenz enthalten könnte, fehlt oder ist unlesbar; scannen Sie das Archiv: {0}</value></data>
<data name="Archive.Log.TrashOffline" xml:space="preserve"><value>Papierkorb nicht geprüft: Das Archiv ist nicht erreichbar</value></data>
<data name="Archive.Log.TrashReport" xml:space="preserve"><value>Alte Papierkorbeinträge: {0}, Größe: {1}; es wurde nichts gelöscht</value></data>
<data name="Archive.Log.VerifyDone" xml:space="preserve"><value>Geprüfte Fotos: {0}, intakt: {1}, mit neuer Prüfsumme: {2}, mit Problemen: {3}</value></data>
@@ -249,6 +352,7 @@
<data name="Archive.Set.All.other" xml:space="preserve"><value>{0:N0} Sequenzen · alle</value></data>
<data name="Archive.Set.Analyse" xml:space="preserve"><value>Analysieren</value></data>
<data name="Archive.Set.ClearFilter" xml:space="preserve"><value>Filter zurücksetzen</value></data>
<data name="Archive.Set.Convert" xml:space="preserve"><value>Konvertieren…</value></data>
<data name="Archive.Set.Delete" xml:space="preserve"><value>Löschen…</value></data>
<data name="Archive.Set.Export" xml:space="preserve"><value>CSV exportieren</value></data>
<data name="Archive.Set.Filter" xml:space="preserve"><value>Filter der Auswahl</value></data>
@@ -278,6 +382,7 @@
<data name="Archive.Toolbar.Scan" xml:space="preserve"><value>Scannen</value></data>
<data name="Archive.Toolbar.Verify" xml:space="preserve"><value>Prüfen</value></data>
<data name="Archive.Trash.Checking" xml:space="preserve"><value>Papierkorb wird geprüft…</value></data>
<data name="Archive.Trash.ConversionDeleted" xml:space="preserve"><value>konvertierte Fassung gelöscht</value></data>
<data name="Archive.Trash.Deleted" xml:space="preserve"><value>Gelöscht am {0}</value></data>
<data name="Archive.Trash.Empty" xml:space="preserve"><value>Der Papierkorb ist leer</value></data>
<data name="Archive.Trash.EmptyAction" xml:space="preserve"><value>Leeren…</value></data>
+1
View File
@@ -69,6 +69,7 @@
<data name="Jobs.Kind.Adopt" xml:space="preserve"><value>Ordner einbinden</value></data>
<data name="Jobs.Kind.Backup" xml:space="preserve"><value>Indexsicherung</value></data>
<data name="Jobs.Kind.Cleanup" xml:space="preserve"><value>Bereinigung</value></data>
<data name="Jobs.Kind.Convert" xml:space="preserve"><value>Konvertierung</value></data>
<data name="Jobs.Kind.DeepAnalyse" xml:space="preserve"><value>Tiefenanalyse</value></data>
<data name="Jobs.Kind.Download" xml:space="preserve"><value>Download</value></data>
<data name="Jobs.Kind.Duplicates" xml:space="preserve"><value>Duplikate</value></data>
+2
View File
@@ -6,6 +6,7 @@
<resheader name="writer"><value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader>
<data name="Library.Action.Analyse" xml:space="preserve"><value>Analysieren</value></data>
<data name="Library.Action.ClearSelection" xml:space="preserve"><value>Auswahl aufheben</value></data>
<data name="Library.Action.Convert" xml:space="preserve"><value>Konvertieren…</value></data>
<data name="Library.Action.Delete" xml:space="preserve"><value>Löschen…</value></data>
<data name="Library.Action.Download" xml:space="preserve"><value>Herunterladen</value></data>
<data name="Library.Action.ExportList" xml:space="preserve"><value>Liste exportieren</value></data>
@@ -32,6 +33,7 @@
<data name="Library.Blocked.NothingToDownload" xml:space="preserve"><value>Für die ausgewählten Sequenzen gibt es nichts vom Server abzurufen.</value></data>
<data name="Library.Blocked.NothingToUpload" xml:space="preserve"><value>Der Server hat bereits alles, was die ausgewählten Sequenzen enthalten.</value></data>
<data name="Library.Blocked.OneArchive" xml:space="preserve"><value>„Neu ordnen“ wirkt jeweils nur auf die Sequenzen eines einzigen Archivs.</value></data>
<data name="Library.Blocked.OneArchiveConvert" xml:space="preserve"><value>„Konvertieren“ wirkt jeweils nur auf die Sequenzen eines einzigen Archivs.</value></data>
<data name="Library.Blocked.ServerOnly" xml:space="preserve"><value>Nur für Sequenzen auf diesem PC; die Auswahl liegt auf dem Server.</value></data>
<data name="Library.Blocked.Transferring" xml:space="preserve"><value>Für diese Sequenz läuft bereits eine Übertragung.</value></data>
<data name="Library.ClearFilters" xml:space="preserve"><value>Filter zurücksetzen</value></data>
+4
View File
@@ -21,6 +21,8 @@
<data name="Server.Conflict.TakeServer.Message" xml:space="preserve"><value>Die Einstellungen dieses PCs für {0} werden durch die Serverkopie ersetzt.</value></data>
<data name="Server.Conflict.TakeServer.Title" xml:space="preserve"><value>Einstellungen des Servers übernehmen?</value></data>
<data name="Server.Connect" xml:space="preserve"><value>Verbinden</value></data>
<data name="Server.Convert.OnPc" xml:space="preserve"><value>Konvertieren Sie diese Fotos auf einem PC: Der Server kann sie nicht in voller Auflösung lesen.</value></data>
<data name="Server.Convert.OnPcNew" xml:space="preserve"><value>Nicht in die neue Sequenz kopiert: Der Server kann diese Fotos nicht in voller Auflösung lesen; konvertieren Sie sie auf einem PC.</value></data>
<data name="Server.Disconnect" xml:space="preserve"><value>Trennen</value></data>
<data name="Server.Empty" xml:space="preserve"><value>Nicht mit einem Server verbunden</value></data>
<data name="Server.Error.AccountLocked" xml:space="preserve"><value>Zu viele fehlgeschlagene Anmeldungen; das Konto ist vorübergehend gesperrt.</value></data>
@@ -71,7 +73,9 @@
<data name="Server.Error.MethodNotAllowed" xml:space="preserve"><value>Diese Methode ist hier nicht zulässig.</value></data>
<data name="Server.Error.NestedTarget" xml:space="preserve"><value>Ein neuer Ordner läge im Ordner einer anderen Sequenz.</value></data>
<data name="Server.Error.NotChronos" xml:space="preserve"><value>Diese Adresse ist kein Chronos Server.</value></data>
<data name="Server.Error.NotEnoughSpace" xml:space="preserve"><value>Auf dem Volume des Archivs fehlt der Speicherplatz, den die Konvertierung benötigt.</value></data>
<data name="Server.Error.NotFound" xml:space="preserve"><value>Nicht gefunden.</value></data>
<data name="Server.Error.NothingToConvert" xml:space="preserve"><value>Der Plan konvertiert nichts: Alle Fotos werden übersprungen oder alle Sequenzen sind blockiert.</value></data>
<data name="Server.Error.PasswordChangeRequired" xml:space="preserve"><value>Ändern Sie zuerst Ihr Kennwort.</value></data>
<data name="Server.Error.PhotoRemoved" xml:space="preserve"><value>Das Foto wurde während des Hochladens aus der Sequenz gelöscht und daher nicht hinzugefügt.</value></data>
<data name="Server.Error.PhotoUnreadable" xml:space="preserve"><value>{0} kann nicht gelesen werden; ohne ihre Prüfsumme würden andere Kopien nicht erfahren, dass die Datei gelöscht wurde. Schließen Sie das Programm, das sie verwendet, oder prüfen Sie ihre Berechtigungen, und versuchen Sie es dann erneut.</value></data>
+19 -1
View File
@@ -27,6 +27,21 @@
<data name="Tooltips.Archive.ClearFilter" xml:space="preserve"><value>Wieder alle Sequenzen der Auswahl anzeigen</value></data>
<data name="Tooltips.Archive.CloseDialog" xml:space="preserve"><value>Schließen, ohne etwas zu ändern · Esc</value></data>
<data name="Tooltips.Archive.Collapse" xml:space="preserve"><value>Sequenzen dieses Jahres ausblenden</value></data>
<data name="Tooltips.Archive.ConvertApplyNew" xml:space="preserve"><value>Bestätigen und dann einen Auftrag einreihen, der Kopien in neue Sequenzen konvertiert · unter „Aufträge“ anhalten und fortsetzen</value></data>
<data name="Tooltips.Archive.ConvertApplyReplace" xml:space="preserve"><value>Zur Bestätigung die Anzahl der Fotos eingeben, dann einen Auftrag einreihen, der sie durch ihre konvertierte Fassung ersetzt · unter „Aufträge“ anhalten und fortsetzen</value></data>
<data name="Tooltips.Archive.ConvertBack" xml:space="preserve"><value>Zurück zum Plan; nichts wird konvertiert</value></data>
<data name="Tooltips.Archive.ConvertDng" xml:space="preserve"><value>Lineares DNG, 16 Bit und verlustfrei · lesbar in jedem RAW-Editor; die Wahl für die Archivierung</value></data>
<data name="Tooltips.Archive.ConvertJpeg" xml:space="preserve"><value>8-Bit-JPEG in der unten eingestellten Qualität · die kleinsten Dateien; einige Details gehen verloren</value></data>
<data name="Tooltips.Archive.ConvertModeNew" xml:space="preserve"><value>Die konvertierten Kopien kommen jeweils in eine neue Sequenz neben der ursprünglichen; die Originale bleiben unverändert</value></data>
<data name="Tooltips.Archive.ConvertModeReplace" xml:space="preserve"><value>Die konvertierten Dateien treten in ihren Sequenzen an die Stelle der Fotos; die Originale kommen in den Papierkorb des Archivs und lassen sich wiederherstellen, bis dieser geleert wird</value></data>
<data name="Tooltips.Archive.ConvertNew" xml:space="preserve"><value>Den Auftrag einreihen, der die Fotos in neue Sequenzen konvertiert und jede Konvertierung prüft; die Originale bleiben unberührt</value></data>
<data name="Tooltips.Archive.ConvertPlan" xml:space="preserve"><value>Die Sequenzen, deren Fotos ersetzt werden</value></data>
<data name="Tooltips.Archive.ConvertPlanNew" xml:space="preserve"><value>Die Sequenzen, die in neue kopiert werden, und die Fotos, die jede davon auslässt</value></data>
<data name="Tooltips.Archive.ConvertQuality" xml:space="preserve"><value>JPEG-Qualität von 1 bis 100 · 95 erhält feine Details; niedrigere Werte ergeben kleinere Dateien</value></data>
<data name="Tooltips.Archive.ConvertReplace.one" xml:space="preserve"><value>{0:N0} Foto durch seine konvertierte Fassung ersetzen; geben Sie zuerst oben die Anzahl ein</value></data>
<data name="Tooltips.Archive.ConvertReplace.other" xml:space="preserve"><value>{0:N0} Fotos durch ihre konvertierten Fassungen ersetzen; geben Sie zuerst oben die Anzahl ein</value></data>
<data name="Tooltips.Archive.ConvertTiff" xml:space="preserve"><value>16-Bit-TIFF, verlustfrei komprimiert · große Dateien, die jedes Bildbearbeitungsprogramm öffnet</value></data>
<data name="Tooltips.Archive.ConvertUndo" xml:space="preserve"><value>Die Originale aus dem Papierkorb wieder an die Stelle ihrer konvertierten Fassungen setzen</value></data>
<data name="Tooltips.Archive.DeleteAction.one" xml:space="preserve"><value>{0:N0} Sequenz in den Papierkorb verschieben; geben Sie zuerst oben die Anzahl ein</value></data>
<data name="Tooltips.Archive.DeleteAction.other" xml:space="preserve"><value>{0:N0} Sequenzen in den Papierkorb verschieben; geben Sie zuerst oben die Anzahl ein</value></data>
<data name="Tooltips.Archive.DeleteKeep" xml:space="preserve"><value>Nichts ändern</value></data>
@@ -82,6 +97,7 @@
<data name="Tooltips.Archive.Scan" xml:space="preserve"><value>Inkrementeller Scan: neue, geänderte und entfernte Dateien nach Änderungszeit und Größe</value></data>
<data name="Tooltips.Archive.Set" xml:space="preserve"><value>Die ausgewählten Jahre und Sequenzen (alle, wenn nichts ausgewählt ist), eingegrenzt nach Kamera, Status oder Tag</value></data>
<data name="Tooltips.Archive.SetAnalyse" xml:space="preserve"><value>Tiefenanalyse für jede Sequenz der Auswahl ausführen</value></data>
<data name="Tooltips.Archive.SetConvert" xml:space="preserve"><value>Die Fotos der Auswahl in JPEG, TIFF oder DNG konvertieren · zuerst ein Probelauf, dann ein Auftrag</value></data>
<data name="Tooltips.Archive.SetDelete" xml:space="preserve"><value>Die Auswahl in den Papierkorb des Archivs verschieben · zeigt zuerst den Probelauf und verlangt dann eine Bestätigung per Eingabe</value></data>
<data name="Tooltips.Archive.SetExport" xml:space="preserve"><value>Auswahl als CSV exportieren: eine Zeile pro Sequenz</value></data>
<data name="Tooltips.Archive.SetProxies" xml:space="preserve"><value>Proxys erstellen oder aktualisieren</value></data>
@@ -96,7 +112,7 @@
<data name="Tooltips.Archive.TitleTemplate" xml:space="preserve"><value>Titelvorlage; der Titel-Platzhalter steht für den aktuellen Titel · wird beim Tippen geprüft</value></data>
<data name="Tooltips.Archive.Trash" xml:space="preserve"><value>Die aus diesem Archiv gelöschten Sequenzen und Fotos, jeweils wiederherstellbar</value></data>
<data name="Tooltips.Archive.TrashEmpty" xml:space="preserve"><value>Die Einträge dieses Papierkorbs endgültig löschen, nach einer Prüfung ihres Inhalts und einer Bestätigung per Eingabe</value></data>
<data name="Tooltips.Archive.TrashEmptyPlan" xml:space="preserve"><value>Was endgültig aus dem Archiv gelöscht wird</value></data>
<data name="Tooltips.Archive.TrashEmptyPlan" xml:space="preserve"><value>Was endgültig aus dem Archiv gelöscht wird; Originale, deren konvertierte Fassung gelöscht wurde, können die letzte Kopie ihrer Fotos sein</value></data>
<data name="Tooltips.Archive.TrashErase.one" xml:space="preserve"><value>{0:N0} Eintrag endgültig löschen; geben Sie zuerst oben die Anzahl ein</value></data>
<data name="Tooltips.Archive.TrashErase.other" xml:space="preserve"><value>{0:N0} Einträge endgültig löschen; geben Sie zuerst oben die Anzahl ein</value></data>
<data name="Tooltips.Archive.TrashRestore" xml:space="preserve"><value>Diesen Eintrag zurückholen: eine Sequenz in ihren Ordner und die Bibliothek, Fotos nach einer Prüfsummenprüfung in ihre Sequenz</value></data>
@@ -468,6 +484,8 @@
<data name="Tooltips.Library.List" xml:space="preserve"><value>Tabelle mit sortierbaren Spalten</value></data>
<data name="Tooltips.Library.Mass.Analyse.one" xml:space="preserve"><value>Tiefenanalyse von {0:N0} Sequenz auf diesem PC · läuft als ein Auftrag</value></data>
<data name="Tooltips.Library.Mass.Analyse.other" xml:space="preserve"><value>Tiefenanalyse von {0:N0} Sequenzen auf diesem PC · läuft als ein Auftrag</value></data>
<data name="Tooltips.Library.Mass.Convert.one" xml:space="preserve"><value>Die Fotos von {0:N0} Sequenz in JPEG, TIFF oder DNG konvertieren · zuerst ein Probelauf, dann ein Auftrag</value></data>
<data name="Tooltips.Library.Mass.Convert.other" xml:space="preserve"><value>Die Fotos von {0:N0} Sequenzen ihres Archivs in JPEG, TIFF oder DNG konvertieren · zuerst ein Probelauf, dann ein Auftrag</value></data>
<data name="Tooltips.Library.Mass.Delete.one" xml:space="preserve"><value>{0:N0} Sequenz in den Papierkorb ihres Archivs verschieben · zeigt zuerst den Probelauf und verlangt dann eine Bestätigung per Eingabe</value></data>
<data name="Tooltips.Library.Mass.Delete.other" xml:space="preserve"><value>{0:N0} Sequenzen in den Papierkorb ihres Archivs verschieben · zeigt zuerst den Probelauf und verlangt dann eine Bestätigung per Eingabe</value></data>
<data name="Tooltips.Library.Mass.Download.one" xml:space="preserve"><value>Für {0:N0} Sequenz vom Server holen, was hier fehlt (Originale oder Renderings) · läuft als Übertragungsauftrag</value></data>
+69
View File
@@ -9,6 +9,7 @@
<data name="Admin.About.Title" xml:space="preserve"><value>Chronos Server</value></data>
<data name="Admin.About.Uptime" xml:space="preserve"><value>Χρόνος λειτουργίας</value></data>
<data name="Admin.About.Version" xml:space="preserve"><value>Έκδοση</value></data>
<data name="Admin.Activity.ArchiveConverted" xml:space="preserve"><value>{0} έβαλε στην ουρά μια μετατροπή · {1}</value></data>
<data name="Admin.Activity.ArchiveReorganized" xml:space="preserve"><value>{0} αναδιοργάνωσε την αρχειοθήκη · {1}</value></data>
<data name="Admin.Activity.ArchiveSettings" xml:space="preserve"><value>{0} άλλαξε τη διάταξη της αρχειοθήκης</value></data>
<data name="Admin.Activity.FramesDeleted" xml:space="preserve"><value>{0} διέγραψε {1}</value></data>
@@ -83,6 +84,68 @@
<data name="Admin.Common.TypeToConfirm.Tip" xml:space="preserve"><value>Πληκτρολογήστε το όνομα ακριβώς όπως εμφανίζεται για επιβεβαίωση</value></data>
<data name="Admin.Common.TypeWord.Tip" xml:space="preserve"><value>Πληκτρολογήστε τη λέξη ακριβώς όπως εμφανίζεται. Τα κεφαλαία και τα πεζά δεν έχουν σημασία</value></data>
<data name="Admin.Common.TypeWordFirst.Tip" xml:space="preserve"><value>Πληκτρολογήστε πρώτα την παραπάνω λέξη</value></data>
<data name="Admin.Convert.Action" xml:space="preserve"><value>Μετατροπή…</value></data>
<data name="Admin.Convert.Action.Tip" xml:space="preserve"><value>Μετατροπή των φωτογραφιών των επιλεγμένων ακολουθιών σε JPEG, TIFF-16 ή γραμμικό DNG. Μια προεπισκόπηση δείχνει πρώτα κάθε ακολουθία</value></data>
<data name="Admin.Convert.Apply" xml:space="preserve"><value>Μετατροπή…</value></data>
<data name="Admin.Convert.Apply.Tip" xml:space="preserve"><value>Μετατροπή όπως δείχνει η προεπισκόπηση. Πρώτα ζητείται επιβεβαίωση</value></data>
<data name="Admin.Convert.Cancel.Tip" xml:space="preserve"><value>Κλείσιμο χωρίς καμία μετατροπή</value></data>
<data name="Admin.Convert.ChooseMode" xml:space="preserve"><value>Επιλέξτε «Αντικατάσταση» ή «Νέα ακολουθία» για να γίνει η μετατροπή.</value></data>
<data name="Admin.Convert.ChooseMode.Tip" xml:space="preserve"><value>Επιλέξτε πρώτα «Αντικατάσταση» ή «Νέα ακολουθία»</value></data>
<data name="Admin.Convert.Column.Converted" xml:space="preserve"><value>Μετατρέπονται</value></data>
<data name="Admin.Convert.Column.NotCopied" xml:space="preserve"><value>Δεν αντιγράφονται</value></data>
<data name="Admin.Convert.Column.Sequence" xml:space="preserve"><value>Ακολουθία</value></data>
<data name="Admin.Convert.Column.Size" xml:space="preserve"><value>Μέγεθος</value></data>
<data name="Admin.Convert.Column.Unchanged" xml:space="preserve"><value>Χωρίς αλλαγή</value></data>
<data name="Admin.Convert.Confirm.New" xml:space="preserve"><value>Μετατροπή</value></data>
<data name="Admin.Convert.Confirm.New.Tip" xml:space="preserve"><value>Τοποθέτηση στην ουρά της εργασίας που μετατρέπει τις φωτογραφίες σε νέες ακολουθίες και επαληθεύει κάθε μετατροπή. Τα πρωτότυπα δεν αγγίζονται</value></data>
<data name="Admin.Convert.Confirm.Replace" xml:space="preserve"><value>Αντικατάσταση</value></data>
<data name="Admin.Convert.Confirm.Replace.Tip" xml:space="preserve"><value>Τοποθέτηση στην ουρά της εργασίας που μετατρέπει τις φωτογραφίες, επαληθεύει κάθε μετατροπή και μετακινεί τα πρωτότυπα στον κάδο</value></data>
<data name="Admin.Convert.ConfirmNew.one" xml:space="preserve"><value>{0} φωτογραφία μετατρέπεται σε αντίγραφο μέσα σε μια νέα ακολουθία. Το πρωτότυπο μένει ως έχει.</value></data>
<data name="Admin.Convert.ConfirmNew.other" xml:space="preserve"><value>{0} φωτογραφίες μετατρέπονται σε αντίγραφα, μέσα σε μια νέα ακολουθία δίπλα σε κάθε αρχική. Τα πρωτότυπα μένουν ως έχουν.</value></data>
<data name="Admin.Convert.ConfirmNewNotCopied.one" xml:space="preserve"><value>{0} φωτογραφία δεν αντιγράφεται στη νέα ακολουθία, για τον λόγο που αναφέρει η προεπισκόπηση.</value></data>
<data name="Admin.Convert.ConfirmNewNotCopied.other" xml:space="preserve"><value>{0} φωτογραφίες δεν αντιγράφονται στις νέες ακολουθίες, για τους λόγους που αναφέρει η προεπισκόπηση.</value></data>
<data name="Admin.Convert.ConfirmNewTitle" xml:space="preserve"><value>Μετατροπή σε {0} ως νέες ακολουθίες;</value></data>
<data name="Admin.Convert.ConfirmReplace.one" xml:space="preserve"><value>{0} φωτογραφία σε {1} αντικαθίσταται από τη μετατροπή της. Το πρωτότυπο πηγαίνει στον κάδο και μπορεί να επαναφερθεί μέχρι να αδειάσει ο κάδος.</value></data>
<data name="Admin.Convert.ConfirmReplace.other" xml:space="preserve"><value>{0} φωτογραφίες σε {1} αντικαθίστανται από τις μετατροπές τους. Τα πρωτότυπα πηγαίνουν στον κάδο και μπορούν να επαναφερθούν μέχρι να αδειάσει ο κάδος.</value></data>
<data name="Admin.Convert.ConfirmReplaceTitle" xml:space="preserve"><value>Αντικατάσταση των πρωτοτύπων με {0};</value></data>
<data name="Admin.Convert.Format" xml:space="preserve"><value>Μορφή</value></data>
<data name="Admin.Convert.Format.Jpeg.Tip" xml:space="preserve"><value>JPEG 8 bit με πλήρη χρωματική λεπτομέρεια, στην ποιότητα που ορίζεται δίπλα: τα μικρότερα αρχεία, που ανοίγουν σε κάθε πρόγραμμα</value></data>
<data name="Admin.Convert.Format.LinearDng" xml:space="preserve"><value>Γραμμικό DNG</value></data>
<data name="Admin.Convert.Format.LinearDng.Tip" xml:space="preserve"><value>Γραμμικό DNG 16 bit με συμπίεση χωρίς απώλειες: η επιλογή για αρχειοθέτηση, που ανοίγει σε προγράμματα επεξεργασίας RAW</value></data>
<data name="Admin.Convert.Format.Tiff16.Tip" xml:space="preserve"><value>TIFF sRGB 16 bit με συμπίεση χωρίς απώλειες: μεγάλα αρχεία που διατηρούν κάθε τόνο για επεξεργασία</value></data>
<data name="Admin.Convert.Gone" xml:space="preserve"><value>Μια επιλεγμένη ακολουθία δεν βρίσκεται πλέον στην αρχειοθήκη. Κλείστε και επιλέξτε ξανά.</value></data>
<data name="Admin.Convert.Mode" xml:space="preserve"><value>Λειτουργία</value></data>
<data name="Admin.Convert.Mode.NewSequence" xml:space="preserve"><value>Νέα ακολουθία</value></data>
<data name="Admin.Convert.Mode.NewSequence.Tip" xml:space="preserve"><value>Τα αντίγραφα που μετατρέπονται μπαίνουν σε μια νέα ακολουθία δίπλα σε κάθε αρχική. Τα πρωτότυπα και η ακολουθία τους μένουν ακριβώς ως έχουν</value></data>
<data name="Admin.Convert.Mode.Replace" xml:space="preserve"><value>Αντικατάσταση</value></data>
<data name="Admin.Convert.Mode.Replace.Tip" xml:space="preserve"><value>Τα αρχεία που μετατρέπονται γίνονται οι φωτογραφίες της ακολουθίας. Τα πρωτότυπα πηγαίνουν στον κάδο της αρχειοθήκης και μπορούν να επαναφερθούν μέχρι να αδειάσει</value></data>
<data name="Admin.Convert.NoAnswer" xml:space="preserve"><value>Ο διακομιστής δεν απάντησε: ελέγξτε στη σελίδα Εργασίες αν η μετατροπή μπήκε στην ουρά, πριν κάνετε ξανά μετατροπή.</value></data>
<data name="Admin.Convert.NoSpace.Tip" xml:space="preserve"><value>Ελευθερώστε πρώτα χώρο στον τόμο της αρχειοθήκης</value></data>
<data name="Admin.Convert.NotCopiedCount.one" xml:space="preserve"><value>{0} δεν αντιγράφεται</value></data>
<data name="Admin.Convert.NotCopiedCount.other" xml:space="preserve"><value>{0} δεν αντιγράφονται</value></data>
<data name="Admin.Convert.Nothing.Tip" xml:space="preserve"><value>Στην προεπισκόπηση δεν μετατρέπεται τίποτα</value></data>
<data name="Admin.Convert.NothingToConvert" xml:space="preserve"><value>Τίποτα για μετατροπή: κάθε φωτογραφία μένει ως έχει, για τους λόγους που εμφανίζονται.</value></data>
<data name="Admin.Convert.OpenJob" xml:space="preserve"><value>Άνοιγμα εργασίας</value></data>
<data name="Admin.Convert.OpenJob.Tip" xml:space="preserve"><value>Εμφάνιση της εργασίας και της καταγραφής της στη σελίδα Εργασίες</value></data>
<data name="Admin.Convert.PlanChanged" xml:space="preserve"><value>Η αρχειοθήκη άλλαξε μετά την προεπισκόπηση. Ελέγξτε τη νέα και εφαρμόστε ξανά.</value></data>
<data name="Admin.Convert.Planning" xml:space="preserve"><value>Σχεδιασμός…</value></data>
<data name="Admin.Convert.Planning.Tip" xml:space="preserve"><value>Ο διακομιστής διαβάζει κάθε φάκελο φωτογραφιών της επιλογής: για μια μεγάλη αρχειοθήκη χρειάζονται αρκετά λεπτά και η προεπισκόπηση εμφανίζεται μόλις τελειώσει</value></data>
<data name="Admin.Convert.PlanningFor" xml:space="preserve"><value>Σχεδιασμός… {0}</value></data>
<data name="Admin.Convert.Preview" xml:space="preserve"><value>Προεπισκόπηση</value></data>
<data name="Admin.Convert.Preview.Tip" xml:space="preserve"><value>Τι μετατρέπει και τι αφήνει ως έχει κάθε ακολουθία, με το μέγεθος πριν και μετά (εκτίμηση). Δεν έχει αλλάξει τίποτα ακόμη</value></data>
<data name="Admin.Convert.Quality" xml:space="preserve"><value>Ποιότητα</value></data>
<data name="Admin.Convert.Quality.Tip" xml:space="preserve"><value>Ποιότητα JPEG από 1 έως 100. Το 95 διατηρεί τις λεπτές λεπτομέρειες, χαμηλότερες τιμές δίνουν μικρότερα αρχεία</value></data>
<data name="Admin.Convert.QualityRange" xml:space="preserve"><value>Γράψτε έναν ακέραιο αριθμό από 1 έως 100.</value></data>
<data name="Admin.Convert.Queued" xml:space="preserve"><value>Η μετατροπή μπήκε στην ουρά.</value></data>
<data name="Admin.Convert.ReplaceWord" xml:space="preserve"><value>αντικατάσταση</value></data>
<data name="Admin.Convert.Size.Tip" xml:space="preserve"><value>Τρέχον μέγεθος των φωτογραφιών που μετατρέπονται, έπειτα το εκτιμώμενο μέγεθος μετά τη μετατροπή</value></data>
<data name="Admin.Convert.SkippedPhotos" xml:space="preserve"><value>{0}: {1}</value></data>
<data name="Admin.Convert.Title.one" xml:space="preserve"><value>Μετατροπή {0} ακολουθίας</value></data>
<data name="Admin.Convert.Title.other" xml:space="preserve"><value>Μετατροπή {0} ακολουθιών</value></data>
<data name="Admin.Convert.TitleAll" xml:space="preserve"><value>Μετατροπή όλων των ακολουθιών</value></data>
<data name="Admin.Convert.TooMany" xml:space="preserve"><value>Η μετατροπή δέχεται έως {0} ακολουθίες τη φορά ή όλες τις ακολουθίες: απαλείψτε τα φίλτρα και επιλέξτε όλες.</value></data>
<data name="Admin.Convert.Totals" xml:space="preserve"><value>Ακολουθίες που μετατρέπονται: {0} · φωτογραφίες: {1} · χωρίς αλλαγή: {2} · μέγεθος: {3} → {4}</value></data>
<data name="Admin.Convert.TotalsNew" xml:space="preserve"><value>Ακολουθίες που μετατρέπονται: {0} · φωτογραφίες: {1} · δεν αντιγράφονται: {2} · μέγεθος: {3} → {4}</value></data>
<data name="Admin.Dashboard.Activity" xml:space="preserve"><value>Πρόσφατη δραστηριότητα</value></data>
<data name="Admin.Dashboard.AllLogs" xml:space="preserve"><value>Όλες οι καταγραφές</value></data>
<data name="Admin.Dashboard.AllLogs.Tip" xml:space="preserve"><value>Άνοιγμα του αρχείου ελέγχου</value></data>
@@ -133,6 +196,7 @@
<data name="Admin.Job.Kind.Adopt" xml:space="preserve"><value>Ενσωμάτωση</value></data>
<data name="Admin.Job.Kind.Backup" xml:space="preserve"><value>Αντίγραφο ασφαλείας</value></data>
<data name="Admin.Job.Kind.Cleanup" xml:space="preserve"><value>Εκκαθάριση</value></data>
<data name="Admin.Job.Kind.Convert" xml:space="preserve"><value>Μετατροπή</value></data>
<data name="Admin.Job.Kind.DeepAnalyse" xml:space="preserve"><value>Ανάλυση σε βάθος</value></data>
<data name="Admin.Job.Kind.Duplicates" xml:space="preserve"><value>Διπλότυπα</value></data>
<data name="Admin.Job.Kind.EmptyTrash" xml:space="preserve"><value>Άδειασμα κάδου</value></data>
@@ -344,6 +408,7 @@
<data name="Admin.Login.SignIn.Tip" xml:space="preserve"><value>Είσοδος για τη διαχείριση αυτού του διακομιστή</value></data>
<data name="Admin.Login.User" xml:space="preserve"><value>Χρήστης</value></data>
<data name="Admin.Login.User.Tip" xml:space="preserve"><value>Το όνομα χρήστη σας σε αυτόν τον διακομιστή</value></data>
<data name="Admin.Logs.Action.ArchiveConverted" xml:space="preserve"><value>Μετατροπή φωτογραφιών</value></data>
<data name="Admin.Logs.Action.ArchiveReorganized" xml:space="preserve"><value>Αναδιοργάνωση αρχειοθήκης</value></data>
<data name="Admin.Logs.Action.ArchiveSettings" xml:space="preserve"><value>Διάταξη αρχειοθήκης</value></data>
<data name="Admin.Logs.Action.FramesDeleted" xml:space="preserve"><value>Διαγραφή φωτογραφιών</value></data>
@@ -793,6 +858,7 @@
<data name="Admin.Theme.Tip" xml:space="preserve"><value>Εναλλαγή μεταξύ φωτεινού και σκοτεινού θέματος</value></data>
<data name="Admin.Trash.Back" xml:space="preserve"><value>Βιβλιοθήκη</value></data>
<data name="Admin.Trash.Back.Tip" xml:space="preserve"><value>Επιστροφή στη Βιβλιοθήκη</value></data>
<data name="Admin.Trash.ConversionDeleted" xml:space="preserve"><value>η μετατροπή διαγράφηκε</value></data>
<data name="Admin.Trash.DeletedAt" xml:space="preserve"><value>Διαγράφηκε</value></data>
<data name="Admin.Trash.DeletedBy" xml:space="preserve"><value>Διαγράφηκε από</value></data>
<data name="Admin.Trash.Emptied" xml:space="preserve"><value>Ο κάδος άδειασε.</value></data>
@@ -819,9 +885,12 @@
<data name="Admin.Trash.Photos" xml:space="preserve"><value>Φωτογραφίες</value></data>
<data name="Admin.Trash.Restore" xml:space="preserve"><value>Επαναφορά</value></data>
<data name="Admin.Trash.RestorePhotos.Tip" xml:space="preserve"><value>Επαναφορά των φωτογραφιών στην ακολουθία τους (σε νέα, αν εκείνη δεν υπάρχει πλέον). Πρώτα ελέγχεται καθεμία με το SHA-256 της</value></data>
<data name="Admin.Trash.RestoreReplaced.Tip" xml:space="preserve"><value>Επαναφορά των πρωτοτύπων στη θέση των μετατροπών τους, εφόσον αυτές δεν έχουν αλλάξει (οι μετατροπές πηγαίνουν στον κάδο), αλλιώς σε νέα ακολουθία. Πρώτα ελέγχεται καθένα με το SHA-256 του</value></data>
<data name="Admin.Trash.RestoreSequence.Tip" xml:space="preserve"><value>Επιστροφή του φακέλου της ακολουθίας στη βιβλιοθήκη ως έχει (δίπλα στην παλιά του θέση, αν αυτή είναι κατειλημμένη). Το hash των φωτογραφιών της δεν ελέγχεται: αυτό το κάνει η Επαλήθευση</value></data>
<data name="Admin.Trash.RestoredNew.one" xml:space="preserve"><value>{0} φωτογραφία επαναφέρθηκε σε νέα ακολουθία.</value></data>
<data name="Admin.Trash.RestoredNew.other" xml:space="preserve"><value>{0} φωτογραφίες επαναφέρθηκαν σε νέα ακολουθία.</value></data>
<data name="Admin.Trash.RestoredOriginals.one" xml:space="preserve"><value>{0} πρωτότυπο επέστρεψε στην ακολουθία {1}. Η μετατροπή του βρίσκεται στον κάδο.</value></data>
<data name="Admin.Trash.RestoredOriginals.other" xml:space="preserve"><value>{0} πρωτότυπα επέστρεψαν στην ακολουθία {1}. Οι μετατροπές τους βρίσκονται στον κάδο.</value></data>
<data name="Admin.Trash.RestoredPhotos.one" xml:space="preserve"><value>{0} φωτογραφία επέστρεψε στην ακολουθία {1}.</value></data>
<data name="Admin.Trash.RestoredPhotos.other" xml:space="preserve"><value>{0} φωτογραφίες επέστρεψαν στην ακολουθία {1}.</value></data>
<data name="Admin.Trash.RestoredSequence" xml:space="preserve"><value>Η ακολουθία {0} επέστρεψε στη βιβλιοθήκη.</value></data>
+108 -3
View File
@@ -15,8 +15,10 @@
<data name="Archive.Blocked.Applying" xml:space="preserve"><value>Περιμένετε να εφαρμοστούν οι αλλαγές.</value></data>
<data name="Archive.Blocked.EmptySet" xml:space="preserve"><value>Το σύνολο είναι κενό: αλλάξτε την επιλογή ή το φίλτρο.</value></data>
<data name="Archive.Blocked.NoChanges" xml:space="preserve"><value>Δεν θα άλλαζε τίποτα.</value></data>
<data name="Archive.Blocked.NoMode" xml:space="preserve"><value>Επιλέξτε «Αντικατάσταση» ή «Νέα ακολουθία».</value></data>
<data name="Archive.Blocked.NoTemplate" xml:space="preserve"><value>Ενεργοποιήστε τουλάχιστον ένα πρότυπο.</value></data>
<data name="Archive.Blocked.NotOnline" xml:space="preserve"><value>Η αρχειοθήκη πρέπει να είναι σε σύνδεση και εγγράψιμη.</value></data>
<data name="Archive.Blocked.NothingToConvert" xml:space="preserve"><value>Τίποτα για μετατροπή: όλες οι φωτογραφίες παραλείπονται ή όλες οι ακολουθίες είναι αποκλεισμένες.</value></data>
<data name="Archive.Blocked.Planning" xml:space="preserve"><value>Περιμένετε τη δοκιμαστική εκτέλεση.</value></data>
<data name="Archive.Blocked.Reading" xml:space="preserve"><value>Περιμένετε να διαβαστεί η αρχειοθήκη.</value></data>
<data name="Archive.Blocked.Searching" xml:space="preserve"><value>Εκτελείται αναζήτηση. Ακυρώστε την ή περιμένετε.</value></data>
@@ -32,6 +34,82 @@
<data name="Archive.Confirm.Remove" xml:space="preserve"><value>Κατάργηση γραμμής</value></data>
<data name="Archive.Confirm.RemoveHeading" xml:space="preserve"><value>Κατάργηση του «{0}» από το ευρετήριο;</value></data>
<data name="Archive.Confirm.RemoveMessage" xml:space="preserve"><value>Το αρχείο sidecar της ακολουθίας δεν υπάρχει πλέον. Καταργείται μόνο η γραμμή του ευρετηρίου. Κανένα αρχείο δεν διαγράφεται.</value></data>
<data name="Archive.Convert.AlreadyQueued" xml:space="preserve"><value>Μια μετατροπή αυτών των ακολουθιών βρίσκεται ήδη σε αναμονή ή σε εκτέλεση. Παρακολουθήστε την από τις Εργασίες.</value></data>
<data name="Archive.Convert.Blocked.Busy" xml:space="preserve"><value>Μια εργασία επεξεργάζεται αυτήν την ακολουθία. Μετατρέψτε τη μόλις ολοκληρωθεί η εργασία.</value></data>
<data name="Archive.Convert.Blocked.FramesChanged" xml:space="preserve"><value>Η ακολουθία άλλαξε μετά το σχέδιο. Ελέγξτε ξανά το σχέδιο.</value></data>
<data name="Archive.Convert.Blocked.Offline" xml:space="preserve"><value>Η αρχειοθήκη είναι εκτός σύνδεσης ή μόνο για ανάγνωση.</value></data>
<data name="Archive.Convert.Blocked.Unreadable" xml:space="preserve"><value>Το αρχείο της ακολουθίας δεν είναι αναγνώσιμο.</value></data>
<data name="Archive.Convert.Confirm" xml:space="preserve"><value>Μετατροπή</value></data>
<data name="Archive.Convert.CopyUnfinished" xml:space="preserve"><value>Μια άλλη μετατροπή δημιούργησε αντίγραφό της σε αυτήν τη μορφή και δεν έχει ολοκληρωθεί. Ολοκληρώστε ή επαναλάβετε πρώτα εκείνη.</value></data>
<data name="Archive.Convert.Done.one" xml:space="preserve"><value>{0:N0} ακολουθία μετατράπηκε</value></data>
<data name="Archive.Convert.Done.other" xml:space="preserve"><value>{0:N0} ακολουθίες μετατράπηκαν</value></data>
<data name="Archive.Convert.Failed.Changed" xml:space="preserve"><value>Η φωτογραφία δεν ταιριάζει πλέον με το αντίγραφο που αρχειοθετήθηκε. Επαληθεύστε την ακολουθία.</value></data>
<data name="Archive.Convert.Failed.ColorProfile" xml:space="preserve"><value>Το χρωματικό της προφίλ δεν μπορεί ούτε να διατηρηθεί ούτε να μετατραπεί σε αυτήν τη μορφή.</value></data>
<data name="Archive.Convert.Failed.Damaged" xml:space="preserve"><value>Τα pixel της περιέχουν τιμές που δεν είναι αριθμοί: το αρχείο είναι κατεστραμμένο.</value></data>
<data name="Archive.Convert.Failed.EightBit" xml:space="preserve"><value>Αυτός ο υπολογιστής αποκωδικοποιεί αυτό το RAW μόνο σε 8 bit, πολύ λίγα για αρχείο 16 bit. Η μετατροπή σε JPEG είναι δυνατή.</value></data>
<data name="Archive.Convert.Failed.Full" xml:space="preserve"><value>Ο δίσκος της αρχειοθήκης είναι γεμάτος.</value></data>
<data name="Archive.Convert.Failed.NoDecoder" xml:space="preserve"><value>Κανένας αποκωδικοποιητής σε αυτόν τον υπολογιστή δεν τη διαβάζει σε πλήρη ανάλυση.</value></data>
<data name="Archive.Convert.Failed.NotVerified" xml:space="preserve"><value>Το αρχείο που μετατράπηκε δεν διαβάστηκε ξανά όπως γράφτηκε.</value></data>
<data name="Archive.Convert.Failed.Other" xml:space="preserve"><value>Δεν ήταν δυνατή η δημιουργία του αρχείου της μετατροπής.</value></data>
<data name="Archive.Convert.Failed.PreviewOnly" xml:space="preserve"><value>Αυτός ο υπολογιστής τη διαβάζει μόνο από την ενσωματωμένη προεπισκόπησή της: μετατρέψτε τη σε έναν υπολογιστή που τη διαβάζει σε πλήρη ανάλυση.</value></data>
<data name="Archive.Convert.Failed.TooLarge" xml:space="preserve"><value>Είναι μεγαλύτερη από όσο χωράει αυτή η μορφή, από όσο μπορεί να διαβάσει ξανά το Chronos ή από όσο χωράει η μνήμη για μία φωτογραφία.</value></data>
<data name="Archive.Convert.Failed.Unreadable" xml:space="preserve"><value>Δεν ήταν δυνατή η αποκωδικοποίηση της φωτογραφίας.</value></data>
<data name="Archive.Convert.Format" xml:space="preserve"><value>Μορφή</value></data>
<data name="Archive.Convert.Heading.one" xml:space="preserve"><value>Μετατροπή {0:N0} ακολουθίας</value></data>
<data name="Archive.Convert.Heading.other" xml:space="preserve"><value>Μετατροπή {0:N0} ακολουθιών</value></data>
<data name="Archive.Convert.HeadingAll" xml:space="preserve"><value>Μετατροπή της αρχειοθήκης {0}</value></data>
<data name="Archive.Convert.Mode" xml:space="preserve"><value>Λειτουργία</value></data>
<data name="Archive.Convert.NewHeading.one" xml:space="preserve"><value>Μετατροπή {0:N0} ακολουθίας σε νέα;</value></data>
<data name="Archive.Convert.NewHeading.other" xml:space="preserve"><value>Μετατροπή {0:N0} ακολουθιών σε νέες;</value></data>
<data name="Archive.Convert.NewLeftOut.one" xml:space="preserve"><value>{0:N0} φωτογραφία δεν αντιγράφεται: μένει μόνο στην αρχική της ακολουθία, για τον λόγο που αναφέρει το σχέδιο.</value></data>
<data name="Archive.Convert.NewLeftOut.other" xml:space="preserve"><value>{0:N0} φωτογραφίες δεν αντιγράφονται: μένουν μόνο στην αρχική τους ακολουθία, για τους λόγους που αναφέρει το σχέδιο.</value></data>
<data name="Archive.Convert.NewMessage" xml:space="preserve"><value>{0} ({1}) μετατρέπονται σε {2}, μέσα σε μια νέα ακολουθία δίπλα σε κάθε αρχική. Τα πρωτότυπα μένουν ως έχουν.</value></data>
<data name="Archive.Convert.NewSequence" xml:space="preserve"><value>Νέα ακολουθία</value></data>
<data name="Archive.Convert.NotCopied.ColorProfile" xml:space="preserve"><value>Οι φωτογραφίες με χρωματικό προφίλ που αυτή η μορφή δεν μπορεί ούτε να διατηρήσει ούτε να μετατρέψει δεν αντιγράφονται στη νέα ακολουθία.</value></data>
<data name="Archive.Convert.NotCopied.EightBit" xml:space="preserve"><value>Οι φωτογραφίες RAW που αυτός ο υπολογιστής αποκωδικοποιεί μόνο σε 8 bit δεν αντιγράφονται στη νέα ακολουθία. Η μετατροπή σε JPEG είναι δυνατή.</value></data>
<data name="Archive.Convert.NotCopied.Inaccessible" xml:space="preserve"><value>Οι φωτογραφίες που κρατά ανοιχτές άλλο πρόγραμμα ή που δεν ανοίγουν δεν αντιγράφονται στη νέα ακολουθία. Καταρτίστε ξανά το σχέδιο μόλις ελευθερωθούν.</value></data>
<data name="Archive.Convert.NotCopied.Missing" xml:space="preserve"><value>Οι φωτογραφίες που λείπουν δεν αντιγράφονται στη νέα ακολουθία.</value></data>
<data name="Archive.Convert.NotCopied.NoNativeDecoder" xml:space="preserve"><value>Οι φωτογραφίες σε μορφή που αυτός ο υπολογιστής δεν μπορεί να διαβάσει σε πλήρη ανάλυση δεν αντιγράφονται στη νέα ακολουθία.</value></data>
<data name="Archive.Convert.NotCopied.PreviewOnly" xml:space="preserve"><value>Οι φωτογραφίες που εδώ διαβάζονται μόνο από την ενσωματωμένη προεπισκόπησή τους δεν αντιγράφονται στη νέα ακολουθία.</value></data>
<data name="Archive.Convert.NotCopied.SameFormat" xml:space="preserve"><value>Οι φωτογραφίες που είναι ήδη σε αυτήν τη μορφή δεν αντιγράφονται στη νέα ακολουθία.</value></data>
<data name="Archive.Convert.NotCopied.TooLarge" xml:space="preserve"><value>Οι φωτογραφίες που είναι μεγαλύτερες από όσο χωράει αυτή η μορφή ή από όσο μπορεί να διαβάσει ξανά το Chronos δεν αντιγράφονται στη νέα ακολουθία.</value></data>
<data name="Archive.Convert.NotCopied.Undecodable" xml:space="preserve"><value>Οι μη αναγνώσιμες φωτογραφίες δεν αντιγράφονται στη νέα ακολουθία.</value></data>
<data name="Archive.Convert.NotCopied.Unhashed" xml:space="preserve"><value>Οι φωτογραφίες που δεν έχουν επαληθευτεί ποτέ δεν αντιγράφονται στη νέα ακολουθία. Επαληθεύστε πρώτα την ακολουθία.</value></data>
<data name="Archive.Convert.NotCopiedPhotos.one" xml:space="preserve"><value>{0:N0} δεν αντιγράφεται</value></data>
<data name="Archive.Convert.NotCopiedPhotos.other" xml:space="preserve"><value>{0:N0} δεν αντιγράφονται</value></data>
<data name="Archive.Convert.NotPlaced" xml:space="preserve"><value>Οι φωτογραφίες που μετατράπηκαν δεν μπόρεσαν να πάρουν τη θέση των πρωτοτύπων. {0}</value></data>
<data name="Archive.Convert.PhotoFailed" xml:space="preserve"><value>Δεν ήταν δυνατή η μετατροπή του {0}. {1}</value></data>
<data name="Archive.Convert.PhotoHeld" xml:space="preserve"><value>Μια φωτογραφία της ακολουθίας είναι ανοιχτή σε άλλο πρόγραμμα ή δεν ανοίγει. Δοκιμάστε ξανά μόλις ελευθερωθεί.</value></data>
<data name="Archive.Convert.Quality" xml:space="preserve"><value>Ποιότητα</value></data>
<data name="Archive.Convert.Replace" xml:space="preserve"><value>Αντικατάσταση</value></data>
<data name="Archive.Convert.ReplaceHeading.one" xml:space="preserve"><value>Αντικατάσταση των φωτογραφιών {0:N0} ακολουθίας;</value></data>
<data name="Archive.Convert.ReplaceHeading.other" xml:space="preserve"><value>Αντικατάσταση των φωτογραφιών {0:N0} ακολουθιών;</value></data>
<data name="Archive.Convert.ReplaceMessage" xml:space="preserve"><value>{0} ({1}) αντικαθίστανται από τη μετατροπή τους σε {2}. Τα πρωτότυπα μετακινούνται στον κάδο της αρχειοθήκης και μπορούν να επαναφερθούν μέχρι να αδειάσει.</value></data>
<data name="Archive.Convert.Sizes" xml:space="preserve"><value>{0} → {1}</value></data>
<data name="Archive.Convert.Skipped.ColorProfile" xml:space="preserve"><value>Οι φωτογραφίες με χρωματικό προφίλ που αυτή η μορφή δεν μπορεί ούτε να διατηρήσει ούτε να μετατρέψει μένουν ως έχουν.</value></data>
<data name="Archive.Convert.Skipped.EightBit" xml:space="preserve"><value>Οι φωτογραφίες RAW που αυτός ο υπολογιστής αποκωδικοποιεί μόνο σε 8 bit μένουν ως έχουν. Η μετατροπή σε JPEG είναι δυνατή.</value></data>
<data name="Archive.Convert.Skipped.Inaccessible" xml:space="preserve"><value>Οι φωτογραφίες που κρατά ανοιχτές άλλο πρόγραμμα ή που δεν ανοίγουν μένουν ως έχουν. Καταρτίστε ξανά το σχέδιο μόλις ελευθερωθούν.</value></data>
<data name="Archive.Convert.Skipped.Missing" xml:space="preserve"><value>Οι φωτογραφίες που λείπουν μένουν ως έχουν.</value></data>
<data name="Archive.Convert.Skipped.NoNativeDecoder" xml:space="preserve"><value>Οι φωτογραφίες σε μορφή που αυτός ο υπολογιστής δεν μπορεί να διαβάσει σε πλήρη ανάλυση μένουν ως έχουν.</value></data>
<data name="Archive.Convert.Skipped.PreviewOnly" xml:space="preserve"><value>Οι φωτογραφίες που εδώ διαβάζονται μόνο από την ενσωματωμένη προεπισκόπησή τους μένουν ως έχουν.</value></data>
<data name="Archive.Convert.Skipped.SameFormat" xml:space="preserve"><value>Οι φωτογραφίες που είναι ήδη σε αυτήν τη μορφή μένουν ως έχουν.</value></data>
<data name="Archive.Convert.Skipped.TooLarge" xml:space="preserve"><value>Οι φωτογραφίες που είναι μεγαλύτερες από όσο χωράει αυτή η μορφή ή από όσο μπορεί να διαβάσει ξανά το Chronos μένουν ως έχουν.</value></data>
<data name="Archive.Convert.Skipped.Undecodable" xml:space="preserve"><value>Οι μη αναγνώσιμες φωτογραφίες μένουν ως έχουν.</value></data>
<data name="Archive.Convert.Skipped.Unhashed" xml:space="preserve"><value>Οι φωτογραφίες που δεν έχουν επαληθευτεί ποτέ μένουν ως έχουν. Επαληθεύστε πρώτα την ακολουθία.</value></data>
<data name="Archive.Convert.SkippedPhotos.one" xml:space="preserve"><value>{0:N0} παραλείπεται</value></data>
<data name="Archive.Convert.SkippedPhotos.other" xml:space="preserve"><value>{0:N0} παραλείπονται</value></data>
<data name="Archive.Convert.Space" xml:space="preserve"><value>Απαιτούνται {0}, ελεύθερα {1}</value></data>
<data name="Archive.Convert.SpaceShort" xml:space="preserve"><value>Απαιτούνται {0}, ελεύθερα μόνο {1}: ελευθερώστε πρώτα χώρο.</value></data>
<data name="Archive.Convert.SpaceUnknown" xml:space="preserve"><value>Απαιτούνται {0}. Ο ελεύθερος χώρος δεν μπορεί να μετρηθεί.</value></data>
<data name="Archive.Convert.Target.LinearDng" xml:space="preserve"><value>Γραμμικό DNG</value></data>
<data name="Archive.Convert.Target.Tiff16" xml:space="preserve"><value>TIFF 16 bit</value></data>
<data name="Archive.Convert.UndoFailed" xml:space="preserve"><value>Δεν ήταν δυνατή η επαναφορά των πρωτοτύπων</value></data>
<data name="Archive.Convert.UndoNothing" xml:space="preserve"><value>Τα πρωτότυπα που αντικαταστάθηκαν δεν βρίσκονται πλέον στον κάδο.</value></data>
<data name="Archive.Convert.Undone.one" xml:space="preserve"><value>Τα πρωτότυπα επέστρεψαν σε {0:N0} ακολουθία</value></data>
<data name="Archive.Convert.Undone.other" xml:space="preserve"><value>Τα πρωτότυπα επέστρεψαν σε {0:N0} ακολουθίες</value></data>
<data name="Archive.Convert.UndoneNew.one" xml:space="preserve"><value>{0:N0} ακολουθία είχε αλλάξει στο μεταξύ: τα πρωτότυπά της επέστρεψαν ως νέα ακολουθία.</value></data>
<data name="Archive.Convert.UndoneNew.other" xml:space="preserve"><value>{0:N0} ακολουθίες είχαν αλλάξει στο μεταξύ: τα πρωτότυπά τους επέστρεψαν ως νέες ακολουθίες.</value></data>
<data name="Archive.Convert.Unstaged" xml:space="preserve"><value>Η μετατροπή του {0} δεν βρίσκεται πλέον στα προετοιμασμένα αρχεία. Με την επανάληψη μετατρέπεται ξανά.</value></data>
<data name="Archive.Copy.Title" xml:space="preserve"><value>Φάκελος για αντιγραφή στην αρχειοθήκη</value></data>
<data name="Archive.Delete.Action" xml:space="preserve"><value>Μετακίνηση στον κάδο</value></data>
<data name="Archive.Delete.Blocked" xml:space="preserve"><value>Δεν μετακινείται: {0} · {1}</value></data>
@@ -75,6 +153,9 @@
<data name="Archive.Duplicates.Title" xml:space="preserve"><value>Διπλότυπα</value></data>
<data name="Archive.Empty" xml:space="preserve"><value>Δεν υπάρχει αρχειοθήκη ακόμη</value></data>
<data name="Archive.Error.Busy" xml:space="preserve"><value>Ένα άλλο Chronos ({0}) γράφει εδώ. Δοκιμάστε ξανά σε λίγο.</value></data>
<data name="Archive.Error.ConvertKept.one" xml:space="preserve"><value>{0:N0} ακολουθία δεν μετατράπηκε όπως είχε σχεδιαστεί. Η καταγραφή της εργασίας εξηγεί τον λόγο.</value></data>
<data name="Archive.Error.ConvertKept.other" xml:space="preserve"><value>{0:N0} ακολουθίες δεν μετατράπηκαν όπως είχε σχεδιαστεί. Η καταγραφή της εργασίας εξηγεί τον λόγο.</value></data>
<data name="Archive.Error.ConvertSpace" xml:space="preserve"><value>Η μετατροπή χρειάζεται {0} ελεύθερα στον τόμο της αρχειοθήκης, ενώ είναι ελεύθερα {1}.</value></data>
<data name="Archive.Error.CopyMismatch" xml:space="preserve"><value>Το αντίγραφο του {0} δεν ταιριάζει με το πρωτότυπο.</value></data>
<data name="Archive.Error.DuplicateLost" xml:space="preserve"><value>Δεν ήταν δυνατή η προσθήκη του {0} στην ακολουθία.</value></data>
<data name="Archive.Error.InLibrary" xml:space="preserve"><value>Η ακολουθία {0} βρίσκεται ήδη στη βιβλιοθήκη.</value></data>
@@ -92,8 +173,8 @@
<data name="Archive.Error.SourceGone" xml:space="preserve"><value>Η κάρτα ή ο φάκελος {0} δεν είναι πλέον διαθέσιμος.</value></data>
<data name="Archive.Error.StalePlan" xml:space="preserve"><value>Η αρχειοθήκη άλλαξε μετά τη δημιουργία αυτού του σχεδίου.</value></data>
<data name="Archive.Error.TrashChanged" xml:space="preserve"><value>Ο κάδος άλλαξε μετά τον έλεγχο. Δεν διαγράφηκε τίποτα.</value></data>
<data name="Archive.Error.TrashKept.one" xml:space="preserve"><value>{0:N0} εγγραφή του κάδου διατηρήθηκε: άλλαξε ή μια αντικατάσταση δεν ταιριάζει πλέον.</value></data>
<data name="Archive.Error.TrashKept.other" xml:space="preserve"><value>{0:N0} εγγραφές του κάδου διατηρήθηκαν: άλλαξαν ή μια αντικατάσταση δεν ταιριάζει πλέον.</value></data>
<data name="Archive.Error.TrashKept.one" xml:space="preserve"><value>{0:N0} εγγραφή του κάδου διατηρήθηκε. Η καταγραφή της εργασίας εξηγεί τον λόγο.</value></data>
<data name="Archive.Error.TrashKept.other" xml:space="preserve"><value>{0:N0} εγγραφές του κάδου διατηρήθηκαν. Η καταγραφή της εργασίας εξηγεί τον λόγο.</value></data>
<data name="Archive.Error.TrashMismatch" xml:space="preserve"><value>Κανένα αρχείο αυτής της εγγραφής του κάδου δεν αντιστοιχεί πλέον στα καταγεγραμμένα στοιχεία της. Η εγγραφή παραμένει στον κάδο.</value></data>
<data name="Archive.Failed.Access" xml:space="preserve"><value>Δεν επιτράπηκε στο Chronos η πρόσβαση στην αρχειοθήκη.</value></data>
<data name="Archive.Failed.Files" xml:space="preserve"><value>Δεν ήταν δυνατή η ανάγνωση ή η εγγραφή ενός αρχείου της αρχειοθήκης.</value></data>
@@ -132,6 +213,15 @@
<data name="Archive.Log.AuditKept" xml:space="preserve"><value>Το αρχείο ελέγχου διατηρήθηκε ολόκληρο</value></data>
<data name="Archive.Log.AuditPurged" xml:space="preserve"><value>Εγγραφές ελέγχου που αφαιρέθηκαν: {0}</value></data>
<data name="Archive.Log.BackupDone" xml:space="preserve"><value>Το ευρετήριο αντιγράφηκε στο {0} ({1}), αντίγραφα που διατηρούνται: {2}</value></data>
<data name="Archive.Log.ConvertBlocked" xml:space="preserve"><value>Έμεινε ως είχε, σε επεξεργασία ή μη αναγνώσιμη: {0}</value></data>
<data name="Archive.Log.ConvertChanged" xml:space="preserve"><value>Έμεινε ως είχε, άλλαξε μετά το σχέδιο: {0}. Μια επανάληψη την αφήνει ως έχει: μετατρέψτε την ξανά με νέο σχέδιο.</value></data>
<data name="Archive.Log.ConvertDone" xml:space="preserve"><value>Ακολουθίες που μετατράπηκαν: {0}, νέες ακολουθίες: {1}, φωτογραφίες: {2}</value></data>
<data name="Archive.Log.ConvertFailed" xml:space="preserve"><value>Έμεινε ως είχε: {0}. {1}</value></data>
<data name="Archive.Log.ConvertLeftOut" xml:space="preserve"><value>{0}: φωτογραφίες που δεν μετατράπηκαν, έμειναν μόνο στην αρχική ακολουθία: {1}</value></data>
<data name="Archive.Log.ConvertNothing" xml:space="preserve"><value>Τίποτα για μετατροπή: {0}</value></data>
<data name="Archive.Log.ConvertSuperseded" xml:space="preserve"><value>{0}: μια άλλη μετατροπή δημιούργησε το αντίγραφό της σε αυτήν τη μορφή αφότου επιβεβαιώθηκε αυτή. Δεν δημιουργείται δεύτερο αντίγραφο.</value></data>
<data name="Archive.Log.Converted" xml:space="preserve"><value>{0}: φωτογραφίες που αντικαταστάθηκαν από τη μετατροπή τους: {1}</value></data>
<data name="Archive.Log.ConvertedNew" xml:space="preserve"><value>{0}: φωτογραφίες που μετατράπηκαν σε νέα ακολουθία: {1}</value></data>
<data name="Archive.Log.DryRun" xml:space="preserve"><value>Δοκιμαστική εκτέλεση: δεν άλλαξε τίποτα.</value></data>
<data name="Archive.Log.DuplicateGroup" xml:space="preserve"><value>Επιπλέον αντίγραφα του {0}: {1}</value></data>
<data name="Archive.Log.DuplicatesDone" xml:space="preserve"><value>Ομάδες διπλοτύπων: {0}, επιπλέον αντίγραφα: {1}</value></data>
@@ -166,9 +256,22 @@
<data name="Archive.Log.SequenceMissing" xml:space="preserve"><value>Η ακολουθία δεν βρέθηκε: {0}</value></data>
<data name="Archive.Log.StepFailed" xml:space="preserve"><value>Το βήμα εκκαθάρισης {0} απέτυχε: {1}</value></data>
<data name="Archive.Log.StepUnknown" xml:space="preserve"><value>Άγνωστο βήμα εκκαθάρισης εδώ: {0}</value></data>
<data name="Archive.Log.SyncChanged" xml:space="preserve"><value>{0}: άλλαξε από τότε που αρχειοθετήθηκε, δεν στάλθηκε</value></data>
<data name="Archive.Log.SyncDeletedHere" xml:space="preserve"><value>{0}: διαγράφηκε σε αυτόν τον υπολογιστή, δεν έγινε λήψη</value></data>
<data name="Archive.Log.SyncDeletedThere" xml:space="preserve"><value>{0}: διαγράφηκε στον διακομιστή, δεν στάλθηκε</value></data>
<data name="Archive.Log.SyncFrameChanged" xml:space="preserve"><value>{0}: το καρέ του εδώ άλλαξε στο μεταξύ, δεν έγινε λήψη</value></data>
<data name="Archive.Log.SyncMissing" xml:space="preserve"><value>{0}: λείπει, δεν στάλθηκε</value></data>
<data name="Archive.Log.SyncNoPreview.one" xml:space="preserve"><value>{0:N0} καρέ δεν έχει ούτε proxy ούτε μικρογραφία στον διακομιστή</value></data>
<data name="Archive.Log.SyncNoPreview.other" xml:space="preserve"><value>{0:N0} καρέ δεν έχουν ούτε proxy ούτε μικρογραφία στον διακομιστή</value></data>
<data name="Archive.Log.TrashEmptied" xml:space="preserve"><value>Εγγραφές που διαγράφηκαν: {0}, μέγεθος: {1}</value></data>
<data name="Archive.Log.TrashEntry" xml:space="preserve"><value>Στον κάδο από τις {0}: {1} ({2})</value></data>
<data name="Archive.Log.TrashKept" xml:space="preserve"><value>Παρέμεινε στον κάδο: {0}</value></data>
<data name="Archive.Log.TrashKept" xml:space="preserve"><value>Διατηρήθηκε στον κάδο, άλλαξε μετά το σχέδιο: {0}</value></data>
<data name="Archive.Log.TrashKeptBusy" xml:space="preserve"><value>Διατηρήθηκε στον κάδο, η ακολουθία ήταν σε επεξεργασία: {0}</value></data>
<data name="Archive.Log.TrashKeptMismatch" xml:space="preserve"><value>Διατηρήθηκε στον κάδο, μια μετατροπή των πρωτοτύπων δεν αντιστοιχεί πλέον: {0}</value></data>
<data name="Archive.Log.TrashKeptStaleIndex" xml:space="preserve"><value>Διατηρήθηκε στον κάδο, το ευρετήριο αναφέρει την ακολουθία, την οποία η αρχειοθήκη δεν περιέχει πλέον. Αναδομήστε το ευρετήριο: {0}</value></data>
<data name="Archive.Log.TrashKeptUnhashed" xml:space="preserve"><value>Διατηρήθηκε στον κάδο, μια φωτογραφία της ακολουθίας δεν επαληθεύτηκε ποτέ. Επαληθεύστε την ακολουθία: {0}</value></data>
<data name="Archive.Log.TrashKeptUnknown" xml:space="preserve"><value>Διατηρήθηκε στον κάδο, η αρχειοθήκη δεν δείχνει τι απέγινε η μετατροπή των πρωτοτύπων. Επαναφέρετέ το για να τα διατηρήσετε: {0}</value></data>
<data name="Archive.Log.TrashKeptUnreadable" xml:space="preserve"><value>Διατηρήθηκε στον κάδο, το αρχείο sidecar ενός φακέλου που ίσως περιέχει την ακολουθία λείπει ή δεν διαβάζεται. Κάντε σάρωση της αρχειοθήκης: {0}</value></data>
<data name="Archive.Log.TrashOffline" xml:space="preserve"><value>Ο κάδος δεν ελέγχθηκε: η αρχειοθήκη δεν είναι προσβάσιμη</value></data>
<data name="Archive.Log.TrashReport" xml:space="preserve"><value>Παλιές εγγραφές στον κάδο: {0}, μέγεθος: {1}. Δεν διαγράφηκε τίποτα</value></data>
<data name="Archive.Log.VerifyDone" xml:space="preserve"><value>Φωτογραφίες που ελέγχθηκαν: {0}, ακέραιες: {1}, με νέο hash: {2}, με προβλήματα: {3}</value></data>
@@ -249,6 +352,7 @@
<data name="Archive.Set.All.other" xml:space="preserve"><value>{0:N0} ακολουθίες · όλες</value></data>
<data name="Archive.Set.Analyse" xml:space="preserve"><value>Ανάλυση</value></data>
<data name="Archive.Set.ClearFilter" xml:space="preserve"><value>Απαλοιφή φίλτρου</value></data>
<data name="Archive.Set.Convert" xml:space="preserve"><value>Μετατροπή…</value></data>
<data name="Archive.Set.Delete" xml:space="preserve"><value>Διαγραφή…</value></data>
<data name="Archive.Set.Export" xml:space="preserve"><value>Εξαγωγή CSV</value></data>
<data name="Archive.Set.Filter" xml:space="preserve"><value>Φίλτρο συνόλου</value></data>
@@ -278,6 +382,7 @@
<data name="Archive.Toolbar.Scan" xml:space="preserve"><value>Σάρωση</value></data>
<data name="Archive.Toolbar.Verify" xml:space="preserve"><value>Επαλήθευση</value></data>
<data name="Archive.Trash.Checking" xml:space="preserve"><value>Έλεγχος του κάδου…</value></data>
<data name="Archive.Trash.ConversionDeleted" xml:space="preserve"><value>η μετατροπή διαγράφηκε</value></data>
<data name="Archive.Trash.Deleted" xml:space="preserve"><value>Διαγράφηκε στις {0}</value></data>
<data name="Archive.Trash.Empty" xml:space="preserve"><value>Ο κάδος είναι άδειος</value></data>
<data name="Archive.Trash.EmptyAction" xml:space="preserve"><value>Άδειασμα…</value></data>
+1
View File
@@ -69,6 +69,7 @@
<data name="Jobs.Kind.Adopt" xml:space="preserve"><value>Ενσωμάτωση φακέλου</value></data>
<data name="Jobs.Kind.Backup" xml:space="preserve"><value>Αντίγραφο ασφαλείας ευρετηρίου</value></data>
<data name="Jobs.Kind.Cleanup" xml:space="preserve"><value>Εκκαθάριση</value></data>
<data name="Jobs.Kind.Convert" xml:space="preserve"><value>Μετατροπή</value></data>
<data name="Jobs.Kind.DeepAnalyse" xml:space="preserve"><value>Ανάλυση σε βάθος</value></data>
<data name="Jobs.Kind.Download" xml:space="preserve"><value>Λήψη</value></data>
<data name="Jobs.Kind.Duplicates" xml:space="preserve"><value>Διπλότυπα</value></data>
+2
View File
@@ -6,6 +6,7 @@
<resheader name="writer"><value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader>
<data name="Library.Action.Analyse" xml:space="preserve"><value>Ανάλυση</value></data>
<data name="Library.Action.ClearSelection" xml:space="preserve"><value>Απαλοιφή επιλογής</value></data>
<data name="Library.Action.Convert" xml:space="preserve"><value>Μετατροπή…</value></data>
<data name="Library.Action.Delete" xml:space="preserve"><value>Διαγραφή…</value></data>
<data name="Library.Action.Download" xml:space="preserve"><value>Λήψη</value></data>
<data name="Library.Action.ExportList" xml:space="preserve"><value>Εξαγωγή λίστας</value></data>
@@ -32,6 +33,7 @@
<data name="Library.Blocked.NothingToDownload" xml:space="preserve"><value>Οι επιλεγμένες ακολουθίες δεν έχουν τίποτα για λήψη από τον διακομιστή.</value></data>
<data name="Library.Blocked.NothingToUpload" xml:space="preserve"><value>Ο διακομιστής έχει ήδη όσα περιέχουν οι επιλεγμένες ακολουθίες.</value></data>
<data name="Library.Blocked.OneArchive" xml:space="preserve"><value>Η αναδιοργάνωση αφορά τις ακολουθίες μίας μόνο αρχειοθήκης κάθε φορά.</value></data>
<data name="Library.Blocked.OneArchiveConvert" xml:space="preserve"><value>Η μετατροπή αφορά τις ακολουθίες μίας μόνο αρχειοθήκης κάθε φορά.</value></data>
<data name="Library.Blocked.ServerOnly" xml:space="preserve"><value>Μόνο για ακολουθίες σε αυτόν τον υπολογιστή. Η επιλογή βρίσκεται στον διακομιστή.</value></data>
<data name="Library.Blocked.Transferring" xml:space="preserve"><value>Μια μεταφορά αυτής της ακολουθίας βρίσκεται ήδη σε εξέλιξη.</value></data>
<data name="Library.ClearFilters" xml:space="preserve"><value>Απαλοιφή φίλτρων</value></data>
+4
View File
@@ -21,6 +21,8 @@
<data name="Server.Conflict.TakeServer.Message" xml:space="preserve"><value>Οι ρυθμίσεις της ακολουθίας {0} σε αυτόν τον υπολογιστή θα αντικατασταθούν από το αντίγραφο του διακομιστή.</value></data>
<data name="Server.Conflict.TakeServer.Title" xml:space="preserve"><value>Χρήση των ρυθμίσεων του διακομιστή;</value></data>
<data name="Server.Connect" xml:space="preserve"><value>Σύνδεση</value></data>
<data name="Server.Convert.OnPc" xml:space="preserve"><value>Μετατρέψτε αυτές τις φωτογραφίες σε έναν υπολογιστή: ο διακομιστής δεν μπορεί να τις διαβάσει σε πλήρη ανάλυση.</value></data>
<data name="Server.Convert.OnPcNew" xml:space="preserve"><value>Δεν αντιγράφονται στη νέα ακολουθία: ο διακομιστής δεν μπορεί να διαβάσει αυτές τις φωτογραφίες σε πλήρη ανάλυση. Μετατρέψτε τις σε έναν υπολογιστή.</value></data>
<data name="Server.Disconnect" xml:space="preserve"><value>Αποσύνδεση</value></data>
<data name="Server.Empty" xml:space="preserve"><value>Χωρίς σύνδεση σε διακομιστή</value></data>
<data name="Server.Error.AccountLocked" xml:space="preserve"><value>Πάρα πολλές αποτυχημένες είσοδοι. Ο λογαριασμός κλειδώθηκε για λίγο.</value></data>
@@ -71,7 +73,9 @@
<data name="Server.Error.MethodNotAllowed" xml:space="preserve"><value>Αυτή η μέθοδος δεν επιτρέπεται εδώ.</value></data>
<data name="Server.Error.NestedTarget" xml:space="preserve"><value>Ένας νέος φάκελος θα βρισκόταν μέσα στον φάκελο άλλης ακολουθίας.</value></data>
<data name="Server.Error.NotChronos" xml:space="preserve"><value>Αυτή η διεύθυνση δεν είναι Chronos Server.</value></data>
<data name="Server.Error.NotEnoughSpace" xml:space="preserve"><value>Ο τόμος της αρχειοθήκης δεν έχει τον χώρο που χρειάζεται η μετατροπή.</value></data>
<data name="Server.Error.NotFound" xml:space="preserve"><value>Δεν βρέθηκε.</value></data>
<data name="Server.Error.NothingToConvert" xml:space="preserve"><value>Το σχέδιο δεν μετατρέπει τίποτα: όλες οι φωτογραφίες παραλείπονται ή όλες οι ακολουθίες είναι αποκλεισμένες.</value></data>
<data name="Server.Error.PasswordChangeRequired" xml:space="preserve"><value>Αλλάξτε πρώτα τον κωδικό πρόσβασής σας.</value></data>
<data name="Server.Error.PhotoRemoved" xml:space="preserve"><value>Η φωτογραφία διαγράφηκε από την ακολουθία ενώ γινόταν η αποστολή της, οπότε δεν προστέθηκε.</value></data>
<data name="Server.Error.PhotoUnreadable" xml:space="preserve"><value>Δεν είναι δυνατή η ανάγνωση του αρχείου {0} και, χωρίς το hash του, τα άλλα αντίγραφα δεν θα μάθαιναν ότι διαγράφηκε. Κλείστε το πρόγραμμα που το χρησιμοποιεί ή ελέγξτε τα δικαιώματά του και δοκιμάστε ξανά.</value></data>
+19 -1
View File
@@ -27,6 +27,21 @@
<data name="Tooltips.Archive.ClearFilter" xml:space="preserve"><value>Εμφάνιση ξανά όλων των ακολουθιών της επιλογής</value></data>
<data name="Tooltips.Archive.CloseDialog" xml:space="preserve"><value>Κλείσιμο χωρίς καμία αλλαγή · Esc</value></data>
<data name="Tooltips.Archive.Collapse" xml:space="preserve"><value>Απόκρυψη των ακολουθιών αυτού του έτους</value></data>
<data name="Tooltips.Archive.ConvertApplyNew" xml:space="preserve"><value>Επιβεβαίωση και μετά τοποθέτηση στην ουρά μιας εργασίας που μετατρέπει αντίγραφα σε νέες ακολουθίες · παύση και συνέχισή της από τις Εργασίες</value></data>
<data name="Tooltips.Archive.ConvertApplyReplace" xml:space="preserve"><value>Πληκτρολόγηση του αριθμού των φωτογραφιών για επιβεβαίωση και μετά τοποθέτηση στην ουρά μιας εργασίας που τις αντικαθιστά με τη μετατροπή τους · παύση και συνέχισή της από τις Εργασίες</value></data>
<data name="Tooltips.Archive.ConvertBack" xml:space="preserve"><value>Επιστροφή στο σχέδιο, δεν μετατρέπεται τίποτα</value></data>
<data name="Tooltips.Archive.ConvertDng" xml:space="preserve"><value>Γραμμικό DNG, 16 bit και χωρίς απώλειες · το διαβάζει κάθε πρόγραμμα επεξεργασίας RAW, η επιλογή για αρχειοθέτηση</value></data>
<data name="Tooltips.Archive.ConvertJpeg" xml:space="preserve"><value>JPEG 8 bit στην ποιότητα που ορίζεται παρακάτω · τα μικρότερα αρχεία, χάνεται λίγη λεπτομέρεια</value></data>
<data name="Tooltips.Archive.ConvertModeNew" xml:space="preserve"><value>Τα αντίγραφα που μετατρέπονται μπαίνουν σε μια νέα ακολουθία δίπλα σε κάθε αρχική. Τα πρωτότυπα μένουν ως έχουν</value></data>
<data name="Tooltips.Archive.ConvertModeReplace" xml:space="preserve"><value>Τα αρχεία που μετατρέπονται παίρνουν τη θέση των φωτογραφιών στις ακολουθίες τους. Τα πρωτότυπα πηγαίνουν στον κάδο της αρχειοθήκης και μπορούν να επαναφερθούν μέχρι να αδειάσει</value></data>
<data name="Tooltips.Archive.ConvertNew" xml:space="preserve"><value>Τοποθέτηση στην ουρά της εργασίας που μετατρέπει τις φωτογραφίες σε νέες ακολουθίες και επαληθεύει κάθε μετατροπή. Τα πρωτότυπα δεν αγγίζονται</value></data>
<data name="Tooltips.Archive.ConvertPlan" xml:space="preserve"><value>Οι ακολουθίες των οποίων οι φωτογραφίες αντικαθίστανται</value></data>
<data name="Tooltips.Archive.ConvertPlanNew" xml:space="preserve"><value>Οι ακολουθίες που αντιγράφονται σε νέες και οι φωτογραφίες που αφήνει έξω η καθεμία</value></data>
<data name="Tooltips.Archive.ConvertQuality" xml:space="preserve"><value>Ποιότητα JPEG από 1 έως 100 · το 95 διατηρεί τις λεπτές λεπτομέρειες, χαμηλότερη τιμή δίνει μικρότερα αρχεία</value></data>
<data name="Tooltips.Archive.ConvertReplace.one" xml:space="preserve"><value>Αντικατάσταση {0:N0} φωτογραφίας με τη μετατροπή της. Πληκτρολογήστε πρώτα τον παραπάνω αριθμό</value></data>
<data name="Tooltips.Archive.ConvertReplace.other" xml:space="preserve"><value>Αντικατάσταση {0:N0} φωτογραφιών με τη μετατροπή τους. Πληκτρολογήστε πρώτα τον παραπάνω αριθμό</value></data>
<data name="Tooltips.Archive.ConvertTiff" xml:space="preserve"><value>TIFF 16 bit με συμπίεση χωρίς απώλειες · μεγάλα αρχεία που ανοίγουν σε κάθε πρόγραμμα επεξεργασίας</value></data>
<data name="Tooltips.Archive.ConvertUndo" xml:space="preserve"><value>Επαναφορά των πρωτοτύπων από τον κάδο στη θέση των μετατροπών τους</value></data>
<data name="Tooltips.Archive.DeleteAction.one" xml:space="preserve"><value>Μετακίνηση {0:N0} ακολουθίας στον κάδο. Πληκτρολογήστε πρώτα τον παραπάνω αριθμό</value></data>
<data name="Tooltips.Archive.DeleteAction.other" xml:space="preserve"><value>Μετακίνηση {0:N0} ακολουθιών στον κάδο. Πληκτρολογήστε πρώτα τον παραπάνω αριθμό</value></data>
<data name="Tooltips.Archive.DeleteKeep" xml:space="preserve"><value>Καμία αλλαγή</value></data>
@@ -82,6 +97,7 @@
<data name="Tooltips.Archive.Scan" xml:space="preserve"><value>Σταδιακή σάρωση: νέα, τροποποιημένα και διαγραμμένα αρχεία βάσει ώρας τροποποίησης και μεγέθους</value></data>
<data name="Tooltips.Archive.Set" xml:space="preserve"><value>Τα επιλεγμένα έτη και ακολουθίες (όλα, αν δεν έχει επιλεγεί τίποτα), φιλτραρισμένα κατά κάμερα, κατάσταση ή ετικέτα</value></data>
<data name="Tooltips.Archive.SetAnalyse" xml:space="preserve"><value>Εκτέλεση της ανάλυσης σε βάθος σε κάθε ακολουθία του συνόλου</value></data>
<data name="Tooltips.Archive.SetConvert" xml:space="preserve"><value>Μετατροπή των φωτογραφιών του συνόλου σε JPEG, TIFF ή DNG · πρώτα δοκιμαστική εκτέλεση, μετά εργασία</value></data>
<data name="Tooltips.Archive.SetDelete" xml:space="preserve"><value>Μετακίνηση του συνόλου στον κάδο της αρχειοθήκης · εμφανίζει τη δοκιμαστική εκτέλεση και ζητά πληκτρολόγηση για επιβεβαίωση</value></data>
<data name="Tooltips.Archive.SetExport" xml:space="preserve"><value>Εξαγωγή του συνόλου ως CSV: μία γραμμή ανά ακολουθία</value></data>
<data name="Tooltips.Archive.SetProxies" xml:space="preserve"><value>Δημιουργία ή ανανέωση των proxy</value></data>
@@ -96,7 +112,7 @@
<data name="Tooltips.Archive.TitleTemplate" xml:space="preserve"><value>Πρότυπο τίτλου. Το πεδίο title είναι ο τρέχων τίτλος · ελέγχεται καθώς πληκτρολογείτε</value></data>
<data name="Tooltips.Archive.Trash" xml:space="preserve"><value>Οι ακολουθίες και οι φωτογραφίες που διαγράφηκαν από αυτήν την αρχειοθήκη, καθεμία με δυνατότητα επαναφοράς</value></data>
<data name="Tooltips.Archive.TrashEmpty" xml:space="preserve"><value>Οριστική διαγραφή των εγγραφών αυτού του κάδου, μετά από έλεγχο του περιεχομένου τους και πληκτρολόγηση για επιβεβαίωση</value></data>
<data name="Tooltips.Archive.TrashEmptyPlan" xml:space="preserve"><value>Τι διαγράφεται οριστικά από την αρχειοθήκη</value></data>
<data name="Tooltips.Archive.TrashEmptyPlan" xml:space="preserve"><value>Τι διαγράφεται οριστικά από την αρχειοθήκη. Τα πρωτότυπα των οποίων η μετατροπή διαγράφηκε μπορεί να είναι το τελευταίο αντίγραφο των φωτογραφιών τους</value></data>
<data name="Tooltips.Archive.TrashErase.one" xml:space="preserve"><value>Οριστική διαγραφή {0:N0} εγγραφής. Πληκτρολογήστε πρώτα τον παραπάνω αριθμό</value></data>
<data name="Tooltips.Archive.TrashErase.other" xml:space="preserve"><value>Οριστική διαγραφή {0:N0} εγγραφών. Πληκτρολογήστε πρώτα τον παραπάνω αριθμό</value></data>
<data name="Tooltips.Archive.TrashRestore" xml:space="preserve"><value>Επαναφορά αυτής της εγγραφής: μιας ακολουθίας στον φάκελό της και στη βιβλιοθήκη, φωτογραφιών στην ακολουθία τους μετά από έλεγχο του hash</value></data>
@@ -468,6 +484,8 @@
<data name="Tooltips.Library.List" xml:space="preserve"><value>Πίνακας με στήλες που ταξινομούνται</value></data>
<data name="Tooltips.Library.Mass.Analyse.one" xml:space="preserve"><value>Ανάλυση σε βάθος {0:N0} ακολουθίας σε αυτόν τον υπολογιστή · εκτελείται ως μία εργασία</value></data>
<data name="Tooltips.Library.Mass.Analyse.other" xml:space="preserve"><value>Ανάλυση σε βάθος {0:N0} ακολουθιών σε αυτόν τον υπολογιστή · εκτελείται ως μία εργασία</value></data>
<data name="Tooltips.Library.Mass.Convert.one" xml:space="preserve"><value>Μετατροπή των φωτογραφιών {0:N0} ακολουθίας σε JPEG, TIFF ή DNG · πρώτα δοκιμαστική εκτέλεση, μετά εργασία</value></data>
<data name="Tooltips.Library.Mass.Convert.other" xml:space="preserve"><value>Μετατροπή των φωτογραφιών {0:N0} ακολουθιών της αρχειοθήκης τους σε JPEG, TIFF ή DNG · πρώτα δοκιμαστική εκτέλεση, μετά εργασία</value></data>
<data name="Tooltips.Library.Mass.Delete.one" xml:space="preserve"><value>Μετακίνηση {0:N0} ακολουθίας στον κάδο της αρχειοθήκης της · εμφανίζει τη δοκιμαστική εκτέλεση και ζητά πληκτρολόγηση για επιβεβαίωση</value></data>
<data name="Tooltips.Library.Mass.Delete.other" xml:space="preserve"><value>Μετακίνηση {0:N0} ακολουθιών στον κάδο της αρχειοθήκης τους · εμφανίζει τη δοκιμαστική εκτέλεση και ζητά πληκτρολόγηση για επιβεβαίωση</value></data>
<data name="Tooltips.Library.Mass.Download.one" xml:space="preserve"><value>Λήψη από τον διακομιστή όσων λείπουν εδώ από {0:N0} ακολουθία (πρωτότυπα ή αποδόσεις) · εκτελείται ως εργασία μεταφοράς</value></data>
+74
View File
@@ -9,6 +9,7 @@
<data name="Admin.About.Title" xml:space="preserve"><value>Chronos Server</value></data>
<data name="Admin.About.Uptime" xml:space="preserve"><value>Running for</value></data>
<data name="Admin.About.Version" xml:space="preserve"><value>Version</value></data>
<data name="Admin.Activity.ArchiveConverted" xml:space="preserve"><value>{0} queued a conversion · {1}</value><comment>long</comment></data>
<data name="Admin.Activity.ArchiveReorganized" xml:space="preserve"><value>{0} reorganized the archive · {1}</value><comment>long</comment></data>
<data name="Admin.Activity.ArchiveSettings" xml:space="preserve"><value>{0} changed the archive layout</value><comment>long</comment></data>
<data name="Admin.Activity.FramesDeleted" xml:space="preserve"><value>{0} deleted {1}</value><comment>long</comment></data>
@@ -83,6 +84,73 @@
<data name="Admin.Common.TypeToConfirm.Tip" xml:space="preserve"><value>Type the name exactly as shown to confirm</value></data>
<data name="Admin.Common.TypeWord.Tip" xml:space="preserve"><value>Type the word exactly as shown; upper or lower case does not matter</value></data>
<data name="Admin.Common.TypeWordFirst.Tip" xml:space="preserve"><value>Type the word above first</value></data>
<data name="Admin.Convert.Action" xml:space="preserve"><value>Convert…</value></data>
<data name="Admin.Convert.Action.Tip" xml:space="preserve"><value>Convert the photos of the selected sequences to JPEG, TIFF-16 or linear DNG; a preview shows every sequence first</value></data>
<data name="Admin.Convert.Apply" xml:space="preserve"><value>Convert…</value></data>
<data name="Admin.Convert.Apply.Tip" xml:space="preserve"><value>Convert as the preview shows; a confirmation comes first</value></data>
<data name="Admin.Convert.Cancel.Tip" xml:space="preserve"><value>Close without converting anything</value></data>
<data name="Admin.Convert.ChooseMode" xml:space="preserve"><value>Choose Replace or New sequence to convert.</value><comment>long</comment></data>
<data name="Admin.Convert.ChooseMode.Tip" xml:space="preserve"><value>Choose Replace or New sequence first</value></data>
<data name="Admin.Convert.Column.Converted" xml:space="preserve"><value>Converted</value></data>
<data name="Admin.Convert.Column.NotCopied" xml:space="preserve"><value>Not copied</value></data>
<data name="Admin.Convert.Column.Sequence" xml:space="preserve"><value>Sequence</value></data>
<data name="Admin.Convert.Column.Size" xml:space="preserve"><value>Size</value></data>
<data name="Admin.Convert.Column.Unchanged" xml:space="preserve"><value>Unchanged</value></data>
<data name="Admin.Convert.Confirm.New" xml:space="preserve"><value>Convert</value></data>
<data name="Admin.Convert.Confirm.New.Tip" xml:space="preserve"><value>Queue the job that converts the photos into new sequences, each conversion verified; the originals are not touched</value></data>
<data name="Admin.Convert.Confirm.Replace" xml:space="preserve"><value>Replace</value></data>
<data name="Admin.Convert.Confirm.Replace.Tip" xml:space="preserve"><value>Queue the job that converts the photos, verifies each conversion and moves the originals to the trash</value></data>
<data name="Admin.Convert.ConfirmNew.one" xml:space="preserve"><value>{0} photo is converted into a copy in a new sequence; the original stays as it is.</value><comment>long</comment></data>
<data name="Admin.Convert.ConfirmNew.other" xml:space="preserve"><value>{0} photos are converted into copies in a new sequence beside each one; the originals stay as they are.</value><comment>long</comment></data>
<data name="Admin.Convert.ConfirmNewNotCopied.one" xml:space="preserve"><value>{0} photo is not copied into the new sequence, for the reason the preview gives.</value><comment>long</comment></data>
<data name="Admin.Convert.ConfirmNewNotCopied.other" xml:space="preserve"><value>{0} photos are not copied into the new sequences, for the reasons the preview gives.</value><comment>long</comment></data>
<data name="Admin.Convert.ConfirmNewTitle" xml:space="preserve"><value>Convert to {0} in new sequences?</value><comment>long</comment></data>
<data name="Admin.Convert.ConfirmReplace.one" xml:space="preserve"><value>{0} photo in {1} is replaced by its conversion; the original goes to the trash, restorable until it is emptied.</value><comment>long</comment></data>
<data name="Admin.Convert.ConfirmReplace.other" xml:space="preserve"><value>{0} photos in {1} are replaced by their conversions; the originals go to the trash, restorable until it is emptied.</value><comment>long</comment></data>
<data name="Admin.Convert.ConfirmReplaceTitle" xml:space="preserve"><value>Replace the originals with {0}?</value><comment>long</comment></data>
<data name="Admin.Convert.Format" xml:space="preserve"><value>Format</value></data>
<data name="Admin.Convert.Format.Jpeg" xml:space="preserve"><value>JPEG</value><comment>invariant: a file format's name</comment></data>
<data name="Admin.Convert.Format.Jpeg.Tip" xml:space="preserve"><value>8-bit JPEG with full colour detail at the quality set beside: the smallest files, opened by every program</value></data>
<data name="Admin.Convert.Format.LinearDng" xml:space="preserve"><value>Linear DNG</value></data>
<data name="Admin.Convert.Format.LinearDng.Tip" xml:space="preserve"><value>16-bit linear DNG compressed without loss: the archival choice, opened by raw editors</value></data>
<data name="Admin.Convert.Format.Tiff16" xml:space="preserve"><value>TIFF-16</value><comment>invariant: a file format's name</comment></data>
<data name="Admin.Convert.Format.Tiff16.Tip" xml:space="preserve"><value>16-bit sRGB TIFF compressed without loss: large files that keep every tone for editing</value></data>
<data name="Admin.Convert.Gone" xml:space="preserve"><value>A selected sequence is no longer in the archive; close and select again.</value><comment>long</comment></data>
<data name="Admin.Convert.Mode" xml:space="preserve"><value>Mode</value></data>
<data name="Admin.Convert.Mode.NewSequence" xml:space="preserve"><value>New sequence</value></data>
<data name="Admin.Convert.Mode.NewSequence.Tip" xml:space="preserve"><value>The converted copies go into a new sequence beside each one; the originals and their sequence stay exactly as they are</value></data>
<data name="Admin.Convert.Mode.Replace" xml:space="preserve"><value>Replace</value></data>
<data name="Admin.Convert.Mode.Replace.Tip" xml:space="preserve"><value>The converted files become the sequence's photos; the originals go to the archive's trash, restorable until it is emptied</value></data>
<data name="Admin.Convert.NoAnswer" xml:space="preserve"><value>The server did not answer: check on the Jobs page whether the conversion was queued before converting again.</value><comment>long</comment></data>
<data name="Admin.Convert.NoSpace.Tip" xml:space="preserve"><value>Free some space on the archive's volume first</value></data>
<data name="Admin.Convert.NotCopiedCount.one" xml:space="preserve"><value>{0} not copied</value><comment>a photo count a new sequence lacks</comment></data>
<data name="Admin.Convert.NotCopiedCount.other" xml:space="preserve"><value>{0} not copied</value><comment>a photo count a new sequence lacks</comment></data>
<data name="Admin.Convert.Nothing.Tip" xml:space="preserve"><value>Nothing in the preview converts</value></data>
<data name="Admin.Convert.NothingToConvert" xml:space="preserve"><value>Nothing to convert: every photo stays as it is, for the reasons shown.</value><comment>long</comment></data>
<data name="Admin.Convert.OpenJob" xml:space="preserve"><value>Open job</value></data>
<data name="Admin.Convert.OpenJob.Tip" xml:space="preserve"><value>Show the job and its log on the Jobs page</value></data>
<data name="Admin.Convert.PlanItem" xml:space="preserve"><value>{0} · {1} · {2}</value><comment>invariant; a sequence's title, the photos it converts, and their size before and after</comment></data>
<data name="Admin.Convert.PlanChanged" xml:space="preserve"><value>The archive changed since the preview; check the new one and apply again.</value><comment>long</comment></data>
<data name="Admin.Convert.PlanItemNotCopied" xml:space="preserve"><value>{0} · {1}</value><comment>invariant; a sequence of the New sequence confirmation (Admin.Convert.PlanItem), then the photos its new sequence lacks</comment></data>
<data name="Admin.Convert.Planning" xml:space="preserve"><value>Planning…</value></data>
<data name="Admin.Convert.Planning.Tip" xml:space="preserve"><value>The server reads every photo folder of the selection: a large archive takes minutes, and the preview appears once it is done</value></data>
<data name="Admin.Convert.PlanningFor" xml:space="preserve"><value>Planning… {0}</value><comment>{0} how long the dry run has taken so far, e.g. "2 min"</comment></data>
<data name="Admin.Convert.Preview" xml:space="preserve"><value>Preview</value></data>
<data name="Admin.Convert.Preview.Tip" xml:space="preserve"><value>What each sequence converts and leaves as it is, with the size before and after (an estimate); nothing has changed yet</value></data>
<data name="Admin.Convert.Quality" xml:space="preserve"><value>Quality</value></data>
<data name="Admin.Convert.Quality.Tip" xml:space="preserve"><value>JPEG quality from 1 to 100; 95 keeps fine detail, lower values make smaller files</value></data>
<data name="Admin.Convert.QualityRange" xml:space="preserve"><value>Write a whole number from 1 to 100.</value><comment>long</comment></data>
<data name="Admin.Convert.Queued" xml:space="preserve"><value>Conversion queued.</value></data>
<data name="Admin.Convert.ReplaceWord" xml:space="preserve"><value>replace</value><comment>the word typed to confirm replacing the originals, lower case</comment></data>
<data name="Admin.Convert.Size.Tip" xml:space="preserve"><value>Size of the photos converted now, then the estimate after</value></data>
<data name="Admin.Convert.SizeChange" xml:space="preserve"><value>{0} → {1}</value><comment>invariant; a size before and the estimated size after</comment></data>
<data name="Admin.Convert.SkippedPhotos" xml:space="preserve"><value>{0}: {1}</value><comment>long: a photo count, then why those photos stay as they are</comment></data>
<data name="Admin.Convert.Title.one" xml:space="preserve"><value>Convert {0} sequence</value></data>
<data name="Admin.Convert.Title.other" xml:space="preserve"><value>Convert {0} sequences</value></data>
<data name="Admin.Convert.TitleAll" xml:space="preserve"><value>Convert all sequences</value></data>
<data name="Admin.Convert.TooMany" xml:space="preserve"><value>Convert takes at most {0} sequences at once, or every sequence: clear the filters and select all.</value><comment>long</comment></data>
<data name="Admin.Convert.Totals" xml:space="preserve"><value>Sequences converted: {0} · photos: {1} · unchanged: {2} · size: {3} → {4}</value><comment>long</comment></data>
<data name="Admin.Convert.TotalsNew" xml:space="preserve"><value>Sequences converted: {0} · photos: {1} · not copied: {2} · size: {3} → {4}</value><comment>long: the totals with New sequence chosen; {2} the photos the new sequences lack</comment></data>
<data name="Admin.Dashboard.Activity" xml:space="preserve"><value>Recent activity</value></data>
<data name="Admin.Dashboard.AllLogs" xml:space="preserve"><value>All logs</value></data>
<data name="Admin.Dashboard.AllLogs.Tip" xml:space="preserve"><value>Open the audit log</value></data>
@@ -133,6 +201,7 @@
<data name="Admin.Job.Kind.Adopt" xml:space="preserve"><value>Adopt</value></data>
<data name="Admin.Job.Kind.Backup" xml:space="preserve"><value>Backup</value></data>
<data name="Admin.Job.Kind.Cleanup" xml:space="preserve"><value>Clean-up</value></data>
<data name="Admin.Job.Kind.Convert" xml:space="preserve"><value>Convert</value></data>
<data name="Admin.Job.Kind.DeepAnalyse" xml:space="preserve"><value>Deep analysis</value></data>
<data name="Admin.Job.Kind.Duplicates" xml:space="preserve"><value>Duplicates</value></data>
<data name="Admin.Job.Kind.EmptyTrash" xml:space="preserve"><value>Empty trash</value></data>
@@ -344,6 +413,7 @@
<data name="Admin.Login.SignIn.Tip" xml:space="preserve"><value>Sign in to administer this server</value></data>
<data name="Admin.Login.User" xml:space="preserve"><value>User</value></data>
<data name="Admin.Login.User.Tip" xml:space="preserve"><value>Your user name on this server</value></data>
<data name="Admin.Logs.Action.ArchiveConverted" xml:space="preserve"><value>Photos converted</value></data>
<data name="Admin.Logs.Action.ArchiveReorganized" xml:space="preserve"><value>Archive reorganized</value></data>
<data name="Admin.Logs.Action.ArchiveSettings" xml:space="preserve"><value>Archive layout</value></data>
<data name="Admin.Logs.Action.FramesDeleted" xml:space="preserve"><value>Photos deleted</value></data>
@@ -795,6 +865,7 @@
<data name="Admin.Theme.Tip" xml:space="preserve"><value>Switch between light and dark</value></data>
<data name="Admin.Trash.Back" xml:space="preserve"><value>Library</value></data>
<data name="Admin.Trash.Back.Tip" xml:space="preserve"><value>Back to the Library</value></data>
<data name="Admin.Trash.ConversionDeleted" xml:space="preserve"><value>conversion deleted</value></data>
<data name="Admin.Trash.DeletedAt" xml:space="preserve"><value>Deleted</value></data>
<data name="Admin.Trash.DeletedBy" xml:space="preserve"><value>Deleted by</value></data>
<data name="Admin.Trash.Emptied" xml:space="preserve"><value>Trash emptied.</value><comment>long</comment></data>
@@ -822,9 +893,12 @@
<data name="Admin.Trash.PlanItem" xml:space="preserve"><value>{0} · {1} · {2}</value><comment>invariant; an entry's kind, title and size</comment></data>
<data name="Admin.Trash.Restore" xml:space="preserve"><value>Restore</value></data>
<data name="Admin.Trash.RestorePhotos.Tip" xml:space="preserve"><value>Put the photos back into their sequence (a new one if it is gone); each is checked against its SHA-256 first</value></data>
<data name="Admin.Trash.RestoreReplaced.Tip" xml:space="preserve"><value>Put the originals back in place of their conversions while those are unchanged (the conversions go to the trash), else into a new sequence; each is checked against its SHA-256 first</value></data>
<data name="Admin.Trash.RestoreSequence.Tip" xml:space="preserve"><value>Move the sequence's folder back into the library as it is (next to its old place if that is taken); its photos are not hash-checked: Verify does that</value></data>
<data name="Admin.Trash.RestoredNew.one" xml:space="preserve"><value>{0} photo restored into a new sequence.</value><comment>long</comment></data>
<data name="Admin.Trash.RestoredNew.other" xml:space="preserve"><value>{0} photos restored into a new sequence.</value><comment>long</comment></data>
<data name="Admin.Trash.RestoredOriginals.one" xml:space="preserve"><value>{0} original is back in {1}; its conversion is in the trash.</value><comment>long</comment></data>
<data name="Admin.Trash.RestoredOriginals.other" xml:space="preserve"><value>{0} originals are back in {1}; their conversions are in the trash.</value><comment>long</comment></data>
<data name="Admin.Trash.RestoredPhotos.one" xml:space="preserve"><value>{0} photo is back in {1}.</value><comment>long</comment></data>
<data name="Admin.Trash.RestoredPhotos.other" xml:space="preserve"><value>{0} photos are back in {1}.</value><comment>long</comment></data>
<data name="Admin.Trash.RestoredSequence" xml:space="preserve"><value>{0} is back in the library.</value><comment>long</comment></data>
+109 -3
View File
@@ -15,8 +15,10 @@
<data name="Archive.Blocked.Applying" xml:space="preserve"><value>Wait until the changes are applied.</value><comment>long</comment></data>
<data name="Archive.Blocked.EmptySet" xml:space="preserve"><value>The set is empty: change the selection or the filter.</value><comment>long</comment></data>
<data name="Archive.Blocked.NoChanges" xml:space="preserve"><value>Nothing would change.</value><comment>long</comment></data>
<data name="Archive.Blocked.NoMode" xml:space="preserve"><value>Choose Replace or New sequence.</value><comment>long</comment></data>
<data name="Archive.Blocked.NoTemplate" xml:space="preserve"><value>Turn on at least one template.</value><comment>long</comment></data>
<data name="Archive.Blocked.NotOnline" xml:space="preserve"><value>The archive must be online and writable.</value><comment>long</comment></data>
<data name="Archive.Blocked.NothingToConvert" xml:space="preserve"><value>Nothing to convert: every photo is skipped or every sequence is blocked.</value><comment>long</comment></data>
<data name="Archive.Blocked.Planning" xml:space="preserve"><value>Wait for the dry run.</value><comment>long</comment></data>
<data name="Archive.Blocked.Reading" xml:space="preserve"><value>Wait until the archive is read.</value><comment>long</comment></data>
<data name="Archive.Blocked.Searching" xml:space="preserve"><value>A search is running; cancel it or wait.</value><comment>long</comment></data>
@@ -35,6 +37,83 @@
<data name="Archive.Confirm.Remove" xml:space="preserve"><value>Remove row</value></data>
<data name="Archive.Confirm.RemoveHeading" xml:space="preserve"><value>Remove {0} from the index?</value><comment>long</comment></data>
<data name="Archive.Confirm.RemoveMessage" xml:space="preserve"><value>Its sidecar is gone. Only the index row is removed; no file is deleted.</value><comment>long</comment></data>
<data name="Archive.Convert.AlreadyQueued" xml:space="preserve"><value>A conversion of these sequences is already waiting or running; follow it in Jobs.</value><comment>long: error sentence; nothing was queued</comment></data>
<data name="Archive.Convert.Blocked.Busy" xml:space="preserve"><value>A job is working on this sequence; convert it once the job is done.</value><comment>long: why a sequence is not converted in a conversion dry run</comment></data>
<data name="Archive.Convert.Blocked.FramesChanged" xml:space="preserve"><value>The sequence changed after the plan; review the plan again.</value><comment>long: why a sequence is not converted in a conversion dry run</comment></data>
<data name="Archive.Convert.Blocked.Offline" xml:space="preserve"><value>The archive is offline or read-only.</value><comment>long: why a sequence is not converted in a conversion dry run</comment></data>
<data name="Archive.Convert.Blocked.Unreadable" xml:space="preserve"><value>The sequence file cannot be read.</value><comment>long: why a sequence is not converted in a conversion dry run</comment></data>
<data name="Archive.Convert.Confirm" xml:space="preserve"><value>Convert</value></data>
<data name="Archive.Convert.Done.one" xml:space="preserve"><value>{0:N0} sequence converted</value></data>
<data name="Archive.Convert.Done.other" xml:space="preserve"><value>{0:N0} sequences converted</value></data>
<data name="Archive.Convert.Failed.Changed" xml:space="preserve"><value>The photo no longer matches the copy that was archived; verify the sequence.</value><comment>long: why a photo was not converted, in the job log</comment></data>
<data name="Archive.Convert.Failed.ColorProfile" xml:space="preserve"><value>Its colour profile can be neither kept nor converted in this format.</value><comment>long: why a photo was not converted, in the job log</comment></data>
<data name="Archive.Convert.Failed.Damaged" xml:space="preserve"><value>Its pixels hold values that are not numbers: the file is damaged.</value><comment>long: why a photo was not converted, in the job log</comment></data>
<data name="Archive.Convert.Failed.EightBit" xml:space="preserve"><value>This computer develops this RAW at 8 bits only, too few for a 16-bit file; JPEG converts it.</value><comment>long: why a photo was not converted, in the job log</comment></data>
<data name="Archive.Convert.Failed.Full" xml:space="preserve"><value>The archive's disk is full.</value><comment>long: why a photo was not converted, in the job log</comment></data>
<data name="Archive.Convert.Failed.NoDecoder" xml:space="preserve"><value>No decoder on this computer reads it at full resolution.</value><comment>long: why a photo was not converted, in the job log</comment></data>
<data name="Archive.Convert.Failed.NotVerified" xml:space="preserve"><value>The converted file did not read back as it was written.</value><comment>long: why a photo was not converted, in the job log</comment></data>
<data name="Archive.Convert.Failed.Other" xml:space="preserve"><value>The converted file could not be made.</value><comment>long: why a photo was not converted, in the job log</comment></data>
<data name="Archive.Convert.Failed.PreviewOnly" xml:space="preserve"><value>This computer reads it only from its embedded preview: convert it on a PC that reads it at full resolution.</value><comment>long: why a photo was not converted, in the job log</comment></data>
<data name="Archive.Convert.Failed.TooLarge" xml:space="preserve"><value>It is larger than this format holds, than Chronos reads back or than the memory for one photo can hold.</value><comment>long: why a photo was not converted, in the job log</comment></data>
<data name="Archive.Convert.Failed.Unreadable" xml:space="preserve"><value>The photo could not be decoded.</value><comment>long: why a photo was not converted, in the job log</comment></data>
<data name="Archive.Convert.Format" xml:space="preserve"><value>Format</value></data>
<data name="Archive.Convert.Heading.one" xml:space="preserve"><value>Convert {0:N0} sequence</value></data>
<data name="Archive.Convert.Heading.other" xml:space="preserve"><value>Convert {0:N0} sequences</value></data>
<data name="Archive.Convert.HeadingAll" xml:space="preserve"><value>Convert {0}</value><comment>long: dialog heading; {0} archive name</comment></data>
<data name="Archive.Convert.Mode" xml:space="preserve"><value>Mode</value></data>
<data name="Archive.Convert.NewHeading.one" xml:space="preserve"><value>Convert {0:N0} sequence into a new one?</value><comment>long</comment></data>
<data name="Archive.Convert.NewHeading.other" xml:space="preserve"><value>Convert {0:N0} sequences into new ones?</value><comment>long</comment></data>
<data name="Archive.Convert.NewLeftOut.one" xml:space="preserve"><value>{0:N0} photo is not copied: it stays in its source alone, for the reason the plan gives.</value><comment>long: the photos a conversion into new sequences leaves out of them</comment></data>
<data name="Archive.Convert.NewLeftOut.other" xml:space="preserve"><value>{0:N0} photos are not copied: they stay in their source alone, for the reasons the plan gives.</value><comment>long: the photos a conversion into new sequences leaves out of them</comment></data>
<data name="Archive.Convert.NewMessage" xml:space="preserve"><value>{0} ({1}) are converted to {2} into a new sequence beside each source; the originals stay as they are.</value><comment>long: {0} photos, e.g. "120 photos"; {1} their size; {2} the format, e.g. "Linear DNG"</comment></data>
<data name="Archive.Convert.NewSequence" xml:space="preserve"><value>New sequence</value></data>
<data name="Archive.Convert.NotCopied.ColorProfile" xml:space="preserve"><value>Photos whose colour profile this format can neither keep nor convert are not copied into the new sequence.</value><comment>long: why photos are not in the new sequence a conversion makes, in its dry run</comment></data>
<data name="Archive.Convert.NotCopied.EightBit" xml:space="preserve"><value>RAW photos this computer develops at 8 bits only are not copied into the new sequence; JPEG converts them.</value><comment>long: why photos are not in the new sequence a conversion makes, in its dry run</comment></data>
<data name="Archive.Convert.NotCopied.Inaccessible" xml:space="preserve"><value>Photos another program holds open, or that cannot be opened, are not copied into the new sequence; plan again once they are free.</value><comment>long: why photos are not in the new sequence a conversion makes, in its dry run</comment></data>
<data name="Archive.Convert.NotCopied.Missing" xml:space="preserve"><value>Missing photos are not copied into the new sequence.</value><comment>long: why photos are not in the new sequence a conversion makes, in its dry run</comment></data>
<data name="Archive.Convert.NotCopied.NoNativeDecoder" xml:space="preserve"><value>Photos of a format this computer cannot read at full resolution are not copied into the new sequence.</value><comment>long: why photos are not in the new sequence a conversion makes, in its dry run</comment></data>
<data name="Archive.Convert.NotCopied.PreviewOnly" xml:space="preserve"><value>Photos read only from their embedded preview here are not copied into the new sequence.</value><comment>long: why photos are not in the new sequence a conversion makes, in its dry run</comment></data>
<data name="Archive.Convert.NotCopied.SameFormat" xml:space="preserve"><value>Photos already in this format are not copied into the new sequence.</value><comment>long: why photos are not in the new sequence a conversion makes, in its dry run</comment></data>
<data name="Archive.Convert.NotCopied.TooLarge" xml:space="preserve"><value>Photos larger than this format holds or Chronos reads back are not copied into the new sequence.</value><comment>long: why photos are not in the new sequence a conversion makes, in its dry run</comment></data>
<data name="Archive.Convert.NotCopied.Undecodable" xml:space="preserve"><value>Unreadable photos are not copied into the new sequence.</value><comment>long: why photos are not in the new sequence a conversion makes, in its dry run</comment></data>
<data name="Archive.Convert.NotCopied.Unhashed" xml:space="preserve"><value>Photos never verified are not copied into the new sequence; verify the sequence first.</value><comment>long: why photos are not in the new sequence a conversion makes, in its dry run</comment></data>
<data name="Archive.Convert.NotCopiedPhotos.one" xml:space="preserve"><value>{0:N0} not copied</value><comment>photos a conversion into a new sequence leaves out of it</comment></data>
<data name="Archive.Convert.NotCopiedPhotos.other" xml:space="preserve"><value>{0:N0} not copied</value><comment>photos a conversion into a new sequence leaves out of it</comment></data>
<data name="Archive.Convert.NotPlaced" xml:space="preserve"><value>The converted photos could not take their place. {0}</value><comment>long: job log; {0} why (one sentence)</comment></data>
<data name="Archive.Convert.PhotoFailed" xml:space="preserve"><value>{0} could not be converted. {1}</value><comment>long: job log; {0} the photo's file, {1} why (one sentence)</comment></data>
<data name="Archive.Convert.CopyUnfinished" xml:space="preserve"><value>Another conversion made a copy of it in this format and has not finished; finish or retry that one first.</value><comment>long: job log, why a sequence was left as it was (one sentence)</comment></data>
<data name="Archive.Convert.PhotoHeld" xml:space="preserve"><value>A photo of it is held open by another program or cannot be opened; retry once it is free.</value><comment>long: job log, why a sequence was left as it was (one sentence)</comment></data>
<data name="Archive.Convert.Quality" xml:space="preserve"><value>Quality</value></data>
<data name="Archive.Convert.Replace" xml:space="preserve"><value>Replace</value></data>
<data name="Archive.Convert.ReplaceHeading.one" xml:space="preserve"><value>Replace the photos of {0:N0} sequence?</value><comment>long</comment></data>
<data name="Archive.Convert.ReplaceHeading.other" xml:space="preserve"><value>Replace the photos of {0:N0} sequences?</value><comment>long</comment></data>
<data name="Archive.Convert.ReplaceMessage" xml:space="preserve"><value>{0} ({1}) are replaced by their conversion to {2}; the originals move to the archive's trash and can be restored until it is emptied.</value><comment>long: {0} photos, e.g. "120 photos"; {1} their size; {2} the format, e.g. "Linear DNG"</comment></data>
<data name="Archive.Convert.Sizes" xml:space="preserve"><value>{0} → {1}</value><comment>sizes before and after a conversion</comment></data>
<data name="Archive.Convert.Skipped.ColorProfile" xml:space="preserve"><value>Photos whose colour profile this format can neither keep nor convert stay as they are.</value><comment>long: why photos are not converted in a conversion dry run</comment></data>
<data name="Archive.Convert.Skipped.EightBit" xml:space="preserve"><value>RAW photos this computer develops at 8 bits only stay as they are; JPEG converts them.</value><comment>long: why photos are not converted in a conversion dry run</comment></data>
<data name="Archive.Convert.Skipped.Inaccessible" xml:space="preserve"><value>Photos another program holds open, or that cannot be opened, stay as they are; plan again once they are free.</value><comment>long: why photos are not converted in a conversion dry run</comment></data>
<data name="Archive.Convert.Skipped.Missing" xml:space="preserve"><value>Missing photos stay as they are.</value><comment>long: why photos are not converted in a conversion dry run</comment></data>
<data name="Archive.Convert.Skipped.NoNativeDecoder" xml:space="preserve"><value>Photos of a format this computer cannot read at full resolution stay as they are.</value><comment>long: why photos are not converted in a conversion dry run</comment></data>
<data name="Archive.Convert.Skipped.PreviewOnly" xml:space="preserve"><value>Photos read only from their embedded preview here stay as they are.</value><comment>long: why photos are not converted in a conversion dry run</comment></data>
<data name="Archive.Convert.Skipped.SameFormat" xml:space="preserve"><value>Photos already in this format stay as they are.</value><comment>long: why photos are not converted in a conversion dry run</comment></data>
<data name="Archive.Convert.Skipped.TooLarge" xml:space="preserve"><value>Photos larger than this format holds or Chronos reads back stay as they are.</value><comment>long: why photos are not converted in a conversion dry run</comment></data>
<data name="Archive.Convert.Skipped.Undecodable" xml:space="preserve"><value>Unreadable photos stay as they are.</value><comment>long: why photos are not converted in a conversion dry run</comment></data>
<data name="Archive.Convert.Skipped.Unhashed" xml:space="preserve"><value>Photos never verified stay as they are; verify the sequence first.</value><comment>long: why photos are not converted in a conversion dry run</comment></data>
<data name="Archive.Convert.SkippedPhotos.one" xml:space="preserve"><value>{0:N0} skipped</value><comment>photos a conversion leaves as they are</comment></data>
<data name="Archive.Convert.SkippedPhotos.other" xml:space="preserve"><value>{0:N0} skipped</value><comment>photos a conversion leaves as they are</comment></data>
<data name="Archive.Convert.Space" xml:space="preserve"><value>Needs {0}, free {1}</value><comment>long: free space line of a conversion dry run; {0} and {1} sizes</comment></data>
<data name="Archive.Convert.SpaceShort" xml:space="preserve"><value>Needs {0}, only {1} free: free some space first.</value><comment>long: free space line of a conversion dry run; {0} and {1} sizes</comment></data>
<data name="Archive.Convert.SpaceUnknown" xml:space="preserve"><value>Needs {0}; the free space cannot be measured.</value><comment>long: free space line of a conversion dry run; {0} size</comment></data>
<data name="Archive.Convert.Target.Jpeg" xml:space="preserve"><value>JPEG</value><comment>invariant</comment></data>
<data name="Archive.Convert.Target.LinearDng" xml:space="preserve"><value>Linear DNG</value></data>
<data name="Archive.Convert.Target.Tiff16" xml:space="preserve"><value>TIFF 16-bit</value></data>
<data name="Archive.Convert.UndoFailed" xml:space="preserve"><value>The originals could not come back</value><comment>long</comment></data>
<data name="Archive.Convert.UndoNothing" xml:space="preserve"><value>The replaced originals are no longer in the trash.</value><comment>long</comment></data>
<data name="Archive.Convert.Undone.one" xml:space="preserve"><value>Originals back in {0:N0} sequence</value><comment>long</comment></data>
<data name="Archive.Convert.Undone.other" xml:space="preserve"><value>Originals back in {0:N0} sequences</value><comment>long</comment></data>
<data name="Archive.Convert.UndoneNew.one" xml:space="preserve"><value>{0:N0} sequence had changed since: its originals came back as a new sequence.</value><comment>long</comment></data>
<data name="Archive.Convert.UndoneNew.other" xml:space="preserve"><value>{0:N0} sequences had changed since: their originals came back as new sequences.</value><comment>long</comment></data>
<data name="Archive.Convert.Unstaged" xml:space="preserve"><value>The conversion of {0} is no longer among the staged files; the retry converts it again.</value><comment>long: job log, why a new sequence was not made (one sentence); {0} the photo's file</comment></data>
<data name="Archive.Copy.Title" xml:space="preserve"><value>Folder to copy into the archive</value><comment>long</comment></data>
<data name="Archive.Delete.Action" xml:space="preserve"><value>Move to trash</value></data>
<data name="Archive.Delete.Blocked" xml:space="preserve"><value>Not moved: {0} · {1}</value><comment>long</comment></data>
@@ -80,6 +159,9 @@
<data name="Archive.Duplicates.Title" xml:space="preserve"><value>Duplicates</value></data>
<data name="Archive.Empty" xml:space="preserve"><value>No archive yet</value></data>
<data name="Archive.Error.Busy" xml:space="preserve"><value>Another Chronos ({0}) is writing here. Try again shortly.</value><comment>long: error sentence</comment></data>
<data name="Archive.Error.ConvertKept.one" xml:space="preserve"><value>{0:N0} sequence was not converted as planned; the job log says why.</value><comment>long: error sentence of a conversion job</comment></data>
<data name="Archive.Error.ConvertKept.other" xml:space="preserve"><value>{0:N0} sequences were not converted as planned; the job log says why.</value><comment>long: error sentence of a conversion job</comment></data>
<data name="Archive.Error.ConvertSpace" xml:space="preserve"><value>The conversion needs {0} free on the archive's volume, and {1} are free.</value><comment>long: error sentence of a conversion job; {0} and {1} sizes</comment></data>
<data name="Archive.Error.CopyMismatch" xml:space="preserve"><value>The copy of {0} does not match the original.</value><comment>long: error sentence</comment></data>
<data name="Archive.Error.DuplicateLost" xml:space="preserve"><value>{0} could not be added to the sequence.</value><comment>long: error sentence</comment></data>
<data name="Archive.Error.InLibrary" xml:space="preserve"><value>{0} is already in the library.</value><comment>long: error sentence</comment></data>
@@ -97,8 +179,8 @@
<data name="Archive.Error.SourceGone" xml:space="preserve"><value>The card or folder {0} is no longer available.</value><comment>long: error sentence</comment></data>
<data name="Archive.Error.StalePlan" xml:space="preserve"><value>The archive changed after this plan was made.</value><comment>long: error sentence</comment></data>
<data name="Archive.Error.TrashChanged" xml:space="preserve"><value>The trash changed after it was checked; nothing was erased.</value><comment>long: error sentence</comment></data>
<data name="Archive.Error.TrashKept.one" xml:space="preserve"><value>{0:N0} trash entry was kept: it changed, or a replacement no longer matches.</value><comment>long: error sentence of an emptying job</comment></data>
<data name="Archive.Error.TrashKept.other" xml:space="preserve"><value>{0:N0} trash entries were kept: they changed, or a replacement no longer matches.</value><comment>long: error sentence of an emptying job</comment></data>
<data name="Archive.Error.TrashKept.one" xml:space="preserve"><value>{0:N0} trash entry was kept; the job log says why.</value><comment>long: error sentence of an emptying job</comment></data>
<data name="Archive.Error.TrashKept.other" xml:space="preserve"><value>{0:N0} trash entries were kept; the job log says why.</value><comment>long: error sentence of an emptying job</comment></data>
<data name="Archive.Error.TrashMismatch" xml:space="preserve"><value>No file of this trash entry matches its record any more; it stays in the trash.</value><comment>long: error sentence</comment></data>
<data name="Archive.Failed.Access" xml:space="preserve"><value>Chronos was denied access to the archive.</value><comment>long</comment></data>
<data name="Archive.Failed.Files" xml:space="preserve"><value>A file of the archive could not be read or written.</value><comment>long</comment></data>
@@ -137,6 +219,15 @@
<data name="Archive.Log.AuditKept" xml:space="preserve"><value>Audit log kept in full</value><comment>long: job log line; a clean-up step whose age limit is 0</comment></data>
<data name="Archive.Log.AuditPurged" xml:space="preserve"><value>Audit entries removed: {0}</value><comment>long: job log line</comment></data>
<data name="Archive.Log.BackupDone" xml:space="preserve"><value>Index copied to {0} ({1}); copies kept: {2}</value><comment>long: job log line; {0} file path; {1} size, e.g. "12.4 MB"</comment></data>
<data name="Archive.Log.ConvertBlocked" xml:space="preserve"><value>Left as it was, busy or unreadable: {0}</value><comment>long: job log line; {0} sequence title</comment></data>
<data name="Archive.Log.ConvertChanged" xml:space="preserve"><value>Left as it was, changed after the plan: {0}. A retry leaves it as it is: convert it again from a new plan.</value><comment>long: job log line; {0} sequence title</comment></data>
<data name="Archive.Log.ConvertDone" xml:space="preserve"><value>Sequences converted: {0}, new sequences: {1}, photos: {2}</value><comment>long: job log line of a conversion</comment></data>
<data name="Archive.Log.ConvertFailed" xml:space="preserve"><value>Left as it was: {0}. {1}</value><comment>long: job log line; {0} sequence title, {1} what failed and why (sentences)</comment></data>
<data name="Archive.Log.ConvertLeftOut" xml:space="preserve"><value>{0}: photos not converted, left in the source alone: {1}</value><comment>long: job log line after a conversion into a new sequence; {0} sequence title, {1} photos</comment></data>
<data name="Archive.Log.ConvertNothing" xml:space="preserve"><value>Nothing to convert: {0}</value><comment>long: job log line; {0} sequence title</comment></data>
<data name="Archive.Log.ConvertSuperseded" xml:space="preserve"><value>{0}: another conversion made its copy in this format since this one was confirmed; no second copy is made.</value><comment>long: job log line of a conversion into new sequences; {0} sequence title</comment></data>
<data name="Archive.Log.Converted" xml:space="preserve"><value>{0}: photos replaced by their conversion: {1}</value><comment>long: job log line; {0} sequence title, {1} photos</comment></data>
<data name="Archive.Log.ConvertedNew" xml:space="preserve"><value>{0}: photos converted into a new sequence: {1}</value><comment>long: job log line; {0} sequence title, {1} photos</comment></data>
<data name="Archive.Log.DryRun" xml:space="preserve"><value>Dry run: nothing was changed.</value><comment>long: job log line</comment></data>
<data name="Archive.Log.DuplicateGroup" xml:space="preserve"><value>Extra copies of {0}: {1}</value><comment>long: job log line; {0} path of the first photo of a group sharing one hash</comment></data>
<data name="Archive.Log.DuplicatesDone" xml:space="preserve"><value>Duplicate groups: {0}, extra copies: {1}</value><comment>long: job log line</comment></data>
@@ -171,9 +262,22 @@
<data name="Archive.Log.SequenceMissing" xml:space="preserve"><value>Sequence not found: {0}</value><comment>long: job log line</comment></data>
<data name="Archive.Log.StepFailed" xml:space="preserve"><value>Clean-up step {0} failed: {1}</value><comment>long: job log line; {0} step name (job-history, audit…); {1} error message</comment></data>
<data name="Archive.Log.StepUnknown" xml:space="preserve"><value>Clean-up step unknown here: {0}</value><comment>long: job log line; {0} step name</comment></data>
<data name="Archive.Log.SyncChanged" xml:space="preserve"><value>{0}: changed since it was archived, not uploaded</value><comment>long: job log line of an upload; {0} file name</comment></data>
<data name="Archive.Log.SyncDeletedHere" xml:space="preserve"><value>{0}: deleted on this PC, not downloaded</value><comment>long: job log line of a download; {0} file name</comment></data>
<data name="Archive.Log.SyncDeletedThere" xml:space="preserve"><value>{0}: deleted on the server, not uploaded</value><comment>long: job log line of an upload; {0} file name</comment></data>
<data name="Archive.Log.SyncFrameChanged" xml:space="preserve"><value>{0}: its frame here changed meanwhile, not downloaded</value><comment>long: job log line of a download; {0} file name of the server's copy of a photo this PC holds in another encoding</comment></data>
<data name="Archive.Log.SyncMissing" xml:space="preserve"><value>{0}: missing, not uploaded</value><comment>long: job log line of an upload; {0} file name</comment></data>
<data name="Archive.Log.SyncNoPreview.one" xml:space="preserve"><value>{0:N0} frame has neither proxy nor thumbnail on the server</value><comment>long: job log line of a proxy download</comment></data>
<data name="Archive.Log.SyncNoPreview.other" xml:space="preserve"><value>{0:N0} frames have neither proxy nor thumbnail on the server</value><comment>long: job log line of a proxy download</comment></data>
<data name="Archive.Log.TrashEmptied" xml:space="preserve"><value>Entries erased: {0}, size: {1}</value><comment>long: job log line; {0} count; {1} size</comment></data>
<data name="Archive.Log.TrashEntry" xml:space="preserve"><value>In the trash since {0}: {1} ({2})</value><comment>long: job log line; {0} date; {1} sequence title; {2} size</comment></data>
<data name="Archive.Log.TrashKept" xml:space="preserve"><value>Kept in the trash: {0}</value><comment>long: job log line; {0} sequence title</comment></data>
<data name="Archive.Log.TrashKept" xml:space="preserve"><value>Kept in the trash, changed after the plan: {0}</value><comment>long: job log line of an emptying; {0} sequence title</comment></data>
<data name="Archive.Log.TrashKeptBusy" xml:space="preserve"><value>Kept in the trash, its sequence was busy: {0}</value><comment>long: job log line of an emptying; {0} sequence title</comment></data>
<data name="Archive.Log.TrashKeptMismatch" xml:space="preserve"><value>Kept in the trash, a conversion of its originals no longer matches: {0}</value><comment>long: job log line of an emptying; {0} sequence title</comment></data>
<data name="Archive.Log.TrashKeptStaleIndex" xml:space="preserve"><value>Kept in the trash, the index lists its sequence, which the archive no longer holds; rebuild the index: {0}</value><comment>long: job log line of an emptying; {0} sequence title</comment></data>
<data name="Archive.Log.TrashKeptUnhashed" xml:space="preserve"><value>Kept in the trash, a photo of its sequence was never verified; verify the sequence: {0}</value><comment>long: job log line of an emptying; {0} sequence title</comment></data>
<data name="Archive.Log.TrashKeptUnknown" xml:space="preserve"><value>Kept in the trash, the archive does not show what became of the conversion of its originals; restore it to keep them: {0}</value><comment>long: job log line of an emptying; {0} sequence title</comment></data>
<data name="Archive.Log.TrashKeptUnreadable" xml:space="preserve"><value>Kept in the trash, the sidecar of a folder that may hold its sequence is missing or cannot be read; scan the archive: {0}</value><comment>long: job log line of an emptying; {0} sequence title</comment></data>
<data name="Archive.Log.TrashOffline" xml:space="preserve"><value>Trash not checked: the archive cannot be reached</value><comment>long: job log line</comment></data>
<data name="Archive.Log.TrashReport" xml:space="preserve"><value>Old trash entries: {0}, size: {1}; nothing was deleted</value><comment>long: job log line; entries older than the clean-up's age limit</comment></data>
<data name="Archive.Log.VerifyDone" xml:space="preserve"><value>Photos checked: {0}, intact: {1}, hashed: {2}, with problems: {3}</value><comment>long: job log line</comment></data>
@@ -255,6 +359,7 @@
<data name="Archive.Set.All.other" xml:space="preserve"><value>{0:N0} sequences · all</value></data>
<data name="Archive.Set.Analyse" xml:space="preserve"><value>Analyse</value></data>
<data name="Archive.Set.ClearFilter" xml:space="preserve"><value>Clear filter</value></data>
<data name="Archive.Set.Convert" xml:space="preserve"><value>Convert…</value></data>
<data name="Archive.Set.Delete" xml:space="preserve"><value>Delete…</value></data>
<data name="Archive.Set.Export" xml:space="preserve"><value>Export CSV</value></data>
<data name="Archive.Set.Filter" xml:space="preserve"><value>Set filter</value></data>
@@ -285,6 +390,7 @@
<data name="Archive.Toolbar.Scan" xml:space="preserve"><value>Scan</value></data>
<data name="Archive.Toolbar.Verify" xml:space="preserve"><value>Verify</value></data>
<data name="Archive.Trash.Checking" xml:space="preserve"><value>Checking the trash…</value></data>
<data name="Archive.Trash.ConversionDeleted" xml:space="preserve"><value>conversion deleted</value></data>
<data name="Archive.Trash.Deleted" xml:space="preserve"><value>Deleted {0}</value><comment>long</comment></data>
<data name="Archive.Trash.Empty" xml:space="preserve"><value>The trash is empty</value><comment>long</comment></data>
<data name="Archive.Trash.EmptyAction" xml:space="preserve"><value>Empty…</value></data>
+1
View File
@@ -69,6 +69,7 @@
<data name="Jobs.Kind.Adopt" xml:space="preserve"><value>Adopt folder</value></data>
<data name="Jobs.Kind.Backup" xml:space="preserve"><value>Index backup</value></data>
<data name="Jobs.Kind.Cleanup" xml:space="preserve"><value>Clean-up</value></data>
<data name="Jobs.Kind.Convert" xml:space="preserve"><value>Convert</value></data>
<data name="Jobs.Kind.DeepAnalyse" xml:space="preserve"><value>Deep analysis</value></data>
<data name="Jobs.Kind.Download" xml:space="preserve"><value>Download</value></data>
<data name="Jobs.Kind.Duplicates" xml:space="preserve"><value>Duplicates</value></data>
+2
View File
@@ -6,6 +6,7 @@
<resheader name="writer"><value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader>
<data name="Library.Action.Analyse" xml:space="preserve"><value>Analyse</value></data>
<data name="Library.Action.ClearSelection" xml:space="preserve"><value>Clear selection</value></data>
<data name="Library.Action.Convert" xml:space="preserve"><value>Convert…</value></data>
<data name="Library.Action.Delete" xml:space="preserve"><value>Delete…</value></data>
<data name="Library.Action.Download" xml:space="preserve"><value>Download</value></data>
<data name="Library.Action.ExportList" xml:space="preserve"><value>Export list</value></data>
@@ -32,6 +33,7 @@
<data name="Library.Blocked.NothingToDownload" xml:space="preserve"><value>The selected sequences have nothing to fetch from the server.</value><comment>long</comment></data>
<data name="Library.Blocked.NothingToUpload" xml:space="preserve"><value>The server already has what the selected sequences hold.</value><comment>long</comment></data>
<data name="Library.Blocked.OneArchive" xml:space="preserve"><value>Reorganize works on the sequences of one archive at a time.</value><comment>long</comment></data>
<data name="Library.Blocked.OneArchiveConvert" xml:space="preserve"><value>Convert works on the sequences of one archive at a time.</value><comment>long</comment></data>
<data name="Library.Blocked.ServerOnly" xml:space="preserve"><value>Only for sequences on this PC; the selection lives on the server.</value><comment>long</comment></data>
<data name="Library.Blocked.Transferring" xml:space="preserve"><value>A transfer of this sequence is already under way.</value><comment>long</comment></data>
<data name="Library.ClearFilters" xml:space="preserve"><value>Clear filters</value></data>
+4
View File
@@ -23,6 +23,8 @@
<data name="Server.Conflict.TakeServer.Message" xml:space="preserve"><value>This PC's settings of {0} will be replaced by the server copy.</value><comment>long; {0} sequence title</comment></data>
<data name="Server.Conflict.TakeServer.Title" xml:space="preserve"><value>Take the server's settings?</value></data>
<data name="Server.Connect" xml:space="preserve"><value>Connect</value></data>
<data name="Server.Convert.OnPc" xml:space="preserve"><value>Convert these photos on a PC: the server cannot read them at full resolution.</value><comment>long: why photos are not converted in a conversion dry run on the server</comment></data>
<data name="Server.Convert.OnPcNew" xml:space="preserve"><value>Not copied into the new sequence: the server cannot read these photos at full resolution; convert them on a PC.</value><comment>long: why photos are not in the new sequence a conversion on the server makes, in its dry run</comment></data>
<data name="Server.Disconnect" xml:space="preserve"><value>Disconnect</value></data>
<data name="Server.Empty" xml:space="preserve"><value>Not connected to a server</value></data>
<data name="Server.Error.AccountLocked" xml:space="preserve"><value>Too many failed sign-ins; the account is locked for a while.</value><comment>long</comment></data>
@@ -72,8 +74,10 @@
<data name="Server.Error.LastAdmin" xml:space="preserve"><value>The last administrator cannot be removed or disabled.</value><comment>long</comment></data>
<data name="Server.Error.MethodNotAllowed" xml:space="preserve"><value>This method is not allowed here.</value><comment>long</comment></data>
<data name="Server.Error.NestedTarget" xml:space="preserve"><value>A new folder would lie inside the folder of another sequence.</value><comment>long</comment></data>
<data name="Server.Error.NotEnoughSpace" xml:space="preserve"><value>The archive's volume lacks the space the conversion needs.</value><comment>long</comment></data>
<data name="Server.Error.NotFound" xml:space="preserve"><value>Not found.</value><comment>long</comment></data>
<data name="Server.Error.NotChronos" xml:space="preserve"><value>That address is not a Chronos Server.</value><comment>long</comment></data>
<data name="Server.Error.NothingToConvert" xml:space="preserve"><value>The plan converts nothing: every photo is skipped or every sequence is blocked.</value><comment>long</comment></data>
<data name="Server.Error.PasswordChangeRequired" xml:space="preserve"><value>Change your password first.</value><comment>long</comment></data>
<data name="Server.Error.PhotoRemoved" xml:space="preserve"><value>The photo was deleted from the sequence while it was being uploaded, so it was not added.</value><comment>long</comment></data>
<data name="Server.Error.PhotoUnreadable" xml:space="preserve"><value>{0} cannot be read, and without its hash other copies would not learn it was deleted; close the program using it or check its permissions, then try again.</value><comment>long</comment></data>
+19 -1
View File
@@ -27,6 +27,21 @@
<data name="Tooltips.Archive.ClearFilter" xml:space="preserve"><value>Show every sequence of the selection again</value></data>
<data name="Tooltips.Archive.CloseDialog" xml:space="preserve"><value>Close without changing anything · Esc</value></data>
<data name="Tooltips.Archive.Collapse" xml:space="preserve"><value>Hide the sequences of this year</value></data>
<data name="Tooltips.Archive.ConvertApplyNew" xml:space="preserve"><value>Confirm, then queue a job that converts copies into new sequences · pause and resume it in Jobs</value></data>
<data name="Tooltips.Archive.ConvertApplyReplace" xml:space="preserve"><value>Type the number of photos to confirm, then queue a job that replaces them with their conversion · pause and resume it in Jobs</value></data>
<data name="Tooltips.Archive.ConvertBack" xml:space="preserve"><value>Back to the plan; nothing is converted</value></data>
<data name="Tooltips.Archive.ConvertDng" xml:space="preserve"><value>Linear DNG, 16-bit and lossless · read by every raw editor; the choice for archiving</value></data>
<data name="Tooltips.Archive.ConvertJpeg" xml:space="preserve"><value>8-bit JPEG at the quality below · the smallest files; some detail is lost</value></data>
<data name="Tooltips.Archive.ConvertModeNew" xml:space="preserve"><value>The converted copies go into a new sequence beside each one; the originals stay as they are</value></data>
<data name="Tooltips.Archive.ConvertModeReplace" xml:space="preserve"><value>The converted files take the photos' place in their sequences; the originals go to the archive's trash, restorable until it is emptied</value></data>
<data name="Tooltips.Archive.ConvertNew" xml:space="preserve"><value>Queue the job that converts the photos into new sequences, each conversion verified; the originals are not touched</value></data>
<data name="Tooltips.Archive.ConvertPlan" xml:space="preserve"><value>The sequences whose photos are replaced</value></data>
<data name="Tooltips.Archive.ConvertPlanNew" xml:space="preserve"><value>The sequences copied into new ones, and the photos each leaves out</value></data>
<data name="Tooltips.Archive.ConvertQuality" xml:space="preserve"><value>JPEG quality from 1 to 100 · 95 keeps fine detail; lower makes smaller files</value></data>
<data name="Tooltips.Archive.ConvertReplace.one" xml:space="preserve"><value>Replace {0:N0} photo with its conversion; type the number above first</value></data>
<data name="Tooltips.Archive.ConvertReplace.other" xml:space="preserve"><value>Replace {0:N0} photos with their conversion; type the number above first</value></data>
<data name="Tooltips.Archive.ConvertTiff" xml:space="preserve"><value>16-bit TIFF compressed without loss · large files every editor opens</value></data>
<data name="Tooltips.Archive.ConvertUndo" xml:space="preserve"><value>Put the originals back from the trash in place of their conversions</value></data>
<data name="Tooltips.Archive.DeleteAction.one" xml:space="preserve"><value>Move {0:N0} sequence to the trash; type the number above first</value></data>
<data name="Tooltips.Archive.DeleteAction.other" xml:space="preserve"><value>Move {0:N0} sequences to the trash; type the number above first</value></data>
<data name="Tooltips.Archive.DeleteKeep" xml:space="preserve"><value>Change nothing</value></data>
@@ -82,6 +97,7 @@
<data name="Tooltips.Archive.Scan" xml:space="preserve"><value>Incremental scan: new, changed and removed files by modification time and size</value></data>
<data name="Tooltips.Archive.Set" xml:space="preserve"><value>The selected years and sequences (all when nothing is selected), narrowed by camera, status or tag</value></data>
<data name="Tooltips.Archive.SetAnalyse" xml:space="preserve"><value>Run the deep analysis on every sequence in the set</value></data>
<data name="Tooltips.Archive.SetConvert" xml:space="preserve"><value>Convert the photos of the set to JPEG, TIFF or DNG · dry run first, then a job</value></data>
<data name="Tooltips.Archive.SetDelete" xml:space="preserve"><value>Move the set to the archive's trash · shows the dry run, then asks you to type to confirm</value></data>
<data name="Tooltips.Archive.SetExport" xml:space="preserve"><value>Export the set as CSV: one row per sequence</value></data>
<data name="Tooltips.Archive.SetProxies" xml:space="preserve"><value>Generate or refresh proxies</value></data>
@@ -96,7 +112,7 @@
<data name="Tooltips.Archive.TitleTemplate" xml:space="preserve"><value>Title template; the title token is the current title · checked as you type</value></data>
<data name="Tooltips.Archive.Trash" xml:space="preserve"><value>The sequences and photos deleted from this archive, each one restorable</value></data>
<data name="Tooltips.Archive.TrashEmpty" xml:space="preserve"><value>Erase the entries of this trash for good, after a check of what they hold and a typed confirmation</value></data>
<data name="Tooltips.Archive.TrashEmptyPlan" xml:space="preserve"><value>What is erased from the archive for good</value></data>
<data name="Tooltips.Archive.TrashEmptyPlan" xml:space="preserve"><value>What is erased from the archive for good; originals whose conversion was deleted may be the last copy of their photos</value></data>
<data name="Tooltips.Archive.TrashErase.one" xml:space="preserve"><value>Erase {0:N0} entry for good; type the number above first</value></data>
<data name="Tooltips.Archive.TrashErase.other" xml:space="preserve"><value>Erase {0:N0} entries for good; type the number above first</value></data>
<data name="Tooltips.Archive.TrashRestore" xml:space="preserve"><value>Move this entry back: a sequence into its folder and the library, photos into their sequence after a hash check</value></data>
@@ -469,6 +485,8 @@
<data name="Tooltips.Library.List" xml:space="preserve"><value>Table with sortable columns</value></data>
<data name="Tooltips.Library.Mass.Analyse.one" xml:space="preserve"><value>Deep analysis of {0:N0} sequence on this PC · runs as one job</value></data>
<data name="Tooltips.Library.Mass.Analyse.other" xml:space="preserve"><value>Deep analysis of {0:N0} sequences on this PC · runs as one job</value></data>
<data name="Tooltips.Library.Mass.Convert.one" xml:space="preserve"><value>Convert the photos of {0:N0} sequence to JPEG, TIFF or DNG · dry run first, then a job</value></data>
<data name="Tooltips.Library.Mass.Convert.other" xml:space="preserve"><value>Convert the photos of {0:N0} sequences of their archive to JPEG, TIFF or DNG · dry run first, then a job</value></data>
<data name="Tooltips.Library.Mass.Delete.one" xml:space="preserve"><value>Move {0:N0} sequence to its archive's trash · shows the dry run, then asks you to type to confirm</value></data>
<data name="Tooltips.Library.Mass.Delete.other" xml:space="preserve"><value>Move {0:N0} sequences to their archive's trash · shows the dry run, then asks you to type to confirm</value></data>
<data name="Tooltips.Library.Mass.Download.one" xml:space="preserve"><value>Fetch what {0:N0} sequence lacks here (originals or renders) from the server · runs as a transfer job</value></data>
+69
View File
@@ -9,6 +9,7 @@
<data name="Admin.About.Title" xml:space="preserve"><value>Chronos Server</value></data>
<data name="Admin.About.Uptime" xml:space="preserve"><value>Tiempo activo</value></data>
<data name="Admin.About.Version" xml:space="preserve"><value>Versión</value></data>
<data name="Admin.Activity.ArchiveConverted" xml:space="preserve"><value>{0} puso en cola una conversión · {1}</value></data>
<data name="Admin.Activity.ArchiveReorganized" xml:space="preserve"><value>{0} reorganizó la fototeca · {1}</value></data>
<data name="Admin.Activity.ArchiveSettings" xml:space="preserve"><value>{0} cambió la organización de la fototeca</value></data>
<data name="Admin.Activity.FramesDeleted" xml:space="preserve"><value>{0} eliminó {1}</value></data>
@@ -83,6 +84,68 @@
<data name="Admin.Common.TypeToConfirm.Tip" xml:space="preserve"><value>Escribe el nombre exactamente como se muestra para confirmar</value></data>
<data name="Admin.Common.TypeWord.Tip" xml:space="preserve"><value>Escribe la palabra exactamente como se muestra; no importan las mayúsculas ni las minúsculas</value></data>
<data name="Admin.Common.TypeWordFirst.Tip" xml:space="preserve"><value>Escribe primero la palabra de arriba</value></data>
<data name="Admin.Convert.Action" xml:space="preserve"><value>Convertir…</value></data>
<data name="Admin.Convert.Action.Tip" xml:space="preserve"><value>Convierte las fotos de las secuencias seleccionadas a JPEG, TIFF-16 o DNG lineal; una vista previa muestra antes cada secuencia</value></data>
<data name="Admin.Convert.Apply" xml:space="preserve"><value>Convertir…</value></data>
<data name="Admin.Convert.Apply.Tip" xml:space="preserve"><value>Convierte según muestra la vista previa; antes pide confirmación</value></data>
<data name="Admin.Convert.Cancel.Tip" xml:space="preserve"><value>Cierra sin convertir nada</value></data>
<data name="Admin.Convert.ChooseMode" xml:space="preserve"><value>Elige Sustituir o Nueva secuencia para convertir.</value></data>
<data name="Admin.Convert.ChooseMode.Tip" xml:space="preserve"><value>Elige primero Sustituir o Nueva secuencia</value></data>
<data name="Admin.Convert.Column.Converted" xml:space="preserve"><value>Convertidas</value></data>
<data name="Admin.Convert.Column.NotCopied" xml:space="preserve"><value>Sin copiar</value></data>
<data name="Admin.Convert.Column.Sequence" xml:space="preserve"><value>Secuencia</value></data>
<data name="Admin.Convert.Column.Size" xml:space="preserve"><value>Tamaño</value></data>
<data name="Admin.Convert.Column.Unchanged" xml:space="preserve"><value>Sin cambios</value></data>
<data name="Admin.Convert.Confirm.New" xml:space="preserve"><value>Convertir</value></data>
<data name="Admin.Convert.Confirm.New.Tip" xml:space="preserve"><value>Pone en cola la tarea que convierte las fotos en secuencias nuevas, verificando cada conversión; los originales no se tocan</value></data>
<data name="Admin.Convert.Confirm.Replace" xml:space="preserve"><value>Sustituir</value></data>
<data name="Admin.Convert.Confirm.Replace.Tip" xml:space="preserve"><value>Pone en cola la tarea que convierte las fotos, verifica cada conversión y mueve los originales a la papelera</value></data>
<data name="Admin.Convert.ConfirmNew.one" xml:space="preserve"><value>{0} foto se convierte en una copia dentro de una secuencia nueva; el original se queda como está.</value></data>
<data name="Admin.Convert.ConfirmNew.other" xml:space="preserve"><value>{0} fotos se convierten en copias dentro de una secuencia nueva junto a cada secuencia de origen; los originales se quedan como están.</value></data>
<data name="Admin.Convert.ConfirmNewNotCopied.one" xml:space="preserve"><value>{0} foto no se copia en la secuencia nueva, por el motivo que indica la vista previa.</value></data>
<data name="Admin.Convert.ConfirmNewNotCopied.other" xml:space="preserve"><value>{0} fotos no se copian en las secuencias nuevas, por los motivos que indica la vista previa.</value></data>
<data name="Admin.Convert.ConfirmNewTitle" xml:space="preserve"><value>¿Convertir a {0} en secuencias nuevas?</value></data>
<data name="Admin.Convert.ConfirmReplace.one" xml:space="preserve"><value>{0} foto de {1} se sustituye por su versión convertida; el original va a la papelera, donde se puede restaurar hasta que se vacíe.</value></data>
<data name="Admin.Convert.ConfirmReplace.other" xml:space="preserve"><value>{0} fotos de {1} se sustituyen por sus versiones convertidas; los originales van a la papelera, donde se pueden restaurar hasta que se vacíe.</value></data>
<data name="Admin.Convert.ConfirmReplaceTitle" xml:space="preserve"><value>¿Sustituir los originales por {0}?</value></data>
<data name="Admin.Convert.Format" xml:space="preserve"><value>Formato</value></data>
<data name="Admin.Convert.Format.Jpeg.Tip" xml:space="preserve"><value>JPEG de 8 bits con todo el detalle de color y la calidad indicada al lado: los archivos más pequeños, que abre cualquier programa</value></data>
<data name="Admin.Convert.Format.LinearDng" xml:space="preserve"><value>DNG lineal</value></data>
<data name="Admin.Convert.Format.LinearDng.Tip" xml:space="preserve"><value>DNG lineal de 16 bits comprimido sin pérdidas: la opción para archivar, que abren los editores RAW</value></data>
<data name="Admin.Convert.Format.Tiff16.Tip" xml:space="preserve"><value>TIFF sRGB de 16 bits comprimido sin pérdidas: archivos grandes que conservan todos los tonos para la edición</value></data>
<data name="Admin.Convert.Gone" xml:space="preserve"><value>Una secuencia seleccionada ya no está en la fototeca; cierra y vuelve a seleccionar.</value></data>
<data name="Admin.Convert.Mode" xml:space="preserve"><value>Modo</value></data>
<data name="Admin.Convert.Mode.NewSequence" xml:space="preserve"><value>Nueva secuencia</value></data>
<data name="Admin.Convert.Mode.NewSequence.Tip" xml:space="preserve"><value>Las copias convertidas van a una secuencia nueva junto a cada secuencia de origen; los originales y su secuencia se quedan exactamente como están</value></data>
<data name="Admin.Convert.Mode.Replace" xml:space="preserve"><value>Sustituir</value></data>
<data name="Admin.Convert.Mode.Replace.Tip" xml:space="preserve"><value>Los archivos convertidos pasan a ser las fotos de la secuencia; los originales van a la papelera de la fototeca, donde se pueden restaurar hasta que se vacíe</value></data>
<data name="Admin.Convert.NoAnswer" xml:space="preserve"><value>El servidor no respondió: comprueba en la página Tareas si la conversión se puso en cola antes de volver a convertir.</value></data>
<data name="Admin.Convert.NoSpace.Tip" xml:space="preserve"><value>Libera primero espacio en el volumen de la fototeca</value></data>
<data name="Admin.Convert.NotCopiedCount.one" xml:space="preserve"><value>{0} sin copiar</value></data>
<data name="Admin.Convert.NotCopiedCount.other" xml:space="preserve"><value>{0} sin copiar</value></data>
<data name="Admin.Convert.Nothing.Tip" xml:space="preserve"><value>En la vista previa no hay nada que convertir</value></data>
<data name="Admin.Convert.NothingToConvert" xml:space="preserve"><value>Nada que convertir: todas las fotos se quedan como están, por los motivos indicados.</value></data>
<data name="Admin.Convert.OpenJob" xml:space="preserve"><value>Abrir tarea</value></data>
<data name="Admin.Convert.OpenJob.Tip" xml:space="preserve"><value>Muestra la tarea y su registro en la página Tareas</value></data>
<data name="Admin.Convert.PlanChanged" xml:space="preserve"><value>La fototeca cambió desde la vista previa; revisa la nueva y vuelve a aplicar.</value></data>
<data name="Admin.Convert.Planning" xml:space="preserve"><value>Planificando…</value></data>
<data name="Admin.Convert.Planning.Tip" xml:space="preserve"><value>El servidor lee cada carpeta de fotos de la selección: con una fototeca grande tarda varios minutos, y la vista previa aparece cuando termina</value></data>
<data name="Admin.Convert.PlanningFor" xml:space="preserve"><value>Planificando… {0}</value></data>
<data name="Admin.Convert.Preview" xml:space="preserve"><value>Vista previa</value></data>
<data name="Admin.Convert.Preview.Tip" xml:space="preserve"><value>Lo que cada secuencia convierte y lo que deja como está, con el tamaño antes y después (una estimación); todavía no ha cambiado nada</value></data>
<data name="Admin.Convert.Quality" xml:space="preserve"><value>Calidad</value></data>
<data name="Admin.Convert.Quality.Tip" xml:space="preserve"><value>Calidad JPEG de 1 a 100; 95 conserva los detalles finos, los valores más bajos dan archivos más pequeños</value></data>
<data name="Admin.Convert.QualityRange" xml:space="preserve"><value>Escribe un número entero de 1 a 100.</value></data>
<data name="Admin.Convert.Queued" xml:space="preserve"><value>Conversión en cola.</value></data>
<data name="Admin.Convert.ReplaceWord" xml:space="preserve"><value>sustituir</value></data>
<data name="Admin.Convert.Size.Tip" xml:space="preserve"><value>Tamaño actual de las fotos que se convierten y, después, el estimado tras la conversión</value></data>
<data name="Admin.Convert.SkippedPhotos" xml:space="preserve"><value>{0}: {1}</value></data>
<data name="Admin.Convert.Title.one" xml:space="preserve"><value>Convertir {0} secuencia</value></data>
<data name="Admin.Convert.Title.other" xml:space="preserve"><value>Convertir {0} secuencias</value></data>
<data name="Admin.Convert.TitleAll" xml:space="preserve"><value>Convertir todas las secuencias</value></data>
<data name="Admin.Convert.TooMany" xml:space="preserve"><value>Convertir admite como máximo {0} secuencias a la vez, o todas: quita los filtros y selecciona todo.</value></data>
<data name="Admin.Convert.Totals" xml:space="preserve"><value>Secuencias convertidas: {0} · fotos: {1} · sin cambios: {2} · tamaño: {3} → {4}</value></data>
<data name="Admin.Convert.TotalsNew" xml:space="preserve"><value>Secuencias convertidas: {0} · fotos: {1} · sin copiar: {2} · tamaño: {3} → {4}</value></data>
<data name="Admin.Dashboard.Activity" xml:space="preserve"><value>Actividad reciente</value></data>
<data name="Admin.Dashboard.AllLogs" xml:space="preserve"><value>Todos los registros</value></data>
<data name="Admin.Dashboard.AllLogs.Tip" xml:space="preserve"><value>Abre el registro de auditoría</value></data>
@@ -133,6 +196,7 @@
<data name="Admin.Job.Kind.Adopt" xml:space="preserve"><value>Incorporación</value></data>
<data name="Admin.Job.Kind.Backup" xml:space="preserve"><value>Copia de seguridad</value></data>
<data name="Admin.Job.Kind.Cleanup" xml:space="preserve"><value>Limpieza</value></data>
<data name="Admin.Job.Kind.Convert" xml:space="preserve"><value>Conversión</value></data>
<data name="Admin.Job.Kind.DeepAnalyse" xml:space="preserve"><value>Análisis profundo</value></data>
<data name="Admin.Job.Kind.Duplicates" xml:space="preserve"><value>Duplicados</value></data>
<data name="Admin.Job.Kind.EmptyTrash" xml:space="preserve"><value>Vaciado de la papelera</value></data>
@@ -344,6 +408,7 @@
<data name="Admin.Login.SignIn.Tip" xml:space="preserve"><value>Inicia sesión para administrar este servidor</value></data>
<data name="Admin.Login.User" xml:space="preserve"><value>Usuario</value></data>
<data name="Admin.Login.User.Tip" xml:space="preserve"><value>Tu nombre de usuario en este servidor</value></data>
<data name="Admin.Logs.Action.ArchiveConverted" xml:space="preserve"><value>Fotos convertidas</value></data>
<data name="Admin.Logs.Action.ArchiveReorganized" xml:space="preserve"><value>Fototeca reorganizada</value></data>
<data name="Admin.Logs.Action.ArchiveSettings" xml:space="preserve"><value>Organización de la fototeca</value></data>
<data name="Admin.Logs.Action.FramesDeleted" xml:space="preserve"><value>Fotos eliminadas</value></data>
@@ -793,6 +858,7 @@
<data name="Admin.Theme.Tip" xml:space="preserve"><value>Cambia entre el tema claro y el oscuro</value></data>
<data name="Admin.Trash.Back" xml:space="preserve"><value>Biblioteca</value></data>
<data name="Admin.Trash.Back.Tip" xml:space="preserve"><value>Vuelve a la Biblioteca</value></data>
<data name="Admin.Trash.ConversionDeleted" xml:space="preserve"><value>conversión eliminada</value></data>
<data name="Admin.Trash.DeletedAt" xml:space="preserve"><value>Eliminación</value></data>
<data name="Admin.Trash.DeletedBy" xml:space="preserve"><value>Eliminado por</value></data>
<data name="Admin.Trash.Emptied" xml:space="preserve"><value>Papelera vaciada.</value></data>
@@ -819,9 +885,12 @@
<data name="Admin.Trash.Photos" xml:space="preserve"><value>Fotos</value></data>
<data name="Admin.Trash.Restore" xml:space="preserve"><value>Restaurar</value></data>
<data name="Admin.Trash.RestorePhotos.Tip" xml:space="preserve"><value>Devuelve las fotos a su secuencia (a una nueva si ya no existe); antes se comprueba cada una con su SHA-256</value></data>
<data name="Admin.Trash.RestoreReplaced.Tip" xml:space="preserve"><value>Devuelve los originales al lugar de sus versiones convertidas mientras estas no hayan cambiado (las versiones convertidas van a la papelera) o, si no, a una secuencia nueva; antes se comprueba cada uno con su SHA-256</value></data>
<data name="Admin.Trash.RestoreSequence.Tip" xml:space="preserve"><value>Devuelve la carpeta de la secuencia a la biblioteca tal como está (junto a su antiguo lugar si está ocupado); no se comprueba el hash de sus fotos: de eso se encarga Verificar</value></data>
<data name="Admin.Trash.RestoredNew.one" xml:space="preserve"><value>{0} foto restaurada en una secuencia nueva.</value></data>
<data name="Admin.Trash.RestoredNew.other" xml:space="preserve"><value>{0} fotos restauradas en una secuencia nueva.</value></data>
<data name="Admin.Trash.RestoredOriginals.one" xml:space="preserve"><value>{0} original vuelve a estar en {1}; su versión convertida está en la papelera.</value></data>
<data name="Admin.Trash.RestoredOriginals.other" xml:space="preserve"><value>{0} originales vuelven a estar en {1}; sus versiones convertidas están en la papelera.</value></data>
<data name="Admin.Trash.RestoredPhotos.one" xml:space="preserve"><value>{0} foto vuelve a estar en {1}.</value></data>
<data name="Admin.Trash.RestoredPhotos.other" xml:space="preserve"><value>{0} fotos vuelven a estar en {1}.</value></data>
<data name="Admin.Trash.RestoredSequence" xml:space="preserve"><value>{0} vuelve a estar en la biblioteca.</value></data>
+108 -3
View File
@@ -15,8 +15,10 @@
<data name="Archive.Blocked.Applying" xml:space="preserve"><value>Espera a que se apliquen los cambios.</value></data>
<data name="Archive.Blocked.EmptySet" xml:space="preserve"><value>El conjunto está vacío: cambia la selección o el filtro.</value></data>
<data name="Archive.Blocked.NoChanges" xml:space="preserve"><value>No cambiaría nada.</value></data>
<data name="Archive.Blocked.NoMode" xml:space="preserve"><value>Elige Sustituir o Nueva secuencia.</value></data>
<data name="Archive.Blocked.NoTemplate" xml:space="preserve"><value>Activa al menos una plantilla.</value></data>
<data name="Archive.Blocked.NotOnline" xml:space="preserve"><value>La fototeca debe estar en línea y admitir escritura.</value></data>
<data name="Archive.Blocked.NothingToConvert" xml:space="preserve"><value>Nada que convertir: todas las fotos se omiten o todas las secuencias están bloqueadas.</value></data>
<data name="Archive.Blocked.Planning" xml:space="preserve"><value>Espera a que termine la simulación.</value></data>
<data name="Archive.Blocked.Reading" xml:space="preserve"><value>Espera a que se lea la fototeca.</value></data>
<data name="Archive.Blocked.Searching" xml:space="preserve"><value>Hay una búsqueda en curso; cancélala o espera.</value></data>
@@ -32,6 +34,82 @@
<data name="Archive.Confirm.Remove" xml:space="preserve"><value>Quitar fila</value></data>
<data name="Archive.Confirm.RemoveHeading" xml:space="preserve"><value>¿Quitar {0} del índice?</value></data>
<data name="Archive.Confirm.RemoveMessage" xml:space="preserve"><value>Su archivo sidecar ya no existe. Solo se quita la fila del índice; no se elimina ningún archivo.</value></data>
<data name="Archive.Convert.AlreadyQueued" xml:space="preserve"><value>Ya hay una conversión de estas secuencias en espera o en curso; síguela en Tareas.</value></data>
<data name="Archive.Convert.Blocked.Busy" xml:space="preserve"><value>Una tarea está procesando esta secuencia; conviértela cuando la tarea termine.</value></data>
<data name="Archive.Convert.Blocked.FramesChanged" xml:space="preserve"><value>La secuencia cambió después del plan; vuelve a revisar el plan.</value></data>
<data name="Archive.Convert.Blocked.Offline" xml:space="preserve"><value>La fototeca está sin conexión o es de solo lectura.</value></data>
<data name="Archive.Convert.Blocked.Unreadable" xml:space="preserve"><value>No se puede leer el archivo de la secuencia.</value></data>
<data name="Archive.Convert.Confirm" xml:space="preserve"><value>Convertir</value></data>
<data name="Archive.Convert.CopyUnfinished" xml:space="preserve"><value>Otra conversión creó una copia de ella en este formato y no ha terminado; completa o reintenta esa primero.</value></data>
<data name="Archive.Convert.Done.one" xml:space="preserve"><value>{0:N0} secuencia convertida</value></data>
<data name="Archive.Convert.Done.other" xml:space="preserve"><value>{0:N0} secuencias convertidas</value></data>
<data name="Archive.Convert.Failed.Changed" xml:space="preserve"><value>La foto ya no coincide con la copia que se archivó; verifica la secuencia.</value></data>
<data name="Archive.Convert.Failed.ColorProfile" xml:space="preserve"><value>Su perfil de color no se puede conservar ni convertir en este formato.</value></data>
<data name="Archive.Convert.Failed.Damaged" xml:space="preserve"><value>Sus píxeles contienen valores que no son números: el archivo está dañado.</value></data>
<data name="Archive.Convert.Failed.EightBit" xml:space="preserve"><value>Este equipo revela este RAW solo a 8 bits, demasiado pocos para un archivo de 16 bits; se puede convertir a JPEG.</value></data>
<data name="Archive.Convert.Failed.Full" xml:space="preserve"><value>El disco de la fototeca está lleno.</value></data>
<data name="Archive.Convert.Failed.NoDecoder" xml:space="preserve"><value>Ningún decodificador de este equipo la lee a resolución completa.</value></data>
<data name="Archive.Convert.Failed.NotVerified" xml:space="preserve"><value>El archivo convertido no se leyó tal como se escribió.</value></data>
<data name="Archive.Convert.Failed.Other" xml:space="preserve"><value>No se pudo crear el archivo convertido.</value></data>
<data name="Archive.Convert.Failed.PreviewOnly" xml:space="preserve"><value>Este equipo solo la lee desde su vista previa incrustada: conviértela en un equipo que la lea a resolución completa.</value></data>
<data name="Archive.Convert.Failed.TooLarge" xml:space="preserve"><value>Es más grande de lo que admite este formato, de lo que Chronos puede volver a leer o de lo que cabe en la memoria para una foto.</value></data>
<data name="Archive.Convert.Failed.Unreadable" xml:space="preserve"><value>No se pudo decodificar la foto.</value></data>
<data name="Archive.Convert.Format" xml:space="preserve"><value>Formato</value></data>
<data name="Archive.Convert.Heading.one" xml:space="preserve"><value>Convertir {0:N0} secuencia</value></data>
<data name="Archive.Convert.Heading.other" xml:space="preserve"><value>Convertir {0:N0} secuencias</value></data>
<data name="Archive.Convert.HeadingAll" xml:space="preserve"><value>Convertir {0}</value></data>
<data name="Archive.Convert.Mode" xml:space="preserve"><value>Modo</value></data>
<data name="Archive.Convert.NewHeading.one" xml:space="preserve"><value>¿Convertir {0:N0} secuencia en una nueva?</value></data>
<data name="Archive.Convert.NewHeading.other" xml:space="preserve"><value>¿Convertir {0:N0} secuencias en otras nuevas?</value></data>
<data name="Archive.Convert.NewLeftOut.one" xml:space="preserve"><value>{0:N0} foto no se copia: se queda solo en su secuencia de origen, por el motivo que indica el plan.</value></data>
<data name="Archive.Convert.NewLeftOut.other" xml:space="preserve"><value>{0:N0} fotos no se copian: se quedan solo en su secuencia de origen, por los motivos que indica el plan.</value></data>
<data name="Archive.Convert.NewMessage" xml:space="preserve"><value>{0} ({1}) se convierten a {2} en una secuencia nueva junto a cada secuencia de origen; los originales se quedan como están.</value></data>
<data name="Archive.Convert.NewSequence" xml:space="preserve"><value>Nueva secuencia</value></data>
<data name="Archive.Convert.NotCopied.ColorProfile" xml:space="preserve"><value>Las fotos cuyo perfil de color este formato no puede conservar ni convertir no se copian en la secuencia nueva.</value></data>
<data name="Archive.Convert.NotCopied.EightBit" xml:space="preserve"><value>Las fotos RAW que este equipo solo revela a 8 bits no se copian en la secuencia nueva; se pueden convertir a JPEG.</value></data>
<data name="Archive.Convert.NotCopied.Inaccessible" xml:space="preserve"><value>Las fotos que otro programa mantiene abiertas, o que no se pueden abrir, no se copian en la secuencia nueva; vuelve a planificar cuando estén libres.</value></data>
<data name="Archive.Convert.NotCopied.Missing" xml:space="preserve"><value>Las fotos que faltan no se copian en la secuencia nueva.</value></data>
<data name="Archive.Convert.NotCopied.NoNativeDecoder" xml:space="preserve"><value>Las fotos de un formato que este equipo no puede leer a resolución completa no se copian en la secuencia nueva.</value></data>
<data name="Archive.Convert.NotCopied.PreviewOnly" xml:space="preserve"><value>Las fotos que aquí solo se leen desde su vista previa incrustada no se copian en la secuencia nueva.</value></data>
<data name="Archive.Convert.NotCopied.SameFormat" xml:space="preserve"><value>Las fotos que ya están en este formato no se copian en la secuencia nueva.</value></data>
<data name="Archive.Convert.NotCopied.TooLarge" xml:space="preserve"><value>Las fotos más grandes de lo que admite este formato o de lo que Chronos puede volver a leer no se copian en la secuencia nueva.</value></data>
<data name="Archive.Convert.NotCopied.Undecodable" xml:space="preserve"><value>Las fotos ilegibles no se copian en la secuencia nueva.</value></data>
<data name="Archive.Convert.NotCopied.Unhashed" xml:space="preserve"><value>Las fotos nunca verificadas no se copian en la secuencia nueva; verifica primero la secuencia.</value></data>
<data name="Archive.Convert.NotCopiedPhotos.one" xml:space="preserve"><value>{0:N0} sin copiar</value></data>
<data name="Archive.Convert.NotCopiedPhotos.other" xml:space="preserve"><value>{0:N0} sin copiar</value></data>
<data name="Archive.Convert.NotPlaced" xml:space="preserve"><value>Las fotos convertidas no pudieron ocupar el lugar de los originales. {0}</value></data>
<data name="Archive.Convert.PhotoFailed" xml:space="preserve"><value>No se pudo convertir {0}. {1}</value></data>
<data name="Archive.Convert.PhotoHeld" xml:space="preserve"><value>Otro programa mantiene abierta una de sus fotos o no se puede abrir; reintenta la tarea cuando la foto esté libre.</value></data>
<data name="Archive.Convert.Quality" xml:space="preserve"><value>Calidad</value></data>
<data name="Archive.Convert.Replace" xml:space="preserve"><value>Sustituir</value></data>
<data name="Archive.Convert.ReplaceHeading.one" xml:space="preserve"><value>¿Sustituir las fotos de {0:N0} secuencia?</value></data>
<data name="Archive.Convert.ReplaceHeading.other" xml:space="preserve"><value>¿Sustituir las fotos de {0:N0} secuencias?</value></data>
<data name="Archive.Convert.ReplaceMessage" xml:space="preserve"><value>{0} ({1}) se sustituyen por su conversión a {2}; los originales pasan a la papelera de la fototeca y se pueden restaurar hasta que se vacíe.</value></data>
<data name="Archive.Convert.Sizes" xml:space="preserve"><value>{0} → {1}</value></data>
<data name="Archive.Convert.Skipped.ColorProfile" xml:space="preserve"><value>Las fotos cuyo perfil de color este formato no puede conservar ni convertir se quedan como están.</value></data>
<data name="Archive.Convert.Skipped.EightBit" xml:space="preserve"><value>Las fotos RAW que este equipo solo revela a 8 bits se quedan como están; se pueden convertir a JPEG.</value></data>
<data name="Archive.Convert.Skipped.Inaccessible" xml:space="preserve"><value>Las fotos que otro programa mantiene abiertas, o que no se pueden abrir, se quedan como están; vuelve a planificar cuando estén libres.</value></data>
<data name="Archive.Convert.Skipped.Missing" xml:space="preserve"><value>Las fotos que faltan se quedan como están.</value></data>
<data name="Archive.Convert.Skipped.NoNativeDecoder" xml:space="preserve"><value>Las fotos de un formato que este equipo no puede leer a resolución completa se quedan como están.</value></data>
<data name="Archive.Convert.Skipped.PreviewOnly" xml:space="preserve"><value>Las fotos que aquí solo se leen desde su vista previa incrustada se quedan como están.</value></data>
<data name="Archive.Convert.Skipped.SameFormat" xml:space="preserve"><value>Las fotos que ya están en este formato se quedan como están.</value></data>
<data name="Archive.Convert.Skipped.TooLarge" xml:space="preserve"><value>Las fotos más grandes de lo que admite este formato o de lo que Chronos puede volver a leer se quedan como están.</value></data>
<data name="Archive.Convert.Skipped.Undecodable" xml:space="preserve"><value>Las fotos ilegibles se quedan como están.</value></data>
<data name="Archive.Convert.Skipped.Unhashed" xml:space="preserve"><value>Las fotos nunca verificadas se quedan como están; verifica primero la secuencia.</value></data>
<data name="Archive.Convert.SkippedPhotos.one" xml:space="preserve"><value>{0:N0} omitida</value></data>
<data name="Archive.Convert.SkippedPhotos.other" xml:space="preserve"><value>{0:N0} omitidas</value></data>
<data name="Archive.Convert.Space" xml:space="preserve"><value>Necesita {0}, libres {1}</value></data>
<data name="Archive.Convert.SpaceShort" xml:space="preserve"><value>Necesita {0} y solo hay {1} libres: libera antes algo de espacio.</value></data>
<data name="Archive.Convert.SpaceUnknown" xml:space="preserve"><value>Necesita {0}; no se puede medir el espacio libre.</value></data>
<data name="Archive.Convert.Target.LinearDng" xml:space="preserve"><value>DNG lineal</value></data>
<data name="Archive.Convert.Target.Tiff16" xml:space="preserve"><value>TIFF 16 bits</value></data>
<data name="Archive.Convert.UndoFailed" xml:space="preserve"><value>No se pudieron recuperar los originales</value></data>
<data name="Archive.Convert.UndoNothing" xml:space="preserve"><value>Los originales sustituidos ya no están en la papelera.</value></data>
<data name="Archive.Convert.Undone.one" xml:space="preserve"><value>Originales restaurados en {0:N0} secuencia</value></data>
<data name="Archive.Convert.Undone.other" xml:space="preserve"><value>Originales restaurados en {0:N0} secuencias</value></data>
<data name="Archive.Convert.UndoneNew.one" xml:space="preserve"><value>{0:N0} secuencia había cambiado entretanto: sus originales volvieron como una secuencia nueva.</value></data>
<data name="Archive.Convert.UndoneNew.other" xml:space="preserve"><value>{0:N0} secuencias habían cambiado entretanto: sus originales volvieron como secuencias nuevas.</value></data>
<data name="Archive.Convert.Unstaged" xml:space="preserve"><value>La conversión de {0} ya no está entre los archivos preparados; al reintentar se vuelve a convertir.</value></data>
<data name="Archive.Copy.Title" xml:space="preserve"><value>Carpeta que copiar en la fototeca</value></data>
<data name="Archive.Delete.Action" xml:space="preserve"><value>Mover a la papelera</value></data>
<data name="Archive.Delete.Blocked" xml:space="preserve"><value>No movida: {0} · {1}</value></data>
@@ -75,6 +153,9 @@
<data name="Archive.Duplicates.Title" xml:space="preserve"><value>Duplicados</value></data>
<data name="Archive.Empty" xml:space="preserve"><value>Aún no hay fototeca</value></data>
<data name="Archive.Error.Busy" xml:space="preserve"><value>Otro Chronos ({0}) está escribiendo aquí. Inténtalo de nuevo en breve.</value></data>
<data name="Archive.Error.ConvertKept.one" xml:space="preserve"><value>{0:N0} secuencia no se convirtió según lo previsto; el registro de la tarea indica por qué.</value></data>
<data name="Archive.Error.ConvertKept.other" xml:space="preserve"><value>{0:N0} secuencias no se convirtieron según lo previsto; el registro de la tarea indica por qué.</value></data>
<data name="Archive.Error.ConvertSpace" xml:space="preserve"><value>La conversión necesita {0} libres en el volumen de la fototeca, y hay {1} libres.</value></data>
<data name="Archive.Error.CopyMismatch" xml:space="preserve"><value>La copia de {0} no coincide con el original.</value></data>
<data name="Archive.Error.DuplicateLost" xml:space="preserve"><value>No se pudo añadir {0} a la secuencia.</value></data>
<data name="Archive.Error.InLibrary" xml:space="preserve"><value>{0} ya está en la biblioteca.</value></data>
@@ -92,8 +173,8 @@
<data name="Archive.Error.SourceGone" xml:space="preserve"><value>La tarjeta o carpeta {0} ya no está disponible.</value></data>
<data name="Archive.Error.StalePlan" xml:space="preserve"><value>La fototeca cambió después de crear este plan.</value></data>
<data name="Archive.Error.TrashChanged" xml:space="preserve"><value>La papelera cambió después de comprobarse; no se ha borrado nada.</value></data>
<data name="Archive.Error.TrashKept.one" xml:space="preserve"><value>Se conservó {0:N0} entrada de la papelera: cambió, o una sustitución ya no coincide.</value></data>
<data name="Archive.Error.TrashKept.other" xml:space="preserve"><value>Se conservaron {0:N0} entradas de la papelera: cambiaron, o una sustitución ya no coincide.</value></data>
<data name="Archive.Error.TrashKept.one" xml:space="preserve"><value>{0:N0} entrada de la papelera se conservó; el registro de la tarea indica por qué.</value></data>
<data name="Archive.Error.TrashKept.other" xml:space="preserve"><value>{0:N0} entradas de la papelera se conservaron; el registro de la tarea indica por qué.</value></data>
<data name="Archive.Error.TrashMismatch" xml:space="preserve"><value>Ningún archivo de esta entrada de la papelera coincide ya con su registro; se queda en la papelera.</value></data>
<data name="Archive.Failed.Access" xml:space="preserve"><value>Se denegó a Chronos el acceso a la fototeca.</value></data>
<data name="Archive.Failed.Files" xml:space="preserve"><value>No se pudo leer o escribir un archivo de la fototeca.</value></data>
@@ -132,6 +213,15 @@
<data name="Archive.Log.AuditKept" xml:space="preserve"><value>Registro de auditoría conservado íntegramente</value></data>
<data name="Archive.Log.AuditPurged" xml:space="preserve"><value>Entradas de auditoría eliminadas: {0}</value></data>
<data name="Archive.Log.BackupDone" xml:space="preserve"><value>Índice copiado en {0} ({1}); copias conservadas: {2}</value></data>
<data name="Archive.Log.ConvertBlocked" xml:space="preserve"><value>Se dejó como estaba, en uso o ilegible: {0}</value></data>
<data name="Archive.Log.ConvertChanged" xml:space="preserve"><value>Se dejó como estaba, cambió después del plan: {0}. Un reintento la deja como está: vuelve a convertirla a partir de un plan nuevo.</value></data>
<data name="Archive.Log.ConvertDone" xml:space="preserve"><value>Secuencias convertidas: {0}, secuencias nuevas: {1}, fotos: {2}</value></data>
<data name="Archive.Log.ConvertFailed" xml:space="preserve"><value>Se dejó como estaba: {0}. {1}</value></data>
<data name="Archive.Log.ConvertLeftOut" xml:space="preserve"><value>{0}: fotos sin convertir, que se quedan solo en la secuencia de origen: {1}</value></data>
<data name="Archive.Log.ConvertNothing" xml:space="preserve"><value>Nada que convertir: {0}</value></data>
<data name="Archive.Log.ConvertSuperseded" xml:space="preserve"><value>{0}: otra conversión creó su copia en este formato después de confirmarse esta; no se crea una segunda copia.</value></data>
<data name="Archive.Log.Converted" xml:space="preserve"><value>{0}: fotos sustituidas por su versión convertida: {1}</value></data>
<data name="Archive.Log.ConvertedNew" xml:space="preserve"><value>{0}: fotos convertidas en una secuencia nueva: {1}</value></data>
<data name="Archive.Log.DryRun" xml:space="preserve"><value>Simulación: no se ha cambiado nada.</value></data>
<data name="Archive.Log.DuplicateGroup" xml:space="preserve"><value>Copias adicionales de {0}: {1}</value></data>
<data name="Archive.Log.DuplicatesDone" xml:space="preserve"><value>Grupos de duplicados: {0}, copias adicionales: {1}</value></data>
@@ -166,9 +256,22 @@
<data name="Archive.Log.SequenceMissing" xml:space="preserve"><value>Secuencia no encontrada: {0}</value></data>
<data name="Archive.Log.StepFailed" xml:space="preserve"><value>Paso de limpieza {0} con error: {1}</value></data>
<data name="Archive.Log.StepUnknown" xml:space="preserve"><value>Paso de limpieza desconocido aquí: {0}</value></data>
<data name="Archive.Log.SyncChanged" xml:space="preserve"><value>{0}: cambió desde que se archivó, no se subió</value></data>
<data name="Archive.Log.SyncDeletedHere" xml:space="preserve"><value>{0}: eliminado en este equipo, no se descargó</value></data>
<data name="Archive.Log.SyncDeletedThere" xml:space="preserve"><value>{0}: eliminado en el servidor, no se subió</value></data>
<data name="Archive.Log.SyncFrameChanged" xml:space="preserve"><value>{0}: su fotograma de aquí cambió entretanto, no se descargó</value></data>
<data name="Archive.Log.SyncMissing" xml:space="preserve"><value>{0}: falta, no se subió</value></data>
<data name="Archive.Log.SyncNoPreview.one" xml:space="preserve"><value>{0:N0} fotograma no tiene proxy ni miniatura en el servidor</value></data>
<data name="Archive.Log.SyncNoPreview.other" xml:space="preserve"><value>{0:N0} fotogramas no tienen proxy ni miniatura en el servidor</value></data>
<data name="Archive.Log.TrashEmptied" xml:space="preserve"><value>Entradas borradas: {0}, tamaño: {1}</value></data>
<data name="Archive.Log.TrashEntry" xml:space="preserve"><value>En la papelera desde el {0}: {1} ({2})</value></data>
<data name="Archive.Log.TrashKept" xml:space="preserve"><value>Sigue en la papelera: {0}</value></data>
<data name="Archive.Log.TrashKept" xml:space="preserve"><value>Se conservó en la papelera, cambió después del plan: {0}</value></data>
<data name="Archive.Log.TrashKeptBusy" xml:space="preserve"><value>Se conservó en la papelera, su secuencia estaba en uso: {0}</value></data>
<data name="Archive.Log.TrashKeptMismatch" xml:space="preserve"><value>Se conservó en la papelera, una conversión de sus originales ya no coincide: {0}</value></data>
<data name="Archive.Log.TrashKeptStaleIndex" xml:space="preserve"><value>Se conservó en la papelera, el índice incluye su secuencia, que la fototeca ya no contiene; reconstruye el índice: {0}</value></data>
<data name="Archive.Log.TrashKeptUnhashed" xml:space="preserve"><value>Se conservó en la papelera, una foto de su secuencia nunca se verificó; verifica la secuencia: {0}</value></data>
<data name="Archive.Log.TrashKeptUnknown" xml:space="preserve"><value>Se conservó en la papelera, la fototeca no muestra qué fue de la conversión de sus originales; restáurala para conservarlos: {0}</value></data>
<data name="Archive.Log.TrashKeptUnreadable" xml:space="preserve"><value>Se conservó en la papelera, el archivo sidecar de una carpeta que puede contener su secuencia falta o no se puede leer; escanea la fototeca: {0}</value></data>
<data name="Archive.Log.TrashOffline" xml:space="preserve"><value>Papelera sin comprobar: no se puede acceder a la fototeca</value></data>
<data name="Archive.Log.TrashReport" xml:space="preserve"><value>Entradas antiguas en la papelera: {0}, tamaño: {1}; no se ha eliminado nada</value></data>
<data name="Archive.Log.VerifyDone" xml:space="preserve"><value>Fotos comprobadas: {0}, intactas: {1}, con hash calculado: {2}, con problemas: {3}</value></data>
@@ -249,6 +352,7 @@
<data name="Archive.Set.All.other" xml:space="preserve"><value>{0:N0} secuencias · toda la fototeca</value></data>
<data name="Archive.Set.Analyse" xml:space="preserve"><value>Analizar</value></data>
<data name="Archive.Set.ClearFilter" xml:space="preserve"><value>Quitar filtro</value></data>
<data name="Archive.Set.Convert" xml:space="preserve"><value>Convertir…</value></data>
<data name="Archive.Set.Delete" xml:space="preserve"><value>Eliminar…</value></data>
<data name="Archive.Set.Export" xml:space="preserve"><value>Exportar CSV</value></data>
<data name="Archive.Set.Filter" xml:space="preserve"><value>Filtro del conjunto</value></data>
@@ -278,6 +382,7 @@
<data name="Archive.Toolbar.Scan" xml:space="preserve"><value>Escanear</value></data>
<data name="Archive.Toolbar.Verify" xml:space="preserve"><value>Verificar</value></data>
<data name="Archive.Trash.Checking" xml:space="preserve"><value>Comprobando la papelera…</value></data>
<data name="Archive.Trash.ConversionDeleted" xml:space="preserve"><value>conversión eliminada</value></data>
<data name="Archive.Trash.Deleted" xml:space="preserve"><value>Eliminada el {0}</value></data>
<data name="Archive.Trash.Empty" xml:space="preserve"><value>La papelera está vacía</value></data>
<data name="Archive.Trash.EmptyAction" xml:space="preserve"><value>Vaciar…</value></data>
+1
View File
@@ -69,6 +69,7 @@
<data name="Jobs.Kind.Adopt" xml:space="preserve"><value>Incorporación de carpeta</value></data>
<data name="Jobs.Kind.Backup" xml:space="preserve"><value>Copia del índice</value></data>
<data name="Jobs.Kind.Cleanup" xml:space="preserve"><value>Limpieza</value></data>
<data name="Jobs.Kind.Convert" xml:space="preserve"><value>Conversión</value></data>
<data name="Jobs.Kind.DeepAnalyse" xml:space="preserve"><value>Análisis profundo</value></data>
<data name="Jobs.Kind.Download" xml:space="preserve"><value>Descarga</value></data>
<data name="Jobs.Kind.Duplicates" xml:space="preserve"><value>Duplicados</value></data>
+2
View File
@@ -6,6 +6,7 @@
<resheader name="writer"><value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader>
<data name="Library.Action.Analyse" xml:space="preserve"><value>Analizar</value></data>
<data name="Library.Action.ClearSelection" xml:space="preserve"><value>Anular selección</value></data>
<data name="Library.Action.Convert" xml:space="preserve"><value>Convertir…</value></data>
<data name="Library.Action.Delete" xml:space="preserve"><value>Eliminar…</value></data>
<data name="Library.Action.Download" xml:space="preserve"><value>Descargar</value></data>
<data name="Library.Action.ExportList" xml:space="preserve"><value>Exportar lista</value></data>
@@ -32,6 +33,7 @@
<data name="Library.Blocked.NothingToDownload" xml:space="preserve"><value>Las secuencias seleccionadas no tienen nada que obtener del servidor.</value></data>
<data name="Library.Blocked.NothingToUpload" xml:space="preserve"><value>El servidor ya tiene lo que contienen las secuencias seleccionadas.</value></data>
<data name="Library.Blocked.OneArchive" xml:space="preserve"><value>Reorganizar actúa sobre las secuencias de una sola fototeca a la vez.</value></data>
<data name="Library.Blocked.OneArchiveConvert" xml:space="preserve"><value>Convertir actúa sobre las secuencias de una sola fototeca a la vez.</value></data>
<data name="Library.Blocked.ServerOnly" xml:space="preserve"><value>Solo para secuencias de este equipo; la selección está en el servidor.</value></data>
<data name="Library.Blocked.Transferring" xml:space="preserve"><value>Ya hay una transferencia de esta secuencia en curso.</value></data>
<data name="Library.ClearFilters" xml:space="preserve"><value>Quitar filtros</value></data>
+4
View File
@@ -21,6 +21,8 @@
<data name="Server.Conflict.TakeServer.Message" xml:space="preserve"><value>La configuración de {0} en este equipo se sustituirá por la copia del servidor.</value></data>
<data name="Server.Conflict.TakeServer.Title" xml:space="preserve"><value>¿Usar la configuración del servidor?</value></data>
<data name="Server.Connect" xml:space="preserve"><value>Conectar</value></data>
<data name="Server.Convert.OnPc" xml:space="preserve"><value>Convierte estas fotos en un equipo: el servidor no puede leerlas a resolución completa.</value></data>
<data name="Server.Convert.OnPcNew" xml:space="preserve"><value>No se copian en la secuencia nueva: el servidor no puede leer estas fotos a resolución completa; conviértelas en un equipo.</value></data>
<data name="Server.Disconnect" xml:space="preserve"><value>Desconectar</value></data>
<data name="Server.Empty" xml:space="preserve"><value>No conectado a ningún servidor</value></data>
<data name="Server.Error.AccountLocked" xml:space="preserve"><value>Demasiados inicios de sesión fallidos; la cuenta queda bloqueada durante un tiempo.</value></data>
@@ -71,7 +73,9 @@
<data name="Server.Error.MethodNotAllowed" xml:space="preserve"><value>Este método no está permitido aquí.</value></data>
<data name="Server.Error.NestedTarget" xml:space="preserve"><value>Una carpeta nueva quedaría dentro de la carpeta de otra secuencia.</value></data>
<data name="Server.Error.NotChronos" xml:space="preserve"><value>Esa dirección no es un Chronos Server.</value></data>
<data name="Server.Error.NotEnoughSpace" xml:space="preserve"><value>Al volumen de la fototeca le falta el espacio que necesita la conversión.</value></data>
<data name="Server.Error.NotFound" xml:space="preserve"><value>No encontrado.</value></data>
<data name="Server.Error.NothingToConvert" xml:space="preserve"><value>El plan no convierte nada: todas las fotos se omiten o todas las secuencias están bloqueadas.</value></data>
<data name="Server.Error.PasswordChangeRequired" xml:space="preserve"><value>Primero cambia tu contraseña.</value></data>
<data name="Server.Error.PhotoRemoved" xml:space="preserve"><value>La foto se eliminó de la secuencia mientras se subía, así que no se añadió.</value></data>
<data name="Server.Error.PhotoUnreadable" xml:space="preserve"><value>No se puede leer {0} y, sin su hash, las demás copias no sabrían que se eliminó; cierra el programa que lo usa o revisa sus permisos y vuelve a intentarlo.</value></data>
+19 -1
View File
@@ -27,6 +27,21 @@
<data name="Tooltips.Archive.ClearFilter" xml:space="preserve"><value>Vuelve a mostrar todas las secuencias de la selección</value></data>
<data name="Tooltips.Archive.CloseDialog" xml:space="preserve"><value>Cierra sin cambiar nada · Esc</value></data>
<data name="Tooltips.Archive.Collapse" xml:space="preserve"><value>Oculta las secuencias de este año</value></data>
<data name="Tooltips.Archive.ConvertApplyNew" xml:space="preserve"><value>Confirma y luego pone en cola una tarea que convierte copias en secuencias nuevas · puedes pausarla y reanudarla en Tareas</value></data>
<data name="Tooltips.Archive.ConvertApplyReplace" xml:space="preserve"><value>Pide escribir el número de fotos para confirmar y luego pone en cola una tarea que las sustituye por su versión convertida · puedes pausarla y reanudarla en Tareas</value></data>
<data name="Tooltips.Archive.ConvertBack" xml:space="preserve"><value>Vuelve al plan; no se convierte nada</value></data>
<data name="Tooltips.Archive.ConvertDng" xml:space="preserve"><value>DNG lineal, de 16 bits y sin pérdidas · lo lee cualquier editor RAW; la opción para archivar</value></data>
<data name="Tooltips.Archive.ConvertJpeg" xml:space="preserve"><value>JPEG de 8 bits con la calidad indicada abajo · los archivos más pequeños; se pierde algo de detalle</value></data>
<data name="Tooltips.Archive.ConvertModeNew" xml:space="preserve"><value>Las copias convertidas van a una secuencia nueva junto a cada secuencia de origen; los originales se quedan como están</value></data>
<data name="Tooltips.Archive.ConvertModeReplace" xml:space="preserve"><value>Los archivos convertidos ocupan el lugar de las fotos en sus secuencias; los originales van a la papelera de la fototeca, donde se pueden restaurar hasta que se vacíe</value></data>
<data name="Tooltips.Archive.ConvertNew" xml:space="preserve"><value>Pone en cola la tarea que convierte las fotos en secuencias nuevas, verificando cada conversión; los originales no se tocan</value></data>
<data name="Tooltips.Archive.ConvertPlan" xml:space="preserve"><value>Las secuencias cuyas fotos se sustituyen</value></data>
<data name="Tooltips.Archive.ConvertPlanNew" xml:space="preserve"><value>Las secuencias que se copian en otras nuevas y las fotos que deja fuera cada una</value></data>
<data name="Tooltips.Archive.ConvertQuality" xml:space="preserve"><value>Calidad JPEG de 1 a 100 · 95 conserva los detalles finos; los valores más bajos dan archivos más pequeños</value></data>
<data name="Tooltips.Archive.ConvertReplace.one" xml:space="preserve"><value>Sustituye {0:N0} foto por su versión convertida; escribe antes el número de arriba</value></data>
<data name="Tooltips.Archive.ConvertReplace.other" xml:space="preserve"><value>Sustituye {0:N0} fotos por sus versiones convertidas; escribe antes el número de arriba</value></data>
<data name="Tooltips.Archive.ConvertTiff" xml:space="preserve"><value>TIFF de 16 bits comprimido sin pérdidas · archivos grandes que abre cualquier editor</value></data>
<data name="Tooltips.Archive.ConvertUndo" xml:space="preserve"><value>Devuelve los originales de la papelera al lugar de sus versiones convertidas</value></data>
<data name="Tooltips.Archive.DeleteAction.one" xml:space="preserve"><value>Mueve {0:N0} secuencia a la papelera; escribe antes el número de arriba</value></data>
<data name="Tooltips.Archive.DeleteAction.other" xml:space="preserve"><value>Mueve {0:N0} secuencias a la papelera; escribe antes el número de arriba</value></data>
<data name="Tooltips.Archive.DeleteKeep" xml:space="preserve"><value>No cambia nada</value></data>
@@ -82,6 +97,7 @@
<data name="Tooltips.Archive.Scan" xml:space="preserve"><value>Escaneo incremental: archivos nuevos, modificados y eliminados según la fecha de modificación y el tamaño</value></data>
<data name="Tooltips.Archive.Set" xml:space="preserve"><value>Los años y secuencias seleccionados (todos si no hay nada seleccionado), filtrados por cámara, estado o etiqueta</value></data>
<data name="Tooltips.Archive.SetAnalyse" xml:space="preserve"><value>Ejecuta el análisis profundo en todas las secuencias del conjunto</value></data>
<data name="Tooltips.Archive.SetConvert" xml:space="preserve"><value>Convierte las fotos del conjunto a JPEG, TIFF o DNG · primero una simulación, luego una tarea</value></data>
<data name="Tooltips.Archive.SetDelete" xml:space="preserve"><value>Mueve el conjunto a la papelera de la fototeca · muestra la simulación y luego te pide que escribas para confirmar</value></data>
<data name="Tooltips.Archive.SetExport" xml:space="preserve"><value>Exporta el conjunto como CSV: una fila por secuencia</value></data>
<data name="Tooltips.Archive.SetProxies" xml:space="preserve"><value>Genera o actualiza los proxies</value></data>
@@ -96,7 +112,7 @@
<data name="Tooltips.Archive.TitleTemplate" xml:space="preserve"><value>Plantilla de título; el marcador del título es el título actual · se comprueba mientras escribes</value></data>
<data name="Tooltips.Archive.Trash" xml:space="preserve"><value>Las secuencias y fotos eliminadas de esta fototeca; cada una se puede restaurar</value></data>
<data name="Tooltips.Archive.TrashEmpty" xml:space="preserve"><value>Borra definitivamente las entradas de esta papelera, tras comprobar lo que contienen y pedir una confirmación escrita</value></data>
<data name="Tooltips.Archive.TrashEmptyPlan" xml:space="preserve"><value>Lo que se borra definitivamente de la fototeca</value></data>
<data name="Tooltips.Archive.TrashEmptyPlan" xml:space="preserve"><value>Lo que se borra definitivamente de la fototeca; los originales cuya versión convertida se eliminó pueden ser la última copia de sus fotos</value></data>
<data name="Tooltips.Archive.TrashErase.one" xml:space="preserve"><value>Borra definitivamente {0:N0} entrada; escribe antes el número de arriba</value></data>
<data name="Tooltips.Archive.TrashErase.other" xml:space="preserve"><value>Borra definitivamente {0:N0} entradas; escribe antes el número de arriba</value></data>
<data name="Tooltips.Archive.TrashRestore" xml:space="preserve"><value>Devuelve esta entrada a su sitio: una secuencia a su carpeta y a la biblioteca, las fotos a su secuencia tras comprobar su hash</value></data>
@@ -468,6 +484,8 @@
<data name="Tooltips.Library.List" xml:space="preserve"><value>Tabla con columnas ordenables</value></data>
<data name="Tooltips.Library.Mass.Analyse.one" xml:space="preserve"><value>Análisis profundo de {0:N0} secuencia en este equipo · se ejecuta como una sola tarea</value></data>
<data name="Tooltips.Library.Mass.Analyse.other" xml:space="preserve"><value>Análisis profundo de {0:N0} secuencias en este equipo · se ejecuta como una sola tarea</value></data>
<data name="Tooltips.Library.Mass.Convert.one" xml:space="preserve"><value>Convierte las fotos de {0:N0} secuencia a JPEG, TIFF o DNG · primero una simulación, luego una tarea</value></data>
<data name="Tooltips.Library.Mass.Convert.other" xml:space="preserve"><value>Convierte las fotos de {0:N0} secuencias de su fototeca a JPEG, TIFF o DNG · primero una simulación, luego una tarea</value></data>
<data name="Tooltips.Library.Mass.Delete.one" xml:space="preserve"><value>Mueve {0:N0} secuencia a la papelera de su fototeca · muestra la simulación y luego te pide que escribas para confirmar</value></data>
<data name="Tooltips.Library.Mass.Delete.other" xml:space="preserve"><value>Mueve {0:N0} secuencias a la papelera de su fototeca · muestra la simulación y luego te pide que escribas para confirmar</value></data>
<data name="Tooltips.Library.Mass.Download.one" xml:space="preserve"><value>Obtiene del servidor lo que le falta aquí a {0:N0} secuencia (originales o renderizados) · se ejecuta como tarea de transferencia</value></data>
+69
View File
@@ -9,6 +9,7 @@
<data name="Admin.About.Title" xml:space="preserve"><value>Chronos Server</value></data>
<data name="Admin.About.Uptime" xml:space="preserve"><value>Tööaeg</value></data>
<data name="Admin.About.Version" xml:space="preserve"><value>Versioon</value></data>
<data name="Admin.Activity.ArchiveConverted" xml:space="preserve"><value>{0} lisas järjekorda teisendustöö · {1}</value></data>
<data name="Admin.Activity.ArchiveReorganized" xml:space="preserve"><value>{0} korraldas arhiivi ümber · {1}</value></data>
<data name="Admin.Activity.ArchiveSettings" xml:space="preserve"><value>{0} muutis arhiivi paigutust</value></data>
<data name="Admin.Activity.FramesDeleted" xml:space="preserve"><value>{0} kustutas {1}</value></data>
@@ -83,6 +84,68 @@
<data name="Admin.Common.TypeToConfirm.Tip" xml:space="preserve"><value>Kinnitamiseks tippige nimi täpselt nii, nagu see on kuvatud</value></data>
<data name="Admin.Common.TypeWord.Tip" xml:space="preserve"><value>Tippige sõna täpselt nii, nagu see on kuvatud; suur- ja väiketähtedel pole vahet</value></data>
<data name="Admin.Common.TypeWordFirst.Tip" xml:space="preserve"><value>Tippige esmalt ülalolev sõna</value></data>
<data name="Admin.Convert.Action" xml:space="preserve"><value>Teisenda…</value></data>
<data name="Admin.Convert.Action.Tip" xml:space="preserve"><value>Teisendage valitud jadade fotod vormingusse JPEG, TIFF-16 või lineaarne DNG; eelvaade näitab enne iga jada</value></data>
<data name="Admin.Convert.Apply" xml:space="preserve"><value>Teisenda…</value></data>
<data name="Admin.Convert.Apply.Tip" xml:space="preserve"><value>Teisendage nii, nagu eelvaade näitab; enne küsitakse kinnitust</value></data>
<data name="Admin.Convert.Cancel.Tip" xml:space="preserve"><value>Sulgege midagi teisendamata</value></data>
<data name="Admin.Convert.ChooseMode" xml:space="preserve"><value>Teisendamiseks valige „Asenda“ või „Uus jada“.</value></data>
<data name="Admin.Convert.ChooseMode.Tip" xml:space="preserve"><value>Valige esmalt „Asenda“ või „Uus jada“</value></data>
<data name="Admin.Convert.Column.Converted" xml:space="preserve"><value>Teisendatud</value></data>
<data name="Admin.Convert.Column.NotCopied" xml:space="preserve"><value>Kopeerimata</value></data>
<data name="Admin.Convert.Column.Sequence" xml:space="preserve"><value>Jada</value></data>
<data name="Admin.Convert.Column.Size" xml:space="preserve"><value>Suurus</value></data>
<data name="Admin.Convert.Column.Unchanged" xml:space="preserve"><value>Muutmata</value></data>
<data name="Admin.Convert.Confirm.New" xml:space="preserve"><value>Teisenda</value></data>
<data name="Admin.Convert.Confirm.New.Tip" xml:space="preserve"><value>Lisage järjekorda töö, mis teisendab fotod uutesse jadadesse ja kontrollib iga teisendust; originaale ei puudutata</value></data>
<data name="Admin.Convert.Confirm.Replace" xml:space="preserve"><value>Asenda</value></data>
<data name="Admin.Convert.Confirm.Replace.Tip" xml:space="preserve"><value>Lisage järjekorda töö, mis teisendab fotod, kontrollib iga teisendust ja teisaldab originaalid prügikasti</value></data>
<data name="Admin.Convert.ConfirmNew.one" xml:space="preserve"><value>{0} foto teisendatakse koopiaks, mis läheb uude jadasse; originaal jääb samaks.</value></data>
<data name="Admin.Convert.ConfirmNew.other" xml:space="preserve"><value>{0} fotot teisendatakse koopiateks, mis lähevad iga lähtejada kõrvale uude jadasse; originaalid jäävad samaks.</value></data>
<data name="Admin.Convert.ConfirmNewNotCopied.one" xml:space="preserve"><value>{0} foto jääb uude jadasse kopeerimata eelvaates toodud põhjusel.</value></data>
<data name="Admin.Convert.ConfirmNewNotCopied.other" xml:space="preserve"><value>{0} fotot jääb uutesse jadadesse kopeerimata eelvaates toodud põhjustel.</value></data>
<data name="Admin.Convert.ConfirmNewTitle" xml:space="preserve"><value>Kas teisendada vormingusse {0} uute jadadena?</value></data>
<data name="Admin.Convert.ConfirmReplace.one" xml:space="preserve"><value>{0} foto ({1}) asendatakse selle teisendusega; originaal läheb prügikasti ja seda saab taastada, kuni prügikast tühjendatakse.</value></data>
<data name="Admin.Convert.ConfirmReplace.other" xml:space="preserve"><value>{0} fotot ({1}) asendatakse nende teisendustega; originaalid lähevad prügikasti ja neid saab taastada, kuni prügikast tühjendatakse.</value></data>
<data name="Admin.Convert.ConfirmReplaceTitle" xml:space="preserve"><value>Kas asendada originaalid vormingu {0} failidega?</value></data>
<data name="Admin.Convert.Format" xml:space="preserve"><value>Vorming</value></data>
<data name="Admin.Convert.Format.Jpeg.Tip" xml:space="preserve"><value>8-bitine JPEG täieliku värvieraldusvõimega ja kõrval määratud kvaliteediga: kõige väiksemad failid, mida avab iga programm</value></data>
<data name="Admin.Convert.Format.LinearDng" xml:space="preserve"><value>Lineaarne DNG</value></data>
<data name="Admin.Convert.Format.LinearDng.Tip" xml:space="preserve"><value>16-bitine lineaarne DNG kadudeta tihendusega: valik arhiveerimiseks, mida avavad RAW-töötlusprogrammid</value></data>
<data name="Admin.Convert.Format.Tiff16.Tip" xml:space="preserve"><value>16-bitine sRGB TIFF kadudeta tihendusega: suured failid, mis säilitavad töötlemiseks kõik toonid</value></data>
<data name="Admin.Convert.Gone" xml:space="preserve"><value>Üks valitud jada pole enam arhiivis; sulgege aken ja valige uuesti.</value></data>
<data name="Admin.Convert.Mode" xml:space="preserve"><value>Režiim</value></data>
<data name="Admin.Convert.Mode.NewSequence" xml:space="preserve"><value>Uus jada</value></data>
<data name="Admin.Convert.Mode.NewSequence.Tip" xml:space="preserve"><value>Teisendatud koopiad lähevad iga jada kõrvale uude jadasse; originaalid ja nende jada jäävad täpselt samaks</value></data>
<data name="Admin.Convert.Mode.Replace" xml:space="preserve"><value>Asenda</value></data>
<data name="Admin.Convert.Mode.Replace.Tip" xml:space="preserve"><value>Teisendatud failidest saavad jada fotod; originaalid lähevad arhiivi prügikasti ja neid saab taastada, kuni see tühjendatakse</value></data>
<data name="Admin.Convert.NoAnswer" xml:space="preserve"><value>Server ei vastanud: enne uuesti teisendamist kontrollige tööde lehel, kas teisendamine lisati järjekorda.</value></data>
<data name="Admin.Convert.NoSpace.Tip" xml:space="preserve"><value>Vabastage esmalt arhiivi köitel ruumi</value></data>
<data name="Admin.Convert.NotCopiedCount.one" xml:space="preserve"><value>{0} kopeerimata</value></data>
<data name="Admin.Convert.NotCopiedCount.other" xml:space="preserve"><value>{0} kopeerimata</value></data>
<data name="Admin.Convert.Nothing.Tip" xml:space="preserve"><value>Eelvaate järgi ei teisendata midagi</value></data>
<data name="Admin.Convert.NothingToConvert" xml:space="preserve"><value>Pole midagi teisendada: kõik fotod jäävad samaks näidatud põhjustel.</value></data>
<data name="Admin.Convert.OpenJob" xml:space="preserve"><value>Ava töö</value></data>
<data name="Admin.Convert.OpenJob.Tip" xml:space="preserve"><value>Kuvage töö ja selle logi tööde lehel</value></data>
<data name="Admin.Convert.PlanChanged" xml:space="preserve"><value>Arhiiv on pärast eelvaadet muutunud; vaadake uus eelvaade üle ja rakendage uuesti.</value></data>
<data name="Admin.Convert.Planning" xml:space="preserve"><value>Plaani koostamine…</value></data>
<data name="Admin.Convert.Planning.Tip" xml:space="preserve"><value>Server loeb valiku iga fotokausta: suure arhiivi puhul kulub mitu minutit ja eelvaade ilmub, kui see on valmis</value></data>
<data name="Admin.Convert.PlanningFor" xml:space="preserve"><value>Plaani koostamine… {0}</value></data>
<data name="Admin.Convert.Preview" xml:space="preserve"><value>Eelvaade</value></data>
<data name="Admin.Convert.Preview.Tip" xml:space="preserve"><value>Mida iga jada teisendab ja mida jätab samaks, koos suurusega enne ja pärast (hinnanguline); veel pole midagi muudetud</value></data>
<data name="Admin.Convert.Quality" xml:space="preserve"><value>Kvaliteet</value></data>
<data name="Admin.Convert.Quality.Tip" xml:space="preserve"><value>JPEG-i kvaliteet 1 kuni 100; 95 säilitab peened detailid, väiksemad väärtused annavad väiksemad failid</value></data>
<data name="Admin.Convert.QualityRange" xml:space="preserve"><value>Kirjutage täisarv vahemikus 1 kuni 100.</value></data>
<data name="Admin.Convert.Queued" xml:space="preserve"><value>Teisendamine on järjekorras.</value></data>
<data name="Admin.Convert.ReplaceWord" xml:space="preserve"><value>asenda</value></data>
<data name="Admin.Convert.Size.Tip" xml:space="preserve"><value>Teisendatavate fotode praegune suurus, seejärel hinnanguline suurus pärast teisendamist</value></data>
<data name="Admin.Convert.SkippedPhotos" xml:space="preserve"><value>{0}: {1}</value></data>
<data name="Admin.Convert.Title.one" xml:space="preserve"><value>Teisenda {0} jada</value></data>
<data name="Admin.Convert.Title.other" xml:space="preserve"><value>Teisenda {0} jada</value></data>
<data name="Admin.Convert.TitleAll" xml:space="preserve"><value>Teisenda kõik jadad</value></data>
<data name="Admin.Convert.TooMany" xml:space="preserve"><value>Teisendamine võtab korraga kuni {0} jada või kõik jadad: tühjendage filtrid ja valige kõik.</value></data>
<data name="Admin.Convert.Totals" xml:space="preserve"><value>Teisendatud jadasid: {0} · fotosid: {1} · muutmata: {2} · suurus: {3} → {4}</value></data>
<data name="Admin.Convert.TotalsNew" xml:space="preserve"><value>Teisendatud jadasid: {0} · fotosid: {1} · kopeerimata: {2} · suurus: {3} → {4}</value></data>
<data name="Admin.Dashboard.Activity" xml:space="preserve"><value>Viimased tegevused</value></data>
<data name="Admin.Dashboard.AllLogs" xml:space="preserve"><value>Kõik logid</value></data>
<data name="Admin.Dashboard.AllLogs.Tip" xml:space="preserve"><value>Avage auditilogi</value></data>
@@ -133,6 +196,7 @@
<data name="Admin.Job.Kind.Adopt" xml:space="preserve"><value>Ülevõtmine</value></data>
<data name="Admin.Job.Kind.Backup" xml:space="preserve"><value>Varundamine</value></data>
<data name="Admin.Job.Kind.Cleanup" xml:space="preserve"><value>Puhastamine</value></data>
<data name="Admin.Job.Kind.Convert" xml:space="preserve"><value>Teisendamine</value></data>
<data name="Admin.Job.Kind.DeepAnalyse" xml:space="preserve"><value>Süvaanalüüs</value></data>
<data name="Admin.Job.Kind.Duplicates" xml:space="preserve"><value>Duplikaadid</value></data>
<data name="Admin.Job.Kind.EmptyTrash" xml:space="preserve"><value>Prügikasti tühjendamine</value></data>
@@ -344,6 +408,7 @@
<data name="Admin.Login.SignIn.Tip" xml:space="preserve"><value>Logige sisse, et seda serverit hallata</value></data>
<data name="Admin.Login.User" xml:space="preserve"><value>Kasutaja</value></data>
<data name="Admin.Login.User.Tip" xml:space="preserve"><value>Teie kasutajanimi selles serveris</value></data>
<data name="Admin.Logs.Action.ArchiveConverted" xml:space="preserve"><value>Fotod teisendatud</value></data>
<data name="Admin.Logs.Action.ArchiveReorganized" xml:space="preserve"><value>Arhiiv ümber korraldatud</value></data>
<data name="Admin.Logs.Action.ArchiveSettings" xml:space="preserve"><value>Arhiivi paigutus</value></data>
<data name="Admin.Logs.Action.FramesDeleted" xml:space="preserve"><value>Fotod kustutatud</value></data>
@@ -793,6 +858,7 @@
<data name="Admin.Theme.Tip" xml:space="preserve"><value>Lülitage heleda ja tumeda kujunduse vahel</value></data>
<data name="Admin.Trash.Back" xml:space="preserve"><value>Teek</value></data>
<data name="Admin.Trash.Back.Tip" xml:space="preserve"><value>Tagasi teeki</value></data>
<data name="Admin.Trash.ConversionDeleted" xml:space="preserve"><value>teisendus kustutatud</value></data>
<data name="Admin.Trash.DeletedAt" xml:space="preserve"><value>Kustutatud</value></data>
<data name="Admin.Trash.DeletedBy" xml:space="preserve"><value>Kustutaja</value></data>
<data name="Admin.Trash.Emptied" xml:space="preserve"><value>Prügikast tühjendatud.</value></data>
@@ -819,9 +885,12 @@
<data name="Admin.Trash.Photos" xml:space="preserve"><value>Fotod</value></data>
<data name="Admin.Trash.Restore" xml:space="preserve"><value>Taasta</value></data>
<data name="Admin.Trash.RestorePhotos.Tip" xml:space="preserve"><value>Pange fotod tagasi nende jadasse (uude, kui seda enam pole); igaüht kontrollitakse esmalt SHA-256 räsi järgi</value></data>
<data name="Admin.Trash.RestoreReplaced.Tip" xml:space="preserve"><value>Pange originaalid tagasi nende teisenduste asemele, kui need on muutmata (teisendused lähevad prügikasti), muidu uude jadasse; igaüht kontrollitakse esmalt SHA-256 räsi järgi</value></data>
<data name="Admin.Trash.RestoreSequence.Tip" xml:space="preserve"><value>Teisaldage jada kaust tagasi teeki sellisena, nagu see on (vana koha kõrvale, kui see on hõivatud); selle fotode räsi ei kontrollita: seda teeb „Kontrolli“</value></data>
<data name="Admin.Trash.RestoredNew.one" xml:space="preserve"><value>{0} foto taastati uude jadasse.</value></data>
<data name="Admin.Trash.RestoredNew.other" xml:space="preserve"><value>{0} fotot taastati uude jadasse.</value></data>
<data name="Admin.Trash.RestoredOriginals.one" xml:space="preserve"><value>{0} originaal on taas jadas {1}; selle teisendus on prügikastis.</value></data>
<data name="Admin.Trash.RestoredOriginals.other" xml:space="preserve"><value>{0} originaali on taas jadas {1}; nende teisendused on prügikastis.</value></data>
<data name="Admin.Trash.RestoredPhotos.one" xml:space="preserve"><value>{0} foto on taas jadas {1}.</value></data>
<data name="Admin.Trash.RestoredPhotos.other" xml:space="preserve"><value>{0} fotot on taas jadas {1}.</value></data>
<data name="Admin.Trash.RestoredSequence" xml:space="preserve"><value>{0} on taas teegis.</value></data>
+108 -3
View File
@@ -15,8 +15,10 @@
<data name="Archive.Blocked.Applying" xml:space="preserve"><value>Oodake, kuni muudatused on rakendatud.</value></data>
<data name="Archive.Blocked.EmptySet" xml:space="preserve"><value>Valik on tühi: muutke valikut või filtrit.</value></data>
<data name="Archive.Blocked.NoChanges" xml:space="preserve"><value>Midagi ei muutuks.</value></data>
<data name="Archive.Blocked.NoMode" xml:space="preserve"><value>Valige „Asenda“ või „Uus jada“.</value></data>
<data name="Archive.Blocked.NoTemplate" xml:space="preserve"><value>Lülitage sisse vähemalt üks mall.</value></data>
<data name="Archive.Blocked.NotOnline" xml:space="preserve"><value>Arhiiv peab olema saadaval ja kirjutatav.</value></data>
<data name="Archive.Blocked.NothingToConvert" xml:space="preserve"><value>Pole midagi teisendada: kõik fotod jäetakse vahele või kõik jadad on blokeeritud.</value></data>
<data name="Archive.Blocked.Planning" xml:space="preserve"><value>Oodake proovikäivituse lõppu.</value></data>
<data name="Archive.Blocked.Reading" xml:space="preserve"><value>Oodake, kuni arhiiv on loetud.</value></data>
<data name="Archive.Blocked.Searching" xml:space="preserve"><value>Otsing on käimas; tühistage see või oodake.</value></data>
@@ -32,6 +34,82 @@
<data name="Archive.Confirm.Remove" xml:space="preserve"><value>Eemalda rida</value></data>
<data name="Archive.Confirm.RemoveHeading" xml:space="preserve"><value>Kas eemaldada {0} indeksist?</value></data>
<data name="Archive.Confirm.RemoveMessage" xml:space="preserve"><value>Selle kaasfail on kadunud. Eemaldatakse ainult indeksi rida; ühtegi faili ei kustutata.</value></data>
<data name="Archive.Convert.AlreadyQueued" xml:space="preserve"><value>Nende jadade teisendamine juba ootab või on käimas; jälgige seda jaotises „Tööd“.</value></data>
<data name="Archive.Convert.Blocked.Busy" xml:space="preserve"><value>Seda jada töötleb praegu mõni töö; teisendage see, kui töö on valmis.</value></data>
<data name="Archive.Convert.Blocked.FramesChanged" xml:space="preserve"><value>Jada muutus pärast plaani koostamist; vaadake plaan uuesti üle.</value></data>
<data name="Archive.Convert.Blocked.Offline" xml:space="preserve"><value>Arhiiv pole saadaval või on kirjutuskaitstud.</value></data>
<data name="Archive.Convert.Blocked.Unreadable" xml:space="preserve"><value>Jadafaili ei saa lugeda.</value></data>
<data name="Archive.Convert.Confirm" xml:space="preserve"><value>Teisenda</value></data>
<data name="Archive.Convert.CopyUnfinished" xml:space="preserve"><value>Teine teisendus on teinud sellest selles vormingus koopia ega ole veel lõppenud; viige see esmalt lõpule või proovige seda uuesti.</value></data>
<data name="Archive.Convert.Done.one" xml:space="preserve"><value>{0:N0} jada teisendatud</value></data>
<data name="Archive.Convert.Done.other" xml:space="preserve"><value>{0:N0} jada teisendatud</value></data>
<data name="Archive.Convert.Failed.Changed" xml:space="preserve"><value>Foto ei vasta enam arhiveeritud koopiale; kontrollige jada.</value></data>
<data name="Archive.Convert.Failed.ColorProfile" xml:space="preserve"><value>Selle värviprofiili ei saa selles vormingus säilitada ega teisendada.</value></data>
<data name="Archive.Convert.Failed.Damaged" xml:space="preserve"><value>Selle pikslid sisaldavad väärtusi, mis pole arvud: fail on kahjustatud.</value></data>
<data name="Archive.Convert.Failed.EightBit" xml:space="preserve"><value>See arvuti ilmutab seda RAW-faili ainult 8-bitisena, mis on 16-bitise faili jaoks liiga vähe; JPEG-vormingusse saab selle teisendada.</value></data>
<data name="Archive.Convert.Failed.Full" xml:space="preserve"><value>Arhiivi ketas on täis.</value></data>
<data name="Archive.Convert.Failed.NoDecoder" xml:space="preserve"><value>Ükski selle arvuti dekodeerija ei loe seda täies eraldusvõimes.</value></data>
<data name="Archive.Convert.Failed.NotVerified" xml:space="preserve"><value>Teisendatud faili ei saanud tagasi lugeda sellisena, nagu see kirjutati.</value></data>
<data name="Archive.Convert.Failed.Other" xml:space="preserve"><value>Teisendatud faili ei saanud luua.</value></data>
<data name="Archive.Convert.Failed.PreviewOnly" xml:space="preserve"><value>See arvuti loeb seda ainult manustatud eelvaatest: teisendage see arvutis, mis loeb seda täies eraldusvõimes.</value></data>
<data name="Archive.Convert.Failed.TooLarge" xml:space="preserve"><value>See on suurem, kui see vorming mahutab, kui Chronos suudab tagasi lugeda või kui ühe foto jaoks ette nähtud mälu mahutab.</value></data>
<data name="Archive.Convert.Failed.Unreadable" xml:space="preserve"><value>Fotot ei saanud dekodeerida.</value></data>
<data name="Archive.Convert.Format" xml:space="preserve"><value>Vorming</value></data>
<data name="Archive.Convert.Heading.one" xml:space="preserve"><value>Teisenda {0:N0} jada</value></data>
<data name="Archive.Convert.Heading.other" xml:space="preserve"><value>Teisenda {0:N0} jada</value></data>
<data name="Archive.Convert.HeadingAll" xml:space="preserve"><value>Teisenda arhiiv {0}</value></data>
<data name="Archive.Convert.Mode" xml:space="preserve"><value>Režiim</value></data>
<data name="Archive.Convert.NewHeading.one" xml:space="preserve"><value>Kas teisendada {0:N0} jada uueks jadaks?</value></data>
<data name="Archive.Convert.NewHeading.other" xml:space="preserve"><value>Kas teisendada {0:N0} jada uuteks jadadeks?</value></data>
<data name="Archive.Convert.NewLeftOut.one" xml:space="preserve"><value>{0:N0} foto jääb kopeerimata: see jääb ainult lähtejadasse plaanis toodud põhjusel.</value></data>
<data name="Archive.Convert.NewLeftOut.other" xml:space="preserve"><value>{0:N0} fotot jääb kopeerimata: need jäävad ainult lähtejadasse plaanis toodud põhjustel.</value></data>
<data name="Archive.Convert.NewMessage" xml:space="preserve"><value>{0} ({1}) teisendatakse vormingusse {2}, iga lähtejada kõrvale uude jadasse; originaalid jäävad samaks.</value></data>
<data name="Archive.Convert.NewSequence" xml:space="preserve"><value>Uus jada</value></data>
<data name="Archive.Convert.NotCopied.ColorProfile" xml:space="preserve"><value>Fotosid, mille värviprofiili see vorming ei saa säilitada ega teisendada, uude jadasse ei kopeerita.</value></data>
<data name="Archive.Convert.NotCopied.EightBit" xml:space="preserve"><value>RAW-fotosid, mida see arvuti ilmutab ainult 8-bitisena, uude jadasse ei kopeerita; JPEG-vormingusse saab need teisendada.</value></data>
<data name="Archive.Convert.NotCopied.Inaccessible" xml:space="preserve"><value>Fotosid, mida mõni teine programm hoiab avatuna või mida ei saa avada, uude jadasse ei kopeerita; koostage plaan uuesti, kui need on vabad.</value></data>
<data name="Archive.Convert.NotCopied.Missing" xml:space="preserve"><value>Puuduvaid fotosid uude jadasse ei kopeerita.</value></data>
<data name="Archive.Convert.NotCopied.NoNativeDecoder" xml:space="preserve"><value>Fotosid vormingus, mida see arvuti ei suuda täies eraldusvõimes lugeda, uude jadasse ei kopeerita.</value></data>
<data name="Archive.Convert.NotCopied.PreviewOnly" xml:space="preserve"><value>Fotosid, mida siin loetakse ainult manustatud eelvaatest, uude jadasse ei kopeerita.</value></data>
<data name="Archive.Convert.NotCopied.SameFormat" xml:space="preserve"><value>Fotosid, mis on juba selles vormingus, uude jadasse ei kopeerita.</value></data>
<data name="Archive.Convert.NotCopied.TooLarge" xml:space="preserve"><value>Fotosid, mis on suuremad, kui see vorming mahutab või Chronos suudab tagasi lugeda, uude jadasse ei kopeerita.</value></data>
<data name="Archive.Convert.NotCopied.Undecodable" xml:space="preserve"><value>Loetamatuid fotosid uude jadasse ei kopeerita.</value></data>
<data name="Archive.Convert.NotCopied.Unhashed" xml:space="preserve"><value>Kunagi kontrollimata fotosid uude jadasse ei kopeerita; kontrollige esmalt jada.</value></data>
<data name="Archive.Convert.NotCopiedPhotos.one" xml:space="preserve"><value>{0:N0} kopeerimata</value></data>
<data name="Archive.Convert.NotCopiedPhotos.other" xml:space="preserve"><value>{0:N0} kopeerimata</value></data>
<data name="Archive.Convert.NotPlaced" xml:space="preserve"><value>Teisendatud fotod ei saanud originaalide asemele asuda. {0}</value></data>
<data name="Archive.Convert.PhotoFailed" xml:space="preserve"><value>Faili {0} ei saanud teisendada. {1}</value></data>
<data name="Archive.Convert.PhotoHeld" xml:space="preserve"><value>Mõnda selle fotot hoiab avatuna teine programm või seda ei saa avada; proovige uuesti, kui see on vaba.</value></data>
<data name="Archive.Convert.Quality" xml:space="preserve"><value>Kvaliteet</value></data>
<data name="Archive.Convert.Replace" xml:space="preserve"><value>Asenda</value></data>
<data name="Archive.Convert.ReplaceHeading.one" xml:space="preserve"><value>Kas asendada {0:N0} jada fotod?</value></data>
<data name="Archive.Convert.ReplaceHeading.other" xml:space="preserve"><value>Kas asendada {0:N0} jada fotod?</value></data>
<data name="Archive.Convert.ReplaceMessage" xml:space="preserve"><value>{0} ({1}) asendatakse vormingusse {2} teisendatud failidega; originaalid teisaldatakse arhiivi prügikasti ja neid saab taastada, kuni see tühjendatakse.</value></data>
<data name="Archive.Convert.Sizes" xml:space="preserve"><value>{0} → {1}</value></data>
<data name="Archive.Convert.Skipped.ColorProfile" xml:space="preserve"><value>Fotod, mille värviprofiili see vorming ei saa säilitada ega teisendada, jäävad samaks.</value></data>
<data name="Archive.Convert.Skipped.EightBit" xml:space="preserve"><value>RAW-fotod, mida see arvuti ilmutab ainult 8-bitisena, jäävad samaks; JPEG-vormingusse saab need teisendada.</value></data>
<data name="Archive.Convert.Skipped.Inaccessible" xml:space="preserve"><value>Fotod, mida mõni teine programm hoiab avatuna või mida ei saa avada, jäävad samaks; koostage plaan uuesti, kui need on vabad.</value></data>
<data name="Archive.Convert.Skipped.Missing" xml:space="preserve"><value>Puuduvad fotod jäävad samaks.</value></data>
<data name="Archive.Convert.Skipped.NoNativeDecoder" xml:space="preserve"><value>Fotod vormingus, mida see arvuti ei suuda täies eraldusvõimes lugeda, jäävad samaks.</value></data>
<data name="Archive.Convert.Skipped.PreviewOnly" xml:space="preserve"><value>Fotod, mida siin loetakse ainult manustatud eelvaatest, jäävad samaks.</value></data>
<data name="Archive.Convert.Skipped.SameFormat" xml:space="preserve"><value>Fotod, mis on juba selles vormingus, jäävad samaks.</value></data>
<data name="Archive.Convert.Skipped.TooLarge" xml:space="preserve"><value>Fotod, mis on suuremad, kui see vorming mahutab või Chronos suudab tagasi lugeda, jäävad samaks.</value></data>
<data name="Archive.Convert.Skipped.Undecodable" xml:space="preserve"><value>Loetamatud fotod jäävad samaks.</value></data>
<data name="Archive.Convert.Skipped.Unhashed" xml:space="preserve"><value>Kunagi kontrollimata fotod jäävad samaks; kontrollige esmalt jada.</value></data>
<data name="Archive.Convert.SkippedPhotos.one" xml:space="preserve"><value>{0:N0} vahele jäetud</value></data>
<data name="Archive.Convert.SkippedPhotos.other" xml:space="preserve"><value>{0:N0} vahele jäetud</value></data>
<data name="Archive.Convert.Space" xml:space="preserve"><value>Vaja {0}, vaba {1}</value></data>
<data name="Archive.Convert.SpaceShort" xml:space="preserve"><value>Vaja {0}, vaba ainult {1}: vabastage esmalt ruumi.</value></data>
<data name="Archive.Convert.SpaceUnknown" xml:space="preserve"><value>Vaja {0}; vaba ruumi ei saa mõõta.</value></data>
<data name="Archive.Convert.Target.LinearDng" xml:space="preserve"><value>Lineaarne DNG</value></data>
<data name="Archive.Convert.Target.Tiff16" xml:space="preserve"><value>TIFF 16-bitine</value></data>
<data name="Archive.Convert.UndoFailed" xml:space="preserve"><value>Originaale ei saanud taastada</value></data>
<data name="Archive.Convert.UndoNothing" xml:space="preserve"><value>Asendatud originaale pole enam prügikastis.</value></data>
<data name="Archive.Convert.Undone.one" xml:space="preserve"><value>Originaalid on taas {0:N0} jadas</value></data>
<data name="Archive.Convert.Undone.other" xml:space="preserve"><value>Originaalid on taas {0:N0} jadas</value></data>
<data name="Archive.Convert.UndoneNew.one" xml:space="preserve"><value>{0:N0} jada oli vahepeal muutunud: selle originaalid taastati uue jadana.</value></data>
<data name="Archive.Convert.UndoneNew.other" xml:space="preserve"><value>{0:N0} jada oli vahepeal muutunud: nende originaalid taastati uute jadadena.</value></data>
<data name="Archive.Convert.Unstaged" xml:space="preserve"><value>Faili {0} teisendus pole enam ettevalmistatud failide hulgas; kordamisel teisendatakse see uuesti.</value></data>
<data name="Archive.Copy.Title" xml:space="preserve"><value>Arhiivi kopeeritav kaust</value></data>
<data name="Archive.Delete.Action" xml:space="preserve"><value>Teisalda prügikasti</value></data>
<data name="Archive.Delete.Blocked" xml:space="preserve"><value>Teisaldamata: {0} · {1}</value></data>
@@ -75,6 +153,9 @@
<data name="Archive.Duplicates.Title" xml:space="preserve"><value>Duplikaadid</value></data>
<data name="Archive.Empty" xml:space="preserve"><value>Arhiivi veel pole</value></data>
<data name="Archive.Error.Busy" xml:space="preserve"><value>Siia kirjutab teine Chronos ({0}). Proovige varsti uuesti.</value></data>
<data name="Archive.Error.ConvertKept.one" xml:space="preserve"><value>{0:N0} jada ei teisendatud kavandatud viisil; põhjus on töö logis.</value></data>
<data name="Archive.Error.ConvertKept.other" xml:space="preserve"><value>{0:N0} jada ei teisendatud kavandatud viisil; põhjus on töö logis.</value></data>
<data name="Archive.Error.ConvertSpace" xml:space="preserve"><value>Teisendamiseks on arhiivi köitel vaja {0} vaba ruumi, vaba on {1}.</value></data>
<data name="Archive.Error.CopyMismatch" xml:space="preserve"><value>Faili {0} koopia ei vasta originaalile.</value></data>
<data name="Archive.Error.DuplicateLost" xml:space="preserve"><value>{0} lisamine jadasse nurjus.</value></data>
<data name="Archive.Error.InLibrary" xml:space="preserve"><value>Jada „{0}“ on juba teegis.</value></data>
@@ -92,8 +173,8 @@
<data name="Archive.Error.SourceGone" xml:space="preserve"><value>Kaart või kaust {0} ei ole enam saadaval.</value></data>
<data name="Archive.Error.StalePlan" xml:space="preserve"><value>Arhiiv muutus pärast selle plaani koostamist.</value></data>
<data name="Archive.Error.TrashChanged" xml:space="preserve"><value>Prügikast muutus pärast kontrollimist; midagi ei kustutatud.</value></data>
<data name="Archive.Error.TrashKept.one" xml:space="preserve"><value>{0:N0} prügikasti kirje säilitati: see muutus või asendus ei vasta enam.</value></data>
<data name="Archive.Error.TrashKept.other" xml:space="preserve"><value>{0:N0} prügikasti kirjet säilitati: need muutusid või asendus ei vasta enam.</value></data>
<data name="Archive.Error.TrashKept.one" xml:space="preserve"><value>{0:N0} prügikasti kirje säilitati; põhjus on töö logis.</value></data>
<data name="Archive.Error.TrashKept.other" xml:space="preserve"><value>{0:N0} prügikasti kirjet säilitati; põhjus on töö logis.</value></data>
<data name="Archive.Error.TrashMismatch" xml:space="preserve"><value>Ükski selle prügikasti kirje fail ei vasta enam salvestatud andmetele; kirje jääb prügikasti.</value></data>
<data name="Archive.Failed.Access" xml:space="preserve"><value>Chronosele keelati juurdepääs arhiivile.</value></data>
<data name="Archive.Failed.Files" xml:space="preserve"><value>Mõnda arhiivi faili ei saanud lugeda ega kirjutada.</value></data>
@@ -132,6 +213,15 @@
<data name="Archive.Log.AuditKept" xml:space="preserve"><value>Auditilogi säilitatakse täielikult</value></data>
<data name="Archive.Log.AuditPurged" xml:space="preserve"><value>Eemaldatud auditikirjeid: {0}</value></data>
<data name="Archive.Log.BackupDone" xml:space="preserve"><value>Indeks kopeeriti asukohta {0} ({1}); säilitatud koopiaid: {2}</value></data>
<data name="Archive.Log.ConvertBlocked" xml:space="preserve"><value>Jäeti endiseks, hõivatud või loetamatu: {0}</value></data>
<data name="Archive.Log.ConvertChanged" xml:space="preserve"><value>Jäeti endiseks, muutus pärast plaani koostamist: {0}. Kordamine jätab selle samaks: teisendage see uuesti uue plaani järgi.</value></data>
<data name="Archive.Log.ConvertDone" xml:space="preserve"><value>Teisendatud jadasid: {0}, uusi jadasid: {1}, fotosid: {2}</value></data>
<data name="Archive.Log.ConvertFailed" xml:space="preserve"><value>Jäeti endiseks: {0}. {1}</value></data>
<data name="Archive.Log.ConvertLeftOut" xml:space="preserve"><value>{0}: teisendamata fotod, mis jäid ainult lähtejadasse: {1}</value></data>
<data name="Archive.Log.ConvertNothing" xml:space="preserve"><value>Pole midagi teisendada: {0}</value></data>
<data name="Archive.Log.ConvertSuperseded" xml:space="preserve"><value>{0}: teine teisendus on pärast selle kinnitamist teinud selles vormingus oma koopia; teist koopiat ei tehta.</value></data>
<data name="Archive.Log.Converted" xml:space="preserve"><value>{0}: teisendusega asendatud fotod: {1}</value></data>
<data name="Archive.Log.ConvertedNew" xml:space="preserve"><value>{0}: uude jadasse teisendatud fotod: {1}</value></data>
<data name="Archive.Log.DryRun" xml:space="preserve"><value>Proovikäivitus: midagi ei muudetud.</value></data>
<data name="Archive.Log.DuplicateGroup" xml:space="preserve"><value>Faili {0} lisakoopiad: {1}</value></data>
<data name="Archive.Log.DuplicatesDone" xml:space="preserve"><value>Duplikaatide rühmi: {0}, lisakoopiaid: {1}</value></data>
@@ -166,9 +256,22 @@
<data name="Archive.Log.SequenceMissing" xml:space="preserve"><value>Jada ei leitud: {0}</value></data>
<data name="Archive.Log.StepFailed" xml:space="preserve"><value>Puhastussamm {0} nurjus: {1}</value></data>
<data name="Archive.Log.StepUnknown" xml:space="preserve"><value>Siin tundmatu puhastussamm: {0}</value></data>
<data name="Archive.Log.SyncChanged" xml:space="preserve"><value>{0}: muutunud pärast arhiveerimist, üles laadimata</value></data>
<data name="Archive.Log.SyncDeletedHere" xml:space="preserve"><value>{0}: selles arvutis kustutatud, alla laadimata</value></data>
<data name="Archive.Log.SyncDeletedThere" xml:space="preserve"><value>{0}: serveris kustutatud, üles laadimata</value></data>
<data name="Archive.Log.SyncFrameChanged" xml:space="preserve"><value>{0}: selle kaader siin muutus vahepeal, alla laadimata</value></data>
<data name="Archive.Log.SyncMissing" xml:space="preserve"><value>{0}: puudub, üles laadimata</value></data>
<data name="Archive.Log.SyncNoPreview.one" xml:space="preserve"><value>{0:N0} kaadril pole serveris proksit ega pisipilti</value></data>
<data name="Archive.Log.SyncNoPreview.other" xml:space="preserve"><value>{0:N0} kaadril pole serveris proksit ega pisipilti</value></data>
<data name="Archive.Log.TrashEmptied" xml:space="preserve"><value>Kustutatud kirjeid: {0}, maht: {1}</value></data>
<data name="Archive.Log.TrashEntry" xml:space="preserve"><value>Prügikastis alates {0}: {1} ({2})</value></data>
<data name="Archive.Log.TrashKept" xml:space="preserve"><value>Prügikasti jäeti: {0}</value></data>
<data name="Archive.Log.TrashKept" xml:space="preserve"><value>Jäeti prügikasti, muutus pärast plaani koostamist: {0}</value></data>
<data name="Archive.Log.TrashKeptBusy" xml:space="preserve"><value>Jäeti prügikasti, selle jada oli hõivatud: {0}</value></data>
<data name="Archive.Log.TrashKeptMismatch" xml:space="preserve"><value>Jäeti prügikasti, selle originaalide teisendus ei vasta enam: {0}</value></data>
<data name="Archive.Log.TrashKeptStaleIndex" xml:space="preserve"><value>Jäeti prügikasti, indeks loetleb selle jada, mida arhiivis enam pole; looge indeks uuesti: {0}</value></data>
<data name="Archive.Log.TrashKeptUnhashed" xml:space="preserve"><value>Jäeti prügikasti, selle jada üht fotot pole kunagi kontrollitud; kontrollige jada: {0}</value></data>
<data name="Archive.Log.TrashKeptUnknown" xml:space="preserve"><value>Jäeti prügikasti, arhiiv ei näita, mis sai selle originaalide teisendusest; taastage see, et need alles jääksid: {0}</value></data>
<data name="Archive.Log.TrashKeptUnreadable" xml:space="preserve"><value>Jäeti prügikasti, kausta, milles võib olla selle jada, kaasfail puudub või seda ei saa lugeda; skannige arhiivi: {0}</value></data>
<data name="Archive.Log.TrashOffline" xml:space="preserve"><value>Prügikasti ei kontrollitud: arhiiv pole kättesaadav</value></data>
<data name="Archive.Log.TrashReport" xml:space="preserve"><value>Vanu prügikasti kirjeid: {0}, maht: {1}; midagi ei kustutatud</value></data>
<data name="Archive.Log.VerifyDone" xml:space="preserve"><value>Kontrollitud fotosid: {0}, terveid: {1}, räsitud: {2}, probleemidega: {3}</value></data>
@@ -249,6 +352,7 @@
<data name="Archive.Set.All.other" xml:space="preserve"><value>{0:N0} jada · kõik</value></data>
<data name="Archive.Set.Analyse" xml:space="preserve"><value>Analüüsi</value></data>
<data name="Archive.Set.ClearFilter" xml:space="preserve"><value>Tühjenda filter</value></data>
<data name="Archive.Set.Convert" xml:space="preserve"><value>Teisenda…</value></data>
<data name="Archive.Set.Delete" xml:space="preserve"><value>Kustuta…</value></data>
<data name="Archive.Set.Export" xml:space="preserve"><value>Ekspordi CSV</value></data>
<data name="Archive.Set.Filter" xml:space="preserve"><value>Valiku filter</value></data>
@@ -278,6 +382,7 @@
<data name="Archive.Toolbar.Scan" xml:space="preserve"><value>Skanni</value></data>
<data name="Archive.Toolbar.Verify" xml:space="preserve"><value>Kontrolli</value></data>
<data name="Archive.Trash.Checking" xml:space="preserve"><value>Prügikasti kontrollimine…</value></data>
<data name="Archive.Trash.ConversionDeleted" xml:space="preserve"><value>teisendus kustutatud</value></data>
<data name="Archive.Trash.Deleted" xml:space="preserve"><value>Kustutatud {0}</value></data>
<data name="Archive.Trash.Empty" xml:space="preserve"><value>Prügikast on tühi</value></data>
<data name="Archive.Trash.EmptyAction" xml:space="preserve"><value>Tühjenda…</value></data>
+1
View File
@@ -69,6 +69,7 @@
<data name="Jobs.Kind.Adopt" xml:space="preserve"><value>Kausta ülevõtmine</value></data>
<data name="Jobs.Kind.Backup" xml:space="preserve"><value>Indeksi varundamine</value></data>
<data name="Jobs.Kind.Cleanup" xml:space="preserve"><value>Puhastamine</value></data>
<data name="Jobs.Kind.Convert" xml:space="preserve"><value>Teisendamine</value></data>
<data name="Jobs.Kind.DeepAnalyse" xml:space="preserve"><value>Süvaanalüüs</value></data>
<data name="Jobs.Kind.Download" xml:space="preserve"><value>Allalaadimine</value></data>
<data name="Jobs.Kind.Duplicates" xml:space="preserve"><value>Duplikaadid</value></data>
+2
View File
@@ -6,6 +6,7 @@
<resheader name="writer"><value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader>
<data name="Library.Action.Analyse" xml:space="preserve"><value>Analüüsi</value></data>
<data name="Library.Action.ClearSelection" xml:space="preserve"><value>Tühjenda valik</value></data>
<data name="Library.Action.Convert" xml:space="preserve"><value>Teisenda…</value></data>
<data name="Library.Action.Delete" xml:space="preserve"><value>Kustuta…</value></data>
<data name="Library.Action.Download" xml:space="preserve"><value>Laadi alla</value></data>
<data name="Library.Action.ExportList" xml:space="preserve"><value>Ekspordi loend</value></data>
@@ -32,6 +33,7 @@
<data name="Library.Blocked.NothingToDownload" xml:space="preserve"><value>Valitud jadadel pole serverist midagi tuua.</value></data>
<data name="Library.Blocked.NothingToUpload" xml:space="preserve"><value>Serveris on juba olemas kõik, mis valitud jadades on.</value></data>
<data name="Library.Blocked.OneArchive" xml:space="preserve"><value>Ümberkorraldamine toimib korraga ainult ühe arhiivi jadadel.</value></data>
<data name="Library.Blocked.OneArchiveConvert" xml:space="preserve"><value>Teisendamine toimib korraga ainult ühe arhiivi jadadel.</value></data>
<data name="Library.Blocked.ServerOnly" xml:space="preserve"><value>Ainult selles arvutis olevatele jadadele; valik asub serveris.</value></data>
<data name="Library.Blocked.Transferring" xml:space="preserve"><value>Selle jada edastus on juba käimas.</value></data>
<data name="Library.ClearFilters" xml:space="preserve"><value>Tühjenda filtrid</value></data>
+4
View File
@@ -21,6 +21,8 @@
<data name="Server.Conflict.TakeServer.Message" xml:space="preserve"><value>Jada „{0}“ sätted selles arvutis asendatakse serverikoopiaga.</value></data>
<data name="Server.Conflict.TakeServer.Title" xml:space="preserve"><value>Kas võtta serveri sätted?</value></data>
<data name="Server.Connect" xml:space="preserve"><value>Ühenda</value></data>
<data name="Server.Convert.OnPc" xml:space="preserve"><value>Teisendage need fotod arvutis: server ei suuda neid täies eraldusvõimes lugeda.</value></data>
<data name="Server.Convert.OnPcNew" xml:space="preserve"><value>Uude jadasse ei kopeerita: server ei suuda neid fotosid täies eraldusvõimes lugeda; teisendage need arvutis.</value></data>
<data name="Server.Disconnect" xml:space="preserve"><value>Katkesta ühendus</value></data>
<data name="Server.Empty" xml:space="preserve"><value>Serveriga pole ühendust</value></data>
<data name="Server.Error.AccountLocked" xml:space="preserve"><value>Liiga palju nurjunud sisselogimisi; konto on mõneks ajaks lukustatud.</value></data>
@@ -71,7 +73,9 @@
<data name="Server.Error.MethodNotAllowed" xml:space="preserve"><value>See meetod pole siin lubatud.</value></data>
<data name="Server.Error.NestedTarget" xml:space="preserve"><value>Uus kaust jääks teise jada kausta sisse.</value></data>
<data name="Server.Error.NotChronos" xml:space="preserve"><value>Sellel aadressil pole Chronos Serverit.</value></data>
<data name="Server.Error.NotEnoughSpace" xml:space="preserve"><value>Arhiivi köitel pole teisendamiseks vajalikku ruumi.</value></data>
<data name="Server.Error.NotFound" xml:space="preserve"><value>Ei leitud.</value></data>
<data name="Server.Error.NothingToConvert" xml:space="preserve"><value>Plaan ei teisenda midagi: kõik fotod jäetakse vahele või kõik jadad on blokeeritud.</value></data>
<data name="Server.Error.PasswordChangeRequired" xml:space="preserve"><value>Muutke esmalt oma parooli.</value></data>
<data name="Server.Error.PhotoRemoved" xml:space="preserve"><value>Foto kustutati jadast üleslaadimise ajal, seega seda ei lisatud.</value></data>
<data name="Server.Error.PhotoUnreadable" xml:space="preserve"><value>Faili {0} ei saa lugeda ja ilma selle räsita ei saaks teised koopiad teada, et see on kustutatud; sulgege seda kasutav programm või kontrollige selle õigusi ja proovige siis uuesti.</value></data>
+19 -1
View File
@@ -27,6 +27,21 @@
<data name="Tooltips.Archive.ClearFilter" xml:space="preserve"><value>Kuvage taas kõik valiku jadad</value></data>
<data name="Tooltips.Archive.CloseDialog" xml:space="preserve"><value>Sulgege midagi muutmata · Esc</value></data>
<data name="Tooltips.Archive.Collapse" xml:space="preserve"><value>Peitke selle aasta jadad</value></data>
<data name="Tooltips.Archive.ConvertApplyNew" xml:space="preserve"><value>Kinnitage ja lisage seejärel järjekorda töö, mis teisendab koopiad uutesse jadadesse · saate selle jaotises „Tööd“ peatada ja jätkata</value></data>
<data name="Tooltips.Archive.ConvertApplyReplace" xml:space="preserve"><value>Kinnitamiseks tippige fotode arv, seejärel lisage järjekorda töö, mis asendab need nende teisendusega · saate selle jaotises „Tööd“ peatada ja jätkata</value></data>
<data name="Tooltips.Archive.ConvertBack" xml:space="preserve"><value>Tagasi plaani juurde; midagi ei teisendata</value></data>
<data name="Tooltips.Archive.ConvertDng" xml:space="preserve"><value>Lineaarne DNG, 16-bitine ja kadudeta · loeb iga RAW-töötlusprogramm; valik arhiveerimiseks</value></data>
<data name="Tooltips.Archive.ConvertJpeg" xml:space="preserve"><value>8-bitine JPEG allpool määratud kvaliteediga · kõige väiksemad failid; osa detailidest läheb kaotsi</value></data>
<data name="Tooltips.Archive.ConvertModeNew" xml:space="preserve"><value>Teisendatud koopiad lähevad iga lähtejada kõrvale uude jadasse; originaalid jäävad samaks</value></data>
<data name="Tooltips.Archive.ConvertModeReplace" xml:space="preserve"><value>Teisendatud failid asuvad nende jadades fotode asemele; originaalid lähevad arhiivi prügikasti ja neid saab taastada, kuni see tühjendatakse</value></data>
<data name="Tooltips.Archive.ConvertNew" xml:space="preserve"><value>Lisage järjekorda töö, mis teisendab fotod uutesse jadadesse ja kontrollib iga teisendust; originaale ei puudutata</value></data>
<data name="Tooltips.Archive.ConvertPlan" xml:space="preserve"><value>Jadad, mille fotod asendatakse</value></data>
<data name="Tooltips.Archive.ConvertPlanNew" xml:space="preserve"><value>Jadad, mis kopeeritakse uutesse, ja fotod, mille iga jada välja jätab</value></data>
<data name="Tooltips.Archive.ConvertQuality" xml:space="preserve"><value>JPEG-i kvaliteet 1 kuni 100 · 95 säilitab peened detailid; väiksem väärtus annab väiksemad failid</value></data>
<data name="Tooltips.Archive.ConvertReplace.one" xml:space="preserve"><value>Asendage {0:N0} foto selle teisendusega; tippige esmalt ülalolev arv</value></data>
<data name="Tooltips.Archive.ConvertReplace.other" xml:space="preserve"><value>Asendage {0:N0} fotot nende teisendustega; tippige esmalt ülalolev arv</value></data>
<data name="Tooltips.Archive.ConvertTiff" xml:space="preserve"><value>16-bitine TIFF kadudeta tihendusega · suured failid, mida avab iga pilditöötlusprogramm</value></data>
<data name="Tooltips.Archive.ConvertUndo" xml:space="preserve"><value>Pange originaalid prügikastist tagasi nende teisenduste asemele</value></data>
<data name="Tooltips.Archive.DeleteAction.one" xml:space="preserve"><value>Teisaldage {0:N0} jada prügikasti; tippige esmalt ülalolev arv</value></data>
<data name="Tooltips.Archive.DeleteAction.other" xml:space="preserve"><value>Teisaldage {0:N0} jada prügikasti; tippige esmalt ülalolev arv</value></data>
<data name="Tooltips.Archive.DeleteKeep" xml:space="preserve"><value>Jätke kõik muutmata</value></data>
@@ -82,6 +97,7 @@
<data name="Tooltips.Archive.Scan" xml:space="preserve"><value>Inkrementaalne skannimine: uued, muudetud ja eemaldatud failid muutmisaja ja suuruse järgi</value></data>
<data name="Tooltips.Archive.Set" xml:space="preserve"><value>Valitud aastad ja jadad (kõik, kui midagi pole valitud), kitsendatud kaamera, oleku või sildi järgi</value></data>
<data name="Tooltips.Archive.SetAnalyse" xml:space="preserve"><value>Käivitage valiku iga jada süvaanalüüs</value></data>
<data name="Tooltips.Archive.SetConvert" xml:space="preserve"><value>Teisendage valiku fotod vormingusse JPEG, TIFF või DNG · esmalt proovikäivitus, siis töö</value></data>
<data name="Tooltips.Archive.SetDelete" xml:space="preserve"><value>Teisaldage valik arhiivi prügikasti · näitab proovikäivitust ja palub seejärel kinnitamiseks tippida</value></data>
<data name="Tooltips.Archive.SetExport" xml:space="preserve"><value>Eksportige valik CSV-failina: üks rida jada kohta</value></data>
<data name="Tooltips.Archive.SetProxies" xml:space="preserve"><value>Looge või värskendage proksid</value></data>
@@ -96,7 +112,7 @@
<data name="Tooltips.Archive.TitleTemplate" xml:space="preserve"><value>Pealkirjamall; märgend title on praegune pealkiri · kontrollitakse tippimise ajal</value></data>
<data name="Tooltips.Archive.Trash" xml:space="preserve"><value>Sellest arhiivist kustutatud jadad ja fotod, igaüks taastatav</value></data>
<data name="Tooltips.Archive.TrashEmpty" xml:space="preserve"><value>Kustutage selle prügikasti kirjed lõplikult pärast nende sisu kontrollimist ja tipitud kinnitust</value></data>
<data name="Tooltips.Archive.TrashEmptyPlan" xml:space="preserve"><value>Mis kustutatakse arhiivist lõplikult</value></data>
<data name="Tooltips.Archive.TrashEmptyPlan" xml:space="preserve"><value>Mis arhiivist lõplikult kustutatakse; originaalid, mille teisendus on kustutatud, võivad olla nende fotode viimane koopia</value></data>
<data name="Tooltips.Archive.TrashErase.one" xml:space="preserve"><value>Kustutage {0:N0} kirje lõplikult; tippige esmalt ülalolev arv</value></data>
<data name="Tooltips.Archive.TrashErase.other" xml:space="preserve"><value>Kustutage {0:N0} kirjet lõplikult; tippige esmalt ülalolev arv</value></data>
<data name="Tooltips.Archive.TrashRestore" xml:space="preserve"><value>Teisaldage see kirje tagasi: jada oma kausta ja teeki, fotod pärast räsi kontrollimist oma jadasse</value></data>
@@ -468,6 +484,8 @@
<data name="Tooltips.Library.List" xml:space="preserve"><value>Sorditavate veergudega tabel</value></data>
<data name="Tooltips.Library.Mass.Analyse.one" xml:space="preserve"><value>{0:N0} jada süvaanalüüs selles arvutis · käib ühe tööna</value></data>
<data name="Tooltips.Library.Mass.Analyse.other" xml:space="preserve"><value>{0:N0} jada süvaanalüüs selles arvutis · käib ühe tööna</value></data>
<data name="Tooltips.Library.Mass.Convert.one" xml:space="preserve"><value>Teisendage {0:N0} jada fotod vormingusse JPEG, TIFF või DNG · esmalt proovikäivitus, siis töö</value></data>
<data name="Tooltips.Library.Mass.Convert.other" xml:space="preserve"><value>Teisendage nende arhiivi {0:N0} jada fotod vormingusse JPEG, TIFF või DNG · esmalt proovikäivitus, siis töö</value></data>
<data name="Tooltips.Library.Mass.Delete.one" xml:space="preserve"><value>Teisaldage {0:N0} jada arhiivi prügikasti · näitab proovikäivitust ja palub seejärel kinnitamiseks tippida</value></data>
<data name="Tooltips.Library.Mass.Delete.other" xml:space="preserve"><value>Teisaldage {0:N0} jada nende arhiivi prügikasti · näitab proovikäivitust ja palub seejärel kinnitamiseks tippida</value></data>
<data name="Tooltips.Library.Mass.Download.one" xml:space="preserve"><value>Tooge serverist see, mis {0:N0} jadal siin puudub (originaalid või renderdused) · käib edastustööna</value></data>
+69
View File
@@ -9,6 +9,7 @@
<data name="Admin.About.Title" xml:space="preserve"><value>Chronos-palvelin</value></data>
<data name="Admin.About.Uptime" xml:space="preserve"><value>Käynnissä</value></data>
<data name="Admin.About.Version" xml:space="preserve"><value>Versio</value></data>
<data name="Admin.Activity.ArchiveConverted" xml:space="preserve"><value>{0} lisäsi muunnoksen jonoon · {1}</value></data>
<data name="Admin.Activity.ArchiveReorganized" xml:space="preserve"><value>{0} järjesti arkiston uudelleen · {1}</value></data>
<data name="Admin.Activity.ArchiveSettings" xml:space="preserve"><value>{0} muutti arkiston rakennetta</value></data>
<data name="Admin.Activity.FramesDeleted" xml:space="preserve"><value>{0} poisti {1}</value></data>
@@ -83,6 +84,68 @@
<data name="Admin.Common.TypeToConfirm.Tip" xml:space="preserve"><value>Vahvista kirjoittamalla nimi täsmälleen näytetyssä muodossa</value></data>
<data name="Admin.Common.TypeWord.Tip" xml:space="preserve"><value>Kirjoita sana täsmälleen näytetyssä muodossa; isoilla ja pienillä kirjaimilla ei ole väliä</value></data>
<data name="Admin.Common.TypeWordFirst.Tip" xml:space="preserve"><value>Kirjoita ensin yllä oleva sana</value></data>
<data name="Admin.Convert.Action" xml:space="preserve"><value>Muunna…</value></data>
<data name="Admin.Convert.Action.Tip" xml:space="preserve"><value>Muunna valittujen sarjojen kuvat muotoon JPEG, TIFF-16 tai lineaarinen DNG; esikatselu näyttää ensin jokaisen sarjan</value></data>
<data name="Admin.Convert.Apply" xml:space="preserve"><value>Muunna…</value></data>
<data name="Admin.Convert.Apply.Tip" xml:space="preserve"><value>Muunna esikatselun mukaisesti; ensin pyydetään vahvistus</value></data>
<data name="Admin.Convert.Cancel.Tip" xml:space="preserve"><value>Sulje muuntamatta mitään</value></data>
<data name="Admin.Convert.ChooseMode" xml:space="preserve"><value>Valitse muuntamista varten ”Korvaa” tai ”Uusi sarja”.</value></data>
<data name="Admin.Convert.ChooseMode.Tip" xml:space="preserve"><value>Valitse ensin ”Korvaa” tai ”Uusi sarja”</value></data>
<data name="Admin.Convert.Column.Converted" xml:space="preserve"><value>Muunnettavat</value></data>
<data name="Admin.Convert.Column.NotCopied" xml:space="preserve"><value>Kopioimatta</value></data>
<data name="Admin.Convert.Column.Sequence" xml:space="preserve"><value>Sarja</value></data>
<data name="Admin.Convert.Column.Size" xml:space="preserve"><value>Koko</value></data>
<data name="Admin.Convert.Column.Unchanged" xml:space="preserve"><value>Ennallaan</value></data>
<data name="Admin.Convert.Confirm.New" xml:space="preserve"><value>Muunna</value></data>
<data name="Admin.Convert.Confirm.New.Tip" xml:space="preserve"><value>Lisää jonoon työ, joka muuntaa kuvat uusiin sarjoihin ja tarkistaa jokaisen muunnoksen; alkuperäisiin tiedostoihin ei kosketa</value></data>
<data name="Admin.Convert.Confirm.Replace" xml:space="preserve"><value>Korvaa</value></data>
<data name="Admin.Convert.Confirm.Replace.Tip" xml:space="preserve"><value>Lisää jonoon työ, joka muuntaa kuvat, tarkistaa jokaisen muunnoksen ja siirtää alkuperäiset tiedostot roskakoriin</value></data>
<data name="Admin.Convert.ConfirmNew.one" xml:space="preserve"><value>{0} kuva muunnetaan kopioksi uuteen sarjaan; alkuperäinen tiedosto pysyy ennallaan.</value></data>
<data name="Admin.Convert.ConfirmNew.other" xml:space="preserve"><value>{0} kuvaa muunnetaan kopioiksi uuteen sarjaan kunkin sarjan viereen; alkuperäiset tiedostot pysyvät ennallaan.</value></data>
<data name="Admin.Convert.ConfirmNewNotCopied.one" xml:space="preserve"><value>{0} kuva jää kopioimatta uuteen sarjaan esikatselussa näkyvästä syystä.</value></data>
<data name="Admin.Convert.ConfirmNewNotCopied.other" xml:space="preserve"><value>{0} kuvaa jää kopioimatta uusiin sarjoihin esikatselussa näkyvistä syistä.</value></data>
<data name="Admin.Convert.ConfirmNewTitle" xml:space="preserve"><value>Muunnetaanko muotoon {0} uusiin sarjoihin?</value></data>
<data name="Admin.Convert.ConfirmReplace.one" xml:space="preserve"><value>{0} kuva ({1}) korvataan muunnoksella; alkuperäinen tiedosto siirtyy roskakoriin, josta sen voi palauttaa, kunnes roskakori tyhjennetään.</value></data>
<data name="Admin.Convert.ConfirmReplace.other" xml:space="preserve"><value>{0} kuvaa ({1}) korvataan muunnoksilla; alkuperäiset tiedostot siirtyvät roskakoriin, josta ne voi palauttaa, kunnes roskakori tyhjennetään.</value></data>
<data name="Admin.Convert.ConfirmReplaceTitle" xml:space="preserve"><value>Korvataanko alkuperäiset tiedostot muotoon {0} muunnetuilla?</value></data>
<data name="Admin.Convert.Format" xml:space="preserve"><value>Muoto</value></data>
<data name="Admin.Convert.Format.Jpeg.Tip" xml:space="preserve"><value>8-bittinen JPEG täydellä väritarkkuudella ja vieressä asetetulla laadulla: pienimmät tiedostot, jotka avautuvat kaikissa ohjelmissa</value></data>
<data name="Admin.Convert.Format.LinearDng" xml:space="preserve"><value>Lineaarinen DNG</value></data>
<data name="Admin.Convert.Format.LinearDng.Tip" xml:space="preserve"><value>16-bittinen lineaarinen DNG häviöttömästi pakattuna: valinta arkistointiin, avautuu RAW-editoreissa</value></data>
<data name="Admin.Convert.Format.Tiff16.Tip" xml:space="preserve"><value>16-bittinen sRGB-TIFF häviöttömästi pakattuna: suuria tiedostoja, jotka säilyttävät jokaisen sävyn muokkausta varten</value></data>
<data name="Admin.Convert.Gone" xml:space="preserve"><value>Valittu sarja ei ole enää arkistossa; sulje ja valitse uudelleen.</value></data>
<data name="Admin.Convert.Mode" xml:space="preserve"><value>Tila</value></data>
<data name="Admin.Convert.Mode.NewSequence" xml:space="preserve"><value>Uusi sarja</value></data>
<data name="Admin.Convert.Mode.NewSequence.Tip" xml:space="preserve"><value>Muunnetut kopiot menevät uuteen sarjaan kunkin sarjan viereen; alkuperäiset tiedostot ja niiden sarja pysyvät täsmälleen ennallaan</value></data>
<data name="Admin.Convert.Mode.Replace" xml:space="preserve"><value>Korvaa</value></data>
<data name="Admin.Convert.Mode.Replace.Tip" xml:space="preserve"><value>Muunnetuista tiedostoista tulee sarjan kuvat; alkuperäiset tiedostot siirtyvät arkiston roskakoriin, josta ne voi palauttaa, kunnes roskakori tyhjennetään</value></data>
<data name="Admin.Convert.NoAnswer" xml:space="preserve"><value>Palvelin ei vastannut: tarkista Työt-sivulta, lisättiinkö muunnos jonoon, ennen kuin muunnat uudelleen.</value></data>
<data name="Admin.Convert.NoSpace.Tip" xml:space="preserve"><value>Vapauta ensin tilaa arkiston taltiolta</value></data>
<data name="Admin.Convert.NotCopiedCount.one" xml:space="preserve"><value>{0} kuva kopioimatta</value></data>
<data name="Admin.Convert.NotCopiedCount.other" xml:space="preserve"><value>{0} kuvaa kopioimatta</value></data>
<data name="Admin.Convert.Nothing.Tip" xml:space="preserve"><value>Esikatselussa ei ole mitään muunnettavaa</value></data>
<data name="Admin.Convert.NothingToConvert" xml:space="preserve"><value>Ei muunnettavaa: jokainen kuva pysyy ennallaan näytetyistä syistä.</value></data>
<data name="Admin.Convert.OpenJob" xml:space="preserve"><value>Avaa työ</value></data>
<data name="Admin.Convert.OpenJob.Tip" xml:space="preserve"><value>Näytä työ ja sen loki Työt-sivulla</value></data>
<data name="Admin.Convert.PlanChanged" xml:space="preserve"><value>Arkisto muuttui esikatselun jälkeen; tarkista uusi esikatselu ja yritä uudelleen.</value></data>
<data name="Admin.Convert.Planning" xml:space="preserve"><value>Suunnitellaan…</value></data>
<data name="Admin.Convert.Planning.Tip" xml:space="preserve"><value>Palvelin lukee valinnan jokaisen kuvakansion: suuressa arkistossa se vie minuutteja, ja esikatselu tulee näkyviin, kun lukeminen on valmis</value></data>
<data name="Admin.Convert.PlanningFor" xml:space="preserve"><value>Suunnitellaan… {0}</value></data>
<data name="Admin.Convert.Preview" xml:space="preserve"><value>Esikatselu</value></data>
<data name="Admin.Convert.Preview.Tip" xml:space="preserve"><value>Mitä kustakin sarjasta muunnetaan ja mitä jätetään ennalleen, sekä koko ennen ja jälkeen (arvio); mitään ei ole vielä muutettu</value></data>
<data name="Admin.Convert.Quality" xml:space="preserve"><value>Laatu</value></data>
<data name="Admin.Convert.Quality.Tip" xml:space="preserve"><value>JPEG-laatu 1–100; 95 säilyttää hienot yksityiskohdat, pienemmät arvot tuottavat pienempiä tiedostoja</value></data>
<data name="Admin.Convert.QualityRange" xml:space="preserve"><value>Kirjoita kokonaisluku väliltä 1–100.</value></data>
<data name="Admin.Convert.Queued" xml:space="preserve"><value>Muunnos lisätty jonoon.</value></data>
<data name="Admin.Convert.ReplaceWord" xml:space="preserve"><value>korvaa</value></data>
<data name="Admin.Convert.Size.Tip" xml:space="preserve"><value>Muunnettavien kuvien koko nyt ja arvio muunnoksen jälkeen</value></data>
<data name="Admin.Convert.SkippedPhotos" xml:space="preserve"><value>{0}: {1}</value></data>
<data name="Admin.Convert.Title.one" xml:space="preserve"><value>Muunna {0} sarja</value></data>
<data name="Admin.Convert.Title.other" xml:space="preserve"><value>Muunna {0} sarjaa</value></data>
<data name="Admin.Convert.TitleAll" xml:space="preserve"><value>Muunna kaikki sarjat</value></data>
<data name="Admin.Convert.TooMany" xml:space="preserve"><value>Muuntamiseen voi ottaa kerralla enintään {0} sarjaa tai kaikki sarjat: tyhjennä suodattimet ja valitse kaikki.</value></data>
<data name="Admin.Convert.Totals" xml:space="preserve"><value>Muunnettavia sarjoja: {0} · kuvia: {1} · ennallaan: {2} · koko: {3} → {4}</value></data>
<data name="Admin.Convert.TotalsNew" xml:space="preserve"><value>Muunnettavia sarjoja: {0} · kuvia: {1} · kopioimatta: {2} · koko: {3} → {4}</value></data>
<data name="Admin.Dashboard.Activity" xml:space="preserve"><value>Viimeaikainen toiminta</value></data>
<data name="Admin.Dashboard.AllLogs" xml:space="preserve"><value>Kaikki lokit</value></data>
<data name="Admin.Dashboard.AllLogs.Tip" xml:space="preserve"><value>Avaa valvontaloki</value></data>
@@ -133,6 +196,7 @@
<data name="Admin.Job.Kind.Adopt" xml:space="preserve"><value>Sisällytys</value></data>
<data name="Admin.Job.Kind.Backup" xml:space="preserve"><value>Varmuuskopiointi</value></data>
<data name="Admin.Job.Kind.Cleanup" xml:space="preserve"><value>Siivous</value></data>
<data name="Admin.Job.Kind.Convert" xml:space="preserve"><value>Muunnos</value></data>
<data name="Admin.Job.Kind.DeepAnalyse" xml:space="preserve"><value>Syväanalyysi</value></data>
<data name="Admin.Job.Kind.Duplicates" xml:space="preserve"><value>Kaksoiskappaleet</value></data>
<data name="Admin.Job.Kind.EmptyTrash" xml:space="preserve"><value>Roskakorin tyhjennys</value></data>
@@ -344,6 +408,7 @@
<data name="Admin.Login.SignIn.Tip" xml:space="preserve"><value>Kirjaudu sisään hallitaksesi tätä palvelinta</value></data>
<data name="Admin.Login.User" xml:space="preserve"><value>Käyttäjä</value></data>
<data name="Admin.Login.User.Tip" xml:space="preserve"><value>Käyttäjänimesi tällä palvelimella</value></data>
<data name="Admin.Logs.Action.ArchiveConverted" xml:space="preserve"><value>Kuvia muunnettu</value></data>
<data name="Admin.Logs.Action.ArchiveReorganized" xml:space="preserve"><value>Arkisto järjestetty uudelleen</value></data>
<data name="Admin.Logs.Action.ArchiveSettings" xml:space="preserve"><value>Arkiston rakenne</value></data>
<data name="Admin.Logs.Action.FramesDeleted" xml:space="preserve"><value>Kuvia poistettu</value></data>
@@ -793,6 +858,7 @@
<data name="Admin.Theme.Tip" xml:space="preserve"><value>Vaihda vaalean ja tumman teeman välillä</value></data>
<data name="Admin.Trash.Back" xml:space="preserve"><value>Kirjasto</value></data>
<data name="Admin.Trash.Back.Tip" xml:space="preserve"><value>Takaisin Kirjastoon</value></data>
<data name="Admin.Trash.ConversionDeleted" xml:space="preserve"><value>muunnos poistettu</value></data>
<data name="Admin.Trash.DeletedAt" xml:space="preserve"><value>Poistettu</value></data>
<data name="Admin.Trash.DeletedBy" xml:space="preserve"><value>Poistaja</value></data>
<data name="Admin.Trash.Emptied" xml:space="preserve"><value>Roskakori tyhjennetty.</value></data>
@@ -819,9 +885,12 @@
<data name="Admin.Trash.Photos" xml:space="preserve"><value>Kuvat</value></data>
<data name="Admin.Trash.Restore" xml:space="preserve"><value>Palauta</value></data>
<data name="Admin.Trash.RestorePhotos.Tip" xml:space="preserve"><value>Palauta kuvat sarjaansa (uuteen sarjaan, jos sitä ei enää ole); jokainen tarkistetaan ensin SHA-256-tiivistettään vasten</value></data>
<data name="Admin.Trash.RestoreReplaced.Tip" xml:space="preserve"><value>Palauta alkuperäiset tiedostot muunnostensa tilalle, jos muunnokset ovat ennallaan (muunnokset siirtyvät roskakoriin), muuten uuteen sarjaan; jokainen tarkistetaan ensin SHA-256-tiivistettään vasten</value></data>
<data name="Admin.Trash.RestoreSequence.Tip" xml:space="preserve"><value>Siirrä sarjan kansio takaisin kirjastoon sellaisenaan (vanhan paikkansa viereen, jos se on varattu); sen kuvien tiivisteitä ei tarkisteta: ”Tarkista” tekee sen</value></data>
<data name="Admin.Trash.RestoredNew.one" xml:space="preserve"><value>{0} kuva palautettu uuteen sarjaan.</value></data>
<data name="Admin.Trash.RestoredNew.other" xml:space="preserve"><value>{0} kuvaa palautettu uuteen sarjaan.</value></data>
<data name="Admin.Trash.RestoredOriginals.one" xml:space="preserve"><value>{0} alkuperäinen tiedosto on taas sarjassa {1}; sen muunnos on roskakorissa.</value></data>
<data name="Admin.Trash.RestoredOriginals.other" xml:space="preserve"><value>{0} alkuperäistä tiedostoa on taas sarjassa {1}; niiden muunnokset ovat roskakorissa.</value></data>
<data name="Admin.Trash.RestoredPhotos.one" xml:space="preserve"><value>{0} kuva on taas sarjassa {1}.</value></data>
<data name="Admin.Trash.RestoredPhotos.other" xml:space="preserve"><value>{0} kuvaa on taas sarjassa {1}.</value></data>
<data name="Admin.Trash.RestoredSequence" xml:space="preserve"><value>{0} on taas kirjastossa.</value></data>
+108 -3
View File
@@ -15,8 +15,10 @@
<data name="Archive.Blocked.Applying" xml:space="preserve"><value>Odota, kunnes muutokset on tehty.</value></data>
<data name="Archive.Blocked.EmptySet" xml:space="preserve"><value>Joukko on tyhjä: muuta valintaa tai suodatinta.</value></data>
<data name="Archive.Blocked.NoChanges" xml:space="preserve"><value>Mikään ei muuttuisi.</value></data>
<data name="Archive.Blocked.NoMode" xml:space="preserve"><value>Valitse ”Korvaa” tai ”Uusi sarja”.</value></data>
<data name="Archive.Blocked.NoTemplate" xml:space="preserve"><value>Ota käyttöön vähintään yksi malli.</value></data>
<data name="Archive.Blocked.NotOnline" xml:space="preserve"><value>Arkiston on oltava käytettävissä ja kirjoitettavissa.</value></data>
<data name="Archive.Blocked.NothingToConvert" xml:space="preserve"><value>Ei muunnettavaa: jokainen kuva ohitetaan tai jokainen sarja on estetty.</value></data>
<data name="Archive.Blocked.Planning" xml:space="preserve"><value>Odota testiajon valmistumista.</value></data>
<data name="Archive.Blocked.Reading" xml:space="preserve"><value>Odota, kunnes arkisto on luettu.</value></data>
<data name="Archive.Blocked.Searching" xml:space="preserve"><value>Haku on käynnissä; peruuta se tai odota.</value></data>
@@ -32,6 +34,82 @@
<data name="Archive.Confirm.Remove" xml:space="preserve"><value>Poista rivi</value></data>
<data name="Archive.Confirm.RemoveHeading" xml:space="preserve"><value>Poistetaanko {0} indeksistä?</value></data>
<data name="Archive.Confirm.RemoveMessage" xml:space="preserve"><value>Sen sivutiedosto on kadonnut. Vain indeksin rivi poistetaan; tiedostoja ei poisteta.</value></data>
<data name="Archive.Convert.AlreadyQueued" xml:space="preserve"><value>Näiden sarjojen muunnos odottaa jo tai on käynnissä; seuraa sitä Työt-näkymässä.</value></data>
<data name="Archive.Convert.Blocked.Busy" xml:space="preserve"><value>Työ käsittelee tätä sarjaa; muunna se, kun työ on valmis.</value></data>
<data name="Archive.Convert.Blocked.FramesChanged" xml:space="preserve"><value>Sarja muuttui suunnitelman laatimisen jälkeen; tarkista suunnitelma uudelleen.</value></data>
<data name="Archive.Convert.Blocked.Offline" xml:space="preserve"><value>Arkisto ei ole käytettävissä tai on vain luku -tilassa.</value></data>
<data name="Archive.Convert.Blocked.Unreadable" xml:space="preserve"><value>Sarjatiedostoa ei voi lukea.</value></data>
<data name="Archive.Convert.Confirm" xml:space="preserve"><value>Muunna</value></data>
<data name="Archive.Convert.CopyUnfinished" xml:space="preserve"><value>Toinen muunnos teki siitä kopion tähän muotoon, eikä se ole valmis; suorita se loppuun tai yritä sitä uudelleen ensin.</value></data>
<data name="Archive.Convert.Done.one" xml:space="preserve"><value>{0:N0} sarja muunnettu</value></data>
<data name="Archive.Convert.Done.other" xml:space="preserve"><value>{0:N0} sarjaa muunnettu</value></data>
<data name="Archive.Convert.Failed.Changed" xml:space="preserve"><value>Kuva ei enää vastaa arkistoitua kopiota; tarkista sarja.</value></data>
<data name="Archive.Convert.Failed.ColorProfile" xml:space="preserve"><value>Sen väriprofiilia ei voi tässä muodossa säilyttää eikä muuntaa.</value></data>
<data name="Archive.Convert.Failed.Damaged" xml:space="preserve"><value>Sen pikseleissä on arvoja, jotka eivät ole lukuja: tiedosto on vaurioitunut.</value></data>
<data name="Archive.Convert.Failed.EightBit" xml:space="preserve"><value>Tämä tietokone kehittää tämän RAW-kuvan vain 8-bittisenä, mikä ei riitä 16-bittiseen tiedostoon; JPEG-muotoon sen voi muuntaa.</value></data>
<data name="Archive.Convert.Failed.Full" xml:space="preserve"><value>Arkiston levy on täynnä.</value></data>
<data name="Archive.Convert.Failed.NoDecoder" xml:space="preserve"><value>Mikään tämän tietokoneen dekooderi ei lue sitä täydellä tarkkuudella.</value></data>
<data name="Archive.Convert.Failed.NotVerified" xml:space="preserve"><value>Muunnettu tiedosto ei uudelleen luettuna vastannut kirjoitettua.</value></data>
<data name="Archive.Convert.Failed.Other" xml:space="preserve"><value>Muunnettua tiedostoa ei voitu luoda.</value></data>
<data name="Archive.Convert.Failed.PreviewOnly" xml:space="preserve"><value>Tämä tietokone lukee sen vain upotetusta esikatselukuvasta: muunna se tietokoneella, joka lukee sen täydellä tarkkuudella.</value></data>
<data name="Archive.Convert.Failed.TooLarge" xml:space="preserve"><value>Se on suurempi kuin mitä tämä muoto voi sisältää, Chronos pystyy lukemaan takaisin tai yhden kuvan muistiin mahtuu.</value></data>
<data name="Archive.Convert.Failed.Unreadable" xml:space="preserve"><value>Kuvaa ei voitu purkaa.</value></data>
<data name="Archive.Convert.Format" xml:space="preserve"><value>Muoto</value></data>
<data name="Archive.Convert.Heading.one" xml:space="preserve"><value>Muunna {0:N0} sarja</value></data>
<data name="Archive.Convert.Heading.other" xml:space="preserve"><value>Muunna {0:N0} sarjaa</value></data>
<data name="Archive.Convert.HeadingAll" xml:space="preserve"><value>Muunna arkisto {0}</value></data>
<data name="Archive.Convert.Mode" xml:space="preserve"><value>Tila</value></data>
<data name="Archive.Convert.NewHeading.one" xml:space="preserve"><value>Muunnetaanko {0:N0} sarja uudeksi sarjaksi?</value></data>
<data name="Archive.Convert.NewHeading.other" xml:space="preserve"><value>Muunnetaanko {0:N0} sarjaa uusiksi sarjoiksi?</value></data>
<data name="Archive.Convert.NewLeftOut.one" xml:space="preserve"><value>{0:N0} kuva jää kopioimatta: se jää vain lähdesarjaansa suunnitelmassa näkyvästä syystä.</value></data>
<data name="Archive.Convert.NewLeftOut.other" xml:space="preserve"><value>{0:N0} kuvaa jää kopioimatta: ne jäävät vain lähdesarjaansa suunnitelmassa näkyvistä syistä.</value></data>
<data name="Archive.Convert.NewMessage" xml:space="preserve"><value>{0} ({1}) muunnetaan muotoon {2} uuteen sarjaan kunkin lähdesarjan viereen; alkuperäiset tiedostot pysyvät ennallaan.</value></data>
<data name="Archive.Convert.NewSequence" xml:space="preserve"><value>Uusi sarja</value></data>
<data name="Archive.Convert.NotCopied.ColorProfile" xml:space="preserve"><value>Kuvia, joiden väriprofiilia tämä muoto ei voi säilyttää eikä muuntaa, ei kopioida uuteen sarjaan.</value></data>
<data name="Archive.Convert.NotCopied.EightBit" xml:space="preserve"><value>RAW-kuvia, jotka tämä tietokone kehittää vain 8-bittisinä, ei kopioida uuteen sarjaan; JPEG-muotoon ne voi muuntaa.</value></data>
<data name="Archive.Convert.NotCopied.Inaccessible" xml:space="preserve"><value>Kuvia, jotka ovat auki toisessa ohjelmassa tai joita ei voi avata, ei kopioida uuteen sarjaan; suunnittele uudelleen, kun ne ovat vapaina.</value></data>
<data name="Archive.Convert.NotCopied.Missing" xml:space="preserve"><value>Puuttuvia kuvia ei kopioida uuteen sarjaan.</value></data>
<data name="Archive.Convert.NotCopied.NoNativeDecoder" xml:space="preserve"><value>Kuvia, joiden muotoa tämä tietokone ei voi lukea täydellä tarkkuudella, ei kopioida uuteen sarjaan.</value></data>
<data name="Archive.Convert.NotCopied.PreviewOnly" xml:space="preserve"><value>Kuvia, jotka luetaan täällä vain niiden upotetusta esikatselukuvasta, ei kopioida uuteen sarjaan.</value></data>
<data name="Archive.Convert.NotCopied.SameFormat" xml:space="preserve"><value>Valmiiksi tässä muodossa olevia kuvia ei kopioida uuteen sarjaan.</value></data>
<data name="Archive.Convert.NotCopied.TooLarge" xml:space="preserve"><value>Kuvia, jotka ovat suurempia kuin mitä tämä muoto voi sisältää tai Chronos pystyy lukemaan takaisin, ei kopioida uuteen sarjaan.</value></data>
<data name="Archive.Convert.NotCopied.Undecodable" xml:space="preserve"><value>Lukukelvottomia kuvia ei kopioida uuteen sarjaan.</value></data>
<data name="Archive.Convert.NotCopied.Unhashed" xml:space="preserve"><value>Koskaan tarkistamattomia kuvia ei kopioida uuteen sarjaan; tarkista sarja ensin.</value></data>
<data name="Archive.Convert.NotCopiedPhotos.one" xml:space="preserve"><value>{0:N0} kuva kopioimatta</value></data>
<data name="Archive.Convert.NotCopiedPhotos.other" xml:space="preserve"><value>{0:N0} kuvaa kopioimatta</value></data>
<data name="Archive.Convert.NotPlaced" xml:space="preserve"><value>Muunnettuja kuvia ei voitu siirtää paikoilleen. {0}</value></data>
<data name="Archive.Convert.PhotoFailed" xml:space="preserve"><value>Tiedostoa {0} ei voitu muuntaa. {1}</value></data>
<data name="Archive.Convert.PhotoHeld" xml:space="preserve"><value>Jokin sen kuvista on auki toisessa ohjelmassa tai sitä ei voi avata; yritä uudelleen, kun kuva on vapaa.</value></data>
<data name="Archive.Convert.Quality" xml:space="preserve"><value>Laatu</value></data>
<data name="Archive.Convert.Replace" xml:space="preserve"><value>Korvaa</value></data>
<data name="Archive.Convert.ReplaceHeading.one" xml:space="preserve"><value>Korvataanko {0:N0} sarjan kuvat?</value></data>
<data name="Archive.Convert.ReplaceHeading.other" xml:space="preserve"><value>Korvataanko {0:N0} sarjan kuvat?</value></data>
<data name="Archive.Convert.ReplaceMessage" xml:space="preserve"><value>{0} ({1}) korvataan muunnoksella muotoon {2}; alkuperäiset tiedostot siirtyvät arkiston roskakoriin, josta ne voi palauttaa, kunnes roskakori tyhjennetään.</value></data>
<data name="Archive.Convert.Sizes" xml:space="preserve"><value>{0} → {1}</value></data>
<data name="Archive.Convert.Skipped.ColorProfile" xml:space="preserve"><value>Kuvat, joiden väriprofiilia tämä muoto ei voi säilyttää eikä muuntaa, pysyvät ennallaan.</value></data>
<data name="Archive.Convert.Skipped.EightBit" xml:space="preserve"><value>RAW-kuvat, jotka tämä tietokone kehittää vain 8-bittisinä, pysyvät ennallaan; JPEG-muotoon ne voi muuntaa.</value></data>
<data name="Archive.Convert.Skipped.Inaccessible" xml:space="preserve"><value>Kuvat, jotka ovat auki toisessa ohjelmassa tai joita ei voi avata, pysyvät ennallaan; suunnittele uudelleen, kun ne ovat vapaina.</value></data>
<data name="Archive.Convert.Skipped.Missing" xml:space="preserve"><value>Puuttuvat kuvat pysyvät ennallaan.</value></data>
<data name="Archive.Convert.Skipped.NoNativeDecoder" xml:space="preserve"><value>Kuvat, joiden muotoa tämä tietokone ei voi lukea täydellä tarkkuudella, pysyvät ennallaan.</value></data>
<data name="Archive.Convert.Skipped.PreviewOnly" xml:space="preserve"><value>Kuvat, jotka luetaan täällä vain niiden upotetusta esikatselukuvasta, pysyvät ennallaan.</value></data>
<data name="Archive.Convert.Skipped.SameFormat" xml:space="preserve"><value>Valmiiksi tässä muodossa olevat kuvat pysyvät ennallaan.</value></data>
<data name="Archive.Convert.Skipped.TooLarge" xml:space="preserve"><value>Kuvat, jotka ovat suurempia kuin mitä tämä muoto voi sisältää tai Chronos pystyy lukemaan takaisin, pysyvät ennallaan.</value></data>
<data name="Archive.Convert.Skipped.Undecodable" xml:space="preserve"><value>Lukukelvottomat kuvat pysyvät ennallaan.</value></data>
<data name="Archive.Convert.Skipped.Unhashed" xml:space="preserve"><value>Koskaan tarkistamattomat kuvat pysyvät ennallaan; tarkista sarja ensin.</value></data>
<data name="Archive.Convert.SkippedPhotos.one" xml:space="preserve"><value>{0:N0} kuva ohitettu</value></data>
<data name="Archive.Convert.SkippedPhotos.other" xml:space="preserve"><value>{0:N0} kuvaa ohitettu</value></data>
<data name="Archive.Convert.Space" xml:space="preserve"><value>Tarvitaan {0}, vapaana {1}</value></data>
<data name="Archive.Convert.SpaceShort" xml:space="preserve"><value>Tarvitaan {0}, vapaana vain {1}: vapauta ensin tilaa.</value></data>
<data name="Archive.Convert.SpaceUnknown" xml:space="preserve"><value>Tarvitaan {0}; vapaata tilaa ei voi mitata.</value></data>
<data name="Archive.Convert.Target.LinearDng" xml:space="preserve"><value>Lineaarinen DNG</value></data>
<data name="Archive.Convert.Target.Tiff16" xml:space="preserve"><value>TIFF 16-bittinen</value></data>
<data name="Archive.Convert.UndoFailed" xml:space="preserve"><value>Alkuperäisiä tiedostoja ei voitu palauttaa</value></data>
<data name="Archive.Convert.UndoNothing" xml:space="preserve"><value>Korvatut alkuperäiset tiedostot eivät ole enää roskakorissa.</value></data>
<data name="Archive.Convert.Undone.one" xml:space="preserve"><value>Alkuperäiset tiedostot palautettu {0:N0} sarjaan</value></data>
<data name="Archive.Convert.Undone.other" xml:space="preserve"><value>Alkuperäiset tiedostot palautettu {0:N0} sarjaan</value></data>
<data name="Archive.Convert.UndoneNew.one" xml:space="preserve"><value>{0:N0} sarja oli muuttunut sillä välin: sen alkuperäiset tiedostot palautettiin uutena sarjana.</value></data>
<data name="Archive.Convert.UndoneNew.other" xml:space="preserve"><value>{0:N0} sarjaa oli muuttunut sillä välin: niiden alkuperäiset tiedostot palautettiin uusina sarjoina.</value></data>
<data name="Archive.Convert.Unstaged" xml:space="preserve"><value>Tiedoston {0} muunnos ei ole enää valmisteltujen tiedostojen joukossa; uusi yritys muuntaa sen uudelleen.</value></data>
<data name="Archive.Copy.Title" xml:space="preserve"><value>Arkistoon kopioitava kansio</value></data>
<data name="Archive.Delete.Action" xml:space="preserve"><value>Siirrä roskakoriin</value></data>
<data name="Archive.Delete.Blocked" xml:space="preserve"><value>Ei siirretty: {0} · {1}</value></data>
@@ -75,6 +153,9 @@
<data name="Archive.Duplicates.Title" xml:space="preserve"><value>Kaksoiskappaleet</value></data>
<data name="Archive.Empty" xml:space="preserve"><value>Ei vielä arkistoa</value></data>
<data name="Archive.Error.Busy" xml:space="preserve"><value>Toinen Chronos ({0}) kirjoittaa tänne. Yritä hetken kuluttua uudelleen.</value></data>
<data name="Archive.Error.ConvertKept.one" xml:space="preserve"><value>{0:N0} sarjan muunnos ei toteutunut suunnitellusti; työn loki kertoo syyn.</value></data>
<data name="Archive.Error.ConvertKept.other" xml:space="preserve"><value>{0:N0} sarjan muunnos ei toteutunut suunnitellusti; työn loki kertoo syyn.</value></data>
<data name="Archive.Error.ConvertSpace" xml:space="preserve"><value>Muunnos tarvitsee arkiston taltiolle {0} vapaata tilaa, ja vapaana on {1}.</value></data>
<data name="Archive.Error.CopyMismatch" xml:space="preserve"><value>Tiedoston {0} kopio ei vastaa alkuperäistä.</value></data>
<data name="Archive.Error.DuplicateLost" xml:space="preserve"><value>Tiedostoa {0} ei voitu lisätä sarjaan.</value></data>
<data name="Archive.Error.InLibrary" xml:space="preserve"><value>{0} on jo kirjastossa.</value></data>
@@ -92,8 +173,8 @@
<data name="Archive.Error.SourceGone" xml:space="preserve"><value>Korttia tai kansiota {0} ei ole enää saatavilla.</value></data>
<data name="Archive.Error.StalePlan" xml:space="preserve"><value>Arkisto muuttui tämän suunnitelman laatimisen jälkeen.</value></data>
<data name="Archive.Error.TrashChanged" xml:space="preserve"><value>Roskakori muuttui tarkistuksen jälkeen; mitään ei poistettu.</value></data>
<data name="Archive.Error.TrashKept.one" xml:space="preserve"><value>{0:N0} roskakorin kohde säilytettiin: se muuttui, tai korvaava tiedosto ei enää täsmää.</value></data>
<data name="Archive.Error.TrashKept.other" xml:space="preserve"><value>{0:N0} roskakorin kohdetta säilytettiin: ne muuttuivat, tai korvaava tiedosto ei enää täsmää.</value></data>
<data name="Archive.Error.TrashKept.one" xml:space="preserve"><value>{0:N0} kohde jäi roskakoriin; työn loki kertoo syyn.</value></data>
<data name="Archive.Error.TrashKept.other" xml:space="preserve"><value>{0:N0} kohdetta jäi roskakoriin; työn loki kertoo syyn.</value></data>
<data name="Archive.Error.TrashMismatch" xml:space="preserve"><value>Mikään tämän roskakorin kohteen tiedostoista ei enää vastaa kirjattuja tietoja; kohde jää roskakoriin.</value></data>
<data name="Archive.Failed.Access" xml:space="preserve"><value>Chronos ei saanut käyttöoikeutta arkistoon.</value></data>
<data name="Archive.Failed.Files" xml:space="preserve"><value>Arkiston tiedostoa ei voitu lukea tai kirjoittaa.</value></data>
@@ -132,6 +213,15 @@
<data name="Archive.Log.AuditKept" xml:space="preserve"><value>Valvontaloki säilytetty kokonaan</value></data>
<data name="Archive.Log.AuditPurged" xml:space="preserve"><value>Valvontalokin merkintöjä poistettu: {0}</value></data>
<data name="Archive.Log.BackupDone" xml:space="preserve"><value>Indeksi kopioitu kohteeseen {0} ({1}); säilytettyjä kopioita: {2}</value></data>
<data name="Archive.Log.ConvertBlocked" xml:space="preserve"><value>Jätetty ennalleen, varattu tai lukukelvoton: {0}</value></data>
<data name="Archive.Log.ConvertChanged" xml:space="preserve"><value>Jätetty ennalleen, muuttui suunnitelman jälkeen: {0}. Uusi yritys jättää sen ennalleen: muunna se uudelleen uuden suunnitelman pohjalta.</value></data>
<data name="Archive.Log.ConvertDone" xml:space="preserve"><value>Muunnettuja sarjoja: {0}, uusia sarjoja: {1}, kuvia: {2}</value></data>
<data name="Archive.Log.ConvertFailed" xml:space="preserve"><value>Jätetty ennalleen: {0}. {1}</value></data>
<data name="Archive.Log.ConvertLeftOut" xml:space="preserve"><value>{0}: kuvia jäi muuntamatta ja vain lähdesarjaan: {1}</value></data>
<data name="Archive.Log.ConvertNothing" xml:space="preserve"><value>Ei muunnettavaa: {0}</value></data>
<data name="Archive.Log.ConvertSuperseded" xml:space="preserve"><value>{0}: toinen muunnos on tehnyt kopionsa tähän muotoon sen jälkeen, kun tämä vahvistettiin; toista kopiota ei tehdä.</value></data>
<data name="Archive.Log.Converted" xml:space="preserve"><value>{0}: muunnoksella korvattuja kuvia: {1}</value></data>
<data name="Archive.Log.ConvertedNew" xml:space="preserve"><value>{0}: uuteen sarjaan muunnettuja kuvia: {1}</value></data>
<data name="Archive.Log.DryRun" xml:space="preserve"><value>Testiajo: mitään ei muutettu.</value></data>
<data name="Archive.Log.DuplicateGroup" xml:space="preserve"><value>Ylimääräiset kopiot tiedostosta {0}: {1}</value></data>
<data name="Archive.Log.DuplicatesDone" xml:space="preserve"><value>Kaksoiskappaleryhmiä: {0}, ylimääräisiä kopioita: {1}</value></data>
@@ -166,9 +256,22 @@
<data name="Archive.Log.SequenceMissing" xml:space="preserve"><value>Sarjaa ei löydy: {0}</value></data>
<data name="Archive.Log.StepFailed" xml:space="preserve"><value>Siivousvaihe {0} epäonnistui: {1}</value></data>
<data name="Archive.Log.StepUnknown" xml:space="preserve"><value>Siivousvaihetta ei tunneta täällä: {0}</value></data>
<data name="Archive.Log.SyncChanged" xml:space="preserve"><value>{0}: muuttunut arkistoinnin jälkeen, ei lähetetty</value></data>
<data name="Archive.Log.SyncDeletedHere" xml:space="preserve"><value>{0}: poistettu tällä tietokoneella, ei ladattu</value></data>
<data name="Archive.Log.SyncDeletedThere" xml:space="preserve"><value>{0}: poistettu palvelimelta, ei lähetetty</value></data>
<data name="Archive.Log.SyncFrameChanged" xml:space="preserve"><value>{0}: vastaava kuva täällä muuttui sillä välin, ei ladattu</value></data>
<data name="Archive.Log.SyncMissing" xml:space="preserve"><value>{0}: puuttuu, ei lähetetty</value></data>
<data name="Archive.Log.SyncNoPreview.one" xml:space="preserve"><value>{0:N0} kuvalla ei ole palvelimella proxya eikä pikkukuvaa</value></data>
<data name="Archive.Log.SyncNoPreview.other" xml:space="preserve"><value>{0:N0} kuvalla ei ole palvelimella proxya eikä pikkukuvaa</value></data>
<data name="Archive.Log.TrashEmptied" xml:space="preserve"><value>Poistettuja kohteita: {0}, koko: {1}</value></data>
<data name="Archive.Log.TrashEntry" xml:space="preserve"><value>Roskakorissa {0} alkaen: {1} ({2})</value></data>
<data name="Archive.Log.TrashKept" xml:space="preserve"><value>Säilytetty roskakorissa: {0}</value></data>
<data name="Archive.Log.TrashKept" xml:space="preserve"><value>Jäi roskakoriin, muuttui suunnitelman jälkeen: {0}</value></data>
<data name="Archive.Log.TrashKeptBusy" xml:space="preserve"><value>Jäi roskakoriin, sen sarja oli varattuna: {0}</value></data>
<data name="Archive.Log.TrashKeptMismatch" xml:space="preserve"><value>Jäi roskakoriin, sen alkuperäisten tiedostojen muunnos ei enää täsmää: {0}</value></data>
<data name="Archive.Log.TrashKeptStaleIndex" xml:space="preserve"><value>Jäi roskakoriin, indeksi luettelee sen sarjan, jota arkistossa ei enää ole; luo indeksi uudelleen: {0}</value></data>
<data name="Archive.Log.TrashKeptUnhashed" xml:space="preserve"><value>Jäi roskakoriin, sen sarjan kuvaa ei ole koskaan tarkistettu; tarkista sarja: {0}</value></data>
<data name="Archive.Log.TrashKeptUnknown" xml:space="preserve"><value>Jäi roskakoriin, arkisto ei näytä, mitä sen alkuperäisten tiedostojen muunnokselle tapahtui; palauta se säilyttääksesi ne: {0}</value></data>
<data name="Archive.Log.TrashKeptUnreadable" xml:space="preserve"><value>Jäi roskakoriin, sen sarjaa mahdollisesti sisältävän kansion sivutiedosto puuttuu tai sitä ei voi lukea; skannaa arkisto: {0}</value></data>
<data name="Archive.Log.TrashOffline" xml:space="preserve"><value>Roskakoria ei tarkistettu: arkistoon ei saada yhteyttä</value></data>
<data name="Archive.Log.TrashReport" xml:space="preserve"><value>Vanhoja roskakorin kohteita: {0}, koko: {1}; mitään ei poistettu</value></data>
<data name="Archive.Log.VerifyDone" xml:space="preserve"><value>Tarkistettuja kuvia: {0}, ehjiä: {1}, tiiviste laskettu: {2}, ongelmallisia: {3}</value></data>
@@ -249,6 +352,7 @@
<data name="Archive.Set.All.other" xml:space="preserve"><value>{0:N0} sarjaa · kaikki</value></data>
<data name="Archive.Set.Analyse" xml:space="preserve"><value>Analysoi</value></data>
<data name="Archive.Set.ClearFilter" xml:space="preserve"><value>Tyhjennä suodatin</value></data>
<data name="Archive.Set.Convert" xml:space="preserve"><value>Muunna…</value></data>
<data name="Archive.Set.Delete" xml:space="preserve"><value>Poista…</value></data>
<data name="Archive.Set.Export" xml:space="preserve"><value>Vie CSV</value></data>
<data name="Archive.Set.Filter" xml:space="preserve"><value>Joukon suodatin</value></data>
@@ -278,6 +382,7 @@
<data name="Archive.Toolbar.Scan" xml:space="preserve"><value>Skannaa</value></data>
<data name="Archive.Toolbar.Verify" xml:space="preserve"><value>Tarkista</value></data>
<data name="Archive.Trash.Checking" xml:space="preserve"><value>Tarkistetaan roskakoria…</value></data>
<data name="Archive.Trash.ConversionDeleted" xml:space="preserve"><value>muunnos poistettu</value></data>
<data name="Archive.Trash.Deleted" xml:space="preserve"><value>Poistettu {0}</value></data>
<data name="Archive.Trash.Empty" xml:space="preserve"><value>Roskakori on tyhjä</value></data>
<data name="Archive.Trash.EmptyAction" xml:space="preserve"><value>Tyhjennä…</value></data>
+1
View File
@@ -69,6 +69,7 @@
<data name="Jobs.Kind.Adopt" xml:space="preserve"><value>Kansion sisällytys</value></data>
<data name="Jobs.Kind.Backup" xml:space="preserve"><value>Indeksin varmuuskopiointi</value></data>
<data name="Jobs.Kind.Cleanup" xml:space="preserve"><value>Siivous</value></data>
<data name="Jobs.Kind.Convert" xml:space="preserve"><value>Muunnos</value></data>
<data name="Jobs.Kind.DeepAnalyse" xml:space="preserve"><value>Syväanalyysi</value></data>
<data name="Jobs.Kind.Download" xml:space="preserve"><value>Lataus</value></data>
<data name="Jobs.Kind.Duplicates" xml:space="preserve"><value>Kaksoiskappaleet</value></data>
+2
View File
@@ -6,6 +6,7 @@
<resheader name="writer"><value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader>
<data name="Library.Action.Analyse" xml:space="preserve"><value>Analysoi</value></data>
<data name="Library.Action.ClearSelection" xml:space="preserve"><value>Tyhjennä valinta</value></data>
<data name="Library.Action.Convert" xml:space="preserve"><value>Muunna…</value></data>
<data name="Library.Action.Delete" xml:space="preserve"><value>Poista…</value></data>
<data name="Library.Action.Download" xml:space="preserve"><value>Lataa</value></data>
<data name="Library.Action.ExportList" xml:space="preserve"><value>Vie luettelo</value></data>
@@ -32,6 +33,7 @@
<data name="Library.Blocked.NothingToDownload" xml:space="preserve"><value>Valituilla sarjoilla ei ole palvelimelta haettavaa.</value></data>
<data name="Library.Blocked.NothingToUpload" xml:space="preserve"><value>Palvelimella on jo kaikki, mitä valitut sarjat sisältävät.</value></data>
<data name="Library.Blocked.OneArchive" xml:space="preserve"><value>Uudelleenjärjestely käsittelee kerrallaan vain yhden arkiston sarjoja.</value></data>
<data name="Library.Blocked.OneArchiveConvert" xml:space="preserve"><value>Muunnos käsittelee kerrallaan vain yhden arkiston sarjoja.</value></data>
<data name="Library.Blocked.ServerOnly" xml:space="preserve"><value>Vain tällä tietokoneella oleville sarjoille; valitut sarjat ovat palvelimella.</value></data>
<data name="Library.Blocked.Transferring" xml:space="preserve"><value>Tämän sarjan siirto on jo käynnissä.</value></data>
<data name="Library.ClearFilters" xml:space="preserve"><value>Tyhjennä suodattimet</value></data>
+4
View File
@@ -21,6 +21,8 @@
<data name="Server.Conflict.TakeServer.Message" xml:space="preserve"><value>Tämän tietokoneen asetukset sarjalle {0} korvataan palvelinkopiolla.</value></data>
<data name="Server.Conflict.TakeServer.Title" xml:space="preserve"><value>Otetaanko palvelimen asetukset?</value></data>
<data name="Server.Connect" xml:space="preserve"><value>Yhdistä</value></data>
<data name="Server.Convert.OnPc" xml:space="preserve"><value>Muunna nämä kuvat tietokoneella: palvelin ei voi lukea niitä täydellä tarkkuudella.</value></data>
<data name="Server.Convert.OnPcNew" xml:space="preserve"><value>Ei kopioida uuteen sarjaan: palvelin ei voi lukea näitä kuvia täydellä tarkkuudella; muunna ne tietokoneella.</value></data>
<data name="Server.Disconnect" xml:space="preserve"><value>Katkaise yhteys</value></data>
<data name="Server.Empty" xml:space="preserve"><value>Ei yhteyttä palvelimeen</value></data>
<data name="Server.Error.AccountLocked" xml:space="preserve"><value>Liian monta epäonnistunutta kirjautumista; tili on lukittu hetkeksi.</value></data>
@@ -71,7 +73,9 @@
<data name="Server.Error.MethodNotAllowed" xml:space="preserve"><value>Tätä metodia ei sallita täällä.</value></data>
<data name="Server.Error.NestedTarget" xml:space="preserve"><value>Uusi kansio tulisi toisen sarjan kansion sisään.</value></data>
<data name="Server.Error.NotChronos" xml:space="preserve"><value>Osoitteessa ei ole Chronos-palvelinta.</value></data>
<data name="Server.Error.NotEnoughSpace" xml:space="preserve"><value>Arkiston taltiolla ei ole muunnoksen tarvitsemaa tilaa.</value></data>
<data name="Server.Error.NotFound" xml:space="preserve"><value>Ei löytynyt.</value></data>
<data name="Server.Error.NothingToConvert" xml:space="preserve"><value>Suunnitelma ei muunna mitään: jokainen kuva ohitetaan tai jokainen sarja on estetty.</value></data>
<data name="Server.Error.PasswordChangeRequired" xml:space="preserve"><value>Vaihda ensin salasanasi.</value></data>
<data name="Server.Error.PhotoRemoved" xml:space="preserve"><value>Kuva poistettiin sarjasta sen lähetyksen aikana, joten sitä ei lisätty.</value></data>
<data name="Server.Error.PhotoUnreadable" xml:space="preserve"><value>Tiedostoa {0} ei voi lukea, eivätkä muut kopiot saisi ilman sen tiivistettä tietää sen poistamisesta; sulje sitä käyttävä ohjelma tai tarkista sen käyttöoikeudet ja yritä sitten uudelleen.</value></data>
+19 -1
View File
@@ -27,6 +27,21 @@
<data name="Tooltips.Archive.ClearFilter" xml:space="preserve"><value>Näytä taas kaikki valinnan sarjat</value></data>
<data name="Tooltips.Archive.CloseDialog" xml:space="preserve"><value>Sulje muuttamatta mitään · Esc</value></data>
<data name="Tooltips.Archive.Collapse" xml:space="preserve"><value>Piilota tämän vuoden sarjat</value></data>
<data name="Tooltips.Archive.ConvertApplyNew" xml:space="preserve"><value>Vahvista ja lisää sitten jonoon työ, joka muuntaa kopiot uusiin sarjoihin · keskeytä ja jatka sitä Työt-näkymässä</value></data>
<data name="Tooltips.Archive.ConvertApplyReplace" xml:space="preserve"><value>Vahvista kirjoittamalla kuvien määrä ja lisää sitten jonoon työ, joka korvaa ne muunnoksilla · keskeytä ja jatka sitä Työt-näkymässä</value></data>
<data name="Tooltips.Archive.ConvertBack" xml:space="preserve"><value>Takaisin suunnitelmaan; mitään ei muunneta</value></data>
<data name="Tooltips.Archive.ConvertDng" xml:space="preserve"><value>Lineaarinen DNG, 16-bittinen ja häviötön · jokainen RAW-editori lukee sen; valinta arkistointiin</value></data>
<data name="Tooltips.Archive.ConvertJpeg" xml:space="preserve"><value>8-bittinen JPEG alla asetetulla laadulla · pienimmät tiedostot; osa yksityiskohdista menetetään</value></data>
<data name="Tooltips.Archive.ConvertModeNew" xml:space="preserve"><value>Muunnetut kopiot menevät uuteen sarjaan kunkin sarjan viereen; alkuperäiset tiedostot pysyvät ennallaan</value></data>
<data name="Tooltips.Archive.ConvertModeReplace" xml:space="preserve"><value>Muunnetut tiedostot korvaavat kuvat niiden sarjoissa; alkuperäiset tiedostot siirtyvät arkiston roskakoriin, josta ne voi palauttaa, kunnes roskakori tyhjennetään</value></data>
<data name="Tooltips.Archive.ConvertNew" xml:space="preserve"><value>Lisää jonoon työ, joka muuntaa kuvat uusiin sarjoihin ja tarkistaa jokaisen muunnoksen; alkuperäisiin tiedostoihin ei kosketa</value></data>
<data name="Tooltips.Archive.ConvertPlan" xml:space="preserve"><value>Sarjat, joiden kuvat korvataan</value></data>
<data name="Tooltips.Archive.ConvertPlanNew" xml:space="preserve"><value>Uusiksi sarjoiksi kopioitavat sarjat ja kuvat, jotka kustakin jäävät pois</value></data>
<data name="Tooltips.Archive.ConvertQuality" xml:space="preserve"><value>JPEG-laatu 1–100 · 95 säilyttää hienot yksityiskohdat; pienempi arvo tuottaa pienempiä tiedostoja</value></data>
<data name="Tooltips.Archive.ConvertReplace.one" xml:space="preserve"><value>Korvaa {0:N0} kuva sen muunnoksella; kirjoita ensin yllä oleva luku</value></data>
<data name="Tooltips.Archive.ConvertReplace.other" xml:space="preserve"><value>Korvaa {0:N0} kuvaa niiden muunnoksilla; kirjoita ensin yllä oleva luku</value></data>
<data name="Tooltips.Archive.ConvertTiff" xml:space="preserve"><value>16-bittinen TIFF häviöttömästi pakattuna · suuria tiedostoja, jotka jokainen editori avaa</value></data>
<data name="Tooltips.Archive.ConvertUndo" xml:space="preserve"><value>Palauta alkuperäiset tiedostot roskakorista muunnostensa tilalle</value></data>
<data name="Tooltips.Archive.DeleteAction.one" xml:space="preserve"><value>Siirrä {0:N0} sarja roskakoriin; kirjoita ensin yllä oleva luku</value></data>
<data name="Tooltips.Archive.DeleteAction.other" xml:space="preserve"><value>Siirrä {0:N0} sarjaa roskakoriin; kirjoita ensin yllä oleva luku</value></data>
<data name="Tooltips.Archive.DeleteKeep" xml:space="preserve"><value>Älä muuta mitään</value></data>
@@ -82,6 +97,7 @@
<data name="Tooltips.Archive.Scan" xml:space="preserve"><value>Inkrementaalinen skannaus: uudet, muuttuneet ja poistetut tiedostot muokkausajan ja koon perusteella</value></data>
<data name="Tooltips.Archive.Set" xml:space="preserve"><value>Valitut vuodet ja sarjat (kaikki, jos mitään ei ole valittu) kameran, tilan tai tunnisteen mukaan rajattuina</value></data>
<data name="Tooltips.Archive.SetAnalyse" xml:space="preserve"><value>Suorita syväanalyysi joukon kaikille sarjoille</value></data>
<data name="Tooltips.Archive.SetConvert" xml:space="preserve"><value>Muunna joukon kuvat muotoon JPEG, TIFF tai DNG · ensin testiajo, sitten työ</value></data>
<data name="Tooltips.Archive.SetDelete" xml:space="preserve"><value>Siirrä joukko arkiston roskakoriin · näyttää ensin testiajon ja pyytää sitten vahvistamaan kirjoittamalla</value></data>
<data name="Tooltips.Archive.SetExport" xml:space="preserve"><value>Vie joukko CSV-tiedostona: yksi rivi sarjaa kohden</value></data>
<data name="Tooltips.Archive.SetProxies" xml:space="preserve"><value>Luo tai päivitä proxyt</value></data>
@@ -96,7 +112,7 @@
<data name="Tooltips.Archive.TitleTemplate" xml:space="preserve"><value>Nimimalli; title-paikkamerkki on nykyinen nimi · tarkistetaan kirjoittaessasi</value></data>
<data name="Tooltips.Archive.Trash" xml:space="preserve"><value>Tästä arkistosta poistetut sarjat ja kuvat; jokaisen voi palauttaa</value></data>
<data name="Tooltips.Archive.TrashEmpty" xml:space="preserve"><value>Poista tämän roskakorin kohteet pysyvästi sen jälkeen, kun niiden sisältö on tarkistettu ja poisto vahvistettu kirjoittamalla</value></data>
<data name="Tooltips.Archive.TrashEmptyPlan" xml:space="preserve"><value>Mitä arkistosta poistetaan pysyvästi</value></data>
<data name="Tooltips.Archive.TrashEmptyPlan" xml:space="preserve"><value>Mitä arkistosta poistetaan pysyvästi; alkuperäiset tiedostot, joiden muunnos on poistettu, voivat olla kuviensa viimeinen kopio</value></data>
<data name="Tooltips.Archive.TrashErase.one" xml:space="preserve"><value>Poista {0:N0} kohde pysyvästi; kirjoita ensin yllä oleva luku</value></data>
<data name="Tooltips.Archive.TrashErase.other" xml:space="preserve"><value>Poista {0:N0} kohdetta pysyvästi; kirjoita ensin yllä oleva luku</value></data>
<data name="Tooltips.Archive.TrashRestore" xml:space="preserve"><value>Siirrä tämä kohde takaisin: sarja kansioonsa ja kirjastoon, kuvat sarjaansa tiivisteen tarkistuksen jälkeen</value></data>
@@ -468,6 +484,8 @@
<data name="Tooltips.Library.List" xml:space="preserve"><value>Taulukko, jonka sarakkeet voi lajitella</value></data>
<data name="Tooltips.Library.Mass.Analyse.one" xml:space="preserve"><value>{0:N0} sarjan syväanalyysi tällä tietokoneella · suoritetaan yhtenä työnä</value></data>
<data name="Tooltips.Library.Mass.Analyse.other" xml:space="preserve"><value>{0:N0} sarjan syväanalyysi tällä tietokoneella · suoritetaan yhtenä työnä</value></data>
<data name="Tooltips.Library.Mass.Convert.one" xml:space="preserve"><value>Muunna {0:N0} sarjan kuvat muotoon JPEG, TIFF tai DNG · ensin testiajo, sitten työ</value></data>
<data name="Tooltips.Library.Mass.Convert.other" xml:space="preserve"><value>Muunna {0:N0} sarjan kuvat niiden arkistossa muotoon JPEG, TIFF tai DNG · ensin testiajo, sitten työ</value></data>
<data name="Tooltips.Library.Mass.Delete.one" xml:space="preserve"><value>Siirrä {0:N0} sarja arkistonsa roskakoriin · näyttää ensin testiajon ja pyytää sitten vahvistamaan kirjoittamalla</value></data>
<data name="Tooltips.Library.Mass.Delete.other" xml:space="preserve"><value>Siirrä {0:N0} sarjaa arkistonsa roskakoriin · näyttää ensin testiajon ja pyytää sitten vahvistamaan kirjoittamalla</value></data>
<data name="Tooltips.Library.Mass.Download.one" xml:space="preserve"><value>Hae palvelimelta, mitä {0:N0} sarjalta puuttuu täältä (alkuperäiset tiedostot tai renderöinnit) · suoritetaan siirtotyönä</value></data>
+69
View File
@@ -9,6 +9,7 @@
<data name="Admin.About.Title" xml:space="preserve"><value>Chronos Server</value></data>
<data name="Admin.About.Uptime" xml:space="preserve"><value>Actif depuis</value></data>
<data name="Admin.About.Version" xml:space="preserve"><value>Version</value></data>
<data name="Admin.Activity.ArchiveConverted" xml:space="preserve"><value>{0} a mis une conversion en file d'attente · {1}</value></data>
<data name="Admin.Activity.ArchiveReorganized" xml:space="preserve"><value>{0} a réorganisé l'archive · {1}</value></data>
<data name="Admin.Activity.ArchiveSettings" xml:space="preserve"><value>{0} a modifié l'organisation de l'archive</value></data>
<data name="Admin.Activity.FramesDeleted" xml:space="preserve"><value>{0} a supprimé {1}</value></data>
@@ -83,6 +84,68 @@
<data name="Admin.Common.TypeToConfirm.Tip" xml:space="preserve"><value>Saisissez le nom exactement comme il est affiché pour confirmer</value></data>
<data name="Admin.Common.TypeWord.Tip" xml:space="preserve"><value>Saisissez le mot exactement comme il est affiché ; majuscules et minuscules sont indifférentes</value></data>
<data name="Admin.Common.TypeWordFirst.Tip" xml:space="preserve"><value>Saisissez d'abord le mot ci-dessus</value></data>
<data name="Admin.Convert.Action" xml:space="preserve"><value>Convertir…</value></data>
<data name="Admin.Convert.Action.Tip" xml:space="preserve"><value>Convertir les photos des séquences sélectionnées en JPEG, TIFF-16 ou DNG linéaire ; un aperçu montre d'abord chaque séquence</value></data>
<data name="Admin.Convert.Apply" xml:space="preserve"><value>Convertir…</value></data>
<data name="Admin.Convert.Apply.Tip" xml:space="preserve"><value>Convertir comme le montre l'aperçu ; une confirmation est demandée d'abord</value></data>
<data name="Admin.Convert.Cancel.Tip" xml:space="preserve"><value>Fermer sans rien convertir</value></data>
<data name="Admin.Convert.ChooseMode" xml:space="preserve"><value>Choisissez Remplacer ou Nouvelle séquence pour convertir.</value></data>
<data name="Admin.Convert.ChooseMode.Tip" xml:space="preserve"><value>Choisissez d'abord Remplacer ou Nouvelle séquence</value></data>
<data name="Admin.Convert.Column.Converted" xml:space="preserve"><value>Converties</value></data>
<data name="Admin.Convert.Column.NotCopied" xml:space="preserve"><value>Non copiées</value></data>
<data name="Admin.Convert.Column.Sequence" xml:space="preserve"><value>Séquence</value></data>
<data name="Admin.Convert.Column.Size" xml:space="preserve"><value>Taille</value></data>
<data name="Admin.Convert.Column.Unchanged" xml:space="preserve"><value>Inchangées</value></data>
<data name="Admin.Convert.Confirm.New" xml:space="preserve"><value>Convertir</value></data>
<data name="Admin.Convert.Confirm.New.Tip" xml:space="preserve"><value>Mettre en file d'attente la tâche qui convertit les photos dans de nouvelles séquences, chaque conversion étant vérifiée ; les originaux restent intacts</value></data>
<data name="Admin.Convert.Confirm.Replace" xml:space="preserve"><value>Remplacer</value></data>
<data name="Admin.Convert.Confirm.Replace.Tip" xml:space="preserve"><value>Mettre en file d'attente la tâche qui convertit les photos, vérifie chaque conversion et met les originaux à la corbeille</value></data>
<data name="Admin.Convert.ConfirmNew.one" xml:space="preserve"><value>{0} photo est convertie en une copie dans une nouvelle séquence ; l'original reste tel quel.</value></data>
<data name="Admin.Convert.ConfirmNew.other" xml:space="preserve"><value>{0} photos sont converties en copies dans une nouvelle séquence à côté de chacune ; les originaux restent tels quels.</value></data>
<data name="Admin.Convert.ConfirmNewNotCopied.one" xml:space="preserve"><value>{0} photo n'est pas copiée dans la nouvelle séquence, pour la raison indiquée dans l'aperçu.</value></data>
<data name="Admin.Convert.ConfirmNewNotCopied.other" xml:space="preserve"><value>{0} photos ne sont pas copiées dans les nouvelles séquences, pour les raisons indiquées dans l'aperçu.</value></data>
<data name="Admin.Convert.ConfirmNewTitle" xml:space="preserve"><value>Convertir en {0} dans de nouvelles séquences ?</value></data>
<data name="Admin.Convert.ConfirmReplace.one" xml:space="preserve"><value>{0} photo dans {1} est remplacée par sa conversion ; l'original est mis à la corbeille, restaurable tant que la corbeille n'a pas été vidée.</value></data>
<data name="Admin.Convert.ConfirmReplace.other" xml:space="preserve"><value>{0} photos dans {1} sont remplacées par leurs conversions ; les originaux sont mis à la corbeille, restaurables tant que la corbeille n'a pas été vidée.</value></data>
<data name="Admin.Convert.ConfirmReplaceTitle" xml:space="preserve"><value>Remplacer les originaux par leur conversion en {0} ?</value></data>
<data name="Admin.Convert.Format" xml:space="preserve"><value>Format</value></data>
<data name="Admin.Convert.Format.Jpeg.Tip" xml:space="preserve"><value>JPEG 8 bits avec la couleur en pleine résolution, à la qualité indiquée à côté : les fichiers les plus petits, lisibles par tous les logiciels</value></data>
<data name="Admin.Convert.Format.LinearDng" xml:space="preserve"><value>DNG linéaire</value></data>
<data name="Admin.Convert.Format.LinearDng.Tip" xml:space="preserve"><value>DNG linéaire 16 bits compressé sans perte : le choix pour l'archivage, lisible par les logiciels de traitement RAW</value></data>
<data name="Admin.Convert.Format.Tiff16.Tip" xml:space="preserve"><value>TIFF sRGB 16 bits compressé sans perte : de gros fichiers qui conservent chaque nuance pour la retouche</value></data>
<data name="Admin.Convert.Gone" xml:space="preserve"><value>Une séquence sélectionnée n'est plus dans l'archive ; fermez et sélectionnez de nouveau.</value></data>
<data name="Admin.Convert.Mode" xml:space="preserve"><value>Mode</value></data>
<data name="Admin.Convert.Mode.NewSequence" xml:space="preserve"><value>Nouvelle séquence</value></data>
<data name="Admin.Convert.Mode.NewSequence.Tip" xml:space="preserve"><value>Les copies converties vont dans une nouvelle séquence à côté de chacune ; les originaux et leur séquence restent exactement tels quels</value></data>
<data name="Admin.Convert.Mode.Replace" xml:space="preserve"><value>Remplacer</value></data>
<data name="Admin.Convert.Mode.Replace.Tip" xml:space="preserve"><value>Les fichiers convertis deviennent les photos de la séquence ; les originaux sont mis à la corbeille de l'archive, restaurables tant que la corbeille n'a pas été vidée</value></data>
<data name="Admin.Convert.NoAnswer" xml:space="preserve"><value>Le serveur n'a pas répondu : vérifiez dans la page Tâches si la conversion a été mise en file d'attente avant de convertir de nouveau.</value></data>
<data name="Admin.Convert.NoSpace.Tip" xml:space="preserve"><value>Libérez d'abord de l'espace sur le volume de l'archive</value></data>
<data name="Admin.Convert.NotCopiedCount.one" xml:space="preserve"><value>{0} non copiée</value></data>
<data name="Admin.Convert.NotCopiedCount.other" xml:space="preserve"><value>{0} non copiées</value></data>
<data name="Admin.Convert.Nothing.Tip" xml:space="preserve"><value>Rien à convertir dans l'aperçu</value></data>
<data name="Admin.Convert.NothingToConvert" xml:space="preserve"><value>Rien à convertir : chaque photo reste telle quelle, pour les raisons indiquées.</value></data>
<data name="Admin.Convert.OpenJob" xml:space="preserve"><value>Ouvrir la tâche</value></data>
<data name="Admin.Convert.OpenJob.Tip" xml:space="preserve"><value>Afficher la tâche et son journal dans la page Tâches</value></data>
<data name="Admin.Convert.PlanChanged" xml:space="preserve"><value>L'archive a changé depuis l'aperçu ; vérifiez le nouvel aperçu et appliquez de nouveau.</value></data>
<data name="Admin.Convert.Planning" xml:space="preserve"><value>Planification…</value></data>
<data name="Admin.Convert.Planning.Tip" xml:space="preserve"><value>Le serveur lit chaque dossier de photos de la sélection : une grande archive demande plusieurs minutes, et l'aperçu apparaît une fois la lecture terminée</value></data>
<data name="Admin.Convert.PlanningFor" xml:space="preserve"><value>Planification… {0}</value></data>
<data name="Admin.Convert.Preview" xml:space="preserve"><value>Aperçu</value></data>
<data name="Admin.Convert.Preview.Tip" xml:space="preserve"><value>Ce que chaque séquence convertit et laisse tel quel, avec la taille avant et après (une estimation) ; rien n'a encore changé</value></data>
<data name="Admin.Convert.Quality" xml:space="preserve"><value>Qualité</value></data>
<data name="Admin.Convert.Quality.Tip" xml:space="preserve"><value>Qualité JPEG de 1 à 100 ; 95 conserve les détails fins, des valeurs plus basses donnent des fichiers plus petits</value></data>
<data name="Admin.Convert.QualityRange" xml:space="preserve"><value>Saisissez un nombre entier de 1 à 100.</value></data>
<data name="Admin.Convert.Queued" xml:space="preserve"><value>Conversion mise en file d'attente.</value></data>
<data name="Admin.Convert.ReplaceWord" xml:space="preserve"><value>remplacer</value></data>
<data name="Admin.Convert.Size.Tip" xml:space="preserve"><value>Taille actuelle des photos converties, puis l'estimation après conversion</value></data>
<data name="Admin.Convert.SkippedPhotos" xml:space="preserve"><value>{0} : {1}</value></data>
<data name="Admin.Convert.Title.one" xml:space="preserve"><value>Convertir {0} séquence</value></data>
<data name="Admin.Convert.Title.other" xml:space="preserve"><value>Convertir {0} séquences</value></data>
<data name="Admin.Convert.TitleAll" xml:space="preserve"><value>Convertir toutes les séquences</value></data>
<data name="Admin.Convert.TooMany" xml:space="preserve"><value>La conversion porte sur {0} séquences au plus à la fois, ou sur toutes : effacez les filtres et sélectionnez tout.</value></data>
<data name="Admin.Convert.Totals" xml:space="preserve"><value>Séquences converties : {0} · photos : {1} · inchangées : {2} · taille : {3} → {4}</value></data>
<data name="Admin.Convert.TotalsNew" xml:space="preserve"><value>Séquences converties : {0} · photos : {1} · non copiées : {2} · taille : {3} → {4}</value></data>
<data name="Admin.Dashboard.Activity" xml:space="preserve"><value>Activité récente</value></data>
<data name="Admin.Dashboard.AllLogs" xml:space="preserve"><value>Tous les journaux</value></data>
<data name="Admin.Dashboard.AllLogs.Tip" xml:space="preserve"><value>Ouvrir le journal d'audit</value></data>
@@ -133,6 +196,7 @@
<data name="Admin.Job.Kind.Adopt" xml:space="preserve"><value>Adoption</value></data>
<data name="Admin.Job.Kind.Backup" xml:space="preserve"><value>Sauvegarde</value></data>
<data name="Admin.Job.Kind.Cleanup" xml:space="preserve"><value>Nettoyage</value></data>
<data name="Admin.Job.Kind.Convert" xml:space="preserve"><value>Conversion</value></data>
<data name="Admin.Job.Kind.DeepAnalyse" xml:space="preserve"><value>Analyse approfondie</value></data>
<data name="Admin.Job.Kind.Duplicates" xml:space="preserve"><value>Doublons</value></data>
<data name="Admin.Job.Kind.EmptyTrash" xml:space="preserve"><value>Vidage de la corbeille</value></data>
@@ -344,6 +408,7 @@
<data name="Admin.Login.SignIn.Tip" xml:space="preserve"><value>Ouvrir une session pour administrer ce serveur</value></data>
<data name="Admin.Login.User" xml:space="preserve"><value>Utilisateur</value></data>
<data name="Admin.Login.User.Tip" xml:space="preserve"><value>Votre nom d'utilisateur sur ce serveur</value></data>
<data name="Admin.Logs.Action.ArchiveConverted" xml:space="preserve"><value>Photos converties</value></data>
<data name="Admin.Logs.Action.ArchiveReorganized" xml:space="preserve"><value>Archive réorganisée</value></data>
<data name="Admin.Logs.Action.ArchiveSettings" xml:space="preserve"><value>Organisation de l'archive</value></data>
<data name="Admin.Logs.Action.FramesDeleted" xml:space="preserve"><value>Photos supprimées</value></data>
@@ -793,6 +858,7 @@
<data name="Admin.Theme.Tip" xml:space="preserve"><value>Basculer entre le thème clair et le thème sombre</value></data>
<data name="Admin.Trash.Back" xml:space="preserve"><value>Bibliothèque</value></data>
<data name="Admin.Trash.Back.Tip" xml:space="preserve"><value>Retour à la Bibliothèque</value></data>
<data name="Admin.Trash.ConversionDeleted" xml:space="preserve"><value>conversion supprimée</value></data>
<data name="Admin.Trash.DeletedAt" xml:space="preserve"><value>Date de suppression</value></data>
<data name="Admin.Trash.DeletedBy" xml:space="preserve"><value>Supprimé par</value></data>
<data name="Admin.Trash.Emptied" xml:space="preserve"><value>Corbeille vidée.</value></data>
@@ -819,9 +885,12 @@
<data name="Admin.Trash.Photos" xml:space="preserve"><value>Photos</value></data>
<data name="Admin.Trash.Restore" xml:space="preserve"><value>Restaurer</value></data>
<data name="Admin.Trash.RestorePhotos.Tip" xml:space="preserve"><value>Remettre les photos dans leur séquence (une nouvelle si elle n'existe plus) ; chacune est d'abord contrôlée par rapport à son SHA-256</value></data>
<data name="Admin.Trash.RestoreReplaced.Tip" xml:space="preserve"><value>Remettre les originaux à la place de leurs conversions tant que celles-ci sont inchangées (les conversions sont mises à la corbeille), sinon dans une nouvelle séquence ; chacun est d'abord contrôlé par rapport à son SHA-256</value></data>
<data name="Admin.Trash.RestoreSequence.Tip" xml:space="preserve"><value>Replacer le dossier de la séquence dans la bibliothèque tel quel (à côté de son ancien emplacement si celui-ci est occupé) ; ses photos ne sont pas contrôlées par hachage : Vérifier s'en charge</value></data>
<data name="Admin.Trash.RestoredNew.one" xml:space="preserve"><value>{0} photo restaurée dans une nouvelle séquence.</value></data>
<data name="Admin.Trash.RestoredNew.other" xml:space="preserve"><value>{0} photos restaurées dans une nouvelle séquence.</value></data>
<data name="Admin.Trash.RestoredOriginals.one" xml:space="preserve"><value>{0} original est de retour dans {1} ; sa conversion est dans la corbeille.</value></data>
<data name="Admin.Trash.RestoredOriginals.other" xml:space="preserve"><value>{0} originaux sont de retour dans {1} ; leurs conversions sont dans la corbeille.</value></data>
<data name="Admin.Trash.RestoredPhotos.one" xml:space="preserve"><value>{0} photo est de retour dans {1}.</value></data>
<data name="Admin.Trash.RestoredPhotos.other" xml:space="preserve"><value>{0} photos sont de retour dans {1}.</value></data>
<data name="Admin.Trash.RestoredSequence" xml:space="preserve"><value>{0} est de retour dans la bibliothèque.</value></data>
+108 -3
View File
@@ -15,8 +15,10 @@
<data name="Archive.Blocked.Applying" xml:space="preserve"><value>Attendez que les modifications soient appliquées.</value></data>
<data name="Archive.Blocked.EmptySet" xml:space="preserve"><value>L'ensemble est vide : modifiez la sélection ou le filtre.</value></data>
<data name="Archive.Blocked.NoChanges" xml:space="preserve"><value>Rien ne changerait.</value></data>
<data name="Archive.Blocked.NoMode" xml:space="preserve"><value>Choisissez Remplacer ou Nouvelle séquence.</value></data>
<data name="Archive.Blocked.NoTemplate" xml:space="preserve"><value>Activez au moins un modèle.</value></data>
<data name="Archive.Blocked.NotOnline" xml:space="preserve"><value>L'archive doit être en ligne et accessible en écriture.</value></data>
<data name="Archive.Blocked.NothingToConvert" xml:space="preserve"><value>Rien à convertir : chaque photo est ignorée ou chaque séquence est bloquée.</value></data>
<data name="Archive.Blocked.Planning" xml:space="preserve"><value>Attendez la fin de la simulation.</value></data>
<data name="Archive.Blocked.Reading" xml:space="preserve"><value>Attendez la fin de la lecture de l'archive.</value></data>
<data name="Archive.Blocked.Searching" xml:space="preserve"><value>Une recherche est en cours ; annulez-la ou patientez.</value></data>
@@ -32,6 +34,82 @@
<data name="Archive.Confirm.Remove" xml:space="preserve"><value>Retirer la ligne</value></data>
<data name="Archive.Confirm.RemoveHeading" xml:space="preserve"><value>Retirer {0} de l'index ?</value></data>
<data name="Archive.Confirm.RemoveMessage" xml:space="preserve"><value>Son fichier annexe a disparu. Seule la ligne d'index est retirée ; aucun fichier n'est supprimé.</value></data>
<data name="Archive.Convert.AlreadyQueued" xml:space="preserve"><value>Une conversion de ces séquences est déjà en attente ou en cours ; suivez-la dans Tâches.</value></data>
<data name="Archive.Convert.Blocked.Busy" xml:space="preserve"><value>Une tâche est en cours sur cette séquence ; convertissez-la une fois la tâche terminée.</value></data>
<data name="Archive.Convert.Blocked.FramesChanged" xml:space="preserve"><value>La séquence a changé après le plan ; vérifiez de nouveau le plan.</value></data>
<data name="Archive.Convert.Blocked.Offline" xml:space="preserve"><value>L'archive est hors ligne ou en lecture seule.</value></data>
<data name="Archive.Convert.Blocked.Unreadable" xml:space="preserve"><value>Le fichier de séquence est illisible.</value></data>
<data name="Archive.Convert.Confirm" xml:space="preserve"><value>Convertir</value></data>
<data name="Archive.Convert.CopyUnfinished" xml:space="preserve"><value>Une autre conversion en a fait une copie dans ce format et n'est pas terminée ; terminez ou réessayez d'abord celle-ci.</value></data>
<data name="Archive.Convert.Done.one" xml:space="preserve"><value>{0:N0} séquence convertie</value></data>
<data name="Archive.Convert.Done.other" xml:space="preserve"><value>{0:N0} séquences converties</value></data>
<data name="Archive.Convert.Failed.Changed" xml:space="preserve"><value>La photo ne correspond plus à la copie archivée ; vérifiez la séquence.</value></data>
<data name="Archive.Convert.Failed.ColorProfile" xml:space="preserve"><value>Son profil colorimétrique ne peut être ni conservé ni converti dans ce format.</value></data>
<data name="Archive.Convert.Failed.Damaged" xml:space="preserve"><value>Ses pixels contiennent des valeurs qui ne sont pas des nombres : le fichier est endommagé.</value></data>
<data name="Archive.Convert.Failed.EightBit" xml:space="preserve"><value>Cet ordinateur ne développe ce RAW qu'en 8 bits, trop peu pour un fichier 16 bits ; le JPEG permet de le convertir.</value></data>
<data name="Archive.Convert.Failed.Full" xml:space="preserve"><value>Le disque de l'archive est plein.</value></data>
<data name="Archive.Convert.Failed.NoDecoder" xml:space="preserve"><value>Aucun décodeur de cet ordinateur ne la lit en pleine résolution.</value></data>
<data name="Archive.Convert.Failed.NotVerified" xml:space="preserve"><value>À la relecture, le fichier converti ne correspond pas à ce qui a été écrit.</value></data>
<data name="Archive.Convert.Failed.Other" xml:space="preserve"><value>Le fichier converti n'a pas pu être créé.</value></data>
<data name="Archive.Convert.Failed.PreviewOnly" xml:space="preserve"><value>Cet ordinateur ne la lit qu'à partir de son aperçu incorporé : convertissez-la sur un PC qui la lit en pleine résolution.</value></data>
<data name="Archive.Convert.Failed.TooLarge" xml:space="preserve"><value>Elle dépasse ce que ce format peut contenir, ce que Chronos peut relire ou ce que la mémoire allouée à une photo peut contenir.</value></data>
<data name="Archive.Convert.Failed.Unreadable" xml:space="preserve"><value>La photo n'a pas pu être décodée.</value></data>
<data name="Archive.Convert.Format" xml:space="preserve"><value>Format</value></data>
<data name="Archive.Convert.Heading.one" xml:space="preserve"><value>Convertir {0:N0} séquence</value></data>
<data name="Archive.Convert.Heading.other" xml:space="preserve"><value>Convertir {0:N0} séquences</value></data>
<data name="Archive.Convert.HeadingAll" xml:space="preserve"><value>Convertir {0}</value></data>
<data name="Archive.Convert.Mode" xml:space="preserve"><value>Mode</value></data>
<data name="Archive.Convert.NewHeading.one" xml:space="preserve"><value>Convertir {0:N0} séquence en une nouvelle ?</value></data>
<data name="Archive.Convert.NewHeading.other" xml:space="preserve"><value>Convertir {0:N0} séquences en nouvelles séquences ?</value></data>
<data name="Archive.Convert.NewLeftOut.one" xml:space="preserve"><value>{0:N0} photo n'est pas copiée : elle reste seulement dans sa source, pour la raison indiquée par le plan.</value></data>
<data name="Archive.Convert.NewLeftOut.other" xml:space="preserve"><value>{0:N0} photos ne sont pas copiées : elles restent seulement dans leur source, pour les raisons indiquées par le plan.</value></data>
<data name="Archive.Convert.NewMessage" xml:space="preserve"><value>Conversion de {0} ({1}) en {2} dans une nouvelle séquence à côté de chaque source ; les originaux restent tels quels.</value></data>
<data name="Archive.Convert.NewSequence" xml:space="preserve"><value>Nouvelle séquence</value></data>
<data name="Archive.Convert.NotCopied.ColorProfile" xml:space="preserve"><value>Les photos dont ce format ne peut ni conserver ni convertir le profil colorimétrique ne sont pas copiées dans la nouvelle séquence.</value></data>
<data name="Archive.Convert.NotCopied.EightBit" xml:space="preserve"><value>Les photos RAW que cet ordinateur ne développe qu'en 8 bits ne sont pas copiées dans la nouvelle séquence ; le JPEG permet de les convertir.</value></data>
<data name="Archive.Convert.NotCopied.Inaccessible" xml:space="preserve"><value>Les photos ouvertes dans un autre programme, ou qui ne peuvent pas être ouvertes, ne sont pas copiées dans la nouvelle séquence ; établissez un nouveau plan une fois qu'elles sont libres.</value></data>
<data name="Archive.Convert.NotCopied.Missing" xml:space="preserve"><value>Les photos manquantes ne sont pas copiées dans la nouvelle séquence.</value></data>
<data name="Archive.Convert.NotCopied.NoNativeDecoder" xml:space="preserve"><value>Les photos d'un format que cet ordinateur ne peut pas lire en pleine résolution ne sont pas copiées dans la nouvelle séquence.</value></data>
<data name="Archive.Convert.NotCopied.PreviewOnly" xml:space="preserve"><value>Les photos lues ici uniquement à partir de leur aperçu incorporé ne sont pas copiées dans la nouvelle séquence.</value></data>
<data name="Archive.Convert.NotCopied.SameFormat" xml:space="preserve"><value>Les photos déjà dans ce format ne sont pas copiées dans la nouvelle séquence.</value></data>
<data name="Archive.Convert.NotCopied.TooLarge" xml:space="preserve"><value>Les photos qui dépassent ce que ce format peut contenir ou ce que Chronos peut relire ne sont pas copiées dans la nouvelle séquence.</value></data>
<data name="Archive.Convert.NotCopied.Undecodable" xml:space="preserve"><value>Les photos illisibles ne sont pas copiées dans la nouvelle séquence.</value></data>
<data name="Archive.Convert.NotCopied.Unhashed" xml:space="preserve"><value>Les photos jamais vérifiées ne sont pas copiées dans la nouvelle séquence ; vérifiez d'abord la séquence.</value></data>
<data name="Archive.Convert.NotCopiedPhotos.one" xml:space="preserve"><value>{0:N0} non copiée</value></data>
<data name="Archive.Convert.NotCopiedPhotos.other" xml:space="preserve"><value>{0:N0} non copiées</value></data>
<data name="Archive.Convert.NotPlaced" xml:space="preserve"><value>Les photos converties n'ont pas pu prendre leur place. {0}</value></data>
<data name="Archive.Convert.PhotoFailed" xml:space="preserve"><value>Impossible de convertir {0}. {1}</value></data>
<data name="Archive.Convert.PhotoHeld" xml:space="preserve"><value>Une de ses photos est ouverte dans un autre programme ou ne peut pas être ouverte ; réessayez une fois qu'elle est libre.</value></data>
<data name="Archive.Convert.Quality" xml:space="preserve"><value>Qualité</value></data>
<data name="Archive.Convert.Replace" xml:space="preserve"><value>Remplacer</value></data>
<data name="Archive.Convert.ReplaceHeading.one" xml:space="preserve"><value>Remplacer les photos de {0:N0} séquence ?</value></data>
<data name="Archive.Convert.ReplaceHeading.other" xml:space="preserve"><value>Remplacer les photos de {0:N0} séquences ?</value></data>
<data name="Archive.Convert.ReplaceMessage" xml:space="preserve"><value>La conversion en {2} remplace {0} ({1}) ; les originaux sont mis à la corbeille de l'archive et peuvent être restaurés tant que la corbeille n'a pas été vidée.</value></data>
<data name="Archive.Convert.Sizes" xml:space="preserve"><value>{0} → {1}</value></data>
<data name="Archive.Convert.Skipped.ColorProfile" xml:space="preserve"><value>Les photos dont ce format ne peut ni conserver ni convertir le profil colorimétrique restent telles quelles.</value></data>
<data name="Archive.Convert.Skipped.EightBit" xml:space="preserve"><value>Les photos RAW que cet ordinateur ne développe qu'en 8 bits restent telles quelles ; le JPEG permet de les convertir.</value></data>
<data name="Archive.Convert.Skipped.Inaccessible" xml:space="preserve"><value>Les photos ouvertes dans un autre programme, ou qui ne peuvent pas être ouvertes, restent telles quelles ; établissez un nouveau plan une fois qu'elles sont libres.</value></data>
<data name="Archive.Convert.Skipped.Missing" xml:space="preserve"><value>Les photos manquantes restent telles quelles.</value></data>
<data name="Archive.Convert.Skipped.NoNativeDecoder" xml:space="preserve"><value>Les photos d'un format que cet ordinateur ne peut pas lire en pleine résolution restent telles quelles.</value></data>
<data name="Archive.Convert.Skipped.PreviewOnly" xml:space="preserve"><value>Les photos lues ici uniquement à partir de leur aperçu incorporé restent telles quelles.</value></data>
<data name="Archive.Convert.Skipped.SameFormat" xml:space="preserve"><value>Les photos déjà dans ce format restent telles quelles.</value></data>
<data name="Archive.Convert.Skipped.TooLarge" xml:space="preserve"><value>Les photos qui dépassent ce que ce format peut contenir ou ce que Chronos peut relire restent telles quelles.</value></data>
<data name="Archive.Convert.Skipped.Undecodable" xml:space="preserve"><value>Les photos illisibles restent telles quelles.</value></data>
<data name="Archive.Convert.Skipped.Unhashed" xml:space="preserve"><value>Les photos jamais vérifiées restent telles quelles ; vérifiez d'abord la séquence.</value></data>
<data name="Archive.Convert.SkippedPhotos.one" xml:space="preserve"><value>{0:N0} ignorée</value></data>
<data name="Archive.Convert.SkippedPhotos.other" xml:space="preserve"><value>{0:N0} ignorées</value></data>
<data name="Archive.Convert.Space" xml:space="preserve"><value>{0} nécessaires, {1} libres</value></data>
<data name="Archive.Convert.SpaceShort" xml:space="preserve"><value>{0} nécessaires, seulement {1} libres : libérez d'abord de l'espace.</value></data>
<data name="Archive.Convert.SpaceUnknown" xml:space="preserve"><value>{0} nécessaires ; l'espace libre ne peut pas être mesuré.</value></data>
<data name="Archive.Convert.Target.LinearDng" xml:space="preserve"><value>DNG linéaire</value></data>
<data name="Archive.Convert.Target.Tiff16" xml:space="preserve"><value>TIFF 16 bits</value></data>
<data name="Archive.Convert.UndoFailed" xml:space="preserve"><value>Les originaux n'ont pas pu être restaurés</value></data>
<data name="Archive.Convert.UndoNothing" xml:space="preserve"><value>Les originaux remplacés ne sont plus dans la corbeille.</value></data>
<data name="Archive.Convert.Undone.one" xml:space="preserve"><value>Originaux restaurés dans {0:N0} séquence</value></data>
<data name="Archive.Convert.Undone.other" xml:space="preserve"><value>Originaux restaurés dans {0:N0} séquences</value></data>
<data name="Archive.Convert.UndoneNew.one" xml:space="preserve"><value>{0:N0} séquence avait changé entre-temps : ses originaux sont revenus sous forme de nouvelle séquence.</value></data>
<data name="Archive.Convert.UndoneNew.other" xml:space="preserve"><value>{0:N0} séquences avaient changé entre-temps : leurs originaux sont revenus sous forme de nouvelles séquences.</value></data>
<data name="Archive.Convert.Unstaged" xml:space="preserve"><value>La conversion de {0} ne figure plus parmi les fichiers préparés ; la nouvelle tentative refait la conversion.</value></data>
<data name="Archive.Copy.Title" xml:space="preserve"><value>Dossier à copier dans l'archive</value></data>
<data name="Archive.Delete.Action" xml:space="preserve"><value>Mettre à la corbeille</value></data>
<data name="Archive.Delete.Blocked" xml:space="preserve"><value>Non déplacée : {0} · {1}</value></data>
@@ -75,6 +153,9 @@
<data name="Archive.Duplicates.Title" xml:space="preserve"><value>Doublons</value></data>
<data name="Archive.Empty" xml:space="preserve"><value>Aucune archive pour l'instant</value></data>
<data name="Archive.Error.Busy" xml:space="preserve"><value>Une autre instance de Chronos ({0}) écrit ici. Réessayez dans un instant.</value></data>
<data name="Archive.Error.ConvertKept.one" xml:space="preserve"><value>{0:N0} séquence n'a pas été convertie comme prévu ; le journal de la tâche indique pourquoi.</value></data>
<data name="Archive.Error.ConvertKept.other" xml:space="preserve"><value>{0:N0} séquences n'ont pas été converties comme prévu ; le journal de la tâche indique pourquoi.</value></data>
<data name="Archive.Error.ConvertSpace" xml:space="preserve"><value>La conversion nécessite {0} d'espace libre sur le volume de l'archive, alors que {1} sont libres.</value></data>
<data name="Archive.Error.CopyMismatch" xml:space="preserve"><value>La copie de {0} ne correspond pas à l'original.</value></data>
<data name="Archive.Error.DuplicateLost" xml:space="preserve"><value>{0} n'a pas pu être ajouté à la séquence.</value></data>
<data name="Archive.Error.InLibrary" xml:space="preserve"><value>{0} est déjà dans la bibliothèque.</value></data>
@@ -92,8 +173,8 @@
<data name="Archive.Error.SourceGone" xml:space="preserve"><value>La carte ou le dossier {0} n'est plus disponible.</value></data>
<data name="Archive.Error.StalePlan" xml:space="preserve"><value>L'archive a changé après l'établissement de ce plan.</value></data>
<data name="Archive.Error.TrashChanged" xml:space="preserve"><value>La corbeille a changé après le contrôle ; rien n'a été effacé.</value></data>
<data name="Archive.Error.TrashKept.one" xml:space="preserve"><value>{0:N0} entrée de la corbeille a été conservée : elle a changé, ou un fichier de remplacement ne correspond plus.</value></data>
<data name="Archive.Error.TrashKept.other" xml:space="preserve"><value>{0:N0} entrées de la corbeille ont été conservées : elles ont changé, ou un fichier de remplacement ne correspond plus.</value></data>
<data name="Archive.Error.TrashKept.one" xml:space="preserve"><value>{0:N0} entrée est restée dans la corbeille ; le journal de la tâche indique pourquoi.</value></data>
<data name="Archive.Error.TrashKept.other" xml:space="preserve"><value>{0:N0} entrées sont restées dans la corbeille ; le journal de la tâche indique pourquoi.</value></data>
<data name="Archive.Error.TrashMismatch" xml:space="preserve"><value>Aucun fichier de cette entrée de la corbeille ne correspond plus à son enregistrement ; elle reste dans la corbeille.</value></data>
<data name="Archive.Failed.Access" xml:space="preserve"><value>L'accès à l'archive a été refusé à Chronos.</value></data>
<data name="Archive.Failed.Files" xml:space="preserve"><value>Un fichier de l'archive n'a pas pu être lu ou écrit.</value></data>
@@ -132,6 +213,15 @@
<data name="Archive.Log.AuditKept" xml:space="preserve"><value>Journal d'audit conservé en entier</value></data>
<data name="Archive.Log.AuditPurged" xml:space="preserve"><value>Entrées d'audit supprimées : {0}</value></data>
<data name="Archive.Log.BackupDone" xml:space="preserve"><value>Index copié dans {0} ({1}) ; copies conservées : {2}</value></data>
<data name="Archive.Log.ConvertBlocked" xml:space="preserve"><value>Laissée telle quelle, occupée ou illisible : {0}</value></data>
<data name="Archive.Log.ConvertChanged" xml:space="preserve"><value>Laissée telle quelle, modifiée après le plan : {0}. Une nouvelle tentative la laisse telle quelle : convertissez-la de nouveau à partir d'un nouveau plan.</value></data>
<data name="Archive.Log.ConvertDone" xml:space="preserve"><value>Séquences converties : {0}, nouvelles séquences : {1}, photos : {2}</value></data>
<data name="Archive.Log.ConvertFailed" xml:space="preserve"><value>Laissée telle quelle : {0}. {1}</value></data>
<data name="Archive.Log.ConvertLeftOut" xml:space="preserve"><value>{0} : photos non converties, restées seulement dans la source : {1}</value></data>
<data name="Archive.Log.ConvertNothing" xml:space="preserve"><value>Rien à convertir : {0}</value></data>
<data name="Archive.Log.ConvertSuperseded" xml:space="preserve"><value>{0} : une autre conversion a fait sa copie dans ce format depuis la confirmation de celle-ci ; aucune seconde copie n'est faite.</value></data>
<data name="Archive.Log.Converted" xml:space="preserve"><value>{0} : photos remplacées par leur conversion : {1}</value></data>
<data name="Archive.Log.ConvertedNew" xml:space="preserve"><value>{0} : photos converties dans une nouvelle séquence : {1}</value></data>
<data name="Archive.Log.DryRun" xml:space="preserve"><value>Simulation : rien n'a été modifié.</value></data>
<data name="Archive.Log.DuplicateGroup" xml:space="preserve"><value>Copies supplémentaires de {0} : {1}</value></data>
<data name="Archive.Log.DuplicatesDone" xml:space="preserve"><value>Groupes de doublons : {0}, copies supplémentaires : {1}</value></data>
@@ -166,9 +256,22 @@
<data name="Archive.Log.SequenceMissing" xml:space="preserve"><value>Séquence introuvable : {0}</value></data>
<data name="Archive.Log.StepFailed" xml:space="preserve"><value>Échec de l'étape de nettoyage {0} : {1}</value></data>
<data name="Archive.Log.StepUnknown" xml:space="preserve"><value>Étape de nettoyage inconnue ici : {0}</value></data>
<data name="Archive.Log.SyncChanged" xml:space="preserve"><value>{0} : modifié depuis son archivage, non envoyé</value></data>
<data name="Archive.Log.SyncDeletedHere" xml:space="preserve"><value>{0} : supprimé sur ce PC, non téléchargé</value></data>
<data name="Archive.Log.SyncDeletedThere" xml:space="preserve"><value>{0} : supprimé sur le serveur, non envoyé</value></data>
<data name="Archive.Log.SyncFrameChanged" xml:space="preserve"><value>{0} : son image ici a changé entre-temps, non téléchargé</value></data>
<data name="Archive.Log.SyncMissing" xml:space="preserve"><value>{0} : manquant, non envoyé</value></data>
<data name="Archive.Log.SyncNoPreview.one" xml:space="preserve"><value>{0:N0} image n'a ni proxy ni miniature sur le serveur</value></data>
<data name="Archive.Log.SyncNoPreview.other" xml:space="preserve"><value>{0:N0} images n'ont ni proxy ni miniature sur le serveur</value></data>
<data name="Archive.Log.TrashEmptied" xml:space="preserve"><value>Entrées effacées : {0}, taille : {1}</value></data>
<data name="Archive.Log.TrashEntry" xml:space="preserve"><value>Dans la corbeille depuis le {0} : {1} ({2})</value></data>
<data name="Archive.Log.TrashKept" xml:space="preserve"><value>Reste dans la corbeille : {0}</value></data>
<data name="Archive.Log.TrashKept" xml:space="preserve"><value>Conservée dans la corbeille, modifiée après le plan : {0}</value></data>
<data name="Archive.Log.TrashKeptBusy" xml:space="preserve"><value>Conservée dans la corbeille, sa séquence était occupée : {0}</value></data>
<data name="Archive.Log.TrashKeptMismatch" xml:space="preserve"><value>Conservée dans la corbeille, une conversion de ses originaux ne correspond plus : {0}</value></data>
<data name="Archive.Log.TrashKeptStaleIndex" xml:space="preserve"><value>Conservée dans la corbeille, l'index répertorie sa séquence, que l'archive ne contient plus ; reconstruisez l'index : {0}</value></data>
<data name="Archive.Log.TrashKeptUnhashed" xml:space="preserve"><value>Conservée dans la corbeille, une photo de sa séquence n'a jamais été vérifiée ; vérifiez la séquence : {0}</value></data>
<data name="Archive.Log.TrashKeptUnknown" xml:space="preserve"><value>Conservée dans la corbeille, l'archive n'indique pas ce qu'est devenue la conversion de ses originaux ; restaurez-la pour les conserver : {0}</value></data>
<data name="Archive.Log.TrashKeptUnreadable" xml:space="preserve"><value>Conservée dans la corbeille, le fichier annexe d'un dossier pouvant contenir sa séquence est absent ou illisible ; scannez l'archive : {0}</value></data>
<data name="Archive.Log.TrashOffline" xml:space="preserve"><value>Corbeille non contrôlée : l'archive est inaccessible</value></data>
<data name="Archive.Log.TrashReport" xml:space="preserve"><value>Anciennes entrées de la corbeille : {0}, taille : {1} ; rien n'a été supprimé</value></data>
<data name="Archive.Log.VerifyDone" xml:space="preserve"><value>Photos contrôlées : {0}, intactes : {1}, nouveau hachage : {2}, avec des problèmes : {3}</value></data>
@@ -249,6 +352,7 @@
<data name="Archive.Set.All.other" xml:space="preserve"><value>{0:N0} séquences · archive entière</value></data>
<data name="Archive.Set.Analyse" xml:space="preserve"><value>Analyser</value></data>
<data name="Archive.Set.ClearFilter" xml:space="preserve"><value>Effacer le filtre</value></data>
<data name="Archive.Set.Convert" xml:space="preserve"><value>Convertir…</value></data>
<data name="Archive.Set.Delete" xml:space="preserve"><value>Supprimer…</value></data>
<data name="Archive.Set.Export" xml:space="preserve"><value>Exporter en CSV</value></data>
<data name="Archive.Set.Filter" xml:space="preserve"><value>Filtre de l'ensemble</value></data>
@@ -278,6 +382,7 @@
<data name="Archive.Toolbar.Scan" xml:space="preserve"><value>Scanner</value></data>
<data name="Archive.Toolbar.Verify" xml:space="preserve"><value>Vérifier</value></data>
<data name="Archive.Trash.Checking" xml:space="preserve"><value>Contrôle de la corbeille…</value></data>
<data name="Archive.Trash.ConversionDeleted" xml:space="preserve"><value>conversion supprimée</value></data>
<data name="Archive.Trash.Deleted" xml:space="preserve"><value>Supprimée le {0}</value></data>
<data name="Archive.Trash.Empty" xml:space="preserve"><value>La corbeille est vide</value></data>
<data name="Archive.Trash.EmptyAction" xml:space="preserve"><value>Vider…</value></data>
+1
View File
@@ -69,6 +69,7 @@
<data name="Jobs.Kind.Adopt" xml:space="preserve"><value>Adoption de dossier</value></data>
<data name="Jobs.Kind.Backup" xml:space="preserve"><value>Sauvegarde de l'index</value></data>
<data name="Jobs.Kind.Cleanup" xml:space="preserve"><value>Nettoyage</value></data>
<data name="Jobs.Kind.Convert" xml:space="preserve"><value>Conversion</value></data>
<data name="Jobs.Kind.DeepAnalyse" xml:space="preserve"><value>Analyse approfondie</value></data>
<data name="Jobs.Kind.Download" xml:space="preserve"><value>Téléchargement</value></data>
<data name="Jobs.Kind.Duplicates" xml:space="preserve"><value>Doublons</value></data>
+2
View File
@@ -6,6 +6,7 @@
<resheader name="writer"><value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader>
<data name="Library.Action.Analyse" xml:space="preserve"><value>Analyser</value></data>
<data name="Library.Action.ClearSelection" xml:space="preserve"><value>Effacer la sélection</value></data>
<data name="Library.Action.Convert" xml:space="preserve"><value>Convertir…</value></data>
<data name="Library.Action.Delete" xml:space="preserve"><value>Supprimer…</value></data>
<data name="Library.Action.Download" xml:space="preserve"><value>Télécharger</value></data>
<data name="Library.Action.ExportList" xml:space="preserve"><value>Exporter la liste</value></data>
@@ -32,6 +33,7 @@
<data name="Library.Blocked.NothingToDownload" xml:space="preserve"><value>Les séquences sélectionnées n'ont rien à récupérer du serveur.</value></data>
<data name="Library.Blocked.NothingToUpload" xml:space="preserve"><value>Le serveur possède déjà tout ce que contiennent les séquences sélectionnées.</value></data>
<data name="Library.Blocked.OneArchive" xml:space="preserve"><value>La réorganisation porte sur les séquences d'une seule archive à la fois.</value></data>
<data name="Library.Blocked.OneArchiveConvert" xml:space="preserve"><value>La conversion porte sur les séquences d'une seule archive à la fois.</value></data>
<data name="Library.Blocked.ServerOnly" xml:space="preserve"><value>Uniquement pour les séquences de ce PC ; la sélection se trouve sur le serveur.</value></data>
<data name="Library.Blocked.Transferring" xml:space="preserve"><value>Un transfert de cette séquence est déjà en cours.</value></data>
<data name="Library.ClearFilters" xml:space="preserve"><value>Effacer les filtres</value></data>
+4
View File
@@ -21,6 +21,8 @@
<data name="Server.Conflict.TakeServer.Message" xml:space="preserve"><value>Les paramètres de {0} sur ce PC seront remplacés par la copie du serveur.</value></data>
<data name="Server.Conflict.TakeServer.Title" xml:space="preserve"><value>Prendre les paramètres du serveur ?</value></data>
<data name="Server.Connect" xml:space="preserve"><value>Se connecter</value></data>
<data name="Server.Convert.OnPc" xml:space="preserve"><value>Convertissez ces photos sur un PC : le serveur ne peut pas les lire en pleine résolution.</value></data>
<data name="Server.Convert.OnPcNew" xml:space="preserve"><value>Non copiées dans la nouvelle séquence : le serveur ne peut pas lire ces photos en pleine résolution ; convertissez-les sur un PC.</value></data>
<data name="Server.Disconnect" xml:space="preserve"><value>Se déconnecter</value></data>
<data name="Server.Empty" xml:space="preserve"><value>Non connecté à un serveur</value></data>
<data name="Server.Error.AccountLocked" xml:space="preserve"><value>Trop d'échecs d'ouverture de session ; le compte est verrouillé pendant un moment.</value></data>
@@ -71,7 +73,9 @@
<data name="Server.Error.MethodNotAllowed" xml:space="preserve"><value>Cette méthode n'est pas autorisée ici.</value></data>
<data name="Server.Error.NestedTarget" xml:space="preserve"><value>Un nouveau dossier se trouverait dans le dossier d'une autre séquence.</value></data>
<data name="Server.Error.NotChronos" xml:space="preserve"><value>Cette adresse n'est pas un Chronos Server.</value></data>
<data name="Server.Error.NotEnoughSpace" xml:space="preserve"><value>Le volume de l'archive n'a pas l'espace nécessaire à la conversion.</value></data>
<data name="Server.Error.NotFound" xml:space="preserve"><value>Introuvable.</value></data>
<data name="Server.Error.NothingToConvert" xml:space="preserve"><value>Le plan ne convertit rien : chaque photo est ignorée ou chaque séquence est bloquée.</value></data>
<data name="Server.Error.PasswordChangeRequired" xml:space="preserve"><value>Changez d'abord votre mot de passe.</value></data>
<data name="Server.Error.PhotoRemoved" xml:space="preserve"><value>La photo a été supprimée de la séquence pendant son envoi ; elle n'a donc pas été ajoutée.</value></data>
<data name="Server.Error.PhotoUnreadable" xml:space="preserve"><value>Impossible de lire {0} : sans son hachage, les autres copies ne sauraient pas que ce fichier a été supprimé ; fermez le programme qui l'utilise ou vérifiez ses autorisations, puis réessayez.</value></data>
+19 -1
View File
@@ -27,6 +27,21 @@
<data name="Tooltips.Archive.ClearFilter" xml:space="preserve"><value>Afficher de nouveau toutes les séquences de la sélection</value></data>
<data name="Tooltips.Archive.CloseDialog" xml:space="preserve"><value>Fermer sans rien modifier · Esc</value></data>
<data name="Tooltips.Archive.Collapse" xml:space="preserve"><value>Masquer les séquences de cette année</value></data>
<data name="Tooltips.Archive.ConvertApplyNew" xml:space="preserve"><value>Confirmer, puis mettre en file d'attente une tâche qui convertit des copies dans de nouvelles séquences · vous pouvez la suspendre et la reprendre dans Tâches</value></data>
<data name="Tooltips.Archive.ConvertApplyReplace" xml:space="preserve"><value>Saisir le nombre de photos pour confirmer, puis mettre en file d'attente une tâche qui les remplace par leur conversion · vous pouvez la suspendre et la reprendre dans Tâches</value></data>
<data name="Tooltips.Archive.ConvertBack" xml:space="preserve"><value>Revenir au plan ; rien n'est converti</value></data>
<data name="Tooltips.Archive.ConvertDng" xml:space="preserve"><value>DNG linéaire, 16 bits et sans perte · lu par tous les logiciels de traitement RAW ; le choix pour l'archivage</value></data>
<data name="Tooltips.Archive.ConvertJpeg" xml:space="preserve"><value>JPEG 8 bits à la qualité indiquée ci-dessous · les fichiers les plus petits ; une partie des détails est perdue</value></data>
<data name="Tooltips.Archive.ConvertModeNew" xml:space="preserve"><value>Les copies converties vont dans une nouvelle séquence à côté de chacune ; les originaux restent tels quels</value></data>
<data name="Tooltips.Archive.ConvertModeReplace" xml:space="preserve"><value>Les fichiers convertis prennent la place des photos dans leurs séquences ; les originaux sont mis à la corbeille de l'archive, restaurables tant que la corbeille n'a pas été vidée</value></data>
<data name="Tooltips.Archive.ConvertNew" xml:space="preserve"><value>Mettre en file d'attente la tâche qui convertit les photos dans de nouvelles séquences, chaque conversion étant vérifiée ; les originaux restent intacts</value></data>
<data name="Tooltips.Archive.ConvertPlan" xml:space="preserve"><value>Les séquences dont les photos sont remplacées</value></data>
<data name="Tooltips.Archive.ConvertPlanNew" xml:space="preserve"><value>Les séquences copiées dans de nouvelles séquences, et les photos que chacune laisse de côté</value></data>
<data name="Tooltips.Archive.ConvertQuality" xml:space="preserve"><value>Qualité JPEG de 1 à 100 · 95 conserve les détails fins ; une valeur plus basse donne des fichiers plus petits</value></data>
<data name="Tooltips.Archive.ConvertReplace.one" xml:space="preserve"><value>Remplacer {0:N0} photo par sa conversion ; saisissez d'abord le nombre ci-dessus</value></data>
<data name="Tooltips.Archive.ConvertReplace.other" xml:space="preserve"><value>Remplacer {0:N0} photos par leur conversion ; saisissez d'abord le nombre ci-dessus</value></data>
<data name="Tooltips.Archive.ConvertTiff" xml:space="preserve"><value>TIFF 16 bits compressé sans perte · de gros fichiers que tous les logiciels de retouche ouvrent</value></data>
<data name="Tooltips.Archive.ConvertUndo" xml:space="preserve"><value>Remettre les originaux de la corbeille à la place de leurs conversions</value></data>
<data name="Tooltips.Archive.DeleteAction.one" xml:space="preserve"><value>Mettre {0:N0} séquence à la corbeille ; saisissez d'abord le nombre ci-dessus</value></data>
<data name="Tooltips.Archive.DeleteAction.other" xml:space="preserve"><value>Mettre {0:N0} séquences à la corbeille ; saisissez d'abord le nombre ci-dessus</value></data>
<data name="Tooltips.Archive.DeleteKeep" xml:space="preserve"><value>Ne rien modifier</value></data>
@@ -82,6 +97,7 @@
<data name="Tooltips.Archive.Scan" xml:space="preserve"><value>Scan incrémentiel : fichiers nouveaux, modifiés et supprimés d'après la date de modification et la taille</value></data>
<data name="Tooltips.Archive.Set" xml:space="preserve"><value>Les années et séquences sélectionnées (toutes si rien n'est sélectionné), restreintes par appareil, état ou étiquette</value></data>
<data name="Tooltips.Archive.SetAnalyse" xml:space="preserve"><value>Lancer l'analyse approfondie de chaque séquence de l'ensemble</value></data>
<data name="Tooltips.Archive.SetConvert" xml:space="preserve"><value>Convertir les photos de l'ensemble en JPEG, TIFF ou DNG · simulation d'abord, puis une tâche</value></data>
<data name="Tooltips.Archive.SetDelete" xml:space="preserve"><value>Mettre l'ensemble à la corbeille de l'archive · affiche la simulation, puis vous demande de saisir une confirmation</value></data>
<data name="Tooltips.Archive.SetExport" xml:space="preserve"><value>Exporter l'ensemble en CSV : une ligne par séquence</value></data>
<data name="Tooltips.Archive.SetProxies" xml:space="preserve"><value>Créer ou actualiser les proxys</value></data>
@@ -96,7 +112,7 @@
<data name="Tooltips.Archive.TitleTemplate" xml:space="preserve"><value>Modèle de titre ; la balise du titre correspond au titre actuel · vérifié pendant la saisie</value></data>
<data name="Tooltips.Archive.Trash" xml:space="preserve"><value>Les séquences et photos supprimées de cette archive, chacune restaurable</value></data>
<data name="Tooltips.Archive.TrashEmpty" xml:space="preserve"><value>Effacer définitivement les entrées de cette corbeille, après un contrôle de leur contenu et une confirmation saisie</value></data>
<data name="Tooltips.Archive.TrashEmptyPlan" xml:space="preserve"><value>Ce qui est effacé définitivement de l'archive</value></data>
<data name="Tooltips.Archive.TrashEmptyPlan" xml:space="preserve"><value>Ce qui est effacé définitivement de l'archive ; les originaux dont la conversion a été supprimée peuvent être la dernière copie de leurs photos</value></data>
<data name="Tooltips.Archive.TrashErase.one" xml:space="preserve"><value>Effacer définitivement {0:N0} entrée ; saisissez d'abord le nombre ci-dessus</value></data>
<data name="Tooltips.Archive.TrashErase.other" xml:space="preserve"><value>Effacer définitivement {0:N0} entrées ; saisissez d'abord le nombre ci-dessus</value></data>
<data name="Tooltips.Archive.TrashRestore" xml:space="preserve"><value>Remettre cette entrée en place : une séquence dans son dossier et dans la bibliothèque, des photos dans leur séquence après un contrôle du hachage</value></data>
@@ -468,6 +484,8 @@
<data name="Tooltips.Library.List" xml:space="preserve"><value>Tableau avec colonnes triables</value></data>
<data name="Tooltips.Library.Mass.Analyse.one" xml:space="preserve"><value>Analyse approfondie de {0:N0} séquence sur ce PC · s'exécute comme une seule tâche</value></data>
<data name="Tooltips.Library.Mass.Analyse.other" xml:space="preserve"><value>Analyse approfondie de {0:N0} séquences sur ce PC · s'exécute comme une seule tâche</value></data>
<data name="Tooltips.Library.Mass.Convert.one" xml:space="preserve"><value>Convertir les photos de {0:N0} séquence en JPEG, TIFF ou DNG · simulation d'abord, puis une tâche</value></data>
<data name="Tooltips.Library.Mass.Convert.other" xml:space="preserve"><value>Convertir les photos de {0:N0} séquences de leur archive en JPEG, TIFF ou DNG · simulation d'abord, puis une tâche</value></data>
<data name="Tooltips.Library.Mass.Delete.one" xml:space="preserve"><value>Mettre {0:N0} séquence à la corbeille de son archive · affiche la simulation, puis vous demande de saisir une confirmation</value></data>
<data name="Tooltips.Library.Mass.Delete.other" xml:space="preserve"><value>Mettre {0:N0} séquences à la corbeille de leur archive · affiche la simulation, puis vous demande de saisir une confirmation</value></data>
<data name="Tooltips.Library.Mass.Download.one" xml:space="preserve"><value>Récupérer depuis le serveur ce qui manque ici à {0:N0} séquence (originaux ou rendus) · s'exécute comme tâche de transfert</value></data>
+75
View File
@@ -9,6 +9,7 @@
<data name="Admin.About.Title" xml:space="preserve"><value>שרת Chronos</value></data>
<data name="Admin.About.Uptime" xml:space="preserve"><value>זמן פעולה</value></data>
<data name="Admin.About.Version" xml:space="preserve"><value>גרסה</value></data>
<data name="Admin.Activity.ArchiveConverted" xml:space="preserve"><value>הוספת המרה לתור על ידי {0} · {1}</value></data>
<data name="Admin.Activity.ArchiveReorganized" xml:space="preserve"><value>ארגון מחדש של הארכיון על ידי {0} · {1}</value></data>
<data name="Admin.Activity.ArchiveSettings" xml:space="preserve"><value>שינוי מבנה הארכיון על ידי {0}</value></data>
<data name="Admin.Activity.FramesDeleted" xml:space="preserve"><value>מחיקת {1} על ידי {0}</value></data>
@@ -84,6 +85,73 @@
<data name="Admin.Common.TypeToConfirm.Tip" xml:space="preserve"><value>יש להקליד את השם בדיוק כפי שהוא מוצג כדי לאשר</value></data>
<data name="Admin.Common.TypeWord.Tip" xml:space="preserve"><value>יש להקליד את המילה בדיוק כפי שהיא מוצגת; ללא תלות ברישיות</value></data>
<data name="Admin.Common.TypeWordFirst.Tip" xml:space="preserve"><value>יש להקליד קודם את המילה שלמעלה</value></data>
<data name="Admin.Convert.Action" xml:space="preserve"><value>המר…</value></data>
<data name="Admin.Convert.Action.Tip" xml:space="preserve"><value>המרת התמונות של הרצפים שנבחרו ל-JPEG, ל-TIFF-16 או ל-DNG ליניארי; תצוגה מקדימה מציגה קודם כל רצף</value></data>
<data name="Admin.Convert.Apply" xml:space="preserve"><value>המר…</value></data>
<data name="Admin.Convert.Apply.Tip" xml:space="preserve"><value>המרה כפי שמוצג בתצוגה המקדימה; לפני כן מוצגת בקשת אישור</value></data>
<data name="Admin.Convert.Cancel.Tip" xml:space="preserve"><value>סגירה בלי להמיר דבר</value></data>
<data name="Admin.Convert.ChooseMode" xml:space="preserve"><value>יש לבחור &quot;החלף&quot; או &quot;רצף חדש&quot; כדי להמיר.</value></data>
<data name="Admin.Convert.ChooseMode.Tip" xml:space="preserve"><value>יש לבחור קודם &quot;החלף&quot; או &quot;רצף חדש&quot;</value></data>
<data name="Admin.Convert.Column.Converted" xml:space="preserve"><value>יומרו</value></data>
<data name="Admin.Convert.Column.NotCopied" xml:space="preserve"><value>לא יועתקו</value></data>
<data name="Admin.Convert.Column.Sequence" xml:space="preserve"><value>רצף</value></data>
<data name="Admin.Convert.Column.Size" xml:space="preserve"><value>גודל</value></data>
<data name="Admin.Convert.Column.Unchanged" xml:space="preserve"><value>ללא שינוי</value></data>
<data name="Admin.Convert.Confirm.New" xml:space="preserve"><value>המר</value></data>
<data name="Admin.Convert.Confirm.New.Tip" xml:space="preserve"><value>הוספה לתור של המשימה שממירה את התמונות לרצפים חדשים ומאמתת כל המרה; הקבצים המקוריים נשארים ללא שינוי</value></data>
<data name="Admin.Convert.Confirm.Replace" xml:space="preserve"><value>החלף</value></data>
<data name="Admin.Convert.Confirm.Replace.Tip" xml:space="preserve"><value>הוספה לתור של המשימה שממירה את התמונות, מאמתת כל המרה ומעבירה את הקבצים המקוריים לאשפה</value></data>
<data name="Admin.Convert.ConfirmNew.few" xml:space="preserve"><value>{0} תמונות יומרו לעותקים ברצף חדש לצד כל רצף; הקבצים המקוריים יישארו כפי שהם.</value></data>
<data name="Admin.Convert.ConfirmNew.one" xml:space="preserve"><value>תמונה אחת תומר לעותק ברצף חדש; הקובץ המקורי יישאר כפי שהוא.</value></data>
<data name="Admin.Convert.ConfirmNew.other" xml:space="preserve"><value>{0} תמונות יומרו לעותקים ברצף חדש לצד כל רצף; הקבצים המקוריים יישארו כפי שהם.</value></data>
<data name="Admin.Convert.ConfirmNewNotCopied.few" xml:space="preserve"><value>{0} תמונות לא יועתקו לרצפים החדשים, מהסיבות שמופיעות בתצוגה המקדימה.</value></data>
<data name="Admin.Convert.ConfirmNewNotCopied.one" xml:space="preserve"><value>תמונה אחת לא תועתק לרצף החדש, מהסיבה שמופיעה בתצוגה המקדימה.</value></data>
<data name="Admin.Convert.ConfirmNewNotCopied.other" xml:space="preserve"><value>{0} תמונות לא יועתקו לרצפים החדשים, מהסיבות שמופיעות בתצוגה המקדימה.</value></data>
<data name="Admin.Convert.ConfirmNewTitle" xml:space="preserve"><value>להמיר ל-{0} ברצפים חדשים?</value></data>
<data name="Admin.Convert.ConfirmReplace.few" xml:space="preserve"><value>{0} תמונות ({1}) יוחלפו בהמרות שלהן; הקבצים המקוריים יעברו לאשפה, וניתן יהיה לשחזר אותם עד לריקון האשפה.</value></data>
<data name="Admin.Convert.ConfirmReplace.one" xml:space="preserve"><value>תמונה אחת ({1}) תוחלף בהמרה שלה; הקובץ המקורי יעבור לאשפה, וניתן יהיה לשחזר אותו עד לריקון האשפה.</value></data>
<data name="Admin.Convert.ConfirmReplace.other" xml:space="preserve"><value>{0} תמונות ({1}) יוחלפו בהמרות שלהן; הקבצים המקוריים יעברו לאשפה, וניתן יהיה לשחזר אותם עד לריקון האשפה.</value></data>
<data name="Admin.Convert.ConfirmReplaceTitle" xml:space="preserve"><value>להחליף את הקבצים המקוריים ב-{0}?</value></data>
<data name="Admin.Convert.Format" xml:space="preserve"><value>פורמט</value></data>
<data name="Admin.Convert.Format.Jpeg.Tip" xml:space="preserve"><value>JPEG ב-8 סיביות עם פרטי צבע מלאים, באיכות שנקבעת לצדו: הקבצים הקטנים ביותר, שכל תוכנה פותחת</value></data>
<data name="Admin.Convert.Format.LinearDng" xml:space="preserve"><value>DNG ליניארי</value></data>
<data name="Admin.Convert.Format.LinearDng.Tip" xml:space="preserve"><value>DNG ליניארי ב-16 סיביות בדחיסה ללא אובדן: הבחירה לארכוב, נפתח בעורכי RAW</value></data>
<data name="Admin.Convert.Format.Tiff16.Tip" xml:space="preserve"><value>TIFF ב-16 סיביות במרחב sRGB, בדחיסה ללא אובדן: קבצים גדולים ששומרים על כל גוון לצורך עריכה</value></data>
<data name="Admin.Convert.Gone" xml:space="preserve"><value>רצף שנבחר כבר אינו בארכיון; יש לסגור ולבחור שוב.</value></data>
<data name="Admin.Convert.Mode" xml:space="preserve"><value>מצב</value></data>
<data name="Admin.Convert.Mode.NewSequence" xml:space="preserve"><value>רצף חדש</value></data>
<data name="Admin.Convert.Mode.NewSequence.Tip" xml:space="preserve"><value>העותקים שהומרו נכנסים לרצף חדש לצד כל רצף; הקבצים המקוריים והרצף שלהם נשארים בדיוק כפי שהם</value></data>
<data name="Admin.Convert.Mode.Replace" xml:space="preserve"><value>החלף</value></data>
<data name="Admin.Convert.Mode.Replace.Tip" xml:space="preserve"><value>הקבצים שהומרו הופכים לתמונות של הרצף; הקבצים המקוריים עוברים לאשפה של הארכיון, וניתן לשחזר אותם עד לריקון האשפה</value></data>
<data name="Admin.Convert.NoAnswer" xml:space="preserve"><value>השרת לא הגיב: יש לבדוק בדף המשימות אם ההמרה נוספה לתור לפני שממירים שוב.</value></data>
<data name="Admin.Convert.NoSpace.Tip" xml:space="preserve"><value>יש לפנות קודם מקום באמצעי האחסון של הארכיון</value></data>
<data name="Admin.Convert.NotCopiedCount.few" xml:space="preserve"><value>{0} תמונות לא יועתקו</value></data>
<data name="Admin.Convert.NotCopiedCount.one" xml:space="preserve"><value>תמונה אחת לא תועתק</value></data>
<data name="Admin.Convert.NotCopiedCount.other" xml:space="preserve"><value>{0} תמונות לא יועתקו</value></data>
<data name="Admin.Convert.Nothing.Tip" xml:space="preserve"><value>אין בתצוגה המקדימה דבר להמרה</value></data>
<data name="Admin.Convert.NothingToConvert" xml:space="preserve"><value>אין מה להמיר: כל תמונה נשארת כפי שהיא, מהסיבות שמוצגות.</value></data>
<data name="Admin.Convert.OpenJob" xml:space="preserve"><value>פתח משימה</value></data>
<data name="Admin.Convert.OpenJob.Tip" xml:space="preserve"><value>הצגת המשימה והיומן שלה בדף המשימות</value></data>
<data name="Admin.Convert.PlanChanged" xml:space="preserve"><value>הארכיון השתנה מאז התצוגה המקדימה; יש לבדוק את התצוגה המקדימה החדשה ולהחיל שוב.</value></data>
<data name="Admin.Convert.Planning" xml:space="preserve"><value>תכנון…</value></data>
<data name="Admin.Convert.Planning.Tip" xml:space="preserve"><value>השרת קורא כל תיקיית תמונות בבחירה: בארכיון גדול זה נמשך דקות, והתצוגה המקדימה מופיעה כשהקריאה מסתיימת</value></data>
<data name="Admin.Convert.PlanningFor" xml:space="preserve"><value>תכנון… {0}</value></data>
<data name="Admin.Convert.Preview" xml:space="preserve"><value>תצוגה מקדימה</value></data>
<data name="Admin.Convert.Preview.Tip" xml:space="preserve"><value>מה יומר בכל רצף ומה יישאר כפי שהוא, עם הגודל לפני ואחרי (הערכה); עדיין לא שונה דבר</value></data>
<data name="Admin.Convert.Quality" xml:space="preserve"><value>איכות</value></data>
<data name="Admin.Convert.Quality.Tip" xml:space="preserve"><value>איכות JPEG מ-1 עד 100; 95 שומר על פרטים עדינים, ערכים נמוכים יותר יוצרים קבצים קטנים יותר</value></data>
<data name="Admin.Convert.QualityRange" xml:space="preserve"><value>יש להזין מספר שלם בין 1 ל-100.</value></data>
<data name="Admin.Convert.Queued" xml:space="preserve"><value>ההמרה נוספה לתור.</value></data>
<data name="Admin.Convert.ReplaceWord" xml:space="preserve"><value>החלף</value></data>
<data name="Admin.Convert.Size.Tip" xml:space="preserve"><value>גודל התמונות שיומרו כעת, ואחריו הגודל המשוער לאחר ההמרה</value></data>
<data name="Admin.Convert.SkippedPhotos" xml:space="preserve"><value>{0}: {1}</value></data>
<data name="Admin.Convert.Title.few" xml:space="preserve"><value>המרה של {0} רצפים</value></data>
<data name="Admin.Convert.Title.one" xml:space="preserve"><value>המרה של רצף אחד</value></data>
<data name="Admin.Convert.Title.other" xml:space="preserve"><value>המרה של {0} רצפים</value></data>
<data name="Admin.Convert.TitleAll" xml:space="preserve"><value>המרה של כל הרצפים</value></data>
<data name="Admin.Convert.TooMany" xml:space="preserve"><value>המרה פועלת על {0} רצפים לכל היותר בכל פעם, או על כל הרצפים: יש לנקות את הסינון ולבחור הכול.</value></data>
<data name="Admin.Convert.Totals" xml:space="preserve"><value>רצפים שיומרו: {0} · תמונות: {1} · ללא שינוי: {2} · גודל: {3} → {4}</value></data>
<data name="Admin.Convert.TotalsNew" xml:space="preserve"><value>רצפים שיומרו: {0} · תמונות: {1} · לא יועתקו: {2} · גודל: {3} → {4}</value></data>
<data name="Admin.Dashboard.Activity" xml:space="preserve"><value>פעילות אחרונה</value></data>
<data name="Admin.Dashboard.AllLogs" xml:space="preserve"><value>כל היומנים</value></data>
<data name="Admin.Dashboard.AllLogs.Tip" xml:space="preserve"><value>פתיחת יומן הביקורת</value></data>
@@ -142,6 +210,7 @@
<data name="Admin.Job.Kind.Adopt" xml:space="preserve"><value>אימוץ</value></data>
<data name="Admin.Job.Kind.Backup" xml:space="preserve"><value>גיבוי</value></data>
<data name="Admin.Job.Kind.Cleanup" xml:space="preserve"><value>ניקוי</value></data>
<data name="Admin.Job.Kind.Convert" xml:space="preserve"><value>המרה</value></data>
<data name="Admin.Job.Kind.DeepAnalyse" xml:space="preserve"><value>ניתוח מעמיק</value></data>
<data name="Admin.Job.Kind.Duplicates" xml:space="preserve"><value>כפילויות</value></data>
<data name="Admin.Job.Kind.EmptyTrash" xml:space="preserve"><value>ריקון האשפה</value></data>
@@ -368,6 +437,7 @@
<data name="Admin.Login.SignIn.Tip" xml:space="preserve"><value>כניסה לניהול השרת הזה</value></data>
<data name="Admin.Login.User" xml:space="preserve"><value>משתמש</value></data>
<data name="Admin.Login.User.Tip" xml:space="preserve"><value>שם המשתמש שלך בשרת הזה</value></data>
<data name="Admin.Logs.Action.ArchiveConverted" xml:space="preserve"><value>תמונות הומרו</value></data>
<data name="Admin.Logs.Action.ArchiveReorganized" xml:space="preserve"><value>הארכיון אורגן מחדש</value></data>
<data name="Admin.Logs.Action.ArchiveSettings" xml:space="preserve"><value>מבנה הארכיון</value></data>
<data name="Admin.Logs.Action.FramesDeleted" xml:space="preserve"><value>תמונות נמחקו</value></data>
@@ -833,6 +903,7 @@
<data name="Admin.Theme.Tip" xml:space="preserve"><value>מעבר בין ערכת נושא בהירה לכהה</value></data>
<data name="Admin.Trash.Back" xml:space="preserve"><value>ספרייה</value></data>
<data name="Admin.Trash.Back.Tip" xml:space="preserve"><value>חזרה לספרייה</value></data>
<data name="Admin.Trash.ConversionDeleted" xml:space="preserve"><value>ההמרה נמחקה</value></data>
<data name="Admin.Trash.DeletedAt" xml:space="preserve"><value>מועד מחיקה</value></data>
<data name="Admin.Trash.DeletedBy" xml:space="preserve"><value>נמחק על ידי</value></data>
<data name="Admin.Trash.Emptied" xml:space="preserve"><value>האשפה רוקנה.</value></data>
@@ -861,10 +932,14 @@
<data name="Admin.Trash.Photos" xml:space="preserve"><value>תמונות</value></data>
<data name="Admin.Trash.Restore" xml:space="preserve"><value>שחזר</value></data>
<data name="Admin.Trash.RestorePhotos.Tip" xml:space="preserve"><value>החזרת התמונות לרצף שלהן (לרצף חדש אם הוא כבר אינו קיים); כל אחת נבדקת קודם מול ה-SHA-256 שלה</value></data>
<data name="Admin.Trash.RestoreReplaced.Tip" xml:space="preserve"><value>החזרת הקבצים המקוריים במקום ההמרות שלהם כל עוד ההמרות לא השתנו (ההמרות עוברות לאשפה), ואחרת לרצף חדש; כל קובץ נבדק קודם מול ה-SHA-256 שלו</value></data>
<data name="Admin.Trash.RestoreSequence.Tip" xml:space="preserve"><value>החזרת התיקייה של הרצף לספרייה כפי שהיא (ליד מקומה הקודם, אם הוא תפוס); הגיבוב של התמונות שלו אינו נבדק: &quot;אמת&quot; עושה זאת</value></data>
<data name="Admin.Trash.RestoredNew.few" xml:space="preserve"><value>{0} תמונות שוחזרו לרצף חדש.</value></data>
<data name="Admin.Trash.RestoredNew.one" xml:space="preserve"><value>תמונה אחת שוחזרה לרצף חדש.</value></data>
<data name="Admin.Trash.RestoredNew.other" xml:space="preserve"><value>{0} תמונות שוחזרו לרצף חדש.</value></data>
<data name="Admin.Trash.RestoredOriginals.few" xml:space="preserve"><value>{0} קבצים מקוריים חזרו אל {1}; ההמרות שלהם נמצאות באשפה.</value></data>
<data name="Admin.Trash.RestoredOriginals.one" xml:space="preserve"><value>קובץ מקורי אחד חזר אל {1}; ההמרה שלו נמצאת באשפה.</value></data>
<data name="Admin.Trash.RestoredOriginals.other" xml:space="preserve"><value>{0} קבצים מקוריים חזרו אל {1}; ההמרות שלהם נמצאות באשפה.</value></data>
<data name="Admin.Trash.RestoredPhotos.few" xml:space="preserve"><value>{0} תמונות חזרו אל {1}.</value></data>
<data name="Admin.Trash.RestoredPhotos.one" xml:space="preserve"><value>תמונה אחת חזרה אל {1}.</value></data>
<data name="Admin.Trash.RestoredPhotos.other" xml:space="preserve"><value>{0} תמונות חזרו אל {1}.</value></data>
+120 -4
View File
@@ -16,8 +16,10 @@
<data name="Archive.Blocked.Applying" xml:space="preserve"><value>יש להמתין עד שהשינויים יוחלו.</value></data>
<data name="Archive.Blocked.EmptySet" xml:space="preserve"><value>האוסף ריק: יש לשנות את הבחירה או את הסינון.</value></data>
<data name="Archive.Blocked.NoChanges" xml:space="preserve"><value>שום דבר לא ישתנה.</value></data>
<data name="Archive.Blocked.NoMode" xml:space="preserve"><value>יש לבחור &quot;החלף&quot; או &quot;רצף חדש&quot;.</value></data>
<data name="Archive.Blocked.NoTemplate" xml:space="preserve"><value>יש להפעיל לפחות תבנית אחת.</value></data>
<data name="Archive.Blocked.NotOnline" xml:space="preserve"><value>הארכיון חייב להיות מקוון וניתן לכתיבה.</value></data>
<data name="Archive.Blocked.NothingToConvert" xml:space="preserve"><value>אין מה להמיר: כל התמונות מדולגות או שכל הרצפים חסומים.</value></data>
<data name="Archive.Blocked.Planning" xml:space="preserve"><value>יש להמתין להרצת הניסיון.</value></data>
<data name="Archive.Blocked.Reading" xml:space="preserve"><value>יש להמתין עד שהארכיון ייקרא.</value></data>
<data name="Archive.Blocked.Searching" xml:space="preserve"><value>מתבצע חיפוש; יש לבטל אותו או להמתין.</value></data>
@@ -34,6 +36,91 @@
<data name="Archive.Confirm.Remove" xml:space="preserve"><value>הסר שורה</value></data>
<data name="Archive.Confirm.RemoveHeading" xml:space="preserve"><value>להסיר את {0} מהאינדקס?</value></data>
<data name="Archive.Confirm.RemoveMessage" xml:space="preserve"><value>הקובץ הנלווה שלו כבר אינו קיים. רק השורה באינדקס מוסרת; שום קובץ אינו נמחק.</value></data>
<data name="Archive.Convert.AlreadyQueued" xml:space="preserve"><value>המרה של הרצפים האלה כבר ממתינה או פועלת; ניתן לעקוב אחריה במסך &quot;משימות&quot;.</value></data>
<data name="Archive.Convert.Blocked.Busy" xml:space="preserve"><value>משימה פועלת על הרצף הזה; יש להמיר אותו כשהמשימה תסתיים.</value></data>
<data name="Archive.Convert.Blocked.FramesChanged" xml:space="preserve"><value>הרצף השתנה אחרי התוכנית; יש לבדוק שוב את התוכנית.</value></data>
<data name="Archive.Convert.Blocked.Offline" xml:space="preserve"><value>הארכיון אינו מקוון או מוגדר לקריאה בלבד.</value></data>
<data name="Archive.Convert.Blocked.Unreadable" xml:space="preserve"><value>לא ניתן לקרוא את קובץ הרצף.</value></data>
<data name="Archive.Convert.Confirm" xml:space="preserve"><value>המר</value></data>
<data name="Archive.Convert.CopyUnfinished" xml:space="preserve"><value>המרה אחרת יצרה ממנו עותק בפורמט הזה ועדיין לא הסתיימה; יש להשלים אותה או לנסות אותה שוב קודם.</value></data>
<data name="Archive.Convert.Done.few" xml:space="preserve"><value>{0:N0} רצפים הומרו</value></data>
<data name="Archive.Convert.Done.one" xml:space="preserve"><value>רצף אחד הומר</value></data>
<data name="Archive.Convert.Done.other" xml:space="preserve"><value>{0:N0} רצפים הומרו</value></data>
<data name="Archive.Convert.Failed.Changed" xml:space="preserve"><value>התמונה כבר אינה תואמת לעותק שנשמר בארכיון; יש לאמת את הרצף.</value></data>
<data name="Archive.Convert.Failed.ColorProfile" xml:space="preserve"><value>לא ניתן לשמור את פרופיל הצבע שלה בפורמט הזה, וגם לא להמיר אותו.</value></data>
<data name="Archive.Convert.Failed.Damaged" xml:space="preserve"><value>הפיקסלים שלה מכילים ערכים שאינם מספרים: הקובץ פגום.</value></data>
<data name="Archive.Convert.Failed.EightBit" xml:space="preserve"><value>המחשב הזה מפתח את קובץ ה-RAW הזה ב-8 סיביות בלבד, מעט מדי לקובץ של 16 סיביות; המרה ל-JPEG אפשרית.</value></data>
<data name="Archive.Convert.Failed.Full" xml:space="preserve"><value>הדיסק של הארכיון מלא.</value></data>
<data name="Archive.Convert.Failed.NoDecoder" xml:space="preserve"><value>אין במחשב הזה מפענח שקורא אותה ברזולוציה מלאה.</value></data>
<data name="Archive.Convert.Failed.NotVerified" xml:space="preserve"><value>הקובץ שהומר לא נקרא בחזרה כפי שנכתב.</value></data>
<data name="Archive.Convert.Failed.Other" xml:space="preserve"><value>לא ניתן היה ליצור את הקובץ המומר.</value></data>
<data name="Archive.Convert.Failed.PreviewOnly" xml:space="preserve"><value>המחשב הזה קורא אותה רק מהתצוגה המקדימה המוטמעת שלה: יש להמיר אותה במחשב שקורא אותה ברזולוציה מלאה.</value></data>
<data name="Archive.Convert.Failed.TooLarge" xml:space="preserve"><value>היא גדולה ממה שהפורמט הזה יכול להכיל, ממה ש-Chronos יכול לקרוא בחזרה או ממה שהזיכרון לתמונה אחת יכול להכיל.</value></data>
<data name="Archive.Convert.Failed.Unreadable" xml:space="preserve"><value>לא ניתן היה לפענח את התמונה.</value></data>
<data name="Archive.Convert.Format" xml:space="preserve"><value>פורמט</value></data>
<data name="Archive.Convert.Heading.few" xml:space="preserve"><value>המרה של {0:N0} רצפים</value></data>
<data name="Archive.Convert.Heading.one" xml:space="preserve"><value>המרה של רצף אחד</value></data>
<data name="Archive.Convert.Heading.other" xml:space="preserve"><value>המרה של {0:N0} רצפים</value></data>
<data name="Archive.Convert.HeadingAll" xml:space="preserve"><value>המרה של {0}</value></data>
<data name="Archive.Convert.Mode" xml:space="preserve"><value>מצב</value></data>
<data name="Archive.Convert.NewHeading.few" xml:space="preserve"><value>להמיר {0:N0} רצפים לרצפים חדשים?</value></data>
<data name="Archive.Convert.NewHeading.one" xml:space="preserve"><value>להמיר רצף אחד לרצף חדש?</value></data>
<data name="Archive.Convert.NewHeading.other" xml:space="preserve"><value>להמיר {0:N0} רצפים לרצפים חדשים?</value></data>
<data name="Archive.Convert.NewLeftOut.few" xml:space="preserve"><value>{0:N0} תמונות לא יועתקו: הן יישארו רק במקור שלהן, מהסיבות שמופיעות בתוכנית.</value></data>
<data name="Archive.Convert.NewLeftOut.one" xml:space="preserve"><value>תמונה אחת לא תועתק: היא תישאר רק במקור שלה, מהסיבה שמופיעה בתוכנית.</value></data>
<data name="Archive.Convert.NewLeftOut.other" xml:space="preserve"><value>{0:N0} תמונות לא יועתקו: הן יישארו רק במקור שלהן, מהסיבות שמופיעות בתוכנית.</value></data>
<data name="Archive.Convert.NewMessage" xml:space="preserve"><value>המרה של {0} ({1}) ל-{2} ברצף חדש לצד כל מקור; הקבצים המקוריים נשארים כפי שהם.</value></data>
<data name="Archive.Convert.NewSequence" xml:space="preserve"><value>רצף חדש</value></data>
<data name="Archive.Convert.NotCopied.ColorProfile" xml:space="preserve"><value>תמונות שהפורמט הזה אינו יכול לשמור או להמיר את פרופיל הצבע שלהן אינן מועתקות לרצף החדש.</value></data>
<data name="Archive.Convert.NotCopied.EightBit" xml:space="preserve"><value>תמונות RAW שהמחשב הזה מפתח ב-8 סיביות בלבד אינן מועתקות לרצף החדש; המרה ל-JPEG אפשרית.</value></data>
<data name="Archive.Convert.NotCopied.Inaccessible" xml:space="preserve"><value>תמונות שתוכנית אחרת מחזיקה פתוחות, או שלא ניתן לפתוח, אינן מועתקות לרצף החדש; יש לתכנן שוב כשהן יתפנו.</value></data>
<data name="Archive.Convert.NotCopied.Missing" xml:space="preserve"><value>תמונות חסרות אינן מועתקות לרצף החדש.</value></data>
<data name="Archive.Convert.NotCopied.NoNativeDecoder" xml:space="preserve"><value>תמונות בפורמט שהמחשב הזה אינו יכול לקרוא ברזולוציה מלאה אינן מועתקות לרצף החדש.</value></data>
<data name="Archive.Convert.NotCopied.PreviewOnly" xml:space="preserve"><value>תמונות שנקראות כאן רק מהתצוגה המקדימה המוטמעת שלהן אינן מועתקות לרצף החדש.</value></data>
<data name="Archive.Convert.NotCopied.SameFormat" xml:space="preserve"><value>תמונות שכבר נמצאות בפורמט הזה אינן מועתקות לרצף החדש.</value></data>
<data name="Archive.Convert.NotCopied.TooLarge" xml:space="preserve"><value>תמונות הגדולות ממה שהפורמט הזה יכול להכיל או ממה ש-Chronos יכול לקרוא בחזרה אינן מועתקות לרצף החדש.</value></data>
<data name="Archive.Convert.NotCopied.Undecodable" xml:space="preserve"><value>תמונות שאינן קריאות אינן מועתקות לרצף החדש.</value></data>
<data name="Archive.Convert.NotCopied.Unhashed" xml:space="preserve"><value>תמונות שמעולם לא אומתו אינן מועתקות לרצף החדש; יש לאמת קודם את הרצף.</value></data>
<data name="Archive.Convert.NotCopiedPhotos.few" xml:space="preserve"><value>{0:N0} תמונות לא יועתקו</value></data>
<data name="Archive.Convert.NotCopiedPhotos.one" xml:space="preserve"><value>תמונה אחת לא תועתק</value></data>
<data name="Archive.Convert.NotCopiedPhotos.other" xml:space="preserve"><value>{0:N0} תמונות לא יועתקו</value></data>
<data name="Archive.Convert.NotPlaced" xml:space="preserve"><value>התמונות שהומרו לא יכלו לתפוס את מקומן. {0}</value></data>
<data name="Archive.Convert.PhotoFailed" xml:space="preserve"><value>לא ניתן היה להמיר את {0}. {1}</value></data>
<data name="Archive.Convert.PhotoHeld" xml:space="preserve"><value>אחת התמונות שלו פתוחה בתוכנית אחרת או שלא ניתן לפתוח אותה; יש לנסות שוב כשהיא תתפנה.</value></data>
<data name="Archive.Convert.Quality" xml:space="preserve"><value>איכות</value></data>
<data name="Archive.Convert.Replace" xml:space="preserve"><value>החלף</value></data>
<data name="Archive.Convert.ReplaceHeading.few" xml:space="preserve"><value>להחליף את התמונות של {0:N0} רצפים?</value></data>
<data name="Archive.Convert.ReplaceHeading.one" xml:space="preserve"><value>להחליף את התמונות של רצף אחד?</value></data>
<data name="Archive.Convert.ReplaceHeading.other" xml:space="preserve"><value>להחליף את התמונות של {0:N0} רצפים?</value></data>
<data name="Archive.Convert.ReplaceMessage" xml:space="preserve"><value>ההמרה ל-{2} תחליף את {0} ({1}); הקבצים המקוריים יעברו לאשפה של הארכיון, וניתן יהיה לשחזר אותם עד לריקון האשפה.</value></data>
<data name="Archive.Convert.Sizes" xml:space="preserve"><value>{0} → {1}</value></data>
<data name="Archive.Convert.Skipped.ColorProfile" xml:space="preserve"><value>תמונות שהפורמט הזה אינו יכול לשמור או להמיר את פרופיל הצבע שלהן נשארות כפי שהן.</value></data>
<data name="Archive.Convert.Skipped.EightBit" xml:space="preserve"><value>תמונות RAW שהמחשב הזה מפתח ב-8 סיביות בלבד נשארות כפי שהן; המרה ל-JPEG אפשרית.</value></data>
<data name="Archive.Convert.Skipped.Inaccessible" xml:space="preserve"><value>תמונות שתוכנית אחרת מחזיקה פתוחות, או שלא ניתן לפתוח, נשארות כפי שהן; יש לתכנן שוב כשהן יתפנו.</value></data>
<data name="Archive.Convert.Skipped.Missing" xml:space="preserve"><value>תמונות חסרות נשארות כפי שהן.</value></data>
<data name="Archive.Convert.Skipped.NoNativeDecoder" xml:space="preserve"><value>תמונות בפורמט שהמחשב הזה אינו יכול לקרוא ברזולוציה מלאה נשארות כפי שהן.</value></data>
<data name="Archive.Convert.Skipped.PreviewOnly" xml:space="preserve"><value>תמונות שנקראות כאן רק מהתצוגה המקדימה המוטמעת שלהן נשארות כפי שהן.</value></data>
<data name="Archive.Convert.Skipped.SameFormat" xml:space="preserve"><value>תמונות שכבר נמצאות בפורמט הזה נשארות כפי שהן.</value></data>
<data name="Archive.Convert.Skipped.TooLarge" xml:space="preserve"><value>תמונות הגדולות ממה שהפורמט הזה יכול להכיל או ממה ש-Chronos יכול לקרוא בחזרה נשארות כפי שהן.</value></data>
<data name="Archive.Convert.Skipped.Undecodable" xml:space="preserve"><value>תמונות שאינן קריאות נשארות כפי שהן.</value></data>
<data name="Archive.Convert.Skipped.Unhashed" xml:space="preserve"><value>תמונות שמעולם לא אומתו נשארות כפי שהן; יש לאמת קודם את הרצף.</value></data>
<data name="Archive.Convert.SkippedPhotos.few" xml:space="preserve"><value>{0:N0} תמונות ידולגו</value></data>
<data name="Archive.Convert.SkippedPhotos.one" xml:space="preserve"><value>תמונה אחת תדולג</value></data>
<data name="Archive.Convert.SkippedPhotos.other" xml:space="preserve"><value>{0:N0} תמונות ידולגו</value></data>
<data name="Archive.Convert.Space" xml:space="preserve"><value>נדרשים {0}, פנויים {1}</value></data>
<data name="Archive.Convert.SpaceShort" xml:space="preserve"><value>נדרשים {0}, פנויים רק {1}: יש לפנות קודם מקום.</value></data>
<data name="Archive.Convert.SpaceUnknown" xml:space="preserve"><value>נדרשים {0}; לא ניתן למדוד את השטח הפנוי.</value></data>
<data name="Archive.Convert.Target.LinearDng" xml:space="preserve"><value>DNG ליניארי</value></data>
<data name="Archive.Convert.Target.Tiff16" xml:space="preserve"><value>TIFF ב-16 סיביות</value></data>
<data name="Archive.Convert.UndoFailed" xml:space="preserve"><value>לא ניתן היה להחזיר את הקבצים המקוריים</value></data>
<data name="Archive.Convert.UndoNothing" xml:space="preserve"><value>הקבצים המקוריים שהוחלפו כבר אינם באשפה.</value></data>
<data name="Archive.Convert.Undone.few" xml:space="preserve"><value>הקבצים המקוריים חזרו ל-{0:N0} רצפים</value></data>
<data name="Archive.Convert.Undone.one" xml:space="preserve"><value>הקבצים המקוריים חזרו לרצף אחד</value></data>
<data name="Archive.Convert.Undone.other" xml:space="preserve"><value>הקבצים המקוריים חזרו ל-{0:N0} רצפים</value></data>
<data name="Archive.Convert.UndoneNew.few" xml:space="preserve"><value>{0:N0} רצפים השתנו בינתיים: הקבצים המקוריים שלהם חזרו כרצפים חדשים.</value></data>
<data name="Archive.Convert.UndoneNew.one" xml:space="preserve"><value>רצף אחד השתנה בינתיים: הקבצים המקוריים שלו חזרו כרצף חדש.</value></data>
<data name="Archive.Convert.UndoneNew.other" xml:space="preserve"><value>{0:N0} רצפים השתנו בינתיים: הקבצים המקוריים שלהם חזרו כרצפים חדשים.</value></data>
<data name="Archive.Convert.Unstaged" xml:space="preserve"><value>ההמרה של {0} כבר אינה בין הקבצים שהוכנו; הניסיון החוזר ימיר אותו שוב.</value></data>
<data name="Archive.Copy.Title" xml:space="preserve"><value>תיקייה להעתקה לארכיון</value></data>
<data name="Archive.Delete.Action" xml:space="preserve"><value>העבר לאשפה</value></data>
<data name="Archive.Delete.Blocked" xml:space="preserve"><value>לא הועבר: {0} · {1}</value></data>
@@ -85,6 +172,10 @@
<data name="Archive.Duplicates.Title" xml:space="preserve"><value>כפילויות</value></data>
<data name="Archive.Empty" xml:space="preserve"><value>אין ארכיון עדיין</value></data>
<data name="Archive.Error.Busy" xml:space="preserve"><value>מופע אחר של Chronos ({0}) כותב כאן. יש לנסות שוב בעוד רגע.</value></data>
<data name="Archive.Error.ConvertKept.few" xml:space="preserve"><value>{0:N0} רצפים לא הומרו כמתוכנן; הסיבה מופיעה ביומן המשימה.</value></data>
<data name="Archive.Error.ConvertKept.one" xml:space="preserve"><value>רצף אחד לא הומר כמתוכנן; הסיבה מופיעה ביומן המשימה.</value></data>
<data name="Archive.Error.ConvertKept.other" xml:space="preserve"><value>{0:N0} רצפים לא הומרו כמתוכנן; הסיבה מופיעה ביומן המשימה.</value></data>
<data name="Archive.Error.ConvertSpace" xml:space="preserve"><value>ההמרה דורשת {0} פנויים באמצעי האחסון של הארכיון, ופנויים בו {1}.</value></data>
<data name="Archive.Error.CopyMismatch" xml:space="preserve"><value>העותק של {0} אינו תואם למקור.</value></data>
<data name="Archive.Error.DuplicateLost" xml:space="preserve"><value>לא ניתן היה להוסיף את {0} לרצף.</value></data>
<data name="Archive.Error.InLibrary" xml:space="preserve"><value>{0} כבר נמצא בספרייה.</value></data>
@@ -105,9 +196,9 @@
<data name="Archive.Error.SourceGone" xml:space="preserve"><value>הכרטיס או התיקייה {0} אינם זמינים עוד.</value></data>
<data name="Archive.Error.StalePlan" xml:space="preserve"><value>הארכיון השתנה לאחר שהתוכנית הזו נוצרה.</value></data>
<data name="Archive.Error.TrashChanged" xml:space="preserve"><value>האשפה השתנתה לאחר שנבדקה; דבר לא נמחק.</value></data>
<data name="Archive.Error.TrashKept.few" xml:space="preserve"><value>{0:N0} פריטים באשפה נשמרו: הם השתנו, או שהחלפה כבר אינה תואמת.</value></data>
<data name="Archive.Error.TrashKept.one" xml:space="preserve"><value>פריט אחד באשפה נשמר: הוא השתנה, או שהחלפה כבר אינה תואמת.</value></data>
<data name="Archive.Error.TrashKept.other" xml:space="preserve"><value>{0:N0} פריטים באשפה נשמרו: הם השתנו, או שהחלפה כבר אינה תואמת.</value></data>
<data name="Archive.Error.TrashKept.few" xml:space="preserve"><value>{0:N0} פריטים נשארו באשפה; הסיבה מופיעה ביומן המשימה.</value></data>
<data name="Archive.Error.TrashKept.one" xml:space="preserve"><value>פריט אחד נשאר באשפה; הסיבה מופיעה ביומן המשימה.</value></data>
<data name="Archive.Error.TrashKept.other" xml:space="preserve"><value>{0:N0} פריטים נשארו באשפה; הסיבה מופיעה ביומן המשימה.</value></data>
<data name="Archive.Error.TrashMismatch" xml:space="preserve"><value>אף קובץ של פריט האשפה הזה כבר אינו תואם לרשומה שלו; הוא נשאר באשפה.</value></data>
<data name="Archive.Failed.Access" xml:space="preserve"><value>הגישה של Chronos לארכיון נדחתה.</value></data>
<data name="Archive.Failed.Files" xml:space="preserve"><value>לא ניתן היה לקרוא או לכתוב קובץ בארכיון.</value></data>
@@ -151,6 +242,15 @@
<data name="Archive.Log.AuditKept" xml:space="preserve"><value>יומן הביקורת נשמר במלואו</value></data>
<data name="Archive.Log.AuditPurged" xml:space="preserve"><value>רשומות ביקורת שהוסרו: {0}</value></data>
<data name="Archive.Log.BackupDone" xml:space="preserve"><value>האינדקס הועתק אל {0} ({1}); עותקים שנשמרים: {2}</value></data>
<data name="Archive.Log.ConvertBlocked" xml:space="preserve"><value>נשאר כפי שהיה, תפוס או בלתי קריא: {0}</value></data>
<data name="Archive.Log.ConvertChanged" xml:space="preserve"><value>נשאר כפי שהיה, השתנה אחרי התוכנית: {0}. ניסיון חוזר ישאיר אותו כפי שהוא: יש להמיר אותו שוב מתוכנית חדשה.</value></data>
<data name="Archive.Log.ConvertDone" xml:space="preserve"><value>רצפים שהומרו: {0}, רצפים חדשים: {1}, תמונות: {2}</value></data>
<data name="Archive.Log.ConvertFailed" xml:space="preserve"><value>נשאר כפי שהיה: {0}. {1}</value></data>
<data name="Archive.Log.ConvertLeftOut" xml:space="preserve"><value>{0}: תמונות שלא הומרו ונשארו רק במקור: {1}</value></data>
<data name="Archive.Log.ConvertNothing" xml:space="preserve"><value>אין מה להמיר: {0}</value></data>
<data name="Archive.Log.ConvertSuperseded" xml:space="preserve"><value>{0}: המרה אחרת יצרה את העותק שלה בפורמט הזה מאז שהמרה זו אושרה; לא נוצר עותק שני.</value></data>
<data name="Archive.Log.Converted" xml:space="preserve"><value>{0}: תמונות שהוחלפו בהמרה שלהן: {1}</value></data>
<data name="Archive.Log.ConvertedNew" xml:space="preserve"><value>{0}: תמונות שהומרו לרצף חדש: {1}</value></data>
<data name="Archive.Log.DryRun" xml:space="preserve"><value>הרצת ניסיון: לא שונה דבר.</value></data>
<data name="Archive.Log.DuplicateGroup" xml:space="preserve"><value>עותקים נוספים של {0}: {1}</value></data>
<data name="Archive.Log.DuplicatesDone" xml:space="preserve"><value>קבוצות כפילויות: {0}, עותקים נוספים: {1}</value></data>
@@ -185,9 +285,23 @@
<data name="Archive.Log.SequenceMissing" xml:space="preserve"><value>הרצף לא נמצא: {0}</value></data>
<data name="Archive.Log.StepFailed" xml:space="preserve"><value>שלב הניקוי {0} נכשל: {1}</value></data>
<data name="Archive.Log.StepUnknown" xml:space="preserve"><value>שלב ניקוי שאינו מוכר כאן: {0}</value></data>
<data name="Archive.Log.SyncChanged" xml:space="preserve"><value>{0}: השתנה מאז שנשמר בארכיון, לא הועלה</value></data>
<data name="Archive.Log.SyncDeletedHere" xml:space="preserve"><value>{0}: נמחק במחשב הזה, לא הורד</value></data>
<data name="Archive.Log.SyncDeletedThere" xml:space="preserve"><value>{0}: נמחק בשרת, לא הועלה</value></data>
<data name="Archive.Log.SyncFrameChanged" xml:space="preserve"><value>{0}: הפריים שלו כאן השתנה בינתיים, לא הורד</value></data>
<data name="Archive.Log.SyncMissing" xml:space="preserve"><value>{0}: חסר, לא הועלה</value></data>
<data name="Archive.Log.SyncNoPreview.few" xml:space="preserve"><value>ל-{0:N0} פריימים אין בשרת פרוקסי וגם לא תמונה ממוזערת</value></data>
<data name="Archive.Log.SyncNoPreview.one" xml:space="preserve"><value>לפריים אחד אין בשרת פרוקסי וגם לא תמונה ממוזערת</value></data>
<data name="Archive.Log.SyncNoPreview.other" xml:space="preserve"><value>ל-{0:N0} פריימים אין בשרת פרוקסי וגם לא תמונה ממוזערת</value></data>
<data name="Archive.Log.TrashEmptied" xml:space="preserve"><value>פריטים שנמחקו: {0}, גודל: {1}</value></data>
<data name="Archive.Log.TrashEntry" xml:space="preserve"><value>באשפה מאז {0}: {1} ({2})</value></data>
<data name="Archive.Log.TrashKept" xml:space="preserve"><value>נשאר באשפה: {0}</value></data>
<data name="Archive.Log.TrashKept" xml:space="preserve"><value>נשאר באשפה, השתנה אחרי התוכנית: {0}</value></data>
<data name="Archive.Log.TrashKeptBusy" xml:space="preserve"><value>נשאר באשפה, הרצף שלו היה תפוס: {0}</value></data>
<data name="Archive.Log.TrashKeptMismatch" xml:space="preserve"><value>נשאר באשפה, המרה של הקבצים המקוריים שלו כבר אינה תואמת: {0}</value></data>
<data name="Archive.Log.TrashKeptStaleIndex" xml:space="preserve"><value>נשאר באשפה, האינדקס מפרט את הרצף שלו, שכבר אינו נמצא בארכיון; יש לבנות מחדש את האינדקס: {0}</value></data>
<data name="Archive.Log.TrashKeptUnhashed" xml:space="preserve"><value>נשאר באשפה, תמונה מהרצף שלו מעולם לא אומתה; יש לאמת את הרצף: {0}</value></data>
<data name="Archive.Log.TrashKeptUnknown" xml:space="preserve"><value>נשאר באשפה, הארכיון אינו מראה מה עלה בגורל ההמרה של הקבצים המקוריים שלו; יש לשחזר אותו כדי לשמור עליהם: {0}</value></data>
<data name="Archive.Log.TrashKeptUnreadable" xml:space="preserve"><value>נשאר באשפה, הקובץ הנלווה של תיקייה שעשויה להכיל את הרצף שלו חסר או שאינו קריא; יש לסרוק את הארכיון: {0}</value></data>
<data name="Archive.Log.TrashOffline" xml:space="preserve"><value>האשפה לא נבדקה: אין גישה לארכיון</value></data>
<data name="Archive.Log.TrashReport" xml:space="preserve"><value>פריטים ישנים באשפה: {0}, גודל: {1}; דבר לא נמחק</value></data>
<data name="Archive.Log.VerifyDone" xml:space="preserve"><value>תמונות שנבדקו: {0}, תקינות: {1}, חושב להן גיבוב: {2}, עם בעיות: {3}</value></data>
@@ -277,6 +391,7 @@
<data name="Archive.Set.All.other" xml:space="preserve"><value>{0:N0} רצפים · הכול</value></data>
<data name="Archive.Set.Analyse" xml:space="preserve"><value>נתח</value></data>
<data name="Archive.Set.ClearFilter" xml:space="preserve"><value>נקה סינון</value></data>
<data name="Archive.Set.Convert" xml:space="preserve"><value>המר…</value></data>
<data name="Archive.Set.Delete" xml:space="preserve"><value>מחק…</value></data>
<data name="Archive.Set.Export" xml:space="preserve"><value>ייצא CSV</value></data>
<data name="Archive.Set.Filter" xml:space="preserve"><value>סינון האוסף</value></data>
@@ -310,6 +425,7 @@
<data name="Archive.Toolbar.Scan" xml:space="preserve"><value>סרוק</value></data>
<data name="Archive.Toolbar.Verify" xml:space="preserve"><value>אמת</value></data>
<data name="Archive.Trash.Checking" xml:space="preserve"><value>בודק את האשפה…</value></data>
<data name="Archive.Trash.ConversionDeleted" xml:space="preserve"><value>ההמרה נמחקה</value></data>
<data name="Archive.Trash.Deleted" xml:space="preserve"><value>נמחק ב-{0}</value></data>
<data name="Archive.Trash.Empty" xml:space="preserve"><value>האשפה ריקה</value></data>
<data name="Archive.Trash.EmptyAction" xml:space="preserve"><value>רוקן…</value></data>
+1
View File
@@ -70,6 +70,7 @@
<data name="Jobs.Kind.Adopt" xml:space="preserve"><value>אימוץ תיקייה</value></data>
<data name="Jobs.Kind.Backup" xml:space="preserve"><value>גיבוי האינדקס</value></data>
<data name="Jobs.Kind.Cleanup" xml:space="preserve"><value>ניקוי</value></data>
<data name="Jobs.Kind.Convert" xml:space="preserve"><value>המרה</value></data>
<data name="Jobs.Kind.DeepAnalyse" xml:space="preserve"><value>ניתוח מעמיק</value></data>
<data name="Jobs.Kind.Download" xml:space="preserve"><value>הורדה</value></data>
<data name="Jobs.Kind.Duplicates" xml:space="preserve"><value>כפילויות</value></data>
+2
View File
@@ -6,6 +6,7 @@
<resheader name="writer"><value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader>
<data name="Library.Action.Analyse" xml:space="preserve"><value>נתח</value></data>
<data name="Library.Action.ClearSelection" xml:space="preserve"><value>נקה בחירה</value></data>
<data name="Library.Action.Convert" xml:space="preserve"><value>המר…</value></data>
<data name="Library.Action.Delete" xml:space="preserve"><value>מחק…</value></data>
<data name="Library.Action.Download" xml:space="preserve"><value>הורד</value></data>
<data name="Library.Action.ExportList" xml:space="preserve"><value>ייצא רשימה</value></data>
@@ -32,6 +33,7 @@
<data name="Library.Blocked.NothingToDownload" xml:space="preserve"><value>לרצפים שנבחרו אין מה להוריד מהשרת.</value></data>
<data name="Library.Blocked.NothingToUpload" xml:space="preserve"><value>לשרת כבר יש את כל מה שהרצפים שנבחרו מכילים.</value></data>
<data name="Library.Blocked.OneArchive" xml:space="preserve"><value>ארגון מחדש פועל על הרצפים של ארכיון אחד בכל פעם.</value></data>
<data name="Library.Blocked.OneArchiveConvert" xml:space="preserve"><value>המרה פועלת על הרצפים של ארכיון אחד בכל פעם.</value></data>
<data name="Library.Blocked.ServerOnly" xml:space="preserve"><value>רק עבור רצפים במחשב הזה; הרצפים שנבחרו נמצאים בשרת בלבד.</value></data>
<data name="Library.Blocked.Transferring" xml:space="preserve"><value>העברה של הרצף הזה כבר מתבצעת.</value></data>
<data name="Library.ClearFilters" xml:space="preserve"><value>נקה מסננים</value></data>
+4
View File
@@ -21,6 +21,8 @@
<data name="Server.Conflict.TakeServer.Message" xml:space="preserve"><value>ההגדרות של {0} במחשב הזה יוחלפו בעותק שבשרת.</value></data>
<data name="Server.Conflict.TakeServer.Title" xml:space="preserve"><value>לקחת את ההגדרות מהשרת?</value></data>
<data name="Server.Connect" xml:space="preserve"><value>התחבר</value></data>
<data name="Server.Convert.OnPc" xml:space="preserve"><value>יש להמיר את התמונות האלה במחשב: השרת אינו יכול לקרוא אותן ברזולוציה מלאה.</value></data>
<data name="Server.Convert.OnPcNew" xml:space="preserve"><value>לא מועתקות לרצף החדש: השרת אינו יכול לקרוא את התמונות האלה ברזולוציה מלאה; יש להמיר אותן במחשב.</value></data>
<data name="Server.Disconnect" xml:space="preserve"><value>התנתק</value></data>
<data name="Server.Empty" xml:space="preserve"><value>לא מחובר לשרת</value></data>
<data name="Server.Error.AccountLocked" xml:space="preserve"><value>יותר מדי ניסיונות כניסה כושלים; החשבון נעול לזמן מה.</value></data>
@@ -71,7 +73,9 @@
<data name="Server.Error.MethodNotAllowed" xml:space="preserve"><value>השיטה הזו אינה מותרת כאן.</value></data>
<data name="Server.Error.NestedTarget" xml:space="preserve"><value>תיקייה חדשה תהיה בתוך התיקייה של רצף אחר.</value></data>
<data name="Server.Error.NotChronos" xml:space="preserve"><value>הכתובת הזו אינה של שרת Chronos.</value></data>
<data name="Server.Error.NotEnoughSpace" xml:space="preserve"><value>באמצעי האחסון של הארכיון אין מספיק מקום להמרה.</value></data>
<data name="Server.Error.NotFound" xml:space="preserve"><value>לא נמצא.</value></data>
<data name="Server.Error.NothingToConvert" xml:space="preserve"><value>התוכנית אינה ממירה דבר: כל התמונות מדולגות או שכל הרצפים חסומים.</value></data>
<data name="Server.Error.PasswordChangeRequired" xml:space="preserve"><value>יש להחליף קודם את הסיסמה.</value></data>
<data name="Server.Error.PhotoRemoved" xml:space="preserve"><value>התמונה נמחקה מהרצף בזמן שהועלתה, ולכן לא נוספה.</value></data>
<data name="Server.Error.PhotoUnreadable" xml:space="preserve"><value>לא ניתן לקרוא את {0}, ובלי הגיבוב שלו עותקים אחרים לא יידעו שהוא נמחק; יש לסגור את התוכנית שמשתמשת בו או לבדוק את ההרשאות שלו, ולנסות שוב.</value></data>
+21 -1
View File
@@ -27,6 +27,22 @@
<data name="Tooltips.Archive.ClearFilter" xml:space="preserve"><value>הצגה מחדש של כל הרצפים בבחירה</value></data>
<data name="Tooltips.Archive.CloseDialog" xml:space="preserve"><value>סגירה ללא שינוי · Esc</value></data>
<data name="Tooltips.Archive.Collapse" xml:space="preserve"><value>הסתרת הרצפים של השנה הזו</value></data>
<data name="Tooltips.Archive.ConvertApplyNew" xml:space="preserve"><value>אישור, ואז הוספה לתור של משימה שממירה עותקים לרצפים חדשים · ניתן להשהות ולהמשיך אותה במסך &quot;משימות&quot;</value></data>
<data name="Tooltips.Archive.ConvertApplyReplace" xml:space="preserve"><value>הקלדת מספר התמונות לאישור, ואז הוספה לתור של משימה שמחליפה אותן בהמרה שלהן · ניתן להשהות ולהמשיך אותה במסך &quot;משימות&quot;</value></data>
<data name="Tooltips.Archive.ConvertBack" xml:space="preserve"><value>חזרה לתוכנית; דבר אינו מומר</value></data>
<data name="Tooltips.Archive.ConvertDng" xml:space="preserve"><value>DNG ליניארי, 16 סיביות וללא אובדן · כל עורך RAW קורא אותו; הבחירה לארכוב</value></data>
<data name="Tooltips.Archive.ConvertJpeg" xml:space="preserve"><value>JPEG ב-8 סיביות באיכות שנקבעת למטה · הקבצים הקטנים ביותר; חלק מהפרטים אובדים</value></data>
<data name="Tooltips.Archive.ConvertModeNew" xml:space="preserve"><value>העותקים שהומרו נכנסים לרצף חדש לצד כל רצף; הקבצים המקוריים נשארים כפי שהם</value></data>
<data name="Tooltips.Archive.ConvertModeReplace" xml:space="preserve"><value>הקבצים שהומרו תופסים את מקום התמונות ברצפים שלהן; הקבצים המקוריים עוברים לאשפה של הארכיון, וניתן לשחזר אותם עד לריקון האשפה</value></data>
<data name="Tooltips.Archive.ConvertNew" xml:space="preserve"><value>הוספה לתור של המשימה שממירה את התמונות לרצפים חדשים ומאמתת כל המרה; הקבצים המקוריים נשארים ללא שינוי</value></data>
<data name="Tooltips.Archive.ConvertPlan" xml:space="preserve"><value>הרצפים שהתמונות שלהם יוחלפו</value></data>
<data name="Tooltips.Archive.ConvertPlanNew" xml:space="preserve"><value>הרצפים שיועתקו לרצפים חדשים, והתמונות שכל אחד מהם משאיר בחוץ</value></data>
<data name="Tooltips.Archive.ConvertQuality" xml:space="preserve"><value>איכות JPEG מ-1 עד 100 · 95 שומר על פרטים עדינים; ערך נמוך יותר יוצר קבצים קטנים יותר</value></data>
<data name="Tooltips.Archive.ConvertReplace.few" xml:space="preserve"><value>החלפת {0:N0} תמונות בהמרה שלהן; יש להקליד קודם את המספר שלמעלה</value></data>
<data name="Tooltips.Archive.ConvertReplace.one" xml:space="preserve"><value>החלפת תמונה אחת בהמרה שלה; יש להקליד קודם את המספר שלמעלה</value></data>
<data name="Tooltips.Archive.ConvertReplace.other" xml:space="preserve"><value>החלפת {0:N0} תמונות בהמרה שלהן; יש להקליד קודם את המספר שלמעלה</value></data>
<data name="Tooltips.Archive.ConvertTiff" xml:space="preserve"><value>TIFF ב-16 סיביות בדחיסה ללא אובדן · קבצים גדולים שכל עורך פותח</value></data>
<data name="Tooltips.Archive.ConvertUndo" xml:space="preserve"><value>החזרת הקבצים המקוריים מהאשפה במקום ההמרות שלהם</value></data>
<data name="Tooltips.Archive.DeleteAction.few" xml:space="preserve"><value>העברת {0:N0} רצפים לאשפה; יש להקליד קודם את המספר שלמעלה</value></data>
<data name="Tooltips.Archive.DeleteAction.one" xml:space="preserve"><value>העברת רצף אחד לאשפה; יש להקליד קודם את המספר שלמעלה</value></data>
<data name="Tooltips.Archive.DeleteAction.other" xml:space="preserve"><value>העברת {0:N0} רצפים לאשפה; יש להקליד קודם את המספר שלמעלה</value></data>
@@ -83,6 +99,7 @@
<data name="Tooltips.Archive.Scan" xml:space="preserve"><value>סריקה מצטברת: קבצים חדשים, שהשתנו ושהוסרו, לפי זמן השינוי והגודל</value></data>
<data name="Tooltips.Archive.Set" xml:space="preserve"><value>השנים והרצפים שנבחרו (הכול כשלא נבחר דבר), מצומצמים לפי מצלמה, מצב או תגית</value></data>
<data name="Tooltips.Archive.SetAnalyse" xml:space="preserve"><value>הרצת ניתוח מעמיק על כל רצף באוסף</value></data>
<data name="Tooltips.Archive.SetConvert" xml:space="preserve"><value>המרת התמונות של האוסף ל-JPEG, ל-TIFF או ל-DNG · קודם הרצת ניסיון, ואז משימה</value></data>
<data name="Tooltips.Archive.SetDelete" xml:space="preserve"><value>העברת האוסף לאשפה של הארכיון · מציג את הרצת הניסיון, ואז מבקש להקליד לאישור</value></data>
<data name="Tooltips.Archive.SetExport" xml:space="preserve"><value>ייצוא האוסף כ-CSV: שורה אחת לכל רצף</value></data>
<data name="Tooltips.Archive.SetProxies" xml:space="preserve"><value>יצירה או רענון של קובצי פרוקסי</value></data>
@@ -97,7 +114,7 @@
<data name="Tooltips.Archive.TitleTemplate" xml:space="preserve"><value>תבנית הכותרת; השדה title הוא הכותרת הנוכחית · נבדקת תוך כדי הקלדה</value></data>
<data name="Tooltips.Archive.Trash" xml:space="preserve"><value>הרצפים והתמונות שנמחקו מהארכיון הזה, וכל אחד מהם ניתן לשחזור</value></data>
<data name="Tooltips.Archive.TrashEmpty" xml:space="preserve"><value>מחיקה לצמיתות של הפריטים באשפה הזו, לאחר בדיקה של מה שהם מכילים ואישור בהקלדה</value></data>
<data name="Tooltips.Archive.TrashEmptyPlan" xml:space="preserve"><value>מה נמחק מהארכיון לצמיתות</value></data>
<data name="Tooltips.Archive.TrashEmptyPlan" xml:space="preserve"><value>מה יימחק מהארכיון לצמיתות; קבצים מקוריים שההמרה שלהם נמחקה עשויים להיות העותק האחרון של התמונות שלהם</value></data>
<data name="Tooltips.Archive.TrashErase.few" xml:space="preserve"><value>מחיקה לצמיתות של {0:N0} פריטים; יש להקליד קודם את המספר שלמעלה</value></data>
<data name="Tooltips.Archive.TrashErase.one" xml:space="preserve"><value>מחיקה לצמיתות של פריט אחד; יש להקליד קודם את המספר שלמעלה</value></data>
<data name="Tooltips.Archive.TrashErase.other" xml:space="preserve"><value>מחיקה לצמיתות של {0:N0} פריטים; יש להקליד קודם את המספר שלמעלה</value></data>
@@ -472,6 +489,9 @@
<data name="Tooltips.Library.Mass.Analyse.few" xml:space="preserve"><value>ניתוח מעמיק של {0:N0} רצפים במחשב הזה · פועל כמשימה אחת</value></data>
<data name="Tooltips.Library.Mass.Analyse.one" xml:space="preserve"><value>ניתוח מעמיק של רצף אחד במחשב הזה · פועל כמשימה אחת</value></data>
<data name="Tooltips.Library.Mass.Analyse.other" xml:space="preserve"><value>ניתוח מעמיק של {0:N0} רצפים במחשב הזה · פועל כמשימה אחת</value></data>
<data name="Tooltips.Library.Mass.Convert.few" xml:space="preserve"><value>המרת התמונות של {0:N0} רצפים בארכיון שלהם ל-JPEG, ל-TIFF או ל-DNG · קודם הרצת ניסיון, ואז משימה</value></data>
<data name="Tooltips.Library.Mass.Convert.one" xml:space="preserve"><value>המרת התמונות של רצף אחד ל-JPEG, ל-TIFF או ל-DNG · קודם הרצת ניסיון, ואז משימה</value></data>
<data name="Tooltips.Library.Mass.Convert.other" xml:space="preserve"><value>המרת התמונות של {0:N0} רצפים בארכיון שלהם ל-JPEG, ל-TIFF או ל-DNG · קודם הרצת ניסיון, ואז משימה</value></data>
<data name="Tooltips.Library.Mass.Delete.few" xml:space="preserve"><value>העברת {0:N0} רצפים לאשפה של הארכיון שלהם · מציג את הרצת הניסיון, ואז מבקש להקליד לאישור</value></data>
<data name="Tooltips.Library.Mass.Delete.one" xml:space="preserve"><value>העברת רצף אחד לאשפה של הארכיון שלו · מציג את הרצת הניסיון, ואז מבקש להקליד לאישור</value></data>
<data name="Tooltips.Library.Mass.Delete.other" xml:space="preserve"><value>העברת {0:N0} רצפים לאשפה של הארכיון שלהם · מציג את הרצת הניסיון, ואז מבקש להקליד לאישור</value></data>
+69
View File
@@ -9,6 +9,7 @@
<data name="Admin.About.Title" xml:space="preserve"><value>Chronos Server</value></data>
<data name="Admin.About.Uptime" xml:space="preserve"><value>चालू अवधि</value></data>
<data name="Admin.About.Version" xml:space="preserve"><value>संस्करण</value></data>
<data name="Admin.Activity.ArchiveConverted" xml:space="preserve"><value>{0} ने एक रूपांतरण कतार में रखा · {1}</value></data>
<data name="Admin.Activity.ArchiveReorganized" xml:space="preserve"><value>{0} ने संग्रह को पुनर्व्यवस्थित किया · {1}</value></data>
<data name="Admin.Activity.ArchiveSettings" xml:space="preserve"><value>{0} ने संग्रह का लेआउट बदला</value></data>
<data name="Admin.Activity.FramesDeleted" xml:space="preserve"><value>{0} ने {1} हटाया</value></data>
@@ -83,6 +84,68 @@
<data name="Admin.Common.TypeToConfirm.Tip" xml:space="preserve"><value>पुष्टि के लिए नाम ठीक वैसा ही टाइप करें जैसा दिखाया गया है</value></data>
<data name="Admin.Common.TypeWord.Tip" xml:space="preserve"><value>शब्द ठीक वैसा ही टाइप करें जैसा दिखाया गया है; बड़े या छोटे अक्षरों से फ़र्क नहीं पड़ता</value></data>
<data name="Admin.Common.TypeWordFirst.Tip" xml:space="preserve"><value>पहले ऊपर दिया गया शब्द टाइप करें</value></data>
<data name="Admin.Convert.Action" xml:space="preserve"><value>रूपांतरित करें…</value></data>
<data name="Admin.Convert.Action.Tip" xml:space="preserve"><value>चयनित सीक्वेंस की फ़ोटो को JPEG, TIFF-16 या लीनियर DNG में रूपांतरित करें; पूर्वावलोकन पहले हर सीक्वेंस दिखाता है</value></data>
<data name="Admin.Convert.Apply" xml:space="preserve"><value>रूपांतरित करें…</value></data>
<data name="Admin.Convert.Apply.Tip" xml:space="preserve"><value>पूर्वावलोकन के अनुसार रूपांतरित करें; पहले पुष्टि माँगी जाती है</value></data>
<data name="Admin.Convert.Cancel.Tip" xml:space="preserve"><value>कुछ भी रूपांतरित किए बिना बंद करें</value></data>
<data name="Admin.Convert.ChooseMode" xml:space="preserve"><value>रूपांतरित करने के लिए “प्रतिस्थापित करें” या “नया सीक्वेंस” चुनें।</value></data>
<data name="Admin.Convert.ChooseMode.Tip" xml:space="preserve"><value>पहले “प्रतिस्थापित करें” या “नया सीक्वेंस” चुनें</value></data>
<data name="Admin.Convert.Column.Converted" xml:space="preserve"><value>रूपांतरित</value></data>
<data name="Admin.Convert.Column.NotCopied" xml:space="preserve"><value>कॉपी नहीं की गईं</value></data>
<data name="Admin.Convert.Column.Sequence" xml:space="preserve"><value>सीक्वेंस</value></data>
<data name="Admin.Convert.Column.Size" xml:space="preserve"><value>आकार</value></data>
<data name="Admin.Convert.Column.Unchanged" xml:space="preserve"><value>अपरिवर्तित</value></data>
<data name="Admin.Convert.Confirm.New" xml:space="preserve"><value>रूपांतरित करें</value></data>
<data name="Admin.Convert.Confirm.New.Tip" xml:space="preserve"><value>वह कार्य कतार में रखें जो फ़ोटो को नए सीक्वेंस में रूपांतरित करता है और हर रूपांतरण सत्यापित करता है; मूल फ़ाइलों को छुआ नहीं जाता</value></data>
<data name="Admin.Convert.Confirm.Replace" xml:space="preserve"><value>प्रतिस्थापित करें</value></data>
<data name="Admin.Convert.Confirm.Replace.Tip" xml:space="preserve"><value>वह कार्य कतार में रखें जो फ़ोटो रूपांतरित करता है, हर रूपांतरण सत्यापित करता है और मूल फ़ाइलों को ट्रैश में ले जाता है</value></data>
<data name="Admin.Convert.ConfirmNew.one" xml:space="preserve"><value>{0} फ़ोटो को एक नए सीक्वेंस में कॉपी के रूप में रूपांतरित किया जाता है; मूल फ़ाइल जैसी है वैसी रहती है।</value></data>
<data name="Admin.Convert.ConfirmNew.other" xml:space="preserve"><value>{0} फ़ोटो को हर सीक्वेंस के बगल में एक नए सीक्वेंस में कॉपी के रूप में रूपांतरित किया जाता है; मूल फ़ाइलें जैसी हैं वैसी रहती हैं।</value></data>
<data name="Admin.Convert.ConfirmNewNotCopied.one" xml:space="preserve"><value>{0} फ़ोटो पूर्वावलोकन में बताए गए कारण से नए सीक्वेंस में कॉपी नहीं की जाती।</value></data>
<data name="Admin.Convert.ConfirmNewNotCopied.other" xml:space="preserve"><value>{0} फ़ोटो पूर्वावलोकन में बताए गए कारणों से नए सीक्वेंस में कॉपी नहीं की जातीं।</value></data>
<data name="Admin.Convert.ConfirmNewTitle" xml:space="preserve"><value>{0} में रूपांतरित करके नए सीक्वेंस बनाएँ?</value></data>
<data name="Admin.Convert.ConfirmReplace.one" xml:space="preserve"><value>{1} में {0} फ़ोटो को उसके रूपांतरण से प्रतिस्थापित किया जाता है; मूल फ़ाइल ट्रैश में जाती है, और ट्रैश खाली होने तक पुनर्स्थापित की जा सकती है।</value></data>
<data name="Admin.Convert.ConfirmReplace.other" xml:space="preserve"><value>{1} में {0} फ़ोटो को उनके रूपांतरणों से प्रतिस्थापित किया जाता है; मूल फ़ाइलें ट्रैश में जाती हैं, और ट्रैश खाली होने तक पुनर्स्थापित की जा सकती हैं।</value></data>
<data name="Admin.Convert.ConfirmReplaceTitle" xml:space="preserve"><value>मूल फ़ाइलों को {0} से प्रतिस्थापित करें?</value></data>
<data name="Admin.Convert.Format" xml:space="preserve"><value>फ़ॉर्मेट</value></data>
<data name="Admin.Convert.Format.Jpeg.Tip" xml:space="preserve"><value>पूर्ण रंग विवरण वाला 8-बिट JPEG, बगल में सेट की गई गुणवत्ता पर: सबसे छोटी फ़ाइलें, जिन्हें हर प्रोग्राम खोलता है</value></data>
<data name="Admin.Convert.Format.LinearDng" xml:space="preserve"><value>लीनियर DNG</value></data>
<data name="Admin.Convert.Format.LinearDng.Tip" xml:space="preserve"><value>दोषरहित रूप से संपीड़ित 16-बिट लीनियर DNG: संग्रह के लिए उपयुक्त विकल्प, जिसे RAW एडिटर खोलते हैं</value></data>
<data name="Admin.Convert.Format.Tiff16.Tip" xml:space="preserve"><value>दोषरहित रूप से संपीड़ित 16-बिट sRGB TIFF: बड़ी फ़ाइलें जो संपादन के लिए हर टोन बनाए रखती हैं</value></data>
<data name="Admin.Convert.Gone" xml:space="preserve"><value>चयनित कोई सीक्वेंस अब संग्रह में नहीं है; बंद करें और फिर से चुनें।</value></data>
<data name="Admin.Convert.Mode" xml:space="preserve"><value>मोड</value></data>
<data name="Admin.Convert.Mode.NewSequence" xml:space="preserve"><value>नया सीक्वेंस</value></data>
<data name="Admin.Convert.Mode.NewSequence.Tip" xml:space="preserve"><value>रूपांतरित कॉपियाँ हर सीक्वेंस के बगल में एक नए सीक्वेंस में जाती हैं; मूल फ़ाइलें और उनका सीक्वेंस ठीक वैसे ही रहते हैं जैसे हैं</value></data>
<data name="Admin.Convert.Mode.Replace" xml:space="preserve"><value>प्रतिस्थापित करें</value></data>
<data name="Admin.Convert.Mode.Replace.Tip" xml:space="preserve"><value>रूपांतरित फ़ाइलें सीक्वेंस की फ़ोटो बन जाती हैं; मूल फ़ाइलें संग्रह के ट्रैश में जाती हैं, और ट्रैश खाली होने तक पुनर्स्थापित की जा सकती हैं</value></data>
<data name="Admin.Convert.NoAnswer" xml:space="preserve"><value>सर्वर ने जवाब नहीं दिया: फिर से रूपांतरित करने से पहले “कार्य” पेज पर जाँचें कि रूपांतरण कतार में रखा गया था या नहीं।</value></data>
<data name="Admin.Convert.NoSpace.Tip" xml:space="preserve"><value>पहले संग्रह के वॉल्यूम पर कुछ स्थान खाली करें</value></data>
<data name="Admin.Convert.NotCopiedCount.one" xml:space="preserve"><value>{0} कॉपी नहीं की गई</value></data>
<data name="Admin.Convert.NotCopiedCount.other" xml:space="preserve"><value>{0} कॉपी नहीं की गईं</value></data>
<data name="Admin.Convert.Nothing.Tip" xml:space="preserve"><value>पूर्वावलोकन में रूपांतरित करने को कुछ नहीं है</value></data>
<data name="Admin.Convert.NothingToConvert" xml:space="preserve"><value>रूपांतरित करने को कुछ नहीं: दिखाए गए कारणों से हर फ़ोटो जैसी है वैसी रहती है।</value></data>
<data name="Admin.Convert.OpenJob" xml:space="preserve"><value>कार्य खोलें</value></data>
<data name="Admin.Convert.OpenJob.Tip" xml:space="preserve"><value>यह कार्य और इसका लॉग “कार्य” पेज पर दिखाएँ</value></data>
<data name="Admin.Convert.PlanChanged" xml:space="preserve"><value>पूर्वावलोकन के बाद संग्रह बदल गया; नया पूर्वावलोकन जाँचें और फिर से लागू करें।</value></data>
<data name="Admin.Convert.Planning" xml:space="preserve"><value>योजना बन रही है…</value></data>
<data name="Admin.Convert.Planning.Tip" xml:space="preserve"><value>सर्वर चयन का हर फ़ोटो फ़ोल्डर पढ़ता है: बड़े संग्रह में मिनट लगते हैं, और पढ़ना पूरा होने पर पूर्वावलोकन दिखाई देता है</value></data>
<data name="Admin.Convert.PlanningFor" xml:space="preserve"><value>योजना बन रही है… {0}</value></data>
<data name="Admin.Convert.Preview" xml:space="preserve"><value>पूर्वावलोकन</value></data>
<data name="Admin.Convert.Preview.Tip" xml:space="preserve"><value>हर सीक्वेंस में क्या रूपांतरित होता है और क्या जैसा है वैसा रहता है, पहले और बाद के आकार (अनुमान) के साथ; अभी तक कुछ नहीं बदला है</value></data>
<data name="Admin.Convert.Quality" xml:space="preserve"><value>गुणवत्ता</value></data>
<data name="Admin.Convert.Quality.Tip" xml:space="preserve"><value>1 से 100 तक JPEG गुणवत्ता; 95 बारीक विवरण बनाए रखता है, कम मान छोटी फ़ाइलें बनाते हैं</value></data>
<data name="Admin.Convert.QualityRange" xml:space="preserve"><value>1 से 100 तक की कोई पूर्ण संख्या लिखें।</value></data>
<data name="Admin.Convert.Queued" xml:space="preserve"><value>रूपांतरण कतार में।</value></data>
<data name="Admin.Convert.ReplaceWord" xml:space="preserve"><value>प्रतिस्थापित</value></data>
<data name="Admin.Convert.Size.Tip" xml:space="preserve"><value>रूपांतरित होने वाली फ़ोटो का अभी का आकार, फिर बाद का अनुमान</value></data>
<data name="Admin.Convert.SkippedPhotos" xml:space="preserve"><value>{0}: {1}</value></data>
<data name="Admin.Convert.Title.one" xml:space="preserve"><value>{0} सीक्वेंस रूपांतरित करें</value></data>
<data name="Admin.Convert.Title.other" xml:space="preserve"><value>{0} सीक्वेंस रूपांतरित करें</value></data>
<data name="Admin.Convert.TitleAll" xml:space="preserve"><value>सभी सीक्वेंस रूपांतरित करें</value></data>
<data name="Admin.Convert.TooMany" xml:space="preserve"><value>रूपांतरण एक बार में अधिकतम {0} सीक्वेंस या सभी सीक्वेंस पर काम करता है: फ़िल्टर साफ़ करें और सभी चुनें।</value></data>
<data name="Admin.Convert.Totals" xml:space="preserve"><value>रूपांतरित सीक्वेंस: {0} · फ़ोटो: {1} · अपरिवर्तित: {2} · आकार: {3} → {4}</value></data>
<data name="Admin.Convert.TotalsNew" xml:space="preserve"><value>रूपांतरित सीक्वेंस: {0} · फ़ोटो: {1} · कॉपी नहीं की गईं: {2} · आकार: {3} → {4}</value></data>
<data name="Admin.Dashboard.Activity" xml:space="preserve"><value>हाल की गतिविधि</value></data>
<data name="Admin.Dashboard.AllLogs" xml:space="preserve"><value>सभी लॉग</value></data>
<data name="Admin.Dashboard.AllLogs.Tip" xml:space="preserve"><value>ऑडिट लॉग खोलें</value></data>
@@ -133,6 +196,7 @@
<data name="Admin.Job.Kind.Adopt" xml:space="preserve"><value>अपनाना</value></data>
<data name="Admin.Job.Kind.Backup" xml:space="preserve"><value>बैकअप</value></data>
<data name="Admin.Job.Kind.Cleanup" xml:space="preserve"><value>सफ़ाई</value></data>
<data name="Admin.Job.Kind.Convert" xml:space="preserve"><value>रूपांतरण</value></data>
<data name="Admin.Job.Kind.DeepAnalyse" xml:space="preserve"><value>गहन विश्लेषण</value></data>
<data name="Admin.Job.Kind.Duplicates" xml:space="preserve"><value>डुप्लिकेट</value></data>
<data name="Admin.Job.Kind.EmptyTrash" xml:space="preserve"><value>ट्रैश खाली करना</value></data>
@@ -344,6 +408,7 @@
<data name="Admin.Login.SignIn.Tip" xml:space="preserve"><value>इस सर्वर का प्रबंधन करने के लिए साइन इन करें</value></data>
<data name="Admin.Login.User" xml:space="preserve"><value>उपयोगकर्ता</value></data>
<data name="Admin.Login.User.Tip" xml:space="preserve"><value>इस सर्वर पर आपका उपयोगकर्ता नाम</value></data>
<data name="Admin.Logs.Action.ArchiveConverted" xml:space="preserve"><value>फ़ोटो रूपांतरित की गईं</value></data>
<data name="Admin.Logs.Action.ArchiveReorganized" xml:space="preserve"><value>संग्रह पुनर्व्यवस्थित किया गया</value></data>
<data name="Admin.Logs.Action.ArchiveSettings" xml:space="preserve"><value>संग्रह लेआउट</value></data>
<data name="Admin.Logs.Action.FramesDeleted" xml:space="preserve"><value>फ़ोटो हटाई गईं</value></data>
@@ -793,6 +858,7 @@
<data name="Admin.Theme.Tip" xml:space="preserve"><value>हल्की और गहरी थीम के बीच बदलें</value></data>
<data name="Admin.Trash.Back" xml:space="preserve"><value>लाइब्रेरी</value></data>
<data name="Admin.Trash.Back.Tip" xml:space="preserve"><value>लाइब्रेरी पर वापस जाएँ</value></data>
<data name="Admin.Trash.ConversionDeleted" xml:space="preserve"><value>रूपांतरण हटाया गया</value></data>
<data name="Admin.Trash.DeletedAt" xml:space="preserve"><value>हटाया गया</value></data>
<data name="Admin.Trash.DeletedBy" xml:space="preserve"><value>हटाने वाला</value></data>
<data name="Admin.Trash.Emptied" xml:space="preserve"><value>ट्रैश खाली किया गया।</value></data>
@@ -819,9 +885,12 @@
<data name="Admin.Trash.Photos" xml:space="preserve"><value>फ़ोटो</value></data>
<data name="Admin.Trash.Restore" xml:space="preserve"><value>पुनर्स्थापित करें</value></data>
<data name="Admin.Trash.RestorePhotos.Tip" xml:space="preserve"><value>फ़ोटो को उनके सीक्वेंस में वापस रखें (अगर वह नहीं रहा तो एक नए में); पहले हर फ़ोटो की जाँच उसके SHA-256 से की जाती है</value></data>
<data name="Admin.Trash.RestoreReplaced.Tip" xml:space="preserve"><value>मूल फ़ाइलों को उनके रूपांतरणों की जगह वापस रखें, जब तक वे रूपांतरण अपरिवर्तित हैं (रूपांतरण ट्रैश में जाते हैं), अन्यथा एक नए सीक्वेंस में; पहले हर फ़ाइल की जाँच उसके SHA-256 से की जाती है</value></data>
<data name="Admin.Trash.RestoreSequence.Tip" xml:space="preserve"><value>सीक्वेंस का फ़ोल्डर जैसा है वैसा ही लाइब्रेरी में वापस ले जाएँ (पुरानी जगह भरी हो तो उसके पास); उसकी फ़ोटो की हैश जाँच नहीं होती: वह सत्यापन करता है</value></data>
<data name="Admin.Trash.RestoredNew.one" xml:space="preserve"><value>{0} फ़ोटो एक नए सीक्वेंस में पुनर्स्थापित की गई।</value></data>
<data name="Admin.Trash.RestoredNew.other" xml:space="preserve"><value>{0} फ़ोटो एक नए सीक्वेंस में पुनर्स्थापित की गईं।</value></data>
<data name="Admin.Trash.RestoredOriginals.one" xml:space="preserve"><value>{0} मूल फ़ाइल {1} में वापस आ गई है; उसका रूपांतरण ट्रैश में है।</value></data>
<data name="Admin.Trash.RestoredOriginals.other" xml:space="preserve"><value>{0} मूल फ़ाइलें {1} में वापस आ गई हैं; उनके रूपांतरण ट्रैश में हैं।</value></data>
<data name="Admin.Trash.RestoredPhotos.one" xml:space="preserve"><value>{0} फ़ोटो {1} में वापस आ गई है।</value></data>
<data name="Admin.Trash.RestoredPhotos.other" xml:space="preserve"><value>{0} फ़ोटो {1} में वापस आ गई हैं।</value></data>
<data name="Admin.Trash.RestoredSequence" xml:space="preserve"><value>{0} लाइब्रेरी में वापस आ गया है।</value></data>
+108 -3
View File
@@ -15,8 +15,10 @@
<data name="Archive.Blocked.Applying" xml:space="preserve"><value>बदलाव लागू होने तक प्रतीक्षा करें।</value></data>
<data name="Archive.Blocked.EmptySet" xml:space="preserve"><value>सेट खाली है: चयन या फ़िल्टर बदलें।</value></data>
<data name="Archive.Blocked.NoChanges" xml:space="preserve"><value>कुछ भी नहीं बदलेगा।</value></data>
<data name="Archive.Blocked.NoMode" xml:space="preserve"><value>“प्रतिस्थापित करें” या “नया सीक्वेंस” चुनें।</value></data>
<data name="Archive.Blocked.NoTemplate" xml:space="preserve"><value>कम से कम एक टेम्पलेट चालू करें।</value></data>
<data name="Archive.Blocked.NotOnline" xml:space="preserve"><value>संग्रह ऑनलाइन और लिखने योग्य होना चाहिए।</value></data>
<data name="Archive.Blocked.NothingToConvert" xml:space="preserve"><value>रूपांतरित करने को कुछ नहीं: हर फ़ोटो छोड़ी जाती है या हर सीक्वेंस अवरुद्ध है।</value></data>
<data name="Archive.Blocked.Planning" xml:space="preserve"><value>परीक्षण रन की प्रतीक्षा करें।</value></data>
<data name="Archive.Blocked.Reading" xml:space="preserve"><value>संग्रह पढ़े जाने तक प्रतीक्षा करें।</value></data>
<data name="Archive.Blocked.Searching" xml:space="preserve"><value>एक खोज चल रही है; उसे रद्द करें या प्रतीक्षा करें।</value></data>
@@ -32,6 +34,82 @@
<data name="Archive.Confirm.Remove" xml:space="preserve"><value>पंक्ति निकालें</value></data>
<data name="Archive.Confirm.RemoveHeading" xml:space="preserve"><value>{0} को इंडेक्स से निकालें?</value></data>
<data name="Archive.Confirm.RemoveMessage" xml:space="preserve"><value>इसकी साइडकार फ़ाइल गायब है। केवल इंडेक्स की पंक्ति निकाली जाती है; कोई फ़ाइल नहीं हटाई जाती।</value></data>
<data name="Archive.Convert.AlreadyQueued" xml:space="preserve"><value>इन सीक्वेंस का एक रूपांतरण पहले से प्रतीक्षा में है या चल रहा है; उसे “कार्य” में देखें।</value></data>
<data name="Archive.Convert.Blocked.Busy" xml:space="preserve"><value>इस सीक्वेंस पर एक कार्य चल रहा है; कार्य पूरा होने पर इसे रूपांतरित करें।</value></data>
<data name="Archive.Convert.Blocked.FramesChanged" xml:space="preserve"><value>योजना के बाद सीक्वेंस बदल गया; योजना की फिर से समीक्षा करें।</value></data>
<data name="Archive.Convert.Blocked.Offline" xml:space="preserve"><value>संग्रह ऑफ़लाइन या केवल-पढ़ने योग्य है।</value></data>
<data name="Archive.Convert.Blocked.Unreadable" xml:space="preserve"><value>सीक्वेंस फ़ाइल पढ़ी नहीं जा सकती।</value></data>
<data name="Archive.Convert.Confirm" xml:space="preserve"><value>रूपांतरित करें</value></data>
<data name="Archive.Convert.CopyUnfinished" xml:space="preserve"><value>एक अन्य रूपांतरण ने इस फ़ॉर्मेट में इसकी कॉपी बनाई है और वह पूरा नहीं हुआ है; पहले उसे पूरा करें या उसका पुनः प्रयास करें।</value></data>
<data name="Archive.Convert.Done.one" xml:space="preserve"><value>{0:N0} सीक्वेंस रूपांतरित किया गया</value></data>
<data name="Archive.Convert.Done.other" xml:space="preserve"><value>{0:N0} सीक्वेंस रूपांतरित किए गए</value></data>
<data name="Archive.Convert.Failed.Changed" xml:space="preserve"><value>फ़ोटो अब संग्रहीत कॉपी से मेल नहीं खाती; सीक्वेंस सत्यापित करें।</value></data>
<data name="Archive.Convert.Failed.ColorProfile" xml:space="preserve"><value>इसकी रंग प्रोफ़ाइल इस फ़ॉर्मेट में न रखी जा सकती है, न रूपांतरित की जा सकती है।</value></data>
<data name="Archive.Convert.Failed.Damaged" xml:space="preserve"><value>इसके पिक्सेल में ऐसे मान हैं जो संख्याएँ नहीं हैं: फ़ाइल क्षतिग्रस्त है।</value></data>
<data name="Archive.Convert.Failed.EightBit" xml:space="preserve"><value>यह कंप्यूटर इस RAW को केवल 8 बिट पर डेवलप करता है, जो 16-बिट फ़ाइल के लिए बहुत कम है; JPEG इसे रूपांतरित करता है।</value></data>
<data name="Archive.Convert.Failed.Full" xml:space="preserve"><value>संग्रह की डिस्क भरी हुई है।</value></data>
<data name="Archive.Convert.Failed.NoDecoder" xml:space="preserve"><value>इस कंप्यूटर पर कोई डिकोडर इसे पूर्ण रिज़ॉल्यूशन पर नहीं पढ़ता।</value></data>
<data name="Archive.Convert.Failed.NotVerified" xml:space="preserve"><value>रूपांतरित फ़ाइल वापस पढ़ने पर वैसी नहीं निकली जैसी लिखी गई थी।</value></data>
<data name="Archive.Convert.Failed.Other" xml:space="preserve"><value>रूपांतरित फ़ाइल नहीं बनाई जा सकी।</value></data>
<data name="Archive.Convert.Failed.PreviewOnly" xml:space="preserve"><value>यह कंप्यूटर इसे केवल इसके एम्बेडेड पूर्वावलोकन से पढ़ता है: इसे ऐसे PC पर रूपांतरित करें जो इसे पूर्ण रिज़ॉल्यूशन पर पढ़ता हो।</value></data>
<data name="Archive.Convert.Failed.TooLarge" xml:space="preserve"><value>यह उससे बड़ी है जितना यह फ़ॉर्मेट रख सकता है, Chronos वापस पढ़ सकता है या एक फ़ोटो की मेमोरी रख सकती है।</value></data>
<data name="Archive.Convert.Failed.Unreadable" xml:space="preserve"><value>फ़ोटो डिकोड नहीं की जा सकी।</value></data>
<data name="Archive.Convert.Format" xml:space="preserve"><value>फ़ॉर्मेट</value></data>
<data name="Archive.Convert.Heading.one" xml:space="preserve"><value>{0:N0} सीक्वेंस रूपांतरित करें</value></data>
<data name="Archive.Convert.Heading.other" xml:space="preserve"><value>{0:N0} सीक्वेंस रूपांतरित करें</value></data>
<data name="Archive.Convert.HeadingAll" xml:space="preserve"><value>{0} रूपांतरित करें</value></data>
<data name="Archive.Convert.Mode" xml:space="preserve"><value>मोड</value></data>
<data name="Archive.Convert.NewHeading.one" xml:space="preserve"><value>{0:N0} सीक्वेंस को एक नए सीक्वेंस में रूपांतरित करें?</value></data>
<data name="Archive.Convert.NewHeading.other" xml:space="preserve"><value>{0:N0} सीक्वेंस को नए सीक्वेंस में रूपांतरित करें?</value></data>
<data name="Archive.Convert.NewLeftOut.one" xml:space="preserve"><value>{0:N0} फ़ोटो कॉपी नहीं की जाती: योजना में बताए गए कारण से वह केवल अपने स्रोत में रहती है।</value></data>
<data name="Archive.Convert.NewLeftOut.other" xml:space="preserve"><value>{0:N0} फ़ोटो कॉपी नहीं की जातीं: योजना में बताए गए कारणों से वे केवल अपने स्रोत में रहती हैं।</value></data>
<data name="Archive.Convert.NewMessage" xml:space="preserve"><value>{0} ({1}) का {2} में रूपांतरण हर स्रोत के बगल में एक नए सीक्वेंस में होता है; मूल फ़ाइलें जैसी हैं वैसी रहती हैं।</value></data>
<data name="Archive.Convert.NewSequence" xml:space="preserve"><value>नया सीक्वेंस</value></data>
<data name="Archive.Convert.NotCopied.ColorProfile" xml:space="preserve"><value>जिन फ़ोटो की रंग प्रोफ़ाइल यह फ़ॉर्मेट न रख सकता है, न रूपांतरित कर सकता है, वे नए सीक्वेंस में कॉपी नहीं की जातीं।</value></data>
<data name="Archive.Convert.NotCopied.EightBit" xml:space="preserve"><value>जिन RAW फ़ोटो को यह कंप्यूटर केवल 8 बिट पर डेवलप करता है, वे नए सीक्वेंस में कॉपी नहीं की जातीं; JPEG उन्हें रूपांतरित करता है।</value></data>
<data name="Archive.Convert.NotCopied.Inaccessible" xml:space="preserve"><value>जो फ़ोटो किसी अन्य प्रोग्राम में खुली हैं, या खोली नहीं जा सकतीं, वे नए सीक्वेंस में कॉपी नहीं की जातीं; उनके खाली होने पर फिर से योजना बनाएँ।</value></data>
<data name="Archive.Convert.NotCopied.Missing" xml:space="preserve"><value>गुम फ़ोटो नए सीक्वेंस में कॉपी नहीं की जातीं।</value></data>
<data name="Archive.Convert.NotCopied.NoNativeDecoder" xml:space="preserve"><value>ऐसे फ़ॉर्मेट की फ़ोटो जिसे यह कंप्यूटर पूर्ण रिज़ॉल्यूशन पर नहीं पढ़ सकता, नए सीक्वेंस में कॉपी नहीं की जातीं।</value></data>
<data name="Archive.Convert.NotCopied.PreviewOnly" xml:space="preserve"><value>यहाँ केवल अपने एम्बेडेड पूर्वावलोकन से पढ़ी जाने वाली फ़ोटो नए सीक्वेंस में कॉपी नहीं की जातीं।</value></data>
<data name="Archive.Convert.NotCopied.SameFormat" xml:space="preserve"><value>जो फ़ोटो पहले से इस फ़ॉर्मेट में हैं, वे नए सीक्वेंस में कॉपी नहीं की जातीं।</value></data>
<data name="Archive.Convert.NotCopied.TooLarge" xml:space="preserve"><value>जो फ़ोटो इतनी बड़ी हैं कि यह फ़ॉर्मेट उन्हें रख नहीं सकता या Chronos उन्हें वापस पढ़ नहीं सकता, वे नए सीक्वेंस में कॉपी नहीं की जातीं।</value></data>
<data name="Archive.Convert.NotCopied.Undecodable" xml:space="preserve"><value>अपठनीय फ़ोटो नए सीक्वेंस में कॉपी नहीं की जातीं।</value></data>
<data name="Archive.Convert.NotCopied.Unhashed" xml:space="preserve"><value>कभी सत्यापित न की गई फ़ोटो नए सीक्वेंस में कॉपी नहीं की जातीं; पहले सीक्वेंस सत्यापित करें।</value></data>
<data name="Archive.Convert.NotCopiedPhotos.one" xml:space="preserve"><value>{0:N0} कॉपी नहीं की गई</value></data>
<data name="Archive.Convert.NotCopiedPhotos.other" xml:space="preserve"><value>{0:N0} कॉपी नहीं की गईं</value></data>
<data name="Archive.Convert.NotPlaced" xml:space="preserve"><value>रूपांतरित फ़ोटो अपनी जगह नहीं ले सकीं। {0}</value></data>
<data name="Archive.Convert.PhotoFailed" xml:space="preserve"><value>{0} को रूपांतरित नहीं किया जा सका। {1}</value></data>
<data name="Archive.Convert.PhotoHeld" xml:space="preserve"><value>इसकी एक फ़ोटो किसी अन्य प्रोग्राम में खुली है या खोली नहीं जा सकती; उसके खाली होने पर पुनः प्रयास करें।</value></data>
<data name="Archive.Convert.Quality" xml:space="preserve"><value>गुणवत्ता</value></data>
<data name="Archive.Convert.Replace" xml:space="preserve"><value>प्रतिस्थापित करें</value></data>
<data name="Archive.Convert.ReplaceHeading.one" xml:space="preserve"><value>{0:N0} सीक्वेंस की फ़ोटो प्रतिस्थापित करें?</value></data>
<data name="Archive.Convert.ReplaceHeading.other" xml:space="preserve"><value>{0:N0} सीक्वेंस की फ़ोटो प्रतिस्थापित करें?</value></data>
<data name="Archive.Convert.ReplaceMessage" xml:space="preserve"><value>{2} में रूपांतरण {0} ({1}) को प्रतिस्थापित करता है; मूल फ़ाइलें संग्रह के ट्रैश में जाती हैं, और ट्रैश खाली होने तक पुनर्स्थापित की जा सकती हैं।</value></data>
<data name="Archive.Convert.Sizes" xml:space="preserve"><value>{0} → {1}</value></data>
<data name="Archive.Convert.Skipped.ColorProfile" xml:space="preserve"><value>जिन फ़ोटो की रंग प्रोफ़ाइल यह फ़ॉर्मेट न रख सकता है, न रूपांतरित कर सकता है, वे जैसी हैं वैसी रहती हैं।</value></data>
<data name="Archive.Convert.Skipped.EightBit" xml:space="preserve"><value>जिन RAW फ़ोटो को यह कंप्यूटर केवल 8 बिट पर डेवलप करता है, वे जैसी हैं वैसी रहती हैं; JPEG उन्हें रूपांतरित करता है।</value></data>
<data name="Archive.Convert.Skipped.Inaccessible" xml:space="preserve"><value>जो फ़ोटो किसी अन्य प्रोग्राम में खुली हैं, या खोली नहीं जा सकतीं, वे जैसी हैं वैसी रहती हैं; उनके खाली होने पर फिर से योजना बनाएँ।</value></data>
<data name="Archive.Convert.Skipped.Missing" xml:space="preserve"><value>गुम फ़ोटो जैसी हैं वैसी रहती हैं।</value></data>
<data name="Archive.Convert.Skipped.NoNativeDecoder" xml:space="preserve"><value>ऐसे फ़ॉर्मेट की फ़ोटो जिसे यह कंप्यूटर पूर्ण रिज़ॉल्यूशन पर नहीं पढ़ सकता, जैसी हैं वैसी रहती हैं।</value></data>
<data name="Archive.Convert.Skipped.PreviewOnly" xml:space="preserve"><value>यहाँ केवल अपने एम्बेडेड पूर्वावलोकन से पढ़ी जाने वाली फ़ोटो जैसी हैं वैसी रहती हैं।</value></data>
<data name="Archive.Convert.Skipped.SameFormat" xml:space="preserve"><value>जो फ़ोटो पहले से इस फ़ॉर्मेट में हैं, वे जैसी हैं वैसी रहती हैं।</value></data>
<data name="Archive.Convert.Skipped.TooLarge" xml:space="preserve"><value>जो फ़ोटो इतनी बड़ी हैं कि यह फ़ॉर्मेट उन्हें रख नहीं सकता या Chronos उन्हें वापस पढ़ नहीं सकता, वे जैसी हैं वैसी रहती हैं।</value></data>
<data name="Archive.Convert.Skipped.Undecodable" xml:space="preserve"><value>अपठनीय फ़ोटो जैसी हैं वैसी रहती हैं।</value></data>
<data name="Archive.Convert.Skipped.Unhashed" xml:space="preserve"><value>कभी सत्यापित न की गई फ़ोटो जैसी हैं वैसी रहती हैं; पहले सीक्वेंस सत्यापित करें।</value></data>
<data name="Archive.Convert.SkippedPhotos.one" xml:space="preserve"><value>{0:N0} छोड़ी गई</value></data>
<data name="Archive.Convert.SkippedPhotos.other" xml:space="preserve"><value>{0:N0} छोड़ी गईं</value></data>
<data name="Archive.Convert.Space" xml:space="preserve"><value>आवश्यक {0}, खाली {1}</value></data>
<data name="Archive.Convert.SpaceShort" xml:space="preserve"><value>आवश्यक {0}, केवल {1} खाली: पहले कुछ स्थान खाली करें।</value></data>
<data name="Archive.Convert.SpaceUnknown" xml:space="preserve"><value>आवश्यक {0}; खाली स्थान मापा नहीं जा सकता।</value></data>
<data name="Archive.Convert.Target.LinearDng" xml:space="preserve"><value>लीनियर DNG</value></data>
<data name="Archive.Convert.Target.Tiff16" xml:space="preserve"><value>TIFF 16-बिट</value></data>
<data name="Archive.Convert.UndoFailed" xml:space="preserve"><value>मूल फ़ाइलें वापस नहीं आ सकीं</value></data>
<data name="Archive.Convert.UndoNothing" xml:space="preserve"><value>प्रतिस्थापित मूल फ़ाइलें अब ट्रैश में नहीं हैं।</value></data>
<data name="Archive.Convert.Undone.one" xml:space="preserve"><value>{0:N0} सीक्वेंस में मूल फ़ाइलें वापस आ गईं</value></data>
<data name="Archive.Convert.Undone.other" xml:space="preserve"><value>{0:N0} सीक्वेंस में मूल फ़ाइलें वापस आ गईं</value></data>
<data name="Archive.Convert.UndoneNew.one" xml:space="preserve"><value>{0:N0} सीक्वेंस इस बीच बदल गया था: उसकी मूल फ़ाइलें एक नए सीक्वेंस के रूप में वापस आईं।</value></data>
<data name="Archive.Convert.UndoneNew.other" xml:space="preserve"><value>{0:N0} सीक्वेंस इस बीच बदल गए थे: उनकी मूल फ़ाइलें नए सीक्वेंस के रूप में वापस आईं।</value></data>
<data name="Archive.Convert.Unstaged" xml:space="preserve"><value>{0} का रूपांतरण अब तैयार की गई फ़ाइलों में नहीं है; पुनः प्रयास इसे फिर से रूपांतरित करता है।</value></data>
<data name="Archive.Copy.Title" xml:space="preserve"><value>संग्रह में कॉपी करने के लिए फ़ोल्डर</value></data>
<data name="Archive.Delete.Action" xml:space="preserve"><value>ट्रैश में ले जाएँ</value></data>
<data name="Archive.Delete.Blocked" xml:space="preserve"><value>नहीं ले जाया गया: {0} · {1}</value></data>
@@ -75,6 +153,9 @@
<data name="Archive.Duplicates.Title" xml:space="preserve"><value>डुप्लिकेट</value></data>
<data name="Archive.Empty" xml:space="preserve"><value>अभी कोई संग्रह नहीं</value></data>
<data name="Archive.Error.Busy" xml:space="preserve"><value>कोई अन्य Chronos ({0}) यहाँ लिख रहा है। थोड़ी देर बाद फिर से प्रयास करें।</value></data>
<data name="Archive.Error.ConvertKept.one" xml:space="preserve"><value>{0:N0} सीक्वेंस योजना के अनुसार रूपांतरित नहीं हुआ; कार्य लॉग बताता है कि क्यों।</value></data>
<data name="Archive.Error.ConvertKept.other" xml:space="preserve"><value>{0:N0} सीक्वेंस योजना के अनुसार रूपांतरित नहीं हुए; कार्य लॉग बताता है कि क्यों।</value></data>
<data name="Archive.Error.ConvertSpace" xml:space="preserve"><value>रूपांतरण के लिए संग्रह के वॉल्यूम पर {0} खाली स्थान चाहिए, और {1} खाली है।</value></data>
<data name="Archive.Error.CopyMismatch" xml:space="preserve"><value>{0} की कॉपी मूल से मेल नहीं खाती।</value></data>
<data name="Archive.Error.DuplicateLost" xml:space="preserve"><value>{0} को सीक्वेंस में नहीं जोड़ा जा सका।</value></data>
<data name="Archive.Error.InLibrary" xml:space="preserve"><value>{0} पहले से लाइब्रेरी में है।</value></data>
@@ -92,8 +173,8 @@
<data name="Archive.Error.SourceGone" xml:space="preserve"><value>कार्ड या फ़ोल्डर {0} अब उपलब्ध नहीं है।</value></data>
<data name="Archive.Error.StalePlan" xml:space="preserve"><value>यह योजना बनने के बाद संग्रह बदल गया।</value></data>
<data name="Archive.Error.TrashChanged" xml:space="preserve"><value>जाँच के बाद ट्रैश बदल गया; कुछ भी नहीं मिटाया गया।</value></data>
<data name="Archive.Error.TrashKept.one" xml:space="preserve"><value>{0:N0} ट्रैश प्रविष्टि रखी गई: वह बदल गई, या कोई प्रतिस्थापन अब मेल नहीं खाता।</value></data>
<data name="Archive.Error.TrashKept.other" xml:space="preserve"><value>{0:N0} ट्रैश प्रविष्टियाँ रखी गईं: वे बदल गईं, या कोई प्रतिस्थापन अब मेल नहीं खाता।</value></data>
<data name="Archive.Error.TrashKept.one" xml:space="preserve"><value>{0:N0} ट्रैश प्रविष्टि ट्रैश में ही रही; कार्य लॉग बताता है कि क्यों।</value></data>
<data name="Archive.Error.TrashKept.other" xml:space="preserve"><value>{0:N0} ट्रैश प्रविष्टियाँ ट्रैश में ही रहीं; कार्य लॉग बताता है कि क्यों।</value></data>
<data name="Archive.Error.TrashMismatch" xml:space="preserve"><value>इस ट्रैश प्रविष्टि की कोई भी फ़ाइल अब उसके रिकॉर्ड से मेल नहीं खाती; यह ट्रैश में रहती है।</value></data>
<data name="Archive.Failed.Access" xml:space="preserve"><value>Chronos को संग्रह तक पहुँच नहीं दी गई।</value></data>
<data name="Archive.Failed.Files" xml:space="preserve"><value>संग्रह की एक फ़ाइल पढ़ी या लिखी नहीं जा सकी।</value></data>
@@ -132,6 +213,15 @@
<data name="Archive.Log.AuditKept" xml:space="preserve"><value>ऑडिट लॉग पूरा रखा गया</value></data>
<data name="Archive.Log.AuditPurged" xml:space="preserve"><value>निकाली गई ऑडिट प्रविष्टियाँ: {0}</value></data>
<data name="Archive.Log.BackupDone" xml:space="preserve"><value>इंडेक्स {0} में कॉपी किया गया ({1}); रखी गई कॉपियाँ: {2}</value></data>
<data name="Archive.Log.ConvertBlocked" xml:space="preserve"><value>जैसा था वैसा छोड़ा गया, व्यस्त या अपठनीय: {0}</value></data>
<data name="Archive.Log.ConvertChanged" xml:space="preserve"><value>जैसा था वैसा छोड़ा गया, योजना के बाद बदल गया: {0}। पुनः प्रयास इसे जैसा है वैसा ही छोड़ता है: नई योजना से इसे फिर से रूपांतरित करें।</value></data>
<data name="Archive.Log.ConvertDone" xml:space="preserve"><value>रूपांतरित सीक्वेंस: {0}, नए सीक्वेंस: {1}, फ़ोटो: {2}</value></data>
<data name="Archive.Log.ConvertFailed" xml:space="preserve"><value>जैसा था वैसा छोड़ा गया: {0}। {1}</value></data>
<data name="Archive.Log.ConvertLeftOut" xml:space="preserve"><value>{0}: रूपांतरित न की गई फ़ोटो, जो केवल स्रोत में रहीं: {1}</value></data>
<data name="Archive.Log.ConvertNothing" xml:space="preserve"><value>रूपांतरित करने को कुछ नहीं: {0}</value></data>
<data name="Archive.Log.ConvertSuperseded" xml:space="preserve"><value>{0}: इस रूपांतरण की पुष्टि के बाद एक अन्य रूपांतरण ने इस फ़ॉर्मेट में अपनी कॉपी बना ली; दूसरी कॉपी नहीं बनाई जाती।</value></data>
<data name="Archive.Log.Converted" xml:space="preserve"><value>{0}: अपने रूपांतरण से प्रतिस्थापित फ़ोटो: {1}</value></data>
<data name="Archive.Log.ConvertedNew" xml:space="preserve"><value>{0}: नए सीक्वेंस में रूपांतरित फ़ोटो: {1}</value></data>
<data name="Archive.Log.DryRun" xml:space="preserve"><value>परीक्षण रन: कुछ नहीं बदला गया।</value></data>
<data name="Archive.Log.DuplicateGroup" xml:space="preserve"><value>{0} की अतिरिक्त कॉपियाँ: {1}</value></data>
<data name="Archive.Log.DuplicatesDone" xml:space="preserve"><value>डुप्लिकेट समूह: {0}, अतिरिक्त कॉपियाँ: {1}</value></data>
@@ -166,9 +256,22 @@
<data name="Archive.Log.SequenceMissing" xml:space="preserve"><value>सीक्वेंस नहीं मिला: {0}</value></data>
<data name="Archive.Log.StepFailed" xml:space="preserve"><value>सफ़ाई चरण {0} विफल: {1}</value></data>
<data name="Archive.Log.StepUnknown" xml:space="preserve"><value>सफ़ाई चरण यहाँ अज्ञात: {0}</value></data>
<data name="Archive.Log.SyncChanged" xml:space="preserve"><value>{0}: संग्रहीत होने के बाद बदल गई, अपलोड नहीं की गई</value></data>
<data name="Archive.Log.SyncDeletedHere" xml:space="preserve"><value>{0}: इस PC पर हटाई गई, डाउनलोड नहीं की गई</value></data>
<data name="Archive.Log.SyncDeletedThere" xml:space="preserve"><value>{0}: सर्वर पर हटाई गई, अपलोड नहीं की गई</value></data>
<data name="Archive.Log.SyncFrameChanged" xml:space="preserve"><value>{0}: यहाँ इसका फ़्रेम इस बीच बदल गया, डाउनलोड नहीं की गई</value></data>
<data name="Archive.Log.SyncMissing" xml:space="preserve"><value>{0}: गुम, अपलोड नहीं की गई</value></data>
<data name="Archive.Log.SyncNoPreview.one" xml:space="preserve"><value>{0:N0} फ़्रेम का सर्वर पर न प्रॉक्सी है, न थंबनेल</value></data>
<data name="Archive.Log.SyncNoPreview.other" xml:space="preserve"><value>{0:N0} फ़्रेम के सर्वर पर न प्रॉक्सी हैं, न थंबनेल</value></data>
<data name="Archive.Log.TrashEmptied" xml:space="preserve"><value>मिटाई गई प्रविष्टियाँ: {0}, आकार: {1}</value></data>
<data name="Archive.Log.TrashEntry" xml:space="preserve"><value>{0} से ट्रैश में: {1} ({2})</value></data>
<data name="Archive.Log.TrashKept" xml:space="preserve"><value>ट्रैश में रखा गया: {0}</value></data>
<data name="Archive.Log.TrashKept" xml:space="preserve"><value>ट्रैश में रखा गया, योजना के बाद बदल गया: {0}</value></data>
<data name="Archive.Log.TrashKeptBusy" xml:space="preserve"><value>ट्रैश में रखा गया, इसका सीक्वेंस व्यस्त था: {0}</value></data>
<data name="Archive.Log.TrashKeptMismatch" xml:space="preserve"><value>ट्रैश में रखा गया, इसकी मूल फ़ाइलों का एक रूपांतरण अब मेल नहीं खाता: {0}</value></data>
<data name="Archive.Log.TrashKeptStaleIndex" xml:space="preserve"><value>ट्रैश में रखा गया, इंडेक्स इसके सीक्वेंस को सूचीबद्ध करता है, जो अब संग्रह में नहीं है; इंडेक्स फिर से बनाएँ: {0}</value></data>
<data name="Archive.Log.TrashKeptUnhashed" xml:space="preserve"><value>ट्रैश में रखा गया, इसके सीक्वेंस की एक फ़ोटो कभी सत्यापित नहीं की गई; सीक्वेंस सत्यापित करें: {0}</value></data>
<data name="Archive.Log.TrashKeptUnknown" xml:space="preserve"><value>ट्रैश में रखा गया, संग्रह यह नहीं दिखाता कि इसकी मूल फ़ाइलों के रूपांतरण का क्या हुआ; उन्हें रखने के लिए इसे पुनर्स्थापित करें: {0}</value></data>
<data name="Archive.Log.TrashKeptUnreadable" xml:space="preserve"><value>ट्रैश में रखा गया, उस फ़ोल्डर की साइडकार फ़ाइल गायब है या पढ़ी नहीं जा सकती जिसमें इसका सीक्वेंस हो सकता है; संग्रह स्कैन करें: {0}</value></data>
<data name="Archive.Log.TrashOffline" xml:space="preserve"><value>ट्रैश की जाँच नहीं हुई: संग्रह तक पहुँचा नहीं जा सकता</value></data>
<data name="Archive.Log.TrashReport" xml:space="preserve"><value>पुरानी ट्रैश प्रविष्टियाँ: {0}, आकार: {1}; कुछ नहीं हटाया गया</value></data>
<data name="Archive.Log.VerifyDone" xml:space="preserve"><value>जाँची गई फ़ोटो: {0}, सही-सलामत: {1}, हैश की गईं: {2}, समस्या वाली: {3}</value></data>
@@ -249,6 +352,7 @@
<data name="Archive.Set.All.other" xml:space="preserve"><value>{0:N0} सीक्वेंस · सभी</value></data>
<data name="Archive.Set.Analyse" xml:space="preserve"><value>विश्लेषण करें</value></data>
<data name="Archive.Set.ClearFilter" xml:space="preserve"><value>फ़िल्टर साफ़ करें</value></data>
<data name="Archive.Set.Convert" xml:space="preserve"><value>रूपांतरित करें…</value></data>
<data name="Archive.Set.Delete" xml:space="preserve"><value>हटाएँ…</value></data>
<data name="Archive.Set.Export" xml:space="preserve"><value>CSV निर्यात करें</value></data>
<data name="Archive.Set.Filter" xml:space="preserve"><value>सेट का फ़िल्टर</value></data>
@@ -278,6 +382,7 @@
<data name="Archive.Toolbar.Scan" xml:space="preserve"><value>स्कैन करें</value></data>
<data name="Archive.Toolbar.Verify" xml:space="preserve"><value>सत्यापित करें</value></data>
<data name="Archive.Trash.Checking" xml:space="preserve"><value>ट्रैश की जाँच हो रही है…</value></data>
<data name="Archive.Trash.ConversionDeleted" xml:space="preserve"><value>रूपांतरण हटाया गया</value></data>
<data name="Archive.Trash.Deleted" xml:space="preserve"><value>{0} को हटाया गया</value></data>
<data name="Archive.Trash.Empty" xml:space="preserve"><value>ट्रैश खाली है</value></data>
<data name="Archive.Trash.EmptyAction" xml:space="preserve"><value>खाली करें…</value></data>
+1
View File
@@ -69,6 +69,7 @@
<data name="Jobs.Kind.Adopt" xml:space="preserve"><value>फ़ोल्डर अपनाना</value></data>
<data name="Jobs.Kind.Backup" xml:space="preserve"><value>इंडेक्स बैकअप</value></data>
<data name="Jobs.Kind.Cleanup" xml:space="preserve"><value>सफ़ाई</value></data>
<data name="Jobs.Kind.Convert" xml:space="preserve"><value>रूपांतरण</value></data>
<data name="Jobs.Kind.DeepAnalyse" xml:space="preserve"><value>गहन विश्लेषण</value></data>
<data name="Jobs.Kind.Download" xml:space="preserve"><value>डाउनलोड</value></data>
<data name="Jobs.Kind.Duplicates" xml:space="preserve"><value>डुप्लिकेट</value></data>
+2
View File
@@ -6,6 +6,7 @@
<resheader name="writer"><value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader>
<data name="Library.Action.Analyse" xml:space="preserve"><value>विश्लेषण करें</value></data>
<data name="Library.Action.ClearSelection" xml:space="preserve"><value>चयन साफ़ करें</value></data>
<data name="Library.Action.Convert" xml:space="preserve"><value>रूपांतरित करें…</value></data>
<data name="Library.Action.Delete" xml:space="preserve"><value>हटाएँ…</value></data>
<data name="Library.Action.Download" xml:space="preserve"><value>डाउनलोड करें</value></data>
<data name="Library.Action.ExportList" xml:space="preserve"><value>सूची निर्यात करें</value></data>
@@ -32,6 +33,7 @@
<data name="Library.Blocked.NothingToDownload" xml:space="preserve"><value>चयनित सीक्वेंस के लिए सर्वर से लाने को कुछ नहीं है।</value></data>
<data name="Library.Blocked.NothingToUpload" xml:space="preserve"><value>चयनित सीक्वेंस में जो कुछ है, वह सर्वर पर पहले से है।</value></data>
<data name="Library.Blocked.OneArchive" xml:space="preserve"><value>पुनर्व्यवस्थापन एक बार में एक ही संग्रह के सीक्वेंस पर काम करता है।</value></data>
<data name="Library.Blocked.OneArchiveConvert" xml:space="preserve"><value>रूपांतरण एक बार में एक ही संग्रह के सीक्वेंस पर काम करता है।</value></data>
<data name="Library.Blocked.ServerOnly" xml:space="preserve"><value>केवल इस PC पर मौजूद सीक्वेंस के लिए; चयन सर्वर पर है।</value></data>
<data name="Library.Blocked.Transferring" xml:space="preserve"><value>इस सीक्वेंस का एक ट्रांसफ़र पहले से चल रहा है।</value></data>
<data name="Library.ClearFilters" xml:space="preserve"><value>फ़िल्टर साफ़ करें</value></data>
+4
View File
@@ -21,6 +21,8 @@
<data name="Server.Conflict.TakeServer.Message" xml:space="preserve"><value>{0} की इस PC वाली सेटिंग्स को सर्वर कॉपी से बदल दिया जाएगा।</value></data>
<data name="Server.Conflict.TakeServer.Title" xml:space="preserve"><value>सर्वर की सेटिंग्स लें?</value></data>
<data name="Server.Connect" xml:space="preserve"><value>कनेक्ट करें</value></data>
<data name="Server.Convert.OnPc" xml:space="preserve"><value>इन फ़ोटो को किसी PC पर रूपांतरित करें: सर्वर इन्हें पूर्ण रिज़ॉल्यूशन पर नहीं पढ़ सकता।</value></data>
<data name="Server.Convert.OnPcNew" xml:space="preserve"><value>नए सीक्वेंस में कॉपी नहीं की जातीं: सर्वर इन फ़ोटो को पूर्ण रिज़ॉल्यूशन पर नहीं पढ़ सकता; इन्हें किसी PC पर रूपांतरित करें।</value></data>
<data name="Server.Disconnect" xml:space="preserve"><value>डिस्कनेक्ट करें</value></data>
<data name="Server.Empty" xml:space="preserve"><value>किसी सर्वर से कनेक्ट नहीं है</value></data>
<data name="Server.Error.AccountLocked" xml:space="preserve"><value>बहुत अधिक विफल साइन-इन; खाता कुछ समय के लिए लॉक है।</value></data>
@@ -71,7 +73,9 @@
<data name="Server.Error.MethodNotAllowed" xml:space="preserve"><value>यहाँ इस विधि की अनुमति नहीं है।</value></data>
<data name="Server.Error.NestedTarget" xml:space="preserve"><value>एक नया फ़ोल्डर किसी दूसरे सीक्वेंस के फ़ोल्डर के अंदर होगा।</value></data>
<data name="Server.Error.NotChronos" xml:space="preserve"><value>यह पता किसी Chronos Server का नहीं है।</value></data>
<data name="Server.Error.NotEnoughSpace" xml:space="preserve"><value>संग्रह के वॉल्यूम पर रूपांतरण के लिए आवश्यक स्थान नहीं है।</value></data>
<data name="Server.Error.NotFound" xml:space="preserve"><value>नहीं मिला।</value></data>
<data name="Server.Error.NothingToConvert" xml:space="preserve"><value>योजना कुछ भी रूपांतरित नहीं करती: हर फ़ोटो छोड़ी जाती है या हर सीक्वेंस अवरुद्ध है।</value></data>
<data name="Server.Error.PasswordChangeRequired" xml:space="preserve"><value>पहले अपना पासवर्ड बदलें।</value></data>
<data name="Server.Error.PhotoRemoved" xml:space="preserve"><value>अपलोड होते समय फ़ोटो सीक्वेंस से हटा दी गई, इसलिए उसे जोड़ा नहीं गया।</value></data>
<data name="Server.Error.PhotoUnreadable" xml:space="preserve"><value>{0} को पढ़ा नहीं जा सकता, और उसके हैश के बिना अन्य कॉपियों को पता नहीं चलेगा कि उसे हटाया गया था; उसका उपयोग कर रहा प्रोग्राम बंद करें या उसकी अनुमतियाँ जाँचें, फिर से प्रयास करें।</value></data>
+19 -1
View File
@@ -27,6 +27,21 @@
<data name="Tooltips.Archive.ClearFilter" xml:space="preserve"><value>चयन का हर सीक्वेंस फिर से दिखाएँ</value></data>
<data name="Tooltips.Archive.CloseDialog" xml:space="preserve"><value>कुछ भी बदले बिना बंद करें · Esc</value></data>
<data name="Tooltips.Archive.Collapse" xml:space="preserve"><value>इस वर्ष के सीक्वेंस छिपाएँ</value></data>
<data name="Tooltips.Archive.ConvertApplyNew" xml:space="preserve"><value>पुष्टि करें, फिर एक कार्य कतार में रखें जो कॉपियों को नए सीक्वेंस में रूपांतरित करता है · उसे “कार्य” में विराम दें और फिर से शुरू करें</value></data>
<data name="Tooltips.Archive.ConvertApplyReplace" xml:space="preserve"><value>पुष्टि के लिए फ़ोटो की संख्या टाइप करें, फिर एक कार्य कतार में रखें जो उन्हें उनके रूपांतरण से प्रतिस्थापित करता है · उसे “कार्य” में विराम दें और फिर से शुरू करें</value></data>
<data name="Tooltips.Archive.ConvertBack" xml:space="preserve"><value>योजना पर वापस जाएँ; कुछ भी रूपांतरित नहीं होता</value></data>
<data name="Tooltips.Archive.ConvertDng" xml:space="preserve"><value>लीनियर DNG, 16-बिट और दोषरहित · हर RAW एडिटर इसे पढ़ता है; संग्रह के लिए उपयुक्त विकल्प</value></data>
<data name="Tooltips.Archive.ConvertJpeg" xml:space="preserve"><value>नीचे दी गई गुणवत्ता पर 8-बिट JPEG · सबसे छोटी फ़ाइलें; कुछ विवरण खो जाता है</value></data>
<data name="Tooltips.Archive.ConvertModeNew" xml:space="preserve"><value>रूपांतरित कॉपियाँ हर सीक्वेंस के बगल में एक नए सीक्वेंस में जाती हैं; मूल फ़ाइलें जैसी हैं वैसी रहती हैं</value></data>
<data name="Tooltips.Archive.ConvertModeReplace" xml:space="preserve"><value>रूपांतरित फ़ाइलें अपने सीक्वेंस में फ़ोटो की जगह ले लेती हैं; मूल फ़ाइलें संग्रह के ट्रैश में जाती हैं, और ट्रैश खाली होने तक पुनर्स्थापित की जा सकती हैं</value></data>
<data name="Tooltips.Archive.ConvertNew" xml:space="preserve"><value>वह कार्य कतार में रखें जो फ़ोटो को नए सीक्वेंस में रूपांतरित करता है और हर रूपांतरण सत्यापित करता है; मूल फ़ाइलों को छुआ नहीं जाता</value></data>
<data name="Tooltips.Archive.ConvertPlan" xml:space="preserve"><value>वे सीक्वेंस जिनकी फ़ोटो प्रतिस्थापित की जाती हैं</value></data>
<data name="Tooltips.Archive.ConvertPlanNew" xml:space="preserve"><value>नए सीक्वेंस में कॉपी किए जाने वाले सीक्वेंस, और वे फ़ोटो जिन्हें हर एक छोड़ देता है</value></data>
<data name="Tooltips.Archive.ConvertQuality" xml:space="preserve"><value>1 से 100 तक JPEG गुणवत्ता · 95 बारीक विवरण बनाए रखता है; कम मान छोटी फ़ाइलें बनाता है</value></data>
<data name="Tooltips.Archive.ConvertReplace.one" xml:space="preserve"><value>{0:N0} फ़ोटो को उसके रूपांतरण से प्रतिस्थापित करें; पहले ऊपर दी गई संख्या टाइप करें</value></data>
<data name="Tooltips.Archive.ConvertReplace.other" xml:space="preserve"><value>{0:N0} फ़ोटो को उनके रूपांतरण से प्रतिस्थापित करें; पहले ऊपर दी गई संख्या टाइप करें</value></data>
<data name="Tooltips.Archive.ConvertTiff" xml:space="preserve"><value>दोषरहित रूप से संपीड़ित 16-बिट TIFF · बड़ी फ़ाइलें जिन्हें हर एडिटर खोलता है</value></data>
<data name="Tooltips.Archive.ConvertUndo" xml:space="preserve"><value>मूल फ़ाइलों को ट्रैश से उनके रूपांतरणों की जगह वापस रखें</value></data>
<data name="Tooltips.Archive.DeleteAction.one" xml:space="preserve"><value>{0:N0} सीक्वेंस को ट्रैश में ले जाएँ; पहले ऊपर संख्या टाइप करें</value></data>
<data name="Tooltips.Archive.DeleteAction.other" xml:space="preserve"><value>{0:N0} सीक्वेंस को ट्रैश में ले जाएँ; पहले ऊपर संख्या टाइप करें</value></data>
<data name="Tooltips.Archive.DeleteKeep" xml:space="preserve"><value>कुछ न बदलें</value></data>
@@ -82,6 +97,7 @@
<data name="Tooltips.Archive.Scan" xml:space="preserve"><value>इंक्रीमेंटल स्कैन: संशोधन समय और आकार के आधार पर नई, बदली और हटाई गई फ़ाइलें</value></data>
<data name="Tooltips.Archive.Set" xml:space="preserve"><value>चयनित वर्ष और सीक्वेंस (कुछ न चुना हो तो सभी), कैमरा, स्थिति या टैग से सीमित</value></data>
<data name="Tooltips.Archive.SetAnalyse" xml:space="preserve"><value>सेट के हर सीक्वेंस पर गहन विश्लेषण चलाएँ</value></data>
<data name="Tooltips.Archive.SetConvert" xml:space="preserve"><value>सेट की फ़ोटो को JPEG, TIFF या DNG में रूपांतरित करें · पहले परीक्षण रन, फिर एक कार्य</value></data>
<data name="Tooltips.Archive.SetDelete" xml:space="preserve"><value>सेट को संग्रह के ट्रैश में ले जाएँ · परीक्षण रन दिखाता है, फिर पुष्टि के लिए टाइप करने को कहता है</value></data>
<data name="Tooltips.Archive.SetExport" xml:space="preserve"><value>सेट को CSV के रूप में निर्यात करें: प्रति सीक्वेंस एक पंक्ति</value></data>
<data name="Tooltips.Archive.SetProxies" xml:space="preserve"><value>प्रॉक्सी बनाएँ या रीफ़्रेश करें</value></data>
@@ -96,7 +112,7 @@
<data name="Tooltips.Archive.TitleTemplate" xml:space="preserve"><value>शीर्षक टेम्पलेट; शीर्षक टोकन वर्तमान शीर्षक है · टाइप करते ही जाँचा जाता है</value></data>
<data name="Tooltips.Archive.Trash" xml:space="preserve"><value>इस संग्रह से हटाए गए सीक्वेंस और फ़ोटो, जिनमें से हर एक पुनर्स्थापित किया जा सकता है</value></data>
<data name="Tooltips.Archive.TrashEmpty" xml:space="preserve"><value>इस ट्रैश की प्रविष्टियाँ हमेशा के लिए मिटाएँ, उनमें क्या है इसकी जाँच और टाइप की गई पुष्टि के बाद</value></data>
<data name="Tooltips.Archive.TrashEmptyPlan" xml:space="preserve"><value>संग्रह से हमेशा के लिए क्या मिटाया जाता है</value></data>
<data name="Tooltips.Archive.TrashEmptyPlan" xml:space="preserve"><value>संग्रह से हमेशा के लिए क्या मिटाया जाता है; जिन मूल फ़ाइलों का रूपांतरण हटा दिया गया है, वे अपनी फ़ोटो की अंतिम कॉपी हो सकती हैं</value></data>
<data name="Tooltips.Archive.TrashErase.one" xml:space="preserve"><value>{0:N0} प्रविष्टि हमेशा के लिए मिटाएँ; पहले ऊपर दी गई संख्या टाइप करें</value></data>
<data name="Tooltips.Archive.TrashErase.other" xml:space="preserve"><value>{0:N0} प्रविष्टियाँ हमेशा के लिए मिटाएँ; पहले ऊपर दी गई संख्या टाइप करें</value></data>
<data name="Tooltips.Archive.TrashRestore" xml:space="preserve"><value>इस प्रविष्टि को वापस ले जाएँ: सीक्वेंस को उसके फ़ोल्डर और लाइब्रेरी में, फ़ोटो को हैश जाँच के बाद उनके सीक्वेंस में</value></data>
@@ -468,6 +484,8 @@
<data name="Tooltips.Library.List" xml:space="preserve"><value>क्रमबद्ध किए जा सकने वाले कॉलम वाली तालिका</value></data>
<data name="Tooltips.Library.Mass.Analyse.one" xml:space="preserve"><value>इस PC पर {0:N0} सीक्वेंस का गहन विश्लेषण · एक कार्य के रूप में चलता है</value></data>
<data name="Tooltips.Library.Mass.Analyse.other" xml:space="preserve"><value>इस PC पर {0:N0} सीक्वेंस का गहन विश्लेषण · एक कार्य के रूप में चलता है</value></data>
<data name="Tooltips.Library.Mass.Convert.one" xml:space="preserve"><value>{0:N0} सीक्वेंस की फ़ोटो को JPEG, TIFF या DNG में रूपांतरित करें · पहले परीक्षण रन, फिर एक कार्य</value></data>
<data name="Tooltips.Library.Mass.Convert.other" xml:space="preserve"><value>उनके संग्रह के {0:N0} सीक्वेंस की फ़ोटो को JPEG, TIFF या DNG में रूपांतरित करें · पहले परीक्षण रन, फिर एक कार्य</value></data>
<data name="Tooltips.Library.Mass.Delete.one" xml:space="preserve"><value>{0:N0} सीक्वेंस को उसके संग्रह के ट्रैश में ले जाएँ · परीक्षण रन दिखाता है, फिर पुष्टि के लिए टाइप करने को कहता है</value></data>
<data name="Tooltips.Library.Mass.Delete.other" xml:space="preserve"><value>{0:N0} सीक्वेंस को उनके संग्रह के ट्रैश में ले जाएँ · परीक्षण रन दिखाता है, फिर पुष्टि के लिए टाइप करने को कहता है</value></data>
<data name="Tooltips.Library.Mass.Download.one" xml:space="preserve"><value>{0:N0} सीक्वेंस का जो हिस्सा यहाँ नहीं है (मूल फ़ाइलें या रेंडर), उसे सर्वर से लाएँ · ट्रांसफ़र कार्य के रूप में चलता है</value></data>
+75
View File
@@ -9,6 +9,7 @@
<data name="Admin.About.Title" xml:space="preserve"><value>Chronos Server</value></data>
<data name="Admin.About.Uptime" xml:space="preserve"><value>Vrijeme rada</value></data>
<data name="Admin.About.Version" xml:space="preserve"><value>Verzija</value></data>
<data name="Admin.Activity.ArchiveConverted" xml:space="preserve"><value>Korisnik {0} stavio je pretvorbu u red čekanja · {1}</value></data>
<data name="Admin.Activity.ArchiveReorganized" xml:space="preserve"><value>Korisnik {0} reorganizirao je arhivu · {1}</value></data>
<data name="Admin.Activity.ArchiveSettings" xml:space="preserve"><value>Korisnik {0} promijenio je strukturu arhive</value></data>
<data name="Admin.Activity.FramesDeleted" xml:space="preserve"><value>Korisnik {0} izbrisao je {1}</value></data>
@@ -84,6 +85,73 @@
<data name="Admin.Common.TypeToConfirm.Tip" xml:space="preserve"><value>Za potvrdu upišite ime točno kako je prikazano</value></data>
<data name="Admin.Common.TypeWord.Tip" xml:space="preserve"><value>Upišite riječ točno kako je prikazana; velika i mala slova nisu bitna</value></data>
<data name="Admin.Common.TypeWordFirst.Tip" xml:space="preserve"><value>Najprije upišite gore navedenu riječ</value></data>
<data name="Admin.Convert.Action" xml:space="preserve"><value>Pretvori…</value></data>
<data name="Admin.Convert.Action.Tip" xml:space="preserve"><value>Pretvara fotografije odabranih sekvenci u JPEG, TIFF-16 ili linearni DNG; pretpregled najprije prikazuje svaku sekvencu</value></data>
<data name="Admin.Convert.Apply" xml:space="preserve"><value>Pretvori…</value></data>
<data name="Admin.Convert.Apply.Tip" xml:space="preserve"><value>Pretvara kako je prikazano u pretpregledu; najprije traži potvrdu</value></data>
<data name="Admin.Convert.Cancel.Tip" xml:space="preserve"><value>Zatvara bez ikakve pretvorbe</value></data>
<data name="Admin.Convert.ChooseMode" xml:space="preserve"><value>Za pretvorbu odaberite „Zamijeni” ili „Nova sekvenca”.</value></data>
<data name="Admin.Convert.ChooseMode.Tip" xml:space="preserve"><value>Najprije odaberite „Zamijeni” ili „Nova sekvenca”</value></data>
<data name="Admin.Convert.Column.Converted" xml:space="preserve"><value>Pretvoreno</value></data>
<data name="Admin.Convert.Column.NotCopied" xml:space="preserve"><value>Nije kopirano</value></data>
<data name="Admin.Convert.Column.Sequence" xml:space="preserve"><value>Sekvenca</value></data>
<data name="Admin.Convert.Column.Size" xml:space="preserve"><value>Veličina</value></data>
<data name="Admin.Convert.Column.Unchanged" xml:space="preserve"><value>Nepromijenjeno</value></data>
<data name="Admin.Convert.Confirm.New" xml:space="preserve"><value>Pretvori</value></data>
<data name="Admin.Convert.Confirm.New.Tip" xml:space="preserve"><value>Stavlja u red čekanja zadatak koji pretvara fotografije u nove sekvence i provjerava svaku pretvorbu; izvornici ostaju netaknuti</value></data>
<data name="Admin.Convert.Confirm.Replace" xml:space="preserve"><value>Zamijeni</value></data>
<data name="Admin.Convert.Confirm.Replace.Tip" xml:space="preserve"><value>Stavlja u red čekanja zadatak koji pretvara fotografije, provjerava svaku pretvorbu i premješta izvornike u koš za smeće</value></data>
<data name="Admin.Convert.ConfirmNew.few" xml:space="preserve"><value>{0} fotografije pretvaraju se u kopije u novoj sekvenci pokraj svake izvorne; izvornici ostaju kakvi jesu.</value></data>
<data name="Admin.Convert.ConfirmNew.one" xml:space="preserve"><value>{0} fotografija pretvara se u kopiju u novoj sekvenci; izvornik ostaje kakav jest.</value></data>
<data name="Admin.Convert.ConfirmNew.other" xml:space="preserve"><value>{0} fotografija pretvara se u kopije u novoj sekvenci pokraj svake izvorne; izvornici ostaju kakvi jesu.</value></data>
<data name="Admin.Convert.ConfirmNewNotCopied.few" xml:space="preserve"><value>{0} fotografije ne kopiraju se u nove sekvence, iz razloga navedenih u pretpregledu.</value></data>
<data name="Admin.Convert.ConfirmNewNotCopied.one" xml:space="preserve"><value>{0} fotografija ne kopira se u novu sekvencu, iz razloga navedenog u pretpregledu.</value></data>
<data name="Admin.Convert.ConfirmNewNotCopied.other" xml:space="preserve"><value>{0} fotografija ne kopira se u nove sekvence, iz razloga navedenih u pretpregledu.</value></data>
<data name="Admin.Convert.ConfirmNewTitle" xml:space="preserve"><value>Pretvoriti u {0} u novim sekvencama?</value></data>
<data name="Admin.Convert.ConfirmReplace.few" xml:space="preserve"><value>{0} fotografije ({1}) zamjenjuju se svojim pretvorbama; izvornici se premještaju u koš za smeće i mogu se vratiti dok se koš ne isprazni.</value></data>
<data name="Admin.Convert.ConfirmReplace.one" xml:space="preserve"><value>{0} fotografija ({1}) zamjenjuje se svojom pretvorbom; izvornik se premješta u koš za smeće i može se vratiti dok se koš ne isprazni.</value></data>
<data name="Admin.Convert.ConfirmReplace.other" xml:space="preserve"><value>{0} fotografija ({1}) zamjenjuje se svojim pretvorbama; izvornici se premještaju u koš za smeće i mogu se vratiti dok se koš ne isprazni.</value></data>
<data name="Admin.Convert.ConfirmReplaceTitle" xml:space="preserve"><value>Zamijeniti izvornike pretvorbom u {0}?</value></data>
<data name="Admin.Convert.Format" xml:space="preserve"><value>Format</value></data>
<data name="Admin.Convert.Format.Jpeg.Tip" xml:space="preserve"><value>8-bitni JPEG s bojama u punoj razlučivosti, uz kvalitetu postavljenu pokraj: najmanje datoteke, koje otvara svaki program</value></data>
<data name="Admin.Convert.Format.LinearDng" xml:space="preserve"><value>Linearni DNG</value></data>
<data name="Admin.Convert.Format.LinearDng.Tip" xml:space="preserve"><value>16-bitni linearni DNG komprimiran bez gubitaka: izbor za arhiviranje, otvaraju ga programi za obradu RAW datoteka</value></data>
<data name="Admin.Convert.Format.Tiff16.Tip" xml:space="preserve"><value>16-bitni sRGB TIFF komprimiran bez gubitaka: velike datoteke koje čuvaju svaki ton za uređivanje</value></data>
<data name="Admin.Convert.Gone" xml:space="preserve"><value>Odabrana sekvenca više nije u arhivi; zatvorite prozor i ponovno odaberite.</value></data>
<data name="Admin.Convert.Mode" xml:space="preserve"><value>Način</value></data>
<data name="Admin.Convert.Mode.NewSequence" xml:space="preserve"><value>Nova sekvenca</value></data>
<data name="Admin.Convert.Mode.NewSequence.Tip" xml:space="preserve"><value>Pretvorene kopije spremaju se u novu sekvencu pokraj svake izvorne; izvornici i njihova sekvenca ostaju točno kakvi jesu</value></data>
<data name="Admin.Convert.Mode.Replace" xml:space="preserve"><value>Zamijeni</value></data>
<data name="Admin.Convert.Mode.Replace.Tip" xml:space="preserve"><value>Pretvorene datoteke postaju fotografije sekvence; izvornici se premještaju u koš za smeće arhive i mogu se vratiti dok se koš ne isprazni</value></data>
<data name="Admin.Convert.NoAnswer" xml:space="preserve"><value>Poslužitelj nije odgovorio: prije ponovne pretvorbe na stranici „Zadaci” provjerite je li pretvorba stavljena u red čekanja.</value></data>
<data name="Admin.Convert.NoSpace.Tip" xml:space="preserve"><value>Najprije oslobodite prostor na volumenu arhive</value></data>
<data name="Admin.Convert.NotCopiedCount.few" xml:space="preserve"><value>{0} fotografije nisu kopirane</value></data>
<data name="Admin.Convert.NotCopiedCount.one" xml:space="preserve"><value>{0} fotografija nije kopirana</value></data>
<data name="Admin.Convert.NotCopiedCount.other" xml:space="preserve"><value>{0} fotografija nije kopirano</value></data>
<data name="Admin.Convert.Nothing.Tip" xml:space="preserve"><value>U pretpregledu nema ničega za pretvorbu</value></data>
<data name="Admin.Convert.NothingToConvert" xml:space="preserve"><value>Nema se što pretvoriti: svaka fotografija ostaje kakva jest, iz prikazanih razloga.</value></data>
<data name="Admin.Convert.OpenJob" xml:space="preserve"><value>Otvori zadatak</value></data>
<data name="Admin.Convert.OpenJob.Tip" xml:space="preserve"><value>Prikazuje zadatak i njegov zapisnik na stranici „Zadaci”</value></data>
<data name="Admin.Convert.PlanChanged" xml:space="preserve"><value>Arhiva se promijenila nakon pretpregleda; provjerite novi pretpregled i ponovno primijenite.</value></data>
<data name="Admin.Convert.Planning" xml:space="preserve"><value>Planiranje…</value></data>
<data name="Admin.Convert.Planning.Tip" xml:space="preserve"><value>Poslužitelj čita svaku mapu fotografija iz odabira: za veliku arhivu to traje nekoliko minuta, a pretpregled se prikazuje kada čitanje završi</value></data>
<data name="Admin.Convert.PlanningFor" xml:space="preserve"><value>Planiranje… {0}</value></data>
<data name="Admin.Convert.Preview" xml:space="preserve"><value>Pretpregled</value></data>
<data name="Admin.Convert.Preview.Tip" xml:space="preserve"><value>Što se u svakoj sekvenci pretvara, a što ostaje kakvo jest, uz veličinu prije i poslije (procjena); još ništa nije promijenjeno</value></data>
<data name="Admin.Convert.Quality" xml:space="preserve"><value>Kvaliteta</value></data>
<data name="Admin.Convert.Quality.Tip" xml:space="preserve"><value>Kvaliteta JPEG-a od 1 do 100; 95 čuva fine detalje, niže vrijednosti daju manje datoteke</value></data>
<data name="Admin.Convert.QualityRange" xml:space="preserve"><value>Upišite cijeli broj od 1 do 100.</value></data>
<data name="Admin.Convert.Queued" xml:space="preserve"><value>Pretvorba je u redu čekanja.</value></data>
<data name="Admin.Convert.ReplaceWord" xml:space="preserve"><value>zamijeni</value></data>
<data name="Admin.Convert.Size.Tip" xml:space="preserve"><value>Sadašnja veličina fotografija koje se pretvaraju, zatim procijenjena veličina nakon pretvorbe</value></data>
<data name="Admin.Convert.SkippedPhotos" xml:space="preserve"><value>{0}: {1}</value></data>
<data name="Admin.Convert.Title.few" xml:space="preserve"><value>Pretvorba {0} sekvence</value></data>
<data name="Admin.Convert.Title.one" xml:space="preserve"><value>Pretvorba {0} sekvence</value></data>
<data name="Admin.Convert.Title.other" xml:space="preserve"><value>Pretvorba {0} sekvenci</value></data>
<data name="Admin.Convert.TitleAll" xml:space="preserve"><value>Pretvorba svih sekvenci</value></data>
<data name="Admin.Convert.TooMany" xml:space="preserve"><value>Pretvorba obuhvaća najviše {0} sekvenci odjednom ili sve sekvence: očistite filtre i odaberite sve.</value></data>
<data name="Admin.Convert.Totals" xml:space="preserve"><value>Pretvorene sekvence: {0} · fotografije: {1} · nepromijenjene: {2} · veličina: {3} → {4}</value></data>
<data name="Admin.Convert.TotalsNew" xml:space="preserve"><value>Pretvorene sekvence: {0} · fotografije: {1} · nekopirane: {2} · veličina: {3} → {4}</value></data>
<data name="Admin.Dashboard.Activity" xml:space="preserve"><value>Nedavna aktivnost</value></data>
<data name="Admin.Dashboard.AllLogs" xml:space="preserve"><value>Svi zapisnici</value></data>
<data name="Admin.Dashboard.AllLogs.Tip" xml:space="preserve"><value>Otvara zapisnik revizije</value></data>
@@ -142,6 +210,7 @@
<data name="Admin.Job.Kind.Adopt" xml:space="preserve"><value>Usvajanje</value></data>
<data name="Admin.Job.Kind.Backup" xml:space="preserve"><value>Sigurnosno kopiranje</value></data>
<data name="Admin.Job.Kind.Cleanup" xml:space="preserve"><value>Čišćenje</value></data>
<data name="Admin.Job.Kind.Convert" xml:space="preserve"><value>Pretvorba</value></data>
<data name="Admin.Job.Kind.DeepAnalyse" xml:space="preserve"><value>Dubinska analiza</value></data>
<data name="Admin.Job.Kind.Duplicates" xml:space="preserve"><value>Duplikati</value></data>
<data name="Admin.Job.Kind.EmptyTrash" xml:space="preserve"><value>Pražnjenje koša za smeće</value></data>
@@ -368,6 +437,7 @@
<data name="Admin.Login.SignIn.Tip" xml:space="preserve"><value>Prijava radi administriranja ovog poslužitelja</value></data>
<data name="Admin.Login.User" xml:space="preserve"><value>Korisnik</value></data>
<data name="Admin.Login.User.Tip" xml:space="preserve"><value>Vaše korisničko ime na ovom poslužitelju</value></data>
<data name="Admin.Logs.Action.ArchiveConverted" xml:space="preserve"><value>Fotografije pretvorene</value></data>
<data name="Admin.Logs.Action.ArchiveReorganized" xml:space="preserve"><value>Arhiva reorganizirana</value></data>
<data name="Admin.Logs.Action.ArchiveSettings" xml:space="preserve"><value>Struktura arhive</value></data>
<data name="Admin.Logs.Action.FramesDeleted" xml:space="preserve"><value>Fotografije izbrisane</value></data>
@@ -833,6 +903,7 @@
<data name="Admin.Theme.Tip" xml:space="preserve"><value>Prebacuje između svijetle i tamne teme</value></data>
<data name="Admin.Trash.Back" xml:space="preserve"><value>Biblioteka</value></data>
<data name="Admin.Trash.Back.Tip" xml:space="preserve"><value>Natrag u Biblioteku</value></data>
<data name="Admin.Trash.ConversionDeleted" xml:space="preserve"><value>pretvorba izbrisana</value></data>
<data name="Admin.Trash.DeletedAt" xml:space="preserve"><value>Izbrisano</value></data>
<data name="Admin.Trash.DeletedBy" xml:space="preserve"><value>Izbrisao korisnik</value></data>
<data name="Admin.Trash.Emptied" xml:space="preserve"><value>Koš za smeće je ispražnjen.</value></data>
@@ -861,10 +932,14 @@
<data name="Admin.Trash.Photos" xml:space="preserve"><value>Fotografije</value></data>
<data name="Admin.Trash.Restore" xml:space="preserve"><value>Vrati</value></data>
<data name="Admin.Trash.RestorePhotos.Tip" xml:space="preserve"><value>Vraća fotografije u njihovu sekvencu (u novu ako ona više ne postoji); svaka se najprije provjerava prema svojem SHA-256</value></data>
<data name="Admin.Trash.RestoreReplaced.Tip" xml:space="preserve"><value>Vraća izvornike na mjesto njihovih pretvorbi ako su one nepromijenjene (pretvorbe se premještaju u koš za smeće), a inače u novu sekvencu; svaki se najprije provjerava prema svojem SHA-256</value></data>
<data name="Admin.Trash.RestoreSequence.Tip" xml:space="preserve"><value>Vraća mapu sekvence u biblioteku onakvu kakva jest (pokraj starog mjesta ako je ono zauzeto); hash njezinih fotografija ne provjerava se: to radi Provjera</value></data>
<data name="Admin.Trash.RestoredNew.few" xml:space="preserve"><value>{0} fotografije vraćene su u novu sekvencu.</value></data>
<data name="Admin.Trash.RestoredNew.one" xml:space="preserve"><value>{0} fotografija vraćena je u novu sekvencu.</value></data>
<data name="Admin.Trash.RestoredNew.other" xml:space="preserve"><value>{0} fotografija vraćeno je u novu sekvencu.</value></data>
<data name="Admin.Trash.RestoredOriginals.few" xml:space="preserve"><value>{0} izvornika ponovno su u sekvenci {1}; njihove su pretvorbe u košu za smeće.</value></data>
<data name="Admin.Trash.RestoredOriginals.one" xml:space="preserve"><value>{0} izvornik ponovno je u sekvenci {1}; njegova je pretvorba u košu za smeće.</value></data>
<data name="Admin.Trash.RestoredOriginals.other" xml:space="preserve"><value>{0} izvornika ponovno je u sekvenci {1}; njihove su pretvorbe u košu za smeće.</value></data>
<data name="Admin.Trash.RestoredPhotos.few" xml:space="preserve"><value>{0} fotografije ponovno su u sekvenci {1}.</value></data>
<data name="Admin.Trash.RestoredPhotos.one" xml:space="preserve"><value>{0} fotografija ponovno je u sekvenci {1}.</value></data>
<data name="Admin.Trash.RestoredPhotos.other" xml:space="preserve"><value>{0} fotografija ponovno je u sekvenci {1}.</value></data>
+120 -4
View File
@@ -16,8 +16,10 @@
<data name="Archive.Blocked.Applying" xml:space="preserve"><value>Pričekajte da se promjene primijene.</value></data>
<data name="Archive.Blocked.EmptySet" xml:space="preserve"><value>Skup je prazan: promijenite odabir ili filtar.</value></data>
<data name="Archive.Blocked.NoChanges" xml:space="preserve"><value>Ništa se ne bi promijenilo.</value></data>
<data name="Archive.Blocked.NoMode" xml:space="preserve"><value>Odaberite „Zamijeni” ili „Nova sekvenca”.</value></data>
<data name="Archive.Blocked.NoTemplate" xml:space="preserve"><value>Uključite barem jedan predložak.</value></data>
<data name="Archive.Blocked.NotOnline" xml:space="preserve"><value>Arhiva mora biti dostupna i omogućavati zapisivanje.</value></data>
<data name="Archive.Blocked.NothingToConvert" xml:space="preserve"><value>Nema se što pretvoriti: sve su fotografije preskočene ili su sve sekvence blokirane.</value></data>
<data name="Archive.Blocked.Planning" xml:space="preserve"><value>Pričekajte probni rad.</value></data>
<data name="Archive.Blocked.Reading" xml:space="preserve"><value>Pričekajte da se arhiva pročita.</value></data>
<data name="Archive.Blocked.Searching" xml:space="preserve"><value>Pretraživanje je u tijeku; otkažite ga ili pričekajte.</value></data>
@@ -34,6 +36,91 @@
<data name="Archive.Confirm.Remove" xml:space="preserve"><value>Ukloni redak</value></data>
<data name="Archive.Confirm.RemoveHeading" xml:space="preserve"><value>Ukloniti {0} iz indeksa?</value></data>
<data name="Archive.Confirm.RemoveMessage" xml:space="preserve"><value>Prateća datoteka sekvence više ne postoji. Uklanja se samo redak u indeksu; ne briše se nijedna datoteka.</value></data>
<data name="Archive.Convert.AlreadyQueued" xml:space="preserve"><value>Pretvorba ovih sekvenci već čeka ili je u tijeku; pratite je u Zadacima.</value></data>
<data name="Archive.Convert.Blocked.Busy" xml:space="preserve"><value>Na ovoj sekvenci upravo radi zadatak; pretvorite je kada zadatak završi.</value></data>
<data name="Archive.Convert.Blocked.FramesChanged" xml:space="preserve"><value>Sekvenca se promijenila nakon izrade plana; ponovno pregledajte plan.</value></data>
<data name="Archive.Convert.Blocked.Offline" xml:space="preserve"><value>Arhiva nije dostupna ili je samo za čitanje.</value></data>
<data name="Archive.Convert.Blocked.Unreadable" xml:space="preserve"><value>Datoteka sekvence ne može se pročitati.</value></data>
<data name="Archive.Convert.Confirm" xml:space="preserve"><value>Pretvori</value></data>
<data name="Archive.Convert.CopyUnfinished" xml:space="preserve"><value>Druga pretvorba izradila je njezinu kopiju u ovom formatu i nije završila; najprije dovršite tu pretvorbu ili je pokušajte ponovno.</value></data>
<data name="Archive.Convert.Done.few" xml:space="preserve"><value>Pretvorene su {0:N0} sekvence</value></data>
<data name="Archive.Convert.Done.one" xml:space="preserve"><value>Pretvorena je {0:N0} sekvenca</value></data>
<data name="Archive.Convert.Done.other" xml:space="preserve"><value>Pretvoreno je {0:N0} sekvenci</value></data>
<data name="Archive.Convert.Failed.Changed" xml:space="preserve"><value>Fotografija se više ne podudara s arhiviranom kopijom; provjerite sekvencu.</value></data>
<data name="Archive.Convert.Failed.ColorProfile" xml:space="preserve"><value>Njezin profil boja u ovom se formatu ne može ni zadržati ni pretvoriti.</value></data>
<data name="Archive.Convert.Failed.Damaged" xml:space="preserve"><value>Njezini pikseli sadrže vrijednosti koje nisu brojevi: datoteka je oštećena.</value></data>
<data name="Archive.Convert.Failed.EightBit" xml:space="preserve"><value>Ovo računalo razvija ovaj RAW samo u 8 bita, što je premalo za 16-bitnu datoteku; u JPEG se može pretvoriti.</value></data>
<data name="Archive.Convert.Failed.Full" xml:space="preserve"><value>Disk arhive je pun.</value></data>
<data name="Archive.Convert.Failed.NoDecoder" xml:space="preserve"><value>Nijedan dekoder na ovom računalu ne čita je u punoj razlučivosti.</value></data>
<data name="Archive.Convert.Failed.NotVerified" xml:space="preserve"><value>Pretvorena datoteka pri ponovnom čitanju nije odgovarala zapisanoj.</value></data>
<data name="Archive.Convert.Failed.Other" xml:space="preserve"><value>Pretvorena datoteka nije se mogla izraditi.</value></data>
<data name="Archive.Convert.Failed.PreviewOnly" xml:space="preserve"><value>Ovo je računalo čita samo iz njezina ugrađenog pretpregleda: pretvorite je na računalu koje je čita u punoj razlučivosti.</value></data>
<data name="Archive.Convert.Failed.TooLarge" xml:space="preserve"><value>Veća je od onoga što ovaj format može sadržavati, što Chronos može ponovno pročitati ili što memorija za jednu fotografiju može primiti.</value></data>
<data name="Archive.Convert.Failed.Unreadable" xml:space="preserve"><value>Fotografija se nije mogla dekodirati.</value></data>
<data name="Archive.Convert.Format" xml:space="preserve"><value>Format</value></data>
<data name="Archive.Convert.Heading.few" xml:space="preserve"><value>Pretvorba {0:N0} sekvence</value></data>
<data name="Archive.Convert.Heading.one" xml:space="preserve"><value>Pretvorba {0:N0} sekvence</value></data>
<data name="Archive.Convert.Heading.other" xml:space="preserve"><value>Pretvorba {0:N0} sekvenci</value></data>
<data name="Archive.Convert.HeadingAll" xml:space="preserve"><value>Pretvorba arhive {0}</value></data>
<data name="Archive.Convert.Mode" xml:space="preserve"><value>Način</value></data>
<data name="Archive.Convert.NewHeading.few" xml:space="preserve"><value>Pretvoriti {0:N0} sekvence u nove?</value></data>
<data name="Archive.Convert.NewHeading.one" xml:space="preserve"><value>Pretvoriti {0:N0} sekvencu u novu?</value></data>
<data name="Archive.Convert.NewHeading.other" xml:space="preserve"><value>Pretvoriti {0:N0} sekvenci u nove?</value></data>
<data name="Archive.Convert.NewLeftOut.few" xml:space="preserve"><value>{0:N0} fotografije ne kopiraju se: ostaju samo u svojem izvoru, iz razloga navedenih u planu.</value></data>
<data name="Archive.Convert.NewLeftOut.one" xml:space="preserve"><value>{0:N0} fotografija ne kopira se: ostaje samo u svojem izvoru, iz razloga navedenog u planu.</value></data>
<data name="Archive.Convert.NewLeftOut.other" xml:space="preserve"><value>{0:N0} fotografija ne kopira se: ostaju samo u svojem izvoru, iz razloga navedenih u planu.</value></data>
<data name="Archive.Convert.NewMessage" xml:space="preserve"><value>Pretvorba u {2}: {0} ({1}), u novu sekvencu pokraj svakog izvora; izvornici ostaju kakvi jesu.</value></data>
<data name="Archive.Convert.NewSequence" xml:space="preserve"><value>Nova sekvenca</value></data>
<data name="Archive.Convert.NotCopied.ColorProfile" xml:space="preserve"><value>Fotografije čiji profil boja ovaj format ne može ni zadržati ni pretvoriti ne kopiraju se u novu sekvencu.</value></data>
<data name="Archive.Convert.NotCopied.EightBit" xml:space="preserve"><value>RAW fotografije koje ovo računalo razvija samo u 8 bita ne kopiraju se u novu sekvencu; u JPEG se mogu pretvoriti.</value></data>
<data name="Archive.Convert.NotCopied.Inaccessible" xml:space="preserve"><value>Fotografije koje drži otvorene drugi program ili koje se ne mogu otvoriti ne kopiraju se u novu sekvencu; ponovno izradite plan kada se oslobode.</value></data>
<data name="Archive.Convert.NotCopied.Missing" xml:space="preserve"><value>Fotografije koje nedostaju ne kopiraju se u novu sekvencu.</value></data>
<data name="Archive.Convert.NotCopied.NoNativeDecoder" xml:space="preserve"><value>Fotografije u formatu koji ovo računalo ne može čitati u punoj razlučivosti ne kopiraju se u novu sekvencu.</value></data>
<data name="Archive.Convert.NotCopied.PreviewOnly" xml:space="preserve"><value>Fotografije koje se ovdje čitaju samo iz ugrađenog pretpregleda ne kopiraju se u novu sekvencu.</value></data>
<data name="Archive.Convert.NotCopied.SameFormat" xml:space="preserve"><value>Fotografije koje su već u ovom formatu ne kopiraju se u novu sekvencu.</value></data>
<data name="Archive.Convert.NotCopied.TooLarge" xml:space="preserve"><value>Fotografije veće od onoga što ovaj format može sadržavati ili Chronos ponovno pročitati ne kopiraju se u novu sekvencu.</value></data>
<data name="Archive.Convert.NotCopied.Undecodable" xml:space="preserve"><value>Nečitljive fotografije ne kopiraju se u novu sekvencu.</value></data>
<data name="Archive.Convert.NotCopied.Unhashed" xml:space="preserve"><value>Fotografije koje nikad nisu provjerene ne kopiraju se u novu sekvencu; najprije provjerite sekvencu.</value></data>
<data name="Archive.Convert.NotCopiedPhotos.few" xml:space="preserve"><value>{0:N0} fotografije nisu kopirane</value></data>
<data name="Archive.Convert.NotCopiedPhotos.one" xml:space="preserve"><value>{0:N0} fotografija nije kopirana</value></data>
<data name="Archive.Convert.NotCopiedPhotos.other" xml:space="preserve"><value>{0:N0} fotografija nije kopirano</value></data>
<data name="Archive.Convert.NotPlaced" xml:space="preserve"><value>Pretvorene fotografije nisu mogle zauzeti svoje mjesto. {0}</value></data>
<data name="Archive.Convert.PhotoFailed" xml:space="preserve"><value>Datoteka {0} nije se mogla pretvoriti. {1}</value></data>
<data name="Archive.Convert.PhotoHeld" xml:space="preserve"><value>Jednu njezinu fotografiju drži otvorenom drugi program ili se ona ne može otvoriti; pokušajte ponovno kada se oslobodi.</value></data>
<data name="Archive.Convert.Quality" xml:space="preserve"><value>Kvaliteta</value></data>
<data name="Archive.Convert.Replace" xml:space="preserve"><value>Zamijeni</value></data>
<data name="Archive.Convert.ReplaceHeading.few" xml:space="preserve"><value>Zamijeniti fotografije {0:N0} sekvence?</value></data>
<data name="Archive.Convert.ReplaceHeading.one" xml:space="preserve"><value>Zamijeniti fotografije {0:N0} sekvence?</value></data>
<data name="Archive.Convert.ReplaceHeading.other" xml:space="preserve"><value>Zamijeniti fotografije {0:N0} sekvenci?</value></data>
<data name="Archive.Convert.ReplaceMessage" xml:space="preserve"><value>Zamjena pretvorbom u {2}: {0} ({1}); izvornici se premještaju u koš za smeće arhive i mogu se vratiti dok se koš ne isprazni.</value></data>
<data name="Archive.Convert.Sizes" xml:space="preserve"><value>{0} → {1}</value></data>
<data name="Archive.Convert.Skipped.ColorProfile" xml:space="preserve"><value>Fotografije čiji profil boja ovaj format ne može ni zadržati ni pretvoriti ostaju kakve jesu.</value></data>
<data name="Archive.Convert.Skipped.EightBit" xml:space="preserve"><value>RAW fotografije koje ovo računalo razvija samo u 8 bita ostaju kakve jesu; u JPEG se mogu pretvoriti.</value></data>
<data name="Archive.Convert.Skipped.Inaccessible" xml:space="preserve"><value>Fotografije koje drži otvorene drugi program ili koje se ne mogu otvoriti ostaju kakve jesu; ponovno izradite plan kada se oslobode.</value></data>
<data name="Archive.Convert.Skipped.Missing" xml:space="preserve"><value>Fotografije koje nedostaju ostaju kakve jesu.</value></data>
<data name="Archive.Convert.Skipped.NoNativeDecoder" xml:space="preserve"><value>Fotografije u formatu koji ovo računalo ne može čitati u punoj razlučivosti ostaju kakve jesu.</value></data>
<data name="Archive.Convert.Skipped.PreviewOnly" xml:space="preserve"><value>Fotografije koje se ovdje čitaju samo iz ugrađenog pretpregleda ostaju kakve jesu.</value></data>
<data name="Archive.Convert.Skipped.SameFormat" xml:space="preserve"><value>Fotografije koje su već u ovom formatu ostaju kakve jesu.</value></data>
<data name="Archive.Convert.Skipped.TooLarge" xml:space="preserve"><value>Fotografije veće od onoga što ovaj format može sadržavati ili Chronos ponovno pročitati ostaju kakve jesu.</value></data>
<data name="Archive.Convert.Skipped.Undecodable" xml:space="preserve"><value>Nečitljive fotografije ostaju kakve jesu.</value></data>
<data name="Archive.Convert.Skipped.Unhashed" xml:space="preserve"><value>Fotografije koje nikad nisu provjerene ostaju kakve jesu; najprije provjerite sekvencu.</value></data>
<data name="Archive.Convert.SkippedPhotos.few" xml:space="preserve"><value>{0:N0} fotografije preskočene</value></data>
<data name="Archive.Convert.SkippedPhotos.one" xml:space="preserve"><value>{0:N0} fotografija preskočena</value></data>
<data name="Archive.Convert.SkippedPhotos.other" xml:space="preserve"><value>{0:N0} fotografija preskočeno</value></data>
<data name="Archive.Convert.Space" xml:space="preserve"><value>Potrebno: {0}, slobodno: {1}</value></data>
<data name="Archive.Convert.SpaceShort" xml:space="preserve"><value>Potrebno: {0}, slobodno samo {1}: najprije oslobodite prostor.</value></data>
<data name="Archive.Convert.SpaceUnknown" xml:space="preserve"><value>Potrebno: {0}; slobodan prostor ne može se izmjeriti.</value></data>
<data name="Archive.Convert.Target.LinearDng" xml:space="preserve"><value>Linearni DNG</value></data>
<data name="Archive.Convert.Target.Tiff16" xml:space="preserve"><value>TIFF 16-bitni</value></data>
<data name="Archive.Convert.UndoFailed" xml:space="preserve"><value>Izvornici se nisu mogli vratiti</value></data>
<data name="Archive.Convert.UndoNothing" xml:space="preserve"><value>Zamijenjeni izvornici više nisu u košu za smeće.</value></data>
<data name="Archive.Convert.Undone.few" xml:space="preserve"><value>Izvornici su vraćeni u {0:N0} sekvence</value></data>
<data name="Archive.Convert.Undone.one" xml:space="preserve"><value>Izvornici su vraćeni u {0:N0} sekvencu</value></data>
<data name="Archive.Convert.Undone.other" xml:space="preserve"><value>Izvornici su vraćeni u {0:N0} sekvenci</value></data>
<data name="Archive.Convert.UndoneNew.few" xml:space="preserve"><value>{0:N0} sekvence u međuvremenu su se promijenile: njihovi su se izvornici vratili kao nove sekvence.</value></data>
<data name="Archive.Convert.UndoneNew.one" xml:space="preserve"><value>{0:N0} sekvenca u međuvremenu se promijenila: njezini su se izvornici vratili kao nova sekvenca.</value></data>
<data name="Archive.Convert.UndoneNew.other" xml:space="preserve"><value>{0:N0} sekvenci u međuvremenu se promijenilo: njihovi su se izvornici vratili kao nove sekvence.</value></data>
<data name="Archive.Convert.Unstaged" xml:space="preserve"><value>Pretvorba datoteke {0} više nije među pripremljenim datotekama; ponovni pokušaj ponovno će je pretvoriti.</value></data>
<data name="Archive.Copy.Title" xml:space="preserve"><value>Mapa za kopiranje u arhivu</value></data>
<data name="Archive.Delete.Action" xml:space="preserve"><value>Premjesti u koš</value></data>
<data name="Archive.Delete.Blocked" xml:space="preserve"><value>Nije premješteno: {0} · {1}</value></data>
@@ -85,6 +172,10 @@
<data name="Archive.Duplicates.Title" xml:space="preserve"><value>Duplikati</value></data>
<data name="Archive.Empty" xml:space="preserve"><value>Još nema arhive</value></data>
<data name="Archive.Error.Busy" xml:space="preserve"><value>Drugi Chronos ({0}) upravo ovdje zapisuje podatke. Pokušajte ponovno malo poslije.</value></data>
<data name="Archive.Error.ConvertKept.few" xml:space="preserve"><value>{0:N0} sekvence nisu pretvorene prema planu; razlog je naveden u zapisniku zadatka.</value></data>
<data name="Archive.Error.ConvertKept.one" xml:space="preserve"><value>{0:N0} sekvenca nije pretvorena prema planu; razlog je naveden u zapisniku zadatka.</value></data>
<data name="Archive.Error.ConvertKept.other" xml:space="preserve"><value>{0:N0} sekvenci nije pretvoreno prema planu; razlog je naveden u zapisniku zadatka.</value></data>
<data name="Archive.Error.ConvertSpace" xml:space="preserve"><value>Za pretvorbu je na volumenu arhive potrebno slobodno {0}, a slobodno je {1}.</value></data>
<data name="Archive.Error.CopyMismatch" xml:space="preserve"><value>Kopija datoteke {0} ne podudara se s izvornikom.</value></data>
<data name="Archive.Error.DuplicateLost" xml:space="preserve"><value>Datoteka {0} ne može se dodati u sekvencu.</value></data>
<data name="Archive.Error.InLibrary" xml:space="preserve"><value>Sekvenca {0} već je u biblioteci.</value></data>
@@ -105,9 +196,9 @@
<data name="Archive.Error.SourceGone" xml:space="preserve"><value>Kartica ili mapa {0} više nije dostupna.</value></data>
<data name="Archive.Error.StalePlan" xml:space="preserve"><value>Arhiva se promijenila nakon izrade ovog plana.</value></data>
<data name="Archive.Error.TrashChanged" xml:space="preserve"><value>Koš za smeće promijenio se nakon provjere; ništa nije izbrisano.</value></data>
<data name="Archive.Error.TrashKept.few" xml:space="preserve"><value>{0:N0} unosa u košu za smeće zadržana su: promijenili su se ili se zamjena više ne podudara.</value></data>
<data name="Archive.Error.TrashKept.one" xml:space="preserve"><value>{0:N0} unos u košu za smeće zadržan je: promijenio se ili se zamjena više ne podudara.</value></data>
<data name="Archive.Error.TrashKept.other" xml:space="preserve"><value>{0:N0} unosa u košu za smeće zadržano je: promijenili su se ili se zamjena više ne podudara.</value></data>
<data name="Archive.Error.TrashKept.few" xml:space="preserve"><value>{0:N0} unosa u košu za smeće zadržana su; razlog je naveden u zapisniku zadatka.</value></data>
<data name="Archive.Error.TrashKept.one" xml:space="preserve"><value>{0:N0} unos u košu za smeće zadržan je; razlog je naveden u zapisniku zadatka.</value></data>
<data name="Archive.Error.TrashKept.other" xml:space="preserve"><value>{0:N0} unosa u košu za smeće zadržano je; razlog je naveden u zapisniku zadatka.</value></data>
<data name="Archive.Error.TrashMismatch" xml:space="preserve"><value>Nijedna datoteka ovog unosa u košu za smeće više se ne podudara sa svojim zapisom; unos ostaje u košu.</value></data>
<data name="Archive.Failed.Access" xml:space="preserve"><value>Programu Chronos odbijen je pristup arhivi.</value></data>
<data name="Archive.Failed.Files" xml:space="preserve"><value>Datoteka arhive nije se mogla pročitati ili zapisati.</value></data>
@@ -151,6 +242,15 @@
<data name="Archive.Log.AuditKept" xml:space="preserve"><value>Zapisnik revizije čuva se u cijelosti</value></data>
<data name="Archive.Log.AuditPurged" xml:space="preserve"><value>Uklonjeni unosi revizije: {0}</value></data>
<data name="Archive.Log.BackupDone" xml:space="preserve"><value>Indeks je kopiran u {0} ({1}); zadržane kopije: {2}</value></data>
<data name="Archive.Log.ConvertBlocked" xml:space="preserve"><value>Ostavljeno kako je bilo, zauzeto ili nečitljivo: {0}</value></data>
<data name="Archive.Log.ConvertChanged" xml:space="preserve"><value>Ostavljeno kako je bilo, promijenjeno nakon izrade plana: {0}. Ponovni pokušaj ostavlja je kakva jest: ponovno je pretvorite iz novog plana.</value></data>
<data name="Archive.Log.ConvertDone" xml:space="preserve"><value>Pretvorene sekvence: {0}, nove sekvence: {1}, fotografije: {2}</value></data>
<data name="Archive.Log.ConvertFailed" xml:space="preserve"><value>Ostavljeno kako je bilo: {0}. {1}</value></data>
<data name="Archive.Log.ConvertLeftOut" xml:space="preserve"><value>{0}: nepretvorene fotografije, ostale samo u izvoru: {1}</value></data>
<data name="Archive.Log.ConvertNothing" xml:space="preserve"><value>Nema se što pretvoriti: {0}</value></data>
<data name="Archive.Log.ConvertSuperseded" xml:space="preserve"><value>{0}: otkad je ova pretvorba potvrđena, druga je pretvorba izradila njezinu kopiju u ovom formatu; još jedna kopija ne izrađuje se.</value></data>
<data name="Archive.Log.Converted" xml:space="preserve"><value>{0}: fotografije zamijenjene pretvorbom: {1}</value></data>
<data name="Archive.Log.ConvertedNew" xml:space="preserve"><value>{0}: fotografije pretvorene u novu sekvencu: {1}</value></data>
<data name="Archive.Log.DryRun" xml:space="preserve"><value>Probni rad: ništa nije promijenjeno.</value></data>
<data name="Archive.Log.DuplicateGroup" xml:space="preserve"><value>Dodatne kopije fotografije {0}: {1}</value></data>
<data name="Archive.Log.DuplicatesDone" xml:space="preserve"><value>Grupe duplikata: {0}, dodatne kopije: {1}</value></data>
@@ -185,9 +285,23 @@
<data name="Archive.Log.SequenceMissing" xml:space="preserve"><value>Sekvenca nije pronađena: {0}</value></data>
<data name="Archive.Log.StepFailed" xml:space="preserve"><value>Korak čišćenja {0} nije uspio: {1}</value></data>
<data name="Archive.Log.StepUnknown" xml:space="preserve"><value>Korak čišćenja ovdje je nepoznat: {0}</value></data>
<data name="Archive.Log.SyncChanged" xml:space="preserve"><value>{0}: promijenjeno nakon arhiviranja, nije preneseno</value></data>
<data name="Archive.Log.SyncDeletedHere" xml:space="preserve"><value>{0}: izbrisano na ovom računalu, nije preuzeto</value></data>
<data name="Archive.Log.SyncDeletedThere" xml:space="preserve"><value>{0}: izbrisano na poslužitelju, nije preneseno</value></data>
<data name="Archive.Log.SyncFrameChanged" xml:space="preserve"><value>{0}: kadar se ovdje u međuvremenu promijenio, nije preuzeto</value></data>
<data name="Archive.Log.SyncMissing" xml:space="preserve"><value>{0}: nedostaje, nije preneseno</value></data>
<data name="Archive.Log.SyncNoPreview.few" xml:space="preserve"><value>{0:N0} kadra nemaju ni proxy kopije ni minijature na poslužitelju</value></data>
<data name="Archive.Log.SyncNoPreview.one" xml:space="preserve"><value>{0:N0} kadar nema ni proxy kopije ni minijature na poslužitelju</value></data>
<data name="Archive.Log.SyncNoPreview.other" xml:space="preserve"><value>{0:N0} kadrova nema ni proxy kopije ni minijature na poslužitelju</value></data>
<data name="Archive.Log.TrashEmptied" xml:space="preserve"><value>Trajno izbrisani unosi: {0}, veličina: {1}</value></data>
<data name="Archive.Log.TrashEntry" xml:space="preserve"><value>U košu za smeće od {0}: {1} ({2})</value></data>
<data name="Archive.Log.TrashKept" xml:space="preserve"><value>Zadržano u košu za smeće: {0}</value></data>
<data name="Archive.Log.TrashKept" xml:space="preserve"><value>Zadržano u košu za smeće, promijenjeno nakon izrade plana: {0}</value></data>
<data name="Archive.Log.TrashKeptBusy" xml:space="preserve"><value>Zadržano u košu za smeće, njegova je sekvenca bila zauzeta: {0}</value></data>
<data name="Archive.Log.TrashKeptMismatch" xml:space="preserve"><value>Zadržano u košu za smeće, jedna od pretvorbi njegovih izvornika više se ne podudara: {0}</value></data>
<data name="Archive.Log.TrashKeptStaleIndex" xml:space="preserve"><value>Zadržano u košu za smeće, indeks navodi njegovu sekvencu, koju arhiva više ne sadrži; ponovno izgradite indeks: {0}</value></data>
<data name="Archive.Log.TrashKeptUnhashed" xml:space="preserve"><value>Zadržano u košu za smeće, jedna fotografija njegove sekvence nikad nije provjerena; provjerite sekvencu: {0}</value></data>
<data name="Archive.Log.TrashKeptUnknown" xml:space="preserve"><value>Zadržano u košu za smeće, arhiva ne pokazuje što se dogodilo s pretvorbom njegovih izvornika; vratite ga da biste ih zadržali: {0}</value></data>
<data name="Archive.Log.TrashKeptUnreadable" xml:space="preserve"><value>Zadržano u košu za smeće, prateća datoteka mape koja možda sadrži njegovu sekvencu nedostaje ili se ne može pročitati; skenirajte arhivu: {0}</value></data>
<data name="Archive.Log.TrashOffline" xml:space="preserve"><value>Koš za smeće nije provjeren: arhiva nije dostupna</value></data>
<data name="Archive.Log.TrashReport" xml:space="preserve"><value>Stari unosi u košu za smeće: {0}, veličina: {1}; ništa nije izbrisano</value></data>
<data name="Archive.Log.VerifyDone" xml:space="preserve"><value>Provjerene fotografije: {0}, neoštećene: {1}, s novim hashom: {2}, s problemima: {3}</value></data>
@@ -277,6 +391,7 @@
<data name="Archive.Set.All.other" xml:space="preserve"><value>{0:N0} sekvenci · sve</value></data>
<data name="Archive.Set.Analyse" xml:space="preserve"><value>Analiziraj</value></data>
<data name="Archive.Set.ClearFilter" xml:space="preserve"><value>Očisti filtar</value></data>
<data name="Archive.Set.Convert" xml:space="preserve"><value>Pretvori…</value></data>
<data name="Archive.Set.Delete" xml:space="preserve"><value>Izbriši…</value></data>
<data name="Archive.Set.Export" xml:space="preserve"><value>Izvezi CSV</value></data>
<data name="Archive.Set.Filter" xml:space="preserve"><value>Filtar skupa</value></data>
@@ -310,6 +425,7 @@
<data name="Archive.Toolbar.Scan" xml:space="preserve"><value>Skeniraj</value></data>
<data name="Archive.Toolbar.Verify" xml:space="preserve"><value>Provjeri</value></data>
<data name="Archive.Trash.Checking" xml:space="preserve"><value>Provjera koša za smeće…</value></data>
<data name="Archive.Trash.ConversionDeleted" xml:space="preserve"><value>pretvorba izbrisana</value></data>
<data name="Archive.Trash.Deleted" xml:space="preserve"><value>Izbrisano {0}</value></data>
<data name="Archive.Trash.Empty" xml:space="preserve"><value>Koš za smeće je prazan</value></data>
<data name="Archive.Trash.EmptyAction" xml:space="preserve"><value>Isprazni…</value></data>
+1
View File
@@ -70,6 +70,7 @@
<data name="Jobs.Kind.Adopt" xml:space="preserve"><value>Usvajanje mape</value></data>
<data name="Jobs.Kind.Backup" xml:space="preserve"><value>Sigurnosno kopiranje indeksa</value></data>
<data name="Jobs.Kind.Cleanup" xml:space="preserve"><value>Čišćenje</value></data>
<data name="Jobs.Kind.Convert" xml:space="preserve"><value>Pretvorba</value></data>
<data name="Jobs.Kind.DeepAnalyse" xml:space="preserve"><value>Dubinska analiza</value></data>
<data name="Jobs.Kind.Download" xml:space="preserve"><value>Preuzimanje</value></data>
<data name="Jobs.Kind.Duplicates" xml:space="preserve"><value>Duplikati</value></data>
+2
View File
@@ -6,6 +6,7 @@
<resheader name="writer"><value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader>
<data name="Library.Action.Analyse" xml:space="preserve"><value>Analiziraj</value></data>
<data name="Library.Action.ClearSelection" xml:space="preserve"><value>Poništi odabir</value></data>
<data name="Library.Action.Convert" xml:space="preserve"><value>Pretvori…</value></data>
<data name="Library.Action.Delete" xml:space="preserve"><value>Izbriši…</value></data>
<data name="Library.Action.Download" xml:space="preserve"><value>Preuzmi</value></data>
<data name="Library.Action.ExportList" xml:space="preserve"><value>Izvezi popis</value></data>
@@ -32,6 +33,7 @@
<data name="Library.Blocked.NothingToDownload" xml:space="preserve"><value>Odabrane sekvence nemaju ništa za preuzimanje s poslužitelja.</value></data>
<data name="Library.Blocked.NothingToUpload" xml:space="preserve"><value>Poslužitelj već ima sve što sadrže odabrane sekvence.</value></data>
<data name="Library.Blocked.OneArchive" xml:space="preserve"><value>Reorganizacija radi sa sekvencama samo jedne arhive odjednom.</value></data>
<data name="Library.Blocked.OneArchiveConvert" xml:space="preserve"><value>Pretvorba radi sa sekvencama samo jedne arhive odjednom.</value></data>
<data name="Library.Blocked.ServerOnly" xml:space="preserve"><value>Samo za sekvence na ovom računalu; odabir se nalazi na poslužitelju.</value></data>
<data name="Library.Blocked.Transferring" xml:space="preserve"><value>Prijenos ove sekvence već je u tijeku.</value></data>
<data name="Library.ClearFilters" xml:space="preserve"><value>Očisti filtre</value></data>
+4
View File
@@ -21,6 +21,8 @@
<data name="Server.Conflict.TakeServer.Message" xml:space="preserve"><value>Postavke sekvence {0} na ovom računalu zamijenit će se kopijom s poslužitelja.</value></data>
<data name="Server.Conflict.TakeServer.Title" xml:space="preserve"><value>Preuzeti postavke s poslužitelja?</value></data>
<data name="Server.Connect" xml:space="preserve"><value>Poveži</value></data>
<data name="Server.Convert.OnPc" xml:space="preserve"><value>Pretvorite ove fotografije na računalu: poslužitelj ih ne može čitati u punoj razlučivosti.</value></data>
<data name="Server.Convert.OnPcNew" xml:space="preserve"><value>Ne kopiraju se u novu sekvencu: poslužitelj ove fotografije ne može čitati u punoj razlučivosti; pretvorite ih na računalu.</value></data>
<data name="Server.Disconnect" xml:space="preserve"><value>Prekini vezu</value></data>
<data name="Server.Empty" xml:space="preserve"><value>Nema veze s poslužiteljem</value></data>
<data name="Server.Error.AccountLocked" xml:space="preserve"><value>Previše neuspjelih prijava; račun je privremeno zaključan.</value></data>
@@ -71,7 +73,9 @@
<data name="Server.Error.MethodNotAllowed" xml:space="preserve"><value>Ova metoda ovdje nije dopuštena.</value></data>
<data name="Server.Error.NestedTarget" xml:space="preserve"><value>Nova mapa nalazila bi se unutar mape druge sekvence.</value></data>
<data name="Server.Error.NotChronos" xml:space="preserve"><value>Ta adresa nije Chronos Server.</value></data>
<data name="Server.Error.NotEnoughSpace" xml:space="preserve"><value>Na volumenu arhive nema dovoljno prostora potrebnog za pretvorbu.</value></data>
<data name="Server.Error.NotFound" xml:space="preserve"><value>Nije pronađeno.</value></data>
<data name="Server.Error.NothingToConvert" xml:space="preserve"><value>Plan ništa ne pretvara: sve su fotografije preskočene ili su sve sekvence blokirane.</value></data>
<data name="Server.Error.PasswordChangeRequired" xml:space="preserve"><value>Najprije promijenite lozinku.</value></data>
<data name="Server.Error.PhotoRemoved" xml:space="preserve"><value>Fotografija je izbrisana iz sekvence dok se prenosila pa nije dodana.</value></data>
<data name="Server.Error.PhotoUnreadable" xml:space="preserve"><value>Datoteka {0} ne može se pročitati, a bez njezina hasha ostale kopije ne bi saznale da je izbrisana; zatvorite program koji je upotrebljava ili provjerite njezina dopuštenja, a zatim pokušajte ponovno.</value></data>
+21 -1
View File
@@ -27,6 +27,22 @@
<data name="Tooltips.Archive.ClearFilter" xml:space="preserve"><value>Ponovno prikazuje sve sekvence odabira</value></data>
<data name="Tooltips.Archive.CloseDialog" xml:space="preserve"><value>Zatvara bez ikakvih promjena · Esc</value></data>
<data name="Tooltips.Archive.Collapse" xml:space="preserve"><value>Skriva sekvence ove godine</value></data>
<data name="Tooltips.Archive.ConvertApplyNew" xml:space="preserve"><value>Nakon potvrde stavlja u red čekanja zadatak koji pretvara kopije u nove sekvence · može se pauzirati i nastaviti u Zadacima</value></data>
<data name="Tooltips.Archive.ConvertApplyReplace" xml:space="preserve"><value>Za potvrdu upišite broj fotografija; zatim se u red čekanja stavlja zadatak koji ih zamjenjuje pretvorbom · može se pauzirati i nastaviti u Zadacima</value></data>
<data name="Tooltips.Archive.ConvertBack" xml:space="preserve"><value>Vraća na plan; ništa se ne pretvara</value></data>
<data name="Tooltips.Archive.ConvertDng" xml:space="preserve"><value>Linearni DNG, 16-bitni i bez gubitaka · čita ga svaki program za obradu RAW datoteka; izbor za arhiviranje</value></data>
<data name="Tooltips.Archive.ConvertJpeg" xml:space="preserve"><value>8-bitni JPEG uz kvalitetu postavljenu ispod · najmanje datoteke; dio detalja se gubi</value></data>
<data name="Tooltips.Archive.ConvertModeNew" xml:space="preserve"><value>Pretvorene kopije spremaju se u novu sekvencu pokraj svake izvorne; izvornici ostaju kakvi jesu</value></data>
<data name="Tooltips.Archive.ConvertModeReplace" xml:space="preserve"><value>Pretvorene datoteke zauzimaju mjesto fotografija u njihovim sekvencama; izvornici se premještaju u koš za smeće arhive i mogu se vratiti dok se koš ne isprazni</value></data>
<data name="Tooltips.Archive.ConvertNew" xml:space="preserve"><value>Stavlja u red čekanja zadatak koji pretvara fotografije u nove sekvence i provjerava svaku pretvorbu; izvornici ostaju netaknuti</value></data>
<data name="Tooltips.Archive.ConvertPlan" xml:space="preserve"><value>Sekvence čije se fotografije zamjenjuju</value></data>
<data name="Tooltips.Archive.ConvertPlanNew" xml:space="preserve"><value>Sekvence koje se kopiraju u nove i fotografije koje svaka izostavlja</value></data>
<data name="Tooltips.Archive.ConvertQuality" xml:space="preserve"><value>Kvaliteta JPEG-a od 1 do 100 · 95 čuva fine detalje; niža vrijednost daje manje datoteke</value></data>
<data name="Tooltips.Archive.ConvertReplace.few" xml:space="preserve"><value>Zamjenjuje {0:N0} fotografije njihovim pretvorbama; najprije upišite broj naveden iznad</value></data>
<data name="Tooltips.Archive.ConvertReplace.one" xml:space="preserve"><value>Zamjenjuje {0:N0} fotografiju njezinom pretvorbom; najprije upišite broj naveden iznad</value></data>
<data name="Tooltips.Archive.ConvertReplace.other" xml:space="preserve"><value>Zamjenjuje {0:N0} fotografija njihovim pretvorbama; najprije upišite broj naveden iznad</value></data>
<data name="Tooltips.Archive.ConvertTiff" xml:space="preserve"><value>16-bitni TIFF komprimiran bez gubitaka · velike datoteke koje otvara svaki program za uređivanje</value></data>
<data name="Tooltips.Archive.ConvertUndo" xml:space="preserve"><value>Vraća izvornike iz koša za smeće na mjesto njihovih pretvorbi</value></data>
<data name="Tooltips.Archive.DeleteAction.few" xml:space="preserve"><value>Premješta {0:N0} sekvence u koš za smeće; najprije upišite broj naveden iznad</value></data>
<data name="Tooltips.Archive.DeleteAction.one" xml:space="preserve"><value>Premješta {0:N0} sekvencu u koš za smeće; najprije upišite broj naveden iznad</value></data>
<data name="Tooltips.Archive.DeleteAction.other" xml:space="preserve"><value>Premješta {0:N0} sekvenci u koš za smeće; najprije upišite broj naveden iznad</value></data>
@@ -83,6 +99,7 @@
<data name="Tooltips.Archive.Scan" xml:space="preserve"><value>Inkrementalno skeniranje: nove, promijenjene i uklonjene datoteke prema vremenu izmjene i veličini</value></data>
<data name="Tooltips.Archive.Set" xml:space="preserve"><value>Odabrane godine i sekvence (sve ako ništa nije odabrano), sužene prema fotoaparatu, statusu ili oznaci</value></data>
<data name="Tooltips.Archive.SetAnalyse" xml:space="preserve"><value>Pokreće dubinsku analizu svake sekvence u skupu</value></data>
<data name="Tooltips.Archive.SetConvert" xml:space="preserve"><value>Pretvara fotografije skupa u JPEG, TIFF ili DNG · najprije probni rad, zatim zadatak</value></data>
<data name="Tooltips.Archive.SetDelete" xml:space="preserve"><value>Premješta skup u koš za smeće arhive · prikazuje probni rad, a zatim traži da upišete potvrdu</value></data>
<data name="Tooltips.Archive.SetExport" xml:space="preserve"><value>Izvozi skup kao CSV: jedan redak po sekvenci</value></data>
<data name="Tooltips.Archive.SetProxies" xml:space="preserve"><value>Izrađuje ili osvježava proxy kopije</value></data>
@@ -97,7 +114,7 @@
<data name="Tooltips.Archive.TitleTemplate" xml:space="preserve"><value>Predložak naslova; rezervirano mjesto naslova predstavlja trenutačni naslov · provjerava se tijekom upisivanja</value></data>
<data name="Tooltips.Archive.Trash" xml:space="preserve"><value>Sekvence i fotografije izbrisane iz ove arhive; svaka se može vratiti</value></data>
<data name="Tooltips.Archive.TrashEmpty" xml:space="preserve"><value>Trajno briše unose iz ovog koša za smeće nakon provjere njihova sadržaja i upisane potvrde</value></data>
<data name="Tooltips.Archive.TrashEmptyPlan" xml:space="preserve"><value>Što se trajno briše iz arhive</value></data>
<data name="Tooltips.Archive.TrashEmptyPlan" xml:space="preserve"><value>Što se trajno briše iz arhive; izvornici čija je pretvorba izbrisana mogu biti posljednja kopija svojih fotografija</value></data>
<data name="Tooltips.Archive.TrashErase.few" xml:space="preserve"><value>Trajno briše {0:N0} unosa; najprije upišite broj naveden iznad</value></data>
<data name="Tooltips.Archive.TrashErase.one" xml:space="preserve"><value>Trajno briše {0:N0} unos; najprije upišite broj naveden iznad</value></data>
<data name="Tooltips.Archive.TrashErase.other" xml:space="preserve"><value>Trajno briše {0:N0} unosa; najprije upišite broj naveden iznad</value></data>
@@ -472,6 +489,9 @@
<data name="Tooltips.Library.Mass.Analyse.few" xml:space="preserve"><value>Dubinska analiza {0:N0} sekvence na ovom računalu · izvodi se kao jedan zadatak</value></data>
<data name="Tooltips.Library.Mass.Analyse.one" xml:space="preserve"><value>Dubinska analiza {0:N0} sekvence na ovom računalu · izvodi se kao jedan zadatak</value></data>
<data name="Tooltips.Library.Mass.Analyse.other" xml:space="preserve"><value>Dubinska analiza {0:N0} sekvenci na ovom računalu · izvodi se kao jedan zadatak</value></data>
<data name="Tooltips.Library.Mass.Convert.few" xml:space="preserve"><value>Pretvara fotografije {0:N0} sekvence iz njihove arhive u JPEG, TIFF ili DNG · najprije probni rad, zatim zadatak</value></data>
<data name="Tooltips.Library.Mass.Convert.one" xml:space="preserve"><value>Pretvara fotografije {0:N0} sekvence u JPEG, TIFF ili DNG · najprije probni rad, zatim zadatak</value></data>
<data name="Tooltips.Library.Mass.Convert.other" xml:space="preserve"><value>Pretvara fotografije {0:N0} sekvenci iz njihove arhive u JPEG, TIFF ili DNG · najprije probni rad, zatim zadatak</value></data>
<data name="Tooltips.Library.Mass.Delete.few" xml:space="preserve"><value>Premješta {0:N0} sekvence u koš za smeće arhive · prikazuje probni rad, a zatim traži da upišete potvrdu</value></data>
<data name="Tooltips.Library.Mass.Delete.one" xml:space="preserve"><value>Premješta {0:N0} sekvencu u koš za smeće arhive · prikazuje probni rad, a zatim traži da upišete potvrdu</value></data>
<data name="Tooltips.Library.Mass.Delete.other" xml:space="preserve"><value>Premješta {0:N0} sekvenci u koš za smeće arhive · prikazuje probni rad, a zatim traži da upišete potvrdu</value></data>
+69
View File
@@ -9,6 +9,7 @@
<data name="Admin.About.Title" xml:space="preserve"><value>Chronos Server</value></data>
<data name="Admin.About.Uptime" xml:space="preserve"><value>Üzemidő</value></data>
<data name="Admin.About.Version" xml:space="preserve"><value>Verzió</value></data>
<data name="Admin.Activity.ArchiveConverted" xml:space="preserve"><value>{0} várólistára tett egy konvertálást · {1}</value></data>
<data name="Admin.Activity.ArchiveReorganized" xml:space="preserve"><value>{0} átrendezte az archívumot · {1}</value></data>
<data name="Admin.Activity.ArchiveSettings" xml:space="preserve"><value>{0} módosította az archívum szerkezetét</value></data>
<data name="Admin.Activity.FramesDeleted" xml:space="preserve"><value>{0} törölte: {1}</value></data>
@@ -83,6 +84,68 @@
<data name="Admin.Common.TypeToConfirm.Tip" xml:space="preserve"><value>A megerősítéshez írja be a nevet pontosan úgy, ahogy látható</value></data>
<data name="Admin.Common.TypeWord.Tip" xml:space="preserve"><value>Írja be a szót pontosan úgy, ahogy látható; a kis- és nagybetűk nem számítanak</value></data>
<data name="Admin.Common.TypeWordFirst.Tip" xml:space="preserve"><value>Előbb írja be a fenti szót</value></data>
<data name="Admin.Convert.Action" xml:space="preserve"><value>Konvertálás…</value></data>
<data name="Admin.Convert.Action.Tip" xml:space="preserve"><value>JPEG, TIFF-16 vagy lineáris DNG formátumba konvertálja a kijelölt sorozatok fotóit; előbb előnézet mutatja meg az összes sorozatot</value></data>
<data name="Admin.Convert.Apply" xml:space="preserve"><value>Konvertálás…</value></data>
<data name="Admin.Convert.Apply.Tip" xml:space="preserve"><value>Az előnézet szerint konvertál; előbb megerősítést kér</value></data>
<data name="Admin.Convert.Cancel.Tip" xml:space="preserve"><value>Bezárja anélkül, hogy bármit konvertálna</value></data>
<data name="Admin.Convert.ChooseMode" xml:space="preserve"><value>A konvertáláshoz válassza a Csere vagy az Új sorozat módot.</value></data>
<data name="Admin.Convert.ChooseMode.Tip" xml:space="preserve"><value>Előbb válassza a Csere vagy az Új sorozat módot</value></data>
<data name="Admin.Convert.Column.Converted" xml:space="preserve"><value>Konvertálva</value></data>
<data name="Admin.Convert.Column.NotCopied" xml:space="preserve"><value>Nincs másolva</value></data>
<data name="Admin.Convert.Column.Sequence" xml:space="preserve"><value>Sorozat</value></data>
<data name="Admin.Convert.Column.Size" xml:space="preserve"><value>Méret</value></data>
<data name="Admin.Convert.Column.Unchanged" xml:space="preserve"><value>Változatlan</value></data>
<data name="Admin.Convert.Confirm.New" xml:space="preserve"><value>Konvertálás</value></data>
<data name="Admin.Convert.Confirm.New.Tip" xml:space="preserve"><value>Várólistára teszi a feladatot, amely új sorozatokba konvertálja a fotókat, és minden konvertálást ellenőriz; az eredeti fájlokhoz nem nyúl</value></data>
<data name="Admin.Convert.Confirm.Replace" xml:space="preserve"><value>Csere</value></data>
<data name="Admin.Convert.Confirm.Replace.Tip" xml:space="preserve"><value>Várólistára teszi a feladatot, amely konvertálja a fotókat, ellenőrzi az egyes konvertálásokat, és a lomtárba helyezi az eredeti fájlokat</value></data>
<data name="Admin.Convert.ConfirmNew.one" xml:space="preserve"><value>{0} fotóból konvertált másolat készül egy új sorozatban; az eredeti fájl változatlan marad.</value></data>
<data name="Admin.Convert.ConfirmNew.other" xml:space="preserve"><value>{0} fotóból konvertált másolat készül, minden sorozat mellett egy új sorozatban; az eredeti fájlok változatlanok maradnak.</value></data>
<data name="Admin.Convert.ConfirmNewNotCopied.one" xml:space="preserve"><value>{0} fotó nem kerül be az új sorozatba, az előnézetben látható okból.</value></data>
<data name="Admin.Convert.ConfirmNewNotCopied.other" xml:space="preserve"><value>{0} fotó nem kerül be az új sorozatokba, az előnézetben látható okokból.</value></data>
<data name="Admin.Convert.ConfirmNewTitle" xml:space="preserve"><value>Konvertálja {0} formátumba, új sorozatokba?</value></data>
<data name="Admin.Convert.ConfirmReplace.one" xml:space="preserve"><value>{1} {0} fotóját konvertált fájl váltja fel; az eredeti fájl a lomtárba kerül, és a lomtár ürítéséig visszaállítható.</value></data>
<data name="Admin.Convert.ConfirmReplace.other" xml:space="preserve"><value>{1} {0} fotóját konvertált fájl váltja fel; az eredeti fájlok a lomtárba kerülnek, és a lomtár ürítéséig visszaállíthatók.</value></data>
<data name="Admin.Convert.ConfirmReplaceTitle" xml:space="preserve"><value>Lecseréli az eredeti fájlokat {0} formátumú fájlokra?</value></data>
<data name="Admin.Convert.Format" xml:space="preserve"><value>Formátum</value></data>
<data name="Admin.Convert.Format.Jpeg.Tip" xml:space="preserve"><value>8 bites JPEG teljes felbontású színekkel, a mellette beállított minőségben: a legkisebb fájlok, amelyeket minden program megnyit</value></data>
<data name="Admin.Convert.Format.LinearDng" xml:space="preserve"><value>Lineáris DNG</value></data>
<data name="Admin.Convert.Format.LinearDng.Tip" xml:space="preserve"><value>Veszteségmentesen tömörített, 16 bites lineáris DNG: archiváláshoz ajánlott, a RAW-szerkesztők megnyitják</value></data>
<data name="Admin.Convert.Format.Tiff16.Tip" xml:space="preserve"><value>Veszteségmentesen tömörített, 16 bites sRGB TIFF: nagy fájlok, amelyek minden tónust megőriznek a szerkesztéshez</value></data>
<data name="Admin.Convert.Gone" xml:space="preserve"><value>Az egyik kijelölt sorozat már nincs az archívumban; zárja be az ablakot, és jelöljön ki újra.</value></data>
<data name="Admin.Convert.Mode" xml:space="preserve"><value>Mód</value></data>
<data name="Admin.Convert.Mode.NewSequence" xml:space="preserve"><value>Új sorozat</value></data>
<data name="Admin.Convert.Mode.NewSequence.Tip" xml:space="preserve"><value>A konvertált másolatok minden sorozat mellé egy új sorozatba kerülnek; az eredeti fájlok és a sorozatuk pontosan úgy maradnak, ahogy vannak</value></data>
<data name="Admin.Convert.Mode.Replace" xml:space="preserve"><value>Csere</value></data>
<data name="Admin.Convert.Mode.Replace.Tip" xml:space="preserve"><value>A konvertált fájlok lesznek a sorozat fotói; az eredeti fájlok az archívum lomtárába kerülnek, és a lomtár ürítéséig visszaállíthatók</value></data>
<data name="Admin.Convert.NoAnswer" xml:space="preserve"><value>A szerver nem válaszolt: mielőtt újra konvertálna, ellenőrizze a Feladatok oldalon, hogy a konvertálás várólistára került-e.</value></data>
<data name="Admin.Convert.NoSpace.Tip" xml:space="preserve"><value>Előbb szabadítson fel helyet az archívum kötetén</value></data>
<data name="Admin.Convert.NotCopiedCount.one" xml:space="preserve"><value>{0} fotó nincs másolva</value></data>
<data name="Admin.Convert.NotCopiedCount.other" xml:space="preserve"><value>{0} fotó nincs másolva</value></data>
<data name="Admin.Convert.Nothing.Tip" xml:space="preserve"><value>Az előnézetben nincs mit konvertálni</value></data>
<data name="Admin.Convert.NothingToConvert" xml:space="preserve"><value>Nincs mit konvertálni: minden fotó változatlan marad, a látható okokból.</value></data>
<data name="Admin.Convert.OpenJob" xml:space="preserve"><value>Feladat megnyitása</value></data>
<data name="Admin.Convert.OpenJob.Tip" xml:space="preserve"><value>Megjeleníti a feladatot és a naplóját a Feladatok oldalon</value></data>
<data name="Admin.Convert.PlanChanged" xml:space="preserve"><value>Az archívum megváltozott az előnézet óta; ellenőrizze az újat, és alkalmazza újra.</value></data>
<data name="Admin.Convert.Planning" xml:space="preserve"><value>Tervezés…</value></data>
<data name="Admin.Convert.Planning.Tip" xml:space="preserve"><value>A szerver beolvassa a kijelölés összes fotómappáját: nagy archívum esetén ez percekig tart, és az előnézet a végén jelenik meg</value></data>
<data name="Admin.Convert.PlanningFor" xml:space="preserve"><value>Tervezés… {0}</value></data>
<data name="Admin.Convert.Preview" xml:space="preserve"><value>Előnézet</value></data>
<data name="Admin.Convert.Preview.Tip" xml:space="preserve"><value>Az egyes sorozatokban mi konvertálódik és mi marad változatlan, a konvertálás előtti és utáni (becsült) mérettel; még semmi sem változott</value></data>
<data name="Admin.Convert.Quality" xml:space="preserve"><value>Minőség</value></data>
<data name="Admin.Convert.Quality.Tip" xml:space="preserve"><value>JPEG-minőség 1 és 100 között; a 95 megőrzi a finom részleteket, a kisebb értékek kisebb fájlokat adnak</value></data>
<data name="Admin.Convert.QualityRange" xml:space="preserve"><value>Írjon be egy egész számot 1 és 100 között.</value></data>
<data name="Admin.Convert.Queued" xml:space="preserve"><value>Konvertálás várólistára téve.</value></data>
<data name="Admin.Convert.ReplaceWord" xml:space="preserve"><value>csere</value></data>
<data name="Admin.Convert.Size.Tip" xml:space="preserve"><value>A konvertálandó fotók jelenlegi mérete, majd a konvertálás utáni becsült méret</value></data>
<data name="Admin.Convert.SkippedPhotos" xml:space="preserve"><value>{0}: {1}</value></data>
<data name="Admin.Convert.Title.one" xml:space="preserve"><value>{0} sorozat konvertálása</value></data>
<data name="Admin.Convert.Title.other" xml:space="preserve"><value>{0} sorozat konvertálása</value></data>
<data name="Admin.Convert.TitleAll" xml:space="preserve"><value>Az összes sorozat konvertálása</value></data>
<data name="Admin.Convert.TooMany" xml:space="preserve"><value>A konvertálás egyszerre legfeljebb {0} sorozatot kezel, vagy az összeset: törölje a szűrőket, és jelöljön ki mindent.</value></data>
<data name="Admin.Convert.Totals" xml:space="preserve"><value>Konvertált sorozatok: {0} · fotók: {1} · változatlan: {2} · méret: {3} → {4}</value></data>
<data name="Admin.Convert.TotalsNew" xml:space="preserve"><value>Konvertált sorozatok: {0} · fotók: {1} · nincs másolva: {2} · méret: {3} → {4}</value></data>
<data name="Admin.Dashboard.Activity" xml:space="preserve"><value>Legutóbbi tevékenységek</value></data>
<data name="Admin.Dashboard.AllLogs" xml:space="preserve"><value>Összes napló</value></data>
<data name="Admin.Dashboard.AllLogs.Tip" xml:space="preserve"><value>Megnyitja az auditnaplót</value></data>
@@ -133,6 +196,7 @@
<data name="Admin.Job.Kind.Adopt" xml:space="preserve"><value>Átvétel</value></data>
<data name="Admin.Job.Kind.Backup" xml:space="preserve"><value>Biztonsági mentés</value></data>
<data name="Admin.Job.Kind.Cleanup" xml:space="preserve"><value>Tisztítás</value></data>
<data name="Admin.Job.Kind.Convert" xml:space="preserve"><value>Konvertálás</value></data>
<data name="Admin.Job.Kind.DeepAnalyse" xml:space="preserve"><value>Részletes elemzés</value></data>
<data name="Admin.Job.Kind.Duplicates" xml:space="preserve"><value>Duplikátumok</value></data>
<data name="Admin.Job.Kind.EmptyTrash" xml:space="preserve"><value>Lomtár ürítése</value></data>
@@ -344,6 +408,7 @@
<data name="Admin.Login.SignIn.Tip" xml:space="preserve"><value>Bejelentkezés a szerver felügyeletéhez</value></data>
<data name="Admin.Login.User" xml:space="preserve"><value>Felhasználó</value></data>
<data name="Admin.Login.User.Tip" xml:space="preserve"><value>A felhasználóneve ezen a szerveren</value></data>
<data name="Admin.Logs.Action.ArchiveConverted" xml:space="preserve"><value>Fotók konvertálva</value></data>
<data name="Admin.Logs.Action.ArchiveReorganized" xml:space="preserve"><value>Archívum átrendezve</value></data>
<data name="Admin.Logs.Action.ArchiveSettings" xml:space="preserve"><value>Archívum szerkezete</value></data>
<data name="Admin.Logs.Action.FramesDeleted" xml:space="preserve"><value>Fotók törölve</value></data>
@@ -793,6 +858,7 @@
<data name="Admin.Theme.Tip" xml:space="preserve"><value>Vált a világos és a sötét téma között</value></data>
<data name="Admin.Trash.Back" xml:space="preserve"><value>Könyvtár</value></data>
<data name="Admin.Trash.Back.Tip" xml:space="preserve"><value>Vissza a Könyvtárhoz</value></data>
<data name="Admin.Trash.ConversionDeleted" xml:space="preserve"><value>konvertált változat törölve</value></data>
<data name="Admin.Trash.DeletedAt" xml:space="preserve"><value>Törölve</value></data>
<data name="Admin.Trash.DeletedBy" xml:space="preserve"><value>Törölte</value></data>
<data name="Admin.Trash.Emptied" xml:space="preserve"><value>Lomtár kiürítve.</value></data>
@@ -819,9 +885,12 @@
<data name="Admin.Trash.Photos" xml:space="preserve"><value>Fotók</value></data>
<data name="Admin.Trash.Restore" xml:space="preserve"><value>Visszaállítás</value></data>
<data name="Admin.Trash.RestorePhotos.Tip" xml:space="preserve"><value>Visszahelyezi a fotókat a sorozatukba (ha az már nincs meg, egy újba); előbb mindegyiket összeveti az SHA-256 értékével</value></data>
<data name="Admin.Trash.RestoreReplaced.Tip" xml:space="preserve"><value>Visszahelyezi az eredeti fájlokat a konvertált változataik helyére, ha azok változatlanok (a konvertált változatok a lomtárba kerülnek), egyébként egy új sorozatba; előbb mindegyiket összeveti az SHA-256 értékével</value></data>
<data name="Admin.Trash.RestoreSequence.Tip" xml:space="preserve"><value>Változatlanul visszahelyezi a sorozat mappáját a könyvtárba (a régi helye mellé, ha az foglalt); a fotók hash-értékét nem ellenőrzi: erre az Ellenőrzés való</value></data>
<data name="Admin.Trash.RestoredNew.one" xml:space="preserve"><value>{0} fotó visszaállítva egy új sorozatba.</value></data>
<data name="Admin.Trash.RestoredNew.other" xml:space="preserve"><value>{0} fotó visszaállítva egy új sorozatba.</value></data>
<data name="Admin.Trash.RestoredOriginals.one" xml:space="preserve"><value>{0} eredeti fájl visszakerült ide: {1}; a konvertált változata a lomtárban van.</value></data>
<data name="Admin.Trash.RestoredOriginals.other" xml:space="preserve"><value>{0} eredeti fájl visszakerült ide: {1}; a konvertált változataik a lomtárban vannak.</value></data>
<data name="Admin.Trash.RestoredPhotos.one" xml:space="preserve"><value>{0} fotó visszakerült ide: {1}.</value></data>
<data name="Admin.Trash.RestoredPhotos.other" xml:space="preserve"><value>{0} fotó visszakerült ide: {1}.</value></data>
<data name="Admin.Trash.RestoredSequence" xml:space="preserve"><value>{0} visszakerült a könyvtárba.</value></data>
+108 -3
View File
@@ -15,8 +15,10 @@
<data name="Archive.Blocked.Applying" xml:space="preserve"><value>Várja meg, amíg a módosítások érvénybe lépnek.</value></data>
<data name="Archive.Blocked.EmptySet" xml:space="preserve"><value>A halmaz üres: módosítsa a kijelölést vagy a szűrőt.</value></data>
<data name="Archive.Blocked.NoChanges" xml:space="preserve"><value>Semmi sem változna.</value></data>
<data name="Archive.Blocked.NoMode" xml:space="preserve"><value>Válassza a Csere vagy az Új sorozat módot.</value></data>
<data name="Archive.Blocked.NoTemplate" xml:space="preserve"><value>Kapcsoljon be legalább egy sablont.</value></data>
<data name="Archive.Blocked.NotOnline" xml:space="preserve"><value>Az archívumnak elérhetőnek és írhatónak kell lennie.</value></data>
<data name="Archive.Blocked.NothingToConvert" xml:space="preserve"><value>Nincs mit konvertálni: minden fotó kimarad, vagy minden sorozat blokkolva van.</value></data>
<data name="Archive.Blocked.Planning" xml:space="preserve"><value>Várja meg a próbafuttatást.</value></data>
<data name="Archive.Blocked.Reading" xml:space="preserve"><value>Várja meg, amíg az archívum beolvasása befejeződik.</value></data>
<data name="Archive.Blocked.Searching" xml:space="preserve"><value>Keresés van folyamatban; szakítsa meg, vagy várja meg a végét.</value></data>
@@ -32,6 +34,82 @@
<data name="Archive.Confirm.Remove" xml:space="preserve"><value>Sor eltávolítása</value></data>
<data name="Archive.Confirm.RemoveHeading" xml:space="preserve"><value>Eltávolítja a(z) {0} sorozatot az indexből?</value></data>
<data name="Archive.Confirm.RemoveMessage" xml:space="preserve"><value>A kísérőfájlja eltűnt. Csak az indexsort távolítja el; egyetlen fájlt sem töröl.</value></data>
<data name="Archive.Convert.AlreadyQueued" xml:space="preserve"><value>Ezeknek a sorozatoknak a konvertálása már várakozik vagy fut; kövesse a Feladatok között.</value></data>
<data name="Archive.Convert.Blocked.Busy" xml:space="preserve"><value>Egy feladat dolgozik ezen a sorozaton; konvertálja, amikor a feladat befejeződött.</value></data>
<data name="Archive.Convert.Blocked.FramesChanged" xml:space="preserve"><value>A sorozat a terv elkészülte után megváltozott; tekintse át újra a tervet.</value></data>
<data name="Archive.Convert.Blocked.Offline" xml:space="preserve"><value>Az archívum nem érhető el, vagy csak olvasható.</value></data>
<data name="Archive.Convert.Blocked.Unreadable" xml:space="preserve"><value>A sorozatfájl nem olvasható.</value></data>
<data name="Archive.Convert.Confirm" xml:space="preserve"><value>Konvertálás</value></data>
<data name="Archive.Convert.CopyUnfinished" xml:space="preserve"><value>Egy másik konvertálás már készített róla másolatot ebben a formátumban, és nem fejeződött be; előbb fejezze be vagy próbálja újra azt.</value></data>
<data name="Archive.Convert.Done.one" xml:space="preserve"><value>{0:N0} sorozat konvertálva</value></data>
<data name="Archive.Convert.Done.other" xml:space="preserve"><value>{0:N0} sorozat konvertálva</value></data>
<data name="Archive.Convert.Failed.Changed" xml:space="preserve"><value>A fotó már nem egyezik az archivált példánnyal; ellenőrizze a sorozatot.</value></data>
<data name="Archive.Convert.Failed.ColorProfile" xml:space="preserve"><value>A színprofilját ebben a formátumban sem megtartani, sem konvertálni nem lehet.</value></data>
<data name="Archive.Convert.Failed.Damaged" xml:space="preserve"><value>A pixelei olyan értékeket tartalmaznak, amelyek nem számok: a fájl sérült.</value></data>
<data name="Archive.Convert.Failed.EightBit" xml:space="preserve"><value>Ez a számítógép ezt a RAW-fájlt csak 8 biten hívja elő, ami kevés egy 16 bites fájlhoz; JPEG formátumba konvertálható.</value></data>
<data name="Archive.Convert.Failed.Full" xml:space="preserve"><value>Az archívum lemeze megtelt.</value></data>
<data name="Archive.Convert.Failed.NoDecoder" xml:space="preserve"><value>Ezen a számítógépen egyik dekóder sem olvassa be teljes felbontásban.</value></data>
<data name="Archive.Convert.Failed.NotVerified" xml:space="preserve"><value>A konvertált fájl visszaolvasáskor nem egyezett a kiírt tartalommal.</value></data>
<data name="Archive.Convert.Failed.Other" xml:space="preserve"><value>A konvertált fájlt nem sikerült létrehozni.</value></data>
<data name="Archive.Convert.Failed.PreviewOnly" xml:space="preserve"><value>Ez a számítógép csak a beágyazott előnézetéből olvassa be: konvertálja olyan számítógépen, amely teljes felbontásban olvassa.</value></data>
<data name="Archive.Convert.Failed.TooLarge" xml:space="preserve"><value>Nagyobb annál, amit ez a formátum tárolni tud, amit a Chronos vissza tud olvasni, vagy amit az egy fotóra jutó memória befogad.</value></data>
<data name="Archive.Convert.Failed.Unreadable" xml:space="preserve"><value>A fotót nem sikerült dekódolni.</value></data>
<data name="Archive.Convert.Format" xml:space="preserve"><value>Formátum</value></data>
<data name="Archive.Convert.Heading.one" xml:space="preserve"><value>{0:N0} sorozat konvertálása</value></data>
<data name="Archive.Convert.Heading.other" xml:space="preserve"><value>{0:N0} sorozat konvertálása</value></data>
<data name="Archive.Convert.HeadingAll" xml:space="preserve"><value>A(z) {0} archívum konvertálása</value></data>
<data name="Archive.Convert.Mode" xml:space="preserve"><value>Mód</value></data>
<data name="Archive.Convert.NewHeading.one" xml:space="preserve"><value>Új sorozatba konvertálja a(z) {0:N0} sorozatot?</value></data>
<data name="Archive.Convert.NewHeading.other" xml:space="preserve"><value>Új sorozatokba konvertálja a(z) {0:N0} sorozatot?</value></data>
<data name="Archive.Convert.NewLeftOut.one" xml:space="preserve"><value>{0:N0} fotó nem kerül át: csak a forrásában marad, a tervben megadott okból.</value></data>
<data name="Archive.Convert.NewLeftOut.other" xml:space="preserve"><value>{0:N0} fotó nem kerül át: csak a forrásában marad, a tervben megadott okokból.</value></data>
<data name="Archive.Convert.NewMessage" xml:space="preserve"><value>{0} ({1}) {2} formátumba konvertált másolata egy-egy új sorozatba kerül a forrás mellé; az eredeti fájlok változatlanok maradnak.</value></data>
<data name="Archive.Convert.NewSequence" xml:space="preserve"><value>Új sorozat</value></data>
<data name="Archive.Convert.NotCopied.ColorProfile" xml:space="preserve"><value>Azok a fotók, amelyek színprofilját ez a formátum sem megtartani, sem konvertálni nem tudja, nem kerülnek át az új sorozatba.</value></data>
<data name="Archive.Convert.NotCopied.EightBit" xml:space="preserve"><value>Azok a RAW-fotók, amelyeket ez a számítógép csak 8 biten hív elő, nem kerülnek át az új sorozatba; JPEG formátumba konvertálhatók.</value></data>
<data name="Archive.Convert.NotCopied.Inaccessible" xml:space="preserve"><value>Azok a fotók, amelyeket egy másik program nyitva tart, vagy amelyek nem nyithatók meg, nem kerülnek át az új sorozatba; készítsen új tervet, amikor felszabadulnak.</value></data>
<data name="Archive.Convert.NotCopied.Missing" xml:space="preserve"><value>A hiányzó fotók nem kerülnek át az új sorozatba.</value></data>
<data name="Archive.Convert.NotCopied.NoNativeDecoder" xml:space="preserve"><value>Azok a fotók, amelyek formátumát ez a számítógép nem tudja teljes felbontásban olvasni, nem kerülnek át az új sorozatba.</value></data>
<data name="Archive.Convert.NotCopied.PreviewOnly" xml:space="preserve"><value>Azok a fotók, amelyeket itt csak a beágyazott előnézetükből lehet olvasni, nem kerülnek át az új sorozatba.</value></data>
<data name="Archive.Convert.NotCopied.SameFormat" xml:space="preserve"><value>A már ebben a formátumban lévő fotók nem kerülnek át az új sorozatba.</value></data>
<data name="Archive.Convert.NotCopied.TooLarge" xml:space="preserve"><value>Azok a fotók, amelyek nagyobbak annál, amit ez a formátum tárolni tud vagy a Chronos vissza tud olvasni, nem kerülnek át az új sorozatba.</value></data>
<data name="Archive.Convert.NotCopied.Undecodable" xml:space="preserve"><value>Az olvashatatlan fotók nem kerülnek át az új sorozatba.</value></data>
<data name="Archive.Convert.NotCopied.Unhashed" xml:space="preserve"><value>A soha nem ellenőrzött fotók nem kerülnek át az új sorozatba; előbb ellenőrizze a sorozatot.</value></data>
<data name="Archive.Convert.NotCopiedPhotos.one" xml:space="preserve"><value>{0:N0} fotó nincs másolva</value></data>
<data name="Archive.Convert.NotCopiedPhotos.other" xml:space="preserve"><value>{0:N0} fotó nincs másolva</value></data>
<data name="Archive.Convert.NotPlaced" xml:space="preserve"><value>A konvertált fotók nem kerülhettek a helyükre. {0}</value></data>
<data name="Archive.Convert.PhotoFailed" xml:space="preserve"><value>A(z) {0} fájlt nem sikerült konvertálni. {1}</value></data>
<data name="Archive.Convert.PhotoHeld" xml:space="preserve"><value>Egyik fotóját egy másik program nyitva tartja, vagy nem nyitható meg; próbálja újra, amikor felszabadul.</value></data>
<data name="Archive.Convert.Quality" xml:space="preserve"><value>Minőség</value></data>
<data name="Archive.Convert.Replace" xml:space="preserve"><value>Csere</value></data>
<data name="Archive.Convert.ReplaceHeading.one" xml:space="preserve"><value>Lecseréli a(z) {0:N0} sorozat fotóit?</value></data>
<data name="Archive.Convert.ReplaceHeading.other" xml:space="preserve"><value>Lecseréli a(z) {0:N0} sorozat fotóit?</value></data>
<data name="Archive.Convert.ReplaceMessage" xml:space="preserve"><value>{0} ({1}) helyére {2} formátumú konvertált fájl lép; az eredeti fájlok az archívum lomtárába kerülnek, és a lomtár ürítéséig visszaállíthatók.</value></data>
<data name="Archive.Convert.Sizes" xml:space="preserve"><value>{0} → {1}</value></data>
<data name="Archive.Convert.Skipped.ColorProfile" xml:space="preserve"><value>Azok a fotók, amelyek színprofilját ez a formátum sem megtartani, sem konvertálni nem tudja, változatlanok maradnak.</value></data>
<data name="Archive.Convert.Skipped.EightBit" xml:space="preserve"><value>Azok a RAW-fotók, amelyeket ez a számítógép csak 8 biten hív elő, változatlanok maradnak; JPEG formátumba konvertálhatók.</value></data>
<data name="Archive.Convert.Skipped.Inaccessible" xml:space="preserve"><value>Azok a fotók, amelyeket egy másik program nyitva tart, vagy amelyek nem nyithatók meg, változatlanok maradnak; készítsen új tervet, amikor felszabadulnak.</value></data>
<data name="Archive.Convert.Skipped.Missing" xml:space="preserve"><value>A hiányzó fotók változatlanok maradnak.</value></data>
<data name="Archive.Convert.Skipped.NoNativeDecoder" xml:space="preserve"><value>Azok a fotók, amelyek formátumát ez a számítógép nem tudja teljes felbontásban olvasni, változatlanok maradnak.</value></data>
<data name="Archive.Convert.Skipped.PreviewOnly" xml:space="preserve"><value>Azok a fotók, amelyeket itt csak a beágyazott előnézetükből lehet olvasni, változatlanok maradnak.</value></data>
<data name="Archive.Convert.Skipped.SameFormat" xml:space="preserve"><value>A már ebben a formátumban lévő fotók változatlanok maradnak.</value></data>
<data name="Archive.Convert.Skipped.TooLarge" xml:space="preserve"><value>Azok a fotók, amelyek nagyobbak annál, amit ez a formátum tárolni tud vagy a Chronos vissza tud olvasni, változatlanok maradnak.</value></data>
<data name="Archive.Convert.Skipped.Undecodable" xml:space="preserve"><value>Az olvashatatlan fotók változatlanok maradnak.</value></data>
<data name="Archive.Convert.Skipped.Unhashed" xml:space="preserve"><value>A soha nem ellenőrzött fotók változatlanok maradnak; előbb ellenőrizze a sorozatot.</value></data>
<data name="Archive.Convert.SkippedPhotos.one" xml:space="preserve"><value>{0:N0} fotó kihagyva</value></data>
<data name="Archive.Convert.SkippedPhotos.other" xml:space="preserve"><value>{0:N0} fotó kihagyva</value></data>
<data name="Archive.Convert.Space" xml:space="preserve"><value>Szükséges: {0}, szabad: {1}</value></data>
<data name="Archive.Convert.SpaceShort" xml:space="preserve"><value>Szükséges: {0}, csak {1} szabad: előbb szabadítson fel helyet.</value></data>
<data name="Archive.Convert.SpaceUnknown" xml:space="preserve"><value>Szükséges: {0}; a szabad hely nem mérhető.</value></data>
<data name="Archive.Convert.Target.LinearDng" xml:space="preserve"><value>Lineáris DNG</value></data>
<data name="Archive.Convert.Target.Tiff16" xml:space="preserve"><value>TIFF 16 bites</value></data>
<data name="Archive.Convert.UndoFailed" xml:space="preserve"><value>Az eredeti fájlokat nem sikerült visszaállítani</value></data>
<data name="Archive.Convert.UndoNothing" xml:space="preserve"><value>A lecserélt eredeti fájlok már nincsenek a lomtárban.</value></data>
<data name="Archive.Convert.Undone.one" xml:space="preserve"><value>Eredeti fájlok visszaállítva {0:N0} sorozatban</value></data>
<data name="Archive.Convert.Undone.other" xml:space="preserve"><value>Eredeti fájlok visszaállítva {0:N0} sorozatban</value></data>
<data name="Archive.Convert.UndoneNew.one" xml:space="preserve"><value>{0:N0} sorozat időközben megváltozott: az eredeti fájljai új sorozatként kerültek vissza.</value></data>
<data name="Archive.Convert.UndoneNew.other" xml:space="preserve"><value>{0:N0} sorozat időközben megváltozott: az eredeti fájljaik új sorozatokként kerültek vissza.</value></data>
<data name="Archive.Convert.Unstaged" xml:space="preserve"><value>A(z) {0} konvertált változata már nincs az előkészített fájlok között; az újrapróbálkozás ismét konvertálja.</value></data>
<data name="Archive.Copy.Title" xml:space="preserve"><value>Az archívumba másolandó mappa</value></data>
<data name="Archive.Delete.Action" xml:space="preserve"><value>Áthelyezés a lomtárba</value></data>
<data name="Archive.Delete.Blocked" xml:space="preserve"><value>Nincs áthelyezve: {0} · {1}</value></data>
@@ -75,6 +153,9 @@
<data name="Archive.Duplicates.Title" xml:space="preserve"><value>Duplikátumok</value></data>
<data name="Archive.Empty" xml:space="preserve"><value>Még nincs archívum</value></data>
<data name="Archive.Error.Busy" xml:space="preserve"><value>Egy másik Chronos ({0}) éppen ide ír. Próbálja újra hamarosan.</value></data>
<data name="Archive.Error.ConvertKept.one" xml:space="preserve"><value>{0:N0} sorozat terv szerinti konvertálása elmaradt; az okát a feladat naplója tartalmazza.</value></data>
<data name="Archive.Error.ConvertKept.other" xml:space="preserve"><value>{0:N0} sorozat terv szerinti konvertálása elmaradt; az okát a feladat naplója tartalmazza.</value></data>
<data name="Archive.Error.ConvertSpace" xml:space="preserve"><value>A konvertáláshoz {0} szabad hely kell az archívum kötetén, de csak {1} szabad.</value></data>
<data name="Archive.Error.CopyMismatch" xml:space="preserve"><value>A(z) {0} másolata nem egyezik az eredetivel.</value></data>
<data name="Archive.Error.DuplicateLost" xml:space="preserve"><value>{0}: nem adható hozzá a sorozathoz.</value></data>
<data name="Archive.Error.InLibrary" xml:space="preserve"><value>A(z) {0} sorozat már a könyvtárban van.</value></data>
@@ -92,8 +173,8 @@
<data name="Archive.Error.SourceGone" xml:space="preserve"><value>A(z) {0} kártya vagy mappa már nem érhető el.</value></data>
<data name="Archive.Error.StalePlan" xml:space="preserve"><value>Az archívum megváltozott a terv elkészülte óta.</value></data>
<data name="Archive.Error.TrashChanged" xml:space="preserve"><value>A lomtár az ellenőrzés után megváltozott; semmi sem lett törölve.</value></data>
<data name="Archive.Error.TrashKept.one" xml:space="preserve"><value>{0:N0} lomtárbejegyzés megmaradt: megváltozott, vagy egy lecserélt fájl már nem egyezik.</value></data>
<data name="Archive.Error.TrashKept.other" xml:space="preserve"><value>{0:N0} lomtárbejegyzés megmaradt: megváltoztak, vagy egy lecserélt fájl már nem egyezik.</value></data>
<data name="Archive.Error.TrashKept.one" xml:space="preserve"><value>{0:N0} lomtárbejegyzés megmaradt; az okát a feladat naplója tartalmazza.</value></data>
<data name="Archive.Error.TrashKept.other" xml:space="preserve"><value>{0:N0} lomtárbejegyzés megmaradt; az okát a feladat naplója tartalmazza.</value></data>
<data name="Archive.Error.TrashMismatch" xml:space="preserve"><value>Ennek a lomtárbejegyzésnek egyetlen fájlja sem egyezik már a rögzített adataival; a lomtárban marad.</value></data>
<data name="Archive.Failed.Access" xml:space="preserve"><value>A Chronos nem kapott hozzáférést az archívumhoz.</value></data>
<data name="Archive.Failed.Files" xml:space="preserve"><value>Az archívum egyik fájlja nem olvasható vagy nem írható.</value></data>
@@ -132,6 +213,15 @@
<data name="Archive.Log.AuditKept" xml:space="preserve"><value>Az auditnapló teljes egészében megmaradt</value></data>
<data name="Archive.Log.AuditPurged" xml:space="preserve"><value>Eltávolított auditbejegyzések: {0}</value></data>
<data name="Archive.Log.BackupDone" xml:space="preserve"><value>Index átmásolva ide: {0} ({1}); megtartott másolatok: {2}</value></data>
<data name="Archive.Log.ConvertBlocked" xml:space="preserve"><value>Változatlanul hagyva, foglalt vagy olvashatatlan: {0}</value></data>
<data name="Archive.Log.ConvertChanged" xml:space="preserve"><value>Változatlanul hagyva, a terv elkészülte után megváltozott: {0}. Az újrapróbálkozás is változatlanul hagyja: konvertálja újra egy új tervből.</value></data>
<data name="Archive.Log.ConvertDone" xml:space="preserve"><value>Konvertált sorozatok: {0}, új sorozatok: {1}, fotók: {2}</value></data>
<data name="Archive.Log.ConvertFailed" xml:space="preserve"><value>Változatlanul hagyva: {0}. {1}</value></data>
<data name="Archive.Log.ConvertLeftOut" xml:space="preserve"><value>{0}: nem konvertált fotók, csak a forrásban maradtak: {1}</value></data>
<data name="Archive.Log.ConvertNothing" xml:space="preserve"><value>Nincs mit konvertálni: {0}</value></data>
<data name="Archive.Log.ConvertSuperseded" xml:space="preserve"><value>{0}: ennek a konvertálásnak a megerősítése óta egy másik már elkészítette a másolatát ebben a formátumban; második másolat nem készül.</value></data>
<data name="Archive.Log.Converted" xml:space="preserve"><value>{0}: konvertált változatukra cserélt fotók: {1}</value></data>
<data name="Archive.Log.ConvertedNew" xml:space="preserve"><value>{0}: új sorozatba konvertált fotók: {1}</value></data>
<data name="Archive.Log.DryRun" xml:space="preserve"><value>Próbafuttatás: semmi sem változott.</value></data>
<data name="Archive.Log.DuplicateGroup" xml:space="preserve"><value>Fölös másolatok ({0}): {1}</value></data>
<data name="Archive.Log.DuplicatesDone" xml:space="preserve"><value>Duplikátumcsoportok: {0}, fölös másolatok: {1}</value></data>
@@ -166,9 +256,22 @@
<data name="Archive.Log.SequenceMissing" xml:space="preserve"><value>A sorozat nem található: {0}</value></data>
<data name="Archive.Log.StepFailed" xml:space="preserve"><value>A(z) {0} tisztítási lépés sikertelen: {1}</value></data>
<data name="Archive.Log.StepUnknown" xml:space="preserve"><value>Itt ismeretlen tisztítási lépés: {0}</value></data>
<data name="Archive.Log.SyncChanged" xml:space="preserve"><value>{0}: az archiválás óta megváltozott, nincs feltöltve</value></data>
<data name="Archive.Log.SyncDeletedHere" xml:space="preserve"><value>{0}: ezen a számítógépen törölve, nincs letöltve</value></data>
<data name="Archive.Log.SyncDeletedThere" xml:space="preserve"><value>{0}: a szerveren törölve, nincs feltöltve</value></data>
<data name="Archive.Log.SyncFrameChanged" xml:space="preserve"><value>{0}: az itteni képkockája időközben megváltozott, nincs letöltve</value></data>
<data name="Archive.Log.SyncMissing" xml:space="preserve"><value>{0}: hiányzik, nincs feltöltve</value></data>
<data name="Archive.Log.SyncNoPreview.one" xml:space="preserve"><value>{0:N0} képkockának sem proxyja, sem miniatűrje nincs a szerveren</value></data>
<data name="Archive.Log.SyncNoPreview.other" xml:space="preserve"><value>{0:N0} képkockának sem proxyja, sem miniatűrje nincs a szerveren</value></data>
<data name="Archive.Log.TrashEmptied" xml:space="preserve"><value>Véglegesen törölt bejegyzések: {0}, méret: {1}</value></data>
<data name="Archive.Log.TrashEntry" xml:space="preserve"><value>A lomtárban {0} óta: {1} ({2})</value></data>
<data name="Archive.Log.TrashKept" xml:space="preserve"><value>A lomtárban maradt: {0}</value></data>
<data name="Archive.Log.TrashKept" xml:space="preserve"><value>A lomtárban maradt, a terv elkészülte után megváltozott: {0}</value></data>
<data name="Archive.Log.TrashKeptBusy" xml:space="preserve"><value>A lomtárban maradt, mert a sorozata foglalt volt: {0}</value></data>
<data name="Archive.Log.TrashKeptMismatch" xml:space="preserve"><value>A lomtárban maradt, mert az eredeti fájljainak egyik konvertált változata már nem egyezik: {0}</value></data>
<data name="Archive.Log.TrashKeptStaleIndex" xml:space="preserve"><value>A lomtárban maradt, mert az index még felsorolja a sorozatát, amely már nincs az archívumban; építse újra az indexet: {0}</value></data>
<data name="Archive.Log.TrashKeptUnhashed" xml:space="preserve"><value>A lomtárban maradt, mert a sorozatának egyik fotóját soha nem ellenőrizték; ellenőrizze a sorozatot: {0}</value></data>
<data name="Archive.Log.TrashKeptUnknown" xml:space="preserve"><value>A lomtárban maradt, mert az archívum nem mutatja, mi lett az eredeti fájljainak konvertálásával; állítsa vissza, hogy megmaradjanak: {0}</value></data>
<data name="Archive.Log.TrashKeptUnreadable" xml:space="preserve"><value>A lomtárban maradt, mert egy olyan mappa kísérőfájlja, amely a sorozatát tartalmazhatja, hiányzik vagy nem olvasható; vizsgálja át az archívumot: {0}</value></data>
<data name="Archive.Log.TrashOffline" xml:space="preserve"><value>A lomtár nincs ellenőrizve: az archívum nem érhető el</value></data>
<data name="Archive.Log.TrashReport" xml:space="preserve"><value>Régi lomtárbejegyzések: {0}, méret: {1}; semmi sem lett törölve</value></data>
<data name="Archive.Log.VerifyDone" xml:space="preserve"><value>Ellenőrzött fotók: {0}, sértetlen: {1}, új hash-érték: {2}, hibás: {3}</value></data>
@@ -249,6 +352,7 @@
<data name="Archive.Set.All.other" xml:space="preserve"><value>{0:N0} sorozat · mind</value></data>
<data name="Archive.Set.Analyse" xml:space="preserve"><value>Elemzés</value></data>
<data name="Archive.Set.ClearFilter" xml:space="preserve"><value>Szűrő törlése</value></data>
<data name="Archive.Set.Convert" xml:space="preserve"><value>Konvertálás…</value></data>
<data name="Archive.Set.Delete" xml:space="preserve"><value>Törlés…</value></data>
<data name="Archive.Set.Export" xml:space="preserve"><value>CSV exportálása</value></data>
<data name="Archive.Set.Filter" xml:space="preserve"><value>Halmazszűrő</value></data>
@@ -278,6 +382,7 @@
<data name="Archive.Toolbar.Scan" xml:space="preserve"><value>Átvizsgálás</value></data>
<data name="Archive.Toolbar.Verify" xml:space="preserve"><value>Ellenőrzés</value></data>
<data name="Archive.Trash.Checking" xml:space="preserve"><value>Lomtár ellenőrzése…</value></data>
<data name="Archive.Trash.ConversionDeleted" xml:space="preserve"><value>konvertált változat törölve</value></data>
<data name="Archive.Trash.Deleted" xml:space="preserve"><value>Törölve: {0}</value></data>
<data name="Archive.Trash.Empty" xml:space="preserve"><value>A lomtár üres</value></data>
<data name="Archive.Trash.EmptyAction" xml:space="preserve"><value>Ürítés…</value></data>
+1
View File
@@ -69,6 +69,7 @@
<data name="Jobs.Kind.Adopt" xml:space="preserve"><value>Mappa átvétele</value></data>
<data name="Jobs.Kind.Backup" xml:space="preserve"><value>Index biztonsági mentése</value></data>
<data name="Jobs.Kind.Cleanup" xml:space="preserve"><value>Tisztítás</value></data>
<data name="Jobs.Kind.Convert" xml:space="preserve"><value>Konvertálás</value></data>
<data name="Jobs.Kind.DeepAnalyse" xml:space="preserve"><value>Részletes elemzés</value></data>
<data name="Jobs.Kind.Download" xml:space="preserve"><value>Letöltés</value></data>
<data name="Jobs.Kind.Duplicates" xml:space="preserve"><value>Duplikátumok</value></data>
+2
View File
@@ -6,6 +6,7 @@
<resheader name="writer"><value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader>
<data name="Library.Action.Analyse" xml:space="preserve"><value>Elemzés</value></data>
<data name="Library.Action.ClearSelection" xml:space="preserve"><value>Kijelölés törlése</value></data>
<data name="Library.Action.Convert" xml:space="preserve"><value>Konvertálás…</value></data>
<data name="Library.Action.Delete" xml:space="preserve"><value>Törlés…</value></data>
<data name="Library.Action.Download" xml:space="preserve"><value>Letöltés</value></data>
<data name="Library.Action.ExportList" xml:space="preserve"><value>Lista exportálása</value></data>
@@ -32,6 +33,7 @@
<data name="Library.Blocked.NothingToDownload" xml:space="preserve"><value>A kijelölt sorozatokhoz nincs mit letölteni a szerverről.</value></data>
<data name="Library.Blocked.NothingToUpload" xml:space="preserve"><value>A szerveren már megvan minden, ami a kijelölt sorozatokban található.</value></data>
<data name="Library.Blocked.OneArchive" xml:space="preserve"><value>Az átrendezés egyszerre csak egy archívum sorozataival működik.</value></data>
<data name="Library.Blocked.OneArchiveConvert" xml:space="preserve"><value>A konvertálás egyszerre csak egy archívum sorozataival működik.</value></data>
<data name="Library.Blocked.ServerOnly" xml:space="preserve"><value>Csak az ezen a számítógépen lévő sorozatokhoz; a kijelölés a szerveren található.</value></data>
<data name="Library.Blocked.Transferring" xml:space="preserve"><value>Ennek a sorozatnak az átvitele már folyamatban van.</value></data>
<data name="Library.ClearFilters" xml:space="preserve"><value>Szűrők törlése</value></data>
+4
View File
@@ -21,6 +21,8 @@
<data name="Server.Conflict.TakeServer.Message" xml:space="preserve"><value>A(z) {0} beállításait ezen a számítógépen a szerveren lévő példány váltja fel.</value></data>
<data name="Server.Conflict.TakeServer.Title" xml:space="preserve"><value>A szerver beállításait használja?</value></data>
<data name="Server.Connect" xml:space="preserve"><value>Csatlakozás</value></data>
<data name="Server.Convert.OnPc" xml:space="preserve"><value>Ezeket a fotókat számítógépen konvertálja: a szerver nem tudja teljes felbontásban olvasni őket.</value></data>
<data name="Server.Convert.OnPcNew" xml:space="preserve"><value>Nem kerülnek át az új sorozatba: a szerver nem tudja teljes felbontásban olvasni ezeket a fotókat; konvertálja őket számítógépen.</value></data>
<data name="Server.Disconnect" xml:space="preserve"><value>Kapcsolat bontása</value></data>
<data name="Server.Empty" xml:space="preserve"><value>Nincs szerverkapcsolat</value></data>
<data name="Server.Error.AccountLocked" xml:space="preserve"><value>Túl sok sikertelen bejelentkezés; a fiók egy időre zárolva van.</value></data>
@@ -71,7 +73,9 @@
<data name="Server.Error.MethodNotAllowed" xml:space="preserve"><value>Ez a metódus itt nem engedélyezett.</value></data>
<data name="Server.Error.NestedTarget" xml:space="preserve"><value>Egy új mappa egy másik sorozat mappáján belülre kerülne.</value></data>
<data name="Server.Error.NotChronos" xml:space="preserve"><value>Ez a cím nem Chronos Server.</value></data>
<data name="Server.Error.NotEnoughSpace" xml:space="preserve"><value>Az archívum kötetén nincs elég hely a konvertáláshoz.</value></data>
<data name="Server.Error.NotFound" xml:space="preserve"><value>Nem található.</value></data>
<data name="Server.Error.NothingToConvert" xml:space="preserve"><value>A terv semmit sem konvertál: minden fotó kimarad, vagy minden sorozat blokkolva van.</value></data>
<data name="Server.Error.PasswordChangeRequired" xml:space="preserve"><value>Előbb változtassa meg a jelszavát.</value></data>
<data name="Server.Error.PhotoRemoved" xml:space="preserve"><value>A fotót feltöltés közben törölték a sorozatból, ezért nem lett hozzáadva.</value></data>
<data name="Server.Error.PhotoUnreadable" xml:space="preserve"><value>A(z) {0} nem olvasható, és a hash-értéke nélkül a többi másolat nem értesülne a törléséről; zárja be az azt használó programot, vagy ellenőrizze a jogosultságait, majd próbálja újra.</value></data>
+19 -1
View File
@@ -27,6 +27,21 @@
<data name="Tooltips.Archive.ClearFilter" xml:space="preserve"><value>Ismét a kijelölés összes sorozatát mutatja</value></data>
<data name="Tooltips.Archive.CloseDialog" xml:space="preserve"><value>Bezárás módosítás nélkül · Esc</value></data>
<data name="Tooltips.Archive.Collapse" xml:space="preserve"><value>Elrejti ennek az évnek a sorozatait</value></data>
<data name="Tooltips.Archive.ConvertApplyNew" xml:space="preserve"><value>Megerősítés után várólistára tesz egy feladatot, amely másolatokat konvertál új sorozatokba · a Feladatok között szüneteltethető és folytatható</value></data>
<data name="Tooltips.Archive.ConvertApplyReplace" xml:space="preserve"><value>A megerősítéshez írja be a fotók számát; ezután várólistára kerül egy feladat, amely a konvertált változatukra cseréli őket · a Feladatok között szüneteltethető és folytatható</value></data>
<data name="Tooltips.Archive.ConvertBack" xml:space="preserve"><value>Vissza a tervhez; semmi sem konvertálódik</value></data>
<data name="Tooltips.Archive.ConvertDng" xml:space="preserve"><value>Lineáris DNG, 16 bites és veszteségmentes · minden RAW-szerkesztő olvassa; archiváláshoz ajánlott</value></data>
<data name="Tooltips.Archive.ConvertJpeg" xml:space="preserve"><value>8 bites JPEG az alább beállított minőségben · a legkisebb fájlok; némi részlet elvész</value></data>
<data name="Tooltips.Archive.ConvertModeNew" xml:space="preserve"><value>A konvertált másolatok minden sorozat mellé egy új sorozatba kerülnek; az eredeti fájlok változatlanok maradnak</value></data>
<data name="Tooltips.Archive.ConvertModeReplace" xml:space="preserve"><value>A konvertált fájlok a fotók helyére kerülnek a sorozatukban; az eredeti fájlok az archívum lomtárába kerülnek, és a lomtár ürítéséig visszaállíthatók</value></data>
<data name="Tooltips.Archive.ConvertNew" xml:space="preserve"><value>Várólistára teszi a feladatot, amely új sorozatokba konvertálja a fotókat, és minden konvertálást ellenőriz; az eredeti fájlokhoz nem nyúl</value></data>
<data name="Tooltips.Archive.ConvertPlan" xml:space="preserve"><value>Azok a sorozatok, amelyek fotói lecserélődnek</value></data>
<data name="Tooltips.Archive.ConvertPlanNew" xml:space="preserve"><value>Az új sorozatokba másolt sorozatok, és az egyes sorozatokból kimaradó fotók</value></data>
<data name="Tooltips.Archive.ConvertQuality" xml:space="preserve"><value>JPEG-minőség 1 és 100 között · a 95 megőrzi a finom részleteket; a kisebb érték kisebb fájlokat ad</value></data>
<data name="Tooltips.Archive.ConvertReplace.one" xml:space="preserve"><value>Lecseréli a(z) {0:N0} fotót a konvertált változatára; előbb írja be a fenti számot</value></data>
<data name="Tooltips.Archive.ConvertReplace.other" xml:space="preserve"><value>Lecseréli a(z) {0:N0} fotót a konvertált változatára; előbb írja be a fenti számot</value></data>
<data name="Tooltips.Archive.ConvertTiff" xml:space="preserve"><value>Veszteségmentesen tömörített, 16 bites TIFF · nagy fájlok, amelyeket minden szerkesztőprogram megnyit</value></data>
<data name="Tooltips.Archive.ConvertUndo" xml:space="preserve"><value>Visszahelyezi az eredeti fájlokat a lomtárból a konvertált változataik helyére</value></data>
<data name="Tooltips.Archive.DeleteAction.one" xml:space="preserve"><value>A lomtárba helyezi a(z) {0:N0} sorozatot; előbb írja be a fenti számot</value></data>
<data name="Tooltips.Archive.DeleteAction.other" xml:space="preserve"><value>A lomtárba helyezi a(z) {0:N0} sorozatot; előbb írja be a fenti számot</value></data>
<data name="Tooltips.Archive.DeleteKeep" xml:space="preserve"><value>Semmit sem módosít</value></data>
@@ -82,6 +97,7 @@
<data name="Tooltips.Archive.Scan" xml:space="preserve"><value>Növekményes átvizsgálás: új, módosult és eltávolított fájlok a módosítási idő és a méret alapján</value></data>
<data name="Tooltips.Archive.Set" xml:space="preserve"><value>A kijelölt évek és sorozatok (kijelölés nélkül mind), fényképezőgép, állapot vagy címke szerint szűkítve</value></data>
<data name="Tooltips.Archive.SetAnalyse" xml:space="preserve"><value>Részletes elemzést futtat a halmaz minden sorozatán</value></data>
<data name="Tooltips.Archive.SetConvert" xml:space="preserve"><value>JPEG, TIFF vagy DNG formátumba konvertálja a halmaz fotóit · előbb próbafuttatás, aztán feladat</value></data>
<data name="Tooltips.Archive.SetDelete" xml:space="preserve"><value>A halmazt az archívum lomtárába helyezi · előbb próbafuttatást mutat, majd begépelt megerősítést kér</value></data>
<data name="Tooltips.Archive.SetExport" xml:space="preserve"><value>CSV-be exportálja a halmazt: soronként egy sorozat</value></data>
<data name="Tooltips.Archive.SetProxies" xml:space="preserve"><value>Proxykat készít vagy frissít</value></data>
@@ -96,7 +112,7 @@
<data name="Tooltips.Archive.TitleTemplate" xml:space="preserve"><value>Címsablon; a cím helyőrző a jelenlegi címet jelenti · gépelés közben ellenőrizve</value></data>
<data name="Tooltips.Archive.Trash" xml:space="preserve"><value>Az ebből az archívumból törölt sorozatok és fotók, amelyek egyenként visszaállíthatók</value></data>
<data name="Tooltips.Archive.TrashEmpty" xml:space="preserve"><value>Véglegesen törli a lomtár bejegyzéseit, miután ellenőrizte a tartalmukat, és begépelt megerősítést kért</value></data>
<data name="Tooltips.Archive.TrashEmptyPlan" xml:space="preserve"><value>Mi törlődik véglegesen az archívumból</value></data>
<data name="Tooltips.Archive.TrashEmptyPlan" xml:space="preserve"><value>Ami véglegesen törlődik az archívumból; azok az eredeti fájlok, amelyek konvertált változatát törölték, a fotóik utolsó példányai lehetnek</value></data>
<data name="Tooltips.Archive.TrashErase.one" xml:space="preserve"><value>Véglegesen törli a(z) {0:N0} bejegyzést; előbb írja be a fenti számot</value></data>
<data name="Tooltips.Archive.TrashErase.other" xml:space="preserve"><value>Véglegesen törli a(z) {0:N0} bejegyzést; előbb írja be a fenti számot</value></data>
<data name="Tooltips.Archive.TrashRestore" xml:space="preserve"><value>Visszahelyezi ezt a bejegyzést: a sorozatot a mappájába és a könyvtárba, a fotókat hash-ellenőrzés után a sorozatukba</value></data>
@@ -468,6 +484,8 @@
<data name="Tooltips.Library.List" xml:space="preserve"><value>Táblázat rendezhető oszlopokkal</value></data>
<data name="Tooltips.Library.Mass.Analyse.one" xml:space="preserve"><value>{0:N0} sorozat részletes elemzése ezen a számítógépen · egyetlen feladatként fut</value></data>
<data name="Tooltips.Library.Mass.Analyse.other" xml:space="preserve"><value>{0:N0} sorozat részletes elemzése ezen a számítógépen · egyetlen feladatként fut</value></data>
<data name="Tooltips.Library.Mass.Convert.one" xml:space="preserve"><value>JPEG, TIFF vagy DNG formátumba konvertálja {0:N0} sorozat fotóit · előbb próbafuttatás, aztán feladat</value></data>
<data name="Tooltips.Library.Mass.Convert.other" xml:space="preserve"><value>JPEG, TIFF vagy DNG formátumba konvertálja {0:N0} sorozat fotóit a saját archívumukban · előbb próbafuttatás, aztán feladat</value></data>
<data name="Tooltips.Library.Mass.Delete.one" xml:space="preserve"><value>{0:N0} sorozatot az archívuma lomtárába helyez · előbb próbafuttatást mutat, majd begépelt megerősítést kér</value></data>
<data name="Tooltips.Library.Mass.Delete.other" xml:space="preserve"><value>{0:N0} sorozatot az archívumuk lomtárába helyez · előbb próbafuttatást mutat, majd begépelt megerősítést kér</value></data>
<data name="Tooltips.Library.Mass.Download.one" xml:space="preserve"><value>Letölti a szerverről, ami {0:N0} sorozatból itt hiányzik (eredeti vagy renderelt fájlok) · átviteli feladatként fut</value></data>
+69
View File
@@ -9,6 +9,7 @@
<data name="Admin.About.Title" xml:space="preserve"><value>Chronos Server</value></data>
<data name="Admin.About.Uptime" xml:space="preserve"><value>Berjalan selama</value></data>
<data name="Admin.About.Version" xml:space="preserve"><value>Versi</value></data>
<data name="Admin.Activity.ArchiveConverted" xml:space="preserve"><value>{0} mengantrekan konversi · {1}</value></data>
<data name="Admin.Activity.ArchiveReorganized" xml:space="preserve"><value>{0} menata ulang arsip · {1}</value></data>
<data name="Admin.Activity.ArchiveSettings" xml:space="preserve"><value>{0} mengubah tata letak arsip</value></data>
<data name="Admin.Activity.FramesDeleted" xml:space="preserve"><value>{0} menghapus {1}</value></data>
@@ -83,6 +84,68 @@
<data name="Admin.Common.TypeToConfirm.Tip" xml:space="preserve"><value>Ketik nama persis seperti yang ditampilkan untuk mengonfirmasi</value></data>
<data name="Admin.Common.TypeWord.Tip" xml:space="preserve"><value>Ketik kata persis seperti yang ditampilkan; huruf besar atau kecil tidak berpengaruh</value></data>
<data name="Admin.Common.TypeWordFirst.Tip" xml:space="preserve"><value>Ketik kata di atas terlebih dahulu</value></data>
<data name="Admin.Convert.Action" xml:space="preserve"><value>Konversi…</value></data>
<data name="Admin.Convert.Action.Tip" xml:space="preserve"><value>Konversi foto dari sekuens yang dipilih ke JPEG, TIFF-16, atau DNG linear; pratinjau menampilkan setiap sekuens terlebih dahulu</value></data>
<data name="Admin.Convert.Apply" xml:space="preserve"><value>Konversi…</value></data>
<data name="Admin.Convert.Apply.Tip" xml:space="preserve"><value>Konversi seperti yang ditampilkan pratinjau; konfirmasi diminta terlebih dahulu</value></data>
<data name="Admin.Convert.Cancel.Tip" xml:space="preserve"><value>Tutup tanpa mengonversi apa pun</value></data>
<data name="Admin.Convert.ChooseMode" xml:space="preserve"><value>Pilih Ganti atau Sekuens baru untuk mengonversi.</value></data>
<data name="Admin.Convert.ChooseMode.Tip" xml:space="preserve"><value>Pilih Ganti atau Sekuens baru terlebih dahulu</value></data>
<data name="Admin.Convert.Column.Converted" xml:space="preserve"><value>Dikonversi</value></data>
<data name="Admin.Convert.Column.NotCopied" xml:space="preserve"><value>Tidak disalin</value></data>
<data name="Admin.Convert.Column.Sequence" xml:space="preserve"><value>Sekuens</value></data>
<data name="Admin.Convert.Column.Size" xml:space="preserve"><value>Ukuran</value></data>
<data name="Admin.Convert.Column.Unchanged" xml:space="preserve"><value>Tidak berubah</value></data>
<data name="Admin.Convert.Confirm.New" xml:space="preserve"><value>Konversi</value></data>
<data name="Admin.Convert.Confirm.New.Tip" xml:space="preserve"><value>Antrekan tugas yang mengonversi foto ke sekuens baru, dengan setiap konversi diverifikasi; file asli tidak disentuh</value></data>
<data name="Admin.Convert.Confirm.Replace" xml:space="preserve"><value>Ganti</value></data>
<data name="Admin.Convert.Confirm.Replace.Tip" xml:space="preserve"><value>Antrekan tugas yang mengonversi foto, memverifikasi setiap konversi, dan memindahkan file asli ke sampah</value></data>
<data name="Admin.Convert.ConfirmNew.one" xml:space="preserve"><value>{0} foto dikonversi menjadi salinan di sekuens baru; file aslinya tetap seperti semula.</value></data>
<data name="Admin.Convert.ConfirmNew.other" xml:space="preserve"><value>{0} foto dikonversi menjadi salinan di sekuens baru di samping setiap sekuens; file aslinya tetap seperti semula.</value></data>
<data name="Admin.Convert.ConfirmNewNotCopied.one" xml:space="preserve"><value>{0} foto tidak disalin ke sekuens baru, karena alasan yang ditampilkan pratinjau.</value></data>
<data name="Admin.Convert.ConfirmNewNotCopied.other" xml:space="preserve"><value>{0} foto tidak disalin ke sekuens baru, karena alasan yang ditampilkan pratinjau.</value></data>
<data name="Admin.Convert.ConfirmNewTitle" xml:space="preserve"><value>Konversi ke {0} di sekuens baru?</value></data>
<data name="Admin.Convert.ConfirmReplace.one" xml:space="preserve"><value>{0} foto di {1} diganti dengan hasil konversinya; file aslinya dipindahkan ke sampah dan dapat dipulihkan hingga sampah dikosongkan.</value></data>
<data name="Admin.Convert.ConfirmReplace.other" xml:space="preserve"><value>{0} foto di {1} diganti dengan hasil konversinya; file aslinya dipindahkan ke sampah dan dapat dipulihkan hingga sampah dikosongkan.</value></data>
<data name="Admin.Convert.ConfirmReplaceTitle" xml:space="preserve"><value>Ganti file asli dengan {0}?</value></data>
<data name="Admin.Convert.Format" xml:space="preserve"><value>Format</value></data>
<data name="Admin.Convert.Format.Jpeg.Tip" xml:space="preserve"><value>JPEG 8-bit dengan warna beresolusi penuh, pada kualitas yang diatur di sampingnya: file terkecil, dapat dibuka oleh semua program</value></data>
<data name="Admin.Convert.Format.LinearDng" xml:space="preserve"><value>DNG linear</value></data>
<data name="Admin.Convert.Format.LinearDng.Tip" xml:space="preserve"><value>DNG linear 16-bit yang dikompresi secara lossless: pilihan untuk pengarsipan, dapat dibuka oleh editor RAW</value></data>
<data name="Admin.Convert.Format.Tiff16.Tip" xml:space="preserve"><value>TIFF sRGB 16-bit yang dikompresi secara lossless: file besar yang mempertahankan setiap gradasi nada untuk pengeditan</value></data>
<data name="Admin.Convert.Gone" xml:space="preserve"><value>Sekuens yang dipilih sudah tidak ada di arsip; tutup lalu pilih lagi.</value></data>
<data name="Admin.Convert.Mode" xml:space="preserve"><value>Mode</value></data>
<data name="Admin.Convert.Mode.NewSequence" xml:space="preserve"><value>Sekuens baru</value></data>
<data name="Admin.Convert.Mode.NewSequence.Tip" xml:space="preserve"><value>Salinan hasil konversi masuk ke sekuens baru di samping setiap sekuens; file asli dan sekuensnya tetap persis seperti semula</value></data>
<data name="Admin.Convert.Mode.Replace" xml:space="preserve"><value>Ganti</value></data>
<data name="Admin.Convert.Mode.Replace.Tip" xml:space="preserve"><value>File hasil konversi menjadi foto sekuens; file asli dipindahkan ke sampah arsip dan dapat dipulihkan hingga sampah dikosongkan</value></data>
<data name="Admin.Convert.NoAnswer" xml:space="preserve"><value>Server tidak merespons: sebelum mengonversi lagi, periksa di halaman Tugas apakah konversi sudah diantrekan.</value></data>
<data name="Admin.Convert.NoSpace.Tip" xml:space="preserve"><value>Kosongkan sebagian ruang di volume arsip terlebih dahulu</value></data>
<data name="Admin.Convert.NotCopiedCount.one" xml:space="preserve"><value>{0} tidak disalin</value></data>
<data name="Admin.Convert.NotCopiedCount.other" xml:space="preserve"><value>{0} tidak disalin</value></data>
<data name="Admin.Convert.Nothing.Tip" xml:space="preserve"><value>Tidak ada yang dikonversi dalam pratinjau</value></data>
<data name="Admin.Convert.NothingToConvert" xml:space="preserve"><value>Tidak ada yang perlu dikonversi: setiap foto tetap seperti semula, karena alasan yang ditampilkan.</value></data>
<data name="Admin.Convert.OpenJob" xml:space="preserve"><value>Buka tugas</value></data>
<data name="Admin.Convert.OpenJob.Tip" xml:space="preserve"><value>Tampilkan tugas dan log-nya di halaman Tugas</value></data>
<data name="Admin.Convert.PlanChanged" xml:space="preserve"><value>Arsip berubah sejak pratinjau dibuat; periksa pratinjau baru lalu terapkan lagi.</value></data>
<data name="Admin.Convert.Planning" xml:space="preserve"><value>Merencanakan…</value></data>
<data name="Admin.Convert.Planning.Tip" xml:space="preserve"><value>Server membaca setiap folder foto dalam pilihan: arsip besar memerlukan beberapa menit, dan pratinjau muncul setelah selesai</value></data>
<data name="Admin.Convert.PlanningFor" xml:space="preserve"><value>Merencanakan… {0}</value></data>
<data name="Admin.Convert.Preview" xml:space="preserve"><value>Pratinjau</value></data>
<data name="Admin.Convert.Preview.Tip" xml:space="preserve"><value>Apa yang dikonversi dan yang dibiarkan seperti semula di setiap sekuens, dengan ukuran sebelum dan sesudah (perkiraan); belum ada yang berubah</value></data>
<data name="Admin.Convert.Quality" xml:space="preserve"><value>Kualitas</value></data>
<data name="Admin.Convert.Quality.Tip" xml:space="preserve"><value>Kualitas JPEG dari 1 hingga 100; 95 mempertahankan detail halus, nilai lebih rendah menghasilkan file lebih kecil</value></data>
<data name="Admin.Convert.QualityRange" xml:space="preserve"><value>Tulis bilangan bulat dari 1 hingga 100.</value></data>
<data name="Admin.Convert.Queued" xml:space="preserve"><value>Konversi diantrekan.</value></data>
<data name="Admin.Convert.ReplaceWord" xml:space="preserve"><value>ganti</value></data>
<data name="Admin.Convert.Size.Tip" xml:space="preserve"><value>Ukuran foto yang dikonversi saat ini, lalu perkiraan ukuran sesudahnya</value></data>
<data name="Admin.Convert.SkippedPhotos" xml:space="preserve"><value>{0}: {1}</value></data>
<data name="Admin.Convert.Title.one" xml:space="preserve"><value>Konversi {0} sekuens</value></data>
<data name="Admin.Convert.Title.other" xml:space="preserve"><value>Konversi {0} sekuens</value></data>
<data name="Admin.Convert.TitleAll" xml:space="preserve"><value>Konversi semua sekuens</value></data>
<data name="Admin.Convert.TooMany" xml:space="preserve"><value>Konversi menangani paling banyak {0} sekuens sekaligus, atau semua sekuens: bersihkan filter lalu pilih semua.</value></data>
<data name="Admin.Convert.Totals" xml:space="preserve"><value>Sekuens dikonversi: {0} · foto: {1} · tidak berubah: {2} · ukuran: {3} → {4}</value></data>
<data name="Admin.Convert.TotalsNew" xml:space="preserve"><value>Sekuens dikonversi: {0} · foto: {1} · tidak disalin: {2} · ukuran: {3} → {4}</value></data>
<data name="Admin.Dashboard.Activity" xml:space="preserve"><value>Aktivitas terbaru</value></data>
<data name="Admin.Dashboard.AllLogs" xml:space="preserve"><value>Semua log</value></data>
<data name="Admin.Dashboard.AllLogs.Tip" xml:space="preserve"><value>Buka log audit</value></data>
@@ -133,6 +196,7 @@
<data name="Admin.Job.Kind.Adopt" xml:space="preserve"><value>Adopsi</value></data>
<data name="Admin.Job.Kind.Backup" xml:space="preserve"><value>Pencadangan</value></data>
<data name="Admin.Job.Kind.Cleanup" xml:space="preserve"><value>Pembersihan</value></data>
<data name="Admin.Job.Kind.Convert" xml:space="preserve"><value>Konversi</value></data>
<data name="Admin.Job.Kind.DeepAnalyse" xml:space="preserve"><value>Analisis mendalam</value></data>
<data name="Admin.Job.Kind.Duplicates" xml:space="preserve"><value>Duplikat</value></data>
<data name="Admin.Job.Kind.EmptyTrash" xml:space="preserve"><value>Pengosongan sampah</value></data>
@@ -344,6 +408,7 @@
<data name="Admin.Login.SignIn.Tip" xml:space="preserve"><value>Masuk untuk mengelola server ini</value></data>
<data name="Admin.Login.User" xml:space="preserve"><value>Pengguna</value></data>
<data name="Admin.Login.User.Tip" xml:space="preserve"><value>Nama pengguna Anda di server ini</value></data>
<data name="Admin.Logs.Action.ArchiveConverted" xml:space="preserve"><value>Foto dikonversi</value></data>
<data name="Admin.Logs.Action.ArchiveReorganized" xml:space="preserve"><value>Arsip ditata ulang</value></data>
<data name="Admin.Logs.Action.ArchiveSettings" xml:space="preserve"><value>Tata letak arsip</value></data>
<data name="Admin.Logs.Action.FramesDeleted" xml:space="preserve"><value>Foto dihapus</value></data>
@@ -793,6 +858,7 @@
<data name="Admin.Theme.Tip" xml:space="preserve"><value>Beralih antara terang dan gelap</value></data>
<data name="Admin.Trash.Back" xml:space="preserve"><value>Pustaka</value></data>
<data name="Admin.Trash.Back.Tip" xml:space="preserve"><value>Kembali ke Pustaka</value></data>
<data name="Admin.Trash.ConversionDeleted" xml:space="preserve"><value>hasil konversi dihapus</value></data>
<data name="Admin.Trash.DeletedAt" xml:space="preserve"><value>Dihapus</value></data>
<data name="Admin.Trash.DeletedBy" xml:space="preserve"><value>Dihapus oleh</value></data>
<data name="Admin.Trash.Emptied" xml:space="preserve"><value>Sampah dikosongkan.</value></data>
@@ -819,9 +885,12 @@
<data name="Admin.Trash.Photos" xml:space="preserve"><value>Foto</value></data>
<data name="Admin.Trash.Restore" xml:space="preserve"><value>Pulihkan</value></data>
<data name="Admin.Trash.RestorePhotos.Tip" xml:space="preserve"><value>Kembalikan foto ke sekuensnya (sekuens baru jika sudah tidak ada); masing-masing diperiksa terlebih dahulu dengan SHA-256-nya</value></data>
<data name="Admin.Trash.RestoreReplaced.Tip" xml:space="preserve"><value>Kembalikan file asli ke tempat hasil konversinya selama hasil konversi itu tidak berubah (hasil konversi dipindahkan ke sampah), atau ke sekuens baru jika berubah; masing-masing diperiksa terlebih dahulu dengan SHA-256-nya</value></data>
<data name="Admin.Trash.RestoreSequence.Tip" xml:space="preserve"><value>Kembalikan folder sekuens ke pustaka apa adanya (di sebelah tempat lamanya jika tempat itu sudah terisi); hash fotonya tidak diperiksa: itu tugas Verifikasi</value></data>
<data name="Admin.Trash.RestoredNew.one" xml:space="preserve"><value>{0} foto dipulihkan ke sekuens baru.</value></data>
<data name="Admin.Trash.RestoredNew.other" xml:space="preserve"><value>{0} foto dipulihkan ke sekuens baru.</value></data>
<data name="Admin.Trash.RestoredOriginals.one" xml:space="preserve"><value>{0} file asli sudah kembali di {1}; hasil konversinya ada di sampah.</value></data>
<data name="Admin.Trash.RestoredOriginals.other" xml:space="preserve"><value>{0} file asli sudah kembali di {1}; hasil konversinya ada di sampah.</value></data>
<data name="Admin.Trash.RestoredPhotos.one" xml:space="preserve"><value>{0} foto sudah kembali di {1}.</value></data>
<data name="Admin.Trash.RestoredPhotos.other" xml:space="preserve"><value>{0} foto sudah kembali di {1}.</value></data>
<data name="Admin.Trash.RestoredSequence" xml:space="preserve"><value>{0} sudah kembali di pustaka.</value></data>
+108 -3
View File
@@ -15,8 +15,10 @@
<data name="Archive.Blocked.Applying" xml:space="preserve"><value>Tunggu hingga perubahan selesai diterapkan.</value></data>
<data name="Archive.Blocked.EmptySet" xml:space="preserve"><value>Kumpulan ini kosong: ubah pilihan atau filternya.</value></data>
<data name="Archive.Blocked.NoChanges" xml:space="preserve"><value>Tidak ada yang akan berubah.</value></data>
<data name="Archive.Blocked.NoMode" xml:space="preserve"><value>Pilih Ganti atau Sekuens baru.</value></data>
<data name="Archive.Blocked.NoTemplate" xml:space="preserve"><value>Aktifkan setidaknya satu templat.</value></data>
<data name="Archive.Blocked.NotOnline" xml:space="preserve"><value>Arsip harus online dan dapat ditulis.</value></data>
<data name="Archive.Blocked.NothingToConvert" xml:space="preserve"><value>Tidak ada yang perlu dikonversi: setiap foto dilewati atau setiap sekuens diblokir.</value></data>
<data name="Archive.Blocked.Planning" xml:space="preserve"><value>Tunggu hingga uji coba selesai.</value></data>
<data name="Archive.Blocked.Reading" xml:space="preserve"><value>Tunggu hingga arsip selesai dibaca.</value></data>
<data name="Archive.Blocked.Searching" xml:space="preserve"><value>Pencarian sedang berjalan; batalkan atau tunggu.</value></data>
@@ -32,6 +34,82 @@
<data name="Archive.Confirm.Remove" xml:space="preserve"><value>Hapus baris</value></data>
<data name="Archive.Confirm.RemoveHeading" xml:space="preserve"><value>Hapus {0} dari indeks?</value></data>
<data name="Archive.Confirm.RemoveMessage" xml:space="preserve"><value>Sidecar-nya sudah tidak ada. Hanya baris indeks yang dihapus; tidak ada file yang dihapus.</value></data>
<data name="Archive.Convert.AlreadyQueued" xml:space="preserve"><value>Konversi sekuens ini sudah menunggu atau sedang berjalan; pantau di Tugas.</value></data>
<data name="Archive.Convert.Blocked.Busy" xml:space="preserve"><value>Sebuah tugas sedang memproses sekuens ini; konversi sekuens ini setelah tugas itu selesai.</value></data>
<data name="Archive.Convert.Blocked.FramesChanged" xml:space="preserve"><value>Sekuens berubah setelah rencana dibuat; tinjau kembali rencananya.</value></data>
<data name="Archive.Convert.Blocked.Offline" xml:space="preserve"><value>Arsip sedang offline atau hanya-baca.</value></data>
<data name="Archive.Convert.Blocked.Unreadable" xml:space="preserve"><value>File sekuens tidak dapat dibaca.</value></data>
<data name="Archive.Convert.Confirm" xml:space="preserve"><value>Konversi</value></data>
<data name="Archive.Convert.CopyUnfinished" xml:space="preserve"><value>Konversi lain telah membuat salinannya dalam format ini dan belum selesai; selesaikan atau coba lagi konversi itu terlebih dahulu.</value></data>
<data name="Archive.Convert.Done.one" xml:space="preserve"><value>{0:N0} sekuens dikonversi</value></data>
<data name="Archive.Convert.Done.other" xml:space="preserve"><value>{0:N0} sekuens dikonversi</value></data>
<data name="Archive.Convert.Failed.Changed" xml:space="preserve"><value>Foto tidak lagi cocok dengan salinan yang diarsipkan; verifikasi sekuens.</value></data>
<data name="Archive.Convert.Failed.ColorProfile" xml:space="preserve"><value>Profil warnanya tidak dapat dipertahankan maupun dikonversi dalam format ini.</value></data>
<data name="Archive.Convert.Failed.Damaged" xml:space="preserve"><value>Pikselnya berisi nilai yang bukan angka: file rusak.</value></data>
<data name="Archive.Convert.Failed.EightBit" xml:space="preserve"><value>Komputer ini hanya memproses RAW ini pada 8 bit, terlalu sedikit untuk file 16-bit; JPEG dapat mengonversinya.</value></data>
<data name="Archive.Convert.Failed.Full" xml:space="preserve"><value>Disk arsip penuh.</value></data>
<data name="Archive.Convert.Failed.NoDecoder" xml:space="preserve"><value>Tidak ada dekoder di komputer ini yang dapat membacanya dalam resolusi penuh.</value></data>
<data name="Archive.Convert.Failed.NotVerified" xml:space="preserve"><value>File hasil konversi tidak terbaca kembali seperti saat ditulis.</value></data>
<data name="Archive.Convert.Failed.Other" xml:space="preserve"><value>File hasil konversi tidak dapat dibuat.</value></data>
<data name="Archive.Convert.Failed.PreviewOnly" xml:space="preserve"><value>Komputer ini hanya membacanya dari pratinjau tertanamnya: konversi foto ini di PC yang dapat membacanya dalam resolusi penuh.</value></data>
<data name="Archive.Convert.Failed.TooLarge" xml:space="preserve"><value>Foto ini lebih besar daripada yang dapat ditampung format ini, yang dapat dibaca kembali oleh Chronos, atau yang dapat ditampung memori untuk satu foto.</value></data>
<data name="Archive.Convert.Failed.Unreadable" xml:space="preserve"><value>Foto tidak dapat didekode.</value></data>
<data name="Archive.Convert.Format" xml:space="preserve"><value>Format</value></data>
<data name="Archive.Convert.Heading.one" xml:space="preserve"><value>Konversi {0:N0} sekuens</value></data>
<data name="Archive.Convert.Heading.other" xml:space="preserve"><value>Konversi {0:N0} sekuens</value></data>
<data name="Archive.Convert.HeadingAll" xml:space="preserve"><value>Konversi {0}</value></data>
<data name="Archive.Convert.Mode" xml:space="preserve"><value>Mode</value></data>
<data name="Archive.Convert.NewHeading.one" xml:space="preserve"><value>Konversi {0:N0} sekuens menjadi sekuens baru?</value></data>
<data name="Archive.Convert.NewHeading.other" xml:space="preserve"><value>Konversi {0:N0} sekuens menjadi sekuens baru?</value></data>
<data name="Archive.Convert.NewLeftOut.one" xml:space="preserve"><value>{0:N0} foto tidak disalin: foto tersebut tetap hanya ada di sumbernya, karena alasan yang tercantum di rencana.</value></data>
<data name="Archive.Convert.NewLeftOut.other" xml:space="preserve"><value>{0:N0} foto tidak disalin: foto-foto tersebut tetap hanya ada di sumbernya, karena alasan yang tercantum di rencana.</value></data>
<data name="Archive.Convert.NewMessage" xml:space="preserve"><value>{0} ({1}) dikonversi ke {2} ke dalam sekuens baru di samping setiap sumber; file aslinya tetap seperti semula.</value></data>
<data name="Archive.Convert.NewSequence" xml:space="preserve"><value>Sekuens baru</value></data>
<data name="Archive.Convert.NotCopied.ColorProfile" xml:space="preserve"><value>Foto yang profil warnanya tidak dapat dipertahankan maupun dikonversi oleh format ini tidak disalin ke sekuens baru.</value></data>
<data name="Archive.Convert.NotCopied.EightBit" xml:space="preserve"><value>Foto RAW yang hanya diproses komputer ini pada 8 bit tidak disalin ke sekuens baru; JPEG dapat mengonversinya.</value></data>
<data name="Archive.Convert.NotCopied.Inaccessible" xml:space="preserve"><value>Foto yang sedang dibuka program lain, atau yang tidak dapat dibuka, tidak disalin ke sekuens baru; buat rencana lagi setelah foto tersebut bebas.</value></data>
<data name="Archive.Convert.NotCopied.Missing" xml:space="preserve"><value>Foto yang hilang tidak disalin ke sekuens baru.</value></data>
<data name="Archive.Convert.NotCopied.NoNativeDecoder" xml:space="preserve"><value>Foto dalam format yang tidak dapat dibaca komputer ini dalam resolusi penuh tidak disalin ke sekuens baru.</value></data>
<data name="Archive.Convert.NotCopied.PreviewOnly" xml:space="preserve"><value>Foto yang di sini hanya dibaca dari pratinjau tertanamnya tidak disalin ke sekuens baru.</value></data>
<data name="Archive.Convert.NotCopied.SameFormat" xml:space="preserve"><value>Foto yang sudah dalam format ini tidak disalin ke sekuens baru.</value></data>
<data name="Archive.Convert.NotCopied.TooLarge" xml:space="preserve"><value>Foto yang lebih besar daripada yang dapat ditampung format ini atau dibaca kembali oleh Chronos tidak disalin ke sekuens baru.</value></data>
<data name="Archive.Convert.NotCopied.Undecodable" xml:space="preserve"><value>Foto yang tidak terbaca tidak disalin ke sekuens baru.</value></data>
<data name="Archive.Convert.NotCopied.Unhashed" xml:space="preserve"><value>Foto yang belum pernah diverifikasi tidak disalin ke sekuens baru; verifikasi sekuens terlebih dahulu.</value></data>
<data name="Archive.Convert.NotCopiedPhotos.one" xml:space="preserve"><value>{0:N0} tidak disalin</value></data>
<data name="Archive.Convert.NotCopiedPhotos.other" xml:space="preserve"><value>{0:N0} tidak disalin</value></data>
<data name="Archive.Convert.NotPlaced" xml:space="preserve"><value>Foto hasil konversi tidak dapat menempati tempatnya. {0}</value></data>
<data name="Archive.Convert.PhotoFailed" xml:space="preserve"><value>{0} tidak dapat dikonversi. {1}</value></data>
<data name="Archive.Convert.PhotoHeld" xml:space="preserve"><value>Salah satu fotonya sedang dibuka program lain atau tidak dapat dibuka; coba lagi setelah foto itu bebas.</value></data>
<data name="Archive.Convert.Quality" xml:space="preserve"><value>Kualitas</value></data>
<data name="Archive.Convert.Replace" xml:space="preserve"><value>Ganti</value></data>
<data name="Archive.Convert.ReplaceHeading.one" xml:space="preserve"><value>Ganti foto dari {0:N0} sekuens?</value></data>
<data name="Archive.Convert.ReplaceHeading.other" xml:space="preserve"><value>Ganti foto dari {0:N0} sekuens?</value></data>
<data name="Archive.Convert.ReplaceMessage" xml:space="preserve"><value>{0} ({1}) diganti dengan hasil konversinya ke {2}; file aslinya dipindahkan ke sampah arsip dan dapat dipulihkan hingga sampah dikosongkan.</value></data>
<data name="Archive.Convert.Sizes" xml:space="preserve"><value>{0} → {1}</value></data>
<data name="Archive.Convert.Skipped.ColorProfile" xml:space="preserve"><value>Foto yang profil warnanya tidak dapat dipertahankan maupun dikonversi oleh format ini tetap seperti semula.</value></data>
<data name="Archive.Convert.Skipped.EightBit" xml:space="preserve"><value>Foto RAW yang hanya diproses komputer ini pada 8 bit tetap seperti semula; JPEG dapat mengonversinya.</value></data>
<data name="Archive.Convert.Skipped.Inaccessible" xml:space="preserve"><value>Foto yang sedang dibuka program lain, atau yang tidak dapat dibuka, tetap seperti semula; buat rencana lagi setelah foto tersebut bebas.</value></data>
<data name="Archive.Convert.Skipped.Missing" xml:space="preserve"><value>Foto yang hilang tetap seperti semula.</value></data>
<data name="Archive.Convert.Skipped.NoNativeDecoder" xml:space="preserve"><value>Foto dalam format yang tidak dapat dibaca komputer ini dalam resolusi penuh tetap seperti semula.</value></data>
<data name="Archive.Convert.Skipped.PreviewOnly" xml:space="preserve"><value>Foto yang di sini hanya dibaca dari pratinjau tertanamnya tetap seperti semula.</value></data>
<data name="Archive.Convert.Skipped.SameFormat" xml:space="preserve"><value>Foto yang sudah dalam format ini tetap seperti semula.</value></data>
<data name="Archive.Convert.Skipped.TooLarge" xml:space="preserve"><value>Foto yang lebih besar daripada yang dapat ditampung format ini atau dibaca kembali oleh Chronos tetap seperti semula.</value></data>
<data name="Archive.Convert.Skipped.Undecodable" xml:space="preserve"><value>Foto yang tidak terbaca tetap seperti semula.</value></data>
<data name="Archive.Convert.Skipped.Unhashed" xml:space="preserve"><value>Foto yang belum pernah diverifikasi tetap seperti semula; verifikasi sekuens terlebih dahulu.</value></data>
<data name="Archive.Convert.SkippedPhotos.one" xml:space="preserve"><value>{0:N0} dilewati</value></data>
<data name="Archive.Convert.SkippedPhotos.other" xml:space="preserve"><value>{0:N0} dilewati</value></data>
<data name="Archive.Convert.Space" xml:space="preserve"><value>Diperlukan {0}, kosong {1}</value></data>
<data name="Archive.Convert.SpaceShort" xml:space="preserve"><value>Diperlukan {0}, hanya {1} kosong: kosongkan sebagian ruang terlebih dahulu.</value></data>
<data name="Archive.Convert.SpaceUnknown" xml:space="preserve"><value>Diperlukan {0}; ruang kosong tidak dapat diukur.</value></data>
<data name="Archive.Convert.Target.LinearDng" xml:space="preserve"><value>DNG linear</value></data>
<data name="Archive.Convert.Target.Tiff16" xml:space="preserve"><value>TIFF 16-bit</value></data>
<data name="Archive.Convert.UndoFailed" xml:space="preserve"><value>File asli tidak dapat dikembalikan</value></data>
<data name="Archive.Convert.UndoNothing" xml:space="preserve"><value>File asli yang diganti sudah tidak ada di sampah.</value></data>
<data name="Archive.Convert.Undone.one" xml:space="preserve"><value>File asli dikembalikan di {0:N0} sekuens</value></data>
<data name="Archive.Convert.Undone.other" xml:space="preserve"><value>File asli dikembalikan di {0:N0} sekuens</value></data>
<data name="Archive.Convert.UndoneNew.one" xml:space="preserve"><value>{0:N0} sekuens telah berubah sejak itu: file aslinya kembali sebagai sekuens baru.</value></data>
<data name="Archive.Convert.UndoneNew.other" xml:space="preserve"><value>{0:N0} sekuens telah berubah sejak itu: file aslinya kembali sebagai sekuens baru.</value></data>
<data name="Archive.Convert.Unstaged" xml:space="preserve"><value>Hasil konversi {0} tidak lagi ada di antara file yang disiapkan; percobaan ulang akan mengonversinya lagi.</value></data>
<data name="Archive.Copy.Title" xml:space="preserve"><value>Folder yang akan disalin ke arsip</value></data>
<data name="Archive.Delete.Action" xml:space="preserve"><value>Pindahkan ke sampah</value></data>
<data name="Archive.Delete.Blocked" xml:space="preserve"><value>Tidak dipindahkan: {0} · {1}</value></data>
@@ -75,6 +153,9 @@
<data name="Archive.Duplicates.Title" xml:space="preserve"><value>Duplikat</value></data>
<data name="Archive.Empty" xml:space="preserve"><value>Belum ada arsip</value></data>
<data name="Archive.Error.Busy" xml:space="preserve"><value>Chronos lain ({0}) sedang menulis di sini. Coba lagi sebentar lagi.</value></data>
<data name="Archive.Error.ConvertKept.one" xml:space="preserve"><value>{0:N0} sekuens tidak dikonversi sesuai rencana; log tugas menjelaskan alasannya.</value></data>
<data name="Archive.Error.ConvertKept.other" xml:space="preserve"><value>{0:N0} sekuens tidak dikonversi sesuai rencana; log tugas menjelaskan alasannya.</value></data>
<data name="Archive.Error.ConvertSpace" xml:space="preserve"><value>Konversi memerlukan ruang kosong {0} di volume arsip, sedangkan ruang kosong yang ada {1}.</value></data>
<data name="Archive.Error.CopyMismatch" xml:space="preserve"><value>Salinan {0} tidak cocok dengan aslinya.</value></data>
<data name="Archive.Error.DuplicateLost" xml:space="preserve"><value>{0} tidak dapat ditambahkan ke sekuens.</value></data>
<data name="Archive.Error.InLibrary" xml:space="preserve"><value>{0} sudah ada di pustaka.</value></data>
@@ -92,8 +173,8 @@
<data name="Archive.Error.SourceGone" xml:space="preserve"><value>Kartu atau folder {0} tidak lagi tersedia.</value></data>
<data name="Archive.Error.StalePlan" xml:space="preserve"><value>Arsip berubah setelah rencana ini dibuat.</value></data>
<data name="Archive.Error.TrashChanged" xml:space="preserve"><value>Sampah berubah setelah diperiksa; tidak ada yang dihapus.</value></data>
<data name="Archive.Error.TrashKept.one" xml:space="preserve"><value>{0:N0} entri sampah dipertahankan: entri itu berubah, atau file penggantinya tidak lagi cocok.</value></data>
<data name="Archive.Error.TrashKept.other" xml:space="preserve"><value>{0:N0} entri sampah dipertahankan: entri itu berubah, atau file penggantinya tidak lagi cocok.</value></data>
<data name="Archive.Error.TrashKept.one" xml:space="preserve"><value>{0:N0} entri sampah dipertahankan; log tugas menjelaskan alasannya.</value></data>
<data name="Archive.Error.TrashKept.other" xml:space="preserve"><value>{0:N0} entri sampah dipertahankan; log tugas menjelaskan alasannya.</value></data>
<data name="Archive.Error.TrashMismatch" xml:space="preserve"><value>Tidak ada file dari entri sampah ini yang masih cocok dengan catatannya; entri ini tetap di sampah.</value></data>
<data name="Archive.Failed.Access" xml:space="preserve"><value>Akses Chronos ke arsip ditolak.</value></data>
<data name="Archive.Failed.Files" xml:space="preserve"><value>Sebuah file arsip tidak dapat dibaca atau ditulis.</value></data>
@@ -132,6 +213,15 @@
<data name="Archive.Log.AuditKept" xml:space="preserve"><value>Log audit disimpan seluruhnya</value></data>
<data name="Archive.Log.AuditPurged" xml:space="preserve"><value>Entri audit dihapus: {0}</value></data>
<data name="Archive.Log.BackupDone" xml:space="preserve"><value>Indeks disalin ke {0} ({1}); salinan disimpan: {2}</value></data>
<data name="Archive.Log.ConvertBlocked" xml:space="preserve"><value>Dibiarkan seperti semula, sibuk atau tidak terbaca: {0}</value></data>
<data name="Archive.Log.ConvertChanged" xml:space="preserve"><value>Dibiarkan seperti semula, berubah setelah rencana dibuat: {0}. Percobaan ulang tetap membiarkannya apa adanya: konversi lagi dari rencana baru.</value></data>
<data name="Archive.Log.ConvertDone" xml:space="preserve"><value>Sekuens dikonversi: {0}, sekuens baru: {1}, foto: {2}</value></data>
<data name="Archive.Log.ConvertFailed" xml:space="preserve"><value>Dibiarkan seperti semula: {0}. {1}</value></data>
<data name="Archive.Log.ConvertLeftOut" xml:space="preserve"><value>{0}: foto tidak dikonversi, tetap hanya ada di sumber: {1}</value></data>
<data name="Archive.Log.ConvertNothing" xml:space="preserve"><value>Tidak ada yang perlu dikonversi: {0}</value></data>
<data name="Archive.Log.ConvertSuperseded" xml:space="preserve"><value>{0}: sejak konversi ini dikonfirmasi, konversi lain telah membuat salinannya dalam format ini; salinan kedua tidak dibuat.</value></data>
<data name="Archive.Log.Converted" xml:space="preserve"><value>{0}: foto diganti dengan hasil konversinya: {1}</value></data>
<data name="Archive.Log.ConvertedNew" xml:space="preserve"><value>{0}: foto dikonversi ke sekuens baru: {1}</value></data>
<data name="Archive.Log.DryRun" xml:space="preserve"><value>Uji coba: tidak ada yang diubah.</value></data>
<data name="Archive.Log.DuplicateGroup" xml:space="preserve"><value>Salinan tambahan dari {0}: {1}</value></data>
<data name="Archive.Log.DuplicatesDone" xml:space="preserve"><value>Grup duplikat: {0}, salinan tambahan: {1}</value></data>
@@ -166,9 +256,22 @@
<data name="Archive.Log.SequenceMissing" xml:space="preserve"><value>Sekuens tidak ditemukan: {0}</value></data>
<data name="Archive.Log.StepFailed" xml:space="preserve"><value>Langkah pembersihan {0} gagal: {1}</value></data>
<data name="Archive.Log.StepUnknown" xml:space="preserve"><value>Langkah pembersihan tidak dikenal di sini: {0}</value></data>
<data name="Archive.Log.SyncChanged" xml:space="preserve"><value>{0}: berubah sejak diarsipkan, tidak diunggah</value></data>
<data name="Archive.Log.SyncDeletedHere" xml:space="preserve"><value>{0}: dihapus di PC ini, tidak diunduh</value></data>
<data name="Archive.Log.SyncDeletedThere" xml:space="preserve"><value>{0}: dihapus di server, tidak diunggah</value></data>
<data name="Archive.Log.SyncFrameChanged" xml:space="preserve"><value>{0}: bingkainya di sini berubah sementara itu, tidak diunduh</value></data>
<data name="Archive.Log.SyncMissing" xml:space="preserve"><value>{0}: hilang, tidak diunggah</value></data>
<data name="Archive.Log.SyncNoPreview.one" xml:space="preserve"><value>{0:N0} bingkai tidak memiliki proksi maupun gambar mini di server</value></data>
<data name="Archive.Log.SyncNoPreview.other" xml:space="preserve"><value>{0:N0} bingkai tidak memiliki proksi maupun gambar mini di server</value></data>
<data name="Archive.Log.TrashEmptied" xml:space="preserve"><value>Entri dihapus: {0}, ukuran: {1}</value></data>
<data name="Archive.Log.TrashEntry" xml:space="preserve"><value>Di sampah sejak {0}: {1} ({2})</value></data>
<data name="Archive.Log.TrashKept" xml:space="preserve"><value>Dipertahankan di sampah: {0}</value></data>
<data name="Archive.Log.TrashKept" xml:space="preserve"><value>Dipertahankan di sampah, berubah setelah rencana dibuat: {0}</value></data>
<data name="Archive.Log.TrashKeptBusy" xml:space="preserve"><value>Dipertahankan di sampah, sekuensnya sedang sibuk: {0}</value></data>
<data name="Archive.Log.TrashKeptMismatch" xml:space="preserve"><value>Dipertahankan di sampah, salah satu hasil konversi file aslinya tidak lagi cocok: {0}</value></data>
<data name="Archive.Log.TrashKeptStaleIndex" xml:space="preserve"><value>Dipertahankan di sampah, indeks mencantumkan sekuensnya, yang tidak lagi ada di arsip; bangun ulang indeks: {0}</value></data>
<data name="Archive.Log.TrashKeptUnhashed" xml:space="preserve"><value>Dipertahankan di sampah, salah satu foto sekuensnya belum pernah diverifikasi; verifikasi sekuens: {0}</value></data>
<data name="Archive.Log.TrashKeptUnknown" xml:space="preserve"><value>Dipertahankan di sampah, arsip tidak menunjukkan apa yang terjadi pada konversi file aslinya; pulihkan untuk mempertahankannya: {0}</value></data>
<data name="Archive.Log.TrashKeptUnreadable" xml:space="preserve"><value>Dipertahankan di sampah, file sidecar dari folder yang mungkin berisi sekuensnya hilang atau tidak dapat dibaca; pindai arsip: {0}</value></data>
<data name="Archive.Log.TrashOffline" xml:space="preserve"><value>Sampah tidak diperiksa: arsip tidak dapat dijangkau</value></data>
<data name="Archive.Log.TrashReport" xml:space="preserve"><value>Entri sampah lama: {0}, ukuran: {1}; tidak ada yang dihapus</value></data>
<data name="Archive.Log.VerifyDone" xml:space="preserve"><value>Foto diperiksa: {0}, utuh: {1}, hash dihitung: {2}, bermasalah: {3}</value></data>
@@ -249,6 +352,7 @@
<data name="Archive.Set.All.other" xml:space="preserve"><value>{0:N0} sekuens · semua</value></data>
<data name="Archive.Set.Analyse" xml:space="preserve"><value>Analisis</value></data>
<data name="Archive.Set.ClearFilter" xml:space="preserve"><value>Bersihkan filter</value></data>
<data name="Archive.Set.Convert" xml:space="preserve"><value>Konversi…</value></data>
<data name="Archive.Set.Delete" xml:space="preserve"><value>Hapus…</value></data>
<data name="Archive.Set.Export" xml:space="preserve"><value>Ekspor CSV</value></data>
<data name="Archive.Set.Filter" xml:space="preserve"><value>Filter kumpulan</value></data>
@@ -278,6 +382,7 @@
<data name="Archive.Toolbar.Scan" xml:space="preserve"><value>Pindai</value></data>
<data name="Archive.Toolbar.Verify" xml:space="preserve"><value>Verifikasi</value></data>
<data name="Archive.Trash.Checking" xml:space="preserve"><value>Memeriksa sampah…</value></data>
<data name="Archive.Trash.ConversionDeleted" xml:space="preserve"><value>hasil konversi dihapus</value></data>
<data name="Archive.Trash.Deleted" xml:space="preserve"><value>Dihapus pada {0}</value></data>
<data name="Archive.Trash.Empty" xml:space="preserve"><value>Tidak ada sekuens di sampah</value></data>
<data name="Archive.Trash.EmptyAction" xml:space="preserve"><value>Kosongkan…</value></data>
+1
View File
@@ -69,6 +69,7 @@
<data name="Jobs.Kind.Adopt" xml:space="preserve"><value>Adopsi folder</value></data>
<data name="Jobs.Kind.Backup" xml:space="preserve"><value>Pencadangan indeks</value></data>
<data name="Jobs.Kind.Cleanup" xml:space="preserve"><value>Pembersihan</value></data>
<data name="Jobs.Kind.Convert" xml:space="preserve"><value>Konversi</value></data>
<data name="Jobs.Kind.DeepAnalyse" xml:space="preserve"><value>Analisis mendalam</value></data>
<data name="Jobs.Kind.Download" xml:space="preserve"><value>Unduhan</value></data>
<data name="Jobs.Kind.Duplicates" xml:space="preserve"><value>Duplikat</value></data>
+2
View File
@@ -6,6 +6,7 @@
<resheader name="writer"><value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader>
<data name="Library.Action.Analyse" xml:space="preserve"><value>Analisis</value></data>
<data name="Library.Action.ClearSelection" xml:space="preserve"><value>Bersihkan pilihan</value></data>
<data name="Library.Action.Convert" xml:space="preserve"><value>Konversi…</value></data>
<data name="Library.Action.Delete" xml:space="preserve"><value>Hapus…</value></data>
<data name="Library.Action.Download" xml:space="preserve"><value>Unduh</value></data>
<data name="Library.Action.ExportList" xml:space="preserve"><value>Ekspor daftar</value></data>
@@ -32,6 +33,7 @@
<data name="Library.Blocked.NothingToDownload" xml:space="preserve"><value>Tidak ada yang perlu diambil dari server untuk sekuens yang dipilih.</value></data>
<data name="Library.Blocked.NothingToUpload" xml:space="preserve"><value>Server sudah memiliki semua isi sekuens yang dipilih.</value></data>
<data name="Library.Blocked.OneArchive" xml:space="preserve"><value>Penataan ulang hanya dapat dilakukan pada sekuens dari satu arsip dalam satu waktu.</value></data>
<data name="Library.Blocked.OneArchiveConvert" xml:space="preserve"><value>Konversi hanya dapat dilakukan pada sekuens dari satu arsip dalam satu waktu.</value></data>
<data name="Library.Blocked.ServerOnly" xml:space="preserve"><value>Hanya untuk sekuens di PC ini; pilihan ini berada di server.</value></data>
<data name="Library.Blocked.Transferring" xml:space="preserve"><value>Transfer sekuens ini sudah berlangsung.</value></data>
<data name="Library.ClearFilters" xml:space="preserve"><value>Bersihkan filter</value></data>
Loaded 100 of 354 files, more files were not shown because too many files have changed in this diff. Show more