#![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(feature = "dox", feature(doc_cfg))]
#[allow(unused_imports)]
use libc::{
c_char, c_double, c_float, c_int, c_long, c_short, c_uchar, c_uint, c_ulong, c_ushort, c_void,
intptr_t, size_t, ssize_t, uintptr_t, FILE,
};
#[allow(unused_imports)]
use glib::{gboolean, gconstpointer, gpointer, GType};
pub type ShumateFileCacheError = c_int;
pub const SHUMATE_FILE_CACHE_ERROR_FAILED: ShumateFileCacheError = 0;
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;
pub const SHUMATE_MAJOR_VERSION: c_int = 1;
pub const SHUMATE_MAP_SOURCE_MFF_RELIEF: *const c_char =
b"mff-relief\0" as *const u8 as *const c_char;
pub const SHUMATE_MAP_SOURCE_OSM_CYCLE_MAP: *const c_char =
b"osm-cyclemap\0" as *const u8 as *const c_char;
pub const SHUMATE_MAP_SOURCE_OSM_MAPNIK: *const c_char =
b"osm-mapnik\0" as *const u8 as *const c_char;
pub const SHUMATE_MAP_SOURCE_OSM_TRANSPORT_MAP: *const c_char =
b"osm-transportmap\0" as *const u8 as *const c_char;
pub const SHUMATE_MAP_SOURCE_OWM_CLOUDS: *const c_char =
b"owm-clouds\0" as *const u8 as *const c_char;
pub const SHUMATE_MAP_SOURCE_OWM_PRECIPITATION: *const c_char =
b"owm-precipitation\0" as *const u8 as *const c_char;
pub const SHUMATE_MAP_SOURCE_OWM_PRESSURE: *const c_char =
b"owm-pressure\0" as *const u8 as *const c_char;
pub const SHUMATE_MAP_SOURCE_OWM_TEMPERATURE: *const c_char =
b"owm-temperature\0" as *const u8 as *const c_char;
pub const SHUMATE_MAP_SOURCE_OWM_WIND: *const c_char = b"owm-wind\0" as *const u8 as *const c_char;
pub const SHUMATE_MAX_LATITUDE: c_double = 85.0511287798;
pub const SHUMATE_MAX_LONGITUDE: c_double = 180.0;
pub const SHUMATE_MINOR_VERSION: c_int = 1;
pub const SHUMATE_MIN_LATITUDE: c_double = -85.0511287798;
pub const SHUMATE_MIN_LONGITUDE: c_double = -180.0;
#[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 @ {:p}", self))
.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 @ {:p}", self))
.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 padding: [gpointer; 16],
}
impl ::std::fmt::Debug for ShumateDataSourceClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("ShumateDataSourceClass @ {:p}", self))
.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)
.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 @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct ShumateLayerClass {
pub parent_class: gtk::GtkWidgetClass,
pub padding: [gpointer; 16],
}
impl ::std::fmt::Debug for ShumateLayerClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("ShumateLayerClass @ {:p}", self))
.field("parent_class", &self.parent_class)
.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 @ {:p}", self))
.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 @ {:p}", self))
.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 @ {:p}", self))
.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 @ {:p}", self))
.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 @ {:p}", self))
.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 @ {:p}", self))
.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 @ {:p}", self))
.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 @ {:p}", self))
.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 @ {:p}", self))
.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 @ {:p}", self))
.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 @ {:p}", self))
.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 @ {:p}", self))
.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 @ {:p}", self))
.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 @ {:p}", self))
.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 @ {:p}", self))
.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 @ {:p}", self))
.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 @ {:p}", self))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
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 @ {:p}", self))
.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 @ {:p}", self))
.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 @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
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 @ {:p}", self))
.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 @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
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 @ {:p}", self))
.finish()
}
}
#[repr(C)]
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 @ {:p}", self)).finish()
}
}
#[repr(C)]
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 @ {:p}", self))
.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 @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
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 @ {:p}", self))
.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 @ {:p}", self))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
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 @ {:p}", self))
.finish()
}
}
#[repr(C)]
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 @ {:p}", self))
.finish()
}
}
#[repr(C)]
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 @ {:p}", self))
.finish()
}
}
#[repr(C)]
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 @ {:p}", self))
.finish()
}
}
#[repr(C)]
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 @ {:p}", self))
.finish()
}
}
#[repr(C)]
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 @ {:p}", self))
.finish()
}
}
#[repr(C)]
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 @ {:p}", self))
.finish()
}
}
#[repr(C)]
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 @ {:p}", self))
.finish()
}
}
#[repr(C)]
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 @ {:p}", self))
.finish()
}
}
#[repr(C)]
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 @ {:p}", self))
.finish()
}
}
#[repr(C)]
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 @ {:p}", self)
}
}
#[link(name = "shumate-1.0")]
extern "C" {
pub fn shumate_file_cache_error_get_type() -> GType;
pub fn shumate_file_cache_error_quark() -> glib::GQuark;
pub fn shumate_map_projection_get_type() -> GType;
pub fn shumate_state_get_type() -> GType;
pub fn shumate_style_error_get_type() -> GType;
pub fn shumate_style_error_quark() -> glib::GQuark;
pub fn shumate_tile_downloader_error_get_type() -> GType;
pub fn shumate_tile_downloader_error_quark() -> glib::GQuark;
pub fn shumate_unit_get_type() -> GType;
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,
);
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;
pub fn shumate_data_source_get_type() -> GType;
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;
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;
pub fn shumate_layer_get_type() -> GType;
pub fn shumate_layer_get_viewport(self_: *mut ShumateLayer) -> *mut ShumateViewport;
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);
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);
pub fn shumate_map_layer_get_type() -> GType;
pub fn shumate_map_layer_new(
map_source: *mut ShumateMapSource,
viewport: *mut ShumateViewport,
) -> *mut ShumateMapLayer;
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);
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,
);
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);
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,
);
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);
pub fn shumate_point_get_type() -> GType;
pub fn shumate_point_new() -> *mut ShumatePoint;
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;
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);
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,
);
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(
self_: *mut ShumateSimpleMap,
layer: *mut ShumateLayer,
idx: c_uint,
);
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,
);
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_etag(self_: *mut ShumateTile) -> *const c_char;
pub fn shumate_tile_get_fade_in(self_: *mut ShumateTile) -> gboolean;
pub fn shumate_tile_get_modified_time(self_: *mut ShumateTile) -> *mut glib::GDateTime;
pub fn shumate_tile_get_paintable(self_: *mut ShumateTile) -> *mut gdk::GdkPaintable;
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_etag(self_: *mut ShumateTile, etag: *const c_char);
pub fn shumate_tile_set_fade_in(self_: *mut ShumateTile, fade_in: gboolean);
pub fn shumate_tile_set_modified_time(
self_: *mut ShumateTile,
modified_time: *mut glib::GDateTime,
);
pub fn shumate_tile_set_paintable(self_: *mut ShumateTile, paintable: *mut gdk::GdkPaintable);
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);
pub fn shumate_tile_downloader_get_type() -> GType;
pub fn shumate_tile_downloader_new(url_template: *const c_char) -> *mut ShumateTileDownloader;
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;
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;
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,
);
pub fn shumate_location_get_type() -> GType;
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,
);
pub fn shumate_get_user_agent() -> *const c_char;
pub fn shumate_set_user_agent(new_user_agent: *const c_char);
}