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

module GI.Gtk.Structs.TableChild
    ( 

-- * Exported types
    TableChild(..)                          ,
    newZeroTableChild                       ,
    noTableChild                            ,


 -- * Properties
-- ** BottomAttach
    tableChildReadBottomAttach              ,


-- ** LeftAttach
    tableChildReadLeftAttach                ,


-- ** RightAttach
    tableChildReadRightAttach               ,


-- ** TopAttach
    tableChildReadTopAttach                 ,


-- ** Widget
    tableChildReadWidget                    ,


-- ** Xexpand
    tableChildReadXexpand                   ,


-- ** Xfill
    tableChildReadXfill                     ,


-- ** Xpadding
    tableChildReadXpadding                  ,


-- ** Xshrink
    tableChildReadXshrink                   ,


-- ** Yexpand
    tableChildReadYexpand                   ,


-- ** Yfill
    tableChildReadYfill                     ,


-- ** Ypadding
    tableChildReadYpadding                  ,


-- ** Yshrink
    tableChildReadYshrink                   ,




    ) 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.Gtk.Types
import GI.Gtk.Callbacks

newtype TableChild = TableChild (ForeignPtr TableChild)
-- | Construct a `TableChild` struct initialized to zero.
newZeroTableChild :: MonadIO m => m TableChild
newZeroTableChild = liftIO $ callocBytes 48 >>= wrapPtr TableChild

noTableChild :: Maybe TableChild
noTableChild = Nothing

tableChildReadWidget :: TableChild -> IO Widget
tableChildReadWidget s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO (Ptr Widget)
    val' <- (newObject Widget) val
    return val'

tableChildReadLeftAttach :: TableChild -> IO Word16
tableChildReadLeftAttach s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 8) :: IO Word16
    return val

tableChildReadRightAttach :: TableChild -> IO Word16
tableChildReadRightAttach s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 10) :: IO Word16
    return val

tableChildReadTopAttach :: TableChild -> IO Word16
tableChildReadTopAttach s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 12) :: IO Word16
    return val

tableChildReadBottomAttach :: TableChild -> IO Word16
tableChildReadBottomAttach s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 14) :: IO Word16
    return val

tableChildReadXpadding :: TableChild -> IO Word16
tableChildReadXpadding s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 16) :: IO Word16
    return val

tableChildReadYpadding :: TableChild -> IO Word16
tableChildReadYpadding s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 18) :: IO Word16
    return val

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

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

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

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

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

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

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

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

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