-- | 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.GtkSource.Flags
    ( 

 -- * Flags
-- ** CompletionActivation #flag:CompletionActivation#

    CompletionActivation(..)                ,


-- ** DrawSpacesFlags #flag:DrawSpacesFlags#

    DrawSpacesFlags(..)                     ,


-- ** FileSaverFlags #flag:FileSaverFlags#

    FileSaverFlags(..)                      ,


-- ** GutterRendererState #flag:GutterRendererState#

    GutterRendererState(..)                 ,


-- ** 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.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


-- Flags SpaceTypeFlags
-- | t'GI.GtkSource.Flags.SpaceTypeFlags' contains flags for white space types.
-- 
-- /Since: 3.24/
data SpaceTypeFlags = 
      SpaceTypeFlagsNone
    -- ^ No flags.
    | SpaceTypeFlagsSpace
    -- ^ Space character.
    | SpaceTypeFlagsTab
    -- ^ Tab character.
    | SpaceTypeFlagsNewline
    -- ^ Line break character. If the
    --   t'GI.GtkSource.Objects.Buffer.Buffer':@/implicit-trailing-newline/@ 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
showList :: [SpaceTypeFlags] -> ShowS
$cshowList :: [SpaceTypeFlags] -> ShowS
show :: SpaceTypeFlags -> String
$cshow :: SpaceTypeFlags -> String
showsPrec :: Int -> SpaceTypeFlags -> ShowS
$cshowsPrec :: Int -> SpaceTypeFlags -> ShowS
Show, SpaceTypeFlags -> SpaceTypeFlags -> Bool
(SpaceTypeFlags -> SpaceTypeFlags -> Bool)
-> (SpaceTypeFlags -> SpaceTypeFlags -> Bool) -> Eq SpaceTypeFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SpaceTypeFlags -> SpaceTypeFlags -> Bool
$c/= :: SpaceTypeFlags -> SpaceTypeFlags -> Bool
== :: SpaceTypeFlags -> SpaceTypeFlags -> Bool
$c== :: SpaceTypeFlags -> SpaceTypeFlags -> Bool
Eq)

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

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

instance P.Ord SpaceTypeFlags where
    compare :: SpaceTypeFlags -> SpaceTypeFlags -> Ordering
compare a :: SpaceTypeFlags
a b :: 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)

foreign import ccall "gtk_source_space_type_flags_get_type" c_gtk_source_space_type_flags_get_type :: 
    IO GType

instance BoxedFlags SpaceTypeFlags where
    boxedFlagsType :: Proxy SpaceTypeFlags -> IO GType
boxedFlagsType _ = IO GType
c_gtk_source_space_type_flags_get_type

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'.
-- 
-- /Since: 3.24/
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
showList :: [SpaceLocationFlags] -> ShowS
$cshowList :: [SpaceLocationFlags] -> ShowS
show :: SpaceLocationFlags -> String
$cshow :: SpaceLocationFlags -> String
showsPrec :: Int -> SpaceLocationFlags -> ShowS
$cshowsPrec :: Int -> SpaceLocationFlags -> ShowS
Show, SpaceLocationFlags -> SpaceLocationFlags -> Bool
(SpaceLocationFlags -> SpaceLocationFlags -> Bool)
-> (SpaceLocationFlags -> SpaceLocationFlags -> Bool)
-> Eq SpaceLocationFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SpaceLocationFlags -> SpaceLocationFlags -> Bool
$c/= :: SpaceLocationFlags -> SpaceLocationFlags -> Bool
== :: SpaceLocationFlags -> SpaceLocationFlags -> Bool
$c== :: SpaceLocationFlags -> SpaceLocationFlags -> Bool
Eq)

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

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

instance P.Ord SpaceLocationFlags where
    compare :: SpaceLocationFlags -> SpaceLocationFlags -> Ordering
compare a :: SpaceLocationFlags
a b :: 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)

foreign import ccall "gtk_source_space_location_flags_get_type" c_gtk_source_space_location_flags_get_type :: 
    IO GType

instance BoxedFlags SpaceLocationFlags where
    boxedFlagsType :: Proxy SpaceLocationFlags -> IO GType
boxedFlagsType _ = IO GType
c_gtk_source_space_location_flags_get_type

instance IsGFlag SpaceLocationFlags

