GI.WebKit2WebExtension.Objects.WebPage

No description available in the introspection data.

Exported types

newtype WebPage

Memory-managed wrapper type.

Constructors

WebPage (ManagedPtr WebPage)

Instances

Eq WebPage

Defined in GI.WebKit2WebExtension.Objects.WebPage

Methods

(==) :: WebPage -> WebPage -> Bool

(/=) :: WebPage -> WebPage -> Bool

GObject WebPage

Defined in GI.WebKit2WebExtension.Objects.WebPage

ManagedPtrNewtype WebPage

Defined in GI.WebKit2WebExtension.Objects.WebPage

Methods

toManagedPtr :: WebPage -> ManagedPtr WebPage

TypedObject WebPage

Defined in GI.WebKit2WebExtension.Objects.WebPage

Methods

glibType :: IO GType

IsGValue WebPage

Convert WebPage to and from GValue with toGValue and fromGValue.

Defined in GI.WebKit2WebExtension.Objects.WebPage

Methods

toGValue :: WebPage -> IO GValue

fromGValue :: GValue -> IO WebPage

HasParentTypes WebPage

Defined in GI.WebKit2WebExtension.Objects.WebPage

type ParentTypes WebPage

Defined in GI.WebKit2WebExtension.Objects.WebPage

type ParentTypes WebPage = '[Object]

class (GObject o, IsDescendantOf WebPage o) => IsWebPage o

Type class for types which can be safely cast to WebPage, for instance with toWebPage.

Instances

(GObject o, IsDescendantOf WebPage o) => IsWebPage o

Defined in GI.WebKit2WebExtension.Objects.WebPage

toWebPage :: (MonadIO m, IsWebPage o) => o -> m WebPage

Cast to WebPage, for types for which this is known to be safe. For general casts, use castTo.

Methods

Overloaded methods

getDomDocument

webPageGetDomDocument

Arguments

:: (HasCallStack, MonadIO m, IsWebPage a)

=> a

webPage: a WebPage

-> m (Maybe DOMDocument)

Returns: the DOMDocument currently loaded, or Nothing if no document is currently loaded.

Get the DOMDocument currently loaded in webPage

getEditor

webPageGetEditor

Arguments

:: (HasCallStack, MonadIO m, IsWebPage a)

=> a

webPage: a WebPage

-> m WebEditor

Returns: the WebEditor

Gets the WebEditor of a WebPage.

Since: 2.10

getId

webPageGetId

Arguments

:: (HasCallStack, MonadIO m, IsWebPage a)

=> a

webPage: a WebPage

-> m Word64

Returns: the identifier of webPage

Get the identifier of the WebPage

getMainFrame

webPageGetMainFrame

Arguments

:: (HasCallStack, MonadIO m, IsWebPage a)

=> a

webPage: a WebPage

-> m Frame

Returns: the Frame that is the main frame of webPage

Returns the main frame of a WebPage.

Since: 2.2

getUri

webPageGetUri

Arguments

:: (HasCallStack, MonadIO m, IsWebPage a)

=> a

webPage: a WebPage

-> m (Maybe Text)

Returns: the current active URI of webView or Nothing if nothing has been loaded yet.

Returns the current active URI of webPage.

