{- |
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.WebContext
    (

-- * Exported types
    WebContext(..)                          ,
    IsWebContext                            ,
    toWebContext                            ,
    noWebContext                            ,


 -- * Methods
-- ** allowTlsCertificateForHost #method:allowTlsCertificateForHost#

#if ENABLE_OVERLOADING
    WebContextAllowTlsCertificateForHostMethodInfo,
#endif
    webContextAllowTlsCertificateForHost    ,


-- ** clearCache #method:clearCache#

#if ENABLE_OVERLOADING
    WebContextClearCacheMethodInfo          ,
#endif
    webContextClearCache                    ,


-- ** downloadUri #method:downloadUri#

#if ENABLE_OVERLOADING
    WebContextDownloadUriMethodInfo         ,
#endif
    webContextDownloadUri                   ,


-- ** getCacheModel #method:getCacheModel#

#if ENABLE_OVERLOADING
    WebContextGetCacheModelMethodInfo       ,
#endif
    webContextGetCacheModel                 ,


-- ** getCookieManager #method:getCookieManager#

#if ENABLE_OVERLOADING
    WebContextGetCookieManagerMethodInfo    ,
#endif
    webContextGetCookieManager              ,


-- ** getDefault #method:getDefault#

    webContextGetDefault                    ,


-- ** getFaviconDatabase #method:getFaviconDatabase#

#if ENABLE_OVERLOADING
    WebContextGetFaviconDatabaseMethodInfo  ,
#endif
    webContextGetFaviconDatabase            ,


-- ** getFaviconDatabaseDirectory #method:getFaviconDatabaseDirectory#

#if ENABLE_OVERLOADING
    WebContextGetFaviconDatabaseDirectoryMethodInfo,
#endif
    webContextGetFaviconDatabaseDirectory   ,


-- ** getPlugins #method:getPlugins#

#if ENABLE_OVERLOADING
    WebContextGetPluginsMethodInfo          ,
#endif
    webContextGetPlugins                    ,


-- ** getPluginsFinish #method:getPluginsFinish#

#if ENABLE_OVERLOADING
    WebContextGetPluginsFinishMethodInfo    ,
#endif
    webContextGetPluginsFinish              ,


-- ** getProcessModel #method:getProcessModel#

#if ENABLE_OVERLOADING
    WebContextGetProcessModelMethodInfo     ,
#endif
    webContextGetProcessModel               ,


-- ** getSecurityManager #method:getSecurityManager#

#if ENABLE_OVERLOADING
    WebContextGetSecurityManagerMethodInfo  ,
#endif
    webContextGetSecurityManager            ,


-- ** getSpellCheckingEnabled #method:getSpellCheckingEnabled#

#if ENABLE_OVERLOADING
    WebContextGetSpellCheckingEnabledMethodInfo,
#endif
    webContextGetSpellCheckingEnabled       ,


-- ** getSpellCheckingLanguages #method:getSpellCheckingLanguages#

#if ENABLE_OVERLOADING
    WebContextGetSpellCheckingLanguagesMethodInfo,
#endif
    webContextGetSpellCheckingLanguages     ,


-- ** getTlsErrorsPolicy #method:getTlsErrorsPolicy#

#if ENABLE_OVERLOADING
    WebContextGetTlsErrorsPolicyMethodInfo  ,
#endif
    webContextGetTlsErrorsPolicy            ,


-- ** getWebProcessCountLimit #method:getWebProcessCountLimit#

#if ENABLE_OVERLOADING
    WebContextGetWebProcessCountLimitMethodInfo,
#endif
    webContextGetWebProcessCountLimit       ,


-- ** getWebsiteDataManager #method:getWebsiteDataManager#

#if ENABLE_OVERLOADING
    WebContextGetWebsiteDataManagerMethodInfo,
#endif
    webContextGetWebsiteDataManager         ,


-- ** initializeNotificationPermissions #method:initializeNotificationPermissions#

#if ENABLE_OVERLOADING
    WebContextInitializeNotificationPermissionsMethodInfo,
#endif
    webContextInitializeNotificationPermissions,


-- ** isAutomationAllowed #method:isAutomationAllowed#

#if ENABLE_OVERLOADING
    WebContextIsAutomationAllowedMethodInfo ,
#endif
    webContextIsAutomationAllowed           ,


-- ** isEphemeral #method:isEphemeral#

#if ENABLE_OVERLOADING
    WebContextIsEphemeralMethodInfo         ,
#endif
    webContextIsEphemeral                   ,


-- ** new #method:new#

    webContextNew                           ,


-- ** newEphemeral #method:newEphemeral#

    webContextNewEphemeral                  ,


-- ** newWithWebsiteDataManager #method:newWithWebsiteDataManager#

    webContextNewWithWebsiteDataManager     ,


-- ** prefetchDns #method:prefetchDns#

#if ENABLE_OVERLOADING
    WebContextPrefetchDnsMethodInfo         ,
#endif
    webContextPrefetchDns                   ,


-- ** registerUriScheme #method:registerUriScheme#

#if ENABLE_OVERLOADING
    WebContextRegisterUriSchemeMethodInfo   ,
#endif
    webContextRegisterUriScheme             ,


-- ** setAdditionalPluginsDirectory #method:setAdditionalPluginsDirectory#

#if ENABLE_OVERLOADING
    WebContextSetAdditionalPluginsDirectoryMethodInfo,
#endif
    webContextSetAdditionalPluginsDirectory ,


-- ** setAutomationAllowed #method:setAutomationAllowed#

#if ENABLE_OVERLOADING
    WebContextSetAutomationAllowedMethodInfo,
#endif
    webContextSetAutomationAllowed          ,


-- ** setCacheModel #method:setCacheModel#

#if ENABLE_OVERLOADING
    WebContextSetCacheModelMethodInfo       ,
#endif
    webContextSetCacheModel                 ,


-- ** setDiskCacheDirectory #method:setDiskCacheDirectory#

#if ENABLE_OVERLOADING
    WebContextSetDiskCacheDirectoryMethodInfo,
#endif
    webContextSetDiskCacheDirectory         ,


-- ** setFaviconDatabaseDirectory #method:setFaviconDatabaseDirectory#

#if ENABLE_OVERLOADING
    WebContextSetFaviconDatabaseDirectoryMethodInfo,
#endif
    webContextSetFaviconDatabaseDirectory   ,


-- ** setNetworkProxySettings #method:setNetworkProxySettings#

#if ENABLE_OVERLOADING
    WebContextSetNetworkProxySettingsMethodInfo,
#endif
    webContextSetNetworkProxySettings       ,


-- ** setPreferredLanguages #method:setPreferredLanguages#

#if ENABLE_OVERLOADING
    WebContextSetPreferredLanguagesMethodInfo,
#endif
    webContextSetPreferredLanguages         ,


-- ** setProcessModel #method:setProcessModel#

#if ENABLE_OVERLOADING
    WebContextSetProcessModelMethodInfo     ,
#endif
    webContextSetProcessModel               ,


-- ** setSpellCheckingEnabled #method:setSpellCheckingEnabled#

#if ENABLE_OVERLOADING
    WebContextSetSpellCheckingEnabledMethodInfo,
#endif
    webContextSetSpellCheckingEnabled       ,


-- ** setSpellCheckingLanguages #method:setSpellCheckingLanguages#

#if ENABLE_OVERLOADING
    WebContextSetSpellCheckingLanguagesMethodInfo,
#endif
    webContextSetSpellCheckingLanguages     ,


-- ** setTlsErrorsPolicy #method:setTlsErrorsPolicy#

#if ENABLE_OVERLOADING
    WebContextSetTlsErrorsPolicyMethodInfo  ,
#endif
    webContextSetTlsErrorsPolicy            ,


-- ** setWebExtensionsDirectory #method:setWebExtensionsDirectory#

#if ENABLE_OVERLOADING
    WebContextSetWebExtensionsDirectoryMethodInfo,
#endif
    webContextSetWebExtensionsDirectory     ,


-- ** setWebExtensionsInitializationUserData #method:setWebExtensionsInitializationUserData#

#if ENABLE_OVERLOADING
    WebContextSetWebExtensionsInitializationUserDataMethodInfo,
#endif
    webContextSetWebExtensionsInitializationUserData,


-- ** setWebProcessCountLimit #method:setWebProcessCountLimit#

#if ENABLE_OVERLOADING
    WebContextSetWebProcessCountLimitMethodInfo,
#endif
    webContextSetWebProcessCountLimit       ,




 -- * Properties
-- ** localStorageDirectory #attr:localStorageDirectory#
{- | The directory where local storage data will be saved.

/Since: 2.8/
-}
#if ENABLE_OVERLOADING
    WebContextLocalStorageDirectoryPropertyInfo,
#endif
    constructWebContextLocalStorageDirectory,
    getWebContextLocalStorageDirectory      ,
#if ENABLE_OVERLOADING
    webContextLocalStorageDirectory         ,
#endif


-- ** websiteDataManager #attr:websiteDataManager#
{- | The 'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager' associated with this context.

/Since: 2.10/
-}
#if ENABLE_OVERLOADING
    WebContextWebsiteDataManagerPropertyInfo,
#endif
    constructWebContextWebsiteDataManager   ,
    getWebContextWebsiteDataManager         ,
#if ENABLE_OVERLOADING
    webContextWebsiteDataManager            ,
#endif




 -- * Signals
-- ** automationStarted #signal:automationStarted#

    C_WebContextAutomationStartedCallback   ,
    WebContextAutomationStartedCallback     ,
#if ENABLE_OVERLOADING
    WebContextAutomationStartedSignalInfo   ,
#endif
    afterWebContextAutomationStarted        ,
    genClosure_WebContextAutomationStarted  ,
    mk_WebContextAutomationStartedCallback  ,
    noWebContextAutomationStartedCallback   ,
    onWebContextAutomationStarted           ,
    wrap_WebContextAutomationStartedCallback,


-- ** downloadStarted #signal:downloadStarted#

    C_WebContextDownloadStartedCallback     ,
    WebContextDownloadStartedCallback       ,
#if ENABLE_OVERLOADING
    WebContextDownloadStartedSignalInfo     ,
#endif
    afterWebContextDownloadStarted          ,
    genClosure_WebContextDownloadStarted    ,
    mk_WebContextDownloadStartedCallback    ,
    noWebContextDownloadStartedCallback     ,
    onWebContextDownloadStarted             ,
    wrap_WebContextDownloadStartedCallback  ,


-- ** initializeNotificationPermissions #signal:initializeNotificationPermissions#

    C_WebContextInitializeNotificationPermissionsCallback,
    WebContextInitializeNotificationPermissionsCallback,
#if ENABLE_OVERLOADING
    WebContextInitializeNotificationPermissionsSignalInfo,
#endif
    afterWebContextInitializeNotificationPermissions,
    genClosure_WebContextInitializeNotificationPermissions,
    mk_WebContextInitializeNotificationPermissionsCallback,
    noWebContextInitializeNotificationPermissionsCallback,
    onWebContextInitializeNotificationPermissions,
    wrap_WebContextInitializeNotificationPermissionsCallback,


-- ** initializeWebExtensions #signal:initializeWebExtensions#

    C_WebContextInitializeWebExtensionsCallback,
    WebContextInitializeWebExtensionsCallback,
#if ENABLE_OVERLOADING
    WebContextInitializeWebExtensionsSignalInfo,
#endif
    afterWebContextInitializeWebExtensions  ,
    genClosure_WebContextInitializeWebExtensions,
    mk_WebContextInitializeWebExtensionsCallback,
    noWebContextInitializeWebExtensionsCallback,
    onWebContextInitializeWebExtensions     ,
    wrap_WebContextInitializeWebExtensionsCallback,




    ) 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.GLib.Callbacks as GLib.Callbacks
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gio.Callbacks as Gio.Callbacks
import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult
import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable
import qualified GI.Gio.Objects.TlsCertificate as Gio.TlsCertificate
import qualified GI.WebKit2.Callbacks as WebKit2.Callbacks
import {-# SOURCE #-} qualified GI.WebKit2.Enums as WebKit2.Enums
import {-# SOURCE #-} qualified GI.WebKit2.Objects.AutomationSession as WebKit2.AutomationSession
import {-# SOURCE #-} qualified GI.WebKit2.Objects.CookieManager as WebKit2.CookieManager
import {-# SOURCE #-} qualified GI.WebKit2.Objects.Download as WebKit2.Download
import {-# SOURCE #-} qualified GI.WebKit2.Objects.FaviconDatabase as WebKit2.FaviconDatabase
import {-# SOURCE #-} qualified GI.WebKit2.Objects.Plugin as WebKit2.Plugin
import {-# SOURCE #-} qualified GI.WebKit2.Objects.SecurityManager as WebKit2.SecurityManager
import {-# SOURCE #-} qualified GI.WebKit2.Objects.WebsiteDataManager as WebKit2.WebsiteDataManager
import {-# SOURCE #-} qualified GI.WebKit2.Structs.NetworkProxySettings as WebKit2.NetworkProxySettings
import {-# SOURCE #-} qualified GI.WebKit2.Structs.SecurityOrigin as WebKit2.SecurityOrigin

-- | Memory-managed wrapper type.
newtype WebContext = WebContext (ManagedPtr WebContext)
foreign import ccall "webkit_web_context_get_type"
    c_webkit_web_context_get_type :: IO GType

instance GObject WebContext where
    gobjectType = c_webkit_web_context_get_type


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

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

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

-- | A convenience alias for `Nothing` :: `Maybe` `WebContext`.
noWebContext :: Maybe WebContext
noWebContext = Nothing

#if ENABLE_OVERLOADING
type family ResolveWebContextMethod (t :: Symbol) (o :: *) :: * where
    ResolveWebContextMethod "allowTlsCertificateForHost" o = WebContextAllowTlsCertificateForHostMethodInfo
    ResolveWebContextMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveWebContextMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveWebContextMethod "clearCache" o = WebContextClearCacheMethodInfo
    ResolveWebContextMethod "downloadUri" o = WebContextDownloadUriMethodInfo
    ResolveWebContextMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveWebContextMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveWebContextMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveWebContextMethod "initializeNotificationPermissions" o = WebContextInitializeNotificationPermissionsMethodInfo
    ResolveWebContextMethod "isAutomationAllowed" o = WebContextIsAutomationAllowedMethodInfo
    ResolveWebContextMethod "isEphemeral" o = WebContextIsEphemeralMethodInfo
    ResolveWebContextMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveWebContextMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveWebContextMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveWebContextMethod "prefetchDns" o = WebContextPrefetchDnsMethodInfo
    ResolveWebContextMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveWebContextMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveWebContextMethod "registerUriScheme" o = WebContextRegisterUriSchemeMethodInfo
    ResolveWebContextMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveWebContextMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveWebContextMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveWebContextMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveWebContextMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveWebContextMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveWebContextMethod "getCacheModel" o = WebContextGetCacheModelMethodInfo
    ResolveWebContextMethod "getCookieManager" o = WebContextGetCookieManagerMethodInfo
    ResolveWebContextMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveWebContextMethod "getFaviconDatabase" o = WebContextGetFaviconDatabaseMethodInfo
    ResolveWebContextMethod "getFaviconDatabaseDirectory" o = WebContextGetFaviconDatabaseDirectoryMethodInfo
    ResolveWebContextMethod "getPlugins" o = WebContextGetPluginsMethodInfo
    ResolveWebContextMethod "getPluginsFinish" o = WebContextGetPluginsFinishMethodInfo
    ResolveWebContextMethod "getProcessModel" o = WebContextGetProcessModelMethodInfo
    ResolveWebContextMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveWebContextMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveWebContextMethod "getSecurityManager" o = WebContextGetSecurityManagerMethodInfo
    ResolveWebContextMethod "getSpellCheckingEnabled" o = WebContextGetSpellCheckingEnabledMethodInfo
    ResolveWebContextMethod "getSpellCheckingLanguages" o = WebContextGetSpellCheckingLanguagesMethodInfo
    ResolveWebContextMethod "getTlsErrorsPolicy" o = WebContextGetTlsErrorsPolicyMethodInfo
    ResolveWebContextMethod "getWebProcessCountLimit" o = WebContextGetWebProcessCountLimitMethodInfo
    ResolveWebContextMethod "getWebsiteDataManager" o = WebContextGetWebsiteDataManagerMethodInfo
    ResolveWebContextMethod "setAdditionalPluginsDirectory" o = WebContextSetAdditionalPluginsDirectoryMethodInfo
    ResolveWebContextMethod "setAutomationAllowed" o = WebContextSetAutomationAllowedMethodInfo
    ResolveWebContextMethod "setCacheModel" o = WebContextSetCacheModelMethodInfo
    ResolveWebContextMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveWebContextMethod "setDiskCacheDirectory" o = WebContextSetDiskCacheDirectoryMethodInfo
    ResolveWebContextMethod "setFaviconDatabaseDirectory" o = WebContextSetFaviconDatabaseDirectoryMethodInfo
    ResolveWebContextMethod "setNetworkProxySettings" o = WebContextSetNetworkProxySettingsMethodInfo
    ResolveWebContextMethod "setPreferredLanguages" o = WebContextSetPreferredLanguagesMethodInfo
    ResolveWebContextMethod "setProcessModel" o = WebContextSetProcessModelMethodInfo
    ResolveWebContextMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveWebContextMethod "setSpellCheckingEnabled" o = WebContextSetSpellCheckingEnabledMethodInfo
    ResolveWebContextMethod "setSpellCheckingLanguages" o = WebContextSetSpellCheckingLanguagesMethodInfo
    ResolveWebContextMethod "setTlsErrorsPolicy" o = WebContextSetTlsErrorsPolicyMethodInfo
    ResolveWebContextMethod "setWebExtensionsDirectory" o = WebContextSetWebExtensionsDirectoryMethodInfo
    ResolveWebContextMethod "setWebExtensionsInitializationUserData" o = WebContextSetWebExtensionsInitializationUserDataMethodInfo
    ResolveWebContextMethod "setWebProcessCountLimit" o = WebContextSetWebProcessCountLimitMethodInfo
    ResolveWebContextMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveWebContextMethod t WebContext, O.MethodInfo info WebContext p) => OL.IsLabel t (WebContext -> 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 WebContext::automation-started
{- |
This signal is emitted when a new automation request is made.
Note that it will never be emitted if automation is not enabled in /@context@/,
see 'GI.WebKit2.Objects.WebContext.webContextSetAutomationAllowed' for more details.

/Since: 2.18/
-}
type WebContextAutomationStartedCallback =
    WebKit2.AutomationSession.AutomationSession
    {- ^ /@session@/: the 'GI.WebKit2.Objects.AutomationSession.AutomationSession' associated with this event -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `WebContextAutomationStartedCallback`@.
noWebContextAutomationStartedCallback :: Maybe WebContextAutomationStartedCallback
noWebContextAutomationStartedCallback = Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_WebContextAutomationStarted :: MonadIO m => WebContextAutomationStartedCallback -> m (GClosure C_WebContextAutomationStartedCallback)
genClosure_WebContextAutomationStarted cb = liftIO $ do
    let cb' = wrap_WebContextAutomationStartedCallback cb
    mk_WebContextAutomationStartedCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `WebContextAutomationStartedCallback` into a `C_WebContextAutomationStartedCallback`.
wrap_WebContextAutomationStartedCallback ::
    WebContextAutomationStartedCallback ->
    C_WebContextAutomationStartedCallback
wrap_WebContextAutomationStartedCallback _cb _ session _ = do
    session' <- (newObject WebKit2.AutomationSession.AutomationSession) session
    _cb  session'


{- |
Connect a signal handler for the “@automation-started@” 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' webContext #automationStarted callback
@
-}
onWebContextAutomationStarted :: (IsWebContext a, MonadIO m) => a -> WebContextAutomationStartedCallback -> m SignalHandlerId
onWebContextAutomationStarted obj cb = liftIO $ do
    let cb' = wrap_WebContextAutomationStartedCallback cb
    cb'' <- mk_WebContextAutomationStartedCallback cb'
    connectSignalFunPtr obj "automation-started" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@automation-started@” 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' webContext #automationStarted callback
@
-}
afterWebContextAutomationStarted :: (IsWebContext a, MonadIO m) => a -> WebContextAutomationStartedCallback -> m SignalHandlerId
afterWebContextAutomationStarted obj cb = liftIO $ do
    let cb' = wrap_WebContextAutomationStartedCallback cb
    cb'' <- mk_WebContextAutomationStartedCallback cb'
    connectSignalFunPtr obj "automation-started" cb'' SignalConnectAfter


-- signal WebContext::download-started
{- |
This signal is emitted when a new download request is made.
-}
type WebContextDownloadStartedCallback =
    WebKit2.Download.Download
    {- ^ /@download@/: the 'GI.WebKit2.Objects.Download.Download' associated with this event -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `WebContextDownloadStartedCallback`@.
noWebContextDownloadStartedCallback :: Maybe WebContextDownloadStartedCallback
noWebContextDownloadStartedCallback = Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_WebContextDownloadStarted :: MonadIO m => WebContextDownloadStartedCallback -> m (GClosure C_WebContextDownloadStartedCallback)
genClosure_WebContextDownloadStarted cb = liftIO $ do
    let cb' = wrap_WebContextDownloadStartedCallback cb
    mk_WebContextDownloadStartedCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `WebContextDownloadStartedCallback` into a `C_WebContextDownloadStartedCallback`.
wrap_WebContextDownloadStartedCallback ::
    WebContextDownloadStartedCallback ->
    C_WebContextDownloadStartedCallback
wrap_WebContextDownloadStartedCallback _cb _ download _ = do
    download' <- (newObject WebKit2.Download.Download) download
    _cb  download'


{- |
Connect a signal handler for the “@download-started@” 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' webContext #downloadStarted callback
@
-}
onWebContextDownloadStarted :: (IsWebContext a, MonadIO m) => a -> WebContextDownloadStartedCallback -> m SignalHandlerId
onWebContextDownloadStarted obj cb = liftIO $ do
    let cb' = wrap_WebContextDownloadStartedCallback cb
    cb'' <- mk_WebContextDownloadStartedCallback cb'
    connectSignalFunPtr obj "download-started" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@download-started@” 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' webContext #downloadStarted callback
@
-}
afterWebContextDownloadStarted :: (IsWebContext a, MonadIO m) => a -> WebContextDownloadStartedCallback -> m SignalHandlerId
afterWebContextDownloadStarted obj cb = liftIO $ do
    let cb' = wrap_WebContextDownloadStartedCallback cb
    cb'' <- mk_WebContextDownloadStartedCallback cb'
    connectSignalFunPtr obj "download-started" cb'' SignalConnectAfter


-- signal WebContext::initialize-notification-permissions
{- |
This signal is emitted when a 'GI.WebKit2.Objects.WebContext.WebContext' needs to set
initial notification permissions for a web process. It is emitted
when a new web process is about to be launched, and signals the
most appropriate moment to use
'GI.WebKit2.Objects.WebContext.webContextInitializeNotificationPermissions'. If no
notification permissions have changed since the last time this
signal was emitted, then there is no need to call
'GI.WebKit2.Objects.WebContext.webContextInitializeNotificationPermissions' again.

/Since: 2.16/
-}
type WebContextInitializeNotificationPermissionsCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `WebContextInitializeNotificationPermissionsCallback`@.
noWebContextInitializeNotificationPermissionsCallback :: Maybe WebContextInitializeNotificationPermissionsCallback
noWebContextInitializeNotificationPermissionsCallback = Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_WebContextInitializeNotificationPermissions :: MonadIO m => WebContextInitializeNotificationPermissionsCallback -> m (GClosure C_WebContextInitializeNotificationPermissionsCallback)
genClosure_WebContextInitializeNotificationPermissions cb = liftIO $ do
    let cb' = wrap_WebContextInitializeNotificationPermissionsCallback cb
    mk_WebContextInitializeNotificationPermissionsCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `WebContextInitializeNotificationPermissionsCallback` into a `C_WebContextInitializeNotificationPermissionsCallback`.
wrap_WebContextInitializeNotificationPermissionsCallback ::
    WebContextInitializeNotificationPermissionsCallback ->
    C_WebContextInitializeNotificationPermissionsCallback
wrap_WebContextInitializeNotificationPermissionsCallback _cb _ _ = do
    _cb


{- |
Connect a signal handler for the “@initialize-notification-permissions@” 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' webContext #initializeNotificationPermissions callback
@
-}
onWebContextInitializeNotificationPermissions :: (IsWebContext a, MonadIO m) => a -> WebContextInitializeNotificationPermissionsCallback -> m SignalHandlerId
onWebContextInitializeNotificationPermissions obj cb = liftIO $ do
    let cb' = wrap_WebContextInitializeNotificationPermissionsCallback cb
    cb'' <- mk_WebContextInitializeNotificationPermissionsCallback cb'
    connectSignalFunPtr obj "initialize-notification-permissions" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@initialize-notification-permissions@” 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' webContext #initializeNotificationPermissions callback
@
-}
afterWebContextInitializeNotificationPermissions :: (IsWebContext a, MonadIO m) => a -> WebContextInitializeNotificationPermissionsCallback -> m SignalHandlerId
afterWebContextInitializeNotificationPermissions obj cb = liftIO $ do
    let cb' = wrap_WebContextInitializeNotificationPermissionsCallback cb
    cb'' <- mk_WebContextInitializeNotificationPermissionsCallback cb'
    connectSignalFunPtr obj "initialize-notification-permissions" cb'' SignalConnectAfter


-- signal WebContext::initialize-web-extensions
{- |
This signal is emitted when a new web process is about to be
launched. It signals the most appropriate moment to use
'GI.WebKit2.Objects.WebContext.webContextSetWebExtensionsInitializationUserData'
and 'GI.WebKit2.Objects.WebContext.webContextSetWebExtensionsDirectory'.

/Since: 2.4/
-}
type WebContextInitializeWebExtensionsCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `WebContextInitializeWebExtensionsCallback`@.
noWebContextInitializeWebExtensionsCallback :: Maybe WebContextInitializeWebExtensionsCallback
noWebContextInitializeWebExtensionsCallback = Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_WebContextInitializeWebExtensions :: MonadIO m => WebContextInitializeWebExtensionsCallback -> m (GClosure C_WebContextInitializeWebExtensionsCallback)
genClosure_WebContextInitializeWebExtensions cb = liftIO $ do
    let cb' = wrap_WebContextInitializeWebExtensionsCallback cb
    mk_WebContextInitializeWebExtensionsCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `WebContextInitializeWebExtensionsCallback` into a `C_WebContextInitializeWebExtensionsCallback`.
wrap_WebContextInitializeWebExtensionsCallback ::
    WebContextInitializeWebExtensionsCallback ->
    C_WebContextInitializeWebExtensionsCallback
wrap_WebContextInitializeWebExtensionsCallback _cb _ _ = do
    _cb


{- |
Connect a signal handler for the “@initialize-web-extensions@” 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' webContext #initializeWebExtensions callback
@
-}
onWebContextInitializeWebExtensions :: (IsWebContext a, MonadIO m) => a -> WebContextInitializeWebExtensionsCallback -> m SignalHandlerId
onWebContextInitializeWebExtensions obj cb = liftIO $ do
    let cb' = wrap_WebContextInitializeWebExtensionsCallback cb
    cb'' <- mk_WebContextInitializeWebExtensionsCallback cb'
    connectSignalFunPtr obj "initialize-web-extensions" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@initialize-web-extensions@” 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' webContext #initializeWebExtensions callback
@
-}
afterWebContextInitializeWebExtensions :: (IsWebContext a, MonadIO m) => a -> WebContextInitializeWebExtensionsCallback -> m SignalHandlerId
afterWebContextInitializeWebExtensions obj cb = liftIO $ do
    let cb' = wrap_WebContextInitializeWebExtensionsCallback cb
    cb'' <- mk_WebContextInitializeWebExtensionsCallback cb'
    connectSignalFunPtr obj "initialize-web-extensions" cb'' SignalConnectAfter


-- VVV Prop "local-storage-directory"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Nothing,Nothing)

{- |
Get the value of the “@local-storage-directory@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' webContext #localStorageDirectory
@
-}
getWebContextLocalStorageDirectory :: (MonadIO m, IsWebContext o) => o -> m (Maybe T.Text)
getWebContextLocalStorageDirectory obj = liftIO $ B.Properties.getObjectPropertyString obj "local-storage-directory"

{- |
Construct a `GValueConstruct` with valid value for the “@local-storage-directory@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructWebContextLocalStorageDirectory :: (IsWebContext o) => T.Text -> IO (GValueConstruct o)
constructWebContextLocalStorageDirectory val = B.Properties.constructObjectPropertyString "local-storage-directory" (Just val)

#if ENABLE_OVERLOADING
data WebContextLocalStorageDirectoryPropertyInfo
instance AttrInfo WebContextLocalStorageDirectoryPropertyInfo where
    type AttrAllowedOps WebContextLocalStorageDirectoryPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WebContextLocalStorageDirectoryPropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint WebContextLocalStorageDirectoryPropertyInfo = IsWebContext
    type AttrGetType WebContextLocalStorageDirectoryPropertyInfo = (Maybe T.Text)
    type AttrLabel WebContextLocalStorageDirectoryPropertyInfo = "local-storage-directory"
    type AttrOrigin WebContextLocalStorageDirectoryPropertyInfo = WebContext
    attrGet _ = getWebContextLocalStorageDirectory
    attrSet _ = undefined
    attrConstruct _ = constructWebContextLocalStorageDirectory
    attrClear _ = undefined
#endif

-- VVV Prop "website-data-manager"
   -- Type: TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"})
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Just False,Nothing)

{- |
Get the value of the “@website-data-manager@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' webContext #websiteDataManager
@
-}
getWebContextWebsiteDataManager :: (MonadIO m, IsWebContext o) => o -> m WebKit2.WebsiteDataManager.WebsiteDataManager
getWebContextWebsiteDataManager obj = liftIO $ checkUnexpectedNothing "getWebContextWebsiteDataManager" $ B.Properties.getObjectPropertyObject obj "website-data-manager" WebKit2.WebsiteDataManager.WebsiteDataManager

{- |
Construct a `GValueConstruct` with valid value for the “@website-data-manager@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructWebContextWebsiteDataManager :: (IsWebContext o, WebKit2.WebsiteDataManager.IsWebsiteDataManager a) => a -> IO (GValueConstruct o)
constructWebContextWebsiteDataManager val = B.Properties.constructObjectPropertyObject "website-data-manager" (Just val)

#if ENABLE_OVERLOADING
data WebContextWebsiteDataManagerPropertyInfo
instance AttrInfo WebContextWebsiteDataManagerPropertyInfo where
    type AttrAllowedOps WebContextWebsiteDataManagerPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WebContextWebsiteDataManagerPropertyInfo = WebKit2.WebsiteDataManager.IsWebsiteDataManager
    type AttrBaseTypeConstraint WebContextWebsiteDataManagerPropertyInfo = IsWebContext
    type AttrGetType WebContextWebsiteDataManagerPropertyInfo = WebKit2.WebsiteDataManager.WebsiteDataManager
    type AttrLabel WebContextWebsiteDataManagerPropertyInfo = "website-data-manager"
    type AttrOrigin WebContextWebsiteDataManagerPropertyInfo = WebContext
    attrGet _ = getWebContextWebsiteDataManager
    attrSet _ = undefined
    attrConstruct _ = constructWebContextWebsiteDataManager
    attrClear _ = undefined
#endif

#if ENABLE_OVERLOADING
instance O.HasAttributeList WebContext
type instance O.AttributeList WebContext = WebContextAttributeList
type WebContextAttributeList = ('[ '("localStorageDirectory", WebContextLocalStorageDirectoryPropertyInfo), '("websiteDataManager", WebContextWebsiteDataManagerPropertyInfo)] :: [(Symbol, *)])
#endif

#if ENABLE_OVERLOADING
webContextLocalStorageDirectory :: AttrLabelProxy "localStorageDirectory"
webContextLocalStorageDirectory = AttrLabelProxy

webContextWebsiteDataManager :: AttrLabelProxy "websiteDataManager"
webContextWebsiteDataManager = AttrLabelProxy

#endif

#if ENABLE_OVERLOADING
data WebContextAutomationStartedSignalInfo
instance SignalInfo WebContextAutomationStartedSignalInfo where
    type HaskellCallbackType WebContextAutomationStartedSignalInfo = WebContextAutomationStartedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_WebContextAutomationStartedCallback cb
        cb'' <- mk_WebContextAutomationStartedCallback cb'
        connectSignalFunPtr obj "automation-started" cb'' connectMode

data WebContextDownloadStartedSignalInfo
instance SignalInfo WebContextDownloadStartedSignalInfo where
    type HaskellCallbackType WebContextDownloadStartedSignalInfo = WebContextDownloadStartedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_WebContextDownloadStartedCallback cb
        cb'' <- mk_WebContextDownloadStartedCallback cb'
        connectSignalFunPtr obj "download-started" cb'' connectMode

data WebContextInitializeNotificationPermissionsSignalInfo
instance SignalInfo WebContextInitializeNotificationPermissionsSignalInfo where
    type HaskellCallbackType WebContextInitializeNotificationPermissionsSignalInfo = WebContextInitializeNotificationPermissionsCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_WebContextInitializeNotificationPermissionsCallback cb
        cb'' <- mk_WebContextInitializeNotificationPermissionsCallback cb'
        connectSignalFunPtr obj "initialize-notification-permissions" cb'' connectMode

data WebContextInitializeWebExtensionsSignalInfo
instance SignalInfo WebContextInitializeWebExtensionsSignalInfo where
    type HaskellCallbackType WebContextInitializeWebExtensionsSignalInfo = WebContextInitializeWebExtensionsCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_WebContextInitializeWebExtensionsCallback cb
        cb'' <- mk_WebContextInitializeWebExtensionsCallback cb'
        connectSignalFunPtr obj "initialize-web-extensions" cb'' connectMode

type instance O.SignalList WebContext = WebContextSignalList
type WebContextSignalList = ('[ '("automationStarted", WebContextAutomationStartedSignalInfo), '("downloadStarted", WebContextDownloadStartedSignalInfo), '("initializeNotificationPermissions", WebContextInitializeNotificationPermissionsSignalInfo), '("initializeWebExtensions", WebContextInitializeWebExtensionsSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

#endif

-- method WebContext::new
-- method type : Constructor
-- Args : []
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "WebContext"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_context_new" webkit_web_context_new ::
    IO (Ptr WebContext)

{- |
Create a new 'GI.WebKit2.Objects.WebContext.WebContext'

/Since: 2.8/
-}
webContextNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m WebContext
    {- ^ __Returns:__ a newly created 'GI.WebKit2.Objects.WebContext.WebContext' -}
webContextNew  = liftIO $ do
    result <- webkit_web_context_new
    checkUnexpectedReturnNULL "webContextNew" result
    result' <- (wrapObject WebContext) result
    return result'

#if ENABLE_OVERLOADING
#endif

-- method WebContext::new_ephemeral
-- method type : Constructor
-- Args : []
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "WebContext"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_context_new_ephemeral" webkit_web_context_new_ephemeral ::
    IO (Ptr WebContext)

{- |
Create a new ephemeral 'GI.WebKit2.Objects.WebContext.WebContext'. An ephemeral 'GI.WebKit2.Objects.WebContext.WebContext' is a context
created with an ephemeral 'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager'. This is just a convenient method
to create ephemeral contexts without having to create your own 'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager'.
All 'GI.WebKit2.Objects.WebView.WebView'\<!-- -->s associated with this context will also be ephemeral. Websites will
not store any data in the client storage.
This is normally used to implement private instances.

/Since: 2.16/
-}
webContextNewEphemeral ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m WebContext
    {- ^ __Returns:__ a new ephemeral 'GI.WebKit2.Objects.WebContext.WebContext'. -}
webContextNewEphemeral  = liftIO $ do
    result <- webkit_web_context_new_ephemeral
    checkUnexpectedReturnNULL "webContextNewEphemeral" result
    result' <- (wrapObject WebContext) result
    return result'

#if ENABLE_OVERLOADING
#endif

-- method WebContext::new_with_website_data_manager
-- method type : Constructor
-- Args : [Arg {argCName = "manager", argType = TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebsiteDataManager", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "WebContext"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_context_new_with_website_data_manager" webkit_web_context_new_with_website_data_manager ::
    Ptr WebKit2.WebsiteDataManager.WebsiteDataManager -> -- manager : TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"})
    IO (Ptr WebContext)

{- |
Create a new 'GI.WebKit2.Objects.WebContext.WebContext' with a 'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager'.

/Since: 2.10/
-}
webContextNewWithWebsiteDataManager ::
    (B.CallStack.HasCallStack, MonadIO m, WebKit2.WebsiteDataManager.IsWebsiteDataManager a) =>
    a
    {- ^ /@manager@/: a 'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager' -}
    -> m WebContext
    {- ^ __Returns:__ a newly created 'GI.WebKit2.Objects.WebContext.WebContext' -}
webContextNewWithWebsiteDataManager manager = liftIO $ do
    manager' <- unsafeManagedPtrCastPtr manager
    result <- webkit_web_context_new_with_website_data_manager manager'
    checkUnexpectedReturnNULL "webContextNewWithWebsiteDataManager" result
    result' <- (wrapObject WebContext) result
    touchManagedPtr manager
    return result'

#if ENABLE_OVERLOADING
#endif

-- method WebContext::allow_tls_certificate_for_host
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "WebKit2", name = "WebContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "certificate", argType = TInterface (Name {namespace = "Gio", name = "TlsCertificate"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GTlsCertificate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "host", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the host for which a certificate is to be allowed", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_context_allow_tls_certificate_for_host" webkit_web_context_allow_tls_certificate_for_host ::
    Ptr WebContext ->                       -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"})
    Ptr Gio.TlsCertificate.TlsCertificate -> -- certificate : TInterface (Name {namespace = "Gio", name = "TlsCertificate"})
    CString ->                              -- host : TBasicType TUTF8
    IO ()

{- |
Ignore further TLS errors on the /@host@/ for the certificate present in /@info@/.

/Since: 2.6/
-}
webContextAllowTlsCertificateForHost ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebContext a, Gio.TlsCertificate.IsTlsCertificate b) =>
    a
    {- ^ /@context@/: a 'GI.WebKit2.Objects.WebContext.WebContext' -}
    -> b
    {- ^ /@certificate@/: a 'GI.Gio.Objects.TlsCertificate.TlsCertificate' -}
    -> T.Text
    {- ^ /@host@/: the host for which a certificate is to be allowed -}
    -> m ()
webContextAllowTlsCertificateForHost context certificate host = liftIO $ do
    context' <- unsafeManagedPtrCastPtr context
    certificate' <- unsafeManagedPtrCastPtr certificate
    host' <- textToCString host
    webkit_web_context_allow_tls_certificate_for_host context' certificate' host'
    touchManagedPtr context
    touchManagedPtr certificate
    freeMem host'
    return ()

#if ENABLE_OVERLOADING
data WebContextAllowTlsCertificateForHostMethodInfo
instance (signature ~ (b -> T.Text -> m ()), MonadIO m, IsWebContext a, Gio.TlsCertificate.IsTlsCertificate b) => O.MethodInfo WebContextAllowTlsCertificateForHostMethodInfo a signature where
    overloadedMethod _ = webContextAllowTlsCertificateForHost

#endif

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

foreign import ccall "webkit_web_context_clear_cache" webkit_web_context_clear_cache ::
    Ptr WebContext ->                       -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"})
    IO ()

{- |
Clears all resources currently cached.
See also 'GI.WebKit2.Objects.WebContext.webContextSetCacheModel'.
-}
webContextClearCache ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) =>
    a
    {- ^ /@context@/: a 'GI.WebKit2.Objects.WebContext.WebContext' -}
    -> m ()
webContextClearCache context = liftIO $ do
    context' <- unsafeManagedPtrCastPtr context
    webkit_web_context_clear_cache context'
    touchManagedPtr context
    return ()

#if ENABLE_OVERLOADING
data WebContextClearCacheMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWebContext a) => O.MethodInfo WebContextClearCacheMethodInfo a signature where
    overloadedMethod _ = webContextClearCache

#endif

-- method WebContext::download_uri
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "WebKit2", name = "WebContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the URI to download", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "Download"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_context_download_uri" webkit_web_context_download_uri ::
    Ptr WebContext ->                       -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"})
    CString ->                              -- uri : TBasicType TUTF8
    IO (Ptr WebKit2.Download.Download)

{- |
Requests downloading of the specified URI string. The download operation
will not be associated to any 'GI.WebKit2.Objects.WebView.WebView', if you are interested in
starting a download from a particular 'GI.WebKit2.Objects.WebView.WebView' use
'GI.WebKit2.Objects.WebView.webViewDownloadUri' instead.
-}
webContextDownloadUri ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) =>
    a
    {- ^ /@context@/: a 'GI.WebKit2.Objects.WebContext.WebContext' -}
    -> T.Text
    {- ^ /@uri@/: the URI to download -}
    -> m WebKit2.Download.Download
    {- ^ __Returns:__ a new 'GI.WebKit2.Objects.Download.Download' representing
   the download operation. -}
webContextDownloadUri context uri = liftIO $ do
    context' <- unsafeManagedPtrCastPtr context
    uri' <- textToCString uri
    result <- webkit_web_context_download_uri context' uri'
    checkUnexpectedReturnNULL "webContextDownloadUri" result
    result' <- (wrapObject WebKit2.Download.Download) result
    touchManagedPtr context
    freeMem uri'
    return result'

#if ENABLE_OVERLOADING
data WebContextDownloadUriMethodInfo
instance (signature ~ (T.Text -> m WebKit2.Download.Download), MonadIO m, IsWebContext a) => O.MethodInfo WebContextDownloadUriMethodInfo a signature where
    overloadedMethod _ = webContextDownloadUri

#endif

-- method WebContext::get_cache_model
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "WebKit2", name = "WebContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #WebKitWebContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "CacheModel"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_context_get_cache_model" webkit_web_context_get_cache_model ::
    Ptr WebContext ->                       -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"})
    IO CUInt

{- |
Returns the current cache model. For more information about this
value check the documentation of the function
'GI.WebKit2.Objects.WebContext.webContextSetCacheModel'.
-}
webContextGetCacheModel ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) =>
    a
    {- ^ /@context@/: the 'GI.WebKit2.Objects.WebContext.WebContext' -}
    -> m WebKit2.Enums.CacheModel
    {- ^ __Returns:__ the current 'GI.WebKit2.Enums.CacheModel' -}
webContextGetCacheModel context = liftIO $ do
    context' <- unsafeManagedPtrCastPtr context
    result <- webkit_web_context_get_cache_model context'
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr context
    return result'

#if ENABLE_OVERLOADING
data WebContextGetCacheModelMethodInfo
instance (signature ~ (m WebKit2.Enums.CacheModel), MonadIO m, IsWebContext a) => O.MethodInfo WebContextGetCacheModelMethodInfo a signature where
    overloadedMethod _ = webContextGetCacheModel

#endif

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

foreign import ccall "webkit_web_context_get_cookie_manager" webkit_web_context_get_cookie_manager ::
    Ptr WebContext ->                       -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"})
    IO (Ptr WebKit2.CookieManager.CookieManager)

{- |
Get the 'GI.WebKit2.Objects.CookieManager.CookieManager' of the /@context@/\'s 'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager'.
-}
webContextGetCookieManager ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) =>
    a
    {- ^ /@context@/: a 'GI.WebKit2.Objects.WebContext.WebContext' -}
    -> m WebKit2.CookieManager.CookieManager
    {- ^ __Returns:__ the 'GI.WebKit2.Objects.CookieManager.CookieManager' of /@context@/. -}
webContextGetCookieManager context = liftIO $ do
    context' <- unsafeManagedPtrCastPtr context
    result <- webkit_web_context_get_cookie_manager context'
    checkUnexpectedReturnNULL "webContextGetCookieManager" result
    result' <- (newObject WebKit2.CookieManager.CookieManager) result
    touchManagedPtr context
    return result'

#if ENABLE_OVERLOADING
data WebContextGetCookieManagerMethodInfo
instance (signature ~ (m WebKit2.CookieManager.CookieManager), MonadIO m, IsWebContext a) => O.MethodInfo WebContextGetCookieManagerMethodInfo a signature where
    overloadedMethod _ = webContextGetCookieManager

#endif

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

foreign import ccall "webkit_web_context_get_favicon_database" webkit_web_context_get_favicon_database ::
    Ptr WebContext ->                       -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"})
    IO (Ptr WebKit2.FaviconDatabase.FaviconDatabase)

{- |
Get the 'GI.WebKit2.Objects.FaviconDatabase.FaviconDatabase' associated with /@context@/.

To initialize the database you need to call
'GI.WebKit2.Objects.WebContext.webContextSetFaviconDatabaseDirectory'.
-}
webContextGetFaviconDatabase ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) =>
    a
    {- ^ /@context@/: a 'GI.WebKit2.Objects.WebContext.WebContext' -}
    -> m WebKit2.FaviconDatabase.FaviconDatabase
    {- ^ __Returns:__ the 'GI.WebKit2.Objects.FaviconDatabase.FaviconDatabase' of /@context@/. -}
webContextGetFaviconDatabase context = liftIO $ do
    context' <- unsafeManagedPtrCastPtr context
    result <- webkit_web_context_get_favicon_database context'
    checkUnexpectedReturnNULL "webContextGetFaviconDatabase" result
    result' <- (newObject WebKit2.FaviconDatabase.FaviconDatabase) result
    touchManagedPtr context
    return result'

#if ENABLE_OVERLOADING
data WebContextGetFaviconDatabaseMethodInfo
instance (signature ~ (m WebKit2.FaviconDatabase.FaviconDatabase), MonadIO m, IsWebContext a) => O.MethodInfo WebContextGetFaviconDatabaseMethodInfo a signature where
    overloadedMethod _ = webContextGetFaviconDatabase

#endif

-- method WebContext::get_favicon_database_directory
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "WebKit2", name = "WebContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebContext", 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_web_context_get_favicon_database_directory" webkit_web_context_get_favicon_database_directory ::
    Ptr WebContext ->                       -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"})
    IO CString

{- |
Get the directory path being used to store the favicons database
for /@context@/, or 'Nothing' if
'GI.WebKit2.Objects.WebContext.webContextSetFaviconDatabaseDirectory' hasn\'t been
called yet.

This function will always return the same path after having called
'GI.WebKit2.Objects.WebContext.webContextSetFaviconDatabaseDirectory' for the first
time.
-}
webContextGetFaviconDatabaseDirectory ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) =>
    a
    {- ^ /@context@/: a 'GI.WebKit2.Objects.WebContext.WebContext' -}
    -> m (Maybe T.Text)
    {- ^ __Returns:__ the path of the directory of the favicons
database associated with /@context@/, or 'Nothing'. -}
webContextGetFaviconDatabaseDirectory context = liftIO $ do
    context' <- unsafeManagedPtrCastPtr context
    result <- webkit_web_context_get_favicon_database_directory context'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- cstringToText result'
        return result''
    touchManagedPtr context
    return maybeResult

#if ENABLE_OVERLOADING
data WebContextGetFaviconDatabaseDirectoryMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsWebContext a) => O.MethodInfo WebContextGetFaviconDatabaseDirectoryMethodInfo a signature where
    overloadedMethod _ = webContextGetFaviconDatabaseDirectory

#endif

-- method WebContext::get_plugins
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "WebKit2", name = "WebContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable or %NULL to ignore", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GAsyncReadyCallback to call when the request is satisfied", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the data to pass to callback function", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_context_get_plugins" webkit_web_context_get_plugins ::
    Ptr WebContext ->                       -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO ()

{- |
Asynchronously get the list of installed plugins.

When the operation is finished, /@callback@/ will be called. You can then call
'GI.WebKit2.Objects.WebContext.webContextGetPluginsFinish' to get the result of the operation.
-}
webContextGetPlugins ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebContext a, Gio.Cancellable.IsCancellable b) =>
    a
    {- ^ /@context@/: a 'GI.WebKit2.Objects.WebContext.WebContext' -}
    -> Maybe (b)
    {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable' or 'Nothing' to ignore -}
    -> Maybe (Gio.Callbacks.AsyncReadyCallback)
    {- ^ /@callback@/: a 'GI.Gio.Callbacks.AsyncReadyCallback' to call when the request is satisfied -}
    -> m ()
webContextGetPlugins context cancellable callback = liftIO $ do
    context' <- unsafeManagedPtrCastPtr context
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    maybeCallback <- case callback of
        Nothing -> return (castPtrToFunPtr nullPtr)
        Just jCallback -> do
            ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
            jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback))
            poke ptrcallback jCallback'
            return jCallback'
    let userData = nullPtr
    webkit_web_context_get_plugins context' maybeCancellable maybeCallback userData
    touchManagedPtr context
    whenJust cancellable touchManagedPtr
    return ()

#if ENABLE_OVERLOADING
data WebContextGetPluginsMethodInfo
instance (signature ~ (Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsWebContext a, Gio.Cancellable.IsCancellable b) => O.MethodInfo WebContextGetPluginsMethodInfo a signature where
    overloadedMethod _ = webContextGetPlugins

#endif

-- method WebContext::get_plugins_finish
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "WebKit2", name = "WebContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAsyncResult", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TGList (TInterface (Name {namespace = "WebKit2", name = "Plugin"})))
-- throws : True
-- Skip return : False

foreign import ccall "webkit_web_context_get_plugins_finish" webkit_web_context_get_plugins_finish ::
    Ptr WebContext ->                       -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"})
    Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr (GList (Ptr WebKit2.Plugin.Plugin)))

{- |
Finish an asynchronous operation started with webkit_web_context_get_plugins.
-}
webContextGetPluginsFinish ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebContext a, Gio.AsyncResult.IsAsyncResult b) =>
    a
    {- ^ /@context@/: a 'GI.WebKit2.Objects.WebContext.WebContext' -}
    -> b
    {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult' -}
    -> m [WebKit2.Plugin.Plugin]
    {- ^ __Returns:__ a 'GI.GLib.Structs.List.List' of 'GI.WebKit2.Objects.Plugin.Plugin'. You must free the 'GI.GLib.Structs.List.List' with
   @/g_list_free()/@ and unref the 'GI.WebKit2.Objects.Plugin.Plugin'\<!-- -->s with 'GI.GObject.Objects.Object.objectUnref' when you\'re done with them. /(Can throw 'Data.GI.Base.GError.GError')/ -}
webContextGetPluginsFinish context result_ = liftIO $ do
    context' <- unsafeManagedPtrCastPtr context
    result_' <- unsafeManagedPtrCastPtr result_
    onException (do
        result <- propagateGError $ webkit_web_context_get_plugins_finish context' result_'
        result' <- unpackGList result
        result'' <- mapM (wrapObject WebKit2.Plugin.Plugin) result'
        g_list_free result
        touchManagedPtr context
        touchManagedPtr result_
        return result''
     ) (do
        return ()
     )

#if ENABLE_OVERLOADING
data WebContextGetPluginsFinishMethodInfo
instance (signature ~ (b -> m [WebKit2.Plugin.Plugin]), MonadIO m, IsWebContext a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo WebContextGetPluginsFinishMethodInfo a signature where
    overloadedMethod _ = webContextGetPluginsFinish

#endif

-- method WebContext::get_process_model
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "WebKit2", name = "WebContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #WebKitWebContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "ProcessModel"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_context_get_process_model" webkit_web_context_get_process_model ::
    Ptr WebContext ->                       -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"})
    IO CUInt

{- |
Returns the current process model. For more information about this value
see 'GI.WebKit2.Objects.WebContext.webContextSetProcessModel'.

/Since: 2.4/
-}
webContextGetProcessModel ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) =>
    a
    {- ^ /@context@/: the 'GI.WebKit2.Objects.WebContext.WebContext' -}
    -> m WebKit2.Enums.ProcessModel
    {- ^ __Returns:__ the current 'GI.WebKit2.Enums.ProcessModel' -}
webContextGetProcessModel context = liftIO $ do
    context' <- unsafeManagedPtrCastPtr context
    result <- webkit_web_context_get_process_model context'
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr context
    return result'

#if ENABLE_OVERLOADING
data WebContextGetProcessModelMethodInfo
instance (signature ~ (m WebKit2.Enums.ProcessModel), MonadIO m, IsWebContext a) => O.MethodInfo WebContextGetProcessModelMethodInfo a signature where
    overloadedMethod _ = webContextGetProcessModel

#endif

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

foreign import ccall "webkit_web_context_get_security_manager" webkit_web_context_get_security_manager ::
    Ptr WebContext ->                       -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"})
    IO (Ptr WebKit2.SecurityManager.SecurityManager)

{- |
Get the 'GI.WebKit2.Objects.SecurityManager.SecurityManager' of /@context@/.
-}
webContextGetSecurityManager ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) =>
    a
    {- ^ /@context@/: a 'GI.WebKit2.Objects.WebContext.WebContext' -}
    -> m WebKit2.SecurityManager.SecurityManager
    {- ^ __Returns:__ the 'GI.WebKit2.Objects.SecurityManager.SecurityManager' of /@context@/. -}
webContextGetSecurityManager context = liftIO $ do
    context' <- unsafeManagedPtrCastPtr context
    result <- webkit_web_context_get_security_manager context'
    checkUnexpectedReturnNULL "webContextGetSecurityManager" result
    result' <- (newObject WebKit2.SecurityManager.SecurityManager) result
    touchManagedPtr context
    return result'

#if ENABLE_OVERLOADING
data WebContextGetSecurityManagerMethodInfo
instance (signature ~ (m WebKit2.SecurityManager.SecurityManager), MonadIO m, IsWebContext a) => O.MethodInfo WebContextGetSecurityManagerMethodInfo a signature where
    overloadedMethod _ = webContextGetSecurityManager

#endif

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

foreign import ccall "webkit_web_context_get_spell_checking_enabled" webkit_web_context_get_spell_checking_enabled ::
    Ptr WebContext ->                       -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"})
    IO CInt

{- |
Get whether spell checking feature is currently enabled.
-}
webContextGetSpellCheckingEnabled ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) =>
    a
    {- ^ /@context@/: a 'GI.WebKit2.Objects.WebContext.WebContext' -}
    -> m Bool
    {- ^ __Returns:__ 'True' If spell checking is enabled, or 'False' otherwise. -}
