/*

 * DO NOT EDIT.  THIS FILE IS GENERATED FROM /src/mozilla-central/image/imgIContainer.idl

 */

#ifndef __gen_imgIContainer_h__

#define __gen_imgIContainer_h__

#ifndef __gen_nsISupports_h__

#include "nsISupports.h"

#endif

#include "mozilla/AlreadyAddRefed.h"

#include "mozilla/Assertions.h"

#include "mozilla/DebugOnly.h"

/* For IDL files that don't want to include root IDL files. */

#ifndef NS_NO_VTABLE

#define NS_NO_VTABLE

#endif

#include "ImgDrawResult.h"

#include "gfxContext.h"

#include "gfxMatrix.h"

#include "gfxRect.h"

#include "mozilla/gfx/2D.h"

#include "mozilla/Maybe.h"

#include "mozilla/RefPtr.h"

#include "nsRect.h"

#include "nsSize.h"

#include "limits.h"

class nsIDocument;

namespace mozilla {

namespace layers {

class LayerManager;

class ImageContainer;

}

}

class nsIFrame;

namespace mozilla {

class TimeStamp;

class SVGImageContext;

}

namespace mozilla {

namespace image {

class ImageRegion;

struct Orientation;

}

}

/* starting interface:    imgIContainer */

#define IMGICONTAINER_IID_STR "a8dbee24-ff86-4755-b40e-51175caf31af"

#define IMGICONTAINER_IID \

  {0xa8dbee24, 0xff86, 0x4755, \

    { 0xb4, 0x0e, 0x51, 0x17, 0x5c, 0xaf, 0x31, 0xaf }}

class imgIContainer : public nsISupports {

 public:

  NS_DECLARE_STATIC_IID_ACCESSOR(IMGICONTAINER_IID)

  /* readonly attribute int32_t width; */

  NS_IMETHOD GetWidth(int32_t *aWidth) = 0;

  /* readonly attribute int32_t height; */

  NS_IMETHOD GetHeight(int32_t *aHeight) = 0;

  /* [noscript] readonly attribute nsSize intrinsicSize; */

  NS_IMETHOD GetIntrinsicSize(nsSize * aIntrinsicSize) = 0;

  /* [noscript] readonly attribute nsSize intrinsicRatio; */

  NS_IMETHOD GetIntrinsicRatio(nsSize * aIntrinsicRatio) = 0;

  /* [nostdcall,notxpcom] nsIntSizeByVal optimalImageSizeForDest ([const] in gfxSize aDest, in uint32_t aWhichFrame, in SamplingFilter aSamplingFilter, in uint32_t aFlags); */

  virtual nsIntSize OptimalImageSizeForDest(const gfxSize & aDest, uint32_t aWhichFrame, mozilla::gfx::SamplingFilter aSamplingFilter, uint32_t aFlags) = 0;

  enum {

    TYPE_RASTER = 0U,

    TYPE_VECTOR = 1U

  };

  /* [infallible] readonly attribute unsigned short type; */

  NS_IMETHOD GetType(uint16_t *aType) = 0;

  inline uint16_t GetType()

  {

    uint16_t result;

    mozilla::DebugOnly<nsresult> rv = GetType(&result);

    MOZ_ASSERT(NS_SUCCEEDED(rv));

    return result;

  }

  /* readonly attribute boolean animated; */

  NS_IMETHOD GetAnimated(bool *aAnimated) = 0;

  enum {

    FLAG_NONE = 0U,

    FLAG_SYNC_DECODE = 1U,

    FLAG_SYNC_DECODE_IF_FAST = 2U,

    FLAG_ASYNC_NOTIFY = 4U,

    FLAG_DECODE_NO_PREMULTIPLY_ALPHA = 8U,

    FLAG_DECODE_NO_COLORSPACE_CONVERSION = 16U,

    FLAG_CLAMP = 32U,

    FLAG_HIGH_QUALITY_SCALING = 64U,

    FLAG_WANT_DATA_SURFACE = 128U,

    FLAG_BYPASS_SURFACE_CACHE = 256U,

    FLAG_FORCE_PRESERVEASPECTRATIO_NONE = 512U,

    FLAG_FORCE_UNIFORM_SCALING = 1024U,

