GI.WebKit2.Objects.WebInspector

No description available in the introspection data.

Exported types

newtype WebInspector

Memory-managed wrapper type.

Constructors

WebInspector (ManagedPtr WebInspector)

Instances

Eq WebInspector

Defined in GI.WebKit2.Objects.WebInspector

Methods

(==) :: WebInspector -> WebInspector -> Bool

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

IsGValue WebInspector

Convert WebInspector to and from GValue with toGValue and fromGValue.

Defined in GI.WebKit2.Objects.WebInspector

Methods

toGValue :: WebInspector -> IO GValue

fromGValue :: GValue -> IO WebInspector

GObject WebInspector

Defined in GI.WebKit2.Objects.WebInspector

Methods

gobjectType :: IO GType

HasParentTypes WebInspector

Defined in GI.WebKit2.Objects.WebInspector

type ParentTypes WebInspector

Defined in GI.WebKit2.Objects.WebInspector

type ParentTypes WebInspector = '[Object]

class (GObject o, IsDescendantOf WebInspector o) => IsWebInspector o

Type class for types which can be safely cast to WebInspector, for instance with toWebInspector.

Instances

(GObject o, IsDescendantOf WebInspector o) => IsWebInspector o

Defined in GI.WebKit2.Objects.WebInspector

toWebInspector :: (MonadIO m, IsWebInspector o) => o -> m WebInspector

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

noWebInspector :: Maybe WebInspector

A convenience alias for Nothing :: Maybe WebInspector.

Methods

Overloaded methods

attach

webInspectorAttach

Arguments

:: (HasCallStack, MonadIO m, IsWebInspector a)

=> a

inspector: a WebInspector

-> m ()

Request inspector to be attached. The signal attach will be emitted. If the inspector is already attached it does nothing.

close

webInspectorClose

Arguments

:: (HasCallStack, MonadIO m, IsWebInspector a)

=> a

inspector: a WebInspector

-> m ()

Request inspector to be closed.

detach

webInspectorDetach

Arguments

:: (HasCallStack, MonadIO m, IsWebInspector a)

=> a

inspector: a WebInspector

-> m ()

Request inspector to be detached. The signal detach will be emitted. If the inspector is already detached it does nothing.

getAttachedHeight

webInspectorGetAttachedHeight

Arguments

:: (HasCallStack, MonadIO m, IsWebInspector a)

=> a

inspector: a WebInspector

-> m Word32

Returns: the height of the inspector view when attached

Get the height that the inspector view should have when it's attached. If the inspector view is not attached this returns 0.

getCanAttach

webInspectorGetCanAttach

Arguments

:: (HasCallStack, MonadIO m, IsWebInspector a)

=> a

inspector: a WebInspector

-> m Bool

Returns: True if there is enough room for the inspector view inside the window that contains the inspected view, or False otherwise.

Whether the inspector can be attached to the same window that contains the inspected view.

Since: 2.8

getInspectedUri

webInspectorGetInspectedUri

Arguments

:: (HasCallStack, MonadIO m, IsWebInspector a)

=> a

inspector: a WebInspector

-> m (Maybe Text)

Returns: the URI that is currently being inspected or Nothing

Get the URI that is currently being inspected. This can be Nothing if nothing has been loaded yet in the inspected view, if the inspector has been closed or when inspected view was loaded from a HTML string instead of a URI.

getWebView

webInspectorGetWebView

Arguments

:: (HasCallStack, MonadIO m, IsWebInspector a)

=> a

inspector: a WebInspector

-> m (Maybe WebViewBase)

Returns: the WebViewBase used to display the inspector or Nothing

Get the WebViewBase used to display the inspector. This might be Nothing if the inspector hasn't been loaded yet, or it has been closed.

isAttached

webInspectorIsAttached

Arguments

:: (HasCallStack, MonadIO m, IsWebInspector a)

=> a

inspector: a WebInspector

-> m Bool

Returns: True if inspector is currently attached or False otherwise

Whether the inspector view is currently attached to the same window that contains the inspected view.

show

webInspectorShow

Arguments

:: (HasCallStack, MonadIO m, IsWebInspector a)

=> a

inspector: a WebInspector

-> m ()

Request inspector to be shown.

Properties

attachedHeight

The height that the inspector view should have when it is attached.

