Skip to main content

Interface: WebKitWebViewProps

Defined in: packages/react/src/generated/jsx.ts:9043

Props for the WebKitWebView widget.

Extends​

Properties​

accessibleActiveDescendant?​

optional accessibleActiveDescendant: Widget

Defined in: packages/react/src/jsx.ts:1175

Inherited from​

WebKitWebViewBaseProps.accessibleActiveDescendant

accessibleAutocomplete?​

optional accessibleAutocomplete: AccessibleAutocomplete

Defined in: packages/react/src/jsx.ts:1144

Inherited from​

WebKitWebViewBaseProps.accessibleAutocomplete

accessibleBusy?​

optional accessibleBusy: boolean

Defined in: packages/react/src/jsx.ts:1165

Inherited from​

WebKitWebViewBaseProps.accessibleBusy

accessibleChecked?​

optional accessibleChecked: AccessibleTristate

Defined in: packages/react/src/jsx.ts:1166

Inherited from​

WebKitWebViewBaseProps.accessibleChecked

accessibleColCount?​

optional accessibleColCount: number

Defined in: packages/react/src/jsx.ts:1176

Inherited from​

WebKitWebViewBaseProps.accessibleColCount

accessibleColIndex?​

optional accessibleColIndex: number

Defined in: packages/react/src/jsx.ts:1177

Inherited from​

WebKitWebViewBaseProps.accessibleColIndex

accessibleColIndexText?​

optional accessibleColIndexText: string

Defined in: packages/react/src/jsx.ts:1178

Inherited from​

WebKitWebViewBaseProps.accessibleColIndexText

accessibleColSpan?​

optional accessibleColSpan: number

Defined in: packages/react/src/jsx.ts:1179

Inherited from​

WebKitWebViewBaseProps.accessibleColSpan

accessibleControls?​

optional accessibleControls: Widget[]

Defined in: packages/react/src/jsx.ts:1180

Inherited from​

WebKitWebViewBaseProps.accessibleControls

accessibleDescribedBy?​

optional accessibleDescribedBy: Widget[]

Defined in: packages/react/src/jsx.ts:1181

Inherited from​

WebKitWebViewBaseProps.accessibleDescribedBy

accessibleDescription?​

optional accessibleDescription: string

Defined in: packages/react/src/jsx.ts:1145

Inherited from​

WebKitWebViewBaseProps.accessibleDescription

accessibleDetails?​

optional accessibleDetails: Widget[]

Defined in: packages/react/src/jsx.ts:1182

Inherited from​

WebKitWebViewBaseProps.accessibleDetails

accessibleDisabled?​

optional accessibleDisabled: boolean

Defined in: packages/react/src/jsx.ts:1167

Inherited from​

WebKitWebViewBaseProps.accessibleDisabled

accessibleErrorMessage?​

optional accessibleErrorMessage: Widget[]

Defined in: packages/react/src/jsx.ts:1183

Inherited from​

WebKitWebViewBaseProps.accessibleErrorMessage

accessibleExpanded?​

optional accessibleExpanded: boolean

Defined in: packages/react/src/jsx.ts:1168

Inherited from​

WebKitWebViewBaseProps.accessibleExpanded

accessibleFlowTo?​

optional accessibleFlowTo: Widget[]

Defined in: packages/react/src/jsx.ts:1184

Inherited from​

WebKitWebViewBaseProps.accessibleFlowTo

accessibleHasPopup?​

optional accessibleHasPopup: boolean

Defined in: packages/react/src/jsx.ts:1146

Inherited from​

WebKitWebViewBaseProps.accessibleHasPopup

accessibleHelpText?​

optional accessibleHelpText: string

Defined in: packages/react/src/jsx.ts:1163

Inherited from​

WebKitWebViewBaseProps.accessibleHelpText

accessibleHidden?​

optional accessibleHidden: boolean

Defined in: packages/react/src/jsx.ts:1169

Inherited from​

WebKitWebViewBaseProps.accessibleHidden

accessibleInvalid?​

optional accessibleInvalid: AccessibleInvalidState

Defined in: packages/react/src/jsx.ts:1170

Inherited from​

WebKitWebViewBaseProps.accessibleInvalid

accessibleKeyShortcuts?​

optional accessibleKeyShortcuts: string

Defined in: packages/react/src/jsx.ts:1147

Inherited from​

WebKitWebViewBaseProps.accessibleKeyShortcuts

accessibleLabel?​

optional accessibleLabel: string

Defined in: packages/react/src/jsx.ts:1148

Inherited from​

WebKitWebViewBaseProps.accessibleLabel

accessibleLabelledBy?​

optional accessibleLabelledBy: Widget[]

Defined in: packages/react/src/jsx.ts:1185

Inherited from​

WebKitWebViewBaseProps.accessibleLabelledBy

accessibleLevel?​

optional accessibleLevel: number

Defined in: packages/react/src/jsx.ts:1149

Inherited from​

WebKitWebViewBaseProps.accessibleLevel

accessibleModal?​

optional accessibleModal: boolean

Defined in: packages/react/src/jsx.ts:1150

Inherited from​

WebKitWebViewBaseProps.accessibleModal

accessibleMultiLine?​

optional accessibleMultiLine: boolean

Defined in: packages/react/src/jsx.ts:1151

Inherited from​

WebKitWebViewBaseProps.accessibleMultiLine

