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

 -- * Flags


-- ** EditorTypingAttributes #flag:EditorTypingAttributes#

    EditorTypingAttributes(..)              ,


-- ** FindOptions #flag:FindOptions#

    FindOptions(..)                         ,


-- ** HitTestResultContext #flag:HitTestResultContext#

    HitTestResultContext(..)                ,


-- ** InputHints #flag:InputHints#

    InputHints(..)                          ,


-- ** SnapshotOptions #flag:SnapshotOptions#

    SnapshotOptions(..)                     ,


-- ** WebsiteDataTypes #flag:WebsiteDataTypes#

    WebsiteDataTypes(..)                    ,




    ) 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 WebsiteDataTypes
-- | Enum values with flags representing types of Website data.
-- 
-- /Since: 2.16/
data WebsiteDataTypes = 
      WebsiteDataTypesMemoryCache
    -- ^ Memory cache.
    | WebsiteDataTypesDiskCache
    -- ^ HTTP disk cache.
    | WebsiteDataTypesOfflineApplicationCache
    -- ^ Offline web application cache.
    | WebsiteDataTypesSessionStorage
    -- ^ Session storage data.
    | WebsiteDataTypesLocalStorage
    -- ^ Local storage data.
    | WebsiteDataTypesIndexeddbDatabases
    -- ^ IndexedDB databases.
    | WebsiteDataTypesCookies
    -- ^ Cookies.
    | WebsiteDataTypesDeviceIdHashSalt
    -- ^ Hash salt used to generate the device ids used by webpages.
    | WebsiteDataTypesHstsCache
    -- ^ HSTS cache.
    | WebsiteDataTypesItp
    -- ^ Intelligent Tracking Prevention data.
    | WebsiteDataTypesServiceWorkerRegistrations
    -- ^ Service worker registrations.
    | WebsiteDataTypesDomCache
    -- ^ DOM (CacheStorage) cache.
    | WebsiteDataTypesAll
    -- ^ All types.
    | AnotherWebsiteDataTypes Int
    -- ^ Catch-all for unknown values
    deriving (Int -> WebsiteDataTypes -> ShowS
[WebsiteDataTypes] -> ShowS
WebsiteDataTypes -> String
(Int -> WebsiteDataTypes -> ShowS)
-> (WebsiteDataTypes -> String)
-> ([WebsiteDataTypes] -> ShowS)
-> Show WebsiteDataTypes
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> WebsiteDataTypes -> ShowS
showsPrec :: Int -> WebsiteDataTypes -> ShowS
$cshow :: WebsiteDataTypes -> String
show :: WebsiteDataTypes -> String
$cshowList :: [WebsiteDataTypes] -> ShowS
showList :: [WebsiteDataTypes] -> ShowS
Show, WebsiteDataTypes -> WebsiteDataTypes -> Bool
(WebsiteDataTypes -> WebsiteDataTypes -> Bool)
-> (WebsiteDataTypes -> WebsiteDataTypes -> Bool)
-> Eq WebsiteDataTypes
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: WebsiteDataTypes -> WebsiteDataTypes -> Bool
== :: WebsiteDataTypes -> WebsiteDataTypes -> Bool
$c/= :: WebsiteDataTypes -> WebsiteDataTypes -> Bool
/= :: WebsiteDataTypes -> WebsiteDataTypes -> Bool
Eq)

instance P.Enum WebsiteDataTypes where
    fromEnum :: WebsiteDataTypes -> Int
fromEnum WebsiteDataTypes
WebsiteDataTypesMemoryCache = Int
1
    fromEnum WebsiteDataTypes
WebsiteDataTypesDiskCache = Int
2
    fromEnum WebsiteDataTypes
WebsiteDataTypesOfflineApplicationCache = Int
4
    fromEnum WebsiteDataTypes
WebsiteDataTypesSessionStorage = Int
8
    fromEnum WebsiteDataTypes
