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

module GI.WebKit.Objects.WebView
    ( 

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


 -- * Methods
-- ** webViewCanCopyClipboard
    webViewCanCopyClipboard                 ,


-- ** webViewCanCutClipboard
    webViewCanCutClipboard                  ,


-- ** webViewCanGoBack
    webViewCanGoBack                        ,


-- ** webViewCanGoBackOrForward
    webViewCanGoBackOrForward               ,


-- ** webViewCanGoForward
    webViewCanGoForward                     ,


-- ** webViewCanPasteClipboard
    webViewCanPasteClipboard                ,


-- ** webViewCanRedo
    webViewCanRedo                          ,


-- ** webViewCanShowMimeType
    webViewCanShowMimeType                  ,


-- ** webViewCanUndo
    webViewCanUndo                          ,


-- ** webViewCopyClipboard
    webViewCopyClipboard                    ,


-- ** webViewCutClipboard
    webViewCutClipboard                     ,


-- ** webViewDeleteSelection
    webViewDeleteSelection                  ,


-- ** webViewExecuteScript
    webViewExecuteScript                    ,


-- ** webViewGetBackForwardList
    webViewGetBackForwardList               ,


-- ** webViewGetCopyTargetList
    webViewGetCopyTargetList                ,


-- ** webViewGetCustomEncoding
    webViewGetCustomEncoding                ,


-- ** webViewGetDomDocument
    webViewGetDomDocument                   ,


-- ** webViewGetEditable
    webViewGetEditable                      ,


-- ** webViewGetEncoding
    webViewGetEncoding                      ,


-- ** webViewGetFocusedFrame
    webViewGetFocusedFrame                  ,


-- ** webViewGetFullContentZoom
    webViewGetFullContentZoom               ,


-- ** webViewGetHitTestResult
    webViewGetHitTestResult                 ,


-- ** webViewGetIconPixbuf
    webViewGetIconPixbuf                    ,


-- ** webViewGetIconUri
    webViewGetIconUri                       ,


-- ** webViewGetInspector
    webViewGetInspector                     ,


-- ** webViewGetLoadStatus
    webViewGetLoadStatus                    ,


-- ** webViewGetMainFrame
    webViewGetMainFrame                     ,


-- ** webViewGetPasteTargetList
    webViewGetPasteTargetList               ,


-- ** webViewGetProgress
    webViewGetProgress                      ,


-- ** webViewGetSettings
    webViewGetSettings                      ,


-- ** webViewGetSnapshot
    webViewGetSnapshot                      ,


-- ** webViewGetTitle
    webViewGetTitle                         ,


-- ** webViewGetTransparent
    webViewGetTransparent                   ,


-- ** webViewGetUri
    webViewGetUri                           ,


-- ** webViewGetViewMode
    webViewGetViewMode                      ,


-- ** webViewGetViewSourceMode
    webViewGetViewSourceMode                ,


-- ** webViewGetViewportAttributes
    webViewGetViewportAttributes            ,


-- ** webViewGetWindowFeatures
    webViewGetWindowFeatures                ,


-- ** webViewGetZoomLevel
    webViewGetZoomLevel                     ,


-- ** webViewGoBack
    webViewGoBack                           ,


-- ** webViewGoBackOrForward
    webViewGoBackOrForward                  ,


-- ** webViewGoForward
    webViewGoForward                        ,


-- ** webViewGoToBackForwardItem
    webViewGoToBackForwardItem              ,


-- ** webViewHasSelection
    webViewHasSelection                     ,


-- ** webViewLoadHtmlString
    webViewLoadHtmlString                   ,


-- ** webViewLoadRequest
    webViewLoadRequest                      ,


-- ** webViewLoadString
    webViewLoadString                       ,


-- ** webViewLoadUri
    webViewLoadUri                          ,


-- ** webViewMarkTextMatches
    webViewMarkTextMatches                  ,


-- ** webViewMoveCursor
    webViewMoveCursor                       ,


-- ** webViewNew
    webViewNew                              ,


-- ** webViewOpen
    webViewOpen                             ,


-- ** webViewPasteClipboard
    webViewPasteClipboard                   ,


-- ** webViewRedo
    webViewRedo                             ,


-- ** webViewReload
    webViewReload                           ,


-- ** webViewReloadBypassCache
    webViewReloadBypassCache                ,


-- ** webViewSearchText
    webViewSearchText                       ,


-- ** webViewSelectAll
    webViewSelectAll                        ,


-- ** webViewSetCustomEncoding
    webViewSetCustomEncoding                ,


-- ** webViewSetEditable
    webViewSetEditable                      ,


-- ** webViewSetFullContentZoom
    webViewSetFullContentZoom               ,


-- ** webViewSetHighlightTextMatches
    webViewSetHighlightTextMatches          ,


-- ** webViewSetMaintainsBackForwardList
    webViewSetMaintainsBackForwardList      ,


-- ** webViewSetSettings
    webViewSetSettings                      ,


-- ** webViewSetTransparent
    webViewSetTransparent                   ,


-- ** webViewSetViewMode
    webViewSetViewMode                      ,


-- ** webViewSetViewSourceMode
    webViewSetViewSourceMode                ,


-- ** webViewSetZoomLevel
    webViewSetZoomLevel                     ,


-- ** webViewStopLoading
    webViewStopLoading                      ,


-- ** webViewTryGetFaviconPixbuf
    webViewTryGetFaviconPixbuf              ,


-- ** webViewUndo
    webViewUndo                             ,


-- ** webViewUnmarkTextMatches
    webViewUnmarkTextMatches                ,


-- ** webViewZoomIn
    webViewZoomIn                           ,


-- ** webViewZoomOut
    webViewZoomOut                          ,




 -- * Properties
-- ** CopyTargetList
    WebViewCopyTargetListPropertyInfo       ,
    getWebViewCopyTargetList                ,


-- ** CustomEncoding
    WebViewCustomEncodingPropertyInfo       ,
    constructWebViewCustomEncoding          ,
    getWebViewCustomEncoding                ,
    setWebViewCustomEncoding                ,


-- ** Editable
    WebViewEditablePropertyInfo             ,
    constructWebViewEditable                ,
    getWebViewEditable                      ,
    setWebViewEditable                      ,


-- ** Encoding
    WebViewEncodingPropertyInfo             ,
    getWebViewEncoding                      ,


-- ** FullContentZoom
    WebViewFullContentZoomPropertyInfo      ,
    constructWebViewFullContentZoom         ,
    getWebViewFullContentZoom               ,
    setWebViewFullContentZoom               ,


-- ** IconUri
    WebViewIconUriPropertyInfo              ,
    getWebViewIconUri                       ,


-- ** ImContext
    WebViewImContextPropertyInfo            ,
    getWebViewImContext                     ,


-- ** LoadStatus
    WebViewLoadStatusPropertyInfo           ,
    getWebViewLoadStatus                    ,


-- ** PasteTargetList
    WebViewPasteTargetListPropertyInfo      ,
    getWebViewPasteTargetList               ,


-- ** Progress
    WebViewProgressPropertyInfo             ,
    getWebViewProgress                      ,


-- ** SelfScrolling
    WebViewSelfScrollingPropertyInfo        ,
    constructWebViewSelfScrolling           ,
    getWebViewSelfScrolling                 ,


-- ** Settings
    WebViewSettingsPropertyInfo             ,
    constructWebViewSettings                ,
    getWebViewSettings                      ,
    setWebViewSettings                      ,


-- ** Title
    WebViewTitlePropertyInfo                ,
    getWebViewTitle                         ,


-- ** Transparent
    WebViewTransparentPropertyInfo          ,
    constructWebViewTransparent             ,
    getWebViewTransparent                   ,
    setWebViewTransparent                   ,


-- ** Uri
    WebViewUriPropertyInfo                  ,
    getWebViewUri                           ,


-- ** ViewMode
    WebViewViewModePropertyInfo             ,
    constructWebViewViewMode                ,
    getWebViewViewMode                      ,
    setWebViewViewMode                      ,


-- ** ViewportAttributes
    WebViewViewportAttributesPropertyInfo   ,
    getWebViewViewportAttributes            ,


-- ** WebInspector
    WebViewWebInspectorPropertyInfo         ,
    getWebViewWebInspector                  ,


-- ** WindowFeatures
    WebViewWindowFeaturesPropertyInfo       ,
    constructWebViewWindowFeatures          ,
    getWebViewWindowFeatures                ,
    setWebViewWindowFeatures                ,


-- ** ZoomLevel
    WebViewZoomLevelPropertyInfo            ,
    constructWebViewZoomLevel               ,
    getWebViewZoomLevel                     ,
    setWebViewZoomLevel                     ,




 -- * Signals
-- ** CloseWebView
    WebViewCloseWebViewCallback             ,
    WebViewCloseWebViewCallbackC            ,
    WebViewCloseWebViewSignalInfo           ,
    afterWebViewCloseWebView                ,
    mkWebViewCloseWebViewCallback           ,
    noWebViewCloseWebViewCallback           ,
    onWebViewCloseWebView                   ,
    webViewCloseWebViewCallbackWrapper      ,
    webViewCloseWebViewClosure              ,


-- ** ConsoleMessage
    WebViewConsoleMessageCallback           ,
    WebViewConsoleMessageCallbackC          ,
    WebViewConsoleMessageSignalInfo         ,
    afterWebViewConsoleMessage              ,
    mkWebViewConsoleMessageCallback         ,
    noWebViewConsoleMessageCallback         ,
    onWebViewConsoleMessage                 ,
    webViewConsoleMessageCallbackWrapper    ,
    webViewConsoleMessageClosure            ,


-- ** ContextMenu
    WebViewContextMenuCallback              ,
    WebViewContextMenuCallbackC             ,
    WebViewContextMenuSignalInfo            ,
    afterWebViewContextMenu                 ,
    mkWebViewContextMenuCallback            ,
    noWebViewContextMenuCallback            ,
    onWebViewContextMenu                    ,
    webViewContextMenuCallbackWrapper       ,
    webViewContextMenuClosure               ,


-- ** CopyClipboard
    WebViewCopyClipboardCallback            ,
    WebViewCopyClipboardCallbackC           ,
    WebViewCopyClipboardSignalInfo          ,
    afterWebViewCopyClipboard               ,
    mkWebViewCopyClipboardCallback          ,
    noWebViewCopyClipboardCallback          ,
    onWebViewCopyClipboard                  ,
    webViewCopyClipboardCallbackWrapper     ,
    webViewCopyClipboardClosure             ,


-- ** CreatePluginWidget
    WebViewCreatePluginWidgetCallback       ,
    WebViewCreatePluginWidgetCallbackC      ,
    WebViewCreatePluginWidgetSignalInfo     ,
    afterWebViewCreatePluginWidget          ,
    mkWebViewCreatePluginWidgetCallback     ,
    noWebViewCreatePluginWidgetCallback     ,
    onWebViewCreatePluginWidget             ,
    webViewCreatePluginWidgetCallbackWrapper,
    webViewCreatePluginWidgetClosure        ,


-- ** CreateWebView
    WebViewCreateWebViewCallback            ,
    WebViewCreateWebViewCallbackC           ,
    WebViewCreateWebViewSignalInfo          ,
    afterWebViewCreateWebView               ,
    mkWebViewCreateWebViewCallback          ,
    noWebViewCreateWebViewCallback          ,
    onWebViewCreateWebView                  ,
    webViewCreateWebViewCallbackWrapper     ,
    webViewCreateWebViewClosure             ,


-- ** CutClipboard
    WebViewCutClipboardCallback             ,
    WebViewCutClipboardCallbackC            ,
    WebViewCutClipboardSignalInfo           ,
    afterWebViewCutClipboard                ,
    mkWebViewCutClipboardCallback           ,
    noWebViewCutClipboardCallback           ,
    onWebViewCutClipboard                   ,
    webViewCutClipboardCallbackWrapper      ,
    webViewCutClipboardClosure              ,


-- ** DatabaseQuotaExceeded
    WebViewDatabaseQuotaExceededCallback    ,
    WebViewDatabaseQuotaExceededCallbackC   ,
    WebViewDatabaseQuotaExceededSignalInfo  ,
    afterWebViewDatabaseQuotaExceeded       ,
    mkWebViewDatabaseQuotaExceededCallback  ,
    noWebViewDatabaseQuotaExceededCallback  ,
    onWebViewDatabaseQuotaExceeded          ,
    webViewDatabaseQuotaExceededCallbackWrapper,
    webViewDatabaseQuotaExceededClosure     ,


-- ** DocumentLoadFinished
    WebViewDocumentLoadFinishedCallback     ,
    WebViewDocumentLoadFinishedCallbackC    ,
    WebViewDocumentLoadFinishedSignalInfo   ,
    afterWebViewDocumentLoadFinished        ,
    mkWebViewDocumentLoadFinishedCallback   ,
    noWebViewDocumentLoadFinishedCallback   ,
    onWebViewDocumentLoadFinished           ,
    webViewDocumentLoadFinishedCallbackWrapper,
    webViewDocumentLoadFinishedClosure      ,


-- ** DownloadRequested
    WebViewDownloadRequestedCallback        ,
    WebViewDownloadRequestedCallbackC       ,
    WebViewDownloadRequestedSignalInfo      ,
    afterWebViewDownloadRequested           ,
    mkWebViewDownloadRequestedCallback      ,
    noWebViewDownloadRequestedCallback      ,
    onWebViewDownloadRequested              ,
    webViewDownloadRequestedCallbackWrapper ,
    webViewDownloadRequestedClosure         ,


-- ** EditingBegan
    WebViewEditingBeganCallback             ,
    WebViewEditingBeganCallbackC            ,
    WebViewEditingBeganSignalInfo           ,
    afterWebViewEditingBegan                ,
    mkWebViewEditingBeganCallback           ,
    noWebViewEditingBeganCallback           ,
    onWebViewEditingBegan                   ,
    webViewEditingBeganCallbackWrapper      ,
    webViewEditingBeganClosure              ,


-- ** EditingEnded
    WebViewEditingEndedCallback             ,
    WebViewEditingEndedCallbackC            ,
    WebViewEditingEndedSignalInfo           ,
    afterWebViewEditingEnded                ,
    mkWebViewEditingEndedCallback           ,
    noWebViewEditingEndedCallback           ,
    onWebViewEditingEnded                   ,
    webViewEditingEndedCallbackWrapper      ,
    webViewEditingEndedClosure              ,


-- ** EnteringFullscreen
    WebViewEnteringFullscreenCallback       ,
    WebViewEnteringFullscreenCallbackC      ,
    WebViewEnteringFullscreenSignalInfo     ,
    afterWebViewEnteringFullscreen          ,
    mkWebViewEnteringFullscreenCallback     ,
    noWebViewEnteringFullscreenCallback     ,
    onWebViewEnteringFullscreen             ,
    webViewEnteringFullscreenCallbackWrapper,
    webViewEnteringFullscreenClosure        ,


-- ** FrameCreated
    WebViewFrameCreatedCallback             ,
    WebViewFrameCreatedCallbackC            ,
    WebViewFrameCreatedSignalInfo           ,
    afterWebViewFrameCreated                ,
    mkWebViewFrameCreatedCallback           ,
    noWebViewFrameCreatedCallback           ,
    onWebViewFrameCreated                   ,
    webViewFrameCreatedCallbackWrapper      ,
    webViewFrameCreatedClosure              ,


-- ** GeolocationPolicyDecisionCancelled
    WebViewGeolocationPolicyDecisionCancelledCallback,
    WebViewGeolocationPolicyDecisionCancelledCallbackC,
    WebViewGeolocationPolicyDecisionCancelledSignalInfo,
    afterWebViewGeolocationPolicyDecisionCancelled,
    mkWebViewGeolocationPolicyDecisionCancelledCallback,
    noWebViewGeolocationPolicyDecisionCancelledCallback,
    onWebViewGeolocationPolicyDecisionCancelled,
    webViewGeolocationPolicyDecisionCancelledCallbackWrapper,
    webViewGeolocationPolicyDecisionCancelledClosure,


-- ** GeolocationPolicyDecisionRequested
    WebViewGeolocationPolicyDecisionRequestedCallback,
    WebViewGeolocationPolicyDecisionRequestedCallbackC,
    WebViewGeolocationPolicyDecisionRequestedSignalInfo,
    afterWebViewGeolocationPolicyDecisionRequested,
    mkWebViewGeolocationPolicyDecisionRequestedCallback,
    noWebViewGeolocationPolicyDecisionRequestedCallback,
    onWebViewGeolocationPolicyDecisionRequested,
    webViewGeolocationPolicyDecisionRequestedCallbackWrapper,
    webViewGeolocationPolicyDecisionRequestedClosure,


-- ** HoveringOverLink
    WebViewHoveringOverLinkCallback         ,
    WebViewHoveringOverLinkCallbackC        ,
    WebViewHoveringOverLinkSignalInfo       ,
    afterWebViewHoveringOverLink            ,
    mkWebViewHoveringOverLinkCallback       ,
    noWebViewHoveringOverLinkCallback       ,
    onWebViewHoveringOverLink               ,
    webViewHoveringOverLinkCallbackWrapper  ,
    webViewHoveringOverLinkClosure          ,


-- ** IconLoaded
    WebViewIconLoadedCallback               ,
    WebViewIconLoadedCallbackC              ,
    WebViewIconLoadedSignalInfo             ,
    afterWebViewIconLoaded                  ,
    mkWebViewIconLoadedCallback             ,
    noWebViewIconLoadedCallback             ,
    onWebViewIconLoaded                     ,
    webViewIconLoadedCallbackWrapper        ,
    webViewIconLoadedClosure                ,


-- ** LeavingFullscreen
    WebViewLeavingFullscreenCallback        ,
    WebViewLeavingFullscreenCallbackC       ,
    WebViewLeavingFullscreenSignalInfo      ,
    afterWebViewLeavingFullscreen           ,
    mkWebViewLeavingFullscreenCallback      ,
    noWebViewLeavingFullscreenCallback      ,
    onWebViewLeavingFullscreen              ,
    webViewLeavingFullscreenCallbackWrapper ,
    webViewLeavingFullscreenClosure         ,


-- ** LoadCommitted
    WebViewLoadCommittedCallback            ,
    WebViewLoadCommittedCallbackC           ,
    WebViewLoadCommittedSignalInfo          ,
    afterWebViewLoadCommitted               ,
    mkWebViewLoadCommittedCallback          ,
    noWebViewLoadCommittedCallback          ,
    onWebViewLoadCommitted                  ,
    webViewLoadCommittedCallbackWrapper     ,
    webViewLoadCommittedClosure             ,


-- ** LoadError
    WebViewLoadErrorCallback                ,
    WebViewLoadErrorCallbackC               ,
    WebViewLoadErrorSignalInfo              ,
    afterWebViewLoadError                   ,
    mkWebViewLoadErrorCallback              ,
    noWebViewLoadErrorCallback              ,
    onWebViewLoadError                      ,
    webViewLoadErrorCallbackWrapper         ,
    webViewLoadErrorClosure                 ,


-- ** LoadFinished
    WebViewLoadFinishedCallback             ,
    WebViewLoadFinishedCallbackC            ,
    WebViewLoadFinishedSignalInfo           ,
    afterWebViewLoadFinished                ,
    mkWebViewLoadFinishedCallback           ,
    noWebViewLoadFinishedCallback           ,
    onWebViewLoadFinished                   ,
    webViewLoadFinishedCallbackWrapper      ,
    webViewLoadFinishedClosure              ,


-- ** LoadProgressChanged
    WebViewLoadProgressChangedCallback      ,
    WebViewLoadProgressChangedCallbackC     ,
    WebViewLoadProgressChangedSignalInfo    ,
    afterWebViewLoadProgressChanged         ,
    mkWebViewLoadProgressChangedCallback    ,
    noWebViewLoadProgressChangedCallback    ,
    onWebViewLoadProgressChanged            ,
    webViewLoadProgressChangedCallbackWrapper,
    webViewLoadProgressChangedClosure       ,


-- ** LoadStarted
    WebViewLoadStartedCallback              ,
    WebViewLoadStartedCallbackC             ,
    WebViewLoadStartedSignalInfo            ,
    afterWebViewLoadStarted                 ,
    mkWebViewLoadStartedCallback            ,
    noWebViewLoadStartedCallback            ,
    onWebViewLoadStarted                    ,
    webViewLoadStartedCallbackWrapper       ,
    webViewLoadStartedClosure               ,


-- ** MimeTypePolicyDecisionRequested
    WebViewMimeTypePolicyDecisionRequestedCallback,
    WebViewMimeTypePolicyDecisionRequestedCallbackC,
    WebViewMimeTypePolicyDecisionRequestedSignalInfo,
    afterWebViewMimeTypePolicyDecisionRequested,
    mkWebViewMimeTypePolicyDecisionRequestedCallback,
    noWebViewMimeTypePolicyDecisionRequestedCallback,
    onWebViewMimeTypePolicyDecisionRequested,
    webViewMimeTypePolicyDecisionRequestedCallbackWrapper,
    webViewMimeTypePolicyDecisionRequestedClosure,


-- ** MoveCursor
    WebViewMoveCursorCallback               ,
    WebViewMoveCursorCallbackC              ,
    WebViewMoveCursorSignalInfo             ,
    afterWebViewMoveCursor                  ,
    mkWebViewMoveCursorCallback             ,
    noWebViewMoveCursorCallback             ,
    onWebViewMoveCursor                     ,
    webViewMoveCursorCallbackWrapper        ,
    webViewMoveCursorClosure                ,


-- ** NavigationPolicyDecisionRequested
    WebViewNavigationPolicyDecisionRequestedCallback,
    WebViewNavigationPolicyDecisionRequestedCallbackC,
    WebViewNavigationPolicyDecisionRequestedSignalInfo,
    afterWebViewNavigationPolicyDecisionRequested,
    mkWebViewNavigationPolicyDecisionRequestedCallback,
    noWebViewNavigationPolicyDecisionRequestedCallback,
    onWebViewNavigationPolicyDecisionRequested,
    webViewNavigationPolicyDecisionRequestedCallbackWrapper,
    webViewNavigationPolicyDecisionRequestedClosure,


-- ** NavigationRequested
    WebViewNavigationRequestedCallback      ,
    WebViewNavigationRequestedCallbackC     ,
    WebViewNavigationRequestedSignalInfo    ,
    afterWebViewNavigationRequested         ,
    mkWebViewNavigationRequestedCallback    ,
    noWebViewNavigationRequestedCallback    ,
    onWebViewNavigationRequested            ,
    webViewNavigationRequestedCallbackWrapper,
    webViewNavigationRequestedClosure       ,


-- ** NewWindowPolicyDecisionRequested
    WebViewNewWindowPolicyDecisionRequestedCallback,
    WebViewNewWindowPolicyDecisionRequestedCallbackC,
    WebViewNewWindowPolicyDecisionRequestedSignalInfo,
    afterWebViewNewWindowPolicyDecisionRequested,
    mkWebViewNewWindowPolicyDecisionRequestedCallback,
    noWebViewNewWindowPolicyDecisionRequestedCallback,
    onWebViewNewWindowPolicyDecisionRequested,
    webViewNewWindowPolicyDecisionRequestedCallbackWrapper,
    webViewNewWindowPolicyDecisionRequestedClosure,


-- ** OnloadEvent
    WebViewOnloadEventCallback              ,
    WebViewOnloadEventCallbackC             ,
    WebViewOnloadEventSignalInfo            ,
    afterWebViewOnloadEvent                 ,
    mkWebViewOnloadEventCallback            ,
    noWebViewOnloadEventCallback            ,
    onWebViewOnloadEvent                    ,
    webViewOnloadEventCallbackWrapper       ,
    webViewOnloadEventClosure               ,


-- ** PasteClipboard
    WebViewPasteClipboardCallback           ,
    WebViewPasteClipboardCallbackC          ,
    WebViewPasteClipboardSignalInfo         ,
    afterWebViewPasteClipboard              ,
    mkWebViewPasteClipboardCallback         ,
    noWebViewPasteClipboardCallback         ,
    onWebViewPasteClipboard                 ,
    webViewPasteClipboardCallbackWrapper    ,
    webViewPasteClipboardClosure            ,


-- ** PopulatePopup
    WebViewPopulatePopupCallback            ,
    WebViewPopulatePopupCallbackC           ,
    WebViewPopulatePopupSignalInfo          ,
    afterWebViewPopulatePopup               ,
    mkWebViewPopulatePopupCallback          ,
    noWebViewPopulatePopupCallback          ,
    onWebViewPopulatePopup                  ,
    webViewPopulatePopupCallbackWrapper     ,
    webViewPopulatePopupClosure             ,


-- ** PrintRequested
    WebViewPrintRequestedCallback           ,
    WebViewPrintRequestedCallbackC          ,
    WebViewPrintRequestedSignalInfo         ,
    afterWebViewPrintRequested              ,
    mkWebViewPrintRequestedCallback         ,
    noWebViewPrintRequestedCallback         ,
    onWebViewPrintRequested                 ,
    webViewPrintRequestedCallbackWrapper    ,
    webViewPrintRequestedClosure            ,


-- ** Redo
    WebViewRedoCallback                     ,
    WebViewRedoCallbackC                    ,
    WebViewRedoSignalInfo                   ,
    afterWebViewRedo                        ,
    mkWebViewRedoCallback                   ,
    noWebViewRedoCallback                   ,
    onWebViewRedo                           ,
    webViewRedoCallbackWrapper              ,
    webViewRedoClosure                      ,


-- ** ResourceContentLengthReceived
    WebViewResourceContentLengthReceivedCallback,
    WebViewResourceContentLengthReceivedCallbackC,
    WebViewResourceContentLengthReceivedSignalInfo,
    afterWebViewResourceContentLengthReceived,
    mkWebViewResourceContentLengthReceivedCallback,
    noWebViewResourceContentLengthReceivedCallback,
    onWebViewResourceContentLengthReceived  ,
    webViewResourceContentLengthReceivedCallbackWrapper,
    webViewResourceContentLengthReceivedClosure,


-- ** ResourceLoadFailed
    WebViewResourceLoadFailedCallback       ,
    WebViewResourceLoadFailedCallbackC      ,
    WebViewResourceLoadFailedSignalInfo     ,
    afterWebViewResourceLoadFailed          ,
    mkWebViewResourceLoadFailedCallback     ,
    noWebViewResourceLoadFailedCallback     ,
    onWebViewResourceLoadFailed             ,
    webViewResourceLoadFailedCallbackWrapper,
    webViewResourceLoadFailedClosure        ,


-- ** ResourceLoadFinished
    WebViewResourceLoadFinishedCallback     ,
    WebViewResourceLoadFinishedCallbackC    ,
    WebViewResourceLoadFinishedSignalInfo   ,
    afterWebViewResourceLoadFinished        ,
    mkWebViewResourceLoadFinishedCallback   ,
    noWebViewResourceLoadFinishedCallback   ,
    onWebViewResourceLoadFinished           ,
    webViewResourceLoadFinishedCallbackWrapper,
    webViewResourceLoadFinishedClosure      ,


-- ** ResourceRequestStarting
    WebViewResourceRequestStartingCallback  ,
    WebViewResourceRequestStartingCallbackC ,
    WebViewResourceRequestStartingSignalInfo,
    afterWebViewResourceRequestStarting     ,
    mkWebViewResourceRequestStartingCallback,
    noWebViewResourceRequestStartingCallback,
    onWebViewResourceRequestStarting        ,
    webViewResourceRequestStartingCallbackWrapper,
    webViewResourceRequestStartingClosure   ,


-- ** ResourceResponseReceived
    WebViewResourceResponseReceivedCallback ,
    WebViewResourceResponseReceivedCallbackC,
    WebViewResourceResponseReceivedSignalInfo,
    afterWebViewResourceResponseReceived    ,
    mkWebViewResourceResponseReceivedCallback,
    noWebViewResourceResponseReceivedCallback,
    onWebViewResourceResponseReceived       ,
    webViewResourceResponseReceivedCallbackWrapper,
    webViewResourceResponseReceivedClosure  ,


-- ** RunFileChooser
    WebViewRunFileChooserCallback           ,
    WebViewRunFileChooserCallbackC          ,
    WebViewRunFileChooserSignalInfo         ,
    afterWebViewRunFileChooser              ,
    mkWebViewRunFileChooserCallback         ,
    noWebViewRunFileChooserCallback         ,
    onWebViewRunFileChooser                 ,
    webViewRunFileChooserCallbackWrapper    ,
    webViewRunFileChooserClosure            ,


-- ** ScriptAlert
    WebViewScriptAlertCallback              ,
    WebViewScriptAlertCallbackC             ,
    WebViewScriptAlertSignalInfo            ,
    afterWebViewScriptAlert                 ,
    mkWebViewScriptAlertCallback            ,
    noWebViewScriptAlertCallback            ,
    onWebViewScriptAlert                    ,
    webViewScriptAlertCallbackWrapper       ,
    webViewScriptAlertClosure               ,


-- ** ScriptConfirm
    WebViewScriptConfirmCallback            ,
    WebViewScriptConfirmCallbackC           ,
    WebViewScriptConfirmSignalInfo          ,
    afterWebViewScriptConfirm               ,
    mkWebViewScriptConfirmCallback          ,
    noWebViewScriptConfirmCallback          ,
    onWebViewScriptConfirm                  ,
    webViewScriptConfirmCallbackWrapper     ,
    webViewScriptConfirmClosure             ,


-- ** ScriptPrompt
    WebViewScriptPromptCallback             ,
    WebViewScriptPromptCallbackC            ,
    WebViewScriptPromptSignalInfo           ,
    afterWebViewScriptPrompt                ,
    mkWebViewScriptPromptCallback           ,
    noWebViewScriptPromptCallback           ,
    onWebViewScriptPrompt                   ,
    webViewScriptPromptCallbackWrapper      ,
    webViewScriptPromptClosure              ,


-- ** SelectAll
    WebViewSelectAllCallback                ,
    WebViewSelectAllCallbackC               ,
    WebViewSelectAllSignalInfo              ,
    afterWebViewSelectAll                   ,
    mkWebViewSelectAllCallback              ,
    noWebViewSelectAllCallback              ,
    onWebViewSelectAll                      ,
    webViewSelectAllCallbackWrapper         ,
    webViewSelectAllClosure                 ,


-- ** SelectionChanged
    WebViewSelectionChangedCallback         ,
    WebViewSelectionChangedCallbackC        ,
    WebViewSelectionChangedSignalInfo       ,
    afterWebViewSelectionChanged            ,
    mkWebViewSelectionChangedCallback       ,
    noWebViewSelectionChangedCallback       ,
    onWebViewSelectionChanged               ,
    webViewSelectionChangedCallbackWrapper  ,
    webViewSelectionChangedClosure          ,


-- ** ShouldApplyStyle
    WebViewShouldApplyStyleCallback         ,
    WebViewShouldApplyStyleCallbackC        ,
    WebViewShouldApplyStyleSignalInfo       ,
    afterWebViewShouldApplyStyle            ,
    mkWebViewShouldApplyStyleCallback       ,
    noWebViewShouldApplyStyleCallback       ,
    onWebViewShouldApplyStyle               ,
    webViewShouldApplyStyleCallbackWrapper  ,
    webViewShouldApplyStyleClosure          ,


-- ** ShouldBeginEditing
    WebViewShouldBeginEditingCallback       ,
    WebViewShouldBeginEditingCallbackC      ,
    WebViewShouldBeginEditingSignalInfo     ,
    afterWebViewShouldBeginEditing          ,
    mkWebViewShouldBeginEditingCallback     ,
    noWebViewShouldBeginEditingCallback     ,
    onWebViewShouldBeginEditing             ,
    webViewShouldBeginEditingCallbackWrapper,
    webViewShouldBeginEditingClosure        ,


-- ** ShouldChangeSelectedRange
    WebViewShouldChangeSelectedRangeCallback,
    WebViewShouldChangeSelectedRangeCallbackC,
    WebViewShouldChangeSelectedRangeSignalInfo,
    afterWebViewShouldChangeSelectedRange   ,
    mkWebViewShouldChangeSelectedRangeCallback,
    noWebViewShouldChangeSelectedRangeCallback,
    onWebViewShouldChangeSelectedRange      ,
    webViewShouldChangeSelectedRangeCallbackWrapper,
    webViewShouldChangeSelectedRangeClosure ,


-- ** ShouldDeleteRange
    WebViewShouldDeleteRangeCallback        ,
    WebViewShouldDeleteRangeCallbackC       ,
    WebViewShouldDeleteRangeSignalInfo      ,
    afterWebViewShouldDeleteRange           ,
    mkWebViewShouldDeleteRangeCallback      ,
    noWebViewShouldDeleteRangeCallback      ,
    onWebViewShouldDeleteRange              ,
    webViewShouldDeleteRangeCallbackWrapper ,
    webViewShouldDeleteRangeClosure         ,


-- ** ShouldEndEditing
    WebViewShouldEndEditingCallback         ,
    WebViewShouldEndEditingCallbackC        ,
    WebViewShouldEndEditingSignalInfo       ,
    afterWebViewShouldEndEditing            ,
    mkWebViewShouldEndEditingCallback       ,
    noWebViewShouldEndEditingCallback       ,
    onWebViewShouldEndEditing               ,
    webViewShouldEndEditingCallbackWrapper  ,
    webViewShouldEndEditingClosure          ,


-- ** ShouldInsertNode
    WebViewShouldInsertNodeCallback         ,
    WebViewShouldInsertNodeCallbackC        ,
    WebViewShouldInsertNodeSignalInfo       ,
    afterWebViewShouldInsertNode            ,
    mkWebViewShouldInsertNodeCallback       ,
    noWebViewShouldInsertNodeCallback       ,
    onWebViewShouldInsertNode               ,
    webViewShouldInsertNodeCallbackWrapper  ,
    webViewShouldInsertNodeClosure          ,


-- ** ShouldInsertText
    WebViewShouldInsertTextCallback         ,
    WebViewShouldInsertTextCallbackC        ,
    WebViewShouldInsertTextSignalInfo       ,
    afterWebViewShouldInsertText            ,
    mkWebViewShouldInsertTextCallback       ,
    noWebViewShouldInsertTextCallback       ,
    onWebViewShouldInsertText               ,
    webViewShouldInsertTextCallbackWrapper  ,
    webViewShouldInsertTextClosure          ,


-- ** ShouldShowDeleteInterfaceForElement
    WebViewShouldShowDeleteInterfaceForElementCallback,
    WebViewShouldShowDeleteInterfaceForElementCallbackC,
    WebViewShouldShowDeleteInterfaceForElementSignalInfo,
    afterWebViewShouldShowDeleteInterfaceForElement,
    mkWebViewShouldShowDeleteInterfaceForElementCallback,
    noWebViewShouldShowDeleteInterfaceForElementCallback,
    onWebViewShouldShowDeleteInterfaceForElement,
    webViewShouldShowDeleteInterfaceForElementCallbackWrapper,
    webViewShouldShowDeleteInterfaceForElementClosure,


-- ** StatusBarTextChanged
    WebViewStatusBarTextChangedCallback     ,
    WebViewStatusBarTextChangedCallbackC    ,
    WebViewStatusBarTextChangedSignalInfo   ,
    afterWebViewStatusBarTextChanged        ,
    mkWebViewStatusBarTextChangedCallback   ,
    noWebViewStatusBarTextChangedCallback   ,
    onWebViewStatusBarTextChanged           ,
    webViewStatusBarTextChangedCallbackWrapper,
    webViewStatusBarTextChangedClosure      ,


-- ** TitleChanged
    WebViewTitleChangedCallback             ,
    WebViewTitleChangedCallbackC            ,
    WebViewTitleChangedSignalInfo           ,
    afterWebViewTitleChanged                ,
    mkWebViewTitleChangedCallback           ,
    noWebViewTitleChangedCallback           ,
    onWebViewTitleChanged                   ,
    webViewTitleChangedCallbackWrapper      ,
    webViewTitleChangedClosure              ,


-- ** Undo
    WebViewUndoCallback                     ,
    WebViewUndoCallbackC                    ,
    WebViewUndoSignalInfo                   ,
    afterWebViewUndo                        ,
    mkWebViewUndoCallback                   ,
    noWebViewUndoCallback                   ,
    onWebViewUndo                           ,
    webViewUndoCallbackWrapper              ,
    webViewUndoClosure                      ,


-- ** UserChangedContents
    WebViewUserChangedContentsCallback      ,
    WebViewUserChangedContentsCallbackC     ,
    WebViewUserChangedContentsSignalInfo    ,
    afterWebViewUserChangedContents         ,
    mkWebViewUserChangedContentsCallback    ,
    noWebViewUserChangedContentsCallback    ,
    onWebViewUserChangedContents            ,
    webViewUserChangedContentsCallbackWrapper,
    webViewUserChangedContentsClosure       ,


-- ** ViewportAttributesChanged
    WebViewViewportAttributesChangedCallback,
    WebViewViewportAttributesChangedCallbackC,
    WebViewViewportAttributesChangedSignalInfo,
    afterWebViewViewportAttributesChanged   ,
    mkWebViewViewportAttributesChangedCallback,
    noWebViewViewportAttributesChangedCallback,
    onWebViewViewportAttributesChanged      ,
    webViewViewportAttributesChangedCallbackWrapper,
    webViewViewportAttributesChangedClosure ,


-- ** ViewportAttributesRecomputeRequested
    WebViewViewportAttributesRecomputeRequestedCallback,
    WebViewViewportAttributesRecomputeRequestedCallbackC,
    WebViewViewportAttributesRecomputeRequestedSignalInfo,
    afterWebViewViewportAttributesRecomputeRequested,
    mkWebViewViewportAttributesRecomputeRequestedCallback,
    noWebViewViewportAttributesRecomputeRequestedCallback,
    onWebViewViewportAttributesRecomputeRequested,
    webViewViewportAttributesRecomputeRequestedCallbackWrapper,
    webViewViewportAttributesRecomputeRequestedClosure,


-- ** WebViewReady
    WebViewWebViewReadyCallback             ,
    WebViewWebViewReadyCallbackC            ,
    WebViewWebViewReadySignalInfo           ,
    afterWebViewWebViewReady                ,
    mkWebViewWebViewReadyCallback           ,
    noWebViewWebViewReadyCallback           ,
    onWebViewWebViewReady                   ,
    webViewWebViewReadyCallbackWrapper      ,
    webViewWebViewReadyClosure              ,


-- ** WindowObjectCleared
    WebViewWindowObjectClearedCallback      ,
    WebViewWindowObjectClearedCallbackC     ,
    WebViewWindowObjectClearedSignalInfo    ,
    afterWebViewWindowObjectCleared         ,
    mkWebViewWindowObjectClearedCallback    ,
    noWebViewWindowObjectClearedCallback    ,
    onWebViewWindowObjectCleared            ,
    webViewWindowObjectClearedCallbackWrapper,
    webViewWindowObjectClearedClosure       ,




    ) where

