{- |
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 #PangoLogAttr structure stores information
about the attributes of a single character.
-}

module GI.Pango.Structs.LogAttr
    ( 

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


 -- * Properties
-- ** BackspaceDeletesCharacter
    logAttrReadBackspaceDeletesCharacter    ,


-- ** IsCharBreak
    logAttrReadIsCharBreak                  ,


-- ** IsCursorPosition
    logAttrReadIsCursorPosition             ,


-- ** IsExpandableSpace
    logAttrReadIsExpandableSpace            ,


-- ** IsLineBreak
    logAttrReadIsLineBreak                  ,


-- ** IsMandatoryBreak
    logAttrReadIsMandatoryBreak             ,


-- ** IsSentenceBoundary
    logAttrReadIsSentenceBoundary           ,


-- ** IsSentenceEnd
    logAttrReadIsSentenceEnd                ,


-- ** IsSentenceStart
    logAttrReadIsSentenceStart              ,


-- ** IsWhite
    logAttrReadIsWhite                      ,


-- ** IsWordBoundary
    logAttrReadIsWordBoundary               ,


-- ** IsWordEnd
    logAttrReadIsWordEnd                    ,


-- ** IsWordStart
    logAttrReadIsWordStart                  ,




    ) where

import Prelude ()
import Data.GI.Base.ShortPrelude

import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map

import GI.Pango.Types
import GI.Pango.Callbacks

newtype LogAttr = LogAttr (ForeignPtr LogAttr)
-- | Construct a `LogAttr` struct initialized to zero.
newZeroLogAttr :: MonadIO m => m LogAttr
newZeroLogAttr = liftIO $ callocBytes 52 >>= wrapPtr LogAttr

noLogAttr :: Maybe LogAttr
noLogAttr = Nothing

logAttrReadIsLineBreak :: LogAttr -> IO Word32
logAttrReadIsLineBreak s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO Word32
    return val

logAttrReadIsMandatoryBreak :: LogAttr -> IO Word32
logAttrReadIsMandatoryBreak s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 4) :: IO Word32
    return val

logAttrReadIsCharBreak :: LogAttr -> IO Word32
logAttrReadIsCharBreak s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 8) :: IO Word32
    return val

logAttrReadIsWhite :: LogAttr -> IO Word32
logAttrReadIsWhite s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 12) :: IO Word32
    return val

logAttrReadIsCursorPosition :: LogAttr -> IO Word32
logAttrReadIsCursorPosition s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 16) :: IO Word32
    return val

logAttrReadIsWordStart :: LogAttr -> IO Word32
logAttrReadIsWordStart s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 20) :: IO Word32
    return val

logAttrReadIsWordEnd :: LogAttr -> IO Word32
logAttrReadIsWordEnd s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 24) :: IO Word32
    return val

logAttrReadIsSentenceBoundary :: LogAttr -> IO Word32
logAttrReadIsSentenceBoundary s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 28) :: IO Word32
    return val

logAttrReadIsSentenceStart :: LogAttr -> IO Word32
logAttrReadIsSentenceStart s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 32) :: IO Word32
    return val

logAttrReadIsSentenceEnd :: LogAttr -> IO Word32
logAttrReadIsSentenceEnd s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 36) :: IO Word32
    return val

logAttrReadBackspaceDeletesCharacter :: LogAttr -> IO Word32
logAttrReadBackspaceDeletesCharacter s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 40) :: IO Word32
    return val

logAttrReadIsExpandableSpace :: LogAttr -> IO Word32
logAttrReadIsExpandableSpace s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 44) :: IO Word32
    return val

logAttrReadIsWordBoundary :: LogAttr -> IO Word32
logAttrReadIsWordBoundary s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 48) :: IO Word32
    return val

type family ResolveLogAttrMethod (t :: Symbol) (o :: *) :: * where
    ResolveLogAttrMethod l o = MethodResolutionFailed l o

instance (info ~ ResolveLogAttrMethod t LogAttr, MethodInfo info LogAttr p) => IsLabelProxy t (LogAttr -> p) where
    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)

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