// 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::Script;
use glib::translate::*;
use std::fmt;

glib::wrapper! {
    /// The [`Language`][crate::Language] structure is used to
    /// represent a language.
    ///
    /// [`Language`][crate::Language] pointers can be efficiently
    /// copied and compared with each other.
    #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct Language(Boxed<ffi::PangoLanguage>);

    match fn {
        copy => |ptr| glib::gobject_ffi::g_boxed_copy(ffi::pango_language_get_type(), ptr as *mut _) as *mut ffi::PangoLanguage,
        free => |ptr| glib::gobject_ffi::g_boxed_free(ffi::pango_language_get_type(), ptr as *mut _),
        type_ => || ffi::pango_language_get_type(),
    }
}

impl Language {
    /// Get a string that is representative of the characters needed to
    /// render a particular language.
    ///
    /// The sample text may be a pangram, but is not necessarily. It is chosen
    /// to be demonstrative of normal text in the language, as well as exposing
    /// font feature requirements unique to the language. It is suitable for use
    /// as sample text in a font selection dialog.
    ///
    /// If @self is [`None`], the default language as found by
    /// [`default()`][Self::default()] is used.
    ///
    /// If Pango does not have a sample string for @self, the classic
    /// "The quick brown fox..." is returned.  This can be detected by
    /// comparing the returned pointer value to that returned for (non-existent)
    /// language code "xx".  That is, compare to:
    ///
    /// ```text
    /// pango_language_get_sample_string (pango_language_from_string ("xx"))
    /// ```
    ///
    /// # Returns
    ///
    /// the sample string
    #[doc(alias = "pango_language_get_sample_string")]
    #[doc(alias = "get_sample_string")]
    pub fn sample_string(&self) -> glib::GString {
        unsafe {
            from_glib_none(ffi::pango_language_get_sample_string(mut_override(
                self.to_glib_none().0,
            )))
        }
    }

    /// Determines if @script is one of the scripts used to
    /// write @self.
    ///
    /// The returned value is conservative; if nothing is known about
    /// the language tag @self, [`true`] will be returned, since, as
    /// far as Pango knows, @script might be used to write @self.
    ///
    /// This routine is used in Pango's itemization process when
    /// determining if a supplied language tag is relevant to
    /// a particular section of text. It probably is not useful
    /// for applications in most circumstances.
    ///
    /// This function uses [`scripts()`][Self::scripts()] internally.
    /// ## `script`
    /// a [`Script`][crate::Script]
    ///
    /// # Returns
    ///
    /// [`true`] if @script is one of the scripts used
    ///   to write @self or if nothing is known about @self
    ///   (including the case that @self is [`None`]), [`false`] otherwise.
    #[doc(alias = "pango_language_includes_script")]
    pub fn includes_script(&self, script: Script) -> bool {
        unsafe {
            from_glib(ffi::pango_language_includes_script(
                mut_override(self.to_glib_none().0),
                script.into_glib(),
            ))
        }
    }

    /// Checks if a language tag matches one of the elements in a list of
    /// language ranges.
    ///
    /// A language tag is considered to match a range in the list if the
    /// range is '*', the range is exactly the tag, or the range is a prefix
    /// of the tag, and the character after it in the tag is '-'.
    /// ## `range_list`
    /// a list of language ranges, separated by ';', ':',
    ///   ',', or space characters.
    ///   Each element must either be '*', or a RFC 3066 language range
    ///   canonicalized as by [`from_string()`][Self::from_string()]
    ///
    /// # Returns
    ///
    /// [`true`] if a match was found
    #[doc(alias = "pango_language_matches")]
    pub fn matches(&self, range_list: &str) -> bool {
        unsafe {
            from_glib(ffi::pango_language_matches(
                mut_override(self.to_glib_none().0),
                range_list.to_glib_none().0,
            ))
        }
    }

