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

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

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

module GI.WebKit2.Objects.WebView
    (

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


 -- * Methods
-- ** canExecuteEditingCommand #method:canExecuteEditingCommand#

#if ENABLE_OVERLOADING
    WebViewCanExecuteEditingCommandMethodInfo,
#endif
    webViewCanExecuteEditingCommand         ,


-- ** canExecuteEditingCommandFinish #method:canExecuteEditingCommandFinish#

#if ENABLE_OVERLOADING
    WebViewCanExecuteEditingCommandFinishMethodInfo,
#endif
    webViewCanExecuteEditingCommandFinish   ,


-- ** canGoBack #method:canGoBack#

#if ENABLE_OVERLOADING
    WebViewCanGoBackMethodInfo              ,
#endif
    webViewCanGoBack                        ,


-- ** canGoForward #method:canGoForward#

#if ENABLE_OVERLOADING
    WebViewCanGoForwardMethodInfo           ,
#endif
    webViewCanGoForward                     ,


-- ** canShowMimeType #method:canShowMimeType#

#if ENABLE_OVERLOADING
    WebViewCanShowMimeTypeMethodInfo        ,
#endif
    webViewCanShowMimeType                  ,


-- ** downloadUri #method:downloadUri#

#if ENABLE_OVERLOADING
    WebViewDownloadUriMethodInfo            ,
#endif
    webViewDownloadUri                      ,


-- ** executeEditingCommand #method:executeEditingCommand#

#if ENABLE_OVERLOADING
    WebViewExecuteEditingCommandMethodInfo  ,
#endif
    webViewExecuteEditingCommand            ,


-- ** executeEditingCommandWithArgument #method:executeEditingCommandWithArgument#

#if ENABLE_OVERLOADING
    WebViewExecuteEditingCommandWithArgumentMethodInfo,
#endif
    webViewExecuteEditingCommandWithArgument,


-- ** getBackForwardList #method:getBackForwardList#

#if ENABLE_OVERLOADING
    WebViewGetBackForwardListMethodInfo     ,
#endif
    webViewGetBackForwardList               ,


-- ** getBackgroundColor #method:getBackgroundColor#

#if ENABLE_OVERLOADING
    WebViewGetBackgroundColorMethodInfo     ,
#endif
    webViewGetBackgroundColor               ,


-- ** getContext #method:getContext#

#if ENABLE_OVERLOADING
    WebViewGetContextMethodInfo             ,
#endif
    webViewGetContext                       ,


-- ** getCustomCharset #method:getCustomCharset#

#if ENABLE_OVERLOADING
    WebViewGetCustomCharsetMethodInfo       ,
#endif
    webViewGetCustomCharset                 ,


-- ** getEditorState #method:getEditorState#

#if ENABLE_OVERLOADING
    WebViewGetEditorStateMethodInfo         ,
#endif
    webViewGetEditorState                   ,


-- ** getEstimatedLoadProgress #method:getEstimatedLoadProgress#

#if ENABLE_OVERLOADING
    WebViewGetEstimatedLoadProgressMethodInfo,
#endif
    webViewGetEstimatedLoadProgress         ,


-- ** getFavicon #method:getFavicon#

#if ENABLE_OVERLOADING
    WebViewGetFaviconMethodInfo             ,
#endif
    webViewGetFavicon                       ,


-- ** getFindController #method:getFindController#

#if ENABLE_OVERLOADING
    WebViewGetFindControllerMethodInfo      ,
#endif
    webViewGetFindController                ,


-- ** getInspector #method:getInspector#

#if ENABLE_OVERLOADING
    WebViewGetInspectorMethodInfo           ,
#endif
    webViewGetInspector                     ,


-- ** getMainResource #method:getMainResource#

#if ENABLE_OVERLOADING
    WebViewGetMainResourceMethodInfo        ,
#endif
    webViewGetMainResource                  ,


-- ** getPageId #method:getPageId#

#if ENABLE_OVERLOADING
    WebViewGetPageIdMethodInfo              ,
#endif
    webViewGetPageId                        ,


-- ** getSessionState #method:getSessionState#

#if ENABLE_OVERLOADING
    WebViewGetSessionStateMethodInfo        ,
#endif
    webViewGetSessionState                  ,


-- ** getSettings #method:getSettings#

#if ENABLE_OVERLOADING
    WebViewGetSettingsMethodInfo            ,
#endif
    webViewGetSettings                      ,


-- ** getSnapshot #method:getSnapshot#

#if ENABLE_OVERLOADING
    WebViewGetSnapshotMethodInfo            ,
#endif
    webViewGetSnapshot                      ,


-- ** getSnapshotFinish #method:getSnapshotFinish#

#if ENABLE_OVERLOADING
    WebViewGetSnapshotFinishMethodInfo      ,
#endif
    webViewGetSnapshotFinish                ,


-- ** getTitle #method:getTitle#

#if ENABLE_OVERLOADING
    WebViewGetTitleMethodInfo               ,
#endif
    webViewGetTitle                         ,


-- ** getTlsInfo #method:getTlsInfo#

#if ENABLE_OVERLOADING
    WebViewGetTlsInfoMethodInfo             ,
#endif
    webViewGetTlsInfo                       ,


-- ** getUri #method:getUri#

#if ENABLE_OVERLOADING
    WebViewGetUriMethodInfo                 ,
#endif
    webViewGetUri                           ,


-- ** getUserContentManager #method:getUserContentManager#

#if ENABLE_OVERLOADING
    WebViewGetUserContentManagerMethodInfo  ,
#endif
    webViewGetUserContentManager            ,


-- ** getWebsiteDataManager #method:getWebsiteDataManager#

#if ENABLE_OVERLOADING
    WebViewGetWebsiteDataManagerMethodInfo  ,
#endif
    webViewGetWebsiteDataManager            ,


-- ** getWindowProperties #method:getWindowProperties#

#if ENABLE_OVERLOADING
    WebViewGetWindowPropertiesMethodInfo    ,
#endif
    webViewGetWindowProperties              ,


-- ** getZoomLevel #method:getZoomLevel#

#if ENABLE_OVERLOADING
    WebViewGetZoomLevelMethodInfo           ,
#endif
    webViewGetZoomLevel                     ,


-- ** goBack #method:goBack#

#if ENABLE_OVERLOADING
    WebViewGoBackMethodInfo                 ,
#endif
    webViewGoBack                           ,


-- ** goForward #method:goForward#

#if ENABLE_OVERLOADING
    WebViewGoForwardMethodInfo              ,
#endif
    webViewGoForward                        ,


-- ** goToBackForwardListItem #method:goToBackForwardListItem#

#if ENABLE_OVERLOADING
    WebViewGoToBackForwardListItemMethodInfo,
#endif
    webViewGoToBackForwardListItem          ,


-- ** isControlledByAutomation #method:isControlledByAutomation#

#if ENABLE_OVERLOADING
    WebViewIsControlledByAutomationMethodInfo,
#endif
    webViewIsControlledByAutomation         ,


-- ** isEditable #method:isEditable#

#if ENABLE_OVERLOADING
    WebViewIsEditableMethodInfo             ,
#endif
    webViewIsEditable                       ,


-- ** isEphemeral #method:isEphemeral#

#if ENABLE_OVERLOADING
    WebViewIsEphemeralMethodInfo            ,
#endif
    webViewIsEphemeral                      ,


-- ** isLoading #method:isLoading#

#if ENABLE_OVERLOADING
    WebViewIsLoadingMethodInfo              ,
#endif
    webViewIsLoading                        ,


-- ** isPlayingAudio #method:isPlayingAudio#

#if ENABLE_OVERLOADING
    WebViewIsPlayingAudioMethodInfo         ,
#endif
    webViewIsPlayingAudio                   ,


-- ** loadAlternateHtml #method:loadAlternateHtml#

#if ENABLE_OVERLOADING
    WebViewLoadAlternateHtmlMethodInfo      ,
#endif
    webViewLoadAlternateHtml                ,


-- ** loadBytes #method:loadBytes#

#if ENABLE_OVERLOADING
    WebViewLoadBytesMethodInfo              ,
#endif
    webViewLoadBytes                        ,


-- ** loadHtml #method:loadHtml#

#if ENABLE_OVERLOADING
    WebViewLoadHtmlMethodInfo               ,
#endif
    webViewLoadHtml                         ,


-- ** loadPlainText #method:loadPlainText#

#if ENABLE_OVERLOADING
    WebViewLoadPlainTextMethodInfo          ,
#endif
    webViewLoadPlainText                    ,


-- ** loadRequest #method:loadRequest#

#if ENABLE_OVERLOADING
    WebViewLoadRequestMethodInfo            ,
#endif
    webViewLoadRequest                      ,


-- ** loadUri #method:loadUri#

#if ENABLE_OVERLOADING
    WebViewLoadUriMethodInfo                ,
#endif
    webViewLoadUri                          ,


-- ** new #method:new#

    webViewNew                              ,


-- ** newWithContext #method:newWithContext#

    webViewNewWithContext                   ,


-- ** newWithRelatedView #method:newWithRelatedView#

    webViewNewWithRelatedView               ,


-- ** newWithSettings #method:newWithSettings#

    webViewNewWithSettings                  ,


-- ** newWithUserContentManager #method:newWithUserContentManager#

    webViewNewWithUserContentManager        ,


-- ** reload #method:reload#

#if ENABLE_OVERLOADING
    WebViewReloadMethodInfo                 ,
#endif
    webViewReload                           ,


-- ** reloadBypassCache #method:reloadBypassCache#

#if ENABLE_OVERLOADING
    WebViewReloadBypassCacheMethodInfo      ,
#endif
    webViewReloadBypassCache                ,


-- ** restoreSessionState #method:restoreSessionState#

#if ENABLE_OVERLOADING
    WebViewRestoreSessionStateMethodInfo    ,
#endif
    webViewRestoreSessionState              ,


-- ** runJavascript #method:runJavascript#

#if ENABLE_OVERLOADING
    WebViewRunJavascriptMethodInfo          ,
#endif
    webViewRunJavascript                    ,


-- ** runJavascriptFinish #method:runJavascriptFinish#

#if ENABLE_OVERLOADING
    WebViewRunJavascriptFinishMethodInfo    ,
#endif
    webViewRunJavascriptFinish              ,


-- ** runJavascriptFromGresource #method:runJavascriptFromGresource#

#if ENABLE_OVERLOADING
    WebViewRunJavascriptFromGresourceMethodInfo,
#endif
    webViewRunJavascriptFromGresource       ,


-- ** runJavascriptFromGresourceFinish #method:runJavascriptFromGresourceFinish#

#if ENABLE_OVERLOADING
    WebViewRunJavascriptFromGresourceFinishMethodInfo,
#endif
    webViewRunJavascriptFromGresourceFinish ,


-- ** runJavascriptInWorld #method:runJavascriptInWorld#

#if ENABLE_OVERLOADING
    WebViewRunJavascriptInWorldMethodInfo   ,
#endif
    webViewRunJavascriptInWorld             ,


-- ** runJavascriptInWorldFinish #method:runJavascriptInWorldFinish#

#if ENABLE_OVERLOADING
    WebViewRunJavascriptInWorldFinishMethodInfo,
#endif
    webViewRunJavascriptInWorldFinish       ,


-- ** save #method:save#

#if ENABLE_OVERLOADING
    WebViewSaveMethodInfo                   ,
#endif
    webViewSave                             ,


-- ** saveFinish #method:saveFinish#

#if ENABLE_OVERLOADING
    WebViewSaveFinishMethodInfo             ,
#endif
    webViewSaveFinish                       ,


-- ** saveToFile #method:saveToFile#

#if ENABLE_OVERLOADING
    WebViewSaveToFileMethodInfo             ,
#endif
    webViewSaveToFile                       ,


-- ** saveToFileFinish #method:saveToFileFinish#

#if ENABLE_OVERLOADING
    WebViewSaveToFileFinishMethodInfo       ,
#endif
    webViewSaveToFileFinish                 ,


-- ** setBackgroundColor #method:setBackgroundColor#

#if ENABLE_OVERLOADING
    WebViewSetBackgroundColorMethodInfo     ,
#endif
    webViewSetBackgroundColor               ,


-- ** setCustomCharset #method:setCustomCharset#

#if ENABLE_OVERLOADING
    WebViewSetCustomCharsetMethodInfo       ,
#endif
    webViewSetCustomCharset                 ,


-- ** setEditable #method:setEditable#

#if ENABLE_OVERLOADING
    WebViewSetEditableMethodInfo            ,
#endif
    webViewSetEditable                      ,


-- ** setSettings #method:setSettings#

#if ENABLE_OVERLOADING
    WebViewSetSettingsMethodInfo            ,
#endif
    webViewSetSettings                      ,


-- ** setZoomLevel #method:setZoomLevel#

#if ENABLE_OVERLOADING
    WebViewSetZoomLevelMethodInfo           ,
#endif
    webViewSetZoomLevel                     ,


-- ** stopLoading #method:stopLoading#

#if ENABLE_OVERLOADING
    WebViewStopLoadingMethodInfo            ,
#endif
    webViewStopLoading                      ,


-- ** tryClose #method:tryClose#

#if ENABLE_OVERLOADING
    WebViewTryCloseMethodInfo               ,
#endif
    webViewTryClose                         ,




 -- * Properties
-- ** editable #attr:editable#
{- | Whether the pages loaded inside 'GI.WebKit2.Objects.WebView.WebView' are editable. For more
information see 'GI.WebKit2.Objects.WebView.webViewSetEditable'.

/Since: 2.8/
-}
#if ENABLE_OVERLOADING
    WebViewEditablePropertyInfo             ,
#endif
    constructWebViewEditable                ,
    getWebViewEditable                      ,
    setWebViewEditable                      ,
#if ENABLE_OVERLOADING
    webViewEditable                         ,
#endif


-- ** estimatedLoadProgress #attr:estimatedLoadProgress#
{- | An estimate of the percent completion for the current loading operation.
This value will range from 0.0 to 1.0 and, once a load completes,
will remain at 1.0 until a new load starts, at which point it
will be reset to 0.0.
The value is an estimate based on the total number of bytes expected
to be received for a document, including all its possible subresources
and child documents.
-}
#if ENABLE_OVERLOADING
    WebViewEstimatedLoadProgressPropertyInfo,
#endif
    getWebViewEstimatedLoadProgress         ,
#if ENABLE_OVERLOADING
    webViewEstimatedLoadProgress            ,
#endif


-- ** favicon #attr:favicon#
{- | The favicon currently associated to the 'GI.WebKit2.Objects.WebView.WebView'.
See 'GI.WebKit2.Objects.WebView.webViewGetFavicon' for more details.
-}
#if ENABLE_OVERLOADING
    WebViewFaviconPropertyInfo              ,
#endif
    getWebViewFavicon                       ,
#if ENABLE_OVERLOADING
    webViewFavicon                          ,
#endif


-- ** isControlledByAutomation #attr:isControlledByAutomation#
{- | Whether the 'GI.WebKit2.Objects.WebView.WebView' is controlled by automation. This should only be used when
creating a new 'GI.WebKit2.Objects.WebView.WebView' as a response to 'GI.WebKit2.Objects.AutomationSession.AutomationSession'::@/create-web-view/@
signal request.

/Since: 2.18/
-}
#if ENABLE_OVERLOADING
    WebViewIsControlledByAutomationPropertyInfo,
#endif
    constructWebViewIsControlledByAutomation,
    getWebViewIsControlledByAutomation      ,


-- ** isEphemeral #attr:isEphemeral#
{- | Whether the 'GI.WebKit2.Objects.WebView.WebView' is ephemeral. An ephemeral web view never writes
website data to the client storage, no matter what 'GI.WebKit2.Objects.WebsiteDataManager.WebsiteDataManager'
its context is using. This is normally used to implement private browsing mode.
This is a 'GI.GObject.Flags.ParamFlagsConstructOnly' property, so you have to create a ephemeral
'GI.WebKit2.Objects.WebView.WebView' and it can\'t be changed. Note that all 'GI.WebKit2.Objects.WebView.WebView'\<!-- -->s
created with an ephemeral 'GI.WebKit2.Objects.WebContext.WebContext' will be ephemeral automatically.
See also 'GI.WebKit2.Objects.WebContext.webContextNewEphemeral'.

/Since: 2.16/
-}
#if ENABLE_OVERLOADING
    WebViewIsEphemeralPropertyInfo          ,
#endif
    constructWebViewIsEphemeral             ,
    getWebViewIsEphemeral                   ,


-- ** isLoading #attr:isLoading#
{- | Whether the 'GI.WebKit2.Objects.WebView.WebView' is currently loading a page. This property becomes
'True' as soon as a new load operation is requested and before the
'GI.WebKit2.Objects.WebView.WebView'::@/load-changed/@ signal is emitted with 'GI.WebKit2.Enums.LoadEventStarted' and
at that point the active URI is the requested one.
When the load operation finishes the property is set to 'False' before
'GI.WebKit2.Objects.WebView.WebView'::@/load-changed/@ is emitted with 'GI.WebKit2.Enums.LoadEventFinished'.
-}
#if ENABLE_OVERLOADING
    WebViewIsLoadingPropertyInfo            ,
#endif
    getWebViewIsLoading                     ,


-- ** isPlayingAudio #attr:isPlayingAudio#
{- | Whether the 'GI.WebKit2.Objects.WebView.WebView' is currently playing audio from a page.
This property becomes 'True' as soon as web content starts playing any
kind of audio. When a page is no longer playing any kind of sound,
the property is set back to 'False'.

/Since: 2.8/
-}
#if ENABLE_OVERLOADING
    WebViewIsPlayingAudioPropertyInfo       ,
#endif
    getWebViewIsPlayingAudio                ,


-- ** relatedView #attr:relatedView#
{- | The related 'GI.WebKit2.Objects.WebView.WebView' used when creating the view to share the
same web process. This property is not readable because the related
web view is only valid during the object construction.

/Since: 2.4/
-}
#if ENABLE_OVERLOADING
    WebViewRelatedViewPropertyInfo          ,
#endif
    constructWebViewRelatedView             ,
#if ENABLE_OVERLOADING
    webViewRelatedView                      ,
#endif


-- ** settings #attr:settings#
{- | The 'GI.WebKit2.Objects.Settings.Settings' of the view.

/Since: 2.6/
-}
#if ENABLE_OVERLOADING
    WebViewSettingsPropertyInfo             ,
#endif
    constructWebViewSettings                ,
    setWebViewSettings                      ,
#if ENABLE_OVERLOADING
    webViewSettings                         ,
#endif


-- ** title #attr:title#
{- | The main frame document title of this 'GI.WebKit2.Objects.WebView.WebView'. If
the title has not been received yet, it will be 'Nothing'.
-}
#if ENABLE_OVERLOADING
    WebViewTitlePropertyInfo                ,
#endif
    getWebViewTitle                         ,
#if ENABLE_OVERLOADING
    webViewTitle                            ,
#endif


-- ** uri #attr:uri#
{- | The current active URI of the 'GI.WebKit2.Objects.WebView.WebView'.
See 'GI.WebKit2.Objects.WebView.webViewGetUri' for more details.
-}
#if ENABLE_OVERLOADING
    WebViewUriPropertyInfo                  ,
#endif
    getWebViewUri                           ,
#if ENABLE_OVERLOADING
    webViewUri                              ,
#endif


-- ** userContentManager #attr:userContentManager#
{- | The 'GI.WebKit2.Objects.UserContentManager.UserContentManager' of the view.

/Since: 2.6/
-}
#if ENABLE_OVERLOADING
    WebViewUserContentManagerPropertyInfo   ,
#endif
    constructWebViewUserContentManager      ,
    getWebViewUserContentManager            ,
#if ENABLE_OVERLOADING
    webViewUserContentManager               ,
#endif


-- ** webContext #attr:webContext#
{- | The 'GI.WebKit2.Objects.WebContext.WebContext' of the view.
-}
#if ENABLE_OVERLOADING
    WebViewWebContextPropertyInfo           ,
#endif
    constructWebViewWebContext              ,
    getWebViewWebContext                    ,
#if ENABLE_OVERLOADING
    webViewWebContext                       ,
#endif


-- ** zoomLevel #attr:zoomLevel#
{- | The zoom level of the 'GI.WebKit2.Objects.WebView.WebView' content.
See 'GI.WebKit2.Objects.WebView.webViewSetZoomLevel' for more details.
-}
#if ENABLE_OVERLOADING
    WebViewZoomLevelPropertyInfo            ,
#endif
    constructWebViewZoomLevel               ,
    getWebViewZoomLevel                     ,
    setWebViewZoomLevel                     ,
#if ENABLE_OVERLOADING
    webViewZoomLevel                        ,
#endif




 -- * Signals
-- ** authenticate #signal:authenticate#

    C_WebViewAuthenticateCallback           ,
    WebViewAuthenticateCallback             ,
#if ENABLE_OVERLOADING
    WebViewAuthenticateSignalInfo           ,
#endif
    afterWebViewAuthenticate                ,
    genClosure_WebViewAuthenticate          ,
    mk_WebViewAuthenticateCallback          ,
    noWebViewAuthenticateCallback           ,
    onWebViewAuthenticate                   ,
    wrap_WebViewAuthenticateCallback        ,


-- ** close #signal:close#

    C_WebViewCloseCallback                  ,
    WebViewCloseCallback                    ,
#if ENABLE_OVERLOADING
    WebViewCloseSignalInfo                  ,
#endif
    afterWebViewClose                       ,
    genClosure_WebViewClose                 ,
    mk_WebViewCloseCallback                 ,
    noWebViewCloseCallback                  ,
    onWebViewClose                          ,
    wrap_WebViewCloseCallback               ,


-- ** contextMenu #signal:contextMenu#

    C_WebViewContextMenuCallback            ,
    WebViewContextMenuCallback              ,
#if ENABLE_OVERLOADING
    WebViewContextMenuSignalInfo            ,
#endif
    afterWebViewContextMenu                 ,
    genClosure_WebViewContextMenu           ,
    mk_WebViewContextMenuCallback           ,
    noWebViewContextMenuCallback            ,
    onWebViewContextMenu                    ,
    wrap_WebViewContextMenuCallback         ,


-- ** contextMenuDismissed #signal:contextMenuDismissed#

    C_WebViewContextMenuDismissedCallback   ,
    WebViewContextMenuDismissedCallback     ,
#if ENABLE_OVERLOADING
    WebViewContextMenuDismissedSignalInfo   ,
#endif
    afterWebViewContextMenuDismissed        ,
    genClosure_WebViewContextMenuDismissed  ,
    mk_WebViewContextMenuDismissedCallback  ,
    noWebViewContextMenuDismissedCallback   ,
    onWebViewContextMenuDismissed           ,
    wrap_WebViewContextMenuDismissedCallback,


-- ** create #signal:create#

    C_WebViewCreateCallback                 ,
    WebViewCreateCallback                   ,
#if ENABLE_OVERLOADING
    WebViewCreateSignalInfo                 ,
#endif
    afterWebViewCreate                      ,
    genClosure_WebViewCreate                ,
    mk_WebViewCreateCallback                ,
    noWebViewCreateCallback                 ,
    onWebViewCreate                         ,
    wrap_WebViewCreateCallback              ,


-- ** decidePolicy #signal:decidePolicy#

    C_WebViewDecidePolicyCallback           ,
    WebViewDecidePolicyCallback             ,
#if ENABLE_OVERLOADING
    WebViewDecidePolicySignalInfo           ,
#endif
    afterWebViewDecidePolicy                ,
    genClosure_WebViewDecidePolicy          ,
    mk_WebViewDecidePolicyCallback          ,
    noWebViewDecidePolicyCallback           ,
    onWebViewDecidePolicy                   ,
    wrap_WebViewDecidePolicyCallback        ,


-- ** enterFullscreen #signal:enterFullscreen#

    C_WebViewEnterFullscreenCallback        ,
    WebViewEnterFullscreenCallback          ,
#if ENABLE_OVERLOADING
    WebViewEnterFullscreenSignalInfo        ,
#endif
    afterWebViewEnterFullscreen             ,
    genClosure_WebViewEnterFullscreen       ,
    mk_WebViewEnterFullscreenCallback       ,
    noWebViewEnterFullscreenCallback        ,
    onWebViewEnterFullscreen                ,
    wrap_WebViewEnterFullscreenCallback     ,


-- ** insecureContentDetected #signal:insecureContentDetected#

    C_WebViewInsecureContentDetectedCallback,
    WebViewInsecureContentDetectedCallback  ,
#if ENABLE_OVERLOADING
    WebViewInsecureContentDetectedSignalInfo,
#endif
    afterWebViewInsecureContentDetected     ,
    genClosure_WebViewInsecureContentDetected,
    mk_WebViewInsecureContentDetectedCallback,
    noWebViewInsecureContentDetectedCallback,
    onWebViewInsecureContentDetected        ,
    wrap_WebViewInsecureContentDetectedCallback,


-- ** leaveFullscreen #signal:leaveFullscreen#

    C_WebViewLeaveFullscreenCallback        ,
    WebViewLeaveFullscreenCallback          ,
#if ENABLE_OVERLOADING
    WebViewLeaveFullscreenSignalInfo        ,
#endif
    afterWebViewLeaveFullscreen             ,
    genClosure_WebViewLeaveFullscreen       ,
    mk_WebViewLeaveFullscreenCallback       ,
    noWebViewLeaveFullscreenCallback        ,
    onWebViewLeaveFullscreen                ,
    wrap_WebViewLeaveFullscreenCallback     ,


-- ** loadChanged #signal:loadChanged#

    C_WebViewLoadChangedCallback            ,
    WebViewLoadChangedCallback              ,
#if ENABLE_OVERLOADING
    WebViewLoadChangedSignalInfo            ,
#endif
    afterWebViewLoadChanged                 ,
    genClosure_WebViewLoadChanged           ,
    mk_WebViewLoadChangedCallback           ,
    noWebViewLoadChangedCallback            ,
    onWebViewLoadChanged                    ,
    wrap_WebViewLoadChangedCallback         ,


-- ** loadFailed #signal:loadFailed#

    C_WebViewLoadFailedCallback             ,
    WebViewLoadFailedCallback               ,
#if ENABLE_OVERLOADING
    WebViewLoadFailedSignalInfo             ,
#endif
    afterWebViewLoadFailed                  ,
    genClosure_WebViewLoadFailed            ,
    mk_WebViewLoadFailedCallback            ,
    noWebViewLoadFailedCallback             ,
    onWebViewLoadFailed                     ,
    wrap_WebViewLoadFailedCallback          ,


-- ** loadFailedWithTlsErrors #signal:loadFailedWithTlsErrors#

    C_WebViewLoadFailedWithTlsErrorsCallback,
    WebViewLoadFailedWithTlsErrorsCallback  ,
#if ENABLE_OVERLOADING
    WebViewLoadFailedWithTlsErrorsSignalInfo,
#endif
    afterWebViewLoadFailedWithTlsErrors     ,
    genClosure_WebViewLoadFailedWithTlsErrors,
    mk_WebViewLoadFailedWithTlsErrorsCallback,
    noWebViewLoadFailedWithTlsErrorsCallback,
    onWebViewLoadFailedWithTlsErrors        ,
    wrap_WebViewLoadFailedWithTlsErrorsCallback,


-- ** mouseTargetChanged #signal:mouseTargetChanged#

    C_WebViewMouseTargetChangedCallback     ,
    WebViewMouseTargetChangedCallback       ,
#if ENABLE_OVERLOADING
    WebViewMouseTargetChangedSignalInfo     ,
#endif
    afterWebViewMouseTargetChanged          ,
    genClosure_WebViewMouseTargetChanged    ,
    mk_WebViewMouseTargetChangedCallback    ,
    noWebViewMouseTargetChangedCallback     ,
    onWebViewMouseTargetChanged             ,
    wrap_WebViewMouseTargetChangedCallback  ,


-- ** permissionRequest #signal:permissionRequest#

    C_WebViewPermissionRequestCallback      ,
    WebViewPermissionRequestCallback        ,
#if ENABLE_OVERLOADING
    WebViewPermissionRequestSignalInfo      ,
#endif
    afterWebViewPermissionRequest           ,
    genClosure_WebViewPermissionRequest     ,
    mk_WebViewPermissionRequestCallback     ,
    noWebViewPermissionRequestCallback      ,
    onWebViewPermissionRequest              ,
    wrap_WebViewPermissionRequestCallback   ,


-- ** print #signal:print#

    C_WebViewPrintCallback                  ,
    WebViewPrintCallback                    ,
#if ENABLE_OVERLOADING
    WebViewPrintSignalInfo                  ,
#endif
    afterWebViewPrint                       ,
    genClosure_WebViewPrint                 ,
    mk_WebViewPrintCallback                 ,
    noWebViewPrintCallback                  ,
    onWebViewPrint                          ,
    wrap_WebViewPrintCallback               ,


-- ** readyToShow #signal:readyToShow#

    C_WebViewReadyToShowCallback            ,
    WebViewReadyToShowCallback              ,
#if ENABLE_OVERLOADING
    WebViewReadyToShowSignalInfo            ,
#endif
    afterWebViewReadyToShow                 ,
    genClosure_WebViewReadyToShow           ,
    mk_WebViewReadyToShowCallback           ,
    noWebViewReadyToShowCallback            ,
    onWebViewReadyToShow                    ,
    wrap_WebViewReadyToShowCallback         ,


-- ** resourceLoadStarted #signal:resourceLoadStarted#

    C_WebViewResourceLoadStartedCallback    ,
    WebViewResourceLoadStartedCallback      ,
#if ENABLE_OVERLOADING
    WebViewResourceLoadStartedSignalInfo    ,
#endif
    afterWebViewResourceLoadStarted         ,
    genClosure_WebViewResourceLoadStarted   ,
    mk_WebViewResourceLoadStartedCallback   ,
    noWebViewResourceLoadStartedCallback    ,
    onWebViewResourceLoadStarted            ,
    wrap_WebViewResourceLoadStartedCallback ,


-- ** runAsModal #signal:runAsModal#

    C_WebViewRunAsModalCallback             ,
    WebViewRunAsModalCallback               ,
#if ENABLE_OVERLOADING
    WebViewRunAsModalSignalInfo             ,
#endif
    afterWebViewRunAsModal                  ,
    genClosure_WebViewRunAsModal            ,
    mk_WebViewRunAsModalCallback            ,
    noWebViewRunAsModalCallback             ,
    onWebViewRunAsModal                     ,
    wrap_WebViewRunAsModalCallback          ,


-- ** runColorChooser #signal:runColorChooser#

    C_WebViewRunColorChooserCallback        ,
    WebViewRunColorChooserCallback          ,
#if ENABLE_OVERLOADING
    WebViewRunColorChooserSignalInfo        ,
#endif
    afterWebViewRunColorChooser             ,
    genClosure_WebViewRunColorChooser       ,
    mk_WebViewRunColorChooserCallback       ,
    noWebViewRunColorChooserCallback        ,
    onWebViewRunColorChooser                ,
    wrap_WebViewRunColorChooserCallback     ,


-- ** runFileChooser #signal:runFileChooser#

    C_WebViewRunFileChooserCallback         ,
    WebViewRunFileChooserCallback           ,
#if ENABLE_OVERLOADING
    WebViewRunFileChooserSignalInfo         ,
#endif
    afterWebViewRunFileChooser              ,
    genClosure_WebViewRunFileChooser        ,
    mk_WebViewRunFileChooserCallback        ,
    noWebViewRunFileChooserCallback         ,
    onWebViewRunFileChooser                 ,
    wrap_WebViewRunFileChooserCallback      ,


-- ** scriptDialog #signal:scriptDialog#

    C_WebViewScriptDialogCallback           ,
    WebViewScriptDialogCallback             ,
#if ENABLE_OVERLOADING
    WebViewScriptDialogSignalInfo           ,
#endif
    afterWebViewScriptDialog                ,
    genClosure_WebViewScriptDialog          ,
    mk_WebViewScriptDialogCallback          ,
    noWebViewScriptDialogCallback           ,
    onWebViewScriptDialog                   ,
    wrap_WebViewScriptDialogCallback        ,


-- ** showNotification #signal:showNotification#

    C_WebViewShowNotificationCallback       ,
    WebViewShowNotificationCallback         ,
#if ENABLE_OVERLOADING
    WebViewShowNotificationSignalInfo       ,
#endif
    afterWebViewShowNotification            ,
    genClosure_WebViewShowNotification      ,
    mk_WebViewShowNotificationCallback      ,
    noWebViewShowNotificationCallback       ,
    onWebViewShowNotification               ,
    wrap_WebViewShowNotificationCallback    ,


-- ** showOptionMenu #signal:showOptionMenu#

    C_WebViewShowOptionMenuCallback         ,
    WebViewShowOptionMenuCallback           ,
#if ENABLE_OVERLOADING
    WebViewShowOptionMenuSignalInfo         ,
#endif
    afterWebViewShowOptionMenu              ,
    genClosure_WebViewShowOptionMenu        ,
    mk_WebViewShowOptionMenuCallback        ,
    noWebViewShowOptionMenuCallback         ,
    onWebViewShowOptionMenu                 ,
    wrap_WebViewShowOptionMenuCallback      ,


-- ** submitForm #signal:submitForm#

    C_WebViewSubmitFormCallback             ,
    WebViewSubmitFormCallback               ,
#if ENABLE_OVERLOADING
    WebViewSubmitFormSignalInfo             ,
#endif
    afterWebViewSubmitForm                  ,
    genClosure_WebViewSubmitForm            ,
    mk_WebViewSubmitFormCallback            ,
    noWebViewSubmitFormCallback             ,
    onWebViewSubmitForm                     ,
    wrap_WebViewSubmitFormCallback          ,


-- ** webProcessCrashed #signal:webProcessCrashed#

    C_WebViewWebProcessCrashedCallback      ,
    WebViewWebProcessCrashedCallback        ,
#if ENABLE_OVERLOADING
    WebViewWebProcessCrashedSignalInfo      ,
#endif
    afterWebViewWebProcessCrashed           ,
    genClosure_WebViewWebProcessCrashed     ,
    mk_WebViewWebProcessCrashedCallback     ,
    noWebViewWebProcessCrashedCallback      ,
    onWebViewWebProcessCrashed              ,
    wrap_WebViewWebProcessCrashedCallback   ,


-- ** webProcessTerminated #signal:webProcessTerminated#

    C_WebViewWebProcessTerminatedCallback   ,
    WebViewWebProcessTerminatedCallback     ,
#if ENABLE_OVERLOADING
    WebViewWebProcessTerminatedSignalInfo   ,
#endif
    afterWebViewWebProcessTerminated        ,
    genClosure_WebViewWebProcessTerminated  ,
    mk_WebViewWebProcessTerminatedCallback  ,
    noWebViewWebProcessTerminatedCallback   ,
    onWebViewWebProcessTerminated           ,
    wrap_WebViewWebProcessTerminatedCallback,




    ) where

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

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL

