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

    #if !defined(__HADDOCK_VERSION__)
    #define ENABLE_OVERLOADING
    #endif

    module GI.GdkPixbuf.Enums
        (

     -- * Enumerations

    -- ** Colorspace #enum:Colorspace#

        Colorspace(..)                          ,

    -- ** InterpType #enum:InterpType#

        InterpType(..)                          ,

    -- ** PixbufAlphaMode #enum:PixbufAlphaMode#

        PixbufAlphaMode(..)                     ,

    -- ** PixbufError #enum:PixbufError#

        PixbufError(..)                         ,
        catchPixbufError                        ,
        handlePixbufError                       ,

    -- ** PixbufRotation #enum:PixbufRotation#

        PixbufRotation(..)                      ,

        ) where

    import Data.GI.Base.ShortPrelude
    import qualified Data.GI.Base.ShortPrelude as SP
    import qualified Data.GI.Base.Overloading as O
    import qualified Prelude as P

    import qualified Data.GI.Base.Attributes as GI.Attributes
    import qualified Data.GI.Base.BasicTypes as B.Types
    import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
    import qualified Data.GI.Base.GArray as B.GArray
    import qualified Data.GI.Base.GClosure as B.GClosure
    import qualified Data.GI.Base.GError as B.GError
    import qualified Data.GI.Base.GHashTable as B.GHT
    import qualified Data.GI.Base.GVariant as B.GVariant
    import qualified Data.GI.Base.GValue as B.GValue
    import qualified Data.GI.Base.GParamSpec as B.GParamSpec
    import qualified Data.GI.Base.CallStack as B.CallStack
    import qualified Data.GI.Base.Properties as B.Properties
    import qualified Data.GI.Base.Signals as B.Signals
    import qualified Control.Monad.IO.Class as MIO
    import qualified Data.Coerce as Coerce
    import qualified Data.Text as T
    import qualified Data.Kind as DK
    import qualified Data.ByteString.Char8 as B
    import qualified Data.Map as Map
    import qualified Foreign.Ptr as FP
    import qualified GHC.OverloadedLabels as OL
    import qualified GHC.Records as R
    import qualified Data.Word as DW
    import qualified Data.Int as DI
    import qualified System.Posix.Types as SPT
    import qualified Foreign.C.Types as FCT

    -- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
    #if MIN_VERSION_base(4,18,0)

    #else

    #endif

    -- Enum PixbufRotation
    -- | The possible rotations which can be passed to 'GI.GdkPixbuf.Objects.Pixbuf.pixbufRotateSimple'.
    --
    -- To make them easier to use, their numerical values are the actual degrees.
    data PixbufRotation =
          PixbufRotationNone
        -- ^ No rotation.
        | PixbufRotationCounterclockwise
        -- ^ Rotate by 90 degrees.
        | PixbufRotationUpsidedown
        -- ^ Rotate by 180 degrees.
        | PixbufRotationClockwise
        -- ^ Rotate by 270 degrees.
        | AnotherPixbufRotation Int
        -- ^ Catch-all for unknown values
        deriving (Int -> PixbufRotation -> ShowS
    [PixbufRotation] -> ShowS
    PixbufRotation -> String
    (Int -> PixbufRotation -> ShowS)
    -> (PixbufRotation -> String)
    -> ([PixbufRotation] -> ShowS)
    -> Show PixbufRotation
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> PixbufRotation -> ShowS
    showsPrec :: Int -> PixbufRotation -> ShowS
    $cshow :: PixbufRotation -> String
    show :: PixbufRotation -> String
    $cshowList :: [PixbufRotation] -> ShowS
    showList :: [PixbufRotation] -> ShowS
    Show, PixbufRotation -> PixbufRotation -> Bool
    (PixbufRotation -> PixbufRotation -> Bool)
    -> (PixbufRotation -> PixbufRotation -> Bool) -> Eq PixbufRotation
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: PixbufRotation -> PixbufRotation -> Bool
    == :: PixbufRotation -> PixbufRotation -> Bool
    $c/= :: PixbufRotation -> PixbufRotation -> Bool
    /= :: PixbufRotation -> PixbufRotation -> Bool
    Eq)

    instance P.Enum PixbufRotation where
        fromEnum :: PixbufRotation -> Int
    fromEnum PixbufRotation
    PixbufRotationNone = Int
    0
        fromEnum PixbufRotation
    PixbufRotationCounterclockwise = Int
    90
        fromEnum PixbufRotation
    PixbufRotationUpsidedown = Int
    180
        fromEnum PixbufRotation
    PixbufRotationClockwise = Int
    270
        fromEnum (AnotherPixbufRotation Int
    k) = Int
    k

        toEnum :: Int -> PixbufRotation
    toEnum Int
    0 = PixbufRotation
    PixbufRotationNone
        toEnum Int
    90 = PixbufRotation
    PixbufRotationCounterclockwise
        toEnum Int
    180 = PixbufRotation
    PixbufRotationUpsidedown
        toEnum Int
    270 = PixbufRotation
    PixbufRotationClockwise
        toEnum Int
    k = Int -> PixbufRotation
    AnotherPixbufRotation Int
    k

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

    type instance O.ParentTypes PixbufRotation = '[]
    instance O.HasParentTypes PixbufRotation

    foreign import ccall "gdk_pixbuf_rotation_get_type" c_gdk_pixbuf_rotation_get_type ::
        IO GType

    instance B.Types.TypedObject PixbufRotation where
        glibType :: IO GType
    glibType = IO GType
    c_gdk_pixbuf_rotation_get_type

    instance B.Types.BoxedEnum PixbufRotation

    -- Enum PixbufError
    -- | An error code in the @GDK_PIXBUF_ERROR@ domain.
    --
    -- Many gdk-pixbuf operations can cause errors in this domain, or in
    -- the @G_FILE_ERROR@ domain.
    data PixbufError =
          PixbufErrorCorruptImage
        -- ^ An image file was broken somehow.
        | PixbufErrorInsufficientMemory
        -- ^ Not enough memory.
        | PixbufErrorBadOption
        -- ^ A bad option was passed to a pixbuf save module.
        | PixbufErrorUnknownType
        -- ^ Unknown image type.
        | PixbufErrorUnsupportedOperation
        -- ^ Don\'t know how to perform the
        --  given operation on the type of image at hand.
        | PixbufErrorFailed
        -- ^ Generic failure code, something went wrong.
        | PixbufErrorIncompleteAnimation
        -- ^ Only part of the animation was loaded.
        | AnotherPixbufError Int
        -- ^ Catch-all for unknown values
        deriving (Int -> PixbufError -> ShowS
    [PixbufError] -> ShowS
    PixbufError -> String
    (Int -> PixbufError -> ShowS)
    -> (PixbufError -> String)
    -> ([PixbufError] -> ShowS)
    -> Show PixbufError
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> PixbufError -> ShowS
    showsPrec :: Int -> PixbufError -> ShowS
    $cshow :: PixbufError -> String
    show :: PixbufError -> String
    $cshowList :: [PixbufError] -> ShowS
    showList :: [PixbufError] -> ShowS
    Show, PixbufError -> PixbufError -> Bool
    (PixbufError -> PixbufError -> Bool)
    -> (PixbufError -> PixbufError -> Bool) -> Eq PixbufError
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: PixbufError -> PixbufError -> Bool
    == :: PixbufError -> PixbufError -> Bool
    $c/= :: PixbufError -> PixbufError -> Bool
    /= :: PixbufError -> PixbufError -> Bool
    Eq)

    instance P.Enum PixbufError where
        fromEnum :: PixbufError -> Int
    fromEnum PixbufError
    PixbufErrorCorruptImage = Int
    0
        fromEnum PixbufError
    PixbufErrorInsufficientMemory = Int
    1
        fromEnum PixbufError
    PixbufErrorBadOption = Int
    2
        fromEnum PixbufError
    PixbufErrorUnknownType = Int
    3
        fromEnum PixbufError
    PixbufErrorUnsupportedOperation = Int
    4
        fromEnum PixbufError
    PixbufErrorFailed = Int
    5
        fromEnum PixbufError
    PixbufErrorIncompleteAnimation = Int
    6
        fromEnum (AnotherPixbufError Int
    k) = Int
    k

        toEnum :: Int -> PixbufError
    toEnum Int
    0 = PixbufError
    PixbufErrorCorruptImage
        toEnum Int
    1 = PixbufError
    PixbufErrorInsufficientMemory
        toEnum Int
    2 = PixbufError
    PixbufErrorBadOption
        toEnum Int
    3 = PixbufError
    PixbufErrorUnknownType
        toEnum Int
    4 = PixbufError
    PixbufErrorUnsupportedOperation
        toEnum Int
    5 = PixbufError
    PixbufErrorFailed
        toEnum Int
    6 = PixbufError
    PixbufErrorIncompleteAnimation
        toEnum Int
    k = Int -> PixbufError
    AnotherPixbufError Int
    k

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

    instance GErrorClass PixbufError where
        gerrorClassDomain :: PixbufError -> Text
    gerrorClassDomain PixbufError
    _ = Text
    "gdk-pixbuf-error-quark"

    -- | Catch exceptions of type `PixbufError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
    catchPixbufError ::
        IO a ->
        (PixbufError -> GErrorMessage -> IO a) ->
        IO a
    catchPixbufError :: forall a. IO a -> (PixbufError -> Text -> IO a) -> IO a
    catchPixbufError = IO a -> (PixbufError -> Text -> IO a) -> IO a
    forall err a.
    GErrorClass err =>
    IO a -> (err -> Text -> IO a) -> IO a
    catchGErrorJustDomain

    -- | Handle exceptions of type `PixbufError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
    handlePixbufError ::
        (PixbufError -> GErrorMessage -> IO a) ->
        IO a ->
        IO a
    handlePixbufError :: forall a. (PixbufError -> Text -> IO a) -> IO a -> IO a
    handlePixbufError = (PixbufError -> Text -> IO a) -> IO a -> IO a
    forall err a.
    GErrorClass err =>
    (err -> Text -> IO a) -> IO a -> IO a
    handleGErrorJustDomain

    type instance O.ParentTypes PixbufError = '[]
    instance O.HasParentTypes PixbufError

    foreign import ccall "gdk_pixbuf_error_get_type" c_gdk_pixbuf_error_get_type ::
        IO GType

    instance B.Types.TypedObject PixbufError where
        glibType :: IO GType
    glibType = IO GType
    c_gdk_pixbuf_error_get_type

    instance B.Types.BoxedEnum PixbufError

    -- Enum PixbufAlphaMode
    {-# DEPRECATED PixbufAlphaMode ["(Since version 2.42)","There is no user of GdkPixbufAlphaMode in GdkPixbuf,","  and the Xlib utility functions have been split out to their own","  library, gdk-pixbuf-xlib"] #-}
    -- | Control the alpha channel for drawables.
    --
    -- These values can be passed to @/gdk_pixbuf_xlib_render_to_drawable_alpha()/@
    -- in gdk-pixbuf-xlib to control how the alpha channel of an image should
    -- be handled.
    --
    -- This function can create a bilevel clipping mask (black and white) and use
    -- it while painting the image.
    --
    -- In the future, when the X Window System gets an alpha channel extension,
    -- it will be possible to do full alpha compositing onto arbitrary drawables.
    -- For now both cases fall back to a bilevel clipping mask.
    data PixbufAlphaMode =
          PixbufAlphaModeBilevel
        -- ^ A bilevel clipping mask (black and white)
        --  will be created and used to draw the image.  Pixels below 0.5 opacity
        --  will be considered fully transparent, and all others will be
        --  considered fully opaque.
        | PixbufAlphaModeFull
        -- ^ For now falls back to @/GDK_PIXBUF_ALPHA_BILEVEL/@.
        --  In the future it will do full alpha compositing.
        | AnotherPixbufAlphaMode Int
        -- ^ Catch-all for unknown values
        deriving (Int -> PixbufAlphaMode -> ShowS
    [PixbufAlphaMode] -> ShowS
    PixbufAlphaMode -> String
    (Int -> PixbufAlphaMode -> ShowS)
    -> (PixbufAlphaMode -> String)
    -> ([PixbufAlphaMode] -> ShowS)
    -> Show PixbufAlphaMode
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> PixbufAlphaMode -> ShowS
    showsPrec :: Int -> PixbufAlphaMode -> ShowS
    $cshow :: PixbufAlphaMode -> String
    show :: PixbufAlphaMode -> String
    $cshowList :: [PixbufAlphaMode] -> ShowS
    showList :: [PixbufAlphaMode] -> ShowS
    Show, PixbufAlphaMode -> PixbufAlphaMode -> Bool
    (PixbufAlphaMode -> PixbufAlphaMode -> Bool)
    -> (PixbufAlphaMode -> PixbufAlphaMode -> Bool)
    -> Eq PixbufAlphaMode
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: PixbufAlphaMode -> PixbufAlphaMode -> Bool
    == :: PixbufAlphaMode -> PixbufAlphaMode -> Bool
    $c/= :: PixbufAlphaMode -> PixbufAlphaMode -> Bool
    /= :: PixbufAlphaMode -> PixbufAlphaMode -> Bool
    Eq)

    instance P.Enum PixbufAlphaMode where
        fromEnum :: PixbufAlphaMode -> Int
    fromEnum PixbufAlphaMode
    PixbufAlphaModeBilevel = Int
    0
        fromEnum PixbufAlphaMode
    PixbufAlphaModeFull = Int
    1
        fromEnum (AnotherPixbufAlphaMode Int
    k) = Int
    k

        toEnum :: Int -> PixbufAlphaMode
    toEnum Int
    0 = PixbufAlphaMode
    PixbufAlphaModeBilevel
        toEnum Int
    1 = PixbufAlphaMode
    PixbufAlphaModeFull
        toEnum Int
    k = Int -> PixbufAlphaMode
    AnotherPixbufAlphaMode Int
    k

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

    type instance O.ParentTypes PixbufAlphaMode = '[]
    instance O.HasParentTypes PixbufAlphaMode

    foreign import ccall "gdk_pixbuf_alpha_mode_get_type" c_gdk_pixbuf_alpha_mode_get_type ::
        IO GType

    instance B.Types.TypedObject PixbufAlphaMode where
        glibType :: IO GType
    glibType = IO GType
    c_gdk_pixbuf_alpha_mode_get_type

    instance B.Types.BoxedEnum PixbufAlphaMode

    -- Enum InterpType
    -- | Interpolation modes for scaling functions.
    --
    -- The @GDK_INTERP_NEAREST@ mode is the fastest scaling method, but has
    -- horrible quality when scaling down; @GDK_INTERP_BILINEAR@ is the best
    -- choice if you aren\'t sure what to choose, it has a good speed\/quality
    -- balance.
    --
    -- __Note__: Cubic filtering is missing from the list; hyperbolic
    -- interpolation is just as fast and results in higher quality.
    data InterpType =
          InterpTypeNearest
        -- ^ Nearest neighbor sampling; this is the fastest
        --  and lowest quality mode. Quality is normally unacceptable when scaling
        --  down, but may be OK when scaling up.
        | InterpTypeTiles
        -- ^ This is an accurate simulation of the PostScript
        --  image operator without any interpolation enabled.  Each pixel is
        --  rendered as a tiny parallelogram of solid color, the edges of which
        --  are implemented with antialiasing.  It resembles nearest neighbor for
        --  enlargement, and bilinear for reduction.
        | InterpTypeBilinear
        -- ^ Best quality\/speed balance; use this mode by
        --  default. Bilinear interpolation.  For enlargement, it is
        --  equivalent to point-sampling the ideal bilinear-interpolated image.
        --  For reduction, it is equivalent to laying down small tiles and
        --  integrating over the coverage area.
        | InterpTypeHyper
        -- ^ This is the slowest and highest quality
        --  reconstruction function. It is derived from the hyperbolic filters in
        --  Wolberg\'s \"Digital Image Warping\", and is formally defined as the
        --  hyperbolic-filter sampling the ideal hyperbolic-filter interpolated
        --  image (the filter is designed to be idempotent for 1:1 pixel mapping).
        --  __Deprecated__: this interpolation filter is deprecated, as in reality
        --  it has a lower quality than the /@gDKINTERPBILINEAR@/ filter
        --  (Since: 2.38)
        | AnotherInterpType Int
        -- ^ Catch-all for unknown values
        deriving (Int -> InterpType -> ShowS
    [InterpType] -> ShowS
    InterpType -> String
    (Int -> InterpType -> ShowS)
    -> (InterpType -> String)
    -> ([InterpType] -> ShowS)
    -> Show InterpType
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> InterpType -> ShowS
    showsPrec :: Int -> InterpType -> ShowS
    $cshow :: InterpType -> String
    show :: InterpType -> String
    $cshowList :: [InterpType] -> ShowS
    showList :: [InterpType] -> ShowS
    Show, InterpType -> InterpType -> Bool
    (InterpType -> InterpType -> Bool)
    -> (InterpType -> InterpType -> Bool) -> Eq InterpType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: InterpType -> InterpType -> Bool
    == :: InterpType -> InterpType -> Bool
    $c/= :: InterpType -> InterpType -> Bool
    /= :: InterpType -> InterpType -> Bool
    Eq)

    instance P.Enum InterpType where
        fromEnum :: InterpType -> Int
    fromEnum InterpType
    InterpTypeNearest = Int
    0
        fromEnum InterpType
    InterpTypeTiles = Int
    1
        fromEnum InterpType
    InterpTypeBilinear = Int
    2
        fromEnum InterpType
    InterpTypeHyper = Int
    3
        fromEnum (AnotherInterpType Int
    k) = Int
    k

        toEnum :: Int -> InterpType
    toEnum Int
    0 = InterpType
    InterpTypeNearest
        toEnum Int
    1 = InterpType
    InterpTypeTiles
        toEnum Int
    2 = InterpType
    InterpTypeBilinear
        toEnum Int
    3 = InterpType
    InterpTypeHyper
        toEnum Int
    k = Int -> InterpType
    AnotherInterpType Int
    k

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

    type instance O.ParentTypes InterpType = '[]
    instance O.HasParentTypes InterpType

    foreign import ccall "gdk_interp_type_get_type" c_gdk_interp_type_get_type ::
        IO GType

    instance B.Types.TypedObject InterpType where
        glibType :: IO GType
    glibType = IO GType
    c_gdk_interp_type_get_type

    instance B.Types.BoxedEnum InterpType

    -- Enum Colorspace
    -- | This enumeration defines the color spaces that are supported by
    -- the gdk-pixbuf library.
    --
    -- Currently only RGB is supported.
    data Colorspace =
          ColorspaceRgb
        -- ^ Indicates a red\/green\/blue additive color space.
        | AnotherColorspace Int
        -- ^ Catch-all for unknown values
        deriving (Int -> Colorspace -> ShowS
    [Colorspace] -> ShowS
    Colorspace -> String
    (Int -> Colorspace -> ShowS)
    -> (Colorspace -> String)
    -> ([Colorspace] -> ShowS)
    -> Show Colorspace
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Colorspace -> ShowS
    showsPrec :: Int -> Colorspace -> ShowS
    $cshow :: Colorspace -> String
    show :: Colorspace -> String
    $cshowList :: [Colorspace] -> ShowS
    showList :: [Colorspace] -> ShowS
    Show, Colorspace -> Colorspace -> Bool
    (Colorspace -> Colorspace -> Bool)
    -> (Colorspace -> Colorspace -> Bool) -> Eq Colorspace
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Colorspace -> Colorspace -> Bool
    == :: Colorspace -> Colorspace -> Bool
    $c/= :: Colorspace -> Colorspace -> Bool
    /= :: Colorspace -> Colorspace -> Bool
    Eq)

    instance P.Enum Colorspace where
        fromEnum :: Colorspace -> Int
    fromEnum Colorspace
    ColorspaceRgb = Int
    0
        fromEnum (AnotherColorspace Int
    k) = Int
    k

        toEnum :: Int -> Colorspace
    toEnum Int
    0 = Colorspace
    ColorspaceRgb
        toEnum Int
    k = Int -> Colorspace
    AnotherColorspace Int
    k

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

    type instance O.ParentTypes Colorspace = '[]
    instance O.HasParentTypes Colorspace

    foreign import ccall "gdk_colorspace_get_type" c_gdk_colorspace_get_type ::
        IO GType

    instance B.Types.TypedObject Colorspace where
        glibType :: IO GType
    glibType = IO GType
    c_gdk_colorspace_get_type

    instance B.Types.BoxedEnum Colorspace