// 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::{ConstraintAttribute, ConstraintRelation, ConstraintTarget};
use glib::{prelude::*, translate::*};

glib::wrapper! {
    /// [`Constraint`][crate::Constraint] describes a constraint between attributes of two widgets,
    ///  expressed as a linear equation.
    ///
    /// The typical equation for a constraint is:
    ///
    /// ```text
    ///   target.target_attr = source.source_attr × multiplier + constant
    /// ```
    ///
    /// Each [`Constraint`][crate::Constraint] is part of a system that will be solved by a
    /// [`ConstraintLayout`][crate::ConstraintLayout] in order to allocate and position each
    /// child widget or guide.
    ///
    /// The source and target, as well as their attributes, of a [`Constraint`][crate::Constraint]
    /// instance are immutable after creation.
    ///
    /// ## Properties
    ///
    ///
    /// #### `constant`
    ///  The constant value to be added to the [`source-attribute`][struct@crate::Constraint#source-attribute].
    ///
    /// Readable | Writeable | Construct Only
    ///
    ///
    /// #### `multiplier`
    ///  The multiplication factor to be applied to
    /// the [`source-attribute`][struct@crate::Constraint#source-attribute].
    ///
    /// Readable | Writeable | Construct Only
    ///
    ///
    /// #### `relation`
    ///  The order relation between the terms of the constraint.
    ///
    /// Readable | Writeable | Construct Only
    ///
    ///
    /// #### `source`
    ///  The source of the constraint.
    ///
    /// The constraint will set the [`target-attribute`][struct@crate::Constraint#target-attribute]
    /// property of the target using the [`source-attribute`][struct@crate::Constraint#source-attribute]
    /// property of the source.
    ///
    /// Readable | Writeable | Construct Only
    ///
    ///
    /// #### `source-attribute`
    ///  The attribute of the [`source`][struct@crate::Constraint#source] read by the
    /// constraint.
    ///
    /// Readable | Writeable | Construct Only
    ///
    ///
    /// #### `strength`
    ///  The strength of the constraint.
    ///
    /// The strength can be expressed either using one of the symbolic values
    /// of the [`ConstraintStrength`][crate::ConstraintStrength] enumeration, or any positive integer
    /// value.
    ///
    /// Readable | Writeable | Construct Only
    ///
    ///
    /// #### `target`
    ///  The target of the constraint.
    ///
    /// The constraint will set the [`target-attribute`][struct@crate::Constraint#target-attribute]
    /// property of the target using the [`source-attribute`][struct@crate::Constraint#source-attribute]
    /// property of the source widget.
    ///
    /// Readable | Writeable | Construct Only
    ///
    ///
    /// #### `target-attribute`
    ///  The attribute of the [`target`][struct@crate::Constraint#target] set by the constraint.
    ///
    /// Readable | Writeable | Construct Only
    ///
    /// # Implements
    ///
    /// [`trait@glib::ObjectExt`]
    #[doc(alias = "GtkConstraint")]
    pub struct Constraint(Object<ffi::GtkConstraint, ffi::GtkConstraintClass>);

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

impl Constraint {
    /// Creates a new constraint representing a relation between a layout
    /// attribute on a source and a layout attribute on a target.
    /// ## `target`
    /// the target of the constraint
    /// ## `target_attribute`
    /// the attribute of `target` to be set
    /// ## `relation`
    /// the relation equivalence between `target_attribute` and `source_attribute`
    /// ## `source`
    /// the source of the constraint
    /// ## `source_attribute`
    /// the attribute of `source` to be read
    /// ## `multiplier`
    /// a multiplication factor to be applied to `source_attribute`
    /// ## `constant`
    /// a constant factor to be added to `source_attribute`
    /// ## `strength`
    /// the strength of the constraint
    ///
    /// # Returns
    ///
    /// the newly created constraint
    #[doc(alias = "gtk_constraint_new")]
    pub fn new(
        target: Option<&impl IsA<ConstraintTarget>>,
        target_attribute: ConstraintAttribute,
        relation: ConstraintRelation,
        source: Option<&impl IsA<ConstraintTarget>>,
        source_attribute: ConstraintAttribute,
        multiplier: f64,
        constant: f64,
        strength: i32,
    ) -> Constraint {
        assert_initialized_main_thread!();
        unsafe {
            from_glib_full(ffi::gtk_constraint_new(
                target.map(|p| p.as_ref()).to_glib_none().0,
                target_attribute.into_glib(),
                relation.into_glib(),
                source.map(|p| p.as_ref()).to_glib_none().0,
                source_attribute.into_glib(),
                multiplier,
                constant,
                strength,
            ))
        }
    }

    /// Creates a new constraint representing a relation between a layout
    /// attribute on a target and a constant value.
    /// ## `target`
    /// a the target of the constraint
    /// ## `target_attribute`
    /// the attribute of `target` to be set
    /// ## `relation`
    /// the relation equivalence between `target_attribute` and `constant`
    /// ## `constant`
    /// a constant factor to be set on `target_attribute`
    /// ## `strength`
    /// the strength of the constraint
    ///
    /// # Returns
    ///
    /// the newly created constraint
    #[doc(alias = "gtk_constraint_new_constant")]
    pub fn new_constant(
        target: Option<&impl IsA<ConstraintTarget>>,
        target_attribute: ConstraintAttribute,
        relation: ConstraintRelation,
        constant: f64,
        strength: i32,
    ) -> Constraint {
        assert_initialized_main_thread!();
        unsafe {
            from_glib_full(ffi::gtk_constraint_new_constant(
                target.map(|p| p.as_ref()).to_glib_none().0,
                target_attribute.into_glib(),
                relation.into_glib(),
                constant,
                strength,
            ))
        }
    }

    // rustdoc-stripper-ignore-next
    /// Creates a new builder-pattern struct instance to construct [`Constraint`] objects.
    ///
    /// This method returns an instance of [`ConstraintBuilder`](crate::builders::ConstraintBuilder) which can be used to create [`Constraint`] objects.
    pub fn builder() -> ConstraintBuilder {
        ConstraintBuilder::new()
    }

    /// Retrieves the constant factor added to the source attributes' value.
    ///
    /// # Returns
    ///
    /// a constant factor
    #[doc(alias = "gtk_constraint_get_constant")]
    #[doc(alias = "get_constant")]
    pub fn constant(&self) -> f64 {
        unsafe { ffi::gtk_constraint_get_constant(self.to_glib_none().0) }
    }

    /// Retrieves the multiplication factor applied to the source
    /// attribute's value.
    ///
    /// # Returns
    ///
    /// a multiplication factor
    #[doc(alias = "gtk_constraint_get_multiplier")]
    #[doc(alias = "get_multiplier")]
    pub fn multiplier(&self) -> f64 {
        unsafe { ffi::gtk_constraint_get_multiplier(self.to_glib_none().0) }
    }

    /// The order relation between the terms of the constraint.
    ///
    /// # Returns
    ///
    /// a relation type
    #[doc(alias = "gtk_constraint_get_relation")]
    #[doc(alias = "get_relation")]
    pub fn relation(&self) -> ConstraintRelation {
        unsafe { from_glib(ffi::gtk_constraint_get_relation(self.to_glib_none().0)) }
    }

    /// Retrieves the [`ConstraintTarget`][crate::ConstraintTarget] used as the source for the
    /// constraint.
    ///
    /// If the source is set to `NULL` at creation, the constraint will use
    /// the widget using the [`ConstraintLayout`][crate::ConstraintLayout] as the source.
    ///
    /// # Returns
    ///
    /// the source of the constraint
    #[doc(alias = "gtk_constraint_get_source")]
    #[doc(alias = "get_source")]
    pub fn source(&self) -> Option<ConstraintTarget> {
        unsafe { from_glib_none(ffi::gtk_constraint_get_source(self.to_glib_none().0)) }
    }

    /// Retrieves the attribute of the source to be read by the constraint.
    ///
    /// # Returns
    ///
    /// the source's attribute
    #[doc(alias = "gtk_constraint_get_source_attribute")]
    #[doc(alias = "get_source_attribute")]
    pub fn source_attribute(&self) -> ConstraintAttribute {
        unsafe {
            from_glib(ffi::gtk_constraint_get_source_attribute(
                self.to_glib_none().0,
            ))
        }
    }

    /// Retrieves the strength of the constraint.
    ///
    /// # Returns
    ///
    /// the strength value
    #[doc(alias = "gtk_constraint_get_strength")]
    #[doc(alias = "get_strength")]
    pub fn strength(&self) -> i32 {
        unsafe { ffi::gtk_constraint_get_strength(self.to_glib_none().0) }
    }

    /// Retrieves the [`ConstraintTarget`][crate::ConstraintTarget] used as the target for
    /// the constraint.
    ///
    /// If the targe is set to `NULL` at creation, the constraint will use
    /// the widget using the [`ConstraintLayout`][crate::ConstraintLayout] as the target.
    ///
    /// # Returns
    ///
    /// a [`ConstraintTarget`][crate::ConstraintTarget]
    #[doc(alias = "gtk_constraint_get_target")]
    #[doc(alias = "get_target")]
    pub fn target(&self) -> Option<ConstraintTarget> {
        unsafe { from_glib_none(ffi::gtk_constraint_get_target(self.to_glib_none().0)) }
    }

    /// Retrieves the attribute of the target to be set by the constraint.
    ///
    /// # Returns
    ///
    /// the target's attribute
    #[doc(alias = "gtk_constraint_get_target_attribute")]
    #[doc(alias = "get_target_attribute")]
    pub fn target_attribute(&self) -> ConstraintAttribute {
        unsafe {
            from_glib(ffi::gtk_constraint_get_target_attribute(
                self.to_glib_none().0,
            ))
        }
    }

    /// Checks whether the constraint is attached to a [`ConstraintLayout`][crate::ConstraintLayout],
    /// and it is contributing to the layout.
    ///
    /// # Returns
    ///
    /// `TRUE` if the constraint is attached
    #[doc(alias = "gtk_constraint_is_attached")]
    pub fn is_attached(&self) -> bool {
        unsafe { from_glib(ffi::gtk_constraint_is_attached(self.to_glib_none().0)) }
    }

    /// Checks whether the constraint describes a relation between an attribute
    /// on the [`target`][struct@crate::Constraint#target] and a constant value.
    ///
    /// # Returns
    ///
    /// `TRUE` if the constraint is a constant relation
    #[doc(alias = "gtk_constraint_is_constant")]
    pub fn is_constant(&self) -> bool {
        unsafe { from_glib(ffi::gtk_constraint_is_constant(self.to_glib_none().0)) }
    }

    /// Checks whether the constraint is a required relation for solving the
    /// constraint layout.
    ///
    /// # Returns
    ///
    /// [`true`] if the constraint is required
    #[doc(alias = "gtk_constraint_is_required")]
    pub fn is_required(&self) -> bool {
        unsafe { from_glib(ffi::gtk_constraint_is_required(self.to_glib_none().0)) }
    }
}

impl Default for Constraint {
    fn default() -> Self {
        glib::object::Object::new::<Self>()
    }
}

// rustdoc-stripper-ignore-next
/// A [builder-pattern] type to construct [`Constraint`] objects.
///
/// [builder-pattern]: https://doc.rust-lang.org/1.0.0/style/ownership/builders.html
#[must_use = "The builder must be built to be used"]
pub struct ConstraintBuilder {
    builder: glib::object::ObjectBuilder<'static, Constraint>,
}

impl ConstraintBuilder {
    fn new() -> Self {
        Self {
            builder: glib::object::Object::builder(),
        }
    }

    /// The constant value to be added to the [`source-attribute`][struct@crate::Constraint#source-attribute].
    pub fn constant(self, constant: f64) -> Self {
        Self {
            builder: self.builder.property("constant", constant),
        }
    }

    /// The multiplication factor to be applied to
    /// the [`source-attribute`][struct@crate::Constraint#source-attribute].
    pub fn multiplier(self, multiplier: f64) -> Self {
        Self {
            builder: self.builder.property("multiplier", multiplier),
        }
    }

    /// The order relation between the terms of the constraint.
    pub fn relation(self, relation: ConstraintRelation) -> Self {
        Self {
            builder: self.builder.property("relation", relation),
        }
    }

    /// The source of the constraint.
    ///
    /// The constraint will set the [`target-attribute`][struct@crate::Constraint#target-attribute]
    /// property of the target using the [`source-attribute`][struct@crate::Constraint#source-attribute]
    /// property of the source.
    pub fn source(self, source: &impl IsA<ConstraintTarget>) -> Self {
        Self {
            builder: self.builder.property("source", source.clone().upcast()),
        }
    }

    /// The attribute of the [`source`][struct@crate::Constraint#source] read by the
    /// constraint.
    pub fn source_attribute(self, source_attribute: ConstraintAttribute) -> Self {
        Self {
            builder: self.builder.property("source-attribute", source_attribute),
        }
    }

    /// The strength of the constraint.
    ///
    /// The strength can be expressed either using one of the symbolic values
    /// of the [`ConstraintStrength`][crate::ConstraintStrength] enumeration, or any positive integer
    /// value.
    pub fn strength(self, strength: i32) -> Self {
        Self {
            builder: self.builder.property("strength", strength),
        }
    }

    /// The target of the constraint.
    ///
    /// The constraint will set the [`target-attribute`][struct@crate::Constraint#target-attribute]
    /// property of the target using the [`source-attribute`][struct@crate::Constraint#source-attribute]
    /// property of the source widget.
    pub fn target(self, target: &impl IsA<ConstraintTarget>) -> Self {
        Self {
            builder: self.builder.property("target", target.clone().upcast()),
        }
    }

    /// The attribute of the [`target`][struct@crate::Constraint#target] set by the constraint.
    pub fn target_attribute(self, target_attribute: ConstraintAttribute) -> Self {
        Self {
            builder: self.builder.property("target-attribute", target_attribute),
        }
    }

    // rustdoc-stripper-ignore-next
    /// Build the [`Constraint`].
    #[must_use = "Building the object from the builder is usually expensive and is not expected to have side effects"]
    pub fn build(self) -> Constraint {
        self.builder.build()
    }
}