{-# LANGUAGE ImplicitParams, RankNTypes, TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- 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.WebKit2WebExtension.Objects.ScriptWorld
    ( 

-- * Exported types
    ScriptWorld(..)                         ,
    IsScriptWorld                           ,
    toScriptWorld                           ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getData]("GI.GObject.Objects.Object#g:method:getData"), [getName]("GI.WebKit2WebExtension.Objects.ScriptWorld#g:method:getName"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata").
-- 
-- ==== Setters
-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty").

#if defined(ENABLE_OVERLOADING)
    ResolveScriptWorldMethod                ,
#endif

-- ** getDefault #method:getDefault#

    scriptWorldGetDefault                   ,


-- ** getName #method:getName#

#if defined(ENABLE_OVERLOADING)
    ScriptWorldGetNameMethodInfo            ,
#endif
    scriptWorldGetName                      ,


-- ** new #method:new#

    scriptWorldNew                          ,


-- ** newWithName #method:newWithName#

    scriptWorldNewWithName                  ,




 -- * Signals


-- ** windowObjectCleared #signal:windowObjectCleared#

    ScriptWorldWindowObjectClearedCallback  ,
#if defined(ENABLE_OVERLOADING)
    ScriptWorldWindowObjectClearedSignalInfo,
#endif
    afterScriptWorldWindowObjectCleared     ,
    onScriptWorldWindowObjectCleared        ,




    ) 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.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
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.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
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 GHC.Records as R

import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.WebKit2WebExtension.Objects.Frame as WebKit2WebExtension.Frame
import {-# SOURCE #-} qualified GI.WebKit2WebExtension.Objects.WebPage as WebKit2WebExtension.WebPage

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

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

foreign import ccall "webkit_script_world_get_type"
    c_webkit_script_world_get_type :: IO B.Types.GType

instance B.Types.TypedObject ScriptWorld where
    glibType :: IO GType
glibType = IO GType
c_webkit_script_world_get_type

instance B.Types.GObject ScriptWorld

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

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

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

-- | Convert 'ScriptWorld' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe ScriptWorld) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_webkit_script_world_get_type
    gvalueSet_ :: Ptr GValue -> Maybe ScriptWorld -> IO ()
gvalueSet_ Ptr GValue
gv Maybe ScriptWorld
P.Nothing = Ptr GValue -> Ptr ScriptWorld -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr ScriptWorld
forall a. Ptr a
FP.nullPtr :: FP.Ptr ScriptWorld)
    gvalueSet_ Ptr GValue
gv (P.Just ScriptWorld
obj) = ScriptWorld -> (Ptr ScriptWorld -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr ScriptWorld
obj (Ptr GValue -> Ptr ScriptWorld -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe ScriptWorld)
gvalueGet_ Ptr GValue
gv = do
        Ptr ScriptWorld
ptr <- Ptr GValue -> IO (Ptr ScriptWorld)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr ScriptWorld)
        if Ptr ScriptWorld
ptr Ptr ScriptWorld -> Ptr ScriptWorld -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr ScriptWorld
forall a. Ptr a
FP.nullPtr
        then ScriptWorld -> Maybe ScriptWorld
forall a. a -> Maybe a
P.Just (ScriptWorld -> Maybe ScriptWorld)
-> IO ScriptWorld -> IO (Maybe ScriptWorld)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr ScriptWorld -> ScriptWorld)
-> Ptr ScriptWorld -> IO ScriptWorld
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr ScriptWorld -> ScriptWorld
ScriptWorld Ptr ScriptWorld
ptr
        else Maybe ScriptWorld -> IO (Maybe ScriptWorld)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ScriptWorld
forall a. Maybe a
P.Nothing
        
    

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

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

#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveScriptWorldMethod t ScriptWorld, O.OverloadedMethod info ScriptWorld p, R.HasField t ScriptWorld p) => R.HasField t ScriptWorld p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveScriptWorldMethod t ScriptWorld, O.OverloadedMethodInfo info ScriptWorld) => OL.IsLabel t (O.MethodProxy info ScriptWorld) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif

-- signal ScriptWorld::window-object-cleared
-- | Emitted when the JavaScript window object in a t'GI.WebKit2WebExtension.Objects.ScriptWorld.ScriptWorld' has been
-- cleared. This is the preferred place to set custom properties on the window
-- object using the JavaScriptCore API. You can get the window object of /@frame@/
-- from the JavaScript execution context of /@world@/ that is returned by
-- 'GI.WebKit2WebExtension.Objects.Frame.frameGetJsContextForScriptWorld'.
-- 
-- /Since: 2.2/
type ScriptWorldWindowObjectClearedCallback =
    WebKit2WebExtension.WebPage.WebPage
    -- ^ /@page@/: a t'GI.WebKit2WebExtension.Objects.WebPage.WebPage'
    -> WebKit2WebExtension.Frame.Frame
    -- ^ /@frame@/: the t'GI.WebKit2WebExtension.Objects.Frame.Frame'  to which /@world@/ belongs
    -> IO ()

type C_ScriptWorldWindowObjectClearedCallback =
    Ptr ScriptWorld ->                      -- object
    Ptr WebKit2WebExtension.WebPage.WebPage ->
    Ptr WebKit2WebExtension.Frame.Frame ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_ScriptWorldWindowObjectClearedCallback :: 
    GObject a => (a -> ScriptWorldWindowObjectClearedCallback) ->
    C_ScriptWorldWindowObjectClearedCallback
wrap_ScriptWorldWindowObjectClearedCallback :: forall a.
GObject a =>
(a -> ScriptWorldWindowObjectClearedCallback)
-> C_ScriptWorldWindowObjectClearedCallback
wrap_ScriptWorldWindowObjectClearedCallback a -> ScriptWorldWindowObjectClearedCallback
gi'cb Ptr ScriptWorld
gi'selfPtr Ptr WebPage
page Ptr Frame
frame Ptr ()
_ = do
    WebPage
page' <- ((ManagedPtr WebPage -> WebPage) -> Ptr WebPage -> IO WebPage
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr WebPage -> WebPage
WebKit2WebExtension.WebPage.WebPage) Ptr WebPage
page
    Frame
