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


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- A loaded web page.

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

module GI.WebKitWebProcessExtension.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.WebKitWebProcessExtension.Objects.WebPage#g:method:sendMessageToView"), [sendMessageToViewFinish]("GI.WebKitWebProcessExtension.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"), [getEditor]("GI.WebKitWebProcessExtension.Objects.WebPage#g:method:getEditor"), [getFormManager]("GI.WebKitWebProcessExtension.Objects.WebPage#g:method:getFormManager"), [getId]("GI.WebKitWebProcessExtension.Objects.WebPage#g:method:getId"), [getMainFrame]("GI.WebKitWebProcessExtension.Objects.WebPage#g:method:getMainFrame"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getUri]("GI.WebKitWebProcessExtension.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

-- ** getEditor #method:getEditor#

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


-- ** getFormManager #method:getFormManager#

#if defined(ENABLE_OVERLOADING)
    WebPageGetFormManagerMethodInfo         ,
#endif
    webPageGetFormManager                   ,


-- ** 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.WebKitWebProcessExtension.Objects.WebPage.WebPage'.

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




 -- * Signals


-- ** contextMenu #signal:contextMenu#

    WebPageContextMenuCallback              ,
#if defined(ENABLE_OVERLOADING)
    WebPageContextMenuSignalInfo            ,
#endif
    afterWebPageContextMenu                 ,
    onWebPageContextMenu                    ,


-- ** documentLoaded #signal:documentLoaded#

    WebPageDocumentLoadedCallback           ,
#if defined(ENABLE_OVERLOADING)
    WebPageDocumentLoadedSignalInfo         ,
#endif
    afterWebPageDocumentLoaded              ,
    onWebPageDocumentLoaded                 ,


-- ** sendRequest #signal:sendRequest#

    WebPageSendRequestCallback              ,
#if defined(ENABLE_OVERLOADING)
    WebPageSendRequestSignalInfo            ,
#endif
    afterWebPageSendRequest                 ,
    onWebPageSendRequest                    ,


-- ** userMessageReceived #signal:userMessageReceived#

    WebPageUserMessageReceivedCallback      ,
#if defined(ENABLE_OVERLOADING)
    WebPageUserMessageReceivedSignalInfo    ,
#endif
    afterWebPageUserMessageReceived         ,
    onWebPageUserMessageReceived            ,




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R

