Struct MapWidget 

#[repr(C)]
pub struct MapWidget {
    pub layer: MapTileLayer,
    pub viewport: MapViewport,
    pub container_style: CssPropertyWithConditionsVec,
    pub on_viewport_changed: OptionMapViewportChanged,
    pub on_pin_tap: OptionMapPinTap,
}

Fields

layer: MapTileLayer

viewport: MapViewport

container_style: CssPropertyWithConditionsVec

on_viewport_changed: OptionMapViewportChanged

Optional hook fired when the user pans / zooms (effects / persist the viewport). FFI-exposed; re-set on each fresh build.

on_pin_tap: OptionMapPinTap

Optional hook fired when the user taps the map, with the tapped lat/lon. FFI-exposed; re-set on each fresh build.

Implementations

impl MapWidget

pub fn create(layer: MapTileLayer) -> Self

pub fn with_viewport(self, viewport: MapViewport) -> Self

pub fn with_container_style(self, css: CssPropertyWithConditionsVec) -> Self

pub fn set_on_viewport_changed<C: Into<MapViewportChangedCallback>>( &mut self, data: RefAny, callback: C, )

Set a hook fired when the user pans / zooms the map. The map owns its own pan/pinch state; this lets your app observe or persist the resulting MapViewport. The backreference DI pattern (architecture.md).

pub fn with_on_viewport_changed<C: Into<MapViewportChangedCallback>>( self, data: RefAny, callback: C, ) -> Self

Builder form of set_on_viewport_changed.

pub fn set_on_pin_tap<C: Into<MapPinTapCallback>>( &mut self, data: RefAny, callback: C, )

Set a hook fired when the user taps the map (a press + release at ~the same point, no drag), with the tapped lat/lon. The backreference DI pattern (architecture.md).

pub fn with_on_pin_tap<C: Into<MapPinTapCallback>>( self, data: RefAny, callback: C, ) -> Self

Builder form of set_on_pin_tap.

pub fn latlon_at_px( viewport: MapViewport, px: LogicalPosition, container: LogicalSize, ) -> MapLatLon

Project a screen pixel px (relative to the map node’s top-left, in a node of size container) to a lat/lon on the map at viewport. Small- angle Mercator (accurate at city zooms). Inverse of px_at_latlon. Exposed so apps don’t reimplement the projection (e.g. to drop a pin where the user tapped).

pub fn px_at_latlon( viewport: MapViewport, coord: MapLatLon, container: LogicalSize, ) -> LogicalPosition

Inverse of latlon_at_px: where coord lands in container pixels at viewport.

pub fn dom(self) -> Dom

Construct the rendered Dom. The returned Dom is a single <div> with:

• A MapTileCache RefAny dataset (initialised from this widget’s viewport + layer).
• A DatasetMergeCallback so the cache survives relayout.
• A VirtualView child that re-renders the visible-tile grid on bounds change.
• Mouse-down / mouse-move / mouse-up callbacks that pan the viewport while a drag is active (the widget owns the pan state via MapTileCache::drag_anchor, so user code doesn’t have to wire anything).
• Pinch callbacks that zoom in / out.

No tile-fetch worker is wired — tiles render as placeholders. Use dom_with_fetch to supply one.

pub fn dom_with_fetch(self, cb: ThreadCallback) -> Dom

Like dom, but wires a tile-fetch worker thread. cb runs on a framework Thread per visible tile: it reads the TileFetchInit, fetches + decodes, then sender.send(ThreadReceiveMsg::WriteBack(...)) a TileReadyMsg targeting map_tile_writeback. The standard worker is azul_dll::desktop::extra::map::tile_fetch_worker; wrap it in a ThreadCallback to pass it here. See the recipe in MOBILE_SESSION_LOG.md.

Trait Implementations

impl Clone for MapWidget

fn clone(&self) -> MapWidget

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for MapWidget

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for MapWidget

fn eq(&self, other: &MapWidget) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for MapWidget