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

module GI.WebKit2.Objects.WebView
    ( 

-- * Exported types
    WebView(..)                             ,
    IsWebView                               ,
    toWebView                               ,
    noWebView                               ,


 -- * Methods
-- ** canExecuteEditingCommand #method:canExecuteEditingCommand#
    WebViewCanExecuteEditingCommandMethodInfo,
    webViewCanExecuteEditingCommand         ,


-- ** canExecuteEditingCommandFinish #method:canExecuteEditingCommandFinish#
    WebViewCanExecuteEditingCommandFinishMethodInfo,
    webViewCanExecuteEditingCommandFinish   ,


-- ** canGoBack #method:canGoBack#
    WebViewCanGoBackMethodInfo              ,
    webViewCanGoBack                        ,


-- ** canGoForward #method:canGoForward#
    WebViewCanGoForwardMethodInfo           ,
    webViewCanGoForward                     ,


-- ** canShowMimeType #method:canShowMimeType#
    WebViewCanShowMimeTypeMethodInfo        ,
    webViewCanShowMimeType                  ,


-- ** downloadUri #method:downloadUri#
    WebViewDownloadUriMethodInfo            ,
    webViewDownloadUri                      ,


-- ** executeEditingCommand #method:executeEditingCommand#
    WebViewExecuteEditingCommandMethodInfo  ,
    webViewExecuteEditingCommand            ,


-- ** executeEditingCommandWithArgument #method:executeEditingCommandWithArgument#
    WebViewExecuteEditingCommandWithArgumentMethodInfo,
    webViewExecuteEditingCommandWithArgument,


-- ** getBackForwardList #method:getBackForwardList#
    WebViewGetBackForwardListMethodInfo     ,
    webViewGetBackForwardList               ,


-- ** getBackgroundColor #method:getBackgroundColor#
    WebViewGetBackgroundColorMethodInfo     ,
    webViewGetBackgroundColor               ,


-- ** getContext #method:getContext#
    WebViewGetContextMethodInfo             ,
    webViewGetContext                       ,


-- ** getCustomCharset #method:getCustomCharset#
    WebViewGetCustomCharsetMethodInfo       ,
    webViewGetCustomCharset                 ,


-- ** getEditorState #method:getEditorState#
    WebViewGetEditorStateMethodInfo         ,
    webViewGetEditorState                   ,


-- ** getEstimatedLoadProgress #method:getEstimatedLoadProgress#
    WebViewGetEstimatedLoadProgressMethodInfo,
    webViewGetEstimatedLoadProgress         ,


-- ** getFavicon #method:getFavicon#
    WebViewGetFaviconMethodInfo             ,
    webViewGetFavicon                       ,


-- ** getFindController #method:getFindController#
    WebViewGetFindControllerMethodInfo      ,
    webViewGetFindController                ,


-- ** getInspector #method:getInspector#
    WebViewGetInspectorMethodInfo           ,
    webViewGetInspector                     ,


-- ** getJavascriptGlobalContext #method:getJavascriptGlobalContext#
    WebViewGetJavascriptGlobalContextMethodInfo,
    webViewGetJavascriptGlobalContext       ,


-- ** getMainResource #method:getMainResource#
    WebViewGetMainResourceMethodInfo        ,
    webViewGetMainResource                  ,


-- ** getPageId #method:getPageId#
    WebViewGetPageIdMethodInfo              ,
    webViewGetPageId                        ,


-- ** getSessionState #method:getSessionState#
    WebViewGetSessionStateMethodInfo        ,
    webViewGetSessionState                  ,


-- ** getSettings #method:getSettings#
    WebViewGetSettingsMethodInfo            ,
    webViewGetSettings                      ,


-- ** getSnapshot #method:getSnapshot#
    WebViewGetSnapshotMethodInfo            ,
    webViewGetSnapshot                      ,


-- ** getSnapshotFinish #method:getSnapshotFinish#
    WebViewGetSnapshotFinishMethodInfo      ,
    webViewGetSnapshotFinish                ,


-- ** getTitle #method:getTitle#
    WebViewGetTitleMethodInfo               ,
    webViewGetTitle                         ,


-- ** getTlsInfo #method:getTlsInfo#
    WebViewGetTlsInfoMethodInfo             ,
    webViewGetTlsInfo                       ,


-- ** getUri #method:getUri#
    WebViewGetUriMethodInfo                 ,
    webViewGetUri                           ,


-- ** getUserContentManager #method:getUserContentManager#
    WebViewGetUserContentManagerMethodInfo  ,
    webViewGetUserContentManager            ,


-- ** getWindowProperties #method:getWindowProperties#
    WebViewGetWindowPropertiesMethodInfo    ,
    webViewGetWindowProperties              ,


-- ** getZoomLevel #method:getZoomLevel#
    WebViewGetZoomLevelMethodInfo           ,
    webViewGetZoomLevel                     ,


-- ** goBack #method:goBack#
    WebViewGoBackMethodInfo                 ,
    webViewGoBack                           ,


-- ** goForward #method:goForward#
    WebViewGoForwardMethodInfo              ,
    webViewGoForward                        ,


-- ** goToBackForwardListItem #method:goToBackForwardListItem#
    WebViewGoToBackForwardListItemMethodInfo,
    webViewGoToBackForwardListItem          ,


-- ** isEditable #method:isEditable#
    WebViewIsEditableMethodInfo             ,
    webViewIsEditable                       ,


-- ** isLoading #method:isLoading#
    WebViewIsLoadingMethodInfo              ,
    webViewIsLoading                        ,


-- ** isPlayingAudio #method:isPlayingAudio#
    WebViewIsPlayingAudioMethodInfo         ,
    webViewIsPlayingAudio                   ,


-- ** loadAlternateHtml #method:loadAlternateHtml#
    WebViewLoadAlternateHtmlMethodInfo      ,
    webViewLoadAlternateHtml                ,


-- ** loadBytes #method:loadBytes#
    WebViewLoadBytesMethodInfo              ,
    webViewLoadBytes                        ,


-- ** loadHtml #method:loadHtml#
    WebViewLoadHtmlMethodInfo               ,
    webViewLoadHtml                         ,


-- ** loadPlainText #method:loadPlainText#
    WebViewLoadPlainTextMethodInfo          ,
    webViewLoadPlainText                    ,


-- ** loadRequest #method:loadRequest#
    WebViewLoadRequestMethodInfo            ,
    webViewLoadRequest                      ,


-- ** loadUri #method:loadUri#
    WebViewLoadUriMethodInfo                ,
    webViewLoadUri                          ,


-- ** new #method:new#
    webViewNew                              ,


-- ** newWithContext #method:newWithContext#
    webViewNewWithContext                   ,


-- ** newWithRelatedView #method:newWithRelatedView#
    WebViewNewWithRelatedViewMethodInfo     ,
    webViewNewWithRelatedView               ,


-- ** newWithSettings #method:newWithSettings#
    webViewNewWithSettings                  ,


-- ** newWithUserContentManager #method:newWithUserContentManager#
    webViewNewWithUserContentManager        ,


-- ** reload #method:reload#
    WebViewReloadMethodInfo                 ,
    webViewReload                           ,


-- ** reloadBypassCache #method:reloadBypassCache#
    WebViewReloadBypassCacheMethodInfo      ,
    webViewReloadBypassCache                ,


-- ** restoreSessionState #method:restoreSessionState#
    WebViewRestoreSessionStateMethodInfo    ,
    webViewRestoreSessionState              ,


-- ** runJavascript #method:runJavascript#
    WebViewRunJavascriptMethodInfo          ,
    webViewRunJavascript                    ,


-- ** runJavascriptFinish #method:runJavascriptFinish#
    WebViewRunJavascriptFinishMethodInfo    ,
    webViewRunJavascriptFinish              ,


-- ** runJavascriptFromGresource #method:runJavascriptFromGresource#
    WebViewRunJavascriptFromGresourceMethodInfo,
    webViewRunJavascriptFromGresource       ,


-- ** runJavascriptFromGresourceFinish #method:runJavascriptFromGresourceFinish#
    WebViewRunJavascriptFromGresourceFinishMethodInfo,
    webViewRunJavascriptFromGresourceFinish ,


-- ** save #method:save#
    WebViewSaveMethodInfo                   ,
    webViewSave                             ,


-- ** saveFinish #method:saveFinish#
    WebViewSaveFinishMethodInfo             ,
    webViewSaveFinish                       ,


-- ** saveToFile #method:saveToFile#
    WebViewSaveToFileMethodInfo             ,
    webViewSaveToFile                       ,


-- ** saveToFileFinish #method:saveToFileFinish#
    WebViewSaveToFileFinishMethodInfo       ,
    webViewSaveToFileFinish                 ,


-- ** setBackgroundColor #method:setBackgroundColor#
    WebViewSetBackgroundColorMethodInfo     ,
    webViewSetBackgroundColor               ,


-- ** setCustomCharset #method:setCustomCharset#
    WebViewSetCustomCharsetMethodInfo       ,
    webViewSetCustomCharset                 ,


-- ** setEditable #method:setEditable#
    WebViewSetEditableMethodInfo            ,
    webViewSetEditable                      ,


-- ** setSettings #method:setSettings#
    WebViewSetSettingsMethodInfo            ,
    webViewSetSettings                      ,


-- ** setZoomLevel #method:setZoomLevel#
    WebViewSetZoomLevelMethodInfo           ,
    webViewSetZoomLevel                     ,


-- ** stopLoading #method:stopLoading#
    WebViewStopLoadingMethodInfo            ,
    webViewStopLoading                      ,


-- ** tryClose #method:tryClose#
    WebViewTryCloseMethodInfo               ,
    webViewTryClose                         ,




 -- * Properties
-- ** editable #attr:editable#
    WebViewEditablePropertyInfo             ,
    constructWebViewEditable                ,
    getWebViewEditable                      ,
    setWebViewEditable                      ,
    webViewEditable                         ,


-- ** estimatedLoadProgress #attr:estimatedLoadProgress#
    WebViewEstimatedLoadProgressPropertyInfo,
    getWebViewEstimatedLoadProgress         ,
    webViewEstimatedLoadProgress            ,


-- ** favicon #attr:favicon#
    WebViewFaviconPropertyInfo              ,
    getWebViewFavicon                       ,
    webViewFavicon                          ,


-- ** isLoading #attr:isLoading#
    WebViewIsLoadingPropertyInfo            ,
    getWebViewIsLoading                     ,


-- ** isPlayingAudio #attr:isPlayingAudio#
    WebViewIsPlayingAudioPropertyInfo       ,
    getWebViewIsPlayingAudio                ,


-- ** relatedView #attr:relatedView#
    WebViewRelatedViewPropertyInfo          ,
    constructWebViewRelatedView             ,
    webViewRelatedView                      ,


-- ** settings #attr:settings#
    WebViewSettingsPropertyInfo             ,
    constructWebViewSettings                ,
    setWebViewSettings                      ,
    webViewSettings                         ,


-- ** title #attr:title#
    WebViewTitlePropertyInfo                ,
    getWebViewTitle                         ,
    webViewTitle                            ,


-- ** uri #attr:uri#
    WebViewUriPropertyInfo                  ,
    getWebViewUri                           ,
    webViewUri                              ,


-- ** userContentManager #attr:userContentManager#
    WebViewUserContentManagerPropertyInfo   ,
    constructWebViewUserContentManager      ,
    getWebViewUserContentManager            ,
    webViewUserContentManager               ,


-- ** webContext #attr:webContext#
    WebViewWebContextPropertyInfo           ,
    constructWebViewWebContext              ,
    getWebViewWebContext                    ,
    webViewWebContext                       ,


-- ** zoomLevel #attr:zoomLevel#
    WebViewZoomLevelPropertyInfo            ,
    constructWebViewZoomLevel               ,
    getWebViewZoomLevel                     ,
    setWebViewZoomLevel                     ,
    webViewZoomLevel                        ,




 -- * Signals
-- ** authenticate #signal:authenticate#
    C_WebViewAuthenticateCallback           ,
    WebViewAuthenticateCallback             ,
    WebViewAuthenticateSignalInfo           ,
    afterWebViewAuthenticate                ,
    genClosure_WebViewAuthenticate          ,
    mk_WebViewAuthenticateCallback          ,
    noWebViewAuthenticateCallback           ,
    onWebViewAuthenticate                   ,
    wrap_WebViewAuthenticateCallback        ,


-- ** close #signal:close#
    C_WebViewCloseCallback                  ,
    WebViewCloseCallback                    ,
    WebViewCloseSignalInfo                  ,
    afterWebViewClose                       ,
    genClosure_WebViewClose                 ,
    mk_WebViewCloseCallback                 ,
    noWebViewCloseCallback                  ,
    onWebViewClose                          ,
    wrap_WebViewCloseCallback               ,


-- ** contextMenu #signal:contextMenu#
    C_WebViewContextMenuCallback            ,
    WebViewContextMenuCallback              ,
    WebViewContextMenuSignalInfo            ,
    afterWebViewContextMenu                 ,
    genClosure_WebViewContextMenu           ,
    mk_WebViewContextMenuCallback           ,
    noWebViewContextMenuCallback            ,
    onWebViewContextMenu                    ,
    wrap_WebViewContextMenuCallback         ,


-- ** contextMenuDismissed #signal:contextMenuDismissed#
    C_WebViewContextMenuDismissedCallback   ,
    WebViewContextMenuDismissedCallback     ,
    WebViewContextMenuDismissedSignalInfo   ,
    afterWebViewContextMenuDismissed        ,
    genClosure_WebViewContextMenuDismissed  ,
    mk_WebViewContextMenuDismissedCallback  ,
    noWebViewContextMenuDismissedCallback   ,
    onWebViewContextMenuDismissed           ,
    wrap_WebViewContextMenuDismissedCallback,


-- ** create #signal:create#
    C_WebViewCreateCallback                 ,
    WebViewCreateCallback                   ,
    WebViewCreateSignalInfo                 ,
    afterWebViewCreate                      ,
    genClosure_WebViewCreate                ,
    mk_WebViewCreateCallback                ,
    noWebViewCreateCallback                 ,
    onWebViewCreate                         ,
    wrap_WebViewCreateCallback              ,


-- ** decidePolicy #signal:decidePolicy#
    C_WebViewDecidePolicyCallback           ,
    WebViewDecidePolicyCallback             ,
    WebViewDecidePolicySignalInfo           ,
    afterWebViewDecidePolicy                ,
    genClosure_WebViewDecidePolicy          ,
    mk_WebViewDecidePolicyCallback          ,
    noWebViewDecidePolicyCallback           ,
    onWebViewDecidePolicy                   ,
    wrap_WebViewDecidePolicyCallback        ,


-- ** enterFullscreen #signal:enterFullscreen#
    C_WebViewEnterFullscreenCallback        ,
    WebViewEnterFullscreenCallback          ,
    WebViewEnterFullscreenSignalInfo        ,
    afterWebViewEnterFullscreen             ,
    genClosure_WebViewEnterFullscreen       ,
    mk_WebViewEnterFullscreenCallback       ,
    noWebViewEnterFullscreenCallback        ,
    onWebViewEnterFullscreen                ,
    wrap_WebViewEnterFullscreenCallback     ,


-- ** insecureContentDetected #signal:insecureContentDetected#
    C_WebViewInsecureContentDetectedCallback,
    WebViewInsecureContentDetectedCallback  ,
    WebViewInsecureContentDetectedSignalInfo,
    afterWebViewInsecureContentDetected     ,
    genClosure_WebViewInsecureContentDetected,
    mk_WebViewInsecureContentDetectedCallback,
    noWebViewInsecureContentDetectedCallback,
    onWebViewInsecureContentDetected        ,
    wrap_WebViewInsecureContentDetectedCallback,


-- ** leaveFullscreen #signal:leaveFullscreen#
    C_WebViewLeaveFullscreenCallback        ,
    WebViewLeaveFullscreenCallback          ,
    WebViewLeaveFullscreenSignalInfo        ,
    afterWebViewLeaveFullscreen             ,
    genClosure_WebViewLeaveFullscreen       ,
    mk_WebViewLeaveFullscreenCallback       ,
    noWebViewLeaveFullscreenCallback        ,
    onWebViewLeaveFullscreen                ,
    wrap_WebViewLeaveFullscreenCallback     ,


-- ** loadChanged #signal:loadChanged#
    C_WebViewLoadChangedCallback            ,
    WebViewLoadChangedCallback              ,
    WebViewLoadChangedSignalInfo            ,
    afterWebViewLoadChanged                 ,
    genClosure_WebViewLoadChanged           ,
    mk_WebViewLoadChangedCallback           ,
    noWebViewLoadChangedCallback            ,
    onWebViewLoadChanged                    ,
    wrap_WebViewLoadChangedCallback         ,


-- ** loadFailed #signal:loadFailed#
    C_WebViewLoadFailedCallback             ,
    WebViewLoadFailedCallback               ,
    WebViewLoadFailedSignalInfo             ,
    afterWebViewLoadFailed                  ,
    genClosure_WebViewLoadFailed            ,
    mk_WebViewLoadFailedCallback            ,
    noWebViewLoadFailedCallback             ,
    onWebViewLoadFailed                     ,
    wrap_WebViewLoadFailedCallback          ,


-- ** loadFailedWithTlsErrors #signal:loadFailedWithTlsErrors#
    C_WebViewLoadFailedWithTlsErrorsCallback,
    WebViewLoadFailedWithTlsErrorsCallback  ,
    WebViewLoadFailedWithTlsErrorsSignalInfo,
    afterWebViewLoadFailedWithTlsErrors     ,
    genClosure_WebViewLoadFailedWithTlsErrors,
    mk_WebViewLoadFailedWithTlsErrorsCallback,
    noWebViewLoadFailedWithTlsErrorsCallback,
    onWebViewLoadFailedWithTlsErrors        ,
    wrap_WebViewLoadFailedWithTlsErrorsCallback,


-- ** mouseTargetChanged #signal:mouseTargetChanged#
    C_WebViewMouseTargetChangedCallback     ,
    WebViewMouseTargetChangedCallback       ,
    WebViewMouseTargetChangedSignalInfo     ,
    afterWebViewMouseTargetChanged          ,
    genClosure_WebViewMouseTargetChanged    ,
    mk_WebViewMouseTargetChangedCallback    ,
    noWebViewMouseTargetChangedCallback     ,
    onWebViewMouseTargetChanged             ,
    wrap_WebViewMouseTargetChangedCallback  ,


-- ** permissionRequest #signal:permissionRequest#
    C_WebViewPermissionRequestCallback      ,
    WebViewPermissionRequestCallback        ,
    WebViewPermissionRequestSignalInfo      ,
    afterWebViewPermissionRequest           ,
    genClosure_WebViewPermissionRequest     ,
    mk_WebViewPermissionRequestCallback     ,
    noWebViewPermissionRequestCallback      ,
    onWebViewPermissionRequest              ,
    wrap_WebViewPermissionRequestCallback   ,


-- ** print #signal:print#
    C_WebViewPrintCallback                  ,
    WebViewPrintCallback                    ,
    WebViewPrintSignalInfo                  ,
    afterWebViewPrint                       ,
    genClosure_WebViewPrint                 ,
    mk_WebViewPrintCallback                 ,
    noWebViewPrintCallback                  ,
    onWebViewPrint                          ,
    wrap_WebViewPrintCallback               ,


-- ** readyToShow #signal:readyToShow#
    C_WebViewReadyToShowCallback            ,
    WebViewReadyToShowCallback              ,
    WebViewReadyToShowSignalInfo            ,
    afterWebViewReadyToShow                 ,
    genClosure_WebViewReadyToShow           ,
    mk_WebViewReadyToShowCallback           ,
    noWebViewReadyToShowCallback            ,
    onWebViewReadyToShow                    ,
    wrap_WebViewReadyToShowCallback         ,


-- ** resourceLoadStarted #signal:resourceLoadStarted#
    C_WebViewResourceLoadStartedCallback    ,
    WebViewResourceLoadStartedCallback      ,
    WebViewResourceLoadStartedSignalInfo    ,
    afterWebViewResourceLoadStarted         ,
    genClosure_WebViewResourceLoadStarted   ,
    mk_WebViewResourceLoadStartedCallback   ,
    noWebViewResourceLoadStartedCallback    ,
    onWebViewResourceLoadStarted            ,
    wrap_WebViewResourceLoadStartedCallback ,


-- ** runAsModal #signal:runAsModal#
    C_WebViewRunAsModalCallback             ,
    WebViewRunAsModalCallback               ,
    WebViewRunAsModalSignalInfo             ,
    afterWebViewRunAsModal                  ,
    genClosure_WebViewRunAsModal            ,
    mk_WebViewRunAsModalCallback            ,
    noWebViewRunAsModalCallback             ,
    onWebViewRunAsModal                     ,
    wrap_WebViewRunAsModalCallback          ,


-- ** runColorChooser #signal:runColorChooser#
    C_WebViewRunColorChooserCallback        ,
    WebViewRunColorChooserCallback          ,
    WebViewRunColorChooserSignalInfo        ,
    afterWebViewRunColorChooser             ,
    genClosure_WebViewRunColorChooser       ,
    mk_WebViewRunColorChooserCallback       ,
    noWebViewRunColorChooserCallback        ,
    onWebViewRunColorChooser                ,
    wrap_WebViewRunColorChooserCallback     ,


-- ** runFileChooser #signal:runFileChooser#
    C_WebViewRunFileChooserCallback         ,
    WebViewRunFileChooserCallback           ,
    WebViewRunFileChooserSignalInfo         ,
    afterWebViewRunFileChooser              ,
    genClosure_WebViewRunFileChooser        ,
    mk_WebViewRunFileChooserCallback        ,
    noWebViewRunFileChooserCallback         ,
    onWebViewRunFileChooser                 ,
    wrap_WebViewRunFileChooserCallback      ,


-- ** scriptDialog #signal:scriptDialog#
    C_WebViewScriptDialogCallback           ,
    WebViewScriptDialogCallback             ,
    WebViewScriptDialogSignalInfo           ,
    afterWebViewScriptDialog                ,
    genClosure_WebViewScriptDialog          ,
    mk_WebViewScriptDialogCallback          ,
    noWebViewScriptDialogCallback           ,
    onWebViewScriptDialog                   ,
    wrap_WebViewScriptDialogCallback        ,


-- ** showNotification #signal:showNotification#
    C_WebViewShowNotificationCallback       ,
    WebViewShowNotificationCallback         ,
    WebViewShowNotificationSignalInfo       ,
    afterWebViewShowNotification            ,
    genClosure_WebViewShowNotification      ,
    mk_WebViewShowNotificationCallback      ,
    noWebViewShowNotificationCallback       ,
    onWebViewShowNotification               ,
    wrap_WebViewShowNotificationCallback    ,


-- ** submitForm #signal:submitForm#
    C_WebViewSubmitFormCallback             ,
    WebViewSubmitFormCallback               ,
    WebViewSubmitFormSignalInfo             ,
    afterWebViewSubmitForm                  ,
    genClosure_WebViewSubmitForm            ,
    mk_WebViewSubmitFormCallback            ,
    noWebViewSubmitFormCallback             ,
    onWebViewSubmitForm                     ,
    wrap_WebViewSubmitFormCallback          ,


-- ** webProcessCrashed #signal:webProcessCrashed#
    C_WebViewWebProcessCrashedCallback      ,
    WebViewWebProcessCrashedCallback        ,
    WebViewWebProcessCrashedSignalInfo      ,
    afterWebViewWebProcessCrashed           ,
    genClosure_WebViewWebProcessCrashed     ,
    mk_WebViewWebProcessCrashedCallback     ,
    noWebViewWebProcessCrashedCallback      ,
    onWebViewWebProcessCrashed              ,
    wrap_WebViewWebProcessCrashedCallback   ,




    ) 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.Atk.Interfaces.ImplementorIface as Atk.ImplementorIface
