atk/auto/

object.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 crate::{Layer, RelationSet, RelationType, Role, State, StateSet};
use glib::{
    prelude::*,
    signal::{connect_raw, SignalHandlerId},
    translate::*,
};
use std::{boxed::Box as Box_, fmt, mem::transmute};

glib::wrapper! {
    /// The base object class for the Accessibility Toolkit API.
    ///
    /// This class is the primary class for accessibility support via the
    /// Accessibility ToolKit (ATK). Objects which are instances of
    /// [`Object`][crate::Object] (or instances of AtkObject-derived types) are queried
    /// for properties which relate basic (and generic) properties of a UI
    /// component such as name and description. Instances of [`Object`][crate::Object]
    /// may also be queried as to whether they implement other ATK
    /// interfaces (e.g. [`Action`][crate::Action], [`Component`][crate::Component], etc.), as appropriate
    /// to the role which a given UI component plays in a user interface.
    ///
    /// All UI components in an application which provide useful
    /// information or services to the user must provide corresponding
    /// [`Object`][crate::Object] instances on request (in GTK+, for instance, usually on
    /// a call to `gtk_widget_get_accessible` ()), either via ATK support
    /// built into the toolkit for the widget class or ancestor class, or
    /// in the case of custom widgets, if the inherited [`Object`][crate::Object]
    /// implementation is insufficient, via instances of a new [`Object`][crate::Object]
    /// subclass.
    ///
    /// See [class[`ObjectFactory`][crate::ObjectFactory]], [class[`Registry`][crate::Registry]]. (GTK+ users see also
    /// `GtkAccessible`).
    ///
    /// ## Properties
    ///
    ///
    /// #### `accessible-component-layer`
    ///  Readable
    ///
    ///
    /// #### `accessible-component-mdi-zorder`
    ///  Readable
    ///
    ///
    /// #### `accessible-description`
    ///  Readable | Writeable
    ///
    ///
    /// #### `accessible-hypertext-nlinks`
    ///  Readable
    ///
    ///
    /// #### `accessible-name`
    ///  Readable | Writeable
    ///
    ///
    /// #### `accessible-parent`
    ///  Readable | Writeable
    ///
    ///
    /// #### `accessible-role`
    ///  Readable | Writeable
    ///
    ///
    /// #### `accessible-table-caption`
    ///  Table caption.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `accessible-table-caption-object`
    ///  Readable | Writeable
    ///
    ///
    /// #### `accessible-table-column-description`
    ///  Accessible table column description.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `accessible-table-column-header`
    ///  Accessible table column header.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `accessible-table-row-description`
    ///  Accessible table row description.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `accessible-table-row-header`
    ///  Accessible table row header.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `accessible-table-summary`
    ///  Readable | Writeable
    ///
    ///
    /// #### `accessible-value`
    ///  Numeric value of this object, in case being and AtkValue.
    ///
    /// Readable | Writeable
    ///
    /// ## Signals
    ///
    ///
    /// #### `active-descendant-changed`
    ///  The "active-descendant-changed" signal is emitted by an object
    /// which has the state ATK_STATE_MANAGES_DESCENDANTS when the focus
    /// object in the object changes. For instance, a table will emit the
    /// signal when the cell in the table which has focus changes.
    ///
    /// Detailed
    ///
    ///
    /// #### `announcement`
    ///  The "announcement" signal can be emitted to pass an announcement on to
    /// be read by a screen reader.
    ///
    /// Depcrecated (2.50): Use AtkObject::notification instead.
    ///
    ///
    ///
    ///
    /// #### `children-changed`
    ///  The signal "children-changed" is emitted when a child is added or
    /// removed form an object. It supports two details: "add" and
    /// "remove"
    ///
    /// Detailed
    ///
    ///
    /// #### `focus-event`
    ///  The signal "focus-event" is emitted when an object gained or lost
    /// focus.
    ///
    ///
    ///
    ///
    /// #### `notification`
    ///  The "notification" signal can be emitted to pass an announcement on to
    /// be read by a screen reader.
    ///
    ///
    ///
    ///
    /// #### `property-change`
    ///  The signal "property-change" is emitted when an object's property
    /// value changes. `arg1` contains an `AtkPropertyValues` with the name
    /// and the new value of the property whose value has changed. Note
    /// that, as with GObject notify, getting this signal does not
    /// guarantee that the value of the property has actually changed; it
    /// may also be emitted when the setter of the property is called to
    /// reinstate the previous value.
    ///
    /// Toolkit implementor note: ATK implementors should use
    /// [`ObjectExt::notify()`][crate::glib::prelude::ObjectExt::notify()] to emit property-changed
    /// notifications. [`property-changed`][struct@crate::Object#property-changed] is needed by the
    /// implementation of `atk_add_global_event_listener()` because GObject
    /// notify doesn't support emission hooks.
    ///
    /// Detailed
    ///
    ///
    /// #### `state-change`
    ///  The "state-change" signal is emitted when an object's state
    /// changes. The detail value identifies the state type which has
    /// changed.
    ///
    /// Detailed
    ///
    ///
    /// #### `visible-data-changed`
    ///  The "visible-data-changed" signal is emitted when the visual
    /// appearance of the object changed.
    ///
    ///
    ///
    /// # Implements
    ///
    /// [`AtkObjectExt`][trait@crate::prelude::AtkObjectExt], [`trait@glib::ObjectExt`]
    #[doc(alias = "AtkObject")]
    pub struct Object(Object<ffi::AtkObject, ffi::AtkObjectClass>);

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

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

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

/// Trait containing all [`struct@Object`] methods.
///
/// # Implementors
///
/// [`GObjectAccessible`][struct@crate::GObjectAccessible], [`NoOpObject`][struct@crate::NoOpObject], [`Object`][struct@crate::Object], [`Plug`][struct@crate::Plug], [`Socket`][struct@crate::Socket], [`TableCell`][struct@crate::TableCell], [`Window`][struct@crate::Window]
pub trait AtkObjectExt: IsA<Object> + sealed::Sealed + 'static {
    /// Adds a relationship of the specified type with the specified target.
    /// ## `relationship`
    /// The [`RelationType`][crate::RelationType] of the relation
    /// ## `target`
    /// The [`Object`][crate::Object] which is to be the target of the relation.
    ///
    /// # Returns
    ///
    /// TRUE if the relationship is added.
    #[doc(alias = "atk_object_add_relationship")]
    fn add_relationship(&self, relationship: RelationType, target: &impl IsA<Object>) -> bool {
        unsafe {
            from_glib(ffi::atk_object_add_relationship(
                self.as_ref().to_glib_none().0,
                relationship.into_glib(),
                target.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the accessible id of the accessible.
    ///
    /// # Returns
    ///
    /// a character string representing the accessible id of the object, or
    /// NULL if no such string was set.
    #[cfg(feature = "v2_34")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v2_34")))]
    #[doc(alias = "atk_object_get_accessible_id")]
    #[doc(alias = "get_accessible_id")]
    fn accessible_id(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::atk_object_get_accessible_id(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the accessible description of the accessible.
    ///
    /// # Returns
    ///
    /// a character string representing the accessible description
    /// of the accessible.
    #[doc(alias = "atk_object_get_description")]
    #[doc(alias = "get_description")]
    fn description(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::atk_object_get_description(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the 0-based index of this accessible in its parent; returns -1 if the
    /// accessible does not have an accessible parent.
    ///
    /// # Returns
    ///
    /// an integer which is the index of the accessible in its parent
    #[doc(alias = "atk_object_get_index_in_parent")]
    #[doc(alias = "get_index_in_parent")]
    fn index_in_parent(&self) -> i32 {
        unsafe { ffi::atk_object_get_index_in_parent(self.as_ref().to_glib_none().0) }
    }

    /// Gets the layer of the accessible.
    ///
    /// # Deprecated
    ///
    /// Use atk_component_get_layer instead.
    ///
    /// # Returns
    ///
    /// an [`Layer`][crate::Layer] which is the layer of the accessible
    #[doc(alias = "atk_object_get_layer")]
    #[doc(alias = "get_layer")]
    fn layer(&self) -> Layer {
        unsafe { from_glib(ffi::atk_object_get_layer(self.as_ref().to_glib_none().0)) }
    }

    /// Gets the zorder of the accessible. The value G_MININT will be returned
    /// if the layer of the accessible is not ATK_LAYER_MDI.
    ///
    /// # Deprecated
    ///
    /// Use atk_component_get_mdi_zorder instead.
    ///
    /// # Returns
    ///
    /// a gint which is the zorder of the accessible, i.e. the depth at
    /// which the component is shown in relation to other components in the same
    /// container.
    #[doc(alias = "atk_object_get_mdi_zorder")]
    #[doc(alias = "get_mdi_zorder")]
    fn mdi_zorder(&self) -> i32 {
        unsafe { ffi::atk_object_get_mdi_zorder(self.as_ref().to_glib_none().0) }
    }

    /// Gets the number of accessible children of the accessible.
    ///
    /// # Returns
    ///
    /// an integer representing the number of accessible children
    /// of the accessible.
    #[doc(alias = "atk_object_get_n_accessible_children")]
    #[doc(alias = "get_n_accessible_children")]
    fn n_accessible_children(&self) -> i32 {
        unsafe { ffi::atk_object_get_n_accessible_children(self.as_ref().to_glib_none().0) }
    }

    /// Gets the accessible name of the accessible.
    ///
    /// # Returns
    ///
    /// a character string representing the accessible name of the object.
    #[doc(alias = "atk_object_get_name")]
    #[doc(alias = "get_name")]
    fn name(&self) -> Option<glib::GString> {
        unsafe { from_glib_none(ffi::atk_object_get_name(self.as_ref().to_glib_none().0)) }
    }

    /// Gets a UTF-8 string indicating the POSIX-style LC_MESSAGES locale
    /// of `self`.
    ///
    /// # Returns
    ///
    /// a UTF-8 string indicating the POSIX-style LC_MESSAGES
    ///  locale of `self`.
    #[doc(alias = "atk_object_get_object_locale")]
    #[doc(alias = "get_object_locale")]
    fn object_locale(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::atk_object_get_object_locale(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the accessible parent of the accessible. By default this is
    /// the one assigned with [`set_parent()`][Self::set_parent()], but it is assumed
    /// that ATK implementors have ways to get the parent of the object
    /// without the need of assigning it manually with
    /// [`set_parent()`][Self::set_parent()], and will return it with this method.
    ///
    /// If you are only interested on the parent assigned with
    /// [`set_parent()`][Self::set_parent()], use [`peek_parent()`][Self::peek_parent()].
    ///
    /// # Returns
    ///
    /// an [`Object`][crate::Object] representing the accessible
    /// parent of the accessible
    #[doc(alias = "atk_object_get_parent")]
    #[doc(alias = "get_parent")]
    #[must_use]
    fn parent(&self) -> Option<Object> {
        unsafe { from_glib_none(ffi::atk_object_get_parent(self.as_ref().to_glib_none().0)) }
    }

    /// Gets the role of the accessible.
    ///
    /// # Returns
    ///
    /// an [`Role`][crate::Role] which is the role of the accessible
    #[doc(alias = "atk_object_get_role")]
    #[doc(alias = "get_role")]
    fn role(&self) -> Role {
        unsafe { from_glib(ffi::atk_object_get_role(self.as_ref().to_glib_none().0)) }
    }

    //#[doc(alias = "atk_object_initialize")]
    //fn initialize(&self, data: /*Unimplemented*/Option<Basic: Pointer>) {
    //    unsafe { TODO: call ffi:atk_object_initialize() }
    //}

    /// Emits a state-change signal for the specified state.
    ///
    /// Note that as a general rule when the state of an existing object changes,
    /// emitting a notification is expected.
    /// ## `state`
    /// an `AtkState` whose state is changed
    /// ## `value`
    /// a gboolean which indicates whether the state is being set on or off
    #[doc(alias = "atk_object_notify_state_change")]
    fn notify_state_change(&self, state: State, value: bool) {
        unsafe {
            ffi::atk_object_notify_state_change(
                self.as_ref().to_glib_none().0,
                state,
                value.into_glib(),
            );
        }
    }

    /// Gets the accessible parent of the accessible, if it has been
    /// manually assigned with atk_object_set_parent. Otherwise, this
    /// function returns [`None`].
    ///
    /// This method is intended as an utility for ATK implementors, and not
    /// to be exposed to accessible tools. See [`parent()`][Self::parent()] for
    /// further reference.
    ///
    /// # Returns
    ///
    /// an [`Object`][crate::Object] representing the accessible
    /// parent of the accessible if assigned
    #[doc(alias = "atk_object_peek_parent")]
    #[must_use]
    fn peek_parent(&self) -> Option<Object> {
        unsafe { from_glib_none(ffi::atk_object_peek_parent(self.as_ref().to_glib_none().0)) }
    }

    /// Gets a reference to the specified accessible child of the object.
    /// The accessible children are 0-based so the first accessible child is
    /// at index 0, the second at index 1 and so on.
    /// ## `i`
    /// a gint representing the position of the child, starting from 0
    ///
    /// # Returns
    ///
    /// an [`Object`][crate::Object] representing the specified
    /// accessible child of the accessible.
    #[doc(alias = "atk_object_ref_accessible_child")]
    #[must_use]
    fn ref_accessible_child(&self, i: i32) -> Option<Object> {
        unsafe {
            from_glib_full(ffi::atk_object_ref_accessible_child(
                self.as_ref().to_glib_none().0,
                i,
            ))
        }
    }

    /// Gets the [`RelationSet`][crate::RelationSet] associated with the object.
    ///
    /// # Returns
    ///
    /// an [`RelationSet`][crate::RelationSet] representing the relation set
    /// of the object.
    #[doc(alias = "atk_object_ref_relation_set")]
    fn ref_relation_set(&self) -> Option<RelationSet> {
        unsafe {
            from_glib_full(ffi::atk_object_ref_relation_set(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets a reference to the state set of the accessible; the caller must
    /// unreference it when it is no longer needed.
    ///
    /// # Returns
    ///
    /// a reference to an [`StateSet`][crate::StateSet] which is the state
    /// set of the accessible
    #[doc(alias = "atk_object_ref_state_set")]
    fn ref_state_set(&self) -> Option<StateSet> {
        unsafe {
            from_glib_full(ffi::atk_object_ref_state_set(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Removes a relationship of the specified type with the specified target.
    /// ## `relationship`
    /// The [`RelationType`][crate::RelationType] of the relation
    /// ## `target`
    /// The [`Object`][crate::Object] which is the target of the relation to be removed.
    ///
    /// # Returns
    ///
    /// TRUE if the relationship is removed.
    #[doc(alias = "atk_object_remove_relationship")]
    fn remove_relationship(&self, relationship: RelationType, target: &impl IsA<Object>) -> bool {
        unsafe {
            from_glib(ffi::atk_object_remove_relationship(
                self.as_ref().to_glib_none().0,
                relationship.into_glib(),
                target.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Sets the accessible ID of the accessible. This is not meant to be presented
    /// to the user, but to be an ID which is stable over application development.
    /// Typically, this is the gtkbuilder ID. Such an ID will be available for
    /// instance to identify a given well-known accessible object for tailored screen
    /// reading, or for automatic regression testing.
    /// ## `name`
    /// a character string to be set as the accessible id
    #[cfg(feature = "v2_34")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v2_34")))]
    #[doc(alias = "atk_object_set_accessible_id")]
    fn set_accessible_id(&self, name: &str) {
        unsafe {
            ffi::atk_object_set_accessible_id(
                self.as_ref().to_glib_none().0,
                name.to_glib_none().0,
            );
        }
    }

    /// Sets the accessible description of the accessible. You can't set
    /// the description to NULL. This is reserved for the initial value. In
    /// this aspect NULL is similar to ATK_ROLE_UNKNOWN. If you want to set
    /// the name to a empty value you can use "".
    /// ## `description`
    /// a character string to be set as the accessible description
    #[doc(alias = "atk_object_set_description")]
    fn set_description(&self, description: &str) {
        unsafe {
            ffi::atk_object_set_description(
                self.as_ref().to_glib_none().0,
                description.to_glib_none().0,
            );
        }
    }

    /// Sets the accessible name of the accessible. You can't set the name
    /// to NULL. This is reserved for the initial value. In this aspect
    /// NULL is similar to ATK_ROLE_UNKNOWN. If you want to set the name to
    /// a empty value you can use "".
    /// ## `name`
    /// a character string to be set as the accessible name
    #[doc(alias = "atk_object_set_name")]
    fn set_name(&self, name: &str) {
        unsafe {
            ffi::atk_object_set_name(self.as_ref().to_glib_none().0, name.to_glib_none().0);
        }
    }

    /// Sets the accessible parent of the accessible. `parent` can be NULL.
    /// ## `parent`
    /// an [`Object`][crate::Object] to be set as the accessible parent
    #[doc(alias = "atk_object_set_parent")]
    fn set_parent(&self, parent: &impl IsA<Object>) {
        unsafe {
            ffi::atk_object_set_parent(
                self.as_ref().to_glib_none().0,
                parent.as_ref().to_glib_none().0,
            );
        }
    }

    /// Sets the role of the accessible.
    /// ## `role`
    /// an [`Role`][crate::Role] to be set as the role
    #[doc(alias = "atk_object_set_role")]
    fn set_role(&self, role: Role) {
        unsafe {
            ffi::atk_object_set_role(self.as_ref().to_glib_none().0, role.into_glib());
        }
    }

    #[doc(alias = "accessible-component-layer")]
    fn accessible_component_layer(&self) -> i32 {
        ObjectExt::property(self.as_ref(), "accessible-component-layer")
    }

    #[doc(alias = "accessible-component-mdi-zorder")]
    fn accessible_component_mdi_zorder(&self) -> i32 {
        ObjectExt::property(self.as_ref(), "accessible-component-mdi-zorder")
    }

    #[doc(alias = "accessible-description")]
    fn accessible_description(&self) -> Option<glib::GString> {
        ObjectExt::property(self.as_ref(), "accessible-description")
    }

    #[doc(alias = "accessible-description")]
    fn set_accessible_description(&self, accessible_description: Option<&str>) {
        ObjectExt::set_property(
            self.as_ref(),
            "accessible-description",
            accessible_description,
        )
    }

    #[doc(alias = "accessible-hypertext-nlinks")]
    fn accessible_hypertext_nlinks(&self) -> i32 {
        ObjectExt::property(self.as_ref(), "accessible-hypertext-nlinks")
    }

    #[doc(alias = "accessible-name")]
    fn accessible_name(&self) -> Option<glib::GString> {
        ObjectExt::property(self.as_ref(), "accessible-name")
    }

    #[doc(alias = "accessible-name")]
    fn set_accessible_name(&self, accessible_name: Option<&str>) {
        ObjectExt::set_property(self.as_ref(), "accessible-name", accessible_name)
    }

    #[doc(alias = "accessible-parent")]
    fn accessible_parent(&self) -> Option<Object> {
        ObjectExt::property(self.as_ref(), "accessible-parent")
    }

    #[doc(alias = "accessible-parent")]
    fn set_accessible_parent<P: IsA<Object>>(&self, accessible_parent: Option<&P>) {
        ObjectExt::set_property(self.as_ref(), "accessible-parent", accessible_parent)
    }

    #[doc(alias = "accessible-role")]
    fn accessible_role(&self) -> Role {
        ObjectExt::property(self.as_ref(), "accessible-role")
    }

    #[doc(alias = "accessible-role")]
    fn set_accessible_role(&self, accessible_role: Role) {
        ObjectExt::set_property(self.as_ref(), "accessible-role", accessible_role)
    }

    /// Table caption.
    ///
    /// # Deprecated
    ///
    /// Since 1.3. Use table-caption-object instead.
    #[doc(alias = "accessible-table-caption")]
    fn accessible_table_caption(&self) -> Option<glib::GString> {
        ObjectExt::property(self.as_ref(), "accessible-table-caption")
    }

    /// Table caption.
    ///
    /// # Deprecated
    ///
    /// Since 1.3. Use table-caption-object instead.
    #[doc(alias = "accessible-table-caption")]
    fn set_accessible_table_caption(&self, accessible_table_caption: Option<&str>) {
        ObjectExt::set_property(
            self.as_ref(),
            "accessible-table-caption",
            accessible_table_caption,
        )
    }

    #[doc(alias = "accessible-table-caption-object")]
    fn accessible_table_caption_object(&self) -> Option<Object> {
        ObjectExt::property(self.as_ref(), "accessible-table-caption-object")
    }

    #[doc(alias = "accessible-table-caption-object")]
    fn set_accessible_table_caption_object<P: IsA<Object>>(
        &self,
        accessible_table_caption_object: Option<&P>,
    ) {
        ObjectExt::set_property(
            self.as_ref(),
            "accessible-table-caption-object",
            accessible_table_caption_object,
        )
    }

    /// Accessible table column description.
    ///
    /// # Deprecated
    ///
    /// Since 2.12. Use [`TableExt::column_description()`][crate::prelude::TableExt::column_description()]
    /// and [`TableExt::set_column_description()`][crate::prelude::TableExt::set_column_description()] instead.
    #[doc(alias = "accessible-table-column-description")]
    fn accessible_table_column_description(&self) -> Option<glib::GString> {
        ObjectExt::property(self.as_ref(), "accessible-table-column-description")
    }

    /// Accessible table column description.
    ///
    /// # Deprecated
    ///
    /// Since 2.12. Use [`TableExt::column_description()`][crate::prelude::TableExt::column_description()]
    /// and [`TableExt::set_column_description()`][crate::prelude::TableExt::set_column_description()] instead.
    #[doc(alias = "accessible-table-column-description")]
    fn set_accessible_table_column_description(
        &self,
        accessible_table_column_description: Option<&str>,
    ) {
        ObjectExt::set_property(
            self.as_ref(),
            "accessible-table-column-description",
            accessible_table_column_description,
        )
    }

    /// Accessible table column header.
    ///
    /// # Deprecated
    ///
    /// Since 2.12. Use [`TableExt::column_header()`][crate::prelude::TableExt::column_header()] and
    /// [`TableExt::set_column_header()`][crate::prelude::TableExt::set_column_header()] instead.
    #[doc(alias = "accessible-table-column-header")]
    fn accessible_table_column_header(&self) -> Option<Object> {
        ObjectExt::property(self.as_ref(), "accessible-table-column-header")
    }

    /// Accessible table column header.
    ///
    /// # Deprecated
    ///
    /// Since 2.12. Use [`TableExt::column_header()`][crate::prelude::TableExt::column_header()] and
    /// [`TableExt::set_column_header()`][crate::prelude::TableExt::set_column_header()] instead.
    #[doc(alias = "accessible-table-column-header")]
    fn set_accessible_table_column_header<P: IsA<Object>>(
        &self,
        accessible_table_column_header: Option<&P>,
    ) {
        ObjectExt::set_property(
            self.as_ref(),
            "accessible-table-column-header",
            accessible_table_column_header,
        )
    }

    /// Accessible table row description.
    ///
    /// # Deprecated
    ///
    /// Since 2.12. Use [`TableExt::row_description()`][crate::prelude::TableExt::row_description()] and
    /// [`TableExt::set_row_description()`][crate::prelude::TableExt::set_row_description()] instead.
    #[doc(alias = "accessible-table-row-description")]
    fn accessible_table_row_description(&self) -> Option<glib::GString> {
        ObjectExt::property(self.as_ref(), "accessible-table-row-description")
    }

    /// Accessible table row description.
    ///
    /// # Deprecated
    ///
    /// Since 2.12. Use [`TableExt::row_description()`][crate::prelude::TableExt::row_description()] and
    /// [`TableExt::set_row_description()`][crate::prelude::TableExt::set_row_description()] instead.
    #[doc(alias = "accessible-table-row-description")]
    fn set_accessible_table_row_description(&self, accessible_table_row_description: Option<&str>) {
        ObjectExt::set_property(
            self.as_ref(),
            "accessible-table-row-description",
            accessible_table_row_description,
        )
    }

    /// Accessible table row header.
    ///
    /// # Deprecated
    ///
    /// Since 2.12. Use [`TableExt::row_header()`][crate::prelude::TableExt::row_header()] and
    /// [`TableExt::set_row_header()`][crate::prelude::TableExt::set_row_header()] instead.
    #[doc(alias = "accessible-table-row-header")]
    fn accessible_table_row_header(&self) -> Option<Object> {
        ObjectExt::property(self.as_ref(), "accessible-table-row-header")
    }

    /// Accessible table row header.
    ///
    /// # Deprecated
    ///
    /// Since 2.12. Use [`TableExt::row_header()`][crate::prelude::TableExt::row_header()] and
    /// [`TableExt::set_row_header()`][crate::prelude::TableExt::set_row_header()] instead.
    #[doc(alias = "accessible-table-row-header")]
    fn set_accessible_table_row_header<P: IsA<Object>>(
        &self,
        accessible_table_row_header: Option<&P>,
    ) {
        ObjectExt::set_property(
            self.as_ref(),
            "accessible-table-row-header",
            accessible_table_row_header,
        )
    }

    #[doc(alias = "accessible-table-summary")]
    fn accessible_table_summary(&self) -> Option<Object> {
        ObjectExt::property(self.as_ref(), "accessible-table-summary")
    }

    #[doc(alias = "accessible-table-summary")]
    fn set_accessible_table_summary<P: IsA<Object>>(&self, accessible_table_summary: Option<&P>) {
        ObjectExt::set_property(
            self.as_ref(),
            "accessible-table-summary",
            accessible_table_summary,
        )
    }

    /// Numeric value of this object, in case being and AtkValue.
    ///
    /// # Deprecated
    ///
    /// Since 2.12. Use [`ValueExt::value_and_text()`][crate::prelude::ValueExt::value_and_text()] to get
    /// the value, and value-changed signal to be notified on their value
    /// changes.
    #[doc(alias = "accessible-value")]
    fn accessible_value(&self) -> f64 {
        ObjectExt::property(self.as_ref(), "accessible-value")
    }

    /// Numeric value of this object, in case being and AtkValue.
    ///
    /// # Deprecated
    ///
    /// Since 2.12. Use [`ValueExt::value_and_text()`][crate::prelude::ValueExt::value_and_text()] to get
    /// the value, and value-changed signal to be notified on their value
    /// changes.
    #[doc(alias = "accessible-value")]
    fn set_accessible_value(&self, accessible_value: f64) {
        ObjectExt::set_property(self.as_ref(), "accessible-value", accessible_value)
    }

    /// The "active-descendant-changed" signal is emitted by an object
    /// which has the state ATK_STATE_MANAGES_DESCENDANTS when the focus
    /// object in the object changes. For instance, a table will emit the
    /// signal when the cell in the table which has focus changes.
    /// ## `arg1`
    /// the newly focused object.
    #[doc(alias = "active-descendant-changed")]
    fn connect_active_descendant_changed<F: Fn(&Self, &Object) + 'static>(
        &self,
        detail: Option<&str>,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn active_descendant_changed_trampoline<
            P: IsA<Object>,
            F: Fn(&P, &Object) + 'static,
        >(
            this: *mut ffi::AtkObject,
            arg1: *mut ffi::AtkObject,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                Object::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(arg1),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            let detailed_signal_name =
                detail.map(|name| format!("active-descendant-changed::{name}\0"));
            let signal_name: &[u8] = detailed_signal_name
                .as_ref()
                .map_or(&b"active-descendant-changed\0"[..], |n| n.as_bytes());
            connect_raw(
                self.as_ptr() as *mut _,
                signal_name.as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    active_descendant_changed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The "announcement" signal can be emitted to pass an announcement on to
    /// be read by a screen reader.
    ///
    /// Depcrecated (2.50): Use AtkObject::notification instead.
    /// ## `arg1`
    /// the text to be announced.
    #[cfg(feature = "v2_46")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v2_46")))]
    #[doc(alias = "announcement")]
    fn connect_announcement<F: Fn(&Self, &str) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn announcement_trampoline<P: IsA<Object>, F: Fn(&P, &str) + 'static>(
            this: *mut ffi::AtkObject,
            arg1: *mut libc::c_char,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                Object::from_glib_borrow(this).unsafe_cast_ref(),
                &glib::GString::from_glib_borrow(arg1),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"announcement\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    announcement_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The signal "children-changed" is emitted when a child is added or
    /// removed form an object. It supports two details: "add" and
    /// "remove"
    /// ## `arg1`
    /// The index of the added or removed child. The value can be
    /// -1. This is used if the value is not known by the implementor
    /// when the child is added/removed or irrelevant.
    /// ## `arg2`
    /// A gpointer to the child AtkObject which was added or
    /// removed. If the child was removed, it is possible that it is not
    /// available for the implementor. In that case this pointer can be
    /// NULL.
    #[doc(alias = "children-changed")]
    fn connect_children_changed<F: Fn(&Self, u32, &Object) + 'static>(
        &self,
        detail: Option<&str>,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn children_changed_trampoline<
            P: IsA<Object>,
            F: Fn(&P, u32, &Object) + 'static,
        >(
            this: *mut ffi::AtkObject,
            arg1: libc::c_uint,
            arg2: *mut ffi::AtkObject,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                Object::from_glib_borrow(this).unsafe_cast_ref(),
                arg1,
                &from_glib_borrow(arg2),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            let detailed_signal_name = detail.map(|name| format!("children-changed::{name}\0"));
            let signal_name: &[u8] = detailed_signal_name
                .as_ref()
                .map_or(&b"children-changed\0"[..], |n| n.as_bytes());
            connect_raw(
                self.as_ptr() as *mut _,
                signal_name.as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    children_changed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The "notification" signal can be emitted to pass an announcement on to
    /// be read by a screen reader.
    /// ## `arg1`
    /// the text to be announced.
    /// ## `arg2`
    /// an [`Live`][crate::Live] specifying the politeness of the notification.
    /// Should be either ATK_LIVE_POLITE or ATK_LIVE_ASSERTIVE.
    #[cfg(feature = "v2_50")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v2_50")))]
    #[doc(alias = "notification")]
    fn connect_notification<F: Fn(&Self, &str, i32) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notification_trampoline<
            P: IsA<Object>,
            F: Fn(&P, &str, i32) + 'static,
        >(
            this: *mut ffi::AtkObject,
            arg1: *mut libc::c_char,
            arg2: libc::c_int,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                Object::from_glib_borrow(this).unsafe_cast_ref(),
                &glib::GString::from_glib_borrow(arg1),
                arg2,
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notification\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notification_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    //#[doc(alias = "property-change")]
    //fn connect_property_change<Unsupported or ignored types>(&self, detail: Option<&str>, f: F) -> SignalHandlerId {
    //    Ignored arg1: Atk.PropertyValues
    //}

    /// The "state-change" signal is emitted when an object's state
    /// changes. The detail value identifies the state type which has
    /// changed.
    /// ## `arg1`
    /// The name of the state which has changed
    /// ## `arg2`
    /// A boolean which indicates whether the state has been set or unset.
    #[doc(alias = "state-change")]
    fn connect_state_change<F: Fn(&Self, &str, bool) + 'static>(
        &self,
        detail: Option<&str>,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn state_change_trampoline<
            P: IsA<Object>,
            F: Fn(&P, &str, bool) + 'static,
        >(
            this: *mut ffi::AtkObject,
            arg1: *mut libc::c_char,
            arg2: glib::ffi::gboolean,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                Object::from_glib_borrow(this).unsafe_cast_ref(),
                &glib::GString::from_glib_borrow(arg1),
                from_glib(arg2),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            let detailed_signal_name = detail.map(|name| format!("state-change::{name}\0"));
            let signal_name: &[u8] = detailed_signal_name
                .as_ref()
                .map_or(&b"state-change\0"[..], |n| n.as_bytes());
            connect_raw(
                self.as_ptr() as *mut _,
                signal_name.as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    state_change_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The "visible-data-changed" signal is emitted when the visual
    /// appearance of the object changed.
    #[doc(alias = "visible-data-changed")]
    fn connect_visible_data_changed<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn visible_data_changed_trampoline<
            P: IsA<Object>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::AtkObject,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Object::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"visible-data-changed\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    visible_data_changed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "accessible-component-layer")]
    fn connect_accessible_component_layer_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_accessible_component_layer_trampoline<
            P: IsA<Object>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::AtkObject,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Object::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::accessible-component-layer\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_accessible_component_layer_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "accessible-component-mdi-zorder")]
    fn connect_accessible_component_mdi_zorder_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_accessible_component_mdi_zorder_trampoline<
            P: IsA<Object>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::AtkObject,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Object::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::accessible-component-mdi-zorder\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_accessible_component_mdi_zorder_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "accessible-description")]
    fn connect_accessible_description_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_accessible_description_trampoline<
            P: IsA<Object>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::AtkObject,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Object::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::accessible-description\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_accessible_description_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "accessible-hypertext-nlinks")]
    fn connect_accessible_hypertext_nlinks_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_accessible_hypertext_nlinks_trampoline<
            P: IsA<Object>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::AtkObject,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Object::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::accessible-hypertext-nlinks\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_accessible_hypertext_nlinks_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "accessible-name")]
    fn connect_accessible_name_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_accessible_name_trampoline<
            P: IsA<Object>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::AtkObject,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Object::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::accessible-name\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_accessible_name_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "accessible-parent")]
    fn connect_accessible_parent_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_accessible_parent_trampoline<
            P: IsA<Object>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::AtkObject,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Object::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::accessible-parent\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_accessible_parent_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "accessible-role")]
    fn connect_accessible_role_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_accessible_role_trampoline<
            P: IsA<Object>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::AtkObject,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Object::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::accessible-role\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_accessible_role_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "accessible-table-caption")]
    fn connect_accessible_table_caption_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_accessible_table_caption_trampoline<
            P: IsA<Object>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::AtkObject,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Object::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::accessible-table-caption\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_accessible_table_caption_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "accessible-table-caption-object")]
    fn connect_accessible_table_caption_object_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_accessible_table_caption_object_trampoline<
            P: IsA<Object>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::AtkObject,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Object::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::accessible-table-caption-object\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_accessible_table_caption_object_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "accessible-table-column-description")]
    fn connect_accessible_table_column_description_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_accessible_table_column_description_trampoline<
            P: IsA<Object>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::AtkObject,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Object::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::accessible-table-column-description\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_accessible_table_column_description_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "accessible-table-column-header")]
    fn connect_accessible_table_column_header_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_accessible_table_column_header_trampoline<
            P: IsA<Object>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::AtkObject,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Object::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::accessible-table-column-header\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_accessible_table_column_header_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "accessible-table-row-description")]
    fn connect_accessible_table_row_description_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_accessible_table_row_description_trampoline<
            P: IsA<Object>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::AtkObject,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Object::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::accessible-table-row-description\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_accessible_table_row_description_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "accessible-table-row-header")]
    fn connect_accessible_table_row_header_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_accessible_table_row_header_trampoline<
            P: IsA<Object>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::AtkObject,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Object::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::accessible-table-row-header\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_accessible_table_row_header_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "accessible-table-summary")]
    fn connect_accessible_table_summary_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_accessible_table_summary_trampoline<
            P: IsA<Object>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::AtkObject,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Object::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::accessible-table-summary\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_accessible_table_summary_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "accessible-value")]
    fn connect_accessible_value_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_accessible_value_trampoline<
            P: IsA<Object>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::AtkObject,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Object::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::accessible-value\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_accessible_value_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

impl<O: IsA<Object>> AtkObjectExt for O {}

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