-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- 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.GtkSource.Flags
    ( 

 -- * Flags


-- ** FileSaverFlags #flag:FileSaverFlags#

    FileSaverFlags(..)                      ,


-- ** SortFlags #flag:SortFlags#

    SortFlags(..)                           ,


-- ** SpaceLocationFlags #flag:SpaceLocationFlags#

    SpaceLocationFlags(..)                  ,


-- ** SpaceTypeFlags #flag:SpaceTypeFlags#

    SpaceTypeFlags(..)                      ,




    ) 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


-- Flags SpaceTypeFlags
-- | t'GI.GtkSource.Flags.SpaceTypeFlags' contains flags for white space types.
data SpaceTypeFlags = 
      SpaceTypeFlagsNone
    -- ^ No flags.
    | SpaceTypeFlagsSpace
    -- ^ Space character.
    | SpaceTypeFlagsTab
    -- ^ Tab character.
    | SpaceTypeFlagsNewline
    -- ^ Line break character. If the
    --   [Buffer:implicitTrailingNewline]("GI.GtkSource.Objects.Buffer#g:attr:implicitTrailingNewline") property is 'P.True',
    --   t'GI.GtkSource.Objects.SpaceDrawer.SpaceDrawer' also draws a line break at the end of the buffer.
    | SpaceTypeFlagsNbsp
    -- ^ Non-breaking space character.
    | SpaceTypeFlagsAll
    -- ^ All white spaces.
    | AnotherSpaceTypeFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SpaceTypeFlags -> ShowS
[SpaceTypeFlags] -> ShowS
SpaceTypeFlags -> String
(Int -> SpaceTypeFlags -> ShowS)
-> (SpaceTypeFlags -> String)
-> ([SpaceTypeFlags] -> ShowS)
-> Show SpaceTypeFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SpaceTypeFlags -> ShowS
showsPrec :: Int -> SpaceTypeFlags -> ShowS
$cshow :: SpaceTypeFlags -> String
show :: SpaceTypeFlags -> String
$cshowList :: [SpaceTypeFlags] -> ShowS
showList :: [SpaceTypeFlags] -> ShowS
Show, SpaceTypeFlags -> SpaceTypeFlags -> Bool
(SpaceTypeFlags -> SpaceTypeFlags -> Bool)
-> (SpaceTypeFlags -> SpaceTypeFlags -> Bool) -> Eq SpaceTypeFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SpaceTypeFlags -> SpaceTypeFlags -> Bool
== :: SpaceTypeFlags -> SpaceTypeFlags -> Bool
$c/= :: SpaceTypeFlags -> SpaceTypeFlags -> Bool
/= :: SpaceTypeFlags -> SpaceTypeFlags -> Bool
Eq)

instance P.Enum SpaceTypeFlags where
    fromEnum :: SpaceTypeFlags -> Int
fromEnum SpaceTypeFlags
SpaceTypeFlagsNone = Int
0
    fromEnum SpaceTypeFlags
SpaceTypeFlagsSpace = Int
1
    fromEnum SpaceTypeFlags
SpaceTypeFlagsTab = Int
2
    fromEnum SpaceTypeFlags
SpaceTypeFlagsNewline = Int
4
    fromEnum SpaceTypeFlags
SpaceTypeFlagsNbsp = Int
8
    fromEnum SpaceTypeFlags
SpaceTypeFlagsAll = Int
15
    fromEnum (AnotherSpaceTypeFlags Int
k) = Int
k

    toEnum :: Int -> SpaceTypeFlags
toEnum Int
0 = SpaceTypeFlags
SpaceTypeFlagsNone
    toEnum Int
1 = SpaceTypeFlags
SpaceTypeFlagsSpace
    toEnum Int
2 = SpaceTypeFlags
SpaceTypeFlagsTab
    toEnum Int
4 = SpaceTypeFlags
SpaceTypeFlagsNewline
    toEnum Int
8 = SpaceTypeFlags
SpaceTypeFlagsNbsp
    toEnum Int
15 = SpaceTypeFlags
SpaceTypeFlagsAll
    toEnum Int
k = Int -> SpaceTypeFlags
AnotherSpaceTypeFlags Int
k

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

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

foreign import ccall "gtk_source_space_type_flags_get_type" c_gtk_source_space_type_flags_get_type :: 
    IO GType

instance B.Types.TypedObject SpaceTypeFlags where
    glibType :: IO GType
glibType = IO GType
c_gtk_source_space_type_flags_get_type

instance B.Types.BoxedFlags SpaceTypeFlags

instance IsGFlag SpaceTypeFlags