    DECODE_FLAGS_DEFAULT = 0U,

    FRAME_FIRST = 0U,

    FRAME_CURRENT = 1U,

    FRAME_MAX_VALUE = 1U

  };

  /* [noscript,notxpcom] TempRefSourceSurface getFrame (in uint32_t aWhichFrame, in uint32_t aFlags); */

  NS_IMETHOD_(already_AddRefed<mozilla::gfx::SourceSurface>) GetFrame(uint32_t aWhichFrame, uint32_t aFlags) = 0;

  /* [noscript,notxpcom] TempRefSourceSurface getFrameAtSize ([const] in nsIntSize aSize, in uint32_t aWhichFrame, in uint32_t aFlags); */

  NS_IMETHOD_(already_AddRefed<mozilla::gfx::SourceSurface>) GetFrameAtSize(const nsIntSize & aSize, uint32_t aWhichFrame, uint32_t aFlags) = 0;

  /* [noscript,notxpcom] boolean willDrawOpaqueNow (); */

  NS_IMETHOD_(bool) WillDrawOpaqueNow(void) = 0;

  /* [noscript,notxpcom] boolean isImageContainerAvailable (in LayerManager aManager, in uint32_t aFlags); */

  NS_IMETHOD_(bool) IsImageContainerAvailable(mozilla::layers::LayerManager * aManager, uint32_t aFlags) = 0;

  /* [noscript,notxpcom] TempRefImageContainer getImageContainer (in LayerManager aManager, in uint32_t aFlags); */

  NS_IMETHOD_(already_AddRefed<mozilla::layers::ImageContainer>) GetImageContainer(mozilla::layers::LayerManager * aManager, uint32_t aFlags) = 0;

  /* [noscript,notxpcom] ImgDrawResult getImageContainerAtSize (in LayerManager aManager, [const] in nsIntSize aSize, [const] in MaybeSVGImageContext aSVGContext, in uint32_t aFlags, out ImageContainer aOutContainer); */

  NS_IMETHOD_(mozilla::image::ImgDrawResult) GetImageContainerAtSize(mozilla::layers::LayerManager * aManager, const nsIntSize & aSize, const mozilla::Maybe<mozilla::SVGImageContext> & aSVGContext, uint32_t aFlags, mozilla::layers::ImageContainer * * aOutContainer) = 0;

  /* [noscript,notxpcom] boolean isImageContainerAvailableAtSize (in LayerManager aManager, [const] in nsIntSize aSize, in uint32_t aFlags); */

  NS_IMETHOD_(bool) IsImageContainerAvailableAtSize(mozilla::layers::LayerManager * aManager, const nsIntSize & aSize, uint32_t aFlags) = 0;

  /* [noscript,notxpcom] ImgDrawResult draw (in gfxContext aContext, [const] in nsIntSize aSize, [const] in ImageRegion aRegion, in uint32_t aWhichFrame, in SamplingFilter aSamplingFilter, [const] in MaybeSVGImageContext aSVGContext, in uint32_t aFlags, in float aOpacity); */

  NS_IMETHOD_(mozilla::image::ImgDrawResult) Draw(gfxContext * aContext, const nsIntSize & aSize, const mozilla::image::ImageRegion & aRegion, uint32_t aWhichFrame, mozilla::gfx::SamplingFilter aSamplingFilter, const mozilla::Maybe<mozilla::SVGImageContext> & aSVGContext, uint32_t aFlags, float aOpacity) = 0;

  /* [noscript] void startDecoding (in uint32_t aFlags); */

  NS_IMETHOD StartDecoding(uint32_t aFlags) = 0;

  /* [noscript,notxpcom] boolean startDecodingWithResult (in uint32_t aFlags); */

  NS_IMETHOD_(bool) StartDecodingWithResult(uint32_t aFlags) = 0;

  /* [noscript] void requestDecodeForSize ([const] in nsIntSize aSize, in uint32_t aFlags); */

  NS_IMETHOD RequestDecodeForSize(const nsIntSize & aSize, uint32_t aFlags) = 0;

  /* void lockImage (); */

  NS_IMETHOD LockImage(void) = 0;

  /* void unlockImage (); */

  NS_IMETHOD UnlockImage(void) = 0;

  /* void requestDiscard (); */