import qualified GI.GObject.Objects.Object as GObject.Object
import 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.WebKitWebProcessExtension.Objects.ContextMenu as WebKitWebProcessExtension.ContextMenu
import {-# SOURCE #-} qualified GI.WebKitWebProcessExtension.Objects.Frame as WebKitWebProcessExtension.Frame
import {-# SOURCE #-} qualified GI.WebKitWebProcessExtension.Objects.ScriptWorld as WebKitWebProcessExtension.ScriptWorld
import {-# SOURCE #-} qualified GI.WebKitWebProcessExtension.Objects.URIRequest as WebKitWebProcessExtension.URIRequest
import {-# SOURCE #-} qualified GI.WebKitWebProcessExtension.Objects.URIResponse as WebKitWebProcessExtension.URIResponse
import {-# SOURCE #-} qualified GI.WebKitWebProcessExtension.Objects.UserMessage as WebKitWebProcessExtension.UserMessage
import {-# SOURCE #-} qualified GI.WebKitWebProcessExtension.Objects.WebEditor as WebKitWebProcessExtension.WebEditor
import {-# SOURCE #-} qualified GI.WebKitWebProcessExtension.Objects.WebFormManager as WebKitWebProcessExtension.WebFormManager
import {-# SOURCE #-} qualified GI.WebKitWebProcessExtension.Objects.WebHitTestResult as WebKitWebProcessExtension.WebHitTestResult

-- | 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
$c== :: WebPage -> WebPage -> Bool
== :: WebPage -> WebPage -> Bool
$c/= :: WebPage -> WebPage -> Bool
/= :: 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 a. IO a -> m a
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 a. a -> IO a
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 :: DK.Type) :: DK.Type 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 "getEditor" o = WebPageGetEditorMethodInfo
    ResolveWebPageMethod "getFormManager" o = WebPageGetFormManagerMethodInfo
    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::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 node at the coordinates of the
-- /@hitTestResult@/. Otherwise, it\'s recommended to use @/WebKitWebView::context-menu/@
-- signal instead.
-- 
-- /Since: 2.8/
type WebPageContextMenuCallback =
    WebKitWebProcessExtension.ContextMenu.ContextMenu
    -- ^ /@contextMenu@/: the proposed t'GI.WebKitWebProcessExtension.Objects.ContextMenu.ContextMenu'
    -> WebKitWebProcessExtension.WebHitTestResult.WebHitTestResult
    -- ^ /@hitTestResult@/: a t'GI.WebKitWebProcessExtension.Objects.WebHitTestResult.WebHitTestResult'
    -> IO Bool
    -- ^ __Returns:__ 'P.True' if the proposed /@contextMenu@/ has been modified, or 'P.False' otherwise.

type C_WebPageContextMenuCallback =
    Ptr WebPage ->                          -- object
    Ptr WebKitWebProcessExtension.ContextMenu.ContextMenu ->
    Ptr WebKitWebProcessExtension.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_WebPageContextMenuCallback :: 
    GObject a => (a -> WebPageContextMenuCallback) ->
    C_WebPageContextMenuCallback
wrap_WebPageContextMenuCallback :: forall a.
GObject a =>
(a -> WebPageContextMenuCallback) -> C_WebPageContextMenuCallback
wrap_WebPageContextMenuCallback a -> WebPageContextMenuCallback
gi'cb Ptr WebPage
gi'selfPtr 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
WebKitWebProcessExtension.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
WebKitWebProcessExtension.WebHitTestResult.WebHitTestResult) Ptr WebHitTestResult
hitTestResult
    Bool
result <- Ptr WebPage -> (WebPage -> IO Bool) -> IO Bool
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr WebPage
gi'selfPtr ((WebPage -> IO Bool) -> IO Bool)
-> (WebPage -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \WebPage
gi'self -> a -> WebPageContextMenuCallback
gi'cb (WebPage -> a
forall a b. Coercible a b => a -> b
Coerce.coerce WebPage
gi'self)  ContextMenu
contextMenu' WebHitTestResult
hitTestResult'
    let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.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
P.fromEnum) Bool
result
    CInt -> IO CInt
forall a. a -> IO a
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 -> ((?self :: a) => WebPageContextMenuCallback) -> m SignalHandlerId
onWebPageContextMenu :: forall a (m :: * -> *).
(IsWebPage a, MonadIO m) =>
a
-> ((?self::a) => WebPageContextMenuCallback) -> m SignalHandlerId
onWebPageContextMenu a
obj (?self::a) => WebPageContextMenuCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> WebPageContextMenuCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => WebPageContextMenuCallback
WebPageContextMenuCallback
cb
    let wrapped' :: C_WebPageContextMenuCallback
wrapped' = (a -> WebPageContextMenuCallback) -> C_WebPageContextMenuCallback
forall a.
GObject a =>
(a -> WebPageContextMenuCallback) -> C_WebPageContextMenuCallback
wrap_WebPageContextMenuCallback a -> WebPageContextMenuCallback
wrapped
    FunPtr C_WebPageContextMenuCallback
wrapped'' <- C_WebPageContextMenuCallback
-> IO (FunPtr C_WebPageContextMenuCallback)
mk_WebPageContextMenuCallback C_WebPageContextMenuCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterWebPageContextMenu :: (IsWebPage a, MonadIO m) => a -> ((?self :: a) => WebPageContextMenuCallback) -> m SignalHandlerId
afterWebPageContextMenu :: forall a (m :: * -> *).
(IsWebPage a, MonadIO m) =>
a
-> ((?self::a) => WebPageContextMenuCallback) -> m SignalHandlerId
afterWebPageContextMenu a
obj (?self::a) => WebPageContextMenuCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> WebPageContextMenuCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => WebPageContextMenuCallback
WebPageContextMenuCallback
cb
    let wrapped' :: C_WebPageContextMenuCallback
wrapped' = (a -> WebPageContextMenuCallback) -> C_WebPageContextMenuCallback
forall a.
GObject a =>
(a -> WebPageContextMenuCallback) -> C_WebPageContextMenuCallback
wrap_WebPageContextMenuCallback a -> WebPageContextMenuCallback
wrapped
    FunPtr C_WebPageContextMenuCallback
wrapped'' <- C_WebPageContextMenuCallback
-> IO (FunPtr C_WebPageContextMenuCallback)
mk_WebPageContextMenuCallback C_WebPageContextMenuCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.WebKitWebProcessExtension.Objects.WebPage::context-menu"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-webkitwebprocessextension-6.0.2/docs/GI-WebKitWebProcessExtension-Objects-WebPage.html#g:signal:contextMenu"})

#endif

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

type C_WebPageDocumentLoadedCallback =
    Ptr WebPage ->                          -- 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_WebPageDocumentLoadedCallback :: 
    GObject a => (a -> WebPageDocumentLoadedCallback) ->
    C_WebPageDocumentLoadedCallback
wrap_WebPageDocumentLoadedCallback :: forall a.
GObject a =>
(a -> IO ()) -> C_WebPageDocumentLoadedCallback
wrap_WebPageDocumentLoadedCallback a -> IO ()
gi'cb Ptr WebPage
gi'selfPtr Ptr ()
_ = do
    Ptr WebPage -> (WebPage -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr WebPage
gi'selfPtr ((WebPage -> IO ()) -> IO ()) -> (WebPage -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \WebPage
gi'self -> a -> IO ()
gi'cb (WebPage -> a
forall a b. Coercible a b => a -> b
Coerce.coerce WebPage
gi'self) 


-- | 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 -> ((?self :: a) => WebPageDocumentLoadedCallback) -> m SignalHandlerId
onWebPageDocumentLoaded :: forall a (m :: * -> *).
(IsWebPage a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onWebPageDocumentLoaded a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_WebPageDocumentLoadedCallback
wrapped' = (a -> IO ()) -> C_WebPageDocumentLoadedCallback
forall a.
GObject a =>
(a -> IO ()) -> C_WebPageDocumentLoadedCallback
wrap_WebPageDocumentLoadedCallback a -> IO ()
wrapped
    FunPtr C_WebPageDocumentLoadedCallback
wrapped'' <- C_WebPageDocumentLoadedCallback
-> IO (FunPtr C_WebPageDocumentLoadedCallback)
mk_WebPageDocumentLoadedCallback C_WebPageDocumentLoadedCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterWebPageDocumentLoaded :: (IsWebPage a, MonadIO m) => a -> ((?self :: a) => WebPageDocumentLoadedCallback) -> m SignalHandlerId
afterWebPageDocumentLoaded :: forall a (m :: * -> *).
(IsWebPage a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterWebPageDocumentLoaded a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_WebPageDocumentLoadedCallback
wrapped' = (a -> IO ()) -> C_WebPageDocumentLoadedCallback
forall a.
GObject a =>
(a -> IO ()) -> C_WebPageDocumentLoadedCallback
wrap_WebPageDocumentLoadedCallback a -> IO ()
wrapped
    FunPtr C_WebPageDocumentLoadedCallback
wrapped'' <- C_WebPageDocumentLoadedCallback
-> IO (FunPtr C_WebPageDocumentLoadedCallback)
mk_WebPageDocumentLoadedCallback C_WebPageDocumentLoadedCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.WebKitWebProcessExtension.Objects.WebPage::document-loaded"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-webkitwebprocessextension-6.0.2/docs/GI-WebKitWebProcessExtension-Objects-WebPage.html#g:signal:documentLoaded"})

#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.WebKitWebProcessExtension.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.WebKitWebProcessExtension.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 =
    WebKitWebProcessExtension.URIRequest.URIRequest
    -- ^ /@request@/: a t'GI.WebKitWebProcessExtension.Objects.URIRequest.URIRequest'
    -> WebKitWebProcessExtension.URIResponse.URIResponse
    -- ^ /@redirectedResponse@/: a t'GI.WebKitWebProcessExtension.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.

type C_WebPageSendRequestCallback =
    Ptr WebPage ->                          -- object
    Ptr WebKitWebProcessExtension.URIRequest.URIRequest ->
    Ptr WebKitWebProcessExtension.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_WebPageSendRequestCallback :: 
    GObject a => (a -> WebPageSendRequestCallback) ->
    C_WebPageSendRequestCallback
wrap_WebPageSendRequestCallback :: forall a.
GObject a =>
(a -> WebPageSendRequestCallback) -> C_WebPageSendRequestCallback
wrap_WebPageSendRequestCallback a -> WebPageSendRequestCallback
gi'cb Ptr WebPage
gi'selfPtr 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
WebKitWebProcessExtension.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
WebKitWebProcessExtension.URIResponse.URIResponse) Ptr URIResponse
redirectedResponse
    Bool
result <- Ptr WebPage -> (WebPage -> IO Bool) -> IO Bool
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr WebPage
gi'selfPtr ((WebPage -> IO Bool) -> IO Bool)
-> (WebPage -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \WebPage
gi'self -> a -> WebPageSendRequestCallback
gi'cb (WebPage -> a
forall a b. Coercible a b => a -> b
Coerce.coerce WebPage
gi'self)  URIRequest
request' URIResponse
redirectedResponse'
    let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.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
P.fromEnum) Bool
result
    CInt -> IO CInt
forall a. a -> IO a
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 -> ((?self :: a) => WebPageSendRequestCallback) -> m SignalHandlerId
onWebPageSendRequest :: forall a (m :: * -> *).
(IsWebPage a, MonadIO m) =>
a
-> ((?self::a) => WebPageSendRequestCallback) -> m SignalHandlerId
onWebPageSendRequest a
obj (?self::a) => WebPageSendRequestCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> WebPageSendRequestCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => WebPageSendRequestCallback
WebPageSendRequestCallback
cb
    let wrapped' :: C_WebPageSendRequestCallback
wrapped' = (a -> WebPageSendRequestCallback) -> C_WebPageSendRequestCallback
forall a.
GObject a =>
(a -> WebPageSendRequestCallback) -> C_WebPageSendRequestCallback
wrap_WebPageSendRequestCallback a -> WebPageSendRequestCallback
wrapped
    FunPtr C_WebPageSendRequestCallback
wrapped'' <- C_WebPageSendRequestCallback
-> IO (FunPtr C_WebPageSendRequestCallback)
mk_WebPageSendRequestCallback C_WebPageSendRequestCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterWebPageSendRequest :: (IsWebPage a, MonadIO m) => a -> ((?self :: a) => WebPageSendRequestCallback) -> m SignalHandlerId
afterWebPageSendRequest :: forall a (m :: * -> *).
(IsWebPage a, MonadIO m) =>
a
-> ((?self::a) => WebPageSendRequestCallback) -> m SignalHandlerId
afterWebPageSendRequest a
obj (?self::a) => WebPageSendRequestCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> WebPageSendRequestCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => WebPageSendRequestCallback
WebPageSendRequestCallback
cb
    let wrapped' :: C_WebPageSendRequestCallback
wrapped' = (a -> WebPageSendRequestCallback) -> C_WebPageSendRequestCallback
forall a.
GObject a =>
(a -> WebPageSendRequestCallback) -> C_WebPageSendRequestCallback
wrap_WebPageSendRequestCallback a -> WebPageSendRequestCallback
wrapped
    FunPtr C_WebPageSendRequestCallback
wrapped'' <- C_WebPageSendRequestCallback
-> IO (FunPtr C_WebPageSendRequestCallback)
mk_WebPageSendRequestCallback C_WebPageSendRequestCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.WebKitWebProcessExtension.Objects.WebPage::send-request"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-webkitwebprocessextension-6.0.2/docs/GI-WebKitWebProcessExtension-Objects-WebPage.html#g:signal:sendRequest"})

#endif

-- signal WebPage::user-message-received
-- | This signal is emitted when a t'GI.WebKitWebProcessExtension.Objects.UserMessage.UserMessage' is received from the
-- @/WebKitWebView/@ corresponding to /@webPage@/. You can reply to the message
-- using 'GI.WebKitWebProcessExtension.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.WebKitWebProcessExtension.Enums.UserMessageErrorUserMessageUnhandledMessage'.
-- 
-- /Since: 2.28/
type WebPageUserMessageReceivedCallback =
    WebKitWebProcessExtension.UserMessage.UserMessage
    -- ^ /@message@/: the t'GI.WebKitWebProcessExtension.Objects.UserMessage.UserMessage' received
    -> IO Bool
    -- ^ __Returns:__ 'P.True' if the message was handled, or 'P.False' otherwise.

type C_WebPageUserMessageReceivedCallback =
    Ptr WebPage ->                          -- object
    Ptr WebKitWebProcessExtension.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_WebPageUserMessageReceivedCallback :: 
    GObject a => (a -> WebPageUserMessageReceivedCallback) ->
    C_WebPageUserMessageReceivedCallback
wrap_WebPageUserMessageReceivedCallback :: forall a.
GObject a =>
(a -> WebPageUserMessageReceivedCallback)
-> C_WebPageUserMessageReceivedCallback
wrap_WebPageUserMessageReceivedCallback a -> WebPageUserMessageReceivedCallback
gi'cb Ptr WebPage
gi'selfPtr 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
WebKitWebProcessExtension.UserMessage.UserMessage) Ptr UserMessage
message
    Bool
result <- Ptr WebPage -> (WebPage -> IO Bool) -> IO Bool
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr WebPage
gi'selfPtr ((WebPage -> IO Bool) -> IO Bool)
-> (WebPage -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \WebPage
gi'self -> a -> WebPageUserMessageReceivedCallback
gi'cb (WebPage -> a
forall a b. Coercible a b => a -> b
Coerce.coerce WebPage
gi'self)  UserMessage
message'
    let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.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
P.fromEnum) Bool
result
    CInt -> IO CInt
forall a. a -> IO a
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 -> ((?self :: a) => WebPageUserMessageReceivedCallback) -> m SignalHandlerId
onWebPageUserMessageReceived :: forall a (m :: * -> *).
(IsWebPage a, MonadIO m) =>
a
-> ((?self::a) => WebPageUserMessageReceivedCallback)
-> m SignalHandlerId
onWebPageUserMessageReceived a
obj (?self::a) => WebPageUserMessageReceivedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> WebPageUserMessageReceivedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => WebPageUserMessageReceivedCallback
WebPageUserMessageReceivedCallback
cb
    let wrapped' :: C_WebPageUserMessageReceivedCallback
wrapped' = (a -> WebPageUserMessageReceivedCallback)
-> C_WebPageUserMessageReceivedCallback
forall a.
GObject a =>
(a -> WebPageUserMessageReceivedCallback)
-> C_WebPageUserMessageReceivedCallback
wrap_WebPageUserMessageReceivedCallback a -> WebPageUserMessageReceivedCallback
wrapped
    FunPtr C_WebPageUserMessageReceivedCallback
wrapped'' <- C_WebPageUserMessageReceivedCallback
-> IO (FunPtr C_WebPageUserMessageReceivedCallback)
mk_WebPageUserMessageReceivedCallback C_WebPageUserMessageReceivedCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterWebPageUserMessageReceived :: (IsWebPage a, MonadIO m) => a -> ((?self :: a) => WebPageUserMessageReceivedCallback) -> m SignalHandlerId
afterWebPageUserMessageReceived :: forall a (m :: * -> *).
(IsWebPage a, MonadIO m) =>
a
-> ((?self::a) => WebPageUserMessageReceivedCallback)
-> m SignalHandlerId
afterWebPageUserMessageReceived a
obj (?self::a) => WebPageUserMessageReceivedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> WebPageUserMessageReceivedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => WebPageUserMessageReceivedCallback
WebPageUserMessageReceivedCallback
cb
    let wrapped' :: C_WebPageUserMessageReceivedCallback
wrapped' = (a -> WebPageUserMessageReceivedCallback)
-> C_WebPageUserMessageReceivedCallback
forall a.
GObject a =>
(a -> WebPageUserMessageReceivedCallback)
-> C_WebPageUserMessageReceivedCallback
wrap_WebPageUserMessageReceivedCallback a -> WebPageUserMessageReceivedCallback
wrapped
    FunPtr C_WebPageUserMessageReceivedCallback
wrapped'' <- C_WebPageUserMessageReceivedCallback
-> IO (FunPtr C_WebPageUserMessageReceivedCallback)
mk_WebPageUserMessageReceivedCallback C_WebPageUserMessageReceivedCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.WebKitWebProcessExtension.Objects.WebPage::user-message-received"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-webkitwebprocessextension-6.0.2/docs/GI-WebKitWebProcessExtension-Objects-WebPage.html#g:signal:userMessageReceived"})