frame' <- ((ManagedPtr Frame -> Frame) -> Ptr Frame -> IO Frame
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Frame -> Frame
WebKit2WebExtension.Frame.Frame) Ptr Frame
frame
    Ptr ScriptWorld -> (ScriptWorld -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr ScriptWorld
gi'selfPtr ((ScriptWorld -> IO ()) -> IO ())
-> (ScriptWorld -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ScriptWorld
gi'self -> a -> ScriptWorldWindowObjectClearedCallback
gi'cb (ScriptWorld -> a
forall a b. Coercible a b => a -> b
Coerce.coerce ScriptWorld
gi'self)  WebPage
page' Frame
frame'


-- | Connect a signal handler for the [windowObjectCleared](#signal:windowObjectCleared) 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' scriptWorld #windowObjectCleared callback
-- @
-- 
-- 
onScriptWorldWindowObjectCleared :: (IsScriptWorld a, MonadIO m) => a -> ((?self :: a) => ScriptWorldWindowObjectClearedCallback) -> m SignalHandlerId
onScriptWorldWindowObjectCleared :: forall a (m :: * -> *).
(IsScriptWorld a, MonadIO m) =>
a
-> ((?self::a) => ScriptWorldWindowObjectClearedCallback)
-> m SignalHandlerId
onScriptWorldWindowObjectCleared a
obj (?self::a) => ScriptWorldWindowObjectClearedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> ScriptWorldWindowObjectClearedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ScriptWorldWindowObjectClearedCallback
ScriptWorldWindowObjectClearedCallback
cb
    let wrapped' :: C_ScriptWorldWindowObjectClearedCallback
wrapped' = (a -> ScriptWorldWindowObjectClearedCallback)
-> C_ScriptWorldWindowObjectClearedCallback
forall a.
GObject a =>
(a -> ScriptWorldWindowObjectClearedCallback)
-> C_ScriptWorldWindowObjectClearedCallback
wrap_ScriptWorldWindowObjectClearedCallback a -> ScriptWorldWindowObjectClearedCallback
wrapped
    FunPtr C_ScriptWorldWindowObjectClearedCallback
wrapped'' <- C_ScriptWorldWindowObjectClearedCallback
-> IO (FunPtr C_ScriptWorldWindowObjectClearedCallback)
mk_ScriptWorldWindowObjectClearedCallback C_ScriptWorldWindowObjectClearedCallback
wrapped'
    a
-> Text
-> FunPtr C_ScriptWorldWindowObjectClearedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"window-object-cleared" FunPtr C_ScriptWorldWindowObjectClearedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [windowObjectCleared](#signal:windowObjectCleared) 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' scriptWorld #windowObjectCleared callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterScriptWorldWindowObjectCleared :: (IsScriptWorld a, MonadIO m) => a -> ((?self :: a) => ScriptWorldWindowObjectClearedCallback) -> m SignalHandlerId
afterScriptWorldWindowObjectCleared :: forall a (m :: * -> *).
(IsScriptWorld a, MonadIO m) =>
a
-> ((?self::a) => ScriptWorldWindowObjectClearedCallback)
-> m SignalHandlerId
afterScriptWorldWindowObjectCleared a
obj (?self::a) => ScriptWorldWindowObjectClearedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> ScriptWorldWindowObjectClearedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ScriptWorldWindowObjectClearedCallback
ScriptWorldWindowObjectClearedCallback
cb
    let wrapped' :: C_ScriptWorldWindowObjectClearedCallback
wrapped' = (a -> ScriptWorldWindowObjectClearedCallback)
-> C_ScriptWorldWindowObjectClearedCallback
forall a.
GObject a =>
(a -> ScriptWorldWindowObjectClearedCallback)
-> C_ScriptWorldWindowObjectClearedCallback
wrap_ScriptWorldWindowObjectClearedCallback a -> ScriptWorldWindowObjectClearedCallback
wrapped
    FunPtr C_ScriptWorldWindowObjectClearedCallback
wrapped'' <- C_ScriptWorldWindowObjectClearedCallback
-> IO (FunPtr C_ScriptWorldWindowObjectClearedCallback)
mk_ScriptWorldWindowObjectClearedCallback C_ScriptWorldWindowObjectClearedCallback
wrapped'
    a
-> Text
-> FunPtr C_ScriptWorldWindowObjectClearedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"window-object-cleared" FunPtr C_ScriptWorldWindowObjectClearedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ScriptWorldWindowObjectClearedSignalInfo
instance SignalInfo ScriptWorldWindowObjectClearedSignalInfo where
    type HaskellCallbackType ScriptWorldWindowObjectClearedSignalInfo = ScriptWorldWindowObjectClearedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ScriptWorldWindowObjectClearedCallback cb
        cb'' <- mk_ScriptWorldWindowObjectClearedCallback cb'
        connectSignalFunPtr obj "window-object-cleared" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.WebKit2WebExtension.Objects.ScriptWorld::window-object-cleared"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-webkit2webextension-4.0.30/docs/GI-WebKit2WebExtension-Objects-ScriptWorld.html#g:signal:windowObjectCleared"})

#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList ScriptWorld
type instance O.AttributeList ScriptWorld = ScriptWorldAttributeList
type ScriptWorldAttributeList = ('[ ] :: [(Symbol, DK.Type)])
#endif

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList ScriptWorld = ScriptWorldSignalList
type ScriptWorldSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo), '("windowObjectCleared", ScriptWorldWindowObjectClearedSignalInfo)] :: [(Symbol, DK.Type)])

#endif

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

foreign import ccall "webkit_script_world_new" webkit_script_world_new :: 
    IO (Ptr ScriptWorld)

-- | Creates a new isolated t'GI.WebKit2WebExtension.Objects.ScriptWorld.ScriptWorld'. Scripts executed in
-- isolated worlds have access to the DOM but not to other variable
-- or functions created by the page.
-- The t'GI.WebKit2WebExtension.Objects.ScriptWorld.ScriptWorld' is created with a generated unique name. Use
-- 'GI.WebKit2WebExtension.Objects.ScriptWorld.scriptWorldNewWithName' if you want to create it with a
-- custom name.
-- You can get the JavaScript execution context of a t'GI.WebKit2WebExtension.Objects.ScriptWorld.ScriptWorld'
-- for a given t'GI.WebKit2WebExtension.Objects.Frame.Frame' with @/webkit_frame_get_javascript_context_for_script_world()/@.
-- 
-- /Since: 2.2/
scriptWorldNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m ScriptWorld
    -- ^ __Returns:__ a new isolated t'GI.WebKit2WebExtension.Objects.ScriptWorld.ScriptWorld'
scriptWorldNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m ScriptWorld
scriptWorldNew  = IO ScriptWorld -> m ScriptWorld
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ScriptWorld -> m ScriptWorld)
-> IO ScriptWorld -> m ScriptWorld
forall a b. (a -> b) -> a -> b
$ do
    Ptr ScriptWorld
result <- IO (Ptr ScriptWorld)
webkit_script_world_new
    Text -> Ptr ScriptWorld -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"scriptWorldNew" Ptr ScriptWorld
result
    ScriptWorld
result' <- ((ManagedPtr ScriptWorld -> ScriptWorld)
-> Ptr ScriptWorld -> IO ScriptWorld
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr ScriptWorld -> ScriptWorld
ScriptWorld) Ptr ScriptWorld
result
    ScriptWorld -> IO ScriptWorld
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ScriptWorld
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method ScriptWorld::new_with_name
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a name for the script world"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "WebKit2WebExtension" , name = "ScriptWorld" })
-- throws : False
-- Skip return : False