  NS_IMETHOD RequestDiscard(void) = 0;

  /* [notxpcom] void requestRefresh ([const] in TimeStamp aTime); */

  NS_IMETHOD_(void) RequestRefresh(const mozilla::TimeStamp & aTime) = 0;

  enum {

    kNormalAnimMode = 0,

    kDontAnimMode = 1,

    kLoopOnceAnimMode = 2

  };

  /* attribute unsigned short animationMode; */

  NS_IMETHOD GetAnimationMode(uint16_t *aAnimationMode) = 0;

  NS_IMETHOD SetAnimationMode(uint16_t aAnimationMode) = 0;

  /* void resetAnimation (); */

  NS_IMETHOD ResetAnimation(void) = 0;

  /* [notxpcom] float getFrameIndex (in uint32_t aWhichFrame); */

  NS_IMETHOD_(float) GetFrameIndex(uint32_t aWhichFrame) = 0;

  /* [notxpcom] Orientation getOrientation (); */

  NS_IMETHOD_(mozilla::image::Orientation) GetOrientation(void) = 0;

  /* [notxpcom] int32_t getFirstFrameDelay (); */

  NS_IMETHOD_(int32_t) GetFirstFrameDelay(void) = 0;

  /* [notxpcom] void setAnimationStartTime ([const] in TimeStamp aTime); */

  NS_IMETHOD_(void) SetAnimationStartTime(const mozilla::TimeStamp & aTime) = 0;

  /* [notxpcom] nsIntRectByVal getImageSpaceInvalidationRect ([const] in nsIntRect aRect); */

  NS_IMETHOD_(nsIntRect) GetImageSpaceInvalidationRect(const nsIntRect & aRect) = 0;

  /* [nostdcall,notxpcom] TempRefImgIContainer unwrap (); */

  virtual already_AddRefed<imgIContainer> Unwrap(void) = 0;

  /* [noscript,notxpcom] void propagateUseCounters (in nsIDocument aDocument); */

  NS_IMETHOD_(void) PropagateUseCounters(nsIDocument * aDocument) = 0;

   /*

   * Get the set of sizes the image can decode to natively.

   */

  virtual nsresult GetNativeSizes(nsTArray<nsIntSize>& aNativeSizes) const = 0;

  virtual size_t GetNativeSizesLength() const = 0;

  };

  NS_DEFINE_STATIC_IID_ACCESSOR(imgIContainer, IMGICONTAINER_IID)

/* Use this macro when declaring classes that implement this interface. */