#endif

-- VVV Prop "uri"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,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 T.Text
getWebPageUri :: forall (m :: * -> *) o. (MonadIO m, IsWebPage o) => o -> m Text
getWebPageUri o
obj = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe Text) -> IO Text
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getWebPageUri" (IO (Maybe Text) -> IO Text) -> IO (Maybe Text) -> IO 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 = T.Text
    type AttrLabel WebPageUriPropertyInfo = "uri"
    type AttrOrigin WebPageUriPropertyInfo = WebPage
    attrGet = getWebPageUri
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.WebKitWebProcessExtension.Objects.WebPage.uri"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-webkitwebprocessextension-6.0.2/docs/GI-WebKitWebProcessExtension-Objects-WebPage.html#g:attr:uri"
        })
#endif

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

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

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList WebPage = WebPageSignalList
type WebPageSignalList = ('[ '("contextMenu", WebPageContextMenuSignalInfo), '("documentLoaded", WebPageDocumentLoadedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("sendRequest", WebPageSendRequestSignalInfo), '("userMessageReceived", WebPageUserMessageReceivedSignalInfo)] :: [(Symbol, DK.Type)])

#endif

-- method WebPage::get_editor
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "web_page"
--           , argType =
--               TInterface
--                 Name { namespace = "WebKitWebProcessExtension" , 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 = "WebKitWebProcessExtension" , 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 = "WebKitWebProcessExtension", name = "WebPage"})
    IO (Ptr WebKitWebProcessExtension.WebEditor.WebEditor)