webContextGetSpellCheckingEnabled context = liftIO $ do
    context' <- unsafeManagedPtrCastPtr context
    result <- webkit_web_context_get_spell_checking_enabled context'
    let result' = (/= 0) result
    touchManagedPtr context
    return result'

#if ENABLE_OVERLOADING
data WebContextGetSpellCheckingEnabledMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWebContext a) => O.MethodInfo WebContextGetSpellCheckingEnabledMethodInfo a signature where
    overloadedMethod _ = webContextGetSpellCheckingEnabled

#endif

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

foreign import ccall "webkit_web_context_get_spell_checking_languages" webkit_web_context_get_spell_checking_languages ::
    Ptr WebContext ->                       -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"})
    IO (Ptr CString)

{- |
Get the the list of spell checking languages associated with
/@context@/, or 'Nothing' if no languages have been previously set.

See 'GI.WebKit2.Objects.WebContext.webContextSetSpellCheckingLanguages' for more
details on the format of the languages in the list.
-}
webContextGetSpellCheckingLanguages ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) =>
    a
    {- ^ /@context@/: a 'GI.WebKit2.Objects.WebContext.WebContext' -}
    -> m (Maybe [T.Text])
    {- ^ __Returns:__ A 'Nothing'-terminated
   array of languages if available, or 'Nothing' otherwise. -}