import qualified GI.Cairo.Structs.Surface as Cairo.Surface
import qualified GI.GLib.Structs.Bytes as GLib.Bytes
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gdk.Structs.RGBA as Gdk.RGBA
import qualified GI.Gdk.Unions.Event as Gdk.Event
import qualified GI.Gio.Callbacks as Gio.Callbacks
import qualified GI.Gio.Flags as Gio.Flags
import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult
import qualified GI.Gio.Interfaces.File as Gio.File
import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable
import qualified GI.Gio.Objects.InputStream as Gio.InputStream
import qualified GI.Gio.Objects.TlsCertificate as Gio.TlsCertificate
import qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
import qualified GI.Gtk.Objects.Container as Gtk.Container
import qualified GI.Gtk.Objects.Widget as Gtk.Widget
import qualified GI.JavaScriptCore.Structs.GlobalContext as JavaScriptCore.GlobalContext
import {-# SOURCE #-} qualified GI.WebKit2.Enums as WebKit2.Enums
import {-# SOURCE #-} qualified GI.WebKit2.Flags as WebKit2.Flags
import {-# SOURCE #-} qualified GI.WebKit2.Interfaces.PermissionRequest as WebKit2.PermissionRequest
import {-# SOURCE #-} qualified GI.WebKit2.Objects.AuthenticationRequest as WebKit2.AuthenticationRequest
import {-# SOURCE #-} qualified GI.WebKit2.Objects.BackForwardList as WebKit2.BackForwardList
import {-# SOURCE #-} qualified GI.WebKit2.Objects.BackForwardListItem as WebKit2.BackForwardListItem
import {-# SOURCE #-} qualified GI.WebKit2.Objects.ColorChooserRequest as WebKit2.ColorChooserRequest
import {-# SOURCE #-} qualified GI.WebKit2.Objects.ContextMenu as WebKit2.ContextMenu
import {-# SOURCE #-} qualified GI.WebKit2.Objects.Download as WebKit2.Download
import {-# SOURCE #-} qualified GI.WebKit2.Objects.EditorState as WebKit2.EditorState
import {-# SOURCE #-} qualified GI.WebKit2.Objects.FileChooserRequest as WebKit2.FileChooserRequest
import {-# SOURCE #-} qualified GI.WebKit2.Objects.FindController as WebKit2.FindController
import {-# SOURCE #-} qualified GI.WebKit2.Objects.FormSubmissionRequest as WebKit2.FormSubmissionRequest
import {-# SOURCE #-} qualified GI.WebKit2.Objects.HitTestResult as WebKit2.HitTestResult
import {-# SOURCE #-} qualified GI.WebKit2.Objects.Notification as WebKit2.Notification
import {-# SOURCE #-} qualified GI.WebKit2.Objects.PolicyDecision as WebKit2.PolicyDecision
import {-# SOURCE #-} qualified GI.WebKit2.Objects.PrintOperation as WebKit2.PrintOperation
import {-# SOURCE #-} qualified GI.WebKit2.Objects.Settings as WebKit2.Settings
import {-# SOURCE #-} qualified GI.WebKit2.Objects.URIRequest as WebKit2.URIRequest
import {-# SOURCE #-} qualified GI.WebKit2.Objects.UserContentManager as WebKit2.UserContentManager
import {-# SOURCE #-} qualified GI.WebKit2.Objects.WebContext as WebKit2.WebContext
import {-# SOURCE #-} qualified GI.WebKit2.Objects.WebInspector as WebKit2.WebInspector
import {-# SOURCE #-} qualified GI.WebKit2.Objects.WebResource as WebKit2.WebResource
import {-# SOURCE #-} qualified GI.WebKit2.Objects.WebViewBase as WebKit2.WebViewBase
import {-# SOURCE #-} qualified GI.WebKit2.Objects.WindowProperties as WebKit2.WindowProperties
import {-# SOURCE #-} qualified GI.WebKit2.Structs.JavascriptResult as WebKit2.JavascriptResult
import {-# SOURCE #-} qualified GI.WebKit2.Structs.NavigationAction as WebKit2.NavigationAction
import {-# SOURCE #-} qualified GI.WebKit2.Structs.ScriptDialog as WebKit2.ScriptDialog
import {-# SOURCE #-} qualified GI.WebKit2.Structs.WebViewSessionState as WebKit2.WebViewSessionState

newtype WebView = WebView (ManagedPtr WebView)
foreign import ccall "webkit_web_view_get_type"
    c_webkit_web_view_get_type :: IO GType

instance GObject WebView where
    gobjectType _ = c_webkit_web_view_get_type
    

class GObject o => IsWebView o
#if MIN_VERSION_base(4,9,0)
instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError WebView a) =>
    IsWebView a
#endif
instance IsWebView WebView
instance WebKit2.WebViewBase.IsWebViewBase WebView
instance Gtk.Container.IsContainer WebView
instance Gtk.Widget.IsWidget WebView
instance GObject.Object.IsObject WebView
instance Atk.ImplementorIface.IsImplementorIface WebView
instance Gtk.Buildable.IsBuildable WebView

toWebView :: IsWebView o => o -> IO WebView
toWebView = unsafeCastTo WebView

noWebView :: Maybe WebView
noWebView = Nothing

type family ResolveWebViewMethod (t :: Symbol) (o :: *) :: * where
    ResolveWebViewMethod "activate" o = Gtk.Widget.WidgetActivateMethodInfo
    ResolveWebViewMethod "add" o = Gtk.Container.ContainerAddMethodInfo
    ResolveWebViewMethod "addAccelerator" o = Gtk.Widget.WidgetAddAcceleratorMethodInfo
    ResolveWebViewMethod "addChild" o = Gtk.Buildable.BuildableAddChildMethodInfo
    ResolveWebViewMethod "addDeviceEvents" o = Gtk.Widget.WidgetAddDeviceEventsMethodInfo
    ResolveWebViewMethod "addEvents" o = Gtk.Widget.WidgetAddEventsMethodInfo
    ResolveWebViewMethod "addMnemonicLabel" o = Gtk.Widget.WidgetAddMnemonicLabelMethodInfo
    ResolveWebViewMethod "addTickCallback" o = Gtk.Widget.WidgetAddTickCallbackMethodInfo
    ResolveWebViewMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveWebViewMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveWebViewMethod "canActivateAccel" o = Gtk.Widget.WidgetCanActivateAccelMethodInfo
    ResolveWebViewMethod "canExecuteEditingCommand" o = WebViewCanExecuteEditingCommandMethodInfo
    ResolveWebViewMethod "canExecuteEditingCommandFinish" o = WebViewCanExecuteEditingCommandFinishMethodInfo
    ResolveWebViewMethod "canGoBack" o = WebViewCanGoBackMethodInfo
    ResolveWebViewMethod "canGoForward" o = WebViewCanGoForwardMethodInfo
    ResolveWebViewMethod "canShowMimeType" o = WebViewCanShowMimeTypeMethodInfo
    ResolveWebViewMethod "checkResize" o = Gtk.Container.ContainerCheckResizeMethodInfo
    ResolveWebViewMethod "childFocus" o = Gtk.Widget.WidgetChildFocusMethodInfo
    ResolveWebViewMethod "childGetProperty" o = Gtk.Container.ContainerChildGetPropertyMethodInfo
    ResolveWebViewMethod "childNotify" o = Gtk.Container.ContainerChildNotifyMethodInfo
    ResolveWebViewMethod "childNotifyByPspec" o = Gtk.Container.ContainerChildNotifyByPspecMethodInfo
    ResolveWebViewMethod "childSetProperty" o = Gtk.Container.ContainerChildSetPropertyMethodInfo
    ResolveWebViewMethod "childType" o = Gtk.Container.ContainerChildTypeMethodInfo
    ResolveWebViewMethod "classPath" o = Gtk.Widget.WidgetClassPathMethodInfo
    ResolveWebViewMethod "computeExpand" o = Gtk.Widget.WidgetComputeExpandMethodInfo
    ResolveWebViewMethod "constructChild" o = Gtk.Buildable.BuildableConstructChildMethodInfo
    ResolveWebViewMethod "createPangoContext" o = Gtk.Widget.WidgetCreatePangoContextMethodInfo
    ResolveWebViewMethod "createPangoLayout" o = Gtk.Widget.WidgetCreatePangoLayoutMethodInfo
    ResolveWebViewMethod "customFinished" o = Gtk.Buildable.BuildableCustomFinishedMethodInfo
    ResolveWebViewMethod "customTagEnd" o = Gtk.Buildable.BuildableCustomTagEndMethodInfo
    ResolveWebViewMethod "customTagStart" o = Gtk.Buildable.BuildableCustomTagStartMethodInfo
    ResolveWebViewMethod "destroy" o = Gtk.Widget.WidgetDestroyMethodInfo
    ResolveWebViewMethod "destroyed" o = Gtk.Widget.WidgetDestroyedMethodInfo
    ResolveWebViewMethod "deviceIsShadowed" o = Gtk.Widget.WidgetDeviceIsShadowedMethodInfo
    ResolveWebViewMethod "downloadUri" o = WebViewDownloadUriMethodInfo
    ResolveWebViewMethod "dragBegin" o = Gtk.Widget.WidgetDragBeginMethodInfo
    ResolveWebViewMethod "dragBeginWithCoordinates" o = Gtk.Widget.WidgetDragBeginWithCoordinatesMethodInfo
    ResolveWebViewMethod "dragCheckThreshold" o = Gtk.Widget.WidgetDragCheckThresholdMethodInfo
    ResolveWebViewMethod "dragDestAddImageTargets" o = Gtk.Widget.WidgetDragDestAddImageTargetsMethodInfo
    ResolveWebViewMethod "dragDestAddTextTargets" o = Gtk.Widget.WidgetDragDestAddTextTargetsMethodInfo
    ResolveWebViewMethod "dragDestAddUriTargets" o = Gtk.Widget.WidgetDragDestAddUriTargetsMethodInfo
    ResolveWebViewMethod "dragDestFindTarget" o = Gtk.Widget.WidgetDragDestFindTargetMethodInfo
    ResolveWebViewMethod "dragDestGetTargetList" o = Gtk.Widget.WidgetDragDestGetTargetListMethodInfo
    ResolveWebViewMethod "dragDestGetTrackMotion" o = Gtk.Widget.WidgetDragDestGetTrackMotionMethodInfo
    ResolveWebViewMethod "dragDestSet" o = Gtk.Widget.WidgetDragDestSetMethodInfo
    ResolveWebViewMethod "dragDestSetProxy" o = Gtk.Widget.WidgetDragDestSetProxyMethodInfo
    ResolveWebViewMethod "dragDestSetTargetList" o = Gtk.Widget.WidgetDragDestSetTargetListMethodInfo
    ResolveWebViewMethod "dragDestSetTrackMotion" o = Gtk.Widget.WidgetDragDestSetTrackMotionMethodInfo
    ResolveWebViewMethod "dragDestUnset" o = Gtk.Widget.WidgetDragDestUnsetMethodInfo
    ResolveWebViewMethod "dragGetData" o = Gtk.Widget.WidgetDragGetDataMethodInfo
    ResolveWebViewMethod "dragHighlight" o = Gtk.Widget.WidgetDragHighlightMethodInfo
    ResolveWebViewMethod "dragSourceAddImageTargets" o = Gtk.Widget.WidgetDragSourceAddImageTargetsMethodInfo
    ResolveWebViewMethod "dragSourceAddTextTargets" o = Gtk.Widget.WidgetDragSourceAddTextTargetsMethodInfo
    ResolveWebViewMethod "dragSourceAddUriTargets" o = Gtk.Widget.WidgetDragSourceAddUriTargetsMethodInfo
    ResolveWebViewMethod "dragSourceGetTargetList" o = Gtk.Widget.WidgetDragSourceGetTargetListMethodInfo
    ResolveWebViewMethod "dragSourceSet" o = Gtk.Widget.WidgetDragSourceSetMethodInfo
    ResolveWebViewMethod "dragSourceSetIconGicon" o = Gtk.Widget.WidgetDragSourceSetIconGiconMethodInfo
    ResolveWebViewMethod "dragSourceSetIconName" o = Gtk.Widget.WidgetDragSourceSetIconNameMethodInfo
    ResolveWebViewMethod "dragSourceSetIconPixbuf" o = Gtk.Widget.WidgetDragSourceSetIconPixbufMethodInfo
    ResolveWebViewMethod "dragSourceSetIconStock" o = Gtk.Widget.WidgetDragSourceSetIconStockMethodInfo
    ResolveWebViewMethod "dragSourceSetTargetList" o = Gtk.Widget.WidgetDragSourceSetTargetListMethodInfo
    ResolveWebViewMethod "dragSourceUnset" o = Gtk.Widget.WidgetDragSourceUnsetMethodInfo
    ResolveWebViewMethod "dragUnhighlight" o = Gtk.Widget.WidgetDragUnhighlightMethodInfo
    ResolveWebViewMethod "draw" o = Gtk.Widget.WidgetDrawMethodInfo
    ResolveWebViewMethod "ensureStyle" o = Gtk.Widget.WidgetEnsureStyleMethodInfo
    ResolveWebViewMethod "errorBell" o = Gtk.Widget.WidgetErrorBellMethodInfo
    ResolveWebViewMethod "event" o = Gtk.Widget.WidgetEventMethodInfo
    ResolveWebViewMethod "executeEditingCommand" o = WebViewExecuteEditingCommandMethodInfo
    ResolveWebViewMethod "executeEditingCommandWithArgument" o = WebViewExecuteEditingCommandWithArgumentMethodInfo
    ResolveWebViewMethod "forall" o = Gtk.Container.ContainerForallMethodInfo
    ResolveWebViewMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveWebViewMethod "foreach" o = Gtk.Container.ContainerForeachMethodInfo
    ResolveWebViewMethod "freezeChildNotify" o = Gtk.Widget.WidgetFreezeChildNotifyMethodInfo
    ResolveWebViewMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveWebViewMethod "goBack" o = WebViewGoBackMethodInfo
    ResolveWebViewMethod "goForward" o = WebViewGoForwardMethodInfo
    ResolveWebViewMethod "goToBackForwardListItem" o = WebViewGoToBackForwardListItemMethodInfo
    ResolveWebViewMethod "grabAdd" o = Gtk.Widget.WidgetGrabAddMethodInfo
    ResolveWebViewMethod "grabDefault" o = Gtk.Widget.WidgetGrabDefaultMethodInfo
    ResolveWebViewMethod "grabFocus" o = Gtk.Widget.WidgetGrabFocusMethodInfo
    ResolveWebViewMethod "grabRemove" o = Gtk.Widget.WidgetGrabRemoveMethodInfo
    ResolveWebViewMethod "hasDefault" o = Gtk.Widget.WidgetHasDefaultMethodInfo
    ResolveWebViewMethod "hasFocus" o = Gtk.Widget.WidgetHasFocusMethodInfo
    ResolveWebViewMethod "hasGrab" o = Gtk.Widget.WidgetHasGrabMethodInfo
    ResolveWebViewMethod "hasRcStyle" o = Gtk.Widget.WidgetHasRcStyleMethodInfo
    ResolveWebViewMethod "hasScreen" o = Gtk.Widget.WidgetHasScreenMethodInfo
    ResolveWebViewMethod "hasVisibleFocus" o = Gtk.Widget.WidgetHasVisibleFocusMethodInfo
    ResolveWebViewMethod "hide" o = Gtk.Widget.WidgetHideMethodInfo
    ResolveWebViewMethod "hideOnDelete" o = Gtk.Widget.WidgetHideOnDeleteMethodInfo
    ResolveWebViewMethod "inDestruction" o = Gtk.Widget.WidgetInDestructionMethodInfo
    ResolveWebViewMethod "initTemplate" o = Gtk.Widget.WidgetInitTemplateMethodInfo
    ResolveWebViewMethod "inputShapeCombineRegion" o = Gtk.Widget.WidgetInputShapeCombineRegionMethodInfo
    ResolveWebViewMethod "insertActionGroup" o = Gtk.Widget.WidgetInsertActionGroupMethodInfo
    ResolveWebViewMethod "intersect" o = Gtk.Widget.WidgetIntersectMethodInfo
    ResolveWebViewMethod "isAncestor" o = Gtk.Widget.WidgetIsAncestorMethodInfo
    ResolveWebViewMethod "isComposited" o = Gtk.Widget.WidgetIsCompositedMethodInfo
    ResolveWebViewMethod "isDrawable" o = Gtk.Widget.WidgetIsDrawableMethodInfo
    ResolveWebViewMethod "isEditable" o = WebViewIsEditableMethodInfo
    ResolveWebViewMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveWebViewMethod "isFocus" o = Gtk.Widget.WidgetIsFocusMethodInfo
    ResolveWebViewMethod "isLoading" o = WebViewIsLoadingMethodInfo
    ResolveWebViewMethod "isPlayingAudio" o = WebViewIsPlayingAudioMethodInfo
    ResolveWebViewMethod "isSensitive" o = Gtk.Widget.WidgetIsSensitiveMethodInfo
    ResolveWebViewMethod "isToplevel" o = Gtk.Widget.WidgetIsToplevelMethodInfo
    ResolveWebViewMethod "isVisible" o = Gtk.Widget.WidgetIsVisibleMethodInfo
    ResolveWebViewMethod "keynavFailed" o = Gtk.Widget.WidgetKeynavFailedMethodInfo
    ResolveWebViewMethod "listAccelClosures" o = Gtk.Widget.WidgetListAccelClosuresMethodInfo
    ResolveWebViewMethod "listActionPrefixes" o = Gtk.Widget.WidgetListActionPrefixesMethodInfo
    ResolveWebViewMethod "listMnemonicLabels" o = Gtk.Widget.WidgetListMnemonicLabelsMethodInfo
    ResolveWebViewMethod "loadAlternateHtml" o = WebViewLoadAlternateHtmlMethodInfo
    ResolveWebViewMethod "loadBytes" o = WebViewLoadBytesMethodInfo
    ResolveWebViewMethod "loadHtml" o = WebViewLoadHtmlMethodInfo
    ResolveWebViewMethod "loadPlainText" o = WebViewLoadPlainTextMethodInfo
    ResolveWebViewMethod "loadRequest" o = WebViewLoadRequestMethodInfo
    ResolveWebViewMethod "loadUri" o = WebViewLoadUriMethodInfo
    ResolveWebViewMethod "map" o = Gtk.Widget.WidgetMapMethodInfo
    ResolveWebViewMethod "mnemonicActivate" o = Gtk.Widget.WidgetMnemonicActivateMethodInfo
    ResolveWebViewMethod "modifyBase" o = Gtk.Widget.WidgetModifyBaseMethodInfo
    ResolveWebViewMethod "modifyBg" o = Gtk.Widget.WidgetModifyBgMethodInfo
    ResolveWebViewMethod "modifyCursor" o = Gtk.Widget.WidgetModifyCursorMethodInfo
    ResolveWebViewMethod "modifyFg" o = Gtk.Widget.WidgetModifyFgMethodInfo
    ResolveWebViewMethod "modifyFont" o = Gtk.Widget.WidgetModifyFontMethodInfo
    ResolveWebViewMethod "modifyStyle" o = Gtk.Widget.WidgetModifyStyleMethodInfo
    ResolveWebViewMethod "modifyText" o = Gtk.Widget.WidgetModifyTextMethodInfo
    ResolveWebViewMethod "newWithRelatedView" o = WebViewNewWithRelatedViewMethodInfo
    ResolveWebViewMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveWebViewMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveWebViewMethod "overrideBackgroundColor" o = Gtk.Widget.WidgetOverrideBackgroundColorMethodInfo
    ResolveWebViewMethod "overrideColor" o = Gtk.Widget.WidgetOverrideColorMethodInfo
    ResolveWebViewMethod "overrideCursor" o = Gtk.Widget.WidgetOverrideCursorMethodInfo
    ResolveWebViewMethod "overrideFont" o = Gtk.Widget.WidgetOverrideFontMethodInfo
    ResolveWebViewMethod "overrideSymbolicColor" o = Gtk.Widget.WidgetOverrideSymbolicColorMethodInfo
    ResolveWebViewMethod "parserFinished" o = Gtk.Buildable.BuildableParserFinishedMethodInfo
    ResolveWebViewMethod "path" o = Gtk.Widget.WidgetPathMethodInfo
    ResolveWebViewMethod "propagateDraw" o = Gtk.Container.ContainerPropagateDrawMethodInfo
    ResolveWebViewMethod "queueAllocate" o = Gtk.Widget.WidgetQueueAllocateMethodInfo
    ResolveWebViewMethod "queueComputeExpand" o = Gtk.Widget.WidgetQueueComputeExpandMethodInfo
    ResolveWebViewMethod "queueDraw" o = Gtk.Widget.WidgetQueueDrawMethodInfo
    ResolveWebViewMethod "queueDrawArea" o = Gtk.Widget.WidgetQueueDrawAreaMethodInfo
    ResolveWebViewMethod "queueDrawRegion" o = Gtk.Widget.WidgetQueueDrawRegionMethodInfo
    ResolveWebViewMethod "queueResize" o = Gtk.Widget.WidgetQueueResizeMethodInfo
    ResolveWebViewMethod "queueResizeNoRedraw" o = Gtk.Widget.WidgetQueueResizeNoRedrawMethodInfo
    ResolveWebViewMethod "realize" o = Gtk.Widget.WidgetRealizeMethodInfo
    ResolveWebViewMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveWebViewMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveWebViewMethod "regionIntersect" o = Gtk.Widget.WidgetRegionIntersectMethodInfo
    ResolveWebViewMethod "registerWindow" o = Gtk.Widget.WidgetRegisterWindowMethodInfo
    ResolveWebViewMethod "reload" o = WebViewReloadMethodInfo
    ResolveWebViewMethod "reloadBypassCache" o = WebViewReloadBypassCacheMethodInfo
    ResolveWebViewMethod "remove" o = Gtk.Container.ContainerRemoveMethodInfo
    ResolveWebViewMethod "removeAccelerator" o = Gtk.Widget.WidgetRemoveAcceleratorMethodInfo
    ResolveWebViewMethod "removeMnemonicLabel" o = Gtk.Widget.WidgetRemoveMnemonicLabelMethodInfo
    ResolveWebViewMethod "removeTickCallback" o = Gtk.Widget.WidgetRemoveTickCallbackMethodInfo
    ResolveWebViewMethod "renderIcon" o = Gtk.Widget.WidgetRenderIconMethodInfo
    ResolveWebViewMethod "renderIconPixbuf" o = Gtk.Widget.WidgetRenderIconPixbufMethodInfo
    ResolveWebViewMethod "reparent" o = Gtk.Widget.WidgetReparentMethodInfo
    ResolveWebViewMethod "replaceData" o = GObject.Object.ObjectReplaceDataMethodInfo
    ResolveWebViewMethod "replaceQdata" o = GObject.Object.ObjectReplaceQdataMethodInfo
    ResolveWebViewMethod "resetRcStyles" o = Gtk.Widget.WidgetResetRcStylesMethodInfo
    ResolveWebViewMethod "resetStyle" o = Gtk.Widget.WidgetResetStyleMethodInfo
    ResolveWebViewMethod "resizeChildren" o = Gtk.Container.ContainerResizeChildrenMethodInfo
    ResolveWebViewMethod "restoreSessionState" o = WebViewRestoreSessionStateMethodInfo
    ResolveWebViewMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveWebViewMethod "runJavascript" o = WebViewRunJavascriptMethodInfo
    ResolveWebViewMethod "runJavascriptFinish" o = WebViewRunJavascriptFinishMethodInfo
    ResolveWebViewMethod "runJavascriptFromGresource" o = WebViewRunJavascriptFromGresourceMethodInfo
    ResolveWebViewMethod "runJavascriptFromGresourceFinish" o = WebViewRunJavascriptFromGresourceFinishMethodInfo
    ResolveWebViewMethod "save" o = WebViewSaveMethodInfo
    ResolveWebViewMethod "saveFinish" o = WebViewSaveFinishMethodInfo
    ResolveWebViewMethod "saveToFile" o = WebViewSaveToFileMethodInfo
    ResolveWebViewMethod "saveToFileFinish" o = WebViewSaveToFileFinishMethodInfo
    ResolveWebViewMethod "sendExpose" o = Gtk.Widget.WidgetSendExposeMethodInfo
    ResolveWebViewMethod "sendFocusChange" o = Gtk.Widget.WidgetSendFocusChangeMethodInfo
    ResolveWebViewMethod "shapeCombineRegion" o = Gtk.Widget.WidgetShapeCombineRegionMethodInfo
    ResolveWebViewMethod "show" o = Gtk.Widget.WidgetShowMethodInfo
    ResolveWebViewMethod "showAll" o = Gtk.Widget.WidgetShowAllMethodInfo
    ResolveWebViewMethod "showNow" o = Gtk.Widget.WidgetShowNowMethodInfo
    ResolveWebViewMethod "sizeAllocate" o = Gtk.Widget.WidgetSizeAllocateMethodInfo
    ResolveWebViewMethod "sizeAllocateWithBaseline" o = Gtk.Widget.WidgetSizeAllocateWithBaselineMethodInfo
    ResolveWebViewMethod "sizeRequest" o = Gtk.Widget.WidgetSizeRequestMethodInfo
    ResolveWebViewMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveWebViewMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveWebViewMethod "stopLoading" o = WebViewStopLoadingMethodInfo
    ResolveWebViewMethod "styleAttach" o = Gtk.Widget.WidgetStyleAttachMethodInfo
    ResolveWebViewMethod "styleGetProperty" o = Gtk.Widget.WidgetStyleGetPropertyMethodInfo
    ResolveWebViewMethod "thawChildNotify" o = Gtk.Widget.WidgetThawChildNotifyMethodInfo
    ResolveWebViewMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveWebViewMethod "translateCoordinates" o = Gtk.Widget.WidgetTranslateCoordinatesMethodInfo
    ResolveWebViewMethod "triggerTooltipQuery" o = Gtk.Widget.WidgetTriggerTooltipQueryMethodInfo
    ResolveWebViewMethod "tryClose" o = WebViewTryCloseMethodInfo
    ResolveWebViewMethod "unmap" o = Gtk.Widget.WidgetUnmapMethodInfo
    ResolveWebViewMethod "unparent" o = Gtk.Widget.WidgetUnparentMethodInfo
    ResolveWebViewMethod "unrealize" o = Gtk.Widget.WidgetUnrealizeMethodInfo
    ResolveWebViewMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveWebViewMethod "unregisterWindow" o = Gtk.Widget.WidgetUnregisterWindowMethodInfo
    ResolveWebViewMethod "unsetFocusChain" o = Gtk.Container.ContainerUnsetFocusChainMethodInfo
    ResolveWebViewMethod "unsetStateFlags" o = Gtk.Widget.WidgetUnsetStateFlagsMethodInfo
    ResolveWebViewMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveWebViewMethod "getAccessible" o = Gtk.Widget.WidgetGetAccessibleMethodInfo
    ResolveWebViewMethod "getActionGroup" o = Gtk.Widget.WidgetGetActionGroupMethodInfo
    ResolveWebViewMethod "getAllocatedBaseline" o = Gtk.Widget.WidgetGetAllocatedBaselineMethodInfo
    ResolveWebViewMethod "getAllocatedHeight" o = Gtk.Widget.WidgetGetAllocatedHeightMethodInfo
    ResolveWebViewMethod "getAllocatedSize" o = Gtk.Widget.WidgetGetAllocatedSizeMethodInfo
    ResolveWebViewMethod "getAllocatedWidth" o = Gtk.Widget.WidgetGetAllocatedWidthMethodInfo
    ResolveWebViewMethod "getAllocation" o = Gtk.Widget.WidgetGetAllocationMethodInfo
    ResolveWebViewMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo
    ResolveWebViewMethod "getAppPaintable" o = Gtk.Widget.WidgetGetAppPaintableMethodInfo
    ResolveWebViewMethod "getBackForwardList" o = WebViewGetBackForwardListMethodInfo
    ResolveWebViewMethod "getBackgroundColor" o = WebViewGetBackgroundColorMethodInfo
    ResolveWebViewMethod "getBorderWidth" o = Gtk.Container.ContainerGetBorderWidthMethodInfo
    ResolveWebViewMethod "getCanDefault" o = Gtk.Widget.WidgetGetCanDefaultMethodInfo
    ResolveWebViewMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo
    ResolveWebViewMethod "getChildRequisition" o = Gtk.Widget.WidgetGetChildRequisitionMethodInfo
    ResolveWebViewMethod "getChildVisible" o = Gtk.Widget.WidgetGetChildVisibleMethodInfo
    ResolveWebViewMethod "getChildren" o = Gtk.Container.ContainerGetChildrenMethodInfo
    ResolveWebViewMethod "getClip" o = Gtk.Widget.WidgetGetClipMethodInfo
    ResolveWebViewMethod "getClipboard" o = Gtk.Widget.WidgetGetClipboardMethodInfo
    ResolveWebViewMethod "getCompositeName" o = Gtk.Widget.WidgetGetCompositeNameMethodInfo
    ResolveWebViewMethod "getContext" o = WebViewGetContextMethodInfo
    ResolveWebViewMethod "getCustomCharset" o = WebViewGetCustomCharsetMethodInfo
    ResolveWebViewMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveWebViewMethod "getDeviceEnabled" o = Gtk.Widget.WidgetGetDeviceEnabledMethodInfo
    ResolveWebViewMethod "getDeviceEvents" o = Gtk.Widget.WidgetGetDeviceEventsMethodInfo
    ResolveWebViewMethod "getDirection" o = Gtk.Widget.WidgetGetDirectionMethodInfo
    ResolveWebViewMethod "getDisplay" o = Gtk.Widget.WidgetGetDisplayMethodInfo
    ResolveWebViewMethod "getDoubleBuffered" o = Gtk.Widget.WidgetGetDoubleBufferedMethodInfo
    ResolveWebViewMethod "getEditorState" o = WebViewGetEditorStateMethodInfo
    ResolveWebViewMethod "getEstimatedLoadProgress" o = WebViewGetEstimatedLoadProgressMethodInfo
    ResolveWebViewMethod "getEvents" o = Gtk.Widget.WidgetGetEventsMethodInfo
    ResolveWebViewMethod "getFavicon" o = WebViewGetFaviconMethodInfo
    ResolveWebViewMethod "getFindController" o = WebViewGetFindControllerMethodInfo
    ResolveWebViewMethod "getFocusChain" o = Gtk.Container.ContainerGetFocusChainMethodInfo
    ResolveWebViewMethod "getFocusChild" o = Gtk.Container.ContainerGetFocusChildMethodInfo
    ResolveWebViewMethod "getFocusHadjustment" o = Gtk.Container.ContainerGetFocusHadjustmentMethodInfo
    ResolveWebViewMethod "getFocusOnClick" o = Gtk.Widget.WidgetGetFocusOnClickMethodInfo
    ResolveWebViewMethod "getFocusVadjustment" o = Gtk.Container.ContainerGetFocusVadjustmentMethodInfo
    ResolveWebViewMethod "getFontMap" o = Gtk.Widget.WidgetGetFontMapMethodInfo
    ResolveWebViewMethod "getFontOptions" o = Gtk.Widget.WidgetGetFontOptionsMethodInfo
    ResolveWebViewMethod "getFrameClock" o = Gtk.Widget.WidgetGetFrameClockMethodInfo
    ResolveWebViewMethod "getHalign" o = Gtk.Widget.WidgetGetHalignMethodInfo
    ResolveWebViewMethod "getHasTooltip" o = Gtk.Widget.WidgetGetHasTooltipMethodInfo
    ResolveWebViewMethod "getHasWindow" o = Gtk.Widget.WidgetGetHasWindowMethodInfo
    ResolveWebViewMethod "getHexpand" o = Gtk.Widget.WidgetGetHexpandMethodInfo
    ResolveWebViewMethod "getHexpandSet" o = Gtk.Widget.WidgetGetHexpandSetMethodInfo
    ResolveWebViewMethod "getInspector" o = WebViewGetInspectorMethodInfo
    ResolveWebViewMethod "getInternalChild" o = Gtk.Buildable.BuildableGetInternalChildMethodInfo
    ResolveWebViewMethod "getJavascriptGlobalContext" o = WebViewGetJavascriptGlobalContextMethodInfo
    ResolveWebViewMethod "getMainResource" o = WebViewGetMainResourceMethodInfo
    ResolveWebViewMethod "getMapped" o = Gtk.Widget.WidgetGetMappedMethodInfo
    ResolveWebViewMethod "getMarginBottom" o = Gtk.Widget.WidgetGetMarginBottomMethodInfo
    ResolveWebViewMethod "getMarginEnd" o = Gtk.Widget.WidgetGetMarginEndMethodInfo
    ResolveWebViewMethod "getMarginLeft" o = Gtk.Widget.WidgetGetMarginLeftMethodInfo
    ResolveWebViewMethod "getMarginRight" o = Gtk.Widget.WidgetGetMarginRightMethodInfo
    ResolveWebViewMethod "getMarginStart" o = Gtk.Widget.WidgetGetMarginStartMethodInfo
    ResolveWebViewMethod "getMarginTop" o = Gtk.Widget.WidgetGetMarginTopMethodInfo
    ResolveWebViewMethod "getModifierMask" o = Gtk.Widget.WidgetGetModifierMaskMethodInfo
    ResolveWebViewMethod "getModifierStyle" o = Gtk.Widget.WidgetGetModifierStyleMethodInfo
    ResolveWebViewMethod "getName" o = Gtk.Widget.WidgetGetNameMethodInfo
    ResolveWebViewMethod "getNoShowAll" o = Gtk.Widget.WidgetGetNoShowAllMethodInfo
    ResolveWebViewMethod "getOpacity" o = Gtk.Widget.WidgetGetOpacityMethodInfo
    ResolveWebViewMethod "getPageId" o = WebViewGetPageIdMethodInfo
    ResolveWebViewMethod "getPangoContext" o = Gtk.Widget.WidgetGetPangoContextMethodInfo
    ResolveWebViewMethod "getParent" o = Gtk.Widget.WidgetGetParentMethodInfo
    ResolveWebViewMethod "getParentWindow" o = Gtk.Widget.WidgetGetParentWindowMethodInfo
    ResolveWebViewMethod "getPath" o = Gtk.Widget.WidgetGetPathMethodInfo
    ResolveWebViewMethod "getPathForChild" o = Gtk.Container.ContainerGetPathForChildMethodInfo
    ResolveWebViewMethod "getPointer" o = Gtk.Widget.WidgetGetPointerMethodInfo
    ResolveWebViewMethod "getPreferredHeight" o = Gtk.Widget.WidgetGetPreferredHeightMethodInfo
    ResolveWebViewMethod "getPreferredHeightAndBaselineForWidth" o = Gtk.Widget.WidgetGetPreferredHeightAndBaselineForWidthMethodInfo
    ResolveWebViewMethod "getPreferredHeightForWidth" o = Gtk.Widget.WidgetGetPreferredHeightForWidthMethodInfo
    ResolveWebViewMethod "getPreferredSize" o = Gtk.Widget.WidgetGetPreferredSizeMethodInfo
    ResolveWebViewMethod "getPreferredWidth" o = Gtk.Widget.WidgetGetPreferredWidthMethodInfo
    ResolveWebViewMethod "getPreferredWidthForHeight" o = Gtk.Widget.WidgetGetPreferredWidthForHeightMethodInfo
    ResolveWebViewMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveWebViewMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveWebViewMethod "getRealized" o = Gtk.Widget.WidgetGetRealizedMethodInfo
    ResolveWebViewMethod "getReceivesDefault" o = Gtk.Widget.WidgetGetReceivesDefaultMethodInfo
    ResolveWebViewMethod "getRequestMode" o = Gtk.Widget.WidgetGetRequestModeMethodInfo
    ResolveWebViewMethod "getRequisition" o = Gtk.Widget.WidgetGetRequisitionMethodInfo
    ResolveWebViewMethod "getResizeMode" o = Gtk.Container.ContainerGetResizeModeMethodInfo
    ResolveWebViewMethod "getRootWindow" o = Gtk.Widget.WidgetGetRootWindowMethodInfo
    ResolveWebViewMethod "getScaleFactor" o = Gtk.Widget.WidgetGetScaleFactorMethodInfo
    ResolveWebViewMethod "getScreen" o = Gtk.Widget.WidgetGetScreenMethodInfo
    ResolveWebViewMethod "getSensitive" o = Gtk.Widget.WidgetGetSensitiveMethodInfo
    ResolveWebViewMethod "getSessionState" o = WebViewGetSessionStateMethodInfo
    ResolveWebViewMethod "getSettings" o = WebViewGetSettingsMethodInfo
    ResolveWebViewMethod "getSizeRequest" o = Gtk.Widget.WidgetGetSizeRequestMethodInfo
    ResolveWebViewMethod "getSnapshot" o = WebViewGetSnapshotMethodInfo
    ResolveWebViewMethod "getSnapshotFinish" o = WebViewGetSnapshotFinishMethodInfo
    ResolveWebViewMethod "getState" o = Gtk.Widget.WidgetGetStateMethodInfo
    ResolveWebViewMethod "getStateFlags" o = Gtk.Widget.WidgetGetStateFlagsMethodInfo
    ResolveWebViewMethod "getStyle" o = Gtk.Widget.WidgetGetStyleMethodInfo
    ResolveWebViewMethod "getStyleContext" o = Gtk.Widget.WidgetGetStyleContextMethodInfo
    ResolveWebViewMethod "getSupportMultidevice" o = Gtk.Widget.WidgetGetSupportMultideviceMethodInfo
    ResolveWebViewMethod "getTemplateChild" o = Gtk.Widget.WidgetGetTemplateChildMethodInfo
    ResolveWebViewMethod "getTitle" o = WebViewGetTitleMethodInfo
    ResolveWebViewMethod "getTlsInfo" o = WebViewGetTlsInfoMethodInfo
    ResolveWebViewMethod "getTooltipMarkup" o = Gtk.Widget.WidgetGetTooltipMarkupMethodInfo
    ResolveWebViewMethod "getTooltipText" o = Gtk.Widget.WidgetGetTooltipTextMethodInfo
    ResolveWebViewMethod "getTooltipWindow" o = Gtk.Widget.WidgetGetTooltipWindowMethodInfo
    ResolveWebViewMethod "getToplevel" o = Gtk.Widget.WidgetGetToplevelMethodInfo
    ResolveWebViewMethod "getUri" o = WebViewGetUriMethodInfo
    ResolveWebViewMethod "getUserContentManager" o = WebViewGetUserContentManagerMethodInfo
    ResolveWebViewMethod "getValign" o = Gtk.Widget.WidgetGetValignMethodInfo
    ResolveWebViewMethod "getValignWithBaseline" o = Gtk.Widget.WidgetGetValignWithBaselineMethodInfo
    ResolveWebViewMethod "getVexpand" o = Gtk.Widget.WidgetGetVexpandMethodInfo
    ResolveWebViewMethod "getVexpandSet" o = Gtk.Widget.WidgetGetVexpandSetMethodInfo
    ResolveWebViewMethod "getVisible" o = Gtk.Widget.WidgetGetVisibleMethodInfo
    ResolveWebViewMethod "getVisual" o = Gtk.Widget.WidgetGetVisualMethodInfo
    ResolveWebViewMethod "getWindow" o = Gtk.Widget.WidgetGetWindowMethodInfo
    ResolveWebViewMethod "getWindowProperties" o = WebViewGetWindowPropertiesMethodInfo
    ResolveWebViewMethod "getZoomLevel" o = WebViewGetZoomLevelMethodInfo
    ResolveWebViewMethod "setAccelPath" o = Gtk.Widget.WidgetSetAccelPathMethodInfo
    ResolveWebViewMethod "setAllocation" o = Gtk.Widget.WidgetSetAllocationMethodInfo
    ResolveWebViewMethod "setAppPaintable" o = Gtk.Widget.WidgetSetAppPaintableMethodInfo
    ResolveWebViewMethod "setBackgroundColor" o = WebViewSetBackgroundColorMethodInfo
    ResolveWebViewMethod "setBorderWidth" o = Gtk.Container.ContainerSetBorderWidthMethodInfo
    ResolveWebViewMethod "setBuildableProperty" o = Gtk.Buildable.BuildableSetBuildablePropertyMethodInfo
    ResolveWebViewMethod "setCanDefault" o = Gtk.Widget.WidgetSetCanDefaultMethodInfo
    ResolveWebViewMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo
    ResolveWebViewMethod "setChildVisible" o = Gtk.Widget.WidgetSetChildVisibleMethodInfo
    ResolveWebViewMethod "setClip" o = Gtk.Widget.WidgetSetClipMethodInfo
    ResolveWebViewMethod "setCompositeName" o = Gtk.Widget.WidgetSetCompositeNameMethodInfo
    ResolveWebViewMethod "setCustomCharset" o = WebViewSetCustomCharsetMethodInfo
    ResolveWebViewMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveWebViewMethod "setDeviceEnabled" o = Gtk.Widget.WidgetSetDeviceEnabledMethodInfo
    ResolveWebViewMethod "setDeviceEvents" o = Gtk.Widget.WidgetSetDeviceEventsMethodInfo
    ResolveWebViewMethod "setDirection" o = Gtk.Widget.WidgetSetDirectionMethodInfo
    ResolveWebViewMethod "setDoubleBuffered" o = Gtk.Widget.WidgetSetDoubleBufferedMethodInfo
    ResolveWebViewMethod "setEditable" o = WebViewSetEditableMethodInfo
    ResolveWebViewMethod "setEvents" o = Gtk.Widget.WidgetSetEventsMethodInfo
    ResolveWebViewMethod "setFocusChain" o = Gtk.Container.ContainerSetFocusChainMethodInfo
    ResolveWebViewMethod "setFocusChild" o = Gtk.Container.ContainerSetFocusChildMethodInfo
    ResolveWebViewMethod "setFocusHadjustment" o = Gtk.Container.ContainerSetFocusHadjustmentMethodInfo
    ResolveWebViewMethod "setFocusOnClick" o = Gtk.Widget.WidgetSetFocusOnClickMethodInfo
    ResolveWebViewMethod "setFocusVadjustment" o = Gtk.Container.ContainerSetFocusVadjustmentMethodInfo
    ResolveWebViewMethod "setFontMap" o = Gtk.Widget.WidgetSetFontMapMethodInfo
    ResolveWebViewMethod "setFontOptions" o = Gtk.Widget.WidgetSetFontOptionsMethodInfo
    ResolveWebViewMethod "setHalign" o = Gtk.Widget.WidgetSetHalignMethodInfo
    ResolveWebViewMethod "setHasTooltip" o = Gtk.Widget.WidgetSetHasTooltipMethodInfo
    ResolveWebViewMethod "setHasWindow" o = Gtk.Widget.WidgetSetHasWindowMethodInfo
    ResolveWebViewMethod "setHexpand" o = Gtk.Widget.WidgetSetHexpandMethodInfo
    ResolveWebViewMethod "setHexpandSet" o = Gtk.Widget.WidgetSetHexpandSetMethodInfo
    ResolveWebViewMethod "setMapped" o = Gtk.Widget.WidgetSetMappedMethodInfo
    ResolveWebViewMethod "setMarginBottom" o = Gtk.Widget.WidgetSetMarginBottomMethodInfo
    ResolveWebViewMethod "setMarginEnd" o = Gtk.Widget.WidgetSetMarginEndMethodInfo
    ResolveWebViewMethod "setMarginLeft" o = Gtk.Widget.WidgetSetMarginLeftMethodInfo
    ResolveWebViewMethod "setMarginRight" o = Gtk.Widget.WidgetSetMarginRightMethodInfo
    ResolveWebViewMethod "setMarginStart" o = Gtk.Widget.WidgetSetMarginStartMethodInfo
    ResolveWebViewMethod "setMarginTop" o = Gtk.Widget.WidgetSetMarginTopMethodInfo
    ResolveWebViewMethod "setName" o = Gtk.Widget.WidgetSetNameMethodInfo
    ResolveWebViewMethod "setNoShowAll" o = Gtk.Widget.WidgetSetNoShowAllMethodInfo
    ResolveWebViewMethod "setOpacity" o = Gtk.Widget.WidgetSetOpacityMethodInfo
    ResolveWebViewMethod "setParent" o = Gtk.Widget.WidgetSetParentMethodInfo
    ResolveWebViewMethod "setParentWindow" o = Gtk.Widget.WidgetSetParentWindowMethodInfo
    ResolveWebViewMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveWebViewMethod "setRealized" o = Gtk.Widget.WidgetSetRealizedMethodInfo
    ResolveWebViewMethod "setReallocateRedraws" o = Gtk.Container.ContainerSetReallocateRedrawsMethodInfo
    ResolveWebViewMethod "setReceivesDefault" o = Gtk.Widget.WidgetSetReceivesDefaultMethodInfo
    ResolveWebViewMethod "setRedrawOnAllocate" o = Gtk.Widget.WidgetSetRedrawOnAllocateMethodInfo
    ResolveWebViewMethod "setResizeMode" o = Gtk.Container.ContainerSetResizeModeMethodInfo
    ResolveWebViewMethod "setSensitive" o = Gtk.Widget.WidgetSetSensitiveMethodInfo
    ResolveWebViewMethod "setSettings" o = WebViewSetSettingsMethodInfo
    ResolveWebViewMethod "setSizeRequest" o = Gtk.Widget.WidgetSetSizeRequestMethodInfo
    ResolveWebViewMethod "setState" o = Gtk.Widget.WidgetSetStateMethodInfo
    ResolveWebViewMethod "setStateFlags" o = Gtk.Widget.WidgetSetStateFlagsMethodInfo
    ResolveWebViewMethod "setStyle" o = Gtk.Widget.WidgetSetStyleMethodInfo
    ResolveWebViewMethod "setSupportMultidevice" o = Gtk.Widget.WidgetSetSupportMultideviceMethodInfo
    ResolveWebViewMethod "setTooltipMarkup" o = Gtk.Widget.WidgetSetTooltipMarkupMethodInfo
    ResolveWebViewMethod "setTooltipText" o = Gtk.Widget.WidgetSetTooltipTextMethodInfo
    ResolveWebViewMethod "setTooltipWindow" o = Gtk.Widget.WidgetSetTooltipWindowMethodInfo
    ResolveWebViewMethod "setValign" o = Gtk.Widget.WidgetSetValignMethodInfo
    ResolveWebViewMethod "setVexpand" o = Gtk.Widget.WidgetSetVexpandMethodInfo
    ResolveWebViewMethod "setVexpandSet" o = Gtk.Widget.WidgetSetVexpandSetMethodInfo
    ResolveWebViewMethod "setVisible" o = Gtk.Widget.WidgetSetVisibleMethodInfo
    ResolveWebViewMethod "setVisual" o = Gtk.Widget.WidgetSetVisualMethodInfo
    ResolveWebViewMethod "setWindow" o = Gtk.Widget.WidgetSetWindowMethodInfo
    ResolveWebViewMethod "setZoomLevel" o = WebViewSetZoomLevelMethodInfo
    ResolveWebViewMethod l o = O.MethodResolutionFailed l o

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

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

-- signal WebView::authenticate
type WebViewAuthenticateCallback =
    WebKit2.AuthenticationRequest.AuthenticationRequest ->
    IO Bool

noWebViewAuthenticateCallback :: Maybe WebViewAuthenticateCallback
noWebViewAuthenticateCallback = Nothing

type C_WebViewAuthenticateCallback =
    Ptr () ->                               -- object
    Ptr WebKit2.AuthenticationRequest.AuthenticationRequest ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_WebViewAuthenticateCallback :: C_WebViewAuthenticateCallback -> IO (FunPtr C_WebViewAuthenticateCallback)

genClosure_WebViewAuthenticate :: WebViewAuthenticateCallback -> IO Closure
genClosure_WebViewAuthenticate cb = do
    let cb' = wrap_WebViewAuthenticateCallback cb
    mk_WebViewAuthenticateCallback cb' >>= newCClosure


wrap_WebViewAuthenticateCallback ::
    WebViewAuthenticateCallback ->
    Ptr () ->
    Ptr WebKit2.AuthenticationRequest.AuthenticationRequest ->
    Ptr () ->
    IO CInt
wrap_WebViewAuthenticateCallback _cb _ request _ = do
    request' <- (newObject WebKit2.AuthenticationRequest.AuthenticationRequest) request
    result <- _cb  request'
    let result' = (fromIntegral . fromEnum) result
    return result'


onWebViewAuthenticate :: (GObject a, MonadIO m) => a -> WebViewAuthenticateCallback -> m SignalHandlerId
onWebViewAuthenticate obj cb = liftIO $ connectWebViewAuthenticate obj cb SignalConnectBefore
afterWebViewAuthenticate :: (GObject a, MonadIO m) => a -> WebViewAuthenticateCallback -> m SignalHandlerId
afterWebViewAuthenticate obj cb = connectWebViewAuthenticate obj cb SignalConnectAfter

connectWebViewAuthenticate :: (GObject a, MonadIO m) =>
                              a -> WebViewAuthenticateCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewAuthenticate obj cb after = liftIO $ do
    let cb' = wrap_WebViewAuthenticateCallback cb
    cb'' <- mk_WebViewAuthenticateCallback cb'
    connectSignalFunPtr obj "authenticate" cb'' after

-- signal WebView::close
type WebViewCloseCallback =
    IO ()

noWebViewCloseCallback :: Maybe WebViewCloseCallback
noWebViewCloseCallback = Nothing

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

foreign import ccall "wrapper"
    mk_WebViewCloseCallback :: C_WebViewCloseCallback -> IO (FunPtr C_WebViewCloseCallback)

genClosure_WebViewClose :: WebViewCloseCallback -> IO Closure
genClosure_WebViewClose cb = do
    let cb' = wrap_WebViewCloseCallback cb
    mk_WebViewCloseCallback cb' >>= newCClosure


wrap_WebViewCloseCallback ::
    WebViewCloseCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_WebViewCloseCallback _cb _ _ = do
    _cb 


onWebViewClose :: (GObject a, MonadIO m) => a -> WebViewCloseCallback -> m SignalHandlerId
onWebViewClose obj cb = liftIO $ connectWebViewClose obj cb SignalConnectBefore
afterWebViewClose :: (GObject a, MonadIO m) => a -> WebViewCloseCallback -> m SignalHandlerId
afterWebViewClose obj cb = connectWebViewClose obj cb SignalConnectAfter

connectWebViewClose :: (GObject a, MonadIO m) =>
                       a -> WebViewCloseCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewClose obj cb after = liftIO $ do
    let cb' = wrap_WebViewCloseCallback cb
    cb'' <- mk_WebViewCloseCallback cb'
    connectSignalFunPtr obj "close" cb'' after

-- signal WebView::context-menu
type WebViewContextMenuCallback =
    WebKit2.ContextMenu.ContextMenu ->
    Gdk.Event.Event ->
    WebKit2.HitTestResult.HitTestResult ->
    IO Bool

noWebViewContextMenuCallback :: Maybe WebViewContextMenuCallback
noWebViewContextMenuCallback = Nothing

type C_WebViewContextMenuCallback =
    Ptr () ->                               -- object
    Ptr WebKit2.ContextMenu.ContextMenu ->
    Ptr Gdk.Event.Event ->
    Ptr WebKit2.HitTestResult.HitTestResult ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_WebViewContextMenuCallback :: C_WebViewContextMenuCallback -> IO (FunPtr C_WebViewContextMenuCallback)

genClosure_WebViewContextMenu :: WebViewContextMenuCallback -> IO Closure
genClosure_WebViewContextMenu cb = do
    let cb' = wrap_WebViewContextMenuCallback cb
    mk_WebViewContextMenuCallback cb' >>= newCClosure


wrap_WebViewContextMenuCallback ::
    WebViewContextMenuCallback ->
    Ptr () ->
    Ptr WebKit2.ContextMenu.ContextMenu ->
    Ptr Gdk.Event.Event ->
    Ptr WebKit2.HitTestResult.HitTestResult ->
    Ptr () ->
    IO CInt
wrap_WebViewContextMenuCallback _cb _ contextMenu event hitTestResult _ = do
    contextMenu' <- (newObject WebKit2.ContextMenu.ContextMenu) contextMenu
    event' <- (newBoxed Gdk.Event.Event) event
    hitTestResult' <- (newObject WebKit2.HitTestResult.HitTestResult) hitTestResult
    result <- _cb  contextMenu' event' hitTestResult'
    let result' = (fromIntegral . fromEnum) result
    return result'


onWebViewContextMenu :: (GObject a, MonadIO m) => a -> WebViewContextMenuCallback -> m SignalHandlerId
onWebViewContextMenu obj cb = liftIO $ connectWebViewContextMenu obj cb SignalConnectBefore
afterWebViewContextMenu :: (GObject a, MonadIO m) => a -> WebViewContextMenuCallback -> m SignalHandlerId
afterWebViewContextMenu obj cb = connectWebViewContextMenu obj cb SignalConnectAfter

connectWebViewContextMenu :: (GObject a, MonadIO m) =>
                             a -> WebViewContextMenuCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewContextMenu obj cb after = liftIO $ do
    let cb' = wrap_WebViewContextMenuCallback cb
    cb'' <- mk_WebViewContextMenuCallback cb'
    connectSignalFunPtr obj "context-menu" cb'' after

-- signal WebView::context-menu-dismissed
type WebViewContextMenuDismissedCallback =
    IO ()

noWebViewContextMenuDismissedCallback :: Maybe WebViewContextMenuDismissedCallback
noWebViewContextMenuDismissedCallback = Nothing

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

foreign import ccall "wrapper"
    mk_WebViewContextMenuDismissedCallback :: C_WebViewContextMenuDismissedCallback -> IO (FunPtr C_WebViewContextMenuDismissedCallback)

genClosure_WebViewContextMenuDismissed :: WebViewContextMenuDismissedCallback -> IO Closure
genClosure_WebViewContextMenuDismissed cb = do
    let cb' = wrap_WebViewContextMenuDismissedCallback cb
    mk_WebViewContextMenuDismissedCallback cb' >>= newCClosure


wrap_WebViewContextMenuDismissedCallback ::
    WebViewContextMenuDismissedCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_WebViewContextMenuDismissedCallback _cb _ _ = do
    _cb 


onWebViewContextMenuDismissed :: (GObject a, MonadIO m) => a -> WebViewContextMenuDismissedCallback -> m SignalHandlerId
onWebViewContextMenuDismissed obj cb = liftIO $ connectWebViewContextMenuDismissed obj cb SignalConnectBefore
afterWebViewContextMenuDismissed :: (GObject a, MonadIO m) => a -> WebViewContextMenuDismissedCallback -> m SignalHandlerId
afterWebViewContextMenuDismissed obj cb = connectWebViewContextMenuDismissed obj cb SignalConnectAfter

connectWebViewContextMenuDismissed :: (GObject a, MonadIO m) =>
                                      a -> WebViewContextMenuDismissedCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewContextMenuDismissed obj cb after = liftIO $ do
    let cb' = wrap_WebViewContextMenuDismissedCallback cb
    cb'' <- mk_WebViewContextMenuDismissedCallback cb'
    connectSignalFunPtr obj "context-menu-dismissed" cb'' after

-- signal WebView::create
type WebViewCreateCallback =
    WebKit2.NavigationAction.NavigationAction ->
    IO Gtk.Widget.Widget

noWebViewCreateCallback :: Maybe WebViewCreateCallback
noWebViewCreateCallback = Nothing

type C_WebViewCreateCallback =
    Ptr () ->                               -- object
    Ptr WebKit2.NavigationAction.NavigationAction ->
    Ptr () ->                               -- user_data
    IO (Ptr Gtk.Widget.Widget)

foreign import ccall "wrapper"
    mk_WebViewCreateCallback :: C_WebViewCreateCallback -> IO (FunPtr C_WebViewCreateCallback)

genClosure_WebViewCreate :: WebViewCreateCallback -> IO Closure
genClosure_WebViewCreate cb = do
    let cb' = wrap_WebViewCreateCallback cb
    mk_WebViewCreateCallback cb' >>= newCClosure


wrap_WebViewCreateCallback ::
    WebViewCreateCallback ->
    Ptr () ->
    Ptr WebKit2.NavigationAction.NavigationAction ->
    Ptr () ->
    IO (Ptr Gtk.Widget.Widget)
wrap_WebViewCreateCallback _cb _ navigationAction _ = do
    navigationAction' <- (newBoxed WebKit2.NavigationAction.NavigationAction) navigationAction
    result <- _cb  navigationAction'
    result' <- B.ManagedPtr.disownObject result
    return result'


onWebViewCreate :: (GObject a, MonadIO m) => a -> WebViewCreateCallback -> m SignalHandlerId
onWebViewCreate obj cb = liftIO $ connectWebViewCreate obj cb SignalConnectBefore
afterWebViewCreate :: (GObject a, MonadIO m) => a -> WebViewCreateCallback -> m SignalHandlerId
afterWebViewCreate obj cb = connectWebViewCreate obj cb SignalConnectAfter

connectWebViewCreate :: (GObject a, MonadIO m) =>
                        a -> WebViewCreateCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewCreate obj cb after = liftIO $ do
    let cb' = wrap_WebViewCreateCallback cb
    cb'' <- mk_WebViewCreateCallback cb'
    connectSignalFunPtr obj "create" cb'' after

-- signal WebView::decide-policy
type WebViewDecidePolicyCallback =
    WebKit2.PolicyDecision.PolicyDecision ->
    WebKit2.Enums.PolicyDecisionType ->
    IO Bool

noWebViewDecidePolicyCallback :: Maybe WebViewDecidePolicyCallback
noWebViewDecidePolicyCallback = Nothing

type C_WebViewDecidePolicyCallback =
    Ptr () ->                               -- object
    Ptr WebKit2.PolicyDecision.PolicyDecision ->
    CUInt ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_WebViewDecidePolicyCallback :: C_WebViewDecidePolicyCallback -> IO (FunPtr C_WebViewDecidePolicyCallback)

genClosure_WebViewDecidePolicy :: WebViewDecidePolicyCallback -> IO Closure
genClosure_WebViewDecidePolicy cb = do
    let cb' = wrap_WebViewDecidePolicyCallback cb
    mk_WebViewDecidePolicyCallback cb' >>= newCClosure


wrap_WebViewDecidePolicyCallback ::
    WebViewDecidePolicyCallback ->
    Ptr () ->
    Ptr WebKit2.PolicyDecision.PolicyDecision ->
    CUInt ->
    Ptr () ->
    IO CInt
wrap_WebViewDecidePolicyCallback _cb _ decision decisionType _ = do
    decision' <- (newObject WebKit2.PolicyDecision.PolicyDecision) decision
    let decisionType' = (toEnum . fromIntegral) decisionType
    result <- _cb  decision' decisionType'
    let result' = (fromIntegral . fromEnum) result
    return result'


onWebViewDecidePolicy :: (GObject a, MonadIO m) => a -> WebViewDecidePolicyCallback -> m SignalHandlerId
onWebViewDecidePolicy obj cb = liftIO $ connectWebViewDecidePolicy obj cb SignalConnectBefore
afterWebViewDecidePolicy :: (GObject a, MonadIO m) => a -> WebViewDecidePolicyCallback -> m SignalHandlerId
afterWebViewDecidePolicy obj cb = connectWebViewDecidePolicy obj cb SignalConnectAfter

connectWebViewDecidePolicy :: (GObject a, MonadIO m) =>
                              a -> WebViewDecidePolicyCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewDecidePolicy obj cb after = liftIO $ do
    let cb' = wrap_WebViewDecidePolicyCallback cb
    cb'' <- mk_WebViewDecidePolicyCallback cb'
    connectSignalFunPtr obj "decide-policy" cb'' after

-- signal WebView::enter-fullscreen
type WebViewEnterFullscreenCallback =
    IO Bool

noWebViewEnterFullscreenCallback :: Maybe WebViewEnterFullscreenCallback
noWebViewEnterFullscreenCallback = Nothing

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

foreign import ccall "wrapper"
    mk_WebViewEnterFullscreenCallback :: C_WebViewEnterFullscreenCallback -> IO (FunPtr C_WebViewEnterFullscreenCallback)

genClosure_WebViewEnterFullscreen :: WebViewEnterFullscreenCallback -> IO Closure
genClosure_WebViewEnterFullscreen cb = do
    let cb' = wrap_WebViewEnterFullscreenCallback cb
    mk_WebViewEnterFullscreenCallback cb' >>= newCClosure


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


onWebViewEnterFullscreen :: (GObject a, MonadIO m) => a -> WebViewEnterFullscreenCallback -> m SignalHandlerId
onWebViewEnterFullscreen obj cb = liftIO $ connectWebViewEnterFullscreen obj cb SignalConnectBefore
afterWebViewEnterFullscreen :: (GObject a, MonadIO m) => a -> WebViewEnterFullscreenCallback -> m SignalHandlerId
afterWebViewEnterFullscreen obj cb = connectWebViewEnterFullscreen obj cb SignalConnectAfter

connectWebViewEnterFullscreen :: (GObject a, MonadIO m) =>
                                 a -> WebViewEnterFullscreenCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewEnterFullscreen obj cb after = liftIO $ do
    let cb' = wrap_WebViewEnterFullscreenCallback cb
    cb'' <- mk_WebViewEnterFullscreenCallback cb'
    connectSignalFunPtr obj "enter-fullscreen" cb'' after

-- signal WebView::insecure-content-detected
type WebViewInsecureContentDetectedCallback =
    WebKit2.Enums.InsecureContentEvent ->
    IO ()

noWebViewInsecureContentDetectedCallback :: Maybe WebViewInsecureContentDetectedCallback
noWebViewInsecureContentDetectedCallback = Nothing

type C_WebViewInsecureContentDetectedCallback =
    Ptr () ->                               -- object
    CUInt ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_WebViewInsecureContentDetectedCallback :: C_WebViewInsecureContentDetectedCallback -> IO (FunPtr C_WebViewInsecureContentDetectedCallback)

genClosure_WebViewInsecureContentDetected :: WebViewInsecureContentDetectedCallback -> IO Closure
genClosure_WebViewInsecureContentDetected cb = do
    let cb' = wrap_WebViewInsecureContentDetectedCallback cb
    mk_WebViewInsecureContentDetectedCallback cb' >>= newCClosure


wrap_WebViewInsecureContentDetectedCallback ::
    WebViewInsecureContentDetectedCallback ->
    Ptr () ->
    CUInt ->
    Ptr () ->
    IO ()
wrap_WebViewInsecureContentDetectedCallback _cb _ event _ = do
    let event' = (toEnum . fromIntegral) event
    _cb  event'


onWebViewInsecureContentDetected :: (GObject a, MonadIO m) => a -> WebViewInsecureContentDetectedCallback -> m SignalHandlerId
onWebViewInsecureContentDetected obj cb = liftIO $ connectWebViewInsecureContentDetected obj cb SignalConnectBefore
afterWebViewInsecureContentDetected :: (GObject a, MonadIO m) => a -> WebViewInsecureContentDetectedCallback -> m SignalHandlerId
afterWebViewInsecureContentDetected obj cb = connectWebViewInsecureContentDetected obj cb SignalConnectAfter

connectWebViewInsecureContentDetected :: (GObject a, MonadIO m) =>
                                         a -> WebViewInsecureContentDetectedCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewInsecureContentDetected obj cb after = liftIO $ do
    let cb' = wrap_WebViewInsecureContentDetectedCallback cb
    cb'' <- mk_WebViewInsecureContentDetectedCallback cb'
    connectSignalFunPtr obj "insecure-content-detected" cb'' after

-- signal WebView::leave-fullscreen
type WebViewLeaveFullscreenCallback =
    IO Bool

noWebViewLeaveFullscreenCallback :: Maybe WebViewLeaveFullscreenCallback
noWebViewLeaveFullscreenCallback = Nothing

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

foreign import ccall "wrapper"
    mk_WebViewLeaveFullscreenCallback :: C_WebViewLeaveFullscreenCallback -> IO (FunPtr C_WebViewLeaveFullscreenCallback)

genClosure_WebViewLeaveFullscreen :: WebViewLeaveFullscreenCallback -> IO Closure
genClosure_WebViewLeaveFullscreen cb = do
    let cb' = wrap_WebViewLeaveFullscreenCallback cb
    mk_WebViewLeaveFullscreenCallback cb' >>= newCClosure


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


onWebViewLeaveFullscreen :: (GObject a, MonadIO m) => a -> WebViewLeaveFullscreenCallback -> m SignalHandlerId
onWebViewLeaveFullscreen obj cb = liftIO $ connectWebViewLeaveFullscreen obj cb SignalConnectBefore
afterWebViewLeaveFullscreen :: (GObject a, MonadIO m) => a -> WebViewLeaveFullscreenCallback -> m SignalHandlerId
afterWebViewLeaveFullscreen obj cb = connectWebViewLeaveFullscreen obj cb SignalConnectAfter

connectWebViewLeaveFullscreen :: (GObject a, MonadIO m) =>
                                 a -> WebViewLeaveFullscreenCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewLeaveFullscreen obj cb after = liftIO $ do
    let cb' = wrap_WebViewLeaveFullscreenCallback cb
    cb'' <- mk_WebViewLeaveFullscreenCallback cb'
    connectSignalFunPtr obj "leave-fullscreen" cb'' after

-- signal WebView::load-changed
type WebViewLoadChangedCallback =
    WebKit2.Enums.LoadEvent ->
    IO ()

noWebViewLoadChangedCallback :: Maybe WebViewLoadChangedCallback
noWebViewLoadChangedCallback = Nothing

type C_WebViewLoadChangedCallback =
    Ptr () ->                               -- object
    CUInt ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_WebViewLoadChangedCallback :: C_WebViewLoadChangedCallback -> IO (FunPtr C_WebViewLoadChangedCallback)

genClosure_WebViewLoadChanged :: WebViewLoadChangedCallback -> IO Closure
genClosure_WebViewLoadChanged cb = do
    let cb' = wrap_WebViewLoadChangedCallback cb
    mk_WebViewLoadChangedCallback cb' >>= newCClosure


wrap_WebViewLoadChangedCallback ::
    WebViewLoadChangedCallback ->
    Ptr () ->
    CUInt ->
    Ptr () ->
    IO ()
wrap_WebViewLoadChangedCallback _cb _ loadEvent _ = do
    let loadEvent' = (toEnum . fromIntegral) loadEvent
    _cb  loadEvent'


onWebViewLoadChanged :: (GObject a, MonadIO m) => a -> WebViewLoadChangedCallback -> m SignalHandlerId
onWebViewLoadChanged obj cb = liftIO $ connectWebViewLoadChanged obj cb SignalConnectBefore
afterWebViewLoadChanged :: (GObject a, MonadIO m) => a -> WebViewLoadChangedCallback -> m SignalHandlerId
afterWebViewLoadChanged obj cb = connectWebViewLoadChanged obj cb SignalConnectAfter

connectWebViewLoadChanged :: (GObject a, MonadIO m) =>
                             a -> WebViewLoadChangedCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewLoadChanged obj cb after = liftIO $ do
    let cb' = wrap_WebViewLoadChangedCallback cb
    cb'' <- mk_WebViewLoadChangedCallback cb'
    connectSignalFunPtr obj "load-changed" cb'' after

-- signal WebView::load-failed
type WebViewLoadFailedCallback =
    WebKit2.Enums.LoadEvent ->
    T.Text ->
    GError ->
    IO Bool

noWebViewLoadFailedCallback :: Maybe WebViewLoadFailedCallback
noWebViewLoadFailedCallback = Nothing

type C_WebViewLoadFailedCallback =
    Ptr () ->                               -- object
    CUInt ->
    CString ->
    Ptr GError ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_WebViewLoadFailedCallback :: C_WebViewLoadFailedCallback -> IO (FunPtr C_WebViewLoadFailedCallback)

genClosure_WebViewLoadFailed :: WebViewLoadFailedCallback -> IO Closure
genClosure_WebViewLoadFailed cb = do
    let cb' = wrap_WebViewLoadFailedCallback cb
    mk_WebViewLoadFailedCallback cb' >>= newCClosure


wrap_WebViewLoadFailedCallback ::
    WebViewLoadFailedCallback ->
    Ptr () ->
    CUInt ->
    CString ->
    Ptr GError ->
    Ptr () ->
    IO CInt
wrap_WebViewLoadFailedCallback _cb _ loadEvent failingUri error_ _ = do
    let loadEvent' = (toEnum . fromIntegral) loadEvent
    failingUri' <- cstringToText failingUri
    error_' <- (newBoxed GError) error_
    result <- _cb  loadEvent' failingUri' error_'
    let result' = (fromIntegral . fromEnum) result
    return result'


onWebViewLoadFailed :: (GObject a, MonadIO m) => a -> WebViewLoadFailedCallback -> m SignalHandlerId
onWebViewLoadFailed obj cb = liftIO $ connectWebViewLoadFailed obj cb SignalConnectBefore
afterWebViewLoadFailed :: (GObject a, MonadIO m) => a -> WebViewLoadFailedCallback -> m SignalHandlerId
afterWebViewLoadFailed obj cb = connectWebViewLoadFailed obj cb SignalConnectAfter

connectWebViewLoadFailed :: (GObject a, MonadIO m) =>
                            a -> WebViewLoadFailedCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewLoadFailed obj cb after = liftIO $ do
    let cb' = wrap_WebViewLoadFailedCallback cb
    cb'' <- mk_WebViewLoadFailedCallback cb'
    connectSignalFunPtr obj "load-failed" cb'' after

-- signal WebView::load-failed-with-tls-errors
type WebViewLoadFailedWithTlsErrorsCallback =
    T.Text ->
    Gio.TlsCertificate.TlsCertificate ->
    [Gio.Flags.TlsCertificateFlags] ->
    IO Bool

noWebViewLoadFailedWithTlsErrorsCallback :: Maybe WebViewLoadFailedWithTlsErrorsCallback
noWebViewLoadFailedWithTlsErrorsCallback = Nothing

type C_WebViewLoadFailedWithTlsErrorsCallback =
    Ptr () ->                               -- object
    CString ->
    Ptr Gio.TlsCertificate.TlsCertificate ->
    CUInt ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_WebViewLoadFailedWithTlsErrorsCallback :: C_WebViewLoadFailedWithTlsErrorsCallback -> IO (FunPtr C_WebViewLoadFailedWithTlsErrorsCallback)

genClosure_WebViewLoadFailedWithTlsErrors :: WebViewLoadFailedWithTlsErrorsCallback -> IO Closure
genClosure_WebViewLoadFailedWithTlsErrors cb = do
    let cb' = wrap_WebViewLoadFailedWithTlsErrorsCallback cb
    mk_WebViewLoadFailedWithTlsErrorsCallback cb' >>= newCClosure


wrap_WebViewLoadFailedWithTlsErrorsCallback ::
    WebViewLoadFailedWithTlsErrorsCallback ->
    Ptr () ->
    CString ->
    Ptr Gio.TlsCertificate.TlsCertificate ->
    CUInt ->
    Ptr () ->
    IO CInt
wrap_WebViewLoadFailedWithTlsErrorsCallback _cb _ failingUri certificate errors _ = do
    failingUri' <- cstringToText failingUri
    certificate' <- (newObject Gio.TlsCertificate.TlsCertificate) certificate
    let errors' = wordToGFlags errors
    result <- _cb  failingUri' certificate' errors'
    let result' = (fromIntegral . fromEnum) result
    return result'


onWebViewLoadFailedWithTlsErrors :: (GObject a, MonadIO m) => a -> WebViewLoadFailedWithTlsErrorsCallback -> m SignalHandlerId
onWebViewLoadFailedWithTlsErrors obj cb = liftIO $ connectWebViewLoadFailedWithTlsErrors obj cb SignalConnectBefore
afterWebViewLoadFailedWithTlsErrors :: (GObject a, MonadIO m) => a -> WebViewLoadFailedWithTlsErrorsCallback -> m SignalHandlerId
afterWebViewLoadFailedWithTlsErrors obj cb = connectWebViewLoadFailedWithTlsErrors obj cb SignalConnectAfter

connectWebViewLoadFailedWithTlsErrors :: (GObject a, MonadIO m) =>
                                         a -> WebViewLoadFailedWithTlsErrorsCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewLoadFailedWithTlsErrors obj cb after = liftIO $ do
    let cb' = wrap_WebViewLoadFailedWithTlsErrorsCallback cb
    cb'' <- mk_WebViewLoadFailedWithTlsErrorsCallback cb'
    connectSignalFunPtr obj "load-failed-with-tls-errors" cb'' after

-- signal WebView::mouse-target-changed
type WebViewMouseTargetChangedCallback =
    WebKit2.HitTestResult.HitTestResult ->
    Word32 ->
    IO ()

noWebViewMouseTargetChangedCallback :: Maybe WebViewMouseTargetChangedCallback
noWebViewMouseTargetChangedCallback = Nothing

type C_WebViewMouseTargetChangedCallback =
    Ptr () ->                               -- object
    Ptr WebKit2.HitTestResult.HitTestResult ->
    Word32 ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_WebViewMouseTargetChangedCallback :: C_WebViewMouseTargetChangedCallback -> IO (FunPtr C_WebViewMouseTargetChangedCallback)

genClosure_WebViewMouseTargetChanged :: WebViewMouseTargetChangedCallback -> IO Closure
genClosure_WebViewMouseTargetChanged cb = do
    let cb' = wrap_WebViewMouseTargetChangedCallback cb
    mk_WebViewMouseTargetChangedCallback cb' >>= newCClosure


wrap_WebViewMouseTargetChangedCallback ::
    WebViewMouseTargetChangedCallback ->
    Ptr () ->
    Ptr WebKit2.HitTestResult.HitTestResult ->
    Word32 ->
    Ptr () ->
    IO ()
wrap_WebViewMouseTargetChangedCallback _cb _ hitTestResult modifiers _ = do
    hitTestResult' <- (newObject WebKit2.HitTestResult.HitTestResult) hitTestResult
    _cb  hitTestResult' modifiers


onWebViewMouseTargetChanged :: (GObject a, MonadIO m) => a -> WebViewMouseTargetChangedCallback -> m SignalHandlerId
onWebViewMouseTargetChanged obj cb = liftIO $ connectWebViewMouseTargetChanged obj cb SignalConnectBefore
afterWebViewMouseTargetChanged :: (GObject a, MonadIO m) => a -> WebViewMouseTargetChangedCallback -> m SignalHandlerId
afterWebViewMouseTargetChanged obj cb = connectWebViewMouseTargetChanged obj cb SignalConnectAfter

connectWebViewMouseTargetChanged :: (GObject a, MonadIO m) =>
                                    a -> WebViewMouseTargetChangedCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewMouseTargetChanged obj cb after = liftIO $ do
    let cb' = wrap_WebViewMouseTargetChangedCallback cb
    cb'' <- mk_WebViewMouseTargetChangedCallback cb'
    connectSignalFunPtr obj "mouse-target-changed" cb'' after

-- signal WebView::permission-request
type WebViewPermissionRequestCallback =
    WebKit2.PermissionRequest.PermissionRequest ->
    IO Bool

noWebViewPermissionRequestCallback :: Maybe WebViewPermissionRequestCallback
noWebViewPermissionRequestCallback = Nothing

type C_WebViewPermissionRequestCallback =
    Ptr () ->                               -- object
    Ptr WebKit2.PermissionRequest.PermissionRequest ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_WebViewPermissionRequestCallback :: C_WebViewPermissionRequestCallback -> IO (FunPtr C_WebViewPermissionRequestCallback)

genClosure_WebViewPermissionRequest :: WebViewPermissionRequestCallback -> IO Closure
genClosure_WebViewPermissionRequest cb = do
    let cb' = wrap_WebViewPermissionRequestCallback cb
    mk_WebViewPermissionRequestCallback cb' >>= newCClosure


wrap_WebViewPermissionRequestCallback ::
    WebViewPermissionRequestCallback ->
    Ptr () ->
    Ptr WebKit2.PermissionRequest.PermissionRequest ->
    Ptr () ->
    IO CInt
wrap_WebViewPermissionRequestCallback _cb _ request _ = do
    request' <- (newObject WebKit2.PermissionRequest.PermissionRequest) request
    result <- _cb  request'
    let result' = (fromIntegral . fromEnum) result
    return result'


onWebViewPermissionRequest :: (GObject a, MonadIO m) => a -> WebViewPermissionRequestCallback -> m SignalHandlerId
onWebViewPermissionRequest obj cb = liftIO $ connectWebViewPermissionRequest obj cb SignalConnectBefore
afterWebViewPermissionRequest :: (GObject a, MonadIO m) => a -> WebViewPermissionRequestCallback -> m SignalHandlerId
afterWebViewPermissionRequest obj cb = connectWebViewPermissionRequest obj cb SignalConnectAfter

connectWebViewPermissionRequest :: (GObject a, MonadIO m) =>
                                   a -> WebViewPermissionRequestCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewPermissionRequest obj cb after = liftIO $ do
    let cb' = wrap_WebViewPermissionRequestCallback cb
    cb'' <- mk_WebViewPermissionRequestCallback cb'
    connectSignalFunPtr obj "permission-request" cb'' after

-- signal WebView::print
type WebViewPrintCallback =
    WebKit2.PrintOperation.PrintOperation ->
    IO Bool

noWebViewPrintCallback :: Maybe WebViewPrintCallback
noWebViewPrintCallback = Nothing

type C_WebViewPrintCallback =
    Ptr () ->                               -- object
    Ptr WebKit2.PrintOperation.PrintOperation ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_WebViewPrintCallback :: C_WebViewPrintCallback -> IO (FunPtr C_WebViewPrintCallback)

genClosure_WebViewPrint :: WebViewPrintCallback -> IO Closure
genClosure_WebViewPrint cb = do
    let cb' = wrap_WebViewPrintCallback cb
    mk_WebViewPrintCallback cb' >>= newCClosure


wrap_WebViewPrintCallback ::
    WebViewPrintCallback ->
    Ptr () ->
    Ptr WebKit2.PrintOperation.PrintOperation ->
    Ptr () ->
    IO CInt
wrap_WebViewPrintCallback _cb _ printOperation _ = do
    printOperation' <- (newObject WebKit2.PrintOperation.PrintOperation) printOperation
    result <- _cb  printOperation'
    let result' = (fromIntegral . fromEnum) result
    return result'


onWebViewPrint :: (GObject a, MonadIO m) => a -> WebViewPrintCallback -> m SignalHandlerId
onWebViewPrint obj cb = liftIO $ connectWebViewPrint obj cb SignalConnectBefore
afterWebViewPrint :: (GObject a, MonadIO m) => a -> WebViewPrintCallback -> m SignalHandlerId
afterWebViewPrint obj cb = connectWebViewPrint obj cb SignalConnectAfter

connectWebViewPrint :: (GObject a, MonadIO m) =>
                       a -> WebViewPrintCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewPrint obj cb after = liftIO $ do
    let cb' = wrap_WebViewPrintCallback cb
    cb'' <- mk_WebViewPrintCallback cb'
    connectSignalFunPtr obj "print" cb'' after

-- signal WebView::ready-to-show
type WebViewReadyToShowCallback =
    IO ()

noWebViewReadyToShowCallback :: Maybe WebViewReadyToShowCallback
noWebViewReadyToShowCallback = Nothing

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

foreign import ccall "wrapper"
    mk_WebViewReadyToShowCallback :: C_WebViewReadyToShowCallback -> IO (FunPtr C_WebViewReadyToShowCallback)

genClosure_WebViewReadyToShow :: WebViewReadyToShowCallback -> IO Closure
genClosure_WebViewReadyToShow cb = do
    let cb' = wrap_WebViewReadyToShowCallback cb
    mk_WebViewReadyToShowCallback cb' >>= newCClosure


wrap_WebViewReadyToShowCallback ::
    WebViewReadyToShowCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_WebViewReadyToShowCallback _cb _ _ = do
    _cb 


onWebViewReadyToShow :: (GObject a, MonadIO m) => a -> WebViewReadyToShowCallback -> m SignalHandlerId
onWebViewReadyToShow obj cb = liftIO $ connectWebViewReadyToShow obj cb SignalConnectBefore
afterWebViewReadyToShow :: (GObject a, MonadIO m) => a -> WebViewReadyToShowCallback -> m SignalHandlerId
afterWebViewReadyToShow obj cb = connectWebViewReadyToShow obj cb SignalConnectAfter

connectWebViewReadyToShow :: (GObject a, MonadIO m) =>
                             a -> WebViewReadyToShowCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewReadyToShow obj cb after = liftIO $ do
    let cb' = wrap_WebViewReadyToShowCallback cb
    cb'' <- mk_WebViewReadyToShowCallback cb'
    connectSignalFunPtr obj "ready-to-show" cb'' after

-- signal WebView::resource-load-started
type WebViewResourceLoadStartedCallback =
    WebKit2.WebResource.WebResource ->
    WebKit2.URIRequest.URIRequest ->
    IO ()

noWebViewResourceLoadStartedCallback :: Maybe WebViewResourceLoadStartedCallback
noWebViewResourceLoadStartedCallback = Nothing

type C_WebViewResourceLoadStartedCallback =
    Ptr () ->                               -- object
    Ptr WebKit2.WebResource.WebResource ->
    Ptr WebKit2.URIRequest.URIRequest ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_WebViewResourceLoadStartedCallback :: C_WebViewResourceLoadStartedCallback -> IO (FunPtr C_WebViewResourceLoadStartedCallback)

genClosure_WebViewResourceLoadStarted :: WebViewResourceLoadStartedCallback -> IO Closure
genClosure_WebViewResourceLoadStarted cb = do
    let cb' = wrap_WebViewResourceLoadStartedCallback cb
    mk_WebViewResourceLoadStartedCallback cb' >>= newCClosure


wrap_WebViewResourceLoadStartedCallback ::
    WebViewResourceLoadStartedCallback ->
    Ptr () ->
    Ptr WebKit2.WebResource.WebResource ->
    Ptr WebKit2.URIRequest.URIRequest ->
    Ptr () ->
    IO ()
wrap_WebViewResourceLoadStartedCallback _cb _ resource request _ = do
    resource' <- (newObject WebKit2.WebResource.WebResource) resource
    request' <- (newObject WebKit2.URIRequest.URIRequest) request
    _cb  resource' request'


onWebViewResourceLoadStarted :: (GObject a, MonadIO m) => a -> WebViewResourceLoadStartedCallback -> m SignalHandlerId
onWebViewResourceLoadStarted obj cb = liftIO $ connectWebViewResourceLoadStarted obj cb SignalConnectBefore
afterWebViewResourceLoadStarted :: (GObject a, MonadIO m) => a -> WebViewResourceLoadStartedCallback -> m SignalHandlerId
afterWebViewResourceLoadStarted obj cb = connectWebViewResourceLoadStarted obj cb SignalConnectAfter

connectWebViewResourceLoadStarted :: (GObject a, MonadIO m) =>
                                     a -> WebViewResourceLoadStartedCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewResourceLoadStarted obj cb after = liftIO $ do
    let cb' = wrap_WebViewResourceLoadStartedCallback cb
    cb'' <- mk_WebViewResourceLoadStartedCallback cb'
    connectSignalFunPtr obj "resource-load-started" cb'' after

-- signal WebView::run-as-modal
type WebViewRunAsModalCallback =
    IO ()

noWebViewRunAsModalCallback :: Maybe WebViewRunAsModalCallback
noWebViewRunAsModalCallback = Nothing

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

foreign import ccall "wrapper"
    mk_WebViewRunAsModalCallback :: C_WebViewRunAsModalCallback -> IO (FunPtr C_WebViewRunAsModalCallback)

genClosure_WebViewRunAsModal :: WebViewRunAsModalCallback -> IO Closure
genClosure_WebViewRunAsModal cb = do
    let cb' = wrap_WebViewRunAsModalCallback cb
    mk_WebViewRunAsModalCallback cb' >>= newCClosure


wrap_WebViewRunAsModalCallback ::
    WebViewRunAsModalCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_WebViewRunAsModalCallback _cb _ _ = do
    _cb 


onWebViewRunAsModal :: (GObject a, MonadIO m) => a -> WebViewRunAsModalCallback -> m SignalHandlerId
onWebViewRunAsModal obj cb = liftIO $ connectWebViewRunAsModal obj cb SignalConnectBefore
afterWebViewRunAsModal :: (GObject a, MonadIO m) => a -> WebViewRunAsModalCallback -> m SignalHandlerId
afterWebViewRunAsModal obj cb = connectWebViewRunAsModal obj cb SignalConnectAfter

connectWebViewRunAsModal :: (GObject a, MonadIO m) =>
                            a -> WebViewRunAsModalCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewRunAsModal obj cb after = liftIO $ do
    let cb' = wrap_WebViewRunAsModalCallback cb
    cb'' <- mk_WebViewRunAsModalCallback cb'
    connectSignalFunPtr obj "run-as-modal" cb'' after

-- signal WebView::run-color-chooser
type WebViewRunColorChooserCallback =
    WebKit2.ColorChooserRequest.ColorChooserRequest ->
    IO Bool

noWebViewRunColorChooserCallback :: Maybe WebViewRunColorChooserCallback
noWebViewRunColorChooserCallback = Nothing

type C_WebViewRunColorChooserCallback =
    Ptr () ->                               -- object
    Ptr WebKit2.ColorChooserRequest.ColorChooserRequest ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_WebViewRunColorChooserCallback :: C_WebViewRunColorChooserCallback -> IO (FunPtr C_WebViewRunColorChooserCallback)

genClosure_WebViewRunColorChooser :: WebViewRunColorChooserCallback -> IO Closure
genClosure_WebViewRunColorChooser cb = do
    let cb' = wrap_WebViewRunColorChooserCallback cb
    mk_WebViewRunColorChooserCallback cb' >>= newCClosure


wrap_WebViewRunColorChooserCallback ::
    WebViewRunColorChooserCallback ->
    Ptr () ->
    Ptr WebKit2.ColorChooserRequest.ColorChooserRequest ->
    Ptr () ->
    IO CInt
wrap_WebViewRunColorChooserCallback _cb _ request _ = do
    request' <- (newObject WebKit2.ColorChooserRequest.ColorChooserRequest) request
    result <- _cb  request'
    let result' = (fromIntegral . fromEnum) result
    return result'


onWebViewRunColorChooser :: (GObject a, MonadIO m) => a -> WebViewRunColorChooserCallback -> m SignalHandlerId
onWebViewRunColorChooser obj cb = liftIO $ connectWebViewRunColorChooser obj cb SignalConnectBefore
afterWebViewRunColorChooser :: (GObject a, MonadIO m) => a -> WebViewRunColorChooserCallback -> m SignalHandlerId
afterWebViewRunColorChooser obj cb = connectWebViewRunColorChooser obj cb SignalConnectAfter

connectWebViewRunColorChooser :: (GObject a, MonadIO m) =>
                                 a -> WebViewRunColorChooserCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewRunColorChooser obj cb after = liftIO $ do
    let cb' = wrap_WebViewRunColorChooserCallback cb
    cb'' <- mk_WebViewRunColorChooserCallback cb'
    connectSignalFunPtr obj "run-color-chooser" cb'' after

-- signal WebView::run-file-chooser
type WebViewRunFileChooserCallback =
    WebKit2.FileChooserRequest.FileChooserRequest ->
    IO Bool

noWebViewRunFileChooserCallback :: Maybe WebViewRunFileChooserCallback
noWebViewRunFileChooserCallback = Nothing

type C_WebViewRunFileChooserCallback =
    Ptr () ->                               -- object
    Ptr WebKit2.FileChooserRequest.FileChooserRequest ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_WebViewRunFileChooserCallback :: C_WebViewRunFileChooserCallback -> IO (FunPtr C_WebViewRunFileChooserCallback)

genClosure_WebViewRunFileChooser :: WebViewRunFileChooserCallback -> IO Closure
genClosure_WebViewRunFileChooser cb = do
    let cb' = wrap_WebViewRunFileChooserCallback cb
    mk_WebViewRunFileChooserCallback cb' >>= newCClosure


wrap_WebViewRunFileChooserCallback ::
    WebViewRunFileChooserCallback ->
    Ptr () ->
    Ptr WebKit2.FileChooserRequest.FileChooserRequest ->
    Ptr () ->
    IO CInt
wrap_WebViewRunFileChooserCallback _cb _ request _ = do
    request' <- (newObject WebKit2.FileChooserRequest.FileChooserRequest) request
    result <- _cb  request'
    let result' = (fromIntegral . fromEnum) result
    return result'


onWebViewRunFileChooser :: (GObject a, MonadIO m) => a -> WebViewRunFileChooserCallback -> m SignalHandlerId
onWebViewRunFileChooser obj cb = liftIO $ connectWebViewRunFileChooser obj cb SignalConnectBefore
afterWebViewRunFileChooser :: (GObject a, MonadIO m) => a -> WebViewRunFileChooserCallback -> m SignalHandlerId
afterWebViewRunFileChooser obj cb = connectWebViewRunFileChooser obj cb SignalConnectAfter

connectWebViewRunFileChooser :: (GObject a, MonadIO m) =>
                                a -> WebViewRunFileChooserCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewRunFileChooser obj cb after = liftIO $ do
    let cb' = wrap_WebViewRunFileChooserCallback cb
    cb'' <- mk_WebViewRunFileChooserCallback cb'
    connectSignalFunPtr obj "run-file-chooser" cb'' after

-- signal WebView::script-dialog
type WebViewScriptDialogCallback =
    WebKit2.ScriptDialog.ScriptDialog ->
    IO Bool

noWebViewScriptDialogCallback :: Maybe WebViewScriptDialogCallback
noWebViewScriptDialogCallback = Nothing

type C_WebViewScriptDialogCallback =
    Ptr () ->                               -- object
    Ptr WebKit2.ScriptDialog.ScriptDialog ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_WebViewScriptDialogCallback :: C_WebViewScriptDialogCallback -> IO (FunPtr C_WebViewScriptDialogCallback)

genClosure_WebViewScriptDialog :: WebViewScriptDialogCallback -> IO Closure
genClosure_WebViewScriptDialog cb = do
    let cb' = wrap_WebViewScriptDialogCallback cb
    mk_WebViewScriptDialogCallback cb' >>= newCClosure


wrap_WebViewScriptDialogCallback ::
    WebViewScriptDialogCallback ->
    Ptr () ->
    Ptr WebKit2.ScriptDialog.ScriptDialog ->
    Ptr () ->
    IO CInt
wrap_WebViewScriptDialogCallback _cb _ dialog _ = do
    dialog' <- (newBoxed WebKit2.ScriptDialog.ScriptDialog) dialog
    result <- _cb  dialog'
    let result' = (fromIntegral . fromEnum) result
    return result'


onWebViewScriptDialog :: (GObject a, MonadIO m) => a -> WebViewScriptDialogCallback -> m SignalHandlerId
onWebViewScriptDialog obj cb = liftIO $ connectWebViewScriptDialog obj cb SignalConnectBefore
afterWebViewScriptDialog :: (GObject a, MonadIO m) => a -> WebViewScriptDialogCallback -> m SignalHandlerId
afterWebViewScriptDialog obj cb = connectWebViewScriptDialog obj cb SignalConnectAfter

connectWebViewScriptDialog :: (GObject a, MonadIO m) =>
                              a -> WebViewScriptDialogCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewScriptDialog obj cb after = liftIO $ do
    let cb' = wrap_WebViewScriptDialogCallback cb
    cb'' <- mk_WebViewScriptDialogCallback cb'
    connectSignalFunPtr obj "script-dialog" cb'' after

-- signal WebView::show-notification
type WebViewShowNotificationCallback =
    WebKit2.Notification.Notification ->
    IO Bool

noWebViewShowNotificationCallback :: Maybe WebViewShowNotificationCallback
noWebViewShowNotificationCallback = Nothing

type C_WebViewShowNotificationCallback =
    Ptr () ->                               -- object
    Ptr WebKit2.Notification.Notification ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_WebViewShowNotificationCallback :: C_WebViewShowNotificationCallback -> IO (FunPtr C_WebViewShowNotificationCallback)

genClosure_WebViewShowNotification :: WebViewShowNotificationCallback -> IO Closure
genClosure_WebViewShowNotification cb = do
    let cb' = wrap_WebViewShowNotificationCallback cb
    mk_WebViewShowNotificationCallback cb' >>= newCClosure


wrap_WebViewShowNotificationCallback ::
    WebViewShowNotificationCallback ->
    Ptr () ->
    Ptr WebKit2.Notification.Notification ->
    Ptr () ->
    IO CInt
wrap_WebViewShowNotificationCallback _cb _ notification _ = do
    notification' <- (newObject WebKit2.Notification.Notification) notification
    result <- _cb  notification'
    let result' = (fromIntegral . fromEnum) result
    return result'


onWebViewShowNotification :: (GObject a, MonadIO m) => a -> WebViewShowNotificationCallback -> m SignalHandlerId
onWebViewShowNotification obj cb = liftIO $ connectWebViewShowNotification obj cb SignalConnectBefore
afterWebViewShowNotification :: (GObject a, MonadIO m) => a -> WebViewShowNotificationCallback -> m SignalHandlerId
afterWebViewShowNotification obj cb = connectWebViewShowNotification obj cb SignalConnectAfter

connectWebViewShowNotification :: (GObject a, MonadIO m) =>
                                  a -> WebViewShowNotificationCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewShowNotification obj cb after = liftIO $ do
    let cb' = wrap_WebViewShowNotificationCallback cb
    cb'' <- mk_WebViewShowNotificationCallback cb'
    connectSignalFunPtr obj "show-notification" cb'' after

-- signal WebView::submit-form
type WebViewSubmitFormCallback =
    WebKit2.FormSubmissionRequest.FormSubmissionRequest ->
    IO ()

noWebViewSubmitFormCallback :: Maybe WebViewSubmitFormCallback
noWebViewSubmitFormCallback = Nothing

type C_WebViewSubmitFormCallback =
    Ptr () ->                               -- object
    Ptr WebKit2.FormSubmissionRequest.FormSubmissionRequest ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_WebViewSubmitFormCallback :: C_WebViewSubmitFormCallback -> IO (FunPtr C_WebViewSubmitFormCallback)

genClosure_WebViewSubmitForm :: WebViewSubmitFormCallback -> IO Closure
genClosure_WebViewSubmitForm cb = do
    let cb' = wrap_WebViewSubmitFormCallback cb
    mk_WebViewSubmitFormCallback cb' >>= newCClosure


wrap_WebViewSubmitFormCallback ::
    WebViewSubmitFormCallback ->
    Ptr () ->
    Ptr WebKit2.FormSubmissionRequest.FormSubmissionRequest ->
    Ptr () ->
    IO ()
wrap_WebViewSubmitFormCallback _cb _ request _ = do
    request' <- (newObject WebKit2.FormSubmissionRequest.FormSubmissionRequest) request
    _cb  request'


onWebViewSubmitForm :: (GObject a, MonadIO m) => a -> WebViewSubmitFormCallback -> m SignalHandlerId
onWebViewSubmitForm obj cb = liftIO $ connectWebViewSubmitForm obj cb SignalConnectBefore
afterWebViewSubmitForm :: (GObject a, MonadIO m) => a -> WebViewSubmitFormCallback -> m SignalHandlerId
afterWebViewSubmitForm obj cb = connectWebViewSubmitForm obj cb SignalConnectAfter

connectWebViewSubmitForm :: (GObject a, MonadIO m) =>
                            a -> WebViewSubmitFormCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewSubmitForm obj cb after = liftIO $ do
    let cb' = wrap_WebViewSubmitFormCallback cb
    cb'' <- mk_WebViewSubmitFormCallback cb'
    connectSignalFunPtr obj "submit-form" cb'' after

-- signal WebView::web-process-crashed
type WebViewWebProcessCrashedCallback =
    IO Bool

noWebViewWebProcessCrashedCallback :: Maybe WebViewWebProcessCrashedCallback
noWebViewWebProcessCrashedCallback = Nothing

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

foreign import ccall "wrapper"
    mk_WebViewWebProcessCrashedCallback :: C_WebViewWebProcessCrashedCallback -> IO (FunPtr C_WebViewWebProcessCrashedCallback)

genClosure_WebViewWebProcessCrashed :: WebViewWebProcessCrashedCallback -> IO Closure
genClosure_WebViewWebProcessCrashed cb = do
    let cb' = wrap_WebViewWebProcessCrashedCallback cb
    mk_WebViewWebProcessCrashedCallback cb' >>= newCClosure


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


onWebViewWebProcessCrashed :: (GObject a, MonadIO m) => a -> WebViewWebProcessCrashedCallback -> m SignalHandlerId
onWebViewWebProcessCrashed obj cb = liftIO $ connectWebViewWebProcessCrashed obj cb SignalConnectBefore
afterWebViewWebProcessCrashed :: (GObject a, MonadIO m) => a -> WebViewWebProcessCrashedCallback -> m SignalHandlerId
afterWebViewWebProcessCrashed obj cb = connectWebViewWebProcessCrashed obj cb SignalConnectAfter

connectWebViewWebProcessCrashed :: (GObject a, MonadIO m) =>
                                   a -> WebViewWebProcessCrashedCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewWebProcessCrashed obj cb after = liftIO $ do
    let cb' = wrap_WebViewWebProcessCrashedCallback cb
    cb'' <- mk_WebViewWebProcessCrashedCallback cb'
    connectSignalFunPtr obj "web-process-crashed" cb'' after

-- VVV Prop "editable"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Just False)

getWebViewEditable :: (MonadIO m, IsWebView o) => o -> m Bool
getWebViewEditable obj = liftIO $ getObjectPropertyBool obj "editable"

setWebViewEditable :: (MonadIO m, IsWebView o) => o -> Bool -> m ()
setWebViewEditable obj val = liftIO $ setObjectPropertyBool obj "editable" val

constructWebViewEditable :: (IsWebView o) => Bool -> IO (GValueConstruct o)
constructWebViewEditable val = constructObjectPropertyBool "editable" val

data WebViewEditablePropertyInfo
instance AttrInfo WebViewEditablePropertyInfo where
    type AttrAllowedOps WebViewEditablePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint WebViewEditablePropertyInfo = (~) Bool
    type AttrBaseTypeConstraint WebViewEditablePropertyInfo = IsWebView
    type AttrGetType WebViewEditablePropertyInfo = Bool
    type AttrLabel WebViewEditablePropertyInfo = "editable"
    type AttrOrigin WebViewEditablePropertyInfo = WebView
    attrGet _ = getWebViewEditable
    attrSet _ = setWebViewEditable
    attrConstruct _ = constructWebViewEditable
    attrClear _ = undefined

-- VVV Prop "estimated-load-progress"
   -- Type: TBasicType TDouble
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

getWebViewEstimatedLoadProgress :: (MonadIO m, IsWebView o) => o -> m Double
getWebViewEstimatedLoadProgress obj = liftIO $ getObjectPropertyDouble obj "estimated-load-progress"

data WebViewEstimatedLoadProgressPropertyInfo
instance AttrInfo WebViewEstimatedLoadProgressPropertyInfo where
    type AttrAllowedOps WebViewEstimatedLoadProgressPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint WebViewEstimatedLoadProgressPropertyInfo = (~) ()
    type AttrBaseTypeConstraint WebViewEstimatedLoadProgressPropertyInfo = IsWebView
    type AttrGetType WebViewEstimatedLoadProgressPropertyInfo = Double
    type AttrLabel WebViewEstimatedLoadProgressPropertyInfo = "estimated-load-progress"
    type AttrOrigin WebViewEstimatedLoadProgressPropertyInfo = WebView
    attrGet _ = getWebViewEstimatedLoadProgress
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "favicon"
   -- Type: TBasicType TPtr
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

getWebViewFavicon :: (MonadIO m, IsWebView o) => o -> m (Ptr ())
getWebViewFavicon obj = liftIO $ getObjectPropertyPtr obj "favicon"

data WebViewFaviconPropertyInfo
instance AttrInfo WebViewFaviconPropertyInfo where
    type AttrAllowedOps WebViewFaviconPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint WebViewFaviconPropertyInfo = (~) ()
    type AttrBaseTypeConstraint WebViewFaviconPropertyInfo = IsWebView
    type AttrGetType WebViewFaviconPropertyInfo = (Ptr ())
    type AttrLabel WebViewFaviconPropertyInfo = "favicon"
    type AttrOrigin WebViewFaviconPropertyInfo = WebView
    attrGet _ = getWebViewFavicon
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "is-loading"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

getWebViewIsLoading :: (MonadIO m, IsWebView o) => o -> m Bool
getWebViewIsLoading obj = liftIO $ getObjectPropertyBool obj "is-loading"

data WebViewIsLoadingPropertyInfo
instance AttrInfo WebViewIsLoadingPropertyInfo where
    type AttrAllowedOps WebViewIsLoadingPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint WebViewIsLoadingPropertyInfo = (~) ()
    type AttrBaseTypeConstraint WebViewIsLoadingPropertyInfo = IsWebView
    type AttrGetType WebViewIsLoadingPropertyInfo = Bool
    type AttrLabel WebViewIsLoadingPropertyInfo = "is-loading"
    type AttrOrigin WebViewIsLoadingPropertyInfo = WebView
    attrGet _ = getWebViewIsLoading
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "is-playing-audio"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

getWebViewIsPlayingAudio :: (MonadIO m, IsWebView o) => o -> m Bool
getWebViewIsPlayingAudio obj = liftIO $ getObjectPropertyBool obj "is-playing-audio"

data WebViewIsPlayingAudioPropertyInfo
instance AttrInfo WebViewIsPlayingAudioPropertyInfo where
    type AttrAllowedOps WebViewIsPlayingAudioPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint WebViewIsPlayingAudioPropertyInfo = (~) ()
    type AttrBaseTypeConstraint WebViewIsPlayingAudioPropertyInfo = IsWebView
    type AttrGetType WebViewIsPlayingAudioPropertyInfo = Bool
    type AttrLabel WebViewIsPlayingAudioPropertyInfo = "is-playing-audio"
    type AttrOrigin WebViewIsPlayingAudioPropertyInfo = WebView
    attrGet _ = getWebViewIsPlayingAudio
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "related-view"
   -- Type: TInterface (Name {namespace = "WebKit2", name = "WebView"})
   -- Flags: [PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Nothing,Nothing)

constructWebViewRelatedView :: (IsWebView o, IsWebView a) => a -> IO (GValueConstruct o)
constructWebViewRelatedView val = constructObjectPropertyObject "related-view" (Just val)

data WebViewRelatedViewPropertyInfo
instance AttrInfo WebViewRelatedViewPropertyInfo where
    type AttrAllowedOps WebViewRelatedViewPropertyInfo = '[ 'AttrConstruct, 'AttrClear]
    type AttrSetTypeConstraint WebViewRelatedViewPropertyInfo = IsWebView
    type AttrBaseTypeConstraint WebViewRelatedViewPropertyInfo = IsWebView
    type AttrGetType WebViewRelatedViewPropertyInfo = ()
    type AttrLabel WebViewRelatedViewPropertyInfo = "related-view"
    type AttrOrigin WebViewRelatedViewPropertyInfo = WebView
    attrGet _ = undefined
    attrSet _ = undefined
    attrConstruct _ = constructWebViewRelatedView
    attrClear _ = undefined

-- VVV Prop "settings"
   -- Type: TInterface (Name {namespace = "WebKit2", name = "Settings"})
   -- Flags: [PropertyWritable,PropertyConstruct]
   -- Nullable: (Just False,Just False)

setWebViewSettings :: (MonadIO m, IsWebView o, WebKit2.Settings.IsSettings a) => o -> a -> m ()
setWebViewSettings obj val = liftIO $ setObjectPropertyObject obj "settings" (Just val)

constructWebViewSettings :: (IsWebView o, WebKit2.Settings.IsSettings a) => a -> IO (GValueConstruct o)
constructWebViewSettings val = constructObjectPropertyObject "settings" (Just val)

data WebViewSettingsPropertyInfo
instance AttrInfo WebViewSettingsPropertyInfo where
    type AttrAllowedOps WebViewSettingsPropertyInfo = '[ 'AttrSet, 'AttrConstruct]
    type AttrSetTypeConstraint WebViewSettingsPropertyInfo = WebKit2.Settings.IsSettings
    type AttrBaseTypeConstraint WebViewSettingsPropertyInfo = IsWebView
    type AttrGetType WebViewSettingsPropertyInfo = ()
    type AttrLabel WebViewSettingsPropertyInfo = "settings"
    type AttrOrigin WebViewSettingsPropertyInfo = WebView
    attrGet _ = undefined
    attrSet _ = setWebViewSettings
    attrConstruct _ = constructWebViewSettings
    attrClear _ = undefined

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

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

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

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

getWebViewUri :: (MonadIO m, IsWebView o) => o -> m (Maybe T.Text)
getWebViewUri obj = liftIO $ getObjectPropertyString obj "uri"

data WebViewUriPropertyInfo
instance AttrInfo WebViewUriPropertyInfo where
    type AttrAllowedOps WebViewUriPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WebViewUriPropertyInfo = (~) ()
    type AttrBaseTypeConstraint WebViewUriPropertyInfo = IsWebView
    type AttrGetType WebViewUriPropertyInfo = (Maybe T.Text)
    type AttrLabel WebViewUriPropertyInfo = "uri"
    type AttrOrigin WebViewUriPropertyInfo = WebView
    attrGet _ = getWebViewUri
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "user-content-manager"
   -- Type: TInterface (Name {namespace = "WebKit2", name = "UserContentManager"})
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Just False,Nothing)

getWebViewUserContentManager :: (MonadIO m, IsWebView o) => o -> m WebKit2.UserContentManager.UserContentManager
getWebViewUserContentManager obj = liftIO $ checkUnexpectedNothing "getWebViewUserContentManager" $ getObjectPropertyObject obj "user-content-manager" WebKit2.UserContentManager.UserContentManager

constructWebViewUserContentManager :: (IsWebView o, WebKit2.UserContentManager.IsUserContentManager a) => a -> IO (GValueConstruct o)
constructWebViewUserContentManager val = constructObjectPropertyObject "user-content-manager" (Just val)

data WebViewUserContentManagerPropertyInfo
instance AttrInfo WebViewUserContentManagerPropertyInfo where
    type AttrAllowedOps WebViewUserContentManagerPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WebViewUserContentManagerPropertyInfo = WebKit2.UserContentManager.IsUserContentManager
    type AttrBaseTypeConstraint WebViewUserContentManagerPropertyInfo = IsWebView
    type AttrGetType WebViewUserContentManagerPropertyInfo = WebKit2.UserContentManager.UserContentManager
    type AttrLabel WebViewUserContentManagerPropertyInfo = "user-content-manager"
    type AttrOrigin WebViewUserContentManagerPropertyInfo = WebView
    attrGet _ = getWebViewUserContentManager
    attrSet _ = undefined
    attrConstruct _ = constructWebViewUserContentManager
    attrClear _ = undefined

-- VVV Prop "web-context"
   -- Type: TInterface (Name {namespace = "WebKit2", name = "WebContext"})
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Nothing,Nothing)

getWebViewWebContext :: (MonadIO m, IsWebView o) => o -> m (Maybe WebKit2.WebContext.WebContext)
getWebViewWebContext obj = liftIO $ getObjectPropertyObject obj "web-context" WebKit2.WebContext.WebContext

constructWebViewWebContext :: (IsWebView o, WebKit2.WebContext.IsWebContext a) => a -> IO (GValueConstruct o)
constructWebViewWebContext val = constructObjectPropertyObject "web-context" (Just val)

data WebViewWebContextPropertyInfo
instance AttrInfo WebViewWebContextPropertyInfo where
    type AttrAllowedOps WebViewWebContextPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WebViewWebContextPropertyInfo = WebKit2.WebContext.IsWebContext
    type AttrBaseTypeConstraint WebViewWebContextPropertyInfo = IsWebView
    type AttrGetType WebViewWebContextPropertyInfo = (Maybe WebKit2.WebContext.WebContext)
    type AttrLabel WebViewWebContextPropertyInfo = "web-context"
    type AttrOrigin WebViewWebContextPropertyInfo = WebView
    attrGet _ = getWebViewWebContext
    attrSet _ = undefined
    attrConstruct _ = constructWebViewWebContext
    attrClear _ = undefined

-- VVV Prop "zoom-level"
   -- Type: TBasicType TDouble
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getWebViewZoomLevel :: (MonadIO m, IsWebView o) => o -> m Double
getWebViewZoomLevel obj = liftIO $ getObjectPropertyDouble obj "zoom-level"

setWebViewZoomLevel :: (MonadIO m, IsWebView o) => o -> Double -> m ()
setWebViewZoomLevel obj val = liftIO $ setObjectPropertyDouble obj "zoom-level" val

constructWebViewZoomLevel :: (IsWebView o) => Double -> IO (GValueConstruct o)
constructWebViewZoomLevel val = constructObjectPropertyDouble "zoom-level" val

data WebViewZoomLevelPropertyInfo
instance AttrInfo WebViewZoomLevelPropertyInfo where
    type AttrAllowedOps WebViewZoomLevelPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint WebViewZoomLevelPropertyInfo = (~) Double
    type AttrBaseTypeConstraint WebViewZoomLevelPropertyInfo = IsWebView
    type AttrGetType WebViewZoomLevelPropertyInfo = Double
    type AttrLabel WebViewZoomLevelPropertyInfo = "zoom-level"
    type AttrOrigin WebViewZoomLevelPropertyInfo = WebView
    attrGet _ = getWebViewZoomLevel
    attrSet _ = setWebViewZoomLevel
    attrConstruct _ = constructWebViewZoomLevel
    attrClear _ = undefined

instance O.HasAttributeList WebView
type instance O.AttributeList WebView = WebViewAttributeList
type WebViewAttributeList = ('[ '("appPaintable", Gtk.Widget.WidgetAppPaintablePropertyInfo), '("borderWidth", Gtk.Container.ContainerBorderWidthPropertyInfo), '("canDefault", Gtk.Widget.WidgetCanDefaultPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("child", Gtk.Container.ContainerChildPropertyInfo), '("compositeChild", Gtk.Widget.WidgetCompositeChildPropertyInfo), '("doubleBuffered", Gtk.Widget.WidgetDoubleBufferedPropertyInfo), '("editable", WebViewEditablePropertyInfo), '("estimatedLoadProgress", WebViewEstimatedLoadProgressPropertyInfo), '("events", Gtk.Widget.WidgetEventsPropertyInfo), '("expand", Gtk.Widget.WidgetExpandPropertyInfo), '("favicon", WebViewFaviconPropertyInfo), '("focusOnClick", Gtk.Widget.WidgetFocusOnClickPropertyInfo), '("halign", Gtk.Widget.WidgetHalignPropertyInfo), '("hasDefault", Gtk.Widget.WidgetHasDefaultPropertyInfo), '("hasFocus", Gtk.Widget.WidgetHasFocusPropertyInfo), '("hasTooltip", Gtk.Widget.WidgetHasTooltipPropertyInfo), '("heightRequest", Gtk.Widget.WidgetHeightRequestPropertyInfo), '("hexpand", Gtk.Widget.WidgetHexpandPropertyInfo), '("hexpandSet", Gtk.Widget.WidgetHexpandSetPropertyInfo), '("isFocus", Gtk.Widget.WidgetIsFocusPropertyInfo), '("isLoading", WebViewIsLoadingPropertyInfo), '("isPlayingAudio", WebViewIsPlayingAudioPropertyInfo), '("margin", Gtk.Widget.WidgetMarginPropertyInfo), '("marginBottom", Gtk.Widget.WidgetMarginBottomPropertyInfo), '("marginEnd", Gtk.Widget.WidgetMarginEndPropertyInfo), '("marginLeft", Gtk.Widget.WidgetMarginLeftPropertyInfo), '("marginRight", Gtk.Widget.WidgetMarginRightPropertyInfo), '("marginStart", Gtk.Widget.WidgetMarginStartPropertyInfo), '("marginTop", Gtk.Widget.WidgetMarginTopPropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("noShowAll", Gtk.Widget.WidgetNoShowAllPropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("relatedView", WebViewRelatedViewPropertyInfo), '("resizeMode", Gtk.Container.ContainerResizeModePropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("settings", WebViewSettingsPropertyInfo), '("style", Gtk.Widget.WidgetStylePropertyInfo), '("title", WebViewTitlePropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("uri", WebViewUriPropertyInfo), '("userContentManager", WebViewUserContentManagerPropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("webContext", WebViewWebContextPropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo), '("window", Gtk.Widget.WidgetWindowPropertyInfo), '("zoomLevel", WebViewZoomLevelPropertyInfo)] :: [(Symbol, *)])

webViewEditable :: AttrLabelProxy "editable"
webViewEditable = AttrLabelProxy

webViewEstimatedLoadProgress :: AttrLabelProxy "estimatedLoadProgress"
webViewEstimatedLoadProgress = AttrLabelProxy

webViewFavicon :: AttrLabelProxy "favicon"
webViewFavicon = AttrLabelProxy

webViewRelatedView :: AttrLabelProxy "relatedView"
webViewRelatedView = AttrLabelProxy

webViewSettings :: AttrLabelProxy "settings"
webViewSettings = AttrLabelProxy

webViewTitle :: AttrLabelProxy "title"
webViewTitle = AttrLabelProxy

webViewUri :: AttrLabelProxy "uri"
webViewUri = AttrLabelProxy

webViewUserContentManager :: AttrLabelProxy "userContentManager"
webViewUserContentManager = AttrLabelProxy

webViewWebContext :: AttrLabelProxy "webContext"
webViewWebContext = AttrLabelProxy

webViewZoomLevel :: AttrLabelProxy "zoomLevel"
webViewZoomLevel = AttrLabelProxy

data WebViewAuthenticateSignalInfo
instance SignalInfo WebViewAuthenticateSignalInfo where
    type HaskellCallbackType WebViewAuthenticateSignalInfo = WebViewAuthenticateCallback
    connectSignal _ = connectWebViewAuthenticate

data WebViewCloseSignalInfo
instance SignalInfo WebViewCloseSignalInfo where
    type HaskellCallbackType WebViewCloseSignalInfo = WebViewCloseCallback
    connectSignal _ = connectWebViewClose

data WebViewContextMenuSignalInfo
instance SignalInfo WebViewContextMenuSignalInfo where
    type HaskellCallbackType WebViewContextMenuSignalInfo = WebViewContextMenuCallback
    connectSignal _ = connectWebViewContextMenu

data WebViewContextMenuDismissedSignalInfo
instance SignalInfo WebViewContextMenuDismissedSignalInfo where
    type HaskellCallbackType WebViewContextMenuDismissedSignalInfo = WebViewContextMenuDismissedCallback
    connectSignal _ = connectWebViewContextMenuDismissed

data WebViewCreateSignalInfo
instance SignalInfo WebViewCreateSignalInfo where
    type HaskellCallbackType WebViewCreateSignalInfo = WebViewCreateCallback
    connectSignal _ = connectWebViewCreate

data WebViewDecidePolicySignalInfo
instance SignalInfo WebViewDecidePolicySignalInfo where
    type HaskellCallbackType WebViewDecidePolicySignalInfo = WebViewDecidePolicyCallback
    connectSignal _ = connectWebViewDecidePolicy

data WebViewEnterFullscreenSignalInfo
instance SignalInfo WebViewEnterFullscreenSignalInfo where
    type HaskellCallbackType WebViewEnterFullscreenSignalInfo = WebViewEnterFullscreenCallback
    connectSignal _ = connectWebViewEnterFullscreen

data WebViewInsecureContentDetectedSignalInfo
instance SignalInfo WebViewInsecureContentDetectedSignalInfo where
    type HaskellCallbackType WebViewInsecureContentDetectedSignalInfo = WebViewInsecureContentDetectedCallback
    connectSignal _ = connectWebViewInsecureContentDetected

data WebViewLeaveFullscreenSignalInfo
instance SignalInfo WebViewLeaveFullscreenSignalInfo where
    type HaskellCallbackType WebViewLeaveFullscreenSignalInfo = WebViewLeaveFullscreenCallback
    connectSignal _ = connectWebViewLeaveFullscreen

data WebViewLoadChangedSignalInfo
instance SignalInfo WebViewLoadChangedSignalInfo where
    type HaskellCallbackType WebViewLoadChangedSignalInfo = WebViewLoadChangedCallback
    connectSignal _ = connectWebViewLoadChanged

data WebViewLoadFailedSignalInfo
instance SignalInfo WebViewLoadFailedSignalInfo where
    type HaskellCallbackType WebViewLoadFailedSignalInfo = WebViewLoadFailedCallback
    connectSignal _ = connectWebViewLoadFailed

data WebViewLoadFailedWithTlsErrorsSignalInfo
instance SignalInfo WebViewLoadFailedWithTlsErrorsSignalInfo where
    type HaskellCallbackType WebViewLoadFailedWithTlsErrorsSignalInfo = WebViewLoadFailedWithTlsErrorsCallback
    connectSignal _ = connectWebViewLoadFailedWithTlsErrors

data WebViewMouseTargetChangedSignalInfo
instance SignalInfo WebViewMouseTargetChangedSignalInfo where
    type HaskellCallbackType WebViewMouseTargetChangedSignalInfo = WebViewMouseTargetChangedCallback
    connectSignal _ = connectWebViewMouseTargetChanged

data WebViewPermissionRequestSignalInfo
instance SignalInfo WebViewPermissionRequestSignalInfo where
    type HaskellCallbackType WebViewPermissionRequestSignalInfo = WebViewPermissionRequestCallback
    connectSignal _ = connectWebViewPermissionRequest

data WebViewPrintSignalInfo
instance SignalInfo WebViewPrintSignalInfo where
    type HaskellCallbackType WebViewPrintSignalInfo = WebViewPrintCallback
    connectSignal _ = connectWebViewPrint

data WebViewReadyToShowSignalInfo
instance SignalInfo WebViewReadyToShowSignalInfo where
    type HaskellCallbackType WebViewReadyToShowSignalInfo = WebViewReadyToShowCallback
    connectSignal _ = connectWebViewReadyToShow

data WebViewResourceLoadStartedSignalInfo
instance SignalInfo WebViewResourceLoadStartedSignalInfo where
    type HaskellCallbackType WebViewResourceLoadStartedSignalInfo = WebViewResourceLoadStartedCallback
    connectSignal _ = connectWebViewResourceLoadStarted

data WebViewRunAsModalSignalInfo
instance SignalInfo WebViewRunAsModalSignalInfo where
    type HaskellCallbackType WebViewRunAsModalSignalInfo = WebViewRunAsModalCallback
    connectSignal _ = connectWebViewRunAsModal

data WebViewRunColorChooserSignalInfo
instance SignalInfo WebViewRunColorChooserSignalInfo where
    type HaskellCallbackType WebViewRunColorChooserSignalInfo = WebViewRunColorChooserCallback
    connectSignal _ = connectWebViewRunColorChooser

data WebViewRunFileChooserSignalInfo
instance SignalInfo WebViewRunFileChooserSignalInfo where
    type HaskellCallbackType WebViewRunFileChooserSignalInfo = WebViewRunFileChooserCallback
    connectSignal _ = connectWebViewRunFileChooser

data WebViewScriptDialogSignalInfo
instance SignalInfo WebViewScriptDialogSignalInfo where
    type HaskellCallbackType WebViewScriptDialogSignalInfo = WebViewScriptDialogCallback
    connectSignal _ = connectWebViewScriptDialog

data WebViewShowNotificationSignalInfo
instance SignalInfo WebViewShowNotificationSignalInfo where
    type HaskellCallbackType WebViewShowNotificationSignalInfo = WebViewShowNotificationCallback
    connectSignal _ = connectWebViewShowNotification

data WebViewSubmitFormSignalInfo
instance SignalInfo WebViewSubmitFormSignalInfo where
    type HaskellCallbackType WebViewSubmitFormSignalInfo = WebViewSubmitFormCallback
    connectSignal _ = connectWebViewSubmitForm

data WebViewWebProcessCrashedSignalInfo
instance SignalInfo WebViewWebProcessCrashedSignalInfo where
    type HaskellCallbackType WebViewWebProcessCrashedSignalInfo = WebViewWebProcessCrashedCallback
    connectSignal _ = connectWebViewWebProcessCrashed

type instance O.SignalList WebView = WebViewSignalList
type WebViewSignalList = ('[ '("accelClosuresChanged", Gtk.Widget.WidgetAccelClosuresChangedSignalInfo), '("add", Gtk.Container.ContainerAddSignalInfo), '("authenticate", WebViewAuthenticateSignalInfo), '("buttonPressEvent", Gtk.Widget.WidgetButtonPressEventSignalInfo), '("buttonReleaseEvent", Gtk.Widget.WidgetButtonReleaseEventSignalInfo), '("canActivateAccel", Gtk.Widget.WidgetCanActivateAccelSignalInfo), '("checkResize", Gtk.Container.ContainerCheckResizeSignalInfo), '("childNotify", Gtk.Widget.WidgetChildNotifySignalInfo), '("close", WebViewCloseSignalInfo), '("compositedChanged", Gtk.Widget.WidgetCompositedChangedSignalInfo), '("configureEvent", Gtk.Widget.WidgetConfigureEventSignalInfo), '("contextMenu", WebViewContextMenuSignalInfo), '("contextMenuDismissed", WebViewContextMenuDismissedSignalInfo), '("create", WebViewCreateSignalInfo), '("damageEvent", Gtk.Widget.WidgetDamageEventSignalInfo), '("decidePolicy", WebViewDecidePolicySignalInfo), '("deleteEvent", Gtk.Widget.WidgetDeleteEventSignalInfo), '("destroy", Gtk.Widget.WidgetDestroySignalInfo), '("destroyEvent", Gtk.Widget.WidgetDestroyEventSignalInfo), '("directionChanged", Gtk.Widget.WidgetDirectionChangedSignalInfo), '("dragBegin", Gtk.Widget.WidgetDragBeginSignalInfo), '("dragDataDelete", Gtk.Widget.WidgetDragDataDeleteSignalInfo), '("dragDataGet", Gtk.Widget.WidgetDragDataGetSignalInfo), '("dragDataReceived", Gtk.Widget.WidgetDragDataReceivedSignalInfo), '("dragDrop", Gtk.Widget.WidgetDragDropSignalInfo), '("dragEnd", Gtk.Widget.WidgetDragEndSignalInfo), '("dragFailed", Gtk.Widget.WidgetDragFailedSignalInfo), '("dragLeave", Gtk.Widget.WidgetDragLeaveSignalInfo), '("dragMotion", Gtk.Widget.WidgetDragMotionSignalInfo), '("draw", Gtk.Widget.WidgetDrawSignalInfo), '("enterFullscreen", WebViewEnterFullscreenSignalInfo), '("enterNotifyEvent", Gtk.Widget.WidgetEnterNotifyEventSignalInfo), '("event", Gtk.Widget.WidgetEventSignalInfo), '("eventAfter", Gtk.Widget.WidgetEventAfterSignalInfo), '("focus", Gtk.Widget.WidgetFocusSignalInfo), '("focusInEvent", Gtk.Widget.WidgetFocusInEventSignalInfo), '("focusOutEvent", Gtk.Widget.WidgetFocusOutEventSignalInfo), '("grabBrokenEvent", Gtk.Widget.WidgetGrabBrokenEventSignalInfo), '("grabFocus", Gtk.Widget.WidgetGrabFocusSignalInfo), '("grabNotify", Gtk.Widget.WidgetGrabNotifySignalInfo), '("hide", Gtk.Widget.WidgetHideSignalInfo), '("hierarchyChanged", Gtk.Widget.WidgetHierarchyChangedSignalInfo), '("insecureContentDetected", WebViewInsecureContentDetectedSignalInfo), '("keyPressEvent", Gtk.Widget.WidgetKeyPressEventSignalInfo), '("keyReleaseEvent", Gtk.Widget.WidgetKeyReleaseEventSignalInfo), '("keynavFailed", Gtk.Widget.WidgetKeynavFailedSignalInfo), '("leaveFullscreen", WebViewLeaveFullscreenSignalInfo), '("leaveNotifyEvent", Gtk.Widget.WidgetLeaveNotifyEventSignalInfo), '("loadChanged", WebViewLoadChangedSignalInfo), '("loadFailed", WebViewLoadFailedSignalInfo), '("loadFailedWithTlsErrors", WebViewLoadFailedWithTlsErrorsSignalInfo), '("map", Gtk.Widget.WidgetMapSignalInfo), '("mapEvent", Gtk.Widget.WidgetMapEventSignalInfo), '("mnemonicActivate", Gtk.Widget.WidgetMnemonicActivateSignalInfo), '("motionNotifyEvent", Gtk.Widget.WidgetMotionNotifyEventSignalInfo), '("mouseTargetChanged", WebViewMouseTargetChangedSignalInfo), '("moveFocus", Gtk.Widget.WidgetMoveFocusSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("parentSet", Gtk.Widget.WidgetParentSetSignalInfo), '("permissionRequest", WebViewPermissionRequestSignalInfo), '("popupMenu", Gtk.Widget.WidgetPopupMenuSignalInfo), '("print", WebViewPrintSignalInfo), '("propertyNotifyEvent", Gtk.Widget.WidgetPropertyNotifyEventSignalInfo), '("proximityInEvent", Gtk.Widget.WidgetProximityInEventSignalInfo), '("proximityOutEvent", Gtk.Widget.WidgetProximityOutEventSignalInfo), '("queryTooltip", Gtk.Widget.WidgetQueryTooltipSignalInfo), '("readyToShow", WebViewReadyToShowSignalInfo), '("realize", Gtk.Widget.WidgetRealizeSignalInfo), '("remove", Gtk.Container.ContainerRemoveSignalInfo), '("resourceLoadStarted", WebViewResourceLoadStartedSignalInfo), '("runAsModal", WebViewRunAsModalSignalInfo), '("runColorChooser", WebViewRunColorChooserSignalInfo), '("runFileChooser", WebViewRunFileChooserSignalInfo), '("screenChanged", Gtk.Widget.WidgetScreenChangedSignalInfo), '("scriptDialog", WebViewScriptDialogSignalInfo), '("scrollEvent", Gtk.Widget.WidgetScrollEventSignalInfo), '("selectionClearEvent", Gtk.Widget.WidgetSelectionClearEventSignalInfo), '("selectionGet", Gtk.Widget.WidgetSelectionGetSignalInfo), '("selectionNotifyEvent", Gtk.Widget.WidgetSelectionNotifyEventSignalInfo), '("selectionReceived", Gtk.Widget.WidgetSelectionReceivedSignalInfo), '("selectionRequestEvent", Gtk.Widget.WidgetSelectionRequestEventSignalInfo), '("setFocusChild", Gtk.Container.ContainerSetFocusChildSignalInfo), '("show", Gtk.Widget.WidgetShowSignalInfo), '("showHelp", Gtk.Widget.WidgetShowHelpSignalInfo), '("showNotification", WebViewShowNotificationSignalInfo), '("sizeAllocate", Gtk.Widget.WidgetSizeAllocateSignalInfo), '("stateChanged", Gtk.Widget.WidgetStateChangedSignalInfo), '("stateFlagsChanged", Gtk.Widget.WidgetStateFlagsChangedSignalInfo), '("styleSet", Gtk.Widget.WidgetStyleSetSignalInfo), '("styleUpdated", Gtk.Widget.WidgetStyleUpdatedSignalInfo), '("submitForm", WebViewSubmitFormSignalInfo), '("touchEvent", Gtk.Widget.WidgetTouchEventSignalInfo), '("unmap", Gtk.Widget.WidgetUnmapSignalInfo), '("unmapEvent", Gtk.Widget.WidgetUnmapEventSignalInfo), '("unrealize", Gtk.Widget.WidgetUnrealizeSignalInfo), '("visibilityNotifyEvent", Gtk.Widget.WidgetVisibilityNotifyEventSignalInfo), '("webProcessCrashed", WebViewWebProcessCrashedSignalInfo), '("windowStateEvent", Gtk.Widget.WidgetWindowStateEventSignalInfo)] :: [(Symbol, *)])

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

foreign import ccall "webkit_web_view_new" webkit_web_view_new :: 
    IO (Ptr WebView)

{- |
Creates a new 'GI.WebKit2.Objects.WebView.WebView' with the default 'GI.WebKit2.Objects.WebContext.WebContext' and
no 'GI.WebKit2.Objects.UserContentManager.UserContentManager' associated with it.
See also 'GI.WebKit2.Objects.WebView.webViewNewWithContext',
'GI.WebKit2.Objects.WebView.webViewNewWithUserContentManager', and
'GI.WebKit2.Objects.WebView.webViewNewWithSettings'.
-}
webViewNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m WebView
    {- ^ __Returns:__ The newly created 'GI.WebKit2.Objects.WebView.WebView' widget -}
webViewNew  = liftIO $ do
    result <- webkit_web_view_new
    checkUnexpectedReturnNULL "webViewNew" result
    result' <- (newObject WebView) result
    return result'

-- method WebView::new_with_context
-- method type : Constructor
-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "WebKit2", name = "WebContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #WebKitWebContext to be used by the #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "WebView"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_new_with_context" webkit_web_view_new_with_context :: 
    Ptr WebKit2.WebContext.WebContext ->    -- context : TInterface (Name {namespace = "WebKit2", name = "WebContext"})
    IO (Ptr WebView)

{- |
Creates a new 'GI.WebKit2.Objects.WebView.WebView' with the given 'GI.WebKit2.Objects.WebContext.WebContext' and
no 'GI.WebKit2.Objects.UserContentManager.UserContentManager' associated with it.
See also 'GI.WebKit2.Objects.WebView.webViewNewWithUserContentManager' and
'GI.WebKit2.Objects.WebView.webViewNewWithSettings'.
-}
webViewNewWithContext ::
    (B.CallStack.HasCallStack, MonadIO m, WebKit2.WebContext.IsWebContext a) =>
    a
    {- ^ /@context@/: the 'GI.WebKit2.Objects.WebContext.WebContext' to be used by the 'GI.WebKit2.Objects.WebView.WebView' -}
    -> m WebView
    {- ^ __Returns:__ The newly created 'GI.WebKit2.Objects.WebView.WebView' widget -}
webViewNewWithContext context = liftIO $ do
    context' <- unsafeManagedPtrCastPtr context
    result <- webkit_web_view_new_with_context context'
    checkUnexpectedReturnNULL "webViewNewWithContext" result
    result' <- (newObject WebView) result
    touchManagedPtr context
    return result'

-- method WebView::new_with_settings
-- method type : Constructor
-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "WebView"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_new_with_settings" webkit_web_view_new_with_settings :: 
    Ptr WebKit2.Settings.Settings ->        -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"})
    IO (Ptr WebView)

{- |
Creates a new 'GI.WebKit2.Objects.WebView.WebView' with the given 'GI.WebKit2.Objects.Settings.Settings'.
See also 'GI.WebKit2.Objects.WebView.webViewNewWithContext', and
'GI.WebKit2.Objects.WebView.webViewNewWithUserContentManager'.

@since 2.6
-}
webViewNewWithSettings ::
    (B.CallStack.HasCallStack, MonadIO m, WebKit2.Settings.IsSettings a) =>
    a
    {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -}
    -> m WebView
    {- ^ __Returns:__ The newly created 'GI.WebKit2.Objects.WebView.WebView' widget -}
webViewNewWithSettings settings = liftIO $ do
    settings' <- unsafeManagedPtrCastPtr settings
    result <- webkit_web_view_new_with_settings settings'
    checkUnexpectedReturnNULL "webViewNewWithSettings" result
    result' <- (newObject WebView) result
    touchManagedPtr settings
    return result'

-- method WebView::new_with_user_content_manager
-- method type : Constructor
-- Args : [Arg {argCName = "user_content_manager", argType = TInterface (Name {namespace = "WebKit2", name = "UserContentManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitUserContentManager.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "WebView"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_new_with_user_content_manager" webkit_web_view_new_with_user_content_manager :: 
    Ptr WebKit2.UserContentManager.UserContentManager -> -- user_content_manager : TInterface (Name {namespace = "WebKit2", name = "UserContentManager"})
    IO (Ptr WebView)

{- |
Creates a new 'GI.WebKit2.Objects.WebView.WebView' with the given 'GI.WebKit2.Objects.UserContentManager.UserContentManager'.
The content loaded in the view may be affected by the content injected
in the view by the user content manager.

@since 2.6
-}
webViewNewWithUserContentManager ::
    (B.CallStack.HasCallStack, MonadIO m, WebKit2.UserContentManager.IsUserContentManager a) =>
    a
    {- ^ /@userContentManager@/: a 'GI.WebKit2.Objects.UserContentManager.UserContentManager'. -}
    -> m WebView
    {- ^ __Returns:__ The newly created 'GI.WebKit2.Objects.WebView.WebView' widget -}
webViewNewWithUserContentManager userContentManager = liftIO $ do
    userContentManager' <- unsafeManagedPtrCastPtr userContentManager
    result <- webkit_web_view_new_with_user_content_manager userContentManager'
    checkUnexpectedReturnNULL "webViewNewWithUserContentManager" result
    result' <- (newObject WebView) result
    touchManagedPtr userContentManager
    return result'

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

foreign import ccall "webkit_web_view_can_execute_editing_command" webkit_web_view_can_execute_editing_command :: 
    Ptr WebView ->                          -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"})
    CString ->                              -- command : TBasicType TUTF8
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO ()

{- |
Asynchronously execute the given editing command.

When the operation is finished, /@callback@/ will be called. You can then call
'GI.WebKit2.Objects.WebView.webViewCanExecuteEditingCommandFinish' to get the result of the operation.
-}
webViewCanExecuteEditingCommand ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebView a, Gio.Cancellable.IsCancellable b) =>
    a
    {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -}
    -> T.Text
    {- ^ /@command@/: the command to check -}
    -> Maybe (b)
    {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable' or 'Nothing' to ignore -}
    -> Maybe (Gio.Callbacks.AsyncReadyCallback)
    {- ^ /@callback@/: a 'GI.Gio.Callbacks.AsyncReadyCallback' to call when the request is satisfied -}
    -> m ()
webViewCanExecuteEditingCommand webView command cancellable callback = liftIO $ do
    webView' <- unsafeManagedPtrCastPtr webView
    command' <- textToCString command
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
    maybeCallback <- case callback of
        Nothing -> return (castPtrToFunPtr nullPtr)
        Just jCallback -> do
            jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback))
            poke ptrcallback jCallback'
            return jCallback'
    let userData = nullPtr
    webkit_web_view_can_execute_editing_command webView' command' maybeCancellable maybeCallback userData
    touchManagedPtr webView
    whenJust cancellable touchManagedPtr
    freeMem command'
    return ()

data WebViewCanExecuteEditingCommandMethodInfo
instance (signature ~ (T.Text -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsWebView a, Gio.Cancellable.IsCancellable b) => O.MethodInfo WebViewCanExecuteEditingCommandMethodInfo a signature where
    overloadedMethod _ = webViewCanExecuteEditingCommand

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

foreign import ccall "webkit_web_view_can_execute_editing_command_finish" webkit_web_view_can_execute_editing_command_finish :: 
    Ptr WebView ->                          -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"})
    Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{- |
Finish an asynchronous operation started with 'GI.WebKit2.Objects.WebView.webViewCanExecuteEditingCommand'.
-}
webViewCanExecuteEditingCommandFinish ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebView a, Gio.AsyncResult.IsAsyncResult b) =>
    a
    {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -}
    -> b
    {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult' -}
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
webViewCanExecuteEditingCommandFinish webView result_ = liftIO $ do
    webView' <- unsafeManagedPtrCastPtr webView
    result_' <- unsafeManagedPtrCastPtr result_
    onException (do
        _ <- propagateGError $ webkit_web_view_can_execute_editing_command_finish webView' result_'
        touchManagedPtr webView
        touchManagedPtr result_
        return ()
     ) (do
        return ()
     )

data WebViewCanExecuteEditingCommandFinishMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsWebView a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo WebViewCanExecuteEditingCommandFinishMethodInfo a signature where
    overloadedMethod _ = webViewCanExecuteEditingCommandFinish

-- method WebView::can_go_back
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), 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 (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_can_go_back" webkit_web_view_can_go_back :: 
    Ptr WebView ->                          -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"})
    IO CInt

{- |
Determines whether /@webView@/ has a previous history item.
-}
webViewCanGoBack ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebView a) =>
    a
    {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if able to move back or 'False' otherwise. -}
webViewCanGoBack webView = liftIO $ do
    webView' <- unsafeManagedPtrCastPtr webView
    result <- webkit_web_view_can_go_back webView'
    let result' = (/= 0) result
    touchManagedPtr webView
    return result'

data WebViewCanGoBackMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWebView a) => O.MethodInfo WebViewCanGoBackMethodInfo a signature where
    overloadedMethod _ = webViewCanGoBack

-- method WebView::can_go_forward
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), 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 (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_can_go_forward" webkit_web_view_can_go_forward :: 
    Ptr WebView ->                          -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"})
    IO CInt

{- |
Determines whether /@webView@/ has a next history item.
-}
webViewCanGoForward ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebView a) =>
    a
    {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if able to move forward or 'False' otherwise. -}
webViewCanGoForward webView = liftIO $ do
    webView' <- unsafeManagedPtrCastPtr webView
    result <- webkit_web_view_can_go_forward webView'
    let result' = (/= 0) result
    touchManagedPtr webView
    return result'

data WebViewCanGoForwardMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWebView a) => O.MethodInfo WebViewCanGoForwardMethodInfo a signature where
    overloadedMethod _ = webViewCanGoForward

-- method WebView::can_show_mime_type
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", 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 "a MIME type", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_can_show_mime_type" webkit_web_view_can_show_mime_type :: 
    Ptr WebView ->                          -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"})
    CString ->                              -- mime_type : TBasicType TUTF8
    IO CInt

{- |
Whether or not a MIME type can be displayed in /@webView@/.
-}
webViewCanShowMimeType ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebView a) =>
    a
    {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -}
    -> T.Text
    {- ^ /@mimeType@/: a MIME type -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the MIME type /@mimeType@/ can be displayed or 'False' otherwise -}
webViewCanShowMimeType webView mimeType = liftIO $ do
    webView' <- unsafeManagedPtrCastPtr webView
    mimeType' <- textToCString mimeType
    result <- webkit_web_view_can_show_mime_type webView' mimeType'
    let result' = (/= 0) result
    touchManagedPtr webView
    freeMem mimeType'
    return result'

data WebViewCanShowMimeTypeMethodInfo
instance (signature ~ (T.Text -> m Bool), MonadIO m, IsWebView a) => O.MethodInfo WebViewCanShowMimeTypeMethodInfo a signature where
    overloadedMethod _ = webViewCanShowMimeType

-- method WebView::download_uri
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", 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 "the URI to download", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "Download"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_download_uri" webkit_web_view_download_uri :: 
    Ptr WebView ->                          -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"})
    CString ->                              -- uri : TBasicType TUTF8
    IO (Ptr WebKit2.Download.Download)

{- |
Requests downloading of the specified URI string for /@webView@/.
-}
webViewDownloadUri ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebView a) =>
    a
    {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -}
    -> T.Text
    {- ^ /@uri@/: the URI to download -}
    -> m WebKit2.Download.Download
    {- ^ __Returns:__ a new 'GI.WebKit2.Objects.Download.Download' representing the
   the download operation. -}
webViewDownloadUri webView uri = liftIO $ do
    webView' <- unsafeManagedPtrCastPtr webView
    uri' <- textToCString uri
    result <- webkit_web_view_download_uri webView' uri'
    checkUnexpectedReturnNULL "webViewDownloadUri" result
    result' <- (wrapObject WebKit2.Download.Download) result
    touchManagedPtr webView
    freeMem uri'
    return result'

data WebViewDownloadUriMethodInfo
instance (signature ~ (T.Text -> m WebKit2.Download.Download), MonadIO m, IsWebView a) => O.MethodInfo WebViewDownloadUriMethodInfo a signature where
    overloadedMethod _ = webViewDownloadUri

-- method WebView::execute_editing_command
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "command", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the command to execute", 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_view_execute_editing_command" webkit_web_view_execute_editing_command :: 
    Ptr WebView ->                          -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"})
    CString ->                              -- command : TBasicType TUTF8
    IO ()

{- |
Request to execute the given /@command@/ for /@webView@/. You can use
'GI.WebKit2.Objects.WebView.webViewCanExecuteEditingCommand' to check whether
it\'s possible to execute the command.
-}
webViewExecuteEditingCommand ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebView a) =>
    a
    {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -}
    -> T.Text
    {- ^ /@command@/: the command to execute -}
    -> m ()
webViewExecuteEditingCommand webView command = liftIO $ do
    webView' <- unsafeManagedPtrCastPtr webView
    command' <- textToCString command
    webkit_web_view_execute_editing_command webView' command'
    touchManagedPtr webView
    freeMem command'
    return ()

data WebViewExecuteEditingCommandMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsWebView a) => O.MethodInfo WebViewExecuteEditingCommandMethodInfo a signature where
    overloadedMethod _ = webViewExecuteEditingCommand

-- method WebView::execute_editing_command_with_argument
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "command", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the command to execute", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "argument", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the command argument", 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_view_execute_editing_command_with_argument" webkit_web_view_execute_editing_command_with_argument :: 
    Ptr WebView ->                          -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"})
    CString ->                              -- command : TBasicType TUTF8
    CString ->                              -- argument : TBasicType TUTF8
    IO ()

{- |
Request to execute the given /@command@/ with /@argument@/ for /@webView@/. You can use
'GI.WebKit2.Objects.WebView.webViewCanExecuteEditingCommand' to check whether
it\'s possible to execute the command.

@since 2.10
-}
webViewExecuteEditingCommandWithArgument ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebView a) =>
    a
    {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -}
    -> T.Text
    {- ^ /@command@/: the command to execute -}
    -> T.Text
    {- ^ /@argument@/: the command argument -}
    -> m ()
webViewExecuteEditingCommandWithArgument webView command argument = liftIO $ do
    webView' <- unsafeManagedPtrCastPtr webView
    command' <- textToCString command
    argument' <- textToCString argument
    webkit_web_view_execute_editing_command_with_argument webView' command' argument'
    touchManagedPtr webView
    freeMem command'
    freeMem argument'
    return ()

data WebViewExecuteEditingCommandWithArgumentMethodInfo
instance (signature ~ (T.Text -> T.Text -> m ()), MonadIO m, IsWebView a) => O.MethodInfo WebViewExecuteEditingCommandWithArgumentMethodInfo a signature where
    overloadedMethod _ = webViewExecuteEditingCommandWithArgument

-- method WebView::get_back_forward_list
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), 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 = "WebKit2", name = "BackForwardList"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_get_back_forward_list" webkit_web_view_get_back_forward_list :: 
    Ptr WebView ->                          -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"})
    IO (Ptr WebKit2.BackForwardList.BackForwardList)

{- |
Obtains the 'GI.WebKit2.Objects.BackForwardList.BackForwardList' associated with the given 'GI.WebKit2.Objects.WebView.WebView'. The
'GI.WebKit2.Objects.BackForwardList.BackForwardList' is owned by the 'GI.WebKit2.Objects.WebView.WebView'.
-}
webViewGetBackForwardList ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebView a) =>
    a
    {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -}
    -> m WebKit2.BackForwardList.BackForwardList
    {- ^ __Returns:__ the 'GI.WebKit2.Objects.BackForwardList.BackForwardList' -}
webViewGetBackForwardList webView = liftIO $ do
    webView' <- unsafeManagedPtrCastPtr webView
    result <- webkit_web_view_get_back_forward_list webView'
    checkUnexpectedReturnNULL "webViewGetBackForwardList" result
    result' <- (newObject WebKit2.BackForwardList.BackForwardList) result
    touchManagedPtr webView
    return result'

data WebViewGetBackForwardListMethodInfo
instance (signature ~ (m WebKit2.BackForwardList.BackForwardList), MonadIO m, IsWebView a) => O.MethodInfo WebViewGetBackForwardListMethodInfo a signature where
    overloadedMethod _ = webViewGetBackForwardList

-- method WebView::get_background_color
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rgba", argType = TInterface (Name {namespace = "Gdk", name = "RGBA"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkRGBA to fill in with the background color", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_get_background_color" webkit_web_view_get_background_color :: 
    Ptr WebView ->                          -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"})
    Ptr Gdk.RGBA.RGBA ->                    -- rgba : TInterface (Name {namespace = "Gdk", name = "RGBA"})
    IO ()

{- |
Gets the color that is used to draw the /@webView@/ background before
the actual contents are rendered.
For more information see also 'GI.WebKit2.Objects.WebView.webViewSetBackgroundColor'

@since 2.8
-}
webViewGetBackgroundColor ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebView a) =>
    a
    {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -}
    -> m (Gdk.RGBA.RGBA)
webViewGetBackgroundColor webView = liftIO $ do
    webView' <- unsafeManagedPtrCastPtr webView
    rgba <- callocBoxedBytes 32 :: IO (Ptr Gdk.RGBA.RGBA)
    webkit_web_view_get_background_color webView' rgba
    rgba' <- (wrapBoxed Gdk.RGBA.RGBA) rgba
    touchManagedPtr webView
    return rgba'

data WebViewGetBackgroundColorMethodInfo
instance (signature ~ (m (Gdk.RGBA.RGBA)), MonadIO m, IsWebView a) => O.MethodInfo WebViewGetBackgroundColorMethodInfo a signature where
    overloadedMethod _ = webViewGetBackgroundColor

-- method WebView::get_context
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), 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 = "WebKit2", name = "WebContext"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_get_context" webkit_web_view_get_context :: 
    Ptr WebView ->                          -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"})
    IO (Ptr WebKit2.WebContext.WebContext)

{- |
Gets the web context of /@webView@/.
-}
webViewGetContext ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebView a) =>
    a
    {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -}
    -> m WebKit2.WebContext.WebContext
    {- ^ __Returns:__ the 'GI.WebKit2.Objects.WebContext.WebContext' of the view -}
webViewGetContext webView = liftIO $ do
    webView' <- unsafeManagedPtrCastPtr webView
    result <- webkit_web_view_get_context webView'
    checkUnexpectedReturnNULL "webViewGetContext" result
    result' <- (newObject WebKit2.WebContext.WebContext) result
    touchManagedPtr webView
    return result'

data WebViewGetContextMethodInfo
instance (signature ~ (m WebKit2.WebContext.WebContext), MonadIO m, IsWebView a) => O.MethodInfo WebViewGetContextMethodInfo a signature where
    overloadedMethod _ = webViewGetContext

-- method WebView::get_custom_charset
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), 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 (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_get_custom_charset" webkit_web_view_get_custom_charset :: 
    Ptr WebView ->                          -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"})
    IO CString

{- |
Returns the current custom character encoding name of /@webView@/.
-}
webViewGetCustomCharset ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebView a) =>
    a
    {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -}
    -> m T.Text
    {- ^ __Returns:__ the current custom character encoding name or 'Nothing' if no
   custom character encoding has been set. -}
webViewGetCustomCharset webView = liftIO $ do
    webView' <- unsafeManagedPtrCastPtr webView
    result <- webkit_web_view_get_custom_charset webView'
    checkUnexpectedReturnNULL "webViewGetCustomCharset" result
    result' <- cstringToText result
    touchManagedPtr webView
    return result'

data WebViewGetCustomCharsetMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsWebView a) => O.MethodInfo WebViewGetCustomCharsetMethodInfo a signature where
    overloadedMethod _ = webViewGetCustomCharset

-- method WebView::get_editor_state
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), 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 = "WebKit2", name = "EditorState"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_get_editor_state" webkit_web_view_get_editor_state :: 
    Ptr WebView ->                          -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"})
    IO (Ptr WebKit2.EditorState.EditorState)

{- |
Gets the web editor state of /@webView@/.

@since 2.10
-}
webViewGetEditorState ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebView a) =>
    a
    {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -}
    -> m WebKit2.EditorState.EditorState
    {- ^ __Returns:__ the 'GI.WebKit2.Objects.EditorState.EditorState' of the view -}
webViewGetEditorState webView = liftIO $ do
    webView' <- unsafeManagedPtrCastPtr webView
    result <- webkit_web_view_get_editor_state webView'
    checkUnexpectedReturnNULL "webViewGetEditorState" result
    result' <- (newObject WebKit2.EditorState.EditorState) result
    touchManagedPtr webView
    return result'

data WebViewGetEditorStateMethodInfo
instance (signature ~ (m WebKit2.EditorState.EditorState), MonadIO m, IsWebView a) => O.MethodInfo WebViewGetEditorStateMethodInfo a signature where
    overloadedMethod _ = webViewGetEditorState

-- method WebView::get_estimated_load_progress
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), 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 (TBasicType TDouble)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_get_estimated_load_progress" webkit_web_view_get_estimated_load_progress :: 
    Ptr WebView ->                          -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"})
    IO CDouble

{- |
Gets the value of the 'GI.WebKit2.Objects.WebView.WebView':@/estimated-load-progress/@ property.
You can monitor the estimated progress of a load operation by
connecting to the notify::estimated-load-progress signal of /@webView@/.
-}
webViewGetEstimatedLoadProgress ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebView a) =>
    a
    {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -}
    -> m Double
    {- ^ __Returns:__ an estimate of the of the percent complete for a document
    load as a range from 0.0 to 1.0. -}
webViewGetEstimatedLoadProgress webView = liftIO $ do
    webView' <- unsafeManagedPtrCastPtr webView
    result <- webkit_web_view_get_estimated_load_progress webView'
    let result' = realToFrac result
    touchManagedPtr webView
    return result'

data WebViewGetEstimatedLoadProgressMethodInfo
instance (signature ~ (m Double), MonadIO m, IsWebView a) => O.MethodInfo WebViewGetEstimatedLoadProgressMethodInfo a signature where
    overloadedMethod _ = webViewGetEstimatedLoadProgress

-- method WebView::get_favicon
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), 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 = "cairo", name = "Surface"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_get_favicon" webkit_web_view_get_favicon :: 
    Ptr WebView ->                          -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"})
    IO (Ptr Cairo.Surface.Surface)

{- |
Returns favicon currently associated to /@webView@/, if any. You can
connect to notify::favicon signal of /@webView@/ to be notified when
the favicon is available.
-}
webViewGetFavicon ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebView a) =>
    a
    {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -}
    -> m Cairo.Surface.Surface
    {- ^ __Returns:__ a pointer to a 'GI.Cairo.Structs.Surface.Surface' with the
   favicon or 'Nothing' if there\'s no icon associated with /@webView@/. -}
webViewGetFavicon webView = liftIO $ do
    webView' <- unsafeManagedPtrCastPtr webView
    result <- webkit_web_view_get_favicon webView'
    checkUnexpectedReturnNULL "webViewGetFavicon" result
    result' <- (newBoxed Cairo.Surface.Surface) result
    touchManagedPtr webView
    return result'

data WebViewGetFaviconMethodInfo
instance (signature ~ (m Cairo.Surface.Surface), MonadIO m, IsWebView a) => O.MethodInfo WebViewGetFaviconMethodInfo a signature where
    overloadedMethod _ = webViewGetFavicon

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

foreign import ccall "webkit_web_view_get_find_controller" webkit_web_view_get_find_controller :: 
    Ptr WebView ->                          -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"})
    IO (Ptr WebKit2.FindController.FindController)

{- |
Gets the 'GI.WebKit2.Objects.FindController.FindController' that will allow the caller to query
the 'GI.WebKit2.Objects.WebView.WebView' for the text to look for.
-}
webViewGetFindController ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebView a) =>
    a
    {- ^ /@webView@/: the 'GI.WebKit2.Objects.WebView.WebView' -}
    -> m WebKit2.FindController.FindController
    {- ^ __Returns:__ the 'GI.WebKit2.Objects.FindController.FindController' associated to
this particular 'GI.WebKit2.Objects.WebView.WebView'. -}
webViewGetFindController webView = liftIO $ do
    webView' <- unsafeManagedPtrCastPtr webView
    result <- webkit_web_view_get_find_controller webView'
    checkUnexpectedReturnNULL "webViewGetFindController" result
    result' <- (newObject WebKit2.FindController.FindController) result
    touchManagedPtr webView
    return result'

data WebViewGetFindControllerMethodInfo
instance (signature ~ (m WebKit2.FindController.FindController), MonadIO m, IsWebView a) => O.MethodInfo WebViewGetFindControllerMethodInfo a signature where
    overloadedMethod _ = webViewGetFindController

-- method WebView::get_inspector
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), 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 = "WebKit2", name = "WebInspector"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_get_inspector" webkit_web_view_get_inspector :: 
    Ptr WebView ->                          -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"})
    IO (Ptr WebKit2.WebInspector.WebInspector)

{- |
Get the 'GI.WebKit2.Objects.WebInspector.WebInspector' associated to /@webView@/
-}
webViewGetInspector ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebView a) =>
    a
    {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -}
    -> m WebKit2.WebInspector.WebInspector
    {- ^ __Returns:__ the 'GI.WebKit2.Objects.WebInspector.WebInspector' of /@webView@/ -}
webViewGetInspector webView = liftIO $ do
    webView' <- unsafeManagedPtrCastPtr webView
    result <- webkit_web_view_get_inspector webView'
    checkUnexpectedReturnNULL "webViewGetInspector" result
    result' <- (newObject WebKit2.WebInspector.WebInspector) result
    touchManagedPtr webView
    return result'

data WebViewGetInspectorMethodInfo
instance (signature ~ (m WebKit2.WebInspector.WebInspector), MonadIO m, IsWebView a) => O.MethodInfo WebViewGetInspectorMethodInfo a signature where
    overloadedMethod _ = webViewGetInspector

-- method WebView::get_javascript_global_context
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), 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 = "JavaScriptCore", name = "GlobalContext"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_get_javascript_global_context" webkit_web_view_get_javascript_global_context :: 
    Ptr WebView ->                          -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"})
    IO (Ptr JavaScriptCore.GlobalContext.GlobalContext)

{- |
Get the global JavaScript context used by /@webView@/ to deserialize the
result values of scripts executed with 'GI.WebKit2.Objects.WebView.webViewRunJavascript'.
-}
webViewGetJavascriptGlobalContext ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebView a) =>
    a
    {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -}
    -> m JavaScriptCore.GlobalContext.GlobalContext
    {- ^ __Returns:__ the \<function>JSGlobalContextRef\<\/function> used by /@webView@/ to deserialize
   the result values of scripts. -}
webViewGetJavascriptGlobalContext webView = liftIO $ do
    webView' <- unsafeManagedPtrCastPtr webView
    result <- webkit_web_view_get_javascript_global_context webView'
    checkUnexpectedReturnNULL "webViewGetJavascriptGlobalContext" result
    result' <- (wrapPtr JavaScriptCore.GlobalContext.GlobalContext) result
    touchManagedPtr webView
    return result'

data WebViewGetJavascriptGlobalContextMethodInfo
instance (signature ~ (m JavaScriptCore.GlobalContext.GlobalContext), MonadIO m, IsWebView a) => O.MethodInfo WebViewGetJavascriptGlobalContextMethodInfo a signature where
    overloadedMethod _ = webViewGetJavascriptGlobalContext

-- method WebView::get_main_resource
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), 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 = "WebKit2", name = "WebResource"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_get_main_resource" webkit_web_view_get_main_resource :: 
    Ptr WebView ->                          -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"})
    IO (Ptr WebKit2.WebResource.WebResource)

{- |
Return the main resource of /@webView@/.
-}
webViewGetMainResource ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebView a) =>
    a
    {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -}
    -> m WebKit2.WebResource.WebResource
    {- ^ __Returns:__ the main 'GI.WebKit2.Objects.WebResource.WebResource' of the view
   or 'Nothing' if nothing has been loaded. -}
webViewGetMainResource webView = liftIO $ do
    webView' <- unsafeManagedPtrCastPtr webView
    result <- webkit_web_view_get_main_resource webView'
    checkUnexpectedReturnNULL "webViewGetMainResource" result
    result' <- (newObject WebKit2.WebResource.WebResource) result
    touchManagedPtr webView
    return result'

data WebViewGetMainResourceMethodInfo
instance (signature ~ (m WebKit2.WebResource.WebResource), MonadIO m, IsWebView a) => O.MethodInfo WebViewGetMainResourceMethodInfo a signature where
    overloadedMethod _ = webViewGetMainResource

-- method WebView::get_page_id
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), 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 (TBasicType TUInt64)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_get_page_id" webkit_web_view_get_page_id :: 
    Ptr WebView ->                          -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"})
    IO Word64

{- |
Get the identifier of the @/WebKitWebPage/@ corresponding to
the 'GI.WebKit2.Objects.WebView.WebView'
-}
webViewGetPageId ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebView a) =>
    a
    {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -}
    -> m Word64
    {- ^ __Returns:__ the page ID of /@webView@/. -}
webViewGetPageId webView = liftIO $ do
    webView' <- unsafeManagedPtrCastPtr webView
    result <- webkit_web_view_get_page_id webView'
    touchManagedPtr webView
    return result

data WebViewGetPageIdMethodInfo
instance (signature ~ (m Word64), MonadIO m, IsWebView a) => O.MethodInfo WebViewGetPageIdMethodInfo a signature where
    overloadedMethod _ = webViewGetPageId

-- method WebView::get_session_state
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), 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 = "WebKit2", name = "WebViewSessionState"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_get_session_state" webkit_web_view_get_session_state :: 
    Ptr WebView ->                          -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"})
    IO (Ptr WebKit2.WebViewSessionState.WebViewSessionState)

{- |
Gets the current session state of /@webView@/

@since 2.12
-}
webViewGetSessionState ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebView a) =>
    a
    {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -}
    -> m WebKit2.WebViewSessionState.WebViewSessionState
    {- ^ __Returns:__ a 'GI.WebKit2.Structs.WebViewSessionState.WebViewSessionState' -}
webViewGetSessionState webView = liftIO $ do
    webView' <- unsafeManagedPtrCastPtr webView
    result <- webkit_web_view_get_session_state webView'
    checkUnexpectedReturnNULL "webViewGetSessionState" result
    result' <- (wrapBoxed WebKit2.WebViewSessionState.WebViewSessionState) result
    touchManagedPtr webView
    return result'

data WebViewGetSessionStateMethodInfo
instance (signature ~ (m WebKit2.WebViewSessionState.WebViewSessionState), MonadIO m, IsWebView a) => O.MethodInfo WebViewGetSessionStateMethodInfo a signature where
    overloadedMethod _ = webViewGetSessionState

-- method WebView::get_settings
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), 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 = "WebKit2", name = "Settings"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_get_settings" webkit_web_view_get_settings :: 
    Ptr WebView ->                          -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"})
    IO (Ptr WebKit2.Settings.Settings)

{- |
Gets the 'GI.WebKit2.Objects.Settings.Settings' currently applied to /@webView@/.
If no other 'GI.WebKit2.Objects.Settings.Settings' have been explicitly applied to
/@webView@/ with 'GI.WebKit2.Objects.WebView.webViewSetSettings', the default
'GI.WebKit2.Objects.Settings.Settings' will be returned. This method always returns
a valid 'GI.WebKit2.Objects.Settings.Settings' object.
To modify any of the /@webView@/ settings, you can either create
a new 'GI.WebKit2.Objects.Settings.Settings' object with 'GI.WebKit2.Objects.Settings.settingsNew', setting
the desired preferences, and then replace the existing /@webView@/
settings with 'GI.WebKit2.Objects.WebView.webViewSetSettings' or get the existing
/@webView@/ settings and update it directly. 'GI.WebKit2.Objects.Settings.Settings' objects
can be shared by multiple 'GI.WebKit2.Objects.WebView.WebView'\<!-- -->s, so modifying
the settings of a 'GI.WebKit2.Objects.WebView.WebView' would affect other
'GI.WebKit2.Objects.WebView.WebView'\<!-- -->s using the same 'GI.WebKit2.Objects.Settings.Settings'.
-}
webViewGetSettings ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebView a) =>
    a
    {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -}
    -> m WebKit2.Settings.Settings
    {- ^ __Returns:__ the 'GI.WebKit2.Objects.Settings.Settings' attached to /@webView@/ -}
