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
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir-files (https://github.com/gtk-rs/gir-files)
// from gst-gir-files (https://gitlab.freedesktop.org/gstreamer/gir-files-rs.git)
// DO NOT EDIT

use crate::{ffi, Asset, MetaContainer, TrackType};
use glib::{
    prelude::*,
    signal::{connect_raw, SignalHandlerId},
    translate::*,
};
use std::boxed::Box as Box_;

glib::wrapper! {
    ///
    ///
    /// ## Properties
    ///
    ///
    /// #### `track-type`
    ///  Readable | Writeable | Construct
    /// <details><summary><h4>Asset</h4></summary>
    ///
    ///
    /// #### `extractable-type`
    ///  The [`Extractable`][crate::Extractable] object type that can be extracted from the asset.
    ///
    /// Readable | Writeable | Construct Only
    ///
    ///
    /// #### `id`
    ///  The ID of the asset. This should be unique amongst all assets with
    /// the same [`extractable-type`][struct@crate::Asset#extractable-type]. Depending on the associated
    /// [`Extractable`][crate::Extractable] implementation, this id may convey some information
    /// about the [`glib::Object`][crate::glib::Object] that should be extracted. Note that, as such, the
    /// ID will have an expected format, and you can not choose this value
    /// arbitrarily. By default, this will be set to the type name of the
    /// [`extractable-type`][struct@crate::Asset#extractable-type], but you should check the documentation
    /// of the extractable type to see whether they differ from the
    /// default behaviour.
    ///
    /// Readable | Writeable | Construct Only
    ///
    ///
    /// #### `proxy`
    ///  The default proxy for this asset, or [`None`] if it has no proxy. A
    /// proxy will act as a substitute for the original asset when the
    /// original is requested (see [`Asset::request()`][crate::Asset::request()]).
    ///
    /// Setting this property will not usually remove the existing proxy, but
    /// will replace it as the default (see [`AssetExt::set_proxy()`][crate::prelude::AssetExt::set_proxy()]).
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `proxy-target`
    ///  The asset that this asset is a proxy for, or [`None`] if it is not a
    /// proxy for another asset.
    ///
    /// Note that even if this asset is acting as a proxy for another asset,
    /// but this asset is not the default [`proxy`][struct@crate::Asset#proxy], then `proxy`-target
    /// will *still* point to this other asset. So you should check the
    /// [`proxy`][struct@crate::Asset#proxy] property of `target`-proxy before assuming it is the
    /// current default proxy for the target.
    ///
    /// Note that the [`notify`][struct@crate::glib::Object#notify] for this property is emitted after
    /// the [`proxy`][struct@crate::Asset#proxy] [`notify`][struct@crate::glib::Object#notify] for the corresponding (if any)
    /// asset it is now the proxy of/no longer the proxy of.
    ///
    /// Readable
    /// </details>
    ///
    /// # Implements
    ///
    /// [`TrackElementAssetExt`][trait@crate::prelude::TrackElementAssetExt], [`AssetExt`][trait@crate::prelude::AssetExt], [`trait@glib::ObjectExt`], [`MetaContainerExt`][trait@crate::prelude::MetaContainerExt]
    #[doc(alias = "GESTrackElementAsset")]
    pub struct TrackElementAsset(Object<ffi::GESTrackElementAsset, ffi::GESTrackElementAssetClass>) @extends Asset, @implements MetaContainer;

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

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

unsafe impl Send for TrackElementAsset {}
unsafe impl Sync for TrackElementAsset {}

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

/// Trait containing all [`struct@TrackElementAsset`] methods.
///
/// # Implementors
///
/// [`EffectAsset`][struct@crate::EffectAsset], [`TrackElementAsset`][struct@crate::TrackElementAsset], [`UriSourceAsset`][struct@crate::UriSourceAsset]
pub trait TrackElementAssetExt: IsA<TrackElementAsset> + sealed::Sealed + 'static {
    /// Result: [`true`] if `self` has a natural framerate [`false`] otherwise
    ///
    /// # Returns
    ///
    ///
    /// ## `framerate_n`
    /// The framerate numerator
    ///
    /// ## `framerate_d`
    /// The framerate denominator
    #[cfg(feature = "v1_18")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
    #[doc(alias = "ges_track_element_asset_get_natural_framerate")]
    #[doc(alias = "get_natural_framerate")]
    fn natural_framerate(&self) -> Option<(i32, i32)> {
        unsafe {
            let mut framerate_n = std::mem::MaybeUninit::uninit();
            let mut framerate_d = std::mem::MaybeUninit::uninit();
            let ret = from_glib(ffi::ges_track_element_asset_get_natural_framerate(
                self.as_ref().to_glib_none().0,
                framerate_n.as_mut_ptr(),
                framerate_d.as_mut_ptr(),
            ));
            if ret {
                Some((framerate_n.assume_init(), framerate_d.assume_init()))
            } else {
                None
            }
        }
    }

    /// Get the GESAssetTrackType the [`TrackElement`][crate::TrackElement] extracted from `self_`
    /// should get into
    ///
    /// # Returns
    ///
    /// a [`TrackType`][crate::TrackType]
    #[doc(alias = "ges_track_element_asset_get_track_type")]
    #[doc(alias = "get_track_type")]
    #[doc(alias = "track-type")]
    fn track_type(&self) -> TrackType {
        unsafe {
            from_glib(ffi::ges_track_element_asset_get_track_type(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Set the [`TrackType`][crate::TrackType] the [`TrackElement`][crate::TrackElement] extracted from `self_`
    /// should get into
    /// ## `type_`
    /// A [`TrackType`][crate::TrackType]
    #[doc(alias = "ges_track_element_asset_set_track_type")]
    #[doc(alias = "track-type")]
    fn set_track_type(&self, type_: TrackType) {
        unsafe {
            ffi::ges_track_element_asset_set_track_type(
                self.as_ref().to_glib_none().0,
                type_.into_glib(),
            );
        }
    }

    #[doc(alias = "track-type")]
    fn connect_track_type_notify<F: Fn(&Self) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_track_type_trampoline<
            P: IsA<TrackElementAsset>,
            F: Fn(&P) + Send + Sync + 'static,
        >(
            this: *mut ffi::GESTrackElementAsset,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(TrackElementAsset::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::track-type\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_track_type_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

impl<O: IsA<TrackElementAsset>> TrackElementAssetExt for O {}