{-# 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.WebKit2WebExtension.Objects.WebPage
    ( 

-- * Exported types
    WebPage(..)                             ,
    IsWebPage                               ,
    toWebPage                               ,


 -- * 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"), [sendMessageToView]("GI.WebKit2WebExtension.Objects.WebPage#g:method:sendMessageToView"), [sendMessageToViewFinish]("GI.WebKit2WebExtension.Objects.WebPage#g:method:sendMessageToViewFinish"), [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"), [getDomDocument]("GI.WebKit2WebExtension.Objects.WebPage#g:method:getDomDocument"), [getEditor]("GI.WebKit2WebExtension.Objects.WebPage#g:method:getEditor"), [getId]("GI.WebKit2WebExtension.Objects.WebPage#g:method:getId"), [getMainFrame]("GI.WebKit2WebExtension.Objects.WebPage#g:method:getMainFrame"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getUri]("GI.WebKit2WebExtension.Objects.WebPage#g:method:getUri").
-- 
-- ==== 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)
    ResolveWebPageMethod                    ,
#endif

-- ** getDomDocument #method:getDomDocument#

#if defined(ENABLE_OVERLOADING)
    WebPageGetDomDocumentMethodInfo         ,
#endif
    webPageGetDomDocument                   ,


-- ** getEditor #method:getEditor#

#if defined(ENABLE_OVERLOADING)
    WebPageGetEditorMethodInfo              ,
#endif
    webPageGetEditor                        ,


-- ** getId #method:getId#

#if defined(ENABLE_OVERLOADING)
    WebPageGetIdMethodInfo                  ,
#endif
    webPageGetId                            ,


-- ** getMainFrame #method:getMainFrame#

#if defined(ENABLE_OVERLOADING)
    WebPageGetMainFrameMethodInfo           ,
#endif
    webPageGetMainFrame                     ,


-- ** getUri #method:getUri#

#if defined(ENABLE_OVERLOADING)
    WebPageGetUriMethodInfo                 ,
#endif
    webPageGetUri                           ,


-- ** sendMessageToView #method:sendMessageToView#

#if defined(ENABLE_OVERLOADING)
    WebPageSendMessageToViewMethodInfo      ,
#endif
    webPageSendMessageToView                ,


-- ** sendMessageToViewFinish #method:sendMessageToViewFinish#

#if defined(ENABLE_OVERLOADING)
    WebPageSendMessageToViewFinishMethodInfo,
#endif
    webPageSendMessageToViewFinish          ,




 -- * Properties


-- ** uri #attr:uri#
-- | The current active URI of the t'GI.WebKit2WebExtension.Objects.WebPage.WebPage'.

#if defined(ENABLE_OVERLOADING)
    WebPageUriPropertyInfo                  ,
#endif
    getWebPageUri                           ,
#if defined(ENABLE_OVERLOADING)
    webPageUri                              ,
#endif




 -- * Signals


-- ** consoleMessageSent #signal:consoleMessageSent#

    C_WebPageConsoleMessageSentCallback     ,
    WebPageConsoleMessageSentCallback       ,
#if defined(ENABLE_OVERLOADING)
    WebPageConsoleMessageSentSignalInfo     ,
#endif
    afterWebPageConsoleMessageSent          ,
    genClosure_WebPageConsoleMessageSent    ,
    mk_WebPageConsoleMessageSentCallback    ,
    noWebPageConsoleMessageSentCallback     ,
    onWebPageConsoleMessageSent             ,
    wrap_WebPageConsoleMessageSentCallback  ,


-- ** contextMenu #signal:contextMenu#

    C_WebPageContextMenuCallback            ,
    WebPageContextMenuCallback              ,
#if defined(ENABLE_OVERLOADING)
    WebPageContextMenuSignalInfo            ,
#endif
    afterWebPageContextMenu                 ,
    genClosure_WebPageContextMenu           ,
    mk_WebPageContextMenuCallback           ,
    noWebPageContextMenuCallback            ,
    onWebPageContextMenu                    ,
    wrap_WebPageContextMenuCallback         ,


-- ** documentLoaded #signal:documentLoaded#

    C_WebPageDocumentLoadedCallback         ,
    WebPageDocumentLoadedCallback           ,
#if defined(ENABLE_OVERLOADING)
    WebPageDocumentLoadedSignalInfo         ,
#endif
    afterWebPageDocumentLoaded              ,
    genClosure_WebPageDocumentLoaded        ,
    mk_WebPageDocumentLoadedCallback        ,
    noWebPageDocumentLoadedCallback         ,
    onWebPageDocumentLoaded                 ,
    wrap_WebPageDocumentLoadedCallback      ,


-- ** formControlsAssociated #signal:formControlsAssociated#

    C_WebPageFormControlsAssociatedCallback ,
    WebPageFormControlsAssociatedCallback   ,
#if defined(ENABLE_OVERLOADING)
    WebPageFormControlsAssociatedSignalInfo ,
#endif
    afterWebPageFormControlsAssociated      ,
    genClosure_WebPageFormControlsAssociated,
    mk_WebPageFormControlsAssociatedCallback,
    noWebPageFormControlsAssociatedCallback ,
    onWebPageFormControlsAssociated         ,
    wrap_WebPageFormControlsAssociatedCallback,


-- ** formControlsAssociatedForFrame #signal:formControlsAssociatedForFrame#

    C_WebPageFormControlsAssociatedForFrameCallback,
    WebPageFormControlsAssociatedForFrameCallback,
#if defined(ENABLE_OVERLOADING)
    WebPageFormControlsAssociatedForFrameSignalInfo,
#endif
    afterWebPageFormControlsAssociatedForFrame,
    genClosure_WebPageFormControlsAssociatedForFrame,
    mk_WebPageFormControlsAssociatedForFrameCallback,
    noWebPageFormControlsAssociatedForFrameCallback,
    onWebPageFormControlsAssociatedForFrame ,
    wrap_WebPageFormControlsAssociatedForFrameCallback,


-- ** sendRequest #signal:sendRequest#

    C_WebPageSendRequestCallback            ,
    WebPageSendRequestCallback              ,
#if defined(ENABLE_OVERLOADING)
    WebPageSendRequestSignalInfo            ,
#endif
    afterWebPageSendRequest                 ,
    genClosure_WebPageSendRequest           ,
    mk_WebPageSendRequestCallback           ,
    noWebPageSendRequestCallback            ,
    onWebPageSendRequest                    ,
    wrap_WebPageSendRequestCallback         ,


-- ** userMessageReceived #signal:userMessageReceived#

    C_WebPageUserMessageReceivedCallback    ,
    WebPageUserMessageReceivedCallback      ,
#if defined(ENABLE_OVERLOADING)
    WebPageUserMessageReceivedSignalInfo    ,
#endif
    afterWebPageUserMessageReceived         ,
    genClosure_WebPageUserMessageReceived   ,
    mk_WebPageUserMessageReceivedCallback   ,
    noWebPageUserMessageReceivedCallback    ,
    onWebPageUserMessageReceived            ,
    wrap_WebPageUserMessageReceivedCallback ,


-- ** willSubmitForm #signal:willSubmitForm#

    C_WebPageWillSubmitFormCallback         ,
    WebPageWillSubmitFormCallback           ,
#if defined(ENABLE_OVERLOADING)
    WebPageWillSubmitFormSignalInfo         ,
#endif
    afterWebPageWillSubmitForm              ,
    genClosure_WebPageWillSubmitForm        ,
    mk_WebPageWillSubmitFormCallback        ,
    noWebPageWillSubmitFormCallback         ,
    onWebPageWillSubmitForm                 ,
    wrap_WebPageWillSubmitFormCallback      ,




    ) 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.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 GHC.Records as R

