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
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
// 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
#![allow(deprecated)]

use crate::{
    ffi, Extractable, MetaContainer, Operation, TimelineElement, TrackElement, Transition,
    VideoStandardTransitionType,
};
use glib::{
    prelude::*,
    signal::{connect_raw, SignalHandlerId},
    translate::*,
};
use std::boxed::Box as Box_;

glib::wrapper! {
    ///
    ///
    /// ## Properties
    ///
    ///
    /// #### `border`
    ///  This value represents the border width of the transition.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `invert`
    ///  This value represents the direction of the transition.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `transition-type`
    ///  Readable | Writeable
    /// <details><summary><h4>TrackElement</h4></summary>
    ///
    ///
    /// #### `active`
    ///  Whether the effect of the element should be applied in its
    /// [`track`][struct@crate::TrackElement#track]. If set to [`false`], it will not be used in
    /// the output of the track.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `auto-clamp-control-sources`
    ///  Whether the control sources on the element (see
    /// [`TrackElementExt::set_control_source()`][crate::prelude::TrackElementExt::set_control_source()]) will be automatically
    /// updated whenever the [`in-point`][struct@crate::TimelineElement#in-point] or out-point of the
    /// element change in value.
    ///
    /// See [`TrackElementExt::clamp_control_source()`][crate::prelude::TrackElementExt::clamp_control_source()] for how this is done
    /// per control source.
    ///
    /// Default value: [`true`]
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `has-internal-source`
    ///  This property is used to determine whether the 'internal time'
    /// properties of the element have any meaning. In particular, unless
    /// this is set to [`true`], the [`in-point`][struct@crate::TimelineElement#in-point] and
    /// [`max-duration`][struct@crate::TimelineElement#max-duration] can not be set to any value other
    /// than the default 0 and `GST_CLOCK_TIME_NONE`, respectively.
    ///
    /// If an element has some *internal* *timed* source [`gst::Element`][crate::gst::Element] that it
    /// reads stream data from as part of its function in a [`Track`][crate::Track], then
    /// you'll likely want to set this to [`true`] to allow the
    /// [`in-point`][struct@crate::TimelineElement#in-point] and [`max-duration`][struct@crate::TimelineElement#max-duration] to
    /// be set.
    ///
    /// The default value is determined by the `GESTrackElementClass`
    /// `default_has_internal_source` class property. For most
    /// `GESSourceClass`-es, this will be [`true`], with the exception of those
    /// that have a potentially *static* source, such as `GESImageSourceClass`
    /// and `GESTitleSourceClass`. Otherwise, this will usually be [`false`].
    ///
    /// For most [`Operation`][crate::Operation]-s you will likely want to leave this set to
    /// [`false`]. The exception may be for an operation that reads some stream
    /// data from some private internal source as part of manipulating the
    /// input data from the usual linked upstream [`TrackElement`][crate::TrackElement].
    ///
    /// For example, you may want to set this to [`true`] for a
    /// [`TrackType::VIDEO`][crate::TrackType::VIDEO] operation that wraps a `textoverlay` that reads
    /// from a subtitle file and places its text on top of the received video
    /// data. The [`in-point`][struct@crate::TimelineElement#in-point] of the element would be used
    /// to shift the initial seek time on the `textoverlay` away from 0, and
    /// the [`max-duration`][struct@crate::TimelineElement#max-duration] could be set to reflect the
    /// time at which the subtitle file runs out of data.
    ///
    /// Note that GES can not support track elements that have both internal
    /// content and manipulate the timing of their data streams (time
    /// effects).
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `track`
    ///  The track that this element belongs to, or [`None`] if it does not
    /// belong to a track.
    ///
    /// Readable
    ///
    ///
    /// #### `track-type`
    ///  The track type of the element, which determines the type of track the
    /// element can be added to (see [`track-type`][struct@crate::Track#track-type]). This should
    /// correspond to the type of data that the element can produce or
    /// process.
    ///
    /// Readable | Writeable | Construct
    /// </details>
    /// <details><summary><h4>TimelineElement</h4></summary>
    ///
    ///
    /// #### `duration`
    ///  The duration that the element is in effect for in the timeline (a
    /// time difference in nanoseconds using the time coordinates of the
    /// timeline). For example, for a source element, this would determine
    /// for how long it should output its internal content for. For an
    /// operation element, this would determine for how long its effect
    /// should be applied to any source content.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `in-point`
    ///  The initial offset to use internally when outputting content (in
    /// nanoseconds, but in the time coordinates of the internal content).
    ///
    /// For example, for a [`VideoUriSource`][crate::VideoUriSource] that references some media
    /// file, the "internal content" is the media file data, and the
    /// in-point would correspond to some timestamp in the media file.
    /// When playing the timeline, and when the element is first reached at
    /// timeline-time [`start`][struct@crate::TimelineElement#start], it will begin outputting the
    /// data from the timestamp in-point **onwards**, until it reaches the
    /// end of its [`duration`][struct@crate::TimelineElement#duration] in the timeline.
    ///
    /// For elements that have no internal content, this should be kept
    /// as 0.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `max-duration`
    ///  The full duration of internal content that is available (a time
    /// difference in nanoseconds using the time coordinates of the internal
    /// content).
    ///
    /// This will act as a cap on the [`in-point`][struct@crate::TimelineElement#in-point] of the
    /// element (which is in the same time coordinates), and will sometimes
    /// be used to limit the [`duration`][struct@crate::TimelineElement#duration] of the element in
    /// the timeline.
    ///
    /// For example, for a [`VideoUriSource`][crate::VideoUriSource] that references some media
    /// file, this would be the length of the media file.
    ///
    /// For elements that have no internal content, or whose content is
    /// indefinite, this should be kept as `GST_CLOCK_TIME_NONE`.
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `name`
    ///  The name of the element. This should be unique within its timeline.
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `parent`
    ///  The parent container of the element.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `priority`
    ///  The priority of the element.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `serialize`
    ///  Whether the element should be serialized.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `start`
    ///  The starting position of the element in the timeline (in nanoseconds
    /// and in the time coordinates of the timeline). For example, for a
    /// source element, this would determine the time at which it should
    /// start outputting its internal content. For an operation element, this
    /// would determine the time at which it should start applying its effect
    /// to any source content.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `timeline`
    ///  The timeline that the element lies within.
    ///
    /// Readable | Writeable
    /// </details>
    ///
    /// # Implements
    ///
    /// [`VideoTransitionExt`][trait@crate::prelude::VideoTransitionExt], [`TransitionExt`][trait@crate::prelude::TransitionExt], [`OperationExt`][trait@crate::prelude::OperationExt], [`TrackElementExt`][trait@crate::prelude::TrackElementExt], [`TimelineElementExt`][trait@crate::prelude::TimelineElementExt], [`trait@glib::ObjectExt`], [`ExtractableExt`][trait@crate::prelude::ExtractableExt], [`MetaContainerExt`][trait@crate::prelude::MetaContainerExt], [`TimelineElementExtManual`][trait@crate::prelude::TimelineElementExtManual]
    #[doc(alias = "GESVideoTransition")]
    pub struct VideoTransition(Object<ffi::GESVideoTransition, ffi::GESVideoTransitionClass>) @extends Transition, Operation, TrackElement, TimelineElement, @implements Extractable, MetaContainer;

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

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

    #[doc(alias = "ges_video_transition_new")]
    pub fn new() -> VideoTransition {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::ges_video_transition_new()) }
    }
}

