// 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, WebViewBase};
use glib::{
    prelude::*,
    signal::{connect_raw, SignalHandlerId},
    translate::*,
};
use std::boxed::Box as Box_;

glib::wrapper! {
    /// Access to the WebKit inspector.
    ///
    /// The WebKit Inspector is a graphical tool to inspect and change the
    /// content of a #WebKitWebView. It also includes an interactive
    /// JavaScript debugger. Using this class one can get a #GtkWidget
    /// which can be embedded into an application to show the inspector.
    ///
    /// The inspector is available when the #WebKitSettings of the
    /// #WebKitWebView has set the #WebKitSettings:enable-developer-extras
    /// to true, otherwise no inspector is available.
    ///
    /// **⚠️ The following code is in c ⚠️**
    ///
    /// ```c
    /// // Enable the developer extras
    /// WebKitSettings *settings = webkit_web_view_get_settings (WEBKIT_WEB_VIEW(my_webview));
    /// g_object_set (G_OBJECT(settings), "enable-developer-extras", TRUE, NULL);
    ///
    /// // Load some data or reload to be able to inspect the page
    /// webkit_web_view_load_uri (WEBKIT_WEB_VIEW(my_webview), "http://www.gnome.org");
    ///
    /// // Show the inspector
    /// WebKitWebInspector *inspector = webkit_web_view_get_inspector (WEBKIT_WEB_VIEW(my_webview));
    /// webkit_web_inspector_show (WEBKIT_WEB_INSPECTOR(inspector));
    /// ```
    ///
    /// ## Properties
    ///
    ///
    /// #### `attached-height`
    ///  The height that the inspector view should have when it is attached.
    ///
    /// Readable
    ///
    ///
    /// #### `can-attach`
    ///  Whether the @inspector can be attached to the same window that contains
    /// the inspected view.
    ///
    /// Readable
    ///
    ///
    /// #### `inspected-uri`
    ///  The URI that is currently being inspected.
    ///
    /// Readable
    ///
    /// ## Signals
    ///
    ///
    /// #### `attach`
    ///  Emitted when the inspector is requested to be attached to the window
    /// where the inspected web view is.
    /// If this signal is not handled the inspector view will be automatically
    /// attached to the inspected view, so you only need to handle this signal
    /// if you want to attach the inspector view yourself (for example, to add
    /// the inspector view to a browser tab).
    ///
    /// To prevent the inspector view from being attached you can connect to this
    /// signal and simply return [`true`].
    ///
    ///
    ///
    ///
    /// #### `bring-to-front`
    ///  Emitted when the inspector should be shown.
    ///
    /// If the inspector is not attached the inspector window should be shown
    /// on top of any other windows.
    /// If the inspector is attached the inspector view should be made visible.
    /// For example, if the inspector view is attached using a tab in a browser
    /// window, the browser window should be raised and the tab containing the
    /// inspector view should be the active one.
    /// In both cases, if this signal is not handled, the default implementation
    /// calls gtk_window_present() on the current toplevel #GtkWindow of the
    /// inspector view.
    ///
    ///
    ///
    ///
    /// #### `closed`
    ///  Emitted when the inspector page is closed. If you are using your own
    /// inspector window, you should connect to this signal and destroy your
    /// window.
    ///
    ///
    ///
    ///
    /// #### `detach`
    ///  Emitted when the inspector is requested to be detached from the window
    /// it is currently attached to. The inspector is detached when the inspector page
    /// is about to be closed, and this signal is emitted right before
    /// #WebKitWebInspector::closed, or when the user clicks on the detach button
    /// in the inspector view to show the inspector in a separate window. In this case
    /// the signal #WebKitWebInspector::open-window is emitted after this one.
    ///
    /// To prevent the inspector view from being detached you can connect to this
    /// signal and simply return [`true`].
    ///
    ///
    ///
    ///
    /// #### `open-window`
    ///  Emitted when the inspector is requested to open in a separate window.
    /// If this signal is not handled, a #GtkWindow with the inspector will be
    /// created and shown, so you only need to handle this signal if you want
    /// to use your own window.
    /// This signal is emitted after #WebKitWebInspector::detach to show
    /// the inspector in a separate window after being detached.
    ///
    /// To prevent the inspector from being shown you can connect to this
    /// signal and simply return [`true`]
    ///
    ///
    #[doc(alias = "WebKitWebInspector")]
    pub struct WebInspector(Object<ffi::WebKitWebInspector, ffi::WebKitWebInspectorClass>);

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

impl WebInspector {
    /// Request @self to be attached.
    ///
    /// The signal #WebKitWebInspector::attach
    /// will be emitted. If the inspector is already attached it does nothing.
    #[doc(alias = "webkit_web_inspector_attach")]
    pub fn attach(&self) {
        unsafe {
            ffi::webkit_web_inspector_attach(self.to_glib_none().0);
        }
    }

    /// Request @self to be closed.
    #[doc(alias = "webkit_web_inspector_close")]
    pub fn close(&self) {
        unsafe {
            ffi::webkit_web_inspector_close(self.to_glib_none().0);
        }
    }

    /// Request @self to be detached.
    ///
    /// The signal #WebKitWebInspector::detach
    /// will be emitted. If the inspector is already detached it does nothing.
    #[doc(alias = "webkit_web_inspector_detach")]
    pub fn detach(&self) {
        unsafe {
            ffi::webkit_web_inspector_detach(self.to_glib_none().0);
        }
    }

    /// Get the height that the inspector view when attached.
    ///
    /// Get the height that the inspector view should have when
    /// it's attached. If the inspector view is not attached this
    /// returns 0.
    ///
    /// # Returns
    ///
    /// the height of the inspector view when attached
    #[doc(alias = "webkit_web_inspector_get_attached_height")]
    #[doc(alias = "get_attached_height")]
    #[doc(alias = "attached-height")]
    pub fn attached_height(&self) -> u32 {
        unsafe { ffi::webkit_web_inspector_get_attached_height(self.to_glib_none().0) }
    }

    /// Whether the @self can be attached to the same window that contains
    /// the inspected view.
    ///
    /// # Returns
    ///
    /// [`true`] if there is enough room for the inspector view inside the
    ///     window that contains the inspected view, or [`false`] otherwise.
    #[doc(alias = "webkit_web_inspector_get_can_attach")]
    #[doc(alias = "get_can_attach")]
    #[doc(alias = "can-attach")]
    pub fn can_attach(&self) -> bool {
        unsafe {
            from_glib(ffi::webkit_web_inspector_get_can_attach(
                self.to_glib_none().0,
            ))
        }
    }

    /// Get the URI that is currently being inspected.
    ///
    /// This can be [`None`] if
    /// nothing has been loaded yet in the inspected view, if the inspector
    /// has been closed or when inspected view was loaded from a HTML string
    /// instead of a URI.
    ///
    /// # Returns
    ///
    /// the URI that is currently being inspected or [`None`]
    #[doc(alias = "webkit_web_inspector_get_inspected_uri")]
    #[doc(alias = "get_inspected_uri")]
    #[doc(alias = "inspected-uri")]
    pub fn inspected_uri(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::webkit_web_inspector_get_inspected_uri(
                self.to_glib_none().0,
            ))
        }
    }

    /// Get the #WebKitWebViewBase used to display the inspector.
    ///
    /// This might be [`None`] if the inspector hasn't been loaded yet,
    /// or it has been closed.
    ///
    /// # Returns
    ///
    /// the #WebKitWebViewBase used to display the inspector or [`None`]
    #[doc(alias = "webkit_web_inspector_get_web_view")]
    #[doc(alias = "get_web_view")]
    pub fn web_view(&self) -> Option<WebViewBase> {
        unsafe {
            from_glib_none(ffi::webkit_web_inspector_get_web_view(
                self.to_glib_none().0,
            ))
        }
    }

    /// Whether the @self view is currently attached to the same window that contains
    /// the inspected view.
    ///
    /// # Returns
    ///
    /// [`true`] if @self is currently attached or [`false`] otherwise
    #[doc(alias = "webkit_web_inspector_is_attached")]
    pub fn is_attached(&self) -> bool {
        unsafe { from_glib(ffi::webkit_web_inspector_is_attached(self.to_glib_none().0)) }
    }

    /// Request @self to be shown.
    #[doc(alias = "webkit_web_inspector_show")]
    pub fn show(&self) {
        unsafe {
            ffi::webkit_web_inspector_show(self.to_glib_none().0);
        }
    }

    /// Emitted when the inspector is requested to be attached to the window
    /// where the inspected web view is.
    /// If this signal is not handled the inspector view will be automatically
    /// attached to the inspected view, so you only need to handle this signal
    /// if you want to attach the inspector view yourself (for example, to add
    /// the inspector view to a browser tab).
    ///
    /// To prevent the inspector view from being attached you can connect to this
    /// signal and simply return [`true`].
    ///
    /// # Returns
    ///
    /// [`true`] to stop other handlers from being invoked for the event.
    ///    [`false`] to propagate the event further.
    #[doc(alias = "attach")]
    pub fn connect_attach<F: Fn(&Self) -> bool + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn attach_trampoline<F: Fn(&WebInspector) -> bool + 'static>(
            this: *mut ffi::WebKitWebInspector,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this)).into_glib()
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"attach\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    attach_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted when the inspector should be shown.
    ///
    /// If the inspector is not attached the inspector window should be shown
    /// on top of any other windows.
    /// If the inspector is attached the inspector view should be made visible.
    /// For example, if the inspector view is attached using a tab in a browser
    /// window, the browser window should be raised and the tab containing the
    /// inspector view should be the active one.
    /// In both cases, if this signal is not handled, the default implementation
    /// calls gtk_window_present() on the current toplevel #GtkWindow of the
    /// inspector view.
    ///
    /// # Returns
    ///
    /// [`true`] to stop other handlers from being invoked for the event.
    ///    [`false`] to propagate the event further.
    #[doc(alias = "bring-to-front")]
    pub fn connect_bring_to_front<F: Fn(&Self) -> bool + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn bring_to_front_trampoline<F: Fn(&WebInspector) -> bool + 'static>(
            this: *mut ffi::WebKitWebInspector,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this)).into_glib()
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"bring-to-front\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    bring_to_front_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted when the inspector page is closed. If you are using your own
    /// inspector window, you should connect to this signal and destroy your
    /// window.
    #[doc(alias = "closed")]
    pub fn connect_closed<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn closed_trampoline<F: Fn(&WebInspector) + 'static>(
            this: *mut ffi::WebKitWebInspector,
            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"closed\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    closed_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted when the inspector is requested to be detached from the window
    /// it is currently attached to. The inspector is detached when the inspector page
    /// is about to be closed, and this signal is emitted right before
    /// #WebKitWebInspector::closed, or when the user clicks on the detach button
    /// in the inspector view to show the inspector in a separate window. In this case
    /// the signal #WebKitWebInspector::open-window is emitted after this one.
    ///
    /// To prevent the inspector view from being detached you can connect to this
    /// signal and simply return [`true`].
    ///
    /// # Returns
    ///
    /// [`true`] to stop other handlers from being invoked for the event.
    ///    [`false`] to propagate the event further.
    #[doc(alias = "detach")]
    pub fn connect_detach<F: Fn(&Self) -> bool + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn detach_trampoline<F: Fn(&WebInspector) -> bool + 'static>(
            this: *mut ffi::WebKitWebInspector,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this)).into_glib()
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"detach\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    detach_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted when the inspector is requested to open in a separate window.
    /// If this signal is not handled, a #GtkWindow with the inspector will be
    /// created and shown, so you only need to handle this signal if you want
    /// to use your own window.
    /// This signal is emitted after #WebKitWebInspector::detach to show
    /// the inspector in a separate window after being detached.
    ///
    /// To prevent the inspector from being shown you can connect to this
    /// signal and simply return [`true`]
    ///
    /// # Returns
    ///
    /// [`true`] to stop other handlers from being invoked for the event.
    ///    [`false`] to propagate the event further.
    #[doc(alias = "open-window")]
    pub fn connect_open_window<F: Fn(&Self) -> bool + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn open_window_trampoline<F: Fn(&WebInspector) -> bool + 'static>(
            this: *mut ffi::WebKitWebInspector,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this)).into_glib()
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"open-window\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    open_window_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "attached-height")]
    pub fn connect_attached_height_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_attached_height_trampoline<F: Fn(&WebInspector) + 'static>(
            this: *mut ffi::WebKitWebInspector,
            _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::attached-height\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_attached_height_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "can-attach")]
    pub fn connect_can_attach_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_can_attach_trampoline<F: Fn(&WebInspector) + 'static>(
            this: *mut ffi::WebKitWebInspector,
            _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::can-attach\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_can_attach_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "inspected-uri")]
    pub fn connect_inspected_uri_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_inspected_uri_trampoline<F: Fn(&WebInspector) + 'static>(
            this: *mut ffi::WebKitWebInspector,
            _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::inspected-uri\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_inspected_uri_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}