-- Flags SortFlags
-- | /No description available in the introspection data./
-- 
-- /Since: 3.18/
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
showList :: [SortFlags] -> ShowS
$cshowList :: [SortFlags] -> ShowS
show :: SortFlags -> String
$cshow :: SortFlags -> String
showsPrec :: Int -> SortFlags -> ShowS
$cshowsPrec :: Int -> SortFlags -> ShowS
Show, SortFlags -> SortFlags -> Bool
(SortFlags -> SortFlags -> Bool)
-> (SortFlags -> SortFlags -> Bool) -> Eq SortFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SortFlags -> SortFlags -> Bool
$c/= :: SortFlags -> SortFlags -> Bool
== :: SortFlags -> SortFlags -> Bool
$c== :: SortFlags -> SortFlags -> Bool
Eq)

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

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

instance P.Ord SortFlags where
    compare :: SortFlags -> SortFlags -> Ordering
compare a :: SortFlags
a b :: 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)

foreign import ccall "gtk_source_sort_flags_get_type" c_gtk_source_sort_flags_get_type :: 
    IO GType

instance BoxedFlags SortFlags where
    boxedFlagsType :: Proxy SortFlags -> IO GType
boxedFlagsType _ = IO GType
c_gtk_source_sort_flags_get_type

instance IsGFlag SortFlags

-- Flags GutterRendererState
-- | /No description available in the introspection data./
data GutterRendererState = 
      GutterRendererStateNormal
    -- ^ normal state
    | GutterRendererStateCursor
    -- ^ area in the renderer represents the
    -- line on which the insert cursor is currently positioned
    | GutterRendererStatePrelit
    -- ^ the mouse pointer is currently
    -- over the activatable area of the renderer
    | GutterRendererStateSelected
    -- ^ area in the renderer represents
    -- a line in the buffer which contains part of the selection
    | AnotherGutterRendererState Int
    -- ^ Catch-all for unknown values
    deriving (Int -> GutterRendererState -> ShowS
[GutterRendererState] -> ShowS
GutterRendererState -> String
(Int -> GutterRendererState -> ShowS)
-> (GutterRendererState -> String)
-> ([GutterRendererState] -> ShowS)
-> Show GutterRendererState
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GutterRendererState] -> ShowS
$cshowList :: [GutterRendererState] -> ShowS
show :: GutterRendererState -> String
$cshow :: GutterRendererState -> String
showsPrec :: Int -> GutterRendererState -> ShowS
$cshowsPrec :: Int -> GutterRendererState -> ShowS
Show, GutterRendererState -> GutterRendererState -> Bool
(GutterRendererState -> GutterRendererState -> Bool)
-> (GutterRendererState -> GutterRendererState -> Bool)
-> Eq GutterRendererState
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GutterRendererState -> GutterRendererState -> Bool
$c/= :: GutterRendererState -> GutterRendererState -> Bool
== :: GutterRendererState -> GutterRendererState -> Bool
$c== :: GutterRendererState -> GutterRendererState -> Bool
Eq)

instance P.Enum GutterRendererState where
    fromEnum :: GutterRendererState -> Int
fromEnum GutterRendererStateNormal = 0
    fromEnum GutterRendererStateCursor = 1
    fromEnum GutterRendererStatePrelit = 2
    fromEnum GutterRendererStateSelected = 4
    fromEnum (AnotherGutterRendererState k :: Int
k) = Int
k

    toEnum :: Int -> GutterRendererState
toEnum 0 = GutterRendererState
GutterRendererStateNormal
    toEnum 1 = GutterRendererState
GutterRendererStateCursor
    toEnum 2 = GutterRendererState
GutterRendererStatePrelit
    toEnum 4 = GutterRendererState
GutterRendererStateSelected
    toEnum k :: Int
k = Int -> GutterRendererState
AnotherGutterRendererState Int
k

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

foreign import ccall "gtk_source_gutter_renderer_state_get_type" c_gtk_source_gutter_renderer_state_get_type :: 
    IO GType

instance BoxedFlags GutterRendererState where
    boxedFlagsType :: Proxy GutterRendererState -> IO GType
boxedFlagsType _ = IO GType
c_gtk_source_gutter_renderer_state_get_type

instance IsGFlag GutterRendererState