import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gio.Callbacks as Gio.Callbacks
import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult
import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable
import {-# SOURCE #-} qualified GI.WebKit2WebExtension.Enums as WebKit2WebExtension.Enums
import {-# SOURCE #-} qualified GI.WebKit2WebExtension.Objects.ContextMenu as WebKit2WebExtension.ContextMenu
import {-# SOURCE #-} qualified GI.WebKit2WebExtension.Objects.DOMDocument as WebKit2WebExtension.DOMDocument
import {-# SOURCE #-} qualified GI.WebKit2WebExtension.Objects.DOMElement as WebKit2WebExtension.DOMElement
import {-# SOURCE #-} qualified GI.WebKit2WebExtension.Objects.Frame as WebKit2WebExtension.Frame
import {-# SOURCE #-} qualified GI.WebKit2WebExtension.Objects.URIRequest as WebKit2WebExtension.URIRequest
import {-# SOURCE #-} qualified GI.WebKit2WebExtension.Objects.URIResponse as WebKit2WebExtension.URIResponse
import {-# SOURCE #-} qualified GI.WebKit2WebExtension.Objects.UserMessage as WebKit2WebExtension.UserMessage
import {-# SOURCE #-} qualified GI.WebKit2WebExtension.Objects.WebEditor as WebKit2WebExtension.WebEditor
import {-# SOURCE #-} qualified GI.WebKit2WebExtension.Objects.WebHitTestResult as WebKit2WebExtension.WebHitTestResult
import {-# SOURCE #-} qualified GI.WebKit2WebExtension.Structs.ConsoleMessage as WebKit2WebExtension.ConsoleMessage

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

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

foreign import ccall "webkit_web_page_get_type"
    c_webkit_web_page_get_type :: IO B.Types.GType

instance B.Types.TypedObject WebPage where
    glibType :: IO GType
glibType = IO GType
c_webkit_web_page_get_type

instance B.Types.GObject WebPage

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

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

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

-- | Convert 'WebPage' 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 WebPage) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_webkit_web_page_get_type
    gvalueSet_ :: Ptr GValue -> Maybe WebPage -> IO ()
gvalueSet_ Ptr GValue
gv Maybe WebPage
P.Nothing = Ptr GValue -> Ptr WebPage -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr WebPage
forall a. Ptr a
FP.nullPtr :: FP.Ptr WebPage)
    gvalueSet_ Ptr GValue
gv (P.Just WebPage
obj) = WebPage -> (Ptr WebPage -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr WebPage
obj (Ptr GValue -> Ptr WebPage -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe WebPage)
gvalueGet_ Ptr GValue
gv = do
        Ptr WebPage
ptr <- Ptr GValue -> IO (Ptr WebPage)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr WebPage)
        if Ptr WebPage
ptr Ptr WebPage -> Ptr WebPage -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr WebPage
forall a. Ptr a
FP.nullPtr
        then WebPage -> Maybe WebPage
forall a. a -> Maybe a
P.Just (WebPage -> Maybe WebPage) -> IO WebPage -> IO (Maybe WebPage)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr WebPage -> WebPage) -> Ptr WebPage -> IO WebPage
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr WebPage -> WebPage
WebPage Ptr WebPage
ptr
        else Maybe WebPage -> IO (Maybe WebPage)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WebPage
forall a. Maybe a
P.Nothing
        
    

#if defined(ENABLE_OVERLOADING)
type family ResolveWebPageMethod (t :: Symbol) (o :: *) :: * where
    ResolveWebPageMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveWebPageMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveWebPageMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveWebPageMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveWebPageMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveWebPageMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveWebPageMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveWebPageMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveWebPageMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveWebPageMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveWebPageMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveWebPageMethod "sendMessageToView" o = WebPageSendMessageToViewMethodInfo
    ResolveWebPageMethod "sendMessageToViewFinish" o = WebPageSendMessageToViewFinishMethodInfo
    ResolveWebPageMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveWebPageMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveWebPageMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveWebPageMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveWebPageMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveWebPageMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveWebPageMethod "getDomDocument" o = WebPageGetDomDocumentMethodInfo
    ResolveWebPageMethod "getEditor" o = WebPageGetEditorMethodInfo
    ResolveWebPageMethod "getId" o = WebPageGetIdMethodInfo
    ResolveWebPageMethod "getMainFrame" o = WebPageGetMainFrameMethodInfo
    ResolveWebPageMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveWebPageMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveWebPageMethod "getUri" o = WebPageGetUriMethodInfo
    ResolveWebPageMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveWebPageMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveWebPageMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveWebPageMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveWebPageMethod t WebPage, O.OverloadedMethod info WebPage p) => OL.IsLabel t (WebPage -> 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 ~ ResolveWebPageMethod t WebPage, O.OverloadedMethod info WebPage p, R.HasField t WebPage p) => R.HasField t WebPage p where
    getField = O.overloadedMethod @info

#endif

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

#endif

-- signal WebPage::console-message-sent
-- | Emitted when a message is sent to the console. This can be a message
-- produced by the use of JavaScript console API, a JavaScript exception,
-- a security error or other errors, warnings, debug or log messages.
-- The /@consoleMessage@/ contains information of the message.
-- 
-- /Since: 2.12/
type WebPageConsoleMessageSentCallback =
    WebKit2WebExtension.ConsoleMessage.ConsoleMessage
    -- ^ /@consoleMessage@/: the t'GI.WebKit2WebExtension.Structs.ConsoleMessage.ConsoleMessage'
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `WebPageConsoleMessageSentCallback`@.
noWebPageConsoleMessageSentCallback :: Maybe WebPageConsoleMessageSentCallback
noWebPageConsoleMessageSentCallback :: Maybe WebPageConsoleMessageSentCallback
noWebPageConsoleMessageSentCallback = Maybe WebPageConsoleMessageSentCallback
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_WebPageConsoleMessageSent :: MonadIO m => WebPageConsoleMessageSentCallback -> m (GClosure C_WebPageConsoleMessageSentCallback)
genClosure_WebPageConsoleMessageSent :: forall (m :: * -> *).
MonadIO m =>
WebPageConsoleMessageSentCallback
-> m (GClosure C_WebPageConsoleMessageSentCallback)
genClosure_WebPageConsoleMessageSent WebPageConsoleMessageSentCallback
cb = IO (GClosure C_WebPageConsoleMessageSentCallback)
-> m (GClosure C_WebPageConsoleMessageSentCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_WebPageConsoleMessageSentCallback)
 -> m (GClosure C_WebPageConsoleMessageSentCallback))
-> IO (GClosure C_WebPageConsoleMessageSentCallback)
-> m (GClosure C_WebPageConsoleMessageSentCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_WebPageConsoleMessageSentCallback
cb' = WebPageConsoleMessageSentCallback
-> C_WebPageConsoleMessageSentCallback
wrap_WebPageConsoleMessageSentCallback WebPageConsoleMessageSentCallback
cb
    C_WebPageConsoleMessageSentCallback
-> IO (FunPtr C_WebPageConsoleMessageSentCallback)
mk_WebPageConsoleMessageSentCallback C_WebPageConsoleMessageSentCallback
cb' IO (FunPtr C_WebPageConsoleMessageSentCallback)
-> (FunPtr C_WebPageConsoleMessageSentCallback
    -> IO (GClosure C_WebPageConsoleMessageSentCallback))
-> IO (GClosure C_WebPageConsoleMessageSentCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_WebPageConsoleMessageSentCallback
-> IO (GClosure C_WebPageConsoleMessageSentCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `WebPageConsoleMessageSentCallback` into a `C_WebPageConsoleMessageSentCallback`.
wrap_WebPageConsoleMessageSentCallback ::
    WebPageConsoleMessageSentCallback ->
    C_WebPageConsoleMessageSentCallback
wrap_WebPageConsoleMessageSentCallback :: WebPageConsoleMessageSentCallback
-> C_WebPageConsoleMessageSentCallback
wrap_WebPageConsoleMessageSentCallback WebPageConsoleMessageSentCallback
_cb Ptr ()
_ Ptr ConsoleMessage
consoleMessage Ptr ()
_ = do
    (ManagedPtr ConsoleMessage -> ConsoleMessage)
-> Ptr ConsoleMessage -> WebPageConsoleMessageSentCallback -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr ConsoleMessage -> ConsoleMessage
WebKit2WebExtension.ConsoleMessage.ConsoleMessage Ptr ConsoleMessage
consoleMessage (WebPageConsoleMessageSentCallback -> IO ())
-> WebPageConsoleMessageSentCallback -> IO ()
forall a b. (a -> b) -> a -> b
$ \ConsoleMessage
consoleMessage' -> do
        WebPageConsoleMessageSentCallback
_cb  ConsoleMessage
consoleMessage'


-- | Connect a signal handler for the [consoleMessageSent](#signal:consoleMessageSent) 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' webPage #consoleMessageSent callback
-- @
-- 
-- 
onWebPageConsoleMessageSent :: (IsWebPage a, MonadIO m) => a -> WebPageConsoleMessageSentCallback -> m SignalHandlerId
onWebPageConsoleMessageSent :: forall a (m :: * -> *).
(IsWebPage a, MonadIO m) =>
a -> WebPageConsoleMessageSentCallback -> m SignalHandlerId
onWebPageConsoleMessageSent a
obj WebPageConsoleMessageSentCallback
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_WebPageConsoleMessageSentCallback
cb' = WebPageConsoleMessageSentCallback
-> C_WebPageConsoleMessageSentCallback
wrap_WebPageConsoleMessageSentCallback WebPageConsoleMessageSentCallback
cb
    FunPtr C_WebPageConsoleMessageSentCallback
cb'' <- C_WebPageConsoleMessageSentCallback
-> IO (FunPtr C_WebPageConsoleMessageSentCallback)
mk_WebPageConsoleMessageSentCallback C_WebPageConsoleMessageSentCallback
cb'
    a
-> Text
-> FunPtr C_WebPageConsoleMessageSentCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"console-message-sent" FunPtr C_WebPageConsoleMessageSentCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [consoleMessageSent](#signal:consoleMessageSent) 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' webPage #consoleMessageSent callback
-- @
-- 
-- 
afterWebPageConsoleMessageSent :: (IsWebPage a, MonadIO m) => a -> WebPageConsoleMessageSentCallback -> m SignalHandlerId
afterWebPageConsoleMessageSent :: forall a (m :: * -> *).
(IsWebPage a, MonadIO m) =>
a -> WebPageConsoleMessageSentCallback -> m SignalHandlerId
afterWebPageConsoleMessageSent a
obj WebPageConsoleMessageSentCallback
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_WebPageConsoleMessageSentCallback
cb' = WebPageConsoleMessageSentCallback
-> C_WebPageConsoleMessageSentCallback
wrap_WebPageConsoleMessageSentCallback WebPageConsoleMessageSentCallback
cb
    FunPtr C_WebPageConsoleMessageSentCallback
cb'' <- C_WebPageConsoleMessageSentCallback
-> IO (FunPtr C_WebPageConsoleMessageSentCallback)
mk_WebPageConsoleMessageSentCallback C_WebPageConsoleMessageSentCallback
cb'
    a
-> Text
-> FunPtr C_WebPageConsoleMessageSentCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"console-message-sent" FunPtr C_WebPageConsoleMessageSentCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data WebPageConsoleMessageSentSignalInfo
instance SignalInfo WebPageConsoleMessageSentSignalInfo where
    type HaskellCallbackType WebPageConsoleMessageSentSignalInfo = WebPageConsoleMessageSentCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_WebPageConsoleMessageSentCallback cb
        cb'' <- mk_WebPageConsoleMessageSentCallback cb'
        connectSignalFunPtr obj "console-message-sent" cb'' connectMode detail

#endif

-- signal WebPage::context-menu
-- | Emitted before a context menu is displayed in the UI Process to
-- give the application a chance to customize the proposed menu,
-- build its own context menu or pass user data to the UI Process.
-- This signal is useful when the information available in the UI Process
-- is not enough to build or customize the context menu, for example, to
-- add menu entries depending on the t'GI.WebKit2WebExtension.Objects.DOMNode.DOMNode' at the coordinates of the
-- /@hitTestResult@/. Otherwise, it\'s recommended to use @/WebKitWebView::context-menu/@
-- signal instead.
-- 
-- /Since: 2.8/
type WebPageContextMenuCallback =
    WebKit2WebExtension.ContextMenu.ContextMenu
    -- ^ /@contextMenu@/: the proposed @/WebKitContextMenu/@
    -> WebKit2WebExtension.WebHitTestResult.WebHitTestResult
    -- ^ /@hitTestResult@/: a t'GI.WebKit2WebExtension.Objects.WebHitTestResult.WebHitTestResult'
    -> IO Bool
    -- ^ __Returns:__ 'P.True' if the proposed /@contextMenu@/ has been modified, or 'P.False' otherwise.

-- | A convenience synonym for @`Nothing` :: `Maybe` `WebPageContextMenuCallback`@.
noWebPageContextMenuCallback :: Maybe WebPageContextMenuCallback
noWebPageContextMenuCallback :: Maybe WebPageContextMenuCallback
noWebPageContextMenuCallback = Maybe WebPageContextMenuCallback
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_WebPageContextMenuCallback =
    Ptr () ->                               -- object
    Ptr WebKit2WebExtension.ContextMenu.ContextMenu ->
    Ptr WebKit2WebExtension.WebHitTestResult.WebHitTestResult ->
    Ptr () ->                               -- user_data
    IO CInt

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

-- | Wrap the callback into a `GClosure`.
genClosure_WebPageContextMenu :: MonadIO m => WebPageContextMenuCallback -> m (GClosure C_WebPageContextMenuCallback)
genClosure_WebPageContextMenu :: forall (m :: * -> *).
MonadIO m =>
WebPageContextMenuCallback
-> m (GClosure C_WebPageContextMenuCallback)
genClosure_WebPageContextMenu WebPageContextMenuCallback
cb = IO (GClosure C_WebPageContextMenuCallback)
-> m (GClosure C_WebPageContextMenuCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_WebPageContextMenuCallback)
 -> m (GClosure C_WebPageContextMenuCallback))
-> IO (GClosure C_WebPageContextMenuCallback)
-> m (GClosure C_WebPageContextMenuCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_WebPageContextMenuCallback
cb' = WebPageContextMenuCallback -> C_WebPageContextMenuCallback
wrap_WebPageContextMenuCallback WebPageContextMenuCallback
cb
    C_WebPageContextMenuCallback
-> IO (FunPtr C_WebPageContextMenuCallback)
mk_WebPageContextMenuCallback C_WebPageContextMenuCallback
cb' IO (FunPtr C_WebPageContextMenuCallback)
-> (FunPtr C_WebPageContextMenuCallback
    -> IO (GClosure C_WebPageContextMenuCallback))
-> IO (GClosure C_WebPageContextMenuCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_WebPageContextMenuCallback
-> IO (GClosure C_WebPageContextMenuCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `WebPageContextMenuCallback` into a `C_WebPageContextMenuCallback`.
wrap_WebPageContextMenuCallback ::
    WebPageContextMenuCallback ->
    C_WebPageContextMenuCallback
wrap_WebPageContextMenuCallback :: WebPageContextMenuCallback -> C_WebPageContextMenuCallback
wrap_WebPageContextMenuCallback WebPageContextMenuCallback
_cb Ptr ()
_ Ptr ContextMenu
contextMenu Ptr WebHitTestResult
hitTestResult Ptr ()
_ = do
    ContextMenu
contextMenu' <- ((ManagedPtr ContextMenu -> ContextMenu)
-> Ptr ContextMenu -> IO ContextMenu
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr ContextMenu -> ContextMenu
WebKit2WebExtension.ContextMenu.ContextMenu) Ptr ContextMenu
contextMenu
    WebHitTestResult
hitTestResult' <- ((ManagedPtr WebHitTestResult -> WebHitTestResult)
-> Ptr WebHitTestResult -> IO WebHitTestResult
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr WebHitTestResult -> WebHitTestResult
WebKit2WebExtension.WebHitTestResult.WebHitTestResult) Ptr WebHitTestResult
hitTestResult
    Bool
result <- WebPageContextMenuCallback
_cb  ContextMenu
contextMenu' WebHitTestResult
hitTestResult'
    let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
result
    CInt -> IO CInt
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'


-- | Connect a signal handler for the [contextMenu](#signal:contextMenu) 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' webPage #contextMenu callback
-- @
-- 
-- 
onWebPageContextMenu :: (IsWebPage a, MonadIO m) => a -> WebPageContextMenuCallback -> m SignalHandlerId
onWebPageContextMenu :: forall a (m :: * -> *).
(IsWebPage a, MonadIO m) =>
a -> WebPageContextMenuCallback -> m SignalHandlerId
onWebPageContextMenu a
obj WebPageContextMenuCallback
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_WebPageContextMenuCallback
cb' = WebPageContextMenuCallback -> C_WebPageContextMenuCallback
wrap_WebPageContextMenuCallback WebPageContextMenuCallback
cb
    FunPtr C_WebPageContextMenuCallback
cb'' <- C_WebPageContextMenuCallback
-> IO (FunPtr C_WebPageContextMenuCallback)
mk_WebPageContextMenuCallback C_WebPageContextMenuCallback
cb'
    a
-> Text
-> FunPtr C_WebPageContextMenuCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"context-menu" FunPtr C_WebPageContextMenuCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [contextMenu](#signal:contextMenu) 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' webPage #contextMenu callback
-- @
-- 
-- 
afterWebPageContextMenu :: (IsWebPage a, MonadIO m) => a -> WebPageContextMenuCallback -> m SignalHandlerId
afterWebPageContextMenu :: forall a (m :: * -> *).
(IsWebPage a, MonadIO m) =>
a -> WebPageContextMenuCallback -> m SignalHandlerId
afterWebPageContextMenu a
obj WebPageContextMenuCallback
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_WebPageContextMenuCallback
cb' = WebPageContextMenuCallback -> C_WebPageContextMenuCallback
wrap_WebPageContextMenuCallback WebPageContextMenuCallback
cb
    FunPtr C_WebPageContextMenuCallback
cb'' <- C_WebPageContextMenuCallback
-> IO (FunPtr C_WebPageContextMenuCallback)
mk_WebPageContextMenuCallback C_WebPageContextMenuCallback
cb'
    a
-> Text
-> FunPtr C_WebPageContextMenuCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"context-menu" FunPtr C_WebPageContextMenuCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data WebPageContextMenuSignalInfo
instance SignalInfo WebPageContextMenuSignalInfo where
    type HaskellCallbackType WebPageContextMenuSignalInfo = WebPageContextMenuCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_WebPageContextMenuCallback cb
        cb'' <- mk_WebPageContextMenuCallback cb'
        connectSignalFunPtr obj "context-menu" cb'' connectMode detail

#endif

-- signal WebPage::document-loaded
-- | This signal is emitted when the DOM document of a t'GI.WebKit2WebExtension.Objects.WebPage.WebPage' has been
-- loaded.
-- 
-- You can wait for this signal to get the DOM document with
-- 'GI.WebKit2WebExtension.Objects.WebPage.webPageGetDomDocument'.
type WebPageDocumentLoadedCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `WebPageDocumentLoadedCallback`@.
noWebPageDocumentLoadedCallback :: Maybe WebPageDocumentLoadedCallback
noWebPageDocumentLoadedCallback :: Maybe (IO ())
noWebPageDocumentLoadedCallback = Maybe (IO ())
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_WebPageDocumentLoaded :: MonadIO m => WebPageDocumentLoadedCallback -> m (GClosure C_WebPageDocumentLoadedCallback)
genClosure_WebPageDocumentLoaded :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_WebPageDocumentLoadedCallback)
genClosure_WebPageDocumentLoaded IO ()
cb = IO (GClosure C_WebPageDocumentLoadedCallback)
-> m (GClosure C_WebPageDocumentLoadedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_WebPageDocumentLoadedCallback)
 -> m (GClosure C_WebPageDocumentLoadedCallback))
-> IO (GClosure C_WebPageDocumentLoadedCallback)
-> m (GClosure C_WebPageDocumentLoadedCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_WebPageDocumentLoadedCallback
cb' = IO () -> C_WebPageDocumentLoadedCallback
wrap_WebPageDocumentLoadedCallback IO ()
cb
    C_WebPageDocumentLoadedCallback
-> IO (FunPtr C_WebPageDocumentLoadedCallback)
mk_WebPageDocumentLoadedCallback C_WebPageDocumentLoadedCallback
cb' IO (FunPtr C_WebPageDocumentLoadedCallback)
-> (FunPtr C_WebPageDocumentLoadedCallback
    -> IO (GClosure C_WebPageDocumentLoadedCallback))
-> IO (GClosure C_WebPageDocumentLoadedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_WebPageDocumentLoadedCallback
-> IO (GClosure C_WebPageDocumentLoadedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `WebPageDocumentLoadedCallback` into a `C_WebPageDocumentLoadedCallback`.
wrap_WebPageDocumentLoadedCallback ::
    WebPageDocumentLoadedCallback ->
    C_WebPageDocumentLoadedCallback
wrap_WebPageDocumentLoadedCallback :: IO () -> C_WebPageDocumentLoadedCallback
wrap_WebPageDocumentLoadedCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


-- | Connect a signal handler for the [documentLoaded](#signal:documentLoaded) 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' webPage #documentLoaded callback
-- @
-- 
-- 
onWebPageDocumentLoaded :: (IsWebPage a, MonadIO m) => a -> WebPageDocumentLoadedCallback -> m SignalHandlerId
onWebPageDocumentLoaded :: forall a (m :: * -> *).
(IsWebPage a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onWebPageDocumentLoaded a
obj IO ()
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_WebPageDocumentLoadedCallback
cb' = IO () -> C_WebPageDocumentLoadedCallback
wrap_WebPageDocumentLoadedCallback IO ()
cb
    FunPtr C_WebPageDocumentLoadedCallback
cb'' <- C_WebPageDocumentLoadedCallback
-> IO (FunPtr C_WebPageDocumentLoadedCallback)
mk_WebPageDocumentLoadedCallback C_WebPageDocumentLoadedCallback
cb'
    a
-> Text
-> FunPtr C_WebPageDocumentLoadedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"document-loaded" FunPtr C_WebPageDocumentLoadedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [documentLoaded](#signal:documentLoaded) 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' webPage #documentLoaded callback
-- @
-- 
-- 
afterWebPageDocumentLoaded :: (IsWebPage a, MonadIO m) => a -> WebPageDocumentLoadedCallback -> m SignalHandlerId
afterWebPageDocumentLoaded :: forall a (m :: * -> *).
(IsWebPage a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterWebPageDocumentLoaded a
obj IO ()
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_WebPageDocumentLoadedCallback
cb' = IO () -> C_WebPageDocumentLoadedCallback
wrap_WebPageDocumentLoadedCallback IO ()
cb
    FunPtr C_WebPageDocumentLoadedCallback
cb'' <- C_WebPageDocumentLoadedCallback
-> IO (FunPtr C_WebPageDocumentLoadedCallback)
mk_WebPageDocumentLoadedCallback C_WebPageDocumentLoadedCallback
cb'
    a
-> Text
-> FunPtr C_WebPageDocumentLoadedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"document-loaded" FunPtr C_WebPageDocumentLoadedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data WebPageDocumentLoadedSignalInfo
instance SignalInfo WebPageDocumentLoadedSignalInfo where
    type HaskellCallbackType WebPageDocumentLoadedSignalInfo = WebPageDocumentLoadedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_WebPageDocumentLoadedCallback cb
        cb'' <- mk_WebPageDocumentLoadedCallback cb'
        connectSignalFunPtr obj "document-loaded" cb'' connectMode detail

#endif

-- signal WebPage::form-controls-associated
{-# DEPRECATED WebPageFormControlsAssociatedCallback ["(Since version 2.26)",", use [formControlsAssociatedForFrame](\"GI.WebKit2WebExtension.Objects.WebPage#g:signal:formControlsAssociatedForFrame\") instead."] #-}
-- | Emitted after form elements (or form associated elements) are associated to a particular web
-- page. This is useful to implement form auto filling for web pages where form fields are added
-- dynamically. This signal might be emitted multiple times for the same web page.
-- 
-- Note that this signal could be also emitted when form controls are moved between forms. In
-- that case, the /@elements@/ array carries the list of those elements which have moved.
-- 
-- Clients should take a reference to the members of the /@elements@/ array if it is desired to
-- keep them alive after the signal handler returns.
-- 
-- /Since: 2.16/
type WebPageFormControlsAssociatedCallback =
    [WebKit2WebExtension.DOMElement.DOMElement]
    -- ^ /@elements@/: a t'GI.GLib.Structs.PtrArray.PtrArray' of
    --     t'GI.WebKit2WebExtension.Objects.DOMElement.DOMElement' with the list of forms in the page
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `WebPageFormControlsAssociatedCallback`@.
noWebPageFormControlsAssociatedCallback :: Maybe WebPageFormControlsAssociatedCallback
noWebPageFormControlsAssociatedCallback :: Maybe WebPageFormControlsAssociatedCallback
noWebPageFormControlsAssociatedCallback = Maybe WebPageFormControlsAssociatedCallback
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_WebPageFormControlsAssociated :: MonadIO m => WebPageFormControlsAssociatedCallback -> m (GClosure C_WebPageFormControlsAssociatedCallback)
genClosure_WebPageFormControlsAssociated :: forall (m :: * -> *).
MonadIO m =>
WebPageFormControlsAssociatedCallback
-> m (GClosure C_WebPageFormControlsAssociatedCallback)
genClosure_WebPageFormControlsAssociated WebPageFormControlsAssociatedCallback
cb = IO (GClosure C_WebPageFormControlsAssociatedCallback)
-> m (GClosure C_WebPageFormControlsAssociatedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_WebPageFormControlsAssociatedCallback)
 -> m (GClosure C_WebPageFormControlsAssociatedCallback))
-> IO (GClosure C_WebPageFormControlsAssociatedCallback)
-> m (GClosure C_WebPageFormControlsAssociatedCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_WebPageFormControlsAssociatedCallback
cb' = WebPageFormControlsAssociatedCallback
-> C_WebPageFormControlsAssociatedCallback
wrap_WebPageFormControlsAssociatedCallback WebPageFormControlsAssociatedCallback
cb
    C_WebPageFormControlsAssociatedCallback
-> IO (FunPtr C_WebPageFormControlsAssociatedCallback)
mk_WebPageFormControlsAssociatedCallback C_WebPageFormControlsAssociatedCallback
cb' IO (FunPtr C_WebPageFormControlsAssociatedCallback)
-> (FunPtr C_WebPageFormControlsAssociatedCallback
    -> IO (GClosure C_WebPageFormControlsAssociatedCallback))
-> IO (GClosure C_WebPageFormControlsAssociatedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_WebPageFormControlsAssociatedCallback
-> IO (GClosure C_WebPageFormControlsAssociatedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `WebPageFormControlsAssociatedCallback` into a `C_WebPageFormControlsAssociatedCallback`.
wrap_WebPageFormControlsAssociatedCallback ::
    WebPageFormControlsAssociatedCallback ->
    C_WebPageFormControlsAssociatedCallback
wrap_WebPageFormControlsAssociatedCallback :: WebPageFormControlsAssociatedCallback
-> C_WebPageFormControlsAssociatedCallback
wrap_WebPageFormControlsAssociatedCallback WebPageFormControlsAssociatedCallback
_cb Ptr ()
_ Ptr (GPtrArray (Ptr DOMElement))
elements Ptr ()
_ = do
    [Ptr DOMElement]
elements' <- Ptr (GPtrArray (Ptr DOMElement)) -> IO [Ptr DOMElement]
forall a. Ptr (GPtrArray (Ptr a)) -> IO [Ptr a]
unpackGPtrArray Ptr (GPtrArray (Ptr DOMElement))
elements
    [DOMElement]
elements'' <- (Ptr DOMElement -> IO DOMElement)
-> [Ptr DOMElement] -> IO [DOMElement]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((ManagedPtr DOMElement -> DOMElement)
-> Ptr DOMElement -> IO DOMElement
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr DOMElement -> DOMElement
WebKit2WebExtension.DOMElement.DOMElement) [Ptr DOMElement]
elements'
    WebPageFormControlsAssociatedCallback
_cb  [DOMElement]
elements''


-- | Connect a signal handler for the [formControlsAssociated](#signal:formControlsAssociated) 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' webPage #formControlsAssociated callback
-- @
-- 
-- 
onWebPageFormControlsAssociated :: (IsWebPage a, MonadIO m) => a -> WebPageFormControlsAssociatedCallback -> m SignalHandlerId
onWebPageFormControlsAssociated :: forall a (m :: * -> *).
(IsWebPage a, MonadIO m) =>
a -> WebPageFormControlsAssociatedCallback -> m SignalHandlerId
onWebPageFormControlsAssociated a
obj WebPageFormControlsAssociatedCallback
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_WebPageFormControlsAssociatedCallback
cb' = WebPageFormControlsAssociatedCallback
-> C_WebPageFormControlsAssociatedCallback
wrap_WebPageFormControlsAssociatedCallback WebPageFormControlsAssociatedCallback
cb
    FunPtr C_WebPageFormControlsAssociatedCallback
cb'' <- C_WebPageFormControlsAssociatedCallback
-> IO (FunPtr C_WebPageFormControlsAssociatedCallback)
mk_WebPageFormControlsAssociatedCallback C_WebPageFormControlsAssociatedCallback
cb'
    a
-> Text
-> FunPtr C_WebPageFormControlsAssociatedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"form-controls-associated" FunPtr C_WebPageFormControlsAssociatedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [formControlsAssociated](#signal:formControlsAssociated) 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' webPage #formControlsAssociated callback
-- @
-- 
-- 
afterWebPageFormControlsAssociated :: (IsWebPage a, MonadIO m) => a -> WebPageFormControlsAssociatedCallback -> m SignalHandlerId
afterWebPageFormControlsAssociated :: forall a (m :: * -> *).
(IsWebPage a, MonadIO m) =>
a -> WebPageFormControlsAssociatedCallback -> m SignalHandlerId
afterWebPageFormControlsAssociated a
obj WebPageFormControlsAssociatedCallback
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_WebPageFormControlsAssociatedCallback
cb' = WebPageFormControlsAssociatedCallback
-> C_WebPageFormControlsAssociatedCallback
wrap_WebPageFormControlsAssociatedCallback WebPageFormControlsAssociatedCallback
cb
    FunPtr C_WebPageFormControlsAssociatedCallback
cb'' <- C_WebPageFormControlsAssociatedCallback
-> IO (FunPtr C_WebPageFormControlsAssociatedCallback)
mk_WebPageFormControlsAssociatedCallback C_WebPageFormControlsAssociatedCallback
cb'
    a
-> Text
-> FunPtr C_WebPageFormControlsAssociatedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"form-controls-associated" FunPtr C_WebPageFormControlsAssociatedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data WebPageFormControlsAssociatedSignalInfo
instance SignalInfo WebPageFormControlsAssociatedSignalInfo where
    type HaskellCallbackType WebPageFormControlsAssociatedSignalInfo = WebPageFormControlsAssociatedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_WebPageFormControlsAssociatedCallback cb
        cb'' <- mk_WebPageFormControlsAssociatedCallback cb'
        connectSignalFunPtr obj "form-controls-associated" cb'' connectMode detail

#endif

-- signal WebPage::form-controls-associated-for-frame
-- | Emitted after form elements (or form associated elements) are associated to a particular web
-- page. This is useful to implement form auto filling for web pages where form fields are added
-- dynamically. This signal might be emitted multiple times for the same web page.
-- 
-- Note that this signal could be also emitted when form controls are moved between forms. In
-- that case, the /@elements@/ array carries the list of those elements which have moved.
-- 
-- Clients should take a reference to the members of the /@elements@/ array if it is desired to
-- keep them alive after the signal handler returns.
-- 
-- /Since: 2.26/
type WebPageFormControlsAssociatedForFrameCallback =
    [WebKit2WebExtension.DOMElement.DOMElement]
    -- ^ /@elements@/: a t'GI.GLib.Structs.PtrArray.PtrArray' of
    --     t'GI.WebKit2WebExtension.Objects.DOMElement.DOMElement' with the list of forms in the page
    -> WebKit2WebExtension.Frame.Frame
    -- ^ /@frame@/: the t'GI.WebKit2WebExtension.Objects.Frame.Frame'
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `WebPageFormControlsAssociatedForFrameCallback`@.
noWebPageFormControlsAssociatedForFrameCallback :: Maybe WebPageFormControlsAssociatedForFrameCallback
noWebPageFormControlsAssociatedForFrameCallback :: Maybe WebPageFormControlsAssociatedForFrameCallback
noWebPageFormControlsAssociatedForFrameCallback = Maybe WebPageFormControlsAssociatedForFrameCallback
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_WebPageFormControlsAssociatedForFrameCallback =
    Ptr () ->                               -- object
    Ptr (GPtrArray (Ptr WebKit2WebExtension.DOMElement.DOMElement)) ->
    Ptr WebKit2WebExtension.Frame.Frame ->
    Ptr () ->                               -- user_data
    IO ()

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

-- | Wrap the callback into a `GClosure`.
genClosure_WebPageFormControlsAssociatedForFrame :: MonadIO m => WebPageFormControlsAssociatedForFrameCallback -> m (GClosure C_WebPageFormControlsAssociatedForFrameCallback)
genClosure_WebPageFormControlsAssociatedForFrame :: forall (m :: * -> *).
MonadIO m =>
WebPageFormControlsAssociatedForFrameCallback
-> m (GClosure C_WebPageFormControlsAssociatedForFrameCallback)
genClosure_WebPageFormControlsAssociatedForFrame WebPageFormControlsAssociatedForFrameCallback
cb = IO (GClosure C_WebPageFormControlsAssociatedForFrameCallback)
-> m (GClosure C_WebPageFormControlsAssociatedForFrameCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_WebPageFormControlsAssociatedForFrameCallback)
 -> m (GClosure C_WebPageFormControlsAssociatedForFrameCallback))
-> IO (GClosure C_WebPageFormControlsAssociatedForFrameCallback)
-> m (GClosure C_WebPageFormControlsAssociatedForFrameCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_WebPageFormControlsAssociatedForFrameCallback
cb' = WebPageFormControlsAssociatedForFrameCallback
-> C_WebPageFormControlsAssociatedForFrameCallback
wrap_WebPageFormControlsAssociatedForFrameCallback WebPageFormControlsAssociatedForFrameCallback
cb
    C_WebPageFormControlsAssociatedForFrameCallback
-> IO (FunPtr C_WebPageFormControlsAssociatedForFrameCallback)
mk_WebPageFormControlsAssociatedForFrameCallback C_WebPageFormControlsAssociatedForFrameCallback
cb' IO (FunPtr C_WebPageFormControlsAssociatedForFrameCallback)
-> (FunPtr C_WebPageFormControlsAssociatedForFrameCallback
    -> IO (GClosure C_WebPageFormControlsAssociatedForFrameCallback))
-> IO (GClosure C_WebPageFormControlsAssociatedForFrameCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_WebPageFormControlsAssociatedForFrameCallback
-> IO (GClosure C_WebPageFormControlsAssociatedForFrameCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `WebPageFormControlsAssociatedForFrameCallback` into a `C_WebPageFormControlsAssociatedForFrameCallback`.
wrap_WebPageFormControlsAssociatedForFrameCallback ::
    WebPageFormControlsAssociatedForFrameCallback ->
    C_WebPageFormControlsAssociatedForFrameCallback
wrap_WebPageFormControlsAssociatedForFrameCallback :: WebPageFormControlsAssociatedForFrameCallback
-> C_WebPageFormControlsAssociatedForFrameCallback
wrap_WebPageFormControlsAssociatedForFrameCallback WebPageFormControlsAssociatedForFrameCallback
_cb Ptr ()
_ Ptr (GPtrArray (Ptr DOMElement))
elements Ptr Frame
frame Ptr ()
_ = do
    [Ptr DOMElement]
elements' <- Ptr (GPtrArray (Ptr DOMElement)) -> IO [Ptr DOMElement]
forall a. Ptr (GPtrArray (Ptr a)) -> IO [Ptr a]
unpackGPtrArray Ptr (GPtrArray (Ptr DOMElement))
elements
    [DOMElement]
elements'' <- (Ptr DOMElement -> IO DOMElement)
-> [Ptr DOMElement] -> IO [DOMElement]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((ManagedPtr DOMElement -> DOMElement)
-> Ptr DOMElement -> IO DOMElement
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr DOMElement -> DOMElement
WebKit2WebExtension.DOMElement.DOMElement) [Ptr DOMElement]
elements'
    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
    WebPageFormControlsAssociatedForFrameCallback
_cb  [DOMElement]
elements'' Frame
frame'


-- | Connect a signal handler for the [formControlsAssociatedForFrame](#signal:formControlsAssociatedForFrame) 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' webPage #formControlsAssociatedForFrame callback
-- @
-- 
-- 
onWebPageFormControlsAssociatedForFrame :: (IsWebPage a, MonadIO m) => a -> WebPageFormControlsAssociatedForFrameCallback -> m SignalHandlerId
onWebPageFormControlsAssociatedForFrame :: forall a (m :: * -> *).
(IsWebPage a, MonadIO m) =>
a
-> WebPageFormControlsAssociatedForFrameCallback
-> m SignalHandlerId
onWebPageFormControlsAssociatedForFrame a
obj WebPageFormControlsAssociatedForFrameCallback
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_WebPageFormControlsAssociatedForFrameCallback
cb' = WebPageFormControlsAssociatedForFrameCallback
-> C_WebPageFormControlsAssociatedForFrameCallback
wrap_WebPageFormControlsAssociatedForFrameCallback WebPageFormControlsAssociatedForFrameCallback
cb
    FunPtr C_WebPageFormControlsAssociatedForFrameCallback
cb'' <- C_WebPageFormControlsAssociatedForFrameCallback
-> IO (FunPtr C_WebPageFormControlsAssociatedForFrameCallback)
mk_WebPageFormControlsAssociatedForFrameCallback C_WebPageFormControlsAssociatedForFrameCallback
cb'
    a
-> Text
-> FunPtr C_WebPageFormControlsAssociatedForFrameCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"form-controls-associated-for-frame" FunPtr C_WebPageFormControlsAssociatedForFrameCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [formControlsAssociatedForFrame](#signal:formControlsAssociatedForFrame) 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' webPage #formControlsAssociatedForFrame callback
-- @
-- 
-- 
afterWebPageFormControlsAssociatedForFrame :: (IsWebPage a, MonadIO m) => a -> WebPageFormControlsAssociatedForFrameCallback -> m SignalHandlerId
afterWebPageFormControlsAssociatedForFrame :: forall a (m :: * -> *).
(IsWebPage a, MonadIO m) =>
a
-> WebPageFormControlsAssociatedForFrameCallback
-> m SignalHandlerId
afterWebPageFormControlsAssociatedForFrame a
obj WebPageFormControlsAssociatedForFrameCallback
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_WebPageFormControlsAssociatedForFrameCallback
cb' = WebPageFormControlsAssociatedForFrameCallback
-> C_WebPageFormControlsAssociatedForFrameCallback
wrap_WebPageFormControlsAssociatedForFrameCallback WebPageFormControlsAssociatedForFrameCallback
cb
    FunPtr C_WebPageFormControlsAssociatedForFrameCallback
cb'' <- C_WebPageFormControlsAssociatedForFrameCallback
-> IO (FunPtr C_WebPageFormControlsAssociatedForFrameCallback)
mk_WebPageFormControlsAssociatedForFrameCallback C_WebPageFormControlsAssociatedForFrameCallback
cb'
    a
-> Text
-> FunPtr C_WebPageFormControlsAssociatedForFrameCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"form-controls-associated-for-frame" FunPtr C_WebPageFormControlsAssociatedForFrameCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data WebPageFormControlsAssociatedForFrameSignalInfo
instance SignalInfo WebPageFormControlsAssociatedForFrameSignalInfo where
    type HaskellCallbackType WebPageFormControlsAssociatedForFrameSignalInfo = WebPageFormControlsAssociatedForFrameCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_WebPageFormControlsAssociatedForFrameCallback cb
        cb'' <- mk_WebPageFormControlsAssociatedForFrameCallback cb'
        connectSignalFunPtr obj "form-controls-associated-for-frame" cb'' connectMode detail

#endif

-- signal WebPage::send-request
-- | This signal is emitted when /@request@/ is about to be sent to
-- the server. This signal can be used to modify the t'GI.WebKit2WebExtension.Objects.URIRequest.URIRequest'
-- that will be sent to the server. You can also cancel the resource load
-- operation by connecting to this signal and returning 'P.True'.
-- 
-- In case of a server redirection this signal is
-- emitted again with the /@request@/ argument containing the new
-- request to be sent to the server due to the redirection and the
-- /@redirectedResponse@/ parameter containing the response
-- received by the server for the initial request.
-- 
-- Modifications to the t'GI.WebKit2WebExtension.Objects.URIRequest.URIRequest' and its associated
-- t'GI.Soup.Structs.MessageHeaders.MessageHeaders' will be taken into account when the request
-- is sent over the network.
type WebPageSendRequestCallback =
    WebKit2WebExtension.URIRequest.URIRequest
    -- ^ /@request@/: a t'GI.WebKit2WebExtension.Objects.URIRequest.URIRequest'
    -> WebKit2WebExtension.URIResponse.URIResponse
    -- ^ /@redirectedResponse@/: a t'GI.WebKit2WebExtension.Objects.URIResponse.URIResponse', or 'P.Nothing'
    -> IO Bool
    -- ^ __Returns:__ 'P.True' to stop other handlers from being invoked for the event.
    --    'P.False' to continue emission of the event.

-- | A convenience synonym for @`Nothing` :: `Maybe` `WebPageSendRequestCallback`@.
noWebPageSendRequestCallback :: Maybe WebPageSendRequestCallback
noWebPageSendRequestCallback :: Maybe WebPageSendRequestCallback
noWebPageSendRequestCallback = Maybe WebPageSendRequestCallback
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_WebPageSendRequestCallback =
    Ptr () ->                               -- object
    Ptr WebKit2WebExtension.URIRequest.URIRequest ->
    Ptr WebKit2WebExtension.URIResponse.URIResponse ->
    Ptr () ->                               -- user_data
    IO CInt

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

-- | Wrap the callback into a `GClosure`.
genClosure_WebPageSendRequest :: MonadIO m => WebPageSendRequestCallback -> m (GClosure C_WebPageSendRequestCallback)
genClosure_WebPageSendRequest :: forall (m :: * -> *).
MonadIO m =>
WebPageSendRequestCallback
-> m (GClosure C_WebPageSendRequestCallback)
genClosure_WebPageSendRequest WebPageSendRequestCallback
cb = IO (GClosure C_WebPageSendRequestCallback)
-> m (GClosure C_WebPageSendRequestCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_WebPageSendRequestCallback)
 -> m (GClosure C_WebPageSendRequestCallback))
-> IO (GClosure C_WebPageSendRequestCallback)
-> m (GClosure C_WebPageSendRequestCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_WebPageSendRequestCallback
cb' = WebPageSendRequestCallback -> C_WebPageSendRequestCallback
wrap_WebPageSendRequestCallback WebPageSendRequestCallback
cb
    C_WebPageSendRequestCallback
-> IO (FunPtr C_WebPageSendRequestCallback)
mk_WebPageSendRequestCallback C_WebPageSendRequestCallback
cb' IO (FunPtr C_WebPageSendRequestCallback)
-> (FunPtr C_WebPageSendRequestCallback
    -> IO (GClosure C_WebPageSendRequestCallback))
-> IO (GClosure C_WebPageSendRequestCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_WebPageSendRequestCallback
-> IO (GClosure C_WebPageSendRequestCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `WebPageSendRequestCallback` into a `C_WebPageSendRequestCallback`.
wrap_WebPageSendRequestCallback ::
    WebPageSendRequestCallback ->
    C_WebPageSendRequestCallback
wrap_WebPageSendRequestCallback :: WebPageSendRequestCallback -> C_WebPageSendRequestCallback
wrap_WebPageSendRequestCallback WebPageSendRequestCallback
_cb Ptr ()
_ Ptr URIRequest
request Ptr URIResponse
redirectedResponse Ptr ()
_ = do
    URIRequest
request' <- ((ManagedPtr URIRequest -> URIRequest)
-> Ptr URIRequest -> IO URIRequest
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr URIRequest -> URIRequest
WebKit2WebExtension.URIRequest.URIRequest) Ptr URIRequest
request
    URIResponse
redirectedResponse' <- ((ManagedPtr URIResponse -> URIResponse)
-> Ptr URIResponse -> IO URIResponse
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr URIResponse -> URIResponse
WebKit2WebExtension.URIResponse.URIResponse) Ptr URIResponse
redirectedResponse
    Bool
result <- WebPageSendRequestCallback
_cb  URIRequest
request' URIResponse
redirectedResponse'
    let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
result
    CInt -> IO CInt
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'


-- | Connect a signal handler for the [sendRequest](#signal:sendRequest) 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' webPage #sendRequest callback
-- @
-- 
-- 
onWebPageSendRequest :: (IsWebPage a, MonadIO m) => a -> WebPageSendRequestCallback -> m SignalHandlerId
onWebPageSendRequest :: forall a (m :: * -> *).
(IsWebPage a, MonadIO m) =>
a -> WebPageSendRequestCallback -> m SignalHandlerId
onWebPageSendRequest a
obj WebPageSendRequestCallback
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_WebPageSendRequestCallback
cb' = WebPageSendRequestCallback -> C_WebPageSendRequestCallback
wrap_WebPageSendRequestCallback WebPageSendRequestCallback
cb
    FunPtr C_WebPageSendRequestCallback
cb'' <- C_WebPageSendRequestCallback
-> IO (FunPtr C_WebPageSendRequestCallback)
mk_WebPageSendRequestCallback C_WebPageSendRequestCallback
cb'
    a
-> Text
-> FunPtr C_WebPageSendRequestCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"send-request" FunPtr C_WebPageSendRequestCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [sendRequest](#signal:sendRequest) 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' webPage #sendRequest callback
-- @
-- 
-- 
afterWebPageSendRequest :: (IsWebPage a, MonadIO m) => a -> WebPageSendRequestCallback -> m SignalHandlerId
afterWebPageSendRequest :: forall a (m :: * -> *).
(IsWebPage a, MonadIO m) =>
a -> WebPageSendRequestCallback -> m SignalHandlerId
afterWebPageSendRequest a
obj WebPageSendRequestCallback
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_WebPageSendRequestCallback
cb' = WebPageSendRequestCallback -> C_WebPageSendRequestCallback
wrap_WebPageSendRequestCallback WebPageSendRequestCallback
cb
    FunPtr C_WebPageSendRequestCallback
cb'' <- C_WebPageSendRequestCallback
-> IO (FunPtr C_WebPageSendRequestCallback)
mk_WebPageSendRequestCallback C_WebPageSendRequestCallback
cb'
    a
-> Text
-> FunPtr C_WebPageSendRequestCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"send-request" FunPtr C_WebPageSendRequestCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data WebPageSendRequestSignalInfo
instance SignalInfo WebPageSendRequestSignalInfo where
    type HaskellCallbackType WebPageSendRequestSignalInfo = WebPageSendRequestCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_WebPageSendRequestCallback cb
        cb'' <- mk_WebPageSendRequestCallback cb'
        connectSignalFunPtr obj "send-request" cb'' connectMode detail

#endif

-- signal WebPage::user-message-received
-- | This signal is emitted when a t'GI.WebKit2WebExtension.Objects.UserMessage.UserMessage' is received from the
-- @/WebKitWebView/@ corresponding to /@webPage@/. You can reply to the message
-- using 'GI.WebKit2WebExtension.Objects.UserMessage.userMessageSendReply'.
-- 
-- You can handle the user message asynchronously by calling 'GI.GObject.Objects.Object.objectRef' on
-- /@message@/ and returning 'P.True'. If the last reference of /@message@/ is removed
-- and the message has been replied, the operation in the @/WebKitWebView/@ will
-- finish with error 'GI.WebKit2WebExtension.Enums.UserMessageErrorUserMessageUnhandledMessage'.
-- 
-- /Since: 2.28/
type WebPageUserMessageReceivedCallback =
    WebKit2WebExtension.UserMessage.UserMessage
    -- ^ /@message@/: the t'GI.WebKit2WebExtension.Objects.UserMessage.UserMessage' received
    -> IO Bool
    -- ^ __Returns:__ 'P.True' if the message was handled, or 'P.False' otherwise.

-- | A convenience synonym for @`Nothing` :: `Maybe` `WebPageUserMessageReceivedCallback`@.
noWebPageUserMessageReceivedCallback :: Maybe WebPageUserMessageReceivedCallback
noWebPageUserMessageReceivedCallback :: Maybe WebPageUserMessageReceivedCallback
noWebPageUserMessageReceivedCallback = Maybe WebPageUserMessageReceivedCallback
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_WebPageUserMessageReceived :: MonadIO m => WebPageUserMessageReceivedCallback -> m (GClosure C_WebPageUserMessageReceivedCallback)
genClosure_WebPageUserMessageReceived :: forall (m :: * -> *).
MonadIO m =>
WebPageUserMessageReceivedCallback
-> m (GClosure C_WebPageUserMessageReceivedCallback)
genClosure_WebPageUserMessageReceived WebPageUserMessageReceivedCallback
cb = IO (GClosure C_WebPageUserMessageReceivedCallback)
-> m (GClosure C_WebPageUserMessageReceivedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_WebPageUserMessageReceivedCallback)
 -> m (GClosure C_WebPageUserMessageReceivedCallback))
-> IO (GClosure C_WebPageUserMessageReceivedCallback)
-> m (GClosure C_WebPageUserMessageReceivedCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_WebPageUserMessageReceivedCallback
cb' = WebPageUserMessageReceivedCallback
-> C_WebPageUserMessageReceivedCallback
wrap_WebPageUserMessageReceivedCallback WebPageUserMessageReceivedCallback
cb
    C_WebPageUserMessageReceivedCallback
-> IO (FunPtr C_WebPageUserMessageReceivedCallback)
mk_WebPageUserMessageReceivedCallback C_WebPageUserMessageReceivedCallback
cb' IO (FunPtr C_WebPageUserMessageReceivedCallback)
-> (FunPtr C_WebPageUserMessageReceivedCallback
    -> IO (GClosure C_WebPageUserMessageReceivedCallback))
-> IO (GClosure C_WebPageUserMessageReceivedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_WebPageUserMessageReceivedCallback
-> IO (GClosure C_WebPageUserMessageReceivedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `WebPageUserMessageReceivedCallback` into a `C_WebPageUserMessageReceivedCallback`.
wrap_WebPageUserMessageReceivedCallback ::
    WebPageUserMessageReceivedCallback ->
    C_WebPageUserMessageReceivedCallback
wrap_WebPageUserMessageReceivedCallback :: WebPageUserMessageReceivedCallback
-> C_WebPageUserMessageReceivedCallback
wrap_WebPageUserMessageReceivedCallback WebPageUserMessageReceivedCallback
_cb Ptr ()
_ Ptr UserMessage
message Ptr ()
_ = do
    UserMessage
message' <- ((ManagedPtr UserMessage -> UserMessage)
-> Ptr UserMessage -> IO UserMessage
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr UserMessage -> UserMessage
WebKit2WebExtension.UserMessage.UserMessage) Ptr UserMessage
message
    Bool
result <- WebPageUserMessageReceivedCallback
_cb  UserMessage
message'
    let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
result
    CInt -> IO CInt
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'


-- | Connect a signal handler for the [userMessageReceived](#signal:userMessageReceived) 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' webPage #userMessageReceived callback
-- @
-- 
-- 
onWebPageUserMessageReceived :: (IsWebPage a, MonadIO m) => a -> WebPageUserMessageReceivedCallback -> m SignalHandlerId
onWebPageUserMessageReceived :: forall a (m :: * -> *).
(IsWebPage a, MonadIO m) =>
a -> WebPageUserMessageReceivedCallback -> m SignalHandlerId
onWebPageUserMessageReceived a
obj WebPageUserMessageReceivedCallback
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_WebPageUserMessageReceivedCallback
cb' = WebPageUserMessageReceivedCallback
-> C_WebPageUserMessageReceivedCallback
wrap_WebPageUserMessageReceivedCallback WebPageUserMessageReceivedCallback
cb
    FunPtr C_WebPageUserMessageReceivedCallback
cb'' <- C_WebPageUserMessageReceivedCallback
-> IO (FunPtr C_WebPageUserMessageReceivedCallback)
mk_WebPageUserMessageReceivedCallback C_WebPageUserMessageReceivedCallback
cb'
    a
-> Text
-> FunPtr C_WebPageUserMessageReceivedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"user-message-received" FunPtr C_WebPageUserMessageReceivedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [userMessageReceived](#signal:userMessageReceived) 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' webPage #userMessageReceived callback
-- @
-- 
-- 
afterWebPageUserMessageReceived :: (IsWebPage a, MonadIO m) => a -> WebPageUserMessageReceivedCallback -> m SignalHandlerId
afterWebPageUserMessageReceived :: forall a (m :: * -> *).
(IsWebPage a, MonadIO m) =>
a -> WebPageUserMessageReceivedCallback -> m SignalHandlerId
afterWebPageUserMessageReceived a
obj WebPageUserMessageReceivedCallback
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_WebPageUserMessageReceivedCallback
cb' = WebPageUserMessageReceivedCallback
-> C_WebPageUserMessageReceivedCallback
wrap_WebPageUserMessageReceivedCallback WebPageUserMessageReceivedCallback
cb
    FunPtr C_WebPageUserMessageReceivedCallback
cb'' <- C_WebPageUserMessageReceivedCallback
-> IO (FunPtr C_WebPageUserMessageReceivedCallback)
mk_WebPageUserMessageReceivedCallback C_WebPageUserMessageReceivedCallback
cb'
    a
-> Text
-> FunPtr C_WebPageUserMessageReceivedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"user-message-received" FunPtr C_WebPageUserMessageReceivedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data WebPageUserMessageReceivedSignalInfo
instance SignalInfo WebPageUserMessageReceivedSignalInfo where
    type HaskellCallbackType WebPageUserMessageReceivedSignalInfo = WebPageUserMessageReceivedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_WebPageUserMessageReceivedCallback cb
        cb'' <- mk_WebPageUserMessageReceivedCallback cb'
        connectSignalFunPtr obj "user-message-received" cb'' connectMode detail

#endif

-- signal WebPage::will-submit-form
-- | This signal is emitted to indicate various points during form
-- submission. /@step@/ indicates the current stage of form submission.
-- 
-- If this signal is emitted with 'GI.WebKit2WebExtension.Enums.FormSubmissionStepSendDomEvent',
-- then the DOM submit event is about to be emitted. JavaScript code
-- may rely on the submit event to detect that the user has clicked
-- on a submit button, and to possibly cancel the form submission
-- before 'GI.WebKit2WebExtension.Enums.FormSubmissionStepComplete'. However, beware
-- that, for historical reasons, the submit event is not emitted at
-- all if the form submission is triggered by JavaScript. For these
-- reasons, 'GI.WebKit2WebExtension.Enums.FormSubmissionStepSendDomEvent' may not
-- be used to reliably detect whether a form will be submitted.
-- Instead, use it to detect if a user has clicked on a form\'s
-- submit button even if JavaScript later cancels the form
-- submission, or to read the values of the form\'s fields even if
-- JavaScript later clears certain fields before submitting. This
-- may be needed, for example, to implement a robust browser
-- password manager, as some misguided websites may use such
-- techniques to attempt to thwart password managers.
-- 
-- If this signal is emitted with 'GI.WebKit2WebExtension.Enums.FormSubmissionStepComplete',
-- the form will imminently be submitted. It can no longer be
-- cancelled. This event always occurs immediately before a form is
-- submitted to its target, so use this event to reliably detect
-- when a form is submitted. This event occurs after
-- 'GI.WebKit2WebExtension.Enums.FormSubmissionStepSendDomEvent' if that event is
-- emitted.
-- 
-- /Since: 2.20/
type WebPageWillSubmitFormCallback =
    WebKit2WebExtension.DOMElement.DOMElement
    -- ^ /@form@/: the t'GI.WebKit2WebExtension.Objects.DOMElement.DOMElement' to be submitted, which will always correspond to an HTMLFormElement
    -> WebKit2WebExtension.Enums.FormSubmissionStep
    -- ^ /@step@/: a @/WebKitFormSubmissionEventType/@ indicating the current
    -- stage of form submission
    -> WebKit2WebExtension.Frame.Frame
    -- ^ /@sourceFrame@/: the t'GI.WebKit2WebExtension.Objects.Frame.Frame' containing the form to be
    -- submitted
    -> WebKit2WebExtension.Frame.Frame
    -- ^ /@targetFrame@/: the t'GI.WebKit2WebExtension.Objects.Frame.Frame' containing the form\'s target,
    -- which may be the same as /@sourceFrame@/ if no target was specified
    -> [T.Text]
    -- ^ /@textFieldNames@/: names of
    -- the form\'s text fields
    -> [T.Text]
    -- ^ /@textFieldValues@/: values
    -- of the form\'s text fields
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `WebPageWillSubmitFormCallback`@.
noWebPageWillSubmitFormCallback :: Maybe WebPageWillSubmitFormCallback
noWebPageWillSubmitFormCallback :: Maybe WebPageWillSubmitFormCallback
noWebPageWillSubmitFormCallback = Maybe WebPageWillSubmitFormCallback
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_WebPageWillSubmitFormCallback =
    Ptr () ->                               -- object
    Ptr WebKit2WebExtension.DOMElement.DOMElement ->
    CUInt ->
    Ptr WebKit2WebExtension.Frame.Frame ->
    Ptr WebKit2WebExtension.Frame.Frame ->
    Ptr (GPtrArray CString) ->
    Ptr (GPtrArray CString) ->
    Ptr () ->                               -- user_data
    IO ()

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

-- | Wrap the callback into a `GClosure`.
genClosure_WebPageWillSubmitForm :: MonadIO m => WebPageWillSubmitFormCallback -> m (GClosure C_WebPageWillSubmitFormCallback)
genClosure_WebPageWillSubmitForm :: forall (m :: * -> *).
MonadIO m =>
WebPageWillSubmitFormCallback
-> m (GClosure C_WebPageWillSubmitFormCallback)
genClosure_WebPageWillSubmitForm WebPageWillSubmitFormCallback
cb = IO (GClosure C_WebPageWillSubmitFormCallback)
-> m (GClosure C_WebPageWillSubmitFormCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_WebPageWillSubmitFormCallback)
 -> m (GClosure C_WebPageWillSubmitFormCallback))
-> IO (GClosure C_WebPageWillSubmitFormCallback)
-> m (GClosure C_WebPageWillSubmitFormCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_WebPageWillSubmitFormCallback
cb' = WebPageWillSubmitFormCallback -> C_WebPageWillSubmitFormCallback
wrap_WebPageWillSubmitFormCallback WebPageWillSubmitFormCallback
cb
    C_WebPageWillSubmitFormCallback
-> IO (FunPtr C_WebPageWillSubmitFormCallback)
mk_WebPageWillSubmitFormCallback C_WebPageWillSubmitFormCallback
cb' IO (FunPtr C_WebPageWillSubmitFormCallback)
-> (FunPtr C_WebPageWillSubmitFormCallback
    -> IO (GClosure C_WebPageWillSubmitFormCallback))
-> IO (GClosure C_WebPageWillSubmitFormCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_WebPageWillSubmitFormCallback
-> IO (GClosure C_WebPageWillSubmitFormCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `WebPageWillSubmitFormCallback` into a `C_WebPageWillSubmitFormCallback`.
wrap_WebPageWillSubmitFormCallback ::
    WebPageWillSubmitFormCallback ->
    C_WebPageWillSubmitFormCallback
wrap_WebPageWillSubmitFormCallback :: WebPageWillSubmitFormCallback -> C_WebPageWillSubmitFormCallback
wrap_WebPageWillSubmitFormCallback WebPageWillSubmitFormCallback
_cb Ptr ()
_ Ptr DOMElement
form CUInt
step Ptr Frame
sourceFrame Ptr Frame
targetFrame Ptr (GPtrArray CString)
textFieldNames Ptr (GPtrArray CString)
textFieldValues Ptr ()
_ = do
    DOMElement
form' <- ((ManagedPtr DOMElement -> DOMElement)
-> Ptr DOMElement -> IO DOMElement
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr DOMElement -> DOMElement
WebKit2WebExtension.DOMElement.DOMElement) Ptr DOMElement
form
    let step' :: FormSubmissionStep
step' = (Int -> FormSubmissionStep
forall a. Enum a => Int -> a
toEnum (Int -> FormSubmissionStep)
-> (CUInt -> Int) -> CUInt -> FormSubmissionStep
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
step
    Frame
sourceFrame' <- ((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
sourceFrame
    Frame
targetFrame' <- ((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
targetFrame
    [CString]
textFieldNames' <- Ptr (GPtrArray CString) -> IO [CString]
forall a. Ptr (GPtrArray (Ptr a)) -> IO [Ptr a]
unpackGPtrArray Ptr (GPtrArray CString)
textFieldNames
    [Text]
textFieldNames'' <- (CString -> IO Text) -> [CString] -> IO [Text]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText [CString]
textFieldNames'
    [CString]
textFieldValues' <- Ptr (GPtrArray CString) -> IO [CString]
forall a. Ptr (GPtrArray (Ptr a)) -> IO [Ptr a]
unpackGPtrArray Ptr (GPtrArray CString)
textFieldValues
    [Text]
textFieldValues'' <- (CString -> IO Text) -> [CString] -> IO [Text]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText [CString]
textFieldValues'
    WebPageWillSubmitFormCallback
_cb  DOMElement
form' FormSubmissionStep
step' Frame
sourceFrame' Frame
targetFrame' [Text]
textFieldNames'' [Text]
textFieldValues''


-- | Connect a signal handler for the [willSubmitForm](#signal:willSubmitForm) 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' webPage #willSubmitForm callback
-- @
-- 
-- 
onWebPageWillSubmitForm :: (IsWebPage a, MonadIO m) => a -> WebPageWillSubmitFormCallback -> m SignalHandlerId
onWebPageWillSubmitForm :: forall a (m :: * -> *).
(IsWebPage a, MonadIO m) =>
a -> WebPageWillSubmitFormCallback -> m SignalHandlerId
onWebPageWillSubmitForm a
obj WebPageWillSubmitFormCallback
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_WebPageWillSubmitFormCallback
cb' = WebPageWillSubmitFormCallback -> C_WebPageWillSubmitFormCallback
wrap_WebPageWillSubmitFormCallback WebPageWillSubmitFormCallback
cb
    FunPtr C_WebPageWillSubmitFormCallback
cb'' <- C_WebPageWillSubmitFormCallback
-> IO (FunPtr C_WebPageWillSubmitFormCallback)
mk_WebPageWillSubmitFormCallback C_WebPageWillSubmitFormCallback
cb'
    a
-> Text
-> FunPtr C_WebPageWillSubmitFormCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"will-submit-form" FunPtr C_WebPageWillSubmitFormCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [willSubmitForm](#signal:willSubmitForm) 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' webPage #willSubmitForm callback
-- @
-- 
-- 
afterWebPageWillSubmitForm :: (IsWebPage a, MonadIO m) => a -> WebPageWillSubmitFormCallback -> m SignalHandlerId
afterWebPageWillSubmitForm :: forall a (m :: * -> *).
(IsWebPage a, MonadIO m) =>
a -> WebPageWillSubmitFormCallback -> m SignalHandlerId
afterWebPageWillSubmitForm a
obj WebPageWillSubmitFormCallback
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_WebPageWillSubmitFormCallback
cb' = WebPageWillSubmitFormCallback -> C_WebPageWillSubmitFormCallback
wrap_WebPageWillSubmitFormCallback WebPageWillSubmitFormCallback
cb
    FunPtr C_WebPageWillSubmitFormCallback
cb'' <- C_WebPageWillSubmitFormCallback
-> IO (FunPtr C_WebPageWillSubmitFormCallback)
mk_WebPageWillSubmitFormCallback C_WebPageWillSubmitFormCallback
cb'
    a
-> Text
-> FunPtr C_WebPageWillSubmitFormCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"will-submit-form" FunPtr C_WebPageWillSubmitFormCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data WebPageWillSubmitFormSignalInfo
instance SignalInfo WebPageWillSubmitFormSignalInfo where
    type HaskellCallbackType WebPageWillSubmitFormSignalInfo = WebPageWillSubmitFormCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_WebPageWillSubmitFormCallback cb
        cb'' <- mk_WebPageWillSubmitFormCallback cb'
        connectSignalFunPtr obj "will-submit-form" cb'' connectMode detail

#endif

-- VVV Prop "uri"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable]
   -- Nullable: (Just True,Nothing)

-- | Get the value of the “@uri@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' webPage #uri
-- @
getWebPageUri :: (MonadIO m, IsWebPage o) => o -> m (Maybe T.Text)
getWebPageUri :: forall (m :: * -> *) o.
(MonadIO m, IsWebPage o) =>
o -> m (Maybe Text)
getWebPageUri o
obj = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj String
"uri"

#if defined(ENABLE_OVERLOADING)
data WebPageUriPropertyInfo
instance AttrInfo WebPageUriPropertyInfo where
    type AttrAllowedOps WebPageUriPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint WebPageUriPropertyInfo = IsWebPage
    type AttrSetTypeConstraint WebPageUriPropertyInfo = (~) ()
    type AttrTransferTypeConstraint WebPageUriPropertyInfo = (~) ()
    type AttrTransferType WebPageUriPropertyInfo = ()
    type AttrGetType WebPageUriPropertyInfo = (Maybe T.Text)
    type AttrLabel WebPageUriPropertyInfo = "uri"
    type AttrOrigin WebPageUriPropertyInfo = WebPage
    attrGet = getWebPageUri
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList WebPage
type instance O.AttributeList WebPage = WebPageAttributeList
type WebPageAttributeList = ('[ '("uri", WebPageUriPropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
webPageUri :: AttrLabelProxy "uri"
webPageUri = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList WebPage = WebPageSignalList
type WebPageSignalList = ('[ '("consoleMessageSent", WebPageConsoleMessageSentSignalInfo), '("contextMenu", WebPageContextMenuSignalInfo), '("documentLoaded", WebPageDocumentLoadedSignalInfo), '("formControlsAssociated", WebPageFormControlsAssociatedSignalInfo), '("formControlsAssociatedForFrame", WebPageFormControlsAssociatedForFrameSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("sendRequest", WebPageSendRequestSignalInfo), '("userMessageReceived", WebPageUserMessageReceivedSignalInfo), '("willSubmitForm", WebPageWillSubmitFormSignalInfo)] :: [(Symbol, *)])

#endif

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

foreign import ccall "webkit_web_page_get_dom_document" webkit_web_page_get_dom_document :: 
    Ptr WebPage ->                          -- web_page : TInterface (Name {namespace = "WebKit2WebExtension", name = "WebPage"})
    IO (Ptr WebKit2WebExtension.DOMDocument.DOMDocument)

-- | Get the t'GI.WebKit2WebExtension.Objects.DOMDocument.DOMDocument' currently loaded in /@webPage@/
webPageGetDomDocument ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebPage a) =>
    a
    -- ^ /@webPage@/: a t'GI.WebKit2WebExtension.Objects.WebPage.WebPage'
    -> m (Maybe WebKit2WebExtension.DOMDocument.DOMDocument)
    -- ^ __Returns:__ the t'GI.WebKit2WebExtension.Objects.DOMDocument.DOMDocument' currently loaded, or 'P.Nothing'
    --    if no document is currently loaded.
webPageGetDomDocument :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWebPage a) =>
a -> m (Maybe DOMDocument)
webPageGetDomDocument a
webPage = IO (Maybe DOMDocument) -> m (Maybe DOMDocument)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe DOMDocument) -> m (Maybe DOMDocument))
-> IO (Maybe DOMDocument) -> m (Maybe DOMDocument)
forall a b. (a -> b) -> a -> b
$ do
    Ptr WebPage
webPage' <- a -> IO (Ptr WebPage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
webPage
    Ptr DOMDocument
result <- Ptr WebPage -> IO (Ptr DOMDocument)
webkit_web_page_get_dom_document Ptr WebPage
webPage'
    Maybe DOMDocument
maybeResult <- Ptr DOMDocument
-> (Ptr DOMDocument -> IO DOMDocument) -> IO (Maybe DOMDocument)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr DOMDocument
result ((Ptr DOMDocument -> IO DOMDocument) -> IO (Maybe DOMDocument))
-> (Ptr DOMDocument -> IO DOMDocument) -> IO (Maybe DOMDocument)
forall a b. (a -> b) -> a -> b
$ \Ptr DOMDocument
result' -> do
        DOMDocument
result'' <- ((ManagedPtr DOMDocument -> DOMDocument)
-> Ptr DOMDocument -> IO DOMDocument
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr DOMDocument -> DOMDocument
WebKit2WebExtension.DOMDocument.DOMDocument) Ptr DOMDocument
result'
        DOMDocument -> IO DOMDocument
forall (m :: * -> *) a. Monad m => a -> m a
return DOMDocument
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
webPage
    Maybe DOMDocument -> IO (Maybe DOMDocument)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe DOMDocument
maybeResult

#if defined(ENABLE_OVERLOADING)
data WebPageGetDomDocumentMethodInfo
instance (signature ~ (m (Maybe WebKit2WebExtension.DOMDocument.DOMDocument)), MonadIO m, IsWebPage a) => O.OverloadedMethod WebPageGetDomDocumentMethodInfo a signature where
    overloadedMethod = webPageGetDomDocument

instance O.OverloadedMethodInfo WebPageGetDomDocumentMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.WebKit2WebExtension.Objects.WebPage.webPageGetDomDocument",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-webkit2webextension-4.0.26/docs/GI-WebKit2WebExtension-Objects-WebPage.html#v:webPageGetDomDocument"
        }


#endif

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

foreign import ccall "webkit_web_page_get_editor" webkit_web_page_get_editor :: 
    Ptr WebPage ->                          -- web_page : TInterface (Name {namespace = "WebKit2WebExtension", name = "WebPage"})
    IO (Ptr WebKit2WebExtension.WebEditor.WebEditor)

-- | Gets the t'GI.WebKit2WebExtension.Objects.WebEditor.WebEditor' of a t'GI.WebKit2WebExtension.Objects.WebPage.WebPage'.
-- 
-- /Since: 2.10/
webPageGetEditor ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebPage a) =>
    a
    -- ^ /@webPage@/: a t'GI.WebKit2WebExtension.Objects.WebPage.WebPage'
    -> m WebKit2WebExtension.WebEditor.WebEditor
    -- ^ __Returns:__ the t'GI.WebKit2WebExtension.Objects.WebEditor.WebEditor'
webPageGetEditor :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWebPage a) =>
a -> m WebEditor
webPageGetEditor a
webPage = IO WebEditor -> m WebEditor
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO WebEditor -> m WebEditor) -> IO WebEditor -> m WebEditor
forall a b. (a -> b) -> a -> b
$ do
    Ptr WebPage
webPage' <- a -> IO (Ptr WebPage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
webPage
    Ptr WebEditor
result <- Ptr WebPage -> IO (Ptr WebEditor)
webkit_web_page_get_editor Ptr WebPage
webPage'
    Text -> Ptr WebEditor -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"webPageGetEditor" Ptr WebEditor
result
    WebEditor
result' <- ((ManagedPtr WebEditor -> WebEditor)
-> Ptr WebEditor -> IO WebEditor
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr WebEditor -> WebEditor
WebKit2WebExtension.WebEditor.WebEditor) Ptr WebEditor
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
webPage
    WebEditor -> IO WebEditor
forall (m :: * -> *) a. Monad m => a -> m a
return WebEditor
result'

#if defined(ENABLE_OVERLOADING)
data WebPageGetEditorMethodInfo
instance (signature ~ (m WebKit2WebExtension.WebEditor.WebEditor), MonadIO m, IsWebPage a) => O.OverloadedMethod WebPageGetEditorMethodInfo a signature where
    overloadedMethod = webPageGetEditor

instance O.OverloadedMethodInfo WebPageGetEditorMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.WebKit2WebExtension.Objects.WebPage.webPageGetEditor",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-webkit2webextension-4.0.26/docs/GI-WebKit2WebExtension-Objects-WebPage.html#v:webPageGetEditor"
        }


#endif

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

foreign import ccall "webkit_web_page_get_id" webkit_web_page_get_id :: 
    Ptr WebPage ->                          -- web_page : TInterface (Name {namespace = "WebKit2WebExtension", name = "WebPage"})
    IO Word64

-- | Get the identifier of the t'GI.WebKit2WebExtension.Objects.WebPage.WebPage'
webPageGetId ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebPage a) =>
    a
    -- ^ /@webPage@/: a t'GI.WebKit2WebExtension.Objects.WebPage.WebPage'
    -> m Word64
    -- ^ __Returns:__ the identifier of /@webPage@/
webPageGetId :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWebPage a) =>
a -> m Word64
webPageGetId a
webPage = IO Word64 -> m Word64
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word64 -> m Word64) -> IO Word64 -> m Word64
forall a b. (a -> b) -> a -> b
$ do
    Ptr WebPage
webPage' <- a -> IO (Ptr WebPage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
webPage
    Word64
result <- Ptr WebPage -> IO Word64
webkit_web_page_get_id Ptr WebPage
webPage'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
webPage
    Word64 -> IO Word64
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
result

#if defined(ENABLE_OVERLOADING)
data WebPageGetIdMethodInfo
instance (signature ~ (m Word64), MonadIO m, IsWebPage a) => O.OverloadedMethod WebPageGetIdMethodInfo a signature where
    overloadedMethod = webPageGetId

instance O.OverloadedMethodInfo WebPageGetIdMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.WebKit2WebExtension.Objects.WebPage.webPageGetId",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-webkit2webextension-4.0.26/docs/GI-WebKit2WebExtension-Objects-WebPage.html#v:webPageGetId"
        }


#endif

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

foreign import ccall "webkit_web_page_get_main_frame" webkit_web_page_get_main_frame :: 
    Ptr WebPage ->                          -- web_page : TInterface (Name {namespace = "WebKit2WebExtension", name = "WebPage"})
    IO (Ptr WebKit2WebExtension.Frame.Frame)

-- | Returns the main frame of a t'GI.WebKit2WebExtension.Objects.WebPage.WebPage'.
-- 
-- /Since: 2.2/
webPageGetMainFrame ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebPage a) =>
    a
    -- ^ /@webPage@/: a t'GI.WebKit2WebExtension.Objects.WebPage.WebPage'
    -> m WebKit2WebExtension.Frame.Frame
    -- ^ __Returns:__ the t'GI.WebKit2WebExtension.Objects.Frame.Frame' that is the main frame of /@webPage@/
webPageGetMainFrame :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWebPage a) =>
a -> m Frame
webPageGetMainFrame a
webPage = IO Frame -> m Frame
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Frame -> m Frame) -> IO Frame -> m Frame
forall a b. (a -> b) -> a -> b
$ do
    Ptr WebPage
webPage' <- a -> IO (Ptr WebPage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
webPage
    Ptr Frame
result <- Ptr WebPage -> IO (Ptr Frame)
webkit_web_page_get_main_frame Ptr WebPage
webPage'
    Text -> Ptr Frame -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"webPageGetMainFrame" Ptr Frame
result
    Frame
result' <- ((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
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
webPage
    Frame -> IO Frame
forall (m :: * -> *) a. Monad m => a -> m a
return Frame
result'

#if defined(ENABLE_OVERLOADING)
data WebPageGetMainFrameMethodInfo
instance (signature ~ (m WebKit2WebExtension.Frame.Frame), MonadIO m, IsWebPage a) => O.OverloadedMethod WebPageGetMainFrameMethodInfo a signature where
    overloadedMethod = webPageGetMainFrame

instance O.OverloadedMethodInfo WebPageGetMainFrameMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.WebKit2WebExtension.Objects.WebPage.webPageGetMainFrame",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-webkit2webextension-4.0.26/docs/GI-WebKit2WebExtension-Objects-WebPage.html#v:webPageGetMainFrame"
        }


#endif

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

foreign import ccall "webkit_web_page_get_uri" webkit_web_page_get_uri :: 
    Ptr WebPage ->                          -- web_page : TInterface (Name {namespace = "WebKit2WebExtension", name = "WebPage"})
    IO CString

-- | Returns the current active URI of /@webPage@/.
-- 
-- You can monitor the active URI by connecting to the notify[uri](#g:signal:uri)
-- signal of /@webPage@/.
webPageGetUri ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebPage a) =>
    a
    -- ^ /@webPage@/: a t'GI.WebKit2WebExtension.Objects.WebPage.WebPage'
    -> m (Maybe T.Text)
    -- ^ __Returns:__ the current active URI of /@webView@/ or 'P.Nothing' if nothing has been
    --    loaded yet.
webPageGetUri :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWebPage a) =>
a -> m (Maybe Text)
webPageGetUri a
webPage = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    Ptr WebPage
webPage' <- a -> IO (Ptr WebPage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
webPage
    CString
result <- Ptr WebPage -> IO CString
webkit_web_page_get_uri Ptr WebPage
webPage'
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
webPage
    Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

#if defined(ENABLE_OVERLOADING)
data WebPageGetUriMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsWebPage a) => O.OverloadedMethod WebPageGetUriMethodInfo a signature where
    overloadedMethod = webPageGetUri

instance O.OverloadedMethodInfo WebPageGetUriMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.WebKit2WebExtension.Objects.WebPage.webPageGetUri",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-webkit2webextension-4.0.26/docs/GI-WebKit2WebExtension-Objects-WebPage.html#v:webPageGetUri"
        }


#endif

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

foreign import ccall "webkit_web_page_send_message_to_view" webkit_web_page_send_message_to_view :: 
    Ptr WebPage ->                          -- web_page : TInterface (Name {namespace = "WebKit2WebExtension", name = "WebPage"})
    Ptr WebKit2WebExtension.UserMessage.UserMessage -> -- message : TInterface (Name {namespace = "WebKit2WebExtension", name = "UserMessage"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO ()

-- | Send /@message@/ to the @/WebKitWebView/@ corresponding to /@webPage@/. If /@message@/ is floating, it\'s consumed.
-- 
-- If you don\'t expect any reply, or you simply want to ignore it, you can pass 'P.Nothing' as /@callback@/.
-- When the operation is finished, /@callback@/ will be called. You can then call
-- 'GI.WebKit2WebExtension.Objects.WebPage.webPageSendMessageToViewFinish' to get the message reply.
-- 
-- /Since: 2.28/
webPageSendMessageToView ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebPage a, WebKit2WebExtension.UserMessage.IsUserMessage b, Gio.Cancellable.IsCancellable c) =>
    a
    -- ^ /@webPage@/: a t'GI.WebKit2WebExtension.Objects.WebPage.WebPage'
    -> b
    -- ^ /@message@/: a t'GI.WebKit2WebExtension.Objects.UserMessage.UserMessage'
    -> Maybe (c)
    -- ^ /@cancellable@/: a t'GI.Gio.Objects.Cancellable.Cancellable' or 'P.Nothing' to ignore
    -> Maybe (Gio.Callbacks.AsyncReadyCallback)
    -- ^ /@callback@/: (nullable): A t'GI.Gio.Callbacks.AsyncReadyCallback' to call when the request is satisfied or 'P.Nothing'
    -> m ()
webPageSendMessageToView :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsWebPage a, IsUserMessage b,
 IsCancellable c) =>
a -> b -> Maybe c -> Maybe AsyncReadyCallback -> m ()
webPageSendMessageToView a
webPage b
message Maybe c
cancellable Maybe AsyncReadyCallback
callback = 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 WebPage
webPage' <- a -> IO (Ptr WebPage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
webPage
    Ptr UserMessage
message' <- b -> IO (Ptr UserMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
message
    Ptr Cancellable
maybeCancellable <- case Maybe c
cancellable of
        Maybe c
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
nullPtr
        Just c
jCancellable -> do
            Ptr Cancellable
jCancellable' <- c -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jCancellable
            Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    FunPtr C_AsyncReadyCallback
maybeCallback <- case Maybe AsyncReadyCallback
callback of
        Maybe AsyncReadyCallback
Nothing -> FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return (Ptr Any -> FunPtr C_AsyncReadyCallback
forall a b. Ptr a -> FunPtr b
castPtrToFunPtr Ptr Any
forall a. Ptr a
nullPtr)
        Just AsyncReadyCallback
jCallback -> do
            Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback <- IO (Ptr (FunPtr C_AsyncReadyCallback))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
            FunPtr C_AsyncReadyCallback
jCallback' <- C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
Gio.Callbacks.mk_AsyncReadyCallback (Maybe (Ptr (FunPtr C_AsyncReadyCallback))
-> AsyncReadyCallback_WithClosures -> C_AsyncReadyCallback
Gio.Callbacks.wrap_AsyncReadyCallback (Ptr (FunPtr C_AsyncReadyCallback)
-> Maybe (Ptr (FunPtr C_AsyncReadyCallback))
forall a. a -> Maybe a
Just Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback) (AsyncReadyCallback -> AsyncReadyCallback_WithClosures
Gio.Callbacks.drop_closures_AsyncReadyCallback AsyncReadyCallback
jCallback))
            Ptr (FunPtr C_AsyncReadyCallback)
-> FunPtr C_AsyncReadyCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback FunPtr C_AsyncReadyCallback
jCallback'
            FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_AsyncReadyCallback
jCallback'
    let userData :: Ptr a
userData = Ptr a
forall a. Ptr a
nullPtr
    Ptr WebPage
-> Ptr UserMessage
-> Ptr Cancellable
-> FunPtr C_AsyncReadyCallback
-> Ptr ()
-> IO ()
webkit_web_page_send_message_to_view Ptr WebPage
webPage' Ptr UserMessage
message' Ptr Cancellable
maybeCancellable FunPtr C_AsyncReadyCallback
maybeCallback Ptr ()
forall a. Ptr a
userData
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
webPage
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
message
    Maybe c -> (c -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe c
cancellable c -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data WebPageSendMessageToViewMethodInfo
instance (signature ~ (b -> Maybe (c) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsWebPage a, WebKit2WebExtension.UserMessage.IsUserMessage b, Gio.Cancellable.IsCancellable c) => O.OverloadedMethod WebPageSendMessageToViewMethodInfo a signature where
    overloadedMethod = webPageSendMessageToView

instance O.OverloadedMethodInfo WebPageSendMessageToViewMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.WebKit2WebExtension.Objects.WebPage.webPageSendMessageToView",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-webkit2webextension-4.0.26/docs/GI-WebKit2WebExtension-Objects-WebPage.html#v:webPageSendMessageToView"
        }


#endif

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

foreign import ccall "webkit_web_page_send_message_to_view_finish" webkit_web_page_send_message_to_view_finish :: 
    Ptr WebPage ->                          -- web_page : TInterface (Name {namespace = "WebKit2WebExtension", name = "WebPage"})
    Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr WebKit2WebExtension.UserMessage.UserMessage)

-- | Finish an asynchronous operation started with 'GI.WebKit2WebExtension.Objects.WebPage.webPageSendMessageToView'.
-- 
-- /Since: 2.28/
webPageSendMessageToViewFinish ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebPage a, Gio.AsyncResult.IsAsyncResult b) =>
    a
    -- ^ /@webPage@/: a t'GI.WebKit2WebExtension.Objects.WebPage.WebPage'
    -> b
    -- ^ /@result@/: a t'GI.Gio.Interfaces.AsyncResult.AsyncResult'
    -> m WebKit2WebExtension.UserMessage.UserMessage
    -- ^ __Returns:__ a t'GI.WebKit2WebExtension.Objects.UserMessage.UserMessage' with the reply or 'P.Nothing' in case of error. /(Can throw 'Data.GI.Base.GError.GError')/
webPageSendMessageToViewFinish :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsWebPage a, IsAsyncResult b) =>
a -> b -> m UserMessage
webPageSendMessageToViewFinish a
webPage b
result_ = IO UserMessage -> m UserMessage
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO UserMessage -> m UserMessage)
-> IO UserMessage -> m UserMessage
forall a b. (a -> b) -> a -> b
$ do
    Ptr WebPage
webPage' <- a -> IO (Ptr WebPage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
webPage
    Ptr AsyncResult
result_' <- b -> IO (Ptr AsyncResult)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
result_
    IO UserMessage -> IO () -> IO UserMessage
forall a b. IO a -> IO b -> IO a
onException (do
        Ptr UserMessage
result <- (Ptr (Ptr GError) -> IO (Ptr UserMessage)) -> IO (Ptr UserMessage)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr UserMessage))
 -> IO (Ptr UserMessage))
-> (Ptr (Ptr GError) -> IO (Ptr UserMessage))
-> IO (Ptr UserMessage)
forall a b. (a -> b) -> a -> b
$ Ptr WebPage
-> Ptr AsyncResult -> Ptr (Ptr GError) -> IO (Ptr UserMessage)
webkit_web_page_send_message_to_view_finish Ptr WebPage
webPage' Ptr AsyncResult
result_'
        Text -> Ptr UserMessage -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"webPageSendMessageToViewFinish" Ptr UserMessage
result
        UserMessage
result' <- ((ManagedPtr UserMessage -> UserMessage)
-> Ptr UserMessage -> IO UserMessage
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr UserMessage -> UserMessage
WebKit2WebExtension.UserMessage.UserMessage) Ptr UserMessage
result
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
webPage
        b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
result_
        UserMessage -> IO UserMessage
forall (m :: * -> *) a. Monad m => a -> m a
return UserMessage
result'
     ) (do
        () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data WebPageSendMessageToViewFinishMethodInfo
instance (signature ~ (b -> m WebKit2WebExtension.UserMessage.UserMessage), MonadIO m, IsWebPage a, Gio.AsyncResult.IsAsyncResult b) => O.OverloadedMethod WebPageSendMessageToViewFinishMethodInfo a signature where
    overloadedMethod = webPageSendMessageToViewFinish

instance O.OverloadedMethodInfo WebPageSendMessageToViewFinishMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.WebKit2WebExtension.Objects.WebPage.webPageSendMessageToViewFinish",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-webkit2webextension-4.0.26/docs/GI-WebKit2WebExtension-Objects-WebPage.html#v:webPageSendMessageToViewFinish"
        }


#endif