Source code

Revision control

Other Tools

/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*-
* 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
#include "mozilla/MemoryReporting.h"
#include "mozilla/UniquePtr.h"
#include "gfxPoint.h"
#include "gfxRect.h"
#include "gfxTypes.h"
#include "nscore.h"
#include "nsSize.h"
#include "mozilla/gfx/Rect.h"
#include "nsStringFwd.h"
class gfxImageSurface;
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);
#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,
const mozilla::gfx::IntSize& aSize = mozilla::gfx::IntSize(-1, -1));
/*** 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;
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 mozilla::gfx::IntSize& 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();
/**
* Creates a new ARGB32 image surface with the same contents as this surface.
* Returns null on error.
*/
already_AddRefed<gfxImageSurface> CopyToARGB32ImageSurface();
int CairoStatus();
static gfxContentType ContentFromFormat(gfxImageFormat format);
/**
* 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; }
static int32_t BytePerPixelFromFormat(gfxImageFormat format);
virtual const mozilla::gfx::IntSize GetSize() const;
virtual mozilla::gfx::SurfaceFormat GetSurfaceFormat() const;
void SetOpaqueRect(const gfxRect& aRect);
const gfxRect& GetOpaqueRect() {
if (!!mOpaqueRect) return *mOpaqueRect;
return GetEmptyOpaqueRect();
}
static uint8_t BytesPerPixel(gfxImageFormat aImageFormat);
protected:
gfxASurface();
static gfxASurface* GetSurfaceWrapper(cairo_surface_t* csurf);
static void SetSurfaceWrapper(cairo_surface_t* csurf, gfxASurface* asurf);
// 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::UniquePtr<gfxRect> mOpaqueRect;
private:
static void SurfaceDestroyFunc(void* data);
int32_t mFloatingRefs;
int32_t mBytesRecorded;
protected:
bool mSurfaceValid;
};
/**
* An Unknown surface; used to wrap unknown cairo_surface_t returns from cairo
*/
class gfxUnknownSurface : public gfxASurface {
public:
gfxUnknownSurface(cairo_surface_t* surf, const mozilla::gfx::IntSize& aSize)
: mSize(aSize) {
Init(surf, true);
}
virtual ~gfxUnknownSurface() = default;
const mozilla::gfx::IntSize GetSize() const override { return mSize; }
private:
mozilla::gfx::IntSize mSize;
};
#endif /* GFX_ASURFACE_H */