WebsiteDataTypesLocalStorage = Int
16
    fromEnum WebsiteDataTypes
WebsiteDataTypesIndexeddbDatabases = Int
32
    fromEnum WebsiteDataTypes
WebsiteDataTypesCookies = Int
64
    fromEnum WebsiteDataTypes
WebsiteDataTypesDeviceIdHashSalt = Int
128
    fromEnum WebsiteDataTypes
WebsiteDataTypesHstsCache = Int
256
    fromEnum WebsiteDataTypes
WebsiteDataTypesItp = Int
512
    fromEnum WebsiteDataTypes
WebsiteDataTypesServiceWorkerRegistrations = Int
1024
    fromEnum WebsiteDataTypes
WebsiteDataTypesDomCache = Int
2048
    fromEnum WebsiteDataTypes
WebsiteDataTypesAll = Int
4095
    fromEnum (AnotherWebsiteDataTypes Int
k) = Int
k

    toEnum :: Int -> WebsiteDataTypes
toEnum Int
1 = WebsiteDataTypes
WebsiteDataTypesMemoryCache
    toEnum Int
2 = WebsiteDataTypes
WebsiteDataTypesDiskCache
    toEnum Int
4 = WebsiteDataTypes
WebsiteDataTypesOfflineApplicationCache
    toEnum Int
8 = WebsiteDataTypes
WebsiteDataTypesSessionStorage
    toEnum Int
16 = WebsiteDataTypes
WebsiteDataTypesLocalStorage
    toEnum Int
32 = WebsiteDataTypes
WebsiteDataTypesIndexeddbDatabases
    toEnum Int
64 = WebsiteDataTypes
WebsiteDataTypesCookies
    toEnum Int
128 = WebsiteDataTypes
WebsiteDataTypesDeviceIdHashSalt
    toEnum Int
256 = WebsiteDataTypes
WebsiteDataTypesHstsCache
    toEnum Int
512 = WebsiteDataTypes
WebsiteDataTypesItp
    toEnum Int
1024 = WebsiteDataTypes
WebsiteDataTypesServiceWorkerRegistrations
    toEnum Int
2048 = WebsiteDataTypes
WebsiteDataTypesDomCache
    toEnum Int
4095 = WebsiteDataTypes
WebsiteDataTypesAll
    toEnum Int
k = Int -> WebsiteDataTypes
AnotherWebsiteDataTypes Int
k

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

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

foreign import ccall "webkit_website_data_types_get_type" c_webkit_website_data_types_get_type :: 
    IO GType

instance B.Types.TypedObject WebsiteDataTypes where
    glibType :: IO GType
glibType = IO GType
c_webkit_website_data_types_get_type

instance B.Types.BoxedFlags WebsiteDataTypes

instance IsGFlag WebsiteDataTypes

-- Flags SnapshotOptions
-- | Enum values used to specify options when taking a snapshot
-- from a t'GI.WebKit.Objects.WebView.WebView'.
data SnapshotOptions = 
      SnapshotOptionsNone
    -- ^ Do not include any special options.
    | SnapshotOptionsIncludeSelectionHighlighting
    -- ^ Whether to include in the
    -- snapshot the highlight of the selected content.
    | SnapshotOptionsTransparentBackground
    -- ^ Do not fill the background with white before
    -- rendering the snapshot. Since 2.8
    | AnotherSnapshotOptions Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SnapshotOptions -> ShowS
[SnapshotOptions] -> ShowS
SnapshotOptions -> String
(Int -> SnapshotOptions -> ShowS)
-> (SnapshotOptions -> String)
-> ([SnapshotOptions] -> ShowS)
-> Show SnapshotOptions
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SnapshotOptions -> ShowS
showsPrec :: Int -> SnapshotOptions -> ShowS
$cshow :: SnapshotOptions -> String
show :: SnapshotOptions -> String
$cshowList :: [SnapshotOptions] -> ShowS
showList :: [SnapshotOptions] -> ShowS
Show, SnapshotOptions -> SnapshotOptions -> Bool
(SnapshotOptions -> SnapshotOptions -> Bool)
-> (SnapshotOptions -> SnapshotOptions -> Bool)
-> Eq SnapshotOptions
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SnapshotOptions -> SnapshotOptions -> Bool
== :: SnapshotOptions -> SnapshotOptions -> Bool
$c/= :: SnapshotOptions -> SnapshotOptions -> Bool
/= :: SnapshotOptions -> SnapshotOptions -> Bool
Eq)