webContextGetSpellCheckingLanguages context = liftIO $ do
    context' <- unsafeManagedPtrCastPtr context
    result <- webkit_web_context_get_spell_checking_languages context'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- unpackZeroTerminatedUTF8CArray result'
        return result''
    touchManagedPtr context
    return maybeResult

#if ENABLE_OVERLOADING
data WebContextGetSpellCheckingLanguagesMethodInfo
instance (signature ~ (m (Maybe [T.Text])), MonadIO m, IsWebContext a) => O.MethodInfo WebContextGetSpellCheckingLanguagesMethodInfo a signature where
    overloadedMethod _ = webContextGetSpellCheckingLanguages

#endif

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

foreign import ccall "webkit_web_context_get_tls_errors_policy" webkit_web_context_get_tls_errors_policy ::
    Ptr WebContext ->                       -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"})
    IO CUInt

{- |
Get the TLS errors policy of /@context@/
-}
webContextGetTlsErrorsPolicy ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) =>
    a
    {- ^ /@context@/: a 'GI.WebKit2.Objects.WebContext.WebContext' -}
    -> m WebKit2.Enums.TLSErrorsPolicy
    {- ^ __Returns:__ a 'GI.WebKit2.Enums.TLSErrorsPolicy' -}
webContextGetTlsErrorsPolicy context = liftIO $ do
    context' <- unsafeManagedPtrCastPtr context
    result <- webkit_web_context_get_tls_errors_policy context'
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr context
    return result'