webViewGetSettings webView = liftIO $ do
    webView' <- unsafeManagedPtrCastPtr webView
    result <- webkit_web_view_get_settings webView'
    checkUnexpectedReturnNULL "webViewGetSettings" result
    result' <- (newObject WebKit2.Settings.Settings) result
    touchManagedPtr webView
    return result'

data WebViewGetSettingsMethodInfo
instance (signature ~ (m WebKit2.Settings.Settings), MonadIO m, IsWebView a) => O.MethodInfo WebViewGetSettingsMethodInfo a signature where
    overloadedMethod _ = webViewGetSettings

-- method WebView::get_snapshot
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "region", argType = TInterface (Name {namespace = "WebKit2", name = "SnapshotRegion"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #WebKitSnapshotRegion for this snapshot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "options", argType = TInterface (Name {namespace = "WebKit2", name = "SnapshotOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#WebKitSnapshotOptions for the snapshot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GAsyncReadyCallback", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data", 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_view_get_snapshot" webkit_web_view_get_snapshot :: 
    Ptr WebView ->                          -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"})
    CUInt ->                                -- region : TInterface (Name {namespace = "WebKit2", name = "SnapshotRegion"})
    CUInt ->                                -- options : TInterface (Name {namespace = "WebKit2", name = "SnapshotOptions"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO ()

{- |
Asynchronously retrieves a snapshot of /@webView@/ for /@region@/.
/@options@/ specifies how the snapshot should be rendered.

When the operation is finished, /@callback@/ will be called. You must
call 'GI.WebKit2.Objects.WebView.webViewGetSnapshotFinish' to get the result of the
operation.
-}
webViewGetSnapshot ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebView a, Gio.Cancellable.IsCancellable b) =>
    a
    {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -}
    -> WebKit2.Enums.SnapshotRegion
    {- ^ /@region@/: the 'GI.WebKit2.Enums.SnapshotRegion' for this snapshot -}
    -> [WebKit2.Flags.SnapshotOptions]
    {- ^ /@options@/: 'GI.WebKit2.Flags.SnapshotOptions' for the snapshot -}
    -> Maybe (b)
    {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable' -}
    -> Maybe (Gio.Callbacks.AsyncReadyCallback)
    {- ^ /@callback@/: a 'GI.Gio.Callbacks.AsyncReadyCallback' -}
    -> m ()
webViewGetSnapshot webView region options cancellable callback = liftIO $ do
    webView' <- unsafeManagedPtrCastPtr webView
    let region' = (fromIntegral . fromEnum) region
    let options' = gflagsToWord options
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
    maybeCallback <- case callback of
        Nothing -> return (castPtrToFunPtr nullPtr)
        Just jCallback -> do
            jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback))
            poke ptrcallback jCallback'
            return jCallback'
    let userData = nullPtr
    webkit_web_view_get_snapshot webView' region' options' maybeCancellable maybeCallback userData
    touchManagedPtr webView
    whenJust cancellable touchManagedPtr
    return ()

data WebViewGetSnapshotMethodInfo
instance (signature ~ (WebKit2.Enums.SnapshotRegion -> [WebKit2.Flags.SnapshotOptions] -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsWebView a, Gio.Cancellable.IsCancellable b) => O.MethodInfo WebViewGetSnapshotMethodInfo a signature where
    overloadedMethod _ = webViewGetSnapshot

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

foreign import ccall "webkit_web_view_get_snapshot_finish" webkit_web_view_get_snapshot_finish :: 
    Ptr WebView ->                          -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"})
    Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr Cairo.Surface.Surface)

{- |
Finishes an asynchronous operation started with 'GI.WebKit2.Objects.WebView.webViewGetSnapshot'.
-}
webViewGetSnapshotFinish ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebView a, Gio.AsyncResult.IsAsyncResult b) =>
    a
    {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -}
    -> b
    {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult' -}
    -> m Cairo.Surface.Surface
    {- ^ __Returns:__ a 'GI.Cairo.Structs.Surface.Surface' with the retrieved snapshot or 'Nothing' in error. /(Can throw 'Data.GI.Base.GError.GError')/ -}
webViewGetSnapshotFinish webView result_ = liftIO $ do
    webView' <- unsafeManagedPtrCastPtr webView
    result_' <- unsafeManagedPtrCastPtr result_
    onException (do
        result <- propagateGError $ webkit_web_view_get_snapshot_finish webView' result_'
        checkUnexpectedReturnNULL "webViewGetSnapshotFinish" result
        result' <- (wrapBoxed Cairo.Surface.Surface) result
        touchManagedPtr webView
        touchManagedPtr result_
        return result'
     ) (do
        return ()
     )

data WebViewGetSnapshotFinishMethodInfo
instance (signature ~ (b -> m Cairo.Surface.Surface), MonadIO m, IsWebView a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo WebViewGetSnapshotFinishMethodInfo a signature where
    overloadedMethod _ = webViewGetSnapshotFinish

-- method WebView::get_title
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), 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 (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_get_title" webkit_web_view_get_title :: 
    Ptr WebView ->                          -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"})
    IO CString

{- |
Gets the value of the 'GI.WebKit2.Objects.WebView.WebView':@/title/@ property.
You can connect to notify::title signal of /@webView@/ to
be notified when the title has been received.
-}
webViewGetTitle ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebView a) =>
    a
    {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -}
    -> m T.Text
    {- ^ __Returns:__ The main frame document title of /@webView@/. -}
webViewGetTitle webView = liftIO $ do
    webView' <- unsafeManagedPtrCastPtr webView
    result <- webkit_web_view_get_title webView'
    checkUnexpectedReturnNULL "webViewGetTitle" result
    result' <- cstringToText result
    touchManagedPtr webView
    return result'

data WebViewGetTitleMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsWebView a) => O.MethodInfo WebViewGetTitleMethodInfo a signature where
    overloadedMethod _ = webViewGetTitle

-- method WebView::get_tls_info
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "certificate", argType = TInterface (Name {namespace = "Gio", name = "TlsCertificate"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for a #GTlsCertificate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "errors", argType = TInterface (Name {namespace = "Gio", name = "TlsCertificateFlags"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for a #GTlsCertificateFlags the verification status of @certificate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_get_tls_info" webkit_web_view_get_tls_info :: 
    Ptr WebView ->                          -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"})
    Ptr (Ptr Gio.TlsCertificate.TlsCertificate) -> -- certificate : TInterface (Name {namespace = "Gio", name = "TlsCertificate"})
    Ptr CUInt ->                            -- errors : TInterface (Name {namespace = "Gio", name = "TlsCertificateFlags"})
    IO CInt

{- |
Retrieves the 'GI.Gio.Objects.TlsCertificate.TlsCertificate' associated with the main resource of /@webView@/,
and the 'GI.Gio.Flags.TlsCertificateFlags' showing what problems, if any, have been found
with that certificate.
If the connection is not HTTPS, this function returns 'False'.
This function should be called after a response has been received from the
server, so you can connect to 'GI.WebKit2.Objects.WebView.WebView'::@/load-changed/@ and call this function
when it\'s emitted with 'GI.WebKit2.Enums.LoadEventCommitted' event.

Note that this function provides no information about the security of the web
page if the current 'GI.WebKit2.Enums.TLSErrorsPolicy' is /@wEBKITTLSERRORSPOLICYIGNORE@/,
as subresources of the page may be controlled by an attacker. This function
may safely be used to determine the security status of the current page only
if the current 'GI.WebKit2.Enums.TLSErrorsPolicy' is /@wEBKITTLSERRORSPOLICYFAIL@/, in
which case subresources that fail certificate verification will be blocked.
-}
webViewGetTlsInfo ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebView a) =>
    a
    {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -}
    -> m (Bool,Gio.TlsCertificate.TlsCertificate,[Gio.Flags.TlsCertificateFlags])
    {- ^ __Returns:__ 'True' if the /@webView@/ connection uses HTTPS and a response has been received
   from the server, or 'False' otherwise. -}
webViewGetTlsInfo webView = liftIO $ do
    webView' <- unsafeManagedPtrCastPtr webView
    certificate <- allocMem :: IO (Ptr (Ptr Gio.TlsCertificate.TlsCertificate))
    errors <- allocMem :: IO (Ptr CUInt)
    result <- webkit_web_view_get_tls_info webView' certificate errors
    let result' = (/= 0) result
    certificate' <- peek certificate
    certificate'' <- (newObject Gio.TlsCertificate.TlsCertificate) certificate'
    errors' <- peek errors
    let errors'' = wordToGFlags errors'
    touchManagedPtr webView
    freeMem certificate
    freeMem errors
    return (result', certificate'', errors'')

data WebViewGetTlsInfoMethodInfo
instance (signature ~ (m (Bool,Gio.TlsCertificate.TlsCertificate,[Gio.Flags.TlsCertificateFlags])), MonadIO m, IsWebView a) => O.MethodInfo WebViewGetTlsInfoMethodInfo a signature where
    overloadedMethod _ = webViewGetTlsInfo

-- method WebView::get_uri
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), 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 (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_get_uri" webkit_web_view_get_uri :: 
    Ptr WebView ->                          -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"})
    IO CString

{- |
Returns the current active URI of /@webView@/. The active URI might change during
a load operation:

\<orderedlist>
\<listitem>\<para>
  When nothing has been loaded yet on /@webView@/ the active URI is 'Nothing'.
\<\/para>\<\/listitem>
\<listitem>\<para>
  When a new load operation starts the active URI is the requested URI:
  \<itemizedlist>
  \<listitem>\<para>
    If the load operation was started by 'GI.WebKit2.Objects.WebView.webViewLoadUri',
    the requested URI is the given one.
  \<\/para>\<\/listitem>
  \<listitem>\<para>
    If the load operation was started by 'GI.WebKit2.Objects.WebView.webViewLoadHtml',
    the requested URI is \"about:blank\".
  \<\/para>\<\/listitem>
  \<listitem>\<para>
    If the load operation was started by 'GI.WebKit2.Objects.WebView.webViewLoadAlternateHtml',
    the requested URI is content URI provided.
  \<\/para>\<\/listitem>
  \<listitem>\<para>
    If the load operation was started by 'GI.WebKit2.Objects.WebView.webViewGoBack' or
    'GI.WebKit2.Objects.WebView.webViewGoForward', the requested URI is the original URI
    of the previous\/next item in the 'GI.WebKit2.Objects.BackForwardList.BackForwardList' of /@webView@/.
  \<\/para>\<\/listitem>
  \<listitem>\<para>
    If the load operation was started by
    'GI.WebKit2.Objects.WebView.webViewGoToBackForwardListItem', the requested URI
    is the opriginal URI of the given 'GI.WebKit2.Objects.BackForwardListItem.BackForwardListItem'.
  \<\/para>\<\/listitem>
  \<\/itemizedlist>
\<\/para>\<\/listitem>
\<listitem>\<para>
  If there is a server redirection during the load operation,
  the active URI is the redirected URI. When the signal
  'GI.WebKit2.Objects.WebView.WebView'::@/load-changed/@ is emitted with 'GI.WebKit2.Enums.LoadEventRedirected'
  event, the active URI is already updated to the redirected URI.
\<\/para>\<\/listitem>
\<listitem>\<para>
  When the signal 'GI.WebKit2.Objects.WebView.WebView'::@/load-changed/@ is emitted
  with 'GI.WebKit2.Enums.LoadEventCommitted' event, the active URI is the final
  one and it will not change unless a new load operation is started
  or a navigation action within the same page is performed.
\<\/para>\<\/listitem>
\<\/orderedlist>

You can monitor the active URI by connecting to the notify::uri
signal of /@webView@/.
-}
webViewGetUri ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebView a) =>
    a
    {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -}
    -> m (Maybe T.Text)
    {- ^ __Returns:__ the current active URI of /@webView@/ or 'Nothing'
   if nothing has been loaded yet. -}
webViewGetUri webView = liftIO $ do
    webView' <- unsafeManagedPtrCastPtr webView
    result <- webkit_web_view_get_uri webView'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- cstringToText result'
        return result''
    touchManagedPtr webView
    return maybeResult

data WebViewGetUriMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsWebView a) => O.MethodInfo WebViewGetUriMethodInfo a signature where
    overloadedMethod _ = webViewGetUri

-- method WebView::get_user_content_manager
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), 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 = "WebKit2", name = "UserContentManager"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_get_user_content_manager" webkit_web_view_get_user_content_manager :: 
    Ptr WebView ->                          -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"})
    IO (Ptr WebKit2.UserContentManager.UserContentManager)