instance P.Enum SnapshotOptions where
    fromEnum :: SnapshotOptions -> Int
fromEnum SnapshotOptions
SnapshotOptionsNone = Int
0
    fromEnum SnapshotOptions
SnapshotOptionsIncludeSelectionHighlighting = Int
1
    fromEnum SnapshotOptions
SnapshotOptionsTransparentBackground = Int
2
    fromEnum (AnotherSnapshotOptions Int
k) = Int
k

    toEnum :: Int -> SnapshotOptions
toEnum Int
0 = SnapshotOptions
SnapshotOptionsNone
    toEnum Int
1 = SnapshotOptions
SnapshotOptionsIncludeSelectionHighlighting
    toEnum Int
2 = SnapshotOptions
SnapshotOptionsTransparentBackground
    toEnum Int
k = Int -> SnapshotOptions
AnotherSnapshotOptions Int
k

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

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

foreign import ccall "webkit_snapshot_options_get_type" c_webkit_snapshot_options_get_type :: 
    IO GType

instance B.Types.TypedObject SnapshotOptions where
    glibType :: IO GType
glibType = IO GType
c_webkit_snapshot_options_get_type

instance B.Types.BoxedFlags SnapshotOptions

instance IsGFlag SnapshotOptions

-- Flags InputHints
-- | Enum values used to describe hints that might be taken into account by input methods.
-- 
-- /Since: 2.28/
data InputHints = 
      InputHintsNone
    -- ^ No special behavior suggested
    | InputHintsSpellcheck
    -- ^ Suggest spell checking
    | InputHintsLowercase
    -- ^ Suggest to not autocapitlize
    | InputHintsUppercaseChars
    -- ^ Suggest to capitalize all text
    | InputHintsUppercaseWords
    -- ^ Suggest to capitalize the first character of each word
    | InputHintsUppercaseSentences
    -- ^ Suggest to capitalize the first word of each sentence
    | InputHintsInhibitOsk
    -- ^ Suggest to not show an onscreen keyboard
    | AnotherInputHints Int
    -- ^ Catch-all for unknown values
    deriving (Int -> InputHints -> ShowS
[InputHints] -> ShowS
InputHints -> String
(Int -> InputHints -> ShowS)
-> (InputHints -> String)
-> ([InputHints] -> ShowS)
-> Show InputHints
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> InputHints -> ShowS
showsPrec :: Int -> InputHints -> ShowS
$cshow :: InputHints -> String
show :: InputHints -> String
$cshowList :: [InputHints] -> ShowS
showList :: [InputHints] -> ShowS
Show, InputHints -> InputHints -> Bool
(InputHints -> InputHints -> Bool)
-> (InputHints -> InputHints -> Bool) -> Eq InputHints
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: InputHints -> InputHints -> Bool
== :: InputHints -> InputHints -> Bool
$c/= :: InputHints -> InputHints -> Bool
/= :: InputHints -> InputHints -> Bool
Eq)

instance P.Enum InputHints where
    fromEnum :: InputHints -> Int
fromEnum InputHints
InputHintsNone = Int
0
    fromEnum InputHints
InputHintsSpellcheck = Int
1
    fromEnum InputHints
InputHintsLowercase = Int
2
    fromEnum InputHints
InputHintsUppercaseChars = Int
4
    fromEnum InputHints
InputHintsUppercaseWords = Int
8
    fromEnum InputHints
