1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

// 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::Hyperlink;
use glib::object::Cast;
use glib::object::IsA;
use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*;
use std::boxed::Box as Box_;
use std::fmt;
use std::mem::transmute;

glib::wrapper! {
    /// An interface used for objects which implement linking between
    /// multiple resource or content locations, or multiple 'markers'
    /// within a single document. A Hypertext instance is associated with
    /// one or more Hyperlinks, which are associated with particular
    /// offsets within the Hypertext's included content. While this
    /// interface is derived from Text, there is no requirement that
    /// Hypertext instances have textual content; they may implement Image
    /// as well, and Hyperlinks need not have non-zero text offsets.
    ///
    /// # Implements
    ///
    /// [`HypertextExt`][trait@crate::prelude::HypertextExt]
    #[doc(alias = "AtkHypertext")]
    pub struct Hypertext(Interface<ffi::AtkHypertext, ffi::AtkHypertextIface>);

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

pub const NONE_HYPERTEXT: Option<&Hypertext> = None;

/// Trait containing all [`struct@Hypertext`] methods.
///
/// # Implementors
///
/// [`Hypertext`][struct@crate::Hypertext], [`NoOpObject`][struct@crate::NoOpObject]
pub trait HypertextExt: 'static {
    /// Gets the link in this hypertext document at index
    /// `link_index`
    /// ## `link_index`
    /// an integer specifying the desired link
    ///
    /// # Returns
    ///
    /// the link in this hypertext document at
    /// index `link_index`
    #[doc(alias = "atk_hypertext_get_link")]
    #[doc(alias = "get_link")]
    fn link(&self, link_index: i32) -> Option<Hyperlink>;

    /// Gets the index into the array of hyperlinks that is associated with
    /// the character specified by `char_index`.
    /// ## `char_index`
    /// a character index
    ///
    /// # Returns
    ///
    /// an index into the array of hyperlinks in `self`,
    /// or -1 if there is no hyperlink associated with this character.
    #[doc(alias = "atk_hypertext_get_link_index")]
    #[doc(alias = "get_link_index")]
    fn link_index(&self, char_index: i32) -> i32;

    /// Gets the number of links within this hypertext document.
    ///
    /// # Returns
    ///
    /// the number of links within this hypertext document
    #[doc(alias = "atk_hypertext_get_n_links")]
    #[doc(alias = "get_n_links")]
    fn n_links(&self) -> i32;

    /// The "link-selected" signal is emitted by an AtkHyperText
    /// object when one of the hyperlinks associated with the object
    /// is selected.
    /// ## `arg1`
    /// the index of the hyperlink which is selected
    #[doc(alias = "link-selected")]
    fn connect_link_selected<F: Fn(&Self, i32) + 'static>(&self, f: F) -> SignalHandlerId;
}

impl<O: IsA<Hypertext>> HypertextExt for O {
    fn link(&self, link_index: i32) -> Option<Hyperlink> {
        unsafe {
            from_glib_none(ffi::atk_hypertext_get_link(
                self.as_ref().to_glib_none().0,
                link_index,
            ))
        }
    }

    fn link_index(&self, char_index: i32) -> i32 {
        unsafe { ffi::atk_hypertext_get_link_index(self.as_ref().to_glib_none().0, char_index) }
    }

    fn n_links(&self) -> i32 {
        unsafe { ffi::atk_hypertext_get_n_links(self.as_ref().to_glib_none().0) }
    }

    fn connect_link_selected<F: Fn(&Self, i32) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn link_selected_trampoline<
            P: IsA<Hypertext>,
            F: Fn(&P, i32) + 'static,
        >(
            this: *mut ffi::AtkHypertext,
            arg1: libc::c_int,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Hypertext::from_glib_borrow(this).unsafe_cast_ref(), arg1)
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"link-selected\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    link_selected_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

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