atk/auto/

table.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::Object;
use glib::{
    prelude::*,
    signal::{connect_raw, SignalHandlerId},
    translate::*,
};
use std::{boxed::Box as Box_, fmt, mem::transmute};

glib::wrapper! {
    /// The ATK interface implemented for UI components which contain tabular or row/column information.
    ///
    /// [`Table`][crate::Table] should be implemented by components which present
    /// elements ordered via rows and columns. It may also be used to
    /// present tree-structured information if the nodes of the trees can
    /// be said to contain multiple "columns". Individual elements of an
    /// [`Table`][crate::Table] are typically referred to as "cells". Those cells should
    /// implement the interface [`TableCell`][crate::TableCell], but `Atk` doesn't require
    /// them to be direct children of the current [`Table`][crate::Table]. They can be
    /// grand-children, grand-grand-children etc. [`Table`][crate::Table] provides the
    /// API needed to get a individual cell based on the row and column
    /// numbers.
    ///
    /// Children of [`Table`][crate::Table] are frequently "lightweight" objects, that
    /// is, they may not have backing widgets in the host UI toolkit. They
    /// are therefore often transient.
    ///
    /// Since tables are often very complex, [`Table`][crate::Table] includes provision
    /// for offering simplified summary information, as well as row and
    /// column headers and captions. Headers and captions are `AtkObjects`
    /// which may implement other interfaces ([`Text`][crate::Text], [`Image`][crate::Image], etc.) as
    /// appropriate. [`Table`][crate::Table] summaries may themselves be (simplified)
    /// `AtkTables`, etc.
    ///
    /// Note for implementors: in the past, [`Table`][crate::Table] required that all the
    /// cells should be direct children of [`Table`][crate::Table], and provided some
    /// index based methods to request the cells. The practice showed that
    /// that forcing made [`Table`][crate::Table] implementation complex, and hard to
    /// expose other kind of children, like rows or captions. Right now,
    /// index-based methods are deprecated.
    ///
    /// ## Signals
    ///
    ///
    /// #### `column-deleted`
    ///  The "column-deleted" signal is emitted by an object which
    /// implements the AtkTable interface when a column is deleted.
    ///
    ///
    ///
    ///
    /// #### `column-inserted`
    ///  The "column-inserted" signal is emitted by an object which
    /// implements the AtkTable interface when a column is inserted.
    ///
    ///
    ///
    ///
    /// #### `column-reordered`
    ///  The "column-reordered" signal is emitted by an object which
    /// implements the AtkTable interface when the columns are
    /// reordered.
    ///
    ///
    ///
    ///
    /// #### `model-changed`
    ///  The "model-changed" signal is emitted by an object which
    /// implements the AtkTable interface when the model displayed by
    /// the table changes.
    ///
    ///
    ///
    ///
    /// #### `row-deleted`
    ///  The "row-deleted" signal is emitted by an object which
    /// implements the AtkTable interface when a row is deleted.
    ///
    ///
    ///
    ///
    /// #### `row-inserted`
    ///  The "row-inserted" signal is emitted by an object which
    /// implements the AtkTable interface when a row is inserted.
    ///
    ///
    ///
    ///
    /// #### `row-reordered`
    ///  The "row-reordered" signal is emitted by an object which
    /// implements the AtkTable interface when the rows are
    /// reordered.
    ///
    ///
    ///
    /// # Implements
    ///
    /// [`TableExt`][trait@crate::prelude::TableExt], [`TableExtManual`][trait@crate::prelude::TableExtManual]
    #[doc(alias = "AtkTable")]
    pub struct Table(Interface<ffi::AtkTable, ffi::AtkTableIface>);

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

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

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

/// Trait containing all [`struct@Table`] methods.
///
/// # Implementors
///
/// [`NoOpObject`][struct@crate::NoOpObject], [`Table`][struct@crate::Table]
pub trait TableExt: IsA<Table> + sealed::Sealed + 'static {
    /// Adds the specified `column` to the selection.
    /// ## `column`
    /// a `gint` representing a column in `self`
    ///
    /// # Returns
    ///
    /// a gboolean representing if the column was successfully added to
    /// the selection, or 0 if value does not implement this interface.
    #[doc(alias = "atk_table_add_column_selection")]
    fn add_column_selection(&self, column: i32) -> bool {
        unsafe {
            from_glib(ffi::atk_table_add_column_selection(
                self.as_ref().to_glib_none().0,
                column,
            ))
        }
    }

    /// Adds the specified `row` to the selection.
    /// ## `row`
    /// a `gint` representing a row in `self`
    ///
    /// # Returns
    ///
    /// a gboolean representing if row was successfully added to selection,
    /// or 0 if value does not implement this interface.
    #[doc(alias = "atk_table_add_row_selection")]
    fn add_row_selection(&self, row: i32) -> bool {
        unsafe {
            from_glib(ffi::atk_table_add_row_selection(
                self.as_ref().to_glib_none().0,
                row,
            ))
        }
    }

    /// Gets the caption for the `self`.
    ///
    /// # Returns
    ///
    /// a AtkObject* representing the
    /// table caption, or [`None`] if value does not implement this interface.
    #[doc(alias = "atk_table_get_caption")]
    #[doc(alias = "get_caption")]
    fn caption(&self) -> Option<Object> {
        unsafe { from_glib_none(ffi::atk_table_get_caption(self.as_ref().to_glib_none().0)) }
    }

    /// Gets a `gint` representing the column at the specified `index_`.
    ///
    /// # Deprecated
    ///
    /// Since 2.12.
    /// ## `index_`
    /// a `gint` representing an index in `self`
    ///
    /// # Returns
    ///
    /// a gint representing the column at the specified index,
    /// or -1 if the table does not implement this method.
    #[doc(alias = "atk_table_get_column_at_index")]
    #[doc(alias = "get_column_at_index")]
    fn column_at_index(&self, index_: i32) -> i32 {
        unsafe { ffi::atk_table_get_column_at_index(self.as_ref().to_glib_none().0, index_) }
    }

    /// Gets the description text of the specified `column` in the table
    /// ## `column`
    /// a `gint` representing a column in `self`
    ///
    /// # Returns
    ///
    /// a gchar* representing the column description, or [`None`]
    /// if value does not implement this interface.
    #[doc(alias = "atk_table_get_column_description")]
    #[doc(alias = "get_column_description")]
    fn column_description(&self, column: i32) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::atk_table_get_column_description(
                self.as_ref().to_glib_none().0,
                column,
            ))
        }
    }

    /// Gets the number of columns occupied by the accessible object
    /// at the specified `row` and `column` in the `self`.
    /// ## `row`
    /// a `gint` representing a row in `self`
    /// ## `column`
    /// a `gint` representing a column in `self`
    ///
    /// # Returns
    ///
    /// a gint representing the column extent at specified position, or 0
    /// if value does not implement this interface.
    #[doc(alias = "atk_table_get_column_extent_at")]
    #[doc(alias = "get_column_extent_at")]
    fn column_extent_at(&self, row: i32, column: i32) -> i32 {
        unsafe { ffi::atk_table_get_column_extent_at(self.as_ref().to_glib_none().0, row, column) }
    }

    /// Gets the column header of a specified column in an accessible table.
    /// ## `column`
    /// a `gint` representing a column in the table
    ///
    /// # Returns
    ///
    /// a AtkObject* representing the
    /// specified column header, or [`None`] if value does not implement this
    /// interface.
    #[doc(alias = "atk_table_get_column_header")]
    #[doc(alias = "get_column_header")]
    fn column_header(&self, column: i32) -> Option<Object> {
        unsafe {
            from_glib_none(ffi::atk_table_get_column_header(
                self.as_ref().to_glib_none().0,
                column,
            ))
        }
    }

    /// Gets a `gint` representing the index at the specified `row` and
    /// `column`.
    ///
    /// # Deprecated
    ///
    /// Since 2.12. Use [`ref_at()`][Self::ref_at()] in order to get the
    /// accessible that represents the cell at (`row`, `column`)
    /// ## `row`
    /// a `gint` representing a row in `self`
    /// ## `column`
    /// a `gint` representing a column in `self`
    ///
    /// # Returns
    ///
    /// a `gint` representing the index at specified position.
    /// The value -1 is returned if the object at row,column is not a child
    /// of table or table does not implement this interface.
    #[doc(alias = "atk_table_get_index_at")]
    #[doc(alias = "get_index_at")]
    fn index_at(&self, row: i32, column: i32) -> i32 {
        unsafe { ffi::atk_table_get_index_at(self.as_ref().to_glib_none().0, row, column) }
    }

    /// Gets the number of columns in the table.
    ///
    /// # Returns
    ///
    /// a gint representing the number of columns, or 0
    /// if value does not implement this interface.
    #[doc(alias = "atk_table_get_n_columns")]
    #[doc(alias = "get_n_columns")]
    fn n_columns(&self) -> i32 {
        unsafe { ffi::atk_table_get_n_columns(self.as_ref().to_glib_none().0) }
    }

    /// Gets the number of rows in the table.
    ///
    /// # Returns
    ///
    /// a gint representing the number of rows, or 0
    /// if value does not implement this interface.
    #[doc(alias = "atk_table_get_n_rows")]
    #[doc(alias = "get_n_rows")]
    fn n_rows(&self) -> i32 {
        unsafe { ffi::atk_table_get_n_rows(self.as_ref().to_glib_none().0) }
    }

    /// Gets a `gint` representing the row at the specified `index_`.
    ///
    /// # Deprecated
    ///
    /// since 2.12.
    /// ## `index_`
    /// a `gint` representing an index in `self`
    ///
    /// # Returns
    ///
    /// a gint representing the row at the specified index,
    /// or -1 if the table does not implement this method.
    #[doc(alias = "atk_table_get_row_at_index")]
    #[doc(alias = "get_row_at_index")]
    fn row_at_index(&self, index_: i32) -> i32 {
        unsafe { ffi::atk_table_get_row_at_index(self.as_ref().to_glib_none().0, index_) }
    }

    /// Gets the description text of the specified row in the table
    /// ## `row`
    /// a `gint` representing a row in `self`
    ///
    /// # Returns
    ///
    /// a gchar* representing the row description, or
    /// [`None`] if value does not implement this interface.
    #[doc(alias = "atk_table_get_row_description")]
    #[doc(alias = "get_row_description")]
    fn row_description(&self, row: i32) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::atk_table_get_row_description(
                self.as_ref().to_glib_none().0,
                row,
            ))
        }
    }

    /// Gets the number of rows occupied by the accessible object
    /// at a specified `row` and `column` in the `self`.
    /// ## `row`
    /// a `gint` representing a row in `self`
    /// ## `column`
    /// a `gint` representing a column in `self`
    ///
    /// # Returns
    ///
    /// a gint representing the row extent at specified position, or 0
    /// if value does not implement this interface.
    #[doc(alias = "atk_table_get_row_extent_at")]
    #[doc(alias = "get_row_extent_at")]
    fn row_extent_at(&self, row: i32, column: i32) -> i32 {
        unsafe { ffi::atk_table_get_row_extent_at(self.as_ref().to_glib_none().0, row, column) }
    }

    /// Gets the row header of a specified row in an accessible table.
    /// ## `row`
    /// a `gint` representing a row in the table
    ///
    /// # Returns
    ///
    /// a AtkObject* representing the
    /// specified row header, or [`None`] if value does not implement this
    /// interface.
    #[doc(alias = "atk_table_get_row_header")]
    #[doc(alias = "get_row_header")]
    fn row_header(&self, row: i32) -> Option<Object> {
        unsafe {
            from_glib_none(ffi::atk_table_get_row_header(
                self.as_ref().to_glib_none().0,
                row,
            ))
        }
    }

    /// Gets the summary description of the table.
    ///
    /// # Returns
    ///
    /// a AtkObject* representing a summary description
    /// of the table, or zero if value does not implement this interface.
    #[doc(alias = "atk_table_get_summary")]
    #[doc(alias = "get_summary")]
    fn summary(&self) -> Option<Object> {
        unsafe { from_glib_full(ffi::atk_table_get_summary(self.as_ref().to_glib_none().0)) }
    }

    /// Gets a boolean value indicating whether the specified `column`
    /// is selected
    /// ## `column`
    /// a `gint` representing a column in `self`
    ///
    /// # Returns
    ///
    /// a gboolean representing if the column is selected, or 0
    /// if value does not implement this interface.
    #[doc(alias = "atk_table_is_column_selected")]
    fn is_column_selected(&self, column: i32) -> bool {
        unsafe {
            from_glib(ffi::atk_table_is_column_selected(
                self.as_ref().to_glib_none().0,
                column,
            ))
        }
    }

    /// Gets a boolean value indicating whether the specified `row`
    /// is selected
    /// ## `row`
    /// a `gint` representing a row in `self`
    ///
    /// # Returns
    ///
    /// a gboolean representing if the row is selected, or 0
    /// if value does not implement this interface.
    #[doc(alias = "atk_table_is_row_selected")]
    fn is_row_selected(&self, row: i32) -> bool {
        unsafe {
            from_glib(ffi::atk_table_is_row_selected(
                self.as_ref().to_glib_none().0,
                row,
            ))
        }
    }

    /// Gets a boolean value indicating whether the accessible object
    /// at the specified `row` and `column` is selected
    /// ## `row`
    /// a `gint` representing a row in `self`
    /// ## `column`
    /// a `gint` representing a column in `self`
    ///
    /// # Returns
    ///
    /// a gboolean representing if the cell is selected, or 0
    /// if value does not implement this interface.
    #[doc(alias = "atk_table_is_selected")]
    fn is_selected(&self, row: i32, column: i32) -> bool {
        unsafe {
            from_glib(ffi::atk_table_is_selected(
                self.as_ref().to_glib_none().0,
                row,
                column,
            ))
        }
    }

    /// Get a reference to the table cell at `row`, `column`. This cell
    /// should implement the interface [`TableCell`][crate::TableCell]
    /// ## `row`
    /// a `gint` representing a row in `self`
    /// ## `column`
    /// a `gint` representing a column in `self`
    ///
    /// # Returns
    ///
    /// an [`Object`][crate::Object] representing the referred
    /// to accessible
    #[doc(alias = "atk_table_ref_at")]
    fn ref_at(&self, row: i32, column: i32) -> Option<Object> {
        unsafe {
            from_glib_full(ffi::atk_table_ref_at(
                self.as_ref().to_glib_none().0,
                row,
                column,
            ))
        }
    }

    /// Adds the specified `column` to the selection.
    /// ## `column`
    /// a `gint` representing a column in `self`
    ///
    /// # Returns
    ///
    /// a gboolean representing if the column was successfully removed from
    /// the selection, or 0 if value does not implement this interface.
    #[doc(alias = "atk_table_remove_column_selection")]
    fn remove_column_selection(&self, column: i32) -> bool {
        unsafe {
            from_glib(ffi::atk_table_remove_column_selection(
                self.as_ref().to_glib_none().0,
                column,
            ))
        }
    }

    /// Removes the specified `row` from the selection.
    /// ## `row`
    /// a `gint` representing a row in `self`
    ///
    /// # Returns
    ///
    /// a gboolean representing if the row was successfully removed from
    /// the selection, or 0 if value does not implement this interface.
    #[doc(alias = "atk_table_remove_row_selection")]
    fn remove_row_selection(&self, row: i32) -> bool {
        unsafe {
            from_glib(ffi::atk_table_remove_row_selection(
                self.as_ref().to_glib_none().0,
                row,
            ))
        }
    }

    /// Sets the caption for the table.
    /// ## `caption`
    /// a [`Object`][crate::Object] representing the caption to set for `self`
    #[doc(alias = "atk_table_set_caption")]
    fn set_caption(&self, caption: &impl IsA<Object>) {
        unsafe {
            ffi::atk_table_set_caption(
                self.as_ref().to_glib_none().0,
                caption.as_ref().to_glib_none().0,
            );
        }
    }

    /// Sets the description text for the specified `column` of the `self`.
    /// ## `column`
    /// a `gint` representing a column in `self`
    /// ## `description`
    /// a `gchar` representing the description text
    /// to set for the specified `column` of the `self`
    #[doc(alias = "atk_table_set_column_description")]
    fn set_column_description(&self, column: i32, description: &str) {
        unsafe {
            ffi::atk_table_set_column_description(
                self.as_ref().to_glib_none().0,
                column,
                description.to_glib_none().0,
            );
        }
    }

    /// Sets the specified column header to `header`.
    /// ## `column`
    /// a `gint` representing a column in `self`
    /// ## `header`
    /// an [`Table`][crate::Table]
    #[doc(alias = "atk_table_set_column_header")]
    fn set_column_header(&self, column: i32, header: &impl IsA<Object>) {
        unsafe {
            ffi::atk_table_set_column_header(
                self.as_ref().to_glib_none().0,
                column,
                header.as_ref().to_glib_none().0,
            );
        }
    }

    /// Sets the description text for the specified `row` of `self`.
    /// ## `row`
    /// a `gint` representing a row in `self`
    /// ## `description`
    /// a `gchar` representing the description text
    /// to set for the specified `row` of `self`
    #[doc(alias = "atk_table_set_row_description")]
    fn set_row_description(&self, row: i32, description: &str) {
        unsafe {
            ffi::atk_table_set_row_description(
                self.as_ref().to_glib_none().0,
                row,
                description.to_glib_none().0,
            );
        }
    }

    /// Sets the specified row header to `header`.
    /// ## `row`
    /// a `gint` representing a row in `self`
    /// ## `header`
    /// an [`Table`][crate::Table]
    #[doc(alias = "atk_table_set_row_header")]
    fn set_row_header(&self, row: i32, header: &impl IsA<Object>) {
        unsafe {
            ffi::atk_table_set_row_header(
                self.as_ref().to_glib_none().0,
                row,
                header.as_ref().to_glib_none().0,
            );
        }
    }

    /// Sets the summary description of the table.
    /// ## `accessible`
    /// an [`Object`][crate::Object] representing the summary description
    /// to set for `self`
    #[doc(alias = "atk_table_set_summary")]
    fn set_summary(&self, accessible: &impl IsA<Object>) {
        unsafe {
            ffi::atk_table_set_summary(
                self.as_ref().to_glib_none().0,
                accessible.as_ref().to_glib_none().0,
            );
        }
    }

    /// The "column-deleted" signal is emitted by an object which
    /// implements the AtkTable interface when a column is deleted.
    /// ## `arg1`
    /// The index of the first column deleted.
    /// ## `arg2`
    /// The number of columns deleted.
    #[doc(alias = "column-deleted")]
    fn connect_column_deleted<F: Fn(&Self, i32, i32) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn column_deleted_trampoline<
            P: IsA<Table>,
            F: Fn(&P, i32, i32) + 'static,
        >(
            this: *mut ffi::AtkTable,
            arg1: libc::c_int,
            arg2: libc::c_int,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Table::from_glib_borrow(this).unsafe_cast_ref(), arg1, arg2)
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"column-deleted\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    column_deleted_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The "column-inserted" signal is emitted by an object which
    /// implements the AtkTable interface when a column is inserted.
    /// ## `arg1`
    /// The index of the column inserted.
    /// ## `arg2`
    /// The number of colums inserted.
    #[doc(alias = "column-inserted")]
    fn connect_column_inserted<F: Fn(&Self, i32, i32) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn column_inserted_trampoline<
            P: IsA<Table>,
            F: Fn(&P, i32, i32) + 'static,
        >(
            this: *mut ffi::AtkTable,
            arg1: libc::c_int,
            arg2: libc::c_int,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Table::from_glib_borrow(this).unsafe_cast_ref(), arg1, arg2)
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"column-inserted\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    column_inserted_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The "column-reordered" signal is emitted by an object which
    /// implements the AtkTable interface when the columns are
    /// reordered.
    #[doc(alias = "column-reordered")]
    fn connect_column_reordered<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn column_reordered_trampoline<P: IsA<Table>, F: Fn(&P) + 'static>(
            this: *mut ffi::AtkTable,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Table::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"column-reordered\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    column_reordered_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The "model-changed" signal is emitted by an object which
    /// implements the AtkTable interface when the model displayed by
    /// the table changes.
    #[doc(alias = "model-changed")]
    fn connect_model_changed<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn model_changed_trampoline<P: IsA<Table>, F: Fn(&P) + 'static>(
            this: *mut ffi::AtkTable,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Table::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"model-changed\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    model_changed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The "row-deleted" signal is emitted by an object which
    /// implements the AtkTable interface when a row is deleted.
    /// ## `arg1`
    /// The index of the first row deleted.
    /// ## `arg2`
    /// The number of rows deleted.
    #[doc(alias = "row-deleted")]
    fn connect_row_deleted<F: Fn(&Self, i32, i32) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn row_deleted_trampoline<
            P: IsA<Table>,
            F: Fn(&P, i32, i32) + 'static,
        >(
            this: *mut ffi::AtkTable,
            arg1: libc::c_int,
            arg2: libc::c_int,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Table::from_glib_borrow(this).unsafe_cast_ref(), arg1, arg2)
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"row-deleted\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    row_deleted_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The "row-inserted" signal is emitted by an object which
    /// implements the AtkTable interface when a row is inserted.
    /// ## `arg1`
    /// The index of the first row inserted.
    /// ## `arg2`
    /// The number of rows inserted.
    #[doc(alias = "row-inserted")]
    fn connect_row_inserted<F: Fn(&Self, i32, i32) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn row_inserted_trampoline<
            P: IsA<Table>,
            F: Fn(&P, i32, i32) + 'static,
        >(
            this: *mut ffi::AtkTable,
            arg1: libc::c_int,
            arg2: libc::c_int,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Table::from_glib_borrow(this).unsafe_cast_ref(), arg1, arg2)
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"row-inserted\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    row_inserted_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The "row-reordered" signal is emitted by an object which
    /// implements the AtkTable interface when the rows are
    /// reordered.
    #[doc(alias = "row-reordered")]
    fn connect_row_reordered<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn row_reordered_trampoline<P: IsA<Table>, F: Fn(&P) + 'static>(
            this: *mut ffi::AtkTable,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Table::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"row-reordered\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    row_reordered_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

impl<O: IsA<Table>> TableExt for O {}

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