-- | 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.Cairo.Enums
    ( 

 -- * Enumerations
-- ** Antialias #enum:Antialias#

    Antialias(..)                           ,


-- ** Content #enum:Content#

    Content(..)                             ,


-- ** DeviceType #enum:DeviceType#

    DeviceType(..)                          ,


-- ** Extend #enum:Extend#

    Extend(..)                              ,


-- ** FillRule #enum:FillRule#

    FillRule(..)                            ,


-- ** Filter #enum:Filter#

    Filter(..)                              ,


-- ** FontSlant #enum:FontSlant#

    FontSlant(..)                           ,


-- ** FontType #enum:FontType#

    FontType(..)                            ,


-- ** FontWeight #enum:FontWeight#

    FontWeight(..)                          ,


-- ** Format #enum:Format#

    Format(..)                              ,


-- ** HintMetrics #enum:HintMetrics#

    HintMetrics(..)                         ,


-- ** HintStyle #enum:HintStyle#

    HintStyle(..)                           ,


-- ** LineCap #enum:LineCap#

    LineCap(..)                             ,


-- ** LineJoin #enum:LineJoin#

    LineJoin(..)                            ,


-- ** Operator #enum:Operator#

    Operator(..)                            ,


-- ** PathDataType #enum:PathDataType#

    PathDataType(..)                        ,


-- ** PatternType #enum:PatternType#

    PatternType(..)                         ,


-- ** RegionOverlap #enum:RegionOverlap#

    RegionOverlap(..)                       ,


-- ** Status #enum:Status#

    Status(..)                              ,


-- ** SubpixelOrder #enum:SubpixelOrder#

    SubpixelOrder(..)                       ,


-- ** SurfaceType #enum:SurfaceType#

    SurfaceType(..)                         ,


-- ** TextClusterFlags #enum:TextClusterFlags#

    TextClusterFlags(..)                    ,




    ) 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 TextClusterFlags
-- | /No description available in the introspection data./
data TextClusterFlags = 
      TextClusterFlagsBackward
    -- ^ /No description available in the introspection data./
    | AnotherTextClusterFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> TextClusterFlags -> ShowS
[TextClusterFlags] -> ShowS
TextClusterFlags -> String
(Int -> TextClusterFlags -> ShowS)
-> (TextClusterFlags -> String)
-> ([TextClusterFlags] -> ShowS)
-> Show TextClusterFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TextClusterFlags] -> ShowS
$cshowList :: [TextClusterFlags] -> ShowS
show :: TextClusterFlags -> String
$cshow :: TextClusterFlags -> String
showsPrec :: Int -> TextClusterFlags -> ShowS
$cshowsPrec :: Int -> TextClusterFlags -> ShowS
Show, TextClusterFlags -> TextClusterFlags -> Bool
(TextClusterFlags -> TextClusterFlags -> Bool)
-> (TextClusterFlags -> TextClusterFlags -> Bool)
-> Eq TextClusterFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TextClusterFlags -> TextClusterFlags -> Bool
$c/= :: TextClusterFlags -> TextClusterFlags -> Bool
== :: TextClusterFlags -> TextClusterFlags -> Bool
$c== :: TextClusterFlags -> TextClusterFlags -> Bool
Eq)

instance P.Enum TextClusterFlags where
    fromEnum :: TextClusterFlags -> Int
fromEnum TextClusterFlagsBackward = 1
    fromEnum (AnotherTextClusterFlags k :: Int
k) = Int
k

    toEnum :: Int -> TextClusterFlags
toEnum 1 = TextClusterFlags
TextClusterFlagsBackward
    toEnum k :: Int
k = Int -> TextClusterFlags
AnotherTextClusterFlags Int
k

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

foreign import ccall "cairo_gobject_text_cluster_flags_get_type" c_cairo_gobject_text_cluster_flags_get_type :: 
    IO GType

instance BoxedEnum TextClusterFlags where
    boxedEnumType :: TextClusterFlags -> IO GType
boxedEnumType _ = IO GType
c_cairo_gobject_text_cluster_flags_get_type

-- Enum SurfaceType
-- | /No description available in the introspection data./
data SurfaceType = 
      SurfaceTypeImage
    -- ^ /No description available in the introspection data./
    | SurfaceTypePdf
    -- ^ /No description available in the introspection data./
    | SurfaceTypePs
    -- ^ /No description available in the introspection data./
    | SurfaceTypeXlib
    -- ^ /No description available in the introspection data./
    | SurfaceTypeXcb
    -- ^ /No description available in the introspection data./
    | SurfaceTypeGlitz
    -- ^ /No description available in the introspection data./
    | SurfaceTypeQuartz
    -- ^ /No description available in the introspection data./
    | SurfaceTypeWin32
    -- ^ /No description available in the introspection data./
    | SurfaceTypeBeos
    -- ^ /No description available in the introspection data./
    | SurfaceTypeDirectfb
    -- ^ /No description available in the introspection data./
    | SurfaceTypeSvg
    -- ^ /No description available in the introspection data./
    | SurfaceTypeOs2
    -- ^ /No description available in the introspection data./
    | SurfaceTypeWin32Printing
    -- ^ /No description available in the introspection data./
    | SurfaceTypeQuartzImage
    -- ^ /No description available in the introspection data./
    | SurfaceTypeScript
    -- ^ /No description available in the introspection data./
    | SurfaceTypeQt
    -- ^ /No description available in the introspection data./
    | SurfaceTypeRecording
    -- ^ /No description available in the introspection data./
    | SurfaceTypeVg
    -- ^ /No description available in the introspection data./
    | SurfaceTypeGl
    -- ^ /No description available in the introspection data./
    | SurfaceTypeDrm
    -- ^ /No description available in the introspection data./
    | SurfaceTypeTee
    -- ^ /No description available in the introspection data./
    | SurfaceTypeXml
    -- ^ /No description available in the introspection data./
    | SurfaceTypeSkia
    -- ^ /No description available in the introspection data./
    | SurfaceTypeSubsurface
    -- ^ /No description available in the introspection data./
    | SurfaceTypeCogl
    -- ^ /No description available in the introspection data./
    | AnotherSurfaceType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SurfaceType -> ShowS
[SurfaceType] -> ShowS
SurfaceType -> String
(Int -> SurfaceType -> ShowS)
-> (SurfaceType -> String)
-> ([SurfaceType] -> ShowS)
-> Show SurfaceType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SurfaceType] -> ShowS
$cshowList :: [SurfaceType] -> ShowS
show :: SurfaceType -> String
$cshow :: SurfaceType -> String
showsPrec :: Int -> SurfaceType -> ShowS
$cshowsPrec :: Int -> SurfaceType -> ShowS
Show, SurfaceType -> SurfaceType -> Bool
(SurfaceType -> SurfaceType -> Bool)
-> (SurfaceType -> SurfaceType -> Bool) -> Eq SurfaceType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SurfaceType -> SurfaceType -> Bool
$c/= :: SurfaceType -> SurfaceType -> Bool
== :: SurfaceType -> SurfaceType -> Bool
$c== :: SurfaceType -> SurfaceType -> Bool
Eq)

instance P.Enum SurfaceType where
    fromEnum :: SurfaceType -> Int
fromEnum SurfaceTypeImage = 0
    fromEnum SurfaceTypePdf = 1
    fromEnum SurfaceTypePs = 2
    fromEnum SurfaceTypeXlib = 3
    fromEnum SurfaceTypeXcb = 4
    fromEnum SurfaceTypeGlitz = 5
    fromEnum SurfaceTypeQuartz = 6
    fromEnum SurfaceTypeWin32 = 7
    fromEnum SurfaceTypeBeos = 8
    fromEnum SurfaceTypeDirectfb = 9
    fromEnum SurfaceTypeSvg = 10
    fromEnum SurfaceTypeOs2 = 11
    fromEnum SurfaceTypeWin32Printing = 12
    fromEnum SurfaceTypeQuartzImage = 13
    fromEnum SurfaceTypeScript = 14
    fromEnum SurfaceTypeQt = 15
    fromEnum SurfaceTypeRecording = 16
    fromEnum SurfaceTypeVg = 17
    fromEnum SurfaceTypeGl = 18
    fromEnum SurfaceTypeDrm = 19
    fromEnum SurfaceTypeTee = 20
    fromEnum SurfaceTypeXml = 21
    fromEnum SurfaceTypeSkia = 22
    fromEnum SurfaceTypeSubsurface = 23
    fromEnum SurfaceTypeCogl = 24
    fromEnum (AnotherSurfaceType k :: Int
k) = Int
k

    toEnum :: Int -> SurfaceType
