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

/No description available in the introspection data./
-}

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

module GI.WebKit2.Objects.BackForwardList
    ( 

-- * Exported types
    BackForwardList(..)                     ,
    IsBackForwardList                       ,
    toBackForwardList                       ,
    noBackForwardList                       ,


 -- * Methods
-- ** getBackItem #method:getBackItem#

#if ENABLE_OVERLOADING
    BackForwardListGetBackItemMethodInfo    ,
#endif
    backForwardListGetBackItem              ,


-- ** getBackList #method:getBackList#

#if ENABLE_OVERLOADING
    BackForwardListGetBackListMethodInfo    ,
#endif
    backForwardListGetBackList              ,


-- ** getBackListWithLimit #method:getBackListWithLimit#

#if ENABLE_OVERLOADING
    BackForwardListGetBackListWithLimitMethodInfo,
#endif
    backForwardListGetBackListWithLimit     ,


-- ** getCurrentItem #method:getCurrentItem#

#if ENABLE_OVERLOADING
    BackForwardListGetCurrentItemMethodInfo ,
#endif
    backForwardListGetCurrentItem           ,


-- ** getForwardItem #method:getForwardItem#

#if ENABLE_OVERLOADING
    BackForwardListGetForwardItemMethodInfo ,
#endif
    backForwardListGetForwardItem           ,


-- ** getForwardList #method:getForwardList#

#if ENABLE_OVERLOADING
    BackForwardListGetForwardListMethodInfo ,
#endif
    backForwardListGetForwardList           ,


-- ** getForwardListWithLimit #method:getForwardListWithLimit#

#if ENABLE_OVERLOADING
    BackForwardListGetForwardListWithLimitMethodInfo,
#endif
    backForwardListGetForwardListWithLimit  ,


-- ** getLength #method:getLength#

#if ENABLE_OVERLOADING
    BackForwardListGetLengthMethodInfo      ,
#endif
    backForwardListGetLength                ,


-- ** getNthItem #method:getNthItem#

#if ENABLE_OVERLOADING
    BackForwardListGetNthItemMethodInfo     ,
#endif
    backForwardListGetNthItem               ,




 -- * Signals
-- ** changed #signal:changed#

    BackForwardListChangedCallback          ,
#if ENABLE_OVERLOADING
    BackForwardListChangedSignalInfo        ,
#endif
    C_BackForwardListChangedCallback        ,
    afterBackForwardListChanged             ,
    genClosure_BackForwardListChanged       ,
    mk_BackForwardListChangedCallback       ,
    noBackForwardListChangedCallback        ,
    onBackForwardListChanged                ,
    wrap_BackForwardListChangedCallback     ,




    ) 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

import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.WebKit2.Objects.BackForwardListItem as WebKit2.BackForwardListItem

-- | Memory-managed wrapper type.
newtype BackForwardList = BackForwardList (ManagedPtr BackForwardList)
foreign import ccall "webkit_back_forward_list_get_type"
    c_webkit_back_forward_list_get_type :: IO GType

instance GObject BackForwardList where
    gobjectType = c_webkit_back_forward_list_get_type
    

-- | Type class for types which can be safely cast to `BackForwardList`, for instance with `toBackForwardList`.
class (GObject o, O.IsDescendantOf BackForwardList o) => IsBackForwardList o
instance (GObject o, O.IsDescendantOf BackForwardList o) => IsBackForwardList o

instance O.HasParentTypes BackForwardList
type instance O.ParentTypes BackForwardList = '[GObject.Object.Object]

-- | Cast to `BackForwardList`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toBackForwardList :: (MonadIO m, IsBackForwardList o) => o -> m BackForwardList
toBackForwardList = liftIO . unsafeCastTo BackForwardList

-- | A convenience alias for `Nothing` :: `Maybe` `BackForwardList`.
noBackForwardList :: Maybe BackForwardList
noBackForwardList = Nothing

