{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)

The 'GI.Pango.Structs.LogAttr.LogAttr' structure stores information
about the attributes of a single character.
-}

#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
       && !defined(__HADDOCK_VERSION__))

module GI.Pango.Structs.LogAttr
    ( 

-- * Exported types
    LogAttr(..)                             ,
    newZeroLogAttr                          ,
    noLogAttr                               ,


 -- * Properties
-- ** backspaceDeletesCharacter #attr:backspaceDeletesCharacter#
{- | if set, backspace deletes one character
rather than the entire grapheme cluster. This
field is only meaningful on grapheme
boundaries (where /@isCursorPosition@/ is
set).  In some languages, the full grapheme
(e.g.  letter + diacritics) is considered a
unit, while in others, each decomposed
character in the grapheme is a unit. In the
default implementation of 'GI.Pango.Functions.break', this
bit is set on all grapheme boundaries except
those following Latin, Cyrillic or Greek base characters.
-}
    getLogAttrBackspaceDeletesCharacter     ,
#if ENABLE_OVERLOADING
    logAttr_backspaceDeletesCharacter       ,
#endif
    setLogAttrBackspaceDeletesCharacter     ,


-- ** isCharBreak #attr:isCharBreak#
{- | if set, can break here when doing character wrapping
-}
    getLogAttrIsCharBreak                   ,
#if ENABLE_OVERLOADING
    logAttr_isCharBreak                     ,
#endif
    setLogAttrIsCharBreak                   ,


-- ** isCursorPosition #attr:isCursorPosition#
{- | if set, cursor can appear in front of character.
i.e. this is a grapheme boundary, or the first character
in the text.
This flag implements Unicode\'s
\<ulink url=\"http:\/\/www.unicode.org\/reports\/tr29\/\">Grapheme
Cluster Boundaries\<\/ulink> semantics.
-}
    getLogAttrIsCursorPosition              ,
#if ENABLE_OVERLOADING
    logAttr_isCursorPosition                ,
#endif
    setLogAttrIsCursorPosition              ,


-- ** isExpandableSpace #attr:isExpandableSpace#
{- | is a whitespace character that can possibly be
expanded for justification purposes. (Since: 1.18)
-}
    getLogAttrIsExpandableSpace             ,
#if ENABLE_OVERLOADING
    logAttr_isExpandableSpace               ,
#endif
    setLogAttrIsExpandableSpace             ,


-- ** isLineBreak #attr:isLineBreak#
{- | if set, can break line in front of character
-}
    getLogAttrIsLineBreak                   ,
#if ENABLE_OVERLOADING
    logAttr_isLineBreak                     ,
#endif
    setLogAttrIsLineBreak                   ,


-- ** isMandatoryBreak #attr:isMandatoryBreak#
{- | if set, must break line in front of character
-}
    getLogAttrIsMandatoryBreak              ,
#if ENABLE_OVERLOADING
    logAttr_isMandatoryBreak                ,
#endif
    setLogAttrIsMandatoryBreak              ,


-- ** isSentenceBoundary #attr:isSentenceBoundary#
{- | is a sentence boundary.
There are two ways to divide sentences. The first assigns all
inter-sentence whitespace\/control\/format chars to some sentence,
so all chars are in some sentence; /@isSentenceBoundary@/ denotes
the boundaries there. The second way doesn\'t assign
between-sentence spaces, etc. to any sentence, so
/@isSentenceStart@/\//@isSentenceEnd@/ mark the boundaries of those sentences.
-}
    getLogAttrIsSentenceBoundary            ,
#if ENABLE_OVERLOADING
    logAttr_isSentenceBoundary              ,
#endif
    setLogAttrIsSentenceBoundary            ,


-- ** isSentenceEnd #attr:isSentenceEnd#
{- | is first char after a sentence.
Note that in degenerate cases, you could have both /@isSentenceStart@/
and /@isSentenceEnd@/ set for some character. (e.g. no space after a
period, so the next sentence starts right away)
-}
    getLogAttrIsSentenceEnd                 ,
#if ENABLE_OVERLOADING
    logAttr_isSentenceEnd                   ,
#endif
    setLogAttrIsSentenceEnd                 ,


-- ** isSentenceStart #attr:isSentenceStart#
{- | is first character in a sentence
-}
    getLogAttrIsSentenceStart               ,
#if ENABLE_OVERLOADING
    logAttr_isSentenceStart                 ,
#endif
    setLogAttrIsSentenceStart               ,


-- ** isWhite #attr:isWhite#
{- | is whitespace character
-}
    getLogAttrIsWhite                       ,
#if ENABLE_OVERLOADING
    logAttr_isWhite                         ,
#endif
    setLogAttrIsWhite                       ,


-- ** isWordBoundary #attr:isWordBoundary#
{- | is a word boundary.
More specifically, means that this is not a position in the middle
of a word.  For example, both sides of a punctuation mark are
considered word boundaries.  This flag is particularly useful when
selecting text word-by-word.
This flag implements Unicode\'s
\<ulink url=\"http:\/\/www.unicode.org\/reports\/tr29\/\">Word
Boundaries\<\/ulink> semantics. (Since: 1.22)
-}
    getLogAttrIsWordBoundary                ,
#if ENABLE_OVERLOADING
    logAttr_isWordBoundary                  ,
#endif
    setLogAttrIsWordBoundary                ,


-- ** isWordEnd #attr:isWordEnd#
{- | is first non-word char after a word
Note that in degenerate cases, you could have both /@isWordStart@/
and /@isWordEnd@/ set for some character.
-}
    getLogAttrIsWordEnd                     ,
#if ENABLE_OVERLOADING
    logAttr_isWordEnd                       ,
#endif
    setLogAttrIsWordEnd                     ,


-- ** isWordStart #attr:isWordStart#
{- | is first character in a word
-}
    getLogAttrIsWordStart                   ,
#if ENABLE_OVERLOADING
    logAttr_isWordStart                     ,
#endif
    setLogAttrIsWordStart                   ,




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


-- | Memory-managed wrapper type.
newtype LogAttr = LogAttr (ManagedPtr LogAttr)
instance WrappedPtr LogAttr where
    wrappedPtrCalloc = callocBytes 52
    wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 52 >=> wrapPtr LogAttr)
    wrappedPtrFree = Just ptr_to_g_free

