Merge branch 'podusowski:main' into add-provider

CHANGELOG.md

@@ -2,9 +2,11 @@
 
 All notable changes to this project will be documented in this file.
 
-## Unreleased
+## 0.23.0
 
+ * New functions in `MapMemory` for getting and setting the zoom level: `zoom` and `set_zoom`.
  * In-memory cache is now limited to 256 tiles. Previously it grew indefinitely.
+ * `TilesManager` trait is now called `Tiles` and `Tiles` struct is now called `HttpTiles`.
 
 ## 0.22.0
 

Cargo.toml

@@ -10,10 +10,10 @@ members = [
 resolver = "2"
 
 [workspace.package]
-version = "0.22.0"
+version = "0.23.0"
 
 [workspace.dependencies]
-image = "0.25"
+image = { version = "0.25", default-features = false }
 log = "0.4"
 egui = "0.27"
 egui_extras = { version = "0.27", features = ["svg"] }

demo/src/lib.rs

@@ -7,7 +7,7 @@ use std::collections::HashMap;
 
 use crate::plugins::ImagesPluginData;
 use egui::Context;
-use walkers::{HttpOptions, Map, MapMemory, Tiles, TilesManager};
+use walkers::{HttpOptions, HttpTiles, Map, MapMemory, Tiles};
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum Provider {
@@ -31,12 +31,12 @@ fn http_options() -> HttpOptions {
     }
 }
 
-fn providers(egui_ctx: Context) -> HashMap<Provider, Box<dyn TilesManager + Send>> {
-    let mut providers: HashMap<Provider, Box<dyn TilesManager + Send>> = HashMap::default();
+fn providers(egui_ctx: Context) -> HashMap<Provider, Box<dyn Tiles + Send>> {
+    let mut providers: HashMap<Provider, Box<dyn Tiles + Send>> = HashMap::default();
 
     providers.insert(
         Provider::OpenStreetMap,
-        Box::new(Tiles::with_options(
+        Box::new(HttpTiles::with_options(
             walkers::sources::OpenStreetMap,
             http_options(),
             egui_ctx.to_owned(),
@@ -45,7 +45,7 @@ fn providers(egui_ctx: Context) -> HashMap<Provider, Box<dyn TilesManager + Send
 
     providers.insert(
         Provider::Geoportal,
-        Box::new(Tiles::with_options(
+        Box::new(HttpTiles::with_options(
             walkers::sources::Geoportal,
             http_options(),
             egui_ctx.to_owned(),
@@ -65,7 +65,7 @@ fn providers(egui_ctx: Context) -> HashMap<Provider, Box<dyn TilesManager + Send
     if let Some(token) = mapbox_access_token {
         providers.insert(
             Provider::MapboxStreets,
-            Box::new(Tiles::with_options(
+            Box::new(HttpTiles::with_options(
                 walkers::sources::Mapbox {
                     style: walkers::sources::MapboxStyle::Streets,
                     access_token: token.to_string(),
@@ -77,7 +77,7 @@ fn providers(egui_ctx: Context) -> HashMap<Provider, Box<dyn TilesManager + Send
         );
         providers.insert(
             Provider::MapboxSatellite,
-            Box::new(Tiles::with_options(
+            Box::new(HttpTiles::with_options(
                 walkers::sources::Mapbox {
                     style: walkers::sources::MapboxStyle::Satellite,
                     access_token: token.to_string(),
@@ -93,7 +93,7 @@ fn providers(egui_ctx: Context) -> HashMap<Provider, Box<dyn TilesManager + Send
 }
 
 pub struct MyApp {
-    providers: HashMap<Provider, Box<dyn TilesManager + Send>>,
+    providers: HashMap<Provider, Box<dyn Tiles + Send>>,
     selected_provider: Provider,
     map_memory: MapMemory,
     images_plugin_data: ImagesPluginData,

demo/src/local_tiles.rs

@@ -3,7 +3,7 @@ use egui::Context;
 use walkers::sources::Attribution;
 use walkers::Texture;
 use walkers::TileId;
-use walkers::TilesManager;
+use walkers::Tiles;
 
 pub struct LocalTiles {
     egui_ctx: Context,
@@ -15,7 +15,7 @@ impl LocalTiles {
     }
 }
 
-impl TilesManager for LocalTiles {
+impl Tiles for LocalTiles {
     fn at(&mut self, _tile_id: TileId) -> Option<Texture> {
         let image = ColorImage::example();
 

demo_android/rust/Cargo.toml

@@ -6,7 +6,7 @@ publish = false
 
 [dependencies]
 log = "0.4"
-android_logger = "0.13"
+android_logger = "0.14"
 jni = "*"
 eframe = { workspace = true, features = ["wgpu", "android-game-activity"] }
 egui-winit.workspace = true

hypermocker/src/lib.rs

@@ -134,7 +134,7 @@ impl AnticipatedRequest {
         self.payload_tx.send(response).unwrap();
     }
 
-    /// Respond to this request with given status, and empty body.
+    /// Similar to [AnticipatedRequest], but with status and empty body.
     pub async fn respond_with_status(self, status: hyper::StatusCode) {
         log::info!(
             "Saving response (with status: {}) for '{}'.",

walkers/Cargo.toml

@@ -14,7 +14,7 @@ log.workspace = true
 egui.workspace = true
 egui_extras.workspace = true
 thiserror = "1"
-image = { version = "0.25", features = ["jpeg", "png"] }
+image = { version = "0.25", default-features = false, features = ["jpeg", "png"] }
 geo-types = { version = "0.7" }
 reqwest = { version = "0.11", default-features = false, features = [
     "rustls-tls",

walkers/README.md

@@ -1,6 +1,7 @@
 # Walkers, a map widget for Rust
 
 [![crates.io](https://img.shields.io/crates/v/walkers.svg)](https://crates.io/crates/walkers)
+[![docs.rs](https://img.shields.io/docsrs/walkers/latest)](https://docs.rs/walkers/latest/)
 
 Walkers is a slippy maps widget for [egui](https://github.com/emilk/egui), 
 similar to very popular [Leaflet](https://leafletjs.com/), but written in Rust.
@@ -22,19 +23,19 @@ such as OpenStreetMap and stores them in a cache, `MapMemory` keeps track of
 the widget's state and `Map` is the widget itself.
 
 ```rust
-use walkers::{Tiles, Map, MapMemory, Position, sources::OpenStreetMap};
+use walkers::{HttpTiles, Map, MapMemory, Position, sources::OpenStreetMap};
 use egui::{Context, CentralPanel};
 use eframe::{App, Frame};
 
 struct MyApp {
-    tiles: Tiles,
+    tiles: HttpTiles,
     map_memory: MapMemory,
 }
 
 impl MyApp {
     fn new(egui_ctx: Context) -> Self {
         Self {
-            tiles: Tiles::new(OpenStreetMap, egui_ctx),
+            tiles: HttpTiles::new(OpenStreetMap, egui_ctx),
             map_memory: MapMemory::default(),
         }
     }

walkers/src/download.rs

@@ -33,7 +33,11 @@ impl Default for HttpOptions {
     fn default() -> Self {
         Self {
             cache: None,
-            user_agent: HeaderValue::from_static("Walkers"),
+            user_agent: HeaderValue::from_static(concat!(
+                env!("CARGO_PKG_NAME"),
+                "/",
+                env!("CARGO_PKG_VERSION"),
+            )),
         }
     }
 }

walkers/src/lib.rs

@@ -15,5 +15,5 @@ mod zoom;
 pub use download::{HeaderValue, HttpOptions};
 pub use map::{Map, MapMemory, Plugin, Projector};
 pub use mercator::{screen_to_position, Position, TileId};
-pub use tiles::{Texture, Tiles, TilesManager};
+pub use tiles::{HttpTiles, Texture, Tiles};
 pub use zoom::InvalidZoom;

walkers/src/map.rs

@@ -7,7 +7,7 @@ use crate::{
     mercator::{screen_to_position, Pixels, PixelsExt, TileId},
     tiles,
     zoom::{InvalidZoom, Zoom},
-    Position, TilesManager,
+    Position, Tiles,
 };
 
 /// Plugins allow drawing custom shapes on the map. After implementing this trait for your type,
@@ -18,14 +18,14 @@ pub trait Plugin {
 }
 
 /// The actual map widget. Instances are to be created on each frame, as all necessary state is
-/// stored in [`TilesManager`] and [`MapMemory`].
+/// stored in [`Tiles`] and [`MapMemory`].
 ///
 /// # Examples
 ///
 /// ```
 /// # use walkers::{Map, Tiles, MapMemory, Position};
 ///
-/// fn update(ui: &mut egui::Ui, tiles: &mut Tiles, map_memory: &mut MapMemory) {
+/// fn update(ui: &mut egui::Ui, tiles: &mut dyn Tiles, map_memory: &mut MapMemory) {
 ///     ui.add(Map::new(
 ///         Some(tiles), // `None`, if you don't want to show any tiles.
 ///         map_memory,
@@ -34,7 +34,7 @@ pub trait Plugin {
 /// }
 /// ```
 pub struct Map<'a, 'b, 'c> {
-    tiles: Option<&'b mut dyn TilesManager>,
+    tiles: Option<&'b mut dyn Tiles>,
     memory: &'a mut MapMemory,
     my_position: Position,
     plugins: Vec<Box<dyn Plugin + 'c>>,
@@ -45,7 +45,7 @@ pub struct Map<'a, 'b, 'c> {
 
 impl<'a, 'b, 'c> Map<'a, 'b, 'c> {
     pub fn new(
-        tiles: Option<&'b mut dyn TilesManager>,
+        tiles: Option<&'b mut dyn Tiles>,
         memory: &'a mut MapMemory,
         my_position: Position,
     ) -> Self {
@@ -104,7 +104,7 @@ impl Projector {
         let projected_position = position.project(self.memory.zoom.into());
 
         // We need the precision of f64 here,
-        // since some "gaps" between tiles are noticable on large zoom levels (e.g. 16+)
+        // since some "gaps" between tiles are noticeable on large zoom levels (e.g. 16+)
         let zoom: f64 = self.memory.zoom.into();
 
         // We also need to know where the map center is.
@@ -290,6 +290,18 @@ impl MapMemory {
         self.zoom.zoom_out()
     }
 
+    /// Set exact zoom level
+    pub fn set_zoom(&mut self, zoom: f32) -> Result<(), InvalidZoom> {
+        self.center_mode = self.center_mode.clone().zero_offset(self.zoom.into());
+        self.zoom = Zoom::try_from(zoom)?;
+        Ok(())
+    }
+
+    /// Returns the current zoom level
+    pub fn zoom(&self) -> f32 {
+        self.zoom.into()
+    }
+
     /// Returns exact position if map is detached (i.e. not following `my_position`),
     /// `None` otherwise.
     pub fn detached(&self) -> Option<Position> {
@@ -316,7 +328,7 @@ fn flood_fill_tiles(
     tile_id: TileId,
     map_center_projected_position: Pixels,
     zoom: f64,
-    tiles: &mut dyn TilesManager,
+    tiles: &mut dyn Tiles,
     meshes: &mut HashMap<TileId, Option<Mesh>>,
 ) {
     // We need to make up the difference between integer and floating point zoom levels.

walkers/src/mercator.rs

@@ -116,7 +116,7 @@ pub struct TileId {
     pub y: u32,
 
     /// Zoom level, where 0 means no zoom.
-    /// See: https://wiki.openstreetmap.org/wiki/Zoom_levels
+    /// See: <https://wiki.openstreetmap.org/wiki/Zoom_levels>
     pub zoom: u8,
 }