#if ENABLE_OVERLOADING
data WebContextGetTlsErrorsPolicyMethodInfo
instance (signature ~ (m WebKit2.Enums.TLSErrorsPolicy), MonadIO m, IsWebContext a) => O.MethodInfo WebContextGetTlsErrorsPolicyMethodInfo a signature where
    overloadedMethod _ = webContextGetTlsErrorsPolicy

#endif

-- method WebContext::get_web_process_count_limit
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "WebKit2", name = "WebContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #WebKitWebContext", 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_web_context_get_web_process_count_limit" webkit_web_context_get_web_process_count_limit ::
    Ptr WebContext ->                       -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"})
    IO Word32

{- |
Gets the maximum number of web processes that can be created at the same time for the /@context@/.

/Since: 2.10/
-}
webContextGetWebProcessCountLimit ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) =>
    a
    {- ^ /@context@/: the 'GI.WebKit2.Objects.WebContext.WebContext' -}
    -> m Word32
    {- ^ __Returns:__ the maximum limit of web processes, or 0 if there isn\'t a limit. -}
webContextGetWebProcessCountLimit context = liftIO $ do
    context' <- unsafeManagedPtrCastPtr context
    result <- webkit_web_context_get_web_process_count_limit context'
    touchManagedPtr context
    return result

#if ENABLE_OVERLOADING
data WebContextGetWebProcessCountLimitMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsWebContext a) => O.MethodInfo WebContextGetWebProcessCountLimitMethodInfo a signature where
    overloadedMethod _ = webContextGetWebProcessCountLimit