InputHintsUppercaseSentences = Int
16
    fromEnum InputHints
InputHintsInhibitOsk = Int
32
    fromEnum (AnotherInputHints Int
k) = Int
k

    toEnum :: Int -> InputHints
toEnum Int
0 = InputHints
InputHintsNone
    toEnum Int
1 = InputHints
InputHintsSpellcheck
    toEnum Int
2 = InputHints
InputHintsLowercase
    toEnum Int
4 = InputHints
InputHintsUppercaseChars
    toEnum Int
8 = InputHints
InputHintsUppercaseWords
    toEnum Int
16 = InputHints
InputHintsUppercaseSentences
    toEnum Int
32 = InputHints
InputHintsInhibitOsk
    toEnum Int
k = Int -> InputHints
AnotherInputHints Int
k

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

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

foreign import ccall "webkit_input_hints_get_type" c_webkit_input_hints_get_type :: 
    IO GType

instance B.Types.TypedObject InputHints where
    glibType :: IO GType
glibType = IO GType
c_webkit_input_hints_get_type

instance B.Types.BoxedFlags InputHints

instance IsGFlag InputHints

-- Flags HitTestResultContext
-- | Enum values with flags representing the context of a t'GI.WebKit.Objects.HitTestResult.HitTestResult'.
data HitTestResultContext = 
      HitTestResultContextDocument
    -- ^ anywhere in the document.
    | HitTestResultContextLink
    -- ^ a hyperlink element.
    | HitTestResultContextImage
    -- ^ an image element.
    | HitTestResultContextMedia
    -- ^ a video or audio element.
    | HitTestResultContextEditable
    -- ^ an editable element
    | HitTestResultContextScrollbar
    -- ^ a scrollbar element.
    | HitTestResultContextSelection
    -- ^ a selected element. Since 2.8
    | AnotherHitTestResultContext Int
    -- ^ Catch-all for unknown values
    deriving (Int -> HitTestResultContext -> ShowS
[HitTestResultContext] -> ShowS
HitTestResultContext -> String
(Int -> HitTestResultContext -> ShowS)
-> (HitTestResultContext -> String)
-> ([HitTestResultContext] -> ShowS)
-> Show HitTestResultContext
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> HitTestResultContext -> ShowS
showsPrec :: Int -> HitTestResultContext -> ShowS
$cshow :: HitTestResultContext -> String
show :: HitTestResultContext -> String
$cshowList :: [HitTestResultContext] -> ShowS
showList :: [HitTestResultContext] -> ShowS
Show, HitTestResultContext -> HitTestResultContext -> Bool
(HitTestResultContext -> HitTestResultContext -> Bool)
-> (HitTestResultContext -> HitTestResultContext -> Bool)
-> Eq HitTestResultContext
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: HitTestResultContext -> HitTestResultContext -> Bool
== :: HitTestResultContext -> HitTestResultContext -> Bool
$c/= :: HitTestResultContext -> HitTestResultContext -> Bool
/= :: HitTestResultContext -> HitTestResultContext -> Bool
Eq)

instance P.Enum HitTestResultContext where
    fromEnum :: HitTestResultContext -> Int
fromEnum HitTestResultContext
HitTestResultContextDocument = Int
2
    fromEnum HitTestResultContext
HitTestResultContextLink = Int
4
    fromEnum HitTestResultContext
HitTestResultContextImage = Int
8
    fromEnum HitTestResultContext
HitTestResultContextMedia = Int
16
    fromEnum HitTestResultContext
HitTestResultContextEditable = Int
32
    fromEnum HitTestResultContext
HitTestResultContextScrollbar = Int
64
    fromEnum HitTestResultContext
HitTestResultContextSelection = Int
128
    fromEnum (AnotherHitTestResultContext Int
k) = Int
k

    toEnum :: Int -> HitTestResultContext
toEnum Int
2 = HitTestResultContext
HitTestResultContextDocument
    toEnum Int
