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

use crate::{ffi, View};
use glib::{
    prelude::*,
    signal::{connect_raw, SignalHandlerId},
    translate::*,
};
use std::boxed::Box as Box_;

glib::wrapper! {
    /// Vim emulation.
    ///
    /// The [`VimIMContext`][crate::VimIMContext] is a [`gtk::IMContext`][crate::gtk::IMContext] implementation that can
    /// be used to provide Vim-like editing controls within a [`View`][crate::View].
    ///
    /// The `GtkSourceViMIMContext` will process incoming `Gdk::KeyEvent` as the
    /// user types. It should be used in conjunction with a `Gtk::EventControllerKey`.
    ///
    /// Various features supported by [`VimIMContext`][crate::VimIMContext] include:
    ///
    ///  - Normal, Insert, Replace, Visual, and Visual Line modes
    ///  - Support for an integrated command bar and current command preview
    ///  - Search and replace
    ///  - Motions and Text Objects
    ///  - History replay
    ///  - Jumplists within the current file
    ///  - Registers including the system and primary clipboards
    ///  - Creation and motion to marks
    ///  - Some commonly used Vim commands
    ///
    /// It is recommended that applications display the contents of
    /// [`command-bar-text`][struct@crate::VimIMContext#command-bar-text] and
    /// [`command-text`][struct@crate::VimIMContext#command-text] to the user as they represent the
    /// command-bar and current command preview found in Vim.
    ///
    /// [`VimIMContext`][crate::VimIMContext] attempts to work with additional [`gtk::IMContext`][crate::gtk::IMContext]
    /// implementations such as IBus by querying the [`gtk::TextView`][crate::gtk::TextView] before processing
    /// the command in states which support it (notably Insert and Replace modes).
    ///
    /// **⚠️ The following code is in c ⚠️**
    ///
    /// ```c
    /// GtkEventController *key;
    /// GtkIMContext *im_context;
    /// GtkWidget *view;
    ///
    /// view = gtk_source_view_new ();
    /// im_context = gtk_source_vim_im_context_new ();
    /// key = gtk_event_controller_key_new ();
    ///
    /// gtk_event_controller_key_set_im_context (GTK_EVENT_CONTROLLER_KEY (key), im_context);
    /// gtk_event_controller_set_propagation_phase (key, GTK_PHASE_CAPTURE);
    /// gtk_widget_add_controller (view, key);
    /// gtk_im_context_set_client_widget (im_context, view);
    ///
    /// g_object_bind_property (im_context, "command-bar-text", command_bar_label, "label", 0);
    /// g_object_bind_property (im_context, "command-text", command_label, "label", 0);
    /// ```
    ///
    /// ## Properties
    ///
    ///
    /// #### `command-bar-text`
    ///  Readable
    ///
    ///
    /// #### `command-text`
    ///  Readable
    /// <details><summary><h4>IMContext</h4></summary>
    ///
    ///
    /// #### `input-hints`
    ///  Additional hints that allow input methods to fine-tune
    /// their behaviour.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `input-purpose`
    ///  The purpose of the text field that the `GtkIMContext is connected to.
    ///
    /// This property can be used by on-screen keyboards and other input
    /// methods to adjust their behaviour.
    ///
    /// Readable | Writeable
    /// </details>
    ///
    /// ## Signals
    ///
    ///
    /// #### `edit`
    ///  Requests the application open the file found at @path.
    ///
    /// If @path is [`None`], then the current file should be reloaded from storage.
    ///
    /// This may be executed in relation to the user running the
    /// `:edit` or `:e` commands.
    ///
    ///
    ///
    ///
    /// #### `execute-command`
    ///  The signal is emitted when a command should be
    /// executed. This might be something like `:wq` or `:e <path>`.
    ///
    /// If the application chooses to implement this, it should return
    /// [`true`] from this signal to indicate the command has been handled.
    ///
    ///
    ///
    ///
    /// #### `format-text`
    ///  Requests that the application format the text between
    /// @begin and @end.
    ///
    ///
    ///
    ///
    /// #### `write`
    ///  Requests the application save the file.
    ///
    /// If a filename was provided, it will be available to the signal handler as @path.
    /// This may be executed in relation to the user running the `:write` or `:w` commands.
    ///
    ///
    /// <details><summary><h4>IMContext</h4></summary>
    ///
    ///
    /// #### `commit`
    ///  The ::commit signal is emitted when a complete input sequence
    /// has been entered by the user.
    ///
    /// If the commit comes after a preediting sequence, the
    /// ::commit signal is emitted after ::preedit-end.
    ///
    /// This can be a single character immediately after a key press or
    /// the final result of preediting.
    ///
    ///
    ///
    ///
    /// #### `delete-surrounding`
    ///  The ::delete-surrounding signal is emitted when the input method
    /// needs to delete all or part of the context surrounding the cursor.
    ///
    ///
    ///
    ///
    /// #### `preedit-changed`
    ///  The ::preedit-changed signal is emitted whenever the preedit sequence
    /// currently being entered has changed.
    ///
    /// It is also emitted at the end of a preedit sequence, in which case
    /// [`IMContextExtManual::preedit_string()`][crate::gtk::prelude::IMContextExtManual::preedit_string()] returns the empty string.
    ///
    ///
    ///
    ///
    /// #### `preedit-end`
    ///  The ::preedit-end signal is emitted when a preediting sequence
    /// has been completed or canceled.
    ///
    ///
    ///
    ///
    /// #### `preedit-start`
    ///  The ::preedit-start signal is emitted when a new preediting sequence
    /// starts.
    ///
    ///
    ///
    ///
    /// #### `retrieve-surrounding`
    ///  The ::retrieve-surrounding signal is emitted when the input method
    /// requires the context surrounding the cursor.
    ///
    /// The callback should set the input method surrounding context by
    /// calling the `Gtk::IMContext::set_surrounding()` method.
    ///
    ///
    /// </details>
    ///
    /// # Implements
    ///
    /// [`trait@gtk::prelude::IMContextExt`], [`trait@glib::ObjectExt`]
    #[doc(alias = "GtkSourceVimIMContext")]
    pub struct VimIMContext(Object<ffi::GtkSourceVimIMContext, ffi::GtkSourceVimIMContextClass>) @extends gtk::IMContext;

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

impl VimIMContext {
    #[doc(alias = "gtk_source_vim_im_context_new")]
    pub fn new() -> VimIMContext {
        assert_initialized_main_thread!();
        unsafe {
            gtk::IMContext::from_glib_full(ffi::gtk_source_vim_im_context_new()).unsafe_cast()
        }
    }

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

    /// Executes @command as if it was typed into the command bar by the
    /// user except that this does not emit the
    /// [`execute-command`][struct@crate::VimIMContext#execute-command] signal.
    /// ## `command`
    /// the command text
    #[doc(alias = "gtk_source_vim_im_context_execute_command")]
    pub fn execute_command(&self, command: &str) {
        unsafe {
            ffi::gtk_source_vim_im_context_execute_command(
                self.to_glib_none().0,
                command.to_glib_none().0,
            );
        }
    }

    /// Gets the current command-bar text as it is entered by the user.
    ///
    /// # Returns
    ///
    /// A string containing the command-bar text
    #[doc(alias = "gtk_source_vim_im_context_get_command_bar_text")]
    #[doc(alias = "get_command_bar_text")]
    #[doc(alias = "command-bar-text")]
    pub fn command_bar_text(&self) -> glib::GString {
        unsafe {
            from_glib_none(ffi::gtk_source_vim_im_context_get_command_bar_text(
                self.to_glib_none().0,
            ))
        }
    }

    /// Gets the current command text as it is entered by the user.
    ///
    /// # Returns
    ///
    /// A string containing the command text
    #[doc(alias = "gtk_source_vim_im_context_get_command_text")]
    #[doc(alias = "get_command_text")]
    #[doc(alias = "command-text")]
    pub fn command_text(&self) -> glib::GString {
        unsafe {
            from_glib_none(ffi::gtk_source_vim_im_context_get_command_text(
                self.to_glib_none().0,
            ))
        }
    }

    #[cfg(not(feature = "v5_4"))]
    #[cfg_attr(docsrs, doc(cfg(not(feature = "v5_4"))))]
    #[doc(alias = "command-bar-text")]
    pub fn command_bar_text(&self) -> Option<glib::GString> {
        ObjectExt::property(self, "command-bar-text")
    }

    #[cfg(not(feature = "v5_4"))]
    #[cfg_attr(docsrs, doc(cfg(not(feature = "v5_4"))))]
    #[doc(alias = "command-text")]
    pub fn command_text(&self) -> Option<glib::GString> {
        ObjectExt::property(self, "command-text")
    }

    /// Requests the application open the file found at @path.
    ///
    /// If @path is [`None`], then the current file should be reloaded from storage.
    ///
    /// This may be executed in relation to the user running the
    /// `:edit` or `:e` commands.
    /// ## `view`
    /// the #GtkSourceView
    /// ## `path`
    /// the path if provided, otherwise [`None`]
    #[cfg(feature = "v5_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v5_4")))]
    #[doc(alias = "edit")]
    pub fn connect_edit<F: Fn(&Self, &View, Option<&str>) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn edit_trampoline<
            F: Fn(&VimIMContext, &View, Option<&str>) + 'static,
        >(
            this: *mut ffi::GtkSourceVimIMContext,
            view: *mut ffi::GtkSourceView,
            path: *mut libc::c_char,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                &from_glib_borrow(this),
                &from_glib_borrow(view),
                Option::<glib::GString>::from_glib_borrow(path)
                    .as_ref()
                    .as_ref()
                    .map(|s| s.as_str()),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"edit\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    edit_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The signal is emitted when a command should be
    /// executed. This might be something like `:wq` or `:e <path>`.
    ///
    /// If the application chooses to implement this, it should return
    /// [`true`] from this signal to indicate the command has been handled.
    /// ## `command`
    /// the command to execute
    ///
    /// # Returns
    ///
    /// [`true`] if handled; otherwise [`false`].
    #[cfg(feature = "v5_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v5_4")))]
    #[doc(alias = "execute-command")]
    pub fn connect_execute_command<F: Fn(&Self, &str) -> bool + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn execute_command_trampoline<
            F: Fn(&VimIMContext, &str) -> bool + 'static,
        >(
            this: *mut ffi::GtkSourceVimIMContext,
            command: *mut libc::c_char,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            let f: &F = &*(f as *const F);
            f(
                &from_glib_borrow(this),
                &glib::GString::from_glib_borrow(command),
            )
            .into_glib()
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"execute-command\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    execute_command_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Requests that the application format the text between
    /// @begin and @end.
    /// ## `begin`
    /// the start location
    /// ## `end`
    /// the end location
    #[cfg(feature = "v5_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v5_4")))]
    #[doc(alias = "format-text")]
    pub fn connect_format_text<F: Fn(&Self, &gtk::TextIter, &gtk::TextIter) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn format_text_trampoline<
            F: Fn(&VimIMContext, &gtk::TextIter, &gtk::TextIter) + 'static,
        >(
            this: *mut ffi::GtkSourceVimIMContext,
            begin: *mut gtk::ffi::GtkTextIter,
            end: *mut gtk::ffi::GtkTextIter,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                &from_glib_borrow(this),
                &from_glib_borrow(begin),
                &from_glib_borrow(end),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"format-text\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    format_text_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Requests the application save the file.
    ///
    /// If a filename was provided, it will be available to the signal handler as @path.
    /// This may be executed in relation to the user running the `:write` or `:w` commands.
    /// ## `view`
    /// the #GtkSourceView
    /// ## `path`
    /// the path if provided, otherwise [`None`]
    #[cfg(feature = "v5_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v5_4")))]
    #[doc(alias = "write")]
    pub fn connect_write<F: Fn(&Self, &View, Option<&str>) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn write_trampoline<
            F: Fn(&VimIMContext, &View, Option<&str>) + 'static,
        >(
            this: *mut ffi::GtkSourceVimIMContext,
            view: *mut ffi::GtkSourceView,
            path: *mut libc::c_char,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                &from_glib_borrow(this),
                &from_glib_borrow(view),
                Option::<glib::GString>::from_glib_borrow(path)
                    .as_ref()
                    .as_ref()
                    .map(|s| s.as_str()),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"write\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    write_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "command-bar-text")]
    pub fn connect_command_bar_text_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_command_bar_text_trampoline<F: Fn(&VimIMContext) + 'static>(
            this: *mut ffi::GtkSourceVimIMContext,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::command-bar-text\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_command_bar_text_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "command-text")]
    pub fn connect_command_text_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_command_text_trampoline<F: Fn(&VimIMContext) + 'static>(
            this: *mut ffi::GtkSourceVimIMContext,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::command-text\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_command_text_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

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

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

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

    /// Additional hints that allow input methods to fine-tune
    /// their behaviour.
    pub fn input_hints(self, input_hints: gtk::InputHints) -> Self {
        Self {
            builder: self.builder.property("input-hints", input_hints),
        }
    }

    /// The purpose of the text field that the `GtkIMContext is connected to.
    ///
    /// This property can be used by on-screen keyboards and other input
    /// methods to adjust their behaviour.
    pub fn input_purpose(self, input_purpose: gtk::InputPurpose) -> Self {
        Self {
            builder: self.builder.property("input-purpose", input_purpose),
        }
    }

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