#endif

-- method WebContext::get_website_data_manager
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "WebKit2", name = "WebContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #WebKitWebContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "WebsiteDataManager"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_context_get_website_data_manager" webkit_web_context_get_website_data_manager ::
    Ptr WebContext ->                       -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"})
    IO (Ptr WebKit2.WebsiteDataManager.WebsiteDataManager)

{- |
Get the 'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager' of /@context@/.

/Since: 2.10/
-}
webContextGetWebsiteDataManager ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) =>
    a
    {- ^ /@context@/: the 'GI.WebKit2.Objects.WebContext.WebContext' -}
    -> m WebKit2.WebsiteDataManager.WebsiteDataManager
    {- ^ __Returns:__ a 'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager' -}
webContextGetWebsiteDataManager context = liftIO $ do
    context' <- unsafeManagedPtrCastPtr context
    result <- webkit_web_context_get_website_data_manager context'
    checkUnexpectedReturnNULL "webContextGetWebsiteDataManager" result
    result' <- (newObject WebKit2.WebsiteDataManager.WebsiteDataManager) result
    touchManagedPtr context
    return result'

#if ENABLE_OVERLOADING
data WebContextGetWebsiteDataManagerMethodInfo
instance (signature ~ (m WebKit2.WebsiteDataManager.WebsiteDataManager), MonadIO m, IsWebContext a) => O.MethodInfo WebContextGetWebsiteDataManagerMethodInfo a signature where
    overloadedMethod _ = webContextGetWebsiteDataManager

#endif