#define NS_DECL_IMGICONTAINER \

  NS_IMETHOD GetWidth(int32_t *aWidth) override; \

  NS_IMETHOD GetHeight(int32_t *aHeight) override; \

  NS_IMETHOD GetIntrinsicSize(nsSize * aIntrinsicSize) override; \

  NS_IMETHOD GetIntrinsicRatio(nsSize * aIntrinsicRatio) override; \

  virtual nsIntSize OptimalImageSizeForDest(const gfxSize & aDest, uint32_t aWhichFrame, mozilla::gfx::SamplingFilter aSamplingFilter, uint32_t aFlags) override; \

  using imgIContainer::GetType; \

  NS_IMETHOD GetType(uint16_t *aType) override; \

  NS_IMETHOD GetAnimated(bool *aAnimated) override; \

  NS_IMETHOD_(already_AddRefed<mozilla::gfx::SourceSurface>) GetFrame(uint32_t aWhichFrame, uint32_t aFlags) override; \

  NS_IMETHOD_(already_AddRefed<mozilla::gfx::SourceSurface>) GetFrameAtSize(const nsIntSize & aSize, uint32_t aWhichFrame, uint32_t aFlags) override; \

  NS_IMETHOD_(bool) WillDrawOpaqueNow(void) override; \

  NS_IMETHOD_(bool) IsImageContainerAvailable(mozilla::layers::LayerManager * aManager, uint32_t aFlags) override; \

  NS_IMETHOD_(already_AddRefed<mozilla::layers::ImageContainer>) GetImageContainer(mozilla::layers::LayerManager * aManager, uint32_t aFlags) override; \

  NS_IMETHOD_(mozilla::image::ImgDrawResult) GetImageContainerAtSize(mozilla::layers::LayerManager * aManager, const nsIntSize & aSize, const mozilla::Maybe<mozilla::SVGImageContext> & aSVGContext, uint32_t aFlags, mozilla::layers::ImageContainer * * aOutContainer) override; \

  NS_IMETHOD_(bool) IsImageContainerAvailableAtSize(mozilla::layers::LayerManager * aManager, const nsIntSize & aSize, uint32_t aFlags) override; \

  NS_IMETHOD_(mozilla::image::ImgDrawResult) Draw(gfxContext * aContext, const nsIntSize & aSize, const mozilla::image::ImageRegion & aRegion, uint32_t aWhichFrame, mozilla::gfx::SamplingFilter aSamplingFilter, const mozilla::Maybe<mozilla::SVGImageContext> & aSVGContext, uint32_t aFlags, float aOpacity) override; \

  NS_IMETHOD StartDecoding(uint32_t aFlags) override; \

  NS_IMETHOD_(bool) StartDecodingWithResult(uint32_t aFlags) override; \

  NS_IMETHOD RequestDecodeForSize(const nsIntSize & aSize, uint32_t aFlags) override; \

  NS_IMETHOD LockImage(void) override; \

  NS_IMETHOD UnlockImage(void) override; \

  NS_IMETHOD RequestDiscard(void) override; \

  NS_IMETHOD_(void) RequestRefresh(const mozilla::TimeStamp & aTime) override; \

  NS_IMETHOD GetAnimationMode(uint16_t *aAnimationMode) override; \

  NS_IMETHOD SetAnimationMode(uint16_t aAnimationMode) override; \

  NS_IMETHOD ResetAnimation(void) override; \

  NS_IMETHOD_(float) GetFrameIndex(uint32_t aWhichFrame) override; \

  NS_IMETHOD_(mozilla::image::Orientation) GetOrientation(void) override; \

  NS_IMETHOD_(int32_t) GetFirstFrameDelay(void) override; \

  NS_IMETHOD_(void) SetAnimationStartTime(const mozilla::TimeStamp & aTime) override; \

  NS_IMETHOD_(nsIntRect) GetImageSpaceInvalidationRect(const nsIntRect & aRect) override; \

  virtual already_AddRefed<imgIContainer> Unwrap(void) override; \

  NS_IMETHOD_(void) PropagateUseCounters(nsIDocument * aDocument) override; \

/* Use this macro when declaring the members of this interface when the

   class doesn't implement the interface. This is useful for forwarding. */

#define NS_DECL_NON_VIRTUAL_IMGICONTAINER \

  nsresult GetWidth(int32_t *aWidth); \

  nsresult GetHeight(int32_t *aHeight); \

  nsresult GetIntrinsicSize(nsSize * aIntrinsicSize); \

  nsresult GetIntrinsicRatio(nsSize * aIntrinsicRatio); \

  nsIntSize OptimalImageSizeForDest(const gfxSize & aDest, uint32_t aWhichFrame, mozilla::gfx::SamplingFilter aSamplingFilter, uint32_t aFlags); \

  using imgIContainer::GetType; \

  nsresult GetType(uint16_t *aType); \

  nsresult GetAnimated(bool *aAnimated); \

  nsresult_(already_AddRefed<mozilla::gfx::SourceSurface>) GetFrame(uint32_t aWhichFrame, uint32_t aFlags); \

  nsresult_(already_AddRefed<mozilla::gfx::SourceSurface>) GetFrameAtSize(const nsIntSize & aSize, uint32_t aWhichFrame, uint32_t aFlags); \

  nsresult_(bool) WillDrawOpaqueNow(void); \

  nsresult_(bool) IsImageContainerAvailable(mozilla::layers::LayerManager * aManager, uint32_t aFlags); \

  nsresult_(already_AddRefed<mozilla::layers::ImageContainer>) GetImageContainer(mozilla::layers::LayerManager * aManager, uint32_t aFlags); \

  nsresult_(mozilla::image::ImgDrawResult) GetImageContainerAtSize(mozilla::layers::LayerManager * aManager, const nsIntSize & aSize, const mozilla::Maybe<mozilla::SVGImageContext> & aSVGContext, uint32_t aFlags, mozilla::layers::ImageContainer * * aOutContainer); \

  nsresult_(bool) IsImageContainerAvailableAtSize(mozilla::layers::LayerManager * aManager, const nsIntSize & aSize, uint32_t aFlags); \

  nsresult_(mozilla::image::ImgDrawResult) Draw(gfxContext * aContext, const nsIntSize & aSize, const mozilla::image::ImageRegion & aRegion, uint32_t aWhichFrame, mozilla::gfx::SamplingFilter aSamplingFilter, const mozilla::Maybe<mozilla::SVGImageContext> & aSVGContext, uint32_t aFlags, float aOpacity); \

  nsresult StartDecoding(uint32_t aFlags); \

  nsresult_(bool) StartDecodingWithResult(uint32_t aFlags); \

  nsresult RequestDecodeForSize(const nsIntSize & aSize, uint32_t aFlags); \

  nsresult LockImage(void); \

  nsresult UnlockImage(void); \

  nsresult RequestDiscard(void); \

  nsresult_(void) RequestRefresh(const mozilla::TimeStamp & aTime); \

  nsresult GetAnimationMode(uint16_t *aAnimationMode); \

  nsresult SetAnimationMode(uint16_t aAnimationMode); \

  nsresult ResetAnimation(void); \

  nsresult_(float) GetFrameIndex(uint32_t aWhichFrame); \

  nsresult_(mozilla::image::Orientation) GetOrientation(void); \

  nsresult_(int32_t) GetFirstFrameDelay(void); \

  nsresult_(void) SetAnimationStartTime(const mozilla::TimeStamp & aTime); \

  nsresult_(nsIntRect) GetImageSpaceInvalidationRect(const nsIntRect & aRect); \

  already_AddRefed<imgIContainer> Unwrap(void); \

  nsresult_(void) PropagateUseCounters(nsIDocument * aDocument); \