{- |
Gets the user content manager associated to /@webView@/, or 'Nothing' if the
view does not have an user content manager.

@since 2.6
-}
webViewGetUserContentManager ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebView a) =>
    a
    {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -}
    -> m WebKit2.UserContentManager.UserContentManager
    {- ^ __Returns:__ the 'GI.WebKit2.Objects.UserContentManager.UserContentManager' associated with the view -}
webViewGetUserContentManager webView = liftIO $ do
    webView' <- unsafeManagedPtrCastPtr webView
    result <- webkit_web_view_get_user_content_manager webView'
    checkUnexpectedReturnNULL "webViewGetUserContentManager" result
    result' <- (newObject WebKit2.UserContentManager.UserContentManager) result
    touchManagedPtr webView
    return result'

data WebViewGetUserContentManagerMethodInfo
instance (signature ~ (m WebKit2.UserContentManager.UserContentManager), MonadIO m, IsWebView a) => O.MethodInfo WebViewGetUserContentManagerMethodInfo a signature where
    overloadedMethod _ = webViewGetUserContentManager

-- method WebView::get_window_properties
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), 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 = "WebKit2", name = "WindowProperties"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_get_window_properties" webkit_web_view_get_window_properties :: 
    Ptr WebView ->                          -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"})
    IO (Ptr WebKit2.WindowProperties.WindowProperties)