-- method WebContext::initialize_notification_permissions
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "WebKit2", name = "WebContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #WebKitWebContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "allowed_origins", argType = TGList (TInterface (Name {namespace = "WebKit2", name = "SecurityOrigin"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GList of security origins", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "disallowed_origins", argType = TGList (TInterface (Name {namespace = "WebKit2", name = "SecurityOrigin"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GList of security origins", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_context_initialize_notification_permissions" webkit_web_context_initialize_notification_permissions ::
    Ptr WebContext ->                       -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"})
    Ptr (GList (Ptr WebKit2.SecurityOrigin.SecurityOrigin)) -> -- allowed_origins : TGList (TInterface (Name {namespace = "WebKit2", name = "SecurityOrigin"}))
    Ptr (GList (Ptr WebKit2.SecurityOrigin.SecurityOrigin)) -> -- disallowed_origins : TGList (TInterface (Name {namespace = "WebKit2", name = "SecurityOrigin"}))
    IO ()

{- |
Sets initial desktop notification permissions for the /@context@/.
/@allowedOrigins@/ and /@disallowedOrigins@/ must each be 'GI.GLib.Structs.List.List' of
'GI.WebKit2.Structs.SecurityOrigin.SecurityOrigin' objects representing origins that will,
respectively, either always or never have permission to show desktop
notifications. No 'GI.WebKit2.Objects.NotificationPermissionRequest.NotificationPermissionRequest' will ever be
generated for any of the security origins represented in
/@allowedOrigins@/ or /@disallowedOrigins@/. This function is necessary
because some webpages proactively check whether they have permission
to display notifications without ever creating a permission request.

This function only affects web processes that have not already been
created. The best time to call it is when handling
'GI.WebKit2.Objects.WebContext.WebContext'::@/initialize-notification-permissions/@ so as to
ensure that new web processes receive the most recent set of
permissions.

/Since: 2.16/
-}
webContextInitializeNotificationPermissions ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) =>
    a
    {- ^ /@context@/: the 'GI.WebKit2.Objects.WebContext.WebContext' -}
    -> [WebKit2.SecurityOrigin.SecurityOrigin]
    {- ^ /@allowedOrigins@/: a 'GI.GLib.Structs.List.List' of security origins -}
    -> [WebKit2.SecurityOrigin.SecurityOrigin]
    {- ^ /@disallowedOrigins@/: a 'GI.GLib.Structs.List.List' of security origins -}
    -> m ()
webContextInitializeNotificationPermissions context allowedOrigins disallowedOrigins = liftIO $ do
    context' <- unsafeManagedPtrCastPtr context
    allowedOrigins' <- mapM unsafeManagedPtrGetPtr allowedOrigins
    allowedOrigins'' <- packGList allowedOrigins'
    disallowedOrigins' <- mapM unsafeManagedPtrGetPtr disallowedOrigins
    disallowedOrigins'' <- packGList disallowedOrigins'
    webkit_web_context_initialize_notification_permissions context' allowedOrigins'' disallowedOrigins''
    touchManagedPtr context
    mapM_ touchManagedPtr allowedOrigins
    mapM_ touchManagedPtr disallowedOrigins
    g_list_free allowedOrigins''
    g_list_free disallowedOrigins''
    return ()

#if ENABLE_OVERLOADING
data WebContextInitializeNotificationPermissionsMethodInfo
instance (signature ~ ([WebKit2.SecurityOrigin.SecurityOrigin] -> [WebKit2.SecurityOrigin.SecurityOrigin] -> m ()), MonadIO m, IsWebContext a) => O.MethodInfo WebContextInitializeNotificationPermissionsMethodInfo a signature where
    overloadedMethod _ = webContextInitializeNotificationPermissions

#endif

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

foreign import ccall "webkit_web_context_is_automation_allowed" webkit_web_context_is_automation_allowed ::
    Ptr WebContext ->                       -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"})
    IO CInt

{- |
Get whether automation is allowed in /@context@/.
See also 'GI.WebKit2.Objects.WebContext.webContextSetAutomationAllowed'.

/Since: 2.18/
-}
webContextIsAutomationAllowed ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) =>
    a
    {- ^ /@context@/: the 'GI.WebKit2.Objects.WebContext.WebContext' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if automation is allowed or 'False' otherwise. -}
webContextIsAutomationAllowed context = liftIO $ do
    context' <- unsafeManagedPtrCastPtr context
    result <- webkit_web_context_is_automation_allowed context'
    let result' = (/= 0) result
    touchManagedPtr context
    return result'

#if ENABLE_OVERLOADING
data WebContextIsAutomationAllowedMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWebContext a) => O.MethodInfo WebContextIsAutomationAllowedMethodInfo a signature where
    overloadedMethod _ = webContextIsAutomationAllowed

#endif

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

foreign import ccall "webkit_web_context_is_ephemeral" webkit_web_context_is_ephemeral ::
    Ptr WebContext ->                       -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"})
    IO CInt

{- |
Get whether a 'GI.WebKit2.Objects.WebContext.WebContext' is ephemeral.

/Since: 2.16/
-}
webContextIsEphemeral ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) =>
    a
    {- ^ /@context@/: the 'GI.WebKit2.Objects.WebContext.WebContext' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if /@context@/ is ephemeral or 'False' otherwise. -}
webContextIsEphemeral context = liftIO $ do
    context' <- unsafeManagedPtrCastPtr context
    result <- webkit_web_context_is_ephemeral context'
    let result' = (/= 0) result
    touchManagedPtr context
    return result'

#if ENABLE_OVERLOADING
data WebContextIsEphemeralMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWebContext a) => O.MethodInfo WebContextIsEphemeralMethodInfo a signature where
    overloadedMethod _ = webContextIsEphemeral

#endif

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

foreign import ccall "webkit_web_context_prefetch_dns" webkit_web_context_prefetch_dns ::
    Ptr WebContext ->                       -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"})
    CString ->                              -- hostname : TBasicType TUTF8
    IO ()

{- |
Resolve the domain name of the given /@hostname@/ in advance, so that if a URI
of /@hostname@/ is requested the load will be performed more quickly.
-}
webContextPrefetchDns ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) =>
    a
    {- ^ /@context@/: a 'GI.WebKit2.Objects.WebContext.WebContext' -}
    -> T.Text
    {- ^ /@hostname@/: a hostname to be resolved -}
    -> m ()
webContextPrefetchDns context hostname = liftIO $ do
    context' <- unsafeManagedPtrCastPtr context
    hostname' <- textToCString hostname
    webkit_web_context_prefetch_dns context' hostname'
    touchManagedPtr context
    freeMem hostname'
    return ()

#if ENABLE_OVERLOADING
data WebContextPrefetchDnsMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsWebContext a) => O.MethodInfo WebContextPrefetchDnsMethodInfo a signature where
    overloadedMethod _ = webContextPrefetchDns

#endif