-- Flags FileSaverFlags
-- | Flags to define the behavior of a t'GI.GtkSource.Objects.FileSaver.FileSaver'.
-- 
-- /Since: 3.14/
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
showList :: [FileSaverFlags] -> ShowS
$cshowList :: [FileSaverFlags] -> ShowS
show :: FileSaverFlags -> String
$cshow :: FileSaverFlags -> String
showsPrec :: Int -> FileSaverFlags -> ShowS
$cshowsPrec :: Int -> FileSaverFlags -> ShowS
Show, FileSaverFlags -> FileSaverFlags -> Bool
(FileSaverFlags -> FileSaverFlags -> Bool)
-> (FileSaverFlags -> FileSaverFlags -> Bool) -> Eq FileSaverFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FileSaverFlags -> FileSaverFlags -> Bool
$c/= :: FileSaverFlags -> FileSaverFlags -> Bool
== :: FileSaverFlags -> FileSaverFlags -> Bool
$c== :: FileSaverFlags -> FileSaverFlags -> Bool
Eq)

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

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

instance P.Ord FileSaverFlags where
    compare :: FileSaverFlags -> FileSaverFlags -> Ordering
compare a :: FileSaverFlags
a b :: 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)

foreign import ccall "gtk_source_file_saver_flags_get_type" c_gtk_source_file_saver_flags_get_type :: 
    IO GType

instance BoxedFlags FileSaverFlags where
    boxedFlagsType :: Proxy FileSaverFlags -> IO GType
boxedFlagsType _ = IO GType
c_gtk_source_file_saver_flags_get_type

instance IsGFlag FileSaverFlags

-- Flags DrawSpacesFlags
{-# DEPRECATED DrawSpacesFlags ["(Since version 3.24)","Use t'GI.GtkSource.Flags.SpaceTypeFlags' and","t'GI.GtkSource.Flags.SpaceLocationFlags' instead."] #-}
-- | GtkSourceDrawSpacesFlags determine what kind of spaces whould be drawn. If none
-- of GTK_SOURCE_DRAW_SPACES_LEADING, GTK_SOURCE_DRAW_SPACES_TEXT or
-- GTK_SOURCE_DRAW_SPACES_TRAILING is specified, whitespaces at any position in
-- the line will be drawn (i.e. it has the same effect as specifying all of them).
data DrawSpacesFlags = 
      DrawSpacesFlagsSpace
    -- ^ whether the space character should be drawn.
    | DrawSpacesFlagsTab
    -- ^ whether the tab character should be drawn.
    | DrawSpacesFlagsNewline
    -- ^ whether the line breaks should be drawn. If
    --   the t'GI.GtkSource.Objects.Buffer.Buffer':@/implicit-trailing-newline/@ property is 'P.True', a line
    --   break is also drawn at the end of the buffer.
    | DrawSpacesFlagsNbsp
    -- ^ whether the non-breaking whitespaces should be drawn.
    | DrawSpacesFlagsLeading
    -- ^ whether leading whitespaces should be drawn.
    | DrawSpacesFlagsText
    -- ^ whether whitespaces inside text should be drawn.
    | DrawSpacesFlagsTrailing
    -- ^ whether trailing whitespaces should be drawn.
    | DrawSpacesFlagsAll
    -- ^ wheter all kind of spaces should be drawn.
    | AnotherDrawSpacesFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> DrawSpacesFlags -> ShowS
[DrawSpacesFlags] -> ShowS
DrawSpacesFlags -> String
(Int -> DrawSpacesFlags -> ShowS)
-> (DrawSpacesFlags -> String)
-> ([DrawSpacesFlags] -> ShowS)
-> Show DrawSpacesFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DrawSpacesFlags] -> ShowS
$cshowList :: [DrawSpacesFlags] -> ShowS
show :: DrawSpacesFlags -> String
$cshow :: DrawSpacesFlags -> String
showsPrec :: Int -> DrawSpacesFlags -> ShowS
$cshowsPrec :: Int -> DrawSpacesFlags -> ShowS
Show, DrawSpacesFlags -> DrawSpacesFlags -> Bool
(DrawSpacesFlags -> DrawSpacesFlags -> Bool)
-> (DrawSpacesFlags -> DrawSpacesFlags -> Bool)
-> Eq DrawSpacesFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DrawSpacesFlags -> DrawSpacesFlags -> Bool
$c/= :: DrawSpacesFlags -> DrawSpacesFlags -> Bool
== :: DrawSpacesFlags -> DrawSpacesFlags -> Bool
$c== :: DrawSpacesFlags -> DrawSpacesFlags -> Bool
Eq)

instance P.Enum DrawSpacesFlags where
    fromEnum :: DrawSpacesFlags -> Int
