atk/auto/

document.rs

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

use glib::{
    prelude::*,
    signal::{connect_raw, SignalHandlerId},
    translate::*,
};
use std::{boxed::Box as Box_, fmt, mem::transmute};

glib::wrapper! {
    /// The ATK interface which represents the toplevel
    ///  container for document content.
    ///
    /// The AtkDocument interface should be supported by any object whose
    /// content is a representation or view of a document. The AtkDocument
    /// interface should appear on the toplevel container for the document
    /// content; however AtkDocument instances may be nested (i.e. an
    /// AtkDocument may be a descendant of another AtkDocument) in those
    /// cases where one document contains "embedded content" which can
    /// reasonably be considered a document in its own right.
    ///
    /// ## Signals
    ///
    ///
    /// #### `load-complete`
    ///  The 'load-complete' signal is emitted when a pending load of
    /// a static document has completed. This signal is to be
    /// expected by ATK clients if and when AtkDocument implementors
    /// expose ATK_STATE_BUSY. If the state of an AtkObject which
    /// implements AtkDocument does not include ATK_STATE_BUSY, it
    /// should be safe for clients to assume that the AtkDocument's
    /// static contents are fully loaded into the container.
    /// (Dynamic document contents should be exposed via other
    /// signals.)
    ///
    ///
    ///
    ///
    /// #### `load-stopped`
    ///  The 'load-stopped' signal is emitted when a pending load of
    /// document contents is cancelled, paused, or otherwise
    /// interrupted by the user or application logic. It should not
    /// however be emitted while waiting for a resource (for instance
    /// while blocking on a file or network read) unless a
    /// user-significant timeout has occurred.
    ///
    ///
    ///
    ///
    /// #### `page-changed`
    ///  The 'page-changed' signal is emitted when the current page of
    /// a document changes, e.g. pressing page up/down in a document
    /// viewer.
    ///
    ///
    ///
    ///
    /// #### `reload`
    ///  The 'reload' signal is emitted when the contents of a
    /// document is refreshed from its source. Once 'reload' has
    /// been emitted, a matching 'load-complete' or 'load-stopped'
    /// signal should follow, which clients may await before
    /// interrogating ATK for the latest document content.
    ///
    ///
    ///
    /// # Implements
    ///
    /// [`DocumentExt`][trait@crate::prelude::DocumentExt]
    #[doc(alias = "AtkDocument")]
    pub struct Document(Interface<ffi::AtkDocument, ffi::AtkDocumentIface>);

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

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

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

/// Trait containing all [`struct@Document`] methods.
///
/// # Implementors
///
/// [`Document`][struct@crate::Document], [`NoOpObject`][struct@crate::NoOpObject]
pub trait DocumentExt: IsA<Document> + sealed::Sealed + 'static {
    /// Retrieves the value of the given `attribute_name` inside `self`.
    /// ## `attribute_name`
    /// a character string representing the name of the attribute
    ///  whose value is being queried.
    ///
    /// # Returns
    ///
    /// a string value associated with the named
    ///  attribute for this document, or [`None`] if a value for
    ///  `attribute_name` has not been specified for this document.
    #[doc(alias = "atk_document_get_attribute_value")]
    #[doc(alias = "get_attribute_value")]
    fn attribute_value(&self, attribute_name: &str) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::atk_document_get_attribute_value(
                self.as_ref().to_glib_none().0,
                attribute_name.to_glib_none().0,
            ))
        }
    }

    /// Retrieves the current page number inside `self`.
    ///
    /// # Returns
    ///
    /// the current page number inside `self`, or -1 if
    ///  not implemented, not know by the implementor, or irrelevant.
    #[doc(alias = "atk_document_get_current_page_number")]
    #[doc(alias = "get_current_page_number")]
    fn current_page_number(&self) -> i32 {
        unsafe { ffi::atk_document_get_current_page_number(self.as_ref().to_glib_none().0) }
    }

    //#[doc(alias = "atk_document_get_document")]
    //#[doc(alias = "get_document")]
    //fn document(&self) -> /*Unimplemented*/Option<Basic: Pointer> {
    //    unsafe { TODO: call ffi:atk_document_get_document() }
    //}

    /// Gets a string indicating the document type.
    ///
    /// # Deprecated
    ///
    /// Since 2.12. Please use `atk_document_get_attributes()` to
    /// ask for the document type if it applies.
    ///
    /// # Returns
    ///
    /// a string indicating the document type
    #[doc(alias = "atk_document_get_document_type")]
    #[doc(alias = "get_document_type")]
    fn document_type(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::atk_document_get_document_type(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Retrieves the total number of pages inside `self`.
    ///
    /// # Returns
    ///
    /// total page count of `self`, or -1 if not implemented,
    ///  not know by the implementor or irrelevant.
    #[doc(alias = "atk_document_get_page_count")]
    #[doc(alias = "get_page_count")]
    fn page_count(&self) -> i32 {
        unsafe { ffi::atk_document_get_page_count(self.as_ref().to_glib_none().0) }
    }

    /// Sets the value for the given `attribute_name` inside `self`.
    /// ## `attribute_name`
    /// a character string representing the name of the attribute
    ///  whose value is being set.
    /// ## `attribute_value`
    /// a string value to be associated with `attribute_name`.
    ///
    /// # Returns
    ///
    /// [`true`] if `attribute_value` is successfully associated
    ///  with `attribute_name` for this `self`, and [`false`] if if the
    ///  document does not allow the attribute to be modified
    #[doc(alias = "atk_document_set_attribute_value")]
    fn set_attribute_value(&self, attribute_name: &str, attribute_value: &str) -> bool {
        unsafe {
            from_glib(ffi::atk_document_set_attribute_value(
                self.as_ref().to_glib_none().0,
                attribute_name.to_glib_none().0,
                attribute_value.to_glib_none().0,
            ))
        }
    }

    /// The 'load-complete' signal is emitted when a pending load of
    /// a static document has completed. This signal is to be
    /// expected by ATK clients if and when AtkDocument implementors
    /// expose ATK_STATE_BUSY. If the state of an AtkObject which
    /// implements AtkDocument does not include ATK_STATE_BUSY, it
    /// should be safe for clients to assume that the AtkDocument's
    /// static contents are fully loaded into the container.
    /// (Dynamic document contents should be exposed via other
    /// signals.)
    #[doc(alias = "load-complete")]
    fn connect_load_complete<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn load_complete_trampoline<P: IsA<Document>, F: Fn(&P) + 'static>(
            this: *mut ffi::AtkDocument,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Document::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"load-complete\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    load_complete_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The 'load-stopped' signal is emitted when a pending load of
    /// document contents is cancelled, paused, or otherwise
    /// interrupted by the user or application logic. It should not
    /// however be emitted while waiting for a resource (for instance
    /// while blocking on a file or network read) unless a
    /// user-significant timeout has occurred.
    #[doc(alias = "load-stopped")]
    fn connect_load_stopped<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn load_stopped_trampoline<P: IsA<Document>, F: Fn(&P) + 'static>(
            this: *mut ffi::AtkDocument,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Document::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"load-stopped\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    load_stopped_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The 'page-changed' signal is emitted when the current page of
    /// a document changes, e.g. pressing page up/down in a document
    /// viewer.
    /// ## `page_number`
    /// the new page number. If this value is unknown
    /// or not applicable, -1 should be provided.
    #[doc(alias = "page-changed")]
    fn connect_page_changed<F: Fn(&Self, i32) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn page_changed_trampoline<P: IsA<Document>, F: Fn(&P, i32) + 'static>(
            this: *mut ffi::AtkDocument,
            page_number: libc::c_int,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                Document::from_glib_borrow(this).unsafe_cast_ref(),
                page_number,
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"page-changed\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    page_changed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The 'reload' signal is emitted when the contents of a
    /// document is refreshed from its source. Once 'reload' has
    /// been emitted, a matching 'load-complete' or 'load-stopped'
    /// signal should follow, which clients may await before
    /// interrogating ATK for the latest document content.
    #[doc(alias = "reload")]
    fn connect_reload<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn reload_trampoline<P: IsA<Document>, F: Fn(&P) + 'static>(
            this: *mut ffi::AtkDocument,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Document::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"reload\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    reload_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

impl<O: IsA<Document>> DocumentExt for O {}

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