gi-webkit2webextension-4.0.19: GI/WebKit2WebExtension/Objects/WebPage.hs

{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)

/No description available in the introspection data./
-}

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

module GI.WebKit2WebExtension.Objects.WebPage
    ( 

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


 -- * Methods
-- ** getDomDocument #method:getDomDocument#

#if ENABLE_OVERLOADING
    WebPageGetDomDocumentMethodInfo         ,
#endif
    webPageGetDomDocument                   ,


-- ** getEditor #method:getEditor#

#if ENABLE_OVERLOADING
    WebPageGetEditorMethodInfo              ,
#endif
    webPageGetEditor                        ,


-- ** getId #method:getId#

#if ENABLE_OVERLOADING
    WebPageGetIdMethodInfo                  ,
#endif
    webPageGetId                            ,


-- ** getMainFrame #method:getMainFrame#

#if ENABLE_OVERLOADING
    WebPageGetMainFrameMethodInfo           ,
#endif
    webPageGetMainFrame                     ,


-- ** getUri #method:getUri#

#if ENABLE_OVERLOADING
    WebPageGetUriMethodInfo                 ,
#endif
    webPageGetUri                           ,




 -- * Properties
-- ** uri #attr:uri#
{- | The current active URI of the 'GI.WebKit2WebExtension.Objects.WebPage.WebPage'.
-}
#if ENABLE_OVERLOADING
    WebPageUriPropertyInfo                  ,
#endif
    getWebPageUri                           ,
#if ENABLE_OVERLOADING
    webPageUri                              ,
#endif




 -- * Signals
-- ** consoleMessageSent #signal:consoleMessageSent#

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


-- ** contextMenu #signal:contextMenu#

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


-- ** documentLoaded #signal:documentLoaded#

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


-- ** formControlsAssociated #signal:formControlsAssociated#

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


-- ** sendRequest #signal:sendRequest#

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


-- ** willSubmitForm #signal:willSubmitForm#

    C_WebPageWillSubmitFormCallback         ,
    WebPageWillSubmitFormCallback           ,
#if 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.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL

import qualified GI.GObject.Objects.Object as GObject.Object
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.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 (ManagedPtr WebPage)
foreign import ccall "webkit_web_page_get_type"
    c_webkit_web_page_get_type :: IO GType

instance GObject WebPage where
    gobjectType = c_webkit_web_page_get_type
    

-- | Type class for types which can be safely cast to `WebPage`, for instance with `toWebPage`.
class (GObject o, O.IsDescendantOf WebPage o) => IsWebPage o
instance (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 :: (MonadIO m, IsWebPage o) => o -> m WebPage
toWebPage = liftIO . unsafeCastTo WebPage

-- | A convenience alias for `Nothing` :: `Maybe` `WebPage`.
noWebPage :: Maybe WebPage
noWebPage = Nothing

#if 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 "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 "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveWebPageMethod l o = O.MethodResolutionFailed l o

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

#endif

-- signal 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 'GI.WebKit2WebExtension.Structs.ConsoleMessage.ConsoleMessage' -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `WebPageConsoleMessageSentCallback`@.
noWebPageConsoleMessageSentCallback :: Maybe WebPageConsoleMessageSentCallback
noWebPageConsoleMessageSentCallback = 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 cb = liftIO $ do
    let cb' = wrap_WebPageConsoleMessageSentCallback cb
    mk_WebPageConsoleMessageSentCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `WebPageConsoleMessageSentCallback` into a `C_WebPageConsoleMessageSentCallback`.
wrap_WebPageConsoleMessageSentCallback ::
    WebPageConsoleMessageSentCallback ->
    C_WebPageConsoleMessageSentCallback
wrap_WebPageConsoleMessageSentCallback _cb _ consoleMessage _ = do
    B.ManagedPtr.withTransient WebKit2WebExtension.ConsoleMessage.ConsoleMessage consoleMessage $ \consoleMessage' -> do
        _cb  consoleMessage'


{- |
Connect a signal handler for the “@console-message-sent@” 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 obj cb = liftIO $ do
    let cb' = wrap_WebPageConsoleMessageSentCallback cb
    cb'' <- mk_WebPageConsoleMessageSentCallback cb'
    connectSignalFunPtr obj "console-message-sent" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@console-message-sent@” 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 obj cb = liftIO $ do
    let cb' = wrap_WebPageConsoleMessageSentCallback cb
    cb'' <- mk_WebPageConsoleMessageSentCallback cb'
    connectSignalFunPtr obj "console-message-sent" cb'' SignalConnectAfter


-- 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 '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 'GI.WebKit2WebExtension.Objects.WebHitTestResult.WebHitTestResult' -}
    -> IO Bool
    {- ^ __Returns:__ 'True' if the proposed /@contextMenu@/ has been modified, or 'False' otherwise. -}

-- | A convenience synonym for @`Nothing` :: `Maybe` `WebPageContextMenuCallback`@.
noWebPageContextMenuCallback :: Maybe WebPageContextMenuCallback
noWebPageContextMenuCallback = 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 cb = liftIO $ do
    let cb' = wrap_WebPageContextMenuCallback cb
    mk_WebPageContextMenuCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `WebPageContextMenuCallback` into a `C_WebPageContextMenuCallback`.
wrap_WebPageContextMenuCallback ::
    WebPageContextMenuCallback ->
    C_WebPageContextMenuCallback
wrap_WebPageContextMenuCallback _cb _ contextMenu hitTestResult _ = do
    contextMenu' <- (newObject WebKit2WebExtension.ContextMenu.ContextMenu) contextMenu
    hitTestResult' <- (newObject WebKit2WebExtension.WebHitTestResult.WebHitTestResult) hitTestResult
    result <- _cb  contextMenu' hitTestResult'
    let result' = (fromIntegral . fromEnum) result
    return result'


{- |
Connect a signal handler for the “@context-menu@” 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 obj cb = liftIO $ do
    let cb' = wrap_WebPageContextMenuCallback cb
    cb'' <- mk_WebPageContextMenuCallback cb'
    connectSignalFunPtr obj "context-menu" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@context-menu@” 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 obj cb = liftIO $ do
    let cb' = wrap_WebPageContextMenuCallback cb
    cb'' <- mk_WebPageContextMenuCallback cb'
    connectSignalFunPtr obj "context-menu" cb'' SignalConnectAfter


-- signal WebPage::document-loaded
{- |
This signal is emitted when the DOM document of a '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 = 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 cb = liftIO $ do
    let cb' = wrap_WebPageDocumentLoadedCallback cb
    mk_WebPageDocumentLoadedCallback cb' >>= B.GClosure.newGClosure


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


{- |
Connect a signal handler for the “@document-loaded@” 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 obj cb = liftIO $ do
    let cb' = wrap_WebPageDocumentLoadedCallback cb
    cb'' <- mk_WebPageDocumentLoadedCallback cb'
    connectSignalFunPtr obj "document-loaded" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@document-loaded@” 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 obj cb = liftIO $ do
    let cb' = wrap_WebPageDocumentLoadedCallback cb
    cb'' <- mk_WebPageDocumentLoadedCallback cb'
    connectSignalFunPtr obj "document-loaded" cb'' SignalConnectAfter


-- signal WebPage::form-controls-associated
{- |
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 'GI.GLib.Structs.PtrArray.PtrArray' of
    '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 = 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 cb = liftIO $ do
    let cb' = wrap_WebPageFormControlsAssociatedCallback cb
    mk_WebPageFormControlsAssociatedCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `WebPageFormControlsAssociatedCallback` into a `C_WebPageFormControlsAssociatedCallback`.
wrap_WebPageFormControlsAssociatedCallback ::
    WebPageFormControlsAssociatedCallback ->
    C_WebPageFormControlsAssociatedCallback
wrap_WebPageFormControlsAssociatedCallback _cb _ elements _ = do
    elements' <- unpackGPtrArray elements
    elements'' <- mapM (newObject WebKit2WebExtension.DOMElement.DOMElement) elements'
    _cb  elements''


{- |
Connect a signal handler for the “@form-controls-associated@” 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 obj cb = liftIO $ do
    let cb' = wrap_WebPageFormControlsAssociatedCallback cb
    cb'' <- mk_WebPageFormControlsAssociatedCallback cb'
    connectSignalFunPtr obj "form-controls-associated" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@form-controls-associated@” 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 obj cb = liftIO $ do
    let cb' = wrap_WebPageFormControlsAssociatedCallback cb
    cb'' <- mk_WebPageFormControlsAssociatedCallback cb'
    connectSignalFunPtr obj "form-controls-associated" cb'' SignalConnectAfter


-- 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 '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 '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 'GI.WebKit2WebExtension.Objects.URIRequest.URIRequest' and its associated
'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 'GI.WebKit2WebExtension.Objects.URIRequest.URIRequest' -}
    -> WebKit2WebExtension.URIResponse.URIResponse
    {- ^ /@redirectedResponse@/: a 'GI.WebKit2WebExtension.Objects.URIResponse.URIResponse', or 'Nothing' -}
    -> IO Bool
    {- ^ __Returns:__ 'True' to stop other handlers from being invoked for the event.
   'False' to continue emission of the event. -}

-- | A convenience synonym for @`Nothing` :: `Maybe` `WebPageSendRequestCallback`@.
noWebPageSendRequestCallback :: Maybe WebPageSendRequestCallback
noWebPageSendRequestCallback = 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 cb = liftIO $ do
    let cb' = wrap_WebPageSendRequestCallback cb
    mk_WebPageSendRequestCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `WebPageSendRequestCallback` into a `C_WebPageSendRequestCallback`.
wrap_WebPageSendRequestCallback ::
    WebPageSendRequestCallback ->
    C_WebPageSendRequestCallback
wrap_WebPageSendRequestCallback _cb _ request redirectedResponse _ = do
    request' <- (newObject WebKit2WebExtension.URIRequest.URIRequest) request
    redirectedResponse' <- (newObject WebKit2WebExtension.URIResponse.URIResponse) redirectedResponse
    result <- _cb  request' redirectedResponse'
    let result' = (fromIntegral . fromEnum) result
    return result'


{- |
Connect a signal handler for the “@send-request@” 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 obj cb = liftIO $ do
    let cb' = wrap_WebPageSendRequestCallback cb
    cb'' <- mk_WebPageSendRequestCallback cb'
    connectSignalFunPtr obj "send-request" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@send-request@” 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 obj cb = liftIO $ do
    let cb' = wrap_WebPageSendRequestCallback cb
    cb'' <- mk_WebPageSendRequestCallback cb'
    connectSignalFunPtr obj "send-request" cb'' SignalConnectAfter


-- 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 '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 'GI.WebKit2WebExtension.Objects.Frame.Frame' containing the form to be
submitted -}
    -> WebKit2WebExtension.Frame.Frame
    {- ^ /@targetFrame@/: the '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 = 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 cb = liftIO $ do
    let cb' = wrap_WebPageWillSubmitFormCallback cb
    mk_WebPageWillSubmitFormCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `WebPageWillSubmitFormCallback` into a `C_WebPageWillSubmitFormCallback`.
wrap_WebPageWillSubmitFormCallback ::
    WebPageWillSubmitFormCallback ->
    C_WebPageWillSubmitFormCallback
wrap_WebPageWillSubmitFormCallback _cb _ form step sourceFrame targetFrame textFieldNames textFieldValues _ = do
    form' <- (newObject WebKit2WebExtension.DOMElement.DOMElement) form
    let step' = (toEnum . fromIntegral) step
    sourceFrame' <- (newObject WebKit2WebExtension.Frame.Frame) sourceFrame
    targetFrame' <- (newObject WebKit2WebExtension.Frame.Frame) targetFrame
    textFieldNames' <- unpackGPtrArray textFieldNames
    textFieldNames'' <- mapM cstringToText textFieldNames'
    textFieldValues' <- unpackGPtrArray textFieldValues
    textFieldValues'' <- mapM cstringToText textFieldValues'
    _cb  form' step' sourceFrame' targetFrame' textFieldNames'' textFieldValues''


{- |
Connect a signal handler for the “@will-submit-form@” 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 obj cb = liftIO $ do
    let cb' = wrap_WebPageWillSubmitFormCallback cb
    cb'' <- mk_WebPageWillSubmitFormCallback cb'
    connectSignalFunPtr obj "will-submit-form" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@will-submit-form@” 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 obj cb = liftIO $ do
    let cb' = wrap_WebPageWillSubmitFormCallback cb
    cb'' <- mk_WebPageWillSubmitFormCallback cb'
    connectSignalFunPtr obj "will-submit-form" cb'' SignalConnectAfter


-- 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 obj = liftIO $ B.Properties.getObjectPropertyString obj "uri"

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

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

#if ENABLE_OVERLOADING
webPageUri :: AttrLabelProxy "uri"
webPageUri = AttrLabelProxy

#endif

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

data WebPageContextMenuSignalInfo
instance SignalInfo WebPageContextMenuSignalInfo where
    type HaskellCallbackType WebPageContextMenuSignalInfo = WebPageContextMenuCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_WebPageContextMenuCallback cb
        cb'' <- mk_WebPageContextMenuCallback cb'
        connectSignalFunPtr obj "context-menu" cb'' connectMode

data WebPageDocumentLoadedSignalInfo
instance SignalInfo WebPageDocumentLoadedSignalInfo where
    type HaskellCallbackType WebPageDocumentLoadedSignalInfo = WebPageDocumentLoadedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_WebPageDocumentLoadedCallback cb
        cb'' <- mk_WebPageDocumentLoadedCallback cb'
        connectSignalFunPtr obj "document-loaded" cb'' connectMode

data WebPageFormControlsAssociatedSignalInfo
instance SignalInfo WebPageFormControlsAssociatedSignalInfo where
    type HaskellCallbackType WebPageFormControlsAssociatedSignalInfo = WebPageFormControlsAssociatedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_WebPageFormControlsAssociatedCallback cb
        cb'' <- mk_WebPageFormControlsAssociatedCallback cb'
        connectSignalFunPtr obj "form-controls-associated" cb'' connectMode

data WebPageSendRequestSignalInfo
instance SignalInfo WebPageSendRequestSignalInfo where
    type HaskellCallbackType WebPageSendRequestSignalInfo = WebPageSendRequestCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_WebPageSendRequestCallback cb
        cb'' <- mk_WebPageSendRequestCallback cb'
        connectSignalFunPtr obj "send-request" cb'' connectMode

data WebPageWillSubmitFormSignalInfo
instance SignalInfo WebPageWillSubmitFormSignalInfo where
    type HaskellCallbackType WebPageWillSubmitFormSignalInfo = WebPageWillSubmitFormCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_WebPageWillSubmitFormCallback cb
        cb'' <- mk_WebPageWillSubmitFormCallback cb'
        connectSignalFunPtr obj "will-submit-form" cb'' connectMode

type instance O.SignalList WebPage = WebPageSignalList
type WebPageSignalList = ('[ '("consoleMessageSent", WebPageConsoleMessageSentSignalInfo), '("contextMenu", WebPageContextMenuSignalInfo), '("documentLoaded", WebPageDocumentLoadedSignalInfo), '("formControlsAssociated", WebPageFormControlsAssociatedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("sendRequest", WebPageSendRequestSignalInfo), '("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 'GI.WebKit2WebExtension.Objects.DOMDocument.DOMDocument' currently loaded in /@webPage@/
-}
webPageGetDomDocument ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebPage a) =>
    a
    {- ^ /@webPage@/: a 'GI.WebKit2WebExtension.Objects.WebPage.WebPage' -}
    -> m (Maybe WebKit2WebExtension.DOMDocument.DOMDocument)
    {- ^ __Returns:__ the 'GI.WebKit2WebExtension.Objects.DOMDocument.DOMDocument' currently loaded, or 'Nothing'
   if no document is currently loaded. -}
webPageGetDomDocument webPage = liftIO $ do
    webPage' <- unsafeManagedPtrCastPtr webPage
    result <- webkit_web_page_get_dom_document webPage'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (newObject WebKit2WebExtension.DOMDocument.DOMDocument) result'
        return result''
    touchManagedPtr webPage
    return maybeResult

#if ENABLE_OVERLOADING
data WebPageGetDomDocumentMethodInfo
instance (signature ~ (m (Maybe WebKit2WebExtension.DOMDocument.DOMDocument)), MonadIO m, IsWebPage a) => O.MethodInfo WebPageGetDomDocumentMethodInfo a signature where
    overloadedMethod _ = 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 'GI.WebKit2WebExtension.Objects.WebEditor.WebEditor' of a 'GI.WebKit2WebExtension.Objects.WebPage.WebPage'.

/Since: 2.10/
-}
webPageGetEditor ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebPage a) =>
    a
    {- ^ /@webPage@/: a 'GI.WebKit2WebExtension.Objects.WebPage.WebPage' -}
    -> m WebKit2WebExtension.WebEditor.WebEditor
    {- ^ __Returns:__ the 'GI.WebKit2WebExtension.Objects.WebEditor.WebEditor' -}
webPageGetEditor webPage = liftIO $ do
    webPage' <- unsafeManagedPtrCastPtr webPage
    result <- webkit_web_page_get_editor webPage'
    checkUnexpectedReturnNULL "webPageGetEditor" result
    result' <- (newObject WebKit2WebExtension.WebEditor.WebEditor) result
    touchManagedPtr webPage
    return result'

#if ENABLE_OVERLOADING
data WebPageGetEditorMethodInfo
instance (signature ~ (m WebKit2WebExtension.WebEditor.WebEditor), MonadIO m, IsWebPage a) => O.MethodInfo WebPageGetEditorMethodInfo a signature where
    overloadedMethod _ = 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 'GI.WebKit2WebExtension.Objects.WebPage.WebPage'
-}
webPageGetId ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebPage a) =>
    a
    {- ^ /@webPage@/: a 'GI.WebKit2WebExtension.Objects.WebPage.WebPage' -}
    -> m Word64
    {- ^ __Returns:__ the identifier of /@webPage@/ -}
webPageGetId webPage = liftIO $ do
    webPage' <- unsafeManagedPtrCastPtr webPage
    result <- webkit_web_page_get_id webPage'
    touchManagedPtr webPage
    return result

#if ENABLE_OVERLOADING
data WebPageGetIdMethodInfo
instance (signature ~ (m Word64), MonadIO m, IsWebPage a) => O.MethodInfo WebPageGetIdMethodInfo a signature where
    overloadedMethod _ = 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 'GI.WebKit2WebExtension.Objects.WebPage.WebPage'.

/Since: 2.2/
-}
webPageGetMainFrame ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebPage a) =>
    a
    {- ^ /@webPage@/: a 'GI.WebKit2WebExtension.Objects.WebPage.WebPage' -}
    -> m WebKit2WebExtension.Frame.Frame
    {- ^ __Returns:__ the 'GI.WebKit2WebExtension.Objects.Frame.Frame' that is the main frame of /@webPage@/ -}
webPageGetMainFrame webPage = liftIO $ do
    webPage' <- unsafeManagedPtrCastPtr webPage
    result <- webkit_web_page_get_main_frame webPage'
    checkUnexpectedReturnNULL "webPageGetMainFrame" result
    result' <- (newObject WebKit2WebExtension.Frame.Frame) result
    touchManagedPtr webPage
    return result'

#if ENABLE_OVERLOADING
data WebPageGetMainFrameMethodInfo
instance (signature ~ (m WebKit2WebExtension.Frame.Frame), MonadIO m, IsWebPage a) => O.MethodInfo WebPageGetMainFrameMethodInfo a signature where
    overloadedMethod _ = 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
signal of /@webPage@/.
-}
webPageGetUri ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebPage a) =>
    a
    {- ^ /@webPage@/: a 'GI.WebKit2WebExtension.Objects.WebPage.WebPage' -}
    -> m (Maybe T.Text)
    {- ^ __Returns:__ the current active URI of /@webView@/ or 'Nothing' if nothing has been
   loaded yet. -}
webPageGetUri webPage = liftIO $ do
    webPage' <- unsafeManagedPtrCastPtr webPage
    result <- webkit_web_page_get_uri webPage'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- cstringToText result'
        return result''
    touchManagedPtr webPage
    return maybeResult

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

#endif