import qualified GI.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.Structs.Rectangle as Gdk.Rectangle
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 {-# 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.OptionMenu as WebKit2.OptionMenu
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.WebsiteDataManager as WebKit2.WebsiteDataManager
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

-- | Memory-managed wrapper type.
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


-- | Type class for types which can be safely cast to `WebView`, for instance with `toWebView`.
class (GObject o, O.IsDescendantOf WebView o) => IsWebView o
instance (GObject o, O.IsDescendantOf WebView o) => IsWebView o

instance O.HasParentTypes WebView
type instance O.ParentTypes WebView = '[WebKit2.WebViewBase.WebViewBase, Gtk.Container.Container, Gtk.Widget.Widget, GObject.Object.Object, Atk.ImplementorIface.ImplementorIface, Gtk.Buildable.Buildable]

-- | Cast to `WebView`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toWebView :: (MonadIO m, IsWebView o) => o -> m WebView
toWebView = liftIO . unsafeCastTo WebView

-- | A convenience alias for `Nothing` :: `Maybe` `WebView`.
noWebView :: Maybe WebView
noWebView = Nothing

#if ENABLE_OVERLOADING
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 "getv" o = GObject.Object.ObjectGetvMethodInfo
    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 "isControlledByAutomation" o = WebViewIsControlledByAutomationMethodInfo
    ResolveWebViewMethod "isDrawable" o = Gtk.Widget.WidgetIsDrawableMethodInfo
    ResolveWebViewMethod "isEditable" o = WebViewIsEditableMethodInfo
    ResolveWebViewMethod "isEphemeral" o = WebViewIsEphemeralMethodInfo
    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 "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 "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 "runJavascriptInWorld" o = WebViewRunJavascriptInWorldMethodInfo
    ResolveWebViewMethod "runJavascriptInWorldFinish" o = WebViewRunJavascriptInWorldFinishMethodInfo
    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 "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 "getWebsiteDataManager" o = WebViewGetWebsiteDataManagerMethodInfo
    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) => OL.IsLabel t (WebView -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#else
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif

#endif

-- signal WebView::authenticate
{- |
This signal is emitted when the user is challenged with HTTP
authentication. To let the  application access or supply
the credentials as well as to allow the client application
to either cancel the request or perform the authentication,
the signal will pass an instance of the
'GI.WebKit2.Objects.AuthenticationRequest.AuthenticationRequest' in the /@request@/ argument.
To handle this signal asynchronously you should keep a ref
of the request and return 'True'. To disable HTTP authentication
entirely, connect to this signal and simply return 'True'.

The default signal handler will run a default authentication
dialog asynchronously for the user to interact with.

/Since: 2.2/
-}
type WebViewAuthenticateCallback =
    WebKit2.AuthenticationRequest.AuthenticationRequest
    {- ^ /@request@/: a 'GI.WebKit2.Objects.AuthenticationRequest.AuthenticationRequest' -}
    -> IO Bool
    {- ^ __Returns:__ 'True' to stop other handlers from being invoked for the event.
  'False' to propagate the event further. -}

-- | A convenience synonym for @`Nothing` :: `Maybe` `WebViewAuthenticateCallback`@.
noWebViewAuthenticateCallback :: Maybe WebViewAuthenticateCallback
noWebViewAuthenticateCallback = Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_WebViewAuthenticate :: MonadIO m => WebViewAuthenticateCallback -> m (GClosure C_WebViewAuthenticateCallback)
genClosure_WebViewAuthenticate cb = liftIO $ do
    let cb' = wrap_WebViewAuthenticateCallback cb
    mk_WebViewAuthenticateCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `WebViewAuthenticateCallback` into a `C_WebViewAuthenticateCallback`.
wrap_WebViewAuthenticateCallback ::
    WebViewAuthenticateCallback ->
    C_WebViewAuthenticateCallback
wrap_WebViewAuthenticateCallback _cb _ request _ = do
    request' <- (newObject WebKit2.AuthenticationRequest.AuthenticationRequest) request
    result <- _cb  request'
    let result' = (fromIntegral . fromEnum) result
    return result'


{- |
Connect a signal handler for the “@authenticate@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' webView #authenticate callback
@
-}
onWebViewAuthenticate :: (IsWebView a, MonadIO m) => a -> WebViewAuthenticateCallback -> m SignalHandlerId
onWebViewAuthenticate obj cb = liftIO $ do
    let cb' = wrap_WebViewAuthenticateCallback cb
    cb'' <- mk_WebViewAuthenticateCallback cb'
    connectSignalFunPtr obj "authenticate" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@authenticate@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' webView #authenticate callback
@
-}
afterWebViewAuthenticate :: (IsWebView a, MonadIO m) => a -> WebViewAuthenticateCallback -> m SignalHandlerId
afterWebViewAuthenticate obj cb = liftIO $ do
    let cb' = wrap_WebViewAuthenticateCallback cb
    cb'' <- mk_WebViewAuthenticateCallback cb'
    connectSignalFunPtr obj "authenticate" cb'' SignalConnectAfter