-- | Gets the t'GI.WebKitWebProcessExtension.Objects.WebEditor.WebEditor' of a t'GI.WebKitWebProcessExtension.Objects.WebPage.WebPage'.
-- 
-- /Since: 2.10/
webPageGetEditor ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebPage a) =>
    a
    -- ^ /@webPage@/: a t'GI.WebKitWebProcessExtension.Objects.WebPage.WebPage'
    -> m WebKitWebProcessExtension.WebEditor.WebEditor
    -- ^ __Returns:__ the t'GI.WebKitWebProcessExtension.Objects.WebEditor.WebEditor'
webPageGetEditor :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWebPage a) =>
a -> m WebEditor
webPageGetEditor a
webPage = IO WebEditor -> m WebEditor
forall a. IO a -> m a
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
WebKitWebProcessExtension.WebEditor.WebEditor) Ptr WebEditor
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
webPage
    WebEditor -> IO WebEditor
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return WebEditor
result'

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

instance O.OverloadedMethodInfo WebPageGetEditorMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.WebKitWebProcessExtension.Objects.WebPage.webPageGetEditor",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-webkitwebprocessextension-6.0.2/docs/GI-WebKitWebProcessExtension-Objects-WebPage.html#v:webPageGetEditor"
        })


#endif

-- method WebPage::get_form_manager
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "web_page"
--           , argType =
--               TInterface
--                 Name { namespace = "WebKitWebProcessExtension" , 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 = "world"
--           , argType =
--               TInterface
--                 Name
--                   { namespace = "WebKitWebProcessExtension" , name = "ScriptWorld" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #WebKitScriptWorld"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name
--                    { namespace = "WebKitWebProcessExtension"
--                    , name = "WebFormManager"
--                    })
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_page_get_form_manager" webkit_web_page_get_form_manager :: 
    Ptr WebPage ->                          -- web_page : TInterface (Name {namespace = "WebKitWebProcessExtension", name = "WebPage"})
    Ptr WebKitWebProcessExtension.ScriptWorld.ScriptWorld -> -- world : TInterface (Name {namespace = "WebKitWebProcessExtension", name = "ScriptWorld"})
    IO (Ptr WebKitWebProcessExtension.WebFormManager.WebFormManager)

-- | Get the t'GI.WebKitWebProcessExtension.Objects.WebFormManager.WebFormManager' of /@webPage@/ in /@world@/.
-- 
-- /Since: 2.40/
webPageGetFormManager ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebPage a, WebKitWebProcessExtension.ScriptWorld.IsScriptWorld b) =>
    a
    -- ^ /@webPage@/: a t'GI.WebKitWebProcessExtension.Objects.WebPage.WebPage'
    -> Maybe (b)
    -- ^ /@world@/: a t'GI.WebKitWebProcessExtension.Objects.ScriptWorld.ScriptWorld'
    -> m WebKitWebProcessExtension.WebFormManager.WebFormManager
    -- ^ __Returns:__ a t'GI.WebKitWebProcessExtension.Objects.WebFormManager.WebFormManager'
