Copyright | Will Thompson Iñaki García Etxebarria and Jonas Platte |
---|---|
License | LGPL-2.1 |
Maintainer | Iñaki García Etxebarria (inaki@blueleaf.cc) |
Safe Haskell | None |
Language | Haskell2010 |
- Exported types
- Methods
- canExecuteEditingCommand
- canExecuteEditingCommandFinish
- canGoBack
- canGoForward
- canShowMimeType
- downloadUri
- executeEditingCommand
- executeEditingCommandWithArgument
- getBackForwardList
- getBackgroundColor
- getContext
- getCustomCharset
- getEditorState
- getEstimatedLoadProgress
- getFavicon
- getFindController
- getInspector
- getMainResource
- getPageId
- getSessionState
- getSettings
- getSnapshot
- getSnapshotFinish
- getTitle
- getTlsInfo
- getUri
- getUserContentManager
- getWebsiteDataManager
- getWindowProperties
- getZoomLevel
- goBack
- goForward
- goToBackForwardListItem
- isControlledByAutomation
- isEditable
- isEphemeral
- isLoading
- isPlayingAudio
- loadAlternateHtml
- loadBytes
- loadHtml
- loadPlainText
- loadRequest
- loadUri
- new
- newWithContext
- newWithRelatedView
- newWithSettings
- newWithUserContentManager
- reload
- reloadBypassCache
- restoreSessionState
- runJavascript
- runJavascriptFinish
- runJavascriptFromGresource
- runJavascriptFromGresourceFinish
- runJavascriptInWorld
- runJavascriptInWorldFinish
- save
- saveFinish
- saveToFile
- saveToFileFinish
- setBackgroundColor
- setCustomCharset
- setEditable
- setSettings
- setZoomLevel
- stopLoading
- tryClose
- Properties
- Signals
- authenticate
- close
- contextMenu
- contextMenuDismissed
- create
- decidePolicy
- enterFullscreen
- insecureContentDetected
- leaveFullscreen
- loadChanged
- loadFailed
- loadFailedWithTlsErrors
- mouseTargetChanged
- permissionRequest
- readyToShow
- resourceLoadStarted
- runAsModal
- runColorChooser
- runFileChooser
- scriptDialog
- showNotification
- showOptionMenu
- submitForm
- webProcessCrashed
- webProcessTerminated
No description available in the introspection data.
Synopsis
- newtype WebView = WebView (ManagedPtr WebView)
- class (GObject o, IsDescendantOf WebView o) => IsWebView o
- toWebView :: (MonadIO m, IsWebView o) => o -> m WebView
- noWebView :: Maybe WebView
- webViewCanExecuteEditingCommand :: (HasCallStack, MonadIO m, IsWebView a, IsCancellable b) => a -> Text -> Maybe b -> Maybe AsyncReadyCallback -> m ()
- webViewCanExecuteEditingCommandFinish :: (HasCallStack, MonadIO m, IsWebView a, IsAsyncResult b) => a -> b -> m ()
- webViewCanGoBack :: (HasCallStack, MonadIO m, IsWebView a) => a -> m Bool
- webViewCanGoForward :: (HasCallStack, MonadIO m, IsWebView a) => a -> m Bool
- webViewCanShowMimeType :: (HasCallStack, MonadIO m, IsWebView a) => a -> Text -> m Bool
- webViewDownloadUri :: (HasCallStack, MonadIO m, IsWebView a) => a -> Text -> m Download
- webViewExecuteEditingCommand :: (HasCallStack, MonadIO m, IsWebView a) => a -> Text -> m ()
- webViewExecuteEditingCommandWithArgument :: (HasCallStack, MonadIO m, IsWebView a) => a -> Text -> Text -> m ()
- webViewGetBackForwardList :: (HasCallStack, MonadIO m, IsWebView a) => a -> m BackForwardList
- webViewGetBackgroundColor :: (HasCallStack, MonadIO m, IsWebView a) => a -> m RGBA
- webViewGetContext :: (HasCallStack, MonadIO m, IsWebView a) => a -> m WebContext
- webViewGetCustomCharset :: (HasCallStack, MonadIO m, IsWebView a) => a -> m (Maybe Text)
- webViewGetEditorState :: (HasCallStack, MonadIO m, IsWebView a) => a -> m EditorState
- webViewGetEstimatedLoadProgress :: (HasCallStack, MonadIO m, IsWebView a) => a -> m Double
- webViewGetFavicon :: (HasCallStack, MonadIO m, IsWebView a) => a -> m (Maybe Surface)
- webViewGetFindController :: (HasCallStack, MonadIO m, IsWebView a) => a -> m FindController
- webViewGetInspector :: (HasCallStack, MonadIO m, IsWebView a) => a -> m WebInspector
- webViewGetMainResource :: (HasCallStack, MonadIO m, IsWebView a) => a -> m (Maybe WebResource)
- webViewGetPageId :: (HasCallStack, MonadIO m, IsWebView a) => a -> m Word64
- webViewGetSessionState :: (HasCallStack, MonadIO m, IsWebView a) => a -> m WebViewSessionState
- webViewGetSettings :: (HasCallStack, MonadIO m, IsWebView a) => a -> m Settings
- webViewGetSnapshot :: (HasCallStack, MonadIO m, IsWebView a, IsCancellable b) => a -> SnapshotRegion -> [SnapshotOptions] -> Maybe b -> Maybe AsyncReadyCallback -> m ()
- webViewGetSnapshotFinish :: (HasCallStack, MonadIO m, IsWebView a, IsAsyncResult b) => a -> b -> m Surface
- webViewGetTitle :: (HasCallStack, MonadIO m, IsWebView a) => a -> m (Maybe Text)
- webViewGetTlsInfo :: (HasCallStack, MonadIO m, IsWebView a) => a -> m (Bool, TlsCertificate, [TlsCertificateFlags])
- webViewGetUri :: (HasCallStack, MonadIO m, IsWebView a) => a -> m (Maybe Text)
- webViewGetUserContentManager :: (HasCallStack, MonadIO m, IsWebView a) => a -> m UserContentManager
- webViewGetWebsiteDataManager :: (HasCallStack, MonadIO m, IsWebView a) => a -> m WebsiteDataManager
- webViewGetWindowProperties :: (HasCallStack, MonadIO m, IsWebView a) => a -> m WindowProperties
- webViewGetZoomLevel :: (HasCallStack, MonadIO m, IsWebView a) => a -> m Double
- webViewGoBack :: (HasCallStack, MonadIO m, IsWebView a) => a -> m ()
- webViewGoForward :: (HasCallStack, MonadIO m, IsWebView a) => a -> m ()
- webViewGoToBackForwardListItem :: (HasCallStack, MonadIO m, IsWebView a, IsBackForwardListItem b) => a -> b -> m ()
- webViewIsControlledByAutomation :: (HasCallStack, MonadIO m, IsWebView a) => a -> m Bool
- webViewIsEditable :: (HasCallStack, MonadIO m, IsWebView a) => a -> m Bool
- webViewIsEphemeral :: (HasCallStack, MonadIO m, IsWebView a) => a -> m Bool
- webViewIsLoading :: (HasCallStack, MonadIO m, IsWebView a) => a -> m Bool
- webViewIsPlayingAudio :: (HasCallStack, MonadIO m, IsWebView a) => a -> m Bool
- webViewLoadAlternateHtml :: (HasCallStack, MonadIO m, IsWebView a) => a -> Text -> Text -> Maybe Text -> m ()
- webViewLoadBytes :: (HasCallStack, MonadIO m, IsWebView a) => a -> Bytes -> Maybe Text -> Maybe Text -> Maybe Text -> m ()
- webViewLoadHtml :: (HasCallStack, MonadIO m, IsWebView a) => a -> Text -> Maybe Text -> m ()
- webViewLoadPlainText :: (HasCallStack, MonadIO m, IsWebView a) => a -> Text -> m ()
- webViewLoadRequest :: (HasCallStack, MonadIO m, IsWebView a, IsURIRequest b) => a -> b -> m ()
- webViewLoadUri :: (HasCallStack, MonadIO m, IsWebView a) => a -> Text -> m ()
- webViewNew :: (HasCallStack, MonadIO m) => m WebView
- webViewNewWithContext :: (HasCallStack, MonadIO m, IsWebContext a) => a -> m WebView
- webViewNewWithRelatedView :: (HasCallStack, MonadIO m, IsWebView a) => a -> m WebView
- webViewNewWithSettings :: (HasCallStack, MonadIO m, IsSettings a) => a -> m WebView
- webViewNewWithUserContentManager :: (HasCallStack, MonadIO m, IsUserContentManager a) => a -> m WebView
- webViewReload :: (HasCallStack, MonadIO m, IsWebView a) => a -> m ()
- webViewReloadBypassCache :: (HasCallStack, MonadIO m, IsWebView a) => a -> m ()
- webViewRestoreSessionState :: (HasCallStack, MonadIO m, IsWebView a) => a -> WebViewSessionState -> m ()
- webViewRunJavascript :: (HasCallStack, MonadIO m, IsWebView a, IsCancellable b) => a -> Text -> Maybe b -> Maybe AsyncReadyCallback -> m ()
- webViewRunJavascriptFinish :: (HasCallStack, MonadIO m, IsWebView a, IsAsyncResult b) => a -> b -> m JavascriptResult
- webViewRunJavascriptFromGresource :: (HasCallStack, MonadIO m, IsWebView a, IsCancellable b) => a -> Text -> Maybe b -> Maybe AsyncReadyCallback -> m ()
- webViewRunJavascriptFromGresourceFinish :: (HasCallStack, MonadIO m, IsWebView a, IsAsyncResult b) => a -> b -> m JavascriptResult
- webViewRunJavascriptInWorld :: (HasCallStack, MonadIO m, IsWebView a, IsCancellable b) => a -> Text -> Text -> Maybe b -> Maybe AsyncReadyCallback -> m ()
- webViewRunJavascriptInWorldFinish :: (HasCallStack, MonadIO m, IsWebView a, IsAsyncResult b) => a -> b -> m JavascriptResult
- webViewSave :: (HasCallStack, MonadIO m, IsWebView a, IsCancellable b) => a -> SaveMode -> Maybe b -> Maybe AsyncReadyCallback -> m ()
- webViewSaveFinish :: (HasCallStack, MonadIO m, IsWebView a, IsAsyncResult b) => a -> b -> m InputStream
- webViewSaveToFile :: (HasCallStack, MonadIO m, IsWebView a, IsFile b, IsCancellable c) => a -> b -> SaveMode -> Maybe c -> Maybe AsyncReadyCallback -> m ()
- webViewSaveToFileFinish :: (HasCallStack, MonadIO m, IsWebView a, IsAsyncResult b) => a -> b -> m ()
- webViewSetBackgroundColor :: (HasCallStack, MonadIO m, IsWebView a) => a -> RGBA -> m ()
- webViewSetCustomCharset :: (HasCallStack, MonadIO m, IsWebView a) => a -> Maybe Text -> m ()
- webViewSetEditable :: (HasCallStack, MonadIO m, IsWebView a) => a -> Bool -> m ()
- webViewSetSettings :: (HasCallStack, MonadIO m, IsWebView a, IsSettings b) => a -> b -> m ()
- webViewSetZoomLevel :: (HasCallStack, MonadIO m, IsWebView a) => a -> Double -> m ()
- webViewStopLoading :: (HasCallStack, MonadIO m, IsWebView a) => a -> m ()
- webViewTryClose :: (HasCallStack, MonadIO m, IsWebView a) => a -> m ()
- constructWebViewEditable :: IsWebView o => Bool -> IO (GValueConstruct o)
- getWebViewEditable :: (MonadIO m, IsWebView o) => o -> m Bool
- setWebViewEditable :: (MonadIO m, IsWebView o) => o -> Bool -> m ()
- getWebViewEstimatedLoadProgress :: (MonadIO m, IsWebView o) => o -> m Double
- getWebViewFavicon :: (MonadIO m, IsWebView o) => o -> m (Ptr ())
- constructWebViewIsControlledByAutomation :: IsWebView o => Bool -> IO (GValueConstruct o)
- getWebViewIsControlledByAutomation :: (MonadIO m, IsWebView o) => o -> m Bool
- constructWebViewIsEphemeral :: IsWebView o => Bool -> IO (GValueConstruct o)
- getWebViewIsEphemeral :: (MonadIO m, IsWebView o) => o -> m Bool
- getWebViewIsLoading :: (MonadIO m, IsWebView o) => o -> m Bool
- getWebViewIsPlayingAudio :: (MonadIO m, IsWebView o) => o -> m Bool
- constructWebViewRelatedView :: (IsWebView o, IsWebView a) => a -> IO (GValueConstruct o)
- constructWebViewSettings :: (IsWebView o, IsSettings a) => a -> IO (GValueConstruct o)
- setWebViewSettings :: (MonadIO m, IsWebView o, IsSettings a) => o -> a -> m ()
- getWebViewTitle :: (MonadIO m, IsWebView o) => o -> m (Maybe Text)
- getWebViewUri :: (MonadIO m, IsWebView o) => o -> m (Maybe Text)
- constructWebViewUserContentManager :: (IsWebView o, IsUserContentManager a) => a -> IO (GValueConstruct o)
- getWebViewUserContentManager :: (MonadIO m, IsWebView o) => o -> m UserContentManager
- constructWebViewWebContext :: (IsWebView o, IsWebContext a) => a -> IO (GValueConstruct o)
- getWebViewWebContext :: (MonadIO m, IsWebView o) => o -> m (Maybe WebContext)
- constructWebViewZoomLevel :: IsWebView o => Double -> IO (GValueConstruct o)
- getWebViewZoomLevel :: (MonadIO m, IsWebView o) => o -> m Double
- setWebViewZoomLevel :: (MonadIO m, IsWebView o) => o -> Double -> m ()
- type C_WebViewAuthenticateCallback = Ptr () -> Ptr AuthenticationRequest -> Ptr () -> IO CInt
- type WebViewAuthenticateCallback = AuthenticationRequest -> IO Bool
- afterWebViewAuthenticate :: (IsWebView a, MonadIO m) => a -> WebViewAuthenticateCallback -> m SignalHandlerId
- genClosure_WebViewAuthenticate :: MonadIO m => WebViewAuthenticateCallback -> m (GClosure C_WebViewAuthenticateCallback)
- mk_WebViewAuthenticateCallback :: C_WebViewAuthenticateCallback -> IO (FunPtr C_WebViewAuthenticateCallback)
- noWebViewAuthenticateCallback :: Maybe WebViewAuthenticateCallback
- onWebViewAuthenticate :: (IsWebView a, MonadIO m) => a -> WebViewAuthenticateCallback -> m SignalHandlerId
- wrap_WebViewAuthenticateCallback :: WebViewAuthenticateCallback -> C_WebViewAuthenticateCallback
- type C_WebViewCloseCallback = Ptr () -> Ptr () -> IO ()
- type WebViewCloseCallback = IO ()
- afterWebViewClose :: (IsWebView a, MonadIO m) => a -> WebViewCloseCallback -> m SignalHandlerId
- genClosure_WebViewClose :: MonadIO m => WebViewCloseCallback -> m (GClosure C_WebViewCloseCallback)
- mk_WebViewCloseCallback :: C_WebViewCloseCallback -> IO (FunPtr C_WebViewCloseCallback)
- noWebViewCloseCallback :: Maybe WebViewCloseCallback
- onWebViewClose :: (IsWebView a, MonadIO m) => a -> WebViewCloseCallback -> m SignalHandlerId
- wrap_WebViewCloseCallback :: WebViewCloseCallback -> C_WebViewCloseCallback
- type C_WebViewContextMenuCallback = Ptr () -> Ptr ContextMenu -> Ptr Event -> Ptr HitTestResult -> Ptr () -> IO CInt
- type WebViewContextMenuCallback = ContextMenu -> Event -> HitTestResult -> IO Bool
- afterWebViewContextMenu :: (IsWebView a, MonadIO m) => a -> WebViewContextMenuCallback -> m SignalHandlerId
- genClosure_WebViewContextMenu :: MonadIO m => WebViewContextMenuCallback -> m (GClosure C_WebViewContextMenuCallback)
- mk_WebViewContextMenuCallback :: C_WebViewContextMenuCallback -> IO (FunPtr C_WebViewContextMenuCallback)
- noWebViewContextMenuCallback :: Maybe WebViewContextMenuCallback
- onWebViewContextMenu :: (IsWebView a, MonadIO m) => a -> WebViewContextMenuCallback -> m SignalHandlerId
- wrap_WebViewContextMenuCallback :: WebViewContextMenuCallback -> C_WebViewContextMenuCallback
- type C_WebViewContextMenuDismissedCallback = Ptr () -> Ptr () -> IO ()
- type WebViewContextMenuDismissedCallback = IO ()
- afterWebViewContextMenuDismissed :: (IsWebView a, MonadIO m) => a -> WebViewContextMenuDismissedCallback -> m SignalHandlerId
- genClosure_WebViewContextMenuDismissed :: MonadIO m => WebViewContextMenuDismissedCallback -> m (GClosure C_WebViewContextMenuDismissedCallback)
- mk_WebViewContextMenuDismissedCallback :: C_WebViewContextMenuDismissedCallback -> IO (FunPtr C_WebViewContextMenuDismissedCallback)
- noWebViewContextMenuDismissedCallback :: Maybe WebViewContextMenuDismissedCallback
- onWebViewContextMenuDismissed :: (IsWebView a, MonadIO m) => a -> WebViewContextMenuDismissedCallback -> m SignalHandlerId
- wrap_WebViewContextMenuDismissedCallback :: WebViewContextMenuDismissedCallback -> C_WebViewContextMenuDismissedCallback
- type C_WebViewCreateCallback = Ptr () -> Ptr NavigationAction -> Ptr () -> IO (Ptr Widget)
- type WebViewCreateCallback = NavigationAction -> IO Widget
- afterWebViewCreate :: (IsWebView a, MonadIO m) => a -> WebViewCreateCallback -> m SignalHandlerId
- genClosure_WebViewCreate :: MonadIO m => WebViewCreateCallback -> m (GClosure C_WebViewCreateCallback)
- mk_WebViewCreateCallback :: C_WebViewCreateCallback -> IO (FunPtr C_WebViewCreateCallback)
- noWebViewCreateCallback :: Maybe WebViewCreateCallback
- onWebViewCreate :: (IsWebView a, MonadIO m) => a -> WebViewCreateCallback -> m SignalHandlerId
- wrap_WebViewCreateCallback :: WebViewCreateCallback -> C_WebViewCreateCallback
- type C_WebViewDecidePolicyCallback = Ptr () -> Ptr PolicyDecision -> CUInt -> Ptr () -> IO CInt
- type WebViewDecidePolicyCallback = PolicyDecision -> PolicyDecisionType -> IO Bool
- afterWebViewDecidePolicy :: (IsWebView a, MonadIO m) => a -> WebViewDecidePolicyCallback -> m SignalHandlerId
- genClosure_WebViewDecidePolicy :: MonadIO m => WebViewDecidePolicyCallback -> m (GClosure C_WebViewDecidePolicyCallback)
- mk_WebViewDecidePolicyCallback :: C_WebViewDecidePolicyCallback -> IO (FunPtr C_WebViewDecidePolicyCallback)
- noWebViewDecidePolicyCallback :: Maybe WebViewDecidePolicyCallback
- onWebViewDecidePolicy :: (IsWebView a, MonadIO m) => a -> WebViewDecidePolicyCallback -> m SignalHandlerId
- wrap_WebViewDecidePolicyCallback :: WebViewDecidePolicyCallback -> C_WebViewDecidePolicyCallback
- type C_WebViewEnterFullscreenCallback = Ptr () -> Ptr () -> IO CInt
- type WebViewEnterFullscreenCallback = IO Bool
- afterWebViewEnterFullscreen :: (IsWebView a, MonadIO m) => a -> WebViewEnterFullscreenCallback -> m SignalHandlerId
- genClosure_WebViewEnterFullscreen :: MonadIO m => WebViewEnterFullscreenCallback -> m (GClosure C_WebViewEnterFullscreenCallback)
- mk_WebViewEnterFullscreenCallback :: C_WebViewEnterFullscreenCallback -> IO (FunPtr C_WebViewEnterFullscreenCallback)
- noWebViewEnterFullscreenCallback :: Maybe WebViewEnterFullscreenCallback
- onWebViewEnterFullscreen :: (IsWebView a, MonadIO m) => a -> WebViewEnterFullscreenCallback -> m SignalHandlerId
- wrap_WebViewEnterFullscreenCallback :: WebViewEnterFullscreenCallback -> C_WebViewEnterFullscreenCallback
- type C_WebViewInsecureContentDetectedCallback = Ptr () -> CUInt -> Ptr () -> IO ()
- type WebViewInsecureContentDetectedCallback = InsecureContentEvent -> IO ()
- afterWebViewInsecureContentDetected :: (IsWebView a, MonadIO m) => a -> WebViewInsecureContentDetectedCallback -> m SignalHandlerId
- genClosure_WebViewInsecureContentDetected :: MonadIO m => WebViewInsecureContentDetectedCallback -> m (GClosure C_WebViewInsecureContentDetectedCallback)
- mk_WebViewInsecureContentDetectedCallback :: C_WebViewInsecureContentDetectedCallback -> IO (FunPtr C_WebViewInsecureContentDetectedCallback)
- noWebViewInsecureContentDetectedCallback :: Maybe WebViewInsecureContentDetectedCallback
- onWebViewInsecureContentDetected :: (IsWebView a, MonadIO m) => a -> WebViewInsecureContentDetectedCallback -> m SignalHandlerId
- wrap_WebViewInsecureContentDetectedCallback :: WebViewInsecureContentDetectedCallback -> C_WebViewInsecureContentDetectedCallback
- type C_WebViewLeaveFullscreenCallback = Ptr () -> Ptr () -> IO CInt
- type WebViewLeaveFullscreenCallback = IO Bool
- afterWebViewLeaveFullscreen :: (IsWebView a, MonadIO m) => a -> WebViewLeaveFullscreenCallback -> m SignalHandlerId
- genClosure_WebViewLeaveFullscreen :: MonadIO m => WebViewLeaveFullscreenCallback -> m (GClosure C_WebViewLeaveFullscreenCallback)
- mk_WebViewLeaveFullscreenCallback :: C_WebViewLeaveFullscreenCallback -> IO (FunPtr C_WebViewLeaveFullscreenCallback)
- noWebViewLeaveFullscreenCallback :: Maybe WebViewLeaveFullscreenCallback
- onWebViewLeaveFullscreen :: (IsWebView a, MonadIO m) => a -> WebViewLeaveFullscreenCallback -> m SignalHandlerId
- wrap_WebViewLeaveFullscreenCallback :: WebViewLeaveFullscreenCallback -> C_WebViewLeaveFullscreenCallback
- type C_WebViewLoadChangedCallback = Ptr () -> CUInt -> Ptr () -> IO ()
- type WebViewLoadChangedCallback = LoadEvent -> IO ()
- afterWebViewLoadChanged :: (IsWebView a, MonadIO m) => a -> WebViewLoadChangedCallback -> m SignalHandlerId
- genClosure_WebViewLoadChanged :: MonadIO m => WebViewLoadChangedCallback -> m (GClosure C_WebViewLoadChangedCallback)
- mk_WebViewLoadChangedCallback :: C_WebViewLoadChangedCallback -> IO (FunPtr C_WebViewLoadChangedCallback)
- noWebViewLoadChangedCallback :: Maybe WebViewLoadChangedCallback
- onWebViewLoadChanged :: (IsWebView a, MonadIO m) => a -> WebViewLoadChangedCallback -> m SignalHandlerId
- wrap_WebViewLoadChangedCallback :: WebViewLoadChangedCallback -> C_WebViewLoadChangedCallback
- type C_WebViewLoadFailedCallback = Ptr () -> CUInt -> CString -> Ptr GError -> Ptr () -> IO CInt
- type WebViewLoadFailedCallback = LoadEvent -> Text -> GError -> IO Bool
- afterWebViewLoadFailed :: (IsWebView a, MonadIO m) => a -> WebViewLoadFailedCallback -> m SignalHandlerId
- genClosure_WebViewLoadFailed :: MonadIO m => WebViewLoadFailedCallback -> m (GClosure C_WebViewLoadFailedCallback)
- mk_WebViewLoadFailedCallback :: C_WebViewLoadFailedCallback -> IO (FunPtr C_WebViewLoadFailedCallback)
- noWebViewLoadFailedCallback :: Maybe WebViewLoadFailedCallback
- onWebViewLoadFailed :: (IsWebView a, MonadIO m) => a -> WebViewLoadFailedCallback -> m SignalHandlerId
- wrap_WebViewLoadFailedCallback :: WebViewLoadFailedCallback -> C_WebViewLoadFailedCallback
- type C_WebViewLoadFailedWithTlsErrorsCallback = Ptr () -> CString -> Ptr TlsCertificate -> CUInt -> Ptr () -> IO CInt
- type WebViewLoadFailedWithTlsErrorsCallback = Text -> TlsCertificate -> [TlsCertificateFlags] -> IO Bool
- afterWebViewLoadFailedWithTlsErrors :: (IsWebView a, MonadIO m) => a -> WebViewLoadFailedWithTlsErrorsCallback -> m SignalHandlerId
- genClosure_WebViewLoadFailedWithTlsErrors :: MonadIO m => WebViewLoadFailedWithTlsErrorsCallback -> m (GClosure C_WebViewLoadFailedWithTlsErrorsCallback)
- mk_WebViewLoadFailedWithTlsErrorsCallback :: C_WebViewLoadFailedWithTlsErrorsCallback -> IO (FunPtr C_WebViewLoadFailedWithTlsErrorsCallback)
- noWebViewLoadFailedWithTlsErrorsCallback :: Maybe WebViewLoadFailedWithTlsErrorsCallback
- onWebViewLoadFailedWithTlsErrors :: (IsWebView a, MonadIO m) => a -> WebViewLoadFailedWithTlsErrorsCallback -> m SignalHandlerId
- wrap_WebViewLoadFailedWithTlsErrorsCallback :: WebViewLoadFailedWithTlsErrorsCallback -> C_WebViewLoadFailedWithTlsErrorsCallback
- type C_WebViewMouseTargetChangedCallback = Ptr () -> Ptr HitTestResult -> Word32 -> Ptr () -> IO ()
- type WebViewMouseTargetChangedCallback = HitTestResult -> Word32 -> IO ()
- afterWebViewMouseTargetChanged :: (IsWebView a, MonadIO m) => a -> WebViewMouseTargetChangedCallback -> m SignalHandlerId
- genClosure_WebViewMouseTargetChanged :: MonadIO m => WebViewMouseTargetChangedCallback -> m (GClosure C_WebViewMouseTargetChangedCallback)
- mk_WebViewMouseTargetChangedCallback :: C_WebViewMouseTargetChangedCallback -> IO (FunPtr C_WebViewMouseTargetChangedCallback)
- noWebViewMouseTargetChangedCallback :: Maybe WebViewMouseTargetChangedCallback
- onWebViewMouseTargetChanged :: (IsWebView a, MonadIO m) => a -> WebViewMouseTargetChangedCallback -> m SignalHandlerId
- wrap_WebViewMouseTargetChangedCallback :: WebViewMouseTargetChangedCallback -> C_WebViewMouseTargetChangedCallback
- type C_WebViewPermissionRequestCallback = Ptr () -> Ptr PermissionRequest -> Ptr () -> IO CInt
- type WebViewPermissionRequestCallback = PermissionRequest -> IO Bool
- afterWebViewPermissionRequest :: (IsWebView a, MonadIO m) => a -> WebViewPermissionRequestCallback -> m SignalHandlerId
- genClosure_WebViewPermissionRequest :: MonadIO m => WebViewPermissionRequestCallback -> m (GClosure C_WebViewPermissionRequestCallback)
- mk_WebViewPermissionRequestCallback :: C_WebViewPermissionRequestCallback -> IO (FunPtr C_WebViewPermissionRequestCallback)
- noWebViewPermissionRequestCallback :: Maybe WebViewPermissionRequestCallback
- onWebViewPermissionRequest :: (IsWebView a, MonadIO m) => a -> WebViewPermissionRequestCallback -> m SignalHandlerId
- wrap_WebViewPermissionRequestCallback :: WebViewPermissionRequestCallback -> C_WebViewPermissionRequestCallback
- type C_WebViewPrintCallback = Ptr () -> Ptr PrintOperation -> Ptr () -> IO CInt
- type WebViewPrintCallback = PrintOperation -> IO Bool
- afterWebViewPrint :: (IsWebView a, MonadIO m) => a -> WebViewPrintCallback -> m SignalHandlerId
- genClosure_WebViewPrint :: MonadIO m => WebViewPrintCallback -> m (GClosure C_WebViewPrintCallback)
- mk_WebViewPrintCallback :: C_WebViewPrintCallback -> IO (FunPtr C_WebViewPrintCallback)
- noWebViewPrintCallback :: Maybe WebViewPrintCallback
- onWebViewPrint :: (IsWebView a, MonadIO m) => a -> WebViewPrintCallback -> m SignalHandlerId
- wrap_WebViewPrintCallback :: WebViewPrintCallback -> C_WebViewPrintCallback
- type C_WebViewReadyToShowCallback = Ptr () -> Ptr () -> IO ()
- type WebViewReadyToShowCallback = IO ()
- afterWebViewReadyToShow :: (IsWebView a, MonadIO m) => a -> WebViewReadyToShowCallback -> m SignalHandlerId
- genClosure_WebViewReadyToShow :: MonadIO m => WebViewReadyToShowCallback -> m (GClosure C_WebViewReadyToShowCallback)
- mk_WebViewReadyToShowCallback :: C_WebViewReadyToShowCallback -> IO (FunPtr C_WebViewReadyToShowCallback)
- noWebViewReadyToShowCallback :: Maybe WebViewReadyToShowCallback
- onWebViewReadyToShow :: (IsWebView a, MonadIO m) => a -> WebViewReadyToShowCallback -> m SignalHandlerId
- wrap_WebViewReadyToShowCallback :: WebViewReadyToShowCallback -> C_WebViewReadyToShowCallback
- type C_WebViewResourceLoadStartedCallback = Ptr () -> Ptr WebResource -> Ptr URIRequest -> Ptr () -> IO ()
- type WebViewResourceLoadStartedCallback = WebResource -> URIRequest -> IO ()
- afterWebViewResourceLoadStarted :: (IsWebView a, MonadIO m) => a -> WebViewResourceLoadStartedCallback -> m SignalHandlerId
- genClosure_WebViewResourceLoadStarted :: MonadIO m => WebViewResourceLoadStartedCallback -> m (GClosure C_WebViewResourceLoadStartedCallback)
- mk_WebViewResourceLoadStartedCallback :: C_WebViewResourceLoadStartedCallback -> IO (FunPtr C_WebViewResourceLoadStartedCallback)
- noWebViewResourceLoadStartedCallback :: Maybe WebViewResourceLoadStartedCallback
- onWebViewResourceLoadStarted :: (IsWebView a, MonadIO m) => a -> WebViewResourceLoadStartedCallback -> m SignalHandlerId
- wrap_WebViewResourceLoadStartedCallback :: WebViewResourceLoadStartedCallback -> C_WebViewResourceLoadStartedCallback
- type C_WebViewRunAsModalCallback = Ptr () -> Ptr () -> IO ()
- type WebViewRunAsModalCallback = IO ()
- afterWebViewRunAsModal :: (IsWebView a, MonadIO m) => a -> WebViewRunAsModalCallback -> m SignalHandlerId
- genClosure_WebViewRunAsModal :: MonadIO m => WebViewRunAsModalCallback -> m (GClosure C_WebViewRunAsModalCallback)
- mk_WebViewRunAsModalCallback :: C_WebViewRunAsModalCallback -> IO (FunPtr C_WebViewRunAsModalCallback)
- noWebViewRunAsModalCallback :: Maybe WebViewRunAsModalCallback
- onWebViewRunAsModal :: (IsWebView a, MonadIO m) => a -> WebViewRunAsModalCallback -> m SignalHandlerId
- wrap_WebViewRunAsModalCallback :: WebViewRunAsModalCallback -> C_WebViewRunAsModalCallback
- type C_WebViewRunColorChooserCallback = Ptr () -> Ptr ColorChooserRequest -> Ptr () -> IO CInt
- type WebViewRunColorChooserCallback = ColorChooserRequest -> IO Bool
- afterWebViewRunColorChooser :: (IsWebView a, MonadIO m) => a -> WebViewRunColorChooserCallback -> m SignalHandlerId
- genClosure_WebViewRunColorChooser :: MonadIO m => WebViewRunColorChooserCallback -> m (GClosure C_WebViewRunColorChooserCallback)
- mk_WebViewRunColorChooserCallback :: C_WebViewRunColorChooserCallback -> IO (FunPtr C_WebViewRunColorChooserCallback)
- noWebViewRunColorChooserCallback :: Maybe WebViewRunColorChooserCallback
- onWebViewRunColorChooser :: (IsWebView a, MonadIO m) => a -> WebViewRunColorChooserCallback -> m SignalHandlerId
- wrap_WebViewRunColorChooserCallback :: WebViewRunColorChooserCallback -> C_WebViewRunColorChooserCallback
- type C_WebViewRunFileChooserCallback = Ptr () -> Ptr FileChooserRequest -> Ptr () -> IO CInt
- type WebViewRunFileChooserCallback = FileChooserRequest -> IO Bool
- afterWebViewRunFileChooser :: (IsWebView a, MonadIO m) => a -> WebViewRunFileChooserCallback -> m SignalHandlerId
- genClosure_WebViewRunFileChooser :: MonadIO m => WebViewRunFileChooserCallback -> m (GClosure C_WebViewRunFileChooserCallback)
- mk_WebViewRunFileChooserCallback :: C_WebViewRunFileChooserCallback -> IO (FunPtr C_WebViewRunFileChooserCallback)
- noWebViewRunFileChooserCallback :: Maybe WebViewRunFileChooserCallback
- onWebViewRunFileChooser :: (IsWebView a, MonadIO m) => a -> WebViewRunFileChooserCallback -> m SignalHandlerId
- wrap_WebViewRunFileChooserCallback :: WebViewRunFileChooserCallback -> C_WebViewRunFileChooserCallback
- type C_WebViewScriptDialogCallback = Ptr () -> Ptr ScriptDialog -> Ptr () -> IO CInt
- type WebViewScriptDialogCallback = ScriptDialog -> IO Bool
- afterWebViewScriptDialog :: (IsWebView a, MonadIO m) => a -> WebViewScriptDialogCallback -> m SignalHandlerId
- genClosure_WebViewScriptDialog :: MonadIO m => WebViewScriptDialogCallback -> m (GClosure C_WebViewScriptDialogCallback)
- mk_WebViewScriptDialogCallback :: C_WebViewScriptDialogCallback -> IO (FunPtr C_WebViewScriptDialogCallback)
- noWebViewScriptDialogCallback :: Maybe WebViewScriptDialogCallback
- onWebViewScriptDialog :: (IsWebView a, MonadIO m) => a -> WebViewScriptDialogCallback -> m SignalHandlerId
- wrap_WebViewScriptDialogCallback :: WebViewScriptDialogCallback -> C_WebViewScriptDialogCallback
- type C_WebViewShowNotificationCallback = Ptr () -> Ptr Notification -> Ptr () -> IO CInt
- type WebViewShowNotificationCallback = Notification -> IO Bool
- afterWebViewShowNotification :: (IsWebView a, MonadIO m) => a -> WebViewShowNotificationCallback -> m SignalHandlerId
- genClosure_WebViewShowNotification :: MonadIO m => WebViewShowNotificationCallback -> m (GClosure C_WebViewShowNotificationCallback)
- mk_WebViewShowNotificationCallback :: C_WebViewShowNotificationCallback -> IO (FunPtr C_WebViewShowNotificationCallback)
- noWebViewShowNotificationCallback :: Maybe WebViewShowNotificationCallback
- onWebViewShowNotification :: (IsWebView a, MonadIO m) => a -> WebViewShowNotificationCallback -> m SignalHandlerId
- wrap_WebViewShowNotificationCallback :: WebViewShowNotificationCallback -> C_WebViewShowNotificationCallback
- type C_WebViewShowOptionMenuCallback = Ptr () -> Ptr OptionMenu -> Ptr Event -> Ptr Rectangle -> Ptr () -> IO CInt
- type WebViewShowOptionMenuCallback = OptionMenu -> Event -> Rectangle -> IO Bool
- afterWebViewShowOptionMenu :: (IsWebView a, MonadIO m) => a -> WebViewShowOptionMenuCallback -> m SignalHandlerId
- genClosure_WebViewShowOptionMenu :: MonadIO m => WebViewShowOptionMenuCallback -> m (GClosure C_WebViewShowOptionMenuCallback)
- mk_WebViewShowOptionMenuCallback :: C_WebViewShowOptionMenuCallback -> IO (FunPtr C_WebViewShowOptionMenuCallback)
- noWebViewShowOptionMenuCallback :: Maybe WebViewShowOptionMenuCallback
- onWebViewShowOptionMenu :: (IsWebView a, MonadIO m) => a -> WebViewShowOptionMenuCallback -> m SignalHandlerId
- wrap_WebViewShowOptionMenuCallback :: WebViewShowOptionMenuCallback -> C_WebViewShowOptionMenuCallback
- type C_WebViewSubmitFormCallback = Ptr () -> Ptr FormSubmissionRequest -> Ptr () -> IO ()
- type WebViewSubmitFormCallback = FormSubmissionRequest -> IO ()
- afterWebViewSubmitForm :: (IsWebView a, MonadIO m) => a -> WebViewSubmitFormCallback -> m SignalHandlerId
- genClosure_WebViewSubmitForm :: MonadIO m => WebViewSubmitFormCallback -> m (GClosure C_WebViewSubmitFormCallback)
- mk_WebViewSubmitFormCallback :: C_WebViewSubmitFormCallback -> IO (FunPtr C_WebViewSubmitFormCallback)
- noWebViewSubmitFormCallback :: Maybe WebViewSubmitFormCallback
- onWebViewSubmitForm :: (IsWebView a, MonadIO m) => a -> WebViewSubmitFormCallback -> m SignalHandlerId
- wrap_WebViewSubmitFormCallback :: WebViewSubmitFormCallback -> C_WebViewSubmitFormCallback
- type C_WebViewWebProcessCrashedCallback = Ptr () -> Ptr () -> IO CInt
- type WebViewWebProcessCrashedCallback = IO Bool
- afterWebViewWebProcessCrashed :: (IsWebView a, MonadIO m) => a -> WebViewWebProcessCrashedCallback -> m SignalHandlerId
- genClosure_WebViewWebProcessCrashed :: MonadIO m => WebViewWebProcessCrashedCallback -> m (GClosure C_WebViewWebProcessCrashedCallback)
- mk_WebViewWebProcessCrashedCallback :: C_WebViewWebProcessCrashedCallback -> IO (FunPtr C_WebViewWebProcessCrashedCallback)
- noWebViewWebProcessCrashedCallback :: Maybe WebViewWebProcessCrashedCallback
- onWebViewWebProcessCrashed :: (IsWebView a, MonadIO m) => a -> WebViewWebProcessCrashedCallback -> m SignalHandlerId
- wrap_WebViewWebProcessCrashedCallback :: WebViewWebProcessCrashedCallback -> C_WebViewWebProcessCrashedCallback
- type C_WebViewWebProcessTerminatedCallback = Ptr () -> CUInt -> Ptr () -> IO ()
- type WebViewWebProcessTerminatedCallback = WebProcessTerminationReason -> IO ()
- afterWebViewWebProcessTerminated :: (IsWebView a, MonadIO m) => a -> WebViewWebProcessTerminatedCallback -> m SignalHandlerId
- genClosure_WebViewWebProcessTerminated :: MonadIO m => WebViewWebProcessTerminatedCallback -> m (GClosure C_WebViewWebProcessTerminatedCallback)
- mk_WebViewWebProcessTerminatedCallback :: C_WebViewWebProcessTerminatedCallback -> IO (FunPtr C_WebViewWebProcessTerminatedCallback)
- noWebViewWebProcessTerminatedCallback :: Maybe WebViewWebProcessTerminatedCallback
- onWebViewWebProcessTerminated :: (IsWebView a, MonadIO m) => a -> WebViewWebProcessTerminatedCallback -> m SignalHandlerId
- wrap_WebViewWebProcessTerminatedCallback :: WebViewWebProcessTerminatedCallback -> C_WebViewWebProcessTerminatedCallback
Exported types
Memory-managed wrapper type.
Instances
GObject WebView Source # | |
Defined in GI.WebKit2.Objects.WebView gobjectType :: IO GType | |
HasParentTypes WebView Source # | |
Defined in GI.WebKit2.Objects.WebView | |
type ParentTypes WebView Source # | |
Defined in GI.WebKit2.Objects.WebView type ParentTypes WebView = WebViewBase ': (Container ': (Widget ': (Object ': (ImplementorIface ': (Buildable ': ([] :: [Type])))))) |
class (GObject o, IsDescendantOf WebView o) => IsWebView o Source #
Instances
(GObject o, IsDescendantOf WebView o) => IsWebView o Source # | |
Defined in GI.WebKit2.Objects.WebView |
Methods
canExecuteEditingCommand
webViewCanExecuteEditingCommand Source #
:: (HasCallStack, MonadIO m, IsWebView a, IsCancellable b) | |
=> a |
|
-> Text |
|
-> Maybe b |
|
-> Maybe AsyncReadyCallback |
|
-> m () |
Asynchronously check if it is possible to execute the given editing command.
When the operation is finished, callback
will be called. You can then call
webViewCanExecuteEditingCommandFinish
to get the result of the operation.
canExecuteEditingCommandFinish
webViewCanExecuteEditingCommandFinish Source #
:: (HasCallStack, MonadIO m, IsWebView a, IsAsyncResult b) | |
=> a |
|
-> b |
|
-> m () | (Can throw |
Finish an asynchronous operation started with webViewCanExecuteEditingCommand
.
canGoBack
:: (HasCallStack, MonadIO m, IsWebView a) | |
=> a |
|
-> m Bool |
Determines whether webView
has a previous history item.
canGoForward
:: (HasCallStack, MonadIO m, IsWebView a) | |
=> a |
|
-> m Bool |
Determines whether webView
has a next history item.
canShowMimeType
webViewCanShowMimeType Source #
:: (HasCallStack, MonadIO m, IsWebView a) | |
=> a |
|
-> Text |
|
-> m Bool | Returns: |
Whether or not a MIME type can be displayed in webView
.
downloadUri
:: (HasCallStack, MonadIO m, IsWebView a) | |
=> a |
|
-> Text |
|
-> m Download | Returns: a new |
Requests downloading of the specified URI string for webView
.
executeEditingCommand
webViewExecuteEditingCommand Source #
:: (HasCallStack, MonadIO m, IsWebView a) | |
=> a |
|
-> Text |
|
-> m () |
Request to execute the given command
for webView
. You can use
webViewCanExecuteEditingCommand
to check whether
it's possible to execute the command.
executeEditingCommandWithArgument
webViewExecuteEditingCommandWithArgument Source #
:: (HasCallStack, MonadIO m, IsWebView a) | |
=> a |
|
-> Text |
|
-> Text |
|
-> m () |
Request to execute the given command
with argument
for webView
. You can use
webViewCanExecuteEditingCommand
to check whether
it's possible to execute the command.
Since: 2.10
getBackForwardList
webViewGetBackForwardList Source #
:: (HasCallStack, MonadIO m, IsWebView a) | |
=> a |
|
-> m BackForwardList | Returns: the |
Obtains the BackForwardList
associated with the given WebView
. The
BackForwardList
is owned by the WebView
.
getBackgroundColor
webViewGetBackgroundColor Source #
:: (HasCallStack, MonadIO m, IsWebView a) | |
=> a |
|
-> m RGBA |
Gets the color that is used to draw the webView
background before
the actual contents are rendered.
For more information see also webViewSetBackgroundColor
Since: 2.8
getContext
:: (HasCallStack, MonadIO m, IsWebView a) | |
=> a |
|
-> m WebContext | Returns: the |
Gets the web context of webView
.
getCustomCharset
webViewGetCustomCharset Source #
:: (HasCallStack, MonadIO m, IsWebView a) | |
=> a |
|
-> m (Maybe Text) | Returns: the current custom character encoding name or |
Returns the current custom character encoding name of webView
.
getEditorState
webViewGetEditorState Source #
:: (HasCallStack, MonadIO m, IsWebView a) | |
=> a |
|
-> m EditorState | Returns: the |
Gets the web editor state of webView
.
Since: 2.10
getEstimatedLoadProgress
webViewGetEstimatedLoadProgress Source #
:: (HasCallStack, MonadIO m, IsWebView a) | |
=> a |
|
-> m Double | Returns: an estimate of the of the percent complete for a document load as a range from 0.0 to 1.0. |
Gets the value of the WebView
:estimated-load-progress
property.
You can monitor the estimated progress of a load operation by
connecting to the notify::estimated-load-progress signal of webView
.
getFavicon
:: (HasCallStack, MonadIO m, IsWebView a) | |
=> a |
|
-> m (Maybe Surface) | Returns: a pointer to a |
Returns favicon currently associated to webView
, if any. You can
connect to notify::favicon signal of webView
to be notified when
the favicon is available.
getFindController
webViewGetFindController Source #
:: (HasCallStack, MonadIO m, IsWebView a) | |
=> a |
|
-> m FindController | Returns: the |
Gets the FindController
that will allow the caller to query
the WebView
for the text to look for.
getInspector
:: (HasCallStack, MonadIO m, IsWebView a) | |
=> a |
|
-> m WebInspector | Returns: the |
Get the WebInspector
associated to webView
getMainResource
webViewGetMainResource Source #
:: (HasCallStack, MonadIO m, IsWebView a) | |
=> a |
|
-> m (Maybe WebResource) | Returns: the main |
Return the main resource of webView
.
getPageId
:: (HasCallStack, MonadIO m, IsWebView a) | |
=> a |
|
-> m Word64 | Returns: the page ID of |
Get the identifier of the WebKitWebPage
corresponding to
the WebView
getSessionState
webViewGetSessionState Source #
:: (HasCallStack, MonadIO m, IsWebView a) | |
=> a |
|
-> m WebViewSessionState | Returns: a |
Gets the current session state of webView
Since: 2.12
getSettings
:: (HasCallStack, MonadIO m, IsWebView a) | |
=> a |
|
-> m Settings | Returns: the |
Gets the Settings
currently applied to webView
.
If no other Settings
have been explicitly applied to
webView
with webViewSetSettings
, the default
Settings
will be returned. This method always returns
a valid Settings
object.
To modify any of the webView
settings, you can either create
a new Settings
object with settingsNew
, setting
the desired preferences, and then replace the existing webView
settings with webViewSetSettings
or get the existing
webView
settings and update it directly. Settings
objects
can be shared by multiple WebView
<!-- -->s, so modifying
the settings of a WebView
would affect other
WebView
<!-- -->s using the same Settings
.
getSnapshot
:: (HasCallStack, MonadIO m, IsWebView a, IsCancellable b) | |
=> a |
|
-> SnapshotRegion |
|
-> [SnapshotOptions] |
|
-> Maybe b |
|
-> Maybe AsyncReadyCallback |
|
-> m () |
Asynchronously retrieves a snapshot of webView
for region
.
options
specifies how the snapshot should be rendered.
When the operation is finished, callback
will be called. You must
call webViewGetSnapshotFinish
to get the result of the
operation.
getSnapshotFinish
webViewGetSnapshotFinish Source #
:: (HasCallStack, MonadIO m, IsWebView a, IsAsyncResult b) | |
=> a |
|
-> b |
|
-> m Surface | Returns: a |
Finishes an asynchronous operation started with webViewGetSnapshot
.
getTitle
:: (HasCallStack, MonadIO m, IsWebView a) | |
=> a |
|
-> m (Maybe Text) | Returns: The main frame document title of |
Gets the value of the WebView
:title
property.
You can connect to notify::title signal of webView
to
be notified when the title has been received.
getTlsInfo
:: (HasCallStack, MonadIO m, IsWebView a) | |
=> a |
|
-> m (Bool, TlsCertificate, [TlsCertificateFlags]) | Returns: |
Retrieves the TlsCertificate
associated with the main resource of webView
,
and the TlsCertificateFlags
showing what problems, if any, have been found
with that certificate.
If the connection is not HTTPS, this function returns False
.
This function should be called after a response has been received from the
server, so you can connect to WebView
::load-changed
and call this function
when it's emitted with LoadEventCommitted
event.
Note that this function provides no information about the security of the web
page if the current TLSErrorsPolicy
is wEBKITTLSERRORSPOLICYIGNORE
,
as subresources of the page may be controlled by an attacker. This function
may safely be used to determine the security status of the current page only
if the current TLSErrorsPolicy
is wEBKITTLSERRORSPOLICYFAIL
, in
which case subresources that fail certificate verification will be blocked.
getUri
:: (HasCallStack, MonadIO m, IsWebView a) | |
=> a |
|
-> m (Maybe Text) | Returns: the current active URI of |
Returns the current active URI of webView
. The active URI might change during
a load operation:
<orderedlist>
<listitem><para>
When nothing has been loaded yet on webView
the active URI is Nothing
.
</para></listitem>
<listitem><para>
When a new load operation starts the active URI is the requested URI:
<itemizedlist>
<listitem><para>
If the load operation was started by webViewLoadUri
,
the requested URI is the given one.
</para></listitem>
<listitem><para>
If the load operation was started by webViewLoadHtml
,
the requested URI is "about:blank".
</para></listitem>
<listitem><para>
If the load operation was started by webViewLoadAlternateHtml
,
the requested URI is content URI provided.
</para></listitem>
<listitem><para>
If the load operation was started by webViewGoBack
or
webViewGoForward
, the requested URI is the original URI
of the previous/next item in the BackForwardList
of webView
.
</para></listitem>
<listitem><para>
If the load operation was started by
webViewGoToBackForwardListItem
, the requested URI
is the opriginal URI of the given BackForwardListItem
.
</para></listitem>
</itemizedlist>
</para></listitem>
<listitem><para>
If there is a server redirection during the load operation,
the active URI is the redirected URI. When the signal
WebView
::load-changed
is emitted with LoadEventRedirected
event, the active URI is already updated to the redirected URI.
</para></listitem>
<listitem><para>
When the signal WebView
::load-changed
is emitted
with LoadEventCommitted
event, the active URI is the final
one and it will not change unless a new load operation is started
or a navigation action within the same page is performed.
</para></listitem>
</orderedlist>
You can monitor the active URI by connecting to the notify::uri
signal of webView
.
getUserContentManager
webViewGetUserContentManager Source #
:: (HasCallStack, MonadIO m, IsWebView a) | |
=> a |
|
-> m UserContentManager | Returns: the |
Gets the user content manager associated to webView
.
Since: 2.6
getWebsiteDataManager
webViewGetWebsiteDataManager Source #
:: (HasCallStack, MonadIO m, IsWebView a) | |
=> a |
|
-> m WebsiteDataManager | Returns: a |
Get the WebsiteDataManager
associated to webView
. If webView
is not ephemeral,
the returned WebsiteDataManager
will be the same as the WebsiteDataManager
of webView
's WebContext
.
Since: 2.16
getWindowProperties
webViewGetWindowProperties Source #
:: (HasCallStack, MonadIO m, IsWebView a) | |
=> a |
|
-> m WindowProperties | Returns: the |
Get the WindowProperties
object containing the properties
that the window containing webView
should have.
getZoomLevel
:: (HasCallStack, MonadIO m, IsWebView a) | |
=> a |
|
-> m Double | Returns: the current zoom level of |
Get the zoom level of webView
, i.e. the factor by which the
view contents are scaled with respect to their original size.
goBack
:: (HasCallStack, MonadIO m, IsWebView a) | |
=> a |
|
-> m () |
Loads the previous history item.
You can monitor the load operation by connecting to
WebView
::load-changed
signal.
goForward
:: (HasCallStack, MonadIO m, IsWebView a) | |
=> a |
|
-> m () |
Loads the next history item.
You can monitor the load operation by connecting to
WebView
::load-changed
signal.
goToBackForwardListItem
webViewGoToBackForwardListItem Source #
:: (HasCallStack, MonadIO m, IsWebView a, IsBackForwardListItem b) | |
=> a |
|
-> b |
|
-> m () |
Loads the specific history item listItem
.
You can monitor the load operation by connecting to
WebView
::load-changed
signal.
isControlledByAutomation
isEditable
webViewIsEditable :: (HasCallStack, MonadIO m, IsWebView a) => a -> m Bool Source #
No description available in the introspection data.
isEphemeral
:: (HasCallStack, MonadIO m, IsWebView a) | |
=> a |
|
-> m Bool |
Get whether a WebView
is ephemeral. To create an ephemeral WebView
you need to
use g_object_new()
and pass is-ephemeral property with True
value. See
WebView
:is-ephemeral
for more details.
If webView
was created with a ephemeral WebView
:related-view
or an
ephemeral WebView
:web-context
it will also be ephemeral.
Since: 2.16
isLoading
:: (HasCallStack, MonadIO m, IsWebView a) | |
=> a |
|
-> m Bool | Returns: |
Gets the value of the WebView
:is-loading
property.
You can monitor when a WebView
is loading a page by connecting to
notify::is-loading signal of webView
. This is useful when you are
interesting in knowing when the view is loading something but not in the
details about the status of the load operation, for example to start a spinner
when the view is loading a page and stop it when it finishes.
isPlayingAudio
loadAlternateHtml
webViewLoadAlternateHtml Source #
:: (HasCallStack, MonadIO m, IsWebView a) | |
=> a |
|
-> Text |
|
-> Text |
|
-> Maybe Text |
|
-> m () |
Load the given content
string for the URI contentUri
.
This allows clients to display page-loading errors in the WebView
itself.
When this method is called from WebView
::load-failed
signal to show an
error page, then the back-forward list is maintained appropriately.
For everything else this method works the same way as webViewLoadHtml
.
loadBytes
:: (HasCallStack, MonadIO m, IsWebView a) | |
=> a |
|
-> Bytes |
|
-> Maybe Text |
|
-> Maybe Text |
|
-> Maybe Text |
|
-> m () |
Load the specified bytes
into webView
using the given mimeType
and encoding
.
When mimeType
is Nothing
, it defaults to "text/html".
When encoding
is Nothing
, it defaults to "UTF-8".
When baseUri
is Nothing
, it defaults to "about:blank".
You can monitor the load operation by connecting to WebView
::load-changed
signal.
Since: 2.6
loadHtml
:: (HasCallStack, MonadIO m, IsWebView a) | |
=> a |
|
-> Text |
|
-> Maybe Text |
|
-> m () |
Load the given content
string with the specified baseUri
.
If baseUri
is not Nothing
, relative URLs in the content
will be
resolved against baseUri
and absolute local paths must be children of the baseUri
.
For security reasons absolute local paths that are not children of baseUri
will cause the web process to terminate.
If you need to include URLs in content
that are local paths in a different
directory than baseUri
you can build a data URI for them. When baseUri
is Nothing
,
it defaults to "about:blank". The mime type of the document will be "text/html".
You can monitor the load operation by connecting to WebView
::load-changed
signal.
loadPlainText
:: (HasCallStack, MonadIO m, IsWebView a) | |
=> a |
|
-> Text |
|
-> m () |
Load the specified plainText
string into webView
. The mime type of
document will be "text/plain". You can monitor the load
operation by connecting to WebView
::load-changed
signal.
loadRequest
:: (HasCallStack, MonadIO m, IsWebView a, IsURIRequest b) | |
=> a |
|
-> b |
|
-> m () |
Requests loading of the specified URIRequest
.
You can monitor the load operation by connecting to
WebView
::load-changed
signal.
loadUri
:: (HasCallStack, MonadIO m, IsWebView a) | |
=> a |
|
-> Text |
|
-> m () |
Requests loading of the specified URI string.
You can monitor the load operation by connecting to
WebView
::load-changed
signal.
new
:: (HasCallStack, MonadIO m) | |
=> m WebView | Returns: The newly created |
Creates a new WebView
with the default WebContext
and
no UserContentManager
associated with it.
See also webViewNewWithContext
,
webViewNewWithUserContentManager
, and
webViewNewWithSettings
.
newWithContext
webViewNewWithContext Source #
:: (HasCallStack, MonadIO m, IsWebContext a) | |
=> a |
|
-> m WebView | Returns: The newly created |
Creates a new WebView
with the given WebContext
and
no UserContentManager
associated with it.
See also webViewNewWithUserContentManager
and
webViewNewWithSettings
.
newWithRelatedView
webViewNewWithRelatedView Source #
:: (HasCallStack, MonadIO m, IsWebView a) | |
=> a |
|
-> m WebView | Returns: The newly created |
Creates a new WebView
sharing the same web process with webView
.
This method doesn't have any effect when ProcessModelSharedSecondaryProcess
process model is used, because a single web process is shared for all the web views in the
same WebContext
. When using ProcessModelMultipleSecondaryProcesses
process model,
this method should always be used when creating the WebView
in the WebView
::create
signal.
You can also use this method to implement other process models based on ProcessModelMultipleSecondaryProcesses
,
like for example, sharing the same web process for all the views in the same security domain.
The newly created WebView
will also have the same UserContentManager
and Settings
as webView
.
Since: 2.4
newWithSettings
webViewNewWithSettings Source #
:: (HasCallStack, MonadIO m, IsSettings a) | |
=> a |
|
-> m WebView | Returns: The newly created |
Creates a new WebView
with the given Settings
.
See also webViewNewWithContext
, and
webViewNewWithUserContentManager
.
Since: 2.6
newWithUserContentManager
webViewNewWithUserContentManager Source #
:: (HasCallStack, MonadIO m, IsUserContentManager a) | |
=> a |
|
-> m WebView | Returns: The newly created |
Creates a new WebView
with the given UserContentManager
.
The content loaded in the view may be affected by the content injected
in the view by the user content manager.
Since: 2.6
reload
:: (HasCallStack, MonadIO m, IsWebView a) | |
=> a |
|
-> m () |
Reloads the current contents of webView
.
See also webViewReloadBypassCache
.
reloadBypassCache
webViewReloadBypassCache Source #
:: (HasCallStack, MonadIO m, IsWebView a) | |
=> a |
|
-> m () |
Reloads the current contents of webView
without
using any cached data.
restoreSessionState
webViewRestoreSessionState Source #
:: (HasCallStack, MonadIO m, IsWebView a) | |
=> a |
|
-> WebViewSessionState |
|
-> m () |
Restore the webView
session state from state
Since: 2.12
runJavascript
:: (HasCallStack, MonadIO m, IsWebView a, IsCancellable b) | |
=> a |
|
-> Text |
|
-> Maybe b |
|
-> Maybe AsyncReadyCallback |
|
-> m () |
Asynchronously run script
in the context of the current page in webView
. If
WebKitSettings:enable-javascript is FALSE, this method will do nothing.
When the operation is finished, callback
will be called. You can then call
webViewRunJavascriptFinish
to get the result of the operation.
runJavascriptFinish
webViewRunJavascriptFinish Source #
:: (HasCallStack, MonadIO m, IsWebView a, IsAsyncResult b) | |
=> a |
|
-> b |
|
-> m JavascriptResult | Returns: a |
Finish an asynchronous operation started with webViewRunJavascript
.
This is an example of using webViewRunJavascript
with a script returning
a string:
<informalexample><programlisting> static void web_view_javascript_finished (GObject *object, GAsyncResult *result, gpointer user_data) { WebKitJavascriptResult *js_result; JSCValue *value; GError *error = NULL;
js_result = webkit_web_view_run_javascript_finish (WEBKIT_WEB_VIEW (object), result, &error);
if (!js_result) {
g_warning ("Error running javascript: s
", error->message);
g_error_free (error);
return;
}
value = webkit_javascript_result_get_js_value (js_result); if (jsc_value_is_string (value)) { JSCException *exception; gchar *str_value;
str_value = jsc_value_to_string (value);
exception = jsc_context_get_exception (jsc_value_get_context (value));
if (exception)
g_warning ("Error running javascript: s
", jsc_exception_get_message (exception));
else
g_print ("Script result: s
\n", str_value);
g_free (str_value);
} else {
g_warning ("Error running javascript: unexpected return value");
}
webkit_javascript_result_unref (js_result);
}
static void web_view_get_link_url (WebKitWebView *web_view, const gchar *link_id) { gchar *script;
script = g_strdup_printf ("window.document.getElementById('s
').href;", link_id);
webkit_web_view_run_javascript (web_view, script, NULL, web_view_javascript_finished, NULL);
g_free (script);
}
</programlisting></informalexample>
runJavascriptFromGresource
webViewRunJavascriptFromGresource Source #
:: (HasCallStack, MonadIO m, IsWebView a, IsCancellable b) | |
=> a |
|
-> Text |
|
-> Maybe b |
|
-> Maybe AsyncReadyCallback |
|
-> m () |
Asynchronously run the script from resource
in the context of the
current page in webView
.
When the operation is finished, callback
will be called. You can
then call webViewRunJavascriptFromGresourceFinish
to get the result
of the operation.
runJavascriptFromGresourceFinish
webViewRunJavascriptFromGresourceFinish Source #
:: (HasCallStack, MonadIO m, IsWebView a, IsAsyncResult b) | |
=> a |
|
-> b |
|
-> m JavascriptResult | Returns: a |
Finish an asynchronous operation started with webViewRunJavascriptFromGresource
.
Check webViewRunJavascriptFinish
for a usage example.
runJavascriptInWorld
webViewRunJavascriptInWorld Source #
:: (HasCallStack, MonadIO m, IsWebView a, IsCancellable b) | |
=> a |
|
-> Text |
|
-> Text |
|
-> Maybe b |
|
-> Maybe AsyncReadyCallback |
|
-> m () |
Asynchronously run script
in the script world with name worldName
of the current page context in webView
.
If WebKitSettings:enable-javascript is FALSE, this method will do nothing.
When the operation is finished, callback
will be called. You can then call
webViewRunJavascriptInWorldFinish
to get the result of the operation.
Since: 2.22
runJavascriptInWorldFinish
webViewRunJavascriptInWorldFinish Source #
:: (HasCallStack, MonadIO m, IsWebView a, IsAsyncResult b) | |
=> a |
|
-> b |
|
-> m JavascriptResult | Returns: a |
Finish an asynchronous operation started with webViewRunJavascriptInWorld
.
Since: 2.22
save
:: (HasCallStack, MonadIO m, IsWebView a, IsCancellable b) | |
=> a |
|
-> SaveMode |
|
-> Maybe b |
|
-> Maybe AsyncReadyCallback |
|
-> m () |
Asynchronously save the current web page associated to the
WebView
into a self-contained format using the mode
specified in saveMode
.
When the operation is finished, callback
will be called. You can
then call webViewSaveFinish
to get the result of the
operation.
saveFinish
:: (HasCallStack, MonadIO m, IsWebView a, IsAsyncResult b) | |
=> a |
|
-> b |
|
-> m InputStream | Returns: a |
Finish an asynchronous operation started with webViewSave
.
saveToFile
:: (HasCallStack, MonadIO m, IsWebView a, IsFile b, IsCancellable c) | |
=> a |
|
-> b |
|
-> SaveMode |
|
-> Maybe c |
|
-> Maybe AsyncReadyCallback |
|
-> m () |
Asynchronously save the current web page associated to the
WebView
into a self-contained format using the mode
specified in saveMode
and writing it to file
.
When the operation is finished, callback
will be called. You can
then call webViewSaveToFileFinish
to get the result of the
operation.
saveToFileFinish
webViewSaveToFileFinish Source #
:: (HasCallStack, MonadIO m, IsWebView a, IsAsyncResult b) | |
=> a |
|
-> b |
|
-> m () | (Can throw |
Finish an asynchronous operation started with webViewSaveToFile
.
setBackgroundColor
webViewSetBackgroundColor Source #
:: (HasCallStack, MonadIO m, IsWebView a) | |
=> a |
|
-> RGBA |
|
-> m () |
Sets the color that will be used to draw the webView
background before
the actual contents are rendered. Note that if the web page loaded in webView
specifies a background color, it will take precedence over the rgba
color.
By default the webView
background color is opaque white.
Note that the parent window must have a RGBA visual and
Widget
:app-paintable
property set to True
for backgrounds colors to work.
<informalexample><programlisting> static void browser_window_set_background_color (BrowserWindow *window, const GdkRGBA *rgba) { WebKitWebView *web_view; GdkScreen *screen = gtk_window_get_screen (GTK_WINDOW (window)); GdkVisual *rgba_visual = gdk_screen_get_rgba_visual (screen);
if (!rgba_visual) return;
gtk_widget_set_visual (GTK_WIDGET (window), rgba_visual); gtk_widget_set_app_paintable (GTK_WIDGET (window), TRUE);
web_view = browser_window_get_web_view (window); webkit_web_view_set_background_color (web_view, rgba); } </programlisting></informalexample>
Since: 2.8
setCustomCharset
webViewSetCustomCharset Source #
:: (HasCallStack, MonadIO m, IsWebView a) | |
=> a |
|
-> Maybe Text |
|
-> m () |
Sets the current custom character encoding override of webView
. The custom
character encoding will override any text encoding detected via HTTP headers or
META tags. Calling this method will stop any current load operation and reload the
current page. Setting the custom character encoding to Nothing
removes the character
encoding override.
setEditable
:: (HasCallStack, MonadIO m, IsWebView a) | |
=> a |
|
-> Bool |
|
-> m () |
Sets whether the user is allowed to edit the HTML document.
If editable
is True
, webView
allows the user to edit the HTML document. If
editable
is False
, an element in webView
's document can only be edited if the
CONTENTEDITABLE attribute has been set on the element or one of its parent
elements. By default a WebView
is not editable.
Normally, a HTML document is not editable unless the elements within the
document are editable. This function provides a way to make the contents
of a WebView
editable without altering the document or DOM structure.
Since: 2.8
setSettings
:: (HasCallStack, MonadIO m, IsWebView a, IsSettings b) | |
=> a |
|
-> b |
|
-> m () |
setZoomLevel
:: (HasCallStack, MonadIO m, IsWebView a) | |
=> a |
|
-> Double |
|
-> m () |
Set the zoom level of webView
, i.e. the factor by which the
view contents are scaled with respect to their original size.
stopLoading
:: (HasCallStack, MonadIO m, IsWebView a) | |
=> a |
|
-> m () |
Stops any ongoing loading operation in webView
.
This method does nothing if no content is being loaded.
If there is a loading operation in progress, it will be cancelled and
WebView
::load-failed
signal will be emitted with
NetworkErrorCancelled
error.
tryClose
:: (HasCallStack, MonadIO m, IsWebView a) | |
=> a |
|
-> m () |
Tries to close the webView
. This will fire the onbeforeunload event
to ask the user for confirmation to close the page. If there isn't an
onbeforeunload event handler or the user confirms to close the page,
the WebView
::close
signal is emitted, otherwise nothing happens.
Since: 2.12
Properties
editable
Whether the pages loaded inside WebView
are editable. For more
information see webViewSetEditable
.
Since: 2.8
constructWebViewEditable :: IsWebView o => Bool -> IO (GValueConstruct o) Source #
Construct a GValueConstruct
with valid value for the “editable
” property. This is rarely needed directly, but it is used by new
.
getWebViewEditable :: (MonadIO m, IsWebView o) => o -> m Bool Source #
Get the value of the “editable
” property.
When overloading is enabled, this is equivalent to
get
webView #editable
setWebViewEditable :: (MonadIO m, IsWebView o) => o -> Bool -> m () Source #
Set the value of the “editable
” property.
When overloading is enabled, this is equivalent to
set
webView [ #editable:=
value ]
estimatedLoadProgress
An estimate of the percent completion for the current loading operation. This value will range from 0.0 to 1.0 and, once a load completes, will remain at 1.0 until a new load starts, at which point it will be reset to 0.0. The value is an estimate based on the total number of bytes expected to be received for a document, including all its possible subresources and child documents.
getWebViewEstimatedLoadProgress :: (MonadIO m, IsWebView o) => o -> m Double Source #
Get the value of the “estimated-load-progress
” property.
When overloading is enabled, this is equivalent to
get
webView #estimatedLoadProgress
favicon
The favicon currently associated to the WebView
.
See webViewGetFavicon
for more details.
getWebViewFavicon :: (MonadIO m, IsWebView o) => o -> m (Ptr ()) Source #
Get the value of the “favicon
” property.
When overloading is enabled, this is equivalent to
get
webView #favicon
isControlledByAutomation
Whether the WebView
is controlled by automation. This should only be used when
creating a new WebView
as a response to AutomationSession
::create-web-view
signal request.
Since: 2.18
constructWebViewIsControlledByAutomation :: IsWebView o => Bool -> IO (GValueConstruct o) Source #
Construct a GValueConstruct
with valid value for the “is-controlled-by-automation
” property. This is rarely needed directly, but it is used by new
.
getWebViewIsControlledByAutomation :: (MonadIO m, IsWebView o) => o -> m Bool Source #
Get the value of the “is-controlled-by-automation
” property.
When overloading is enabled, this is equivalent to
get
webView #isControlledByAutomation
isEphemeral
Whether the WebView
is ephemeral. An ephemeral web view never writes
website data to the client storage, no matter what WebsiteDataManager
its context is using. This is normally used to implement private browsing mode.
This is a ParamFlagsConstructOnly
property, so you have to create a ephemeral
WebView
and it can't be changed. Note that all WebView
<!-- -->s
created with an ephemeral WebContext
will be ephemeral automatically.
See also webContextNewEphemeral
.
Since: 2.16
constructWebViewIsEphemeral :: IsWebView o => Bool -> IO (GValueConstruct o) Source #
Construct a GValueConstruct
with valid value for the “is-ephemeral
” property. This is rarely needed directly, but it is used by new
.
getWebViewIsEphemeral :: (MonadIO m, IsWebView o) => o -> m Bool Source #
Get the value of the “is-ephemeral
” property.
When overloading is enabled, this is equivalent to
get
webView #isEphemeral
isLoading
Whether the WebView
is currently loading a page. This property becomes
True
as soon as a new load operation is requested and before the
WebView
::load-changed
signal is emitted with LoadEventStarted
and
at that point the active URI is the requested one.
When the load operation finishes the property is set to False
before
WebView
::load-changed
is emitted with LoadEventFinished
.
getWebViewIsLoading :: (MonadIO m, IsWebView o) => o -> m Bool Source #
Get the value of the “is-loading
” property.
When overloading is enabled, this is equivalent to
get
webView #isLoading
isPlayingAudio
Whether the WebView
is currently playing audio from a page.
This property becomes True
as soon as web content starts playing any
kind of audio. When a page is no longer playing any kind of sound,
the property is set back to False
.
Since: 2.8
getWebViewIsPlayingAudio :: (MonadIO m, IsWebView o) => o -> m Bool Source #
Get the value of the “is-playing-audio
” property.
When overloading is enabled, this is equivalent to
get
webView #isPlayingAudio
relatedView
The related WebView
used when creating the view to share the
same web process. This property is not readable because the related
web view is only valid during the object construction.
Since: 2.4
constructWebViewRelatedView :: (IsWebView o, IsWebView a) => a -> IO (GValueConstruct o) Source #
Construct a GValueConstruct
with valid value for the “related-view
” property. This is rarely needed directly, but it is used by new
.
settings
The Settings
of the view.
Since: 2.6
constructWebViewSettings :: (IsWebView o, IsSettings a) => a -> IO (GValueConstruct o) Source #
Construct a GValueConstruct
with valid value for the “settings
” property. This is rarely needed directly, but it is used by new
.
setWebViewSettings :: (MonadIO m, IsWebView o, IsSettings a) => o -> a -> m () Source #
Set the value of the “settings
” property.
When overloading is enabled, this is equivalent to
set
webView [ #settings:=
value ]
title
The main frame document title of this WebView
. If
the title has not been received yet, it will be Nothing
.
getWebViewTitle :: (MonadIO m, IsWebView o) => o -> m (Maybe Text) Source #
Get the value of the “title
” property.
When overloading is enabled, this is equivalent to
get
webView #title
uri
The current active URI of the WebView
.
See webViewGetUri
for more details.
getWebViewUri :: (MonadIO m, IsWebView o) => o -> m (Maybe Text) Source #
Get the value of the “uri
” property.
When overloading is enabled, this is equivalent to
get
webView #uri
userContentManager
The UserContentManager
of the view.
Since: 2.6
constructWebViewUserContentManager :: (IsWebView o, IsUserContentManager a) => a -> IO (GValueConstruct o) Source #
Construct a GValueConstruct
with valid value for the “user-content-manager
” property. This is rarely needed directly, but it is used by new
.
getWebViewUserContentManager :: (MonadIO m, IsWebView o) => o -> m UserContentManager Source #
Get the value of the “user-content-manager
” property.
When overloading is enabled, this is equivalent to
get
webView #userContentManager
webContext
The WebContext
of the view.
constructWebViewWebContext :: (IsWebView o, IsWebContext a) => a -> IO (GValueConstruct o) Source #
Construct a GValueConstruct
with valid value for the “web-context
” property. This is rarely needed directly, but it is used by new
.
getWebViewWebContext :: (MonadIO m, IsWebView o) => o -> m (Maybe WebContext) Source #
Get the value of the “web-context
” property.
When overloading is enabled, this is equivalent to
get
webView #webContext
zoomLevel
The zoom level of the WebView
content.
See webViewSetZoomLevel
for more details.
constructWebViewZoomLevel :: IsWebView o => Double -> IO (GValueConstruct o) Source #
Construct a GValueConstruct
with valid value for the “zoom-level
” property. This is rarely needed directly, but it is used by new
.
getWebViewZoomLevel :: (MonadIO m, IsWebView o) => o -> m Double Source #
Get the value of the “zoom-level
” property.
When overloading is enabled, this is equivalent to
get
webView #zoomLevel
setWebViewZoomLevel :: (MonadIO m, IsWebView o) => o -> Double -> m () Source #
Set the value of the “zoom-level
” property.
When overloading is enabled, this is equivalent to
set
webView [ #zoomLevel:=
value ]
Signals
authenticate
type C_WebViewAuthenticateCallback = Ptr () -> Ptr AuthenticationRequest -> Ptr () -> IO CInt Source #
Type for the callback on the (unwrapped) C side.
type WebViewAuthenticateCallback Source #
= AuthenticationRequest |
|
-> IO Bool | Returns: |
This signal is emitted when the user is challenged with HTTP
authentication. To let the application access or supply
the credentials as well as to allow the client application
to either cancel the request or perform the authentication,
the signal will pass an instance of the
AuthenticationRequest
in the request
argument.
To handle this signal asynchronously you should keep a ref
of the request and return True
. To disable HTTP authentication
entirely, connect to this signal and simply return True
.
The default signal handler will run a default authentication dialog asynchronously for the user to interact with.
Since: 2.2
afterWebViewAuthenticate :: (IsWebView a, MonadIO m) => a -> WebViewAuthenticateCallback -> m SignalHandlerId Source #
Connect a signal handler for the “authenticate
” signal, to be run after the default handler.
When overloading is enabled, this is equivalent to
after
webView #authenticate callback
genClosure_WebViewAuthenticate :: MonadIO m => WebViewAuthenticateCallback -> m (GClosure C_WebViewAuthenticateCallback) Source #
Wrap the callback into a GClosure
.
mk_WebViewAuthenticateCallback :: C_WebViewAuthenticateCallback -> IO (FunPtr C_WebViewAuthenticateCallback) Source #
Generate a function pointer callable from C code, from a C_WebViewAuthenticateCallback
.
noWebViewAuthenticateCallback :: Maybe WebViewAuthenticateCallback Source #
A convenience synonym for
.Nothing
:: Maybe
WebViewAuthenticateCallback
onWebViewAuthenticate :: (IsWebView a, MonadIO m) => a -> WebViewAuthenticateCallback -> m SignalHandlerId Source #
Connect a signal handler for the “authenticate
” signal, to be run before the default handler.
When overloading is enabled, this is equivalent to
on
webView #authenticate callback
wrap_WebViewAuthenticateCallback :: WebViewAuthenticateCallback -> C_WebViewAuthenticateCallback Source #
Wrap a WebViewAuthenticateCallback
into a C_WebViewAuthenticateCallback
.
close
type C_WebViewCloseCallback = Ptr () -> Ptr () -> IO () Source #
Type for the callback on the (unwrapped) C side.
type WebViewCloseCallback = IO () Source #
Emitted when closing a WebView
is requested. This occurs when a
call is made from JavaScript's <function>window.close</function> function or
after trying to close the webView
with webViewTryClose
.
It is the owner's responsibility to handle this signal to hide or
destroy the WebView
, if necessary.
afterWebViewClose :: (IsWebView a, MonadIO m) => a -> WebViewCloseCallback -> m SignalHandlerId Source #
Connect a signal handler for the “close
” signal, to be run after the default handler.
When overloading is enabled, this is equivalent to
after
webView #close callback
genClosure_WebViewClose :: MonadIO m => WebViewCloseCallback -> m (GClosure C_WebViewCloseCallback) Source #
Wrap the callback into a GClosure
.
mk_WebViewCloseCallback :: C_WebViewCloseCallback -> IO (FunPtr C_WebViewCloseCallback) Source #
Generate a function pointer callable from C code, from a C_WebViewCloseCallback
.
noWebViewCloseCallback :: Maybe WebViewCloseCallback Source #
A convenience synonym for
.Nothing
:: Maybe
WebViewCloseCallback
onWebViewClose :: (IsWebView a, MonadIO m) => a -> WebViewCloseCallback -> m SignalHandlerId Source #
Connect a signal handler for the “close
” signal, to be run before the default handler.
When overloading is enabled, this is equivalent to
on
webView #close callback
wrap_WebViewCloseCallback :: WebViewCloseCallback -> C_WebViewCloseCallback Source #
Wrap a WebViewCloseCallback
into a C_WebViewCloseCallback
.
contextMenu
type C_WebViewContextMenuCallback = Ptr () -> Ptr ContextMenu -> Ptr Event -> Ptr HitTestResult -> Ptr () -> IO CInt Source #
Type for the callback on the (unwrapped) C side.
type WebViewContextMenuCallback Source #
= ContextMenu |
|
-> Event |
|
-> HitTestResult |
|
-> IO Bool | Returns: |
Emitted when a context menu is about to be displayed to give the application
a chance to customize the proposed menu, prevent the menu from being displayed,
or build its own context menu.
<itemizedlist>
<listitem><para>
To customize the proposed menu you can use contextMenuPrepend
,
contextMenuAppend
or contextMenuInsert
to add new
ContextMenuItem
<!-- -->s to contextMenu
, contextMenuMoveItem
to reorder existing items, or contextMenuRemove
to remove an
existing item. The signal handler should return False
, and the menu represented
by contextMenu
will be shown.
</para></listitem>
<listitem><para>
To prevent the menu from being displayed you can just connect to this signal
and return True
so that the proposed menu will not be shown.
</para></listitem>
<listitem><para>
To build your own menu, you can remove all items from the proposed menu with
contextMenuRemoveAll
, add your own items and return False
so
that the menu will be shown. You can also ignore the proposed ContextMenu
,
build your own Menu
and return True
to prevent the proposed menu from being shown.
</para></listitem>
<listitem><para>
If you just want the default menu to be shown always, simply don't connect to this
signal because showing the proposed context menu is the default behaviour.
</para></listitem>
</itemizedlist>
The event
is expected to be one of the following types:
<itemizedlist>
<listitem><para>
a EventButton
of type EventTypeButtonPress
when the context menu
was triggered with mouse.
</para></listitem>
<listitem><para>
a EventKey
of type EventTypeKeyPress
if the keyboard was used to show
the menu.
</para></listitem>
<listitem><para>
a generic Event
of type EventTypeNothing
when the Widget
::popup-menu
signal was used to show the context menu.
</para></listitem>
</itemizedlist>
If the signal handler returns False
the context menu represented by contextMenu
will be shown, if it return True
the context menu will not be shown.
The proposed ContextMenu
passed in contextMenu
argument is only valid
during the signal emission.
afterWebViewContextMenu :: (IsWebView a, MonadIO m) => a -> WebViewContextMenuCallback -> m SignalHandlerId Source #
Connect a signal handler for the “context-menu
” signal, to be run after the default handler.
When overloading is enabled, this is equivalent to
after
webView #contextMenu callback
genClosure_WebViewContextMenu :: MonadIO m => WebViewContextMenuCallback -> m (GClosure C_WebViewContextMenuCallback) Source #
Wrap the callback into a GClosure
.
mk_WebViewContextMenuCallback :: C_WebViewContextMenuCallback -> IO (FunPtr C_WebViewContextMenuCallback) Source #
Generate a function pointer callable from C code, from a C_WebViewContextMenuCallback
.
noWebViewContextMenuCallback :: Maybe WebViewContextMenuCallback Source #
A convenience synonym for
.Nothing
:: Maybe
WebViewContextMenuCallback
onWebViewContextMenu :: (IsWebView a, MonadIO m) => a -> WebViewContextMenuCallback -> m SignalHandlerId Source #
Connect a signal handler for the “context-menu
” signal, to be run before the default handler.
When overloading is enabled, this is equivalent to
on
webView #contextMenu callback
wrap_WebViewContextMenuCallback :: WebViewContextMenuCallback -> C_WebViewContextMenuCallback Source #
Wrap a WebViewContextMenuCallback
into a C_WebViewContextMenuCallback
.
contextMenuDismissed
type C_WebViewContextMenuDismissedCallback = Ptr () -> Ptr () -> IO () Source #
Type for the callback on the (unwrapped) C side.
type WebViewContextMenuDismissedCallback = IO () Source #
Emitted after WebView
::context-menu
signal, if the context menu is shown,
to notify that the context menu is dismissed.
afterWebViewContextMenuDismissed :: (IsWebView a, MonadIO m) => a -> WebViewContextMenuDismissedCallback -> m SignalHandlerId Source #
Connect a signal handler for the “context-menu-dismissed
” signal, to be run after the default handler.
When overloading is enabled, this is equivalent to
after
webView #contextMenuDismissed callback
genClosure_WebViewContextMenuDismissed :: MonadIO m => WebViewContextMenuDismissedCallback -> m (GClosure C_WebViewContextMenuDismissedCallback) Source #
Wrap the callback into a GClosure
.
mk_WebViewContextMenuDismissedCallback :: C_WebViewContextMenuDismissedCallback -> IO (FunPtr C_WebViewContextMenuDismissedCallback) Source #
Generate a function pointer callable from C code, from a C_WebViewContextMenuDismissedCallback
.
noWebViewContextMenuDismissedCallback :: Maybe WebViewContextMenuDismissedCallback Source #
A convenience synonym for
.Nothing
:: Maybe
WebViewContextMenuDismissedCallback
onWebViewContextMenuDismissed :: (IsWebView a, MonadIO m) => a -> WebViewContextMenuDismissedCallback -> m SignalHandlerId Source #
Connect a signal handler for the “context-menu-dismissed
” signal, to be run before the default handler.
When overloading is enabled, this is equivalent to
on
webView #contextMenuDismissed callback
wrap_WebViewContextMenuDismissedCallback :: WebViewContextMenuDismissedCallback -> C_WebViewContextMenuDismissedCallback Source #
create
type C_WebViewCreateCallback = Ptr () -> Ptr NavigationAction -> Ptr () -> IO (Ptr Widget) Source #
Type for the callback on the (unwrapped) C side.
type WebViewCreateCallback Source #
= NavigationAction |
|
-> IO Widget | Returns: a newly allocated |
Emitted when the creation of a new WebView
is requested.
If this signal is handled the signal handler should return the
newly created WebView
.
The NavigationAction
parameter contains information about the
navigation action that triggered this signal.
When using ProcessModelMultipleSecondaryProcesses
process model, the new WebView
should be related to
webView
to share the same web process, see webViewNewWithRelatedView
for more details.
The new WebView
should not be displayed to the user
until the WebView
::ready-to-show
signal is emitted.
afterWebViewCreate :: (IsWebView a, MonadIO m) => a -> WebViewCreateCallback -> m SignalHandlerId Source #
Connect a signal handler for the “create
” signal, to be run after the default handler.
When overloading is enabled, this is equivalent to
after
webView #create callback
genClosure_WebViewCreate :: MonadIO m => WebViewCreateCallback -> m (GClosure C_WebViewCreateCallback) Source #
Wrap the callback into a GClosure
.
mk_WebViewCreateCallback :: C_WebViewCreateCallback -> IO (FunPtr C_WebViewCreateCallback) Source #
Generate a function pointer callable from C code, from a C_WebViewCreateCallback
.
noWebViewCreateCallback :: Maybe WebViewCreateCallback Source #
A convenience synonym for
.Nothing
:: Maybe
WebViewCreateCallback
onWebViewCreate :: (IsWebView a, MonadIO m) => a -> WebViewCreateCallback -> m SignalHandlerId Source #
Connect a signal handler for the “create
” signal, to be run before the default handler.
When overloading is enabled, this is equivalent to
on
webView #create callback
wrap_WebViewCreateCallback :: WebViewCreateCallback -> C_WebViewCreateCallback Source #
Wrap a WebViewCreateCallback
into a C_WebViewCreateCallback
.
decidePolicy
type C_WebViewDecidePolicyCallback = Ptr () -> Ptr PolicyDecision -> CUInt -> Ptr () -> IO CInt Source #
Type for the callback on the (unwrapped) C side.
type WebViewDecidePolicyCallback Source #
= PolicyDecision |
|
-> PolicyDecisionType |
|
-> IO Bool | Returns: |
This signal is emitted when WebKit is requesting the client to decide a policy
decision, such as whether to navigate to a page, open a new window or whether or
not to download a resource. The NavigationPolicyDecision
passed in the
decision
argument is a generic type, but should be casted to a more
specific type when making the decision. For example:
<informalexample><programlisting>
static gboolean
decide_policy_cb (WebKitWebView *web_view,
WebKitPolicyDecision *decision,
WebKitPolicyDecisionType type)
{
switch (type) {
case WEBKIT_POLICY_DECISION_TYPE_NAVIGATION_ACTION: {
WebKitNavigationPolicyDecision *navigation_decision = WEBKIT_NAVIGATION_POLICY_DECISION (decision);
/<!-- -->* Make a policy decision here. *<!-- -->/
break;
}
case WEBKIT_POLICY_DECISION_TYPE_NEW_WINDOW_ACTION: {
WebKitNavigationPolicyDecision *navigation_decision = WEBKIT_NAVIGATION_POLICY_DECISION (decision);
/<!-- -->* Make a policy decision here. *<!-- -->/
break;
}
case WEBKIT_POLICY_DECISION_TYPE_RESPONSE:
WebKitResponsePolicyDecision *response = WEBKIT_RESPONSE_POLICY_DECISION (decision);
/<!-- -->* Make a policy decision here. *<!-- -->/
break;
default:
/<!-- -->* Making no decision results in policyDecisionUse
. *<!-- -->/
return FALSE;
}
return TRUE;
}
</programlisting></informalexample>
It is possible to make policy decision asynchronously, by simply calling objectRef
on the decision
argument and returning True
to block the default signal handler.
If the last reference is removed on a PolicyDecision
and no decision has been
made explicitly, policyDecisionUse
will be the default policy decision. The
default signal handler will simply call policyDecisionUse
. Only the first
policy decision chosen for a given PolicyDecision
will have any affect.
afterWebViewDecidePolicy :: (IsWebView a, MonadIO m) => a -> WebViewDecidePolicyCallback -> m SignalHandlerId Source #
Connect a signal handler for the “decide-policy
” signal, to be run after the default handler.
When overloading is enabled, this is equivalent to
after
webView #decidePolicy callback
genClosure_WebViewDecidePolicy :: MonadIO m => WebViewDecidePolicyCallback -> m (GClosure C_WebViewDecidePolicyCallback) Source #
Wrap the callback into a GClosure
.
mk_WebViewDecidePolicyCallback :: C_WebViewDecidePolicyCallback -> IO (FunPtr C_WebViewDecidePolicyCallback) Source #
Generate a function pointer callable from C code, from a C_WebViewDecidePolicyCallback
.
noWebViewDecidePolicyCallback :: Maybe WebViewDecidePolicyCallback Source #
A convenience synonym for
.Nothing
:: Maybe
WebViewDecidePolicyCallback
onWebViewDecidePolicy :: (IsWebView a, MonadIO m) => a -> WebViewDecidePolicyCallback -> m SignalHandlerId Source #
Connect a signal handler for the “decide-policy
” signal, to be run before the default handler.
When overloading is enabled, this is equivalent to
on
webView #decidePolicy callback
wrap_WebViewDecidePolicyCallback :: WebViewDecidePolicyCallback -> C_WebViewDecidePolicyCallback Source #
Wrap a WebViewDecidePolicyCallback
into a C_WebViewDecidePolicyCallback
.
enterFullscreen
type C_WebViewEnterFullscreenCallback = Ptr () -> Ptr () -> IO CInt Source #
Type for the callback on the (unwrapped) C side.
type WebViewEnterFullscreenCallback Source #
= IO Bool | Returns: |
Emitted when JavaScript code calls
<function>element.webkitRequestFullScreen</function>. If the
signal is not handled the WebView
will proceed to full screen
its top level window. This signal can be used by client code to
request permission to the user prior doing the full screen
transition and eventually prepare the top-level window
(e.g. hide some widgets that would otherwise be part of the
full screen window).
afterWebViewEnterFullscreen :: (IsWebView a, MonadIO m) => a -> WebViewEnterFullscreenCallback -> m SignalHandlerId Source #
Connect a signal handler for the “enter-fullscreen
” signal, to be run after the default handler.
When overloading is enabled, this is equivalent to
after
webView #enterFullscreen callback
genClosure_WebViewEnterFullscreen :: MonadIO m => WebViewEnterFullscreenCallback -> m (GClosure C_WebViewEnterFullscreenCallback) Source #
Wrap the callback into a GClosure
.
mk_WebViewEnterFullscreenCallback :: C_WebViewEnterFullscreenCallback -> IO (FunPtr C_WebViewEnterFullscreenCallback) Source #
Generate a function pointer callable from C code, from a C_WebViewEnterFullscreenCallback
.
noWebViewEnterFullscreenCallback :: Maybe WebViewEnterFullscreenCallback Source #
A convenience synonym for
.Nothing
:: Maybe
WebViewEnterFullscreenCallback
onWebViewEnterFullscreen :: (IsWebView a, MonadIO m) => a -> WebViewEnterFullscreenCallback -> m SignalHandlerId Source #
Connect a signal handler for the “enter-fullscreen
” signal, to be run before the default handler.
When overloading is enabled, this is equivalent to
on
webView #enterFullscreen callback
wrap_WebViewEnterFullscreenCallback :: WebViewEnterFullscreenCallback -> C_WebViewEnterFullscreenCallback Source #
Wrap a WebViewEnterFullscreenCallback
into a C_WebViewEnterFullscreenCallback
.
insecureContentDetected
type C_WebViewInsecureContentDetectedCallback = Ptr () -> CUInt -> Ptr () -> IO () Source #
Type for the callback on the (unwrapped) C side.
type WebViewInsecureContentDetectedCallback Source #
= InsecureContentEvent |
|
-> IO () |
This signal is emitted when insecure content has been detected in a page loaded through a secure connection. This typically means that a external resource from an unstrusted source has been run or displayed, resulting in a mix of HTTPS and non-HTTPS content.
You can check the event
parameter to know exactly which kind
of event has been detected (see InsecureContentEvent
).
afterWebViewInsecureContentDetected :: (IsWebView a, MonadIO m) => a -> WebViewInsecureContentDetectedCallback -> m SignalHandlerId Source #
Connect a signal handler for the “insecure-content-detected
” signal, to be run after the default handler.
When overloading is enabled, this is equivalent to
after
webView #insecureContentDetected callback
genClosure_WebViewInsecureContentDetected :: MonadIO m => WebViewInsecureContentDetectedCallback -> m (GClosure C_WebViewInsecureContentDetectedCallback) Source #
Wrap the callback into a GClosure
.
mk_WebViewInsecureContentDetectedCallback :: C_WebViewInsecureContentDetectedCallback -> IO (FunPtr C_WebViewInsecureContentDetectedCallback) Source #
Generate a function pointer callable from C code, from a C_WebViewInsecureContentDetectedCallback
.
noWebViewInsecureContentDetectedCallback :: Maybe WebViewInsecureContentDetectedCallback Source #
A convenience synonym for
.Nothing
:: Maybe
WebViewInsecureContentDetectedCallback
onWebViewInsecureContentDetected :: (IsWebView a, MonadIO m) => a -> WebViewInsecureContentDetectedCallback -> m SignalHandlerId Source #
Connect a signal handler for the “insecure-content-detected
” signal, to be run before the default handler.
When overloading is enabled, this is equivalent to
on
webView #insecureContentDetected callback
wrap_WebViewInsecureContentDetectedCallback :: WebViewInsecureContentDetectedCallback -> C_WebViewInsecureContentDetectedCallback Source #
leaveFullscreen
type C_WebViewLeaveFullscreenCallback = Ptr () -> Ptr () -> IO CInt Source #
Type for the callback on the (unwrapped) C side.
afterWebViewLeaveFullscreen :: (IsWebView a, MonadIO m) => a -> WebViewLeaveFullscreenCallback -> m SignalHandlerId Source #
Connect a signal handler for the “leave-fullscreen
” signal, to be run after the default handler.
When overloading is enabled, this is equivalent to
after
webView #leaveFullscreen callback
genClosure_WebViewLeaveFullscreen :: MonadIO m => WebViewLeaveFullscreenCallback -> m (GClosure C_WebViewLeaveFullscreenCallback) Source #
Wrap the callback into a GClosure
.
mk_WebViewLeaveFullscreenCallback :: C_WebViewLeaveFullscreenCallback -> IO (FunPtr C_WebViewLeaveFullscreenCallback) Source #
Generate a function pointer callable from C code, from a C_WebViewLeaveFullscreenCallback
.
noWebViewLeaveFullscreenCallback :: Maybe WebViewLeaveFullscreenCallback Source #
A convenience synonym for
.Nothing
:: Maybe
WebViewLeaveFullscreenCallback
onWebViewLeaveFullscreen :: (IsWebView a, MonadIO m) => a -> WebViewLeaveFullscreenCallback -> m SignalHandlerId Source #
Connect a signal handler for the “leave-fullscreen
” signal, to be run before the default handler.
When overloading is enabled, this is equivalent to
on
webView #leaveFullscreen callback
wrap_WebViewLeaveFullscreenCallback :: WebViewLeaveFullscreenCallback -> C_WebViewLeaveFullscreenCallback Source #
Wrap a WebViewLeaveFullscreenCallback
into a C_WebViewLeaveFullscreenCallback
.
loadChanged
type C_WebViewLoadChangedCallback = Ptr () -> CUInt -> Ptr () -> IO () Source #
Type for the callback on the (unwrapped) C side.
type WebViewLoadChangedCallback Source #
Emitted when a load operation in webView
changes.
The signal is always emitted with LoadEventStarted
when a
new load request is made and LoadEventFinished
when the load
finishes successfully or due to an error. When the ongoing load
operation fails WebView
::load-failed
signal is emitted
before WebView
::load-changed
is emitted with
LoadEventFinished
.
If a redirection is received from the server, this signal is emitted
with LoadEventRedirected
after the initial emission with
LoadEventStarted
and before LoadEventCommitted
.
When the page content starts arriving the signal is emitted with
LoadEventCommitted
event.
You can handle this signal and use a switch to track any ongoing load operation.
<informalexample><programlisting> static void web_view_load_changed (WebKitWebView *web_view, WebKitLoadEvent load_event, gpointer user_data) { switch (load_event) { case WEBKIT_LOAD_STARTED: /<!-- -->* New load, we have now a provisional URI *<!-- -->/ provisional_uri = webkit_web_view_get_uri (web_view); /<!-- -->* Here we could start a spinner or update the <!-- -->* location bar with the provisional URI *<!-- -->/ break; case WEBKIT_LOAD_REDIRECTED: redirected_uri = webkit_web_view_get_uri (web_view); break; case WEBKIT_LOAD_COMMITTED: /<!-- -->* The load is being performed. Current URI is <!-- -->* the final one and it won't change unless a new <!-- -->* load is requested or a navigation within the <!-- -->* same page is performed *<!-- -->/ uri = webkit_web_view_get_uri (web_view); break; case WEBKIT_LOAD_FINISHED: /<!-- -->* Load finished, we can now stop the spinner *<!-- -->/ break; } } </programlisting></informalexample>
afterWebViewLoadChanged :: (IsWebView a, MonadIO m) => a -> WebViewLoadChangedCallback -> m SignalHandlerId Source #
Connect a signal handler for the “load-changed
” signal, to be run after the default handler.
When overloading is enabled, this is equivalent to
after
webView #loadChanged callback
genClosure_WebViewLoadChanged :: MonadIO m => WebViewLoadChangedCallback -> m (GClosure C_WebViewLoadChangedCallback) Source #
Wrap the callback into a GClosure
.
mk_WebViewLoadChangedCallback :: C_WebViewLoadChangedCallback -> IO (FunPtr C_WebViewLoadChangedCallback) Source #
Generate a function pointer callable from C code, from a C_WebViewLoadChangedCallback
.
noWebViewLoadChangedCallback :: Maybe WebViewLoadChangedCallback Source #
A convenience synonym for
.Nothing
:: Maybe
WebViewLoadChangedCallback
onWebViewLoadChanged :: (IsWebView a, MonadIO m) => a -> WebViewLoadChangedCallback -> m SignalHandlerId Source #
Connect a signal handler for the “load-changed
” signal, to be run before the default handler.
When overloading is enabled, this is equivalent to
on
webView #loadChanged callback
wrap_WebViewLoadChangedCallback :: WebViewLoadChangedCallback -> C_WebViewLoadChangedCallback Source #
Wrap a WebViewLoadChangedCallback
into a C_WebViewLoadChangedCallback
.
loadFailed
type C_WebViewLoadFailedCallback = Ptr () -> CUInt -> CString -> Ptr GError -> Ptr () -> IO CInt Source #
Type for the callback on the (unwrapped) C side.
type WebViewLoadFailedCallback Source #
= LoadEvent |
|
-> Text |
|
-> GError |
|
-> IO Bool | Returns: |
Emitted when an error occurs during a load operation.
If the error happened when starting to load data for a page
loadEvent
will be LoadEventStarted
. If it happened while
loading a committed data source loadEvent
will be LoadEventCommitted
.
Since a load error causes the load operation to finish, the signal
WebKitWebView::load-changed will always be emitted with
LoadEventFinished
event right after this one.
By default, if the signal is not handled, a stock error page will be displayed. You need to handle the signal if you want to provide your own error page.
afterWebViewLoadFailed :: (IsWebView a, MonadIO m) => a -> WebViewLoadFailedCallback -> m SignalHandlerId Source #
Connect a signal handler for the “load-failed
” signal, to be run after the default handler.
When overloading is enabled, this is equivalent to
after
webView #loadFailed callback
genClosure_WebViewLoadFailed :: MonadIO m => WebViewLoadFailedCallback -> m (GClosure C_WebViewLoadFailedCallback) Source #
Wrap the callback into a GClosure
.
mk_WebViewLoadFailedCallback :: C_WebViewLoadFailedCallback -> IO (FunPtr C_WebViewLoadFailedCallback) Source #
Generate a function pointer callable from C code, from a C_WebViewLoadFailedCallback
.
noWebViewLoadFailedCallback :: Maybe WebViewLoadFailedCallback Source #
A convenience synonym for
.Nothing
:: Maybe
WebViewLoadFailedCallback
onWebViewLoadFailed :: (IsWebView a, MonadIO m) => a -> WebViewLoadFailedCallback -> m SignalHandlerId Source #
Connect a signal handler for the “load-failed
” signal, to be run before the default handler.
When overloading is enabled, this is equivalent to
on
webView #loadFailed callback
wrap_WebViewLoadFailedCallback :: WebViewLoadFailedCallback -> C_WebViewLoadFailedCallback Source #
Wrap a WebViewLoadFailedCallback
into a C_WebViewLoadFailedCallback
.
loadFailedWithTlsErrors
type C_WebViewLoadFailedWithTlsErrorsCallback = Ptr () -> CString -> Ptr TlsCertificate -> CUInt -> Ptr () -> IO CInt Source #
Type for the callback on the (unwrapped) C side.
type WebViewLoadFailedWithTlsErrorsCallback Source #
= Text |
|
-> TlsCertificate |
|
-> [TlsCertificateFlags] |
|
-> IO Bool | Returns: |
Emitted when a TLS error occurs during a load operation.
To allow an exception for this certificate
and the host of failingUri
use webContextAllowTlsCertificateForHost
.
To handle this signal asynchronously you should call objectRef
on certificate
and return True
.
If False
is returned, WebView
::load-failed
will be emitted. The load
will finish regardless of the returned value.
Since: 2.6
afterWebViewLoadFailedWithTlsErrors :: (IsWebView a, MonadIO m) => a -> WebViewLoadFailedWithTlsErrorsCallback -> m SignalHandlerId Source #
Connect a signal handler for the “load-failed-with-tls-errors
” signal, to be run after the default handler.
When overloading is enabled, this is equivalent to
after
webView #loadFailedWithTlsErrors callback
genClosure_WebViewLoadFailedWithTlsErrors :: MonadIO m => WebViewLoadFailedWithTlsErrorsCallback -> m (GClosure C_WebViewLoadFailedWithTlsErrorsCallback) Source #
Wrap the callback into a GClosure
.
mk_WebViewLoadFailedWithTlsErrorsCallback :: C_WebViewLoadFailedWithTlsErrorsCallback -> IO (FunPtr C_WebViewLoadFailedWithTlsErrorsCallback) Source #
Generate a function pointer callable from C code, from a C_WebViewLoadFailedWithTlsErrorsCallback
.
noWebViewLoadFailedWithTlsErrorsCallback :: Maybe WebViewLoadFailedWithTlsErrorsCallback Source #
A convenience synonym for
.Nothing
:: Maybe
WebViewLoadFailedWithTlsErrorsCallback
onWebViewLoadFailedWithTlsErrors :: (IsWebView a, MonadIO m) => a -> WebViewLoadFailedWithTlsErrorsCallback -> m SignalHandlerId Source #
Connect a signal handler for the “load-failed-with-tls-errors
” signal, to be run before the default handler.
When overloading is enabled, this is equivalent to
on
webView #loadFailedWithTlsErrors callback
wrap_WebViewLoadFailedWithTlsErrorsCallback :: WebViewLoadFailedWithTlsErrorsCallback -> C_WebViewLoadFailedWithTlsErrorsCallback Source #
mouseTargetChanged
type C_WebViewMouseTargetChangedCallback = Ptr () -> Ptr HitTestResult -> Word32 -> Ptr () -> IO () Source #
Type for the callback on the (unwrapped) C side.
type WebViewMouseTargetChangedCallback Source #
= HitTestResult |
|
-> Word32 |
|
-> IO () |
This signal is emitted when the mouse cursor moves over an
element such as a link, image or a media element. To determine
what type of element the mouse cursor is over, a Hit Test is performed
on the current mouse coordinates and the result is passed in the
hitTestResult
argument. The modifiers
argument is a bitmask of
ModifierType
flags indicating the state of modifier keys.
The signal is emitted again when the mouse is moved out of the
current element with a new hitTestResult
.
afterWebViewMouseTargetChanged :: (IsWebView a, MonadIO m) => a -> WebViewMouseTargetChangedCallback -> m SignalHandlerId Source #
Connect a signal handler for the “mouse-target-changed
” signal, to be run after the default handler.
When overloading is enabled, this is equivalent to
after
webView #mouseTargetChanged callback
genClosure_WebViewMouseTargetChanged :: MonadIO m => WebViewMouseTargetChangedCallback -> m (GClosure C_WebViewMouseTargetChangedCallback) Source #
Wrap the callback into a GClosure
.
mk_WebViewMouseTargetChangedCallback :: C_WebViewMouseTargetChangedCallback -> IO (FunPtr C_WebViewMouseTargetChangedCallback) Source #
Generate a function pointer callable from C code, from a C_WebViewMouseTargetChangedCallback
.
noWebViewMouseTargetChangedCallback :: Maybe WebViewMouseTargetChangedCallback Source #
A convenience synonym for
.Nothing
:: Maybe
WebViewMouseTargetChangedCallback
onWebViewMouseTargetChanged :: (IsWebView a, MonadIO m) => a -> WebViewMouseTargetChangedCallback -> m SignalHandlerId Source #
Connect a signal handler for the “mouse-target-changed
” signal, to be run before the default handler.
When overloading is enabled, this is equivalent to
on
webView #mouseTargetChanged callback
wrap_WebViewMouseTargetChangedCallback :: WebViewMouseTargetChangedCallback -> C_WebViewMouseTargetChangedCallback Source #
permissionRequest
type C_WebViewPermissionRequestCallback = Ptr () -> Ptr PermissionRequest -> Ptr () -> IO CInt Source #
Type for the callback on the (unwrapped) C side.
type WebViewPermissionRequestCallback Source #
= PermissionRequest |
|
-> IO Bool | Returns: |
This signal is emitted when WebKit is requesting the client to decide about a permission request, such as allowing the browser to switch to fullscreen mode, sharing its location or similar operations.
A possible way to use this signal could be through a dialog allowing the user decide what to do with the request:
<informalexample><programlisting> static gboolean permission_request_cb (WebKitWebView *web_view, WebKitPermissionRequest *request, GtkWindow *parent_window) { GtkWidget *dialog = gtk_message_dialog_new (parent_window, GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO, "Allow Permission Request?"); gtk_widget_show (dialog); gint result = gtk_dialog_run (GTK_DIALOG (dialog));
switch (result) { case GTK_RESPONSE_YES: webkit_permission_request_allow (request); break; default: webkit_permission_request_deny (request); break; } gtk_widget_destroy (dialog);
return TRUE; } </programlisting></informalexample>
It is possible to handle permission requests asynchronously, by
simply calling objectRef
on the request
argument and
returning True
to block the default signal handler. If the
last reference is removed on a PermissionRequest
and the
request has not been handled, permissionRequestDeny
will be the default action.
If the signal is not handled, the request
will be completed automatically
by the specific PermissionRequest
that could allow or deny it. Check the
documentation of classes implementing PermissionRequest
interface to know
their default action.
afterWebViewPermissionRequest :: (IsWebView a, MonadIO m) => a -> WebViewPermissionRequestCallback -> m SignalHandlerId Source #
Connect a signal handler for the “permission-request
” signal, to be run after the default handler.
When overloading is enabled, this is equivalent to
after
webView #permissionRequest callback
genClosure_WebViewPermissionRequest :: MonadIO m => WebViewPermissionRequestCallback -> m (GClosure C_WebViewPermissionRequestCallback) Source #
Wrap the callback into a GClosure
.
mk_WebViewPermissionRequestCallback :: C_WebViewPermissionRequestCallback -> IO (FunPtr C_WebViewPermissionRequestCallback) Source #
Generate a function pointer callable from C code, from a C_WebViewPermissionRequestCallback
.
noWebViewPermissionRequestCallback :: Maybe WebViewPermissionRequestCallback Source #
A convenience synonym for
.Nothing
:: Maybe
WebViewPermissionRequestCallback
onWebViewPermissionRequest :: (IsWebView a, MonadIO m) => a -> WebViewPermissionRequestCallback -> m SignalHandlerId Source #
Connect a signal handler for the “permission-request
” signal, to be run before the default handler.
When overloading is enabled, this is equivalent to
on
webView #permissionRequest callback
wrap_WebViewPermissionRequestCallback :: WebViewPermissionRequestCallback -> C_WebViewPermissionRequestCallback Source #
type C_WebViewPrintCallback = Ptr () -> Ptr PrintOperation -> Ptr () -> IO CInt Source #
Type for the callback on the (unwrapped) C side.
type WebViewPrintCallback Source #
= PrintOperation |
|
-> IO Bool | Returns: |
Emitted when printing is requested on webView
, usually by a JavaScript call,
before the print dialog is shown. This signal can be used to set the initial
print settings and page setup of printOperation
to be used as default values in
the print dialog. You can call printOperationSetPrintSettings
and
printOperationSetPageSetup
and then return False
to propagate the
event so that the print dialog is shown.
You can connect to this signal and return True
to cancel the print operation
or implement your own print dialog.
afterWebViewPrint :: (IsWebView a, MonadIO m) => a -> WebViewPrintCallback -> m SignalHandlerId Source #
Connect a signal handler for the “print
” signal, to be run after the default handler.
When overloading is enabled, this is equivalent to
after
webView #print callback
genClosure_WebViewPrint :: MonadIO m => WebViewPrintCallback -> m (GClosure C_WebViewPrintCallback) Source #
Wrap the callback into a GClosure
.
mk_WebViewPrintCallback :: C_WebViewPrintCallback -> IO (FunPtr C_WebViewPrintCallback) Source #
Generate a function pointer callable from C code, from a C_WebViewPrintCallback
.
noWebViewPrintCallback :: Maybe WebViewPrintCallback Source #
A convenience synonym for
.Nothing
:: Maybe
WebViewPrintCallback
onWebViewPrint :: (IsWebView a, MonadIO m) => a -> WebViewPrintCallback -> m SignalHandlerId Source #
Connect a signal handler for the “print
” signal, to be run before the default handler.
When overloading is enabled, this is equivalent to
on
webView #print callback
wrap_WebViewPrintCallback :: WebViewPrintCallback -> C_WebViewPrintCallback Source #
Wrap a WebViewPrintCallback
into a C_WebViewPrintCallback
.
readyToShow
type C_WebViewReadyToShowCallback = Ptr () -> Ptr () -> IO () Source #
Type for the callback on the (unwrapped) C side.
type WebViewReadyToShowCallback = IO () Source #
Emitted after WebView
::create
on the newly created WebView
when it should be displayed to the user. When this signal is emitted
all the information about how the window should look, including
size, position, whether the location, status and scrollbars
should be displayed, is already set on the WindowProperties
of webView
. See also webViewGetWindowProperties
.
afterWebViewReadyToShow :: (IsWebView a, MonadIO m) => a -> WebViewReadyToShowCallback -> m SignalHandlerId Source #
Connect a signal handler for the “ready-to-show
” signal, to be run after the default handler.
When overloading is enabled, this is equivalent to
after
webView #readyToShow callback
genClosure_WebViewReadyToShow :: MonadIO m => WebViewReadyToShowCallback -> m (GClosure C_WebViewReadyToShowCallback) Source #
Wrap the callback into a GClosure
.
mk_WebViewReadyToShowCallback :: C_WebViewReadyToShowCallback -> IO (FunPtr C_WebViewReadyToShowCallback) Source #
Generate a function pointer callable from C code, from a C_WebViewReadyToShowCallback
.
noWebViewReadyToShowCallback :: Maybe WebViewReadyToShowCallback Source #
A convenience synonym for
.Nothing
:: Maybe
WebViewReadyToShowCallback
onWebViewReadyToShow :: (IsWebView a, MonadIO m) => a -> WebViewReadyToShowCallback -> m SignalHandlerId Source #
Connect a signal handler for the “ready-to-show
” signal, to be run before the default handler.
When overloading is enabled, this is equivalent to
on
webView #readyToShow callback
wrap_WebViewReadyToShowCallback :: WebViewReadyToShowCallback -> C_WebViewReadyToShowCallback Source #
Wrap a WebViewReadyToShowCallback
into a C_WebViewReadyToShowCallback
.
resourceLoadStarted
type C_WebViewResourceLoadStartedCallback = Ptr () -> Ptr WebResource -> Ptr URIRequest -> Ptr () -> IO () Source #
Type for the callback on the (unwrapped) C side.
type WebViewResourceLoadStartedCallback Source #
= WebResource |
|
-> URIRequest |
|
-> IO () |
Emitted when a new resource is going to be loaded. The request
parameter
contains the URIRequest
that will be sent to the server.
You can monitor the load operation by connecting to the different signals
of resource
.
afterWebViewResourceLoadStarted :: (IsWebView a, MonadIO m) => a -> WebViewResourceLoadStartedCallback -> m SignalHandlerId Source #
Connect a signal handler for the “resource-load-started
” signal, to be run after the default handler.
When overloading is enabled, this is equivalent to
after
webView #resourceLoadStarted callback
genClosure_WebViewResourceLoadStarted :: MonadIO m => WebViewResourceLoadStartedCallback -> m (GClosure C_WebViewResourceLoadStartedCallback) Source #
Wrap the callback into a GClosure
.
mk_WebViewResourceLoadStartedCallback :: C_WebViewResourceLoadStartedCallback -> IO (FunPtr C_WebViewResourceLoadStartedCallback) Source #
Generate a function pointer callable from C code, from a C_WebViewResourceLoadStartedCallback
.
noWebViewResourceLoadStartedCallback :: Maybe WebViewResourceLoadStartedCallback Source #
A convenience synonym for
.Nothing
:: Maybe
WebViewResourceLoadStartedCallback
onWebViewResourceLoadStarted :: (IsWebView a, MonadIO m) => a -> WebViewResourceLoadStartedCallback -> m SignalHandlerId Source #
Connect a signal handler for the “resource-load-started
” signal, to be run before the default handler.
When overloading is enabled, this is equivalent to
on
webView #resourceLoadStarted callback
wrap_WebViewResourceLoadStartedCallback :: WebViewResourceLoadStartedCallback -> C_WebViewResourceLoadStartedCallback Source #
runAsModal
type C_WebViewRunAsModalCallback = Ptr () -> Ptr () -> IO () Source #
Type for the callback on the (unwrapped) C side.
type WebViewRunAsModalCallback = IO () Source #
Emitted after WebView
::ready-to-show
on the newly
created WebView
when JavaScript code calls
<function>window.showModalDialog</function>. The purpose of
this signal is to allow the client application to prepare the
new view to behave as modal. Once the signal is emitted a new
main loop will be run to block user interaction in the parent
WebView
until the new dialog is closed.
afterWebViewRunAsModal :: (IsWebView a, MonadIO m) => a -> WebViewRunAsModalCallback -> m SignalHandlerId Source #
Connect a signal handler for the “run-as-modal
” signal, to be run after the default handler.
When overloading is enabled, this is equivalent to
after
webView #runAsModal callback
genClosure_WebViewRunAsModal :: MonadIO m => WebViewRunAsModalCallback -> m (GClosure C_WebViewRunAsModalCallback) Source #
Wrap the callback into a GClosure
.
mk_WebViewRunAsModalCallback :: C_WebViewRunAsModalCallback -> IO (FunPtr C_WebViewRunAsModalCallback) Source #
Generate a function pointer callable from C code, from a C_WebViewRunAsModalCallback
.
noWebViewRunAsModalCallback :: Maybe WebViewRunAsModalCallback Source #
A convenience synonym for
.Nothing
:: Maybe
WebViewRunAsModalCallback
onWebViewRunAsModal :: (IsWebView a, MonadIO m) => a -> WebViewRunAsModalCallback -> m SignalHandlerId Source #
Connect a signal handler for the “run-as-modal
” signal, to be run before the default handler.
When overloading is enabled, this is equivalent to
on
webView #runAsModal callback
wrap_WebViewRunAsModalCallback :: WebViewRunAsModalCallback -> C_WebViewRunAsModalCallback Source #
Wrap a WebViewRunAsModalCallback
into a C_WebViewRunAsModalCallback
.
runColorChooser
type C_WebViewRunColorChooserCallback = Ptr () -> Ptr ColorChooserRequest -> Ptr () -> IO CInt Source #
Type for the callback on the (unwrapped) C side.
type WebViewRunColorChooserCallback Source #
= ColorChooserRequest |
|
-> IO Bool | Returns: |
This signal is emitted when the user interacts with a <input
type='color' /> HTML element, requesting from WebKit to show
a dialog to select a color. To let the application know the details of
the color chooser, as well as to allow the client application to either
cancel the request or perform an actual color selection, the signal will
pass an instance of the ColorChooserRequest
in the request
argument.
It is possible to handle this request asynchronously by increasing the reference count of the request.
The default signal handler will asynchronously run a regular
ColorChooser
for the user to interact with.
Since: 2.8
afterWebViewRunColorChooser :: (IsWebView a, MonadIO m) => a -> WebViewRunColorChooserCallback -> m SignalHandlerId Source #
Connect a signal handler for the “run-color-chooser
” signal, to be run after the default handler.
When overloading is enabled, this is equivalent to
after
webView #runColorChooser callback
genClosure_WebViewRunColorChooser :: MonadIO m => WebViewRunColorChooserCallback -> m (GClosure C_WebViewRunColorChooserCallback) Source #
Wrap the callback into a GClosure
.
mk_WebViewRunColorChooserCallback :: C_WebViewRunColorChooserCallback -> IO (FunPtr C_WebViewRunColorChooserCallback) Source #
Generate a function pointer callable from C code, from a C_WebViewRunColorChooserCallback
.
noWebViewRunColorChooserCallback :: Maybe WebViewRunColorChooserCallback Source #
A convenience synonym for
.Nothing
:: Maybe
WebViewRunColorChooserCallback
onWebViewRunColorChooser :: (IsWebView a, MonadIO m) => a -> WebViewRunColorChooserCallback -> m SignalHandlerId Source #
Connect a signal handler for the “run-color-chooser
” signal, to be run before the default handler.
When overloading is enabled, this is equivalent to
on
webView #runColorChooser callback
wrap_WebViewRunColorChooserCallback :: WebViewRunColorChooserCallback -> C_WebViewRunColorChooserCallback Source #
Wrap a WebViewRunColorChooserCallback
into a C_WebViewRunColorChooserCallback
.
runFileChooser
type C_WebViewRunFileChooserCallback = Ptr () -> Ptr FileChooserRequest -> Ptr () -> IO CInt Source #
Type for the callback on the (unwrapped) C side.
type WebViewRunFileChooserCallback Source #
= FileChooserRequest |
|
-> IO Bool | Returns: |
This signal is emitted when the user interacts with a <input
type='file' /> HTML element, requesting from WebKit to show
a dialog to select one or more files to be uploaded. To let the
application know the details of the file chooser, as well as to
allow the client application to either cancel the request or
perform an actual selection of files, the signal will pass an
instance of the FileChooserRequest
in the request
argument.
The default signal handler will asynchronously run a regular
FileChooserDialog
for the user to interact with.
afterWebViewRunFileChooser :: (IsWebView a, MonadIO m) => a -> WebViewRunFileChooserCallback -> m SignalHandlerId Source #
Connect a signal handler for the “run-file-chooser
” signal, to be run after the default handler.
When overloading is enabled, this is equivalent to
after
webView #runFileChooser callback
genClosure_WebViewRunFileChooser :: MonadIO m => WebViewRunFileChooserCallback -> m (GClosure C_WebViewRunFileChooserCallback) Source #
Wrap the callback into a GClosure
.
mk_WebViewRunFileChooserCallback :: C_WebViewRunFileChooserCallback -> IO (FunPtr C_WebViewRunFileChooserCallback) Source #
Generate a function pointer callable from C code, from a C_WebViewRunFileChooserCallback
.
noWebViewRunFileChooserCallback :: Maybe WebViewRunFileChooserCallback Source #
A convenience synonym for
.Nothing
:: Maybe
WebViewRunFileChooserCallback
onWebViewRunFileChooser :: (IsWebView a, MonadIO m) => a -> WebViewRunFileChooserCallback -> m SignalHandlerId Source #
Connect a signal handler for the “run-file-chooser
” signal, to be run before the default handler.
When overloading is enabled, this is equivalent to
on
webView #runFileChooser callback
wrap_WebViewRunFileChooserCallback :: WebViewRunFileChooserCallback -> C_WebViewRunFileChooserCallback Source #
Wrap a WebViewRunFileChooserCallback
into a C_WebViewRunFileChooserCallback
.
scriptDialog
type C_WebViewScriptDialogCallback = Ptr () -> Ptr ScriptDialog -> Ptr () -> IO CInt Source #
Type for the callback on the (unwrapped) C side.
type WebViewScriptDialogCallback Source #
= ScriptDialog |
|
-> IO Bool | Returns: |
Emitted when JavaScript code calls <function>window.alert</function>,
<function>window.confirm</function> or <function>window.prompt</function>,
or when <function>onbeforeunload</function> event is fired.
The dialog
parameter should be used to build the dialog.
If the signal is not handled a different dialog will be built and shown depending
on the dialog type:
<itemizedlist>
<listitem><para>
ScriptDialogTypeAlert
: message dialog with a single Close button.
</para></listitem>
<listitem><para>
ScriptDialogTypeConfirm
: message dialog with OK and Cancel buttons.
</para></listitem>
<listitem><para>
ScriptDialogTypePrompt
: message dialog with OK and Cancel buttons and
a text entry with the default text.
</para></listitem>
<listitem><para>
ScriptDialogTypeBeforeUnloadConfirm
: message dialog with Stay and Leave buttons.
</para></listitem>
</itemizedlist>
It is possible to handle the script dialog request asynchronously, by simply
caling scriptDialogRef
on the dialog
argument and calling
scriptDialogClose
when done.
If the last reference is removed on a ScriptDialog
and the dialog has not been
closed, scriptDialogClose
will be called.
afterWebViewScriptDialog :: (IsWebView a, MonadIO m) => a -> WebViewScriptDialogCallback -> m SignalHandlerId Source #
Connect a signal handler for the “script-dialog
” signal, to be run after the default handler.
When overloading is enabled, this is equivalent to
after
webView #scriptDialog callback
genClosure_WebViewScriptDialog :: MonadIO m => WebViewScriptDialogCallback -> m (GClosure C_WebViewScriptDialogCallback) Source #
Wrap the callback into a GClosure
.
mk_WebViewScriptDialogCallback :: C_WebViewScriptDialogCallback -> IO (FunPtr C_WebViewScriptDialogCallback) Source #
Generate a function pointer callable from C code, from a C_WebViewScriptDialogCallback
.
noWebViewScriptDialogCallback :: Maybe WebViewScriptDialogCallback Source #
A convenience synonym for
.Nothing
:: Maybe
WebViewScriptDialogCallback
onWebViewScriptDialog :: (IsWebView a, MonadIO m) => a -> WebViewScriptDialogCallback -> m SignalHandlerId Source #
Connect a signal handler for the “script-dialog
” signal, to be run before the default handler.
When overloading is enabled, this is equivalent to
on
webView #scriptDialog callback
wrap_WebViewScriptDialogCallback :: WebViewScriptDialogCallback -> C_WebViewScriptDialogCallback Source #
Wrap a WebViewScriptDialogCallback
into a C_WebViewScriptDialogCallback
.
showNotification
type C_WebViewShowNotificationCallback = Ptr () -> Ptr Notification -> Ptr () -> IO CInt Source #
Type for the callback on the (unwrapped) C side.
type WebViewShowNotificationCallback Source #
= Notification |
|
-> IO Bool | Returns: |
This signal is emitted when a notification should be presented to the
user. The notification
is kept alive until either: 1) the web page cancels it
or 2) a navigation happens.
The default handler will emit a notification using libnotify, if built with support for it.
Since: 2.8
afterWebViewShowNotification :: (IsWebView a, MonadIO m) => a -> WebViewShowNotificationCallback -> m SignalHandlerId Source #
Connect a signal handler for the “show-notification
” signal, to be run after the default handler.
When overloading is enabled, this is equivalent to
after
webView #showNotification callback
genClosure_WebViewShowNotification :: MonadIO m => WebViewShowNotificationCallback -> m (GClosure C_WebViewShowNotificationCallback) Source #
Wrap the callback into a GClosure
.
mk_WebViewShowNotificationCallback :: C_WebViewShowNotificationCallback -> IO (FunPtr C_WebViewShowNotificationCallback) Source #
Generate a function pointer callable from C code, from a C_WebViewShowNotificationCallback
.
noWebViewShowNotificationCallback :: Maybe WebViewShowNotificationCallback Source #
A convenience synonym for
.Nothing
:: Maybe
WebViewShowNotificationCallback
onWebViewShowNotification :: (IsWebView a, MonadIO m) => a -> WebViewShowNotificationCallback -> m SignalHandlerId Source #
Connect a signal handler for the “show-notification
” signal, to be run before the default handler.
When overloading is enabled, this is equivalent to
on
webView #showNotification callback
wrap_WebViewShowNotificationCallback :: WebViewShowNotificationCallback -> C_WebViewShowNotificationCallback Source #
Wrap a WebViewShowNotificationCallback
into a C_WebViewShowNotificationCallback
.
showOptionMenu
type C_WebViewShowOptionMenuCallback = Ptr () -> Ptr OptionMenu -> Ptr Event -> Ptr Rectangle -> Ptr () -> IO CInt Source #
Type for the callback on the (unwrapped) C side.
type WebViewShowOptionMenuCallback Source #
= OptionMenu |
|
-> Event | |
-> Rectangle |
|
-> IO Bool | Returns: |
This signal is emitted when a select element in webView
needs to display a
dropdown menu. This signal can be used to show a custom menu, using menu
to get
the details of all items that should be displayed. The area of the element in the
WebView
is given as rectangle
parameter, it can be used to position the
menu. If this was triggered by a user interaction, like a mouse click,
event
parameter provides the Event
.
To handle this signal asynchronously you should keep a ref of the menu
.
The default signal handler will pop up a Menu
.
Since: 2.18
afterWebViewShowOptionMenu :: (IsWebView a, MonadIO m) => a -> WebViewShowOptionMenuCallback -> m SignalHandlerId Source #
Connect a signal handler for the “show-option-menu
” signal, to be run after the default handler.
When overloading is enabled, this is equivalent to
after
webView #showOptionMenu callback
genClosure_WebViewShowOptionMenu :: MonadIO m => WebViewShowOptionMenuCallback -> m (GClosure C_WebViewShowOptionMenuCallback) Source #
Wrap the callback into a GClosure
.
mk_WebViewShowOptionMenuCallback :: C_WebViewShowOptionMenuCallback -> IO (FunPtr C_WebViewShowOptionMenuCallback) Source #
Generate a function pointer callable from C code, from a C_WebViewShowOptionMenuCallback
.
noWebViewShowOptionMenuCallback :: Maybe WebViewShowOptionMenuCallback Source #
A convenience synonym for
.Nothing
:: Maybe
WebViewShowOptionMenuCallback
onWebViewShowOptionMenu :: (IsWebView a, MonadIO m) => a -> WebViewShowOptionMenuCallback -> m SignalHandlerId Source #
Connect a signal handler for the “show-option-menu
” signal, to be run before the default handler.
When overloading is enabled, this is equivalent to
on
webView #showOptionMenu callback
wrap_WebViewShowOptionMenuCallback :: WebViewShowOptionMenuCallback -> C_WebViewShowOptionMenuCallback Source #
Wrap a WebViewShowOptionMenuCallback
into a C_WebViewShowOptionMenuCallback
.
submitForm
type C_WebViewSubmitFormCallback = Ptr () -> Ptr FormSubmissionRequest -> Ptr () -> IO () Source #
Type for the callback on the (unwrapped) C side.
type WebViewSubmitFormCallback Source #
= FormSubmissionRequest |
|
-> IO () |
This signal is emitted when a form is about to be submitted. The request
argument passed contains information about the text fields of the form. This
is typically used to store login information that can be used later to
pre-fill the form.
The form will not be submitted until formSubmissionRequestSubmit
is called.
It is possible to handle the form submission request asynchronously, by
simply calling objectRef
on the request
argument and calling
formSubmissionRequestSubmit
when done to continue with the form submission.
If the last reference is removed on a FormSubmissionRequest
and the
form has not been submitted, formSubmissionRequestSubmit
will be called.
afterWebViewSubmitForm :: (IsWebView a, MonadIO m) => a -> WebViewSubmitFormCallback -> m SignalHandlerId Source #
Connect a signal handler for the “submit-form
” signal, to be run after the default handler.
When overloading is enabled, this is equivalent to
after
webView #submitForm callback
genClosure_WebViewSubmitForm :: MonadIO m => WebViewSubmitFormCallback -> m (GClosure C_WebViewSubmitFormCallback) Source #
Wrap the callback into a GClosure
.
mk_WebViewSubmitFormCallback :: C_WebViewSubmitFormCallback -> IO (FunPtr C_WebViewSubmitFormCallback) Source #
Generate a function pointer callable from C code, from a C_WebViewSubmitFormCallback
.
noWebViewSubmitFormCallback :: Maybe WebViewSubmitFormCallback Source #
A convenience synonym for
.Nothing
:: Maybe
WebViewSubmitFormCallback
onWebViewSubmitForm :: (IsWebView a, MonadIO m) => a -> WebViewSubmitFormCallback -> m SignalHandlerId Source #
Connect a signal handler for the “submit-form
” signal, to be run before the default handler.
When overloading is enabled, this is equivalent to
on
webView #submitForm callback
wrap_WebViewSubmitFormCallback :: WebViewSubmitFormCallback -> C_WebViewSubmitFormCallback Source #
Wrap a WebViewSubmitFormCallback
into a C_WebViewSubmitFormCallback
.
webProcessCrashed
type C_WebViewWebProcessCrashedCallback = Ptr () -> Ptr () -> IO CInt Source #
Type for the callback on the (unwrapped) C side.
type WebViewWebProcessCrashedCallback Source #
= IO Bool | Returns: |
Deprecated: (Since version 2.20)Use WebKitWebView::web-process-terminated instead.
This signal is emitted when the web process crashes.
afterWebViewWebProcessCrashed :: (IsWebView a, MonadIO m) => a -> WebViewWebProcessCrashedCallback -> m SignalHandlerId Source #
Connect a signal handler for the “web-process-crashed
” signal, to be run after the default handler.
When overloading is enabled, this is equivalent to
after
webView #webProcessCrashed callback
genClosure_WebViewWebProcessCrashed :: MonadIO m => WebViewWebProcessCrashedCallback -> m (GClosure C_WebViewWebProcessCrashedCallback) Source #
Wrap the callback into a GClosure
.
mk_WebViewWebProcessCrashedCallback :: C_WebViewWebProcessCrashedCallback -> IO (FunPtr C_WebViewWebProcessCrashedCallback) Source #
Generate a function pointer callable from C code, from a C_WebViewWebProcessCrashedCallback
.
noWebViewWebProcessCrashedCallback :: Maybe WebViewWebProcessCrashedCallback Source #
A convenience synonym for
.Nothing
:: Maybe
WebViewWebProcessCrashedCallback
onWebViewWebProcessCrashed :: (IsWebView a, MonadIO m) => a -> WebViewWebProcessCrashedCallback -> m SignalHandlerId Source #
Connect a signal handler for the “web-process-crashed
” signal, to be run before the default handler.
When overloading is enabled, this is equivalent to
on
webView #webProcessCrashed callback
wrap_WebViewWebProcessCrashedCallback :: WebViewWebProcessCrashedCallback -> C_WebViewWebProcessCrashedCallback Source #
webProcessTerminated
type C_WebViewWebProcessTerminatedCallback = Ptr () -> CUInt -> Ptr () -> IO () Source #
Type for the callback on the (unwrapped) C side.
type WebViewWebProcessTerminatedCallback Source #
= WebProcessTerminationReason |
|
-> IO () |
This signal is emitted when the web process terminates abnormally due
to reason
.
Since: 2.20
afterWebViewWebProcessTerminated :: (IsWebView a, MonadIO m) => a -> WebViewWebProcessTerminatedCallback -> m SignalHandlerId Source #
Connect a signal handler for the “web-process-terminated
” signal, to be run after the default handler.
When overloading is enabled, this is equivalent to
after
webView #webProcessTerminated callback
genClosure_WebViewWebProcessTerminated :: MonadIO m => WebViewWebProcessTerminatedCallback -> m (GClosure C_WebViewWebProcessTerminatedCallback) Source #
Wrap the callback into a GClosure
.
mk_WebViewWebProcessTerminatedCallback :: C_WebViewWebProcessTerminatedCallback -> IO (FunPtr C_WebViewWebProcessTerminatedCallback) Source #
Generate a function pointer callable from C code, from a C_WebViewWebProcessTerminatedCallback
.
noWebViewWebProcessTerminatedCallback :: Maybe WebViewWebProcessTerminatedCallback Source #
A convenience synonym for
.Nothing
:: Maybe
WebViewWebProcessTerminatedCallback
onWebViewWebProcessTerminated :: (IsWebView a, MonadIO m) => a -> WebViewWebProcessTerminatedCallback -> m SignalHandlerId Source #
Connect a signal handler for the “web-process-terminated
” signal, to be run before the default handler.
When overloading is enabled, this is equivalent to
on
webView #webProcessTerminated callback