/* Use this macro to declare functions that forward the behavior of this interface to another object. */

#define NS_FORWARD_IMGICONTAINER(_to) \

  NS_IMETHOD GetWidth(int32_t *aWidth) override { return _to GetWidth(aWidth); } \

  NS_IMETHOD GetHeight(int32_t *aHeight) override { return _to GetHeight(aHeight); } \

  NS_IMETHOD GetIntrinsicSize(nsSize * aIntrinsicSize) override { return _to GetIntrinsicSize(aIntrinsicSize); } \

  NS_IMETHOD GetIntrinsicRatio(nsSize * aIntrinsicRatio) override { return _to GetIntrinsicRatio(aIntrinsicRatio); } \

  virtual nsIntSize OptimalImageSizeForDest(const gfxSize & aDest, uint32_t aWhichFrame, mozilla::gfx::SamplingFilter aSamplingFilter, uint32_t aFlags) override { return _to OptimalImageSizeForDest(aDest, aWhichFrame, aSamplingFilter, aFlags); } \

  using imgIContainer::GetType; \

  NS_IMETHOD GetType(uint16_t *aType) override { return _to GetType(aType); } \

  NS_IMETHOD GetAnimated(bool *aAnimated) override { return _to GetAnimated(aAnimated); } \

  NS_IMETHOD_(already_AddRefed<mozilla::gfx::SourceSurface>) GetFrame(uint32_t aWhichFrame, uint32_t aFlags) override { return _to GetFrame(aWhichFrame, aFlags); } \

  NS_IMETHOD_(already_AddRefed<mozilla::gfx::SourceSurface>) GetFrameAtSize(const nsIntSize & aSize, uint32_t aWhichFrame, uint32_t aFlags) override { return _to GetFrameAtSize(aSize, aWhichFrame, aFlags); } \

  NS_IMETHOD_(bool) WillDrawOpaqueNow(void) override { return _to WillDrawOpaqueNow(); } \

  NS_IMETHOD_(bool) IsImageContainerAvailable(mozilla::layers::LayerManager * aManager, uint32_t aFlags) override { return _to IsImageContainerAvailable(aManager, aFlags); } \

  NS_IMETHOD_(already_AddRefed<mozilla::layers::ImageContainer>) GetImageContainer(mozilla::layers::LayerManager * aManager, uint32_t aFlags) override { return _to GetImageContainer(aManager, aFlags); } \

  NS_IMETHOD_(mozilla::image::ImgDrawResult) GetImageContainerAtSize(mozilla::layers::LayerManager * aManager, const nsIntSize & aSize, const mozilla::Maybe<mozilla::SVGImageContext> & aSVGContext, uint32_t aFlags, mozilla::layers::ImageContainer * * aOutContainer) override { return _to GetImageContainerAtSize(aManager, aSize, aSVGContext, aFlags, aOutContainer); } \

  NS_IMETHOD_(bool) IsImageContainerAvailableAtSize(mozilla::layers::LayerManager * aManager, const nsIntSize & aSize, uint32_t aFlags) override { return _to IsImageContainerAvailableAtSize(aManager, aSize, aFlags); } \

  NS_IMETHOD_(mozilla::image::ImgDrawResult) Draw(gfxContext * aContext, const nsIntSize & aSize, const mozilla::image::ImageRegion & aRegion, uint32_t aWhichFrame, mozilla::gfx::SamplingFilter aSamplingFilter, const mozilla::Maybe<mozilla::SVGImageContext> & aSVGContext, uint32_t aFlags, float aOpacity) override { return _to Draw(aContext, aSize, aRegion, aWhichFrame, aSamplingFilter, aSVGContext, aFlags, aOpacity); } \

  NS_IMETHOD StartDecoding(uint32_t aFlags) override { return _to StartDecoding(aFlags); } \

  NS_IMETHOD_(bool) StartDecodingWithResult(uint32_t aFlags) override { return _to StartDecodingWithResult(aFlags); } \

  NS_IMETHOD RequestDecodeForSize(const nsIntSize & aSize, uint32_t aFlags) override { return _to RequestDecodeForSize(aSize, aFlags); } \

  NS_IMETHOD LockImage(void) override { return _to LockImage(); } \

  NS_IMETHOD UnlockImage(void) override { return _to UnlockImage(); } \

  NS_IMETHOD RequestDiscard(void) override { return _to RequestDiscard(); } \

  NS_IMETHOD_(void) RequestRefresh(const mozilla::TimeStamp & aTime) override { return _to RequestRefresh(aTime); } \

  NS_IMETHOD GetAnimationMode(uint16_t *aAnimationMode) override { return _to GetAnimationMode(aAnimationMode); } \

  NS_IMETHOD SetAnimationMode(uint16_t aAnimationMode) override { return _to SetAnimationMode(aAnimationMode); } \

  NS_IMETHOD ResetAnimation(void) override { return _to ResetAnimation(); } \

  NS_IMETHOD_(float) GetFrameIndex(uint32_t aWhichFrame) override { return _to GetFrameIndex(aWhichFrame); } \

  NS_IMETHOD_(mozilla::image::Orientation) GetOrientation(void) override { return _to GetOrientation(); } \

  NS_IMETHOD_(int32_t) GetFirstFrameDelay(void) override { return _to GetFirstFrameDelay(); } \

  NS_IMETHOD_(void) SetAnimationStartTime(const mozilla::TimeStamp & aTime) override { return _to SetAnimationStartTime(aTime); } \

  NS_IMETHOD_(nsIntRect) GetImageSpaceInvalidationRect(const nsIntRect & aRect) override { return _to GetImageSpaceInvalidationRect(aRect); } \

  virtual already_AddRefed<imgIContainer> Unwrap(void) override { return _to Unwrap(); } \

  NS_IMETHOD_(void) PropagateUseCounters(nsIDocument * aDocument) override { return _to PropagateUseCounters(aDocument); } \

