atk/auto/

relation_set.rs

// 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::{Object, Relation, RelationType};
use glib::{prelude::*, translate::*};
use std::fmt;

glib::wrapper! {
    /// A set of AtkRelations, normally the set of
    ///  AtkRelations which an AtkObject has.
    ///
    /// The AtkRelationSet held by an object establishes its relationships
    /// with objects beyond the normal "parent/child" hierarchical
    /// relationships that all user interface objects have.
    /// AtkRelationSets establish whether objects are labelled or
    /// controlled by other components, share group membership with other
    /// components (for instance within a radio-button group), or share
    /// content which "flows" between them, among other types of possible
    /// relationships.
    ///
    /// # Implements
    ///
    /// [`RelationSetExt`][trait@crate::prelude::RelationSetExt], [`trait@glib::ObjectExt`]
    #[doc(alias = "AtkRelationSet")]
    pub struct RelationSet(Object<ffi::AtkRelationSet, ffi::AtkRelationSetClass>);

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

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

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

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

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

/// Trait containing all [`struct@RelationSet`] methods.
///
/// # Implementors
///
/// [`RelationSet`][struct@crate::RelationSet]
pub trait RelationSetExt: IsA<RelationSet> + sealed::Sealed + 'static {
    /// Add a new relation to the current relation set if it is not already
    /// present.
    /// This function ref's the AtkRelation so the caller of this function
    /// should unref it to ensure that it will be destroyed when the AtkRelationSet
    /// is destroyed.
    /// ## `relation`
    /// an [`Relation`][crate::Relation]
    #[doc(alias = "atk_relation_set_add")]
    fn add(&self, relation: &impl IsA<Relation>) {
        unsafe {
            ffi::atk_relation_set_add(
                self.as_ref().to_glib_none().0,
                relation.as_ref().to_glib_none().0,
            );
        }
    }

    /// Add a new relation of the specified type with the specified target to
    /// the current relation set if the relation set does not contain a relation
    /// of that type. If it is does contain a relation of that typea the target
    /// is added to the relation.
    /// ## `relationship`
    /// an [`RelationType`][crate::RelationType]
    /// ## `target`
    /// an [`Object`][crate::Object]
    #[doc(alias = "atk_relation_set_add_relation_by_type")]
    fn add_relation_by_type(&self, relationship: RelationType, target: &impl IsA<Object>) {
        unsafe {
            ffi::atk_relation_set_add_relation_by_type(
                self.as_ref().to_glib_none().0,
                relationship.into_glib(),
                target.as_ref().to_glib_none().0,
            );
        }
    }

    /// Determines whether the relation set contains a relation that matches the
    /// specified type.
    /// ## `relationship`
    /// an [`RelationType`][crate::RelationType]
    ///
    /// # Returns
    ///
    /// [`true`] if `relationship` is the relationship type of a relation
    /// in `self`, [`false`] otherwise
    #[doc(alias = "atk_relation_set_contains")]
    fn contains(&self, relationship: RelationType) -> bool {
        unsafe {
            from_glib(ffi::atk_relation_set_contains(
                self.as_ref().to_glib_none().0,
                relationship.into_glib(),
            ))
        }
    }

    /// Determines whether the relation set contains a relation that
    /// matches the specified pair formed by type `relationship` and object
    /// `target`.
    /// ## `relationship`
    /// an [`RelationType`][crate::RelationType]
    /// ## `target`
    /// an [`Object`][crate::Object]
    ///
    /// # Returns
    ///
    /// [`true`] if `self` contains a relation with the relationship
    /// type `relationship` with an object `target`, [`false`] otherwise
    #[doc(alias = "atk_relation_set_contains_target")]
    fn contains_target(&self, relationship: RelationType, target: &impl IsA<Object>) -> bool {
        unsafe {
            from_glib(ffi::atk_relation_set_contains_target(
                self.as_ref().to_glib_none().0,
                relationship.into_glib(),
                target.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Determines the number of relations in a relation set.
    ///
    /// # Returns
    ///
    /// an integer representing the number of relations in the set.
    #[doc(alias = "atk_relation_set_get_n_relations")]
    #[doc(alias = "get_n_relations")]
    fn n_relations(&self) -> i32 {
        unsafe { ffi::atk_relation_set_get_n_relations(self.as_ref().to_glib_none().0) }
    }

    /// Determines the relation at the specified position in the relation set.
    /// ## `i`
    /// a gint representing a position in the set, starting from 0.
    ///
    /// # Returns
    ///
    /// a [`Relation`][crate::Relation], which is the relation at
    /// position i in the set.
    #[doc(alias = "atk_relation_set_get_relation")]
    #[doc(alias = "get_relation")]
    fn relation(&self, i: i32) -> Option<Relation> {
        unsafe {
            from_glib_none(ffi::atk_relation_set_get_relation(
                self.as_ref().to_glib_none().0,
                i,
            ))
        }
    }

    /// Finds a relation that matches the specified type.
    /// ## `relationship`
    /// an [`RelationType`][crate::RelationType]
    ///
    /// # Returns
    ///
    /// an [`Relation`][crate::Relation], which is a relation matching the
    /// specified type.
    #[doc(alias = "atk_relation_set_get_relation_by_type")]
    #[doc(alias = "get_relation_by_type")]
    fn relation_by_type(&self, relationship: RelationType) -> Option<Relation> {
        unsafe {
            from_glib_none(ffi::atk_relation_set_get_relation_by_type(
                self.as_ref().to_glib_none().0,
                relationship.into_glib(),
            ))
        }
    }

    /// Removes a relation from the relation set.
    /// This function unref's the [`Relation`][crate::Relation] so it will be deleted unless there
    /// is another reference to it.
    /// ## `relation`
    /// an [`Relation`][crate::Relation]
    #[doc(alias = "atk_relation_set_remove")]
    fn remove(&self, relation: &impl IsA<Relation>) {
        unsafe {
            ffi::atk_relation_set_remove(
                self.as_ref().to_glib_none().0,
                relation.as_ref().to_glib_none().0,
            );
        }
    }
}

impl<O: IsA<RelationSet>> RelationSetExt for O {}

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