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

use crate::CompletionCell;
use crate::CompletionContext;
use crate::CompletionProposal;
use glib::object::IsA;
use glib::translate::*;
use std::boxed::Box as Box_;
use std::fmt;
use std::pin::Pin;
use std::ptr;

glib::wrapper! {
    pub struct CompletionProvider(Interface<ffi::GtkSourceCompletionProvider, ffi::GtkSourceCompletionProviderInterface>);

    match fn {
        get_type => || ffi::gtk_source_completion_provider_get_type(),
    }
}

pub const NONE_COMPLETION_PROVIDER: Option<&CompletionProvider> = None;

/// Trait containing all `CompletionProvider` methods.
///
/// Feature: `v5_0`
///
/// # Implementors
///
/// [`CompletionProvider`](struct.CompletionProvider.html), [`CompletionSnippets`](struct.CompletionSnippets.html), [`CompletionWords`](struct.CompletionWords.html)
pub trait CompletionProviderExt: 'static {
    /// This function requests `proposal` to be activated by the
    /// `CompletionProvider`.
    ///
    /// What the provider does to activate the proposal is specific to that
    /// provider. Many providers may choose to insert a `Snippet` with
    /// edit points the user may cycle through.
    ///
    /// See also: `Snippet`, `SnippetChunk`, `View::push_snippet`
    ///
    /// Feature: `v5_0`
    ///
    /// ## `context`
    /// a `CompletionContext`
    /// ## `proposal`
    /// a `CompletionProposal`
    #[doc(alias = "gtk_source_completion_provider_activate")]
    fn activate<P: IsA<CompletionProposal>>(&self, context: &CompletionContext, proposal: &P);

    /// This function requests that the `CompletionProvider` prepares
    /// `cell` to display the contents of `proposal`. Based on `cells` column
    /// type, you may want to display different information.
    ///
    /// This allows for columns of information among completion proposals
    /// resulting in better alignment of similar content (icons, return types,
    /// method names, and parameter lists).
    ///
    /// Feature: `v5_0`
    ///
    /// ## `context`
    /// a `CompletionContext`
    /// ## `proposal`
    /// a `CompletionProposal`
    /// ## `cell`
    /// a `CompletionCell`
    #[doc(alias = "gtk_source_completion_provider_display")]
    fn display<P: IsA<CompletionProposal>>(
        &self,
        context: &CompletionContext,
        proposal: &P,
        cell: &CompletionCell,
    );

    /// This function should return the priority of `self` in `context`.
    ///
    /// The priority is used to sort groups of completion proposals by
    /// provider so that higher priority providers results are shown
    /// above lower priority providers.
    ///
    /// Lower value indicates higher priority.
    ///
    /// Feature: `v5_0`
    ///
    /// ## `context`
    /// a `CompletionContext`
    #[doc(alias = "gtk_source_completion_provider_get_priority")]
    fn get_priority(&self, context: &CompletionContext) -> i32;

    /// Gets the title of the completion provider, if any.
    ///
    /// Currently, titles are not displayed in the completion results, but may be
    /// at some point in the future when non-`None`.
    ///
    /// Feature: `v5_0`
    ///
    ///
    /// # Returns
    ///
    /// a title for the provider or `None`
    #[doc(alias = "gtk_source_completion_provider_get_title")]
    fn get_title(&self) -> Option<glib::GString>;

    /// This function is used to determine of a character inserted into the text
    /// editor should cause a new completion request to be triggered.
    ///
    /// An example would be period '.' which might indicate that the user wants
    /// to complete method or field names of an object.
    ///
    /// Feature: `v5_0`
    ///
    /// ## `iter`
    /// a `gtk::TextIter`
    /// ## `ch`
    /// a `gunichar` of the character inserted
    #[doc(alias = "gtk_source_completion_provider_is_trigger")]
    fn is_trigger(&self, iter: &gtk::TextIter, ch: char) -> bool;

    /// This function is used to determine if a key typed by the user should
    /// activate `proposal` (resulting in committing the text to the editor).
    ///
    /// This is useful when using languages where convention may lead to less
    /// typing by the user. One example may be the use of "." or "-" to expand
    /// a field access in the C programming language.
    ///
    /// Feature: `v5_0`
    ///
    /// ## `context`
    /// a `CompletionContext`
    /// ## `proposal`
    /// a `CompletionProposal`
    /// ## `keyval`
    /// a keyval such as `GDK_KEY_period`
    /// ## `state`
    /// a `gdk::ModifierType` or 0
    #[doc(alias = "gtk_source_completion_provider_key_activates")]
    fn key_activates<P: IsA<CompletionProposal>>(
        &self,
        context: &CompletionContext,
        proposal: &P,
        keyval: u32,
        state: gdk::ModifierType,
    ) -> bool;

    /// Providers should return a list of alternates to `proposal` or `None` if
    /// there are no alternates available. This can be used by the completion
    /// view to allow the user to move laterally through similar proposals, such
    /// as overrides of methods by the same name.
    ///
    /// Feature: `v5_0`
    ///
    /// ## `context`
    /// a `CompletionContext`
    /// ## `proposal`
    /// a `CompletionProposal`
    ///
    /// # Returns
    ///
    ///
    ///  a `glib::PtrArray` of `CompletionProposal` or `None`.
    #[doc(alias = "gtk_source_completion_provider_list_alternates")]
    fn list_alternates<P: IsA<CompletionProposal>>(
        &self,
        context: &CompletionContext,
        proposal: &P,
    ) -> Vec<CompletionProposal>;

    /// Asynchronously requests that the provider populates the completion
    /// results for `context`.
    ///
    /// For providers that would like to populate a `gio::ListModel` while those
    /// results are displayed to the user,
    /// `CompletionContext::set_proposals_for_provider` may be used
    /// to reduce latency until the user sees results.
    ///
    /// Feature: `v5_0`
    ///
    /// ## `context`
    /// a `CompletionContext`
    /// ## `cancellable`
    /// a `gio::Cancellable` or `None`
    /// ## `callback`
    /// a callback to execute upon completion
    /// ## `user_data`
    /// closure data for `callback`
    #[doc(alias = "gtk_source_completion_provider_populate_async")]
    fn populate_async<
        P: IsA<gio::Cancellable>,
        Q: FnOnce(Result<gio::ListModel, glib::Error>) + Send + 'static,
    >(
        &self,
        context: &CompletionContext,
        cancellable: Option<&P>,
        callback: Q,
    );

    fn populate_async_future(
        &self,
        context: &CompletionContext,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<gio::ListModel, glib::Error>> + 'static>>;

    /// This function can be used to filter results previously provided to
    /// the `CompletionContext` by the `CompletionProvider`.
    ///
    /// This can happen as the user types additionl text onto the word so
    /// that previously matched items may be removed from the list instead of
    /// generating new `gio::ListModel` of results.
    ///
    /// Feature: `v5_0`
    ///
    /// ## `context`
    /// a `CompletionContext`
    /// ## `model`
    /// a `gio::ListModel`
    #[doc(alias = "gtk_source_completion_provider_refilter")]
    fn refilter<P: IsA<gio::ListModel>>(&self, context: &CompletionContext, model: &P);
}