-- | Construct a `LogAttr` struct initialized to zero.
newZeroLogAttr :: MonadIO m => m LogAttr
newZeroLogAttr = liftIO $ wrappedPtrCalloc >>= wrapPtr LogAttr

instance tag ~ 'AttrSet => Constructible LogAttr tag where
    new _ attrs = do
        o <- newZeroLogAttr
        GI.Attributes.set o attrs
        return o


-- | A convenience alias for `Nothing` :: `Maybe` `LogAttr`.
noLogAttr :: Maybe LogAttr
noLogAttr = Nothing

{- |
Get the value of the “@is_line_break@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' logAttr #isLineBreak
@
-}
getLogAttrIsLineBreak :: MonadIO m => LogAttr -> m Word32
getLogAttrIsLineBreak s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO Word32
    return val

{- |
Set the value of the “@is_line_break@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' logAttr [ #isLineBreak 'Data.GI.Base.Attributes.:=' value ]
@
-}
setLogAttrIsLineBreak :: MonadIO m => LogAttr -> Word32 -> m ()
setLogAttrIsLineBreak s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (val :: Word32)

#if ENABLE_OVERLOADING
data LogAttrIsLineBreakFieldInfo
instance AttrInfo LogAttrIsLineBreakFieldInfo where
    type AttrAllowedOps LogAttrIsLineBreakFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint LogAttrIsLineBreakFieldInfo = (~) Word32
    type AttrBaseTypeConstraint LogAttrIsLineBreakFieldInfo = (~) LogAttr
    type AttrGetType LogAttrIsLineBreakFieldInfo = Word32
    type AttrLabel LogAttrIsLineBreakFieldInfo = "is_line_break"
    type AttrOrigin LogAttrIsLineBreakFieldInfo = LogAttr
    attrGet _ = getLogAttrIsLineBreak
    attrSet _ = setLogAttrIsLineBreak
    attrConstruct = undefined
    attrClear _ = undefined

logAttr_isLineBreak :: AttrLabelProxy "isLineBreak"
logAttr_isLineBreak = AttrLabelProxy

