class SK_API SkColorFilter : public SkFlattenable {
public:
+ SK_DECLARE_INST_COUNT(SkColorFilter)
+
/**
* If the filter can be represented by a source color plus Mode, this
* returns true, and sets (if not NULL) the color and mode appropriately.
*/
class SkColorTable : public SkFlattenable {
public:
+ SK_DECLARE_INST_COUNT(SkColorTable)
+
/** Makes a deep copy of colors.
*/
SkColorTable(const SkColorTable& src);
*/
class SK_API SkDrawLooper : public SkFlattenable {
public:
+ SK_DECLARE_INST_COUNT(SkDrawLooper)
+
/**
* Called right before something is being drawn. This will be followed by
* calls to next() until next() returns false.
*/
class SK_API SkImageFilter : public SkFlattenable {
public:
+ SK_DECLARE_INST_COUNT(SkImageFilter)
+
class Proxy {
public:
virtual ~Proxy() {};
*/
class SkMaskFilter : public SkFlattenable {
public:
+ SK_DECLARE_INST_COUNT(SkMaskFilter)
+
SkMaskFilter() {}
/** Returns the format of the resulting mask that this subclass will return
*/
class SK_API SkPathEffect : public SkFlattenable {
public:
+ SK_DECLARE_INST_COUNT(SkPathEffect)
+
SkPathEffect() {}
/**
*/
class SK_API SkPixelRef : public SkFlattenable {
public:
+ SK_DECLARE_INST_COUNT(SkPixelRef)
+
explicit SkPixelRef(SkBaseMutex* mutex = NULL);
/** Return the pixel memory returned from lockPixels, or null if the
class SkRasterizer : public SkFlattenable {
public:
+ SK_DECLARE_INST_COUNT(SkRasterizer)
+
SkRasterizer() {}
/** Turn the path into a mask, respecting the specified local->device matrix.
*/
class SK_API SkShader : public SkFlattenable {
public:
- SkShader();
+ SK_DECLARE_INST_COUNT(SkShader)
+
+ SkShader();
virtual ~SkShader();
/**
class SkShape : public SkFlattenable {
public:
+ SK_DECLARE_INST_COUNT(SkShape)
+
SkShape();
virtual ~SkShape();
class SkUnitMapper : public SkFlattenable {
public:
+ SK_DECLARE_INST_COUNT(SkUnitMapper)
+
SkUnitMapper() {}
/** Given a value in [0..0xFFFF], return a value in the same range.
protected:
SkUnitMapper(SkFlattenableReadBuffer& rb) : SkFlattenable(rb) {}
+
+private:
+ typedef SkFlattenable INHERITED;
};
#endif
*/
class SK_API SkXfermode : public SkFlattenable {
public:
+ SK_DECLARE_INST_COUNT(SkXfermode)
+
SkXfermode() {}
virtual void xfer32(SkPMColor dst[], const SkPMColor src[], int count,
class SK_API SkLayerDrawLooper : public SkDrawLooper {
public:
+ SK_DECLARE_INST_COUNT(SkLayerDrawLooper)
+
SkLayerDrawLooper();
virtual ~SkLayerDrawLooper();
#include "SkShader.h"
#include "SkUnPreMultiply.h"
+SK_DEFINE_INST_COUNT(SkColorFilter)
+
bool SkColorFilter::asColorMode(SkColor* color, SkXfermode::Mode* mode) {
return false;
}
#include "SkStream.h"
#include "SkTemplates.h"
+SK_DEFINE_INST_COUNT(SkColorTable)
+
SkColorTable::SkColorTable(int count)
: f16BitCache(NULL), fFlags(0)
{
#include "SkDraw.h"
#include "SkRasterClip.h"
+SK_DEFINE_INST_COUNT(SkMaskFilter)
+
bool SkMaskFilter::filterMask(SkMask*, const SkMask&, const SkMatrix&,
SkIPoint*) {
return false;
//////////// Move these to their own file soon.
+SK_DEFINE_INST_COUNT(SkImageFilter)
+
bool SkImageFilter::filterImage(Proxy* proxy, const SkBitmap& src,
const SkMatrix& ctm,
SkBitmap* result, SkIPoint* loc) {
//////
+SK_DEFINE_INST_COUNT(SkDrawLooper)
+
bool SkDrawLooper::canComputeFastBounds(const SkPaint& paint) {
SkCanvas canvas;
///////////////////////////////////////////////////////////////////////////////
+SK_DEFINE_INST_COUNT(SkPathEffect)
+
void SkPathEffect::computeFastBounds(SkRect* dst, const SkRect& src) {
*dst = src;
}
#include "SkFlattenable.h"
#include "SkThread.h"
+SK_DEFINE_INST_COUNT(SkPixelRef)
+
// must be a power-of-2. undef to just use 1 mutex
#define PIXELREF_MUTEX_RING_COUNT 32
#include "SkMaskFilter.h"
#include "SkPath.h"
+SK_DEFINE_INST_COUNT(SkRasterizer)
+
bool SkRasterizer::rasterize(const SkPath& fillPath, const SkMatrix& matrix,
const SkIRect* clipBounds, SkMaskFilter* filter,
SkMask* mask, SkMask::CreateMode mode) {
#include "SkPaint.h"
#include "SkMallocPixelRef.h"
+SK_DEFINE_INST_COUNT(SkShader)
+
SkShader::SkShader() : fLocalMatrix(NULL) {
SkDEBUGCODE(fInSession = false;)
}
#include "SkShape.h"
#include "SkMatrix.h"
+SK_DEFINE_INST_COUNT(SkShape)
+
#if 0
static int gShapeCounter;
static void inc_shape(const SkShape* s) {
#include "SkXfermode.h"
#include "SkColorPriv.h"
+SK_DEFINE_INST_COUNT(SkXfermode)
+
#define SkAlphaMulAlpha(a, b) SkMulDiv255Round(a, b)
#if 0
#include "SkPaint.h"
#include "SkUnPreMultiply.h"
+SK_DEFINE_INST_COUNT(SkLayerDrawLooper)
+
SkLayerDrawLooper::LayerInfo::LayerInfo() {
fFlagsMask = 0; // ignore our paint flags
fPaintBits = 0; // ignore our paint fields
class SkLight : public SkFlattenable {
public:
+ SK_DECLARE_INST_COUNT(SkLight)
+
enum LightType {
kDistant_LightType,
kPoint_LightType,
typedef SkFlattenable INHERITED;
};
+SK_DEFINE_INST_COUNT(SkLight)
+
class SkDistantLight : public SkLight {
public:
SkDistantLight(const SkPoint3& direction) : fDirection(direction) {
*/
#include "SkUnitMappers.h"
+SK_DEFINE_INST_COUNT(SkUnitMapper)
+
SkDiscreteMapper::SkDiscreteMapper(int segments) {
if (segments < 2) {
fSegments = 0;