{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- /No description available in the introspection data./

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

module GI.WebKit2.Objects.BackForwardList
    ( 

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


 -- * Methods
-- ** Overloaded methods #method:Overloaded methods#

#if defined(ENABLE_OVERLOADING)
    ResolveBackForwardListMethod            ,
#endif


-- ** getBackItem #method:getBackItem#

#if defined(ENABLE_OVERLOADING)
    BackForwardListGetBackItemMethodInfo    ,
#endif
    backForwardListGetBackItem              ,


-- ** getBackList #method:getBackList#

#if defined(ENABLE_OVERLOADING)
    BackForwardListGetBackListMethodInfo    ,
#endif
    backForwardListGetBackList              ,


-- ** getBackListWithLimit #method:getBackListWithLimit#

#if defined(ENABLE_OVERLOADING)
    BackForwardListGetBackListWithLimitMethodInfo,
#endif
    backForwardListGetBackListWithLimit     ,


-- ** getCurrentItem #method:getCurrentItem#

#if defined(ENABLE_OVERLOADING)
    BackForwardListGetCurrentItemMethodInfo ,
#endif
    backForwardListGetCurrentItem           ,


-- ** getForwardItem #method:getForwardItem#

#if defined(ENABLE_OVERLOADING)
    BackForwardListGetForwardItemMethodInfo ,
#endif
    backForwardListGetForwardItem           ,


-- ** getForwardList #method:getForwardList#

#if defined(ENABLE_OVERLOADING)
    BackForwardListGetForwardListMethodInfo ,
#endif
    backForwardListGetForwardList           ,


-- ** getForwardListWithLimit #method:getForwardListWithLimit#

#if defined(ENABLE_OVERLOADING)
    BackForwardListGetForwardListWithLimitMethodInfo,
#endif
    backForwardListGetForwardListWithLimit  ,


-- ** getLength #method:getLength#

#if defined(ENABLE_OVERLOADING)
    BackForwardListGetLengthMethodInfo      ,
#endif
    backForwardListGetLength                ,


-- ** getNthItem #method:getNthItem#

#if defined(ENABLE_OVERLOADING)
    BackForwardListGetNthItemMethodInfo     ,
#endif
    backForwardListGetNthItem               ,




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

    BackForwardListChangedCallback          ,
#if defined(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.GI.Base.Signals as B.Signals
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)
    deriving (BackForwardList -> BackForwardList -> Bool
(BackForwardList -> BackForwardList -> Bool)
-> (BackForwardList -> BackForwardList -> Bool)
-> Eq BackForwardList
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BackForwardList -> BackForwardList -> Bool
$c/= :: BackForwardList -> BackForwardList -> Bool
== :: BackForwardList -> BackForwardList -> Bool
$c== :: BackForwardList -> BackForwardList -> Bool
Eq)
foreign import ccall "webkit_back_forward_list_get_type"
    c_webkit_back_forward_list_get_type :: IO GType

instance GObject BackForwardList where
    gobjectType :: IO GType
gobjectType = IO GType
c_webkit_back_forward_list_get_type
    

-- | Convert 'BackForwardList' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue BackForwardList where
    toGValue :: BackForwardList -> IO GValue
toGValue o :: BackForwardList
o = do
        GType
gtype <- IO GType
c_webkit_back_forward_list_get_type
        BackForwardList -> (Ptr BackForwardList -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr BackForwardList
o (GType
-> (GValue -> Ptr BackForwardList -> IO ())
-> Ptr BackForwardList
-> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr BackForwardList -> IO ()
forall a. GObject a => GValue -> Ptr a -> IO ()
B.GValue.set_object)
        
    fromGValue :: GValue -> IO BackForwardList
fromGValue gv :: GValue
gv = do
        Ptr BackForwardList
ptr <- GValue -> IO (Ptr BackForwardList)
forall b. GObject b => GValue -> IO (Ptr b)
B.GValue.get_object GValue
gv :: IO (Ptr BackForwardList)
        (ManagedPtr BackForwardList -> BackForwardList)
-> Ptr BackForwardList -> IO BackForwardList
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr BackForwardList -> BackForwardList
BackForwardList Ptr BackForwardList
ptr
        
    

-- | 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 :: o -> m BackForwardList
toBackForwardList = IO BackForwardList -> m BackForwardList
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BackForwardList -> m BackForwardList)
-> (o -> IO BackForwardList) -> o -> m BackForwardList
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr BackForwardList -> BackForwardList)
-> o -> IO BackForwardList
forall o o'.
(HasCallStack, GObject o, GObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr BackForwardList -> BackForwardList
BackForwardList

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

#if defined(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 "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    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 @info
#else
    fromLabel _ = O.overloadedMethod @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
-- 'P.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 t'GI.WebKit2.Objects.BackForwardListItem.BackForwardListItem' added or 'P.Nothing'
    -> Ptr ()
    -- ^ /@itemsRemoved@/: a t'GI.GLib.Structs.List.List' of t'GI.WebKit2.Objects.BackForwardListItem.BackForwardListItem's
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `BackForwardListChangedCallback`@.
noBackForwardListChangedCallback :: Maybe BackForwardListChangedCallback
noBackForwardListChangedCallback :: Maybe BackForwardListChangedCallback
noBackForwardListChangedCallback = Maybe BackForwardListChangedCallback
forall a. Maybe a
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 :: BackForwardListChangedCallback
-> m (GClosure C_BackForwardListChangedCallback)
genClosure_BackForwardListChanged cb :: BackForwardListChangedCallback
cb = IO (GClosure C_BackForwardListChangedCallback)
-> m (GClosure C_BackForwardListChangedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_BackForwardListChangedCallback)
 -> m (GClosure C_BackForwardListChangedCallback))
