// 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::Accessible;
use crate::Buildable;
use crate::ConstraintTarget;
use crate::Widget;
use glib::object::Cast;
use glib::object::IsA;
use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*;
use glib::StaticType;
use glib::ToValue;
use std::boxed::Box as Box_;
use std::fmt;
use std::mem;
use std::mem::transmute;

glib::wrapper! {
    /// [`Editable`][crate::Editable] is an interface for text editing widgets.
    ///
    /// Typical examples of editable widgets are [`Entry`][crate::Entry] and
    /// [`SpinButton`][crate::SpinButton]. It contains functions for generically manipulating
    /// an editable widget, a large number of action signals used for key bindings,
    /// and several signals that an application can connect to modify the behavior
    /// of a widget.
    ///
    /// As an example of the latter usage, by connecting the following handler to
    /// `signal::Editable::insert-text`, an application can convert all entry
    /// into a widget into uppercase.
    ///
    /// ## Forcing entry to uppercase.
    ///
    /// **⚠️ The following code is in c ⚠️**
    ///
    /// ```c
    /// #include <ctype.h>
    ///
    /// void
    /// insert_text_handler (GtkEditable *editable,
    ///                      const char  *text,
    ///                      int          length,
    ///                      int         *position,
    ///                      gpointer     data)
    /// {
    ///   char *result = g_utf8_strup (text, length);
    ///
    ///   g_signal_handlers_block_by_func (editable,
    ///                                (gpointer) insert_text_handler, data);
    ///   gtk_editable_insert_text (editable, result, length, position);
    ///   g_signal_handlers_unblock_by_func (editable,
    ///                                      (gpointer) insert_text_handler, data);
    ///
    ///   g_signal_stop_emission_by_name (editable, "insert_text");
    ///
    ///   g_free (result);
    /// }
    /// ```
    ///
    /// ## Implementing GtkEditable
    ///
    /// The most likely scenario for implementing [`Editable`][crate::Editable] on your own widget
    /// is that you will embed a [`Text`][crate::Text] inside a complex widget, and want to
    /// delegate the editable functionality to that text widget. [`Editable`][crate::Editable]
    /// provides some utility functions to make this easy.
    ///
    /// In your class_init function, call [`install_properties()`][Self::install_properties()],
    /// passing the first available property ID:
    ///
    /// **⚠️ The following code is in c ⚠️**
    ///
    /// ```c
    /// static void
    /// my_class_init (MyClass *class)
    /// {
    ///   ...
    ///   g_object_class_install_properties (object_class, NUM_PROPERTIES, props);
    ///   gtk_editable_install_properties (object_clas, NUM_PROPERTIES);
    ///   ...
    /// }
    /// ```
    ///
    /// In your interface_init function for the [`Editable`][crate::Editable] interface, provide
    /// an implementation for the get_delegate vfunc that returns your text widget:
    ///
    /// **⚠️ The following code is in c ⚠️**
    ///
    /// ```c
    /// GtkEditable *
    /// get_editable_delegate (GtkEditable *editable)
    /// {
    ///   return GTK_EDITABLE (MY_WIDGET (editable)->text_widget);
    /// }
    ///
    /// static void
    /// my_editable_init (GtkEditableInterface *iface)
    /// {
    ///   iface->get_delegate = get_editable_delegate;
    /// }
    /// ```
    ///
    /// You don't need to provide any other vfuncs. The default implementations
    /// work by forwarding to the delegate that the GtkEditableInterface.get_delegate()
    /// vfunc returns.
    ///
    /// In your instance_init function, create your text widget, and then call
    /// [`EditableExt::init_delegate()`][crate::prelude::EditableExt::init_delegate()]:
    ///
    /// **⚠️ The following code is in c ⚠️**
    ///
    /// ```c
    /// static void
    /// my_widget_init (MyWidget *self)
    /// {
    ///   ...
    ///   self->text_widget = gtk_text_new ();
    ///   gtk_editable_init_delegate (GTK_EDITABLE (self));
    ///   ...
    /// }
    /// ```
    ///
    /// In your dispose function, call [`EditableExt::finish_delegate()`][crate::prelude::EditableExt::finish_delegate()] before
    /// destroying your text widget:
    ///
    /// **⚠️ The following code is in c ⚠️**
    ///
    /// ```c
    /// static void
    /// my_widget_dispose (GObject *object)
    /// {
    ///   ...
    ///   gtk_editable_finish_delegate (GTK_EDITABLE (self));
    ///   g_clear_pointer (&self->text_widget, gtk_widget_unparent);
    ///   ...
    /// }
    /// ```
    ///
    /// Finally, use [`delegate_set_property()`][Self::delegate_set_property()] in your `set_property`
    /// function (and similar for `get_property`), to set the editable properties:
    ///
    /// **⚠️ The following code is in c ⚠️**
    ///
    /// ```c
    ///   ...
    ///   if (gtk_editable_delegate_set_property (object, prop_id, value, pspec))
    ///     return;
    ///
    ///   switch (prop_id)
    ///   ...
    /// ```
    ///
    /// It is important to note that if you create a [`Editable`][crate::Editable] that uses
    /// a delegate, the low level `signal::Editable::insert-text` and
    /// `signal::Editable::delete-text` signals will be propagated from the
    /// "wrapper" editable to the delegate, but they will not be propagated from
    /// the delegate to the "wrapper" editable, as they would cause an infinite
    /// recursion. If you wish to connect to the `signal::Editable::insert-text`
    /// and `signal::Editable::delete-text` signals, you will need to connect
    /// to them on the delegate obtained via [`EditableExt::delegate()`][crate::prelude::EditableExt::delegate()].
    ///
    /// # Implements
    ///
    /// [`EditableExt`][trait@crate::prelude::EditableExt], [`WidgetExt`][trait@crate::prelude::WidgetExt], [`trait@glib::ObjectExt`], [`AccessibleExt`][trait@crate::prelude::AccessibleExt], [`BuildableExt`][trait@crate::prelude::BuildableExt], [`ConstraintTargetExt`][trait@crate::prelude::ConstraintTargetExt], [`EditableExtManual`][trait@crate::prelude::EditableExtManual], [`WidgetExtManual`][trait@crate::prelude::WidgetExtManual], [`AccessibleExtManual`][trait@crate::prelude::AccessibleExtManual]
    #[doc(alias = "GtkEditable")]
    pub struct Editable(Interface<ffi::GtkEditable, ffi::GtkEditableInterface>) @requires Widget, Accessible, Buildable, ConstraintTarget;

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

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

/// Trait containing all [`struct@Editable`] methods.
///
/// # Implementors
///
/// [`EditableLabel`][struct@crate::EditableLabel], [`Editable`][struct@crate::Editable], [`Entry`][struct@crate::Entry], [`PasswordEntry`][struct@crate::PasswordEntry], [`SearchEntry`][struct@crate::SearchEntry], [`SpinButton`][struct@crate::SpinButton], [`Text`][struct@crate::Text]
pub trait EditableExt: 'static {
    /// Deletes the currently selected text of the editable.
    ///
    /// This call doesn’t do anything if there is no selected text.
    #[doc(alias = "gtk_editable_delete_selection")]
    fn delete_selection(&self);

    /// Deletes a sequence of characters.
    ///
    /// The characters that are deleted are those characters at positions
    /// from @start_pos up to, but not including @end_pos. If @end_pos is
    /// negative, then the characters deleted are those from @start_pos to
    /// the end of the text.
    ///
    /// Note that the positions are specified in characters, not bytes.
    /// ## `start_pos`
    /// start position
    /// ## `end_pos`
    /// end position
    #[doc(alias = "gtk_editable_delete_text")]
    fn delete_text(&self, start_pos: i32, end_pos: i32);

    /// Undoes the setup done by [`init_delegate()`][Self::init_delegate()].
    ///
    /// This is a helper function that should be called from dispose,
    /// before removing the delegate object.
    #[doc(alias = "gtk_editable_finish_delegate")]
    fn finish_delegate(&self);

    /// Gets the alignment of the editable.
    ///
    /// # Returns
    ///
    /// the alignment
    #[doc(alias = "gtk_editable_get_alignment")]
    #[doc(alias = "get_alignment")]
    fn alignment(&self) -> f32;

    /// Retrieves a sequence of characters.
    ///
    /// The characters that are retrieved are those characters at positions
    /// from @start_pos up to, but not including @end_pos. If @end_pos is negative,
    /// then the characters retrieved are those characters from @start_pos to
    /// the end of the text.
    ///
    /// Note that positions are specified in characters, not bytes.
    /// ## `start_pos`
    /// start of text
    /// ## `end_pos`
    /// end of text
    ///
    /// # Returns
    ///
    /// a pointer to the contents of the widget as a
    ///   string. This string is allocated by the [`Editable`][crate::Editable] implementation
    ///   and should be freed by the caller.
    #[doc(alias = "gtk_editable_get_chars")]
    #[doc(alias = "get_chars")]
    fn chars(&self, start_pos: i32, end_pos: i32) -> glib::GString;

    /// Gets the [`Editable`][crate::Editable] that @self is delegating its
    /// implementation to.
    ///
    /// Typically, the delegate is a [`Text`][crate::Text] widget.
    ///
    /// # Returns
    ///
    /// the delegate [`Editable`][crate::Editable]
    #[doc(alias = "gtk_editable_get_delegate")]
    #[doc(alias = "get_delegate")]
    #[must_use]
    fn delegate(&self) -> Option<Editable>;

    /// Retrieves whether @self is editable.
    ///
    /// # Returns
    ///
    /// [`true`] if @self is editable.
    #[doc(alias = "gtk_editable_get_editable")]
    #[doc(alias = "get_editable")]
    fn is_editable(&self) -> bool;

    /// Gets if undo/redo actions are enabled for @self
    ///
    /// # Returns
    ///
    /// [`true`] if undo is enabled
    #[doc(alias = "gtk_editable_get_enable_undo")]
    #[doc(alias = "get_enable_undo")]
    fn enables_undo(&self) -> bool;

    /// Retrieves the desired maximum width of @self, in characters.
    ///
    /// # Returns
    ///
    /// the maximum width of the entry, in characters
    #[doc(alias = "gtk_editable_get_max_width_chars")]
    #[doc(alias = "get_max_width_chars")]
    fn max_width_chars(&self) -> i32;

    /// Retrieves the current position of the cursor relative
    /// to the start of the content of the editable.
    ///
    /// Note that this position is in characters, not in bytes.
    ///
    /// # Returns
    ///
    /// the cursor position
    #[doc(alias = "gtk_editable_get_position")]
    #[doc(alias = "get_position")]
    fn position(&self) -> i32;

    /// Retrieves the selection bound of the editable.
    ///
    /// @start_pos will be filled with the start of the selection and
    /// @end_pos with end. If no text was selected both will be identical
    /// and [`false`] will be returned.
    ///
    /// Note that positions are specified in characters, not bytes.
    ///
    /// # Returns
    ///
    /// [`true`] if there is a non-empty selection, [`false`] otherwise
    ///
    /// ## `start_pos`
    /// location to store the starting position
    ///
    /// ## `end_pos`
    /// location to store the end position
    #[doc(alias = "gtk_editable_get_selection_bounds")]
    #[doc(alias = "get_selection_bounds")]
    fn selection_bounds(&self) -> Option<(i32, i32)>;

    /// Retrieves the contents of @self.
    ///
    /// The returned string is owned by GTK and must not be modified or freed.
    ///
    /// # Returns
    ///
    /// a pointer to the contents of the editable
    #[doc(alias = "gtk_editable_get_text")]
    #[doc(alias = "get_text")]
    fn text(&self) -> glib::GString;

    /// Gets the number of characters of space reserved
    /// for the contents of the editable.
    ///
    /// # Returns
    ///
    /// number of chars to request space for, or negative if unset
    #[doc(alias = "gtk_editable_get_width_chars")]
    #[doc(alias = "get_width_chars")]
    fn width_chars(&self) -> i32;

    /// Sets up a delegate for [`Editable`][crate::Editable].
    ///
    /// This is assuming that the get_delegate vfunc in the [`Editable`][crate::Editable]
    /// interface has been set up for the @self's type.
    ///
    /// This is a helper function that should be called in instance init,
    /// after creating the delegate object.
    #[doc(alias = "gtk_editable_init_delegate")]
    fn init_delegate(&self);

    /// Inserts @length bytes of @text into the contents of the
    /// widget, at position @position.
    ///
    /// Note that the position is in characters, not in bytes.
    /// The function updates @position to point after the newly
    /// inserted text.
    /// ## `text`
    /// the text to append
    /// ## `length`
    /// the length of the text in bytes, or -1
    /// ## `position`
    /// location of the position text will be inserted at
    #[doc(alias = "gtk_editable_insert_text")]
    fn insert_text(&self, text: &str, position: &mut i32);

    /// Selects a region of text.
    ///
    /// The characters that are selected are those characters at positions
    /// from @start_pos up to, but not including @end_pos. If @end_pos is
    /// negative, then the characters selected are those characters from
    /// @start_pos to  the end of the text.
    ///
    /// Note that positions are specified in characters, not bytes.
    /// ## `start_pos`
    /// start of region
    /// ## `end_pos`
    /// end of region
    #[doc(alias = "gtk_editable_select_region")]
    fn select_region(&self, start_pos: i32, end_pos: i32);

    /// Sets the alignment for the contents of the editable.
    ///
    /// This controls the horizontal positioning of the contents when
    /// the displayed text is shorter than the width of the editable.
    /// ## `xalign`
    /// The horizontal alignment, from 0 (left) to 1 (right).
    ///   Reversed for RTL layouts
    #[doc(alias = "gtk_editable_set_alignment")]
    fn set_alignment(&self, xalign: f32);

    /// Determines if the user can edit the text in the editable widget.
    /// ## `is_editable`
    /// [`true`] if the user is allowed to edit the text
    ///   in the widget
    #[doc(alias = "gtk_editable_set_editable")]
    fn set_editable(&self, is_editable: bool);

    /// If enabled, changes to @self will be saved for undo/redo
    /// actions.
    ///
    /// This results in an additional copy of text changes and are not
    /// stored in secure memory. As such, undo is forcefully disabled
    /// when `property::Text::visibility` is set to [`false`].
    /// ## `enable_undo`
    /// if undo/redo should be enabled
    #[doc(alias = "gtk_editable_set_enable_undo")]
    fn set_enable_undo(&self, enable_undo: bool);

    /// Sets the desired maximum width in characters of @self.
    /// ## `n_chars`
    /// the new desired maximum width, in characters
    #[doc(alias = "gtk_editable_set_max_width_chars")]
    fn set_max_width_chars(&self, n_chars: i32);

    /// Sets the cursor position in the editable to the given value.
    ///
    /// The cursor is displayed before the character with the given (base 0)
    /// index in the contents of the editable. The value must be less than
    /// or equal to the number of characters in the editable. A value of -1
    /// indicates that the position should be set after the last character
    /// of the editable. Note that @position is in characters, not in bytes.
    /// ## `position`
    /// the position of the cursor
    #[doc(alias = "gtk_editable_set_position")]
    fn set_position(&self, position: i32);

    /// Sets the text in the editable to the given value.
    ///
    /// This is replacing the current contents.
    /// ## `text`
    /// the text to set
    #[doc(alias = "gtk_editable_set_text")]
    fn set_text(&self, text: &str);

    /// Changes the size request of the editable to be about the
    /// right size for @n_chars characters.
    ///
    /// Note that it changes the size request, the size can still
    /// be affected by how you pack the widget into containers.
    /// If @n_chars is -1, the size reverts to the default size.
    /// ## `n_chars`
    /// width in chars
    #[doc(alias = "gtk_editable_set_width_chars")]
    fn set_width_chars(&self, n_chars: i32);

    /// The current position of the insertion cursor in chars.
    #[doc(alias = "cursor-position")]
    fn cursor_position(&self) -> i32;

    /// The position of the opposite end of the selection from the cursor in chars.
    #[doc(alias = "selection-bound")]
    fn selection_bound(&self) -> i32;

    /// The horizontal alignment, from 0 (left) to 1 (right).
    ///
    /// Reversed for RTL layouts.
    fn xalign(&self) -> f32;

    /// The horizontal alignment, from 0 (left) to 1 (right).
    ///
    /// Reversed for RTL layouts.
    fn set_xalign(&self, xalign: f32);

    /// Emitted at the end of a single user-visible operation on the
    /// contents.
    ///
    /// E.g., a paste operation that replaces the contents of the
    /// selection will cause only one signal emission (even though it
    /// is implemented by first deleting the selection, then inserting
    /// the new content, and may cause multiple ::notify::text signals
    /// to be emitted).
    #[doc(alias = "changed")]
    fn connect_changed<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;

    /// Emitted when text is deleted from the widget by the user.
    ///
    /// The default handler for this signal will normally be responsible for
    /// deleting the text, so by connecting to this signal and then stopping
    /// the signal with g_signal_stop_emission(), it is possible to modify the
    /// range of deleted text, or prevent it from being deleted entirely.
    ///
    /// The @start_pos and @end_pos parameters are interpreted as for
    /// [`delete_text()`][Self::delete_text()].
    /// ## `start_pos`
    /// the starting position
    /// ## `end_pos`
    /// the end position
    #[doc(alias = "delete-text")]
    fn connect_delete_text<F: Fn(&Self, i32, i32) + 'static>(&self, f: F) -> SignalHandlerId;

    #[doc(alias = "cursor-position")]
    fn connect_cursor_position_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;

    #[doc(alias = "editable")]
    fn connect_editable_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;

    #[doc(alias = "enable-undo")]
    fn connect_enable_undo_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;

    #[doc(alias = "max-width-chars")]
    fn connect_max_width_chars_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;

    #[doc(alias = "selection-bound")]
    fn connect_selection_bound_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;

    #[doc(alias = "text")]
    fn connect_text_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;

    #[doc(alias = "width-chars")]
    fn connect_width_chars_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;

    #[doc(alias = "xalign")]
    fn connect_xalign_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
}