accessibleMultiSelectable?​

optional accessibleMultiSelectable: boolean

Defined in: packages/react/src/jsx.ts:1152

Inherited from​

WebKitWebViewBaseProps.accessibleMultiSelectable

accessibleOrientation?​

optional accessibleOrientation: Orientation

Defined in: packages/react/src/jsx.ts:1153

Inherited from​

WebKitWebViewBaseProps.accessibleOrientation

accessibleOwns?​

optional accessibleOwns: Widget[]

Defined in: packages/react/src/jsx.ts:1186

Inherited from​

WebKitWebViewBaseProps.accessibleOwns

accessiblePlaceholder?​

optional accessiblePlaceholder: string

Defined in: packages/react/src/jsx.ts:1154

Inherited from​

WebKitWebViewBaseProps.accessiblePlaceholder

accessiblePosInSet?​

optional accessiblePosInSet: number

Defined in: packages/react/src/jsx.ts:1187

Inherited from​

WebKitWebViewBaseProps.accessiblePosInSet

accessiblePressed?​

optional accessiblePressed: AccessibleTristate

Defined in: packages/react/src/jsx.ts:1171

Inherited from​

WebKitWebViewBaseProps.accessiblePressed

accessibleReadOnly?​

optional accessibleReadOnly: boolean

Defined in: packages/react/src/jsx.ts:1155

Inherited from​

WebKitWebViewBaseProps.accessibleReadOnly

accessibleRequired?​

optional accessibleRequired: boolean

Defined in: packages/react/src/jsx.ts:1156

Inherited from​

WebKitWebViewBaseProps.accessibleRequired

accessibleRole?​

optional accessibleRole: AccessibleRole

Defined in: packages/react/src/generated/jsx.ts:187

The accessible role of the given GtkAccessible implementation.

The accessible role cannot be changed once set.

Inherited from​

WebKitWebViewBaseProps.accessibleRole

accessibleRoleDescription?​

optional accessibleRoleDescription: string

Defined in: packages/react/src/jsx.ts:1157

Inherited from​

WebKitWebViewBaseProps.accessibleRoleDescription

accessibleRowCount?​

optional accessibleRowCount: number

Defined in: packages/react/src/jsx.ts:1188

Inherited from​

WebKitWebViewBaseProps.accessibleRowCount

accessibleRowIndex?​

optional accessibleRowIndex: number

Defined in: packages/react/src/jsx.ts:1189

Inherited from​

WebKitWebViewBaseProps.accessibleRowIndex

accessibleRowIndexText?​

optional accessibleRowIndexText: string

Defined in: packages/react/src/jsx.ts:1190

Inherited from​

WebKitWebViewBaseProps.accessibleRowIndexText

accessibleRowSpan?​

optional accessibleRowSpan: number

Defined in: packages/react/src/jsx.ts:1191

Inherited from​

WebKitWebViewBaseProps.accessibleRowSpan

accessibleSelected?​

optional accessibleSelected: boolean

Defined in: packages/react/src/jsx.ts:1172

Inherited from​

WebKitWebViewBaseProps.accessibleSelected

accessibleSetSize?​

optional accessibleSetSize: number

Defined in: packages/react/src/jsx.ts:1192

Inherited from​

WebKitWebViewBaseProps.accessibleSetSize

accessibleSort?​

optional accessibleSort: AccessibleSort

Defined in: packages/react/src/jsx.ts:1158

Inherited from​

WebKitWebViewBaseProps.accessibleSort

accessibleValueMax?​

optional accessibleValueMax: number

Defined in: packages/react/src/jsx.ts:1159

Inherited from​

WebKitWebViewBaseProps.accessibleValueMax

accessibleValueMin?​

optional accessibleValueMin: number

Defined in: packages/react/src/jsx.ts:1160

Inherited from​

WebKitWebViewBaseProps.accessibleValueMin

accessibleValueNow?​

optional accessibleValueNow: number

Defined in: packages/react/src/jsx.ts:1161

Inherited from​

WebKitWebViewBaseProps.accessibleValueNow

accessibleValueText?​

optional accessibleValueText: string

Defined in: packages/react/src/jsx.ts:1162

Inherited from​

WebKitWebViewBaseProps.accessibleValueText

accessibleVisited?​

optional accessibleVisited: boolean

Defined in: packages/react/src/jsx.ts:1173

Inherited from​

WebKitWebViewBaseProps.accessibleVisited

automationPresentationType?​

optional automationPresentationType: AutomationBrowsingContextPresentation

Defined in: packages/react/src/generated/jsx.ts:9050

The #WebKitAutomationBrowsingContextPresentation of #WebKitWebView. This should only be used when creating a new #WebKitWebView as a response to #WebKitAutomationSession::create-web-view signal request. If the new WebView was added to a new tab of current browsing context window %WEBKIT_AUTOMATION_BROWSING_CONTEXT_PRESENTATION_TAB should be used.

cameraCaptureState?​

optional cameraCaptureState: MediaCaptureState

Defined in: packages/react/src/generated/jsx.ts:9064

Capture state of the camera device. Whenever the user grants a media-request sent by the web page, requesting video capture capabilities (navigator.mediaDevices.getUserMedia({video: true})) this property will be set to %WEBKIT_MEDIA_CAPTURE_STATE_ACTIVE.