You can monitor the active URI by connecting to the notify[uri](#g:signal:uri) signal of webPage.

sendMessageToView

webPageSendMessageToView

Arguments

:: (HasCallStack, MonadIO m, IsWebPage a, IsUserMessage b, IsCancellable c)

=> a

webPage: a WebPage

-> b

message: a UserMessage

-> Maybe c

cancellable: a Cancellable or Nothing to ignore

-> Maybe AsyncReadyCallback

callback: (nullable): A AsyncReadyCallback to call when the request is satisfied or Nothing

-> m ()

Send message to the WebKitWebView corresponding to webPage. If message is floating, it's consumed.

If you don't expect any reply, or you simply want to ignore it, you can pass Nothing as callback. When the operation is finished, callback will be called. You can then call webPageSendMessageToViewFinish to get the message reply.

Since: 2.28

sendMessageToViewFinish

webPageSendMessageToViewFinish

Arguments

:: (HasCallStack, MonadIO m, IsWebPage a, IsAsyncResult b)

=> a

webPage: a WebPage

-> b

result: a AsyncResult

-> m UserMessage

Returns: a UserMessage with the reply or Nothing in case of error. (Can throw GError)

Finish an asynchronous operation started with webPageSendMessageToView.

Since: 2.28

Properties

uri

The current active URI of the WebPage.

getWebPageUri :: (MonadIO m, IsWebPage o) => o -> m (Maybe Text)

Get the value of the “uri” property. When overloading is enabled, this is equivalent to

get webPage #uri

Signals

consoleMessageSent

type C_WebPageConsoleMessageSentCallback = Ptr () -> Ptr ConsoleMessage -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type WebPageConsoleMessageSentCallback

Arguments

 = ConsoleMessage

consoleMessage: the ConsoleMessage

-> IO ()

Emitted when a message is sent to the console. This can be a message produced by the use of JavaScript console API, a JavaScript exception, a security error or other errors, warnings, debug or log messages. The consoleMessage contains information of the message.

Since: 2.12

afterWebPageConsoleMessageSent :: (IsWebPage a, MonadIO m) => a -> WebPageConsoleMessageSentCallback -> m SignalHandlerId

Connect a signal handler for the consoleMessageSent signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after webPage #consoleMessageSent callback

genClosure_WebPageConsoleMessageSent :: MonadIO m => WebPageConsoleMessageSentCallback -> m (GClosure C_WebPageConsoleMessageSentCallback)

Wrap the callback into a GClosure.

mk_WebPageConsoleMessageSentCallback :: C_WebPageConsoleMessageSentCallback -> IO (FunPtr C_WebPageConsoleMessageSentCallback)

Generate a function pointer callable from C code, from a C_WebPageConsoleMessageSentCallback.

noWebPageConsoleMessageSentCallback :: Maybe WebPageConsoleMessageSentCallback

A convenience synonym for Nothing :: Maybe WebPageConsoleMessageSentCallback.

onWebPageConsoleMessageSent :: (IsWebPage a, MonadIO m) => a -> WebPageConsoleMessageSentCallback -> m SignalHandlerId

Connect a signal handler for the consoleMessageSent signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on webPage #consoleMessageSent callback

wrap_WebPageConsoleMessageSentCallback :: WebPageConsoleMessageSentCallback -> C_WebPageConsoleMessageSentCallback

Wrap a WebPageConsoleMessageSentCallback into a C_WebPageConsoleMessageSentCallback.

contextMenu

type C_WebPageContextMenuCallback = Ptr () -> Ptr ContextMenu -> Ptr WebHitTestResult -> Ptr () -> IO CInt

Type for the callback on the (unwrapped) C side.

type WebPageContextMenuCallback

Arguments

 = ContextMenu

contextMenu: the proposed WebKitContextMenu

-> WebHitTestResult

hitTestResult: a WebHitTestResult

-> IO Bool

Returns: True if the proposed contextMenu has been modified, or False otherwise.

Emitted before a context menu is displayed in the UI Process to give the application a chance to customize the proposed menu, build its own context menu or pass user data to the UI Process. This signal is useful when the information available in the UI Process is not enough to build or customize the context menu, for example, to add menu entries depending on the DOMNode at the coordinates of the hitTestResult. Otherwise, it's recommended to use WebKitWebView::context-menu signal instead.

Since: 2.8

afterWebPageContextMenu :: (IsWebPage a, MonadIO m) => a -> WebPageContextMenuCallback -> m SignalHandlerId

Connect a signal handler for the contextMenu signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after webPage #contextMenu callback

genClosure_WebPageContextMenu :: MonadIO m => WebPageContextMenuCallback -> m (GClosure C_WebPageContextMenuCallback)

Wrap the callback into a GClosure.

mk_WebPageContextMenuCallback :: C_WebPageContextMenuCallback -> IO (FunPtr C_WebPageContextMenuCallback)

Generate a function pointer callable from C code, from a C_WebPageContextMenuCallback.

noWebPageContextMenuCallback :: Maybe WebPageContextMenuCallback

A convenience synonym for Nothing :: Maybe WebPageContextMenuCallback.

onWebPageContextMenu :: (IsWebPage a, MonadIO m) => a -> WebPageContextMenuCallback -> m SignalHandlerId

Connect a signal handler for the contextMenu signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on webPage #contextMenu callback

wrap_WebPageContextMenuCallback :: WebPageContextMenuCallback -> C_WebPageContextMenuCallback

Wrap a WebPageContextMenuCallback into a C_WebPageContextMenuCallback.

documentLoaded

type C_WebPageDocumentLoadedCallback = Ptr () -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type WebPageDocumentLoadedCallback = IO ()

This signal is emitted when the DOM document of a WebPage has been loaded.

You can wait for this signal to get the DOM document with webPageGetDomDocument.

afterWebPageDocumentLoaded :: (IsWebPage a, MonadIO m) => a -> WebPageDocumentLoadedCallback -> m SignalHandlerId

Connect a signal handler for the documentLoaded signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after webPage #documentLoaded callback

genClosure_WebPageDocumentLoaded :: MonadIO m => WebPageDocumentLoadedCallback -> m (GClosure C_WebPageDocumentLoadedCallback)

Wrap the callback into a GClosure.

mk_WebPageDocumentLoadedCallback :: C_WebPageDocumentLoadedCallback -> IO (FunPtr C_WebPageDocumentLoadedCallback)

Generate a function pointer callable from C code, from a C_WebPageDocumentLoadedCallback.

noWebPageDocumentLoadedCallback :: Maybe WebPageDocumentLoadedCallback

A convenience synonym for Nothing :: Maybe WebPageDocumentLoadedCallback.

onWebPageDocumentLoaded :: (IsWebPage a, MonadIO m) => a -> WebPageDocumentLoadedCallback -> m SignalHandlerId

Connect a signal handler for the documentLoaded signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on webPage #documentLoaded callback

wrap_WebPageDocumentLoadedCallback :: WebPageDocumentLoadedCallback -> C_WebPageDocumentLoadedCallback

Wrap a WebPageDocumentLoadedCallback into a C_WebPageDocumentLoadedCallback.

formControlsAssociated

type C_WebPageFormControlsAssociatedCallback = Ptr () -> Ptr (GPtrArray (Ptr DOMElement)) -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type WebPageFormControlsAssociatedCallback

Arguments

 = [DOMElement]

elements: a PtrArray of DOMElement with the list of forms in the page

-> IO ()

Deprecated: (Since version 2.26), use formControlsAssociatedForFrame instead.

Emitted after form elements (or form associated elements) are associated to a particular web page. This is useful to implement form auto filling for web pages where form fields are added dynamically. This signal might be emitted multiple times for the same web page.

Note that this signal could be also emitted when form controls are moved between forms. In that case, the elements array carries the list of those elements which have moved.

Clients should take a reference to the members of the elements array if it is desired to keep them alive after the signal handler returns.

Since: 2.16

afterWebPageFormControlsAssociated :: (IsWebPage a, MonadIO m) => a -> WebPageFormControlsAssociatedCallback -> m SignalHandlerId

Connect a signal handler for the formControlsAssociated signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after webPage #formControlsAssociated callback

genClosure_WebPageFormControlsAssociated :: MonadIO m => WebPageFormControlsAssociatedCallback -> m (GClosure C_WebPageFormControlsAssociatedCallback)

Wrap the callback into a GClosure.

mk_WebPageFormControlsAssociatedCallback :: C_WebPageFormControlsAssociatedCallback -> IO (FunPtr C_WebPageFormControlsAssociatedCallback)

Generate a function pointer callable from C code, from a C_WebPageFormControlsAssociatedCallback.

noWebPageFormControlsAssociatedCallback :: Maybe WebPageFormControlsAssociatedCallback

A convenience synonym for Nothing :: Maybe WebPageFormControlsAssociatedCallback.

onWebPageFormControlsAssociated :: (IsWebPage a, MonadIO m) => a -> WebPageFormControlsAssociatedCallback -> m SignalHandlerId

Connect a signal handler for the formControlsAssociated signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on webPage #formControlsAssociated callback

wrap_WebPageFormControlsAssociatedCallback :: WebPageFormControlsAssociatedCallback -> C_WebPageFormControlsAssociatedCallback

Wrap a WebPageFormControlsAssociatedCallback into a C_WebPageFormControlsAssociatedCallback.

formControlsAssociatedForFrame

type C_WebPageFormControlsAssociatedForFrameCallback = Ptr () -> Ptr (GPtrArray (Ptr DOMElement)) -> Ptr Frame -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type WebPageFormControlsAssociatedForFrameCallback

Arguments

 = [DOMElement]

elements: a PtrArray of DOMElement with the list of forms in the page

-> Frame

frame: the Frame

-> IO ()

Emitted after form elements (or form associated elements) are associated to a particular web page. This is useful to implement form auto filling for web pages where form fields are added dynamically. This signal might be emitted multiple times for the same web page.

Note that this signal could be also emitted when form controls are moved between forms. In that case, the elements array carries the list of those elements which have moved.

Clients should take a reference to the members of the elements array if it is desired to keep them alive after the signal handler returns.

Since: 2.26

afterWebPageFormControlsAssociatedForFrame :: (IsWebPage a, MonadIO m) => a -> WebPageFormControlsAssociatedForFrameCallback -> m SignalHandlerId

Connect a signal handler for the formControlsAssociatedForFrame signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after webPage #formControlsAssociatedForFrame callback

genClosure_WebPageFormControlsAssociatedForFrame :: MonadIO m => WebPageFormControlsAssociatedForFrameCallback -> m (GClosure C_WebPageFormControlsAssociatedForFrameCallback)

Wrap the callback into a GClosure.

mk_WebPageFormControlsAssociatedForFrameCallback :: C_WebPageFormControlsAssociatedForFrameCallback -> IO (FunPtr C_WebPageFormControlsAssociatedForFrameCallback)

Generate a function pointer callable from C code, from a C_WebPageFormControlsAssociatedForFrameCallback.

noWebPageFormControlsAssociatedForFrameCallback :: Maybe WebPageFormControlsAssociatedForFrameCallback

A convenience synonym for Nothing :: Maybe WebPageFormControlsAssociatedForFrameCallback.

onWebPageFormControlsAssociatedForFrame :: (IsWebPage a, MonadIO m) => a -> WebPageFormControlsAssociatedForFrameCallback -> m SignalHandlerId

Connect a signal handler for the formControlsAssociatedForFrame signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on webPage #formControlsAssociatedForFrame callback

wrap_WebPageFormControlsAssociatedForFrameCallback :: WebPageFormControlsAssociatedForFrameCallback -> C_WebPageFormControlsAssociatedForFrameCallback

Wrap a WebPageFormControlsAssociatedForFrameCallback into a C_WebPageFormControlsAssociatedForFrameCallback.

sendRequest

type C_WebPageSendRequestCallback = Ptr () -> Ptr URIRequest -> Ptr URIResponse -> Ptr () -> IO CInt

Type for the callback on the (unwrapped) C side.

type WebPageSendRequestCallback

Arguments

 = URIRequest

request: a URIRequest

-> URIResponse

redirectedResponse: a URIResponse, or Nothing

-> IO Bool

Returns: True to stop other handlers from being invoked for the event. False to continue emission of the event.

This signal is emitted when request is about to be sent to the server. This signal can be used to modify the URIRequest that will be sent to the server. You can also cancel the resource load operation by connecting to this signal and returning True.

In case of a server redirection this signal is emitted again with the request argument containing the new request to be sent to the server due to the redirection and the redirectedResponse parameter containing the response received by the server for the initial request.

Modifications to the URIRequest and its associated MessageHeaders will be taken into account when the request is sent over the network.

afterWebPageSendRequest :: (IsWebPage a, MonadIO m) => a -> WebPageSendRequestCallback -> m SignalHandlerId

Connect a signal handler for the sendRequest signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after webPage #sendRequest callback

genClosure_WebPageSendRequest :: MonadIO m => WebPageSendRequestCallback -> m (GClosure C_WebPageSendRequestCallback)

Wrap the callback into a GClosure.

mk_WebPageSendRequestCallback :: C_WebPageSendRequestCallback -> IO (FunPtr C_WebPageSendRequestCallback)

Generate a function pointer callable from C code, from a C_WebPageSendRequestCallback.

noWebPageSendRequestCallback :: Maybe WebPageSendRequestCallback

A convenience synonym for Nothing :: Maybe WebPageSendRequestCallback.

onWebPageSendRequest :: (IsWebPage a, MonadIO m) => a -> WebPageSendRequestCallback -> m SignalHandlerId

Connect a signal handler for the sendRequest signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on webPage #sendRequest callback

wrap_WebPageSendRequestCallback :: WebPageSendRequestCallback -> C_WebPageSendRequestCallback

Wrap a WebPageSendRequestCallback into a C_WebPageSendRequestCallback.

userMessageReceived

type C_WebPageUserMessageReceivedCallback = Ptr () -> Ptr UserMessage -> Ptr () -> IO CInt

Type for the callback on the (unwrapped) C side.

type WebPageUserMessageReceivedCallback

Arguments

 = UserMessage

message: the UserMessage received

-> IO Bool

Returns: True if the message was handled, or False otherwise.

This signal is emitted when a UserMessage is received from the WebKitWebView corresponding to webPage. You can reply to the message using userMessageSendReply.

You can handle the user message asynchronously by calling objectRef on message and returning True. If the last reference of message is removed and the message has been replied, the operation in the WebKitWebView will finish with error UserMessageErrorUserMessageUnhandledMessage.

Since: 2.28

afterWebPageUserMessageReceived :: (IsWebPage a, MonadIO m) => a -> WebPageUserMessageReceivedCallback -> m SignalHandlerId

Connect a signal handler for the userMessageReceived signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after webPage #userMessageReceived callback

genClosure_WebPageUserMessageReceived :: MonadIO m => WebPageUserMessageReceivedCallback -> m (GClosure C_WebPageUserMessageReceivedCallback)

Wrap the callback into a GClosure.

mk_WebPageUserMessageReceivedCallback :: C_WebPageUserMessageReceivedCallback -> IO (FunPtr C_WebPageUserMessageReceivedCallback)

Generate a function pointer callable from C code, from a C_WebPageUserMessageReceivedCallback.

noWebPageUserMessageReceivedCallback :: Maybe WebPageUserMessageReceivedCallback

A convenience synonym for Nothing :: Maybe WebPageUserMessageReceivedCallback.

onWebPageUserMessageReceived :: (IsWebPage a, MonadIO m) => a -> WebPageUserMessageReceivedCallback -> m SignalHandlerId

Connect a signal handler for the userMessageReceived signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on webPage #userMessageReceived callback

wrap_WebPageUserMessageReceivedCallback :: WebPageUserMessageReceivedCallback -> C_WebPageUserMessageReceivedCallback

Wrap a WebPageUserMessageReceivedCallback into a C_WebPageUserMessageReceivedCallback.

willSubmitForm

type C_WebPageWillSubmitFormCallback = Ptr () -> Ptr DOMElement -> CUInt -> Ptr Frame -> Ptr Frame -> Ptr (GPtrArray CString) -> Ptr (GPtrArray CString) -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type WebPageWillSubmitFormCallback

Arguments

 = DOMElement

form: the DOMElement to be submitted, which will always correspond to an HTMLFormElement

-> FormSubmissionStep

step: a WebKitFormSubmissionEventType indicating the current stage of form submission

-> Frame

sourceFrame: the Frame containing the form to be submitted

-> Frame

targetFrame: the Frame containing the form's target, which may be the same as sourceFrame if no target was specified

-> [Text]

textFieldNames: names of the form's text fields

-> [Text]

textFieldValues: values of the form's text fields

-> IO ()

This signal is emitted to indicate various points during form submission. step indicates the current stage of form submission.

If this signal is emitted with FormSubmissionStepSendDomEvent, then the DOM submit event is about to be emitted. JavaScript code may rely on the submit event to detect that the user has clicked on a submit button, and to possibly cancel the form submission before FormSubmissionStepComplete. However, beware that, for historical reasons, the submit event is not emitted at all if the form submission is triggered by JavaScript. For these reasons, FormSubmissionStepSendDomEvent may not be used to reliably detect whether a form will be submitted. Instead, use it to detect if a user has clicked on a form's submit button even if JavaScript later cancels the form submission, or to read the values of the form's fields even if JavaScript later clears certain fields before submitting. This may be needed, for example, to implement a robust browser password manager, as some misguided websites may use such techniques to attempt to thwart password managers.

If this signal is emitted with FormSubmissionStepComplete, the form will imminently be submitted. It can no longer be cancelled. This event always occurs immediately before a form is submitted to its target, so use this event to reliably detect when a form is submitted. This event occurs after FormSubmissionStepSendDomEvent if that event is emitted.

Since: 2.20

afterWebPageWillSubmitForm :: (IsWebPage a, MonadIO m) => a -> WebPageWillSubmitFormCallback -> m SignalHandlerId

Connect a signal handler for the willSubmitForm signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after webPage #willSubmitForm callback

genClosure_WebPageWillSubmitForm :: MonadIO m => WebPageWillSubmitFormCallback -> m (GClosure C_WebPageWillSubmitFormCallback)

Wrap the callback into a GClosure.

mk_WebPageWillSubmitFormCallback :: C_WebPageWillSubmitFormCallback -> IO (FunPtr C_WebPageWillSubmitFormCallback)

Generate a function pointer callable from C code, from a C_WebPageWillSubmitFormCallback.

noWebPageWillSubmitFormCallback :: Maybe WebPageWillSubmitFormCallback

A convenience synonym for Nothing :: Maybe WebPageWillSubmitFormCallback.

onWebPageWillSubmitForm :: (IsWebPage a, MonadIO m) => a -> WebPageWillSubmitFormCallback -> m SignalHandlerId

Connect a signal handler for the willSubmitForm signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on webPage #willSubmitForm callback

wrap_WebPageWillSubmitFormCallback :: WebPageWillSubmitFormCallback -> C_WebPageWillSubmitFormCallback

Wrap a WebPageWillSubmitFormCallback into a C_WebPageWillSubmitFormCallback.