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

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

    #define ENABLE_OVERLOADING \
           (!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.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.Text as T
    import qualified Data.ByteString.Char8 as B
    import qualified Data.Map as Map
    import qualified Foreign.Ptr as FP

    -- | 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) => O.IsLabelProxy t (LogAttr -> p) where
        fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

    #if MIN_VERSION_base(4,9,0)
    instance (info ~ ResolveLogAttrMethod t LogAttr, O.MethodInfo info LogAttr p) => O.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

    #endif