toEnum 0 = SurfaceType
SurfaceTypeImage
    toEnum 1 = SurfaceType
SurfaceTypePdf
    toEnum 2 = SurfaceType
SurfaceTypePs
    toEnum 3 = SurfaceType
SurfaceTypeXlib
    toEnum 4 = SurfaceType
SurfaceTypeXcb
    toEnum 5 = SurfaceType
SurfaceTypeGlitz
    toEnum 6 = SurfaceType
SurfaceTypeQuartz
    toEnum 7 = SurfaceType
SurfaceTypeWin32
    toEnum 8 = SurfaceType
SurfaceTypeBeos
    toEnum 9 = SurfaceType
SurfaceTypeDirectfb
    toEnum 10 = SurfaceType
SurfaceTypeSvg
    toEnum 11 = SurfaceType
SurfaceTypeOs2
    toEnum 12 = SurfaceType
SurfaceTypeWin32Printing
    toEnum 13 = SurfaceType
SurfaceTypeQuartzImage
    toEnum 14 = SurfaceType
SurfaceTypeScript
    toEnum 15 = SurfaceType
SurfaceTypeQt
    toEnum 16 = SurfaceType
SurfaceTypeRecording
    toEnum 17 = SurfaceType
SurfaceTypeVg
    toEnum 18 = SurfaceType
SurfaceTypeGl
    toEnum 19 = SurfaceType
SurfaceTypeDrm
    toEnum 20 = SurfaceType
SurfaceTypeTee
    toEnum 21 = SurfaceType
SurfaceTypeXml
    toEnum 22 = SurfaceType
SurfaceTypeSkia
    toEnum 23 = SurfaceType
SurfaceTypeSubsurface
    toEnum 24 = SurfaceType
SurfaceTypeCogl
    toEnum k :: Int
k = Int -> SurfaceType
AnotherSurfaceType Int
k

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

foreign import ccall "cairo_gobject_surface_type_get_type" c_cairo_gobject_surface_type_get_type :: 
    IO GType

instance BoxedEnum SurfaceType where
    boxedEnumType :: SurfaceType -> IO GType
boxedEnumType _ = IO GType
c_cairo_gobject_surface_type_get_type

-- Enum SubpixelOrder
-- | /No description available in the introspection data./
data SubpixelOrder = 
      SubpixelOrderDefault
    -- ^ /No description available in the introspection data./
    | SubpixelOrderRgb
    -- ^ /No description available in the introspection data./
    | SubpixelOrderBgr
    -- ^ /No description available in the introspection data./
    | SubpixelOrderVrgb
    -- ^ /No description available in the introspection data./
    | SubpixelOrderVbgr
    -- ^ /No description available in the introspection data./
    | AnotherSubpixelOrder Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SubpixelOrder -> ShowS
[SubpixelOrder] -> ShowS
SubpixelOrder -> String
(Int -> SubpixelOrder -> ShowS)
-> (SubpixelOrder -> String)
-> ([SubpixelOrder] -> ShowS)
-> Show SubpixelOrder
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SubpixelOrder] -> ShowS
$cshowList :: [SubpixelOrder] -> ShowS
show :: SubpixelOrder -> String
$cshow :: SubpixelOrder -> String
showsPrec :: Int -> SubpixelOrder -> ShowS
$cshowsPrec :: Int -> SubpixelOrder -> ShowS
Show, SubpixelOrder -> SubpixelOrder -> Bool
(SubpixelOrder -> SubpixelOrder -> Bool)
-> (SubpixelOrder -> SubpixelOrder -> Bool) -> Eq SubpixelOrder
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SubpixelOrder -> SubpixelOrder -> Bool
$c/= :: SubpixelOrder -> SubpixelOrder -> Bool
== :: SubpixelOrder -> SubpixelOrder -> Bool
$c== :: SubpixelOrder -> SubpixelOrder -> Bool
Eq)

instance P.Enum SubpixelOrder where
    fromEnum :: SubpixelOrder -> Int
fromEnum SubpixelOrderDefault = 0
    fromEnum SubpixelOrderRgb = 1
    fromEnum SubpixelOrderBgr = 2
    fromEnum SubpixelOrderVrgb = 3
    fromEnum SubpixelOrderVbgr = 4
    fromEnum (AnotherSubpixelOrder k :: Int
k) = Int
k

    toEnum :: Int -> SubpixelOrder
toEnum 0 = SubpixelOrder
SubpixelOrderDefault
    toEnum 1 = SubpixelOrder
SubpixelOrderRgb
    toEnum 2 = SubpixelOrder
SubpixelOrderBgr
    toEnum 3 = SubpixelOrder
SubpixelOrderVrgb
    toEnum 4 = SubpixelOrder
SubpixelOrderVbgr
    toEnum k :: Int
k = Int -> SubpixelOrder
AnotherSubpixelOrder Int
k

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

foreign import ccall "cairo_gobject_subpixel_order_get_type" c_cairo_gobject_subpixel_order_get_type :: 
    IO GType

instance BoxedEnum SubpixelOrder where
    boxedEnumType :: SubpixelOrder -> IO GType
boxedEnumType _ = IO GType
c_cairo_gobject_subpixel_order_get_type

-- Enum Status
-- | /No description available in the introspection data./
data Status = 
      StatusSuccess
    -- ^ /No description available in the introspection data./
    | StatusNoMemory
    -- ^ /No description available in the introspection data./
    | StatusInvalidRestore
    -- ^ /No description available in the introspection data./
    | StatusInvalidPopGroup
    -- ^ /No description available in the introspection data./
    | StatusNoCurrentPoint
    -- ^ /No description available in the introspection data./
    | StatusInvalidMatrix
    -- ^ /No description available in the introspection data./
    | StatusInvalidStatus
    -- ^ /No description available in the introspection data./
    | StatusNullPointer
    -- ^ /No description available in the introspection data./
    | StatusInvalidString
    -- ^ /No description available in the introspection data./
    | StatusInvalidPathData
    -- ^ /No description available in the introspection data./
    | StatusReadError
    -- ^ /No description available in the introspection data./
    | StatusWriteError
    -- ^ /No description available in the introspection data./
    | StatusSurfaceFinished
    -- ^ /No description available in the introspection data./
    | StatusSurfaceTypeMismatch
    -- ^ /No description available in the introspection data./
    | StatusPatternTypeMismatch
    -- ^ /No description available in the introspection data./
    | StatusInvalidContent
    -- ^ /No description available in the introspection data./
    | StatusInvalidFormat
    -- ^ /No description available in the introspection data./
    | StatusInvalidVisual
    -- ^ /No description available in the introspection data./
    | StatusFileNotFound
    -- ^ /No description available in the introspection data./
    | StatusInvalidDash
    -- ^ /No description available in the introspection data./
    | StatusInvalidDscComment
    -- ^ /No description available in the introspection data./
    | StatusInvalidIndex
    -- ^ /No description available in the introspection data./
    | StatusClipNotRepresentable
    -- ^ /No description available in the introspection data./
    | StatusTempFileError
    -- ^ /No description available in the introspection data./
    | StatusInvalidStride
    -- ^ /No description available in the introspection data./
    | StatusFontTypeMismatch
    -- ^ /No description available in the introspection data./
    | StatusUserFontImmutable
    -- ^ /No description available in the introspection data./
    | StatusUserFontError
    -- ^ /No description available in the introspection data./
    | StatusNegativeCount
    -- ^ /No description available in the introspection data./
    | StatusInvalidClusters
    -- ^ /No description available in the introspection data./
    | StatusInvalidSlant
    -- ^ /No description available in the introspection data./
    | StatusInvalidWeight
    -- ^ /No description available in the introspection data./
    | StatusInvalidSize
    -- ^ /No description available in the introspection data./
    | StatusUserFontNotImplemented
    -- ^ /No description available in the introspection data./
    | StatusDeviceTypeMismatch
    -- ^ /No description available in the introspection data./
    | StatusDeviceError
    -- ^ /No description available in the introspection data./
    | StatusInvalidMeshConstruction
    -- ^ /No description available in the introspection data./
    | StatusDeviceFinished
    -- ^ /No description available in the introspection data./
    | StatusJbig2GlobalMissing
    -- ^ /No description available in the introspection data./
    | AnotherStatus Int
    -- ^ Catch-all for unknown values
    deriving (Int -> Status -> ShowS
[Status] -> ShowS
Status -> String
(Int -> Status -> ShowS)
-> (Status -> String) -> ([Status] -> ShowS) -> Show Status
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Status] -> ShowS
$cshowList :: [Status] -> ShowS
show :: Status -> String
$cshow :: Status -> String
showsPrec :: Int -> Status -> ShowS
$cshowsPrec :: Int -> Status -> ShowS
Show, Status -> Status -> Bool
(Status -> Status -> Bool)
-> (Status -> Status -> Bool) -> Eq Status
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Status -> Status -> Bool
$c/= :: Status -> Status -> Bool
== :: Status -> Status -> Bool
$c== :: Status -> Status -> Bool
Eq)