-- signal WebView::close
{- |
Emitted when closing a 'GI.WebKit2.Objects.WebView.WebView' is requested. This occurs when a
call is made from JavaScript\'s \<function>window.close\<\/function> function or
after trying to close the /@webView@/ with 'GI.WebKit2.Objects.WebView.webViewTryClose'.
It is the owner\'s responsibility to handle this signal to hide or
destroy the 'GI.WebKit2.Objects.WebView.WebView', if necessary.
-}
type WebViewCloseCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `WebViewCloseCallback`@.
noWebViewCloseCallback :: Maybe WebViewCloseCallback
noWebViewCloseCallback = Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_WebViewClose :: MonadIO m => WebViewCloseCallback -> m (GClosure C_WebViewCloseCallback)
genClosure_WebViewClose cb = liftIO $ do
    let cb' = wrap_WebViewCloseCallback cb
    mk_WebViewCloseCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `WebViewCloseCallback` into a `C_WebViewCloseCallback`.
wrap_WebViewCloseCallback ::
    WebViewCloseCallback ->
    C_WebViewCloseCallback
wrap_WebViewCloseCallback _cb _ _ = do
    _cb


{- |
Connect a signal handler for the “@close@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' webView #close callback
@
-}
onWebViewClose :: (IsWebView a, MonadIO m) => a -> WebViewCloseCallback -> m SignalHandlerId
onWebViewClose obj cb = liftIO $ do
    let cb' = wrap_WebViewCloseCallback cb
    cb'' <- mk_WebViewCloseCallback cb'
    connectSignalFunPtr obj "close" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@close@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' webView #close callback
@
-}
afterWebViewClose :: (IsWebView a, MonadIO m) => a -> WebViewCloseCallback -> m SignalHandlerId
afterWebViewClose obj cb = liftIO $ do
    let cb' = wrap_WebViewCloseCallback cb
    cb'' <- mk_WebViewCloseCallback cb'
    connectSignalFunPtr obj "close" cb'' SignalConnectAfter


-- signal WebView::context-menu
{- |
Emitted when a context menu is about to be displayed to give the application
a chance to customize the proposed menu, prevent the menu from being displayed,
or build its own context menu.
\<itemizedlist>
\<listitem>\<para>
 To customize the proposed menu you can use 'GI.WebKit2.Objects.ContextMenu.contextMenuPrepend',
 'GI.WebKit2.Objects.ContextMenu.contextMenuAppend' or 'GI.WebKit2.Objects.ContextMenu.contextMenuInsert' to add new
 'GI.WebKit2.Objects.ContextMenuItem.ContextMenuItem'\<!-- -->s to /@contextMenu@/, 'GI.WebKit2.Objects.ContextMenu.contextMenuMoveItem'
 to reorder existing items, or 'GI.WebKit2.Objects.ContextMenu.contextMenuRemove' to remove an
 existing item. The signal handler should return 'False', and the menu represented
 by /@contextMenu@/ will be shown.
\<\/para>\<\/listitem>
\<listitem>\<para>
 To prevent the menu from being displayed you can just connect to this signal
 and return 'True' so that the proposed menu will not be shown.
\<\/para>\<\/listitem>
\<listitem>\<para>
 To build your own menu, you can remove all items from the proposed menu with
 'GI.WebKit2.Objects.ContextMenu.contextMenuRemoveAll', add your own items and return 'False' so
 that the menu will be shown. You can also ignore the proposed 'GI.WebKit2.Objects.ContextMenu.ContextMenu',
 build your own 'GI.Gtk.Objects.Menu.Menu' and return 'True' to prevent the proposed menu from being shown.
\<\/para>\<\/listitem>
\<listitem>\<para>
 If you just want the default menu to be shown always, simply don\'t connect to this
 signal because showing the proposed context menu is the default behaviour.
\<\/para>\<\/listitem>
\<\/itemizedlist>

The /@event@/ is expected to be one of the following types:
\<itemizedlist>
\<listitem>\<para>
a 'GI.Gdk.Structs.EventButton.EventButton' of type 'GI.Gdk.Enums.EventTypeButtonPress' when the context menu
was triggered with mouse.
\<\/para>\<\/listitem>
\<listitem>\<para>
a 'GI.Gdk.Structs.EventKey.EventKey' of type 'GI.Gdk.Enums.EventTypeKeyPress' if the keyboard was used to show
the menu.
\<\/para>\<\/listitem>
\<listitem>\<para>
a generic 'GI.Gdk.Unions.Event.Event' of type 'GI.Gdk.Enums.EventTypeNothing' when the 'GI.Gtk.Objects.Widget.Widget'::@/popup-menu/@
signal was used to show the context menu.
\<\/para>\<\/listitem>
\<\/itemizedlist>

If the signal handler returns 'False' the context menu represented by /@contextMenu@/
will be shown, if it return 'True' the context menu will not be shown.

The proposed 'GI.WebKit2.Objects.ContextMenu.ContextMenu' passed in /@contextMenu@/ argument is only valid
during the signal emission.
-}
type WebViewContextMenuCallback =
    WebKit2.ContextMenu.ContextMenu
    {- ^ /@contextMenu@/: the proposed 'GI.WebKit2.Objects.ContextMenu.ContextMenu' -}
    -> Gdk.Event.Event
    {- ^ /@event@/: the 'GI.Gdk.Unions.Event.Event' that triggered the context menu -}
    -> WebKit2.HitTestResult.HitTestResult
    {- ^ /@hitTestResult@/: a 'GI.WebKit2.Objects.HitTestResult.HitTestResult' -}
    -> IO Bool
    {- ^ __Returns:__ 'True' to stop other handlers from being invoked for the event.
   'False' to propagate the event further. -}

-- | A convenience synonym for @`Nothing` :: `Maybe` `WebViewContextMenuCallback`@.
noWebViewContextMenuCallback :: Maybe WebViewContextMenuCallback
noWebViewContextMenuCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_WebViewContextMenuCallback =
    Ptr () ->                               -- object
    Ptr WebKit2.ContextMenu.ContextMenu ->
    Ptr Gdk.Event.Event ->
    Ptr WebKit2.HitTestResult.HitTestResult ->
    Ptr () ->                               -- user_data
    IO CInt

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

-- | Wrap the callback into a `GClosure`.
genClosure_WebViewContextMenu :: MonadIO m => WebViewContextMenuCallback -> m (GClosure C_WebViewContextMenuCallback)
genClosure_WebViewContextMenu cb = liftIO $ do
    let cb' = wrap_WebViewContextMenuCallback cb
    mk_WebViewContextMenuCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `WebViewContextMenuCallback` into a `C_WebViewContextMenuCallback`.
wrap_WebViewContextMenuCallback ::
    WebViewContextMenuCallback ->
    C_WebViewContextMenuCallback
wrap_WebViewContextMenuCallback _cb _ contextMenu event hitTestResult _ = do
    contextMenu' <- (newObject WebKit2.ContextMenu.ContextMenu) contextMenu
    B.ManagedPtr.withTransient Gdk.Event.Event event $ \event' -> do
        hitTestResult' <- (newObject WebKit2.HitTestResult.HitTestResult) hitTestResult
        result <- _cb  contextMenu' event' hitTestResult'
        let result' = (fromIntegral . fromEnum) result
        return result'


{- |
Connect a signal handler for the “@context-menu@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' webView #contextMenu callback
@
-}
onWebViewContextMenu :: (IsWebView a, MonadIO m) => a -> WebViewContextMenuCallback -> m SignalHandlerId
onWebViewContextMenu obj cb = liftIO $ do
    let cb' = wrap_WebViewContextMenuCallback cb
    cb'' <- mk_WebViewContextMenuCallback cb'
    connectSignalFunPtr obj "context-menu" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@context-menu@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' webView #contextMenu callback
@
-}
afterWebViewContextMenu :: (IsWebView a, MonadIO m) => a -> WebViewContextMenuCallback -> m SignalHandlerId
afterWebViewContextMenu obj cb = liftIO $ do
    let cb' = wrap_WebViewContextMenuCallback cb
    cb'' <- mk_WebViewContextMenuCallback cb'
    connectSignalFunPtr obj "context-menu" cb'' SignalConnectAfter


-- signal WebView::context-menu-dismissed
{- |
Emitted after 'GI.WebKit2.Objects.WebView.WebView'::@/context-menu/@ signal, if the context menu is shown,
to notify that the context menu is dismissed.
-}
type WebViewContextMenuDismissedCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `WebViewContextMenuDismissedCallback`@.
noWebViewContextMenuDismissedCallback :: Maybe WebViewContextMenuDismissedCallback
noWebViewContextMenuDismissedCallback = Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_WebViewContextMenuDismissed :: MonadIO m => WebViewContextMenuDismissedCallback -> m (GClosure C_WebViewContextMenuDismissedCallback)
genClosure_WebViewContextMenuDismissed cb = liftIO $ do
    let cb' = wrap_WebViewContextMenuDismissedCallback cb
    mk_WebViewContextMenuDismissedCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `WebViewContextMenuDismissedCallback` into a `C_WebViewContextMenuDismissedCallback`.
wrap_WebViewContextMenuDismissedCallback ::
    WebViewContextMenuDismissedCallback ->
    C_WebViewContextMenuDismissedCallback
wrap_WebViewContextMenuDismissedCallback _cb _ _ = do
    _cb


{- |
Connect a signal handler for the “@context-menu-dismissed@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' webView #contextMenuDismissed callback
@
-}
onWebViewContextMenuDismissed :: (IsWebView a, MonadIO m) => a -> WebViewContextMenuDismissedCallback -> m SignalHandlerId
onWebViewContextMenuDismissed obj cb = liftIO $ do
    let cb' = wrap_WebViewContextMenuDismissedCallback cb
    cb'' <- mk_WebViewContextMenuDismissedCallback cb'
    connectSignalFunPtr obj "context-menu-dismissed" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@context-menu-dismissed@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' webView #contextMenuDismissed callback
@
-}
afterWebViewContextMenuDismissed :: (IsWebView a, MonadIO m) => a -> WebViewContextMenuDismissedCallback -> m SignalHandlerId
afterWebViewContextMenuDismissed obj cb = liftIO $ do
    let cb' = wrap_WebViewContextMenuDismissedCallback cb
    cb'' <- mk_WebViewContextMenuDismissedCallback cb'
    connectSignalFunPtr obj "context-menu-dismissed" cb'' SignalConnectAfter


-- signal WebView::create
{- |
Emitted when the creation of a new 'GI.WebKit2.Objects.WebView.WebView' is requested.
If this signal is handled the signal handler should return the
newly created 'GI.WebKit2.Objects.WebView.WebView'.

The 'GI.WebKit2.Structs.NavigationAction.NavigationAction' parameter contains information about the
navigation action that triggered this signal.

When using 'GI.WebKit2.Enums.ProcessModelMultipleSecondaryProcesses'
process model, the new 'GI.WebKit2.Objects.WebView.WebView' should be related to
/@webView@/ to share the same web process, see 'GI.WebKit2.Objects.WebView.webViewNewWithRelatedView'
for more details.

The new 'GI.WebKit2.Objects.WebView.WebView' should not be displayed to the user
until the 'GI.WebKit2.Objects.WebView.WebView'::@/ready-to-show/@ signal is emitted.
-}
type WebViewCreateCallback =
    WebKit2.NavigationAction.NavigationAction
    {- ^ /@navigationAction@/: a 'GI.WebKit2.Structs.NavigationAction.NavigationAction' -}
    -> IO Gtk.Widget.Widget
    {- ^ __Returns:__ a newly allocated 'GI.WebKit2.Objects.WebView.WebView' widget
   or 'Nothing' to propagate the event further. -}

-- | A convenience synonym for @`Nothing` :: `Maybe` `WebViewCreateCallback`@.
noWebViewCreateCallback :: Maybe WebViewCreateCallback
noWebViewCreateCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_WebViewCreateCallback =
    Ptr () ->                               -- object
    Ptr WebKit2.NavigationAction.NavigationAction ->
    Ptr () ->                               -- user_data
    IO (Ptr Gtk.Widget.Widget)

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

-- | Wrap the callback into a `GClosure`.
genClosure_WebViewCreate :: MonadIO m => WebViewCreateCallback -> m (GClosure C_WebViewCreateCallback)
genClosure_WebViewCreate cb = liftIO $ do
    let cb' = wrap_WebViewCreateCallback cb
    mk_WebViewCreateCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `WebViewCreateCallback` into a `C_WebViewCreateCallback`.
wrap_WebViewCreateCallback ::
    WebViewCreateCallback ->
    C_WebViewCreateCallback
