pango-0.14.8/.cargo_vcs_info.json0000644000000001120000000000100122240ustar { "git": { "sha1": "9364a9538de344056ea14c2678229f76b197161e" } } pango-0.14.8/COPYRIGHT000064400000000000000000000012130072674642500123420ustar 00000000000000The gtk-rs Project is licensed under the MIT license, see the LICENSE file or . Copyrights in the gtk-rs Project project are retained by their contributors. No copyright assignment is required to contribute to the gtk-rs Project project. For full authorship information, see the version control history. This project provides interoperability with various GNOME libraries but doesn't distribute any parts of them. Distributing compiled libraries and executables that link to those libraries may be subject to terms of the GNU LGPL or other licenses. For more information check the license of each GNOME library. pango-0.14.8/Cargo.toml0000644000000025110000000000100102270ustar # 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 = "2018" name = "pango" version = "0.14.8" authors = ["The gtk-rs Project Developers"] exclude = ["gir-files/*"] description = "Rust bindings for the Pango library" homepage = "https://gtk-rs.org/" documentation = "https://gtk-rs.org/gtk-rs-core/stable/latest/docs/pango/" readme = "README.md" keywords = ["pango", "gtk-rs", "gnome"] license = "MIT" repository = "https://github.com/gtk-rs/gtk-rs-core" [package.metadata.docs.rs] features = ["dox"] [dependencies.bitflags] version = "1.0" [dependencies.ffi] version = "0.14.0" package = "pango-sys" [dependencies.glib] version = "0.14.0" [dependencies.libc] version = "0.2" [dependencies.once_cell] version = "1.0" [dev-dependencies.gir-format-check] version = "^0.1" [features] dox = ["ffi/dox", "glib/dox"] v1_40 = [] v1_42 = ["v1_40", "ffi/v1_42"] v1_44 = ["v1_42", "ffi/v1_44"] v1_46 = ["v1_44", "ffi/v1_46"] pango-0.14.8/Cargo.toml.orig000064400000000000000000000015150072674642500137430ustar 00000000000000[package] name = "pango" documentation = "https://gtk-rs.org/gtk-rs-core/stable/latest/docs/pango/" homepage = "https://gtk-rs.org/" authors = ["The gtk-rs Project Developers"] keywords = ["pango", "gtk-rs", "gnome"] readme = "README.md" version = "0.14.8" description = "Rust bindings for the Pango library" repository = "https://github.com/gtk-rs/gtk-rs-core" license = "MIT" exclude = [ "gir-files/*", ] edition = "2018" [features] v1_40 = [] v1_42 = ["v1_40", "ffi/v1_42"] v1_44 = ["v1_42", "ffi/v1_44"] v1_46 = ["v1_44", "ffi/v1_46"] dox = ["ffi/dox", "glib/dox"] [package.metadata.docs.rs] features = ["dox"] [dependencies] libc = "0.2" bitflags = "1.0" once_cell = "1.0" ffi = {package = "pango-sys", path = "./sys", version = "0.14.0"} glib = {version = "0.14.0", path = "./../glib"} [dev-dependencies] gir-format-check = "^0.1" pango-0.14.8/Gir.toml000064400000000000000000000132650072674642500124770ustar 00000000000000[options] girs_directories = ["../gir-files"] library = "Pango" version = "1.0" target_path = "." work_mode = "normal" generate_safety_asserts = false min_cfg_version = "1.38" single_version_file = true deprecate_by_min_version = true generate = [ # "Pango.AttrColor", # "Pango.AttrFloat", # "Pango.AttrFontDesc", # "Pango.AttrFontFeatures", # "Pango.AttrInt", # "Pango.AttrLanguage", # "Pango.AttrShape", # "Pango.AttrSize", # "Pango.AttrString", # "Pango.GlyphGeometry", # "Pango.GlyphInfo", # "Pango.GlyphVisAttr", # "Pango.LogAttr", # "Pango.Map", # "Pango.MapEntry", # "Pango.ScriptForLang", # "Pango.ScriptIter", "Pango.Alignment", "Pango.BidiType", "Pango.Color", "Pango.CoverageLevel", "Pango.Direction", "Pango.EllipsizeMode", "Pango.FontFace", "Pango.FontFamily", "Pango.FontMask", "Pango.FontMetrics", "Pango.Fontset", "Pango.FontsetSimple", "Pango.Glyph", "Pango.GlyphItem", "Pango.GlyphItemIter", "Pango.GlyphString", "Pango.GlyphUnit", "Pango.Gravity", "Pango.GravityHint", "Pango.Item", "Pango.LayoutIter", "Pango.LayoutRun", "Pango.Matrix", "Pango.Overline", "Pango.Renderer", "Pango.RenderPart", "Pango.Script", "Pango.Stretch", "Pango.Style", "Pango.TabAlign", "Pango.TabArray", "Pango.Underline", "Pango.Variant", "Pango.Weight", "Pango.WrapMode", ] manual = [ "GLib.Error", "Pango.Analysis", "Pango.AttrClass", "Pango.Coverage", "Pango.Language", "Pango.Rectangle", ] ignore = [ "Pango.EngineLang", "Pango.EngineShape", ] [[object]] name = "Pango.*" status = "generate" [[object.function]] name = "extents_to_pixels" [[object.function.parameter]] pattern = ".+" const = true [[object.function]] name = "get_mirror_char" #out param ignore = true [[object.function]] name = "log2vis_get_embedding_levels" #out param ignore = true [[object.function]] pattern = "attr_.+" #moved to Attribute ignore = true [[object.function]] name = "itemize" [[object.function.parameter]] name = "cached_iter" const = true [[object.function]] name = "itemize_with_base_dir" [[object.function.parameter]] name = "cached_iter" const = true [[object.function]] name = "reorder_items" ignore = true [[object.function]] name = "shape_full" # invalid length computation on Stash instead of str ignore = true [[object.function]] name = "shape_with_flags" # ivanlid length computation on a Option, it should fallback to 0. ignore = true [[object]] name = "Pango.Attribute" status = "generate" [[object.function]] name = "get_type" version = "1.44" [[object]] name = "Pango.AttrIterator" status = "generate" [[object.function]] name = "get_font" manual = true [[object.function]] name = "get_type" version = "1.44" [[object]] name = "Pango.AttrList" status = "generate" [[object.derive]] name = "Debug" [[object.function]] name = "change" manual = true [[object.function]] name = "insert" manual = true [[object.function]] name = "insert_before" manual = true [[object.function]] name = "equal" ignore = true [[object]] name = "Pango.AttrType" status = "generate" [[object.function]] name = "register" # Problematic function needs manual implementation ignore = true [[object]] name = "Pango.Context" status = "generate" [[object.function]] name = "get_metrics" [[object.function.parameter]] name = "language" const = true [[object.function]] name = "load_fontset" [[object.function.parameter]] name = "language" const = true [[object.function]] name = "set_language" [[object.function.parameter]] name = "language" const = true [[object]] name = "Pango.Font" status = "generate" [[object.function]] name = "descriptions_free" ignore = true [[object.function]] name = "get_metrics" [[object.function.parameter]] name = "language" const = true [[object.function]] name = "find_shaper" [[object.function.parameter]] name = "language" const = true [[object.function]] name = "get_coverage" [[object.function.parameter]] name = "language" const = true [[object]] name = "Pango.FontDescription" status = "generate" [[object.function]] name = "from_string" [object.function.return] nullable = false [[object.function]] name = "set_family_static" ignore = true [[object.function]] name = "copy_static" ignore = true [[object.function]] name = "get_size_is_absolute" rename = "is_size_absolute" [[object.function]] name = "merge_static" ignore = true [[object]] name = "Pango.FontMap" status = "generate" [[object.function]] name = "load_fontset" [[object.function.parameter]] name = "language" const = true [[object]] name = "Pango.Layout" status = "generate" [[object.function]] name = "xy_to_index" [object.function.return] nullable = false [[object.function]] name = "set_tabs" [[object.function.parameter]] name = "tabs" const = true [[object]] name = "Pango.LayoutLine" status = "generate" [[object.function]] name = "x_to_index" manual = true [[object]] name = "Pango.ShapeFlags" version = "1.44" status = "generate" [[object]] name = "Pango.ShowFlags" version = "1.44" status = "generate" pango-0.14.8/LICENSE000064400000000000000000000020000072674642500120470ustar 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. pango-0.14.8/README.md000064400000000000000000000022650072674642500123360ustar 00000000000000# pango __Rust__ bindings and wrappers for __Pango__, part of [gtk-rs-core](https://github.com/gtk-rs/gtk-rs-core). ## Minimum supported Rust version Currently, the minimum supported Rust version is `1.51.0`. ## Documentation * [Rust API - Stable](https://gtk-rs.org/gtk-rs-core/stable/latest/docs/pango/) * [Rust API - Development](https://gtk-rs.org/gtk-rs-core/git/docs/pango) * [C API](https://developer.gnome.org/platform-overview/unstable/tech-pango.html.en) * [GTK Installation instructions](https://www.gtk.org/docs/installations/) ## Using We recommend using [crates from crates.io](https://crates.io/keywords/gtk-rs), as [demonstrated here](https://gtk-rs.org/#using). If you want to track the bleeding edge, use the git dependency instead: ```toml [dependencies] pango = { git = "https://github.com/gtk-rs/gtk-rs-core.git", package = "pango" } ``` Avoid mixing versioned and git crates like this: ```toml # This will not compile [dependencies] pango = "0.13" pango = { git = "https://github.com/gtk-rs/gtk-rs-core.git", package = "pango" } ``` ### See Also * [glib](https://crates.io/crates/glib) ## License __pango__ is available under the MIT License, please refer to it. pango-0.14.8/src/analysis.rs000064400000000000000000000035400072674642500140340ustar 00000000000000// Take a look at the license at the top of the repository in the LICENSE file. use crate::Attribute; use crate::Font; use crate::Gravity; use crate::Language; use crate::Script; use glib::translate::*; #[repr(C)] #[doc(alias = "PangoAnalysis")] pub struct Analysis(ffi::PangoAnalysis); impl Analysis { pub fn font(&self) -> Font { unsafe { from_glib_none(self.0.font) } } pub fn level(&self) -> u8 { self.0.level } pub fn gravity(&self) -> Gravity { unsafe { from_glib(self.0.gravity as i32) } } pub fn flags(&self) -> u8 { self.0.flags } pub fn script(&self) -> Script { unsafe { from_glib(self.0.script as i32) } } pub fn language(&self) -> Language { unsafe { from_glib_none(self.0.language) } } pub fn extra_attrs(&self) -> Vec { unsafe { FromGlibPtrContainer::from_glib_none(self.0.extra_attrs) } } } #[doc(hidden)] impl<'a> ToGlibPtr<'a, *const ffi::PangoAnalysis> for Analysis { type Storage = &'a Self; #[inline] fn to_glib_none(&'a self) -> Stash<'a, *const ffi::PangoAnalysis, Self> { let ptr: *const ffi::PangoAnalysis = &self.0; Stash(ptr, self) } } #[doc(hidden)] impl<'a> ToGlibPtrMut<'a, *mut ffi::PangoAnalysis> for Analysis { type Storage = &'a mut Self; #[inline] fn to_glib_none_mut(&'a mut self) -> StashMut<'a, *mut ffi::PangoAnalysis, Self> { let ptr: *mut ffi::PangoAnalysis = &mut self.0; StashMut(ptr, self) } } #[doc(hidden)] impl FromGlibPtrNone<*const ffi::PangoAnalysis> for Analysis { unsafe fn from_glib_none(ptr: *const ffi::PangoAnalysis) -> Self { Self(*ptr) } } #[doc(hidden)] impl FromGlibPtrNone<*mut ffi::PangoAnalysis> for Analysis { unsafe fn from_glib_none(ptr: *mut ffi::PangoAnalysis) -> Self { Self(*ptr) } } pango-0.14.8/src/attr_class.rs000064400000000000000000000031110072674642500143420ustar 00000000000000// Take a look at the license at the top of the repository in the LICENSE file. use crate::AttrType; use glib::translate::{from_glib, FromGlibPtrFull, FromGlibPtrNone, Stash, ToGlibPtr}; #[doc(hidden)] impl<'a> ToGlibPtr<'a, *mut ffi::PangoAttrClass> for &'a AttrClass { type Storage = &'a AttrClass; fn to_glib_none(&self) -> Stash<'a, *mut ffi::PangoAttrClass, Self> { Stash(self.0, *self) } } #[doc(hidden)] impl FromGlibPtrNone<*mut ffi::PangoAttrClass> for AttrClass { unsafe fn from_glib_none(ptr: *mut ffi::PangoAttrClass) -> Self { assert!(!ptr.is_null()); Self(ptr) } } #[doc(hidden)] impl FromGlibPtrFull<*mut ffi::PangoAttrClass> for AttrClass { unsafe fn from_glib_full(ptr: *mut ffi::PangoAttrClass) -> Self { assert!(!ptr.is_null()); Self(ptr) } } #[doc(hidden)] impl FromGlibPtrNone<*const ffi::PangoAttrClass> for AttrClass { unsafe fn from_glib_none(ptr: *const ffi::PangoAttrClass) -> Self { assert!(!ptr.is_null()); Self(ptr as *mut _) } } #[doc(hidden)] impl FromGlibPtrFull<*const ffi::PangoAttrClass> for AttrClass { unsafe fn from_glib_full(ptr: *const ffi::PangoAttrClass) -> Self { assert!(!ptr.is_null()); Self(ptr as *mut _) } } #[doc(alias = "PangoAttrClass")] pub struct AttrClass(*mut ffi::PangoAttrClass); impl AttrClass { pub fn type_(&self) -> AttrType { unsafe { from_glib((*self.0).type_) } } } impl PartialEq for AttrClass { fn eq(&self, other: &AttrClass) -> bool { self.0 == other.0 } } impl Eq for AttrClass {} pango-0.14.8/src/attr_iterator.rs000064400000000000000000000020000072674642500150620ustar 00000000000000// Take a look at the license at the top of the repository in the LICENSE file. use crate::AttrIterator; use crate::Attribute; use crate::FontDescription; use crate::Language; use glib::translate::*; use std::ptr; impl AttrIterator { #[doc(alias = "pango_attr_iterator_get_font")] #[doc(alias = "get_font")] pub fn font( &mut self, desc: &mut FontDescription, language: Option<&Language>, extra_attrs: &[&Attribute], ) { unsafe { let stash_vec: Vec<_> = extra_attrs.iter().rev().map(|v| v.to_glib_none()).collect(); let mut list: *mut glib::ffi::GSList = ptr::null_mut(); for stash in &stash_vec { list = glib::ffi::g_slist_prepend(list, Ptr::to(stash.0)); } ffi::pango_attr_iterator_get_font( self.to_glib_none_mut().0, desc.to_glib_none_mut().0, &mut language.to_glib_none().0, &mut list, ); } } } pango-0.14.8/src/attr_list.rs000064400000000000000000000032700072674642500142160ustar 00000000000000// Take a look at the license at the top of the repository in the LICENSE file. use crate::AttrList; use crate::Attribute; use glib::translate::*; use std::mem; impl AttrList { #[doc(alias = "pango_attr_list_change")] pub fn change(&self, attr: Attribute) { unsafe { ffi::pango_attr_list_change(self.to_glib_none().0, attr.to_glib_none().0 as *mut _); mem::forget(attr); //As attr transferred fully } } #[cfg(any(feature = "v1_46", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_46")))] #[doc(alias = "pango_attr_list_equal")] fn equal(&self, other_list: &AttrList) -> bool { unsafe { from_glib(ffi::pango_attr_list_equal( self.to_glib_none().0, other_list.to_glib_none().0, )) } } #[doc(alias = "pango_attr_list_insert")] pub fn insert(&self, attr: Attribute) { unsafe { ffi::pango_attr_list_insert(self.to_glib_none().0, attr.to_glib_none().0 as *mut _); mem::forget(attr); //As attr transferred fully } } #[doc(alias = "pango_attr_list_insert_before")] pub fn insert_before(&self, attr: Attribute) { unsafe { ffi::pango_attr_list_insert_before( self.to_glib_none().0, attr.to_glib_none().0 as *mut _, ); mem::forget(attr); //As attr transferred fully } } } #[cfg(any(feature = "v1_46", feature = "dox"))] impl PartialEq for AttrList { #[inline] fn eq(&self, other: &Self) -> bool { self.equal(other) } } #[cfg(any(feature = "v1_46", feature = "dox"))] impl Eq for AttrList {} pango-0.14.8/src/attribute.rs000064400000000000000000000326160072674642500142220ustar 00000000000000// Take a look at the license at the top of the repository in the LICENSE file. use crate::AttrClass; use crate::AttrType; use crate::Attribute; use crate::Color; use crate::FontDescription; use crate::Gravity; use crate::GravityHint; use crate::Language; #[cfg(any(feature = "v1_46", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_46")))] use crate::Overline; use crate::Rectangle; #[cfg(any(feature = "v1_44", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_44")))] use crate::ShowFlags; use crate::Stretch; use crate::Style; use crate::Underline; use crate::Variant; use crate::Weight; use glib::translate::*; impl Attribute { #[cfg(any(feature = "v1_44", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_44")))] #[doc(alias = "pango_attr_allow_breaks_new")] pub fn new_allow_breaks(allow_breaks: bool) -> Self { unsafe { from_glib_full(ffi::pango_attr_allow_breaks_new(allow_breaks.into_glib())) } } #[doc(alias = "pango_attr_background_alpha_new")] pub fn new_background_alpha(alpha: u16) -> Self { unsafe { from_glib_full(ffi::pango_attr_background_alpha_new(alpha)) } } #[doc(alias = "pango_attr_background_new")] pub fn new_background(red: u16, green: u16, blue: u16) -> Self { unsafe { from_glib_full(ffi::pango_attr_background_new(red, green, blue)) } } #[doc(alias = "pango_attr_fallback_new")] pub fn new_fallback(enable_fallback: bool) -> Self { unsafe { from_glib_full(ffi::pango_attr_fallback_new(enable_fallback.into_glib())) } } #[doc(alias = "pango_attr_family_new")] pub fn new_family(family: &str) -> Self { unsafe { from_glib_full(ffi::pango_attr_family_new(family.to_glib_none().0)) } } #[doc(alias = "pango_attr_font_desc_new")] pub fn new_font_desc(desc: &FontDescription) -> Self { unsafe { from_glib_full(ffi::pango_attr_font_desc_new(desc.to_glib_none().0)) } } #[doc(alias = "pango_attr_font_features_new")] pub fn new_font_features(features: &str) -> Self { unsafe { from_glib_full(ffi::pango_attr_font_features_new(features.to_glib_none().0)) } } #[doc(alias = "pango_attr_foreground_alpha_new")] pub fn new_foreground_alpha(alpha: u16) -> Self { unsafe { from_glib_full(ffi::pango_attr_foreground_alpha_new(alpha)) } } #[doc(alias = "pango_attr_foreground_new")] pub fn new_foreground(red: u16, green: u16, blue: u16) -> Self { unsafe { from_glib_full(ffi::pango_attr_foreground_new(red, green, blue)) } } #[doc(alias = "pango_attr_gravity_hint_new")] pub fn new_gravity_hint(hint: GravityHint) -> Self { unsafe { from_glib_full(ffi::pango_attr_gravity_hint_new(hint.into_glib())) } } #[doc(alias = "pango_attr_gravity_new")] pub fn new_gravity(gravity: Gravity) -> Self { unsafe { from_glib_full(ffi::pango_attr_gravity_new(gravity.into_glib())) } } #[cfg(any(feature = "v1_44", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_44")))] #[doc(alias = "pango_attr_insert_hyphens_new")] pub fn new_insert_hyphens(insert_hyphens: bool) -> Self { unsafe { from_glib_full(ffi::pango_attr_insert_hyphens_new( insert_hyphens.into_glib(), )) } } #[doc(alias = "pango_attr_letter_spacing_new")] pub fn new_letter_spacing(letter_spacing: i32) -> Self { unsafe { from_glib_full(ffi::pango_attr_letter_spacing_new(letter_spacing)) } } #[cfg(any(feature = "v1_46", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_46")))] #[doc(alias = "pango_attr_overline_color_new")] pub fn new_overline_color(red: u16, green: u16, blue: u16) -> Self { unsafe { from_glib_full(ffi::pango_attr_overline_color_new(red, green, blue)) } } #[cfg(any(feature = "v1_46", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_46")))] #[doc(alias = "pango_attr_overline_new")] pub fn new_overline(overline: Overline) -> Self { unsafe { from_glib_full(ffi::pango_attr_overline_new(overline.into_glib())) } } #[doc(alias = "pango_attr_rise_new")] pub fn new_rise(rise: i32) -> Self { unsafe { from_glib_full(ffi::pango_attr_rise_new(rise)) } } #[doc(alias = "pango_attr_scale_new")] pub fn new_scale(scale_factor: f64) -> Self { unsafe { from_glib_full(ffi::pango_attr_scale_new(scale_factor)) } } #[cfg(any(feature = "v1_44", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_44")))] #[doc(alias = "pango_attr_show_new")] pub fn new_show(flags: ShowFlags) -> Self { unsafe { from_glib_full(ffi::pango_attr_show_new(flags.into_glib())) } } #[doc(alias = "pango_attr_size_new")] pub fn new_size(size: i32) -> Self { unsafe { from_glib_full(ffi::pango_attr_size_new(size)) } } #[doc(alias = "pango_attr_size_new_absolute")] pub fn new_size_absolute(size: i32) -> Self { unsafe { from_glib_full(ffi::pango_attr_size_new_absolute(size)) } } #[doc(alias = "pango_attr_stretch_new")] pub fn new_stretch(stretch: Stretch) -> Self { unsafe { from_glib_full(ffi::pango_attr_stretch_new(stretch.into_glib())) } } #[doc(alias = "pango_attr_strikethrough_color_new")] pub fn new_strikethrough_color(red: u16, green: u16, blue: u16) -> Self { unsafe { from_glib_full(ffi::pango_attr_strikethrough_color_new(red, green, blue)) } } #[doc(alias = "pango_attr_strikethrough_new")] pub fn new_strikethrough(strikethrough: bool) -> Self { unsafe { from_glib_full(ffi::pango_attr_strikethrough_new(strikethrough.into_glib())) } } #[doc(alias = "pango_attr_style_new")] pub fn new_style(style: Style) -> Self { unsafe { from_glib_full(ffi::pango_attr_style_new(style.into_glib())) } } #[doc(alias = "pango_attr_underline_color_new")] pub fn new_underline_color(red: u16, green: u16, blue: u16) -> Self { unsafe { from_glib_full(ffi::pango_attr_underline_color_new(red, green, blue)) } } #[doc(alias = "pango_attr_underline_new")] pub fn new_underline(underline: Underline) -> Self { unsafe { from_glib_full(ffi::pango_attr_underline_new(underline.into_glib())) } } #[doc(alias = "pango_attr_variant_new")] pub fn new_variant(variant: Variant) -> Self { unsafe { from_glib_full(ffi::pango_attr_variant_new(variant.into_glib())) } } #[doc(alias = "pango_attr_weight_new")] pub fn new_weight(weight: Weight) -> Self { unsafe { from_glib_full(ffi::pango_attr_weight_new(weight.into_glib())) } } #[doc(alias = "pango_attr_shape_new")] pub fn new_shape(ink_rect: &Rectangle, logical_rect: &Rectangle) -> Self { unsafe { from_glib_full(ffi::pango_attr_shape_new( ink_rect.to_glib_none().0, logical_rect.to_glib_none().0, )) } } #[doc(alias = "get_attr_class")] pub fn attr_class(&self) -> AttrClass { unsafe { from_glib_full((*self.to_glib_none().0).klass) } } pub fn type_(&self) -> AttrType { unsafe { from_glib((*(*self.to_glib_none().0).klass).type_) } } #[doc(alias = "get_start_index")] pub fn start_index(&self) -> u32 { unsafe { let stash = self.to_glib_none(); (*stash.0).start_index } } #[doc(alias = "get_end_index")] pub fn end_index(&self) -> u32 { unsafe { let stash = self.to_glib_none(); (*stash.0).end_index } } pub fn set_start_index(&mut self, index: u32) { unsafe { let stash = self.to_glib_none_mut(); (*stash.0).start_index = index; } } pub fn set_end_index(&mut self, index: u32) { unsafe { let stash = self.to_glib_none_mut(); (*stash.0).end_index = index; } } pub fn downcast(self) -> Result { unsafe { if T::ATTR_TYPES.contains(&self.attr_class().type_()) { Ok(from_glib_full(self.to_glib_full())) } else { Err(self) } } } pub fn downcast_ref(&self) -> Option<&T> { unsafe { if T::ATTR_TYPES.contains(&self.attr_class().type_()) { Some(&*(self as *const Attribute as *const T)) } else { None } } } } pub unsafe trait IsAttribute: FromGlibPtrFull<*const ffi::PangoAttribute> + FromGlibPtrFull<*mut ffi::PangoAttribute> + std::convert::AsRef + 'static { const ATTR_TYPES: &'static [AttrType]; fn upcast(self) -> Attribute; fn upcast_ref(&self) -> &Attribute; } macro_rules! define_attribute_struct { ($rust_type:ident, $ffi_type:path, $attr_types:expr) => { #[cfg(any(feature = "v1_44", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_44")))] glib::wrapper! { #[derive(Debug)] pub struct $rust_type(Boxed<$ffi_type>); match fn { copy => |ptr| ffi::pango_attribute_copy(ptr as *const ffi::PangoAttribute) as *mut $ffi_type, free => |ptr| ffi::pango_attribute_destroy(ptr as *mut ffi::PangoAttribute), type_ => || ffi::pango_attribute_get_type(), } } #[cfg(not(any(feature = "v1_44", feature = "dox")))] glib::wrapper! { #[derive(Debug)] pub struct $rust_type(Boxed<$ffi_type>); match fn { copy => |ptr| ffi::pango_attribute_copy(ptr as *const ffi::PangoAttribute) as *mut $ffi_type, free => |ptr| ffi::pango_attribute_destroy(ptr as *mut ffi::PangoAttribute), } } impl $rust_type { #[doc(alias = "pango_attribute_equal")] fn equal<'a, T: IsAttribute>(&self, attr2: &'a T) -> bool { unsafe { from_glib(ffi::pango_attribute_equal( self.to_glib_none().0 as *const ffi::PangoAttribute, attr2.upcast_ref().to_glib_none().0 as *const ffi::PangoAttribute, )) } } } impl PartialEq for $rust_type { #[inline] fn eq(&self, other: &Self) -> bool { self.equal(other) } } impl Eq for $rust_type {} unsafe impl IsAttribute for $rust_type { const ATTR_TYPES: &'static [AttrType] = $attr_types; fn upcast(self) -> crate::Attribute { unsafe { from_glib_full(self.to_glib_full() as *mut ffi::PangoAttribute) } } fn upcast_ref(&self) -> &crate::Attribute { &*self } } #[doc(hidden)] impl FromGlibPtrFull<*mut ffi::PangoAttribute> for $rust_type { unsafe fn from_glib_full(ptr: *mut ffi::PangoAttribute) -> Self { from_glib_full(ptr as *mut $ffi_type) } } #[doc(hidden)] impl FromGlibPtrFull<*const ffi::PangoAttribute> for $rust_type { unsafe fn from_glib_full(ptr: *const ffi::PangoAttribute) -> Self { from_glib_full(ptr as *const $ffi_type) } } impl std::convert::AsRef for $rust_type { fn as_ref(&self) -> &crate::Attribute { &*self } } impl std::ops::Deref for $rust_type { type Target = crate::Attribute; fn deref(&self) -> &Self::Target { unsafe { &*(self as *const $rust_type as *const crate::Attribute) } } } } } define_attribute_struct!( AttrColor, ffi::PangoAttrColor, &[ AttrType::Foreground, AttrType::Background, AttrType::UnderlineColor, AttrType::StrikethroughColor, AttrType::OverlineColor ] ); impl AttrColor { pub fn color(&self) -> Color { unsafe { from_glib_none((&self.0.color) as *const ffi::PangoColor) } } } define_attribute_struct!( AttrInt, ffi::PangoAttrInt, &[ AttrType::AbsoluteSize, AttrType::AllowBreaks, AttrType::BackgroundAlpha, AttrType::Fallback, AttrType::FontFeatures, AttrType::ForegroundAlpha, AttrType::Gravity, AttrType::GravityHint, AttrType::InsertHyphens, AttrType::LetterSpacing, AttrType::Overline, AttrType::Rise, AttrType::Show, AttrType::Size, AttrType::Stretch, AttrType::Strikethrough, AttrType::Style, AttrType::Underline, AttrType::Variant, AttrType::Weight ] ); impl AttrInt { pub fn value(&self) -> i32 { self.0.value } } define_attribute_struct!(AttrFloat, ffi::PangoAttrFloat, &[AttrType::Scale]); impl AttrFloat { pub fn value(&self) -> f64 { self.0.value } } define_attribute_struct!(AttrFontDesc, ffi::PangoAttrFontDesc, &[AttrType::FontDesc]); impl AttrFontDesc { pub fn value(&self) -> FontDescription { unsafe { from_glib_none(self.0.desc) } } } define_attribute_struct!(AttrLanguage, ffi::PangoAttrLanguage, &[AttrType::Language]); impl AttrLanguage { pub fn value(&self) -> Language { unsafe { from_glib_none(self.0.value) } } } pango-0.14.8/src/auto/alias.rs000064400000000000000000000004100072674642500142430ustar 00000000000000// This file was generated by gir (https://github.com/gtk-rs/gir) // from gir-files (https://github.com/gtk-rs/gir-files) // DO NOT EDIT #[allow(unused_imports)] use crate::auto::*; pub type Glyph = u32; pub type GlyphUnit = i32; pub type LayoutRun = GlyphItem; pango-0.14.8/src/auto/attr_iterator.rs000064400000000000000000000044530072674642500160500ustar 00000000000000// This file was generated by gir (https://github.com/gtk-rs/gir) // from gir-files (https://github.com/gtk-rs/gir-files) // DO NOT EDIT use crate::AttrType; use crate::Attribute; use glib::translate::*; use std::mem; #[cfg(any(feature = "v1_44", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_44")))] glib::wrapper! { #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct AttrIterator(Boxed); match fn { copy => |ptr| ffi::pango_attr_iterator_copy(mut_override(ptr)), free => |ptr| ffi::pango_attr_iterator_destroy(ptr), type_ => || ffi::pango_attr_iterator_get_type(), } } #[cfg(not(any(feature = "v1_44", feature = "dox")))] glib::wrapper! { #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct AttrIterator(Boxed); match fn { copy => |ptr| ffi::pango_attr_iterator_copy(mut_override(ptr)), free => |ptr| ffi::pango_attr_iterator_destroy(ptr), } } impl AttrIterator { #[doc(alias = "pango_attr_iterator_get")] pub fn get(&mut self, type_: AttrType) -> Option { unsafe { from_glib_none(ffi::pango_attr_iterator_get( self.to_glib_none_mut().0, type_.into_glib(), )) } } #[doc(alias = "pango_attr_iterator_get_attrs")] #[doc(alias = "get_attrs")] pub fn attrs(&mut self) -> Vec { unsafe { FromGlibPtrContainer::from_glib_full(ffi::pango_attr_iterator_get_attrs( self.to_glib_none_mut().0, )) } } #[doc(alias = "pango_attr_iterator_next")] pub fn next(&mut self) -> bool { unsafe { from_glib(ffi::pango_attr_iterator_next(self.to_glib_none_mut().0)) } } #[doc(alias = "pango_attr_iterator_range")] pub fn range(&mut self) -> (i32, i32) { unsafe { let mut start = mem::MaybeUninit::uninit(); let mut end = mem::MaybeUninit::uninit(); ffi::pango_attr_iterator_range( self.to_glib_none_mut().0, start.as_mut_ptr(), end.as_mut_ptr(), ); let start = start.assume_init(); let end = end.assume_init(); (start, end) } } } pango-0.14.8/src/auto/attr_list.rs000064400000000000000000000057560072674642500152010ustar 00000000000000// This file was generated by gir (https://github.com/gtk-rs/gir) // from gir-files (https://github.com/gtk-rs/gir-files) // DO NOT EDIT use crate::AttrIterator; use crate::Attribute; use glib::translate::*; glib::wrapper! { #[derive(Debug)] pub struct AttrList(Shared); match fn { ref => |ptr| ffi::pango_attr_list_ref(ptr), unref => |ptr| ffi::pango_attr_list_unref(ptr), type_ => || ffi::pango_attr_list_get_type(), } } impl AttrList { #[doc(alias = "pango_attr_list_new")] pub fn new() -> AttrList { unsafe { from_glib_full(ffi::pango_attr_list_new()) } } #[doc(alias = "pango_attr_list_copy")] pub fn copy(&self) -> Option { unsafe { from_glib_full(ffi::pango_attr_list_copy(self.to_glib_none().0)) } } #[doc(alias = "pango_attr_list_filter")] pub fn filter bool>(&self, func: P) -> Option { let func_data: P = func; unsafe extern "C" fn func_func bool>( attribute: *mut ffi::PangoAttribute, user_data: glib::ffi::gpointer, ) -> glib::ffi::gboolean { let attribute = from_glib_borrow(attribute); let callback: *mut P = user_data as *const _ as usize as *mut P; let res = (*callback)(&attribute); res.into_glib() } let func = Some(func_func::