instance P.Enum Status where
    fromEnum :: Status -> Int
fromEnum StatusSuccess = 0
    fromEnum StatusNoMemory = 1
    fromEnum StatusInvalidRestore = 2
    fromEnum StatusInvalidPopGroup = 3
    fromEnum StatusNoCurrentPoint = 4
    fromEnum StatusInvalidMatrix = 5
    fromEnum StatusInvalidStatus = 6
    fromEnum StatusNullPointer = 7
    fromEnum StatusInvalidString = 8
    fromEnum StatusInvalidPathData = 9
    fromEnum StatusReadError = 10
    fromEnum StatusWriteError = 11
    fromEnum StatusSurfaceFinished = 12
    fromEnum StatusSurfaceTypeMismatch = 13
    fromEnum StatusPatternTypeMismatch = 14
    fromEnum StatusInvalidContent = 15
    fromEnum StatusInvalidFormat = 16
    fromEnum StatusInvalidVisual = 17
    fromEnum StatusFileNotFound = 18
    fromEnum StatusInvalidDash = 19
    fromEnum StatusInvalidDscComment = 20
    fromEnum StatusInvalidIndex = 21
    fromEnum StatusClipNotRepresentable = 22
    fromEnum StatusTempFileError = 23
    fromEnum StatusInvalidStride = 24
    fromEnum StatusFontTypeMismatch = 25
    fromEnum StatusUserFontImmutable = 26
    fromEnum StatusUserFontError = 27
    fromEnum StatusNegativeCount = 28
    fromEnum StatusInvalidClusters = 29
    fromEnum StatusInvalidSlant = 30
    fromEnum StatusInvalidWeight = 31
    fromEnum StatusInvalidSize = 32
    fromEnum StatusUserFontNotImplemented = 33
    fromEnum StatusDeviceTypeMismatch = 34
    fromEnum StatusDeviceError = 35
    fromEnum StatusInvalidMeshConstruction = 36
    fromEnum StatusDeviceFinished = 37
    fromEnum StatusJbig2GlobalMissing = 38
    fromEnum (AnotherStatus k :: Int
k) = Int
k

    toEnum :: Int -> Status
toEnum 0 = Status
StatusSuccess
    toEnum 1 = Status
StatusNoMemory
    toEnum 2 = Status
StatusInvalidRestore
    toEnum 3 = Status
StatusInvalidPopGroup
    toEnum 4 = Status
StatusNoCurrentPoint
    toEnum 5 = Status
StatusInvalidMatrix
    toEnum 6 = Status
StatusInvalidStatus
    toEnum 7 = Status
StatusNullPointer
    toEnum 8 = Status
StatusInvalidString
    toEnum 9 = Status
StatusInvalidPathData
    toEnum 10 = Status
StatusReadError
    toEnum 11 = Status
StatusWriteError
    toEnum 12 = Status
StatusSurfaceFinished
    toEnum 13 = Status
StatusSurfaceTypeMismatch
    toEnum 14 = Status
StatusPatternTypeMismatch
    toEnum 15 = Status
StatusInvalidContent
    toEnum 16 = Status
StatusInvalidFormat
    toEnum 17 = Status
StatusInvalidVisual
    toEnum 18 = Status
StatusFileNotFound
    toEnum 19 = Status
StatusInvalidDash
    toEnum 20 = Status
StatusInvalidDscComment
    toEnum 21 = Status
StatusInvalidIndex
    toEnum 22 = Status
StatusClipNotRepresentable
    toEnum 23 = Status
StatusTempFileError
    toEnum 24 = Status
StatusInvalidStride
    toEnum 25 = Status
StatusFontTypeMismatch
    toEnum 26 = Status
StatusUserFontImmutable
    toEnum 27 = Status
StatusUserFontError
    toEnum 28 = Status
StatusNegativeCount
    toEnum 29 = Status
StatusInvalidClusters
    toEnum 30 = Status
StatusInvalidSlant
    toEnum 31 = Status
StatusInvalidWeight
    toEnum 32 = Status
StatusInvalidSize
    toEnum 33 = Status
StatusUserFontNotImplemented
    toEnum 34 = Status
StatusDeviceTypeMismatch
    toEnum 35 = Status
StatusDeviceError
    toEnum 36 = Status
StatusInvalidMeshConstruction
    toEnum 37 = Status
StatusDeviceFinished
    toEnum 38 = Status
StatusJbig2GlobalMissing
    toEnum k :: Int
k = Int -> Status
AnotherStatus Int
k

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

foreign import ccall "cairo_gobject_status_get_type" c_cairo_gobject_status_get_type :: 
    IO GType

instance BoxedEnum Status where
    boxedEnumType :: Status -> IO GType
boxedEnumType _ = IO GType
c_cairo_gobject_status_get_type

-- Enum RegionOverlap
-- | /No description available in the introspection data./
data RegionOverlap = 
      RegionOverlapIn
    -- ^ /No description available in the introspection data./
    | RegionOverlapOut
    -- ^ /No description available in the introspection data./
    | RegionOverlapPart
    -- ^ /No description available in the introspection data./
    | AnotherRegionOverlap Int
    -- ^ Catch-all for unknown values
    deriving (Int -> RegionOverlap -> ShowS
[RegionOverlap] -> ShowS
RegionOverlap -> String
(Int -> RegionOverlap -> ShowS)
-> (RegionOverlap -> String)
-> ([RegionOverlap] -> ShowS)
-> Show RegionOverlap
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RegionOverlap] -> ShowS
$cshowList :: [RegionOverlap] -> ShowS
show :: RegionOverlap -> String
$cshow :: RegionOverlap -> String
showsPrec :: Int -> RegionOverlap -> ShowS
$cshowsPrec :: Int -> RegionOverlap -> ShowS
Show, RegionOverlap -> RegionOverlap -> Bool
(RegionOverlap -> RegionOverlap -> Bool)
-> (RegionOverlap -> RegionOverlap -> Bool) -> Eq RegionOverlap
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RegionOverlap -> RegionOverlap -> Bool
$c/= :: RegionOverlap -> RegionOverlap -> Bool
== :: RegionOverlap -> RegionOverlap -> Bool
$c== :: RegionOverlap -> RegionOverlap -> Bool
Eq)

instance P.Enum RegionOverlap where
    fromEnum :: RegionOverlap -> Int
fromEnum RegionOverlapIn = 0
    fromEnum RegionOverlapOut = 1
    fromEnum RegionOverlapPart = 2
    fromEnum (AnotherRegionOverlap k :: Int
k) = Int
k

    toEnum :: Int -> RegionOverlap
toEnum 0 = RegionOverlap
RegionOverlapIn
    toEnum 1 = RegionOverlap
RegionOverlapOut
    toEnum 2 = RegionOverlap
RegionOverlapPart
    toEnum k :: Int
k = Int -> RegionOverlap
AnotherRegionOverlap Int
k

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

foreign import ccall "cairo_gobject_region_overlap_get_type" c_cairo_gobject_region_overlap_get_type :: 
    IO GType

instance BoxedEnum RegionOverlap where
    boxedEnumType :: RegionOverlap -> IO GType
boxedEnumType _ = IO GType
c_cairo_gobject_region_overlap_get_type

-- Enum PatternType
-- | /No description available in the introspection data./
data PatternType = 
      PatternTypeSolid
    -- ^ /No description available in the introspection data./
    | PatternTypeSurface
    -- ^ /No description available in the introspection data./
    | PatternTypeLinear
    -- ^ /No description available in the introspection data./
    | PatternTypeRadial
    -- ^ /No description available in the introspection data./
    | PatternTypeMesh
    -- ^ /No description available in the introspection data./
    | PatternTypeRasterSource
    -- ^ /No description available in the introspection data./
    | AnotherPatternType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> PatternType -> ShowS
[PatternType] -> ShowS
PatternType -> String
(Int -> PatternType -> ShowS)
-> (PatternType -> String)
-> ([PatternType] -> ShowS)
-> Show PatternType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PatternType] -> ShowS
$cshowList :: [PatternType] -> ShowS
show :: PatternType -> String
$cshow :: PatternType -> String
showsPrec :: Int -> PatternType -> ShowS
$cshowsPrec :: Int -> PatternType -> ShowS
Show, PatternType -> PatternType -> Bool
(PatternType -> PatternType -> Bool)
-> (PatternType -> PatternType -> Bool) -> Eq PatternType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PatternType -> PatternType -> Bool
$c/= :: PatternType -> PatternType -> Bool
== :: PatternType -> PatternType -> Bool
$c== :: PatternType -> PatternType -> Bool
Eq)