webPageGetFormManager :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsWebPage a, IsScriptWorld b) =>
a -> Maybe b -> m WebFormManager
webPageGetFormManager a
webPage Maybe b
world = IO WebFormManager -> m WebFormManager
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO WebFormManager -> m WebFormManager)
-> IO WebFormManager -> m WebFormManager
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 ScriptWorld
maybeWorld <- case Maybe b
world of
        Maybe b
Nothing -> Ptr ScriptWorld -> IO (Ptr ScriptWorld)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ScriptWorld
forall a. Ptr a
nullPtr
        Just b
jWorld -> do
            Ptr ScriptWorld
jWorld' <- b -> IO (Ptr ScriptWorld)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jWorld
            Ptr ScriptWorld -> IO (Ptr ScriptWorld)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ScriptWorld
jWorld'
    Ptr WebFormManager
result <- Ptr WebPage -> Ptr ScriptWorld -> IO (Ptr WebFormManager)
webkit_web_page_get_form_manager Ptr WebPage
webPage' Ptr ScriptWorld
maybeWorld
    Text -> Ptr WebFormManager -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"webPageGetFormManager" Ptr WebFormManager
result
    WebFormManager
result' <- ((ManagedPtr WebFormManager -> WebFormManager)
-> Ptr WebFormManager -> IO WebFormManager
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr WebFormManager -> WebFormManager
WebKitWebProcessExtension.WebFormManager.WebFormManager) Ptr WebFormManager
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
webPage
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
world b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    WebFormManager -> IO WebFormManager
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return WebFormManager
result'