The application can monitor this property and provide a visual indicator allowing to optionally deactivate or mute the capture device by setting this property respectively to %WEBKIT_MEDIA_CAPTURE_STATE_NONE or %WEBKIT_MEDIA_CAPTURE_STATE_MUTED.

If the capture state of the device is set to %WEBKIT_MEDIA_CAPTURE_STATE_NONE the web-page can still re-request the permission to the user. Permission desision caching is left to the application.

canFocus?​

optional canFocus: boolean

Defined in: packages/react/src/generated/jsx.ts:24

Whether the widget or any of its descendents can accept the input focus.

This property is meant to be set by widget implementations, typically in their instance init function.

Inherited from​

WebKitWebViewBaseProps.canFocus

canTarget?​

optional canTarget: boolean

Defined in: packages/react/src/generated/jsx.ts:26

Whether the widget can receive pointer events.

Inherited from​

WebKitWebViewBaseProps.canTarget

children?​

optional children: ReactNode

Defined in: packages/react/src/generated/jsx.ts:314

Children elements (child widgets or event controllers).

Inherited from​

WebKitWebViewBaseProps.children

cssClasses?​

optional cssClasses: string[]

Defined in: packages/react/src/generated/jsx.ts:28

A list of css classes applied to this widget.

Inherited from​

WebKitWebViewBaseProps.cssClasses

cssName?​

optional cssName: string

Defined in: packages/react/src/generated/jsx.ts:35

The name of this widget in the CSS tree.

This property is meant to be set by widget implementations, typically in their instance init function.

Inherited from​

WebKitWebViewBaseProps.cssName

cursor?​

optional cursor: Cursor | null

Defined in: packages/react/src/generated/jsx.ts:37

The cursor used by widget.

Inherited from​

WebKitWebViewBaseProps.cursor

defaultContentSecurityPolicy?​

optional defaultContentSecurityPolicy: string

Defined in: packages/react/src/generated/jsx.ts:9077

The default Content-Security-Policy used by the webview as if it were set by an HTTP header.

This applies to all content loaded including through navigation or via the various webkit_web_view_load_* APIs. However do note that many WebKit APIs bypass Content-Security-Policy in general such as #WebKitUserContentManager and webkit_web_view_run_javascript().

Policies are additive so if a website sets its own policy it still applies on top of the policy set here.

displayCaptureState?​

optional displayCaptureState: MediaCaptureState

Defined in: packages/react/src/generated/jsx.ts:9091

