Struct xpcom::interfaces::nsIFrameLoader

#[repr(C)]
pub struct nsIFrameLoader { /* fields omitted */ }

interface nsIFrameLoader : nsISupports

Methods

impl nsIFrameLoader

pub fn coerce<T: nsIFrameLoaderCoerce>(&self) -> &T

Cast this nsIFrameLoader to one of its base interfaces.

impl nsIFrameLoader

pub const EVENT_MODE_NORMAL_DISPATCH: i64

EVENT_MODE_NORMAL_DISPATCH: i64 = 0

/**
   * The default event mode automatically forwards the events
   * handled in EventStateManager::HandleCrossProcessEvent to
   * the child content process when these events are targeted to
   * the remote browser element.
   *
   * Used primarly for input events (mouse, keyboard)
   */

pub const EVENT_MODE_DONT_FORWARD_TO_CHILD: i64

EVENT_MODE_DONT_FORWARD_TO_CHILD: i64 = 1

/**
   * With this event mode, it's the application's responsability to
   * convert and forward events to the content process
   */

pub unsafe fn GetDocShell(&self, aDocShell: *mut *const nsIDocShell) -> nsresult

/**
   * Get the docshell from the frame loader.
   */

readonly attribute nsIDocShell docShell;

pub unsafe fn GetTabParent(
    &self,
    aTabParent: *mut *const nsITabParent
) -> nsresult

/**
   * Get this frame loader's TabParent, if it has a remote frame.  Otherwise,
   * returns null.
   */

readonly attribute nsITabParent tabParent;

pub unsafe fn GetLoadContext(
    &self,
    aLoadContext: *mut *const nsILoadContext
) -> nsresult

/**
   * Get an nsILoadContext for the top-level docshell. For remote
   * frames, a shim is returned that contains private browsing and app
   * information.
   */

readonly attribute nsILoadContext loadContext;

pub unsafe fn LoadFrame(&self) -> nsresult

/**
   * Start loading the frame. This method figures out what to load
   * from the owner content in the frame loader.
   */

void loadFrame ();

pub unsafe fn LoadURI(&self, aURI: *const nsIURI) -> nsresult

/**
   * Loads the specified URI in this frame. Behaves identically to loadFrame,
   * except that this method allows specifying the URI to load.
   */

void loadURI (in nsIURI aURI);

pub unsafe fn SetIsPrerendered(&self) -> nsresult

/**
   * Puts the frameloader in prerendering mode.
   */

void setIsPrerendered ();

pub unsafe fn MakePrerenderedLoaderActive(&self) -> nsresult

/**
   * Make the prerendered frameloader being active (and clear isPrerendered flag).
   */

void makePrerenderedLoaderActive ();

pub unsafe fn AppendPartialSHistoryAndSwap(
    &self,
    aOther: *const nsIFrameLoader,
    _retval: *mut *const nsISupports
) -> nsresult

/**
   * Append partial session history from another frame loader.
   *
   * @return A promise which will be resolved when the navigation is complete.
   */

nsISupports appendPartialSHistoryAndSwap (in nsIFrameLoader aOther);

pub unsafe fn RequestGroupedHistoryNavigation(
    &self,
    aGlobalIndex: uint32_t,
    _retval: *mut *const nsISupports
) -> nsresult

/**
   * If grouped session history is applied, use this function to navigate to
   * an entry of session history object of another frameloader.
   *
   * @return A promise which will be resolved when the navigation is complete.
   */

nsISupports requestGroupedHistoryNavigation (in unsigned long aGlobalIndex);

pub unsafe fn Destroy(&self) -> nsresult

/**
   * Destroy the frame loader and everything inside it. This will
   * clear the weak owner content reference.
   */

void destroy ();

pub unsafe fn GetDepthTooGreat(&self, aDepthTooGreat: *mut bool) -> nsresult

/**
   * Find out whether the loader's frame is at too great a depth in
   * the frame tree.  This can be used to decide what operations may
   * or may not be allowed on the loader's docshell.
   */

readonly attribute boolean depthTooGreat;

pub unsafe fn ActivateRemoteFrame(&self) -> nsresult

/**
   * Activate remote frame.
   * Throws an exception with non-remote frames.
   */

void activateRemoteFrame ();

