summaryrefslogtreecommitdiff
path: root/include/mbgl/map/map_options.hpp
blob: 7fd17c2dff7cf7c266c9105f487fe38652f4d293 (plain)
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
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
#pragma once

#include <mbgl/map/mode.hpp>
#include <mbgl/util/geo.hpp>
#include <mbgl/util/size.hpp>

#include <memory>

namespace mbgl {

/**
 * @brief Holds values for Map options.
 */
class MapOptions final {
public:
    /**
     * @brief Constructs a MapOptions object with default values.
     */
    MapOptions();
    ~MapOptions();

    MapOptions(MapOptions&&) noexcept;

    /**
     * @brief Sets the map rendering mode. By default, it is set to Continuous
     * so the map will render as data arrives from the network and react
     * immediately to state changes.
     *
     * @param mode Map rendering mode.
     * @return MapOptions for chaining options together.
     */
    MapOptions& withMapMode(MapMode mode);

    /**
     * @brief Gets the previously set (or default) map mode.
     *
     * @return map mode.
     */
    MapMode mapMode() const;

    /**
     * @brief Sets the map constrain mode. This can be used to limit the map
     * to wrap around the globe horizontally. By default, it is set to
     * HeightOnly.
     *
     * @param mode Map constrain mode.
     * @return MapOptions for chaining options together.
     */
    MapOptions& withConstrainMode(ConstrainMode mode);

    /**
     * @brief Gets the previously set (or default) constrain mode.
     *
     * @return constrain mode.
     */
    ConstrainMode constrainMode() const;

    /**
     * @brief Sets the viewport mode. This can be used to flip the vertical
     * orientation of the map as some devices may use inverted orientation.
     *
     * @param mode Viewport mode.
     * @return MapOptions for chaining options together.
     */
    MapOptions& withViewportMode(ViewportMode mode);

    /**
     * @brief Gets the previously set (or default) viewport mode.
     *
     * @return viewport mode.
     */
    ViewportMode viewportMode() const;

    /**
     * @brief Specify whether to enable cross-source symbol collision detection
     * or not. By default, it is set to true.
     *
     * @param enableCollisions true to enable, false to disable
     * @return MapOptions for chaining options together.
     */
    MapOptions& withCrossSourceCollisions(bool enableCollisions);

    /**
     * @brief Gets the previously set (or default) crossSourceCollisions value.
     *
     * @return true if ecross-source symbol collision detection enabled,
     * false otherwise.
     */
    bool crossSourceCollisions() const;

    /**
     * @brief Specify whether render data for layers, sources and images should be kept between renderStill() calls.
     *
     * This flag is ignored in Continuous mode. In Static mode and Tile mode, if this flag is set to false, all the data
     * are created from scratch for every renderStill() call, which guaranties that no extra memory is used, however it
     * might cause higher CPU load and network traffic.
     *
     * By default, it is set to true.
     *
     * @param keepRenderData true to enable, false to disable
     * @return MapOptions for chaining options together.
     */
    MapOptions& withKeepRenderData(bool keepRenderData);

    /**
     * @brief Gets the previously set (or default) keepRenderData value.
     *
     * @return true if render data is kept between renderStill() calls,
     * false otherwise.
     */
    bool keepRenderData() const;

    /**
     * @brief Sets the orientation of the Map. By default, it is set to
     * Upwards.
     *
     * @param orientation Orientation of the Map.
     * @return reference to MapOptions for chaining options together.
     */
    MapOptions& withNorthOrientation(NorthOrientation orientation);

    /**
     * @brief Gets the previously set (or default) orientation.
     *
     * @return Map orientation.
     */
    NorthOrientation northOrientation() const;

    /**
     * @brief Sets the size to resize the map object and renderer backend.
     *
     * @param size_ A size given in logical pixels.
     * @return reference to MapOptions for chaining options together.
     */
    MapOptions& withSize(Size size_);

    /**
     * @brief Gets the previously set size.
     *
     * @return Size.
     */
    Size size() const;

    /**
     * @brief Sets the custom pixel ratio. By default, it is set to 1.
     *
     * @param ratio Pixel ratio value.
     * @return reference to MapOptions for chaining options together.
     */
    MapOptions& withPixelRatio(float ratio);

    /**
     * @brief Gets the previously set (or default) pixel ratio value.
     *
     * @return pixel ratio value.
     */
    float pixelRatio() const;

private:
    class Impl;
    std::unique_ptr<Impl> impl_;
};

}  // namespace mbgl