#if defined(ENABLE_OVERLOADING)
data WebPageGetFormManagerMethodInfo
instance (signature ~ (Maybe (b) -> m WebKitWebProcessExtension.WebFormManager.WebFormManager), MonadIO m, IsWebPage a, WebKitWebProcessExtension.ScriptWorld.IsScriptWorld b) => O.OverloadedMethod WebPageGetFormManagerMethodInfo a signature where
    overloadedMethod = webPageGetFormManager

instance O.OverloadedMethodInfo WebPageGetFormManagerMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.WebKitWebProcessExtension.Objects.WebPage.webPageGetFormManager",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-webkitwebprocessextension-6.0.2/docs/GI-WebKitWebProcessExtension-Objects-WebPage.html#v:webPageGetFormManager"
        })


#endif

-- method WebPage::get_id
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "web_page"
--           , argType =
--               TInterface
--                 Name { namespace = "WebKitWebProcessExtension" , 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 = "WebKitWebProcessExtension", name = "WebPage"})
    IO Word64

-- | Get the identifier of the t'GI.WebKitWebProcessExtension.Objects.WebPage.WebPage'
webPageGetId ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebPage a) =>
    a
    -- ^ /@webPage@/: a t'GI.WebKitWebProcessExtension.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 a. IO a -> m a
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 a. a -> IO a
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 = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.WebKitWebProcessExtension.Objects.WebPage.webPageGetId",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-webkitwebprocessextension-6.0.2/docs/GI-WebKitWebProcessExtension-Objects-WebPage.html#v:webPageGetId"
        })