#endif


{- |
Get the value of the “@is_mandatory_break@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' logAttr #isMandatoryBreak
@
-}
getLogAttrIsMandatoryBreak :: MonadIO m => LogAttr -> m Word32
getLogAttrIsMandatoryBreak s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 4) :: IO Word32
    return val

{- |
Set the value of the “@is_mandatory_break@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' logAttr [ #isMandatoryBreak 'Data.GI.Base.Attributes.:=' value ]
@
-}
setLogAttrIsMandatoryBreak :: MonadIO m => LogAttr -> Word32 -> m ()
setLogAttrIsMandatoryBreak s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 4) (val :: Word32)

#if ENABLE_OVERLOADING
data LogAttrIsMandatoryBreakFieldInfo
instance AttrInfo LogAttrIsMandatoryBreakFieldInfo where
    type AttrAllowedOps LogAttrIsMandatoryBreakFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint LogAttrIsMandatoryBreakFieldInfo = (~) Word32
    type AttrBaseTypeConstraint LogAttrIsMandatoryBreakFieldInfo = (~) LogAttr
    type AttrGetType LogAttrIsMandatoryBreakFieldInfo = Word32
    type AttrLabel LogAttrIsMandatoryBreakFieldInfo = "is_mandatory_break"
    type AttrOrigin LogAttrIsMandatoryBreakFieldInfo = LogAttr
    attrGet _ = getLogAttrIsMandatoryBreak
    attrSet _ = setLogAttrIsMandatoryBreak
    attrConstruct = undefined
    attrClear _ = undefined

logAttr_isMandatoryBreak :: AttrLabelProxy "isMandatoryBreak"
logAttr_isMandatoryBreak = AttrLabelProxy

#endif


{- |
Get the value of the “@is_char_break@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' logAttr #isCharBreak
@
-}
getLogAttrIsCharBreak :: MonadIO m => LogAttr -> m Word32
getLogAttrIsCharBreak s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 8) :: IO Word32
    return val

{- |
Set the value of the “@is_char_break@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' logAttr [ #isCharBreak 'Data.GI.Base.Attributes.:=' value ]
@
-}
setLogAttrIsCharBreak :: MonadIO m => LogAttr -> Word32 -> m ()
setLogAttrIsCharBreak s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 8) (val :: Word32)

#if ENABLE_OVERLOADING
data LogAttrIsCharBreakFieldInfo
instance AttrInfo LogAttrIsCharBreakFieldInfo where
    type AttrAllowedOps LogAttrIsCharBreakFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint LogAttrIsCharBreakFieldInfo = (~) Word32
    type AttrBaseTypeConstraint LogAttrIsCharBreakFieldInfo = (~) LogAttr
    type AttrGetType LogAttrIsCharBreakFieldInfo = Word32
    type AttrLabel LogAttrIsCharBreakFieldInfo = "is_char_break"
    type AttrOrigin LogAttrIsCharBreakFieldInfo = LogAttr
    attrGet _ = getLogAttrIsCharBreak
    attrSet _ = setLogAttrIsCharBreak
    attrConstruct = undefined
    attrClear _ = undefined

logAttr_isCharBreak :: AttrLabelProxy "isCharBreak"
logAttr_isCharBreak = AttrLabelProxy

#endif


{- |
Get the value of the “@is_white@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' logAttr #isWhite
@
-}
getLogAttrIsWhite :: MonadIO m => LogAttr -> m Word32
getLogAttrIsWhite s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 12) :: IO Word32
    return val

{- |
Set the value of the “@is_white@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' logAttr [ #isWhite 'Data.GI.Base.Attributes.:=' value ]
@
-}
setLogAttrIsWhite :: MonadIO m => LogAttr -> Word32 -> m ()
setLogAttrIsWhite s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 12) (val :: Word32)

