feat: While importing ADIF, update MY fields

app_cw.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"fmt"
+	"time"
 
 	"hamlog/internal/applog"
 	"hamlog/internal/audio"
@@ -13,6 +14,31 @@ import (
 // CW decoder: taps the RX audio device (the same "From radio" capture the DVK
 // and QSO recorder use) and streams decoded Morse text to the UI. It is started
 // only by the frontend, and only while the entry mode is CW.
+//
+// Pitch targeting: the single-channel decoder is far more reliable when it locks
+// to a KNOWN pitch (a narrow filter at the signal frequency, like a skimmer)
+// instead of auto-searching for the loudest tone. So we follow the radio's CW
+// pitch (FlexRadio cw_pitch) when available — or a manual override — and fall
+// back to auto-search otherwise.
+
+// cwTargetPitch returns the pitch (Hz) the decoder should lock to: the manual
+// override if set, else the FlexRadio's CW pitch when it's in CW, else 0 (auto).
+func (a *App) cwTargetPitch() int {
+	if a.cwPitchHz > 0 {
+		return a.cwPitchHz
+	}
+	if a.cat != nil {
+		if st, ok := a.cat.FlexState(); ok && st.Available {
+			// Only trust the radio's pitch when it's actually in CW.
+			if st.Mode == "CW" || st.Mode == "CWL" || st.Mode == "CWU" {
+				if st.CWPitch > 0 {
+					return st.CWPitch
+				}
+			}
+		}
+	}
+	return 0
+}
 
 // StartCWDecoder begins decoding CW from the configured RX audio device. The
 // frontend calls this when the decoder toggle is on AND the mode is CW. Safe to
@@ -43,6 +69,8 @@ func (a *App) StartCWDecoder() error {
 			}
 		},
 	)
+	dec.SetTarget(a.cwTargetPitch())
+	a.cwDecoder = dec
 
 	stop := make(chan struct{})
 	a.cwStop = stop
@@ -53,21 +81,38 @@ func (a *App) StartCWDecoder() error {
 				wruntime.EventsEmit(a.ctx, "cw:error", err.Error())
 			}
 		}
-		// Capture ended (stopped or errored) — clear state so a restart works.
 		a.cwMu.Lock()
 		if a.cwStop == stop {
 			a.cwStop = nil
+			a.cwDecoder = nil
 		}
 		a.cwMu.Unlock()
 	}()
+	// Follow the radio's CW pitch live (every second) while this run is active.
+	go a.cwFollowPitch(stop, dec)
 	return nil
 }
 
+// cwFollowPitch keeps the decoder locked to the current target pitch until stop.
+func (a *App) cwFollowPitch(stop <-chan struct{}, dec *cwdecode.Decoder) {
+	t := time.NewTicker(time.Second)
+	defer t.Stop()
+	for {
+		select {
+		case <-stop:
+			return
+		case <-t.C:
+			dec.SetTarget(a.cwTargetPitch())
+		}
+	}
+}
+
 // StopCWDecoder halts the CW decoder if running.
 func (a *App) StopCWDecoder() {
 	a.cwMu.Lock()
 	stop := a.cwStop
 	a.cwStop = nil
+	a.cwDecoder = nil
 	a.cwMu.Unlock()
 	if stop != nil {
 		close(stop)
@@ -80,3 +125,25 @@ func (a *App) CWDecoderRunning() bool {
 	defer a.cwMu.Unlock()
 	return a.cwStop != nil
 }
+
+// SetCWDecoderPitch sets a manual decode pitch (Hz); 0 returns to auto (follow
+// the Flex CW pitch, or search). Applies live to a running decoder.
+func (a *App) SetCWDecoderPitch(hz int) {
+	if hz < 0 {
+		hz = 0
+	}
+	a.cwMu.Lock()
+	a.cwPitchHz = hz
+	dec := a.cwDecoder
+	a.cwMu.Unlock()
+	if dec != nil {
+		dec.SetTarget(a.cwTargetPitch())
+	}
+}
+
+// GetCWDecoderPitch returns the manual override (0 = auto / follow Flex).
+func (a *App) GetCWDecoderPitch() int {
+	a.cwMu.Lock()
+	defer a.cwMu.Unlock()
+	return a.cwPitchHz
+}