-- Flags SpaceLocationFlags
-- | t'GI.GtkSource.Flags.SpaceLocationFlags' contains flags for white space locations.
-- 
-- If a line contains only white spaces (no text), the white spaces match both
-- 'GI.GtkSource.Flags.SpaceLocationFlagsLeading' and 'GI.GtkSource.Flags.SpaceLocationFlagsTrailing'.
data SpaceLocationFlags = 
      SpaceLocationFlagsNone
    -- ^ No flags.
    | SpaceLocationFlagsLeading
    -- ^ Leading white spaces on a line, i.e. the
    --   indentation.
    | SpaceLocationFlagsInsideText
    -- ^ White spaces inside a line of text.
    | SpaceLocationFlagsTrailing
    -- ^ Trailing white spaces on a line.
    | SpaceLocationFlagsAll
    -- ^ White spaces anywhere.
    | AnotherSpaceLocationFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SpaceLocationFlags -> ShowS
[SpaceLocationFlags] -> ShowS
SpaceLocationFlags -> String
(Int -> SpaceLocationFlags -> ShowS)
-> (SpaceLocationFlags -> String)
-> ([SpaceLocationFlags] -> ShowS)
-> Show SpaceLocationFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SpaceLocationFlags -> ShowS
showsPrec :: Int -> SpaceLocationFlags -> ShowS
$cshow :: SpaceLocationFlags -> String
show :: SpaceLocationFlags -> String
$cshowList :: [SpaceLocationFlags] -> ShowS
showList :: [SpaceLocationFlags] -> ShowS
Show, SpaceLocationFlags -> SpaceLocationFlags -> Bool
(SpaceLocationFlags -> SpaceLocationFlags -> Bool)
-> (SpaceLocationFlags -> SpaceLocationFlags -> Bool)
-> Eq SpaceLocationFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SpaceLocationFlags -> SpaceLocationFlags -> Bool
== :: SpaceLocationFlags -> SpaceLocationFlags -> Bool
$c/= :: SpaceLocationFlags -> SpaceLocationFlags -> Bool
/= :: SpaceLocationFlags -> SpaceLocationFlags -> Bool
Eq)

instance P.Enum SpaceLocationFlags where
    fromEnum :: SpaceLocationFlags -> Int
fromEnum SpaceLocationFlags
SpaceLocationFlagsNone = Int
0
    fromEnum SpaceLocationFlags
SpaceLocationFlagsLeading = Int
1
    fromEnum SpaceLocationFlags
SpaceLocationFlagsInsideText = Int
2
    fromEnum SpaceLocationFlags
SpaceLocationFlagsTrailing = Int
4
    fromEnum SpaceLocationFlags
SpaceLocationFlagsAll = Int
7
    fromEnum (AnotherSpaceLocationFlags Int
k) = Int
k

    toEnum :: Int -> SpaceLocationFlags
toEnum Int
0 = SpaceLocationFlags
SpaceLocationFlagsNone
    toEnum Int
1 = SpaceLocationFlags
SpaceLocationFlagsLeading
    toEnum Int
2 = SpaceLocationFlags
SpaceLocationFlagsInsideText
    toEnum Int
4 = SpaceLocationFlags
SpaceLocationFlagsTrailing
    toEnum Int
7 = SpaceLocationFlags
SpaceLocationFlagsAll
    toEnum Int
k = Int -> SpaceLocationFlags
AnotherSpaceLocationFlags Int
k

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

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

foreign import ccall "gtk_source_space_location_flags_get_type" c_gtk_source_space_location_flags_get_type :: 
    IO GType

instance B.Types.TypedObject SpaceLocationFlags where
    glibType :: IO GType
glibType = IO GType
c_gtk_source_space_location_flags_get_type

instance B.Types.BoxedFlags SpaceLocationFlags

instance IsGFlag SpaceLocationFlags

-- Flags SortFlags
-- | /No description available in the introspection data./
data SortFlags = 
      SortFlagsNone
    -- ^ no flags specified
    | SortFlagsCaseSensitive
    -- ^ case sensitive sort
    | SortFlagsReverseOrder
    -- ^ sort in reverse order
    | SortFlagsRemoveDuplicates
    -- ^ remove duplicates
    | AnotherSortFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SortFlags -> ShowS
[SortFlags] -> ShowS
SortFlags -> String
(Int -> SortFlags -> ShowS)
-> (SortFlags -> String)
-> ([SortFlags] -> ShowS)
-> Show SortFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SortFlags -> ShowS
showsPrec :: Int -> SortFlags -> ShowS
$cshow :: SortFlags -> String
show :: SortFlags -> String
$cshowList :: [SortFlags] -> ShowS
showList :: [SortFlags] -> ShowS
Show, SortFlags -> SortFlags -> Bool
(SortFlags -> SortFlags -> Bool)
-> (SortFlags -> SortFlags -> Bool) -> Eq SortFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SortFlags -> SortFlags -> Bool
== :: SortFlags -> SortFlags -> Bool
$c/= :: SortFlags -> SortFlags -> Bool
/= :: SortFlags -> SortFlags -> Bool
Eq)

