libshumate_sys/

lib.rs

// Generated by gir (https://github.com/gtk-rs/gir @ b3d444a058cf)
// from
// from gir-files (https://github.com/gtk-rs/gir-files.git @ 5c1e490fe50a)
// DO NOT EDIT

#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)]
#![allow(
    clippy::approx_constant,
    clippy::type_complexity,
    clippy::unreadable_literal,
    clippy::upper_case_acronyms
)]
#![cfg_attr(docsrs, feature(doc_cfg))]

use gdk_pixbuf_sys as gdk_pixbuf;
use gdk_sys as gdk;
use gio_sys as gio;
use glib_sys as glib;
use gobject_sys as gobject;
use gtk_sys as gtk;

#[cfg(unix)]
#[allow(unused_imports)]
use libc::{dev_t, gid_t, pid_t, socklen_t, uid_t};
#[allow(unused_imports)]
use libc::{intptr_t, off_t, size_t, ssize_t, time_t, uintptr_t, FILE};
#[allow(unused_imports)]
use std::ffi::{
    c_char, c_double, c_float, c_int, c_long, c_short, c_uchar, c_uint, c_ulong, c_ushort, c_void,
};

#[allow(unused_imports)]
use glib::{gboolean, gconstpointer, gpointer, GType};

// Enums
pub type ShumateFileCacheError = c_int;
pub const SHUMATE_FILE_CACHE_ERROR_FAILED: ShumateFileCacheError = 0;

pub type ShumateGeometryType = c_int;
pub const SHUMATE_GEOMETRY_TYPE_UNKNOWN: ShumateGeometryType = 0;
pub const SHUMATE_GEOMETRY_TYPE_POINT: ShumateGeometryType = 1;
pub const SHUMATE_GEOMETRY_TYPE_MULTIPOINT: ShumateGeometryType = 2;
pub const SHUMATE_GEOMETRY_TYPE_LINESTRING: ShumateGeometryType = 3;
pub const SHUMATE_GEOMETRY_TYPE_MULTILINESTRING: ShumateGeometryType = 4;
pub const SHUMATE_GEOMETRY_TYPE_POLYGON: ShumateGeometryType = 5;
pub const SHUMATE_GEOMETRY_TYPE_MULTIPOLYGON: ShumateGeometryType = 6;

pub type ShumateMapProjection = c_int;
pub const SHUMATE_MAP_PROJECTION_MERCATOR: ShumateMapProjection = 0;

pub type ShumateState = c_int;
pub const SHUMATE_STATE_NONE: ShumateState = 0;
pub const SHUMATE_STATE_LOADING: ShumateState = 1;
pub const SHUMATE_STATE_LOADED: ShumateState = 2;
pub const SHUMATE_STATE_DONE: ShumateState = 3;

pub type ShumateStyleError = c_int;
pub const SHUMATE_STYLE_ERROR_FAILED: ShumateStyleError = 0;
pub const SHUMATE_STYLE_ERROR_MALFORMED_STYLE: ShumateStyleError = 1;
pub const SHUMATE_STYLE_ERROR_UNSUPPORTED_LAYER: ShumateStyleError = 2;
pub const SHUMATE_STYLE_ERROR_INVALID_EXPRESSION: ShumateStyleError = 3;
pub const SHUMATE_STYLE_ERROR_SUPPORT_OMITTED: ShumateStyleError = 4;
pub const SHUMATE_STYLE_ERROR_UNSUPPORTED: ShumateStyleError = 5;

pub type ShumateTileDownloaderError = c_int;
pub const SHUMATE_TILE_DOWNLOADER_ERROR_FAILED: ShumateTileDownloaderError = 0;
pub const SHUMATE_TILE_DOWNLOADER_ERROR_BAD_RESPONSE: ShumateTileDownloaderError = 1;
pub const SHUMATE_TILE_DOWNLOADER_ERROR_COULD_NOT_CONNECT: ShumateTileDownloaderError = 2;
pub const SHUMATE_TILE_DOWNLOADER_ERROR_MALFORMED_URL: ShumateTileDownloaderError = 3;
pub const SHUMATE_TILE_DOWNLOADER_ERROR_OFFLINE: ShumateTileDownloaderError = 4;

pub type ShumateUnit = c_int;
pub const SHUMATE_UNIT_BOTH: ShumateUnit = 0;
pub const SHUMATE_UNIT_METRIC: ShumateUnit = 1;
pub const SHUMATE_UNIT_IMPERIAL: ShumateUnit = 2;

// Constants
pub const SHUMATE_MAJOR_VERSION: c_int = 1;
pub const SHUMATE_MAP_SOURCE_MFF_RELIEF: &[u8] = b"mff-relief\0";
pub const SHUMATE_MAP_SOURCE_OSM_CYCLE_MAP: &[u8] = b"osm-cyclemap\0";
pub const SHUMATE_MAP_SOURCE_OSM_MAPNIK: &[u8] = b"osm-mapnik\0";
pub const SHUMATE_MAP_SOURCE_OSM_TRANSPORT_MAP: &[u8] = b"osm-transportmap\0";
pub const SHUMATE_MAP_SOURCE_OWM_CLOUDS: &[u8] = b"owm-clouds\0";
pub const SHUMATE_MAP_SOURCE_OWM_PRECIPITATION: &[u8] = b"owm-precipitation\0";
pub const SHUMATE_MAP_SOURCE_OWM_PRESSURE: &[u8] = b"owm-pressure\0";
pub const SHUMATE_MAP_SOURCE_OWM_TEMPERATURE: &[u8] = b"owm-temperature\0";
pub const SHUMATE_MAP_SOURCE_OWM_WIND: &[u8] = b"owm-wind\0";
pub const SHUMATE_MAX_LATITUDE: c_double = 85.0511287798;
pub const SHUMATE_MAX_LONGITUDE: c_double = 180.0;
pub const SHUMATE_MIN_LATITUDE: c_double = -85.0511287798;
pub const SHUMATE_MIN_LONGITUDE: c_double = -180.0;

// Callbacks
pub type ShumateVectorSpriteFallbackFunc = Option<
    unsafe extern "C" fn(
        *mut ShumateVectorSpriteSheet,
        *const c_char,
        c_double,
        gpointer,
    ) -> *mut ShumateVectorSprite,
>;

// Records
#[derive(Copy, Clone)]
#[repr(C)]
pub struct ShumateCompassClass {
    pub parent_class: gtk::GtkWidgetClass,
}

impl ::std::fmt::Debug for ShumateCompassClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ShumateCompassClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct ShumateCoordinateClass {
    pub parent_class: gobject::GInitiallyUnownedClass,
    pub padding: [gpointer; 16],
}

impl ::std::fmt::Debug for ShumateCoordinateClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ShumateCoordinateClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct ShumateDataSourceClass {
    pub parent_class: gobject::GObjectClass,
    pub get_tile_data_async: Option<
        unsafe extern "C" fn(
            *mut ShumateDataSource,
            c_int,
            c_int,
            c_int,
            *mut gio::GCancellable,
            gio::GAsyncReadyCallback,
            gpointer,
        ),
    >,
    pub get_tile_data_finish: Option<
        unsafe extern "C" fn(
            *mut ShumateDataSource,
            *mut gio::GAsyncResult,
            *mut *mut glib::GError,
        ) -> *mut glib::GBytes,
    >,
    pub start_request: Option<
        unsafe extern "C" fn(
            *mut ShumateDataSource,
            c_int,
            c_int,
            c_int,
            *mut gio::GCancellable,
        ) -> *mut ShumateDataSourceRequest,
    >,
    pub padding: [gpointer; 15],
}