4 = HitTestResultContext
HitTestResultContextLink
    toEnum Int
8 = HitTestResultContext
HitTestResultContextImage
    toEnum Int
16 = HitTestResultContext
HitTestResultContextMedia
    toEnum Int
32 = HitTestResultContext
HitTestResultContextEditable
    toEnum Int
64 = HitTestResultContext
HitTestResultContextScrollbar
    toEnum Int
128 = HitTestResultContext
HitTestResultContextSelection
    toEnum Int
k = Int -> HitTestResultContext
AnotherHitTestResultContext Int
k

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

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

foreign import ccall "webkit_hit_test_result_context_get_type" c_webkit_hit_test_result_context_get_type :: 
    IO GType

instance B.Types.TypedObject HitTestResultContext where
    glibType :: IO GType
glibType = IO GType
c_webkit_hit_test_result_context_get_type

instance B.Types.BoxedFlags HitTestResultContext

instance IsGFlag HitTestResultContext

-- Flags FindOptions
-- | Enum values used to specify search options.
data FindOptions = 
      FindOptionsNone
    -- ^ no search flags, this means a case
    --   sensitive, no wrap, forward only search.
    | FindOptionsCaseInsensitive
    -- ^ case insensitive search.
    | FindOptionsAtWordStarts
    -- ^ search text only at the
    --   begining of the words.
    | FindOptionsTreatMedialCapitalAsWordStart
    -- ^ treat
    --   capital letters in the middle of words as word start.
    | FindOptionsBackwards
    -- ^ search backwards.
    | FindOptionsWrapAround
    -- ^ if not present search will stop
    --   at the end of the document.
    | AnotherFindOptions Int
    -- ^ Catch-all for unknown values
    deriving (Int -> FindOptions -> ShowS
[FindOptions] -> ShowS
FindOptions -> String
(Int -> FindOptions -> ShowS)
-> (FindOptions -> String)
-> ([FindOptions] -> ShowS)
-> Show FindOptions
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FindOptions -> ShowS
showsPrec :: Int -> FindOptions -> ShowS
$cshow :: FindOptions -> String
show :: FindOptions -> String
$cshowList :: [FindOptions] -> ShowS
showList :: [FindOptions] -> ShowS
Show, FindOptions -> FindOptions -> Bool
(FindOptions -> FindOptions -> Bool)
-> (FindOptions -> FindOptions -> Bool) -> Eq FindOptions
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FindOptions -> FindOptions -> Bool
== :: FindOptions -> FindOptions -> Bool
$c/= :: FindOptions -> FindOptions -> Bool
/= :: FindOptions -> FindOptions -> Bool
Eq)

instance P.Enum FindOptions where
    fromEnum :: FindOptions -> Int
fromEnum FindOptions
FindOptionsNone = Int
0
    fromEnum FindOptions
FindOptionsCaseInsensitive = Int
1
    fromEnum FindOptions
FindOptionsAtWordStarts = Int
2
    fromEnum FindOptions
FindOptionsTreatMedialCapitalAsWordStart = Int
4
    fromEnum FindOptions
FindOptionsBackwards = Int
8
    fromEnum FindOptions
FindOptionsWrapAround = Int
16
    fromEnum (AnotherFindOptions Int
k) = Int
k

    toEnum :: Int -> FindOptions
toEnum Int
0 = FindOptions
FindOptionsNone
    toEnum Int
1 = FindOptions
FindOptionsCaseInsensitive
    toEnum Int
2 = FindOptions
FindOptionsAtWordStarts
    toEnum Int
4 = FindOptions
FindOptionsTreatMedialCapitalAsWordStart
    toEnum Int
8 = FindOptions
FindOptionsBackwards
    toEnum Int
16 = FindOptions
FindOptionsWrapAround
    toEnum Int
k = Int -> FindOptions
AnotherFindOptions Int
k

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

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