foreign import ccall "webkit_script_world_new_with_name" webkit_script_world_new_with_name :: 
    CString ->                              -- name : TBasicType TUTF8
    IO (Ptr ScriptWorld)

-- | Creates a new isolated t'GI.WebKit2WebExtension.Objects.ScriptWorld.ScriptWorld' with a name. Scripts executed in
-- isolated worlds have access to the DOM but not to other variable
-- or functions created by the page.
-- You can get the JavaScript execution context of a t'GI.WebKit2WebExtension.Objects.ScriptWorld.ScriptWorld'
-- for a given t'GI.WebKit2WebExtension.Objects.Frame.Frame' with @/webkit_frame_get_javascript_context_for_script_world()/@.
-- 
-- /Since: 2.22/
scriptWorldNewWithName ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    -- ^ /@name@/: a name for the script world
    -> m ScriptWorld
    -- ^ __Returns:__ a new isolated t'GI.WebKit2WebExtension.Objects.ScriptWorld.ScriptWorld'
scriptWorldNewWithName :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m ScriptWorld
scriptWorldNewWithName Text
name = IO ScriptWorld -> m ScriptWorld
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ScriptWorld -> m ScriptWorld)
-> IO ScriptWorld -> m ScriptWorld
forall a b. (a -> b) -> a -> b
$ do
    CString
name' <- Text -> IO CString
textToCString Text
name
    Ptr ScriptWorld
result <- CString -> IO (Ptr ScriptWorld)
webkit_script_world_new_with_name CString
name'
    Text -> Ptr ScriptWorld -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"scriptWorldNewWithName" Ptr ScriptWorld
result
    ScriptWorld