#if ENABLE_OVERLOADING
data LogAttrIsWhiteFieldInfo
instance AttrInfo LogAttrIsWhiteFieldInfo where
    type AttrAllowedOps LogAttrIsWhiteFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint LogAttrIsWhiteFieldInfo = (~) Word32
    type AttrBaseTypeConstraint LogAttrIsWhiteFieldInfo = (~) LogAttr
    type AttrGetType LogAttrIsWhiteFieldInfo = Word32
    type AttrLabel LogAttrIsWhiteFieldInfo = "is_white"
    type AttrOrigin LogAttrIsWhiteFieldInfo = LogAttr
    attrGet _ = getLogAttrIsWhite
    attrSet _ = setLogAttrIsWhite
    attrConstruct = undefined
    attrClear _ = undefined

logAttr_isWhite :: AttrLabelProxy "isWhite"
logAttr_isWhite = AttrLabelProxy

#endif


{- |
Get the value of the “@is_cursor_position@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' logAttr #isCursorPosition
@
-}
getLogAttrIsCursorPosition :: MonadIO m => LogAttr -> m Word32
getLogAttrIsCursorPosition s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 16) :: IO Word32
    return val

{- |
Set the value of the “@is_cursor_position@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' logAttr [ #isCursorPosition 'Data.GI.Base.Attributes.:=' value ]
@
-}
setLogAttrIsCursorPosition :: MonadIO m => LogAttr -> Word32 -> m ()
setLogAttrIsCursorPosition s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 16) (val :: Word32)

#if ENABLE_OVERLOADING
data LogAttrIsCursorPositionFieldInfo
instance AttrInfo LogAttrIsCursorPositionFieldInfo where
    type AttrAllowedOps LogAttrIsCursorPositionFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint LogAttrIsCursorPositionFieldInfo = (~) Word32
    type AttrBaseTypeConstraint LogAttrIsCursorPositionFieldInfo = (~) LogAttr
    type AttrGetType LogAttrIsCursorPositionFieldInfo = Word32
    type AttrLabel LogAttrIsCursorPositionFieldInfo = "is_cursor_position"
    type AttrOrigin LogAttrIsCursorPositionFieldInfo = LogAttr
    attrGet _ = getLogAttrIsCursorPosition
    attrSet _ = setLogAttrIsCursorPosition
    attrConstruct = undefined
    attrClear _ = undefined

logAttr_isCursorPosition :: AttrLabelProxy "isCursorPosition"
logAttr_isCursorPosition = AttrLabelProxy

#endif


{- |
Get the value of the “@is_word_start@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' logAttr #isWordStart
@
-}
getLogAttrIsWordStart :: MonadIO m => LogAttr -> m Word32
getLogAttrIsWordStart s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 20) :: IO Word32
    return val

{- |
Set the value of the “@is_word_start@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' logAttr [ #isWordStart 'Data.GI.Base.Attributes.:=' value ]
@
-}
setLogAttrIsWordStart :: MonadIO m => LogAttr -> Word32 -> m ()
setLogAttrIsWordStart s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 20) (val :: Word32)

#if ENABLE_OVERLOADING
data LogAttrIsWordStartFieldInfo
instance AttrInfo LogAttrIsWordStartFieldInfo where
    type AttrAllowedOps LogAttrIsWordStartFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint LogAttrIsWordStartFieldInfo = (~) Word32
    type AttrBaseTypeConstraint LogAttrIsWordStartFieldInfo = (~) LogAttr
    type AttrGetType LogAttrIsWordStartFieldInfo = Word32
    type AttrLabel LogAttrIsWordStartFieldInfo = "is_word_start"
    type AttrOrigin LogAttrIsWordStartFieldInfo = LogAttr
    attrGet _ = getLogAttrIsWordStart
    attrSet _ = setLogAttrIsWordStart
    attrConstruct = undefined
    attrClear _ = undefined

logAttr_isWordStart :: AttrLabelProxy "isWordStart"
logAttr_isWordStart = AttrLabelProxy

#endif


{- |
Get the value of the “@is_word_end@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' logAttr #isWordEnd
@
-}
getLogAttrIsWordEnd :: MonadIO m => LogAttr -> m Word32
getLogAttrIsWordEnd s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 24) :: IO Word32
    return val

{- |
Set the value of the “@is_word_end@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' logAttr [ #isWordEnd 'Data.GI.Base.Attributes.:=' value ]
@
-}
setLogAttrIsWordEnd :: MonadIO m => LogAttr -> Word32 -> m ()
setLogAttrIsWordEnd s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 24) (val :: Word32)