#if ENABLE_OVERLOADING
type family ResolveBackForwardListMethod (t :: Symbol) (o :: *) :: * where
    ResolveBackForwardListMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveBackForwardListMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveBackForwardListMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveBackForwardListMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveBackForwardListMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveBackForwardListMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveBackForwardListMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveBackForwardListMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveBackForwardListMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveBackForwardListMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveBackForwardListMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveBackForwardListMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveBackForwardListMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveBackForwardListMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveBackForwardListMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveBackForwardListMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveBackForwardListMethod "getBackItem" o = BackForwardListGetBackItemMethodInfo
    ResolveBackForwardListMethod "getBackList" o = BackForwardListGetBackListMethodInfo
    ResolveBackForwardListMethod "getBackListWithLimit" o = BackForwardListGetBackListWithLimitMethodInfo
    ResolveBackForwardListMethod "getCurrentItem" o = BackForwardListGetCurrentItemMethodInfo
    ResolveBackForwardListMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveBackForwardListMethod "getForwardItem" o = BackForwardListGetForwardItemMethodInfo
    ResolveBackForwardListMethod "getForwardList" o = BackForwardListGetForwardListMethodInfo
    ResolveBackForwardListMethod "getForwardListWithLimit" o = BackForwardListGetForwardListWithLimitMethodInfo
    ResolveBackForwardListMethod "getLength" o = BackForwardListGetLengthMethodInfo
    ResolveBackForwardListMethod "getNthItem" o = BackForwardListGetNthItemMethodInfo
    ResolveBackForwardListMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveBackForwardListMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveBackForwardListMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveBackForwardListMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveBackForwardListMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveBackForwardListMethod t BackForwardList, O.MethodInfo info BackForwardList p) => OL.IsLabel t (BackForwardList -> 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

-- signal BackForwardList::changed
{- |
This signal is emitted when /@backForwardList@/ changes. This happens
when the current item is updated, a new item is added or one or more
items are removed. Note that both /@itemAdded@/ and /@itemsRemoved@/ can
'Nothing' when only the current item is updated. Items are only removed
when the list is cleared or the maximum items limit is reached.
-}
type BackForwardListChangedCallback =
    Maybe WebKit2.BackForwardListItem.BackForwardListItem
    {- ^ /@itemAdded@/: the 'GI.WebKit2.Objects.BackForwardListItem.BackForwardListItem' added or 'Nothing' -}
    -> Ptr ()
    {- ^ /@itemsRemoved@/: a 'GI.GLib.Structs.List.List' of 'GI.WebKit2.Objects.BackForwardListItem.BackForwardListItem'\<!-- -->s -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `BackForwardListChangedCallback`@.
noBackForwardListChangedCallback :: Maybe BackForwardListChangedCallback
noBackForwardListChangedCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_BackForwardListChangedCallback =
    Ptr () ->                               -- object
    Ptr WebKit2.BackForwardListItem.BackForwardListItem ->
    Ptr () ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_BackForwardListChangedCallback`.
foreign import ccall "wrapper"
    mk_BackForwardListChangedCallback :: C_BackForwardListChangedCallback -> IO (FunPtr C_BackForwardListChangedCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_BackForwardListChanged :: MonadIO m => BackForwardListChangedCallback -> m (GClosure C_BackForwardListChangedCallback)
genClosure_BackForwardListChanged cb = liftIO $ do
    let cb' = wrap_BackForwardListChangedCallback cb
    mk_BackForwardListChangedCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `BackForwardListChangedCallback` into a `C_BackForwardListChangedCallback`.
wrap_BackForwardListChangedCallback ::
    BackForwardListChangedCallback ->
    C_BackForwardListChangedCallback
wrap_BackForwardListChangedCallback _cb _ itemAdded itemsRemoved _ = do
    maybeItemAdded <-
        if itemAdded == nullPtr
        then return Nothing
        else do
            itemAdded' <- (newObject WebKit2.BackForwardListItem.BackForwardListItem) itemAdded
            return $ Just itemAdded'
    _cb  maybeItemAdded itemsRemoved


{- |
Connect a signal handler for the “@changed@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' backForwardList #changed callback
@
-}
onBackForwardListChanged :: (IsBackForwardList a, MonadIO m) => a -> BackForwardListChangedCallback -> m SignalHandlerId
onBackForwardListChanged obj cb = liftIO $ do
    let cb' = wrap_BackForwardListChangedCallback cb
    cb'' <- mk_BackForwardListChangedCallback cb'
    connectSignalFunPtr obj "changed" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@changed@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' backForwardList #changed callback
@
-}
afterBackForwardListChanged :: (IsBackForwardList a, MonadIO m) => a -> BackForwardListChangedCallback -> m SignalHandlerId
afterBackForwardListChanged obj cb = liftIO $ do
    let cb' = wrap_BackForwardListChangedCallback cb
    cb'' <- mk_BackForwardListChangedCallback cb'
    connectSignalFunPtr obj "changed" cb'' SignalConnectAfter


#if ENABLE_OVERLOADING
instance O.HasAttributeList BackForwardList
type instance O.AttributeList BackForwardList = BackForwardListAttributeList
type BackForwardListAttributeList = ('[ ] :: [(Symbol, *)])
#endif

#if ENABLE_OVERLOADING
#endif

#if ENABLE_OVERLOADING
data BackForwardListChangedSignalInfo
instance SignalInfo BackForwardListChangedSignalInfo where
    type HaskellCallbackType BackForwardListChangedSignalInfo = BackForwardListChangedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_BackForwardListChangedCallback cb
        cb'' <- mk_BackForwardListChangedCallback cb'
        connectSignalFunPtr obj "changed" cb'' connectMode

type instance O.SignalList BackForwardList = BackForwardListSignalList
type BackForwardListSignalList = ('[ '("changed", BackForwardListChangedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

#endif

-- method BackForwardList::get_back_item
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "back_forward_list", argType = TInterface (Name {namespace = "WebKit2", name = "BackForwardList"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitBackForwardList", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "BackForwardListItem"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_back_forward_list_get_back_item" webkit_back_forward_list_get_back_item :: 
    Ptr BackForwardList ->                  -- back_forward_list : TInterface (Name {namespace = "WebKit2", name = "BackForwardList"})
    IO (Ptr WebKit2.BackForwardListItem.BackForwardListItem)

{- |
Returns the item that precedes the current item.
-}
backForwardListGetBackItem ::
    (B.CallStack.HasCallStack, MonadIO m, IsBackForwardList a) =>
    a
    {- ^ /@backForwardList@/: a 'GI.WebKit2.Objects.BackForwardList.BackForwardList' -}
    -> m (Maybe WebKit2.BackForwardListItem.BackForwardListItem)
    {- ^ __Returns:__ the 'GI.WebKit2.Objects.BackForwardListItem.BackForwardListItem'
   preceding the current item or 'Nothing'. -}
backForwardListGetBackItem backForwardList = liftIO $ do
    backForwardList' <- unsafeManagedPtrCastPtr backForwardList
    result <- webkit_back_forward_list_get_back_item backForwardList'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (newObject WebKit2.BackForwardListItem.BackForwardListItem) result'
        return result''
    touchManagedPtr backForwardList
    return maybeResult

#if ENABLE_OVERLOADING
data BackForwardListGetBackItemMethodInfo
instance (signature ~ (m (Maybe WebKit2.BackForwardListItem.BackForwardListItem)), MonadIO m, IsBackForwardList a) => O.MethodInfo BackForwardListGetBackItemMethodInfo a signature where
    overloadedMethod _ = backForwardListGetBackItem

#endif

-- method BackForwardList::get_back_list
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "back_forward_list", argType = TInterface (Name {namespace = "WebKit2", name = "BackForwardList"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitBackForwardList", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TGList (TInterface (Name {namespace = "WebKit2", name = "BackForwardListItem"})))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_back_forward_list_get_back_list" webkit_back_forward_list_get_back_list :: 
    Ptr BackForwardList ->                  -- back_forward_list : TInterface (Name {namespace = "WebKit2", name = "BackForwardList"})
    IO (Ptr (GList (Ptr WebKit2.BackForwardListItem.BackForwardListItem)))

{- |
/No description available in the introspection data./
-}
backForwardListGetBackList ::
    (B.CallStack.HasCallStack, MonadIO m, IsBackForwardList a) =>
    a
    {- ^ /@backForwardList@/: a 'GI.WebKit2.Objects.BackForwardList.BackForwardList' -}
    -> m [WebKit2.BackForwardListItem.BackForwardListItem]
    {- ^ __Returns:__ a 'GI.GLib.Structs.List.List' of
   items preceding the current item. -}
backForwardListGetBackList backForwardList = liftIO $ do
    backForwardList' <- unsafeManagedPtrCastPtr backForwardList
    result <- webkit_back_forward_list_get_back_list backForwardList'
    result' <- unpackGList result
    result'' <- mapM (newObject WebKit2.BackForwardListItem.BackForwardListItem) result'
    g_list_free result
    touchManagedPtr backForwardList
    return result''

#if ENABLE_OVERLOADING
data BackForwardListGetBackListMethodInfo
instance (signature ~ (m [WebKit2.BackForwardListItem.BackForwardListItem]), MonadIO m, IsBackForwardList a) => O.MethodInfo BackForwardListGetBackListMethodInfo a signature where
    overloadedMethod _ = backForwardListGetBackList

#endif

-- method BackForwardList::get_back_list_with_limit
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "back_forward_list", argType = TInterface (Name {namespace = "WebKit2", name = "BackForwardList"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitBackForwardList", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "limit", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of items to retrieve", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TGList (TInterface (Name {namespace = "WebKit2", name = "BackForwardListItem"})))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_back_forward_list_get_back_list_with_limit" webkit_back_forward_list_get_back_list_with_limit :: 
    Ptr BackForwardList ->                  -- back_forward_list : TInterface (Name {namespace = "WebKit2", name = "BackForwardList"})
    Word32 ->                               -- limit : TBasicType TUInt
    IO (Ptr (GList (Ptr WebKit2.BackForwardListItem.BackForwardListItem)))

{- |
/No description available in the introspection data./
-}
backForwardListGetBackListWithLimit ::
    (B.CallStack.HasCallStack, MonadIO m, IsBackForwardList a) =>
    a
    {- ^ /@backForwardList@/: a 'GI.WebKit2.Objects.BackForwardList.BackForwardList' -}
    -> Word32
    {- ^ /@limit@/: the number of items to retrieve -}
    -> m [WebKit2.BackForwardListItem.BackForwardListItem]
    {- ^ __Returns:__ a 'GI.GLib.Structs.List.List' of
   items preceding the current item limited by /@limit@/. -}
backForwardListGetBackListWithLimit backForwardList limit = liftIO $ do
    backForwardList' <- unsafeManagedPtrCastPtr backForwardList
    result <- webkit_back_forward_list_get_back_list_with_limit backForwardList' limit
    result' <- unpackGList result
    result'' <- mapM (newObject WebKit2.BackForwardListItem.BackForwardListItem) result'
    g_list_free result
    touchManagedPtr backForwardList
    return result''

#if ENABLE_OVERLOADING
data BackForwardListGetBackListWithLimitMethodInfo
instance (signature ~ (Word32 -> m [WebKit2.BackForwardListItem.BackForwardListItem]), MonadIO m, IsBackForwardList a) => O.MethodInfo BackForwardListGetBackListWithLimitMethodInfo a signature where
    overloadedMethod _ = backForwardListGetBackListWithLimit

#endif

-- method BackForwardList::get_current_item
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "back_forward_list", argType = TInterface (Name {namespace = "WebKit2", name = "BackForwardList"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitBackForwardList", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "BackForwardListItem"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_back_forward_list_get_current_item" webkit_back_forward_list_get_current_item :: 
    Ptr BackForwardList ->                  -- back_forward_list : TInterface (Name {namespace = "WebKit2", name = "BackForwardList"})
    IO (Ptr WebKit2.BackForwardListItem.BackForwardListItem)

{- |
Returns the current item in /@backForwardList@/.
-}
backForwardListGetCurrentItem ::
    (B.CallStack.HasCallStack, MonadIO m, IsBackForwardList a) =>
    a
    {- ^ /@backForwardList@/: a 'GI.WebKit2.Objects.BackForwardList.BackForwardList' -}
    -> m (Maybe WebKit2.BackForwardListItem.BackForwardListItem)
    {- ^ __Returns:__ a 'GI.WebKit2.Objects.BackForwardListItem.BackForwardListItem'
   or 'Nothing' if /@backForwardList@/ is empty. -}
backForwardListGetCurrentItem backForwardList = liftIO $ do
    backForwardList' <- unsafeManagedPtrCastPtr backForwardList
    result <- webkit_back_forward_list_get_current_item backForwardList'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (newObject WebKit2.BackForwardListItem.BackForwardListItem) result'
        return result''
    touchManagedPtr backForwardList
    return maybeResult

#if ENABLE_OVERLOADING
data BackForwardListGetCurrentItemMethodInfo
instance (signature ~ (m (Maybe WebKit2.BackForwardListItem.BackForwardListItem)), MonadIO m, IsBackForwardList a) => O.MethodInfo BackForwardListGetCurrentItemMethodInfo a signature where
    overloadedMethod _ = backForwardListGetCurrentItem

#endif

-- method BackForwardList::get_forward_item
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "back_forward_list", argType = TInterface (Name {namespace = "WebKit2", name = "BackForwardList"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitBackForwardList", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "BackForwardListItem"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_back_forward_list_get_forward_item" webkit_back_forward_list_get_forward_item :: 
    Ptr BackForwardList ->                  -- back_forward_list : TInterface (Name {namespace = "WebKit2", name = "BackForwardList"})
    IO (Ptr WebKit2.BackForwardListItem.BackForwardListItem)

{- |
Returns the item that follows the current item.
-}
backForwardListGetForwardItem ::
    (B.CallStack.HasCallStack, MonadIO m, IsBackForwardList a) =>
    a
    {- ^ /@backForwardList@/: a 'GI.WebKit2.Objects.BackForwardList.BackForwardList' -}
    -> m (Maybe WebKit2.BackForwardListItem.BackForwardListItem)
    {- ^ __Returns:__ the 'GI.WebKit2.Objects.BackForwardListItem.BackForwardListItem'
   following the current item or 'Nothing'. -}
backForwardListGetForwardItem backForwardList = liftIO $ do
    backForwardList' <- unsafeManagedPtrCastPtr backForwardList
    result <- webkit_back_forward_list_get_forward_item backForwardList'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (newObject WebKit2.BackForwardListItem.BackForwardListItem) result'
        return result''
    touchManagedPtr backForwardList
    return maybeResult

#if ENABLE_OVERLOADING
data BackForwardListGetForwardItemMethodInfo
instance (signature ~ (m (Maybe WebKit2.BackForwardListItem.BackForwardListItem)), MonadIO m, IsBackForwardList a) => O.MethodInfo BackForwardListGetForwardItemMethodInfo a signature where
    overloadedMethod _ = backForwardListGetForwardItem

#endif

-- method BackForwardList::get_forward_list
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "back_forward_list", argType = TInterface (Name {namespace = "WebKit2", name = "BackForwardList"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitBackForwardList", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TGList (TInterface (Name {namespace = "WebKit2", name = "BackForwardListItem"})))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_back_forward_list_get_forward_list" webkit_back_forward_list_get_forward_list :: 
    Ptr BackForwardList ->                  -- back_forward_list : TInterface (Name {namespace = "WebKit2", name = "BackForwardList"})
    IO (Ptr (GList (Ptr WebKit2.BackForwardListItem.BackForwardListItem)))

{- |
/No description available in the introspection data./
-}
backForwardListGetForwardList ::
    (B.CallStack.HasCallStack, MonadIO m, IsBackForwardList a) =>
    a
    {- ^ /@backForwardList@/: a 'GI.WebKit2.Objects.BackForwardList.BackForwardList' -}
    -> m [WebKit2.BackForwardListItem.BackForwardListItem]
    {- ^ __Returns:__ a 'GI.GLib.Structs.List.List' of
   items following the current item. -}
backForwardListGetForwardList backForwardList = liftIO $ do
    backForwardList' <- unsafeManagedPtrCastPtr backForwardList
    result <- webkit_back_forward_list_get_forward_list backForwardList'
    result' <- unpackGList result
    result'' <- mapM (newObject WebKit2.BackForwardListItem.BackForwardListItem) result'
    g_list_free result
    touchManagedPtr backForwardList
    return result''

#if ENABLE_OVERLOADING
data BackForwardListGetForwardListMethodInfo
instance (signature ~ (m [WebKit2.BackForwardListItem.BackForwardListItem]), MonadIO m, IsBackForwardList a) => O.MethodInfo BackForwardListGetForwardListMethodInfo a signature where
    overloadedMethod _ = backForwardListGetForwardList

#endif

-- method BackForwardList::get_forward_list_with_limit
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "back_forward_list", argType = TInterface (Name {namespace = "WebKit2", name = "BackForwardList"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitBackForwardList", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "limit", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of items to retrieve", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TGList (TInterface (Name {namespace = "WebKit2", name = "BackForwardListItem"})))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_back_forward_list_get_forward_list_with_limit" webkit_back_forward_list_get_forward_list_with_limit :: 
    Ptr BackForwardList ->                  -- back_forward_list : TInterface (Name {namespace = "WebKit2", name = "BackForwardList"})
    Word32 ->                               -- limit : TBasicType TUInt
    IO (Ptr (GList (Ptr WebKit2.BackForwardListItem.BackForwardListItem)))

{- |
/No description available in the introspection data./
-}
backForwardListGetForwardListWithLimit ::
    (B.CallStack.HasCallStack, MonadIO m, IsBackForwardList a) =>
    a
    {- ^ /@backForwardList@/: a 'GI.WebKit2.Objects.BackForwardList.BackForwardList' -}
    -> Word32
    {- ^ /@limit@/: the number of items to retrieve -}
    -> m [WebKit2.BackForwardListItem.BackForwardListItem]
    {- ^ __Returns:__ a 'GI.GLib.Structs.List.List' of
   items following the current item limited by /@limit@/. -}
backForwardListGetForwardListWithLimit backForwardList limit = liftIO $ do
    backForwardList' <- unsafeManagedPtrCastPtr backForwardList
    result <- webkit_back_forward_list_get_forward_list_with_limit backForwardList' limit
    result' <- unpackGList result
    result'' <- mapM (newObject WebKit2.BackForwardListItem.BackForwardListItem) result'
    g_list_free result
    touchManagedPtr backForwardList
    return result''

#if ENABLE_OVERLOADING
data BackForwardListGetForwardListWithLimitMethodInfo
instance (signature ~ (Word32 -> m [WebKit2.BackForwardListItem.BackForwardListItem]), MonadIO m, IsBackForwardList a) => O.MethodInfo BackForwardListGetForwardListWithLimitMethodInfo a signature where
    overloadedMethod _ = backForwardListGetForwardListWithLimit

#endif

-- method BackForwardList::get_length
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "back_forward_list", argType = TInterface (Name {namespace = "WebKit2", name = "BackForwardList"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitBackForwardList", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUInt)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_back_forward_list_get_length" webkit_back_forward_list_get_length :: 
    Ptr BackForwardList ->                  -- back_forward_list : TInterface (Name {namespace = "WebKit2", name = "BackForwardList"})
    IO Word32

{- |
/No description available in the introspection data./
-}
backForwardListGetLength ::
    (B.CallStack.HasCallStack, MonadIO m, IsBackForwardList a) =>
    a
    {- ^ /@backForwardList@/: a 'GI.WebKit2.Objects.BackForwardList.BackForwardList' -}
    -> m Word32
    {- ^ __Returns:__ the length of /@backForwardList@/. -}
backForwardListGetLength backForwardList = liftIO $ do
    backForwardList' <- unsafeManagedPtrCastPtr backForwardList
    result <- webkit_back_forward_list_get_length backForwardList'
    touchManagedPtr backForwardList
    return result

#if ENABLE_OVERLOADING
data BackForwardListGetLengthMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsBackForwardList a) => O.MethodInfo BackForwardListGetLengthMethodInfo a signature where
    overloadedMethod _ = backForwardListGetLength

#endif

-- method BackForwardList::get_nth_item
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "back_forward_list", argType = TInterface (Name {namespace = "WebKit2", name = "BackForwardList"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitBackForwardList", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the index of the item", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "BackForwardListItem"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_back_forward_list_get_nth_item" webkit_back_forward_list_get_nth_item :: 
    Ptr BackForwardList ->                  -- back_forward_list : TInterface (Name {namespace = "WebKit2", name = "BackForwardList"})
    Int32 ->                                -- index : TBasicType TInt
    IO (Ptr WebKit2.BackForwardListItem.BackForwardListItem)

{- |
Returns the item at a given index relative to the current item.
-}
backForwardListGetNthItem ::
    (B.CallStack.HasCallStack, MonadIO m, IsBackForwardList a) =>
    a
    {- ^ /@backForwardList@/: a 'GI.WebKit2.Objects.BackForwardList.BackForwardList' -}
    -> Int32
    {- ^ /@index@/: the index of the item -}
    -> m (Maybe WebKit2.BackForwardListItem.BackForwardListItem)
    {- ^ __Returns:__ the 'GI.WebKit2.Objects.BackForwardListItem.BackForwardListItem'
   located at the specified index relative to the current item or 'Nothing'. -}
backForwardListGetNthItem backForwardList index = liftIO $ do
    backForwardList' <- unsafeManagedPtrCastPtr backForwardList
    result <- webkit_back_forward_list_get_nth_item backForwardList' index
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (newObject WebKit2.BackForwardListItem.BackForwardListItem) result'
        return result''
    touchManagedPtr backForwardList
    return maybeResult

#if ENABLE_OVERLOADING
data BackForwardListGetNthItemMethodInfo
instance (signature ~ (Int32 -> m (Maybe WebKit2.BackForwardListItem.BackForwardListItem)), MonadIO m, IsBackForwardList a) => O.MethodInfo BackForwardListGetNthItemMethodInfo a signature where
    overloadedMethod _ = backForwardListGetNthItem

#endif