fromEnum DrawSpacesFlagsSpace = 1
    fromEnum DrawSpacesFlagsTab = 2
    fromEnum DrawSpacesFlagsNewline = 4
    fromEnum DrawSpacesFlagsNbsp = 8
    fromEnum DrawSpacesFlagsLeading = 16
    fromEnum DrawSpacesFlagsText = 32
    fromEnum DrawSpacesFlagsTrailing = 64
    fromEnum DrawSpacesFlagsAll = 127
    fromEnum (AnotherDrawSpacesFlags k :: Int
k) = Int
k

    toEnum :: Int -> DrawSpacesFlags
toEnum 1 = DrawSpacesFlags
DrawSpacesFlagsSpace
    toEnum 2 = DrawSpacesFlags
DrawSpacesFlagsTab
    toEnum 4 = DrawSpacesFlags
DrawSpacesFlagsNewline
    toEnum 8 = DrawSpacesFlags
DrawSpacesFlagsNbsp
    toEnum 16 = DrawSpacesFlags
DrawSpacesFlagsLeading
    toEnum 32 = DrawSpacesFlags
DrawSpacesFlagsText
    toEnum 64 = DrawSpacesFlags
DrawSpacesFlagsTrailing
    toEnum 127 = DrawSpacesFlags
DrawSpacesFlagsAll
    toEnum k :: Int
k = Int -> DrawSpacesFlags
AnotherDrawSpacesFlags Int
k

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

foreign import ccall "gtk_source_draw_spaces_flags_get_type" c_gtk_source_draw_spaces_flags_get_type :: 
    IO GType

instance BoxedFlags DrawSpacesFlags where
    boxedFlagsType :: Proxy DrawSpacesFlags -> IO GType
boxedFlagsType _ = IO GType
c_gtk_source_draw_spaces_flags_get_type

instance IsGFlag DrawSpacesFlags

-- Flags CompletionActivation
-- | /No description available in the introspection data./
data CompletionActivation = 
      CompletionActivationNone
    -- ^ None.
    | CompletionActivationInteractive
    -- ^ Interactive activation. By
    -- default, it occurs on each insertion in the t'GI.Gtk.Objects.TextBuffer.TextBuffer'. This can be
    -- blocked temporarily with 'GI.GtkSource.Objects.Completion.completionBlockInteractive'.
    | CompletionActivationUserRequested
    -- ^ User requested activation.
    -- By default, it occurs when the user presses
    -- \<keycombo>\<keycap>Control\<\/keycap>\<keycap>space\<\/keycap>\<\/keycombo>.
    | AnotherCompletionActivation Int
    -- ^ Catch-all for unknown values
    deriving (Int -> CompletionActivation -> ShowS
[CompletionActivation] -> ShowS
CompletionActivation -> String
(Int -> CompletionActivation -> ShowS)
-> (CompletionActivation -> String)
-> ([CompletionActivation] -> ShowS)
-> Show CompletionActivation
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CompletionActivation] -> ShowS
$cshowList :: [CompletionActivation] -> ShowS
show :: CompletionActivation -> String
$cshow :: CompletionActivation -> String
showsPrec :: Int -> CompletionActivation -> ShowS
$cshowsPrec :: Int -> CompletionActivation -> ShowS
Show, CompletionActivation -> CompletionActivation -> Bool
(CompletionActivation -> CompletionActivation -> Bool)
-> (CompletionActivation -> CompletionActivation -> Bool)
-> Eq CompletionActivation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CompletionActivation -> CompletionActivation -> Bool
$c/= :: CompletionActivation -> CompletionActivation -> Bool
== :: CompletionActivation -> CompletionActivation -> Bool
$c== :: CompletionActivation -> CompletionActivation -> Bool
Eq)

instance P.Enum CompletionActivation where
    fromEnum :: CompletionActivation -> Int
fromEnum CompletionActivationNone = 0
    fromEnum CompletionActivationInteractive = 1
    fromEnum CompletionActivationUserRequested = 2
    fromEnum (AnotherCompletionActivation k :: Int
k) = Int
k

    toEnum :: Int -> CompletionActivation
toEnum 0 = CompletionActivation
CompletionActivationNone
    toEnum 1 = CompletionActivation
CompletionActivationInteractive
    toEnum 2 = CompletionActivation
CompletionActivationUserRequested
    toEnum k :: Int
k = Int -> CompletionActivation
AnotherCompletionActivation Int
k

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

foreign import ccall "gtk_source_completion_activation_get_type" c_gtk_source_completion_activation_get_type :: 
    IO GType

instance BoxedFlags CompletionActivation where
    boxedFlagsType :: Proxy CompletionActivation -> IO GType
boxedFlagsType _ = IO GType
c_gtk_source_completion_activation_get_type

instance IsGFlag CompletionActivation