#ifndef Image_h
#define Image_h
#include "Color.h"
#include "FloatRect.h"
#include "FloatSize.h"
#include "GraphicsTypes.h"
#include "ImageOrientation.h"
#include "NativeImagePtr.h"
#include <wtf/Optional.h>
#include <wtf/PassRefPtr.h>
#include <wtf/RefCounted.h>
#include <wtf/RefPtr.h>
#include <wtf/RetainPtr.h>
#include <wtf/TypeCasts.h>
#include <wtf/text/WTFString.h>
#if USE(APPKIT)
OBJC_CLASS NSImage;
#endif
#if USE(CG)
struct CGContext;
#endif
#if PLATFORM(WIN)
typedef struct tagSIZE SIZE;
typedef SIZE* LPSIZE;
typedef struct HBITMAP__ *HBITMAP;
#endif
#if PLATFORM(GTK)
typedef struct _GdkPixbuf GdkPixbuf;
#endif
namespace WebCore {
class AffineTransform;
class FloatPoint;
class FloatSize;
class GraphicsContext;
class SharedBuffer;
struct Length;
class ImageObserver;
class Image : public RefCounted<Image> {
friend class GraphicsContext;
public:
virtual ~Image();
static PassRefPtr<Image> create(ImageObserver* = nullptr);
WEBCORE_EXPORT static PassRefPtr<Image> loadPlatformResource(const char* name);
WEBCORE_EXPORT static bool supportsType(const String&);
virtual bool isBitmapImage() const { return false; }
virtual bool isGeneratedImage() const { return false; }
virtual bool isCrossfadeGeneratedImage() const { return false; }
virtual bool isNamedImageGeneratedImage() const { return false; }
virtual bool isGradientImage() const { return false; }
virtual bool isSVGImage() const { return false; }
virtual bool isPDFDocumentImage() const { return false; }
virtual bool currentFrameKnownToBeOpaque() = 0;
virtual bool isAnimated() const { return false; }
virtual bool hasSingleSecurityOrigin() const { return false; }
WEBCORE_EXPORT static Image* nullImage();
bool isNull() const { return size().isEmpty(); }
virtual void setContainerSize(const FloatSize&) { }
virtual bool usesContainerSize() const { return false; }
virtual bool hasRelativeWidth() const { return false; }
virtual bool hasRelativeHeight() const { return false; }
virtual void computeIntrinsicDimensions(Length& intrinsicWidth, Length& intrinsicHeight, FloatSize& intrinsicRatio);
virtual FloatSize size() const = 0;
FloatRect rect() const { return FloatRect(FloatPoint(), size()); }
float width() const { return size().width(); }
float height() const { return size().height(); }
virtual Optional<IntPoint> hotSpot() const { return Nullopt; }
#if PLATFORM(IOS)
virtual FloatSize originalSize() const { return size(); }
#endif
WEBCORE_EXPORT bool setData(RefPtr<SharedBuffer>&& data, bool allDataReceived);
virtual bool dataChanged(bool ) { return false; }
virtual String filenameExtension() const { return String(); }
virtual void destroyDecodedData(bool destroyAll = true) = 0;
SharedBuffer* data() { return m_encodedImageData.get(); }
const SharedBuffer* data() const { return m_encodedImageData.get(); }
enum CatchUpAnimation { DoNotCatchUp, CatchUp };
virtual void startAnimation(CatchUpAnimation = CatchUp) { }
virtual void stopAnimation() {}
virtual void resetAnimation() {}
ImageObserver* imageObserver() const { return m_imageObserver; }
void setImageObserver(ImageObserver* observer) { m_imageObserver = observer; }
enum TileRule { StretchTile, RoundTile, SpaceTile, RepeatTile };
virtual NativeImagePtr nativeImageForCurrentFrame() { return nullptr; }
virtual ImageOrientation orientationForCurrentFrame() { return ImageOrientation(); }
#if USE(APPKIT)
virtual NSImage* getNSImage() { return nullptr; }
#endif
#if PLATFORM(COCOA)
virtual CFDataRef getTIFFRepresentation() { return nullptr; }
#endif
#if USE(CG)
virtual CGImageRef getCGImageRef() { return nullptr; }
virtual CGImageRef getFirstCGImageRefOfSize(const IntSize&) { return nullptr; }
virtual RetainPtr<CFArrayRef> getCGImageArray() { return nullptr; }
#endif
#if PLATFORM(WIN)
virtual bool getHBITMAP(HBITMAP) { return false; }
virtual bool getHBITMAPOfSize(HBITMAP, const IntSize*) { return false; }
#endif
#if PLATFORM(GTK)
virtual GdkPixbuf* getGdkPixbuf() { return nullptr; }
#endif
#if PLATFORM(EFL)
virtual Evas_Object* getEvasObject(Evas*) { return nullptr; }
#endif
virtual void drawPattern(GraphicsContext&, const FloatRect& srcRect, const AffineTransform& patternTransform,
const FloatPoint& phase, const FloatSize& spacing, CompositeOperator, const FloatRect& destRect, BlendMode = BlendModeNormal);
#if ENABLE(IMAGE_DECODER_DOWN_SAMPLING)
FloatRect adjustSourceRectForDownSampling(const FloatRect& srcRect, const IntSize& scaledSize) const;
#endif
#if !ASSERT_DISABLED
virtual bool notSolidColor() { return true; }
#endif
virtual void dump(TextStream&) const;
protected:
Image(ImageObserver* = nullptr);
static void fillWithSolidColor(GraphicsContext&, const FloatRect& dstRect, const Color&, CompositeOperator);
#if PLATFORM(WIN)
virtual void drawFrameMatchingSourceSize(GraphicsContext&, const FloatRect& dstRect, const IntSize& srcSize, CompositeOperator) { }
#endif
virtual void draw(GraphicsContext&, const FloatRect& dstRect, const FloatRect& srcRect, CompositeOperator, BlendMode, ImageOrientationDescription) = 0;
void drawTiled(GraphicsContext&, const FloatRect& dstRect, const FloatPoint& srcPoint, const FloatSize& tileSize, const FloatSize& spacing, CompositeOperator, BlendMode);
void drawTiled(GraphicsContext&, const FloatRect& dstRect, const FloatRect& srcRect, const FloatSize& tileScaleFactor, TileRule hRule, TileRule vRule, CompositeOperator);
virtual Color singlePixelSolidColor() { return Color(); }
private:
RefPtr<SharedBuffer> m_encodedImageData;
ImageObserver* m_imageObserver;
};
TextStream& operator<<(TextStream&, const Image&);
}
#define SPECIALIZE_TYPE_TRAITS_IMAGE(ToClassName) \
SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::ToClassName) \
static bool isType(const WebCore::Image& image) { return image.is##ToClassName(); } \
SPECIALIZE_TYPE_TRAITS_END()
#endif // Image_h