libappstream 0.4.0

// 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, Agreement, AgreementKind, Branding, Bundle, BundleKind, Category, ComponentKind,
    ComponentScope, ContentRating, Context, FormatKind, Icon, Launchable, LaunchableKind,
    MergeKind, Provided, ProvidedKind, Relation, Release, ReleaseList, Review, Screenshot,
    Suggested, Translation, UrlKind,
};
use glib::{
    prelude::*,
    signal::{connect_raw, SignalHandlerId},
    translate::*,
};
use std::boxed::Box as Box_;

glib::wrapper! {
    #[doc(alias = "AsComponent")]
    pub struct Component(Object<ffi::AsComponent, ffi::AsComponentClass>);

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

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

    #[doc(alias = "as_component_new")]
    pub fn new() -> Component {
        assert_initialized_main_thread!();
        unsafe { from_glib_full(ffi::as_component_new()) }
    }
}

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

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

pub trait ComponentExt: IsA<Component> + 'static {
    #[doc(alias = "as_component_add_addon")]
    fn add_addon(&self, addon: &impl IsA<Component>) {
        unsafe {
            ffi::as_component_add_addon(
                self.as_ref().to_glib_none().0,
                addon.as_ref().to_glib_none().0,
            );
        }
    }

    #[doc(alias = "as_component_add_agreement")]
    fn add_agreement(&self, agreement: &impl IsA<Agreement>) {
        unsafe {
            ffi::as_component_add_agreement(
                self.as_ref().to_glib_none().0,
                agreement.as_ref().to_glib_none().0,
            );
        }
    }

    #[doc(alias = "as_component_add_bundle")]
    fn add_bundle(&self, bundle: &impl IsA<Bundle>) {
        unsafe {
            ffi::as_component_add_bundle(
                self.as_ref().to_glib_none().0,
                bundle.as_ref().to_glib_none().0,
            );
        }
    }

    #[doc(alias = "as_component_add_category")]
    fn add_category(&self, category: &str) {
        unsafe {
            ffi::as_component_add_category(
                self.as_ref().to_glib_none().0,
                category.to_glib_none().0,
            );
        }
    }

    #[doc(alias = "as_component_add_content_rating")]
    fn add_content_rating(&self, content_rating: &impl IsA<ContentRating>) {
        unsafe {
            ffi::as_component_add_content_rating(
                self.as_ref().to_glib_none().0,
                content_rating.as_ref().to_glib_none().0,
            );
        }
    }

    #[doc(alias = "as_component_add_extends")]
    fn add_extends(&self, cpt_id: &str) {
        unsafe {
            ffi::as_component_add_extends(self.as_ref().to_glib_none().0, cpt_id.to_glib_none().0);
        }
    }

    #[doc(alias = "as_component_add_icon")]
    fn add_icon(&self, icon: &impl IsA<Icon>) {
        unsafe {
            ffi::as_component_add_icon(
                self.as_ref().to_glib_none().0,
                icon.as_ref().to_glib_none().0,
            );
        }
    }

    #[doc(alias = "as_component_add_keyword")]
    fn add_keyword(&self, keyword: &str, locale: Option<&str>) {
        unsafe {
            ffi::as_component_add_keyword(
                self.as_ref().to_glib_none().0,
                keyword.to_glib_none().0,
                locale.to_glib_none().0,
            );
        }
    }

    #[doc(alias = "as_component_add_language")]
    fn add_language(&self, locale: Option<&str>, percentage: i32) {
        unsafe {
            ffi::as_component_add_language(
                self.as_ref().to_glib_none().0,
                locale.to_glib_none().0,
                percentage,
            );
        }
    }

    #[doc(alias = "as_component_add_launchable")]
    fn add_launchable(&self, launchable: &impl IsA<Launchable>) {
        unsafe {
            ffi::as_component_add_launchable(
                self.as_ref().to_glib_none().0,
                launchable.as_ref().to_glib_none().0,
            );
        }
    }

    #[doc(alias = "as_component_add_provided")]
    fn add_provided(&self, prov: &impl IsA<Provided>) {
        unsafe {
            ffi::as_component_add_provided(
                self.as_ref().to_glib_none().0,
                prov.as_ref().to_glib_none().0,
            );
        }
    }

    #[doc(alias = "as_component_add_provided_item")]
    fn add_provided_item(&self, kind: ProvidedKind, item: &str) {
        unsafe {
            ffi::as_component_add_provided_item(
                self.as_ref().to_glib_none().0,
                kind.into_glib(),
                item.to_glib_none().0,
            );
        }
    }

    //#[doc(alias = "as_component_add_reference")]
    //fn add_reference(&self, reference: /*Ignored*/&Reference) {
    //    unsafe { TODO: call ffi:as_component_add_reference() }
    //}

    #[doc(alias = "as_component_add_relation")]
    fn add_relation(&self, relation: &impl IsA<Relation>) {
        unsafe {
            ffi::as_component_add_relation(
                self.as_ref().to_glib_none().0,
                relation.as_ref().to_glib_none().0,
            );
        }
    }

    #[doc(alias = "as_component_add_release")]
    fn add_release(&self, release: &impl IsA<Release>) {
        unsafe {
            ffi::as_component_add_release(
                self.as_ref().to_glib_none().0,
                release.as_ref().to_glib_none().0,
            );
        }
    }

    #[doc(alias = "as_component_add_replaces")]
    fn add_replaces(&self, cid: &str) {
        unsafe {
            ffi::as_component_add_replaces(self.as_ref().to_glib_none().0, cid.to_glib_none().0);
        }
    }

    #[doc(alias = "as_component_add_review")]
    fn add_review(&self, review: &impl IsA<Review>) {
        unsafe {
            ffi::as_component_add_review(
                self.as_ref().to_glib_none().0,
                review.as_ref().to_glib_none().0,
            );
        }
    }

    #[doc(alias = "as_component_add_screenshot")]
    fn add_screenshot(&self, sshot: &impl IsA<Screenshot>) {
        unsafe {
            ffi::as_component_add_screenshot(
                self.as_ref().to_glib_none().0,
                sshot.as_ref().to_glib_none().0,
            );
        }
    }

    #[doc(alias = "as_component_add_suggested")]
    fn add_suggested(&self, suggested: &impl IsA<Suggested>) {
        unsafe {
            ffi::as_component_add_suggested(
                self.as_ref().to_glib_none().0,
                suggested.as_ref().to_glib_none().0,
            );
        }
    }

    #[doc(alias = "as_component_add_tag")]
    fn add_tag(&self, ns: &str, tag: &str) -> bool {
        unsafe {
            from_glib(ffi::as_component_add_tag(
                self.as_ref().to_glib_none().0,
                ns.to_glib_none().0,
                tag.to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_component_add_translation")]
    fn add_translation(&self, tr: &impl IsA<Translation>) {
        unsafe {
            ffi::as_component_add_translation(
                self.as_ref().to_glib_none().0,
                tr.as_ref().to_glib_none().0,
            );
        }
    }

    #[doc(alias = "as_component_add_url")]
    fn add_url(&self, url_kind: UrlKind, url: &str) {
        unsafe {
            ffi::as_component_add_url(
                self.as_ref().to_glib_none().0,
                url_kind.into_glib(),
                url.to_glib_none().0,
            );
        }
    }

    //#[doc(alias = "as_component_check_relations")]
    //fn check_relations(&self, sysinfo: /*Ignored*/Option<&SystemInfo>, pool: Option<&impl IsA<Pool>>, rel_kind: RelationKind) -> /*Ignored*/Vec<RelationCheckResult> {
    //    unsafe { TODO: call ffi:as_component_check_relations() }
    //}

    #[doc(alias = "as_component_clear_keywords")]
    fn clear_keywords(&self, locale: Option<&str>) {
        unsafe {
            ffi::as_component_clear_keywords(
                self.as_ref().to_glib_none().0,
                locale.to_glib_none().0,
            );
        }
    }

    #[doc(alias = "as_component_clear_languages")]
    fn clear_languages(&self) {
        unsafe {
            ffi::as_component_clear_languages(self.as_ref().to_glib_none().0);
        }
    }

    #[doc(alias = "as_component_clear_tags")]
    fn clear_tags(&self) {
        unsafe {
            ffi::as_component_clear_tags(self.as_ref().to_glib_none().0);
        }
    }

    #[doc(alias = "as_component_get_addons")]
    #[doc(alias = "get_addons")]
    fn addons(&self) -> Vec<Component> {
        unsafe {
            FromGlibPtrContainer::from_glib_none(ffi::as_component_get_addons(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_component_get_agreement_by_kind")]
    #[doc(alias = "get_agreement_by_kind")]
    fn agreement_by_kind(&self, kind: AgreementKind) -> Option<Agreement> {
        unsafe {
            from_glib_none(ffi::as_component_get_agreement_by_kind(
                self.as_ref().to_glib_none().0,
                kind.into_glib(),
            ))
        }
    }

    #[doc(alias = "as_component_get_agreements")]
    #[doc(alias = "get_agreements")]
    fn agreements(&self) -> Vec<Agreement> {
        unsafe {
            FromGlibPtrContainer::from_glib_none(ffi::as_component_get_agreements(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_component_get_branch")]
    #[doc(alias = "get_branch")]
    fn branch(&self) -> Option<glib::GString> {
        unsafe { from_glib_none(ffi::as_component_get_branch(self.as_ref().to_glib_none().0)) }
    }

    #[doc(alias = "as_component_get_branding")]
    #[doc(alias = "get_branding")]
    fn branding(&self) -> Option<Branding> {
        unsafe {
            from_glib_none(ffi::as_component_get_branding(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_component_get_bundle")]
    #[doc(alias = "get_bundle")]
    fn bundle(&self, bundle_kind: BundleKind) -> Option<Bundle> {
        unsafe {
            from_glib_none(ffi::as_component_get_bundle(
                self.as_ref().to_glib_none().0,
                bundle_kind.into_glib(),
            ))
        }
    }

    #[doc(alias = "as_component_get_bundles")]
    #[doc(alias = "get_bundles")]
    fn bundles(&self) -> Vec<Bundle> {
        unsafe {
            FromGlibPtrContainer::from_glib_none(ffi::as_component_get_bundles(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_component_get_categories")]
    #[doc(alias = "get_categories")]
    fn categories(&self) -> Vec<glib::GString> {
        unsafe {
            FromGlibPtrContainer::from_glib_none(ffi::as_component_get_categories(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_component_get_compulsory_for_desktops")]
    #[doc(alias = "get_compulsory_for_desktops")]
    fn compulsory_for_desktops(&self) -> Vec<glib::GString> {
        unsafe {
            FromGlibPtrContainer::from_glib_none(ffi::as_component_get_compulsory_for_desktops(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_component_get_content_rating")]
    #[doc(alias = "get_content_rating")]
    fn content_rating(&self, kind: &str) -> Option<ContentRating> {
        unsafe {
            from_glib_none(ffi::as_component_get_content_rating(
                self.as_ref().to_glib_none().0,
                kind.to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_component_get_content_ratings")]
    #[doc(alias = "get_content_ratings")]
    fn content_ratings(&self) -> Vec<ContentRating> {
        unsafe {
            FromGlibPtrContainer::from_glib_none(ffi::as_component_get_content_ratings(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_component_get_context")]
    #[doc(alias = "get_context")]
    fn context(&self) -> Option<Context> {
        unsafe {
            from_glib_none(ffi::as_component_get_context(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    //#[doc(alias = "as_component_get_custom")]
    //#[doc(alias = "get_custom")]
    //fn custom(&self) -> /*Unknown conversion*//*Unimplemented*/HashTable TypeId { ns_id: 0, id: 25 }/TypeId { ns_id: 0, id: 25 } {
    //    unsafe { TODO: call ffi:as_component_get_custom() }
    //}

    #[doc(alias = "as_component_get_custom_value")]
    #[doc(alias = "get_custom_value")]
    fn custom_value(&self, key: &str) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::as_component_get_custom_value(
                self.as_ref().to_glib_none().0,
                key.to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_component_get_data_id")]
    #[doc(alias = "get_data_id")]
    fn data_id(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::as_component_get_data_id(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_component_get_date_eol")]
    #[doc(alias = "get_date_eol")]
    fn date_eol(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::as_component_get_date_eol(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_component_get_description")]
    #[doc(alias = "get_description")]
    fn description(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::as_component_get_description(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    //#[doc(alias = "as_component_get_developer")]
    //#[doc(alias = "get_developer")]
    //fn developer(&self) -> /*Ignored*/Option<Developer> {
    //    unsafe { TODO: call ffi:as_component_get_developer() }
    //}

    #[doc(alias = "as_component_get_extends")]
    #[doc(alias = "get_extends")]
    fn extends(&self) -> Vec<glib::GString> {
        unsafe {
            FromGlibPtrContainer::from_glib_none(ffi::as_component_get_extends(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_component_get_icon_by_size")]
    #[doc(alias = "get_icon_by_size")]
    fn icon_by_size(&self, width: u32, height: u32) -> Option<Icon> {
        unsafe {
            from_glib_none(ffi::as_component_get_icon_by_size(
                self.as_ref().to_glib_none().0,
                width,
                height,
            ))
        }
    }

    #[doc(alias = "as_component_get_icon_stock")]
    #[doc(alias = "get_icon_stock")]
    fn icon_stock(&self) -> Option<Icon> {
        unsafe {
            from_glib_none(ffi::as_component_get_icon_stock(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_component_get_icons")]
    #[doc(alias = "get_icons")]
    fn icons(&self) -> Vec<Icon> {
        unsafe {
            FromGlibPtrContainer::from_glib_none(ffi::as_component_get_icons(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_component_get_id")]
    #[doc(alias = "get_id")]
    fn id(&self) -> Option<glib::GString> {
        unsafe { from_glib_none(ffi::as_component_get_id(self.as_ref().to_glib_none().0)) }
    }

    #[doc(alias = "as_component_get_keywords")]
    #[doc(alias = "get_keywords")]
    fn keywords(&self) -> Vec<glib::GString> {
        unsafe {
            FromGlibPtrContainer::from_glib_none(ffi::as_component_get_keywords(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    //#[doc(alias = "as_component_get_keywords_table")]
    //#[doc(alias = "get_keywords_table")]
    //fn keywords_table(&self) -> /*Unknown conversion*//*Unimplemented*/HashTable TypeId { ns_id: 0, id: 25 }/TypeId { ns_id: 0, id: 25 } {
    //    unsafe { TODO: call ffi:as_component_get_keywords_table() }
    //}

    #[doc(alias = "as_component_get_kind")]
    #[doc(alias = "get_kind")]
    fn kind(&self) -> ComponentKind {
        unsafe { from_glib(ffi::as_component_get_kind(self.as_ref().to_glib_none().0)) }
    }

    #[doc(alias = "as_component_get_language")]
    #[doc(alias = "get_language")]
    fn language(&self, locale: Option<&str>) -> i32 {
        unsafe {
            ffi::as_component_get_language(self.as_ref().to_glib_none().0, locale.to_glib_none().0)
        }
    }

    #[doc(alias = "as_component_get_languages")]
    #[doc(alias = "get_languages")]
    fn languages(&self) -> Vec<glib::GString> {
        unsafe {
            FromGlibPtrContainer::from_glib_container(ffi::as_component_get_languages(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_component_get_launchable")]
    #[doc(alias = "get_launchable")]
    fn launchable(&self, kind: LaunchableKind) -> Option<Launchable> {
        unsafe {
            from_glib_none(ffi::as_component_get_launchable(
                self.as_ref().to_glib_none().0,
                kind.into_glib(),
            ))
        }
    }

    #[doc(alias = "as_component_get_launchables")]
    #[doc(alias = "get_launchables")]
    fn launchables(&self) -> Vec<Launchable> {
        unsafe {
            FromGlibPtrContainer::from_glib_none(ffi::as_component_get_launchables(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_component_get_merge_kind")]
    #[doc(alias = "get_merge_kind")]
    fn merge_kind(&self) -> MergeKind {
        unsafe {
            from_glib(ffi::as_component_get_merge_kind(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_component_get_metadata_license")]
    #[doc(alias = "get_metadata_license")]
    fn metadata_license(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::as_component_get_metadata_license(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_component_get_name")]
    #[doc(alias = "get_name")]
    fn name(&self) -> Option<glib::GString> {
        unsafe { from_glib_none(ffi::as_component_get_name(self.as_ref().to_glib_none().0)) }
    }

    //#[doc(alias = "as_component_get_name_table")]
    //#[doc(alias = "get_name_table")]
    //fn name_table(&self) -> /*Unknown conversion*//*Unimplemented*/HashTable TypeId { ns_id: 0, id: 25 }/TypeId { ns_id: 0, id: 25 } {
    //    unsafe { TODO: call ffi:as_component_get_name_table() }
    //}

    #[doc(alias = "as_component_get_name_variant_suffix")]
    #[doc(alias = "get_name_variant_suffix")]
    fn name_variant_suffix(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::as_component_get_name_variant_suffix(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_component_get_origin")]
    #[doc(alias = "get_origin")]
    fn origin(&self) -> Option<glib::GString> {
        unsafe { from_glib_none(ffi::as_component_get_origin(self.as_ref().to_glib_none().0)) }
    }

    #[doc(alias = "as_component_get_pkgname")]
    #[doc(alias = "get_pkgname")]
    fn pkgname(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::as_component_get_pkgname(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_component_get_pkgnames")]
    #[doc(alias = "get_pkgnames")]
    fn pkgnames(&self) -> Vec<glib::GString> {
        unsafe {
            FromGlibPtrContainer::from_glib_none(ffi::as_component_get_pkgnames(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_component_get_priority")]
    #[doc(alias = "get_priority")]
    fn priority(&self) -> i32 {
        unsafe { ffi::as_component_get_priority(self.as_ref().to_glib_none().0) }
    }

    #[doc(alias = "as_component_get_project_group")]
    #[doc(alias = "get_project_group")]
    #[doc(alias = "project-group")]
    fn project_group(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::as_component_get_project_group(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_component_get_project_license")]
    #[doc(alias = "get_project_license")]
    #[doc(alias = "project-license")]
    fn project_license(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::as_component_get_project_license(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_component_get_provided")]
    #[doc(alias = "get_provided")]
    fn provided(&self) -> Vec<Provided> {
        unsafe {
            FromGlibPtrContainer::from_glib_none(ffi::as_component_get_provided(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_component_get_provided_for_kind")]
    #[doc(alias = "get_provided_for_kind")]
    fn provided_for_kind(&self, kind: ProvidedKind) -> Option<Provided> {
        unsafe {
            from_glib_none(ffi::as_component_get_provided_for_kind(
                self.as_ref().to_glib_none().0,
                kind.into_glib(),
            ))
        }
    }

    #[doc(alias = "as_component_get_recommends")]
    #[doc(alias = "get_recommends")]
    fn recommends(&self) -> Vec<Relation> {
        unsafe {
            FromGlibPtrContainer::from_glib_none(ffi::as_component_get_recommends(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    //#[doc(alias = "as_component_get_references")]
    //#[doc(alias = "get_references")]
    //fn references(&self) -> /*Ignored*/Vec<Reference> {
    //    unsafe { TODO: call ffi:as_component_get_references() }
    //}

    #[doc(alias = "as_component_get_releases_plain")]
    #[doc(alias = "get_releases_plain")]
    fn releases_plain(&self) -> Option<ReleaseList> {
        unsafe {
            from_glib_none(ffi::as_component_get_releases_plain(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_component_get_replaces")]
    #[doc(alias = "get_replaces")]
    fn replaces(&self) -> Vec<glib::GString> {
        unsafe {
            FromGlibPtrContainer::from_glib_none(ffi::as_component_get_replaces(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_component_get_requires")]
    #[doc(alias = "get_requires")]
    fn requires(&self) -> Vec<Relation> {
        unsafe {
            FromGlibPtrContainer::from_glib_none(ffi::as_component_get_requires(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_component_get_reviews")]
    #[doc(alias = "get_reviews")]
    fn reviews(&self) -> Vec<Review> {
        unsafe {
            FromGlibPtrContainer::from_glib_none(ffi::as_component_get_reviews(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_component_get_scope")]
    #[doc(alias = "get_scope")]
    fn scope(&self) -> ComponentScope {
        unsafe { from_glib(ffi::as_component_get_scope(self.as_ref().to_glib_none().0)) }
    }

    #[doc(alias = "as_component_get_screenshots_all")]
    #[doc(alias = "get_screenshots_all")]
    fn screenshots_all(&self) -> Vec<Screenshot> {
        unsafe {
            FromGlibPtrContainer::from_glib_none(ffi::as_component_get_screenshots_all(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_component_get_search_tokens")]
    #[doc(alias = "get_search_tokens")]
    fn search_tokens(&self) -> Vec<glib::GString> {
        unsafe {
            FromGlibPtrContainer::from_glib_container(ffi::as_component_get_search_tokens(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_component_get_sort_score")]
    #[doc(alias = "get_sort_score")]
    fn sort_score(&self) -> u32 {
        unsafe { ffi::as_component_get_sort_score(self.as_ref().to_glib_none().0) }
    }

    #[doc(alias = "as_component_get_source_pkgname")]
    #[doc(alias = "get_source_pkgname")]
    fn source_pkgname(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::as_component_get_source_pkgname(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_component_get_suggested")]
    #[doc(alias = "get_suggested")]
    fn suggested(&self) -> Vec<Suggested> {
        unsafe {
            FromGlibPtrContainer::from_glib_none(ffi::as_component_get_suggested(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_component_get_summary")]
    #[doc(alias = "get_summary")]
    fn summary(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::as_component_get_summary(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    //#[doc(alias = "as_component_get_summary_table")]
    //#[doc(alias = "get_summary_table")]
    //fn summary_table(&self) -> /*Unknown conversion*//*Unimplemented*/HashTable TypeId { ns_id: 0, id: 25 }/TypeId { ns_id: 0, id: 25 } {
    //    unsafe { TODO: call ffi:as_component_get_summary_table() }
    //}

    #[doc(alias = "as_component_get_supports")]
    #[doc(alias = "get_supports")]
    fn supports(&self) -> Vec<Relation> {
        unsafe {
            FromGlibPtrContainer::from_glib_none(ffi::as_component_get_supports(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    //#[doc(alias = "as_component_get_system_compatibility_score")]
    //#[doc(alias = "get_system_compatibility_score")]
    //fn system_compatibility_score(&self, sysinfo: /*Ignored*/&SystemInfo, is_template: bool, results: /*Ignored*/Vec<RelationCheckResult>) -> i32 {
    //    unsafe { TODO: call ffi:as_component_get_system_compatibility_score() }
    //}

    #[doc(alias = "as_component_get_timestamp_eol")]
    #[doc(alias = "get_timestamp_eol")]
    fn timestamp_eol(&self) -> u64 {
        unsafe { ffi::as_component_get_timestamp_eol(self.as_ref().to_glib_none().0) }
    }

    #[doc(alias = "as_component_get_translations")]
    #[doc(alias = "get_translations")]
    fn translations(&self) -> Vec<Translation> {
        unsafe {
            FromGlibPtrContainer::from_glib_none(ffi::as_component_get_translations(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_component_get_url")]
    #[doc(alias = "get_url")]
    fn url(&self, url_kind: UrlKind) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::as_component_get_url(
                self.as_ref().to_glib_none().0,
                url_kind.into_glib(),
            ))
        }
    }

    #[doc(alias = "as_component_has_bundle")]
    fn has_bundle(&self) -> bool {
        unsafe { from_glib(ffi::as_component_has_bundle(self.as_ref().to_glib_none().0)) }
    }

    #[doc(alias = "as_component_has_category")]
    fn has_category(&self, category: &str) -> bool {
        unsafe {
            from_glib(ffi::as_component_has_category(
                self.as_ref().to_glib_none().0,
                category.to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_component_has_tag")]
    fn has_tag(&self, ns: &str, tag: &str) -> bool {
        unsafe {
            from_glib(ffi::as_component_has_tag(
                self.as_ref().to_glib_none().0,
                ns.to_glib_none().0,
                tag.to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_component_insert_custom_value")]
    fn insert_custom_value(&self, key: &str, value: &str) -> bool {
        unsafe {
            from_glib(ffi::as_component_insert_custom_value(
                self.as_ref().to_glib_none().0,
                key.to_glib_none().0,
                value.to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_component_is_compulsory_for_desktop")]
    fn is_compulsory_for_desktop(&self, desktop: &str) -> bool {
        unsafe {
            from_glib(ffi::as_component_is_compulsory_for_desktop(
                self.as_ref().to_glib_none().0,
                desktop.to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_component_is_floss")]
    fn is_floss(&self) -> bool {
        unsafe { from_glib(ffi::as_component_is_floss(self.as_ref().to_glib_none().0)) }
    }

    #[doc(alias = "as_component_is_ignored")]
    fn is_ignored(&self) -> bool {
        unsafe { from_glib(ffi::as_component_is_ignored(self.as_ref().to_glib_none().0)) }
    }

    #[doc(alias = "as_component_is_member_of_category")]
    fn is_member_of_category(&self, category: &impl IsA<Category>) -> bool {
        unsafe {
            from_glib(ffi::as_component_is_member_of_category(
                self.as_ref().to_glib_none().0,
                category.as_ref().to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_component_is_valid")]
    fn is_valid(&self) -> bool {
        unsafe { from_glib(ffi::as_component_is_valid(self.as_ref().to_glib_none().0)) }
    }

    #[doc(alias = "as_component_load_from_bytes")]
    fn load_from_bytes(
        &self,
        context: &impl IsA<Context>,
        format: FormatKind,
        bytes: &glib::Bytes,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::as_component_load_from_bytes(
                self.as_ref().to_glib_none().0,
                context.as_ref().to_glib_none().0,
                format.into_glib(),
                bytes.to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    #[doc(alias = "as_component_load_releases")]
    fn load_releases(&self, allow_net: bool) -> Result<Option<ReleaseList>, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::as_component_load_releases(
                self.as_ref().to_glib_none().0,
                allow_net.into_glib(),
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_none(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    #[doc(alias = "as_component_remove_tag")]
    fn remove_tag(&self, ns: &str, tag: &str) -> bool {
        unsafe {
            from_glib(ffi::as_component_remove_tag(
                self.as_ref().to_glib_none().0,
                ns.to_glib_none().0,
                tag.to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "as_component_search_matches")]
    fn search_matches(&self, term: &str) -> u32 {
        unsafe {
            ffi::as_component_search_matches(self.as_ref().to_glib_none().0, term.to_glib_none().0)
        }
    }

    #[doc(alias = "as_component_set_branch")]
    fn set_branch(&self, branch: &str) {
        unsafe {
            ffi::as_component_set_branch(self.as_ref().to_glib_none().0, branch.to_glib_none().0);
        }
    }

    #[doc(alias = "as_component_set_branding")]
    fn set_branding(&self, branding: &impl IsA<Branding>) {
        unsafe {
            ffi::as_component_set_branding(
                self.as_ref().to_glib_none().0,
                branding.as_ref().to_glib_none().0,
            );
        }
    }

    #[doc(alias = "as_component_set_compulsory_for_desktop")]
    fn set_compulsory_for_desktop(&self, desktop: &str) {
        unsafe {
            ffi::as_component_set_compulsory_for_desktop(
                self.as_ref().to_glib_none().0,
                desktop.to_glib_none().0,
            );
        }
    }

    #[doc(alias = "as_component_set_context")]
    fn set_context(&self, context: &impl IsA<Context>) {
        unsafe {
            ffi::as_component_set_context(
                self.as_ref().to_glib_none().0,
                context.as_ref().to_glib_none().0,
            );
        }
    }

    #[doc(alias = "as_component_set_context_locale")]
    fn set_context_locale(&self, locale: &str) {
        unsafe {
            ffi::as_component_set_context_locale(
                self.as_ref().to_glib_none().0,
                locale.to_glib_none().0,
            );
        }
    }

    #[doc(alias = "as_component_set_data_id")]
    fn set_data_id(&self, value: &str) {
        unsafe {
            ffi::as_component_set_data_id(self.as_ref().to_glib_none().0, value.to_glib_none().0);
        }
    }

    #[doc(alias = "as_component_set_date_eol")]
    fn set_date_eol(&self, date: &str) {
        unsafe {
            ffi::as_component_set_date_eol(self.as_ref().to_glib_none().0, date.to_glib_none().0);
        }
    }

    #[doc(alias = "as_component_set_description")]
    #[doc(alias = "description")]
    fn set_description(&self, value: &str, locale: Option<&str>) {
        unsafe {
            ffi::as_component_set_description(
                self.as_ref().to_glib_none().0,
                value.to_glib_none().0,
                locale.to_glib_none().0,
            );
        }
    }

    //#[doc(alias = "as_component_set_developer")]
    //fn set_developer(&self, developer: /*Ignored*/&Developer) {
    //    unsafe { TODO: call ffi:as_component_set_developer() }
    //}

    #[doc(alias = "as_component_set_id")]
    #[doc(alias = "id")]
    fn set_id(&self, value: &str) {
        unsafe {
            ffi::as_component_set_id(self.as_ref().to_glib_none().0, value.to_glib_none().0);
        }
    }

    #[doc(alias = "as_component_set_keywords")]
    #[doc(alias = "keywords")]
    fn set_keywords(&self, new_keywords: &[&str], locale: Option<&str>, deep_copy: bool) {
        unsafe {
            ffi::as_component_set_keywords(
                self.as_ref().to_glib_none().0,
                new_keywords.to_glib_none().0,
                locale.to_glib_none().0,
                deep_copy.into_glib(),
            );
        }
    }

    #[doc(alias = "as_component_set_kind")]
    #[doc(alias = "kind")]
    fn set_kind(&self, value: ComponentKind) {
        unsafe {
            ffi::as_component_set_kind(self.as_ref().to_glib_none().0, value.into_glib());
        }
    }

    #[doc(alias = "as_component_set_merge_kind")]
    fn set_merge_kind(&self, kind: MergeKind) {
        unsafe {
            ffi::as_component_set_merge_kind(self.as_ref().to_glib_none().0, kind.into_glib());
        }
    }

    #[doc(alias = "as_component_set_metadata_license")]
    fn set_metadata_license(&self, value: &str) {
        unsafe {
            ffi::as_component_set_metadata_license(
                self.as_ref().to_glib_none().0,
                value.to_glib_none().0,
            );
        }
    }

    #[doc(alias = "as_component_set_name")]
    #[doc(alias = "name")]
    fn set_name(&self, value: &str, locale: Option<&str>) {
        unsafe {
            ffi::as_component_set_name(
                self.as_ref().to_glib_none().0,
                value.to_glib_none().0,
                locale.to_glib_none().0,
            );
        }
    }

    #[doc(alias = "as_component_set_name_variant_suffix")]
    fn set_name_variant_suffix(&self, value: &str, locale: Option<&str>) {
        unsafe {
            ffi::as_component_set_name_variant_suffix(
                self.as_ref().to_glib_none().0,
                value.to_glib_none().0,
                locale.to_glib_none().0,
            );
        }
    }

    #[doc(alias = "as_component_set_origin")]
    fn set_origin(&self, origin: &str) {
        unsafe {
            ffi::as_component_set_origin(self.as_ref().to_glib_none().0, origin.to_glib_none().0);
        }
    }

    #[doc(alias = "as_component_set_pkgname")]
    fn set_pkgname(&self, pkgname: &str) {
        unsafe {
            ffi::as_component_set_pkgname(self.as_ref().to_glib_none().0, pkgname.to_glib_none().0);
        }
    }

    #[doc(alias = "as_component_set_pkgnames")]
    #[doc(alias = "pkgnames")]
    fn set_pkgnames(&self, packages: &[&str]) {
        unsafe {
            ffi::as_component_set_pkgnames(
                self.as_ref().to_glib_none().0,
                packages.to_glib_none().0,
            );
        }
    }

    #[doc(alias = "as_component_set_priority")]
    fn set_priority(&self, priority: i32) {
        unsafe {
            ffi::as_component_set_priority(self.as_ref().to_glib_none().0, priority);
        }
    }

    #[doc(alias = "as_component_set_project_group")]
    #[doc(alias = "project-group")]
    fn set_project_group(&self, value: &str) {
        unsafe {
            ffi::as_component_set_project_group(
                self.as_ref().to_glib_none().0,
                value.to_glib_none().0,
            );
        }
    }

    #[doc(alias = "as_component_set_project_license")]
    #[doc(alias = "project-license")]
    fn set_project_license(&self, value: &str) {
        unsafe {
            ffi::as_component_set_project_license(
                self.as_ref().to_glib_none().0,
                value.to_glib_none().0,
            );
        }
    }

    #[doc(alias = "as_component_set_releases")]
    fn set_releases(&self, releases: &impl IsA<ReleaseList>) {
        unsafe {
            ffi::as_component_set_releases(
                self.as_ref().to_glib_none().0,
                releases.as_ref().to_glib_none().0,
            );
        }
    }

    #[doc(alias = "as_component_set_scope")]
    fn set_scope(&self, scope: ComponentScope) {
        unsafe {
            ffi::as_component_set_scope(self.as_ref().to_glib_none().0, scope.into_glib());
        }
    }

    #[doc(alias = "as_component_set_sort_score")]
    fn set_sort_score(&self, score: u32) {
        unsafe {
            ffi::as_component_set_sort_score(self.as_ref().to_glib_none().0, score);
        }
    }

    #[doc(alias = "as_component_set_source_pkgname")]
    fn set_source_pkgname(&self, spkgname: &str) {
        unsafe {
            ffi::as_component_set_source_pkgname(
                self.as_ref().to_glib_none().0,
                spkgname.to_glib_none().0,
            );
        }
    }

    #[doc(alias = "as_component_set_summary")]
    #[doc(alias = "summary")]
    fn set_summary(&self, value: &str, locale: Option<&str>) {
        unsafe {
            ffi::as_component_set_summary(
                self.as_ref().to_glib_none().0,
                value.to_glib_none().0,
                locale.to_glib_none().0,
            );
        }
    }

    #[doc(alias = "as_component_sort_screenshots")]
    fn sort_screenshots(
        &self,
        environment: Option<&str>,
        style: Option<&str>,
        prioritize_style: bool,
    ) {
        unsafe {
            ffi::as_component_sort_screenshots(
                self.as_ref().to_glib_none().0,
                environment.to_glib_none().0,
                style.to_glib_none().0,
                prioritize_style.into_glib(),
            );
        }
    }

    #[doc(alias = "as_component_to_string")]
    #[doc(alias = "to_string")]
    fn to_str(&self) -> glib::GString {
        unsafe { from_glib_full(ffi::as_component_to_string(self.as_ref().to_glib_none().0)) }
    }

    #[doc(alias = "as_component_to_xml_data")]
    fn to_xml_data(&self, context: &impl IsA<Context>) -> Result<glib::GString, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::as_component_to_xml_data(
                self.as_ref().to_glib_none().0,
                context.as_ref().to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    //fn urls(&self) -> /*Unimplemented*/HashTable TypeId { ns_id: 1, id: 39 }/TypeId { ns_id: 0, id: 28 } {
    //    ObjectExt::property(self.as_ref(), "urls")
    //}

    #[doc(alias = "categories")]
    fn connect_categories_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_categories_trampoline<
            P: IsA<Component>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::AsComponent,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Component::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::categories".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_categories_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<Component>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::AsComponent,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Component::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::description".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 = "icons")]
    fn connect_icons_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_icons_trampoline<P: IsA<Component>, F: Fn(&P) + 'static>(
            this: *mut ffi::AsComponent,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Component::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::icons".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_icons_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<Component>, F: Fn(&P) + 'static>(
            this: *mut ffi::AsComponent,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Component::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::id".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 = "keywords")]
    fn connect_keywords_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_keywords_trampoline<P: IsA<Component>, F: Fn(&P) + 'static>(
            this: *mut ffi::AsComponent,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Component::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::keywords".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_keywords_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

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

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

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

    #[doc(alias = "project-group")]
    fn connect_project_group_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_project_group_trampoline<
            P: IsA<Component>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::AsComponent,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Component::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::project-group".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_project_group_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "project-license")]
    fn connect_project_license_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_project_license_trampoline<
            P: IsA<Component>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::AsComponent,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Component::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::project-license".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_project_license_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "screenshots")]
    fn connect_screenshots_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_screenshots_trampoline<
            P: IsA<Component>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::AsComponent,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Component::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::screenshots".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_screenshots_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<Component>, F: Fn(&P) + 'static>(
            this: *mut ffi::AsComponent,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Component::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::summary".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 = "urls")]
    fn connect_urls_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_urls_trampoline<P: IsA<Component>, F: Fn(&P) + 'static>(
            this: *mut ffi::AsComponent,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Component::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::urls".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_urls_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

impl<O: IsA<Component>> ComponentExt for O {}