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

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

glib::wrapper! {
    /// Form manager of a #WebKitWebPage in a #WebKitScriptWorld
    ///
    /// ## Signals
    ///
    ///
    /// #### `form-controls-associated`
    ///  Emitted after form elements (or form associated elements) are associated to @frame.
    /// This is useful to implement form auto filling for web pages where form fields are added
    /// dynamically. This signal might be emitted multiple times for the same frame.
    ///
    /// Note that this signal could be also emitted when form controls are moved between forms. In
    /// that case, the @elements array carries the list of those elements which have moved.
    ///
    /// Clients should take a reference to the members of the @elements array if it is desired to
    /// keep them alive after the signal handler returns.
    ///
    ///
    ///
    ///
    /// #### `will-send-submit-event`
    ///  This signal is emitted when the DOM submit event is about to be fired for @form.
    /// JavaScript code may rely on the submit event to detect that the user has clicked
    /// on a submit button, and to possibly cancel the form submission before
    /// #WebKitWebFormManager::will-submit-form signal is emitted.
    /// However, beware that, for historical reasons, the submit event is not emitted at
    /// all if the form submission is triggered by JavaScript. For these reasons,
    /// this signal may not be used to reliably detect whether a form will be submitted.
    /// Instead, use it to detect if a user has clicked on a form's submit button even if
    /// JavaScript later cancels the form submission, or to read the values of the form's
    /// fields even if JavaScript later clears certain fields before submitting. This may
    /// be needed, for example, to implement a robust browser password manager, as some
    /// misguided websites may use such techniques to attempt to thwart password managers.
    ///
    ///
    ///
    ///
    /// #### `will-submit-form`
    ///  This signal is emitted when @form will imminently be submitted. It can no longer
    /// be cancelled. This event always occurs immediately before a form is submitted to
    /// its target, so use this event to reliably detect when a form is submitted. This
    /// signal is emitted after #WebKitWebFormManager::will-send-submit-event if that
    /// signal is emitted.
    ///
    ///
    ///
    /// # Implements
    ///
    /// [`WebFormManagerExt`][trait@crate::prelude::WebFormManagerExt]
    #[doc(alias = "WebKitWebFormManager")]
    pub struct WebFormManager(Object<ffi::WebKitWebFormManager, ffi::WebKitWebFormManagerClass>);

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

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

    /// Set the value of an HTML input element as if it had been edited by
    /// the user, triggering a change event, and set it as filled automatically.
    /// If @element is not an HTML input element this function does nothing.
    /// ## `element`
    /// a #JSCValue
    /// ## `value`
    /// the text to set
    #[doc(alias = "webkit_web_form_manager_input_element_auto_fill")]
    pub fn input_element_auto_fill(element: &javascriptcore::Value, value: &str) {
        assert_initialized_main_thread!();
        unsafe {
            ffi::webkit_web_form_manager_input_element_auto_fill(
                element.to_glib_none().0,
                value.to_glib_none().0,
            );
        }
    }

    /// Get whether @element is an HTML input element that has been filled automatically.
    /// ## `element`
    /// a #JSCValue
    ///
    /// # Returns
    ///
    /// [`true`] if @element is an HTML input element that has been filled automatically,
    ///    or [`false`] otherwise
    #[doc(alias = "webkit_web_form_manager_input_element_is_auto_filled")]
    pub fn input_element_is_auto_filled(element: &javascriptcore::Value) -> bool {
        assert_initialized_main_thread!();
        unsafe {
            from_glib(ffi::webkit_web_form_manager_input_element_is_auto_filled(
                element.to_glib_none().0,
            ))
        }
    }

    /// Get whether @element is an HTML text input element that has been edited by a user action.
    /// ## `element`
    /// a #JSCValue
    ///
    /// # Returns
    ///
    /// [`true`] if @element is an HTML text input element that has been edited by a user action,
    ///    or [`false`] otherwise
    #[doc(alias = "webkit_web_form_manager_input_element_is_user_edited")]
    pub fn input_element_is_user_edited(element: &javascriptcore::Value) -> bool {
        assert_initialized_main_thread!();
        unsafe {
            from_glib(ffi::webkit_web_form_manager_input_element_is_user_edited(
                element.to_glib_none().0,
            ))
        }
    }
}

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