impl Default for VideoTransition {
    fn default() -> Self {
        Self::new()
    }
}

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

/// Trait containing all [`struct@VideoTransition`] methods.
///
/// # Implementors
///
/// [`VideoTransition`][struct@crate::VideoTransition]
pub trait VideoTransitionExt: IsA<VideoTransition> + sealed::Sealed + 'static {
    /// Get the border property of `self`, this value represents
    /// the border width of the transition.
    ///
    /// # Deprecated since 1.20
    ///
    /// Use ges_timeline_element_get_child_property instead.
    ///
    /// # Returns
    ///
    /// The border values of `self` or -1 if not meaningful
    /// (this will happen when not using a smpte transition).
    #[cfg_attr(feature = "v1_20", deprecated = "Since 1.20")]
    #[allow(deprecated)]
    #[doc(alias = "ges_video_transition_get_border")]
    #[doc(alias = "get_border")]
    fn border(&self) -> i32 {
        unsafe { ffi::ges_video_transition_get_border(self.as_ref().to_glib_none().0) }
    }

    /// Get the transition type used by `self`.
    ///
    /// # Returns
    ///
    /// The transition type used by `self`.
    #[doc(alias = "ges_video_transition_get_transition_type")]
    #[doc(alias = "get_transition_type")]
    #[doc(alias = "transition-type")]
    fn transition_type(&self) -> VideoStandardTransitionType {
        unsafe {
            from_glib(ffi::ges_video_transition_get_transition_type(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Get the invert property of `self`, this value represents
    /// the direction of the transition.
    ///
    /// # Deprecated since 1.20
    ///
    /// Use ges_timeline_element_get_child_property instead.
    ///
    /// # Returns
    ///
    /// The invert value of `self`
    #[cfg_attr(feature = "v1_20", deprecated = "Since 1.20")]
    #[allow(deprecated)]
    #[doc(alias = "ges_video_transition_is_inverted")]
    fn is_inverted(&self) -> bool {
        unsafe {
            from_glib(ffi::ges_video_transition_is_inverted(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Set the border property of `self`, this value represents
    /// the border width of the transition. In case this value does
    /// not make sense for the current transition type, it is cached
    /// for later use.
    ///
    /// # Deprecated since 1.20
    ///
    /// Use ges_timeline_element_set_child_property instead.
    /// ## `value`
    /// The value of the border to set on `object`
    #[cfg_attr(feature = "v1_20", deprecated = "Since 1.20")]
    #[allow(deprecated)]
    #[doc(alias = "ges_video_transition_set_border")]
    #[doc(alias = "border")]
    fn set_border(&self, value: u32) {
        unsafe {
            ffi::ges_video_transition_set_border(self.as_ref().to_glib_none().0, value);
        }
    }

    /// Set the invert property of `self`, this value represents
    /// the direction of the transition. In case this value does
    /// not make sense for the current transition type, it is cached
    /// for later use.
    ///
    /// # Deprecated since 1.20
    ///
    /// Use ges_timeline_element_set_child_property instead.
    /// ## `inverted`
    /// [`true`] if the transition should be inverted [`false`] otherwise
    #[cfg_attr(feature = "v1_20", deprecated = "Since 1.20")]
    #[allow(deprecated)]
    #[doc(alias = "ges_video_transition_set_inverted")]
    fn set_inverted(&self, inverted: bool) {
        unsafe {
            ffi::ges_video_transition_set_inverted(
                self.as_ref().to_glib_none().0,
                inverted.into_glib(),
            );
        }
    }

    /// Sets the transition being used to `type_`.
    /// ## `type_`
    /// a [`VideoStandardTransitionType`][crate::VideoStandardTransitionType]
    ///
    /// # Returns
    ///
    /// [`true`] if the transition type was properly changed, else [`false`].
    #[doc(alias = "ges_video_transition_set_transition_type")]
    #[doc(alias = "transition-type")]
    fn set_transition_type(&self, type_: VideoStandardTransitionType) -> bool {
        unsafe {
            from_glib(ffi::ges_video_transition_set_transition_type(
                self.as_ref().to_glib_none().0,
                type_.into_glib(),
            ))
        }
    }

    /// This value represents the direction of the transition.
    ///
    /// # Deprecated since 1.20
    ///
    /// Use ges_timeline_element_[sg]et_child_property instead.
    #[cfg_attr(feature = "v1_20", deprecated = "Since 1.20")]
    fn inverts(&self) -> bool {
        ObjectExt::property(self.as_ref(), "invert")
    }

    /// This value represents the direction of the transition.
    ///
    /// # Deprecated since 1.20
    ///
    /// Use ges_timeline_element_[sg]et_child_property instead.
    #[cfg_attr(feature = "v1_20", deprecated = "Since 1.20")]
    fn set_invert(&self, invert: bool) {
        ObjectExt::set_property(self.as_ref(), "invert", invert)
    }

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

    #[cfg_attr(feature = "v1_20", deprecated = "Since 1.20")]
    #[doc(alias = "invert")]
    fn connect_invert_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_invert_trampoline<
            P: IsA<VideoTransition>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GESVideoTransition,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(VideoTransition::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::invert\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_invert_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

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

impl<O: IsA<VideoTransition>> VideoTransitionExt for O {}