libappstream/auto/

review.rs

// This file was generated by gir (https://github.com/gtk-rs/gir)
// from
// from gir-files (https://github.com/gtk-rs/gir-files.git)
// DO NOT EDIT

use crate::{ffi, ReviewFlags};
use glib::{
    prelude::*,
    signal::{connect_raw, SignalHandlerId},
    translate::*,
};
use std::boxed::Box as Box_;

glib::wrapper! {
    ///
    ///
    /// ## Properties
    ///
    ///
    /// #### `date`
    ///  Readable | Writeable | Construct
    ///
    ///
    /// #### `description`
    ///  Readable | Writeable | Construct
    ///
    ///
    /// #### `flags`
    ///  Readable | Writeable | Construct
    ///
    ///
    /// #### `id`
    ///  Readable | Writeable | Construct
    ///
    ///
    /// #### `locale`
    ///  Readable | Writeable | Construct
    ///
    ///
    /// #### `priority`
    ///  The priority for the review, where positive numbers indicate
    /// a better review for the specific user.
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `rating`
    ///  Readable | Writeable | Construct
    ///
    ///
    /// #### `reviewer-id`
    ///  Readable | Writeable | Construct
    ///
    ///
    /// #### `reviewer-name`
    ///  Readable | Writeable | Construct
    ///
    ///
    /// #### `summary`
    ///  Readable | Writeable | Construct
    ///
    ///
    /// #### `version`
    ///  Readable | Writeable | Construct
    ///
    /// # Implements
    ///
    /// [`ReviewExt`][trait@crate::prelude::ReviewExt]
    #[doc(alias = "AsReview")]
    pub struct Review(Object<ffi::AsReview, ffi::AsReviewClass>);

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

impl Review {
    pub const NONE: Option<&'static Review> = None;

    /// Creates a new [`Review`][crate::Review].
    ///
    /// # Returns
    ///
    /// a [`Review`][crate::Review]
    #[doc(alias = "as_review_new")]
    pub fn new() -> Review {
        assert_initialized_main_thread!();
        unsafe { from_glib_full(ffi::as_review_new()) }
    }
}

impl Default for Review {
    fn default() -> Self {
        Self::new()
    }
}

mod sealed {
    pub trait Sealed {}
    impl<T: super::IsA<super::Review>> Sealed for T {}
}

/// Trait containing all [`struct@Review`] methods.
///
/// # Implementors
///
/// [`Review`][struct@crate::Review]
pub trait ReviewExt: IsA<Review> + sealed::Sealed + 'static {
    /// Adds flags to an existing review without replacing the other flags.
    /// ## `flags`
    /// a [`ReviewFlags`][crate::ReviewFlags], e.g. [`ReviewFlags::SELF`][crate::ReviewFlags::SELF]
    #[doc(alias = "as_review_add_flags")]
    fn add_flags(&self, flags: ReviewFlags) {
        unsafe {
            ffi::as_review_add_flags(self.as_ref().to_glib_none().0, flags.into_glib());
        }
    }

    /// Adds metadata to the review object.
    /// It is left for the the plugin to use this method as required, but a
    /// typical use would be to store some secure authentication token.
    /// ## `key`
    /// a string
    /// ## `value`
    /// a string
    #[doc(alias = "as_review_add_metadata")]
    fn add_metadata(&self, key: &str, value: &str) {
        unsafe {
            ffi::as_review_add_metadata(
                self.as_ref().to_glib_none().0,
                key.to_glib_none().0,
                value.to_glib_none().0,
            );
        }
    }

    #[doc(alias = "as_review_equal")]
    fn equal(&self, review2: &impl IsA<Review>) -> bool {
        unsafe {
            from_glib(ffi::as_review_equal(
                self.as_ref().to_glib_none().0,
                review2.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the date the review was originally submitted.
    ///
    /// # Returns
    ///
    /// the [`glib::DateTime`][crate::glib::DateTime], or [`None`] for unset
    #[doc(alias = "as_review_get_date")]
    #[doc(alias = "get_date")]
    fn date(&self) -> Option<glib::DateTime> {
        unsafe { from_glib_none(ffi::as_review_get_date(self.as_ref().to_glib_none().0)) }
    }

    /// Gets the multi-line review text that forms the body of the review.
    ///
    /// # Returns
    ///
    /// the string, or [`None`]
    #[doc(alias = "as_review_get_description")]
    #[doc(alias = "get_description")]
    fn description(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::as_review_get_description(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets any flags set on the review, for example if the user has already
    /// voted on the review or if the user wrote the review themselves.
    ///
    /// # Returns
    ///
    /// a [`ReviewFlags`][crate::ReviewFlags], e.g. [`ReviewFlags::SELF`][crate::ReviewFlags::SELF]
    #[doc(alias = "as_review_get_flags")]
    #[doc(alias = "get_flags")]
    fn flags(&self) -> ReviewFlags {
        unsafe { from_glib(ffi::as_review_get_flags(self.as_ref().to_glib_none().0)) }
    }

    /// Gets the review id.
    ///
    /// # Returns
    ///
    /// the review identifier, e.g. "deadbeef"
    #[doc(alias = "as_review_get_id")]
    #[doc(alias = "get_id")]
    fn id(&self) -> Option<glib::GString> {
        unsafe { from_glib_none(ffi::as_review_get_id(self.as_ref().to_glib_none().0)) }
    }

    /// Gets the locale for the review.
    ///
    /// # Returns
    ///
    /// the string, or [`None`]
    #[doc(alias = "as_review_get_locale")]
    #[doc(alias = "get_locale")]
    fn locale(&self) -> Option<glib::GString> {
        unsafe { from_glib_none(ffi::as_review_get_locale(self.as_ref().to_glib_none().0)) }
    }

    /// Gets some metadata from a review object.
    /// It is left for the the plugin to use this method as required, but a
    /// typical use would be to retrieve some secure authentication token.
    /// ## `key`
    /// a string
    ///
    /// # Returns
    ///
    /// A string value, or [`None`] for not found
    #[doc(alias = "as_review_get_metadata_item")]
    #[doc(alias = "get_metadata_item")]
    fn metadata_item(&self, key: &str) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::as_review_get_metadata_item(
                self.as_ref().to_glib_none().0,
                key.to_glib_none().0,
            ))
        }
    }

    /// This allows the UI to sort reviews into the correct order.
    /// Higher numbers indicate a more important or relevant review.
    ///
    /// # Returns
    ///
    /// the review priority, or 0 for unset.
    #[doc(alias = "as_review_get_priority")]
    #[doc(alias = "get_priority")]
    fn priority(&self) -> i32 {
        unsafe { ffi::as_review_get_priority(self.as_ref().to_glib_none().0) }
    }

    /// Gets the star rating of the review, where 100 is 5 stars.
    ///
    /// # Returns
    ///
    /// integer as a percentage, or 0 for unset
    #[doc(alias = "as_review_get_rating")]
    #[doc(alias = "get_rating")]
    fn rating(&self) -> i32 {
        unsafe { ffi::as_review_get_rating(self.as_ref().to_glib_none().0) }
    }

    /// Gets the name of the reviewer.
    ///
    /// # Returns
    ///
    /// the reviewer ID, e.g. "deadbeef", or [`None`]
    #[doc(alias = "as_review_get_reviewer_id")]
    #[doc(alias = "get_reviewer_id")]
    #[doc(alias = "reviewer-id")]
    fn reviewer_id(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::as_review_get_reviewer_id(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the name of the reviewer.
    ///
    /// # Returns
    ///
    /// the reviewer name, e.g. "David Smith", or [`None`]
    #[doc(alias = "as_review_get_reviewer_name")]
    #[doc(alias = "get_reviewer_name")]
    #[doc(alias = "reviewer-name")]
    fn reviewer_name(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::as_review_get_reviewer_name(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the review summary.
    ///
    /// # Returns
    ///
    /// the one-line summary, e.g. "Awesome application"
    #[doc(alias = "as_review_get_summary")]
    #[doc(alias = "get_summary")]
    fn summary(&self) -> Option<glib::GString> {
        unsafe { from_glib_none(ffi::as_review_get_summary(self.as_ref().to_glib_none().0)) }
    }

    /// Gets the version string for the application being reviewed..
    ///
    /// # Returns
    ///
    /// the version string, e.g. "0.1.2", or [`None`] for unset
    #[doc(alias = "as_review_get_version")]
    #[doc(alias = "get_version")]
    fn version(&self) -> Option<glib::GString> {
        unsafe { from_glib_none(ffi::as_review_get_version(self.as_ref().to_glib_none().0)) }
    }

    /// Sets the date the review was originally submitted.
    /// ## `date`
    /// a [`glib::DateTime`][crate::glib::DateTime], or [`None`]
    #[doc(alias = "as_review_set_date")]
    #[doc(alias = "date")]
    fn set_date(&self, date: &glib::DateTime) {
        unsafe {
            ffi::as_review_set_date(self.as_ref().to_glib_none().0, date.to_glib_none().0);
        }
    }

    /// Sets the multi-line review text that forms the body of the review.
    /// ## `description`
    /// multi-line description
    #[doc(alias = "as_review_set_description")]
    #[doc(alias = "description")]
    fn set_description(&self, description: &str) {
        unsafe {
            ffi::as_review_set_description(
                self.as_ref().to_glib_none().0,
                description.to_glib_none().0,
            );
        }
    }

    /// Gets any flags set on the review, for example if the user has already
    /// voted on the review or if the user wrote the review themselves.
    /// ## `flags`
    /// a [`ReviewFlags`][crate::ReviewFlags], e.g. [`ReviewFlags::SELF`][crate::ReviewFlags::SELF]
    #[doc(alias = "as_review_set_flags")]
    #[doc(alias = "flags")]
    fn set_flags(&self, flags: ReviewFlags) {
        unsafe {
            ffi::as_review_set_flags(self.as_ref().to_glib_none().0, flags.into_glib());
        }
    }

    /// Sets the review identifier that is unique to each review.
    /// ## `id`
    /// review identifier, e.g. "deadbeef"
    #[doc(alias = "as_review_set_id")]
    #[doc(alias = "id")]
    fn set_id(&self, id: &str) {
        unsafe {
            ffi::as_review_set_id(self.as_ref().to_glib_none().0, id.to_glib_none().0);
        }
    }

    /// Sets the locale for the review.
    /// ## `locale`
    /// a BCP47 locale, e.g. "en-GB"
    #[doc(alias = "as_review_set_locale")]
    #[doc(alias = "locale")]
    fn set_locale(&self, locale: &str) {
        unsafe {
            ffi::as_review_set_locale(self.as_ref().to_glib_none().0, locale.to_glib_none().0);
        }
    }

    /// Sets the priority for the review, where positive numbers indicate
    /// a better review for the specific user.
    /// ## `priority`
    /// a priority value
    #[doc(alias = "as_review_set_priority")]
    #[doc(alias = "priority")]
    fn set_priority(&self, priority: i32) {
        unsafe {
            ffi::as_review_set_priority(self.as_ref().to_glib_none().0, priority);
        }
    }

    /// Sets the star rating of the review, where 100 is 5 stars..
    /// ## `rating`
    /// a integer as a percentage, or 0 for unset
    #[doc(alias = "as_review_set_rating")]
    #[doc(alias = "rating")]
    fn set_rating(&self, rating: i32) {
        unsafe {
            ffi::as_review_set_rating(self.as_ref().to_glib_none().0, rating);
        }
    }

    /// Sets the name of the reviewer, which can be left unset.
    /// ## `reviewer_id`
    /// the reviewer ID, e.g. "deadbeef"
    #[doc(alias = "as_review_set_reviewer_id")]
    #[doc(alias = "reviewer-id")]
    fn set_reviewer_id(&self, reviewer_id: &str) {
        unsafe {
            ffi::as_review_set_reviewer_id(
                self.as_ref().to_glib_none().0,
                reviewer_id.to_glib_none().0,
            );
        }
    }

    /// Sets the name of the reviewer, which can be left unset.
    /// ## `reviewer_name`
    /// the reviewer name, e.g. "David Smith"
    #[doc(alias = "as_review_set_reviewer_name")]
    #[doc(alias = "reviewer-name")]
    fn set_reviewer_name(&self, reviewer_name: &str) {
        unsafe {
            ffi::as_review_set_reviewer_name(
                self.as_ref().to_glib_none().0,
                reviewer_name.to_glib_none().0,
            );
        }
    }

    /// Sets the one-line summary that may be displayed in bold.
    /// ## `summary`
    /// a one-line summary, e.g. "Awesome application"
    #[doc(alias = "as_review_set_summary")]
    #[doc(alias = "summary")]
    fn set_summary(&self, summary: &str) {
        unsafe {
            ffi::as_review_set_summary(self.as_ref().to_glib_none().0, summary.to_glib_none().0);
        }
    }

    /// Sets the version string for the application being reviewed.
    /// ## `version`
    /// a version string, e.g. "0.1.2"
    #[doc(alias = "as_review_set_version")]
    #[doc(alias = "version")]
    fn set_version(&self, version: &str) {
        unsafe {
            ffi::as_review_set_version(self.as_ref().to_glib_none().0, version.to_glib_none().0);
        }
    }

    #[doc(alias = "date")]
    fn connect_date_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_date_trampoline<P: IsA<Review>, F: Fn(&P) + 'static>(
            this: *mut ffi::AsReview,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Review::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::date\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_date_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "description")]
    fn connect_description_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_description_trampoline<P: IsA<Review>, F: Fn(&P) + 'static>(
            this: *mut ffi::AsReview,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Review::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::description\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_description_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "flags")]
    fn connect_flags_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_flags_trampoline<P: IsA<Review>, F: Fn(&P) + 'static>(
            this: *mut ffi::AsReview,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Review::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::flags\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_flags_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "id")]
    fn connect_id_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_id_trampoline<P: IsA<Review>, F: Fn(&P) + 'static>(
            this: *mut ffi::AsReview,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Review::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::id\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_id_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "locale")]
    fn connect_locale_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_locale_trampoline<P: IsA<Review>, F: Fn(&P) + 'static>(
            this: *mut ffi::AsReview,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Review::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::locale\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_locale_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "priority")]
    fn connect_priority_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_priority_trampoline<P: IsA<Review>, F: Fn(&P) + 'static>(
            this: *mut ffi::AsReview,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Review::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::priority\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_priority_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "rating")]
    fn connect_rating_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_rating_trampoline<P: IsA<Review>, F: Fn(&P) + 'static>(
            this: *mut ffi::AsReview,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Review::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::rating\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_rating_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "reviewer-id")]
    fn connect_reviewer_id_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_reviewer_id_trampoline<P: IsA<Review>, F: Fn(&P) + 'static>(
            this: *mut ffi::AsReview,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Review::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::reviewer-id\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_reviewer_id_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "reviewer-name")]
    fn connect_reviewer_name_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_reviewer_name_trampoline<
            P: IsA<Review>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::AsReview,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Review::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::reviewer-name\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_reviewer_name_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "summary")]
    fn connect_summary_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_summary_trampoline<P: IsA<Review>, F: Fn(&P) + 'static>(
            this: *mut ffi::AsReview,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Review::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::summary\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_summary_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "version")]
    fn connect_version_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_version_trampoline<P: IsA<Review>, F: Fn(&P) + 'static>(
            this: *mut ffi::AsReview,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Review::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::version\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_version_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

impl<O: IsA<Review>> ReviewExt for O {}