/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */

#define NS_FORWARD_SAFE_IMGICONTAINER(_to) \

  NS_IMETHOD GetWidth(int32_t *aWidth) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetWidth(aWidth); } \

  NS_IMETHOD GetHeight(int32_t *aHeight) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetHeight(aHeight); } \

  NS_IMETHOD GetIntrinsicSize(nsSize * aIntrinsicSize) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetIntrinsicSize(aIntrinsicSize); } \

  NS_IMETHOD GetIntrinsicRatio(nsSize * aIntrinsicRatio) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetIntrinsicRatio(aIntrinsicRatio); } \

  virtual nsIntSize OptimalImageSizeForDest(const gfxSize & aDest, uint32_t aWhichFrame, mozilla::gfx::SamplingFilter aSamplingFilter, uint32_t aFlags) override; \

  NS_IMETHOD GetType(uint16_t *aType) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetType(aType); } \

  NS_IMETHOD GetAnimated(bool *aAnimated) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetAnimated(aAnimated); } \

  NS_IMETHOD_(already_AddRefed<mozilla::gfx::SourceSurface>) GetFrame(uint32_t aWhichFrame, uint32_t aFlags) override; \

  NS_IMETHOD_(already_AddRefed<mozilla::gfx::SourceSurface>) GetFrameAtSize(const nsIntSize & aSize, uint32_t aWhichFrame, uint32_t aFlags) override; \

  NS_IMETHOD_(bool) WillDrawOpaqueNow(void) override; \

  NS_IMETHOD_(bool) IsImageContainerAvailable(mozilla::layers::LayerManager * aManager, uint32_t aFlags) override; \

  NS_IMETHOD_(already_AddRefed<mozilla::layers::ImageContainer>) GetImageContainer(mozilla::layers::LayerManager * aManager, uint32_t aFlags) override; \

  NS_IMETHOD_(mozilla::image::ImgDrawResult) GetImageContainerAtSize(mozilla::layers::LayerManager * aManager, const nsIntSize & aSize, const mozilla::Maybe<mozilla::SVGImageContext> & aSVGContext, uint32_t aFlags, mozilla::layers::ImageContainer * * aOutContainer) override; \

  NS_IMETHOD_(bool) IsImageContainerAvailableAtSize(mozilla::layers::LayerManager * aManager, const nsIntSize & aSize, uint32_t aFlags) override; \

  NS_IMETHOD_(mozilla::image::ImgDrawResult) Draw(gfxContext * aContext, const nsIntSize & aSize, const mozilla::image::ImageRegion & aRegion, uint32_t aWhichFrame, mozilla::gfx::SamplingFilter aSamplingFilter, const mozilla::Maybe<mozilla::SVGImageContext> & aSVGContext, uint32_t aFlags, float aOpacity) override; \

  NS_IMETHOD StartDecoding(uint32_t aFlags) override { return !_to ? NS_ERROR_NULL_POINTER : _to->StartDecoding(aFlags); } \

  NS_IMETHOD_(bool) StartDecodingWithResult(uint32_t aFlags) override; \

  NS_IMETHOD RequestDecodeForSize(const nsIntSize & aSize, uint32_t aFlags) override { return !_to ? NS_ERROR_NULL_POINTER : _to->RequestDecodeForSize(aSize, aFlags); } \

  NS_IMETHOD LockImage(void) override { return !_to ? NS_ERROR_NULL_POINTER : _to->LockImage(); } \

  NS_IMETHOD UnlockImage(void) override { return !_to ? NS_ERROR_NULL_POINTER : _to->UnlockImage(); } \

  NS_IMETHOD RequestDiscard(void) override { return !_to ? NS_ERROR_NULL_POINTER : _to->RequestDiscard(); } \

  NS_IMETHOD_(void) RequestRefresh(const mozilla::TimeStamp & aTime) override; \

  NS_IMETHOD GetAnimationMode(uint16_t *aAnimationMode) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetAnimationMode(aAnimationMode); } \

  NS_IMETHOD SetAnimationMode(uint16_t aAnimationMode) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetAnimationMode(aAnimationMode); } \

  NS_IMETHOD ResetAnimation(void) override { return !_to ? NS_ERROR_NULL_POINTER : _to->ResetAnimation(); } \

  NS_IMETHOD_(float) GetFrameIndex(uint32_t aWhichFrame) override; \

  NS_IMETHOD_(mozilla::image::Orientation) GetOrientation(void) override; \

  NS_IMETHOD_(int32_t) GetFirstFrameDelay(void) override; \

  NS_IMETHOD_(void) SetAnimationStartTime(const mozilla::TimeStamp & aTime) override; \

  NS_IMETHOD_(nsIntRect) GetImageSpaceInvalidationRect(const nsIntRect & aRect) override; \

  virtual already_AddRefed<imgIContainer> Unwrap(void) override; \

  NS_IMETHOD_(void) PropagateUseCounters(nsIDocument * aDocument) override; \

#endif /* __gen_imgIContainer_h__ */