pub unsafe fn DeactivateRemoteFrame(&self) -> nsresult

/**
   * Deactivate remote frame.
   * Throws an exception with non-remote frames.
   */

void deactivateRemoteFrame ();

pub unsafe fn SendCrossProcessMouseEvent(
    &self,
    aType: &nsAString,
    aX: c_float,
    aY: c_float,
    aButton: int32_t,
    aClickCount: int32_t,
    aModifiers: int32_t,
    aIgnoreRootScrollFrame: bool
) -> nsresult

/**
   * @see nsIDOMWindowUtils sendMouseEvent.
   */

void sendCrossProcessMouseEvent (in AString aType, in float aX, in float aY, in long aButton, in long aClickCount, in long aModifiers, [optional] in boolean aIgnoreRootScrollFrame);

pub unsafe fn ActivateFrameEvent(
    &self,
    aType: &nsAString,
    capture: bool
) -> nsresult

/**
   * Activate event forwarding from client (remote frame) to parent.
   */

void activateFrameEvent (in AString aType, in boolean capture);

pub unsafe fn GetMessageManager(
    &self,
    aMessageManager: *mut *const nsIMessageSender
) -> nsresult

readonly attribute nsIMessageSender messageManager;

pub unsafe fn SendCrossProcessKeyEvent(
    &self,
    aType: &nsAString,
    aKeyCode: int32_t,
    aCharCode: int32_t,
    aModifiers: int32_t,
    aPreventDefault: bool
) -> nsresult

/**
   * @see nsIDOMWindowUtils sendKeyEvent.
   */

void sendCrossProcessKeyEvent (in AString aType, in long aKeyCode, in long aCharCode, in long aModifiers, [optional] in boolean aPreventDefault);

pub unsafe fn RequestNotifyAfterRemotePaint(&self) -> nsresult

/**
   * Request that the next time a remote layer transaction has been
   * received by the Compositor, a MozAfterRemoteFrame event be sent
   * to the window.
   */

void requestNotifyAfterRemotePaint ();

pub unsafe fn RequestFrameLoaderClose(&self) -> nsresult

/**
   * Close the window through the ownerElement.
   */

void requestFrameLoaderClose ();

pub unsafe fn Print(
    &self,
    aOuterWindowID: uint64_t,
    aPrintSettings: *const nsIPrintSettings,
    aProgressListener: *const nsIWebProgressListener
) -> nsresult

/**
   * Print the current document.
   *
   * @param aOuterWindowID the ID of the outer window to print
   * @param aPrintSettings optional print settings to use; printSilent can be
   *                       set to prevent prompting.
   * @param aProgressListener optional print progress listener.
   */

void print (in unsigned long long aOuterWindowID, in nsIPrintSettings aPrintSettings, in nsIWebProgressListener aProgressListener);

pub unsafe fn EnsureGroupedSHistory(
    &self,
    _retval: *mut *const nsIGroupedSHistory
) -> nsresult

/**
   * Ensure that the current nsIFrameLoader has a GroupedSHistory.
   */

nsIGroupedSHistory ensureGroupedSHistory ();

pub unsafe fn GetEventMode(&self, aEventMode: *mut uint32_t) -> nsresult

attribute unsigned long eventMode;

pub unsafe fn SetEventMode(&self, aEventMode: uint32_t) -> nsresult

attribute unsigned long eventMode;

pub unsafe fn GetClipSubdocument(&self, aClipSubdocument: *mut bool) -> nsresult

/**
   * If false, then the subdocument is not clipped to its CSS viewport, and the
   * subdocument's viewport scrollbar(s) are not rendered.
   * Defaults to true.
   */

attribute boolean clipSubdocument;

pub unsafe fn SetClipSubdocument(&self, aClipSubdocument: bool) -> nsresult

/**
   * If false, then the subdocument is not clipped to its CSS viewport, and the
   * subdocument's viewport scrollbar(s) are not rendered.
   * Defaults to true.
   */

attribute boolean clipSubdocument;

pub unsafe fn GetClampScrollPosition(
    &self,
    aClampScrollPosition: *mut bool
) -> nsresult

/**
   * If false, then the subdocument's scroll coordinates will not be clamped
   * to their scroll boundaries.
   * Defaults to true.
   */

attribute boolean clampScrollPosition;