wrap_WebViewCreateCallback _cb _ navigationAction _ = do
    B.ManagedPtr.withTransient WebKit2.NavigationAction.NavigationAction navigationAction $ \navigationAction' -> do
        result <- _cb  navigationAction'
        result' <- B.ManagedPtr.disownObject result
        return result'


{- |
Connect a signal handler for the “@create@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' webView #create callback
@
-}
onWebViewCreate :: (IsWebView a, MonadIO m) => a -> WebViewCreateCallback -> m SignalHandlerId
onWebViewCreate obj cb = liftIO $ do
    let cb' = wrap_WebViewCreateCallback cb
    cb'' <- mk_WebViewCreateCallback cb'
    connectSignalFunPtr obj "create" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@create@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' webView #create callback
@
-}
afterWebViewCreate :: (IsWebView a, MonadIO m) => a -> WebViewCreateCallback -> m SignalHandlerId
afterWebViewCreate obj cb = liftIO $ do
    let cb' = wrap_WebViewCreateCallback cb
    cb'' <- mk_WebViewCreateCallback cb'
    connectSignalFunPtr obj "create" cb'' SignalConnectAfter


-- signal WebView::decide-policy
{- |
This signal is emitted when WebKit is requesting the client to decide a policy
decision, such as whether to navigate to a page, open a new window or whether or
not to download a resource. The 'GI.WebKit2.Objects.NavigationPolicyDecision.NavigationPolicyDecision' passed in the
/@decision@/ argument is a generic type, but should be casted to a more
specific type when making the decision. For example:

\<informalexample>\<programlisting>
static gboolean
decide_policy_cb (WebKitWebView *web_view,
                  WebKitPolicyDecision *decision,
                  WebKitPolicyDecisionType type)
{
    switch (type) {
    case WEBKIT_POLICY_DECISION_TYPE_NAVIGATION_ACTION: {
        WebKitNavigationPolicyDecision *navigation_decision = WEBKIT_NAVIGATION_POLICY_DECISION (decision);
        \/\<!-- -->* Make a policy decision here. *\<!-- -->\/
        break;
    }
    case WEBKIT_POLICY_DECISION_TYPE_NEW_WINDOW_ACTION: {
        WebKitNavigationPolicyDecision *navigation_decision = WEBKIT_NAVIGATION_POLICY_DECISION (decision);
        \/\<!-- -->* Make a policy decision here. *\<!-- -->\/
        break;
    }
    case WEBKIT_POLICY_DECISION_TYPE_RESPONSE:
        WebKitResponsePolicyDecision *response = WEBKIT_RESPONSE_POLICY_DECISION (decision);
        \/\<!-- -->* Make a policy decision here. *\<!-- -->\/
        break;
    default:
        \/\<!-- -->* Making no decision results in 'GI.WebKit2.Objects.PolicyDecision.policyDecisionUse'. *\<!-- -->\/
        return FALSE;
    }
    return TRUE;
}
\<\/programlisting>\<\/informalexample>

It is possible to make policy decision asynchronously, by simply calling 'GI.GObject.Objects.Object.objectRef'
on the /@decision@/ argument and returning 'True' to block the default signal handler.
If the last reference is removed on a 'GI.WebKit2.Objects.PolicyDecision.PolicyDecision' and no decision has been
made explicitly, 'GI.WebKit2.Objects.PolicyDecision.policyDecisionUse' will be the default policy decision. The
default signal handler will simply call 'GI.WebKit2.Objects.PolicyDecision.policyDecisionUse'. Only the first
policy decision chosen for a given 'GI.WebKit2.Objects.PolicyDecision.PolicyDecision' will have any affect.
-}
type WebViewDecidePolicyCallback =
    WebKit2.PolicyDecision.PolicyDecision
    {- ^ /@decision@/: the 'GI.WebKit2.Objects.PolicyDecision.PolicyDecision' -}
    -> WebKit2.Enums.PolicyDecisionType
    {- ^ /@decisionType@/: a 'GI.WebKit2.Enums.PolicyDecisionType' denoting the type of /@decision@/ -}
    -> IO Bool
    {- ^ __Returns:__ 'True' to stop other handlers from being invoked for the event.
  'False' to propagate the event further. -}

-- | A convenience synonym for @`Nothing` :: `Maybe` `WebViewDecidePolicyCallback`@.
noWebViewDecidePolicyCallback :: Maybe WebViewDecidePolicyCallback
noWebViewDecidePolicyCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_WebViewDecidePolicyCallback =
    Ptr () ->                               -- object
    Ptr WebKit2.PolicyDecision.PolicyDecision ->
    CUInt ->
    Ptr () ->                               -- user_data
    IO CInt

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

-- | Wrap the callback into a `GClosure`.
genClosure_WebViewDecidePolicy :: MonadIO m => WebViewDecidePolicyCallback -> m (GClosure C_WebViewDecidePolicyCallback)
genClosure_WebViewDecidePolicy cb = liftIO $ do
    let cb' = wrap_WebViewDecidePolicyCallback cb
    mk_WebViewDecidePolicyCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `WebViewDecidePolicyCallback` into a `C_WebViewDecidePolicyCallback`.
wrap_WebViewDecidePolicyCallback ::
    WebViewDecidePolicyCallback ->
    C_WebViewDecidePolicyCallback
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'


{- |
Connect a signal handler for the “@decide-policy@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' webView #decidePolicy callback
@
-}
onWebViewDecidePolicy :: (IsWebView a, MonadIO m) => a -> WebViewDecidePolicyCallback -> m SignalHandlerId
onWebViewDecidePolicy obj cb = liftIO $ do
    let cb' = wrap_WebViewDecidePolicyCallback cb
    cb'' <- mk_WebViewDecidePolicyCallback cb'
    connectSignalFunPtr obj "decide-policy" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@decide-policy@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' webView #decidePolicy callback
@
-}
afterWebViewDecidePolicy :: (IsWebView a, MonadIO m) => a -> WebViewDecidePolicyCallback -> m SignalHandlerId
afterWebViewDecidePolicy obj cb = liftIO $ do
    let cb' = wrap_WebViewDecidePolicyCallback cb
    cb'' <- mk_WebViewDecidePolicyCallback cb'
    connectSignalFunPtr obj "decide-policy" cb'' SignalConnectAfter


-- signal WebView::enter-fullscreen
{- |
Emitted when JavaScript code calls
\<function>element.webkitRequestFullScreen\<\/function>. If the
signal is not handled the 'GI.WebKit2.Objects.WebView.WebView' will proceed to full screen
its top level window. This signal can be used by client code to
request permission to the user prior doing the full screen
transition and eventually prepare the top-level window
(e.g. hide some widgets that would otherwise be part of the
full screen window).
-}
type WebViewEnterFullscreenCallback =
    IO Bool
    {- ^ __Returns:__ 'True' to stop other handlers from being invoked for the event.
   'False' to continue emission of the event. -}

-- | A convenience synonym for @`Nothing` :: `Maybe` `WebViewEnterFullscreenCallback`@.
noWebViewEnterFullscreenCallback :: Maybe WebViewEnterFullscreenCallback
noWebViewEnterFullscreenCallback = Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_WebViewEnterFullscreen :: MonadIO m => WebViewEnterFullscreenCallback -> m (GClosure C_WebViewEnterFullscreenCallback)
genClosure_WebViewEnterFullscreen cb = liftIO $ do
    let cb' = wrap_WebViewEnterFullscreenCallback cb
    mk_WebViewEnterFullscreenCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `WebViewEnterFullscreenCallback` into a `C_WebViewEnterFullscreenCallback`.
wrap_WebViewEnterFullscreenCallback ::
    WebViewEnterFullscreenCallback ->
    C_WebViewEnterFullscreenCallback
wrap_WebViewEnterFullscreenCallback _cb _ _ = do
    result <- _cb
    let result' = (fromIntegral . fromEnum) result
    return result'


{- |
Connect a signal handler for the “@enter-fullscreen@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' webView #enterFullscreen callback
@
-}
onWebViewEnterFullscreen :: (IsWebView a, MonadIO m) => a -> WebViewEnterFullscreenCallback -> m SignalHandlerId
onWebViewEnterFullscreen obj cb = liftIO $ do
    let cb' = wrap_WebViewEnterFullscreenCallback cb
    cb'' <- mk_WebViewEnterFullscreenCallback cb'
    connectSignalFunPtr obj "enter-fullscreen" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@enter-fullscreen@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' webView #enterFullscreen callback
@
-}
afterWebViewEnterFullscreen :: (IsWebView a, MonadIO m) => a -> WebViewEnterFullscreenCallback -> m SignalHandlerId
afterWebViewEnterFullscreen obj cb = liftIO $ do
    let cb' = wrap_WebViewEnterFullscreenCallback cb
    cb'' <- mk_WebViewEnterFullscreenCallback cb'
    connectSignalFunPtr obj "enter-fullscreen" cb'' SignalConnectAfter


-- signal WebView::insecure-content-detected
{- |
This signal is emitted when insecure content has been detected
in a page loaded through a secure connection. This typically
means that a external resource from an unstrusted source has
been run or displayed, resulting in a mix of HTTPS and
non-HTTPS content.

You can check the /@event@/ parameter to know exactly which kind
of event has been detected (see 'GI.WebKit2.Enums.InsecureContentEvent').
-}
type WebViewInsecureContentDetectedCallback =
    WebKit2.Enums.InsecureContentEvent
    {- ^ /@event@/: the 'GI.WebKit2.Enums.InsecureContentEvent' -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `WebViewInsecureContentDetectedCallback`@.
noWebViewInsecureContentDetectedCallback :: Maybe WebViewInsecureContentDetectedCallback
noWebViewInsecureContentDetectedCallback = Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_WebViewInsecureContentDetected :: MonadIO m => WebViewInsecureContentDetectedCallback -> m (GClosure C_WebViewInsecureContentDetectedCallback)
genClosure_WebViewInsecureContentDetected cb = liftIO $ do
    let cb' = wrap_WebViewInsecureContentDetectedCallback cb
    mk_WebViewInsecureContentDetectedCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `WebViewInsecureContentDetectedCallback` into a `C_WebViewInsecureContentDetectedCallback`.
wrap_WebViewInsecureContentDetectedCallback ::
    WebViewInsecureContentDetectedCallback ->
    C_WebViewInsecureContentDetectedCallback
wrap_WebViewInsecureContentDetectedCallback _cb _ event _ = do
    let event' = (toEnum . fromIntegral) event
    _cb  event'


{- |
Connect a signal handler for the “@insecure-content-detected@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' webView #insecureContentDetected callback
@
-}
onWebViewInsecureContentDetected :: (IsWebView a, MonadIO m) => a -> WebViewInsecureContentDetectedCallback -> m SignalHandlerId
onWebViewInsecureContentDetected obj cb = liftIO $ do
    let cb' = wrap_WebViewInsecureContentDetectedCallback cb
    cb'' <- mk_WebViewInsecureContentDetectedCallback cb'
    connectSignalFunPtr obj "insecure-content-detected" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@insecure-content-detected@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' webView #insecureContentDetected callback
@
-}
afterWebViewInsecureContentDetected :: (IsWebView a, MonadIO m) => a -> WebViewInsecureContentDetectedCallback -> m SignalHandlerId
afterWebViewInsecureContentDetected obj cb = liftIO $ do
    let cb' = wrap_WebViewInsecureContentDetectedCallback cb
    cb'' <- mk_WebViewInsecureContentDetectedCallback cb'
    connectSignalFunPtr obj "insecure-content-detected" cb'' SignalConnectAfter


-- signal WebView::leave-fullscreen
{- |
Emitted when the 'GI.WebKit2.Objects.WebView.WebView' is about to restore its top level
window out of its full screen state. This signal can be used by
client code to restore widgets hidden during the
'GI.WebKit2.Objects.WebView.WebView'::@/enter-fullscreen/@ stage for instance.
-}
type WebViewLeaveFullscreenCallback =
    IO Bool
    {- ^ __Returns:__ 'True' to stop other handlers from being invoked for the event.
   'False' to continue emission of the event. -}

-- | A convenience synonym for @`Nothing` :: `Maybe` `WebViewLeaveFullscreenCallback`@.
noWebViewLeaveFullscreenCallback :: Maybe WebViewLeaveFullscreenCallback
noWebViewLeaveFullscreenCallback = Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_WebViewLeaveFullscreen :: MonadIO m => WebViewLeaveFullscreenCallback -> m (GClosure C_WebViewLeaveFullscreenCallback)
genClosure_WebViewLeaveFullscreen cb = liftIO $ do
    let cb' = wrap_WebViewLeaveFullscreenCallback cb
    mk_WebViewLeaveFullscreenCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `WebViewLeaveFullscreenCallback` into a `C_WebViewLeaveFullscreenCallback`.
wrap_WebViewLeaveFullscreenCallback ::
    WebViewLeaveFullscreenCallback ->
    C_WebViewLeaveFullscreenCallback
wrap_WebViewLeaveFullscreenCallback _cb _ _ = do
    result <- _cb
    let result' = (fromIntegral . fromEnum) result
    return result'


{- |
Connect a signal handler for the “@leave-fullscreen@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' webView #leaveFullscreen callback
@
-}
onWebViewLeaveFullscreen :: (IsWebView a, MonadIO m) => a -> WebViewLeaveFullscreenCallback -> m SignalHandlerId
onWebViewLeaveFullscreen obj cb = liftIO $ do
    let cb' = wrap_WebViewLeaveFullscreenCallback cb
    cb'' <- mk_WebViewLeaveFullscreenCallback cb'
    connectSignalFunPtr obj "leave-fullscreen" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@leave-fullscreen@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' webView #leaveFullscreen callback
@
-}
afterWebViewLeaveFullscreen :: (IsWebView a, MonadIO m) => a -> WebViewLeaveFullscreenCallback -> m SignalHandlerId
afterWebViewLeaveFullscreen obj cb = liftIO $ do
    let cb' = wrap_WebViewLeaveFullscreenCallback cb
    cb'' <- mk_WebViewLeaveFullscreenCallback cb'
    connectSignalFunPtr obj "leave-fullscreen" cb'' SignalConnectAfter


-- signal WebView::load-changed
{- |
Emitted when a load operation in /@webView@/ changes.
The signal is always emitted with 'GI.WebKit2.Enums.LoadEventStarted' when a
new load request is made and 'GI.WebKit2.Enums.LoadEventFinished' when the load
finishes successfully or due to an error. When the ongoing load
operation fails 'GI.WebKit2.Objects.WebView.WebView'::@/load-failed/@ signal is emitted
before 'GI.WebKit2.Objects.WebView.WebView'::@/load-changed/@ is emitted with
'GI.WebKit2.Enums.LoadEventFinished'.
If a redirection is received from the server, this signal is emitted
with 'GI.WebKit2.Enums.LoadEventRedirected' after the initial emission with
'GI.WebKit2.Enums.LoadEventStarted' and before 'GI.WebKit2.Enums.LoadEventCommitted'.
When the page content starts arriving the signal is emitted with
'GI.WebKit2.Enums.LoadEventCommitted' event.

You can handle this signal and use a switch to track any ongoing
load operation.

\<informalexample>\<programlisting>
static void web_view_load_changed (WebKitWebView  *web_view,
                                   WebKitLoadEvent load_event,
                                   gpointer        user_data)
{
    switch (load_event) {
    case WEBKIT_LOAD_STARTED:
        \/\<!-- -->* New load, we have now a provisional URI *\<!-- -->\/
        provisional_uri = webkit_web_view_get_uri (web_view);
        \/\<!-- -->* Here we could start a spinner or update the
         \<!-- -->* location bar with the provisional URI *\<!-- -->\/
        break;
    case WEBKIT_LOAD_REDIRECTED:
        redirected_uri = webkit_web_view_get_uri (web_view);
        break;
    case WEBKIT_LOAD_COMMITTED:
        \/\<!-- -->* The load is being performed. Current URI is
         \<!-- -->* the final one and it won\'t change unless a new
         \<!-- -->* load is requested or a navigation within the
         \<!-- -->* same page is performed *\<!-- -->\/
        uri = webkit_web_view_get_uri (web_view);
        break;
    case WEBKIT_LOAD_FINISHED:
        \/\<!-- -->* Load finished, we can now stop the spinner *\<!-- -->\/
        break;
    }
}
\<\/programlisting>\<\/informalexample>
-}
type WebViewLoadChangedCallback =
    WebKit2.Enums.LoadEvent
    {- ^ /@loadEvent@/: the 'GI.WebKit2.Enums.LoadEvent' -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `WebViewLoadChangedCallback`@.
noWebViewLoadChangedCallback :: Maybe WebViewLoadChangedCallback
noWebViewLoadChangedCallback = Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_WebViewLoadChanged :: MonadIO m => WebViewLoadChangedCallback -> m (GClosure C_WebViewLoadChangedCallback)
genClosure_WebViewLoadChanged cb = liftIO $ do
    let cb' = wrap_WebViewLoadChangedCallback cb
    mk_WebViewLoadChangedCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `WebViewLoadChangedCallback` into a `C_WebViewLoadChangedCallback`.
wrap_WebViewLoadChangedCallback ::
    WebViewLoadChangedCallback ->
    C_WebViewLoadChangedCallback
wrap_WebViewLoadChangedCallback _cb _ loadEvent _ = do
    let loadEvent' = (toEnum . fromIntegral) loadEvent
    _cb  loadEvent'


{- |
Connect a signal handler for the “@load-changed@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' webView #loadChanged callback
@
-}
onWebViewLoadChanged :: (IsWebView a, MonadIO m) => a -> WebViewLoadChangedCallback -> m SignalHandlerId
onWebViewLoadChanged obj cb = liftIO $ do
    let cb' = wrap_WebViewLoadChangedCallback cb
    cb'' <- mk_WebViewLoadChangedCallback cb'
    connectSignalFunPtr obj "load-changed" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@load-changed@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' webView #loadChanged callback
@
-}
afterWebViewLoadChanged :: (IsWebView a, MonadIO m) => a -> WebViewLoadChangedCallback -> m SignalHandlerId
afterWebViewLoadChanged obj cb = liftIO $ do
    let cb' = wrap_WebViewLoadChangedCallback cb
    cb'' <- mk_WebViewLoadChangedCallback cb'
    connectSignalFunPtr obj "load-changed" cb'' SignalConnectAfter


