Struct xpcom::interfaces::nsIImageLoadingContent

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

interface nsIImageLoadingContent : imgINotificationObserver

/**
 * This interface represents a content node that loads images.  The interface
 * exists to allow getting information on the images that the content node
 * loads and to allow registration of observers for the image loads.
 *
 * Implementors of this interface should handle all the mechanics of actually
 * loading an image -- getting the URI, checking with content policies and
 * the security manager to see whether loading the URI is allowed, performing
 * the load, firing any DOM events as needed.
 *
 * An implementation of this interface may support the concepts of a
 * "current" image and a "pending" image.  If it does, a request to change
 * the currently loaded image will start a "pending" request which will
 * become current only when the image is loaded.  It is the responsibility of
 * observers to check which request they are getting notifications for.
 *
 * Please make sure to update the MozImageLoadingContent WebIDL
 * interface to mirror this interface when changing it.
 */

Methods

impl nsIImageLoadingContent

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

Cast this nsIImageLoadingContent to one of its base interfaces.

impl nsIImageLoadingContent

pub const UNKNOWN_REQUEST: i64

UNKNOWN_REQUEST: i64 = -1

/**
   * Request types.  Image loading content nodes attempt to do atomic
   * image changes when the image url is changed.  This means that
   * when the url changes the new image load will start, but the old
   * image will remain the "current" request until the new image is
   * fully loaded.  At that point, the old "current" request will be
   * discarded and the "pending" request will become "current".
   */

pub const CURRENT_REQUEST: i64

CURRENT_REQUEST: i64 = 0

pub const PENDING_REQUEST: i64

PENDING_REQUEST: i64 = 1

pub unsafe fn GetLoadingEnabled(&self, aLoadingEnabled: *mut bool) -> nsresult

/**
   * loadingEnabled is used to enable and disable loading in
   * situations where loading images is unwanted.  Note that enabling
   * loading will *not* automatically trigger an image load.
   */

attribute boolean loadingEnabled;

pub unsafe fn SetLoadingEnabled(&self, aLoadingEnabled: bool) -> nsresult

/**
   * loadingEnabled is used to enable and disable loading in
   * situations where loading images is unwanted.  Note that enabling
   * loading will *not* automatically trigger an image load.
   */

attribute boolean loadingEnabled;

pub unsafe fn GetImageBlockingStatus(
    &self,
    aImageBlockingStatus: *mut int16_t
) -> nsresult

/**
   * Returns the image blocking status (@see nsIContentPolicy).  This
   * will always be an nsIContentPolicy REJECT_* status for cases when
   * the image was blocked.  This status always refers to the
   * CURRENT_REQUEST load.
   */

readonly attribute short imageBlockingStatus;

pub unsafe fn AddNativeObserver(
    &self,
    aObserver: *const imgINotificationObserver
) -> nsresult

/**
   * Used to register an image decoder observer.  Typically, this will
   * be a proxy for a frame that wants to paint the image.
   * Notifications from ongoing image loads will be passed to all
   * registered observers.  Notifications for all request types,
   * current and pending, will be passed through.
   *
   * @param aObserver the observer to register
   *
   * @throws NS_ERROR_OUT_OF_MEMORY
   */

[notxpcom] nsresult addNativeObserver (in imgINotificationObserver aObserver);

pub unsafe fn RemoveNativeObserver(
    &self,
    aObserver: *const imgINotificationObserver
) -> nsresult

/**
   * Used to unregister an image decoder observer.
   *
   * @param aObserver the observer to unregister
   */

[notxpcom] nsresult removeNativeObserver (in imgINotificationObserver aObserver);

pub unsafe fn AddObserver(
    &self,
    aObserver: *const imgINotificationObserver
) -> nsresult

/**
   * Same as addNativeObserver but intended for scripted observers or observers
   * from another or without a document.
   */

void addObserver (in imgINotificationObserver aObserver);

pub unsafe fn RemoveObserver(
    &self,
    aObserver: *const imgINotificationObserver
) -> nsresult

/**
   * Same as removeNativeObserver but intended for scripted observers or
   * observers from another or without a document.
   */

void removeObserver (in imgINotificationObserver aObserver);

pub unsafe fn GetRequest(
    &self,
    aRequestType: int32_t,
    _retval: *mut *const imgIRequest
) -> nsresult