impl ::std::fmt::Debug for ShumateDataSourceClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ShumateDataSourceClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .field("get_tile_data_async", &self.get_tile_data_async)
            .field("get_tile_data_finish", &self.get_tile_data_finish)
            .field("start_request", &self.start_request)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct ShumateDataSourceRequestClass {
    pub parent_class: gobject::GObjectClass,
    pub padding: [gpointer; 16],
}

impl ::std::fmt::Debug for ShumateDataSourceRequestClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ShumateDataSourceRequestClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct ShumateFileCacheClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for ShumateFileCacheClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ShumateFileCacheClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct ShumateLayerClass {
    pub parent_class: gtk::GtkWidgetClass,
    pub get_debug_text: Option<unsafe extern "C" fn(*mut ShumateLayer) -> *mut c_char>,
    pub padding: [gpointer; 15],
}

impl ::std::fmt::Debug for ShumateLayerClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ShumateLayerClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .field("get_debug_text", &self.get_debug_text)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct ShumateLicenseClass {
    pub parent_class: gtk::GtkWidgetClass,
}

impl ::std::fmt::Debug for ShumateLicenseClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ShumateLicenseClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct ShumateLocationInterface {
    pub g_iface: gobject::GTypeInterface,
    pub get_latitude: Option<unsafe extern "C" fn(*mut ShumateLocation) -> c_double>,
    pub get_longitude: Option<unsafe extern "C" fn(*mut ShumateLocation) -> c_double>,
    pub set_location: Option<unsafe extern "C" fn(*mut ShumateLocation, c_double, c_double)>,
}

impl ::std::fmt::Debug for ShumateLocationInterface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ShumateLocationInterface @ {self:p}"))
            .field("get_latitude", &self.get_latitude)
            .field("get_longitude", &self.get_longitude)
            .field("set_location", &self.set_location)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct ShumateMapClass {
    pub parent_class: gtk::GtkWidgetClass,
}

impl ::std::fmt::Debug for ShumateMapClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ShumateMapClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct ShumateMapLayerClass {
    pub parent_class: ShumateLayerClass,
}

impl ::std::fmt::Debug for ShumateMapLayerClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ShumateMapLayerClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct ShumateMapSourceClass {
    pub parent_class: gobject::GObjectClass,
    pub fill_tile_async: Option<
        unsafe extern "C" fn(
            *mut ShumateMapSource,
            *mut ShumateTile,
            *mut gio::GCancellable,
            gio::GAsyncReadyCallback,
            gpointer,
        ),
    >,
    pub fill_tile_finish: Option<
        unsafe extern "C" fn(
            *mut ShumateMapSource,
            *mut gio::GAsyncResult,
            *mut *mut glib::GError,
        ) -> gboolean,
    >,
    pub padding: [gpointer; 16],
}

impl ::std::fmt::Debug for ShumateMapSourceClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ShumateMapSourceClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .field("fill_tile_async", &self.fill_tile_async)
            .field("fill_tile_finish", &self.fill_tile_finish)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct ShumateMapSourceRegistryClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for ShumateMapSourceRegistryClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ShumateMapSourceRegistryClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct ShumateMarkerClass {
    pub parent_class: gtk::GtkWidgetClass,
    pub padding: [gpointer; 16],
}

impl ::std::fmt::Debug for ShumateMarkerClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ShumateMarkerClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct ShumateMarkerLayerClass {
    pub parent_class: ShumateLayerClass,
}

impl ::std::fmt::Debug for ShumateMarkerLayerClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ShumateMarkerLayerClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct ShumatePathLayerClass {
    pub parent_class: ShumateLayerClass,
}

impl ::std::fmt::Debug for ShumatePathLayerClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ShumatePathLayerClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct ShumatePointClass {
    pub parent_class: ShumateMarkerClass,
}

impl ::std::fmt::Debug for ShumatePointClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ShumatePointClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct ShumateRasterRendererClass {
    pub parent_class: ShumateMapSourceClass,
}

impl ::std::fmt::Debug for ShumateRasterRendererClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ShumateRasterRendererClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct ShumateScaleClass {
    pub parent_class: gtk::GtkWidgetClass,
}

impl ::std::fmt::Debug for ShumateScaleClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ShumateScaleClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct ShumateSimpleMapClass {
    pub parent_class: gtk::GtkWidgetClass,
}

impl ::std::fmt::Debug for ShumateSimpleMapClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ShumateSimpleMapClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct ShumateSymbolEventClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for ShumateSymbolEventClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ShumateSymbolEventClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct ShumateTileClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for ShumateTileClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ShumateTileClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct ShumateTileDownloaderClass {
    pub parent_class: ShumateDataSourceClass,
}

impl ::std::fmt::Debug for ShumateTileDownloaderClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ShumateTileDownloaderClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct ShumateVectorReaderClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for ShumateVectorReaderClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ShumateVectorReaderClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct ShumateVectorReaderIterClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for ShumateVectorReaderIterClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ShumateVectorReaderIterClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct ShumateVectorRendererClass {
    pub parent_class: ShumateMapSourceClass,
}

impl ::std::fmt::Debug for ShumateVectorRendererClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ShumateVectorRendererClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct ShumateVectorSpriteClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for ShumateVectorSpriteClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ShumateVectorSpriteClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct ShumateVectorSpriteSheetClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for ShumateVectorSpriteSheetClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ShumateVectorSpriteSheetClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct ShumateViewportClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for ShumateViewportClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ShumateViewportClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

