// Take a look at the license at the top of the repository in the LICENSE file.

use crate::prelude::*;
use crate::{DeleteType, MovementStep, Text, Widget};
use glib::object::ObjectType;
use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*;
use glib::GString;
use std::mem::transmute;

impl Text {
    /// Emitted when the user hits the Enter key.
    ///
    /// The default bindings for this signal are all forms
    /// of the `<kbd>`Enter`</kbd>` key.
    pub fn connect_activate<F: Fn(&Text) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn activate_trampoline<F: Fn(&Text) + 'static>(
            this: *mut ffi::GtkText,
            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"activate\0".as_ptr() as *const _,
                Some(transmute(activate_trampoline::<F> as usize)),
                Box::into_raw(f),
            )
        }
    }

    /// Emitted when the user asks for it.
    ///
    /// This is a [keybinding signal](class.SignalAction.html).
    ///
    /// The default bindings for this signal are
    /// `<kbd>`Backspace`</kbd>` and `<kbd>`Shift`</kbd>`-`<kbd>`Backspace`</kbd>`.
    pub fn connect_backspace<F: Fn(&Text) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn backspace_trampoline<F: Fn(&Text) + 'static>(
            this: *mut ffi::GtkText,
            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"backspace\0".as_ptr() as *const _,
                Some(transmute(backspace_trampoline::<F> as usize)),
                Box::into_raw(f),
            )
        }
    }

    /// Emitted to copy the selection to the clipboard.
    ///
    /// This is a [keybinding signal](class.SignalAction.html).
    ///
    /// The default bindings for this signal are
    /// `<kbd>`Ctrl`</kbd>`-`<kbd>`c`</kbd>` and
    /// `<kbd>`Ctrl`</kbd>`-`<kbd>`Insert`</kbd>`.
    pub fn connect_copy_clipboard<F: Fn(&Text) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn copy_clipboard_trampoline<F: Fn(&Text) + 'static>(
            this: *mut ffi::GtkText,
            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"copy-clipboard\0".as_ptr() as *const _,
                Some(transmute(copy_clipboard_trampoline::<F> as usize)),
                Box::into_raw(f),
            )
        }
    }

    /// Emitted to cut the selection to the clipboard.
    ///
    /// This is a [keybinding signal](class.SignalAction.html).
    ///
    /// The default bindings for this signal are
    /// `<kbd>`Ctrl`</kbd>`-`<kbd>`x`</kbd>` and
    /// `<kbd>`Shift`</kbd>`-`<kbd>`Delete`</kbd>`.
    pub fn connect_cut_clipboard<F: Fn(&Text) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn cut_clipboard_trampoline<F: Fn(&Text) + 'static>(
            this: *mut ffi::GtkText,
            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"cut-clipboard\0".as_ptr() as *const _,
                Some(transmute(cut_clipboard_trampoline::<F> as usize)),
                Box::into_raw(f),
            )
        }
    }

    /// Emitted when the user initiates a text deletion.
    ///
    /// This is a [keybinding signal](class.SignalAction.html).
    ///
    /// If the `type_` is [`DeleteType::Chars`][crate::DeleteType::Chars], GTK deletes the selection
    /// if there is one, otherwise it deletes the requested number
    /// of characters.
    ///
    /// The default bindings for this signal are `<kbd>`Delete`</kbd>`
    /// for deleting a character and `<kbd>`Ctrl`</kbd>`-`<kbd>`Delete`</kbd>`
    /// for deleting a word.
    /// ## `type_`
    /// the granularity of the deletion, as a [`DeleteType`][crate::DeleteType]
    /// ## `count`
    /// the number of `type_` units to delete
    pub fn connect_delete_from_cursor<F: Fn(&Text, DeleteType, i32) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn delete_from_cursor_trampoline<
            F: Fn(&Text, DeleteType, i32) + 'static,
        >(
            this: *mut ffi::GtkText,
            type_: ffi::GtkDeleteType,
            count: libc::c_int,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this), from_glib(type_), count)
        }
        unsafe {
            let f: Box<F> = Box::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"delete-from-cursor\0".as_ptr() as *const _,
                Some(transmute(delete_from_cursor_trampoline::<F> as usize)),
                Box::into_raw(f),
            )
        }
    }

    /// Emitted when the user initiates the insertion of a
    /// fixed string at the cursor.
    ///
    /// This is a [keybinding signal](class.SignalAction.html).
    ///
    /// This signal has no default bindings.
    /// ## `string`
    /// the string to insert
    pub fn connect_insert_at_cursor<F: Fn(&Text, &str) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn insert_at_cursor_trampoline<F: Fn(&Text, &str) + 'static>(
            this: *mut ffi::GtkText,
            string: *mut libc::c_char,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this), &GString::from_glib_borrow(string))
        }
        unsafe {
            let f: Box<F> = Box::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"insert-at-cursor\0".as_ptr() as *const _,
                Some(transmute(insert_at_cursor_trampoline::<F> as usize)),
                Box::into_raw(f),
            )
        }
    }

    /// Emitted to present the Emoji chooser for the widget.
    ///
    /// This is a [keybinding signal](class.SignalAction.html).
    ///
    /// The default bindings for this signal are
    /// `<kbd>`Ctrl`</kbd>`-`<kbd>`.`</kbd>` and
    /// `<kbd>`Ctrl`</kbd>`-`<kbd>`;`</kbd>`
    pub fn connect_insert_emoji<F: Fn(&Text) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn insert_emoji_trampoline<F: Fn(&Text) + 'static>(
            this: *mut ffi::GtkText,
            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"insert-emoji\0".as_ptr() as *const _,
                Some(transmute(insert_emoji_trampoline::<F> as usize)),
                Box::into_raw(f),
            )
        }
    }

    /// Emitted when the user initiates a cursor movement.
    ///
    /// If the cursor is not visible in `self_`, this signal causes
    /// the viewport to be moved instead.
    ///
    /// This is a [keybinding signal](class.SignalAction.html).
    ///
    /// Applications should not connect to it, but may emit it with
    /// `g_signal_emit_by_name()` if they need to control the cursor
    /// programmatically.
    ///
    /// The default bindings for this signal come in two variants,
    /// the variant with the `<kbd>`Shift`</kbd>` modifier extends the
    /// selection, the variant without it does not.
    /// There are too many key combinations to list them all here.
    ///
    /// - `<kbd>`←`</kbd>`, `<kbd>`→`</kbd>`, `<kbd>`↑`</kbd>`, `<kbd>`↓`</kbd>`
    ///  move by individual characters/lines
    /// - `<kbd>`Ctrl`</kbd>`-`<kbd>`→`</kbd>`, etc. move by words/paragraphs
    /// - `<kbd>`Home`</kbd>`, `<kbd>`End`</kbd>` move to the ends of the buffer
    /// ## `step`
    /// the granularity of the move, as a [`MovementStep`][crate::MovementStep]
    /// ## `count`
    /// the number of `step` units to move
    /// ## `extend`
    /// [`true`] if the move should extend the selection
    pub fn connect_move_cursor<F: Fn(&Text, MovementStep, i32, bool) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn move_cursor_trampoline<
            F: Fn(&Text, MovementStep, i32, bool) + 'static,
        >(
            this: *mut ffi::GtkText,
            step: ffi::GtkMovementStep,
            count: libc::c_int,
            extend: glib::ffi::gboolean,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                &from_glib_borrow(this),
                from_glib(step),
                count,
                from_glib(extend),
            )
        }
        unsafe {
            let f: Box<F> = Box::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"move-cursor\0".as_ptr() as *const _,
                Some(transmute(move_cursor_trampoline::<F> as usize)),
                Box::into_raw(f),
            )
        }
    }

    /// Emitted to paste the contents of the clipboard.
    ///
    /// This is a [keybinding signal](class.SignalAction.html).
    ///
    /// The default bindings for this signal are
    /// `<kbd>`Ctrl`</kbd>`-`<kbd>`v`</kbd>` and `<kbd>`Shift`</kbd>`-`<kbd>`Insert`</kbd>`.
    pub fn connect_paste_clipboard<F: Fn(&Text) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn paste_clipboard_trampoline<F: Fn(&Text) + 'static>(
            this: *mut ffi::GtkText,
            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"paste-clipboard\0".as_ptr() as *const _,
                Some(transmute(paste_clipboard_trampoline::<F> as usize)),
                Box::into_raw(f),
            )
        }
    }

    pub fn connect_populate_popup<F: Fn(&Text, &Widget) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn populate_popup_trampoline<F: Fn(&Text, &Widget) + 'static>(
            this: *mut ffi::GtkText,
            widget: *mut ffi::GtkWidget,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this), &from_glib_borrow(widget))
        }
        unsafe {
            let f: Box<F> = Box::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"populate-popup\0".as_ptr() as *const _,
                Some(transmute(populate_popup_trampoline::<F> as usize)),
                Box::into_raw(f),
            )
        }
    }

    /// Emitted when the preedit text changes.
    ///
    /// If an input method is used, the typed text will not immediately
    /// be committed to the buffer. So if you are interested in the text,
    /// connect to this signal.
    /// ## `preedit`
    /// the current preedit string
    pub fn connect_preedit_changed<F: Fn(&Text, &str) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn preedit_changed_trampoline<F: Fn(&Text, &str) + 'static>(
            this: *mut ffi::GtkText,
            preedit: *mut libc::c_char,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this), &GString::from_glib_borrow(preedit))
        }
        unsafe {
            let f: Box<F> = Box::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"preedit-changed\0".as_ptr() as *const _,
                Some(transmute(preedit_changed_trampoline::<F> as usize)),
                Box::into_raw(f),
            )
        }
    }

    /// Emitted to toggle the overwrite mode of the [`Text`][crate::Text].
    ///
    /// This is a [keybinding signal](class.SignalAction.html).
    ///
    /// The default bindings for this signal is `<kbd>`Insert`</kbd>`.
    pub fn connect_toggle_overwrite<F: Fn(&Text) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn toggle_overwrite_trampoline<F: Fn(&Text) + 'static>(
            this: *mut ffi::GtkText,
            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"toggle-overwrite\0".as_ptr() as *const _,
                Some(transmute(toggle_overwrite_trampoline::<F> as usize)),
                Box::into_raw(f),
            )
        }
    }

    pub fn emit_activate(&self) {
        let stash: Stash<*mut ffi::GtkText, _> = self.to_glib_none();
        let _ = unsafe {
            glib::Object::from_glib_borrow(stash.0 as *mut glib::gobject_ffi::GObject)
                .emit_by_name("activate", &[])
                .unwrap()
        };
    }

    pub fn emit_backspace(&self) {
        let stash: Stash<*mut ffi::GtkText, _> = self.to_glib_none();
        let _ = unsafe {
            glib::Object::from_glib_borrow(stash.0 as *mut glib::gobject_ffi::GObject)
                .emit_by_name("backspace", &[])
                .unwrap()
        };
    }

    pub fn emit_copy_clipboard(&self) {
        let stash: Stash<*mut ffi::GtkText, _> = self.to_glib_none();
        let _ = unsafe {
            glib::Object::from_glib_borrow(stash.0 as *mut glib::gobject_ffi::GObject)
                .emit_by_name("copy-clipboard", &[])
                .unwrap()
        };
    }

    pub fn emit_cut_clipboard(&self) {
        let stash: Stash<*mut ffi::GtkText, _> = self.to_glib_none();
        let _ = unsafe {
            glib::Object::from_glib_borrow(stash.0 as *mut glib::gobject_ffi::GObject)
                .emit_by_name("cut-clipboard", &[])
                .unwrap()
        };
    }

    pub fn emit_delete_from_cursor(&self, type_: DeleteType, count: i32) {
        let stash: Stash<*mut ffi::GtkText, _> = self.to_glib_none();
        let _ = unsafe {
            glib::Object::from_glib_borrow(stash.0 as *mut glib::gobject_ffi::GObject)
                .emit_by_name("delete-from-cursor", &[&type_, &count])
                .unwrap()
        };
    }

    pub fn emit_insert_at_cursor(&self, string: &str) {
        let stash: Stash<*mut ffi::GtkText, _> = self.to_glib_none();
        let _ = unsafe {
            glib::Object::from_glib_borrow(stash.0 as *mut glib::gobject_ffi::GObject)
                .emit_by_name("insert-at-cursor", &[&string])
                .unwrap()
        };
    }

    pub fn emit_insert_emoji(&self) {
        let stash: Stash<*mut ffi::GtkText, _> = self.to_glib_none();
        let _ = unsafe {
            glib::Object::from_glib_borrow(stash.0 as *mut glib::gobject_ffi::GObject)
                .emit_by_name("insert-emoji", &[])
                .unwrap()
        };
    }

    pub fn emit_move_cursor(&self, step: MovementStep, count: i32, extend: bool) {
        let stash: Stash<*mut ffi::GtkText, _> = self.to_glib_none();
        let _ = unsafe {
            glib::Object::from_glib_borrow(stash.0 as *mut glib::gobject_ffi::GObject)
                .emit_by_name("move-cursor", &[&step, &count, &extend])
                .unwrap()
        };
    }

    pub fn emit_paste_clipboard(&self) {
        let stash: Stash<*mut ffi::GtkText, _> = self.to_glib_none();
        let _ = unsafe {
            glib::Object::from_glib_borrow(stash.0 as *mut glib::gobject_ffi::GObject)
                .emit_by_name("paste-clipboard", &[])
                .unwrap()
        };
    }

    pub fn emit_preedit_changed(&self, preedit: &str) {
        let stash: Stash<*mut ffi::GtkText, _> = self.to_glib_none();
        let _ = unsafe {
            glib::Object::from_glib_borrow(stash.0 as *mut glib::gobject_ffi::GObject)
                .emit_by_name("preedit-changed", &[&preedit])
                .unwrap()
        };
    }

    pub fn emit_toggle_overwrite(&self) {
        let stash: Stash<*mut ffi::GtkText, _> = self.to_glib_none();
        let _ = unsafe {
            glib::Object::from_glib_borrow(stash.0 as *mut glib::gobject_ffi::GObject)
                .emit_by_name("toggle-overwrite", &[])
                .unwrap()
        };
    }
}