#endif

-- method WebPage::get_main_frame
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "web_page"
--           , argType =
--               TInterface
--                 Name { namespace = "WebKitWebProcessExtension" , 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 = "WebKitWebProcessExtension" , 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 = "WebKitWebProcessExtension", name = "WebPage"})
    IO (Ptr WebKitWebProcessExtension.Frame.Frame)

-- | Returns the main frame of a t'GI.WebKitWebProcessExtension.Objects.WebPage.WebPage'.
-- 
-- /Since: 2.2/
webPageGetMainFrame ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebPage a) =>
    a
    -- ^ /@webPage@/: a t'GI.WebKitWebProcessExtension.Objects.WebPage.WebPage'
    -> m WebKitWebProcessExtension.Frame.Frame
    -- ^ __Returns:__ the t'GI.WebKitWebProcessExtension.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 a. IO a -> m a
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
WebKitWebProcessExtension.Frame.Frame) Ptr Frame
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
webPage
    Frame -> IO Frame
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Frame
result'

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

instance O.OverloadedMethodInfo WebPageGetMainFrameMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.WebKitWebProcessExtension.Objects.WebPage.webPageGetMainFrame",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-webkitwebprocessextension-6.0.2/docs/GI-WebKitWebProcessExtension-Objects-WebPage.html#v:webPageGetMainFrame"
        })


