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