-- signal WebView::load-failed
{- |
Emitted when an error occurs during a load operation.
If the error happened when starting to load data for a page
/@loadEvent@/ will be 'GI.WebKit2.Enums.LoadEventStarted'. If it happened while
loading a committed data source /@loadEvent@/ will be 'GI.WebKit2.Enums.LoadEventCommitted'.
Since a load error causes the load operation to finish, the signal
WebKitWebView::load-changed will always be emitted with
'GI.WebKit2.Enums.LoadEventFinished' event right after this one.

By default, if the signal is not handled, a stock error page will be displayed.
You need to handle the signal if you want to provide your own error page.
-}
type WebViewLoadFailedCallback =
    WebKit2.Enums.LoadEvent
    {- ^ /@loadEvent@/: the 'GI.WebKit2.Enums.LoadEvent' of the load operation -}
    -> T.Text
    {- ^ /@failingUri@/: the URI that failed to load -}
    -> GError
    {- ^ /@error@/: the 'GError' that was triggered -}
    -> IO Bool
    {- ^ __Returns:__ 'True' to stop other handlers from being invoked for the event.
   'False' to propagate the event further. -}

-- | A convenience synonym for @`Nothing` :: `Maybe` `WebViewLoadFailedCallback`@.
noWebViewLoadFailedCallback :: Maybe WebViewLoadFailedCallback
noWebViewLoadFailedCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_WebViewLoadFailedCallback =
    Ptr () ->                               -- object
    CUInt ->
    CString ->
    Ptr GError ->
    Ptr () ->                               -- user_data
    IO CInt

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

-- | Wrap the callback into a `GClosure`.
genClosure_WebViewLoadFailed :: MonadIO m => WebViewLoadFailedCallback -> m (GClosure C_WebViewLoadFailedCallback)
genClosure_WebViewLoadFailed cb = liftIO $ do
    let cb' = wrap_WebViewLoadFailedCallback cb
    mk_WebViewLoadFailedCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `WebViewLoadFailedCallback` into a `C_WebViewLoadFailedCallback`.
wrap_WebViewLoadFailedCallback ::
    WebViewLoadFailedCallback ->
    C_WebViewLoadFailedCallback
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'


{- |
Connect a signal handler for the “@load-failed@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' webView #loadFailed callback
@
-}
onWebViewLoadFailed :: (IsWebView a, MonadIO m) => a -> WebViewLoadFailedCallback -> m SignalHandlerId
onWebViewLoadFailed obj cb = liftIO $ do
    let cb' = wrap_WebViewLoadFailedCallback cb
    cb'' <- mk_WebViewLoadFailedCallback cb'
    connectSignalFunPtr obj "load-failed" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@load-failed@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' webView #loadFailed callback
@
-}
afterWebViewLoadFailed :: (IsWebView a, MonadIO m) => a -> WebViewLoadFailedCallback -> m SignalHandlerId
afterWebViewLoadFailed obj cb = liftIO $ do
    let cb' = wrap_WebViewLoadFailedCallback cb
    cb'' <- mk_WebViewLoadFailedCallback cb'
    connectSignalFunPtr obj "load-failed" cb'' SignalConnectAfter


-- signal WebView::load-failed-with-tls-errors
{- |
Emitted when a TLS error occurs during a load operation.
To allow an exception for this /@certificate@/
and the host of /@failingUri@/ use 'GI.WebKit2.Objects.WebContext.webContextAllowTlsCertificateForHost'.

To handle this signal asynchronously you should call 'GI.GObject.Objects.Object.objectRef' on /@certificate@/
and return 'True'.

If 'False' is returned, 'GI.WebKit2.Objects.WebView.WebView'::@/load-failed/@ will be emitted. The load
will finish regardless of the returned value.

/Since: 2.6/
-}
type WebViewLoadFailedWithTlsErrorsCallback =
    T.Text
    {- ^ /@failingUri@/: the URI that failed to load -}
    -> Gio.TlsCertificate.TlsCertificate
    {- ^ /@certificate@/: a 'GI.Gio.Objects.TlsCertificate.TlsCertificate' -}
    -> [Gio.Flags.TlsCertificateFlags]
    {- ^ /@errors@/: a 'GI.Gio.Flags.TlsCertificateFlags' with the verification status of /@certificate@/ -}
    -> IO Bool
    {- ^ __Returns:__ 'True' to stop other handlers from being invoked for the event.
  'False' to propagate the event further. -}

-- | A convenience synonym for @`Nothing` :: `Maybe` `WebViewLoadFailedWithTlsErrorsCallback`@.
noWebViewLoadFailedWithTlsErrorsCallback :: Maybe WebViewLoadFailedWithTlsErrorsCallback
noWebViewLoadFailedWithTlsErrorsCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_WebViewLoadFailedWithTlsErrorsCallback =
    Ptr () ->                               -- object
    CString ->
    Ptr Gio.TlsCertificate.TlsCertificate ->
    CUInt ->
    Ptr () ->                               -- user_data
    IO CInt

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

-- | Wrap the callback into a `GClosure`.
genClosure_WebViewLoadFailedWithTlsErrors :: MonadIO m => WebViewLoadFailedWithTlsErrorsCallback -> m (GClosure C_WebViewLoadFailedWithTlsErrorsCallback)
genClosure_WebViewLoadFailedWithTlsErrors cb = liftIO $ do
    let cb' = wrap_WebViewLoadFailedWithTlsErrorsCallback cb
    mk_WebViewLoadFailedWithTlsErrorsCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `WebViewLoadFailedWithTlsErrorsCallback` into a `C_WebViewLoadFailedWithTlsErrorsCallback`.
wrap_WebViewLoadFailedWithTlsErrorsCallback ::
    WebViewLoadFailedWithTlsErrorsCallback ->
    C_WebViewLoadFailedWithTlsErrorsCallback
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'


{- |
Connect a signal handler for the “@load-failed-with-tls-errors@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' webView #loadFailedWithTlsErrors callback
@
-}
onWebViewLoadFailedWithTlsErrors :: (IsWebView a, MonadIO m) => a -> WebViewLoadFailedWithTlsErrorsCallback -> m SignalHandlerId
onWebViewLoadFailedWithTlsErrors obj cb = liftIO $ do
    let cb' = wrap_WebViewLoadFailedWithTlsErrorsCallback cb
    cb'' <- mk_WebViewLoadFailedWithTlsErrorsCallback cb'
    connectSignalFunPtr obj "load-failed-with-tls-errors" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@load-failed-with-tls-errors@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' webView #loadFailedWithTlsErrors callback
@
-}
afterWebViewLoadFailedWithTlsErrors :: (IsWebView a, MonadIO m) => a -> WebViewLoadFailedWithTlsErrorsCallback -> m SignalHandlerId
afterWebViewLoadFailedWithTlsErrors obj cb = liftIO $ do
    let cb' = wrap_WebViewLoadFailedWithTlsErrorsCallback cb
    cb'' <- mk_WebViewLoadFailedWithTlsErrorsCallback cb'
    connectSignalFunPtr obj "load-failed-with-tls-errors" cb'' SignalConnectAfter


-- signal WebView::mouse-target-changed
{- |
This signal is emitted when the mouse cursor moves over an
element such as a link, image or a media element. To determine
what type of element the mouse cursor is over, a Hit Test is performed
on the current mouse coordinates and the result is passed in the
/@hitTestResult@/ argument. The /@modifiers@/ argument is a bitmask of
'GI.Gdk.Flags.ModifierType' flags indicating the state of modifier keys.
The signal is emitted again when the mouse is moved out of the
current element with a new /@hitTestResult@/.
-}
type WebViewMouseTargetChangedCallback =
    WebKit2.HitTestResult.HitTestResult
    {- ^ /@hitTestResult@/: a 'GI.WebKit2.Objects.HitTestResult.HitTestResult' -}
    -> Word32
    {- ^ /@modifiers@/: a bitmask of 'GI.Gdk.Flags.ModifierType' -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `WebViewMouseTargetChangedCallback`@.
noWebViewMouseTargetChangedCallback :: Maybe WebViewMouseTargetChangedCallback
noWebViewMouseTargetChangedCallback = Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_WebViewMouseTargetChanged :: MonadIO m => WebViewMouseTargetChangedCallback -> m (GClosure C_WebViewMouseTargetChangedCallback)
genClosure_WebViewMouseTargetChanged cb = liftIO $ do
    let cb' = wrap_WebViewMouseTargetChangedCallback cb
    mk_WebViewMouseTargetChangedCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `WebViewMouseTargetChangedCallback` into a `C_WebViewMouseTargetChangedCallback`.
wrap_WebViewMouseTargetChangedCallback ::
    WebViewMouseTargetChangedCallback ->
    C_WebViewMouseTargetChangedCallback
wrap_WebViewMouseTargetChangedCallback _cb _ hitTestResult modifiers _ = do
    hitTestResult' <- (newObject WebKit2.HitTestResult.HitTestResult) hitTestResult
    _cb  hitTestResult' modifiers


{- |
Connect a signal handler for the “@mouse-target-changed@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' webView #mouseTargetChanged callback
@
-}
onWebViewMouseTargetChanged :: (IsWebView a, MonadIO m) => a -> WebViewMouseTargetChangedCallback -> m SignalHandlerId
onWebViewMouseTargetChanged obj cb = liftIO $ do
    let cb' = wrap_WebViewMouseTargetChangedCallback cb
    cb'' <- mk_WebViewMouseTargetChangedCallback cb'
    connectSignalFunPtr obj "mouse-target-changed" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@mouse-target-changed@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' webView #mouseTargetChanged callback
@
-}
afterWebViewMouseTargetChanged :: (IsWebView a, MonadIO m) => a -> WebViewMouseTargetChangedCallback -> m SignalHandlerId
afterWebViewMouseTargetChanged obj cb = liftIO $ do
    let cb' = wrap_WebViewMouseTargetChangedCallback cb
    cb'' <- mk_WebViewMouseTargetChangedCallback cb'
    connectSignalFunPtr obj "mouse-target-changed" cb'' SignalConnectAfter


-- signal WebView::permission-request
{- |
This signal is emitted when WebKit is requesting the client to
decide about a permission request, such as allowing the browser
to switch to fullscreen mode, sharing its location or similar
operations.

A possible way to use this signal could be through a dialog
allowing the user decide what to do with the request:

\<informalexample>\<programlisting>
static gboolean permission_request_cb (WebKitWebView *web_view,
                                       WebKitPermissionRequest *request,
                                       GtkWindow *parent_window)
{
    GtkWidget *dialog = gtk_message_dialog_new (parent_window,
                                                GTK_DIALOG_MODAL,
                                                GTK_MESSAGE_QUESTION,
                                                GTK_BUTTONS_YES_NO,
                                                \"Allow Permission Request?\");
    gtk_widget_show (dialog);
    gint result = gtk_dialog_run (GTK_DIALOG (dialog));

    switch (result) {
    case GTK_RESPONSE_YES:
        webkit_permission_request_allow (request);
        break;
    default:
        webkit_permission_request_deny (request);
        break;
    }
    gtk_widget_destroy (dialog);

    return TRUE;
}
\<\/programlisting>\<\/informalexample>

It is possible to handle permission requests asynchronously, by
simply calling 'GI.GObject.Objects.Object.objectRef' on the /@request@/ argument and
returning 'True' to block the default signal handler.  If the
last reference is removed on a 'GI.WebKit2.Interfaces.PermissionRequest.PermissionRequest' and the
request has not been handled, 'GI.WebKit2.Interfaces.PermissionRequest.permissionRequestDeny'
will be the default action.

If the signal is not handled, the /@request@/ will be completed automatically
by the specific 'GI.WebKit2.Interfaces.PermissionRequest.PermissionRequest' that could allow or deny it. Check the
documentation of classes implementing 'GI.WebKit2.Interfaces.PermissionRequest.PermissionRequest' interface to know
their default action.
-}
type WebViewPermissionRequestCallback =
    WebKit2.PermissionRequest.PermissionRequest
    {- ^ /@request@/: the 'GI.WebKit2.Interfaces.PermissionRequest.PermissionRequest' -}
    -> IO Bool
    {- ^ __Returns:__ 'True' to stop other handlers from being invoked for the event.
  'False' to propagate the event further. -}

-- | A convenience synonym for @`Nothing` :: `Maybe` `WebViewPermissionRequestCallback`@.
noWebViewPermissionRequestCallback :: Maybe WebViewPermissionRequestCallback
noWebViewPermissionRequestCallback = Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_WebViewPermissionRequest :: MonadIO m => WebViewPermissionRequestCallback -> m (GClosure C_WebViewPermissionRequestCallback)
genClosure_WebViewPermissionRequest cb = liftIO $ do
    let cb' = wrap_WebViewPermissionRequestCallback cb
    mk_WebViewPermissionRequestCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `WebViewPermissionRequestCallback` into a `C_WebViewPermissionRequestCallback`.
wrap_WebViewPermissionRequestCallback ::
    WebViewPermissionRequestCallback ->
    C_WebViewPermissionRequestCallback
wrap_WebViewPermissionRequestCallback _cb _ request _ = do
    request' <- (newObject WebKit2.PermissionRequest.PermissionRequest) request
    result <- _cb  request'
    let result' = (fromIntegral . fromEnum) result
    return result'


{- |
Connect a signal handler for the “@permission-request@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' webView #permissionRequest callback
@
-}
onWebViewPermissionRequest :: (IsWebView a, MonadIO m) => a -> WebViewPermissionRequestCallback -> m SignalHandlerId
onWebViewPermissionRequest obj cb = liftIO $ do
    let cb' = wrap_WebViewPermissionRequestCallback cb
    cb'' <- mk_WebViewPermissionRequestCallback cb'
    connectSignalFunPtr obj "permission-request" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@permission-request@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' webView #permissionRequest callback
@
-}
afterWebViewPermissionRequest :: (IsWebView a, MonadIO m) => a -> WebViewPermissionRequestCallback -> m SignalHandlerId
afterWebViewPermissionRequest obj cb = liftIO $ do
    let cb' = wrap_WebViewPermissionRequestCallback cb
    cb'' <- mk_WebViewPermissionRequestCallback cb'
    connectSignalFunPtr obj "permission-request" cb'' SignalConnectAfter


-- signal WebView::print
{- |
Emitted when printing is requested on /@webView@/, usually by a JavaScript call,
before the print dialog is shown. This signal can be used to set the initial
print settings and page setup of /@printOperation@/ to be used as default values in
the print dialog. You can call 'GI.WebKit2.Objects.PrintOperation.printOperationSetPrintSettings' and
'GI.WebKit2.Objects.PrintOperation.printOperationSetPageSetup' and then return 'False' to propagate the
event so that the print dialog is shown.

You can connect to this signal and return 'True' to cancel the print operation
or implement your own print dialog.
-}
type WebViewPrintCallback =
    WebKit2.PrintOperation.PrintOperation
    {- ^ /@printOperation@/: the 'GI.WebKit2.Objects.PrintOperation.PrintOperation' that will handle the print request -}
    -> IO Bool
    {- ^ __Returns:__ 'True' to stop other handlers from being invoked for the event.
   'False' to propagate the event further. -}

-- | A convenience synonym for @`Nothing` :: `Maybe` `WebViewPrintCallback`@.
noWebViewPrintCallback :: Maybe WebViewPrintCallback
noWebViewPrintCallback = Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_WebViewPrint :: MonadIO m => WebViewPrintCallback -> m (GClosure C_WebViewPrintCallback)
genClosure_WebViewPrint cb = liftIO $ do
    let cb' = wrap_WebViewPrintCallback cb
    mk_WebViewPrintCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `WebViewPrintCallback` into a `C_WebViewPrintCallback`.
wrap_WebViewPrintCallback ::
    WebViewPrintCallback ->
    C_WebViewPrintCallback
wrap_WebViewPrintCallback _cb _ printOperation _ = do
    printOperation' <- (newObject WebKit2.PrintOperation.PrintOperation) printOperation
    result <- _cb  printOperation'
    let result' = (fromIntegral . fromEnum) result
    return result'


{- |
Connect a signal handler for the “@print@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' webView #print callback
@
-}
onWebViewPrint :: (IsWebView a, MonadIO m) => a -> WebViewPrintCallback -> m SignalHandlerId
onWebViewPrint obj cb = liftIO $ do
    let cb' = wrap_WebViewPrintCallback cb
    cb'' <- mk_WebViewPrintCallback cb'
    connectSignalFunPtr obj "print" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@print@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' webView #print callback
@
-}
afterWebViewPrint :: (IsWebView a, MonadIO m) => a -> WebViewPrintCallback -> m SignalHandlerId
afterWebViewPrint obj cb = liftIO $ do
    let cb' = wrap_WebViewPrintCallback cb
    cb'' <- mk_WebViewPrintCallback cb'
    connectSignalFunPtr obj "print" cb'' SignalConnectAfter