#if ENABLE_OVERLOADING
data LogAttrIsWordEndFieldInfo
instance AttrInfo LogAttrIsWordEndFieldInfo where
    type AttrAllowedOps LogAttrIsWordEndFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint LogAttrIsWordEndFieldInfo = (~) Word32
    type AttrBaseTypeConstraint LogAttrIsWordEndFieldInfo = (~) LogAttr
    type AttrGetType LogAttrIsWordEndFieldInfo = Word32
    type AttrLabel LogAttrIsWordEndFieldInfo = "is_word_end"
    type AttrOrigin LogAttrIsWordEndFieldInfo = LogAttr
    attrGet _ = getLogAttrIsWordEnd
    attrSet _ = setLogAttrIsWordEnd
    attrConstruct = undefined
    attrClear _ = undefined

logAttr_isWordEnd :: AttrLabelProxy "isWordEnd"
logAttr_isWordEnd = AttrLabelProxy

#endif


{- |
Get the value of the “@is_sentence_boundary@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' logAttr #isSentenceBoundary
@
-}
getLogAttrIsSentenceBoundary :: MonadIO m => LogAttr -> m Word32
getLogAttrIsSentenceBoundary s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 28) :: IO Word32
    return val

{- |
Set the value of the “@is_sentence_boundary@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' logAttr [ #isSentenceBoundary 'Data.GI.Base.Attributes.:=' value ]
@
-}
setLogAttrIsSentenceBoundary :: MonadIO m => LogAttr -> Word32 -> m ()
setLogAttrIsSentenceBoundary s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 28) (val :: Word32)

#if ENABLE_OVERLOADING
data LogAttrIsSentenceBoundaryFieldInfo
instance AttrInfo LogAttrIsSentenceBoundaryFieldInfo where
    type AttrAllowedOps LogAttrIsSentenceBoundaryFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint LogAttrIsSentenceBoundaryFieldInfo = (~) Word32
    type AttrBaseTypeConstraint LogAttrIsSentenceBoundaryFieldInfo = (~) LogAttr
    type AttrGetType LogAttrIsSentenceBoundaryFieldInfo = Word32
    type AttrLabel LogAttrIsSentenceBoundaryFieldInfo = "is_sentence_boundary"
    type AttrOrigin LogAttrIsSentenceBoundaryFieldInfo = LogAttr
    attrGet _ = getLogAttrIsSentenceBoundary
    attrSet _ = setLogAttrIsSentenceBoundary
    attrConstruct = undefined
    attrClear _ = undefined

logAttr_isSentenceBoundary :: AttrLabelProxy "isSentenceBoundary"
logAttr_isSentenceBoundary = AttrLabelProxy

#endif


{- |
Get the value of the “@is_sentence_start@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' logAttr #isSentenceStart
@
-}
getLogAttrIsSentenceStart :: MonadIO m => LogAttr -> m Word32
getLogAttrIsSentenceStart s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 32) :: IO Word32
    return val

{- |
Set the value of the “@is_sentence_start@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' logAttr [ #isSentenceStart 'Data.GI.Base.Attributes.:=' value ]
@
-}
setLogAttrIsSentenceStart :: MonadIO m => LogAttr -> Word32 -> m ()
setLogAttrIsSentenceStart s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 32) (val :: Word32)

#if ENABLE_OVERLOADING
data LogAttrIsSentenceStartFieldInfo
instance AttrInfo LogAttrIsSentenceStartFieldInfo where
    type AttrAllowedOps LogAttrIsSentenceStartFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint LogAttrIsSentenceStartFieldInfo = (~) Word32
    type AttrBaseTypeConstraint LogAttrIsSentenceStartFieldInfo = (~) LogAttr
    type AttrGetType LogAttrIsSentenceStartFieldInfo = Word32
    type AttrLabel LogAttrIsSentenceStartFieldInfo = "is_sentence_start"
    type AttrOrigin LogAttrIsSentenceStartFieldInfo = LogAttr
    attrGet _ = getLogAttrIsSentenceStart
    attrSet _ = setLogAttrIsSentenceStart
    attrConstruct = undefined
    attrClear _ = undefined

logAttr_isSentenceStart :: AttrLabelProxy "isSentenceStart"
logAttr_isSentenceStart = AttrLabelProxy

