// 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;
use glib::{prelude::*, translate::*};

glib::wrapper! {
    /// Window properties of a #WebKitWebView.
    ///
    /// The content of a #WebKitWebView can request to change certain
    /// properties of the window containing the view. This can include the x, y position
    /// of the window, the width and height but also if a toolbar,
    /// scrollbar, statusbar, locationbar should be visible to the user,
    /// and the request to show the #WebKitWebView fullscreen.
    ///
    /// The #WebKitWebView::ready-to-show signal handler is the proper place
    /// to apply the initial window properties. Then you can monitor the
    /// #WebKitWindowProperties by connecting to ::notify signal.
    ///
    /// **⚠️ The following code is in c ⚠️**
    ///
    /// ```c
    /// static void ready_to_show_cb (WebKitWebView *web_view, gpointer user_data)
    /// {
    ///     GtkWidget *window;
    ///     WebKitWindowProperties *window_properties;
    ///     gboolean visible;
    ///
    ///     // Create the window to contain the WebKitWebView.
    ///     window = browser_window_new ();
    ///     gtk_container_add (GTK_CONTAINER (window), GTK_WIDGET (web_view));
    ///     gtk_widget_show (GTK_WIDGET (web_view));
    ///
    ///     // Get the WebKitWindowProperties of the web view and monitor it.
    ///     window_properties = webkit_web_view_get_window_properties (web_view);
    ///     g_signal_connect (window_properties, "notify::geometry",
    ///                       G_CALLBACK (window_geometry_changed), window);
    ///     g_signal_connect (window_properties, "notify::toolbar-visible",
    ///                       G_CALLBACK (window_toolbar_visibility_changed), window);
    ///     g_signal_connect (window_properties, "notify::menubar-visible",
    ///                       G_CALLBACK (window_menubar_visibility_changed), window);
    ///
    ///     // Apply the window properties before showing the window.
    ///     visible = webkit_window_properties_get_toolbar_visible (window_properties);
    ///     browser_window_set_toolbar_visible (BROWSER_WINDOW (window), visible);
    ///     visible = webkit_window_properties_get_menubar_visible (window_properties);
    ///     browser_window_set_menubar_visible (BROWSER_WINDOW (window), visible);
    ///
    ///     if (webkit_window_properties_get_fullscreen (window_properties)) {
    ///         gtk_window_fullscreen (GTK_WINDOW (window));
    ///     } else {
    ///         GdkRectangle geometry;
    ///
    ///         gtk_window_set_resizable (GTK_WINDOW (window),
    ///                                   webkit_window_properties_get_resizable (window_properties));
    ///         webkit_window_properties_get_geometry (window_properties, &geometry);
    ///         gtk_window_move (GTK_WINDOW (window), geometry.x, geometry.y);
    ///         gtk_window_resize (GTK_WINDOW (window), geometry.width, geometry.height);
    ///     }
    ///
    ///     gtk_widget_show (window);
    /// }
    /// ```
    ///
    /// ## Properties
    ///
    ///
    /// #### `fullscreen`
    ///  Whether window will be displayed fullscreen.
    ///
    /// Readable | Writeable | Construct Only
    ///
    ///
    /// #### `geometry`
    ///  The size and position of the window on the screen.
    ///
    /// Readable | Writeable | Construct Only
    ///
    ///
    /// #### `locationbar-visible`
    ///  Whether the locationbar should be visible for the window.
    ///
    /// Readable | Writeable | Construct Only
    ///
    ///
    /// #### `menubar-visible`
    ///  Whether the menubar should be visible for the window.
    ///
    /// Readable | Writeable | Construct Only
    ///
    ///
    /// #### `resizable`
    ///  Whether the window can be resized.
    ///
    /// Readable | Writeable | Construct Only
    ///
    ///
    /// #### `scrollbars-visible`
    ///  Whether the scrollbars should be visible for the window.
    ///
    /// Readable | Writeable | Construct Only
    ///
    ///
    /// #### `statusbar-visible`
    ///  Whether the statusbar should be visible for the window.
    ///
    /// Readable | Writeable | Construct Only
    ///
    ///
    /// #### `toolbar-visible`
    ///  Whether the toolbar should be visible for the window.
    ///
    /// Readable | Writeable | Construct Only
    #[doc(alias = "WebKitWindowProperties")]
    pub struct WindowProperties(Object<ffi::WebKitWindowProperties, ffi::WebKitWindowPropertiesClass>);

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

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

    /// Get whether the window should be shown in fullscreen state or not.
    ///
    /// # Returns
    ///
    /// [`true`] if the window should be fullscreen or [`false`] otherwise.
    #[doc(alias = "webkit_window_properties_get_fullscreen")]
    #[doc(alias = "get_fullscreen")]
    #[doc(alias = "fullscreen")]
    pub fn is_fullscreen(&self) -> bool {
        unsafe {
            from_glib(ffi::webkit_window_properties_get_fullscreen(
                self.to_glib_none().0,
            ))
        }
    }

    /// Get the geometry the window should have on the screen when shown.
    ///
    /// # Returns
    ///
    ///
    /// ## `geometry`
    /// return location for the window geometry
    #[doc(alias = "webkit_window_properties_get_geometry")]
    #[doc(alias = "get_geometry")]
    pub fn geometry(&self) -> gdk::Rectangle {
        unsafe {
            let mut geometry = gdk::Rectangle::uninitialized();
            ffi::webkit_window_properties_get_geometry(
                self.to_glib_none().0,
                geometry.to_glib_none_mut().0,
            );
            geometry
        }
    }

    /// Get whether the window should have the locationbar visible or not.
    ///
    /// # Returns
    ///
    /// [`true`] if locationbar should be visible or [`false`] otherwise.
    #[doc(alias = "webkit_window_properties_get_locationbar_visible")]
    #[doc(alias = "get_locationbar_visible")]
    #[doc(alias = "locationbar-visible")]
    pub fn is_locationbar_visible(&self) -> bool {
        unsafe {
            from_glib(ffi::webkit_window_properties_get_locationbar_visible(
                self.to_glib_none().0,
            ))
        }
    }

    /// Get whether the window should have the menubar visible or not.
    ///
    /// # Returns
    ///
    /// [`true`] if menubar should be visible or [`false`] otherwise.
    #[doc(alias = "webkit_window_properties_get_menubar_visible")]
    #[doc(alias = "get_menubar_visible")]
    #[doc(alias = "menubar-visible")]
    pub fn is_menubar_visible(&self) -> bool {
        unsafe {
            from_glib(ffi::webkit_window_properties_get_menubar_visible(
                self.to_glib_none().0,
            ))
        }
    }

    /// Get whether the window should be resizable by the user or not.
    ///
    /// # Returns
    ///
    /// [`true`] if the window should be resizable or [`false`] otherwise.
    #[doc(alias = "webkit_window_properties_get_resizable")]
    #[doc(alias = "get_resizable")]
    #[doc(alias = "resizable")]
    pub fn is_resizable(&self) -> bool {
        unsafe {
            from_glib(ffi::webkit_window_properties_get_resizable(
                self.to_glib_none().0,
            ))
        }
    }

    /// Get whether the window should have the scrollbars visible or not.
    ///
    /// # Returns
    ///
    /// [`true`] if scrollbars should be visible or [`false`] otherwise.
    #[doc(alias = "webkit_window_properties_get_scrollbars_visible")]
    #[doc(alias = "get_scrollbars_visible")]
    #[doc(alias = "scrollbars-visible")]
    pub fn is_scrollbars_visible(&self) -> bool {
        unsafe {
            from_glib(ffi::webkit_window_properties_get_scrollbars_visible(
                self.to_glib_none().0,
            ))
        }
    }

    /// Get whether the window should have the statusbar visible or not.
    ///
    /// # Returns
    ///
    /// [`true`] if statusbar should be visible or [`false`] otherwise.
    #[doc(alias = "webkit_window_properties_get_statusbar_visible")]
    #[doc(alias = "get_statusbar_visible")]
    #[doc(alias = "statusbar-visible")]
    pub fn is_statusbar_visible(&self) -> bool {
        unsafe {
            from_glib(ffi::webkit_window_properties_get_statusbar_visible(
                self.to_glib_none().0,
            ))
        }
    }

    /// Get whether the window should have the toolbar visible or not.
    ///
    /// # Returns
    ///
    /// [`true`] if toolbar should be visible or [`false`] otherwise.
    #[doc(alias = "webkit_window_properties_get_toolbar_visible")]
    #[doc(alias = "get_toolbar_visible")]
    #[doc(alias = "toolbar-visible")]
    pub fn is_toolbar_visible(&self) -> bool {
        unsafe {
            from_glib(ffi::webkit_window_properties_get_toolbar_visible(
                self.to_glib_none().0,
            ))
        }
    }
}

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

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

    /// Whether window will be displayed fullscreen.
    pub fn fullscreen(self, fullscreen: bool) -> Self {
        Self {
            builder: self.builder.property("fullscreen", fullscreen),
        }
    }

    /// The size and position of the window on the screen.
    pub fn geometry(self, geometry: &gdk::Rectangle) -> Self {
        Self {
            builder: self.builder.property("geometry", geometry),
        }
    }

    /// Whether the locationbar should be visible for the window.
    pub fn locationbar_visible(self, locationbar_visible: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("locationbar-visible", locationbar_visible),
        }
    }

    /// Whether the menubar should be visible for the window.
    pub fn menubar_visible(self, menubar_visible: bool) -> Self {
        Self {
            builder: self.builder.property("menubar-visible", menubar_visible),
        }
    }

    /// Whether the window can be resized.
    pub fn resizable(self, resizable: bool) -> Self {
        Self {
            builder: self.builder.property("resizable", resizable),
        }
    }

    /// Whether the scrollbars should be visible for the window.
    pub fn scrollbars_visible(self, scrollbars_visible: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("scrollbars-visible", scrollbars_visible),
        }
    }

    /// Whether the statusbar should be visible for the window.
    pub fn statusbar_visible(self, statusbar_visible: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("statusbar-visible", statusbar_visible),
        }
    }

    /// Whether the toolbar should be visible for the window.
    pub fn toolbar_visible(self, toolbar_visible: bool) -> Self {
        Self {
            builder: self.builder.property("toolbar-visible", toolbar_visible),
        }
    }

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