getWebInspectorAttachedHeight :: (MonadIO m, IsWebInspector o) => o -> m Word32

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

get webInspector #attachedHeight

canAttach

Whether the inspector can be attached to the same window that contains the inspected view.

Since: 2.8

getWebInspectorCanAttach :: (MonadIO m, IsWebInspector o) => o -> m Bool

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

get webInspector #canAttach

inspectedUri

The URI that is currently being inspected.

getWebInspectorInspectedUri :: (MonadIO m, IsWebInspector o) => o -> m (Maybe Text)

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

get webInspector #inspectedUri

Signals

attach

type C_WebInspectorAttachCallback = Ptr () -> Ptr () -> IO CInt

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

type WebInspectorAttachCallback

Arguments

 = IO Bool

Returns: True to stop other handlers from being invoked for the event. False to propagate the event further.

Emitted when the inspector is requested to be attached to the window where the inspected web view is. If this signal is not handled the inspector view will be automatically attached to the inspected view, so you only need to handle this signal if you want to attach the inspector view yourself (for example, to add the inspector view to a browser tab).

To prevent the inspector view from being attached you can connect to this signal and simply return True.

afterWebInspectorAttach :: (IsWebInspector a, MonadIO m) => a -> WebInspectorAttachCallback -> m SignalHandlerId

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

after webInspector #attach callback

genClosure_WebInspectorAttach :: MonadIO m => WebInspectorAttachCallback -> m (GClosure C_WebInspectorAttachCallback)

Wrap the callback into a GClosure.

mk_WebInspectorAttachCallback :: C_WebInspectorAttachCallback -> IO (FunPtr C_WebInspectorAttachCallback)

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

noWebInspectorAttachCallback :: Maybe WebInspectorAttachCallback

A convenience synonym for Nothing :: Maybe WebInspectorAttachCallback.

onWebInspectorAttach :: (IsWebInspector a, MonadIO m) => a -> WebInspectorAttachCallback -> m SignalHandlerId

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

on webInspector #attach callback

wrap_WebInspectorAttachCallback :: WebInspectorAttachCallback -> C_WebInspectorAttachCallback

Wrap a WebInspectorAttachCallback into a C_WebInspectorAttachCallback.

bringToFront

type C_WebInspectorBringToFrontCallback = Ptr () -> Ptr () -> IO CInt

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

type WebInspectorBringToFrontCallback

Arguments

 = IO Bool

Returns: True to stop other handlers from being invoked for the event. False to propagate the event further.

Emitted when the inspector should be shown.

If the inspector is not attached the inspector window should be shown on top of any other windows. If the inspector is attached the inspector view should be made visible. For example, if the inspector view is attached using a tab in a browser window, the browser window should be raised and the tab containing the inspector view should be the active one. In both cases, if this signal is not handled, the default implementation calls windowPresent on the current toplevel Window of the inspector view.

afterWebInspectorBringToFront :: (IsWebInspector a, MonadIO m) => a -> WebInspectorBringToFrontCallback -> m SignalHandlerId

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

after webInspector #bringToFront callback

genClosure_WebInspectorBringToFront :: MonadIO m => WebInspectorBringToFrontCallback -> m (GClosure C_WebInspectorBringToFrontCallback)

Wrap the callback into a GClosure.

mk_WebInspectorBringToFrontCallback :: C_WebInspectorBringToFrontCallback -> IO (FunPtr C_WebInspectorBringToFrontCallback)

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

noWebInspectorBringToFrontCallback :: Maybe WebInspectorBringToFrontCallback

A convenience synonym for Nothing :: Maybe WebInspectorBringToFrontCallback.

onWebInspectorBringToFront :: (IsWebInspector a, MonadIO m) => a -> WebInspectorBringToFrontCallback -> m SignalHandlerId

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

on webInspector #bringToFront callback

wrap_WebInspectorBringToFrontCallback :: WebInspectorBringToFrontCallback -> C_WebInspectorBringToFrontCallback

Wrap a WebInspectorBringToFrontCallback into a C_WebInspectorBringToFrontCallback.

closed

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

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

type WebInspectorClosedCallback = IO ()

Emitted when the inspector page is closed. If you are using your own inspector window, you should connect to this signal and destroy your window.

afterWebInspectorClosed :: (IsWebInspector a, MonadIO m) => a -> WebInspectorClosedCallback -> m SignalHandlerId

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

