#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gst.Flags
(
AllocatorFlags(..) ,
BinFlags(..) ,
BufferCopyFlags(..) ,
BufferFlags(..) ,
BufferPoolAcquireFlags(..) ,
BusFlags(..) ,
CapsFlags(..) ,
ClockFlags(..) ,
DebugColorFlags(..) ,
DebugGraphDetails(..) ,
ElementFlags(..) ,
EventTypeFlags(..) ,
GapFlags(..) ,
LockFlags(..) ,
MapFlags(..) ,
MemoryFlags(..) ,
MessageType(..) ,
MetaFlags(..) ,
MiniObjectFlags(..) ,
ObjectFlags(..) ,
PadFlags(..) ,
PadLinkCheck(..) ,
PadProbeType(..) ,
PadTemplateFlags(..) ,
ParseFlags(..) ,
PipelineFlags(..) ,
PluginAPIFlags(..) ,
PluginDependencyFlags(..) ,
PluginFlags(..) ,
QueryTypeFlags(..) ,
SchedulingFlags(..) ,
SeekFlags(..) ,
SegmentFlags(..) ,
SerializeFlags(..) ,
StackTraceFlags(..) ,
StreamFlags(..) ,
StreamType(..) ,
TracerValueFlags(..) ,
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R
data TracerValueFlags =
TracerValueFlagsNone
| TracerValueFlagsOptional
| TracerValueFlagsAggregated
| AnotherTracerValueFlags Int
deriving (Int -> TracerValueFlags -> ShowS
[TracerValueFlags] -> ShowS
TracerValueFlags -> String
(Int -> TracerValueFlags -> ShowS)
-> (TracerValueFlags -> String)
-> ([TracerValueFlags] -> ShowS)
-> Show TracerValueFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TracerValueFlags -> ShowS
showsPrec :: Int -> TracerValueFlags -> ShowS
$cshow :: TracerValueFlags -> String
show :: TracerValueFlags -> String
$cshowList :: [TracerValueFlags] -> ShowS
showList :: [TracerValueFlags] -> ShowS
Show, TracerValueFlags -> TracerValueFlags -> Bool
(TracerValueFlags -> TracerValueFlags -> Bool)
-> (TracerValueFlags -> TracerValueFlags -> Bool)
-> Eq TracerValueFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TracerValueFlags -> TracerValueFlags -> Bool
== :: TracerValueFlags -> TracerValueFlags -> Bool
$c/= :: TracerValueFlags -> TracerValueFlags -> Bool
/= :: TracerValueFlags -> TracerValueFlags -> Bool
Eq)
instance P.Enum TracerValueFlags where
fromEnum :: TracerValueFlags -> Int
fromEnum TracerValueFlags
TracerValueFlagsNone = Int
0
fromEnum TracerValueFlags
TracerValueFlagsOptional = Int
1
fromEnum TracerValueFlags
TracerValueFlagsAggregated = Int
2
fromEnum (AnotherTracerValueFlags Int
k) = Int
k
toEnum :: Int -> TracerValueFlags
toEnum Int
0 = TracerValueFlags
TracerValueFlagsNone
toEnum Int
1 = TracerValueFlags
TracerValueFlagsOptional
toEnum Int
2 = TracerValueFlags
TracerValueFlagsAggregated
toEnum Int
k = Int -> TracerValueFlags
AnotherTracerValueFlags Int
k
instance P.Ord TracerValueFlags where
compare :: TracerValueFlags -> TracerValueFlags -> Ordering
compare TracerValueFlags
a TracerValueFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (TracerValueFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum TracerValueFlags
a) (TracerValueFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum TracerValueFlags
b)
type instance O.ParentTypes TracerValueFlags = '[]
instance O.HasParentTypes TracerValueFlags
foreign import ccall "gst_tracer_value_flags_get_type" c_gst_tracer_value_flags_get_type ::
IO GType
instance B.Types.TypedObject TracerValueFlags where
glibType :: IO GType
glibType = IO GType
c_gst_tracer_value_flags_get_type
instance B.Types.BoxedFlags TracerValueFlags
instance IsGFlag TracerValueFlags
data StreamType =
StreamTypeUnknown
| StreamTypeAudio
| StreamTypeVideo
| StreamTypeContainer
| StreamTypeText
| AnotherStreamType Int
deriving (Int -> StreamType -> ShowS
[StreamType] -> ShowS
StreamType -> String
(Int -> StreamType -> ShowS)
-> (StreamType -> String)
-> ([StreamType] -> ShowS)
-> Show StreamType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> StreamType -> ShowS
showsPrec :: Int -> StreamType -> ShowS
$cshow :: StreamType -> String
show :: StreamType -> String
$cshowList :: [StreamType] -> ShowS
showList :: [StreamType] -> ShowS
Show, StreamType -> StreamType -> Bool
(StreamType -> StreamType -> Bool)
-> (StreamType -> StreamType -> Bool) -> Eq StreamType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: StreamType -> StreamType -> Bool
== :: StreamType -> StreamType -> Bool
$c/= :: StreamType -> StreamType -> Bool
/= :: StreamType -> StreamType -> Bool
Eq)
instance P.Enum StreamType where
fromEnum :: StreamType -> Int
fromEnum StreamType
StreamTypeUnknown = Int
1
fromEnum StreamType
StreamTypeAudio = Int
2
fromEnum StreamType
StreamTypeVideo = Int
4
fromEnum StreamType
StreamTypeContainer = Int
8
fromEnum StreamType
StreamTypeText = Int
16
fromEnum (AnotherStreamType Int
k) = Int
k
toEnum :: Int -> StreamType
toEnum Int
1 = StreamType
StreamTypeUnknown
toEnum Int
2 = StreamType
StreamTypeAudio
toEnum Int
4 = StreamType
StreamTypeVideo
toEnum Int
8 = StreamType
StreamTypeContainer
toEnum Int
16 = StreamType
StreamTypeText
toEnum Int
k = Int -> StreamType
AnotherStreamType Int
k
instance P.Ord StreamType where
compare :: StreamType -> StreamType -> Ordering
compare StreamType
a StreamType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (StreamType -> Int
forall a. Enum a => a -> Int
P.fromEnum StreamType
a) (StreamType -> Int
forall a. Enum a => a -> Int
P.fromEnum StreamType
b)
type instance O.ParentTypes StreamType = '[]
instance O.HasParentTypes StreamType
foreign import ccall "gst_stream_type_get_type" c_gst_stream_type_get_type ::
IO GType
instance B.Types.TypedObject StreamType where
glibType :: IO GType
glibType = IO GType
c_gst_stream_type_get_type
instance B.Types.BoxedFlags StreamType
instance IsGFlag StreamType
data StreamFlags =
StreamFlagsNone
| StreamFlagsSparse
| StreamFlagsSelect
| StreamFlagsUnselect
| AnotherStreamFlags Int
deriving (Int -> StreamFlags -> ShowS
[StreamFlags] -> ShowS
StreamFlags -> String
(Int -> StreamFlags -> ShowS)
-> (StreamFlags -> String)
-> ([StreamFlags] -> ShowS)
-> Show StreamFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> StreamFlags -> ShowS
showsPrec :: Int -> StreamFlags -> ShowS
$cshow :: StreamFlags -> String
show :: StreamFlags -> String
$cshowList :: [StreamFlags] -> ShowS
showList :: [StreamFlags] -> ShowS
Show, StreamFlags -> StreamFlags -> Bool
(StreamFlags -> StreamFlags -> Bool)
-> (StreamFlags -> StreamFlags -> Bool) -> Eq StreamFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: StreamFlags -> StreamFlags -> Bool
== :: StreamFlags -> StreamFlags -> Bool
$c/= :: StreamFlags -> StreamFlags -> Bool
/= :: StreamFlags -> StreamFlags -> Bool
Eq)
instance P.Enum StreamFlags where
fromEnum :: StreamFlags -> Int
fromEnum StreamFlags
StreamFlagsNone = Int
0
fromEnum StreamFlags
StreamFlagsSparse = Int
1
fromEnum StreamFlags
StreamFlagsSelect = Int
2
fromEnum StreamFlags
StreamFlagsUnselect = Int
4
fromEnum (AnotherStreamFlags Int
k) = Int
k
toEnum :: Int -> StreamFlags
toEnum Int
0 = StreamFlags
StreamFlagsNone
toEnum Int
1 = StreamFlags
StreamFlagsSparse
toEnum Int
2 = StreamFlags
StreamFlagsSelect
toEnum Int
4 = StreamFlags
StreamFlagsUnselect
toEnum Int
k = Int -> StreamFlags
AnotherStreamFlags Int
k
instance P.Ord StreamFlags where
compare :: StreamFlags -> StreamFlags -> Ordering
compare StreamFlags
a StreamFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (StreamFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum StreamFlags
a) (StreamFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum StreamFlags
b)
type instance O.ParentTypes StreamFlags = '[]
instance O.HasParentTypes StreamFlags
foreign import ccall "gst_stream_flags_get_type" c_gst_stream_flags_get_type ::
IO GType
instance B.Types.TypedObject StreamFlags where
glibType :: IO GType
glibType = IO GType
c_gst_stream_flags_get_type
instance B.Types.BoxedFlags StreamFlags
instance IsGFlag StreamFlags
data StackTraceFlags =
StackTraceFlagsNone
| StackTraceFlagsFull
| AnotherStackTraceFlags Int
deriving (Int -> StackTraceFlags -> ShowS
[StackTraceFlags] -> ShowS
StackTraceFlags -> String
(Int -> StackTraceFlags -> ShowS)
-> (StackTraceFlags -> String)
-> ([StackTraceFlags] -> ShowS)
-> Show StackTraceFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> StackTraceFlags -> ShowS
showsPrec :: Int -> StackTraceFlags -> ShowS
$cshow :: StackTraceFlags -> String
show :: StackTraceFlags -> String
$cshowList :: [StackTraceFlags] -> ShowS
showList :: [StackTraceFlags] -> ShowS
Show, StackTraceFlags -> StackTraceFlags -> Bool
(StackTraceFlags -> StackTraceFlags -> Bool)
-> (StackTraceFlags -> StackTraceFlags -> Bool)
-> Eq StackTraceFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: StackTraceFlags -> StackTraceFlags -> Bool
== :: StackTraceFlags -> StackTraceFlags -> Bool
$c/= :: StackTraceFlags -> StackTraceFlags -> Bool
/= :: StackTraceFlags -> StackTraceFlags -> Bool
Eq)
instance P.Enum StackTraceFlags where
fromEnum :: StackTraceFlags -> Int
fromEnum StackTraceFlags
StackTraceFlagsNone = Int
0
fromEnum StackTraceFlags
StackTraceFlagsFull = Int
1
fromEnum (AnotherStackTraceFlags Int
k) = Int
k
toEnum :: Int -> StackTraceFlags
toEnum Int
0 = StackTraceFlags
StackTraceFlagsNone
toEnum Int
1 = StackTraceFlags
StackTraceFlagsFull
toEnum Int
k = Int -> StackTraceFlags
AnotherStackTraceFlags Int
k
instance P.Ord StackTraceFlags where
compare :: StackTraceFlags -> StackTraceFlags -> Ordering
compare StackTraceFlags
a StackTraceFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (StackTraceFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum StackTraceFlags
a) (StackTraceFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum StackTraceFlags
b)
type instance O.ParentTypes StackTraceFlags = '[]
instance O.HasParentTypes StackTraceFlags
foreign import ccall "gst_stack_trace_flags_get_type" c_gst_stack_trace_flags_get_type ::
IO GType
instance B.Types.TypedObject StackTraceFlags where
glibType :: IO GType
glibType = IO GType
c_gst_stack_trace_flags_get_type
instance B.Types.BoxedFlags StackTraceFlags
instance IsGFlag StackTraceFlags
data SerializeFlags =
SerializeFlagsNone
| SerializeFlagsBackwardCompat
| AnotherSerializeFlags Int
deriving (Int -> SerializeFlags -> ShowS
[SerializeFlags] -> ShowS
SerializeFlags -> String
(Int -> SerializeFlags -> ShowS)
-> (SerializeFlags -> String)
-> ([SerializeFlags] -> ShowS)
-> Show SerializeFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SerializeFlags -> ShowS
showsPrec :: Int -> SerializeFlags -> ShowS
$cshow :: SerializeFlags -> String
show :: SerializeFlags -> String
$cshowList :: [SerializeFlags] -> ShowS
showList :: [SerializeFlags] -> ShowS
Show, SerializeFlags -> SerializeFlags -> Bool
(SerializeFlags -> SerializeFlags -> Bool)
-> (SerializeFlags -> SerializeFlags -> Bool) -> Eq SerializeFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SerializeFlags -> SerializeFlags -> Bool
== :: SerializeFlags -> SerializeFlags -> Bool
$c/= :: SerializeFlags -> SerializeFlags -> Bool
/= :: SerializeFlags -> SerializeFlags -> Bool
Eq)
instance P.Enum SerializeFlags where
fromEnum :: SerializeFlags -> Int
fromEnum SerializeFlags
SerializeFlagsNone = Int
0
fromEnum SerializeFlags
SerializeFlagsBackwardCompat = Int
1
fromEnum (AnotherSerializeFlags Int
k) = Int
k
toEnum :: Int -> SerializeFlags
toEnum Int
0 = SerializeFlags
SerializeFlagsNone
toEnum Int
1 = SerializeFlags
SerializeFlagsBackwardCompat
toEnum Int
k = Int -> SerializeFlags
AnotherSerializeFlags Int
k
instance P.Ord SerializeFlags where
compare :: SerializeFlags -> SerializeFlags -> Ordering
compare SerializeFlags
a SerializeFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SerializeFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum SerializeFlags
a) (SerializeFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum SerializeFlags
b)
type instance O.ParentTypes SerializeFlags = '[]
instance O.HasParentTypes SerializeFlags
foreign import ccall "gst_serialize_flags_get_type" c_gst_serialize_flags_get_type ::
IO GType
instance B.Types.TypedObject SerializeFlags where
glibType :: IO GType
glibType = IO GType
c_gst_serialize_flags_get_type
instance B.Types.BoxedFlags SerializeFlags
instance IsGFlag SerializeFlags
data SegmentFlags =
SegmentFlagsNone
| SegmentFlagsReset
| SegmentFlagsTrickmode
| SegmentFlagsSkip
| SegmentFlagsSegment
| SegmentFlagsTrickmodeKeyUnits
| SegmentFlagsTrickmodeForwardPredicted
| SegmentFlagsTrickmodeNoAudio
| AnotherSegmentFlags Int
deriving (Int -> SegmentFlags -> ShowS
[SegmentFlags] -> ShowS
SegmentFlags -> String
(Int -> SegmentFlags -> ShowS)
-> (SegmentFlags -> String)
-> ([SegmentFlags] -> ShowS)
-> Show SegmentFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SegmentFlags -> ShowS
showsPrec :: Int -> SegmentFlags -> ShowS
$cshow :: SegmentFlags -> String
show :: SegmentFlags -> String
$cshowList :: [SegmentFlags] -> ShowS
showList :: [SegmentFlags] -> ShowS
Show, SegmentFlags -> SegmentFlags -> Bool
(SegmentFlags -> SegmentFlags -> Bool)
-> (SegmentFlags -> SegmentFlags -> Bool) -> Eq SegmentFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SegmentFlags -> SegmentFlags -> Bool
== :: SegmentFlags -> SegmentFlags -> Bool
$c/= :: SegmentFlags -> SegmentFlags -> Bool
/= :: SegmentFlags -> SegmentFlags -> Bool
Eq)
instance P.Enum SegmentFlags where
fromEnum :: SegmentFlags -> Int
fromEnum SegmentFlags
SegmentFlagsNone = Int
0
fromEnum SegmentFlags
SegmentFlagsReset = Int
1
fromEnum SegmentFlags
SegmentFlagsTrickmode = Int
16
fromEnum SegmentFlags
SegmentFlagsSkip = Int
16
fromEnum SegmentFlags
SegmentFlagsSegment = Int
8
fromEnum SegmentFlags
SegmentFlagsTrickmodeKeyUnits = Int
128
fromEnum SegmentFlags
SegmentFlagsTrickmodeForwardPredicted = Int
512
fromEnum SegmentFlags
SegmentFlagsTrickmodeNoAudio = Int
256
fromEnum (AnotherSegmentFlags Int
k) = Int
k
toEnum :: Int -> SegmentFlags
toEnum Int
0 = SegmentFlags
SegmentFlagsNone
toEnum Int
1 = SegmentFlags
SegmentFlagsReset
toEnum Int
16 = SegmentFlags
SegmentFlagsTrickmode
toEnum Int
8 = SegmentFlags
SegmentFlagsSegment
toEnum Int
128 = SegmentFlags
SegmentFlagsTrickmodeKeyUnits
toEnum Int
512 = SegmentFlags
SegmentFlagsTrickmodeForwardPredicted
toEnum Int
256 = SegmentFlags
SegmentFlagsTrickmodeNoAudio
toEnum Int
k = Int -> SegmentFlags
AnotherSegmentFlags Int
k
instance P.Ord SegmentFlags where
compare :: SegmentFlags -> SegmentFlags -> Ordering
compare SegmentFlags
a SegmentFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SegmentFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum SegmentFlags
a) (SegmentFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum SegmentFlags
b)
type instance O.ParentTypes SegmentFlags = '[]
instance O.HasParentTypes SegmentFlags
foreign import ccall "gst_segment_flags_get_type" c_gst_segment_flags_get_type ::
IO GType
instance B.Types.TypedObject SegmentFlags where
glibType :: IO GType
glibType = IO GType
c_gst_segment_flags_get_type
instance B.Types.BoxedFlags SegmentFlags
instance IsGFlag SegmentFlags
data SeekFlags =
SeekFlagsNone
| SeekFlagsFlush
| SeekFlagsAccurate
| SeekFlagsKeyUnit
| SeekFlagsSegment
| SeekFlagsTrickmode
| SeekFlagsSkip
| SeekFlagsSnapBefore
| SeekFlagsSnapAfter
| SeekFlagsSnapNearest
| SeekFlagsTrickmodeKeyUnits
| SeekFlagsTrickmodeNoAudio
| SeekFlagsTrickmodeForwardPredicted
| SeekFlagsInstantRateChange
| AnotherSeekFlags Int
deriving (Int -> SeekFlags -> ShowS
[SeekFlags] -> ShowS
SeekFlags -> String
(Int -> SeekFlags -> ShowS)
-> (SeekFlags -> String)
-> ([SeekFlags] -> ShowS)
-> Show SeekFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SeekFlags -> ShowS
showsPrec :: Int -> SeekFlags -> ShowS
$cshow :: SeekFlags -> String
show :: SeekFlags -> String
$cshowList :: [SeekFlags] -> ShowS
showList :: [SeekFlags] -> ShowS
Show, SeekFlags -> SeekFlags -> Bool
(SeekFlags -> SeekFlags -> Bool)
-> (SeekFlags -> SeekFlags -> Bool) -> Eq SeekFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SeekFlags -> SeekFlags -> Bool
== :: SeekFlags -> SeekFlags -> Bool
$c/= :: SeekFlags -> SeekFlags -> Bool
/= :: SeekFlags -> SeekFlags -> Bool
Eq)
instance P.Enum SeekFlags where
fromEnum :: SeekFlags -> Int
fromEnum SeekFlags
SeekFlagsNone = Int
0
fromEnum SeekFlags
SeekFlagsFlush = Int
1
fromEnum SeekFlags
SeekFlagsAccurate = Int
2
fromEnum SeekFlags
SeekFlagsKeyUnit = Int
4
fromEnum SeekFlags
SeekFlagsSegment = Int
8
fromEnum SeekFlags
SeekFlagsTrickmode = Int
16
fromEnum SeekFlags
SeekFlagsSkip = Int
16
fromEnum SeekFlags
SeekFlagsSnapBefore = Int
32
fromEnum SeekFlags
SeekFlagsSnapAfter = Int
64
fromEnum SeekFlags
SeekFlagsSnapNearest = Int
96
fromEnum SeekFlags
SeekFlagsTrickmodeKeyUnits = Int
128
fromEnum SeekFlags
SeekFlagsTrickmodeNoAudio = Int
256
fromEnum SeekFlags
SeekFlagsTrickmodeForwardPredicted = Int
512
fromEnum SeekFlags
SeekFlagsInstantRateChange = Int
1024
fromEnum (AnotherSeekFlags Int
k) = Int
k
toEnum :: Int -> SeekFlags
toEnum Int
0 = SeekFlags
SeekFlagsNone
toEnum Int
1 = SeekFlags
SeekFlagsFlush
toEnum Int
2 = SeekFlags
SeekFlagsAccurate
toEnum Int
4 = SeekFlags
SeekFlagsKeyUnit
toEnum Int
8 = SeekFlags
SeekFlagsSegment
toEnum Int
16 = SeekFlags
SeekFlagsTrickmode
toEnum Int
32 = SeekFlags
SeekFlagsSnapBefore
toEnum Int
64 = SeekFlags
SeekFlagsSnapAfter
toEnum Int
96 = SeekFlags
SeekFlagsSnapNearest
toEnum Int
128 = SeekFlags
SeekFlagsTrickmodeKeyUnits
toEnum Int
256 = SeekFlags
SeekFlagsTrickmodeNoAudio
toEnum Int
512 = SeekFlags
SeekFlagsTrickmodeForwardPredicted
toEnum Int
1024 = SeekFlags
SeekFlagsInstantRateChange
toEnum Int
k = Int -> SeekFlags
AnotherSeekFlags Int
k
instance P.Ord SeekFlags where
compare :: SeekFlags -> SeekFlags -> Ordering
compare SeekFlags
a SeekFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SeekFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum SeekFlags
a) (SeekFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum SeekFlags
b)
type instance O.ParentTypes SeekFlags = '[]
instance O.HasParentTypes SeekFlags
foreign import ccall "gst_seek_flags_get_type" c_gst_seek_flags_get_type ::
IO GType
instance B.Types.TypedObject SeekFlags where
glibType :: IO GType
glibType = IO GType
c_gst_seek_flags_get_type
instance B.Types.BoxedFlags SeekFlags
instance IsGFlag SeekFlags
data SchedulingFlags =
SchedulingFlagsSeekable
| SchedulingFlagsSequential
| SchedulingFlagsBandwidthLimited
| AnotherSchedulingFlags Int
deriving (Int -> SchedulingFlags -> ShowS
[SchedulingFlags] -> ShowS
SchedulingFlags -> String
(Int -> SchedulingFlags -> ShowS)
-> (SchedulingFlags -> String)
-> ([SchedulingFlags] -> ShowS)
-> Show SchedulingFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SchedulingFlags -> ShowS
showsPrec :: Int -> SchedulingFlags -> ShowS
$cshow :: SchedulingFlags -> String
show :: SchedulingFlags -> String
$cshowList :: [SchedulingFlags] -> ShowS
showList :: [SchedulingFlags] -> ShowS
Show, SchedulingFlags -> SchedulingFlags -> Bool
(SchedulingFlags -> SchedulingFlags -> Bool)
-> (SchedulingFlags -> SchedulingFlags -> Bool)
-> Eq SchedulingFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SchedulingFlags -> SchedulingFlags -> Bool
== :: SchedulingFlags -> SchedulingFlags -> Bool
$c/= :: SchedulingFlags -> SchedulingFlags -> Bool
/= :: SchedulingFlags -> SchedulingFlags -> Bool
Eq)
instance P.Enum SchedulingFlags where
fromEnum :: SchedulingFlags -> Int
fromEnum SchedulingFlags
SchedulingFlagsSeekable = Int
1
fromEnum SchedulingFlags
SchedulingFlagsSequential = Int
2
fromEnum SchedulingFlags
SchedulingFlagsBandwidthLimited = Int
4
fromEnum (AnotherSchedulingFlags Int
k) = Int
k
toEnum :: Int -> SchedulingFlags
toEnum Int
1 = SchedulingFlags
SchedulingFlagsSeekable
toEnum Int
2 = SchedulingFlags
SchedulingFlagsSequential
toEnum Int
4 = SchedulingFlags
SchedulingFlagsBandwidthLimited
toEnum Int
k = Int -> SchedulingFlags
AnotherSchedulingFlags Int
k
instance P.Ord SchedulingFlags where
compare :: SchedulingFlags -> SchedulingFlags -> Ordering
compare SchedulingFlags
a SchedulingFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SchedulingFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum SchedulingFlags
a) (SchedulingFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum SchedulingFlags
b)
type instance O.ParentTypes SchedulingFlags = '[]
instance O.HasParentTypes SchedulingFlags
foreign import ccall "gst_scheduling_flags_get_type" c_gst_scheduling_flags_get_type ::
IO GType
instance B.Types.TypedObject SchedulingFlags where
glibType :: IO GType
glibType = IO GType
c_gst_scheduling_flags_get_type
instance B.Types.BoxedFlags SchedulingFlags
instance IsGFlag SchedulingFlags
data QueryTypeFlags =
QueryTypeFlagsUpstream
| QueryTypeFlagsDownstream
| QueryTypeFlagsSerialized
| AnotherQueryTypeFlags Int
deriving (Int -> QueryTypeFlags -> ShowS
[QueryTypeFlags] -> ShowS
QueryTypeFlags -> String
(Int -> QueryTypeFlags -> ShowS)
-> (QueryTypeFlags -> String)
-> ([QueryTypeFlags] -> ShowS)
-> Show QueryTypeFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> QueryTypeFlags -> ShowS
showsPrec :: Int -> QueryTypeFlags -> ShowS
$cshow :: QueryTypeFlags -> String
show :: QueryTypeFlags -> String
$cshowList :: [QueryTypeFlags] -> ShowS
showList :: [QueryTypeFlags] -> ShowS
Show, QueryTypeFlags -> QueryTypeFlags -> Bool
(QueryTypeFlags -> QueryTypeFlags -> Bool)
-> (QueryTypeFlags -> QueryTypeFlags -> Bool) -> Eq QueryTypeFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: QueryTypeFlags -> QueryTypeFlags -> Bool
== :: QueryTypeFlags -> QueryTypeFlags -> Bool
$c/= :: QueryTypeFlags -> QueryTypeFlags -> Bool
/= :: QueryTypeFlags -> QueryTypeFlags -> Bool
Eq)
instance P.Enum QueryTypeFlags where
fromEnum :: QueryTypeFlags -> Int
fromEnum QueryTypeFlags
QueryTypeFlagsUpstream = Int
1
fromEnum QueryTypeFlags
QueryTypeFlagsDownstream = Int
2
fromEnum QueryTypeFlags
QueryTypeFlagsSerialized = Int
4
fromEnum (AnotherQueryTypeFlags Int
k) = Int
k
toEnum :: Int -> QueryTypeFlags
toEnum Int
1 = QueryTypeFlags
QueryTypeFlagsUpstream
toEnum Int
2 = QueryTypeFlags
QueryTypeFlagsDownstream
toEnum Int
4 = QueryTypeFlags
QueryTypeFlagsSerialized
toEnum Int
k = Int -> QueryTypeFlags
AnotherQueryTypeFlags Int
k
instance P.Ord QueryTypeFlags where
compare :: QueryTypeFlags -> QueryTypeFlags -> Ordering
compare QueryTypeFlags
a QueryTypeFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (QueryTypeFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum QueryTypeFlags
a) (QueryTypeFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum QueryTypeFlags
b)
type instance O.ParentTypes QueryTypeFlags = '[]
instance O.HasParentTypes QueryTypeFlags
foreign import ccall "gst_query_type_flags_get_type" c_gst_query_type_flags_get_type ::
IO GType
instance B.Types.TypedObject QueryTypeFlags where
glibType :: IO GType
glibType = IO GType
c_gst_query_type_flags_get_type
instance B.Types.BoxedFlags QueryTypeFlags
instance IsGFlag QueryTypeFlags
data PluginFlags =
PluginFlagsCached
| PluginFlagsBlacklisted
| AnotherPluginFlags Int
deriving (Int -> PluginFlags -> ShowS
[PluginFlags] -> ShowS
PluginFlags -> String
(Int -> PluginFlags -> ShowS)
-> (PluginFlags -> String)
-> ([PluginFlags] -> ShowS)
-> Show PluginFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PluginFlags -> ShowS
showsPrec :: Int -> PluginFlags -> ShowS
$cshow :: PluginFlags -> String
show :: PluginFlags -> String
$cshowList :: [PluginFlags] -> ShowS
showList :: [PluginFlags] -> ShowS
Show, PluginFlags -> PluginFlags -> Bool
(PluginFlags -> PluginFlags -> Bool)
-> (PluginFlags -> PluginFlags -> Bool) -> Eq PluginFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PluginFlags -> PluginFlags -> Bool
== :: PluginFlags -> PluginFlags -> Bool
$c/= :: PluginFlags -> PluginFlags -> Bool
/= :: PluginFlags -> PluginFlags -> Bool
Eq)
instance P.Enum PluginFlags where
fromEnum :: PluginFlags -> Int
fromEnum PluginFlags
PluginFlagsCached = Int
16
fromEnum PluginFlags
PluginFlagsBlacklisted = Int
32
fromEnum (AnotherPluginFlags Int
k) = Int
k
toEnum :: Int -> PluginFlags
toEnum Int
16 = PluginFlags
PluginFlagsCached
toEnum Int
32 = PluginFlags
PluginFlagsBlacklisted
toEnum Int
k = Int -> PluginFlags
AnotherPluginFlags Int
k
instance P.Ord PluginFlags where
compare :: PluginFlags -> PluginFlags -> Ordering
compare PluginFlags
a PluginFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PluginFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum PluginFlags
a) (PluginFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum PluginFlags
b)
type instance O.ParentTypes PluginFlags = '[]
instance O.HasParentTypes PluginFlags
foreign import ccall "gst_plugin_flags_get_type" c_gst_plugin_flags_get_type ::
IO GType
instance B.Types.TypedObject PluginFlags where
glibType :: IO GType
glibType = IO GType
c_gst_plugin_flags_get_type
instance B.Types.BoxedFlags PluginFlags
instance IsGFlag PluginFlags
data PluginDependencyFlags =
PluginDependencyFlagsNone
| PluginDependencyFlagsRecurse
| PluginDependencyFlagsPathsAreDefaultOnly
| PluginDependencyFlagsFileNameIsSuffix
| PluginDependencyFlagsFileNameIsPrefix
| PluginDependencyFlagsPathsAreRelativeToExe
| AnotherPluginDependencyFlags Int
deriving (Int -> PluginDependencyFlags -> ShowS
[PluginDependencyFlags] -> ShowS
PluginDependencyFlags -> String
(Int -> PluginDependencyFlags -> ShowS)
-> (PluginDependencyFlags -> String)
-> ([PluginDependencyFlags] -> ShowS)
-> Show PluginDependencyFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PluginDependencyFlags -> ShowS
showsPrec :: Int -> PluginDependencyFlags -> ShowS
$cshow :: PluginDependencyFlags -> String
show :: PluginDependencyFlags -> String
$cshowList :: [PluginDependencyFlags] -> ShowS
showList :: [PluginDependencyFlags] -> ShowS
Show, PluginDependencyFlags -> PluginDependencyFlags -> Bool
(PluginDependencyFlags -> PluginDependencyFlags -> Bool)
-> (PluginDependencyFlags -> PluginDependencyFlags -> Bool)
-> Eq PluginDependencyFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PluginDependencyFlags -> PluginDependencyFlags -> Bool
== :: PluginDependencyFlags -> PluginDependencyFlags -> Bool
$c/= :: PluginDependencyFlags -> PluginDependencyFlags -> Bool
/= :: PluginDependencyFlags -> PluginDependencyFlags -> Bool
Eq)
instance P.Enum PluginDependencyFlags where
fromEnum :: PluginDependencyFlags -> Int
fromEnum PluginDependencyFlags
PluginDependencyFlagsNone = Int
0
fromEnum PluginDependencyFlags
PluginDependencyFlagsRecurse = Int
1
fromEnum PluginDependencyFlags
PluginDependencyFlagsPathsAreDefaultOnly = Int
2
fromEnum PluginDependencyFlags
PluginDependencyFlagsFileNameIsSuffix = Int
4
fromEnum PluginDependencyFlags
PluginDependencyFlagsFileNameIsPrefix = Int
8
fromEnum PluginDependencyFlags
PluginDependencyFlagsPathsAreRelativeToExe = Int
16
fromEnum (AnotherPluginDependencyFlags Int
k) = Int
k
toEnum :: Int -> PluginDependencyFlags
toEnum Int
0 = PluginDependencyFlags
PluginDependencyFlagsNone
toEnum Int
1 = PluginDependencyFlags
PluginDependencyFlagsRecurse
toEnum Int
2 = PluginDependencyFlags
PluginDependencyFlagsPathsAreDefaultOnly
toEnum Int
4 = PluginDependencyFlags
PluginDependencyFlagsFileNameIsSuffix
toEnum Int
8 = PluginDependencyFlags
PluginDependencyFlagsFileNameIsPrefix
toEnum Int
16 = PluginDependencyFlags
PluginDependencyFlagsPathsAreRelativeToExe
toEnum Int
k = Int -> PluginDependencyFlags
AnotherPluginDependencyFlags Int
k
instance P.Ord PluginDependencyFlags where
compare :: PluginDependencyFlags -> PluginDependencyFlags -> Ordering
compare PluginDependencyFlags
a PluginDependencyFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PluginDependencyFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum PluginDependencyFlags
a) (PluginDependencyFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum PluginDependencyFlags
b)
type instance O.ParentTypes PluginDependencyFlags = '[]
instance O.HasParentTypes PluginDependencyFlags
foreign import ccall "gst_plugin_dependency_flags_get_type" c_gst_plugin_dependency_flags_get_type ::
IO GType
instance B.Types.TypedObject PluginDependencyFlags where
glibType :: IO GType
glibType = IO GType
c_gst_plugin_dependency_flags_get_type
instance B.Types.BoxedFlags PluginDependencyFlags
instance IsGFlag PluginDependencyFlags
data PluginAPIFlags =
PluginAPIFlagsMembers
| AnotherPluginAPIFlags Int
deriving (Int -> PluginAPIFlags -> ShowS
[PluginAPIFlags] -> ShowS
PluginAPIFlags -> String
(Int -> PluginAPIFlags -> ShowS)
-> (PluginAPIFlags -> String)
-> ([PluginAPIFlags] -> ShowS)
-> Show PluginAPIFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PluginAPIFlags -> ShowS
showsPrec :: Int -> PluginAPIFlags -> ShowS
$cshow :: PluginAPIFlags -> String
show :: PluginAPIFlags -> String
$cshowList :: [PluginAPIFlags] -> ShowS
showList :: [PluginAPIFlags] -> ShowS
Show, PluginAPIFlags -> PluginAPIFlags -> Bool
(PluginAPIFlags -> PluginAPIFlags -> Bool)
-> (PluginAPIFlags -> PluginAPIFlags -> Bool) -> Eq PluginAPIFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PluginAPIFlags -> PluginAPIFlags -> Bool
== :: PluginAPIFlags -> PluginAPIFlags -> Bool
$c/= :: PluginAPIFlags -> PluginAPIFlags -> Bool
/= :: PluginAPIFlags -> PluginAPIFlags -> Bool
Eq)
instance P.Enum PluginAPIFlags where
fromEnum :: PluginAPIFlags -> Int
fromEnum PluginAPIFlags
PluginAPIFlagsMembers = Int
1
fromEnum (AnotherPluginAPIFlags Int
k) = Int
k
toEnum :: Int -> PluginAPIFlags
toEnum Int
1 = PluginAPIFlags
PluginAPIFlagsMembers
toEnum Int
k = Int -> PluginAPIFlags
AnotherPluginAPIFlags Int
k
instance P.Ord PluginAPIFlags where
compare :: PluginAPIFlags -> PluginAPIFlags -> Ordering
compare PluginAPIFlags
a PluginAPIFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PluginAPIFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum PluginAPIFlags
a) (PluginAPIFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum PluginAPIFlags
b)
type instance O.ParentTypes PluginAPIFlags = '[]
instance O.HasParentTypes PluginAPIFlags
foreign import ccall "gst_plugin_api_flags_get_type" c_gst_plugin_api_flags_get_type ::
IO GType
instance B.Types.TypedObject PluginAPIFlags where
glibType :: IO GType
glibType = IO GType
c_gst_plugin_api_flags_get_type
instance B.Types.BoxedFlags PluginAPIFlags
instance IsGFlag PluginAPIFlags
data PipelineFlags =
PipelineFlagsFixedClock
| PipelineFlagsLast
| AnotherPipelineFlags Int
deriving (Int -> PipelineFlags -> ShowS
[PipelineFlags] -> ShowS
PipelineFlags -> String
(Int -> PipelineFlags -> ShowS)
-> (PipelineFlags -> String)
-> ([PipelineFlags] -> ShowS)
-> Show PipelineFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PipelineFlags -> ShowS
showsPrec :: Int -> PipelineFlags -> ShowS
$cshow :: PipelineFlags -> String
show :: PipelineFlags -> String
$cshowList :: [PipelineFlags] -> ShowS
showList :: [PipelineFlags] -> ShowS
Show, PipelineFlags -> PipelineFlags -> Bool
(PipelineFlags -> PipelineFlags -> Bool)
-> (PipelineFlags -> PipelineFlags -> Bool) -> Eq PipelineFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PipelineFlags -> PipelineFlags -> Bool
== :: PipelineFlags -> PipelineFlags -> Bool
$c/= :: PipelineFlags -> PipelineFlags -> Bool
/= :: PipelineFlags -> PipelineFlags -> Bool
Eq)
instance P.Enum PipelineFlags where
fromEnum :: PipelineFlags -> Int
fromEnum PipelineFlags
PipelineFlagsFixedClock = Int
524288
fromEnum PipelineFlags
PipelineFlagsLast = Int
8388608
fromEnum (AnotherPipelineFlags Int
k) = Int
k
toEnum :: Int -> PipelineFlags
toEnum Int
524288 = PipelineFlags
PipelineFlagsFixedClock
toEnum Int
8388608 = PipelineFlags
PipelineFlagsLast
toEnum Int
k = Int -> PipelineFlags
AnotherPipelineFlags Int
k
instance P.Ord PipelineFlags where
compare :: PipelineFlags -> PipelineFlags -> Ordering
compare PipelineFlags
a PipelineFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PipelineFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum PipelineFlags
a) (PipelineFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum PipelineFlags
b)
type instance O.ParentTypes PipelineFlags = '[]
instance O.HasParentTypes PipelineFlags
foreign import ccall "gst_pipeline_flags_get_type" c_gst_pipeline_flags_get_type ::
IO GType
instance B.Types.TypedObject PipelineFlags where
glibType :: IO GType
glibType = IO GType
c_gst_pipeline_flags_get_type
instance B.Types.BoxedFlags PipelineFlags
instance IsGFlag PipelineFlags
data ParseFlags =
ParseFlagsNone
| ParseFlagsFatalErrors
| ParseFlagsNoSingleElementBins
| ParseFlagsPlaceInBin
| AnotherParseFlags Int
deriving (Int -> ParseFlags -> ShowS
[ParseFlags] -> ShowS
ParseFlags -> String
(Int -> ParseFlags -> ShowS)
-> (ParseFlags -> String)
-> ([ParseFlags] -> ShowS)
-> Show ParseFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ParseFlags -> ShowS
showsPrec :: Int -> ParseFlags -> ShowS
$cshow :: ParseFlags -> String
show :: ParseFlags -> String
$cshowList :: [ParseFlags] -> ShowS
showList :: [ParseFlags] -> ShowS
Show, ParseFlags -> ParseFlags -> Bool
(ParseFlags -> ParseFlags -> Bool)
-> (ParseFlags -> ParseFlags -> Bool) -> Eq ParseFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ParseFlags -> ParseFlags -> Bool
== :: ParseFlags -> ParseFlags -> Bool
$c/= :: ParseFlags -> ParseFlags -> Bool
/= :: ParseFlags -> ParseFlags -> Bool
Eq)
instance P.Enum ParseFlags where
fromEnum :: ParseFlags -> Int
fromEnum ParseFlags
ParseFlagsNone = Int
0
fromEnum ParseFlags
ParseFlagsFatalErrors = Int
1
fromEnum ParseFlags
ParseFlagsNoSingleElementBins = Int
2
fromEnum ParseFlags
ParseFlagsPlaceInBin = Int
4
fromEnum (AnotherParseFlags Int
k) = Int
k
toEnum :: Int -> ParseFlags
toEnum Int
0 = ParseFlags
ParseFlagsNone
toEnum Int
1 = ParseFlags
ParseFlagsFatalErrors
toEnum Int
2 = ParseFlags
ParseFlagsNoSingleElementBins
toEnum Int
4 = ParseFlags
ParseFlagsPlaceInBin
toEnum Int
k = Int -> ParseFlags
AnotherParseFlags Int
k
instance P.Ord ParseFlags where
compare :: ParseFlags -> ParseFlags -> Ordering
compare ParseFlags
a ParseFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ParseFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum ParseFlags
a) (ParseFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum ParseFlags
b)
type instance O.ParentTypes ParseFlags = '[]
instance O.HasParentTypes ParseFlags
foreign import ccall "gst_parse_flags_get_type" c_gst_parse_flags_get_type ::
IO GType
instance B.Types.TypedObject ParseFlags where
glibType :: IO GType
glibType = IO GType
c_gst_parse_flags_get_type
instance B.Types.BoxedFlags ParseFlags
instance IsGFlag ParseFlags
data PadTemplateFlags =
PadTemplateFlagsLast
| AnotherPadTemplateFlags Int
deriving (Int -> PadTemplateFlags -> ShowS
[PadTemplateFlags] -> ShowS
PadTemplateFlags -> String
(Int -> PadTemplateFlags -> ShowS)
-> (PadTemplateFlags -> String)
-> ([PadTemplateFlags] -> ShowS)
-> Show PadTemplateFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PadTemplateFlags -> ShowS
showsPrec :: Int -> PadTemplateFlags -> ShowS
$cshow :: PadTemplateFlags -> String
show :: PadTemplateFlags -> String
$cshowList :: [PadTemplateFlags] -> ShowS
showList :: [PadTemplateFlags] -> ShowS
Show, PadTemplateFlags -> PadTemplateFlags -> Bool
(PadTemplateFlags -> PadTemplateFlags -> Bool)
-> (PadTemplateFlags -> PadTemplateFlags -> Bool)
-> Eq PadTemplateFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PadTemplateFlags -> PadTemplateFlags -> Bool
== :: PadTemplateFlags -> PadTemplateFlags -> Bool
$c/= :: PadTemplateFlags -> PadTemplateFlags -> Bool
/= :: PadTemplateFlags -> PadTemplateFlags -> Bool
Eq)
instance P.Enum PadTemplateFlags where
fromEnum :: PadTemplateFlags -> Int
fromEnum PadTemplateFlags
PadTemplateFlagsLast = Int
256
fromEnum (AnotherPadTemplateFlags Int
k) = Int
k
toEnum :: Int -> PadTemplateFlags
toEnum Int
256 = PadTemplateFlags
PadTemplateFlagsLast
toEnum Int
k = Int -> PadTemplateFlags
AnotherPadTemplateFlags Int
k
instance P.Ord PadTemplateFlags where
compare :: PadTemplateFlags -> PadTemplateFlags -> Ordering
compare PadTemplateFlags
a PadTemplateFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PadTemplateFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum PadTemplateFlags
a) (PadTemplateFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum PadTemplateFlags
b)
type instance O.ParentTypes PadTemplateFlags = '[]
instance O.HasParentTypes PadTemplateFlags
foreign import ccall "gst_pad_template_flags_get_type" c_gst_pad_template_flags_get_type ::
IO GType
instance B.Types.TypedObject PadTemplateFlags where
glibType :: IO GType
glibType = IO GType
c_gst_pad_template_flags_get_type
instance B.Types.BoxedFlags PadTemplateFlags
instance IsGFlag PadTemplateFlags
data PadProbeType =
PadProbeTypeInvalid
| PadProbeTypeIdle
| PadProbeTypeBlock
| PadProbeTypeBuffer
| PadProbeTypeBufferList
| PadProbeTypeEventDownstream
| PadProbeTypeEventUpstream
| PadProbeTypeEventFlush
| PadProbeTypeQueryDownstream
| PadProbeTypeQueryUpstream
| PadProbeTypePush
| PadProbeTypePull
| PadProbeTypeBlocking
| PadProbeTypeDataDownstream
| PadProbeTypeDataUpstream
| PadProbeTypeDataBoth
| PadProbeTypeBlockDownstream
| PadProbeTypeBlockUpstream
| PadProbeTypeEventBoth
| PadProbeTypeQueryBoth
| PadProbeTypeAllBoth
| PadProbeTypeScheduling
| AnotherPadProbeType Int
deriving (Int -> PadProbeType -> ShowS
[PadProbeType] -> ShowS
PadProbeType -> String
(Int -> PadProbeType -> ShowS)
-> (PadProbeType -> String)
-> ([PadProbeType] -> ShowS)
-> Show PadProbeType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PadProbeType -> ShowS
showsPrec :: Int -> PadProbeType -> ShowS
$cshow :: PadProbeType -> String
show :: PadProbeType -> String
$cshowList :: [PadProbeType] -> ShowS
showList :: [PadProbeType] -> ShowS
Show, PadProbeType -> PadProbeType -> Bool
(PadProbeType -> PadProbeType -> Bool)
-> (PadProbeType -> PadProbeType -> Bool) -> Eq PadProbeType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PadProbeType -> PadProbeType -> Bool
== :: PadProbeType -> PadProbeType -> Bool
$c/= :: PadProbeType -> PadProbeType -> Bool
/= :: PadProbeType -> PadProbeType -> Bool
Eq)
instance P.Enum PadProbeType where
fromEnum :: PadProbeType -> Int
fromEnum PadProbeType
PadProbeTypeInvalid = Int
0
fromEnum PadProbeType
PadProbeTypeIdle = Int
1
fromEnum PadProbeType
PadProbeTypeBlock = Int
2
fromEnum PadProbeType
PadProbeTypeBuffer = Int
16
fromEnum PadProbeType
PadProbeTypeBufferList = Int
32
fromEnum PadProbeType
PadProbeTypeEventDownstream = Int
64
fromEnum PadProbeType
PadProbeTypeEventUpstream = Int
128
fromEnum PadProbeType
PadProbeTypeEventFlush = Int
256
fromEnum PadProbeType
PadProbeTypeQueryDownstream = Int
512
fromEnum PadProbeType
PadProbeTypeQueryUpstream = Int
1024
fromEnum PadProbeType
PadProbeTypePush = Int
4096
fromEnum PadProbeType
PadProbeTypePull = Int
8192
fromEnum PadProbeType
PadProbeTypeBlocking = Int
3
fromEnum PadProbeType
PadProbeTypeDataDownstream = Int
112
fromEnum PadProbeType
PadProbeTypeDataUpstream = Int
128
fromEnum PadProbeType
PadProbeTypeDataBoth = Int
240
fromEnum PadProbeType
PadProbeTypeBlockDownstream = Int
114
fromEnum PadProbeType
PadProbeTypeBlockUpstream = Int
130
fromEnum PadProbeType
PadProbeTypeEventBoth = Int
192
fromEnum PadProbeType
PadProbeTypeQueryBoth = Int
1536
fromEnum PadProbeType
PadProbeTypeAllBoth = Int
1776
fromEnum PadProbeType
PadProbeTypeScheduling = Int
12288
fromEnum (AnotherPadProbeType Int
k) = Int
k
toEnum :: Int -> PadProbeType
toEnum Int
0 = PadProbeType
PadProbeTypeInvalid
toEnum Int
1 = PadProbeType
PadProbeTypeIdle
toEnum Int
2 = PadProbeType
PadProbeTypeBlock
toEnum Int
16 = PadProbeType
PadProbeTypeBuffer
toEnum Int
32 = PadProbeType
PadProbeTypeBufferList
toEnum Int
64 = PadProbeType
PadProbeTypeEventDownstream
toEnum Int
128 = PadProbeType
PadProbeTypeEventUpstream
toEnum Int
256 = PadProbeType
PadProbeTypeEventFlush
toEnum Int
512 = PadProbeType
PadProbeTypeQueryDownstream
toEnum Int
1024 = PadProbeType
PadProbeTypeQueryUpstream
toEnum Int
4096 = PadProbeType
PadProbeTypePush
toEnum Int
8192 = PadProbeType
PadProbeTypePull
toEnum Int
3 = PadProbeType
PadProbeTypeBlocking
toEnum Int
112 = PadProbeType
PadProbeTypeDataDownstream
toEnum Int
240 = PadProbeType
PadProbeTypeDataBoth
toEnum Int
114 = PadProbeType
PadProbeTypeBlockDownstream
toEnum Int
130 = PadProbeType
PadProbeTypeBlockUpstream
toEnum Int
192 = PadProbeType
PadProbeTypeEventBoth
toEnum Int
1536 = PadProbeType
PadProbeTypeQueryBoth
toEnum Int
1776 = PadProbeType
PadProbeTypeAllBoth
toEnum Int
12288 = PadProbeType
PadProbeTypeScheduling
toEnum Int
k = Int -> PadProbeType
AnotherPadProbeType Int
k
instance P.Ord PadProbeType where
compare :: PadProbeType -> PadProbeType -> Ordering
compare PadProbeType
a PadProbeType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PadProbeType -> Int
forall a. Enum a => a -> Int
P.fromEnum PadProbeType
a) (PadProbeType -> Int
forall a. Enum a => a -> Int
P.fromEnum PadProbeType
b)
type instance O.ParentTypes PadProbeType = '[]
instance O.HasParentTypes PadProbeType
foreign import ccall "gst_pad_probe_type_get_type" c_gst_pad_probe_type_get_type ::
IO GType
instance B.Types.TypedObject PadProbeType where
glibType :: IO GType
glibType = IO GType
c_gst_pad_probe_type_get_type
instance B.Types.BoxedFlags PadProbeType
instance IsGFlag PadProbeType
data PadLinkCheck =
PadLinkCheckNothing
| PadLinkCheckHierarchy
| PadLinkCheckTemplateCaps
| PadLinkCheckCaps
| PadLinkCheckNoReconfigure
| PadLinkCheckDefault
| AnotherPadLinkCheck Int
deriving (Int -> PadLinkCheck -> ShowS
[PadLinkCheck] -> ShowS
PadLinkCheck -> String
(Int -> PadLinkCheck -> ShowS)
-> (PadLinkCheck -> String)
-> ([PadLinkCheck] -> ShowS)
-> Show PadLinkCheck
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PadLinkCheck -> ShowS
showsPrec :: Int -> PadLinkCheck -> ShowS
$cshow :: PadLinkCheck -> String
show :: PadLinkCheck -> String
$cshowList :: [PadLinkCheck] -> ShowS
showList :: [PadLinkCheck] -> ShowS
Show, PadLinkCheck -> PadLinkCheck -> Bool
(PadLinkCheck -> PadLinkCheck -> Bool)
-> (PadLinkCheck -> PadLinkCheck -> Bool) -> Eq PadLinkCheck
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PadLinkCheck -> PadLinkCheck -> Bool
== :: PadLinkCheck -> PadLinkCheck -> Bool
$c/= :: PadLinkCheck -> PadLinkCheck -> Bool
/= :: PadLinkCheck -> PadLinkCheck -> Bool
Eq)
instance P.Enum PadLinkCheck where
fromEnum :: PadLinkCheck -> Int
fromEnum PadLinkCheck
PadLinkCheckNothing = Int
0
fromEnum PadLinkCheck
PadLinkCheckHierarchy = Int
1
fromEnum PadLinkCheck
PadLinkCheckTemplateCaps = Int
2
fromEnum PadLinkCheck
PadLinkCheckCaps = Int
4
fromEnum PadLinkCheck
PadLinkCheckNoReconfigure = Int
8
fromEnum PadLinkCheck
PadLinkCheckDefault = Int
5
fromEnum (AnotherPadLinkCheck Int
k) = Int
k
toEnum :: Int -> PadLinkCheck
toEnum Int
0 = PadLinkCheck
PadLinkCheckNothing
toEnum Int
1 = PadLinkCheck
PadLinkCheckHierarchy
toEnum Int
2 = PadLinkCheck
PadLinkCheckTemplateCaps
toEnum Int
4 = PadLinkCheck
PadLinkCheckCaps
toEnum Int
8 = PadLinkCheck
PadLinkCheckNoReconfigure
toEnum Int
5 = PadLinkCheck
PadLinkCheckDefault
toEnum Int
k = Int -> PadLinkCheck
AnotherPadLinkCheck Int
k
instance P.Ord PadLinkCheck where
compare :: PadLinkCheck -> PadLinkCheck -> Ordering
compare PadLinkCheck
a PadLinkCheck
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PadLinkCheck -> Int
forall a. Enum a => a -> Int
P.fromEnum PadLinkCheck
a) (PadLinkCheck -> Int
forall a. Enum a => a -> Int
P.fromEnum PadLinkCheck
b)
type instance O.ParentTypes PadLinkCheck = '[]
instance O.HasParentTypes PadLinkCheck
foreign import ccall "gst_pad_link_check_get_type" c_gst_pad_link_check_get_type ::
IO GType
instance B.Types.TypedObject PadLinkCheck where
glibType :: IO GType
glibType = IO GType
c_gst_pad_link_check_get_type
instance B.Types.BoxedFlags PadLinkCheck
instance IsGFlag PadLinkCheck
data PadFlags =
PadFlagsBlocked
| PadFlagsFlushing
| PadFlagsEos
| PadFlagsBlocking
| PadFlagsNeedParent
| PadFlagsNeedReconfigure
| PadFlagsPendingEvents
| PadFlagsFixedCaps
| PadFlagsProxyCaps
| PadFlagsProxyAllocation
| PadFlagsProxyScheduling
| PadFlagsAcceptIntersect
| PadFlagsAcceptTemplate
| PadFlagsLast
| AnotherPadFlags Int
deriving (Int -> PadFlags -> ShowS
[PadFlags] -> ShowS
PadFlags -> String
(Int -> PadFlags -> ShowS)
-> (PadFlags -> String) -> ([PadFlags] -> ShowS) -> Show PadFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PadFlags -> ShowS
showsPrec :: Int -> PadFlags -> ShowS
$cshow :: PadFlags -> String
show :: PadFlags -> String
$cshowList :: [PadFlags] -> ShowS
showList :: [PadFlags] -> ShowS
Show, PadFlags -> PadFlags -> Bool
(PadFlags -> PadFlags -> Bool)
-> (PadFlags -> PadFlags -> Bool) -> Eq PadFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PadFlags -> PadFlags -> Bool
== :: PadFlags -> PadFlags -> Bool
$c/= :: PadFlags -> PadFlags -> Bool
/= :: PadFlags -> PadFlags -> Bool
Eq)
instance P.Enum PadFlags where
fromEnum :: PadFlags -> Int
fromEnum PadFlags
PadFlagsBlocked = Int
16
fromEnum PadFlags
PadFlagsFlushing = Int
32
fromEnum PadFlags
PadFlagsEos = Int
64
fromEnum PadFlags
PadFlagsBlocking = Int
128
fromEnum PadFlags
PadFlagsNeedParent = Int
256
fromEnum PadFlags
PadFlagsNeedReconfigure = Int
512
fromEnum PadFlags
PadFlagsPendingEvents = Int
1024
fromEnum PadFlags
PadFlagsFixedCaps = Int
2048
fromEnum PadFlags
PadFlagsProxyCaps = Int
4096
fromEnum PadFlags
PadFlagsProxyAllocation = Int
8192
fromEnum PadFlags
PadFlagsProxyScheduling = Int
16384
fromEnum PadFlags
PadFlagsAcceptIntersect = Int
32768
fromEnum PadFlags
PadFlagsAcceptTemplate = Int
65536
fromEnum PadFlags
PadFlagsLast = Int
1048576
fromEnum (AnotherPadFlags Int
k) = Int
k
toEnum :: Int -> PadFlags
toEnum Int
16 = PadFlags
PadFlagsBlocked
toEnum Int
32 = PadFlags
PadFlagsFlushing
toEnum Int
64 = PadFlags
PadFlagsEos
toEnum Int
128 = PadFlags
PadFlagsBlocking
toEnum Int
256 = PadFlags
PadFlagsNeedParent
toEnum Int
512 = PadFlags
PadFlagsNeedReconfigure
toEnum Int
1024 = PadFlags
PadFlagsPendingEvents
toEnum Int
2048 = PadFlags
PadFlagsFixedCaps
toEnum Int
4096 = PadFlags
PadFlagsProxyCaps
toEnum Int
8192 = PadFlags
PadFlagsProxyAllocation
toEnum Int
16384 = PadFlags
PadFlagsProxyScheduling
toEnum Int
32768 = PadFlags
PadFlagsAcceptIntersect
toEnum Int
65536 = PadFlags
PadFlagsAcceptTemplate
toEnum Int
1048576 = PadFlags
PadFlagsLast
toEnum Int
k = Int -> PadFlags
AnotherPadFlags Int
k
instance P.Ord PadFlags where
compare :: PadFlags -> PadFlags -> Ordering
compare PadFlags
a PadFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PadFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum PadFlags
a) (PadFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum PadFlags
b)
type instance O.ParentTypes PadFlags = '[]
instance O.HasParentTypes PadFlags
foreign import ccall "gst_pad_flags_get_type" c_gst_pad_flags_get_type ::
IO GType
instance B.Types.TypedObject PadFlags where
glibType :: IO GType
glibType = IO GType
c_gst_pad_flags_get_type
instance B.Types.BoxedFlags PadFlags
instance IsGFlag PadFlags
data ObjectFlags =
ObjectFlagsMayBeLeaked
| ObjectFlagsLast
| AnotherObjectFlags Int
deriving (Int -> ObjectFlags -> ShowS
[ObjectFlags] -> ShowS
ObjectFlags -> String
(Int -> ObjectFlags -> ShowS)
-> (ObjectFlags -> String)
-> ([ObjectFlags] -> ShowS)
-> Show ObjectFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ObjectFlags -> ShowS
showsPrec :: Int -> ObjectFlags -> ShowS
$cshow :: ObjectFlags -> String
show :: ObjectFlags -> String
$cshowList :: [ObjectFlags] -> ShowS
showList :: [ObjectFlags] -> ShowS
Show, ObjectFlags -> ObjectFlags -> Bool
(ObjectFlags -> ObjectFlags -> Bool)
-> (ObjectFlags -> ObjectFlags -> Bool) -> Eq ObjectFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ObjectFlags -> ObjectFlags -> Bool
== :: ObjectFlags -> ObjectFlags -> Bool
$c/= :: ObjectFlags -> ObjectFlags -> Bool
/= :: ObjectFlags -> ObjectFlags -> Bool
Eq)
instance P.Enum ObjectFlags where
fromEnum :: ObjectFlags -> Int
fromEnum ObjectFlags
ObjectFlagsMayBeLeaked = Int
1
fromEnum ObjectFlags
ObjectFlagsLast = Int
16
fromEnum (AnotherObjectFlags Int
k) = Int
k
toEnum :: Int -> ObjectFlags
toEnum Int
1 = ObjectFlags
ObjectFlagsMayBeLeaked
toEnum Int
16 = ObjectFlags
ObjectFlagsLast
toEnum Int
k = Int -> ObjectFlags
AnotherObjectFlags Int
k
instance P.Ord ObjectFlags where
compare :: ObjectFlags -> ObjectFlags -> Ordering
compare ObjectFlags
a ObjectFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ObjectFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum ObjectFlags
a) (ObjectFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum ObjectFlags
b)
type instance O.ParentTypes ObjectFlags = '[]
instance O.HasParentTypes ObjectFlags
foreign import ccall "gst_object_flags_get_type" c_gst_object_flags_get_type ::
IO GType
instance B.Types.TypedObject ObjectFlags where
glibType :: IO GType
glibType = IO GType
c_gst_object_flags_get_type
instance B.Types.BoxedFlags ObjectFlags
instance IsGFlag ObjectFlags
data MiniObjectFlags =
MiniObjectFlagsLockable
| MiniObjectFlagsLockReadonly
| MiniObjectFlagsMayBeLeaked
| MiniObjectFlagsLast
| AnotherMiniObjectFlags Int
deriving (Int -> MiniObjectFlags -> ShowS
[MiniObjectFlags] -> ShowS
MiniObjectFlags -> String
(Int -> MiniObjectFlags -> ShowS)
-> (MiniObjectFlags -> String)
-> ([MiniObjectFlags] -> ShowS)
-> Show MiniObjectFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MiniObjectFlags -> ShowS
showsPrec :: Int -> MiniObjectFlags -> ShowS
$cshow :: MiniObjectFlags -> String
show :: MiniObjectFlags -> String
$cshowList :: [MiniObjectFlags] -> ShowS
showList :: [MiniObjectFlags] -> ShowS
Show, MiniObjectFlags -> MiniObjectFlags -> Bool
(MiniObjectFlags -> MiniObjectFlags -> Bool)
-> (MiniObjectFlags -> MiniObjectFlags -> Bool)
-> Eq MiniObjectFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MiniObjectFlags -> MiniObjectFlags -> Bool
== :: MiniObjectFlags -> MiniObjectFlags -> Bool
$c/= :: MiniObjectFlags -> MiniObjectFlags -> Bool
/= :: MiniObjectFlags -> MiniObjectFlags -> Bool
Eq)
instance P.Enum MiniObjectFlags where
fromEnum :: MiniObjectFlags -> Int
fromEnum MiniObjectFlags
MiniObjectFlagsLockable = Int
1
fromEnum MiniObjectFlags
MiniObjectFlagsLockReadonly = Int
2
fromEnum MiniObjectFlags
MiniObjectFlagsMayBeLeaked = Int
4
fromEnum MiniObjectFlags
MiniObjectFlagsLast = Int
16
fromEnum (AnotherMiniObjectFlags Int
k) = Int
k
toEnum :: Int -> MiniObjectFlags
toEnum Int
1 = MiniObjectFlags
MiniObjectFlagsLockable
toEnum Int
2 = MiniObjectFlags
MiniObjectFlagsLockReadonly
toEnum Int
4 = MiniObjectFlags
MiniObjectFlagsMayBeLeaked
toEnum Int
16 = MiniObjectFlags
MiniObjectFlagsLast
toEnum Int
k = Int -> MiniObjectFlags
AnotherMiniObjectFlags Int
k
instance P.Ord MiniObjectFlags where
compare :: MiniObjectFlags -> MiniObjectFlags -> Ordering
compare MiniObjectFlags
a MiniObjectFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (MiniObjectFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum MiniObjectFlags
a) (MiniObjectFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum MiniObjectFlags
b)
type instance O.ParentTypes MiniObjectFlags = '[]
instance O.HasParentTypes MiniObjectFlags
foreign import ccall "gst_mini_object_flags_get_type" c_gst_mini_object_flags_get_type ::
IO GType
instance B.Types.TypedObject MiniObjectFlags where
glibType :: IO GType
glibType = IO GType
c_gst_mini_object_flags_get_type
instance B.Types.BoxedFlags MiniObjectFlags
instance IsGFlag MiniObjectFlags
data MetaFlags =
MetaFlagsNone
| MetaFlagsReadonly
| MetaFlagsPooled
| MetaFlagsLocked
| MetaFlagsLast
| AnotherMetaFlags Int
deriving (Int -> MetaFlags -> ShowS
[MetaFlags] -> ShowS
MetaFlags -> String
(Int -> MetaFlags -> ShowS)
-> (MetaFlags -> String)
-> ([MetaFlags] -> ShowS)
-> Show MetaFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MetaFlags -> ShowS
showsPrec :: Int -> MetaFlags -> ShowS
$cshow :: MetaFlags -> String
show :: MetaFlags -> String
$cshowList :: [MetaFlags] -> ShowS
showList :: [MetaFlags] -> ShowS
Show, MetaFlags -> MetaFlags -> Bool
(MetaFlags -> MetaFlags -> Bool)
-> (MetaFlags -> MetaFlags -> Bool) -> Eq MetaFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MetaFlags -> MetaFlags -> Bool
== :: MetaFlags -> MetaFlags -> Bool
$c/= :: MetaFlags -> MetaFlags -> Bool
/= :: MetaFlags -> MetaFlags -> Bool
Eq)
instance P.Enum MetaFlags where
fromEnum :: MetaFlags -> Int
fromEnum MetaFlags
MetaFlagsNone = Int
0
fromEnum MetaFlags
MetaFlagsReadonly = Int
1
fromEnum MetaFlags
MetaFlagsPooled = Int
2
fromEnum MetaFlags
MetaFlagsLocked = Int
4
fromEnum MetaFlags
MetaFlagsLast = Int
65536
fromEnum (AnotherMetaFlags Int
k) = Int
k
toEnum :: Int -> MetaFlags
toEnum Int
0 = MetaFlags
MetaFlagsNone
toEnum Int
1 = MetaFlags
MetaFlagsReadonly
toEnum Int
2 = MetaFlags
MetaFlagsPooled
toEnum Int
4 = MetaFlags
MetaFlagsLocked
toEnum Int
65536 = MetaFlags
MetaFlagsLast
toEnum Int
k = Int -> MetaFlags
AnotherMetaFlags Int
k
instance P.Ord MetaFlags where
compare :: MetaFlags -> MetaFlags -> Ordering
compare MetaFlags
a MetaFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (MetaFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum MetaFlags
a) (MetaFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum MetaFlags
b)
type instance O.ParentTypes MetaFlags = '[]
instance O.HasParentTypes MetaFlags
foreign import ccall "gst_meta_flags_get_type" c_gst_meta_flags_get_type ::
IO GType
instance B.Types.TypedObject MetaFlags where
glibType :: IO GType
glibType = IO GType
c_gst_meta_flags_get_type
instance B.Types.BoxedFlags MetaFlags
instance IsGFlag MetaFlags
data MessageType =
MessageTypeUnknown
| MessageTypeEos
| MessageTypeError
| MessageTypeWarning
| MessageTypeInfo
| MessageTypeTag
| MessageTypeBuffering
| MessageTypeStateChanged
| MessageTypeStateDirty
| MessageTypeStepDone
| MessageTypeClockProvide
| MessageTypeClockLost
| MessageTypeNewClock
| MessageTypeStructureChange
| MessageTypeStreamStatus
| MessageTypeApplication
| MessageTypeElement
| MessageTypeSegmentStart
| MessageTypeSegmentDone
| MessageTypeDurationChanged
| MessageTypeLatency
| MessageTypeAsyncStart
| MessageTypeAsyncDone
| MessageTypeRequestState
| MessageTypeStepStart
| MessageTypeQos
| MessageTypeProgress
| MessageTypeToc
| MessageTypeResetTime
| MessageTypeStreamStart
| MessageTypeNeedContext
| MessageTypeHaveContext
| MessageTypeExtended
| MessageTypeDeviceAdded
| MessageTypeDeviceRemoved
| MessageTypePropertyNotify
| MessageTypeStreamCollection
| MessageTypeStreamsSelected
| MessageTypeRedirect
| MessageTypeDeviceChanged
| MessageTypeInstantRateRequest
| MessageTypeAny
| AnotherMessageType Int
deriving (Int -> MessageType -> ShowS
[MessageType] -> ShowS
MessageType -> String
(Int -> MessageType -> ShowS)
-> (MessageType -> String)
-> ([MessageType] -> ShowS)
-> Show MessageType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MessageType -> ShowS
showsPrec :: Int -> MessageType -> ShowS
$cshow :: MessageType -> String
show :: MessageType -> String
$cshowList :: [MessageType] -> ShowS
showList :: [MessageType] -> ShowS
Show, MessageType -> MessageType -> Bool
(MessageType -> MessageType -> Bool)
-> (MessageType -> MessageType -> Bool) -> Eq MessageType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MessageType -> MessageType -> Bool
== :: MessageType -> MessageType -> Bool
$c/= :: MessageType -> MessageType -> Bool
/= :: MessageType -> MessageType -> Bool
Eq)
instance P.Enum MessageType where
fromEnum :: MessageType -> Int
fromEnum MessageType
MessageTypeUnknown = Int
0
fromEnum MessageType
MessageTypeEos = Int
1
fromEnum MessageType
MessageTypeError = Int
2
fromEnum MessageType
MessageTypeWarning = Int
4
fromEnum MessageType
MessageTypeInfo = Int
8
fromEnum MessageType
MessageTypeTag = Int
16
fromEnum MessageType
MessageTypeBuffering = Int
32
fromEnum MessageType
MessageTypeStateChanged = Int
64
fromEnum MessageType
MessageTypeStateDirty = Int
128
fromEnum MessageType
MessageTypeStepDone = Int
256
fromEnum MessageType
MessageTypeClockProvide = Int
512
fromEnum MessageType
MessageTypeClockLost = Int
1024
fromEnum MessageType
MessageTypeNewClock = Int
2048
fromEnum MessageType
MessageTypeStructureChange = Int
4096
fromEnum MessageType
MessageTypeStreamStatus = Int
8192
fromEnum MessageType
MessageTypeApplication = Int
16384
fromEnum MessageType
MessageTypeElement = Int
32768
fromEnum MessageType
MessageTypeSegmentStart = Int
65536
fromEnum MessageType
MessageTypeSegmentDone = Int
131072
fromEnum MessageType
MessageTypeDurationChanged = Int
262144
fromEnum MessageType
MessageTypeLatency = Int
524288
fromEnum MessageType
MessageTypeAsyncStart = Int
1048576
fromEnum MessageType
MessageTypeAsyncDone = Int
2097152
fromEnum MessageType
MessageTypeRequestState = Int
4194304
fromEnum MessageType
MessageTypeStepStart = Int
8388608
fromEnum MessageType
MessageTypeQos = Int
16777216
fromEnum MessageType
MessageTypeProgress = Int
33554432
fromEnum MessageType
MessageTypeToc = Int
67108864
fromEnum MessageType
MessageTypeResetTime = Int
134217728
fromEnum MessageType
MessageTypeStreamStart = Int
268435456
fromEnum MessageType
MessageTypeNeedContext = Int
536870912
fromEnum MessageType
MessageTypeHaveContext = Int
1073741824
fromEnum MessageType
MessageTypeExtended = Int
2147483648
fromEnum MessageType
MessageTypeDeviceAdded = Int
2147483649
fromEnum MessageType
MessageTypeDeviceRemoved = Int
2147483650
fromEnum MessageType
MessageTypePropertyNotify = Int
2147483651
fromEnum MessageType
MessageTypeStreamCollection = Int
2147483652
fromEnum MessageType
MessageTypeStreamsSelected = Int
2147483653
fromEnum MessageType
MessageTypeRedirect = Int
2147483654
fromEnum MessageType
MessageTypeDeviceChanged = Int
2147483655
fromEnum MessageType
MessageTypeInstantRateRequest = Int
2147483656
fromEnum MessageType
MessageTypeAny = Int
4294967295
fromEnum (AnotherMessageType Int
k) = Int
k
toEnum :: Int -> MessageType
toEnum Int
0 = MessageType
MessageTypeUnknown
toEnum Int
1 = MessageType
MessageTypeEos
toEnum Int
2 = MessageType
MessageTypeError
toEnum Int
4 = MessageType
MessageTypeWarning
toEnum Int
8 = MessageType
MessageTypeInfo
toEnum Int
16 = MessageType
MessageTypeTag
toEnum Int
32 = MessageType
MessageTypeBuffering
toEnum Int
64 = MessageType
MessageTypeStateChanged
toEnum Int
128 = MessageType
MessageTypeStateDirty
toEnum Int
256 = MessageType
MessageTypeStepDone
toEnum Int
512 = MessageType
MessageTypeClockProvide
toEnum Int
1024 = MessageType
MessageTypeClockLost
toEnum Int
2048 = MessageType
MessageTypeNewClock
toEnum Int
4096 = MessageType
MessageTypeStructureChange
toEnum Int
8192 = MessageType
MessageTypeStreamStatus
toEnum Int
16384 = MessageType
MessageTypeApplication
toEnum Int
32768 = MessageType
MessageTypeElement
toEnum Int
65536 = MessageType
MessageTypeSegmentStart
toEnum Int
131072 = MessageType
MessageTypeSegmentDone
toEnum Int
262144 = MessageType
MessageTypeDurationChanged
toEnum Int
524288 = MessageType
MessageTypeLatency
toEnum Int
1048576 = MessageType
MessageTypeAsyncStart
toEnum Int
2097152 = MessageType
MessageTypeAsyncDone
toEnum Int
4194304 = MessageType
MessageTypeRequestState
toEnum Int
8388608 = MessageType
MessageTypeStepStart
toEnum Int
16777216 = MessageType
MessageTypeQos
toEnum Int
33554432 = MessageType
MessageTypeProgress
toEnum Int
67108864 = MessageType
MessageTypeToc
toEnum Int
134217728 = MessageType
MessageTypeResetTime
toEnum Int
268435456 = MessageType
MessageTypeStreamStart
toEnum Int
536870912 = MessageType
MessageTypeNeedContext
toEnum Int
1073741824 = MessageType
MessageTypeHaveContext
toEnum Int
2147483648 = MessageType
MessageTypeExtended
toEnum Int
2147483649 = MessageType
MessageTypeDeviceAdded
toEnum Int
2147483650 = MessageType
MessageTypeDeviceRemoved
toEnum Int
2147483651 = MessageType
MessageTypePropertyNotify
toEnum Int
2147483652 = MessageType
MessageTypeStreamCollection
toEnum Int
2147483653 = MessageType
MessageTypeStreamsSelected
toEnum Int
2147483654 = MessageType
MessageTypeRedirect
toEnum Int
2147483655 = MessageType
MessageTypeDeviceChanged
toEnum Int
2147483656 = MessageType
MessageTypeInstantRateRequest
toEnum Int
4294967295 = MessageType
MessageTypeAny
toEnum Int
k = Int -> MessageType
AnotherMessageType Int
k
instance P.Ord MessageType where
compare :: MessageType -> MessageType -> Ordering
compare MessageType
a MessageType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (MessageType -> Int
forall a. Enum a => a -> Int
P.fromEnum MessageType
a) (MessageType -> Int
forall a. Enum a => a -> Int
P.fromEnum MessageType
b)
type instance O.ParentTypes MessageType = '[]
instance O.HasParentTypes MessageType
foreign import ccall "gst_message_type_get_type" c_gst_message_type_get_type ::
IO GType
instance B.Types.TypedObject MessageType where
glibType :: IO GType
glibType = IO GType
c_gst_message_type_get_type
instance B.Types.BoxedFlags MessageType
instance IsGFlag MessageType
data MemoryFlags =
MemoryFlagsReadonly
| MemoryFlagsNoShare
| MemoryFlagsZeroPrefixed
| MemoryFlagsZeroPadded
| MemoryFlagsPhysicallyContiguous
| MemoryFlagsNotMappable
| MemoryFlagsLast
| AnotherMemoryFlags Int
deriving (Int -> MemoryFlags -> ShowS
[MemoryFlags] -> ShowS
MemoryFlags -> String
(Int -> MemoryFlags -> ShowS)
-> (MemoryFlags -> String)
-> ([MemoryFlags] -> ShowS)
-> Show MemoryFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MemoryFlags -> ShowS
showsPrec :: Int -> MemoryFlags -> ShowS
$cshow :: MemoryFlags -> String
show :: MemoryFlags -> String
$cshowList :: [MemoryFlags] -> ShowS
showList :: [MemoryFlags] -> ShowS
Show, MemoryFlags -> MemoryFlags -> Bool
(MemoryFlags -> MemoryFlags -> Bool)
-> (MemoryFlags -> MemoryFlags -> Bool) -> Eq MemoryFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MemoryFlags -> MemoryFlags -> Bool
== :: MemoryFlags -> MemoryFlags -> Bool
$c/= :: MemoryFlags -> MemoryFlags -> Bool
/= :: MemoryFlags -> MemoryFlags -> Bool
Eq)
instance P.Enum MemoryFlags where
fromEnum :: MemoryFlags -> Int
fromEnum MemoryFlags
MemoryFlagsReadonly = Int
2
fromEnum MemoryFlags
MemoryFlagsNoShare = Int
16
fromEnum MemoryFlags
MemoryFlagsZeroPrefixed = Int
32
fromEnum MemoryFlags
MemoryFlagsZeroPadded = Int
64
fromEnum MemoryFlags
MemoryFlagsPhysicallyContiguous = Int
128
fromEnum MemoryFlags
MemoryFlagsNotMappable = Int
256
fromEnum MemoryFlags
MemoryFlagsLast = Int
1048576
fromEnum (AnotherMemoryFlags Int
k) = Int
k
toEnum :: Int -> MemoryFlags
toEnum Int
2 = MemoryFlags
MemoryFlagsReadonly
toEnum Int
16 = MemoryFlags
MemoryFlagsNoShare
toEnum Int
32 = MemoryFlags
MemoryFlagsZeroPrefixed
toEnum Int
64 = MemoryFlags
MemoryFlagsZeroPadded
toEnum Int
128 = MemoryFlags
MemoryFlagsPhysicallyContiguous
toEnum Int
256 = MemoryFlags
MemoryFlagsNotMappable
toEnum Int
1048576 = MemoryFlags
MemoryFlagsLast
toEnum Int
k = Int -> MemoryFlags
AnotherMemoryFlags Int
k
instance P.Ord MemoryFlags where
compare :: MemoryFlags -> MemoryFlags -> Ordering
compare MemoryFlags
a MemoryFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (MemoryFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum MemoryFlags
a) (MemoryFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum MemoryFlags
b)
type instance O.ParentTypes MemoryFlags = '[]
instance O.HasParentTypes MemoryFlags
foreign import ccall "gst_memory_flags_get_type" c_gst_memory_flags_get_type ::
IO GType
instance B.Types.TypedObject MemoryFlags where
glibType :: IO GType
glibType = IO GType
c_gst_memory_flags_get_type
instance B.Types.BoxedFlags MemoryFlags
instance IsGFlag MemoryFlags
data MapFlags =
MapFlagsRead
| MapFlagsWrite
| MapFlagsFlagLast
| AnotherMapFlags Int
deriving (Int -> MapFlags -> ShowS
[MapFlags] -> ShowS
MapFlags -> String
(Int -> MapFlags -> ShowS)
-> (MapFlags -> String) -> ([MapFlags] -> ShowS) -> Show MapFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MapFlags -> ShowS
showsPrec :: Int -> MapFlags -> ShowS
$cshow :: MapFlags -> String
show :: MapFlags -> String
$cshowList :: [MapFlags] -> ShowS
showList :: [MapFlags] -> ShowS
Show, MapFlags -> MapFlags -> Bool
(MapFlags -> MapFlags -> Bool)
-> (MapFlags -> MapFlags -> Bool) -> Eq MapFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MapFlags -> MapFlags -> Bool
== :: MapFlags -> MapFlags -> Bool
$c/= :: MapFlags -> MapFlags -> Bool
/= :: MapFlags -> MapFlags -> Bool
Eq)
instance P.Enum MapFlags where
fromEnum :: MapFlags -> Int
fromEnum MapFlags
MapFlagsRead = Int
1
fromEnum MapFlags
MapFlagsWrite = Int
2
fromEnum MapFlags
MapFlagsFlagLast = Int
65536
fromEnum (AnotherMapFlags Int
k) = Int
k
toEnum :: Int -> MapFlags
toEnum Int
1 = MapFlags
MapFlagsRead
toEnum Int
2 = MapFlags
MapFlagsWrite
toEnum Int
65536 = MapFlags
MapFlagsFlagLast
toEnum Int
k = Int -> MapFlags
AnotherMapFlags Int
k
instance P.Ord MapFlags where
compare :: MapFlags -> MapFlags -> Ordering
compare MapFlags
a MapFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (MapFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum MapFlags
a) (MapFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum MapFlags
b)
type instance O.ParentTypes MapFlags = '[]
instance O.HasParentTypes MapFlags
foreign import ccall "gst_map_flags_get_type" c_gst_map_flags_get_type ::
IO GType
instance B.Types.TypedObject MapFlags where
glibType :: IO GType
glibType = IO GType
c_gst_map_flags_get_type
instance B.Types.BoxedFlags MapFlags
instance IsGFlag MapFlags
data LockFlags =
LockFlagsRead
| LockFlagsWrite
| LockFlagsExclusive
| LockFlagsLast
| AnotherLockFlags Int
deriving (Int -> LockFlags -> ShowS
[LockFlags] -> ShowS
LockFlags -> String
(Int -> LockFlags -> ShowS)
-> (LockFlags -> String)
-> ([LockFlags] -> ShowS)
-> Show LockFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> LockFlags -> ShowS
showsPrec :: Int -> LockFlags -> ShowS
$cshow :: LockFlags -> String
show :: LockFlags -> String
$cshowList :: [LockFlags] -> ShowS
showList :: [LockFlags] -> ShowS
Show, LockFlags -> LockFlags -> Bool
(LockFlags -> LockFlags -> Bool)
-> (LockFlags -> LockFlags -> Bool) -> Eq LockFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: LockFlags -> LockFlags -> Bool
== :: LockFlags -> LockFlags -> Bool
$c/= :: LockFlags -> LockFlags -> Bool
/= :: LockFlags -> LockFlags -> Bool
Eq)
instance P.Enum LockFlags where
fromEnum :: LockFlags -> Int
fromEnum LockFlags
LockFlagsRead = Int
1
fromEnum LockFlags
LockFlagsWrite = Int
2
fromEnum LockFlags
LockFlagsExclusive = Int
4
fromEnum LockFlags
LockFlagsLast = Int
256
fromEnum (AnotherLockFlags Int
k) = Int
k
toEnum :: Int -> LockFlags
toEnum Int
1 = LockFlags
LockFlagsRead
toEnum Int
2 = LockFlags
LockFlagsWrite
toEnum Int
4 = LockFlags
LockFlagsExclusive
toEnum Int
256 = LockFlags
LockFlagsLast
toEnum Int
k = Int -> LockFlags
AnotherLockFlags Int
k
instance P.Ord LockFlags where
compare :: LockFlags -> LockFlags -> Ordering
compare LockFlags
a LockFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (LockFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum LockFlags
a) (LockFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum LockFlags
b)
type instance O.ParentTypes LockFlags = '[]
instance O.HasParentTypes LockFlags
foreign import ccall "gst_lock_flags_get_type" c_gst_lock_flags_get_type ::
IO GType
instance B.Types.TypedObject LockFlags where
glibType :: IO GType
glibType = IO GType
c_gst_lock_flags_get_type
instance B.Types.BoxedFlags LockFlags
instance IsGFlag LockFlags
data GapFlags =
GapFlagsData
| AnotherGapFlags Int
deriving (Int -> GapFlags -> ShowS
[GapFlags] -> ShowS
GapFlags -> String
(Int -> GapFlags -> ShowS)
-> (GapFlags -> String) -> ([GapFlags] -> ShowS) -> Show GapFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> GapFlags -> ShowS
showsPrec :: Int -> GapFlags -> ShowS
$cshow :: GapFlags -> String
show :: GapFlags -> String
$cshowList :: [GapFlags] -> ShowS
showList :: [GapFlags] -> ShowS
Show, GapFlags -> GapFlags -> Bool
(GapFlags -> GapFlags -> Bool)
-> (GapFlags -> GapFlags -> Bool) -> Eq GapFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: GapFlags -> GapFlags -> Bool
== :: GapFlags -> GapFlags -> Bool
$c/= :: GapFlags -> GapFlags -> Bool
/= :: GapFlags -> GapFlags -> Bool
Eq)
instance P.Enum GapFlags where
fromEnum :: GapFlags -> Int
fromEnum GapFlags
GapFlagsData = Int
1
fromEnum (AnotherGapFlags Int
k) = Int
k
toEnum :: Int -> GapFlags
toEnum Int
1 = GapFlags
GapFlagsData
toEnum Int
k = Int -> GapFlags
AnotherGapFlags Int
k
instance P.Ord GapFlags where
compare :: GapFlags -> GapFlags -> Ordering
compare GapFlags
a GapFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (GapFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum GapFlags
a) (GapFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum GapFlags
b)
type instance O.ParentTypes GapFlags = '[]
instance O.HasParentTypes GapFlags
foreign import ccall "gst_gap_flags_get_type" c_gst_gap_flags_get_type ::
IO GType
instance B.Types.TypedObject GapFlags where
glibType :: IO GType
glibType = IO GType
c_gst_gap_flags_get_type
instance B.Types.BoxedFlags GapFlags
instance IsGFlag GapFlags
data EventTypeFlags =
EventTypeFlagsUpstream
| EventTypeFlagsDownstream
| EventTypeFlagsSerialized
| EventTypeFlagsSticky
| EventTypeFlagsStickyMulti
| AnotherEventTypeFlags Int
deriving (Int -> EventTypeFlags -> ShowS
[EventTypeFlags] -> ShowS
EventTypeFlags -> String
(Int -> EventTypeFlags -> ShowS)
-> (EventTypeFlags -> String)
-> ([EventTypeFlags] -> ShowS)
-> Show EventTypeFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> EventTypeFlags -> ShowS
showsPrec :: Int -> EventTypeFlags -> ShowS
$cshow :: EventTypeFlags -> String
show :: EventTypeFlags -> String
$cshowList :: [EventTypeFlags] -> ShowS
showList :: [EventTypeFlags] -> ShowS
Show, EventTypeFlags -> EventTypeFlags -> Bool
(EventTypeFlags -> EventTypeFlags -> Bool)
-> (EventTypeFlags -> EventTypeFlags -> Bool) -> Eq EventTypeFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: EventTypeFlags -> EventTypeFlags -> Bool
== :: EventTypeFlags -> EventTypeFlags -> Bool
$c/= :: EventTypeFlags -> EventTypeFlags -> Bool
/= :: EventTypeFlags -> EventTypeFlags -> Bool
Eq)
instance P.Enum EventTypeFlags where
fromEnum :: EventTypeFlags -> Int
fromEnum EventTypeFlags
EventTypeFlagsUpstream = Int
1
fromEnum EventTypeFlags
EventTypeFlagsDownstream = Int
2
fromEnum EventTypeFlags
EventTypeFlagsSerialized = Int
4
fromEnum EventTypeFlags
EventTypeFlagsSticky = Int
8
fromEnum EventTypeFlags
EventTypeFlagsStickyMulti = Int
16
fromEnum (AnotherEventTypeFlags Int
k) = Int
k
toEnum :: Int -> EventTypeFlags
toEnum Int
1 = EventTypeFlags
EventTypeFlagsUpstream
toEnum Int
2 = EventTypeFlags
EventTypeFlagsDownstream
toEnum Int
4 = EventTypeFlags
EventTypeFlagsSerialized
toEnum Int
8 = EventTypeFlags
EventTypeFlagsSticky
toEnum Int
16 = EventTypeFlags
EventTypeFlagsStickyMulti
toEnum Int
k = Int -> EventTypeFlags
AnotherEventTypeFlags Int
k
instance P.Ord EventTypeFlags where
compare :: EventTypeFlags -> EventTypeFlags -> Ordering
compare EventTypeFlags
a EventTypeFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (EventTypeFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum EventTypeFlags
a) (EventTypeFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum EventTypeFlags
b)
type instance O.ParentTypes EventTypeFlags = '[]
instance O.HasParentTypes EventTypeFlags
foreign import ccall "gst_event_type_flags_get_type" c_gst_event_type_flags_get_type ::
IO GType
instance B.Types.TypedObject EventTypeFlags where
glibType :: IO GType
glibType = IO GType
c_gst_event_type_flags_get_type
instance B.Types.BoxedFlags EventTypeFlags
instance IsGFlag EventTypeFlags
data ElementFlags =
ElementFlagsLockedState
| ElementFlagsSink
| ElementFlagsSource
| ElementFlagsProvideClock
| ElementFlagsRequireClock
| ElementFlagsIndexable
| ElementFlagsLast
| AnotherElementFlags Int
deriving (Int -> ElementFlags -> ShowS
[ElementFlags] -> ShowS
ElementFlags -> String
(Int -> ElementFlags -> ShowS)
-> (ElementFlags -> String)
-> ([ElementFlags] -> ShowS)
-> Show ElementFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ElementFlags -> ShowS
showsPrec :: Int -> ElementFlags -> ShowS
$cshow :: ElementFlags -> String
show :: ElementFlags -> String
$cshowList :: [ElementFlags] -> ShowS
showList :: [ElementFlags] -> ShowS
Show, ElementFlags -> ElementFlags -> Bool
(ElementFlags -> ElementFlags -> Bool)
-> (ElementFlags -> ElementFlags -> Bool) -> Eq ElementFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ElementFlags -> ElementFlags -> Bool
== :: ElementFlags -> ElementFlags -> Bool
$c/= :: ElementFlags -> ElementFlags -> Bool
/= :: ElementFlags -> ElementFlags -> Bool
Eq)
instance P.Enum ElementFlags where
fromEnum :: ElementFlags -> Int
fromEnum ElementFlags
ElementFlagsLockedState = Int
16
fromEnum ElementFlags
ElementFlagsSink = Int
32
fromEnum ElementFlags
ElementFlagsSource = Int
64
fromEnum ElementFlags
ElementFlagsProvideClock = Int
128
fromEnum ElementFlags
ElementFlagsRequireClock = Int
256
fromEnum ElementFlags
ElementFlagsIndexable = Int
512
fromEnum ElementFlags
ElementFlagsLast = Int
16384
fromEnum (AnotherElementFlags Int
k) = Int
k
toEnum :: Int -> ElementFlags
toEnum Int
16 = ElementFlags
ElementFlagsLockedState
toEnum Int
32 = ElementFlags
ElementFlagsSink
toEnum Int
64 = ElementFlags
ElementFlagsSource
toEnum Int
128 = ElementFlags
ElementFlagsProvideClock
toEnum Int
256 = ElementFlags
ElementFlagsRequireClock
toEnum Int
512 = ElementFlags
ElementFlagsIndexable
toEnum Int
16384 = ElementFlags
ElementFlagsLast
toEnum Int
k = Int -> ElementFlags
AnotherElementFlags Int
k
instance P.Ord ElementFlags where
compare :: ElementFlags -> ElementFlags -> Ordering
compare ElementFlags
a ElementFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ElementFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum ElementFlags
a) (ElementFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum ElementFlags
b)
type instance O.ParentTypes ElementFlags = '[]
instance O.HasParentTypes ElementFlags
foreign import ccall "gst_element_flags_get_type" c_gst_element_flags_get_type ::
IO GType
instance B.Types.TypedObject ElementFlags where
glibType :: IO GType
glibType = IO GType
c_gst_element_flags_get_type
instance B.Types.BoxedFlags ElementFlags
instance IsGFlag ElementFlags
data DebugGraphDetails =
DebugGraphDetailsMediaType
| DebugGraphDetailsCapsDetails
| DebugGraphDetailsNonDefaultParams
| DebugGraphDetailsStates
| DebugGraphDetailsFullParams
| DebugGraphDetailsAll
| DebugGraphDetailsVerbose
| AnotherDebugGraphDetails Int
deriving (Int -> DebugGraphDetails -> ShowS
[DebugGraphDetails] -> ShowS
DebugGraphDetails -> String
(Int -> DebugGraphDetails -> ShowS)
-> (DebugGraphDetails -> String)
-> ([DebugGraphDetails] -> ShowS)
-> Show DebugGraphDetails
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DebugGraphDetails -> ShowS
showsPrec :: Int -> DebugGraphDetails -> ShowS
$cshow :: DebugGraphDetails -> String
show :: DebugGraphDetails -> String
$cshowList :: [DebugGraphDetails] -> ShowS
showList :: [DebugGraphDetails] -> ShowS
Show, DebugGraphDetails -> DebugGraphDetails -> Bool
(DebugGraphDetails -> DebugGraphDetails -> Bool)
-> (DebugGraphDetails -> DebugGraphDetails -> Bool)
-> Eq DebugGraphDetails
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DebugGraphDetails -> DebugGraphDetails -> Bool
== :: DebugGraphDetails -> DebugGraphDetails -> Bool
$c/= :: DebugGraphDetails -> DebugGraphDetails -> Bool
/= :: DebugGraphDetails -> DebugGraphDetails -> Bool
Eq)
instance P.Enum DebugGraphDetails where
fromEnum :: DebugGraphDetails -> Int
fromEnum DebugGraphDetails
DebugGraphDetailsMediaType = Int
1
fromEnum DebugGraphDetails
DebugGraphDetailsCapsDetails = Int
2
fromEnum DebugGraphDetails
DebugGraphDetailsNonDefaultParams = Int
4
fromEnum DebugGraphDetails
DebugGraphDetailsStates = Int
8
fromEnum DebugGraphDetails
DebugGraphDetailsFullParams = Int
16
fromEnum DebugGraphDetails
DebugGraphDetailsAll = Int
15
fromEnum DebugGraphDetails
DebugGraphDetailsVerbose = Int
4294967295
fromEnum (AnotherDebugGraphDetails Int
k) = Int
k
toEnum :: Int -> DebugGraphDetails
toEnum Int
1 = DebugGraphDetails
DebugGraphDetailsMediaType
toEnum Int
2 = DebugGraphDetails
DebugGraphDetailsCapsDetails
toEnum Int
4 = DebugGraphDetails
DebugGraphDetailsNonDefaultParams
toEnum Int
8 = DebugGraphDetails
DebugGraphDetailsStates
toEnum Int
16 = DebugGraphDetails
DebugGraphDetailsFullParams
toEnum Int
15 = DebugGraphDetails
DebugGraphDetailsAll
toEnum Int
4294967295 = DebugGraphDetails
DebugGraphDetailsVerbose
toEnum Int
k = Int -> DebugGraphDetails
AnotherDebugGraphDetails Int
k
instance P.Ord DebugGraphDetails where
compare :: DebugGraphDetails -> DebugGraphDetails -> Ordering
compare DebugGraphDetails
a DebugGraphDetails
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (DebugGraphDetails -> Int
forall a. Enum a => a -> Int
P.fromEnum DebugGraphDetails
a) (DebugGraphDetails -> Int
forall a. Enum a => a -> Int
P.fromEnum DebugGraphDetails
b)
type instance O.ParentTypes DebugGraphDetails = '[]
instance O.HasParentTypes DebugGraphDetails
foreign import ccall "gst_debug_graph_details_get_type" c_gst_debug_graph_details_get_type ::
IO GType
instance B.Types.TypedObject DebugGraphDetails where
glibType :: IO GType
glibType = IO GType
c_gst_debug_graph_details_get_type
instance B.Types.BoxedFlags DebugGraphDetails
instance IsGFlag DebugGraphDetails
data DebugColorFlags =
DebugColorFlagsFgBlack
| DebugColorFlagsFgRed
| DebugColorFlagsFgGreen
| DebugColorFlagsFgYellow
| DebugColorFlagsFgBlue
| DebugColorFlagsFgMagenta
| DebugColorFlagsFgCyan
| DebugColorFlagsFgWhite
| DebugColorFlagsBgBlack
| DebugColorFlagsBgRed
| DebugColorFlagsBgGreen
| DebugColorFlagsBgYellow
| DebugColorFlagsBgBlue
| DebugColorFlagsBgMagenta
| DebugColorFlagsBgCyan
| DebugColorFlagsBgWhite
| DebugColorFlagsBold
| DebugColorFlagsUnderline
| AnotherDebugColorFlags Int
deriving (Int -> DebugColorFlags -> ShowS
[DebugColorFlags] -> ShowS
DebugColorFlags -> String
(Int -> DebugColorFlags -> ShowS)
-> (DebugColorFlags -> String)
-> ([DebugColorFlags] -> ShowS)
-> Show DebugColorFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DebugColorFlags -> ShowS
showsPrec :: Int -> DebugColorFlags -> ShowS
$cshow :: DebugColorFlags -> String
show :: DebugColorFlags -> String
$cshowList :: [DebugColorFlags] -> ShowS
showList :: [DebugColorFlags] -> ShowS
Show, DebugColorFlags -> DebugColorFlags -> Bool
(DebugColorFlags -> DebugColorFlags -> Bool)
-> (DebugColorFlags -> DebugColorFlags -> Bool)
-> Eq DebugColorFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DebugColorFlags -> DebugColorFlags -> Bool
== :: DebugColorFlags -> DebugColorFlags -> Bool
$c/= :: DebugColorFlags -> DebugColorFlags -> Bool
/= :: DebugColorFlags -> DebugColorFlags -> Bool
Eq)
instance P.Enum DebugColorFlags where
fromEnum :: DebugColorFlags -> Int
fromEnum DebugColorFlags
DebugColorFlagsFgBlack = Int
0
fromEnum DebugColorFlags
DebugColorFlagsFgRed = Int
1
fromEnum DebugColorFlags
DebugColorFlagsFgGreen = Int
2
fromEnum DebugColorFlags
DebugColorFlagsFgYellow = Int
3
fromEnum DebugColorFlags
DebugColorFlagsFgBlue = Int
4
fromEnum DebugColorFlags
DebugColorFlagsFgMagenta = Int
5
fromEnum DebugColorFlags
DebugColorFlagsFgCyan = Int
6
fromEnum DebugColorFlags
DebugColorFlagsFgWhite = Int
7
fromEnum DebugColorFlags
DebugColorFlagsBgBlack = Int
0
fromEnum DebugColorFlags
DebugColorFlagsBgRed = Int
16
fromEnum DebugColorFlags
DebugColorFlagsBgGreen = Int
32
fromEnum DebugColorFlags
DebugColorFlagsBgYellow = Int
48
fromEnum DebugColorFlags
DebugColorFlagsBgBlue = Int
64
fromEnum DebugColorFlags
DebugColorFlagsBgMagenta = Int
80
fromEnum DebugColorFlags
DebugColorFlagsBgCyan = Int
96
fromEnum DebugColorFlags
DebugColorFlagsBgWhite = Int
112
fromEnum DebugColorFlags
DebugColorFlagsBold = Int
256
fromEnum DebugColorFlags
DebugColorFlagsUnderline = Int
512
fromEnum (AnotherDebugColorFlags Int
k) = Int
k
toEnum :: Int -> DebugColorFlags
toEnum Int
0 = DebugColorFlags
DebugColorFlagsFgBlack
toEnum Int
1 = DebugColorFlags
DebugColorFlagsFgRed
toEnum Int
2 = DebugColorFlags
DebugColorFlagsFgGreen
toEnum Int
3 = DebugColorFlags
DebugColorFlagsFgYellow
toEnum Int
4 = DebugColorFlags
DebugColorFlagsFgBlue
toEnum Int
5 = DebugColorFlags
DebugColorFlagsFgMagenta
toEnum Int
6 = DebugColorFlags
DebugColorFlagsFgCyan
toEnum Int
7 = DebugColorFlags
DebugColorFlagsFgWhite
toEnum Int
16 = DebugColorFlags
DebugColorFlagsBgRed
toEnum Int
32 = DebugColorFlags
DebugColorFlagsBgGreen
toEnum Int
48 = DebugColorFlags
DebugColorFlagsBgYellow
toEnum Int
64 = DebugColorFlags
DebugColorFlagsBgBlue
toEnum Int
80 = DebugColorFlags
DebugColorFlagsBgMagenta
toEnum Int
96 = DebugColorFlags
DebugColorFlagsBgCyan
toEnum Int
112 = DebugColorFlags
DebugColorFlagsBgWhite
toEnum Int
256 = DebugColorFlags
DebugColorFlagsBold
toEnum Int
512 = DebugColorFlags
DebugColorFlagsUnderline
toEnum Int
k = Int -> DebugColorFlags
AnotherDebugColorFlags Int
k
instance P.Ord DebugColorFlags where
compare :: DebugColorFlags -> DebugColorFlags -> Ordering
compare DebugColorFlags
a DebugColorFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (DebugColorFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum DebugColorFlags
a) (DebugColorFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum DebugColorFlags
b)
type instance O.ParentTypes DebugColorFlags = '[]
instance O.HasParentTypes DebugColorFlags
foreign import ccall "gst_debug_color_flags_get_type" c_gst_debug_color_flags_get_type ::
IO GType
instance B.Types.TypedObject DebugColorFlags where
glibType :: IO GType
glibType = IO GType
c_gst_debug_color_flags_get_type
instance B.Types.BoxedFlags DebugColorFlags
instance IsGFlag DebugColorFlags
data ClockFlags =
ClockFlagsCanDoSingleSync
| ClockFlagsCanDoSingleAsync
| ClockFlagsCanDoPeriodicSync
| ClockFlagsCanDoPeriodicAsync
| ClockFlagsCanSetResolution
| ClockFlagsCanSetMaster
| ClockFlagsNeedsStartupSync
| ClockFlagsLast
| AnotherClockFlags Int
deriving (Int -> ClockFlags -> ShowS
[ClockFlags] -> ShowS
ClockFlags -> String
(Int -> ClockFlags -> ShowS)
-> (ClockFlags -> String)
-> ([ClockFlags] -> ShowS)
-> Show ClockFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ClockFlags -> ShowS
showsPrec :: Int -> ClockFlags -> ShowS
$cshow :: ClockFlags -> String
show :: ClockFlags -> String
$cshowList :: [ClockFlags] -> ShowS
showList :: [ClockFlags] -> ShowS
Show, ClockFlags -> ClockFlags -> Bool
(ClockFlags -> ClockFlags -> Bool)
-> (ClockFlags -> ClockFlags -> Bool) -> Eq ClockFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ClockFlags -> ClockFlags -> Bool
== :: ClockFlags -> ClockFlags -> Bool
$c/= :: ClockFlags -> ClockFlags -> Bool
/= :: ClockFlags -> ClockFlags -> Bool
Eq)
instance P.Enum ClockFlags where
fromEnum :: ClockFlags -> Int
fromEnum ClockFlags
ClockFlagsCanDoSingleSync = Int
16
fromEnum ClockFlags
ClockFlagsCanDoSingleAsync = Int
32
fromEnum ClockFlags
ClockFlagsCanDoPeriodicSync = Int
64
fromEnum ClockFlags
ClockFlagsCanDoPeriodicAsync = Int
128
fromEnum ClockFlags
ClockFlagsCanSetResolution = Int
256
fromEnum ClockFlags
ClockFlagsCanSetMaster = Int
512
fromEnum ClockFlags
ClockFlagsNeedsStartupSync = Int
1024
fromEnum ClockFlags
ClockFlagsLast = Int
4096
fromEnum (AnotherClockFlags Int
k) = Int
k
toEnum :: Int -> ClockFlags
toEnum Int
16 = ClockFlags
ClockFlagsCanDoSingleSync
toEnum Int
32 = ClockFlags
ClockFlagsCanDoSingleAsync
toEnum Int
64 = ClockFlags
ClockFlagsCanDoPeriodicSync
toEnum Int
128 = ClockFlags
ClockFlagsCanDoPeriodicAsync
toEnum Int
256 = ClockFlags
ClockFlagsCanSetResolution
toEnum Int
512 = ClockFlags
ClockFlagsCanSetMaster
toEnum Int
1024 = ClockFlags
ClockFlagsNeedsStartupSync
toEnum Int
4096 = ClockFlags
ClockFlagsLast
toEnum Int
k = Int -> ClockFlags
AnotherClockFlags Int
k
instance P.Ord ClockFlags where
compare :: ClockFlags -> ClockFlags -> Ordering
compare ClockFlags
a ClockFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ClockFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum ClockFlags
a) (ClockFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum ClockFlags
b)
type instance O.ParentTypes ClockFlags = '[]
instance O.HasParentTypes ClockFlags
foreign import ccall "gst_clock_flags_get_type" c_gst_clock_flags_get_type ::
IO GType
instance B.Types.TypedObject ClockFlags where
glibType :: IO GType
glibType = IO GType
c_gst_clock_flags_get_type
instance B.Types.BoxedFlags ClockFlags
instance IsGFlag ClockFlags
data CapsFlags =
CapsFlagsAny
| AnotherCapsFlags Int
deriving (Int -> CapsFlags -> ShowS
[CapsFlags] -> ShowS
CapsFlags -> String
(Int -> CapsFlags -> ShowS)
-> (CapsFlags -> String)
-> ([CapsFlags] -> ShowS)
-> Show CapsFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CapsFlags -> ShowS
showsPrec :: Int -> CapsFlags -> ShowS
$cshow :: CapsFlags -> String
show :: CapsFlags -> String
$cshowList :: [CapsFlags] -> ShowS
showList :: [CapsFlags] -> ShowS
Show, CapsFlags -> CapsFlags -> Bool
(CapsFlags -> CapsFlags -> Bool)
-> (CapsFlags -> CapsFlags -> Bool) -> Eq CapsFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CapsFlags -> CapsFlags -> Bool
== :: CapsFlags -> CapsFlags -> Bool
$c/= :: CapsFlags -> CapsFlags -> Bool
/= :: CapsFlags -> CapsFlags -> Bool
Eq)
instance P.Enum CapsFlags where
fromEnum :: CapsFlags -> Int
fromEnum CapsFlags
CapsFlagsAny = Int
16
fromEnum (AnotherCapsFlags Int
k) = Int
k
toEnum :: Int -> CapsFlags
toEnum Int
16 = CapsFlags
CapsFlagsAny
toEnum Int
k = Int -> CapsFlags
AnotherCapsFlags Int
k
instance P.Ord CapsFlags where
compare :: CapsFlags -> CapsFlags -> Ordering
compare CapsFlags
a CapsFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (CapsFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum CapsFlags
a) (CapsFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum CapsFlags
b)
type instance O.ParentTypes CapsFlags = '[]
instance O.HasParentTypes CapsFlags
foreign import ccall "gst_caps_flags_get_type" c_gst_caps_flags_get_type ::
IO GType
instance B.Types.TypedObject CapsFlags where
glibType :: IO GType
glibType = IO GType
c_gst_caps_flags_get_type
instance B.Types.BoxedFlags CapsFlags
instance IsGFlag CapsFlags
data BusFlags =
BusFlagsFlushing
| BusFlagsFlagLast
| AnotherBusFlags Int
deriving (Int -> BusFlags -> ShowS
[BusFlags] -> ShowS
BusFlags -> String
(Int -> BusFlags -> ShowS)
-> (BusFlags -> String) -> ([BusFlags] -> ShowS) -> Show BusFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BusFlags -> ShowS
showsPrec :: Int -> BusFlags -> ShowS
$cshow :: BusFlags -> String
show :: BusFlags -> String
$cshowList :: [BusFlags] -> ShowS
showList :: [BusFlags] -> ShowS
Show, BusFlags -> BusFlags -> Bool
(BusFlags -> BusFlags -> Bool)
-> (BusFlags -> BusFlags -> Bool) -> Eq BusFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BusFlags -> BusFlags -> Bool
== :: BusFlags -> BusFlags -> Bool
$c/= :: BusFlags -> BusFlags -> Bool
/= :: BusFlags -> BusFlags -> Bool
Eq)
instance P.Enum BusFlags where
fromEnum :: BusFlags -> Int
fromEnum BusFlags
BusFlagsFlushing = Int
16
fromEnum BusFlags
BusFlagsFlagLast = Int
32
fromEnum (AnotherBusFlags Int
k) = Int
k
toEnum :: Int -> BusFlags
toEnum Int
16 = BusFlags
BusFlagsFlushing
toEnum Int
32 = BusFlags
BusFlagsFlagLast
toEnum Int
k = Int -> BusFlags
AnotherBusFlags Int
k
instance P.Ord BusFlags where
compare :: BusFlags -> BusFlags -> Ordering
compare BusFlags
a BusFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (BusFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum BusFlags
a) (BusFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum BusFlags
b)
type instance O.ParentTypes BusFlags = '[]
instance O.HasParentTypes BusFlags
foreign import ccall "gst_bus_flags_get_type" c_gst_bus_flags_get_type ::
IO GType
instance B.Types.TypedObject BusFlags where
glibType :: IO GType
glibType = IO GType
c_gst_bus_flags_get_type
instance B.Types.BoxedFlags BusFlags
instance IsGFlag BusFlags
data BufferPoolAcquireFlags =
BufferPoolAcquireFlagsNone
| BufferPoolAcquireFlagsKeyUnit
| BufferPoolAcquireFlagsDontwait
| BufferPoolAcquireFlagsDiscont
| BufferPoolAcquireFlagsLast
| AnotherBufferPoolAcquireFlags Int
deriving (Int -> BufferPoolAcquireFlags -> ShowS
[BufferPoolAcquireFlags] -> ShowS
BufferPoolAcquireFlags -> String
(Int -> BufferPoolAcquireFlags -> ShowS)
-> (BufferPoolAcquireFlags -> String)
-> ([BufferPoolAcquireFlags] -> ShowS)
-> Show BufferPoolAcquireFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BufferPoolAcquireFlags -> ShowS
showsPrec :: Int -> BufferPoolAcquireFlags -> ShowS
$cshow :: BufferPoolAcquireFlags -> String
show :: BufferPoolAcquireFlags -> String
$cshowList :: [BufferPoolAcquireFlags] -> ShowS
showList :: [BufferPoolAcquireFlags] -> ShowS
Show, BufferPoolAcquireFlags -> BufferPoolAcquireFlags -> Bool
(BufferPoolAcquireFlags -> BufferPoolAcquireFlags -> Bool)
-> (BufferPoolAcquireFlags -> BufferPoolAcquireFlags -> Bool)
-> Eq BufferPoolAcquireFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BufferPoolAcquireFlags -> BufferPoolAcquireFlags -> Bool
== :: BufferPoolAcquireFlags -> BufferPoolAcquireFlags -> Bool
$c/= :: BufferPoolAcquireFlags -> BufferPoolAcquireFlags -> Bool
/= :: BufferPoolAcquireFlags -> BufferPoolAcquireFlags -> Bool
Eq)
instance P.Enum BufferPoolAcquireFlags where
fromEnum :: BufferPoolAcquireFlags -> Int
fromEnum BufferPoolAcquireFlags
BufferPoolAcquireFlagsNone = Int
0
fromEnum BufferPoolAcquireFlags
BufferPoolAcquireFlagsKeyUnit = Int
1
fromEnum BufferPoolAcquireFlags
BufferPoolAcquireFlagsDontwait = Int
2
fromEnum BufferPoolAcquireFlags
BufferPoolAcquireFlagsDiscont = Int
4
fromEnum BufferPoolAcquireFlags
BufferPoolAcquireFlagsLast = Int
65536
fromEnum (AnotherBufferPoolAcquireFlags Int
k) = Int
k
toEnum :: Int -> BufferPoolAcquireFlags
toEnum Int
0 = BufferPoolAcquireFlags
BufferPoolAcquireFlagsNone
toEnum Int
1 = BufferPoolAcquireFlags
BufferPoolAcquireFlagsKeyUnit
toEnum Int
2 = BufferPoolAcquireFlags
BufferPoolAcquireFlagsDontwait
toEnum Int
4 = BufferPoolAcquireFlags
BufferPoolAcquireFlagsDiscont
toEnum Int
65536 = BufferPoolAcquireFlags
BufferPoolAcquireFlagsLast
toEnum Int
k = Int -> BufferPoolAcquireFlags
AnotherBufferPoolAcquireFlags Int
k
instance P.Ord BufferPoolAcquireFlags where
compare :: BufferPoolAcquireFlags -> BufferPoolAcquireFlags -> Ordering
compare BufferPoolAcquireFlags
a BufferPoolAcquireFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (BufferPoolAcquireFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum BufferPoolAcquireFlags
a) (BufferPoolAcquireFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum BufferPoolAcquireFlags
b)
type instance O.ParentTypes BufferPoolAcquireFlags = '[]
instance O.HasParentTypes BufferPoolAcquireFlags
foreign import ccall "gst_buffer_pool_acquire_flags_get_type" c_gst_buffer_pool_acquire_flags_get_type ::
IO GType
instance B.Types.TypedObject BufferPoolAcquireFlags where
glibType :: IO GType
glibType = IO GType
c_gst_buffer_pool_acquire_flags_get_type
instance B.Types.BoxedFlags BufferPoolAcquireFlags
instance IsGFlag BufferPoolAcquireFlags
data BufferFlags =
BufferFlagsLive
| BufferFlagsDecodeOnly
| BufferFlagsDiscont
| BufferFlagsResync
| BufferFlagsCorrupted
| BufferFlagsMarker
|
| BufferFlagsGap
| BufferFlagsDroppable
| BufferFlagsDeltaUnit
| BufferFlagsTagMemory
| BufferFlagsSyncAfter
| BufferFlagsNonDroppable
| BufferFlagsLast
| AnotherBufferFlags Int
deriving (Int -> BufferFlags -> ShowS
[BufferFlags] -> ShowS
BufferFlags -> String
(Int -> BufferFlags -> ShowS)
-> (BufferFlags -> String)
-> ([BufferFlags] -> ShowS)
-> Show BufferFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BufferFlags -> ShowS
showsPrec :: Int -> BufferFlags -> ShowS
$cshow :: BufferFlags -> String
show :: BufferFlags -> String
$cshowList :: [BufferFlags] -> ShowS
showList :: [BufferFlags] -> ShowS
Show, BufferFlags -> BufferFlags -> Bool
(BufferFlags -> BufferFlags -> Bool)
-> (BufferFlags -> BufferFlags -> Bool) -> Eq BufferFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BufferFlags -> BufferFlags -> Bool
== :: BufferFlags -> BufferFlags -> Bool
$c/= :: BufferFlags -> BufferFlags -> Bool
/= :: BufferFlags -> BufferFlags -> Bool
Eq)
instance P.Enum BufferFlags where
fromEnum :: BufferFlags -> Int
fromEnum BufferFlags
BufferFlagsLive = Int
16
fromEnum BufferFlags
BufferFlagsDecodeOnly = Int
32
fromEnum BufferFlags
BufferFlagsDiscont = Int
64
fromEnum BufferFlags
BufferFlagsResync = Int
128
fromEnum BufferFlags
BufferFlagsCorrupted = Int
256
fromEnum BufferFlags
BufferFlagsMarker = Int
512
fromEnum BufferFlags
BufferFlagsHeader = Int
1024
fromEnum BufferFlags
BufferFlagsGap = Int
2048
fromEnum BufferFlags
BufferFlagsDroppable = Int
4096
fromEnum BufferFlags
BufferFlagsDeltaUnit = Int
8192
fromEnum BufferFlags
BufferFlagsTagMemory = Int
16384
fromEnum BufferFlags
BufferFlagsSyncAfter = Int
32768
fromEnum BufferFlags
BufferFlagsNonDroppable = Int
65536
fromEnum BufferFlags
BufferFlagsLast = Int
1048576
fromEnum (AnotherBufferFlags Int
k) = Int
k
toEnum :: Int -> BufferFlags
toEnum Int
16 = BufferFlags
BufferFlagsLive
toEnum Int
32 = BufferFlags
BufferFlagsDecodeOnly
toEnum Int
64 = BufferFlags
BufferFlagsDiscont
toEnum Int
128 = BufferFlags
BufferFlagsResync
toEnum Int
256 = BufferFlags
BufferFlagsCorrupted
toEnum Int
512 = BufferFlags
BufferFlagsMarker
toEnum Int
1024 = BufferFlags
BufferFlagsHeader
toEnum Int
2048 = BufferFlags
BufferFlagsGap
toEnum Int
4096 = BufferFlags
BufferFlagsDroppable
toEnum Int
8192 = BufferFlags
BufferFlagsDeltaUnit
toEnum Int
16384 = BufferFlags
BufferFlagsTagMemory
toEnum Int
32768 = BufferFlags
BufferFlagsSyncAfter
toEnum Int
65536 = BufferFlags
BufferFlagsNonDroppable
toEnum Int
1048576 = BufferFlags
BufferFlagsLast
toEnum Int
k = Int -> BufferFlags
AnotherBufferFlags Int
k
instance P.Ord BufferFlags where
compare :: BufferFlags -> BufferFlags -> Ordering
compare BufferFlags
a BufferFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (BufferFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum BufferFlags
a) (BufferFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum BufferFlags
b)
type instance O.ParentTypes BufferFlags = '[]
instance O.HasParentTypes BufferFlags
foreign import ccall "gst_buffer_flags_get_type" c_gst_buffer_flags_get_type ::
IO GType
instance B.Types.TypedObject BufferFlags where
glibType :: IO GType
glibType = IO GType
c_gst_buffer_flags_get_type
instance B.Types.BoxedFlags BufferFlags
instance IsGFlag BufferFlags
data BufferCopyFlags =
BufferCopyFlagsNone
| BufferCopyFlagsFlags
| BufferCopyFlagsTimestamps
| BufferCopyFlagsMeta
| BufferCopyFlagsMemory
| BufferCopyFlagsMerge
| BufferCopyFlagsDeep
| AnotherBufferCopyFlags Int
deriving (Int -> BufferCopyFlags -> ShowS
[BufferCopyFlags] -> ShowS
BufferCopyFlags -> String
(Int -> BufferCopyFlags -> ShowS)
-> (BufferCopyFlags -> String)
-> ([BufferCopyFlags] -> ShowS)
-> Show BufferCopyFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BufferCopyFlags -> ShowS
showsPrec :: Int -> BufferCopyFlags -> ShowS
$cshow :: BufferCopyFlags -> String
show :: BufferCopyFlags -> String
$cshowList :: [BufferCopyFlags] -> ShowS
showList :: [BufferCopyFlags] -> ShowS
Show, BufferCopyFlags -> BufferCopyFlags -> Bool
(BufferCopyFlags -> BufferCopyFlags -> Bool)
-> (BufferCopyFlags -> BufferCopyFlags -> Bool)
-> Eq BufferCopyFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BufferCopyFlags -> BufferCopyFlags -> Bool
== :: BufferCopyFlags -> BufferCopyFlags -> Bool
$c/= :: BufferCopyFlags -> BufferCopyFlags -> Bool
/= :: BufferCopyFlags -> BufferCopyFlags -> Bool
Eq)
instance P.Enum BufferCopyFlags where
fromEnum :: BufferCopyFlags -> Int
fromEnum BufferCopyFlags
BufferCopyFlagsNone = Int
0
fromEnum BufferCopyFlags
BufferCopyFlagsFlags = Int
1
fromEnum BufferCopyFlags
BufferCopyFlagsTimestamps = Int
2
fromEnum BufferCopyFlags
BufferCopyFlagsMeta = Int
4
fromEnum BufferCopyFlags
BufferCopyFlagsMemory = Int
8
fromEnum BufferCopyFlags
BufferCopyFlagsMerge = Int
16
fromEnum BufferCopyFlags
BufferCopyFlagsDeep = Int
32
fromEnum (AnotherBufferCopyFlags Int
k) = Int
k
toEnum :: Int -> BufferCopyFlags
toEnum Int
0 = BufferCopyFlags
BufferCopyFlagsNone
toEnum Int
1 = BufferCopyFlags
BufferCopyFlagsFlags
toEnum Int
2 = BufferCopyFlags
BufferCopyFlagsTimestamps
toEnum Int
4 = BufferCopyFlags
BufferCopyFlagsMeta
toEnum Int
8 = BufferCopyFlags
BufferCopyFlagsMemory
toEnum Int
16 = BufferCopyFlags
BufferCopyFlagsMerge
toEnum Int
32 = BufferCopyFlags
BufferCopyFlagsDeep
toEnum Int
k = Int -> BufferCopyFlags
AnotherBufferCopyFlags Int
k
instance P.Ord BufferCopyFlags where
compare :: BufferCopyFlags -> BufferCopyFlags -> Ordering
compare BufferCopyFlags
a BufferCopyFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (BufferCopyFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum BufferCopyFlags
a) (BufferCopyFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum BufferCopyFlags
b)
type instance O.ParentTypes BufferCopyFlags = '[]
instance O.HasParentTypes BufferCopyFlags
foreign import ccall "gst_buffer_copy_flags_get_type" c_gst_buffer_copy_flags_get_type ::
IO GType
instance B.Types.TypedObject BufferCopyFlags where
glibType :: IO GType
glibType = IO GType
c_gst_buffer_copy_flags_get_type
instance B.Types.BoxedFlags BufferCopyFlags
instance IsGFlag BufferCopyFlags
data BinFlags =
BinFlagsNoResync
| BinFlagsStreamsAware
| BinFlagsLast
| AnotherBinFlags Int
deriving (Int -> BinFlags -> ShowS
[BinFlags] -> ShowS
BinFlags -> String
(Int -> BinFlags -> ShowS)
-> (BinFlags -> String) -> ([BinFlags] -> ShowS) -> Show BinFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BinFlags -> ShowS
showsPrec :: Int -> BinFlags -> ShowS
$cshow :: BinFlags -> String
show :: BinFlags -> String
$cshowList :: [BinFlags] -> ShowS
showList :: [BinFlags] -> ShowS
Show, BinFlags -> BinFlags -> Bool
(BinFlags -> BinFlags -> Bool)
-> (BinFlags -> BinFlags -> Bool) -> Eq BinFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BinFlags -> BinFlags -> Bool
== :: BinFlags -> BinFlags -> Bool
$c/= :: BinFlags -> BinFlags -> Bool
/= :: BinFlags -> BinFlags -> Bool
Eq)
instance P.Enum BinFlags where
fromEnum :: BinFlags -> Int
fromEnum BinFlags
BinFlagsNoResync = Int
16384
fromEnum BinFlags
BinFlagsStreamsAware = Int
32768
fromEnum BinFlags
BinFlagsLast = Int
524288
fromEnum (AnotherBinFlags Int
k) = Int
k
toEnum :: Int -> BinFlags
toEnum Int
16384 = BinFlags
BinFlagsNoResync
toEnum Int
32768 = BinFlags
BinFlagsStreamsAware
toEnum Int
524288 = BinFlags
BinFlagsLast
toEnum Int
k = Int -> BinFlags
AnotherBinFlags Int
k
instance P.Ord BinFlags where
compare :: BinFlags -> BinFlags -> Ordering
compare BinFlags
a BinFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (BinFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum BinFlags
a) (BinFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum BinFlags
b)
type instance O.ParentTypes BinFlags = '[]
instance O.HasParentTypes BinFlags
foreign import ccall "gst_bin_flags_get_type" c_gst_bin_flags_get_type ::
IO GType
instance B.Types.TypedObject BinFlags where
glibType :: IO GType
glibType = IO GType
c_gst_bin_flags_get_type
instance B.Types.BoxedFlags BinFlags
instance IsGFlag BinFlags
data AllocatorFlags =
AllocatorFlagsCustomAlloc
| AllocatorFlagsLast
| AnotherAllocatorFlags Int
deriving (Int -> AllocatorFlags -> ShowS
[AllocatorFlags] -> ShowS
AllocatorFlags -> String
(Int -> AllocatorFlags -> ShowS)
-> (AllocatorFlags -> String)
-> ([AllocatorFlags] -> ShowS)
-> Show AllocatorFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> AllocatorFlags -> ShowS
showsPrec :: Int -> AllocatorFlags -> ShowS
$cshow :: AllocatorFlags -> String
show :: AllocatorFlags -> String
$cshowList :: [AllocatorFlags] -> ShowS
showList :: [AllocatorFlags] -> ShowS
Show, AllocatorFlags -> AllocatorFlags -> Bool
(AllocatorFlags -> AllocatorFlags -> Bool)
-> (AllocatorFlags -> AllocatorFlags -> Bool) -> Eq AllocatorFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AllocatorFlags -> AllocatorFlags -> Bool
== :: AllocatorFlags -> AllocatorFlags -> Bool
$c/= :: AllocatorFlags -> AllocatorFlags -> Bool
/= :: AllocatorFlags -> AllocatorFlags -> Bool
Eq)
instance P.Enum AllocatorFlags where
fromEnum :: AllocatorFlags -> Int
fromEnum AllocatorFlags
AllocatorFlagsCustomAlloc = Int
16
fromEnum AllocatorFlags
AllocatorFlagsLast = Int
1048576
fromEnum (AnotherAllocatorFlags Int
k) = Int
k
toEnum :: Int -> AllocatorFlags
toEnum Int
16 = AllocatorFlags
AllocatorFlagsCustomAlloc
toEnum Int
1048576 = AllocatorFlags
AllocatorFlagsLast
toEnum Int
k = Int -> AllocatorFlags
AnotherAllocatorFlags Int
k
instance P.Ord AllocatorFlags where
compare :: AllocatorFlags -> AllocatorFlags -> Ordering
compare AllocatorFlags
a AllocatorFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (AllocatorFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum AllocatorFlags
a) (AllocatorFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum AllocatorFlags
b)
type instance O.ParentTypes AllocatorFlags = '[]
instance O.HasParentTypes AllocatorFlags
foreign import ccall "gst_allocator_flags_get_type" c_gst_allocator_flags_get_type ::
IO GType
instance B.Types.TypedObject AllocatorFlags where
glibType :: IO GType
glibType = IO GType
c_gst_allocator_flags_get_type
instance B.Types.BoxedFlags AllocatorFlags
instance IsGFlag AllocatorFlags