// 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 crate::{GutterRenderer, View};
use glib::{prelude::*, translate::*};
use std::fmt;

glib::wrapper! {
    ///
    ///
    /// ## Properties
    ///
    ///
    /// #### `view`
    ///  The [`View`][crate::View] of the gutter.
    ///
    /// Readable | Writeable | Construct Only
    ///
    ///
    /// #### `window-type`
    ///  The text window type on which the window is placed.
    ///
    /// Readable | Writeable | Construct Only
    ///
    /// # Implements
    ///
    /// [`GutterExt`][trait@crate::prelude::GutterExt]
    #[doc(alias = "GtkSourceGutter")]
    pub struct Gutter(Object<ffi::GtkSourceGutter, ffi::GtkSourceGutterClass>);

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

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

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

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

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

    /// The [`View`][crate::View] of the gutter.
    pub fn view(self, view: &impl IsA<View>) -> Self {
        Self {
            builder: self.builder.property("view", view.clone().upcast()),
        }
    }

    /// The text window type on which the window is placed.
    pub fn window_type(self, window_type: gtk::TextWindowType) -> Self {
        Self {
            builder: self.builder.property("window-type", window_type),
        }
    }

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

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

/// Trait containing all [`struct@Gutter`] methods.
///
/// # Implementors
///
/// [`Gutter`][struct@crate::Gutter]
pub trait GutterExt: IsA<Gutter> + sealed::Sealed + 'static {
    /// Finds the [`GutterRenderer`][crate::GutterRenderer] at (x, y).
    /// ## `x`
    /// The x position to get identified.
    /// ## `y`
    /// The y position to get identified.
    ///
    /// # Returns
    ///
    /// the renderer at (x, y) or [`None`].
    #[doc(alias = "gtk_source_gutter_get_renderer_at_pos")]
    #[doc(alias = "get_renderer_at_pos")]
    fn renderer_at_pos(&self, x: i32, y: i32) -> Option<GutterRenderer> {
        unsafe {
            from_glib_none(ffi::gtk_source_gutter_get_renderer_at_pos(
                self.as_ref().to_glib_none().0,
                x,
                y,
            ))
        }
    }

    ///
    /// # Returns
    ///
    /// the associated [`View`][crate::View].
    #[doc(alias = "gtk_source_gutter_get_view")]
    #[doc(alias = "get_view")]
    fn view(&self) -> Option<View> {
        unsafe {
            from_glib_none(ffi::gtk_source_gutter_get_view(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    ///
    /// # Returns
    ///
    /// the [`gtk::TextWindowType`][crate::gtk::TextWindowType] of `self`.
    #[doc(alias = "gtk_source_gutter_get_window_type")]
    #[doc(alias = "get_window_type")]
    fn window_type(&self) -> gtk::TextWindowType {
        unsafe {
            from_glib(ffi::gtk_source_gutter_get_window_type(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Insert `renderer` into the gutter. If `renderer` is yet unowned then gutter
    /// claims its ownership. Otherwise just increases renderer's reference count.
    /// `renderer` cannot be already inserted to another gutter.
    /// ## `renderer`
    /// a gutter renderer (must inherit from [`GutterRenderer`][crate::GutterRenderer]).
    /// ## `position`
    /// the renderer position.
    ///
    /// # Returns
    ///
    /// [`true`] if operation succeeded. Otherwise [`false`].
    #[doc(alias = "gtk_source_gutter_insert")]
    fn insert(&self, renderer: &impl IsA<GutterRenderer>, position: i32) -> bool {
        unsafe {
            from_glib(ffi::gtk_source_gutter_insert(
                self.as_ref().to_glib_none().0,
                renderer.as_ref().to_glib_none().0,
                position,
            ))
        }
    }

    /// Invalidates the drawable area of the gutter. You can use this to force a
    /// redraw of the gutter if something has changed and needs to be redrawn.
    #[doc(alias = "gtk_source_gutter_queue_draw")]
    fn queue_draw(&self) {
        unsafe {
            ffi::gtk_source_gutter_queue_draw(self.as_ref().to_glib_none().0);
        }
    }

    /// Removes `renderer` from `self`.
    /// ## `renderer`
    /// a [`GutterRenderer`][crate::GutterRenderer].
    #[doc(alias = "gtk_source_gutter_remove")]
    fn remove(&self, renderer: &impl IsA<GutterRenderer>) {
        unsafe {
            ffi::gtk_source_gutter_remove(
                self.as_ref().to_glib_none().0,
                renderer.as_ref().to_glib_none().0,
            );
        }
    }

    /// Reorders `renderer` in `self` to new `position`.
    /// ## `renderer`
    /// a `GtkCellRenderer`.
    /// ## `position`
    /// the new renderer position.
    #[doc(alias = "gtk_source_gutter_reorder")]
    fn reorder(&self, renderer: &impl IsA<GutterRenderer>, position: i32) {
        unsafe {
            ffi::gtk_source_gutter_reorder(
                self.as_ref().to_glib_none().0,
                renderer.as_ref().to_glib_none().0,
                position,
            );
        }
    }
}

impl<O: IsA<Gutter>> GutterExt for O {}

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