instance P.Enum PatternType where
    fromEnum :: PatternType -> Int
fromEnum PatternTypeSolid = 0
    fromEnum PatternTypeSurface = 1
    fromEnum PatternTypeLinear = 2
    fromEnum PatternTypeRadial = 3
    fromEnum PatternTypeMesh = 4
    fromEnum PatternTypeRasterSource = 5
    fromEnum (AnotherPatternType k :: Int
k) = Int
k

    toEnum :: Int -> PatternType
toEnum 0 = PatternType
PatternTypeSolid
    toEnum 1 = PatternType
PatternTypeSurface
    toEnum 2 = PatternType
PatternTypeLinear
    toEnum 3 = PatternType
PatternTypeRadial
    toEnum 4 = PatternType
PatternTypeMesh
    toEnum 5 = PatternType
PatternTypeRasterSource
    toEnum k :: Int
k = Int -> PatternType
AnotherPatternType Int
k

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

foreign import ccall "cairo_gobject_pattern_type_get_type" c_cairo_gobject_pattern_type_get_type :: 
    IO GType

instance BoxedEnum PatternType where
    boxedEnumType :: PatternType -> IO GType
boxedEnumType _ = IO GType
c_cairo_gobject_pattern_type_get_type

-- Enum PathDataType
-- | /No description available in the introspection data./
data PathDataType = 
      PathDataTypeMoveTo
    -- ^ /No description available in the introspection data./
    | PathDataTypeLineTo
    -- ^ /No description available in the introspection data./
    | PathDataTypeCurveTo
    -- ^ /No description available in the introspection data./
    | PathDataTypeClosePath
    -- ^ /No description available in the introspection data./
    | AnotherPathDataType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> PathDataType -> ShowS
[PathDataType] -> ShowS
PathDataType -> String
(Int -> PathDataType -> ShowS)
-> (PathDataType -> String)
-> ([PathDataType] -> ShowS)
-> Show PathDataType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PathDataType] -> ShowS
$cshowList :: [PathDataType] -> ShowS
show :: PathDataType -> String
$cshow :: PathDataType -> String
showsPrec :: Int -> PathDataType -> ShowS
$cshowsPrec :: Int -> PathDataType -> ShowS
Show, PathDataType -> PathDataType -> Bool
(PathDataType -> PathDataType -> Bool)
-> (PathDataType -> PathDataType -> Bool) -> Eq PathDataType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PathDataType -> PathDataType -> Bool
$c/= :: PathDataType -> PathDataType -> Bool
== :: PathDataType -> PathDataType -> Bool
$c== :: PathDataType -> PathDataType -> Bool
Eq)

instance P.Enum PathDataType where
    fromEnum :: PathDataType -> Int
fromEnum PathDataTypeMoveTo = 0
    fromEnum PathDataTypeLineTo = 1
    fromEnum PathDataTypeCurveTo = 2
    fromEnum PathDataTypeClosePath = 3
    fromEnum (AnotherPathDataType k :: Int
k) = Int
k

    toEnum :: Int -> PathDataType
toEnum 0 = PathDataType
PathDataTypeMoveTo
    toEnum 1 = PathDataType
PathDataTypeLineTo
    toEnum 2 = PathDataType
PathDataTypeCurveTo
    toEnum 3 = PathDataType
PathDataTypeClosePath
    toEnum k :: Int
k = Int -> PathDataType
AnotherPathDataType Int
k

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

foreign import ccall "cairo_gobject_path_data_type_get_type" c_cairo_gobject_path_data_type_get_type :: 
    IO GType

instance BoxedEnum PathDataType where
    boxedEnumType :: PathDataType -> IO GType
boxedEnumType _ = IO GType
c_cairo_gobject_path_data_type_get_type

-- Enum Operator
-- | /No description available in the introspection data./
data Operator = 
      OperatorClear
    -- ^ /No description available in the introspection data./
    | OperatorSource
    -- ^ /No description available in the introspection data./
    | OperatorOver
    -- ^ /No description available in the introspection data./
    | OperatorIn
    -- ^ /No description available in the introspection data./
    | OperatorOut
    -- ^ /No description available in the introspection data./
    | OperatorAtop
    -- ^ /No description available in the introspection data./
    | OperatorDest
    -- ^ /No description available in the introspection data./
    | OperatorDestOver
    -- ^ /No description available in the introspection data./
    | OperatorDestIn
    -- ^ /No description available in the introspection data./
    | OperatorDestOut
    -- ^ /No description available in the introspection data./
    | OperatorDestAtop
    -- ^ /No description available in the introspection data./
    | OperatorXor
    -- ^ /No description available in the introspection data./
    | OperatorAdd
    -- ^ /No description available in the introspection data./
    | OperatorSaturate
    -- ^ /No description available in the introspection data./
    | OperatorMultiply
    -- ^ /No description available in the introspection data./
    | OperatorScreen
    -- ^ /No description available in the introspection data./
    | OperatorOverlay
    -- ^ /No description available in the introspection data./
    | OperatorDarken
    -- ^ /No description available in the introspection data./
    | OperatorLighten
    -- ^ /No description available in the introspection data./
    | OperatorColorDodge
    -- ^ /No description available in the introspection data./
    | OperatorColorBurn
    -- ^ /No description available in the introspection data./
    | OperatorHardLight
    -- ^ /No description available in the introspection data./
    | OperatorSoftLight
    -- ^ /No description available in the introspection data./
    | OperatorDifference
    -- ^ /No description available in the introspection data./
    | OperatorExclusion
    -- ^ /No description available in the introspection data./
    | OperatorHslHue
    -- ^ /No description available in the introspection data./
    | OperatorHslSaturation
    -- ^ /No description available in the introspection data./
    | OperatorHslColor
    -- ^ /No description available in the introspection data./
    | OperatorHslLuminosity
    -- ^ /No description available in the introspection data./
    | AnotherOperator Int
    -- ^ Catch-all for unknown values
    deriving (Int -> Operator -> ShowS
[Operator] -> ShowS
Operator -> String
(Int -> Operator -> ShowS)
-> (Operator -> String) -> ([Operator] -> ShowS) -> Show Operator
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Operator] -> ShowS
$cshowList :: [Operator] -> ShowS
show :: Operator -> String
$cshow :: Operator -> String
showsPrec :: Int -> Operator -> ShowS
$cshowsPrec :: Int -> Operator -> ShowS
Show, Operator -> Operator -> Bool
(Operator -> Operator -> Bool)
-> (Operator -> Operator -> Bool) -> Eq Operator
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Operator -> Operator -> Bool
$c/= :: Operator -> Operator -> Bool
== :: Operator -> Operator -> Bool
$c== :: Operator -> Operator -> Bool
Eq)

instance P.Enum Operator where
    fromEnum :: Operator -> Int
fromEnum OperatorClear = 0
    fromEnum OperatorSource = 1
    fromEnum OperatorOver = 2
    fromEnum OperatorIn = 3
    fromEnum OperatorOut = 4
    fromEnum OperatorAtop = 5
    fromEnum OperatorDest = 6
    fromEnum OperatorDestOver = 7
    fromEnum OperatorDestIn = 8
    fromEnum OperatorDestOut = 9
    fromEnum OperatorDestAtop = 10
    fromEnum OperatorXor = 11
    fromEnum OperatorAdd = 12
    fromEnum OperatorSaturate = 13
    fromEnum OperatorMultiply = 14
    fromEnum OperatorScreen = 15
    fromEnum OperatorOverlay = 16
    fromEnum OperatorDarken = 17
    fromEnum OperatorLighten = 18
    fromEnum OperatorColorDodge = 19
    fromEnum OperatorColorBurn = 20
    fromEnum OperatorHardLight = 21
    fromEnum OperatorSoftLight = 22
    fromEnum OperatorDifference = 23
    fromEnum OperatorExclusion = 24
    fromEnum OperatorHslHue = 25
    fromEnum OperatorHslSaturation = 26
    fromEnum OperatorHslColor = 27
    fromEnum OperatorHslLuminosity = 28
    fromEnum (AnotherOperator k :: Int
k) = Int
k

    toEnum :: Int -> Operator
toEnum 0 = Operator
OperatorClear
    toEnum 1 = Operator
OperatorSource
    toEnum 2 = Operator
OperatorOver
    toEnum 3 = Operator
