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

use glib::{prelude::*, translate::*};
use std::fmt;

glib::wrapper! {
    ///
    ///
    /// ## Properties
    ///
    ///
    /// #### `buffer`
    ///  The [`gtk::TextBuffer`][crate::gtk::TextBuffer]. The [`Region`][crate::Region] has a weak reference to the
    /// buffer.
    ///
    /// Readable | Writeable | Construct Only
    ///
    /// # Implements
    ///
    /// [`RegionExt`][trait@crate::prelude::RegionExt]
    #[doc(alias = "GtkSourceRegion")]
    pub struct Region(Object<ffi::GtkSourceRegion, ffi::GtkSourceRegionClass>);

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

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

    /// ## `buffer`
    /// a [`gtk::TextBuffer`][crate::gtk::TextBuffer].
    ///
    /// # Returns
    ///
    /// a new [`Region`][crate::Region] object for `buffer`.
    #[doc(alias = "gtk_source_region_new")]
    pub fn new(buffer: &impl IsA<gtk::TextBuffer>) -> Region {
        assert_initialized_main_thread!();
        unsafe { from_glib_full(ffi::gtk_source_region_new(buffer.as_ref().to_glib_none().0)) }
    }

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

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

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

// rustdoc-stripper-ignore-next
/// A [builder-pattern] type to construct [`Region`] 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 RegionBuilder {
    builder: glib::object::ObjectBuilder<'static, Region>,
}

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

    /// The [`gtk::TextBuffer`][crate::gtk::TextBuffer]. The [`Region`][crate::Region] has a weak reference to the
    /// buffer.
    pub fn buffer(self, buffer: &impl IsA<gtk::TextBuffer>) -> Self {
        Self {
            builder: self.builder.property("buffer", buffer.clone().upcast()),
        }
    }

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

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