instance P.Enum SortFlags where
    fromEnum :: SortFlags -> Int
fromEnum SortFlags
SortFlagsNone = Int
0
    fromEnum SortFlags
SortFlagsCaseSensitive = Int
1
    fromEnum SortFlags
SortFlagsReverseOrder = Int
2
    fromEnum SortFlags
SortFlagsRemoveDuplicates = Int
4
    fromEnum (AnotherSortFlags Int
k) = Int
k

    toEnum :: Int -> SortFlags
toEnum Int
0 = SortFlags
SortFlagsNone
    toEnum Int
1 = SortFlags
SortFlagsCaseSensitive
    toEnum Int
2 = SortFlags
SortFlagsReverseOrder
    toEnum Int
4 = SortFlags
SortFlagsRemoveDuplicates
    toEnum Int
k = Int -> SortFlags
AnotherSortFlags Int
k

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

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

foreign import ccall "gtk_source_sort_flags_get_type" c_gtk_source_sort_flags_get_type :: 
    IO GType

instance B.Types.TypedObject SortFlags where
    glibType :: IO GType
glibType = IO GType
c_gtk_source_sort_flags_get_type

instance B.Types.BoxedFlags SortFlags

instance IsGFlag SortFlags

-- Flags FileSaverFlags
-- | Flags to define the behavior of a [flags/@fileSaverFlags@/].
data FileSaverFlags = 
      FileSaverFlagsNone
    -- ^ No flags.
    | FileSaverFlagsIgnoreInvalidChars
    -- ^ Ignore invalid characters.
    | FileSaverFlagsIgnoreModificationTime
    -- ^ Save file despite external modifications.
    | FileSaverFlagsCreateBackup
    -- ^ Create a backup before saving the file.
    | AnotherFileSaverFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> FileSaverFlags -> ShowS
[FileSaverFlags] -> ShowS
FileSaverFlags -> String
(Int -> FileSaverFlags -> ShowS)
-> (FileSaverFlags -> String)
-> ([FileSaverFlags] -> ShowS)
-> Show FileSaverFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FileSaverFlags -> ShowS
showsPrec :: Int -> FileSaverFlags -> ShowS
$cshow :: FileSaverFlags -> String
show :: FileSaverFlags -> String
$cshowList :: [FileSaverFlags] -> ShowS
showList :: [FileSaverFlags] -> ShowS
Show, FileSaverFlags -> FileSaverFlags -> Bool
(FileSaverFlags -> FileSaverFlags -> Bool)
-> (FileSaverFlags -> FileSaverFlags -> Bool) -> Eq FileSaverFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FileSaverFlags -> FileSaverFlags -> Bool
== :: FileSaverFlags -> FileSaverFlags -> Bool
$c/= :: FileSaverFlags -> FileSaverFlags -> Bool
/= :: FileSaverFlags -> FileSaverFlags -> Bool
Eq)

instance P.Enum FileSaverFlags where
    fromEnum :: FileSaverFlags -> Int
fromEnum FileSaverFlags
FileSaverFlagsNone = Int
0
    fromEnum FileSaverFlags
FileSaverFlagsIgnoreInvalidChars = Int
1
    fromEnum FileSaverFlags
FileSaverFlagsIgnoreModificationTime = Int
2
    fromEnum FileSaverFlags
FileSaverFlagsCreateBackup = Int
4
    fromEnum (AnotherFileSaverFlags Int
k) = Int
k

    toEnum :: Int -> FileSaverFlags
toEnum Int
0 = FileSaverFlags
FileSaverFlagsNone
    toEnum Int
1 = FileSaverFlags
FileSaverFlagsIgnoreInvalidChars
    toEnum Int
2 = FileSaverFlags
FileSaverFlagsIgnoreModificationTime
    toEnum Int
4 = FileSaverFlags
FileSaverFlagsCreateBackup
    toEnum Int
k = Int -> FileSaverFlags
AnotherFileSaverFlags Int
k

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

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

foreign import ccall "gtk_source_file_saver_flags_get_type" c_gtk_source_file_saver_flags_get_type :: 
    IO GType

instance B.Types.TypedObject FileSaverFlags where
    glibType :: IO GType
glibType = IO GType
c_gtk_source_file_saver_flags_get_type

instance B.Types.BoxedFlags FileSaverFlags

instance IsGFlag FileSaverFlags