-> IO (GClosure C_BackForwardListChangedCallback)
-> m (GClosure C_BackForwardListChangedCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_BackForwardListChangedCallback
cb' = BackForwardListChangedCallback -> C_BackForwardListChangedCallback
wrap_BackForwardListChangedCallback BackForwardListChangedCallback
cb
    C_BackForwardListChangedCallback
-> IO (FunPtr C_BackForwardListChangedCallback)
mk_BackForwardListChangedCallback C_BackForwardListChangedCallback
cb' IO (FunPtr C_BackForwardListChangedCallback)
-> (FunPtr C_BackForwardListChangedCallback
    -> IO (GClosure C_BackForwardListChangedCallback))
-> IO (GClosure C_BackForwardListChangedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_BackForwardListChangedCallback
-> IO (GClosure C_BackForwardListChangedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `BackForwardListChangedCallback` into a `C_BackForwardListChangedCallback`.
wrap_BackForwardListChangedCallback ::
    BackForwardListChangedCallback ->
    C_BackForwardListChangedCallback
wrap_BackForwardListChangedCallback :: BackForwardListChangedCallback -> C_BackForwardListChangedCallback
wrap_BackForwardListChangedCallback _cb :: BackForwardListChangedCallback
_cb _ itemAdded :: Ptr BackForwardListItem
itemAdded itemsRemoved :: Ptr ()
itemsRemoved _ = do
    Maybe BackForwardListItem
maybeItemAdded <-
        if Ptr BackForwardListItem
itemAdded Ptr BackForwardListItem -> Ptr BackForwardListItem -> Bool
forall a. Eq a => a -> a -> Bool
== Ptr BackForwardListItem
forall a. Ptr a
nullPtr
        then Maybe BackForwardListItem -> IO (Maybe BackForwardListItem)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe BackForwardListItem
forall a. Maybe a
Nothing
        else do
            BackForwardListItem
itemAdded' <- ((ManagedPtr BackForwardListItem -> BackForwardListItem)
-> Ptr BackForwardListItem -> IO BackForwardListItem
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr BackForwardListItem -> BackForwardListItem
WebKit2.BackForwardListItem.BackForwardListItem) Ptr BackForwardListItem
itemAdded
            Maybe BackForwardListItem -> IO (Maybe BackForwardListItem)
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe BackForwardListItem -> IO (Maybe BackForwardListItem))
-> Maybe BackForwardListItem -> IO (Maybe BackForwardListItem)
forall a b. (a -> b) -> a -> b
$ BackForwardListItem -> Maybe BackForwardListItem
forall a. a -> Maybe a
Just BackForwardListItem
itemAdded'
    BackForwardListChangedCallback
_cb  Maybe BackForwardListItem
maybeItemAdded Ptr ()
itemsRemoved


-- | Connect a signal handler for the [changed](#signal: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 :: a -> BackForwardListChangedCallback -> m SignalHandlerId
onBackForwardListChanged obj :: a
obj cb :: BackForwardListChangedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_BackForwardListChangedCallback
cb' = BackForwardListChangedCallback -> C_BackForwardListChangedCallback
wrap_BackForwardListChangedCallback BackForwardListChangedCallback
cb
    FunPtr C_BackForwardListChangedCallback
cb'' <- C_BackForwardListChangedCallback
-> IO (FunPtr C_BackForwardListChangedCallback)
mk_BackForwardListChangedCallback C_BackForwardListChangedCallback
cb'
    a
-> Text
-> FunPtr C_BackForwardListChangedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "changed" FunPtr C_BackForwardListChangedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [changed](#signal: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 :: a -> BackForwardListChangedCallback -> m SignalHandlerId
afterBackForwardListChanged obj :: a
obj cb :: BackForwardListChangedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_BackForwardListChangedCallback
cb' = BackForwardListChangedCallback -> C_BackForwardListChangedCallback
wrap_BackForwardListChangedCallback BackForwardListChangedCallback
cb
    FunPtr C_BackForwardListChangedCallback
cb'' <- C_BackForwardListChangedCallback
-> IO (FunPtr C_BackForwardListChangedCallback)
mk_BackForwardListChangedCallback C_BackForwardListChangedCallback
cb'
    a
-> Text
-> FunPtr C_BackForwardListChangedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "changed" FunPtr C_BackForwardListChangedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


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

#endif

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

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
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 t'GI.WebKit2.Objects.BackForwardList.BackForwardList'
    -> m (Maybe WebKit2.BackForwardListItem.BackForwardListItem)
    -- ^ __Returns:__ the t'GI.WebKit2.Objects.BackForwardListItem.BackForwardListItem'
    --    preceding the current item or 'P.Nothing'.
backForwardListGetBackItem :: a -> m (Maybe BackForwardListItem)
backForwardListGetBackItem backForwardList :: a
backForwardList = IO (Maybe BackForwardListItem) -> m (Maybe BackForwardListItem)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe BackForwardListItem) -> m (Maybe BackForwardListItem))
-> IO (Maybe BackForwardListItem) -> m (Maybe BackForwardListItem)
forall a b. (a -> b) -> a -> b
$ do
    Ptr BackForwardList
backForwardList' <- a -> IO (Ptr BackForwardList)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
backForwardList
    Ptr BackForwardListItem
result <- Ptr BackForwardList -> IO (Ptr BackForwardListItem)
webkit_back_forward_list_get_back_item Ptr BackForwardList
backForwardList'
    Maybe BackForwardListItem
maybeResult <- Ptr BackForwardListItem
-> (Ptr BackForwardListItem -> IO BackForwardListItem)
-> IO (Maybe BackForwardListItem)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr BackForwardListItem
result ((Ptr BackForwardListItem -> IO BackForwardListItem)
 -> IO (Maybe BackForwardListItem))
-> (Ptr BackForwardListItem -> IO BackForwardListItem)
-> IO (Maybe BackForwardListItem)
forall a b. (a -> b) -> a -> b
$ \result' :: Ptr BackForwardListItem
result' -> do
        BackForwardListItem
result'' <- ((ManagedPtr BackForwardListItem -> BackForwardListItem)
-> Ptr BackForwardListItem -> IO BackForwardListItem
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr BackForwardListItem -> BackForwardListItem
WebKit2.BackForwardListItem.BackForwardListItem) Ptr BackForwardListItem
result'
        BackForwardListItem -> IO BackForwardListItem
forall (m :: * -> *) a. Monad m => a -> m a
return BackForwardListItem
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
backForwardList
    Maybe BackForwardListItem -> IO (Maybe BackForwardListItem)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe BackForwardListItem
maybeResult

#if defined(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 t'GI.WebKit2.Objects.BackForwardList.BackForwardList'
    -> m [WebKit2.BackForwardListItem.BackForwardListItem]
    -- ^ __Returns:__ a t'GI.GLib.Structs.List.List' of
    --    items preceding the current item.
backForwardListGetBackList :: a -> m [BackForwardListItem]
backForwardListGetBackList backForwardList :: a
backForwardList = IO [BackForwardListItem] -> m [BackForwardListItem]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [BackForwardListItem] -> m [BackForwardListItem])
-> IO [BackForwardListItem] -> m [BackForwardListItem]
forall a b. (a -> b) -> a -> b
$ do
    Ptr BackForwardList