import Prelude ()
import Data.GI.Base.ShortPrelude

import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map

import GI.WebKit.Types
import GI.WebKit.Callbacks
import qualified GI.Atk as Atk
import qualified GI.GObject as GObject
import qualified GI.Gdk as Gdk
import qualified GI.GdkPixbuf as GdkPixbuf
import qualified GI.Gtk as Gtk
import qualified GI.Cairo as Cairo

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

type instance ParentTypes WebView = WebViewParentTypes
type WebViewParentTypes = '[Gtk.Container, Gtk.Widget, GObject.Object, Atk.ImplementorIface, Gtk.Buildable, Gtk.Scrollable]

instance GObject WebView where
    gobjectIsInitiallyUnowned _ = True
    gobjectType _ = c_webkit_web_view_get_type
    

class GObject o => WebViewK o
instance (GObject o, IsDescendantOf WebView o) => WebViewK o

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

noWebView :: Maybe WebView
noWebView = Nothing

-- signal WebView::close-web-view
type WebViewCloseWebViewCallback =
    IO Bool

noWebViewCloseWebViewCallback :: Maybe WebViewCloseWebViewCallback
noWebViewCloseWebViewCallback = Nothing

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

foreign import ccall "wrapper"
    mkWebViewCloseWebViewCallback :: WebViewCloseWebViewCallbackC -> IO (FunPtr WebViewCloseWebViewCallbackC)

webViewCloseWebViewClosure :: WebViewCloseWebViewCallback -> IO Closure
webViewCloseWebViewClosure cb = newCClosure =<< mkWebViewCloseWebViewCallback wrapped
    where wrapped = webViewCloseWebViewCallbackWrapper cb

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

onWebViewCloseWebView :: (GObject a, MonadIO m) => a -> WebViewCloseWebViewCallback -> m SignalHandlerId
onWebViewCloseWebView obj cb = liftIO $ connectWebViewCloseWebView obj cb SignalConnectBefore
afterWebViewCloseWebView :: (GObject a, MonadIO m) => a -> WebViewCloseWebViewCallback -> m SignalHandlerId
afterWebViewCloseWebView obj cb = connectWebViewCloseWebView obj cb SignalConnectAfter

connectWebViewCloseWebView :: (GObject a, MonadIO m) =>
                              a -> WebViewCloseWebViewCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewCloseWebView obj cb after = liftIO $ do
    cb' <- mkWebViewCloseWebViewCallback (webViewCloseWebViewCallbackWrapper cb)
    connectSignalFunPtr obj "close-web-view" cb' after

-- signal WebView::console-message
type WebViewConsoleMessageCallback =
    T.Text ->
    Int32 ->
    T.Text ->
    IO Bool

noWebViewConsoleMessageCallback :: Maybe WebViewConsoleMessageCallback
noWebViewConsoleMessageCallback = Nothing

type WebViewConsoleMessageCallbackC =
    Ptr () ->                               -- object
    CString ->
    Int32 ->
    CString ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mkWebViewConsoleMessageCallback :: WebViewConsoleMessageCallbackC -> IO (FunPtr WebViewConsoleMessageCallbackC)

webViewConsoleMessageClosure :: WebViewConsoleMessageCallback -> IO Closure
webViewConsoleMessageClosure cb = newCClosure =<< mkWebViewConsoleMessageCallback wrapped
    where wrapped = webViewConsoleMessageCallbackWrapper cb

webViewConsoleMessageCallbackWrapper ::
    WebViewConsoleMessageCallback ->
    Ptr () ->
    CString ->
    Int32 ->
    CString ->
    Ptr () ->
    IO CInt
webViewConsoleMessageCallbackWrapper _cb _ message line source_id _ = do
    message' <- cstringToText message
    source_id' <- cstringToText source_id
    result <- _cb  message' line source_id'
    let result' = (fromIntegral . fromEnum) result
    return result'

onWebViewConsoleMessage :: (GObject a, MonadIO m) => a -> WebViewConsoleMessageCallback -> m SignalHandlerId
onWebViewConsoleMessage obj cb = liftIO $ connectWebViewConsoleMessage obj cb SignalConnectBefore
afterWebViewConsoleMessage :: (GObject a, MonadIO m) => a -> WebViewConsoleMessageCallback -> m SignalHandlerId
afterWebViewConsoleMessage obj cb = connectWebViewConsoleMessage obj cb SignalConnectAfter

connectWebViewConsoleMessage :: (GObject a, MonadIO m) =>
                                a -> WebViewConsoleMessageCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewConsoleMessage obj cb after = liftIO $ do
    cb' <- mkWebViewConsoleMessageCallback (webViewConsoleMessageCallbackWrapper cb)
    connectSignalFunPtr obj "console-message" cb' after

-- signal WebView::context-menu
type WebViewContextMenuCallback =
    Gtk.Widget ->
    HitTestResult ->
    Bool ->
    IO Bool

noWebViewContextMenuCallback :: Maybe WebViewContextMenuCallback
noWebViewContextMenuCallback = Nothing

type WebViewContextMenuCallbackC =
    Ptr () ->                               -- object
    Ptr Gtk.Widget ->
    Ptr HitTestResult ->
    CInt ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mkWebViewContextMenuCallback :: WebViewContextMenuCallbackC -> IO (FunPtr WebViewContextMenuCallbackC)

webViewContextMenuClosure :: WebViewContextMenuCallback -> IO Closure
webViewContextMenuClosure cb = newCClosure =<< mkWebViewContextMenuCallback wrapped
    where wrapped = webViewContextMenuCallbackWrapper cb

webViewContextMenuCallbackWrapper ::
    WebViewContextMenuCallback ->
    Ptr () ->
    Ptr Gtk.Widget ->
    Ptr HitTestResult ->
    CInt ->
    Ptr () ->
    IO CInt
webViewContextMenuCallbackWrapper _cb _ default_menu hit_test_result triggered_with_keyboard _ = do
    default_menu' <- (newObject Gtk.Widget) default_menu
    hit_test_result' <- (newObject HitTestResult) hit_test_result
    let triggered_with_keyboard' = (/= 0) triggered_with_keyboard
    result <- _cb  default_menu' hit_test_result' triggered_with_keyboard'
    let result' = (fromIntegral . fromEnum) result
    return result'

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

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

-- signal WebView::copy-clipboard
type WebViewCopyClipboardCallback =
    IO ()

noWebViewCopyClipboardCallback :: Maybe WebViewCopyClipboardCallback
noWebViewCopyClipboardCallback = Nothing

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

foreign import ccall "wrapper"
    mkWebViewCopyClipboardCallback :: WebViewCopyClipboardCallbackC -> IO (FunPtr WebViewCopyClipboardCallbackC)

webViewCopyClipboardClosure :: WebViewCopyClipboardCallback -> IO Closure
webViewCopyClipboardClosure cb = newCClosure =<< mkWebViewCopyClipboardCallback wrapped
    where wrapped = webViewCopyClipboardCallbackWrapper cb

webViewCopyClipboardCallbackWrapper ::
    WebViewCopyClipboardCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
webViewCopyClipboardCallbackWrapper _cb _ _ = do
    _cb 

onWebViewCopyClipboard :: (GObject a, MonadIO m) => a -> WebViewCopyClipboardCallback -> m SignalHandlerId
onWebViewCopyClipboard obj cb = liftIO $ connectWebViewCopyClipboard obj cb SignalConnectBefore
afterWebViewCopyClipboard :: (GObject a, MonadIO m) => a -> WebViewCopyClipboardCallback -> m SignalHandlerId
afterWebViewCopyClipboard obj cb = connectWebViewCopyClipboard obj cb SignalConnectAfter

connectWebViewCopyClipboard :: (GObject a, MonadIO m) =>
                               a -> WebViewCopyClipboardCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewCopyClipboard obj cb after = liftIO $ do
    cb' <- mkWebViewCopyClipboardCallback (webViewCopyClipboardCallbackWrapper cb)
    connectSignalFunPtr obj "copy-clipboard" cb' after

-- signal WebView::create-plugin-widget
type WebViewCreatePluginWidgetCallback =
    T.Text ->
    T.Text ->
    Map.Map (Ptr ()) (Ptr ()) ->
    IO Gtk.Widget

noWebViewCreatePluginWidgetCallback :: Maybe WebViewCreatePluginWidgetCallback
noWebViewCreatePluginWidgetCallback = Nothing

type WebViewCreatePluginWidgetCallbackC =
    Ptr () ->                               -- object
    CString ->
    CString ->
    Ptr (GHashTable (Ptr ()) (Ptr ())) ->
    Ptr () ->                               -- user_data
    IO (Ptr Gtk.Widget)

foreign import ccall "wrapper"
    mkWebViewCreatePluginWidgetCallback :: WebViewCreatePluginWidgetCallbackC -> IO (FunPtr WebViewCreatePluginWidgetCallbackC)

webViewCreatePluginWidgetClosure :: WebViewCreatePluginWidgetCallback -> IO Closure
webViewCreatePluginWidgetClosure cb = newCClosure =<< mkWebViewCreatePluginWidgetCallback wrapped
    where wrapped = webViewCreatePluginWidgetCallbackWrapper cb

webViewCreatePluginWidgetCallbackWrapper ::
    WebViewCreatePluginWidgetCallback ->
    Ptr () ->
    CString ->
    CString ->
    Ptr (GHashTable (Ptr ()) (Ptr ())) ->
    Ptr () ->
    IO (Ptr Gtk.Widget)
