chore: release v0.26.0
This commit is contained in:
+233
-16
@@ -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<TxMsgRow | null>(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<Record<string, TxMsgRow>>({});
|
||||
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<AutoCallSettings>(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<Map<string, number>>(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<Set<string>>(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<Map<string, number>>(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<DecodeRow[]>([]);
|
||||
@@ -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() {
|
||||
</div>
|
||||
)}
|
||||
{/* 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) && (
|
||||
<div className="w-[320px] shrink-0 min-h-0">
|
||||
<div className={cn('shrink-0 min-h-0', rotorCompact ? 'w-[196px]' : 'w-[320px]')}>
|
||||
<RotorCompass
|
||||
presets={rotorPresets}
|
||||
onStop={() => { 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() {
|
||||
</span>
|
||||
</TabsTrigger>
|
||||
)}
|
||||
{gridsTabOpen && (
|
||||
<TabsTrigger value="grids" className="gap-1.5">
|
||||
{t('gsm.title')}
|
||||
<span
|
||||
role="button"
|
||||
aria-label="Close grid squares"
|
||||
title="Close"
|
||||
className="inline-flex items-center justify-center size-4 rounded hover:bg-foreground/10 text-muted-foreground hover:text-foreground"
|
||||
onPointerDown={(e) => { e.stopPropagation(); }}
|
||||
onClick={(e) => { e.stopPropagation(); closeGridsTab(); }}
|
||||
>
|
||||
<X className="size-3" />
|
||||
</span>
|
||||
</TabsTrigger>
|
||||
)}
|
||||
{decodesTabOpen && (
|
||||
<TabsTrigger value="decodes" className="gap-1.5">
|
||||
{t('dec.tab')}
|
||||
@@ -6832,7 +7023,8 @@ export default function App() {
|
||||
<div className="relative flex-1">
|
||||
<Input
|
||||
className="w-full pr-8 font-mono"
|
||||
placeholder="Search callsign…"
|
||||
placeholder={t('rq.searchPh')}
|
||||
title={t('rq.searchTip')}
|
||||
value={filterCallsign}
|
||||
onChange={(e) => setFilterCallsign(e.target.value.toUpperCase())}
|
||||
/>
|
||||
@@ -7201,7 +7393,26 @@ export default function App() {
|
||||
updating) while you work on other tabs. */}
|
||||
{qslTabOpen && (
|
||||
<TabsContent value="qsl" forceMount className="mt-0 flex flex-col min-h-0 flex-1 data-[state=inactive]:hidden">
|
||||
<QSLManagerPanel onEditQSO={openEdit} />
|
||||
<QSLManagerPanel
|
||||
onEditQSO={openEdit}
|
||||
// The same row actions the Recent QSOs grid offers. Only the
|
||||
// selection-based exports: exporting "the filter" would mean
|
||||
// the Recent-QSOs filter, not the rows shown here.
|
||||
actions={{
|
||||
onUpdateFromCty: bulkUpdateFromCty,
|
||||
onUpdateFromQRZ: bulkUpdateFromQRZ,
|
||||
onUpdateFromClublog: bulkUpdateFromClublog,
|
||||
onUpdateCountyFromULS: ulsReady ? bulkUpdateCountyFromULS : undefined,
|
||||
onSendTo: bulkSendTo,
|
||||
onSendRecording: bulkSendRecording,
|
||||
onSendEQSL: (ids) => setEqslQsoId(ids[0] ?? null),
|
||||
onBulkEdit: openBulkEdit,
|
||||
onExportSelected: exportSelectedADIF,
|
||||
onExportSelectedFields: exportSelectedFields,
|
||||
onExportCabrilloSelected: exportSelectedCabrillo,
|
||||
onDelete: (ids) => setDeletingIds(ids),
|
||||
}}
|
||||
/>
|
||||
</TabsContent>
|
||||
)}
|
||||
|
||||
@@ -7240,6 +7451,12 @@ export default function App() {
|
||||
</TabsContent>
|
||||
)}
|
||||
|
||||
{gridsTabOpen && (
|
||||
<TabsContent value="grids" className="mt-0 flex flex-col min-h-0 flex-1 data-[state=inactive]:hidden">
|
||||
<GridSquareMap myGrid={station.my_grid} className="flex-1 min-h-0" />
|
||||
</TabsContent>
|
||||
)}
|
||||
|
||||
{decodesTabOpen && (
|
||||
<TabsContent value="decodes" className="mt-0 flex flex-col min-h-0 flex-1 data-[state=inactive]:hidden">
|
||||
{renderDecodesPanel()}
|
||||
|
||||
@@ -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 <span style={{ color: 'var(--muted-foreground)', fontSize: 10 }}>—</span>;
|
||||
return (
|
||||
<span style={{ whiteSpace: 'nowrap' }}>
|
||||
{parts.map((pt, i) => (
|
||||
<span key={i} style={{ color: pt.color, fontWeight: 700 }}>
|
||||
<span key={i} style={{ color: pt.color, fontWeight: 700, opacity: pt.dim ? 0.5 : 1 }}>
|
||||
{i > 0 ? ' · ' : ''}{pt.text}
|
||||
</span>
|
||||
))}
|
||||
@@ -638,6 +646,17 @@ export function ClusterGrid({ rows, spotStatus, onSpotClick }: Props) {
|
||||
{t('clg2.pickerDesc')}
|
||||
</DialogDescription>
|
||||
</DialogHeader>
|
||||
{/* 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. */}
|
||||
<div className="flex items-center gap-1 px-1 text-[11px] text-muted-foreground">
|
||||
<span>{t('clg2.allGroups')}</span>
|
||||
<button type="button" className="text-[11px] text-primary hover:underline px-1"
|
||||
onClick={() => showAll()}>{t('clg2.all')}</button>
|
||||
<span className="opacity-40">·</span>
|
||||
<button type="button" className="text-[11px] text-muted-foreground hover:underline px-1"
|
||||
onClick={() => hideAll()}>{t('clg2.none')}</button>
|
||||
</div>
|
||||
<div className="max-h-[60vh] overflow-y-auto py-2">
|
||||
{GROUP_ORDER.map((group) => {
|
||||
const cols = COL_CATALOG.filter((c) => c.group === group);
|
||||
|
||||
@@ -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<string, TxMsg>;
|
||||
spotStatus: Record<string, StatusEntry>;
|
||||
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<NewCat> {
|
||||
}
|
||||
|
||||
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<string, unknown> {
|
||||
try {
|
||||
const v = JSON.parse(localStorage.getItem(FILTER_KEY) || '{}');
|
||||
return v && typeof v === 'object' ? v : {};
|
||||
} catch { return {}; }
|
||||
}
|
||||
function usePersisted<T>(key: string, fallback: T): [T, (v: T) => void] {
|
||||
const [v, setV] = useState<T>(() => {
|
||||
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<ColKey, number>;
|
||||
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<Record<ColKey, unknown>>;
|
||||
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 (
|
||||
<span
|
||||
role="separator"
|
||||
aria-orientation="vertical"
|
||||
onDoubleClick={(e) => { 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<number, { decodes: Decode[]; tx: TxMsg[] }>();
|
||||
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<ColWidths>(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<Set<NewCat>>(() => {
|
||||
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<number, { decodes: Decode[]; tx: TxMsg[] }>();
|
||||
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
|
||||
<PeriodClock trSec={liveTr} mode={liveMode} />
|
||||
<span className="w-px h-5 bg-border/60 mx-1" />
|
||||
|
||||
<button type="button" className={chip(cqOnly, 'success')} onClick={() => setCqOnly((v) => !v)}>
|
||||
<button type="button" className={chip(cqOnly, 'success')} onClick={() => setCqOnly(!cqOnly)}>
|
||||
{t('dec.cqOnly')}
|
||||
</button>
|
||||
<button type="button" className={chip(lotwOnly)} onClick={() => setLotwOnly((v) => !v)}>
|
||||
<button type="button" className={chip(lotwOnly)} onClick={() => setLotwOnly(!lotwOnly)}>
|
||||
{t('dec.lotwOnly')}
|
||||
</button>
|
||||
|
||||
@@ -545,6 +733,21 @@ export function DecodesPanel({ decodes, txMsgs, txState, spotStatus, onCall, myC
|
||||
<span className="flex-1" />
|
||||
{/* 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 && (
|
||||
<button
|
||||
type="button"
|
||||
onClick={() => setSplitByInstance((v) => { try { localStorage.setItem(SPLIT_KEY, v ? '0' : '1'); } catch { /* quota */ } return !v; })}
|
||||
title={t('dec.splitTip')}
|
||||
className={cn('h-8 px-2.5 rounded-lg text-sm inline-flex items-center gap-1.5 border',
|
||||
splitByInstance
|
||||
? 'border-primary bg-primary text-primary-foreground'
|
||||
: 'border-border text-muted-foreground hover:bg-muted hover:text-foreground')}
|
||||
>
|
||||
<Columns2 className="size-3.5" /> {t('dec.split')}
|
||||
</button>
|
||||
)}
|
||||
{instances.length > 1 && (
|
||||
<span className="text-xs text-muted-foreground">
|
||||
{t('dec.instances', { n: instances.length })}
|
||||
@@ -553,6 +756,55 @@ export function DecodesPanel({ decodes, txMsgs, txState, spotStatus, onCall, myC
|
||||
<span className="text-sm text-muted-foreground tabular-nums">
|
||||
{t('dec.count', { shown: filtered.length, total: decodes.length })}
|
||||
</span>
|
||||
|
||||
{/* 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 && (
|
||||
<button
|
||||
type="button"
|
||||
onClick={onToggleAutoCall}
|
||||
title={t('dec.autoCallTip')}
|
||||
className={cn('h-8 px-2.5 rounded-lg text-sm inline-flex items-center gap-1.5 border',
|
||||
// Lit when it is armed, because what matters at a glance is not
|
||||
// "where is the switch" but "is this thing about to transmit".
|
||||
autoCallOn
|
||||
? 'border-warning bg-warning text-warning-foreground'
|
||||
: 'border-border text-muted-foreground hover:bg-muted hover:text-foreground')}
|
||||
>
|
||||
<Bot className="size-3.5" /> {t('dec.autoCall')}
|
||||
</button>
|
||||
)}
|
||||
{onHalt && (
|
||||
<button
|
||||
type="button"
|
||||
onClick={() => onHalt(txState?.instance ?? '')}
|
||||
title={t('dec.haltTitle')}
|
||||
className={cn('h-8 px-2.5 rounded-lg text-sm inline-flex items-center gap-1.5 border',
|
||||
// Hot while the carrier is actually up: that is when the button is
|
||||
// urgent, and an always-red control stops being read as a warning.
|
||||
txState?.transmitting
|
||||
? 'border-danger bg-danger text-danger-foreground hover:brightness-110'
|
||||
: 'border-border text-muted-foreground hover:bg-muted hover:text-foreground')}
|
||||
>
|
||||
<Ban className="size-3.5" /> {t('dec.halt')}
|
||||
</button>
|
||||
)}
|
||||
{onClear && (
|
||||
<button
|
||||
type="button"
|
||||
onClick={() => onClear()}
|
||||
disabled={decodes.length === 0 && txMsgs.length === 0}
|
||||
title={t('dec.clearAllTitle')}
|
||||
className="h-8 px-2.5 rounded-lg text-sm text-muted-foreground border border-border
|
||||
hover:bg-muted hover:text-foreground inline-flex items-center gap-1.5
|
||||
disabled:opacity-40 disabled:pointer-events-none"
|
||||
>
|
||||
<Trash2 className="size-3.5" /> {t('dec.clearAll')}
|
||||
</button>
|
||||
)}
|
||||
</div>
|
||||
|
||||
{/* ── 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) && (
|
||||
<div className={cn('flex items-center gap-3 px-3 py-2 shrink-0 border-b',
|
||||
@@ -571,9 +822,18 @@ export function DecodesPanel({ decodes, txMsgs, txState, spotStatus, onCall, myC
|
||||
{txState.transmitting && <span className="size-2 rounded-full bg-primary animate-pulse" />}
|
||||
{txState.transmitting ? t('dec.txNow') : t('dec.txIdle')}
|
||||
</span>
|
||||
{/* 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
|
||||
? <span className="font-mono text-base font-semibold text-foreground truncate">{txState.msg}</span>
|
||||
: <span className="text-sm text-muted-foreground italic">{t('dec.txUnknown')}</span>}
|
||||
: <span className="text-sm text-muted-foreground italic">
|
||||
{txState.transmitting ? t('dec.txUnknown') : t('dec.txNothing')}
|
||||
</span>}
|
||||
{txState.dx_call && (
|
||||
<span className="flex items-center gap-1.5 shrink-0">
|
||||
<span className="text-xs text-muted-foreground uppercase tracking-wider">{t('dec.working')}</span>
|
||||
@@ -588,24 +848,83 @@ export function DecodesPanel({ decodes, txMsgs, txState, spotStatus, onCall, myC
|
||||
</div>
|
||||
)}
|
||||
|
||||
{/* 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. */}
|
||||
<div className="flex-1 min-h-0 flex gap-px bg-border/40">
|
||||
{panes.map((pane) => (
|
||||
<div key={pane.key}
|
||||
className={cn('flex-1 min-w-0 flex flex-col min-h-0 bg-card',
|
||||
pane.tx?.transmitting && 'ring-2 ring-primary ring-inset')}>
|
||||
{pane.label && (
|
||||
<div className={cn('shrink-0 flex items-center gap-1.5 px-2 py-1 border-b border-border',
|
||||
pane.tx?.transmitting ? 'bg-primary/15 border-primary/40' : 'bg-muted/40')}>
|
||||
<span className="text-[10px] font-semibold uppercase tracking-wider text-muted-foreground truncate">
|
||||
{pane.label}
|
||||
</span>
|
||||
{/* 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 && (
|
||||
<span className={cn('font-mono text-[11px] truncate',
|
||||
pane.tx.transmitting ? 'text-primary font-semibold' : 'text-muted-foreground')}>
|
||||
{pane.tx.transmitting && (
|
||||
<span className="inline-flex items-center gap-1 mr-1.5 font-sans font-bold uppercase tracking-wider">
|
||||
<span className="inline-block size-1.5 rounded-full bg-primary animate-pulse" />
|
||||
{t('dec.txNow')}
|
||||
</span>
|
||||
)}
|
||||
{pane.tx.msg}
|
||||
</span>
|
||||
)}
|
||||
<span className="flex-1" />
|
||||
{onHalt && (
|
||||
<button type="button"
|
||||
onClick={() => onHalt(pane.key)}
|
||||
title={t('dec.haltOne', { n: pane.label })}
|
||||
className={cn('h-6 px-1.5 rounded text-[11px] inline-flex items-center gap-1 border',
|
||||
pane.tx?.transmitting
|
||||
? 'border-danger bg-danger text-danger-foreground'
|
||||
: 'border-border text-muted-foreground hover:bg-muted hover:text-foreground')}>
|
||||
<Ban className="size-3" /> {t('dec.halt')}
|
||||
</button>
|
||||
)}
|
||||
{onClear && (
|
||||
<button type="button"
|
||||
onClick={() => onClear(pane.key)}
|
||||
title={t('dec.clearOne', { n: pane.label })}
|
||||
className="h-6 px-1.5 rounded text-[11px] inline-flex items-center gap-1 border border-border text-muted-foreground hover:bg-muted hover:text-foreground">
|
||||
<Trash2 className="size-3" />
|
||||
</button>
|
||||
)}
|
||||
</div>
|
||||
)}
|
||||
{/* ── Column header ──────────────────────────────────────────── */}
|
||||
<div className="shrink-0 border-b border-border bg-background">
|
||||
<div className={cn(ROW, 'h-7 text-[10px] font-semibold uppercase tracking-wider text-muted-foreground')}>
|
||||
<span className={CELL}>{t('dec.colTime')}</span>
|
||||
<span className={cn(CELL, 'justify-end')}>{t('dec.colSnr')}</span>
|
||||
<span className={cn(CELL, 'justify-end')} title={t('dec.colDtTitle')}>{t('dec.colDt')}</span>
|
||||
<span className={cn(CELL, 'justify-end')} title={t('dec.colFreqTitle')}>{t('dec.colFreq')}</span>
|
||||
<span className={CELL}>{t('dec.colBand')}</span>
|
||||
<span className={CELL}>{t('dec.colMode')}</span>
|
||||
<span className={CELL}>{t('dec.colMsg')}</span>
|
||||
<span className={CELL}>{t('dec.colCountry')}</span>
|
||||
<span className={CELL_LAST}>{t('dec.colStatus')}</span>
|
||||
<div className="shrink-0 border-b border-border bg-background overflow-hidden">
|
||||
<div className={cn(ROW, 'h-7 text-[10px] font-semibold uppercase tracking-wider text-muted-foreground')}
|
||||
style={{ gridTemplateColumns: template, width: tableW }}>
|
||||
{COLS.map((c, i) => (
|
||||
<span key={c.key}
|
||||
// Not CELL_LAST for the final column: its overflow-hidden would
|
||||
// clip that column's own resize handle.
|
||||
className={cn('relative flex items-center min-w-0 px-2',
|
||||
i < COLS.length - 1 && 'border-r border-border/30',
|
||||
// The three numeric columns label their own right edge, where the
|
||||
// figures are.
|
||||
(c.key === 'snr' || c.key === 'dt' || c.key === 'freq') && 'justify-end')}
|
||||
title={c.key === 'dt' ? t('dec.colDtTitle') : c.key === 'freq' ? t('dec.colFreqTitle') : undefined}>
|
||||
<span className="truncate">{t(c.tkey)}</span>
|
||||
<ColResizer
|
||||
onResize={(dx) => setColWidth(c.key, colw[c.key] + dx)}
|
||||
onReset={() => setColWidth(c.key, c.def)}
|
||||
/>
|
||||
</span>
|
||||
))}
|
||||
</div>
|
||||
</div>
|
||||
|
||||
{/* ── Periods ────────────────────────────────────────────────── */}
|
||||
<div className="flex-1 min-h-0 overflow-y-auto">
|
||||
{groups.length === 0 && (
|
||||
<div className="flex-1 min-h-0 overflow-y-auto overflow-x-hidden">
|
||||
{pane.periods.length === 0 && (
|
||||
<div className="h-full flex items-center justify-center px-6 text-center">
|
||||
<p className="text-sm text-muted-foreground max-w-md">
|
||||
{decodes.length === 0 ? t('dec.empty') : t('dec.emptyFiltered')}
|
||||
@@ -613,7 +932,7 @@ export function DecodesPanel({ decodes, txMsgs, txState, spotStatus, onCall, myC
|
||||
</div>
|
||||
)}
|
||||
|
||||
{groups.map((g, gi) => (
|
||||
{pane.periods.map((g, gi) => (
|
||||
<section key={g.start}>
|
||||
{/* Period header — sticky, so the slot being read is always named. */}
|
||||
<header className="sticky top-0 z-10 px-3 bg-muted/95 backdrop-blur border-y border-border/60">
|
||||
@@ -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
|
||||
<span className="truncate">{renderMsg(d.msg ?? '', me, calling)}</span>
|
||||
</span>
|
||||
|
||||
{/* 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. */}
|
||||
<span className={cn(CELL, 'font-mono text-[11px]',
|
||||
d.grid ? 'text-foreground/85' : 'text-muted-foreground/70')}>
|
||||
<span className="truncate">{d.grid || e?.grid || ''}</span>
|
||||
</span>
|
||||
|
||||
<span className={cn(CELL, 'text-[11px] text-muted-foreground')}>
|
||||
<span className="truncate">{e?.country ?? ''}</span>
|
||||
</span>
|
||||
@@ -737,13 +1067,25 @@ export function DecodesPanel({ decodes, txMsgs, txState, spotStatus, onCall, myC
|
||||
{t(entity.label)}
|
||||
</span>
|
||||
)}
|
||||
{extras.map((b) => (
|
||||
<span key={b.key as string}
|
||||
className="rounded border px-1 py-px text-[10px] font-semibold uppercase tracking-wide bg-transparent shrink-0"
|
||||
style={{ borderColor: markerColour(b.marker), color: markerColour(b.marker) }}>
|
||||
{t(b.label)}
|
||||
</span>
|
||||
))}
|
||||
{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 (
|
||||
<span key={b.key as string}
|
||||
title={unconf ? t('dec.bgGridUnconfTip') : undefined}
|
||||
className="rounded border px-1 py-px text-[10px] font-semibold uppercase tracking-wide bg-transparent shrink-0"
|
||||
style={unconf
|
||||
? { borderColor: c, color: c, opacity: 0.45, borderStyle: 'dashed' }
|
||||
: { borderColor: c, color: c }}>
|
||||
{unconf ? t('dec.bgGridUnconf') : t(b.label)}
|
||||
</span>
|
||||
);
|
||||
})}
|
||||
{replying && (
|
||||
<span className="rounded px-1 py-px text-[10px] font-bold uppercase bg-success text-success-foreground shrink-0">
|
||||
{t('dec.toYou')}
|
||||
@@ -755,6 +1097,9 @@ export function DecodesPanel({ decodes, txMsgs, txState, spotStatus, onCall, myC
|
||||
})}
|
||||
</section>
|
||||
))}
|
||||
</div>
|
||||
</div>
|
||||
))}
|
||||
</div>
|
||||
</div>
|
||||
);
|
||||
|
||||
@@ -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 }: {
|
||||
<DialogDescription>{t('exf.desc')}</DialogDescription>
|
||||
</DialogHeader>
|
||||
|
||||
{/* 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". */}
|
||||
<div className="flex items-center gap-2 px-1 text-[11px] text-muted-foreground">
|
||||
<span>{t('exf.chosen', { n: sel.size })}</span>
|
||||
<Button variant="ghost" size="sm" className="ml-auto h-6 text-[11px]" onClick={() => setSel(defaultSet(official))}>
|
||||
{t('exf.defaults')}
|
||||
</Button>
|
||||
<span className="ml-auto inline-flex items-center gap-1">
|
||||
<Button variant="ghost" size="sm" className="h-6 text-[11px]"
|
||||
onClick={() => setSel(new Set(everyTag))}>
|
||||
{t('exf.selectAll')}
|
||||
</Button>
|
||||
<Button variant="ghost" size="sm" className="h-6 text-[11px]"
|
||||
disabled={sel.size === 0}
|
||||
onClick={() => setSel(new Set())}>
|
||||
{t('exf.selectNone')}
|
||||
</Button>
|
||||
<Button variant="ghost" size="sm" className="h-6 text-[11px]" onClick={() => setSel(defaultSet(official))}>
|
||||
{t('exf.defaults')}
|
||||
</Button>
|
||||
</span>
|
||||
</div>
|
||||
|
||||
<div className="grid grid-cols-3 gap-3 max-h-[56vh] overflow-y-auto pr-1">
|
||||
|
||||
@@ -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<HTMLDivElement>(null);
|
||||
const mapRef = useRef<L.Map | null>(null);
|
||||
const layerRef = useRef<L.LayerGroup | null>(null);
|
||||
const [squares, setSquares] = useState<Square[] | null>(null);
|
||||
const [busy, setBusy] = useState(false);
|
||||
const [err, setErr] = useState('');
|
||||
const [scope, setScope] = useState<ScopeKey>(
|
||||
() => (SCOPES.some((s) => s.key === localStorage.getItem(SCOPE_KEY))
|
||||
? (localStorage.getItem(SCOPE_KEY) as ScopeKey) : 'DIGI'));
|
||||
|
||||
const [basemap, setBasemap] = useState<BasemapKey>(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<L.TileLayer | null>(null);
|
||||
const labelsRef = useRef<L.TileLayer | null>(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.
|
||||
<section className={cn('isolate relative flex flex-col min-h-0 rounded-lg border border-border bg-card overflow-hidden', className)}>
|
||||
<header className="flex items-center gap-2 px-2.5 py-1.5 border-b border-border bg-muted/40 shrink-0 flex-wrap">
|
||||
<span className="text-xs font-semibold uppercase tracking-wider text-muted-foreground">
|
||||
{t('gsm.title')}
|
||||
</span>
|
||||
<div className="inline-flex rounded-md border border-border overflow-hidden">
|
||||
{SCOPES.map((s, i) => (
|
||||
<button key={s.key} type="button"
|
||||
onClick={() => { setScope(s.key); try { localStorage.setItem(SCOPE_KEY, s.key); } catch { /* quota */ } }}
|
||||
className={cn('px-1.5 h-6 text-[11px] whitespace-nowrap', i > 0 && 'border-l border-border',
|
||||
scope === s.key ? 'bg-primary text-primary-foreground' : 'hover:bg-muted text-muted-foreground')}>
|
||||
{t(s.label)}
|
||||
</button>
|
||||
))}
|
||||
</div>
|
||||
<span className="text-[11px] text-muted-foreground tabular-nums">
|
||||
{t('gsm.count', { n: stats.total, c: stats.confirmed })}
|
||||
</span>
|
||||
<select
|
||||
value={basemap}
|
||||
onChange={(e) => { const v = e.target.value as BasemapKey; setBasemap(v); writeUiPref('opslog.mapBasemap', v); }}
|
||||
title={t('gsm.basemap')}
|
||||
className="h-6 rounded border border-border bg-background px-1 text-[11px]"
|
||||
>
|
||||
{(Object.keys(BASEMAPS) as BasemapKey[]).map((k) => (
|
||||
<option key={k} value={k}>{BASEMAPS[k].label}</option>
|
||||
))}
|
||||
</select>
|
||||
<span className="flex-1" />
|
||||
<button type="button" onClick={() => void load()} disabled={busy} title={t('gsm.refresh')}
|
||||
className="inline-flex items-center justify-center size-6 rounded border border-border hover:bg-muted disabled:opacity-50">
|
||||
{busy ? <Loader2 className="size-3 animate-spin" /> : <RefreshCw className="size-3" />}
|
||||
</button>
|
||||
</header>
|
||||
{err && <p className="px-2.5 py-1 text-[11px] text-destructive shrink-0">{err}</p>}
|
||||
{/* The map host must have a real height or Leaflet renders nothing at all
|
||||
— flex-1 + min-h-0, never a percentage. */}
|
||||
<div ref={hostRef} className="flex-1 min-h-0" />
|
||||
<footer className="flex items-center gap-3 px-2.5 py-1 border-t border-border bg-muted/30 shrink-0 text-[10px] text-muted-foreground">
|
||||
<span className="inline-flex items-center gap-1.5">
|
||||
<span className="inline-block size-2.5 rounded-[2px]"
|
||||
style={{ background: 'var(--success)', opacity: 0.75 }} />
|
||||
{t('gsm.confirmed')}
|
||||
</span>
|
||||
<span className="inline-flex items-center gap-1.5">
|
||||
<span className="inline-block size-2.5 rounded-[2px]"
|
||||
style={{ background: 'var(--chart-1)', opacity: 0.35 }} />
|
||||
{t('gsm.worked')}
|
||||
</span>
|
||||
</footer>
|
||||
</section>
|
||||
);
|
||||
}
|
||||
@@ -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<BasemapKey, { label: string; url: string; attr: string; subdomains?: string; labelsUrl?: string }> = {
|
||||
export type BasemapKey = 'light' | 'voyager' | 'street' | 'satellite';
|
||||
export const BASEMAPS: Record<BasemapKey, { label: string; url: string; attr: string; subdomains?: string; labelsUrl?: string }> = {
|
||||
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<BasemapKey, { label: string; url: string; attr: string; s
|
||||
attr: 'Tiles © Esri — Source: Esri, Maxar, Earthstar Geographics',
|
||||
labelsUrl: 'https://server.arcgisonline.com/ArcGIS/rest/services/Reference/World_Boundaries_and_Places/MapServer/tile/{z}/{y}/{x}' },
|
||||
};
|
||||
function loadBasemap(): BasemapKey {
|
||||
export function loadBasemap(): BasemapKey {
|
||||
const v = localStorage.getItem('opslog.mapBasemap');
|
||||
return v === 'voyager' || v === 'street' || v === 'satellite' ? v : 'light';
|
||||
}
|
||||
@@ -80,7 +80,7 @@ function loadBasemap(): BasemapKey {
|
||||
// place-name overlay. updateWhenIdle/keepBuffer keep the number of live tiles
|
||||
// down: satellite loads TWO tile layers, so its tile count — and the composited
|
||||
// layers WebView2 has to hold — is double every other basemap's.
|
||||
function addBasemap(
|
||||
export function addBasemap(
|
||||
m: L.Map,
|
||||
key: BasemapKey,
|
||||
base: React.MutableRefObject<L.TileLayer | null>,
|
||||
|
||||
@@ -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}
|
||||
/>
|
||||
</div>
|
||||
)
|
||||
@@ -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}
|
||||
/>
|
||||
</div>
|
||||
)}
|
||||
|
||||
@@ -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
|
||||
<div className="px-3 py-1 text-[11px] uppercase tracking-wider text-muted-foreground">
|
||||
{t('qctx.selected', { n })}
|
||||
</div>
|
||||
<button
|
||||
className="flex w-full items-center gap-2 px-3 py-1.5 text-left hover:bg-accent/50"
|
||||
onClick={() => { onUpdateFromCty(menu.ids); onClose(); }}
|
||||
>
|
||||
<Globe2 className="size-4 text-primary" />
|
||||
<span>{t('qctx.fixCountry')}</span>
|
||||
</button>
|
||||
<button
|
||||
className="flex w-full items-center gap-2 px-3 py-1.5 text-left hover:bg-accent/50"
|
||||
onClick={() => { onUpdateFromQRZ(menu.ids); onClose(); }}
|
||||
>
|
||||
<RefreshCw className="size-4 text-info" />
|
||||
<span>{t('qctx.updateQrz')}</span>
|
||||
</button>
|
||||
{/* 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 && (
|
||||
<button
|
||||
className="flex w-full items-center gap-2 px-3 py-1.5 text-left hover:bg-accent/50"
|
||||
onClick={() => { onUpdateFromCty(menu.ids); onClose(); }}
|
||||
>
|
||||
<Globe2 className="size-4 text-primary" />
|
||||
<span>{t('qctx.fixCountry')}</span>
|
||||
</button>
|
||||
)}
|
||||
{onUpdateFromQRZ && (
|
||||
<button
|
||||
className="flex w-full items-center gap-2 px-3 py-1.5 text-left hover:bg-accent/50"
|
||||
onClick={() => { onUpdateFromQRZ(menu.ids); onClose(); }}
|
||||
>
|
||||
<RefreshCw className="size-4 text-info" />
|
||||
<span>{t('qctx.updateQrz')}</span>
|
||||
</button>
|
||||
)}
|
||||
{onUpdateFromClublog && (
|
||||
<button
|
||||
className="flex w-full items-center gap-2 px-3 py-1.5 text-left hover:bg-accent/50"
|
||||
|
||||
@@ -631,6 +631,20 @@ export function RecentQSOsGrid({ rows, myGrid, selectAllSignal, selectRowSignal,
|
||||
api.setColumnsVisible(ids, false);
|
||||
saveColumnState();
|
||||
}
|
||||
// Whole-dialog show/hide. showAll/hideAll cover the CATALOGUE only; the award
|
||||
// columns live in their own persisted code set, so a global that skipped them
|
||||
// would leave a row of columns behind and look broken.
|
||||
function setEverything(visible: boolean) {
|
||||
const api = gridRef.current?.api;
|
||||
if (!api) return;
|
||||
api.setColumnsVisible(COL_CATALOG.map((c) => c.colId!), visible);
|
||||
if (awardCols && awardCols.length > 0) {
|
||||
persistAwardShown(visible ? new Set(awardCols.map((a) => a.code.toUpperCase())) : new Set());
|
||||
api.setColumnsVisible(awardCols.map((a) => `award_${a.code}`), visible);
|
||||
}
|
||||
saveColumnState();
|
||||
}
|
||||
|
||||
function resetDefaults() {
|
||||
const api = gridRef.current?.api;
|
||||
if (!api) return;
|
||||
@@ -711,11 +725,15 @@ export function RecentQSOsGrid({ rows, myGrid, selectAllSignal, selectRowSignal,
|
||||
</div>
|
||||
</div>
|
||||
|
||||
{/* 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. */}
|
||||
<QSOContextMenu
|
||||
menu={menu}
|
||||
onClose={() => 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')}
|
||||
</DialogDescription>
|
||||
</DialogHeader>
|
||||
{/* Whole-dialog controls. The per-group links alone meant hiding
|
||||
everything was one click PER GROUP, and there are a dozen. */}
|
||||
<div className="flex items-center gap-1 px-5 text-[11px] text-muted-foreground">
|
||||
<span>{t('rqg.pickerAllGroups')}</span>
|
||||
<button type="button" className="text-[11px] text-primary hover:underline px-1"
|
||||
onClick={() => setEverything(true)}>{t('rqg.all')}</button>
|
||||
<span className="opacity-40">·</span>
|
||||
<button type="button" className="text-[11px] text-muted-foreground hover:underline px-1"
|
||||
onClick={() => setEverything(false)}>{t('rqg.none')}</button>
|
||||
</div>
|
||||
<div className="grid grid-cols-3 gap-4 max-h-[60vh] overflow-y-auto px-5 py-3">
|
||||
{GROUP_ORDER.map((group) => {
|
||||
const cols = COL_CATALOG.filter((c) => c.group === group);
|
||||
|
||||
@@ -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<Record<SectionId, string>> = {
|
||||
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<any>({ enabled: false, bands: [], available: [] });
|
||||
// How a worked square is matched, and what counts as still wanted.
|
||||
const [autoCall, setAutoCall] = useState<AutoCallSettings>(loadAutoCall);
|
||||
const [gridScope, setGridScope] = useState<any>({ 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
|
||||
</div>
|
||||
)}
|
||||
|
||||
{/* 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. */}
|
||||
<div className="border-t border-border/60 pt-3 space-y-2">
|
||||
<div className="text-sm font-semibold">{t('rot.widget')}</div>
|
||||
<label className="flex items-center gap-2 text-sm">
|
||||
<Checkbox checked={rotorCompact}
|
||||
onCheckedChange={(c) => { const v = !!c; setRotorCompact(v); writeUiPref('opslog.rotorCompact', v ? '1' : '0'); }} />
|
||||
{t('rot.compact')}
|
||||
</label>
|
||||
<p className="text-xs text-muted-foreground">{t('rot.compactHint')}</p>
|
||||
</div>
|
||||
|
||||
{/* 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. */}
|
||||
<div className="border-t border-border/60 pt-3 space-y-2">
|
||||
rather than copied from someone else's. Hidden in compact mode —
|
||||
editing buttons that are not drawn is a trap. */}
|
||||
<div className={cn('border-t border-border/60 pt-3 space-y-2', rotorCompact && 'opacity-40')}>
|
||||
<div className="text-sm font-semibold">{t('rot.presets')}</div>
|
||||
<p className="text-xs text-muted-foreground">{t('rot.presetsHint')}</p>
|
||||
<div className="space-y-1.5">
|
||||
@@ -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<AutoCallSettings>) => {
|
||||
const next = { ...autoCall, ...patch };
|
||||
setAutoCall(next);
|
||||
writeUiPref(autoCallKey, JSON.stringify(next));
|
||||
};
|
||||
const crit = (which: 'criteria' | 'watchCriteria', k: keyof AutoCallCriteria) => (
|
||||
<label key={k} className="flex items-center gap-1.5 text-xs cursor-pointer">
|
||||
<Checkbox
|
||||
checked={!!autoCall[which][k]}
|
||||
onCheckedChange={(v) => set({ [which]: { ...autoCall[which], [k]: !!v } } as any)}
|
||||
/>
|
||||
{t(`ftx.c_${k}`)}
|
||||
</label>
|
||||
);
|
||||
const KEYS: (keyof AutoCallCriteria)[] = ['dxcc', 'band', 'mode', 'slot', 'grid', 'county', 'pota', 'pfx'];
|
||||
return (
|
||||
<>
|
||||
<SectionHeader title={t('sec.ftx')} hint={t('ftx.hint')} />
|
||||
<div className="space-y-4">
|
||||
<div className="rounded-md border border-border p-3 space-y-3">
|
||||
<label className="flex items-start gap-2 text-sm cursor-pointer">
|
||||
<Checkbox checked={autoCall.enabled} className="mt-0.5"
|
||||
onCheckedChange={(v) => set({ enabled: !!v })} />
|
||||
<span>
|
||||
{t('ftx.enable')}{' '}
|
||||
<span className="text-xs text-muted-foreground">{t('ftx.enableHint')}</span>
|
||||
</span>
|
||||
</label>
|
||||
|
||||
{autoCall.enabled && (
|
||||
<div className="pl-6 space-y-3">
|
||||
<div>
|
||||
<p className="text-xs font-semibold text-muted-foreground mb-1.5">{t('ftx.callWhen')}</p>
|
||||
<div className="grid grid-cols-2 gap-x-4 gap-y-1">{KEYS.map((k) => crit('criteria', k))}</div>
|
||||
</div>
|
||||
|
||||
<div className="border-t border-border/60 pt-3">
|
||||
<p className="text-xs font-semibold text-muted-foreground mb-1">{t('ftx.watch')}</p>
|
||||
<p className="text-[11px] text-muted-foreground mb-1.5 leading-relaxed">{t('ftx.watchHint')}</p>
|
||||
<Textarea
|
||||
className="h-20 font-mono text-xs"
|
||||
placeholder={"4S7*\nTM0HQ\n*/P"}
|
||||
defaultValue={(autoCall.watch ?? []).join('\n')}
|
||||
key={`w-${(autoCall.watch ?? []).length}`}
|
||||
onBlur={(e) => set({
|
||||
watch: e.target.value.split('\n').map((x) => x.trim().toUpperCase()).filter(Boolean),
|
||||
})}
|
||||
/>
|
||||
{(autoCall.watch ?? []).length > 0 && (
|
||||
<div className="mt-2">
|
||||
<p className="text-[11px] text-muted-foreground mb-1">{t('ftx.watchOnlyIf')}</p>
|
||||
<div className="grid grid-cols-2 gap-x-4 gap-y-1">{KEYS.map((k) => crit('watchCriteria', k))}</div>
|
||||
</div>
|
||||
)}
|
||||
</div>
|
||||
|
||||
<div className="border-t border-border/60 pt-3 flex items-center gap-2 flex-wrap">
|
||||
<span className="text-xs text-muted-foreground">{t('ftx.cooldown')}</span>
|
||||
<Input type="number" min={10} max={3600} className="w-24 h-7 text-xs"
|
||||
defaultValue={autoCall.cooldownSec}
|
||||
key={`cd-${autoCall.cooldownSec}`}
|
||||
onBlur={(e) => {
|
||||
const v = parseInt(e.target.value, 10);
|
||||
if (!isNaN(v) && v >= 10 && v <= 3600) set({ cooldownSec: v });
|
||||
}} />
|
||||
<span className="text-xs text-muted-foreground">s</span>
|
||||
</div>
|
||||
|
||||
<p className="text-[11px] rounded border border-warning-border bg-warning-muted text-warning-muted-foreground px-2 py-1.5 leading-relaxed">
|
||||
{t('ftx.warn')}
|
||||
</p>
|
||||
</div>
|
||||
)}
|
||||
</div>
|
||||
</div>
|
||||
</>
|
||||
);
|
||||
}
|
||||
|
||||
function ClusterPanel() {
|
||||
const sorted = [...clusterServers].sort((a, b) => (a.sort_order ?? 0) - (b.sort_order ?? 0));
|
||||
return (
|
||||
@@ -4714,6 +4829,36 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
|
||||
{pskrStatus?.running ? ` · ${t('bo.feedUp', { n: pskrStatus.received ?? 0 })}` : ''}
|
||||
</p>
|
||||
)}
|
||||
|
||||
{/* What counts as "I already have this square". There is no single
|
||||
right answer — a VUCC chaser counts a square per band, someone
|
||||
filling a wall map counts it once — so it is a choice, and the
|
||||
same six GridTracker offers, because a square wanted in one and
|
||||
not the other is a bug report every time. */}
|
||||
<div className="pl-6 space-y-1.5 pt-1">
|
||||
<div className="flex items-center gap-2 flex-wrap">
|
||||
<span className="text-xs text-muted-foreground w-28 shrink-0">{t('gsc.scope')}</span>
|
||||
<Select value={gridScope.scope} onValueChange={(v) => saveGridScope({ ...gridScope, scope: v })}>
|
||||
<SelectTrigger className="h-7 w-64 text-xs"><SelectValue /></SelectTrigger>
|
||||
<SelectContent>
|
||||
{(gridScope.scopes ?? []).map((s: any) => (
|
||||
<SelectItem key={s.key} value={s.key}>{t(`gsc.scope_${s.key}`)}</SelectItem>
|
||||
))}
|
||||
</SelectContent>
|
||||
</Select>
|
||||
</div>
|
||||
<div className="flex items-center gap-2 flex-wrap">
|
||||
<span className="text-xs text-muted-foreground w-28 shrink-0">{t('gsc.hunt')}</span>
|
||||
<Select value={gridScope.hunt} onValueChange={(v) => saveGridScope({ ...gridScope, hunt: v })}>
|
||||
<SelectTrigger className="h-7 w-64 text-xs"><SelectValue /></SelectTrigger>
|
||||
<SelectContent>
|
||||
<SelectItem value="new">{t('gsc.huntNew')}</SelectItem>
|
||||
<SelectItem value="new_unconfirmed">{t('gsc.huntUnconf')}</SelectItem>
|
||||
</SelectContent>
|
||||
</Select>
|
||||
</div>
|
||||
<p className="text-[11px] text-muted-foreground leading-relaxed">{t('gsc.hint')}</p>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
{/* Chase new — its own option, NOT nested under grid chasing. Chasing
|
||||
@@ -4754,6 +4899,28 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
|
||||
);
|
||||
})}
|
||||
</div>
|
||||
{/* How near a RECEIVER has to be. This is the whole premise of
|
||||
the watch — a report is evidence about YOUR path only if it
|
||||
was collected near you — and the right distance differs by
|
||||
band, so it is the operator's call. Committed on blur/Enter,
|
||||
not per keystroke: each save restarts the feed. */}
|
||||
<div className="flex items-center gap-2 flex-wrap">
|
||||
<span className="text-xs text-muted-foreground">{t('bo.nearKm')}</span>
|
||||
<Input
|
||||
type="number" min={25} max={1000} step={25}
|
||||
className="w-24 h-7 text-xs"
|
||||
defaultValue={bandOpen.near_km ?? 300}
|
||||
key={`nk-${bandOpen.near_km ?? 300}`}
|
||||
onBlur={(e) => {
|
||||
const v = parseInt(e.target.value, 10);
|
||||
if (!isNaN(v) && v !== bandOpen.near_km) saveBandOpen({ ...bandOpen, near_km: v });
|
||||
}}
|
||||
onKeyDown={(e) => { if (e.key === 'Enter') (e.target as HTMLInputElement).blur(); }}
|
||||
/>
|
||||
<span className="text-xs text-muted-foreground">km</span>
|
||||
</div>
|
||||
<p className="text-[11px] text-muted-foreground leading-relaxed">{t('bo.nearKmHint')}</p>
|
||||
|
||||
{/* A live count, because a feed that is connected but silent looks
|
||||
exactly like one that is broken until a number moves. */}
|
||||
<p className="text-xs text-muted-foreground">
|
||||
@@ -6670,6 +6837,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
|
||||
'lists-bands': BandsPanel,
|
||||
'lists-modes': ModesPanel,
|
||||
cluster: ClusterPanel,
|
||||
ftx: FtxPanel,
|
||||
udp: UDPIntegrationsPanelWrapper,
|
||||
// Module-scope components, wrapped so their props can be passed. The nested
|
||||
// panels below go through PanelHost instead — which is what now lets either
|
||||
|
||||
@@ -24,7 +24,7 @@ type UDPConfig = {
|
||||
direction: 'inbound' | 'outbound';
|
||||
name: string;
|
||||
port: number;
|
||||
service_type: 'wsjt' | 'adif' | 'n1mm' | 'remote_call' | 'db_updated' | 'pstrotator_freq' | 'n1mm_radioinfo' | 'wsjt_log' | 'custom';
|
||||
service_type: 'wsjt' | 'adif' | 'n1mm' | 'remote_call' | 'db_updated' | 'pstrotator_freq' | 'n1mm_radioinfo' | 'wsjt_log' | 'wsjt_relay' | 'custom';
|
||||
// Custom rows only.
|
||||
trigger?: string;
|
||||
template?: string;
|
||||
@@ -95,6 +95,19 @@ const SERVICE_TYPES: Array<{
|
||||
hint: 'udpp.svcWsjtLogHint',
|
||||
defaults: { port: 2250, destination_ip: '127.0.0.1' },
|
||||
},
|
||||
{
|
||||
// Feeds a SECOND application the stream this OpsLog receives. WSJT-X, JTDX
|
||||
// and MSHV each send to ONE address, so without a relay the choice is
|
||||
// between OpsLog and JTAlert/GridTracker rather than both.
|
||||
//
|
||||
// 2238 by default: beside the 2237 the sender uses, and free. Pointing it AT
|
||||
// 2237 would name an OpsLog listener, which the relay refuses.
|
||||
id: 'wsjt_relay',
|
||||
direction: 'outbound',
|
||||
label: 'udpp.svcWsjtRelayLabel',
|
||||
hint: 'udpp.svcWsjtRelayHint',
|
||||
defaults: { port: 2238, destination_ip: '127.0.0.1' },
|
||||
},
|
||||
{
|
||||
// The general case: the operator picks the moment and writes the message.
|
||||
// Mainly for antenna switches, which are driven by a URL and want the band
|
||||
|
||||
@@ -298,6 +298,20 @@ export function WorkedBeforeGrid({ wb, myGrid, busy, currentCall, onRowDoubleCli
|
||||
{t('wbg.pickerDesc')}
|
||||
</DialogDescription>
|
||||
</DialogHeader>
|
||||
{/* Whole-dialog controls — the award columns included, which the
|
||||
catalogue-only helpers do not cover. */}
|
||||
<div className="flex items-center gap-1 px-5 text-[11px] text-muted-foreground">
|
||||
<span>{t('wbg.allGroups')}</span>
|
||||
<button type="button" className="text-[11px] text-primary hover:underline px-1"
|
||||
onClick={() => { showAll(); (awardCols ?? []).forEach((a) => setColVisible(`award_${a.code}`, true)); }}>
|
||||
{t('wbg.all')}
|
||||
</button>
|
||||
<span className="opacity-40">·</span>
|
||||
<button type="button" className="text-[11px] text-muted-foreground hover:underline px-1"
|
||||
onClick={() => { hideAll(); (awardCols ?? []).forEach((a) => setColVisible(`award_${a.code}`, false)); }}>
|
||||
{t('wbg.none')}
|
||||
</button>
|
||||
</div>
|
||||
<div className="grid grid-cols-2 gap-4 max-h-[60vh] overflow-y-auto px-5 py-3">
|
||||
{GROUP_ORDER.map((group) => {
|
||||
const cols = COL_CATALOG.filter((c) => c.group === group);
|
||||
|
||||
@@ -0,0 +1,176 @@
|
||||
// Auto-call: let OpsLog answer a decode without the operator clicking it.
|
||||
//
|
||||
// This KEYS THE TRANSMITTER on its own, which is why the rules here are written
|
||||
// as a series of refusals rather than a search for a reason to call. Everything
|
||||
// below has to be true; anything unknown means no.
|
||||
//
|
||||
// The decision is made here, in one pure function, precisely because it is the
|
||||
// dangerous part: it can be read, argued with and tested without a radio.
|
||||
|
||||
export type AutoCallCriteria = {
|
||||
dxcc: boolean; // entity never worked
|
||||
band: boolean; // entity never worked on this band
|
||||
mode: boolean; // entity never worked in this mode
|
||||
slot: boolean; // band and mode each worked, never together
|
||||
grid: boolean; // square wanted under the grid scope
|
||||
county: boolean; // US county never worked
|
||||
pota: boolean; // park never worked
|
||||
sota: boolean; // summit never worked (spot-tagged only)
|
||||
pfx: boolean; // CQ WPX prefix never worked
|
||||
};
|
||||
|
||||
export type AutoCallSettings = {
|
||||
enabled: boolean;
|
||||
criteria: AutoCallCriteria;
|
||||
// Callsigns to answer on sight, wildcards allowed (4S7*, */P). Each is still
|
||||
// subject to `watchCriteria` — "call TM0HQ, but only if it is a new band" is
|
||||
// the request, not "call it every time it appears".
|
||||
watch: string[];
|
||||
// Empty means call a watched callsign whenever it is not already worked.
|
||||
watchCriteria: AutoCallCriteria;
|
||||
// Seconds to ignore a callsign after calling it, so a station that keeps
|
||||
// sending CQ is not re-answered every slot while the QSO is in progress.
|
||||
cooldownSec: number;
|
||||
};
|
||||
|
||||
export const emptyCriteria: AutoCallCriteria = {
|
||||
dxcc: false, band: false, mode: false, slot: false,
|
||||
grid: false, county: false, pota: false, sota: false, pfx: false,
|
||||
};
|
||||
|
||||
export const defaultAutoCall: AutoCallSettings = {
|
||||
// OFF, and it stays off until asked for. Unattended transmit is not something
|
||||
// to inherit from an upgrade.
|
||||
enabled: false,
|
||||
criteria: { ...emptyCriteria },
|
||||
watch: [],
|
||||
watchCriteria: { ...emptyCriteria },
|
||||
cooldownSec: 120,
|
||||
};
|
||||
|
||||
const AC_KEY = 'opslog.autoCall';
|
||||
|
||||
export function loadAutoCall(): AutoCallSettings {
|
||||
try {
|
||||
const raw = localStorage.getItem(AC_KEY);
|
||||
if (!raw) return { ...defaultAutoCall };
|
||||
const v = JSON.parse(raw);
|
||||
return {
|
||||
...defaultAutoCall,
|
||||
...v,
|
||||
criteria: { ...emptyCriteria, ...(v?.criteria ?? {}) },
|
||||
watchCriteria: { ...emptyCriteria, ...(v?.watchCriteria ?? {}) },
|
||||
watch: Array.isArray(v?.watch) ? v.watch : [],
|
||||
};
|
||||
} catch { return { ...defaultAutoCall }; }
|
||||
}
|
||||
|
||||
export const autoCallKey = AC_KEY;
|
||||
|
||||
// A decode's resolved novelty, the same shape the panel already renders from.
|
||||
export type DecodeStatus = {
|
||||
status?: string;
|
||||
worked_call?: boolean;
|
||||
new_grid?: boolean;
|
||||
grid_state?: string;
|
||||
new_county?: boolean;
|
||||
new_pota?: boolean;
|
||||
new_pfx?: boolean;
|
||||
};
|
||||
|
||||
// matchesWildcard is the same rule the alert filters use: * is any run, ? is one.
|
||||
export function matchesWildcard(pattern: string, call: string): boolean {
|
||||
const p = pattern.trim().toUpperCase();
|
||||
const c = call.trim().toUpperCase();
|
||||
if (!p) return false;
|
||||
const re = new RegExp('^' + p.split('').map((ch) => (
|
||||
ch === '*' ? '.*' : ch === '?' ? '.' : ch.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
|
||||
)).join('') + '$');
|
||||
return re.test(c);
|
||||
}
|
||||
|
||||
// anyCriterion is false for an all-off set, which is what makes "watch this
|
||||
// callsign, no conditions" expressible.
|
||||
function anyCriterion(c: AutoCallCriteria): boolean {
|
||||
return Object.values(c).some(Boolean);
|
||||
}
|
||||
|
||||
// meets reports whether a decode satisfies at least one ticked criterion.
|
||||
function meets(c: AutoCallCriteria, e: DecodeStatus): boolean {
|
||||
if (c.dxcc && e.status === 'new') return true;
|
||||
if (c.band && e.status === 'new-band') return true;
|
||||
if (c.mode && e.status === 'new-mode') return true;
|
||||
if (c.slot && e.status === 'new-slot') return true;
|
||||
// A square that is merely UNCONFIRMED is not called: the QSO is already made,
|
||||
// and calling again would work a duplicate to chase a QSL.
|
||||
if (c.grid && e.new_grid && e.grid_state !== 'unconf') return true;
|
||||
if (c.county && e.new_county) return true;
|
||||
if (c.pota && e.new_pota) return true;
|
||||
if (c.pfx && e.new_pfx) return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
export type AutoCallDecode = {
|
||||
call: string;
|
||||
cq?: boolean;
|
||||
msg?: string;
|
||||
instance?: string;
|
||||
};
|
||||
|
||||
// shouldAutoCall decides whether to answer one decode. The reason is returned
|
||||
// for the log: an automatic transmission with no record of WHY is the thing an
|
||||
// operator cannot argue with after the fact.
|
||||
export function shouldAutoCall(
|
||||
s: AutoCallSettings,
|
||||
d: AutoCallDecode,
|
||||
e: DecodeStatus | undefined,
|
||||
opts: {
|
||||
// busy is "some receiver is mid-QSO", NOT "this one is transmitting".
|
||||
//
|
||||
// The distinction is the whole bug it fixes: with two instances the caller
|
||||
// used to test a single global transmit flag, which belonged to whichever
|
||||
// receiver reported last. So while slice A worked a station, slice B looked
|
||||
// idle and auto-call started another QSO on it — and the moment either
|
||||
// finished it chained straight into the next. One station at a time means
|
||||
// one across ALL receivers, not one per receiver.
|
||||
busy: boolean;
|
||||
calledAt: Map<string, number>;
|
||||
now: number;
|
||||
myCall?: string;
|
||||
},
|
||||
): { call: boolean; reason: string } {
|
||||
const no = (why: string) => ({ call: false, reason: why });
|
||||
if (!s.enabled) return no('off');
|
||||
if (!e) return no('status not resolved yet');
|
||||
const call = (d.call ?? '').trim().toUpperCase();
|
||||
if (!call) return no('no callsign');
|
||||
// Never answer ourselves, however the decode reached us.
|
||||
if (opts.myCall && call === opts.myCall.trim().toUpperCase()) return no('own callsign');
|
||||
// Only a CQ. Answering a station mid-QSO is both rude and futile — WSJT-X
|
||||
// actions a Reply only for CQ and QRZ anyway.
|
||||
if (!d.cq) return no('not a CQ');
|
||||
// Not while ANY receiver is mid-QSO — transmitting, or holding a DX call it
|
||||
// has not finished with. Starting a second exchange before the first is done
|
||||
// is what turned this into a machine that called without stopping.
|
||||
if (opts.busy) return no('a QSO is already in progress');
|
||||
const last = opts.calledAt.get(call);
|
||||
if (last !== undefined && opts.now - last < s.cooldownSec * 1000) return no('called recently');
|
||||
|
||||
// The watch list first: an explicitly named station outranks the general
|
||||
// criteria, and may carry conditions of its own.
|
||||
const watched = s.watch.some((p) => matchesWildcard(p, call));
|
||||
if (watched) {
|
||||
if (!anyCriterion(s.watchCriteria)) {
|
||||
// No conditions attached: call it unless it is already worked.
|
||||
return e.worked_call ? no('watched, but already worked') : { call: true, reason: 'watch list' };
|
||||
}
|
||||
return meets(s.watchCriteria, e)
|
||||
? { call: true, reason: 'watch list + criteria' }
|
||||
: no('watched, but no criterion met');
|
||||
}
|
||||
|
||||
if (!anyCriterion(s.criteria)) return no('no criteria ticked');
|
||||
return meets(s.criteria, e)
|
||||
? { call: true, reason: 'criteria' }
|
||||
: no('no criterion met');
|
||||
}
|
||||
+34
-14
File diff suppressed because one or more lines are too long
@@ -17,6 +17,8 @@ const PORTABLE_KEYS = [
|
||||
'opslog.autofocusWB', // auto-focus Worked-before
|
||||
'hamlog.filterPresets', // Filter Builder saved presets
|
||||
'opslog.showRotor', // rotor compass shown next to the keyers
|
||||
'opslog.rotorCompact', // rotor widget: dial + SP/LP only, no quick-turn buttons or Stop
|
||||
'opslog.decodesGridMap',// FT decodes tab: grid-square map shown beside the table
|
||||
'opslog.showChaseNew', // Chase New panel shown next to the keyers
|
||||
'opslog.showAmpWidget', // amplifier widget shown next to the keyers
|
||||
'opslog.ampSel.widget', // which amplifier that widget shows ("all" or an amp id)
|
||||
@@ -45,6 +47,7 @@ const PORTABLE_KEYS = [
|
||||
'opslog.bandMapWidth', // docked band map: column width (px)
|
||||
'opslog.bandMapTabWidth', // Band map tab: shared card width (px)
|
||||
'opslog.bandMapZoom', // band map zoom (px/kHz step) remembered per band, as one {band: index} map
|
||||
'opslog.decodeColWidths', // FT decodes table: per-column widths (px), as one {col: px} map
|
||||
// NOTE: 'hamlog.awardColsShown' and the grid column layouts are NOT listed here.
|
||||
// They are handled by lib/gridPrefs, which scopes the localStorage cache PER
|
||||
// PROFILE and mirrors to the DB (already per-profile) itself — mirroring them
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
// Single source of truth for the app version shown in the UI (header + About).
|
||||
// Bump this on a release (the release script updates it alongside telemetry.go).
|
||||
export const APP_VERSION = '0.25.9';
|
||||
export const APP_VERSION = '0.26.0';
|
||||
|
||||
// Author / credits, shown in Help -> About.
|
||||
export const APP_AUTHOR = 'F4BPO';
|
||||
|
||||
Reference in New Issue
Block a user