{-# 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.BackForwardListItem
    ( 

-- * Exported types
    BackForwardListItem(..)                 ,
    IsBackForwardListItem                   ,
    toBackForwardListItem                   ,
    noBackForwardListItem                   ,


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

#if defined(ENABLE_OVERLOADING)
    ResolveBackForwardListItemMethod        ,
#endif


-- ** getOriginalUri #method:getOriginalUri#

#if defined(ENABLE_OVERLOADING)
    BackForwardListItemGetOriginalUriMethodInfo,
#endif
    backForwardListItemGetOriginalUri       ,


-- ** getTitle #method:getTitle#

#if defined(ENABLE_OVERLOADING)
    BackForwardListItemGetTitleMethodInfo   ,
#endif
    backForwardListItemGetTitle             ,


-- ** getUri #method:getUri#

#if defined(ENABLE_OVERLOADING)
    BackForwardListItemGetUriMethodInfo     ,
#endif
    backForwardListItemGetUri               ,




    ) 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

-- | Memory-managed wrapper type.
newtype BackForwardListItem = BackForwardListItem (ManagedPtr BackForwardListItem)
    deriving (BackForwardListItem -> BackForwardListItem -> Bool
(BackForwardListItem -> BackForwardListItem -> Bool)
-> (BackForwardListItem -> BackForwardListItem -> Bool)
-> Eq BackForwardListItem
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BackForwardListItem -> BackForwardListItem -> Bool
$c/= :: BackForwardListItem -> BackForwardListItem -> Bool
== :: BackForwardListItem -> BackForwardListItem -> Bool
$c== :: BackForwardListItem -> BackForwardListItem -> Bool
Eq)
foreign import ccall "webkit_back_forward_list_item_get_type"
    c_webkit_back_forward_list_item_get_type :: IO GType

instance GObject BackForwardListItem where
    gobjectType :: IO GType
gobjectType = IO GType
c_webkit_back_forward_list_item_get_type
    

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

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

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

-- | Cast to `BackForwardListItem`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toBackForwardListItem :: (MonadIO m, IsBackForwardListItem o) => o -> m BackForwardListItem
toBackForwardListItem :: o -> m BackForwardListItem
toBackForwardListItem = IO BackForwardListItem -> m BackForwardListItem
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BackForwardListItem -> m BackForwardListItem)
-> (o -> IO BackForwardListItem) -> o -> m BackForwardListItem
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr BackForwardListItem -> BackForwardListItem)
-> o -> IO BackForwardListItem
forall o o'.
(HasCallStack, GObject o, GObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr BackForwardListItem -> BackForwardListItem
BackForwardListItem

-- | A convenience alias for `Nothing` :: `Maybe` `BackForwardListItem`.
noBackForwardListItem :: Maybe BackForwardListItem
noBackForwardListItem :: Maybe BackForwardListItem
noBackForwardListItem = Maybe BackForwardListItem
forall a. Maybe a
Nothing

#if defined(ENABLE_OVERLOADING)
type family ResolveBackForwardListItemMethod (t :: Symbol) (o :: *) :: * where
    ResolveBackForwardListItemMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveBackForwardListItemMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveBackForwardListItemMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveBackForwardListItemMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveBackForwardListItemMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveBackForwardListItemMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveBackForwardListItemMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveBackForwardListItemMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveBackForwardListItemMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveBackForwardListItemMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveBackForwardListItemMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveBackForwardListItemMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveBackForwardListItemMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveBackForwardListItemMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveBackForwardListItemMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveBackForwardListItemMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveBackForwardListItemMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveBackForwardListItemMethod "getOriginalUri" o = BackForwardListItemGetOriginalUriMethodInfo
    ResolveBackForwardListItemMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveBackForwardListItemMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveBackForwardListItemMethod "getTitle" o = BackForwardListItemGetTitleMethodInfo
    ResolveBackForwardListItemMethod "getUri" o = BackForwardListItemGetUriMethodInfo
    ResolveBackForwardListItemMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveBackForwardListItemMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveBackForwardListItemMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveBackForwardListItemMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveBackForwardListItemMethod t BackForwardListItem, O.MethodInfo info BackForwardListItem p) => OL.IsLabel t (BackForwardListItem -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#endif

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

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList BackForwardListItem = BackForwardListItemSignalList
type BackForwardListItemSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

#endif

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

foreign import ccall "webkit_back_forward_list_item_get_original_uri" webkit_back_forward_list_item_get_original_uri :: 
    Ptr BackForwardListItem ->              -- list_item : TInterface (Name {namespace = "WebKit2", name = "BackForwardListItem"})
    IO CString

-- | See also 'GI.WebKit2.Objects.BackForwardListItem.backForwardListItemGetUri'.
backForwardListItemGetOriginalUri ::
    (B.CallStack.HasCallStack, MonadIO m, IsBackForwardListItem a) =>
    a
    -- ^ /@listItem@/: a t'GI.WebKit2.Objects.BackForwardListItem.BackForwardListItem'
    -> m (Maybe T.Text)
    -- ^ __Returns:__ the original URI of /@listItem@/ or 'P.Nothing'
    --    when the original URI is empty.
backForwardListItemGetOriginalUri :: a -> m (Maybe Text)
backForwardListItemGetOriginalUri listItem :: a
listItem = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    Ptr BackForwardListItem
listItem' <- a -> IO (Ptr BackForwardListItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
listItem
    CString
result <- Ptr BackForwardListItem -> IO CString
webkit_back_forward_list_item_get_original_uri Ptr BackForwardListItem
listItem'
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \result' :: CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
listItem
    Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

#if defined(ENABLE_OVERLOADING)
data BackForwardListItemGetOriginalUriMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsBackForwardListItem a) => O.MethodInfo BackForwardListItemGetOriginalUriMethodInfo a signature where
    overloadedMethod = backForwardListItemGetOriginalUri