    /// Gets the RFC-3066 format string representing the given language tag.
    ///
    /// Returns (transfer none): a string representing the language tag
    #[doc(alias = "pango_language_to_string")]
    #[doc(alias = "to_string")]
    pub fn to_str(&self) -> glib::GString {
        unsafe {
            from_glib_none(ffi::pango_language_to_string(mut_override(
                self.to_glib_none().0,
            )))
        }
    }

    /// Convert a language tag to a [`Language`][crate::Language].
    ///
    /// The language tag must be in a RFC-3066 format. [`Language`][crate::Language] pointers
    /// can be efficiently copied (copy the pointer) and compared with other
    /// language tags (compare the pointer.)
    ///
    /// This function first canonicalizes the string by converting it to
    /// lowercase, mapping '_' to '-', and stripping all characters other
    /// than letters and '-'.
    ///
    /// Use [`default()`][Self::default()] if you want to get the
    /// [`Language`][crate::Language] for the current locale of the process.
    /// ## `language`
    /// a string representing a language tag
    ///
    /// # Returns
    ///
    /// a [`Language`][crate::Language]
    #[doc(alias = "pango_language_from_string")]
    pub fn from_string(language: &str) -> Language {
        unsafe { from_glib_none(ffi::pango_language_from_string(language.to_glib_none().0)) }
    }

    /// Returns the [`Language`][crate::Language] for the current locale of the process.
    ///
    /// On Unix systems, this is the return value is derived from
    /// `setlocale (LC_CTYPE, NULL)`, and the user can
    /// affect this through the environment variables LC_ALL, LC_CTYPE or
    /// LANG (checked in that order). The locale string typically is in
    /// the form lang_COUNTRY, where lang is an ISO-639 language code, and
    /// COUNTRY is an ISO-3166 country code. For instance, sv_FI for
    /// Swedish as written in Finland or pt_BR for Portuguese as written in
    /// Brazil.
    ///
    /// On Windows, the C library does not use any such environment
    /// variables, and setting them won't affect the behavior of functions
    /// like ctime(). The user sets the locale through the Regional Options
    /// in the Control Panel. The C library (in the setlocale() function)
    /// does not use country and language codes, but country and language
    /// names spelled out in English.
    /// However, this function does check the above environment
    /// variables, and does return a Unix-style locale string based on
    /// either said environment variables or the thread's current locale.
    ///
    /// Your application should call `setlocale(LC_ALL, "")` for the user
    /// settings to take effect. GTK does this in its initialization
    /// functions automatically (by calling gtk_set_locale()).
    /// See the setlocale() manpage for more details.
    ///
    /// Note that the default language can change over the life of an application.
    ///
    /// Also note that this function will not do the right thing if you
    /// use per-thread locales with uselocale(). In that case, you should
    /// just call pango_language_from_string() yourself.
    ///
    /// # Returns
    ///
    /// the default language as a [`Language`][crate::Language]
    #[doc(alias = "pango_language_get_default")]
    #[doc(alias = "get_default")]
    #[allow(clippy::should_implement_trait)]
    pub fn default() -> Language {
        unsafe { from_glib_none(ffi::pango_language_get_default()) }
    }

    /// Returns the list of languages that the user prefers.
    ///
    /// The list is specified by the `PANGO_LANGUAGE` or `LANGUAGE`
    /// environment variables, in order of preference. Note that this
    /// list does not necessarily include the language returned by
    /// [`default()`][Self::default()].
    ///
    /// When choosing language-specific resources, such as the sample
    /// text returned by [`sample_string()`][Self::sample_string()],
    /// you should first try the default language, followed by the
    /// languages returned by this function.
    ///
    /// # Returns
    ///
    /// a [`None`]-terminated array
    ///   of [`Language`][crate::Language]*
    #[cfg(feature = "v1_48")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_48")))]
    #[doc(alias = "pango_language_get_preferred")]
    #[doc(alias = "get_preferred")]
    pub fn preferred() -> Vec<Language> {
        unsafe { FromGlibPtrContainer::from_glib_none(ffi::pango_language_get_preferred()) }
    }
}

impl fmt::Display for Language {
    #[inline]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.write_str(&self.to_str())
    }
}