-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.GstTag.Enums
    ( 

 -- * Enumerations
-- ** TagDemuxResult #enum:TagDemuxResult#

    TagDemuxResult(..)                      ,


-- ** TagImageType #enum:TagImageType#

    TagImageType(..)                        ,




    ) 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


-- Enum TagImageType
-- | Type of image contained in an image tag (specified as \"image-type\" field in
-- the info structure in the image\'s t'GI.Gst.Structs.Sample.Sample')
data TagImageType = 
      TagImageTypeNone
    -- ^ No image type. Can be used to
    --      tell functions such as 'GI.GstTag.Functions.tagImageDataToImageSample' that no
    --      image type should be set.
    | TagImageTypeUndefined
    -- ^ Undefined\/other image type
    | TagImageTypeFrontCover
    -- ^ Cover (front)
    | TagImageTypeBackCover
    -- ^ Cover (back)
    | TagImageTypeLeafletPage
    -- ^ Leaflet page
    | TagImageTypeMedium
    -- ^ Medium (e.g. label side of CD)
    | TagImageTypeLeadArtist
    -- ^ Lead artist\/lead performer\/soloist
    | TagImageTypeArtist
    -- ^ Artist\/performer
    | TagImageTypeConductor
    -- ^ Conductor
    | TagImageTypeBandOrchestra
    -- ^ Band\/orchestra
    | TagImageTypeComposer
    -- ^ Composer
    | TagImageTypeLyricist
    -- ^ Lyricist\/text writer
    | TagImageTypeRecordingLocation
    -- ^ Recording location
    | TagImageTypeDuringRecording
    -- ^ During recording
    | TagImageTypeDuringPerformance
    -- ^ During performance
    | TagImageTypeVideoCapture
    -- ^ Movie\/video screen capture
    | TagImageTypeFish
    -- ^ A fish as funny as the ID3v2 spec
    | TagImageTypeIllustration
    -- ^ Illustration
    | TagImageTypeBandArtistLogo
    -- ^ Band\/artist logotype
    | TagImageTypePublisherStudioLogo
    -- ^ Publisher\/studio logotype
    | AnotherTagImageType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> TagImageType -> ShowS
[TagImageType] -> ShowS
TagImageType -> String
(Int -> TagImageType -> ShowS)
-> (TagImageType -> String)
-> ([TagImageType] -> ShowS)
-> Show TagImageType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TagImageType] -> ShowS
$cshowList :: [TagImageType] -> ShowS
show :: TagImageType -> String
$cshow :: TagImageType -> String
showsPrec :: Int -> TagImageType -> ShowS
$cshowsPrec :: Int -> TagImageType -> ShowS
Show, TagImageType -> TagImageType -> Bool
(TagImageType -> TagImageType -> Bool)
-> (TagImageType -> TagImageType -> Bool) -> Eq TagImageType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TagImageType -> TagImageType -> Bool
$c/= :: TagImageType -> TagImageType -> Bool
== :: TagImageType -> TagImageType -> Bool
$c== :: TagImageType -> TagImageType -> Bool
Eq)

instance P.Enum TagImageType where
    fromEnum :: TagImageType -> Int
fromEnum TagImageTypeNone = -1
    fromEnum TagImageTypeUndefined = 0
    fromEnum TagImageTypeFrontCover = 1
    fromEnum TagImageTypeBackCover = 2
    fromEnum TagImageTypeLeafletPage = 3
    fromEnum TagImageTypeMedium = 4
    fromEnum TagImageTypeLeadArtist = 5
    fromEnum TagImageTypeArtist = 6
    fromEnum TagImageTypeConductor = 7
    fromEnum TagImageTypeBandOrchestra = 8
    fromEnum TagImageTypeComposer = 9
    fromEnum TagImageTypeLyricist = 10
    fromEnum TagImageTypeRecordingLocation = 11
    fromEnum TagImageTypeDuringRecording = 12
    fromEnum TagImageTypeDuringPerformance = 13
    fromEnum TagImageTypeVideoCapture = 14
    fromEnum TagImageTypeFish = 15
    fromEnum TagImageTypeIllustration = 16
    fromEnum TagImageTypeBandArtistLogo = 17
    fromEnum TagImageTypePublisherStudioLogo = 18
    fromEnum (AnotherTagImageType k :: Int
k) = Int
k

    toEnum :: Int -> TagImageType
toEnum -1 = TagImageType
TagImageTypeNone
    toEnum 0 = TagImageType
TagImageTypeUndefined
    toEnum 1 = TagImageType
TagImageTypeFrontCover
    toEnum 2 = TagImageType
TagImageTypeBackCover
    toEnum 3 = TagImageType
TagImageTypeLeafletPage
    toEnum 4 = TagImageType
TagImageTypeMedium
    toEnum 5 = TagImageType