/// Trait containing all [`struct@WebFormManager`] methods.
///
/// # Implementors
///
/// [`WebFormManager`][struct@crate::WebFormManager]
pub trait WebFormManagerExt: IsA<WebFormManager> + sealed::Sealed + 'static {
    //#[doc(alias = "form-controls-associated")]
    //fn connect_form_controls_associated<Unsupported or ignored types>(&self, f: F) -> SignalHandlerId {
    //    Empty ctype elements: *.PtrArray TypeId { ns_id: 16, id: 2 }
    //}

    /// This signal is emitted when the DOM submit event is about to be fired for @form.
    /// JavaScript code may rely on the submit event to detect that the user has clicked
    /// on a submit button, and to possibly cancel the form submission before
    /// #WebKitWebFormManager::will-submit-form signal is emitted.
    /// However, beware that, for historical reasons, the submit event is not emitted at
    /// all if the form submission is triggered by JavaScript. For these reasons,
    /// this signal may not be used to reliably detect whether a form will be submitted.
    /// Instead, use it to detect if a user has clicked on a form's submit button even if
    /// JavaScript later cancels the form submission, or to read the values of the form's
    /// fields even if JavaScript later clears certain fields before submitting. This may
    /// be needed, for example, to implement a robust browser password manager, as some
    /// misguided websites may use such techniques to attempt to thwart password managers.
    /// ## `form`
    /// the #JSCValue to be submitted, which will always correspond to an HTMLFormElement
    /// ## `source_frame`
    /// the #WebKitFrame containing the form to be submitted
    /// ## `target_frame`
    /// the #WebKitFrame containing the form's target,
    ///     which may be the same as @source_frame if no target was specified
    #[doc(alias = "will-send-submit-event")]
    fn connect_will_send_submit_event<
        F: Fn(&Self, &javascriptcore::Value, &Frame, &Frame) + 'static,
    >(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn will_send_submit_event_trampoline<
            P: IsA<WebFormManager>,
            F: Fn(&P, &javascriptcore::Value, &Frame, &Frame) + 'static,
        >(
            this: *mut ffi::WebKitWebFormManager,
            form: *mut javascriptcore::ffi::JSCValue,
            source_frame: *mut ffi::WebKitFrame,
            target_frame: *mut ffi::WebKitFrame,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                WebFormManager::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(form),
                &from_glib_borrow(source_frame),
                &from_glib_borrow(target_frame),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"will-send-submit-event\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    will_send_submit_event_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// This signal is emitted when @form will imminently be submitted. It can no longer
    /// be cancelled. This event always occurs immediately before a form is submitted to
    /// its target, so use this event to reliably detect when a form is submitted. This
    /// signal is emitted after #WebKitWebFormManager::will-send-submit-event if that
    /// signal is emitted.
    /// ## `form`
    /// the #JSCValue to be submitted, which will always correspond to an HTMLFormElement
    /// ## `source_frame`
    /// the #WebKitFrame containing the form to be submitted
    /// ## `target_frame`
    /// the #WebKitFrame containing the form's target,
    ///     which may be the same as @source_frame if no target was specified
    #[doc(alias = "will-submit-form")]
    fn connect_will_submit_form<F: Fn(&Self, &javascriptcore::Value, &Frame, &Frame) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn will_submit_form_trampoline<
            P: IsA<WebFormManager>,
            F: Fn(&P, &javascriptcore::Value, &Frame, &Frame) + 'static,
        >(
            this: *mut ffi::WebKitWebFormManager,
            form: *mut javascriptcore::ffi::JSCValue,
            source_frame: *mut ffi::WebKitFrame,
            target_frame: *mut ffi::WebKitFrame,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                WebFormManager::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(form),
                &from_glib_borrow(source_frame),
                &from_glib_borrow(target_frame),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"will-submit-form\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    will_submit_form_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

impl<O: IsA<WebFormManager>> WebFormManagerExt for O {}