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

// 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 ges_sys;
use glib::translate::*;
use glib::value::FromValue;
use glib::value::FromValueOptional;
use glib::value::SetValue;
use glib::value::Value;
use glib::StaticType;
use glib::Type;
use gobject_sys;

bitflags! {
    /// The various modes a `Pipeline` can be configured to.
    pub struct PipelineFlags: u32 {
        /// Output the `Pipeline:timeline`'s
        /// audio to the soundcard
        const AUDIO_PREVIEW = 1;
        /// Output the `Pipeline:timeline`'s
        /// video to the screen
        const VIDEO_PREVIEW = 2;
        /// Output both the `Pipeline:timeline`'s
        /// audio and video to the soundcard and screen (default)
        const FULL_PREVIEW = 3;
        /// Render the `Pipeline:timeline` with
        /// forced decoding (the underlying `encodebin` has its
        /// `encodebin:avoid-reencoding` property set to `false`)
        const RENDER = 4;
        /// Render the `Pipeline:timeline`,
        /// avoiding decoding/reencoding (the underlying `encodebin` has its
        /// `encodebin:avoid-reencoding` property set to `true`).
        /// > NOTE: Smart rendering can not work in tracks where `Track:mixing`
        /// > is enabled.
        const SMART_RENDER = 8;
    }
}

#[doc(hidden)]
impl ToGlib for PipelineFlags {
    type GlibType = ges_sys::GESPipelineFlags;

    fn to_glib(&self) -> ges_sys::GESPipelineFlags {
        self.bits()
    }
}

#[doc(hidden)]
impl FromGlib<ges_sys::GESPipelineFlags> for PipelineFlags {
    fn from_glib(value: ges_sys::GESPipelineFlags) -> PipelineFlags {
        skip_assert_initialized!();
        PipelineFlags::from_bits_truncate(value)
    }
}

impl StaticType for PipelineFlags {
    fn static_type() -> Type {
        unsafe { from_glib(ges_sys::ges_pipeline_flags_get_type()) }
    }
}

impl<'a> FromValueOptional<'a> for PipelineFlags {
    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
        Some(FromValue::from_value(value))
    }
}

impl<'a> FromValue<'a> for PipelineFlags {
    unsafe fn from_value(value: &Value) -> Self {
        from_glib(gobject_sys::g_value_get_flags(value.to_glib_none().0))
    }
}

impl SetValue for PipelineFlags {
    unsafe fn set_value(value: &mut Value, this: &Self) {
        gobject_sys::g_value_set_flags(value.to_glib_none_mut().0, this.to_glib())
    }
}

bitflags! {
    /// Types of content handled by a track. If the content is not one of
    /// `TrackType::Audio`, `TrackType::Video` or `TrackType::Text`,
    /// the user of the `Track` must set the type to `TrackType::Custom`.
    ///
    /// `TrackType::Unknown` is for internal purposes and should not be used
    /// by users
    pub struct TrackType: u32 {
        /// A track of unknown type (i.e. invalid)
        const UNKNOWN = 1;
        /// An audio track
        const AUDIO = 2;
        /// A video track
        const VIDEO = 4;
        /// A text (subtitle) track
        const TEXT = 8;
        /// A custom-content track
        const CUSTOM = 16;
    }
}

#[doc(hidden)]
impl ToGlib for TrackType {
    type GlibType = ges_sys::GESTrackType;

    fn to_glib(&self) -> ges_sys::GESTrackType {
        self.bits()
    }
}

#[doc(hidden)]
impl FromGlib<ges_sys::GESTrackType> for TrackType {
    fn from_glib(value: ges_sys::GESTrackType) -> TrackType {
        skip_assert_initialized!();
        TrackType::from_bits_truncate(value)
    }
}

impl StaticType for TrackType {
    fn static_type() -> Type {
        unsafe { from_glib(ges_sys::ges_track_type_get_type()) }
    }
}

impl<'a> FromValueOptional<'a> for TrackType {
    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
        Some(FromValue::from_value(value))
    }
}

impl<'a> FromValue<'a> for TrackType {
    unsafe fn from_value(value: &Value) -> Self {
        from_glib(gobject_sys::g_value_get_flags(value.to_glib_none().0))
    }
}

impl SetValue for TrackType {
    unsafe fn set_value(value: &mut Value, this: &Self) {
        gobject_sys::g_value_set_flags(value.to_glib_none_mut().0, this.to_glib())
    }
}