#endif


{- |
Get the value of the “@is_sentence_end@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' logAttr #isSentenceEnd
@
-}
getLogAttrIsSentenceEnd :: MonadIO m => LogAttr -> m Word32
getLogAttrIsSentenceEnd s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 36) :: IO Word32
    return val

{- |
Set the value of the “@is_sentence_end@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' logAttr [ #isSentenceEnd 'Data.GI.Base.Attributes.:=' value ]
@
-}
setLogAttrIsSentenceEnd :: MonadIO m => LogAttr -> Word32 -> m ()
setLogAttrIsSentenceEnd s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 36) (val :: Word32)

#if ENABLE_OVERLOADING
data LogAttrIsSentenceEndFieldInfo
instance AttrInfo LogAttrIsSentenceEndFieldInfo where
    type AttrAllowedOps LogAttrIsSentenceEndFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint LogAttrIsSentenceEndFieldInfo = (~) Word32
    type AttrBaseTypeConstraint LogAttrIsSentenceEndFieldInfo = (~) LogAttr
    type AttrGetType LogAttrIsSentenceEndFieldInfo = Word32
    type AttrLabel LogAttrIsSentenceEndFieldInfo = "is_sentence_end"
    type AttrOrigin LogAttrIsSentenceEndFieldInfo = LogAttr
    attrGet _ = getLogAttrIsSentenceEnd
    attrSet _ = setLogAttrIsSentenceEnd
    attrConstruct = undefined
    attrClear _ = undefined

logAttr_isSentenceEnd :: AttrLabelProxy "isSentenceEnd"
logAttr_isSentenceEnd = AttrLabelProxy

#endif


{- |
Get the value of the “@backspace_deletes_character@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' logAttr #backspaceDeletesCharacter
@
-}
getLogAttrBackspaceDeletesCharacter :: MonadIO m => LogAttr -> m Word32
getLogAttrBackspaceDeletesCharacter s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 40) :: IO Word32
    return val

{- |
Set the value of the “@backspace_deletes_character@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' logAttr [ #backspaceDeletesCharacter 'Data.GI.Base.Attributes.:=' value ]
@
-}
setLogAttrBackspaceDeletesCharacter :: MonadIO m => LogAttr -> Word32 -> m ()
setLogAttrBackspaceDeletesCharacter s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 40) (val :: Word32)

#if ENABLE_OVERLOADING
data LogAttrBackspaceDeletesCharacterFieldInfo
instance AttrInfo LogAttrBackspaceDeletesCharacterFieldInfo where
    type AttrAllowedOps LogAttrBackspaceDeletesCharacterFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint LogAttrBackspaceDeletesCharacterFieldInfo = (~) Word32
    type AttrBaseTypeConstraint LogAttrBackspaceDeletesCharacterFieldInfo = (~) LogAttr
    type AttrGetType LogAttrBackspaceDeletesCharacterFieldInfo = Word32
    type AttrLabel LogAttrBackspaceDeletesCharacterFieldInfo = "backspace_deletes_character"
    type AttrOrigin LogAttrBackspaceDeletesCharacterFieldInfo = LogAttr
    attrGet _ = getLogAttrBackspaceDeletesCharacter
    attrSet _ = setLogAttrBackspaceDeletesCharacter
    attrConstruct = undefined
    attrClear _ = undefined

logAttr_backspaceDeletesCharacter :: AttrLabelProxy "backspaceDeletesCharacter"
logAttr_backspaceDeletesCharacter = AttrLabelProxy

#endif


{- |
Get the value of the “@is_expandable_space@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' logAttr #isExpandableSpace
@
-}
getLogAttrIsExpandableSpace :: MonadIO m => LogAttr -> m Word32
getLogAttrIsExpandableSpace s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 44) :: IO Word32
    return val

{- |
Set the value of the “@is_expandable_space@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' logAttr [ #isExpandableSpace 'Data.GI.Base.Attributes.:=' value ]
@
-}
setLogAttrIsExpandableSpace :: MonadIO m => LogAttr -> Word32 -> m ()
setLogAttrIsExpandableSpace s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 44) (val :: Word32)

