map_view.hpp

// SPDX-FileCopyrightText: 2026 Mark G. Russell
// SPDX-License-Identifier: MIT
 
#pragma once
 
#include "map_feature_hover.hpp"
#include <mbgl/map/map.hpp>
#include <mbgl/util/run_loop.hpp>
#include <mbgl/util/timer.hpp>
 
#include <cstddef>
#include <functional>
#include <memory>
#include <string>
#include <vector>
 
struct GLFWwindow;
class GLFWBackend;
class MapRendererFrontend;
 
namespace mbgl { namespace gfx { class RendererBackend; } }
 
struct CachedPoiResult {
    std::string id;
    std::string name;
    std::string category;
    std::string brand;
    std::string sourceClass;
    std::string sourceSubclass;
    double latitude = 0.0;
    double longitude = 0.0;
};
 
struct InteractivePoiMarker {
    std::size_t index = 0;
    std::string id;
    double left = 0.0;
    double top = 0.0;
    double right = 0.0;
    double bottom = 0.0;
 
    bool contains(double x, double y) const {
        return x >= left && x <= right && y >= top && y <= bottom;
    }
};
 
struct PoiSearchResult {
    int count = 0;
    double south = 0.0;
    double west = 0.0;
    double north = 0.0;
    double east = 0.0;
};
 
class MapView : public mbgl::MapObserver {
public:
    using ManualCameraCallback = std::function<void()>;
    using MapClickCallback = std::function<void(
        double, double, double, const std::string&, std::size_t)>;
 
    using PoiSelectedCallback = std::function<void(
        const std::string& name,
        const std::string& brand,
        const std::string& sourceClass,
        const std::string& sourceSubclass,
        double latitude,
        double longitude)>;
 
    MapView(const mbgl::ResourceOptions& resourceOptions, const mbgl::ClientOptions& clientOptions);
    ~MapView() override;
    float getPixelRatio() const;
    mbgl::Size getSize() const;
    mbgl::gfx::RendererBackend& getRendererBackend();
    void setMap(mbgl::Map* map);
    void setRendererFrontend(MapRendererFrontend* rendererFrontend);
    void run();
    void invalidate();
    void showWindow();
    void finishCameraGesture();
    void setShouldClose();
    void onWillStartRenderingFrame() override;
 
    void onDidFailLoadingMap(mbgl::MapLoadError error, const std::string& message) override;
 
    void onTileAction(
        mbgl::TileOperation operation,
        const mbgl::OverscaledTileID& tileId,
        const std::string& sourceId
    ) override;
 
    void setUpdateCallback(std::function<void()> callback);
    void setPoiSelectedCallback(PoiSelectedCallback callback);
    void setManualCameraCallback(ManualCameraCallback callback);
    void setMapClickCallback(MapClickCallback callback);
    void setPoiResultsJson(const std::string& geojson);
    void setCityWeatherJson(const std::string& geojson);
    std::string searchWeatherCities() const;
    PoiSearchResult searchVisiblePois(const std::string& category) const;
 
private:
    static void onWindowResize(GLFWwindow* window, int width, int height);
    static void onFramebufferResize(GLFWwindow* window, int width, int height);
    static void onScroll(GLFWwindow* window, double xOffset, double yOffset);
    static void onWindowFocus(GLFWwindow* window, int focused);
    static void onMouseClick(GLFWwindow* window, int button, int action, int modifiers);
    static void onMouseMove(GLFWwindow* window, double x, double y);
    static void onCursorEnter(GLFWwindow* window, int entered);
    void updateMapHover();
    void publishCityWeatherHover();
    void publishPoiHover();
    void clearMapHover();
    std::vector<InteractivePoiMarker> interactivePoiMarkers() const;
    void render();
 
    mbgl::Map* map = nullptr;
    MapRendererFrontend* rendererFrontend = nullptr;
    std::unique_ptr<GLFWBackend> backend;
    GLFWwindow* window = nullptr;
    int width = 1024;
    int height = 600;
    float pixelRatio = 1.0f;
    double lastX = 0.0;
    double lastY = 0.0;
    double pressX = 0.0;
    double pressY = 0.0;
    double lastClick = -1.0;
    bool tracking = false;
    bool manualGesturePublished = false;
    bool dirty = false;
    mbgl::util::RunLoop runLoop;
    mbgl::util::Timer frameTick;
    std::function<void()> updateCallback;
    PoiSelectedCallback poiSelectedCallback;
    ManualCameraCallback manualCameraCallback;
    MapClickCallback mapClickCallback;
    std::vector<CachedPoiResult> poiResults;
    MapFeatureHover cityWeatherHover;
    MapFeatureHover poiHover{"id", "", "poi_hover"};
    bool pointerInside = false;
    double lastHoverCheck = -1.0;
};