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
137
138
139

// 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 gio_sys;
use glib::object::IsA;
use glib::translate::*;
use glib::GString;
use std::fmt;
use std::ptr;
use MenuModel;

glib_wrapper! {
    /// `MenuLinkIter` is an opaque structure type. You must access it using
    /// the functions below.
    ///
    /// # Implements
    ///
    /// [`MenuLinkIterExt`](trait.MenuLinkIterExt.html), [`glib::object::ObjectExt`](../glib/object/trait.ObjectExt.html)
    pub struct MenuLinkIter(Object<gio_sys::GMenuLinkIter, gio_sys::GMenuLinkIterClass, MenuLinkIterClass>);

    match fn {
        get_type => || gio_sys::g_menu_link_iter_get_type(),
    }
}

pub const NONE_MENU_LINK_ITER: Option<&MenuLinkIter> = None;

/// Trait containing all `MenuLinkIter` methods.
///
/// # Implementors
///
/// [`MenuLinkIter`](struct.MenuLinkIter.html)
pub trait MenuLinkIterExt: 'static {
    /// Gets the name of the link at the current iterator position.
    ///
    /// The iterator is not advanced.
    ///
    /// # Returns
    ///
    /// the type of the link
    fn get_name(&self) -> Option<GString>;

    /// This function combines `MenuLinkIterExt::next` with
    /// `MenuLinkIterExt::get_name` and `MenuLinkIterExt::get_value`.
    ///
    /// First the iterator is advanced to the next (possibly first) link.
    /// If that fails, then `false` is returned and there are no other effects.
    ///
    /// If successful, `out_link` and `value` are set to the name and `MenuModel`
    /// of the link that has just been advanced to. At this point,
    /// `MenuLinkIterExt::get_name` and `MenuLinkIterExt::get_value` will return the
    /// same values again.
    ///
    /// The value returned in `out_link` remains valid for as long as the iterator
    /// remains at the current position. The value returned in `value` must
    /// be unreffed using `gobject::ObjectExt::unref` when it is no longer in use.
    /// ## `out_link`
    /// the name of the link
    /// ## `value`
    /// the linked `MenuModel`
    ///
    /// # Returns
    ///
    /// `true` on success, or `false` if there is no additional link
    fn get_next(&self) -> Option<(GString, MenuModel)>;

    /// Gets the linked `MenuModel` at the current iterator position.
    ///
    /// The iterator is not advanced.
    ///
    /// # Returns
    ///
    /// the `MenuModel` that is linked to
    fn get_value(&self) -> Option<MenuModel>;

    /// Attempts to advance the iterator to the next (possibly first)
    /// link.
    ///
    /// `true` is returned on success, or `false` if there are no more links.
    ///
    /// You must call this function when you first acquire the iterator to
    /// advance it to the first link (and determine if the first link exists
    /// at all).
    ///
    /// # Returns
    ///
    /// `true` on success, or `false` when there are no more links
    fn next(&self) -> bool;
}

impl<O: IsA<MenuLinkIter>> MenuLinkIterExt for O {
    fn get_name(&self) -> Option<GString> {
        unsafe {
            from_glib_none(gio_sys::g_menu_link_iter_get_name(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn get_next(&self) -> Option<(GString, MenuModel)> {
        unsafe {
            let mut out_link = ptr::null();
            let mut value = ptr::null_mut();
            let ret = from_glib(gio_sys::g_menu_link_iter_get_next(
                self.as_ref().to_glib_none().0,
                &mut out_link,
                &mut value,
            ));
            if ret {
                Some((from_glib_none(out_link), from_glib_full(value)))
            } else {
                None
            }
        }
    }

    fn get_value(&self) -> Option<MenuModel> {
        unsafe {
            from_glib_full(gio_sys::g_menu_link_iter_get_value(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn next(&self) -> bool {
        unsafe {
            from_glib(gio_sys::g_menu_link_iter_next(
                self.as_ref().to_glib_none().0,
            ))
        }
    }
}

impl fmt::Display for MenuLinkIter {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "MenuLinkIter")
    }
}