-- method WebContext::register_uri_scheme
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "WebKit2", name = "WebContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "scheme", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the network scheme to register", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "WebKit2", name = "URISchemeRequestCallback"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitURISchemeRequestCallback", sinceVersion = Nothing}, argScope = ScopeTypeNotified, argClosure = 3, argDestroy = 4, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "data to pass to callback function", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data_destroy_func", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "destroy notify for @user_data", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_context_register_uri_scheme" webkit_web_context_register_uri_scheme ::
    Ptr WebContext ->                       -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"})
    CString ->                              -- scheme : TBasicType TUTF8
    FunPtr WebKit2.Callbacks.C_URISchemeRequestCallback -> -- callback : TInterface (Name {namespace = "WebKit2", name = "URISchemeRequestCallback"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    FunPtr GLib.Callbacks.C_DestroyNotify -> -- user_data_destroy_func : TInterface (Name {namespace = "GLib", name = "DestroyNotify"})
    IO ()

{- |
Register /@scheme@/ in /@context@/, so that when an URI request with /@scheme@/ is made in the
'GI.WebKit2.Objects.WebContext.WebContext', the 'GI.WebKit2.Callbacks.URISchemeRequestCallback' registered will be called with a
'GI.WebKit2.Objects.URISchemeRequest.URISchemeRequest'.
It is possible to handle URI scheme requests asynchronously, by calling 'GI.GObject.Objects.Object.objectRef' on the
'GI.WebKit2.Objects.URISchemeRequest.URISchemeRequest' and calling 'GI.WebKit2.Objects.URISchemeRequest.uRISchemeRequestFinish' later
when the data of the request is available or
'GI.WebKit2.Objects.URISchemeRequest.uRISchemeRequestFinishError' in case of error.

\<informalexample>\<programlisting>
static void
about_uri_scheme_request_cb (WebKitURISchemeRequest *request,
                             gpointer                user_data)
{
    GInputStream *stream;
    gsize         stream_length;
    const gchar  *path;

    path = webkit_uri_scheme_request_get_path (request);
    if (!g_strcmp0 (path, \"plugins\")) {
        \/\<!-- -->* Create a GInputStream with the contents of plugins about page, and set its length to stream_length *\<!-- -->\/
    } else if (!g_strcmp0 (path, \"memory\")) {
        \/\<!-- -->* Create a GInputStream with the contents of memory about page, and set its length to stream_length *\<!-- -->\/
    } else if (!g_strcmp0 (path, \"applications\")) {
        \/\<!-- -->* Create a GInputStream with the contents of applications about page, and set its length to stream_length *\<!-- -->\/
    } else if (!g_strcmp0 (path, \"example\")) {
        gchar *contents;

        contents = g_strdup_printf (\"&lt;html&gt;&lt;body&gt;&lt;p&gt;Example about page&lt;\/p&gt;&lt;\/body&gt;&lt;\/html&gt;\");
        stream_length = strlen (contents);
        stream = g_memory_input_stream_new_from_data (contents, stream_length, g_free);
    } else {
        GError *error;

        error = g_error_new (ABOUT_HANDLER_ERROR, ABOUT_HANDLER_ERROR_INVALID, \"Invalid about:@/s/@ page.\", path);
        webkit_uri_scheme_request_finish_error (request, error);
        g_error_free (error);
        return;
    }
    webkit_uri_scheme_request_finish (request, stream, stream_length, \"text\/html\");
    g_object_unref (stream);
}
\<\/programlisting>\<\/informalexample>
-}
webContextRegisterUriScheme ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) =>
    a
    {- ^ /@context@/: a 'GI.WebKit2.Objects.WebContext.WebContext' -}
    -> T.Text
    {- ^ /@scheme@/: the network scheme to register -}
    -> WebKit2.Callbacks.URISchemeRequestCallback
    {- ^ /@callback@/: a 'GI.WebKit2.Callbacks.URISchemeRequestCallback' -}
    -> m ()
webContextRegisterUriScheme context scheme callback = liftIO $ do
    context' <- unsafeManagedPtrCastPtr context
    scheme' <- textToCString scheme
    callback' <- WebKit2.Callbacks.mk_URISchemeRequestCallback (WebKit2.Callbacks.wrap_URISchemeRequestCallback Nothing (WebKit2.Callbacks.drop_closures_URISchemeRequestCallback callback))
    let userData = castFunPtrToPtr callback'
    let userDataDestroyFunc = safeFreeFunPtrPtr
    webkit_web_context_register_uri_scheme context' scheme' callback' userData userDataDestroyFunc
    touchManagedPtr context
    freeMem scheme'
    return ()

#if ENABLE_OVERLOADING
data WebContextRegisterUriSchemeMethodInfo
instance (signature ~ (T.Text -> WebKit2.Callbacks.URISchemeRequestCallback -> m ()), MonadIO m, IsWebContext a) => O.MethodInfo WebContextRegisterUriSchemeMethodInfo a signature where
    overloadedMethod _ = webContextRegisterUriScheme

#endif

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

foreign import ccall "webkit_web_context_set_additional_plugins_directory" webkit_web_context_set_additional_plugins_directory ::
    Ptr WebContext ->                       -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"})
    CString ->                              -- directory : TBasicType TUTF8
    IO ()

{- |
Set an additional directory where WebKit will look for plugins.
-}
webContextSetAdditionalPluginsDirectory ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) =>
    a
    {- ^ /@context@/: a 'GI.WebKit2.Objects.WebContext.WebContext' -}
    -> T.Text
    {- ^ /@directory@/: the directory to add -}
    -> m ()
webContextSetAdditionalPluginsDirectory context directory = liftIO $ do
    context' <- unsafeManagedPtrCastPtr context
    directory' <- textToCString directory
    webkit_web_context_set_additional_plugins_directory context' directory'
    touchManagedPtr context
    freeMem directory'
    return ()

#if ENABLE_OVERLOADING
data WebContextSetAdditionalPluginsDirectoryMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsWebContext a) => O.MethodInfo WebContextSetAdditionalPluginsDirectoryMethodInfo a signature where
    overloadedMethod _ = webContextSetAdditionalPluginsDirectory

#endif

-- method WebContext::set_automation_allowed
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "WebKit2", name = "WebContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #WebKitWebContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "allowed", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "value to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_context_set_automation_allowed" webkit_web_context_set_automation_allowed ::
    Ptr WebContext ->                       -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"})
    CInt ->                                 -- allowed : TBasicType TBoolean
    IO ()

{- |
Set whether automation is allowed in /@context@/. When automation is enabled the browser could
be controlled by another process by requesting an automation session. When a new automation
session is requested the signal 'GI.WebKit2.Objects.WebContext.WebContext'::@/automation-started/@ is emitted.
Automation is disabled by default, so you need to explicitly call this method passing 'True'
to enable it.

Note that only one 'GI.WebKit2.Objects.WebContext.WebContext' can have automation enabled, so this will do nothing
if there\'s another 'GI.WebKit2.Objects.WebContext.WebContext' with automation already enabled.

/Since: 2.18/
-}
webContextSetAutomationAllowed ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) =>
    a
    {- ^ /@context@/: the 'GI.WebKit2.Objects.WebContext.WebContext' -}
    -> Bool
    {- ^ /@allowed@/: value to set -}
    -> m ()
webContextSetAutomationAllowed context allowed = liftIO $ do
    context' <- unsafeManagedPtrCastPtr context
    let allowed' = (fromIntegral . fromEnum) allowed
    webkit_web_context_set_automation_allowed context' allowed'
    touchManagedPtr context
    return ()

#if ENABLE_OVERLOADING
data WebContextSetAutomationAllowedMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsWebContext a) => O.MethodInfo WebContextSetAutomationAllowedMethodInfo a signature where
    overloadedMethod _ = webContextSetAutomationAllowed

#endif

-- method WebContext::set_cache_model
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "WebKit2", name = "WebContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #WebKitWebContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cache_model", argType = TInterface (Name {namespace = "WebKit2", name = "CacheModel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitCacheModel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_context_set_cache_model" webkit_web_context_set_cache_model ::
    Ptr WebContext ->                       -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"})
    CUInt ->                                -- cache_model : TInterface (Name {namespace = "WebKit2", name = "CacheModel"})
    IO ()

{- |
Specifies a usage model for WebViews, which WebKit will use to
determine its caching behavior. All web views follow the cache
model. This cache model determines the RAM and disk space to use
for caching previously viewed content .

Research indicates that users tend to browse within clusters of
documents that hold resources in common, and to revisit previously
visited documents. WebKit and the frameworks below it include
built-in caches that take advantage of these patterns,
substantially improving document load speed in browsing
situations. The WebKit cache model controls the behaviors of all of
these caches, including various WebCore caches.

Browsers can improve document load speed substantially by
specifying 'GI.WebKit2.Enums.CacheModelWebBrowser'. Applications without a
browsing interface can reduce memory usage substantially by
specifying 'GI.WebKit2.Enums.CacheModelDocumentViewer'. The default value is
'GI.WebKit2.Enums.CacheModelWebBrowser'.
-}
webContextSetCacheModel ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) =>
    a
    {- ^ /@context@/: the 'GI.WebKit2.Objects.WebContext.WebContext' -}
    -> WebKit2.Enums.CacheModel
    {- ^ /@cacheModel@/: a 'GI.WebKit2.Enums.CacheModel' -}
    -> m ()
webContextSetCacheModel context cacheModel = liftIO $ do
    context' <- unsafeManagedPtrCastPtr context
    let cacheModel' = (fromIntegral . fromEnum) cacheModel
    webkit_web_context_set_cache_model context' cacheModel'
    touchManagedPtr context
    return ()

#if ENABLE_OVERLOADING
data WebContextSetCacheModelMethodInfo
instance (signature ~ (WebKit2.Enums.CacheModel -> m ()), MonadIO m, IsWebContext a) => O.MethodInfo WebContextSetCacheModelMethodInfo a signature where
    overloadedMethod _ = webContextSetCacheModel

#endif

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

foreign import ccall "webkit_web_context_set_disk_cache_directory" webkit_web_context_set_disk_cache_directory ::
    Ptr WebContext ->                       -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"})
    CString ->                              -- directory : TBasicType TUTF8
    IO ()

{-# DEPRECATED webContextSetDiskCacheDirectory ["(Since version 2.10.)","Use 'GI.WebKit2.Objects.WebContext.webContextNewWithWebsiteDataManager' instead."] #-}
{- |
Set the directory where disk cache files will be stored
This method must be called before loading anything in this context, otherwise
it will not have any effect.

Note that this method overrides the directory set in the 'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager',
but it doesn\'t change the value returned by 'GI.WebKit2.Objects.WebsiteDataManager.websiteDataManagerGetDiskCacheDirectory'
since the 'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager' is immutable.
-}
webContextSetDiskCacheDirectory ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) =>
    a
    {- ^ /@context@/: a 'GI.WebKit2.Objects.WebContext.WebContext' -}
    -> T.Text
    {- ^ /@directory@/: the directory to set -}
    -> m ()
webContextSetDiskCacheDirectory context directory = liftIO $ do
    context' <- unsafeManagedPtrCastPtr context
    directory' <- textToCString directory
    webkit_web_context_set_disk_cache_directory context' directory'
    touchManagedPtr context
    freeMem directory'
    return ()

#if ENABLE_OVERLOADING
data WebContextSetDiskCacheDirectoryMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsWebContext a) => O.MethodInfo WebContextSetDiskCacheDirectoryMethodInfo a signature where
    overloadedMethod _ = webContextSetDiskCacheDirectory

#endif

-- method WebContext::set_favicon_database_directory
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "WebKit2", name = "WebContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "an absolute path to the icon database\ndirectory or %NULL to use the defaults", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_context_set_favicon_database_directory" webkit_web_context_set_favicon_database_directory ::
    Ptr WebContext ->                       -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"})
    CString ->                              -- path : TBasicType TUTF8
    IO ()

{- |
Set the directory path to be used to store the favicons database
for /@context@/ on disk. Passing 'Nothing' as /@path@/ means using the
default directory for the platform (see 'GI.GLib.Functions.getUserCacheDir').

Calling this method also means enabling the favicons database for
its use from the applications, so that\'s why it\'s expected to be
called only once. Further calls for the same instance of
'GI.WebKit2.Objects.WebContext.WebContext' won\'t cause any effect.
-}
webContextSetFaviconDatabaseDirectory ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) =>
    a
    {- ^ /@context@/: a 'GI.WebKit2.Objects.WebContext.WebContext' -}
    -> Maybe (T.Text)
    {- ^ /@path@/: an absolute path to the icon database
directory or 'Nothing' to use the defaults -}
    -> m ()
webContextSetFaviconDatabaseDirectory context path = liftIO $ do
    context' <- unsafeManagedPtrCastPtr context
    maybePath <- case path of
        Nothing -> return nullPtr
        Just jPath -> do
            jPath' <- textToCString jPath
            return jPath'
    webkit_web_context_set_favicon_database_directory context' maybePath
    touchManagedPtr context
    freeMem maybePath
    return ()

#if ENABLE_OVERLOADING
data WebContextSetFaviconDatabaseDirectoryMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsWebContext a) => O.MethodInfo WebContextSetFaviconDatabaseDirectoryMethodInfo a signature where
    overloadedMethod _ = webContextSetFaviconDatabaseDirectory

#endif

-- method WebContext::set_network_proxy_settings
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "WebKit2", name = "WebContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "proxy_mode", argType = TInterface (Name {namespace = "WebKit2", name = "NetworkProxyMode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitNetworkProxyMode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "proxy_settings", argType = TInterface (Name {namespace = "WebKit2", name = "NetworkProxySettings"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #WebKitNetworkProxySettings, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_context_set_network_proxy_settings" webkit_web_context_set_network_proxy_settings ::
    Ptr WebContext ->                       -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"})
    CUInt ->                                -- proxy_mode : TInterface (Name {namespace = "WebKit2", name = "NetworkProxyMode"})
    Ptr WebKit2.NetworkProxySettings.NetworkProxySettings -> -- proxy_settings : TInterface (Name {namespace = "WebKit2", name = "NetworkProxySettings"})
    IO ()

{- |
Set the network proxy settings to be used by connections started in /@context@/.
By default 'GI.WebKit2.Enums.NetworkProxyModeDefault' is used, which means that the
system settings will be used ('GI.Gio.Functions.proxyResolverGetDefault').
If you want to override the system default settings, you can either use
'GI.WebKit2.Enums.NetworkProxyModeNoProxy' to make sure no proxies are used at all,
or 'GI.WebKit2.Enums.NetworkProxyModeCustom' to provide your own proxy settings.
When /@proxyMode@/ is 'GI.WebKit2.Enums.NetworkProxyModeCustom' /@proxySettings@/ must be
a valid 'GI.WebKit2.Structs.NetworkProxySettings.NetworkProxySettings'; otherwise, /@proxySettings@/ must be 'Nothing'.

/Since: 2.16/
-}
webContextSetNetworkProxySettings ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) =>
    a
    {- ^ /@context@/: a 'GI.WebKit2.Objects.WebContext.WebContext' -}
    -> WebKit2.Enums.NetworkProxyMode
    {- ^ /@proxyMode@/: a 'GI.WebKit2.Enums.NetworkProxyMode' -}
    -> Maybe (WebKit2.NetworkProxySettings.NetworkProxySettings)
    {- ^ /@proxySettings@/: a 'GI.WebKit2.Structs.NetworkProxySettings.NetworkProxySettings', or 'Nothing' -}
    -> m ()
webContextSetNetworkProxySettings context proxyMode proxySettings = liftIO $ do
    context' <- unsafeManagedPtrCastPtr context
    let proxyMode' = (fromIntegral . fromEnum) proxyMode
    maybeProxySettings <- case proxySettings of
        Nothing -> return nullPtr
        Just jProxySettings -> do
            jProxySettings' <- unsafeManagedPtrGetPtr jProxySettings
            return jProxySettings'
    webkit_web_context_set_network_proxy_settings context' proxyMode' maybeProxySettings
    touchManagedPtr context
    whenJust proxySettings touchManagedPtr
    return ()

#if ENABLE_OVERLOADING
data WebContextSetNetworkProxySettingsMethodInfo
instance (signature ~ (WebKit2.Enums.NetworkProxyMode -> Maybe (WebKit2.NetworkProxySettings.NetworkProxySettings) -> m ()), MonadIO m, IsWebContext a) => O.MethodInfo WebContextSetNetworkProxySettingsMethodInfo a signature where
    overloadedMethod _ = webContextSetNetworkProxySettings

#endif

-- method WebContext::set_preferred_languages
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "WebKit2", name = "WebContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "languages", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a %NULL-terminated list of language identifiers", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_context_set_preferred_languages" webkit_web_context_set_preferred_languages ::
    Ptr WebContext ->                       -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"})
    Ptr CString ->                          -- languages : TCArray True (-1) (-1) (TBasicType TUTF8)
    IO ()

{- |
Set the list of preferred languages, sorted from most desirable
to least desirable. The list will be used to build the \"Accept-Language\"
header that will be included in the network requests started by
the 'GI.WebKit2.Objects.WebContext.WebContext'.
-}
webContextSetPreferredLanguages ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) =>
    a
    {- ^ /@context@/: a 'GI.WebKit2.Objects.WebContext.WebContext' -}
    -> Maybe ([T.Text])
    {- ^ /@languages@/: a 'Nothing'-terminated list of language identifiers -}
    -> m ()
webContextSetPreferredLanguages context languages = liftIO $ do
    context' <- unsafeManagedPtrCastPtr context
    maybeLanguages <- case languages of
        Nothing -> return nullPtr
        Just jLanguages -> do
            jLanguages' <- packZeroTerminatedUTF8CArray jLanguages
            return jLanguages'
    webkit_web_context_set_preferred_languages context' maybeLanguages
    touchManagedPtr context
    mapZeroTerminatedCArray freeMem maybeLanguages
    freeMem maybeLanguages
    return ()

#if ENABLE_OVERLOADING
data WebContextSetPreferredLanguagesMethodInfo
instance (signature ~ (Maybe ([T.Text]) -> m ()), MonadIO m, IsWebContext a) => O.MethodInfo WebContextSetPreferredLanguagesMethodInfo a signature where
    overloadedMethod _ = webContextSetPreferredLanguages

#endif

-- method WebContext::set_process_model
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "WebKit2", name = "WebContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #WebKitWebContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "process_model", argType = TInterface (Name {namespace = "WebKit2", name = "ProcessModel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitProcessModel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_context_set_process_model" webkit_web_context_set_process_model ::
    Ptr WebContext ->                       -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"})
    CUInt ->                                -- process_model : TInterface (Name {namespace = "WebKit2", name = "ProcessModel"})
    IO ()

{- |
Specifies a process model for WebViews, which WebKit will use to
determine how auxiliary processes are handled. The default setting
('GI.WebKit2.Enums.ProcessModelSharedSecondaryProcess') is suitable for most
applications which embed a small amount of WebViews, or are used to
display documents which are considered safe — like local files.

Applications which may potentially use a large amount of WebViews
—for example a multi-tabbed web browser— may want to use
'GI.WebKit2.Enums.ProcessModelMultipleSecondaryProcesses', which will use
one process per view most of the time, while still allowing for web
views to share a process when needed (for example when different
views interact with each other). Using this model, when a process
hangs or crashes, only the WebViews using it stop working, while
the rest of the WebViews in the application will still function
normally.

This method **must be called before any web process has been created**,
as early as possible in your application. Calling it later will make
your application crash.

/Since: 2.4/
-}
webContextSetProcessModel ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) =>
    a
    {- ^ /@context@/: the 'GI.WebKit2.Objects.WebContext.WebContext' -}
    -> WebKit2.Enums.ProcessModel
    {- ^ /@processModel@/: a 'GI.WebKit2.Enums.ProcessModel' -}
    -> m ()
webContextSetProcessModel context processModel = liftIO $ do
    context' <- unsafeManagedPtrCastPtr context
    let processModel' = (fromIntegral . fromEnum) processModel
    webkit_web_context_set_process_model context' processModel'
    touchManagedPtr context
    return ()

#if ENABLE_OVERLOADING
data WebContextSetProcessModelMethodInfo
instance (signature ~ (WebKit2.Enums.ProcessModel -> m ()), MonadIO m, IsWebContext a) => O.MethodInfo WebContextSetProcessModelMethodInfo a signature where
    overloadedMethod _ = webContextSetProcessModel

#endif

-- method WebContext::set_spell_checking_enabled
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "WebKit2", name = "WebContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Value to be set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_context_set_spell_checking_enabled" webkit_web_context_set_spell_checking_enabled ::
    Ptr WebContext ->                       -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"})
    CInt ->                                 -- enabled : TBasicType TBoolean
    IO ()

{- |
Enable or disable the spell checking feature.
-}
webContextSetSpellCheckingEnabled ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) =>
    a
    {- ^ /@context@/: a 'GI.WebKit2.Objects.WebContext.WebContext' -}
    -> Bool
    {- ^ /@enabled@/: Value to be set -}
    -> m ()