impl<O: IsA<CompletionProvider>> CompletionProviderExt for O {
    fn activate<P: IsA<CompletionProposal>>(&self, context: &CompletionContext, proposal: &P) {
        unsafe {
            ffi::gtk_source_completion_provider_activate(
                self.as_ref().to_glib_none().0,
                context.to_glib_none().0,
                proposal.as_ref().to_glib_none().0,
            );
        }
    }

    fn display<P: IsA<CompletionProposal>>(
        &self,
        context: &CompletionContext,
        proposal: &P,
        cell: &CompletionCell,
    ) {
        unsafe {
            ffi::gtk_source_completion_provider_display(
                self.as_ref().to_glib_none().0,
                context.to_glib_none().0,
                proposal.as_ref().to_glib_none().0,
                cell.to_glib_none().0,
            );
        }
    }

    fn get_priority(&self, context: &CompletionContext) -> i32 {
        unsafe {
            ffi::gtk_source_completion_provider_get_priority(
                self.as_ref().to_glib_none().0,
                context.to_glib_none().0,
            )
        }
    }

    fn get_title(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_full(ffi::gtk_source_completion_provider_get_title(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn is_trigger(&self, iter: &gtk::TextIter, ch: char) -> bool {
        unsafe {
            from_glib(ffi::gtk_source_completion_provider_is_trigger(
                self.as_ref().to_glib_none().0,
                iter.to_glib_none().0,
                ch.to_glib(),
            ))
        }
    }

    fn key_activates<P: IsA<CompletionProposal>>(
        &self,
        context: &CompletionContext,
        proposal: &P,
        keyval: u32,
        state: gdk::ModifierType,
    ) -> bool {
        unsafe {
            from_glib(ffi::gtk_source_completion_provider_key_activates(
                self.as_ref().to_glib_none().0,
                context.to_glib_none().0,
                proposal.as_ref().to_glib_none().0,
                keyval,
                state.to_glib(),
            ))
        }
    }

    fn list_alternates<P: IsA<CompletionProposal>>(
        &self,
        context: &CompletionContext,
        proposal: &P,
    ) -> Vec<CompletionProposal> {
        unsafe {
            FromGlibPtrContainer::from_glib_full(
                ffi::gtk_source_completion_provider_list_alternates(
                    self.as_ref().to_glib_none().0,
                    context.to_glib_none().0,
                    proposal.as_ref().to_glib_none().0,
                ),
            )
        }
    }

    fn populate_async<
        P: IsA<gio::Cancellable>,
        Q: FnOnce(Result<gio::ListModel, glib::Error>) + Send + 'static,
    >(
        &self,
        context: &CompletionContext,
        cancellable: Option<&P>,
        callback: Q,
    ) {
        let user_data: Box_<Q> = Box_::new(callback);
        unsafe extern "C" fn populate_async_trampoline<
            Q: FnOnce(Result<gio::ListModel, glib::Error>) + Send + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut gio::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            let mut error = ptr::null_mut();
            let ret = ffi::gtk_source_completion_provider_populate_finish(
                _source_object as *mut _,
                res,
                &mut error,
            );
            let result = if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            };
            let callback: Box_<Q> = Box_::from_raw(user_data as *mut _);
            callback(result);
        }
        let callback = populate_async_trampoline::<Q>;
        unsafe {
            ffi::gtk_source_completion_provider_populate_async(
                self.as_ref().to_glib_none().0,
                context.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    fn populate_async_future(
        &self,
        context: &CompletionContext,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<gio::ListModel, glib::Error>> + 'static>>
    {
        let context = context.clone();
        Box_::pin(gio::GioFuture::new(self, move |obj, send| {
            let cancellable = gio::Cancellable::new();
            obj.populate_async(&context, Some(&cancellable), move |res| {
                send.resolve(res);
            });

            cancellable
        }))
    }

    fn refilter<P: IsA<gio::ListModel>>(&self, context: &CompletionContext, model: &P) {
        unsafe {
            ffi::gtk_source_completion_provider_refilter(
                self.as_ref().to_glib_none().0,
                context.to_glib_none().0,
                model.as_ref().to_glib_none().0,
            );
        }
    }
}

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