Capture state of the display device. Whenever the user grants a media-request sent by the web page, requesting screencasting capabilities (`navigator.mediaDevices.getDisplayMedia() this property will be set to %WEBKIT_MEDIA_CAPTURE_STATE_ACTIVE.

The application can monitor this property and provide a visual indicator allowing to optionally deactivate or mute the capture device by setting this property respectively to %WEBKIT_MEDIA_CAPTURE_STATE_NONE or %WEBKIT_MEDIA_CAPTURE_STATE_MUTED.

If the capture state of the device is set to %WEBKIT_MEDIA_CAPTURE_STATE_NONE the web-page can still re-request the permission to the user. Permission desision caching is left to the application.

editable?​

optional editable: boolean

Defined in: packages/react/src/generated/jsx.ts:9096

Whether the pages loaded inside #WebKitWebView are editable. For more information see webkit_web_view_set_editable().

focusable?​

optional focusable: boolean

Defined in: packages/react/src/generated/jsx.ts:45

Whether this widget itself will accept the input focus.

Inherited from​

WebKitWebViewBaseProps.focusable

focusOnClick?​

optional focusOnClick: boolean

Defined in: packages/react/src/generated/jsx.ts:43

Whether the widget should grab focus when it is clicked with the mouse.

This property is only relevant for widgets that can take focus.

Inherited from​

WebKitWebViewBaseProps.focusOnClick

halign?​

optional halign: Align

Defined in: packages/react/src/generated/jsx.ts:47

How to distribute horizontal space if widget gets extra space.

Inherited from​

WebKitWebViewBaseProps.halign

hasTooltip?​

optional hasTooltip: boolean

Defined in: packages/react/src/generated/jsx.ts:56

Enables or disables the emission of the Widget.:query-tooltip signal on widget.

A true value indicates that widget can have a tooltip, in this case the widget will be queried using Widget.:query-tooltip to determine whether it will provide a tooltip or not.

Inherited from​

WebKitWebViewBaseProps.hasTooltip

heightRequest?​

optional heightRequest: number

Defined in: packages/react/src/generated/jsx.ts:62

Overrides for height request of the widget.

If this is -1, the natural request will be used.

Inherited from​

WebKitWebViewBaseProps.heightRequest

hexpand?​

optional hexpand: boolean

Defined in: packages/react/src/generated/jsx.ts:64

Whether to expand horizontally.

Inherited from​

WebKitWebViewBaseProps.hexpand

hexpandSet?​

optional hexpandSet: boolean

Defined in: packages/react/src/generated/jsx.ts:66

Whether to use the hexpand property.

Inherited from​

WebKitWebViewBaseProps.hexpandSet

isControlledByAutomation?​

optional isControlledByAutomation: boolean

Defined in: packages/react/src/generated/jsx.ts:9109

Whether the #WebKitWebView is controlled by automation tools (e.g. WebDriver, Selenium). This is required for views returned as a response to #WebKitAutomationSession::create-web-view signal, alongside any view you want to control during an automation session.

As a %G_PARAM_CONSTRUCT_ONLY, you need to set it during construction and it can't be modified.

If #WebKitWebView:related-view is also passed during construction, #WebKitWebView:is-controlled-by-automation ignores its own parameter and inherits directly from the related view #WebKitWebView:is-controlled-by-automation property. This is the recommended way when creating new views as a response to the #WebKitWebView::create signal. For example, as response to JavaScript window.open() calls during an automation session.

isMuted?​

optional isMuted: boolean

Defined in: packages/react/src/generated/jsx.ts:9114

Whether the #WebKitWebView audio is muted. When %TRUE, audio is silenced. It may still be playing, i.e. #WebKitWebView:is-playing-audio may be %TRUE.

layoutManager?​

optional layoutManager: LayoutManager | null

Defined in: packages/react/src/generated/jsx.ts:74

The LayoutManager instance to use to compute the preferred size of the widget, and allocate its children.

This property is meant to be set by widget implementations, typically in their instance init function.

Inherited from​

WebKitWebViewBaseProps.layoutManager

limitEvents?​

optional limitEvents: boolean

Defined in: packages/react/src/generated/jsx.ts:83

Makes this widget act like a modal dialog, with respect to event delivery.

Global event controllers will not handle events with targets inside the widget, unless they are set up to ignore propagation limits. See EventController.set_propagation_limit.

Inherited from​

WebKitWebViewBaseProps.limitEvents

marginBottom?​

optional marginBottom: number

Defined in: packages/react/src/generated/jsx.ts:91

Margin on bottom side of widget.

This property adds margin outside of the widget's normal size request, the margin will be added in addition to the size from Widget.set_size_request for example.

Inherited from​

WebKitWebViewBaseProps.marginBottom

marginEnd?​

optional marginEnd: number

Defined in: packages/react/src/generated/jsx.ts:102

Margin on end of widget, horizontally.

This property supports left-to-right and right-to-left text directions.

This property adds margin outside of the widget's normal size request, the margin will be added in addition to the size from Widget.set_size_request for example.

Inherited from​

WebKitWebViewBaseProps.marginEnd

marginStart?​

optional marginStart: number

Defined in: packages/react/src/generated/jsx.ts:113

Margin on start of widget, horizontally.

This property supports left-to-right and right-to-left text directions.

This property adds margin outside of the widget's normal size request, the margin will be added in addition to the size from Widget.set_size_request for example.

Inherited from​

WebKitWebViewBaseProps.marginStart

marginTop?​

optional marginTop: number

Defined in: packages/react/src/generated/jsx.ts:121

Margin on top side of widget.

This property adds margin outside of the widget's normal size request, the margin will be added in addition to the size from Widget.set_size_request for example.

Inherited from​

WebKitWebViewBaseProps.marginTop

microphoneCaptureState?​

optional microphoneCaptureState: MediaCaptureState

Defined in: packages/react/src/generated/jsx.ts:9128

Capture state of the microphone device. Whenever the user grants a media-request sent by the web page, requesting audio capture capabilities (navigator.mediaDevices.getUserMedia({audio: true})) this property will be set to %WEBKIT_MEDIA_CAPTURE_STATE_ACTIVE.

The application can monitor this property and provide a visual indicator allowing to optionally deactivate or mute the capture device by setting this property respectively to %WEBKIT_MEDIA_CAPTURE_STATE_NONE or %WEBKIT_MEDIA_CAPTURE_STATE_MUTED.

If the capture state of the device is set to %WEBKIT_MEDIA_CAPTURE_STATE_NONE the web-page can still re-request the permission to the user. Permission desision caching is left to the application.

name?​

optional name: string

Defined in: packages/react/src/generated/jsx.ts:123

The name of the widget.

Inherited from​

WebKitWebViewBaseProps.name

networkSession?​

optional networkSession: NetworkSession

Defined in: packages/react/src/generated/jsx.ts:9130

The #WebKitNetworkSession of the view

onAuthenticate?​

optional onAuthenticate: (request, self) => boolean | null

Defined in: packages/react/src/generated/jsx.ts:9174

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 #WebKitAuthenticationRequest 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.

onClose?​

optional onClose: (self) => void | null

Defined in: packages/react/src/generated/jsx.ts:9182

Emitted when closing a #WebKitWebView is requested. This occurs when a call is made from JavaScript's window.close function or after trying to close the web_view with webkit_web_view_try_close(). It is the owner's responsibility to handle this signal to hide or destroy the #WebKitWebView, if necessary.

onContextMenu?​

optional onContextMenu: (contextMenu, hitTestResult, self) => boolean | null

Defined in: packages/react/src/generated/jsx.ts:9218

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. To customize the proposed menu you can use webkit_context_menu_prepend(), webkit_context_menu_append() or webkit_context_menu_insert() to add new #WebKitContextMenuItems to context_menu, webkit_context_menu_move_item() to reorder existing items, or webkit_context_menu_remove() to remove an existing item. The signal handler should return %FALSE, and the menu represented by context_menu will be shown. 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. To build your own menu, you can remove all items from the proposed menu with webkit_context_menu_remove_all(), add your own items and return %FALSE so that the menu will be shown. You can also ignore the proposed #WebKitContextMenu, build your own #GtkMenu and return %TRUE to prevent the proposed menu from being shown. 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.

If the signal handler returns %FALSE the context menu represented by context_menu will be shown, if it return %TRUE the context menu will not be shown.

The proposed #WebKitContextMenu passed in context_menu argument is only valid during the signal emission.

onContextMenuDismissed?​

optional onContextMenuDismissed: (self) => void | null

Defined in: packages/react/src/generated/jsx.ts:9225

Emitted after #WebKitWebView::context-menu signal, if the context menu is shown, to notify that the context menu is dismissed.

onCreate?​

optional onCreate: (navigationAction, self) => Widget | null

Defined in: packages/react/src/generated/jsx.ts:9243

Emitted when the creation of a new #WebKitWebView is requested. If this signal is handled the signal handler should return the newly created #WebKitWebView.

The #WebKitNavigationAction parameter contains information about the navigation action that triggered this signal.

The new #WebKitWebView must be related to web_view, see #WebKitWebView:related-view for more details.

The new #WebKitWebView should not be displayed to the user until the #WebKitWebView::ready-to-show signal is emitted.

For creating views as response to automation tools requests, see the #WebKitAutomationSession::create-web-view signal.

onDecidePolicy?​

optional onDecidePolicy: (decision, decisionType, self) => boolean | null

Defined in: packages/react/src/generated/jsx.ts:9287

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 #WebKitNavigationPolicyDecision passed in the decision argument is a generic type, but should be casted to a more specific type when making the decision. For example:

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 webkit_policy_decision_use()
        return FALSE;
    }
    return TRUE;
}

It is possible to make policy decision asynchronously, by simply calling g_object_ref() on the decision argument and returning %TRUE to block the default signal handler. If the last reference is removed on a #WebKitPolicyDecision and no decision has been made explicitly, webkit_policy_decision_use() will be the default policy decision. The default signal handler will simply call webkit_policy_decision_use(). Only the first policy decision chosen for a given #WebKitPolicyDecision will have any affect.

onDestroy?​

optional onDestroy: (self) => void | null

Defined in: packages/react/src/generated/jsx.ts:196

Signals that all holders of a reference to the widget should release the reference that they hold.

May result in finalization of the widget if all references are released.

This signal is not suitable for saving widget state.

Inherited from​

WebKitWebViewBaseProps.onDestroy

onDirectionChanged?​

optional onDirectionChanged: (previousDirection, self) => void | null

Defined in: packages/react/src/generated/jsx.ts:198

Emitted when the text direction of a widget changes.

Inherited from​

WebKitWebViewBaseProps.onDirectionChanged

onEnterFullscreen?​

optional onEnterFullscreen: (self) => boolean | null

Defined in: packages/react/src/generated/jsx.ts:9300

Emitted when JavaScript code calls element.webkitRequestFullScreen. If the signal is not handled the #WebKitWebView 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).

onHide?​

optional onHide: (self) => void | null

Defined in: packages/react/src/generated/jsx.ts:200

Emitted when widget is hidden.

Inherited from​

WebKitWebViewBaseProps.onHide

onInsecureContentDetected?​

optional onInsecureContentDetected: (event, self) => void | null

Defined in: packages/react/src/generated/jsx.ts:9306

Prior to 2.46, this signal was emitted when insecure content was loaded in a secure content. Since 2.46, this signal is generally no longer emitted.

onKeynavFailed?​

optional onKeynavFailed: (direction, self) => boolean | null

Defined in: packages/react/src/generated/jsx.ts:206

Emitted if keyboard navigation fails.

See Widget.keynav_failed for details.

Inherited from​

WebKitWebViewBaseProps.onKeynavFailed

onLeaveFullscreen?​

optional onLeaveFullscreen: (self) => boolean | null

Defined in: packages/react/src/generated/jsx.ts:9313

Emitted when the #WebKitWebView is about to restore its top level window out of its full screen state. This signal can be used by client code to restore widgets hidden during the #WebKitWebView::enter-fullscreen stage for instance.

onLoadChanged?​

optional onLoadChanged: (loadEvent, self) => void | null

Defined in: packages/react/src/generated/jsx.ts:9360

Emitted when a load operation in web_view changes. The signal is always emitted with %WEBKIT_LOAD_STARTED when a new load request is made and %WEBKIT_LOAD_FINISHED when the load finishes successfully or due to an error. When the ongoing load operation fails #WebKitWebView::load-failed signal is emitted before #WebKitWebView::load-changed is emitted with %WEBKIT_LOAD_FINISHED. If a redirection is received from the server, this signal is emitted with %WEBKIT_LOAD_REDIRECTED after the initial emission with %WEBKIT_LOAD_STARTED and before %WEBKIT_LOAD_COMMITTED. When the page content starts arriving the signal is emitted with %WEBKIT_LOAD_COMMITTED event.

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

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

onLoadFailed?​

optional onLoadFailed: (loadEvent, failingUri, error, self) => boolean | null

Defined in: packages/react/src/generated/jsx.ts:9373

Emitted when an error occurs during a load operation. If the error happened when starting to load data for a page load_event will be %WEBKIT_LOAD_STARTED. If it happened while loading a committed data source load_event will be %WEBKIT_LOAD_COMMITTED. Since a load error causes the load operation to finish, the signal WebKitWebView::load-changed will always be emitted with %WEBKIT_LOAD_FINISHED 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.

onLoadFailedWithTlsErrors?​

optional onLoadFailedWithTlsErrors: (failingUri, certificate, errors, self) => boolean | null

Defined in: packages/react/src/generated/jsx.ts:9387

Emitted when a TLS error occurs during a load operation. To allow an exception for this certificate and the host of failing_uri use webkit_web_context_allow_tls_certificate_for_host().

To handle this signal asynchronously you should call g_object_ref() on certificate and return %TRUE.

If %FALSE is returned, #WebKitWebView::load-failed will be emitted. The load will finish regardless of the returned value.

onMap?​

optional onMap: (self) => void | null

Defined in: packages/react/src/generated/jsx.ts:218

Emitted when widget is going to be mapped.

A widget is mapped when the widget is visible (which is controlled with Widget.visible) and all its parents up to the toplevel widget are also visible.

The ::map signal can be used to determine whether a widget will be drawn, for instance it can resume an animation that was stopped during the emission of Widget.:unmap.

Inherited from​

WebKitWebViewBaseProps.onMap

onMnemonicActivate?​

optional onMnemonicActivate: (groupCycling, self) => boolean | null

Defined in: packages/react/src/generated/jsx.ts:225

Emitted when a widget is activated via a mnemonic.

The default handler for this signal activates widget if group_cycling is false, or just makes widget grab focus if group_cycling is true.

Inherited from​

WebKitWebViewBaseProps.onMnemonicActivate

onMouseTargetChanged?​

optional onMouseTargetChanged: (hitTestResult, modifiers, self) => void | null

Defined in: packages/react/src/generated/jsx.ts:9405

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 hit_test_result argument. The modifiers argument is a bitmask of #GdkModifierType 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 hit_test_result.

onMoveFocus?​

optional onMoveFocus: (direction, self) => void | null

Defined in: packages/react/src/generated/jsx.ts:234

Emitted when the focus is moved.

The ::move-focus signal is a keybinding signal.

The default bindings for this signal are Tab to move forward, and Shift+Tab to move backward.

Inherited from​

WebKitWebViewBaseProps.onMoveFocus

onNotify?​

optional onNotify: (pspec, self) => void | null

Defined in: packages/react/src/generated/jsx.ts:312

The notify signal is emitted on an object when one of its properties has its value set through g_object_set_property(), g_object_set(), et al.

Note that getting this signal doesn’t itself guarantee that the value of the property has actually changed. When it is emitted is determined by the derived GObject class. If the implementor did not create the property with %G_PARAM_EXPLICIT_NOTIFY, then any call to g_object_set_property() results in ::notify being emitted, even if the new value is the same as the old. If they did pass %G_PARAM_EXPLICIT_NOTIFY, then this signal is emitted only when they explicitly call g_object_notify() or g_object_notify_by_pspec(), and common practice is to do that only when the value has actually changed.

This signal is typically used to obtain change notification for a single property, by specifying the property name as a detail in the g_signal_connect() call, like this:

|[ g_signal_connect (text_view->buffer, "notify::paste-target-list", G_CALLBACK (gtk_text_view_target_list_notify), text_view) ]|

It is important to note that you must use [canonical parameter names]GObjectParamSpec#parameter-names as detail strings for the notify signal.

Inherited from​

WebKitWebViewBaseProps.onNotify

onPermissionRequest?​

optional onPermissionRequest: (request, self) => boolean | null

Defined in: packages/react/src/generated/jsx.ts:9456

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:

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

It is possible to handle permission requests asynchronously, by simply calling g_object_ref() on the request argument and returning %TRUE to block the default signal handler. If the last reference is removed on a #WebKitPermissionRequest and the request has not been handled, webkit_permission_request_deny() will be the default action.

If the signal is not handled, the request will be completed automatically by the specific #WebKitPermissionRequest that could allow or deny it. Check the documentation of classes implementing #WebKitPermissionRequest interface to know their default action.

onPrint?​

optional onPrint: (printOperation, self) => boolean | null

Defined in: packages/react/src/generated/jsx.ts:9468

Emitted when printing is requested on web_view, 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 print_operation to be used as default values in the print dialog. You can call webkit_print_operation_set_print_settings() and webkit_print_operation_set_page_setup() 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.

onQueryPermissionState?​

optional onQueryPermissionState: (query, self) => boolean | null

Defined in: packages/react/src/generated/jsx.ts:9478

This signal allows the User-Agent to respond to permission requests for powerful features, as specified by the Permissions W3C Specification. You can reply to the query using webkit_permission_state_query_finish().

You can handle the query asynchronously by calling webkit_permission_state_query_ref() on query and returning %TRUE. If the last reference of query is removed and the query has not been handled, the query result will be set to %WEBKIT_QUERY_PERMISSION_PROMPT.

onQueryTooltip?​

optional onQueryTooltip: (x, y, keyboardMode, tooltip, self) => boolean | null

Defined in: packages/react/src/generated/jsx.ts:250

Emitted when the widget’s tooltip is about to be shown.

This happens when the Widget.has-tooltip property is true and the hover timeout has expired with the cursor hovering above widget; or emitted when widget got focus in keyboard mode.

Using the given coordinates, the signal handler should determine whether a tooltip should be shown for widget. If this is the case true should be returned, false otherwise. Note that if keyboard_mode is true, the values of x and y are undefined and should not be used.

The signal handler is free to manipulate tooltip with the therefore destined function calls.

Inherited from​

WebKitWebViewBaseProps.onQueryTooltip

onReadyToShow?​

optional onReadyToShow: (self) => void | null

Defined in: packages/react/src/generated/jsx.ts:9487

Emitted after #WebKitWebView::create on the newly created #WebKitWebView 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 #WebKitWindowProperties of web_view. See also webkit_web_view_get_window_properties().

onRealize?​

optional onRealize: (self) => void | null

Defined in: packages/react/src/generated/jsx.ts:259

Emitted when widget is associated with a GdkSurface.

This means that Widget.realize has been called or the widget has been mapped (that is, it is going to be drawn).

Inherited from​

WebKitWebViewBaseProps.onRealize

onResourceLoadStarted?​

optional onResourceLoadStarted: (resource, request, self) => void | null

Defined in: packages/react/src/generated/jsx.ts:9494

Emitted when a new resource is going to be loaded. The request parameter contains the #WebKitURIRequest that will be sent to the server. You can monitor the load operation by connecting to the different signals of resource.

onRunAsModal?​

optional onRunAsModal: (self) => void | null

Defined in: packages/react/src/generated/jsx.ts:9506

Emitted after #WebKitWebView::ready-to-show on the newly created #WebKitWebView when JavaScript code calls window.showModalDialog. 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 #WebKitWebView until the new dialog is closed.

onRunColorChooser?​

optional onRunColorChooser: (request, self) => boolean | null

Defined in: packages/react/src/generated/jsx.ts:9522

This signal is emitted when the user interacts with a 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 #WebKitColorChooserRequest 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 #GtkColorChooser for the user to interact with.

onRunFileChooser?​

optional onRunFileChooser: (request, self) => boolean | null

Defined in: packages/react/src/generated/jsx.ts:9536

This signal is emitted when the user interacts with a 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 #WebKitFileChooserRequest in the request argument.

The default signal handler will asynchronously run a regular #GtkFileChooserDialog for the user to interact with.

onScriptDialog?​

optional onScriptDialog: (dialog, self) => boolean | null

Defined in: packages/react/src/generated/jsx.ts:9566

Emitted when JavaScript code calls window.alert, window.confirm or window.prompt, or when onbeforeunload 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: %WEBKIT_SCRIPT_DIALOG_ALERT: message dialog with a single Close button. %WEBKIT_SCRIPT_DIALOG_CONFIRM: message dialog with OK and Cancel buttons. %WEBKIT_SCRIPT_DIALOG_PROMPT: message dialog with OK and Cancel buttons and a text entry with the default text. %WEBKIT_SCRIPT_DIALOG_BEFORE_UNLOAD_CONFIRM: message dialog with Stay and Leave buttons.

It is possible to handle the script dialog request asynchronously, by simply caling webkit_script_dialog_ref() on the dialog argument and calling webkit_script_dialog_close() when done. If the last reference is removed on a #WebKitScriptDialog and the dialog has not been closed, webkit_script_dialog_close() will be called.

onShow?​

optional onShow: (self) => void | null

Defined in: packages/react/src/generated/jsx.ts:261

Emitted when widget is shown.

Inherited from​

WebKitWebViewBaseProps.onShow

onShowNotification?​

optional onShowNotification: (notification, self) => boolean | null

Defined in: packages/react/src/generated/jsx.ts:9575

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.

onShowOptionMenu?​

optional onShowOptionMenu: (menu, rectangle, self) => boolean | null

Defined in: packages/react/src/generated/jsx.ts:9586

This signal is emitted when a select element in web_view 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 #WebKitWebView is given as rectangle parameter, it can be used to position the menu. To handle this signal asynchronously you should keep a ref of the menu.

The default signal handler will pop up a #GtkMenu.

onStateFlagsChanged?​

optional onStateFlagsChanged: (flags, self) => void | null

Defined in: packages/react/src/generated/jsx.ts:267

Emitted when the widget state changes.

See Widget.get_state_flags.

Inherited from​

WebKitWebViewBaseProps.onStateFlagsChanged

onSubmitForm?​

optional onSubmitForm: (request, self) => void | null

Defined in: packages/react/src/generated/jsx.ts:9600

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 webkit_form_submission_request_submit() is called.

It is possible to handle the form submission request asynchronously, by simply calling g_object_ref() on the request argument and calling webkit_form_submission_request_submit() when done to continue with the form submission. If the last reference is removed on a #WebKitFormSubmissionRequest and the form has not been submitted, webkit_form_submission_request_submit() will be called.

onUnmap?​

optional onUnmap: (self) => void | null

Defined in: packages/react/src/generated/jsx.ts:277

Emitted when widget is going to be unmapped.

A widget is unmapped when either it or any of its parents up to the toplevel widget have been set as hidden.

As ::unmap indicates that a widget will not be shown any longer, it can be used to, for example, stop an animation on the widget.

Inherited from​

WebKitWebViewBaseProps.onUnmap

onUnrealize?​

optional onUnrealize: (self) => void | null

Defined in: packages/react/src/generated/jsx.ts:284

Emitted when the GdkSurface associated with widget is destroyed.

This means that Widget.unrealize has been called or the widget has been unmapped (that is, it is going to be hidden).

Inherited from​

WebKitWebViewBaseProps.onUnrealize

onUserMessageReceived?​

optional onUserMessageReceived: (message, self) => boolean | null

Defined in: packages/react/src/generated/jsx.ts:9611

This signal is emitted when a #WebKitUserMessage is received from the #WebKitWebPage corresponding to web_view. You can reply to the message using webkit_user_message_send_reply().

You can handle the user message asynchronously by calling g_object_ref() on message and returning %TRUE. If the last reference of message is removed and the message has not been replied to, the operation in the #WebKitWebPage will finish with error %WEBKIT_USER_MESSAGE_UNHANDLED_MESSAGE.

onWebProcessTerminated?​

optional onWebProcessTerminated: (reason, self) => void | null

Defined in: packages/react/src/generated/jsx.ts:9616

This signal is emitted when the web process terminates abnormally due to reason.

opacity?​

optional opacity: number

Defined in: packages/react/src/generated/jsx.ts:125

The requested opacity of the widget.

Inherited from​

WebKitWebViewBaseProps.opacity

overflow?​

optional overflow: Overflow

Defined in: packages/react/src/generated/jsx.ts:132

How content outside the widget's content area is treated.

This property is meant to be set by widget implementations, typically in their instance init function.

Inherited from​

WebKitWebViewBaseProps.overflow

receivesDefault?​

optional receivesDefault: boolean

Defined in: packages/react/src/generated/jsx.ts:134

Whether the widget will receive the default action when it is focused.

Inherited from​

WebKitWebViewBaseProps.receivesDefault

ref?​

optional ref: Ref<WebView>

Defined in: packages/react/src/generated/jsx.ts:9617

Overrides​

WebKitWebViewBaseProps.ref

relatedView?​

optional relatedView: WebView

Defined in: packages/react/src/generated/jsx.ts:9136

The related #WebKitWebView used when creating the view to share the same web process and network session. This property is not readable because the related web view is only valid during the object construction.

sensitive?​

optional sensitive: boolean

Defined in: packages/react/src/generated/jsx.ts:136

Whether the widget responds to input.

Inherited from​

WebKitWebViewBaseProps.sensitive

settings?​

optional settings: Settings

Defined in: packages/react/src/generated/jsx.ts:9138

The #WebKitSettings of the view.

tooltipMarkup?​

optional tooltipMarkup: string | null

Defined in: packages/react/src/generated/jsx.ts:152

Sets the text of tooltip to be the given string, which is marked up with Pango markup.

Also see Tooltip.set_markup.

This is a convenience property which will take care of getting the tooltip shown if the given string is not NULL: Widget.has-tooltip will automatically be set to true and there will be taken care of Widget.:query-tooltip in the default signal handler.

Note that if both Widget.tooltip-text and Widget.tooltip-markup are set, the last one wins.

Inherited from​

WebKitWebViewBaseProps.tooltipMarkup

tooltipText?​

optional tooltipText: string | null

Defined in: packages/react/src/generated/jsx.ts:167

Sets the text of tooltip to be the given string.

Also see Tooltip.set_text.

This is a convenience property which will take care of getting the tooltip shown if the given string is not NULL: Widget.has-tooltip will automatically be set to true and there will be taken care of Widget.:query-tooltip in the default signal handler.

Note that if both Widget.tooltip-text and Widget.tooltip-markup are set, the last one wins.

Inherited from​

WebKitWebViewBaseProps.tooltipText

userContentManager?​

optional userContentManager: UserContentManager

Defined in: packages/react/src/generated/jsx.ts:9140

The #WebKitUserContentManager of the view.

valign?​

optional valign: Align

Defined in: packages/react/src/generated/jsx.ts:169

How to distribute vertical space if widget gets extra space.

Inherited from​

WebKitWebViewBaseProps.valign

vexpand?​

optional vexpand: boolean

Defined in: packages/react/src/generated/jsx.ts:171

Whether to expand vertically.

Inherited from​

WebKitWebViewBaseProps.vexpand

vexpandSet?​

optional vexpandSet: boolean

Defined in: packages/react/src/generated/jsx.ts:173

Whether to use the vexpand property.

Inherited from​

WebKitWebViewBaseProps.vexpandSet

visible?​

optional visible: boolean

Defined in: packages/react/src/generated/jsx.ts:175

Whether the widget is visible.

Inherited from​

WebKitWebViewBaseProps.visible

webContext?​

optional webContext: WebContext

Defined in: packages/react/src/generated/jsx.ts:9142

The #WebKitWebContext of the view.

webExtensionMode?​

optional webExtensionMode: WebExtensionMode

Defined in: packages/react/src/generated/jsx.ts:9152

This configures web_view to treat the content as a WebExtension.

Note that this refers to the web standard WebExtensions and not WebKitWebExtensions.

In practice this limits the Content-Security-Policies that are allowed to be set. Some details can be found in Chrome's documentation.

websitePolicies?​

optional websitePolicies: WebsitePolicies

Defined in: packages/react/src/generated/jsx.ts:9154

The #WebKitWebsitePolicies for the view.

widthRequest?​

optional widthRequest: number

Defined in: packages/react/src/generated/jsx.ts:181

Overrides for width request of the widget.

If this is -1, the natural request will be used.

Inherited from​

WebKitWebViewBaseProps.widthRequest

zoomLevel?​

optional zoomLevel: number

Defined in: packages/react/src/generated/jsx.ts:9159

The zoom level of the #WebKitWebView content. See webkit_web_view_set_zoom_level() for more details.