/// Trait containing all [`struct@Region`] methods.
///
/// # Implementors
///
/// [`Region`][struct@crate::Region]
pub trait RegionExt: IsA<Region> + sealed::Sealed + 'static {
    /// Adds `region_to_add` to `self`. `region_to_add` is not modified.
    /// ## `region_to_add`
    /// the [`Region`][crate::Region] to add to `self`, or [`None`].
    #[doc(alias = "gtk_source_region_add_region")]
    fn add_region(&self, region_to_add: Option<&impl IsA<Region>>) {
        unsafe {
            ffi::gtk_source_region_add_region(
                self.as_ref().to_glib_none().0,
                region_to_add.map(|p| p.as_ref()).to_glib_none().0,
            );
        }
    }

    /// Adds the subregion delimited by `_start` and `_end` to `self`.
    /// ## `_start`
    /// the start of the subregion.
    /// ## `_end`
    /// the end of the subregion.
    #[doc(alias = "gtk_source_region_add_subregion")]
    fn add_subregion(&self, _start: &gtk::TextIter, _end: &gtk::TextIter) {
        unsafe {
            ffi::gtk_source_region_add_subregion(
                self.as_ref().to_glib_none().0,
                _start.to_glib_none().0,
                _end.to_glib_none().0,
            );
        }
    }

    /// Gets the `start` and `end` bounds of the `self`.
    ///
    /// # Returns
    ///
    /// [`true`] if `start` and `end` have been set successfully (if non-[`None`]),
    ///  or [`false`] if the `self` is empty.
    ///
    /// ## `start`
    /// iterator to initialize with the start of `self`,
    ///  or [`None`].
    ///
    /// ## `end`
    /// iterator to initialize with the end of `self`,
    ///  or [`None`].
    #[doc(alias = "gtk_source_region_get_bounds")]
    #[doc(alias = "get_bounds")]
    fn bounds(&self) -> Option<(gtk::TextIter, gtk::TextIter)> {
        unsafe {
            let mut start = gtk::TextIter::uninitialized();
            let mut end = gtk::TextIter::uninitialized();
            let ret = from_glib(ffi::gtk_source_region_get_bounds(
                self.as_ref().to_glib_none().0,
                start.to_glib_none_mut().0,
                end.to_glib_none_mut().0,
            ));
            if ret {
                Some((start, end))
            } else {
                None
            }
        }
    }

    ///
    /// # Returns
    ///
    /// the [`gtk::TextBuffer`][crate::gtk::TextBuffer].
    #[doc(alias = "gtk_source_region_get_buffer")]
    #[doc(alias = "get_buffer")]
    fn buffer(&self) -> Option<gtk::TextBuffer> {
        unsafe {
            from_glib_none(ffi::gtk_source_region_get_buffer(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    //#[doc(alias = "gtk_source_region_get_start_region_iter")]
    //#[doc(alias = "get_start_region_iter")]
    //fn start_region_iter(&self, iter: /*Ignored*/RegionIter) {
    //    unsafe { TODO: call ffi:gtk_source_region_get_start_region_iter() }
    //}

    /// Returns the intersection between `self` and `region2`. `self` and
    /// `region2` are not modified.
    /// ## `region2`
    /// a [`Region`][crate::Region], or [`None`].
    ///
    /// # Returns
    ///
    /// the intersection as a [`Region`][crate::Region]
    ///  object.
    #[doc(alias = "gtk_source_region_intersect_region")]
    #[must_use]
    fn intersect_region(&self, region2: Option<&impl IsA<Region>>) -> Option<Region> {
        unsafe {
            from_glib_full(ffi::gtk_source_region_intersect_region(
                self.as_ref().to_glib_none().0,
                region2.map(|p| p.as_ref()).to_glib_none().0,
            ))
        }
    }

    /// Returns the intersection between `self` and the subregion delimited by
    /// `_start` and `_end`. `self` is not modified.
    /// ## `_start`
    /// the start of the subregion.
    /// ## `_end`
    /// the end of the subregion.
    ///
    /// # Returns
    ///
    /// the intersection as a new
    ///  [`Region`][crate::Region].
    #[doc(alias = "gtk_source_region_intersect_subregion")]
    #[must_use]
    fn intersect_subregion(&self, _start: &gtk::TextIter, _end: &gtk::TextIter) -> Option<Region> {
        unsafe {
            from_glib_full(ffi::gtk_source_region_intersect_subregion(
                self.as_ref().to_glib_none().0,
                _start.to_glib_none().0,
                _end.to_glib_none().0,
            ))
        }
    }

    /// Returns whether the `self` is empty. A [`None`] `self` is considered empty.
    ///
    /// # Returns
    ///
    /// whether the `self` is empty.
    #[doc(alias = "gtk_source_region_is_empty")]
    fn is_empty(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_source_region_is_empty(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Subtracts `region_to_subtract` from `self`. `region_to_subtract` is not
    /// modified.
    /// ## `region_to_subtract`
    /// the [`Region`][crate::Region] to subtract from
    ///  `self`, or [`None`].
    #[doc(alias = "gtk_source_region_subtract_region")]
    fn subtract_region(&self, region_to_subtract: Option<&impl IsA<Region>>) {
        unsafe {
            ffi::gtk_source_region_subtract_region(
                self.as_ref().to_glib_none().0,
                region_to_subtract.map(|p| p.as_ref()).to_glib_none().0,
            );
        }
    }

    /// Subtracts the subregion delimited by `_start` and `_end` from `self`.
    /// ## `_start`
    /// the start of the subregion.
    /// ## `_end`
    /// the end of the subregion.
    #[doc(alias = "gtk_source_region_subtract_subregion")]
    fn subtract_subregion(&self, _start: &gtk::TextIter, _end: &gtk::TextIter) {
        unsafe {
            ffi::gtk_source_region_subtract_subregion(
                self.as_ref().to_glib_none().0,
                _start.to_glib_none().0,
                _end.to_glib_none().0,
            );
        }
    }

    /// Gets a string represention of `self`, for debugging purposes.
    ///
    /// The returned string contains the character offsets of the subregions. It
    /// doesn't include a newline character at the end of the string.
    ///
    /// # Returns
    ///
    /// a string represention of `self`. Free
    ///  with `g_free()` when no longer needed.
    #[doc(alias = "gtk_source_region_to_string")]
    #[doc(alias = "to_string")]
    fn to_str(&self) -> glib::GString {
        unsafe {
            from_glib_full(ffi::gtk_source_region_to_string(
                self.as_ref().to_glib_none().0,
            ))
        }
    }
}

impl<O: IsA<Region>> RegionExt for O {}