#endif

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

foreign import ccall "webkit_back_forward_list_item_get_title" webkit_back_forward_list_item_get_title :: 
    Ptr BackForwardListItem ->              -- list_item : TInterface (Name {namespace = "WebKit2", name = "BackForwardListItem"})
    IO CString

-- | /No description available in the introspection data./
backForwardListItemGetTitle ::
    (B.CallStack.HasCallStack, MonadIO m, IsBackForwardListItem a) =>
    a
    -- ^ /@listItem@/: a t'GI.WebKit2.Objects.BackForwardListItem.BackForwardListItem'
    -> m (Maybe T.Text)
    -- ^ __Returns:__ the page title of /@listItem@/ or 'P.Nothing'
    --    when the title is empty.
backForwardListItemGetTitle :: a -> m (Maybe Text)
backForwardListItemGetTitle listItem :: a
listItem = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    Ptr BackForwardListItem
listItem' <- a -> IO (Ptr BackForwardListItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
listItem
    CString
result <- Ptr BackForwardListItem -> IO CString
webkit_back_forward_list_item_get_title Ptr BackForwardListItem
listItem'
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \result' :: CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
listItem
    Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

#if defined(ENABLE_OVERLOADING)
data BackForwardListItemGetTitleMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsBackForwardListItem a) => O.MethodInfo BackForwardListItemGetTitleMethodInfo a signature where
    overloadedMethod = backForwardListItemGetTitle

#endif

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

foreign import ccall "webkit_back_forward_list_item_get_uri" webkit_back_forward_list_item_get_uri :: 
    Ptr BackForwardListItem ->              -- list_item : TInterface (Name {namespace = "WebKit2", name = "BackForwardListItem"})
    IO CString

-- | This URI may differ from the original URI if the page was,
-- for example, redirected to a new location.
-- See also 'GI.WebKit2.Objects.BackForwardListItem.backForwardListItemGetOriginalUri'.
backForwardListItemGetUri ::
    (B.CallStack.HasCallStack, MonadIO m, IsBackForwardListItem a) =>
    a
    -- ^ /@listItem@/: a t'GI.WebKit2.Objects.BackForwardListItem.BackForwardListItem'
    -> m (Maybe T.Text)
    -- ^ __Returns:__ the URI of /@listItem@/ or 'P.Nothing'
    --    when the URI is empty.
backForwardListItemGetUri :: a -> m (Maybe Text)
backForwardListItemGetUri listItem :: a
listItem = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    Ptr BackForwardListItem
listItem' <- a -> IO (Ptr BackForwardListItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
listItem
    CString
result <- Ptr BackForwardListItem -> IO CString
webkit_back_forward_list_item_get_uri Ptr BackForwardListItem
listItem'
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \result' :: CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
listItem
    Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

#if defined(ENABLE_OVERLOADING)
data BackForwardListItemGetUriMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsBackForwardListItem a) => O.MethodInfo BackForwardListItemGetUriMethodInfo a signature where
    overloadedMethod = backForwardListItemGetUri

#endif