{-# LANGUAGE TypeApplications #-}


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

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

module GI.WebKit2.Objects.UserContentManager
    ( 

-- * Exported types
    UserContentManager(..)                  ,
    IsUserContentManager                    ,
    toUserContentManager                    ,


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

#if defined(ENABLE_OVERLOADING)
    ResolveUserContentManagerMethod         ,
#endif


-- ** addFilter #method:addFilter#

#if defined(ENABLE_OVERLOADING)
    UserContentManagerAddFilterMethodInfo   ,
#endif
    userContentManagerAddFilter             ,


-- ** addScript #method:addScript#

#if defined(ENABLE_OVERLOADING)
    UserContentManagerAddScriptMethodInfo   ,
#endif
    userContentManagerAddScript             ,


-- ** addStyleSheet #method:addStyleSheet#

#if defined(ENABLE_OVERLOADING)
    UserContentManagerAddStyleSheetMethodInfo,
#endif
    userContentManagerAddStyleSheet         ,


-- ** new #method:new#

    userContentManagerNew                   ,


-- ** registerScriptMessageHandler #method:registerScriptMessageHandler#

#if defined(ENABLE_OVERLOADING)
    UserContentManagerRegisterScriptMessageHandlerMethodInfo,
#endif
    userContentManagerRegisterScriptMessageHandler,


-- ** registerScriptMessageHandlerInWorld #method:registerScriptMessageHandlerInWorld#

#if defined(ENABLE_OVERLOADING)
    UserContentManagerRegisterScriptMessageHandlerInWorldMethodInfo,
#endif
    userContentManagerRegisterScriptMessageHandlerInWorld,


-- ** removeAllFilters #method:removeAllFilters#

#if defined(ENABLE_OVERLOADING)
    UserContentManagerRemoveAllFiltersMethodInfo,
#endif
    userContentManagerRemoveAllFilters      ,


-- ** removeAllScripts #method:removeAllScripts#

#if defined(ENABLE_OVERLOADING)
    UserContentManagerRemoveAllScriptsMethodInfo,
#endif
    userContentManagerRemoveAllScripts      ,


-- ** removeAllStyleSheets #method:removeAllStyleSheets#

#if defined(ENABLE_OVERLOADING)
    UserContentManagerRemoveAllStyleSheetsMethodInfo,
#endif
    userContentManagerRemoveAllStyleSheets  ,


-- ** removeFilter #method:removeFilter#

#if defined(ENABLE_OVERLOADING)
    UserContentManagerRemoveFilterMethodInfo,
#endif
    userContentManagerRemoveFilter          ,


-- ** removeFilterById #method:removeFilterById#

#if defined(ENABLE_OVERLOADING)
    UserContentManagerRemoveFilterByIdMethodInfo,
#endif
    userContentManagerRemoveFilterById      ,


-- ** unregisterScriptMessageHandler #method:unregisterScriptMessageHandler#

#if defined(ENABLE_OVERLOADING)
    UserContentManagerUnregisterScriptMessageHandlerMethodInfo,
#endif
    userContentManagerUnregisterScriptMessageHandler,


-- ** unregisterScriptMessageHandlerInWorld #method:unregisterScriptMessageHandlerInWorld#

#if defined(ENABLE_OVERLOADING)
    UserContentManagerUnregisterScriptMessageHandlerInWorldMethodInfo,
#endif
    userContentManagerUnregisterScriptMessageHandlerInWorld,




 -- * Signals
-- ** scriptMessageReceived #signal:scriptMessageReceived#

    C_UserContentManagerScriptMessageReceivedCallback,
    UserContentManagerScriptMessageReceivedCallback,
#if defined(ENABLE_OVERLOADING)
    UserContentManagerScriptMessageReceivedSignalInfo,
#endif
    afterUserContentManagerScriptMessageReceived,
    genClosure_UserContentManagerScriptMessageReceived,
    mk_UserContentManagerScriptMessageReceivedCallback,
    noUserContentManagerScriptMessageReceivedCallback,
    onUserContentManagerScriptMessageReceived,
    wrap_UserContentManagerScriptMessageReceivedCallback,




    ) 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.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL

import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.WebKit2.Structs.JavascriptResult as WebKit2.JavascriptResult
import {-# SOURCE #-} qualified GI.WebKit2.Structs.UserContentFilter as WebKit2.UserContentFilter
import {-# SOURCE #-} qualified GI.WebKit2.Structs.UserScript as WebKit2.UserScript
import {-# SOURCE #-} qualified GI.WebKit2.Structs.UserStyleSheet as WebKit2.UserStyleSheet

-- | Memory-managed wrapper type.
newtype UserContentManager = UserContentManager (SP.ManagedPtr UserContentManager)
    deriving (UserContentManager -> UserContentManager -> Bool
(UserContentManager -> UserContentManager -> Bool)
-> (UserContentManager -> UserContentManager -> Bool)
-> Eq UserContentManager
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UserContentManager -> UserContentManager -> Bool
$c/= :: UserContentManager -> UserContentManager -> Bool
== :: UserContentManager -> UserContentManager -> Bool
$c== :: UserContentManager -> UserContentManager -> Bool
Eq)

instance SP.ManagedPtrNewtype UserContentManager where
    toManagedPtr :: UserContentManager -> ManagedPtr UserContentManager
toManagedPtr (UserContentManager ManagedPtr UserContentManager
p) = ManagedPtr UserContentManager
p

foreign import ccall "webkit_user_content_manager_get_type"
    c_webkit_user_content_manager_get_type :: IO B.Types.GType

instance B.Types.TypedObject UserContentManager where
    glibType :: IO GType
glibType = IO GType
c_webkit_user_content_manager_get_type

instance B.Types.GObject UserContentManager

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

-- | Type class for types which can be safely cast to `UserContentManager`, for instance with `toUserContentManager`.
class (SP.GObject o, O.IsDescendantOf UserContentManager o) => IsUserContentManager o
instance (SP.GObject o, O.IsDescendantOf UserContentManager o) => IsUserContentManager o

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

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

#if defined(ENABLE_OVERLOADING)
type family ResolveUserContentManagerMethod (t :: Symbol) (o :: *) :: * where
    ResolveUserContentManagerMethod "addFilter" o = UserContentManagerAddFilterMethodInfo
    ResolveUserContentManagerMethod "addScript" o = UserContentManagerAddScriptMethodInfo
    ResolveUserContentManagerMethod "addStyleSheet" o = UserContentManagerAddStyleSheetMethodInfo
    ResolveUserContentManagerMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveUserContentManagerMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveUserContentManagerMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveUserContentManagerMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveUserContentManagerMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveUserContentManagerMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveUserContentManagerMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveUserContentManagerMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveUserContentManagerMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveUserContentManagerMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveUserContentManagerMethod "registerScriptMessageHandler" o = UserContentManagerRegisterScriptMessageHandlerMethodInfo
    ResolveUserContentManagerMethod "registerScriptMessageHandlerInWorld" o = UserContentManagerRegisterScriptMessageHandlerInWorldMethodInfo
    ResolveUserContentManagerMethod "removeAllFilters" o = UserContentManagerRemoveAllFiltersMethodInfo
    ResolveUserContentManagerMethod "removeAllScripts" o = UserContentManagerRemoveAllScriptsMethodInfo
    ResolveUserContentManagerMethod "removeAllStyleSheets" o = UserContentManagerRemoveAllStyleSheetsMethodInfo
    ResolveUserContentManagerMethod "removeFilter" o = UserContentManagerRemoveFilterMethodInfo
    ResolveUserContentManagerMethod "removeFilterById" o = UserContentManagerRemoveFilterByIdMethodInfo
    ResolveUserContentManagerMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveUserContentManagerMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveUserContentManagerMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveUserContentManagerMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveUserContentManagerMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveUserContentManagerMethod "unregisterScriptMessageHandler" o = UserContentManagerUnregisterScriptMessageHandlerMethodInfo
    ResolveUserContentManagerMethod "unregisterScriptMessageHandlerInWorld" o = UserContentManagerUnregisterScriptMessageHandlerInWorldMethodInfo
    ResolveUserContentManagerMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveUserContentManagerMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveUserContentManagerMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveUserContentManagerMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveUserContentManagerMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveUserContentManagerMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveUserContentManagerMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveUserContentManagerMethod l o = O.MethodResolutionFailed l o

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

#endif

-- signal UserContentManager::script-message-received
-- | This signal is emitted when JavaScript in a web view calls
-- \<code>window.webkit.messageHandlers.&lt;name&gt;.@/postMessage()/@\<\/code>, after registering
-- \<code>&lt;name&gt;\<\/code> using
-- 'GI.WebKit2.Objects.UserContentManager.userContentManagerRegisterScriptMessageHandler'
-- 
-- /Since: 2.8/
type UserContentManagerScriptMessageReceivedCallback =
    WebKit2.JavascriptResult.JavascriptResult
    -- ^ /@jsResult@/: the t'GI.WebKit2.Structs.JavascriptResult.JavascriptResult' holding the value received from the JavaScript world.
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `UserContentManagerScriptMessageReceivedCallback`@.
noUserContentManagerScriptMessageReceivedCallback :: Maybe UserContentManagerScriptMessageReceivedCallback
noUserContentManagerScriptMessageReceivedCallback :: Maybe UserContentManagerScriptMessageReceivedCallback
noUserContentManagerScriptMessageReceivedCallback = Maybe UserContentManagerScriptMessageReceivedCallback
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_UserContentManagerScriptMessageReceived :: MonadIO m => UserContentManagerScriptMessageReceivedCallback -> m (GClosure C_UserContentManagerScriptMessageReceivedCallback)
genClosure_UserContentManagerScriptMessageReceived :: UserContentManagerScriptMessageReceivedCallback
-> m (GClosure C_UserContentManagerScriptMessageReceivedCallback)
genClosure_UserContentManagerScriptMessageReceived UserContentManagerScriptMessageReceivedCallback
cb = IO (GClosure C_UserContentManagerScriptMessageReceivedCallback)
-> m (GClosure C_UserContentManagerScriptMessageReceivedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_UserContentManagerScriptMessageReceivedCallback)
 -> m (GClosure C_UserContentManagerScriptMessageReceivedCallback))
-> IO (GClosure C_UserContentManagerScriptMessageReceivedCallback)
-> m (GClosure C_UserContentManagerScriptMessageReceivedCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_UserContentManagerScriptMessageReceivedCallback
cb' = UserContentManagerScriptMessageReceivedCallback
-> C_UserContentManagerScriptMessageReceivedCallback
wrap_UserContentManagerScriptMessageReceivedCallback UserContentManagerScriptMessageReceivedCallback
cb
    C_UserContentManagerScriptMessageReceivedCallback
-> IO (FunPtr C_UserContentManagerScriptMessageReceivedCallback)
mk_UserContentManagerScriptMessageReceivedCallback C_UserContentManagerScriptMessageReceivedCallback
cb' IO (FunPtr C_UserContentManagerScriptMessageReceivedCallback)
-> (FunPtr C_UserContentManagerScriptMessageReceivedCallback
    -> IO (GClosure C_UserContentManagerScriptMessageReceivedCallback))
-> IO (GClosure C_UserContentManagerScriptMessageReceivedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_UserContentManagerScriptMessageReceivedCallback
-> IO (GClosure C_UserContentManagerScriptMessageReceivedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `UserContentManagerScriptMessageReceivedCallback` into a `C_UserContentManagerScriptMessageReceivedCallback`.
wrap_UserContentManagerScriptMessageReceivedCallback ::
    UserContentManagerScriptMessageReceivedCallback ->
    C_UserContentManagerScriptMessageReceivedCallback
wrap_UserContentManagerScriptMessageReceivedCallback :: UserContentManagerScriptMessageReceivedCallback
-> C_UserContentManagerScriptMessageReceivedCallback
wrap_UserContentManagerScriptMessageReceivedCallback UserContentManagerScriptMessageReceivedCallback
_cb Ptr ()
_ Ptr JavascriptResult
jsResult Ptr ()
_ = do
    (ManagedPtr JavascriptResult -> JavascriptResult)
-> Ptr JavascriptResult
-> UserContentManagerScriptMessageReceivedCallback
-> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr JavascriptResult -> JavascriptResult
WebKit2.JavascriptResult.JavascriptResult Ptr JavascriptResult
jsResult (UserContentManagerScriptMessageReceivedCallback -> IO ())
-> UserContentManagerScriptMessageReceivedCallback -> IO ()
forall a b. (a -> b) -> a -> b
$ \JavascriptResult
jsResult' -> do
        UserContentManagerScriptMessageReceivedCallback
_cb  JavascriptResult
jsResult'


-- | Connect a signal handler for the [scriptMessageReceived](#signal:scriptMessageReceived) 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' userContentManager #scriptMessageReceived callback
-- @
-- 
-- This signal admits a optional parameter @detail@.
-- If it's not @Nothing@, we will connect to “@script-message-received::detail@” instead.
-- 
onUserContentManagerScriptMessageReceived :: (IsUserContentManager a, MonadIO m) => a -> P.Maybe T.Text -> UserContentManagerScriptMessageReceivedCallback -> m SignalHandlerId
onUserContentManagerScriptMessageReceived :: a
-> Maybe Text
-> UserContentManagerScriptMessageReceivedCallback
-> m SignalHandlerId
onUserContentManagerScriptMessageReceived a
obj Maybe Text
detail UserContentManagerScriptMessageReceivedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_UserContentManagerScriptMessageReceivedCallback
cb' = UserContentManagerScriptMessageReceivedCallback
-> C_UserContentManagerScriptMessageReceivedCallback
wrap_UserContentManagerScriptMessageReceivedCallback UserContentManagerScriptMessageReceivedCallback
cb
    FunPtr C_UserContentManagerScriptMessageReceivedCallback
cb'' <- C_UserContentManagerScriptMessageReceivedCallback
-> IO (FunPtr C_UserContentManagerScriptMessageReceivedCallback)
mk_UserContentManagerScriptMessageReceivedCallback C_UserContentManagerScriptMessageReceivedCallback
cb'
    a
-> Text
-> FunPtr C_UserContentManagerScriptMessageReceivedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"script-message-received" FunPtr C_UserContentManagerScriptMessageReceivedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
detail

-- | Connect a signal handler for the [scriptMessageReceived](#signal:scriptMessageReceived) 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' userContentManager #scriptMessageReceived callback
-- @
-- 
-- This signal admits a optional parameter @detail@.
-- If it's not @Nothing@, we will connect to “@script-message-received::detail@” instead.
-- 
afterUserContentManagerScriptMessageReceived :: (IsUserContentManager a, MonadIO m) => a -> P.Maybe T.Text -> UserContentManagerScriptMessageReceivedCallback -> m SignalHandlerId
afterUserContentManagerScriptMessageReceived :: a
-> Maybe Text
-> UserContentManagerScriptMessageReceivedCallback
-> m SignalHandlerId
afterUserContentManagerScriptMessageReceived a
obj Maybe Text
detail UserContentManagerScriptMessageReceivedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_UserContentManagerScriptMessageReceivedCallback
cb' = UserContentManagerScriptMessageReceivedCallback
-> C_UserContentManagerScriptMessageReceivedCallback
wrap_UserContentManagerScriptMessageReceivedCallback UserContentManagerScriptMessageReceivedCallback
cb
    FunPtr C_UserContentManagerScriptMessageReceivedCallback
cb'' <- C_UserContentManagerScriptMessageReceivedCallback
-> IO (FunPtr C_UserContentManagerScriptMessageReceivedCallback)
mk_UserContentManagerScriptMessageReceivedCallback C_UserContentManagerScriptMessageReceivedCallback
cb'
    a
-> Text
-> FunPtr C_UserContentManagerScriptMessageReceivedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"script-message-received" FunPtr C_UserContentManagerScriptMessageReceivedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
detail


#if defined(ENABLE_OVERLOADING)
data UserContentManagerScriptMessageReceivedSignalInfo
instance SignalInfo UserContentManagerScriptMessageReceivedSignalInfo where
    type HaskellCallbackType UserContentManagerScriptMessageReceivedSignalInfo = UserContentManagerScriptMessageReceivedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_UserContentManagerScriptMessageReceivedCallback cb
        cb'' <- mk_UserContentManagerScriptMessageReceivedCallback cb'
        connectSignalFunPtr obj "script-message-received" cb'' connectMode detail

#endif

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

#if defined(ENABLE_OVERLOADING)
#endif

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

#endif

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

foreign import ccall "webkit_user_content_manager_new" webkit_user_content_manager_new :: 
    IO (Ptr UserContentManager)

-- | Creates a new user content manager.
-- 
-- /Since: 2.6/
userContentManagerNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m UserContentManager
    -- ^ __Returns:__ A t'GI.WebKit2.Objects.UserContentManager.UserContentManager'
userContentManagerNew :: m UserContentManager
userContentManagerNew  = IO UserContentManager -> m UserContentManager
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO UserContentManager -> m UserContentManager)
-> IO UserContentManager -> m UserContentManager
forall a b. (a -> b) -> a -> b
$ do
    Ptr UserContentManager
result <- IO (Ptr UserContentManager)
webkit_user_content_manager_new
    Text -> Ptr UserContentManager -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"userContentManagerNew" Ptr UserContentManager
result
    UserContentManager
result' <- ((ManagedPtr UserContentManager -> UserContentManager)
-> Ptr UserContentManager -> IO UserContentManager
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr UserContentManager -> UserContentManager
UserContentManager) Ptr UserContentManager
result
    UserContentManager -> IO UserContentManager
forall (m :: * -> *) a. Monad m => a -> m a
return UserContentManager
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method UserContentManager::add_filter
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "manager"
--           , argType =
--               TInterface
--                 Name { namespace = "WebKit2" , name = "UserContentManager" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #WebKitUserContentManager"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "filter"
--           , argType =
--               TInterface
--                 Name { namespace = "WebKit2" , name = "UserContentFilter" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #WebKitUserContentFilter"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_user_content_manager_add_filter" webkit_user_content_manager_add_filter :: 
    Ptr UserContentManager ->               -- manager : TInterface (Name {namespace = "WebKit2", name = "UserContentManager"})
    Ptr WebKit2.UserContentFilter.UserContentFilter -> -- filter : TInterface (Name {namespace = "WebKit2", name = "UserContentFilter"})
    IO ()

-- | Adds a t'GI.WebKit2.Structs.UserContentFilter.UserContentFilter' to the given t'GI.WebKit2.Objects.UserContentManager.UserContentManager'.
-- The same t'GI.WebKit2.Structs.UserContentFilter.UserContentFilter' can be reused with multiple
-- t'GI.WebKit2.Objects.UserContentManager.UserContentManager' instances.
-- 
-- Filters need to be saved and loaded from t'GI.WebKit2.Objects.UserContentFilterStore.UserContentFilterStore'.
-- 
-- /Since: 2.24/
userContentManagerAddFilter ::
    (B.CallStack.HasCallStack, MonadIO m, IsUserContentManager a) =>
    a
    -- ^ /@manager@/: A t'GI.WebKit2.Objects.UserContentManager.UserContentManager'
    -> WebKit2.UserContentFilter.UserContentFilter
    -- ^ /@filter@/: A t'GI.WebKit2.Structs.UserContentFilter.UserContentFilter'
    -> m ()
userContentManagerAddFilter :: a -> UserContentFilter -> m ()
userContentManagerAddFilter a
manager UserContentFilter
filter = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr UserContentManager
manager' <- a -> IO (Ptr UserContentManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
manager
    Ptr UserContentFilter
filter' <- UserContentFilter -> IO (Ptr UserContentFilter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr UserContentFilter
filter
    Ptr UserContentManager -> Ptr UserContentFilter -> IO ()
webkit_user_content_manager_add_filter Ptr UserContentManager
manager' Ptr UserContentFilter
filter'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
manager
    UserContentFilter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr UserContentFilter
filter
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data UserContentManagerAddFilterMethodInfo
instance (signature ~ (WebKit2.UserContentFilter.UserContentFilter -> m ()), MonadIO m, IsUserContentManager a) => O.MethodInfo UserContentManagerAddFilterMethodInfo a signature where
    overloadedMethod = userContentManagerAddFilter

#endif

-- method UserContentManager::add_script
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "manager"
--           , argType =
--               TInterface
--                 Name { namespace = "WebKit2" , name = "UserContentManager" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #WebKitUserContentManager"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "script"
--           , argType =
--               TInterface Name { namespace = "WebKit2" , name = "UserScript" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #WebKitUserScript"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_user_content_manager_add_script" webkit_user_content_manager_add_script :: 
    Ptr UserContentManager ->               -- manager : TInterface (Name {namespace = "WebKit2", name = "UserContentManager"})
    Ptr WebKit2.UserScript.UserScript ->    -- script : TInterface (Name {namespace = "WebKit2", name = "UserScript"})
    IO ()

-- | Adds a t'GI.WebKit2.Structs.UserScript.UserScript' to the given t'GI.WebKit2.Objects.UserContentManager.UserContentManager'.
-- The same t'GI.WebKit2.Structs.UserScript.UserScript' can be reused with multiple
-- t'GI.WebKit2.Objects.UserContentManager.UserContentManager' instances.
-- 
-- /Since: 2.6/
userContentManagerAddScript ::
    (B.CallStack.HasCallStack, MonadIO m, IsUserContentManager a) =>
    a
    -- ^ /@manager@/: A t'GI.WebKit2.Objects.UserContentManager.UserContentManager'
    -> WebKit2.UserScript.UserScript
    -- ^ /@script@/: A t'GI.WebKit2.Structs.UserScript.UserScript'
    -> m ()
userContentManagerAddScript :: a -> UserScript -> m ()
userContentManagerAddScript a
manager UserScript
script = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr UserContentManager
manager' <- a -> IO (Ptr UserContentManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
manager
    Ptr UserScript
script' <- UserScript -> IO (Ptr UserScript)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr UserScript
script
    Ptr UserContentManager -> Ptr UserScript -> IO ()
webkit_user_content_manager_add_script Ptr UserContentManager
manager' Ptr UserScript
script'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
manager
    UserScript -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr UserScript
script
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data UserContentManagerAddScriptMethodInfo
instance (signature ~ (WebKit2.UserScript.UserScript -> m ()), MonadIO m, IsUserContentManager a) => O.MethodInfo UserContentManagerAddScriptMethodInfo a signature where
    overloadedMethod = userContentManagerAddScript

#endif

-- method UserContentManager::add_style_sheet
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "manager"
--           , argType =
--               TInterface
--                 Name { namespace = "WebKit2" , name = "UserContentManager" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #WebKitUserContentManager"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "stylesheet"
--           , argType =
--               TInterface Name { namespace = "WebKit2" , name = "UserStyleSheet" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #WebKitUserStyleSheet"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_user_content_manager_add_style_sheet" webkit_user_content_manager_add_style_sheet :: 
    Ptr UserContentManager ->               -- manager : TInterface (Name {namespace = "WebKit2", name = "UserContentManager"})
    Ptr WebKit2.UserStyleSheet.UserStyleSheet -> -- stylesheet : TInterface (Name {namespace = "WebKit2", name = "UserStyleSheet"})
    IO ()

-- | Adds a t'GI.WebKit2.Structs.UserStyleSheet.UserStyleSheet' to the given t'GI.WebKit2.Objects.UserContentManager.UserContentManager'.
-- The same t'GI.WebKit2.Structs.UserStyleSheet.UserStyleSheet' can be reused with multiple
-- t'GI.WebKit2.Objects.UserContentManager.UserContentManager' instances.
-- 
-- /Since: 2.6/
userContentManagerAddStyleSheet ::
    (B.CallStack.HasCallStack, MonadIO m, IsUserContentManager a) =>
    a
    -- ^ /@manager@/: A t'GI.WebKit2.Objects.UserContentManager.UserContentManager'
    -> WebKit2.UserStyleSheet.UserStyleSheet
    -- ^ /@stylesheet@/: A t'GI.WebKit2.Structs.UserStyleSheet.UserStyleSheet'
    -> m ()
userContentManagerAddStyleSheet :: a -> UserStyleSheet -> m ()
userContentManagerAddStyleSheet a
manager UserStyleSheet
stylesheet = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr UserContentManager
manager' <- a -> IO (Ptr UserContentManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
manager
    Ptr UserStyleSheet
stylesheet' <- UserStyleSheet -> IO (Ptr UserStyleSheet)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr UserStyleSheet
stylesheet
    Ptr UserContentManager -> Ptr UserStyleSheet -> IO ()
webkit_user_content_manager_add_style_sheet Ptr UserContentManager
manager' Ptr UserStyleSheet
stylesheet'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
manager
    UserStyleSheet -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr UserStyleSheet
stylesheet
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data UserContentManagerAddStyleSheetMethodInfo
instance (signature ~ (WebKit2.UserStyleSheet.UserStyleSheet -> m ()), MonadIO m, IsUserContentManager a) => O.MethodInfo UserContentManagerAddStyleSheetMethodInfo a signature where
    overloadedMethod = userContentManagerAddStyleSheet

#endif

-- method UserContentManager::register_script_message_handler
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "manager"
--           , argType =
--               TInterface
--                 Name { namespace = "WebKit2" , name = "UserContentManager" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #WebKitUserContentManager"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Name of the script message channel"
--                 , 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_user_content_manager_register_script_message_handler" webkit_user_content_manager_register_script_message_handler :: 
    Ptr UserContentManager ->               -- manager : TInterface (Name {namespace = "WebKit2", name = "UserContentManager"})
    CString ->                              -- name : TBasicType TUTF8
    IO CInt

-- | Registers a new user script message handler. After it is registered,
-- scripts can use @window.webkit.messageHandlers.&lt;name&gt;.postMessage(value)@
-- to send messages. Those messages are received by connecting handlers
-- to the [scriptMessageReceived]("GI.WebKit2.Objects.UserContentManager#g:signal:scriptMessageReceived") signal. The
-- handler name is used as the detail of the signal. To avoid race
-- conditions between registering the handler name, and starting to
-- receive the signals, it is recommended to connect to the signal
-- *before* registering the handler name:
-- 
-- \<informalexample>\<programlisting>
-- WebKitWebView *view = webkit_web_view_new ();
-- WebKitUserContentManager *manager = webkit_web_view_get_user_content_manager ();
-- g_signal_connect (manager, \"script-message-received[foobar](#g:signal:foobar)\",
--                   G_CALLBACK (handle_script_message), NULL);
-- webkit_user_content_manager_register_script_message_handler (manager, \"foobar\");
-- \<\/programlisting>\<\/informalexample>
-- 
-- Registering a script message handler will fail if the requested
-- name has been already registered before.
-- 
-- /Since: 2.8/
userContentManagerRegisterScriptMessageHandler ::
    (B.CallStack.HasCallStack, MonadIO m, IsUserContentManager a) =>
    a
    -- ^ /@manager@/: A t'GI.WebKit2.Objects.UserContentManager.UserContentManager'
    -> T.Text
    -- ^ /@name@/: Name of the script message channel
    -> m Bool
    -- ^ __Returns:__ 'P.True' if message handler was registered successfully, or 'P.False' otherwise.
userContentManagerRegisterScriptMessageHandler :: a -> Text -> m Bool
userContentManagerRegisterScriptMessageHandler a
manager Text
name = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr UserContentManager
manager' <- a -> IO (Ptr UserContentManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
manager
    CString
name' <- Text -> IO CString
textToCString Text
name
    CInt
result <- Ptr UserContentManager -> CString -> IO CInt
webkit_user_content_manager_register_script_message_handler Ptr UserContentManager
manager' CString
name'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
manager
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data UserContentManagerRegisterScriptMessageHandlerMethodInfo
instance (signature ~ (T.Text -> m Bool), MonadIO m, IsUserContentManager a) => O.MethodInfo UserContentManagerRegisterScriptMessageHandlerMethodInfo a signature where
    overloadedMethod = userContentManagerRegisterScriptMessageHandler

#endif

-- method UserContentManager::register_script_message_handler_in_world
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "manager"
--           , argType =
--               TInterface
--                 Name { namespace = "WebKit2" , name = "UserContentManager" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #WebKitUserContentManager"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Name of the script message channel"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "world_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the name of a #WebKitScriptWorld"
--                 , 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_user_content_manager_register_script_message_handler_in_world" webkit_user_content_manager_register_script_message_handler_in_world :: 
    Ptr UserContentManager ->               -- manager : TInterface (Name {namespace = "WebKit2", name = "UserContentManager"})
    CString ->                              -- name : TBasicType TUTF8
    CString ->                              -- world_name : TBasicType TUTF8
    IO CInt

-- | Registers a new user script message handler in script world with name /@worldName@/.
-- See 'GI.WebKit2.Objects.UserContentManager.userContentManagerRegisterScriptMessageHandler' for full description.
-- 
-- Registering a script message handler will fail if the requested
-- name has been already registered before.
-- 
-- /Since: 2.22/
userContentManagerRegisterScriptMessageHandlerInWorld ::
    (B.CallStack.HasCallStack, MonadIO m, IsUserContentManager a) =>
    a
    -- ^ /@manager@/: A t'GI.WebKit2.Objects.UserContentManager.UserContentManager'
    -> T.Text
    -- ^ /@name@/: Name of the script message channel
    -> T.Text
    -- ^ /@worldName@/: the name of a @/WebKitScriptWorld/@
    -> m Bool
    -- ^ __Returns:__ 'P.True' if message handler was registered successfully, or 'P.False' otherwise.
userContentManagerRegisterScriptMessageHandlerInWorld :: a -> Text -> Text -> m Bool
userContentManagerRegisterScriptMessageHandlerInWorld a
manager Text
name Text
worldName = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr UserContentManager
manager' <- a -> IO (Ptr UserContentManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
manager
    CString
name' <- Text -> IO CString
textToCString Text
name
    CString
worldName' <- Text -> IO CString
textToCString Text
worldName
    CInt
result <- Ptr UserContentManager -> CString -> CString -> IO CInt
webkit_user_content_manager_register_script_message_handler_in_world Ptr UserContentManager
manager' CString
name' CString
worldName'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
manager
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
worldName'
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data UserContentManagerRegisterScriptMessageHandlerInWorldMethodInfo
instance (signature ~ (T.Text -> T.Text -> m Bool), MonadIO m, IsUserContentManager a) => O.MethodInfo UserContentManagerRegisterScriptMessageHandlerInWorldMethodInfo a signature where
    overloadedMethod = userContentManagerRegisterScriptMessageHandlerInWorld

#endif

-- method UserContentManager::remove_all_filters
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "manager"
--           , argType =
--               TInterface
--                 Name { namespace = "WebKit2" , name = "UserContentManager" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #WebKitUserContentManager"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_user_content_manager_remove_all_filters" webkit_user_content_manager_remove_all_filters :: 
    Ptr UserContentManager ->               -- manager : TInterface (Name {namespace = "WebKit2", name = "UserContentManager"})
    IO ()

-- | Removes all content filters from the given t'GI.WebKit2.Objects.UserContentManager.UserContentManager'.
-- 
-- /Since: 2.24/
userContentManagerRemoveAllFilters ::
    (B.CallStack.HasCallStack, MonadIO m, IsUserContentManager a) =>
    a
    -- ^ /@manager@/: A t'GI.WebKit2.Objects.UserContentManager.UserContentManager'
    -> m ()
userContentManagerRemoveAllFilters :: a -> m ()
userContentManagerRemoveAllFilters a
manager = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr UserContentManager
manager' <- a -> IO (Ptr UserContentManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
manager
    Ptr UserContentManager -> IO ()
webkit_user_content_manager_remove_all_filters Ptr UserContentManager
manager'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
manager
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data UserContentManagerRemoveAllFiltersMethodInfo
instance (signature ~ (m ()), MonadIO m, IsUserContentManager a) => O.MethodInfo UserContentManagerRemoveAllFiltersMethodInfo a signature where
    overloadedMethod = userContentManagerRemoveAllFilters

#endif

-- method UserContentManager::remove_all_scripts
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "manager"
--           , argType =
--               TInterface
--                 Name { namespace = "WebKit2" , name = "UserContentManager" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #WebKitUserContentManager"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_user_content_manager_remove_all_scripts" webkit_user_content_manager_remove_all_scripts :: 
    Ptr UserContentManager ->               -- manager : TInterface (Name {namespace = "WebKit2", name = "UserContentManager"})
    IO ()

-- | Removes all user scripts from the given t'GI.WebKit2.Objects.UserContentManager.UserContentManager'
-- 
-- /Since: 2.6/
userContentManagerRemoveAllScripts ::
    (B.CallStack.HasCallStack, MonadIO m, IsUserContentManager a) =>
    a
    -- ^ /@manager@/: A t'GI.WebKit2.Objects.UserContentManager.UserContentManager'
    -> m ()
userContentManagerRemoveAllScripts :: a -> m ()
userContentManagerRemoveAllScripts a
manager = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr UserContentManager
manager' <- a -> IO (Ptr UserContentManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
manager
    Ptr UserContentManager -> IO ()
webkit_user_content_manager_remove_all_scripts Ptr UserContentManager
manager'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
manager
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data UserContentManagerRemoveAllScriptsMethodInfo
instance (signature ~ (m ()), MonadIO m, IsUserContentManager a) => O.MethodInfo UserContentManagerRemoveAllScriptsMethodInfo a signature where
    overloadedMethod = userContentManagerRemoveAllScripts

#endif

-- method UserContentManager::remove_all_style_sheets
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "manager"
--           , argType =
--               TInterface
--                 Name { namespace = "WebKit2" , name = "UserContentManager" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #WebKitUserContentManager"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_user_content_manager_remove_all_style_sheets" webkit_user_content_manager_remove_all_style_sheets :: 
    Ptr UserContentManager ->               -- manager : TInterface (Name {namespace = "WebKit2", name = "UserContentManager"})
    IO ()

-- | Removes all user style sheets from the given t'GI.WebKit2.Objects.UserContentManager.UserContentManager'.
-- 
-- /Since: 2.6/
userContentManagerRemoveAllStyleSheets ::
    (B.CallStack.HasCallStack, MonadIO m, IsUserContentManager a) =>
    a
    -- ^ /@manager@/: A t'GI.WebKit2.Objects.UserContentManager.UserContentManager'
    -> m ()
userContentManagerRemoveAllStyleSheets :: a -> m ()
userContentManagerRemoveAllStyleSheets a
manager = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr UserContentManager
manager' <- a -> IO (Ptr UserContentManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
manager
    Ptr UserContentManager -> IO ()
webkit_user_content_manager_remove_all_style_sheets Ptr UserContentManager
manager'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
manager
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data UserContentManagerRemoveAllStyleSheetsMethodInfo
instance (signature ~ (m ()), MonadIO m, IsUserContentManager a) => O.MethodInfo UserContentManagerRemoveAllStyleSheetsMethodInfo a signature where
    overloadedMethod = userContentManagerRemoveAllStyleSheets

#endif

-- method UserContentManager::remove_filter
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "manager"
--           , argType =
--               TInterface
--                 Name { namespace = "WebKit2" , name = "UserContentManager" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #WebKitUserContentManager"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "filter"
--           , argType =
--               TInterface
--                 Name { namespace = "WebKit2" , name = "UserContentFilter" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #WebKitUserContentFilter"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_user_content_manager_remove_filter" webkit_user_content_manager_remove_filter :: 
    Ptr UserContentManager ->               -- manager : TInterface (Name {namespace = "WebKit2", name = "UserContentManager"})
    Ptr WebKit2.UserContentFilter.UserContentFilter -> -- filter : TInterface (Name {namespace = "WebKit2", name = "UserContentFilter"})
    IO ()

-- | Removes a filter from the given t'GI.WebKit2.Objects.UserContentManager.UserContentManager'.
-- 
-- Since 2.24
userContentManagerRemoveFilter ::
    (B.CallStack.HasCallStack, MonadIO m, IsUserContentManager a) =>
    a
    -- ^ /@manager@/: A t'GI.WebKit2.Objects.UserContentManager.UserContentManager'
    -> WebKit2.UserContentFilter.UserContentFilter
    -- ^ /@filter@/: A t'GI.WebKit2.Structs.UserContentFilter.UserContentFilter'
    -> m ()
userContentManagerRemoveFilter :: a -> UserContentFilter -> m ()
userContentManagerRemoveFilter a
manager UserContentFilter
filter = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr UserContentManager
manager' <- a -> IO (Ptr UserContentManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
manager
    Ptr UserContentFilter
filter' <- UserContentFilter -> IO (Ptr UserContentFilter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr UserContentFilter
filter
    Ptr UserContentManager -> Ptr UserContentFilter -> IO ()
webkit_user_content_manager_remove_filter Ptr UserContentManager
manager' Ptr UserContentFilter
filter'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
manager
    UserContentFilter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr UserContentFilter
filter
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data UserContentManagerRemoveFilterMethodInfo
instance (signature ~ (WebKit2.UserContentFilter.UserContentFilter -> m ()), MonadIO m, IsUserContentManager a) => O.MethodInfo UserContentManagerRemoveFilterMethodInfo a signature where
    overloadedMethod = userContentManagerRemoveFilter

#endif

-- method UserContentManager::remove_filter_by_id
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "manager"
--           , argType =
--               TInterface
--                 Name { namespace = "WebKit2" , name = "UserContentManager" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #WebKitUserContentManager"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "filter_id"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Filter identifier" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_user_content_manager_remove_filter_by_id" webkit_user_content_manager_remove_filter_by_id :: 
    Ptr UserContentManager ->               -- manager : TInterface (Name {namespace = "WebKit2", name = "UserContentManager"})
    CString ->                              -- filter_id : TBasicType TUTF8
    IO ()

-- | Removes a filter from the given t'GI.WebKit2.Objects.UserContentManager.UserContentManager' given the
-- identifier of a t'GI.WebKit2.Structs.UserContentFilter.UserContentFilter' as returned by
-- 'GI.WebKit2.Structs.UserContentFilter.userContentFilterGetIdentifier'.
-- 
-- /Since: 2.26/
userContentManagerRemoveFilterById ::
    (B.CallStack.HasCallStack, MonadIO m, IsUserContentManager a) =>
    a
    -- ^ /@manager@/: A t'GI.WebKit2.Objects.UserContentManager.UserContentManager'
    -> T.Text
    -- ^ /@filterId@/: Filter identifier
    -> m ()
userContentManagerRemoveFilterById :: a -> Text -> m ()
userContentManagerRemoveFilterById a
manager Text
filterId = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr UserContentManager
manager' <- a -> IO (Ptr UserContentManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
manager
    CString
filterId' <- Text -> IO CString
textToCString Text
filterId
    Ptr UserContentManager -> CString -> IO ()
webkit_user_content_manager_remove_filter_by_id Ptr UserContentManager
manager' CString
filterId'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
manager
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
filterId'
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data UserContentManagerRemoveFilterByIdMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsUserContentManager a) => O.MethodInfo UserContentManagerRemoveFilterByIdMethodInfo a signature where
    overloadedMethod = userContentManagerRemoveFilterById

#endif

-- method UserContentManager::unregister_script_message_handler
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "manager"
--           , argType =
--               TInterface
--                 Name { namespace = "WebKit2" , name = "UserContentManager" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #WebKitUserContentManager"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Name of the script message channel"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_user_content_manager_unregister_script_message_handler" webkit_user_content_manager_unregister_script_message_handler :: 
    Ptr UserContentManager ->               -- manager : TInterface (Name {namespace = "WebKit2", name = "UserContentManager"})
    CString ->                              -- name : TBasicType TUTF8
    IO ()

-- | Unregisters a previously registered message handler.
-- 
-- Note that this does *not* disconnect handlers for the
-- [scriptMessageReceived]("GI.WebKit2.Objects.UserContentManager#g:signal:scriptMessageReceived") signal;
-- they will be kept connected, but the signal will not be emitted
-- unless the handler name is registered again.
-- 
-- See also 'GI.WebKit2.Objects.UserContentManager.userContentManagerRegisterScriptMessageHandler'.
-- 
-- /Since: 2.8/
userContentManagerUnregisterScriptMessageHandler ::
    (B.CallStack.HasCallStack, MonadIO m, IsUserContentManager a) =>
    a
    -- ^ /@manager@/: A t'GI.WebKit2.Objects.UserContentManager.UserContentManager'
    -> T.Text
    -- ^ /@name@/: Name of the script message channel
    -> m ()
userContentManagerUnregisterScriptMessageHandler :: a -> Text -> m ()
userContentManagerUnregisterScriptMessageHandler a
manager Text
name = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr UserContentManager
manager' <- a -> IO (Ptr UserContentManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
manager
    CString
name' <- Text -> IO CString
textToCString Text
name
    Ptr UserContentManager -> CString -> IO ()
webkit_user_content_manager_unregister_script_message_handler Ptr UserContentManager
manager' CString
name'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
manager
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data UserContentManagerUnregisterScriptMessageHandlerMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsUserContentManager a) => O.MethodInfo UserContentManagerUnregisterScriptMessageHandlerMethodInfo a signature where
    overloadedMethod = userContentManagerUnregisterScriptMessageHandler

#endif

-- method UserContentManager::unregister_script_message_handler_in_world
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "manager"
--           , argType =
--               TInterface
--                 Name { namespace = "WebKit2" , name = "UserContentManager" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #WebKitUserContentManager"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Name of the script message channel"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "world_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the name of a #WebKitScriptWorld"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_user_content_manager_unregister_script_message_handler_in_world" webkit_user_content_manager_unregister_script_message_handler_in_world :: 
    Ptr UserContentManager ->               -- manager : TInterface (Name {namespace = "WebKit2", name = "UserContentManager"})
    CString ->                              -- name : TBasicType TUTF8
    CString ->                              -- world_name : TBasicType TUTF8
    IO ()

-- | Unregisters a previously registered message handler in script world with name /@worldName@/.
-- 
-- Note that this does *not* disconnect handlers for the
-- [scriptMessageReceived]("GI.WebKit2.Objects.UserContentManager#g:signal:scriptMessageReceived") signal;
-- they will be kept connected, but the signal will not be emitted
-- unless the handler name is registered again.
-- 
-- See also 'GI.WebKit2.Objects.UserContentManager.userContentManagerRegisterScriptMessageHandlerInWorld'.
-- 
-- /Since: 2.22/
userContentManagerUnregisterScriptMessageHandlerInWorld ::
    (B.CallStack.HasCallStack, MonadIO m, IsUserContentManager a) =>
    a
    -- ^ /@manager@/: A t'GI.WebKit2.Objects.UserContentManager.UserContentManager'
    -> T.Text
    -- ^ /@name@/: Name of the script message channel
    -> T.Text
    -- ^ /@worldName@/: the name of a @/WebKitScriptWorld/@
    -> m ()
userContentManagerUnregisterScriptMessageHandlerInWorld :: a -> Text -> Text -> m ()
userContentManagerUnregisterScriptMessageHandlerInWorld a
manager Text
name Text
worldName = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr UserContentManager
manager' <- a -> IO (Ptr UserContentManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
manager
    CString
name' <- Text -> IO CString
textToCString Text
name
    CString
worldName' <- Text -> IO CString
textToCString Text
worldName
    Ptr UserContentManager -> CString -> CString -> IO ()
webkit_user_content_manager_unregister_script_message_handler_in_world Ptr UserContentManager
manager' CString
name' CString
worldName'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
manager
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
worldName'
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data UserContentManagerUnregisterScriptMessageHandlerInWorldMethodInfo
instance (signature ~ (T.Text -> T.Text -> m ()), MonadIO m, IsUserContentManager a) => O.MethodInfo UserContentManagerUnregisterScriptMessageHandlerInWorldMethodInfo a signature where
    overloadedMethod = userContentManagerUnregisterScriptMessageHandlerInWorld

#endif