{- |
Get the 'GI.WebKit2.Objects.WindowProperties.WindowProperties' object containing the properties
that the window containing /@webView@/ should have.
-}
webViewGetWindowProperties ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebView a) =>
    a
    {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -}
    -> m WebKit2.WindowProperties.WindowProperties
    {- ^ __Returns:__ the 'GI.WebKit2.Objects.WindowProperties.WindowProperties' of /@webView@/ -}
webViewGetWindowProperties webView = liftIO $ do
    webView' <- unsafeManagedPtrCastPtr webView
    result <- webkit_web_view_get_window_properties webView'
    checkUnexpectedReturnNULL "webViewGetWindowProperties" result
    result' <- (newObject WebKit2.WindowProperties.WindowProperties) result
    touchManagedPtr webView
    return result'

data WebViewGetWindowPropertiesMethodInfo
instance (signature ~ (m WebKit2.WindowProperties.WindowProperties), MonadIO m, IsWebView a) => O.MethodInfo WebViewGetWindowPropertiesMethodInfo a signature where
    overloadedMethod _ = webViewGetWindowProperties

-- method WebView::get_zoom_level
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), 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 (TBasicType TDouble)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_get_zoom_level" webkit_web_view_get_zoom_level :: 
    Ptr WebView ->                          -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"})
    IO CDouble

