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
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173

use crate::{Actor, ActorMeta, Constraint, Path};
use glib::{
    object as gobject,
    object::{Cast, IsA, ObjectType as ObjectType_},
    signal::{connect_raw, SignalHandlerId},
    translate::*,
};
use std::boxed::Box as Box_;
use std::{fmt, mem::transmute};

glib_wrapper! {
    pub struct PathConstraint(Object<ffi::ClutterPathConstraint, ffi::ClutterPathConstraintClass, PathConstraintClass>) @extends Constraint, ActorMeta, gobject::InitiallyUnowned;

    match fn {
        get_type => || ffi::clutter_path_constraint_get_type(),
    }
}

impl PathConstraint {
    /// Creates a new `PathConstraint` with the given `path` and `offset`
    /// ## `path`
    /// a `Path`, or `None`
    /// ## `offset`
    /// the offset along the `Path`
    ///
    /// # Returns
    ///
    /// the newly created `PathConstraint`
    pub fn new<P: IsA<Path>>(path: Option<&P>, offset: f32) -> PathConstraint {
        unsafe {
            Constraint::from_glib_none(ffi::clutter_path_constraint_new(
                path.map(|p| p.as_ref()).to_glib_none().0,
                offset,
            ))
            .unsafe_cast()
        }
    }

    /// Retrieves the offset along the `Path` used by `self`.
    ///
    /// # Returns
    ///
    /// the offset
    pub fn get_offset(&self) -> f32 {
        unsafe { ffi::clutter_path_constraint_get_offset(self.to_glib_none().0) }
    }

    /// Retrieves a pointer to the `Path` used by `self`.
    ///
    /// # Returns
    ///
    /// the `Path` used by the
    ///  `PathConstraint`, or `None`. The returned `Path` is owned
    ///  by the constraint and it should not be unreferenced
    pub fn get_path(&self) -> Option<Path> {
        unsafe { from_glib_none(ffi::clutter_path_constraint_get_path(self.to_glib_none().0)) }
    }

    /// Sets the offset along the `Path` used by `self`.
    /// ## `offset`
    /// the offset along the path
    pub fn set_offset(&self, offset: f32) {
        unsafe {
            ffi::clutter_path_constraint_set_offset(self.to_glib_none().0, offset);
        }
    }

    /// Sets the `path` to be followed by the `PathConstraint`.
    ///
    /// The `self` will take ownership of the `Path` passed to this
    /// function.
    /// ## `path`
    /// a `Path`
    pub fn set_path<P: IsA<Path>>(&self, path: Option<&P>) {
        unsafe {
            ffi::clutter_path_constraint_set_path(
                self.to_glib_none().0,
                path.map(|p| p.as_ref()).to_glib_none().0,
            );
        }
    }

    /// The ::node-reached signal is emitted each time a
    /// `PathConstraint:offset` value results in the actor
    /// passing a `PathNode`
    /// ## `actor`
    /// the `Actor` using the `constraint`
    /// ## `index`
    /// the index of the node that has been reached
    pub fn connect_node_reached<F: Fn(&PathConstraint, &Actor, u32) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn node_reached_trampoline<
            F: Fn(&PathConstraint, &Actor, u32) + 'static,
        >(
            this: *mut ffi::ClutterPathConstraint,
            actor: *mut ffi::ClutterActor,
            index: libc::c_uint,
            f: glib_sys::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this), &from_glib_borrow(actor), index)
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"node-reached\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    node_reached_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    pub fn connect_property_offset_notify<F: Fn(&PathConstraint) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_offset_trampoline<F: Fn(&PathConstraint) + 'static>(
            this: *mut ffi::ClutterPathConstraint,
            _param_spec: glib_sys::gpointer,
            f: glib_sys::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::offset\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_offset_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    pub fn connect_property_path_notify<F: Fn(&PathConstraint) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_path_trampoline<F: Fn(&PathConstraint) + 'static>(
            this: *mut ffi::ClutterPathConstraint,
            _param_spec: glib_sys::gpointer,
            f: glib_sys::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::path\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_path_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

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