-- signal WebView::ready-to-show
{- |
Emitted after 'GI.WebKit2.Objects.WebView.WebView'::@/create/@ on the newly created 'GI.WebKit2.Objects.WebView.WebView'
when it should be displayed to the user. When this signal is emitted
all the information about how the window should look, including
size, position, whether the location, status and scrollbars
should be displayed, is already set on the 'GI.WebKit2.Objects.WindowProperties.WindowProperties'
of /@webView@/. See also 'GI.WebKit2.Objects.WebView.webViewGetWindowProperties'.
-}
type WebViewReadyToShowCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `WebViewReadyToShowCallback`@.
noWebViewReadyToShowCallback :: Maybe WebViewReadyToShowCallback
noWebViewReadyToShowCallback = Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_WebViewReadyToShow :: MonadIO m => WebViewReadyToShowCallback -> m (GClosure C_WebViewReadyToShowCallback)
genClosure_WebViewReadyToShow cb = liftIO $ do
    let cb' = wrap_WebViewReadyToShowCallback cb
    mk_WebViewReadyToShowCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `WebViewReadyToShowCallback` into a `C_WebViewReadyToShowCallback`.
wrap_WebViewReadyToShowCallback ::
    WebViewReadyToShowCallback ->
    C_WebViewReadyToShowCallback
wrap_WebViewReadyToShowCallback _cb _ _ = do
    _cb


{- |
Connect a signal handler for the “@ready-to-show@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' webView #readyToShow callback
@
-}
onWebViewReadyToShow :: (IsWebView a, MonadIO m) => a -> WebViewReadyToShowCallback -> m SignalHandlerId
onWebViewReadyToShow obj cb = liftIO $ do
    let cb' = wrap_WebViewReadyToShowCallback cb
    cb'' <- mk_WebViewReadyToShowCallback cb'
    connectSignalFunPtr obj "ready-to-show" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@ready-to-show@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' webView #readyToShow callback
@
-}
afterWebViewReadyToShow :: (IsWebView a, MonadIO m) => a -> WebViewReadyToShowCallback -> m SignalHandlerId
afterWebViewReadyToShow obj cb = liftIO $ do
    let cb' = wrap_WebViewReadyToShowCallback cb
    cb'' <- mk_WebViewReadyToShowCallback cb'
    connectSignalFunPtr obj "ready-to-show" cb'' SignalConnectAfter


-- signal WebView::resource-load-started
{- |
Emitted when a new resource is going to be loaded. The /@request@/ parameter
contains the 'GI.WebKit2.Objects.URIRequest.URIRequest' that will be sent to the server.
You can monitor the load operation by connecting to the different signals
of /@resource@/.
-}
type WebViewResourceLoadStartedCallback =
    WebKit2.WebResource.WebResource
    {- ^ /@resource@/: a 'GI.WebKit2.Objects.WebResource.WebResource' -}
    -> WebKit2.URIRequest.URIRequest
    {- ^ /@request@/: a 'GI.WebKit2.Objects.URIRequest.URIRequest' -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `WebViewResourceLoadStartedCallback`@.
noWebViewResourceLoadStartedCallback :: Maybe WebViewResourceLoadStartedCallback
noWebViewResourceLoadStartedCallback = Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_WebViewResourceLoadStarted :: MonadIO m => WebViewResourceLoadStartedCallback -> m (GClosure C_WebViewResourceLoadStartedCallback)
genClosure_WebViewResourceLoadStarted cb = liftIO $ do
    let cb' = wrap_WebViewResourceLoadStartedCallback cb
    mk_WebViewResourceLoadStartedCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `WebViewResourceLoadStartedCallback` into a `C_WebViewResourceLoadStartedCallback`.
wrap_WebViewResourceLoadStartedCallback ::
    WebViewResourceLoadStartedCallback ->
    C_WebViewResourceLoadStartedCallback
wrap_WebViewResourceLoadStartedCallback _cb _ resource request _ = do
    resource' <- (newObject WebKit2.WebResource.WebResource) resource
    request' <- (newObject WebKit2.URIRequest.URIRequest) request
    _cb  resource' request'


{- |
Connect a signal handler for the “@resource-load-started@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' webView #resourceLoadStarted callback
@
-}
onWebViewResourceLoadStarted :: (IsWebView a, MonadIO m) => a -> WebViewResourceLoadStartedCallback -> m SignalHandlerId
onWebViewResourceLoadStarted obj cb = liftIO $ do
    let cb' = wrap_WebViewResourceLoadStartedCallback cb
    cb'' <- mk_WebViewResourceLoadStartedCallback cb'
    connectSignalFunPtr obj "resource-load-started" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@resource-load-started@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' webView #resourceLoadStarted callback
@
-}
afterWebViewResourceLoadStarted :: (IsWebView a, MonadIO m) => a -> WebViewResourceLoadStartedCallback -> m SignalHandlerId
afterWebViewResourceLoadStarted obj cb = liftIO $ do
    let cb' = wrap_WebViewResourceLoadStartedCallback cb
    cb'' <- mk_WebViewResourceLoadStartedCallback cb'
    connectSignalFunPtr obj "resource-load-started" cb'' SignalConnectAfter


-- signal WebView::run-as-modal
{- |
Emitted after 'GI.WebKit2.Objects.WebView.WebView'::@/ready-to-show/@ on the newly
created 'GI.WebKit2.Objects.WebView.WebView' when JavaScript code calls
\<function>window.showModalDialog\<\/function>. The purpose of
this signal is to allow the client application to prepare the
new view to behave as modal. Once the signal is emitted a new
main loop will be run to block user interaction in the parent
'GI.WebKit2.Objects.WebView.WebView' until the new dialog is closed.
-}
type WebViewRunAsModalCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `WebViewRunAsModalCallback`@.
noWebViewRunAsModalCallback :: Maybe WebViewRunAsModalCallback
noWebViewRunAsModalCallback = Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_WebViewRunAsModal :: MonadIO m => WebViewRunAsModalCallback -> m (GClosure C_WebViewRunAsModalCallback)
genClosure_WebViewRunAsModal cb = liftIO $ do
    let cb' = wrap_WebViewRunAsModalCallback cb
    mk_WebViewRunAsModalCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `WebViewRunAsModalCallback` into a `C_WebViewRunAsModalCallback`.
wrap_WebViewRunAsModalCallback ::
    WebViewRunAsModalCallback ->
    C_WebViewRunAsModalCallback
wrap_WebViewRunAsModalCallback _cb _ _ = do
    _cb


{- |
Connect a signal handler for the “@run-as-modal@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' webView #runAsModal callback
@
-}
onWebViewRunAsModal :: (IsWebView a, MonadIO m) => a -> WebViewRunAsModalCallback -> m SignalHandlerId
onWebViewRunAsModal obj cb = liftIO $ do
    let cb' = wrap_WebViewRunAsModalCallback cb
    cb'' <- mk_WebViewRunAsModalCallback cb'
    connectSignalFunPtr obj "run-as-modal" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@run-as-modal@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' webView #runAsModal callback
@
-}
afterWebViewRunAsModal :: (IsWebView a, MonadIO m) => a -> WebViewRunAsModalCallback -> m SignalHandlerId
afterWebViewRunAsModal obj cb = liftIO $ do
    let cb' = wrap_WebViewRunAsModalCallback cb
    cb'' <- mk_WebViewRunAsModalCallback cb'
    connectSignalFunPtr obj "run-as-modal" cb'' SignalConnectAfter


-- signal WebView::run-color-chooser
{- |
This signal is emitted when the user interacts with a &lt;input
type=\'color\' \/&gt; HTML element, requesting from WebKit to show
a dialog to select a color. To let the application know the details of
the color chooser, as well as to allow the client application to either
cancel the request or perform an actual color selection, the signal will
pass an instance of the 'GI.WebKit2.Objects.ColorChooserRequest.ColorChooserRequest' in the /@request@/
argument.

It is possible to handle this request asynchronously by increasing the
reference count of the request.

The default signal handler will asynchronously run a regular
'GI.Gtk.Interfaces.ColorChooser.ColorChooser' for the user to interact with.

/Since: 2.8/
-}
type WebViewRunColorChooserCallback =
    WebKit2.ColorChooserRequest.ColorChooserRequest
    {- ^ /@request@/: a 'GI.WebKit2.Objects.ColorChooserRequest.ColorChooserRequest' -}
    -> IO Bool
    {- ^ __Returns:__ 'True' to stop other handlers from being invoked for the event.
  'False' to propagate the event further. -}

-- | A convenience synonym for @`Nothing` :: `Maybe` `WebViewRunColorChooserCallback`@.
noWebViewRunColorChooserCallback :: Maybe WebViewRunColorChooserCallback
noWebViewRunColorChooserCallback = Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_WebViewRunColorChooser :: MonadIO m => WebViewRunColorChooserCallback -> m (GClosure C_WebViewRunColorChooserCallback)
genClosure_WebViewRunColorChooser cb = liftIO $ do
    let cb' = wrap_WebViewRunColorChooserCallback cb
    mk_WebViewRunColorChooserCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `WebViewRunColorChooserCallback` into a `C_WebViewRunColorChooserCallback`.
wrap_WebViewRunColorChooserCallback ::
    WebViewRunColorChooserCallback ->
    C_WebViewRunColorChooserCallback
wrap_WebViewRunColorChooserCallback _cb _ request _ = do
    request' <- (newObject WebKit2.ColorChooserRequest.ColorChooserRequest) request
    result <- _cb  request'
    let result' = (fromIntegral . fromEnum) result
    return result'


{- |
Connect a signal handler for the “@run-color-chooser@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' webView #runColorChooser callback
@
-}
onWebViewRunColorChooser :: (IsWebView a, MonadIO m) => a -> WebViewRunColorChooserCallback -> m SignalHandlerId
onWebViewRunColorChooser obj cb = liftIO $ do
    let cb' = wrap_WebViewRunColorChooserCallback cb
    cb'' <- mk_WebViewRunColorChooserCallback cb'
    connectSignalFunPtr obj "run-color-chooser" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@run-color-chooser@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' webView #runColorChooser callback
@
-}
afterWebViewRunColorChooser :: (IsWebView a, MonadIO m) => a -> WebViewRunColorChooserCallback -> m SignalHandlerId
afterWebViewRunColorChooser obj cb = liftIO $ do
    let cb' = wrap_WebViewRunColorChooserCallback cb
    cb'' <- mk_WebViewRunColorChooserCallback cb'
    connectSignalFunPtr obj "run-color-chooser" cb'' SignalConnectAfter


-- signal WebView::run-file-chooser
{- |
This signal is emitted when the user interacts with a &lt;input
type=\'file\' \/&gt; HTML element, requesting from WebKit to show
a dialog to select one or more files to be uploaded. To let the
application know the details of the file chooser, as well as to
allow the client application to either cancel the request or
perform an actual selection of files, the signal will pass an
instance of the 'GI.WebKit2.Objects.FileChooserRequest.FileChooserRequest' in the /@request@/
argument.

The default signal handler will asynchronously run a regular
'GI.Gtk.Objects.FileChooserDialog.FileChooserDialog' for the user to interact with.
-}
type WebViewRunFileChooserCallback =
    WebKit2.FileChooserRequest.FileChooserRequest
    {- ^ /@request@/: a 'GI.WebKit2.Objects.FileChooserRequest.FileChooserRequest' -}
    -> IO Bool
    {- ^ __Returns:__ 'True' to stop other handlers from being invoked for the event.
  'False' to propagate the event further. -}

-- | A convenience synonym for @`Nothing` :: `Maybe` `WebViewRunFileChooserCallback`@.
noWebViewRunFileChooserCallback :: Maybe WebViewRunFileChooserCallback
noWebViewRunFileChooserCallback = Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_WebViewRunFileChooser :: MonadIO m => WebViewRunFileChooserCallback -> m (GClosure C_WebViewRunFileChooserCallback)
genClosure_WebViewRunFileChooser cb = liftIO $ do
    let cb' = wrap_WebViewRunFileChooserCallback cb
    mk_WebViewRunFileChooserCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `WebViewRunFileChooserCallback` into a `C_WebViewRunFileChooserCallback`.
wrap_WebViewRunFileChooserCallback ::
    WebViewRunFileChooserCallback ->
    C_WebViewRunFileChooserCallback
wrap_WebViewRunFileChooserCallback _cb _ request _ = do
    request' <- (newObject WebKit2.FileChooserRequest.FileChooserRequest) request
    result <- _cb  request'
    let result' = (fromIntegral . fromEnum) result
    return result'


{- |
Connect a signal handler for the “@run-file-chooser@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' webView #runFileChooser callback
@
-}
onWebViewRunFileChooser :: (IsWebView a, MonadIO m) => a -> WebViewRunFileChooserCallback -> m SignalHandlerId
onWebViewRunFileChooser obj cb = liftIO $ do
    let cb' = wrap_WebViewRunFileChooserCallback cb
    cb'' <- mk_WebViewRunFileChooserCallback cb'
    connectSignalFunPtr obj "run-file-chooser" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@run-file-chooser@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' webView #runFileChooser callback
@
-}
afterWebViewRunFileChooser :: (IsWebView a, MonadIO m) => a -> WebViewRunFileChooserCallback -> m SignalHandlerId
afterWebViewRunFileChooser obj cb = liftIO $ do
    let cb' = wrap_WebViewRunFileChooserCallback cb
    cb'' <- mk_WebViewRunFileChooserCallback cb'
    connectSignalFunPtr obj "run-file-chooser" cb'' SignalConnectAfter


-- signal WebView::script-dialog
{- |
Emitted when JavaScript code calls \<function>window.alert\<\/function>,
\<function>window.confirm\<\/function> or \<function>window.prompt\<\/function>,
or when \<function>onbeforeunload\<\/function> event is fired.
The /@dialog@/ parameter should be used to build the dialog.
If the signal is not handled a different dialog will be built and shown depending
on the dialog type:
\<itemizedlist>
\<listitem>\<para>
 'GI.WebKit2.Enums.ScriptDialogTypeAlert': message dialog with a single Close button.
\<\/para>\<\/listitem>
\<listitem>\<para>
 'GI.WebKit2.Enums.ScriptDialogTypeConfirm': message dialog with OK and Cancel buttons.
\<\/para>\<\/listitem>
\<listitem>\<para>
 'GI.WebKit2.Enums.ScriptDialogTypePrompt': message dialog with OK and Cancel buttons and
 a text entry with the default text.
\<\/para>\<\/listitem>
\<listitem>\<para>
 'GI.WebKit2.Enums.ScriptDialogTypeBeforeUnloadConfirm': message dialog with Stay and Leave buttons.
\<\/para>\<\/listitem>
\<\/itemizedlist>

It is possible to handle the script dialog request asynchronously, by simply
caling 'GI.WebKit2.Structs.ScriptDialog.scriptDialogRef' on the /@dialog@/ argument and calling
'GI.WebKit2.Structs.ScriptDialog.scriptDialogClose' when done.
If the last reference is removed on a 'GI.WebKit2.Structs.ScriptDialog.ScriptDialog' and the dialog has not been
closed, 'GI.WebKit2.Structs.ScriptDialog.scriptDialogClose' will be called.
-}
type WebViewScriptDialogCallback =
    WebKit2.ScriptDialog.ScriptDialog
    {- ^ /@dialog@/: the 'GI.WebKit2.Structs.ScriptDialog.ScriptDialog' to show -}
    -> IO Bool
    {- ^ __Returns:__ 'True' to stop other handlers from being invoked for the event.
   'False' to propagate the event further. -}

-- | A convenience synonym for @`Nothing` :: `Maybe` `WebViewScriptDialogCallback`@.
noWebViewScriptDialogCallback :: Maybe WebViewScriptDialogCallback
noWebViewScriptDialogCallback = Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_WebViewScriptDialog :: MonadIO m => WebViewScriptDialogCallback -> m (GClosure C_WebViewScriptDialogCallback)
genClosure_WebViewScriptDialog cb = liftIO $ do
    let cb' = wrap_WebViewScriptDialogCallback cb
    mk_WebViewScriptDialogCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `WebViewScriptDialogCallback` into a `C_WebViewScriptDialogCallback`.
wrap_WebViewScriptDialogCallback ::
    WebViewScriptDialogCallback ->
    C_WebViewScriptDialogCallback
wrap_WebViewScriptDialogCallback _cb _ dialog _ = do
    B.ManagedPtr.withTransient WebKit2.ScriptDialog.ScriptDialog dialog $ \dialog' -> do
        result <- _cb  dialog'
        let result' = (fromIntegral . fromEnum) result
        return result'


{- |
Connect a signal handler for the “@script-dialog@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' webView #scriptDialog callback
@
-}
onWebViewScriptDialog :: (IsWebView a, MonadIO m) => a -> WebViewScriptDialogCallback -> m SignalHandlerId
onWebViewScriptDialog obj cb = liftIO $ do
    let cb' = wrap_WebViewScriptDialogCallback cb
    cb'' <- mk_WebViewScriptDialogCallback cb'
    connectSignalFunPtr obj "script-dialog" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@script-dialog@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' webView #scriptDialog callback
@
-}
afterWebViewScriptDialog :: (IsWebView a, MonadIO m) => a -> WebViewScriptDialogCallback -> m SignalHandlerId
afterWebViewScriptDialog obj cb = liftIO $ do
    let cb' = wrap_WebViewScriptDialogCallback cb
    cb'' <- mk_WebViewScriptDialogCallback cb'
    connectSignalFunPtr obj "script-dialog" cb'' SignalConnectAfter