backForwardList' <- a -> IO (Ptr BackForwardList)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
backForwardList
    Ptr (GList (Ptr BackForwardListItem))
result <- Ptr BackForwardList -> IO (Ptr (GList (Ptr BackForwardListItem)))
webkit_back_forward_list_get_back_list Ptr BackForwardList
backForwardList'
    [Ptr BackForwardListItem]
result' <- Ptr (GList (Ptr BackForwardListItem))
-> IO [Ptr BackForwardListItem]
forall a. Ptr (GList (Ptr a)) -> IO [Ptr a]
unpackGList Ptr (GList (Ptr BackForwardListItem))
result
    [BackForwardListItem]
result'' <- (Ptr BackForwardListItem -> IO BackForwardListItem)
-> [Ptr BackForwardListItem] -> IO [BackForwardListItem]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((ManagedPtr BackForwardListItem -> BackForwardListItem)
-> Ptr BackForwardListItem -> IO BackForwardListItem
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr BackForwardListItem -> BackForwardListItem
WebKit2.BackForwardListItem.BackForwardListItem) [Ptr BackForwardListItem]
result'
    Ptr (GList (Ptr BackForwardListItem)) -> IO ()
forall a. Ptr (GList a) -> IO ()
g_list_free Ptr (GList (Ptr BackForwardListItem))
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
backForwardList
    [BackForwardListItem] -> IO [BackForwardListItem]