TagImageTypeLeadArtist
    toEnum 6 = TagImageType
TagImageTypeArtist
    toEnum 7 = TagImageType
TagImageTypeConductor
    toEnum 8 = TagImageType
TagImageTypeBandOrchestra
    toEnum 9 = TagImageType
TagImageTypeComposer
    toEnum 10 = TagImageType
TagImageTypeLyricist
    toEnum 11 = TagImageType
TagImageTypeRecordingLocation
    toEnum 12 = TagImageType
TagImageTypeDuringRecording
    toEnum 13 = TagImageType
TagImageTypeDuringPerformance
    toEnum 14 = TagImageType
TagImageTypeVideoCapture
    toEnum 15 = TagImageType
TagImageTypeFish
    toEnum 16 = TagImageType
TagImageTypeIllustration
    toEnum 17 = TagImageType
TagImageTypeBandArtistLogo
    toEnum 18 = TagImageType
TagImageTypePublisherStudioLogo
    toEnum k :: Int
k = Int -> TagImageType
AnotherTagImageType Int
k

instance P.Ord TagImageType where
    compare :: TagImageType -> TagImageType -> Ordering
compare a :: TagImageType
a b :: TagImageType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (TagImageType -> Int
forall a. Enum a => a -> Int
P.fromEnum TagImageType
a) (TagImageType -> Int
forall a. Enum a => a -> Int
P.fromEnum TagImageType
b)

foreign import ccall "gst_tag_image_type_get_type" c_gst_tag_image_type_get_type :: 
    IO GType

instance BoxedEnum TagImageType where
    boxedEnumType :: TagImageType -> IO GType
boxedEnumType _ = IO GType
c_gst_tag_image_type_get_type

-- Enum TagDemuxResult
-- | Result values from the parse_tag virtual function.
data TagDemuxResult = 
      TagDemuxResultBrokenTag
    -- ^ cannot parse tag, just skip it
    | TagDemuxResultAgain
    -- ^ call again with less or more data
    | TagDemuxResultOk
    -- ^ parsed tag successfully
    | AnotherTagDemuxResult Int
    -- ^ Catch-all for unknown values
    deriving (Int -> TagDemuxResult -> ShowS
[TagDemuxResult] -> ShowS
TagDemuxResult -> String
(Int -> TagDemuxResult -> ShowS)
-> (TagDemuxResult -> String)
-> ([TagDemuxResult] -> ShowS)
-> Show TagDemuxResult
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TagDemuxResult] -> ShowS
$cshowList :: [TagDemuxResult] -> ShowS
show :: TagDemuxResult -> String
$cshow :: TagDemuxResult -> String
showsPrec :: Int -> TagDemuxResult -> ShowS
$cshowsPrec :: Int -> TagDemuxResult -> ShowS
Show, TagDemuxResult -> TagDemuxResult -> Bool
(TagDemuxResult -> TagDemuxResult -> Bool)
-> (TagDemuxResult -> TagDemuxResult -> Bool) -> Eq TagDemuxResult
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TagDemuxResult -> TagDemuxResult -> Bool
$c/= :: TagDemuxResult -> TagDemuxResult -> Bool
== :: TagDemuxResult -> TagDemuxResult -> Bool
$c== :: TagDemuxResult -> TagDemuxResult -> Bool
Eq)

instance P.Enum TagDemuxResult where
    fromEnum :: TagDemuxResult -> Int
fromEnum TagDemuxResultBrokenTag = 0
    fromEnum TagDemuxResultAgain = 1
    fromEnum TagDemuxResultOk = 2
    fromEnum (AnotherTagDemuxResult k :: Int
k) = Int
k

    toEnum :: Int -> TagDemuxResult
toEnum 0 = TagDemuxResult
TagDemuxResultBrokenTag
    toEnum 1 = TagDemuxResult
TagDemuxResultAgain
    toEnum 2 = TagDemuxResult
TagDemuxResultOk
    toEnum k :: Int
k = Int -> TagDemuxResult
AnotherTagDemuxResult Int
k

instance P.Ord TagDemuxResult where
    compare :: TagDemuxResult -> TagDemuxResult -> Ordering
compare a :: TagDemuxResult
a b :: TagDemuxResult
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (TagDemuxResult -> Int
forall a. Enum a => a -> Int
P.fromEnum TagDemuxResult
a) (TagDemuxResult -> Int
forall a. Enum a => a -> Int
P.fromEnum TagDemuxResult
b)

foreign import ccall "gst_tag_demux_result_get_type" c_gst_tag_demux_result_get_type :: 
    IO GType

instance BoxedEnum TagDemuxResult where
    boxedEnumType :: TagDemuxResult -> IO GType
boxedEnumType _ = IO GType
c_gst_tag_demux_result_get_type