// Classes
#[repr(C)]
#[allow(dead_code)]
pub struct ShumateCompass {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for ShumateCompass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ShumateCompass @ {self:p}"))
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct ShumateCoordinate {
    pub parent_instance: gobject::GInitiallyUnowned,
}

impl ::std::fmt::Debug for ShumateCoordinate {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ShumateCoordinate @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct ShumateDataSource {
    pub parent_instance: gobject::GObject,
}

impl ::std::fmt::Debug for ShumateDataSource {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ShumateDataSource @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct ShumateDataSourceRequest {
    pub parent_instance: gobject::GObject,
}

impl ::std::fmt::Debug for ShumateDataSourceRequest {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ShumateDataSourceRequest @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct ShumateFileCache {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for ShumateFileCache {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ShumateFileCache @ {self:p}"))
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct ShumateLayer {
    pub parent_instance: gtk::GtkWidget,
}

impl ::std::fmt::Debug for ShumateLayer {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ShumateLayer @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct ShumateLicense {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for ShumateLicense {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ShumateLicense @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct ShumateMap {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for ShumateMap {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ShumateMap @ {self:p}")).finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct ShumateMapLayer {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for ShumateMapLayer {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ShumateMapLayer @ {self:p}"))
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct ShumateMapSource {
    pub parent_instance: gobject::GObject,
}

impl ::std::fmt::Debug for ShumateMapSource {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ShumateMapSource @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct ShumateMapSourceRegistry {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for ShumateMapSourceRegistry {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ShumateMapSourceRegistry @ {self:p}"))
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct ShumateMarker {
    pub parent_instance: gtk::GtkWidget,
}

impl ::std::fmt::Debug for ShumateMarker {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ShumateMarker @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct ShumateMarkerLayer {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for ShumateMarkerLayer {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ShumateMarkerLayer @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct ShumatePathLayer {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for ShumatePathLayer {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ShumatePathLayer @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct ShumatePoint {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for ShumatePoint {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ShumatePoint @ {self:p}")).finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct ShumateRasterRenderer {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for ShumateRasterRenderer {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ShumateRasterRenderer @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct ShumateScale {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for ShumateScale {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ShumateScale @ {self:p}")).finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct ShumateSimpleMap {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for ShumateSimpleMap {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ShumateSimpleMap @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct ShumateSymbolEvent {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for ShumateSymbolEvent {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ShumateSymbolEvent @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct ShumateTile {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for ShumateTile {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ShumateTile @ {self:p}")).finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct ShumateTileDownloader {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for ShumateTileDownloader {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ShumateTileDownloader @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct ShumateVectorReader {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for ShumateVectorReader {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ShumateVectorReader @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct ShumateVectorReaderIter {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for ShumateVectorReaderIter {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ShumateVectorReaderIter @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct ShumateVectorRenderer {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for ShumateVectorRenderer {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ShumateVectorRenderer @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct ShumateVectorSprite {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for ShumateVectorSprite {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ShumateVectorSprite @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct ShumateVectorSpriteSheet {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for ShumateVectorSpriteSheet {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ShumateVectorSpriteSheet @ {self:p}"))
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct ShumateViewport {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for ShumateViewport {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("ShumateViewport @ {self:p}"))
            .finish()
    }
}

// Interfaces
#[repr(C)]
#[allow(dead_code)]
pub struct ShumateLocation {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for ShumateLocation {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "ShumateLocation @ {self:p}")
    }
}

extern "C" {

    //=========================================================================
    // ShumateFileCacheError
    //=========================================================================
    pub fn shumate_file_cache_error_get_type() -> GType;
    pub fn shumate_file_cache_error_quark() -> glib::GQuark;

    //=========================================================================
    // ShumateGeometryType
    //=========================================================================
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn shumate_geometry_type_get_type() -> GType;

    //=========================================================================
    // ShumateMapProjection
    //=========================================================================
    pub fn shumate_map_projection_get_type() -> GType;

    //=========================================================================
    // ShumateState
    //=========================================================================
    pub fn shumate_state_get_type() -> GType;

    //=========================================================================
    // ShumateStyleError
    //=========================================================================
    pub fn shumate_style_error_get_type() -> GType;
    pub fn shumate_style_error_quark() -> glib::GQuark;

    //=========================================================================
    // ShumateTileDownloaderError
    //=========================================================================
    pub fn shumate_tile_downloader_error_get_type() -> GType;
    pub fn shumate_tile_downloader_error_quark() -> glib::GQuark;

    //=========================================================================
    // ShumateUnit
    //=========================================================================
    pub fn shumate_unit_get_type() -> GType;

    //=========================================================================
    // ShumateCompass
    //=========================================================================
    pub fn shumate_compass_get_type() -> GType;
    pub fn shumate_compass_new(viewport: *mut ShumateViewport) -> *mut ShumateCompass;
    pub fn shumate_compass_get_viewport(compass: *mut ShumateCompass) -> *mut ShumateViewport;
    pub fn shumate_compass_set_viewport(
        compass: *mut ShumateCompass,
        viewport: *mut ShumateViewport,
    );

    //=========================================================================
    // ShumateCoordinate
    //=========================================================================
    pub fn shumate_coordinate_get_type() -> GType;
    pub fn shumate_coordinate_new() -> *mut ShumateCoordinate;
    pub fn shumate_coordinate_new_full(
        latitude: c_double,
        longitude: c_double,
    ) -> *mut ShumateCoordinate;

    //=========================================================================
    // ShumateDataSource
    //=========================================================================
    pub fn shumate_data_source_get_type() -> GType;
    #[cfg(feature = "v1_1")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_1")))]
    pub fn shumate_data_source_get_max_zoom_level(self_: *mut ShumateDataSource) -> c_uint;
    #[cfg(feature = "v1_1")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_1")))]
    pub fn shumate_data_source_get_min_zoom_level(self_: *mut ShumateDataSource) -> c_uint;
    pub fn shumate_data_source_get_tile_data_async(
        self_: *mut ShumateDataSource,
        x: c_int,
        y: c_int,
        zoom_level: c_int,
        cancellable: *mut gio::GCancellable,
        callback: gio::GAsyncReadyCallback,
        user_data: gpointer,
    );
    pub fn shumate_data_source_get_tile_data_finish(
        self_: *mut ShumateDataSource,
        result: *mut gio::GAsyncResult,
        error: *mut *mut glib::GError,
    ) -> *mut glib::GBytes;
    #[cfg(feature = "v1_1")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_1")))]
    pub fn shumate_data_source_set_max_zoom_level(
        self_: *mut ShumateDataSource,
        zoom_level: c_uint,
    );
    #[cfg(feature = "v1_1")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_1")))]
    pub fn shumate_data_source_set_min_zoom_level(
        self_: *mut ShumateDataSource,
        zoom_level: c_uint,
    );
    #[cfg(feature = "v1_1")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_1")))]
    pub fn shumate_data_source_start_request(
        self_: *mut ShumateDataSource,
        x: c_int,
        y: c_int,
        zoom_level: c_int,
        cancellable: *mut gio::GCancellable,
    ) -> *mut ShumateDataSourceRequest;

    //=========================================================================
    // ShumateDataSourceRequest
    //=========================================================================
    #[cfg(feature = "v1_1")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_1")))]
    pub fn shumate_data_source_request_get_type() -> GType;
    #[cfg(feature = "v1_1")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_1")))]
    pub fn shumate_data_source_request_new(
        x: c_int,
        y: c_int,
        zoom_level: c_int,
    ) -> *mut ShumateDataSourceRequest;
    #[cfg(feature = "v1_1")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_1")))]
    pub fn shumate_data_source_request_complete(self_: *mut ShumateDataSourceRequest);
    #[cfg(feature = "v1_1")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_1")))]
    pub fn shumate_data_source_request_emit_data(
        self_: *mut ShumateDataSourceRequest,
        data: *mut glib::GBytes,
        complete: gboolean,
    );
    #[cfg(feature = "v1_1")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_1")))]
    pub fn shumate_data_source_request_emit_error(
        self_: *mut ShumateDataSourceRequest,
        error: *const glib::GError,
    );
    #[cfg(feature = "v1_1")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_1")))]
    pub fn shumate_data_source_request_get_data(
        self_: *mut ShumateDataSourceRequest,
    ) -> *mut glib::GBytes;
    #[cfg(feature = "v1_1")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_1")))]
    pub fn shumate_data_source_request_get_error(
        self_: *mut ShumateDataSourceRequest,
    ) -> *mut glib::GError;
    #[cfg(feature = "v1_1")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_1")))]
    pub fn shumate_data_source_request_get_x(self_: *mut ShumateDataSourceRequest) -> c_int;
    #[cfg(feature = "v1_1")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_1")))]
    pub fn shumate_data_source_request_get_y(self_: *mut ShumateDataSourceRequest) -> c_int;
    #[cfg(feature = "v1_1")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_1")))]
    pub fn shumate_data_source_request_get_zoom_level(
        self_: *mut ShumateDataSourceRequest,
    ) -> c_int;
    #[cfg(feature = "v1_1")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_1")))]
    pub fn shumate_data_source_request_is_completed(
        self_: *mut ShumateDataSourceRequest,
    ) -> gboolean;

    //=========================================================================
    // ShumateFileCache
    //=========================================================================
    pub fn shumate_file_cache_get_type() -> GType;
    pub fn shumate_file_cache_new_full(
        size_limit: c_uint,
        cache_key: *const c_char,
        cache_dir: *const c_char,
    ) -> *mut ShumateFileCache;
    pub fn shumate_file_cache_get_cache_dir(self_: *mut ShumateFileCache) -> *const c_char;
    pub fn shumate_file_cache_get_cache_key(self_: *mut ShumateFileCache) -> *const c_char;
    pub fn shumate_file_cache_get_size_limit(self_: *mut ShumateFileCache) -> c_uint;
    pub fn shumate_file_cache_get_tile_async(
        self_: *mut ShumateFileCache,
        x: c_int,
        y: c_int,
        zoom_level: c_int,
        cancellable: *mut gio::GCancellable,
        callback: gio::GAsyncReadyCallback,
        user_data: gpointer,
    );
    pub fn shumate_file_cache_get_tile_finish(
        self_: *mut ShumateFileCache,
        etag: *mut *mut c_char,
        modtime: *mut *mut glib::GDateTime,
        result: *mut gio::GAsyncResult,
        error: *mut *mut glib::GError,
    ) -> *mut glib::GBytes;
    pub fn shumate_file_cache_mark_up_to_date(
        self_: *mut ShumateFileCache,
        x: c_int,
        y: c_int,
        zoom_level: c_int,
    );
    pub fn shumate_file_cache_purge_cache_async(
        self_: *mut ShumateFileCache,
        cancellable: *mut gio::GCancellable,
        callback: gio::GAsyncReadyCallback,
        user_data: gpointer,
    );
    pub fn shumate_file_cache_purge_cache_finish(
        self_: *mut ShumateFileCache,
        result: *mut gio::GAsyncResult,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn shumate_file_cache_set_size_limit(self_: *mut ShumateFileCache, size_limit: c_uint);
    pub fn shumate_file_cache_store_tile_async(
        self_: *mut ShumateFileCache,
        x: c_int,
        y: c_int,
        zoom_level: c_int,
        bytes: *mut glib::GBytes,
        etag: *const c_char,
        cancellable: *mut gio::GCancellable,
        callback: gio::GAsyncReadyCallback,
        user_data: gpointer,
    );
    pub fn shumate_file_cache_store_tile_finish(
        self_: *mut ShumateFileCache,
        result: *mut gio::GAsyncResult,
        error: *mut *mut glib::GError,
    ) -> gboolean;

    //=========================================================================
    // ShumateLayer
    //=========================================================================
    pub fn shumate_layer_get_type() -> GType;
    pub fn shumate_layer_get_viewport(self_: *mut ShumateLayer) -> *mut ShumateViewport;

    //=========================================================================
    // ShumateLicense
    //=========================================================================
    pub fn shumate_license_get_type() -> GType;
    pub fn shumate_license_new() -> *mut ShumateLicense;
    pub fn shumate_license_append_map_source(
        license: *mut ShumateLicense,
        map_source: *mut ShumateMapSource,
    );
    pub fn shumate_license_get_extra_text(license: *mut ShumateLicense) -> *const c_char;
    pub fn shumate_license_get_xalign(license: *mut ShumateLicense) -> c_float;
    pub fn shumate_license_prepend_map_source(
        license: *mut ShumateLicense,
        map_source: *mut ShumateMapSource,
    );
    pub fn shumate_license_remove_map_source(
        license: *mut ShumateLicense,
        map_source: *mut ShumateMapSource,
    );
    pub fn shumate_license_set_extra_text(license: *mut ShumateLicense, text: *const c_char);
    pub fn shumate_license_set_xalign(license: *mut ShumateLicense, xalign: c_float);

    //=========================================================================
    // ShumateMap
    //=========================================================================
    pub fn shumate_map_get_type() -> GType;
    pub fn shumate_map_new() -> *mut ShumateMap;
    pub fn shumate_map_new_simple() -> *mut ShumateMap;
    pub fn shumate_map_add_layer(self_: *mut ShumateMap, layer: *mut ShumateLayer);
    pub fn shumate_map_center_on(self_: *mut ShumateMap, latitude: c_double, longitude: c_double);
    pub fn shumate_map_get_animate_zoom(self_: *mut ShumateMap) -> gboolean;
    pub fn shumate_map_get_go_to_duration(self_: *mut ShumateMap) -> c_uint;
    pub fn shumate_map_get_state(self_: *mut ShumateMap) -> ShumateState;
    pub fn shumate_map_get_viewport(self_: *mut ShumateMap) -> *mut ShumateViewport;
    pub fn shumate_map_get_zoom_on_double_click(self_: *mut ShumateMap) -> gboolean;
    pub fn shumate_map_go_to(self_: *mut ShumateMap, latitude: c_double, longitude: c_double);
    pub fn shumate_map_go_to_full(
        self_: *mut ShumateMap,
        latitude: c_double,
        longitude: c_double,
        zoom_level: c_double,
    );
    pub fn shumate_map_go_to_full_with_duration(
        self_: *mut ShumateMap,
        latitude: c_double,
        longitude: c_double,
        zoom_level: c_double,
        duration_ms: c_uint,
    );
    pub fn shumate_map_insert_layer_above(
        self_: *mut ShumateMap,
        layer: *mut ShumateLayer,
        next_sibling: *mut ShumateLayer,
    );
    pub fn shumate_map_insert_layer_behind(
        self_: *mut ShumateMap,
        layer: *mut ShumateLayer,
        next_sibling: *mut ShumateLayer,
    );
    pub fn shumate_map_remove_layer(self_: *mut ShumateMap, layer: *mut ShumateLayer);
    pub fn shumate_map_set_animate_zoom(self_: *mut ShumateMap, value: gboolean);
    pub fn shumate_map_set_go_to_duration(self_: *mut ShumateMap, duration: c_uint);
    pub fn shumate_map_set_map_source(self_: *mut ShumateMap, map_source: *mut ShumateMapSource);
    pub fn shumate_map_set_zoom_on_double_click(self_: *mut ShumateMap, value: gboolean);
    pub fn shumate_map_stop_go_to(self_: *mut ShumateMap);
    pub fn shumate_map_zoom_in(self_: *mut ShumateMap);
    pub fn shumate_map_zoom_out(self_: *mut ShumateMap);

    //=========================================================================
    // ShumateMapLayer
    //=========================================================================
    pub fn shumate_map_layer_get_type() -> GType;
    pub fn shumate_map_layer_new(
        map_source: *mut ShumateMapSource,
        viewport: *mut ShumateViewport,
    ) -> *mut ShumateMapLayer;

    //=========================================================================
    // ShumateMapSource
    //=========================================================================
    pub fn shumate_map_source_get_type() -> GType;
    pub fn shumate_map_source_fill_tile_async(
        self_: *mut ShumateMapSource,
        tile: *mut ShumateTile,
        cancellable: *mut gio::GCancellable,
        callback: gio::GAsyncReadyCallback,
        user_data: gpointer,
    );
    pub fn shumate_map_source_fill_tile_finish(
        self_: *mut ShumateMapSource,
        result: *mut gio::GAsyncResult,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn shumate_map_source_get_column_count(
        map_source: *mut ShumateMapSource,
        zoom_level: c_uint,
    ) -> c_uint;
    pub fn shumate_map_source_get_id(map_source: *mut ShumateMapSource) -> *const c_char;
    pub fn shumate_map_source_get_latitude(
        map_source: *mut ShumateMapSource,
        zoom_level: c_double,
        y: c_double,
    ) -> c_double;
    pub fn shumate_map_source_get_license(map_source: *mut ShumateMapSource) -> *const c_char;
    pub fn shumate_map_source_get_license_uri(map_source: *mut ShumateMapSource) -> *const c_char;
    pub fn shumate_map_source_get_longitude(
        map_source: *mut ShumateMapSource,
        zoom_level: c_double,
        x: c_double,
    ) -> c_double;
    pub fn shumate_map_source_get_max_zoom_level(map_source: *mut ShumateMapSource) -> c_uint;
    pub fn shumate_map_source_get_meters_per_pixel(
        map_source: *mut ShumateMapSource,
        zoom_level: c_double,
        latitude: c_double,
        longitude: c_double,
    ) -> c_double;
    pub fn shumate_map_source_get_min_zoom_level(map_source: *mut ShumateMapSource) -> c_uint;
    pub fn shumate_map_source_get_name(map_source: *mut ShumateMapSource) -> *const c_char;
    pub fn shumate_map_source_get_projection(
        map_source: *mut ShumateMapSource,
    ) -> ShumateMapProjection;
    pub fn shumate_map_source_get_row_count(
        map_source: *mut ShumateMapSource,
        zoom_level: c_uint,
    ) -> c_uint;
    pub fn shumate_map_source_get_tile_size(map_source: *mut ShumateMapSource) -> c_uint;
    pub fn shumate_map_source_get_tile_size_at_zoom(
        map_source: *mut ShumateMapSource,
        zoom_level: c_double,
    ) -> c_double;
    pub fn shumate_map_source_get_x(
        map_source: *mut ShumateMapSource,
        zoom_level: c_double,
        longitude: c_double,
    ) -> c_double;
    pub fn shumate_map_source_get_y(
        map_source: *mut ShumateMapSource,
        zoom_level: c_double,
        latitude: c_double,
    ) -> c_double;
    pub fn shumate_map_source_set_id(map_source: *mut ShumateMapSource, id: *const c_char);
    pub fn shumate_map_source_set_license(
        map_source: *mut ShumateMapSource,
        license: *const c_char,
    );
    pub fn shumate_map_source_set_license_uri(
        map_source: *mut ShumateMapSource,
        license_uri: *const c_char,
    );
    pub fn shumate_map_source_set_max_zoom_level(
        map_source: *mut ShumateMapSource,
        zoom_level: c_uint,
    );
    pub fn shumate_map_source_set_min_zoom_level(
        map_source: *mut ShumateMapSource,
        zoom_level: c_uint,
    );
    pub fn shumate_map_source_set_name(map_source: *mut ShumateMapSource, name: *const c_char);
    pub fn shumate_map_source_set_projection(
        map_source: *mut ShumateMapSource,
        projection: ShumateMapProjection,
    );
    pub fn shumate_map_source_set_tile_size(map_source: *mut ShumateMapSource, tile_size: c_uint);

    //=========================================================================
    // ShumateMapSourceRegistry
    //=========================================================================
    pub fn shumate_map_source_registry_get_type() -> GType;
    pub fn shumate_map_source_registry_new() -> *mut ShumateMapSourceRegistry;
    pub fn shumate_map_source_registry_new_with_defaults() -> *mut ShumateMapSourceRegistry;
    pub fn shumate_map_source_registry_add(
        self_: *mut ShumateMapSourceRegistry,
        map_source: *mut ShumateMapSource,
    );
    pub fn shumate_map_source_registry_get_by_id(
        self_: *mut ShumateMapSourceRegistry,
        id: *const c_char,
    ) -> *mut ShumateMapSource;
    pub fn shumate_map_source_registry_populate_defaults(self_: *mut ShumateMapSourceRegistry);
    pub fn shumate_map_source_registry_remove(
        self_: *mut ShumateMapSourceRegistry,
        id: *const c_char,
    );

    //=========================================================================
    // ShumateMarker
    //=========================================================================
    pub fn shumate_marker_get_type() -> GType;
    pub fn shumate_marker_new() -> *mut ShumateMarker;
    pub fn shumate_marker_animate_in(marker: *mut ShumateMarker);
    pub fn shumate_marker_animate_in_with_delay(marker: *mut ShumateMarker, delay: c_uint);
    pub fn shumate_marker_animate_out(marker: *mut ShumateMarker);
    pub fn shumate_marker_animate_out_with_delay(marker: *mut ShumateMarker, delay: c_uint);
    pub fn shumate_marker_get_child(marker: *mut ShumateMarker) -> *mut gtk::GtkWidget;
    pub fn shumate_marker_get_draggable(marker: *mut ShumateMarker) -> gboolean;
    pub fn shumate_marker_get_selectable(marker: *mut ShumateMarker) -> gboolean;
    pub fn shumate_marker_is_selected(marker: *mut ShumateMarker) -> gboolean;
    pub fn shumate_marker_set_child(marker: *mut ShumateMarker, child: *mut gtk::GtkWidget);
    pub fn shumate_marker_set_draggable(marker: *mut ShumateMarker, value: gboolean);
    pub fn shumate_marker_set_selectable(marker: *mut ShumateMarker, value: gboolean);

    //=========================================================================
    // ShumateMarkerLayer
    //=========================================================================
    pub fn shumate_marker_layer_get_type() -> GType;
    pub fn shumate_marker_layer_new(viewport: *mut ShumateViewport) -> *mut ShumateMarkerLayer;
    pub fn shumate_marker_layer_new_full(
        viewport: *mut ShumateViewport,
        mode: gtk::GtkSelectionMode,
    ) -> *mut ShumateMarkerLayer;
    pub fn shumate_marker_layer_add_marker(
        self_: *mut ShumateMarkerLayer,
        marker: *mut ShumateMarker,
    );
    pub fn shumate_marker_layer_get_markers(self_: *mut ShumateMarkerLayer) -> *mut glib::GList;
    pub fn shumate_marker_layer_get_selected(self_: *mut ShumateMarkerLayer) -> *mut glib::GList;
    pub fn shumate_marker_layer_get_selection_mode(
        self_: *mut ShumateMarkerLayer,
    ) -> gtk::GtkSelectionMode;
    pub fn shumate_marker_layer_remove_all(self_: *mut ShumateMarkerLayer);
    pub fn shumate_marker_layer_remove_marker(
        self_: *mut ShumateMarkerLayer,
        marker: *mut ShumateMarker,
    );
    pub fn shumate_marker_layer_select_all_markers(self_: *mut ShumateMarkerLayer);
    pub fn shumate_marker_layer_select_marker(
        self_: *mut ShumateMarkerLayer,
        marker: *mut ShumateMarker,
    ) -> gboolean;
    pub fn shumate_marker_layer_set_selection_mode(
        self_: *mut ShumateMarkerLayer,
        mode: gtk::GtkSelectionMode,
    );
    pub fn shumate_marker_layer_unselect_all_markers(self_: *mut ShumateMarkerLayer);
    pub fn shumate_marker_layer_unselect_marker(
        self_: *mut ShumateMarkerLayer,
        marker: *mut ShumateMarker,
    );

    //=========================================================================
    // ShumatePathLayer
    //=========================================================================
    pub fn shumate_path_layer_get_type() -> GType;
    pub fn shumate_path_layer_new(viewport: *mut ShumateViewport) -> *mut ShumatePathLayer;
    pub fn shumate_path_layer_add_node(
        self_: *mut ShumatePathLayer,
        location: *mut ShumateLocation,
    );
    pub fn shumate_path_layer_get_closed(self_: *mut ShumatePathLayer) -> gboolean;
    pub fn shumate_path_layer_get_dash(self_: *mut ShumatePathLayer) -> *mut glib::GList;
    pub fn shumate_path_layer_get_fill(self_: *mut ShumatePathLayer) -> gboolean;
    pub fn shumate_path_layer_get_fill_color(self_: *mut ShumatePathLayer) -> *mut gdk::GdkRGBA;
    pub fn shumate_path_layer_get_nodes(self_: *mut ShumatePathLayer) -> *mut glib::GList;
    pub fn shumate_path_layer_get_outline_color(self_: *mut ShumatePathLayer) -> *mut gdk::GdkRGBA;
    pub fn shumate_path_layer_get_outline_width(self_: *mut ShumatePathLayer) -> c_double;
    pub fn shumate_path_layer_get_stroke(self_: *mut ShumatePathLayer) -> gboolean;
    pub fn shumate_path_layer_get_stroke_color(self_: *mut ShumatePathLayer) -> *mut gdk::GdkRGBA;
    pub fn shumate_path_layer_get_stroke_width(self_: *mut ShumatePathLayer) -> c_double;
    pub fn shumate_path_layer_insert_node(
        self_: *mut ShumatePathLayer,
        location: *mut ShumateLocation,
        position: c_uint,
    );
    pub fn shumate_path_layer_remove_all(self_: *mut ShumatePathLayer);
    pub fn shumate_path_layer_remove_node(
        self_: *mut ShumatePathLayer,
        location: *mut ShumateLocation,
    );
    pub fn shumate_path_layer_set_closed(self_: *mut ShumatePathLayer, value: gboolean);
    pub fn shumate_path_layer_set_dash(
        self_: *mut ShumatePathLayer,
        dash_pattern: *mut glib::GList,
    );
    pub fn shumate_path_layer_set_fill(self_: *mut ShumatePathLayer, value: gboolean);
    pub fn shumate_path_layer_set_fill_color(
        self_: *mut ShumatePathLayer,
        color: *const gdk::GdkRGBA,
    );
    pub fn shumate_path_layer_set_outline_color(
        self_: *mut ShumatePathLayer,
        color: *const gdk::GdkRGBA,
    );
    pub fn shumate_path_layer_set_outline_width(self_: *mut ShumatePathLayer, value: c_double);
    pub fn shumate_path_layer_set_stroke(self_: *mut ShumatePathLayer, value: gboolean);
    pub fn shumate_path_layer_set_stroke_color(
        self_: *mut ShumatePathLayer,
        color: *const gdk::GdkRGBA,
    );
    pub fn shumate_path_layer_set_stroke_width(self_: *mut ShumatePathLayer, value: c_double);

    //=========================================================================
    // ShumatePoint
    //=========================================================================
    pub fn shumate_point_get_type() -> GType;
    pub fn shumate_point_new() -> *mut ShumatePoint;

    //=========================================================================
    // ShumateRasterRenderer
    //=========================================================================
    pub fn shumate_raster_renderer_get_type() -> GType;
    pub fn shumate_raster_renderer_new(
        data_source: *mut ShumateDataSource,
    ) -> *mut ShumateRasterRenderer;
    pub fn shumate_raster_renderer_new_from_url(
        url_template: *const c_char,
    ) -> *mut ShumateRasterRenderer;
    pub fn shumate_raster_renderer_new_full(
        id: *const c_char,
        name: *const c_char,
        license: *const c_char,
        license_uri: *const c_char,
        min_zoom: c_uint,
        max_zoom: c_uint,
        tile_size: c_uint,
        projection: ShumateMapProjection,
        data_source: *mut ShumateDataSource,
    ) -> *mut ShumateRasterRenderer;
    pub fn shumate_raster_renderer_new_full_from_url(
        id: *const c_char,
        name: *const c_char,
        license: *const c_char,
        license_uri: *const c_char,
        min_zoom: c_uint,
        max_zoom: c_uint,
        tile_size: c_uint,
        projection: ShumateMapProjection,
        url_template: *const c_char,
    ) -> *mut ShumateRasterRenderer;

    //=========================================================================
    // ShumateScale
    //=========================================================================
    pub fn shumate_scale_get_type() -> GType;
    pub fn shumate_scale_new(viewport: *mut ShumateViewport) -> *mut ShumateScale;
    pub fn shumate_scale_get_max_width(scale: *mut ShumateScale) -> c_uint;
    pub fn shumate_scale_get_unit(scale: *mut ShumateScale) -> ShumateUnit;
    pub fn shumate_scale_get_viewport(scale: *mut ShumateScale) -> *mut ShumateViewport;
    pub fn shumate_scale_set_max_width(scale: *mut ShumateScale, value: c_uint);
    pub fn shumate_scale_set_unit(scale: *mut ShumateScale, unit: ShumateUnit);
    pub fn shumate_scale_set_viewport(scale: *mut ShumateScale, viewport: *mut ShumateViewport);

    //=========================================================================
    // ShumateSimpleMap
    //=========================================================================
    pub fn shumate_simple_map_get_type() -> GType;
    pub fn shumate_simple_map_new() -> *mut ShumateSimpleMap;
    pub fn shumate_simple_map_add_overlay_layer(
        self_: *mut ShumateSimpleMap,
        layer: *mut ShumateLayer,
    );
    #[cfg(feature = "v1_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
    pub fn shumate_simple_map_get_base_map_layer(
        self_: *mut ShumateSimpleMap,
    ) -> *mut ShumateMapLayer;
    pub fn shumate_simple_map_get_compass(self_: *mut ShumateSimpleMap) -> *mut ShumateCompass;
    pub fn shumate_simple_map_get_license(self_: *mut ShumateSimpleMap) -> *mut ShumateLicense;
    pub fn shumate_simple_map_get_map(self_: *mut ShumateSimpleMap) -> *mut ShumateMap;
    pub fn shumate_simple_map_get_map_source(self_: *mut ShumateSimpleMap)
        -> *mut ShumateMapSource;
    pub fn shumate_simple_map_get_scale(self_: *mut ShumateSimpleMap) -> *mut ShumateScale;
    pub fn shumate_simple_map_get_show_zoom_buttons(self_: *mut ShumateSimpleMap) -> gboolean;
    pub fn shumate_simple_map_get_viewport(self_: *mut ShumateSimpleMap) -> *mut ShumateViewport;
    pub fn shumate_simple_map_insert_overlay_layer_above(
        self_: *mut ShumateSimpleMap,
        layer: *mut ShumateLayer,
        sibling: *mut ShumateLayer,
    );
    pub fn shumate_simple_map_insert_overlay_layer_behind(
        self_: *mut ShumateSimpleMap,
        layer: *mut ShumateLayer,
        sibling: *mut ShumateLayer,
    );
    pub fn shumate_simple_map_remove_overlay_layer(
        self_: *mut ShumateSimpleMap,
        layer: *mut ShumateLayer,
    );
    pub fn shumate_simple_map_set_map_source(
        self_: *mut ShumateSimpleMap,
        map_source: *mut ShumateMapSource,
    );
    pub fn shumate_simple_map_set_show_zoom_buttons(
        self_: *mut ShumateSimpleMap,
        show_zoom_buttons: gboolean,
    );

    //=========================================================================
    // ShumateSymbolEvent
    //=========================================================================
    #[cfg(feature = "v1_1")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_1")))]
    pub fn shumate_symbol_event_get_type() -> GType;
    #[cfg(feature = "v1_1")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_1")))]
    pub fn shumate_symbol_event_get_feature_id(self_: *mut ShumateSymbolEvent) -> *const c_char;
    #[cfg(feature = "v1_1")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_1")))]
    pub fn shumate_symbol_event_get_keys(self_: *mut ShumateSymbolEvent) -> c_char;
    #[cfg(feature = "v1_1")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_1")))]
    pub fn shumate_symbol_event_get_layer(self_: *mut ShumateSymbolEvent) -> *const c_char;
    #[cfg(feature = "v1_5")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
    pub fn shumate_symbol_event_get_n_press(self_: *mut ShumateSymbolEvent) -> c_int;
    #[cfg(feature = "v1_1")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_1")))]
    pub fn shumate_symbol_event_get_source_layer(self_: *mut ShumateSymbolEvent) -> *const c_char;
    #[cfg(feature = "v1_1")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_1")))]
    pub fn shumate_symbol_event_get_tag(
        self_: *mut ShumateSymbolEvent,
        tag_name: *const c_char,
    ) -> *const c_char;

    //=========================================================================
    // ShumateTile
    //=========================================================================
    pub fn shumate_tile_get_type() -> GType;
    pub fn shumate_tile_new() -> *mut ShumateTile;
    pub fn shumate_tile_new_full(
        x: c_uint,
        y: c_uint,
        size: c_uint,
        zoom_level: c_uint,
    ) -> *mut ShumateTile;
    pub fn shumate_tile_get_fade_in(self_: *mut ShumateTile) -> gboolean;
    pub fn shumate_tile_get_paintable(self_: *mut ShumateTile) -> *mut gdk::GdkPaintable;
    #[cfg(feature = "v1_1")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_1")))]
    pub fn shumate_tile_get_scale_factor(self_: *mut ShumateTile) -> c_double;
    pub fn shumate_tile_get_size(self_: *mut ShumateTile) -> c_uint;
    pub fn shumate_tile_get_state(self_: *mut ShumateTile) -> ShumateState;
    pub fn shumate_tile_get_x(self_: *mut ShumateTile) -> c_uint;
    pub fn shumate_tile_get_y(self_: *mut ShumateTile) -> c_uint;
    pub fn shumate_tile_get_zoom_level(self_: *mut ShumateTile) -> c_uint;
    pub fn shumate_tile_set_fade_in(self_: *mut ShumateTile, fade_in: gboolean);
    pub fn shumate_tile_set_paintable(self_: *mut ShumateTile, paintable: *mut gdk::GdkPaintable);
    #[cfg(feature = "v1_1")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_1")))]
    pub fn shumate_tile_set_scale_factor(self_: *mut ShumateTile, scale_factor: c_double);
    pub fn shumate_tile_set_size(self_: *mut ShumateTile, size: c_uint);
    pub fn shumate_tile_set_state(self_: *mut ShumateTile, state: ShumateState);
    pub fn shumate_tile_set_x(self_: *mut ShumateTile, x: c_uint);
    pub fn shumate_tile_set_y(self_: *mut ShumateTile, y: c_uint);
    pub fn shumate_tile_set_zoom_level(self_: *mut ShumateTile, zoom_level: c_uint);

    //=========================================================================
    // ShumateTileDownloader
    //=========================================================================
    pub fn shumate_tile_downloader_get_type() -> GType;
    pub fn shumate_tile_downloader_new(url_template: *const c_char) -> *mut ShumateTileDownloader;

    //=========================================================================
    // ShumateVectorReader
    //=========================================================================
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn shumate_vector_reader_get_type() -> GType;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn shumate_vector_reader_new(bytes: *mut glib::GBytes) -> *mut ShumateVectorReader;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn shumate_vector_reader_iterate(
        self_: *mut ShumateVectorReader,
    ) -> *mut ShumateVectorReaderIter;

    //=========================================================================
    // ShumateVectorReaderIter
    //=========================================================================
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn shumate_vector_reader_iter_get_type() -> GType;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn shumate_vector_reader_iter_feature_contains_point(
        self_: *mut ShumateVectorReaderIter,
        x: c_double,
        y: c_double,
    ) -> gboolean;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn shumate_vector_reader_iter_get_feature_geometry_type(
        self_: *mut ShumateVectorReaderIter,
    ) -> ShumateGeometryType;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn shumate_vector_reader_iter_get_feature_id(self_: *mut ShumateVectorReaderIter) -> u64;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn shumate_vector_reader_iter_get_feature_keys(
        self_: *mut ShumateVectorReaderIter,
    ) -> *mut *const c_char;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn shumate_vector_reader_iter_get_feature_point(
        self_: *mut ShumateVectorReaderIter,
        x: *mut c_double,
        y: *mut c_double,
    ) -> gboolean;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn shumate_vector_reader_iter_get_feature_tag(
        self_: *mut ShumateVectorReaderIter,
        key: *const c_char,
        value: *mut gobject::GValue,
    ) -> gboolean;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn shumate_vector_reader_iter_get_layer_count(
        self_: *mut ShumateVectorReaderIter,
    ) -> c_uint;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn shumate_vector_reader_iter_get_layer_extent(
        self_: *mut ShumateVectorReaderIter,
    ) -> c_uint;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn shumate_vector_reader_iter_get_layer_feature_count(
        self_: *mut ShumateVectorReaderIter,
    ) -> c_uint;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn shumate_vector_reader_iter_get_layer_name(
        self_: *mut ShumateVectorReaderIter,
    ) -> *const c_char;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn shumate_vector_reader_iter_get_reader(
        self_: *mut ShumateVectorReaderIter,
    ) -> *mut ShumateVectorReader;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn shumate_vector_reader_iter_next_feature(self_: *mut ShumateVectorReaderIter)
        -> gboolean;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn shumate_vector_reader_iter_read_feature(
        self_: *mut ShumateVectorReaderIter,
        index: c_int,
    );
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn shumate_vector_reader_iter_read_layer(self_: *mut ShumateVectorReaderIter, index: c_int);
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn shumate_vector_reader_iter_read_layer_by_name(
        self_: *mut ShumateVectorReaderIter,
        name: *const c_char,
    ) -> gboolean;

    //=========================================================================
    // ShumateVectorRenderer
    //=========================================================================
    pub fn shumate_vector_renderer_get_type() -> GType;
    pub fn shumate_vector_renderer_new(
        id: *const c_char,
        style_json: *const c_char,
        error: *mut *mut glib::GError,
    ) -> *mut ShumateVectorRenderer;
    pub fn shumate_vector_renderer_is_supported() -> gboolean;
    #[cfg(feature = "v1_1")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_1")))]
    pub fn shumate_vector_renderer_get_sprite_sheet(
        self_: *mut ShumateVectorRenderer,
    ) -> *mut ShumateVectorSpriteSheet;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn shumate_vector_renderer_set_data_source(
        self_: *mut ShumateVectorRenderer,
        name: *const c_char,
        data_source: *mut ShumateDataSource,
    );
    #[cfg(feature = "v1_1")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_1")))]
    pub fn shumate_vector_renderer_set_sprite_sheet(
        self_: *mut ShumateVectorRenderer,
        sprites: *mut ShumateVectorSpriteSheet,
    );
    pub fn shumate_vector_renderer_set_sprite_sheet_data(
        self_: *mut ShumateVectorRenderer,
        sprites_pixbuf: *mut gdk_pixbuf::GdkPixbuf,
        sprites_json: *const c_char,
        error: *mut *mut glib::GError,
    ) -> gboolean;

    //=========================================================================
    // ShumateVectorSprite
    //=========================================================================
    #[cfg(feature = "v1_1")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_1")))]
    pub fn shumate_vector_sprite_get_type() -> GType;
    #[cfg(feature = "v1_1")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_1")))]
    pub fn shumate_vector_sprite_new(
        source_paintable: *mut gdk::GdkPaintable,
    ) -> *mut ShumateVectorSprite;
    #[cfg(feature = "v1_1")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_1")))]
    pub fn shumate_vector_sprite_new_full(
        source_paintable: *mut gdk::GdkPaintable,
        width: c_int,
        height: c_int,
        scale_factor: c_double,
        source_rect: *mut gdk::GdkRectangle,
    ) -> *mut ShumateVectorSprite;
    #[cfg(feature = "v1_1")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_1")))]
    pub fn shumate_vector_sprite_get_height(self_: *mut ShumateVectorSprite) -> c_int;
    #[cfg(feature = "v1_1")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_1")))]
    pub fn shumate_vector_sprite_get_scale_factor(self_: *mut ShumateVectorSprite) -> c_double;
    #[cfg(feature = "v1_1")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_1")))]
    pub fn shumate_vector_sprite_get_source_paintable(
        self_: *mut ShumateVectorSprite,
    ) -> *mut gdk::GdkPaintable;
    #[cfg(feature = "v1_1")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_1")))]
    pub fn shumate_vector_sprite_get_source_rect(
        self_: *mut ShumateVectorSprite,
    ) -> *mut gdk::GdkRectangle;
    #[cfg(feature = "v1_1")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_1")))]
    pub fn shumate_vector_sprite_get_width(self_: *mut ShumateVectorSprite) -> c_int;

    //=========================================================================
    // ShumateVectorSpriteSheet
    //=========================================================================
    #[cfg(feature = "v1_1")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_1")))]
    pub fn shumate_vector_sprite_sheet_get_type() -> GType;
    #[cfg(feature = "v1_1")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_1")))]
    pub fn shumate_vector_sprite_sheet_new() -> *mut ShumateVectorSpriteSheet;
    #[cfg(feature = "v1_1")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_1")))]
    pub fn shumate_vector_sprite_sheet_add_page(
        self_: *mut ShumateVectorSpriteSheet,
        texture: *mut gdk::GdkTexture,
        json: *const c_char,
        default_scale: c_double,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    #[cfg(feature = "v1_1")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_1")))]
    pub fn shumate_vector_sprite_sheet_add_sprite(
        self_: *mut ShumateVectorSpriteSheet,
        name: *const c_char,
        sprite: *mut ShumateVectorSprite,
    );
    #[cfg(feature = "v1_1")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_1")))]
    pub fn shumate_vector_sprite_sheet_get_sprite(
        self_: *mut ShumateVectorSpriteSheet,
        name: *const c_char,
        scale: c_double,
    ) -> *mut ShumateVectorSprite;
    #[cfg(feature = "v1_1")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_1")))]
    pub fn shumate_vector_sprite_sheet_set_fallback(
        self_: *mut ShumateVectorSpriteSheet,
        fallback: ShumateVectorSpriteFallbackFunc,
        user_data: gpointer,
        notify: glib::GDestroyNotify,
    );

    //=========================================================================
    // ShumateViewport
    //=========================================================================
    pub fn shumate_viewport_get_type() -> GType;
    pub fn shumate_viewport_new() -> *mut ShumateViewport;
    pub fn shumate_viewport_get_max_zoom_level(self_: *mut ShumateViewport) -> c_uint;
    pub fn shumate_viewport_get_min_zoom_level(self_: *mut ShumateViewport) -> c_uint;
    pub fn shumate_viewport_get_reference_map_source(
        self_: *mut ShumateViewport,
    ) -> *mut ShumateMapSource;
    pub fn shumate_viewport_get_rotation(self_: *mut ShumateViewport) -> c_double;
    pub fn shumate_viewport_get_zoom_level(self_: *mut ShumateViewport) -> c_double;
    pub fn shumate_viewport_location_to_widget_coords(
        self_: *mut ShumateViewport,
        widget: *mut gtk::GtkWidget,
        latitude: c_double,
        longitude: c_double,
        x: *mut c_double,
        y: *mut c_double,
    );
    pub fn shumate_viewport_set_max_zoom_level(self_: *mut ShumateViewport, max_zoom_level: c_uint);
    pub fn shumate_viewport_set_min_zoom_level(self_: *mut ShumateViewport, min_zoom_level: c_uint);
    pub fn shumate_viewport_set_reference_map_source(
        self_: *mut ShumateViewport,
        map_source: *mut ShumateMapSource,
    );
    pub fn shumate_viewport_set_rotation(self_: *mut ShumateViewport, rotation: c_double);
    pub fn shumate_viewport_set_zoom_level(self_: *mut ShumateViewport, zoom_level: c_double);
    pub fn shumate_viewport_widget_coords_to_location(
        self_: *mut ShumateViewport,
        widget: *mut gtk::GtkWidget,
        x: c_double,
        y: c_double,
        latitude: *mut c_double,
        longitude: *mut c_double,
    );

    //=========================================================================
    // ShumateLocation
    //=========================================================================
    pub fn shumate_location_get_type() -> GType;
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn shumate_location_distance(
        self_: *mut ShumateLocation,
        other: *mut ShumateLocation,
    ) -> c_double;
    pub fn shumate_location_get_latitude(location: *mut ShumateLocation) -> c_double;
    pub fn shumate_location_get_longitude(location: *mut ShumateLocation) -> c_double;
    pub fn shumate_location_set_location(
        location: *mut ShumateLocation,
        latitude: c_double,
        longitude: c_double,
    );

    //=========================================================================
    // Other functions
    //=========================================================================
    pub fn shumate_get_user_agent() -> *const c_char;
    pub fn shumate_set_user_agent(new_user_agent: *const c_char);

}