forall (m :: * -> *) a. Monad m => a -> m a
return [BackForwardListItem]
result''

#if defined(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 t'GI.WebKit2.Objects.BackForwardList.BackForwardList'
    -> Word32
    -- ^ /@limit@/: the number of items to retrieve
    -> m [WebKit2.BackForwardListItem.BackForwardListItem]
    -- ^ __Returns:__ a t'GI.GLib.Structs.List.List' of
    --    items preceding the current item limited by /@limit@/.
backForwardListGetBackListWithLimit :: a -> Word32 -> m [BackForwardListItem]
backForwardListGetBackListWithLimit backForwardList :: a
backForwardList limit :: Word32
limit = IO [BackForwardListItem] -> m [BackForwardListItem]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [BackForwardListItem] -> m [BackForwardListItem])
-> IO [BackForwardListItem] -> m [BackForwardListItem]
forall a b. (a -> b) -> a -> b
$ do
    Ptr BackForwardList
backForwardList' <- a -> IO (Ptr BackForwardList)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
backForwardList
    Ptr (GList (Ptr BackForwardListItem))
result <- Ptr BackForwardList
-> Word32 -> IO (Ptr (GList (Ptr BackForwardListItem)))
webkit_back_forward_list_get_back_list_with_limit Ptr BackForwardList
backForwardList' Word32
limit
    [Ptr BackForwardListItem]
result' <- Ptr (GList (Ptr BackForwardListItem))
-> IO [Ptr BackForwardListItem]
forall a. Ptr (GList (Ptr a)) -> IO [Ptr a]
unpackGList Ptr (GList (Ptr BackForwardListItem))
result
    [BackForwardListItem]
result'' <- (Ptr BackForwardListItem -> IO BackForwardListItem)
-> [Ptr BackForwardListItem] -> IO [BackForwardListItem]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((ManagedPtr BackForwardListItem -> BackForwardListItem)
-> Ptr BackForwardListItem -> IO BackForwardListItem
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr BackForwardListItem -> BackForwardListItem
WebKit2.BackForwardListItem.BackForwardListItem) [Ptr BackForwardListItem]
result'
    Ptr (GList (Ptr BackForwardListItem)) -> IO ()
