fyne-ui: waterfall on/off toggle with CGo direct call and config persistence

- C side:
  - New ui_comm_set_waterfall() in ui_communication.c; set_waterfall
    command handler delegates to it.  Persists enabled state to
    mercury.ini so the choice survives restarts.
  - New mercury_ui_set_waterfall() bridge function, exposed to Go via
    CGo for direct access without the generic command dispatch.
  - Fixed the set_waterfall handler nesting (was inside the radio
    config block).
- Go side:
  - engineLink.SetWaterfall() calls the bridge directly (no websocket,
    no strcmp dispatch).  Stub (non-embedded) has a no-op fallback.
  - Waterfall toggle checkbox in Settings > Waterfall uses the direct
    CGo path when the embedded engine is active; remote links still
    fall back to sendWSCommand.
  - waterfallCard visibility bound to telemetry.Waterfall: when the
    engine reports waterfall disabled, the spectrum/waterfall card
    vanishes from the layout; toggling on brings it back.

Author: pedromessetti

gui_interface/fyne-ui/engine/mercury_bridge.c

@@ -172,3 +172,8 @@ int mercury_ui_get_input_channel(void)
 {
     return ui_comm_get_input_channel();
 }
+
+void mercury_ui_set_waterfall(bool enabled)
+{
+    ui_comm_set_waterfall(enabled);
+}

gui_interface/fyne-ui/engine/mercury_bridge.h

@@ -76,6 +76,9 @@ int mercury_ui_get_radio_list(ui_device_t *out, int max,
                               int *serial_speed);
 int mercury_ui_get_input_channel(void);
 
+/* Enable / disable waterfall/spectrum at runtime.  Saves to mercury.ini. */
+void mercury_ui_set_waterfall(bool enabled);
+
 #ifdef __cplusplus
 }
 #endif

gui_interface/fyne-ui/link_engine.go

@@ -255,6 +255,11 @@ func readRadioList() (RadioListEvent, bool) {
 	}, true
 }
 
+func (l *engineLink) SetWaterfall(enabled bool) {
+	cEn := C.bool(enabled)
+	C.mercury_ui_set_waterfall(cEn)
+}
+
 func (l *engineLink) Close() {}
 
 // statusFromC converts the engine's status struct into the UI's own type. This

gui_interface/fyne-ui/link_engine_stub.go

@@ -29,3 +29,5 @@ func (l *engineLink) Send(cmd Command) error {
 }
 
 func (l *engineLink) Close() {}
+
+func (l *engineLink) SetWaterfall(enabled bool) {}

gui_interface/fyne-ui/main.go

@@ -110,6 +110,7 @@ type uiBindings struct {
 	rxBytesText       *canvas.Text
 	spectrumCanvas    *canvas.Raster
 	waterfallCanvas   *canvas.Raster
+	waterfallCard     *widget.Card
 }
 
 func parseStatusMessage(payload []byte) (telemetryState, error) {
@@ -565,6 +566,13 @@ func main() {
 			}
 			bindings.txGainLabel.SetText(fmt.Sprintf("TX gain: %.1f dB", telemetry.TXGainDB))
 			bindings.txPeakLabel.SetText(fmt.Sprintf("TX peak: %.1f dBFS", telemetry.TXPeakDBFS))
+			if bindings.waterfallCard != nil {
+				if telemetry.Waterfall {
+					bindings.waterfallCard.Show()
+				} else {
+					bindings.waterfallCard.Hide()
+				}
+			}
 		})
 	}
 
@@ -907,6 +915,7 @@ func main() {
 		nil,
 		waterfallContent,
 	))
+	bindings.waterfallCard = spectrumCard
 
 	topPanel := container.NewVBox(
 		container.NewVBox(txCard, telemetryCard),
@@ -1002,6 +1011,24 @@ func main() {
 		}
 		paletteSelect.SetSelected(lowerToUpper[state.waterfallPalette])
 
+		enabledCheck := widget.NewCheck("Waterfall enabled", func(on bool) {
+			val := "on"
+			if !on {
+				val = "off"
+			}
+			if engLink, ok := state.link.(*engineLink); ok {
+				engLink.SetWaterfall(on)
+				appendLog(fmt.Sprintf("Waterfall turned %s.\n", val))
+				return
+			}
+			if err := sendWSCommand("set_waterfall", val, "", ""); err != nil {
+				appendLog(fmt.Sprintf("Failed to toggle waterfall: %v\n", err))
+			}
+		})
+		state.mu.RLock()
+		enabledCheck.SetChecked(state.telemetry.Waterfall)
+		state.mu.RUnlock()
+
 		applyBtn := widget.NewButton("Apply", func() {
 			sel := paletteSelect.Selected
 			if sel == "" {
@@ -1016,6 +1043,8 @@ func main() {
 		})
 
 		content := container.NewVBox(
+			enabledCheck,
+			widget.NewSeparator(),
 			container.NewGridWithColumns(2,
 				widget.NewLabel("Color Palette"), paletteSelect,
 			),

gui_interface/ui_communication.c

@@ -182,6 +182,11 @@ int ui_comm_handle_command(ui_ctx_t *ctx, const ws_command_t *cmd)
         if (ctx->cfg_path[0] && cfg_write(&ctx->cfg, ctx->cfg_path))
             HLOGI(UI_LOG_TAG, "Config saved to %s", ctx->cfg_path);
 
+    } else if (strcmp(cmd->command, "set_waterfall") == 0) {
+        bool enable = (strcmp(cmd->value, "off") != 0);
+        ui_comm_set_waterfall(enable);
+        HLOGI(UI_LOG_TAG, "Waterfall %s by UI command", enable ? "enabled" : "disabled");
+
     } else if (strcmp(cmd->command, "set_tx_gain") == 0) {
         /* value carries the dB string; clamp to plan range and convert to
          * linear before pushing to the modulator.  Persist to INI so the
@@ -205,6 +210,18 @@ int ui_comm_handle_command(ui_ctx_t *ctx, const ws_command_t *cmd)
     return 0;
 }
 
+void ui_comm_set_waterfall(bool enabled)
+{
+    ui_ctx_t *ctx = g_ui_ctx;
+    if (!ctx)
+        return;
+    modem_set_spectrum_enabled(enabled);
+    ctx->waterfall_enabled = enabled;
+    ctx->cfg.waterfall_enabled = enabled;
+    if (ctx->cfg_path[0] && cfg_write(&ctx->cfg, ctx->cfg_path))
+        HLOGI(UI_LOG_TAG, "Config saved to %s", ctx->cfg_path);
+}
+
 // ---------------- UI PUBLISHER THREAD ----------------
 // Periodically gathers modem/ARQ/network status and sends it to the UI.
 

gui_interface/ui_communication.h

@@ -127,6 +127,10 @@ int  ui_comm_handle_command(ui_ctx_t *ctx, const ws_command_t *cmd);
 int  ui_comm_command(const char *command, const char *value,
                      const char *value2, const char *value3);
 
+/* Enable / disable the waterfall/spectrum FFT pipeline at runtime.  Saves the
+ * choice to mercury.ini so it survives restarts. */
+void ui_comm_set_waterfall(bool enabled);
+
 /* Copy the most recent status snapshot.  False until the first publish. */
 bool ui_comm_get_status(ui_status_t *out);