as _); let super_callback0: &P = &func_data; unsafe { from_glib_full(ffi::pango_attr_list_filter( self.to_glib_none().0, func, super_callback0 as *const _ as usize as *mut _, )) } } #[cfg(any(feature = "v1_44", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_44")))] #[doc(alias = "pango_attr_list_get_attributes")] #[doc(alias = "get_attributes")] pub fn attributes(&self) -> Vec { unsafe { FromGlibPtrContainer::from_glib_full(ffi::pango_attr_list_get_attributes( self.to_glib_none().0, )) } } #[doc(alias = "pango_attr_list_get_iterator")] #[doc(alias = "get_iterator")] pub fn iterator(&self) -> Option { unsafe { from_glib_full(ffi::pango_attr_list_get_iterator(self.to_glib_none().0)) } } #[doc(alias = "pango_attr_list_splice")] pub fn splice(&self, other: &AttrList, pos: i32, len: i32) { unsafe { ffi::pango_attr_list_splice(self.to_glib_none().0, other.to_glib_none().0, pos, len); } } #[cfg(any(feature = "v1_44", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_44")))] #[doc(alias = "pango_attr_list_update")] pub fn update(&self, pos: i32, remove: i32, add: i32) { unsafe { ffi::pango_attr_list_update(self.to_glib_none().0, pos, remove, add); } } } impl Default for AttrList { fn default() -> Self { Self::new() } } pango-0.14.8/src/auto/attribute.rs000064400000000000000000000030160072674642500151620ustar 00000000000000// This file was generated by gir (https://github.com/gtk-rs/gir) // from gir-files (https://github.com/gtk-rs/gir-files) // DO NOT EDIT use crate::AttrClass; use glib::translate::*; #[cfg(any(feature = "v1_44", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_44")))] glib::wrapper! { #[derive(Debug, PartialOrd, Ord, Hash)] pub struct Attribute(Boxed); match fn { copy => |ptr| ffi::pango_attribute_copy(ptr), free => |ptr| ffi::pango_attribute_destroy(ptr), type_ => || ffi::pango_attribute_get_type(), } } #[cfg(not(any(feature = "v1_44", feature = "dox")))] glib::wrapper! { #[derive(Debug, PartialOrd, Ord, Hash)] pub struct Attribute(Boxed); match fn { copy => |ptr| ffi::pango_attribute_copy(ptr), free => |ptr| ffi::pango_attribute_destroy(ptr), } } impl Attribute { #[doc(alias = "pango_attribute_equal")] fn equal(&self, attr2: &Attribute) -> bool { unsafe { from_glib(ffi::pango_attribute_equal( self.to_glib_none().0, attr2.to_glib_none().0, )) } } #[doc(alias = "pango_attribute_init")] pub fn init(&mut self, klass: &AttrClass) { unsafe { ffi::pango_attribute_init(self.to_glib_none_mut().0, klass.to_glib_none().0); } } } impl PartialEq for Attribute { #[inline] fn eq(&self, other: &Self) -> bool { self.equal(other) } } impl Eq for Attribute {} pango-0.14.8/src/auto/color.rs000064400000000000000000000035640072674642500143050ustar 00000000000000// This file was generated by gir (https://github.com/gtk-rs/gir) // from gir-files (https://github.com/gtk-rs/gir-files) // DO NOT EDIT use glib::translate::*; use std::fmt; #[cfg(any(feature = "v1_46", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_46")))] use std::mem; glib::wrapper! { #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct Color(Boxed); match fn { copy => |ptr| ffi::pango_color_copy(ptr), free => |ptr| ffi::pango_color_free(ptr), type_ => || ffi::pango_color_get_type(), } } impl Color { #[doc(alias = "pango_color_parse")] pub fn parse(&mut self, spec: &str) -> bool { unsafe { from_glib(ffi::pango_color_parse( self.to_glib_none_mut().0, spec.to_glib_none().0, )) } } #[cfg(any(feature = "v1_46", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_46")))] #[doc(alias = "pango_color_parse_with_alpha")] pub fn parse_with_alpha(&mut self, spec: &str) -> Option { unsafe { let mut alpha = mem::MaybeUninit::uninit(); let ret = from_glib(ffi::pango_color_parse_with_alpha( self.to_glib_none_mut().0, alpha.as_mut_ptr(), spec.to_glib_none().0, )); let alpha = alpha.assume_init(); if ret { Some(alpha) } else { None } } } #[doc(alias = "pango_color_to_string")] #[doc(alias = "to_string")] pub fn to_str(&self) -> glib::GString { unsafe { from_glib_full(ffi::pango_color_to_string(self.to_glib_none().0)) } } } impl fmt::Display for Color { #[inline] fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.write_str(&self.to_str()) } } pango-0.14.8/src/auto/constants.rs000064400000000000000000000021150072674642500151720ustar 00000000000000// This file was generated by gir (https://github.com/gtk-rs/gir) // from gir-files (https://github.com/gtk-rs/gir-files) // DO NOT EDIT use std::ffi::CStr; #[cfg_attr(feature = "v1_38", deprecated = "Since 1.38")] #[doc(alias = "PANGO_ENGINE_TYPE_LANG")] pub static ENGINE_TYPE_LANG: once_cell::sync::Lazy<&'static str> = once_cell::sync::Lazy::new(|| unsafe { CStr::from_ptr(ffi::PANGO_ENGINE_TYPE_LANG) .to_str() .unwrap() }); #[cfg_attr(feature = "v1_38", deprecated = "Since 1.38")] #[doc(alias = "PANGO_ENGINE_TYPE_SHAPE")] pub static ENGINE_TYPE_SHAPE: once_cell::sync::Lazy<&'static str> = once_cell::sync::Lazy::new(|| unsafe { CStr::from_ptr(ffi::PANGO_ENGINE_TYPE_SHAPE) .to_str() .unwrap() }); #[cfg_attr(feature = "v1_38", deprecated = "Since 1.38")] #[doc(alias = "PANGO_RENDER_TYPE_NONE")] pub static RENDER_TYPE_NONE: once_cell::sync::Lazy<&'static str> = once_cell::sync::Lazy::new(|| unsafe { CStr::from_ptr(ffi::PANGO_RENDER_TYPE_NONE) .to_str() .unwrap() }); pango-0.14.8/src/auto/context.rs000064400000000000000000000166730072674642500146600ustar 00000000000000// This file was generated by gir (https://github.com/gtk-rs/gir) // from gir-files (https://github.com/gtk-rs/gir-files) // DO NOT EDIT use crate::Direction; use crate::Font; use crate::FontDescription; use crate::FontFamily; use crate::FontMap; use crate::FontMetrics; use crate::Fontset; use crate::Gravity; use crate::GravityHint; use crate::Language; use crate::Matrix; use glib::object::IsA; use glib::translate::*; use std::fmt; use std::mem; use std::ptr; glib::wrapper! { #[doc(alias = "PangoContext")] pub struct Context(Object); match fn { type_ => || ffi::pango_context_get_type(), } } impl Context { #[doc(alias = "pango_context_new")] pub fn new() -> Context { unsafe { from_glib_full(ffi::pango_context_new()) } } #[doc(alias = "pango_context_changed")] pub fn changed(&self) { unsafe { ffi::pango_context_changed(self.to_glib_none().0); } } #[doc(alias = "pango_context_get_base_dir")] #[doc(alias = "get_base_dir")] pub fn base_dir(&self) -> Direction { unsafe { from_glib(ffi::pango_context_get_base_dir(self.to_glib_none().0)) } } #[doc(alias = "pango_context_get_base_gravity")] #[doc(alias = "get_base_gravity")] pub fn base_gravity(&self) -> Gravity { unsafe { from_glib(ffi::pango_context_get_base_gravity(self.to_glib_none().0)) } } #[doc(alias = "pango_context_get_font_description")] #[doc(alias = "get_font_description")] pub fn font_description(&self) -> Option { unsafe { from_glib_none(ffi::pango_context_get_font_description( self.to_glib_none().0, )) } } #[doc(alias = "pango_context_get_font_map")] #[doc(alias = "get_font_map")] pub fn font_map(&self) -> Option { unsafe { from_glib_none(ffi::pango_context_get_font_map(self.to_glib_none().0)) } } #[doc(alias = "pango_context_get_gravity")] #[doc(alias = "get_gravity")] pub fn gravity(&self) -> Gravity { unsafe { from_glib(ffi::pango_context_get_gravity(self.to_glib_none().0)) } } #[doc(alias = "pango_context_get_gravity_hint")] #[doc(alias = "get_gravity_hint")] pub fn gravity_hint(&self) -> GravityHint { unsafe { from_glib(ffi::pango_context_get_gravity_hint(self.to_glib_none().0)) } } #[doc(alias = "pango_context_get_language")] #[doc(alias = "get_language")] pub fn language(&self) -> Option { unsafe { from_glib_full(ffi::pango_context_get_language(self.to_glib_none().0)) } } #[doc(alias = "pango_context_get_matrix")] #[doc(alias = "get_matrix")] pub fn matrix(&self) -> Option { unsafe { from_glib_none(ffi::pango_context_get_matrix(self.to_glib_none().0)) } } #[doc(alias = "pango_context_get_metrics")] #[doc(alias = "get_metrics")] pub fn metrics( &self, desc: Option<&FontDescription>, language: Option<&Language>, ) -> Option { unsafe { from_glib_full(ffi::pango_context_get_metrics( self.to_glib_none().0, desc.to_glib_none().0, mut_override(language.to_glib_none().0), )) } } #[cfg(any(feature = "v1_44", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_44")))] #[doc(alias = "pango_context_get_round_glyph_positions")] #[doc(alias = "get_round_glyph_positions")] pub fn is_round_glyph_positions(&self) -> bool { unsafe { from_glib(ffi::pango_context_get_round_glyph_positions( self.to_glib_none().0, )) } } #[doc(alias = "pango_context_get_serial")] #[doc(alias = "get_serial")] pub fn serial(&self) -> u32 { unsafe { ffi::pango_context_get_serial(self.to_glib_none().0) } } #[doc(alias = "pango_context_list_families")] pub fn list_families(&self) -> Vec { unsafe { let mut families = ptr::null_mut(); let mut n_families = mem::MaybeUninit::uninit(); ffi::pango_context_list_families( self.to_glib_none().0, &mut families, n_families.as_mut_ptr(), ); FromGlibContainer::from_glib_container_num(families, n_families.assume_init() as usize) } } #[doc(alias = "pango_context_load_font")] pub fn load_font(&self, desc: &FontDescription) -> Option { unsafe { from_glib_full(ffi::pango_context_load_font( self.to_glib_none().0, desc.to_glib_none().0, )) } } #[doc(alias = "pango_context_load_fontset")] pub fn load_fontset(&self, desc: &FontDescription, language: &Language) -> Option { unsafe { from_glib_full(ffi::pango_context_load_fontset( self.to_glib_none().0, desc.to_glib_none().0, mut_override(language.to_glib_none().0), )) } } #[doc(alias = "pango_context_set_base_dir")] pub fn set_base_dir(&self, direction: Direction) { unsafe { ffi::pango_context_set_base_dir(self.to_glib_none().0, direction.into_glib()); } } #[doc(alias = "pango_context_set_base_gravity")] pub fn set_base_gravity(&self, gravity: Gravity) { unsafe { ffi::pango_context_set_base_gravity(self.to_glib_none().0, gravity.into_glib()); } } #[doc(alias = "pango_context_set_font_description")] pub fn set_font_description(&self, desc: &FontDescription) { unsafe { ffi::pango_context_set_font_description(self.to_glib_none().0, desc.to_glib_none().0); } } #[doc(alias = "pango_context_set_font_map")] pub fn set_font_map>(&self, font_map: &P) { unsafe { ffi::pango_context_set_font_map( self.to_glib_none().0, font_map.as_ref().to_glib_none().0, ); } } #[doc(alias = "pango_context_set_gravity_hint")] pub fn set_gravity_hint(&self, hint: GravityHint) { unsafe { ffi::pango_context_set_gravity_hint(self.to_glib_none().0, hint.into_glib()); } } #[doc(alias = "pango_context_set_language")] pub fn set_language(&self, language: &Language) { unsafe { ffi::pango_context_set_language( self.to_glib_none().0, mut_override(language.to_glib_none().0), ); } } #[doc(alias = "pango_context_set_matrix")] pub fn set_matrix(&self, matrix: Option<&Matrix>) { unsafe { ffi::pango_context_set_matrix(self.to_glib_none().0, matrix.to_glib_none().0); } } #[cfg(any(feature = "v1_44", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_44")))] #[doc(alias = "pango_context_set_round_glyph_positions")] pub fn set_round_glyph_positions(&self, round_positions: bool) { unsafe { ffi::pango_context_set_round_glyph_positions( self.to_glib_none().0, round_positions.into_glib(), ); } } } impl Default for Context { fn default() -> Self { Self::new() } } impl fmt::Display for Context { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.write_str("Context") } } pango-0.14.8/src/auto/enums.rs000064400000000000000000002460660072674642500143240ustar 00000000000000// This file was generated by gir (https://github.com/gtk-rs/gir) // from gir-files (https://github.com/gtk-rs/gir-files) // DO NOT EDIT use crate::Language; use crate::Matrix; use glib::translate::*; use glib::value::FromValue; use glib::value::ToValue; use glib::StaticType; use glib::Type; use std::fmt; #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] #[non_exhaustive] #[doc(alias = "PangoAlignment")] pub enum Alignment { #[doc(alias = "PANGO_ALIGN_LEFT")] Left, #[doc(alias = "PANGO_ALIGN_CENTER")] Center, #[doc(alias = "PANGO_ALIGN_RIGHT")] Right, #[doc(hidden)] __Unknown(i32), } impl fmt::Display for Alignment { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, "Alignment::{}", match *self { Self::Left => "Left", Self::Center => "Center", Self::Right => "Right", _ => "Unknown", } ) } } #[doc(hidden)] impl IntoGlib for Alignment { type GlibType = ffi::PangoAlignment; fn into_glib(self) -> ffi::PangoAlignment { match self { Self::Left => ffi::PANGO_ALIGN_LEFT, Self::Center => ffi::PANGO_ALIGN_CENTER, Self::Right => ffi::PANGO_ALIGN_RIGHT, Self::__Unknown(value) => value, } } } #[doc(hidden)] impl FromGlib for Alignment { unsafe fn from_glib(value: ffi::PangoAlignment) -> Self { match value { ffi::PANGO_ALIGN_LEFT => Self::Left, ffi::PANGO_ALIGN_CENTER => Self::Center, ffi::PANGO_ALIGN_RIGHT => Self::Right, value => Self::__Unknown(value), } } } impl StaticType for Alignment { fn static_type() -> Type { unsafe { from_glib(ffi::pango_alignment_get_type()) } } } impl glib::value::ValueType for Alignment { type Type = Self; } unsafe impl<'a> FromValue<'a> for Alignment { type Checker = glib::value::GenericValueTypeChecker; unsafe fn from_value(value: &'a glib::Value) -> Self { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) } } impl ToValue for Alignment { 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 } fn value_type(&self) -> glib::Type { Self::static_type() } } #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] #[non_exhaustive] #[doc(alias = "PangoAttrType")] pub enum AttrType { #[doc(alias = "PANGO_ATTR_INVALID")] Invalid, #[doc(alias = "PANGO_ATTR_LANGUAGE")] Language, #[doc(alias = "PANGO_ATTR_FAMILY")] Family, #[doc(alias = "PANGO_ATTR_STYLE")] Style, #[doc(alias = "PANGO_ATTR_WEIGHT")] Weight, #[doc(alias = "PANGO_ATTR_VARIANT")] Variant, #[doc(alias = "PANGO_ATTR_STRETCH")] Stretch, #[doc(alias = "PANGO_ATTR_SIZE")] Size, #[doc(alias = "PANGO_ATTR_FONT_DESC")] FontDesc, #[doc(alias = "PANGO_ATTR_FOREGROUND")] Foreground, #[doc(alias = "PANGO_ATTR_BACKGROUND")] Background, #[doc(alias = "PANGO_ATTR_UNDERLINE")] Underline, #[doc(alias = "PANGO_ATTR_STRIKETHROUGH")] Strikethrough, #[doc(alias = "PANGO_ATTR_RISE")] Rise, #[doc(alias = "PANGO_ATTR_SHAPE")] Shape, #[doc(alias = "PANGO_ATTR_SCALE")] Scale, #[doc(alias = "PANGO_ATTR_FALLBACK")] Fallback, #[doc(alias = "PANGO_ATTR_LETTER_SPACING")] LetterSpacing, #[doc(alias = "PANGO_ATTR_UNDERLINE_COLOR")] UnderlineColor, #[doc(alias = "PANGO_ATTR_STRIKETHROUGH_COLOR")] StrikethroughColor, #[doc(alias = "PANGO_ATTR_ABSOLUTE_SIZE")] AbsoluteSize, #[doc(alias = "PANGO_ATTR_GRAVITY")] Gravity, #[doc(alias = "PANGO_ATTR_GRAVITY_HINT")] GravityHint, #[doc(alias = "PANGO_ATTR_FONT_FEATURES")] FontFeatures, #[doc(alias = "PANGO_ATTR_FOREGROUND_ALPHA")] ForegroundAlpha, #[doc(alias = "PANGO_ATTR_BACKGROUND_ALPHA")] BackgroundAlpha, #[doc(alias = "PANGO_ATTR_ALLOW_BREAKS")] AllowBreaks, #[doc(alias = "PANGO_ATTR_SHOW")] Show, #[doc(alias = "PANGO_ATTR_INSERT_HYPHENS")] InsertHyphens, #[doc(alias = "PANGO_ATTR_OVERLINE")] Overline, #[doc(alias = "PANGO_ATTR_OVERLINE_COLOR")] OverlineColor, #[doc(hidden)] __Unknown(i32), } impl AttrType { #[doc(alias = "pango_attr_type_get_name")] #[doc(alias = "get_name")] pub fn name(self) -> Option { unsafe { from_glib_none(ffi::pango_attr_type_get_name(self.into_glib())) } } } impl fmt::Display for AttrType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, "AttrType::{}", match *self { Self::Invalid => "Invalid", Self::Language => "Language", Self::Family => "Family", Self::Style => "Style", Self::Weight => "Weight", Self::Variant => "Variant", Self::Stretch => "Stretch", Self::Size => "Size", Self::FontDesc => "FontDesc", Self::Foreground => "Foreground", Self::Background => "Background", Self::Underline => "Underline", Self::Strikethrough => "Strikethrough", Self::Rise => "Rise", Self::Shape => "Shape", Self::Scale => "Scale", Self::Fallback => "Fallback", Self::LetterSpacing => "LetterSpacing", Self::UnderlineColor => "UnderlineColor", Self::StrikethroughColor => "StrikethroughColor", Self::AbsoluteSize => "AbsoluteSize", Self::Gravity => "Gravity", Self::GravityHint => "GravityHint", Self::FontFeatures => "FontFeatures", Self::ForegroundAlpha => "ForegroundAlpha", Self::BackgroundAlpha => "BackgroundAlpha", Self::AllowBreaks => "AllowBreaks", Self::Show => "Show", Self::InsertHyphens => "InsertHyphens", Self::Overline => "Overline", Self::OverlineColor => "OverlineColor", _ => "Unknown", } ) } } #[doc(hidden)] impl IntoGlib for AttrType { type GlibType = ffi::PangoAttrType; fn into_glib(self) -> ffi::PangoAttrType { match self { Self::Invalid => ffi::PANGO_ATTR_INVALID, Self::Language => ffi::PANGO_ATTR_LANGUAGE, Self::Family => ffi::PANGO_ATTR_FAMILY, Self::Style => ffi::PANGO_ATTR_STYLE, Self::Weight => ffi::PANGO_ATTR_WEIGHT, Self::Variant => ffi::PANGO_ATTR_VARIANT, Self::Stretch => ffi::PANGO_ATTR_STRETCH, Self::Size => ffi::PANGO_ATTR_SIZE, Self::FontDesc => ffi::PANGO_ATTR_FONT_DESC, Self::Foreground => ffi::PANGO_ATTR_FOREGROUND, Self::Background => ffi::PANGO_ATTR_BACKGROUND, Self::Underline => ffi::PANGO_ATTR_UNDERLINE, Self::Strikethrough => ffi::PANGO_ATTR_STRIKETHROUGH, Self::Rise => ffi::PANGO_ATTR_RISE, Self::Shape => ffi::PANGO_ATTR_SHAPE, Self::Scale => ffi::PANGO_ATTR_SCALE, Self::Fallback => ffi::PANGO_ATTR_FALLBACK, Self::LetterSpacing => ffi::PANGO_ATTR_LETTER_SPACING, Self::UnderlineColor => ffi::PANGO_ATTR_UNDERLINE_COLOR, Self::StrikethroughColor => ffi::PANGO_ATTR_STRIKETHROUGH_COLOR, Self::AbsoluteSize => ffi::PANGO_ATTR_ABSOLUTE_SIZE, Self::Gravity => ffi::PANGO_ATTR_GRAVITY, Self::GravityHint => ffi::PANGO_ATTR_GRAVITY_HINT, Self::FontFeatures => ffi::PANGO_ATTR_FONT_FEATURES, Self::ForegroundAlpha => ffi::PANGO_ATTR_FOREGROUND_ALPHA, Self::BackgroundAlpha => ffi::PANGO_ATTR_BACKGROUND_ALPHA, Self::AllowBreaks => ffi::PANGO_ATTR_ALLOW_BREAKS, Self::Show => ffi::PANGO_ATTR_SHOW, Self::InsertHyphens => ffi::PANGO_ATTR_INSERT_HYPHENS, Self::Overline => ffi::PANGO_ATTR_OVERLINE, Self::OverlineColor => ffi::PANGO_ATTR_OVERLINE_COLOR, Self::__Unknown(value) => value, } } } #[doc(hidden)] impl FromGlib for AttrType { unsafe fn from_glib(value: ffi::PangoAttrType) -> Self { match value { ffi::PANGO_ATTR_INVALID => Self::Invalid, ffi::PANGO_ATTR_LANGUAGE => Self::Language, ffi::PANGO_ATTR_FAMILY => Self::Family, ffi::PANGO_ATTR_STYLE => Self::Style, ffi::PANGO_ATTR_WEIGHT => Self::Weight, ffi::PANGO_ATTR_VARIANT => Self::Variant, ffi::PANGO_ATTR_STRETCH => Self::Stretch, ffi::PANGO_ATTR_SIZE => Self::Size, ffi::PANGO_ATTR_FONT_DESC => Self::FontDesc, ffi::PANGO_ATTR_FOREGROUND => Self::Foreground, ffi::PANGO_ATTR_BACKGROUND => Self::Background, ffi::PANGO_ATTR_UNDERLINE => Self::Underline, ffi::PANGO_ATTR_STRIKETHROUGH => Self::Strikethrough, ffi::PANGO_ATTR_RISE => Self::Rise, ffi::PANGO_ATTR_SHAPE => Self::Shape, ffi::PANGO_ATTR_SCALE => Self::Scale, ffi::PANGO_ATTR_FALLBACK => Self::Fallback, ffi::PANGO_ATTR_LETTER_SPACING => Self::LetterSpacing, ffi::PANGO_ATTR_UNDERLINE_COLOR => Self::UnderlineColor, ffi::PANGO_ATTR_STRIKETHROUGH_COLOR => Self::StrikethroughColor, ffi::PANGO_ATTR_ABSOLUTE_SIZE => Self::AbsoluteSize, ffi::PANGO_ATTR_GRAVITY => Self::Gravity, ffi::PANGO_ATTR_GRAVITY_HINT => Self::GravityHint, ffi::PANGO_ATTR_FONT_FEATURES => Self::FontFeatures, ffi::PANGO_ATTR_FOREGROUND_ALPHA => Self::ForegroundAlpha, ffi::PANGO_ATTR_BACKGROUND_ALPHA => Self::BackgroundAlpha, ffi::PANGO_ATTR_ALLOW_BREAKS => Self::AllowBreaks, ffi::PANGO_ATTR_SHOW => Self::Show, ffi::PANGO_ATTR_INSERT_HYPHENS => Self::InsertHyphens, ffi::PANGO_ATTR_OVERLINE => Self::Overline, ffi::PANGO_ATTR_OVERLINE_COLOR => Self::OverlineColor, value => Self::__Unknown(value), } } } impl StaticType for AttrType { fn static_type() -> Type { unsafe { from_glib(ffi::pango_attr_type_get_type()) } } } impl glib::value::ValueType for AttrType { type Type = Self; } unsafe impl<'a> FromValue<'a> for AttrType { type Checker = glib::value::GenericValueTypeChecker; unsafe fn from_value(value: &'a glib::Value) -> Self { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) } } impl ToValue for AttrType { 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 } fn value_type(&self) -> glib::Type { Self::static_type() } } #[cfg_attr(feature = "v1_44", deprecated = "Since 1.44")] #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] #[non_exhaustive] #[doc(alias = "PangoBidiType")] pub enum BidiType { #[doc(alias = "PANGO_BIDI_TYPE_L")] L, #[doc(alias = "PANGO_BIDI_TYPE_LRE")] Lre, #[doc(alias = "PANGO_BIDI_TYPE_LRO")] Lro, #[doc(alias = "PANGO_BIDI_TYPE_R")] R, #[doc(alias = "PANGO_BIDI_TYPE_AL")] Al, #[doc(alias = "PANGO_BIDI_TYPE_RLE")] Rle, #[doc(alias = "PANGO_BIDI_TYPE_RLO")] Rlo, #[doc(alias = "PANGO_BIDI_TYPE_PDF")] Pdf, #[doc(alias = "PANGO_BIDI_TYPE_EN")] En, #[doc(alias = "PANGO_BIDI_TYPE_ES")] Es, #[doc(alias = "PANGO_BIDI_TYPE_ET")] Et, #[doc(alias = "PANGO_BIDI_TYPE_AN")] An, #[doc(alias = "PANGO_BIDI_TYPE_CS")] Cs, #[doc(alias = "PANGO_BIDI_TYPE_NSM")] Nsm, #[doc(alias = "PANGO_BIDI_TYPE_BN")] Bn, #[doc(alias = "PANGO_BIDI_TYPE_B")] B, #[doc(alias = "PANGO_BIDI_TYPE_S")] S, #[doc(alias = "PANGO_BIDI_TYPE_WS")] Ws, #[doc(alias = "PANGO_BIDI_TYPE_ON")] On, #[doc(hidden)] __Unknown(i32), } impl BidiType { #[doc(alias = "pango_bidi_type_for_unichar")] pub fn for_unichar(ch: char) -> BidiType { unsafe { from_glib(ffi::pango_bidi_type_for_unichar(ch.into_glib())) } } } impl fmt::Display for BidiType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, "BidiType::{}", match *self { Self::L => "L", Self::Lre => "Lre", Self::Lro => "Lro", Self::R => "R", Self::Al => "Al", Self::Rle => "Rle", Self::Rlo => "Rlo", Self::Pdf => "Pdf", Self::En => "En", Self::Es => "Es", Self::Et => "Et", Self::An => "An", Self::Cs => "Cs", Self::Nsm => "Nsm", Self::Bn => "Bn", Self::B => "B", Self::S => "S", Self::Ws => "Ws", Self::On => "On", _ => "Unknown", } ) } } #[doc(hidden)] impl IntoGlib for BidiType { type GlibType = ffi::PangoBidiType; fn into_glib(self) -> ffi::PangoBidiType { match self { Self::L => ffi::PANGO_BIDI_TYPE_L, Self::Lre => ffi::PANGO_BIDI_TYPE_LRE, Self::Lro => ffi::PANGO_BIDI_TYPE_LRO, Self::R => ffi::PANGO_BIDI_TYPE_R, Self::Al => ffi::PANGO_BIDI_TYPE_AL, Self::Rle => ffi::PANGO_BIDI_TYPE_RLE, Self::Rlo => ffi::PANGO_BIDI_TYPE_RLO, Self::Pdf => ffi::PANGO_BIDI_TYPE_PDF, Self::En => ffi::PANGO_BIDI_TYPE_EN, Self::Es => ffi::PANGO_BIDI_TYPE_ES, Self::Et => ffi::PANGO_BIDI_TYPE_ET, Self::An => ffi::PANGO_BIDI_TYPE_AN, Self::Cs => ffi::PANGO_BIDI_TYPE_CS, Self::Nsm => ffi::PANGO_BIDI_TYPE_NSM, Self::Bn => ffi::PANGO_BIDI_TYPE_BN, Self::B => ffi::PANGO_BIDI_TYPE_B, Self::S => ffi::PANGO_BIDI_TYPE_S, Self::Ws => ffi::PANGO_BIDI_TYPE_WS, Self::On => ffi::PANGO_BIDI_TYPE_ON, Self::__Unknown(value) => value, } } } #[doc(hidden)] impl FromGlib for BidiType { unsafe fn from_glib(value: ffi::PangoBidiType) -> Self { match value { ffi::PANGO_BIDI_TYPE_L => Self::L, ffi::PANGO_BIDI_TYPE_LRE => Self::Lre, ffi::PANGO_BIDI_TYPE_LRO => Self::Lro, ffi::PANGO_BIDI_TYPE_R => Self::R, ffi::PANGO_BIDI_TYPE_AL => Self::Al, ffi::PANGO_BIDI_TYPE_RLE => Self::Rle, ffi::PANGO_BIDI_TYPE_RLO => Self::Rlo, ffi::PANGO_BIDI_TYPE_PDF => Self::Pdf, ffi::PANGO_BIDI_TYPE_EN => Self::En, ffi::PANGO_BIDI_TYPE_ES => Self::Es, ffi::PANGO_BIDI_TYPE_ET => Self::Et, ffi::PANGO_BIDI_TYPE_AN => Self::An, ffi::PANGO_BIDI_TYPE_CS => Self::Cs, ffi::PANGO_BIDI_TYPE_NSM => Self::Nsm, ffi::PANGO_BIDI_TYPE_BN => Self::Bn, ffi::PANGO_BIDI_TYPE_B => Self::B, ffi::PANGO_BIDI_TYPE_S => Self::S, ffi::PANGO_BIDI_TYPE_WS => Self::Ws, ffi::PANGO_BIDI_TYPE_ON => Self::On, value => Self::__Unknown(value), } } } impl StaticType for BidiType { fn static_type() -> Type { unsafe { from_glib(ffi::pango_bidi_type_get_type()) } } } impl glib::value::ValueType for BidiType { type Type = Self; } unsafe impl<'a> FromValue<'a> for BidiType { type Checker = glib::value::GenericValueTypeChecker; unsafe fn from_value(value: &'a glib::Value) -> Self { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) } } impl ToValue for BidiType { 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 } fn value_type(&self) -> glib::Type { Self::static_type() } } #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] #[non_exhaustive] #[doc(alias = "PangoCoverageLevel")] pub enum CoverageLevel { #[doc(alias = "PANGO_COVERAGE_NONE")] None, #[doc(alias = "PANGO_COVERAGE_FALLBACK")] Fallback, #[doc(alias = "PANGO_COVERAGE_APPROXIMATE")] Approximate, #[doc(alias = "PANGO_COVERAGE_EXACT")] Exact, #[doc(hidden)] __Unknown(i32), } impl fmt::Display for CoverageLevel { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, "CoverageLevel::{}", match *self { Self::None => "None", Self::Fallback => "Fallback", Self::Approximate => "Approximate", Self::Exact => "Exact", _ => "Unknown", } ) } } #[doc(hidden)] impl IntoGlib for CoverageLevel { type GlibType = ffi::PangoCoverageLevel; fn into_glib(self) -> ffi::PangoCoverageLevel { match self { Self::None => ffi::PANGO_COVERAGE_NONE, Self::Fallback => ffi::PANGO_COVERAGE_FALLBACK, Self::Approximate => ffi::PANGO_COVERAGE_APPROXIMATE, Self::Exact => ffi::PANGO_COVERAGE_EXACT, Self::__Unknown(value) => value, } } } #[doc(hidden)] impl FromGlib for CoverageLevel { unsafe fn from_glib(value: ffi::PangoCoverageLevel) -> Self { match value { ffi::PANGO_COVERAGE_NONE => Self::None, ffi::PANGO_COVERAGE_FALLBACK => Self::Fallback, ffi::PANGO_COVERAGE_APPROXIMATE => Self::Approximate, ffi::PANGO_COVERAGE_EXACT => Self::Exact, value => Self::__Unknown(value), } } } impl StaticType for CoverageLevel { fn static_type() -> Type { unsafe { from_glib(ffi::pango_coverage_level_get_type()) } } } impl glib::value::ValueType for CoverageLevel { type Type = Self; } unsafe impl<'a> FromValue<'a> for CoverageLevel { type Checker = glib::value::GenericValueTypeChecker; unsafe fn from_value(value: &'a glib::Value) -> Self { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) } } impl ToValue for CoverageLevel { 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 } fn value_type(&self) -> glib::Type { Self::static_type() } } #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] #[non_exhaustive] #[doc(alias = "PangoDirection")] pub enum Direction { #[doc(alias = "PANGO_DIRECTION_LTR")] Ltr, #[doc(alias = "PANGO_DIRECTION_RTL")] Rtl, #[doc(alias = "PANGO_DIRECTION_TTB_LTR")] TtbLtr, #[doc(alias = "PANGO_DIRECTION_TTB_RTL")] TtbRtl, #[doc(alias = "PANGO_DIRECTION_WEAK_LTR")] WeakLtr, #[doc(alias = "PANGO_DIRECTION_WEAK_RTL")] WeakRtl, #[doc(alias = "PANGO_DIRECTION_NEUTRAL")] Neutral, #[doc(hidden)] __Unknown(i32), } impl fmt::Display for Direction { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, "Direction::{}", match *self { Self::Ltr => "Ltr", Self::Rtl => "Rtl", Self::TtbLtr => "TtbLtr", Self::TtbRtl => "TtbRtl", Self::WeakLtr => "WeakLtr", Self::WeakRtl => "WeakRtl", Self::Neutral => "Neutral", _ => "Unknown", } ) } } #[doc(hidden)] impl IntoGlib for Direction { type GlibType = ffi::PangoDirection; fn into_glib(self) -> ffi::PangoDirection { match self { Self::Ltr => ffi::PANGO_DIRECTION_LTR, Self::Rtl => ffi::PANGO_DIRECTION_RTL, Self::TtbLtr => ffi::PANGO_DIRECTION_TTB_LTR, Self::TtbRtl => ffi::PANGO_DIRECTION_TTB_RTL, Self::WeakLtr => ffi::PANGO_DIRECTION_WEAK_LTR, Self::WeakRtl => ffi::PANGO_DIRECTION_WEAK_RTL, Self::Neutral => ffi::PANGO_DIRECTION_NEUTRAL, Self::__Unknown(value) => value, } } } #[doc(hidden)] impl FromGlib for Direction { unsafe fn from_glib(value: ffi::PangoDirection) -> Self { match value { ffi::PANGO_DIRECTION_LTR => Self::Ltr, ffi::PANGO_DIRECTION_RTL => Self::Rtl, ffi::PANGO_DIRECTION_TTB_LTR => Self::TtbLtr, ffi::PANGO_DIRECTION_TTB_RTL => Self::TtbRtl, ffi::PANGO_DIRECTION_WEAK_LTR => Self::WeakLtr, ffi::PANGO_DIRECTION_WEAK_RTL => Self::WeakRtl, ffi::PANGO_DIRECTION_NEUTRAL => Self::Neutral, value => Self::__Unknown(value), } } } impl StaticType for Direction { fn static_type() -> Type { unsafe { from_glib(ffi::pango_direction_get_type()) } } } impl glib::value::ValueType for Direction { type Type = Self; } unsafe impl<'a> FromValue<'a> for Direction { type Checker = glib::value::GenericValueTypeChecker; unsafe fn from_value(value: &'a glib::Value) -> Self { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) } } impl ToValue for Direction { 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 } fn value_type(&self) -> glib::Type { Self::static_type() } } #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] #[non_exhaustive] #[doc(alias = "PangoEllipsizeMode")] pub enum EllipsizeMode { #[doc(alias = "PANGO_ELLIPSIZE_NONE")] None, #[doc(alias = "PANGO_ELLIPSIZE_START")] Start, #[doc(alias = "PANGO_ELLIPSIZE_MIDDLE")] Middle, #[doc(alias = "PANGO_ELLIPSIZE_END")] End, #[doc(hidden)] __Unknown(i32), } impl fmt::Display for EllipsizeMode { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, "EllipsizeMode::{}", match *self { Self::None => "None", Self::Start => "Start", Self::Middle => "Middle", Self::End => "End", _ => "Unknown", } ) } } #[doc(hidden)] impl IntoGlib for EllipsizeMode { type GlibType = ffi::PangoEllipsizeMode; fn into_glib(self) -> ffi::PangoEllipsizeMode { match self { Self::None => ffi::PANGO_ELLIPSIZE_NONE, Self::Start => ffi::PANGO_ELLIPSIZE_START, Self::Middle => ffi::PANGO_ELLIPSIZE_MIDDLE, Self::End => ffi::PANGO_ELLIPSIZE_END, Self::__Unknown(value) => value, } } } #[doc(hidden)] impl FromGlib for EllipsizeMode { unsafe fn from_glib(value: ffi::PangoEllipsizeMode) -> Self { match value { ffi::PANGO_ELLIPSIZE_NONE => Self::None, ffi::PANGO_ELLIPSIZE_START => Self::Start, ffi::PANGO_ELLIPSIZE_MIDDLE => Self::Middle, ffi::PANGO_ELLIPSIZE_END => Self::End, value => Self::__Unknown(value), } } } impl StaticType for EllipsizeMode { fn static_type() -> Type { unsafe { from_glib(ffi::pango_ellipsize_mode_get_type()) } } } impl glib::value::ValueType for EllipsizeMode { type Type = Self; } unsafe impl<'a> FromValue<'a> for EllipsizeMode { type Checker = glib::value::GenericValueTypeChecker; unsafe fn from_value(value: &'a glib::Value) -> Self { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) } } impl ToValue for EllipsizeMode { 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 } fn value_type(&self) -> glib::Type { Self::static_type() } } #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] #[non_exhaustive] #[doc(alias = "PangoGravity")] pub enum Gravity { #[doc(alias = "PANGO_GRAVITY_SOUTH")] South, #[doc(alias = "PANGO_GRAVITY_EAST")] East, #[doc(alias = "PANGO_GRAVITY_NORTH")] North, #[doc(alias = "PANGO_GRAVITY_WEST")] West, #[doc(alias = "PANGO_GRAVITY_AUTO")] Auto, #[doc(hidden)] __Unknown(i32), } impl Gravity { #[doc(alias = "pango_gravity_get_for_matrix")] #[doc(alias = "get_for_matrix")] pub fn for_matrix(matrix: Option<&Matrix>) -> Gravity { unsafe { from_glib(ffi::pango_gravity_get_for_matrix(matrix.to_glib_none().0)) } } #[doc(alias = "pango_gravity_get_for_script")] #[doc(alias = "get_for_script")] pub fn for_script(script: Script, base_gravity: Gravity, hint: GravityHint) -> Gravity { unsafe { from_glib(ffi::pango_gravity_get_for_script( script.into_glib(), base_gravity.into_glib(), hint.into_glib(), )) } } #[doc(alias = "pango_gravity_get_for_script_and_width")] #[doc(alias = "get_for_script_and_width")] pub fn for_script_and_width( script: Script, wide: bool, base_gravity: Gravity, hint: GravityHint, ) -> Gravity { unsafe { from_glib(ffi::pango_gravity_get_for_script_and_width( script.into_glib(), wide.into_glib(), base_gravity.into_glib(), hint.into_glib(), )) } } #[doc(alias = "pango_gravity_to_rotation")] pub fn to_rotation(self) -> f64 { unsafe { ffi::pango_gravity_to_rotation(self.into_glib()) } } } impl fmt::Display for Gravity { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, "Gravity::{}", match *self { Self::South => "South", Self::East => "East", Self::North => "North", Self::West => "West", Self::Auto => "Auto", _ => "Unknown", } ) } } #[doc(hidden)] impl IntoGlib for Gravity { type GlibType = ffi::PangoGravity; fn into_glib(self) -> ffi::PangoGravity { match self { Self::South => ffi::PANGO_GRAVITY_SOUTH, Self::East => ffi::PANGO_GRAVITY_EAST, Self::North => ffi::PANGO_GRAVITY_NORTH, Self::West => ffi::PANGO_GRAVITY_WEST, Self::Auto => ffi::PANGO_GRAVITY_AUTO, Self::__Unknown(value) => value, } } } #[doc(hidden)] impl FromGlib for Gravity { unsafe fn from_glib(value: ffi::PangoGravity) -> Self { match value { ffi::PANGO_GRAVITY_SOUTH => Self::South, ffi::PANGO_GRAVITY_EAST => Self::East, ffi::PANGO_GRAVITY_NORTH => Self::North, ffi::PANGO_GRAVITY_WEST => Self::West, ffi::PANGO_GRAVITY_AUTO => Self::Auto, value => Self::__Unknown(value), } } } impl StaticType for Gravity { fn static_type() -> Type { unsafe { from_glib(ffi::pango_gravity_get_type()) } } } impl glib::value::ValueType for Gravity { type Type = Self; } unsafe impl<'a> FromValue<'a> for Gravity { type Checker = glib::value::GenericValueTypeChecker; unsafe fn from_value(value: &'a glib::Value) -> Self { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) } } impl ToValue for Gravity { 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 } fn value_type(&self) -> glib::Type { Self::static_type() } } #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] #[non_exhaustive] #[doc(alias = "PangoGravityHint")] pub enum GravityHint { #[doc(alias = "PANGO_GRAVITY_HINT_NATURAL")] Natural, #[doc(alias = "PANGO_GRAVITY_HINT_STRONG")] Strong, #[doc(alias = "PANGO_GRAVITY_HINT_LINE")] Line, #[doc(hidden)] __Unknown(i32), } impl fmt::Display for GravityHint { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, "GravityHint::{}", match *self { Self::Natural => "Natural", Self::Strong => "Strong", Self::Line => "Line", _ => "Unknown", } ) } } #[doc(hidden)] impl IntoGlib for GravityHint { type GlibType = ffi::PangoGravityHint; fn into_glib(self) -> ffi::PangoGravityHint { match self { Self::Natural => ffi::PANGO_GRAVITY_HINT_NATURAL, Self::Strong => ffi::PANGO_GRAVITY_HINT_STRONG, Self::Line => ffi::PANGO_GRAVITY_HINT_LINE, Self::__Unknown(value) => value, } } } #[doc(hidden)] impl FromGlib for GravityHint { unsafe fn from_glib(value: ffi::PangoGravityHint) -> Self { match value { ffi::PANGO_GRAVITY_HINT_NATURAL => Self::Natural, ffi::PANGO_GRAVITY_HINT_STRONG => Self::Strong, ffi::PANGO_GRAVITY_HINT_LINE => Self::Line, value => Self::__Unknown(value), } } } impl StaticType for GravityHint { fn static_type() -> Type { unsafe { from_glib(ffi::pango_gravity_hint_get_type()) } } } impl glib::value::ValueType for GravityHint { type Type = Self; } unsafe impl<'a> FromValue<'a> for GravityHint { type Checker = glib::value::GenericValueTypeChecker; unsafe fn from_value(value: &'a glib::Value) -> Self { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) } } impl ToValue for GravityHint { 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 } fn value_type(&self) -> glib::Type { Self::static_type() } } #[cfg(any(feature = "v1_46", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_46")))] #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] #[non_exhaustive] #[doc(alias = "PangoOverline")] pub enum Overline { #[doc(alias = "PANGO_OVERLINE_NONE")] None, #[doc(alias = "PANGO_OVERLINE_SINGLE")] Single, #[doc(hidden)] __Unknown(i32), } #[cfg(any(feature = "v1_46", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_46")))] impl fmt::Display for Overline { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, "Overline::{}", match *self { Self::None => "None", Self::Single => "Single", _ => "Unknown", } ) } } #[cfg(any(feature = "v1_46", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_46")))] #[doc(hidden)] impl IntoGlib for Overline { type GlibType = ffi::PangoOverline; fn into_glib(self) -> ffi::PangoOverline { match self { Self::None => ffi::PANGO_OVERLINE_NONE, Self::Single => ffi::PANGO_OVERLINE_SINGLE, Self::__Unknown(value) => value, } } } #[cfg(any(feature = "v1_46", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_46")))] #[doc(hidden)] impl FromGlib for Overline { unsafe fn from_glib(value: ffi::PangoOverline) -> Self { match value { ffi::PANGO_OVERLINE_NONE => Self::None, ffi::PANGO_OVERLINE_SINGLE => Self::Single, value => Self::__Unknown(value), } } } #[cfg(any(feature = "v1_46", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_46")))] impl StaticType for Overline { fn static_type() -> Type { unsafe { from_glib(ffi::pango_overline_get_type()) } } } #[cfg(any(feature = "v1_46", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_46")))] impl glib::value::ValueType for Overline { type Type = Self; } #[cfg(any(feature = "v1_46", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_46")))] unsafe impl<'a> FromValue<'a> for Overline { type Checker = glib::value::GenericValueTypeChecker; unsafe fn from_value(value: &'a glib::Value) -> Self { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) } } #[cfg(any(feature = "v1_46", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_46")))] impl ToValue for Overline { 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 } fn value_type(&self) -> glib::Type { Self::static_type() } } #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] #[non_exhaustive] #[doc(alias = "PangoRenderPart")] pub enum RenderPart { #[doc(alias = "PANGO_RENDER_PART_FOREGROUND")] Foreground, #[doc(alias = "PANGO_RENDER_PART_BACKGROUND")] Background, #[doc(alias = "PANGO_RENDER_PART_UNDERLINE")] Underline, #[doc(alias = "PANGO_RENDER_PART_STRIKETHROUGH")] Strikethrough, #[doc(alias = "PANGO_RENDER_PART_OVERLINE")] Overline, #[doc(hidden)] __Unknown(i32), } impl fmt::Display for RenderPart { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, "RenderPart::{}", match *self { Self::Foreground => "Foreground", Self::Background => "Background", Self::Underline => "Underline", Self::Strikethrough => "Strikethrough", Self::Overline => "Overline", _ => "Unknown", } ) } } #[doc(hidden)] impl IntoGlib for RenderPart { type GlibType = ffi::PangoRenderPart; fn into_glib(self) -> ffi::PangoRenderPart { match self { Self::Foreground => ffi::PANGO_RENDER_PART_FOREGROUND, Self::Background => ffi::PANGO_RENDER_PART_BACKGROUND, Self::Underline => ffi::PANGO_RENDER_PART_UNDERLINE, Self::Strikethrough => ffi::PANGO_RENDER_PART_STRIKETHROUGH, Self::Overline => ffi::PANGO_RENDER_PART_OVERLINE, Self::__Unknown(value) => value, } } } #[doc(hidden)] impl FromGlib for RenderPart { unsafe fn from_glib(value: ffi::PangoRenderPart) -> Self { match value { ffi::PANGO_RENDER_PART_FOREGROUND => Self::Foreground, ffi::PANGO_RENDER_PART_BACKGROUND => Self::Background, ffi::PANGO_RENDER_PART_UNDERLINE => Self::Underline, ffi::PANGO_RENDER_PART_STRIKETHROUGH => Self::Strikethrough, ffi::PANGO_RENDER_PART_OVERLINE => Self::Overline, value => Self::__Unknown(value), } } } impl StaticType for RenderPart { fn static_type() -> Type { unsafe { from_glib(ffi::pango_render_part_get_type()) } } } impl glib::value::ValueType for RenderPart { type Type = Self; } unsafe impl<'a> FromValue<'a> for RenderPart { type Checker = glib::value::GenericValueTypeChecker; unsafe fn from_value(value: &'a glib::Value) -> Self { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) } } impl ToValue for RenderPart { 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 } fn value_type(&self) -> glib::Type { Self::static_type() } } #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] #[non_exhaustive] #[doc(alias = "PangoScript")] pub enum Script { #[doc(alias = "PANGO_SCRIPT_INVALID_CODE")] InvalidCode, #[doc(alias = "PANGO_SCRIPT_COMMON")] Common, #[doc(alias = "PANGO_SCRIPT_INHERITED")] Inherited, #[doc(alias = "PANGO_SCRIPT_ARABIC")] Arabic, #[doc(alias = "PANGO_SCRIPT_ARMENIAN")] Armenian, #[doc(alias = "PANGO_SCRIPT_BENGALI")] Bengali, #[doc(alias = "PANGO_SCRIPT_BOPOMOFO")] Bopomofo, #[doc(alias = "PANGO_SCRIPT_CHEROKEE")] Cherokee, #[doc(alias = "PANGO_SCRIPT_COPTIC")] Coptic, #[doc(alias = "PANGO_SCRIPT_CYRILLIC")] Cyrillic, #[doc(alias = "PANGO_SCRIPT_DESERET")] Deseret, #[doc(alias = "PANGO_SCRIPT_DEVANAGARI")] Devanagari, #[doc(alias = "PANGO_SCRIPT_ETHIOPIC")] Ethiopic, #[doc(alias = "PANGO_SCRIPT_GEORGIAN")] Georgian, #[doc(alias = "PANGO_SCRIPT_GOTHIC")] Gothic, #[doc(alias = "PANGO_SCRIPT_GREEK")] Greek, #[doc(alias = "PANGO_SCRIPT_GUJARATI")] Gujarati, #[doc(alias = "PANGO_SCRIPT_GURMUKHI")] Gurmukhi, #[doc(alias = "PANGO_SCRIPT_HAN")] Han, #[doc(alias = "PANGO_SCRIPT_HANGUL")] Hangul, #[doc(alias = "PANGO_SCRIPT_HEBREW")] Hebrew, #[doc(alias = "PANGO_SCRIPT_HIRAGANA")] Hiragana, #[doc(alias = "PANGO_SCRIPT_KANNADA")] Kannada, #[doc(alias = "PANGO_SCRIPT_KATAKANA")] Katakana, #[doc(alias = "PANGO_SCRIPT_KHMER")] Khmer, #[doc(alias = "PANGO_SCRIPT_LAO")] Lao, #[doc(alias = "PANGO_SCRIPT_LATIN")] Latin, #[doc(alias = "PANGO_SCRIPT_MALAYALAM")] Malayalam, #[doc(alias = "PANGO_SCRIPT_MONGOLIAN")] Mongolian, #[doc(alias = "PANGO_SCRIPT_MYANMAR")] Myanmar, #[doc(alias = "PANGO_SCRIPT_OGHAM")] Ogham, #[doc(alias = "PANGO_SCRIPT_OLD_ITALIC")] OldItalic, #[doc(alias = "PANGO_SCRIPT_ORIYA")] Oriya, #[doc(alias = "PANGO_SCRIPT_RUNIC")] Runic, #[doc(alias = "PANGO_SCRIPT_SINHALA")] Sinhala, #[doc(alias = "PANGO_SCRIPT_SYRIAC")] Syriac, #[doc(alias = "PANGO_SCRIPT_TAMIL")] Tamil, #[doc(alias = "PANGO_SCRIPT_TELUGU")] Telugu, #[doc(alias = "PANGO_SCRIPT_THAANA")] Thaana, #[doc(alias = "PANGO_SCRIPT_THAI")] Thai, #[doc(alias = "PANGO_SCRIPT_TIBETAN")] Tibetan, #[doc(alias = "PANGO_SCRIPT_CANADIAN_ABORIGINAL")] CanadianAboriginal, #[doc(alias = "PANGO_SCRIPT_YI")] Yi, #[doc(alias = "PANGO_SCRIPT_TAGALOG")] Tagalog, #[doc(alias = "PANGO_SCRIPT_HANUNOO")] Hanunoo, #[doc(alias = "PANGO_SCRIPT_BUHID")] Buhid, #[doc(alias = "PANGO_SCRIPT_TAGBANWA")] Tagbanwa, #[doc(alias = "PANGO_SCRIPT_BRAILLE")] Braille, #[doc(alias = "PANGO_SCRIPT_CYPRIOT")] Cypriot, #[doc(alias = "PANGO_SCRIPT_LIMBU")] Limbu, #[doc(alias = "PANGO_SCRIPT_OSMANYA")] Osmanya, #[doc(alias = "PANGO_SCRIPT_SHAVIAN")] Shavian, #[doc(alias = "PANGO_SCRIPT_LINEAR_B")] LinearB, #[doc(alias = "PANGO_SCRIPT_TAI_LE")] TaiLe, #[doc(alias = "PANGO_SCRIPT_UGARITIC")] Ugaritic, #[doc(alias = "PANGO_SCRIPT_NEW_TAI_LUE")] NewTaiLue, #[doc(alias = "PANGO_SCRIPT_BUGINESE")] Buginese, #[doc(alias = "PANGO_SCRIPT_GLAGOLITIC")] Glagolitic, #[doc(alias = "PANGO_SCRIPT_TIFINAGH")] Tifinagh, #[doc(alias = "PANGO_SCRIPT_SYLOTI_NAGRI")] SylotiNagri, #[doc(alias = "PANGO_SCRIPT_OLD_PERSIAN")] OldPersian, #[doc(alias = "PANGO_SCRIPT_KHAROSHTHI")] Kharoshthi, #[doc(alias = "PANGO_SCRIPT_UNKNOWN")] Unknown, #[doc(alias = "PANGO_SCRIPT_BALINESE")] Balinese, #[doc(alias = "PANGO_SCRIPT_CUNEIFORM")] Cuneiform, #[doc(alias = "PANGO_SCRIPT_PHOENICIAN")] Phoenician, #[doc(alias = "PANGO_SCRIPT_PHAGS_PA")] PhagsPa, #[doc(alias = "PANGO_SCRIPT_NKO")] Nko, #[doc(alias = "PANGO_SCRIPT_KAYAH_LI")] KayahLi, #[doc(alias = "PANGO_SCRIPT_LEPCHA")] Lepcha, #[doc(alias = "PANGO_SCRIPT_REJANG")] Rejang, #[doc(alias = "PANGO_SCRIPT_SUNDANESE")] Sundanese, #[doc(alias = "PANGO_SCRIPT_SAURASHTRA")] Saurashtra, #[doc(alias = "PANGO_SCRIPT_CHAM")] Cham, #[doc(alias = "PANGO_SCRIPT_OL_CHIKI")] OlChiki, #[doc(alias = "PANGO_SCRIPT_VAI")] Vai, #[doc(alias = "PANGO_SCRIPT_CARIAN")] Carian, #[doc(alias = "PANGO_SCRIPT_LYCIAN")] Lycian, #[doc(alias = "PANGO_SCRIPT_LYDIAN")] Lydian, #[doc(alias = "PANGO_SCRIPT_BATAK")] Batak, #[doc(alias = "PANGO_SCRIPT_BRAHMI")] Brahmi, #[doc(alias = "PANGO_SCRIPT_MANDAIC")] Mandaic, #[doc(alias = "PANGO_SCRIPT_CHAKMA")] Chakma, #[doc(alias = "PANGO_SCRIPT_MEROITIC_CURSIVE")] MeroiticCursive, #[doc(alias = "PANGO_SCRIPT_MEROITIC_HIEROGLYPHS")] MeroiticHieroglyphs, #[doc(alias = "PANGO_SCRIPT_MIAO")] Miao, #[doc(alias = "PANGO_SCRIPT_SHARADA")] Sharada, #[doc(alias = "PANGO_SCRIPT_SORA_SOMPENG")] SoraSompeng, #[doc(alias = "PANGO_SCRIPT_TAKRI")] Takri, #[doc(alias = "PANGO_SCRIPT_BASSA_VAH")] BassaVah, #[doc(alias = "PANGO_SCRIPT_CAUCASIAN_ALBANIAN")] CaucasianAlbanian, #[doc(alias = "PANGO_SCRIPT_DUPLOYAN")] Duployan, #[doc(alias = "PANGO_SCRIPT_ELBASAN")] Elbasan, #[doc(alias = "PANGO_SCRIPT_GRANTHA")] Grantha, #[doc(alias = "PANGO_SCRIPT_KHOJKI")] Khojki, #[doc(alias = "PANGO_SCRIPT_KHUDAWADI")] Khudawadi, #[doc(alias = "PANGO_SCRIPT_LINEAR_A")] LinearA, #[doc(alias = "PANGO_SCRIPT_MAHAJANI")] Mahajani, #[doc(alias = "PANGO_SCRIPT_MANICHAEAN")] Manichaean, #[doc(alias = "PANGO_SCRIPT_MENDE_KIKAKUI")] MendeKikakui, #[doc(alias = "PANGO_SCRIPT_MODI")] Modi, #[doc(alias = "PANGO_SCRIPT_MRO")] Mro, #[doc(alias = "PANGO_SCRIPT_NABATAEAN")] Nabataean, #[doc(alias = "PANGO_SCRIPT_OLD_NORTH_ARABIAN")] OldNorthArabian, #[doc(alias = "PANGO_SCRIPT_OLD_PERMIC")] OldPermic, #[doc(alias = "PANGO_SCRIPT_PAHAWH_HMONG")] PahawhHmong, #[doc(alias = "PANGO_SCRIPT_PALMYRENE")] Palmyrene, #[doc(alias = "PANGO_SCRIPT_PAU_CIN_HAU")] PauCinHau, #[doc(alias = "PANGO_SCRIPT_PSALTER_PAHLAVI")] PsalterPahlavi, #[doc(alias = "PANGO_SCRIPT_SIDDHAM")] Siddham, #[doc(alias = "PANGO_SCRIPT_TIRHUTA")] Tirhuta, #[doc(alias = "PANGO_SCRIPT_WARANG_CITI")] WarangCiti, #[doc(alias = "PANGO_SCRIPT_AHOM")] Ahom, #[doc(alias = "PANGO_SCRIPT_ANATOLIAN_HIEROGLYPHS")] AnatolianHieroglyphs, #[doc(alias = "PANGO_SCRIPT_HATRAN")] Hatran, #[doc(alias = "PANGO_SCRIPT_MULTANI")] Multani, #[doc(alias = "PANGO_SCRIPT_OLD_HUNGARIAN")] OldHungarian, #[doc(alias = "PANGO_SCRIPT_SIGNWRITING")] Signwriting, #[doc(hidden)] __Unknown(i32), } impl Script { #[cfg_attr(feature = "v1_44", deprecated = "Since 1.44")] #[doc(alias = "pango_script_for_unichar")] pub fn for_unichar(ch: char) -> Script { unsafe { from_glib(ffi::pango_script_for_unichar(ch.into_glib())) } } #[doc(alias = "pango_script_get_sample_language")] #[doc(alias = "get_sample_language")] pub fn sample_language(self) -> Option { unsafe { from_glib_full(ffi::pango_script_get_sample_language(self.into_glib())) } } } impl fmt::Display for Script { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, "Script::{}", match *self { Self::InvalidCode => "InvalidCode", Self::Common => "Common", Self::Inherited => "Inherited", Self::Arabic => "Arabic", Self::Armenian => "Armenian", Self::Bengali => "Bengali", Self::Bopomofo => "Bopomofo", Self::Cherokee => "Cherokee", Self::Coptic => "Coptic", Self::Cyrillic => "Cyrillic", Self::Deseret => "Deseret", Self::Devanagari => "Devanagari", Self::Ethiopic => "Ethiopic", Self::Georgian => "Georgian", Self::Gothic => "Gothic", Self::Greek => "Greek", Self::Gujarati => "Gujarati", Self::Gurmukhi => "Gurmukhi", Self::Han => "Han", Self::Hangul => "Hangul", Self::Hebrew => "Hebrew", Self::Hiragana => "Hiragana", Self::Kannada => "Kannada", Self::Katakana => "Katakana", Self::Khmer => "Khmer", Self::Lao => "Lao", Self::Latin => "Latin", Self::Malayalam => "Malayalam", Self::Mongolian => "Mongolian", Self::Myanmar => "Myanmar", Self::Ogham => "Ogham", Self::OldItalic => "OldItalic", Self::Oriya => "Oriya", Self::Runic => "Runic", Self::Sinhala => "Sinhala", Self::Syriac => "Syriac", Self::Tamil => "Tamil", Self::Telugu => "Telugu", Self::Thaana => "Thaana", Self::Thai => "Thai", Self::Tibetan => "Tibetan", Self::CanadianAboriginal => "CanadianAboriginal", Self::Yi => "Yi", Self::Tagalog => "Tagalog", Self::Hanunoo => "Hanunoo", Self::Buhid => "Buhid", Self::Tagbanwa => "Tagbanwa", Self::Braille => "Braille", Self::Cypriot => "Cypriot", Self::Limbu => "Limbu", Self::Osmanya => "Osmanya", Self::Shavian => "Shavian", Self::LinearB => "LinearB", Self::TaiLe => "TaiLe", Self::Ugaritic => "Ugaritic", Self::NewTaiLue => "NewTaiLue", Self::Buginese => "Buginese", Self::Glagolitic => "Glagolitic", Self::Tifinagh => "Tifinagh", Self::SylotiNagri => "SylotiNagri", Self::OldPersian => "OldPersian", Self::Kharoshthi => "Kharoshthi", Self::Unknown => "Unknown", Self::Balinese => "Balinese", Self::Cuneiform => "Cuneiform", Self::Phoenician => "Phoenician", Self::PhagsPa => "PhagsPa", Self::Nko => "Nko", Self::KayahLi => "KayahLi", Self::Lepcha => "Lepcha", Self::Rejang => "Rejang", Self::Sundanese => "Sundanese", Self::Saurashtra => "Saurashtra", Self::Cham => "Cham", Self::OlChiki => "OlChiki", Self::Vai => "Vai", Self::Carian => "Carian", Self::Lycian => "Lycian", Self::Lydian => "Lydian", Self::Batak => "Batak", Self::Brahmi => "Brahmi", Self::Mandaic => "Mandaic", Self::Chakma => "Chakma", Self::MeroiticCursive => "MeroiticCursive", Self::MeroiticHieroglyphs => "MeroiticHieroglyphs", Self::Miao => "Miao", Self::Sharada => "Sharada", Self::SoraSompeng => "SoraSompeng", Self::Takri => "Takri", Self::BassaVah => "BassaVah", Self::CaucasianAlbanian => "CaucasianAlbanian", Self::Duployan => "Duployan", Self::Elbasan => "Elbasan", Self::Grantha => "Grantha", Self::Khojki => "Khojki", Self::Khudawadi => "Khudawadi", Self::LinearA => "LinearA", Self::Mahajani => "Mahajani", Self::Manichaean => "Manichaean", Self::MendeKikakui => "MendeKikakui", Self::Modi => "Modi", Self::Mro => "Mro", Self::Nabataean => "Nabataean", Self::OldNorthArabian => "OldNorthArabian", Self::OldPermic => "OldPermic", Self::PahawhHmong => "PahawhHmong", Self::Palmyrene => "Palmyrene", Self::PauCinHau => "PauCinHau", Self::PsalterPahlavi => "PsalterPahlavi", Self::Siddham => "Siddham", Self::Tirhuta => "Tirhuta", Self::WarangCiti => "WarangCiti", Self::Ahom => "Ahom", Self::AnatolianHieroglyphs => "AnatolianHieroglyphs", Self::Hatran => "Hatran", Self::Multani => "Multani", Self::OldHungarian => "OldHungarian", Self::Signwriting => "Signwriting", _ => "Unknown", } ) } } #[doc(hidden)] impl IntoGlib for Script { type GlibType = ffi::PangoScript; fn into_glib(self) -> ffi::PangoScript { match self { Self::InvalidCode => ffi::PANGO_SCRIPT_INVALID_CODE, Self::Common => ffi::PANGO_SCRIPT_COMMON, Self::Inherited => ffi::PANGO_SCRIPT_INHERITED, Self::Arabic => ffi::PANGO_SCRIPT_ARABIC, Self::Armenian => ffi::PANGO_SCRIPT_ARMENIAN, Self::Bengali => ffi::PANGO_SCRIPT_BENGALI, Self::Bopomofo => ffi::PANGO_SCRIPT_BOPOMOFO, Self::Cherokee => ffi::PANGO_SCRIPT_CHEROKEE, Self::Coptic => ffi::PANGO_SCRIPT_COPTIC, Self::Cyrillic => ffi::PANGO_SCRIPT_CYRILLIC, Self::Deseret => ffi::PANGO_SCRIPT_DESERET, Self::Devanagari => ffi::PANGO_SCRIPT_DEVANAGARI, Self::Ethiopic => ffi::PANGO_SCRIPT_ETHIOPIC, Self::Georgian => ffi::PANGO_SCRIPT_GEORGIAN, Self::Gothic => ffi::PANGO_SCRIPT_GOTHIC, Self::Greek => ffi::PANGO_SCRIPT_GREEK, Self::Gujarati => ffi::PANGO_SCRIPT_GUJARATI, Self::Gurmukhi => ffi::PANGO_SCRIPT_GURMUKHI, Self::Han => ffi::PANGO_SCRIPT_HAN, Self::Hangul => ffi::PANGO_SCRIPT_HANGUL, Self::Hebrew => ffi::PANGO_SCRIPT_HEBREW, Self::Hiragana => ffi::PANGO_SCRIPT_HIRAGANA, Self::Kannada => ffi::PANGO_SCRIPT_KANNADA, Self::Katakana => ffi::PANGO_SCRIPT_KATAKANA, Self::Khmer => ffi::PANGO_SCRIPT_KHMER, Self::Lao => ffi::PANGO_SCRIPT_LAO, Self::Latin => ffi::PANGO_SCRIPT_LATIN, Self::Malayalam => ffi::PANGO_SCRIPT_MALAYALAM, Self::Mongolian => ffi::PANGO_SCRIPT_MONGOLIAN, Self::Myanmar => ffi::PANGO_SCRIPT_MYANMAR, Self::Ogham => ffi::PANGO_SCRIPT_OGHAM, Self::OldItalic => ffi::PANGO_SCRIPT_OLD_ITALIC, Self::Oriya => ffi::PANGO_SCRIPT_ORIYA, Self::Runic => ffi::PANGO_SCRIPT_RUNIC, Self::Sinhala => ffi::PANGO_SCRIPT_SINHALA, Self::Syriac => ffi::PANGO_SCRIPT_SYRIAC, Self::Tamil => ffi::PANGO_SCRIPT_TAMIL, Self::Telugu => ffi::PANGO_SCRIPT_TELUGU, Self::Thaana => ffi::PANGO_SCRIPT_THAANA, Self::Thai => ffi::PANGO_SCRIPT_THAI, Self::Tibetan => ffi::PANGO_SCRIPT_TIBETAN, Self::CanadianAboriginal => ffi::PANGO_SCRIPT_CANADIAN_ABORIGINAL, Self::Yi => ffi::PANGO_SCRIPT_YI, Self::Tagalog => ffi::PANGO_SCRIPT_TAGALOG, Self::Hanunoo => ffi::PANGO_SCRIPT_HANUNOO, Self::Buhid => ffi::PANGO_SCRIPT_BUHID, Self::Tagbanwa => ffi::PANGO_SCRIPT_TAGBANWA, Self::Braille => ffi::PANGO_SCRIPT_BRAILLE, Self::Cypriot => ffi::PANGO_SCRIPT_CYPRIOT, Self::Limbu => ffi::PANGO_SCRIPT_LIMBU, Self::Osmanya => ffi::PANGO_SCRIPT_OSMANYA, Self::Shavian => ffi::PANGO_SCRIPT_SHAVIAN, Self::LinearB => ffi::PANGO_SCRIPT_LINEAR_B, Self::TaiLe => ffi::PANGO_SCRIPT_TAI_LE, Self::Ugaritic => ffi::PANGO_SCRIPT_UGARITIC, Self::NewTaiLue => ffi::PANGO_SCRIPT_NEW_TAI_LUE, Self::Buginese => ffi::PANGO_SCRIPT_BUGINESE, Self::Glagolitic => ffi::PANGO_SCRIPT_GLAGOLITIC, Self::Tifinagh => ffi::PANGO_SCRIPT_TIFINAGH, Self::SylotiNagri => ffi::PANGO_SCRIPT_SYLOTI_NAGRI, Self::OldPersian => ffi::PANGO_SCRIPT_OLD_PERSIAN, Self::Kharoshthi => ffi::PANGO_SCRIPT_KHAROSHTHI, Self::Unknown => ffi::PANGO_SCRIPT_UNKNOWN, Self::Balinese => ffi::PANGO_SCRIPT_BALINESE, Self::Cuneiform => ffi::PANGO_SCRIPT_CUNEIFORM, Self::Phoenician => ffi::PANGO_SCRIPT_PHOENICIAN, Self::PhagsPa => ffi::PANGO_SCRIPT_PHAGS_PA, Self::Nko => ffi::PANGO_SCRIPT_NKO, Self::KayahLi => ffi::PANGO_SCRIPT_KAYAH_LI, Self::Lepcha => ffi::PANGO_SCRIPT_LEPCHA, Self::Rejang => ffi::PANGO_SCRIPT_REJANG, Self::Sundanese => ffi::PANGO_SCRIPT_SUNDANESE, Self::Saurashtra => ffi::PANGO_SCRIPT_SAURASHTRA, Self::Cham => ffi::PANGO_SCRIPT_CHAM, Self::OlChiki => ffi::PANGO_SCRIPT_OL_CHIKI, Self::Vai => ffi::PANGO_SCRIPT_VAI, Self::Carian => ffi::PANGO_SCRIPT_CARIAN, Self::Lycian => ffi::PANGO_SCRIPT_LYCIAN, Self::Lydian => ffi::PANGO_SCRIPT_LYDIAN, Self::Batak => ffi::PANGO_SCRIPT_BATAK, Self::Brahmi => ffi::PANGO_SCRIPT_BRAHMI, Self::Mandaic => ffi::PANGO_SCRIPT_MANDAIC, Self::Chakma => ffi::PANGO_SCRIPT_CHAKMA, Self::MeroiticCursive => ffi::PANGO_SCRIPT_MEROITIC_CURSIVE, Self::MeroiticHieroglyphs => ffi::PANGO_SCRIPT_MEROITIC_HIEROGLYPHS, Self::Miao => ffi::PANGO_SCRIPT_MIAO, Self::Sharada => ffi::PANGO_SCRIPT_SHARADA, Self::SoraSompeng => ffi::PANGO_SCRIPT_SORA_SOMPENG, Self::Takri => ffi::PANGO_SCRIPT_TAKRI, Self::BassaVah => ffi::PANGO_SCRIPT_BASSA_VAH, Self::CaucasianAlbanian => ffi::PANGO_SCRIPT_CAUCASIAN_ALBANIAN, Self::Duployan => ffi::PANGO_SCRIPT_DUPLOYAN, Self::Elbasan => ffi::PANGO_SCRIPT_ELBASAN, Self::Grantha => ffi::PANGO_SCRIPT_GRANTHA, Self::Khojki => ffi::PANGO_SCRIPT_KHOJKI, Self::Khudawadi => ffi::PANGO_SCRIPT_KHUDAWADI, Self::LinearA => ffi::PANGO_SCRIPT_LINEAR_A, Self::Mahajani => ffi::PANGO_SCRIPT_MAHAJANI, Self::Manichaean => ffi::PANGO_SCRIPT_MANICHAEAN, Self::MendeKikakui => ffi::PANGO_SCRIPT_MENDE_KIKAKUI, Self::Modi => ffi::PANGO_SCRIPT_MODI, Self::Mro => ffi::PANGO_SCRIPT_MRO, Self::Nabataean => ffi::PANGO_SCRIPT_NABATAEAN, Self::OldNorthArabian => ffi::PANGO_SCRIPT_OLD_NORTH_ARABIAN, Self::OldPermic => ffi::PANGO_SCRIPT_OLD_PERMIC, Self::PahawhHmong => ffi::PANGO_SCRIPT_PAHAWH_HMONG, Self::Palmyrene => ffi::PANGO_SCRIPT_PALMYRENE, Self::PauCinHau => ffi::PANGO_SCRIPT_PAU_CIN_HAU, Self::PsalterPahlavi => ffi::PANGO_SCRIPT_PSALTER_PAHLAVI, Self::Siddham => ffi::PANGO_SCRIPT_SIDDHAM, Self::Tirhuta => ffi::PANGO_SCRIPT_TIRHUTA, Self::WarangCiti => ffi::PANGO_SCRIPT_WARANG_CITI, Self::Ahom => ffi::PANGO_SCRIPT_AHOM, Self::AnatolianHieroglyphs => ffi::PANGO_SCRIPT_ANATOLIAN_HIEROGLYPHS, Self::Hatran => ffi::PANGO_SCRIPT_HATRAN, Self::Multani => ffi::PANGO_SCRIPT_MULTANI, Self::OldHungarian => ffi::PANGO_SCRIPT_OLD_HUNGARIAN, Self::Signwriting => ffi::PANGO_SCRIPT_SIGNWRITING, Self::__Unknown(value) => value, } } } #[doc(hidden)] impl FromGlib for Script { unsafe fn from_glib(value: ffi::PangoScript) -> Self { match value { ffi::PANGO_SCRIPT_INVALID_CODE => Self::InvalidCode, ffi::PANGO_SCRIPT_COMMON => Self::Common, ffi::PANGO_SCRIPT_INHERITED => Self::Inherited, ffi::PANGO_SCRIPT_ARABIC => Self::Arabic, ffi::PANGO_SCRIPT_ARMENIAN => Self::Armenian, ffi::PANGO_SCRIPT_BENGALI => Self::Bengali, ffi::PANGO_SCRIPT_BOPOMOFO => Self::Bopomofo, ffi::PANGO_SCRIPT_CHEROKEE => Self::Cherokee, ffi::PANGO_SCRIPT_COPTIC => Self::Coptic, ffi::PANGO_SCRIPT_CYRILLIC => Self::Cyrillic, ffi::PANGO_SCRIPT_DESERET => Self::Deseret, ffi::PANGO_SCRIPT_DEVANAGARI => Self::Devanagari, ffi::PANGO_SCRIPT_ETHIOPIC => Self::Ethiopic, ffi::PANGO_SCRIPT_GEORGIAN => Self::Georgian, ffi::PANGO_SCRIPT_GOTHIC => Self::Gothic, ffi::PANGO_SCRIPT_GREEK => Self::Greek, ffi::PANGO_SCRIPT_GUJARATI => Self::Gujarati, ffi::PANGO_SCRIPT_GURMUKHI => Self::Gurmukhi, ffi::PANGO_SCRIPT_HAN => Self::Han, ffi::PANGO_SCRIPT_HANGUL => Self::Hangul, ffi::PANGO_SCRIPT_HEBREW => Self::Hebrew, ffi::PANGO_SCRIPT_HIRAGANA => Self::Hiragana, ffi::PANGO_SCRIPT_KANNADA => Self::Kannada, ffi::PANGO_SCRIPT_KATAKANA => Self::Katakana, ffi::PANGO_SCRIPT_KHMER => Self::Khmer, ffi::PANGO_SCRIPT_LAO => Self::Lao, ffi::PANGO_SCRIPT_LATIN => Self::Latin, ffi::PANGO_SCRIPT_MALAYALAM => Self::Malayalam, ffi::PANGO_SCRIPT_MONGOLIAN => Self::Mongolian, ffi::PANGO_SCRIPT_MYANMAR => Self::Myanmar, ffi::PANGO_SCRIPT_OGHAM => Self::Ogham, ffi::PANGO_SCRIPT_OLD_ITALIC => Self::OldItalic, ffi::PANGO_SCRIPT_ORIYA => Self::Oriya, ffi::PANGO_SCRIPT_RUNIC => Self::Runic, ffi::PANGO_SCRIPT_SINHALA => Self::Sinhala, ffi::PANGO_SCRIPT_SYRIAC => Self::Syriac, ffi::PANGO_SCRIPT_TAMIL => Self::Tamil, ffi::PANGO_SCRIPT_TELUGU => Self::Telugu, ffi::PANGO_SCRIPT_THAANA => Self::Thaana, ffi::PANGO_SCRIPT_THAI => Self::Thai, ffi::PANGO_SCRIPT_TIBETAN => Self::Tibetan, ffi::PANGO_SCRIPT_CANADIAN_ABORIGINAL => Self::CanadianAboriginal, ffi::PANGO_SCRIPT_YI => Self::Yi, ffi::PANGO_SCRIPT_TAGALOG => Self::Tagalog, ffi::PANGO_SCRIPT_HANUNOO => Self::Hanunoo, ffi::PANGO_SCRIPT_BUHID => Self::Buhid, ffi::PANGO_SCRIPT_TAGBANWA => Self::Tagbanwa, ffi::PANGO_SCRIPT_BRAILLE => Self::Braille, ffi::PANGO_SCRIPT_CYPRIOT => Self::Cypriot, ffi::PANGO_SCRIPT_LIMBU => Self::Limbu, ffi::PANGO_SCRIPT_OSMANYA => Self::Osmanya, ffi::PANGO_SCRIPT_SHAVIAN => Self::Shavian, ffi::PANGO_SCRIPT_LINEAR_B => Self::LinearB, ffi::PANGO_SCRIPT_TAI_LE => Self::TaiLe, ffi::PANGO_SCRIPT_UGARITIC => Self::Ugaritic, ffi::PANGO_SCRIPT_NEW_TAI_LUE => Self::NewTaiLue, ffi::PANGO_SCRIPT_BUGINESE => Self::Buginese, ffi::PANGO_SCRIPT_GLAGOLITIC => Self::Glagolitic, ffi::PANGO_SCRIPT_TIFINAGH => Self::Tifinagh, ffi::PANGO_SCRIPT_SYLOTI_NAGRI => Self::SylotiNagri, ffi::PANGO_SCRIPT_OLD_PERSIAN => Self::OldPersian, ffi::PANGO_SCRIPT_KHAROSHTHI => Self::Kharoshthi, ffi::PANGO_SCRIPT_UNKNOWN => Self::Unknown, ffi::PANGO_SCRIPT_BALINESE => Self::Balinese, ffi::PANGO_SCRIPT_CUNEIFORM => Self::Cuneiform, ffi::PANGO_SCRIPT_PHOENICIAN => Self::Phoenician, ffi::PANGO_SCRIPT_PHAGS_PA => Self::PhagsPa, ffi::PANGO_SCRIPT_NKO => Self::Nko, ffi::PANGO_SCRIPT_KAYAH_LI => Self::KayahLi, ffi::PANGO_SCRIPT_LEPCHA => Self::Lepcha, ffi::PANGO_SCRIPT_REJANG => Self::Rejang, ffi::PANGO_SCRIPT_SUNDANESE => Self::Sundanese, ffi::PANGO_SCRIPT_SAURASHTRA => Self::Saurashtra, ffi::PANGO_SCRIPT_CHAM => Self::Cham, ffi::PANGO_SCRIPT_OL_CHIKI => Self::OlChiki, ffi::PANGO_SCRIPT_VAI => Self::Vai, ffi::PANGO_SCRIPT_CARIAN => Self::Carian, ffi::PANGO_SCRIPT_LYCIAN => Self::Lycian, ffi::PANGO_SCRIPT_LYDIAN => Self::Lydian, ffi::PANGO_SCRIPT_BATAK => Self::Batak, ffi::PANGO_SCRIPT_BRAHMI => Self::Brahmi, ffi::PANGO_SCRIPT_MANDAIC => Self::Mandaic, ffi::PANGO_SCRIPT_CHAKMA => Self::Chakma, ffi::PANGO_SCRIPT_MEROITIC_CURSIVE => Self::MeroiticCursive, ffi::PANGO_SCRIPT_MEROITIC_HIEROGLYPHS => Self::MeroiticHieroglyphs, ffi::PANGO_SCRIPT_MIAO => Self::Miao, ffi::PANGO_SCRIPT_SHARADA => Self::Sharada, ffi::PANGO_SCRIPT_SORA_SOMPENG => Self::SoraSompeng, ffi::PANGO_SCRIPT_TAKRI => Self::Takri, ffi::PANGO_SCRIPT_BASSA_VAH => Self::BassaVah, ffi::PANGO_SCRIPT_CAUCASIAN_ALBANIAN => Self::CaucasianAlbanian, ffi::PANGO_SCRIPT_DUPLOYAN => Self::Duployan, ffi::PANGO_SCRIPT_ELBASAN => Self::Elbasan, ffi::PANGO_SCRIPT_GRANTHA => Self::Grantha, ffi::PANGO_SCRIPT_KHOJKI => Self::Khojki, ffi::PANGO_SCRIPT_KHUDAWADI => Self::Khudawadi, ffi::PANGO_SCRIPT_LINEAR_A => Self::LinearA, ffi::PANGO_SCRIPT_MAHAJANI => Self::Mahajani, ffi::PANGO_SCRIPT_MANICHAEAN => Self::Manichaean, ffi::PANGO_SCRIPT_MENDE_KIKAKUI => Self::MendeKikakui, ffi::PANGO_SCRIPT_MODI => Self::Modi, ffi::PANGO_SCRIPT_MRO => Self::Mro, ffi::PANGO_SCRIPT_NABATAEAN => Self::Nabataean, ffi::PANGO_SCRIPT_OLD_NORTH_ARABIAN => Self::OldNorthArabian, ffi::PANGO_SCRIPT_OLD_PERMIC => Self::OldPermic, ffi::PANGO_SCRIPT_PAHAWH_HMONG => Self::PahawhHmong, ffi::PANGO_SCRIPT_PALMYRENE => Self::Palmyrene, ffi::PANGO_SCRIPT_PAU_CIN_HAU => Self::PauCinHau, ffi::PANGO_SCRIPT_PSALTER_PAHLAVI => Self::PsalterPahlavi, ffi::PANGO_SCRIPT_SIDDHAM => Self::Siddham, ffi::PANGO_SCRIPT_TIRHUTA => Self::Tirhuta, ffi::PANGO_SCRIPT_WARANG_CITI => Self::WarangCiti, ffi::PANGO_SCRIPT_AHOM => Self::Ahom, ffi::PANGO_SCRIPT_ANATOLIAN_HIEROGLYPHS => Self::AnatolianHieroglyphs, ffi::PANGO_SCRIPT_HATRAN => Self::Hatran, ffi::PANGO_SCRIPT_MULTANI => Self::Multani, ffi::PANGO_SCRIPT_OLD_HUNGARIAN => Self::OldHungarian, ffi::PANGO_SCRIPT_SIGNWRITING => Self::Signwriting, value => Self::__Unknown(value), } } } impl StaticType for Script { fn static_type() -> Type { unsafe { from_glib(ffi::pango_script_get_type()) } } } impl glib::value::ValueType for Script { type Type = Self; } unsafe impl<'a> FromValue<'a> for Script { type Checker = glib::value::GenericValueTypeChecker; unsafe fn from_value(value: &'a glib::Value) -> Self { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) } } impl ToValue for Script { 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 } fn value_type(&self) -> glib::Type { Self::static_type() } } #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] #[non_exhaustive] #[doc(alias = "PangoStretch")] pub enum Stretch { #[doc(alias = "PANGO_STRETCH_ULTRA_CONDENSED")] UltraCondensed, #[doc(alias = "PANGO_STRETCH_EXTRA_CONDENSED")] ExtraCondensed, #[doc(alias = "PANGO_STRETCH_CONDENSED")] Condensed, #[doc(alias = "PANGO_STRETCH_SEMI_CONDENSED")] SemiCondensed, #[doc(alias = "PANGO_STRETCH_NORMAL")] Normal, #[doc(alias = "PANGO_STRETCH_SEMI_EXPANDED")] SemiExpanded, #[doc(alias = "PANGO_STRETCH_EXPANDED")] Expanded, #[doc(alias = "PANGO_STRETCH_EXTRA_EXPANDED")] ExtraExpanded, #[doc(alias = "PANGO_STRETCH_ULTRA_EXPANDED")] UltraExpanded, #[doc(hidden)] __Unknown(i32), } impl fmt::Display for Stretch { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, "Stretch::{}", match *self { Self::UltraCondensed => "UltraCondensed", Self::ExtraCondensed => "ExtraCondensed", Self::Condensed => "Condensed", Self::SemiCondensed => "SemiCondensed", Self::Normal => "Normal", Self::SemiExpanded => "SemiExpanded", Self::Expanded => "Expanded", Self::ExtraExpanded => "ExtraExpanded", Self::UltraExpanded => "UltraExpanded", _ => "Unknown", } ) } } #[doc(hidden)] impl IntoGlib for Stretch { type GlibType = ffi::PangoStretch; fn into_glib(self) -> ffi::PangoStretch { match self { Self::UltraCondensed => ffi::PANGO_STRETCH_ULTRA_CONDENSED, Self::ExtraCondensed => ffi::PANGO_STRETCH_EXTRA_CONDENSED, Self::Condensed => ffi::PANGO_STRETCH_CONDENSED, Self::SemiCondensed => ffi::PANGO_STRETCH_SEMI_CONDENSED, Self::Normal => ffi::PANGO_STRETCH_NORMAL, Self::SemiExpanded => ffi::PANGO_STRETCH_SEMI_EXPANDED, Self::Expanded => ffi::PANGO_STRETCH_EXPANDED, Self::ExtraExpanded => ffi::PANGO_STRETCH_EXTRA_EXPANDED, Self::UltraExpanded => ffi::PANGO_STRETCH_ULTRA_EXPANDED, Self::__Unknown(value) => value, } } } #[doc(hidden)] impl FromGlib for Stretch { unsafe fn from_glib(value: ffi::PangoStretch) -> Self { match value { ffi::PANGO_STRETCH_ULTRA_CONDENSED => Self::UltraCondensed, ffi::PANGO_STRETCH_EXTRA_CONDENSED => Self::ExtraCondensed, ffi::PANGO_STRETCH_CONDENSED => Self::Condensed, ffi::PANGO_STRETCH_SEMI_CONDENSED => Self::SemiCondensed, ffi::PANGO_STRETCH_NORMAL => Self::Normal, ffi::PANGO_STRETCH_SEMI_EXPANDED => Self::SemiExpanded, ffi::PANGO_STRETCH_EXPANDED => Self::Expanded, ffi::PANGO_STRETCH_EXTRA_EXPANDED => Self::ExtraExpanded, ffi::PANGO_STRETCH_ULTRA_EXPANDED => Self::UltraExpanded, value => Self::__Unknown(value), } } } impl StaticType for Stretch { fn static_type() -> Type { unsafe { from_glib(ffi::pango_stretch_get_type()) } } } impl glib::value::ValueType for Stretch { type Type = Self; } unsafe impl<'a> FromValue<'a> for Stretch { type Checker = glib::value::GenericValueTypeChecker; unsafe fn from_value(value: &'a glib::Value) -> Self { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) } } impl ToValue for Stretch { 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 } fn value_type(&self) -> glib::Type { Self::static_type() } } #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] #[non_exhaustive] #[doc(alias = "PangoStyle")] pub enum Style { #[doc(alias = "PANGO_STYLE_NORMAL")] Normal, #[doc(alias = "PANGO_STYLE_OBLIQUE")] Oblique, #[doc(alias = "PANGO_STYLE_ITALIC")] Italic, #[doc(hidden)] __Unknown(i32), } impl fmt::Display for Style { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, "Style::{}", match *self { Self::Normal => "Normal", Self::Oblique => "Oblique", Self::Italic => "Italic", _ => "Unknown", } ) } } #[doc(hidden)] impl IntoGlib for Style { type GlibType = ffi::PangoStyle; fn into_glib(self) -> ffi::PangoStyle { match self { Self::Normal => ffi::PANGO_STYLE_NORMAL, Self::Oblique => ffi::PANGO_STYLE_OBLIQUE, Self::Italic => ffi::PANGO_STYLE_ITALIC, Self::__Unknown(value) => value, } } } #[doc(hidden)] impl FromGlib for Style { unsafe fn from_glib(value: ffi::PangoStyle) -> Self { match value { ffi::PANGO_STYLE_NORMAL => Self::Normal, ffi::PANGO_STYLE_OBLIQUE => Self::Oblique, ffi::PANGO_STYLE_ITALIC => Self::Italic, value => Self::__Unknown(value), } } } impl StaticType for Style { fn static_type() -> Type { unsafe { from_glib(ffi::pango_style_get_type()) } } } impl glib::value::ValueType for Style { type Type = Self; } unsafe impl<'a> FromValue<'a> for Style { type Checker = glib::value::GenericValueTypeChecker; unsafe fn from_value(value: &'a glib::Value) -> Self { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) } } impl ToValue for Style { 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 } fn value_type(&self) -> glib::Type { Self::static_type() } } #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] #[non_exhaustive] #[doc(alias = "PangoTabAlign")] pub enum TabAlign { #[doc(alias = "PANGO_TAB_LEFT")] Left, #[doc(hidden)] __Unknown(i32), } impl fmt::Display for TabAlign { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, "TabAlign::{}", match *self { Self::Left => "Left", _ => "Unknown", } ) } } #[doc(hidden)] impl IntoGlib for TabAlign { type GlibType = ffi::PangoTabAlign; fn into_glib(self) -> ffi::PangoTabAlign { match self { Self::Left => ffi::PANGO_TAB_LEFT, Self::__Unknown(value) => value, } } } #[doc(hidden)] impl FromGlib for TabAlign { unsafe fn from_glib(value: ffi::PangoTabAlign) -> Self { match value { ffi::PANGO_TAB_LEFT => Self::Left, value => Self::__Unknown(value), } } } impl StaticType for TabAlign { fn static_type() -> Type { unsafe { from_glib(ffi::pango_tab_align_get_type()) } } } impl glib::value::ValueType for TabAlign { type Type = Self; } unsafe impl<'a> FromValue<'a> for TabAlign { type Checker = glib::value::GenericValueTypeChecker; unsafe fn from_value(value: &'a glib::Value) -> Self { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) } } impl ToValue for TabAlign { 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 } fn value_type(&self) -> glib::Type { Self::static_type() } } #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] #[non_exhaustive] #[doc(alias = "PangoUnderline")] pub enum Underline { #[doc(alias = "PANGO_UNDERLINE_NONE")] None, #[doc(alias = "PANGO_UNDERLINE_SINGLE")] Single, #[doc(alias = "PANGO_UNDERLINE_DOUBLE")] Double, #[doc(alias = "PANGO_UNDERLINE_LOW")] Low, #[doc(alias = "PANGO_UNDERLINE_ERROR")] Error, #[doc(alias = "PANGO_UNDERLINE_SINGLE_LINE")] SingleLine, #[doc(alias = "PANGO_UNDERLINE_DOUBLE_LINE")] DoubleLine, #[doc(alias = "PANGO_UNDERLINE_ERROR_LINE")] ErrorLine, #[doc(hidden)] __Unknown(i32), } impl fmt::Display for Underline { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, "Underline::{}", match *self { Self::None => "None", Self::Single => "Single", Self::Double => "Double", Self::Low => "Low", Self::Error => "Error", Self::SingleLine => "SingleLine", Self::DoubleLine => "DoubleLine", Self::ErrorLine => "ErrorLine", _ => "Unknown", } ) } } #[doc(hidden)] impl IntoGlib for Underline { type GlibType = ffi::PangoUnderline; fn into_glib(self) -> ffi::PangoUnderline { match self { Self::None => ffi::PANGO_UNDERLINE_NONE, Self::Single => ffi::PANGO_UNDERLINE_SINGLE, Self::Double => ffi::PANGO_UNDERLINE_DOUBLE, Self::Low => ffi::PANGO_UNDERLINE_LOW, Self::Error => ffi::PANGO_UNDERLINE_ERROR, Self::SingleLine => ffi::PANGO_UNDERLINE_SINGLE_LINE, Self::DoubleLine => ffi::PANGO_UNDERLINE_DOUBLE_LINE, Self::ErrorLine => ffi::PANGO_UNDERLINE_ERROR_LINE, Self::__Unknown(value) => value, } } } #[doc(hidden)] impl FromGlib for Underline { unsafe fn from_glib(value: ffi::PangoUnderline) -> Self { match value { ffi::PANGO_UNDERLINE_NONE => Self::None, ffi::PANGO_UNDERLINE_SINGLE => Self::Single, ffi::PANGO_UNDERLINE_DOUBLE => Self::Double, ffi::PANGO_UNDERLINE_LOW => Self::Low, ffi::PANGO_UNDERLINE_ERROR => Self::Error, ffi::PANGO_UNDERLINE_SINGLE_LINE => Self::SingleLine, ffi::PANGO_UNDERLINE_DOUBLE_LINE => Self::DoubleLine, ffi::PANGO_UNDERLINE_ERROR_LINE => Self::ErrorLine, value => Self::__Unknown(value), } } } impl StaticType for Underline { fn static_type() -> Type { unsafe { from_glib(ffi::pango_underline_get_type()) } } } impl glib::value::ValueType for Underline { type Type = Self; } unsafe impl<'a> FromValue<'a> for Underline { type Checker = glib::value::GenericValueTypeChecker; unsafe fn from_value(value: &'a glib::Value) -> Self { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) } } impl ToValue for Underline { 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 } fn value_type(&self) -> glib::Type { Self::static_type() } } #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] #[non_exhaustive] #[doc(alias = "PangoVariant")] pub enum Variant { #[doc(alias = "PANGO_VARIANT_NORMAL")] Normal, #[doc(alias = "PANGO_VARIANT_SMALL_CAPS")] SmallCaps, #[doc(hidden)] __Unknown(i32), } impl fmt::Display for Variant { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, "Variant::{}", match *self { Self::Normal => "Normal", Self::SmallCaps => "SmallCaps", _ => "Unknown", } ) } } #[doc(hidden)] impl IntoGlib for Variant { type GlibType = ffi::PangoVariant; fn into_glib(self) -> ffi::PangoVariant { match self { Self::Normal => ffi::PANGO_VARIANT_NORMAL, Self::SmallCaps => ffi::PANGO_VARIANT_SMALL_CAPS, Self::__Unknown(value) => value, } } } #[doc(hidden)] impl FromGlib for Variant { unsafe fn from_glib(value: ffi::PangoVariant) -> Self { match value { ffi::PANGO_VARIANT_NORMAL => Self::Normal, ffi::PANGO_VARIANT_SMALL_CAPS => Self::SmallCaps, value => Self::__Unknown(value), } } } impl StaticType for Variant { fn static_type() -> Type { unsafe { from_glib(ffi::pango_variant_get_type()) } } } impl glib::value::ValueType for Variant { type Type = Self; } unsafe impl<'a> FromValue<'a> for Variant { type Checker = glib::value::GenericValueTypeChecker; unsafe fn from_value(value: &'a glib::Value) -> Self { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) } } impl ToValue for Variant { 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 } fn value_type(&self) -> glib::Type { Self::static_type() } } #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] #[non_exhaustive] #[doc(alias = "PangoWeight")] pub enum Weight { #[doc(alias = "PANGO_WEIGHT_THIN")] Thin, #[doc(alias = "PANGO_WEIGHT_ULTRALIGHT")] Ultralight, #[doc(alias = "PANGO_WEIGHT_LIGHT")] Light, #[doc(alias = "PANGO_WEIGHT_SEMILIGHT")] Semilight, #[doc(alias = "PANGO_WEIGHT_BOOK")] Book, #[doc(alias = "PANGO_WEIGHT_NORMAL")] Normal, #[doc(alias = "PANGO_WEIGHT_MEDIUM")] Medium, #[doc(alias = "PANGO_WEIGHT_SEMIBOLD")] Semibold, #[doc(alias = "PANGO_WEIGHT_BOLD")] Bold, #[doc(alias = "PANGO_WEIGHT_ULTRABOLD")] Ultrabold, #[doc(alias = "PANGO_WEIGHT_HEAVY")] Heavy, #[doc(alias = "PANGO_WEIGHT_ULTRAHEAVY")] Ultraheavy, #[doc(hidden)] __Unknown(i32), } impl fmt::Display for Weight { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, "Weight::{}", match *self { Self::Thin => "Thin", Self::Ultralight => "Ultralight", Self::Light => "Light", Self::Semilight => "Semilight", Self::Book => "Book", Self::Normal => "Normal", Self::Medium => "Medium", Self::Semibold => "Semibold", Self::Bold => "Bold", Self::Ultrabold => "Ultrabold", Self::Heavy => "Heavy", Self::Ultraheavy => "Ultraheavy", _ => "Unknown", } ) } } #[doc(hidden)] impl IntoGlib for Weight { type GlibType = ffi::PangoWeight; fn into_glib(self) -> ffi::PangoWeight { match self { Self::Thin => ffi::PANGO_WEIGHT_THIN, Self::Ultralight => ffi::PANGO_WEIGHT_ULTRALIGHT, Self::Light => ffi::PANGO_WEIGHT_LIGHT, Self::Semilight => ffi::PANGO_WEIGHT_SEMILIGHT, Self::Book => ffi::PANGO_WEIGHT_BOOK, Self::Normal => ffi::PANGO_WEIGHT_NORMAL, Self::Medium => ffi::PANGO_WEIGHT_MEDIUM, Self::Semibold => ffi::PANGO_WEIGHT_SEMIBOLD, Self::Bold => ffi::PANGO_WEIGHT_BOLD, Self::Ultrabold => ffi::PANGO_WEIGHT_ULTRABOLD, Self::Heavy => ffi::PANGO_WEIGHT_HEAVY, Self::Ultraheavy => ffi::PANGO_WEIGHT_ULTRAHEAVY, Self::__Unknown(value) => value, } } } #[doc(hidden)] impl FromGlib for Weight { unsafe fn from_glib(value: ffi::PangoWeight) -> Self { match value { ffi::PANGO_WEIGHT_THIN => Self::Thin, ffi::PANGO_WEIGHT_ULTRALIGHT => Self::Ultralight, ffi::PANGO_WEIGHT_LIGHT => Self::Light, ffi::PANGO_WEIGHT_SEMILIGHT => Self::Semilight, ffi::PANGO_WEIGHT_BOOK => Self::Book, ffi::PANGO_WEIGHT_NORMAL => Self::Normal, ffi::PANGO_WEIGHT_MEDIUM => Self::Medium, ffi::PANGO_WEIGHT_SEMIBOLD => Self::Semibold, ffi::PANGO_WEIGHT_BOLD => Self::Bold, ffi::PANGO_WEIGHT_ULTRABOLD => Self::Ultrabold, ffi::PANGO_WEIGHT_HEAVY => Self::Heavy, ffi::PANGO_WEIGHT_ULTRAHEAVY => Self::Ultraheavy, value => Self::__Unknown(value), } } } impl StaticType for Weight { fn static_type() -> Type { unsafe { from_glib(ffi::pango_weight_get_type()) } } } impl glib::value::ValueType for Weight { type Type = Self; } unsafe impl<'a> FromValue<'a> for Weight { type Checker = glib::value::GenericValueTypeChecker; unsafe fn from_value(value: &'a glib::Value) -> Self { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) } } impl ToValue for Weight { 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 } fn value_type(&self) -> glib::Type { Self::static_type() } } #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] #[non_exhaustive] #[doc(alias = "PangoWrapMode")] pub enum WrapMode { #[doc(alias = "PANGO_WRAP_WORD")] Word, #[doc(alias = "PANGO_WRAP_CHAR")] Char, #[doc(alias = "PANGO_WRAP_WORD_CHAR")] WordChar, #[doc(hidden)] __Unknown(i32), } impl fmt::Display for WrapMode { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, "WrapMode::{}", match *self { Self::Word => "Word", Self::Char => "Char", Self::WordChar => "WordChar", _ => "Unknown", } ) } } #[doc(hidden)] impl IntoGlib for WrapMode { type GlibType = ffi::PangoWrapMode; fn into_glib(self) -> ffi::PangoWrapMode { match self { Self::Word => ffi::PANGO_WRAP_WORD, Self::Char => ffi::PANGO_WRAP_CHAR, Self::WordChar => ffi::PANGO_WRAP_WORD_CHAR, Self::__Unknown(value) => value, } } } #[doc(hidden)] impl FromGlib for WrapMode { unsafe fn from_glib(value: ffi::PangoWrapMode) -> Self { match value { ffi::PANGO_WRAP_WORD => Self::Word, ffi::PANGO_WRAP_CHAR => Self::Char, ffi::PANGO_WRAP_WORD_CHAR => Self::WordChar, value => Self::__Unknown(value), } } } impl StaticType for WrapMode { fn static_type() -> Type { unsafe { from_glib(ffi::pango_wrap_mode_get_type()) } } } impl glib::value::ValueType for WrapMode { type Type = Self; } unsafe impl<'a> FromValue<'a> for WrapMode { type Checker = glib::value::GenericValueTypeChecker; unsafe fn from_value(value: &'a glib::Value) -> Self { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) } } impl ToValue for WrapMode { 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 } fn value_type(&self) -> glib::Type { Self::static_type() } } pango-0.14.8/src/auto/flags.rs000064400000000000000000000170020072674642500142530ustar 00000000000000// This file was generated by gir (https://github.com/gtk-rs/gir) // from gir-files (https://github.com/gtk-rs/gir-files) // DO NOT EDIT use bitflags::bitflags; use glib::translate::*; use glib::value::FromValue; use glib::value::ToValue; use glib::StaticType; use glib::Type; use std::fmt; bitflags! { #[doc(alias = "PangoFontMask")] pub struct FontMask: u32 { #[doc(alias = "PANGO_FONT_MASK_FAMILY")] const FAMILY = ffi::PANGO_FONT_MASK_FAMILY as u32; #[doc(alias = "PANGO_FONT_MASK_STYLE")] const STYLE = ffi::PANGO_FONT_MASK_STYLE as u32; #[doc(alias = "PANGO_FONT_MASK_VARIANT")] const VARIANT = ffi::PANGO_FONT_MASK_VARIANT as u32; #[doc(alias = "PANGO_FONT_MASK_WEIGHT")] const WEIGHT = ffi::PANGO_FONT_MASK_WEIGHT as u32; #[doc(alias = "PANGO_FONT_MASK_STRETCH")] const STRETCH = ffi::PANGO_FONT_MASK_STRETCH as u32; #[doc(alias = "PANGO_FONT_MASK_SIZE")] const SIZE = ffi::PANGO_FONT_MASK_SIZE as u32; #[doc(alias = "PANGO_FONT_MASK_GRAVITY")] const GRAVITY = ffi::PANGO_FONT_MASK_GRAVITY as u32; #[doc(alias = "PANGO_FONT_MASK_VARIATIONS")] const VARIATIONS = ffi::PANGO_FONT_MASK_VARIATIONS as u32; } } impl fmt::Display for FontMask { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { ::fmt(self, f) } } #[doc(hidden)] impl IntoGlib for FontMask { type GlibType = ffi::PangoFontMask; fn into_glib(self) -> ffi::PangoFontMask { self.bits() } } #[doc(hidden)] impl FromGlib for FontMask { unsafe fn from_glib(value: ffi::PangoFontMask) -> Self { Self::from_bits_truncate(value) } } impl StaticType for FontMask { fn static_type() -> Type { unsafe { from_glib(ffi::pango_font_mask_get_type()) } } } impl glib::value::ValueType for FontMask { type Type = Self; } unsafe impl<'a> FromValue<'a> for FontMask { type Checker = glib::value::GenericValueTypeChecker; unsafe fn from_value(value: &'a glib::Value) -> Self { from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) } } impl ToValue for FontMask { 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 } fn value_type(&self) -> glib::Type { Self::static_type() } } #[cfg(any(feature = "v1_44", feature = "dox"))] bitflags! { #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_44")))] #[doc(alias = "PangoShapeFlags")] pub struct ShapeFlags: u32 { #[doc(alias = "PANGO_SHAPE_NONE")] const NONE = ffi::PANGO_SHAPE_NONE as u32; #[doc(alias = "PANGO_SHAPE_ROUND_POSITIONS")] const ROUND_POSITIONS = ffi::PANGO_SHAPE_ROUND_POSITIONS as u32; } } #[cfg(any(feature = "v1_44", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_44")))] impl fmt::Display for ShapeFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { ::fmt(self, f) } } #[cfg(any(feature = "v1_44", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_44")))] #[doc(hidden)] impl IntoGlib for ShapeFlags { type GlibType = ffi::PangoShapeFlags; fn into_glib(self) -> ffi::PangoShapeFlags { self.bits() } } #[cfg(any(feature = "v1_44", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_44")))] #[doc(hidden)] impl FromGlib for ShapeFlags { unsafe fn from_glib(value: ffi::PangoShapeFlags) -> Self { Self::from_bits_truncate(value) } } #[cfg(any(feature = "v1_44", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_44")))] impl StaticType for ShapeFlags { fn static_type() -> Type { unsafe { from_glib(ffi::pango_shape_flags_get_type()) } } } #[cfg(any(feature = "v1_44", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_44")))] impl glib::value::ValueType for ShapeFlags { type Type = Self; } #[cfg(any(feature = "v1_44", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_44")))] unsafe impl<'a> FromValue<'a> for ShapeFlags { type Checker = glib::value::GenericValueTypeChecker; unsafe fn from_value(value: &'a glib::Value) -> Self { from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) } } #[cfg(any(feature = "v1_44", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_44")))] impl ToValue for ShapeFlags { 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 } fn value_type(&self) -> glib::Type { Self::static_type() } } #[cfg(any(feature = "v1_44", feature = "dox"))] bitflags! { #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_44")))] #[doc(alias = "PangoShowFlags")] pub struct ShowFlags: u32 { #[doc(alias = "PANGO_SHOW_NONE")] const NONE = ffi::PANGO_SHOW_NONE as u32; #[doc(alias = "PANGO_SHOW_SPACES")] const SPACES = ffi::PANGO_SHOW_SPACES as u32; #[doc(alias = "PANGO_SHOW_LINE_BREAKS")] const LINE_BREAKS = ffi::PANGO_SHOW_LINE_BREAKS as u32; #[doc(alias = "PANGO_SHOW_IGNORABLES")] const IGNORABLES = ffi::PANGO_SHOW_IGNORABLES as u32; } } #[cfg(any(feature = "v1_44", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_44")))] impl fmt::Display for ShowFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { ::fmt(self, f) } } #[cfg(any(feature = "v1_44", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_44")))] #[doc(hidden)] impl IntoGlib for ShowFlags { type GlibType = ffi::PangoShowFlags; fn into_glib(self) -> ffi::PangoShowFlags { self.bits() } } #[cfg(any(feature = "v1_44", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_44")))] #[doc(hidden)] impl FromGlib for ShowFlags { unsafe fn from_glib(value: ffi::PangoShowFlags) -> Self { Self::from_bits_truncate(value) } } #[cfg(any(feature = "v1_44", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_44")))] impl StaticType for ShowFlags { fn static_type() -> Type { unsafe { from_glib(ffi::pango_show_flags_get_type()) } } } #[cfg(any(feature = "v1_44", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_44")))] impl glib::value::ValueType for ShowFlags { type Type = Self; } #[cfg(any(feature = "v1_44", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_44")))] unsafe impl<'a> FromValue<'a> for ShowFlags { type Checker = glib::value::GenericValueTypeChecker; unsafe fn from_value(value: &'a glib::Value) -> Self { from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) } } #[cfg(any(feature = "v1_44", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_44")))] impl ToValue for ShowFlags { 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 } fn value_type(&self) -> glib::Type { Self::static_type() } } pango-0.14.8/src/auto/font.rs000064400000000000000000000132130072674642500141250ustar 00000000000000// This file was generated by gir (https://github.com/gtk-rs/gir) // from gir-files (https://github.com/gtk-rs/gir-files) // DO NOT EDIT use crate::Coverage; use crate::FontDescription; #[cfg(any(feature = "v1_46", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_46")))] use crate::FontFace; use crate::FontMap; use crate::FontMetrics; use crate::Glyph; use crate::Language; use crate::Rectangle; use glib::object::IsA; use glib::translate::*; use std::fmt; glib::wrapper! { #[doc(alias = "PangoFont")] pub struct Font(Object); match fn { type_ => || ffi::pango_font_get_type(), } } pub const NONE_FONT: Option<&Font> = None; pub trait FontExt: 'static { #[doc(alias = "pango_font_describe")] fn describe(&self) -> Option; #[doc(alias = "pango_font_describe_with_absolute_size")] fn describe_with_absolute_size(&self) -> Option; //#[doc(alias = "pango_font_find_shaper")] //fn find_shaper(&self, language: &Language, ch: u32) -> /*Ignored*/Option; #[doc(alias = "pango_font_get_coverage")] #[doc(alias = "get_coverage")] fn coverage(&self, language: &Language) -> Option; #[cfg(any(feature = "v1_46", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_46")))] #[doc(alias = "pango_font_get_face")] #[doc(alias = "get_face")] fn face(&self) -> Option; //#[cfg(any(feature = "v1_44", feature = "dox"))] //#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_44")))] //#[doc(alias = "pango_font_get_features")] //#[doc(alias = "get_features")] //fn features(&self, features: /*Unimplemented*/&mut Fundamental: Pointer, num_features: &mut u32) -> u32; #[doc(alias = "pango_font_get_font_map")] #[doc(alias = "get_font_map")] fn font_map(&self) -> Option; #[doc(alias = "pango_font_get_glyph_extents")] #[doc(alias = "get_glyph_extents")] fn glyph_extents(&self, glyph: Glyph) -> (Rectangle, Rectangle); //#[cfg(any(feature = "v1_44", feature = "dox"))] //#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_44")))] //#[doc(alias = "pango_font_get_hb_font")] //#[doc(alias = "get_hb_font")] //fn hb_font(&self) -> /*Ignored*/Option; #[doc(alias = "pango_font_get_metrics")] #[doc(alias = "get_metrics")] fn metrics(&self, language: Option<&Language>) -> Option; #[cfg(any(feature = "v1_44", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_44")))] #[doc(alias = "pango_font_has_char")] fn has_char(&self, wc: char) -> bool; } impl> FontExt for O { fn describe(&self) -> Option { unsafe { from_glib_full(ffi::pango_font_describe(self.as_ref().to_glib_none().0)) } } fn describe_with_absolute_size(&self) -> Option { unsafe { from_glib_full(ffi::pango_font_describe_with_absolute_size( self.as_ref().to_glib_none().0, )) } } //fn find_shaper(&self, language: &Language, ch: u32) -> /*Ignored*/Option { // unsafe { TODO: call ffi:pango_font_find_shaper() } //} fn coverage(&self, language: &Language) -> Option { unsafe { from_glib_full(ffi::pango_font_get_coverage( self.as_ref().to_glib_none().0, mut_override(language.to_glib_none().0), )) } } #[cfg(any(feature = "v1_46", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_46")))] fn face(&self) -> Option { unsafe { from_glib_none(ffi::pango_font_get_face(self.as_ref().to_glib_none().0)) } } //#[cfg(any(feature = "v1_44", feature = "dox"))] //#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_44")))] //fn features(&self, features: /*Unimplemented*/&mut Fundamental: Pointer, num_features: &mut u32) -> u32 { // unsafe { TODO: call ffi:pango_font_get_features() } //} fn font_map(&self) -> Option { unsafe { from_glib_none(ffi::pango_font_get_font_map(self.as_ref().to_glib_none().0)) } } fn glyph_extents(&self, glyph: Glyph) -> (Rectangle, Rectangle) { unsafe { let mut ink_rect = Rectangle::uninitialized(); let mut logical_rect = Rectangle::uninitialized(); ffi::pango_font_get_glyph_extents( self.as_ref().to_glib_none().0, glyph, ink_rect.to_glib_none_mut().0, logical_rect.to_glib_none_mut().0, ); (ink_rect, logical_rect) } } //#[cfg(any(feature = "v1_44", feature = "dox"))] //#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_44")))] //fn hb_font(&self) -> /*Ignored*/Option { // unsafe { TODO: call ffi:pango_font_get_hb_font() } //} fn metrics(&self, language: Option<&Language>) -> Option { unsafe { from_glib_full(ffi::pango_font_get_metrics( self.as_ref().to_glib_none().0, mut_override(language.to_glib_none().0), )) } } #[cfg(any(feature = "v1_44", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_44")))] fn has_char(&self, wc: char) -> bool { unsafe { from_glib(ffi::pango_font_has_char( self.as_ref().to_glib_none().0, wc.into_glib(), )) } } } impl fmt::Display for Font { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.write_str("Font") } } pango-0.14.8/src/auto/font_description.rs000064400000000000000000000223560072674642500165400ustar 00000000000000// This file was generated by gir (https://github.com/gtk-rs/gir) // from gir-files (https://github.com/gtk-rs/gir-files) // DO NOT EDIT use crate::FontMask; use crate::Gravity; use crate::Stretch; use crate::Style; use crate::Variant; use crate::Weight; use glib::translate::*; use std::fmt; use std::hash; glib::wrapper! { #[derive(Debug, PartialOrd, Ord)] pub struct FontDescription(Boxed); match fn { copy => |ptr| ffi::pango_font_description_copy(ptr), free => |ptr| ffi::pango_font_description_free(ptr), type_ => || ffi::pango_font_description_get_type(), } } impl FontDescription { #[doc(alias = "pango_font_description_new")] pub fn new() -> FontDescription { unsafe { from_glib_full(ffi::pango_font_description_new()) } } #[doc(alias = "pango_font_description_better_match")] pub fn better_match( &self, old_match: Option<&FontDescription>, new_match: &FontDescription, ) -> bool { unsafe { from_glib(ffi::pango_font_description_better_match( self.to_glib_none().0, old_match.to_glib_none().0, new_match.to_glib_none().0, )) } } #[doc(alias = "pango_font_description_equal")] fn equal(&self, desc2: &FontDescription) -> bool { unsafe { from_glib(ffi::pango_font_description_equal( self.to_glib_none().0, desc2.to_glib_none().0, )) } } #[doc(alias = "pango_font_description_get_family")] #[doc(alias = "get_family")] pub fn family(&self) -> Option { unsafe { from_glib_none(ffi::pango_font_description_get_family( self.to_glib_none().0, )) } } #[doc(alias = "pango_font_description_get_gravity")] #[doc(alias = "get_gravity")] pub fn gravity(&self) -> Gravity { unsafe { from_glib(ffi::pango_font_description_get_gravity( self.to_glib_none().0, )) } } #[doc(alias = "pango_font_description_get_set_fields")] #[doc(alias = "get_set_fields")] pub fn set_fields(&self) -> FontMask { unsafe { from_glib(ffi::pango_font_description_get_set_fields( self.to_glib_none().0, )) } } #[doc(alias = "pango_font_description_get_size")] #[doc(alias = "get_size")] pub fn size(&self) -> i32 { unsafe { ffi::pango_font_description_get_size(self.to_glib_none().0) } } #[doc(alias = "pango_font_description_get_size_is_absolute")] #[doc(alias = "get_size_is_absolute")] pub fn is_size_absolute(&self) -> bool { unsafe { from_glib(ffi::pango_font_description_get_size_is_absolute( self.to_glib_none().0, )) } } #[doc(alias = "pango_font_description_get_stretch")] #[doc(alias = "get_stretch")] pub fn stretch(&self) -> Stretch { unsafe { from_glib(ffi::pango_font_description_get_stretch( self.to_glib_none().0, )) } } #[doc(alias = "pango_font_description_get_style")] #[doc(alias = "get_style")] pub fn style(&self) -> Style { unsafe { from_glib(ffi::pango_font_description_get_style(self.to_glib_none().0)) } } #[doc(alias = "pango_font_description_get_variant")] #[doc(alias = "get_variant")] pub fn variant(&self) -> Variant { unsafe { from_glib(ffi::pango_font_description_get_variant( self.to_glib_none().0, )) } } #[cfg(any(feature = "v1_42", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_42")))] #[doc(alias = "pango_font_description_get_variations")] #[doc(alias = "get_variations")] pub fn variations(&self) -> Option { unsafe { from_glib_none(ffi::pango_font_description_get_variations( self.to_glib_none().0, )) } } #[doc(alias = "pango_font_description_get_weight")] #[doc(alias = "get_weight")] pub fn weight(&self) -> Weight { unsafe { from_glib(ffi::pango_font_description_get_weight( self.to_glib_none().0, )) } } #[doc(alias = "pango_font_description_hash")] fn hash(&self) -> u32 { unsafe { ffi::pango_font_description_hash(self.to_glib_none().0) } } #[doc(alias = "pango_font_description_merge")] pub fn merge(&mut self, desc_to_merge: Option<&FontDescription>, replace_existing: bool) { unsafe { ffi::pango_font_description_merge( self.to_glib_none_mut().0, desc_to_merge.to_glib_none().0, replace_existing.into_glib(), ); } } #[doc(alias = "pango_font_description_set_absolute_size")] pub fn set_absolute_size(&mut self, size: f64) { unsafe { ffi::pango_font_description_set_absolute_size(self.to_glib_none_mut().0, size); } } #[doc(alias = "pango_font_description_set_family")] pub fn set_family(&mut self, family: &str) { unsafe { ffi::pango_font_description_set_family( self.to_glib_none_mut().0, family.to_glib_none().0, ); } } #[doc(alias = "pango_font_description_set_gravity")] pub fn set_gravity(&mut self, gravity: Gravity) { unsafe { ffi::pango_font_description_set_gravity(self.to_glib_none_mut().0, gravity.into_glib()); } } #[doc(alias = "pango_font_description_set_size")] pub fn set_size(&mut self, size: i32) { unsafe { ffi::pango_font_description_set_size(self.to_glib_none_mut().0, size); } } #[doc(alias = "pango_font_description_set_stretch")] pub fn set_stretch(&mut self, stretch: Stretch) { unsafe { ffi::pango_font_description_set_stretch(self.to_glib_none_mut().0, stretch.into_glib()); } } #[doc(alias = "pango_font_description_set_style")] pub fn set_style(&mut self, style: Style) { unsafe { ffi::pango_font_description_set_style(self.to_glib_none_mut().0, style.into_glib()); } } #[doc(alias = "pango_font_description_set_variant")] pub fn set_variant(&mut self, variant: Variant) { unsafe { ffi::pango_font_description_set_variant(self.to_glib_none_mut().0, variant.into_glib()); } } #[cfg(any(feature = "v1_42", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_42")))] #[doc(alias = "pango_font_description_set_variations")] pub fn set_variations(&mut self, variations: &str) { unsafe { ffi::pango_font_description_set_variations( self.to_glib_none_mut().0, variations.to_glib_none().0, ); } } #[cfg(any(feature = "v1_42", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_42")))] #[doc(alias = "pango_font_description_set_variations_static")] pub fn set_variations_static(&mut self, variations: &str) { unsafe { ffi::pango_font_description_set_variations_static( self.to_glib_none_mut().0, variations.to_glib_none().0, ); } } #[doc(alias = "pango_font_description_set_weight")] pub fn set_weight(&mut self, weight: Weight) { unsafe { ffi::pango_font_description_set_weight(self.to_glib_none_mut().0, weight.into_glib()); } } #[doc(alias = "pango_font_description_to_filename")] pub fn to_filename(&self) -> Option { unsafe { from_glib_full(ffi::pango_font_description_to_filename( self.to_glib_none().0, )) } } #[doc(alias = "pango_font_description_to_string")] #[doc(alias = "to_string")] pub fn to_str(&self) -> glib::GString { unsafe { from_glib_full(ffi::pango_font_description_to_string(self.to_glib_none().0)) } } #[doc(alias = "pango_font_description_unset_fields")] pub fn unset_fields(&mut self, to_unset: FontMask) { unsafe { ffi::pango_font_description_unset_fields( self.to_glib_none_mut().0, to_unset.into_glib(), ); } } #[doc(alias = "pango_font_description_from_string")] pub fn from_string(str: &str) -> FontDescription { unsafe { from_glib_full(ffi::pango_font_description_from_string( str.to_glib_none().0, )) } } } impl Default for FontDescription { fn default() -> Self { Self::new() } } impl PartialEq for FontDescription { #[inline] fn eq(&self, other: &Self) -> bool { self.equal(other) } } impl Eq for FontDescription {} impl fmt::Display for FontDescription { #[inline] fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.write_str(&self.to_str()) } } impl hash::Hash for FontDescription { #[inline] fn hash(&self, state: &mut H) where H: hash::Hasher, { hash::Hash::hash(&self.hash(), state) } } pango-0.14.8/src/auto/font_face.rs000064400000000000000000000055060072674642500151110ustar 00000000000000// This file was generated by gir (https://github.com/gtk-rs/gir) // from gir-files (https://github.com/gtk-rs/gir-files) // DO NOT EDIT use crate::FontDescription; #[cfg(any(feature = "v1_46", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_46")))] use crate::FontFamily; use glib::object::IsA; use glib::translate::*; use std::fmt; use std::mem; use std::ptr; glib::wrapper! { #[doc(alias = "PangoFontFace")] pub struct FontFace(Object); match fn { type_ => || ffi::pango_font_face_get_type(), } } pub const NONE_FONT_FACE: Option<&FontFace> = None; pub trait FontFaceExt: 'static { #[doc(alias = "pango_font_face_describe")] fn describe(&self) -> Option; #[doc(alias = "pango_font_face_get_face_name")] #[doc(alias = "get_face_name")] fn face_name(&self) -> Option; #[cfg(any(feature = "v1_46", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_46")))] #[doc(alias = "pango_font_face_get_family")] #[doc(alias = "get_family")] fn family(&self) -> Option; #[doc(alias = "pango_font_face_is_synthesized")] fn is_synthesized(&self) -> bool; #[doc(alias = "pango_font_face_list_sizes")] fn list_sizes(&self) -> Vec; } impl> FontFaceExt for O { fn describe(&self) -> Option { unsafe { from_glib_full(ffi::pango_font_face_describe( self.as_ref().to_glib_none().0, )) } } fn face_name(&self) -> Option { unsafe { from_glib_none(ffi::pango_font_face_get_face_name( self.as_ref().to_glib_none().0, )) } } #[cfg(any(feature = "v1_46", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_46")))] fn family(&self) -> Option { unsafe { from_glib_none(ffi::pango_font_face_get_family( self.as_ref().to_glib_none().0, )) } } fn is_synthesized(&self) -> bool { unsafe { from_glib(ffi::pango_font_face_is_synthesized( self.as_ref().to_glib_none().0, )) } } fn list_sizes(&self) -> Vec { unsafe { let mut sizes = ptr::null_mut(); let mut n_sizes = mem::MaybeUninit::uninit(); ffi::pango_font_face_list_sizes( self.as_ref().to_glib_none().0, &mut sizes, n_sizes.as_mut_ptr(), ); FromGlibContainer::from_glib_full_num(sizes, n_sizes.assume_init() as usize) } } } impl fmt::Display for FontFace { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.write_str("FontFace") } } pango-0.14.8/src/auto/font_family.rs000064400000000000000000000057360072674642500155010ustar 00000000000000// This file was generated by gir (https://github.com/gtk-rs/gir) // from gir-files (https://github.com/gtk-rs/gir-files) // DO NOT EDIT use crate::FontFace; use glib::object::IsA; use glib::translate::*; use std::fmt; use std::mem; use std::ptr; glib::wrapper! { #[doc(alias = "PangoFontFamily")] pub struct FontFamily(Object); match fn { type_ => || ffi::pango_font_family_get_type(), } } pub const NONE_FONT_FAMILY: Option<&FontFamily> = None; pub trait FontFamilyExt: 'static { #[cfg(any(feature = "v1_46", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_46")))] #[doc(alias = "pango_font_family_get_face")] #[doc(alias = "get_face")] fn face(&self, name: Option<&str>) -> Option; #[doc(alias = "pango_font_family_get_name")] #[doc(alias = "get_name")] fn name(&self) -> Option; #[doc(alias = "pango_font_family_is_monospace")] fn is_monospace(&self) -> bool; #[cfg(any(feature = "v1_44", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_44")))] #[doc(alias = "pango_font_family_is_variable")] fn is_variable(&self) -> bool; #[doc(alias = "pango_font_family_list_faces")] fn list_faces(&self) -> Vec; } impl> FontFamilyExt for O { #[cfg(any(feature = "v1_46", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_46")))] fn face(&self, name: Option<&str>) -> Option { unsafe { from_glib_none(ffi::pango_font_family_get_face( self.as_ref().to_glib_none().0, name.to_glib_none().0, )) } } fn name(&self) -> Option { unsafe { from_glib_none(ffi::pango_font_family_get_name( self.as_ref().to_glib_none().0, )) } } fn is_monospace(&self) -> bool { unsafe { from_glib(ffi::pango_font_family_is_monospace( self.as_ref().to_glib_none().0, )) } } #[cfg(any(feature = "v1_44", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_44")))] fn is_variable(&self) -> bool { unsafe { from_glib(ffi::pango_font_family_is_variable( self.as_ref().to_glib_none().0, )) } } fn list_faces(&self) -> Vec { unsafe { let mut faces = ptr::null_mut(); let mut n_faces = mem::MaybeUninit::uninit(); ffi::pango_font_family_list_faces( self.as_ref().to_glib_none().0, &mut faces, n_faces.as_mut_ptr(), ); FromGlibContainer::from_glib_container_num(faces, n_faces.assume_init() as usize) } } } impl fmt::Display for FontFamily { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.write_str("FontFamily") } } pango-0.14.8/src/auto/font_map.rs000064400000000000000000000074160072674642500147720ustar 00000000000000// This file was generated by gir (https://github.com/gtk-rs/gir) // from gir-files (https://github.com/gtk-rs/gir-files) // DO NOT EDIT use crate::Context; use crate::Font; use crate::FontDescription; use crate::FontFamily; use crate::Fontset; use crate::Language; use glib::object::IsA; use glib::translate::*; use std::fmt; use std::mem; use std::ptr; glib::wrapper! { #[doc(alias = "PangoFontMap")] pub struct FontMap(Object); match fn { type_ => || ffi::pango_font_map_get_type(), } } pub const NONE_FONT_MAP: Option<&FontMap> = None; pub trait FontMapExt: 'static { #[doc(alias = "pango_font_map_changed")] fn changed(&self); #[doc(alias = "pango_font_map_create_context")] fn create_context(&self) -> Option; #[cfg(any(feature = "v1_46", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_46")))] #[doc(alias = "pango_font_map_get_family")] #[doc(alias = "get_family")] fn family(&self, name: &str) -> Option; #[doc(alias = "pango_font_map_get_serial")] #[doc(alias = "get_serial")] fn serial(&self) -> u32; #[doc(alias = "pango_font_map_list_families")] fn list_families(&self) -> Vec; #[doc(alias = "pango_font_map_load_font")] fn load_font(&self, context: &Context, desc: &FontDescription) -> Option; #[doc(alias = "pango_font_map_load_fontset")] fn load_fontset( &self, context: &Context, desc: &FontDescription, language: &Language, ) -> Option; } impl> FontMapExt for O { fn changed(&self) { unsafe { ffi::pango_font_map_changed(self.as_ref().to_glib_none().0); } } fn create_context(&self) -> Option { unsafe { from_glib_full(ffi::pango_font_map_create_context( self.as_ref().to_glib_none().0, )) } } #[cfg(any(feature = "v1_46", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_46")))] fn family(&self, name: &str) -> Option { unsafe { from_glib_none(ffi::pango_font_map_get_family( self.as_ref().to_glib_none().0, name.to_glib_none().0, )) } } fn serial(&self) -> u32 { unsafe { ffi::pango_font_map_get_serial(self.as_ref().to_glib_none().0) } } fn list_families(&self) -> Vec { unsafe { let mut families = ptr::null_mut(); let mut n_families = mem::MaybeUninit::uninit(); ffi::pango_font_map_list_families( self.as_ref().to_glib_none().0, &mut families, n_families.as_mut_ptr(), ); FromGlibContainer::from_glib_container_num(families, n_families.assume_init() as usize) } } fn load_font(&self, context: &Context, desc: &FontDescription) -> Option { unsafe { from_glib_full(ffi::pango_font_map_load_font( self.as_ref().to_glib_none().0, context.to_glib_none().0, desc.to_glib_none().0, )) } } fn load_fontset( &self, context: &Context, desc: &FontDescription, language: &Language, ) -> Option { unsafe { from_glib_full(ffi::pango_font_map_load_fontset( self.as_ref().to_glib_none().0, context.to_glib_none().0, desc.to_glib_none().0, mut_override(language.to_glib_none().0), )) } } } impl fmt::Display for FontMap { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.write_str("FontMap") } } pango-0.14.8/src/auto/font_metrics.rs000064400000000000000000000054060072674642500156600ustar 00000000000000// This file was generated by gir (https://github.com/gtk-rs/gir) // from gir-files (https://github.com/gtk-rs/gir-files) // DO NOT EDIT use glib::translate::*; glib::wrapper! { #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct FontMetrics(Shared); match fn { ref => |ptr| ffi::pango_font_metrics_ref(ptr), unref => |ptr| ffi::pango_font_metrics_unref(ptr), type_ => || ffi::pango_font_metrics_get_type(), } } impl FontMetrics { #[doc(alias = "pango_font_metrics_get_approximate_char_width")] #[doc(alias = "get_approximate_char_width")] pub fn approximate_char_width(&self) -> i32 { unsafe { ffi::pango_font_metrics_get_approximate_char_width(self.to_glib_none().0) } } #[doc(alias = "pango_font_metrics_get_approximate_digit_width")] #[doc(alias = "get_approximate_digit_width")] pub fn approximate_digit_width(&self) -> i32 { unsafe { ffi::pango_font_metrics_get_approximate_digit_width(self.to_glib_none().0) } } #[doc(alias = "pango_font_metrics_get_ascent")] #[doc(alias = "get_ascent")] pub fn ascent(&self) -> i32 { unsafe { ffi::pango_font_metrics_get_ascent(self.to_glib_none().0) } } #[doc(alias = "pango_font_metrics_get_descent")] #[doc(alias = "get_descent")] pub fn descent(&self) -> i32 { unsafe { ffi::pango_font_metrics_get_descent(self.to_glib_none().0) } } #[cfg(any(feature = "v1_44", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_44")))] #[doc(alias = "pango_font_metrics_get_height")] #[doc(alias = "get_height")] pub fn height(&self) -> i32 { unsafe { ffi::pango_font_metrics_get_height(self.to_glib_none().0) } } #[doc(alias = "pango_font_metrics_get_strikethrough_position")] #[doc(alias = "get_strikethrough_position")] pub fn strikethrough_position(&self) -> i32 { unsafe { ffi::pango_font_metrics_get_strikethrough_position(self.to_glib_none().0) } } #[doc(alias = "pango_font_metrics_get_strikethrough_thickness")] #[doc(alias = "get_strikethrough_thickness")] pub fn strikethrough_thickness(&self) -> i32 { unsafe { ffi::pango_font_metrics_get_strikethrough_thickness(self.to_glib_none().0) } } #[doc(alias = "pango_font_metrics_get_underline_position")] #[doc(alias = "get_underline_position")] pub fn underline_position(&self) -> i32 { unsafe { ffi::pango_font_metrics_get_underline_position(self.to_glib_none().0) } } #[doc(alias = "pango_font_metrics_get_underline_thickness")] #[doc(alias = "get_underline_thickness")] pub fn underline_thickness(&self) -> i32 { unsafe { ffi::pango_font_metrics_get_underline_thickness(self.to_glib_none().0) } } } pango-0.14.8/src/auto/fontset.rs000064400000000000000000000045470072674642500146530ustar 00000000000000// This file was generated by gir (https://github.com/gtk-rs/gir) // from gir-files (https://github.com/gtk-rs/gir-files) // DO NOT EDIT use crate::Font; use crate::FontMetrics; use glib::object::IsA; use glib::translate::*; use std::fmt; glib::wrapper! { #[doc(alias = "PangoFontset")] pub struct Fontset(Object); match fn { type_ => || ffi::pango_fontset_get_type(), } } pub const NONE_FONTSET: Option<&Fontset> = None; pub trait FontsetExt: 'static { #[doc(alias = "pango_fontset_foreach")] fn foreach bool>(&self, func: P); #[doc(alias = "pango_fontset_get_font")] #[doc(alias = "get_font")] fn font(&self, wc: u32) -> Option; #[doc(alias = "pango_fontset_get_metrics")] #[doc(alias = "get_metrics")] fn metrics(&self) -> Option; } impl> FontsetExt for O { fn foreach bool>(&self, func: P) { let func_data: P = func; unsafe extern "C" fn func_func bool>( fontset: *mut ffi::PangoFontset, font: *mut ffi::PangoFont, user_data: glib::ffi::gpointer, ) -> glib::ffi::gboolean { let fontset = from_glib_borrow(fontset); let font = from_glib_borrow(font); let callback: *mut P = user_data as *const _ as usize as *mut P; let res = (*callback)(&fontset, &font); res.into_glib() } let func = Some(func_func::

