2vfo

core/actions.go

@@ -28,8 +28,21 @@ const (
 	ActionEntryWorkmodeRun       = "entry.workmode_run"
 	ActionEntryOfferQTC          = "entry.offer_qtc"
 	ActionEntryRequestQTC        = "entry.request_qtc"
+	ActionEntryToggleFocusedVFO  = "entry.toggle_focused_vfo"
+	ActionEntryFocusVFO1         = "entry.focus_vfo1"
+	ActionEntryFocusVFO2         = "entry.focus_vfo2"
+	ActionEntryLogVFO1           = "entry.log_vfo1"
+	ActionEntryLogVFO2           = "entry.log_vfo2"
+	ActionEntryClearVFO1         = "entry.clear_vfo1"
+	ActionEntryClearVFO2         = "entry.clear_vfo2"
 
-	ActionRadioXITActive = "radio.xit_active"
+	ActionRadioXITActive       = "radio.xit_active"
+	ActionRadioMuteAudioVFO1   = "radio.mute_audio_vfo1"
+	ActionRadioMuteAudioVFO2   = "radio.mute_audio_vfo2"
+	ActionRadioUnmuteAudioVFO1 = "radio.unmute_audio_vfo1"
+	ActionRadioUnmuteAudioVFO2 = "radio.unmute_audio_vfo2"
+	ActionRadioToggleAudioVFO1 = "radio.toggle_audio_vfo1"
+	ActionRadioToggleAudioVFO2 = "radio.toggle_audio_vfo2"
 
 	ActionBandmapMark                 = "bandmap.mark"
 	ActionBandmapGotoHighestValueSpot = "bandmap.goto_highest_value_spot"

core/app/app.go

@@ -74,7 +74,7 @@ type Controller struct {
 	callHistoryFinder *callhistory.Finder
 	hamDXMap          *hamdxmap.HamDXMap
 
-	VFO                      *vfo.VFO
+	VFOs                     []*vfo.VFO
 	Logbook                  *logbook.Logbook
 	QSOList                  *logbook.QSOList
 	QTCList                  *logbook.QTCList
@@ -204,27 +204,42 @@ func (c *Controller) Startup() {
 
 	c.Workmode = workmode.NewController()
 	c.Workmode.Notify(c.Entry)
+	c.Entry.Notify(c.Workmode)
 	c.QSOList.Notify(c.Workmode)
 
-	c.VFO = vfo.NewVFO("VFO 1", c.bandplan, c.Logbook, c.asyncRunner)
-	c.Entry.SetVFO(c.VFO)
-	c.VFO.Notify(c.Bandmap)
-	c.Bandmap.SetVFO(c.VFO)
-	c.Logbook.Notify(c.VFO)
-	c.Workmode.Notify(c.VFO)
+	c.Callinfo = callinfo.New(c.dxccFinder, c.scpFinder, c.callHistoryFinder, c.Logbook, c.Logbook, c.Logbook)
+	c.Entry.SetCallinfo(c.Callinfo)
+	c.Callinfo.Notify(c.Entry)
 
 	c.Radio = radio.NewController(c.configuration.Radios(), c.configuration.Keyers(), c.bandplan)
 	c.Radio.Notify(c.ServiceStatus)
+	c.Radio.Notify(c.Entry)
+	c.Radio.Notify(c.Callinfo)
+	c.Radio.Notify(c.Workmode)
+	c.Entry.SetVFOSwitcher(c.Radio)
 	c.Bandmap.Notify(c.Radio) // TODO implement Entry... in radio.Controller
-	c.VFO.SetClient(c.Radio)
+
+	c.VFOs = make([]*vfo.VFO, core.VFOCount)
+	for vfoID := range len(c.VFOs) {
+		v := vfo.NewVFO(core.VFOID(vfoID), fmt.Sprintf("VFO %d", vfoID+1), c.bandplan, c.Logbook, c.asyncRunner)
+		v.SetClient(c.Radio)
+		c.VFOs[vfoID] = v
+		c.Entry.SetVFO(core.VFOID(vfoID), v)
+		c.Logbook.Notify(v)
+	}
+	c.Bandmap.SetVFO(c.VFOs[core.VFO1])
+	c.Workmode.Notify(c.VFOs[core.VFO1])
 
 	c.Radio.SetSendSpotsToTci(c.session.SendSpotsToTci())
 	c.Radio.SelectRadio(c.session.Radio1())
 	c.Radio.SelectKeyer(c.session.Keyer1())
 
 	c.Keyer = keyer.New(c.Settings, c.Radio, c.configuration.KeyerSettings(), c.Workmode.Workmode(), c.configuration.KeyerPresets())
+	c.Keyer.SetVFOSwitcher(c.Radio)
 	c.Keyer.SetValues(c.Entry.CurrentValues)
 	c.Keyer.Notify(c.ServiceStatus)
+	c.Keyer.Notify(c.Entry)
+	c.Entry.Notify(c.Keyer)
 	c.Workmode.Notify(c.Keyer)
 	c.Entry.SetKeyer(c.Keyer)
 
@@ -243,21 +258,18 @@ func (c *Controller) Startup() {
 	}
 
 	c.QTCController = qtc.NewController(c.clock, c, c.Logbook, c.QTCList, c.Entry, c.Keyer)
-	c.VFO.Notify(c.QTCController)
 
 	c.Rate = rate.NewCounter(c.clock, c.asyncRunner)
 	c.QSOList.Notify(logbook.QSOsClearedListenerFunc(c.Rate.Clear))
 	c.QSOList.Notify(logbook.QSOAddedListenerFunc(c.Rate.Add))
 
-	c.Callinfo = callinfo.New(c.dxccFinder, c.scpFinder, c.callHistoryFinder, c.Logbook, c.Logbook, c.Logbook)
-	c.Entry.SetCallinfo(c.Callinfo)
-	c.Callinfo.Notify(c.Entry)
 	c.Bandmap.SetCallinfo(c.Callinfo)
 	c.Bandmap.Notify(c.Callinfo)
 	c.Logbook.Notify(c.Callinfo)
 
 	c.Parrot = parrot.New(c.Workmode, c.Keyer, c.asyncRunner)
 	c.Keyer.SetParrot(c.Parrot)
+	c.Keyer.Notify(c.Parrot)
 	c.Workmode.Notify(c.Parrot)
 	c.Entry.Notify(c.Parrot)
 	c.Parrot.Notify(c.Entry)
@@ -852,11 +864,23 @@ func (c *Controller) RequestQTC() {
 }
 
 func (c *Controller) XITActive() bool {
-	return c.VFO.XITActive()
+	return c.VFOs[core.VFO1].XITActive()
 }
 
 func (c *Controller) SetXITActive(active bool) {
-	c.VFO.SetXITActive(active)
+	c.VFOs[core.VFO1].SetXITActive(active)
+}
+
+func (c *Controller) MuteAudio(vfo core.VFOID) {
+	c.VFOs[vfo].MuteAudio()
+}
+
+func (c *Controller) UnmuteAudio(vfo core.VFOID) {
+	c.VFOs[vfo].UnmuteAudio()
+}
+
+func (c *Controller) ToggleAudio(vfo core.VFOID) {
+	c.VFOs[vfo].ToggleAudio()
 }
 
 func (c *Controller) MarkInBandmap() {
@@ -954,6 +978,20 @@ func (c *Controller) DoAction(id string) error {
 		c.StartParrot()
 	case core.ActionEntryNextESMStep:
 		c.Entry.NextESMStep()
+	case core.ActionEntryToggleFocusedVFO:
+		c.Entry.ToggleFocusedVFO()
+	case core.ActionEntryFocusVFO1:
+		c.Entry.FocusVFO1()
+	case core.ActionEntryFocusVFO2:
+		c.Entry.FocusVFO2()
+	case core.ActionEntryLogVFO1:
+		c.Entry.LogVFO(core.VFO1)
+	case core.ActionEntryLogVFO2:
+		c.Entry.LogVFO(core.VFO2)
+	case core.ActionEntryClearVFO1:
+		c.Entry.ClearVFO(core.VFO1)
+	case core.ActionEntryClearVFO2:
+		c.Entry.ClearVFO(core.VFO2)
 	case core.ActionEntryOfferQTC:
 		c.OfferQTC()
 	case core.ActionEntryRequestQTC:
@@ -981,13 +1019,25 @@ func (c *Controller) DoAction(id string) error {
 	case core.ActionWindowShowSpots:
 		c.ShowSpots()
 	case core.ActionKeyerSendMacro1:
-		c.Keyer.Send(0)
+		c.Keyer.SendMacro(0)
 	case core.ActionKeyerSendMacro2:
-		c.Keyer.Send(1)
+		c.Keyer.SendMacro(1)
 	case core.ActionKeyerSendMacro3:
-		c.Keyer.Send(2)
+		c.Keyer.SendMacro(2)
 	case core.ActionKeyerSendMacro4:
-		c.Keyer.Send(3)
+		c.Keyer.SendMacro(3)
+	case core.ActionRadioMuteAudioVFO1:
+		c.MuteAudio(core.VFO1)
+	case core.ActionRadioMuteAudioVFO2:
+		c.MuteAudio(core.VFO2)
+	case core.ActionRadioUnmuteAudioVFO1:
+		c.UnmuteAudio(core.VFO1)
+	case core.ActionRadioUnmuteAudioVFO2:
+		c.UnmuteAudio(core.VFO2)
+	case core.ActionRadioToggleAudioVFO1:
+		c.ToggleAudio(core.VFO1)
+	case core.ActionRadioToggleAudioVFO2:
+		c.ToggleAudio(core.VFO2)
 	default:
 		return fmt.Errorf("unknown action: %s", id)
 	}

core/bandmap/bandmap.go

@@ -233,14 +233,20 @@ func (m *Bandmap) ScoreChanged(_ core.Score) {
 	}
 }
 
-func (m *Bandmap) VFOFrequencyChanged(frequency core.Frequency) {
+func (m *Bandmap) VFOFrequencyChanged(vfo core.VFOID, frequency core.Frequency) {
+	if vfo != core.VFO1 {
+		return
+	}
 	m.do <- func() {
 		m.activeFrequency = frequency
 		// the frame is not updated with every frequency change, this creates too much load
 	}
 }
 
-func (m *Bandmap) VFOBandChanged(band core.Band) {
+func (m *Bandmap) VFOBandChanged(vfo core.VFOID, band core.Band) {
+	if vfo != core.VFO1 {
+		return
+	}
 	m.do <- func() {
 		if band == m.activeBand {
 			return
@@ -254,7 +260,10 @@ func (m *Bandmap) VFOBandChanged(band core.Band) {
 	}
 }
 
-func (m *Bandmap) VFOModeChanged(mode core.Mode) {
+func (m *Bandmap) VFOModeChanged(vfo core.VFOID, mode core.Mode) {
+	if vfo != core.VFO1 {
+		return
+	}
 	m.do <- func() {
 		if m.activeMode == mode {
 			return
@@ -398,6 +407,7 @@ func (v *nullView) RevealEntry(core.BandmapEntry) {}
 
 type nullVFO struct{}
 
+func (n *nullVFO) Name() string                { return "" }
 func (n *nullVFO) Notify(any)                  {}
 func (n *nullVFO) Active() bool                { return false }
 func (n *nullVFO) Refresh()                    {}

core/callinfo/callinfo.go

@@ -45,11 +45,12 @@ type QTCProvider interface {
 
 // View defines the visual part of the call information window.
 type View interface {
-	ShowFrame(core.CallinfoFrame)
+	ShowFrame(core.VFOID, core.CallinfoFrame)
+	SetVFOEnabled(core.VFOID, bool)
 }
 
 type CallinfoFrameListener interface {
-	CallinfoFrameChanged(core.CallinfoFrame)
+	CallinfoFrameChanged(core.VFOID, core.CallinfoFrame)
 }
 
 type Callinfo struct {
@@ -61,8 +62,9 @@ type Callinfo struct {
 
 	theirExchangeFields []core.ExchangeField
 	qtcsEnabled         bool
+	vfo2Enabled         bool
 
-	frame core.CallinfoFrame
+	frames [core.VFOCount]core.CallinfoFrame
 }
 
 func New(entities DXCCFinder, callsigns CallsignFinder, callHistory CallHistoryFinder, dupeChecker DupeChecker, valuer Valuer, qtcProvider QTCProvider) *Callinfo {
@@ -85,6 +87,7 @@ func (c *Callinfo) SetView(view View) {
 	}
 
 	c.view = view
+	c.view.SetVFOEnabled(core.VFO2, c.vfo2Enabled)
 }
 
 func (c *Callinfo) StationChanged(station core.Station) {
@@ -110,13 +113,13 @@ func (c *Callinfo) Notify(listener any) {
 	c.listeners = append(c.listeners, listener)
 }
 
-func (c *Callinfo) emitFrameChanged() {
+func (c *Callinfo) emitFrameChanged(vfo core.VFOID) {
 	for _, listener := range c.listeners {
 		if l, ok := listener.(CallinfoFrameListener); ok {
-			l.CallinfoFrameChanged(c.frame)
+			l.CallinfoFrameChanged(vfo, c.frames[vfo])
 		}
 	}
-	c.view.ShowFrame(c.frame)
+	c.view.ShowFrame(vfo, c.frames[vfo])
 }
 
 func (c *Callinfo) GetInfo(call core.Callsign, band core.Band, mode core.Mode, currentExchange []string) core.Callinfo {
@@ -127,39 +130,42 @@ func (c *Callinfo) UpdateValue(info *core.Callinfo, band core.Band, mode core.Mo
 	return c.collector.UpdateValue(info, band, mode)
 }
 
-func (c *Callinfo) InputChanged(call string, band core.Band, mode core.Mode, currentExchange []string) {
+func (c *Callinfo) InputChanged(vfo core.VFOID, call string, band core.Band, mode core.Mode, currentExchange []string) {
 	normalizedCall := normalizeInput(call)
 
 	callinfo := c.collector.GetInfoForInput(normalizedCall, band, mode, currentExchange)
 	supercheck := c.supercheck.Calculate(normalizedCall, band, mode)
 
-	c.frame.NormalizedCallInput = normalizedCall
-	c.frame.DXCCEntity = callinfo.DXCCEntity
-	c.frame.Azimuth = callinfo.Azimuth
-	c.frame.Distance = callinfo.Distance
-	c.frame.UserInfo = callinfo.UserText
+	frame := &c.frames[vfo]
+	frame.NormalizedCallInput = normalizedCall
+	frame.DXCCEntity = callinfo.DXCCEntity
+	frame.Azimuth = callinfo.Azimuth
+	frame.Distance = callinfo.Distance
+	frame.UserInfo = callinfo.UserText
 
-	c.frame.Points = callinfo.Points
-	c.frame.Multis = callinfo.Multis
-	c.frame.Value = callinfo.Value
-	c.frame.SentQTCs = callinfo.SentQTCs
-	c.frame.ReceivedQTCs = callinfo.ReceivedQTCs
+	frame.Points = callinfo.Points
+	frame.Multis = callinfo.Multis
+	frame.Value = callinfo.Value
+	frame.SentQTCs = callinfo.SentQTCs
+	frame.ReceivedQTCs = callinfo.ReceivedQTCs
 
-	c.frame.PredictedExchange = callinfo.PredictedExchange
-	c.frame.Supercheck = supercheck
+	frame.PredictedExchange = callinfo.PredictedExchange
+	frame.Supercheck = supercheck
 
-	c.emitFrameChanged()
+	c.emitFrameChanged(vfo)
 }
 
+// EntryOnFrequency is driven by the bandmap, which is VFO1-only in this step. Updates VFO1's frame only.
 func (c *Callinfo) EntryOnFrequency(entry core.BandmapEntry, available bool) {
-	last := c.frame.CallsignOnFrequency.Callsign.String()
+	frame := &c.frames[core.VFO1]
+	last := frame.CallsignOnFrequency.Callsign.String()
 	if !available {
-		c.frame.CallsignOnFrequency = core.AnnotatedCallsign{}
-	} else if c.frame.CallsignOnFrequency.Callsign.String() == entry.Call.String() {
+		frame.CallsignOnFrequency = core.AnnotatedCallsign{}
+	} else if frame.CallsignOnFrequency.Callsign.String() == entry.Call.String() {
 		// go on
 	} else {
-		exactMatch := c.frame.NormalizedCallInput == entry.Call.String()
-		c.frame.CallsignOnFrequency = core.AnnotatedCallsign{
+		exactMatch := frame.NormalizedCallInput == entry.Call.String()
+		frame.CallsignOnFrequency = core.AnnotatedCallsign{
 			Callsign:          entry.Call,
 			Assembly:          core.MatchingAssembly{{OP: core.Matching, Value: entry.Call.String()}},
 			Duplicate:         entry.Info.Duplicate,
@@ -172,11 +178,17 @@ func (c *Callinfo) EntryOnFrequency(entry core.BandmapEntry, available bool) {
 		}
 	}
 
-	if last != c.frame.CallsignOnFrequency.Callsign.String() {
-		c.emitFrameChanged()
+	if last != frame.CallsignOnFrequency.Callsign.String() {
+		c.emitFrameChanged(core.VFO1)
 	}
 }
 
+// RadioChanged implements core.RadioChangedListener.
+func (c *Callinfo) RadioChanged(_ string, singleVFO bool) {
+	c.vfo2Enabled = !singleVFO
+	c.view.SetVFOEnabled(core.VFO2, c.vfo2Enabled)
+}
+
 func normalizeInput(input string) string {
 	return strings.TrimSpace(strings.ToUpper(input))
 }
@@ -186,4 +198,5 @@ type nullView struct{}
 func (v *nullView) Show()                                           {}
 func (v *nullView) Hide()                                           {}
 func (v *nullView) SetPredictedExchangeFields([]core.ExchangeField) {}
-func (v *nullView) ShowFrame(frame core.CallinfoFrame)              {}
+func (v *nullView) ShowFrame(core.VFOID, core.CallinfoFrame)        {}
+func (v *nullView) SetVFOEnabled(core.VFOID, bool)                  {}

core/cfg/cfg.go

@@ -43,6 +43,9 @@ var Default = &Data{
 			Type:    "tci",
 			Address: "localhost:40001",
 			Keyer:   "radio",
+			Options: map[string]string{
+				"single_vfo": "false",
+			},
 		},
 	},
 	Keyers: []core.Keyer{
@@ -154,6 +157,13 @@ var Default = &Data{
 		"entry.workmode_run":              "Ctrl+R",
 		"entry.offer_qtc":                 "F5",
 		"entry.request_qtc":               "F6",
+		"entry.toggle_focused_vfo":        "F8",
+		"entry.focus_vfo1":                "F9",
+		"entry.focus_vfo2":                "F10",
+		"entry.log_vfo1":                  "",
+		"entry.log_vfo2":                  "",
+		"entry.clear_vfo1":                "",
+		"entry.clear_vfo2":                "",
 		"radio.xit_active":                "Ctrl+Shift+X",
 		"bandmap.mark":                    "Ctrl+M",
 		"bandmap.goto_highest_value_spot": "Ctrl+Shift+N",