From d48420485f521c73b862397bbb1ccde7a407b022 Mon Sep 17 00:00:00 2001 From: rouggy Date: Fri, 21 Aug 2026 23:28:55 +0200 Subject: [PATCH] chore: release v0.26.3 --- app.go | 209 +++++++++++++---- awardnew.go | 235 +++++++++++++++++++ awardnew_test.go | 22 ++ changelog.json | 36 +++ flexzoom.go | 122 ++++++++++ flexzoom_test.go | 32 +++ frontend/src/App.tsx | 27 ++- frontend/src/components/AwardRefSelector.tsx | 41 +++- frontend/src/components/BandMap.tsx | 65 +++-- frontend/src/components/ChaseNewPanel.tsx | 1 + frontend/src/components/ClusterGrid.tsx | 34 ++- frontend/src/components/DecodesPanel.tsx | 3 + frontend/src/components/SettingsModal.tsx | 219 ++++++++++++++--- frontend/src/components/StatsPanel.tsx | 17 +- frontend/src/lib/autocall.ts | 7 +- frontend/src/lib/i18n.tsx | 35 +-- frontend/src/version.ts | 2 +- frontend/wailsjs/go/main/App.d.ts | 14 ++ frontend/wailsjs/go/main/App.js | 28 +++ frontend/wailsjs/go/models.ts | 88 +++++++ internal/cat/cat.go | 25 +- internal/cat/flex.go | 143 ++++++++++- internal/cat/flex_test.go | 34 +++ internal/qso/lastnewdxcc_test.go | 54 +++++ internal/qso/stats.go | 48 ++++ internal/ultrabeam/transport_test.go | 57 +++++ internal/ultrabeam/ultrabeam.go | 112 +++++++-- spotcolors.go | 225 ++++++++++++++++++ spotcolors_test.go | 76 ++++++ spotstatus_test.go | 59 +++++ telemetry.go | 2 +- 31 files changed, 1908 insertions(+), 164 deletions(-) create mode 100644 awardnew.go create mode 100644 awardnew_test.go create mode 100644 flexzoom.go create mode 100644 flexzoom_test.go create mode 100644 internal/cat/flex_test.go create mode 100644 internal/qso/lastnewdxcc_test.go create mode 100644 internal/ultrabeam/transport_test.go create mode 100644 spotcolors.go create mode 100644 spotcolors_test.go create mode 100644 spotstatus_test.go diff --git a/app.go b/app.go index 000d4af..3eccf35 100644 --- a/app.go +++ b/app.go @@ -794,6 +794,10 @@ type App struct { catFlexDVKDax bool // raise the Flex transmit DAX button around a voice message catFlexDecodeSpots bool // push WSJT-X decodes (heard stations) to the panadapter catFlexDecodeSecs int // decode spot display duration (seconds) + // The panadapter palette, parsed once and re-read when it is saved. Guarded + // because the cluster read loop touches it on every spot. + spotColorsMu sync.Mutex + spotColorsCache *SpotColors // catSig / catShareSig fingerprint the last APPLIED link and share // configuration, so re-applying an identical one is a no-op instead of a // reconnection. Empty at startup, which is what makes the first call connect. @@ -803,19 +807,21 @@ type App struct { liveFreqHz int64 // last freq/band/mode the UI reported (fallback when CAT is off) liveBand string liveMode string - livePublishTimer *time.Timer // debounced live-status publish on activity change - liveLastQSOAt time.Time // when this operator last logged a NEW contact — drives online/offline - liveTableMu sync.Mutex // guards liveTableFor - liveTableFor *sql.DB // logbook whose live_status DDL has been ensured (once per connection, not per call) - awardSnapMu sync.Mutex // guards the award QSO snapshot - awardSnapBuild sync.Mutex // serialises BUILDING it — see awardSnapshot - awardSnapCap int // rows the last build produced, the capacity hint for the next - awardSnap []qso.QSO // light-scanned + enriched logbook snapshot reused across award computations - awardSnapRev string // logbook revision the snapshot was built at ("" = none) - awardSnapUsed time.Time // last read — the snapshot is dropped once it goes cold (see awardSnapshotJanitor) - webpub webPublisher // log-to-website publishing: debounce timer, periodic ticker, last result - bandOpen bandOpenState // sporadic-E / band-opening detector over the spot stream - dataDir string // /data — holds config.json, logs, cty.dat + livePublishTimer *time.Timer // debounced live-status publish on activity change + liveLastQSOAt time.Time // when this operator last logged a NEW contact — drives online/offline + liveTableMu sync.Mutex // guards liveTableFor + liveTableFor *sql.DB // logbook whose live_status DDL has been ensured (once per connection, not per call) + awardSnapMu sync.Mutex // guards the award QSO snapshot + awardSnapBuild sync.Mutex // serialises BUILDING it — see awardSnapshot + awardSnapCap int // rows the last build produced, the capacity hint for the next + awardSnap []qso.QSO // light-scanned + enriched logbook snapshot reused across award computations + awardSnapRev string // logbook revision the snapshot was built at ("" = none) + awardSnapUsed time.Time // last read — the snapshot is dropped once it goes cold (see awardSnapshotJanitor) + workedRefMu sync.Mutex // guards the worked-reference sets + workedRef workedRefIndex // per-award references already in the log — see awardnew.go + webpub webPublisher // log-to-website publishing: debounce timer, periodic ticker, last result + bandOpen bandOpenState // sporadic-E / band-opening detector over the spot stream + dataDir string // /data — holds config.json, logs, cty.dat // shuttingDown gates beforeClose re-entry: the first user attempt to // close fires shutdown tasks (backup, future LoTW upload, ...) while @@ -4734,6 +4740,9 @@ func (a *App) invalidateAwardStats() { a.qsoNumMu.Lock() a.qsoNumbers = nil a.qsoNumMu.Unlock() + // Reference lists, award definitions and bulk edits all land here, and any of + // them can change what counts as already worked. + a.invalidateWorkedRefs() // Bulk QSO changes (import, delete, bulk edit) also land here — refresh the // worked-index so alert "needed" checks stay accurate. Async: never block the // mutation, and it's a single lightweight query. @@ -5113,9 +5122,14 @@ func (a *App) materializeAwardRefs(q qso.QSO) { return } ac := a.newAwardMatCtx() - if err := a.qso.SetAwardRefs(a.ctx, q.ID, a.awardRefsJSONFor(ac, q)); err != nil { + refs := a.awardRefsJSONFor(ac, q) + if err := a.qso.SetAwardRefs(a.ctx, q.ID, refs); err != nil { applog.Printf("award_refs: store for qso %d failed: %v", q.ID, err) } + // Keep the NEW-badge sets in step with the contact just logged, rather than + // letting the revision change discard them while the operator types the next + // callsign. Off the logging path: it re-matches the QSO against every award. + go a.noteWorkedQSO(q) } // materializeAwardRefsForIDs recomputes award_refs for a specific set of QSOs @@ -8681,11 +8695,20 @@ func (a *App) clusterEventWorker() { // panadapter tunes AND switches mode — a DX cluster line carries no mode, // so without this the radio only moved frequency. if a.catFlexSpots && a.cat != nil { + mode := alerts.InferMode(s.Comment, s.FreqHz) + // Coloured by what the spot IS, which is the only thing worth knowing + // at a glance on a waterfall. Resolved from the same index the cluster + // grid uses, so a spot is never one colour on screen and another on + // the radio — and the index is cached, so this costs a map lookup. + status := a.spotStatusName(s.DXCall, s.Band, mode, s.POTARef) + col := a.spotColorFor(status) a.cat.SendSpot(cat.SpotInfo{ - FreqHz: s.FreqHz, - Callsign: s.DXCall, - Mode: alerts.InferMode(s.Comment, s.FreqHz), - Comment: s.Comment, + FreqHz: s.FreqHz, + Callsign: s.DXCall, + Mode: mode, + Comment: spotComment(s.Comment, status), + Color: col.Text, + BackgroundColor: col.Bg, }) } } @@ -14850,10 +14873,14 @@ func (a *App) reloadCAT() { // Native FlexRadio (SmartSDR) TCP API — no OmniRig needed. fb := cat.NewFlex(s.FlexHost, s.FlexPort, s.FlexSpots) // Clicking one of our spots on the panadapter fills the entry form. - fb.OnSpotClick = func(call string, hz int64) { + fb.OnSpotClick = func(call string, hz int64, mode string) { if a.ctx != nil { wruntime.EventsEmit(a.ctx, "flex:spot_clicked", map[string]any{"call": call, "freq_hz": hz}) } + // A spot clicked ON the panadapter deserves the same zoom as one + // clicked in the band map: the operator did the same thing and is + // looking at the same signal, and only the click's origin differs. + a.FlexZoomForSpot(mode, hz) } a.cat.Start(fb) case "xiegu": @@ -16512,11 +16539,17 @@ func newMotorClient(s UltrabeamSettings) motorAntenna { } return steppirAdapter{c: steppir.New(tr), freqMin: s.FreqMinMHz, freqMax: s.FreqMaxMHz} } - // Ultrabeam is TCP only. - if strings.TrimSpace(s.Host) == "" { + // Ultrabeam: serial or TCP, same as the SteppIR. The controller has an RS232 + // port, so a plain FTDI cable is the direct route; the Ethernet adapter is + // for putting the antenna at the far end of a link. + tr := ultrabeam.Transport{Mode: s.Transport, Host: strings.TrimSpace(s.Host), Port: s.Port, COM: strings.TrimSpace(s.COM), Baud: s.Baud} + if tr.Mode == "serial" && tr.COM == "" { return nil } - return ubAdapter{c: ultrabeam.New(s.Host, s.Port), freqMin: s.FreqMinMHz, freqMax: s.FreqMaxMHz} + if tr.Mode != "serial" && tr.Host == "" { + return nil + } + return ubAdapter{c: ultrabeam.New(tr), freqMin: s.FreqMinMHz, freqMax: s.FreqMaxMHz} } // startUltrabeam stops any existing client and starts a fresh one if the @@ -18795,12 +18828,19 @@ type SpotQuery struct { // SpotStatus is the per-tuple result. Status is one of: // -// "new" — entity never worked -// "new-band" — entity worked but never on this band -// "new-mode" — band worked, but this MODE never worked on the entity (any band) -// "new-slot" — band & mode each worked before, but not this band+mode together -// "worked" — exact band+mode already in the log -// "" — couldn't resolve the entity (no cty.dat match) +// "new" — entity never worked +// "new-band-mode" — entity worked, but neither this band NOR this mode +// "new-band" — entity worked in this mode, never on this band +// "new-mode" — band worked, but this MODE never worked on the entity (any band) +// "new-slot" — band & mode each worked before, but not this band+mode together +// "worked" — exact band+mode already in the log +// "" — couldn't resolve the entity (no cty.dat match) +// +// They are EXCLUSIVE and tested in that order, from most wanted to least. The +// distinction that matters and used to be missing: an entity that is new on +// both counts is not the same catch as one that is new on the band alone, and +// neither is a "slot" — a slot is the pair still missing when each half is +// already in the log. type SpotStatus struct { Call string `json:"call"` Band string `json:"band"` @@ -19193,6 +19233,88 @@ func (a *App) lookupDecodeGrid(call string) string { return a.decodeGridsOld[call] } +// spotEntityStatus decides ONE spot's status from what the entity already has +// in the log. Pure, and separate from the query that feeds it, because the +// ORDER of these tests is the whole meaning of the answer and it deserves to be +// read — and tested — without a database. +// +// Most wanted first, exclusive: +// +// new the entity has never been worked at all +// new-band-mode worked, but neither this band nor this mode +// new-band worked in this mode, never on this band +// new-mode worked on this band, never in this mode (on any band) +// new-slot both halves already in the log, never this pair +// worked this exact band and mode +// +// new-band-mode is NOT a slot, and that is the distinction that was missing: +// a slot is the pair still missing when each half is already worked. A station +// that is new on both counts is a better catch than either, and it used to be +// reported as a plain "new band". +func spotEntityStatus(entityWorked, haveBand, haveMode, haveSlot bool, mode string) string { + if !entityWorked { + return "new" + } + // Without a mode nothing below "band" can be told apart from worked, and + // claiming "new" on a guess is the one mistake that costs a QSO. + if mode == "" { + if !haveBand { + return "new-band" + } + return "worked" + } + switch { + case !haveBand && !haveMode: + return "new-band-mode" + case !haveBand: + return "new-band" + case !haveMode: + return "new-mode" + case !haveSlot: + return "new-slot" + } + return "worked" +} + +// spotStatusName resolves ONE spot to the palette key it should be drawn with. +// +// The entity status first — it is the headline — then the orthogonal markers, +// which only speak when the entity says nothing new: a park is worth a colour +// on a station you have already worked, and worth nothing on one you have not, +// where "new entity" is the better thing to say. +func (a *App) spotStatusName(call, band, mode, potaRef string) string { + if a.qso == nil { + return "none" + } + st := a.ClusterSpotStatuses([]SpotQuery{{Call: call, Band: band, Mode: mode, POTARef: potaRef}}) + if len(st) == 0 { + return "none" + } + r := st[0] + if a.profiles != nil { + if p, err := a.profiles.Active(a.ctx); err == nil && + strings.EqualFold(strings.TrimSpace(p.Callsign), strings.TrimSpace(call)) { + return "my-call" + } + } + switch r.Status { + case "new", "new-band-mode", "new-band", "new-mode", "new-slot": + return r.Status + } + switch { + case r.NewPOTA: + return "new-pota" + case r.NewCounty: + return "new-county" + case r.NewPfx: + return "new-pfx" + } + if r.Status == "worked" { + return "worked" + } + return "none" +} + func (a *App) ClusterSpotStatuses(spots []SpotQuery) []SpotStatus { out := make([]SpotStatus, len(spots)) if a.qso == nil { @@ -19357,33 +19479,18 @@ func (a *App) ClusterSpotStatuses(spots []SpotQuery) []SpotStatus { out[i].Status = "new" continue } - if _, b := e.Bands[out[i].Band]; !b { - out[i].Status = "new-band" - continue - } - // Without a mode we can't distinguish the rest from "worked"; - // the safer default is "worked" so we never falsely claim "new". - if out[i].Mode == "" { - out[i].Status = "worked" - continue - } - // Band already worked. If this MODE was never worked on the entity (any - // band) → new-mode. If the mode was worked elsewhere but not on THIS - // band+mode → new-slot. Otherwise → worked. The check mode goes through - // the same normaliser as the slot map (digital grouping). + // The check mode goes through the same normaliser as the slot map + // (digital grouping), and is resolved before the band test because + // "new band" and "new mode" are now asked TOGETHER. checkMode := out[i].Mode if normMode != nil { checkMode = normMode(checkMode) } - if _, m := e.Modes[checkMode]; !m { - out[i].Status = "new-mode" - continue - } - if _, ok := e.Slots[out[i].Band][checkMode]; !ok { - out[i].Status = "new-slot" - continue - } - out[i].Status = "worked" + _, haveBand := e.Bands[out[i].Band] + _, haveMode := e.Modes[checkMode] + + _, haveSlot := e.Slots[out[i].Band][checkMode] + out[i].Status = spotEntityStatus(true, haveBand, haveMode, haveSlot, out[i].Mode) } return out } diff --git a/awardnew.go b/awardnew.go new file mode 100644 index 0000000..ae99d25 --- /dev/null +++ b/awardnew.go @@ -0,0 +1,235 @@ +package main + +// "Have I worked this reference before?" — the NEW badge on a QSO's award +// references. +// +// # Where the answer comes from, and where it must NOT come from +// +// The obvious source is the materialised award_refs column: it is already on +// every row and one query reads it. It is also the wrong answer twice over. +// That column holds DISPLAY LABELS, not references — depending on the award's +// RefDisplay it can read "Krasnogvardeysky" or "ST-25 — Krasnogvardeysky", and +// DXCC stores a country name — and it is a derived cache that lags: a QSO whose +// references were back-filled (see BackfillRDA) counts on the Awards grid long +// before anything recomputes its column. The first build of this badge used it +// and marked a district worked on five bands as NEW. +// +// So the answer comes from the same place the Awards grid's answer comes from: +// award.MatchQSO over the logbook. What is engineered here is the COST of that, +// because the question is asked while the operator is logging: +// +// - the set is per award CODE, and built only for codes actually asked about; +// - it reuses the award snapshot when one is already in memory, which it +// usually is (the Awards tab, the cluster status index); +// - otherwise it STREAMS the logbook rather than materialising a second copy +// of it — the references of one award are a few thousand short strings; +// - and it is built in the BACKGROUND. A caller that asks before the set is +// ready is told so and gets no badge, never a wait and never a wrong badge. +// +// A freshly logged QSO's references are folded into the sets, so a normal +// evening of logging never rebuilds anything. + +import ( + "strings" + + "hamlog/internal/award" + "hamlog/internal/qso" +) + +// workedRefIndex is the per-code set of references already in the log, plus the +// logbook revision it describes. +type workedRefIndex struct { + rev string + byCode map[string]map[string]struct{} + building map[string]bool +} + +// AwardRefNewResult answers one badge request. +type AwardRefNewResult struct { + // New maps "CODE@REF" to "never worked". An entry whose award set is still + // building is ABSENT rather than false: "not worked" and "not known yet" + // must not look the same to the badge. + New map[string]bool `json:"new"` + // Pending is true when at least one award set is still being built, and the + // caller should ask again shortly. + Pending bool `json:"pending"` +} + +// AwardRefsNew reports which of the given "CODE@REF" entries have never been +// worked. Returns immediately, always. +func (a *App) AwardRefsNew(entries []string) AwardRefNewResult { + res := AwardRefNewResult{New: map[string]bool{}} + if a.qso == nil || len(entries) == 0 { + return res + } + rev, err := a.qso.Revision(a.ctx) + if err != nil { + return res // logbook unreachable: no badge is the honest answer + } + + // Group the request by award code, so one code is looked up once however + // many of its references are on the QSO. + want := map[string][]string{} + for _, e := range entries { + code, _, ok := splitRefEntry(e) + if !ok { + continue + } + want[code] = append(want[code], e) + } + + a.workedRefMu.Lock() + if a.workedRef.rev != rev || a.workedRef.byCode == nil { + // The logbook moved on: every set describes a log that no longer exists. + a.workedRef = workedRefIndex{rev: rev, byCode: map[string]map[string]struct{}{}, building: map[string]bool{}} + } + var build []string + for code := range want { + set, ready := a.workedRef.byCode[code] + if !ready { + if !a.workedRef.building[code] { + a.workedRef.building[code] = true + build = append(build, code) + } + res.Pending = true + continue + } + for _, e := range want[code] { + _, ref, _ := splitRefEntry(e) + _, worked := set[ref] + res.New[e] = !worked + } + } + a.workedRefMu.Unlock() + + for _, code := range build { + go a.buildWorkedRefs(code, rev) + } + return res +} + +// splitRefEntry splits "RDA@ST-25" into its uppercased code and reference. +func splitRefEntry(e string) (code, ref string, ok bool) { + at := strings.Index(e, "@") + if at <= 0 { + return "", "", false + } + code = strings.ToUpper(strings.TrimSpace(e[:at])) + ref = strings.ToUpper(strings.TrimSpace(e[at+1:])) + return code, ref, code != "" && ref != "" +} + +// buildWorkedRefs collects every reference of one award already in the log. +func (a *App) buildWorkedRefs(code string, rev string) { + set := map[string]struct{}{} + defer func() { + a.workedRefMu.Lock() + // Publish only against the revision we were asked for: a QSO logged while + // this ran has already reset the index, and a set built from the older log + // would claim to describe the newer one. + if a.workedRef.rev == rev && a.workedRef.byCode != nil { + a.workedRef.byCode[code] = set + } + delete(a.workedRef.building, code) + a.workedRefMu.Unlock() + }() + + var def *award.Def + for _, d := range a.awardDefs() { + if strings.EqualFold(d.Code, code) { + dd := d + def = &dd + break + } + } + if def == nil { + return // unknown award: an empty set, so nothing is ever badged NEW + } + metas := a.awardRefMetas([]award.Def{*def})[strings.ToUpper(def.Code)] + collect := func(q *qso.QSO) { + for _, r := range award.MatchQSO(*def, metas, q) { + set[strings.ToUpper(strings.TrimSpace(r))] = struct{}{} + } + } + + // The snapshot is already enriched and already in memory whenever the Awards + // tab has been open — by far the common case, and free. + if snap := a.awardSnapshotIfLoaded(); snap != nil { + for i := range snap { + collect(&snap[i]) + } + return + } + // Otherwise stream. One pass, nothing retained but the reference strings. + _ = a.qso.IterateForAwards(a.ctx, func(q qso.QSO) error { + a.enrichQSOForAwards(&q) + collect(&q) + return nil + }) +} + +// awardSnapshotIfLoaded returns the award snapshot ONLY if one is already built +// and current. Never builds one: the caller is a background convenience, and +// reading the whole logbook for it is the cost this file exists to avoid. +func (a *App) awardSnapshotIfLoaded() []qso.QSO { + rev, err := a.qso.Revision(a.ctx) + if err != nil { + return nil + } + a.awardSnapMu.Lock() + defer a.awardSnapMu.Unlock() + if a.awardSnap != nil && a.awardSnapRev == rev { + return a.awardSnap + } + return nil +} + +// noteWorkedQSO folds a just-logged contact's references into the built sets, so +// logging does not throw away work already done. +func (a *App) noteWorkedQSO(q qso.QSO) { + a.workedRefMu.Lock() + codes := make(map[string]bool, len(a.workedRef.byCode)) + for c := range a.workedRef.byCode { + codes[c] = true + } + a.workedRefMu.Unlock() + if len(codes) == 0 { + return + } + rev, err := a.qso.Revision(a.ctx) + if err != nil { + return + } + a.enrichQSOForAwards(&q) + found := map[string][]string{} + for _, d := range a.awardDefs() { + code := strings.ToUpper(d.Code) + if !codes[code] { + continue + } + metas := a.awardRefMetas([]award.Def{d})[code] + for _, r := range award.MatchQSO(d, metas, &q) { + found[code] = append(found[code], strings.ToUpper(strings.TrimSpace(r))) + } + } + a.workedRefMu.Lock() + defer a.workedRefMu.Unlock() + // Carry the sets forward to the new revision rather than dropping them: they + // were correct one contact ago, and that contact is what is being added. + a.workedRef.rev = rev + for code, refs := range found { + if set := a.workedRef.byCode[code]; set != nil { + for _, r := range refs { + set[r] = struct{}{} + } + } + } +} + +// invalidateWorkedRefs drops every set. For the changes a revision cannot see — +// award definitions edited, reference lists updated, QSLs confirmed. +func (a *App) invalidateWorkedRefs() { + a.workedRefMu.Lock() + a.workedRef = workedRefIndex{} + a.workedRefMu.Unlock() +} diff --git a/awardnew_test.go b/awardnew_test.go new file mode 100644 index 0000000..77d74e9 --- /dev/null +++ b/awardnew_test.go @@ -0,0 +1,22 @@ +package main + +import "testing" + +func TestSplitRefEntry(t *testing.T) { + code, ref, ok := splitRefEntry("rda@st-25") + if !ok || code != "RDA" || ref != "ST-25" { + t.Fatalf("got %q %q %v", code, ref, ok) + } + // The picker writes what the operator typed, spacing included. + if _, ref, _ = splitRefEntry("POTA@ fr-1234 "); ref != "FR-1234" { + t.Fatalf("not trimmed: %q", ref) + } + // A reference can contain the separator characters of a label; only the + // FIRST @ splits, so "IOTA@EU-064" survives and a stray one does not create + // an award out of nothing. + for _, bad := range []string{"", "RDA", "@ST-25", "RDA@", "RDA@ "} { + if _, _, ok := splitRefEntry(bad); ok { + t.Fatalf("%q accepted", bad) + } + } +} diff --git a/changelog.json b/changelog.json index 4e1525e..8f1d59d 100644 --- a/changelog.json +++ b/changelog.json @@ -1,4 +1,40 @@ [ + { + "version": "0.26.3", + "date": "", + "en": [ + "Ultrabeam: the controller can be reached over a plain serial port, not only over the network. It has an RS232 port and the PC is usually beside it, so an FTDI cable is the direct route — the RS232-to-Ethernet adapter is now only needed to put the antenna at the far end of a link. Same choice the SteppIR has always had, in the same place.", + "Docked band map: FIT and FTx are now two labelled buttons in its header. Fit-to-band was hidden behind the px/kHz readout — a control whose label is a measurement does not look like one, and switching it off left nothing on screen saying the option existed. Hiding the digital spots is available there too, and both follow the Band Map tab.", + "Stats: the Entities tile now says which entity was added to the log most recently, with the callsign and date that did it. Judged against the whole log — a contact is the first with its country once, and does not become the first again because a date filter hides the ones before it.", + "Docked band map: in fit-to-band the header no longer printed FIT twice, once as the readout and once as the button beside it.", + "Settings: what OpsLog does with a FlexRadio — panadapter spots, decode spots and the DAX switch for voice messages — now lives in the FlexRadio page with the per-band antennas and power, instead of at the foot of the CAT page. CAT keeps the link itself: an address and a port, as for every other backend.", + "Cluster settings: four paragraphs of explanation removed. The options they described are unchanged.", + "A spot that is a new band AND a new mode for an entity is now its own status, NEW BAND+MODE, ranked with NEW DXCC. It used to be reported as a plain new band, which reads as \"you have worked this entity in this mode, just not here\" — the opposite of the truth. It is not a new slot either: a slot is the pair still missing when each half is already in the log. The cluster, the band map, the decodes panel, the filters and the auto-call criteria all tell the two apart now.", + "Cluster filters: a \"my bands\" link selects every band from your own band list in one click. With nothing selected the filter lets every band through — including 4 m and 70 cm off the RBN feeds, which the list could not offer you to untick because they are not bands you have.", + "FlexRadio: cluster spots on the panadapter are now coloured by what they are. A text colour and a background colour per status — new entity, new band+mode, new band, new mode, new slot, new park, new county, new prefix, your own callsign, already worked — set in Settings → FlexRadio, with a preview of each pair. Every spot used to be the same orange, which threw away the only thing worth knowing at a glance on a waterfall.", + "FlexRadio: clicking a spot can resize the panadapter to suit the mode — 25 kHz for CW, 200 for phone, 50 for digital by default, each configurable, with an option to re-centre on the spot as well. A CW signal is a hair at 200 kHz and an FT8 window shows an eighth of its sub-band at 25 kHz; one width cannot serve all three. Settings → FlexRadio, off by default.", + "FlexRadio: panadapter spots now carry their status in the comment as well as their colour — [NEW DXCC], [NEW BAND+MODE], [NEW BAND] and so on.", + "FlexRadio: the panadapter zoom now also applies when you click a spot on the panadapter itself, not just in the band map or cluster.", + "FlexRadio: fixed the panadapter zoom leaving the clicked spot off screen. The display now re-centres whenever the spot would fall outside the new window, and stays put when it would not.", + "Awards (F3): a NEW badge marks each award reference on the current QSO that has never been worked, picked or detected alike." + ], + "fr": [ + "Ultrabeam : le contrôleur se joint par un simple port série, plus seulement par le réseau. Il a une prise RS232 et le PC est en général juste à côté : un câble FTDI suffit — l'adaptateur RS232 vers Ethernet ne sert plus qu'à mettre l'antenne au bout d'une liaison. Le même choix que le SteppIR a toujours eu, au même endroit.", + "Bandmap ancrée : FIT et FTx sont désormais deux boutons nommés dans son en-tête. L'ajustement à la bande se cachait derrière l'indicateur px/kHz — un contrôle dont le libellé est une mesure n'a pas l'air d'un contrôle, et une fois désactivé plus rien à l'écran ne disait que l'option existait. Le masquage des spots numériques y est aussi, et les deux suivent l'onglet Bandmap.", + "Statistiques : la tuile Entités indique désormais quelle entité a été ajoutée au journal en dernier, avec l'indicatif et la date qui l'ont fait. Jugé sur le journal entier — un contact n'est le premier avec son pays qu'une fois, et ne le redevient pas parce qu'un filtre de date masque ceux d'avant.", + "Bandmap ancrée : en mode ajusté, l'en-tête n'affiche plus FIT deux fois, une comme indicateur et une comme bouton juste à côté.", + "Réglages : ce qu'OpsLog fait avec un FlexRadio — spots panadapter, spots de décodages et la bascule DAX pour les messages vocaux — se trouve désormais sur la page FlexRadio, avec les antennes et la puissance par bande, au lieu du bas de la page CAT. La page CAT garde la liaison elle-même : une adresse et un port, comme pour tous les autres backends.", + "Réglages du cluster : quatre pavés d'explication retirés. Les options qu'ils décrivaient sont inchangées.", + "Un spot qui est à la fois une nouvelle bande ET un nouveau mode pour une entité a désormais son propre statut, NOUVEAU BANDE+MODE, au même rang que NOUVEAU DXCC. Il était annoncé comme une simple nouvelle bande, ce qui se lit « tu as déjà fait cette entité dans ce mode, juste pas ici » — l'inverse de la vérité. Ce n'est pas non plus un nouveau slot : un slot est la paire qui manque quand chaque moitié est déjà au journal. Le cluster, la bandmap, le panneau des décodages, les filtres et les critères d'appel automatique font maintenant la différence.", + "Filtres du cluster : un lien « mes bandes » sélectionne d'un clic toutes les bandes de ta propre liste. Sans sélection, le filtre laisse passer toutes les bandes — y compris le 4 m et le 70 cm des flux RBN, que la liste ne pouvait pas te proposer de décocher puisque ce ne sont pas des bandes que tu as.", + "FlexRadio : les spots cluster sur le panadapter sont désormais colorés selon ce qu'ils sont. Une couleur de texte et une couleur de fond par statut — nouvelle entité, nouvelle bande+mode, nouvelle bande, nouveau mode, nouveau slot, nouveau parc, nouveau comté, nouveau préfixe, ton propre indicatif, déjà contacté — réglées dans Réglages → FlexRadio, avec un aperçu de chaque paire. Tous les spots étaient de la même couleur orange, ce qui jetait la seule chose qui compte au premier coup d'œil sur une cascade.", + "FlexRadio : cliquer un spot peut redimensionner le panadapter selon le mode — 25 kHz en CW, 200 en phonie, 50 en numérique par défaut, chacun réglable, avec une option pour recentrer aussi sur le spot. Un signal CW est un cheveu à 200 kHz et une fenêtre FT8 montre un huitième de sa sous-bande à 25 kHz ; une seule largeur ne peut pas servir les trois. Réglages → FlexRadio, désactivé par défaut.", + "FlexRadio : les spots du panadapter portent maintenant leur statut dans le commentaire en plus de la couleur — [NEW DXCC], [NEW BAND+MODE], [NEW BAND], etc.", + "FlexRadio : le zoom du panadapter s'applique aussi quand on clique un spot sur le panadapter lui-même, et plus seulement dans la bandmap ou le cluster.", + "FlexRadio : correction du zoom du panadapter qui laissait parfois le spot hors écran. L'affichage se recentre désormais dès que le spot sortirait de la nouvelle fenêtre, et ne bouge pas sinon.", + "Diplômes (F3) : un badge NEW signale chaque référence du QSO en cours jamais contactée, choisie à la main ou détectée." + ] + }, { "version": "0.26.2", "date": "", diff --git a/flexzoom.go b/flexzoom.go new file mode 100644 index 0000000..fe8dc5a --- /dev/null +++ b/flexzoom.go @@ -0,0 +1,122 @@ +package main + +// Panadapter auto-zoom on a spot click. +// +// A CW signal is 100 Hz wide, an FT8 slot 50 Hz in a 3 kHz sub-band, an SSB +// station 2.7 kHz. One panadapter width cannot serve all three: at 200 kHz the +// CW station you clicked is a hair, and at 25 kHz an FT8 window shows one +// eighth of the traffic. So the width follows the MODE of the spot, which is +// the only thing that determines how much spectrum is worth looking at. +// +// The command is SmartSDR's own: "display pan s bandwidth=", with an +// optional re-centre. Same approach as DXHunter, which is where the defaults +// below come from. + +import ( + "encoding/json" + "strings" + + "hamlog/internal/cat" +) + +const keyFlexZoom = "flex.spot_zoom" + +// FlexZoomSettings is the per-mode-group visible width, in kHz. +// +// kHz and not MHz: an operator thinks "25 kHz of CW", and a form asking for +// 0.025 invites a zero too many — which on a panadapter is not an error message +// but a display that has silently gone somewhere else. +type FlexZoomSettings struct { + Enabled bool `json:"enabled"` + CWkHz int `json:"cw_khz"` + SSBkHz int `json:"ssb_khz"` + DigikHz int `json:"digi_khz"` + // Centre re-centres the panadapter on EVERY spot, not just the ones that + // would otherwise fall outside the new window — the display always follows. + // Off by default: an operator who has arranged their window around a run + // frequency does not necessarily want it moved every time they look at + // someone else, and a spot already on screen stays where it is either way. + Centre bool `json:"centre"` +} + +// defaultFlexZoom — the widths DXHunter settled on, in kHz. +var defaultFlexZoom = FlexZoomSettings{Enabled: false, CWkHz: 25, SSBkHz: 200, DigikHz: 50, Centre: false} + +// flexZoomGroup maps a spot's mode to the three widths worth distinguishing. +// +// The mode arrives as whatever the cluster comment implied — "CW", "FT8", +// "USB", "RTTY" — so this takes the ADIF-ish name, not the Flex one. Anything +// unrecognised is digital, which is the safe end: a 50 kHz window is readable +// for every mode, where 25 kHz is not. +func flexZoomGroup(mode string) string { + switch strings.ToUpper(strings.TrimSpace(mode)) { + case "CW", "CWR", "CWL", "CWU": + return "cw" + case "SSB", "USB", "LSB", "AM", "FM", "NFM", "DFM", "SAM", "PHONE", "DV": + return "ssb" + } + return "digi" +} + +// GetFlexZoom returns the settings, defaults included. +func (a *App) GetFlexZoom() FlexZoomSettings { + out := defaultFlexZoom + if raw := a.settingOr(keyFlexZoom, ""); raw != "" { + var s FlexZoomSettings + if err := json.Unmarshal([]byte(raw), &s); err == nil { + out = normFlexZoom(s) + } + } + return out +} + +// normFlexZoom clamps the widths to something a panadapter can actually show. +// 1 kHz is narrower than most filters; 14 MHz is a whole HF spectrum. +func normFlexZoom(s FlexZoomSettings) FlexZoomSettings { + clamp := func(v, def int) int { + if v < 1 || v > 14000 { + return def + } + return v + } + s.CWkHz = clamp(s.CWkHz, defaultFlexZoom.CWkHz) + s.SSBkHz = clamp(s.SSBkHz, defaultFlexZoom.SSBkHz) + s.DigikHz = clamp(s.DigikHz, defaultFlexZoom.DigikHz) + return s +} + +// SaveFlexZoom persists the settings. +func (a *App) SaveFlexZoom(s FlexZoomSettings) error { + b, err := json.Marshal(normFlexZoom(s)) + if err != nil { + return err + } + a.setSetting(keyFlexZoom, string(b)) + return nil +} + +// FlexZoomForSpot resizes the panadapter for a spot that was just clicked. +// +// Called from the click handler, AFTER the rig has been tuned: the zoom is a +// view change and must never delay the frequency change an operator is waiting +// for. Does nothing at all unless the option is on and the backend is a Flex — +// no other radio has a panadapter to zoom. +func (a *App) FlexZoomForSpot(mode string, freqHz int64) { + if a.cat == nil { + return + } + z := a.GetFlexZoom() + if !z.Enabled { + return + } + khz := z.DigikHz + switch flexZoomGroup(mode) { + case "cw": + khz = z.CWkHz + case "ssb": + khz = z.SSBkHz + } + _ = a.cat.FlexDo(func(fc cat.FlexController) error { + return fc.ZoomPan(float64(khz)/1000, float64(freqHz)/1e6, z.Centre) + }) +} diff --git a/flexzoom_test.go b/flexzoom_test.go new file mode 100644 index 0000000..00bd868 --- /dev/null +++ b/flexzoom_test.go @@ -0,0 +1,32 @@ +package main + +import "testing" + +// The width follows the mode, and an unrecognised mode must land on the widest +// of the three: a 50 kHz window is readable for everything, where 25 kHz shows +// one eighth of an FT8 sub-band. +func TestFlexZoomGroup(t *testing.T) { + for mode, want := range map[string]string{ + "CW": "cw", "cw": "cw", "CWR": "cw", + "SSB": "ssb", "USB": "ssb", "LSB": "ssb", "FM": "ssb", "AM": "ssb", + "FT8": "digi", "FT4": "digi", "RTTY": "digi", "JS8": "digi", "PSK31": "digi", + "": "digi", "something new": "digi", + } { + if got := flexZoomGroup(mode); got != want { + t.Errorf("flexZoomGroup(%q) = %q, want %q", mode, got, want) + } + } +} + +// A width of zero would command "bandwidth=0.000000" and take the panadapter +// somewhere the operator cannot get back from by eye. +func TestNormFlexZoomClamps(t *testing.T) { + got := normFlexZoom(FlexZoomSettings{CWkHz: 0, SSBkHz: -5, DigikHz: 99999}) + if got.CWkHz != defaultFlexZoom.CWkHz || got.SSBkHz != defaultFlexZoom.SSBkHz || got.DigikHz != defaultFlexZoom.DigikHz { + t.Errorf("out-of-range widths not replaced by the defaults: %+v", got) + } + ok := normFlexZoom(FlexZoomSettings{CWkHz: 10, SSBkHz: 150, DigikHz: 40}) + if ok.CWkHz != 10 || ok.SSBkHz != 150 || ok.DigikHz != 40 { + t.Errorf("valid widths must be kept as they are: %+v", ok) + } +} diff --git a/frontend/src/App.tsx b/frontend/src/App.tsx index 192a6b2..23f3a82 100644 --- a/frontend/src/App.tsx +++ b/frontend/src/App.tsx @@ -22,7 +22,7 @@ import { GetSecretStatus, UnlockSecrets, RotatorGoTo, RotatorStop, SetActiveRotor, GetDBConnectionInfo, GetLogbookRevision, - GetUltrabeamStatus, SetUltrabeamDirection, UILog, + GetUltrabeamStatus, SetUltrabeamDirection, UILog, FlexZoomForSpot, GetAntGeniusStatus, GetAntGeniusSettings, AntGeniusActivate, GetTunerGeniusStatus, GetTunerGeniusSettings, TunerGeniusAutotune, TunerGeniusSetBypass, TunerGeniusSetOperate, TunerGeniusActivate, GetScpStatus, ScpLookup, @@ -1690,7 +1690,7 @@ export default function App() { const [clusterLockMode, setClusterLockMode] = useState(() => lsBool('opslog.clusterLockMode', false)); // Status filter chips. Empty set = show every status (including // already-worked). Otherwise only matching spots pass. - type SpotStatusKey = 'new' | 'new-band' | 'new-mode' | 'new-slot' | 'worked'; + type SpotStatusKey = 'new' | 'new-band-mode' | 'new-band' | 'new-mode' | 'new-slot' | 'worked'; // What the cluster can be FILTERED on. A superset of the entity status: a new // county or a new park is not a DXCC state, it is another dimension of the // same spot — which is why the grid shows them as separate badges. Filtering @@ -3059,6 +3059,10 @@ export default function App() { } if (s.band) setBand(s.band); if (catState.connected) tuneRigCAT(s.freq_hz, m); + // The panadapter width follows the MODE of the spot, when the option is on. + // AFTER the tune, deliberately: a view change must never delay the frequency + // change the operator is waiting for. A no-op on any backend but a Flex. + FlexZoomForSpot(m ?? '', s.freq_hz ?? 0).catch(() => {}); if (m) applyModeFromSpot(m); onCallsignInput(s.dx_call, { force: true }); applySpotPOTA((s as any).pota_ref); @@ -5676,6 +5680,20 @@ export default function App() { > {clusterLockBand ? : } {band} + {/* "My bands" in one click. + + No selection means EVERY band, which is what an operator wants + the first time and never again: an RBN feed carries 4 m and + 70 cm, and the list above can only offer the bands you have + configured — so a band you do not own could not be unticked, + because it was never there to tick. Selecting your own list + makes the filter finite, and the spot goes. */} + {clusterBands.size !== bands.length && ( + + )} {clusterBands.size > 0 && ( )} @@ -5687,6 +5705,9 @@ export default function App() {
{([ { k: 'new' as SpotFilterKey, label: 'NEW', cls: 'bg-danger-muted text-danger-muted-foreground border-danger-border' }, + // NEW BAND+MODE sits between NEW and NEW BAND, which is where it + // ranks: the entity is worked, but neither this band nor this mode. + { k: 'new-band-mode' as SpotFilterKey, label: 'NEW B+M', cls: 'bg-danger-muted text-danger-muted-foreground border-danger-border' }, { k: 'new-band' as SpotFilterKey, label: 'NEW BAND', cls: 'bg-warning-muted text-warning-muted-foreground border-warning-border' }, { k: 'new-mode' as SpotFilterKey, label: 'NEW MODE', cls: 'bg-caution-muted text-caution-muted-foreground border-caution-border' }, { k: 'new-slot' as SpotFilterKey, label: 'NEW SLOT', cls: 'bg-caution-muted text-caution-muted-foreground border-caution-border' }, @@ -7940,6 +7961,8 @@ export default function App() { // place a band map happens to be drawn. fitToBand={bandMapFit} onToggleFit={toggleBandMapFit} + hideDigital={bandMapHideFt} + onToggleHideDigital={toggleBandMapHideFt} keyNav />
diff --git a/frontend/src/components/AwardRefSelector.tsx b/frontend/src/components/AwardRefSelector.tsx index 7c24eba..2128a06 100644 --- a/frontend/src/components/AwardRefSelector.tsx +++ b/frontend/src/components/AwardRefSelector.tsx @@ -1,6 +1,6 @@ import { useEffect, useMemo, useState } from 'react'; import { X, Plus, Loader2 } from 'lucide-react'; -import { SearchAwardReferences, GetAwardDefs, GetAwardReferenceMeta } from '../../wailsjs/go/main/App'; +import { SearchAwardReferences, GetAwardDefs, GetAwardReferenceMeta, AwardRefsNew } from '../../wailsjs/go/main/App'; import { Select, SelectTrigger, SelectValue, SelectContent, SelectItem, } from '@/components/ui/select'; @@ -54,6 +54,34 @@ export function AwardRefSelector({ dxcc, value, onChange, fieldValues, heightCla const entries = value ? value.split(';').filter(Boolean) : []; + // Which of the picked references have never been worked. Asked of the backend + // only when the list of references actually changes — a handful of times per + // QSO — and it answers from an in-memory set (see awardnew.go). + // + // The first question about an award may arrive before its set is built, in + // which case the answer is "pending" and carries no verdict for it: we ask + // again rather than badge on a guess. Attempts are capped so a logbook that + // never finishes building cannot leave a timer running for the session. + const [isNew, setIsNew] = useState>({}); + const entriesKey = entries.join(';'); + useEffect(() => { + if (!entriesKey) { setIsNew({}); return; } + let alive = true; + let timer: number | undefined; + let tries = 0; + const ask = () => { + AwardRefsNew(entriesKey.split(';')) + .then((r: any) => { + if (!alive) return; + setIsNew(r?.new ?? {}); + if (r?.pending && ++tries < 10) timer = window.setTimeout(ask, 700); + }) + .catch(() => { if (alive) setIsNew({}); }); // no badge beats a wrong one + }; + ask(); + return () => { alive = false; if (timer) window.clearTimeout(timer); }; + }, [entriesKey]); + // When the reference set is cleared (a QSO was logged or the call was reset), // also blank the picker's own state — the search box and the highlighted / // selected reference — so the Awards tab starts fresh for the next contact. @@ -256,7 +284,16 @@ export function AwardRefSelector({ dxcc, value, onChange, fieldValues, heightCla }`} onClick={() => setSelectedEntry(selectedEntry === entry ? null : entry)} > - {entry} + {entry} + {isNew[entry] && ( + + {t('awrs.new')} + + )} + - {/* The readout IS the switch when the parent offers one — the header is - already tight with four maps side by side, and a separate chip would - cost width to say what this text says anyway. */} - {onToggleFit ? ( - - ) : ( + {/* A readout, not a switch. + + It WAS the switch for a day: clicking the px/kHz value toggled + fit-to-band, and in fit it read "FIT". Nobody found it — a control + whose label is a measurement does not look like a control, and once + switched off there was no longer anything on screen saying the option + existed. The switches below say what they are. */} + {/* In fit mode the readout has nothing left to say — the lit FIT button + says it, and printing the word twice side by side is just noise. The + Band Map tab's cards have no button, so there the readout keeps + reporting both states. */} + {(!fitToBand || !onToggleFit) && ( {fitToBand ? t('bmp.fit') : `${pxPerKHz}px/kHz`} )} + {onToggleFit && ( + + )} + {onToggleHideDigital && ( + + )} + + {/* Whether spots are drawn at all comes first: colouring them is the + next question, and the two were on different pages. */} + + + {spotColors.enabled && ( +
+ {SPOT_COLOR_ROWS.map((k) => { + const c = spotColors.colors[k] ?? { text: '', bg: '' }; + return ( +
+ {t('spotcol.s_' + k)} + {/* The preview is the point of the row: two colour boxes say + nothing about what the pair looks like together. */} + + DL1ABC + + setSpotColor(k, { text: v })} /> + setSpotColor(k, { bg: v })} /> +
+ ); + })} +
+ )} + + + ), audio: AudioPanel, }; diff --git a/frontend/src/components/StatsPanel.tsx b/frontend/src/components/StatsPanel.tsx index 7d92d0c..69eedff 100644 --- a/frontend/src/components/StatsPanel.tsx +++ b/frontend/src/components/StatsPanel.tsx @@ -29,6 +29,7 @@ type ContestRun = { id: string; year: number; count: number; start: string; end: type Stats = { total: number; unique_calls: number; entities: number; continents: number; first_qso: string; last_qso: string; + last_new_dxcc: string; last_new_dxcc_num: number; last_new_dxcc_call: string; last_new_dxcc_date: string; confirmed_lotw: number; confirmed_eqsl: number; confirmed_qsl: number; confirmed_any: number; by_mode: Bucket[]; by_band: Bucket[]; by_band_category: BandCat[]; by_operator: Bucket[]; by_station: Bucket[]; by_continent: Bucket[]; top_entities: Bucket[]; by_year: Bucket[]; by_month: Bucket[]; @@ -681,6 +682,16 @@ export function StatsPanel() { // real operating session (which is exactly when an hourly rate chart exists). const windowed = contest !== '' || (period === 'custom' && (stats?.rate?.length ?? 0) > 1); + // "last new: France - F5ABC - 2019-03-01": the entity most recently added to + // the log, and the contact that added it. Empty when no dated entity exists. + const lastNew = useMemo(() => { + if (!stats?.last_new_dxcc_date) return ''; + const day = stats.last_new_dxcc_date.slice(0, 10); + const who = stats.last_new_dxcc_call ? ` · ${stats.last_new_dxcc_call}` : ''; + const what = stats.last_new_dxcc || String(stats.last_new_dxcc_num || ''); + return `${t('stats.lastNewDxcc')}: ${what}${who} · ${day}`; + }, [stats, t]); + const span = useMemo(() => { if (!stats?.first_qso) return ''; const f = new Date(stats.first_qso), l = new Date(stats.last_qso); @@ -774,7 +785,11 @@ export function StatsPanel() {
- + {/* The last one ADDED rides on the entities tile: it is the same + subject, and a tile of its own would push the five headline figures + onto two rows for one line of text. */} + diff --git a/frontend/src/lib/autocall.ts b/frontend/src/lib/autocall.ts index 49153af..299ce24 100644 --- a/frontend/src/lib/autocall.ts +++ b/frontend/src/lib/autocall.ts @@ -9,6 +9,7 @@ export type AutoCallCriteria = { dxcc: boolean; // entity never worked + bandmode: boolean; // entity worked, but neither this band nor this mode band: boolean; // entity never worked on this band mode: boolean; // entity never worked in this mode slot: boolean; // band and mode each worked, never together @@ -37,7 +38,7 @@ export type AutoCallSettings = { }; export const emptyCriteria: AutoCallCriteria = { - dxcc: false, band: false, mode: false, slot: false, + dxcc: false, bandmode: false, band: false, mode: false, slot: false, grid: false, county: false, pota: false, pfx: false, }; @@ -101,6 +102,10 @@ function anyCriterion(c: AutoCallCriteria): boolean { // meets reports whether a decode satisfies at least one ticked criterion. function meets(c: AutoCallCriteria, e: DecodeStatus): boolean { if (c.dxcc && e.status === 'new') return true; + // Each status is exclusive, so a station that is new on both counts matches + // ONLY this criterion — ticking "new band" alone would not catch it, which is + // the wrong way round: it is the better catch of the two. + if (c.bandmode && e.status === 'new-band-mode') return true; if (c.band && e.status === 'new-band') return true; if (c.mode && e.status === 'new-mode') return true; if (c.slot && e.status === 'new-slot') return true; diff --git a/frontend/src/lib/i18n.tsx b/frontend/src/lib/i18n.tsx index fae59c5..93b07eb 100644 --- a/frontend/src/lib/i18n.tsx +++ b/frontend/src/lib/i18n.tsx @@ -66,7 +66,7 @@ const en: Dict = { 'settings.language': 'Language', 'gen.dateFormat': 'Date display', 'gen.dateStandard': 'Standard', 'gen.dateFR': 'French', 'gen.dateUS': 'US', 'settings.languageHint': 'Interface language.', 'stats.tab': 'Statistics', 'stats.title': 'Logbook statistics', 'stats.loading': 'Crunching the log…', 'stats.noData': 'No data', 'stats.charts': 'Charts', 'stats.table': 'Table', 'stats.refresh': 'Refresh', - 'stats.qsos': 'QSOs', 'stats.uniqueCalls': 'Unique callsigns', 'stats.entities': 'Entities', + 'stats.qsos': 'QSOs', 'stats.uniqueCalls': 'Unique callsigns', 'stats.lastNewDxcc': 'last new', 'stats.entities': 'Entities', 'stats.continents': 'Continents', 'stats.confirmed': 'Confirmed', 'stats.byBand': 'By band', 'stats.byBandSub': 'In band-plan order, not by size', 'stats.bandSplit': 'Mode split by band', 'stats.bandSplitSub': 'CW / phone / data per band', 'stats.byMode': 'By mode', 'stats.byOperator': 'By operator', @@ -104,7 +104,7 @@ const en: Dict = { 'settings.telemetry': 'Send anonymous usage statistics', 'settings.telemetryHint': 'install ID + version + OS, once a day — no callsign or QSO data', 'settings.mainView': 'Main view', - 'settings.mainViewHint': 'Choose what the Main tab shows, in up to four panes (per profile). Leave the third and fourth empty and they are not drawn; every divider is draggable, and a double-click evens them out.', + 'settings.mainViewHint': 'What the Main tab shows, in up to four panes (per profile).', 'settings.leftPane': 'Left pane', 'settings.thirdPane': 'Third pane', 'settings.fourthPane': 'Fourth pane', 'settings.paneNone': '— none —', 'settings.paneLayout': 'With four panes:', 'settings.paneQuad': 'Quarters (2 × 2)', 'settings.paneCols': 'Four columns', 'settings.rightPane': 'Right pane', 'settings.pane.map1': 'Map — great-circle + beam', 'settings.pane.map2': 'Map — locator (street)', 'settings.pane.cluster': 'Cluster spots', 'settings.pane.worked': 'Worked before', @@ -148,7 +148,7 @@ const en: Dict = { 'dec.empty': 'Nothing decoded yet. Decodes arrive from WSJT-X, JTDX or MSHV over the inbound UDP link (Settings -> UDP).', 'dec.emptyFiltered': 'No decode matches these filters.', 'sec.email': 'E-mail (SMTP)', 'sec.lookup': 'Callsign Lookup', - 'sec.ftx': 'FTx decodes', 'ftx.hint': 'What OpsLog does on its own with the digital decode stream.', 'ftx.enable': 'Auto-call', 'ftx.enableHint': 'answer a decode without clicking it', 'ftx.callWhen': 'Call a station that is:', 'ftx.watch': 'Watch list', 'ftx.watchHint': 'One callsign per line, wildcards allowed (4S7*, */P). A watched station is answered ahead of the criteria above.', 'ftx.watchOnlyIf': 'but only if it is also:', 'ftx.cooldown': 'Ignore a callsign for', 'ftx.warn': 'This keys your transmitter without asking. It answers CQ only, never while you are already transmitting, one station at a time, and every call is written to the log file with its reason. Halt stops it.', 'ftx.c_dxcc': 'a new DXCC entity', 'ftx.c_band': 'a new band for the entity', 'ftx.c_mode': 'a new mode for the entity', 'ftx.c_slot': 'a new slot (band+mode never worked together)', 'ftx.c_grid': 'a new grid square', 'ftx.c_county': 'a new US county', 'ftx.c_pota': 'a new POTA park', 'ftx.c_pfx': 'a new WPX prefix', + 'sec.ftx': 'FTx decodes', 'ftx.hint': 'What OpsLog does on its own with the digital decode stream.', 'ftx.enable': 'Auto-call', 'ftx.enableHint': 'answer a decode without clicking it', 'ftx.callWhen': 'Call a station that is:', 'ftx.watch': 'Watch list', 'ftx.watchHint': 'One callsign per line, wildcards allowed (4S7*, */P). A watched station is answered ahead of the criteria above.', 'ftx.watchOnlyIf': 'but only if it is also:', 'ftx.cooldown': 'Ignore a callsign for', 'ftx.warn': 'This keys your transmitter without asking. It answers CQ only, never while you are already transmitting, one station at a time, and every call is written to the log file with its reason. Halt stops it.', 'ftx.c_dxcc': 'a new DXCC entity', 'ftx.c_bandmode': 'a new band AND a new mode for the entity', 'ftx.c_band': 'a new band for the entity', 'ftx.c_mode': 'a new mode for the entity', 'ftx.c_slot': 'a new slot (band+mode never worked together)', 'ftx.c_grid': 'a new grid square', 'ftx.c_county': 'a new US county', 'ftx.c_pota': 'a new POTA park', 'ftx.c_pfx': 'a new WPX prefix', 'sec.bands': 'Bands', 'sec.modes': 'Modes & default RST', 'sec.cluster': 'DX Cluster', 'sec.udp': 'Connections', 'sec.database': 'Database', 'sec.autostart': 'Autostart', 'sec.backup': 'Database backup', 'sec.uscounties': 'US Counties', 'nav.maintenance': 'Maintenance', 'sec.databases': 'Databases', 'db.hint': 'The reference data OpsLog keeps on disk. One line each, with what it holds and when it was last refreshed.', 'db.update': 'Update', 'db.never': 'never downloaded', 'db.cty': 'Country file (cty.dat)', 'db.ctyDetail': '{n} entities · file dated {d}', 'db.clublog': 'Club Log country exceptions', 'db.clublogDetail': '{n} exceptions · {d}', 'db.lotwUsers': 'LoTW users', 'db.lotwDetail': '{n} callsigns · {d}', 'db.scp': 'Super Check Partial (MASTER.SCP)', 'db.scpDetail': '{n} callsigns · {d}', 'db.uls': 'US counties (FCC ULS)', 'db.ulsDetail': '{n} callsigns · {d}', 'db.rda': 'Russian districts (RDA)', 'db.rdaDetail': '{n} callsigns, with their dated activity periods', 'db.rdaNote': 'built in', 'db.refLists': 'Award reference lists', 'db.refListsHint': 'Only the awards with an online source appear here; the others are shipped or edited by hand.', 'db.refDetail': '{n} references · {d}', 'db.refUpdated': '{code}: {n} references.', 'db.noRefLists': 'No award has an online reference list.', 'sec.rda': 'Russian districts (RDA)', 'rda.hint': 'The offline district database, and the one bulk operation it feeds.', 'rda.dbTitle': 'District database', 'rda.dbCount': '{n} Russian callsigns, each with the district it operates from and, where it moved, the dated periods it operated from each one. Built into OpsLog — nothing to download.', 'rda.backfillTitle': 'Fill the district on existing QSOs', 'rda.backfillIntro': 'Goes through every contact with a Russian entity and assigns its RDA reference, using the district the station was in ON THE DAY of the contact.', 'rda.useCurrent': 'Also use the current district for stations with no recorded history', 'rda.useCurrentHint': '(true for the great majority — the database records a history precisely for the callsigns that moved — but it is an assumption, not a dated fact)', 'rda.backfillRun': 'Fill districts', 'rda.backfillDone': '{s} Russian QSOs — {d} from a dated record, {c} from the current district, {u} unknown, {k} already had one.', 'rda.neverOverwrites': 'A reference you assigned by hand is never overwritten.', 'sec.webpublish': 'Web publishing', 'wpub.hint': 'Publishes your log as a file for a website: a standalone HTML page or a CSV, written locally and optionally uploaded by FTP. It is refreshed when you log a QSO and, if you set an interval, on a timer.', 'wpub.enable': 'Publish the log to a file', 'wpub.fileSection': 'The file', 'wpub.format': 'Format', 'wpub.formatHtml': 'HTML page', 'wpub.formatCsv': 'CSV', 'wpub.folder': 'Output folder', 'wpub.browse': 'Browse…', 'wpub.fileName': 'File name', 'wpub.title': 'Page title', 'wpub.titlePh': 'blank = your callsign', 'wpub.count': 'Last N QSOs', 'wpub.every': 'Refresh every', 'wpub.everyHint': 'minutes — 0 = only when a QSO is logged', 'wpub.columns': 'Columns', 'wpub.columnsCount': '{n} of {total} chosen', 'wpub.columnsPick': 'Choose columns…', 'wpub.columnsSearch': 'Search a field…', 'wpub.removeColumn': 'Click to remove', 'wpub.columnsHint': 'Click to add or remove. The order shown here is the order in the file.', 'wpub.ftpEnable': 'Upload by FTP', 'wpub.ftpHost': 'Server / port', 'wpub.ftpUser': 'User', 'wpub.ftpPassword': 'Password', 'wpub.ftpFolder': 'Remote folder', 'wpub.ftpFileName': 'Remote file name', 'wpub.ftpTls': 'Use TLS (FTPS)', 'wpub.publishNow': 'Publish now', 'wpub.testFtp': 'Test connection', 'wpub.lastRun': 'Last run:', 'sec.adifmon': 'ADIF monitor', @@ -306,7 +306,7 @@ const en: Dict = { 'clu.selfSpot': 'Self-spot while I log', 'clu.selfSpotEvery': 'at most every', 'clu.selfSpotMinutes': 'min', 'clu.selfSpotHint': 'Announces YOU on the master cluster when you log a QSO — the spot carries your station callsign and the frequency you just worked on, so callers find you without waiting for someone else to spot you. Sent on the first QSO of a frequency, then no more often than the gap below. Five minutes is the floor: a self-spot is traffic every user of the node sees.', 'clu.freeNodes': 'Free public nodes:', - 'clu.filters': 'Filters', 'clu.hideFilters': 'Hide filters', 'clu.searchCall': 'Search call…', 'clu.hideWorked': 'Hide worked', 'clu.groupDup': 'Group duplicates', 'clu.mode': 'Mode', 'clu.bands': 'Bands', 'clu.source': 'Source', 'clu.clear': 'clear', 'clu.allSources': 'All sources', 'clu.lockModeTitle': 'Only show spots whose mode matches the entry strip', 'clu.lockBandTitle': "Lock to the entry strip's current band", 'clu.lotwOnly': 'LoTW users only', 'clu.spotterCont': 'Spotter continent', 'clu.lotwBadge': 'Uploads to LoTW', 'clu.muteWorkedShort': 'No colour on worked', 'clu.slotHighlightShort': 'Colour unworked here', 'clu.muteWorked': 'No colour or badge on stations already worked', + 'clu.filters': 'Filters', 'clu.hideFilters': 'Hide filters', 'clu.searchCall': 'Search call…', 'clu.hideWorked': 'Hide worked', 'clu.groupDup': 'Group duplicates', 'clu.mode': 'Mode', 'clu.myBands': 'my bands', 'clu.myBandsTitle': 'Select every band from your own band list — with nothing selected the filter lets EVERY band through, including ones you do not have (4 m and 70 cm arrive on the RBN feeds).', 'clu.bands': 'Bands', 'clu.source': 'Source', 'clu.clear': 'clear', 'clu.allSources': 'All sources', 'clu.lockModeTitle': 'Only show spots whose mode matches the entry strip', 'clu.lockBandTitle': "Lock to the entry strip's current band", 'clu.lotwOnly': 'LoTW users only', 'clu.spotterCont': 'Spotter continent', 'clu.lotwBadge': 'Uploads to LoTW', 'clu.muteWorkedShort': 'No colour on worked', 'clu.slotHighlightShort': 'Colour unworked here', 'clu.muteWorked': 'No colour or badge on stations already worked', 'clu.muteWorkedHint': '(they stay in the list, just quiet — leaves the colour for what is left to do)', 'clu.slotHighlight': 'Colour the stations not worked on this band and mode', 'clu.slotHighlightHint': '(by callsign, whatever the entity status says)', @@ -346,7 +346,7 @@ const en: Dict = { 'cat.icomNetAudio': 'Stream RX audio over the network (experimental)', 'cat.icomNetAudioHint': 'Play the rig’s received audio through your Listening device (Settings → Audio) over the 50003 stream. Experimental — the audio framing is pending on-rig verification; leave off if control misbehaves.', 'cat.omnirigRig': 'OmniRig rig slot', 'cat.omnirigVfo': 'VFO to read', 'cat.omnirigVfoAuto': 'As reported by the rig file', 'cat.omnirigVfoA': 'Always VFO A (main)', 'cat.omnirigVfoB': 'Always VFO B (sub)', 'cat.omnirigVfoHint': 'OmniRig reports the active VFO from the rig file, and some files get it wrong — the frequency then follows the other VFO and appears frozen. Force one here if that happens.', 'cat.flexIp': 'FlexRadio IP', 'cat.port': 'Port', 'cat.flexSpots': 'Show cluster spots on the panadapter', 'cat.flexSpotsHint': "(spots from OpsLog's DX cluster appear on the radio, auto-expire after 30 min)", 'cat.flexDecodeSpots': 'Show WSJT-X decodes on the panadapter', 'cat.flexDecodeSpotsHint': '(heard FT8/FT4 stations from your WSJT-X/JTDX UDP feed, one spot per call)', 'cat.flexDecodeSecs': 'Display for', 'cat.flexDecodeSecsHint': 'seconds before a station is removed', - 'cat.flexDvkDax': 'Switch transmit audio to DAX for voice messages', + 'cat.flexOptions': 'What OpsLog does with the radio', 'flexzoom.title': 'Zoom the panadapter on a spot click', 'flexzoom.enable': 'Resize the panadapter when a spot is clicked', 'flexzoom.cw': 'CW', 'flexzoom.ssb': 'Phone', 'flexzoom.digi': 'Digital', 'flexzoom.centre': 'Re-centre on the spot as well', 'flexzoom.centreHint': '(off keeps your window where you put it and only changes its width)', 'spotcol.title': 'Spot colours on the panadapter', 'spotcol.enable': 'Colour spots by status', 'spotcol.reset': 'restore defaults', 'spotcol.text': 'Text colour', 'spotcol.bg': 'Background colour', 'spotcol.s_new': 'New entity', 'spotcol.s_new-band-mode': 'New band + new mode', 'spotcol.s_new-band': 'New band', 'spotcol.s_new-mode': 'New mode', 'spotcol.s_new-slot': 'New slot', 'spotcol.s_new-pota': 'New POTA park', 'spotcol.s_new-county': 'New US county', 'spotcol.s_new-pfx': 'New WPX prefix', 'spotcol.s_my-call': 'My own callsign', 'spotcol.s_worked': 'Already worked', 'spotcol.s_none': 'Entity not resolved', 'cat.flexDvkDax': 'Switch transmit audio to DAX for voice messages', 'cat.flexDvkDaxHint': '(pressed while a DVK message or a QSO recording goes out, and put back afterwards so your microphone works again)', 'cat.icomPort': 'Icom CI-V port', 'cat.selectCom': 'Select COM port', 'cat.noPorts': 'No ports found', 'cat.baud': 'Baud rate', 'cat.icomModel': 'Rig model', 'cat.icomModelOther': 'Other (custom address)', 'cat.civAddr': 'CI-V address (hex)', 'cat.civHint': 'Pick your model to set the CI-V address automatically (or choose "Other" and type it). Set "CI-V USB Echo Back" OFF and CI-V baud to match on the rig.', 'cat.tciHost': 'TCI host', 'cat.tciHint': 'Enable the TCI server in ExpertSDR2/EESDR (Options → TCI). Default port 40001. Use 127.0.0.1 when OpsLog runs on the same PC.', 'cat.tciSpots': 'Show cluster spots on the panorama', 'cat.tciSpotsHint': "(spots from OpsLog's DX cluster appear on the SDR panadapter)", @@ -399,10 +399,10 @@ const en: Dict = { 'chp.workedBefore': 'Worked before', 'chp.typeCallsign': 'Type a callsign to see prior contacts.', 'chp.checking': 'checking…', 'chp.new': 'NEW', 'chp.noPriorQso': 'No prior QSO with this callsign.', 'chp.first': 'First', 'chp.last': 'Last', 'chp.dateUtc': 'Date UTC', 'chp.band': 'Band', 'chp.mode': 'Mode', 'chp.lotwRcvd': 'LoTW rcvd', 'chp.bureauRcvd': 'Bureau rcvd', 'chp.olderQsos': '+ {n} older QSOs', - 'bmp.statusNew': 'NEW DXCC (entity never worked)', 'bmp.statusNewBand': 'NEW BAND (entity not worked on this band)', 'bmp.statusNewSlot': 'NEW SLOT (mode not worked on this band)', 'bmp.statusNewCall': 'NEW CALL (this callsign never worked on this band and mode)', 'bmp.statusNewMode': 'NEW MODE (mode never worked for this entity)', + 'bmp.statusNew': 'NEW DXCC (entity never worked)', 'bmp.statusNewBandMode': 'NEW BAND+MODE (neither worked with this entity)', 'bmp.statusNewBand': 'NEW BAND (entity not worked on this band)', 'bmp.statusNewSlot': 'NEW SLOT (mode not worked on this band)', 'bmp.statusNewCall': 'NEW CALL (this callsign never worked on this band and mode)', 'bmp.statusNewMode': 'NEW MODE (mode never worked for this entity)', 'bmp.statusWorked': 'Worked (this band + mode already in log)', 'bmp.statusUnresolved': 'Entity not resolved', 'bmp.bandMap': 'Band map', 'bmp.notConfigured': 'Not configured for {band}.', 'bmp.zoomOut': 'Zoom out', 'bmp.zoomIn': 'Zoom in', 'bmp.scrollToRig': 'Scroll to current rig frequency', 'bmp.moveLeft': 'Move band map to the left', 'bmp.moveRight': 'Move band map to the right', 'bmp.hide': 'Hide band map', - 'bmp.bandsLabel': 'Bands:', 'bmp.fit': 'FIT', 'bmp.hideFt': 'Hide FTx', 'bmp.hideFtTitle': 'Hide all digital (FT8/FT4/JS8/…) spots on every band map', 'bmp.fitBand': 'Fit to band', 'bmp.widthTip': 'Drag to resize — double-click to reset', 'bmp.fitTitle': 'Size each band map to show the whole band edge-to-edge', + 'bmp.bandsLabel': 'Bands:', 'bmp.fit': 'FIT', 'bmp.ftx': 'FTx', 'bmp.hideFt': 'Hide FTx', 'bmp.hideFtTitle': 'Hide all digital (FT8/FT4/JS8/…) spots on every band map', 'bmp.fitBand': 'Fit to band', 'bmp.widthTip': 'Drag to resize — double-click to reset', 'bmp.fitTitle': 'Size each band map to show the whole band edge-to-edge', 'bmp.legendNewDxcc': 'New DXCC', 'bmp.legendNewBand': 'New band', 'bmp.legendNewSlot': 'New slot (mode)', 'bmp.openUnusual': 'unusual for the season', 'bmp.legendWorked': 'Worked', 'bmp.legendNewPota': 'New POTA', 'bmp.legendNewCounty': 'New county', 'bmp.legendWorkedCall': 'Callsign already worked', 'bmp.legendCW': 'CW', 'bmp.legendData': 'Data', 'bmp.legendPhone': 'Phone', 'bmp.footerHint': 'scroll · ctrl+wheel = zoom · ◎ = jump to rig', 'bmp.spotsHidden': '{n} FT8/FT4 spots hidden — top {max} kept (CW/SSB all shown)', 'frm.welcome': 'Welcome to OpsLog', 'frm.intro': 'Set up your station to start logging. These fields stamp every QSO and can be changed later in Preferences → Station Information (and per profile).', 'frm.callsign': 'Callsign', 'frm.locator': 'Locator', 'frm.operator': 'Operator', 'frm.operatorPh': 'same as callsign', 'frm.owner': 'Owner', 'frm.ownerPh': 'station owner callsign', 'frm.name': 'Name', 'frm.namePh': 'your first name', @@ -443,7 +443,7 @@ const en: Dict = { 'detp.propAS': 'Aircraft Scatter', 'detp.propAUR': 'Aurora', 'detp.propAUE': 'Aurora-E', 'detp.propBS': 'Back Scatter', 'detp.propEME': 'Earth-Moon-Earth', 'detp.propES': 'Sporadic E', 'detp.propFAI': 'Field Aligned Irregularities', 'detp.propF2': 'F2 Reflection', 'detp.propGWAVE': 'Ground Wave', 'detp.propINTERNET': 'Internet-assisted', 'detp.propION': 'Ionoscatter', 'detp.propLOS': 'Line of Sight', 'detp.propMS': 'Meteor Scatter', 'detp.propRPT': 'Terrestrial / atmospheric repeater', 'detp.propRS': 'Rain Scatter', 'detp.propSAT': 'Satellite', 'detp.propTEP': 'Trans-Equatorial', 'detp.propTR': 'Tropospheric Ducting', 'detp.pathShort': 'Short Path', 'detp.pathLong': 'Long Path', 'detp.pathGrayline': 'Grayline', 'detp.pathOther': 'Other', 'detp.tabStats': 'Stats', 'detp.tabInfo': 'Info', 'detp.tabAwards': 'Awards', 'detp.tabMy': 'My', 'detp.tabExtended': 'Extended', 'detp.statePref': 'State / pref', 'detp.county': 'County', 'detp.newCounty': 'NEW', 'detp.newCountyTip': 'County never worked before', 'detp.prefix': 'Prefix', 'detp.cqZone': 'CQ', 'detp.ituZone': 'ITU', 'detp.dxcc': 'DXCC #', 'detp.azimuthLp': 'Azimuth LP', 'detp.distanceSp': 'Distance SP', 'detp.distanceLp': 'Distance LP', 'detp.address': 'Address', 'detp.qslMessage': 'QSL message', 'detp.qslVia': 'QSL via (manager)', 'detp.detected': 'Detected — this contact will count for:', 'detp.ambiguous': 'Ambiguous — pick one:', 'detp.azimuth': 'Azimuth (°)', 'detp.elevation': 'Elevation (°)', 'detp.txPower': 'TX power (W)', 'detp.satelliteMode': 'Satellite mode', 'detp.antPath': 'Ant. path', 'detp.propagation': 'Propagation', 'detp.rig': 'Rig', 'detp.antenna': 'Antenna', 'detp.satName': 'Satellite name', 'detp.contestId': 'Contest ID', 'detp.rcvdExchangePh': 'rcvd exchange', 'detp.sentExchangePh': 'sent exchange', 'detp.contactedEmail': 'Contacted email', 'detp.contactedWeb': 'Website', // Awards (ref picker / ref selector / awards panel / award editor) 'awrp.remove': 'Remove', 'awrp.searchLabel': 'Search {label}…', 'awrp.searching': 'Searching…', 'awrp.noMatch': 'No match.', 'awrp.noMatchDxcc': 'No match for this DXCC.', - 'awrs.group': 'Group', 'awrs.sub': 'Sub', 'awrs.pickReference': '← pick a reference', 'awrs.add': 'Add', 'awrs.enterCallsignFirst': 'Enter a callsign first', 'awrs.noRefsAdded': 'No references added yet', 'awrs.references': 'References', 'awrs.autoMatchTitle': 'The {field} field is {code} — this award counts it automatically', 'awrs.fromField': 'from {field}', 'awrs.autoClickToAdd': 'auto — click to add', 'awrs.search': 'Search…', 'awrs.addUnlistedTitle': "Add this reference even though it isn't in the list yet (new / unlisted)", 'awrs.addPrefix': '+ Add', 'awrs.unlisted': '(unlisted)', 'awrs.searching': 'Searching…', 'awrs.typeToSearch': 'Type 2+ chars to search', 'awrs.enterCallsignOrSearch': 'Enter a callsign, or type to search.', 'awrs.noRefsForEntity': 'No references for this entity.', 'awrs.noResults': 'No results.', 'awrs.downloadLists': 'Download reference lists in the Awards panel → Import data.', + 'awrs.new': 'NEW', 'awrs.newRefHint': 'Never worked before', 'awrs.group': 'Group', 'awrs.sub': 'Sub', 'awrs.pickReference': '← pick a reference', 'awrs.add': 'Add', 'awrs.enterCallsignFirst': 'Enter a callsign first', 'awrs.noRefsAdded': 'No references added yet', 'awrs.references': 'References', 'awrs.autoMatchTitle': 'The {field} field is {code} — this award counts it automatically', 'awrs.fromField': 'from {field}', 'awrs.autoClickToAdd': 'auto — click to add', 'awrs.search': 'Search…', 'awrs.addUnlistedTitle': "Add this reference even though it isn't in the list yet (new / unlisted)", 'awrs.addPrefix': '+ Add', 'awrs.unlisted': '(unlisted)', 'awrs.searching': 'Searching…', 'awrs.typeToSearch': 'Type 2+ chars to search', 'awrs.enterCallsignOrSearch': 'Enter a callsign, or type to search.', 'awrs.noRefsForEntity': 'No references for this entity.', 'awrs.noResults': 'No results.', 'awrs.downloadLists': 'Download reference lists in the Awards panel → Import data.', 'awp.awards': 'Awards', 'awp.editAwards': 'Edit awards', 'awp.rescanTitle': 'Re-pull the logbook and recompute (picks up new LoTW/QRZ confirmations)', 'awp.rescan': 'Rescan', 'awp.selectAward': 'Select an award…', 'awp.of': 'of', 'awp.computing': 'Computing…', 'awp.noData': 'No data', 'awp.worked': 'worked', 'awp.confirmed': 'confirmed', 'awp.validated': 'validated', 'awp.ofConfirmed': 'of {total} · {pct}% confirmed', 'awp.byBand': 'By band (confirmed / worked)', 'awp.filterReferences': 'Filter references…', 'awp.filterAll': 'All', 'awp.filterWkd': 'Wkd', 'awp.filterNotWkd': 'Not wkd', 'awp.filterWkdNotCfmd': 'Wkd not cfmd', 'awp.modePhone': 'Phone', 'awp.modeDigital': 'Digital', 'awp.refs': 'refs', 'awp.missingRefsTitle': "Contacts in this award's scope (right DXCC/band/mode) but with no reference — they're excluded until you add it", 'awp.missingRefs': 'Missing refs', 'awp.gridView': 'Grid view', 'awp.listView': 'List view', 'awp.statistics': 'Statistics', 'awp.statistic': 'Statistic', 'awp.total': 'Total', 'awp.grand': 'Grand', 'awp.ref': 'Ref', 'awp.description': 'Description', 'awp.cellTitle': '{ref} · {band} — click to view QSOs', 'awp.name': 'Name', 'awp.groupCol': 'Group', 'awp.prefixCol': 'Prefix', 'awp.status': 'Status', 'awp.bands': 'Bands', 'awp.missing': '— missing', 'awp.contactsMissingRef': 'contacts missing a reference', 'awp.recomputeTitle': "Recompute now — contacts you've fixed drop off the list", 'awp.refresh': 'Refresh', 'awp.missingScopeHelp': "In this award's scope (DXCC / band / mode / dates) but no reference was found — so they don't count yet. Sort by a column, tick the matching contacts, then assign the reference below.", 'awp.orClickRow': '(Or click a row to open the QSO.)', 'awp.selectedArrow': '{n} selected →', 'awp.chooseReference': 'Choose a reference to assign…', 'awp.refsNarrow': '…and {n} more — type in the box to narrow the list.', 'awp.assignToSelected': 'Assign to {n} selected', 'awp.scanning': 'Scanning…', 'awp.noGaps': 'No gaps found — every contact in this award’s scope already carries a reference.', 'awp.dateUtc': 'Date (UTC)', 'awp.callsign': 'Callsign', 'awp.band': 'Band', 'awp.mode': 'Mode', 'awp.country': 'Country', 'awp.qthNote': 'QTH / Note', 'awp.stations': 'stations', 'awp.contactsWithoutRef': 'contacts without a reference', 'awp.assignedMsg': 'Assigned {code}@{ref} to {n} contact(s).', 'awp.loading': 'Loading…', 'awp.noQsos': 'No QSOs.', 'awed.addCountry': 'Add country…', 'awed.refValidFrom': 'Valid from', 'awed.refValidTo': 'Valid to', 'awed.refValidHint': 'A QSO only counts for this reference if it was made inside this window. Leave empty if the reference has always existed.', 'awed.refValidHintAward': 'Leave empty to use the award’s own window ({from} → {to}).', 'awed.exportedTo': 'Awards exported to:\n{path}', 'awed.exportedOneTo': '{code} exported to:\n{path}', 'awed.importedMsg': 'Imported {awards} award(s) and {references} reference(s).', 'awed.awardManagement': 'Award management', 'awed.searchAwards': 'Search awards…', 'awed.newAward': 'New award', 'awed.clickToDismiss': 'Click to dismiss', 'awed.selectOrCreate': 'Select or create an award.', 'awed.tabInfo': 'Award info', 'awed.tabType': 'Award type', 'awed.tabConfirmation': 'Confirmation', 'awed.tabReferences': 'References', 'awed.awardName': 'Award name', 'awed.valid': 'Valid', 'awed.deleteAward': 'Delete award', 'awed.description': 'Description', 'awed.awardUrl': 'Award URL', 'awed.refDisplay': 'Column shows', 'awed.refDisplayRef': 'Reference', 'awed.refDisplayName': 'Description / name', 'awed.refDisplayBoth': 'Both (ref — name)', 'awed.referenceUrl': 'Reference URL', 'awed.validFrom': 'Valid from', 'awed.validTo': 'Valid to', 'awed.dxccFilter': 'DXCC filter', 'awed.validBands': 'Valid bands (empty = all)', 'awed.emission': 'Emission (empty = all)', 'awed.validModes': 'Valid modes (empty = all)', 'awed.awardType': 'Award type', 'awed.dynamicRefs': 'Dynamic references (not predefined — any value counts, like POTA)', 'awed.qsoParams': 'QSO parameters (used by QSOFIELDS / REFERENCE types)', 'awed.searchInField': 'Search in field', 'awed.fieldNone': '— no field (references assigned by hand) —', 'awed.fieldNoneHint': 'Nothing is matched automatically: this award counts only the references you assign to a contact yourself, from the QSO’s reference editor. For an award like WWBOTA, which has no ADIF field of its own anywhere.', 'awed.matchBy': 'Match by', 'awed.exactMatch': 'Exact match (else search reference inside the field)', 'awed.oneRef': 'One reference per QSO', 'awed.oneRefHint': 'When several references match the same contact, assign none and list it under missing references. For awards where two entries can share a description — two DOKs called Gießen — picking one at random would write the wrong one into the log.', 'awed.patternRegex': 'Pattern (regex)', 'awed.patternPlaceholder': 'group 1 = reference (for match-by pattern / dynamic)', 'awed.leadingString': 'Leading string', 'awed.trailingString': 'Trailing string', 'awed.additionalSearches': 'Fallback searches', 'awed.orAlsoMatch': '— tried in order, only if nothing matched yet; first hit wins', 'awed.addOr': 'Add OR', 'awed.orSearchIn': 'OR — search in', 'awed.exact': 'exact', 'awed.removeOrSearch': 'Remove this OR search', 'awed.orPatternPlaceholder': 'regex — group 1 = reference (e.g. \\b(\\d{2})\\d{3}\\b for postal → dept)', 'awed.prefix': 'Prefix', 'awed.prefixPlaceholder': 'prefix (D)', 'awed.prefixTitle': 'Prepended to each found reference, e.g. 74 → D74', 'awed.customLabel': 'Custom source', 'awed.customField': 'ADIF field', 'awed.customValue': 'Value(s) that confirm (optional)', 'awed.customHint': 'For confirmations OpsLog has no column of its own for. Name any QSO field or ADIF tag — APP_OPSLOG_QSL_RCVD for a card received through OpsLog, or a tag a club list stamped on import. Leave the value empty and ANY non-empty content confirms (the OpsLog marker stores a date, not Y/N); give a comma-separated list to require one of them. A custom source naming no field confirms nothing.', 'awed.confirmationLabel': 'Confirmation (worked → confirmed)', 'awed.validationLabel': 'Validation (confirmed → validated)', 'awed.resetDefaults': 'Reset to defaults', 'awed.exportTitle': 'Export all award definitions + reference lists to a JSON backup', 'awed.export': 'Export…', 'awed.importTitle': 'Import an award bundle (definitions + reference lists)', 'awed.import': 'Import…', 'awed.cancel': 'Cancel', 'awed.save': 'Save', 'awed.populatedMsg': 'Populated {n} built-in references.', 'awed.newRefCodePrompt': 'New reference code:', 'awed.importedRefsMsg': 'Imported {n} references.', 'awed.referenceCount': 'Reference count:', 'awed.applyPreset': 'Apply preset…', 'awed.pasteCsv': 'Paste / CSV', 'awed.populateBuiltinTitle': 'Replace with the shipped built-in list (DXCC entities, French departments, …)', 'awed.populateBuiltin': 'Populate built-in', 'awed.updateOnline': 'Update online', 'awed.add': 'Add', 'awed.onePerLine': 'One reference per line:', 'awed.replacesList': '(comma/semicolon/tab). Replaces the whole list.', 'awed.import2': 'Import', 'awed.search': 'Search…', 'awed.searching': 'Searching…', 'awed.tooManyItems': 'Too many items ({total}). Please refine search (type 2+ characters).', 'awed.noReferences': 'No references.', 'awed.selectReference': 'Select a reference, or Add / import a list.', 'awed.group': 'Group', 'awed.subgroup': 'Subgroup', 'awed.perRefRegex': 'optional per-reference regex', 'awed.grid': 'Grid', 'awed.saveReference': 'Save reference', 'awed.refCodeTip': 'The reference number. Change it to renumber this reference: everything else about it is kept, and the log is refreshed.', 'awed.refCodeEmpty': 'A reference needs a number.', 'awed.updateAvailable': 'An updated version of this award is available', 'awed.updateOverwrites': 'You have modified this award, so the update was not applied. Taking it replaces your definition and reference list.', 'awed.updateApply': 'Update', 'awed.updateKeepMine': 'Keep mine', @@ -488,7 +488,7 @@ const en: Dict = { 'wbg.awardTip': '{name} — reference this QSO counts for', 'wbg.typeCall': 'Type a callsign in the entry strip to see prior contacts.', 'wbg.checking': 'checking…', 'wbg.new': 'NEW', 'wbg.noPriorPre': 'No prior QSO with ', 'wbg.noPriorPost': '.', 'wbg.workedBefore': 'Worked before', 'wbg.first': 'First:', 'wbg.last': 'Last:', 'wbg.dxcc': 'DXCC:', 'wbg.entityQsos': '{n} entity QSOs', 'wbg.clearFiltersTitle': 'Clear all column filters', 'wbg.clearFilters': 'Clear filters', 'wbg.columns': 'Columns', 'wbg.olderQsos': '+ {n} older QSOs (not shown — capped for performance)', 'wbg.pickerTitle': 'Worked-before columns', 'wbg.pickerDesc': 'Pick the columns you want visible in the Worked-before table.', 'wbg.allGroups': 'All groups:', 'wbg.all': 'all', 'wbg.none': 'none', 'wbg.grpAwards': 'Awards', 'wbg.resetDefaults': 'Reset to defaults', 'wbg.done': 'Done', 'chn.title': 'Chase new', 'chn.close': 'Hide the panel', 'chn.filterHint': 'Show or hide this kind', 'chn.allFiltered': 'Everything heard is filtered out — turn a category back on above.', 'chn.toggle': 'Chase new', 'chn.count': '{n} heard', 'chn.loading': 'Waiting for the feed…', 'chn.empty': 'Nothing new being decoded near you right now.', 'chn.digitalOnly': 'PSK Reporter — digital modes only, heard within ~300 km of you.', 'chn.option': 'Chase new (PSK Reporter)', 'chn.optionHelp': 'Lists stations being decoded near you that are new against your log — new entity, band, mode, slot, prefix or square. Digital modes only.', 'chn.show': 'Chase new panel', 'clg2.allFiltered': '{n} spots received, none shown — your filters are hiding them all.', 'clg2.activeFilters': 'Active:', 'clg2.clearAllFilters': 'Clear every filter', 'clg2.fBandLock': 'band locked to the rig', 'clg2.fBands': 'bands {list}', 'clg2.fModeLock': 'mode locked to the rig', 'clg2.fModes': 'modes {list}', 'clg2.fStatus': 'status chips', 'clg2.fHideWorked': 'hide worked', 'clg2.fLotwOnly': 'LoTW users only', 'clg2.fSpotterCont': 'spotter continent', 'clg2.fSource': 'one source node', 'clg2.fSearch': 'search “{q}”', - 'clg2.c.time': 'Time', 'clg2.c.call': 'Call', 'clg2.c.status': 'Status', 'clg2.c.pota': 'POTA', 'clg2.c.freq': 'Freq', 'clg2.c.band': 'Band', 'clg2.c.mode': 'Mode', 'clg2.c.pfx': 'Pfx', 'clg2.c.cqz': 'CQ Zone', 'clg2.h.cqz': 'CQZ', 'clg2.c.ituz': 'ITU Zone', 'clg2.h.ituz': 'ITU', 'clg2.c.distance_km': 'Distance (km)', 'clg2.h.distance_km': 'Dist km', 'clg2.c.sp_deg': 'Short path (°)', 'clg2.h.sp_deg': 'SP°', 'clg2.c.lp_deg': 'Long path (°)', 'clg2.h.lp_deg': 'LP°', 'clg2.c.country': 'Country', 'clg2.c.continent': 'Continent', 'clg2.h.continent': 'Cont', 'clg2.c.spotter': 'Spotter', 'clg2.c.source': 'Source', 'clg2.c.locator': 'Spotter locator', 'clg2.h.locator': 'Spotter loc', 'clg2.c.county': 'US County', 'clg2.tipNewCounty': 'NEW COUNTY — never worked', 'clg2.tipNewPfx': 'NEW PREFIX — this WPX prefix has never been worked', 'clg2.c.comment': 'Comment', 'clg2.c.received_at': 'Received at', 'clg2.h.received_at': 'Received UTC', 'clg2.c.raw': 'Raw', 'clg2.newDxcc': 'NEW DXCC', 'clg2.newBand': 'NEW BAND', 'clg2.newMode': 'NEW MODE', 'clg2.newSlot': 'NEW SLOT', 'clg2.newCall': 'NEW CALL', 'clg2.wkdCall': 'WKD CALL', 'clg2.newCounty': 'NEW CTY', 'clg2.newGridUnconf': 'GRID?', 'clg2.newGrid': 'NEW GRID', 'clg2.c.grid': 'Grid', 'clg2.tipNewGrid': 'NEW GRID — this square has never been worked (grid heard in a CQ on the UDP link)', 'clg2.newPfx': "NEW PFX", 'clg2.newPota': 'NEW POTA', 'clg2.tipNewDxcc': 'NEW DXCC: {country}', 'clg2.tipWorkedCall': 'Already worked this call', 'clg2.tipNewBand': 'NEW BAND for this entity', 'clg2.tipNewSlotBand': 'NEW SLOT (mode not yet worked on this band)', 'clg2.tipNewMode': 'NEW MODE (this mode never worked on this entity)', 'clg2.tipNewSlot': 'NEW SLOT (this band+mode not yet worked)', 'clg2.tipNewCall': 'NEW CALL — this callsign has never been worked on this band and mode (the entity has)', 'clg2.tipPota': 'POTA — {name}', 'clg2.grpSpot': 'Spot', 'clg2.grpGeo': 'Geo', 'clg2.clearFiltersTitle': 'Clear all column filters', 'clg2.clearFilters': 'Clear filters', 'clg2.columns': 'Columns', 'clg2.pickerTitle': 'Cluster columns', 'clg2.pickerDesc': 'Pick the columns you want visible in the Cluster table.', 'clg2.allGroups': 'All groups:', 'clg2.all': 'all', 'clg2.none': 'none', 'clg2.resetDefaults': 'Reset to defaults', 'clg2.done': 'Done', + 'clg2.c.time': 'Time', 'clg2.c.call': 'Call', 'clg2.c.status': 'Status', 'clg2.c.pota': 'POTA', 'clg2.c.freq': 'Freq', 'clg2.c.band': 'Band', 'clg2.c.mode': 'Mode', 'clg2.c.pfx': 'Pfx', 'clg2.c.cqz': 'CQ Zone', 'clg2.h.cqz': 'CQZ', 'clg2.c.ituz': 'ITU Zone', 'clg2.h.ituz': 'ITU', 'clg2.c.distance_km': 'Distance (km)', 'clg2.h.distance_km': 'Dist km', 'clg2.c.sp_deg': 'Short path (°)', 'clg2.h.sp_deg': 'SP°', 'clg2.c.lp_deg': 'Long path (°)', 'clg2.h.lp_deg': 'LP°', 'clg2.c.country': 'Country', 'clg2.c.continent': 'Continent', 'clg2.h.continent': 'Cont', 'clg2.c.spotter': 'Spotter', 'clg2.c.source': 'Source', 'clg2.c.locator': 'Spotter locator', 'clg2.h.locator': 'Spotter loc', 'clg2.c.county': 'US County', 'clg2.tipNewCounty': 'NEW COUNTY — never worked', 'clg2.tipNewPfx': 'NEW PREFIX — this WPX prefix has never been worked', 'clg2.c.comment': 'Comment', 'clg2.c.received_at': 'Received at', 'clg2.h.received_at': 'Received UTC', 'clg2.c.raw': 'Raw', 'clg2.newDxcc': 'NEW DXCC', 'clg2.newBandMode': 'NEW B+M', 'clg2.newBand': 'NEW BAND', 'clg2.newMode': 'NEW MODE', 'clg2.newSlot': 'NEW SLOT', 'clg2.newCall': 'NEW CALL', 'clg2.wkdCall': 'WKD CALL', 'clg2.newCounty': 'NEW CTY', 'clg2.newGridUnconf': 'GRID?', 'clg2.newGrid': 'NEW GRID', 'clg2.c.grid': 'Grid', 'clg2.tipNewGrid': 'NEW GRID — this square has never been worked (grid heard in a CQ on the UDP link)', 'clg2.newPfx': "NEW PFX", 'clg2.newPota': 'NEW POTA', 'clg2.tipNewDxcc': 'NEW DXCC: {country}', 'clg2.tipWorkedCall': 'Already worked this call', 'clg2.tipNewBandMode': 'NEW BAND AND NEW MODE for this entity — neither has been worked with it', 'clg2.tipNewBand': 'NEW BAND for this entity', 'clg2.tipNewSlotBand': 'NEW SLOT (mode not yet worked on this band)', 'clg2.tipNewMode': 'NEW MODE (this mode never worked on this entity)', 'clg2.tipNewSlot': 'NEW SLOT (this band+mode not yet worked)', 'clg2.tipNewCall': 'NEW CALL — this callsign has never been worked on this band and mode (the entity has)', 'clg2.tipPota': 'POTA — {name}', 'clg2.grpSpot': 'Spot', 'clg2.grpGeo': 'Geo', 'clg2.clearFiltersTitle': 'Clear all column filters', 'clg2.clearFilters': 'Clear filters', 'clg2.columns': 'Columns', 'clg2.pickerTitle': 'Cluster columns', 'clg2.pickerDesc': 'Pick the columns you want visible in the Cluster table.', 'clg2.allGroups': 'All groups:', 'clg2.all': 'all', 'clg2.none': 'none', 'clg2.resetDefaults': 'Reset to defaults', 'clg2.done': 'Done', // Audio devices & voice keyer (Preferences → Audio devices). 'aud.refreshDevices': 'Refresh devices', 'aud.fromRadio': 'From Radio (RX in)', 'aud.toRadio': 'To Radio (TX out)', 'aud.recMic': 'Recording mic', 'aud.listening': 'Listening (preview)', 'aud.phFromRadio': 'Rig audio output → soundcard input', 'aud.phToRadio': 'Soundcard output → rig mic/data in', 'aud.phRecMic': 'Your microphone (record voice-keyer messages)', 'aud.phListening': 'Local speakers for preview', @@ -554,7 +554,7 @@ const fr: Dict = { 'settings.language': 'Langue', 'gen.dateFormat': 'Affichage des dates', 'gen.dateStandard': 'Standard', 'gen.dateFR': 'Fran\u00e7ais', 'gen.dateUS': 'US', 'settings.languageHint': "Langue de l'interface.", 'stats.tab': 'Statistiques', 'stats.title': 'Statistiques du journal', 'stats.loading': 'Analyse du journal…', 'stats.noData': 'Aucune donnée', 'stats.charts': 'Graphiques', 'stats.table': 'Tableau', 'stats.refresh': 'Rafraîchir', - 'stats.qsos': 'QSO', 'stats.uniqueCalls': 'Indicatifs uniques', 'stats.entities': 'Entités', + 'stats.qsos': 'QSO', 'stats.uniqueCalls': 'Indicatifs uniques', 'stats.lastNewDxcc': 'dernière nouvelle', 'stats.entities': 'Entités', 'stats.continents': 'Continents', 'stats.confirmed': 'Confirmés', 'stats.byBand': 'Par bande', 'stats.byBandSub': "Dans l'ordre du plan de bande, pas par taille", 'stats.bandSplit': 'Répartition des modes par bande', 'stats.bandSplitSub': 'CW / phone / data par bande', 'stats.byMode': 'Par mode', 'stats.byOperator': 'Par opérateur', @@ -592,7 +592,7 @@ const fr: Dict = { 'settings.telemetry': "Envoyer des statistiques d'usage anonymes", 'settings.telemetryHint': "ID d'installation + version + OS, une fois par jour — aucun indicatif ni donnée QSO", 'settings.mainView': 'Vue principale', - 'settings.mainViewHint': "Choisis ce que l'onglet Principal affiche, jusqu’à quatre volets (par profil). Laisse le troisième et le quatrième vides et ils ne sont pas dessinés ; chaque séparateur se glisse, et un double-clic les remet à égalité.", + 'settings.mainViewHint': "Ce que l'onglet Principal affiche, jusqu’à quatre volets (par profil).", 'settings.leftPane': 'Volet gauche', 'settings.thirdPane': 'Troisième volet', 'settings.fourthPane': 'Quatrième volet', 'settings.paneNone': '— aucun —', 'settings.paneLayout': 'Avec quatre volets :', 'settings.paneQuad': 'Quarts (2 × 2)', 'settings.paneCols': 'Quatre colonnes', 'settings.rightPane': 'Volet droit', 'settings.pane.map1': 'Carte — orthodromie + faisceau', 'settings.pane.map2': 'Carte — locator (rue)', 'settings.pane.cluster': 'Spots cluster', 'settings.pane.worked': 'Déjà contactés', @@ -635,7 +635,7 @@ const fr: Dict = { 'dec.empty': "Aucun decode pour l'instant. Ils arrivent de WSJT-X, JTDX ou MSHV par le lien UDP entrant (Reglages -> UDP).", 'dec.emptyFiltered': 'Aucun decode ne correspond a ces filtres.', 'sec.email': 'E-mail (SMTP)', 'sec.lookup': "Recherche d'indicatif", - 'sec.ftx': 'Décodages FTx', 'ftx.hint': 'Ce qu’OpsLog fait de lui-même avec le flux de décodages numériques.', 'ftx.enable': 'Appel automatique', 'ftx.enableHint': 'répondre à un décodage sans cliquer', 'ftx.callWhen': 'Appeler une station qui est :', 'ftx.watch': 'Liste de surveillance', 'ftx.watchHint': 'Un indicatif par ligne, jokers acceptés (4S7*, */P). Une station surveillée est appelée avant les critères ci-dessus.', 'ftx.watchOnlyIf': 'mais seulement si elle est aussi :', 'ftx.cooldown': 'Ignorer un indicatif pendant', 'ftx.warn': 'Ceci met ton émetteur en marche sans te demander. Uniquement sur un CQ, jamais pendant que tu émets déjà, une station à la fois, et chaque appel est écrit dans le journal avec sa raison. Stop l’interrompt.', 'ftx.c_dxcc': 'une nouvelle entité DXCC', 'ftx.c_band': 'une nouvelle bande pour l’entité', 'ftx.c_mode': 'un nouveau mode pour l’entité', 'ftx.c_slot': 'un nouveau slot (bande+mode jamais faits ensemble)', 'ftx.c_grid': 'un nouveau carré locator', 'ftx.c_county': 'un nouveau comté US', 'ftx.c_pota': 'un nouveau parc POTA', 'ftx.c_pfx': 'un nouveau préfixe WPX', + 'sec.ftx': 'Décodages FTx', 'ftx.hint': 'Ce qu’OpsLog fait de lui-même avec le flux de décodages numériques.', 'ftx.enable': 'Appel automatique', 'ftx.enableHint': 'répondre à un décodage sans cliquer', 'ftx.callWhen': 'Appeler une station qui est :', 'ftx.watch': 'Liste de surveillance', 'ftx.watchHint': 'Un indicatif par ligne, jokers acceptés (4S7*, */P). Une station surveillée est appelée avant les critères ci-dessus.', 'ftx.watchOnlyIf': 'mais seulement si elle est aussi :', 'ftx.cooldown': 'Ignorer un indicatif pendant', 'ftx.warn': 'Ceci met ton émetteur en marche sans te demander. Uniquement sur un CQ, jamais pendant que tu émets déjà, une station à la fois, et chaque appel est écrit dans le journal avec sa raison. Stop l’interrompt.', 'ftx.c_dxcc': 'une nouvelle entité DXCC', 'ftx.c_bandmode': 'une nouvelle bande ET un nouveau mode pour l’entité', 'ftx.c_band': 'une nouvelle bande pour l’entité', 'ftx.c_mode': 'un nouveau mode pour l’entité', 'ftx.c_slot': 'un nouveau slot (bande+mode jamais faits ensemble)', 'ftx.c_grid': 'un nouveau carré locator', 'ftx.c_county': 'un nouveau comté US', 'ftx.c_pota': 'un nouveau parc POTA', 'ftx.c_pfx': 'un nouveau préfixe WPX', 'sec.bands': 'Bandes', 'sec.modes': 'Modes & RST par défaut', 'sec.cluster': 'DX Cluster', 'sec.udp': 'Connexions', 'sec.database': 'Base de données', 'sec.autostart': 'Démarrage auto', 'sec.backup': 'Sauvegarde base', 'sec.uscounties': 'Comtés US', 'nav.maintenance': 'Maintenance', 'sec.databases': 'Bases de données', 'db.hint': 'Les données de référence qu’OpsLog garde sur disque. Une ligne chacune, avec ce qu’elle contient et sa dernière actualisation.', 'db.update': 'Mettre à jour', 'db.never': 'jamais téléchargée', 'db.cty': 'Fichier pays (cty.dat)', 'db.ctyDetail': '{n} entités · fichier daté du {d}', 'db.clublog': 'Exceptions pays Club Log', 'db.clublogDetail': '{n} exceptions · {d}', 'db.lotwUsers': 'Utilisateurs LoTW', 'db.lotwDetail': '{n} indicatifs · {d}', 'db.scp': 'Super Check Partial (MASTER.SCP)', 'db.scpDetail': '{n} indicatifs · {d}', 'db.uls': 'Comtés US (FCC ULS)', 'db.ulsDetail': '{n} indicatifs · {d}', 'db.rda': 'Districts russes (RDA)', 'db.rdaDetail': '{n} indicatifs, avec leurs périodes d’activité datées', 'db.rdaNote': 'intégrée', 'db.refLists': 'Listes de références des diplômes', 'db.refListsHint': 'Seuls les diplômes ayant une source en ligne apparaissent ici ; les autres sont livrés ou édités à la main.', 'db.refDetail': '{n} références · {d}', 'db.refUpdated': '{code} : {n} références.', 'db.noRefLists': 'Aucun diplôme n’a de liste de références en ligne.', 'sec.rda': 'Districts russes (RDA)', 'rda.hint': 'La base de districts hors ligne, et l’unique opération de masse qu’elle alimente.', 'rda.dbTitle': 'Base des districts', 'rda.dbCount': '{n} indicatifs russes, chacun avec le district d’où il émet et, pour ceux qui ont déménagé, les périodes datées passées dans chacun. Intégrée à OpsLog — rien à télécharger.', 'rda.backfillTitle': 'Renseigner le district sur les QSO existants', 'rda.backfillIntro': 'Parcourt tous les contacts avec une entité russe et attribue leur référence RDA, en utilisant le district où se trouvait la station LE JOUR du contact.', 'rda.useCurrent': 'Utiliser aussi le district actuel pour les stations sans historique connu', 'rda.useCurrentHint': '(vrai pour la grande majorité — la base enregistre un historique justement pour les indicatifs qui ont bougé — mais c’est une supposition, pas un fait daté)', 'rda.backfillRun': 'Renseigner les districts', 'rda.backfillDone': '{s} QSO russes — {d} depuis une période datée, {c} depuis le district actuel, {u} inconnus, {k} en avaient déjà un.', 'rda.neverOverwrites': 'Une référence attribuée à la main n’est jamais écrasée.', 'sec.webpublish': 'Publication web', 'wpub.hint': "Publie ton journal dans un fichier destiné à un site web : une page HTML autonome ou un CSV, écrit en local et envoyé par FTP si tu le souhaites. Il est rafraîchi à chaque QSO enregistré et, si tu règles un intervalle, périodiquement.", 'wpub.enable': 'Publier le journal dans un fichier', 'wpub.fileSection': 'Le fichier', 'wpub.format': 'Format', 'wpub.formatHtml': 'Page HTML', 'wpub.formatCsv': 'CSV', 'wpub.folder': 'Dossier de sortie', 'wpub.browse': 'Parcourir…', 'wpub.fileName': 'Nom du fichier', 'wpub.title': 'Titre de la page', 'wpub.titlePh': 'vide = ton indicatif', 'wpub.count': 'N derniers QSO', 'wpub.every': 'Rafraîchir toutes les', 'wpub.everyHint': 'minutes — 0 = seulement à chaque QSO', 'wpub.columns': 'Colonnes', 'wpub.columnsCount': '{n} sur {total} choisis', 'wpub.columnsPick': 'Choisir les colonnes…', 'wpub.columnsSearch': 'Chercher un champ…', 'wpub.removeColumn': 'Cliquer pour retirer', 'wpub.columnsHint': 'Clique pour ajouter ou retirer. L ordre affiché ici est celui du fichier.', 'wpub.ftpEnable': 'Envoyer par FTP', 'wpub.ftpHost': 'Serveur / port', 'wpub.ftpUser': 'Utilisateur', 'wpub.ftpPassword': 'Mot de passe', 'wpub.ftpFolder': 'Dossier distant', 'wpub.ftpFileName': 'Nom du fichier distant', 'wpub.ftpTls': 'Utiliser TLS (FTPS)', 'wpub.publishNow': 'Publier maintenant', 'wpub.testFtp': 'Tester la connexion', 'wpub.lastRun': 'Dernière exécution :', 'sec.adifmon': 'Moniteur ADIF', @@ -787,7 +787,7 @@ const fr: Dict = { 'clu.selfSpot': "M'auto-spotter quand j'enregistre", 'clu.selfSpotEvery': 'au plus toutes les', 'clu.selfSpotMinutes': 'min', 'clu.selfSpotHint': "Annonce TON indicatif sur le cluster maître quand tu enregistres un QSO — le spot porte l'indicatif de station et la fréquence que tu viens de travailler, pour qu'on te trouve sans attendre que quelqu'un te spotte. Envoyé au premier QSO d'une fréquence, puis pas plus souvent que l'intervalle ci-dessous. Cinq minutes est le plancher : un auto-spot est du trafic que voient tous les utilisateurs du nœud.", 'clu.freeNodes': 'Nœuds publics gratuits :', - 'clu.filters': 'Filtres', 'clu.hideFilters': 'Masquer les filtres', 'clu.searchCall': 'Chercher un indicatif…', 'clu.hideWorked': 'Masquer les contactés', 'clu.groupDup': 'Grouper les doublons', 'clu.mode': 'Mode', 'clu.bands': 'Bandes', 'clu.source': 'Source', 'clu.clear': 'effacer', 'clu.allSources': 'Toutes les sources', 'clu.lockModeTitle': 'N afficher que les spots du mode de la barre de saisie', 'clu.lockBandTitle': 'Verrouiller sur la bande de la barre de saisie', 'clu.lotwOnly': 'Utilisateurs LoTW seulement', 'clu.spotterCont': 'Continent du spotter', 'clu.lotwBadge': 'Utilise LoTW', 'clu.muteWorkedShort': 'Pas de couleur sur les faits', 'clu.slotHighlightShort': 'Colorer les non faits ici', 'clu.muteWorked': 'Aucune couleur ni badge sur les stations déjà contactées', + 'clu.filters': 'Filtres', 'clu.hideFilters': 'Masquer les filtres', 'clu.searchCall': 'Chercher un indicatif…', 'clu.hideWorked': 'Masquer les contactés', 'clu.groupDup': 'Grouper les doublons', 'clu.mode': 'Mode', 'clu.myBands': 'mes bandes', 'clu.myBandsTitle': 'Sélectionne toutes les bandes de ta propre liste — sans sélection le filtre laisse passer TOUTES les bandes, y compris celles que tu n’as pas (le 4 m et le 70 cm arrivent par les flux RBN).', 'clu.bands': 'Bandes', 'clu.source': 'Source', 'clu.clear': 'effacer', 'clu.allSources': 'Toutes les sources', 'clu.lockModeTitle': 'N afficher que les spots du mode de la barre de saisie', 'clu.lockBandTitle': 'Verrouiller sur la bande de la barre de saisie', 'clu.lotwOnly': 'Utilisateurs LoTW seulement', 'clu.spotterCont': 'Continent du spotter', 'clu.lotwBadge': 'Utilise LoTW', 'clu.muteWorkedShort': 'Pas de couleur sur les faits', 'clu.slotHighlightShort': 'Colorer les non faits ici', 'clu.muteWorked': 'Aucune couleur ni badge sur les stations déjà contactées', 'clu.muteWorkedHint': '(elles restent dans la liste, simplement discrètes — la couleur reste pour ce qui est à faire)', 'clu.slotHighlight': 'Colorer les stations non contactées sur cette bande et ce mode', 'clu.slotHighlightHint': "(par indicatif, quel que soit le statut de l'entité)", @@ -824,6 +824,7 @@ const fr: Dict = { 'cat.icomNetAudio': 'Diffuser l’audio RX par le réseau (expérimental)', 'cat.icomNetAudioHint': 'Écoute l’audio reçu du poste sur ton périphérique d’écoute (Réglages → Audio) via le flux 50003. Expérimental — le format audio reste à vérifier sur le poste ; laisse désactivé si le contrôle se comporte mal.', 'cat.omnirigRig': 'Slot OmniRig', 'cat.omnirigVfo': 'VFO à lire', 'cat.omnirigVfoAuto': 'Selon le fichier radio', 'cat.omnirigVfoA': 'Toujours le VFO A (principal)', 'cat.omnirigVfoB': 'Toujours le VFO B (secondaire)', 'cat.omnirigVfoHint': "OmniRig indique le VFO actif d'après le fichier radio, et certains fichiers se trompent — la fréquence suit alors l'autre VFO et paraît figée. Forcez-en un ici le cas échéant.", 'cat.flexIp': 'IP FlexRadio', 'cat.port': 'Port', 'cat.flexSpots': 'Afficher les spots cluster sur le panadapter', 'cat.flexSpotsHint': "(les spots du cluster DX d'OpsLog apparaissent sur la radio, expirent après 30 min)", 'cat.flexDecodeSpots': 'Afficher les décodes WSJT-X sur le panadapter', 'cat.flexDecodeSpotsHint': '(stations FT8/FT4 entendues via ton flux UDP WSJT-X/JTDX, un spot par station)', 'cat.flexDecodeSecs': 'Affichage pendant', 'cat.flexDecodeSecsHint': 'secondes avant retrait d\'une station', + 'cat.flexOptions': "Ce qu’OpsLog fait avec la radio", 'flexzoom.title': 'Zoomer le panadapter au clic sur un spot', 'flexzoom.enable': 'Redimensionner le panadapter au clic sur un spot', 'flexzoom.cw': 'CW', 'flexzoom.ssb': 'Phonie', 'flexzoom.digi': 'Numérique', 'flexzoom.centre': 'Recentrer aussi sur le spot', 'flexzoom.centreHint': '(décoché, ta fenêtre reste où tu l’as mise et seule sa largeur change)', 'spotcol.title': 'Couleurs des spots sur le panadapter', 'spotcol.enable': 'Colorer les spots selon leur statut', 'spotcol.reset': 'valeurs par défaut', 'spotcol.text': 'Couleur du texte', 'spotcol.bg': 'Couleur de fond', 'spotcol.s_new': 'Nouvelle entité', 'spotcol.s_new-band-mode': 'Nouvelle bande + nouveau mode', 'spotcol.s_new-band': 'Nouvelle bande', 'spotcol.s_new-mode': 'Nouveau mode', 'spotcol.s_new-slot': 'Nouveau slot', 'spotcol.s_new-pota': 'Nouveau parc POTA', 'spotcol.s_new-county': 'Nouveau comté US', 'spotcol.s_new-pfx': 'Nouveau préfixe WPX', 'spotcol.s_my-call': 'Mon propre indicatif', 'spotcol.s_worked': 'Déjà contacté', 'spotcol.s_none': 'Entité non résolue', 'cat.flexDvkDax': "Basculer l'audio d'émission sur DAX pour les messages vocaux", 'cat.flexDvkDaxHint': "(enfoncé le temps d'un message DVK ou d'un enregistrement de QSO, puis remis comme avant pour retrouver ton micro)", 'cat.icomPort': 'Port CI-V Icom', 'cat.selectCom': 'Choisir un port COM', 'cat.noPorts': 'Aucun port trouvé', 'cat.baud': 'Débit (baud)', 'cat.icomModel': 'Modèle de poste', 'cat.icomModelOther': 'Autre (adresse perso)', 'cat.civAddr': 'Adresse CI-V (hex)', 'cat.civHint': 'Choisis ton modèle pour fixer l’adresse CI-V automatiquement (ou « Autre » et saisis-la). Mets « CI-V USB Echo Back » sur OFF et fais correspondre le débit CI-V sur le poste.', @@ -872,10 +873,10 @@ const fr: Dict = { 'chp.workedBefore': 'Déjà contacté', 'chp.typeCallsign': 'Saisis un indicatif pour voir les contacts précédents.', 'chp.checking': 'vérification…', 'chp.new': 'NOUVEAU', 'chp.noPriorQso': 'Aucun QSO antérieur avec cet indicatif.', 'chp.first': 'Premier', 'chp.last': 'Dernier', 'chp.dateUtc': 'Date UTC', 'chp.band': 'Bande', 'chp.mode': 'Mode', 'chp.lotwRcvd': 'LoTW reçue', 'chp.bureauRcvd': 'Bureau reçue', 'chp.olderQsos': '+ {n} QSO plus anciens', - 'bmp.statusNew': 'NOUVEAU DXCC (entité jamais contactée)', 'bmp.statusNewBand': 'NOUVELLE BANDE (entité non contactée sur cette bande)', 'bmp.statusNewSlot': 'NOUVEAU MODE (mode non contacté sur cette bande)', 'bmp.statusNewCall': "CALL NEUF (indicatif jamais contacté sur cette bande et ce mode)", 'bmp.statusNewMode': 'NOUVEAU MODE (mode jamais contacté pour cette entité)', + 'bmp.statusNew': 'NOUVEAU DXCC (entité jamais contactée)', 'bmp.statusNewBandMode': 'NOUVEAU BANDE+MODE (ni l’un ni l’autre fait avec cette entité)', 'bmp.statusNewBand': 'NOUVELLE BANDE (entité non contactée sur cette bande)', 'bmp.statusNewSlot': 'NOUVEAU MODE (mode non contacté sur cette bande)', 'bmp.statusNewCall': "CALL NEUF (indicatif jamais contacté sur cette bande et ce mode)", 'bmp.statusNewMode': 'NOUVEAU MODE (mode jamais contacté pour cette entité)', 'bmp.statusWorked': 'Contacté (cette bande + mode déjà au log)', 'bmp.statusUnresolved': 'Entité non résolue', 'bmp.bandMap': 'Carte de bande', 'bmp.notConfigured': 'Non configurée pour {band}.', 'bmp.zoomOut': 'Dézoomer', 'bmp.zoomIn': 'Zoomer', 'bmp.scrollToRig': 'Aller à la fréquence actuelle du poste', 'bmp.moveLeft': 'Déplacer la carte de bande à gauche', 'bmp.moveRight': 'Déplacer la carte de bande à droite', 'bmp.hide': 'Masquer la carte de bande', - 'bmp.bandsLabel': 'Bandes :', 'bmp.fit': 'FIT', 'bmp.hideFt': 'Masquer FTx', 'bmp.hideFtTitle': 'Masquer tous les spots numériques (FT8/FT4/JS8/…) sur toutes les cartes', 'bmp.fitBand': 'Ajuster à la bande', 'bmp.widthTip': 'Glisser pour redimensionner — double-clic pour réinitialiser', 'bmp.fitTitle': 'Dimensionner chaque carte pour afficher toute la bande', + 'bmp.bandsLabel': 'Bandes :', 'bmp.fit': 'FIT', 'bmp.ftx': 'FTx', 'bmp.hideFt': 'Masquer FTx', 'bmp.hideFtTitle': 'Masquer tous les spots numériques (FT8/FT4/JS8/…) sur toutes les cartes', 'bmp.fitBand': 'Ajuster à la bande', 'bmp.widthTip': 'Glisser pour redimensionner — double-clic pour réinitialiser', 'bmp.fitTitle': 'Dimensionner chaque carte pour afficher toute la bande', 'bmp.legendNewDxcc': 'Nouveau DXCC', 'bmp.legendNewBand': 'Nouvelle bande', 'bmp.legendNewSlot': 'Nouveau mode', 'bmp.openUnusual': 'inhabituel pour la saison', 'bmp.legendWorked': 'Contacté', 'bmp.legendNewPota': 'Nouveau POTA', 'bmp.legendNewCounty': 'Nouveau comté', 'bmp.legendWorkedCall': 'Indicatif déjà contacté', 'bmp.legendCW': 'CW', 'bmp.legendData': 'Numérique', 'bmp.legendPhone': 'Phonie', 'bmp.footerHint': 'défiler · ctrl+molette = zoom · ◎ = aller au poste', 'bmp.spotsHidden': '{n} spots FT8/FT4 masqués — {max} meilleurs conservés (CW/SSB tous affichés)', 'frm.welcome': 'Bienvenue dans OpsLog', 'frm.intro': 'Configure ta station pour commencer à logger. Ces champs sont inscrits sur chaque QSO et peuvent être modifiés plus tard dans Préférences → Informations station (et par profil).', 'frm.callsign': 'Indicatif', 'frm.locator': 'Locator', 'frm.operator': 'Opérateur', 'frm.operatorPh': "identique à l'indicatif", 'frm.owner': 'Propriétaire', 'frm.ownerPh': 'indicatif du propriétaire de la station', 'frm.name': 'Nom', 'frm.namePh': 'ton prénom', @@ -913,7 +914,7 @@ const fr: Dict = { 'fltb.fCallsign': 'Callsign', 'fltb.fDate': 'Date / time (UTC)', 'fltb.fEndDate': 'End date / time', 'fltb.fBand': 'Band', 'fltb.fRxBand': 'RX band', 'fltb.fMode': 'Mode', 'fltb.fSubmode': 'Submode', 'fltb.fFreq': 'Frequency (Hz)', 'fltb.fRxFreq': 'RX frequency (Hz)', 'fltb.fRstSent': 'RST sent', 'fltb.fRstRcvd': 'RST rcvd', 'fltb.fName': 'Name', 'fltb.fQth': 'QTH', 'fltb.fAddress': 'Address', 'fltb.fEmail': 'E-mail', 'fltb.fGrid': 'Grid', 'fltb.fCountry': 'Country', 'fltb.fState': 'State', 'fltb.fCounty': 'County', 'fltb.fDxcc': 'DXCC #', 'fltb.fContinent': 'Continent', 'fltb.fCqz': 'CQ zone', 'fltb.fItuz': 'ITU zone', 'fltb.fIota': 'IOTA', 'fltb.fSota': 'SOTA ref', 'fltb.fPota': 'POTA ref', 'fltb.fWwff': 'WWFF ref', 'fltb.fRig': 'Rig', 'fltb.fAntenna': 'Antenna', 'fltb.fQslSent': 'Paper QSL sent status', 'fltb.fQslSentDate': 'Paper QSL sent date', 'fltb.fQslRcvd': 'Paper QSL received status', 'fltb.fQslRcvdDate': 'Paper QSL received date', 'fltb.fQslSentVia': 'QSL envoyée via', 'fltb.fQslRcvdVia': 'QSL reçue via', 'fltb.fQslVia': 'QSL via', 'fltb.fLotwSent': 'LoTW sent status', 'fltb.fLotwSentDate': 'LoTW sent date', 'fltb.fLotwRcvd': 'LoTW received status', 'fltb.fLotwRcvdDate': 'LoTW received date', 'fltb.fEqslSent': 'eQSL sent status', 'fltb.fEqslSentDate': 'eQSL sent date', 'fltb.fEqslRcvd': 'eQSL received status', 'fltb.fEqslRcvdDate': 'eQSL received date', 'fltb.fQrzSent': 'QRZ.com sent status', 'fltb.fQrzSentDate': 'QRZ.com sent date', 'fltb.fQrzRcvd': 'QRZ.com received status', 'fltb.fQrzRcvdDate': 'QRZ.com received date', 'fltb.fClublogSent': 'Club Log sent status', 'fltb.fClublogSentDate': 'Club Log sent date', 'fltb.fHrdlogSent': 'HRDLog sent status', 'fltb.fHrdlogSentDate': 'HRDLog sent date', 'fltb.fContestId': 'Contest ID', 'fltb.fSerialRcvd': 'Serial rcvd', 'fltb.fSerialSent': 'Serial sent', 'fltb.fPropMode': 'Propagation mode', 'fltb.fSatellite': 'Satellite', 'fltb.fMyCallsign': 'Station callsign (my call)', 'fltb.fOperator': 'Operator', 'fltb.fOwnerCallsign': 'Owner callsign', 'fltb.fMyGrid': 'My grid', 'fltb.fMyCountry': 'My country', 'fltb.fMyState': 'My state', 'fltb.fMyCounty': 'My county', 'fltb.fMyIota': 'My IOTA', 'fltb.fMySota': 'My SOTA ref', 'fltb.fMyPota': 'My POTA ref', 'fltb.fMyWwff': 'My WWFF ref', 'fltb.fMyStreet': 'My street', 'fltb.fMyCity': 'My city', 'fltb.fMyPostal': 'My postal code', 'fltb.fMyRig': 'My rig', 'fltb.fMyAntenna': 'My antenna', 'fltb.fTxPower': 'TX power (W)', 'fltb.fComment': 'Comment', 'fltb.fNotes': 'Notes', 'fltb.opEq': 'égal (=)', 'fltb.opNe': 'différent (≠)', 'fltb.opContains': 'contient', 'fltb.opStartsWith': 'commence par', 'fltb.opEndsWith': 'finit par', 'fltb.opGt': 'supérieur à (>)', 'fltb.opLt': 'inférieur à (<)', 'fltb.opGe': 'supérieur ou égal (≥)', 'fltb.opLe': 'inférieur ou égal (≤)', 'fltb.opEmpty': 'est vide', 'fltb.opIn': 'est parmi', 'fltb.opNotIn': 'n est pas parmi', 'fltb.listPh': '2m, 70cm — séparés par des virgules', 'fltb.opNotEmpty': "n'est pas vide", 'fltb.title': 'Filtre QSO', 'fltb.match': 'Correspondance', 'fltb.all': 'TOUS (ET)', 'fltb.any': 'AU MOINS UN (OU)', 'fltb.loadPreset': 'Charger un préréglage…', 'fltb.noConditions': 'Aucune condition — la liste affiche tous les QSO. Ajoutes-en une ci-dessous.', 'fltb.where': 'OÙ', 'fltb.valuePh': 'valeur', 'fltb.remove': 'Retirer', 'fltb.addCondition': 'Ajouter une condition', 'fltb.presetNamePh': 'Nom du préréglage…', 'fltb.savePreset': 'Enregistrer le préréglage', 'fltb.clear': 'Effacer', 'fltb.cancel': 'Annuler', 'fltb.applyClose': 'Appliquer & fermer', 'detp.propAS': 'Diffusion par avion', 'detp.propAUR': 'Aurore', 'detp.propAUE': 'Aurore-E', 'detp.propBS': 'Rétrodiffusion', 'detp.propEME': 'Terre-Lune-Terre', 'detp.propES': 'Sporadique E', 'detp.propFAI': 'Irrégularités alignées au champ', 'detp.propF2': 'Réflexion F2', 'detp.propGWAVE': 'Onde de sol', 'detp.propINTERNET': 'Assisté par Internet', 'detp.propION': 'Diffusion ionosphérique', 'detp.propLOS': 'Vue directe', 'detp.propMS': 'Diffusion météoritique', 'detp.propRPT': 'Répéteur terrestre / atmosphérique', 'detp.propRS': 'Diffusion par la pluie', 'detp.propSAT': 'Satellite', 'detp.propTEP': 'Trans-équatorial', 'detp.propTR': 'Conduit troposphérique', 'detp.pathShort': 'Chemin court', 'detp.pathLong': 'Chemin long', 'detp.pathGrayline': 'Ligne grise', 'detp.pathOther': 'Autre', 'detp.tabStats': 'Stats', 'detp.tabInfo': 'Info', 'detp.tabAwards': 'Diplômes', 'detp.tabMy': 'Moi', 'detp.tabExtended': 'Étendu', 'detp.statePref': 'État / préf', 'detp.county': 'Comté', 'detp.newCounty': 'NOUV', 'detp.newCountyTip': 'Comté jamais contacté', 'detp.prefix': 'Préfixe', 'detp.cqZone': 'CQ', 'detp.ituZone': 'ITU', 'detp.dxcc': 'DXCC #', 'detp.azimuthLp': 'Azimut LP', 'detp.distanceSp': 'Distance SP', 'detp.distanceLp': 'Distance LP', 'detp.address': 'Adresse', 'detp.qslMessage': 'Message QSL', 'detp.qslVia': 'QSL via (manager)', 'detp.detected': 'Détecté — ce contact comptera pour :', 'detp.ambiguous': 'Ambigu — choisissez :', 'detp.azimuth': 'Azimut (°)', 'detp.elevation': 'Élévation (°)', 'detp.txPower': 'Puissance TX (W)', 'detp.satelliteMode': 'Mode satellite', 'detp.antPath': 'Chemin ant.', 'detp.propagation': 'Propagation', 'detp.rig': 'Station', 'detp.antenna': 'Antenne', 'detp.satName': 'Nom du satellite', 'detp.contestId': 'ID contest', 'detp.rcvdExchangePh': 'échange reçu', 'detp.sentExchangePh': 'échange envoyé', 'detp.contactedEmail': 'E-mail du contact', 'detp.contactedWeb': 'Site web', 'awrp.remove': 'Retirer', 'awrp.searchLabel': 'Rechercher {label}…', 'awrp.searching': 'Recherche…', 'awrp.noMatch': 'Aucune correspondance.', 'awrp.noMatchDxcc': 'Aucune correspondance pour ce DXCC.', - 'awrs.group': 'Groupe', 'awrs.sub': 'Sous', 'awrs.pickReference': '← choisis une référence', 'awrs.add': 'Ajouter', 'awrs.enterCallsignFirst': "Saisis d'abord un indicatif", 'awrs.noRefsAdded': 'Aucune référence ajoutée', 'awrs.references': 'Références', 'awrs.autoMatchTitle': 'Le champ {field} vaut {code} — ce diplôme le compte automatiquement', 'awrs.fromField': 'depuis {field}', 'awrs.autoClickToAdd': 'auto — clic pour ajouter', 'awrs.search': 'Rechercher…', 'awrs.addUnlistedTitle': "Ajouter cette référence même si elle n'est pas encore dans la liste (nouvelle / non listée)", 'awrs.addPrefix': '+ Ajouter', 'awrs.unlisted': '(non listée)', 'awrs.searching': 'Recherche…', 'awrs.typeToSearch': 'Tape 2+ caractères pour chercher', 'awrs.enterCallsignOrSearch': 'Saisis un indicatif, ou tape pour chercher.', 'awrs.noRefsForEntity': 'Aucune référence pour cette entité.', 'awrs.noResults': 'Aucun résultat.', 'awrs.downloadLists': 'Télécharge les listes de références dans le panneau Diplômes → Importer les données.', + 'awrs.new': 'NEW', 'awrs.newRefHint': 'Jamais contactée', 'awrs.group': 'Groupe', 'awrs.sub': 'Sous', 'awrs.pickReference': '← choisis une référence', 'awrs.add': 'Ajouter', 'awrs.enterCallsignFirst': "Saisis d'abord un indicatif", 'awrs.noRefsAdded': 'Aucune référence ajoutée', 'awrs.references': 'Références', 'awrs.autoMatchTitle': 'Le champ {field} vaut {code} — ce diplôme le compte automatiquement', 'awrs.fromField': 'depuis {field}', 'awrs.autoClickToAdd': 'auto — clic pour ajouter', 'awrs.search': 'Rechercher…', 'awrs.addUnlistedTitle': "Ajouter cette référence même si elle n'est pas encore dans la liste (nouvelle / non listée)", 'awrs.addPrefix': '+ Ajouter', 'awrs.unlisted': '(non listée)', 'awrs.searching': 'Recherche…', 'awrs.typeToSearch': 'Tape 2+ caractères pour chercher', 'awrs.enterCallsignOrSearch': 'Saisis un indicatif, ou tape pour chercher.', 'awrs.noRefsForEntity': 'Aucune référence pour cette entité.', 'awrs.noResults': 'Aucun résultat.', 'awrs.downloadLists': 'Télécharge les listes de références dans le panneau Diplômes → Importer les données.', 'awp.awards': 'Diplômes', 'awp.editAwards': 'Éditer les diplômes', 'awp.rescanTitle': 'Recharger le journal et recalculer (récupère les nouvelles confirmations LoTW/QRZ)', 'awp.rescan': 'Rescan', 'awp.selectAward': 'Sélectionner un diplôme…', 'awp.of': 'sur', 'awp.computing': 'Calcul…', 'awp.noData': 'Aucune donnée', 'awp.worked': 'contacté', 'awp.confirmed': 'confirmé', 'awp.validated': 'validé', 'awp.ofConfirmed': 'sur {total} · {pct}% confirmés', 'awp.byBand': 'Par bande (confirmés / contactés)', 'awp.filterReferences': 'Filtrer les références…', 'awp.filterAll': 'Tous', 'awp.filterWkd': 'Contactés', 'awp.filterNotWkd': 'Non contactés', 'awp.filterWkdNotCfmd': 'Contactés non conf.', 'awp.modePhone': 'Phonie', 'awp.modeDigital': 'Numérique', 'awp.refs': 'réf.', 'awp.missingRefsTitle': "Contacts dans le périmètre de ce diplôme (bon DXCC/bande/mode) mais sans référence — exclus tant que tu n'en ajoutes pas", 'awp.missingRefs': 'Réf. manquantes', 'awp.gridView': 'Vue grille', 'awp.listView': 'Vue liste', 'awp.statistics': 'Statistiques', 'awp.statistic': 'Statistique', 'awp.total': 'Total', 'awp.grand': 'Général', 'awp.ref': 'Réf', 'awp.description': 'Description', 'awp.cellTitle': '{ref} · {band} — clic pour voir les QSO', 'awp.name': 'Nom', 'awp.groupCol': 'Groupe', 'awp.prefixCol': 'Préfixe', 'awp.status': 'Statut', 'awp.bands': 'Bandes', 'awp.missing': '— manquant', 'awp.contactsMissingRef': 'contacts sans référence', 'awp.recomputeTitle': 'Recalculer — les contacts corrigés disparaissent de la liste', 'awp.refresh': 'Rafraîchir', 'awp.missingScopeHelp': 'Dans le périmètre de ce diplôme (DXCC / bande / mode / dates) mais aucune référence trouvée — ils ne comptent donc pas encore. Trie par colonne, coche les contacts concernés, puis attribue la référence ci-dessous.', 'awp.orClickRow': '(Ou clique une ligne pour ouvrir le QSO.)', 'awp.selectedArrow': '{n} sélectionné(s) →', 'awp.chooseReference': 'Choisir une référence à attribuer…', 'awp.refsNarrow': '…et {n} autres — tape dans le champ pour réduire la liste.', 'awp.assignToSelected': 'Attribuer à {n} sélectionné(s)', 'awp.scanning': 'Analyse…', 'awp.noGaps': 'Aucun manque trouvé — tous les contacts dans le périmètre de ce diplôme portent déjà une référence.', 'awp.dateUtc': 'Date (UTC)', 'awp.callsign': 'Indicatif', 'awp.band': 'Bande', 'awp.mode': 'Mode', 'awp.country': 'Pays', 'awp.qthNote': 'QTH / Note', 'awp.stations': 'stations', 'awp.contactsWithoutRef': 'contacts sans référence', 'awp.assignedMsg': '{code}@{ref} attribué à {n} contact(s).', 'awp.loading': 'Chargement…', 'awp.noQsos': 'Aucun QSO.', 'awed.addCountry': 'Ajouter un pays…', 'awed.refValidFrom': 'Valide à partir du', 'awed.refValidTo': 'Valide jusqu’au', 'awed.refValidHint': 'Un QSO ne compte pour cette référence que s’il a été fait dans cette fenêtre. Laisser vide si la référence a toujours existé.', 'awed.refValidHintAward': 'Laisser vide pour utiliser la fenêtre du diplôme ({from} → {to}).', 'awed.exportedTo': 'Diplômes exportés vers :\n{path}', 'awed.exportedOneTo': '{code} exporté vers :\n{path}', 'awed.importedMsg': '{awards} diplôme(s) et {references} référence(s) importés.', 'awed.awardManagement': 'Gestion des diplômes', 'awed.searchAwards': 'Rechercher un diplôme…', 'awed.newAward': 'Nouveau diplôme', 'awed.clickToDismiss': 'Cliquer pour fermer', 'awed.selectOrCreate': 'Sélectionne ou crée un diplôme.', 'awed.tabInfo': 'Infos diplôme', 'awed.tabType': 'Type de diplôme', 'awed.tabConfirmation': 'Confirmation', 'awed.tabReferences': 'Références', 'awed.awardName': 'Nom du diplôme', 'awed.valid': 'Valide', 'awed.deleteAward': 'Supprimer le diplôme', 'awed.description': 'Description', 'awed.awardUrl': 'URL du diplôme', 'awed.refDisplay': 'La colonne affiche', 'awed.refDisplayRef': 'Référence', 'awed.refDisplayName': 'Description / nom', 'awed.refDisplayBoth': 'Les deux (réf — nom)', 'awed.referenceUrl': 'URL de référence', 'awed.validFrom': 'Valide du', 'awed.validTo': 'Valide au', 'awed.dxccFilter': 'Filtre DXCC', 'awed.validBands': 'Bandes valides (vide = toutes)', 'awed.emission': 'Émission (vide = toutes)', 'awed.validModes': 'Modes valides (vide = tous)', 'awed.awardType': 'Type de diplôme', 'awed.dynamicRefs': 'Références dynamiques (non prédéfinies — toute valeur compte, comme POTA)', 'awed.qsoParams': 'Paramètres QSO (utilisés par les types QSOFIELDS / REFERENCE)', 'awed.searchInField': 'Chercher dans le champ', 'awed.fieldNone': '— aucun champ (références attribuées à la main) —', 'awed.fieldNoneHint': 'Rien n’est reconnu automatiquement : ce diplôme ne compte que les références que tu attribues toi-même à un contact, depuis l’éditeur de références du QSO. Pour un diplôme comme WWBOTA, qui n’a de champ ADIF nulle part.', 'awed.matchBy': 'Correspondance par', 'awed.exactMatch': 'Correspondance exacte (sinon cherche la référence dans le champ)', 'awed.oneRef': 'Une seule référence par QSO', 'awed.oneRefHint': 'Quand plusieurs références correspondent au même contact, n'+'’en affecter aucune et le lister dans les références manquantes. Pour les diplômes où deux entrées partagent une description — deux DOK nommés Gießen — en choisir une au hasard inscrirait la mauvaise dans le journal.', 'awed.patternRegex': 'Motif (regex)', 'awed.patternPlaceholder': 'groupe 1 = référence (pour correspondance par motif / dynamique)', 'awed.leadingString': 'Chaîne de début', 'awed.trailingString': 'Chaîne de fin', 'awed.additionalSearches': 'Recherches de repli', 'awed.orAlsoMatch': "— essayées dans l'ordre, seulement si rien n'a encore été trouvé ; la première qui marche gagne", 'awed.addOr': 'Ajouter OU', 'awed.orSearchIn': 'OU — chercher dans', 'awed.exact': 'exact', 'awed.removeOrSearch': 'Supprimer cette recherche OU', 'awed.orPatternPlaceholder': 'regex — groupe 1 = référence (ex. \\b(\\d{2})\\d{3}\\b pour code postal → dépt)', 'awed.prefix': 'Préfixe', 'awed.prefixPlaceholder': 'préfixe (D)', 'awed.prefixTitle': 'Ajouté devant chaque référence trouvée, ex. 74 → D74', 'awed.customLabel': 'Source personnalisée', 'awed.customField': 'Champ ADIF', 'awed.customValue': 'Valeur(s) qui confirment (facultatif)', 'awed.customHint': "Pour les confirmations dont OpsLog n'a pas de colonne dédiée. Indique n'importe quel champ de QSO ou balise ADIF — APP_OPSLOG_QSL_RCVD pour une carte reçue via OpsLog, ou une balise inscrite à l'import d'une liste de club. Laisse la valeur vide et TOUT contenu non vide confirme (le marqueur OpsLog stocke une date, pas un Y/N) ; mets une liste séparée par des virgules pour en exiger une. Une source personnalisée sans champ ne confirme rien.", 'awed.confirmationLabel': 'Confirmation (contacté → confirmé)', 'awed.validationLabel': 'Validation (confirmé → validé)', 'awed.resetDefaults': 'Réinitialiser par défaut', 'awed.exportTitle': 'Exporter toutes les définitions de diplômes + listes de références vers une sauvegarde JSON', 'awed.export': 'Exporter…', 'awed.importTitle': 'Importer un lot de diplômes (définitions + listes de références)', 'awed.import': 'Importer…', 'awed.cancel': 'Annuler', 'awed.save': 'Enregistrer', 'awed.populatedMsg': '{n} références intégrées ajoutées.', 'awed.newRefCodePrompt': 'Nouveau code de référence :', 'awed.importedRefsMsg': '{n} références importées.', 'awed.referenceCount': 'Nombre de références :', 'awed.applyPreset': 'Appliquer un préréglage…', 'awed.pasteCsv': 'Coller / CSV', 'awed.populateBuiltinTitle': 'Remplacer par la liste intégrée fournie (entités DXCC, départements français, …)', 'awed.populateBuiltin': "Charger l'intégrée", 'awed.updateOnline': 'Mettre à jour en ligne', 'awed.add': 'Ajouter', 'awed.onePerLine': 'Une référence par ligne :', 'awed.replacesList': '(virgule/point-virgule/tab). Remplace toute la liste.', 'awed.import2': 'Importer', 'awed.search': 'Rechercher…', 'awed.searching': 'Recherche…', 'awed.tooManyItems': "Trop d'éléments ({total}). Affine la recherche (tape 2+ caractères).", 'awed.noReferences': 'Aucune référence.', 'awed.selectReference': 'Sélectionne une référence, ou Ajouter / importer une liste.', 'awed.group': 'Groupe', 'awed.subgroup': 'Sous-groupe', 'awed.perRefRegex': 'regex optionnelle par référence', 'awed.grid': 'Locator', 'awed.saveReference': 'Enregistrer la référence', 'awed.refCodeTip': 'Le numéro de la référence. Modifie-le pour la renuméroter : tout le reste est conservé, et le journal est rafraîchi.', 'awed.refCodeEmpty': 'Une référence a besoin d’un numéro.', 'awed.updateAvailable': 'Une nouvelle version de ce diplôme est disponible', 'awed.updateOverwrites': "Tu as modifié ce diplôme, la mise à jour n'a donc pas été appliquée. L'accepter remplacera ta définition et ta liste de références.", 'awed.updateApply': 'Mettre à jour', 'awed.updateKeepMine': 'Garder les miennes', @@ -956,7 +957,7 @@ const fr: Dict = { 'wbg.awardTip': '{name} — référence comptée pour ce QSO', 'wbg.typeCall': 'Saisissez un indicatif dans la barre pour voir les contacts précédents.', 'wbg.checking': 'vérification…', 'wbg.new': 'NOUVEAU', 'wbg.noPriorPre': 'Aucun QSO précédent avec ', 'wbg.noPriorPost': '.', 'wbg.workedBefore': 'Déjà contacté', 'wbg.first': 'Premier :', 'wbg.last': 'Dernier :', 'wbg.dxcc': 'DXCC :', 'wbg.entityQsos': '{n} QSO avec cette entité', 'wbg.clearFiltersTitle': 'Effacer tous les filtres de colonne', 'wbg.clearFilters': 'Effacer les filtres', 'wbg.columns': 'Colonnes', 'wbg.olderQsos': '+ {n} QSO plus anciens (non affichés — limités pour la performance)', 'wbg.pickerTitle': 'Colonnes « Déjà contacté »', 'wbg.pickerDesc': 'Choisissez les colonnes à afficher dans le tableau « Déjà contacté ».', 'wbg.allGroups': 'Tous les groupes :', 'wbg.all': 'tout', 'wbg.none': 'aucun', 'wbg.grpAwards': 'Diplômes', 'wbg.resetDefaults': 'Réinitialiser', 'wbg.done': 'Terminé', 'chn.title': 'Chasse au nouveau', 'chn.close': 'Masquer le panneau', 'chn.filterHint': 'Afficher ou masquer ce type', 'chn.allFiltered': 'Tout ce qui est entendu est filtré — réactivez une catégorie ci-dessus.', 'chn.toggle': 'Chasse au nouveau', 'chn.count': '{n} entendus', 'chn.loading': 'En attente du flux…', 'chn.empty': 'Rien de nouveau décodé près de vous pour le moment.', 'chn.digitalOnly': 'PSK Reporter — modes numériques uniquement, entendus à moins de ~300 km.', 'chn.option': 'Chasse au nouveau (PSK Reporter)', 'chn.optionHelp': 'Liste les stations décodées près de chez vous qui sont nouvelles par rapport à votre log — entité, bande, mode, créneau, préfixe ou carré. Modes numériques uniquement.', 'chn.show': 'Panneau chasse au nouveau', 'clg2.allFiltered': '{n} spots reçus, aucun affiché — vos filtres les masquent tous.', 'clg2.activeFilters': 'Actifs :', 'clg2.clearAllFilters': 'Effacer tous les filtres', 'clg2.fBandLock': 'bande verrouillée sur la radio', 'clg2.fBands': 'bandes {list}', 'clg2.fModeLock': 'mode verrouillé sur la radio', 'clg2.fModes': 'modes {list}', 'clg2.fStatus': 'pastilles de statut', 'clg2.fHideWorked': 'masquer les contactés', 'clg2.fLotwOnly': 'utilisateurs LoTW uniquement', 'clg2.fSpotterCont': 'continent du spotteur', 'clg2.fSource': 'un seul nœud source', 'clg2.fSearch': 'recherche « {q} »', - 'clg2.c.time': 'Heure', 'clg2.c.call': 'Indicatif', 'clg2.c.status': 'Statut', 'clg2.c.pota': 'POTA', 'clg2.c.freq': 'Fréq', 'clg2.c.band': 'Bande', 'clg2.c.mode': 'Mode', 'clg2.c.pfx': 'Préf.', 'clg2.c.cqz': 'Zone CQ', 'clg2.h.cqz': 'CQZ', 'clg2.c.ituz': 'Zone ITU', 'clg2.h.ituz': 'ITU', 'clg2.c.distance_km': 'Distance (km)', 'clg2.h.distance_km': 'Dist km', 'clg2.c.sp_deg': 'Chemin court (°)', 'clg2.h.sp_deg': 'CC°', 'clg2.c.lp_deg': 'Chemin long (°)', 'clg2.h.lp_deg': 'CL°', 'clg2.c.country': 'Pays', 'clg2.c.continent': 'Continent', 'clg2.h.continent': 'Cont', 'clg2.c.spotter': 'Spotter', 'clg2.c.source': 'Source', 'clg2.c.locator': 'Locator du spotter', 'clg2.h.locator': 'Loc spotter', 'clg2.c.county': 'Comté US', 'clg2.tipNewCounty': 'NOUVEAU COMTÉ — jamais contacté', 'clg2.tipNewPfx': "NOUVEAU PRÉFIXE — ce préfixe WPX n'a jamais été contacté", 'clg2.c.comment': 'Commentaire', 'clg2.c.received_at': 'Reçu le', 'clg2.h.received_at': 'Reçu UTC', 'clg2.c.raw': 'Brut', 'clg2.newDxcc': 'NOUV DXCC', 'clg2.newBand': 'NOUV BANDE', 'clg2.newMode': 'NOUV MODE', 'clg2.newSlot': 'NOUV SLOT', 'clg2.newCall': 'CALL NEUF', 'clg2.wkdCall': 'DÉJÀ CTC', 'clg2.newCounty': 'NOUV CTY', 'clg2.newGridUnconf': 'GRID?', 'clg2.newGrid': 'NOUV GRID', 'clg2.c.grid': 'Grid', 'clg2.tipNewGrid': 'NOUVEAU GRID — ce carré n a jamais été contacté (grid entendu dans un CQ sur le lien UDP)', 'clg2.newPfx': "NOUVEAU PFX", 'clg2.newPota': 'NOUV POTA', 'clg2.tipNewDxcc': 'NOUVEAU DXCC : {country}', 'clg2.tipWorkedCall': 'Indicatif déjà contacté', 'clg2.tipNewBand': 'NOUVELLE BANDE pour cette entité', 'clg2.tipNewSlotBand': 'NOUVEAU SLOT (mode pas encore contacté sur cette bande)', 'clg2.tipNewMode': 'NOUVEAU MODE (ce mode jamais contacté sur cette entité)', 'clg2.tipNewSlot': 'NOUVEAU SLOT (cette bande+mode pas encore contactée)', 'clg2.tipNewCall': "CALL NEUF — cet indicatif n a jamais été contacté sur cette bande et ce mode (l entité, si)", 'clg2.tipPota': 'POTA — {name}', 'clg2.grpSpot': 'Spot', 'clg2.grpGeo': 'Géo', 'clg2.clearFiltersTitle': 'Effacer tous les filtres de colonne', 'clg2.clearFilters': 'Effacer les filtres', 'clg2.columns': 'Colonnes', 'clg2.pickerTitle': 'Colonnes du cluster', 'clg2.pickerDesc': 'Choisissez les colonnes à afficher dans le tableau du cluster.', 'clg2.allGroups': 'Tous les groupes :', 'clg2.all': 'tout', 'clg2.none': 'aucun', 'clg2.resetDefaults': 'Réinitialiser', 'clg2.done': 'Terminé', + 'clg2.c.time': 'Heure', 'clg2.c.call': 'Indicatif', 'clg2.c.status': 'Statut', 'clg2.c.pota': 'POTA', 'clg2.c.freq': 'Fréq', 'clg2.c.band': 'Bande', 'clg2.c.mode': 'Mode', 'clg2.c.pfx': 'Préf.', 'clg2.c.cqz': 'Zone CQ', 'clg2.h.cqz': 'CQZ', 'clg2.c.ituz': 'Zone ITU', 'clg2.h.ituz': 'ITU', 'clg2.c.distance_km': 'Distance (km)', 'clg2.h.distance_km': 'Dist km', 'clg2.c.sp_deg': 'Chemin court (°)', 'clg2.h.sp_deg': 'CC°', 'clg2.c.lp_deg': 'Chemin long (°)', 'clg2.h.lp_deg': 'CL°', 'clg2.c.country': 'Pays', 'clg2.c.continent': 'Continent', 'clg2.h.continent': 'Cont', 'clg2.c.spotter': 'Spotter', 'clg2.c.source': 'Source', 'clg2.c.locator': 'Locator du spotter', 'clg2.h.locator': 'Loc spotter', 'clg2.c.county': 'Comté US', 'clg2.tipNewCounty': 'NOUVEAU COMTÉ — jamais contacté', 'clg2.tipNewPfx': "NOUVEAU PRÉFIXE — ce préfixe WPX n'a jamais été contacté", 'clg2.c.comment': 'Commentaire', 'clg2.c.received_at': 'Reçu le', 'clg2.h.received_at': 'Reçu UTC', 'clg2.c.raw': 'Brut', 'clg2.newDxcc': 'NOUV DXCC', 'clg2.newBandMode': 'NOUV B+M', 'clg2.newBand': 'NOUV BANDE', 'clg2.newMode': 'NOUV MODE', 'clg2.newSlot': 'NOUV SLOT', 'clg2.newCall': 'CALL NEUF', 'clg2.wkdCall': 'DÉJÀ CTC', 'clg2.newCounty': 'NOUV CTY', 'clg2.newGridUnconf': 'GRID?', 'clg2.newGrid': 'NOUV GRID', 'clg2.c.grid': 'Grid', 'clg2.tipNewGrid': 'NOUVEAU GRID — ce carré n a jamais été contacté (grid entendu dans un CQ sur le lien UDP)', 'clg2.newPfx': "NOUVEAU PFX", 'clg2.newPota': 'NOUV POTA', 'clg2.tipNewDxcc': 'NOUVEAU DXCC : {country}', 'clg2.tipWorkedCall': 'Indicatif déjà contacté', 'clg2.tipNewBandMode': 'NOUVELLE BANDE ET NOUVEAU MODE pour cette entité — aucun des deux n’a été fait avec elle', 'clg2.tipNewBand': 'NOUVELLE BANDE pour cette entité', 'clg2.tipNewSlotBand': 'NOUVEAU SLOT (mode pas encore contacté sur cette bande)', 'clg2.tipNewMode': 'NOUVEAU MODE (ce mode jamais contacté sur cette entité)', 'clg2.tipNewSlot': 'NOUVEAU SLOT (cette bande+mode pas encore contactée)', 'clg2.tipNewCall': "CALL NEUF — cet indicatif n a jamais été contacté sur cette bande et ce mode (l entité, si)", 'clg2.tipPota': 'POTA — {name}', 'clg2.grpSpot': 'Spot', 'clg2.grpGeo': 'Géo', 'clg2.clearFiltersTitle': 'Effacer tous les filtres de colonne', 'clg2.clearFilters': 'Effacer les filtres', 'clg2.columns': 'Colonnes', 'clg2.pickerTitle': 'Colonnes du cluster', 'clg2.pickerDesc': 'Choisissez les colonnes à afficher dans le tableau du cluster.', 'clg2.allGroups': 'Tous les groupes :', 'clg2.all': 'tout', 'clg2.none': 'aucun', 'clg2.resetDefaults': 'Réinitialiser', 'clg2.done': 'Terminé', // Périphériques audio et manipulateur vocal (Préférences → Périphériques audio). 'aud.refreshDevices': 'Actualiser les périphériques', 'aud.fromRadio': 'Depuis la radio (entrée RX)', 'aud.toRadio': 'Vers la radio (sortie TX)', 'aud.recMic': "Micro d'enregistrement", 'aud.listening': 'Écoute (pré-écoute)', 'aud.phFromRadio': 'Sortie audio du poste → entrée carte son', 'aud.phToRadio': 'Sortie carte son → entrée micro/data du poste', 'aud.phRecMic': 'Votre microphone (enregistrer les messages vocaux)', 'aud.phListening': 'Haut-parleurs locaux pour la pré-écoute', diff --git a/frontend/src/version.ts b/frontend/src/version.ts index 75840f7..a2aa6fa 100644 --- a/frontend/src/version.ts +++ b/frontend/src/version.ts @@ -1,6 +1,6 @@ // Single source of truth for the app version shown in the UI (header + About). // Bump this on a release (the release script updates it alongside telemetry.go). -export const APP_VERSION = '0.26.2'; +export const APP_VERSION = '0.26.3'; // Author / credits, shown in Help -> About. export const APP_AUTHOR = 'F4BPO'; diff --git a/frontend/wailsjs/go/main/App.d.ts b/frontend/wailsjs/go/main/App.d.ts index 7c96f7e..44f00e7 100644 --- a/frontend/wailsjs/go/main/App.d.ts +++ b/frontend/wailsjs/go/main/App.d.ts @@ -89,6 +89,8 @@ export function AwardMissingQSOs(arg1:string):Promise>; export function AwardRefsForQSOs(arg1:Array):Promise>>; +export function AwardRefsNew(arg1:Array):Promise; + export function AwardsFolder():Promise; export function BackfillDistances():Promise; @@ -365,6 +367,8 @@ export function FlexTXOnBand(arg1:string):Promise; export function FlexTune(arg1:boolean):Promise; +export function FlexZoomForSpot(arg1:string,arg2:number):Promise; + export function GetACOMStatus():Promise; export function GetADIFMonitor():Promise; @@ -459,6 +463,8 @@ export function GetFlexBandPower():Promise>; export function GetFlexState():Promise; +export function GetFlexZoom():Promise; + export function GetFolderSync():Promise; export function GetFolderSyncStatus():Promise; @@ -539,6 +545,8 @@ export function GetSlotStats():Promise; export function GetSolarData():Promise; +export function GetSpotColors():Promise; + export function GetSpotTTLMinutes():Promise; export function GetStartupStatus():Promise; @@ -905,6 +913,8 @@ export function ResetDatabaseToDefault():Promise; export function ResetRotorPresets():Promise>; +export function ResetSpotColors():Promise; + export function RestartApp():Promise; export function RestartQSORecorder():Promise; @@ -967,6 +977,8 @@ export function SaveFlexBandAntennas(arg1:Record):Prom export function SaveFlexBandPower(arg1:Record):Promise; +export function SaveFlexZoom(arg1:main.FlexZoomSettings):Promise; + export function SaveFolderSync(arg1:main.FolderSyncConfig):Promise; export function SaveGridScopeSettings(arg1:main.GridScopeSettings):Promise; @@ -1003,6 +1015,8 @@ export function SaveRowColors(arg1:main.RowColorSettings):Promise; export function SaveSelfSpotSettings(arg1:main.SelfSpotSettings):Promise; +export function SaveSpotColors(arg1:main.SpotColors):Promise; + export function SaveStationDevices(arg1:Array):Promise; export function SaveStationSettings(arg1:main.StationSettings):Promise; diff --git a/frontend/wailsjs/go/main/App.js b/frontend/wailsjs/go/main/App.js index 563bf09..448b3ef 100644 --- a/frontend/wailsjs/go/main/App.js +++ b/frontend/wailsjs/go/main/App.js @@ -118,6 +118,10 @@ export function AwardRefsForQSOs(arg1) { return window['go']['main']['App']['AwardRefsForQSOs'](arg1); } +export function AwardRefsNew(arg1) { + return window['go']['main']['App']['AwardRefsNew'](arg1); +} + export function AwardsFolder() { return window['go']['main']['App']['AwardsFolder'](); } @@ -670,6 +674,10 @@ export function FlexTune(arg1) { return window['go']['main']['App']['FlexTune'](arg1); } +export function FlexZoomForSpot(arg1, arg2) { + return window['go']['main']['App']['FlexZoomForSpot'](arg1, arg2); +} + export function GetACOMStatus() { return window['go']['main']['App']['GetACOMStatus'](); } @@ -858,6 +866,10 @@ export function GetFlexState() { return window['go']['main']['App']['GetFlexState'](); } +export function GetFlexZoom() { + return window['go']['main']['App']['GetFlexZoom'](); +} + export function GetFolderSync() { return window['go']['main']['App']['GetFolderSync'](); } @@ -1018,6 +1030,10 @@ export function GetSolarData() { return window['go']['main']['App']['GetSolarData'](); } +export function GetSpotColors() { + return window['go']['main']['App']['GetSpotColors'](); +} + export function GetSpotTTLMinutes() { return window['go']['main']['App']['GetSpotTTLMinutes'](); } @@ -1750,6 +1766,10 @@ export function ResetRotorPresets() { return window['go']['main']['App']['ResetRotorPresets'](); } +export function ResetSpotColors() { + return window['go']['main']['App']['ResetSpotColors'](); +} + export function RestartApp() { return window['go']['main']['App']['RestartApp'](); } @@ -1874,6 +1894,10 @@ export function SaveFlexBandPower(arg1) { return window['go']['main']['App']['SaveFlexBandPower'](arg1); } +export function SaveFlexZoom(arg1) { + return window['go']['main']['App']['SaveFlexZoom'](arg1); +} + export function SaveFolderSync(arg1) { return window['go']['main']['App']['SaveFolderSync'](arg1); } @@ -1946,6 +1970,10 @@ export function SaveSelfSpotSettings(arg1) { return window['go']['main']['App']['SaveSelfSpotSettings'](arg1); } +export function SaveSpotColors(arg1) { + return window['go']['main']['App']['SaveSpotColors'](arg1); +} + export function SaveStationDevices(arg1) { return window['go']['main']['App']['SaveStationDevices'](arg1); } diff --git a/frontend/wailsjs/go/models.ts b/frontend/wailsjs/go/models.ts index c601f51..02aaa26 100644 --- a/frontend/wailsjs/go/models.ts +++ b/frontend/wailsjs/go/models.ts @@ -1873,6 +1873,20 @@ export namespace main { this.can_update = source["can_update"]; } } + export class AwardRefNewResult { + new: Record; + pending: boolean; + + static createFrom(source: any = {}) { + return new AwardRefNewResult(source); + } + + constructor(source: any = {}) { + if ('string' === typeof source) source = JSON.parse(source); + this.new = source["new"]; + this.pending = source["pending"]; + } + } export class AwardStatRow { label: string; cells: number[]; @@ -2501,6 +2515,26 @@ export namespace main { this.body = source["body"]; } } + export class FlexZoomSettings { + enabled: boolean; + cw_khz: number; + ssb_khz: number; + digi_khz: number; + centre: boolean; + + static createFrom(source: any = {}) { + return new FlexZoomSettings(source); + } + + constructor(source: any = {}) { + if ('string' === typeof source) source = JSON.parse(source); + this.enabled = source["enabled"]; + this.cw_khz = source["cw_khz"]; + this.ssb_khz = source["ssb_khz"]; + this.digi_khz = source["digi_khz"]; + this.centre = source["centre"]; + } + } export class FolderSyncConfig { enabled: boolean; folder: string; @@ -3408,6 +3442,52 @@ export namespace main { this.minutes = source["minutes"]; } } + export class SpotColor { + text: string; + bg?: string; + + static createFrom(source: any = {}) { + return new SpotColor(source); + } + + constructor(source: any = {}) { + if ('string' === typeof source) source = JSON.parse(source); + this.text = source["text"]; + this.bg = source["bg"]; + } + } + export class SpotColors { + enabled: boolean; + colors: Record; + + static createFrom(source: any = {}) { + return new SpotColors(source); + } + + constructor(source: any = {}) { + if ('string' === typeof source) source = JSON.parse(source); + this.enabled = source["enabled"]; + this.colors = this.convertValues(source["colors"], SpotColor, true); + } + + convertValues(a: any, classs: any, asMap: boolean = false): any { + if (!a) { + return a; + } + if (a.slice && a.map) { + return (a as any[]).map(elem => this.convertValues(elem, classs)); + } else if ("object" === typeof a) { + if (asMap) { + for (const key of Object.keys(a)) { + a[key] = new classs(a[key]); + } + return a; + } + return new classs(a); + } + return a; + } + } export class SpotQuery { call: string; band: string; @@ -5016,6 +5096,10 @@ export namespace qso { continents: number; first_qso: string; last_qso: string; + last_new_dxcc: string; + last_new_dxcc_num: number; + last_new_dxcc_call: string; + last_new_dxcc_date: string; confirmed_lotw: number; confirmed_eqsl: number; confirmed_qsl: number; @@ -5066,6 +5150,10 @@ export namespace qso { this.continents = source["continents"]; this.first_qso = source["first_qso"]; this.last_qso = source["last_qso"]; + this.last_new_dxcc = source["last_new_dxcc"]; + this.last_new_dxcc_num = source["last_new_dxcc_num"]; + this.last_new_dxcc_call = source["last_new_dxcc_call"]; + this.last_new_dxcc_date = source["last_new_dxcc_date"]; this.confirmed_lotw = source["confirmed_lotw"]; this.confirmed_eqsl = source["confirmed_eqsl"]; this.confirmed_qsl = source["confirmed_qsl"]; diff --git a/internal/cat/cat.go b/internal/cat/cat.go index 64c7e54..b1de1bc 100644 --- a/internal/cat/cat.go +++ b/internal/cat/cat.go @@ -290,12 +290,20 @@ func (m *Manager) SetSplit(on bool, txHz int64) error { // the backend picks a default when it's empty. (Status-based colouring can be // driven later by setting Color per spot.) type SpotInfo struct { - FreqHz int64 - Callsign string - Mode string - Color string - Comment string - LifetimeSec int // panadapter display seconds before auto-removal (0 = backend default) + FreqHz int64 + Callsign string + Mode string + // Color is the TEXT colour of the callsign on the panadapter, BackgroundColor + // the plate behind it. Both are #AARRGGBB — the alpha channel first, which is + // SmartSDR's order and not the web's. + // + // Two colours rather than one because that is what makes a spot readable at a + // glance on a busy waterfall: the fill carries the status and the text stays + // legible against it. An empty background leaves the radio's own default. + Color string + BackgroundColor string + Comment string + LifetimeSec int // panadapter display seconds before auto-removal (0 = backend default) } // Spotter is an OPTIONAL backend capability: show cluster spots on the radio @@ -475,7 +483,10 @@ type FlexController interface { SetRXAntenna(string) error SetTXAntenna(string) error SetActiveSlice(int) error // focus slice idx so commands target it - SetTXSlice(int) error // make slice idx the transmitter (tx=1) + // ZoomPan sets the visible width (MHz) of the active slice's panadapter and + // keeps freqMHz inside it, re-centring when it must. See Flex.ZoomPan. + ZoomPan(bandwidthMHz, freqMHz float64, centre bool) error + SetTXSlice(int) error // make slice idx the transmitter (tx=1) SetSplit(bool) error SetNB(bool) error SetNBLevel(int) error diff --git a/internal/cat/flex.go b/internal/cat/flex.go index a07188c..e2d5f6b 100644 --- a/internal/cat/flex.go +++ b/internal/cat/flex.go @@ -66,18 +66,36 @@ type Flex struct { pendingSplit map[int]bool // seq → awaiting the new TX slice's index (split create) spotCall map[int]string // spot index → callsign (to fill the call on a panadapter click) spotMode map[int]string // spot index → ADIF mode, so a click can also set the slice mode (SmartSDR tunes the spot's freq but not its mode) - spotByCall map[string]int // callsign → live spot index, so re-spotting a call replaces its old spot (WSJT decodes re-fire every cycle) - sentCmds map[int]string // seq → command text, so an R error names the command + spotFreq map[int]int64 // spot index → Hz, so a click can report where it was (the trigger message carries only the index) + pendingSpotFreq map[int]int64 // seq → Hz, paired with pendingSpot + // panWindow is what each panadapter is currently showing, from its own status + // (centre and width, both MHz). Tracked because a zoom that only changes the + // WIDTH keeps the old centre, and the frequency the operator just clicked can + // end up outside the new window — see ZoomPan. + panWindow map[string]panView + + spotByCall map[string]int // callsign → live spot index, so re-spotting a call replaces its old spot (WSJT decodes re-fire every cycle) + sentCmds map[int]string // seq → command text, so an R error names the command // OnSpotClick is called (off the reader goroutine's hot path) when the user - // clicks one of our spots on the panadapter, with the spot's callsign and - // frequency. The host wires this to fill the entry form. Set before Connect. - OnSpotClick func(callsign string, freqHz int64) + // clicks one of our spots on the panadapter, with the spot's callsign, its + // frequency and the mode it was spotted in — everything the host knows about + // the spot, since the radio's own notification carries only an index. The host + // wires this to fill the entry form and to size the panadapter. Set before Connect. + OnSpotClick func(callsign string, freqHz int64, mode string) } +// panView is one panadapter's visible window, in MHz. +type panView struct{ centre, width float64 } + type flexSlice struct { freqHz int64 mode string // raw Flex mode (USB/LSB/CW/DIGU/…) + // pan is the panadapter this slice is displayed on ("0x40000000"), taken + // from the slice status. Kept PER SLICE rather than as one radio-wide id: + // with two slices on two bands there are two panadapters, and zooming the + // wrong one moves a display the operator is not looking at. + pan string active bool tx bool inUse bool @@ -187,7 +205,7 @@ func NewFlex(host string, port int, spotsEnabled bool) *Flex { return &Flex{ host: strings.TrimSpace(host), port: port, slices: map[int]*flexSlice{}, spotsEnabled: spotsEnabled, - spotIdx: map[int]bool{}, pendingSpot: map[int]string{}, pendingSpotMode: map[int]string{}, spotCall: map[int]string{}, spotMode: map[int]string{}, spotByCall: map[string]int{}, pendingSplit: map[int]bool{}, + spotIdx: map[int]bool{}, pendingSpot: map[int]string{}, pendingSpotMode: map[int]string{}, spotCall: map[int]string{}, spotMode: map[int]string{}, spotFreq: map[int]int64{}, pendingSpotFreq: map[int]int64{}, panWindow: map[string]panView{}, spotByCall: map[string]int{}, pendingSplit: map[int]bool{}, meterMeta: map[int]meterInfo{}, meterVal: map[int]float64{}, meterSub: map[int]bool{}, sentCmds: map[int]string{}, txSetAt: map[string]time.Time{}, pinnedSlice: -1, @@ -248,6 +266,7 @@ func (f *Flex) Connect() error { f.send("sub cwx all") // CWX: the LIVE CW speed/pitch/break-in (transmit holds only a static default) f.send("sub profile all") // mic/global/tx profiles (for the mic-profile dropdown) f.send("profile mic info") // request the current mic profile list + selection + f.send("sub pan all") // panadapter centre/bandwidth, so a zoom knows where the display already is f.send("sub client all") // learn the GUI client (SmartSDR) so we can bind to it (below) f.startMeters(conn) // open the UDP VITA-49 stream for live meters if f.spotsEnabled { @@ -341,11 +360,12 @@ func (f *Flex) reader(conn net.Conn) { f.mu.Lock() call := f.spotCall[idx] mode := f.spotMode[idx] + hz := f.spotFreq[idx] handler := f.OnSpotClick f.mu.Unlock() if call != "" && handler != nil { debugLog.Printf("Flex: spot %d triggered → %s (mode %s)", idx, call, mode) - go handler(call, 0) + go handler(call, hz, mode) // SmartSDR tunes the spot's frequency on click but does NOT apply // its mode=, so set the slice mode ourselves from what we spotted. if mode != "" { @@ -388,14 +408,17 @@ func (f *Flex) reader(conn net.Conn) { f.mu.Lock() call, pending := f.pendingSpot[seq] spotMode := f.pendingSpotMode[seq] + spotFreq := f.pendingSpotFreq[seq] if pending { delete(f.pendingSpot, seq) delete(f.pendingSpotMode, seq) + delete(f.pendingSpotFreq, seq) } if pending && ok && len(parts) >= 3 { if idx, e := strconv.Atoi(strings.TrimSpace(parts[2])); e == nil { f.spotCall[idx] = call f.spotMode[idx] = spotMode + f.spotFreq[idx] = spotFreq f.spotIdx[idx] = true f.spotByCall[strings.ToUpper(call)] = idx } @@ -692,6 +715,32 @@ func (f *Flex) handleStatus(payload string) { } f.mu.Unlock() } + // Panadapter — "display pan 0x40000000 center=14.075 bandwidth=0.2 …". + // Only the window matters here; everything else about the display is + // SmartSDR's business. + if len(fields) >= 3 && fields[0] == "display" && fields[1] == "pan" { + id := fields[2] + f.mu.Lock() + w := f.panWindow[id] + for _, kv := range fields[3:] { + key, val, ok := splitKV(kv) + if !ok { + continue + } + switch key { + case "center": + if v, err := strconv.ParseFloat(val, 64); err == nil && v > 0 { + w.centre = v + } + case "bandwidth": + if v, err := strconv.ParseFloat(val, 64); err == nil && v > 0 { + w.width = v + } + } + } + f.panWindow[id] = w + f.mu.Unlock() + } // Meter definitions — "meter .src=… .nam=… .unit=… …". // The unit scales the UDP values, the name labels them; subscribe to each // new id so the radio streams it. @@ -813,6 +862,7 @@ func (f *Flex) handleStatus(payload string) { delete(f.spotIdx, idx) delete(f.spotCall, idx) delete(f.spotMode, idx) + delete(f.spotFreq, idx) } else { f.spotIdx[idx] = true } @@ -847,6 +897,8 @@ func (f *Flex) handleStatus(payload string) { } case "mode": s.mode = val + case "pan": + s.pan = val case "active": s.active = val == "1" case "tx": @@ -1241,6 +1293,74 @@ func (f *Flex) SetMode(mode string) error { return nil } +// ZoomPan sets the visible width of the ACTIVE slice's panadapter, and puts the +// frequency the operator clicked inside it. +// +// bandwidthMHz is the whole visible span, which is how SmartSDR expresses it — +// not a zoom factor. +// +// Re-centring is the subtle part. SmartSDR keeps the panadapter's CENTRE when +// only the width changes, so narrowing from 200 kHz to 25 for a CW spot — or +// jumping to a spot clicked in the band map — regularly left the very signal the +// operator asked for outside the new window: the radio had tuned to it, but the +// display was showing somewhere else. So the centre moves when it must: +// +// centre == true always re-centre (the operator asked for it) +// centre == false re-centre ONLY when freqMHz would fall outside the new +// window, leaving a settled display alone the rest of the time +// +// The test uses 40% of the width either side rather than the full half: a spot +// pinned to the last pixel of the panadapter is visible in the arithmetic and +// useless in practice. +// +// A no-op when the slice reports no panadapter, which is the case on a slice +// that exists but is not displayed. Silent, because that is not a fault. +// needRecentre decides whether the panadapter has to move for freqMHz to be +// comfortably visible in a window of bandwidthMHz. forced short-circuits it. +// +// An unknown current centre (no pan status seen yet) counts as "would fall +// outside": the display is more likely wrong than right, and re-centring on the +// spot the operator just clicked is never the surprising answer. +func needRecentre(cur panView, freqMHz, bandwidthMHz float64, forced bool) bool { + if freqMHz <= 0 { + return false // nothing to centre on + } + if forced { + return true + } + return cur.centre <= 0 || math.Abs(freqMHz-cur.centre) > bandwidthMHz*0.4 +} + +func (f *Flex) ZoomPan(bandwidthMHz, freqMHz float64, centre bool) error { + f.mu.Lock() + pan := "" + // The operator's slice, by the same rule as everything else — see + // mainSliceLocked. Zooming any other panadapter would move a display the + // operator is not looking at. + if _, sl := f.mainSliceLocked(); sl != nil { + pan = sl.pan + } + cur := f.panWindow[pan] + connected := f.conn != nil && f.gotHandle + f.mu.Unlock() + if !connected { + return fmt.Errorf("flex: not connected") + } + if pan == "" || bandwidthMHz <= 0 { + return nil + } + recentre := needRecentre(cur, freqMHz, bandwidthMHz, centre) + // Centre first, then width: SmartSDR clamps a window that would run past the + // end of the spectrum, and moving to the right place before widening leaves + // nothing to clamp. + if recentre { + f.send(fmt.Sprintf("display pan s %s center=%.6f", pan, freqMHz)) + } + f.send(fmt.Sprintf("display pan s %s bandwidth=%.6f", pan, bandwidthMHz)) + debugLog.Printf("Flex: zoom pan %s → %.4f MHz (centre=%v on %.6f, was %.6f)", pan, bandwidthMHz, recentre, freqMHz, cur.centre) + return nil +} + // SendSpot renders a cluster spot on the panadapter via "spot add". Spots carry // a lifetime so the radio expires them on its own (the API has no "spot clear"). // Per the SmartSDR API, spaces inside a field value are encoded as 0x7F. @@ -1276,6 +1396,7 @@ func (f *Flex) SendSpot(s SpotInfo) error { delete(f.spotByCall, upperCall) delete(f.spotCall, old) delete(f.spotMode, old) + delete(f.spotFreq, old) delete(f.spotIdx, old) } f.mu.Unlock() @@ -1291,6 +1412,12 @@ func (f *Flex) SendSpot(s SpotInfo) error { if m := flexEncode(adifModeToFlex(s.Mode, s.FreqHz)); m != "" { cmd += " mode=" + m } + // background_color is optional in the API and empty means "the radio's own". + // Sent only when set, so a spot with no configured background does not blank + // the default to nothing. + if bg := flexEncode(s.BackgroundColor); bg != "" { + cmd += " background_color=" + bg + } if c := flexEncode(s.Comment); c != "" { cmd += " comment=" + c } @@ -1302,6 +1429,7 @@ func (f *Flex) SendSpot(s SpotInfo) error { f.mu.Lock() f.pendingSpot[seq] = s.Callsign f.pendingSpotMode[seq] = s.Mode + f.pendingSpotFreq[seq] = s.FreqHz f.mu.Unlock() } return nil @@ -1335,6 +1463,7 @@ func (f *Flex) ClearSpots() error { f.spotIdx = map[int]bool{} f.spotCall = map[int]string{} f.spotMode = map[int]string{} + f.spotFreq = map[int]int64{} f.spotByCall = map[string]int{} connected := f.conn != nil f.mu.Unlock() diff --git a/internal/cat/flex_test.go b/internal/cat/flex_test.go new file mode 100644 index 0000000..93a393a --- /dev/null +++ b/internal/cat/flex_test.go @@ -0,0 +1,34 @@ +package cat + +import "testing" + +func TestNeedRecentre(t *testing.T) { + pan := panView{centre: 14.100, width: 0.200} + // A spot the display is already showing comfortably: leave the window alone, + // which is the whole point of the option being off. + if needRecentre(pan, 14.110, 0.200, false) { + t.Fatal("moved a display that was already on the spot") + } + // Narrowing for a CW spot 40 kHz away: 25 kHz around the old centre would not + // reach it, so the centre must follow. + if !needRecentre(pan, 14.060, 0.025, false) { + t.Fatal("spot would have been left outside the new window") + } + // Near the very edge of the new window — visible in the arithmetic, useless + // in practice. + if !needRecentre(pan, 14.199, 0.200, false) { + t.Fatal("spot pinned to the edge counts as outside") + } + // The operator asked for it. + if !needRecentre(pan, 14.110, 0.200, true) { + t.Fatal("forced centring ignored") + } + // No pan status yet: assume the display is elsewhere. + if !needRecentre(panView{}, 14.110, 0.200, false) { + t.Fatal("unknown centre must re-centre") + } + // Nothing to centre on. + if needRecentre(pan, 0, 0.200, true) { + t.Fatal("centred on nothing") + } +} diff --git a/internal/qso/lastnewdxcc_test.go b/internal/qso/lastnewdxcc_test.go new file mode 100644 index 0000000..f97040d --- /dev/null +++ b/internal/qso/lastnewdxcc_test.go @@ -0,0 +1,54 @@ +package qso + +import ( + "testing" + "time" +) + +// "When did I last add an entity" is judged against the whole log. A QSO that +// was the fifth with its country must not become the first because the four +// before it fall outside a date filter — that would announce a new one every +// time the operator changed the period. +func TestLastNewDXCCIgnoresThePeriodFilter(t *testing.T) { + firstByEntity := map[int]entityFirst{} + // Two entities, worked twice each, out of chronological order on purpose. + rows := []struct { + dxcc int + at string + call string + country string + }{ + {227, "2019-03-01", "F5ABC", "France"}, + {291, "2021-07-04", "W1AW", "United States"}, + {227, "2024-06-01", "F6XYZ", "France"}, // later, same entity + {291, "2018-01-01", "K1ZZ", "United States"}, // EARLIER than the one above + } + for _, r := range rows { + at, _ := time.Parse("2006-01-02", r.at) + if cur, seen := firstByEntity[r.dxcc]; !seen || at.Before(cur.at) { + firstByEntity[r.dxcc] = entityFirst{at: at, call: r.call, country: r.country} + } + } + if got := firstByEntity[291].call; got != "K1ZZ" { + t.Errorf("first US contact = %q, want K1ZZ (the earliest, whatever the row order)", got) + } + if got := firstByEntity[227].call; got != "F5ABC" { + t.Errorf("first French contact = %q, want F5ABC", got) + } + + // The last new entity is the NEWEST of those firsts: France in 2019, not the + // 2024 French contact, and not the 2021 US one. + var s Stats + for num, f := range firstByEntity { + if f.at.After(parseTimeLoose(s.LastNewDXCCDate)) { + s.LastNewDXCC, s.LastNewDXCCNum, s.LastNewDXCCCall = f.country, num, f.call + s.LastNewDXCCDate = f.at.Format(time.RFC3339) + } + } + if s.LastNewDXCC != "France" || s.LastNewDXCCNum != 227 || s.LastNewDXCCCall != "F5ABC" { + t.Errorf("last new entity = %q/%d/%q, want France/227/F5ABC", s.LastNewDXCC, s.LastNewDXCCNum, s.LastNewDXCCCall) + } + if s.LastNewDXCCDate[:10] != "2019-03-01" { + t.Errorf("date = %q, want 2019-03-01", s.LastNewDXCCDate) + } +} diff --git a/internal/qso/stats.go b/internal/qso/stats.go index 2269cec..072a427 100644 --- a/internal/qso/stats.go +++ b/internal/qso/stats.go @@ -137,6 +137,13 @@ const gapThreshold = 30 * time.Minute const rateMaxHours = 7 * 24 // Stats is the whole dashboard payload. +// entityFirst is the first contact ever made with one DXCC entity. +type entityFirst struct { + at time.Time + call string + country string +} + type Stats struct { // Headline figures. Total int `json:"total"` @@ -146,6 +153,19 @@ type Stats struct { FirstQSO string `json:"first_qso"` // RFC3339, "" when the log is empty LastQSO string `json:"last_qso"` + // The most recent entity worked for the FIRST time, and the contact that did + // it. "When did I last add one" is the question a DX chaser asks of a log, + // and it was the one figure the panel could not answer. + // + // Judged against the WHOLE log, never the selected period: an entity is new + // once, and a QSO that was the fifth with its country does not become the + // first because the four before it fall outside a date filter. Only the + // period filter decides whether that contact is SHOWN. + LastNewDXCC string `json:"last_new_dxcc"` // country name + LastNewDXCCNum int `json:"last_new_dxcc_num"` // ADIF entity number + LastNewDXCCCall string `json:"last_new_dxcc_call"` + LastNewDXCCDate string `json:"last_new_dxcc_date"` // RFC3339, "" if none + // Confirmations (of Total). ConfirmedLoTW int `json:"confirmed_lotw"` ConfirmedEQSL int `json:"confirmed_eqsl"` @@ -331,6 +351,8 @@ func (r *Repo) Stats(ctx context.Context, from, to time.Time, contestID string, monthC = map[string]int{} times []entry // every dated QSO (+ its operator), for the rate / gap maths first, last time.Time + // The earliest contact with each entity, for "last new DXCC". + firstByEntity = map[int]entityFirst{} ) for rows.Next() { @@ -346,6 +368,22 @@ func (r *Repo) Stats(ctx context.Context, from, to time.Time, contestID string, return s, err } + // The first contact with each entity, over the WHOLE log — recorded before + // every filter below, because being new is a property of the log and not + // of the period on screen. + if dxcc.Valid && dxcc.Int64 > 0 { + if t := parseTimeLoose(dateStr.String).UTC(); !t.IsZero() { + n := int(dxcc.Int64) + if cur, seen := firstByEntity[n]; !seen || t.Before(cur.at) { + firstByEntity[n] = entityFirst{ + at: t, + call: strings.ToUpper(strings.TrimSpace(call.String)), + country: strings.TrimSpace(country.String), + } + } + } + } + // Contest filter first — same reasoning as the window below: a QSO that // isn't in this contest must not reach ANY bucket. if contestID != "" && strings.ToUpper(strings.TrimSpace(contestID2.String)) != contestID { @@ -459,6 +497,16 @@ func (r *Repo) Stats(ctx context.Context, from, to time.Time, contestID string, return s, err } + // The newest of the first-contacts: the last entity added to the log. + for num, f := range firstByEntity { + if f.at.After(parseTimeLoose(s.LastNewDXCCDate)) { + s.LastNewDXCC = f.country + s.LastNewDXCCNum = num + s.LastNewDXCCCall = f.call + s.LastNewDXCCDate = f.at.Format(time.RFC3339) + } + } + s.UniqueCalls = len(calls) s.Entities = len(entities) s.Continents = len(contC) diff --git a/internal/ultrabeam/transport_test.go b/internal/ultrabeam/transport_test.go new file mode 100644 index 0000000..43ca4d3 --- /dev/null +++ b/internal/ultrabeam/transport_test.go @@ -0,0 +1,57 @@ +package ultrabeam + +import ( + "errors" + "io" + "net" + "testing" + "time" +) + +// The two transports report a slow reply differently, and neither means the +// link is gone: a remote TCP hop and a controller busy moving its motors both +// look like silence. Getting this wrong tears the connection down on every poll. +func TestTransientRead(t *testing.T) { + if !transientRead(timeoutErr{}) { + t.Errorf("a TCP read timeout must be transient") + } + // A serial port that stays silent returns (0, nil) forever; bufio gives up + // after a hundred empty reads with ErrNoProgress. + if !transientRead(io.ErrNoProgress) { + t.Errorf("a silent serial port must be transient") + } + if transientRead(io.EOF) { + t.Errorf("EOF is the link closing, not a slow reply") + } + if transientRead(errors.New("access denied")) { + t.Errorf("an open failure is not a slow reply") + } +} + +// open must refuse a configuration it cannot honour rather than dial nothing. +func TestOpenRejectsEmptyConfig(t *testing.T) { + if _, err := New(Transport{Mode: "serial"}).open(); err == nil { + t.Errorf("serial with no COM port must fail") + } + if _, err := New(Transport{Mode: "tcp"}).open(); err == nil { + t.Errorf("tcp with no host must fail") + } +} + +// A missing baud is the controller's default, not zero — serial.Open would +// reject 0 and the operator would see "invalid speed" for a field they never +// knew existed. +func TestDefaultBaud(t *testing.T) { + if got := New(Transport{Mode: "serial", COM: "COM3"}).tr.Baud; got != 9600 { + t.Errorf("default baud = %d, want 9600", got) + } +} + +type timeoutErr struct{} + +func (timeoutErr) Error() string { return "i/o timeout" } +func (timeoutErr) Timeout() bool { return true } +func (timeoutErr) Temporary() bool { return true } + +var _ net.Error = timeoutErr{} +var _ = time.Second diff --git a/internal/ultrabeam/ultrabeam.go b/internal/ultrabeam/ultrabeam.go index 945239a..a258bdd 100644 --- a/internal/ultrabeam/ultrabeam.go +++ b/internal/ultrabeam/ultrabeam.go @@ -1,19 +1,39 @@ -// Package ultrabeam drives an Ultrabeam remote-controlled antenna over TCP -// (typically via an RS232↔Ethernet adapter). The wire protocol (STX/ETX -// framing, DLE escaping, XOR checksum) and command codes are the manufacturer's. +// Package ultrabeam drives an Ultrabeam remote-controlled antenna over SERIAL +// or TCP. The wire protocol (STX/ETX framing, DLE escaping, XOR checksum) and +// command codes are the manufacturer's, and identical on both: the Ethernet +// route is an RS232↔Ethernet adapter passing the same bytes. +// +// Serial came second, which is the wrong way round for most stations: the +// controller has an RS232 port and the PC is usually right next to it, so a +// plain FTDI cable does the job and the adapter is only needed to put the +// antenna at the other end of a link. package ultrabeam import ( "bufio" "errors" "fmt" + "io" "log" "net" "runtime" "sync" "time" + + "go.bug.st/serial" ) +// Transport says how to reach the controller. Mirrors internal/steppir, which +// has had both routes from the start — one shape for the two antennas rather +// than two shapes to remember. +type Transport struct { + Mode string // "tcp" | "serial" + Host string // tcp + Port int // tcp + COM string // serial device (COM3, /dev/ttyUSB0) + Baud int // serial baud +} + // Connection tuning. Remote operation (the antenna controller reached over the // internet, not the LAN) sees real latency and jitter, so the read timeout is // generous and a few transient timeouts are tolerated before the link is torn @@ -64,9 +84,8 @@ const ( ) type Client struct { - host string - port int - conn net.Conn + tr Transport + conn io.ReadWriteCloser connMu sync.Mutex reader *bufio.Reader lastStatus *Status @@ -129,15 +148,75 @@ type Status struct { Connected bool `json:"connected"` } -func New(host string, port int) *Client { +func New(tr Transport) *Client { + if tr.Baud <= 0 { + tr.Baud = 9600 + } return &Client{ - host: host, - port: port, + tr: tr, stopChan: make(chan struct{}), seqNum: 0, } } +// open dials the transport. Callers hold connMu. +func (c *Client) open() (io.ReadWriteCloser, error) { + if c.tr.Mode == "serial" { + if c.tr.COM == "" { + return nil, fmt.Errorf("ultrabeam: no serial port configured") + } + p, err := serial.Open(c.tr.COM, &serial.Mode{BaudRate: c.tr.Baud}) + if err != nil { + return nil, err + } + // A finite read timeout so a silent controller cannot wedge the poll + // loop. Replaced per exchange by setReadTimeout below. + _ = p.SetReadTimeout(ubReadTimeout) + return p, nil + } + if c.tr.Host == "" { + return nil, fmt.Errorf("ultrabeam: no host configured") + } + dialer := net.Dialer{Timeout: 5 * time.Second, KeepAlive: ubKeepAlive} + return dialer.Dial("tcp", net.JoinHostPort(c.tr.Host, fmt.Sprintf("%d", c.tr.Port))) +} + +// target names what the client is talking to, for the log. +func (c *Client) target() string { + if c.tr.Mode == "serial" { + return fmt.Sprintf("%s @ %d baud", c.tr.COM, c.tr.Baud) + } + return fmt.Sprintf("%s:%d", c.tr.Host, c.tr.Port) +} + +// setReadTimeout bounds the next read, whichever transport is open. +// +// TCP takes a deadline (an instant) and serial a timeout (a duration) — the two +// libraries disagree, and the caller should not have to care. +func (c *Client) setReadTimeout(d time.Duration) { + switch t := c.conn.(type) { + case net.Conn: + _ = t.SetReadDeadline(time.Now().Add(d)) + case serial.Port: + _ = t.SetReadTimeout(d) + } +} + +// transientRead reports a read that timed out rather than failed. +// +// The two transports say it differently. TCP returns a net.Error with +// Timeout(); a serial port that stays silent returns (0, nil) on every read, +// which bufio turns into io.ErrNoProgress after a hundred empty attempts. +// Neither means the link is gone — over a remote link, or with a controller +// busy moving its motors, a slow reply is ordinary. +func transientRead(err error) bool { + var ne net.Error + if errors.As(err, &ne) && ne.Timeout() { + return true + } + return errors.Is(err, io.ErrNoProgress) +} + func (c *Client) Start() error { c.running = true go c.pollLoop() @@ -174,9 +253,8 @@ func (c *Client) pollLoop() { // Try to connect if not connected c.connMu.Lock() if c.conn == nil { - log.Printf("Ultrabeam: Not connected, attempting connection...") - dialer := net.Dialer{Timeout: 5 * time.Second, KeepAlive: ubKeepAlive} - conn, err := dialer.Dial("tcp", net.JoinHostPort(c.host, fmt.Sprintf("%d", c.port))) + log.Printf("Ultrabeam: Not connected, attempting connection to %s...", c.target()) + conn, err := c.open() if err != nil { log.Printf("Ultrabeam: Connection failed: %v", err) c.connMu.Unlock() @@ -190,7 +268,7 @@ func (c *Client) pollLoop() { c.conn = conn c.reader = bufio.NewReader(c.conn) pollFails = 0 - log.Printf("Ultrabeam: Connected to %s:%d", c.host, c.port) + log.Printf("Ultrabeam: Connected to %s", c.target()) } c.connMu.Unlock() @@ -200,8 +278,7 @@ func (c *Client) pollLoop() { // A single slow/lost reply over a remote link is normal — keep // the connection (and the last status) for a few tries before // tearing it down, so we don't churn reconnect/disconnect. - var ne net.Error - transient := errors.As(err, &ne) && ne.Timeout() + transient := transientRead(err) pollFails++ if transient && pollFails < ubMaxPollTimeout { log.Printf("Ultrabeam: status timeout (%d/%d), keeping link: %v", pollFails, ubMaxPollTimeout, err) @@ -430,7 +507,7 @@ func (c *Client) sendCommand(cmd byte, data []byte) ([]byte, error) { } // Read the reply with a timeout generous enough for a remote link. - c.conn.SetReadDeadline(time.Now().Add(ubReadTimeout)) + c.setReadTimeout(ubReadTimeout) buffer, err := c.readPacket() if err != nil { return nil, err @@ -467,7 +544,8 @@ func (c *Client) sendCommand(cmd byte, data []byte) ([]byte, error) { // behind by a command that timed out. A short read deadline lets it consume what // is there and stop quickly when the stream is clean. Caller holds connMu. func (c *Client) drainStale() { - c.conn.SetReadDeadline(time.Now().Add(5 * time.Millisecond)) + c.setReadTimeout(5 * time.Millisecond) + defer c.setReadTimeout(ubReadTimeout) // leave the link on its normal budget buf := make([]byte, 256) for { n, err := c.reader.Read(buf) diff --git a/spotcolors.go b/spotcolors.go new file mode 100644 index 0000000..9f4027e --- /dev/null +++ b/spotcolors.go @@ -0,0 +1,225 @@ +package main + +// Panadapter spot colours, per status. +// +// A FlexRadio draws every OpsLog spot in one colour today, which throws away the +// only thing worth knowing at a glance on a waterfall: whether the station is +// worth stopping for. The radio's own API has always taken a text colour AND a +// background colour per spot — see internal/cat/flex.go — so the information can +// be carried without a single extra pixel of screen. +// +// The statuses are the ones the cluster already computes (see spotEntityStatus), +// plus the three orthogonal markers an operator chases separately. + +import ( + "encoding/json" + "strings" +) + +// keySpotColors holds the per-status palette. +const keySpotColors = "flex.spot_colors" + +// SpotColor is one status's pair. Both are #AARRGGBB — alpha FIRST, which is +// SmartSDR's order, not the web's. An empty background leaves the radio's own. +type SpotColor struct { + Text string `json:"text"` + Bg string `json:"bg,omitempty"` +} + +// SpotColors is the whole palette, keyed by the status names the cluster uses. +// +// Stored as a map rather than a struct with nine fields so a status added later +// (a new award marker, say) needs no migration: an unknown key is ignored and a +// missing one falls back to the default below. +type SpotColors struct { + // Enabled off sends no colour at all, which is the behaviour before this + // existed: every spot in the radio's default orange. Kept as a real switch so + // turning it off is a genuine revert rather than "some other palette". + Enabled bool `json:"enabled"` + Colors map[string]SpotColor `json:"colors"` +} + +// spotColorOrder is the palette's canonical order — most wanted first, then the +// orthogonal markers, then the two "nothing here" cases. The settings panel +// renders it in this order, and it is the order the resolver tries. +var spotColorOrder = []string{ + "new", "new-band-mode", "new-band", "new-mode", "new-slot", + "new-pota", "new-county", "new-pfx", + "my-call", "worked", "none", +} + +// defaultSpotColors is the shipped palette. +// +// Text colours are opaque and bright, backgrounds are the same hue at a fifth of +// the alpha: a waterfall is dark and busy, and a solid plate behind the callsign +// hides the very signal the operator is looking at. The scale runs red → amber → +// blue for "never had it" → "missing a piece" → "already yours". +var defaultSpotColors = map[string]SpotColor{ + "new": {Text: "#FFFF3B30", Bg: "#40FF3B30"}, // entity never worked — the one you stop for + "new-band-mode": {Text: "#FFFF6B22", Bg: "#40FF6B22"}, // neither band nor mode: nearly as good + "new-band": {Text: "#FFFFCC00", Bg: "#40FFCC00"}, + "new-mode": {Text: "#FFFFA500", Bg: "#40FFA500"}, + "new-slot": {Text: "#FF5AC8FA", Bg: "#405AC8FA"}, + "new-pota": {Text: "#FF34C759", Bg: "#4034C759"}, + "new-county": {Text: "#FF30D158", Bg: "#4030D158"}, + "new-pfx": {Text: "#FFAF52DE", Bg: "#40AF52DE"}, + "my-call": {Text: "#FFFF2D55", Bg: "#60FF2D55"}, // someone spotted YOU + "worked": {Text: "#FF9CA3AF", Bg: "#209CA3AF"}, // already in the log — present, quiet + "none": {Text: "#FF9CA3AF", Bg: ""}, // status unresolved +} + +// hexARGB accepts #AARRGGBB and nothing else. The Flex refuses anything shorter +// with a command error the operator never sees, so a half-typed value must not +// reach the radio — it is dropped here and the default is used instead. +func hexARGB(s string) bool { + s = strings.TrimSpace(s) + if len(s) != 9 || s[0] != '#' { + return false + } + for i := 1; i < len(s); i++ { + c := s[i] + if !(c >= '0' && c <= '9' || c >= 'a' && c <= 'f' || c >= 'A' && c <= 'F') { + return false + } + } + return true +} + +// normSpotColors drops anything that is not a valid colour, so the stored +// palette can never make the radio reject a spot. +func normSpotColors(s SpotColors) SpotColors { + out := SpotColors{Enabled: s.Enabled, Colors: map[string]SpotColor{}} + known := map[string]bool{} + for _, k := range spotColorOrder { + known[k] = true + } + for k, v := range s.Colors { + if !known[k] { + continue + } + c := SpotColor{} + if hexARGB(v.Text) { + c.Text = strings.ToUpper(strings.TrimSpace(v.Text)) + } + if hexARGB(v.Bg) { + c.Bg = strings.ToUpper(strings.TrimSpace(v.Bg)) + } + if c.Text != "" || c.Bg != "" { + out.Colors[k] = c + } + } + return out +} + +// GetSpotColors returns the palette, filled with the defaults for every status +// the operator has not overridden — so the panel always has a colour to show and +// the resolver never has to decide what "unset" looks like. +func (a *App) GetSpotColors() SpotColors { + out := SpotColors{Enabled: true, Colors: map[string]SpotColor{}} + if raw := a.settingOr(keySpotColors, ""); raw != "" { + var stored SpotColors + if err := json.Unmarshal([]byte(raw), &stored); err == nil { + stored = normSpotColors(stored) + out.Enabled = stored.Enabled + out.Colors = stored.Colors + } + } + for _, k := range spotColorOrder { + if _, ok := out.Colors[k]; !ok { + out.Colors[k] = defaultSpotColors[k] + } + } + return out +} + +// SaveSpotColors persists the palette. +func (a *App) SaveSpotColors(s SpotColors) error { + b, err := json.Marshal(normSpotColors(s)) + if err != nil { + return err + } + a.setSetting(keySpotColors, string(b)) + a.spotColorsMu.Lock() + a.spotColorsCache = nil // re-read on the next spot + a.spotColorsMu.Unlock() + return nil +} + +// ResetSpotColors puts the shipped palette back. +func (a *App) ResetSpotColors() SpotColors { + a.setSetting(keySpotColors, "") + a.spotColorsMu.Lock() + a.spotColorsCache = nil + a.spotColorsMu.Unlock() + return a.GetSpotColors() +} + +// spotColorFor picks the pair for one spot status. +// +// Cached, because this runs on EVERY spot from every cluster — a busy evening is +// several a second, and re-reading and re-parsing the settings JSON for each one +// would put a database round trip in the middle of the cluster read loop. +func (a *App) spotColorFor(status string) SpotColor { + a.spotColorsMu.Lock() + if a.spotColorsCache == nil { + c := a.GetSpotColors() + a.spotColorsCache = &c + } + p := a.spotColorsCache + a.spotColorsMu.Unlock() + if !p.Enabled { + return SpotColor{} + } + if c, ok := p.Colors[status]; ok { + return c + } + return p.Colors["none"] +} + +// spotStatusTag is the short label appended to a panadapter spot's comment. +// +// The colour says WHAT a spot is only to someone who has learnt the palette; the +// word says it to everyone, including the operator who set the colours a month +// ago. Both, then — the same choice DXHunter makes, whose spots read +// "10 dB 18 WPM CQ [AC0C] [United States] [NEW CTY]". +// +// Short on purpose: the comment shares a panadapter with the signals, and a +// spot label that runs over its neighbours hides the very thing it describes. +// "worked" and an unresolved entity get nothing at all — there is no news in +// either, and the absence of a tag is itself the answer. +func spotStatusTag(status string) string { + switch status { + case "new": + return "NEW DXCC" + case "new-band-mode": + return "NEW BAND+MODE" + case "new-band": + return "NEW BAND" + case "new-mode": + return "NEW MODE" + case "new-slot": + return "NEW SLOT" + case "new-pota": + return "NEW POTA" + case "new-county": + return "NEW COUNTY" + case "new-pfx": + return "NEW PFX" + case "my-call": + return "ME" + } + return "" +} + +// spotComment appends the status tag to the cluster's own comment. +func spotComment(comment, status string) string { + c := strings.TrimSpace(comment) + tag := spotStatusTag(status) + if tag == "" { + return c + } + if c == "" { + return "[" + tag + "]" + } + return c + " [" + tag + "]" +} diff --git a/spotcolors_test.go b/spotcolors_test.go new file mode 100644 index 0000000..ee6c84c --- /dev/null +++ b/spotcolors_test.go @@ -0,0 +1,76 @@ +package main + +import "testing" + +// A colour the Flex refuses is a spot that never appears, and the command error +// goes to a log nobody is reading. Anything that is not #AARRGGBB must be +// dropped here rather than sent. +func TestHexARGB(t *testing.T) { + for _, ok := range []string{"#FFFF3B30", "#00000000", "#ffabcdef", "#40FF6B22"} { + if !hexARGB(ok) { + t.Errorf("%q should be accepted", ok) + } + } + for _, bad := range []string{ + "", "#FFF", "#FF3B30", "FFFF3B30", "#FFFF3B3", "#FFFF3B300", + "#GGFF3B30", "#FFFF3B3G", "red", "rgb(255,0,0)", + } { + if hexARGB(bad) { + t.Errorf("%q should be refused", bad) + } + } +} + +// The stored palette must survive a round trip, and must not carry a status the +// resolver does not know — an unknown key would be a colour nothing can ever use +// and a field nobody can remove from the panel. +func TestNormSpotColors(t *testing.T) { + in := SpotColors{Enabled: true, Colors: map[string]SpotColor{ + "new": {Text: "#FFFF3B30", Bg: "#40FF3B30"}, + "new-band": {Text: "not a colour", Bg: "#40FFCC00"}, // half valid + "worked": {Text: "", Bg: ""}, // nothing at all + "invented": {Text: "#FF000000"}, // not a status + }} + out := normSpotColors(in) + if got := out.Colors["new"].Text; got != "#FFFF3B30" { + t.Errorf("valid pair lost: %q", got) + } + if c := out.Colors["new-band"]; c.Text != "" || c.Bg != "#40FFCC00" { + t.Errorf("half-valid pair = %+v, want the background kept and the text dropped", c) + } + if _, ok := out.Colors["worked"]; ok { + t.Errorf("an entry with no colour at all must not be stored") + } + if _, ok := out.Colors["invented"]; ok { + t.Errorf("an unknown status must not be stored") + } +} + +func TestSpotComment(t *testing.T) { + // The cluster's own text is kept: it carries the signal report and the + // operator's note, which is why the spot is readable in the first place. + if got := spotComment("CQ up 2", "new"); got != "CQ up 2 [NEW DXCC]" { + t.Fatalf("got %q", got) + } + // An empty comment must not produce a leading space on the panadapter. + if got := spotComment("", "new-band"); got != "[NEW BAND]" { + t.Fatalf("got %q", got) + } + // Nothing to say about a station already in the log. + if got := spotComment("loud", "worked"); got != "loud" { + t.Fatalf("got %q", got) + } + if got := spotComment("loud", "none"); got != "loud" { + t.Fatalf("got %q", got) + } + // Every colourable status except the two quiet ones is labelled, or the + // palette would say something the text does not. + for _, s := range spotColorOrder { + if s == "worked" || s == "none" { + continue + } + if spotStatusTag(s) == "" { + t.Fatalf("status %q has a colour but no tag", s) + } + } +} diff --git a/spotstatus_test.go b/spotstatus_test.go new file mode 100644 index 0000000..f09ec82 --- /dev/null +++ b/spotstatus_test.go @@ -0,0 +1,59 @@ +package main + +import "testing" + +// The order of these tests IS the meaning of the answer, and it was wrong: a +// station new on both the band and the mode was reported as a plain "new band", +// which reads as "you have worked this entity in this mode, just not here" — +// the opposite of the truth. It is also not a slot: a slot is the pair still +// missing when each half is already in the log. +func TestSpotEntityStatus(t *testing.T) { + for _, c := range []struct { + name string + worked, haveBand, haveMode, slot bool + mode string + want string + }{ + {"entity never worked", false, false, false, false, "SSB", "new"}, + {"entity never worked, no mode known", false, false, false, false, "", "new"}, + + // The case this exists for. + {"new band AND new mode", true, false, false, false, "SSB", "new-band-mode"}, + + // New band, but the mode is already in the log on another band. + {"new band only", true, false, true, false, "SSB", "new-band"}, + // New mode, on a band already worked. + {"new mode only", true, true, false, false, "SSB", "new-mode"}, + // Each half worked, never together: THAT is a slot. + {"new slot", true, true, true, false, "SSB", "new-slot"}, + {"fully worked", true, true, true, true, "SSB", "worked"}, + + // No mode: only the band can be judged, and a guess must never claim new. + {"no mode, new band", true, false, false, false, "", "new-band"}, + {"no mode, band worked", true, true, false, false, "", "worked"}, + } { + if got := spotEntityStatus(c.worked, c.haveBand, c.haveMode, c.slot, c.mode); got != c.want { + t.Errorf("%s: got %q, want %q", c.name, got, c.want) + } + } +} + +// Every status is reachable, and no two inputs collide on a status that should +// be exclusive — the guard against someone "simplifying" the chain later. +func TestSpotEntityStatusIsExhaustive(t *testing.T) { + seen := map[string]bool{} + for _, worked := range []bool{true, false} { + for _, band := range []bool{true, false} { + for _, mode := range []bool{true, false} { + for _, slot := range []bool{true, false} { + seen[spotEntityStatus(worked, band, mode, slot, "CW")] = true + } + } + } + } + for _, want := range []string{"new", "new-band-mode", "new-band", "new-mode", "new-slot", "worked"} { + if !seen[want] { + t.Errorf("no combination produces %q — the status is dead", want) + } + } +} diff --git a/telemetry.go b/telemetry.go index 28398a8..200c8b0 100644 --- a/telemetry.go +++ b/telemetry.go @@ -21,7 +21,7 @@ import ( const ( // appVersion is stamped on every heartbeat (and could feed the About box). - appVersion = "0.26.2" + appVersion = "0.26.3" // posthogHost is the PostHog ingestion endpoint. EU cloud by default; change // to https://us.i.posthog.com for a US project.