after webInspector #closed callback

genClosure_WebInspectorClosed :: MonadIO m => WebInspectorClosedCallback -> m (GClosure C_WebInspectorClosedCallback)

Wrap the callback into a GClosure.

mk_WebInspectorClosedCallback :: C_WebInspectorClosedCallback -> IO (FunPtr C_WebInspectorClosedCallback)

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

noWebInspectorClosedCallback :: Maybe WebInspectorClosedCallback

A convenience synonym for Nothing :: Maybe WebInspectorClosedCallback.

onWebInspectorClosed :: (IsWebInspector a, MonadIO m) => a -> WebInspectorClosedCallback -> m SignalHandlerId

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

on webInspector #closed callback

wrap_WebInspectorClosedCallback :: WebInspectorClosedCallback -> C_WebInspectorClosedCallback

Wrap a WebInspectorClosedCallback into a C_WebInspectorClosedCallback.

detach

type C_WebInspectorDetachCallback = Ptr () -> Ptr () -> IO CInt

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

type WebInspectorDetachCallback

Arguments

 = IO Bool

Returns: True to stop other handlers from being invoked for the event. False to propagate the event further.

Emitted when the inspector is requested to be detached from the window it is currently attached to. The inspector is detached when the inspector page is about to be closed, and this signal is emitted right before closed, or when the user clicks on the detach button in the inspector view to show the inspector in a separate window. In this case the signal openWindow is emitted after this one.

To prevent the inspector view from being detached you can connect to this signal and simply return True.

afterWebInspectorDetach :: (IsWebInspector a, MonadIO m) => a -> WebInspectorDetachCallback -> m SignalHandlerId

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

after webInspector #detach callback

genClosure_WebInspectorDetach :: MonadIO m => WebInspectorDetachCallback -> m (GClosure C_WebInspectorDetachCallback)

Wrap the callback into a GClosure.

mk_WebInspectorDetachCallback :: C_WebInspectorDetachCallback -> IO (FunPtr C_WebInspectorDetachCallback)

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

noWebInspectorDetachCallback :: Maybe WebInspectorDetachCallback

A convenience synonym for Nothing :: Maybe WebInspectorDetachCallback.

onWebInspectorDetach :: (IsWebInspector a, MonadIO m) => a -> WebInspectorDetachCallback -> m SignalHandlerId

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

on webInspector #detach callback

wrap_WebInspectorDetachCallback :: WebInspectorDetachCallback -> C_WebInspectorDetachCallback

Wrap a WebInspectorDetachCallback into a C_WebInspectorDetachCallback.

openWindow

type C_WebInspectorOpenWindowCallback = Ptr () -> Ptr () -> IO CInt

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

type WebInspectorOpenWindowCallback

Arguments

 = IO Bool

Returns: True to stop other handlers from being invoked for the event. False to propagate the event further.

Emitted when the inspector is requested to open in a separate window. If this signal is not handled, a Window with the inspector will be created and shown, so you only need to handle this signal if you want to use your own window. This signal is emitted after detach to show the inspector in a separate window after being detached.

To prevent the inspector from being shown you can connect to this signal and simply return True

afterWebInspectorOpenWindow :: (IsWebInspector a, MonadIO m) => a -> WebInspectorOpenWindowCallback -> m SignalHandlerId

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

after webInspector #openWindow callback

genClosure_WebInspectorOpenWindow :: MonadIO m => WebInspectorOpenWindowCallback -> m (GClosure C_WebInspectorOpenWindowCallback)

Wrap the callback into a GClosure.

mk_WebInspectorOpenWindowCallback :: C_WebInspectorOpenWindowCallback -> IO (FunPtr C_WebInspectorOpenWindowCallback)

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

noWebInspectorOpenWindowCallback :: Maybe WebInspectorOpenWindowCallback

A convenience synonym for Nothing :: Maybe WebInspectorOpenWindowCallback.

onWebInspectorOpenWindow :: (IsWebInspector a, MonadIO m) => a -> WebInspectorOpenWindowCallback -> m SignalHandlerId

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

on webInspector #openWindow callback

wrap_WebInspectorOpenWindowCallback :: WebInspectorOpenWindowCallback -> C_WebInspectorOpenWindowCallback

Wrap a WebInspectorOpenWindowCallback into a C_WebInspectorOpenWindowCallback.