-- signal WebView::show-notification
{- |
This signal is emitted when a notification should be presented to the
user. The /@notification@/ is kept alive until either: 1) the web page cancels it
or 2) a navigation happens.

The default handler will emit a notification using libnotify, if built with
support for it.

/Since: 2.8/
-}
type WebViewShowNotificationCallback =
    WebKit2.Notification.Notification
    {- ^ /@notification@/: a 'GI.WebKit2.Objects.Notification.Notification' -}
    -> IO Bool
    {- ^ __Returns:__ 'True' to stop other handlers from being invoked. 'False' otherwise. -}

-- | A convenience synonym for @`Nothing` :: `Maybe` `WebViewShowNotificationCallback`@.
noWebViewShowNotificationCallback :: Maybe WebViewShowNotificationCallback
noWebViewShowNotificationCallback = Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_WebViewShowNotification :: MonadIO m => WebViewShowNotificationCallback -> m (GClosure C_WebViewShowNotificationCallback)
genClosure_WebViewShowNotification cb = liftIO $ do
    let cb' = wrap_WebViewShowNotificationCallback cb
    mk_WebViewShowNotificationCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `WebViewShowNotificationCallback` into a `C_WebViewShowNotificationCallback`.
wrap_WebViewShowNotificationCallback ::
    WebViewShowNotificationCallback ->
    C_WebViewShowNotificationCallback
wrap_WebViewShowNotificationCallback _cb _ notification _ = do
    notification' <- (newObject WebKit2.Notification.Notification) notification
    result <- _cb  notification'
    let result' = (fromIntegral . fromEnum) result
    return result'


{- |
Connect a signal handler for the “@show-notification@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' webView #showNotification callback
@
-}
onWebViewShowNotification :: (IsWebView a, MonadIO m) => a -> WebViewShowNotificationCallback -> m SignalHandlerId
onWebViewShowNotification obj cb = liftIO $ do
    let cb' = wrap_WebViewShowNotificationCallback cb
    cb'' <- mk_WebViewShowNotificationCallback cb'
    connectSignalFunPtr obj "show-notification" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@show-notification@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' webView #showNotification callback
@
-}
afterWebViewShowNotification :: (IsWebView a, MonadIO m) => a -> WebViewShowNotificationCallback -> m SignalHandlerId
afterWebViewShowNotification obj cb = liftIO $ do
    let cb' = wrap_WebViewShowNotificationCallback cb
    cb'' <- mk_WebViewShowNotificationCallback cb'
    connectSignalFunPtr obj "show-notification" cb'' SignalConnectAfter


-- signal WebView::show-option-menu
{- |
This signal is emitted when a select element in /@webView@/ needs to display a
dropdown menu. This signal can be used to show a custom menu, using /@menu@/ to get
the details of all items that should be displayed. The area of the element in the
'GI.WebKit2.Objects.WebView.WebView' is given as /@rectangle@/ parameter, it can be used to position the
menu. If this was triggered by a user interaction, like a mouse click,
/@event@/ parameter provides the 'GI.Gdk.Unions.Event.Event'.
To handle this signal asynchronously you should keep a ref of the /@menu@/.

The default signal handler will pop up a 'GI.Gtk.Objects.Menu.Menu'.

/Since: 2.18/
-}
type WebViewShowOptionMenuCallback =
    WebKit2.OptionMenu.OptionMenu
    {- ^ /@menu@/: the 'GI.WebKit2.Objects.OptionMenu.OptionMenu' -}
    -> Gdk.Event.Event
    {- ^ /@event@/: the 'GI.Gdk.Unions.Event.Event' that triggered the menu, or 'Nothing' -}
    -> Gdk.Rectangle.Rectangle
    {- ^ /@rectangle@/: the option element area -}
    -> IO Bool
    {- ^ __Returns:__ 'True' to stop other handlers from being invoked for the event.
  'False' to propagate the event further. -}

-- | A convenience synonym for @`Nothing` :: `Maybe` `WebViewShowOptionMenuCallback`@.
noWebViewShowOptionMenuCallback :: Maybe WebViewShowOptionMenuCallback
noWebViewShowOptionMenuCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_WebViewShowOptionMenuCallback =
    Ptr () ->                               -- object
    Ptr WebKit2.OptionMenu.OptionMenu ->
    Ptr Gdk.Event.Event ->
    Ptr Gdk.Rectangle.Rectangle ->
    Ptr () ->                               -- user_data
    IO CInt

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

-- | Wrap the callback into a `GClosure`.
genClosure_WebViewShowOptionMenu :: MonadIO m => WebViewShowOptionMenuCallback -> m (GClosure C_WebViewShowOptionMenuCallback)
genClosure_WebViewShowOptionMenu cb = liftIO $ do
    let cb' = wrap_WebViewShowOptionMenuCallback cb
    mk_WebViewShowOptionMenuCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `WebViewShowOptionMenuCallback` into a `C_WebViewShowOptionMenuCallback`.
wrap_WebViewShowOptionMenuCallback ::
    WebViewShowOptionMenuCallback ->
    C_WebViewShowOptionMenuCallback
wrap_WebViewShowOptionMenuCallback _cb _ menu event rectangle _ = do
    menu' <- (newObject WebKit2.OptionMenu.OptionMenu) menu
    B.ManagedPtr.withTransient Gdk.Event.Event event $ \event' -> do
        B.ManagedPtr.withTransient Gdk.Rectangle.Rectangle rectangle $ \rectangle' -> do
            result <- _cb  menu' event' rectangle'
            let result' = (fromIntegral . fromEnum) result
            return result'


{- |
Connect a signal handler for the “@show-option-menu@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' webView #showOptionMenu callback
@
-}
onWebViewShowOptionMenu :: (IsWebView a, MonadIO m) => a -> WebViewShowOptionMenuCallback -> m SignalHandlerId
onWebViewShowOptionMenu obj cb = liftIO $ do
    let cb' = wrap_WebViewShowOptionMenuCallback cb
    cb'' <- mk_WebViewShowOptionMenuCallback cb'
    connectSignalFunPtr obj "show-option-menu" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@show-option-menu@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' webView #showOptionMenu callback
@
-}
afterWebViewShowOptionMenu :: (IsWebView a, MonadIO m) => a -> WebViewShowOptionMenuCallback -> m SignalHandlerId
afterWebViewShowOptionMenu obj cb = liftIO $ do
    let cb' = wrap_WebViewShowOptionMenuCallback cb
    cb'' <- mk_WebViewShowOptionMenuCallback cb'
    connectSignalFunPtr obj "show-option-menu" cb'' SignalConnectAfter


-- signal WebView::submit-form
{- |
This signal is emitted when a form is about to be submitted. The /@request@/
argument passed contains information about the text fields of the form. This
is typically used to store login information that can be used later to
pre-fill the form.
The form will not be submitted until 'GI.WebKit2.Objects.FormSubmissionRequest.formSubmissionRequestSubmit' is called.

It is possible to handle the form submission request asynchronously, by
simply calling 'GI.GObject.Objects.Object.objectRef' on the /@request@/ argument and calling
'GI.WebKit2.Objects.FormSubmissionRequest.formSubmissionRequestSubmit' when done to continue with the form submission.
If the last reference is removed on a 'GI.WebKit2.Objects.FormSubmissionRequest.FormSubmissionRequest' and the
form has not been submitted, 'GI.WebKit2.Objects.FormSubmissionRequest.formSubmissionRequestSubmit' will be called.
-}
type WebViewSubmitFormCallback =
    WebKit2.FormSubmissionRequest.FormSubmissionRequest
    {- ^ /@request@/: a 'GI.WebKit2.Objects.FormSubmissionRequest.FormSubmissionRequest' -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `WebViewSubmitFormCallback`@.
noWebViewSubmitFormCallback :: Maybe WebViewSubmitFormCallback
noWebViewSubmitFormCallback = Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_WebViewSubmitForm :: MonadIO m => WebViewSubmitFormCallback -> m (GClosure C_WebViewSubmitFormCallback)
genClosure_WebViewSubmitForm cb = liftIO $ do
    let cb' = wrap_WebViewSubmitFormCallback cb
    mk_WebViewSubmitFormCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `WebViewSubmitFormCallback` into a `C_WebViewSubmitFormCallback`.
wrap_WebViewSubmitFormCallback ::
    WebViewSubmitFormCallback ->
    C_WebViewSubmitFormCallback
wrap_WebViewSubmitFormCallback _cb _ request _ = do
    request' <- (newObject WebKit2.FormSubmissionRequest.FormSubmissionRequest) request
    _cb  request'


{- |
Connect a signal handler for the “@submit-form@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' webView #submitForm callback
@
-}
onWebViewSubmitForm :: (IsWebView a, MonadIO m) => a -> WebViewSubmitFormCallback -> m SignalHandlerId
onWebViewSubmitForm obj cb = liftIO $ do
    let cb' = wrap_WebViewSubmitFormCallback cb
    cb'' <- mk_WebViewSubmitFormCallback cb'
    connectSignalFunPtr obj "submit-form" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@submit-form@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' webView #submitForm callback
@
-}
afterWebViewSubmitForm :: (IsWebView a, MonadIO m) => a -> WebViewSubmitFormCallback -> m SignalHandlerId
afterWebViewSubmitForm obj cb = liftIO $ do
    let cb' = wrap_WebViewSubmitFormCallback cb
    cb'' <- mk_WebViewSubmitFormCallback cb'
    connectSignalFunPtr obj "submit-form" cb'' SignalConnectAfter


-- signal WebView::web-process-crashed
{-# DEPRECATED WebViewWebProcessCrashedCallback ["(Since version 2.20)","Use WebKitWebView::web-process-terminated instead."] #-}
{- |
This signal is emitted when the web process crashes.
-}
type WebViewWebProcessCrashedCallback =
    IO Bool
    {- ^ __Returns:__ 'True' to stop other handlers from being invoked for the event.
   'False' to propagate the event further. -}

-- | A convenience synonym for @`Nothing` :: `Maybe` `WebViewWebProcessCrashedCallback`@.
noWebViewWebProcessCrashedCallback :: Maybe WebViewWebProcessCrashedCallback
noWebViewWebProcessCrashedCallback = Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_WebViewWebProcessCrashed :: MonadIO m => WebViewWebProcessCrashedCallback -> m (GClosure C_WebViewWebProcessCrashedCallback)
genClosure_WebViewWebProcessCrashed cb = liftIO $ do
    let cb' = wrap_WebViewWebProcessCrashedCallback cb
    mk_WebViewWebProcessCrashedCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `WebViewWebProcessCrashedCallback` into a `C_WebViewWebProcessCrashedCallback`.
wrap_WebViewWebProcessCrashedCallback ::
    WebViewWebProcessCrashedCallback ->
    C_WebViewWebProcessCrashedCallback
wrap_WebViewWebProcessCrashedCallback _cb _ _ = do
    result <- _cb
    let result' = (fromIntegral . fromEnum) result
    return result'


{- |
Connect a signal handler for the “@web-process-crashed@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' webView #webProcessCrashed callback
@
-}
onWebViewWebProcessCrashed :: (IsWebView a, MonadIO m) => a -> WebViewWebProcessCrashedCallback -> m SignalHandlerId
onWebViewWebProcessCrashed obj cb = liftIO $ do
    let cb' = wrap_WebViewWebProcessCrashedCallback cb
    cb'' <- mk_WebViewWebProcessCrashedCallback cb'
    connectSignalFunPtr obj "web-process-crashed" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@web-process-crashed@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' webView #webProcessCrashed callback
@
-}
afterWebViewWebProcessCrashed :: (IsWebView a, MonadIO m) => a -> WebViewWebProcessCrashedCallback -> m SignalHandlerId
afterWebViewWebProcessCrashed obj cb = liftIO $ do
    let cb' = wrap_WebViewWebProcessCrashedCallback cb
    cb'' <- mk_WebViewWebProcessCrashedCallback cb'
    connectSignalFunPtr obj "web-process-crashed" cb'' SignalConnectAfter


-- signal WebView::web-process-terminated
{- |
This signal is emitted when the web process terminates abnormally due
to /@reason@/.

/Since: 2.20/
-}
type WebViewWebProcessTerminatedCallback =
    WebKit2.Enums.WebProcessTerminationReason
    {- ^ /@reason@/: the a 'GI.WebKit2.Enums.WebProcessTerminationReason' -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `WebViewWebProcessTerminatedCallback`@.
noWebViewWebProcessTerminatedCallback :: Maybe WebViewWebProcessTerminatedCallback
noWebViewWebProcessTerminatedCallback = Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_WebViewWebProcessTerminated :: MonadIO m => WebViewWebProcessTerminatedCallback -> m (GClosure C_WebViewWebProcessTerminatedCallback)
genClosure_WebViewWebProcessTerminated cb = liftIO $ do
    let cb' = wrap_WebViewWebProcessTerminatedCallback cb
    mk_WebViewWebProcessTerminatedCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `WebViewWebProcessTerminatedCallback` into a `C_WebViewWebProcessTerminatedCallback`.
wrap_WebViewWebProcessTerminatedCallback ::
    WebViewWebProcessTerminatedCallback ->
    C_WebViewWebProcessTerminatedCallback
wrap_WebViewWebProcessTerminatedCallback _cb _ reason _ = do
    let reason' = (toEnum . fromIntegral) reason
    _cb  reason'


{- |
Connect a signal handler for the “@web-process-terminated@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' webView #webProcessTerminated callback
@
-}
onWebViewWebProcessTerminated :: (IsWebView a, MonadIO m) => a -> WebViewWebProcessTerminatedCallback -> m SignalHandlerId
onWebViewWebProcessTerminated obj cb = liftIO $ do
    let cb' = wrap_WebViewWebProcessTerminatedCallback cb
    cb'' <- mk_WebViewWebProcessTerminatedCallback cb'
    connectSignalFunPtr obj "web-process-terminated" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@web-process-terminated@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' webView #webProcessTerminated callback
@
-}
afterWebViewWebProcessTerminated :: (IsWebView a, MonadIO m) => a -> WebViewWebProcessTerminatedCallback -> m SignalHandlerId
afterWebViewWebProcessTerminated obj cb = liftIO $ do
    let cb' = wrap_WebViewWebProcessTerminatedCallback cb
    cb'' <- mk_WebViewWebProcessTerminatedCallback cb'
    connectSignalFunPtr obj "web-process-terminated" cb'' SignalConnectAfter


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

{- |
Get the value of the “@editable@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' webView #editable
@
-}
getWebViewEditable :: (MonadIO m, IsWebView o) => o -> m Bool
getWebViewEditable obj = liftIO $ B.Properties.getObjectPropertyBool obj "editable"

{- |
Set the value of the “@editable@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' webView [ #editable 'Data.GI.Base.Attributes.:=' value ]
@
-}
setWebViewEditable :: (MonadIO m, IsWebView o) => o -> Bool -> m ()
setWebViewEditable obj val = liftIO $ B.Properties.setObjectPropertyBool obj "editable" val

{- |
Construct a `GValueConstruct` with valid value for the “@editable@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructWebViewEditable :: (IsWebView o) => Bool -> IO (GValueConstruct o)
constructWebViewEditable val = B.Properties.constructObjectPropertyBool "editable" val

#if ENABLE_OVERLOADING
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
#endif

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

{- |
Get the value of the “@estimated-load-progress@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' webView #estimatedLoadProgress
@
-}
getWebViewEstimatedLoadProgress :: (MonadIO m, IsWebView o) => o -> m Double
getWebViewEstimatedLoadProgress obj = liftIO $ B.Properties.getObjectPropertyDouble obj "estimated-load-progress"

#if ENABLE_OVERLOADING
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
#endif

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

{- |
Get the value of the “@favicon@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' webView #favicon
@
-}
getWebViewFavicon :: (MonadIO m, IsWebView o) => o -> m (Ptr ())
getWebViewFavicon obj = liftIO $ B.Properties.getObjectPropertyPtr obj "favicon"

#if ENABLE_OVERLOADING
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
#endif

-- VVV Prop "is-controlled-by-automation"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Nothing,Nothing)

{- |
Get the value of the “@is-controlled-by-automation@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' webView #isControlledByAutomation
@
-}
getWebViewIsControlledByAutomation :: (MonadIO m, IsWebView o) => o -> m Bool
getWebViewIsControlledByAutomation obj = liftIO $ B.Properties.getObjectPropertyBool obj "is-controlled-by-automation"

