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

A 'GI.WebKit.Objects.WebView.WebView' contains a main 'GI.WebKit.Objects.WebFrame.WebFrame'. A 'GI.WebKit.Objects.WebFrame.WebFrame'
contains the content of one URI. The URI and name of the frame can
be retrieved, the load status and progress can be observed using the
signals and can be controlled using the methods of the 'GI.WebKit.Objects.WebFrame.WebFrame'.
A 'GI.WebKit.Objects.WebFrame.WebFrame' can have any number of children and one child can
be found by using @/webkit_web_frame_find_frame/@.

\<informalexample>\<programlisting>
\/\<!-- -->* Get the frame from the 'GI.WebKit.Objects.WebView.WebView' *\<!-- -->\/
WebKitWebFrame *frame = webkit_web_view_get_main_frame (WEBKIT_WEB_VIEW(my_view));
g_print (\"The URI of this frame is \'@/s/@\'\", webkit_web_frame_get_uri (frame));
\<\/programlisting>\<\/informalexample>
-}

module GI.WebKit.Objects.WebFrame
    ( 

-- * Exported types
    WebFrame(..)                            ,
    IsWebFrame                              ,
    toWebFrame                              ,
    noWebFrame                              ,


 -- * Methods
-- ** findFrame #method:findFrame#
    WebFrameFindFrameMethodInfo             ,
    webFrameFindFrame                       ,


-- ** getDataSource #method:getDataSource#
    WebFrameGetDataSourceMethodInfo         ,
    webFrameGetDataSource                   ,


-- ** getDomDocument #method:getDomDocument#
    WebFrameGetDomDocumentMethodInfo        ,
    webFrameGetDomDocument                  ,


-- ** getGlobalContext #method:getGlobalContext#
    WebFrameGetGlobalContextMethodInfo      ,
    webFrameGetGlobalContext                ,


-- ** getHorizontalScrollbarPolicy #method:getHorizontalScrollbarPolicy#
    WebFrameGetHorizontalScrollbarPolicyMethodInfo,
    webFrameGetHorizontalScrollbarPolicy    ,


-- ** getLoadStatus #method:getLoadStatus#
    WebFrameGetLoadStatusMethodInfo         ,
    webFrameGetLoadStatus                   ,


-- ** getName #method:getName#
    WebFrameGetNameMethodInfo               ,
    webFrameGetName                         ,


-- ** getNetworkResponse #method:getNetworkResponse#
    WebFrameGetNetworkResponseMethodInfo    ,
    webFrameGetNetworkResponse              ,


-- ** getParent #method:getParent#
    WebFrameGetParentMethodInfo             ,
    webFrameGetParent                       ,


-- ** getProvisionalDataSource #method:getProvisionalDataSource#
    WebFrameGetProvisionalDataSourceMethodInfo,
    webFrameGetProvisionalDataSource        ,


-- ** getRangeForWordAroundCaret #method:getRangeForWordAroundCaret#
    WebFrameGetRangeForWordAroundCaretMethodInfo,
    webFrameGetRangeForWordAroundCaret      ,


-- ** getSecurityOrigin #method:getSecurityOrigin#
    WebFrameGetSecurityOriginMethodInfo     ,
    webFrameGetSecurityOrigin               ,


-- ** getTitle #method:getTitle#
    WebFrameGetTitleMethodInfo              ,
    webFrameGetTitle                        ,


-- ** getUri #method:getUri#
    WebFrameGetUriMethodInfo                ,
    webFrameGetUri                          ,


-- ** getVerticalScrollbarPolicy #method:getVerticalScrollbarPolicy#
    WebFrameGetVerticalScrollbarPolicyMethodInfo,
    webFrameGetVerticalScrollbarPolicy      ,


-- ** getWebView #method:getWebView#
    WebFrameGetWebViewMethodInfo            ,
    webFrameGetWebView                      ,


-- ** loadAlternateString #method:loadAlternateString#
    WebFrameLoadAlternateStringMethodInfo   ,
    webFrameLoadAlternateString             ,


-- ** loadRequest #method:loadRequest#
    WebFrameLoadRequestMethodInfo           ,
    webFrameLoadRequest                     ,


-- ** loadString #method:loadString#
    WebFrameLoadStringMethodInfo            ,
    webFrameLoadString                      ,


-- ** loadUri #method:loadUri#
    WebFrameLoadUriMethodInfo               ,
    webFrameLoadUri                         ,


-- ** new #method:new#
    webFrameNew                             ,


-- ** print #method:print#
    WebFramePrintMethodInfo                 ,
    webFramePrint                           ,


-- ** printFull #method:printFull#
    WebFramePrintFullMethodInfo             ,
    webFramePrintFull                       ,


-- ** reload #method:reload#
    WebFrameReloadMethodInfo                ,
    webFrameReload                          ,


-- ** replaceSelection #method:replaceSelection#
    WebFrameReplaceSelectionMethodInfo      ,
    webFrameReplaceSelection                ,


-- ** stopLoading #method:stopLoading#
    WebFrameStopLoadingMethodInfo           ,
    webFrameStopLoading                     ,




 -- * Properties
-- ** horizontalScrollbarPolicy #attr:horizontalScrollbarPolicy#
    WebFrameHorizontalScrollbarPolicyPropertyInfo,
    getWebFrameHorizontalScrollbarPolicy    ,
    webFrameHorizontalScrollbarPolicy       ,


-- ** loadStatus #attr:loadStatus#
    WebFrameLoadStatusPropertyInfo          ,
    getWebFrameLoadStatus                   ,
    webFrameLoadStatus                      ,


-- ** name #attr:name#
    WebFrameNamePropertyInfo                ,
    getWebFrameName                         ,
    webFrameName                            ,


-- ** title #attr:title#
    WebFrameTitlePropertyInfo               ,
    getWebFrameTitle                        ,
    webFrameTitle                           ,


-- ** uri #attr:uri#
    WebFrameUriPropertyInfo                 ,
    getWebFrameUri                          ,
    webFrameUri                             ,


-- ** verticalScrollbarPolicy #attr:verticalScrollbarPolicy#
    WebFrameVerticalScrollbarPolicyPropertyInfo,
    getWebFrameVerticalScrollbarPolicy      ,
    webFrameVerticalScrollbarPolicy         ,




 -- * Signals
-- ** cleared #signal:cleared#
    C_WebFrameClearedCallback               ,
    WebFrameClearedCallback                 ,
    WebFrameClearedSignalInfo               ,
    afterWebFrameCleared                    ,
    genClosure_WebFrameCleared              ,
    mk_WebFrameClearedCallback              ,
    noWebFrameClearedCallback               ,
    onWebFrameCleared                       ,
    wrap_WebFrameClearedCallback            ,


-- ** hoveringOverLink #signal:hoveringOverLink#
    C_WebFrameHoveringOverLinkCallback      ,
    WebFrameHoveringOverLinkCallback        ,
    WebFrameHoveringOverLinkSignalInfo      ,
    afterWebFrameHoveringOverLink           ,
    genClosure_WebFrameHoveringOverLink     ,
    mk_WebFrameHoveringOverLinkCallback     ,
    noWebFrameHoveringOverLinkCallback      ,
    onWebFrameHoveringOverLink              ,
    wrap_WebFrameHoveringOverLinkCallback   ,


-- ** insecureContentRun #signal:insecureContentRun#
    C_WebFrameInsecureContentRunCallback    ,
    WebFrameInsecureContentRunCallback      ,
    WebFrameInsecureContentRunSignalInfo    ,
    afterWebFrameInsecureContentRun         ,
    genClosure_WebFrameInsecureContentRun   ,
    mk_WebFrameInsecureContentRunCallback   ,
    noWebFrameInsecureContentRunCallback    ,
    onWebFrameInsecureContentRun            ,
    wrap_WebFrameInsecureContentRunCallback ,


-- ** loadCommitted #signal:loadCommitted#
    C_WebFrameLoadCommittedCallback         ,
    WebFrameLoadCommittedCallback           ,
    WebFrameLoadCommittedSignalInfo         ,
    afterWebFrameLoadCommitted              ,
    genClosure_WebFrameLoadCommitted        ,
    mk_WebFrameLoadCommittedCallback        ,
    noWebFrameLoadCommittedCallback         ,
    onWebFrameLoadCommitted                 ,
    wrap_WebFrameLoadCommittedCallback      ,


-- ** resourceContentLengthReceived #signal:resourceContentLengthReceived#
    C_WebFrameResourceContentLengthReceivedCallback,
    WebFrameResourceContentLengthReceivedCallback,
    WebFrameResourceContentLengthReceivedSignalInfo,
    afterWebFrameResourceContentLengthReceived,
    genClosure_WebFrameResourceContentLengthReceived,
    mk_WebFrameResourceContentLengthReceivedCallback,
    noWebFrameResourceContentLengthReceivedCallback,
    onWebFrameResourceContentLengthReceived ,
    wrap_WebFrameResourceContentLengthReceivedCallback,


-- ** resourceLoadFailed #signal:resourceLoadFailed#
    C_WebFrameResourceLoadFailedCallback    ,
    WebFrameResourceLoadFailedCallback      ,
    WebFrameResourceLoadFailedSignalInfo    ,
    afterWebFrameResourceLoadFailed         ,
    genClosure_WebFrameResourceLoadFailed   ,
    mk_WebFrameResourceLoadFailedCallback   ,
    noWebFrameResourceLoadFailedCallback    ,
    onWebFrameResourceLoadFailed            ,
    wrap_WebFrameResourceLoadFailedCallback ,


-- ** resourceLoadFinished #signal:resourceLoadFinished#
    C_WebFrameResourceLoadFinishedCallback  ,
    WebFrameResourceLoadFinishedCallback    ,
    WebFrameResourceLoadFinishedSignalInfo  ,
    afterWebFrameResourceLoadFinished       ,
    genClosure_WebFrameResourceLoadFinished ,
    mk_WebFrameResourceLoadFinishedCallback ,
    noWebFrameResourceLoadFinishedCallback  ,
    onWebFrameResourceLoadFinished          ,
    wrap_WebFrameResourceLoadFinishedCallback,


-- ** resourceRequestStarting #signal:resourceRequestStarting#
    C_WebFrameResourceRequestStartingCallback,
    WebFrameResourceRequestStartingCallback ,
    WebFrameResourceRequestStartingSignalInfo,
    afterWebFrameResourceRequestStarting    ,
    genClosure_WebFrameResourceRequestStarting,
    mk_WebFrameResourceRequestStartingCallback,
    noWebFrameResourceRequestStartingCallback,
    onWebFrameResourceRequestStarting       ,
    wrap_WebFrameResourceRequestStartingCallback,


-- ** resourceResponseReceived #signal:resourceResponseReceived#
    C_WebFrameResourceResponseReceivedCallback,
    WebFrameResourceResponseReceivedCallback,
    WebFrameResourceResponseReceivedSignalInfo,
    afterWebFrameResourceResponseReceived   ,
    genClosure_WebFrameResourceResponseReceived,
    mk_WebFrameResourceResponseReceivedCallback,
    noWebFrameResourceResponseReceivedCallback,
    onWebFrameResourceResponseReceived      ,
    wrap_WebFrameResourceResponseReceivedCallback,


-- ** scrollbarsPolicyChanged #signal:scrollbarsPolicyChanged#
    C_WebFrameScrollbarsPolicyChangedCallback,
    WebFrameScrollbarsPolicyChangedCallback ,
    WebFrameScrollbarsPolicyChangedSignalInfo,
    afterWebFrameScrollbarsPolicyChanged    ,
    genClosure_WebFrameScrollbarsPolicyChanged,
    mk_WebFrameScrollbarsPolicyChangedCallback,
    noWebFrameScrollbarsPolicyChangedCallback,
    onWebFrameScrollbarsPolicyChanged       ,
    wrap_WebFrameScrollbarsPolicyChangedCallback,


-- ** titleChanged #signal:titleChanged#
    C_WebFrameTitleChangedCallback          ,
    WebFrameTitleChangedCallback            ,
    WebFrameTitleChangedSignalInfo          ,
    afterWebFrameTitleChanged               ,
    genClosure_WebFrameTitleChanged         ,
    mk_WebFrameTitleChangedCallback         ,
    noWebFrameTitleChangedCallback          ,
    onWebFrameTitleChanged                  ,
    wrap_WebFrameTitleChangedCallback       ,




    ) 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.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
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 GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gtk.Enums as Gtk.Enums
import qualified GI.Gtk.Objects.PrintOperation as Gtk.PrintOperation
import qualified GI.JavaScriptCore.Structs.GlobalContext as JavaScriptCore.GlobalContext
import {-# SOURCE #-} qualified GI.WebKit.Enums as WebKit.Enums
import {-# SOURCE #-} qualified GI.WebKit.Objects.DOMDocument as WebKit.DOMDocument
import {-# SOURCE #-} qualified GI.WebKit.Objects.DOMRange as WebKit.DOMRange
import {-# SOURCE #-} qualified GI.WebKit.Objects.NetworkRequest as WebKit.NetworkRequest
import {-# SOURCE #-} qualified GI.WebKit.Objects.NetworkResponse as WebKit.NetworkResponse
import {-# SOURCE #-} qualified GI.WebKit.Objects.SecurityOrigin as WebKit.SecurityOrigin
import {-# SOURCE #-} qualified GI.WebKit.Objects.WebDataSource as WebKit.WebDataSource
import {-# SOURCE #-} qualified GI.WebKit.Objects.WebResource as WebKit.WebResource
import {-# SOURCE #-} qualified GI.WebKit.Objects.WebView as WebKit.WebView

newtype WebFrame = WebFrame (ManagedPtr WebFrame)
foreign import ccall "webkit_web_frame_get_type"
    c_webkit_web_frame_get_type :: IO GType

instance GObject WebFrame where
    gobjectType _ = c_webkit_web_frame_get_type
    

class GObject o => IsWebFrame o
#if MIN_VERSION_base(4,9,0)
instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError WebFrame a) =>
    IsWebFrame a
#endif
instance IsWebFrame WebFrame
instance GObject.Object.IsObject WebFrame

toWebFrame :: IsWebFrame o => o -> IO WebFrame
toWebFrame = unsafeCastTo WebFrame

noWebFrame :: Maybe WebFrame
noWebFrame = Nothing

type family ResolveWebFrameMethod (t :: Symbol) (o :: *) :: * where
    ResolveWebFrameMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveWebFrameMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveWebFrameMethod "findFrame" o = WebFrameFindFrameMethodInfo
    ResolveWebFrameMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveWebFrameMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveWebFrameMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveWebFrameMethod "loadAlternateString" o = WebFrameLoadAlternateStringMethodInfo
    ResolveWebFrameMethod "loadRequest" o = WebFrameLoadRequestMethodInfo
    ResolveWebFrameMethod "loadString" o = WebFrameLoadStringMethodInfo
    ResolveWebFrameMethod "loadUri" o = WebFrameLoadUriMethodInfo
    ResolveWebFrameMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveWebFrameMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveWebFrameMethod "print" o = WebFramePrintMethodInfo
    ResolveWebFrameMethod "printFull" o = WebFramePrintFullMethodInfo
    ResolveWebFrameMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveWebFrameMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveWebFrameMethod "reload" o = WebFrameReloadMethodInfo
    ResolveWebFrameMethod "replaceData" o = GObject.Object.ObjectReplaceDataMethodInfo
    ResolveWebFrameMethod "replaceQdata" o = GObject.Object.ObjectReplaceQdataMethodInfo
    ResolveWebFrameMethod "replaceSelection" o = WebFrameReplaceSelectionMethodInfo
    ResolveWebFrameMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveWebFrameMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveWebFrameMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveWebFrameMethod "stopLoading" o = WebFrameStopLoadingMethodInfo
    ResolveWebFrameMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveWebFrameMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveWebFrameMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveWebFrameMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveWebFrameMethod "getDataSource" o = WebFrameGetDataSourceMethodInfo
    ResolveWebFrameMethod "getDomDocument" o = WebFrameGetDomDocumentMethodInfo
    ResolveWebFrameMethod "getGlobalContext" o = WebFrameGetGlobalContextMethodInfo
    ResolveWebFrameMethod "getHorizontalScrollbarPolicy" o = WebFrameGetHorizontalScrollbarPolicyMethodInfo
    ResolveWebFrameMethod "getLoadStatus" o = WebFrameGetLoadStatusMethodInfo
    ResolveWebFrameMethod "getName" o = WebFrameGetNameMethodInfo
    ResolveWebFrameMethod "getNetworkResponse" o = WebFrameGetNetworkResponseMethodInfo
    ResolveWebFrameMethod "getParent" o = WebFrameGetParentMethodInfo
    ResolveWebFrameMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveWebFrameMethod "getProvisionalDataSource" o = WebFrameGetProvisionalDataSourceMethodInfo
    ResolveWebFrameMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveWebFrameMethod "getRangeForWordAroundCaret" o = WebFrameGetRangeForWordAroundCaretMethodInfo
    ResolveWebFrameMethod "getSecurityOrigin" o = WebFrameGetSecurityOriginMethodInfo
    ResolveWebFrameMethod "getTitle" o = WebFrameGetTitleMethodInfo
    ResolveWebFrameMethod "getUri" o = WebFrameGetUriMethodInfo
    ResolveWebFrameMethod "getVerticalScrollbarPolicy" o = WebFrameGetVerticalScrollbarPolicyMethodInfo
    ResolveWebFrameMethod "getWebView" o = WebFrameGetWebViewMethodInfo
    ResolveWebFrameMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveWebFrameMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveWebFrameMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveWebFrameMethod t WebFrame, O.MethodInfo info WebFrame p) => O.IsLabelProxy t (WebFrame -> p) where
    fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveWebFrameMethod t WebFrame, O.MethodInfo info WebFrame p) => O.IsLabel t (WebFrame -> p) where
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif

-- signal WebFrame::cleared
type WebFrameClearedCallback =
    IO ()

noWebFrameClearedCallback :: Maybe WebFrameClearedCallback
noWebFrameClearedCallback = Nothing

type C_WebFrameClearedCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_WebFrameClearedCallback :: C_WebFrameClearedCallback -> IO (FunPtr C_WebFrameClearedCallback)

genClosure_WebFrameCleared :: WebFrameClearedCallback -> IO Closure
genClosure_WebFrameCleared cb = do
    let cb' = wrap_WebFrameClearedCallback cb
    mk_WebFrameClearedCallback cb' >>= newCClosure


wrap_WebFrameClearedCallback ::
    WebFrameClearedCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_WebFrameClearedCallback _cb _ _ = do
    _cb 


onWebFrameCleared :: (GObject a, MonadIO m) => a -> WebFrameClearedCallback -> m SignalHandlerId
onWebFrameCleared obj cb = liftIO $ connectWebFrameCleared obj cb SignalConnectBefore
afterWebFrameCleared :: (GObject a, MonadIO m) => a -> WebFrameClearedCallback -> m SignalHandlerId
afterWebFrameCleared obj cb = connectWebFrameCleared obj cb SignalConnectAfter

connectWebFrameCleared :: (GObject a, MonadIO m) =>
                          a -> WebFrameClearedCallback -> SignalConnectMode -> m SignalHandlerId
connectWebFrameCleared obj cb after = liftIO $ do
    let cb' = wrap_WebFrameClearedCallback cb
    cb'' <- mk_WebFrameClearedCallback cb'
    connectSignalFunPtr obj "cleared" cb'' after

-- signal WebFrame::hovering-over-link
type WebFrameHoveringOverLinkCallback =
    T.Text ->
    T.Text ->
    IO ()

noWebFrameHoveringOverLinkCallback :: Maybe WebFrameHoveringOverLinkCallback
noWebFrameHoveringOverLinkCallback = Nothing

type C_WebFrameHoveringOverLinkCallback =
    Ptr () ->                               -- object
    CString ->
    CString ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_WebFrameHoveringOverLinkCallback :: C_WebFrameHoveringOverLinkCallback -> IO (FunPtr C_WebFrameHoveringOverLinkCallback)

genClosure_WebFrameHoveringOverLink :: WebFrameHoveringOverLinkCallback -> IO Closure
genClosure_WebFrameHoveringOverLink cb = do
    let cb' = wrap_WebFrameHoveringOverLinkCallback cb
    mk_WebFrameHoveringOverLinkCallback cb' >>= newCClosure


wrap_WebFrameHoveringOverLinkCallback ::
    WebFrameHoveringOverLinkCallback ->
    Ptr () ->
    CString ->
    CString ->
    Ptr () ->
    IO ()
wrap_WebFrameHoveringOverLinkCallback _cb _ object p0 _ = do
    object' <- cstringToText object
    p0' <- cstringToText p0
    _cb  object' p0'


onWebFrameHoveringOverLink :: (GObject a, MonadIO m) => a -> WebFrameHoveringOverLinkCallback -> m SignalHandlerId
onWebFrameHoveringOverLink obj cb = liftIO $ connectWebFrameHoveringOverLink obj cb SignalConnectBefore
afterWebFrameHoveringOverLink :: (GObject a, MonadIO m) => a -> WebFrameHoveringOverLinkCallback -> m SignalHandlerId
afterWebFrameHoveringOverLink obj cb = connectWebFrameHoveringOverLink obj cb SignalConnectAfter

connectWebFrameHoveringOverLink :: (GObject a, MonadIO m) =>
                                   a -> WebFrameHoveringOverLinkCallback -> SignalConnectMode -> m SignalHandlerId
connectWebFrameHoveringOverLink obj cb after = liftIO $ do
    let cb' = wrap_WebFrameHoveringOverLinkCallback cb
    cb'' <- mk_WebFrameHoveringOverLinkCallback cb'
    connectSignalFunPtr obj "hovering-over-link" cb'' after

-- signal WebFrame::insecure-content-run
type WebFrameInsecureContentRunCallback =
    WebKit.SecurityOrigin.SecurityOrigin ->
    T.Text ->
    IO ()

noWebFrameInsecureContentRunCallback :: Maybe WebFrameInsecureContentRunCallback
noWebFrameInsecureContentRunCallback = Nothing

type C_WebFrameInsecureContentRunCallback =
    Ptr () ->                               -- object
    Ptr WebKit.SecurityOrigin.SecurityOrigin ->
    CString ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_WebFrameInsecureContentRunCallback :: C_WebFrameInsecureContentRunCallback -> IO (FunPtr C_WebFrameInsecureContentRunCallback)

genClosure_WebFrameInsecureContentRun :: WebFrameInsecureContentRunCallback -> IO Closure
genClosure_WebFrameInsecureContentRun cb = do
    let cb' = wrap_WebFrameInsecureContentRunCallback cb
    mk_WebFrameInsecureContentRunCallback cb' >>= newCClosure


wrap_WebFrameInsecureContentRunCallback ::
    WebFrameInsecureContentRunCallback ->
    Ptr () ->
    Ptr WebKit.SecurityOrigin.SecurityOrigin ->
    CString ->
    Ptr () ->
    IO ()
wrap_WebFrameInsecureContentRunCallback _cb _ securityOrigin url _ = do
    securityOrigin' <- (newObject WebKit.SecurityOrigin.SecurityOrigin) securityOrigin
    url' <- cstringToText url
    _cb  securityOrigin' url'


onWebFrameInsecureContentRun :: (GObject a, MonadIO m) => a -> WebFrameInsecureContentRunCallback -> m SignalHandlerId
onWebFrameInsecureContentRun obj cb = liftIO $ connectWebFrameInsecureContentRun obj cb SignalConnectBefore
afterWebFrameInsecureContentRun :: (GObject a, MonadIO m) => a -> WebFrameInsecureContentRunCallback -> m SignalHandlerId
afterWebFrameInsecureContentRun obj cb = connectWebFrameInsecureContentRun obj cb SignalConnectAfter

connectWebFrameInsecureContentRun :: (GObject a, MonadIO m) =>
                                     a -> WebFrameInsecureContentRunCallback -> SignalConnectMode -> m SignalHandlerId
connectWebFrameInsecureContentRun obj cb after = liftIO $ do
    let cb' = wrap_WebFrameInsecureContentRunCallback cb
    cb'' <- mk_WebFrameInsecureContentRunCallback cb'
    connectSignalFunPtr obj "insecure-content-run" cb'' after

-- signal WebFrame::load-committed
{-# DEPRECATED WebFrameLoadCommittedCallback ["Use the \\\"load-status\\\" property instead."] #-}
type WebFrameLoadCommittedCallback =
    IO ()

noWebFrameLoadCommittedCallback :: Maybe WebFrameLoadCommittedCallback
noWebFrameLoadCommittedCallback = Nothing

type C_WebFrameLoadCommittedCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_WebFrameLoadCommittedCallback :: C_WebFrameLoadCommittedCallback -> IO (FunPtr C_WebFrameLoadCommittedCallback)

genClosure_WebFrameLoadCommitted :: WebFrameLoadCommittedCallback -> IO Closure
genClosure_WebFrameLoadCommitted cb = do
    let cb' = wrap_WebFrameLoadCommittedCallback cb
    mk_WebFrameLoadCommittedCallback cb' >>= newCClosure


wrap_WebFrameLoadCommittedCallback ::
    WebFrameLoadCommittedCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_WebFrameLoadCommittedCallback _cb _ _ = do
    _cb 


onWebFrameLoadCommitted :: (GObject a, MonadIO m) => a -> WebFrameLoadCommittedCallback -> m SignalHandlerId
onWebFrameLoadCommitted obj cb = liftIO $ connectWebFrameLoadCommitted obj cb SignalConnectBefore
afterWebFrameLoadCommitted :: (GObject a, MonadIO m) => a -> WebFrameLoadCommittedCallback -> m SignalHandlerId
afterWebFrameLoadCommitted obj cb = connectWebFrameLoadCommitted obj cb SignalConnectAfter

connectWebFrameLoadCommitted :: (GObject a, MonadIO m) =>
                                a -> WebFrameLoadCommittedCallback -> SignalConnectMode -> m SignalHandlerId
connectWebFrameLoadCommitted obj cb after = liftIO $ do
    let cb' = wrap_WebFrameLoadCommittedCallback cb
    cb'' <- mk_WebFrameLoadCommittedCallback cb'
    connectSignalFunPtr obj "load-committed" cb'' after

-- signal WebFrame::resource-content-length-received
type WebFrameResourceContentLengthReceivedCallback =
    WebKit.WebResource.WebResource ->
    Int32 ->
    IO ()

noWebFrameResourceContentLengthReceivedCallback :: Maybe WebFrameResourceContentLengthReceivedCallback
noWebFrameResourceContentLengthReceivedCallback = Nothing

type C_WebFrameResourceContentLengthReceivedCallback =
    Ptr () ->                               -- object
    Ptr WebKit.WebResource.WebResource ->
    Int32 ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_WebFrameResourceContentLengthReceivedCallback :: C_WebFrameResourceContentLengthReceivedCallback -> IO (FunPtr C_WebFrameResourceContentLengthReceivedCallback)

genClosure_WebFrameResourceContentLengthReceived :: WebFrameResourceContentLengthReceivedCallback -> IO Closure
genClosure_WebFrameResourceContentLengthReceived cb = do
    let cb' = wrap_WebFrameResourceContentLengthReceivedCallback cb
    mk_WebFrameResourceContentLengthReceivedCallback cb' >>= newCClosure


wrap_WebFrameResourceContentLengthReceivedCallback ::
    WebFrameResourceContentLengthReceivedCallback ->
    Ptr () ->
    Ptr WebKit.WebResource.WebResource ->
    Int32 ->
    Ptr () ->
    IO ()
wrap_WebFrameResourceContentLengthReceivedCallback _cb _ webResource lengthReceived _ = do
    webResource' <- (newObject WebKit.WebResource.WebResource) webResource
    _cb  webResource' lengthReceived


onWebFrameResourceContentLengthReceived :: (GObject a, MonadIO m) => a -> WebFrameResourceContentLengthReceivedCallback -> m SignalHandlerId
onWebFrameResourceContentLengthReceived obj cb = liftIO $ connectWebFrameResourceContentLengthReceived obj cb SignalConnectBefore
afterWebFrameResourceContentLengthReceived :: (GObject a, MonadIO m) => a -> WebFrameResourceContentLengthReceivedCallback -> m SignalHandlerId
afterWebFrameResourceContentLengthReceived obj cb = connectWebFrameResourceContentLengthReceived obj cb SignalConnectAfter

connectWebFrameResourceContentLengthReceived :: (GObject a, MonadIO m) =>
                                                a -> WebFrameResourceContentLengthReceivedCallback -> SignalConnectMode -> m SignalHandlerId
connectWebFrameResourceContentLengthReceived obj cb after = liftIO $ do
    let cb' = wrap_WebFrameResourceContentLengthReceivedCallback cb
    cb'' <- mk_WebFrameResourceContentLengthReceivedCallback cb'
    connectSignalFunPtr obj "resource-content-length-received" cb'' after

-- signal WebFrame::resource-load-failed
type WebFrameResourceLoadFailedCallback =
    WebKit.WebResource.WebResource ->
    Ptr () ->
    IO ()

noWebFrameResourceLoadFailedCallback :: Maybe WebFrameResourceLoadFailedCallback
noWebFrameResourceLoadFailedCallback = Nothing

type C_WebFrameResourceLoadFailedCallback =
    Ptr () ->                               -- object
    Ptr WebKit.WebResource.WebResource ->
    Ptr () ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_WebFrameResourceLoadFailedCallback :: C_WebFrameResourceLoadFailedCallback -> IO (FunPtr C_WebFrameResourceLoadFailedCallback)

genClosure_WebFrameResourceLoadFailed :: WebFrameResourceLoadFailedCallback -> IO Closure
genClosure_WebFrameResourceLoadFailed cb = do
    let cb' = wrap_WebFrameResourceLoadFailedCallback cb
    mk_WebFrameResourceLoadFailedCallback cb' >>= newCClosure


wrap_WebFrameResourceLoadFailedCallback ::
    WebFrameResourceLoadFailedCallback ->
    Ptr () ->
    Ptr WebKit.WebResource.WebResource ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_WebFrameResourceLoadFailedCallback _cb _ webResource error_ _ = do
    webResource' <- (newObject WebKit.WebResource.WebResource) webResource
    _cb  webResource' error_


onWebFrameResourceLoadFailed :: (GObject a, MonadIO m) => a -> WebFrameResourceLoadFailedCallback -> m SignalHandlerId
onWebFrameResourceLoadFailed obj cb = liftIO $ connectWebFrameResourceLoadFailed obj cb SignalConnectBefore
afterWebFrameResourceLoadFailed :: (GObject a, MonadIO m) => a -> WebFrameResourceLoadFailedCallback -> m SignalHandlerId
afterWebFrameResourceLoadFailed obj cb = connectWebFrameResourceLoadFailed obj cb SignalConnectAfter

connectWebFrameResourceLoadFailed :: (GObject a, MonadIO m) =>
                                     a -> WebFrameResourceLoadFailedCallback -> SignalConnectMode -> m SignalHandlerId
connectWebFrameResourceLoadFailed obj cb after = liftIO $ do
    let cb' = wrap_WebFrameResourceLoadFailedCallback cb
    cb'' <- mk_WebFrameResourceLoadFailedCallback cb'
    connectSignalFunPtr obj "resource-load-failed" cb'' after

-- signal WebFrame::resource-load-finished
type WebFrameResourceLoadFinishedCallback =
    WebKit.WebResource.WebResource ->
    IO ()

noWebFrameResourceLoadFinishedCallback :: Maybe WebFrameResourceLoadFinishedCallback
noWebFrameResourceLoadFinishedCallback = Nothing

type C_WebFrameResourceLoadFinishedCallback =
    Ptr () ->                               -- object
    Ptr WebKit.WebResource.WebResource ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_WebFrameResourceLoadFinishedCallback :: C_WebFrameResourceLoadFinishedCallback -> IO (FunPtr C_WebFrameResourceLoadFinishedCallback)

genClosure_WebFrameResourceLoadFinished :: WebFrameResourceLoadFinishedCallback -> IO Closure
genClosure_WebFrameResourceLoadFinished cb = do
    let cb' = wrap_WebFrameResourceLoadFinishedCallback cb
    mk_WebFrameResourceLoadFinishedCallback cb' >>= newCClosure


wrap_WebFrameResourceLoadFinishedCallback ::
    WebFrameResourceLoadFinishedCallback ->
    Ptr () ->
    Ptr WebKit.WebResource.WebResource ->
    Ptr () ->
    IO ()
wrap_WebFrameResourceLoadFinishedCallback _cb _ webResource _ = do
    webResource' <- (newObject WebKit.WebResource.WebResource) webResource
    _cb  webResource'


onWebFrameResourceLoadFinished :: (GObject a, MonadIO m) => a -> WebFrameResourceLoadFinishedCallback -> m SignalHandlerId
onWebFrameResourceLoadFinished obj cb = liftIO $ connectWebFrameResourceLoadFinished obj cb SignalConnectBefore
afterWebFrameResourceLoadFinished :: (GObject a, MonadIO m) => a -> WebFrameResourceLoadFinishedCallback -> m SignalHandlerId
afterWebFrameResourceLoadFinished obj cb = connectWebFrameResourceLoadFinished obj cb SignalConnectAfter

connectWebFrameResourceLoadFinished :: (GObject a, MonadIO m) =>
                                       a -> WebFrameResourceLoadFinishedCallback -> SignalConnectMode -> m SignalHandlerId
connectWebFrameResourceLoadFinished obj cb after = liftIO $ do
    let cb' = wrap_WebFrameResourceLoadFinishedCallback cb
    cb'' <- mk_WebFrameResourceLoadFinishedCallback cb'
    connectSignalFunPtr obj "resource-load-finished" cb'' after

-- signal WebFrame::resource-request-starting
type WebFrameResourceRequestStartingCallback =
    WebKit.WebResource.WebResource ->
    WebKit.NetworkRequest.NetworkRequest ->
    WebKit.NetworkResponse.NetworkResponse ->
    IO ()

noWebFrameResourceRequestStartingCallback :: Maybe WebFrameResourceRequestStartingCallback
noWebFrameResourceRequestStartingCallback = Nothing

type C_WebFrameResourceRequestStartingCallback =
    Ptr () ->                               -- object
    Ptr WebKit.WebResource.WebResource ->
    Ptr WebKit.NetworkRequest.NetworkRequest ->
    Ptr WebKit.NetworkResponse.NetworkResponse ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_WebFrameResourceRequestStartingCallback :: C_WebFrameResourceRequestStartingCallback -> IO (FunPtr C_WebFrameResourceRequestStartingCallback)

genClosure_WebFrameResourceRequestStarting :: WebFrameResourceRequestStartingCallback -> IO Closure
genClosure_WebFrameResourceRequestStarting cb = do
    let cb' = wrap_WebFrameResourceRequestStartingCallback cb
    mk_WebFrameResourceRequestStartingCallback cb' >>= newCClosure


wrap_WebFrameResourceRequestStartingCallback ::
    WebFrameResourceRequestStartingCallback ->
    Ptr () ->
    Ptr WebKit.WebResource.WebResource ->
    Ptr WebKit.NetworkRequest.NetworkRequest ->
    Ptr WebKit.NetworkResponse.NetworkResponse ->
    Ptr () ->
    IO ()
wrap_WebFrameResourceRequestStartingCallback _cb _ webResource request response _ = do
    webResource' <- (newObject WebKit.WebResource.WebResource) webResource
    request' <- (newObject WebKit.NetworkRequest.NetworkRequest) request
    response' <- (newObject WebKit.NetworkResponse.NetworkResponse) response
    _cb  webResource' request' response'


onWebFrameResourceRequestStarting :: (GObject a, MonadIO m) => a -> WebFrameResourceRequestStartingCallback -> m SignalHandlerId
onWebFrameResourceRequestStarting obj cb = liftIO $ connectWebFrameResourceRequestStarting obj cb SignalConnectBefore
afterWebFrameResourceRequestStarting :: (GObject a, MonadIO m) => a -> WebFrameResourceRequestStartingCallback -> m SignalHandlerId
afterWebFrameResourceRequestStarting obj cb = connectWebFrameResourceRequestStarting obj cb SignalConnectAfter

connectWebFrameResourceRequestStarting :: (GObject a, MonadIO m) =>
                                          a -> WebFrameResourceRequestStartingCallback -> SignalConnectMode -> m SignalHandlerId
connectWebFrameResourceRequestStarting obj cb after = liftIO $ do
    let cb' = wrap_WebFrameResourceRequestStartingCallback cb
    cb'' <- mk_WebFrameResourceRequestStartingCallback cb'
    connectSignalFunPtr obj "resource-request-starting" cb'' after

-- signal WebFrame::resource-response-received
type WebFrameResourceResponseReceivedCallback =
    WebKit.WebResource.WebResource ->
    WebKit.NetworkResponse.NetworkResponse ->
    IO ()

noWebFrameResourceResponseReceivedCallback :: Maybe WebFrameResourceResponseReceivedCallback
noWebFrameResourceResponseReceivedCallback = Nothing

type C_WebFrameResourceResponseReceivedCallback =
    Ptr () ->                               -- object
    Ptr WebKit.WebResource.WebResource ->
    Ptr WebKit.NetworkResponse.NetworkResponse ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_WebFrameResourceResponseReceivedCallback :: C_WebFrameResourceResponseReceivedCallback -> IO (FunPtr C_WebFrameResourceResponseReceivedCallback)

genClosure_WebFrameResourceResponseReceived :: WebFrameResourceResponseReceivedCallback -> IO Closure
genClosure_WebFrameResourceResponseReceived cb = do
    let cb' = wrap_WebFrameResourceResponseReceivedCallback cb
    mk_WebFrameResourceResponseReceivedCallback cb' >>= newCClosure


wrap_WebFrameResourceResponseReceivedCallback ::
    WebFrameResourceResponseReceivedCallback ->
    Ptr () ->
    Ptr WebKit.WebResource.WebResource ->
    Ptr WebKit.NetworkResponse.NetworkResponse ->
    Ptr () ->
    IO ()
wrap_WebFrameResourceResponseReceivedCallback _cb _ webResource response _ = do
    webResource' <- (newObject WebKit.WebResource.WebResource) webResource
    response' <- (newObject WebKit.NetworkResponse.NetworkResponse) response
    _cb  webResource' response'


onWebFrameResourceResponseReceived :: (GObject a, MonadIO m) => a -> WebFrameResourceResponseReceivedCallback -> m SignalHandlerId
onWebFrameResourceResponseReceived obj cb = liftIO $ connectWebFrameResourceResponseReceived obj cb SignalConnectBefore
afterWebFrameResourceResponseReceived :: (GObject a, MonadIO m) => a -> WebFrameResourceResponseReceivedCallback -> m SignalHandlerId
afterWebFrameResourceResponseReceived obj cb = connectWebFrameResourceResponseReceived obj cb SignalConnectAfter

connectWebFrameResourceResponseReceived :: (GObject a, MonadIO m) =>
                                           a -> WebFrameResourceResponseReceivedCallback -> SignalConnectMode -> m SignalHandlerId
connectWebFrameResourceResponseReceived obj cb after = liftIO $ do
    let cb' = wrap_WebFrameResourceResponseReceivedCallback cb
    cb'' <- mk_WebFrameResourceResponseReceivedCallback cb'
    connectSignalFunPtr obj "resource-response-received" cb'' after

-- signal WebFrame::scrollbars-policy-changed
type WebFrameScrollbarsPolicyChangedCallback =
    IO Bool

noWebFrameScrollbarsPolicyChangedCallback :: Maybe WebFrameScrollbarsPolicyChangedCallback
noWebFrameScrollbarsPolicyChangedCallback = Nothing

type C_WebFrameScrollbarsPolicyChangedCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_WebFrameScrollbarsPolicyChangedCallback :: C_WebFrameScrollbarsPolicyChangedCallback -> IO (FunPtr C_WebFrameScrollbarsPolicyChangedCallback)

genClosure_WebFrameScrollbarsPolicyChanged :: WebFrameScrollbarsPolicyChangedCallback -> IO Closure
genClosure_WebFrameScrollbarsPolicyChanged cb = do
    let cb' = wrap_WebFrameScrollbarsPolicyChangedCallback cb
    mk_WebFrameScrollbarsPolicyChangedCallback cb' >>= newCClosure


wrap_WebFrameScrollbarsPolicyChangedCallback ::
    WebFrameScrollbarsPolicyChangedCallback ->
    Ptr () ->
    Ptr () ->
    IO CInt
wrap_WebFrameScrollbarsPolicyChangedCallback _cb _ _ = do
    result <- _cb 
    let result' = (fromIntegral . fromEnum) result
    return result'


onWebFrameScrollbarsPolicyChanged :: (GObject a, MonadIO m) => a -> WebFrameScrollbarsPolicyChangedCallback -> m SignalHandlerId
onWebFrameScrollbarsPolicyChanged obj cb = liftIO $ connectWebFrameScrollbarsPolicyChanged obj cb SignalConnectBefore
afterWebFrameScrollbarsPolicyChanged :: (GObject a, MonadIO m) => a -> WebFrameScrollbarsPolicyChangedCallback -> m SignalHandlerId
afterWebFrameScrollbarsPolicyChanged obj cb = connectWebFrameScrollbarsPolicyChanged obj cb SignalConnectAfter

connectWebFrameScrollbarsPolicyChanged :: (GObject a, MonadIO m) =>
                                          a -> WebFrameScrollbarsPolicyChangedCallback -> SignalConnectMode -> m SignalHandlerId
connectWebFrameScrollbarsPolicyChanged obj cb after = liftIO $ do
    let cb' = wrap_WebFrameScrollbarsPolicyChangedCallback cb
    cb'' <- mk_WebFrameScrollbarsPolicyChangedCallback cb'
    connectSignalFunPtr obj "scrollbars-policy-changed" cb'' after

-- signal WebFrame::title-changed
{-# DEPRECATED WebFrameTitleChangedCallback ["(Since version 1.1.18)","Use \\\"notify::title\\\" instead."] #-}
type WebFrameTitleChangedCallback =
    T.Text ->
    IO ()

noWebFrameTitleChangedCallback :: Maybe WebFrameTitleChangedCallback
noWebFrameTitleChangedCallback = Nothing

type C_WebFrameTitleChangedCallback =
    Ptr () ->                               -- object
    CString ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_WebFrameTitleChangedCallback :: C_WebFrameTitleChangedCallback -> IO (FunPtr C_WebFrameTitleChangedCallback)

genClosure_WebFrameTitleChanged :: WebFrameTitleChangedCallback -> IO Closure
genClosure_WebFrameTitleChanged cb = do
    let cb' = wrap_WebFrameTitleChangedCallback cb
    mk_WebFrameTitleChangedCallback cb' >>= newCClosure


wrap_WebFrameTitleChangedCallback ::
    WebFrameTitleChangedCallback ->
    Ptr () ->
    CString ->
    Ptr () ->
    IO ()
wrap_WebFrameTitleChangedCallback _cb _ title _ = do
    title' <- cstringToText title
    _cb  title'


onWebFrameTitleChanged :: (GObject a, MonadIO m) => a -> WebFrameTitleChangedCallback -> m SignalHandlerId
onWebFrameTitleChanged obj cb = liftIO $ connectWebFrameTitleChanged obj cb SignalConnectBefore
afterWebFrameTitleChanged :: (GObject a, MonadIO m) => a -> WebFrameTitleChangedCallback -> m SignalHandlerId
afterWebFrameTitleChanged obj cb = connectWebFrameTitleChanged obj cb SignalConnectAfter

connectWebFrameTitleChanged :: (GObject a, MonadIO m) =>
                               a -> WebFrameTitleChangedCallback -> SignalConnectMode -> m SignalHandlerId
connectWebFrameTitleChanged obj cb after = liftIO $ do
    let cb' = wrap_WebFrameTitleChangedCallback cb
    cb'' <- mk_WebFrameTitleChangedCallback cb'
    connectSignalFunPtr obj "title-changed" cb'' after

-- VVV Prop "horizontal-scrollbar-policy"
   -- Type: TInterface (Name {namespace = "Gtk", name = "PolicyType"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

getWebFrameHorizontalScrollbarPolicy :: (MonadIO m, IsWebFrame o) => o -> m Gtk.Enums.PolicyType
getWebFrameHorizontalScrollbarPolicy obj = liftIO $ getObjectPropertyEnum obj "horizontal-scrollbar-policy"

data WebFrameHorizontalScrollbarPolicyPropertyInfo
instance AttrInfo WebFrameHorizontalScrollbarPolicyPropertyInfo where
    type AttrAllowedOps WebFrameHorizontalScrollbarPolicyPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint WebFrameHorizontalScrollbarPolicyPropertyInfo = (~) ()
    type AttrBaseTypeConstraint WebFrameHorizontalScrollbarPolicyPropertyInfo = IsWebFrame
    type AttrGetType WebFrameHorizontalScrollbarPolicyPropertyInfo = Gtk.Enums.PolicyType
    type AttrLabel WebFrameHorizontalScrollbarPolicyPropertyInfo = "horizontal-scrollbar-policy"
    type AttrOrigin WebFrameHorizontalScrollbarPolicyPropertyInfo = WebFrame
    attrGet _ = getWebFrameHorizontalScrollbarPolicy
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "load-status"
   -- Type: TInterface (Name {namespace = "WebKit", name = "LoadStatus"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

getWebFrameLoadStatus :: (MonadIO m, IsWebFrame o) => o -> m WebKit.Enums.LoadStatus
getWebFrameLoadStatus obj = liftIO $ getObjectPropertyEnum obj "load-status"

data WebFrameLoadStatusPropertyInfo
instance AttrInfo WebFrameLoadStatusPropertyInfo where
    type AttrAllowedOps WebFrameLoadStatusPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint WebFrameLoadStatusPropertyInfo = (~) ()
    type AttrBaseTypeConstraint WebFrameLoadStatusPropertyInfo = IsWebFrame
    type AttrGetType WebFrameLoadStatusPropertyInfo = WebKit.Enums.LoadStatus
    type AttrLabel WebFrameLoadStatusPropertyInfo = "load-status"
    type AttrOrigin WebFrameLoadStatusPropertyInfo = WebFrame
    attrGet _ = getWebFrameLoadStatus
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

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

getWebFrameName :: (MonadIO m, IsWebFrame o) => o -> m T.Text
getWebFrameName obj = liftIO $ checkUnexpectedNothing "getWebFrameName" $ getObjectPropertyString obj "name"

data WebFrameNamePropertyInfo
instance AttrInfo WebFrameNamePropertyInfo where
    type AttrAllowedOps WebFrameNamePropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WebFrameNamePropertyInfo = (~) ()
    type AttrBaseTypeConstraint WebFrameNamePropertyInfo = IsWebFrame
    type AttrGetType WebFrameNamePropertyInfo = T.Text
    type AttrLabel WebFrameNamePropertyInfo = "name"
    type AttrOrigin WebFrameNamePropertyInfo = WebFrame
    attrGet _ = getWebFrameName
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

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

getWebFrameTitle :: (MonadIO m, IsWebFrame o) => o -> m T.Text
getWebFrameTitle obj = liftIO $ checkUnexpectedNothing "getWebFrameTitle" $ getObjectPropertyString obj "title"

data WebFrameTitlePropertyInfo
instance AttrInfo WebFrameTitlePropertyInfo where
    type AttrAllowedOps WebFrameTitlePropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WebFrameTitlePropertyInfo = (~) ()
    type AttrBaseTypeConstraint WebFrameTitlePropertyInfo = IsWebFrame
    type AttrGetType WebFrameTitlePropertyInfo = T.Text
    type AttrLabel WebFrameTitlePropertyInfo = "title"
    type AttrOrigin WebFrameTitlePropertyInfo = WebFrame
    attrGet _ = getWebFrameTitle
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

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

getWebFrameUri :: (MonadIO m, IsWebFrame o) => o -> m T.Text
getWebFrameUri obj = liftIO $ checkUnexpectedNothing "getWebFrameUri" $ getObjectPropertyString obj "uri"

data WebFrameUriPropertyInfo
instance AttrInfo WebFrameUriPropertyInfo where
    type AttrAllowedOps WebFrameUriPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WebFrameUriPropertyInfo = (~) ()
    type AttrBaseTypeConstraint WebFrameUriPropertyInfo = IsWebFrame
    type AttrGetType WebFrameUriPropertyInfo = T.Text
    type AttrLabel WebFrameUriPropertyInfo = "uri"
    type AttrOrigin WebFrameUriPropertyInfo = WebFrame
    attrGet _ = getWebFrameUri
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "vertical-scrollbar-policy"
   -- Type: TInterface (Name {namespace = "Gtk", name = "PolicyType"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

getWebFrameVerticalScrollbarPolicy :: (MonadIO m, IsWebFrame o) => o -> m Gtk.Enums.PolicyType
getWebFrameVerticalScrollbarPolicy obj = liftIO $ getObjectPropertyEnum obj "vertical-scrollbar-policy"

data WebFrameVerticalScrollbarPolicyPropertyInfo
instance AttrInfo WebFrameVerticalScrollbarPolicyPropertyInfo where
    type AttrAllowedOps WebFrameVerticalScrollbarPolicyPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint WebFrameVerticalScrollbarPolicyPropertyInfo = (~) ()
    type AttrBaseTypeConstraint WebFrameVerticalScrollbarPolicyPropertyInfo = IsWebFrame
    type AttrGetType WebFrameVerticalScrollbarPolicyPropertyInfo = Gtk.Enums.PolicyType
    type AttrLabel WebFrameVerticalScrollbarPolicyPropertyInfo = "vertical-scrollbar-policy"
    type AttrOrigin WebFrameVerticalScrollbarPolicyPropertyInfo = WebFrame
    attrGet _ = getWebFrameVerticalScrollbarPolicy
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

instance O.HasAttributeList WebFrame
type instance O.AttributeList WebFrame = WebFrameAttributeList
type WebFrameAttributeList = ('[ '("horizontalScrollbarPolicy", WebFrameHorizontalScrollbarPolicyPropertyInfo), '("loadStatus", WebFrameLoadStatusPropertyInfo), '("name", WebFrameNamePropertyInfo), '("title", WebFrameTitlePropertyInfo), '("uri", WebFrameUriPropertyInfo), '("verticalScrollbarPolicy", WebFrameVerticalScrollbarPolicyPropertyInfo)] :: [(Symbol, *)])

webFrameHorizontalScrollbarPolicy :: AttrLabelProxy "horizontalScrollbarPolicy"
webFrameHorizontalScrollbarPolicy = AttrLabelProxy

webFrameLoadStatus :: AttrLabelProxy "loadStatus"
webFrameLoadStatus = AttrLabelProxy

webFrameName :: AttrLabelProxy "name"
webFrameName = AttrLabelProxy

webFrameTitle :: AttrLabelProxy "title"
webFrameTitle = AttrLabelProxy

webFrameUri :: AttrLabelProxy "uri"
webFrameUri = AttrLabelProxy

webFrameVerticalScrollbarPolicy :: AttrLabelProxy "verticalScrollbarPolicy"
webFrameVerticalScrollbarPolicy = AttrLabelProxy

data WebFrameClearedSignalInfo
instance SignalInfo WebFrameClearedSignalInfo where
    type HaskellCallbackType WebFrameClearedSignalInfo = WebFrameClearedCallback
    connectSignal _ = connectWebFrameCleared

data WebFrameHoveringOverLinkSignalInfo
instance SignalInfo WebFrameHoveringOverLinkSignalInfo where
    type HaskellCallbackType WebFrameHoveringOverLinkSignalInfo = WebFrameHoveringOverLinkCallback
    connectSignal _ = connectWebFrameHoveringOverLink

data WebFrameInsecureContentRunSignalInfo
instance SignalInfo WebFrameInsecureContentRunSignalInfo where
    type HaskellCallbackType WebFrameInsecureContentRunSignalInfo = WebFrameInsecureContentRunCallback
    connectSignal _ = connectWebFrameInsecureContentRun

data WebFrameLoadCommittedSignalInfo
instance SignalInfo WebFrameLoadCommittedSignalInfo where
    type HaskellCallbackType WebFrameLoadCommittedSignalInfo = WebFrameLoadCommittedCallback
    connectSignal _ = connectWebFrameLoadCommitted

data WebFrameResourceContentLengthReceivedSignalInfo
instance SignalInfo WebFrameResourceContentLengthReceivedSignalInfo where
    type HaskellCallbackType WebFrameResourceContentLengthReceivedSignalInfo = WebFrameResourceContentLengthReceivedCallback
    connectSignal _ = connectWebFrameResourceContentLengthReceived

data WebFrameResourceLoadFailedSignalInfo
instance SignalInfo WebFrameResourceLoadFailedSignalInfo where
    type HaskellCallbackType WebFrameResourceLoadFailedSignalInfo = WebFrameResourceLoadFailedCallback
    connectSignal _ = connectWebFrameResourceLoadFailed

data WebFrameResourceLoadFinishedSignalInfo
instance SignalInfo WebFrameResourceLoadFinishedSignalInfo where
    type HaskellCallbackType WebFrameResourceLoadFinishedSignalInfo = WebFrameResourceLoadFinishedCallback
    connectSignal _ = connectWebFrameResourceLoadFinished

data WebFrameResourceRequestStartingSignalInfo
instance SignalInfo WebFrameResourceRequestStartingSignalInfo where
    type HaskellCallbackType WebFrameResourceRequestStartingSignalInfo = WebFrameResourceRequestStartingCallback
    connectSignal _ = connectWebFrameResourceRequestStarting

data WebFrameResourceResponseReceivedSignalInfo
instance SignalInfo WebFrameResourceResponseReceivedSignalInfo where
    type HaskellCallbackType WebFrameResourceResponseReceivedSignalInfo = WebFrameResourceResponseReceivedCallback
    connectSignal _ = connectWebFrameResourceResponseReceived

data WebFrameScrollbarsPolicyChangedSignalInfo
instance SignalInfo WebFrameScrollbarsPolicyChangedSignalInfo where
    type HaskellCallbackType WebFrameScrollbarsPolicyChangedSignalInfo = WebFrameScrollbarsPolicyChangedCallback
    connectSignal _ = connectWebFrameScrollbarsPolicyChanged

data WebFrameTitleChangedSignalInfo
instance SignalInfo WebFrameTitleChangedSignalInfo where
    type HaskellCallbackType WebFrameTitleChangedSignalInfo = WebFrameTitleChangedCallback
    connectSignal _ = connectWebFrameTitleChanged

type instance O.SignalList WebFrame = WebFrameSignalList
type WebFrameSignalList = ('[ '("cleared", WebFrameClearedSignalInfo), '("hoveringOverLink", WebFrameHoveringOverLinkSignalInfo), '("insecureContentRun", WebFrameInsecureContentRunSignalInfo), '("loadCommitted", WebFrameLoadCommittedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("resourceContentLengthReceived", WebFrameResourceContentLengthReceivedSignalInfo), '("resourceLoadFailed", WebFrameResourceLoadFailedSignalInfo), '("resourceLoadFinished", WebFrameResourceLoadFinishedSignalInfo), '("resourceRequestStarting", WebFrameResourceRequestStartingSignalInfo), '("resourceResponseReceived", WebFrameResourceResponseReceivedSignalInfo), '("scrollbarsPolicyChanged", WebFrameScrollbarsPolicyChangedSignalInfo), '("titleChanged", WebFrameTitleChangedSignalInfo)] :: [(Symbol, *)])

-- method WebFrame::new
-- method type : Constructor
-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the controlling #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "WebFrame"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_frame_new" webkit_web_frame_new :: 
    Ptr WebKit.WebView.WebView ->           -- web_view : TInterface (Name {namespace = "WebKit", name = "WebView"})
    IO (Ptr WebFrame)

{-# DEPRECATED webFrameNew ["(Since version 1.0.2)","'GI.WebKit.Objects.WebFrame.WebFrame' can only be used to inspect existing","frames."] #-}
{- |
Creates a new 'GI.WebKit.Objects.WebFrame.WebFrame' initialized with a controlling 'GI.WebKit.Objects.WebView.WebView'.
-}
webFrameNew ::
    (B.CallStack.HasCallStack, MonadIO m, WebKit.WebView.IsWebView a) =>
    a
    {- ^ /@webView@/: the controlling 'GI.WebKit.Objects.WebView.WebView' -}
    -> m WebFrame
    {- ^ __Returns:__ a new 'GI.WebKit.Objects.WebFrame.WebFrame' -}
webFrameNew webView = liftIO $ do
    webView' <- unsafeManagedPtrCastPtr webView
    result <- webkit_web_frame_new webView'
    checkUnexpectedReturnNULL "webFrameNew" result
    result' <- (wrapObject WebFrame) result
    touchManagedPtr webView
    return result'

-- method WebFrame::find_frame
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "frame", argType = TInterface (Name {namespace = "WebKit", name = "WebFrame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebFrame", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the frame to be found", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "WebFrame"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_frame_find_frame" webkit_web_frame_find_frame :: 
    Ptr WebFrame ->                         -- frame : TInterface (Name {namespace = "WebKit", name = "WebFrame"})
    CString ->                              -- name : TBasicType TUTF8
    IO (Ptr WebFrame)

{- |
For pre-defined names, returns /@frame@/ if /@name@/ is \"_self\" or \"_current\",
returns /@frame@/\'s parent frame if /@name@/ is \"_parent\", and returns the main
frame if /@name@/ is \"_top\". Also returns /@frame@/ if it is the main frame and
/@name@/ is either \"_parent\" or \"_top\". For other names, this function returns
the first frame that matches /@name@/. This function searches /@frame@/ and its
descendents first, then /@frame@/\'s parent and its children moving up the
hierarchy until a match is found. If no match is found in /@frame@/\'s
hierarchy, this function will search for a matching frame in other main
frame hierarchies. Returns 'Nothing' if no match is found.
-}
webFrameFindFrame ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebFrame a) =>
    a
    {- ^ /@frame@/: a 'GI.WebKit.Objects.WebFrame.WebFrame' -}
    -> T.Text
    {- ^ /@name@/: the name of the frame to be found -}
    -> m WebFrame
    {- ^ __Returns:__ the found 'GI.WebKit.Objects.WebFrame.WebFrame' or 'Nothing' in case none is found -}
webFrameFindFrame frame name = liftIO $ do
    frame' <- unsafeManagedPtrCastPtr frame
    name' <- textToCString name
    result <- webkit_web_frame_find_frame frame' name'
    checkUnexpectedReturnNULL "webFrameFindFrame" result
    result' <- (newObject WebFrame) result
    touchManagedPtr frame
    freeMem name'
    return result'

data WebFrameFindFrameMethodInfo
instance (signature ~ (T.Text -> m WebFrame), MonadIO m, IsWebFrame a) => O.MethodInfo WebFrameFindFrameMethodInfo a signature where
    overloadedMethod _ = webFrameFindFrame

-- method WebFrame::get_data_source
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "frame", argType = TInterface (Name {namespace = "WebKit", name = "WebFrame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebFrame", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "WebDataSource"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_frame_get_data_source" webkit_web_frame_get_data_source :: 
    Ptr WebFrame ->                         -- frame : TInterface (Name {namespace = "WebKit", name = "WebFrame"})
    IO (Ptr WebKit.WebDataSource.WebDataSource)

{- |
Returns the committed data source.

@since 1.1.14
-}
webFrameGetDataSource ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebFrame a) =>
    a
    {- ^ /@frame@/: a 'GI.WebKit.Objects.WebFrame.WebFrame' -}
    -> m WebKit.WebDataSource.WebDataSource
    {- ^ __Returns:__ the committed 'GI.WebKit.Objects.WebDataSource.WebDataSource'. -}
webFrameGetDataSource frame = liftIO $ do
    frame' <- unsafeManagedPtrCastPtr frame
    result <- webkit_web_frame_get_data_source frame'
    checkUnexpectedReturnNULL "webFrameGetDataSource" result
    result' <- (newObject WebKit.WebDataSource.WebDataSource) result
    touchManagedPtr frame
    return result'

data WebFrameGetDataSourceMethodInfo
instance (signature ~ (m WebKit.WebDataSource.WebDataSource), MonadIO m, IsWebFrame a) => O.MethodInfo WebFrameGetDataSourceMethodInfo a signature where
    overloadedMethod _ = webFrameGetDataSource

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

foreign import ccall "webkit_web_frame_get_dom_document" webkit_web_frame_get_dom_document :: 
    Ptr WebFrame ->                         -- frame : TInterface (Name {namespace = "WebKit", name = "WebFrame"})
    IO (Ptr WebKit.DOMDocument.DOMDocument)

{- |
/No description available in the introspection data./

@since 1.10
-}
webFrameGetDomDocument ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebFrame a) =>
    a
    {- ^ /@frame@/: a 'GI.WebKit.Objects.WebFrame.WebFrame' -}
    -> m WebKit.DOMDocument.DOMDocument
    {- ^ __Returns:__ the 'GI.WebKit.Objects.DOMDocument.DOMDocument' currently loaded
in the /@frame@/ or 'Nothing' if no document is loaded -}
webFrameGetDomDocument frame = liftIO $ do
    frame' <- unsafeManagedPtrCastPtr frame
    result <- webkit_web_frame_get_dom_document frame'
    checkUnexpectedReturnNULL "webFrameGetDomDocument" result
    result' <- (newObject WebKit.DOMDocument.DOMDocument) result
    touchManagedPtr frame
    return result'

data WebFrameGetDomDocumentMethodInfo
instance (signature ~ (m WebKit.DOMDocument.DOMDocument), MonadIO m, IsWebFrame a) => O.MethodInfo WebFrameGetDomDocumentMethodInfo a signature where
    overloadedMethod _ = webFrameGetDomDocument

-- method WebFrame::get_global_context
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "frame", argType = TInterface (Name {namespace = "WebKit", name = "WebFrame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebFrame", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "GlobalContext"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_frame_get_global_context" webkit_web_frame_get_global_context :: 
    Ptr WebFrame ->                         -- frame : TInterface (Name {namespace = "WebKit", name = "WebFrame"})
    IO (Ptr JavaScriptCore.GlobalContext.GlobalContext)

{- |
Gets the global JavaScript execution context. Use this function to bridge
between the WebKit and JavaScriptCore APIs.
-}
webFrameGetGlobalContext ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebFrame a) =>
    a
    {- ^ /@frame@/: a 'GI.WebKit.Objects.WebFrame.WebFrame' -}
    -> m JavaScriptCore.GlobalContext.GlobalContext
    {- ^ __Returns:__ the global JavaScript context 'GI.JavaScriptCore.Structs.GlobalContext.GlobalContext' -}
webFrameGetGlobalContext frame = liftIO $ do
    frame' <- unsafeManagedPtrCastPtr frame
    result <- webkit_web_frame_get_global_context frame'
    checkUnexpectedReturnNULL "webFrameGetGlobalContext" result
    result' <- (newPtr JavaScriptCore.GlobalContext.GlobalContext) result
    touchManagedPtr frame
    return result'

data WebFrameGetGlobalContextMethodInfo
instance (signature ~ (m JavaScriptCore.GlobalContext.GlobalContext), MonadIO m, IsWebFrame a) => O.MethodInfo WebFrameGetGlobalContextMethodInfo a signature where
    overloadedMethod _ = webFrameGetGlobalContext

-- method WebFrame::get_horizontal_scrollbar_policy
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "frame", argType = TInterface (Name {namespace = "WebKit", name = "WebFrame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "PolicyType"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_frame_get_horizontal_scrollbar_policy" webkit_web_frame_get_horizontal_scrollbar_policy :: 
    Ptr WebFrame ->                         -- frame : TInterface (Name {namespace = "WebKit", name = "WebFrame"})
    IO CUInt

{- |
/No description available in the introspection data./
-}
webFrameGetHorizontalScrollbarPolicy ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebFrame a) =>
    a
    -> m Gtk.Enums.PolicyType
webFrameGetHorizontalScrollbarPolicy frame = liftIO $ do
    frame' <- unsafeManagedPtrCastPtr frame
    result <- webkit_web_frame_get_horizontal_scrollbar_policy frame'
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr frame
    return result'

data WebFrameGetHorizontalScrollbarPolicyMethodInfo
instance (signature ~ (m Gtk.Enums.PolicyType), MonadIO m, IsWebFrame a) => O.MethodInfo WebFrameGetHorizontalScrollbarPolicyMethodInfo a signature where
    overloadedMethod _ = webFrameGetHorizontalScrollbarPolicy

-- method WebFrame::get_load_status
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "frame", argType = TInterface (Name {namespace = "WebKit", name = "WebFrame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "LoadStatus"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_frame_get_load_status" webkit_web_frame_get_load_status :: 
    Ptr WebFrame ->                         -- frame : TInterface (Name {namespace = "WebKit", name = "WebFrame"})
    IO CUInt

{- |
Determines the current status of the load.

@since 1.1.7
-}
webFrameGetLoadStatus ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebFrame a) =>
    a
    {- ^ /@frame@/: a 'GI.WebKit.Objects.WebView.WebView' -}
    -> m WebKit.Enums.LoadStatus
    {- ^ __Returns:__ The 'GI.WebKit.Enums.LoadStatus' specifying the status of the current load. -}
webFrameGetLoadStatus frame = liftIO $ do
    frame' <- unsafeManagedPtrCastPtr frame
    result <- webkit_web_frame_get_load_status frame'
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr frame
    return result'

data WebFrameGetLoadStatusMethodInfo
instance (signature ~ (m WebKit.Enums.LoadStatus), MonadIO m, IsWebFrame a) => O.MethodInfo WebFrameGetLoadStatusMethodInfo a signature where
    overloadedMethod _ = webFrameGetLoadStatus

-- method WebFrame::get_name
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "frame", argType = TInterface (Name {namespace = "WebKit", name = "WebFrame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebFrame", 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_frame_get_name" webkit_web_frame_get_name :: 
    Ptr WebFrame ->                         -- frame : TInterface (Name {namespace = "WebKit", name = "WebFrame"})
    IO CString

{- |
Returns the /@frame@/\'s name
-}
webFrameGetName ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebFrame a) =>
    a
    {- ^ /@frame@/: a 'GI.WebKit.Objects.WebFrame.WebFrame' -}
    -> m T.Text
    {- ^ __Returns:__ the name of /@frame@/. This method will return NULL if
the 'GI.WebKit.Objects.WebFrame.WebFrame' is invalid or an empty string if it is not backed
by a live WebCore frame. -}
webFrameGetName frame = liftIO $ do
    frame' <- unsafeManagedPtrCastPtr frame
    result <- webkit_web_frame_get_name frame'
    checkUnexpectedReturnNULL "webFrameGetName" result
    result' <- cstringToText result
    touchManagedPtr frame
    return result'

data WebFrameGetNameMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsWebFrame a) => O.MethodInfo WebFrameGetNameMethodInfo a signature where
    overloadedMethod _ = webFrameGetName

-- method WebFrame::get_network_response
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "frame", argType = TInterface (Name {namespace = "WebKit", name = "WebFrame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebFrame", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "NetworkResponse"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_frame_get_network_response" webkit_web_frame_get_network_response :: 
    Ptr WebFrame ->                         -- frame : TInterface (Name {namespace = "WebKit", name = "WebFrame"})
    IO (Ptr WebKit.NetworkResponse.NetworkResponse)

{- |
Returns a 'GI.WebKit.Objects.NetworkResponse.NetworkResponse' object representing the response
that was given to the request for the given frame, or NULL if the
frame was not created by a load. You must unref the object when you
are done with it.

@since 1.1.18
-}
webFrameGetNetworkResponse ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebFrame a) =>
    a
    {- ^ /@frame@/: a 'GI.WebKit.Objects.WebFrame.WebFrame' -}
    -> m WebKit.NetworkResponse.NetworkResponse
    {- ^ __Returns:__ a 'GI.WebKit.Objects.NetworkResponse.NetworkResponse' object -}
webFrameGetNetworkResponse frame = liftIO $ do
    frame' <- unsafeManagedPtrCastPtr frame
    result <- webkit_web_frame_get_network_response frame'
    checkUnexpectedReturnNULL "webFrameGetNetworkResponse" result
    result' <- (wrapObject WebKit.NetworkResponse.NetworkResponse) result
    touchManagedPtr frame
    return result'

data WebFrameGetNetworkResponseMethodInfo
instance (signature ~ (m WebKit.NetworkResponse.NetworkResponse), MonadIO m, IsWebFrame a) => O.MethodInfo WebFrameGetNetworkResponseMethodInfo a signature where
    overloadedMethod _ = webFrameGetNetworkResponse

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

foreign import ccall "webkit_web_frame_get_parent" webkit_web_frame_get_parent :: 
    Ptr WebFrame ->                         -- frame : TInterface (Name {namespace = "WebKit", name = "WebFrame"})
    IO (Ptr WebFrame)

{- |
Returns the /@frame@/\'s parent frame, or 'Nothing' if it has none.
-}
webFrameGetParent ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebFrame a) =>
    a
    {- ^ /@frame@/: a 'GI.WebKit.Objects.WebFrame.WebFrame' -}
    -> m WebFrame
    {- ^ __Returns:__ the parent 'GI.WebKit.Objects.WebFrame.WebFrame' or 'Nothing' in case there is none -}
webFrameGetParent frame = liftIO $ do
    frame' <- unsafeManagedPtrCastPtr frame
    result <- webkit_web_frame_get_parent frame'
    checkUnexpectedReturnNULL "webFrameGetParent" result
    result' <- (newObject WebFrame) result
    touchManagedPtr frame
    return result'

data WebFrameGetParentMethodInfo
instance (signature ~ (m WebFrame), MonadIO m, IsWebFrame a) => O.MethodInfo WebFrameGetParentMethodInfo a signature where
    overloadedMethod _ = webFrameGetParent

-- method WebFrame::get_provisional_data_source
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "frame", argType = TInterface (Name {namespace = "WebKit", name = "WebFrame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebFrame", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "WebDataSource"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_frame_get_provisional_data_source" webkit_web_frame_get_provisional_data_source :: 
    Ptr WebFrame ->                         -- frame : TInterface (Name {namespace = "WebKit", name = "WebFrame"})
    IO (Ptr WebKit.WebDataSource.WebDataSource)

{- |
You use the webkit_web_frame_load_request method to initiate a request that
creates a provisional data source. The provisional data source will
transition to a committed data source once any data has been received. Use
webkit_web_frame_get_data_source to get the committed data source.

@since 1.1.14
-}
webFrameGetProvisionalDataSource ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebFrame a) =>
    a
    {- ^ /@frame@/: a 'GI.WebKit.Objects.WebFrame.WebFrame' -}
    -> m WebKit.WebDataSource.WebDataSource
    {- ^ __Returns:__ the provisional 'GI.WebKit.Objects.WebDataSource.WebDataSource' or 'Nothing' if a load
request is not in progress. -}
webFrameGetProvisionalDataSource frame = liftIO $ do
    frame' <- unsafeManagedPtrCastPtr frame
    result <- webkit_web_frame_get_provisional_data_source frame'
    checkUnexpectedReturnNULL "webFrameGetProvisionalDataSource" result
    result' <- (newObject WebKit.WebDataSource.WebDataSource) result
    touchManagedPtr frame
    return result'

data WebFrameGetProvisionalDataSourceMethodInfo
instance (signature ~ (m WebKit.WebDataSource.WebDataSource), MonadIO m, IsWebFrame a) => O.MethodInfo WebFrameGetProvisionalDataSourceMethodInfo a signature where
    overloadedMethod _ = webFrameGetProvisionalDataSource

-- method WebFrame::get_range_for_word_around_caret
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "frame", argType = TInterface (Name {namespace = "WebKit", name = "WebFrame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebFrame", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "DOMRange"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_frame_get_range_for_word_around_caret" webkit_web_frame_get_range_for_word_around_caret :: 
    Ptr WebFrame ->                         -- frame : TInterface (Name {namespace = "WebKit", name = "WebFrame"})
    IO (Ptr WebKit.DOMRange.DOMRange)

{- |
Returns a 'GI.WebKit.Objects.DOMRange.DOMRange' for the word where the caret is currently
positioned.

@since 1.5.1.
-}
webFrameGetRangeForWordAroundCaret ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebFrame a) =>
    a
    {- ^ /@frame@/: a 'GI.WebKit.Objects.WebFrame.WebFrame' -}
    -> m WebKit.DOMRange.DOMRange
    {- ^ __Returns:__ a 'GI.WebKit.Objects.DOMRange.DOMRange' spanning the word where the caret
currently is positioned. If there is no caret 'Nothing' will be
returned. -}
webFrameGetRangeForWordAroundCaret frame = liftIO $ do
    frame' <- unsafeManagedPtrCastPtr frame
    result <- webkit_web_frame_get_range_for_word_around_caret frame'
    checkUnexpectedReturnNULL "webFrameGetRangeForWordAroundCaret" result
    result' <- (newObject WebKit.DOMRange.DOMRange) result
    touchManagedPtr frame
    return result'

data WebFrameGetRangeForWordAroundCaretMethodInfo
instance (signature ~ (m WebKit.DOMRange.DOMRange), MonadIO m, IsWebFrame a) => O.MethodInfo WebFrameGetRangeForWordAroundCaretMethodInfo a signature where
    overloadedMethod _ = webFrameGetRangeForWordAroundCaret

-- method WebFrame::get_security_origin
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "frame", argType = TInterface (Name {namespace = "WebKit", name = "WebFrame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebFrame", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "SecurityOrigin"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_frame_get_security_origin" webkit_web_frame_get_security_origin :: 
    Ptr WebFrame ->                         -- frame : TInterface (Name {namespace = "WebKit", name = "WebFrame"})
    IO (Ptr WebKit.SecurityOrigin.SecurityOrigin)

{- |
Returns the /@frame@/\'s security origin.

@since 1.1.14
-}
webFrameGetSecurityOrigin ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebFrame a) =>
    a
    {- ^ /@frame@/: a 'GI.WebKit.Objects.WebFrame.WebFrame' -}
    -> m WebKit.SecurityOrigin.SecurityOrigin
    {- ^ __Returns:__ the security origin of /@frame@/ -}
webFrameGetSecurityOrigin frame = liftIO $ do
    frame' <- unsafeManagedPtrCastPtr frame
    result <- webkit_web_frame_get_security_origin frame'
    checkUnexpectedReturnNULL "webFrameGetSecurityOrigin" result
    result' <- (newObject WebKit.SecurityOrigin.SecurityOrigin) result
    touchManagedPtr frame
    return result'

data WebFrameGetSecurityOriginMethodInfo
instance (signature ~ (m WebKit.SecurityOrigin.SecurityOrigin), MonadIO m, IsWebFrame a) => O.MethodInfo WebFrameGetSecurityOriginMethodInfo a signature where
    overloadedMethod _ = webFrameGetSecurityOrigin

-- method WebFrame::get_title
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "frame", argType = TInterface (Name {namespace = "WebKit", name = "WebFrame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebFrame", 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_frame_get_title" webkit_web_frame_get_title :: 
    Ptr WebFrame ->                         -- frame : TInterface (Name {namespace = "WebKit", name = "WebFrame"})
    IO CString

{- |
Returns the /@frame@/\'s document title
-}
webFrameGetTitle ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebFrame a) =>
    a
    {- ^ /@frame@/: a 'GI.WebKit.Objects.WebFrame.WebFrame' -}
    -> m T.Text
    {- ^ __Returns:__ the title of /@frame@/ -}
webFrameGetTitle frame = liftIO $ do
    frame' <- unsafeManagedPtrCastPtr frame
    result <- webkit_web_frame_get_title frame'
    checkUnexpectedReturnNULL "webFrameGetTitle" result
    result' <- cstringToText result
    touchManagedPtr frame
    return result'

data WebFrameGetTitleMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsWebFrame a) => O.MethodInfo WebFrameGetTitleMethodInfo a signature where
    overloadedMethod _ = webFrameGetTitle

-- method WebFrame::get_uri
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "frame", argType = TInterface (Name {namespace = "WebKit", name = "WebFrame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebFrame", 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_frame_get_uri" webkit_web_frame_get_uri :: 
    Ptr WebFrame ->                         -- frame : TInterface (Name {namespace = "WebKit", name = "WebFrame"})
    IO CString

{- |
Returns the current URI of the contents displayed by the /@frame@/
-}
webFrameGetUri ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebFrame a) =>
    a
    {- ^ /@frame@/: a 'GI.WebKit.Objects.WebFrame.WebFrame' -}
    -> m T.Text
    {- ^ __Returns:__ the URI of /@frame@/ -}
webFrameGetUri frame = liftIO $ do
    frame' <- unsafeManagedPtrCastPtr frame
    result <- webkit_web_frame_get_uri frame'
    checkUnexpectedReturnNULL "webFrameGetUri" result
    result' <- cstringToText result
    touchManagedPtr frame
    return result'

data WebFrameGetUriMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsWebFrame a) => O.MethodInfo WebFrameGetUriMethodInfo a signature where
    overloadedMethod _ = webFrameGetUri

-- method WebFrame::get_vertical_scrollbar_policy
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "frame", argType = TInterface (Name {namespace = "WebKit", name = "WebFrame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "PolicyType"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_frame_get_vertical_scrollbar_policy" webkit_web_frame_get_vertical_scrollbar_policy :: 
    Ptr WebFrame ->                         -- frame : TInterface (Name {namespace = "WebKit", name = "WebFrame"})
    IO CUInt

{- |
/No description available in the introspection data./
-}
webFrameGetVerticalScrollbarPolicy ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebFrame a) =>
    a
    -> m Gtk.Enums.PolicyType
webFrameGetVerticalScrollbarPolicy frame = liftIO $ do
    frame' <- unsafeManagedPtrCastPtr frame
    result <- webkit_web_frame_get_vertical_scrollbar_policy frame'
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr frame
    return result'

data WebFrameGetVerticalScrollbarPolicyMethodInfo
instance (signature ~ (m Gtk.Enums.PolicyType), MonadIO m, IsWebFrame a) => O.MethodInfo WebFrameGetVerticalScrollbarPolicyMethodInfo a signature where
    overloadedMethod _ = webFrameGetVerticalScrollbarPolicy

-- method WebFrame::get_web_view
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "frame", argType = TInterface (Name {namespace = "WebKit", name = "WebFrame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebFrame", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "WebView"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_frame_get_web_view" webkit_web_frame_get_web_view :: 
    Ptr WebFrame ->                         -- frame : TInterface (Name {namespace = "WebKit", name = "WebFrame"})
    IO (Ptr WebKit.WebView.WebView)

{- |
Returns the 'GI.WebKit.Objects.WebView.WebView' that manages this 'GI.WebKit.Objects.WebFrame.WebFrame'.

The 'GI.WebKit.Objects.WebView.WebView' returned manages the entire hierarchy of 'GI.WebKit.Objects.WebFrame.WebFrame'
objects that contains /@frame@/.
-}
webFrameGetWebView ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebFrame a) =>
    a
    {- ^ /@frame@/: a 'GI.WebKit.Objects.WebFrame.WebFrame' -}
    -> m WebKit.WebView.WebView
    {- ^ __Returns:__ the 'GI.WebKit.Objects.WebView.WebView' that manages /@frame@/ -}
webFrameGetWebView frame = liftIO $ do
    frame' <- unsafeManagedPtrCastPtr frame
    result <- webkit_web_frame_get_web_view frame'
    checkUnexpectedReturnNULL "webFrameGetWebView" result
    result' <- (newObject WebKit.WebView.WebView) result
    touchManagedPtr frame
    return result'

data WebFrameGetWebViewMethodInfo
instance (signature ~ (m WebKit.WebView.WebView), MonadIO m, IsWebFrame a) => O.MethodInfo WebFrameGetWebViewMethodInfo a signature where
    overloadedMethod _ = webFrameGetWebView

-- method WebFrame::load_alternate_string
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "frame", argType = TInterface (Name {namespace = "WebKit", name = "WebFrame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebFrame", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "content", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the alternate content to display as the main page of the @frame", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "base_url", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the base URI for relative locations", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "unreachable_url", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the URL for the alternate page content", 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_frame_load_alternate_string" webkit_web_frame_load_alternate_string :: 
    Ptr WebFrame ->                         -- frame : TInterface (Name {namespace = "WebKit", name = "WebFrame"})
    CString ->                              -- content : TBasicType TUTF8
    CString ->                              -- base_url : TBasicType TUTF8
    CString ->                              -- unreachable_url : TBasicType TUTF8
    IO ()

{- |
Request loading of an alternate content for a URL that is unreachable.
Using this method will preserve the back-forward list. The URI passed in
/@baseUrl@/ has to be an absolute URI.

@since 1.1.6
-}
webFrameLoadAlternateString ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebFrame a) =>
    a
    {- ^ /@frame@/: a 'GI.WebKit.Objects.WebFrame.WebFrame' -}
    -> T.Text
    {- ^ /@content@/: the alternate content to display as the main page of the /@frame@/ -}
    -> T.Text
    {- ^ /@baseUrl@/: the base URI for relative locations -}
    -> T.Text
    {- ^ /@unreachableUrl@/: the URL for the alternate page content -}
    -> m ()
webFrameLoadAlternateString frame content baseUrl unreachableUrl = liftIO $ do
    frame' <- unsafeManagedPtrCastPtr frame
    content' <- textToCString content
    baseUrl' <- textToCString baseUrl
    unreachableUrl' <- textToCString unreachableUrl
    webkit_web_frame_load_alternate_string frame' content' baseUrl' unreachableUrl'
    touchManagedPtr frame
    freeMem content'
    freeMem baseUrl'
    freeMem unreachableUrl'
    return ()

data WebFrameLoadAlternateStringMethodInfo
instance (signature ~ (T.Text -> T.Text -> T.Text -> m ()), MonadIO m, IsWebFrame a) => O.MethodInfo WebFrameLoadAlternateStringMethodInfo a signature where
    overloadedMethod _ = webFrameLoadAlternateString

-- method WebFrame::load_request
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "frame", argType = TInterface (Name {namespace = "WebKit", name = "WebFrame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebFrame", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "request", argType = TInterface (Name {namespace = "WebKit", name = "NetworkRequest"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitNetworkRequest", 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_frame_load_request" webkit_web_frame_load_request :: 
    Ptr WebFrame ->                         -- frame : TInterface (Name {namespace = "WebKit", name = "WebFrame"})
    Ptr WebKit.NetworkRequest.NetworkRequest -> -- request : TInterface (Name {namespace = "WebKit", name = "NetworkRequest"})
    IO ()

{- |
Connects to a given URI by initiating an asynchronous client request.

Creates a provisional data source that will transition to a committed data
source once any data has been received. Use 'GI.WebKit.Objects.WebFrame.webFrameStopLoading' to
stop the load. This function is typically invoked on the main frame.
-}
webFrameLoadRequest ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebFrame a, WebKit.NetworkRequest.IsNetworkRequest b) =>
    a
    {- ^ /@frame@/: a 'GI.WebKit.Objects.WebFrame.WebFrame' -}
    -> b
    {- ^ /@request@/: a 'GI.WebKit.Objects.NetworkRequest.NetworkRequest' -}
    -> m ()
webFrameLoadRequest frame request = liftIO $ do
    frame' <- unsafeManagedPtrCastPtr frame
    request' <- unsafeManagedPtrCastPtr request
    webkit_web_frame_load_request frame' request'
    touchManagedPtr frame
    touchManagedPtr request
    return ()

data WebFrameLoadRequestMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsWebFrame a, WebKit.NetworkRequest.IsNetworkRequest b) => O.MethodInfo WebFrameLoadRequestMethodInfo a signature where
    overloadedMethod _ = webFrameLoadRequest

-- method WebFrame::load_string
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "frame", argType = TInterface (Name {namespace = "WebKit", name = "WebFrame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebFrame", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "content", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an URI string", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mime_type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the MIME type, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "encoding", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the encoding, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "base_uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the base URI for relative locations", 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_frame_load_string" webkit_web_frame_load_string :: 
    Ptr WebFrame ->                         -- frame : TInterface (Name {namespace = "WebKit", name = "WebFrame"})
    CString ->                              -- content : TBasicType TUTF8
    CString ->                              -- mime_type : TBasicType TUTF8
    CString ->                              -- encoding : TBasicType TUTF8
    CString ->                              -- base_uri : TBasicType TUTF8
    IO ()

{- |
Requests loading of the given /@content@/ with the specified /@mimeType@/,
/@encoding@/ and /@baseUri@/.

If /@mimeType@/ is 'Nothing', \"text\/html\" is assumed.

If /@encoding@/ is 'Nothing', \"UTF-8\" is assumed.

@since 1.1.1
-}
webFrameLoadString ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebFrame a) =>
    a
    {- ^ /@frame@/: a 'GI.WebKit.Objects.WebFrame.WebFrame' -}
    -> T.Text
    {- ^ /@content@/: an URI string -}
    -> T.Text
    {- ^ /@mimeType@/: the MIME type, or 'Nothing' -}
    -> T.Text
    {- ^ /@encoding@/: the encoding, or 'Nothing' -}
    -> T.Text
    {- ^ /@baseUri@/: the base URI for relative locations -}
    -> m ()
webFrameLoadString frame content mimeType encoding baseUri = liftIO $ do
    frame' <- unsafeManagedPtrCastPtr frame
    content' <- textToCString content
    mimeType' <- textToCString mimeType
    encoding' <- textToCString encoding
    baseUri' <- textToCString baseUri
    webkit_web_frame_load_string frame' content' mimeType' encoding' baseUri'
    touchManagedPtr frame
    freeMem content'
    freeMem mimeType'
    freeMem encoding'
    freeMem baseUri'
    return ()

data WebFrameLoadStringMethodInfo
instance (signature ~ (T.Text -> T.Text -> T.Text -> T.Text -> m ()), MonadIO m, IsWebFrame a) => O.MethodInfo WebFrameLoadStringMethodInfo a signature where
    overloadedMethod _ = webFrameLoadString

-- method WebFrame::load_uri
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "frame", argType = TInterface (Name {namespace = "WebKit", name = "WebFrame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebFrame", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an URI string", 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_frame_load_uri" webkit_web_frame_load_uri :: 
    Ptr WebFrame ->                         -- frame : TInterface (Name {namespace = "WebKit", name = "WebFrame"})
    CString ->                              -- uri : TBasicType TUTF8
    IO ()

{- |
Requests loading of the specified URI string.

@since 1.1.1
-}
webFrameLoadUri ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebFrame a) =>
    a
    {- ^ /@frame@/: a 'GI.WebKit.Objects.WebFrame.WebFrame' -}
    -> T.Text
    {- ^ /@uri@/: an URI string -}
    -> m ()
webFrameLoadUri frame uri = liftIO $ do
    frame' <- unsafeManagedPtrCastPtr frame
    uri' <- textToCString uri
    webkit_web_frame_load_uri frame' uri'
    touchManagedPtr frame
    freeMem uri'
    return ()

data WebFrameLoadUriMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsWebFrame a) => O.MethodInfo WebFrameLoadUriMethodInfo a signature where
    overloadedMethod _ = webFrameLoadUri

-- method WebFrame::print
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "frame", argType = TInterface (Name {namespace = "WebKit", name = "WebFrame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebFrame", 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_frame_print" webkit_web_frame_print :: 
    Ptr WebFrame ->                         -- frame : TInterface (Name {namespace = "WebKit", name = "WebFrame"})
    IO ()

{- |
Prints the given 'GI.WebKit.Objects.WebFrame.WebFrame', by presenting a print dialog to the
user. If you need more control over the printing process, see
'GI.WebKit.Objects.WebFrame.webFramePrintFull'.

@since 1.1.5
-}
webFramePrint ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebFrame a) =>
    a
    {- ^ /@frame@/: a 'GI.WebKit.Objects.WebFrame.WebFrame' -}
    -> m ()
webFramePrint frame = liftIO $ do
    frame' <- unsafeManagedPtrCastPtr frame
    webkit_web_frame_print frame'
    touchManagedPtr frame
    return ()

data WebFramePrintMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWebFrame a) => O.MethodInfo WebFramePrintMethodInfo a signature where
    overloadedMethod _ = webFramePrint

-- method WebFrame::print_full
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "frame", argType = TInterface (Name {namespace = "WebKit", name = "WebFrame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebFrame to be printed", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "operation", argType = TInterface (Name {namespace = "Gtk", name = "PrintOperation"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GtkPrintOperation to be carried", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "action", argType = TInterface (Name {namespace = "Gtk", name = "PrintOperationAction"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GtkPrintOperationAction to be performed", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "PrintOperationResult"}))
-- throws : True
-- Skip return : False

foreign import ccall "webkit_web_frame_print_full" webkit_web_frame_print_full :: 
    Ptr WebFrame ->                         -- frame : TInterface (Name {namespace = "WebKit", name = "WebFrame"})
    Ptr Gtk.PrintOperation.PrintOperation -> -- operation : TInterface (Name {namespace = "Gtk", name = "PrintOperation"})
    CUInt ->                                -- action : TInterface (Name {namespace = "Gtk", name = "PrintOperationAction"})
    Ptr (Ptr GError) ->                     -- error
    IO CUInt

{- |
Prints the given 'GI.WebKit.Objects.WebFrame.WebFrame', using the given 'GI.Gtk.Objects.PrintOperation.PrintOperation'
and 'GI.Gtk.Enums.PrintOperationAction'. This function wraps a call to
'GI.Gtk.Objects.PrintOperation.printOperationRun' for printing the contents of the
'GI.WebKit.Objects.WebFrame.WebFrame'.

@since 1.1.5
-}
webFramePrintFull ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebFrame a, Gtk.PrintOperation.IsPrintOperation b) =>
    a
    {- ^ /@frame@/: a 'GI.WebKit.Objects.WebFrame.WebFrame' to be printed -}
    -> b
    {- ^ /@operation@/: the 'GI.Gtk.Objects.PrintOperation.PrintOperation' to be carried -}
    -> Gtk.Enums.PrintOperationAction
    {- ^ /@action@/: the 'GI.Gtk.Enums.PrintOperationAction' to be performed -}
    -> m Gtk.Enums.PrintOperationResult
    {- ^ __Returns:__ The 'GI.Gtk.Enums.PrintOperationResult' specifying the result of this operation. /(Can throw 'Data.GI.Base.GError.GError')/ -}
webFramePrintFull frame operation action = liftIO $ do
    frame' <- unsafeManagedPtrCastPtr frame
    operation' <- unsafeManagedPtrCastPtr operation
    let action' = (fromIntegral . fromEnum) action
    onException (do
        result <- propagateGError $ webkit_web_frame_print_full frame' operation' action'
        let result' = (toEnum . fromIntegral) result
        touchManagedPtr frame
        touchManagedPtr operation
        return result'
     ) (do
        return ()
     )

data WebFramePrintFullMethodInfo
instance (signature ~ (b -> Gtk.Enums.PrintOperationAction -> m Gtk.Enums.PrintOperationResult), MonadIO m, IsWebFrame a, Gtk.PrintOperation.IsPrintOperation b) => O.MethodInfo WebFramePrintFullMethodInfo a signature where
    overloadedMethod _ = webFramePrintFull

-- method WebFrame::reload
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "frame", argType = TInterface (Name {namespace = "WebKit", name = "WebFrame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebFrame", 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_frame_reload" webkit_web_frame_reload :: 
    Ptr WebFrame ->                         -- frame : TInterface (Name {namespace = "WebKit", name = "WebFrame"})
    IO ()

{- |
Reloads the initial request.
-}
webFrameReload ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebFrame a) =>
    a
    {- ^ /@frame@/: a 'GI.WebKit.Objects.WebFrame.WebFrame' -}
    -> m ()
webFrameReload frame = liftIO $ do
    frame' <- unsafeManagedPtrCastPtr frame
    webkit_web_frame_reload frame'
    touchManagedPtr frame
    return ()

data WebFrameReloadMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWebFrame a) => O.MethodInfo WebFrameReloadMethodInfo a signature where
    overloadedMethod _ = webFrameReload

-- method WebFrame::replace_selection
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "frame", argType = TInterface (Name {namespace = "WebKit", name = "WebFrame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWeFrame", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the text to insert in place of the current selection", 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_frame_replace_selection" webkit_web_frame_replace_selection :: 
    Ptr WebFrame ->                         -- frame : TInterface (Name {namespace = "WebKit", name = "WebFrame"})
    CString ->                              -- text : TBasicType TUTF8
    IO ()

{- |
Replaces the current selection in /@frame@/, if any, with /@text@/.

@since 1.5.1
-}
webFrameReplaceSelection ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebFrame a) =>
    a
    {- ^ /@frame@/: a @/WebKitWeFrame/@ -}
    -> T.Text
    {- ^ /@text@/: the text to insert in place of the current selection -}
    -> m ()
webFrameReplaceSelection frame text = liftIO $ do
    frame' <- unsafeManagedPtrCastPtr frame
    text' <- textToCString text
    webkit_web_frame_replace_selection frame' text'
    touchManagedPtr frame
    freeMem text'
    return ()

data WebFrameReplaceSelectionMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsWebFrame a) => O.MethodInfo WebFrameReplaceSelectionMethodInfo a signature where
    overloadedMethod _ = webFrameReplaceSelection

-- method WebFrame::stop_loading
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "frame", argType = TInterface (Name {namespace = "WebKit", name = "WebFrame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebFrame", 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_frame_stop_loading" webkit_web_frame_stop_loading :: 
    Ptr WebFrame ->                         -- frame : TInterface (Name {namespace = "WebKit", name = "WebFrame"})
    IO ()

{- |
Stops any pending loads on /@frame@/\'s data source, and those of its children.
-}
webFrameStopLoading ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebFrame a) =>
    a
    {- ^ /@frame@/: a 'GI.WebKit.Objects.WebFrame.WebFrame' -}
    -> m ()
webFrameStopLoading frame = liftIO $ do
    frame' <- unsafeManagedPtrCastPtr frame
    webkit_web_frame_stop_loading frame'
    touchManagedPtr frame
    return ()

data WebFrameStopLoadingMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWebFrame a) => O.MethodInfo WebFrameStopLoadingMethodInfo a signature where
    overloadedMethod _ = webFrameStopLoading