pub unsafe fn SetClampScrollPosition(
    &self,
    aClampScrollPosition: bool
) -> nsresult

/**
   * If false, then the subdocument's scroll coordinates will not be clamped
   * to their scroll boundaries.
   * Defaults to true.
   */

attribute boolean clampScrollPosition;

pub unsafe fn GetOwnerElement(
    &self,
    aOwnerElement: *mut *const nsIDOMElement
) -> nsresult

/**
   * The element which owns this frame loader.
   *
   * For example, if this is a frame loader for an <iframe>, this attribute
   * returns the iframe element.
   */

readonly attribute nsIDOMElement ownerElement;

pub unsafe fn GetChildID(&self, aChildID: *mut uint64_t) -> nsresult

/**
   * Cached childID of the ContentParent owning the TabParent in this frame
   * loader. This can be used to obtain the childID after the TabParent died.
   */

readonly attribute unsigned long long childID;

pub unsafe fn GetOwnerIsMozBrowserFrame(
    &self,
    aOwnerIsMozBrowserFrame: *mut bool
) -> nsresult

/**
   * Find out whether the owner content really is a mozbrowser. <xul:browser>
   * is not considered to be a mozbrowser frame.
   */

readonly attribute boolean ownerIsMozBrowserFrame;

pub unsafe fn GetLazyWidth(&self, aLazyWidth: *mut uint32_t) -> nsresult

/**
   * The last known width of the frame. Reading this property will not trigger
   * a reflow, and therefore may not reflect the current state of things. It
   * should only be used in asynchronous APIs where values are not guaranteed
   * to be up-to-date when received.
   */

readonly attribute unsigned long lazyWidth;

pub unsafe fn GetLazyHeight(&self, aLazyHeight: *mut uint32_t) -> nsresult

/**
   * The last known height of the frame. Reading this property will not trigger
   * a reflow, and therefore may not reflect the current state of things. It
   * should only be used in asynchronous APIs where values are not guaranteed
   * to be up-to-date when received.
   */

readonly attribute unsigned long lazyHeight;

pub unsafe fn GetPartialSHistory(
    &self,
    aPartialSHistory: *mut *const nsIPartialSHistory
) -> nsresult

/**
   * The partial session history.
   */

readonly attribute nsIPartialSHistory partialSHistory;

pub unsafe fn GetGroupedSHistory(
    &self,
    aGroupedSHistory: *mut *const nsIGroupedSHistory
) -> nsresult

/**
   * The grouped session history composed of multiple session history objects
   * across root docshells.
   */

readonly attribute nsIGroupedSHistory groupedSHistory;

pub unsafe fn GetIsDead(&self) -> bool

/**
   * Is `true` if the frameloader is dead (destroy has been called on it)
   */

[infallible] readonly attribute boolean isDead;

Methods from Deref<Target = nsISupports>

pub fn coerce<T: nsISupportsCoerce>(&self) -> &T

Cast this nsISupports to one of its base interfaces.

pub unsafe fn QueryInterface(
    &self,
    uuid: &nsIID,
    result: *mut *mut c_void
) -> nsresult

void QueryInterface (in nsIIDRef uuid, [iid_is (uuid), retval] out nsQIResult result);

pub unsafe fn AddRef(&self) -> nsrefcnt

[noscript,notxpcom] nsrefcnt AddRef ();

pub unsafe fn Release(&self) -> nsrefcnt

[noscript,notxpcom] nsrefcnt Release ();

Trait Implementations

impl XpCom for nsIFrameLoader

const IID: nsIID

IID: nsIID = nsID(373665540, 7111, 17251, [143, 44, 235, 150, 121, 34, 10, 177])

fn query_interface<T: XpCom>(&self) -> Option<RefPtr<T>>

Perform a QueryInterface call on this object, attempting to dynamically cast it to the requested interface type. Returns Some(RefPtr) if the cast succeeded, and None otherwise.

impl RefCounted for nsIFrameLoader

unsafe fn addref(&self)

Increment the reference count.

unsafe fn release(&self)

Decrement the reference count, potentially freeing backing memory.

impl Deref for nsIFrameLoader

type Target = nsISupports

The resulting type after dereferencing.

fn deref(&self) -> &nsISupports

Dereferences the value.