/**
   * Accessor to get the image requests
   *
   * @param aRequestType a value saying which request is wanted
   *
   * @return the imgIRequest object (may be null, even when no error
   * is thrown)
   *
   * @throws NS_ERROR_UNEXPECTED if the request type requested is not
   * known
   */

imgIRequest getRequest (in long aRequestType);

pub unsafe fn SetBlockedRequest(&self, aContentDecision: int16_t) -> nsresult

/**
   * Call this function when the request was blocked by any of the
   * security policies enforced.
   *
   * @param aContentDecision the decision returned from nsIContentPolicy
   *                         (any of the types REJECT_*)
   */

void setBlockedRequest (in int16_t aContentDecision);

pub unsafe fn CurrentRequestHasSize(&self) -> bool

/**
   * @return true if the current request's size is available.
   */

[noscript,notxpcom] boolean currentRequestHasSize ();

pub unsafe fn GetRequestType(
    &self,
    aRequest: *const imgIRequest,
    _retval: *mut int32_t
) -> nsresult

/**
   * Used to find out what type of request one is dealing with (eg
   * which request got passed through to the imgINotificationObserver
   * interface of an observer)
   *
   * @param aRequest the request whose type we want to know
   *
   * @return an enum value saying what type this request is
   *
   * @throws NS_ERROR_UNEXPECTED if aRequest is not known
   */

long getRequestType (in imgIRequest aRequest);

pub unsafe fn GetCurrentURI(&self, aCurrentURI: *mut *const nsIURI) -> nsresult

/**
   * Gets the URI of the current request, if available.
   * Otherwise, returns the last URI that this content tried to load, or
   * null if there haven't been any such attempts.
   */

readonly attribute nsIURI currentURI;

pub unsafe fn LoadImageWithChannel(
    &self,
    aChannel: *const nsIChannel,
    _retval: *mut *const nsIStreamListener
) -> nsresult

/**
   * loadImageWithChannel allows data from an existing channel to be
   * used as the image data for this content node.
   *
   * @param aChannel the channel that will deliver the data
   *
   * @return a stream listener to pump the image data into
   *
   * @see imgILoader::loadImageWithChannel
   *
   * @throws NS_ERROR_NULL_POINTER if aChannel is null
   */

nsIStreamListener loadImageWithChannel (in nsIChannel aChannel);

pub unsafe fn ForceImageState(&self, aForce: bool, aState: uint64_t) -> nsresult

/**
   * Enables/disables image state forcing. When |aForce| is PR_TRUE, we force
   * nsImageLoadingContent::ImageState() to return |aState|. Call again with |aForce|
   * as PR_FALSE to revert ImageState() to its original behaviour.
   */

void forceImageState (in boolean aForce, in unsigned long long aState);

pub unsafe fn GetNaturalWidth(&self, aNaturalWidth: *mut uint32_t) -> nsresult

/**
   * The intrinsic size and width of this content. May differ from actual image
   * size due to things like responsive image density.
   */

readonly attribute unsigned long naturalWidth;

pub unsafe fn GetNaturalHeight(&self, aNaturalHeight: *mut uint32_t) -> nsresult

readonly attribute unsigned long naturalHeight;

Methods from Deref<Target = imgINotificationObserver>

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

Cast this imgINotificationObserver to one of its base interfaces.

pub const SIZE_AVAILABLE: i64

pub const FRAME_UPDATE: i64

pub const FRAME_COMPLETE: i64

pub const LOAD_COMPLETE: i64

pub const DECODE_COMPLETE: i64

pub const DISCARD: i64

pub const UNLOCKED_DRAW: i64

pub const IS_ANIMATED: i64

pub const HAS_TRANSPARENCY: i64

Trait Implementations

impl XpCom for nsIImageLoadingContent

const IID: nsIID

IID: nsIID = nsID(56037949, 37412, 19730, [164, 126, 134, 140, 50, 104, 151, 119])

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 nsIImageLoadingContent

unsafe fn addref(&self)

Increment the reference count.

unsafe fn release(&self)

Decrement the reference count, potentially freeing backing memory.

impl Deref for nsIImageLoadingContent

type Target = imgINotificationObserver

The resulting type after dereferencing.

fn deref(&self) -> &imgINotificationObserver

Dereferences the value.