#endif

-- method WebPage::get_uri
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "web_page"
--           , argType =
--               TInterface
--                 Name { namespace = "WebKitWebProcessExtension" , 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 = "WebKitWebProcessExtension", 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.WebKitWebProcessExtension.Objects.WebPage.WebPage'
    -> m 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 Text
webPageGetUri a
webPage = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"webPageGetUri" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
webPage
    Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

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

instance O.OverloadedMethodInfo WebPageGetUriMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.WebKitWebProcessExtension.Objects.WebPage.webPageGetUri",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-webkitwebprocessextension-6.0.2/docs/GI-WebKitWebProcessExtension-Objects-WebPage.html#v:webPageGetUri"
        })


#endif

-- method WebPage::send_message_to_view
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "web_page"
--           , argType =
--               TInterface
--                 Name { namespace = "WebKitWebProcessExtension" , 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 = "WebKitWebProcessExtension" , 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 = "WebKitWebProcessExtension", name = "WebPage"})
    Ptr WebKitWebProcessExtension.UserMessage.UserMessage -> -- message : TInterface (Name {namespace = "WebKitWebProcessExtension", 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.WebKitWebProcessExtension.Objects.WebPage.webPageSendMessageToViewFinish' to get the message reply.
-- 
-- /Since: 2.28/
webPageSendMessageToView ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebPage a, WebKitWebProcessExtension.UserMessage.IsUserMessage b, Gio.Cancellable.IsCancellable c) =>
    a
    -- ^ /@webPage@/: a t'GI.WebKitWebProcessExtension.Objects.WebPage.WebPage'
    -> b
    -- ^ /@message@/: a t'GI.WebKitWebProcessExtension.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 a. IO a -> m a
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 a. a -> IO a
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 a. a -> IO a
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 a. a -> IO a
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 -> 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
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 a. a -> IO a
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 a. a -> IO a
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, WebKitWebProcessExtension.UserMessage.IsUserMessage b, Gio.Cancellable.IsCancellable c) => O.OverloadedMethod WebPageSendMessageToViewMethodInfo a signature where
    overloadedMethod = webPageSendMessageToView

instance O.OverloadedMethodInfo WebPageSendMessageToViewMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.WebKitWebProcessExtension.Objects.WebPage.webPageSendMessageToView",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-webkitwebprocessextension-6.0.2/docs/GI-WebKitWebProcessExtension-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 = "WebKitWebProcessExtension" , 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 = "WebKitWebProcessExtension" , 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 = "WebKitWebProcessExtension", name = "WebPage"})
    Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr WebKitWebProcessExtension.UserMessage.UserMessage)

-- | Finish an asynchronous operation started with 'GI.WebKitWebProcessExtension.Objects.WebPage.webPageSendMessageToView'.
-- 
-- /Since: 2.28/
webPageSendMessageToViewFinish ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebPage a, Gio.AsyncResult.IsAsyncResult b) =>
    a
    -- ^ /@webPage@/: a t'GI.WebKitWebProcessExtension.Objects.WebPage.WebPage'
    -> b
    -- ^ /@result@/: a t'GI.Gio.Interfaces.AsyncResult.AsyncResult'
    -> m WebKitWebProcessExtension.UserMessage.UserMessage
    -- ^ __Returns:__ a t'GI.WebKitWebProcessExtension.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 a. IO a -> m a
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
WebKitWebProcessExtension.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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return UserMessage
result'
     ) (do
        () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data WebPageSendMessageToViewFinishMethodInfo
instance (signature ~ (b -> m WebKitWebProcessExtension.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 = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.WebKitWebProcessExtension.Objects.WebPage.webPageSendMessageToViewFinish",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-webkitwebprocessextension-6.0.2/docs/GI-WebKitWebProcessExtension-Objects-WebPage.html#v:webPageSendMessageToViewFinish"
        })


#endif