impl<O: IsA<Editable>> EditableExt for O {
    fn delete_selection(&self) {
        unsafe {
            ffi::gtk_editable_delete_selection(self.as_ref().to_glib_none().0);
        }
    }

    fn delete_text(&self, start_pos: i32, end_pos: i32) {
        unsafe {
            ffi::gtk_editable_delete_text(self.as_ref().to_glib_none().0, start_pos, end_pos);
        }
    }

    fn finish_delegate(&self) {
        unsafe {
            ffi::gtk_editable_finish_delegate(self.as_ref().to_glib_none().0);
        }
    }

    fn alignment(&self) -> f32 {
        unsafe { ffi::gtk_editable_get_alignment(self.as_ref().to_glib_none().0) }
    }

    fn chars(&self, start_pos: i32, end_pos: i32) -> glib::GString {
        unsafe {
            from_glib_full(ffi::gtk_editable_get_chars(
                self.as_ref().to_glib_none().0,
                start_pos,
                end_pos,
            ))
        }
    }

    fn delegate(&self) -> Option<Editable> {
        unsafe {
            from_glib_none(ffi::gtk_editable_get_delegate(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn is_editable(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_editable_get_editable(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn enables_undo(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_editable_get_enable_undo(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn max_width_chars(&self) -> i32 {
        unsafe { ffi::gtk_editable_get_max_width_chars(self.as_ref().to_glib_none().0) }
    }

    fn position(&self) -> i32 {
        unsafe { ffi::gtk_editable_get_position(self.as_ref().to_glib_none().0) }
    }

    fn selection_bounds(&self) -> Option<(i32, i32)> {
        unsafe {
            let mut start_pos = mem::MaybeUninit::uninit();
            let mut end_pos = mem::MaybeUninit::uninit();
            let ret = from_glib(ffi::gtk_editable_get_selection_bounds(
                self.as_ref().to_glib_none().0,
                start_pos.as_mut_ptr(),
                end_pos.as_mut_ptr(),
            ));
            if ret {
                Some((start_pos.assume_init(), end_pos.assume_init()))
            } else {
                None
            }
        }
    }

    fn text(&self) -> glib::GString {
        unsafe { from_glib_none(ffi::gtk_editable_get_text(self.as_ref().to_glib_none().0)) }
    }

    fn width_chars(&self) -> i32 {
        unsafe { ffi::gtk_editable_get_width_chars(self.as_ref().to_glib_none().0) }
    }

    fn init_delegate(&self) {
        unsafe {
            ffi::gtk_editable_init_delegate(self.as_ref().to_glib_none().0);
        }
    }

    fn insert_text(&self, text: &str, position: &mut i32) {
        let length = text.len() as i32;
        unsafe {
            ffi::gtk_editable_insert_text(
                self.as_ref().to_glib_none().0,
                text.to_glib_none().0,
                length,
                position,
            );
        }
    }

    fn select_region(&self, start_pos: i32, end_pos: i32) {
        unsafe {
            ffi::gtk_editable_select_region(self.as_ref().to_glib_none().0, start_pos, end_pos);
        }
    }

    fn set_alignment(&self, xalign: f32) {
        unsafe {
            ffi::gtk_editable_set_alignment(self.as_ref().to_glib_none().0, xalign);
        }
    }

    fn set_editable(&self, is_editable: bool) {
        unsafe {
            ffi::gtk_editable_set_editable(self.as_ref().to_glib_none().0, is_editable.into_glib());
        }
    }

    fn set_enable_undo(&self, enable_undo: bool) {
        unsafe {
            ffi::gtk_editable_set_enable_undo(
                self.as_ref().to_glib_none().0,
                enable_undo.into_glib(),
            );
        }
    }

    fn set_max_width_chars(&self, n_chars: i32) {
        unsafe {
            ffi::gtk_editable_set_max_width_chars(self.as_ref().to_glib_none().0, n_chars);
        }
    }

    fn set_position(&self, position: i32) {
        unsafe {
            ffi::gtk_editable_set_position(self.as_ref().to_glib_none().0, position);
        }
    }

    fn set_text(&self, text: &str) {
        unsafe {
            ffi::gtk_editable_set_text(self.as_ref().to_glib_none().0, text.to_glib_none().0);
        }
    }

    fn set_width_chars(&self, n_chars: i32) {
        unsafe {
            ffi::gtk_editable_set_width_chars(self.as_ref().to_glib_none().0, n_chars);
        }
    }

    fn cursor_position(&self) -> i32 {
        glib::ObjectExt::property(self.as_ref(), "cursor-position")
    }

    fn selection_bound(&self) -> i32 {
        glib::ObjectExt::property(self.as_ref(), "selection-bound")
    }

    fn xalign(&self) -> f32 {
        glib::ObjectExt::property(self.as_ref(), "xalign")
    }

    fn set_xalign(&self, xalign: f32) {
        glib::ObjectExt::set_property(self.as_ref(), "xalign", &xalign)
    }

    fn connect_changed<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn changed_trampoline<P: IsA<Editable>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkEditable,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Editable::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"changed\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    changed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_delete_text<F: Fn(&Self, i32, i32) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn delete_text_trampoline<
            P: IsA<Editable>,
            F: Fn(&P, i32, i32) + 'static,
        >(
            this: *mut ffi::GtkEditable,
            start_pos: libc::c_int,
            end_pos: libc::c_int,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                Editable::from_glib_borrow(this).unsafe_cast_ref(),
                start_pos,
                end_pos,
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"delete-text\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    delete_text_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_cursor_position_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_cursor_position_trampoline<
            P: IsA<Editable>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkEditable,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Editable::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::cursor-position\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_cursor_position_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_editable_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_editable_trampoline<P: IsA<Editable>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkEditable,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Editable::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::editable\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_editable_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_enable_undo_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_enable_undo_trampoline<
            P: IsA<Editable>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkEditable,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Editable::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::enable-undo\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_enable_undo_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_max_width_chars_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_max_width_chars_trampoline<
            P: IsA<Editable>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkEditable,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Editable::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::max-width-chars\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_max_width_chars_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_selection_bound_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_selection_bound_trampoline<
            P: IsA<Editable>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkEditable,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Editable::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::selection-bound\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_selection_bound_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_text_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_text_trampoline<P: IsA<Editable>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkEditable,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Editable::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::text\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_text_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_width_chars_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_width_chars_trampoline<
            P: IsA<Editable>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkEditable,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Editable::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::width-chars\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_width_chars_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_xalign_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_xalign_trampoline<P: IsA<Editable>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkEditable,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Editable::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::xalign\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_xalign_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

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