#if ENABLE_OVERLOADING
data LogAttrIsExpandableSpaceFieldInfo
instance AttrInfo LogAttrIsExpandableSpaceFieldInfo where
    type AttrAllowedOps LogAttrIsExpandableSpaceFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint LogAttrIsExpandableSpaceFieldInfo = (~) Word32
    type AttrBaseTypeConstraint LogAttrIsExpandableSpaceFieldInfo = (~) LogAttr
    type AttrGetType LogAttrIsExpandableSpaceFieldInfo = Word32
    type AttrLabel LogAttrIsExpandableSpaceFieldInfo = "is_expandable_space"
    type AttrOrigin LogAttrIsExpandableSpaceFieldInfo = LogAttr
    attrGet _ = getLogAttrIsExpandableSpace
    attrSet _ = setLogAttrIsExpandableSpace
    attrConstruct = undefined
    attrClear _ = undefined

logAttr_isExpandableSpace :: AttrLabelProxy "isExpandableSpace"
logAttr_isExpandableSpace = AttrLabelProxy

#endif


{- |
Get the value of the “@is_word_boundary@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' logAttr #isWordBoundary
@
-}
getLogAttrIsWordBoundary :: MonadIO m => LogAttr -> m Word32
getLogAttrIsWordBoundary s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 48) :: IO Word32
    return val

{- |
Set the value of the “@is_word_boundary@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' logAttr [ #isWordBoundary 'Data.GI.Base.Attributes.:=' value ]
@
-}
setLogAttrIsWordBoundary :: MonadIO m => LogAttr -> Word32 -> m ()
setLogAttrIsWordBoundary s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 48) (val :: Word32)

#if ENABLE_OVERLOADING
data LogAttrIsWordBoundaryFieldInfo
instance AttrInfo LogAttrIsWordBoundaryFieldInfo where
    type AttrAllowedOps LogAttrIsWordBoundaryFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint LogAttrIsWordBoundaryFieldInfo = (~) Word32
    type AttrBaseTypeConstraint LogAttrIsWordBoundaryFieldInfo = (~) LogAttr
    type AttrGetType LogAttrIsWordBoundaryFieldInfo = Word32
    type AttrLabel LogAttrIsWordBoundaryFieldInfo = "is_word_boundary"
    type AttrOrigin LogAttrIsWordBoundaryFieldInfo = LogAttr
    attrGet _ = getLogAttrIsWordBoundary
    attrSet _ = setLogAttrIsWordBoundary
    attrConstruct = undefined
    attrClear _ = undefined

logAttr_isWordBoundary :: AttrLabelProxy "isWordBoundary"
logAttr_isWordBoundary = AttrLabelProxy

#endif



#if ENABLE_OVERLOADING
instance O.HasAttributeList LogAttr
type instance O.AttributeList LogAttr = LogAttrAttributeList
type LogAttrAttributeList = ('[ '("isLineBreak", LogAttrIsLineBreakFieldInfo), '("isMandatoryBreak", LogAttrIsMandatoryBreakFieldInfo), '("isCharBreak", LogAttrIsCharBreakFieldInfo), '("isWhite", LogAttrIsWhiteFieldInfo), '("isCursorPosition", LogAttrIsCursorPositionFieldInfo), '("isWordStart", LogAttrIsWordStartFieldInfo), '("isWordEnd", LogAttrIsWordEndFieldInfo), '("isSentenceBoundary", LogAttrIsSentenceBoundaryFieldInfo), '("isSentenceStart", LogAttrIsSentenceStartFieldInfo), '("isSentenceEnd", LogAttrIsSentenceEndFieldInfo), '("backspaceDeletesCharacter", LogAttrBackspaceDeletesCharacterFieldInfo), '("isExpandableSpace", LogAttrIsExpandableSpaceFieldInfo), '("isWordBoundary", LogAttrIsWordBoundaryFieldInfo)] :: [(Symbol, *)])
#endif

#if ENABLE_OVERLOADING
type family ResolveLogAttrMethod (t :: Symbol) (o :: *) :: * where
    ResolveLogAttrMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveLogAttrMethod t LogAttr, O.MethodInfo info LogAttr p) => OL.IsLabel t (LogAttr -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#else
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif

#endif