maplibre_native 0.8.2

Rust bindings to the MapLibre Native map rendering engine
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

#pragma once

#include "rust/cxx.h"
#include <mbgl/map/map_observer.hpp>
#include <memory>
#include <optional>

namespace mln {
namespace bridge {

    // Forward declarations
    using MapObserverCameraChangeMode = mbgl::MapObserver::CameraChangeMode; // Required, because enum nested in class is not supported by cxx

    struct VoidCallback;
    void void_callback(VoidCallback const& callback) noexcept;

    struct FailingLoadingMapCallback;
    void failing_loading_map_callback(FailingLoadingMapCallback const& callback, mbgl::MapLoadError error, const rust::Str what) noexcept;

    struct CameraDidChangeCallback;
    void camera_did_change_callback(CameraDidChangeCallback const& callback, MapObserverCameraChangeMode mode) noexcept;

    struct FinishRenderingFrameCallback;
    void finish_rendering_frame_callback(FinishRenderingFrameCallback const& callback, bool needsRepaint, bool placementChanged) noexcept;

    class MapObserver: public mbgl::MapObserver {
        public:
            void setWillStartLoadingMapCallback(rust::Box<VoidCallback> callback) const {
                willStartLoadingMapCallback = std::optional<rust::Box<VoidCallback>>{std::move(callback)};
            }

            void setFinishLoadingStyleCallback(rust::Box<VoidCallback> callback) const {
                finishLoadingStyleCallback = std::optional<rust::Box<VoidCallback>>{std::move(callback)};
            }

            void setBecomeIdleCallback(rust::Box<VoidCallback> callback) const {
                becomeIdleCallback = std::optional<rust::Box<VoidCallback>>{std::move(callback)};
            }

            void setFailLoadingMapCallback(rust::Box<FailingLoadingMapCallback> callback) const {
                failLoadingMapCallback = std::optional<rust::Box<FailingLoadingMapCallback>>{std::move(callback)};
            }

            void setFinishRenderingFrameCallback(rust::Box<FinishRenderingFrameCallback> callback) const {
                finishRenderingFrameCallback = std::optional<rust::Box<FinishRenderingFrameCallback>>{std::move(callback)};
            }

            void setCameraDidChangeCallback(rust::Box<CameraDidChangeCallback> callback) const {
                cameraDidChangeCallback = std::optional<rust::Box<CameraDidChangeCallback>>{std::move(callback)};
            }

        private:
            void onWillStartLoadingMap() override {
                if (willStartLoadingMapCallback.has_value()) {
                    void_callback(*(*willStartLoadingMapCallback));
                }
            }
            void onDidFinishLoadingStyle() override {
                if (finishLoadingStyleCallback.has_value()) {
                    void_callback(*(*finishLoadingStyleCallback));
                }
            }
            void onDidBecomeIdle() override {
                if (becomeIdleCallback.has_value()) {
                    void_callback(*(*becomeIdleCallback));
                }
            }

            void onDidFailLoadingMap(mbgl::MapLoadError error, const std::string& what) override {
                if (failLoadingMapCallback.has_value()) {
                    failing_loading_map_callback(*(*failLoadingMapCallback), error, what);
                }
            }

            void onCameraDidChange(MapObserverCameraChangeMode mode) override {
                if (cameraDidChangeCallback.has_value()) {
                    camera_did_change_callback(*(*cameraDidChangeCallback), mode);
                }
            }
            // void onSourceChanged(mbgl::style::Source&) override;

            void onDidFinishRenderingFrame(const mbgl::MapObserver::RenderFrameStatus& status) override {
                if (finishRenderingFrameCallback.has_value()) {
                    finish_rendering_frame_callback(*(*finishRenderingFrameCallback), status.needsRepaint, status.placementChanged);
                }
            }

        private:
            mutable std::optional<rust::Box<VoidCallback>> willStartLoadingMapCallback;
            mutable std::optional<rust::Box<VoidCallback>> finishLoadingStyleCallback;
            mutable std::optional<rust::Box<VoidCallback>> becomeIdleCallback;
            mutable std::optional<rust::Box<FailingLoadingMapCallback>> failLoadingMapCallback;
            mutable std::optional<rust::Box<CameraDidChangeCallback>> cameraDidChangeCallback;
            mutable std::optional<rust::Box<FinishRenderingFrameCallback>> finishRenderingFrameCallback;
    };

} // namespace bridge
} // namespace mln