libgweather-4.4.0/.cargo_vcs_info.json0000644000000001510000000000100133330ustar { "git": { "sha1": "417782b288b1648c064845bb56354028997effac" }, "path_in_vcs": "libgweather" }libgweather-4.4.0/Cargo.toml0000644000000024600000000000100113360ustar # THIS FILE IS AUTOMATICALLY GENERATED BY CARGO # # When uploading crates to the registry Cargo will automatically # "normalize" Cargo.toml files for maximal compatibility # with all versions of Cargo and also rewrite `path` dependencies # to registry (e.g., crates.io) dependencies. # # If you are reading this file be aware that the original Cargo.toml # will likely look very different (and much more reasonable). # See Cargo.toml.orig for the original contents. [package] edition = "2021" name = "libgweather" version = "4.4.0" authors = ["Jamie Murphy "] description = "Rust bindings for libgweather" homepage = "https://gitlab.gnome.org/World/Rust/libgweather-rs" documentation = "https://world.pages.gitlab.gnome.org/Rust/libgweather-rs" readme = "README.md" keywords = [ "gtk-rs", "gnome", "weather", "gweather", ] categories = ["api-bindings"] license = "MIT" repository = "https://gitlab.gnome.org/World/Rust/libgweather-rs" resolver = "1" [package.metadata.docs.rs] all-features = true rustc-args = [ "--cfg", "docsrs", ] rustdoc-args = [ "--cfg", "docsrs", ] [lib] name = "libgweather" [dependencies.ffi] version = "4.4.0" package = "gweather-sys" [dependencies.gio] version = "0.19" [dependencies.glib] version = "0.19" [dependencies.libc] version = "0.2" libgweather-4.4.0/Cargo.toml.orig000064400000000000000000000016531046102023000150220ustar 00000000000000[package] name = "libgweather" version = "4.4.0" authors = ["Jamie Murphy "] edition = "2021" readme = "../README.md" homepage = "https://gitlab.gnome.org/World/Rust/libgweather-rs" description = "Rust bindings for libgweather" license = "MIT" repository = "https://gitlab.gnome.org/World/Rust/libgweather-rs" documentation = "https://world.pages.gitlab.gnome.org/Rust/libgweather-rs" categories = ["api-bindings"] keywords = ["gtk-rs", "gnome", "weather", "gweather"] [lib] name = "libgweather" [package.metadata.docs.rs] all-features = true rustc-args = ["--cfg", "docsrs"] rustdoc-args = ["--cfg", "docsrs"] [dependencies] libc = "0.2" [dependencies.ffi] package = "gweather-sys" path = "./sys" version = "4.4.0" [dependencies.glib] git = "https://github.com/gtk-rs/gtk-rs-core" version = "0.19" branch = "0.19" [dependencies.gio] git = "https://github.com/gtk-rs/gtk-rs-core" version = "0.19" branch = "0.19" libgweather-4.4.0/Gir.toml000064400000000000000000000027651046102023000135560ustar 00000000000000[options] library = "GWeather" version = "4.0" target_path = "." min_cfg_version = "4.0" work_mode = "normal" girs_directories = ["../gir-files", "../"] use_gi_docgen = true generate_safety_asserts = true deprecate_by_min_version = true # with this option enabled, versions for gir and gir-files saved only to one file to minimize noise single_version_file = true generate_builder = true trust_return_value_nullability = true generate = [ "GWeather.MoonLatitude", "GWeather.MoonPhase", "GWeather.ConditionPhenomenon", "GWeather.ConditionQualifier", "GWeather.FormatOptions", "GWeather.Provider", "GWeather.DistanceUnit", "GWeather.TemperatureUnit", "GWeather.PressureUnit", "GWeather.Sky", "GWeather.SpeedUnit", "GWeather.WindDirection", "GWeather.LocationLevel", "GWeather.FilterFunc" ] manual = [ "GLib.Variant", "GLib.Error", "Gio.Cancellable", "GLib.DestroyNotify", "Gio.AsyncReadyCallback", "Gio.AsyncResult", "GLib.TimeZone", "GWeather.Conditions" ] [[object]] name = "GWeather.Location" status = "generate" [[object.function]] name = "detect_nearest_city" manual = true # mis-generated function [[object.function]] name = "free_timezones" ignore = true # C Only [[object]] name = "GWeather.Info" status = "generate" [[object.function]] name = "get_upcoming_moonphases" manual = true # mis-generated function [[object.function]] name = "get_update" bypass_auto_rename = true libgweather-4.4.0/LICENSE000064400000000000000000000017771046102023000131470ustar 00000000000000Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. libgweather-4.4.0/README.md000064400000000000000000000005561046102023000134130ustar 00000000000000# libgweather-rs The Rust bindings of libgweather Website: https://world.pages.gitlab.gnome.org/Rust/libgweather-rs ## Documentation - libgweather: https://world.pages.gitlab.gnome.org/Rust/libgweather-rs/stable/latest/docs/libgweather/index.html - gweather-sys: https://world.pages.gitlab.gnome.org/Rust/libgweather-rs/stable/latest/docs/gweather_sys/index.htmllibgweather-4.4.0/src/auto/alias.rs000064400000000000000000000004421046102023000153240ustar 00000000000000// This file was generated by gir (https://github.com/gtk-rs/gir) // from .. // from ../gir-files // DO NOT EDIT #[allow(unused_imports)] use crate::auto::*; #[doc(alias = "GWeatherMoonLatitude")] pub type MoonLatitude = f64; #[doc(alias = "GWeatherMoonPhase")] pub type MoonPhase = f64; libgweather-4.4.0/src/auto/enums.rs000064400000000000000000001202621046102023000153650ustar 00000000000000// This file was generated by gir (https://github.com/gtk-rs/gir) // from .. // from ../gir-files // DO NOT EDIT use crate::{FormatOptions}; use glib::{prelude::*,translate::*,GStr}; #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] #[derive(Clone, Copy)] #[non_exhaustive] #[doc(alias = "GWeatherConditionPhenomenon")] pub enum ConditionPhenomenon { #[doc(alias = "GWEATHER_PHENOMENON_INVALID")] Invalid, #[doc(alias = "GWEATHER_PHENOMENON_NONE")] None, #[doc(alias = "GWEATHER_PHENOMENON_DRIZZLE")] Drizzle, #[doc(alias = "GWEATHER_PHENOMENON_RAIN")] Rain, #[doc(alias = "GWEATHER_PHENOMENON_SNOW")] Snow, #[doc(alias = "GWEATHER_PHENOMENON_SNOW_GRAINS")] SnowGrains, #[doc(alias = "GWEATHER_PHENOMENON_ICE_CRYSTALS")] IceCrystals, #[doc(alias = "GWEATHER_PHENOMENON_ICE_PELLETS")] IcePellets, #[doc(alias = "GWEATHER_PHENOMENON_HAIL")] Hail, #[doc(alias = "GWEATHER_PHENOMENON_SMALL_HAIL")] SmallHail, #[doc(alias = "GWEATHER_PHENOMENON_UNKNOWN_PRECIPITATION")] UnknownPrecipitation, #[doc(alias = "GWEATHER_PHENOMENON_MIST")] Mist, #[doc(alias = "GWEATHER_PHENOMENON_FOG")] Fog, #[doc(alias = "GWEATHER_PHENOMENON_SMOKE")] Smoke, #[doc(alias = "GWEATHER_PHENOMENON_VOLCANIC_ASH")] VolcanicAsh, #[doc(alias = "GWEATHER_PHENOMENON_SAND")] Sand, #[doc(alias = "GWEATHER_PHENOMENON_HAZE")] Haze, #[doc(alias = "GWEATHER_PHENOMENON_SPRAY")] Spray, #[doc(alias = "GWEATHER_PHENOMENON_DUST")] Dust, #[doc(alias = "GWEATHER_PHENOMENON_SQUALL")] Squall, #[doc(alias = "GWEATHER_PHENOMENON_SANDSTORM")] Sandstorm, #[doc(alias = "GWEATHER_PHENOMENON_DUSTSTORM")] Duststorm, #[doc(alias = "GWEATHER_PHENOMENON_FUNNEL_CLOUD")] FunnelCloud, #[doc(alias = "GWEATHER_PHENOMENON_TORNADO")] Tornado, #[doc(alias = "GWEATHER_PHENOMENON_DUST_WHIRLS")] DustWhirls, #[doc(alias = "GWEATHER_PHENOMENON_LAST")] Last, #[doc(hidden)] __Unknown(i32), } #[doc(hidden)] impl IntoGlib for ConditionPhenomenon { type GlibType = ffi::GWeatherConditionPhenomenon; fn into_glib(self) -> ffi::GWeatherConditionPhenomenon { match self { Self::Invalid => ffi::GWEATHER_PHENOMENON_INVALID, Self::None => ffi::GWEATHER_PHENOMENON_NONE, Self::Drizzle => ffi::GWEATHER_PHENOMENON_DRIZZLE, Self::Rain => ffi::GWEATHER_PHENOMENON_RAIN, Self::Snow => ffi::GWEATHER_PHENOMENON_SNOW, Self::SnowGrains => ffi::GWEATHER_PHENOMENON_SNOW_GRAINS, Self::IceCrystals => ffi::GWEATHER_PHENOMENON_ICE_CRYSTALS, Self::IcePellets => ffi::GWEATHER_PHENOMENON_ICE_PELLETS, Self::Hail => ffi::GWEATHER_PHENOMENON_HAIL, Self::SmallHail => ffi::GWEATHER_PHENOMENON_SMALL_HAIL, Self::UnknownPrecipitation => ffi::GWEATHER_PHENOMENON_UNKNOWN_PRECIPITATION, Self::Mist => ffi::GWEATHER_PHENOMENON_MIST, Self::Fog => ffi::GWEATHER_PHENOMENON_FOG, Self::Smoke => ffi::GWEATHER_PHENOMENON_SMOKE, Self::VolcanicAsh => ffi::GWEATHER_PHENOMENON_VOLCANIC_ASH, Self::Sand => ffi::GWEATHER_PHENOMENON_SAND, Self::Haze => ffi::GWEATHER_PHENOMENON_HAZE, Self::Spray => ffi::GWEATHER_PHENOMENON_SPRAY, Self::Dust => ffi::GWEATHER_PHENOMENON_DUST, Self::Squall => ffi::GWEATHER_PHENOMENON_SQUALL, Self::Sandstorm => ffi::GWEATHER_PHENOMENON_SANDSTORM, Self::Duststorm => ffi::GWEATHER_PHENOMENON_DUSTSTORM, Self::FunnelCloud => ffi::GWEATHER_PHENOMENON_FUNNEL_CLOUD, Self::Tornado => ffi::GWEATHER_PHENOMENON_TORNADO, Self::DustWhirls => ffi::GWEATHER_PHENOMENON_DUST_WHIRLS, Self::Last => ffi::GWEATHER_PHENOMENON_LAST, Self::__Unknown(value) => value, } } } #[doc(hidden)] impl FromGlib for ConditionPhenomenon { unsafe fn from_glib(value: ffi::GWeatherConditionPhenomenon) -> Self { skip_assert_initialized!(); match value { ffi::GWEATHER_PHENOMENON_INVALID => Self::Invalid, ffi::GWEATHER_PHENOMENON_NONE => Self::None, ffi::GWEATHER_PHENOMENON_DRIZZLE => Self::Drizzle, ffi::GWEATHER_PHENOMENON_RAIN => Self::Rain, ffi::GWEATHER_PHENOMENON_SNOW => Self::Snow, ffi::GWEATHER_PHENOMENON_SNOW_GRAINS => Self::SnowGrains, ffi::GWEATHER_PHENOMENON_ICE_CRYSTALS => Self::IceCrystals, ffi::GWEATHER_PHENOMENON_ICE_PELLETS => Self::IcePellets, ffi::GWEATHER_PHENOMENON_HAIL => Self::Hail, ffi::GWEATHER_PHENOMENON_SMALL_HAIL => Self::SmallHail, ffi::GWEATHER_PHENOMENON_UNKNOWN_PRECIPITATION => Self::UnknownPrecipitation, ffi::GWEATHER_PHENOMENON_MIST => Self::Mist, ffi::GWEATHER_PHENOMENON_FOG => Self::Fog, ffi::GWEATHER_PHENOMENON_SMOKE => Self::Smoke, ffi::GWEATHER_PHENOMENON_VOLCANIC_ASH => Self::VolcanicAsh, ffi::GWEATHER_PHENOMENON_SAND => Self::Sand, ffi::GWEATHER_PHENOMENON_HAZE => Self::Haze, ffi::GWEATHER_PHENOMENON_SPRAY => Self::Spray, ffi::GWEATHER_PHENOMENON_DUST => Self::Dust, ffi::GWEATHER_PHENOMENON_SQUALL => Self::Squall, ffi::GWEATHER_PHENOMENON_SANDSTORM => Self::Sandstorm, ffi::GWEATHER_PHENOMENON_DUSTSTORM => Self::Duststorm, ffi::GWEATHER_PHENOMENON_FUNNEL_CLOUD => Self::FunnelCloud, ffi::GWEATHER_PHENOMENON_TORNADO => Self::Tornado, ffi::GWEATHER_PHENOMENON_DUST_WHIRLS => Self::DustWhirls, ffi::GWEATHER_PHENOMENON_LAST => Self::Last, value => Self::__Unknown(value), } } } impl StaticType for ConditionPhenomenon { #[inline] #[doc(alias = "gweather_phenomenon_get_type")] fn static_type() -> glib::Type { unsafe { from_glib(ffi::gweather_phenomenon_get_type()) } } } impl glib::HasParamSpec for ConditionPhenomenon { type ParamSpec = glib::ParamSpecEnum; type SetValue = Self; type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder; fn param_spec_builder() -> Self::BuilderFn { Self::ParamSpec::builder_with_default } } impl glib::value::ValueType for ConditionPhenomenon { type Type = Self; } unsafe impl<'a> glib::value::FromValue<'a> for ConditionPhenomenon { type Checker = glib::value::GenericValueTypeChecker; #[inline] unsafe fn from_value(value: &'a glib::Value) -> Self { skip_assert_initialized!(); from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) } } impl ToValue for ConditionPhenomenon { #[inline] fn to_value(&self) -> glib::Value { let mut value = glib::Value::for_value_type::(); unsafe { glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); } value } #[inline] fn value_type(&self) -> glib::Type { Self::static_type() } } impl From for glib::Value { #[inline] fn from(v: ConditionPhenomenon) -> Self { skip_assert_initialized!(); ToValue::to_value(&v) } } #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] #[derive(Clone, Copy)] #[non_exhaustive] #[doc(alias = "GWeatherConditionQualifier")] pub enum ConditionQualifier { #[doc(alias = "GWEATHER_QUALIFIER_INVALID")] Invalid, #[doc(alias = "GWEATHER_QUALIFIER_NONE")] None, #[doc(alias = "GWEATHER_QUALIFIER_VICINITY")] Vicinity, #[doc(alias = "GWEATHER_QUALIFIER_LIGHT")] Light, #[doc(alias = "GWEATHER_QUALIFIER_MODERATE")] Moderate, #[doc(alias = "GWEATHER_QUALIFIER_HEAVY")] Heavy, #[doc(alias = "GWEATHER_QUALIFIER_SHALLOW")] Shallow, #[doc(alias = "GWEATHER_QUALIFIER_PATCHES")] Patches, #[doc(alias = "GWEATHER_QUALIFIER_PARTIAL")] Partial, #[doc(alias = "GWEATHER_QUALIFIER_THUNDERSTORM")] Thunderstorm, #[doc(alias = "GWEATHER_QUALIFIER_BLOWING")] Blowing, #[doc(alias = "GWEATHER_QUALIFIER_SHOWERS")] Showers, #[doc(alias = "GWEATHER_QUALIFIER_DRIFTING")] Drifting, #[doc(alias = "GWEATHER_QUALIFIER_FREEZING")] Freezing, #[doc(alias = "GWEATHER_QUALIFIER_LAST")] Last, #[doc(hidden)] __Unknown(i32), } #[doc(hidden)] impl IntoGlib for ConditionQualifier { type GlibType = ffi::GWeatherConditionQualifier; fn into_glib(self) -> ffi::GWeatherConditionQualifier { match self { Self::Invalid => ffi::GWEATHER_QUALIFIER_INVALID, Self::None => ffi::GWEATHER_QUALIFIER_NONE, Self::Vicinity => ffi::GWEATHER_QUALIFIER_VICINITY, Self::Light => ffi::GWEATHER_QUALIFIER_LIGHT, Self::Moderate => ffi::GWEATHER_QUALIFIER_MODERATE, Self::Heavy => ffi::GWEATHER_QUALIFIER_HEAVY, Self::Shallow => ffi::GWEATHER_QUALIFIER_SHALLOW, Self::Patches => ffi::GWEATHER_QUALIFIER_PATCHES, Self::Partial => ffi::GWEATHER_QUALIFIER_PARTIAL, Self::Thunderstorm => ffi::GWEATHER_QUALIFIER_THUNDERSTORM, Self::Blowing => ffi::GWEATHER_QUALIFIER_BLOWING, Self::Showers => ffi::GWEATHER_QUALIFIER_SHOWERS, Self::Drifting => ffi::GWEATHER_QUALIFIER_DRIFTING, Self::Freezing => ffi::GWEATHER_QUALIFIER_FREEZING, Self::Last => ffi::GWEATHER_QUALIFIER_LAST, Self::__Unknown(value) => value, } } } #[doc(hidden)] impl FromGlib for ConditionQualifier { unsafe fn from_glib(value: ffi::GWeatherConditionQualifier) -> Self { skip_assert_initialized!(); match value { ffi::GWEATHER_QUALIFIER_INVALID => Self::Invalid, ffi::GWEATHER_QUALIFIER_NONE => Self::None, ffi::GWEATHER_QUALIFIER_VICINITY => Self::Vicinity, ffi::GWEATHER_QUALIFIER_LIGHT => Self::Light, ffi::GWEATHER_QUALIFIER_MODERATE => Self::Moderate, ffi::GWEATHER_QUALIFIER_HEAVY => Self::Heavy, ffi::GWEATHER_QUALIFIER_SHALLOW => Self::Shallow, ffi::GWEATHER_QUALIFIER_PATCHES => Self::Patches, ffi::GWEATHER_QUALIFIER_PARTIAL => Self::Partial, ffi::GWEATHER_QUALIFIER_THUNDERSTORM => Self::Thunderstorm, ffi::GWEATHER_QUALIFIER_BLOWING => Self::Blowing, ffi::GWEATHER_QUALIFIER_SHOWERS => Self::Showers, ffi::GWEATHER_QUALIFIER_DRIFTING => Self::Drifting, ffi::GWEATHER_QUALIFIER_FREEZING => Self::Freezing, ffi::GWEATHER_QUALIFIER_LAST => Self::Last, value => Self::__Unknown(value), } } } impl StaticType for ConditionQualifier { #[inline] #[doc(alias = "gweather_qualifier_get_type")] fn static_type() -> glib::Type { unsafe { from_glib(ffi::gweather_qualifier_get_type()) } } } impl glib::HasParamSpec for ConditionQualifier { type ParamSpec = glib::ParamSpecEnum; type SetValue = Self; type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder; fn param_spec_builder() -> Self::BuilderFn { Self::ParamSpec::builder_with_default } } impl glib::value::ValueType for ConditionQualifier { type Type = Self; } unsafe impl<'a> glib::value::FromValue<'a> for ConditionQualifier { type Checker = glib::value::GenericValueTypeChecker; #[inline] unsafe fn from_value(value: &'a glib::Value) -> Self { skip_assert_initialized!(); from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) } } impl ToValue for ConditionQualifier { #[inline] fn to_value(&self) -> glib::Value { let mut value = glib::Value::for_value_type::(); unsafe { glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); } value } #[inline] fn value_type(&self) -> glib::Type { Self::static_type() } } impl From for glib::Value { #[inline] fn from(v: ConditionQualifier) -> Self { skip_assert_initialized!(); ToValue::to_value(&v) } } #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] #[derive(Clone, Copy)] #[non_exhaustive] #[doc(alias = "GWeatherDistanceUnit")] pub enum DistanceUnit { #[doc(alias = "GWEATHER_DISTANCE_UNIT_INVALID")] Invalid, #[doc(alias = "GWEATHER_DISTANCE_UNIT_DEFAULT")] Default, #[doc(alias = "GWEATHER_DISTANCE_UNIT_METERS")] Meters, #[doc(alias = "GWEATHER_DISTANCE_UNIT_KM")] Km, #[doc(alias = "GWEATHER_DISTANCE_UNIT_MILES")] Miles, #[doc(hidden)] __Unknown(i32), } #[doc(hidden)] impl IntoGlib for DistanceUnit { type GlibType = ffi::GWeatherDistanceUnit; #[inline] fn into_glib(self) -> ffi::GWeatherDistanceUnit { match self { Self::Invalid => ffi::GWEATHER_DISTANCE_UNIT_INVALID, Self::Default => ffi::GWEATHER_DISTANCE_UNIT_DEFAULT, Self::Meters => ffi::GWEATHER_DISTANCE_UNIT_METERS, Self::Km => ffi::GWEATHER_DISTANCE_UNIT_KM, Self::Miles => ffi::GWEATHER_DISTANCE_UNIT_MILES, Self::__Unknown(value) => value, } } } #[doc(hidden)] impl FromGlib for DistanceUnit { #[inline] unsafe fn from_glib(value: ffi::GWeatherDistanceUnit) -> Self { skip_assert_initialized!(); match value { ffi::GWEATHER_DISTANCE_UNIT_INVALID => Self::Invalid, ffi::GWEATHER_DISTANCE_UNIT_DEFAULT => Self::Default, ffi::GWEATHER_DISTANCE_UNIT_METERS => Self::Meters, ffi::GWEATHER_DISTANCE_UNIT_KM => Self::Km, ffi::GWEATHER_DISTANCE_UNIT_MILES => Self::Miles, value => Self::__Unknown(value), } } } impl StaticType for DistanceUnit { #[inline] #[doc(alias = "gweather_distance_unit_get_type")] fn static_type() -> glib::Type { unsafe { from_glib(ffi::gweather_distance_unit_get_type()) } } } impl glib::HasParamSpec for DistanceUnit { type ParamSpec = glib::ParamSpecEnum; type SetValue = Self; type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder; fn param_spec_builder() -> Self::BuilderFn { Self::ParamSpec::builder_with_default } } impl glib::value::ValueType for DistanceUnit { type Type = Self; } unsafe impl<'a> glib::value::FromValue<'a> for DistanceUnit { type Checker = glib::value::GenericValueTypeChecker; #[inline] unsafe fn from_value(value: &'a glib::Value) -> Self { skip_assert_initialized!(); from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) } } impl ToValue for DistanceUnit { #[inline] fn to_value(&self) -> glib::Value { let mut value = glib::Value::for_value_type::(); unsafe { glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); } value } #[inline] fn value_type(&self) -> glib::Type { Self::static_type() } } impl From for glib::Value { #[inline] fn from(v: DistanceUnit) -> Self { skip_assert_initialized!(); ToValue::to_value(&v) } } #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] #[derive(Clone, Copy)] #[non_exhaustive] #[doc(alias = "GWeatherLocationLevel")] pub enum LocationLevel { #[doc(alias = "GWEATHER_LOCATION_WORLD")] World, #[doc(alias = "GWEATHER_LOCATION_REGION")] Region, #[doc(alias = "GWEATHER_LOCATION_COUNTRY")] Country, #[doc(alias = "GWEATHER_LOCATION_ADM1")] Adm1, #[doc(alias = "GWEATHER_LOCATION_CITY")] City, #[doc(alias = "GWEATHER_LOCATION_WEATHER_STATION")] WeatherStation, #[doc(alias = "GWEATHER_LOCATION_DETACHED")] Detached, #[doc(alias = "GWEATHER_LOCATION_NAMED_TIMEZONE")] NamedTimezone, #[doc(hidden)] __Unknown(i32), } impl LocationLevel { pub fn to_str<'a>(self) -> &'a GStr { unsafe { GStr::from_ptr( ffi::gweather_location_level_to_string(self.into_glib()) .as_ref() .expect("gweather_location_level_to_string returned NULL"), ) } } } impl std::fmt::Display for LocationLevel { #[inline] fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { f.write_str(&self.to_str()) } } #[doc(hidden)] impl IntoGlib for LocationLevel { type GlibType = ffi::GWeatherLocationLevel; #[inline] fn into_glib(self) -> ffi::GWeatherLocationLevel { match self { Self::World => ffi::GWEATHER_LOCATION_WORLD, Self::Region => ffi::GWEATHER_LOCATION_REGION, Self::Country => ffi::GWEATHER_LOCATION_COUNTRY, Self::Adm1 => ffi::GWEATHER_LOCATION_ADM1, Self::City => ffi::GWEATHER_LOCATION_CITY, Self::WeatherStation => ffi::GWEATHER_LOCATION_WEATHER_STATION, Self::Detached => ffi::GWEATHER_LOCATION_DETACHED, Self::NamedTimezone => ffi::GWEATHER_LOCATION_NAMED_TIMEZONE, Self::__Unknown(value) => value, } } } #[doc(hidden)] impl FromGlib for LocationLevel { #[inline] unsafe fn from_glib(value: ffi::GWeatherLocationLevel) -> Self { skip_assert_initialized!(); match value { ffi::GWEATHER_LOCATION_WORLD => Self::World, ffi::GWEATHER_LOCATION_REGION => Self::Region, ffi::GWEATHER_LOCATION_COUNTRY => Self::Country, ffi::GWEATHER_LOCATION_ADM1 => Self::Adm1, ffi::GWEATHER_LOCATION_CITY => Self::City, ffi::GWEATHER_LOCATION_WEATHER_STATION => Self::WeatherStation, ffi::GWEATHER_LOCATION_DETACHED => Self::Detached, ffi::GWEATHER_LOCATION_NAMED_TIMEZONE => Self::NamedTimezone, value => Self::__Unknown(value), } } } impl StaticType for LocationLevel { #[inline] #[doc(alias = "gweather_location_level_get_type")] fn static_type() -> glib::Type { unsafe { from_glib(ffi::gweather_location_level_get_type()) } } } impl glib::HasParamSpec for LocationLevel { type ParamSpec = glib::ParamSpecEnum; type SetValue = Self; type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder; fn param_spec_builder() -> Self::BuilderFn { Self::ParamSpec::builder_with_default } } impl glib::value::ValueType for LocationLevel { type Type = Self; } unsafe impl<'a> glib::value::FromValue<'a> for LocationLevel { type Checker = glib::value::GenericValueTypeChecker; #[inline] unsafe fn from_value(value: &'a glib::Value) -> Self { skip_assert_initialized!(); from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) } } impl ToValue for LocationLevel { #[inline] fn to_value(&self) -> glib::Value { let mut value = glib::Value::for_value_type::(); unsafe { glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); } value } #[inline] fn value_type(&self) -> glib::Type { Self::static_type() } } impl From for glib::Value { #[inline] fn from(v: LocationLevel) -> Self { skip_assert_initialized!(); ToValue::to_value(&v) } } #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] #[derive(Clone, Copy)] #[non_exhaustive] #[doc(alias = "GWeatherPressureUnit")] pub enum PressureUnit { #[doc(alias = "GWEATHER_PRESSURE_UNIT_INVALID")] Invalid, #[doc(alias = "GWEATHER_PRESSURE_UNIT_DEFAULT")] Default, #[doc(alias = "GWEATHER_PRESSURE_UNIT_KPA")] Kpa, #[doc(alias = "GWEATHER_PRESSURE_UNIT_HPA")] Hpa, #[doc(alias = "GWEATHER_PRESSURE_UNIT_MB")] Mb, #[doc(alias = "GWEATHER_PRESSURE_UNIT_MM_HG")] MmHg, #[doc(alias = "GWEATHER_PRESSURE_UNIT_INCH_HG")] InchHg, #[doc(alias = "GWEATHER_PRESSURE_UNIT_ATM")] Atm, #[doc(hidden)] __Unknown(i32), } #[doc(hidden)] impl IntoGlib for PressureUnit { type GlibType = ffi::GWeatherPressureUnit; #[inline] fn into_glib(self) -> ffi::GWeatherPressureUnit { match self { Self::Invalid => ffi::GWEATHER_PRESSURE_UNIT_INVALID, Self::Default => ffi::GWEATHER_PRESSURE_UNIT_DEFAULT, Self::Kpa => ffi::GWEATHER_PRESSURE_UNIT_KPA, Self::Hpa => ffi::GWEATHER_PRESSURE_UNIT_HPA, Self::Mb => ffi::GWEATHER_PRESSURE_UNIT_MB, Self::MmHg => ffi::GWEATHER_PRESSURE_UNIT_MM_HG, Self::InchHg => ffi::GWEATHER_PRESSURE_UNIT_INCH_HG, Self::Atm => ffi::GWEATHER_PRESSURE_UNIT_ATM, Self::__Unknown(value) => value, } } } #[doc(hidden)] impl FromGlib for PressureUnit { #[inline] unsafe fn from_glib(value: ffi::GWeatherPressureUnit) -> Self { skip_assert_initialized!(); match value { ffi::GWEATHER_PRESSURE_UNIT_INVALID => Self::Invalid, ffi::GWEATHER_PRESSURE_UNIT_DEFAULT => Self::Default, ffi::GWEATHER_PRESSURE_UNIT_KPA => Self::Kpa, ffi::GWEATHER_PRESSURE_UNIT_HPA => Self::Hpa, ffi::GWEATHER_PRESSURE_UNIT_MB => Self::Mb, ffi::GWEATHER_PRESSURE_UNIT_MM_HG => Self::MmHg, ffi::GWEATHER_PRESSURE_UNIT_INCH_HG => Self::InchHg, ffi::GWEATHER_PRESSURE_UNIT_ATM => Self::Atm, value => Self::__Unknown(value), } } } impl StaticType for PressureUnit { #[inline] #[doc(alias = "gweather_pressure_unit_get_type")] fn static_type() -> glib::Type { unsafe { from_glib(ffi::gweather_pressure_unit_get_type()) } } } impl glib::HasParamSpec for PressureUnit { type ParamSpec = glib::ParamSpecEnum; type SetValue = Self; type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder; fn param_spec_builder() -> Self::BuilderFn { Self::ParamSpec::builder_with_default } } impl glib::value::ValueType for PressureUnit { type Type = Self; } unsafe impl<'a> glib::value::FromValue<'a> for PressureUnit { type Checker = glib::value::GenericValueTypeChecker; #[inline] unsafe fn from_value(value: &'a glib::Value) -> Self { skip_assert_initialized!(); from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) } } impl ToValue for PressureUnit { #[inline] fn to_value(&self) -> glib::Value { let mut value = glib::Value::for_value_type::(); unsafe { glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); } value } #[inline] fn value_type(&self) -> glib::Type { Self::static_type() } } impl From for glib::Value { #[inline] fn from(v: PressureUnit) -> Self { skip_assert_initialized!(); ToValue::to_value(&v) } } #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] #[derive(Clone, Copy)] #[non_exhaustive] #[doc(alias = "GWeatherSky")] pub enum Sky { #[doc(alias = "GWEATHER_SKY_INVALID")] Invalid, #[doc(alias = "GWEATHER_SKY_CLEAR")] Clear, #[doc(alias = "GWEATHER_SKY_BROKEN")] Broken, #[doc(alias = "GWEATHER_SKY_SCATTERED")] Scattered, #[doc(alias = "GWEATHER_SKY_FEW")] Few, #[doc(alias = "GWEATHER_SKY_OVERCAST")] Overcast, #[doc(alias = "GWEATHER_SKY_LAST")] Last, #[doc(hidden)] __Unknown(i32), } impl Sky { pub fn to_str<'a>(self) -> &'a GStr { unsafe { GStr::from_ptr( ffi::gweather_sky_to_string(self.into_glib()) .as_ref() .expect("gweather_sky_to_string returned NULL"), ) } } #[doc(alias = "gweather_sky_to_string_full")] pub fn to_string_full(self, options: FormatOptions) -> glib::GString { assert_initialized_main_thread!(); unsafe { from_glib_none(ffi::gweather_sky_to_string_full(self.into_glib(), options.into_glib())) } } } impl std::fmt::Display for Sky { #[inline] fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { f.write_str(&self.to_str()) } } #[doc(hidden)] impl IntoGlib for Sky { type GlibType = ffi::GWeatherSky; #[inline] fn into_glib(self) -> ffi::GWeatherSky { match self { Self::Invalid => ffi::GWEATHER_SKY_INVALID, Self::Clear => ffi::GWEATHER_SKY_CLEAR, Self::Broken => ffi::GWEATHER_SKY_BROKEN, Self::Scattered => ffi::GWEATHER_SKY_SCATTERED, Self::Few => ffi::GWEATHER_SKY_FEW, Self::Overcast => ffi::GWEATHER_SKY_OVERCAST, Self::Last => ffi::GWEATHER_SKY_LAST, Self::__Unknown(value) => value, } } } #[doc(hidden)] impl FromGlib for Sky { #[inline] unsafe fn from_glib(value: ffi::GWeatherSky) -> Self { skip_assert_initialized!(); match value { ffi::GWEATHER_SKY_INVALID => Self::Invalid, ffi::GWEATHER_SKY_CLEAR => Self::Clear, ffi::GWEATHER_SKY_BROKEN => Self::Broken, ffi::GWEATHER_SKY_SCATTERED => Self::Scattered, ffi::GWEATHER_SKY_FEW => Self::Few, ffi::GWEATHER_SKY_OVERCAST => Self::Overcast, ffi::GWEATHER_SKY_LAST => Self::Last, value => Self::__Unknown(value), } } } impl StaticType for Sky { #[inline] #[doc(alias = "gweather_sky_get_type")] fn static_type() -> glib::Type { unsafe { from_glib(ffi::gweather_sky_get_type()) } } } impl glib::HasParamSpec for Sky { type ParamSpec = glib::ParamSpecEnum; type SetValue = Self; type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder; fn param_spec_builder() -> Self::BuilderFn { Self::ParamSpec::builder_with_default } } impl glib::value::ValueType for Sky { type Type = Self; } unsafe impl<'a> glib::value::FromValue<'a> for Sky { type Checker = glib::value::GenericValueTypeChecker; #[inline] unsafe fn from_value(value: &'a glib::Value) -> Self { skip_assert_initialized!(); from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) } } impl ToValue for Sky { #[inline] fn to_value(&self) -> glib::Value { let mut value = glib::Value::for_value_type::(); unsafe { glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); } value } #[inline] fn value_type(&self) -> glib::Type { Self::static_type() } } impl From for glib::Value { #[inline] fn from(v: Sky) -> Self { skip_assert_initialized!(); ToValue::to_value(&v) } } #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] #[derive(Clone, Copy)] #[non_exhaustive] #[doc(alias = "GWeatherSpeedUnit")] pub enum SpeedUnit { #[doc(alias = "GWEATHER_SPEED_UNIT_INVALID")] Invalid, #[doc(alias = "GWEATHER_SPEED_UNIT_DEFAULT")] Default, #[doc(alias = "GWEATHER_SPEED_UNIT_MS")] Ms, #[doc(alias = "GWEATHER_SPEED_UNIT_KPH")] Kph, #[doc(alias = "GWEATHER_SPEED_UNIT_MPH")] Mph, #[doc(alias = "GWEATHER_SPEED_UNIT_KNOTS")] Knots, #[doc(alias = "GWEATHER_SPEED_UNIT_BFT")] Bft, #[doc(hidden)] __Unknown(i32), } impl SpeedUnit { pub fn to_str<'a>(self) -> &'a GStr { unsafe { GStr::from_ptr( ffi::gweather_speed_unit_to_string(self.into_glib()) .as_ref() .expect("gweather_speed_unit_to_string returned NULL"), ) } } } impl std::fmt::Display for SpeedUnit { #[inline] fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { f.write_str(&self.to_str()) } } #[doc(hidden)] impl IntoGlib for SpeedUnit { type GlibType = ffi::GWeatherSpeedUnit; #[inline] fn into_glib(self) -> ffi::GWeatherSpeedUnit { match self { Self::Invalid => ffi::GWEATHER_SPEED_UNIT_INVALID, Self::Default => ffi::GWEATHER_SPEED_UNIT_DEFAULT, Self::Ms => ffi::GWEATHER_SPEED_UNIT_MS, Self::Kph => ffi::GWEATHER_SPEED_UNIT_KPH, Self::Mph => ffi::GWEATHER_SPEED_UNIT_MPH, Self::Knots => ffi::GWEATHER_SPEED_UNIT_KNOTS, Self::Bft => ffi::GWEATHER_SPEED_UNIT_BFT, Self::__Unknown(value) => value, } } } #[doc(hidden)] impl FromGlib for SpeedUnit { #[inline] unsafe fn from_glib(value: ffi::GWeatherSpeedUnit) -> Self { skip_assert_initialized!(); match value { ffi::GWEATHER_SPEED_UNIT_INVALID => Self::Invalid, ffi::GWEATHER_SPEED_UNIT_DEFAULT => Self::Default, ffi::GWEATHER_SPEED_UNIT_MS => Self::Ms, ffi::GWEATHER_SPEED_UNIT_KPH => Self::Kph, ffi::GWEATHER_SPEED_UNIT_MPH => Self::Mph, ffi::GWEATHER_SPEED_UNIT_KNOTS => Self::Knots, ffi::GWEATHER_SPEED_UNIT_BFT => Self::Bft, value => Self::__Unknown(value), } } } impl StaticType for SpeedUnit { #[inline] #[doc(alias = "gweather_speed_unit_get_type")] fn static_type() -> glib::Type { unsafe { from_glib(ffi::gweather_speed_unit_get_type()) } } } impl glib::HasParamSpec for SpeedUnit { type ParamSpec = glib::ParamSpecEnum; type SetValue = Self; type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder; fn param_spec_builder() -> Self::BuilderFn { Self::ParamSpec::builder_with_default } } impl glib::value::ValueType for SpeedUnit { type Type = Self; } unsafe impl<'a> glib::value::FromValue<'a> for SpeedUnit { type Checker = glib::value::GenericValueTypeChecker; #[inline] unsafe fn from_value(value: &'a glib::Value) -> Self { skip_assert_initialized!(); from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) } } impl ToValue for SpeedUnit { #[inline] fn to_value(&self) -> glib::Value { let mut value = glib::Value::for_value_type::(); unsafe { glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); } value } #[inline] fn value_type(&self) -> glib::Type { Self::static_type() } } impl From for glib::Value { #[inline] fn from(v: SpeedUnit) -> Self { skip_assert_initialized!(); ToValue::to_value(&v) } } #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] #[derive(Clone, Copy)] #[non_exhaustive] #[doc(alias = "GWeatherTemperatureUnit")] pub enum TemperatureUnit { #[doc(alias = "GWEATHER_TEMP_UNIT_INVALID")] Invalid, #[doc(alias = "GWEATHER_TEMP_UNIT_DEFAULT")] Default, #[doc(alias = "GWEATHER_TEMP_UNIT_KELVIN")] Kelvin, #[doc(alias = "GWEATHER_TEMP_UNIT_CENTIGRADE")] Centigrade, #[doc(alias = "GWEATHER_TEMP_UNIT_FAHRENHEIT")] Fahrenheit, #[doc(hidden)] __Unknown(i32), } impl TemperatureUnit { #[doc(alias = "gweather_temperature_unit_to_real")] pub fn to_real(self) -> TemperatureUnit { assert_initialized_main_thread!(); unsafe { from_glib(ffi::gweather_temperature_unit_to_real(self.into_glib())) } } } #[doc(hidden)] impl IntoGlib for TemperatureUnit { type GlibType = ffi::GWeatherTemperatureUnit; #[inline] fn into_glib(self) -> ffi::GWeatherTemperatureUnit { match self { Self::Invalid => ffi::GWEATHER_TEMP_UNIT_INVALID, Self::Default => ffi::GWEATHER_TEMP_UNIT_DEFAULT, Self::Kelvin => ffi::GWEATHER_TEMP_UNIT_KELVIN, Self::Centigrade => ffi::GWEATHER_TEMP_UNIT_CENTIGRADE, Self::Fahrenheit => ffi::GWEATHER_TEMP_UNIT_FAHRENHEIT, Self::__Unknown(value) => value, } } } #[doc(hidden)] impl FromGlib for TemperatureUnit { #[inline] unsafe fn from_glib(value: ffi::GWeatherTemperatureUnit) -> Self { skip_assert_initialized!(); match value { ffi::GWEATHER_TEMP_UNIT_INVALID => Self::Invalid, ffi::GWEATHER_TEMP_UNIT_DEFAULT => Self::Default, ffi::GWEATHER_TEMP_UNIT_KELVIN => Self::Kelvin, ffi::GWEATHER_TEMP_UNIT_CENTIGRADE => Self::Centigrade, ffi::GWEATHER_TEMP_UNIT_FAHRENHEIT => Self::Fahrenheit, value => Self::__Unknown(value), } } } impl StaticType for TemperatureUnit { #[inline] #[doc(alias = "gweather_temperature_unit_get_type")] fn static_type() -> glib::Type { unsafe { from_glib(ffi::gweather_temperature_unit_get_type()) } } } impl glib::HasParamSpec for TemperatureUnit { type ParamSpec = glib::ParamSpecEnum; type SetValue = Self; type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder; fn param_spec_builder() -> Self::BuilderFn { Self::ParamSpec::builder_with_default } } impl glib::value::ValueType for TemperatureUnit { type Type = Self; } unsafe impl<'a> glib::value::FromValue<'a> for TemperatureUnit { type Checker = glib::value::GenericValueTypeChecker; #[inline] unsafe fn from_value(value: &'a glib::Value) -> Self { skip_assert_initialized!(); from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) } } impl ToValue for TemperatureUnit { #[inline] fn to_value(&self) -> glib::Value { let mut value = glib::Value::for_value_type::(); unsafe { glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); } value } #[inline] fn value_type(&self) -> glib::Type { Self::static_type() } } impl From for glib::Value { #[inline] fn from(v: TemperatureUnit) -> Self { skip_assert_initialized!(); ToValue::to_value(&v) } } #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] #[derive(Clone, Copy)] #[non_exhaustive] #[doc(alias = "GWeatherWindDirection")] pub enum WindDirection { #[doc(alias = "GWEATHER_WIND_INVALID")] Invalid, #[doc(alias = "GWEATHER_WIND_VARIABLE")] Variable, #[doc(alias = "GWEATHER_WIND_N")] N, #[doc(alias = "GWEATHER_WIND_NNE")] Nne, #[doc(alias = "GWEATHER_WIND_NE")] Ne, #[doc(alias = "GWEATHER_WIND_ENE")] Ene, #[doc(alias = "GWEATHER_WIND_E")] E, #[doc(alias = "GWEATHER_WIND_ESE")] Ese, #[doc(alias = "GWEATHER_WIND_SE")] Se, #[doc(alias = "GWEATHER_WIND_SSE")] Sse, #[doc(alias = "GWEATHER_WIND_S")] S, #[doc(alias = "GWEATHER_WIND_SSW")] Ssw, #[doc(alias = "GWEATHER_WIND_SW")] Sw, #[doc(alias = "GWEATHER_WIND_WSW")] Wsw, #[doc(alias = "GWEATHER_WIND_W")] W, #[doc(alias = "GWEATHER_WIND_WNW")] Wnw, #[doc(alias = "GWEATHER_WIND_NW")] Nw, #[doc(alias = "GWEATHER_WIND_NNW")] Nnw, #[doc(alias = "GWEATHER_WIND_LAST")] Last, #[doc(hidden)] __Unknown(i32), } impl WindDirection { pub fn to_str<'a>(self) -> &'a GStr { unsafe { GStr::from_ptr( ffi::gweather_wind_direction_to_string(self.into_glib()) .as_ref() .expect("gweather_wind_direction_to_string returned NULL"), ) } } #[doc(alias = "gweather_wind_direction_to_string_full")] pub fn to_string_full(self, options: FormatOptions) -> glib::GString { assert_initialized_main_thread!(); unsafe { from_glib_none(ffi::gweather_wind_direction_to_string_full(self.into_glib(), options.into_glib())) } } } impl std::fmt::Display for WindDirection { #[inline] fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { f.write_str(&self.to_str()) } } #[doc(hidden)] impl IntoGlib for WindDirection { type GlibType = ffi::GWeatherWindDirection; fn into_glib(self) -> ffi::GWeatherWindDirection { match self { Self::Invalid => ffi::GWEATHER_WIND_INVALID, Self::Variable => ffi::GWEATHER_WIND_VARIABLE, Self::N => ffi::GWEATHER_WIND_N, Self::Nne => ffi::GWEATHER_WIND_NNE, Self::Ne => ffi::GWEATHER_WIND_NE, Self::Ene => ffi::GWEATHER_WIND_ENE, Self::E => ffi::GWEATHER_WIND_E, Self::Ese => ffi::GWEATHER_WIND_ESE, Self::Se => ffi::GWEATHER_WIND_SE, Self::Sse => ffi::GWEATHER_WIND_SSE, Self::S => ffi::GWEATHER_WIND_S, Self::Ssw => ffi::GWEATHER_WIND_SSW, Self::Sw => ffi::GWEATHER_WIND_SW, Self::Wsw => ffi::GWEATHER_WIND_WSW, Self::W => ffi::GWEATHER_WIND_W, Self::Wnw => ffi::GWEATHER_WIND_WNW, Self::Nw => ffi::GWEATHER_WIND_NW, Self::Nnw => ffi::GWEATHER_WIND_NNW, Self::Last => ffi::GWEATHER_WIND_LAST, Self::__Unknown(value) => value, } } } #[doc(hidden)] impl FromGlib for WindDirection { unsafe fn from_glib(value: ffi::GWeatherWindDirection) -> Self { skip_assert_initialized!(); match value { ffi::GWEATHER_WIND_INVALID => Self::Invalid, ffi::GWEATHER_WIND_VARIABLE => Self::Variable, ffi::GWEATHER_WIND_N => Self::N, ffi::GWEATHER_WIND_NNE => Self::Nne, ffi::GWEATHER_WIND_NE => Self::Ne, ffi::GWEATHER_WIND_ENE => Self::Ene, ffi::GWEATHER_WIND_E => Self::E, ffi::GWEATHER_WIND_ESE => Self::Ese, ffi::GWEATHER_WIND_SE => Self::Se, ffi::GWEATHER_WIND_SSE => Self::Sse, ffi::GWEATHER_WIND_S => Self::S, ffi::GWEATHER_WIND_SSW => Self::Ssw, ffi::GWEATHER_WIND_SW => Self::Sw, ffi::GWEATHER_WIND_WSW => Self::Wsw, ffi::GWEATHER_WIND_W => Self::W, ffi::GWEATHER_WIND_WNW => Self::Wnw, ffi::GWEATHER_WIND_NW => Self::Nw, ffi::GWEATHER_WIND_NNW => Self::Nnw, ffi::GWEATHER_WIND_LAST => Self::Last, value => Self::__Unknown(value), } } } impl StaticType for WindDirection { #[inline] #[doc(alias = "gweather_wind_direction_get_type")] fn static_type() -> glib::Type { unsafe { from_glib(ffi::gweather_wind_direction_get_type()) } } } impl glib::HasParamSpec for WindDirection { type ParamSpec = glib::ParamSpecEnum; type SetValue = Self; type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder; fn param_spec_builder() -> Self::BuilderFn { Self::ParamSpec::builder_with_default } } impl glib::value::ValueType for WindDirection { type Type = Self; } unsafe impl<'a> glib::value::FromValue<'a> for WindDirection { type Checker = glib::value::GenericValueTypeChecker; #[inline] unsafe fn from_value(value: &'a glib::Value) -> Self { skip_assert_initialized!(); from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) } } impl ToValue for WindDirection { #[inline] fn to_value(&self) -> glib::Value { let mut value = glib::Value::for_value_type::(); unsafe { glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); } value } #[inline] fn value_type(&self) -> glib::Type { Self::static_type() } } impl From for glib::Value { #[inline] fn from(v: WindDirection) -> Self { skip_assert_initialized!(); ToValue::to_value(&v) } } libgweather-4.4.0/src/auto/flags.rs000064400000000000000000000127371046102023000153410ustar 00000000000000// This file was generated by gir (https://github.com/gtk-rs/gir) // from .. // from ../gir-files // DO NOT EDIT use glib::{bitflags::bitflags,prelude::*,translate::*}; bitflags! { #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] #[doc(alias = "GWeatherFormatOptions")] pub struct FormatOptions: u32 { #[doc(alias = "GWEATHER_FORMAT_OPTION_DEFAULT")] const DEFAULT = ffi::GWEATHER_FORMAT_OPTION_DEFAULT as _; #[doc(alias = "GWEATHER_FORMAT_OPTION_SENTENCE_CAPITALIZATION")] const SENTENCE_CAPITALIZATION = ffi::GWEATHER_FORMAT_OPTION_SENTENCE_CAPITALIZATION as _; #[doc(alias = "GWEATHER_FORMAT_OPTION_NO_CAPITALIZATION")] const NO_CAPITALIZATION = ffi::GWEATHER_FORMAT_OPTION_NO_CAPITALIZATION as _; } } #[doc(hidden)] impl IntoGlib for FormatOptions { type GlibType = ffi::GWeatherFormatOptions; #[inline] fn into_glib(self) -> ffi::GWeatherFormatOptions { self.bits() } } #[doc(hidden)] impl FromGlib for FormatOptions { #[inline] unsafe fn from_glib(value: ffi::GWeatherFormatOptions) -> Self { skip_assert_initialized!(); Self::from_bits_truncate(value) } } impl StaticType for FormatOptions { #[inline] #[doc(alias = "gweather_format_options_get_type")] fn static_type() -> glib::Type { unsafe { from_glib(ffi::gweather_format_options_get_type()) } } } impl glib::HasParamSpec for FormatOptions { type ParamSpec = glib::ParamSpecFlags; type SetValue = Self; type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder; fn param_spec_builder() -> Self::BuilderFn { Self::ParamSpec::builder } } impl glib::value::ValueType for FormatOptions { type Type = Self; } unsafe impl<'a> glib::value::FromValue<'a> for FormatOptions { type Checker = glib::value::GenericValueTypeChecker; #[inline] unsafe fn from_value(value: &'a glib::Value) -> Self { skip_assert_initialized!(); from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) } } impl ToValue for FormatOptions { #[inline] fn to_value(&self) -> glib::Value { let mut value = glib::Value::for_value_type::(); unsafe { glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib()); } value } #[inline] fn value_type(&self) -> glib::Type { Self::static_type() } } impl From for glib::Value { #[inline] fn from(v: FormatOptions) -> Self { skip_assert_initialized!(); ToValue::to_value(&v) } } bitflags! { #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] #[doc(alias = "GWeatherProvider")] pub struct Provider: u32 { #[doc(alias = "GWEATHER_PROVIDER_NONE")] const NONE = ffi::GWEATHER_PROVIDER_NONE as _; #[doc(alias = "GWEATHER_PROVIDER_METAR")] const METAR = ffi::GWEATHER_PROVIDER_METAR as _; #[doc(alias = "GWEATHER_PROVIDER_IWIN")] const IWIN = ffi::GWEATHER_PROVIDER_IWIN as _; #[doc(alias = "GWEATHER_PROVIDER_MET_NO")] const MET_NO = ffi::GWEATHER_PROVIDER_MET_NO as _; #[doc(alias = "GWEATHER_PROVIDER_OWM")] const OWM = ffi::GWEATHER_PROVIDER_OWM as _; #[doc(alias = "GWEATHER_PROVIDER_NWS")] const NWS = ffi::GWEATHER_PROVIDER_NWS as _; #[doc(alias = "GWEATHER_PROVIDER_ALL")] const ALL = ffi::GWEATHER_PROVIDER_ALL as _; } } #[doc(hidden)] impl IntoGlib for Provider { type GlibType = ffi::GWeatherProvider; #[inline] fn into_glib(self) -> ffi::GWeatherProvider { self.bits() } } #[doc(hidden)] impl FromGlib for Provider { #[inline] unsafe fn from_glib(value: ffi::GWeatherProvider) -> Self { skip_assert_initialized!(); Self::from_bits_truncate(value) } } impl StaticType for Provider { #[inline] #[doc(alias = "gweather_provider_get_type")] fn static_type() -> glib::Type { unsafe { from_glib(ffi::gweather_provider_get_type()) } } } impl glib::HasParamSpec for Provider { type ParamSpec = glib::ParamSpecFlags; type SetValue = Self; type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder; fn param_spec_builder() -> Self::BuilderFn { Self::ParamSpec::builder } } impl glib::value::ValueType for Provider { type Type = Self; } unsafe impl<'a> glib::value::FromValue<'a> for Provider { type Checker = glib::value::GenericValueTypeChecker; #[inline] unsafe fn from_value(value: &'a glib::Value) -> Self { skip_assert_initialized!(); from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) } } impl ToValue for Provider { #[inline] fn to_value(&self) -> glib::Value { let mut value = glib::Value::for_value_type::(); unsafe { glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib()); } value } #[inline] fn value_type(&self) -> glib::Type { Self::static_type() } } impl From for glib::Value { #[inline] fn from(v: Provider) -> Self { skip_assert_initialized!(); ToValue::to_value(&v) } } libgweather-4.4.0/src/auto/info.rs000064400000000000000000000524111046102023000151710ustar 00000000000000// This file was generated by gir (https://github.com/gtk-rs/gir) // from .. // from ../gir-files // DO NOT EDIT use crate::{ConditionPhenomenon,ConditionQualifier,DistanceUnit,Location,MoonLatitude,MoonPhase,PressureUnit,Provider,Sky,SpeedUnit,TemperatureUnit,WindDirection}; use glib::{prelude::*,signal::{connect_raw, SignalHandlerId},translate::*}; use std::{boxed::Box as Box_}; glib::wrapper! { #[doc(alias = "GWeatherInfo")] pub struct Info(Object); match fn { type_ => || ffi::gweather_info_get_type(), } } impl Info { #[doc(alias = "gweather_info_new")] pub fn new(location: Option<&Location>) -> Info { assert_initialized_main_thread!(); unsafe { from_glib_full(ffi::gweather_info_new(location.to_glib_none().0)) } } // rustdoc-stripper-ignore-next /// Creates a new builder-pattern struct instance to construct [`Info`] objects. /// /// This method returns an instance of [`InfoBuilder`](crate::builders::InfoBuilder) which can be used to create [`Info`] objects. pub fn builder() -> InfoBuilder { InfoBuilder::new() } #[doc(alias = "gweather_info_abort")] pub fn abort(&self) { unsafe { ffi::gweather_info_abort(self.to_glib_none().0); } } #[doc(alias = "gweather_info_get_apparent")] #[doc(alias = "get_apparent")] pub fn apparent(&self) -> glib::GString { unsafe { from_glib_full(ffi::gweather_info_get_apparent(self.to_glib_none().0)) } } #[doc(alias = "gweather_info_get_application_id")] #[doc(alias = "get_application_id")] pub fn application_id(&self) -> glib::GString { unsafe { from_glib_none(ffi::gweather_info_get_application_id(self.to_glib_none().0)) } } #[doc(alias = "gweather_info_get_attribution")] #[doc(alias = "get_attribution")] pub fn attribution(&self) -> glib::GString { unsafe { from_glib_none(ffi::gweather_info_get_attribution(self.to_glib_none().0)) } } #[doc(alias = "gweather_info_get_conditions")] #[doc(alias = "get_conditions")] pub fn conditions(&self) -> glib::GString { unsafe { from_glib_full(ffi::gweather_info_get_conditions(self.to_glib_none().0)) } } #[doc(alias = "gweather_info_get_contact_info")] #[doc(alias = "get_contact_info")] pub fn contact_info(&self) -> glib::GString { unsafe { from_glib_none(ffi::gweather_info_get_contact_info(self.to_glib_none().0)) } } #[doc(alias = "gweather_info_get_dew")] #[doc(alias = "get_dew")] pub fn dew(&self) -> glib::GString { unsafe { from_glib_full(ffi::gweather_info_get_dew(self.to_glib_none().0)) } } #[doc(alias = "gweather_info_get_enabled_providers")] #[doc(alias = "get_enabled_providers")] pub fn enabled_providers(&self) -> Provider { unsafe { from_glib(ffi::gweather_info_get_enabled_providers(self.to_glib_none().0)) } } #[doc(alias = "gweather_info_get_forecast_list")] #[doc(alias = "get_forecast_list")] pub fn forecast_list(&self) -> Vec { unsafe { FromGlibPtrContainer::from_glib_none(ffi::gweather_info_get_forecast_list(self.to_glib_none().0)) } } #[doc(alias = "gweather_info_get_humidity")] #[doc(alias = "get_humidity")] pub fn humidity(&self) -> glib::GString { unsafe { from_glib_full(ffi::gweather_info_get_humidity(self.to_glib_none().0)) } } #[doc(alias = "gweather_info_get_icon_name")] #[doc(alias = "get_icon_name")] pub fn icon_name(&self) -> glib::GString { unsafe { from_glib_none(ffi::gweather_info_get_icon_name(self.to_glib_none().0)) } } #[doc(alias = "gweather_info_get_location")] #[doc(alias = "get_location")] pub fn location(&self) -> Location { unsafe { from_glib_none(ffi::gweather_info_get_location(self.to_glib_none().0)) } } #[doc(alias = "gweather_info_get_location_name")] #[doc(alias = "get_location_name")] pub fn location_name(&self) -> glib::GString { unsafe { from_glib_full(ffi::gweather_info_get_location_name(self.to_glib_none().0)) } } #[doc(alias = "gweather_info_get_pressure")] #[doc(alias = "get_pressure")] pub fn pressure(&self) -> glib::GString { unsafe { from_glib_full(ffi::gweather_info_get_pressure(self.to_glib_none().0)) } } #[doc(alias = "gweather_info_get_sky")] #[doc(alias = "get_sky")] pub fn sky(&self) -> glib::GString { unsafe { from_glib_full(ffi::gweather_info_get_sky(self.to_glib_none().0)) } } #[doc(alias = "gweather_info_get_sunrise")] #[doc(alias = "get_sunrise")] pub fn sunrise(&self) -> glib::GString { unsafe { from_glib_full(ffi::gweather_info_get_sunrise(self.to_glib_none().0)) } } #[doc(alias = "gweather_info_get_sunset")] #[doc(alias = "get_sunset")] pub fn sunset(&self) -> glib::GString { unsafe { from_glib_full(ffi::gweather_info_get_sunset(self.to_glib_none().0)) } } #[doc(alias = "gweather_info_get_symbolic_icon_name")] #[doc(alias = "get_symbolic_icon_name")] pub fn symbolic_icon_name(&self) -> glib::GString { unsafe { from_glib_none(ffi::gweather_info_get_symbolic_icon_name(self.to_glib_none().0)) } } #[doc(alias = "gweather_info_get_temp")] #[doc(alias = "get_temp")] pub fn temp(&self) -> glib::GString { unsafe { from_glib_full(ffi::gweather_info_get_temp(self.to_glib_none().0)) } } #[doc(alias = "gweather_info_get_temp_max")] #[doc(alias = "get_temp_max")] pub fn temp_max(&self) -> glib::GString { unsafe { from_glib_full(ffi::gweather_info_get_temp_max(self.to_glib_none().0)) } } #[doc(alias = "gweather_info_get_temp_min")] #[doc(alias = "get_temp_min")] pub fn temp_min(&self) -> glib::GString { unsafe { from_glib_full(ffi::gweather_info_get_temp_min(self.to_glib_none().0)) } } #[doc(alias = "gweather_info_get_temp_summary")] #[doc(alias = "get_temp_summary")] pub fn temp_summary(&self) -> glib::GString { unsafe { from_glib_full(ffi::gweather_info_get_temp_summary(self.to_glib_none().0)) } } #[doc(alias = "gweather_info_get_update")] pub fn get_update(&self) -> glib::GString { unsafe { from_glib_full(ffi::gweather_info_get_update(self.to_glib_none().0)) } } #[doc(alias = "gweather_info_get_value_apparent")] #[doc(alias = "get_value_apparent")] pub fn value_apparent(&self, unit: TemperatureUnit) -> Option { unsafe { let mut value = std::mem::MaybeUninit::uninit(); let ret = from_glib(ffi::gweather_info_get_value_apparent(self.to_glib_none().0, unit.into_glib(), value.as_mut_ptr())); if ret { Some(value.assume_init()) } else { None } } } #[doc(alias = "gweather_info_get_value_conditions")] #[doc(alias = "get_value_conditions")] pub fn value_conditions(&self) -> Option<(ConditionPhenomenon, ConditionQualifier)> { unsafe { let mut phenomenon = std::mem::MaybeUninit::uninit(); let mut qualifier = std::mem::MaybeUninit::uninit(); let ret = from_glib(ffi::gweather_info_get_value_conditions(self.to_glib_none().0, phenomenon.as_mut_ptr(), qualifier.as_mut_ptr())); if ret { Some((from_glib(phenomenon.assume_init()), from_glib(qualifier.assume_init()))) } else { None } } } #[doc(alias = "gweather_info_get_value_dew")] #[doc(alias = "get_value_dew")] pub fn value_dew(&self, unit: TemperatureUnit) -> Option { unsafe { let mut value = std::mem::MaybeUninit::uninit(); let ret = from_glib(ffi::gweather_info_get_value_dew(self.to_glib_none().0, unit.into_glib(), value.as_mut_ptr())); if ret { Some(value.assume_init()) } else { None } } } #[doc(alias = "gweather_info_get_value_moonphase")] #[doc(alias = "get_value_moonphase")] pub fn value_moonphase(&self) -> Option<(MoonPhase, MoonLatitude)> { unsafe { let mut value = std::mem::MaybeUninit::uninit(); let mut lat = std::mem::MaybeUninit::uninit(); let ret = from_glib(ffi::gweather_info_get_value_moonphase(self.to_glib_none().0, value.as_mut_ptr(), lat.as_mut_ptr())); if ret { Some((value.assume_init(), lat.assume_init())) } else { None } } } #[doc(alias = "gweather_info_get_value_pressure")] #[doc(alias = "get_value_pressure")] pub fn value_pressure(&self, unit: PressureUnit) -> Option { unsafe { let mut value = std::mem::MaybeUninit::uninit(); let ret = from_glib(ffi::gweather_info_get_value_pressure(self.to_glib_none().0, unit.into_glib(), value.as_mut_ptr())); if ret { Some(value.assume_init()) } else { None } } } #[doc(alias = "gweather_info_get_value_sky")] #[doc(alias = "get_value_sky")] pub fn value_sky(&self) -> Option { unsafe { let mut sky = std::mem::MaybeUninit::uninit(); let ret = from_glib(ffi::gweather_info_get_value_sky(self.to_glib_none().0, sky.as_mut_ptr())); if ret { Some(from_glib(sky.assume_init())) } else { None } } } #[doc(alias = "gweather_info_get_value_sunrise")] #[doc(alias = "get_value_sunrise")] pub fn value_sunrise(&self) -> Option { unsafe { let mut value = std::mem::MaybeUninit::uninit(); let ret = from_glib(ffi::gweather_info_get_value_sunrise(self.to_glib_none().0, value.as_mut_ptr())); if ret { Some(value.assume_init()) } else { None } } } #[doc(alias = "gweather_info_get_value_sunset")] #[doc(alias = "get_value_sunset")] pub fn value_sunset(&self) -> Option { unsafe { let mut value = std::mem::MaybeUninit::uninit(); let ret = from_glib(ffi::gweather_info_get_value_sunset(self.to_glib_none().0, value.as_mut_ptr())); if ret { Some(value.assume_init()) } else { None } } } #[doc(alias = "gweather_info_get_value_temp")] #[doc(alias = "get_value_temp")] pub fn value_temp(&self, unit: TemperatureUnit) -> Option { unsafe { let mut value = std::mem::MaybeUninit::uninit(); let ret = from_glib(ffi::gweather_info_get_value_temp(self.to_glib_none().0, unit.into_glib(), value.as_mut_ptr())); if ret { Some(value.assume_init()) } else { None } } } #[doc(alias = "gweather_info_get_value_temp_max")] #[doc(alias = "get_value_temp_max")] pub fn value_temp_max(&self, unit: TemperatureUnit) -> Option { unsafe { let mut value = std::mem::MaybeUninit::uninit(); let ret = from_glib(ffi::gweather_info_get_value_temp_max(self.to_glib_none().0, unit.into_glib(), value.as_mut_ptr())); if ret { Some(value.assume_init()) } else { None } } } #[doc(alias = "gweather_info_get_value_temp_min")] #[doc(alias = "get_value_temp_min")] pub fn value_temp_min(&self, unit: TemperatureUnit) -> Option { unsafe { let mut value = std::mem::MaybeUninit::uninit(); let ret = from_glib(ffi::gweather_info_get_value_temp_min(self.to_glib_none().0, unit.into_glib(), value.as_mut_ptr())); if ret { Some(value.assume_init()) } else { None } } } #[doc(alias = "gweather_info_get_value_update")] #[doc(alias = "get_value_update")] pub fn value_update(&self) -> Option { unsafe { let mut value = std::mem::MaybeUninit::uninit(); let ret = from_glib(ffi::gweather_info_get_value_update(self.to_glib_none().0, value.as_mut_ptr())); if ret { Some(value.assume_init()) } else { None } } } #[doc(alias = "gweather_info_get_value_visibility")] #[doc(alias = "get_value_visibility")] pub fn value_visibility(&self, unit: DistanceUnit) -> Option { unsafe { let mut value = std::mem::MaybeUninit::uninit(); let ret = from_glib(ffi::gweather_info_get_value_visibility(self.to_glib_none().0, unit.into_glib(), value.as_mut_ptr())); if ret { Some(value.assume_init()) } else { None } } } #[doc(alias = "gweather_info_get_value_wind")] #[doc(alias = "get_value_wind")] pub fn value_wind(&self, unit: SpeedUnit) -> Option<(f64, WindDirection)> { unsafe { let mut speed = std::mem::MaybeUninit::uninit(); let mut direction = std::mem::MaybeUninit::uninit(); let ret = from_glib(ffi::gweather_info_get_value_wind(self.to_glib_none().0, unit.into_glib(), speed.as_mut_ptr(), direction.as_mut_ptr())); if ret { Some((speed.assume_init(), from_glib(direction.assume_init()))) } else { None } } } #[doc(alias = "gweather_info_get_visibility")] #[doc(alias = "get_visibility")] pub fn visibility(&self) -> glib::GString { unsafe { from_glib_full(ffi::gweather_info_get_visibility(self.to_glib_none().0)) } } #[doc(alias = "gweather_info_get_weather_summary")] #[doc(alias = "get_weather_summary")] pub fn weather_summary(&self) -> glib::GString { unsafe { from_glib_full(ffi::gweather_info_get_weather_summary(self.to_glib_none().0)) } } #[doc(alias = "gweather_info_get_wind")] #[doc(alias = "get_wind")] pub fn wind(&self) -> glib::GString { unsafe { from_glib_full(ffi::gweather_info_get_wind(self.to_glib_none().0)) } } #[doc(alias = "gweather_info_is_daytime")] pub fn is_daytime(&self) -> bool { unsafe { from_glib(ffi::gweather_info_is_daytime(self.to_glib_none().0)) } } #[doc(alias = "gweather_info_is_valid")] pub fn is_valid(&self) -> bool { unsafe { from_glib(ffi::gweather_info_is_valid(self.to_glib_none().0)) } } #[doc(alias = "gweather_info_network_error")] pub fn network_error(&self) -> bool { unsafe { from_glib(ffi::gweather_info_network_error(self.to_glib_none().0)) } } #[doc(alias = "gweather_info_next_sun_event")] pub fn next_sun_event(&self) -> i32 { unsafe { ffi::gweather_info_next_sun_event(self.to_glib_none().0) } } #[doc(alias = "gweather_info_set_application_id")] pub fn set_application_id(&self, application_id: &str) { unsafe { ffi::gweather_info_set_application_id(self.to_glib_none().0, application_id.to_glib_none().0); } } #[doc(alias = "gweather_info_set_contact_info")] pub fn set_contact_info(&self, contact_info: &str) { unsafe { ffi::gweather_info_set_contact_info(self.to_glib_none().0, contact_info.to_glib_none().0); } } #[doc(alias = "gweather_info_set_enabled_providers")] pub fn set_enabled_providers(&self, providers: Provider) { unsafe { ffi::gweather_info_set_enabled_providers(self.to_glib_none().0, providers.into_glib()); } } #[doc(alias = "gweather_info_set_location")] pub fn set_location(&self, location: Option<&Location>) { unsafe { ffi::gweather_info_set_location(self.to_glib_none().0, location.to_glib_none().0); } } #[doc(alias = "gweather_info_update")] pub fn update(&self) { unsafe { ffi::gweather_info_update(self.to_glib_none().0); } } #[doc(alias = "gweather_info_store_cache")] pub fn store_cache() { assert_initialized_main_thread!(); unsafe { ffi::gweather_info_store_cache(); } } #[doc(alias = "updated")] pub fn connect_updated(&self, f: F) -> SignalHandlerId { unsafe extern "C" fn updated_trampoline(this: *mut ffi::GWeatherInfo, f: glib::ffi::gpointer) { let f: &F = &*(f as *const F); f(&from_glib_borrow(this)) } unsafe { let f: Box_ = Box_::new(f); connect_raw(self.as_ptr() as *mut _, b"updated\0".as_ptr() as *const _, Some(std::mem::transmute::<_, unsafe extern "C" fn()>(updated_trampoline:: as *const ())), Box_::into_raw(f)) } } #[doc(alias = "application-id")] pub fn connect_application_id_notify(&self, f: F) -> SignalHandlerId { unsafe extern "C" fn notify_application_id_trampoline(this: *mut ffi::GWeatherInfo, _param_spec: glib::ffi::gpointer, f: glib::ffi::gpointer) { let f: &F = &*(f as *const F); f(&from_glib_borrow(this)) } unsafe { let f: Box_ = Box_::new(f); connect_raw(self.as_ptr() as *mut _, b"notify::application-id\0".as_ptr() as *const _, Some(std::mem::transmute::<_, unsafe extern "C" fn()>(notify_application_id_trampoline:: as *const ())), Box_::into_raw(f)) } } #[doc(alias = "contact-info")] pub fn connect_contact_info_notify(&self, f: F) -> SignalHandlerId { unsafe extern "C" fn notify_contact_info_trampoline(this: *mut ffi::GWeatherInfo, _param_spec: glib::ffi::gpointer, f: glib::ffi::gpointer) { let f: &F = &*(f as *const F); f(&from_glib_borrow(this)) } unsafe { let f: Box_ = Box_::new(f); connect_raw(self.as_ptr() as *mut _, b"notify::contact-info\0".as_ptr() as *const _, Some(std::mem::transmute::<_, unsafe extern "C" fn()>(notify_contact_info_trampoline:: as *const ())), Box_::into_raw(f)) } } #[doc(alias = "enabled-providers")] pub fn connect_enabled_providers_notify(&self, f: F) -> SignalHandlerId { unsafe extern "C" fn notify_enabled_providers_trampoline(this: *mut ffi::GWeatherInfo, _param_spec: glib::ffi::gpointer, f: glib::ffi::gpointer) { let f: &F = &*(f as *const F); f(&from_glib_borrow(this)) } unsafe { let f: Box_ = Box_::new(f); connect_raw(self.as_ptr() as *mut _, b"notify::enabled-providers\0".as_ptr() as *const _, Some(std::mem::transmute::<_, unsafe extern "C" fn()>(notify_enabled_providers_trampoline:: as *const ())), Box_::into_raw(f)) } } #[doc(alias = "location")] pub fn connect_location_notify(&self, f: F) -> SignalHandlerId { unsafe extern "C" fn notify_location_trampoline(this: *mut ffi::GWeatherInfo, _param_spec: glib::ffi::gpointer, f: glib::ffi::gpointer) { let f: &F = &*(f as *const F); f(&from_glib_borrow(this)) } unsafe { let f: Box_ = Box_::new(f); connect_raw(self.as_ptr() as *mut _, b"notify::location\0".as_ptr() as *const _, Some(std::mem::transmute::<_, unsafe extern "C" fn()>(notify_location_trampoline:: as *const ())), Box_::into_raw(f)) } } } impl Default for Info { fn default() -> Self { glib::object::Object::new::() } } // rustdoc-stripper-ignore-next /// A [builder-pattern] type to construct [`Info`] objects. /// /// [builder-pattern]: https://doc.rust-lang.org/1.0.0/style/ownership/builders.html #[must_use = "The builder must be built to be used"] pub struct InfoBuilder { builder: glib::object::ObjectBuilder<'static, Info>, } impl InfoBuilder { fn new() -> Self { Self { builder: glib::object::Object::builder() } } pub fn application_id(self, application_id: impl Into) -> Self { Self { builder: self.builder.property("application-id", application_id.into()), } } pub fn contact_info(self, contact_info: impl Into) -> Self { Self { builder: self.builder.property("contact-info", contact_info.into()), } } pub fn enabled_providers(self, enabled_providers: Provider) -> Self { Self { builder: self.builder.property("enabled-providers", enabled_providers), } } pub fn location(self, location: &Location) -> Self { Self { builder: self.builder.property("location", location.clone()), } } // rustdoc-stripper-ignore-next /// Build the [`Info`]. #[must_use = "Building the object from the builder is usually expensive and is not expected to have side effects"] pub fn build(self) -> Info { self.builder.build() } } libgweather-4.4.0/src/auto/location.rs000064400000000000000000000215041046102023000160450ustar 00000000000000// This file was generated by gir (https://github.com/gtk-rs/gir) // from .. // from ../gir-files // DO NOT EDIT use crate::{LocationLevel}; use glib::{prelude::*,translate::*}; use std::{boxed::Box as Box_}; glib::wrapper! { #[doc(alias = "GWeatherLocation")] pub struct Location(Object); match fn { type_ => || ffi::gweather_location_get_type(), } } impl Location { #[doc(alias = "gweather_location_new_detached")] pub fn new_detached(name: &str, icao: Option<&str>, latitude: f64, longitude: f64) -> Location { assert_initialized_main_thread!(); unsafe { from_glib_full(ffi::gweather_location_new_detached(name.to_glib_none().0, icao.to_glib_none().0, latitude, longitude)) } } #[doc(alias = "gweather_location_deserialize")] #[must_use] pub fn deserialize(&self, serialized: &glib::Variant) -> Location { unsafe { from_glib_full(ffi::gweather_location_deserialize(self.to_glib_none().0, serialized.to_glib_none().0)) } } #[doc(alias = "gweather_location_equal")] pub fn equal(&self, two: &Location) -> bool { unsafe { from_glib(ffi::gweather_location_equal(self.to_glib_none().0, two.to_glib_none().0)) } } #[doc(alias = "gweather_location_find_by_country_code")] #[must_use] pub fn find_by_country_code(&self, country_code: &str) -> Location { unsafe { from_glib_full(ffi::gweather_location_find_by_country_code(self.to_glib_none().0, country_code.to_glib_none().0)) } } #[doc(alias = "gweather_location_find_by_station_code")] #[must_use] pub fn find_by_station_code(&self, station_code: &str) -> Option { unsafe { from_glib_full(ffi::gweather_location_find_by_station_code(self.to_glib_none().0, station_code.to_glib_none().0)) } } #[doc(alias = "gweather_location_find_nearest_city")] #[must_use] pub fn find_nearest_city(&self, lat: f64, lon: f64) -> Location { unsafe { from_glib_full(ffi::gweather_location_find_nearest_city(self.to_glib_none().0, lat, lon)) } } #[doc(alias = "gweather_location_find_nearest_city_full")] #[must_use] pub fn find_nearest_city_full(&self, lat: f64, lon: f64, func: Option bool + 'static>>) -> Location { let func_data: Box_ bool + 'static>>> = Box_::new(func); unsafe extern "C" fn func_func(location: *mut ffi::GWeatherLocation, user_data: glib::ffi::gpointer) -> glib::ffi::gboolean { let location = from_glib_borrow(location); let callback = &*(user_data as *mut Option bool + 'static>>); if let Some(ref callback) = *callback { callback(&location) } else { panic!("cannot get closure...") } .into_glib() } let func = if func_data.is_some() { Some(func_func as _) } else { None }; unsafe extern "C" fn destroy_func(data: glib::ffi::gpointer) { let _callback = Box_::from_raw(data as *mut Option bool + 'static>>); } let destroy_call5 = Some(destroy_func as _); let super_callback0: Box_ bool + 'static>>> = func_data; unsafe { from_glib_full(ffi::gweather_location_find_nearest_city_full(self.to_glib_none().0, lat, lon, func, Box_::into_raw(super_callback0) as *mut _, destroy_call5)) } } #[doc(alias = "gweather_location_get_city_name")] #[doc(alias = "get_city_name")] pub fn city_name(&self) -> Option { unsafe { from_glib_full(ffi::gweather_location_get_city_name(self.to_glib_none().0)) } } #[doc(alias = "gweather_location_get_code")] #[doc(alias = "get_code")] pub fn code(&self) -> Option { unsafe { from_glib_none(ffi::gweather_location_get_code(self.to_glib_none().0)) } } #[doc(alias = "gweather_location_get_coords")] #[doc(alias = "get_coords")] pub fn coords(&self) -> (f64, f64) { unsafe { let mut latitude = std::mem::MaybeUninit::uninit(); let mut longitude = std::mem::MaybeUninit::uninit(); ffi::gweather_location_get_coords(self.to_glib_none().0, latitude.as_mut_ptr(), longitude.as_mut_ptr()); (latitude.assume_init(), longitude.assume_init()) } } #[doc(alias = "gweather_location_get_country")] #[doc(alias = "get_country")] pub fn country(&self) -> Option { unsafe { from_glib_none(ffi::gweather_location_get_country(self.to_glib_none().0)) } } #[doc(alias = "gweather_location_get_country_name")] #[doc(alias = "get_country_name")] pub fn country_name(&self) -> Option { unsafe { from_glib_full(ffi::gweather_location_get_country_name(self.to_glib_none().0)) } } #[doc(alias = "gweather_location_get_distance")] #[doc(alias = "get_distance")] pub fn distance(&self, loc2: &Location) -> f64 { unsafe { ffi::gweather_location_get_distance(self.to_glib_none().0, loc2.to_glib_none().0) } } #[doc(alias = "gweather_location_get_english_name")] #[doc(alias = "get_english_name")] pub fn english_name(&self) -> Option { unsafe { from_glib_none(ffi::gweather_location_get_english_name(self.to_glib_none().0)) } } #[doc(alias = "gweather_location_get_english_sort_name")] #[doc(alias = "get_english_sort_name")] pub fn english_sort_name(&self) -> Option { unsafe { from_glib_none(ffi::gweather_location_get_english_sort_name(self.to_glib_none().0)) } } #[doc(alias = "gweather_location_get_level")] #[doc(alias = "get_level")] pub fn level(&self) -> LocationLevel { unsafe { from_glib(ffi::gweather_location_get_level(self.to_glib_none().0)) } } #[doc(alias = "gweather_location_get_name")] #[doc(alias = "get_name")] pub fn name(&self) -> Option { unsafe { from_glib_none(ffi::gweather_location_get_name(self.to_glib_none().0)) } } #[doc(alias = "gweather_location_get_parent")] #[doc(alias = "get_parent")] #[must_use] pub fn parent(&self) -> Option { unsafe { from_glib_full(ffi::gweather_location_get_parent(self.to_glib_none().0)) } } #[doc(alias = "gweather_location_get_sort_name")] #[doc(alias = "get_sort_name")] pub fn sort_name(&self) -> Option { unsafe { from_glib_none(ffi::gweather_location_get_sort_name(self.to_glib_none().0)) } } #[doc(alias = "gweather_location_get_timezone")] #[doc(alias = "get_timezone")] pub fn timezone(&self) -> Option { unsafe { from_glib_none(ffi::gweather_location_get_timezone(self.to_glib_none().0)) } } #[doc(alias = "gweather_location_get_timezone_str")] #[doc(alias = "get_timezone_str")] pub fn timezone_str(&self) -> Option { unsafe { from_glib_none(ffi::gweather_location_get_timezone_str(self.to_glib_none().0)) } } #[doc(alias = "gweather_location_get_timezones")] #[doc(alias = "get_timezones")] pub fn timezones(&self) -> Vec { unsafe { FromGlibPtrContainer::from_glib_full(ffi::gweather_location_get_timezones(self.to_glib_none().0)) } } #[doc(alias = "gweather_location_has_coords")] pub fn has_coords(&self) -> bool { unsafe { from_glib(ffi::gweather_location_has_coords(self.to_glib_none().0)) } } #[doc(alias = "gweather_location_has_timezone")] pub fn has_timezone(&self) -> bool { unsafe { from_glib(ffi::gweather_location_has_timezone(self.to_glib_none().0)) } } #[doc(alias = "gweather_location_next_child")] #[must_use] pub fn next_child(&self, child: Option) -> Option { unsafe { from_glib_full(ffi::gweather_location_next_child(self.to_glib_none().0, child.into_glib_ptr())) } } #[doc(alias = "gweather_location_serialize")] pub fn serialize(&self) -> glib::Variant { unsafe { from_glib_none(ffi::gweather_location_serialize(self.to_glib_none().0)) } } #[doc(alias = "gweather_location_get_world")] #[doc(alias = "get_world")] pub fn world() -> Option { assert_initialized_main_thread!(); unsafe { from_glib_full(ffi::gweather_location_get_world()) } } } libgweather-4.4.0/src/auto/mod.rs000064400000000000000000000013651046102023000150170ustar 00000000000000// This file was generated by gir (https://github.com/gtk-rs/gir) // from .. // from ../gir-files // DO NOT EDIT mod info; pub use self::info::Info; mod location; pub use self::location::Location; mod enums; pub use self::enums::ConditionPhenomenon; pub use self::enums::ConditionQualifier; pub use self::enums::DistanceUnit; pub use self::enums::LocationLevel; pub use self::enums::PressureUnit; pub use self::enums::Sky; pub use self::enums::SpeedUnit; pub use self::enums::TemperatureUnit; pub use self::enums::WindDirection; mod flags; pub use self::flags::FormatOptions; pub use self::flags::Provider; mod alias; pub use self::alias::MoonLatitude; pub use self::alias::MoonPhase; pub(crate) mod builders { pub use super::info::InfoBuilder; } libgweather-4.4.0/src/auto/versions.txt000064400000000000000000000001751046102023000163010ustar 00000000000000Generated by gir (https://github.com/gtk-rs/gir @ 0e476ab5c1de) from .. (@ 177c7b834f81+) from ../gir-files (@ cfc0305f903b) libgweather-4.4.0/src/conditions.rs000064400000000000000000000034071046102023000154400ustar 00000000000000// Take a look at the license at the top of the repository in the LICENSE file. use crate::{ConditionPhenomenon, ConditionQualifier, FormatOptions}; use glib::translate::*; glib::wrapper! { #[doc(alias = "GWeatherConditions")] pub struct Conditions(BoxedInline); } impl Conditions { #[inline] pub fn new( significant: bool, phenomenon: ConditionPhenomenon, qualifier: ConditionQualifier, ) -> Self { assert_initialized_main_thread!(); unsafe { Self::unsafe_from(ffi::GWeatherConditions { significant: significant.into_glib(), phenomenon: phenomenon.into_glib(), qualifier: qualifier.into_glib(), }) } } #[inline] pub fn significant(&self) -> bool { unsafe { from_glib(self.inner.significant) } } #[inline] pub fn phenomenon(&self) -> ConditionPhenomenon { unsafe { from_glib(self.inner.phenomenon) } } #[inline] pub fn qualifier(&self) -> ConditionQualifier { unsafe { from_glib(self.inner.qualifier) } } #[doc(alias = "gweather_conditions_to_string")] #[doc(alias = "to_string")] pub fn to_str(&mut self) -> glib::GString { unsafe { from_glib_full(ffi::gweather_conditions_to_string( self.to_glib_none_mut().0, )) } } #[doc(alias = "gweather_conditions_to_string_full")] #[doc(alias = "to_string_full")] pub fn to_str_full(&mut self, options: &FormatOptions) -> glib::GString { unsafe { from_glib_full(ffi::gweather_conditions_to_string_full( self.to_glib_none_mut().0, options.into_glib(), )) } } } libgweather-4.4.0/src/info.rs000064400000000000000000000012701046102023000142160ustar 00000000000000// Take a look at the license at the top of the repository in the LICENSE file. use crate::Info; use glib::translate::*; use std::mem; impl Info { #[doc(alias = "gweather_info_get_upcoming_moonphases")] #[doc(alias = "get_upcoming_moonphases")] pub fn upcoming_moonphases(&self) -> Option { unsafe { let mut value = mem::MaybeUninit::uninit(); let ret = from_glib(ffi::gweather_info_get_upcoming_moonphases( self.to_glib_none().0, value.as_mut_ptr(), )); if ret { Some(value.assume_init()) } else { None } } } } libgweather-4.4.0/src/lib.rs000064400000000000000000000021761046102023000140370ustar 00000000000000// Take a look at the license at the top of the repository in the LICENSE file. #![cfg_attr(feature = "dox", feature(doc_cfg))] #![allow(clippy::needless_doctest_main)] #![doc( html_logo_url = "https://gitlab.gnome.org/GNOME/libgweather/-/raw/main/doc/libgweather-logo.svg", html_favicon_url = "https://gitlab.gnome.org/GNOME/libgweather/-/raw/main/doc/libgweather-logo.svg" )] //! # Rust GWeather bindings //! //! This library contains safe Rust bindings for [GWeather](https://gitlab.gnome.org/GNOME/libgweather/), a library that offers //! weather data collection //! //! See also //! //! - [GWeather documentation](https://gnome.pages.gitlab.gnome.org/libgweather/) //! - [gtk-rs project overview](https://gtk-rs.org/) //! macro_rules! skip_assert_initialized { () => {}; } macro_rules! assert_initialized_main_thread { () => {}; } pub use ffi; pub use gio; pub use glib; #[allow(unused_imports)] #[allow(clippy::let_and_return)] #[allow(clippy::type_complexity)] mod auto; mod conditions; mod info; mod location; pub use auto::*; pub use conditions::Conditions; pub mod builders { pub use super::auto::builders::*; } libgweather-4.4.0/src/location.rs000064400000000000000000000052451046102023000151010ustar 00000000000000// Take a look at the license at the top of the repository in the LICENSE file. use crate::Location; use glib::object::IsA; use glib::translate::*; use std::boxed::Box as Box_; use std::pin::Pin; use std::ptr; impl Location { #[doc(alias = "gweather_location_detect_nearest_city")] pub fn detect_nearest_city) + 'static>( &self, lat: f64, lon: f64, cancellable: Option<&impl IsA>, callback: P, ) { let main_context = glib::MainContext::ref_thread_default(); let is_main_context_owner = main_context.is_owner(); let has_acquired_main_context = (!is_main_context_owner) .then(|| main_context.acquire().ok()) .flatten(); assert!( is_main_context_owner || has_acquired_main_context.is_some(), "Async operations only allowed if the thread is owning the MainContext" ); let user_data: Box_> = Box_::new(glib::thread_guard::ThreadGuard::new(callback)); unsafe extern "C" fn detect_nearest_city_trampoline< P: FnOnce(Result) + 'static, >( _source_object: *mut glib::gobject_ffi::GObject, res: *mut gio::ffi::GAsyncResult, user_data: glib::ffi::gpointer, ) { let mut error = ptr::null_mut(); let ret = ffi::gweather_location_detect_nearest_city_finish(res, &mut error); let result = if error.is_null() { Ok(from_glib_full(ret)) } else { Err(from_glib_full(error)) }; let callback: Box_> = Box_::from_raw(user_data as *mut _); let callback: P = callback.into_inner(); callback(result); } let callback = detect_nearest_city_trampoline::

; unsafe { ffi::gweather_location_detect_nearest_city( self.to_glib_none().0, lat, lon, cancellable.map(|p| p.as_ref()).to_glib_none().0, Some(callback), Box_::into_raw(user_data) as *mut _, ); } } pub fn detect_nearest_city_future( &self, lat: f64, lon: f64, ) -> Pin> + 'static>> { Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| { obj.detect_nearest_city(lat, lon, Some(cancellable), move |res| { send.resolve(res); }); })) } }