{- |
Construct a `GValueConstruct` with valid value for the “@is-controlled-by-automation@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructWebViewIsControlledByAutomation :: (IsWebView o) => Bool -> IO (GValueConstruct o)
constructWebViewIsControlledByAutomation val = B.Properties.constructObjectPropertyBool "is-controlled-by-automation" val

#if ENABLE_OVERLOADING
data WebViewIsControlledByAutomationPropertyInfo
instance AttrInfo WebViewIsControlledByAutomationPropertyInfo where
    type AttrAllowedOps WebViewIsControlledByAutomationPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint WebViewIsControlledByAutomationPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint WebViewIsControlledByAutomationPropertyInfo = IsWebView
    type AttrGetType WebViewIsControlledByAutomationPropertyInfo = Bool
    type AttrLabel WebViewIsControlledByAutomationPropertyInfo = "is-controlled-by-automation"
    type AttrOrigin WebViewIsControlledByAutomationPropertyInfo = WebView
    attrGet _ = getWebViewIsControlledByAutomation
    attrSet _ = undefined
    attrConstruct _ = constructWebViewIsControlledByAutomation
    attrClear _ = undefined
#endif

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

{- |
Get the value of the “@is-ephemeral@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' webView #isEphemeral
@
-}
getWebViewIsEphemeral :: (MonadIO m, IsWebView o) => o -> m Bool
getWebViewIsEphemeral obj = liftIO $ B.Properties.getObjectPropertyBool obj "is-ephemeral"

{- |
Construct a `GValueConstruct` with valid value for the “@is-ephemeral@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructWebViewIsEphemeral :: (IsWebView o) => Bool -> IO (GValueConstruct o)
constructWebViewIsEphemeral val = B.Properties.constructObjectPropertyBool "is-ephemeral" val

#if ENABLE_OVERLOADING
data WebViewIsEphemeralPropertyInfo
instance AttrInfo WebViewIsEphemeralPropertyInfo where
    type AttrAllowedOps WebViewIsEphemeralPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint WebViewIsEphemeralPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint WebViewIsEphemeralPropertyInfo = IsWebView
    type AttrGetType WebViewIsEphemeralPropertyInfo = Bool
    type AttrLabel WebViewIsEphemeralPropertyInfo = "is-ephemeral"
    type AttrOrigin WebViewIsEphemeralPropertyInfo = WebView
    attrGet _ = getWebViewIsEphemeral
    attrSet _ = undefined
    attrConstruct _ = constructWebViewIsEphemeral
    attrClear _ = undefined
#endif

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

{- |
Get the value of the “@is-loading@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' webView #isLoading
@
-}
getWebViewIsLoading :: (MonadIO m, IsWebView o) => o -> m Bool
getWebViewIsLoading obj = liftIO $ B.Properties.getObjectPropertyBool obj "is-loading"

#if ENABLE_OVERLOADING
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
#endif

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

{- |
Get the value of the “@is-playing-audio@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' webView #isPlayingAudio
@
-}
getWebViewIsPlayingAudio :: (MonadIO m, IsWebView o) => o -> m Bool
getWebViewIsPlayingAudio obj = liftIO $ B.Properties.getObjectPropertyBool obj "is-playing-audio"

#if ENABLE_OVERLOADING
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
#endif

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

{- |
Construct a `GValueConstruct` with valid value for the “@related-view@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructWebViewRelatedView :: (IsWebView o, IsWebView a) => a -> IO (GValueConstruct o)
constructWebViewRelatedView val = B.Properties.constructObjectPropertyObject "related-view" (Just val)

#if ENABLE_OVERLOADING
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
#endif

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

{- |
Set the value of the “@settings@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' webView [ #settings 'Data.GI.Base.Attributes.:=' value ]
@
-}
setWebViewSettings :: (MonadIO m, IsWebView o, WebKit2.Settings.IsSettings a) => o -> a -> m ()
setWebViewSettings obj val = liftIO $ B.Properties.setObjectPropertyObject obj "settings" (Just val)

{- |
Construct a `GValueConstruct` with valid value for the “@settings@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructWebViewSettings :: (IsWebView o, WebKit2.Settings.IsSettings a) => a -> IO (GValueConstruct o)
constructWebViewSettings val = B.Properties.constructObjectPropertyObject "settings" (Just val)

#if ENABLE_OVERLOADING
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
#endif

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

{- |
Get the value of the “@title@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' webView #title
@
-}
getWebViewTitle :: (MonadIO m, IsWebView o) => o -> m (Maybe T.Text)
getWebViewTitle obj = liftIO $ B.Properties.getObjectPropertyString obj "title"

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

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

{- |
Get the value of the “@uri@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' webView #uri
@
-}
getWebViewUri :: (MonadIO m, IsWebView o) => o -> m (Maybe T.Text)
getWebViewUri obj = liftIO $ B.Properties.getObjectPropertyString obj "uri"

#if ENABLE_OVERLOADING
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
#endif

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

{- |
Get the value of the “@user-content-manager@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' webView #userContentManager
@
-}
getWebViewUserContentManager :: (MonadIO m, IsWebView o) => o -> m WebKit2.UserContentManager.UserContentManager
getWebViewUserContentManager obj = liftIO $ checkUnexpectedNothing "getWebViewUserContentManager" $ B.Properties.getObjectPropertyObject obj "user-content-manager" WebKit2.UserContentManager.UserContentManager

{- |
Construct a `GValueConstruct` with valid value for the “@user-content-manager@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructWebViewUserContentManager :: (IsWebView o, WebKit2.UserContentManager.IsUserContentManager a) => a -> IO (GValueConstruct o)
constructWebViewUserContentManager val = B.Properties.constructObjectPropertyObject "user-content-manager" (Just val)

#if ENABLE_OVERLOADING
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
#endif

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

{- |
Get the value of the “@web-context@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' webView #webContext
@
-}
getWebViewWebContext :: (MonadIO m, IsWebView o) => o -> m (Maybe WebKit2.WebContext.WebContext)
getWebViewWebContext obj = liftIO $ B.Properties.getObjectPropertyObject obj "web-context" WebKit2.WebContext.WebContext

{- |
Construct a `GValueConstruct` with valid value for the “@web-context@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructWebViewWebContext :: (IsWebView o, WebKit2.WebContext.IsWebContext a) => a -> IO (GValueConstruct o)
constructWebViewWebContext val = B.Properties.constructObjectPropertyObject "web-context" (Just val)

#if ENABLE_OVERLOADING
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
#endif

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

{- |
Get the value of the “@zoom-level@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' webView #zoomLevel
@
-}
getWebViewZoomLevel :: (MonadIO m, IsWebView o) => o -> m Double
getWebViewZoomLevel obj = liftIO $ B.Properties.getObjectPropertyDouble obj "zoom-level"

{- |
Set the value of the “@zoom-level@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' webView [ #zoomLevel 'Data.GI.Base.Attributes.:=' value ]
@
-}
setWebViewZoomLevel :: (MonadIO m, IsWebView o) => o -> Double -> m ()
setWebViewZoomLevel obj val = liftIO $ B.Properties.setObjectPropertyDouble obj "zoom-level" val

{- |
Construct a `GValueConstruct` with valid value for the “@zoom-level@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructWebViewZoomLevel :: (IsWebView o) => Double -> IO (GValueConstruct o)
constructWebViewZoomLevel val = B.Properties.constructObjectPropertyDouble "zoom-level" val

#if ENABLE_OVERLOADING
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
#endif

#if ENABLE_OVERLOADING
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), '("isControlledByAutomation", WebViewIsControlledByAutomationPropertyInfo), '("isEphemeral", WebViewIsEphemeralPropertyInfo), '("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, *)])
#endif

#if ENABLE_OVERLOADING
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

#endif

#if ENABLE_OVERLOADING
data WebViewAuthenticateSignalInfo
instance SignalInfo WebViewAuthenticateSignalInfo where
    type HaskellCallbackType WebViewAuthenticateSignalInfo = WebViewAuthenticateCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_WebViewAuthenticateCallback cb
        cb'' <- mk_WebViewAuthenticateCallback cb'
        connectSignalFunPtr obj "authenticate" cb'' connectMode

data WebViewCloseSignalInfo
instance SignalInfo WebViewCloseSignalInfo where
    type HaskellCallbackType WebViewCloseSignalInfo = WebViewCloseCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_WebViewCloseCallback cb
        cb'' <- mk_WebViewCloseCallback cb'
        connectSignalFunPtr obj "close" cb'' connectMode

data WebViewContextMenuSignalInfo
instance SignalInfo WebViewContextMenuSignalInfo where
    type HaskellCallbackType WebViewContextMenuSignalInfo = WebViewContextMenuCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_WebViewContextMenuCallback cb
        cb'' <- mk_WebViewContextMenuCallback cb'
        connectSignalFunPtr obj "context-menu" cb'' connectMode

data WebViewContextMenuDismissedSignalInfo
instance SignalInfo WebViewContextMenuDismissedSignalInfo where
    type HaskellCallbackType WebViewContextMenuDismissedSignalInfo = WebViewContextMenuDismissedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_WebViewContextMenuDismissedCallback cb
        cb'' <- mk_WebViewContextMenuDismissedCallback cb'
        connectSignalFunPtr obj "context-menu-dismissed" cb'' connectMode

data WebViewCreateSignalInfo
instance SignalInfo WebViewCreateSignalInfo where
    type HaskellCallbackType WebViewCreateSignalInfo = WebViewCreateCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_WebViewCreateCallback cb
        cb'' <- mk_WebViewCreateCallback cb'
        connectSignalFunPtr obj "create" cb'' connectMode

data WebViewDecidePolicySignalInfo
instance SignalInfo WebViewDecidePolicySignalInfo where
    type HaskellCallbackType WebViewDecidePolicySignalInfo = WebViewDecidePolicyCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_WebViewDecidePolicyCallback cb
        cb'' <- mk_WebViewDecidePolicyCallback cb'
        connectSignalFunPtr obj "decide-policy" cb'' connectMode

data WebViewEnterFullscreenSignalInfo
instance SignalInfo WebViewEnterFullscreenSignalInfo where
    type HaskellCallbackType WebViewEnterFullscreenSignalInfo = WebViewEnterFullscreenCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_WebViewEnterFullscreenCallback cb
        cb'' <- mk_WebViewEnterFullscreenCallback cb'
        connectSignalFunPtr obj "enter-fullscreen" cb'' connectMode

data WebViewInsecureContentDetectedSignalInfo
instance SignalInfo WebViewInsecureContentDetectedSignalInfo where
    type HaskellCallbackType WebViewInsecureContentDetectedSignalInfo = WebViewInsecureContentDetectedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_WebViewInsecureContentDetectedCallback cb
        cb'' <- mk_WebViewInsecureContentDetectedCallback cb'
        connectSignalFunPtr obj "insecure-content-detected" cb'' connectMode

data WebViewLeaveFullscreenSignalInfo
instance SignalInfo WebViewLeaveFullscreenSignalInfo where
    type HaskellCallbackType WebViewLeaveFullscreenSignalInfo = WebViewLeaveFullscreenCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_WebViewLeaveFullscreenCallback cb
        cb'' <- mk_WebViewLeaveFullscreenCallback cb'
        connectSignalFunPtr obj "leave-fullscreen" cb'' connectMode

data WebViewLoadChangedSignalInfo
instance SignalInfo WebViewLoadChangedSignalInfo where
    type HaskellCallbackType WebViewLoadChangedSignalInfo = WebViewLoadChangedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_WebViewLoadChangedCallback cb
        cb'' <- mk_WebViewLoadChangedCallback cb'
        connectSignalFunPtr obj "load-changed" cb'' connectMode

data WebViewLoadFailedSignalInfo
instance SignalInfo WebViewLoadFailedSignalInfo where
    type HaskellCallbackType WebViewLoadFailedSignalInfo = WebViewLoadFailedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_WebViewLoadFailedCallback cb
        cb'' <- mk_WebViewLoadFailedCallback cb'
        connectSignalFunPtr obj "load-failed" cb'' connectMode

data WebViewLoadFailedWithTlsErrorsSignalInfo
instance SignalInfo WebViewLoadFailedWithTlsErrorsSignalInfo where
    type HaskellCallbackType WebViewLoadFailedWithTlsErrorsSignalInfo = WebViewLoadFailedWithTlsErrorsCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_WebViewLoadFailedWithTlsErrorsCallback cb
        cb'' <- mk_WebViewLoadFailedWithTlsErrorsCallback cb'
        connectSignalFunPtr obj "load-failed-with-tls-errors" cb'' connectMode

data WebViewMouseTargetChangedSignalInfo
instance SignalInfo WebViewMouseTargetChangedSignalInfo where
    type HaskellCallbackType WebViewMouseTargetChangedSignalInfo = WebViewMouseTargetChangedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_WebViewMouseTargetChangedCallback cb
        cb'' <- mk_WebViewMouseTargetChangedCallback cb'
        connectSignalFunPtr obj "mouse-target-changed" cb'' connectMode

data WebViewPermissionRequestSignalInfo
instance SignalInfo WebViewPermissionRequestSignalInfo where
    type HaskellCallbackType WebViewPermissionRequestSignalInfo = WebViewPermissionRequestCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_WebViewPermissionRequestCallback cb
        cb'' <- mk_WebViewPermissionRequestCallback cb'
        connectSignalFunPtr obj "permission-request" cb'' connectMode

data WebViewPrintSignalInfo
instance SignalInfo WebViewPrintSignalInfo where
    type HaskellCallbackType WebViewPrintSignalInfo = WebViewPrintCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_WebViewPrintCallback cb
        cb'' <- mk_WebViewPrintCallback cb'
        connectSignalFunPtr obj "print" cb'' connectMode

data WebViewReadyToShowSignalInfo
instance SignalInfo WebViewReadyToShowSignalInfo where
    type HaskellCallbackType WebViewReadyToShowSignalInfo = WebViewReadyToShowCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_WebViewReadyToShowCallback cb
        cb'' <- mk_WebViewReadyToShowCallback cb'
        connectSignalFunPtr obj "ready-to-show" cb'' connectMode

data WebViewResourceLoadStartedSignalInfo
instance SignalInfo WebViewResourceLoadStartedSignalInfo where
    type HaskellCallbackType WebViewResourceLoadStartedSignalInfo = WebViewResourceLoadStartedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_WebViewResourceLoadStartedCallback cb
        cb'' <- mk_WebViewResourceLoadStartedCallback cb'
        connectSignalFunPtr obj "resource-load-started" cb'' connectMode

data WebViewRunAsModalSignalInfo
instance SignalInfo WebViewRunAsModalSignalInfo where
    type HaskellCallbackType WebViewRunAsModalSignalInfo = WebViewRunAsModalCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_WebViewRunAsModalCallback cb
        cb'' <- mk_WebViewRunAsModalCallback cb'
        connectSignalFunPtr obj "run-as-modal" cb'' connectMode

data WebViewRunColorChooserSignalInfo
instance SignalInfo WebViewRunColorChooserSignalInfo where
    type HaskellCallbackType WebViewRunColorChooserSignalInfo = WebViewRunColorChooserCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_WebViewRunColorChooserCallback cb
        cb'' <- mk_WebViewRunColorChooserCallback cb'
        connectSignalFunPtr obj "run-color-chooser" cb'' connectMode

data WebViewRunFileChooserSignalInfo
instance SignalInfo WebViewRunFileChooserSignalInfo where
    type HaskellCallbackType WebViewRunFileChooserSignalInfo = WebViewRunFileChooserCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_WebViewRunFileChooserCallback cb
        cb'' <- mk_WebViewRunFileChooserCallback cb'
        connectSignalFunPtr obj "run-file-chooser" cb'' connectMode

data WebViewScriptDialogSignalInfo
instance SignalInfo WebViewScriptDialogSignalInfo where
    type HaskellCallbackType WebViewScriptDialogSignalInfo = WebViewScriptDialogCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_WebViewScriptDialogCallback cb
        cb'' <- mk_WebViewScriptDialogCallback cb'
        connectSignalFunPtr obj "script-dialog" cb'' connectMode

data WebViewShowNotificationSignalInfo
instance SignalInfo WebViewShowNotificationSignalInfo where
    type HaskellCallbackType WebViewShowNotificationSignalInfo = WebViewShowNotificationCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_WebViewShowNotificationCallback cb
        cb'' <- mk_WebViewShowNotificationCallback cb'
        connectSignalFunPtr obj "show-notification" cb'' connectMode

data WebViewShowOptionMenuSignalInfo
instance SignalInfo WebViewShowOptionMenuSignalInfo where
    type HaskellCallbackType WebViewShowOptionMenuSignalInfo = WebViewShowOptionMenuCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_WebViewShowOptionMenuCallback cb
        cb'' <- mk_WebViewShowOptionMenuCallback cb'
        connectSignalFunPtr obj "show-option-menu" cb'' connectMode

data WebViewSubmitFormSignalInfo
instance SignalInfo WebViewSubmitFormSignalInfo where
    type HaskellCallbackType WebViewSubmitFormSignalInfo = WebViewSubmitFormCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_WebViewSubmitFormCallback cb
        cb'' <- mk_WebViewSubmitFormCallback cb'
        connectSignalFunPtr obj "submit-form" cb'' connectMode

data WebViewWebProcessCrashedSignalInfo
instance SignalInfo WebViewWebProcessCrashedSignalInfo where
    type HaskellCallbackType WebViewWebProcessCrashedSignalInfo = WebViewWebProcessCrashedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_WebViewWebProcessCrashedCallback cb
        cb'' <- mk_WebViewWebProcessCrashedCallback cb'
        connectSignalFunPtr obj "web-process-crashed" cb'' connectMode

data WebViewWebProcessTerminatedSignalInfo
instance SignalInfo WebViewWebProcessTerminatedSignalInfo where
    type HaskellCallbackType WebViewWebProcessTerminatedSignalInfo = WebViewWebProcessTerminatedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_WebViewWebProcessTerminatedCallback cb
        cb'' <- mk_WebViewWebProcessTerminatedCallback cb'
        connectSignalFunPtr obj "web-process-terminated" cb'' connectMode

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), '("showOptionMenu", WebViewShowOptionMenuSignalInfo), '("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), '("webProcessTerminated", WebViewWebProcessTerminatedSignalInfo), '("windowStateEvent", Gtk.Widget.WidgetWindowStateEventSignalInfo)] :: [(Symbol, *)])

#endif

-- 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'

#if ENABLE_OVERLOADING
#endif

-- 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