webContextSetSpellCheckingEnabled context enabled = liftIO $ do
    context' <- unsafeManagedPtrCastPtr context
    let enabled' = (fromIntegral . fromEnum) enabled
    webkit_web_context_set_spell_checking_enabled context' enabled'
    touchManagedPtr context
    return ()

#if ENABLE_OVERLOADING
data WebContextSetSpellCheckingEnabledMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsWebContext a) => O.MethodInfo WebContextSetSpellCheckingEnabledMethodInfo a signature where
    overloadedMethod _ = webContextSetSpellCheckingEnabled

#endif

-- method WebContext::set_spell_checking_languages
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "WebKit2", name = "WebContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "languages", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a %NULL-terminated list of spell checking languages", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_context_set_spell_checking_languages" webkit_web_context_set_spell_checking_languages ::
    Ptr WebContext ->                       -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"})
    Ptr CString ->                          -- languages : TCArray True (-1) (-1) (TBasicType TUTF8)
    IO ()

{- |
Set the list of spell checking languages to be used for spell
checking.

The locale string typically is in the form lang_COUNTRY, where lang
is an ISO-639 language code, and COUNTRY is an ISO-3166 country code.
For instance, sv_FI for Swedish as written in Finland or pt_BR
for Portuguese as written in Brazil.

You need to call this function with a valid list of languages at
least once in order to properly enable the spell checking feature
in WebKit.
-}
webContextSetSpellCheckingLanguages ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) =>
    a
    {- ^ /@context@/: a 'GI.WebKit2.Objects.WebContext.WebContext' -}
    -> [T.Text]
    {- ^ /@languages@/: a 'Nothing'-terminated list of spell checking languages -}
    -> m ()
webContextSetSpellCheckingLanguages context languages = liftIO $ do
    context' <- unsafeManagedPtrCastPtr context
    languages' <- packZeroTerminatedUTF8CArray languages
    webkit_web_context_set_spell_checking_languages context' languages'
    touchManagedPtr context
    mapZeroTerminatedCArray freeMem languages'
    freeMem languages'
    return ()

#if ENABLE_OVERLOADING
data WebContextSetSpellCheckingLanguagesMethodInfo
instance (signature ~ ([T.Text] -> m ()), MonadIO m, IsWebContext a) => O.MethodInfo WebContextSetSpellCheckingLanguagesMethodInfo a signature where
    overloadedMethod _ = webContextSetSpellCheckingLanguages

#endif

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

foreign import ccall "webkit_web_context_set_tls_errors_policy" webkit_web_context_set_tls_errors_policy ::
    Ptr WebContext ->                       -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"})
    CUInt ->                                -- policy : TInterface (Name {namespace = "WebKit2", name = "TLSErrorsPolicy"})
    IO ()

{- |
Set the TLS errors policy of /@context@/ as /@policy@/
-}
webContextSetTlsErrorsPolicy ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) =>
    a
    {- ^ /@context@/: a 'GI.WebKit2.Objects.WebContext.WebContext' -}
    -> WebKit2.Enums.TLSErrorsPolicy
    {- ^ /@policy@/: a 'GI.WebKit2.Enums.TLSErrorsPolicy' -}
    -> m ()
webContextSetTlsErrorsPolicy context policy = liftIO $ do
    context' <- unsafeManagedPtrCastPtr context
    let policy' = (fromIntegral . fromEnum) policy
    webkit_web_context_set_tls_errors_policy context' policy'
    touchManagedPtr context
    return ()

#if ENABLE_OVERLOADING
data WebContextSetTlsErrorsPolicyMethodInfo
instance (signature ~ (WebKit2.Enums.TLSErrorsPolicy -> m ()), MonadIO m, IsWebContext a) => O.MethodInfo WebContextSetTlsErrorsPolicyMethodInfo a signature where
    overloadedMethod _ = webContextSetTlsErrorsPolicy

#endif

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

foreign import ccall "webkit_web_context_set_web_extensions_directory" webkit_web_context_set_web_extensions_directory ::
    Ptr WebContext ->                       -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"})
    CString ->                              -- directory : TBasicType TUTF8
    IO ()

{- |
Set the directory where WebKit will look for Web Extensions.
This method must be called before loading anything in this context,
otherwise it will not have any effect. You can connect to
'GI.WebKit2.Objects.WebContext.WebContext'::@/initialize-web-extensions/@ to call this method
before anything is loaded.
-}
webContextSetWebExtensionsDirectory ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) =>
    a
    {- ^ /@context@/: a 'GI.WebKit2.Objects.WebContext.WebContext' -}
    -> T.Text
    {- ^ /@directory@/: the directory to add -}
    -> m ()
webContextSetWebExtensionsDirectory context directory = liftIO $ do
    context' <- unsafeManagedPtrCastPtr context
    directory' <- textToCString directory
    webkit_web_context_set_web_extensions_directory context' directory'
    touchManagedPtr context
    freeMem directory'
    return ()

#if ENABLE_OVERLOADING
data WebContextSetWebExtensionsDirectoryMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsWebContext a) => O.MethodInfo WebContextSetWebExtensionsDirectoryMethodInfo a signature where
    overloadedMethod _ = webContextSetWebExtensionsDirectory

#endif

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

foreign import ccall "webkit_web_context_set_web_extensions_initialization_user_data" webkit_web_context_set_web_extensions_initialization_user_data ::
    Ptr WebContext ->                       -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"})
    Ptr GVariant ->                         -- user_data : TVariant
    IO ()

{- |
Set user data to be passed to Web Extensions on initialization.
The data will be passed to the
@/WebKitWebExtensionInitializeWithUserDataFunction/@.
This method must be called before loading anything in this context,
otherwise it will not have any effect. You can connect to
'GI.WebKit2.Objects.WebContext.WebContext'::@/initialize-web-extensions/@ to call this method
before anything is loaded.

/Since: 2.4/
-}
webContextSetWebExtensionsInitializationUserData ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) =>
    a
    {- ^ /@context@/: a 'GI.WebKit2.Objects.WebContext.WebContext' -}
    -> GVariant
    {- ^ /@userData@/: a 'GVariant' -}
    -> m ()
webContextSetWebExtensionsInitializationUserData context userData = liftIO $ do
    context' <- unsafeManagedPtrCastPtr context
    userData' <- unsafeManagedPtrGetPtr userData
    webkit_web_context_set_web_extensions_initialization_user_data context' userData'
    touchManagedPtr context
    touchManagedPtr userData
    return ()

#if ENABLE_OVERLOADING
data WebContextSetWebExtensionsInitializationUserDataMethodInfo
instance (signature ~ (GVariant -> m ()), MonadIO m, IsWebContext a) => O.MethodInfo WebContextSetWebExtensionsInitializationUserDataMethodInfo a signature where
    overloadedMethod _ = webContextSetWebExtensionsInitializationUserData

#endif

-- method WebContext::set_web_process_count_limit
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "WebKit2", name = "WebContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #WebKitWebContext", 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 maximum number of web processes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_context_set_web_process_count_limit" webkit_web_context_set_web_process_count_limit ::
    Ptr WebContext ->                       -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"})
    Word32 ->                               -- limit : TBasicType TUInt
    IO ()

{- |
Sets the maximum number of web processes that can be created at the same time for the /@context@/.
The default value is 0 and means no limit.

This method **must be called before any web process has been created**,
as early as possible in your application. Calling it later will make
your application crash.

/Since: 2.10/
-}
webContextSetWebProcessCountLimit ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebContext a) =>
    a
    {- ^ /@context@/: the 'GI.WebKit2.Objects.WebContext.WebContext' -}
    -> Word32
    {- ^ /@limit@/: the maximum number of web processes -}
    -> m ()
webContextSetWebProcessCountLimit context limit = liftIO $ do
    context' <- unsafeManagedPtrCastPtr context
    webkit_web_context_set_web_process_count_limit context' limit
    touchManagedPtr context
    return ()

#if ENABLE_OVERLOADING
data WebContextSetWebProcessCountLimitMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsWebContext a) => O.MethodInfo WebContextSetWebProcessCountLimitMethodInfo a signature where
    overloadedMethod _ = webContextSetWebProcessCountLimit

#endif

-- method WebContext::get_default
-- method type : MemberFunction
-- Args : []
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "WebContext"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_context_get_default" webkit_web_context_get_default ::
    IO (Ptr WebContext)

{- |
Gets the default web context
-}
webContextGetDefault ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m WebContext
    {- ^ __Returns:__ a 'GI.WebKit2.Objects.WebContext.WebContext' -}
webContextGetDefault  = liftIO $ do
    result <- webkit_web_context_get_default
    checkUnexpectedReturnNULL "webContextGetDefault" result
    result' <- (newObject WebContext) result
    return result'

#if ENABLE_OVERLOADING
#endif