{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
-}

module GI.GdkPixbuf.Flags
    ( 

-- * Exported types
    PixdataType(..)                         ,
    PixdataDumpType(..)                     ,


    ) 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.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
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


-- Flags PixdataType
{- |
An enumeration containing three sets of flags for a 'GI.GdkPixbuf.Structs.Pixdata.Pixdata' struct:
one for the used colorspace, one for the width of the samples and one
for the encoding of the pixel data.
-}
data PixdataType = 
      PixdataTypeColorTypeRgb
    {- ^
    each pixel has red, green and blue samples.
    -}
    | PixdataTypeColorTypeRgba
    {- ^
    each pixel has red, green and blue samples
       and an alpha value.
    -}
    | PixdataTypeColorTypeMask
    {- ^
    mask for the colortype flags of the enum.
    -}
    | PixdataTypeSampleWidth8
    {- ^
    each sample has 8 bits.
    -}
    | PixdataTypeSampleWidthMask
    {- ^
    mask for the sample width flags of the enum.
    -}
    | PixdataTypeEncodingRaw
    {- ^
    the pixel data is in raw form.
    -}
    | PixdataTypeEncodingRle
    {- ^
    the pixel data is run-length encoded. Runs may
       be up to 127 bytes long; their length is stored in a single byte
       preceding the pixel data for the run. If a run is constant, its length
       byte has the high bit set and the pixel data consists of a single pixel
       which must be repeated.
    -}
    | PixdataTypeEncodingMask
    {- ^
    mask for the encoding flags of the enum.
    -}
    | AnotherPixdataType Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum PixdataType where
    fromEnum PixdataTypeColorTypeRgb = 1
    fromEnum PixdataTypeColorTypeRgba = 2
    fromEnum PixdataTypeColorTypeMask = 255
    fromEnum PixdataTypeSampleWidth8 = 65536
    fromEnum PixdataTypeSampleWidthMask = 983040
    fromEnum PixdataTypeEncodingRaw = 16777216
    fromEnum PixdataTypeEncodingRle = 33554432
    fromEnum PixdataTypeEncodingMask = 251658240
    fromEnum (AnotherPixdataType k) = k

    toEnum 1 = PixdataTypeColorTypeRgb
    toEnum 2 = PixdataTypeColorTypeRgba
    toEnum 255 = PixdataTypeColorTypeMask
    toEnum 65536 = PixdataTypeSampleWidth8
    toEnum 983040 = PixdataTypeSampleWidthMask
    toEnum 16777216 = PixdataTypeEncodingRaw
    toEnum 33554432 = PixdataTypeEncodingRle
    toEnum 251658240 = PixdataTypeEncodingMask
    toEnum k = AnotherPixdataType k

instance P.Ord PixdataType where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

instance IsGFlag PixdataType

-- Flags PixdataDumpType
{- |
An enumeration which is used by 'GI.GdkPixbuf.Structs.Pixdata.pixdataToCsource' to
determine the form of C source to be generated. The three values
/@gDKPIXDATADUMPPIXDATASTREAM@/, /@gDKPIXDATADUMPPIXDATASTRUCT@/
and /@gDKPIXDATADUMPMACROS@/ are mutually exclusive, as are
/@gDKPIXBUFDUMPGTYPES@/ and /@gDKPIXBUFDUMPCTYPES@/. The remaining
elements are optional flags that can be freely added.
-}
data PixdataDumpType = 
      PixdataDumpTypePixdataStream
    {- ^
    Generate pixbuf data stream (a single
       string containing a serialized 'GI.GdkPixbuf.Structs.Pixdata.Pixdata' structure in network byte
       order).
    -}
    | PixdataDumpTypePixdataStruct
    {- ^
    Generate 'GI.GdkPixbuf.Structs.Pixdata.Pixdata' structure (needs
       the 'GI.GdkPixbuf.Structs.Pixdata.Pixdata' structure definition from gdk-pixdata.h).
    -}
    | PixdataDumpTypeMacros
    {- ^
    Generate \<function>*_ROWSTRIDE\<\/function>,
       \<function>*_WIDTH\<\/function>, \<function>*_HEIGHT\<\/function>,
       \<function>*_BYTES_PER_PIXEL\<\/function> and
       \<function>*_RLE_PIXEL_DATA\<\/function> or \<function>*_PIXEL_DATA\<\/function>
       macro definitions for the image.
    -}
    | PixdataDumpTypeGtypes
    {- ^
    Generate GLib data types instead of
       standard C data types.
    -}
    | PixdataDumpTypeCtypes
    {- ^
    Generate standard C data types instead of
       GLib data types.
    -}
    | PixdataDumpTypeStatic
    {- ^
    Generate static symbols.
    -}
    | PixdataDumpTypeConst
    {- ^
    Generate const symbols.
    -}
    | PixdataDumpTypeRleDecoder
    {- ^
    Provide a \<function>*_RUN_LENGTH_DECODE(image_buf, rle_data, size, bpp)\<\/function>
       macro definition  to  decode  run-length encoded image data.
    -}
    | AnotherPixdataDumpType Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum PixdataDumpType where
    fromEnum PixdataDumpTypePixdataStream = 0
    fromEnum PixdataDumpTypePixdataStruct = 1
    fromEnum PixdataDumpTypeMacros = 2
    fromEnum PixdataDumpTypeGtypes = 0
    fromEnum PixdataDumpTypeCtypes = 256
    fromEnum PixdataDumpTypeStatic = 512
    fromEnum PixdataDumpTypeConst = 1024
    fromEnum PixdataDumpTypeRleDecoder = 65536
    fromEnum (AnotherPixdataDumpType k) = k

    toEnum 0 = PixdataDumpTypePixdataStream
    toEnum 1 = PixdataDumpTypePixdataStruct
    toEnum 2 = PixdataDumpTypeMacros
    toEnum 0 = PixdataDumpTypeGtypes
    toEnum 256 = PixdataDumpTypeCtypes
    toEnum 512 = PixdataDumpTypeStatic
    toEnum 1024 = PixdataDumpTypeConst
    toEnum 65536 = PixdataDumpTypeRleDecoder
    toEnum k = AnotherPixdataDumpType k

instance P.Ord PixdataDumpType where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

instance IsGFlag PixdataDumpType