{- |
Get the zoom level of /@webView@/, i.e. the factor by which the
view contents are scaled with respect to their original size.
-}
webViewGetZoomLevel ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebView a) =>
    a
    {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -}
    -> m Double
    {- ^ __Returns:__ the current zoom level of /@webView@/ -}
webViewGetZoomLevel webView = liftIO $ do
    webView' <- unsafeManagedPtrCastPtr webView
    result <- webkit_web_view_get_zoom_level webView'
    let result' = realToFrac result
    touchManagedPtr webView
    return result'

data WebViewGetZoomLevelMethodInfo
instance (signature ~ (m Double), MonadIO m, IsWebView a) => O.MethodInfo WebViewGetZoomLevelMethodInfo a signature where
    overloadedMethod _ = webViewGetZoomLevel

-- method WebView::go_back
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", 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_view_go_back" webkit_web_view_go_back :: 
    Ptr WebView ->                          -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"})
    IO ()

{- |
Loads the previous history item.
You can monitor the load operation by connecting to
'GI.WebKit2.Objects.WebView.WebView'::@/load-changed/@ signal.
-}
webViewGoBack ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebView a) =>
    a
    {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -}
    -> m ()
webViewGoBack webView = liftIO $ do
    webView' <- unsafeManagedPtrCastPtr webView
    webkit_web_view_go_back webView'
    touchManagedPtr webView
    return ()

data WebViewGoBackMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWebView a) => O.MethodInfo WebViewGoBackMethodInfo a signature where
    overloadedMethod _ = webViewGoBack

-- method WebView::go_forward
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", 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_view_go_forward" webkit_web_view_go_forward :: 
    Ptr WebView ->                          -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"})
    IO ()

{- |
Loads the next history item.
You can monitor the load operation by connecting to
'GI.WebKit2.Objects.WebView.WebView'::@/load-changed/@ signal.
-}
webViewGoForward ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebView a) =>
    a
    {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -}
    -> m ()
webViewGoForward webView = liftIO $ do
    webView' <- unsafeManagedPtrCastPtr webView
    webkit_web_view_go_forward webView'
    touchManagedPtr webView
    return ()

data WebViewGoForwardMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWebView a) => O.MethodInfo WebViewGoForwardMethodInfo a signature where
    overloadedMethod _ = webViewGoForward

-- method WebView::go_to_back_forward_list_item
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "list_item", argType = TInterface (Name {namespace = "WebKit2", name = "BackForwardListItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitBackForwardListItem", 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_view_go_to_back_forward_list_item" webkit_web_view_go_to_back_forward_list_item :: 
    Ptr WebView ->                          -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"})
    Ptr WebKit2.BackForwardListItem.BackForwardListItem -> -- list_item : TInterface (Name {namespace = "WebKit2", name = "BackForwardListItem"})
    IO ()

{- |
Loads the specific history item /@listItem@/.
You can monitor the load operation by connecting to
'GI.WebKit2.Objects.WebView.WebView'::@/load-changed/@ signal.
-}
webViewGoToBackForwardListItem ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebView a, WebKit2.BackForwardListItem.IsBackForwardListItem b) =>
    a
    {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -}
    -> b
    {- ^ /@listItem@/: a 'GI.WebKit2.Objects.BackForwardListItem.BackForwardListItem' -}
    -> m ()
webViewGoToBackForwardListItem webView listItem = liftIO $ do
    webView' <- unsafeManagedPtrCastPtr webView
    listItem' <- unsafeManagedPtrCastPtr listItem
    webkit_web_view_go_to_back_forward_list_item webView' listItem'
    touchManagedPtr webView
    touchManagedPtr listItem
    return ()

data WebViewGoToBackForwardListItemMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsWebView a, WebKit2.BackForwardListItem.IsBackForwardListItem b) => O.MethodInfo WebViewGoToBackForwardListItemMethodInfo a signature where
    overloadedMethod _ = webViewGoToBackForwardListItem

-- method WebView::is_editable
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_is_editable" webkit_web_view_is_editable :: 
    Ptr WebView ->                          -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"})
    IO CInt

{- |
/No description available in the introspection data./
-}
webViewIsEditable ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebView a) =>
    a
    -> m Bool
webViewIsEditable webView = liftIO $ do
    webView' <- unsafeManagedPtrCastPtr webView
    result <- webkit_web_view_is_editable webView'
    let result' = (/= 0) result
    touchManagedPtr webView
    return result'

data WebViewIsEditableMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWebView a) => O.MethodInfo WebViewIsEditableMethodInfo a signature where
    overloadedMethod _ = webViewIsEditable

-- method WebView::is_loading
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), 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 (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_is_loading" webkit_web_view_is_loading :: 
    Ptr WebView ->                          -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"})
    IO CInt

{- |
Gets the value of the 'GI.WebKit2.Objects.WebView.WebView':@/is-loading/@ property.
You can monitor when a 'GI.WebKit2.Objects.WebView.WebView' is loading a page by connecting to
notify::is-loading signal of /@webView@/. This is useful when you are
interesting in knowing when the view is loding something but not in the
details about the status of the load operation, for example to start a spinner
when the view is loading a page and stop it when it finishes.
-}
webViewIsLoading ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebView a) =>
    a
    {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if /@webView@/ is loading a page or 'False' otherwise. -}
webViewIsLoading webView = liftIO $ do
    webView' <- unsafeManagedPtrCastPtr webView
    result <- webkit_web_view_is_loading webView'
    let result' = (/= 0) result
    touchManagedPtr webView
    return result'

data WebViewIsLoadingMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWebView a) => O.MethodInfo WebViewIsLoadingMethodInfo a signature where
    overloadedMethod _ = webViewIsLoading

-- method WebView::is_playing_audio
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), 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 (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_is_playing_audio" webkit_web_view_is_playing_audio :: 
    Ptr WebView ->                          -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"})
    IO CInt

{- |
Gets the value of the 'GI.WebKit2.Objects.WebView.WebView':@/is-playing-audio/@ property.
You can monitor when a page in a 'GI.WebKit2.Objects.WebView.WebView' is playing audio by
connecting to the notify::is-playing-audio signal of /@webView@/. This
is useful when the application wants to provide visual feedback when a
page is producing sound.

@since 2.8
-}
webViewIsPlayingAudio ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebView a) =>
    a
    {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if a page in /@webView@/ is playing audio or 'False' otherwise. -}
webViewIsPlayingAudio webView = liftIO $ do
    webView' <- unsafeManagedPtrCastPtr webView
    result <- webkit_web_view_is_playing_audio webView'
    let result' = (/= 0) result
    touchManagedPtr webView
    return result'

data WebViewIsPlayingAudioMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWebView a) => O.MethodInfo WebViewIsPlayingAudioMethodInfo a signature where
    overloadedMethod _ = webViewIsPlayingAudio

-- method WebView::load_alternate_html
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", 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 new content to display as the main page of the @web_view", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "content_uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the URI for the alternate page content", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "base_uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the base URI for relative locations or %NULL", 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_view_load_alternate_html" webkit_web_view_load_alternate_html :: 
    Ptr WebView ->                          -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"})
    CString ->                              -- content : TBasicType TUTF8
    CString ->                              -- content_uri : TBasicType TUTF8
    CString ->                              -- base_uri : TBasicType TUTF8
    IO ()

{- |
Load the given /@content@/ string for the URI /@contentUri@/.
This allows clients to display page-loading errors in the 'GI.WebKit2.Objects.WebView.WebView' itself.
When this method is called from 'GI.WebKit2.Objects.WebView.WebView'::@/load-failed/@ signal to show an
error page, the the back-forward list is maintained appropriately.
For everything else this method works the same way as 'GI.WebKit2.Objects.WebView.webViewLoadHtml'.
-}
webViewLoadAlternateHtml ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebView a) =>
    a
    {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -}
    -> T.Text
    {- ^ /@content@/: the new content to display as the main page of the /@webView@/ -}
    -> T.Text
    {- ^ /@contentUri@/: the URI for the alternate page content -}
    -> Maybe (T.Text)
    {- ^ /@baseUri@/: the base URI for relative locations or 'Nothing' -}
    -> m ()
webViewLoadAlternateHtml webView content contentUri baseUri = liftIO $ do
    webView' <- unsafeManagedPtrCastPtr webView
    content' <- textToCString content
    contentUri' <- textToCString contentUri
    maybeBaseUri <- case baseUri of
        Nothing -> return nullPtr
        Just jBaseUri -> do
            jBaseUri' <- textToCString jBaseUri
            return jBaseUri'
    webkit_web_view_load_alternate_html webView' content' contentUri' maybeBaseUri
    touchManagedPtr webView
    freeMem content'
    freeMem contentUri'
    freeMem maybeBaseUri
    return ()

data WebViewLoadAlternateHtmlMethodInfo
instance (signature ~ (T.Text -> T.Text -> Maybe (T.Text) -> m ()), MonadIO m, IsWebView a) => O.MethodInfo WebViewLoadAlternateHtmlMethodInfo a signature where
    overloadedMethod _ = webViewLoadAlternateHtml

-- method WebView::load_bytes
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "bytes", argType = TInterface (Name {namespace = "GLib", name = "Bytes"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "input data to load", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mime_type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the MIME type of @bytes, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "encoding", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the character encoding of @bytes, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "base_uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the base URI for relative locations or %NULL", 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_view_load_bytes" webkit_web_view_load_bytes :: 
    Ptr WebView ->                          -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"})
    Ptr GLib.Bytes.Bytes ->                 -- bytes : TInterface (Name {namespace = "GLib", name = "Bytes"})
    CString ->                              -- mime_type : TBasicType TUTF8
    CString ->                              -- encoding : TBasicType TUTF8
    CString ->                              -- base_uri : TBasicType TUTF8
    IO ()

{- |
Load the specified /@bytes@/ into /@webView@/ using the given /@mimeType@/ and /@encoding@/.
When /@mimeType@/ is 'Nothing', it defaults to \"text\/html\".
When /@encoding@/ is 'Nothing', it defaults to \"UTF-8\".
When /@baseUri@/ is 'Nothing', it defaults to \"about:blank\".
You can monitor the load operation by connecting to 'GI.WebKit2.Objects.WebView.WebView'::@/load-changed/@ signal.

@since 2.6
-}
webViewLoadBytes ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebView a) =>
    a
    {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -}
    -> GLib.Bytes.Bytes
    {- ^ /@bytes@/: input data to load -}
    -> Maybe (T.Text)
    {- ^ /@mimeType@/: the MIME type of /@bytes@/, or 'Nothing' -}
    -> Maybe (T.Text)
    {- ^ /@encoding@/: the character encoding of /@bytes@/, or 'Nothing' -}
    -> Maybe (T.Text)
    {- ^ /@baseUri@/: the base URI for relative locations or 'Nothing' -}
    -> m ()
webViewLoadBytes webView bytes mimeType encoding baseUri = liftIO $ do
    webView' <- unsafeManagedPtrCastPtr webView
    bytes' <- unsafeManagedPtrGetPtr bytes
    maybeMimeType <- case mimeType of
        Nothing -> return nullPtr
        Just jMimeType -> do
            jMimeType' <- textToCString jMimeType
            return jMimeType'
    maybeEncoding <- case encoding of
        Nothing -> return nullPtr
        Just jEncoding -> do
            jEncoding' <- textToCString jEncoding
            return jEncoding'
    maybeBaseUri <- case baseUri of
        Nothing -> return nullPtr
        Just jBaseUri -> do
            jBaseUri' <- textToCString jBaseUri
            return jBaseUri'
    webkit_web_view_load_bytes webView' bytes' maybeMimeType maybeEncoding maybeBaseUri
    touchManagedPtr webView
    touchManagedPtr bytes
    freeMem maybeMimeType
    freeMem maybeEncoding
    freeMem maybeBaseUri
    return ()

data WebViewLoadBytesMethodInfo
instance (signature ~ (GLib.Bytes.Bytes -> Maybe (T.Text) -> Maybe (T.Text) -> Maybe (T.Text) -> m ()), MonadIO m, IsWebView a) => O.MethodInfo WebViewLoadBytesMethodInfo a signature where
    overloadedMethod _ = webViewLoadBytes

-- method WebView::load_html
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", 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 HTML string to load", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "base_uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "The base URI for relative locations or %NULL", 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_view_load_html" webkit_web_view_load_html :: 
    Ptr WebView ->                          -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"})
    CString ->                              -- content : TBasicType TUTF8
    CString ->                              -- base_uri : TBasicType TUTF8
    IO ()

{- |
Load the given /@content@/ string with the specified /@baseUri@/.
If /@baseUri@/ is not 'Nothing', relative URLs in the /@content@/ will be
resolved against /@baseUri@/ and absolute local paths must be children of the /@baseUri@/.
For security reasons absolute local paths that are not children of /@baseUri@/
will cause the web process to terminate.
If you need to include URLs in /@content@/ that are local paths in a different
directory than /@baseUri@/ you can build a data URI for them. When /@baseUri@/ is 'Nothing',
it defaults to \"about:blank\". The mime type of the document will be \"text\/html\".
You can monitor the load operation by connecting to 'GI.WebKit2.Objects.WebView.WebView'::@/load-changed/@ signal.
-}
webViewLoadHtml ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebView a) =>
    a
    {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -}
    -> T.Text
    {- ^ /@content@/: The HTML string to load -}
    -> Maybe (T.Text)
    {- ^ /@baseUri@/: The base URI for relative locations or 'Nothing' -}
    -> m ()
webViewLoadHtml webView content baseUri = liftIO $ do
    webView' <- unsafeManagedPtrCastPtr webView
    content' <- textToCString content
    maybeBaseUri <- case baseUri of
        Nothing -> return nullPtr
        Just jBaseUri -> do
            jBaseUri' <- textToCString jBaseUri
            return jBaseUri'
    webkit_web_view_load_html webView' content' maybeBaseUri
    touchManagedPtr webView
    freeMem content'
    freeMem maybeBaseUri
    return ()

data WebViewLoadHtmlMethodInfo
instance (signature ~ (T.Text -> Maybe (T.Text) -> m ()), MonadIO m, IsWebView a) => O.MethodInfo WebViewLoadHtmlMethodInfo a signature where
    overloadedMethod _ = webViewLoadHtml

-- method WebView::load_plain_text
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "plain_text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The plain text to load", 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_view_load_plain_text" webkit_web_view_load_plain_text :: 
    Ptr WebView ->                          -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"})
    CString ->                              -- plain_text : TBasicType TUTF8
    IO ()

{- |
Load the specified /@plainText@/ string into /@webView@/. The mime type of
document will be \"text\/plain\". You can monitor the load
operation by connecting to 'GI.WebKit2.Objects.WebView.WebView'::@/load-changed/@ signal.
-}
webViewLoadPlainText ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebView a) =>
    a
    {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -}
    -> T.Text
    {- ^ /@plainText@/: The plain text to load -}
    -> m ()
webViewLoadPlainText webView plainText = liftIO $ do
    webView' <- unsafeManagedPtrCastPtr webView
    plainText' <- textToCString plainText
    webkit_web_view_load_plain_text webView' plainText'
    touchManagedPtr webView
    freeMem plainText'
    return ()

data WebViewLoadPlainTextMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsWebView a) => O.MethodInfo WebViewLoadPlainTextMethodInfo a signature where
    overloadedMethod _ = webViewLoadPlainText

-- method WebView::load_request
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "request", argType = TInterface (Name {namespace = "WebKit2", name = "URIRequest"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitURIRequest to load", 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_view_load_request" webkit_web_view_load_request :: 
    Ptr WebView ->                          -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"})
    Ptr WebKit2.URIRequest.URIRequest ->    -- request : TInterface (Name {namespace = "WebKit2", name = "URIRequest"})
    IO ()

{- |
Requests loading of the specified 'GI.WebKit2.Objects.URIRequest.URIRequest'.
You can monitor the load operation by connecting to
'GI.WebKit2.Objects.WebView.WebView'::@/load-changed/@ signal.
-}
webViewLoadRequest ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebView a, WebKit2.URIRequest.IsURIRequest b) =>
    a
    {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -}
    -> b
    {- ^ /@request@/: a 'GI.WebKit2.Objects.URIRequest.URIRequest' to load -}
    -> m ()
webViewLoadRequest webView request = liftIO $ do
    webView' <- unsafeManagedPtrCastPtr webView
    request' <- unsafeManagedPtrCastPtr request
    webkit_web_view_load_request webView' request'
    touchManagedPtr webView
    touchManagedPtr request
    return ()

data WebViewLoadRequestMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsWebView a, WebKit2.URIRequest.IsURIRequest b) => O.MethodInfo WebViewLoadRequestMethodInfo a signature where
    overloadedMethod _ = webViewLoadRequest

-- method WebView::load_uri
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", 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_view_load_uri" webkit_web_view_load_uri :: 
    Ptr WebView ->                          -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"})
    CString ->                              -- uri : TBasicType TUTF8
    IO ()

{- |
Requests loading of the specified URI string.
You can monitor the load operation by connecting to
'GI.WebKit2.Objects.WebView.WebView'::@/load-changed/@ signal.
-}
webViewLoadUri ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebView a) =>
    a
    {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -}
    -> T.Text
    {- ^ /@uri@/: an URI string -}
    -> m ()
webViewLoadUri webView uri = liftIO $ do
    webView' <- unsafeManagedPtrCastPtr webView
    uri' <- textToCString uri
    webkit_web_view_load_uri webView' uri'
    touchManagedPtr webView
    freeMem uri'
    return ()

data WebViewLoadUriMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsWebView a) => O.MethodInfo WebViewLoadUriMethodInfo a signature where
    overloadedMethod _ = webViewLoadUri

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

foreign import ccall "webkit_web_view_new_with_related_view" webkit_web_view_new_with_related_view :: 
    Ptr WebView ->                          -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"})
    IO (Ptr Gtk.Widget.Widget)