webViewCreatePluginWidgetCallbackWrapper _cb _ mime_type uri param _ = do
    mime_type' <- cstringToText mime_type
    uri' <- cstringToText uri
    param' <- unpackGHashTable param
    let param'' = mapFirst ptrUnpackPtr param'
    let param''' = mapSecond ptrUnpackPtr param''
    let param'''' = Map.fromList param'''
    result <- _cb  mime_type' uri' param''''
    result' <- refObject result
    return result'

onWebViewCreatePluginWidget :: (GObject a, MonadIO m) => a -> WebViewCreatePluginWidgetCallback -> m SignalHandlerId
onWebViewCreatePluginWidget obj cb = liftIO $ connectWebViewCreatePluginWidget obj cb SignalConnectBefore
afterWebViewCreatePluginWidget :: (GObject a, MonadIO m) => a -> WebViewCreatePluginWidgetCallback -> m SignalHandlerId
afterWebViewCreatePluginWidget obj cb = connectWebViewCreatePluginWidget obj cb SignalConnectAfter

connectWebViewCreatePluginWidget :: (GObject a, MonadIO m) =>
                                    a -> WebViewCreatePluginWidgetCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewCreatePluginWidget obj cb after = liftIO $ do
    cb' <- mkWebViewCreatePluginWidgetCallback (webViewCreatePluginWidgetCallbackWrapper cb)
    connectSignalFunPtr obj "create-plugin-widget" cb' after

-- signal WebView::create-web-view
type WebViewCreateWebViewCallback =
    WebFrame ->
    IO WebView

noWebViewCreateWebViewCallback :: Maybe WebViewCreateWebViewCallback
noWebViewCreateWebViewCallback = Nothing

type WebViewCreateWebViewCallbackC =
    Ptr () ->                               -- object
    Ptr WebFrame ->
    Ptr () ->                               -- user_data
    IO (Ptr WebView)

foreign import ccall "wrapper"
    mkWebViewCreateWebViewCallback :: WebViewCreateWebViewCallbackC -> IO (FunPtr WebViewCreateWebViewCallbackC)

webViewCreateWebViewClosure :: WebViewCreateWebViewCallback -> IO Closure
webViewCreateWebViewClosure cb = newCClosure =<< mkWebViewCreateWebViewCallback wrapped
    where wrapped = webViewCreateWebViewCallbackWrapper cb

webViewCreateWebViewCallbackWrapper ::
    WebViewCreateWebViewCallback ->
    Ptr () ->
    Ptr WebFrame ->
    Ptr () ->
    IO (Ptr WebView)
webViewCreateWebViewCallbackWrapper _cb _ frame _ = do
    frame' <- (newObject WebFrame) frame
    result <- _cb  frame'
    result' <- refObject result
    return result'

onWebViewCreateWebView :: (GObject a, MonadIO m) => a -> WebViewCreateWebViewCallback -> m SignalHandlerId
onWebViewCreateWebView obj cb = liftIO $ connectWebViewCreateWebView obj cb SignalConnectBefore
afterWebViewCreateWebView :: (GObject a, MonadIO m) => a -> WebViewCreateWebViewCallback -> m SignalHandlerId
afterWebViewCreateWebView obj cb = connectWebViewCreateWebView obj cb SignalConnectAfter

connectWebViewCreateWebView :: (GObject a, MonadIO m) =>
                               a -> WebViewCreateWebViewCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewCreateWebView obj cb after = liftIO $ do
    cb' <- mkWebViewCreateWebViewCallback (webViewCreateWebViewCallbackWrapper cb)
    connectSignalFunPtr obj "create-web-view" cb' after

-- signal WebView::cut-clipboard
type WebViewCutClipboardCallback =
    IO ()

noWebViewCutClipboardCallback :: Maybe WebViewCutClipboardCallback
noWebViewCutClipboardCallback = Nothing

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

foreign import ccall "wrapper"
    mkWebViewCutClipboardCallback :: WebViewCutClipboardCallbackC -> IO (FunPtr WebViewCutClipboardCallbackC)

webViewCutClipboardClosure :: WebViewCutClipboardCallback -> IO Closure
webViewCutClipboardClosure cb = newCClosure =<< mkWebViewCutClipboardCallback wrapped
    where wrapped = webViewCutClipboardCallbackWrapper cb

webViewCutClipboardCallbackWrapper ::
    WebViewCutClipboardCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
webViewCutClipboardCallbackWrapper _cb _ _ = do
    _cb 

onWebViewCutClipboard :: (GObject a, MonadIO m) => a -> WebViewCutClipboardCallback -> m SignalHandlerId
onWebViewCutClipboard obj cb = liftIO $ connectWebViewCutClipboard obj cb SignalConnectBefore
afterWebViewCutClipboard :: (GObject a, MonadIO m) => a -> WebViewCutClipboardCallback -> m SignalHandlerId
afterWebViewCutClipboard obj cb = connectWebViewCutClipboard obj cb SignalConnectAfter

connectWebViewCutClipboard :: (GObject a, MonadIO m) =>
                              a -> WebViewCutClipboardCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewCutClipboard obj cb after = liftIO $ do
    cb' <- mkWebViewCutClipboardCallback (webViewCutClipboardCallbackWrapper cb)
    connectSignalFunPtr obj "cut-clipboard" cb' after

-- signal WebView::database-quota-exceeded
type WebViewDatabaseQuotaExceededCallback =
    GObject.Object ->
    GObject.Object ->
    IO ()

noWebViewDatabaseQuotaExceededCallback :: Maybe WebViewDatabaseQuotaExceededCallback
noWebViewDatabaseQuotaExceededCallback = Nothing

type WebViewDatabaseQuotaExceededCallbackC =
    Ptr () ->                               -- object
    Ptr GObject.Object ->
    Ptr GObject.Object ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mkWebViewDatabaseQuotaExceededCallback :: WebViewDatabaseQuotaExceededCallbackC -> IO (FunPtr WebViewDatabaseQuotaExceededCallbackC)

webViewDatabaseQuotaExceededClosure :: WebViewDatabaseQuotaExceededCallback -> IO Closure
webViewDatabaseQuotaExceededClosure cb = newCClosure =<< mkWebViewDatabaseQuotaExceededCallback wrapped
    where wrapped = webViewDatabaseQuotaExceededCallbackWrapper cb

webViewDatabaseQuotaExceededCallbackWrapper ::
    WebViewDatabaseQuotaExceededCallback ->
    Ptr () ->
    Ptr GObject.Object ->
    Ptr GObject.Object ->
    Ptr () ->
    IO ()
webViewDatabaseQuotaExceededCallbackWrapper _cb _ frame database _ = do
    frame' <- (newObject GObject.Object) frame
    database' <- (newObject GObject.Object) database
    _cb  frame' database'

onWebViewDatabaseQuotaExceeded :: (GObject a, MonadIO m) => a -> WebViewDatabaseQuotaExceededCallback -> m SignalHandlerId
onWebViewDatabaseQuotaExceeded obj cb = liftIO $ connectWebViewDatabaseQuotaExceeded obj cb SignalConnectBefore
afterWebViewDatabaseQuotaExceeded :: (GObject a, MonadIO m) => a -> WebViewDatabaseQuotaExceededCallback -> m SignalHandlerId
afterWebViewDatabaseQuotaExceeded obj cb = connectWebViewDatabaseQuotaExceeded obj cb SignalConnectAfter

connectWebViewDatabaseQuotaExceeded :: (GObject a, MonadIO m) =>
                                       a -> WebViewDatabaseQuotaExceededCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewDatabaseQuotaExceeded obj cb after = liftIO $ do
    cb' <- mkWebViewDatabaseQuotaExceededCallback (webViewDatabaseQuotaExceededCallbackWrapper cb)
    connectSignalFunPtr obj "database-quota-exceeded" cb' after

-- signal WebView::document-load-finished
type WebViewDocumentLoadFinishedCallback =
    WebFrame ->
    IO ()

noWebViewDocumentLoadFinishedCallback :: Maybe WebViewDocumentLoadFinishedCallback
noWebViewDocumentLoadFinishedCallback = Nothing

type WebViewDocumentLoadFinishedCallbackC =
    Ptr () ->                               -- object
    Ptr WebFrame ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mkWebViewDocumentLoadFinishedCallback :: WebViewDocumentLoadFinishedCallbackC -> IO (FunPtr WebViewDocumentLoadFinishedCallbackC)

webViewDocumentLoadFinishedClosure :: WebViewDocumentLoadFinishedCallback -> IO Closure
webViewDocumentLoadFinishedClosure cb = newCClosure =<< mkWebViewDocumentLoadFinishedCallback wrapped
    where wrapped = webViewDocumentLoadFinishedCallbackWrapper cb

webViewDocumentLoadFinishedCallbackWrapper ::
    WebViewDocumentLoadFinishedCallback ->
    Ptr () ->
    Ptr WebFrame ->
    Ptr () ->
    IO ()
webViewDocumentLoadFinishedCallbackWrapper _cb _ web_frame _ = do
    web_frame' <- (newObject WebFrame) web_frame
    _cb  web_frame'

onWebViewDocumentLoadFinished :: (GObject a, MonadIO m) => a -> WebViewDocumentLoadFinishedCallback -> m SignalHandlerId
onWebViewDocumentLoadFinished obj cb = liftIO $ connectWebViewDocumentLoadFinished obj cb SignalConnectBefore
afterWebViewDocumentLoadFinished :: (GObject a, MonadIO m) => a -> WebViewDocumentLoadFinishedCallback -> m SignalHandlerId
afterWebViewDocumentLoadFinished obj cb = connectWebViewDocumentLoadFinished obj cb SignalConnectAfter

connectWebViewDocumentLoadFinished :: (GObject a, MonadIO m) =>
                                      a -> WebViewDocumentLoadFinishedCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewDocumentLoadFinished obj cb after = liftIO $ do
    cb' <- mkWebViewDocumentLoadFinishedCallback (webViewDocumentLoadFinishedCallbackWrapper cb)
    connectSignalFunPtr obj "document-load-finished" cb' after

-- signal WebView::download-requested
type WebViewDownloadRequestedCallback =
    Download ->
    IO Bool

noWebViewDownloadRequestedCallback :: Maybe WebViewDownloadRequestedCallback
noWebViewDownloadRequestedCallback = Nothing

type WebViewDownloadRequestedCallbackC =
    Ptr () ->                               -- object
    Ptr Download ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mkWebViewDownloadRequestedCallback :: WebViewDownloadRequestedCallbackC -> IO (FunPtr WebViewDownloadRequestedCallbackC)

webViewDownloadRequestedClosure :: WebViewDownloadRequestedCallback -> IO Closure
webViewDownloadRequestedClosure cb = newCClosure =<< mkWebViewDownloadRequestedCallback wrapped
    where wrapped = webViewDownloadRequestedCallbackWrapper cb

webViewDownloadRequestedCallbackWrapper ::
    WebViewDownloadRequestedCallback ->
    Ptr () ->
    Ptr Download ->
    Ptr () ->
    IO CInt
webViewDownloadRequestedCallbackWrapper _cb _ download _ = do
    download' <- (newObject Download) download
    result <- _cb  download'
    let result' = (fromIntegral . fromEnum) result
    return result'

onWebViewDownloadRequested :: (GObject a, MonadIO m) => a -> WebViewDownloadRequestedCallback -> m SignalHandlerId
onWebViewDownloadRequested obj cb = liftIO $ connectWebViewDownloadRequested obj cb SignalConnectBefore
afterWebViewDownloadRequested :: (GObject a, MonadIO m) => a -> WebViewDownloadRequestedCallback -> m SignalHandlerId
afterWebViewDownloadRequested obj cb = connectWebViewDownloadRequested obj cb SignalConnectAfter

connectWebViewDownloadRequested :: (GObject a, MonadIO m) =>
                                   a -> WebViewDownloadRequestedCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewDownloadRequested obj cb after = liftIO $ do
    cb' <- mkWebViewDownloadRequestedCallback (webViewDownloadRequestedCallbackWrapper cb)
    connectSignalFunPtr obj "download-requested" cb' after

-- signal WebView::editing-began
type WebViewEditingBeganCallback =
    IO ()

noWebViewEditingBeganCallback :: Maybe WebViewEditingBeganCallback
noWebViewEditingBeganCallback = Nothing

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

foreign import ccall "wrapper"
    mkWebViewEditingBeganCallback :: WebViewEditingBeganCallbackC -> IO (FunPtr WebViewEditingBeganCallbackC)

webViewEditingBeganClosure :: WebViewEditingBeganCallback -> IO Closure
webViewEditingBeganClosure cb = newCClosure =<< mkWebViewEditingBeganCallback wrapped
    where wrapped = webViewEditingBeganCallbackWrapper cb

webViewEditingBeganCallbackWrapper ::
    WebViewEditingBeganCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
webViewEditingBeganCallbackWrapper _cb _ _ = do
    _cb 

onWebViewEditingBegan :: (GObject a, MonadIO m) => a -> WebViewEditingBeganCallback -> m SignalHandlerId
onWebViewEditingBegan obj cb = liftIO $ connectWebViewEditingBegan obj cb SignalConnectBefore
afterWebViewEditingBegan :: (GObject a, MonadIO m) => a -> WebViewEditingBeganCallback -> m SignalHandlerId
afterWebViewEditingBegan obj cb = connectWebViewEditingBegan obj cb SignalConnectAfter

connectWebViewEditingBegan :: (GObject a, MonadIO m) =>
                              a -> WebViewEditingBeganCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewEditingBegan obj cb after = liftIO $ do
    cb' <- mkWebViewEditingBeganCallback (webViewEditingBeganCallbackWrapper cb)
    connectSignalFunPtr obj "editing-began" cb' after

-- signal WebView::editing-ended
type WebViewEditingEndedCallback =
    IO ()

noWebViewEditingEndedCallback :: Maybe WebViewEditingEndedCallback
noWebViewEditingEndedCallback = Nothing

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

foreign import ccall "wrapper"
    mkWebViewEditingEndedCallback :: WebViewEditingEndedCallbackC -> IO (FunPtr WebViewEditingEndedCallbackC)

webViewEditingEndedClosure :: WebViewEditingEndedCallback -> IO Closure
webViewEditingEndedClosure cb = newCClosure =<< mkWebViewEditingEndedCallback wrapped
    where wrapped = webViewEditingEndedCallbackWrapper cb

webViewEditingEndedCallbackWrapper ::
    WebViewEditingEndedCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
webViewEditingEndedCallbackWrapper _cb _ _ = do
    _cb 

onWebViewEditingEnded :: (GObject a, MonadIO m) => a -> WebViewEditingEndedCallback -> m SignalHandlerId
onWebViewEditingEnded obj cb = liftIO $ connectWebViewEditingEnded obj cb SignalConnectBefore
afterWebViewEditingEnded :: (GObject a, MonadIO m) => a -> WebViewEditingEndedCallback -> m SignalHandlerId
afterWebViewEditingEnded obj cb = connectWebViewEditingEnded obj cb SignalConnectAfter

connectWebViewEditingEnded :: (GObject a, MonadIO m) =>
                              a -> WebViewEditingEndedCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewEditingEnded obj cb after = liftIO $ do
    cb' <- mkWebViewEditingEndedCallback (webViewEditingEndedCallbackWrapper cb)
    connectSignalFunPtr obj "editing-ended" cb' after

-- signal WebView::entering-fullscreen
type WebViewEnteringFullscreenCallback =
    DOMHTMLElement ->
    IO Bool

noWebViewEnteringFullscreenCallback :: Maybe WebViewEnteringFullscreenCallback
noWebViewEnteringFullscreenCallback = Nothing

type WebViewEnteringFullscreenCallbackC =
    Ptr () ->                               -- object
    Ptr DOMHTMLElement ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mkWebViewEnteringFullscreenCallback :: WebViewEnteringFullscreenCallbackC -> IO (FunPtr WebViewEnteringFullscreenCallbackC)

webViewEnteringFullscreenClosure :: WebViewEnteringFullscreenCallback -> IO Closure
webViewEnteringFullscreenClosure cb = newCClosure =<< mkWebViewEnteringFullscreenCallback wrapped
    where wrapped = webViewEnteringFullscreenCallbackWrapper cb

webViewEnteringFullscreenCallbackWrapper ::
    WebViewEnteringFullscreenCallback ->
    Ptr () ->
    Ptr DOMHTMLElement ->
    Ptr () ->
    IO CInt
webViewEnteringFullscreenCallbackWrapper _cb _ element _ = do
    element' <- (newObject DOMHTMLElement) element
    result <- _cb  element'
    let result' = (fromIntegral . fromEnum) result
    return result'

onWebViewEnteringFullscreen :: (GObject a, MonadIO m) => a -> WebViewEnteringFullscreenCallback -> m SignalHandlerId
onWebViewEnteringFullscreen obj cb = liftIO $ connectWebViewEnteringFullscreen obj cb SignalConnectBefore
afterWebViewEnteringFullscreen :: (GObject a, MonadIO m) => a -> WebViewEnteringFullscreenCallback -> m SignalHandlerId
afterWebViewEnteringFullscreen obj cb = connectWebViewEnteringFullscreen obj cb SignalConnectAfter

connectWebViewEnteringFullscreen :: (GObject a, MonadIO m) =>
                                    a -> WebViewEnteringFullscreenCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewEnteringFullscreen obj cb after = liftIO $ do
    cb' <- mkWebViewEnteringFullscreenCallback (webViewEnteringFullscreenCallbackWrapper cb)
    connectSignalFunPtr obj "entering-fullscreen" cb' after

-- signal WebView::frame-created
type WebViewFrameCreatedCallback =
    WebFrame ->
    IO ()

noWebViewFrameCreatedCallback :: Maybe WebViewFrameCreatedCallback
noWebViewFrameCreatedCallback = Nothing

type WebViewFrameCreatedCallbackC =
    Ptr () ->                               -- object
    Ptr WebFrame ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mkWebViewFrameCreatedCallback :: WebViewFrameCreatedCallbackC -> IO (FunPtr WebViewFrameCreatedCallbackC)

webViewFrameCreatedClosure :: WebViewFrameCreatedCallback -> IO Closure
webViewFrameCreatedClosure cb = newCClosure =<< mkWebViewFrameCreatedCallback wrapped
    where wrapped = webViewFrameCreatedCallbackWrapper cb

webViewFrameCreatedCallbackWrapper ::
    WebViewFrameCreatedCallback ->
    Ptr () ->
    Ptr WebFrame ->
    Ptr () ->
    IO ()
webViewFrameCreatedCallbackWrapper _cb _ web_frame _ = do
    web_frame' <- (newObject WebFrame) web_frame
    _cb  web_frame'

onWebViewFrameCreated :: (GObject a, MonadIO m) => a -> WebViewFrameCreatedCallback -> m SignalHandlerId
onWebViewFrameCreated obj cb = liftIO $ connectWebViewFrameCreated obj cb SignalConnectBefore
afterWebViewFrameCreated :: (GObject a, MonadIO m) => a -> WebViewFrameCreatedCallback -> m SignalHandlerId
afterWebViewFrameCreated obj cb = connectWebViewFrameCreated obj cb SignalConnectAfter

connectWebViewFrameCreated :: (GObject a, MonadIO m) =>
                              a -> WebViewFrameCreatedCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewFrameCreated obj cb after = liftIO $ do
    cb' <- mkWebViewFrameCreatedCallback (webViewFrameCreatedCallbackWrapper cb)
    connectSignalFunPtr obj "frame-created" cb' after

-- signal WebView::geolocation-policy-decision-cancelled
type WebViewGeolocationPolicyDecisionCancelledCallback =
    WebFrame ->
    IO ()

noWebViewGeolocationPolicyDecisionCancelledCallback :: Maybe WebViewGeolocationPolicyDecisionCancelledCallback
noWebViewGeolocationPolicyDecisionCancelledCallback = Nothing

type WebViewGeolocationPolicyDecisionCancelledCallbackC =
    Ptr () ->                               -- object
    Ptr WebFrame ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mkWebViewGeolocationPolicyDecisionCancelledCallback :: WebViewGeolocationPolicyDecisionCancelledCallbackC -> IO (FunPtr WebViewGeolocationPolicyDecisionCancelledCallbackC)

webViewGeolocationPolicyDecisionCancelledClosure :: WebViewGeolocationPolicyDecisionCancelledCallback -> IO Closure
webViewGeolocationPolicyDecisionCancelledClosure cb = newCClosure =<< mkWebViewGeolocationPolicyDecisionCancelledCallback wrapped
    where wrapped = webViewGeolocationPolicyDecisionCancelledCallbackWrapper cb

webViewGeolocationPolicyDecisionCancelledCallbackWrapper ::
    WebViewGeolocationPolicyDecisionCancelledCallback ->
    Ptr () ->
    Ptr WebFrame ->
    Ptr () ->
    IO ()
webViewGeolocationPolicyDecisionCancelledCallbackWrapper _cb _ frame _ = do
    frame' <- (newObject WebFrame) frame
    _cb  frame'

onWebViewGeolocationPolicyDecisionCancelled :: (GObject a, MonadIO m) => a -> WebViewGeolocationPolicyDecisionCancelledCallback -> m SignalHandlerId
onWebViewGeolocationPolicyDecisionCancelled obj cb = liftIO $ connectWebViewGeolocationPolicyDecisionCancelled obj cb SignalConnectBefore
afterWebViewGeolocationPolicyDecisionCancelled :: (GObject a, MonadIO m) => a -> WebViewGeolocationPolicyDecisionCancelledCallback -> m SignalHandlerId
afterWebViewGeolocationPolicyDecisionCancelled obj cb = connectWebViewGeolocationPolicyDecisionCancelled obj cb SignalConnectAfter

connectWebViewGeolocationPolicyDecisionCancelled :: (GObject a, MonadIO m) =>
                                                    a -> WebViewGeolocationPolicyDecisionCancelledCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewGeolocationPolicyDecisionCancelled obj cb after = liftIO $ do
    cb' <- mkWebViewGeolocationPolicyDecisionCancelledCallback (webViewGeolocationPolicyDecisionCancelledCallbackWrapper cb)
    connectSignalFunPtr obj "geolocation-policy-decision-cancelled" cb' after

-- signal WebView::geolocation-policy-decision-requested
type WebViewGeolocationPolicyDecisionRequestedCallback =
    WebFrame ->
    GeolocationPolicyDecision ->
    IO Bool

noWebViewGeolocationPolicyDecisionRequestedCallback :: Maybe WebViewGeolocationPolicyDecisionRequestedCallback
noWebViewGeolocationPolicyDecisionRequestedCallback = Nothing

type WebViewGeolocationPolicyDecisionRequestedCallbackC =
    Ptr () ->                               -- object
    Ptr WebFrame ->
    Ptr GeolocationPolicyDecision ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mkWebViewGeolocationPolicyDecisionRequestedCallback :: WebViewGeolocationPolicyDecisionRequestedCallbackC -> IO (FunPtr WebViewGeolocationPolicyDecisionRequestedCallbackC)

webViewGeolocationPolicyDecisionRequestedClosure :: WebViewGeolocationPolicyDecisionRequestedCallback -> IO Closure
webViewGeolocationPolicyDecisionRequestedClosure cb = newCClosure =<< mkWebViewGeolocationPolicyDecisionRequestedCallback wrapped
    where wrapped = webViewGeolocationPolicyDecisionRequestedCallbackWrapper cb

webViewGeolocationPolicyDecisionRequestedCallbackWrapper ::
    WebViewGeolocationPolicyDecisionRequestedCallback ->
    Ptr () ->
    Ptr WebFrame ->
    Ptr GeolocationPolicyDecision ->
    Ptr () ->
    IO CInt
webViewGeolocationPolicyDecisionRequestedCallbackWrapper _cb _ frame policy_decision _ = do
    frame' <- (newObject WebFrame) frame
    policy_decision' <- (newObject GeolocationPolicyDecision) policy_decision
    result <- _cb  frame' policy_decision'
    let result' = (fromIntegral . fromEnum) result
    return result'

onWebViewGeolocationPolicyDecisionRequested :: (GObject a, MonadIO m) => a -> WebViewGeolocationPolicyDecisionRequestedCallback -> m SignalHandlerId
onWebViewGeolocationPolicyDecisionRequested obj cb = liftIO $ connectWebViewGeolocationPolicyDecisionRequested obj cb SignalConnectBefore
afterWebViewGeolocationPolicyDecisionRequested :: (GObject a, MonadIO m) => a -> WebViewGeolocationPolicyDecisionRequestedCallback -> m SignalHandlerId
afterWebViewGeolocationPolicyDecisionRequested obj cb = connectWebViewGeolocationPolicyDecisionRequested obj cb SignalConnectAfter

connectWebViewGeolocationPolicyDecisionRequested :: (GObject a, MonadIO m) =>
                                                    a -> WebViewGeolocationPolicyDecisionRequestedCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewGeolocationPolicyDecisionRequested obj cb after = liftIO $ do
    cb' <- mkWebViewGeolocationPolicyDecisionRequestedCallback (webViewGeolocationPolicyDecisionRequestedCallbackWrapper cb)
    connectSignalFunPtr obj "geolocation-policy-decision-requested" cb' after

-- signal WebView::hovering-over-link
type WebViewHoveringOverLinkCallback =
    T.Text ->
    T.Text ->
    IO ()

noWebViewHoveringOverLinkCallback :: Maybe WebViewHoveringOverLinkCallback
noWebViewHoveringOverLinkCallback = Nothing

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

foreign import ccall "wrapper"
    mkWebViewHoveringOverLinkCallback :: WebViewHoveringOverLinkCallbackC -> IO (FunPtr WebViewHoveringOverLinkCallbackC)

webViewHoveringOverLinkClosure :: WebViewHoveringOverLinkCallback -> IO Closure
webViewHoveringOverLinkClosure cb = newCClosure =<< mkWebViewHoveringOverLinkCallback wrapped
    where wrapped = webViewHoveringOverLinkCallbackWrapper cb

webViewHoveringOverLinkCallbackWrapper ::
    WebViewHoveringOverLinkCallback ->
    Ptr () ->
    CString ->
    CString ->
    Ptr () ->
    IO ()
webViewHoveringOverLinkCallbackWrapper _cb _ title uri _ = do
    title' <- cstringToText title
    uri' <- cstringToText uri
    _cb  title' uri'

onWebViewHoveringOverLink :: (GObject a, MonadIO m) => a -> WebViewHoveringOverLinkCallback -> m SignalHandlerId
onWebViewHoveringOverLink obj cb = liftIO $ connectWebViewHoveringOverLink obj cb SignalConnectBefore
afterWebViewHoveringOverLink :: (GObject a, MonadIO m) => a -> WebViewHoveringOverLinkCallback -> m SignalHandlerId
afterWebViewHoveringOverLink obj cb = connectWebViewHoveringOverLink obj cb SignalConnectAfter

connectWebViewHoveringOverLink :: (GObject a, MonadIO m) =>
                                  a -> WebViewHoveringOverLinkCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewHoveringOverLink obj cb after = liftIO $ do
    cb' <- mkWebViewHoveringOverLinkCallback (webViewHoveringOverLinkCallbackWrapper cb)
    connectSignalFunPtr obj "hovering-over-link" cb' after

-- signal WebView::icon-loaded
type WebViewIconLoadedCallback =
    T.Text ->
    IO ()

noWebViewIconLoadedCallback :: Maybe WebViewIconLoadedCallback
noWebViewIconLoadedCallback = Nothing

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

foreign import ccall "wrapper"
    mkWebViewIconLoadedCallback :: WebViewIconLoadedCallbackC -> IO (FunPtr WebViewIconLoadedCallbackC)

webViewIconLoadedClosure :: WebViewIconLoadedCallback -> IO Closure
webViewIconLoadedClosure cb = newCClosure =<< mkWebViewIconLoadedCallback wrapped
    where wrapped = webViewIconLoadedCallbackWrapper cb

webViewIconLoadedCallbackWrapper ::
    WebViewIconLoadedCallback ->
    Ptr () ->
    CString ->
    Ptr () ->
    IO ()
webViewIconLoadedCallbackWrapper _cb _ icon_uri _ = do
    icon_uri' <- cstringToText icon_uri
    _cb  icon_uri'

onWebViewIconLoaded :: (GObject a, MonadIO m) => a -> WebViewIconLoadedCallback -> m SignalHandlerId
onWebViewIconLoaded obj cb = liftIO $ connectWebViewIconLoaded obj cb SignalConnectBefore
afterWebViewIconLoaded :: (GObject a, MonadIO m) => a -> WebViewIconLoadedCallback -> m SignalHandlerId
afterWebViewIconLoaded obj cb = connectWebViewIconLoaded obj cb SignalConnectAfter

connectWebViewIconLoaded :: (GObject a, MonadIO m) =>
                            a -> WebViewIconLoadedCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewIconLoaded obj cb after = liftIO $ do
    cb' <- mkWebViewIconLoadedCallback (webViewIconLoadedCallbackWrapper cb)
    connectSignalFunPtr obj "icon-loaded" cb' after

-- signal WebView::leaving-fullscreen
type WebViewLeavingFullscreenCallback =
    DOMHTMLElement ->
    IO Bool

noWebViewLeavingFullscreenCallback :: Maybe WebViewLeavingFullscreenCallback
noWebViewLeavingFullscreenCallback = Nothing

type WebViewLeavingFullscreenCallbackC =
    Ptr () ->                               -- object
    Ptr DOMHTMLElement ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mkWebViewLeavingFullscreenCallback :: WebViewLeavingFullscreenCallbackC -> IO (FunPtr WebViewLeavingFullscreenCallbackC)

webViewLeavingFullscreenClosure :: WebViewLeavingFullscreenCallback -> IO Closure
webViewLeavingFullscreenClosure cb = newCClosure =<< mkWebViewLeavingFullscreenCallback wrapped
    where wrapped = webViewLeavingFullscreenCallbackWrapper cb

webViewLeavingFullscreenCallbackWrapper ::
    WebViewLeavingFullscreenCallback ->
    Ptr () ->
    Ptr DOMHTMLElement ->
    Ptr () ->
    IO CInt
webViewLeavingFullscreenCallbackWrapper _cb _ element _ = do
    element' <- (newObject DOMHTMLElement) element
    result <- _cb  element'
    let result' = (fromIntegral . fromEnum) result
    return result'

onWebViewLeavingFullscreen :: (GObject a, MonadIO m) => a -> WebViewLeavingFullscreenCallback -> m SignalHandlerId
onWebViewLeavingFullscreen obj cb = liftIO $ connectWebViewLeavingFullscreen obj cb SignalConnectBefore
afterWebViewLeavingFullscreen :: (GObject a, MonadIO m) => a -> WebViewLeavingFullscreenCallback -> m SignalHandlerId
afterWebViewLeavingFullscreen obj cb = connectWebViewLeavingFullscreen obj cb SignalConnectAfter

connectWebViewLeavingFullscreen :: (GObject a, MonadIO m) =>
                                   a -> WebViewLeavingFullscreenCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewLeavingFullscreen obj cb after = liftIO $ do
    cb' <- mkWebViewLeavingFullscreenCallback (webViewLeavingFullscreenCallbackWrapper cb)
    connectSignalFunPtr obj "leaving-fullscreen" cb' after

-- signal WebView::load-committed
type WebViewLoadCommittedCallback =
    WebFrame ->
    IO ()

noWebViewLoadCommittedCallback :: Maybe WebViewLoadCommittedCallback
noWebViewLoadCommittedCallback = Nothing

type WebViewLoadCommittedCallbackC =
    Ptr () ->                               -- object
    Ptr WebFrame ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mkWebViewLoadCommittedCallback :: WebViewLoadCommittedCallbackC -> IO (FunPtr WebViewLoadCommittedCallbackC)

webViewLoadCommittedClosure :: WebViewLoadCommittedCallback -> IO Closure
webViewLoadCommittedClosure cb = newCClosure =<< mkWebViewLoadCommittedCallback wrapped
    where wrapped = webViewLoadCommittedCallbackWrapper cb

webViewLoadCommittedCallbackWrapper ::
    WebViewLoadCommittedCallback ->
    Ptr () ->
    Ptr WebFrame ->
    Ptr () ->
    IO ()
webViewLoadCommittedCallbackWrapper _cb _ frame _ = do
    frame' <- (newObject WebFrame) frame
    _cb  frame'

onWebViewLoadCommitted :: (GObject a, MonadIO m) => a -> WebViewLoadCommittedCallback -> m SignalHandlerId
onWebViewLoadCommitted obj cb = liftIO $ connectWebViewLoadCommitted obj cb SignalConnectBefore
afterWebViewLoadCommitted :: (GObject a, MonadIO m) => a -> WebViewLoadCommittedCallback -> m SignalHandlerId
afterWebViewLoadCommitted obj cb = connectWebViewLoadCommitted obj cb SignalConnectAfter

connectWebViewLoadCommitted :: (GObject a, MonadIO m) =>
                               a -> WebViewLoadCommittedCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewLoadCommitted obj cb after = liftIO $ do
    cb' <- mkWebViewLoadCommittedCallback (webViewLoadCommittedCallbackWrapper cb)
    connectSignalFunPtr obj "load-committed" cb' after

-- signal WebView::load-error
type WebViewLoadErrorCallback =
    WebFrame ->
    T.Text ->
    GError ->
    IO Bool

noWebViewLoadErrorCallback :: Maybe WebViewLoadErrorCallback
noWebViewLoadErrorCallback = Nothing

type WebViewLoadErrorCallbackC =
    Ptr () ->                               -- object
    Ptr WebFrame ->
    CString ->
    Ptr GError ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mkWebViewLoadErrorCallback :: WebViewLoadErrorCallbackC -> IO (FunPtr WebViewLoadErrorCallbackC)

webViewLoadErrorClosure :: WebViewLoadErrorCallback -> IO Closure
webViewLoadErrorClosure cb = newCClosure =<< mkWebViewLoadErrorCallback wrapped
    where wrapped = webViewLoadErrorCallbackWrapper cb

webViewLoadErrorCallbackWrapper ::
    WebViewLoadErrorCallback ->
    Ptr () ->
    Ptr WebFrame ->
    CString ->
    Ptr GError ->
    Ptr () ->
    IO CInt
webViewLoadErrorCallbackWrapper _cb _ web_frame uri web_error _ = do
    web_frame' <- (newObject WebFrame) web_frame
    uri' <- cstringToText uri
    web_error' <- (newBoxed GError) web_error
    result <- _cb  web_frame' uri' web_error'
    let result' = (fromIntegral . fromEnum) result
    return result'

onWebViewLoadError :: (GObject a, MonadIO m) => a -> WebViewLoadErrorCallback -> m SignalHandlerId
onWebViewLoadError obj cb = liftIO $ connectWebViewLoadError obj cb SignalConnectBefore
afterWebViewLoadError :: (GObject a, MonadIO m) => a -> WebViewLoadErrorCallback -> m SignalHandlerId
afterWebViewLoadError obj cb = connectWebViewLoadError obj cb SignalConnectAfter

connectWebViewLoadError :: (GObject a, MonadIO m) =>
                           a -> WebViewLoadErrorCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewLoadError obj cb after = liftIO $ do
    cb' <- mkWebViewLoadErrorCallback (webViewLoadErrorCallbackWrapper cb)
    connectSignalFunPtr obj "load-error" cb' after

-- signal WebView::load-finished
type WebViewLoadFinishedCallback =
    WebFrame ->
    IO ()

noWebViewLoadFinishedCallback :: Maybe WebViewLoadFinishedCallback
noWebViewLoadFinishedCallback = Nothing

type WebViewLoadFinishedCallbackC =
    Ptr () ->                               -- object
    Ptr WebFrame ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mkWebViewLoadFinishedCallback :: WebViewLoadFinishedCallbackC -> IO (FunPtr WebViewLoadFinishedCallbackC)

webViewLoadFinishedClosure :: WebViewLoadFinishedCallback -> IO Closure
webViewLoadFinishedClosure cb = newCClosure =<< mkWebViewLoadFinishedCallback wrapped
    where wrapped = webViewLoadFinishedCallbackWrapper cb

webViewLoadFinishedCallbackWrapper ::
    WebViewLoadFinishedCallback ->
    Ptr () ->
    Ptr WebFrame ->
    Ptr () ->
    IO ()
webViewLoadFinishedCallbackWrapper _cb _ frame _ = do
    frame' <- (newObject WebFrame) frame
    _cb  frame'

onWebViewLoadFinished :: (GObject a, MonadIO m) => a -> WebViewLoadFinishedCallback -> m SignalHandlerId
onWebViewLoadFinished obj cb = liftIO $ connectWebViewLoadFinished obj cb SignalConnectBefore
afterWebViewLoadFinished :: (GObject a, MonadIO m) => a -> WebViewLoadFinishedCallback -> m SignalHandlerId
afterWebViewLoadFinished obj cb = connectWebViewLoadFinished obj cb SignalConnectAfter

connectWebViewLoadFinished :: (GObject a, MonadIO m) =>
                              a -> WebViewLoadFinishedCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewLoadFinished obj cb after = liftIO $ do
    cb' <- mkWebViewLoadFinishedCallback (webViewLoadFinishedCallbackWrapper cb)
    connectSignalFunPtr obj "load-finished" cb' after

-- signal WebView::load-progress-changed
type WebViewLoadProgressChangedCallback =
    Int32 ->
    IO ()

noWebViewLoadProgressChangedCallback :: Maybe WebViewLoadProgressChangedCallback
noWebViewLoadProgressChangedCallback = Nothing

type WebViewLoadProgressChangedCallbackC =
    Ptr () ->                               -- object
    Int32 ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mkWebViewLoadProgressChangedCallback :: WebViewLoadProgressChangedCallbackC -> IO (FunPtr WebViewLoadProgressChangedCallbackC)

webViewLoadProgressChangedClosure :: WebViewLoadProgressChangedCallback -> IO Closure
webViewLoadProgressChangedClosure cb = newCClosure =<< mkWebViewLoadProgressChangedCallback wrapped
    where wrapped = webViewLoadProgressChangedCallbackWrapper cb

webViewLoadProgressChangedCallbackWrapper ::
    WebViewLoadProgressChangedCallback ->
    Ptr () ->
    Int32 ->
    Ptr () ->
    IO ()
webViewLoadProgressChangedCallbackWrapper _cb _ progress _ = do
    _cb  progress

onWebViewLoadProgressChanged :: (GObject a, MonadIO m) => a -> WebViewLoadProgressChangedCallback -> m SignalHandlerId
onWebViewLoadProgressChanged obj cb = liftIO $ connectWebViewLoadProgressChanged obj cb SignalConnectBefore
afterWebViewLoadProgressChanged :: (GObject a, MonadIO m) => a -> WebViewLoadProgressChangedCallback -> m SignalHandlerId
afterWebViewLoadProgressChanged obj cb = connectWebViewLoadProgressChanged obj cb SignalConnectAfter

connectWebViewLoadProgressChanged :: (GObject a, MonadIO m) =>
                                     a -> WebViewLoadProgressChangedCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewLoadProgressChanged obj cb after = liftIO $ do
    cb' <- mkWebViewLoadProgressChangedCallback (webViewLoadProgressChangedCallbackWrapper cb)
    connectSignalFunPtr obj "load-progress-changed" cb' after

-- signal WebView::load-started
type WebViewLoadStartedCallback =
    WebFrame ->
    IO ()

noWebViewLoadStartedCallback :: Maybe WebViewLoadStartedCallback
noWebViewLoadStartedCallback = Nothing

type WebViewLoadStartedCallbackC =
    Ptr () ->                               -- object
    Ptr WebFrame ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mkWebViewLoadStartedCallback :: WebViewLoadStartedCallbackC -> IO (FunPtr WebViewLoadStartedCallbackC)

webViewLoadStartedClosure :: WebViewLoadStartedCallback -> IO Closure
webViewLoadStartedClosure cb = newCClosure =<< mkWebViewLoadStartedCallback wrapped
    where wrapped = webViewLoadStartedCallbackWrapper cb

webViewLoadStartedCallbackWrapper ::
    WebViewLoadStartedCallback ->
    Ptr () ->
    Ptr WebFrame ->
    Ptr () ->
    IO ()
webViewLoadStartedCallbackWrapper _cb _ frame _ = do
    frame' <- (newObject WebFrame) frame
    _cb  frame'

onWebViewLoadStarted :: (GObject a, MonadIO m) => a -> WebViewLoadStartedCallback -> m SignalHandlerId
onWebViewLoadStarted obj cb = liftIO $ connectWebViewLoadStarted obj cb SignalConnectBefore
afterWebViewLoadStarted :: (GObject a, MonadIO m) => a -> WebViewLoadStartedCallback -> m SignalHandlerId
afterWebViewLoadStarted obj cb = connectWebViewLoadStarted obj cb SignalConnectAfter

connectWebViewLoadStarted :: (GObject a, MonadIO m) =>
                             a -> WebViewLoadStartedCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewLoadStarted obj cb after = liftIO $ do
    cb' <- mkWebViewLoadStartedCallback (webViewLoadStartedCallbackWrapper cb)
    connectSignalFunPtr obj "load-started" cb' after

-- signal WebView::mime-type-policy-decision-requested
type WebViewMimeTypePolicyDecisionRequestedCallback =
    WebFrame ->
    NetworkRequest ->
    T.Text ->
    WebPolicyDecision ->
    IO Bool

noWebViewMimeTypePolicyDecisionRequestedCallback :: Maybe WebViewMimeTypePolicyDecisionRequestedCallback
noWebViewMimeTypePolicyDecisionRequestedCallback = Nothing

type WebViewMimeTypePolicyDecisionRequestedCallbackC =
    Ptr () ->                               -- object
    Ptr WebFrame ->
    Ptr NetworkRequest ->
    CString ->
    Ptr WebPolicyDecision ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mkWebViewMimeTypePolicyDecisionRequestedCallback :: WebViewMimeTypePolicyDecisionRequestedCallbackC -> IO (FunPtr WebViewMimeTypePolicyDecisionRequestedCallbackC)

webViewMimeTypePolicyDecisionRequestedClosure :: WebViewMimeTypePolicyDecisionRequestedCallback -> IO Closure
webViewMimeTypePolicyDecisionRequestedClosure cb = newCClosure =<< mkWebViewMimeTypePolicyDecisionRequestedCallback wrapped
    where wrapped = webViewMimeTypePolicyDecisionRequestedCallbackWrapper cb

webViewMimeTypePolicyDecisionRequestedCallbackWrapper ::
    WebViewMimeTypePolicyDecisionRequestedCallback ->
    Ptr () ->
    Ptr WebFrame ->
    Ptr NetworkRequest ->
    CString ->
    Ptr WebPolicyDecision ->
    Ptr () ->
    IO CInt
webViewMimeTypePolicyDecisionRequestedCallbackWrapper _cb _ frame request mimetype policy_decision _ = do
    frame' <- (newObject WebFrame) frame
    request' <- (newObject NetworkRequest) request
    mimetype' <- cstringToText mimetype
    policy_decision' <- (newObject WebPolicyDecision) policy_decision
    result <- _cb  frame' request' mimetype' policy_decision'
    let result' = (fromIntegral . fromEnum) result
    return result'

onWebViewMimeTypePolicyDecisionRequested :: (GObject a, MonadIO m) => a -> WebViewMimeTypePolicyDecisionRequestedCallback -> m SignalHandlerId
onWebViewMimeTypePolicyDecisionRequested obj cb = liftIO $ connectWebViewMimeTypePolicyDecisionRequested obj cb SignalConnectBefore
afterWebViewMimeTypePolicyDecisionRequested :: (GObject a, MonadIO m) => a -> WebViewMimeTypePolicyDecisionRequestedCallback -> m SignalHandlerId
afterWebViewMimeTypePolicyDecisionRequested obj cb = connectWebViewMimeTypePolicyDecisionRequested obj cb SignalConnectAfter

connectWebViewMimeTypePolicyDecisionRequested :: (GObject a, MonadIO m) =>
                                                 a -> WebViewMimeTypePolicyDecisionRequestedCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewMimeTypePolicyDecisionRequested obj cb after = liftIO $ do
    cb' <- mkWebViewMimeTypePolicyDecisionRequestedCallback (webViewMimeTypePolicyDecisionRequestedCallbackWrapper cb)
    connectSignalFunPtr obj "mime-type-policy-decision-requested" cb' after

-- signal WebView::move-cursor
type WebViewMoveCursorCallback =
    Gtk.MovementStep ->
    Int32 ->
    IO Bool

noWebViewMoveCursorCallback :: Maybe WebViewMoveCursorCallback
noWebViewMoveCursorCallback = Nothing

type WebViewMoveCursorCallbackC =
    Ptr () ->                               -- object
    CUInt ->
    Int32 ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mkWebViewMoveCursorCallback :: WebViewMoveCursorCallbackC -> IO (FunPtr WebViewMoveCursorCallbackC)

webViewMoveCursorClosure :: WebViewMoveCursorCallback -> IO Closure
webViewMoveCursorClosure cb = newCClosure =<< mkWebViewMoveCursorCallback wrapped
    where wrapped = webViewMoveCursorCallbackWrapper cb

webViewMoveCursorCallbackWrapper ::
    WebViewMoveCursorCallback ->
    Ptr () ->
    CUInt ->
    Int32 ->
    Ptr () ->
    IO CInt
webViewMoveCursorCallbackWrapper _cb _ step count _ = do
    let step' = (toEnum . fromIntegral) step
    result <- _cb  step' count
    let result' = (fromIntegral . fromEnum) result
    return result'

onWebViewMoveCursor :: (GObject a, MonadIO m) => a -> WebViewMoveCursorCallback -> m SignalHandlerId
onWebViewMoveCursor obj cb = liftIO $ connectWebViewMoveCursor obj cb SignalConnectBefore
afterWebViewMoveCursor :: (GObject a, MonadIO m) => a -> WebViewMoveCursorCallback -> m SignalHandlerId
afterWebViewMoveCursor obj cb = connectWebViewMoveCursor obj cb SignalConnectAfter

connectWebViewMoveCursor :: (GObject a, MonadIO m) =>
                            a -> WebViewMoveCursorCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewMoveCursor obj cb after = liftIO $ do
    cb' <- mkWebViewMoveCursorCallback (webViewMoveCursorCallbackWrapper cb)
    connectSignalFunPtr obj "move-cursor" cb' after

-- signal WebView::navigation-policy-decision-requested
type WebViewNavigationPolicyDecisionRequestedCallback =
    WebFrame ->
    NetworkRequest ->
    WebNavigationAction ->
    WebPolicyDecision ->
    IO Bool

noWebViewNavigationPolicyDecisionRequestedCallback :: Maybe WebViewNavigationPolicyDecisionRequestedCallback
noWebViewNavigationPolicyDecisionRequestedCallback = Nothing

type WebViewNavigationPolicyDecisionRequestedCallbackC =
    Ptr () ->                               -- object
    Ptr WebFrame ->
    Ptr NetworkRequest ->
    Ptr WebNavigationAction ->
    Ptr WebPolicyDecision ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mkWebViewNavigationPolicyDecisionRequestedCallback :: WebViewNavigationPolicyDecisionRequestedCallbackC -> IO (FunPtr WebViewNavigationPolicyDecisionRequestedCallbackC)

webViewNavigationPolicyDecisionRequestedClosure :: WebViewNavigationPolicyDecisionRequestedCallback -> IO Closure
webViewNavigationPolicyDecisionRequestedClosure cb = newCClosure =<< mkWebViewNavigationPolicyDecisionRequestedCallback wrapped
    where wrapped = webViewNavigationPolicyDecisionRequestedCallbackWrapper cb

webViewNavigationPolicyDecisionRequestedCallbackWrapper ::
    WebViewNavigationPolicyDecisionRequestedCallback ->
    Ptr () ->
    Ptr WebFrame ->
    Ptr NetworkRequest ->
    Ptr WebNavigationAction ->
    Ptr WebPolicyDecision ->
    Ptr () ->
    IO CInt
webViewNavigationPolicyDecisionRequestedCallbackWrapper _cb _ frame request navigation_action policy_decision _ = do
    frame' <- (newObject WebFrame) frame
    request' <- (newObject NetworkRequest) request
    navigation_action' <- (newObject WebNavigationAction) navigation_action
    policy_decision' <- (newObject WebPolicyDecision) policy_decision
    result <- _cb  frame' request' navigation_action' policy_decision'
    let result' = (fromIntegral . fromEnum) result
    return result'

onWebViewNavigationPolicyDecisionRequested :: (GObject a, MonadIO m) => a -> WebViewNavigationPolicyDecisionRequestedCallback -> m SignalHandlerId
onWebViewNavigationPolicyDecisionRequested obj cb = liftIO $ connectWebViewNavigationPolicyDecisionRequested obj cb SignalConnectBefore
afterWebViewNavigationPolicyDecisionRequested :: (GObject a, MonadIO m) => a -> WebViewNavigationPolicyDecisionRequestedCallback -> m SignalHandlerId
afterWebViewNavigationPolicyDecisionRequested obj cb = connectWebViewNavigationPolicyDecisionRequested obj cb SignalConnectAfter

connectWebViewNavigationPolicyDecisionRequested :: (GObject a, MonadIO m) =>
                                                   a -> WebViewNavigationPolicyDecisionRequestedCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewNavigationPolicyDecisionRequested obj cb after = liftIO $ do
    cb' <- mkWebViewNavigationPolicyDecisionRequestedCallback (webViewNavigationPolicyDecisionRequestedCallbackWrapper cb)
    connectSignalFunPtr obj "navigation-policy-decision-requested" cb' after

-- signal WebView::navigation-requested
type WebViewNavigationRequestedCallback =
    WebFrame ->
    NetworkRequest ->
    IO NavigationResponse

noWebViewNavigationRequestedCallback :: Maybe WebViewNavigationRequestedCallback
noWebViewNavigationRequestedCallback = Nothing

type WebViewNavigationRequestedCallbackC =
    Ptr () ->                               -- object
    Ptr WebFrame ->
    Ptr NetworkRequest ->
    Ptr () ->                               -- user_data
    IO CUInt

foreign import ccall "wrapper"
    mkWebViewNavigationRequestedCallback :: WebViewNavigationRequestedCallbackC -> IO (FunPtr WebViewNavigationRequestedCallbackC)

webViewNavigationRequestedClosure :: WebViewNavigationRequestedCallback -> IO Closure
webViewNavigationRequestedClosure cb = newCClosure =<< mkWebViewNavigationRequestedCallback wrapped
    where wrapped = webViewNavigationRequestedCallbackWrapper cb

webViewNavigationRequestedCallbackWrapper ::
    WebViewNavigationRequestedCallback ->
    Ptr () ->
    Ptr WebFrame ->
    Ptr NetworkRequest ->
    Ptr () ->
    IO CUInt
webViewNavigationRequestedCallbackWrapper _cb _ frame request _ = do
    frame' <- (newObject WebFrame) frame
    request' <- (newObject NetworkRequest) request
    result <- _cb  frame' request'
    let result' = (fromIntegral . fromEnum) result
    return result'

onWebViewNavigationRequested :: (GObject a, MonadIO m) => a -> WebViewNavigationRequestedCallback -> m SignalHandlerId
onWebViewNavigationRequested obj cb = liftIO $ connectWebViewNavigationRequested obj cb SignalConnectBefore
afterWebViewNavigationRequested :: (GObject a, MonadIO m) => a -> WebViewNavigationRequestedCallback -> m SignalHandlerId
afterWebViewNavigationRequested obj cb = connectWebViewNavigationRequested obj cb SignalConnectAfter

connectWebViewNavigationRequested :: (GObject a, MonadIO m) =>
                                     a -> WebViewNavigationRequestedCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewNavigationRequested obj cb after = liftIO $ do
    cb' <- mkWebViewNavigationRequestedCallback (webViewNavigationRequestedCallbackWrapper cb)
    connectSignalFunPtr obj "navigation-requested" cb' after

-- signal WebView::new-window-policy-decision-requested
type WebViewNewWindowPolicyDecisionRequestedCallback =
    WebFrame ->
    NetworkRequest ->
    WebNavigationAction ->
    WebPolicyDecision ->
    IO Bool

noWebViewNewWindowPolicyDecisionRequestedCallback :: Maybe WebViewNewWindowPolicyDecisionRequestedCallback
noWebViewNewWindowPolicyDecisionRequestedCallback = Nothing

type WebViewNewWindowPolicyDecisionRequestedCallbackC =
    Ptr () ->                               -- object
    Ptr WebFrame ->
    Ptr NetworkRequest ->
    Ptr WebNavigationAction ->
    Ptr WebPolicyDecision ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mkWebViewNewWindowPolicyDecisionRequestedCallback :: WebViewNewWindowPolicyDecisionRequestedCallbackC -> IO (FunPtr WebViewNewWindowPolicyDecisionRequestedCallbackC)

webViewNewWindowPolicyDecisionRequestedClosure :: WebViewNewWindowPolicyDecisionRequestedCallback -> IO Closure
webViewNewWindowPolicyDecisionRequestedClosure cb = newCClosure =<< mkWebViewNewWindowPolicyDecisionRequestedCallback wrapped
    where wrapped = webViewNewWindowPolicyDecisionRequestedCallbackWrapper cb

webViewNewWindowPolicyDecisionRequestedCallbackWrapper ::
    WebViewNewWindowPolicyDecisionRequestedCallback ->
    Ptr () ->
    Ptr WebFrame ->
    Ptr NetworkRequest ->
    Ptr WebNavigationAction ->
    Ptr WebPolicyDecision ->
    Ptr () ->
    IO CInt
webViewNewWindowPolicyDecisionRequestedCallbackWrapper _cb _ frame request navigation_action policy_decision _ = do
    frame' <- (newObject WebFrame) frame
    request' <- (newObject NetworkRequest) request
    navigation_action' <- (newObject WebNavigationAction) navigation_action
    policy_decision' <- (newObject WebPolicyDecision) policy_decision
    result <- _cb  frame' request' navigation_action' policy_decision'
    let result' = (fromIntegral . fromEnum) result
    return result'

onWebViewNewWindowPolicyDecisionRequested :: (GObject a, MonadIO m) => a -> WebViewNewWindowPolicyDecisionRequestedCallback -> m SignalHandlerId
onWebViewNewWindowPolicyDecisionRequested obj cb = liftIO $ connectWebViewNewWindowPolicyDecisionRequested obj cb SignalConnectBefore
afterWebViewNewWindowPolicyDecisionRequested :: (GObject a, MonadIO m) => a -> WebViewNewWindowPolicyDecisionRequestedCallback -> m SignalHandlerId
afterWebViewNewWindowPolicyDecisionRequested obj cb = connectWebViewNewWindowPolicyDecisionRequested obj cb SignalConnectAfter

connectWebViewNewWindowPolicyDecisionRequested :: (GObject a, MonadIO m) =>
                                                  a -> WebViewNewWindowPolicyDecisionRequestedCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewNewWindowPolicyDecisionRequested obj cb after = liftIO $ do
    cb' <- mkWebViewNewWindowPolicyDecisionRequestedCallback (webViewNewWindowPolicyDecisionRequestedCallbackWrapper cb)
    connectSignalFunPtr obj "new-window-policy-decision-requested" cb' after

-- signal WebView::onload-event
type WebViewOnloadEventCallback =
    WebFrame ->
    IO ()

noWebViewOnloadEventCallback :: Maybe WebViewOnloadEventCallback
noWebViewOnloadEventCallback = Nothing

type WebViewOnloadEventCallbackC =
    Ptr () ->                               -- object
    Ptr WebFrame ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mkWebViewOnloadEventCallback :: WebViewOnloadEventCallbackC -> IO (FunPtr WebViewOnloadEventCallbackC)

webViewOnloadEventClosure :: WebViewOnloadEventCallback -> IO Closure
webViewOnloadEventClosure cb = newCClosure =<< mkWebViewOnloadEventCallback wrapped
    where wrapped = webViewOnloadEventCallbackWrapper cb

webViewOnloadEventCallbackWrapper ::
    WebViewOnloadEventCallback ->
    Ptr () ->
    Ptr WebFrame ->
    Ptr () ->
    IO ()
webViewOnloadEventCallbackWrapper _cb _ frame _ = do
    frame' <- (newObject WebFrame) frame
    _cb  frame'

onWebViewOnloadEvent :: (GObject a, MonadIO m) => a -> WebViewOnloadEventCallback -> m SignalHandlerId
onWebViewOnloadEvent obj cb = liftIO $ connectWebViewOnloadEvent obj cb SignalConnectBefore
afterWebViewOnloadEvent :: (GObject a, MonadIO m) => a -> WebViewOnloadEventCallback -> m SignalHandlerId
afterWebViewOnloadEvent obj cb = connectWebViewOnloadEvent obj cb SignalConnectAfter

connectWebViewOnloadEvent :: (GObject a, MonadIO m) =>
                             a -> WebViewOnloadEventCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewOnloadEvent obj cb after = liftIO $ do
    cb' <- mkWebViewOnloadEventCallback (webViewOnloadEventCallbackWrapper cb)
    connectSignalFunPtr obj "onload-event" cb' after

-- signal WebView::paste-clipboard
type WebViewPasteClipboardCallback =
    IO ()

noWebViewPasteClipboardCallback :: Maybe WebViewPasteClipboardCallback
noWebViewPasteClipboardCallback = Nothing

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

foreign import ccall "wrapper"
    mkWebViewPasteClipboardCallback :: WebViewPasteClipboardCallbackC -> IO (FunPtr WebViewPasteClipboardCallbackC)

webViewPasteClipboardClosure :: WebViewPasteClipboardCallback -> IO Closure
webViewPasteClipboardClosure cb = newCClosure =<< mkWebViewPasteClipboardCallback wrapped
    where wrapped = webViewPasteClipboardCallbackWrapper cb

webViewPasteClipboardCallbackWrapper ::
    WebViewPasteClipboardCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
webViewPasteClipboardCallbackWrapper _cb _ _ = do
    _cb 

onWebViewPasteClipboard :: (GObject a, MonadIO m) => a -> WebViewPasteClipboardCallback -> m SignalHandlerId
onWebViewPasteClipboard obj cb = liftIO $ connectWebViewPasteClipboard obj cb SignalConnectBefore
afterWebViewPasteClipboard :: (GObject a, MonadIO m) => a -> WebViewPasteClipboardCallback -> m SignalHandlerId
afterWebViewPasteClipboard obj cb = connectWebViewPasteClipboard obj cb SignalConnectAfter

connectWebViewPasteClipboard :: (GObject a, MonadIO m) =>
                                a -> WebViewPasteClipboardCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewPasteClipboard obj cb after = liftIO $ do
    cb' <- mkWebViewPasteClipboardCallback (webViewPasteClipboardCallbackWrapper cb)
    connectSignalFunPtr obj "paste-clipboard" cb' after

-- signal WebView::populate-popup
type WebViewPopulatePopupCallback =
    Gtk.Menu ->
    IO ()

noWebViewPopulatePopupCallback :: Maybe WebViewPopulatePopupCallback
noWebViewPopulatePopupCallback = Nothing

type WebViewPopulatePopupCallbackC =
    Ptr () ->                               -- object
    Ptr Gtk.Menu ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mkWebViewPopulatePopupCallback :: WebViewPopulatePopupCallbackC -> IO (FunPtr WebViewPopulatePopupCallbackC)

webViewPopulatePopupClosure :: WebViewPopulatePopupCallback -> IO Closure
webViewPopulatePopupClosure cb = newCClosure =<< mkWebViewPopulatePopupCallback wrapped
    where wrapped = webViewPopulatePopupCallbackWrapper cb

webViewPopulatePopupCallbackWrapper ::
    WebViewPopulatePopupCallback ->
    Ptr () ->
    Ptr Gtk.Menu ->
    Ptr () ->
    IO ()
webViewPopulatePopupCallbackWrapper _cb _ menu _ = do
    menu' <- (newObject Gtk.Menu) menu
    _cb  menu'

onWebViewPopulatePopup :: (GObject a, MonadIO m) => a -> WebViewPopulatePopupCallback -> m SignalHandlerId
onWebViewPopulatePopup obj cb = liftIO $ connectWebViewPopulatePopup obj cb SignalConnectBefore
afterWebViewPopulatePopup :: (GObject a, MonadIO m) => a -> WebViewPopulatePopupCallback -> m SignalHandlerId
afterWebViewPopulatePopup obj cb = connectWebViewPopulatePopup obj cb SignalConnectAfter

connectWebViewPopulatePopup :: (GObject a, MonadIO m) =>
                               a -> WebViewPopulatePopupCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewPopulatePopup obj cb after = liftIO $ do
    cb' <- mkWebViewPopulatePopupCallback (webViewPopulatePopupCallbackWrapper cb)
    connectSignalFunPtr obj "populate-popup" cb' after

-- signal WebView::print-requested
type WebViewPrintRequestedCallback =
    WebFrame ->
    IO Bool

noWebViewPrintRequestedCallback :: Maybe WebViewPrintRequestedCallback
noWebViewPrintRequestedCallback = Nothing

type WebViewPrintRequestedCallbackC =
    Ptr () ->                               -- object
    Ptr WebFrame ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mkWebViewPrintRequestedCallback :: WebViewPrintRequestedCallbackC -> IO (FunPtr WebViewPrintRequestedCallbackC)

webViewPrintRequestedClosure :: WebViewPrintRequestedCallback -> IO Closure
webViewPrintRequestedClosure cb = newCClosure =<< mkWebViewPrintRequestedCallback wrapped
    where wrapped = webViewPrintRequestedCallbackWrapper cb

webViewPrintRequestedCallbackWrapper ::
    WebViewPrintRequestedCallback ->
    Ptr () ->
    Ptr WebFrame ->
    Ptr () ->
    IO CInt
webViewPrintRequestedCallbackWrapper _cb _ web_frame _ = do
    web_frame' <- (newObject WebFrame) web_frame
    result <- _cb  web_frame'
    let result' = (fromIntegral . fromEnum) result
    return result'

onWebViewPrintRequested :: (GObject a, MonadIO m) => a -> WebViewPrintRequestedCallback -> m SignalHandlerId
onWebViewPrintRequested obj cb = liftIO $ connectWebViewPrintRequested obj cb SignalConnectBefore
afterWebViewPrintRequested :: (GObject a, MonadIO m) => a -> WebViewPrintRequestedCallback -> m SignalHandlerId
afterWebViewPrintRequested obj cb = connectWebViewPrintRequested obj cb SignalConnectAfter

connectWebViewPrintRequested :: (GObject a, MonadIO m) =>
                                a -> WebViewPrintRequestedCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewPrintRequested obj cb after = liftIO $ do
    cb' <- mkWebViewPrintRequestedCallback (webViewPrintRequestedCallbackWrapper cb)
    connectSignalFunPtr obj "print-requested" cb' after

-- signal WebView::redo
type WebViewRedoCallback =
    IO ()

noWebViewRedoCallback :: Maybe WebViewRedoCallback
noWebViewRedoCallback = Nothing

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

foreign import ccall "wrapper"
    mkWebViewRedoCallback :: WebViewRedoCallbackC -> IO (FunPtr WebViewRedoCallbackC)

webViewRedoClosure :: WebViewRedoCallback -> IO Closure
webViewRedoClosure cb = newCClosure =<< mkWebViewRedoCallback wrapped
    where wrapped = webViewRedoCallbackWrapper cb

webViewRedoCallbackWrapper ::
    WebViewRedoCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
webViewRedoCallbackWrapper _cb _ _ = do
    _cb 

onWebViewRedo :: (GObject a, MonadIO m) => a -> WebViewRedoCallback -> m SignalHandlerId
onWebViewRedo obj cb = liftIO $ connectWebViewRedo obj cb SignalConnectBefore
afterWebViewRedo :: (GObject a, MonadIO m) => a -> WebViewRedoCallback -> m SignalHandlerId
afterWebViewRedo obj cb = connectWebViewRedo obj cb SignalConnectAfter

connectWebViewRedo :: (GObject a, MonadIO m) =>
                      a -> WebViewRedoCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewRedo obj cb after = liftIO $ do
    cb' <- mkWebViewRedoCallback (webViewRedoCallbackWrapper cb)
    connectSignalFunPtr obj "redo" cb' after

-- signal WebView::resource-content-length-received
type WebViewResourceContentLengthReceivedCallback =
    WebFrame ->
    WebResource ->
    Int32 ->
    IO ()

noWebViewResourceContentLengthReceivedCallback :: Maybe WebViewResourceContentLengthReceivedCallback
noWebViewResourceContentLengthReceivedCallback = Nothing

type WebViewResourceContentLengthReceivedCallbackC =
    Ptr () ->                               -- object
    Ptr WebFrame ->
    Ptr WebResource ->
    Int32 ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mkWebViewResourceContentLengthReceivedCallback :: WebViewResourceContentLengthReceivedCallbackC -> IO (FunPtr WebViewResourceContentLengthReceivedCallbackC)

webViewResourceContentLengthReceivedClosure :: WebViewResourceContentLengthReceivedCallback -> IO Closure
webViewResourceContentLengthReceivedClosure cb = newCClosure =<< mkWebViewResourceContentLengthReceivedCallback wrapped
    where wrapped = webViewResourceContentLengthReceivedCallbackWrapper cb

webViewResourceContentLengthReceivedCallbackWrapper ::
    WebViewResourceContentLengthReceivedCallback ->
    Ptr () ->
    Ptr WebFrame ->
    Ptr WebResource ->
    Int32 ->
    Ptr () ->
    IO ()
webViewResourceContentLengthReceivedCallbackWrapper _cb _ web_frame web_resource length_received _ = do
    web_frame' <- (newObject WebFrame) web_frame
    web_resource' <- (newObject WebResource) web_resource
    _cb  web_frame' web_resource' length_received

onWebViewResourceContentLengthReceived :: (GObject a, MonadIO m) => a -> WebViewResourceContentLengthReceivedCallback -> m SignalHandlerId
onWebViewResourceContentLengthReceived obj cb = liftIO $ connectWebViewResourceContentLengthReceived obj cb SignalConnectBefore
afterWebViewResourceContentLengthReceived :: (GObject a, MonadIO m) => a -> WebViewResourceContentLengthReceivedCallback -> m SignalHandlerId
afterWebViewResourceContentLengthReceived obj cb = connectWebViewResourceContentLengthReceived obj cb SignalConnectAfter

connectWebViewResourceContentLengthReceived :: (GObject a, MonadIO m) =>
                                               a -> WebViewResourceContentLengthReceivedCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewResourceContentLengthReceived obj cb after = liftIO $ do
    cb' <- mkWebViewResourceContentLengthReceivedCallback (webViewResourceContentLengthReceivedCallbackWrapper cb)
    connectSignalFunPtr obj "resource-content-length-received" cb' after

-- signal WebView::resource-load-failed
type WebViewResourceLoadFailedCallback =
    WebFrame ->
    WebResource ->
    GError ->
    IO ()

noWebViewResourceLoadFailedCallback :: Maybe WebViewResourceLoadFailedCallback
noWebViewResourceLoadFailedCallback = Nothing

type WebViewResourceLoadFailedCallbackC =
    Ptr () ->                               -- object
    Ptr WebFrame ->
    Ptr WebResource ->
    Ptr GError ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mkWebViewResourceLoadFailedCallback :: WebViewResourceLoadFailedCallbackC -> IO (FunPtr WebViewResourceLoadFailedCallbackC)

webViewResourceLoadFailedClosure :: WebViewResourceLoadFailedCallback -> IO Closure
webViewResourceLoadFailedClosure cb = newCClosure =<< mkWebViewResourceLoadFailedCallback wrapped
    where wrapped = webViewResourceLoadFailedCallbackWrapper cb

webViewResourceLoadFailedCallbackWrapper ::
    WebViewResourceLoadFailedCallback ->
    Ptr () ->
    Ptr WebFrame ->
    Ptr WebResource ->
    Ptr GError ->
    Ptr () ->
    IO ()
webViewResourceLoadFailedCallbackWrapper _cb _ web_frame web_resource error_ _ = do
    web_frame' <- (newObject WebFrame) web_frame
    web_resource' <- (newObject WebResource) web_resource
    error_' <- (newBoxed GError) error_
    _cb  web_frame' web_resource' error_'

onWebViewResourceLoadFailed :: (GObject a, MonadIO m) => a -> WebViewResourceLoadFailedCallback -> m SignalHandlerId
onWebViewResourceLoadFailed obj cb = liftIO $ connectWebViewResourceLoadFailed obj cb SignalConnectBefore
afterWebViewResourceLoadFailed :: (GObject a, MonadIO m) => a -> WebViewResourceLoadFailedCallback -> m SignalHandlerId
afterWebViewResourceLoadFailed obj cb = connectWebViewResourceLoadFailed obj cb SignalConnectAfter

connectWebViewResourceLoadFailed :: (GObject a, MonadIO m) =>
                                    a -> WebViewResourceLoadFailedCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewResourceLoadFailed obj cb after = liftIO $ do
    cb' <- mkWebViewResourceLoadFailedCallback (webViewResourceLoadFailedCallbackWrapper cb)
    connectSignalFunPtr obj "resource-load-failed" cb' after

-- signal WebView::resource-load-finished
type WebViewResourceLoadFinishedCallback =
    WebFrame ->
    WebResource ->
    IO ()

noWebViewResourceLoadFinishedCallback :: Maybe WebViewResourceLoadFinishedCallback
noWebViewResourceLoadFinishedCallback = Nothing

type WebViewResourceLoadFinishedCallbackC =
    Ptr () ->                               -- object
    Ptr WebFrame ->
    Ptr WebResource ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mkWebViewResourceLoadFinishedCallback :: WebViewResourceLoadFinishedCallbackC -> IO (FunPtr WebViewResourceLoadFinishedCallbackC)

webViewResourceLoadFinishedClosure :: WebViewResourceLoadFinishedCallback -> IO Closure
webViewResourceLoadFinishedClosure cb = newCClosure =<< mkWebViewResourceLoadFinishedCallback wrapped
    where wrapped = webViewResourceLoadFinishedCallbackWrapper cb

webViewResourceLoadFinishedCallbackWrapper ::
    WebViewResourceLoadFinishedCallback ->
    Ptr () ->
    Ptr WebFrame ->
    Ptr WebResource ->
    Ptr () ->
    IO ()
webViewResourceLoadFinishedCallbackWrapper _cb _ web_frame web_resource _ = do
    web_frame' <- (newObject WebFrame) web_frame
    web_resource' <- (newObject WebResource) web_resource
    _cb  web_frame' web_resource'

onWebViewResourceLoadFinished :: (GObject a, MonadIO m) => a -> WebViewResourceLoadFinishedCallback -> m SignalHandlerId
onWebViewResourceLoadFinished obj cb = liftIO $ connectWebViewResourceLoadFinished obj cb SignalConnectBefore
afterWebViewResourceLoadFinished :: (GObject a, MonadIO m) => a -> WebViewResourceLoadFinishedCallback -> m SignalHandlerId
afterWebViewResourceLoadFinished obj cb = connectWebViewResourceLoadFinished obj cb SignalConnectAfter

connectWebViewResourceLoadFinished :: (GObject a, MonadIO m) =>
                                      a -> WebViewResourceLoadFinishedCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewResourceLoadFinished obj cb after = liftIO $ do
    cb' <- mkWebViewResourceLoadFinishedCallback (webViewResourceLoadFinishedCallbackWrapper cb)
    connectSignalFunPtr obj "resource-load-finished" cb' after

-- signal WebView::resource-request-starting
type WebViewResourceRequestStartingCallback =
    WebFrame ->
    WebResource ->
    NetworkRequest ->
    NetworkResponse ->
    IO ()

noWebViewResourceRequestStartingCallback :: Maybe WebViewResourceRequestStartingCallback
noWebViewResourceRequestStartingCallback = Nothing

type WebViewResourceRequestStartingCallbackC =
    Ptr () ->                               -- object
    Ptr WebFrame ->
    Ptr WebResource ->
    Ptr NetworkRequest ->
    Ptr NetworkResponse ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mkWebViewResourceRequestStartingCallback :: WebViewResourceRequestStartingCallbackC -> IO (FunPtr WebViewResourceRequestStartingCallbackC)

webViewResourceRequestStartingClosure :: WebViewResourceRequestStartingCallback -> IO Closure
webViewResourceRequestStartingClosure cb = newCClosure =<< mkWebViewResourceRequestStartingCallback wrapped
    where wrapped = webViewResourceRequestStartingCallbackWrapper cb

webViewResourceRequestStartingCallbackWrapper ::
    WebViewResourceRequestStartingCallback ->
    Ptr () ->
    Ptr WebFrame ->
    Ptr WebResource ->
    Ptr NetworkRequest ->
    Ptr NetworkResponse ->
    Ptr () ->
    IO ()
webViewResourceRequestStartingCallbackWrapper _cb _ web_frame web_resource request response _ = do
    web_frame' <- (newObject WebFrame) web_frame
    web_resource' <- (newObject WebResource) web_resource
    request' <- (newObject NetworkRequest) request
    response' <- (newObject NetworkResponse) response
    _cb  web_frame' web_resource' request' response'

onWebViewResourceRequestStarting :: (GObject a, MonadIO m) => a -> WebViewResourceRequestStartingCallback -> m SignalHandlerId
onWebViewResourceRequestStarting obj cb = liftIO $ connectWebViewResourceRequestStarting obj cb SignalConnectBefore
afterWebViewResourceRequestStarting :: (GObject a, MonadIO m) => a -> WebViewResourceRequestStartingCallback -> m SignalHandlerId
afterWebViewResourceRequestStarting obj cb = connectWebViewResourceRequestStarting obj cb SignalConnectAfter

connectWebViewResourceRequestStarting :: (GObject a, MonadIO m) =>
                                         a -> WebViewResourceRequestStartingCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewResourceRequestStarting obj cb after = liftIO $ do
    cb' <- mkWebViewResourceRequestStartingCallback (webViewResourceRequestStartingCallbackWrapper cb)
    connectSignalFunPtr obj "resource-request-starting" cb' after

-- signal WebView::resource-response-received
type WebViewResourceResponseReceivedCallback =
    WebFrame ->
    WebResource ->
    NetworkResponse ->
    IO ()

noWebViewResourceResponseReceivedCallback :: Maybe WebViewResourceResponseReceivedCallback
noWebViewResourceResponseReceivedCallback = Nothing

type WebViewResourceResponseReceivedCallbackC =
    Ptr () ->                               -- object
    Ptr WebFrame ->
    Ptr WebResource ->
    Ptr NetworkResponse ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mkWebViewResourceResponseReceivedCallback :: WebViewResourceResponseReceivedCallbackC -> IO (FunPtr WebViewResourceResponseReceivedCallbackC)

webViewResourceResponseReceivedClosure :: WebViewResourceResponseReceivedCallback -> IO Closure
webViewResourceResponseReceivedClosure cb = newCClosure =<< mkWebViewResourceResponseReceivedCallback wrapped
    where wrapped = webViewResourceResponseReceivedCallbackWrapper cb

webViewResourceResponseReceivedCallbackWrapper ::
    WebViewResourceResponseReceivedCallback ->
    Ptr () ->
    Ptr WebFrame ->
    Ptr WebResource ->
    Ptr NetworkResponse ->
    Ptr () ->
    IO ()
webViewResourceResponseReceivedCallbackWrapper _cb _ web_frame web_resource response _ = do
    web_frame' <- (newObject WebFrame) web_frame
    web_resource' <- (newObject WebResource) web_resource
    response' <- (newObject NetworkResponse) response
    _cb  web_frame' web_resource' response'

onWebViewResourceResponseReceived :: (GObject a, MonadIO m) => a -> WebViewResourceResponseReceivedCallback -> m SignalHandlerId
onWebViewResourceResponseReceived obj cb = liftIO $ connectWebViewResourceResponseReceived obj cb SignalConnectBefore
afterWebViewResourceResponseReceived :: (GObject a, MonadIO m) => a -> WebViewResourceResponseReceivedCallback -> m SignalHandlerId
afterWebViewResourceResponseReceived obj cb = connectWebViewResourceResponseReceived obj cb SignalConnectAfter

connectWebViewResourceResponseReceived :: (GObject a, MonadIO m) =>
                                          a -> WebViewResourceResponseReceivedCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewResourceResponseReceived obj cb after = liftIO $ do
    cb' <- mkWebViewResourceResponseReceivedCallback (webViewResourceResponseReceivedCallbackWrapper cb)
    connectSignalFunPtr obj "resource-response-received" cb' after

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

noWebViewRunFileChooserCallback :: Maybe WebViewRunFileChooserCallback
noWebViewRunFileChooserCallback = Nothing

type WebViewRunFileChooserCallbackC =
    Ptr () ->                               -- object
    Ptr FileChooserRequest ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mkWebViewRunFileChooserCallback :: WebViewRunFileChooserCallbackC -> IO (FunPtr WebViewRunFileChooserCallbackC)

webViewRunFileChooserClosure :: WebViewRunFileChooserCallback -> IO Closure
webViewRunFileChooserClosure cb = newCClosure =<< mkWebViewRunFileChooserCallback wrapped
    where wrapped = webViewRunFileChooserCallbackWrapper cb

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

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

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

-- signal WebView::script-alert
type WebViewScriptAlertCallback =
    WebFrame ->
    T.Text ->
    IO Bool

noWebViewScriptAlertCallback :: Maybe WebViewScriptAlertCallback
noWebViewScriptAlertCallback = Nothing

type WebViewScriptAlertCallbackC =
    Ptr () ->                               -- object
    Ptr WebFrame ->
    CString ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mkWebViewScriptAlertCallback :: WebViewScriptAlertCallbackC -> IO (FunPtr WebViewScriptAlertCallbackC)

webViewScriptAlertClosure :: WebViewScriptAlertCallback -> IO Closure
webViewScriptAlertClosure cb = newCClosure =<< mkWebViewScriptAlertCallback wrapped
    where wrapped = webViewScriptAlertCallbackWrapper cb

webViewScriptAlertCallbackWrapper ::
    WebViewScriptAlertCallback ->
    Ptr () ->
    Ptr WebFrame ->
    CString ->
    Ptr () ->
    IO CInt
webViewScriptAlertCallbackWrapper _cb _ frame message _ = do
    frame' <- (newObject WebFrame) frame
    message' <- cstringToText message
    result <- _cb  frame' message'
    let result' = (fromIntegral . fromEnum) result
    return result'

onWebViewScriptAlert :: (GObject a, MonadIO m) => a -> WebViewScriptAlertCallback -> m SignalHandlerId
onWebViewScriptAlert obj cb = liftIO $ connectWebViewScriptAlert obj cb SignalConnectBefore
afterWebViewScriptAlert :: (GObject a, MonadIO m) => a -> WebViewScriptAlertCallback -> m SignalHandlerId
afterWebViewScriptAlert obj cb = connectWebViewScriptAlert obj cb SignalConnectAfter

connectWebViewScriptAlert :: (GObject a, MonadIO m) =>
                             a -> WebViewScriptAlertCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewScriptAlert obj cb after = liftIO $ do
    cb' <- mkWebViewScriptAlertCallback (webViewScriptAlertCallbackWrapper cb)
    connectSignalFunPtr obj "script-alert" cb' after

-- signal WebView::script-confirm
type WebViewScriptConfirmCallback =
    WebFrame ->
    T.Text ->
    Ptr () ->
    IO Bool

noWebViewScriptConfirmCallback :: Maybe WebViewScriptConfirmCallback
noWebViewScriptConfirmCallback = Nothing

type WebViewScriptConfirmCallbackC =
    Ptr () ->                               -- object
    Ptr WebFrame ->
    CString ->
    Ptr () ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mkWebViewScriptConfirmCallback :: WebViewScriptConfirmCallbackC -> IO (FunPtr WebViewScriptConfirmCallbackC)

webViewScriptConfirmClosure :: WebViewScriptConfirmCallback -> IO Closure
webViewScriptConfirmClosure cb = newCClosure =<< mkWebViewScriptConfirmCallback wrapped
    where wrapped = webViewScriptConfirmCallbackWrapper cb

webViewScriptConfirmCallbackWrapper ::
    WebViewScriptConfirmCallback ->
    Ptr () ->
    Ptr WebFrame ->
    CString ->
    Ptr () ->
    Ptr () ->
    IO CInt
webViewScriptConfirmCallbackWrapper _cb _ frame message confirmed _ = do
    frame' <- (newObject WebFrame) frame
    message' <- cstringToText message
    result <- _cb  frame' message' confirmed
    let result' = (fromIntegral . fromEnum) result
    return result'

onWebViewScriptConfirm :: (GObject a, MonadIO m) => a -> WebViewScriptConfirmCallback -> m SignalHandlerId
onWebViewScriptConfirm obj cb = liftIO $ connectWebViewScriptConfirm obj cb SignalConnectBefore
afterWebViewScriptConfirm :: (GObject a, MonadIO m) => a -> WebViewScriptConfirmCallback -> m SignalHandlerId
afterWebViewScriptConfirm obj cb = connectWebViewScriptConfirm obj cb SignalConnectAfter

connectWebViewScriptConfirm :: (GObject a, MonadIO m) =>
                               a -> WebViewScriptConfirmCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewScriptConfirm obj cb after = liftIO $ do
    cb' <- mkWebViewScriptConfirmCallback (webViewScriptConfirmCallbackWrapper cb)
    connectSignalFunPtr obj "script-confirm" cb' after

-- signal WebView::script-prompt
type WebViewScriptPromptCallback =
    WebFrame ->
    T.Text ->
    T.Text ->
    Ptr () ->
    IO Bool

noWebViewScriptPromptCallback :: Maybe WebViewScriptPromptCallback
noWebViewScriptPromptCallback = Nothing

type WebViewScriptPromptCallbackC =
    Ptr () ->                               -- object
    Ptr WebFrame ->
    CString ->
    CString ->
    Ptr () ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mkWebViewScriptPromptCallback :: WebViewScriptPromptCallbackC -> IO (FunPtr WebViewScriptPromptCallbackC)

webViewScriptPromptClosure :: WebViewScriptPromptCallback -> IO Closure
webViewScriptPromptClosure cb = newCClosure =<< mkWebViewScriptPromptCallback wrapped
    where wrapped = webViewScriptPromptCallbackWrapper cb

webViewScriptPromptCallbackWrapper ::
    WebViewScriptPromptCallback ->
    Ptr () ->
    Ptr WebFrame ->
    CString ->
    CString ->
    Ptr () ->
    Ptr () ->
    IO CInt
webViewScriptPromptCallbackWrapper _cb _ frame message default_ text _ = do
    frame' <- (newObject WebFrame) frame
    message' <- cstringToText message
    default_' <- cstringToText default_
    result <- _cb  frame' message' default_' text
    let result' = (fromIntegral . fromEnum) result
    return result'

onWebViewScriptPrompt :: (GObject a, MonadIO m) => a -> WebViewScriptPromptCallback -> m SignalHandlerId
onWebViewScriptPrompt obj cb = liftIO $ connectWebViewScriptPrompt obj cb SignalConnectBefore
afterWebViewScriptPrompt :: (GObject a, MonadIO m) => a -> WebViewScriptPromptCallback -> m SignalHandlerId
afterWebViewScriptPrompt obj cb = connectWebViewScriptPrompt obj cb SignalConnectAfter

connectWebViewScriptPrompt :: (GObject a, MonadIO m) =>
                              a -> WebViewScriptPromptCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewScriptPrompt obj cb after = liftIO $ do
    cb' <- mkWebViewScriptPromptCallback (webViewScriptPromptCallbackWrapper cb)
    connectSignalFunPtr obj "script-prompt" cb' after

-- signal WebView::select-all
type WebViewSelectAllCallback =
    IO ()

noWebViewSelectAllCallback :: Maybe WebViewSelectAllCallback
noWebViewSelectAllCallback = Nothing

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

foreign import ccall "wrapper"
    mkWebViewSelectAllCallback :: WebViewSelectAllCallbackC -> IO (FunPtr WebViewSelectAllCallbackC)

webViewSelectAllClosure :: WebViewSelectAllCallback -> IO Closure
webViewSelectAllClosure cb = newCClosure =<< mkWebViewSelectAllCallback wrapped
    where wrapped = webViewSelectAllCallbackWrapper cb

webViewSelectAllCallbackWrapper ::
    WebViewSelectAllCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
webViewSelectAllCallbackWrapper _cb _ _ = do
    _cb 

onWebViewSelectAll :: (GObject a, MonadIO m) => a -> WebViewSelectAllCallback -> m SignalHandlerId
onWebViewSelectAll obj cb = liftIO $ connectWebViewSelectAll obj cb SignalConnectBefore
afterWebViewSelectAll :: (GObject a, MonadIO m) => a -> WebViewSelectAllCallback -> m SignalHandlerId
afterWebViewSelectAll obj cb = connectWebViewSelectAll obj cb SignalConnectAfter

connectWebViewSelectAll :: (GObject a, MonadIO m) =>
                           a -> WebViewSelectAllCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewSelectAll obj cb after = liftIO $ do
    cb' <- mkWebViewSelectAllCallback (webViewSelectAllCallbackWrapper cb)
    connectSignalFunPtr obj "select-all" cb' after

-- signal WebView::selection-changed
type WebViewSelectionChangedCallback =
    IO ()

noWebViewSelectionChangedCallback :: Maybe WebViewSelectionChangedCallback
noWebViewSelectionChangedCallback = Nothing

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

foreign import ccall "wrapper"
    mkWebViewSelectionChangedCallback :: WebViewSelectionChangedCallbackC -> IO (FunPtr WebViewSelectionChangedCallbackC)

webViewSelectionChangedClosure :: WebViewSelectionChangedCallback -> IO Closure
webViewSelectionChangedClosure cb = newCClosure =<< mkWebViewSelectionChangedCallback wrapped
    where wrapped = webViewSelectionChangedCallbackWrapper cb

webViewSelectionChangedCallbackWrapper ::
    WebViewSelectionChangedCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
webViewSelectionChangedCallbackWrapper _cb _ _ = do
    _cb 

onWebViewSelectionChanged :: (GObject a, MonadIO m) => a -> WebViewSelectionChangedCallback -> m SignalHandlerId
onWebViewSelectionChanged obj cb = liftIO $ connectWebViewSelectionChanged obj cb SignalConnectBefore
afterWebViewSelectionChanged :: (GObject a, MonadIO m) => a -> WebViewSelectionChangedCallback -> m SignalHandlerId
afterWebViewSelectionChanged obj cb = connectWebViewSelectionChanged obj cb SignalConnectAfter

connectWebViewSelectionChanged :: (GObject a, MonadIO m) =>
                                  a -> WebViewSelectionChangedCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewSelectionChanged obj cb after = liftIO $ do
    cb' <- mkWebViewSelectionChangedCallback (webViewSelectionChangedCallbackWrapper cb)
    connectSignalFunPtr obj "selection-changed" cb' after

-- signal WebView::should-apply-style
type WebViewShouldApplyStyleCallback =
    DOMCSSStyleDeclaration ->
    DOMRange ->
    IO Bool

noWebViewShouldApplyStyleCallback :: Maybe WebViewShouldApplyStyleCallback
noWebViewShouldApplyStyleCallback = Nothing

type WebViewShouldApplyStyleCallbackC =
    Ptr () ->                               -- object
    Ptr DOMCSSStyleDeclaration ->
    Ptr DOMRange ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mkWebViewShouldApplyStyleCallback :: WebViewShouldApplyStyleCallbackC -> IO (FunPtr WebViewShouldApplyStyleCallbackC)

webViewShouldApplyStyleClosure :: WebViewShouldApplyStyleCallback -> IO Closure
webViewShouldApplyStyleClosure cb = newCClosure =<< mkWebViewShouldApplyStyleCallback wrapped
    where wrapped = webViewShouldApplyStyleCallbackWrapper cb

webViewShouldApplyStyleCallbackWrapper ::
    WebViewShouldApplyStyleCallback ->
    Ptr () ->
    Ptr DOMCSSStyleDeclaration ->
    Ptr DOMRange ->
    Ptr () ->
    IO CInt
webViewShouldApplyStyleCallbackWrapper _cb _ set range _ = do
    set' <- (newObject DOMCSSStyleDeclaration) set
    range' <- (newObject DOMRange) range
    result <- _cb  set' range'
    let result' = (fromIntegral . fromEnum) result
    return result'

onWebViewShouldApplyStyle :: (GObject a, MonadIO m) => a -> WebViewShouldApplyStyleCallback -> m SignalHandlerId
onWebViewShouldApplyStyle obj cb = liftIO $ connectWebViewShouldApplyStyle obj cb SignalConnectBefore
afterWebViewShouldApplyStyle :: (GObject a, MonadIO m) => a -> WebViewShouldApplyStyleCallback -> m SignalHandlerId
afterWebViewShouldApplyStyle obj cb = connectWebViewShouldApplyStyle obj cb SignalConnectAfter

connectWebViewShouldApplyStyle :: (GObject a, MonadIO m) =>
                                  a -> WebViewShouldApplyStyleCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewShouldApplyStyle obj cb after = liftIO $ do
    cb' <- mkWebViewShouldApplyStyleCallback (webViewShouldApplyStyleCallbackWrapper cb)
    connectSignalFunPtr obj "should-apply-style" cb' after

-- signal WebView::should-begin-editing
type WebViewShouldBeginEditingCallback =
    DOMRange ->
    IO Bool

noWebViewShouldBeginEditingCallback :: Maybe WebViewShouldBeginEditingCallback
noWebViewShouldBeginEditingCallback = Nothing

type WebViewShouldBeginEditingCallbackC =
    Ptr () ->                               -- object
    Ptr DOMRange ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mkWebViewShouldBeginEditingCallback :: WebViewShouldBeginEditingCallbackC -> IO (FunPtr WebViewShouldBeginEditingCallbackC)

webViewShouldBeginEditingClosure :: WebViewShouldBeginEditingCallback -> IO Closure
webViewShouldBeginEditingClosure cb = newCClosure =<< mkWebViewShouldBeginEditingCallback wrapped
    where wrapped = webViewShouldBeginEditingCallbackWrapper cb

webViewShouldBeginEditingCallbackWrapper ::
    WebViewShouldBeginEditingCallback ->
    Ptr () ->
    Ptr DOMRange ->
    Ptr () ->
    IO CInt
webViewShouldBeginEditingCallbackWrapper _cb _ range _ = do
    range' <- (newObject DOMRange) range
    result <- _cb  range'
    let result' = (fromIntegral . fromEnum) result
    return result'

onWebViewShouldBeginEditing :: (GObject a, MonadIO m) => a -> WebViewShouldBeginEditingCallback -> m SignalHandlerId
onWebViewShouldBeginEditing obj cb = liftIO $ connectWebViewShouldBeginEditing obj cb SignalConnectBefore
afterWebViewShouldBeginEditing :: (GObject a, MonadIO m) => a -> WebViewShouldBeginEditingCallback -> m SignalHandlerId
afterWebViewShouldBeginEditing obj cb = connectWebViewShouldBeginEditing obj cb SignalConnectAfter

connectWebViewShouldBeginEditing :: (GObject a, MonadIO m) =>
                                    a -> WebViewShouldBeginEditingCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewShouldBeginEditing obj cb after = liftIO $ do
    cb' <- mkWebViewShouldBeginEditingCallback (webViewShouldBeginEditingCallbackWrapper cb)
    connectSignalFunPtr obj "should-begin-editing" cb' after

-- signal WebView::should-change-selected-range
type WebViewShouldChangeSelectedRangeCallback =
    DOMRange ->
    DOMRange ->
    SelectionAffinity ->
    Bool ->
    IO Bool

noWebViewShouldChangeSelectedRangeCallback :: Maybe WebViewShouldChangeSelectedRangeCallback
noWebViewShouldChangeSelectedRangeCallback = Nothing

type WebViewShouldChangeSelectedRangeCallbackC =
    Ptr () ->                               -- object
    Ptr DOMRange ->
    Ptr DOMRange ->
    CUInt ->
    CInt ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mkWebViewShouldChangeSelectedRangeCallback :: WebViewShouldChangeSelectedRangeCallbackC -> IO (FunPtr WebViewShouldChangeSelectedRangeCallbackC)

webViewShouldChangeSelectedRangeClosure :: WebViewShouldChangeSelectedRangeCallback -> IO Closure
webViewShouldChangeSelectedRangeClosure cb = newCClosure =<< mkWebViewShouldChangeSelectedRangeCallback wrapped
    where wrapped = webViewShouldChangeSelectedRangeCallbackWrapper cb

webViewShouldChangeSelectedRangeCallbackWrapper ::
    WebViewShouldChangeSelectedRangeCallback ->
    Ptr () ->
    Ptr DOMRange ->
    Ptr DOMRange ->
    CUInt ->
    CInt ->
    Ptr () ->
    IO CInt
webViewShouldChangeSelectedRangeCallbackWrapper _cb _ fromRange toRange affinity stillSelecting _ = do
    fromRange' <- (newObject DOMRange) fromRange
    toRange' <- (newObject DOMRange) toRange
    let affinity' = (toEnum . fromIntegral) affinity
    let stillSelecting' = (/= 0) stillSelecting
    result <- _cb  fromRange' toRange' affinity' stillSelecting'
    let result' = (fromIntegral . fromEnum) result
    return result'

onWebViewShouldChangeSelectedRange :: (GObject a, MonadIO m) => a -> WebViewShouldChangeSelectedRangeCallback -> m SignalHandlerId
onWebViewShouldChangeSelectedRange obj cb = liftIO $ connectWebViewShouldChangeSelectedRange obj cb SignalConnectBefore
afterWebViewShouldChangeSelectedRange :: (GObject a, MonadIO m) => a -> WebViewShouldChangeSelectedRangeCallback -> m SignalHandlerId
afterWebViewShouldChangeSelectedRange obj cb = connectWebViewShouldChangeSelectedRange obj cb SignalConnectAfter

connectWebViewShouldChangeSelectedRange :: (GObject a, MonadIO m) =>
                                           a -> WebViewShouldChangeSelectedRangeCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewShouldChangeSelectedRange obj cb after = liftIO $ do
    cb' <- mkWebViewShouldChangeSelectedRangeCallback (webViewShouldChangeSelectedRangeCallbackWrapper cb)
    connectSignalFunPtr obj "should-change-selected-range" cb' after

-- signal WebView::should-delete-range
type WebViewShouldDeleteRangeCallback =
    DOMRange ->
    IO Bool

noWebViewShouldDeleteRangeCallback :: Maybe WebViewShouldDeleteRangeCallback
noWebViewShouldDeleteRangeCallback = Nothing

type WebViewShouldDeleteRangeCallbackC =
    Ptr () ->                               -- object
    Ptr DOMRange ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mkWebViewShouldDeleteRangeCallback :: WebViewShouldDeleteRangeCallbackC -> IO (FunPtr WebViewShouldDeleteRangeCallbackC)

webViewShouldDeleteRangeClosure :: WebViewShouldDeleteRangeCallback -> IO Closure
webViewShouldDeleteRangeClosure cb = newCClosure =<< mkWebViewShouldDeleteRangeCallback wrapped
    where wrapped = webViewShouldDeleteRangeCallbackWrapper cb

webViewShouldDeleteRangeCallbackWrapper ::
    WebViewShouldDeleteRangeCallback ->
    Ptr () ->
    Ptr DOMRange ->
    Ptr () ->
    IO CInt
webViewShouldDeleteRangeCallbackWrapper _cb _ range _ = do
    range' <- (newObject DOMRange) range
    result <- _cb  range'
    let result' = (fromIntegral . fromEnum) result
    return result'

onWebViewShouldDeleteRange :: (GObject a, MonadIO m) => a -> WebViewShouldDeleteRangeCallback -> m SignalHandlerId
onWebViewShouldDeleteRange obj cb = liftIO $ connectWebViewShouldDeleteRange obj cb SignalConnectBefore
afterWebViewShouldDeleteRange :: (GObject a, MonadIO m) => a -> WebViewShouldDeleteRangeCallback -> m SignalHandlerId
afterWebViewShouldDeleteRange obj cb = connectWebViewShouldDeleteRange obj cb SignalConnectAfter

connectWebViewShouldDeleteRange :: (GObject a, MonadIO m) =>
                                   a -> WebViewShouldDeleteRangeCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewShouldDeleteRange obj cb after = liftIO $ do
    cb' <- mkWebViewShouldDeleteRangeCallback (webViewShouldDeleteRangeCallbackWrapper cb)
    connectSignalFunPtr obj "should-delete-range" cb' after

-- signal WebView::should-end-editing
type WebViewShouldEndEditingCallback =
    DOMRange ->
    IO Bool

noWebViewShouldEndEditingCallback :: Maybe WebViewShouldEndEditingCallback
noWebViewShouldEndEditingCallback = Nothing

type WebViewShouldEndEditingCallbackC =
    Ptr () ->                               -- object
    Ptr DOMRange ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mkWebViewShouldEndEditingCallback :: WebViewShouldEndEditingCallbackC -> IO (FunPtr WebViewShouldEndEditingCallbackC)

webViewShouldEndEditingClosure :: WebViewShouldEndEditingCallback -> IO Closure
webViewShouldEndEditingClosure cb = newCClosure =<< mkWebViewShouldEndEditingCallback wrapped
    where wrapped = webViewShouldEndEditingCallbackWrapper cb

webViewShouldEndEditingCallbackWrapper ::
    WebViewShouldEndEditingCallback ->
    Ptr () ->
    Ptr DOMRange ->
    Ptr () ->
    IO CInt
webViewShouldEndEditingCallbackWrapper _cb _ range _ = do
    range' <- (newObject DOMRange) range
    result <- _cb  range'
    let result' = (fromIntegral . fromEnum) result
    return result'

onWebViewShouldEndEditing :: (GObject a, MonadIO m) => a -> WebViewShouldEndEditingCallback -> m SignalHandlerId
onWebViewShouldEndEditing obj cb = liftIO $ connectWebViewShouldEndEditing obj cb SignalConnectBefore
afterWebViewShouldEndEditing :: (GObject a, MonadIO m) => a -> WebViewShouldEndEditingCallback -> m SignalHandlerId
afterWebViewShouldEndEditing obj cb = connectWebViewShouldEndEditing obj cb SignalConnectAfter

connectWebViewShouldEndEditing :: (GObject a, MonadIO m) =>
                                  a -> WebViewShouldEndEditingCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewShouldEndEditing obj cb after = liftIO $ do
    cb' <- mkWebViewShouldEndEditingCallback (webViewShouldEndEditingCallbackWrapper cb)
    connectSignalFunPtr obj "should-end-editing" cb' after

-- signal WebView::should-insert-node
type WebViewShouldInsertNodeCallback =
    DOMNode ->
    DOMRange ->
    InsertAction ->
    IO Bool

noWebViewShouldInsertNodeCallback :: Maybe WebViewShouldInsertNodeCallback
noWebViewShouldInsertNodeCallback = Nothing

type WebViewShouldInsertNodeCallbackC =
    Ptr () ->                               -- object
    Ptr DOMNode ->
    Ptr DOMRange ->
    CUInt ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mkWebViewShouldInsertNodeCallback :: WebViewShouldInsertNodeCallbackC -> IO (FunPtr WebViewShouldInsertNodeCallbackC)

webViewShouldInsertNodeClosure :: WebViewShouldInsertNodeCallback -> IO Closure
webViewShouldInsertNodeClosure cb = newCClosure =<< mkWebViewShouldInsertNodeCallback wrapped
    where wrapped = webViewShouldInsertNodeCallbackWrapper cb

webViewShouldInsertNodeCallbackWrapper ::
    WebViewShouldInsertNodeCallback ->
    Ptr () ->
    Ptr DOMNode ->
    Ptr DOMRange ->
    CUInt ->
    Ptr () ->
    IO CInt
webViewShouldInsertNodeCallbackWrapper _cb _ node range action _ = do
    node' <- (newObject DOMNode) node
    range' <- (newObject DOMRange) range
    let action' = (toEnum . fromIntegral) action
    result <- _cb  node' range' action'
    let result' = (fromIntegral . fromEnum) result
    return result'

onWebViewShouldInsertNode :: (GObject a, MonadIO m) => a -> WebViewShouldInsertNodeCallback -> m SignalHandlerId
onWebViewShouldInsertNode obj cb = liftIO $ connectWebViewShouldInsertNode obj cb SignalConnectBefore
afterWebViewShouldInsertNode :: (GObject a, MonadIO m) => a -> WebViewShouldInsertNodeCallback -> m SignalHandlerId
afterWebViewShouldInsertNode obj cb = connectWebViewShouldInsertNode obj cb SignalConnectAfter

connectWebViewShouldInsertNode :: (GObject a, MonadIO m) =>
                                  a -> WebViewShouldInsertNodeCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewShouldInsertNode obj cb after = liftIO $ do
    cb' <- mkWebViewShouldInsertNodeCallback (webViewShouldInsertNodeCallbackWrapper cb)
    connectSignalFunPtr obj "should-insert-node" cb' after

-- signal WebView::should-insert-text
type WebViewShouldInsertTextCallback =
    T.Text ->
    DOMRange ->
    InsertAction ->
    IO Bool

noWebViewShouldInsertTextCallback :: Maybe WebViewShouldInsertTextCallback
noWebViewShouldInsertTextCallback = Nothing

type WebViewShouldInsertTextCallbackC =
    Ptr () ->                               -- object
    CString ->
    Ptr DOMRange ->
    CUInt ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mkWebViewShouldInsertTextCallback :: WebViewShouldInsertTextCallbackC -> IO (FunPtr WebViewShouldInsertTextCallbackC)

webViewShouldInsertTextClosure :: WebViewShouldInsertTextCallback -> IO Closure
webViewShouldInsertTextClosure cb = newCClosure =<< mkWebViewShouldInsertTextCallback wrapped
    where wrapped = webViewShouldInsertTextCallbackWrapper cb

webViewShouldInsertTextCallbackWrapper ::
    WebViewShouldInsertTextCallback ->
    Ptr () ->
    CString ->
    Ptr DOMRange ->
    CUInt ->
    Ptr () ->
    IO CInt
webViewShouldInsertTextCallbackWrapper _cb _ string range action _ = do
    string' <- cstringToText string
    range' <- (newObject DOMRange) range
    let action' = (toEnum . fromIntegral) action
    result <- _cb  string' range' action'
    let result' = (fromIntegral . fromEnum) result
    return result'

onWebViewShouldInsertText :: (GObject a, MonadIO m) => a -> WebViewShouldInsertTextCallback -> m SignalHandlerId
onWebViewShouldInsertText obj cb = liftIO $ connectWebViewShouldInsertText obj cb SignalConnectBefore
afterWebViewShouldInsertText :: (GObject a, MonadIO m) => a -> WebViewShouldInsertTextCallback -> m SignalHandlerId
afterWebViewShouldInsertText obj cb = connectWebViewShouldInsertText obj cb SignalConnectAfter

connectWebViewShouldInsertText :: (GObject a, MonadIO m) =>
                                  a -> WebViewShouldInsertTextCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewShouldInsertText obj cb after = liftIO $ do
    cb' <- mkWebViewShouldInsertTextCallback (webViewShouldInsertTextCallbackWrapper cb)
    connectSignalFunPtr obj "should-insert-text" cb' after

-- signal WebView::should-show-delete-interface-for-element
type WebViewShouldShowDeleteInterfaceForElementCallback =
    DOMHTMLElement ->
    IO Bool

noWebViewShouldShowDeleteInterfaceForElementCallback :: Maybe WebViewShouldShowDeleteInterfaceForElementCallback
noWebViewShouldShowDeleteInterfaceForElementCallback = Nothing

type WebViewShouldShowDeleteInterfaceForElementCallbackC =
    Ptr () ->                               -- object
    Ptr DOMHTMLElement ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mkWebViewShouldShowDeleteInterfaceForElementCallback :: WebViewShouldShowDeleteInterfaceForElementCallbackC -> IO (FunPtr WebViewShouldShowDeleteInterfaceForElementCallbackC)

webViewShouldShowDeleteInterfaceForElementClosure :: WebViewShouldShowDeleteInterfaceForElementCallback -> IO Closure
webViewShouldShowDeleteInterfaceForElementClosure cb = newCClosure =<< mkWebViewShouldShowDeleteInterfaceForElementCallback wrapped
    where wrapped = webViewShouldShowDeleteInterfaceForElementCallbackWrapper cb

webViewShouldShowDeleteInterfaceForElementCallbackWrapper ::
    WebViewShouldShowDeleteInterfaceForElementCallback ->
    Ptr () ->
    Ptr DOMHTMLElement ->
    Ptr () ->
    IO CInt
webViewShouldShowDeleteInterfaceForElementCallbackWrapper _cb _ element _ = do
    element' <- (newObject DOMHTMLElement) element
    result <- _cb  element'
    let result' = (fromIntegral . fromEnum) result
    return result'

onWebViewShouldShowDeleteInterfaceForElement :: (GObject a, MonadIO m) => a -> WebViewShouldShowDeleteInterfaceForElementCallback -> m SignalHandlerId
onWebViewShouldShowDeleteInterfaceForElement obj cb = liftIO $ connectWebViewShouldShowDeleteInterfaceForElement obj cb SignalConnectBefore
afterWebViewShouldShowDeleteInterfaceForElement :: (GObject a, MonadIO m) => a -> WebViewShouldShowDeleteInterfaceForElementCallback -> m SignalHandlerId
afterWebViewShouldShowDeleteInterfaceForElement obj cb = connectWebViewShouldShowDeleteInterfaceForElement obj cb SignalConnectAfter

connectWebViewShouldShowDeleteInterfaceForElement :: (GObject a, MonadIO m) =>
                                                     a -> WebViewShouldShowDeleteInterfaceForElementCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewShouldShowDeleteInterfaceForElement obj cb after = liftIO $ do
    cb' <- mkWebViewShouldShowDeleteInterfaceForElementCallback (webViewShouldShowDeleteInterfaceForElementCallbackWrapper cb)
    connectSignalFunPtr obj "should-show-delete-interface-for-element" cb' after

-- signal WebView::status-bar-text-changed
type WebViewStatusBarTextChangedCallback =
    T.Text ->
    IO ()

noWebViewStatusBarTextChangedCallback :: Maybe WebViewStatusBarTextChangedCallback
noWebViewStatusBarTextChangedCallback = Nothing

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

foreign import ccall "wrapper"
    mkWebViewStatusBarTextChangedCallback :: WebViewStatusBarTextChangedCallbackC -> IO (FunPtr WebViewStatusBarTextChangedCallbackC)

webViewStatusBarTextChangedClosure :: WebViewStatusBarTextChangedCallback -> IO Closure
webViewStatusBarTextChangedClosure cb = newCClosure =<< mkWebViewStatusBarTextChangedCallback wrapped
    where wrapped = webViewStatusBarTextChangedCallbackWrapper cb

webViewStatusBarTextChangedCallbackWrapper ::
    WebViewStatusBarTextChangedCallback ->
    Ptr () ->
    CString ->
    Ptr () ->
    IO ()
webViewStatusBarTextChangedCallbackWrapper _cb _ object _ = do
    object' <- cstringToText object
    _cb  object'

onWebViewStatusBarTextChanged :: (GObject a, MonadIO m) => a -> WebViewStatusBarTextChangedCallback -> m SignalHandlerId
onWebViewStatusBarTextChanged obj cb = liftIO $ connectWebViewStatusBarTextChanged obj cb SignalConnectBefore
afterWebViewStatusBarTextChanged :: (GObject a, MonadIO m) => a -> WebViewStatusBarTextChangedCallback -> m SignalHandlerId
afterWebViewStatusBarTextChanged obj cb = connectWebViewStatusBarTextChanged obj cb SignalConnectAfter

connectWebViewStatusBarTextChanged :: (GObject a, MonadIO m) =>
                                      a -> WebViewStatusBarTextChangedCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewStatusBarTextChanged obj cb after = liftIO $ do
    cb' <- mkWebViewStatusBarTextChangedCallback (webViewStatusBarTextChangedCallbackWrapper cb)
    connectSignalFunPtr obj "status-bar-text-changed" cb' after

-- signal WebView::title-changed
type WebViewTitleChangedCallback =
    WebFrame ->
    T.Text ->
    IO ()

noWebViewTitleChangedCallback :: Maybe WebViewTitleChangedCallback
noWebViewTitleChangedCallback = Nothing

type WebViewTitleChangedCallbackC =
    Ptr () ->                               -- object
    Ptr WebFrame ->
    CString ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mkWebViewTitleChangedCallback :: WebViewTitleChangedCallbackC -> IO (FunPtr WebViewTitleChangedCallbackC)

webViewTitleChangedClosure :: WebViewTitleChangedCallback -> IO Closure
webViewTitleChangedClosure cb = newCClosure =<< mkWebViewTitleChangedCallback wrapped
    where wrapped = webViewTitleChangedCallbackWrapper cb

webViewTitleChangedCallbackWrapper ::
    WebViewTitleChangedCallback ->
    Ptr () ->
    Ptr WebFrame ->
    CString ->
    Ptr () ->
    IO ()
webViewTitleChangedCallbackWrapper _cb _ frame title _ = do
    frame' <- (newObject WebFrame) frame
    title' <- cstringToText title
    _cb  frame' title'

onWebViewTitleChanged :: (GObject a, MonadIO m) => a -> WebViewTitleChangedCallback -> m SignalHandlerId
onWebViewTitleChanged obj cb = liftIO $ connectWebViewTitleChanged obj cb SignalConnectBefore
afterWebViewTitleChanged :: (GObject a, MonadIO m) => a -> WebViewTitleChangedCallback -> m SignalHandlerId
afterWebViewTitleChanged obj cb = connectWebViewTitleChanged obj cb SignalConnectAfter

connectWebViewTitleChanged :: (GObject a, MonadIO m) =>
                              a -> WebViewTitleChangedCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewTitleChanged obj cb after = liftIO $ do
    cb' <- mkWebViewTitleChangedCallback (webViewTitleChangedCallbackWrapper cb)
    connectSignalFunPtr obj "title-changed" cb' after

-- signal WebView::undo
type WebViewUndoCallback =
    IO ()

noWebViewUndoCallback :: Maybe WebViewUndoCallback
noWebViewUndoCallback = Nothing

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

foreign import ccall "wrapper"
    mkWebViewUndoCallback :: WebViewUndoCallbackC -> IO (FunPtr WebViewUndoCallbackC)

webViewUndoClosure :: WebViewUndoCallback -> IO Closure
webViewUndoClosure cb = newCClosure =<< mkWebViewUndoCallback wrapped
    where wrapped = webViewUndoCallbackWrapper cb

webViewUndoCallbackWrapper ::
    WebViewUndoCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
webViewUndoCallbackWrapper _cb _ _ = do
    _cb 

onWebViewUndo :: (GObject a, MonadIO m) => a -> WebViewUndoCallback -> m SignalHandlerId
onWebViewUndo obj cb = liftIO $ connectWebViewUndo obj cb SignalConnectBefore
afterWebViewUndo :: (GObject a, MonadIO m) => a -> WebViewUndoCallback -> m SignalHandlerId
afterWebViewUndo obj cb = connectWebViewUndo obj cb SignalConnectAfter

connectWebViewUndo :: (GObject a, MonadIO m) =>
                      a -> WebViewUndoCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewUndo obj cb after = liftIO $ do
    cb' <- mkWebViewUndoCallback (webViewUndoCallbackWrapper cb)
    connectSignalFunPtr obj "undo" cb' after

-- signal WebView::user-changed-contents
type WebViewUserChangedContentsCallback =
    IO ()

noWebViewUserChangedContentsCallback :: Maybe WebViewUserChangedContentsCallback
noWebViewUserChangedContentsCallback = Nothing

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

foreign import ccall "wrapper"
    mkWebViewUserChangedContentsCallback :: WebViewUserChangedContentsCallbackC -> IO (FunPtr WebViewUserChangedContentsCallbackC)

webViewUserChangedContentsClosure :: WebViewUserChangedContentsCallback -> IO Closure
webViewUserChangedContentsClosure cb = newCClosure =<< mkWebViewUserChangedContentsCallback wrapped
    where wrapped = webViewUserChangedContentsCallbackWrapper cb

webViewUserChangedContentsCallbackWrapper ::
    WebViewUserChangedContentsCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
webViewUserChangedContentsCallbackWrapper _cb _ _ = do
    _cb 

onWebViewUserChangedContents :: (GObject a, MonadIO m) => a -> WebViewUserChangedContentsCallback -> m SignalHandlerId
onWebViewUserChangedContents obj cb = liftIO $ connectWebViewUserChangedContents obj cb SignalConnectBefore
afterWebViewUserChangedContents :: (GObject a, MonadIO m) => a -> WebViewUserChangedContentsCallback -> m SignalHandlerId
afterWebViewUserChangedContents obj cb = connectWebViewUserChangedContents obj cb SignalConnectAfter

connectWebViewUserChangedContents :: (GObject a, MonadIO m) =>
                                     a -> WebViewUserChangedContentsCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewUserChangedContents obj cb after = liftIO $ do
    cb' <- mkWebViewUserChangedContentsCallback (webViewUserChangedContentsCallbackWrapper cb)
    connectSignalFunPtr obj "user-changed-contents" cb' after

-- signal WebView::viewport-attributes-changed
type WebViewViewportAttributesChangedCallback =
    ViewportAttributes ->
    IO ()

noWebViewViewportAttributesChangedCallback :: Maybe WebViewViewportAttributesChangedCallback
noWebViewViewportAttributesChangedCallback = Nothing

type WebViewViewportAttributesChangedCallbackC =
    Ptr () ->                               -- object
    Ptr ViewportAttributes ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mkWebViewViewportAttributesChangedCallback :: WebViewViewportAttributesChangedCallbackC -> IO (FunPtr WebViewViewportAttributesChangedCallbackC)

webViewViewportAttributesChangedClosure :: WebViewViewportAttributesChangedCallback -> IO Closure
webViewViewportAttributesChangedClosure cb = newCClosure =<< mkWebViewViewportAttributesChangedCallback wrapped
    where wrapped = webViewViewportAttributesChangedCallbackWrapper cb

webViewViewportAttributesChangedCallbackWrapper ::
    WebViewViewportAttributesChangedCallback ->
    Ptr () ->
    Ptr ViewportAttributes ->
    Ptr () ->
    IO ()
webViewViewportAttributesChangedCallbackWrapper _cb _ object _ = do
    object' <- (newObject ViewportAttributes) object
    _cb  object'

onWebViewViewportAttributesChanged :: (GObject a, MonadIO m) => a -> WebViewViewportAttributesChangedCallback -> m SignalHandlerId
onWebViewViewportAttributesChanged obj cb = liftIO $ connectWebViewViewportAttributesChanged obj cb SignalConnectBefore
afterWebViewViewportAttributesChanged :: (GObject a, MonadIO m) => a -> WebViewViewportAttributesChangedCallback -> m SignalHandlerId
afterWebViewViewportAttributesChanged obj cb = connectWebViewViewportAttributesChanged obj cb SignalConnectAfter

connectWebViewViewportAttributesChanged :: (GObject a, MonadIO m) =>
                                           a -> WebViewViewportAttributesChangedCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewViewportAttributesChanged obj cb after = liftIO $ do
    cb' <- mkWebViewViewportAttributesChangedCallback (webViewViewportAttributesChangedCallbackWrapper cb)
    connectSignalFunPtr obj "viewport-attributes-changed" cb' after

-- signal WebView::viewport-attributes-recompute-requested
type WebViewViewportAttributesRecomputeRequestedCallback =
    ViewportAttributes ->
    IO ()

noWebViewViewportAttributesRecomputeRequestedCallback :: Maybe WebViewViewportAttributesRecomputeRequestedCallback
noWebViewViewportAttributesRecomputeRequestedCallback = Nothing

type WebViewViewportAttributesRecomputeRequestedCallbackC =
    Ptr () ->                               -- object
    Ptr ViewportAttributes ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mkWebViewViewportAttributesRecomputeRequestedCallback :: WebViewViewportAttributesRecomputeRequestedCallbackC -> IO (FunPtr WebViewViewportAttributesRecomputeRequestedCallbackC)

webViewViewportAttributesRecomputeRequestedClosure :: WebViewViewportAttributesRecomputeRequestedCallback -> IO Closure
webViewViewportAttributesRecomputeRequestedClosure cb = newCClosure =<< mkWebViewViewportAttributesRecomputeRequestedCallback wrapped
    where wrapped = webViewViewportAttributesRecomputeRequestedCallbackWrapper cb

webViewViewportAttributesRecomputeRequestedCallbackWrapper ::
    WebViewViewportAttributesRecomputeRequestedCallback ->
    Ptr () ->
    Ptr ViewportAttributes ->
    Ptr () ->
    IO ()
webViewViewportAttributesRecomputeRequestedCallbackWrapper _cb _ object _ = do
    object' <- (newObject ViewportAttributes) object
    _cb  object'

onWebViewViewportAttributesRecomputeRequested :: (GObject a, MonadIO m) => a -> WebViewViewportAttributesRecomputeRequestedCallback -> m SignalHandlerId
onWebViewViewportAttributesRecomputeRequested obj cb = liftIO $ connectWebViewViewportAttributesRecomputeRequested obj cb SignalConnectBefore
afterWebViewViewportAttributesRecomputeRequested :: (GObject a, MonadIO m) => a -> WebViewViewportAttributesRecomputeRequestedCallback -> m SignalHandlerId
afterWebViewViewportAttributesRecomputeRequested obj cb = connectWebViewViewportAttributesRecomputeRequested obj cb SignalConnectAfter

connectWebViewViewportAttributesRecomputeRequested :: (GObject a, MonadIO m) =>
                                                      a -> WebViewViewportAttributesRecomputeRequestedCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewViewportAttributesRecomputeRequested obj cb after = liftIO $ do
    cb' <- mkWebViewViewportAttributesRecomputeRequestedCallback (webViewViewportAttributesRecomputeRequestedCallbackWrapper cb)
    connectSignalFunPtr obj "viewport-attributes-recompute-requested" cb' after

-- signal WebView::web-view-ready
type WebViewWebViewReadyCallback =
    IO Bool

noWebViewWebViewReadyCallback :: Maybe WebViewWebViewReadyCallback
noWebViewWebViewReadyCallback = Nothing

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

foreign import ccall "wrapper"
    mkWebViewWebViewReadyCallback :: WebViewWebViewReadyCallbackC -> IO (FunPtr WebViewWebViewReadyCallbackC)

webViewWebViewReadyClosure :: WebViewWebViewReadyCallback -> IO Closure
webViewWebViewReadyClosure cb = newCClosure =<< mkWebViewWebViewReadyCallback wrapped
    where wrapped = webViewWebViewReadyCallbackWrapper cb

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

onWebViewWebViewReady :: (GObject a, MonadIO m) => a -> WebViewWebViewReadyCallback -> m SignalHandlerId
onWebViewWebViewReady obj cb = liftIO $ connectWebViewWebViewReady obj cb SignalConnectBefore
afterWebViewWebViewReady :: (GObject a, MonadIO m) => a -> WebViewWebViewReadyCallback -> m SignalHandlerId
afterWebViewWebViewReady obj cb = connectWebViewWebViewReady obj cb SignalConnectAfter

connectWebViewWebViewReady :: (GObject a, MonadIO m) =>
                              a -> WebViewWebViewReadyCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewWebViewReady obj cb after = liftIO $ do
    cb' <- mkWebViewWebViewReadyCallback (webViewWebViewReadyCallbackWrapper cb)
    connectSignalFunPtr obj "web-view-ready" cb' after

-- signal WebView::window-object-cleared
type WebViewWindowObjectClearedCallback =
    WebFrame ->
    Ptr () ->
    Ptr () ->
    IO ()

noWebViewWindowObjectClearedCallback :: Maybe WebViewWindowObjectClearedCallback
noWebViewWindowObjectClearedCallback = Nothing

type WebViewWindowObjectClearedCallbackC =
    Ptr () ->                               -- object
    Ptr WebFrame ->
    Ptr () ->
    Ptr () ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mkWebViewWindowObjectClearedCallback :: WebViewWindowObjectClearedCallbackC -> IO (FunPtr WebViewWindowObjectClearedCallbackC)

webViewWindowObjectClearedClosure :: WebViewWindowObjectClearedCallback -> IO Closure
webViewWindowObjectClearedClosure cb = newCClosure =<< mkWebViewWindowObjectClearedCallback wrapped
    where wrapped = webViewWindowObjectClearedCallbackWrapper cb

webViewWindowObjectClearedCallbackWrapper ::
    WebViewWindowObjectClearedCallback ->
    Ptr () ->
    Ptr WebFrame ->
    Ptr () ->
    Ptr () ->
    Ptr () ->
    IO ()
webViewWindowObjectClearedCallbackWrapper _cb _ frame context window_object _ = do
    frame' <- (newObject WebFrame) frame
    _cb  frame' context window_object

onWebViewWindowObjectCleared :: (GObject a, MonadIO m) => a -> WebViewWindowObjectClearedCallback -> m SignalHandlerId
onWebViewWindowObjectCleared obj cb = liftIO $ connectWebViewWindowObjectCleared obj cb SignalConnectBefore
afterWebViewWindowObjectCleared :: (GObject a, MonadIO m) => a -> WebViewWindowObjectClearedCallback -> m SignalHandlerId
afterWebViewWindowObjectCleared obj cb = connectWebViewWindowObjectCleared obj cb SignalConnectAfter

connectWebViewWindowObjectCleared :: (GObject a, MonadIO m) =>
                                     a -> WebViewWindowObjectClearedCallback -> SignalConnectMode -> m SignalHandlerId
connectWebViewWindowObjectCleared obj cb after = liftIO $ do
    cb' <- mkWebViewWindowObjectClearedCallback (webViewWindowObjectClearedCallbackWrapper cb)
    connectSignalFunPtr obj "window-object-cleared" cb' after

-- VVV Prop "copy-target-list"
   -- Type: TInterface "Gtk" "TargetList"
   -- Flags: [PropertyReadable]

getWebViewCopyTargetList :: (MonadIO m, WebViewK o) => o -> m Gtk.TargetList
getWebViewCopyTargetList obj = liftIO $ getObjectPropertyBoxed obj "copy-target-list" Gtk.TargetList

data WebViewCopyTargetListPropertyInfo
instance AttrInfo WebViewCopyTargetListPropertyInfo where
    type AttrAllowedOps WebViewCopyTargetListPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint WebViewCopyTargetListPropertyInfo = (~) ()
    type AttrBaseTypeConstraint WebViewCopyTargetListPropertyInfo = WebViewK
    type AttrGetType WebViewCopyTargetListPropertyInfo = Gtk.TargetList
    type AttrLabel WebViewCopyTargetListPropertyInfo = "WebView::copy-target-list"
    attrGet _ = getWebViewCopyTargetList
    attrSet _ = undefined
    attrConstruct _ = undefined

-- VVV Prop "custom-encoding"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable]

getWebViewCustomEncoding :: (MonadIO m, WebViewK o) => o -> m T.Text
getWebViewCustomEncoding obj = liftIO $ getObjectPropertyString obj "custom-encoding"

setWebViewCustomEncoding :: (MonadIO m, WebViewK o) => o -> T.Text -> m ()
setWebViewCustomEncoding obj val = liftIO $ setObjectPropertyString obj "custom-encoding" val

constructWebViewCustomEncoding :: T.Text -> IO ([Char], GValue)
constructWebViewCustomEncoding val = constructObjectPropertyString "custom-encoding" val

data WebViewCustomEncodingPropertyInfo
instance AttrInfo WebViewCustomEncodingPropertyInfo where
    type AttrAllowedOps WebViewCustomEncodingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint WebViewCustomEncodingPropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint WebViewCustomEncodingPropertyInfo = WebViewK
    type AttrGetType WebViewCustomEncodingPropertyInfo = T.Text
    type AttrLabel WebViewCustomEncodingPropertyInfo = "WebView::custom-encoding"
    attrGet _ = getWebViewCustomEncoding
    attrSet _ = setWebViewCustomEncoding
    attrConstruct _ = constructWebViewCustomEncoding

-- VVV Prop "editable"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]

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

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

constructWebViewEditable :: Bool -> IO ([Char], GValue)
constructWebViewEditable val = constructObjectPropertyBool "editable" val

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

-- VVV Prop "encoding"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable]

getWebViewEncoding :: (MonadIO m, WebViewK o) => o -> m T.Text
getWebViewEncoding obj = liftIO $ getObjectPropertyString obj "encoding"

data WebViewEncodingPropertyInfo
instance AttrInfo WebViewEncodingPropertyInfo where
    type AttrAllowedOps WebViewEncodingPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint WebViewEncodingPropertyInfo = (~) ()
    type AttrBaseTypeConstraint WebViewEncodingPropertyInfo = WebViewK
    type AttrGetType WebViewEncodingPropertyInfo = T.Text
    type AttrLabel WebViewEncodingPropertyInfo = "WebView::encoding"
    attrGet _ = getWebViewEncoding
    attrSet _ = undefined
    attrConstruct _ = undefined

-- VVV Prop "full-content-zoom"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]

getWebViewFullContentZoom :: (MonadIO m, WebViewK o) => o -> m Bool
getWebViewFullContentZoom obj = liftIO $ getObjectPropertyBool obj "full-content-zoom"

setWebViewFullContentZoom :: (MonadIO m, WebViewK o) => o -> Bool -> m ()
setWebViewFullContentZoom obj val = liftIO $ setObjectPropertyBool obj "full-content-zoom" val

constructWebViewFullContentZoom :: Bool -> IO ([Char], GValue)
constructWebViewFullContentZoom val = constructObjectPropertyBool "full-content-zoom" val

data WebViewFullContentZoomPropertyInfo
instance AttrInfo WebViewFullContentZoomPropertyInfo where
    type AttrAllowedOps WebViewFullContentZoomPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint WebViewFullContentZoomPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint WebViewFullContentZoomPropertyInfo = WebViewK
    type AttrGetType WebViewFullContentZoomPropertyInfo = Bool
    type AttrLabel WebViewFullContentZoomPropertyInfo = "WebView::full-content-zoom"
    attrGet _ = getWebViewFullContentZoom
    attrSet _ = setWebViewFullContentZoom
    attrConstruct _ = constructWebViewFullContentZoom

-- VVV Prop "icon-uri"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable]

getWebViewIconUri :: (MonadIO m, WebViewK o) => o -> m T.Text
getWebViewIconUri obj = liftIO $ getObjectPropertyString obj "icon-uri"

data WebViewIconUriPropertyInfo
instance AttrInfo WebViewIconUriPropertyInfo where
    type AttrAllowedOps WebViewIconUriPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint WebViewIconUriPropertyInfo = (~) ()
    type AttrBaseTypeConstraint WebViewIconUriPropertyInfo = WebViewK
    type AttrGetType WebViewIconUriPropertyInfo = T.Text
    type AttrLabel WebViewIconUriPropertyInfo = "WebView::icon-uri"
    attrGet _ = getWebViewIconUri
    attrSet _ = undefined
    attrConstruct _ = undefined

-- VVV Prop "im-context"
   -- Type: TInterface "Gtk" "IMContext"
   -- Flags: [PropertyReadable]

getWebViewImContext :: (MonadIO m, WebViewK o) => o -> m Gtk.IMContext
getWebViewImContext obj = liftIO $ getObjectPropertyObject obj "im-context" Gtk.IMContext

data WebViewImContextPropertyInfo
instance AttrInfo WebViewImContextPropertyInfo where
    type AttrAllowedOps WebViewImContextPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint WebViewImContextPropertyInfo = (~) ()
    type AttrBaseTypeConstraint WebViewImContextPropertyInfo = WebViewK
    type AttrGetType WebViewImContextPropertyInfo = Gtk.IMContext
    type AttrLabel WebViewImContextPropertyInfo = "WebView::im-context"
    attrGet _ = getWebViewImContext
    attrSet _ = undefined
    attrConstruct _ = undefined

-- VVV Prop "load-status"
   -- Type: TInterface "WebKit" "LoadStatus"
   -- Flags: [PropertyReadable]

getWebViewLoadStatus :: (MonadIO m, WebViewK o) => o -> m LoadStatus
getWebViewLoadStatus obj = liftIO $ getObjectPropertyEnum obj "load-status"

data WebViewLoadStatusPropertyInfo
instance AttrInfo WebViewLoadStatusPropertyInfo where
    type AttrAllowedOps WebViewLoadStatusPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint WebViewLoadStatusPropertyInfo = (~) ()
    type AttrBaseTypeConstraint WebViewLoadStatusPropertyInfo = WebViewK
    type AttrGetType WebViewLoadStatusPropertyInfo = LoadStatus
    type AttrLabel WebViewLoadStatusPropertyInfo = "WebView::load-status"
    attrGet _ = getWebViewLoadStatus
    attrSet _ = undefined
    attrConstruct _ = undefined

-- VVV Prop "paste-target-list"
   -- Type: TInterface "Gtk" "TargetList"
   -- Flags: [PropertyReadable]

getWebViewPasteTargetList :: (MonadIO m, WebViewK o) => o -> m Gtk.TargetList
getWebViewPasteTargetList obj = liftIO $ getObjectPropertyBoxed obj "paste-target-list" Gtk.TargetList

data WebViewPasteTargetListPropertyInfo
instance AttrInfo WebViewPasteTargetListPropertyInfo where
    type AttrAllowedOps WebViewPasteTargetListPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint WebViewPasteTargetListPropertyInfo = (~) ()
    type AttrBaseTypeConstraint WebViewPasteTargetListPropertyInfo = WebViewK
    type AttrGetType WebViewPasteTargetListPropertyInfo = Gtk.TargetList
    type AttrLabel WebViewPasteTargetListPropertyInfo = "WebView::paste-target-list"
    attrGet _ = getWebViewPasteTargetList
    attrSet _ = undefined
    attrConstruct _ = undefined

-- VVV Prop "progress"
   -- Type: TBasicType TDouble
   -- Flags: [PropertyReadable]

getWebViewProgress :: (MonadIO m, WebViewK o) => o -> m Double
getWebViewProgress obj = liftIO $ getObjectPropertyDouble obj "progress"

data WebViewProgressPropertyInfo
instance AttrInfo WebViewProgressPropertyInfo where
    type AttrAllowedOps WebViewProgressPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint WebViewProgressPropertyInfo = (~) ()
    type AttrBaseTypeConstraint WebViewProgressPropertyInfo = WebViewK
    type AttrGetType WebViewProgressPropertyInfo = Double
    type AttrLabel WebViewProgressPropertyInfo = "WebView::progress"
    attrGet _ = getWebViewProgress
    attrSet _ = undefined
    attrConstruct _ = undefined

-- VVV Prop "self-scrolling"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]

getWebViewSelfScrolling :: (MonadIO m, WebViewK o) => o -> m Bool
getWebViewSelfScrolling obj = liftIO $ getObjectPropertyBool obj "self-scrolling"

constructWebViewSelfScrolling :: Bool -> IO ([Char], GValue)
constructWebViewSelfScrolling val = constructObjectPropertyBool "self-scrolling" val

data WebViewSelfScrollingPropertyInfo
instance AttrInfo WebViewSelfScrollingPropertyInfo where
    type AttrAllowedOps WebViewSelfScrollingPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint WebViewSelfScrollingPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint WebViewSelfScrollingPropertyInfo = WebViewK
    type AttrGetType WebViewSelfScrollingPropertyInfo = Bool
    type AttrLabel WebViewSelfScrollingPropertyInfo = "WebView::self-scrolling"
    attrGet _ = getWebViewSelfScrolling
    attrSet _ = undefined
    attrConstruct _ = constructWebViewSelfScrolling

-- VVV Prop "settings"
   -- Type: TInterface "WebKit" "WebSettings"
   -- Flags: [PropertyReadable,PropertyWritable]

getWebViewSettings :: (MonadIO m, WebViewK o) => o -> m WebSettings
getWebViewSettings obj = liftIO $ getObjectPropertyObject obj "settings" WebSettings

setWebViewSettings :: (MonadIO m, WebViewK o, WebSettingsK a) => o -> a -> m ()
setWebViewSettings obj val = liftIO $ setObjectPropertyObject obj "settings" val

constructWebViewSettings :: (WebSettingsK a) => a -> IO ([Char], GValue)
constructWebViewSettings val = constructObjectPropertyObject "settings" val

data WebViewSettingsPropertyInfo
instance AttrInfo WebViewSettingsPropertyInfo where
    type AttrAllowedOps WebViewSettingsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint WebViewSettingsPropertyInfo = WebSettingsK
    type AttrBaseTypeConstraint WebViewSettingsPropertyInfo = WebViewK
    type AttrGetType WebViewSettingsPropertyInfo = WebSettings
    type AttrLabel WebViewSettingsPropertyInfo = "WebView::settings"
    attrGet _ = getWebViewSettings
    attrSet _ = setWebViewSettings
    attrConstruct _ = constructWebViewSettings

-- VVV Prop "title"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable]

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

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

-- VVV Prop "transparent"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]

getWebViewTransparent :: (MonadIO m, WebViewK o) => o -> m Bool
getWebViewTransparent obj = liftIO $ getObjectPropertyBool obj "transparent"

setWebViewTransparent :: (MonadIO m, WebViewK o) => o -> Bool -> m ()
setWebViewTransparent obj val = liftIO $ setObjectPropertyBool obj "transparent" val

constructWebViewTransparent :: Bool -> IO ([Char], GValue)
constructWebViewTransparent val = constructObjectPropertyBool "transparent" val

data WebViewTransparentPropertyInfo
instance AttrInfo WebViewTransparentPropertyInfo where
    type AttrAllowedOps WebViewTransparentPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint WebViewTransparentPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint WebViewTransparentPropertyInfo = WebViewK
    type AttrGetType WebViewTransparentPropertyInfo = Bool
    type AttrLabel WebViewTransparentPropertyInfo = "WebView::transparent"
    attrGet _ = getWebViewTransparent
    attrSet _ = setWebViewTransparent
    attrConstruct _ = constructWebViewTransparent

-- VVV Prop "uri"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable]

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

data WebViewUriPropertyInfo
instance AttrInfo WebViewUriPropertyInfo where
    type AttrAllowedOps WebViewUriPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint WebViewUriPropertyInfo = (~) ()
    type AttrBaseTypeConstraint WebViewUriPropertyInfo = WebViewK
    type AttrGetType WebViewUriPropertyInfo = T.Text
    type AttrLabel WebViewUriPropertyInfo = "WebView::uri"
    attrGet _ = getWebViewUri
    attrSet _ = undefined
    attrConstruct _ = undefined

-- VVV Prop "view-mode"
   -- Type: TInterface "WebKit" "WebViewViewMode"
   -- Flags: [PropertyReadable,PropertyWritable]

getWebViewViewMode :: (MonadIO m, WebViewK o) => o -> m WebViewViewMode
getWebViewViewMode obj = liftIO $ getObjectPropertyEnum obj "view-mode"

setWebViewViewMode :: (MonadIO m, WebViewK o) => o -> WebViewViewMode -> m ()
setWebViewViewMode obj val = liftIO $ setObjectPropertyEnum obj "view-mode" val

constructWebViewViewMode :: WebViewViewMode -> IO ([Char], GValue)
constructWebViewViewMode val = constructObjectPropertyEnum "view-mode" val

data WebViewViewModePropertyInfo
instance AttrInfo WebViewViewModePropertyInfo where
    type AttrAllowedOps WebViewViewModePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint WebViewViewModePropertyInfo = (~) WebViewViewMode
    type AttrBaseTypeConstraint WebViewViewModePropertyInfo = WebViewK
    type AttrGetType WebViewViewModePropertyInfo = WebViewViewMode
    type AttrLabel WebViewViewModePropertyInfo = "WebView::view-mode"
    attrGet _ = getWebViewViewMode
    attrSet _ = setWebViewViewMode
    attrConstruct _ = constructWebViewViewMode

-- VVV Prop "viewport-attributes"
   -- Type: TInterface "WebKit" "ViewportAttributes"
   -- Flags: [PropertyReadable]

getWebViewViewportAttributes :: (MonadIO m, WebViewK o) => o -> m ViewportAttributes
getWebViewViewportAttributes obj = liftIO $ getObjectPropertyObject obj "viewport-attributes" ViewportAttributes

data WebViewViewportAttributesPropertyInfo
instance AttrInfo WebViewViewportAttributesPropertyInfo where
    type AttrAllowedOps WebViewViewportAttributesPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint WebViewViewportAttributesPropertyInfo = (~) ()
    type AttrBaseTypeConstraint WebViewViewportAttributesPropertyInfo = WebViewK
    type AttrGetType WebViewViewportAttributesPropertyInfo = ViewportAttributes
    type AttrLabel WebViewViewportAttributesPropertyInfo = "WebView::viewport-attributes"
    attrGet _ = getWebViewViewportAttributes
    attrSet _ = undefined
    attrConstruct _ = undefined

-- VVV Prop "web-inspector"
   -- Type: TInterface "WebKit" "WebInspector"
   -- Flags: [PropertyReadable]

getWebViewWebInspector :: (MonadIO m, WebViewK o) => o -> m WebInspector
getWebViewWebInspector obj = liftIO $ getObjectPropertyObject obj "web-inspector" WebInspector

data WebViewWebInspectorPropertyInfo
instance AttrInfo WebViewWebInspectorPropertyInfo where
    type AttrAllowedOps WebViewWebInspectorPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint WebViewWebInspectorPropertyInfo = (~) ()
    type AttrBaseTypeConstraint WebViewWebInspectorPropertyInfo = WebViewK
    type AttrGetType WebViewWebInspectorPropertyInfo = WebInspector
    type AttrLabel WebViewWebInspectorPropertyInfo = "WebView::web-inspector"
    attrGet _ = getWebViewWebInspector
    attrSet _ = undefined
    attrConstruct _ = undefined

-- VVV Prop "window-features"
   -- Type: TInterface "WebKit" "WebWindowFeatures"
   -- Flags: [PropertyReadable,PropertyWritable]

getWebViewWindowFeatures :: (MonadIO m, WebViewK o) => o -> m WebWindowFeatures
getWebViewWindowFeatures obj = liftIO $ getObjectPropertyObject obj "window-features" WebWindowFeatures

setWebViewWindowFeatures :: (MonadIO m, WebViewK o, WebWindowFeaturesK a) => o -> a -> m ()
setWebViewWindowFeatures obj val = liftIO $ setObjectPropertyObject obj "window-features" val

constructWebViewWindowFeatures :: (WebWindowFeaturesK a) => a -> IO ([Char], GValue)
constructWebViewWindowFeatures val = constructObjectPropertyObject "window-features" val

data WebViewWindowFeaturesPropertyInfo
instance AttrInfo WebViewWindowFeaturesPropertyInfo where
    type AttrAllowedOps WebViewWindowFeaturesPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint WebViewWindowFeaturesPropertyInfo = WebWindowFeaturesK
    type AttrBaseTypeConstraint WebViewWindowFeaturesPropertyInfo = WebViewK
    type AttrGetType WebViewWindowFeaturesPropertyInfo = WebWindowFeatures
    type AttrLabel WebViewWindowFeaturesPropertyInfo = "WebView::window-features"
    attrGet _ = getWebViewWindowFeatures
    attrSet _ = setWebViewWindowFeatures
    attrConstruct _ = constructWebViewWindowFeatures

-- VVV Prop "zoom-level"
   -- Type: TBasicType TFloat
   -- Flags: [PropertyReadable,PropertyWritable]

getWebViewZoomLevel :: (MonadIO m, WebViewK o) => o -> m Float
getWebViewZoomLevel obj = liftIO $ getObjectPropertyFloat obj "zoom-level"

setWebViewZoomLevel :: (MonadIO m, WebViewK o) => o -> Float -> m ()
setWebViewZoomLevel obj val = liftIO $ setObjectPropertyFloat obj "zoom-level" val

constructWebViewZoomLevel :: Float -> IO ([Char], GValue)
constructWebViewZoomLevel val = constructObjectPropertyFloat "zoom-level" val

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

type instance AttributeList WebView = WebViewAttributeList
type WebViewAttributeList = ('[ '("app-paintable", Gtk.WidgetAppPaintablePropertyInfo), '("border-width", Gtk.ContainerBorderWidthPropertyInfo), '("can-default", Gtk.WidgetCanDefaultPropertyInfo), '("can-focus", Gtk.WidgetCanFocusPropertyInfo), '("child", Gtk.ContainerChildPropertyInfo), '("composite-child", Gtk.WidgetCompositeChildPropertyInfo), '("copy-target-list", WebViewCopyTargetListPropertyInfo), '("custom-encoding", WebViewCustomEncodingPropertyInfo), '("double-buffered", Gtk.WidgetDoubleBufferedPropertyInfo), '("editable", WebViewEditablePropertyInfo), '("encoding", WebViewEncodingPropertyInfo), '("events", Gtk.WidgetEventsPropertyInfo), '("expand", Gtk.WidgetExpandPropertyInfo), '("full-content-zoom", WebViewFullContentZoomPropertyInfo), '("hadjustment", Gtk.ScrollableHadjustmentPropertyInfo), '("halign", Gtk.WidgetHalignPropertyInfo), '("has-default", Gtk.WidgetHasDefaultPropertyInfo), '("has-focus", Gtk.WidgetHasFocusPropertyInfo), '("has-tooltip", Gtk.WidgetHasTooltipPropertyInfo), '("height-request", Gtk.WidgetHeightRequestPropertyInfo), '("hexpand", Gtk.WidgetHexpandPropertyInfo), '("hexpand-set", Gtk.WidgetHexpandSetPropertyInfo), '("hscroll-policy", Gtk.ScrollableHscrollPolicyPropertyInfo), '("icon-uri", WebViewIconUriPropertyInfo), '("im-context", WebViewImContextPropertyInfo), '("is-focus", Gtk.WidgetIsFocusPropertyInfo), '("load-status", WebViewLoadStatusPropertyInfo), '("margin", Gtk.WidgetMarginPropertyInfo), '("margin-bottom", Gtk.WidgetMarginBottomPropertyInfo), '("margin-end", Gtk.WidgetMarginEndPropertyInfo), '("margin-left", Gtk.WidgetMarginLeftPropertyInfo), '("margin-right", Gtk.WidgetMarginRightPropertyInfo), '("margin-start", Gtk.WidgetMarginStartPropertyInfo), '("margin-top", Gtk.WidgetMarginTopPropertyInfo), '("name", Gtk.WidgetNamePropertyInfo), '("no-show-all", Gtk.WidgetNoShowAllPropertyInfo), '("opacity", Gtk.WidgetOpacityPropertyInfo), '("parent", Gtk.WidgetParentPropertyInfo), '("paste-target-list", WebViewPasteTargetListPropertyInfo), '("progress", WebViewProgressPropertyInfo), '("receives-default", Gtk.WidgetReceivesDefaultPropertyInfo), '("resize-mode", Gtk.ContainerResizeModePropertyInfo), '("scale-factor", Gtk.WidgetScaleFactorPropertyInfo), '("self-scrolling", WebViewSelfScrollingPropertyInfo), '("sensitive", Gtk.WidgetSensitivePropertyInfo), '("settings", WebViewSettingsPropertyInfo), '("style", Gtk.WidgetStylePropertyInfo), '("title", WebViewTitlePropertyInfo), '("tooltip-markup", Gtk.WidgetTooltipMarkupPropertyInfo), '("tooltip-text", Gtk.WidgetTooltipTextPropertyInfo), '("transparent", WebViewTransparentPropertyInfo), '("uri", WebViewUriPropertyInfo), '("vadjustment", Gtk.ScrollableVadjustmentPropertyInfo), '("valign", Gtk.WidgetValignPropertyInfo), '("vexpand", Gtk.WidgetVexpandPropertyInfo), '("vexpand-set", Gtk.WidgetVexpandSetPropertyInfo), '("view-mode", WebViewViewModePropertyInfo), '("viewport-attributes", WebViewViewportAttributesPropertyInfo), '("visible", Gtk.WidgetVisiblePropertyInfo), '("vscroll-policy", Gtk.ScrollableVscrollPolicyPropertyInfo), '("web-inspector", WebViewWebInspectorPropertyInfo), '("width-request", Gtk.WidgetWidthRequestPropertyInfo), '("window", Gtk.WidgetWindowPropertyInfo), '("window-features", WebViewWindowFeaturesPropertyInfo), '("zoom-level", WebViewZoomLevelPropertyInfo)] :: [(Symbol, *)])

data WebViewCloseWebViewSignalInfo
instance SignalInfo WebViewCloseWebViewSignalInfo where
    type HaskellCallbackType WebViewCloseWebViewSignalInfo = WebViewCloseWebViewCallback
    connectSignal _ = connectWebViewCloseWebView

data WebViewConsoleMessageSignalInfo
instance SignalInfo WebViewConsoleMessageSignalInfo where
    type HaskellCallbackType WebViewConsoleMessageSignalInfo = WebViewConsoleMessageCallback
    connectSignal _ = connectWebViewConsoleMessage

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

data WebViewCopyClipboardSignalInfo
instance SignalInfo WebViewCopyClipboardSignalInfo where
    type HaskellCallbackType WebViewCopyClipboardSignalInfo = WebViewCopyClipboardCallback
    connectSignal _ = connectWebViewCopyClipboard

data WebViewCreatePluginWidgetSignalInfo
instance SignalInfo WebViewCreatePluginWidgetSignalInfo where
    type HaskellCallbackType WebViewCreatePluginWidgetSignalInfo = WebViewCreatePluginWidgetCallback
    connectSignal _ = connectWebViewCreatePluginWidget

data WebViewCreateWebViewSignalInfo
instance SignalInfo WebViewCreateWebViewSignalInfo where
    type HaskellCallbackType WebViewCreateWebViewSignalInfo = WebViewCreateWebViewCallback
    connectSignal _ = connectWebViewCreateWebView

data WebViewCutClipboardSignalInfo
instance SignalInfo WebViewCutClipboardSignalInfo where
    type HaskellCallbackType WebViewCutClipboardSignalInfo = WebViewCutClipboardCallback
    connectSignal _ = connectWebViewCutClipboard

data WebViewDatabaseQuotaExceededSignalInfo
instance SignalInfo WebViewDatabaseQuotaExceededSignalInfo where
    type HaskellCallbackType WebViewDatabaseQuotaExceededSignalInfo = WebViewDatabaseQuotaExceededCallback
    connectSignal _ = connectWebViewDatabaseQuotaExceeded

data WebViewDocumentLoadFinishedSignalInfo
instance SignalInfo WebViewDocumentLoadFinishedSignalInfo where
    type HaskellCallbackType WebViewDocumentLoadFinishedSignalInfo = WebViewDocumentLoadFinishedCallback
    connectSignal _ = connectWebViewDocumentLoadFinished

data WebViewDownloadRequestedSignalInfo
instance SignalInfo WebViewDownloadRequestedSignalInfo where
    type HaskellCallbackType WebViewDownloadRequestedSignalInfo = WebViewDownloadRequestedCallback
    connectSignal _ = connectWebViewDownloadRequested

data WebViewEditingBeganSignalInfo
instance SignalInfo WebViewEditingBeganSignalInfo where
    type HaskellCallbackType WebViewEditingBeganSignalInfo = WebViewEditingBeganCallback
    connectSignal _ = connectWebViewEditingBegan

data WebViewEditingEndedSignalInfo
instance SignalInfo WebViewEditingEndedSignalInfo where
    type HaskellCallbackType WebViewEditingEndedSignalInfo = WebViewEditingEndedCallback
    connectSignal _ = connectWebViewEditingEnded

data WebViewEnteringFullscreenSignalInfo
instance SignalInfo WebViewEnteringFullscreenSignalInfo where
    type HaskellCallbackType WebViewEnteringFullscreenSignalInfo = WebViewEnteringFullscreenCallback
    connectSignal _ = connectWebViewEnteringFullscreen

data WebViewFrameCreatedSignalInfo
instance SignalInfo WebViewFrameCreatedSignalInfo where
    type HaskellCallbackType WebViewFrameCreatedSignalInfo = WebViewFrameCreatedCallback
    connectSignal _ = connectWebViewFrameCreated

data WebViewGeolocationPolicyDecisionCancelledSignalInfo
instance SignalInfo WebViewGeolocationPolicyDecisionCancelledSignalInfo where
    type HaskellCallbackType WebViewGeolocationPolicyDecisionCancelledSignalInfo = WebViewGeolocationPolicyDecisionCancelledCallback
    connectSignal _ = connectWebViewGeolocationPolicyDecisionCancelled

data WebViewGeolocationPolicyDecisionRequestedSignalInfo
instance SignalInfo WebViewGeolocationPolicyDecisionRequestedSignalInfo where
    type HaskellCallbackType WebViewGeolocationPolicyDecisionRequestedSignalInfo = WebViewGeolocationPolicyDecisionRequestedCallback
    connectSignal _ = connectWebViewGeolocationPolicyDecisionRequested

data WebViewHoveringOverLinkSignalInfo
instance SignalInfo WebViewHoveringOverLinkSignalInfo where
    type HaskellCallbackType WebViewHoveringOverLinkSignalInfo = WebViewHoveringOverLinkCallback
    connectSignal _ = connectWebViewHoveringOverLink

data WebViewIconLoadedSignalInfo
instance SignalInfo WebViewIconLoadedSignalInfo where
    type HaskellCallbackType WebViewIconLoadedSignalInfo = WebViewIconLoadedCallback
    connectSignal _ = connectWebViewIconLoaded

data WebViewLeavingFullscreenSignalInfo
instance SignalInfo WebViewLeavingFullscreenSignalInfo where
    type HaskellCallbackType WebViewLeavingFullscreenSignalInfo = WebViewLeavingFullscreenCallback
    connectSignal _ = connectWebViewLeavingFullscreen

data WebViewLoadCommittedSignalInfo
instance SignalInfo WebViewLoadCommittedSignalInfo where
    type HaskellCallbackType WebViewLoadCommittedSignalInfo = WebViewLoadCommittedCallback
    connectSignal _ = connectWebViewLoadCommitted

data WebViewLoadErrorSignalInfo
instance SignalInfo WebViewLoadErrorSignalInfo where
    type HaskellCallbackType WebViewLoadErrorSignalInfo = WebViewLoadErrorCallback
    connectSignal _ = connectWebViewLoadError

data WebViewLoadFinishedSignalInfo
instance SignalInfo WebViewLoadFinishedSignalInfo where
    type HaskellCallbackType WebViewLoadFinishedSignalInfo = WebViewLoadFinishedCallback
    connectSignal _ = connectWebViewLoadFinished

data WebViewLoadProgressChangedSignalInfo
instance SignalInfo WebViewLoadProgressChangedSignalInfo where
    type HaskellCallbackType WebViewLoadProgressChangedSignalInfo = WebViewLoadProgressChangedCallback
    connectSignal _ = connectWebViewLoadProgressChanged

data WebViewLoadStartedSignalInfo
instance SignalInfo WebViewLoadStartedSignalInfo where
    type HaskellCallbackType WebViewLoadStartedSignalInfo = WebViewLoadStartedCallback
    connectSignal _ = connectWebViewLoadStarted

data WebViewMimeTypePolicyDecisionRequestedSignalInfo
instance SignalInfo WebViewMimeTypePolicyDecisionRequestedSignalInfo where
    type HaskellCallbackType WebViewMimeTypePolicyDecisionRequestedSignalInfo = WebViewMimeTypePolicyDecisionRequestedCallback
    connectSignal _ = connectWebViewMimeTypePolicyDecisionRequested

data WebViewMoveCursorSignalInfo
instance SignalInfo WebViewMoveCursorSignalInfo where
    type HaskellCallbackType WebViewMoveCursorSignalInfo = WebViewMoveCursorCallback
    connectSignal _ = connectWebViewMoveCursor

data WebViewNavigationPolicyDecisionRequestedSignalInfo
instance SignalInfo WebViewNavigationPolicyDecisionRequestedSignalInfo where
    type HaskellCallbackType WebViewNavigationPolicyDecisionRequestedSignalInfo = WebViewNavigationPolicyDecisionRequestedCallback
    connectSignal _ = connectWebViewNavigationPolicyDecisionRequested

data WebViewNavigationRequestedSignalInfo
instance SignalInfo WebViewNavigationRequestedSignalInfo where
    type HaskellCallbackType WebViewNavigationRequestedSignalInfo = WebViewNavigationRequestedCallback
    connectSignal _ = connectWebViewNavigationRequested

data WebViewNewWindowPolicyDecisionRequestedSignalInfo
instance SignalInfo WebViewNewWindowPolicyDecisionRequestedSignalInfo where
    type HaskellCallbackType WebViewNewWindowPolicyDecisionRequestedSignalInfo = WebViewNewWindowPolicyDecisionRequestedCallback
    connectSignal _ = connectWebViewNewWindowPolicyDecisionRequested

data WebViewOnloadEventSignalInfo
instance SignalInfo WebViewOnloadEventSignalInfo where
    type HaskellCallbackType WebViewOnloadEventSignalInfo = WebViewOnloadEventCallback
    connectSignal _ = connectWebViewOnloadEvent

data WebViewPasteClipboardSignalInfo
instance SignalInfo WebViewPasteClipboardSignalInfo where
    type HaskellCallbackType WebViewPasteClipboardSignalInfo = WebViewPasteClipboardCallback
    connectSignal _ = connectWebViewPasteClipboard

data WebViewPopulatePopupSignalInfo
instance SignalInfo WebViewPopulatePopupSignalInfo where
    type HaskellCallbackType WebViewPopulatePopupSignalInfo = WebViewPopulatePopupCallback
    connectSignal _ = connectWebViewPopulatePopup

data WebViewPrintRequestedSignalInfo
instance SignalInfo WebViewPrintRequestedSignalInfo where
    type HaskellCallbackType WebViewPrintRequestedSignalInfo = WebViewPrintRequestedCallback
    connectSignal _ = connectWebViewPrintRequested

data WebViewRedoSignalInfo
instance SignalInfo WebViewRedoSignalInfo where
    type HaskellCallbackType WebViewRedoSignalInfo = WebViewRedoCallback
    connectSignal _ = connectWebViewRedo

data WebViewResourceContentLengthReceivedSignalInfo
instance SignalInfo WebViewResourceContentLengthReceivedSignalInfo where
    type HaskellCallbackType WebViewResourceContentLengthReceivedSignalInfo = WebViewResourceContentLengthReceivedCallback
    connectSignal _ = connectWebViewResourceContentLengthReceived

data WebViewResourceLoadFailedSignalInfo
instance SignalInfo WebViewResourceLoadFailedSignalInfo where
    type HaskellCallbackType WebViewResourceLoadFailedSignalInfo = WebViewResourceLoadFailedCallback
    connectSignal _ = connectWebViewResourceLoadFailed

data WebViewResourceLoadFinishedSignalInfo
instance SignalInfo WebViewResourceLoadFinishedSignalInfo where
    type HaskellCallbackType WebViewResourceLoadFinishedSignalInfo = WebViewResourceLoadFinishedCallback
    connectSignal _ = connectWebViewResourceLoadFinished

data WebViewResourceRequestStartingSignalInfo
instance SignalInfo WebViewResourceRequestStartingSignalInfo where
    type HaskellCallbackType WebViewResourceRequestStartingSignalInfo = WebViewResourceRequestStartingCallback
    connectSignal _ = connectWebViewResourceRequestStarting

data WebViewResourceResponseReceivedSignalInfo
instance SignalInfo WebViewResourceResponseReceivedSignalInfo where
    type HaskellCallbackType WebViewResourceResponseReceivedSignalInfo = WebViewResourceResponseReceivedCallback
    connectSignal _ = connectWebViewResourceResponseReceived

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

data WebViewScriptAlertSignalInfo
instance SignalInfo WebViewScriptAlertSignalInfo where
    type HaskellCallbackType WebViewScriptAlertSignalInfo = WebViewScriptAlertCallback
    connectSignal _ = connectWebViewScriptAlert

data WebViewScriptConfirmSignalInfo
instance SignalInfo WebViewScriptConfirmSignalInfo where
    type HaskellCallbackType WebViewScriptConfirmSignalInfo = WebViewScriptConfirmCallback
    connectSignal _ = connectWebViewScriptConfirm

data WebViewScriptPromptSignalInfo
instance SignalInfo WebViewScriptPromptSignalInfo where
    type HaskellCallbackType WebViewScriptPromptSignalInfo = WebViewScriptPromptCallback
    connectSignal _ = connectWebViewScriptPrompt

data WebViewSelectAllSignalInfo
instance SignalInfo WebViewSelectAllSignalInfo where
    type HaskellCallbackType WebViewSelectAllSignalInfo = WebViewSelectAllCallback
    connectSignal _ = connectWebViewSelectAll

data WebViewSelectionChangedSignalInfo
instance SignalInfo WebViewSelectionChangedSignalInfo where
    type HaskellCallbackType WebViewSelectionChangedSignalInfo = WebViewSelectionChangedCallback
    connectSignal _ = connectWebViewSelectionChanged

data WebViewShouldApplyStyleSignalInfo
instance SignalInfo WebViewShouldApplyStyleSignalInfo where
    type HaskellCallbackType WebViewShouldApplyStyleSignalInfo = WebViewShouldApplyStyleCallback
    connectSignal _ = connectWebViewShouldApplyStyle

data WebViewShouldBeginEditingSignalInfo
instance SignalInfo WebViewShouldBeginEditingSignalInfo where
    type HaskellCallbackType WebViewShouldBeginEditingSignalInfo = WebViewShouldBeginEditingCallback
    connectSignal _ = connectWebViewShouldBeginEditing

data WebViewShouldChangeSelectedRangeSignalInfo
instance SignalInfo WebViewShouldChangeSelectedRangeSignalInfo where
    type HaskellCallbackType WebViewShouldChangeSelectedRangeSignalInfo = WebViewShouldChangeSelectedRangeCallback
    connectSignal _ = connectWebViewShouldChangeSelectedRange

data WebViewShouldDeleteRangeSignalInfo
instance SignalInfo WebViewShouldDeleteRangeSignalInfo where
    type HaskellCallbackType WebViewShouldDeleteRangeSignalInfo = WebViewShouldDeleteRangeCallback
    connectSignal _ = connectWebViewShouldDeleteRange

data WebViewShouldEndEditingSignalInfo
instance SignalInfo WebViewShouldEndEditingSignalInfo where
    type HaskellCallbackType WebViewShouldEndEditingSignalInfo = WebViewShouldEndEditingCallback
    connectSignal _ = connectWebViewShouldEndEditing

data WebViewShouldInsertNodeSignalInfo
instance SignalInfo WebViewShouldInsertNodeSignalInfo where
    type HaskellCallbackType WebViewShouldInsertNodeSignalInfo = WebViewShouldInsertNodeCallback
    connectSignal _ = connectWebViewShouldInsertNode

data WebViewShouldInsertTextSignalInfo
instance SignalInfo WebViewShouldInsertTextSignalInfo where
    type HaskellCallbackType WebViewShouldInsertTextSignalInfo = WebViewShouldInsertTextCallback
    connectSignal _ = connectWebViewShouldInsertText

data WebViewShouldShowDeleteInterfaceForElementSignalInfo
instance SignalInfo WebViewShouldShowDeleteInterfaceForElementSignalInfo where
    type HaskellCallbackType WebViewShouldShowDeleteInterfaceForElementSignalInfo = WebViewShouldShowDeleteInterfaceForElementCallback
    connectSignal _ = connectWebViewShouldShowDeleteInterfaceForElement

data WebViewStatusBarTextChangedSignalInfo
instance SignalInfo WebViewStatusBarTextChangedSignalInfo where
    type HaskellCallbackType WebViewStatusBarTextChangedSignalInfo = WebViewStatusBarTextChangedCallback
    connectSignal _ = connectWebViewStatusBarTextChanged

data WebViewTitleChangedSignalInfo
instance SignalInfo WebViewTitleChangedSignalInfo where
    type HaskellCallbackType WebViewTitleChangedSignalInfo = WebViewTitleChangedCallback
    connectSignal _ = connectWebViewTitleChanged

data WebViewUndoSignalInfo
instance SignalInfo WebViewUndoSignalInfo where
    type HaskellCallbackType WebViewUndoSignalInfo = WebViewUndoCallback
    connectSignal _ = connectWebViewUndo

data WebViewUserChangedContentsSignalInfo
instance SignalInfo WebViewUserChangedContentsSignalInfo where
    type HaskellCallbackType WebViewUserChangedContentsSignalInfo = WebViewUserChangedContentsCallback
    connectSignal _ = connectWebViewUserChangedContents

data WebViewViewportAttributesChangedSignalInfo
instance SignalInfo WebViewViewportAttributesChangedSignalInfo where
    type HaskellCallbackType WebViewViewportAttributesChangedSignalInfo = WebViewViewportAttributesChangedCallback
    connectSignal _ = connectWebViewViewportAttributesChanged

data WebViewViewportAttributesRecomputeRequestedSignalInfo
instance SignalInfo WebViewViewportAttributesRecomputeRequestedSignalInfo where
    type HaskellCallbackType WebViewViewportAttributesRecomputeRequestedSignalInfo = WebViewViewportAttributesRecomputeRequestedCallback
    connectSignal _ = connectWebViewViewportAttributesRecomputeRequested

data WebViewWebViewReadySignalInfo
instance SignalInfo WebViewWebViewReadySignalInfo where
    type HaskellCallbackType WebViewWebViewReadySignalInfo = WebViewWebViewReadyCallback
    connectSignal _ = connectWebViewWebViewReady

data WebViewWindowObjectClearedSignalInfo
instance SignalInfo WebViewWindowObjectClearedSignalInfo where
    type HaskellCallbackType WebViewWindowObjectClearedSignalInfo = WebViewWindowObjectClearedCallback
    connectSignal _ = connectWebViewWindowObjectCleared

type instance SignalList WebView = WebViewSignalList
type WebViewSignalList = ('[ '("accel-closures-changed", Gtk.WidgetAccelClosuresChangedSignalInfo), '("add", Gtk.ContainerAddSignalInfo), '("button-press-event", Gtk.WidgetButtonPressEventSignalInfo), '("button-release-event", Gtk.WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", Gtk.WidgetCanActivateAccelSignalInfo), '("check-resize", Gtk.ContainerCheckResizeSignalInfo), '("child-notify", Gtk.WidgetChildNotifySignalInfo), '("close-web-view", WebViewCloseWebViewSignalInfo), '("composited-changed", Gtk.WidgetCompositedChangedSignalInfo), '("configure-event", Gtk.WidgetConfigureEventSignalInfo), '("console-message", WebViewConsoleMessageSignalInfo), '("context-menu", WebViewContextMenuSignalInfo), '("copy-clipboard", WebViewCopyClipboardSignalInfo), '("create-plugin-widget", WebViewCreatePluginWidgetSignalInfo), '("create-web-view", WebViewCreateWebViewSignalInfo), '("cut-clipboard", WebViewCutClipboardSignalInfo), '("damage-event", Gtk.WidgetDamageEventSignalInfo), '("database-quota-exceeded", WebViewDatabaseQuotaExceededSignalInfo), '("delete-event", Gtk.WidgetDeleteEventSignalInfo), '("destroy", Gtk.WidgetDestroySignalInfo), '("destroy-event", Gtk.WidgetDestroyEventSignalInfo), '("direction-changed", Gtk.WidgetDirectionChangedSignalInfo), '("document-load-finished", WebViewDocumentLoadFinishedSignalInfo), '("download-requested", WebViewDownloadRequestedSignalInfo), '("drag-begin", Gtk.WidgetDragBeginSignalInfo), '("drag-data-delete", Gtk.WidgetDragDataDeleteSignalInfo), '("drag-data-get", Gtk.WidgetDragDataGetSignalInfo), '("drag-data-received", Gtk.WidgetDragDataReceivedSignalInfo), '("drag-drop", Gtk.WidgetDragDropSignalInfo), '("drag-end", Gtk.WidgetDragEndSignalInfo), '("drag-failed", Gtk.WidgetDragFailedSignalInfo), '("drag-leave", Gtk.WidgetDragLeaveSignalInfo), '("drag-motion", Gtk.WidgetDragMotionSignalInfo), '("draw", Gtk.WidgetDrawSignalInfo), '("editing-began", WebViewEditingBeganSignalInfo), '("editing-ended", WebViewEditingEndedSignalInfo), '("enter-notify-event", Gtk.WidgetEnterNotifyEventSignalInfo), '("entering-fullscreen", WebViewEnteringFullscreenSignalInfo), '("event", Gtk.WidgetEventSignalInfo), '("event-after", Gtk.WidgetEventAfterSignalInfo), '("focus", Gtk.WidgetFocusSignalInfo), '("focus-in-event", Gtk.WidgetFocusInEventSignalInfo), '("focus-out-event", Gtk.WidgetFocusOutEventSignalInfo), '("frame-created", WebViewFrameCreatedSignalInfo), '("geolocation-policy-decision-cancelled", WebViewGeolocationPolicyDecisionCancelledSignalInfo), '("geolocation-policy-decision-requested", WebViewGeolocationPolicyDecisionRequestedSignalInfo), '("grab-broken-event", Gtk.WidgetGrabBrokenEventSignalInfo), '("grab-focus", Gtk.WidgetGrabFocusSignalInfo), '("grab-notify", Gtk.WidgetGrabNotifySignalInfo), '("hide", Gtk.WidgetHideSignalInfo), '("hierarchy-changed", Gtk.WidgetHierarchyChangedSignalInfo), '("hovering-over-link", WebViewHoveringOverLinkSignalInfo), '("icon-loaded", WebViewIconLoadedSignalInfo), '("key-press-event", Gtk.WidgetKeyPressEventSignalInfo), '("key-release-event", Gtk.WidgetKeyReleaseEventSignalInfo), '("keynav-failed", Gtk.WidgetKeynavFailedSignalInfo), '("leave-notify-event", Gtk.WidgetLeaveNotifyEventSignalInfo), '("leaving-fullscreen", WebViewLeavingFullscreenSignalInfo), '("load-committed", WebViewLoadCommittedSignalInfo), '("load-error", WebViewLoadErrorSignalInfo), '("load-finished", WebViewLoadFinishedSignalInfo), '("load-progress-changed", WebViewLoadProgressChangedSignalInfo), '("load-started", WebViewLoadStartedSignalInfo), '("map", Gtk.WidgetMapSignalInfo), '("map-event", Gtk.WidgetMapEventSignalInfo), '("mime-type-policy-decision-requested", WebViewMimeTypePolicyDecisionRequestedSignalInfo), '("mnemonic-activate", Gtk.WidgetMnemonicActivateSignalInfo), '("motion-notify-event", Gtk.WidgetMotionNotifyEventSignalInfo), '("move-cursor", WebViewMoveCursorSignalInfo), '("move-focus", Gtk.WidgetMoveFocusSignalInfo), '("navigation-policy-decision-requested", WebViewNavigationPolicyDecisionRequestedSignalInfo), '("navigation-requested", WebViewNavigationRequestedSignalInfo), '("new-window-policy-decision-requested", WebViewNewWindowPolicyDecisionRequestedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("onload-event", WebViewOnloadEventSignalInfo), '("parent-set", Gtk.WidgetParentSetSignalInfo), '("paste-clipboard", WebViewPasteClipboardSignalInfo), '("populate-popup", WebViewPopulatePopupSignalInfo), '("popup-menu", Gtk.WidgetPopupMenuSignalInfo), '("print-requested", WebViewPrintRequestedSignalInfo), '("property-notify-event", Gtk.WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", Gtk.WidgetProximityInEventSignalInfo), '("proximity-out-event", Gtk.WidgetProximityOutEventSignalInfo), '("query-tooltip", Gtk.WidgetQueryTooltipSignalInfo), '("realize", Gtk.WidgetRealizeSignalInfo), '("redo", WebViewRedoSignalInfo), '("remove", Gtk.ContainerRemoveSignalInfo), '("resource-content-length-received", WebViewResourceContentLengthReceivedSignalInfo), '("resource-load-failed", WebViewResourceLoadFailedSignalInfo), '("resource-load-finished", WebViewResourceLoadFinishedSignalInfo), '("resource-request-starting", WebViewResourceRequestStartingSignalInfo), '("resource-response-received", WebViewResourceResponseReceivedSignalInfo), '("run-file-chooser", WebViewRunFileChooserSignalInfo), '("screen-changed", Gtk.WidgetScreenChangedSignalInfo), '("script-alert", WebViewScriptAlertSignalInfo), '("script-confirm", WebViewScriptConfirmSignalInfo), '("script-prompt", WebViewScriptPromptSignalInfo), '("scroll-event", Gtk.WidgetScrollEventSignalInfo), '("select-all", WebViewSelectAllSignalInfo), '("selection-changed", WebViewSelectionChangedSignalInfo), '("selection-clear-event", Gtk.WidgetSelectionClearEventSignalInfo), '("selection-get", Gtk.WidgetSelectionGetSignalInfo), '("selection-notify-event", Gtk.WidgetSelectionNotifyEventSignalInfo), '("selection-received", Gtk.WidgetSelectionReceivedSignalInfo), '("selection-request-event", Gtk.WidgetSelectionRequestEventSignalInfo), '("set-focus-child", Gtk.ContainerSetFocusChildSignalInfo), '("should-apply-style", WebViewShouldApplyStyleSignalInfo), '("should-begin-editing", WebViewShouldBeginEditingSignalInfo), '("should-change-selected-range", WebViewShouldChangeSelectedRangeSignalInfo), '("should-delete-range", WebViewShouldDeleteRangeSignalInfo), '("should-end-editing", WebViewShouldEndEditingSignalInfo), '("should-insert-node", WebViewShouldInsertNodeSignalInfo), '("should-insert-text", WebViewShouldInsertTextSignalInfo), '("should-show-delete-interface-for-element", WebViewShouldShowDeleteInterfaceForElementSignalInfo), '("show", Gtk.WidgetShowSignalInfo), '("show-help", Gtk.WidgetShowHelpSignalInfo), '("size-allocate", Gtk.WidgetSizeAllocateSignalInfo), '("state-changed", Gtk.WidgetStateChangedSignalInfo), '("state-flags-changed", Gtk.WidgetStateFlagsChangedSignalInfo), '("status-bar-text-changed", WebViewStatusBarTextChangedSignalInfo), '("style-set", Gtk.WidgetStyleSetSignalInfo), '("style-updated", Gtk.WidgetStyleUpdatedSignalInfo), '("title-changed", WebViewTitleChangedSignalInfo), '("touch-event", Gtk.WidgetTouchEventSignalInfo), '("undo", WebViewUndoSignalInfo), '("unmap", Gtk.WidgetUnmapSignalInfo), '("unmap-event", Gtk.WidgetUnmapEventSignalInfo), '("unrealize", Gtk.WidgetUnrealizeSignalInfo), '("user-changed-contents", WebViewUserChangedContentsSignalInfo), '("viewport-attributes-changed", WebViewViewportAttributesChangedSignalInfo), '("viewport-attributes-recompute-requested", WebViewViewportAttributesRecomputeRequestedSignalInfo), '("visibility-notify-event", Gtk.WidgetVisibilityNotifyEventSignalInfo), '("web-view-ready", WebViewWebViewReadySignalInfo), '("window-object-cleared", WebViewWindowObjectClearedSignalInfo), '("window-state-event", Gtk.WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])

-- method WebView::new
-- method type : Constructor
-- Args : []
-- Lengths : []
-- hInArgs : []
-- returnType : TInterface "WebKit" "WebView"
-- throws : False
-- Skip return : False

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


webViewNew ::
    (MonadIO m) =>
    m WebView
webViewNew  = liftIO $ do
    result <- webkit_web_view_new
    checkUnexpectedReturnNULL "webkit_web_view_new" result
    result' <- (newObject WebView) result
    return result'

-- method WebView::can_copy_clipboard
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TBoolean
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_can_copy_clipboard" webkit_web_view_can_copy_clipboard :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    IO CInt


webViewCanCopyClipboard ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    m Bool
webViewCanCopyClipboard _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- webkit_web_view_can_copy_clipboard _obj'
    let result' = (/= 0) result
    touchManagedPtr _obj
    return result'

-- method WebView::can_cut_clipboard
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TBoolean
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_can_cut_clipboard" webkit_web_view_can_cut_clipboard :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    IO CInt


webViewCanCutClipboard ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    m Bool
webViewCanCutClipboard _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- webkit_web_view_can_cut_clipboard _obj'
    let result' = (/= 0) result
    touchManagedPtr _obj
    return result'

-- method WebView::can_go_back
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TBoolean
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_can_go_back" webkit_web_view_can_go_back :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    IO CInt


webViewCanGoBack ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    m Bool
webViewCanGoBack _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- webkit_web_view_can_go_back _obj'
    let result' = (/= 0) result
    touchManagedPtr _obj
    return result'

-- method WebView::can_go_back_or_forward
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "steps", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "steps", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TBoolean
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_can_go_back_or_forward" webkit_web_view_can_go_back_or_forward :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    Int32 ->                                -- steps : TBasicType TInt32
    IO CInt


webViewCanGoBackOrForward ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    Int32 ->                                -- steps
    m Bool
webViewCanGoBackOrForward _obj steps = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- webkit_web_view_can_go_back_or_forward _obj' steps
    let result' = (/= 0) result
    touchManagedPtr _obj
    return result'

-- method WebView::can_go_forward
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TBoolean
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_can_go_forward" webkit_web_view_can_go_forward :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    IO CInt


webViewCanGoForward ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    m Bool
webViewCanGoForward _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- webkit_web_view_can_go_forward _obj'
    let result' = (/= 0) result
    touchManagedPtr _obj
    return result'

-- method WebView::can_paste_clipboard
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TBoolean
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_can_paste_clipboard" webkit_web_view_can_paste_clipboard :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    IO CInt


webViewCanPasteClipboard ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    m Bool
webViewCanPasteClipboard _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- webkit_web_view_can_paste_clipboard _obj'
    let result' = (/= 0) result
    touchManagedPtr _obj
    return result'

-- method WebView::can_redo
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TBoolean
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_can_redo" webkit_web_view_can_redo :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    IO CInt


webViewCanRedo ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    m Bool
webViewCanRedo _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- webkit_web_view_can_redo _obj'
    let result' = (/= 0) result
    touchManagedPtr _obj
    return result'

-- method WebView::can_show_mime_type
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mime_type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mime_type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TBoolean
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_can_show_mime_type" webkit_web_view_can_show_mime_type :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    CString ->                              -- mime_type : TBasicType TUTF8
    IO CInt


webViewCanShowMimeType ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    T.Text ->                               -- mime_type
    m Bool
webViewCanShowMimeType _obj mime_type = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    mime_type' <- textToCString mime_type
    result <- webkit_web_view_can_show_mime_type _obj' mime_type'
    let result' = (/= 0) result
    touchManagedPtr _obj
    freeMem mime_type'
    return result'

-- method WebView::can_undo
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TBoolean
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_can_undo" webkit_web_view_can_undo :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    IO CInt


webViewCanUndo ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    m Bool
webViewCanUndo _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- webkit_web_view_can_undo _obj'
    let result' = (/= 0) result
    touchManagedPtr _obj
    return result'

-- method WebView::copy_clipboard
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_copy_clipboard" webkit_web_view_copy_clipboard :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    IO ()


webViewCopyClipboard ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    m ()
webViewCopyClipboard _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    webkit_web_view_copy_clipboard _obj'
    touchManagedPtr _obj
    return ()

-- method WebView::cut_clipboard
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_cut_clipboard" webkit_web_view_cut_clipboard :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    IO ()


webViewCutClipboard ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    m ()
webViewCutClipboard _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    webkit_web_view_cut_clipboard _obj'
    touchManagedPtr _obj
    return ()

-- method WebView::delete_selection
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_delete_selection" webkit_web_view_delete_selection :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    IO ()


webViewDeleteSelection ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    m ()
webViewDeleteSelection _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    webkit_web_view_delete_selection _obj'
    touchManagedPtr _obj
    return ()

-- method WebView::execute_script
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "script", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "script", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_execute_script" webkit_web_view_execute_script :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    CString ->                              -- script : TBasicType TUTF8
    IO ()


webViewExecuteScript ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    T.Text ->                               -- script
    m ()
webViewExecuteScript _obj script = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    script' <- textToCString script
    webkit_web_view_execute_script _obj' script'
    touchManagedPtr _obj
    freeMem script'
    return ()

-- method WebView::get_back_forward_list
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TInterface "WebKit" "WebBackForwardList"
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_get_back_forward_list" webkit_web_view_get_back_forward_list :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    IO (Ptr WebBackForwardList)


webViewGetBackForwardList ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    m WebBackForwardList
webViewGetBackForwardList _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- webkit_web_view_get_back_forward_list _obj'
    checkUnexpectedReturnNULL "webkit_web_view_get_back_forward_list" result
    result' <- (newObject WebBackForwardList) result
    touchManagedPtr _obj
    return result'

-- method WebView::get_copy_target_list
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TInterface "Gtk" "TargetList"
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_get_copy_target_list" webkit_web_view_get_copy_target_list :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    IO (Ptr Gtk.TargetList)


webViewGetCopyTargetList ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    m Gtk.TargetList
webViewGetCopyTargetList _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- webkit_web_view_get_copy_target_list _obj'
    checkUnexpectedReturnNULL "webkit_web_view_get_copy_target_list" result
    result' <- (wrapBoxed Gtk.TargetList) result
    touchManagedPtr _obj
    return result'

-- method WebView::get_custom_encoding
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TUTF8
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_get_custom_encoding" webkit_web_view_get_custom_encoding :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    IO CString


webViewGetCustomEncoding ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    m T.Text
webViewGetCustomEncoding _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- webkit_web_view_get_custom_encoding _obj'
    checkUnexpectedReturnNULL "webkit_web_view_get_custom_encoding" result
    result' <- cstringToText result
    touchManagedPtr _obj
    return result'

-- method WebView::get_dom_document
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TInterface "WebKit" "DOMDocument"
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_get_dom_document" webkit_web_view_get_dom_document :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    IO (Ptr DOMDocument)


webViewGetDomDocument ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    m DOMDocument
webViewGetDomDocument _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- webkit_web_view_get_dom_document _obj'
    checkUnexpectedReturnNULL "webkit_web_view_get_dom_document" result
    result' <- (newObject DOMDocument) result
    touchManagedPtr _obj
    return result'

-- method WebView::get_editable
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TBoolean
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_get_editable" webkit_web_view_get_editable :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    IO CInt


webViewGetEditable ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    m Bool
webViewGetEditable _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- webkit_web_view_get_editable _obj'
    let result' = (/= 0) result
    touchManagedPtr _obj
    return result'

-- method WebView::get_encoding
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TUTF8
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_get_encoding" webkit_web_view_get_encoding :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    IO CString


webViewGetEncoding ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    m T.Text
webViewGetEncoding _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- webkit_web_view_get_encoding _obj'
    checkUnexpectedReturnNULL "webkit_web_view_get_encoding" result
    result' <- cstringToText result
    touchManagedPtr _obj
    return result'

-- method WebView::get_focused_frame
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TInterface "WebKit" "WebFrame"
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_get_focused_frame" webkit_web_view_get_focused_frame :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    IO (Ptr WebFrame)


webViewGetFocusedFrame ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    m WebFrame
webViewGetFocusedFrame _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- webkit_web_view_get_focused_frame _obj'
    checkUnexpectedReturnNULL "webkit_web_view_get_focused_frame" result
    result' <- (newObject WebFrame) result
    touchManagedPtr _obj
    return result'

-- method WebView::get_full_content_zoom
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TBoolean
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_get_full_content_zoom" webkit_web_view_get_full_content_zoom :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    IO CInt


webViewGetFullContentZoom ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    m Bool
webViewGetFullContentZoom _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- webkit_web_view_get_full_content_zoom _obj'
    let result' = (/= 0) result
    touchManagedPtr _obj
    return result'

-- method WebView::get_hit_test_result
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "event", argType = TInterface "Gdk" "EventButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "event", argType = TInterface "Gdk" "EventButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TInterface "WebKit" "HitTestResult"
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_get_hit_test_result" webkit_web_view_get_hit_test_result :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    Ptr Gdk.EventButton ->                  -- event : TInterface "Gdk" "EventButton"
    IO (Ptr HitTestResult)


webViewGetHitTestResult ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    Gdk.EventButton ->                      -- event
    m HitTestResult
webViewGetHitTestResult _obj event = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let event' = unsafeManagedPtrGetPtr event
    result <- webkit_web_view_get_hit_test_result _obj' event'
    checkUnexpectedReturnNULL "webkit_web_view_get_hit_test_result" result
    result' <- (wrapObject HitTestResult) result
    touchManagedPtr _obj
    touchManagedPtr event
    return result'

-- method WebView::get_icon_pixbuf
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TInterface "GdkPixbuf" "Pixbuf"
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_get_icon_pixbuf" webkit_web_view_get_icon_pixbuf :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    IO (Ptr GdkPixbuf.Pixbuf)

{-# DEPRECATED webViewGetIconPixbuf ["(Since version 1.8)","Use webkit_web_view_try_get_favicon_pixbuf() instead."]#-}
webViewGetIconPixbuf ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    m GdkPixbuf.Pixbuf
webViewGetIconPixbuf _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- webkit_web_view_get_icon_pixbuf _obj'
    checkUnexpectedReturnNULL "webkit_web_view_get_icon_pixbuf" result
    result' <- (wrapObject GdkPixbuf.Pixbuf) result
    touchManagedPtr _obj
    return result'

-- method WebView::get_icon_uri
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TUTF8
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_get_icon_uri" webkit_web_view_get_icon_uri :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    IO CString


webViewGetIconUri ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    m T.Text
webViewGetIconUri _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- webkit_web_view_get_icon_uri _obj'
    checkUnexpectedReturnNULL "webkit_web_view_get_icon_uri" result
    result' <- cstringToText result
    touchManagedPtr _obj
    return result'

-- method WebView::get_inspector
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TInterface "WebKit" "WebInspector"
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_get_inspector" webkit_web_view_get_inspector :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    IO (Ptr WebInspector)


webViewGetInspector ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    m WebInspector
webViewGetInspector _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- webkit_web_view_get_inspector _obj'
    checkUnexpectedReturnNULL "webkit_web_view_get_inspector" result
    result' <- (newObject WebInspector) result
    touchManagedPtr _obj
    return result'

-- method WebView::get_load_status
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TInterface "WebKit" "LoadStatus"
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_get_load_status" webkit_web_view_get_load_status :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    IO CUInt


webViewGetLoadStatus ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    m LoadStatus
webViewGetLoadStatus _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- webkit_web_view_get_load_status _obj'
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr _obj
    return result'

-- method WebView::get_main_frame
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TInterface "WebKit" "WebFrame"
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_get_main_frame" webkit_web_view_get_main_frame :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    IO (Ptr WebFrame)


webViewGetMainFrame ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    m WebFrame
webViewGetMainFrame _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- webkit_web_view_get_main_frame _obj'
    checkUnexpectedReturnNULL "webkit_web_view_get_main_frame" result
    result' <- (newObject WebFrame) result
    touchManagedPtr _obj
    return result'

-- method WebView::get_paste_target_list
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TInterface "Gtk" "TargetList"
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_get_paste_target_list" webkit_web_view_get_paste_target_list :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    IO (Ptr Gtk.TargetList)


webViewGetPasteTargetList ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    m Gtk.TargetList
webViewGetPasteTargetList _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- webkit_web_view_get_paste_target_list _obj'
    checkUnexpectedReturnNULL "webkit_web_view_get_paste_target_list" result
    result' <- (wrapBoxed Gtk.TargetList) result
    touchManagedPtr _obj
    return result'

-- method WebView::get_progress
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TDouble
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_get_progress" webkit_web_view_get_progress :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    IO CDouble


webViewGetProgress ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    m Double
webViewGetProgress _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- webkit_web_view_get_progress _obj'
    let result' = realToFrac result
    touchManagedPtr _obj
    return result'

-- method WebView::get_settings
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TInterface "WebKit" "WebSettings"
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_get_settings" webkit_web_view_get_settings :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    IO (Ptr WebSettings)


webViewGetSettings ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    m WebSettings
webViewGetSettings _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- webkit_web_view_get_settings _obj'
    checkUnexpectedReturnNULL "webkit_web_view_get_settings" result
    result' <- (newObject WebSettings) result
    touchManagedPtr _obj
    return result'

-- method WebView::get_snapshot
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TInterface "cairo" "Surface"
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_get_snapshot" webkit_web_view_get_snapshot :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    IO (Ptr Cairo.Surface)


webViewGetSnapshot ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    m Cairo.Surface
webViewGetSnapshot _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- webkit_web_view_get_snapshot _obj'
    checkUnexpectedReturnNULL "webkit_web_view_get_snapshot" result
    result' <- (wrapBoxed Cairo.Surface) result
    touchManagedPtr _obj
    return result'

-- method WebView::get_title
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TUTF8
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_get_title" webkit_web_view_get_title :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    IO CString


webViewGetTitle ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    m T.Text
webViewGetTitle _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- webkit_web_view_get_title _obj'
    checkUnexpectedReturnNULL "webkit_web_view_get_title" result
    result' <- cstringToText result
    touchManagedPtr _obj
    return result'

-- method WebView::get_transparent
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TBoolean
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_get_transparent" webkit_web_view_get_transparent :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    IO CInt


webViewGetTransparent ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    m Bool
webViewGetTransparent _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- webkit_web_view_get_transparent _obj'
    let result' = (/= 0) result
    touchManagedPtr _obj
    return result'

-- method WebView::get_uri
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TUTF8
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_get_uri" webkit_web_view_get_uri :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    IO CString


webViewGetUri ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    m T.Text
webViewGetUri _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- webkit_web_view_get_uri _obj'
    checkUnexpectedReturnNULL "webkit_web_view_get_uri" result
    result' <- cstringToText result
    touchManagedPtr _obj
    return result'

-- method WebView::get_view_mode
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TInterface "WebKit" "WebViewViewMode"
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_get_view_mode" webkit_web_view_get_view_mode :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    IO CUInt


webViewGetViewMode ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    m WebViewViewMode
webViewGetViewMode _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- webkit_web_view_get_view_mode _obj'
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr _obj
    return result'

-- method WebView::get_view_source_mode
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TBoolean
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_get_view_source_mode" webkit_web_view_get_view_source_mode :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    IO CInt


webViewGetViewSourceMode ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    m Bool
webViewGetViewSourceMode _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- webkit_web_view_get_view_source_mode _obj'
    let result' = (/= 0) result
    touchManagedPtr _obj
    return result'

-- method WebView::get_viewport_attributes
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TInterface "WebKit" "ViewportAttributes"
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_get_viewport_attributes" webkit_web_view_get_viewport_attributes :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    IO (Ptr ViewportAttributes)


webViewGetViewportAttributes ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    m ViewportAttributes
webViewGetViewportAttributes _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- webkit_web_view_get_viewport_attributes _obj'
    checkUnexpectedReturnNULL "webkit_web_view_get_viewport_attributes" result
    result' <- (newObject ViewportAttributes) result
    touchManagedPtr _obj
    return result'

-- method WebView::get_window_features
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TInterface "WebKit" "WebWindowFeatures"
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_get_window_features" webkit_web_view_get_window_features :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    IO (Ptr WebWindowFeatures)


webViewGetWindowFeatures ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    m WebWindowFeatures
webViewGetWindowFeatures _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- webkit_web_view_get_window_features _obj'
    checkUnexpectedReturnNULL "webkit_web_view_get_window_features" result
    result' <- (newObject WebWindowFeatures) result
    touchManagedPtr _obj
    return result'

-- method WebView::get_zoom_level
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TFloat
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_get_zoom_level" webkit_web_view_get_zoom_level :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    IO CFloat


webViewGetZoomLevel ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    m Float
webViewGetZoomLevel _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- webkit_web_view_get_zoom_level _obj'
    let result' = realToFrac result
    touchManagedPtr _obj
    return result'

-- method WebView::go_back
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_go_back" webkit_web_view_go_back :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    IO ()


webViewGoBack ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    m ()
webViewGoBack _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    webkit_web_view_go_back _obj'
    touchManagedPtr _obj
    return ()

-- method WebView::go_back_or_forward
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "steps", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "steps", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_go_back_or_forward" webkit_web_view_go_back_or_forward :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    Int32 ->                                -- steps : TBasicType TInt32
    IO ()


webViewGoBackOrForward ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    Int32 ->                                -- steps
    m ()
webViewGoBackOrForward _obj steps = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    webkit_web_view_go_back_or_forward _obj' steps
    touchManagedPtr _obj
    return ()

-- method WebView::go_forward
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_go_forward" webkit_web_view_go_forward :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    IO ()


webViewGoForward ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    m ()
webViewGoForward _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    webkit_web_view_go_forward _obj'
    touchManagedPtr _obj
    return ()

-- method WebView::go_to_back_forward_item
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "item", argType = TInterface "WebKit" "WebHistoryItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "item", argType = TInterface "WebKit" "WebHistoryItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TBoolean
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_go_to_back_forward_item" webkit_web_view_go_to_back_forward_item :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    Ptr WebHistoryItem ->                   -- item : TInterface "WebKit" "WebHistoryItem"
    IO CInt


webViewGoToBackForwardItem ::
    (MonadIO m, WebViewK a, WebHistoryItemK b) =>
    a ->                                    -- _obj
    b ->                                    -- item
    m Bool
webViewGoToBackForwardItem _obj item = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let item' = unsafeManagedPtrCastPtr item
    result <- webkit_web_view_go_to_back_forward_item _obj' item'
    let result' = (/= 0) result
    touchManagedPtr _obj
    touchManagedPtr item
    return result'

-- method WebView::has_selection
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TBoolean
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_has_selection" webkit_web_view_has_selection :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    IO CInt


webViewHasSelection ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    m Bool
webViewHasSelection _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- webkit_web_view_has_selection _obj'
    let result' = (/= 0) result
    touchManagedPtr _obj
    return result'

-- method WebView::load_html_string
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "content", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "base_uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "content", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "base_uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_load_html_string" webkit_web_view_load_html_string :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    CString ->                              -- content : TBasicType TUTF8
    CString ->                              -- base_uri : TBasicType TUTF8
    IO ()

{-# DEPRECATED webViewLoadHtmlString ["(Since version 1.1.1)","Use webkit_web_view_load_string() instead."]#-}
webViewLoadHtmlString ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    T.Text ->                               -- content
    T.Text ->                               -- base_uri
    m ()
webViewLoadHtmlString _obj content base_uri = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    content' <- textToCString content
    base_uri' <- textToCString base_uri
    webkit_web_view_load_html_string _obj' content' base_uri'
    touchManagedPtr _obj
    freeMem content'
    freeMem base_uri'
    return ()

-- method WebView::load_request
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "request", argType = TInterface "WebKit" "NetworkRequest", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "request", argType = TInterface "WebKit" "NetworkRequest", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_load_request" webkit_web_view_load_request :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    Ptr NetworkRequest ->                   -- request : TInterface "WebKit" "NetworkRequest"
    IO ()


webViewLoadRequest ::
    (MonadIO m, WebViewK a, NetworkRequestK b) =>
    a ->                                    -- _obj
    b ->                                    -- request
    m ()
webViewLoadRequest _obj request = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let request' = unsafeManagedPtrCastPtr request
    webkit_web_view_load_request _obj' request'
    touchManagedPtr _obj
    touchManagedPtr request
    return ()

-- method WebView::load_string
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "content", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mime_type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "encoding", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "base_uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "content", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mime_type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "encoding", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "base_uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_load_string" webkit_web_view_load_string :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    CString ->                              -- content : TBasicType TUTF8
    CString ->                              -- mime_type : TBasicType TUTF8
    CString ->                              -- encoding : TBasicType TUTF8
    CString ->                              -- base_uri : TBasicType TUTF8
    IO ()


webViewLoadString ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    T.Text ->                               -- content
    T.Text ->                               -- mime_type
    T.Text ->                               -- encoding
    T.Text ->                               -- base_uri
    m ()
webViewLoadString _obj content mime_type encoding base_uri = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    content' <- textToCString content
    mime_type' <- textToCString mime_type
    encoding' <- textToCString encoding
    base_uri' <- textToCString base_uri
    webkit_web_view_load_string _obj' content' mime_type' encoding' base_uri'
    touchManagedPtr _obj
    freeMem content'
    freeMem mime_type'
    freeMem encoding'
    freeMem base_uri'
    return ()

-- method WebView::load_uri
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_load_uri" webkit_web_view_load_uri :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    CString ->                              -- uri : TBasicType TUTF8
    IO ()


webViewLoadUri ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    T.Text ->                               -- uri
    m ()
webViewLoadUri _obj uri = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    uri' <- textToCString uri
    webkit_web_view_load_uri _obj' uri'
    touchManagedPtr _obj
    freeMem uri'
    return ()

-- method WebView::mark_text_matches
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "string", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "case_sensitive", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "limit", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "string", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "case_sensitive", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "limit", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TUInt32
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_mark_text_matches" webkit_web_view_mark_text_matches :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    CString ->                              -- string : TBasicType TUTF8
    CInt ->                                 -- case_sensitive : TBasicType TBoolean
    Word32 ->                               -- limit : TBasicType TUInt32
    IO Word32


webViewMarkTextMatches ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    T.Text ->                               -- string
    Bool ->                                 -- case_sensitive
    Word32 ->                               -- limit
    m Word32
webViewMarkTextMatches _obj string case_sensitive limit = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    string' <- textToCString string
    let case_sensitive' = (fromIntegral . fromEnum) case_sensitive
    result <- webkit_web_view_mark_text_matches _obj' string' case_sensitive' limit
    touchManagedPtr _obj
    freeMem string'
    return result

-- method WebView::move_cursor
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "step", argType = TInterface "Gtk" "MovementStep", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "count", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "step", argType = TInterface "Gtk" "MovementStep", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "count", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_move_cursor" webkit_web_view_move_cursor :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    CUInt ->                                -- step : TInterface "Gtk" "MovementStep"
    Int32 ->                                -- count : TBasicType TInt32
    IO ()


webViewMoveCursor ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    Gtk.MovementStep ->                     -- step
    Int32 ->                                -- count
    m ()
webViewMoveCursor _obj step count = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let step' = (fromIntegral . fromEnum) step
    webkit_web_view_move_cursor _obj' step' count
    touchManagedPtr _obj
    return ()

-- method WebView::open
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_open" webkit_web_view_open :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    CString ->                              -- uri : TBasicType TUTF8
    IO ()

{-# DEPRECATED webViewOpen ["(Since version 1.1.1)","Use webkit_web_view_load_uri() instead."]#-}
webViewOpen ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    T.Text ->                               -- uri
    m ()
webViewOpen _obj uri = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    uri' <- textToCString uri
    webkit_web_view_open _obj' uri'
    touchManagedPtr _obj
    freeMem uri'
    return ()

-- method WebView::paste_clipboard
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_paste_clipboard" webkit_web_view_paste_clipboard :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    IO ()


webViewPasteClipboard ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    m ()
webViewPasteClipboard _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    webkit_web_view_paste_clipboard _obj'
    touchManagedPtr _obj
    return ()

-- method WebView::redo
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_redo" webkit_web_view_redo :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    IO ()


webViewRedo ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    m ()
webViewRedo _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    webkit_web_view_redo _obj'
    touchManagedPtr _obj
    return ()

-- method WebView::reload
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_reload" webkit_web_view_reload :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    IO ()


webViewReload ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    m ()
webViewReload _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    webkit_web_view_reload _obj'
    touchManagedPtr _obj
    return ()

-- method WebView::reload_bypass_cache
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_reload_bypass_cache" webkit_web_view_reload_bypass_cache :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    IO ()


webViewReloadBypassCache ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    m ()
webViewReloadBypassCache _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    webkit_web_view_reload_bypass_cache _obj'
    touchManagedPtr _obj
    return ()

-- method WebView::search_text
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "case_sensitive", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "forward", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "wrap", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "case_sensitive", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "forward", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "wrap", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TBoolean
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_search_text" webkit_web_view_search_text :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    CString ->                              -- text : TBasicType TUTF8
    CInt ->                                 -- case_sensitive : TBasicType TBoolean
    CInt ->                                 -- forward : TBasicType TBoolean
    CInt ->                                 -- wrap : TBasicType TBoolean
    IO CInt


webViewSearchText ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    T.Text ->                               -- text
    Bool ->                                 -- case_sensitive
    Bool ->                                 -- forward
    Bool ->                                 -- wrap
    m Bool
webViewSearchText _obj text case_sensitive forward wrap = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    text' <- textToCString text
    let case_sensitive' = (fromIntegral . fromEnum) case_sensitive
    let forward' = (fromIntegral . fromEnum) forward
    let wrap' = (fromIntegral . fromEnum) wrap
    result <- webkit_web_view_search_text _obj' text' case_sensitive' forward' wrap'
    let result' = (/= 0) result
    touchManagedPtr _obj
    freeMem text'
    return result'

-- method WebView::select_all
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_select_all" webkit_web_view_select_all :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    IO ()


webViewSelectAll ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    m ()
webViewSelectAll _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    webkit_web_view_select_all _obj'
    touchManagedPtr _obj
    return ()

-- method WebView::set_custom_encoding
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "encoding", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "encoding", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_set_custom_encoding" webkit_web_view_set_custom_encoding :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    CString ->                              -- encoding : TBasicType TUTF8
    IO ()


webViewSetCustomEncoding ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    T.Text ->                               -- encoding
    m ()
webViewSetCustomEncoding _obj encoding = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    encoding' <- textToCString encoding
    webkit_web_view_set_custom_encoding _obj' encoding'
    touchManagedPtr _obj
    freeMem encoding'
    return ()

-- method WebView::set_editable
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flag", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flag", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_set_editable" webkit_web_view_set_editable :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    CInt ->                                 -- flag : TBasicType TBoolean
    IO ()


webViewSetEditable ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    Bool ->                                 -- flag
    m ()
webViewSetEditable _obj flag = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let flag' = (fromIntegral . fromEnum) flag
    webkit_web_view_set_editable _obj' flag'
    touchManagedPtr _obj
    return ()

-- method WebView::set_full_content_zoom
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "full_content_zoom", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "full_content_zoom", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_set_full_content_zoom" webkit_web_view_set_full_content_zoom :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    CInt ->                                 -- full_content_zoom : TBasicType TBoolean
    IO ()


webViewSetFullContentZoom ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    Bool ->                                 -- full_content_zoom
    m ()
webViewSetFullContentZoom _obj full_content_zoom = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let full_content_zoom' = (fromIntegral . fromEnum) full_content_zoom
    webkit_web_view_set_full_content_zoom _obj' full_content_zoom'
    touchManagedPtr _obj
    return ()

-- method WebView::set_highlight_text_matches
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "highlight", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "highlight", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_set_highlight_text_matches" webkit_web_view_set_highlight_text_matches :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    CInt ->                                 -- highlight : TBasicType TBoolean
    IO ()


webViewSetHighlightTextMatches ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    Bool ->                                 -- highlight
    m ()
webViewSetHighlightTextMatches _obj highlight = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let highlight' = (fromIntegral . fromEnum) highlight
    webkit_web_view_set_highlight_text_matches _obj' highlight'
    touchManagedPtr _obj
    return ()

-- method WebView::set_maintains_back_forward_list
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flag", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flag", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_set_maintains_back_forward_list" webkit_web_view_set_maintains_back_forward_list :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    CInt ->                                 -- flag : TBasicType TBoolean
    IO ()


webViewSetMaintainsBackForwardList ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    Bool ->                                 -- flag
    m ()
webViewSetMaintainsBackForwardList _obj flag = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let flag' = (fromIntegral . fromEnum) flag
    webkit_web_view_set_maintains_back_forward_list _obj' flag'
    touchManagedPtr _obj
    return ()

-- method WebView::set_settings
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "settings", argType = TInterface "WebKit" "WebSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "settings", argType = TInterface "WebKit" "WebSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_set_settings" webkit_web_view_set_settings :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    Ptr WebSettings ->                      -- settings : TInterface "WebKit" "WebSettings"
    IO ()


webViewSetSettings ::
    (MonadIO m, WebViewK a, WebSettingsK b) =>
    a ->                                    -- _obj
    b ->                                    -- settings
    m ()
webViewSetSettings _obj settings = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let settings' = unsafeManagedPtrCastPtr settings
    webkit_web_view_set_settings _obj' settings'
    touchManagedPtr _obj
    touchManagedPtr settings
    return ()

-- method WebView::set_transparent
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flag", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flag", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_set_transparent" webkit_web_view_set_transparent :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    CInt ->                                 -- flag : TBasicType TBoolean
    IO ()


webViewSetTransparent ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    Bool ->                                 -- flag
    m ()
webViewSetTransparent _obj flag = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let flag' = (fromIntegral . fromEnum) flag
    webkit_web_view_set_transparent _obj' flag'
    touchManagedPtr _obj
    return ()

-- method WebView::set_view_mode
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mode", argType = TInterface "WebKit" "WebViewViewMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mode", argType = TInterface "WebKit" "WebViewViewMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_set_view_mode" webkit_web_view_set_view_mode :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    CUInt ->                                -- mode : TInterface "WebKit" "WebViewViewMode"
    IO ()


webViewSetViewMode ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    WebViewViewMode ->                      -- mode
    m ()
webViewSetViewMode _obj mode = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let mode' = (fromIntegral . fromEnum) mode
    webkit_web_view_set_view_mode _obj' mode'
    touchManagedPtr _obj
    return ()

-- method WebView::set_view_source_mode
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "view_source_mode", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "view_source_mode", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_set_view_source_mode" webkit_web_view_set_view_source_mode :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    CInt ->                                 -- view_source_mode : TBasicType TBoolean
    IO ()


webViewSetViewSourceMode ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    Bool ->                                 -- view_source_mode
    m ()
webViewSetViewSourceMode _obj view_source_mode = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let view_source_mode' = (fromIntegral . fromEnum) view_source_mode
    webkit_web_view_set_view_source_mode _obj' view_source_mode'
    touchManagedPtr _obj
    return ()

-- method WebView::set_zoom_level
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "zoom_level", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "zoom_level", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_set_zoom_level" webkit_web_view_set_zoom_level :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    CFloat ->                               -- zoom_level : TBasicType TFloat
    IO ()


webViewSetZoomLevel ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    Float ->                                -- zoom_level
    m ()
webViewSetZoomLevel _obj zoom_level = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let zoom_level' = realToFrac zoom_level
    webkit_web_view_set_zoom_level _obj' zoom_level'
    touchManagedPtr _obj
    return ()

-- method WebView::stop_loading
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_stop_loading" webkit_web_view_stop_loading :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    IO ()


webViewStopLoading ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    m ()
webViewStopLoading _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    webkit_web_view_stop_loading _obj'
    touchManagedPtr _obj
    return ()

-- method WebView::try_get_favicon_pixbuf
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TInterface "GdkPixbuf" "Pixbuf"
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_try_get_favicon_pixbuf" webkit_web_view_try_get_favicon_pixbuf :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    Word32 ->                               -- width : TBasicType TUInt32
    Word32 ->                               -- height : TBasicType TUInt32
    IO (Ptr GdkPixbuf.Pixbuf)


webViewTryGetFaviconPixbuf ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    Word32 ->                               -- width
    Word32 ->                               -- height
    m GdkPixbuf.Pixbuf
webViewTryGetFaviconPixbuf _obj width height = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- webkit_web_view_try_get_favicon_pixbuf _obj' width height
    checkUnexpectedReturnNULL "webkit_web_view_try_get_favicon_pixbuf" result
    result' <- (wrapObject GdkPixbuf.Pixbuf) result
    touchManagedPtr _obj
    return result'

-- method WebView::undo
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_undo" webkit_web_view_undo :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    IO ()


webViewUndo ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    m ()
webViewUndo _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    webkit_web_view_undo _obj'
    touchManagedPtr _obj
    return ()

-- method WebView::unmark_text_matches
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_unmark_text_matches" webkit_web_view_unmark_text_matches :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    IO ()


webViewUnmarkTextMatches ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    m ()
webViewUnmarkTextMatches _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    webkit_web_view_unmark_text_matches _obj'
    touchManagedPtr _obj
    return ()

-- method WebView::zoom_in
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_zoom_in" webkit_web_view_zoom_in :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    IO ()


webViewZoomIn ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    m ()
webViewZoomIn _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    webkit_web_view_zoom_in _obj'
    touchManagedPtr _obj
    return ()

-- method WebView::zoom_out
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "WebKit" "WebView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_view_zoom_out" webkit_web_view_zoom_out :: 
    Ptr WebView ->                          -- _obj : TInterface "WebKit" "WebView"
    IO ()


webViewZoomOut ::
    (MonadIO m, WebViewK a) =>
    a ->                                    -- _obj
    m ()
webViewZoomOut _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    webkit_web_view_zoom_out _obj'
    touchManagedPtr _obj
    return ()