forall a. Ptr (GList a) -> IO ()
g_list_free Ptr (GList (Ptr BackForwardListItem))
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
backForwardList
    [BackForwardListItem] -> IO [BackForwardListItem]
forall (m :: * -> *) a. Monad m => a -> m a
return [BackForwardListItem]
result''

#if defined(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 t'GI.WebKit2.Objects.BackForwardList.BackForwardList'
    -> m (Maybe WebKit2.BackForwardListItem.BackForwardListItem)
    -- ^ __Returns:__ a t'GI.WebKit2.Objects.BackForwardListItem.BackForwardListItem'
    --    or 'P.Nothing' if /@backForwardList@/ is empty.
backForwardListGetCurrentItem :: a -> m (Maybe BackForwardListItem)
backForwardListGetCurrentItem backForwardList :: a
backForwardList = IO (Maybe BackForwardListItem) -> m (Maybe BackForwardListItem)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe BackForwardListItem) -> m (Maybe BackForwardListItem))
-> IO (Maybe BackForwardListItem) -> m (Maybe BackForwardListItem)
forall a b. (a -> b) -> a -> b
$ do
    Ptr BackForwardList
backForwardList' <- a -> IO (Ptr BackForwardList)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
backForwardList
    Ptr BackForwardListItem
result <- Ptr BackForwardList -> IO (Ptr BackForwardListItem)
webkit_back_forward_list_get_current_item Ptr BackForwardList
backForwardList'
    Maybe BackForwardListItem
maybeResult <- Ptr BackForwardListItem
-> (Ptr BackForwardListItem -> IO BackForwardListItem)
-> IO (Maybe BackForwardListItem)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr BackForwardListItem
result ((Ptr BackForwardListItem -> IO BackForwardListItem)
 -> IO (Maybe BackForwardListItem))
-> (Ptr BackForwardListItem -> IO BackForwardListItem)
-> IO (Maybe BackForwardListItem)
forall a b. (a -> b) -> a -> b
$ \result' :: Ptr BackForwardListItem
result' -> do
        BackForwardListItem
result'' <- ((ManagedPtr BackForwardListItem -> BackForwardListItem)
-> Ptr BackForwardListItem -> IO BackForwardListItem
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr BackForwardListItem -> BackForwardListItem
WebKit2.BackForwardListItem.BackForwardListItem) Ptr BackForwardListItem
result'
        BackForwardListItem -> IO BackForwardListItem
forall (m :: * -> *) a. Monad m => a -> m a
return BackForwardListItem
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
backForwardList
    Maybe BackForwardListItem -> IO (Maybe BackForwardListItem)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe BackForwardListItem
maybeResult

#if defined(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 t'GI.WebKit2.Objects.BackForwardList.BackForwardList'
    -> m (Maybe WebKit2.BackForwardListItem.BackForwardListItem)
    -- ^ __Returns:__ the t'GI.WebKit2.Objects.BackForwardListItem.BackForwardListItem'
    --    following the current item or 'P.Nothing'.
backForwardListGetForwardItem :: a -> m (Maybe BackForwardListItem)
backForwardListGetForwardItem backForwardList :: a
backForwardList = IO (Maybe BackForwardListItem) -> m (Maybe BackForwardListItem)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe BackForwardListItem) -> m (Maybe BackForwardListItem))
-> IO (Maybe BackForwardListItem) -> m (Maybe BackForwardListItem)
forall a b. (a -> b) -> a -> b
$ do
    Ptr BackForwardList
backForwardList' <- a -> IO (Ptr BackForwardList)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
backForwardList
    Ptr BackForwardListItem
result <- Ptr BackForwardList -> IO (Ptr BackForwardListItem)
webkit_back_forward_list_get_forward_item Ptr BackForwardList
backForwardList'
    Maybe BackForwardListItem
maybeResult <- Ptr BackForwardListItem
-> (Ptr BackForwardListItem -> IO BackForwardListItem)
-> IO (Maybe BackForwardListItem)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr BackForwardListItem
result ((Ptr BackForwardListItem -> IO BackForwardListItem)
 -> IO (Maybe BackForwardListItem))
