feat(radar): add radar minimap overlay to the Distance/Bearings frame

src/graphics/Screen.cpp

@@ -2164,6 +2164,12 @@ int Screen::handleInputEvent(const InputEvent *event)
                            this->ui->getUiState()->currentFrame >= framesetInfo.positions.firstFavorite &&
                            this->ui->getUiState()->currentFrame <= framesetInfo.positions.lastFavorite) {
                     menuHandler::favoriteBaseMenu();
+                } else if (this->ui->getUiState()->currentFrame == framesetInfo.positions.nodelist_location &&
+                           uiconfig.bearings_view_radar) {
+                    // Bearings/distance frame is being drawn as a radar — use the
+                    // radar-specific options menu (zoom, heading, favorites filter,
+                    // Tracking View picker).
+                    menuHandler::radarBearingsMenu();
                 } else if (this->ui->getUiState()->currentFrame == framesetInfo.positions.nodelist_nodes ||
                            this->ui->getUiState()->currentFrame == framesetInfo.positions.nodelist_location ||
                            this->ui->getUiState()->currentFrame == framesetInfo.positions.nodelist_lastheard ||

src/graphics/draw/MenuHandler.cpp

@@ -14,6 +14,7 @@
 #include "graphics/SharedUIDisplay.h"
 #include "graphics/TFTColorRegions.h"
 #include "graphics/draw/MessageRenderer.h"
+#include "graphics/draw/RadarRenderer.h"
 #include "graphics/draw/UIRenderer.h"
 #include "input/RotaryEncoderInterruptImpl1.h"
 #include "input/UpDownInterruptImpl1.h"
@@ -556,6 +557,57 @@ void menuHandler::showConfirmationBanner(const char *message, std::function<void
     screen->showOverlayBanner(confirmBanner);
 }
 
+// Where trackingViewPicker should return when the user picks "Back".  Set by
+// the calling menu (nodeListMenu or radarBearingsMenu) just before queueing
+// the picker, so back behaves like the Clock Face → Clock Menu flow.
+static menuHandler::screenMenus s_trackingViewPickerReturn = menuHandler::MenuNone;
+
+void menuHandler::setTrackingViewPickerReturn(screenMenus target)
+{
+    s_trackingViewPickerReturn = target;
+}
+
+void menuHandler::trackingViewPicker()
+{
+    // Mirrors clockFacePicker: pick which view the bearings/distance frame
+    // shows.  Stored in uiconfig.bearings_view_radar (false=Bearings list,
+    // true=Radar overlay).
+    static const ClockFaceOption trackingOptions[] = {
+        {"Back", OptionsAction::Back},
+        {"Bearings", OptionsAction::Select, false},
+        {"Radar", OptionsAction::Select, true},
+    };
+
+    constexpr size_t trackingCount = sizeof(trackingOptions) / sizeof(trackingOptions[0]);
+    static std::array<const char *, trackingCount> trackingLabels{};
+
+    auto bannerOptions = createStaticBannerOptions("Tracking View?", trackingOptions, trackingLabels,
+                                                   [](const ClockFaceOption &option, int) -> void {
+                                                       if (option.action == OptionsAction::Back) {
+                                                           menuHandler::menuQueue = s_trackingViewPickerReturn;
+                                                           if (s_trackingViewPickerReturn != MenuNone)
+                                                               screen->runNow();
+                                                           return;
+                                                       }
+
+                                                       if (!option.hasValue) {
+                                                           return;
+                                                       }
+
+                                                       if (uiconfig.bearings_view_radar == option.value) {
+                                                           return;
+                                                       }
+
+                                                       uiconfig.bearings_view_radar = option.value;
+                                                       menuHandler::saveUIConfig();
+                                                       screen->setFrames(Screen::FOCUS_PRESERVE);
+                                                       screen->runNow();
+                                                   });
+
+    bannerOptions.InitialSelected = uiconfig.bearings_view_radar ? 2 : 1;
+    screen->showOverlayBanner(bannerOptions);
+}
+
 void menuHandler::clockFacePicker()
 {
     static const ClockFaceOption clockFaceOptions[] = {
@@ -1350,7 +1402,7 @@ void menuHandler::positionBaseMenu()
         CompassCalibrate,
         GPSSmartPosition,
         GPSUpdateInterval,
-        GPSPositionBroadcast
+        GPSPositionBroadcast,
     };
 
     static const PositionMenuOption baseOptions[] = {
@@ -1445,16 +1497,72 @@ void menuHandler::positionBaseMenu()
     screen->showOverlayBanner(bannerOptions);
 }
 
+void menuHandler::radarBearingsMenu()
+{
+    enum optionsNumbers { Back, TrackingView, ToggleHeading, ToggleFavorites, ZoomIn, ZoomOut };
+    static const char *optionsArray[] = {
+        "Back",    "Tracking View",
+        nullptr, // ToggleHeading — filled dynamically below
+        nullptr, // ToggleFavorites — filled dynamically below
+        "Zoom In", "Zoom Out",
+    };
+    static int optionsEnumArray[] = {Back, TrackingView, ToggleHeading, ToggleFavorites, ZoomIn, ZoomOut};
+
+    optionsArray[ToggleHeading] = graphics::RadarRenderer::isNorthUp() ? "Switch to HDG-UP" : "Switch to N-UP";
+    optionsArray[ToggleFavorites] = uiconfig.radar_favorites_only ? "Show: All Nodes" : "Show: Favorites Only";
+
+    BannerOverlayOptions bannerOptions;
+    bannerOptions.message = "Radar Options";
+    bannerOptions.optionsArrayPtr = optionsArray;
+    bannerOptions.optionsCount = sizeof(optionsEnumArray) / sizeof(optionsEnumArray[0]);
+    bannerOptions.optionsEnumPtr = optionsEnumArray;
+
+    bannerOptions.bannerCallback = [](int selected) -> void {
+        if (selected == Back) {
+            screen->setFrames(Screen::FOCUS_PRESERVE);
+        } else if (selected == TrackingView) {
+            // Radar bearings menu has no enum value (invoked directly from input
+            // handler), so back from the picker just dismisses to the screen.
+            setTrackingViewPickerReturn(MenuNone);
+            menuQueue = TrackingViewPicker;
+            screen->runNow();
+        } else if (selected == ToggleHeading) {
+            graphics::RadarRenderer::toggleNorthUp();
+            screen->setFrames(Screen::FOCUS_PRESERVE);
+            screen->runNow();
+        } else if (selected == ToggleFavorites) {
+            uiconfig.radar_favorites_only = !uiconfig.radar_favorites_only;
+            menuHandler::saveUIConfig();
+            screen->setFrames(Screen::FOCUS_PRESERVE);
+            screen->runNow();
+        } else if (selected == ZoomIn) {
+            graphics::RadarRenderer::zoomIn();
+            screen->setFrames(Screen::FOCUS_PRESERVE);
+            screen->runNow();
+        } else if (selected == ZoomOut) {
+            graphics::RadarRenderer::zoomOut();
+            screen->setFrames(Screen::FOCUS_PRESERVE);
+            screen->runNow();
+        }
+    };
+    screen->showOverlayBanner(bannerOptions);
+}
+
 void menuHandler::nodeListMenu()
 {
-    enum optionsNumbers { Back, NodePicker, TraceRoute, Verify, Reset, NodeNameLength, enumEnd };
+    enum optionsNumbers { Back, NodePicker, TrackingView, TraceRoute, Verify, Reset, NodeNameLength, enumEnd };
     static const char *optionsArray[enumEnd] = {"Back"};
     static int optionsEnumArray[enumEnd] = {Back};
     int options = 1;
 
     optionsArray[options] = "Node Actions / Settings";
     optionsEnumArray[options++] = NodePicker;
 
+#if HAS_GPS
+    optionsArray[options] = "Tracking View";
+    optionsEnumArray[options++] = TrackingView;
+#endif
+
     if (currentResolution != ScreenResolution::UltraLow) {
         optionsArray[options] = "Show Long/Short Name";
         optionsEnumArray[options++] = NodeNameLength;
@@ -1471,6 +1579,10 @@ void menuHandler::nodeListMenu()
         if (selected == NodePicker) {
             menuQueue = NodePickerMenu;
             screen->runNow();
+        } else if (selected == TrackingView) {
+            setTrackingViewPickerReturn(NodeBaseMenu);
+            menuQueue = TrackingViewPicker;
+            screen->runNow();
         } else if (selected == Reset) {
             menuQueue = ResetNodeDbMenu;
             screen->runNow();
@@ -2781,6 +2893,9 @@ void menuHandler::handleMenuSwitch(OLEDDisplay *display)
     case ClockMenu:
         clockMenu();
         break;
+    case TrackingViewPicker:
+        trackingViewPicker();
+        break;
     case SystemBaseMenu:
         systemBaseMenu();
         break;

src/graphics/draw/MenuHandler.h

@@ -19,6 +19,7 @@ class menuHandler
         TwelveHourPicker,
         ClockFacePicker,
         ClockMenu,
+        TrackingViewPicker,
         PositionBaseMenu,
         NodeBaseMenu,
         GpsToggleMenu,
@@ -75,6 +76,11 @@ class menuHandler
     static void TZPicker();
     static void twelveHourPicker();
     static void clockFacePicker();
+    static void trackingViewPicker();
+    // Set the menu to re-open when the user picks "Back" from trackingViewPicker.
+    // Caller invokes this immediately before queueing TrackingViewPicker so the
+    // picker can return to its actual parent menu (or MenuNone to dismiss).
+    static void setTrackingViewPickerReturn(screenMenus target);
     static void messageResponseMenu();
     static void messageViewModeMenu();
     static void replyMenu();
@@ -93,6 +99,7 @@ class menuHandler
     static void BuzzerModeMenu();
     static void switchToMUIMenu();
     static void nodeListMenu();
+    static void radarBearingsMenu();
     static void resetNodeDBMenu();
     static void BrightnessPickerMenu();
     static void rebootMenu();

src/graphics/draw/NodeListRenderer.cpp

@@ -3,6 +3,7 @@
 #include "CompassRenderer.h"
 #include "NodeDB.h"
 #include "NodeListRenderer.h"
+#include "RadarRenderer.h"
 #if !MESHTASTIC_EXCLUDE_STATUS
 #include "modules/StatusMessageModule.h"
 #endif
@@ -831,6 +832,18 @@ void drawDynamicListScreen_Location(OLEDDisplay *display, OLEDDisplayUiState *st
         lastSwitchTime = now;
     }
 #endif
+
+    // === Radar overlay mode ===
+    // When bearings_view_radar is enabled (toggled via long-press menu →
+    // Tracking View), the bearings/distance frame is replaced by the
+    // circular radar minimap.
+    if (uiconfig.bearings_view_radar) {
+        // RadarRenderer draws its own BT/API icon at the end of the overlay
+        // (without the full-width black wipe drawCommonFooter performs), so
+        // the radar arc and last list row stay intact when BT is connected.
+        graphics::RadarRenderer::drawRadarOverlay(display, x, y);
+        return;
+    }
     // On very first call (on boot or state enter)
     if (lastRenderedMode == MODE_COUNT_LOCATION) {
         currentMode_Location = MODE_DISTANCE;