OperatorIn
    toEnum 4 = Operator
OperatorOut
    toEnum 5 = Operator
OperatorAtop
    toEnum 6 = Operator
OperatorDest
    toEnum 7 = Operator
OperatorDestOver
    toEnum 8 = Operator
OperatorDestIn
    toEnum 9 = Operator
OperatorDestOut
    toEnum 10 = Operator
OperatorDestAtop
    toEnum 11 = Operator
OperatorXor
    toEnum 12 = Operator
OperatorAdd
    toEnum 13 = Operator
OperatorSaturate
    toEnum 14 = Operator
OperatorMultiply
    toEnum 15 = Operator
OperatorScreen
    toEnum 16 = Operator
OperatorOverlay
    toEnum 17 = Operator
OperatorDarken
    toEnum 18 = Operator
OperatorLighten
    toEnum 19 = Operator
OperatorColorDodge
    toEnum 20 = Operator
OperatorColorBurn
    toEnum 21 = Operator
OperatorHardLight
    toEnum 22 = Operator
OperatorSoftLight
    toEnum 23 = Operator
OperatorDifference
    toEnum 24 = Operator
OperatorExclusion
    toEnum 25 = Operator
OperatorHslHue
    toEnum 26 = Operator
OperatorHslSaturation
    toEnum 27 = Operator
OperatorHslColor
    toEnum 28 = Operator
OperatorHslLuminosity
    toEnum k :: Int
k = Int -> Operator
AnotherOperator Int
k

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

foreign import ccall "cairo_gobject_operator_get_type" c_cairo_gobject_operator_get_type :: 
    IO GType

instance BoxedEnum Operator where
    boxedEnumType :: Operator -> IO GType
boxedEnumType _ = IO GType
c_cairo_gobject_operator_get_type

-- Enum LineJoin
-- | /No description available in the introspection data./
data LineJoin = 
      LineJoinMiter
    -- ^ /No description available in the introspection data./
    | LineJoinRound
    -- ^ /No description available in the introspection data./
    | LineJoinBevel
    -- ^ /No description available in the introspection data./
    | AnotherLineJoin Int
    -- ^ Catch-all for unknown values
    deriving (Int -> LineJoin -> ShowS
[LineJoin] -> ShowS
LineJoin -> String
(Int -> LineJoin -> ShowS)
-> (LineJoin -> String) -> ([LineJoin] -> ShowS) -> Show LineJoin
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [LineJoin] -> ShowS
$cshowList :: [LineJoin] -> ShowS
show :: LineJoin -> String
$cshow :: LineJoin -> String
showsPrec :: Int -> LineJoin -> ShowS
$cshowsPrec :: Int -> LineJoin -> ShowS
Show, LineJoin -> LineJoin -> Bool
(LineJoin -> LineJoin -> Bool)
-> (LineJoin -> LineJoin -> Bool) -> Eq LineJoin
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: LineJoin -> LineJoin -> Bool
$c/= :: LineJoin -> LineJoin -> Bool
== :: LineJoin -> LineJoin -> Bool
$c== :: LineJoin -> LineJoin -> Bool
Eq)

instance P.Enum LineJoin where
    fromEnum :: LineJoin -> Int
fromEnum LineJoinMiter = 0
    fromEnum LineJoinRound = 1
    fromEnum LineJoinBevel = 2
    fromEnum (AnotherLineJoin k :: Int
k) = Int
k

    toEnum :: Int -> LineJoin
toEnum 0 = LineJoin
LineJoinMiter
    toEnum 1 = LineJoin
LineJoinRound
    toEnum 2 = LineJoin
LineJoinBevel
    toEnum k :: Int
k = Int -> LineJoin
AnotherLineJoin Int
k

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

foreign import ccall "cairo_gobject_line_join_get_type" c_cairo_gobject_line_join_get_type :: 
    IO GType

instance BoxedEnum LineJoin where
    boxedEnumType :: LineJoin -> IO GType
boxedEnumType _ = IO GType
c_cairo_gobject_line_join_get_type

-- Enum LineCap
-- | /No description available in the introspection data./
data LineCap = 
      LineCapButt
    -- ^ /No description available in the introspection data./
    | LineCapRound
    -- ^ /No description available in the introspection data./
    | LineCapSquare
    -- ^ /No description available in the introspection data./
    | AnotherLineCap Int
    -- ^ Catch-all for unknown values
    deriving (Int -> LineCap -> ShowS
[LineCap] -> ShowS
LineCap -> String
(Int -> LineCap -> ShowS)
-> (LineCap -> String) -> ([LineCap] -> ShowS) -> Show LineCap
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [LineCap] -> ShowS
$cshowList :: [LineCap] -> ShowS
show :: LineCap -> String
$cshow :: LineCap -> String
showsPrec :: Int -> LineCap -> ShowS
$cshowsPrec :: Int -> LineCap -> ShowS
Show, LineCap -> LineCap -> Bool
(LineCap -> LineCap -> Bool)
-> (LineCap -> LineCap -> Bool) -> Eq LineCap
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: LineCap -> LineCap -> Bool
$c/= :: LineCap -> LineCap -> Bool
== :: LineCap -> LineCap -> Bool
$c== :: LineCap -> LineCap -> Bool
Eq)

instance P.Enum LineCap where
    fromEnum :: LineCap -> Int
fromEnum LineCapButt = 0
    fromEnum LineCapRound = 1
    fromEnum LineCapSquare = 2
    fromEnum (AnotherLineCap k :: Int
k) = Int
k

    toEnum :: Int -> LineCap
toEnum 0 = LineCap
LineCapButt
    toEnum 1 = LineCap
LineCapRound
    toEnum 2 = LineCap
LineCapSquare
    toEnum k :: Int
k = Int -> LineCap
AnotherLineCap Int
k

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

foreign import ccall "cairo_gobject_line_cap_get_type" c_cairo_gobject_line_cap_get_type :: 
    IO GType

instance BoxedEnum LineCap where
    boxedEnumType :: LineCap -> IO GType
boxedEnumType _ = IO GType
c_cairo_gobject_line_cap_get_type

-- Enum HintStyle
-- | /No description available in the introspection data./
data HintStyle = 
      HintStyleDefault
    -- ^ /No description available in the introspection data./
    | HintStyleNone
    -- ^ /No description available in the introspection data./
    | HintStyleSlight
    -- ^ /No description available in the introspection data./
    | HintStyleMedium
    -- ^ /No description available in the introspection data./
    | HintStyleFull
    -- ^ /No description available in the introspection data./
    | AnotherHintStyle Int
    -- ^ Catch-all for unknown values
    deriving (Int -> HintStyle -> ShowS
[HintStyle] -> ShowS
HintStyle -> String
(Int -> HintStyle -> ShowS)
-> (HintStyle -> String)
-> ([HintStyle] -> ShowS)
-> Show HintStyle
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [HintStyle] -> ShowS
$cshowList :: [HintStyle] -> ShowS
show :: HintStyle -> String
$cshow :: HintStyle -> String
showsPrec :: Int -> HintStyle -> ShowS
$cshowsPrec :: Int -> HintStyle -> ShowS
Show, HintStyle -> HintStyle -> Bool
(HintStyle -> HintStyle -> Bool)
-> (HintStyle -> HintStyle -> Bool) -> Eq HintStyle
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: HintStyle -> HintStyle -> Bool
$c/= :: HintStyle -> HintStyle -> Bool
== :: HintStyle -> HintStyle -> Bool
$c== :: HintStyle -> HintStyle -> Bool
Eq)

instance P.Enum HintStyle where
    fromEnum :: HintStyle -> Int
fromEnum HintStyleDefault = 0
    fromEnum HintStyleNone = 1
    fromEnum HintStyleSlight = 2
    fromEnum HintStyleMedium = 3
    fromEnum HintStyleFull = 4
    fromEnum (AnotherHintStyle k :: Int
k) = Int
k

    toEnum :: Int -> HintStyle
toEnum 0 = HintStyle
HintStyleDefault
    toEnum 1 = HintStyle
HintStyleNone
    toEnum 2 = HintStyle
HintStyleSlight
    toEnum 3 = HintStyle
HintStyleMedium
    toEnum 4 = HintStyle
HintStyleFull
    toEnum k :: Int
k = Int -> HintStyle
AnotherHintStyle Int
k

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

foreign import ccall "cairo_gobject_hint_style_get_type" c_cairo_gobject_hint_style_get_type :: 
    IO GType

instance BoxedEnum HintStyle where
    boxedEnumType :: HintStyle -> IO GType
boxedEnumType _ = IO GType
c_cairo_gobject_hint_style_get_type

