1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT

use crate::Context;
use crate::Font;
use crate::FontDescription;
use crate::FontFamily;
use crate::Fontset;
use crate::Language;
use glib::object::IsA;
use glib::translate::*;
use std::fmt;
use std::mem;
use std::ptr;

glib::wrapper! {
    /// The [`FontMap`][crate::FontMap] represents the set of fonts available for a
    /// particular rendering system. This is a virtual object with
    /// implementations being specific to particular rendering systems. To
    /// create an implementation of a [`FontMap`][crate::FontMap], the rendering-system
    /// specific code should allocate a larger structure that contains a nested
    /// [`FontMap`][crate::FontMap], fill in the `<structfield>`klass`</structfield>` member of the nested [`FontMap`][crate::FontMap] with a
    /// pointer to a appropriate `PangoFontMapClass`, then call
    /// `pango_font_map_init()` on the structure.
    ///
    /// The [`FontMap`][crate::FontMap] structure contains one member which the implementation
    /// fills in.
    ///
    /// This is an Abstract Base Class, you cannot instantiate it.
    ///
    /// # Implements
    ///
    /// [`FontMapExt`][trait@crate::prelude::FontMapExt]
    #[doc(alias = "PangoFontMap")]
    pub struct FontMap(Object<ffi::PangoFontMap, ffi::PangoFontMapClass>);

    match fn {
        type_ => || ffi::pango_font_map_get_type(),
    }
}

pub const NONE_FONT_MAP: Option<&FontMap> = None;

/// Trait containing all [`struct@FontMap`] methods.
///
/// # Implementors
///
/// [`FontMap`][struct@crate::FontMap]
pub trait FontMapExt: 'static {
    /// Forces a change in the context, which will cause any [`Context`][crate::Context]
    /// using this fontmap to change.
    ///
    /// This function is only useful when implementing a new backend
    /// for Pango, something applications won't do. Backends should
    /// call this function if they have attached extra data to the context
    /// and such data is changed.
    #[doc(alias = "pango_font_map_changed")]
    fn changed(&self);

    /// Creates a [`Context`][crate::Context] connected to `self`. This is equivalent
    /// to [`Context::new()`][crate::Context::new()] followed by [`Context::set_font_map()`][crate::Context::set_font_map()].
    ///
    /// If you are using Pango as part of a higher-level system,
    /// that system may have it's own way of create a [`Context`][crate::Context].
    /// For instance, the GTK+ toolkit has, among others,
    /// `gdk_pango_context_get_for_screen()`, and
    /// `gtk_widget_get_pango_context()`. Use those instead.
    ///
    /// # Returns
    ///
    /// the newly allocated [`Context`][crate::Context],
    ///  which should be freed with `g_object_unref()`.
    #[doc(alias = "pango_font_map_create_context")]
    fn create_context(&self) -> Option<Context>;

    /// Gets a font family by name.
    /// ## `name`
    /// a family name
    ///
    /// # Returns
    ///
    /// the [`FontFamily`][crate::FontFamily]
    #[cfg(any(feature = "v1_46", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_46")))]
    #[doc(alias = "pango_font_map_get_family")]
    #[doc(alias = "get_family")]
    fn family(&self, name: &str) -> Option<FontFamily>;

    /// Returns the current serial number of `self`. The serial number is
    /// initialized to an small number larger than zero when a new fontmap
    /// is created and is increased whenever the fontmap is changed. It may
    /// wrap, but will never have the value 0. Since it can wrap, never compare
    /// it with "less than", always use "not equals".
    ///
    /// The fontmap can only be changed using backend-specific API, like changing
    /// fontmap resolution.
    ///
    /// This can be used to automatically detect changes to a [`FontMap`][crate::FontMap], like
    /// in [`Context`][crate::Context].
    ///
    /// # Returns
    ///
    /// The current serial number of `self`.
    #[doc(alias = "pango_font_map_get_serial")]
    #[doc(alias = "get_serial")]
    fn serial(&self) -> u32;

    /// List all families for a fontmap.
    ///
    /// # Returns
    ///
    ///
    /// ## `families`
    /// location to store a pointer to an array of [`FontFamily`][crate::FontFamily] *.
    ///  This array should be freed with `g_free()`.
    #[doc(alias = "pango_font_map_list_families")]
    fn list_families(&self) -> Vec<FontFamily>;

    /// Load the font in the fontmap that is the closest match for `desc`.
    /// ## `context`
    /// the [`Context`][crate::Context] the font will be used with
    /// ## `desc`
    /// a [`FontDescription`][crate::FontDescription] describing the font to load
    ///
    /// # Returns
    ///
    /// the newly allocated [`Font`][crate::Font]
    ///  loaded, or [`None`] if no font matched.
    #[doc(alias = "pango_font_map_load_font")]
    fn load_font(&self, context: &Context, desc: &FontDescription) -> Option<Font>;

    /// Load a set of fonts in the fontmap that can be used to render
    /// a font matching `desc`.
    /// ## `context`
    /// the [`Context`][crate::Context] the font will be used with
    /// ## `desc`
    /// a [`FontDescription`][crate::FontDescription] describing the font to load
    /// ## `language`
    /// a [`Language`][crate::Language] the fonts will be used for
    ///
    /// # Returns
    ///
    /// the newly allocated
    ///  [`Fontset`][crate::Fontset] loaded, or [`None`] if no font matched.
    #[doc(alias = "pango_font_map_load_fontset")]
    fn load_fontset(
        &self,
        context: &Context,
        desc: &FontDescription,
        language: &Language,
    ) -> Option<Fontset>;
}

impl<O: IsA<FontMap>> FontMapExt for O {
    fn changed(&self) {
        unsafe {
            ffi::pango_font_map_changed(self.as_ref().to_glib_none().0);
        }
    }

    fn create_context(&self) -> Option<Context> {
        unsafe {
            from_glib_full(ffi::pango_font_map_create_context(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    #[cfg(any(feature = "v1_46", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_46")))]
    fn family(&self, name: &str) -> Option<FontFamily> {
        unsafe {
            from_glib_none(ffi::pango_font_map_get_family(
                self.as_ref().to_glib_none().0,
                name.to_glib_none().0,
            ))
        }
    }

    fn serial(&self) -> u32 {
        unsafe { ffi::pango_font_map_get_serial(self.as_ref().to_glib_none().0) }
    }

    fn list_families(&self) -> Vec<FontFamily> {
        unsafe {
            let mut families = ptr::null_mut();
            let mut n_families = mem::MaybeUninit::uninit();
            ffi::pango_font_map_list_families(
                self.as_ref().to_glib_none().0,
                &mut families,
                n_families.as_mut_ptr(),
            );
            FromGlibContainer::from_glib_container_num(families, n_families.assume_init() as usize)
        }
    }

    fn load_font(&self, context: &Context, desc: &FontDescription) -> Option<Font> {
        unsafe {
            from_glib_full(ffi::pango_font_map_load_font(
                self.as_ref().to_glib_none().0,
                context.to_glib_none().0,
                desc.to_glib_none().0,
            ))
        }
    }

    fn load_fontset(
        &self,
        context: &Context,
        desc: &FontDescription,
        language: &Language,
    ) -> Option<Fontset> {
        unsafe {
            from_glib_full(ffi::pango_font_map_load_fontset(
                self.as_ref().to_glib_none().0,
                context.to_glib_none().0,
                desc.to_glib_none().0,
                mut_override(language.to_glib_none().0),
            ))
        }
    }
}

impl fmt::Display for FontMap {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.write_str("FontMap")
    }
}