gecko/gfx/thebes/gfxASurface.h

289 lines
9.0 KiB
C++

/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 4 -*-
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#ifndef GFX_ASURFACE_H
#define GFX_ASURFACE_H
#ifdef MOZ_DUMP_PAINTING
#define MOZ_DUMP_IMAGES
#endif
#include "mozilla/MemoryReporting.h"
#include "gfxTypes.h"
#include "mozilla/Scoped.h"
#include "nscore.h"
#ifdef MOZILLA_INTERNAL_API
#include "nsStringFwd.h"
#else
#include "nsStringAPI.h"
#endif
class gfxImageSurface;
struct nsIntPoint;
struct nsIntRect;
struct gfxRect;
struct gfxPoint;
struct nsIntSize;
template <typename T>
struct already_AddRefed;
/**
* A surface is something you can draw on. Instantiate a subclass of this
* abstract class, and use gfxContext to draw on this surface.
*/
class gfxASurface {
public:
#ifdef MOZILLA_INTERNAL_API
nsrefcnt AddRef(void);
nsrefcnt Release(void);
// These functions exist so that browsercomps can refcount a gfxASurface
virtual nsrefcnt AddRefExternal(void);
virtual nsrefcnt ReleaseExternal(void);
#else
virtual nsrefcnt AddRef(void);
virtual nsrefcnt Release(void);
#endif
public:
/** Wrap the given cairo surface and return a gfxASurface for it.
* This adds a reference to csurf (owned by the returned gfxASurface).
*/
static already_AddRefed<gfxASurface> Wrap(cairo_surface_t *csurf);
/*** this DOES NOT addref the surface */
cairo_surface_t *CairoSurface() {
return mSurface;
}
gfxSurfaceType GetType() const;
gfxContentType GetContentType() const;
void SetDeviceOffset(const gfxPoint& offset);
gfxPoint GetDeviceOffset() const;
virtual bool GetRotateForLandscape() { return false; }
void Flush() const;
void MarkDirty();
void MarkDirty(const gfxRect& r);
/* Printing backend functions */
virtual nsresult BeginPrinting(const nsAString& aTitle, const nsAString& aPrintToFileName);
virtual nsresult EndPrinting();
virtual nsresult AbortPrinting();
virtual nsresult BeginPage();
virtual nsresult EndPage();
void SetData(const cairo_user_data_key_t *key,
void *user_data,
thebes_destroy_func_t destroy);
void *GetData(const cairo_user_data_key_t *key);
virtual void Finish();
/**
* Create an offscreen surface that can be efficiently copied into
* this surface (at least if tiling is not involved).
* Returns null on error.
*/
virtual already_AddRefed<gfxASurface> CreateSimilarSurface(gfxContentType aType,
const nsIntSize& aSize);
/**
* Returns an image surface for this surface, or nullptr if not supported.
* This will not copy image data, just wraps an image surface around
* pixel data already available in memory.
*/
virtual already_AddRefed<gfxImageSurface> GetAsImageSurface();
/**
* Returns a read-only ARGB32 image surface for this surface. If this is an
* optimized surface this may require a copy.
* Returns null on error.
*/
virtual already_AddRefed<gfxImageSurface> GetAsReadableARGB32ImageSurface();
/**
* Creates a new ARGB32 image surface with the same contents as this surface.
* Returns null on error.
*/
already_AddRefed<gfxImageSurface> CopyToARGB32ImageSurface();
int CairoStatus();
/* Make sure that the given dimensions don't overflow a 32-bit signed int
* using 4 bytes per pixel; optionally, make sure that either dimension
* doesn't exceed the given limit.
*/
static bool CheckSurfaceSize(const nsIntSize& sz, int32_t limit = 0);
/* Provide a stride value that will respect all alignment requirements of
* the accelerated image-rendering code.
*/
static int32_t FormatStrideForWidth(gfxImageFormat format, int32_t width);
/* Return the default set of context flags for this surface; these are
* hints to the context about any special rendering considerations. See
* gfxContext::SetFlag for documentation.
*/
virtual int32_t GetDefaultContextFlags() const { return 0; }
static gfxContentType ContentFromFormat(gfxImageFormat format);
void SetSubpixelAntialiasingEnabled(bool aEnabled);
bool GetSubpixelAntialiasingEnabled();
/**
* Record number of bytes for given surface type. Use positive bytes
* for allocations and negative bytes for deallocations.
*/
static void RecordMemoryUsedForSurfaceType(gfxSurfaceType aType,
int32_t aBytes);
/**
* Same as above, but use current surface type as returned by GetType().
* The bytes will be accumulated until RecordMemoryFreed is called,
* in which case the value that was recorded for this surface will
* be freed.
*/
void RecordMemoryUsed(int32_t aBytes);
void RecordMemoryFreed();
virtual int32_t KnownMemoryUsed() { return mBytesRecorded; }
virtual size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
// gfxASurface has many sub-classes. This method indicates if a sub-class
// is capable of measuring its own size accurately. If not, the caller
// must fall back to a computed size. (Note that gfxASurface can actually
// measure itself, but we must |return false| here because it serves as the
// (conservative) default for all the sub-classes. Therefore, this
// function should only be called on a |gfxASurface*| that actually points
// to a sub-class of gfxASurface.)
virtual bool SizeOfIsMeasured() const { return false; }
/**
* Where does this surface's memory live? By default, we say it's in this
* process's heap.
*/
virtual gfxMemoryLocation GetMemoryLocation() const;
static int32_t BytePerPixelFromFormat(gfxImageFormat format);
virtual const nsIntSize GetSize() const;
/**
* Debug functions to encode the current image as a PNG and export it.
*/
/**
* Writes a binary PNG file.
*/
void WriteAsPNG(const char* aFile);
/**
* Write as a PNG encoded Data URL to a file.
*/
void DumpAsDataURL(FILE* aOutput = stdout);
/**
* Write as a PNG encoded Data URL to stdout.
*/
void PrintAsDataURL();
/**
* Copy a PNG encoded Data URL to the clipboard.
*/
void CopyAsDataURL();
void WriteAsPNG_internal(FILE* aFile, bool aBinary);
void SetOpaqueRect(const gfxRect& aRect);
const gfxRect& GetOpaqueRect() {
if (!!mOpaqueRect)
return *mOpaqueRect;
return GetEmptyOpaqueRect();
}
/**
* Move the pixels in |aSourceRect| to |aDestTopLeft|. Like with
* memmove(), |aSourceRect| and the rectangle defined by
* |aDestTopLeft| are allowed to overlap, and the effect is
* equivalent to copying |aSourceRect| to a scratch surface and
* then back to |aDestTopLeft|.
*
* |aSourceRect| and the destination rectangle defined by
* |aDestTopLeft| are clipped to this surface's bounds.
*/
virtual void MovePixels(const nsIntRect& aSourceRect,
const nsIntPoint& aDestTopLeft);
/**
* Mark the surface as being allowed/not allowed to be used as a source.
*/
void SetAllowUseAsSource(bool aAllow) { mAllowUseAsSource = aAllow; }
bool GetAllowUseAsSource() { return mAllowUseAsSource; }
static uint8_t BytesPerPixel(gfxImageFormat aImageFormat);
protected:
gfxASurface();
static gfxASurface* GetSurfaceWrapper(cairo_surface_t *csurf);
static void SetSurfaceWrapper(cairo_surface_t *csurf, gfxASurface *asurf);
/**
* An implementation of MovePixels that assumes the backend can
* internally handle this operation and doesn't allocate any
* temporary surfaces.
*/
void FastMovePixels(const nsIntRect& aSourceRect,
const nsIntPoint& aDestTopLeft);
// NB: Init() *must* be called from within subclass's
// constructors. It's unsafe to call it after the ctor finishes;
// leaks and use-after-frees are possible.
void Init(cairo_surface_t *surface, bool existingSurface = false);
// out-of-line helper to allow GetOpaqueRect() to be inlined
// without including gfxRect.h here
static const gfxRect& GetEmptyOpaqueRect();
virtual ~gfxASurface();
cairo_surface_t *mSurface;
mozilla::ScopedDeletePtr<gfxRect> mOpaqueRect;
private:
static void SurfaceDestroyFunc(void *data);
int32_t mFloatingRefs;
int32_t mBytesRecorded;
protected:
bool mSurfaceValid;
bool mAllowUseAsSource;
};
/**
* An Unknown surface; used to wrap unknown cairo_surface_t returns from cairo
*/
class gfxUnknownSurface : public gfxASurface {
public:
gfxUnknownSurface(cairo_surface_t *surf) {
Init(surf, true);
}
virtual ~gfxUnknownSurface() { }
};
#endif /* GFX_ASURFACE_H */