-- Enum HintMetrics
-- | /No description available in the introspection data./
data HintMetrics = 
      HintMetricsDefault
    -- ^ /No description available in the introspection data./
    | HintMetricsOff
    -- ^ /No description available in the introspection data./
    | HintMetricsOn
    -- ^ /No description available in the introspection data./
    | AnotherHintMetrics Int
    -- ^ Catch-all for unknown values
    deriving (Int -> HintMetrics -> ShowS
[HintMetrics] -> ShowS
HintMetrics -> String
(Int -> HintMetrics -> ShowS)
-> (HintMetrics -> String)
-> ([HintMetrics] -> ShowS)
-> Show HintMetrics
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [HintMetrics] -> ShowS
$cshowList :: [HintMetrics] -> ShowS
show :: HintMetrics -> String
$cshow :: HintMetrics -> String
showsPrec :: Int -> HintMetrics -> ShowS
$cshowsPrec :: Int -> HintMetrics -> ShowS
Show, HintMetrics -> HintMetrics -> Bool
(HintMetrics -> HintMetrics -> Bool)
-> (HintMetrics -> HintMetrics -> Bool) -> Eq HintMetrics
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: HintMetrics -> HintMetrics -> Bool
$c/= :: HintMetrics -> HintMetrics -> Bool
== :: HintMetrics -> HintMetrics -> Bool
$c== :: HintMetrics -> HintMetrics -> Bool
Eq)

instance P.Enum HintMetrics where
    fromEnum :: HintMetrics -> Int
fromEnum HintMetricsDefault = 0
    fromEnum HintMetricsOff = 1
    fromEnum HintMetricsOn = 2
    fromEnum (AnotherHintMetrics k :: Int
k) = Int
k

    toEnum :: Int -> HintMetrics
toEnum 0 = HintMetrics
HintMetricsDefault
    toEnum 1 = HintMetrics
HintMetricsOff
    toEnum 2 = HintMetrics
HintMetricsOn
    toEnum k :: Int
k = Int -> HintMetrics
AnotherHintMetrics Int
k

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

foreign import ccall "cairo_gobject_hint_metrics_get_type" c_cairo_gobject_hint_metrics_get_type :: 
    IO GType

instance BoxedEnum HintMetrics where
    boxedEnumType :: HintMetrics -> IO GType
boxedEnumType _ = IO GType
c_cairo_gobject_hint_metrics_get_type

-- Enum Format
-- | /No description available in the introspection data./
data Format = 
      FormatInvalid
    -- ^ /No description available in the introspection data./
    | FormatArgb32
    -- ^ /No description available in the introspection data./
    | FormatRgb24
    -- ^ /No description available in the introspection data./
    | FormatA8
    -- ^ /No description available in the introspection data./
    | FormatA1
    -- ^ /No description available in the introspection data./
    | FormatRgb16565
    -- ^ /No description available in the introspection data./
    | FormatRgb30
    -- ^ /No description available in the introspection data./
    | AnotherFormat Int
    -- ^ Catch-all for unknown values
    deriving (Int -> Format -> ShowS
[Format] -> ShowS
Format -> String
(Int -> Format -> ShowS)
-> (Format -> String) -> ([Format] -> ShowS) -> Show Format
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Format] -> ShowS
$cshowList :: [Format] -> ShowS
show :: Format -> String
$cshow :: Format -> String
showsPrec :: Int -> Format -> ShowS
$cshowsPrec :: Int -> Format -> ShowS
Show, Format -> Format -> Bool
(Format -> Format -> Bool)
-> (Format -> Format -> Bool) -> Eq Format
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Format -> Format -> Bool
$c/= :: Format -> Format -> Bool
== :: Format -> Format -> Bool
$c== :: Format -> Format -> Bool
Eq)

instance P.Enum Format where
    fromEnum :: Format -> Int
fromEnum FormatInvalid = -1
    fromEnum FormatArgb32 = 0
    fromEnum FormatRgb24 = 1
    fromEnum FormatA8 = 2
    fromEnum FormatA1 = 3
    fromEnum FormatRgb16565 = 4
    fromEnum FormatRgb30 = 5
    fromEnum (AnotherFormat k :: Int
k) = Int
k

    toEnum :: Int -> Format
toEnum -1 = Format
FormatInvalid
    toEnum 0 = Format
FormatArgb32
    toEnum 1 = Format
FormatRgb24
    toEnum 2 = Format
FormatA8
    toEnum 3 = Format
FormatA1
    toEnum 4 = Format
FormatRgb16565
    toEnum 5 = Format
FormatRgb30
    toEnum k :: Int
k = Int -> Format
AnotherFormat Int
k

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

foreign import ccall "cairo_gobject_format_get_type" c_cairo_gobject_format_get_type :: 
    IO GType

instance BoxedEnum Format where
    boxedEnumType :: Format -> IO GType
boxedEnumType _ = IO GType
c_cairo_gobject_format_get_type

-- Enum FontWeight
-- | /No description available in the introspection data./
data FontWeight = 
      FontWeightNormal
    -- ^ /No description available in the introspection data./
    | FontWeightBold
    -- ^ /No description available in the introspection data./
    | AnotherFontWeight Int
    -- ^ Catch-all for unknown values
    deriving (Int -> FontWeight -> ShowS
[FontWeight] -> ShowS
FontWeight -> String
(Int -> FontWeight -> ShowS)
-> (FontWeight -> String)
-> ([FontWeight] -> ShowS)
-> Show FontWeight
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FontWeight] -> ShowS
$cshowList :: [FontWeight] -> ShowS
show :: FontWeight -> String
$cshow :: FontWeight -> String
showsPrec :: Int -> FontWeight -> ShowS
$cshowsPrec :: Int -> FontWeight -> ShowS
Show, FontWeight -> FontWeight -> Bool
(FontWeight -> FontWeight -> Bool)
-> (FontWeight -> FontWeight -> Bool) -> Eq FontWeight
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FontWeight -> FontWeight -> Bool
$c/= :: FontWeight -> FontWeight -> Bool
== :: FontWeight -> FontWeight -> Bool
$c== :: FontWeight -> FontWeight -> Bool
Eq)

instance P.Enum FontWeight where
    fromEnum :: FontWeight -> Int
fromEnum FontWeightNormal = 0
    fromEnum FontWeightBold = 1
    fromEnum (AnotherFontWeight k :: Int
k) = Int
k

    toEnum :: Int -> FontWeight
toEnum 0 = FontWeight
FontWeightNormal
    toEnum 1 = FontWeight
FontWeightBold
    toEnum k :: Int
k = Int -> FontWeight
AnotherFontWeight Int
k

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

foreign import ccall "cairo_gobject_font_weight_get_type" c_cairo_gobject_font_weight_get_type :: 
    IO GType

instance BoxedEnum FontWeight where
    boxedEnumType :: FontWeight -> IO GType
boxedEnumType _ = IO GType
c_cairo_gobject_font_weight_get_type

-- Enum FontType
-- | /No description available in the introspection data./
data FontType = 
      FontTypeToy
    -- ^ /No description available in the introspection data./
    | FontTypeFt
    -- ^ /No description available in the introspection data./
    | FontTypeWin32
    -- ^ /No description available in the introspection data./
    | FontTypeQuartz
    -- ^ /No description available in the introspection data./
    | FontTypeUser
    -- ^ /No description available in the introspection data./
    | AnotherFontType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> FontType -> ShowS
[FontType] -> ShowS
FontType -> String
(Int -> FontType -> ShowS)
-> (FontType -> String) -> ([FontType] -> ShowS) -> Show FontType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FontType] -> ShowS
$cshowList :: [FontType] -> ShowS
show :: FontType -> String
$cshow :: FontType -> String
showsPrec :: Int -> FontType -> ShowS
$cshowsPrec :: Int -> FontType -> ShowS
Show, FontType -> FontType -> Bool
(FontType -> FontType -> Bool)
-> (FontType -> FontType -> Bool) -> Eq FontType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FontType -> FontType -> Bool
$c/= :: FontType -> FontType -> Bool
== :: FontType -> FontType -> Bool
$c== :: FontType -> FontType -> Bool
Eq)

instance P.Enum FontType where
    fromEnum :: FontType -> Int
fromEnum FontTypeToy = 0
    fromEnum FontTypeFt = 1
    fromEnum FontTypeWin32 = 2
    fromEnum FontTypeQuartz = 3
    fromEnum FontTypeUser = 4
    fromEnum (AnotherFontType k :: Int
k) = Int
k

    toEnum :: Int -> FontType
toEnum 0 = FontType
FontTypeToy
    toEnum 1 = FontType
FontTypeFt
    toEnum 2 = FontType
