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


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

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

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

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

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

foreign import ccall "gtk_source_gutter_renderer_state_get_type" c_gtk_source_gutter_renderer_state_get_type :: 
    IO GType

instance B.Types.TypedObject GutterRendererState where
    glibType :: IO GType
glibType = IO GType
c_gtk_source_gutter_renderer_state_get_type

instance B.Types.BoxedFlags GutterRendererState

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
$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

-- 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 [Buffer:implicitTrailingNewline]("GI.GtkSource.Objects.Buffer#g:attr:implicitTrailingNewline") 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
$cshowsPrec :: Int -> DrawSpacesFlags -> ShowS
showsPrec :: Int -> DrawSpacesFlags -> ShowS
$cshow :: DrawSpacesFlags -> String
show :: DrawSpacesFlags -> String
$cshowList :: [DrawSpacesFlags] -> ShowS
showList :: [DrawSpacesFlags] -> ShowS
Show, DrawSpacesFlags -> DrawSpacesFlags -> Bool
(DrawSpacesFlags -> DrawSpacesFlags -> Bool)
-> (DrawSpacesFlags -> DrawSpacesFlags -> Bool)
-> Eq DrawSpacesFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DrawSpacesFlags -> DrawSpacesFlags -> Bool
== :: DrawSpacesFlags -> DrawSpacesFlags -> Bool
$c/= :: DrawSpacesFlags -> DrawSpacesFlags -> Bool
/= :: DrawSpacesFlags -> DrawSpacesFlags -> Bool
Eq)

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

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

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

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

foreign import ccall "gtk_source_draw_spaces_flags_get_type" c_gtk_source_draw_spaces_flags_get_type :: 
    IO GType

instance B.Types.TypedObject DrawSpacesFlags where
    glibType :: IO GType
glibType = IO GType
c_gtk_source_draw_spaces_flags_get_type

instance B.Types.BoxedFlags DrawSpacesFlags

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

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

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

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

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

foreign import ccall "gtk_source_completion_activation_get_type" c_gtk_source_completion_activation_get_type :: 
    IO GType

instance B.Types.TypedObject CompletionActivation where
    glibType :: IO GType
glibType = IO GType
c_gtk_source_completion_activation_get_type

instance B.Types.BoxedFlags CompletionActivation

instance IsGFlag CompletionActivation