foreign import ccall "webkit_find_options_get_type" c_webkit_find_options_get_type :: 
    IO GType

instance B.Types.TypedObject FindOptions where
    glibType :: IO GType
glibType = IO GType
c_webkit_find_options_get_type

instance B.Types.BoxedFlags FindOptions

instance IsGFlag FindOptions

-- Flags EditorTypingAttributes
-- | Enum values with flags representing typing attributes.
-- 
-- /Since: 2.10/
data EditorTypingAttributes = 
      EditorTypingAttributesNone
    -- ^ No typing attributes.
    | EditorTypingAttributesBold
    -- ^ Bold typing attribute.
    | EditorTypingAttributesItalic
    -- ^ Italic typing attribute.
    | EditorTypingAttributesUnderline
    -- ^ Underline typing attribute.
    | EditorTypingAttributesStrikethrough
    -- ^ Strikethrough typing attribute.
    | AnotherEditorTypingAttributes Int
    -- ^ Catch-all for unknown values
    deriving (Int -> EditorTypingAttributes -> ShowS
[EditorTypingAttributes] -> ShowS
EditorTypingAttributes -> String
(Int -> EditorTypingAttributes -> ShowS)
-> (EditorTypingAttributes -> String)
-> ([EditorTypingAttributes] -> ShowS)
-> Show EditorTypingAttributes
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> EditorTypingAttributes -> ShowS
showsPrec :: Int -> EditorTypingAttributes -> ShowS
$cshow :: EditorTypingAttributes -> String
show :: EditorTypingAttributes -> String
$cshowList :: [EditorTypingAttributes] -> ShowS
showList :: [EditorTypingAttributes] -> ShowS
Show, EditorTypingAttributes -> EditorTypingAttributes -> Bool
(EditorTypingAttributes -> EditorTypingAttributes -> Bool)
-> (EditorTypingAttributes -> EditorTypingAttributes -> Bool)
-> Eq EditorTypingAttributes
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: EditorTypingAttributes -> EditorTypingAttributes -> Bool
== :: EditorTypingAttributes -> EditorTypingAttributes -> Bool
$c/= :: EditorTypingAttributes -> EditorTypingAttributes -> Bool
/= :: EditorTypingAttributes -> EditorTypingAttributes -> Bool
Eq)

instance P.Enum EditorTypingAttributes where
    fromEnum :: EditorTypingAttributes -> Int
fromEnum EditorTypingAttributes
EditorTypingAttributesNone = Int
2
    fromEnum EditorTypingAttributes
EditorTypingAttributesBold = Int
4
    fromEnum EditorTypingAttributes
EditorTypingAttributesItalic = Int
8
    fromEnum EditorTypingAttributes
EditorTypingAttributesUnderline = Int
16
    fromEnum EditorTypingAttributes
EditorTypingAttributesStrikethrough = Int
32
    fromEnum (AnotherEditorTypingAttributes Int
k) = Int
k

    toEnum :: Int -> EditorTypingAttributes
toEnum Int
2 = EditorTypingAttributes
EditorTypingAttributesNone
    toEnum Int
4 = EditorTypingAttributes
EditorTypingAttributesBold
    toEnum Int
8 = EditorTypingAttributes
EditorTypingAttributesItalic
    toEnum Int
16 = EditorTypingAttributes
EditorTypingAttributesUnderline
    toEnum Int
32 = EditorTypingAttributes
EditorTypingAttributesStrikethrough
    toEnum Int
k = Int -> EditorTypingAttributes
AnotherEditorTypingAttributes Int
k

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

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

foreign import ccall "webkit_editor_typing_attributes_get_type" c_webkit_editor_typing_attributes_get_type :: 
    IO GType

instance B.Types.TypedObject EditorTypingAttributes where
    glibType :: IO GType
glibType = IO GType
c_webkit_editor_typing_attributes_get_type

instance B.Types.BoxedFlags EditorTypingAttributes

instance IsGFlag EditorTypingAttributes