FontTypeWin32
    toEnum 3 = FontType
FontTypeQuartz
    toEnum 4 = FontType
FontTypeUser
    toEnum k :: Int
k = Int -> FontType
AnotherFontType Int
k

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

foreign import ccall "cairo_gobject_font_type_get_type" c_cairo_gobject_font_type_get_type :: 
    IO GType

instance BoxedEnum FontType where
    boxedEnumType :: FontType -> IO GType
boxedEnumType _ = IO GType
c_cairo_gobject_font_type_get_type

-- Enum FontSlant
-- | /No description available in the introspection data./
data FontSlant = 
      FontSlantNormal
    -- ^ /No description available in the introspection data./
    | FontSlantItalic
    -- ^ /No description available in the introspection data./
    | FontSlantOblique
    -- ^ /No description available in the introspection data./
    | AnotherFontSlant Int
    -- ^ Catch-all for unknown values
    deriving (Int -> FontSlant -> ShowS
[FontSlant] -> ShowS
FontSlant -> String
(Int -> FontSlant -> ShowS)
-> (FontSlant -> String)
-> ([FontSlant] -> ShowS)
-> Show FontSlant
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FontSlant] -> ShowS
$cshowList :: [FontSlant] -> ShowS
show :: FontSlant -> String
$cshow :: FontSlant -> String
showsPrec :: Int -> FontSlant -> ShowS
$cshowsPrec :: Int -> FontSlant -> ShowS
Show, FontSlant -> FontSlant -> Bool
(FontSlant -> FontSlant -> Bool)
-> (FontSlant -> FontSlant -> Bool) -> Eq FontSlant
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FontSlant -> FontSlant -> Bool
$c/= :: FontSlant -> FontSlant -> Bool
== :: FontSlant -> FontSlant -> Bool
$c== :: FontSlant -> FontSlant -> Bool
Eq)

instance P.Enum FontSlant where
    fromEnum :: FontSlant -> Int
fromEnum FontSlantNormal = 0
    fromEnum FontSlantItalic = 1
    fromEnum FontSlantOblique = 2
    fromEnum (AnotherFontSlant k :: Int
k) = Int
k

    toEnum :: Int -> FontSlant
toEnum 0 = FontSlant
FontSlantNormal
    toEnum 1 = FontSlant
FontSlantItalic
    toEnum 2 = FontSlant
FontSlantOblique
    toEnum k :: Int
k = Int -> FontSlant
AnotherFontSlant Int
k

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

foreign import ccall "cairo_gobject_font_slant_get_type" c_cairo_gobject_font_slant_get_type :: 
    IO GType

instance BoxedEnum FontSlant where
    boxedEnumType :: FontSlant -> IO GType
boxedEnumType _ = IO GType
c_cairo_gobject_font_slant_get_type

-- Enum Filter
-- | /No description available in the introspection data./
data Filter = 
      FilterFast
    -- ^ /No description available in the introspection data./
    | FilterGood
    -- ^ /No description available in the introspection data./
    | FilterBest
    -- ^ /No description available in the introspection data./
    | FilterNearest
    -- ^ /No description available in the introspection data./
    | FilterBilinear
    -- ^ /No description available in the introspection data./
    | FilterGaussian
    -- ^ /No description available in the introspection data./
    | AnotherFilter Int
    -- ^ Catch-all for unknown values
    deriving (Int -> Filter -> ShowS
[Filter] -> ShowS
Filter -> String
(Int -> Filter -> ShowS)
-> (Filter -> String) -> ([Filter] -> ShowS) -> Show Filter
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Filter] -> ShowS
$cshowList :: [Filter] -> ShowS
show :: Filter -> String
$cshow :: Filter -> String
showsPrec :: Int -> Filter -> ShowS
$cshowsPrec :: Int -> Filter -> ShowS
Show, Filter -> Filter -> Bool
(Filter -> Filter -> Bool)
-> (Filter -> Filter -> Bool) -> Eq Filter
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Filter -> Filter -> Bool
$c/= :: Filter -> Filter -> Bool
== :: Filter -> Filter -> Bool
$c== :: Filter -> Filter -> Bool
Eq)

instance P.Enum Filter where
    fromEnum :: Filter -> Int
fromEnum FilterFast = 0
    fromEnum FilterGood = 1
    fromEnum FilterBest = 2
    fromEnum FilterNearest = 3
    fromEnum FilterBilinear = 4
    fromEnum FilterGaussian = 5
    fromEnum (AnotherFilter k :: Int
k) = Int
k

    toEnum :: Int -> Filter
toEnum 0 = Filter
FilterFast
    toEnum 1 = Filter
FilterGood
    toEnum 2 = Filter
FilterBest
    toEnum 3 = Filter
FilterNearest
    toEnum 4 = Filter
FilterBilinear
    toEnum 5 = Filter
FilterGaussian
    toEnum k :: Int
k = Int -> Filter
AnotherFilter Int
k

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

foreign import ccall "cairo_gobject_filter_get_type" c_cairo_gobject_filter_get_type :: 
    IO GType

instance BoxedEnum Filter where
    boxedEnumType :: Filter -> IO GType
boxedEnumType _ = IO GType
c_cairo_gobject_filter_get_type

-- Enum FillRule
-- | /No description available in the introspection data./
data FillRule = 
      FillRuleWinding
    -- ^ /No description available in the introspection data./
    | FillRuleEvenOdd
    -- ^ /No description available in the introspection data./
    | AnotherFillRule Int
    -- ^ Catch-all for unknown values
    deriving (Int -> FillRule -> ShowS
[FillRule] -> ShowS
FillRule -> String
(Int -> FillRule -> ShowS)
-> (FillRule -> String) -> ([FillRule] -> ShowS) -> Show FillRule
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FillRule] -> ShowS
$cshowList :: [FillRule] -> ShowS
show :: FillRule -> String
$cshow :: FillRule -> String
showsPrec :: Int -> FillRule -> ShowS
$cshowsPrec :: Int -> FillRule -> ShowS
Show, FillRule -> FillRule -> Bool
(FillRule -> FillRule -> Bool)
-> (FillRule -> FillRule -> Bool) -> Eq FillRule
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FillRule -> FillRule -> Bool
$c/= :: FillRule -> FillRule -> Bool
== :: FillRule -> FillRule -> Bool
$c== :: FillRule -> FillRule -> Bool
Eq)

instance P.Enum FillRule where
    fromEnum :: FillRule -> Int
fromEnum FillRuleWinding = 0
    fromEnum FillRuleEvenOdd = 1
    fromEnum (AnotherFillRule k :: Int
k) = Int
k

    toEnum :: Int -> FillRule
toEnum 0 = FillRule
FillRuleWinding
    toEnum 1 = FillRule
FillRuleEvenOdd
    toEnum k :: Int
k = Int -> FillRule
AnotherFillRule Int
k

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

foreign import ccall "cairo_gobject_fill_rule_get_type" c_cairo_gobject_fill_rule_get_type :: 
    IO GType

instance BoxedEnum FillRule where
    boxedEnumType :: FillRule -> IO GType
boxedEnumType _ = IO GType
c_cairo_gobject_fill_rule_get_type

-- Enum Extend
-- | /No description available in the introspection data./
data Extend = 
      ExtendNone
    -- ^ /No description available in the introspection data./
    | ExtendRepeat
    -- ^ /No description available in the introspection data./
    | ExtendReflect
    -- ^ /No description available in the introspection data./
    | ExtendPad
    -- ^ /No description available in the introspection data./
    | AnotherExtend Int
    -- ^ Catch-all for unknown values
    deriving (Int -> Extend -> ShowS
[Extend] -> ShowS
Extend -> String
(Int -> Extend -> ShowS)
-> (Extend -> String) -> ([Extend] -> ShowS) -> Show Extend
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Extend] -> ShowS
$cshowList :: [Extend] -> ShowS
show :: Extend -> String
$cshow :: Extend -> String
showsPrec :: Int -> Extend -> ShowS
$cshowsPrec :: Int -> Extend -> ShowS
Show, Extend -> Extend -> Bool
(Extend -> Extend -> Bool)
-> (Extend -> Extend -> Bool) -> Eq Extend
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Extend -> Extend -> Bool
$c/= :: Extend -> Extend -> Bool
== :: Extend -> Extend -> Bool
$c== :: Extend -> Extend -> Bool
Eq)

instance P.Enum Extend where
    fromEnum :: Extend -> Int
fromEnum ExtendNone = 0
    fromEnum ExtendRepeat = 1
    fromEnum ExtendReflect = 2
    fromEnum ExtendPad = 3
    fromEnum (AnotherExtend k :: Int
k) = Int
k

    toEnum :: Int -> Extend