-> (Ptr BackForwardListItem -> IO BackForwardListItem)
-> IO (Maybe BackForwardListItem)
forall a b. (a -> b) -> a -> b
$ \result' :: Ptr BackForwardListItem
result' -> do
        BackForwardListItem
result'' <- ((ManagedPtr BackForwardListItem -> BackForwardListItem)
-> Ptr BackForwardListItem -> IO BackForwardListItem
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr BackForwardListItem -> BackForwardListItem
WebKit2.BackForwardListItem.BackForwardListItem) Ptr BackForwardListItem
result'
        BackForwardListItem -> IO BackForwardListItem
forall (m :: * -> *) a. Monad m => a -> m a
return BackForwardListItem
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
backForwardList
    Maybe BackForwardListItem -> IO (Maybe BackForwardListItem)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe BackForwardListItem
maybeResult

#if defined(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 t'GI.WebKit2.Objects.BackForwardList.BackForwardList'
    -> m [WebKit2.BackForwardListItem.BackForwardListItem]
    -- ^ __Returns:__ a t'GI.GLib.Structs.List.List' of
    --    items following the current item.
backForwardListGetForwardList :: a -> m [BackForwardListItem]
backForwardListGetForwardList backForwardList :: a
backForwardList = IO [BackForwardListItem] -> m [BackForwardListItem]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [BackForwardListItem] -> m [BackForwardListItem])
-> IO [BackForwardListItem] -> m [BackForwardListItem]
forall a b. (a -> b) -> a -> b
$ do
    Ptr BackForwardList
backForwardList' <- a -> IO (Ptr BackForwardList)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
backForwardList
    Ptr (GList (Ptr BackForwardListItem))
result <- Ptr BackForwardList -> IO (Ptr (GList (Ptr BackForwardListItem)))
webkit_back_forward_list_get_forward_list Ptr BackForwardList
backForwardList'
    [Ptr BackForwardListItem]
result' <- Ptr (GList (Ptr BackForwardListItem))
-> IO [Ptr BackForwardListItem]
forall a. Ptr (GList (Ptr a)) -> IO [Ptr a]
unpackGList Ptr (GList (Ptr BackForwardListItem))
result
    [BackForwardListItem]
result'' <- (Ptr BackForwardListItem -> IO BackForwardListItem)
-> [Ptr BackForwardListItem] -> IO [BackForwardListItem]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((ManagedPtr BackForwardListItem -> BackForwardListItem)
-> Ptr BackForwardListItem -> IO BackForwardListItem
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr BackForwardListItem -> BackForwardListItem
WebKit2.BackForwardListItem.BackForwardListItem) [Ptr BackForwardListItem]
result'
    Ptr (GList (Ptr BackForwardListItem)) -> IO ()
forall a. Ptr (GList a) -> IO ()
g_list_free Ptr (GList (Ptr BackForwardListItem))
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
backForwardList
    [BackForwardListItem] -> IO [BackForwardListItem]
forall (m :: * -> *) a. Monad m => a -> m a
return [BackForwardListItem]
result''

#if defined(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 t'GI.WebKit2.Objects.BackForwardList.BackForwardList'
    -> Word32
    -- ^ /@limit@/: the number of items to retrieve
    -> m [WebKit2.BackForwardListItem.BackForwardListItem]
    -- ^ __Returns:__ a t'GI.GLib.Structs.List.List' of
    --    items following the current item limited by /@limit@/.
backForwardListGetForwardListWithLimit :: a -> Word32 -> m [BackForwardListItem]
backForwardListGetForwardListWithLimit backForwardList :: a
backForwardList limit :: Word32
limit = IO [BackForwardListItem] -> m [BackForwardListItem]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [BackForwardListItem] -> m [BackForwardListItem])
-> IO [BackForwardListItem] -> m [BackForwardListItem]
forall a b. (a -> b) -> a -> b
$ do
    Ptr BackForwardList
backForwardList' <- a -> IO (Ptr BackForwardList)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
backForwardList
    Ptr (GList (Ptr BackForwardListItem))
result <- Ptr BackForwardList
-> Word32 -> IO (Ptr (GList (Ptr BackForwardListItem)))
webkit_back_forward_list_get_forward_list_with_limit Ptr BackForwardList
backForwardList' Word32
limit
    [Ptr BackForwardListItem]