{- |
Creates a new 'GI.WebKit2.Objects.WebView.WebView' sharing the same web process with /@webView@/.
This method doesn\'t have any effect when 'GI.WebKit2.Enums.ProcessModelSharedSecondaryProcess'
process model is used, because a single web process is shared for all the web views in the
same 'GI.WebKit2.Objects.WebContext.WebContext'. When using 'GI.WebKit2.Enums.ProcessModelMultipleSecondaryProcesses' process model,
this method should always be used when creating the 'GI.WebKit2.Objects.WebView.WebView' in the 'GI.WebKit2.Objects.WebView.WebView'::@/create/@ signal.
You can also use this method to implement other process models based on 'GI.WebKit2.Enums.ProcessModelMultipleSecondaryProcesses',
like for example, sharing the same web process for all the views in the same security domain.

The newly created 'GI.WebKit2.Objects.WebView.WebView' will also have the same 'GI.WebKit2.Objects.UserContentManager.UserContentManager'
and 'GI.WebKit2.Objects.Settings.Settings' as /@webView@/.

@since 2.4
-}
webViewNewWithRelatedView ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebView a) =>
    a
    {- ^ /@webView@/: the related 'GI.WebKit2.Objects.WebView.WebView' -}
    -> m Gtk.Widget.Widget
    {- ^ __Returns:__ The newly created 'GI.WebKit2.Objects.WebView.WebView' widget -}
webViewNewWithRelatedView webView = liftIO $ do
    webView' <- unsafeManagedPtrCastPtr webView
    result <- webkit_web_view_new_with_related_view webView'
    checkUnexpectedReturnNULL "webViewNewWithRelatedView" result
    result' <- (wrapObject Gtk.Widget.Widget) result
    touchManagedPtr webView
    return result'

data WebViewNewWithRelatedViewMethodInfo
instance (signature ~ (m Gtk.Widget.Widget), MonadIO m, IsWebView a) => O.MethodInfo WebViewNewWithRelatedViewMethodInfo a signature where
    overloadedMethod _ = webViewNewWithRelatedView

-- method WebView::reload
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", 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_view_reload" webkit_web_view_reload :: 
    Ptr WebView ->                          -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"})
    IO ()

{- |
Reloads the current contents of /@webView@/.
See also 'GI.WebKit2.Objects.WebView.webViewReloadBypassCache'.
-}
webViewReload ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebView a) =>
    a
    {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -}
    -> m ()
webViewReload webView = liftIO $ do
    webView' <- unsafeManagedPtrCastPtr webView
    webkit_web_view_reload webView'
    touchManagedPtr webView
    return ()

data WebViewReloadMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWebView a) => O.MethodInfo WebViewReloadMethodInfo a signature where
    overloadedMethod _ = webViewReload

-- method WebView::reload_bypass_cache
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", 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_view_reload_bypass_cache" webkit_web_view_reload_bypass_cache :: 
    Ptr WebView ->                          -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"})
    IO ()

{- |
Reloads the current contents of /@webView@/ without
using any cached data.
-}
webViewReloadBypassCache ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebView a) =>
    a
    {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -}
    -> m ()
webViewReloadBypassCache webView = liftIO $ do
    webView' <- unsafeManagedPtrCastPtr webView
    webkit_web_view_reload_bypass_cache webView'
    touchManagedPtr webView
    return ()

data WebViewReloadBypassCacheMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWebView a) => O.MethodInfo WebViewReloadBypassCacheMethodInfo a signature where
    overloadedMethod _ = webViewReloadBypassCache

-- method WebView::restore_session_state
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "state", argType = TInterface (Name {namespace = "WebKit2", name = "WebViewSessionState"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebViewSessionState", 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_view_restore_session_state" webkit_web_view_restore_session_state :: 
    Ptr WebView ->                          -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"})
    Ptr WebKit2.WebViewSessionState.WebViewSessionState -> -- state : TInterface (Name {namespace = "WebKit2", name = "WebViewSessionState"})
    IO ()

{- |
Restore the /@webView@/ session state from /@state@/

@since 2.12
-}
webViewRestoreSessionState ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebView a) =>
    a
    {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -}
    -> WebKit2.WebViewSessionState.WebViewSessionState
    {- ^ /@state@/: a 'GI.WebKit2.Structs.WebViewSessionState.WebViewSessionState' -}
    -> m ()
webViewRestoreSessionState webView state = liftIO $ do
    webView' <- unsafeManagedPtrCastPtr webView
    state' <- unsafeManagedPtrGetPtr state
    webkit_web_view_restore_session_state webView' state'
    touchManagedPtr webView
    touchManagedPtr state
    return ()

data WebViewRestoreSessionStateMethodInfo
instance (signature ~ (WebKit2.WebViewSessionState.WebViewSessionState -> m ()), MonadIO m, IsWebView a) => O.MethodInfo WebViewRestoreSessionStateMethodInfo a signature where
    overloadedMethod _ = webViewRestoreSessionState

-- method WebView::run_javascript
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "script", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the script to run", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable or %NULL to ignore", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GAsyncReadyCallback to call when the script finished", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the data to pass to callback function", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_run_javascript" webkit_web_view_run_javascript :: 
    Ptr WebView ->                          -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"})
    CString ->                              -- script : TBasicType TUTF8
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO ()

{- |
Asynchronously run /@script@/ in the context of the current page in /@webView@/. If
WebKitWebSettings:enable-javascript is FALSE, this method will do nothing.

When the operation is finished, /@callback@/ will be called. You can then call
'GI.WebKit2.Objects.WebView.webViewRunJavascriptFinish' to get the result of the operation.
-}
webViewRunJavascript ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebView a, Gio.Cancellable.IsCancellable b) =>
    a
    {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -}
    -> T.Text
    {- ^ /@script@/: the script to run -}
    -> Maybe (b)
    {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable' or 'Nothing' to ignore -}
    -> Maybe (Gio.Callbacks.AsyncReadyCallback)
    {- ^ /@callback@/: a 'GI.Gio.Callbacks.AsyncReadyCallback' to call when the script finished -}
    -> m ()
webViewRunJavascript webView script cancellable callback = liftIO $ do
    webView' <- unsafeManagedPtrCastPtr webView
    script' <- textToCString script
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
    maybeCallback <- case callback of
        Nothing -> return (castPtrToFunPtr nullPtr)
        Just jCallback -> do
            jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback))
            poke ptrcallback jCallback'
            return jCallback'
    let userData = nullPtr
    webkit_web_view_run_javascript webView' script' maybeCancellable maybeCallback userData
    touchManagedPtr webView
    whenJust cancellable touchManagedPtr
    freeMem script'
    return ()

data WebViewRunJavascriptMethodInfo
instance (signature ~ (T.Text -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsWebView a, Gio.Cancellable.IsCancellable b) => O.MethodInfo WebViewRunJavascriptMethodInfo a signature where
    overloadedMethod _ = webViewRunJavascript

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

foreign import ccall "webkit_web_view_run_javascript_finish" webkit_web_view_run_javascript_finish :: 
    Ptr WebView ->                          -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"})
    Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr WebKit2.JavascriptResult.JavascriptResult)

{- |
Finish an asynchronous operation started with 'GI.WebKit2.Objects.WebView.webViewRunJavascript'.

This is an example of using 'GI.WebKit2.Objects.WebView.webViewRunJavascript' with a script returning
a string:

\<informalexample>\<programlisting>
static void
web_view_javascript_finished (GObject      *object,
                              GAsyncResult *result,
                              gpointer      user_data)
{
    WebKitJavascriptResult *js_result;
    JSValueRef              value;
    JSGlobalContextRef      context;
    GError                 *error = NULL;

    js_result = webkit_web_view_run_javascript_finish (WEBKIT_WEB_VIEW (object), result, &error);
    if (!js_result) {
        g_warning (\"Error running javascript: @/s/@\", error->message);
        g_error_free (error);
        return;
    }

    context = webkit_javascript_result_get_global_context (js_result);
    value = webkit_javascript_result_get_value (js_result);
    if (JSValueIsString (context, value)) {
        JSStringRef js_str_value;
        gchar      *str_value;
        gsize       str_length;

        js_str_value = JSValueToStringCopy (context, value, NULL);
        str_length = JSStringGetMaximumUTF8CStringSize (js_str_value);
        str_value = (gchar *)g_malloc (str_length);
        JSStringGetUTF8CString (js_str_value, str_value, str_length);
        JSStringRelease (js_str_value);
        g_print (\"Script result: @/s/@\\n\", str_value);
        g_free (str_value);
    } else {
        g_warning (\"Error running javascript: unexpected return value\");
    }
    webkit_javascript_result_unref (js_result);
}

static void
web_view_get_link_url (WebKitWebView *web_view,
                       const gchar   *link_id)
{
    gchar *script;

    script = g_strdup_printf (\"window.document.getElementById(\'@/s/@\').href;\", link_id);
    webkit_web_view_run_javascript (web_view, script, NULL, web_view_javascript_finished, NULL);
    g_free (script);
}
\<\/programlisting>\<\/informalexample>
-}
webViewRunJavascriptFinish ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebView a, Gio.AsyncResult.IsAsyncResult b) =>
    a
    {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -}
    -> b
    {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult' -}
    -> m WebKit2.JavascriptResult.JavascriptResult
    {- ^ __Returns:__ a 'GI.WebKit2.Structs.JavascriptResult.JavascriptResult' with the result of the last executed statement in /@script@/
   or 'Nothing' in case of error /(Can throw 'Data.GI.Base.GError.GError')/ -}
webViewRunJavascriptFinish webView result_ = liftIO $ do
    webView' <- unsafeManagedPtrCastPtr webView
    result_' <- unsafeManagedPtrCastPtr result_
    onException (do
        result <- propagateGError $ webkit_web_view_run_javascript_finish webView' result_'
        checkUnexpectedReturnNULL "webViewRunJavascriptFinish" result
        result' <- (wrapBoxed WebKit2.JavascriptResult.JavascriptResult) result
        touchManagedPtr webView
        touchManagedPtr result_
        return result'
     ) (do
        return ()
     )

data WebViewRunJavascriptFinishMethodInfo
instance (signature ~ (b -> m WebKit2.JavascriptResult.JavascriptResult), MonadIO m, IsWebView a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo WebViewRunJavascriptFinishMethodInfo a signature where
    overloadedMethod _ = webViewRunJavascriptFinish

-- method WebView::run_javascript_from_gresource
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "resource", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the location of the resource to load", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable or %NULL to ignore", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GAsyncReadyCallback to call when the script finished", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the data to pass to callback function", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_run_javascript_from_gresource" webkit_web_view_run_javascript_from_gresource :: 
    Ptr WebView ->                          -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"})
    CString ->                              -- resource : TBasicType TUTF8
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO ()

{- |
Asynchronously run the script from /@resource@/ in the context of the
current page in /@webView@/.

When the operation is finished, /@callback@/ will be called. You can
then call 'GI.WebKit2.Objects.WebView.webViewRunJavascriptFromGresourceFinish' to get the result
of the operation.
-}
webViewRunJavascriptFromGresource ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebView a, Gio.Cancellable.IsCancellable b) =>
    a
    {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -}
    -> T.Text
    {- ^ /@resource@/: the location of the resource to load -}
    -> Maybe (b)
    {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable' or 'Nothing' to ignore -}
    -> Maybe (Gio.Callbacks.AsyncReadyCallback)
    {- ^ /@callback@/: a 'GI.Gio.Callbacks.AsyncReadyCallback' to call when the script finished -}
    -> m ()
webViewRunJavascriptFromGresource webView resource cancellable callback = liftIO $ do
    webView' <- unsafeManagedPtrCastPtr webView
    resource' <- textToCString resource
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
    maybeCallback <- case callback of
        Nothing -> return (castPtrToFunPtr nullPtr)
        Just jCallback -> do
            jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback))
            poke ptrcallback jCallback'
            return jCallback'
    let userData = nullPtr
    webkit_web_view_run_javascript_from_gresource webView' resource' maybeCancellable maybeCallback userData
    touchManagedPtr webView
    whenJust cancellable touchManagedPtr
    freeMem resource'
    return ()

data WebViewRunJavascriptFromGresourceMethodInfo
instance (signature ~ (T.Text -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsWebView a, Gio.Cancellable.IsCancellable b) => O.MethodInfo WebViewRunJavascriptFromGresourceMethodInfo a signature where
    overloadedMethod _ = webViewRunJavascriptFromGresource

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

foreign import ccall "webkit_web_view_run_javascript_from_gresource_finish" webkit_web_view_run_javascript_from_gresource_finish :: 
    Ptr WebView ->                          -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"})
    Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr WebKit2.JavascriptResult.JavascriptResult)

{- |
Finish an asynchronous operation started with 'GI.WebKit2.Objects.WebView.webViewRunJavascriptFromGresource'.

Check 'GI.WebKit2.Objects.WebView.webViewRunJavascriptFinish' for a usage example.
-}
webViewRunJavascriptFromGresourceFinish ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebView a, Gio.AsyncResult.IsAsyncResult b) =>
    a
    {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -}
    -> b
    {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult' -}
    -> m WebKit2.JavascriptResult.JavascriptResult
    {- ^ __Returns:__ a 'GI.WebKit2.Structs.JavascriptResult.JavascriptResult' with the result of the last executed statement in /@script@/
   or 'Nothing' in case of error /(Can throw 'Data.GI.Base.GError.GError')/ -}
webViewRunJavascriptFromGresourceFinish webView result_ = liftIO $ do
    webView' <- unsafeManagedPtrCastPtr webView
    result_' <- unsafeManagedPtrCastPtr result_
    onException (do
        result <- propagateGError $ webkit_web_view_run_javascript_from_gresource_finish webView' result_'
        checkUnexpectedReturnNULL "webViewRunJavascriptFromGresourceFinish" result
        result' <- (wrapBoxed WebKit2.JavascriptResult.JavascriptResult) result
        touchManagedPtr webView
        touchManagedPtr result_
        return result'
     ) (do
        return ()
     )

data WebViewRunJavascriptFromGresourceFinishMethodInfo
instance (signature ~ (b -> m WebKit2.JavascriptResult.JavascriptResult), MonadIO m, IsWebView a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo WebViewRunJavascriptFromGresourceFinishMethodInfo a signature where
    overloadedMethod _ = webViewRunJavascriptFromGresourceFinish

-- method WebView::save
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "save_mode", argType = TInterface (Name {namespace = "WebKit2", name = "SaveMode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #WebKitSaveMode specifying how the web page should be saved.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable or %NULL to ignore", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GAsyncReadyCallback to call when the request is satisfied", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the data to pass to callback function", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_save" webkit_web_view_save :: 
    Ptr WebView ->                          -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"})
    CUInt ->                                -- save_mode : TInterface (Name {namespace = "WebKit2", name = "SaveMode"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO ()

{- |
Asynchronously save the current web page associated to the
'GI.WebKit2.Objects.WebView.WebView' into a self-contained format using the mode
specified in /@saveMode@/.

When the operation is finished, /@callback@/ will be called. You can
then call 'GI.WebKit2.Objects.WebView.webViewSaveFinish' to get the result of the
operation.
-}
webViewSave ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebView a, Gio.Cancellable.IsCancellable b) =>
    a
    {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -}
    -> WebKit2.Enums.SaveMode
    {- ^ /@saveMode@/: the 'GI.WebKit2.Enums.SaveMode' specifying how the web page should be saved. -}
    -> Maybe (b)
    {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable' or 'Nothing' to ignore -}
    -> Maybe (Gio.Callbacks.AsyncReadyCallback)
    {- ^ /@callback@/: a 'GI.Gio.Callbacks.AsyncReadyCallback' to call when the request is satisfied -}
    -> m ()
webViewSave webView saveMode cancellable callback = liftIO $ do
    webView' <- unsafeManagedPtrCastPtr webView
    let saveMode' = (fromIntegral . fromEnum) saveMode
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
    maybeCallback <- case callback of
        Nothing -> return (castPtrToFunPtr nullPtr)
        Just jCallback -> do
            jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback))
            poke ptrcallback jCallback'
            return jCallback'
    let userData = nullPtr
    webkit_web_view_save webView' saveMode' maybeCancellable maybeCallback userData
    touchManagedPtr webView
    whenJust cancellable touchManagedPtr
    return ()

data WebViewSaveMethodInfo
instance (signature ~ (WebKit2.Enums.SaveMode -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsWebView a, Gio.Cancellable.IsCancellable b) => O.MethodInfo WebViewSaveMethodInfo a signature where
    overloadedMethod _ = webViewSave

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

foreign import ccall "webkit_web_view_save_finish" webkit_web_view_save_finish :: 
    Ptr WebView ->                          -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"})
    Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr Gio.InputStream.InputStream)

{- |
Finish an asynchronous operation started with 'GI.WebKit2.Objects.WebView.webViewSave'.
-}
webViewSaveFinish ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebView a, Gio.AsyncResult.IsAsyncResult b) =>
    a
    {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -}
    -> b
    {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult' -}
    -> m Gio.InputStream.InputStream
    {- ^ __Returns:__ a 'GI.Gio.Objects.InputStream.InputStream' with the result of saving
   the current web page or 'Nothing' in case of error. /(Can throw 'Data.GI.Base.GError.GError')/ -}
webViewSaveFinish webView result_ = liftIO $ do
    webView' <- unsafeManagedPtrCastPtr webView
    result_' <- unsafeManagedPtrCastPtr result_
    onException (do
        result <- propagateGError $ webkit_web_view_save_finish webView' result_'
        checkUnexpectedReturnNULL "webViewSaveFinish" result
        result' <- (wrapObject Gio.InputStream.InputStream) result
        touchManagedPtr webView
        touchManagedPtr result_
        return result'
     ) (do
        return ()
     )

data WebViewSaveFinishMethodInfo
instance (signature ~ (b -> m Gio.InputStream.InputStream), MonadIO m, IsWebView a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo WebViewSaveFinishMethodInfo a signature where
    overloadedMethod _ = webViewSaveFinish

-- method WebView::save_to_file
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "file", argType = TInterface (Name {namespace = "Gio", name = "File"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GFile where the current web page should be saved to.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "save_mode", argType = TInterface (Name {namespace = "WebKit2", name = "SaveMode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #WebKitSaveMode specifying how the web page should be saved.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable or %NULL to ignore", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GAsyncReadyCallback to call when the request is satisfied", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the data to pass to callback function", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_save_to_file" webkit_web_view_save_to_file :: 
    Ptr WebView ->                          -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"})
    Ptr Gio.File.File ->                    -- file : TInterface (Name {namespace = "Gio", name = "File"})
    CUInt ->                                -- save_mode : TInterface (Name {namespace = "WebKit2", name = "SaveMode"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO ()

{- |
Asynchronously save the current web page associated to the
'GI.WebKit2.Objects.WebView.WebView' into a self-contained format using the mode
specified in /@saveMode@/ and writing it to /@file@/.

When the operation is finished, /@callback@/ will be called. You can
then call 'GI.WebKit2.Objects.WebView.webViewSaveToFileFinish' to get the result of the
operation.
-}
webViewSaveToFile ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebView a, Gio.File.IsFile b, Gio.Cancellable.IsCancellable c) =>
    a
    {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -}
    -> b
    {- ^ /@file@/: the 'GI.Gio.Interfaces.File.File' where the current web page should be saved to. -}
    -> WebKit2.Enums.SaveMode
    {- ^ /@saveMode@/: the 'GI.WebKit2.Enums.SaveMode' specifying how the web page should be saved. -}
    -> Maybe (c)
    {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable' or 'Nothing' to ignore -}
    -> Maybe (Gio.Callbacks.AsyncReadyCallback)
    {- ^ /@callback@/: a 'GI.Gio.Callbacks.AsyncReadyCallback' to call when the request is satisfied -}
    -> m ()
webViewSaveToFile webView file saveMode cancellable callback = liftIO $ do
    webView' <- unsafeManagedPtrCastPtr webView
    file' <- unsafeManagedPtrCastPtr file
    let saveMode' = (fromIntegral . fromEnum) saveMode
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
    maybeCallback <- case callback of
        Nothing -> return (castPtrToFunPtr nullPtr)
        Just jCallback -> do
            jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback))
            poke ptrcallback jCallback'
            return jCallback'
    let userData = nullPtr
    webkit_web_view_save_to_file webView' file' saveMode' maybeCancellable maybeCallback userData
    touchManagedPtr webView
    touchManagedPtr file
    whenJust cancellable touchManagedPtr
    return ()

data WebViewSaveToFileMethodInfo
instance (signature ~ (b -> WebKit2.Enums.SaveMode -> Maybe (c) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsWebView a, Gio.File.IsFile b, Gio.Cancellable.IsCancellable c) => O.MethodInfo WebViewSaveToFileMethodInfo a signature where
    overloadedMethod _ = webViewSaveToFile

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

foreign import ccall "webkit_web_view_save_to_file_finish" webkit_web_view_save_to_file_finish :: 
    Ptr WebView ->                          -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"})
    Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{- |
Finish an asynchronous operation started with 'GI.WebKit2.Objects.WebView.webViewSaveToFile'.
-}
webViewSaveToFileFinish ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebView a, Gio.AsyncResult.IsAsyncResult b) =>
    a
    {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -}
    -> b
    {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult' -}
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
webViewSaveToFileFinish webView result_ = liftIO $ do
    webView' <- unsafeManagedPtrCastPtr webView
    result_' <- unsafeManagedPtrCastPtr result_
    onException (do
        _ <- propagateGError $ webkit_web_view_save_to_file_finish webView' result_'
        touchManagedPtr webView
        touchManagedPtr result_
        return ()
     ) (do
        return ()
     )

data WebViewSaveToFileFinishMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsWebView a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo WebViewSaveToFileFinishMethodInfo a signature where
    overloadedMethod _ = webViewSaveToFileFinish

-- method WebView::set_background_color
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rgba", argType = TInterface (Name {namespace = "Gdk", name = "RGBA"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkRGBA", 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_view_set_background_color" webkit_web_view_set_background_color :: 
    Ptr WebView ->                          -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"})
    Ptr Gdk.RGBA.RGBA ->                    -- rgba : TInterface (Name {namespace = "Gdk", name = "RGBA"})
    IO ()

{- |
Sets the color that will be used to draw the /@webView@/ background before
the actual contents are rendered. Note that if the web page loaded in /@webView@/
specifies a background color, it will take precedence over the /@rgba@/ color.
By default the /@webView@/ background color is opaque white.
Note that the parent window must have a RGBA visual and
'GI.Gtk.Objects.Widget.Widget':@/app-paintable/@ property set to 'True' for backgrounds colors to work.

\<informalexample>\<programlisting>
static void browser_window_set_background_color (BrowserWindow *window,
                                                 const GdkRGBA *rgba)
{
    WebKitWebView *web_view;
    GdkScreen *screen = gtk_window_get_screen (GTK_WINDOW (window));
    GdkVisual *rgba_visual = gdk_screen_get_rgba_visual (screen);

    if (!rgba_visual)
         return;

    gtk_widget_set_visual (GTK_WIDGET (window), rgba_visual);
    gtk_widget_set_app_paintable (GTK_WIDGET (window), TRUE);

    web_view = browser_window_get_web_view (window);
    webkit_web_view_set_background_color (web_view, rgba);
}
\<\/programlisting>\<\/informalexample>

@since 2.8
-}
webViewSetBackgroundColor ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebView a) =>
    a
    {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -}
    -> Gdk.RGBA.RGBA
    {- ^ /@rgba@/: a 'GI.Gdk.Structs.RGBA.RGBA' -}
    -> m ()
webViewSetBackgroundColor webView rgba = liftIO $ do
    webView' <- unsafeManagedPtrCastPtr webView
    rgba' <- unsafeManagedPtrGetPtr rgba
    webkit_web_view_set_background_color webView' rgba'
    touchManagedPtr webView
    touchManagedPtr rgba
    return ()

data WebViewSetBackgroundColorMethodInfo
instance (signature ~ (Gdk.RGBA.RGBA -> m ()), MonadIO m, IsWebView a) => O.MethodInfo WebViewSetBackgroundColorMethodInfo a signature where
    overloadedMethod _ = webViewSetBackgroundColor

-- method WebView::set_custom_charset
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "charset", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a character encoding name or %NULL", 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_view_set_custom_charset" webkit_web_view_set_custom_charset :: 
    Ptr WebView ->                          -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"})
    CString ->                              -- charset : TBasicType TUTF8
    IO ()

{- |
Sets the current custom character encoding override of /@webView@/. The custom
character encoding will override any text encoding detected via HTTP headers or
META tags. Calling this method will stop any current load operation and reload the
current page. Setting the custom character encoding to 'Nothing' removes the character
encoding override.
-}
webViewSetCustomCharset ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebView a) =>
    a
    {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -}
    -> Maybe (T.Text)
    {- ^ /@charset@/: a character encoding name or 'Nothing' -}
    -> m ()
webViewSetCustomCharset webView charset = liftIO $ do
    webView' <- unsafeManagedPtrCastPtr webView
    maybeCharset <- case charset of
        Nothing -> return nullPtr
        Just jCharset -> do
            jCharset' <- textToCString jCharset
            return jCharset'
    webkit_web_view_set_custom_charset webView' maybeCharset
    touchManagedPtr webView
    freeMem maybeCharset
    return ()

data WebViewSetCustomCharsetMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsWebView a) => O.MethodInfo WebViewSetCustomCharsetMethodInfo a signature where
    overloadedMethod _ = webViewSetCustomCharset

-- method WebView::set_editable
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "editable", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gboolean indicating the editable state", 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_view_set_editable" webkit_web_view_set_editable :: 
    Ptr WebView ->                          -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"})
    CInt ->                                 -- editable : TBasicType TBoolean
    IO ()

{- |
Sets whether the user is allowed to edit the HTML document.

If /@editable@/ is 'True', /@webView@/ allows the user to edit the HTML document. If
/@editable@/ is 'False', an element in /@webView@/\'s document can only be edited if the
CONTENTEDITABLE attribute has been set on the element or one of its parent
elements. By default a 'GI.WebKit2.Objects.WebView.WebView' is not editable.

Normally, a HTML document is not editable unless the elements within the
document are editable. This function provides a way to make the contents
of a 'GI.WebKit2.Objects.WebView.WebView' editable without altering the document or DOM structure.

@since 2.8
-}
webViewSetEditable ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebView a) =>
    a
    {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -}
    -> Bool
    {- ^ /@editable@/: a 'Bool' indicating the editable state -}
    -> m ()
webViewSetEditable webView editable = liftIO $ do
    webView' <- unsafeManagedPtrCastPtr webView
    let editable' = (fromIntegral . fromEnum) editable
    webkit_web_view_set_editable webView' editable'
    touchManagedPtr webView
    return ()

data WebViewSetEditableMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsWebView a) => O.MethodInfo WebViewSetEditableMethodInfo a signature where
    overloadedMethod _ = webViewSetEditable

-- method WebView::set_settings
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "settings", argType = TInterface (Name {namespace = "WebKit2", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSettings", 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_view_set_settings" webkit_web_view_set_settings :: 
    Ptr WebView ->                          -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"})
    Ptr WebKit2.Settings.Settings ->        -- settings : TInterface (Name {namespace = "WebKit2", name = "Settings"})
    IO ()

{- |
Sets the 'GI.WebKit2.Objects.Settings.Settings' to be applied to /@webView@/. The
existing 'GI.WebKit2.Objects.Settings.Settings' of /@webView@/ will be replaced by
/@settings@/. New settings are applied immediately on /@webView@/.
The same 'GI.WebKit2.Objects.Settings.Settings' object can be shared
by multiple 'GI.WebKit2.Objects.WebView.WebView'\<!-- -->s.
-}
webViewSetSettings ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebView a, WebKit2.Settings.IsSettings b) =>
    a
    {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -}
    -> b
    {- ^ /@settings@/: a 'GI.WebKit2.Objects.Settings.Settings' -}
    -> m ()
webViewSetSettings webView settings = liftIO $ do
    webView' <- unsafeManagedPtrCastPtr webView
    settings' <- unsafeManagedPtrCastPtr settings
    webkit_web_view_set_settings webView' settings'
    touchManagedPtr webView
    touchManagedPtr settings
    return ()

data WebViewSetSettingsMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsWebView a, WebKit2.Settings.IsSettings b) => O.MethodInfo WebViewSetSettingsMethodInfo a signature where
    overloadedMethod _ = webViewSetSettings

-- method WebView::set_zoom_level
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "zoom_level", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the zoom level", 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_view_set_zoom_level" webkit_web_view_set_zoom_level :: 
    Ptr WebView ->                          -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"})
    CDouble ->                              -- zoom_level : TBasicType TDouble
    IO ()

{- |
Set the zoom level of /@webView@/, i.e. the factor by which the
view contents are scaled with respect to their original size.
-}
webViewSetZoomLevel ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebView a) =>
    a
    {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -}
    -> Double
    {- ^ /@zoomLevel@/: the zoom level -}
    -> m ()
webViewSetZoomLevel webView zoomLevel = liftIO $ do
    webView' <- unsafeManagedPtrCastPtr webView
    let zoomLevel' = realToFrac zoomLevel
    webkit_web_view_set_zoom_level webView' zoomLevel'
    touchManagedPtr webView
    return ()

data WebViewSetZoomLevelMethodInfo
instance (signature ~ (Double -> m ()), MonadIO m, IsWebView a) => O.MethodInfo WebViewSetZoomLevelMethodInfo a signature where
    overloadedMethod _ = webViewSetZoomLevel

-- method WebView::stop_loading
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", 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_view_stop_loading" webkit_web_view_stop_loading :: 
    Ptr WebView ->                          -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"})
    IO ()

{- |
Stops any ongoing loading operation in /@webView@/.
This method does nothing if no content is being loaded.
If there is a loading operation in progress, it will be cancelled and
'GI.WebKit2.Objects.WebView.WebView'::@/load-failed/@ signal will be emitted with
'GI.WebKit2.Enums.NetworkErrorCancelled' error.
-}
webViewStopLoading ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebView a) =>
    a
    {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -}
    -> m ()
webViewStopLoading webView = liftIO $ do
    webView' <- unsafeManagedPtrCastPtr webView
    webkit_web_view_stop_loading webView'
    touchManagedPtr webView
    return ()

data WebViewStopLoadingMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWebView a) => O.MethodInfo WebViewStopLoadingMethodInfo a signature where
    overloadedMethod _ = webViewStopLoading

-- method WebView::try_close
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "web_view", argType = TInterface (Name {namespace = "WebKit2", name = "WebView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebView", 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_view_try_close" webkit_web_view_try_close :: 
    Ptr WebView ->                          -- web_view : TInterface (Name {namespace = "WebKit2", name = "WebView"})
    IO ()

{- |
Tries to close the /@webView@/. This will fire the onbeforeunload event
to ask the user for confirmation to close the page. If there isn\'t an
onbeforeunload event handler or the user confirms to close the page,
the 'GI.WebKit2.Objects.WebView.WebView'::@/close/@ signal is emitted, otherwise nothing happens.

@since 2.12
-}
webViewTryClose ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebView a) =>
    a
    {- ^ /@webView@/: a 'GI.WebKit2.Objects.WebView.WebView' -}
    -> m ()
webViewTryClose webView = liftIO $ do
    webView' <- unsafeManagedPtrCastPtr webView
    webkit_web_view_try_close webView'
    touchManagedPtr webView
    return ()

data WebViewTryCloseMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWebView a) => O.MethodInfo WebViewTryCloseMethodInfo a signature where
    overloadedMethod _ = webViewTryClose