pax_global_header00006660000000000000000000000064146750201610014514gustar00rootroot0000000000000052 comment=fedefda24b24ff7fe4e23ff49737505e868a149b rust-pango-0.18-0.18.3/000077500000000000000000000000001467502016100142705ustar00rootroot00000000000000rust-pango-0.18-0.18.3/.cargo_vcs_info.json000066400000000000000000000001431467502016100202200ustar00rootroot00000000000000{ "git": { "sha1": "e6192fec10b811d4f116e9e362e17e186613f759" }, "path_in_vcs": "pango" }rust-pango-0.18-0.18.3/COPYRIGHT000066400000000000000000000012131467502016100155600ustar00rootroot00000000000000The 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. rust-pango-0.18-0.18.3/Cargo.toml000066400000000000000000000031131467502016100162160ustar00rootroot00000000000000# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO # # When uploading crates to the registry Cargo will automatically # "normalize" Cargo.toml files for maximal compatibility # with all versions of Cargo and also rewrite `path` dependencies # to registry (e.g., crates.io) dependencies. # # If you are reading this file be aware that the original Cargo.toml # will likely look very different (and much more reasonable). # See Cargo.toml.orig for the original contents. [package] edition = "2021" rust-version = "1.70" name = "pango" version = "0.18.3" 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] all-features = true rustc-args = [ "--cfg", "docsrs", ] rustdoc-args = [ "--cfg", "docsrs", "--generate-link-to-definition", ] [dependencies.ffi] version = "0.18" package = "pango-sys" [dependencies.gio] version = "0.18" [dependencies.glib] version = "0.18" [dependencies.libc] version = "0.2" [dependencies.once_cell] version = "1.0" [dev-dependencies.gir-format-check] version = "^0.1" [features] v1_42 = ["ffi/v1_42"] v1_44 = [ "v1_42", "ffi/v1_44", ] v1_46 = [ "v1_44", "ffi/v1_46", ] v1_48 = [ "v1_46", "ffi/v1_48", ] v1_50 = [ "v1_48", "ffi/v1_50", ] v1_52 = [ "v1_50", "ffi/v1_52", ] rust-pango-0.18-0.18.3/Cargo.toml.orig000066400000000000000000000020131467502016100171530ustar00rootroot00000000000000[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.18.3" description = "Rust bindings for the Pango library" repository = "https://github.com/gtk-rs/gtk-rs-core" license = "MIT" exclude = [ "gir-files/*", ] edition = "2021" rust-version = "1.70" [features] v1_42 = ["ffi/v1_42"] v1_44 = ["v1_42", "ffi/v1_44"] v1_46 = ["v1_44", "ffi/v1_46"] v1_48 = ["v1_46", "ffi/v1_48"] v1_50 = ["v1_48", "ffi/v1_50"] v1_52 = ["v1_50", "ffi/v1_52"] [package.metadata.docs.rs] all-features = true rustc-args = ["--cfg", "docsrs"] rustdoc-args = ["--cfg", "docsrs", "--generate-link-to-definition"] [dependencies] libc = "0.2" once_cell = "1.0" ffi = { package = "pango-sys", version = "0.18", path = "sys" } glib = { path = "../glib", version = "0.18" } gio = { path = "../gio", version = "0.18" } [dev-dependencies] gir-format-check = "^0.1" rust-pango-0.18-0.18.3/Gir.toml000066400000000000000000000250531467502016100157130ustar00rootroot00000000000000[options] girs_directories = ["../gir-files"] library = "Pango" version = "1.0" target_path = "." work_mode = "normal" generate_safety_asserts = false min_cfg_version = "1.40" use_gi_docgen = true single_version_file = true deprecate_by_min_version = true trust_return_value_nullability = true generate = [ # "Pango.GlyphVisAttr", # "Pango.LogAttr", "Pango.Alignment", "Pango.BaselineShift", "Pango.BidiType", "Pango.CoverageLevel", "Pango.Direction", "Pango.EllipsizeMode", "Pango.FontFace", "Pango.FontMask", "Pango.FontMetrics", "Pango.FontScale", "Pango.Fontset", "Pango.FontsetSimple", "Pango.Glyph", "Pango.GlyphUnit", "Pango.Gravity", "Pango.GravityHint", "Pango.Item", "Pango.LayoutDeserializeFlags", "Pango.LayoutIter", "Pango.LayoutRun", "Pango.LayoutSerializeFlags", "Pango.Overline", "Pango.Renderer", "Pango.RenderPart", "Pango.Script", "Pango.ShapeFlags", "Pango.ShowFlags", "Pango.Stretch", "Pango.Style", "Pango.TextTransform", "Pango.Underline", "Pango.Weight", "Pango.WrapMode", ] manual = [ "Gio.ListModel", "GLib.Bytes", "GLib.Error", "GLib.MarkupParseContext", "GLib.Quark", "Pango.Analysis", "Pango.AttrClass", "Pango.AttrColor", "Pango.AttrFloat", "Pango.AttrFontDesc", "Pango.AttrFontFeatures", "Pango.AttrInt", "Pango.AttrLanguage", "Pango.AttrShape", "Pango.AttrSize", "Pango.AttrString", "Pango.Coverage", "Pango.GlyphGeometry", "Pango.GlyphInfo", "Pango.LayoutDeserializeError", "Pango.Rectangle", ] [[object]] name = "Pango.*" status = "generate" [[object.constant]] name = "VERSION_STRING" ignore = true [[object.function]] name = "extents_to_pixels" manual = 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" manual = true [[object.function]] name = "shape_full" # invalid length computation on Stash instead of str manual = true [[object.function]] name = "shape_with_flags" # ivanlid length computation on a Option, it should fallback to 0. manual = true [[object]] name = "Pango.Attribute" status = "generate" concurrency = "send+sync" [[object.function]] name = "init" # irrelevant with all the constructors and unusable like this ignore = true [[object.function]] name = "get_type" version = "1.44" [[object.function]] pattern = "as.*" # casting functions, we go with IsAttribute trait in Rust ignore = true [[object]] name = "Pango.AttrIterator" status = "manual" [[object.function]] name = "next" rename = "next_style_change" [[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.function]] name = "from_string" [object.function.return] nullable_return_is_error = "Can't parse AttrList" [[object]] name = "Pango.AttrType" status = "generate" [[object.function]] name = "register" # Problematic function needs manual implementation ignore = true [[object.member]] name = "line_height" version = "1.50" [[object.member]] name = "absolute_line_height" version = "1.50" [[object.member]] name = "text_transform" version = "1.50" [[object.member]] name = "word" version = "1.50" [[object.member]] name = "sentence" version = "1.50" [[object.member]] name = "baseline_shift" version = "1.50" [[object.member]] name = "font_scale" version = "1.50" [[object]] name = "Pango.Color" status = "generate" boxed_inline = true [[object.function]] pattern = "(parse|parse_with_alpha)" manual = true [[object]] name = "Pango.Context" status = "generate" [[object.function]] name = "new" # Can be removed once https://gitlab.gnome.org/GNOME/pango/-/merge_requests/651 # has been merged. [object.function.return] nullable = false [[object.function]] name = "get_language" # Can be removed once https://gitlab.gnome.org/GNOME/pango/-/issues/709 # has been fixed. [object.function.return] nullable = true [[object.function]] name = "get_metrics" [[object.function.parameter]] name = "language" const = true # Can be removed once https://gitlab.gnome.org/GNOME/pango/-/merge_requests/651 # has been merged. [object.function.return] nullable = false [[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.function]] name = "get_languages" # TODO: requires FromGlibPtrArrayContainerAsVec implementation ignore = true [[object]] name = "Pango.FontDescription" status = "generate" concurrency = "send+sync" [[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.FontFamily" status = "generate" [[object.property]] name = "item-type" generate = [] # disable generated getter/notify, use the ones from GListModel iface [[object.property]] name = "n-items" generate = [] # disable generated getter/notify, use the ones from GListModel iface [[object]] name = "Pango.FontMap" status = "generate" [[object.property]] name = "item-type" generate = [] # disable generated getter/notify, use the ones from GListModel iface [[object.property]] name = "n-items" generate = [] # disable generated getter/notify, use the ones from GListModel iface [[object.function]] name = "load_fontset" [[object.function.parameter]] name = "language" const = true [[object]] name = "Pango.GlyphItem" status = "generate" [[object.function]] name = "get_logical_widths" manual = true [[object]] name = "Pango.GlyphItemIter" status = "manual" [[object.function]] name = "init_start" rename = "new_start" [[object.function]] name = "init_end" rename = "new_end" [[object]] name = "Pango.GlyphString" status = "generate" concurrency = "send+sync" [[object.function]] name = "get_logical_widths" manual = true [[object.function]] pattern = "(get_width|index_to_x|x_to_index)" [[object.function.parameter]] name = "glyphs" const = true [[object.function]] pattern = "(index_to_x|x_to_index)" [[object.function.parameter]] name = "analysis" const = true [[object]] name = "Pango.Language" status = "generate" [[object.function]] pattern = "get_scripts" manual = true # enum arrays don't seem to be possible to be autogenerated [[object.function]] pattern = "(get_sample_string|includes_script|matches|to_string)" [[object.function.parameter]] name = "language" const = true [[object.function]] name = "from_string" # This only returns NULL when passing NULL [[object.function.parameter]] name = "language" nullable = false [object.function.return] nullable = false [[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.Matrix" status = "generate" boxed_inline = true [[object.function]] name = "transform_pixel_rectangle" manual = true [[object.function]] name = "transform_rectangle" manual = true [[object]] name = "Pango.ScriptIter" status = "manual" [[object.function]] name = "next" rename = "next_range" [[object]] name = "Pango.TabAlign" status = "generate" [[object.member]] name = "right" version = "1.50" [[object.member]] name = "center" version = "1.50" [[object.member]] name = "decimal" version = "1.50" [[object]] name = "Pango.TabArray" status = "generate" concurrency = "send+sync" [[object.function]] pattern = "(to_string|get_decimal_point|get_positions_in_pixels|get_size|get_tab)" [[object.function.parameter]] pattern = "*" # because we can't target self const = true [[object.function]] name = "get_tabs" manual = true [[object.function]] name = "from_string" [object.function.return] nullable_return_is_error = "Can't parse a TabArray" [[object]] name = "Pango.Variant" status = "generate" [[object.member]] name = "all_small_caps" version = "1.50" [[object.member]] name = "petite_caps" version = "1.50" [[object.member]] name = "all_petite_caps" version = "1.50" [[object.member]] name = "unicase" version = "1.50" [[object.member]] name = "title_caps" version = "1.50" rust-pango-0.18-0.18.3/LICENSE000066400000000000000000000020001467502016100152650ustar00rootroot00000000000000Permission 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. rust-pango-0.18-0.18.3/README.md000066400000000000000000000024521467502016100155520ustar00rootroot00000000000000# Rust Pango bindings __Rust__ bindings and wrappers for [Pango](https://docs.gtk.org/Pango/), part of [gtk-rs-core](https://github.com/gtk-rs/gtk-rs-core). Pango __1.40__ is the lowest supported version for the underlying library. ## Minimum supported Rust version Currently, the minimum supported Rust version is `1.70.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. rust-pango-0.18-0.18.3/src/000077500000000000000000000000001467502016100150575ustar00rootroot00000000000000rust-pango-0.18-0.18.3/src/analysis.rs000066400000000000000000000027141467502016100172540ustar00rootroot00000000000000// Take a look at the license at the top of the repository in the LICENSE file. use std::fmt; use glib::translate::*; use crate::{Attribute, Font, Gravity, Language, Script}; glib::wrapper! { #[doc(alias = "PangoAnalysis")] pub struct Analysis(BoxedInline); } impl Analysis { #[inline] pub fn font(&self) -> Font { unsafe { from_glib_none(self.inner.font) } } #[inline] pub fn level(&self) -> u8 { self.inner.level } #[inline] pub fn gravity(&self) -> Gravity { unsafe { from_glib(self.inner.gravity as i32) } } #[inline] pub fn flags(&self) -> u8 { self.inner.flags } #[inline] pub fn script(&self) -> Script { unsafe { from_glib(self.inner.script as i32) } } #[inline] pub fn language(&self) -> Language { unsafe { from_glib_none(self.inner.language) } } pub fn extra_attrs(&self) -> Vec { unsafe { FromGlibPtrContainer::from_glib_none(self.inner.extra_attrs) } } } impl fmt::Debug for Analysis { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.debug_struct("Analysis") .field("font", &self.font()) .field("level", &self.level()) .field("gravity", &self.gravity()) .field("flags", &self.flags()) .field("script", &self.script()) .field("extra_attrs", &self.extra_attrs()) .finish() } } rust-pango-0.18-0.18.3/src/attr_class.rs000066400000000000000000000032701467502016100175660ustar00rootroot00000000000000// Take a look at the license at the top of the repository in the LICENSE file. use std::marker::PhantomData; use glib::translate::*; use crate::AttrType; #[doc(hidden)] impl<'a> ToGlibPtr<'a, *mut ffi::PangoAttrClass> for &'a AttrClass { type Storage = PhantomData<&'a AttrClass>; #[inline] fn to_glib_none(&self) -> Stash<'a, *mut ffi::PangoAttrClass, Self> { Stash(self.0, PhantomData) } } #[doc(hidden)] impl FromGlibPtrNone<*mut ffi::PangoAttrClass> for AttrClass { #[inline] unsafe fn from_glib_none(ptr: *mut ffi::PangoAttrClass) -> Self { debug_assert!(!ptr.is_null()); Self(ptr) } } #[doc(hidden)] impl FromGlibPtrFull<*mut ffi::PangoAttrClass> for AttrClass { #[inline] unsafe fn from_glib_full(ptr: *mut ffi::PangoAttrClass) -> Self { debug_assert!(!ptr.is_null()); Self(ptr) } } #[doc(hidden)] impl FromGlibPtrNone<*const ffi::PangoAttrClass> for AttrClass { #[inline] unsafe fn from_glib_none(ptr: *const ffi::PangoAttrClass) -> Self { debug_assert!(!ptr.is_null()); Self(ptr as *mut _) } } #[doc(hidden)] impl FromGlibPtrFull<*const ffi::PangoAttrClass> for AttrClass { #[inline] unsafe fn from_glib_full(ptr: *const ffi::PangoAttrClass) -> Self { debug_assert!(!ptr.is_null()); Self(ptr as *mut _) } } #[doc(alias = "PangoAttrClass")] pub struct AttrClass(*mut ffi::PangoAttrClass); impl AttrClass { #[inline] pub fn type_(&self) -> AttrType { unsafe { from_glib((*self.0).type_) } } } impl PartialEq for AttrClass { #[inline] fn eq(&self, other: &AttrClass) -> bool { self.0 == other.0 } } impl Eq for AttrClass {} rust-pango-0.18-0.18.3/src/attr_color.rs000066400000000000000000000032461467502016100176020ustar00rootroot00000000000000// Take a look at the license at the top of the repository in the LICENSE file. use glib::translate::*; use crate::{AttrType, Color}; define_attribute_struct!( AttrColor, ffi::PangoAttrColor, &[ AttrType::Foreground, AttrType::Background, AttrType::UnderlineColor, AttrType::StrikethroughColor, AttrType::OverlineColor ] ); impl AttrColor { #[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_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)) } } #[cfg(feature = "v1_46")] #[cfg_attr(docsrs, 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)) } } #[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_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)) } } pub fn color(&self) -> Color { unsafe { from_glib_none((&self.inner.color) as *const ffi::PangoColor) } } } rust-pango-0.18-0.18.3/src/attr_float.rs000066400000000000000000000014651467502016100175720ustar00rootroot00000000000000// Take a look at the license at the top of the repository in the LICENSE file. use glib::translate::*; use crate::AttrType; define_attribute_struct!( AttrFloat, ffi::PangoAttrFloat, &[ AttrType::Scale, #[cfg(feature = "v1_50")] AttrType::LineHeight ] ); impl AttrFloat { #[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(feature = "v1_50")] #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))] #[doc(alias = "pango_attr_line_height_new")] pub fn new_line_height(factor: f64) -> Self { unsafe { from_glib_full(ffi::pango_attr_line_height_new(factor)) } } pub fn value(&self) -> f64 { self.inner.value } } rust-pango-0.18-0.18.3/src/attr_font_desc.rs000066400000000000000000000010451467502016100204230ustar00rootroot00000000000000// Take a look at the license at the top of the repository in the LICENSE file. use glib::translate::*; use crate::{AttrType, FontDescription}; define_attribute_struct!(AttrFontDesc, ffi::PangoAttrFontDesc, &[AttrType::FontDesc]); impl AttrFontDesc { #[doc(alias = "pango_attr_font_desc_new")] pub fn new(desc: &FontDescription) -> Self { unsafe { from_glib_full(ffi::pango_attr_font_desc_new(desc.to_glib_none().0)) } } pub fn desc(&self) -> FontDescription { unsafe { from_glib_none(self.inner.desc) } } } rust-pango-0.18-0.18.3/src/attr_font_features.rs000066400000000000000000000010721467502016100213230ustar00rootroot00000000000000// Take a look at the license at the top of the repository in the LICENSE file. use glib::translate::*; use crate::AttrType; define_attribute_struct!( AttrFontFeatures, ffi::PangoAttrFontFeatures, &[AttrType::FontFeatures] ); impl AttrFontFeatures { #[doc(alias = "pango_attr_font_features_new")] pub fn new(features: &str) -> Self { unsafe { from_glib_full(ffi::pango_attr_font_features_new(features.to_glib_none().0)) } } pub fn features(&self) -> glib::GString { unsafe { from_glib_none(self.inner.features) } } } rust-pango-0.18-0.18.3/src/attr_int.rs000066400000000000000000000123601467502016100172530ustar00rootroot00000000000000// Take a look at the license at the top of the repository in the LICENSE file. use glib::translate::*; #[cfg(feature = "v1_50")] use crate::FontScale; #[cfg(feature = "v1_46")] use crate::Overline; #[cfg(feature = "v1_44")] use crate::ShowFlags; use crate::{AttrType, Gravity, GravityHint, Stretch, Style, Underline, Variant, Weight}; define_attribute_struct!( AttrInt, ffi::PangoAttrInt, &[ #[cfg(feature = "v1_50")] AttrType::AbsoluteLineHeight, #[cfg(feature = "v1_50")] AttrType::FontScale, AttrType::AllowBreaks, AttrType::BackgroundAlpha, AttrType::Fallback, AttrType::ForegroundAlpha, AttrType::Gravity, AttrType::GravityHint, AttrType::InsertHyphens, AttrType::LetterSpacing, AttrType::Overline, AttrType::Rise, AttrType::Show, AttrType::Stretch, AttrType::Strikethrough, AttrType::Style, AttrType::Underline, AttrType::Variant, AttrType::Weight ] ); impl AttrInt { #[cfg(feature = "v1_50")] #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))] #[doc(alias = "pango_attr_line_height_new_absolute")] pub fn new_line_height_absolute(height: i32) -> Self { unsafe { from_glib_full(ffi::pango_attr_line_height_new_absolute(height)) } } #[cfg(feature = "v1_50")] #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))] #[doc(alias = "pango_attr_font_scale_new")] pub fn new_font_scale(scale: FontScale) -> Self { unsafe { from_glib_full(ffi::pango_attr_font_scale_new(scale.into_glib())) } } #[cfg(feature = "v1_44")] #[cfg_attr(docsrs, 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_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_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_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_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_gravity_new")] pub fn new_gravity(gravity: Gravity) -> Self { unsafe { from_glib_full(ffi::pango_attr_gravity_new(gravity.into_glib())) } } #[cfg(feature = "v1_44")] #[cfg_attr(docsrs, 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(feature = "v1_46")] #[cfg_attr(docsrs, 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)) } } #[cfg(feature = "v1_44")] #[cfg_attr(docsrs, 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_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_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_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())) } } pub fn value(&self) -> i32 { self.inner.value } } rust-pango-0.18-0.18.3/src/attr_iterator.rs000066400000000000000000000153201467502016100203110ustar00rootroot00000000000000// Take a look at the license at the top of the repository in the LICENSE file. use std::{marker::PhantomData, mem, ptr}; use glib::{translate::*, SList}; use crate::{AttrType, Attribute, FontDescription, Language}; #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct AttrIterator<'list> { ptr: ptr::NonNull, list: PhantomData<&'list crate::AttrList>, } impl<'list> Clone for AttrIterator<'list> { #[inline] fn clone(&self) -> Self { let ptr = unsafe { ptr::NonNull::new_unchecked(ffi::pango_attr_iterator_copy(self.ptr.as_ptr())) }; Self { ptr, list: PhantomData, } } } impl<'list> Drop for AttrIterator<'list> { #[inline] fn drop(&mut self) { unsafe { ffi::pango_attr_iterator_destroy(self.ptr.as_ptr()); } } } #[cfg(feature = "v1_44")] #[cfg_attr(docsrs, doc(cfg(feature = "v1_44")))] impl<'list> glib::StaticType for AttrIterator<'list> { #[inline] fn static_type() -> glib::Type { unsafe { from_glib(ffi::pango_attr_iterator_get_type()) } } } impl<'list> AttrIterator<'list> { #[doc(alias = "pango_attr_iterator_get")] pub fn get(&self, type_: AttrType) -> Option { unsafe { from_glib_none(ffi::pango_attr_iterator_get( mut_override(self.to_glib_none().0), type_.into_glib(), )) } } #[doc(alias = "pango_attr_iterator_get_attrs")] #[doc(alias = "get_attrs")] pub fn attrs(&self) -> SList { unsafe { FromGlibPtrContainer::from_glib_full(ffi::pango_attr_iterator_get_attrs(mut_override( self.to_glib_none().0, ))) } } #[doc(alias = "pango_attr_iterator_next")] pub fn next_style_change(&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(&self) -> (i32, i32) { unsafe { let mut start = mem::MaybeUninit::uninit(); let mut end = mem::MaybeUninit::uninit(); ffi::pango_attr_iterator_range( mut_override(self.to_glib_none().0), start.as_mut_ptr(), end.as_mut_ptr(), ); let start = start.assume_init(); let end = end.assume_init(); (start, end) } } #[doc(alias = "pango_attr_iterator_get_font")] #[doc(alias = "get_font")] pub fn font(&self) -> (FontDescription, Option, SList) { unsafe { let desc = FontDescription::new(); let mut language = mem::MaybeUninit::uninit(); let mut extra_attrs = mem::MaybeUninit::uninit(); ffi::pango_attr_iterator_get_font( mut_override(self.to_glib_none().0), mut_override(desc.to_glib_none().0), language.as_mut_ptr(), extra_attrs.as_mut_ptr(), ); ( desc, from_glib_full(language.assume_init()), FromGlibPtrContainer::from_glib_full(extra_attrs.assume_init()), ) } } } impl<'list> IntoIterator for AttrIterator<'list> { type Item = SList; type IntoIter = AttrIntoIter<'list>; #[inline] fn into_iter(self) -> Self::IntoIter { AttrIntoIter(Some(self)) } } #[derive(Clone, Debug)] #[repr(transparent)] pub struct AttrIntoIter<'list>(Option>); impl<'list> Iterator for AttrIntoIter<'list> { type Item = SList; #[inline] fn next(&mut self) -> Option { if let Some(iter) = &mut self.0 { let attrs = iter.attrs(); if !iter.next_style_change() { self.0 = None; } Some(attrs) } else { None } } } impl<'list> std::iter::FusedIterator for AttrIntoIter<'list> {} #[doc(hidden)] impl<'a, 'list> ToGlibPtr<'a, *const ffi::PangoAttrIterator> for AttrIterator<'list> where 'list: 'a, { type Storage = PhantomData<&'a Self>; #[inline] fn to_glib_none(&'a self) -> Stash<'a, *const ffi::PangoAttrIterator, Self> { Stash(self.ptr.as_ptr() as *const _, PhantomData) } } #[doc(hidden)] impl<'a, 'list> ToGlibPtrMut<'a, *mut ffi::PangoAttrIterator> for AttrIterator<'list> where 'list: 'a, { type Storage = PhantomData<&'a mut Self>; #[inline] fn to_glib_none_mut(&'a mut self) -> StashMut<'a, *mut ffi::PangoAttrIterator, Self> { StashMut(self.ptr.as_ptr(), PhantomData) } } #[doc(hidden)] impl<'list> FromGlibPtrFull<*mut ffi::PangoAttrIterator> for AttrIterator<'list> { #[inline] unsafe fn from_glib_full(ptr: *mut ffi::PangoAttrIterator) -> Self { Self { ptr: ptr::NonNull::new_unchecked(ptr), list: PhantomData, } } } #[cfg(test)] mod tests { #[test] fn attr_iterator() { let default_lang = crate::Language::default(); let attributes = crate::AttrList::new(); attributes.insert(crate::AttrColor::new_foreground(0x2000, 0x2000, 0x2000)); attributes.insert(crate::AttrSize::new(10 * crate::SCALE)); attributes.insert(crate::AttrLanguage::new(&default_lang)); let iter = attributes.iterator(); { let mut iter = iter.clone(); loop { let (desc, lang, attrs) = iter.font(); if !attrs.is_empty() { assert_eq!(desc.size(), 10 * crate::SCALE); assert_eq!(lang.map(|l| l.to_string()), Some(default_lang.to_string())); } for attr in attrs { attr.downcast_ref::().unwrap(); } if !iter.next_style_change() { break; } } } let mut max = 0; for (i, mut attrs) in iter.into_iter().enumerate() { if i == 0 { attrs .pop_front() .unwrap() .downcast_ref::() .unwrap(); attrs .pop_front() .unwrap() .downcast_ref::() .unwrap(); attrs .pop_front() .unwrap() .downcast_ref::() .unwrap(); assert!(attrs.is_empty()); } max = i + 1; } // ensure the list was iterated assert!(max > 0); } } rust-pango-0.18-0.18.3/src/attr_language.rs000066400000000000000000000011311467502016100202360ustar00rootroot00000000000000// Take a look at the license at the top of the repository in the LICENSE file. use glib::translate::*; use crate::{AttrType, Language}; define_attribute_struct!(AttrLanguage, ffi::PangoAttrLanguage, &[AttrType::Language]); impl AttrLanguage { #[doc(alias = "pango_attr_language_new")] pub fn new(language: &Language) -> Self { unsafe { from_glib_full(ffi::pango_attr_language_new(mut_override( language.to_glib_none().0, ))) } } pub fn value(&self) -> Language { unsafe { from_glib_none(self.inner.value) } } } rust-pango-0.18-0.18.3/src/attr_list.rs000066400000000000000000000037661467502016100174460ustar00rootroot00000000000000// Take a look at the license at the top of the repository in the LICENSE file. use std::mem; use glib::translate::*; use crate::{AttrList, Attribute}; impl AttrList { #[doc(alias = "pango_attr_list_change")] pub fn change(&self, attr: impl Into) { unsafe { let attr = attr.into(); ffi::pango_attr_list_change(self.to_glib_none().0, attr.to_glib_none().0); mem::forget(attr); //As attr transferred fully } } #[cfg(feature = "v1_46")] #[cfg_attr(docsrs, 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: impl Into) { unsafe { let attr = attr.into(); ffi::pango_attr_list_insert(self.to_glib_none().0, attr.to_glib_none().0); mem::forget(attr); //As attr transferred fully } } #[doc(alias = "pango_attr_list_insert_before")] pub fn insert_before(&self, attr: impl Into) { unsafe { let attr = attr.into(); ffi::pango_attr_list_insert_before(self.to_glib_none().0, attr.to_glib_none().0); mem::forget(attr); //As attr transferred fully } } } #[cfg(feature = "v1_46")] #[cfg_attr(docsrs, doc(cfg(feature = "v1_46")))] impl PartialEq for AttrList { #[inline] fn eq(&self, other: &Self) -> bool { self.equal(other) } } #[cfg(feature = "v1_46")] #[cfg_attr(docsrs, doc(cfg(feature = "v1_46")))] impl Eq for AttrList {} #[cfg(feature = "v1_50")] #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))] impl std::str::FromStr for AttrList { type Err = glib::BoolError; fn from_str(s: &str) -> Result { Self::from_string(s) } } rust-pango-0.18-0.18.3/src/attr_shape.rs000066400000000000000000000014251467502016100175610ustar00rootroot00000000000000// Take a look at the license at the top of the repository in the LICENSE file. use glib::translate::*; use crate::{AttrType, Rectangle}; define_attribute_struct!(AttrShape, ffi::PangoAttrShape, &[AttrType::Shape]); impl AttrShape { #[doc(alias = "pango_attr_shape_new")] pub fn new(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, )) } } pub fn ink_rect(&self) -> Rectangle { unsafe { from_glib_none(&self.inner.ink_rect as *const _) } } pub fn logical_rect(&self) -> Rectangle { unsafe { from_glib_none(&self.inner.logical_rect as *const _) } } } rust-pango-0.18-0.18.3/src/attr_size.rs000066400000000000000000000013651467502016100174360ustar00rootroot00000000000000// Take a look at the license at the top of the repository in the LICENSE file. use glib::translate::*; use crate::AttrType; define_attribute_struct!( AttrSize, ffi::PangoAttrSize, &[AttrType::Size, AttrType::AbsoluteSize] ); impl AttrSize { #[doc(alias = "pango_attr_size_new")] pub fn new(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)) } } pub fn size(&self) -> i32 { self.inner.size } pub fn absolute(&self) -> bool { unsafe { from_glib(self.inner.absolute as i32) } } } rust-pango-0.18-0.18.3/src/attr_string.rs000066400000000000000000000010031467502016100177570ustar00rootroot00000000000000// Take a look at the license at the top of the repository in the LICENSE file. use glib::translate::*; use crate::AttrType; define_attribute_struct!(AttrString, ffi::PangoAttrString, &[AttrType::Family]); impl AttrString { #[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)) } } pub fn value(&self) -> glib::GString { unsafe { from_glib_none(self.inner.value) } } } rust-pango-0.18-0.18.3/src/attribute.rs000066400000000000000000000133031467502016100174300ustar00rootroot00000000000000// Take a look at the license at the top of the repository in the LICENSE file. use glib::translate::*; use crate::{AttrClass, AttrType, Attribute}; impl Attribute { #[doc(alias = "get_attr_class")] #[inline] pub fn attr_class(&self) -> AttrClass { unsafe { from_glib_none((*self.as_ptr()).klass) } } #[inline] pub fn type_(&self) -> AttrType { unsafe { from_glib((*(*self.as_ptr()).klass).type_) } } #[doc(alias = "get_start_index")] #[inline] pub fn start_index(&self) -> u32 { unsafe { (*self.as_ptr()).start_index } } #[doc(alias = "get_end_index")] #[inline] pub fn end_index(&self) -> u32 { unsafe { (*self.as_ptr()).end_index } } #[inline] pub fn set_start_index(&mut self, index: u32) { unsafe { (*self.as_ptr()).start_index = index; } } #[inline] pub fn set_end_index(&mut self, index: u32) { unsafe { (*self.as_ptr()).end_index = index; } } #[inline] pub fn downcast(self) -> Result { unsafe { if T::ATTR_TYPES.contains(&self.attr_class().type_()) { Ok(from_glib_full(glib::translate::IntoGlibPtr::< *mut ffi::PangoAttribute, >::into_glib_ptr(self))) } else { Err(self) } } } #[inline] 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 } } } } #[allow(clippy::missing_safety_doc)] 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(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(), } } unsafe impl Send for $rust_type {} unsafe impl Sync for $rust_type {} #[cfg(not(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), } } impl $rust_type { #[doc(alias = "pango_attribute_equal")] fn equal(&self, attr2: &T) -> bool { unsafe { glib::translate::from_glib(ffi::pango_attribute_equal(self.as_ptr() as *const ffi::PangoAttribute, glib::translate::ToGlibPtr::to_glib_none(attr2.upcast_ref()).0, )) } } } impl PartialEq for $rust_type { #[inline] fn eq(&self, other: &Self) -> bool { self.equal(other) } } impl Eq for $rust_type {} unsafe impl crate::attribute::IsAttribute for $rust_type { const ATTR_TYPES: &'static [crate::AttrType] = $attr_types; #[inline] fn upcast(self) -> crate::Attribute { unsafe { glib::translate::from_glib_full(glib::translate::IntoGlibPtr::<*mut $ffi_type>::into_glib_ptr(self) as *mut ffi::PangoAttribute) } } #[inline] fn upcast_ref(&self) -> &crate::Attribute { &*self } } #[doc(hidden)] impl glib::translate::FromGlibPtrFull<*mut ffi::PangoAttribute> for $rust_type { #[inline] unsafe fn from_glib_full(ptr: *mut ffi::PangoAttribute) -> Self { glib::translate::from_glib_full(ptr as *mut $ffi_type) } } #[doc(hidden)] impl glib::translate::FromGlibPtrFull<*const ffi::PangoAttribute> for $rust_type { #[inline] unsafe fn from_glib_full(ptr: *const ffi::PangoAttribute) -> Self { glib::translate::from_glib_full(ptr as *const $ffi_type) } } impl std::convert::AsRef for $rust_type { #[inline] fn as_ref(&self) -> &crate::Attribute { &*self } } impl From<$rust_type> for crate::Attribute { #[inline] fn from(attr: $rust_type) -> crate::Attribute { crate::IsAttribute::upcast(attr) } } impl std::ops::Deref for $rust_type { type Target = crate::Attribute; #[inline] fn deref(&self) -> &Self::Target { unsafe { &*(self as *const $rust_type as *const crate::Attribute) } } } impl std::ops::DerefMut for $rust_type { #[inline] fn deref_mut(&mut self) -> &mut crate::Attribute { unsafe { &mut *(self as *mut $rust_type as *mut crate::Attribute) } } } } } rust-pango-0.18-0.18.3/src/auto/000077500000000000000000000000001467502016100160275ustar00rootroot00000000000000rust-pango-0.18-0.18.3/src/auto/alias.rs000066400000000000000000000005471467502016100174740ustar00rootroot00000000000000// 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::*; #[doc(alias = "PangoGlyph")] pub type Glyph = u32; #[doc(alias = "PangoGlyphUnit")] pub type GlyphUnit = i32; #[doc(alias = "PangoLayoutRun")] pub type LayoutRun = GlyphItem; rust-pango-0.18-0.18.3/src/auto/attr_list.rs000066400000000000000000000076521467502016100204140ustar00rootroot00000000000000// 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, Attribute}; use glib::translate::*; #[cfg(feature = "v1_50")] #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))] use std::fmt; 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")] #[must_use] 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")] #[must_use] 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; (*callback)(&attribute).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(feature = "v1_44")] #[cfg_attr(docsrs, 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) -> AttrIterator { 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(feature = "v1_50")] #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))] #[doc(alias = "pango_attr_list_to_string")] #[doc(alias = "to_string")] pub fn to_str(&self) -> glib::GString { unsafe { from_glib_full(ffi::pango_attr_list_to_string(self.to_glib_none().0)) } } #[cfg(feature = "v1_44")] #[cfg_attr(docsrs, 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); } } #[cfg(feature = "v1_50")] #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))] #[doc(alias = "pango_attr_list_from_string")] pub fn from_string(text: &str) -> Result { unsafe { Option::<_>::from_glib_full(ffi::pango_attr_list_from_string(text.to_glib_none().0)) .ok_or_else(|| glib::bool_error!("Can't parse AttrList")) } } } impl Default for AttrList { fn default() -> Self { Self::new() } } #[cfg(feature = "v1_50")] #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))] impl fmt::Display for AttrList { #[inline] fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.write_str(&self.to_str()) } } rust-pango-0.18-0.18.3/src/auto/attribute.rs000066400000000000000000000024661467502016100204100ustar00rootroot00000000000000// 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::*; #[cfg(feature = "v1_44")] #[cfg_attr(docsrs, 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")))] 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, )) } } } impl PartialEq for Attribute { #[inline] fn eq(&self, other: &Self) -> bool { self.equal(other) } } impl Eq for Attribute {} unsafe impl Send for Attribute {} unsafe impl Sync for Attribute {} rust-pango-0.18-0.18.3/src/auto/color.rs000066400000000000000000000014321467502016100175130ustar00rootroot00000000000000// 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; glib::wrapper! { pub struct Color(BoxedInline); 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_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()) } } rust-pango-0.18-0.18.3/src/auto/context.rs000066400000000000000000000164311467502016100200660ustar00rootroot00000000000000// 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, Font, FontDescription, FontFamily, FontMap, FontMetrics, Fontset, Gravity, GravityHint, Language, Matrix, }; use glib::{prelude::*, translate::*}; use std::{fmt, mem, 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_none(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>, ) -> FontMetrics { 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(feature = "v1_44")] #[cfg_attr(docsrs, 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 _) } } #[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: Option<&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: Option<&impl IsA>) { unsafe { ffi::pango_context_set_font_map( self.to_glib_none().0, font_map.map(|p| p.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: Option<&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(feature = "v1_44")] #[cfg_attr(docsrs, 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") } } rust-pango-0.18-0.18.3/src/auto/enums.rs000066400000000000000000003367371467502016100175470ustar00rootroot00000000000000// 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, Matrix}; use glib::{prelude::*, translate::*}; 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; #[inline] 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 { #[inline] 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 { #[inline] #[doc(alias = "pango_alignment_get_type")] fn static_type() -> glib::Type { unsafe { from_glib(ffi::pango_alignment_get_type()) } } } impl glib::HasParamSpec for Alignment { type ParamSpec = glib::ParamSpecEnum; type SetValue = Self; type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder; fn param_spec_builder() -> Self::BuilderFn { Self::ParamSpec::builder_with_default } } impl glib::value::ValueType for Alignment { type Type = Self; } unsafe impl<'a> glib::value::FromValue<'a> for Alignment { type Checker = glib::value::GenericValueTypeChecker; #[inline] 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 { #[inline] fn to_value(&self) -> glib::Value { let mut value = glib::Value::for_value_type::(); unsafe { glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); } value } #[inline] fn value_type(&self) -> glib::Type { Self::static_type() } } impl From for glib::Value { #[inline] fn from(v: Alignment) -> Self { ToValue::to_value(&v) } } #[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, #[cfg(feature = "v1_50")] #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))] #[doc(alias = "PANGO_ATTR_LINE_HEIGHT")] LineHeight, #[cfg(feature = "v1_50")] #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))] #[doc(alias = "PANGO_ATTR_ABSOLUTE_LINE_HEIGHT")] AbsoluteLineHeight, #[cfg(feature = "v1_50")] #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))] #[doc(alias = "PANGO_ATTR_TEXT_TRANSFORM")] TextTransform, #[cfg(feature = "v1_50")] #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))] #[doc(alias = "PANGO_ATTR_WORD")] Word, #[cfg(feature = "v1_50")] #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))] #[doc(alias = "PANGO_ATTR_SENTENCE")] Sentence, #[cfg(feature = "v1_50")] #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))] #[doc(alias = "PANGO_ATTR_BASELINE_SHIFT")] BaselineShift, #[cfg(feature = "v1_50")] #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))] #[doc(alias = "PANGO_ATTR_FONT_SCALE")] FontScale, #[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", #[cfg(feature = "v1_50")] Self::LineHeight => "LineHeight", #[cfg(feature = "v1_50")] Self::AbsoluteLineHeight => "AbsoluteLineHeight", #[cfg(feature = "v1_50")] Self::TextTransform => "TextTransform", #[cfg(feature = "v1_50")] Self::Word => "Word", #[cfg(feature = "v1_50")] Self::Sentence => "Sentence", #[cfg(feature = "v1_50")] Self::BaselineShift => "BaselineShift", #[cfg(feature = "v1_50")] Self::FontScale => "FontScale", _ => "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, #[cfg(feature = "v1_50")] Self::LineHeight => ffi::PANGO_ATTR_LINE_HEIGHT, #[cfg(feature = "v1_50")] Self::AbsoluteLineHeight => ffi::PANGO_ATTR_ABSOLUTE_LINE_HEIGHT, #[cfg(feature = "v1_50")] Self::TextTransform => ffi::PANGO_ATTR_TEXT_TRANSFORM, #[cfg(feature = "v1_50")] Self::Word => ffi::PANGO_ATTR_WORD, #[cfg(feature = "v1_50")] Self::Sentence => ffi::PANGO_ATTR_SENTENCE, #[cfg(feature = "v1_50")] Self::BaselineShift => ffi::PANGO_ATTR_BASELINE_SHIFT, #[cfg(feature = "v1_50")] Self::FontScale => ffi::PANGO_ATTR_FONT_SCALE, 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, #[cfg(feature = "v1_50")] ffi::PANGO_ATTR_LINE_HEIGHT => Self::LineHeight, #[cfg(feature = "v1_50")] ffi::PANGO_ATTR_ABSOLUTE_LINE_HEIGHT => Self::AbsoluteLineHeight, #[cfg(feature = "v1_50")] ffi::PANGO_ATTR_TEXT_TRANSFORM => Self::TextTransform, #[cfg(feature = "v1_50")] ffi::PANGO_ATTR_WORD => Self::Word, #[cfg(feature = "v1_50")] ffi::PANGO_ATTR_SENTENCE => Self::Sentence, #[cfg(feature = "v1_50")] ffi::PANGO_ATTR_BASELINE_SHIFT => Self::BaselineShift, #[cfg(feature = "v1_50")] ffi::PANGO_ATTR_FONT_SCALE => Self::FontScale, value => Self::__Unknown(value), } } } impl StaticType for AttrType { #[inline] #[doc(alias = "pango_attr_type_get_type")] fn static_type() -> glib::Type { unsafe { from_glib(ffi::pango_attr_type_get_type()) } } } impl glib::HasParamSpec for AttrType { type ParamSpec = glib::ParamSpecEnum; type SetValue = Self; type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder; fn param_spec_builder() -> Self::BuilderFn { Self::ParamSpec::builder_with_default } } impl glib::value::ValueType for AttrType { type Type = Self; } unsafe impl<'a> glib::value::FromValue<'a> for AttrType { type Checker = glib::value::GenericValueTypeChecker; #[inline] 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 { #[inline] fn to_value(&self) -> glib::Value { let mut value = glib::Value::for_value_type::(); unsafe { glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); } value } #[inline] fn value_type(&self) -> glib::Type { Self::static_type() } } impl From for glib::Value { #[inline] fn from(v: AttrType) -> Self { ToValue::to_value(&v) } } #[cfg(feature = "v1_50")] #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))] #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] #[non_exhaustive] #[doc(alias = "PangoBaselineShift")] pub enum BaselineShift { #[doc(alias = "PANGO_BASELINE_SHIFT_NONE")] None, #[doc(alias = "PANGO_BASELINE_SHIFT_SUPERSCRIPT")] Superscript, #[doc(alias = "PANGO_BASELINE_SHIFT_SUBSCRIPT")] Subscript, #[doc(hidden)] __Unknown(i32), } #[cfg(feature = "v1_50")] #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))] impl fmt::Display for BaselineShift { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, "BaselineShift::{}", match *self { Self::None => "None", Self::Superscript => "Superscript", Self::Subscript => "Subscript", _ => "Unknown", } ) } } #[cfg(feature = "v1_50")] #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))] #[doc(hidden)] impl IntoGlib for BaselineShift { type GlibType = ffi::PangoBaselineShift; #[inline] fn into_glib(self) -> ffi::PangoBaselineShift { match self { Self::None => ffi::PANGO_BASELINE_SHIFT_NONE, Self::Superscript => ffi::PANGO_BASELINE_SHIFT_SUPERSCRIPT, Self::Subscript => ffi::PANGO_BASELINE_SHIFT_SUBSCRIPT, Self::__Unknown(value) => value, } } } #[cfg(feature = "v1_50")] #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))] #[doc(hidden)] impl FromGlib for BaselineShift { #[inline] unsafe fn from_glib(value: ffi::PangoBaselineShift) -> Self { match value { ffi::PANGO_BASELINE_SHIFT_NONE => Self::None, ffi::PANGO_BASELINE_SHIFT_SUPERSCRIPT => Self::Superscript, ffi::PANGO_BASELINE_SHIFT_SUBSCRIPT => Self::Subscript, value => Self::__Unknown(value), } } } #[cfg(feature = "v1_50")] #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))] impl StaticType for BaselineShift { #[inline] #[doc(alias = "pango_baseline_shift_get_type")] fn static_type() -> glib::Type { unsafe { from_glib(ffi::pango_baseline_shift_get_type()) } } } #[cfg(feature = "v1_50")] #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))] impl glib::HasParamSpec for BaselineShift { type ParamSpec = glib::ParamSpecEnum; type SetValue = Self; type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder; fn param_spec_builder() -> Self::BuilderFn { Self::ParamSpec::builder_with_default } } #[cfg(feature = "v1_50")] #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))] impl glib::value::ValueType for BaselineShift { type Type = Self; } #[cfg(feature = "v1_50")] #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))] unsafe impl<'a> glib::value::FromValue<'a> for BaselineShift { type Checker = glib::value::GenericValueTypeChecker; #[inline] unsafe fn from_value(value: &'a glib::Value) -> Self { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) } } #[cfg(feature = "v1_50")] #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))] impl ToValue for BaselineShift { #[inline] fn to_value(&self) -> glib::Value { let mut value = glib::Value::for_value_type::(); unsafe { glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); } value } #[inline] fn value_type(&self) -> glib::Type { Self::static_type() } } #[cfg(feature = "v1_50")] #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))] impl From for glib::Value { #[inline] fn from(v: BaselineShift) -> Self { ToValue::to_value(&v) } } #[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(alias = "PANGO_BIDI_TYPE_LRI")] Lri, #[doc(alias = "PANGO_BIDI_TYPE_RLI")] Rli, #[doc(alias = "PANGO_BIDI_TYPE_FSI")] Fsi, #[doc(alias = "PANGO_BIDI_TYPE_PDI")] Pdi, #[doc(hidden)] __Unknown(i32), } #[allow(deprecated)] 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())) } } } #[allow(deprecated)] 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", Self::Lri => "Lri", Self::Rli => "Rli", Self::Fsi => "Fsi", Self::Pdi => "Pdi", _ => "Unknown", } ) } } #[allow(deprecated)] #[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::Lri => ffi::PANGO_BIDI_TYPE_LRI, Self::Rli => ffi::PANGO_BIDI_TYPE_RLI, Self::Fsi => ffi::PANGO_BIDI_TYPE_FSI, Self::Pdi => ffi::PANGO_BIDI_TYPE_PDI, Self::__Unknown(value) => value, } } } #[allow(deprecated)] #[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, ffi::PANGO_BIDI_TYPE_LRI => Self::Lri, ffi::PANGO_BIDI_TYPE_RLI => Self::Rli, ffi::PANGO_BIDI_TYPE_FSI => Self::Fsi, ffi::PANGO_BIDI_TYPE_PDI => Self::Pdi, value => Self::__Unknown(value), } } } #[allow(deprecated)] impl StaticType for BidiType { #[inline] #[doc(alias = "pango_bidi_type_get_type")] fn static_type() -> glib::Type { unsafe { from_glib(ffi::pango_bidi_type_get_type()) } } } #[allow(deprecated)] impl glib::HasParamSpec for BidiType { type ParamSpec = glib::ParamSpecEnum; type SetValue = Self; type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder; fn param_spec_builder() -> Self::BuilderFn { Self::ParamSpec::builder_with_default } } #[allow(deprecated)] impl glib::value::ValueType for BidiType { type Type = Self; } #[allow(deprecated)] unsafe impl<'a> glib::value::FromValue<'a> for BidiType { type Checker = glib::value::GenericValueTypeChecker; #[inline] unsafe fn from_value(value: &'a glib::Value) -> Self { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) } } #[allow(deprecated)] impl ToValue for BidiType { #[inline] fn to_value(&self) -> glib::Value { let mut value = glib::Value::for_value_type::(); unsafe { glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); } value } #[inline] fn value_type(&self) -> glib::Type { Self::static_type() } } #[allow(deprecated)] impl From for glib::Value { #[inline] fn from(v: BidiType) -> Self { ToValue::to_value(&v) } } #[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; #[inline] 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 { #[inline] 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 { #[inline] #[doc(alias = "pango_coverage_level_get_type")] fn static_type() -> glib::Type { unsafe { from_glib(ffi::pango_coverage_level_get_type()) } } } impl glib::HasParamSpec for CoverageLevel { type ParamSpec = glib::ParamSpecEnum; type SetValue = Self; type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder; fn param_spec_builder() -> Self::BuilderFn { Self::ParamSpec::builder_with_default } } impl glib::value::ValueType for CoverageLevel { type Type = Self; } unsafe impl<'a> glib::value::FromValue<'a> for CoverageLevel { type Checker = glib::value::GenericValueTypeChecker; #[inline] 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 { #[inline] fn to_value(&self) -> glib::Value { let mut value = glib::Value::for_value_type::(); unsafe { glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); } value } #[inline] fn value_type(&self) -> glib::Type { Self::static_type() } } impl From for glib::Value { #[inline] fn from(v: CoverageLevel) -> Self { ToValue::to_value(&v) } } #[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; #[inline] 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 { #[inline] 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 { #[inline] #[doc(alias = "pango_direction_get_type")] fn static_type() -> glib::Type { unsafe { from_glib(ffi::pango_direction_get_type()) } } } impl glib::HasParamSpec for Direction { type ParamSpec = glib::ParamSpecEnum; type SetValue = Self; type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder; fn param_spec_builder() -> Self::BuilderFn { Self::ParamSpec::builder_with_default } } impl glib::value::ValueType for Direction { type Type = Self; } unsafe impl<'a> glib::value::FromValue<'a> for Direction { type Checker = glib::value::GenericValueTypeChecker; #[inline] 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 { #[inline] fn to_value(&self) -> glib::Value { let mut value = glib::Value::for_value_type::(); unsafe { glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); } value } #[inline] fn value_type(&self) -> glib::Type { Self::static_type() } } impl From for glib::Value { #[inline] fn from(v: Direction) -> Self { ToValue::to_value(&v) } } #[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; #[inline] 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 { #[inline] 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 { #[inline] #[doc(alias = "pango_ellipsize_mode_get_type")] fn static_type() -> glib::Type { unsafe { from_glib(ffi::pango_ellipsize_mode_get_type()) } } } impl glib::HasParamSpec for EllipsizeMode { type ParamSpec = glib::ParamSpecEnum; type SetValue = Self; type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder; fn param_spec_builder() -> Self::BuilderFn { Self::ParamSpec::builder_with_default } } impl glib::value::ValueType for EllipsizeMode { type Type = Self; } unsafe impl<'a> glib::value::FromValue<'a> for EllipsizeMode { type Checker = glib::value::GenericValueTypeChecker; #[inline] 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 { #[inline] fn to_value(&self) -> glib::Value { let mut value = glib::Value::for_value_type::(); unsafe { glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); } value } #[inline] fn value_type(&self) -> glib::Type { Self::static_type() } } impl From for glib::Value { #[inline] fn from(v: EllipsizeMode) -> Self { ToValue::to_value(&v) } } #[cfg(feature = "v1_50")] #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))] #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] #[non_exhaustive] #[doc(alias = "PangoFontScale")] pub enum FontScale { #[doc(alias = "PANGO_FONT_SCALE_NONE")] None, #[doc(alias = "PANGO_FONT_SCALE_SUPERSCRIPT")] Superscript, #[doc(alias = "PANGO_FONT_SCALE_SUBSCRIPT")] Subscript, #[doc(alias = "PANGO_FONT_SCALE_SMALL_CAPS")] SmallCaps, #[doc(hidden)] __Unknown(i32), } #[cfg(feature = "v1_50")] #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))] impl fmt::Display for FontScale { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, "FontScale::{}", match *self { Self::None => "None", Self::Superscript => "Superscript", Self::Subscript => "Subscript", Self::SmallCaps => "SmallCaps", _ => "Unknown", } ) } } #[cfg(feature = "v1_50")] #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))] #[doc(hidden)] impl IntoGlib for FontScale { type GlibType = ffi::PangoFontScale; #[inline] fn into_glib(self) -> ffi::PangoFontScale { match self { Self::None => ffi::PANGO_FONT_SCALE_NONE, Self::Superscript => ffi::PANGO_FONT_SCALE_SUPERSCRIPT, Self::Subscript => ffi::PANGO_FONT_SCALE_SUBSCRIPT, Self::SmallCaps => ffi::PANGO_FONT_SCALE_SMALL_CAPS, Self::__Unknown(value) => value, } } } #[cfg(feature = "v1_50")] #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))] #[doc(hidden)] impl FromGlib for FontScale { #[inline] unsafe fn from_glib(value: ffi::PangoFontScale) -> Self { match value { ffi::PANGO_FONT_SCALE_NONE => Self::None, ffi::PANGO_FONT_SCALE_SUPERSCRIPT => Self::Superscript, ffi::PANGO_FONT_SCALE_SUBSCRIPT => Self::Subscript, ffi::PANGO_FONT_SCALE_SMALL_CAPS => Self::SmallCaps, value => Self::__Unknown(value), } } } #[cfg(feature = "v1_50")] #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))] impl StaticType for FontScale { #[inline] #[doc(alias = "pango_font_scale_get_type")] fn static_type() -> glib::Type { unsafe { from_glib(ffi::pango_font_scale_get_type()) } } } #[cfg(feature = "v1_50")] #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))] impl glib::HasParamSpec for FontScale { type ParamSpec = glib::ParamSpecEnum; type SetValue = Self; type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder; fn param_spec_builder() -> Self::BuilderFn { Self::ParamSpec::builder_with_default } } #[cfg(feature = "v1_50")] #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))] impl glib::value::ValueType for FontScale { type Type = Self; } #[cfg(feature = "v1_50")] #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))] unsafe impl<'a> glib::value::FromValue<'a> for FontScale { type Checker = glib::value::GenericValueTypeChecker; #[inline] unsafe fn from_value(value: &'a glib::Value) -> Self { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) } } #[cfg(feature = "v1_50")] #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))] impl ToValue for FontScale { #[inline] fn to_value(&self) -> glib::Value { let mut value = glib::Value::for_value_type::(); unsafe { glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); } value } #[inline] fn value_type(&self) -> glib::Type { Self::static_type() } } #[cfg(feature = "v1_50")] #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))] impl From for glib::Value { #[inline] fn from(v: FontScale) -> Self { ToValue::to_value(&v) } } #[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; #[inline] 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 { #[inline] 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 { #[inline] #[doc(alias = "pango_gravity_get_type")] fn static_type() -> glib::Type { unsafe { from_glib(ffi::pango_gravity_get_type()) } } } impl glib::HasParamSpec for Gravity { type ParamSpec = glib::ParamSpecEnum; type SetValue = Self; type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder; fn param_spec_builder() -> Self::BuilderFn { Self::ParamSpec::builder_with_default } } impl glib::value::ValueType for Gravity { type Type = Self; } unsafe impl<'a> glib::value::FromValue<'a> for Gravity { type Checker = glib::value::GenericValueTypeChecker; #[inline] 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 { #[inline] fn to_value(&self) -> glib::Value { let mut value = glib::Value::for_value_type::(); unsafe { glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); } value } #[inline] fn value_type(&self) -> glib::Type { Self::static_type() } } impl From for glib::Value { #[inline] fn from(v: Gravity) -> Self { ToValue::to_value(&v) } } #[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; #[inline] 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 { #[inline] 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 { #[inline] #[doc(alias = "pango_gravity_hint_get_type")] fn static_type() -> glib::Type { unsafe { from_glib(ffi::pango_gravity_hint_get_type()) } } } impl glib::HasParamSpec for GravityHint { type ParamSpec = glib::ParamSpecEnum; type SetValue = Self; type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder; fn param_spec_builder() -> Self::BuilderFn { Self::ParamSpec::builder_with_default } } impl glib::value::ValueType for GravityHint { type Type = Self; } unsafe impl<'a> glib::value::FromValue<'a> for GravityHint { type Checker = glib::value::GenericValueTypeChecker; #[inline] 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 { #[inline] fn to_value(&self) -> glib::Value { let mut value = glib::Value::for_value_type::(); unsafe { glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); } value } #[inline] fn value_type(&self) -> glib::Type { Self::static_type() } } impl From for glib::Value { #[inline] fn from(v: GravityHint) -> Self { ToValue::to_value(&v) } } #[cfg(feature = "v1_46")] #[cfg_attr(docsrs, 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(feature = "v1_46")] #[cfg_attr(docsrs, 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(feature = "v1_46")] #[cfg_attr(docsrs, doc(cfg(feature = "v1_46")))] #[doc(hidden)] impl IntoGlib for Overline { type GlibType = ffi::PangoOverline; #[inline] 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(feature = "v1_46")] #[cfg_attr(docsrs, doc(cfg(feature = "v1_46")))] #[doc(hidden)] impl FromGlib for Overline { #[inline] 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(feature = "v1_46")] #[cfg_attr(docsrs, doc(cfg(feature = "v1_46")))] impl StaticType for Overline { #[inline] #[doc(alias = "pango_overline_get_type")] fn static_type() -> glib::Type { unsafe { from_glib(ffi::pango_overline_get_type()) } } } #[cfg(feature = "v1_46")] #[cfg_attr(docsrs, doc(cfg(feature = "v1_46")))] impl glib::HasParamSpec for Overline { type ParamSpec = glib::ParamSpecEnum; type SetValue = Self; type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder; fn param_spec_builder() -> Self::BuilderFn { Self::ParamSpec::builder_with_default } } #[cfg(feature = "v1_46")] #[cfg_attr(docsrs, doc(cfg(feature = "v1_46")))] impl glib::value::ValueType for Overline { type Type = Self; } #[cfg(feature = "v1_46")] #[cfg_attr(docsrs, doc(cfg(feature = "v1_46")))] unsafe impl<'a> glib::value::FromValue<'a> for Overline { type Checker = glib::value::GenericValueTypeChecker; #[inline] unsafe fn from_value(value: &'a glib::Value) -> Self { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) } } #[cfg(feature = "v1_46")] #[cfg_attr(docsrs, doc(cfg(feature = "v1_46")))] impl ToValue for Overline { #[inline] fn to_value(&self) -> glib::Value { let mut value = glib::Value::for_value_type::(); unsafe { glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); } value } #[inline] fn value_type(&self) -> glib::Type { Self::static_type() } } #[cfg(feature = "v1_46")] #[cfg_attr(docsrs, doc(cfg(feature = "v1_46")))] impl From for glib::Value { #[inline] fn from(v: Overline) -> Self { ToValue::to_value(&v) } } #[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; #[inline] 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 { #[inline] 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 { #[inline] #[doc(alias = "pango_render_part_get_type")] fn static_type() -> glib::Type { unsafe { from_glib(ffi::pango_render_part_get_type()) } } } impl glib::HasParamSpec for RenderPart { type ParamSpec = glib::ParamSpecEnum; type SetValue = Self; type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder; fn param_spec_builder() -> Self::BuilderFn { Self::ParamSpec::builder_with_default } } impl glib::value::ValueType for RenderPart { type Type = Self; } unsafe impl<'a> glib::value::FromValue<'a> for RenderPart { type Checker = glib::value::GenericValueTypeChecker; #[inline] 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 { #[inline] fn to_value(&self) -> glib::Value { let mut value = glib::Value::for_value_type::(); unsafe { glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); } value } #[inline] fn value_type(&self) -> glib::Type { Self::static_type() } } impl From for glib::Value { #[inline] fn from(v: RenderPart) -> Self { ToValue::to_value(&v) } } #[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")] #[allow(deprecated)] #[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 { #[inline] #[doc(alias = "pango_script_get_type")] fn static_type() -> glib::Type { unsafe { from_glib(ffi::pango_script_get_type()) } } } impl glib::HasParamSpec for Script { type ParamSpec = glib::ParamSpecEnum; type SetValue = Self; type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder; fn param_spec_builder() -> Self::BuilderFn { Self::ParamSpec::builder_with_default } } impl glib::value::ValueType for Script { type Type = Self; } unsafe impl<'a> glib::value::FromValue<'a> for Script { type Checker = glib::value::GenericValueTypeChecker; #[inline] 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 { #[inline] fn to_value(&self) -> glib::Value { let mut value = glib::Value::for_value_type::(); unsafe { glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); } value } #[inline] fn value_type(&self) -> glib::Type { Self::static_type() } } impl From