result' <- Ptr (GList (Ptr BackForwardListItem))
-> IO [Ptr BackForwardListItem]
forall a. Ptr (GList (Ptr a)) -> IO [Ptr a]
unpackGList Ptr (GList (Ptr BackForwardListItem))
result
    [BackForwardListItem]
result'' <- (Ptr BackForwardListItem -> IO BackForwardListItem)
-> [Ptr BackForwardListItem] -> IO [BackForwardListItem]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((ManagedPtr BackForwardListItem -> BackForwardListItem)
-> Ptr BackForwardListItem -> IO BackForwardListItem
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr BackForwardListItem -> BackForwardListItem
WebKit2.BackForwardListItem.BackForwardListItem) [Ptr BackForwardListItem]
result'
    Ptr (GList (Ptr BackForwardListItem)) -> IO ()
forall a. Ptr (GList a) -> IO ()
g_list_free Ptr (GList (Ptr BackForwardListItem))
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
backForwardList
    [BackForwardListItem] -> IO [BackForwardListItem]
forall (m :: * -> *) a. Monad m => a -> m a
return [BackForwardListItem]
result''

#if defined(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 t'GI.WebKit2.Objects.BackForwardList.BackForwardList'
    -> m Word32
    -- ^ __Returns:__ the length of /@backForwardList@/.
backForwardListGetLength :: a -> m Word32
backForwardListGetLength backForwardList :: a
backForwardList = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
    Ptr BackForwardList
backForwardList' <- a -> IO (Ptr BackForwardList)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
backForwardList
    Word32
result <- Ptr BackForwardList -> IO Word32
webkit_back_forward_list_get_length Ptr BackForwardList
backForwardList'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
backForwardList
    Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(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 t'GI.WebKit2.Objects.BackForwardList.BackForwardList'
    -> Int32
    -- ^ /@index@/: the index of the item
    -> m (Maybe WebKit2.BackForwardListItem.BackForwardListItem)
    -- ^ __Returns:__ the t'GI.WebKit2.Objects.BackForwardListItem.BackForwardListItem'
    --    located at the specified index relative to the current item or 'P.Nothing'.
backForwardListGetNthItem :: a -> Int32 -> m (Maybe BackForwardListItem)
backForwardListGetNthItem backForwardList :: a
backForwardList index :: Int32
index = IO (Maybe BackForwardListItem) -> m (Maybe BackForwardListItem)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe BackForwardListItem) -> m (Maybe BackForwardListItem))
-> IO (Maybe BackForwardListItem) -> m (Maybe BackForwardListItem)
forall a b. (a -> b) -> a -> b
$ do
    Ptr BackForwardList
backForwardList' <- a -> IO (Ptr BackForwardList)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
backForwardList
    Ptr BackForwardListItem
result <- Ptr BackForwardList -> Int32 -> IO (Ptr BackForwardListItem)
webkit_back_forward_list_get_nth_item Ptr BackForwardList
backForwardList' Int32
index
    Maybe BackForwardListItem
maybeResult <- Ptr BackForwardListItem
-> (Ptr BackForwardListItem -> IO BackForwardListItem)
-> IO (Maybe BackForwardListItem)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr BackForwardListItem
result ((Ptr BackForwardListItem -> IO BackForwardListItem)
 -> IO (Maybe BackForwardListItem))
-> (Ptr BackForwardListItem -> IO BackForwardListItem)
-> IO (Maybe BackForwardListItem)
forall a b. (a -> b) -> a -> b
$ \result' :: Ptr BackForwardListItem
result' -> do
        BackForwardListItem
result'' <- ((ManagedPtr BackForwardListItem -> BackForwardListItem)
-> Ptr BackForwardListItem -> IO BackForwardListItem
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr BackForwardListItem -> BackForwardListItem
WebKit2.BackForwardListItem.BackForwardListItem) Ptr BackForwardListItem
result'
        BackForwardListItem -> IO BackForwardListItem
forall (m :: * -> *) a. Monad m => a -> m a
return BackForwardListItem
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
backForwardList
    Maybe BackForwardListItem -> IO (Maybe BackForwardListItem)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe BackForwardListItem
maybeResult

#if defined(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