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

glib::wrapper! {
    /// Object used to communicate with the application when downloading.
    ///
    /// #WebKitDownload carries information about a download request and
    /// response, including a #WebKitURIRequest and a #WebKitURIResponse
    /// objects. The application may use this object to control the
    /// download process, or to simply figure out what is to be downloaded,
    /// and handle the download process itself.
    ///
    /// ## Properties
    ///
    ///
    /// #### `allow-overwrite`
    ///  Whether or not the download is allowed to overwrite an existing file on
    /// disk. If this property is [`false`] and the destination already exists,
    /// the download will fail.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `destination`
    ///  The local path to where the download will be saved.
    ///
    /// Readable
    ///
    ///
    /// #### `estimated-progress`
    ///  An estimate of the percent completion for the download operation.
    /// This value will range from 0.0 to 1.0. The value is an estimate
    /// based on the total number of bytes expected to be received for
    /// a download.
    /// If you need a more accurate progress information you can connect to
    /// #WebKitDownload::received-data signal to track the progress.
    ///
    /// Readable
    ///
    ///
    /// #### `response`
    ///  The #WebKitURIResponse associated with this download.
    ///
    /// Readable
    ///
    /// ## Signals
    ///
    ///
    /// #### `created-destination`
    ///  This signal is emitted after #WebKitDownload::decide-destination and before
    /// #WebKitDownload::received-data to notify that destination file has been
    /// created successfully at @destination.
    ///
    ///
    ///
    ///
    /// #### `decide-destination`
    ///  This signal is emitted after response is received to
    /// decide a destination for the download using
    /// webkit_download_set_destination(). If this signal is not
    /// handled, the file will be downloaded to `G_USER_DIRECTORY_DOWNLOAD`
    /// directory using @suggested_filename.
    ///
    /// Since 2.40, you may handle this signal asynchronously by
    /// returning [`true`] without calling webkit_download_set_destination().
    /// This indicates intent to eventually call webkit_download_set_destination().
    /// In this case, the download will not proceed until the destination is set
    /// or cancelled with webkit_download_cancel().
    ///
    ///
    ///
    ///
    /// #### `failed`
    ///  This signal is emitted when an error occurs during the download
    /// operation. The given @error, of the domain `WEBKIT_DOWNLOAD_ERROR`,
    /// contains further details of the failure. If the download is cancelled
    /// with webkit_download_cancel(), this signal is emitted with error
    /// [`DownloadError::CancelledByUser`][crate::DownloadError::CancelledByUser]. The download operation finishes
    /// after an error and #WebKitDownload::finished signal is emitted after this one.
    ///
    ///
    ///
    ///
    /// #### `finished`
    ///  This signal is emitted when download finishes successfully or due to an error.
    /// In case of errors #WebKitDownload::failed signal is emitted before this one.
    ///
    ///
    ///
    ///
    /// #### `received-data`
    ///  This signal is emitted after response is received,
    /// every time new data has been written to the destination. It's
    /// useful to know the progress of the download operation.
    ///
    ///
    #[doc(alias = "WebKitDownload")]
    pub struct Download(Object<ffi::WebKitDownload, ffi::WebKitDownloadClass>);

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

impl Download {
    /// Cancels the download.
    ///
    /// When the ongoing download
    /// operation is effectively cancelled the signal
    /// #WebKitDownload::failed is emitted with
    /// [`DownloadError::CancelledByUser`][crate::DownloadError::CancelledByUser] error.
    #[doc(alias = "webkit_download_cancel")]
    pub fn cancel(&self) {
        unsafe {
            ffi::webkit_download_cancel(self.to_glib_none().0);
        }
    }

    /// Returns the current value of the #WebKitDownload:allow-overwrite property.
    ///
    /// Returns the current value of the #WebKitDownload:allow-overwrite property,
    /// which determines whether the download will overwrite an existing file on
    /// disk, or if it will fail if the destination already exists.
    ///
    /// # Returns
    ///
    /// the current value of the #WebKitDownload:allow-overwrite property
    #[doc(alias = "webkit_download_get_allow_overwrite")]
    #[doc(alias = "get_allow_overwrite")]
    #[doc(alias = "allow-overwrite")]
    pub fn allows_overwrite(&self) -> bool {
        unsafe {
            from_glib(ffi::webkit_download_get_allow_overwrite(
                self.to_glib_none().0,
            ))
        }
    }

    /// Obtains the destination to which the downloaded file will be written.
    ///
    /// You can connect to #WebKitDownload::created-destination to make
    /// sure this method returns a valid destination.
    ///
    /// # Returns
    ///
    /// the destination or [`None`]
    #[doc(alias = "webkit_download_get_destination")]
    #[doc(alias = "get_destination")]
    pub fn destination(&self) -> Option<glib::GString> {
        unsafe { from_glib_none(ffi::webkit_download_get_destination(self.to_glib_none().0)) }
    }

    /// Gets the elapsed time in seconds, including any fractional part.
    ///
    /// If the download finished, had an error or was cancelled this is
    /// the time between its start and the event.
    ///
    /// # Returns
    ///
    /// seconds since the download was started
    #[doc(alias = "webkit_download_get_elapsed_time")]
    #[doc(alias = "get_elapsed_time")]
    pub fn elapsed_time(&self) -> f64 {
        unsafe { ffi::webkit_download_get_elapsed_time(self.to_glib_none().0) }
    }

    /// Gets the value of the #WebKitDownload:estimated-progress property.
    /// Gets the value of the #WebKitDownload:estimated-progress property.
    /// You can monitor the estimated progress of the download operation by
    /// connecting to the notify::estimated-progress signal of @self.
    ///
    /// # Returns
    ///
    /// an estimate of the of the percent complete for a download
    ///     as a range from 0.0 to 1.0.
    #[doc(alias = "webkit_download_get_estimated_progress")]
    #[doc(alias = "get_estimated_progress")]
    #[doc(alias = "estimated-progress")]
    pub fn estimated_progress(&self) -> f64 {
        unsafe { ffi::webkit_download_get_estimated_progress(self.to_glib_none().0) }
    }

    /// Gets the length of the data already downloaded for @self.
    ///
    /// Gets the length of the data already downloaded for @self
    /// in bytes.
    ///
    /// # Returns
    ///
    /// the amount of bytes already downloaded.
    #[doc(alias = "webkit_download_get_received_data_length")]
    #[doc(alias = "get_received_data_length")]
    pub fn received_data_length(&self) -> u64 {
        unsafe { ffi::webkit_download_get_received_data_length(self.to_glib_none().0) }
    }

    /// Retrieves the #WebKitURIRequest object that backs the download
    /// process.
    ///
    /// # Returns
    ///
    /// the #WebKitURIRequest of @self
    #[doc(alias = "webkit_download_get_request")]
    #[doc(alias = "get_request")]
    pub fn request(&self) -> Option<URIRequest> {
        unsafe { from_glib_none(ffi::webkit_download_get_request(self.to_glib_none().0)) }
    }

    /// Retrieves the #WebKitURIResponse object that backs the download process.
    ///
    /// Retrieves the #WebKitURIResponse object that backs the download
    /// process. This method returns [`None`] if called before the response
    /// is received from the server. You can connect to notify::response
    /// signal to be notified when the response is received.
    ///
    /// # Returns
    ///
    /// the #WebKitURIResponse, or [`None`] if
    ///     the response hasn't been received yet.
    #[doc(alias = "webkit_download_get_response")]
    #[doc(alias = "get_response")]
    pub fn response(&self) -> Option<URIResponse> {
        unsafe { from_glib_none(ffi::webkit_download_get_response(self.to_glib_none().0)) }
    }

    /// Get the #WebKitWebView that initiated the download.
    ///
    /// # Returns
    ///
    /// the #WebKitWebView that initiated @self,
    ///    or [`None`] if @self was not initiated by a #WebKitWebView.
    #[doc(alias = "webkit_download_get_web_view")]
    #[doc(alias = "get_web_view")]
    pub fn web_view(&self) -> Option<WebView> {
        unsafe { from_glib_none(ffi::webkit_download_get_web_view(self.to_glib_none().0)) }
    }

    /// Sets the #WebKitDownload:allow-overwrite property.
    ///
    /// Sets the #WebKitDownload:allow-overwrite property, which determines whether
    /// the download may overwrite an existing file on disk, or if it will fail if
    /// the destination already exists.
    /// ## `allowed`
    /// the new value for the #WebKitDownload:allow-overwrite property
    #[doc(alias = "webkit_download_set_allow_overwrite")]
    #[doc(alias = "allow-overwrite")]
    pub fn set_allow_overwrite(&self, allowed: bool) {
        unsafe {
            ffi::webkit_download_set_allow_overwrite(self.to_glib_none().0, allowed.into_glib());
        }
    }

    /// Sets the destination to which the downloaded file will be written.
    ///
    /// This method should be called before the download transfer
    /// starts or it will not have any effect on the ongoing download
    /// operation. To set the destination using the filename suggested
    /// by the server connect to #WebKitDownload::decide-destination
    /// signal and call webkit_download_set_destination(). If you want to
    /// set a fixed destination that doesn't depend on the suggested
    /// filename you can connect to notify::response signal and call
    /// webkit_download_set_destination().
    ///
    /// If #WebKitDownload::decide-destination signal is not handled
    /// and destination is not set when the download transfer starts,
    /// the file will be saved with the filename suggested by the server in
    /// `G_USER_DIRECTORY_DOWNLOAD` directory.
    /// ## `destination`
    /// the destination
    #[doc(alias = "webkit_download_set_destination")]
    pub fn set_destination(&self, destination: &str) {
        unsafe {
            ffi::webkit_download_set_destination(
                self.to_glib_none().0,
                destination.to_glib_none().0,
            );
        }
    }

    /// This signal is emitted after #WebKitDownload::decide-destination and before
    /// #WebKitDownload::received-data to notify that destination file has been
    /// created successfully at @destination.
    /// ## `destination`
    /// the destination
    #[doc(alias = "created-destination")]
    pub fn connect_created_destination<F: Fn(&Self, &str) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn created_destination_trampoline<F: Fn(&Download, &str) + 'static>(
            this: *mut ffi::WebKitDownload,
            destination: *mut libc::c_char,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                &from_glib_borrow(this),
                &glib::GString::from_glib_borrow(destination),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"created-destination\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    created_destination_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// This signal is emitted after response is received to
    /// decide a destination for the download using
    /// webkit_download_set_destination(). If this signal is not
    /// handled, the file will be downloaded to `G_USER_DIRECTORY_DOWNLOAD`
    /// directory using @suggested_filename.
    ///
    /// Since 2.40, you may handle this signal asynchronously by
    /// returning [`true`] without calling webkit_download_set_destination().
    /// This indicates intent to eventually call webkit_download_set_destination().
    /// In this case, the download will not proceed until the destination is set
    /// or cancelled with webkit_download_cancel().
    /// ## `suggested_filename`
    /// the filename suggested for the download
    ///
    /// # Returns
    ///
    /// [`true`] to stop other handlers from being invoked for the event,
    ///   or [`false`] to propagate the event further.
    #[doc(alias = "decide-destination")]
    pub fn connect_decide_destination<F: Fn(&Self, &str) -> bool + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn decide_destination_trampoline<
            F: Fn(&Download, &str) -> bool + 'static,
        >(
            this: *mut ffi::WebKitDownload,
            suggested_filename: *mut libc::c_char,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            let f: &F = &*(f as *const F);
            f(
                &from_glib_borrow(this),
                &glib::GString::from_glib_borrow(suggested_filename),
            )
            .into_glib()
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"decide-destination\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    decide_destination_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// This signal is emitted when an error occurs during the download
    /// operation. The given @error, of the domain `WEBKIT_DOWNLOAD_ERROR`,
    /// contains further details of the failure. If the download is cancelled
    /// with webkit_download_cancel(), this signal is emitted with error
    /// [`DownloadError::CancelledByUser`][crate::DownloadError::CancelledByUser]. The download operation finishes
    /// after an error and #WebKitDownload::finished signal is emitted after this one.
    /// ## `error`
    /// the #GError that was triggered
    #[doc(alias = "failed")]
    pub fn connect_failed<F: Fn(&Self, &glib::Error) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn failed_trampoline<F: Fn(&Download, &glib::Error) + 'static>(
            this: *mut ffi::WebKitDownload,
            error: *mut glib::ffi::GError,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this), &from_glib_borrow(error))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"failed\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    failed_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// This signal is emitted when download finishes successfully or due to an error.
    /// In case of errors #WebKitDownload::failed signal is emitted before this one.
    #[doc(alias = "finished")]
    pub fn connect_finished<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn finished_trampoline<F: Fn(&Download) + 'static>(
            this: *mut ffi::WebKitDownload,
            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"finished\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    finished_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// This signal is emitted after response is received,
    /// every time new data has been written to the destination. It's
    /// useful to know the progress of the download operation.
    /// ## `data_length`
    /// the length of data received in bytes
    #[doc(alias = "received-data")]
    pub fn connect_received_data<F: Fn(&Self, u64) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn received_data_trampoline<F: Fn(&Download, u64) + 'static>(
            this: *mut ffi::WebKitDownload,
            data_length: u64,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this), data_length)
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"received-data\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    received_data_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

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

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

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

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