diff --git a/app.go b/app.go index 416eedd..60d7098 100644 --- a/app.go +++ b/app.go @@ -694,16 +694,21 @@ type App struct { pskr *pskr.Watcher // Self-spot throttle: when and on what frequency we last announced ourselves. // Held in memory only — a restart legitimately re-announces the station. - selfSpotMu sync.Mutex - selfSpotAt time.Time - selfSpotHz int64 - pota *pota.Cache - uls *uls.Store // US callsign→county/grid (offline FCC ULS), lazily opened - awardRefs *awardref.Repo - qslTemplates *qslcard.Repo - operating *operating.Repo - udp *udp.Manager - udpRepo *udp.Repo + selfSpotMu sync.Mutex + selfSpotAt time.Time + selfSpotHz int64 + pota *pota.Cache + uls *uls.Store // US callsign→county/grid (offline FCC ULS), lazily opened + awardRefs *awardref.Repo + qslTemplates *qslcard.Repo + operating *operating.Repo + udp *udp.Manager + udpRepo *udp.Repo + // Program id of the last decoding application that reported its status. + // Halt Tx is routed by id, and the panel's Halt button must work even when + // nothing is transmitting at that instant — so the id is remembered from + // every Status rather than read off a live transmission. + lastTxID atomic.Value // string extsvc *extsvc.Manager winkeyer *winkeyer.Manager clublog *clublog.Manager @@ -4290,6 +4295,13 @@ func (a *App) insertPOTAQSOs(entries []pota.HunterQSO) int { added++ } } + // Bulk insert, so the caches are dropped ONCE at the end rather than per row. + // invalidateAwardStats is the right hammer here: a raw a.qso.Add leaves the + // cluster worked-index, the award snapshot AND the QSO numbering all holding + // a pre-import answer, and this import inserts into the MIDDLE of the order. + if added > 0 { + a.invalidateAwardStats() + } return added } @@ -6667,6 +6679,127 @@ func (a *App) BandSlotQSOs(callsign string, dxccNum int, band, modeClass string) return out, nil } +// FlexTXOnBand moves the FlexRadio's transmitter to the slice listening on the +// given band, and focuses it. +// +// Why this exists: two decoding instances on two slices — say 20 m on slice A +// and 80 m on slice B — both feed OpsLog, and answering a decode routes the +// Reply to the right INSTANCE. But the instance keys one radio, and the radio +// transmits on whichever slice carries the TX flag. Answer an 80 m decode with +// TX still on the 20 m slice and the exchange goes out on the wrong band, or +// nowhere at all. +// +// A no-op that reports success on any other backend: only a Flex has slices, and +// a caller that has to ask what radio is attached before answering a decode is a +// caller that will get it wrong somewhere. +func (a *App) FlexTXOnBand(band string) error { + if a.cat == nil { + return nil + } + st, ok := a.cat.FlexState() + if !ok || len(st.Slices) == 0 { + return nil // not a Flex, or no slices yet — nothing to move + } + want := strings.ToLower(strings.TrimSpace(band)) + if want == "" { + return nil + } + // The whole band is examined BEFORE anything moves. Taking the first slice + // that matches was wrong the moment two slices share a band — which is + // exactly what split is: an RX slice and a TX slice, same band, a few kHz + // apart. The loop would find the RX one first, see no TX flag on it, and move + // the transmitter onto it — collapsing the split into simplex, and with it + // the panel's split indicator. + // + // If any slice on this band already transmits, there is nothing to do: the + // radio is already set up for this band, split or not, and it is not this + // function's business to rearrange it. + var target *cat.FlexSliceInfo + for i := range st.Slices { + s := &st.Slices[i] + if strings.ToLower(s.Band) != want { + continue + } + if s.TX { + return nil + } + if target == nil { + target = s + } + } + if target == nil { + // No slice on that band. Silent: the operator may simply be answering a + // decode from a receiver that is not this radio. + return nil + } + { + s := target + applog.Printf("flex: moving TX to slice %s (%s) to answer a %s decode", s.Letter, s.Band, band) + // TX only. NOT SetActiveSlice — that sets a persistent PIN whose whole + // contract is "the operator chose this slice in OpsLog", overriding the + // radio's own active flag until the slice closes. Calling it from here + // made every click on a decode silently re-pin the operating slice, and + // split — which is built around whichever slice is active — then created + // a new slice instead of pairing with the existing one, every time. + // + // Where the transmitter goes and which slice the operator is working from + // are two different questions. This answers only the first. + return a.cat.FlexDo(func(fc cat.FlexController) error { return fc.SetTXSlice(s.Index) }) + } +} + +// SendDecodeFreeText puts a message in the decoding application's free-text box +// and, with send, transmits it at once. +// +// The one transmit primitive that behaves the same across the whole family, +// because it matches against no decode. It does NOT start a QSO — FT8 free text +// is 13 characters and does not set the DX call, so no sequencing follows — and +// it is offered as "send this text", never as a way to call a station. +func (a *App) SendDecodeFreeText(instance, text string, send bool) error { + if a.udp == nil { + return fmt.Errorf("udp not initialized") + } + if strings.TrimSpace(instance) == "" { + instance = a.lastTxInstance() + } + err := a.udp.SendFreeText(instance, text, send) + if err != nil { + applog.Printf("udp: free text on %q failed: %v", instance, err) + } + return err +} + +// GridSquares returns the 4-character Maidenhead squares in the log, with +// whether each is confirmed. +// +// modeClass scopes it the way the rest of the app does: "DIGI", "CW", "PHONE", +// or "" for every mode. "DIGI" is the one this was built for — a map of the +// squares worked on FT8/FT4 answers "where have I actually been heard" in a way +// no list of callsigns does. +// +// Confirmed means LoTW, a card or eQSL — the same three the award engine counts, +// so a square cannot be green here and unconfirmed in the Awards panel. +func (a *App) GridSquares(modeClass string) ([]qso.GridSquare, error) { + if a.qso == nil { + return nil, fmt.Errorf("db not initialized") + } + want := strings.ToUpper(strings.TrimSpace(modeClass)) + keep := func(mode string) bool { + switch want { + case "", "ALL": + return true + case "FTX": + // The FT family alone, which is narrower than digital and usually the + // honest answer beside an FTx panel: a square worked on RTTY in a + // contest is not a square worked on FT8. + return ftxModes[strings.ToUpper(strings.TrimSpace(mode))] + default: + return award.ModeClass(mode) == want + } + } + return a.qso.GridSquares(a.ctx, keep) +} + // SetCompactMode toggles a tiny always-on-top window that exposes just the // QSO entry — useful when running on a single screen alongside WSJT-X, // JT-Alert or the cluster. @@ -8288,6 +8421,20 @@ func (a *App) clusterEventWorker() { } s := *ev.spot if a.dxcc != nil { + // The SPOTTER's continent, resolved here rather than in the per-call + // status cache. That cache is keyed by call|band|mode, and one DX call + // is spotted by skimmers all over the world within the same minute — + // so all of them collapsed onto whichever spotter happened to arrive + // first, and the continent filter passed every one of them. It is a + // property of the spot and now travels with it. + // + // The skimmer suffix goes first: RBN reports as "VU2OY-#" and cluster + // nodes as "DL1ABC-2", which the prefix matcher cannot resolve. + if sp := skimmerBase(s.Spotter); sp != "" { + if m, ok := a.dxcc.Lookup(sp); ok { + s.SpotterContinent = m.Continent + } + } if m, ok := a.dxcc.Lookup(s.DXCall); ok && m.Entity != nil { s.Country = m.Entity.Name s.Continent = m.Continent @@ -8339,6 +8486,19 @@ func (a *App) clusterEventWorker() { } } +// skimmerBase strips the reporting suffix from a spotter callsign: RBN skimmers +// announce as "VU2OY-#" and cluster nodes as "DL1ABC-2". The DXCC prefix matcher +// sees an unknown callsign and gives up on those, which is how the spotter's +// continent came back empty for every RBN spot. A real callsign never contains a +// hyphen, so cutting at the first one is safe. +func skimmerBase(spotter string) string { + s := strings.TrimSpace(spotter) + if i := strings.IndexByte(s, '-'); i > 0 { + s = s[:i] + } + return s +} + func (a *App) evaluateAlerts(s cluster.Spot) { if a.alertStore == nil { return @@ -8352,10 +8512,15 @@ func (a *App) evaluateAlerts(s cluster.Spot) { Spotter: s.Spotter, } // The spotter's country/continent (cty.dat) — resolved lazily for Origin rules. - if a.dxcc != nil && s.Spotter != "" { - if m, ok := a.dxcc.Lookup(s.Spotter); ok && m.Entity != nil { - sp.SpotterCountry = m.Entity.Name - sp.SpotterContinent = m.Continent + // Through skimmerBase for the same reason the cluster filter needs it: an + // Origin rule on "spotter continent = EU" never matched an RBN spot, because + // "DL1ABC-#" resolves to nothing. + if a.dxcc != nil { + if base := skimmerBase(s.Spotter); base != "" { + if m, ok := a.dxcc.Lookup(base); ok && m.Entity != nil { + sp.SpotterCountry = m.Entity.Name + sp.SpotterContinent = m.Continent + } } } matches := a.alertStore.Evaluate(sp, time.Now(), a.isWorkedBandMode) @@ -8411,10 +8576,13 @@ func (a *App) noteWorked(call, band, mode string) { return } a.wcbmMu.Lock() - if a.wcbm == nil { - a.wcbm = map[string]struct{}{} + // nil means "not built yet", and isWorkedBandMode reads that as its cue to + // load the whole log. Seeding a one-entry map here would look built and + // answer "never worked" for everything else. The row is already inserted, so + // the later rebuild picks this contact up anyway. + if a.wcbm != nil { + a.wcbm[wcbmKey(call, band, mode)] = struct{}{} } - a.wcbm[wcbmKey(call, band, mode)] = struct{}{} a.wcbmMu.Unlock() // The cluster worked-index snapshot is now stale (this call/slot just became // worked) — drop it so the next spot batch recolours with the new QSO. @@ -12633,6 +12801,14 @@ func (a *App) LogUDPLoggedADIF(adifText string) (int64, error) { // log. This insert bypasses AddQSO entirely, which is why UDP-logged contacts // came out unnumbered while hand-logged ones did not. a.noteQSONumbered(id, q.QSODate) + // And for the same reason, the worked indexes have to be told here too. + // AddQSO does this; bypassing it left the cluster/decode status snapshot + // holding its pre-QSO answer for the rest of the session — so a station + // worked through WSJT-X / JTDX / MSHV went on wearing NEW GRID, NEW CALL and + // NEW PFX after the QSO was in the log. Reported on RA3Y (KO73), still badged + // NEW GRID two minutes after the contact. Hand-logged contacts never showed + // it, which is exactly what made it look like a display bug. + a.noteWorked(q.Callsign, q.Band, q.Mode) a.noteLiveQSO() // multi-op: flip this operator back "online" (publishes async) // Announce the log AT ONCE so the grid / ON-AIR badge / stations-on-air widget // refresh immediately, then run the DB-heavy enrichment off the critical path @@ -12693,14 +12869,19 @@ func (a *App) consumeUDPEvents() { // switch because a Status carries BOTH a DX call and a transmit message, // and the switch below takes only one branch. // - // Sent on EVERY Status, not only when there is a transmit message: MSHV - // and older JTDX builds stop before tx_message in the Status payload, and - // the panel still has to be able to say who is being called and whether - // the carrier is up. A Status always carries de_call, so that is the test. + // Sent on EVERY Status, not only when there is a transmit message: the + // field is EMPTY between overs — that is its normal state, not a sender + // that withholds it — and the panel still has to say who is being called + // and whether the carrier is up. A Status always carries de_call, so that + // is the test. if ev.DECall != "" || ev.TxMessage != "" { + if ev.ProgramID != "" { + a.lastTxID.Store(ev.ProgramID) + } wruntime.EventsEmit(a.ctx, "udp:tx_state", map[string]any{ "msg": ev.TxMessage, "transmitting": ev.Transmitting, + "tx_enabled": ev.TxEnabled, "de_call": ev.DECall, "dx_call": ev.DXCall, "mode": ev.Mode, @@ -12744,9 +12925,13 @@ func (a *App) consumeUDPEvents() { "dt": ev.DecodeDT, "audio_hz": ev.DecodeAudioHz, // Carried so a click can answer the station: WSJT-X matches a - // Reply against its own decode list, field for field. + // Reply against its own decode list, field for field. mode_raw is + // the mode as the Decode sent it (the "~"/"+" marker) — "mode" + // above is the resolved name, which the match rejects. "ms": ev.DecodeMs, "low_conf": ev.DecodeLowConf, + "mode_raw": ev.DecodeModeRaw, + "msg_raw": ev.DecodeMsgRaw, }) // A WSJT-X decode (heard station). Render it on the FlexRadio // panadapter when the option is on; green + SNR comment, auto-expiring @@ -18219,6 +18404,12 @@ type SpotStatus struct { // carries the SPOTTER's grid at best, never the DX's. Grid string `json:"grid,omitempty"` NewGrid bool `json:"new_grid"` + // GridState splits NewGrid into its two meanings: "new" (never worked under + // the operator's scope) and "unconf" (worked, awaiting a confirmation). Empty + // when there is nothing to chase. They are different decisions — a QSO to + // make against a QSL to chase — and one badge for both is what made a station + // worked an hour ago still read as NEW GRID. + GridState string `json:"grid_state,omitempty"` // SpotterContinent is the continent of the station that SENT the spot, not of // the DX. It answers a different question — "is anyone near me hearing this?" // — which is what makes it worth filtering on: a JA spot on 20 m tells a @@ -18256,10 +18447,17 @@ type clusterStatusCache struct { // callCounties holds callsign → "STATE,County" for stations already logged // with a county, so a spot shows the county the entry panel showed rather // than the one derived from the licence ZIP. See qso.CallCounties. - callCounties map[string]string - workedPOTA map[string]struct{} - workedPfx map[string]struct{} - workedGrids map[string]struct{} // "GRID|MODE", mode normalised like the rest + callCounties map[string]string + workedPOTA map[string]struct{} + workedPfx map[string]struct{} + // workedGrids answers "is this square already mine" under EVERY band-and-mode + // scope, keyed by qso.GridKey and valued by whether the square is confirmed. + // One index for all six scopes and both hunting modes: the operator switches + // between them freely, and rebuilding the log index on each toggle would make + // a dropdown take seconds. + workedGrids map[string]bool + gridScope gridScope // the scope and hunt the cache was built under — + gridHunt string // a change to either rebuilds it normMode func(string) string // nil unless digital-mode grouping is on groupDigital bool // settings the maps were built under — sameSlot bool // a change rebuilds the snapshot @@ -18274,12 +18472,21 @@ func (a *App) clusterStatusMaps() *clusterStatusCache { groupDigital := a.groupDigitalSlots() sameSlot := a.clusterWorkedSameSlot() slotHighlight := a.clusterSlotHighlight() + // Read BEFORE taking the lock: settingOr goes to the settings store, and + // holding the status mutex across that is how two subsystems deadlock. + gs := a.GetGridScopeSettings() + gridScopeNow := lookupGridScope(gs.Scope) + gridHuntNow := gs.Hunt a.clusterStatusMu.Lock() defer a.clusterStatusMu.Unlock() - if c := a.clusterStatusIdx; c != nil && c.groupDigital == groupDigital && c.sameSlot == sameSlot && c.slotHighlight == slotHighlight { + if c := a.clusterStatusIdx; c != nil && c.groupDigital == groupDigital && c.sameSlot == sameSlot && + c.slotHighlight == slotHighlight && c.gridScope == gridScopeNow && c.gridHunt == gridHuntNow { return c } - c := &clusterStatusCache{groupDigital: groupDigital, sameSlot: sameSlot, slotHighlight: slotHighlight} + c := &clusterStatusCache{ + groupDigital: groupDigital, sameSlot: sameSlot, slotHighlight: slotHighlight, + gridScope: gridScopeNow, gridHunt: gridHuntNow, + } if a.qso == nil { a.clusterStatusIdx = c return c @@ -18330,7 +18537,7 @@ func (a *App) clusterStatusMaps() *clusterStatusCache { // One more DISTINCT scan when the snapshot is rebuilt, then pure map lookups // per spot — the same shape as the county and POTA sets beside it, which is // why grids cost nothing under an RBN firehose. - c.workedGrids, _ = a.qso.WorkedGridKeys(a.ctx, c.normMode) + c.workedGrids, _ = a.qso.GridWorkedIndex(a.ctx, gridClassesOf) // Worked WPX prefixes, derived from the callsigns we already loaded — no // extra query. Derived rather than read from the stored PFX column: that // column is only filled when an import supplied it, and deriving keeps this @@ -18404,6 +18611,37 @@ func (a *App) AnswerDecode(instance string, ms uint32, snr int, dt float64, audi return err } +// HaltDecodeTx tells the decoding application to stop transmitting — the same +// as its own Halt Tx button. +// +// autoTxOnly false stops the transmission mid-over; true lets the current over +// finish and only then disables auto-Tx. Both are real operator intentions: the +// first is "I called the wrong station", the second is "this QSO is done". +// +// instance may be empty, in which case the halt goes to whichever application +// last reported that it is transmitting — with one receiver, which is the +// normal case, that is simply the one running. +func (a *App) HaltDecodeTx(instance string, autoTxOnly bool) error { + if a.udp == nil { + return fmt.Errorf("udp not initialized") + } + if strings.TrimSpace(instance) == "" { + instance = a.lastTxInstance() + } + err := a.udp.SendHaltTx(instance, autoTxOnly) + if err != nil { + applog.Printf("udp: halt tx on %q failed: %v", instance, err) + } + return err +} + +// lastTxInstance is the program id of the last decoding application heard from, +// or "" if none has reported yet. +func (a *App) lastTxInstance() string { + s, _ := a.lastTxID.Load().(string) + return s +} + // GetGridCacheStatus reports what the locator store holds. func (a *App) GetGridCacheStatus() GridCacheStatus { out := GridCacheStatus{Enabled: a.gridStore != nil} @@ -18597,26 +18835,28 @@ func (a *App) ClusterSpotStatuses(spots []SpotQuery) []SpotStatus { } // The spotter's continent, and whether the DX uploads to LoTW. Both are // in-memory lookups on tables already loaded, so they add nothing per spot. + // + // NOTE: the cluster list no longer filters on THIS copy — it is keyed by + // call|band|mode, so every spotter of one call shares it. The filter reads + // the spot's own SpotterContinent instead. Kept because the field is part + // of the published status shape. if a.dxcc != nil && q.Spotter != "" { - // Strip the skimmer suffix first. RBN spotters report as "VU2OY-#" and - // a cluster node as "DL1ABC-2"; the prefix matcher sees an unknown - // callsign and gives up, so EVERY spot came back with no continent and - // the filter silently matched nothing. A real callsign never contains a - // hyphen, so cutting at the first one is safe. - sp := q.Spotter - if i := strings.IndexByte(sp, '-'); i > 0 { - sp = sp[:i] - } - if m, ok := a.dxcc.Lookup(sp); ok { - out[i].SpotterContinent = m.Continent + if sp := skimmerBase(q.Spotter); sp != "" { + if m, ok := a.dxcc.Lookup(sp); ok { + out[i].SpotterContinent = m.Continent + } } } if a.lotwUsers != nil { out[i].LoTW = a.lotwUsers.Lookup(q.Call).IsUser } - // NEW GRID: the square this station announced in a CQ we decoded. The mode - // is part of the key, so the "group digital modes" option decides whether a - // grid worked on FT8 still counts as new on FT4 — one rule, no branch here. + // NEW GRID: the square this station announced on the UDP decode feed. + // + // This runs for CLUSTER spots as well as decodes — one function serves + // both — but a cluster line never carries the DX's grid, only the + // spotter's. So a spot is judged here exactly when the same callsign has + // also been heard on the decode feed, and stays unjudged otherwise. That + // is the honest answer: no grid known is not the same as no grid needed. { // Read through the accessor: the decode goroutine swaps these maps on // rotation, so touching them unguarded is a race on the map header, @@ -18624,13 +18864,14 @@ func (a *App) ClusterSpotStatuses(spots []SpotQuery) []SpotStatus { g := a.lookupDecodeGrid(q.Call) if g != "" { out[i].Grid = g - cm := out[i].Mode - if normMode != nil && cm != "" { - cm = normMode(cm) - } - if _, done := idx.workedGrids[g+"|"+cm]; !done { - out[i].NewGrid = true - } + // The scope decides whether the band and the exact mode matter, + // and the hunt whether an unconfirmed square still counts as + // wanted. Both are the operator's settings — see gridscope.go. + // Two states, not one: never worked is a QSO to make, worked but + // unconfirmed is a QSL to chase. NewGrid stays the yes/no the + // filters read; GridState says WHICH, so the badge can differ. + out[i].GridState = gridStateFor(idx.workedGrids, idx.gridScope, idx.gridHunt, g, out[i].Band, out[i].Mode) + out[i].NewGrid = out[i].GridState != "" } } // NEW COUNTY. Two sources, better one first: diff --git a/bandopen_nearkm_test.go b/bandopen_nearkm_test.go new file mode 100644 index 0000000..b6ab1fc --- /dev/null +++ b/bandopen_nearkm_test.go @@ -0,0 +1,37 @@ +package main + +import ( + "testing" + + "hamlog/internal/pskr" +) + +// The receiver radius is what makes an opening report evidence about the +// OPERATOR's path rather than someone else's. Both ends of the range destroy +// that: too small and no receiver is ever near enough, too large and the +// reports are about a different part of the world. A stored value that would do +// either has to fall back rather than be honoured. +func TestBandOpenNearKmClamps(t *testing.T) { + for _, tc := range []struct { + name string + raw string + want int + }{ + {"unset falls back", "", pskr.DefaultNearKm}, + {"not a number falls back", "soon", pskr.DefaultNearKm}, + {"zero falls back", "0", pskr.DefaultNearKm}, + {"negative falls back", "-100", pskr.DefaultNearKm}, + {"absurdly tight falls back", "5", pskr.DefaultNearKm}, + {"absurdly wide falls back", "5000", pskr.DefaultNearKm}, + {"a real choice is kept", "100", 100}, + {"the lower bound is kept", "25", 25}, + {"the upper bound is kept", "1000", 1000}, + {"surrounding space is ignored", " 150 ", 150}, + } { + t.Run(tc.name, func(t *testing.T) { + if got := bandOpenNearKm(tc.raw); got != tc.want { + t.Errorf("bandOpenNearKm(%q) = %d, want %d", tc.raw, got, tc.want) + } + }) + } +} diff --git a/bandopen_sources.go b/bandopen_sources.go index 2dedc2a..e01c3a1 100644 --- a/bandopen_sources.go +++ b/bandopen_sources.go @@ -16,6 +16,7 @@ package main // they no longer need. import ( + "strconv" "strings" "hamlog/internal/applog" @@ -28,7 +29,8 @@ import ( const ( keyBandOpenEnabled = "bandopen.enabled" - keyBandOpenBands = "bandopen.bands" // comma-separated; empty = the default set + keyBandOpenBands = "bandopen.bands" // comma-separated; empty = the default set + keyBandOpenNearKm = "bandopen.nearkm" // receiver radius; empty = pskr.DefaultNearKm ) // rbnNodes are the two Reverse Beacon Network endpoints the watch wants: CW and @@ -45,6 +47,18 @@ type BandOpenSettings struct { // Available is every band that can be watched, so the UI does not carry its // own copy of a list that belongs to the detector. Available []string `json:"available"` + // NearKm is how close a RECEIVER has to be for its report to count as + // evidence about the operator's own path. An opening on these bands reaches + // an AREA, and the right radius is a judgement about how big that area is — + // a 2 m tropo duct is not a 10 m Es footprint — so it is the operator's to + // make rather than a constant. + // + // Tightening it costs nothing in traffic: the broker subscription is one + // ring of squares whatever this says, and this only decides what survives + // once the messages are here. It costs SENSITIVITY — too small a radius in a + // thinly-populated region leaves no receivers at all, and a watch with + // nothing to look at reports nothing while appearing to work. + NearKm int `json:"near_km"` } func (a *App) GetBandOpenSettings() BandOpenSettings { @@ -52,6 +66,7 @@ func (a *App) GetBandOpenSettings() BandOpenSettings { Enabled: a.settingOr(keyBandOpenEnabled, "") == "1", Bands: splitCSV(a.settingOr(keyBandOpenBands, "")), Available: pskr.Bands, + NearKm: bandOpenNearKm(a.settingOr(keyBandOpenNearKm, "")), } // Keep only bands that are still offered. A saved selection outlives the code // that made it: 12 m was dropped from the watched set, but every operator who @@ -78,9 +93,23 @@ func keepKnownBands(want []string) []string { return out } +// bandOpenNearKm reads the stored receiver radius, falling back to the default +// for anything unset or out of range. The bounds are the two ways to make the +// watch useless: below 25 km almost nobody is ever near enough to hear anything, +// and past 1000 km the reports stop being about the operator's own path — which +// is the entire premise of measuring from a receiver rather than a transmitter. +func bandOpenNearKm(raw string) int { + n, err := strconv.Atoi(strings.TrimSpace(raw)) + if err != nil || n < 25 || n > 1000 { + return pskr.DefaultNearKm + } + return n +} + func (a *App) SaveBandOpenSettings(s BandOpenSettings) error { a.setSetting(keyBandOpenEnabled, map[bool]string{true: "1", false: "0"}[s.Enabled]) a.setSetting(keyBandOpenBands, strings.Join(s.Bands, ",")) + a.setSetting(keyBandOpenNearKm, strconv.Itoa(bandOpenNearKm(strconv.Itoa(s.NearKm)))) if s.Enabled { a.ensureRBNNodes() } @@ -184,6 +213,7 @@ func (a *App) startBandOpenFeed() { a.pskr = pskr.New(pskr.Config{ Bands: bands, RxGrids: rxGrids, + NearKm: s.NearKm, OpLat: a.opLat, OpLon: a.opLon, Geo: func(grid string) (int, int, bool) { lat, lon, ok := gridToLatLon(grid) diff --git a/changelog.json b/changelog.json index 71080b0..4d63e68 100644 --- a/changelog.json +++ b/changelog.json @@ -3,16 +3,38 @@ "version": "0.26.0", "date": "", "en": [ + "A new FT decodes tab: every decode from WSJT-X, JTDX or MSHV, grouped by transmit period, with what is new and what you are sending. Clicking a decode asks the application to call that station, exactly as double-clicking the line in its own window does. Columns are resizable and remembered, the filter bar with them, Clear empties the lists and Halt stops the transmission. With two receivers running the table splits into one column per band, each with its own transmit line, Halt and Clear, and the column lights up when that receiver is on the air. On a FlexRadio, answering a decode moves the transmitter to the slice listening on that band — unless that band already transmits, so an existing split is left alone.", + "FT decodes: auto-call. OpsLog can answer a decode without you clicking it — pick what qualifies (a new entity, band, mode, band+mode slot, grid, US county, POTA park or WPX prefix) and add a watch list of callsigns, with or without conditions of their own. It answers a CQ only, one station at a time across the whole station, never while any receiver is still mid-QSO, with a cooldown per callsign, and every call is written to the log with its reason. Armed from the decodes toolbar or Settings → FTx decodes, and off until you turn it on.", + "A grid-square map (Tools → Grid squares): every 4-character square in the log, confirmed squares solid and worked ones faint, scoped to digital or the FT modes, on the basemap of your choice. It answers the one question a decode list cannot — not who is on the band, but where the station has actually been reaching.", + "UDP: a new outbound type relays the WSJT-X stream. Every datagram received from WSJT-X, JTDX or MSHV is re-sent byte for byte to another program — JTAlert, GridTracker, a second logger — which each sender cannot do on its own, since they talk to one address only. Forwarded verbatim, with no origin header of the kind that has to be stripped back off at the far end, and a target naming one of OpsLog’s own ports is refused rather than looped.", + "New-grid detection now reads the grid from a reply as well as from a CQ. \"C91RU IZ5EME JN52\" — a station answering with its locator — is the commonest grid-bearing message on a busy band, and only CQs were being read: any station whose CQ you happened to miss had no known grid at all and could never be flagged as a new one. This is why other tools showed far more wanted grids than OpsLog did.", + "New-grid chasing is now scoped the way GridTracker scopes it, so the two agree. Pick how a square counts as already worked — this band or any band, crossed with any digital mode, this exact mode, or any FT mode (FT8/FT4/FT2) — and whether to chase only squares never worked or unconfirmed ones too, which are still missing from the award. The two are shown differently: a square never worked is a QSO to make, one worked and awaiting a confirmation is a QSL to chase, and they no longer share a badge. Settings → DX Cluster. The decodes table also gained a Grid column.", + "Cluster: NEW badges now clear after a contact however it was logged. Only hand-logging refreshed the worked snapshot, so a station worked through WSJT-X / JTDX / MSHV — or replayed from the offline outbox, arriving from a multi-op partner, or imported from the POTA hunter log — kept its NEW, NEW BAND, NEW MODE, NEW SLOT, NEW GRID, NEW PFX or NEW POTA badge for the rest of the session.", + "DX cluster: the Spotter continent filter matches again. One callsign is spotted by skimmers all over the world within a minute, and they all shared a single cached entry belonging to whichever spotter arrived first — so picking AF left the Indian and American skimmers in the list. Each spot now carries its own spotter continent. Alert rules on the spotter’s continent or country were missing RBN spots for a related reason and now match too.", + "Recent QSOs: the callsign search takes wildcards. A plain word now matches the START of a call — 4S finds 4S7AB — while * is any run of characters and ? exactly one, so *4S ends with 4S and *4S* contains it anywhere. It was an unconditional contains-match before, which made asking for a prefix impossible.", + "QSL Manager: the right-click menu now carries the same actions as Recent QSOs — ADIF export of the selection, export with a chosen field set, Cabrillo, bulk edit, the callbook and cty.dat updates, e-mail and delete. Filtered exports are deliberately not offered here: \"the filter\" means the Recent-QSOs filter, not the rows on screen. Two entries that appeared in this tab and did nothing when clicked are fixed at the same time — the menu now shows an action only where it is actually wired.", + "Column pickers and the ADIF export field chooser gained a whole-dialog Select all / Clear. Only per-group links existed, so clearing a selection meant one click per group — a dozen of them before you could tick the handful you actually wanted. Applies to Recent QSOs, Worked before, the cluster list and the export dialog, and covers the award columns the per-group links never touched.", + "Rotator: a Compact mode option (Settings → Rotator) reduces the rotor widget to the dial and the short/long-path azimuths under it. Left off, the widget keeps its quick-turn buttons, azimuth box and Stop.", + "Band-opening watch: the radius that counts a receiver as \"around here\" is now adjustable (Settings → DX Cluster), 25–1000 km, still 300 km by default. An opening on 10 m reaches a whole region, a 2 m duct does not, and the right distance is a judgement only the operator can make. Tightening it costs no extra traffic — the subscription is unchanged — only sensitivity.", "Club Log uploads are now identified as OpsLog. They were credited to another station's application key, which took the blame for them.", - "ADIF import: \"fill my station fields\" now fills the station callsign too, on records that carry none.", - "A new FT decodes tab: every decode from WSJT-X, JTDX or MSHV, grouped by transmit period, with what is new and what you are sending.", - "Clicking a decode asks WSJT-X or MSHV to call that station, exactly as double-clicking the line in their own window does." + "ADIF import: \"fill my station fields\" now fills the station callsign too, on records that carry none." ], "fr": [ + "Un onglet Décodages FT : tous les décodages de WSJT-X, JTDX ou MSHV, groupés par période d’émission, avec ce qui est nouveau et ce que tu émets. Cliquer un décodage demande au logiciel d’appeler cette station, exactement comme un double-clic sur la ligne dans sa propre fenêtre. Les colonnes se redimensionnent et sont mémorisées, la barre de filtres avec elles, Vider efface les listes et Stop arrête l’émission. Avec deux récepteurs, le tableau se scinde en une colonne par bande, chacune avec sa ligne d’émission, son Stop et son Vider, et la colonne s’allume quand c’est ce récepteur qui émet. Sur un FlexRadio, répondre à un décodage déplace l’émetteur sur la slice qui écoute cette bande — sauf si cette bande émet déjà, pour ne pas défaire un split en place.", + "Décodages FT : appel automatique. OpsLog peut répondre à un décodage sans que tu cliques — choisis ce qui le déclenche (nouvelle entité, bande, mode, couple bande+mode, carré, comté US, parc POTA ou préfixe WPX) et ajoute une liste d’indicatifs surveillés, avec ou sans conditions propres. Uniquement sur un CQ, une station à la fois pour toute la station, jamais tant qu’un récepteur est encore en QSO, avec un délai de garde par indicatif, et chaque appel est écrit dans le journal avec sa raison. S’arme depuis la barre d’outils des décodages ou Réglages → Décodages FTx, et reste désactivé tant que tu ne l’actives pas.", + "Une carte des carrés locator (Outils → Carrés locator) : tous les carrés de 4 caractères du journal, les confirmés en plein et les contactés en pâle, au choix en numérique ou en modes FT, sur le fond de carte de ton choix. Elle répond à la seule question qu’une liste de décodages ne peut pas traiter : non pas qui est sur la bande, mais jusqu’où la station porte réellement.", + "UDP : un nouveau type sortant relaie le flux WSJT-X. Chaque datagramme reçu de WSJT-X, JTDX ou MSHV est réémis octet pour octet vers un autre logiciel — JTAlert, GridTracker, un second carnet — ce qu’aucun émetteur ne sait faire seul puisqu’il ne parle qu’à une adresse. Transmis tel quel, sans l’en-tête d’origine qu’il faut ensuite retirer à l’autre bout, et une cible désignant un port d’écoute d’OpsLog est refusée au lieu de boucler.", + "La détection des nouveaux carrés lit désormais le locator dans une réponse autant que dans un CQ. « C91RU IZ5EME JN52 » — une station qui répond avec son locator — est le message porteur de locator le plus fréquent sur une bande chargée, et seuls les CQ étaient lus : une station dont on avait manqué le CQ n’avait aucun locator connu et ne pouvait jamais être signalée comme nouvelle. C’est ce qui expliquait l’écart avec les autres logiciels sur le nombre de carrés recherchés.", + "La chasse aux nouveaux carrés se règle désormais comme dans GridTracker, pour que les deux soient d’accord. Choisis ce qui fait qu’un carré est déjà fait — cette bande ou toutes bandes, croisé avec tout mode numérique, ce mode exact, ou tout mode FT (FT8/FT4/FT2) — et si tu chasses seulement les carrés jamais contactés ou aussi les non confirmés, qui manquent encore au diplôme. Les deux s’affichent différemment : un carré jamais contacté est un QSO à faire, un carré contacté en attente de confirmation est une QSL à relancer, et ils ne partagent plus le même badge. Réglages → Cluster DX. Le tableau des décodages gagne aussi une colonne Locator.", + "Cluster : les badges NEW s’effacent enfin après un contact, quel que soit le mode de journalisation. Seule la saisie manuelle rafraîchissait l’instantané des contacts, si bien qu’une station travaillée via WSJT-X / JTDX / MSHV — ou rejouée depuis la file hors-ligne, reçue d’un partenaire multi-op, ou importée du journal chasseur POTA — gardait son badge NEW, NEW BAND, NEW MODE, NEW SLOT, NEW GRID, NEW PFX ou NEW POTA jusqu’à la fin de la session.", + "Cluster DX : le filtre Continent du spotter fonctionne à nouveau. Un même indicatif est spotté par des skimmers du monde entier en une minute, et tous partageaient une seule entrée en cache appartenant au premier spotter arrivé — choisir AF laissait donc les skimmers indiens et américains dans la liste. Chaque spot porte désormais son propre continent de spotter. Les règles d’alerte sur le continent ou le pays du spotter rataient les spots RBN pour une raison voisine et fonctionnent aussi.", + "QSO récents : la recherche d’indicatif accepte les jokers. Un mot simple correspond désormais au DÉBUT de l’indicatif — 4S trouve 4S7AB — tandis que * remplace n’importe quelle suite de caractères et ? exactement un : *4S se termine par 4S, *4S* le contient n’importe où. C’était auparavant une recherche « contient » systématique, qui rendait impossible la recherche par préfixe.", + "Gestionnaire QSL : le menu contextuel propose désormais les mêmes actions que les QSO récents — export ADIF de la sélection, export avec choix des champs, Cabrillo, édition en masse, mises à jour cty.dat et annuaires, e-mail et suppression. Les exports « filtrés » n’y sont volontairement pas offerts : « le filtre » désigne celui des QSO récents, pas les lignes affichées ici. Deux entrées qui apparaissaient dans cet onglet sans rien faire sont corrigées au passage — le menu n’affiche plus une action que là où elle est réellement branchée.", + "Les sélecteurs de colonnes et le choix des champs à l’export ADIF ont désormais un Tout sélectionner / Tout décocher global. Seuls les liens par groupe existaient, si bien que vider une sélection demandait un clic par groupe — une douzaine avant de pouvoir cocher les quelques champs voulus. Vaut pour les QSO récents, Déjà contacté, la liste cluster et la fenêtre d’export, et couvre les colonnes de diplômes que les liens par groupe ne touchaient pas.", + "Rotor : une option Mode compact (Réglages → Rotor) réduit le widget au cadran et aux azimuts courte/longue distance en dessous. Désactivée, le widget garde ses boutons de rotation rapide, sa case d’azimut et Stop.", + "Veille d’ouverture : le rayon qui fait qu’un récepteur compte comme « près d’ici » est désormais réglable (Réglages → Cluster DX), de 25 à 1000 km, toujours 300 km par défaut. Une ouverture sur 10 m couvre toute une région, un conduit sur 2 m non, et la bonne distance est un jugement qui n’appartient qu’à l’opérateur. Le resserrer ne coûte aucun trafic supplémentaire — l’abonnement ne change pas — seulement de la sensibilité.", "Les envois Club Log s’identifient désormais comme OpsLog. Ils étaient attribués à la clé applicative d’une autre station, qui en portait la responsabilité.", - "Import ADIF : « remplir mes champs station » renseigne aussi l’indicatif de station, sur les enregistrements qui n’en portent pas.", - "Un onglet Decodes FT : tous les décodes de WSJT-X, JTDX ou MSHV, groupés par période, avec ce qui est nouveau et ce que tu émets.", - "Cliquer un décode demande à WSJT-X ou MSHV d’appeler la station, exactement comme un double-clic dans leur propre fenêtre." + "Import ADIF : « remplir mes champs station » renseigne aussi l’indicatif de station, sur les enregistrements qui n’en portent pas." ] }, { diff --git a/frontend/src/App.tsx b/frontend/src/App.tsx index 658980e..ca31e45 100644 --- a/frontend/src/App.tsx +++ b/frontend/src/App.tsx @@ -94,7 +94,7 @@ import { ShutdownProgress } from '@/components/ShutdownProgress'; import { ClusterGrid } from '@/components/ClusterGrid'; import { cleanSpotter, inferSpotMode, spotModeCategory, spotStatusKey } from '@/lib/spot'; import { applySpotDisplay, readSpotDisplayOptions, spotIsWorked, SPOT_DISPLAY_OPTIONS_EXPOSED } from '@/lib/spotDisplay'; -import { AnswerDecode, GetMatrixColors, GetRotorPresets, GetRowColors, GetSpotTTLMinutes, IsNewUSCounty } from '../wailsjs/go/main/App'; +import { AnswerDecode, HaltDecodeTx, LogUIError, FlexTXOnBand, GetMatrixColors, GetRotorPresets, GetRowColors, GetSpotTTLMinutes, IsNewUSCounty } from '../wailsjs/go/main/App'; import { applyMatrixColors } from '@/lib/matrixColors'; import { WorkedBeforeGrid } from '@/components/WorkedBeforeGrid'; import { NetControlPanel } from '@/components/NetControlPanel'; @@ -108,6 +108,8 @@ import { DetailsPanel, type DetailsState } from '@/components/DetailsPanel'; import { SendSpotModal, type RecentSpotQSO } from '@/components/SendSpotModal'; import { WinkeyerPanel, type WKStatus, type WKMacro } from '@/components/WinkeyerPanel'; import { RotorCompass } from '@/components/RotorCompass'; +import { GridSquareMap } from '@/components/GridSquareMap'; +import { loadAutoCall, shouldAutoCall, autoCallKey, type AutoCallSettings } from '@/lib/autocall'; import { DecodesPanel, type Decode as DecodeRow, type TxMsg as TxMsgRow } from '@/components/DecodesPanel'; import { subscribeRotorHeading, pokeRotorHeading } from '@/lib/rotorHeading'; import { writeUiPref } from '@/lib/uiPref'; @@ -1036,6 +1038,22 @@ export default function App() { // unlike Statistics, which is consulted and closed, this one is a panel an // operator running digital modes leaves open for the session. const [decodesTabOpen, setDecodesTabOpen] = useState(() => localStorage.getItem('opslog.decodesTab') === '1'); + // The grid-square map is its OWN closable tab, not a column beside the decode + // table. It is an analysis view — consulted a few times an evening — and the + // space beside the table is worth far more to a second receiver's decodes when + // two bands are running. Full width also makes it legible, which it was not in + // a 38 % column. + const [gridsTabOpen, setGridsTabOpen] = useState(() => localStorage.getItem('opslog.gridsTab') === '1'); + function openGridsTab() { + setGridsTabOpen(true); + writeUiPref('opslog.gridsTab', '1'); + setActiveTab('grids'); + } + function closeGridsTab() { + setGridsTabOpen(false); + writeUiPref('opslog.gridsTab', '0'); + setActiveTab((t) => (t === 'grids' ? 'recent' : t)); + } function openDecodesTab() { setDecodesTabOpen(true); writeUiPref('opslog.decodesTab', '1'); @@ -1828,6 +1846,7 @@ export default function App() { const [showSettings, setShowSettings] = useState(false); // Re-read the "beam on map" toggle when Preferences closes (it's edited there). useEffect(() => { if (!showSettings) setShowBeamOnMap(localStorage.getItem('opslog.showBeamOnMap') !== '0'); }, [showSettings]); + useEffect(() => { if (!showSettings) setRotorCompact(localStorage.getItem('opslog.rotorCompact') === '1'); }, [showSettings]); // Openings under way, for the blinking status-bar badge. Polled rather than // event-driven: the badge also has to go OUT when a band goes quiet, and // nothing emits an event for something that stopped happening. @@ -2068,7 +2087,99 @@ export default function App() { // The LIVE transmit state, replaced on every Status — what is going out now // and to whom, which the period history cannot answer between overs. const [txState, setTxState] = useState(null); + // The same, per receiver. With two instances the single txState is whichever + // one reported last, so a split view cannot say WHICH is on the air — which is + // the only question worth asking when both are calling. + const [txStates, setTxStates] = useState>({}); useEffect(() => { decodesRef.current = decodes; }, [decodes]); + + // ── Auto-call ────────────────────────────────────────────────────── + // + // Answers a decode without the operator clicking it. The DECISION lives in + // lib/autocall (one pure function, so the dangerous part can be read and + // argued with); this is only the plumbing that runs it and keys the radio. + // + // Re-read when Preferences closes, like every other setting edited there. + const [autoCall, setAutoCall] = useState(loadAutoCall); + useEffect(() => { if (!showSettings) setAutoCall(loadAutoCall()); }, [showSettings]); + // When each callsign was last answered, so a station still calling CQ is not + // re-answered every slot while the QSO it started is still running. + const autoCalledRef = useRef>(new Map()); + // Decodes are scanned once. Without this the same decode is reconsidered on + // every status refresh, and a cooldown that has just expired would fire again + // on a decode minutes old. + const autoSeenRef = useRef>(new Set()); + // Set when a call goes out, so nothing else fires until the receiver's own + // status catches up and `busy` can be trusted again. + const autoHoldUntilRef = useRef(0); + // Per receiver, when the carrier was last up. Feeds the stale-exchange + // backstop below. + const lastTxAtRef = useRef>(new Map()); + useEffect(() => { + if (!autoCall.enabled) return; + const now = Date.now(); + // A QSO is in progress somewhere if ANY receiver is transmitting or still + // holding a DX call it has not finished with. Both matter: between overs the + // carrier is down but the exchange is not over, and calling someone else + // then is exactly the "it never stops" behaviour. + const busy = Object.values(txStates).some((tx) => { + if (tx?.transmitting) return true; + // A DX call still set means the exchange is not finished — but ONLY while + // the sender still intends to transmit. The watchdog stops transmission + // and leaves the DX call behind, and reading the call alone left auto-call + // waiting for a QSO that had already been given up on, for ever. + if (!tx?.dx_call?.trim()) return false; + if (tx.tx_enabled === false) return false; + // Backstop for a sender that never reports the toggle: an exchange with no + // transmission for three minutes is over, whatever the DX call still says. + // Measured from the last TIME THE CARRIER WAS UP — Status itself arrives + // every second and so can never go stale. + const last = lastTxAtRef.current.get(tx.instance ?? ''); + return last === undefined || now - last < 180_000; + }) + // The hold closes the gap between sending a Reply and the receiver saying + // it has acted on it — about a second. Without it the OTHER instance still + // looks idle in that window and gets a call of its own. + || now < autoHoldUntilRef.current; + for (const d of decodes) { + const seenKey = `${d.call}|${d.ms ?? d.at}|${d.instance ?? ''}`; + if (autoSeenRef.current.has(seenKey)) continue; + // Only decodes from the CURRENT period are worth answering: replying to a + // slot that has closed asks the far end to match a decode it has dropped. + if (now - Date.parse(d.at) > 30_000) { autoSeenRef.current.add(seenKey); continue; } + const e = spotStatus[`${d.call}|${d.band ?? ''}|${(d.mode ?? '').toUpperCase()}`]; + // NOT marked seen until its status has resolved. Statuses land a few + // hundred milliseconds after the decode, so consuming it on first sight + // would throw away almost every decode unjudged — the effect re-runs when + // spotStatus changes, and this is what lets it look again. + if (!e) continue; + autoSeenRef.current.add(seenKey); + const verdict = shouldAutoCall(autoCall, d, e as any, { + busy, + calledAt: autoCalledRef.current, + now, + myCall: station.callsign, + }); + if (!verdict.call) continue; + autoCalledRef.current.set(d.call.toUpperCase(), now); + autoHoldUntilRef.current = now + 12_000; // an FT8 slot, near enough + // Same reason as a manual click: put the transmitter on the decode's band + // before answering, or a second slice answers on the wrong one. + FlexTXOnBand(d.band ?? '').catch(() => {}); + // Logged, always: an automatic transmission with no record of WHY is the + // one thing an operator cannot argue with after the fact. + LogUIError('auto-call', `calling ${d.call} — ${verdict.reason}`, ''); + AnswerDecode( + d.instance ?? '', d.ms ?? 0, d.snr, d.dt ?? 0, + d.audio_hz ?? 0, d.mode_raw || d.mode || '', d.msg_raw ?? d.msg ?? '', !!d.low_conf, + ).catch((e2: any) => setError(String(e2?.message ?? e2))); + onCallsignInput(d.call, { force: true }); + break; // one per pass: a period can hold several, and we work one station + } + // The seen-set is bounded by the same half hour the decode list keeps. + if (autoSeenRef.current.size > 20000) autoSeenRef.current.clear(); + // eslint-disable-next-line react-hooks/exhaustive-deps + }, [decodes, spotStatus, autoCall, txStates]); // Staged like the cluster's, so a period arriving as one burst of fifty // packets costs one status lookup and one render, not fifty of each. const pendingDecodesRef = useRef([]); @@ -2213,6 +2324,11 @@ export default function App() { const refreshChaseNew = useCallback(() => { GetChaseNew().then(setChaseNewOn).catch(() => {}); }, []); useEffect(() => { refreshChaseNew(); }, [refreshChaseNew]); const [showBeamOnMap, setShowBeamOnMap] = useState(() => localStorage.getItem('opslog.showBeamOnMap') !== '0'); + // Compact rotor widget (Settings → Rotator): dial + SP/LP only. RotorCompass + // already draws exactly that when it is given neither presets nor onStop — + // withholding them IS the compact mode, so there is no second layout to keep + // in step with the first. + const [rotorCompact, setRotorCompact] = useState(() => localStorage.getItem('opslog.rotorCompact') === '1'); // Award code → scanned field (e.g. POTA→pota_ref, WWFF→wwff). Used to route // picked award references to the QSO field/extras each award actually reads. @@ -3131,6 +3247,14 @@ export default function App() { // even between overs, and on a sender that never reports its transmit // text at all. setTxState(m as TxMsgRow); + if (m?.instance) { + setTxStates((prev) => ({ ...prev, [m.instance]: m as TxMsgRow })); + // When this receiver last actually TRANSMITTED, which is not the same as + // when it last spoke: Status arrives about once a second whether the + // carrier is up or not, so it can never say how long an exchange has + // been stalled. + if (m.transmitting) lastTxAtRef.current.set(m.instance, Date.now()); + } // The period history takes only real transmissions — Status repeats // itself once a second whether the carrier is up or not. if (!m?.transmitting || !String(m?.msg ?? '').trim()) return; @@ -4313,6 +4437,7 @@ export default function App() { { type: 'item', label: t('stats.tab'), action: 'tools.stats' }, { type: 'item', label: t('station.title'), action: 'tools.station' }, { type: 'item', label: t('dec.tab'), action: 'tools.decodes' }, + { type: 'item', label: t('gsm.title'), action: 'tools.grids' }, { type: 'item', label: t('tools.qslDesigner'), action: 'tools.qsldesigner' }, { type: 'separator' }, { type: 'item', label: (wkEnabled ? '✓ ' : '') + t('tools.winkeyer'), action: 'tools.winkeyer' }, @@ -4363,6 +4488,7 @@ export default function App() { case 'tools.stats': setStatsTabOpen(true); setActiveTab('stats'); break; case 'tools.station': setStationTabOpen(true); setActiveTab('station'); break; case 'tools.decodes': openDecodesTab(); break; + case 'tools.grids': openGridsTab(); break; case 'tools.qsldesigner': setQslDesignerOpen(true); break; case 'tools.winkeyer': wkSetEnabled(!wkEnabled); break; case 'tools.dvk': setDvkEnabled((v) => !v); break; @@ -5192,18 +5318,26 @@ export default function App() { || (!!e?.new_grid && clusterStatusFilter.has('new-grid')); if (!matches) return false; } - // LoTW only, and the spotter's continent. Both are properties of the - // station rather than judgements about the spot, so they AND with the - // status chips instead of joining that OR: "a new band, and from Europe". - if (clusterLotwOnly || clusterSpotterConts.size > 0) { + // The spotter's continent comes from the SPOT, never from spotStatus. + // spotStatus is keyed by call|band|mode, and one DX call is spotted by + // skimmers on every continent within the same minute — so they all shared + // whichever spotter arrived first, and picking AF left the Indian and + // American skimmers exactly where they were. The spot carries its own. + // + // A spot whose spotter could not be resolved IS dropped here: the value + // arrives with the row, so there is no window to flicker through, and + // silently keeping unresolved rows is what made the old bug invisible. + if (clusterSpotterConts.size > 0) { + if (!clusterSpotterConts.has((s as any).spotter_continent ?? '')) return false; + } + // LoTW is a property of the DX station, so it stays on the status entry — + // where call|band|mode is exactly the right key. + if (clusterLotwOnly) { const k = spotStatusKey(s.dx_call, s.band ?? '', s.comment ?? '', s.freq_hz); const e = spotStatus[k]; // An unresolved spot is not filtered out. The status arrives a moment // after the row does, and dropping it meanwhile made the list flicker. - if (e) { - if (clusterLotwOnly && !e.lotw) return false; - if (clusterSpotterConts.size > 0 && e.spotter_continent && !clusterSpotterConts.has(e.spotter_continent)) return false; - } + if (e && !e.lotw) return false; } if (clusterHideWorked) { const k = spotStatusKey(s.dx_call, s.band ?? '', s.comment ?? '', s.freq_hz); @@ -5455,6 +5589,15 @@ export default function App() { decodes={decodes} txMsgs={txMsgs} txState={txState} + txStates={txStates} + autoCallOn={autoCall.enabled} + // Written through the same key Preferences uses, so the two can never + // disagree about whether the machine is armed. + onToggleAutoCall={() => setAutoCall((prev) => { + const next = { ...prev, enabled: !prev.enabled }; + writeUiPref(autoCallKey, JSON.stringify(next)); + return next; + })} spotStatus={spotStatus as any} myCall={station.callsign} // A click ANSWERS the station: it hands the decode back to WSJT-X/MSHV as @@ -5467,11 +5610,42 @@ export default function App() { // for the VFO. The entry is still filled, so the QSO can be logged here. onCall={(d) => { onCallsignInput(d.call, { force: true }); + // With two slices on two bands, the Reply reaches the right INSTANCE but + // the radio still transmits on whichever slice holds the TX flag. Move + // it to the decode's band first, or an 80 m answer goes out on 20 m. + // A no-op on any backend without slices. + FlexTXOnBand(d.band ?? '').catch(() => { /* not a Flex, or no such slice */ }); AnswerDecode( d.instance ?? '', d.ms ?? 0, d.snr, d.dt ?? 0, - d.audio_hz ?? 0, d.mode ?? '', d.msg ?? '', !!d.low_conf, + // The RAW mode marker, not the resolved name: the receiving + // application matches the Reply against its decode list field for + // field, and JTDX drops one that says "FT8" where it decoded "~". + d.audio_hz ?? 0, d.mode_raw || d.mode || '', d.msg_raw ?? d.msg ?? '', !!d.low_conf, ).catch((e: any) => setError(String(e?.message ?? e))); }} + // Wipes the live view only — nothing here is stored, and the staging + // buffer goes too or the next flush would put back what was just cleared. + onClear={(instance) => { + if (!instance) { + pendingDecodesRef.current = []; + setDecodes([]); + setTxMsgs([]); + setTxState(null); + setTxStates({}); + return; + } + // One receiver only: the other pane keeps everything it was showing, + // which is the whole reason for clearing just one. + pendingDecodesRef.current = pendingDecodesRef.current.filter((d) => (d.instance ?? '') !== instance); + setDecodes((a) => a.filter((d) => (d.instance ?? '') !== instance)); + setTxMsgs((a) => a.filter((m) => (m.instance ?? '') !== instance)); + setTxStates((prev) => { const n = { ...prev }; delete n[instance]; return n; }); + }} + // An empty instance lets the backend fall back to whichever application + // last reported its status — the normal single-receiver case. + onHalt={(instance) => { + HaltDecodeTx(instance, false).catch((e: any) => setError(String(e?.message ?? e))); + }} /> ); @@ -6489,12 +6663,14 @@ export default function App() { )} {/* Rotor compass: azimuth dial + needles + click-to-turn. Shows when a - rotator is configured or a DX bearing exists. */} + rotator is configured or a DX bearing exists. Compact mode drops the + controls column, so the widget is just the dial and needs only its + width. */} {showRotor && (rotatorHeading.enabled || dxPath) && ( -
+
{ RotatorStop().then(pokeRotorHeading).catch((err) => setError(String(err?.message ?? err))); }} + presets={rotorCompact ? undefined : rotorPresets} + onStop={rotorCompact ? undefined : () => { RotatorStop().then(pokeRotorHeading).catch((err) => setError(String(err?.message ?? err))); }} bearing={dxPath?.bearingShort ?? null} headings={beamHeadings} boomHeading={boomHeading} @@ -6773,6 +6949,21 @@ export default function App() { )} + {gridsTabOpen && ( + + {t('gsm.title')} + { e.stopPropagation(); }} + onClick={(e) => { e.stopPropagation(); closeGridsTab(); }} + > + + + + )} {decodesTabOpen && ( {t('dec.tab')} @@ -6832,7 +7023,8 @@ export default function App() {
setFilterCallsign(e.target.value.toUpperCase())} /> @@ -7201,7 +7393,26 @@ export default function App() { updating) while you work on other tabs. */} {qslTabOpen && ( - + setEqslQsoId(ids[0] ?? null), + onBulkEdit: openBulkEdit, + onExportSelected: exportSelectedADIF, + onExportSelectedFields: exportSelectedFields, + onExportCabrilloSelected: exportSelectedCabrillo, + onDelete: (ids) => setDeletingIds(ids), + }} + /> )} @@ -7240,6 +7451,12 @@ export default function App() { )} + {gridsTabOpen && ( + + + + )} + {decodesTabOpen && ( {renderDecodesPanel()} diff --git a/frontend/src/components/ClusterGrid.tsx b/frontend/src/components/ClusterGrid.tsx index e2b95b7..b9e4ea3 100644 --- a/frontend/src/components/ClusterGrid.tsx +++ b/frontend/src/components/ClusterGrid.tsx @@ -69,6 +69,7 @@ export type SpotStatusEntry = { spotter_continent?: string; grid?: string; new_grid?: boolean; + grid_state?: string; }; type Props = { @@ -266,12 +267,12 @@ const makeColCatalog = (t: TFn): ColEntry[] => [ if (s?.new_county) parts.push(t('clg2.newCounty')); if (s?.new_pota) parts.push(t('clg2.newPota')); if (s?.new_pfx) parts.push(t('clg2.newPfx')); - if (s?.new_grid) parts.push(t('clg2.newGrid')); + if (s?.new_grid) parts.push(s.grid_state === 'unconf' ? t('clg2.newGridUnconf') : t('clg2.newGrid')); return parts.join(' '); }, cellRenderer: (p: any) => { const s = statusFor(p); - const parts: { text: string; color: string }[] = []; + const parts: { text: string; color: string; dim?: boolean }[] = []; const main = statusColor(s); if (main) { const label = s?.status === 'new' ? t('clg2.newDxcc') @@ -287,12 +288,19 @@ const makeColCatalog = (t: TFn): ColEntry[] => [ if (s?.new_county) parts.push({ text: t('clg2.newCounty'), color: markerColour('new_county') }); if (s?.new_pota) parts.push({ text: t('clg2.newPota'), color: markerColour('new_pota') }); if (s?.new_pfx) parts.push({ text: t('clg2.newPfx'), color: markerColour('new_pfx') }); - if (s?.new_grid) parts.push({ text: t('clg2.newGrid'), color: markerColour('new_grid') }); + // Worked-but-unconfirmed is a QSL to chase, not a QSO to make. Same hue + // held back, so it reads as "less" of the same thing rather than a + // different fact — and the label says which. + if (s?.new_grid) { + parts.push(s.grid_state === 'unconf' + ? { text: t('clg2.newGridUnconf'), color: markerColour('new_grid'), dim: true } + : { text: t('clg2.newGrid'), color: markerColour('new_grid') }); + } if (parts.length === 0) return —; return ( {parts.map((pt, i) => ( - + {i > 0 ? ' · ' : ''}{pt.text} ))} @@ -638,6 +646,17 @@ export function ClusterGrid({ rows, spotStatus, onSpotClick }: Props) { {t('clg2.pickerDesc')} + {/* Whole-dialog controls. showAll/hideAll with no group already mean + "every column"; only the buttons were missing, so hiding the lot + took one click per group. */} +
+ {t('clg2.allGroups')} + + · + +
{GROUP_ORDER.map((group) => { const cols = COL_CATALOG.filter((c) => c.group === group); diff --git a/frontend/src/components/DecodesPanel.tsx b/frontend/src/components/DecodesPanel.tsx index 6da2545..c16cfbe 100644 --- a/frontend/src/components/DecodesPanel.tsx +++ b/frontend/src/components/DecodesPanel.tsx @@ -13,10 +13,11 @@ // come from the same resolver the cluster uses, so a call means the same thing in // both panels rather than being judged twice by two rules. import { useEffect, useMemo, useState } from 'react'; -import { Radio, Search, X, Signal, ArrowUpRight, Timer } from 'lucide-react'; +import { Radio, Search, X, Signal, ArrowUpRight, Timer, Trash2, Ban, Columns2, Bot } from 'lucide-react'; import { cn } from '@/lib/utils'; import { useI18n } from '@/lib/i18n'; import { markerColour, type SpotMarkerKey } from '@/lib/spotMarkers'; +import { writeUiPref } from '@/lib/uiPref'; export type Decode = { call: string; @@ -38,6 +39,12 @@ export type Decode = { // Replayed verbatim when answering the station — see AnswerDecode. ms?: number; low_conf?: boolean; + // The mode field as the Decode carried it (the "~"/"+" marker). `mode` above + // is the resolved name, for display and for the log; a Reply has to send this + // one back or the receiving application finds no matching decode. + mode_raw?: string; + // The message as sent, untrimmed — replayed in a Reply for the same reason. + msg_raw?: string; }; export type TxMsg = { @@ -49,6 +56,9 @@ export type TxMsg = { freq_hz?: number; instance?: string; transmitting?: boolean; + // The sender's Enable Tx toggle. The watchdog clears it while leaving the DX + // call set — the only sign an exchange was abandoned rather than paused. + tx_enabled?: boolean; at: string; }; @@ -62,6 +72,9 @@ type StatusEntry = { new_pota?: boolean; new_pfx?: boolean; new_grid?: boolean; + // "new" = never worked, "unconf" = worked and awaiting a confirmation. + grid_state?: string; + grid?: string; lotw?: boolean; }; @@ -71,9 +84,27 @@ interface Props { // txState is the LIVE transmit state — what is going out right now and to // whom. Separate from txMsgs, which is the history threaded into the periods. txState?: TxMsg | null; + // The same, keyed by instance. In a split view the shared txState is whichever + // receiver reported last, which is a coin toss — each pane needs its own. + txStates?: Record; spotStatus: Record; onCall: (d: Decode) => void; myCall?: string; + // Drop every decode and transmit message held for this panel. The list is a + // live view, not data — clearing it costs nothing but the seconds until the + // next period lands. + // instance = clear just that receiver's decodes; empty = all of them. A split + // view needs the narrow form: clearing both because you wanted one is the same + // loss of context the split exists to prevent. + onClear?: (instance?: string) => void; + // Stop the decoding application transmitting, mid-over. Routed to one + // instance by program id — see HaltDecodeTx. + onHalt?: (instance: string) => void; + // Auto-call on/off, mirrored here as well as in Preferences: it is the one + // setting an operator wants to reach WITHOUT leaving the band — turning the + // machine off is not something to go hunting through a settings tree for. + autoCallOn?: boolean; + onToggleAutoCall?: () => void; } // The "new" categories, as toggle badges — the same idea and the same colours as @@ -113,6 +144,33 @@ function catsOf(e: StatusEntry | undefined): Set { } const CAT_KEY = 'opslog.decodeCats'; +const SPLIT_KEY = 'opslog.decodeSplit'; +const FILTER_KEY = 'opslog.decodeFilters'; + +// usePersisted is useState that survives the panel being unmounted. +// +// All the filters share ONE stored object rather than a key each: they are read +// and written together, and a dozen localStorage entries for one filter bar is a +// dozen things to keep in step when one of them is renamed. +function readFilters(): Record { + try { + const v = JSON.parse(localStorage.getItem(FILTER_KEY) || '{}'); + return v && typeof v === 'object' ? v : {}; + } catch { return {}; } +} +function usePersisted(key: string, fallback: T): [T, (v: T) => void] { + const [v, setV] = useState(() => { + const stored = readFilters()[key]; + return (typeof stored === typeof fallback ? stored as T : fallback); + }); + const set = (next: T) => { + setV(next); + try { + localStorage.setItem(FILTER_KEY, JSON.stringify({ ...readFilters(), [key]: next })); + } catch { /* quota / private mode — the filter still works this session */ } + }; + return [v, set]; +} // DEFAULT_TR is the slot length assumed when nothing better is known. Fifteen // seconds is FT8, the overwhelming majority of what arrives here; a wrong guess @@ -144,15 +202,17 @@ function trSeconds(mode?: string, reported?: number): number { return DEFAULT_TR; } -// ROW is the column template, shared by the header and every row so the two can -// never drift. Full width and left-aligned — an earlier pass centred it inside a -// maximum width, which on a wide screen opened a huge dead margin down the left -// before the first callsign. +// ROW is the grid shell, shared by the header and every row so the two can +// never drift. The column TEMPLATE is no longer baked in: every column has a +// width the operator can drag, so the table takes exactly the room it needs and +// no more. // -// Message is the one elastic column, with a floor so it does not collapse; the -// slack lands there rather than between two fixed columns, which is what read as -// a hole in the middle of every line. -const ROW = 'grid grid-cols-[64px_50px_44px_56px_50px_44px_minmax(240px,1fr)_140px_186px] items-stretch'; +// Message used to be an elastic 1fr column. On a wide screen that handed it +// every spare pixel — a message column hundreds of pixels wider than its longest +// line, with Country and Status marooned against the far edge. Fixed widths +// throughout mean the slack stays OUTSIDE the table, which is where a second +// panel can go. +const ROW = 'grid items-stretch'; // CELL draws the column rule. items-stretch above plus a right border here is // what makes the lines run unbroken from the header to the bottom of the list — @@ -160,6 +220,84 @@ const ROW = 'grid grid-cols-[64px_50px_44px_56px_50px_44px_minmax(240px,1fr)_140 const CELL = 'flex items-center min-w-0 px-2 border-r border-border/30'; const CELL_LAST = 'flex items-center min-w-0 px-2 gap-1 overflow-hidden'; +// ── Columns ────────────────────────────────────────────────────────────────── +// One declaration per column, in display order: the header, the widths and the +// resize handles all read from this, so a column cannot be resized in the header +// and stay the old width in the body. +type ColKey = 'time' | 'snr' | 'dt' | 'freq' | 'band' | 'mode' | 'msg' | 'grid' | 'country' | 'status'; +const COLS: { key: ColKey; tkey: string; def: number; min: number }[] = [ + { key: 'time', tkey: 'dec.colTime', def: 64, min: 44 }, + { key: 'snr', tkey: 'dec.colSnr', def: 50, min: 36 }, + { key: 'dt', tkey: 'dec.colDt', def: 44, min: 32 }, + { key: 'freq', tkey: 'dec.colFreq', def: 56, min: 40 }, + { key: 'band', tkey: 'dec.colBand', def: 50, min: 36 }, + { key: 'mode', tkey: 'dec.colMode', def: 44, min: 36 }, + // 300 px holds the longest real FT8 line ("<3B9/SQ9UM> LZ3BS KN22") with room + // to spare; anything past that was the dead space this replaces. + { key: 'msg', tkey: 'dec.colMsg', def: 300, min: 120 }, + // The grid was carried and shown nowhere: it drives the NEW GRID badge, and + // an operator chasing squares could see the verdict but never the square. + { key: 'grid', tkey: 'dec.colGrid', def: 62, min: 46 }, + { key: 'country', tkey: 'dec.colCountry', def: 140, min: 70 }, + { key: 'status', tkey: 'dec.colStatus', def: 186, min: 80 }, +]; +const COL_MAX = 600; +const COLW_KEY = 'opslog.decodeColWidths'; + +type ColWidths = Record; +const defaultWidths = (): ColWidths => + Object.fromEntries(COLS.map((c) => [c.key, c.def])) as ColWidths; + +// Stored widths are merged ONTO the defaults rather than used as-is: a saved set +// from before a column existed would otherwise leave that column at zero width. +function loadWidths(): ColWidths { + const out = defaultWidths(); + try { + const raw = localStorage.getItem(COLW_KEY); + if (!raw) return out; + const saved = JSON.parse(raw) as Partial>; + for (const c of COLS) { + const v = saved[c.key]; + if (typeof v === 'number' && Number.isFinite(v)) { + out[c.key] = Math.min(COL_MAX, Math.max(c.min, Math.round(v))); + } + } + } catch { /* corrupt value — the defaults are a fine answer */ } + return out; +} + +// The drag handle sitting on a column's right edge. Pointer capture, so a fast +// drag that outruns the cursor still tracks instead of dropping the column. +// Double-click restores that one column's default width. +function ColResizer({ onResize, onReset }: { onResize: (dx: number) => void; onReset: () => void }) { + return ( + { e.stopPropagation(); onReset(); }} + onPointerDown={(e) => { + e.preventDefault(); + e.stopPropagation(); + const startX = e.clientX; + const el = e.currentTarget; + el.setPointerCapture(e.pointerId); + const move = (ev: PointerEvent) => onResize(ev.clientX - startX); + const up = () => { + el.removeEventListener('pointermove', move); + el.removeEventListener('pointerup', up); + }; + el.addEventListener('pointermove', move); + el.addEventListener('pointerup', up); + }} + // Wider than it looks: a 1px target is unusable, so the hit area is 7px + // with only the hairline painted on hover. + className="absolute top-0 right-0 z-10 h-full w-[7px] translate-x-[3px] cursor-col-resize + before:absolute before:inset-y-0 before:left-1/2 before:w-px before:bg-transparent + hover:before:bg-primary" + /> + ); +} + // The "new" badges. Every one of these is a REASON TO CALL, which is why they // get a column of their own rather than a coloured edge: a stripe says something // is special, a badge says what, and the operator is deciding whether to break @@ -305,10 +443,77 @@ function snrTone(snr: number): string { return 'text-muted-foreground/70'; } -export function DecodesPanel({ decodes, txMsgs, txState, spotStatus, onCall, myCall }: Props) { +// buildPeriods cuts a decode list into T/R periods. A plain function, not a +// memo, because it is run ONCE PER PANE: with two receivers on two bands the +// panel shows two independent period lists side by side, and each has to be cut +// with its own slot boundaries. +function buildPeriods(filtered: Decode[], txMsgs: TxMsg[]) { + const by = new Map(); + for (const d of filtered) { + const at = Date.parse(d.at); + if (!Number.isFinite(at)) continue; + const k = periodStartMs(at, trSeconds(d.mode, d.tr_period)); + let g = by.get(k); + if (!g) { g = { decodes: [], tx: [] }; by.set(k, g); } + g.decodes.push(d); + } + for (const m of txMsgs) { + const at = Date.parse(m.at); + if (!Number.isFinite(at)) continue; + const k = periodStartMs(at, trSeconds(m.mode, undefined)); + // A transmit slot CREATES its period when there is none. + // + // This is the whole alternation, and getting it wrong hid the feature + // completely: FT8 transmits and receives in opposite slots, so the period + // you were sending in is exactly the one with no decodes in it. Dropping + // the message when its period was empty meant it never appeared at all. + let g = by.get(k); + if (!g) { g = { decodes: [], tx: [] }; by.set(k, g); } + g.tx.push(m); + } + return [...by.entries()] + .sort((a, b) => b[0] - a[0]) + .map(([start, g]) => ({ + start, + // The slot length this period was cut with, so its heading is labelled + // the same way it was grouped. + tr: trSeconds(g.decodes[0]?.mode ?? g.tx[0]?.mode, g.decodes[0]?.tr_period), + tx: g.tx, + // Strongest first inside a period: the eye should land on what is + // workable, and time within a slot means nothing — they were all + // transmitting simultaneously. + decodes: g.decodes.sort((x, y) => y.snr - x.snr), + })); +} + +export function DecodesPanel({ decodes, txMsgs, txState, txStates, spotStatus, onCall, myCall, onClear, onHalt, autoCallOn, onToggleAutoCall }: Props) { const { t } = useI18n(); - const [cqOnly, setCqOnly] = useState(false); - const [lotwOnly, setLotwOnly] = useState(false); + // Column widths, dragged in the header and shared by every row. Persisted + // through writeUiPref (not raw localStorage) so the layout travels with data/ + // like every other portable preference. + const [colw, setColw] = useState(loadWidths); + const template = useMemo(() => COLS.map((c) => `${colw[c.key]}px`).join(' '), [colw]); + const tableW = useMemo(() => COLS.reduce((s, c) => s + colw[c.key], 0), [colw]); + const setColWidth = (key: ColKey, px: number) => { + const col = COLS.find((c) => c.key === key)!; + const w = Math.min(COL_MAX, Math.max(col.min, Math.round(px))); + setColw((prev) => { + if (prev[key] === w) return prev; + const next = { ...prev, [key]: w }; + writeUiPref(COLW_KEY, JSON.stringify(next)); + return next; + }); + }; + // Split the table into one column per receiver. Off by default: it only means + // anything with two instances running, and a single-receiver operator should + // not have to turn something off to get the layout they had. + const [splitByInstance, setSplitByInstance] = useState(() => localStorage.getItem(SPLIT_KEY) === '1'); + // Every filter below is persisted, NOT just the NEW badges. The panel is + // remounted on a tab change, so anything held only in React state comes back + // cleared — which left the badges lit and the rest silently reset, a list that + // looks filtered and is not. + const [cqOnly, setCqOnly] = usePersisted('cqOnly', false); + const [lotwOnly, setLotwOnly] = usePersisted('lotwOnly', false); const [cats, setCats] = useState>(() => { try { const raw = JSON.parse(localStorage.getItem(CAT_KEY) || '[]'); @@ -321,11 +526,11 @@ export function DecodesPanel({ decodes, txMsgs, txState, spotStatus, onCall, myC try { localStorage.setItem(CAT_KEY, JSON.stringify([...next])); } catch { /* not worth failing over */ } return next; }); - const [bandSel, setBandSel] = useState(''); - const [modeSel, setModeSel] = useState(''); - const [contSel, setContSel] = useState(''); - const [minSnr, setMinSnr] = useState(''); - const [search, setSearch] = useState(''); + const [bandSel, setBandSel] = usePersisted('bandSel', ''); + const [modeSel, setModeSel] = usePersisted('modeSel', ''); + const [contSel, setContSel] = usePersisted('contSel', ''); + const [minSnr, setMinSnr] = usePersisted('minSnr', ''); + const [search, setSearch] = usePersisted('search', ''); const statusOf = (d: Decode): StatusEntry | undefined => spotStatus[`${d.call}|${d.band ?? ''}|${(d.mode ?? '').toUpperCase()}`]; @@ -395,44 +600,27 @@ export function DecodesPanel({ decodes, txMsgs, txState, spotStatus, onCall, myC // Group into periods, newest first, and drop the operator's transmissions into // the slot they went out in. - const groups = useMemo(() => { - const by = new Map(); - for (const d of filtered) { - const at = Date.parse(d.at); - if (!Number.isFinite(at)) continue; - const k = periodStartMs(at, trSeconds(d.mode, d.tr_period)); - let g = by.get(k); - if (!g) { g = { decodes: [], tx: [] }; by.set(k, g); } - g.decodes.push(d); + // One PANE per receiver when the split is on. Two receivers on two bands is + // the day this panel earns its keep, and merging their decodes into one list + // throws away the only thing that tells them apart. + // + // Each pane cuts its own periods: the bands differ, so the slot boundaries and + // the transmit messages belong to one receiver and not the other. + const panes = useMemo(() => { + if (!splitByInstance || instances.length < 2) { + return [{ key: '', label: '', tx: txState ?? undefined, periods: buildPeriods(filtered, txMsgs) }]; } - for (const m of txMsgs) { - const at = Date.parse(m.at); - if (!Number.isFinite(at)) continue; - const k = periodStartMs(at, trSeconds(m.mode, undefined)); - // A transmit slot CREATES its period when there is none. - // - // This is the whole alternation, and getting it wrong hid the feature - // completely: FT8 transmits and receives in opposite slots, so the period - // you were sending in is exactly the one with no decodes in it. Dropping - // the message when its period was empty meant it never appeared at all. - let g = by.get(k); - if (!g) { g = { decodes: [], tx: [] }; by.set(k, g); } - g.tx.push(m); - } - return [...by.entries()] - .sort((a, b) => b[0] - a[0]) - .map(([start, g]) => ({ - start, - // The slot length this period was cut with, so its heading is labelled - // the same way it was grouped. - tr: trSeconds(g.decodes[0]?.mode ?? g.tx[0]?.mode, g.decodes[0]?.tr_period), - tx: g.tx, - // Strongest first inside a period: the eye should land on what is - // workable, and time within a slot means nothing — they were all - // transmitting simultaneously. - decodes: g.decodes.sort((x, y) => y.snr - x.snr), - })); - }, [filtered, txMsgs]); + return instances.map((inst) => ({ + key: inst, + label: inst, + tx: txStates?.[inst], + periods: buildPeriods( + filtered.filter((d) => (d.instance ?? '') === inst), + txMsgs.filter((m) => (m.instance ?? '') === inst), + ), + })); + }, [filtered, txMsgs, splitByInstance, instances, txState, txStates]); + const resetFilters = () => { setCqOnly(false); setLotwOnly(false); setBandSel(''); @@ -467,10 +655,10 @@ export function DecodesPanel({ decodes, txMsgs, txState, spotStatus, onCall, myC - - @@ -545,6 +733,21 @@ export function DecodesPanel({ decodes, txMsgs, txState, spotStatus, onCall, myC {/* Which receivers are feeding this. Only with more than one — with a single MSHV it is a label stating the obvious. */} + {/* Only with two receivers running: with one it would be a control that + does nothing, which is worse than no control. */} + {instances.length > 1 && ( + + )} {instances.length > 1 && ( {t('dec.instances', { n: instances.length })} @@ -553,6 +756,55 @@ export function DecodesPanel({ decodes, txMsgs, txState, spotStatus, onCall, myC {t('dec.count', { shown: filtered.length, total: decodes.length })} + + {/* Halt and Clear sit together at the right, away from the filters: one + talks to the radio, the other only to this list, and neither is a + filter. Halt goes LAST — it is the one that must be findable without + reading, and the end of the row is the one position that never moves + as filters come and go. */} + {onToggleAutoCall && ( + + )} + {onHalt && ( + + )} + {onClear && ( + + )}
{/* ── What I am sending, and to whom ─────────────────────────── */} @@ -560,8 +812,7 @@ export function DecodesPanel({ decodes, txMsgs, txState, spotStatus, onCall, myC Its own strip rather than a line in the list: it is the one thing on this screen that is about the operator and not about the band, and while a period scrolls away this stays put. It appears as soon as a Status - arrives, so it says who is being called even on a sender that never - reports its transmit text. + arrives, so it says who is being called even before anything is sent. */} {txState && (txState.msg || txState.dx_call) && (
} {txState.transmitting ? t('dec.txNow') : t('dec.txIdle')} + {/* An EMPTY tx_message is the ordinary state between overs — WSJT-X, + JTDX and MSHV all send Status about once a second with nothing in + that field when nothing is queued. Reading it as "this application + does not report its transmit text" accused the sender of a + shortcoming on the strength of one empty string, and said so for + most of every cycle. Only a sender that is KEYED and still tells us + nothing has actually withheld anything. */} {txState.msg ? {txState.msg} - : {t('dec.txUnknown')}} + : + {txState.transmitting ? t('dec.txUnknown') : t('dec.txNothing')} + } {txState.dx_call && ( {t('dec.working')} @@ -588,24 +848,83 @@ export function DecodesPanel({ decodes, txMsgs, txState, spotStatus, onCall, myC
)} + {/* One table per receiver when the split is on, side by side. Each pane + carries its OWN column header: they are independent tables at their own + widths, and one shared header row would line up with none of them. */} +
+ {panes.map((pane) => ( +
+ {pane.label && ( +
+ + {pane.label} + + {/* This pane's OWN transmit line. The shared strip shows whichever + instance reported last, which in a split view is a coin toss. */} + {pane.tx?.msg && ( + + {pane.tx.transmitting && ( + + + {t('dec.txNow')} + + )} + {pane.tx.msg} + + )} + + {onHalt && ( + + )} + {onClear && ( + + )} +
+ )} {/* ── Column header ──────────────────────────────────────────── */} -
-
- {t('dec.colTime')} - {t('dec.colSnr')} - {t('dec.colDt')} - {t('dec.colFreq')} - {t('dec.colBand')} - {t('dec.colMode')} - {t('dec.colMsg')} - {t('dec.colCountry')} - {t('dec.colStatus')} +
+
+ {COLS.map((c, i) => ( + + {t(c.tkey)} + setColWidth(c.key, colw[c.key] + dx)} + onReset={() => setColWidth(c.key, c.def)} + /> + + ))}
{/* ── Periods ────────────────────────────────────────────────── */} -
- {groups.length === 0 && ( +
+ {pane.periods.length === 0 && (

{decodes.length === 0 ? t('dec.empty') : t('dec.emptyFiltered')} @@ -613,7 +932,7 @@ export function DecodesPanel({ decodes, txMsgs, txState, spotStatus, onCall, myC

)} - {groups.map((g, gi) => ( + {pane.periods.map((g, gi) => (
{/* Period header — sticky, so the slot being read is always named. */}
@@ -666,7 +985,8 @@ export function DecodesPanel({ decodes, txMsgs, txState, spotStatus, onCall, myC type="button" onClick={() => onCall(d)} title={t('dec.callTitle', { call: d.call })} - className={cn(ROW, 'w-full text-left border-b border-border/20 transition-colors', + style={{ gridTemplateColumns: template, width: tableW }} + className={cn(ROW, 'text-left border-b border-border/20 transition-colors', replying ? 'bg-success/20 hover:bg-success/25' : worked ? 'bg-danger/15 hover:bg-danger/20' : mine ? 'bg-info/10' @@ -716,6 +1036,16 @@ export function DecodesPanel({ decodes, txMsgs, txState, spotStatus, onCall, myC {renderMsg(d.msg ?? '', me, calling)} + {/* The decode's own grid first, the remembered one as the + fallback: this period's message is more current than + whatever was cached from an earlier one. Dimmed when it is + the remembered value, so "heard it now" and "known from + before" are not read as the same thing. */} + + {d.grid || e?.grid || ''} + + {e?.country ?? ''} @@ -737,13 +1067,25 @@ export function DecodesPanel({ decodes, txMsgs, txState, spotStatus, onCall, myC {t(entity.label)} )} - {extras.map((b) => ( - - {t(b.label)} - - ))} + {extras.map((b) => { + // A square WORKED but not yet confirmed is a different job + // from one never worked: a QSL to chase, not a QSO to make. + // Same hue, held back — the badge reads as "less" of the + // same thing, and its label says which. One badge for both + // is what made a station worked an hour ago read as new. + const unconf = b.key === 'new_grid' && e?.grid_state === 'unconf'; + const c = markerColour(b.marker); + return ( + + {unconf ? t('dec.bgGridUnconf') : t(b.label)} + + ); + })} {replying && ( {t('dec.toYou')} @@ -755,6 +1097,9 @@ export function DecodesPanel({ decodes, txMsgs, txState, spotStatus, onCall, myC })}
))} +
+
+ ))}
); diff --git a/frontend/src/components/ExportFieldsDialog.tsx b/frontend/src/components/ExportFieldsDialog.tsx index d74a820..b88fdaf 100644 --- a/frontend/src/components/ExportFieldsDialog.tsx +++ b/frontend/src/components/ExportFieldsDialog.tsx @@ -86,6 +86,13 @@ export function ExportFieldsDialog({ open, count, onExport, onClose }: { return [...m.entries()]; }, [official]); + // Every tag the dialog can offer — the extras AND every group — so "select + // all" means what it says rather than "all the official ones". + const everyTag = useMemo( + () => [...extras, ...groups.flatMap(([, list]) => list.map((d) => d.name))], + [extras, groups], + ); + const toggle = (name: string, on: boolean) => setSel((s) => { const n = new Set(s); if (on) n.add(name); else n.delete(name); return n; }); const setMany = (names: string[], on: boolean) => @@ -114,11 +121,25 @@ export function ExportFieldsDialog({ open, count, onExport, onClose }: { {t('exf.desc')} + {/* Whole-dialog select/clear, next to the count they change. Per-group + links alone meant clearing the selection was one click PER GROUP — + a dozen of them to get to "just the handful I want". */}
{t('exf.chosen', { n: sel.size })} - + + + + +
diff --git a/frontend/src/components/GridSquareMap.tsx b/frontend/src/components/GridSquareMap.tsx new file mode 100644 index 0000000..9121bfe --- /dev/null +++ b/frontend/src/components/GridSquareMap.tsx @@ -0,0 +1,227 @@ +import { useEffect, useMemo, useRef, useState } from 'react'; +import L from 'leaflet'; +import 'leaflet/dist/leaflet.css'; +import { Loader2, RefreshCw } from 'lucide-react'; +import { GridSquares } from '../../wailsjs/go/main/App'; +import { gridSquareBounds, gridToLatLon } from '@/lib/maidenhead'; +import { useI18n } from '@/lib/i18n'; +import { cn } from '@/lib/utils'; +import { BASEMAPS, addBasemap, loadBasemap, type BasemapKey } from '@/components/MainMap'; +import { writeUiPref } from '@/lib/uiPref'; + +// GridSquareMap — every Maidenhead square in the log, drawn on a world map. +// +// A square, not a marker. The question this answers is "where have I been +// heard", and the shape of the answer is an area: a wall of squares across the +// Atlantic and a bare Pacific says something about an antenna that a scatter of +// pins does not. Confirmed and merely worked are two fills of the same hue — +// the distinction is a STATE of one thing, not two categories, so it must not +// be two unrelated colours. +// +// 4 characters, never 6: at world zoom a 6-character square is sub-pixel, and +// aggregating to the big square is also how the count means "contacts in this +// square" rather than "contacts at this exact spot". + +type Square = { grid: string; count: number; confirmed: boolean; band?: string; mode?: string }; + +// The SAME basemaps the Main-tab world map offers, imported rather than copied: +// two lists of tile servers is how one map ends up on a provider the other has +// already been blocked by. This map opened on a hardcoded dark Carto, which is +// the least legible of the four under translucent squares. + +// Leaflet geometry is painted onto a CANVAS, and canvas takes a colour, not a +// stylesheet: "var(--success)" handed to fillStyle is simply invalid and the +// shape is silently not drawn — a map with a correct square count and nothing +// on it. So the token is RESOLVED to its literal value here, once per theme, +// which is also why every other map in this app passes hex. +function cssColour(token: string, fallback: string): string { + try { + const v = getComputedStyle(document.documentElement).getPropertyValue(token).trim(); + return v || fallback; + } catch { return fallback; } +} + +// Mode scope. Two, because the map lives beside a panel that decodes FTx: CW, +// phone and "everything" answer a question nobody is asking here, and a row of +// choices that are never the right one is just noise to read past. +// +// Digital is every digital mode; FTx is the FT family alone, which is the +// narrower and usually the honest one — a square worked on RTTY in a contest is +// not a square worked on FT8. +const SCOPES = [ + { key: 'DIGI', label: 'gsm.digital' }, + { key: 'FTX', label: 'gsm.ftx' }, +] as const; +type ScopeKey = typeof SCOPES[number]['key']; + +const SCOPE_KEY = 'opslog.gridMapScope'; + +export function GridSquareMap({ myGrid, className }: { myGrid?: string; className?: string }) { + const { t } = useI18n(); + const hostRef = useRef(null); + const mapRef = useRef(null); + const layerRef = useRef(null); + const [squares, setSquares] = useState(null); + const [busy, setBusy] = useState(false); + const [err, setErr] = useState(''); + const [scope, setScope] = useState( + () => (SCOPES.some((s) => s.key === localStorage.getItem(SCOPE_KEY)) + ? (localStorage.getItem(SCOPE_KEY) as ScopeKey) : 'DIGI')); + + const [basemap, setBasemap] = useState(loadBasemap); + // Repaint the squares when the THEME changes, not the basemap: the fills come + // from theme tokens resolved at draw time, so a theme switch leaves them on + // the old palette until something forces a redraw. + const [themeTick, setThemeTick] = useState(0); + useEffect(() => { + const obs = new MutationObserver(() => setThemeTick((n) => n + 1)); + obs.observe(document.documentElement, { attributes: true, attributeFilter: ['data-theme'] }); + return () => obs.disconnect(); + }, []); + + const load = async (sc: ScopeKey = scope) => { + setBusy(true); setErr(''); + try { + const r = (await GridSquares(sc)) as any; + setSquares((Array.isArray(r) ? r : []) as Square[]); + } catch (e: any) { + setErr(String(e?.message ?? e)); + setSquares([]); + } finally { setBusy(false); } + }; + useEffect(() => { void load(scope); /* eslint-disable-next-line react-hooks/exhaustive-deps */ }, [scope]); + + // One-time map creation. preferCanvas: a busy digital log is a few thousand + // rectangles, and as SVG that is a few thousand DOM nodes to lay out on every + // pan. + useEffect(() => { + if (!hostRef.current || mapRef.current) return; + const m = L.map(hostRef.current, { + preferCanvas: true, + zoomControl: true, + attributionControl: true, + worldCopyJump: true, + minZoom: 1, + }).setView([25, 0], 2); + mapRef.current = m; + layerRef.current = L.layerGroup().addTo(m); + return () => { m.remove(); mapRef.current = null; layerRef.current = null; }; + }, []); + + // The chosen basemap, shared with the Main-tab map so picking one there and + // finding another here cannot happen. + const baseRef = useRef(null); + const labelsRef = useRef(null); + useEffect(() => { + const m = mapRef.current; + if (!m) return; + addBasemap(m, basemap, baseRef, labelsRef); + baseRef.current?.bringToBack(); + }, [basemap]); + + // Redraw the squares. + useEffect(() => { + const layer = layerRef.current; + if (!layer) return; + layer.clearLayers(); + // Resolved once for the whole redraw, not per square: getComputedStyle + // forces a style flush, and doing that a thousand times is a visible stall. + const confirmedColour = cssColour('--success', '#16a34a'); + const workedColour = cssColour('--chart-1', '#2a78d6'); + const meColour = cssColour('--warning', '#f59e0b'); + for (const sq of squares ?? []) { + const b = gridSquareBounds(sq.grid); + if (!b) continue; + // One hue, two states. Confirmed is the solid, saturated one; worked is + // the same colour held back — so the eye reads "more" and "less" of the + // same thing rather than two unrelated facts. + const colour = sq.confirmed ? confirmedColour : workedColour; + L.rectangle([[b.south, b.west], [b.north, b.east]], { + color: colour, + weight: 0.5, + opacity: sq.confirmed ? 0.9 : 0.5, + fillColor: colour, + fillOpacity: sq.confirmed ? 0.55 : 0.22, + }) + .bindTooltip( + `${sq.grid} — ${sq.count} QSO${sq.count > 1 ? 's' : ''}` + + `${sq.band ? ` · ${sq.band}` : ''}${sq.mode ? ` ${sq.mode}` : ''}` + + `${sq.confirmed ? ` · ${t('gsm.confirmed')}` : ''}`, + { sticky: true }, + ) + .addTo(layer); + } + // The operator's own square, so the pattern has an origin to be read from. + const me = myGrid ? gridToLatLon(myGrid) : null; + if (me) { + L.circleMarker([me.lat, me.lon], { + radius: 4, color: meColour, weight: 2, + fillColor: meColour, fillOpacity: 1, + }).bindTooltip(myGrid!.toUpperCase(), { sticky: true }).addTo(layer); + } + }, [squares, myGrid, t, themeTick]); + + const stats = useMemo(() => { + const list = squares ?? []; + return { total: list.length, confirmed: list.filter((s) => s.confirmed).length }; + }, [squares]); + + return ( + // isolate is load-bearing, not tidiness. Leaflet puts its panes at z-index + // 400 and its zoom control at 1000, in the PAGE's stacking context — and the + // modals here are z-50. Without a stacking context of its own the map floats + // over Preferences and hides the Save and Close buttons. isolation:isolate + // confines every z-index Leaflet sets to this element. +
+
+ + {t('gsm.title')} + +
+ {SCOPES.map((s, i) => ( + + ))} +
+ + {t('gsm.count', { n: stats.total, c: stats.confirmed })} + + + + +
+ {err &&

{err}

} + {/* The map host must have a real height or Leaflet renders nothing at all + — flex-1 + min-h-0, never a percentage. */} +
+
+ + + {t('gsm.confirmed')} + + + + {t('gsm.worked')} + +
+
+ ); +} diff --git a/frontend/src/components/MainMap.tsx b/frontend/src/components/MainMap.tsx index 98ef11f..02ffb7c 100644 --- a/frontend/src/components/MainMap.tsx +++ b/frontend/src/components/MainMap.tsx @@ -61,8 +61,8 @@ const ESRI_STREET_ATTR = 'Tiles © Esri — Source: Esri, HERE, Garmin, &cop // Selectable basemaps for the world (great-circle) map. All key-free and all // LABELLED (country/continent names). `labelsUrl` adds a transparent place-name // overlay on top of an imagery basemap (so satellite keeps its names too). -type BasemapKey = 'light' | 'voyager' | 'street' | 'satellite'; -const BASEMAPS: Record = { +export type BasemapKey = 'light' | 'voyager' | 'street' | 'satellite'; +export const BASEMAPS: Record = { light: { label: 'Light', url: CARTO_LIGHT, attr: CARTO_ATTR, subdomains: 'abcd' }, voyager: { label: 'Voyager', url: 'https://{s}.basemaps.cartocdn.com/rastertiles/voyager/{z}/{x}/{y}{r}.png', attr: CARTO_ATTR, subdomains: 'abcd' }, @@ -71,7 +71,7 @@ const BASEMAPS: Record, diff --git a/frontend/src/components/QSLManagerModal.tsx b/frontend/src/components/QSLManagerModal.tsx index 95130b6..2e45aef 100644 --- a/frontend/src/components/QSLManagerModal.tsx +++ b/frontend/src/components/QSLManagerModal.tsx @@ -111,7 +111,33 @@ export function fmtQslDate(s?: string): string { // QSL Manager as an in-app tab panel: upload logged QSOs to online logbooks // and download confirmations, while the rest of the app stays usable. -export function QSLManagerPanel({ onEditQSO }: { onEditQSO?: (id: number) => void } = {}) { +// GridActions are the row actions the context menu offers, forwarded straight to +// whichever grid this panel is showing. +// +// The FILTERED exports are deliberately absent. "Export everything the filter +// matches" means the Recent-QSOs filter, and the rows here come from a different +// query entirely — offering it would export something other than what is on the +// screen, which is the one thing an export must never do. Selection-based +// exports have no such ambiguity: the ids are the rows you ticked. +export type GridActions = { + onUpdateFromCty?: (ids: number[]) => void; + onUpdateFromQRZ?: (ids: number[]) => void; + onUpdateFromClublog?: (ids: number[]) => void; + onUpdateCountyFromULS?: (ids: number[]) => void; + onSendTo?: (service: string, ids: number[]) => void; + onSendRecording?: (ids: number[]) => void; + onSendEQSL?: (ids: number[]) => void; + onBulkEdit?: (ids: number[]) => void; + onExportSelected?: (ids: number[]) => void; + onExportSelectedFields?: (ids: number[]) => void; + onExportCabrilloSelected?: (ids: number[]) => void; + onDelete?: (ids: number[]) => void; +}; + +export function QSLManagerPanel({ onEditQSO, actions }: { + onEditQSO?: (id: number) => void; + actions?: GridActions; +} = {}) { const { t } = useI18n(); const [service, setService] = useState('lotw'); // The callsign this profile signs/uploads/downloads as for the selected @@ -443,6 +469,8 @@ export function QSLManagerPanel({ onEditQSO }: { onEditQSO?: (id: number) => voi total={paperRows.length} selectAllSignal={paperSelAllSig} onRowSelected={(ids) => setPaperSel(new Set(ids))} + {...actions} + onRowDoubleClicked={onEditQSO ? (q) => onEditQSO(q.id as number) : undefined} />
) @@ -549,6 +577,8 @@ export function QSLManagerPanel({ onEditQSO }: { onEditQSO?: (id: number) => voi total={rows.length} selectAllSignal={uploadSelAllSig} onRowSelected={onUploadRowSelected} + {...actions} + onRowDoubleClicked={onEditQSO ? (q) => onEditQSO(q.id as number) : undefined} />
)} diff --git a/frontend/src/components/QSOContextMenu.tsx b/frontend/src/components/QSOContextMenu.tsx index bcc6de7..993b6bc 100644 --- a/frontend/src/components/QSOContextMenu.tsx +++ b/frontend/src/components/QSOContextMenu.tsx @@ -7,8 +7,8 @@ export type QSOMenuState = { x: number; y: number; ids: number[] } | null; type Props = { menu: QSOMenuState; onClose: () => void; - onUpdateFromCty: (ids: number[]) => void; - onUpdateFromQRZ: (ids: number[]) => void; + onUpdateFromCty?: (ids: number[]) => void; + onUpdateFromQRZ?: (ids: number[]) => void; onUpdateFromClublog?: (ids: number[]) => void; // Only passed once the offline US county database has been downloaded — // an entry that can only ever answer "no database" is not worth a line here. @@ -98,20 +98,28 @@ export function QSOContextMenu({ menu, onClose, onUpdateFromCty, onUpdateFromQRZ
{t('qctx.selected', { n })}
- - + {/* Conditional like every other entry. These two were drawn + unconditionally, and the grid passes them through an arrow that calls + an optional handler — so in a grid that wires neither (the QSL + Manager) both appeared and did precisely nothing when clicked. */} + {onUpdateFromCty && ( + + )} + {onUpdateFromQRZ && ( + + )} {onUpdateFromClublog && (
+ {/* Every handler is passed STRAIGHT through, never wrapped in an arrow: a + wrapper is always truthy, so the menu drew "Fix country" and "Update + from the callsign databases" even in a grid that wired neither — and + clicking them did nothing at all. */} setMenu(null)} - onUpdateFromCty={(ids) => onUpdateFromCty?.(ids)} - onUpdateFromQRZ={(ids) => onUpdateFromQRZ?.(ids)} + onUpdateFromCty={onUpdateFromCty} + onUpdateFromQRZ={onUpdateFromQRZ} onUpdateFromClublog={onUpdateFromClublog} onUpdateCountyFromULS={onUpdateCountyFromULS} onSendTo={onSendTo} @@ -738,6 +756,16 @@ export function RecentQSOsGrid({ rows, myGrid, selectAllSignal, selectRowSignal, {t('rqg.pickerDesc')} + {/* Whole-dialog controls. The per-group links alone meant hiding + everything was one click PER GROUP, and there are a dozen. */} +
+ {t('rqg.pickerAllGroups')} + + · + +
{GROUP_ORDER.map((group) => { const cols = COL_CATALOG.filter((c) => c.group === group); diff --git a/frontend/src/components/SettingsModal.tsx b/frontend/src/components/SettingsModal.tsx index c414b7c..2681946 100644 --- a/frontend/src/components/SettingsModal.tsx +++ b/frontend/src/components/SettingsModal.tsx @@ -55,7 +55,7 @@ import { GetFolderSync, SaveFolderSync, PickFolderSyncFolder, GetFolderSyncStatus, SyncFolderNow, GetRelayAuto, SaveRelayAuto, GetStationDevices, GetAwardDefs, GetTrackedAwards, SaveTrackedAwards, - GetBandOpenSettings, SaveBandOpenSettings, GetPSKReporterStatus, GetChaseNewGrids, SetChaseNewGrids, GetChaseNew, SetChaseNew, GetGridCacheStatus, GetLinkedAmps, SetLinkedAmps, GetSpotTTLMinutes, SetSpotTTLMinutes, + GetBandOpenSettings, SaveBandOpenSettings, GetGridScopeSettings, SaveGridScopeSettings, GetPSKReporterStatus, GetChaseNewGrids, SetChaseNewGrids, GetChaseNew, SetChaseNew, GetGridCacheStatus, GetLinkedAmps, SetLinkedAmps, GetSpotTTLMinutes, SetSpotTTLMinutes, } from '../../wailsjs/go/main/App'; import type { profile as profileModels } from '../../wailsjs/go/models'; import type { LookupSettingsForm, StationSettingsForm, ListsSettingsForm, ModePresetForm } from '@/types'; @@ -76,6 +76,7 @@ import { } from '@/components/ui/select'; import { cn } from '@/lib/utils'; import { writeUiPref } from '@/lib/uiPref'; +import { loadAutoCall, autoCallKey, type AutoCallSettings, type AutoCallCriteria } from '@/lib/autocall'; import { getDateFormat, setDateFormat, type DateFormat } from '@/lib/dateFormat'; import { useI18n, FlagGB, FlagFR, type Lang } from '@/lib/i18n'; import { useTheme, CONCRETE_THEMES, type ThemeChoice } from '@/lib/theme'; @@ -202,6 +203,7 @@ type SectionId = | 'uscounties' | 'awards' | 'cat' + | 'ftx' | 'rotator' | 'winkeyer' | 'antenna' @@ -306,6 +308,7 @@ function buildTree(flexAvailable: boolean, t: (k: string) => string): TreeNode[] { kind: 'item', label: t('sec.modes'), id: 'lists-modes' }, ]}, { kind: 'item', label: t('sec.cluster'), id: 'cluster' }, + { kind: 'item', label: t('sec.ftx'), id: 'ftx' }, { kind: 'item', label: t('sec.udp'), id: 'udp' }, { kind: 'item', label: t('sec.adifmon'), id: 'adifmon' }, { kind: 'item', label: t('sec.foldersync'), id: 'foldersync' }, @@ -325,7 +328,7 @@ function buildTree(flexAvailable: boolean, t: (k: string) => string): TreeNode[] const SECTION_KEY: Partial> = { station: 'sec.station', profiles: 'sec.profiles', operating: 'sec.operating', confirmations: 'sec.confirmations', 'external-services': 'sec.external', appearance: 'sec.appearance', lookup: 'sec.lookup', 'lists-bands': 'sec.bands', 'lists-modes': 'sec.modes', - cluster: 'sec.cluster', backup: 'sec.backup', database: 'sec.database', autostart: 'sec.autostart', udp: 'sec.udp', + cluster: 'sec.cluster', ftx: 'sec.ftx', backup: 'sec.backup', database: 'sec.database', autostart: 'sec.autostart', udp: 'sec.udp', adifmon: 'sec.adifmon', foldersync: 'sec.foldersync', webpublish: 'sec.webpublish', @@ -1519,6 +1522,10 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan const [autofocusWB, setAutofocusWB] = useState(() => localStorage.getItem('opslog.autofocusWB') !== '0'); const [checkUpdates, setCheckUpdates] = useState(() => localStorage.getItem('opslog.checkUpdates') !== '0'); const [showBeamMap, setShowBeamMap] = useState(() => localStorage.getItem('opslog.showBeamOnMap') !== '0'); + // Compact rotor widget: the dial and the SP/LP readout only. Off by default — + // the full widget is what the operator has today, and a setting that changes + // a panel the moment you upgrade is a setting that gets blamed for it. + const [rotorCompact, setRotorCompact] = useState(() => localStorage.getItem('opslog.rotorCompact') === '1'); const [startEqEnd, setStartEqEnd] = useState(() => localStorage.getItem('opslog.startEqualsEnd') === '1'); const [lookupOnBlur, setLookupOnBlur] = useState(() => localStorage.getItem('opslog.lookupOnBlur') === '1'); const [groupDigital, setGroupDigital] = useState(() => localStorage.getItem('opslog.groupDigitalSlots') === '1'); @@ -1724,6 +1731,14 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan // has side effects there — adding the RBN nodes, bringing the PSK Reporter // feed up or down — so the write has to go where those live. const [bandOpen, setBandOpen] = useState({ enabled: false, bands: [], available: [] }); + // How a worked square is matched, and what counts as still wanted. + const [autoCall, setAutoCall] = useState(loadAutoCall); + const [gridScope, setGridScope] = useState({ scope: 'mix_digi', hunt: 'new', scopes: [] }); + useEffect(() => { GetGridScopeSettings().then((g) => setGridScope(g as any)).catch(() => {}); }, []); + const saveGridScope = async (next: any) => { + setGridScope(next); + try { await SaveGridScopeSettings(next); } catch { /* the panel keeps the choice either way */ } + }; const [chaseGrids, setChaseGrids] = useState(false); const [chaseNew, setChaseNew] = useState(false); const [spotTTL, setSpotTTL] = useState(0); @@ -4180,10 +4195,25 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
)} + {/* How much of the rotor widget to draw. Compact keeps the dial and the + SP/LP azimuths and drops the controls — for an operator who turns + the antenna from the bearing pill or from PstRotator and wants the + dial to take a column, not a panel. */} +
+
{t('rot.widget')}
+ +

{t('rot.compactHint')}

+
+ {/* Quick-turn buttons for the rotor widget. Their azimuths start out computed from the station square, so they are right for THIS QTH - rather than copied from someone else's. */} -
+ rather than copied from someone else's. Hidden in compact mode — + editing buttons that are not drawn is a trap. */} +
{t('rot.presets')}

{t('rot.presetsHint')}

@@ -4560,6 +4590,91 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan setEditingServer(next); } + // FTx decodes: what OpsLog does on its own with the digital stream. + // + // Auto-call KEYS THE TRANSMITTER without anyone clicking, so the panel is + // deliberately explicit about it: off by default, every criterion opt-in, and + // a plain statement of what the machine will do once it is on. + function FtxPanel() { + const set = (patch: Partial) => { + const next = { ...autoCall, ...patch }; + setAutoCall(next); + writeUiPref(autoCallKey, JSON.stringify(next)); + }; + const crit = (which: 'criteria' | 'watchCriteria', k: keyof AutoCallCriteria) => ( + + ); + const KEYS: (keyof AutoCallCriteria)[] = ['dxcc', 'band', 'mode', 'slot', 'grid', 'county', 'pota', 'pfx']; + return ( + <> + +
+
+ + + {autoCall.enabled && ( +
+
+

{t('ftx.callWhen')}

+
{KEYS.map((k) => crit('criteria', k))}
+
+ +
+

{t('ftx.watch')}

+

{t('ftx.watchHint')}

+