result' <- ((ManagedPtr ScriptWorld -> ScriptWorld)
-> Ptr ScriptWorld -> IO ScriptWorld
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr ScriptWorld -> ScriptWorld
ScriptWorld) Ptr ScriptWorld
result
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
    ScriptWorld -> IO ScriptWorld
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ScriptWorld
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method ScriptWorld::get_name
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "world"
--           , argType =
--               TInterface
--                 Name { namespace = "WebKit2WebExtension" , name = "ScriptWorld" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #WebKitScriptWorld"
--                 , 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_script_world_get_name" webkit_script_world_get_name :: 
    Ptr ScriptWorld ->                      -- world : TInterface (Name {namespace = "WebKit2WebExtension", name = "ScriptWorld"})
    IO CString

-- | Get the name of a t'GI.WebKit2WebExtension.Objects.ScriptWorld.ScriptWorld'.
-- 
-- /Since: 2.22/
scriptWorldGetName ::
    (B.CallStack.HasCallStack, MonadIO m, IsScriptWorld a) =>
    a
    -- ^ /@world@/: a t'GI.WebKit2WebExtension.Objects.ScriptWorld.ScriptWorld'
    -> m T.Text
    -- ^ __Returns:__ the name of /@world@/
scriptWorldGetName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsScriptWorld a) =>
a -> m Text
scriptWorldGetName a
world = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr ScriptWorld
world' <- a -> IO (Ptr ScriptWorld)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
world
    CString
result <- Ptr ScriptWorld -> IO CString
webkit_script_world_get_name Ptr ScriptWorld
world'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"scriptWorldGetName" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
world
    Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data ScriptWorldGetNameMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsScriptWorld a) => O.OverloadedMethod ScriptWorldGetNameMethodInfo a signature where
    overloadedMethod = scriptWorldGetName

instance O.OverloadedMethodInfo ScriptWorldGetNameMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.WebKit2WebExtension.Objects.ScriptWorld.scriptWorldGetName",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-webkit2webextension-4.0.30/docs/GI-WebKit2WebExtension-Objects-ScriptWorld.html#v:scriptWorldGetName"
        })


#endif

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

foreign import ccall "webkit_script_world_get_default" webkit_script_world_get_default :: 
    IO (Ptr ScriptWorld)

-- | Get the default t'GI.WebKit2WebExtension.Objects.ScriptWorld.ScriptWorld'. This is the normal script world
-- where all scripts are executed by default.
-- You can get the JavaScript execution context of a t'GI.WebKit2WebExtension.Objects.ScriptWorld.ScriptWorld'
-- for a given t'GI.WebKit2WebExtension.Objects.Frame.Frame' with @/webkit_frame_get_javascript_context_for_script_world()/@.
-- 
-- /Since: 2.2/
scriptWorldGetDefault ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m ScriptWorld
    -- ^ __Returns:__ the default t'GI.WebKit2WebExtension.Objects.ScriptWorld.ScriptWorld'
scriptWorldGetDefault :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m ScriptWorld
scriptWorldGetDefault  = IO ScriptWorld -> m ScriptWorld
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ScriptWorld -> m ScriptWorld)
-> IO ScriptWorld -> m ScriptWorld
forall a b. (a -> b) -> a -> b
$ do
    Ptr ScriptWorld
result <- IO (Ptr ScriptWorld)
webkit_script_world_get_default
    Text -> Ptr ScriptWorld -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"scriptWorldGetDefault" Ptr ScriptWorld
result
    ScriptWorld
result' <- ((ManagedPtr ScriptWorld -> ScriptWorld)
-> Ptr ScriptWorld -> IO ScriptWorld
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr ScriptWorld -> ScriptWorld
ScriptWorld) Ptr ScriptWorld
result
    ScriptWorld -> IO ScriptWorld
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ScriptWorld
result'

#if defined(ENABLE_OVERLOADING)
#endif