as _); let super_callback0: &P = &func_data; unsafe { ffi::pango_fontset_foreach( self.as_ref().to_glib_none().0, func, super_callback0 as *const _ as usize as *mut _, ); } } fn font(&self, wc: u32) -> Option { unsafe { from_glib_full(ffi::pango_fontset_get_font( self.as_ref().to_glib_none().0, wc, )) } } fn metrics(&self) -> Option { unsafe { from_glib_full(ffi::pango_fontset_get_metrics( self.as_ref().to_glib_none().0, )) } } } impl fmt::Display for Fontset { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.write_str("Fontset") } } pango-0.14.8/src/auto/fontset_simple.rs000064400000000000000000000023770072674642500162230ustar 00000000000000// This file was generated by gir (https://github.com/gtk-rs/gir) // from gir-files (https://github.com/gtk-rs/gir-files) // DO NOT EDIT use crate::Font; use crate::Fontset; use crate::Language; use glib::object::IsA; use glib::translate::*; use std::fmt; glib::wrapper! { #[doc(alias = "PangoFontsetSimple")] pub struct FontsetSimple(Object) @extends Fontset; match fn { type_ => || ffi::pango_fontset_simple_get_type(), } } impl FontsetSimple { #[doc(alias = "pango_fontset_simple_new")] pub fn new(language: &mut Language) -> FontsetSimple { unsafe { from_glib_full(ffi::pango_fontset_simple_new(language.to_glib_none_mut().0)) } } #[doc(alias = "pango_fontset_simple_append")] pub fn append>(&self, font: &P) { unsafe { ffi::pango_fontset_simple_append(self.to_glib_none().0, font.as_ref().to_glib_none().0); } } #[doc(alias = "pango_fontset_simple_size")] pub fn size(&self) -> i32 { unsafe { ffi::pango_fontset_simple_size(self.to_glib_none().0) } } } impl fmt::Display for FontsetSimple { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.write_str("FontsetSimple") } } pango-0.14.8/src/auto/functions.rs000064400000000000000000000214130072674642500151700ustar 00000000000000// This file was generated by gir (https://github.com/gtk-rs/gir) // from gir-files (https://github.com/gtk-rs/gir-files) // DO NOT EDIT use crate::Analysis; use crate::AttrIterator; use crate::AttrList; use crate::Context; use crate::Direction; use crate::GlyphString; use crate::Item; use crate::Rectangle; use crate::Stretch; use crate::Style; use crate::Variant; use crate::Weight; use glib::translate::*; use std::mem; use std::ptr; //#[cfg_attr(feature = "v1_44", deprecated = "Since 1.44")] //#[doc(alias = "pango_break")] //#[doc(alias = "break")] //pub fn break_(text: &str, analysis: &mut Analysis, attrs: /*Ignored*/&[&LogAttr]) { // unsafe { TODO: call ffi:pango_break() } //} //#[doc(alias = "pango_default_break")] //pub fn default_break(text: &str, analysis: Option<&mut Analysis>, attrs: /*Ignored*/&mut LogAttr, attrs_len: i32) { // unsafe { TODO: call ffi:pango_default_break() } //} #[doc(alias = "pango_extents_to_pixels")] pub fn extents_to_pixels(inclusive: Option<&Rectangle>, nearest: Option<&Rectangle>) { unsafe { ffi::pango_extents_to_pixels( mut_override(inclusive.to_glib_none().0), mut_override(nearest.to_glib_none().0), ); } } #[doc(alias = "pango_find_base_dir")] pub fn find_base_dir(text: &str) -> Direction { let length = text.len() as i32; unsafe { from_glib(ffi::pango_find_base_dir(text.to_glib_none().0, length)) } } #[doc(alias = "pango_find_paragraph_boundary")] pub fn find_paragraph_boundary(text: &str) -> (i32, i32) { let length = text.len() as i32; unsafe { let mut paragraph_delimiter_index = mem::MaybeUninit::uninit(); let mut next_paragraph_start = mem::MaybeUninit::uninit(); ffi::pango_find_paragraph_boundary( text.to_glib_none().0, length, paragraph_delimiter_index.as_mut_ptr(), next_paragraph_start.as_mut_ptr(), ); let paragraph_delimiter_index = paragraph_delimiter_index.assume_init(); let next_paragraph_start = next_paragraph_start.assume_init(); (paragraph_delimiter_index, next_paragraph_start) } } //#[doc(alias = "pango_get_log_attrs")] //#[doc(alias = "get_log_attrs")] //pub fn log_attrs(text: &str, level: i32, language: &mut Language, log_attrs: /*Ignored*/&[&LogAttr]) { // unsafe { TODO: call ffi:pango_get_log_attrs() } //} #[doc(alias = "pango_is_zero_width")] pub fn is_zero_width(ch: char) -> bool { unsafe { from_glib(ffi::pango_is_zero_width(ch.into_glib())) } } #[doc(alias = "pango_itemize")] pub fn itemize( context: &Context, text: &str, start_index: i32, length: i32, attrs: &AttrList, cached_iter: Option<&AttrIterator>, ) -> Vec { unsafe { FromGlibPtrContainer::from_glib_full(ffi::pango_itemize( context.to_glib_none().0, text.to_glib_none().0, start_index, length, attrs.to_glib_none().0, mut_override(cached_iter.to_glib_none().0), )) } } #[doc(alias = "pango_itemize_with_base_dir")] pub fn itemize_with_base_dir( context: &Context, base_dir: Direction, text: &str, start_index: i32, length: i32, attrs: &AttrList, cached_iter: Option<&AttrIterator>, ) -> Vec { unsafe { FromGlibPtrContainer::from_glib_full(ffi::pango_itemize_with_base_dir( context.to_glib_none().0, base_dir.into_glib(), text.to_glib_none().0, start_index, length, attrs.to_glib_none().0, mut_override(cached_iter.to_glib_none().0), )) } } //#[doc(alias = "pango_markup_parser_finish")] //pub fn markup_parser_finish(context: /*Ignored*/&glib::MarkupParseContext) -> Result<(AttrList, glib::GString, char), glib::Error> { // unsafe { TODO: call ffi:pango_markup_parser_finish() } //} //#[doc(alias = "pango_markup_parser_new")] //pub fn markup_parser_new(accel_marker: char) -> /*Ignored*/Option { // unsafe { TODO: call ffi:pango_markup_parser_new() } //} #[doc(alias = "pango_parse_markup")] pub fn parse_markup( markup_text: &str, accel_marker: char, ) -> Result<(AttrList, glib::GString, char), glib::Error> { let length = markup_text.len() as i32; unsafe { let mut attr_list = ptr::null_mut(); let mut text = ptr::null_mut(); let mut accel_char = mem::MaybeUninit::uninit(); let mut error = ptr::null_mut(); let _ = ffi::pango_parse_markup( markup_text.to_glib_none().0, length, accel_marker.into_glib(), &mut attr_list, &mut text, accel_char.as_mut_ptr(), &mut error, ); let accel_char = accel_char.assume_init(); if error.is_null() { Ok(( from_glib_full(attr_list), from_glib_full(text), std::convert::TryFrom::try_from(accel_char) .expect("conversion from an invalid Unicode value attempted"), )) } else { Err(from_glib_full(error)) } } } #[doc(alias = "pango_parse_stretch")] pub fn parse_stretch(str: &str, warn: bool) -> Option { unsafe { let mut stretch = mem::MaybeUninit::uninit(); let ret = from_glib(ffi::pango_parse_stretch( str.to_glib_none().0, stretch.as_mut_ptr(), warn.into_glib(), )); let stretch = stretch.assume_init(); if ret { Some(from_glib(stretch)) } else { None } } } #[doc(alias = "pango_parse_style")] pub fn parse_style(str: &str, warn: bool) -> Option