toEnum 0 = Extend
ExtendNone
    toEnum 1 = Extend
ExtendRepeat
    toEnum 2 = Extend
ExtendReflect
    toEnum 3 = Extend
ExtendPad
    toEnum k :: Int
k = Int -> Extend
AnotherExtend Int
k

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

foreign import ccall "cairo_gobject_extend_get_type" c_cairo_gobject_extend_get_type :: 
    IO GType

instance BoxedEnum Extend where
    boxedEnumType :: Extend -> IO GType
boxedEnumType _ = IO GType
c_cairo_gobject_extend_get_type

-- Enum DeviceType
-- | /No description available in the introspection data./
data DeviceType = 
      DeviceTypeDrm
    -- ^ /No description available in the introspection data./
    | DeviceTypeGl
    -- ^ /No description available in the introspection data./
    | DeviceTypeScript
    -- ^ /No description available in the introspection data./
    | DeviceTypeXcb
    -- ^ /No description available in the introspection data./
    | DeviceTypeXlib
    -- ^ /No description available in the introspection data./
    | DeviceTypeXml
    -- ^ /No description available in the introspection data./
    | DeviceTypeCogl
    -- ^ /No description available in the introspection data./
    | DeviceTypeWin32
    -- ^ /No description available in the introspection data./
    | DeviceTypeInvalid
    -- ^ /No description available in the introspection data./
    | AnotherDeviceType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> DeviceType -> ShowS
[DeviceType] -> ShowS
DeviceType -> String
(Int -> DeviceType -> ShowS)
-> (DeviceType -> String)
-> ([DeviceType] -> ShowS)
-> Show DeviceType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DeviceType] -> ShowS
$cshowList :: [DeviceType] -> ShowS
show :: DeviceType -> String
$cshow :: DeviceType -> String
showsPrec :: Int -> DeviceType -> ShowS
$cshowsPrec :: Int -> DeviceType -> ShowS
Show, DeviceType -> DeviceType -> Bool
(DeviceType -> DeviceType -> Bool)
-> (DeviceType -> DeviceType -> Bool) -> Eq DeviceType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DeviceType -> DeviceType -> Bool
$c/= :: DeviceType -> DeviceType -> Bool
== :: DeviceType -> DeviceType -> Bool
$c== :: DeviceType -> DeviceType -> Bool
Eq)

instance P.Enum DeviceType where
    fromEnum :: DeviceType -> Int
fromEnum DeviceTypeDrm = 0
    fromEnum DeviceTypeGl = 1
    fromEnum DeviceTypeScript = 2
    fromEnum DeviceTypeXcb = 3
    fromEnum DeviceTypeXlib = 4
    fromEnum DeviceTypeXml = 5
    fromEnum DeviceTypeCogl = 6
    fromEnum DeviceTypeWin32 = 7
    fromEnum DeviceTypeInvalid = -1
    fromEnum (AnotherDeviceType k :: Int
k) = Int
k

    toEnum :: Int -> DeviceType
toEnum 0 = DeviceType
DeviceTypeDrm
    toEnum 1 = DeviceType
DeviceTypeGl
    toEnum 2 = DeviceType
DeviceTypeScript
    toEnum 3 = DeviceType
DeviceTypeXcb
    toEnum 4 = DeviceType
DeviceTypeXlib
    toEnum 5 = DeviceType
DeviceTypeXml
    toEnum 6 = DeviceType
DeviceTypeCogl
    toEnum 7 = DeviceType
DeviceTypeWin32
    toEnum -1 = DeviceType
DeviceTypeInvalid
    toEnum k :: Int
k = Int -> DeviceType
AnotherDeviceType Int
k

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

foreign import ccall "cairo_gobject_device_type_get_type" c_cairo_gobject_device_type_get_type :: 
    IO GType

instance BoxedEnum DeviceType where
    boxedEnumType :: DeviceType -> IO GType
boxedEnumType _ = IO GType
c_cairo_gobject_device_type_get_type

-- Enum Content
-- | /No description available in the introspection data./
data Content = 
      ContentColor
    -- ^ /No description available in the introspection data./
    | ContentAlpha
    -- ^ /No description available in the introspection data./
    | ContentColorAlpha
    -- ^ /No description available in the introspection data./
    | AnotherContent Int
    -- ^ Catch-all for unknown values
    deriving (Int -> Content -> ShowS
[Content] -> ShowS
Content -> String
(Int -> Content -> ShowS)
-> (Content -> String) -> ([Content] -> ShowS) -> Show Content
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Content] -> ShowS
$cshowList :: [Content] -> ShowS
show :: Content -> String
$cshow :: Content -> String
showsPrec :: Int -> Content -> ShowS
$cshowsPrec :: Int -> Content -> ShowS
Show, Content -> Content -> Bool
(Content -> Content -> Bool)
-> (Content -> Content -> Bool) -> Eq Content
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Content -> Content -> Bool
$c/= :: Content -> Content -> Bool
== :: Content -> Content -> Bool
$c== :: Content -> Content -> Bool
Eq)

instance P.Enum Content where
    fromEnum :: Content -> Int
fromEnum ContentColor = 4096
    fromEnum ContentAlpha = 8192
    fromEnum ContentColorAlpha = 12288
    fromEnum (AnotherContent k :: Int
k) = Int
k

    toEnum :: Int -> Content
toEnum 4096 = Content
ContentColor
    toEnum 8192 = Content
ContentAlpha
    toEnum 12288 = Content
ContentColorAlpha
    toEnum k :: Int
k = Int -> Content
AnotherContent Int
k

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

foreign import ccall "cairo_gobject_content_get_type" c_cairo_gobject_content_get_type :: 
    IO GType

instance BoxedEnum Content where
    boxedEnumType :: Content -> IO GType
boxedEnumType _ = IO GType
c_cairo_gobject_content_get_type

-- Enum Antialias
-- | /No description available in the introspection data./
data Antialias = 
      AntialiasDefault
    -- ^ /No description available in the introspection data./
    | AntialiasNone
    -- ^ /No description available in the introspection data./
    | AntialiasGray
    -- ^ /No description available in the introspection data./
    | AntialiasSubpixel
    -- ^ /No description available in the introspection data./
    | AntialiasFast
    -- ^ /No description available in the introspection data./
    | AntialiasGood
    -- ^ /No description available in the introspection data./
    | AntialiasBest
    -- ^ /No description available in the introspection data./
    | AnotherAntialias Int
    -- ^ Catch-all for unknown values
    deriving (Int -> Antialias -> ShowS
[Antialias] -> ShowS
Antialias -> String
(Int -> Antialias -> ShowS)
-> (Antialias -> String)
-> ([Antialias] -> ShowS)
-> Show Antialias
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Antialias] -> ShowS
$cshowList :: [Antialias] -> ShowS
show :: Antialias -> String
$cshow :: Antialias -> String
showsPrec :: Int -> Antialias -> ShowS
$cshowsPrec :: Int -> Antialias -> ShowS
Show, Antialias -> Antialias -> Bool
(Antialias -> Antialias -> Bool)
-> (Antialias -> Antialias -> Bool) -> Eq Antialias
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Antialias -> Antialias -> Bool
$c/= :: Antialias -> Antialias -> Bool
== :: Antialias -> Antialias -> Bool
$c== :: Antialias -> Antialias -> Bool
Eq)

instance P.Enum Antialias where
    fromEnum :: Antialias -> Int
fromEnum AntialiasDefault = 0
    fromEnum AntialiasNone = 1
    fromEnum AntialiasGray = 2
    fromEnum AntialiasSubpixel = 3
    fromEnum AntialiasFast = 4
    fromEnum AntialiasGood = 5
    fromEnum AntialiasBest = 6
    fromEnum (AnotherAntialias k :: Int
k) = Int
k

    toEnum :: Int -> Antialias
toEnum 0 = Antialias
AntialiasDefault
    toEnum 1 = Antialias
AntialiasNone
    toEnum 2 = Antialias
AntialiasGray
    toEnum 3 = Antialias
AntialiasSubpixel
    toEnum 4 = Antialias
AntialiasFast
    toEnum 5 = Antialias
AntialiasGood
    toEnum 6 = Antialias
AntialiasBest
    toEnum k :: Int
k = Int -> Antialias
AnotherAntialias Int
k

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

foreign import ccall "cairo_gobject_antialias_get_type" c_cairo_gobject_antialias_get_type :: 
    IO GType

instance BoxedEnum Antialias where
    boxedEnumType :: Antialias -> IO GType
boxedEnumType _ = IO GType
c_cairo_gobject_antialias_get_type